SDSS WAYF patch for multi-federation support
[java-idp.git] / src / edu / internet2 / middleware / shibboleth / wayf / HandlerConfig.java
1 /*
2  * Copyright [2005] [University Corporation for Advanced Internet Development, Inc.]
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package edu.internet2.middleware.shibboleth.wayf;
18
19 import java.util.HashSet;
20
21 import org.apache.log4j.Logger;
22 import org.w3c.dom.Element;
23 import org.w3c.dom.NodeList;
24
25 import edu.internet2.middleware.shibboleth.common.ShibbolethConfigurationException;
26
27 /**
28  * Class used by the DiscoveryServiceHandler to handle run time behaviour 
29  * 
30  * @author Walter Hoehn wassa@columbia.edu
31  */
32
33 public class HandlerConfig {
34
35         private static final Logger log = Logger.getLogger(HandlerConfig.class.getName());
36         public final static String configNameSpace = "urn:mace:shibboleth:wayf:config:1.0"; 
37
38         private final HashSet ignoredForMatch;
39         private final int cacheExpiration;
40         private final String cacheDomain;
41         private final String jspFile;
42         private final String errorJspFile;
43         private final boolean provideListOfLists;  // defaults false below
44         private final boolean provideList;         // defaults true below
45         private final boolean lookupSp;            // defaults true below 
46         private final int handleCookie;
47         //
48         // hacked enum
49         //
50         public final static int ALWAYS_FOLLOW_COOKIE = 9;
51         public final static int FOLLOW_SINGLE_COOKIE = 10;
52         public final static int NEVER_FOLLOW_COOKIE = 11;
53         public final static int CLEAR_COOKIE = 12;
54
55         public HandlerConfig() {
56                 //
57                 // 'Sensible' default values
58                 //
59                 cacheExpiration = 604800;
60                 cacheDomain = "";
61                 jspFile = "/wayf.jsp";
62                 errorJspFile = "/wayfError.jsp";
63                 provideList = true;
64                 provideListOfLists = false;
65                 lookupSp = true;
66                 handleCookie = NEVER_FOLLOW_COOKIE;
67                 ignoredForMatch = new HashSet();        
68         }
69         
70         
71         private String getValue(Element element, String what) throws ShibbolethConfigurationException
72         {
73                 NodeList list = element.getElementsByTagName(what);
74             
75             if (list.getLength() > 0) {
76                 if (list.getLength() > 1) {
77                         throw new ShibbolethConfigurationException("More than one <" + what + "/> element");
78                 }
79                         
80                 return list.item(0).getTextContent();
81             }
82             return null;
83         }
84         
85         /**
86          * 
87          * Parse the Supplied XML element into a new WayfConfig Object
88          * 
89          */
90         
91         public HandlerConfig(Element config, HandlerConfig defaultValue) throws ShibbolethConfigurationException {
92             
93             log.debug("Loading global configuration properties.");
94
95             String attribute   = config.getAttribute("cacheDomain");
96             if ((attribute != null) && (attribute != "")) {
97                 cacheDomain = attribute;
98             } else {
99                 cacheDomain = defaultValue.cacheDomain;
100             }
101                 
102             attribute = config.getAttribute("cacheExpiration");
103             if ((attribute != null) && (attribute != "")) {
104                 
105                 try {
106
107                         cacheExpiration = Integer.parseInt(attribute);
108                 } catch (NumberFormatException ex) {
109                         
110                                 log.error("Invalid CacheExpiration value - " + attribute);
111                         throw new ShibbolethConfigurationException("Invalid CacheExpiration value - " + attribute, ex);
112                         
113                 }
114             } else {
115                 cacheExpiration = defaultValue.cacheExpiration;
116             }
117
118             NodeList list = config.getElementsByTagName("SearchIgnore");
119             
120             if (list.getLength() == 0) {
121                 
122                 ignoredForMatch = defaultValue.ignoredForMatch;
123
124             } else { 
125                 
126                 ignoredForMatch = new HashSet();        
127                     
128                 for (int i = 0; i < list.getLength(); i++ ) {
129                         
130                         NodeList inner = ((Element) list.item(i)).getElementsByTagName("IgnoreText");
131                         
132                         for(int j = 0; j < inner.getLength(); j++) {
133                                 
134                                 addIgnoredForMatch(inner.item(j).getTextContent());
135                         }
136                     }
137             }
138
139             attribute = config.getAttribute("jspFile");
140                 if (attribute != null && !attribute.equals("")) {
141                         jspFile = attribute;
142                 } else {
143                         jspFile = defaultValue.jspFile;
144                 }
145                 
146                 attribute = config.getAttribute("errorJspFile");
147                 if (attribute != null && !attribute.equals("")) {
148                         errorJspFile = attribute;
149                 } else {
150                         errorJspFile = defaultValue.errorJspFile;
151                 }
152                 
153                 attribute = ((Element) config).getAttribute("provideList");
154                 if (attribute != null && !attribute.equals("")) {
155                         provideList = Boolean.valueOf(attribute).booleanValue();
156                 } else { 
157                         provideList = defaultValue.provideList;
158                 }
159
160                 attribute = ((Element) config).getAttribute("provideListOfList");
161                 if (attribute != null && !attribute.equals("")) {
162                         provideListOfLists = Boolean.valueOf(attribute).booleanValue();
163                 } else {
164                         provideListOfLists = defaultValue.provideListOfLists;
165                 }
166                 
167                 attribute = ((Element) config).getAttribute("showUnusableIdPs");
168                 if (attribute != null && !attribute.equals("")) {
169                         lookupSp = !Boolean.valueOf(attribute).booleanValue();
170                 } else {
171                         lookupSp = defaultValue.lookupSp;
172                 }
173
174                 attribute = ((Element) config).getAttribute("handleCookie");
175                 if (attribute == null || attribute.equals("")) {
176                         handleCookie = defaultValue.handleCookie;
177                 } else if (attribute.equalsIgnoreCase("alwaysfollow")) {
178                         handleCookie = ALWAYS_FOLLOW_COOKIE;
179                 } else if (attribute.equalsIgnoreCase("followsingle")) {
180                         handleCookie = FOLLOW_SINGLE_COOKIE;
181                 } else if (attribute.equalsIgnoreCase("neverfollow")) {
182                         handleCookie = NEVER_FOLLOW_COOKIE;
183                 } else if (attribute.equalsIgnoreCase("clearcookie")) {
184                         handleCookie = CLEAR_COOKIE;
185                 } else {
186                         
187                         log.error("Invalid value " + attribute + " to HandleCookie");
188                         throw new ShibbolethConfigurationException("Invalid value " + attribute + " to HandleCookie");
189                 }       
190         }
191         
192
193         /**
194          * Determines if a particular string token should be used for matching when a user searches for origins.
195          * 
196          * @param str
197          *            The string to lookup
198          */
199         public boolean isIgnoredForMatch(String str) {
200
201                 if (ignoredForMatch.contains(str.toLowerCase())) {
202                         return true;
203                 } else {
204                         return false;
205                 }
206         }
207
208         /**
209          * Sets the tokens that should be ignored when a user searches for an origin site.
210          * 
211          * @param s
212          *            The ignored tokens are passed as a single string, each separated by whitespace
213          */
214         private void addIgnoredForMatch(String s) {
215
216                 ignoredForMatch.add(s.toLowerCase());
217         }
218
219         /**
220          * Returns the cacheDomain.
221          * 
222          * @return String
223          */
224         public String getCacheDomain() {
225
226                 return cacheDomain;
227         }
228
229         /**
230          * Returns the cacheExpiration.
231          * 
232          * @return int
233          */
234         public int getCacheExpiration() {
235
236                 return cacheExpiration;
237         }
238         
239         public String getJspFile() {
240                 return jspFile;
241         }
242         
243         public String getErrorJspFile() {
244                 return errorJspFile;
245         }
246         
247         public boolean getProvideListOfLists() {
248                 return provideListOfLists;
249         }
250         
251         public boolean getProvideList() {
252                 return provideList;
253         }
254         
255         public boolean getLookupSp() {  
256                 return lookupSp;  
257         }
258         
259         public int getHandleCookie() {  
260                 return handleCookie;  
261         }
262 }