remove javolution
[java-idp.git] / src / edu / internet2 / middleware / shibboleth / idp / authn / LoginContext.java
1 /*
2  * Copyright [2006] [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.idp.authn;
18
19
20 import java.util.Map;
21 import java.util.concurrent.ConcurrentHashMap;
22
23 import org.joda.time.DateTime;
24
25
26 /**
27  * Login context created by a profile handler and interpreted
28  * by the authentication package.
29  * 
30  * Two properties are tracked by default:
31  * 
32  * <code>forceAuth</code> - Should user authentiation be forced.
33  * <code>passiveAuth</code> - Should user authentication not control the UI.
34  * 
35  * A Map&lt;String, Object&gt; is provided to store other properties.
36  * Alternatively, a profile handler may create a subclass of LoginContext with
37  * extra fields.
38  *
39  * LoginContexts should be created by a profile handler when authentication is needed.
40  * Once control has returned to the profile handler, it should remove the LoginContext
41  * from the HttpSession.
42  *
43  * The {@link AuthenticationManager} or an {@link AuthenticationHandler} should set the
44  * {@link LoginContext#setAuthenticationAttempted()}, {@link LoginContext#setAuthnOK(boolean)},
45  * {@link LoginContext#setAuthnFailure(String)}, {@link LoginContext#{setAuthenticationDuration(long)}
46  * {@link LoginContext#setAuthenticationInstant(DateTime)} appropriately.
47  *
48  */
49 public class LoginContext {
50     
51     /** the key in a HttpSession where login contexts are stored */
52     public static final String LOGIN_CONTEXT_KEY = "shib2.logincontext";
53     
54     
55     /** Should user authentication be forced */
56     protected boolean forceAuth = false;
57     
58     /** Must authentication not interact with the UI */
59     protected boolean passiveAuth = false;
60     
61     /** a catch-all map for other properties */
62     protected Map<String, Object> propsMap = new ConcurrentHashMap<String, Object>();;
63     
64     /** The ProfileHandler URL */
65     protected String profileHandlerURL;
66     
67     /** The AuthenticationManager's URL */
68     protected String authnManagerURL;
69     
70     /** has authentication been attempted yet */
71     protected boolean authnAttempted = false;
72     
73     /** The id of the authenticated user */ 
74     protected String userID;
75
76     /** Did authentication succceed? */
77     protected boolean authenticationOK;
78     
79     /** Optional failure message  */
80     protected String authnFailureMessage;
81
82     /** The instant of authentication */
83     protected DateTime authnInstant;
84     
85     /** The duration of authentication */
86     protected long authnDuration;
87     
88     /** The method used to authenticate the user */
89     protected String authnMethod;        
90     
91     /** The session id */
92     protected String sessionID;
93     
94     
95     /** Creates a new instance of LoginContext */
96     public LoginContext() {
97     }
98     
99     
100     /**
101      * Creates a new instance of LoginContext
102      *
103      * @param forceAuth if the authentication manager must reauth the user.
104      * @param passiveAuth if the authentication manager must not interact with the users UI. 
105      */
106     public LoginContext(boolean forceAuth, boolean passiveAuth) {
107         
108         forceAuth = forceAuth;
109         passiveAuth = passiveAuth;
110     }    
111     
112     
113     /**
114      * Returns if authentication must be forced.
115      *
116      * @return <code>true</code> if the authentication manager must reauth the user.
117      */
118     public boolean getForceAuth() {
119         return forceAuth;
120     }
121     
122     
123     /**
124      * Returns if authentication must be passive.
125      * 
126      * @return <code>true</code> if the authentication manager must not interact with the users UI.
127      */
128     public boolean getPassiveAuth() {
129         return passiveAuth;
130     }
131     
132     
133     /**
134      * Sets if authentication must be forced.
135      *
136      * @param forceAuth if the authentication manager must reauth the user.
137      */
138     public void setForceAuth(boolean forceAuth) {
139         this.forceAuth = forceAuth;
140     }
141     
142     
143     /**
144      * Sets if authentication must be passive.
145      * 
146      * @param passiveAuth if the authentication manager must not interact with the users UI.
147      */
148     public void setPassiveAuth(boolean passiveAuth) {
149         this.passiveAuth = passiveAuth;
150     }
151     
152     
153     /**
154      * Get an optional property object.
155      * 
156      * @param key The key in the properites Map.
157      * 
158      * @return The object, or <code>null</code> is no object exists for the key.
159      */
160     public Object getProperty(String key) {
161         return propsMap.get(key);
162     }
163     
164     
165     /**
166      * Sets an optional property object.
167      * 
168      * If an object is already associated with key, it will be overwritten.
169      * 
170      * @param key The key to set.
171      * @param obj The object to associate with key.
172      */
173     public void setProperty(String key, final Object obj) {
174         propsMap.put(key, obj);
175     }
176  
177     
178     /**
179      * Sets if authentication succeeded.
180      * 
181      * @param authnOK if authentication succeeded;
182      */
183     public void setAuthenticationOK(boolean authnOK) {
184         this.authenticationOK = authnOK;
185     }
186     
187     
188     /**
189      * Returns if authentication succeeded.
190      * 
191      * @return <code>true</code> is the user was successfully authenticated.
192      */
193     public boolean getAuthenticationOK() {
194         return authenticationOK;
195     }
196     
197     
198     /** Sets the optional authentication failure message.
199      * 
200      * @param failureMessage A description of why authN failed.
201      */ 
202     public void setAuthenticationFailureMessage(String failureMessage) {
203         authnFailureMessage = failureMessage;
204     }
205     
206     
207     /**
208      * Returns the optional authentication failure message.
209      * 
210      * @return The failure message, or <code>null</code> is none was set.
211      */
212     public String getAuthenticationFailureMessage() {
213         return authnFailureMessage;
214     }
215     
216     
217     /**
218      * Set if authentication has been attempted.
219      *
220      * This method should be called by an {@link AuthenticationHandler} 
221      * while processing a request.
222      */
223     public void setAuthenticationAttempted() {
224         authnAttempted = true;
225     }
226     
227     
228     /**
229      * Returns if authentication has been attempted for this user.
230      */
231     public boolean getAuthenticationAttempted() {
232         return authnAttempted;
233     }
234     
235     
236     /**
237      * Sets the ID of the authenticated user.
238      * 
239      * @param userID The userid.
240      */
241     public void setUserID(String userID) {
242         this.userID = userID;
243     }
244     
245     
246     /**
247      * Returns the ID of the authenticated user.
248      * 
249      * @return the ID of the user, or <code>null</code> if authentication failed.
250      */
251     public String getUserID() {
252         return userID;
253     }
254     
255     
256     /**
257      * Gets the ProfileHandler URL.
258      *
259      * @return the URL of the profile handler that is invoking the Authentication Manager.
260      */
261     public String getProfileHandlerURL() {
262         return profileHandlerURL;
263     }
264     
265     
266     /**
267      * Sets the ProfileHandler URL.
268      *
269      * @param profileHandlerURL The URL of the profile handler that invoked the AuthenticationManager/
270      */
271     public void setProfileHandlerURL(String profileHandlerURL) {
272         this.profileHandlerURL = profileHandlerURL;
273     }
274     
275     
276     /**
277      * Gets the AuthenticationManager URL.
278      *
279      * @return the URL of the AuthenticationManager.
280      */
281     public String getAuthenticationManagerURL() {
282         return authnManagerURL;
283     }
284     
285     
286     /**
287      * Sets the AuthenticationManager's URL.
288      *
289      * @param authnManagerURL the URL of the AuthenticationManager.
290      */
291     public void setAuthenticationManagerURL(String authnManagerURL) {
292         this.authnManagerURL = authnManagerURL;
293     }
294     
295     
296     /**
297      * Gets the authentication instant.
298      *
299      * @return The instant of authentication, or <code>null</code> if none was set.
300      */
301     public DateTime getAuthenticationInstant() {
302         return authnInstant;
303     }
304     
305     
306     /**
307      * Sets the authentication instant.
308      *
309      * @param authnInstant The instant of authentication.
310      */
311     public void setAuthenticationInstant(final DateTime authnInstant) {
312         this.authnInstant = authnInstant;
313     }
314     
315     
316     /**
317      * Gets the duration of authentication.
318      *
319      * @return The duration of authentication, or zero if none was set.
320      */
321     public long getAuthenticationDuration() {
322         return authnDuration;
323     }
324     
325     
326     /**
327      * Sets the duration of authentication.
328      *
329      * @param authnDuration The duration of authentication.
330      */
331     public void setAuthenticationDuration(long authnDuration) {
332         this.authnDuration = authnDuration;
333     }
334     
335     
336     /**
337      * Gets the method used to authenticate the user.
338      *
339      * @return The method used to authenticate the user.
340      */
341     public String getAuthenticationMethod() {
342         return authnMethod;
343     }
344     
345     
346     /**
347      * Sets the method used to authenticate the user.
348      *
349      * @param authnMethod The method used to authenticate the user.
350      */
351     public void setAuthenticationMethod(String authnMethod) {
352         this.authnMethod = authnMethod;
353     }
354     
355     
356     /**
357      * Gets the {@link Session} ID
358      *
359      * @return the Session id.
360      */
361     public String getSessionID() {
362         return sessionID;
363     }
364     
365     
366     /**
367      * Sets the {@link Session} ID
368      *
369      * @param sessionID the Session ID
370      */
371     public void setSessionID(String sessionID) {
372         this.sessionID = sessionID;
373     }
374     
375     
376     /**
377      * Return the acceptable authentication handler URIs
378      * for authenticating this user. If no authentication
379      * methods are preferred, this method will return 
380      * <code>null</code>.
381      *
382      * @return an array of URIs, or <code>null</code>.
383      */
384     public String[] getRequestedAuthenticationMethods() {
385     
386         return null;
387     }
388 }