Commit | Line | Data |
---|---|---|
805e021f CE |
1 | /* |
2 | * @(#)User.java 1.0 6/29/2001 | |
3 | * | |
4 | * Copyright (c) 2001 International Business Machines Corp. | |
5 | * All rights reserved. | |
6 | * | |
7 | * This software has been released under the terms of the IBM Public | |
8 | * License. For details, see the LICENSE file in the top-level source | |
9 | * directory or online at http://www.openafs.org/dl/license10.html | |
10 | * | |
11 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
12 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
13 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
14 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR | |
15 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | |
16 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
17 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |
18 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | |
19 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |
20 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
21 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
22 | */ | |
23 | ||
24 | package org.openafs.jafs; | |
25 | ||
26 | import java.util.GregorianCalendar; | |
27 | import java.util.Date; | |
28 | import java.util.ArrayList; | |
29 | import java.io.Serializable; | |
30 | ||
31 | /** | |
32 | * An abstract representation of an AFS user. It holds information about | |
33 | * the user, such as what groups it belongs to. | |
34 | * <BR><BR> | |
35 | * | |
36 | * Constructing an instance of a <code>User</code> does not mean an actual | |
37 | * AFS user is created in a cell -- usually a <code>User</code> | |
38 | * object is a representation of an already existing AFS user. If, | |
39 | * however, the <code>User</code> is constructed with the name of a | |
40 | * user that does not exist in the cell represented by the provided | |
41 | * <code>Cell</code>, a new user with that name can be | |
42 | * created in that server by calling the {@link #create(String, int)} or | |
43 | * {@link #create(String)} method. If such a user does already exist when | |
44 | * one of these methods is called, an exception will be thrown.<BR><BR> | |
45 | * | |
46 | * Each <code>User</code> object has its own individual set of | |
47 | * <code>Group</code>s that it owns and <code>Group</code>s for which | |
48 | * it is a member. These represents the properties and attributes | |
49 | * of an actual AFS user. | |
50 | * <BR><BR> | |
51 | * | |
52 | * Since this <code>User</code> object is a union of both the PTS and KAS | |
53 | * properties of AFS users, some methods meant for users with a PTS entry | |
54 | * will throw exceptions if used on a user with only a KAS entry, and vice | |
55 | * versa.<BR><BR> | |
56 | * | |
57 | * <!--Information on how member values are set--> | |
58 | * | |
59 | * Associated with an AFS user are many attributes, such as whether or not | |
60 | * it can change its own password, or who is allowed to find out the groups | |
61 | * to which this user belongs. The <code>User</code> class has many | |
62 | * "set" methods to indicate values for these attributes (i.e. | |
63 | * {@link #setChangePassword(boolean)} and {@link #setListMembership(int)}). | |
64 | * However, in order for these values to be written to the actual AFS user, | |
65 | * the {@link #flushInfo()} method needs to be called. This writes all user | |
66 | * attributes set through this API to AFS. This is done to minimize calls | |
67 | * through JNI.<BR><BR> | |
68 | * | |
69 | * <!--Example of how to use class--> | |
70 | * The following is a simple example of how to construct and use a | |
71 | * <code>User</code> object. It iterates through the list of users | |
72 | * (a union of pts and kas users) for a cell, and prints out the name and | |
73 | * id of each. | |
74 | * | |
75 | * <PRE> | |
76 | * import org.openafs.jafs.Cell; | |
77 | * import org.openafs.jafs.AFSException; | |
78 | * import org.openafs.jafs.User; | |
79 | * ... | |
80 | * public class ... | |
81 | * { | |
82 | * ... | |
83 | * private Cell cell; | |
84 | * ... | |
85 | * public static void main(String[] args) throws Exception | |
86 | * { | |
87 | * String username = arg[0]; | |
88 | * String password = arg[1]; | |
89 | * String cellName = arg[2]; | |
90 | * | |
91 | * token = new Token(username, password, cellName); | |
92 | * cell = new Cell(token); | |
93 | * server = cell.getServer(serverName); | |
94 | * | |
95 | * System.out.println("Users in Cell " + cell.getName() + ":"); | |
96 | * User[] users = cell.getUsers(); | |
97 | * for (int i = 0; i < users.length; i++) { | |
98 | * System.out.println(" -> " + users[i] + ": " users[i].getID()); | |
99 | * } | |
100 | * } | |
101 | * ... | |
102 | * } | |
103 | * </PRE> | |
104 | * | |
105 | */ | |
106 | public class User implements PTSEntry, Serializable, Comparable | |
107 | { | |
108 | /** | |
109 | * Only the owner of the user has access | |
110 | */ | |
111 | public static final int USER_OWNER_ACCESS = 0; | |
112 | /** | |
113 | * Any user has access | |
114 | */ | |
115 | public static final int USER_ANYUSER_ACCESS = 1; | |
116 | ||
117 | /** | |
118 | * User has administrative kas privileges | |
119 | */ | |
120 | public static final int ADMIN = 0; | |
121 | /** | |
122 | * User has no administrative kas privileges | |
123 | */ | |
124 | public static final int NO_ADMIN = 1; | |
125 | ||
126 | /** | |
127 | * TGS will grant tickets for user | |
128 | */ | |
129 | public static final int GRANT_TICKETS = 0; | |
130 | /** | |
131 | * TGS will not grant tickets for user | |
132 | */ | |
133 | public static final int NO_GRANT_TICKETS = 1; | |
134 | ||
135 | /** | |
136 | * TGS can use user's key for an encryption key | |
137 | */ | |
138 | public static final int ENCRYPT = 0; | |
139 | /** | |
140 | * TGS cannot use user's key for an encryption key | |
141 | */ | |
142 | public static final int NO_ENCRYPT = 1; | |
143 | ||
144 | /** | |
145 | * User can change their password | |
146 | */ | |
147 | public static final int CHANGE_PASSWORD = 0; | |
148 | /** | |
149 | * User cannot change their password | |
150 | */ | |
151 | public static final int NO_CHANGE_PASSWORD = 1; | |
152 | ||
153 | /** | |
154 | * User can reuse their password | |
155 | */ | |
156 | public static final int REUSE_PASSWORD = 0; | |
157 | /** | |
158 | * User cannot reuse their password | |
159 | */ | |
160 | public static final int NO_REUSE_PASSWORD = 1; | |
161 | ||
162 | protected Cell cell; | |
163 | protected long cellHandle; | |
164 | protected String name; | |
165 | ||
166 | /** | |
167 | * Does this user have a kas entry? | |
168 | */ | |
169 | protected boolean kas; | |
170 | /** | |
171 | * Does this user have a pts entry? | |
172 | */ | |
173 | protected boolean pts; | |
174 | ||
175 | // pts fields | |
176 | protected int groupCreationQuota; | |
177 | protected int groupMembershipCount; | |
178 | protected int nameUID; | |
179 | protected int ownerUID; | |
180 | protected int creatorUID; | |
181 | ||
182 | /** | |
183 | * who is allowed to execute pts examine for this user. Valid values are: | |
184 | * <ul> | |
185 | * <li>{@link #USER_OWNER_ACCESS} | |
186 | * -- only the owner has permission</li> | |
187 | * <li>{@link #USER_ANYUSER_ACCESS} | |
188 | * -- any user has permission</li></ul> | |
189 | */ | |
190 | protected int listStatus; | |
191 | /** | |
192 | * who is allowed to execute pts listowned for this user. Valid values are: | |
193 | * <ul> | |
194 | * <li>{@link #USER_OWNER_ACCESS} | |
195 | * -- only the owner has permission</li> | |
196 | * <li>{@link #USER_ANYUSER_ACCESS} | |
197 | * -- any user has permission</li></ul> | |
198 | */ | |
199 | protected int listGroupsOwned; | |
200 | /** | |
201 | * who is allowed to execute pts membership for this user. Valid values are: | |
202 | * <ul> | |
203 | * <li>{@link #USER_OWNER_ACCESS} | |
204 | * -- only the owner has permission</li> | |
205 | * <li>{@link #USER_ANYUSER_ACCESS} | |
206 | * -- any user has permission</li></ul> | |
207 | */ | |
208 | protected int listMembership; | |
209 | protected String owner; | |
210 | protected String creator; | |
211 | ||
212 | // lists | |
213 | protected ArrayList groups; | |
214 | protected ArrayList groupNames; | |
215 | protected ArrayList groupsOwned; | |
216 | protected ArrayList groupsOwnedNames; | |
217 | ||
218 | // kas fields | |
219 | /** | |
220 | * whether or not this user has kas administrative privileges. | |
221 | * Valid values are: | |
222 | * <ul> | |
223 | * <li>{@link #ADMIN}</li> | |
224 | * <li>{@link #NO_ADMIN}</li></ul> | |
225 | */ | |
226 | protected int adminSetting; | |
227 | /** | |
228 | * whether the TGS will grant tickets for this user. Valid values are: | |
229 | * <ul> | |
230 | * <li>{@link #GRANT_TICKETS}</li> | |
231 | * <li>{@link #NO_GRANT_TICKETS}</li></ul> | |
232 | */ | |
233 | protected int tgsSetting; | |
234 | /** | |
235 | * whether the TGS can use this user's key as an encryption key. Valid values are: | |
236 | * <ul> | |
237 | * <li>{@link #ENCRYPT}</li> | |
238 | * <li>{@link #NO_ENCRYPT}</li></ul> | |
239 | */ | |
240 | protected int encSetting; | |
241 | /** | |
242 | * whether this user is allowed to change its password. Valid values are: | |
243 | * <ul> | |
244 | * <li>{@link #CHANGE_PASSWORD}</li> | |
245 | * <li>{@link #NO_CHANGE_PASSWORD}</li></ul> | |
246 | */ | |
247 | protected int cpwSetting; | |
248 | /** | |
249 | * whether this user is allowed to reuse its password. Valid values are: | |
250 | * <ul> | |
251 | * <li>{@link #REUSE_PASSWORD}</li> | |
252 | * <li>{@link #NO_REUSE_PASSWORD}</li></ul> | |
253 | */ | |
254 | protected int rpwSetting; | |
255 | protected int userExpiration; | |
256 | protected int lastModTime; | |
257 | protected String lastModName; | |
258 | protected int lastChangePasswordTime; | |
259 | protected int maxTicketLifetime; | |
260 | protected int keyVersion; | |
261 | protected String encryptionKey; | |
262 | protected long keyCheckSum; | |
263 | protected int daysToPasswordExpire; | |
264 | protected int failLoginCount; | |
265 | protected int lockTime; | |
266 | protected int lockedUntil; | |
267 | ||
268 | // Dates and times | |
269 | protected GregorianCalendar lockedUntilDate; | |
270 | protected GregorianCalendar userExpirationDate; | |
271 | protected GregorianCalendar lastModTimeDate; | |
272 | protected GregorianCalendar lastChangePasswordTimeDate; | |
273 | ||
274 | /** | |
275 | * Whether or not the information fields of this user have been filled. | |
276 | */ | |
277 | protected boolean cachedInfo; | |
278 | ||
279 | /** | |
280 | * Constructs a new <code>User</code> object instance given the name | |
281 | * of the AFS user and the AFS cell, represented by | |
282 | * <CODE>cell</CODE>, to which it belongs. This does not actually | |
283 | * create a new AFS user, it just represents one. | |
284 | * If <code>name</code> is not an actual AFS user, exceptions | |
285 | * will be thrown during subsequent method invocations on this | |
286 | * object, unless the {@link #create(String, int)} or {@link #create(String)} | |
287 | * method is explicitly called to create it. | |
288 | * | |
289 | * @param name the name of the user to represent | |
290 | * @param cell the cell to which the user belongs. | |
291 | * @exception AFSException If an error occurs in the native code | |
292 | */ | |
293 | public User( String name, Cell cell ) throws AFSException | |
294 | { | |
295 | this.name = name; | |
296 | this.cell = cell; | |
297 | cellHandle = cell.getCellHandle(); | |
298 | ||
299 | groups = null; | |
300 | groupNames = null; | |
301 | groupsOwned = null; | |
302 | groupsOwnedNames = null; | |
303 | cachedInfo = false; | |
304 | kas = false; | |
305 | pts = false; | |
306 | } | |
307 | ||
308 | /** | |
309 | * Constructs a new <code>User</code> object instance given the name | |
310 | * of the AFS user and the AFS cell, represented by | |
311 | * <CODE>cell</CODE>, to which it belongs. This does not actually | |
312 | * create a new AFS user, it just represents one. | |
313 | * If <code>name</code> is not an actual AFS user, exceptions | |
314 | * will be thrown during subsequent method invocations on this | |
315 | * object, unless the {@link #create(String, int)} or {@link #create(String)} | |
316 | * method is explicitly called to create it. Note that if the process | |
317 | * doesn't exist and <code>preloadAllMembers</code> is true, an exception | |
318 | * will be thrown. | |
319 | * | |
320 | * <P> This constructor is ideal for point-in-time representation and | |
321 | * transient applications. It ensures all data member values are set and | |
322 | * available without calling back to the filesystem at the first request | |
323 | * for them. Use the {@link #refresh()} method to address any coherency | |
324 | * concerns. | |
325 | * | |
326 | * @param name the name of the user to represent | |
327 | * @param cell the cell to which the user belongs. | |
328 | * @param preloadAllMembers true will ensure all object members are | |
329 | * set upon construction; | |
330 | * otherwise members will be set upon access, | |
331 | * which is the default behavior. | |
332 | * @exception AFSException If an error occurs in the native code | |
333 | * @see #refresh | |
334 | */ | |
335 | public User( String name, Cell cell, boolean preloadAllMembers ) | |
336 | throws AFSException | |
337 | { | |
338 | this(name, cell); | |
339 | if (preloadAllMembers) refresh(true); | |
340 | } | |
341 | ||
342 | /** | |
343 | * Constructs a blank <code>User</code> object given the cell to which | |
344 | * the user belongs. This blank object can then be passed into other | |
345 | * methods to fill out its properties. | |
346 | * | |
347 | * @exception AFSException If an error occurs in the native code | |
348 | * @param cell the cell to which the user belongs. | |
349 | */ | |
350 | User( Cell cell ) throws AFSException | |
351 | { | |
352 | this( null, cell ); | |
353 | } | |
354 | ||
355 | /*-------------------------------------------------------------------------*/ | |
356 | ||
357 | /** | |
358 | * Creates the kas and pts entries for a new user in this cell. | |
359 | * Automatically assigns a user id. | |
360 | * * | |
361 | * @param password the password for the new user | |
362 | * @exception AFSException If an error occurs in the native code | |
363 | */ | |
364 | public void create( String password ) throws AFSException | |
365 | { | |
366 | create( password, 0 ); | |
367 | } | |
368 | ||
369 | /** | |
370 | * Creates the kas and pts entries for a new user in this cell. | |
371 | * | |
372 | * @param password the password for the new user | |
373 | * @param uid the user id to assign to the new user | |
374 | * | |
375 | * @exception AFSException If an error occurs in the native code | |
376 | */ | |
377 | public void create( String password, int uid ) throws AFSException | |
378 | { | |
379 | create( cell.getCellHandle(), name, password, uid ); | |
380 | } | |
381 | ||
382 | /** | |
383 | * Deletes the pts and kas entries for a user in this cell. Deletes this user | |
384 | * from the membership list of the groups to which it belonged, but does not | |
385 | * delete the groups owned by this user. Also nullifies this corresponding | |
386 | * Java object. | |
387 | * | |
388 | * @exception AFSException If an error occurs in the native code | |
389 | */ | |
390 | public void delete() throws AFSException | |
391 | { | |
392 | delete( cell.getCellHandle(), name ); | |
393 | ||
394 | cell = null; | |
395 | name = null; | |
396 | kas = false; | |
397 | pts = false; | |
398 | owner = null; | |
399 | creator = null; | |
400 | groups = null; | |
401 | groupsOwned = null; | |
402 | groupNames = null; | |
403 | groupsOwnedNames = null; | |
404 | lastModName = null; | |
405 | encryptionKey = null; | |
406 | lockedUntilDate = null; | |
407 | userExpirationDate = null; | |
408 | lastModTimeDate = null; | |
409 | lastChangePasswordTimeDate = null; | |
410 | try { | |
411 | finalize(); | |
412 | } catch( java.lang.Throwable t ) { | |
413 | throw new AFSException( t.getMessage() ); | |
414 | } | |
415 | } | |
416 | ||
417 | /** | |
418 | * Unlocks the given user if they were locked out of the cell. | |
419 | * | |
420 | * @param userName the name of the user to unlock | |
421 | * @exception AFSException If an error occurs in the native code | |
422 | */ | |
423 | public void unlock() throws AFSException | |
424 | { | |
425 | unlock( cell.getCellHandle(), name ); | |
426 | lockedUntil = 0; | |
427 | lockedUntilDate = null; | |
428 | } | |
429 | ||
430 | /** | |
431 | * Flushes the current information of this <code>User</code> object to disk. | |
432 | * This will update the information of the actual AFS user to match the | |
433 | * settings that have been modified within this <code>User</code> object. | |
434 | * This function must be called before any changes made to the information | |
435 | * fields of this user will be seen by AFS. | |
436 | * | |
437 | * @exception AFSException If an error occurs in the native code | |
438 | */ | |
439 | public void flushInfo() throws AFSException | |
440 | { | |
441 | setUserInfo( cell.getCellHandle(), name, this ); | |
442 | } | |
443 | ||
444 | /** | |
445 | * Change the name of this user. Automatically flushes the info of this | |
446 | * user in order to update kas entry of the new name. NOTE: renaming a | |
447 | * locked user will unlock that user. | |
448 | * | |
449 | * @param newName the new name for this user | |
450 | * @exception AFSException If an error occurs in the native code | |
451 | */ | |
452 | public void rename( String newName ) throws AFSException | |
453 | { | |
454 | rename( cell.getCellHandle(), name, newName ); | |
455 | name = newName; | |
456 | flushInfo(); | |
457 | } | |
458 | ||
459 | /** | |
460 | * Refreshes the properties of this User object instance with values from | |
461 | * the AFS user it represents. All properties that have been initialized | |
462 | * and/or accessed will be renewed according to the values of the AFS user | |
463 | * this User object instance represents. | |
464 | * | |
465 | * <P>Since in most environments administrative changes can be administered | |
466 | * from an AFS command-line program or an alternate GUI application, this | |
467 | * method provides a means to refresh the Java object representation and | |
468 | * thereby ascertain any possible modifications that may have been made | |
469 | * from such alternate administrative programs. Using this method before | |
470 | * an associated instance accessor will ensure the highest level of | |
471 | * representative accuracy, accommodating changes made external to the | |
472 | * Java application space. If administrative changes to the underlying AFS | |
473 | * system are only allowed via this API, then the use of this method is | |
474 | * unnecessary. | |
475 | * | |
476 | * @exception AFSException If an error occurs in the native code | |
477 | */ | |
478 | public void refresh() throws AFSException | |
479 | { | |
480 | refresh(false); | |
481 | } | |
482 | ||
483 | /** | |
484 | * Refreshes the properties of this User object instance with values from | |
485 | * the AFS user it represents. If <CODE>all</CODE> is <CODE>true</CODE> | |
486 | * then <U>all</U> of the properties of this User object instance will be | |
487 | * set, or renewed, according to the values of the AFS user it represents, | |
488 | * disregarding any previously set properties. | |
489 | * | |
490 | * <P> Thus, if <CODE>all</CODE> is <CODE>false</CODE> then properties that | |
491 | * are currently set will be refreshed and properties that are not set will | |
492 | * remain uninitialized. See {@link #refresh()} for more information. | |
493 | * | |
494 | * @param all if true set or renew all object properties; otherwise renew | |
495 | * all set properties | |
496 | * @exception AFSException If an error occurs in the native code | |
497 | * @see #refresh() | |
498 | */ | |
499 | protected void refresh(boolean all) throws AFSException | |
500 | { | |
501 | if ( all || cachedInfo ) { | |
502 | refreshInfo(); | |
503 | } | |
504 | if ( all || groupsOwned != null ) { | |
505 | refreshGroupsOwned(); | |
506 | } | |
507 | if ( all || groupsOwnedNames != null ) { | |
508 | refreshGroupsOwnedNames(); | |
509 | } | |
510 | if ( all || groups != null ) { | |
511 | refreshGroups(); | |
512 | } | |
513 | if ( all || groupNames != null ) { | |
514 | refreshGroupNames(); | |
515 | } | |
516 | } | |
517 | ||
518 | /** | |
519 | * Refreshes the information fields of this <code>User</code> to reflect | |
520 | * the current state of the AFS user. Does not refresh the groups to which | |
521 | * the user belongs or groups owned by the user. | |
522 | * | |
523 | * @exception AFSException If an error occurs in the native code | |
524 | */ | |
525 | protected void refreshInfo() throws AFSException | |
526 | { | |
527 | getUserInfo( cell.getCellHandle(), name, this ); | |
528 | cachedInfo = true; | |
529 | lastModTimeDate = null; | |
530 | lastChangePasswordTimeDate = null; | |
531 | lockedUntilDate = null; | |
532 | userExpirationDate = null; | |
533 | } | |
534 | ||
535 | /** | |
536 | * Refreshes the current information about the group names to which the | |
537 | * user belongs. Does not refresh the information fields of the user or | |
538 | * the groups owned. | |
539 | * | |
540 | * @exception AFSException If an error occurs in the native code | |
541 | */ | |
542 | protected void refreshGroupNames() throws AFSException | |
543 | { | |
544 | String currName; | |
545 | long iterationID = getUserGroupsBegin( cell.getCellHandle(), name ); | |
546 | groupNames = new ArrayList(); | |
547 | while( ( currName = getUserGroupsNextString( iterationID ) ) != null ) { | |
548 | groupNames.add( currName ); | |
549 | } | |
550 | getUserGroupsDone( iterationID ); | |
551 | } | |
552 | ||
553 | /** | |
554 | * Refreshes the current information about the group objects to which the | |
555 | * user belongs. Does not refresh the information fields of the user or | |
556 | * the groups owned. | |
557 | * | |
558 | * @exception AFSException If an error occurs in the native code | |
559 | */ | |
560 | protected void refreshGroups() throws AFSException | |
561 | { | |
562 | Group currGroup; | |
563 | long iterationID = getUserGroupsBegin( cell.getCellHandle(), name ); | |
564 | ||
565 | groups = new ArrayList(); | |
566 | ||
567 | currGroup = new Group( cell ); | |
568 | while( getUserGroupsNext( cellHandle, iterationID, currGroup ) != 0 ) { | |
569 | groups.add( currGroup ); | |
570 | currGroup = new Group( cell ); | |
571 | } | |
572 | getUserGroupsDone( iterationID ); | |
573 | } | |
574 | ||
575 | /** | |
576 | * Refreshes the current information about the group names that the user | |
577 | * owns. Does not refresh the information fields of the user or the groups | |
578 | * belonged to. | |
579 | * | |
580 | * @exception AFSException If an error occurs in the native code | |
581 | */ | |
582 | protected void refreshGroupsOwnedNames() throws AFSException | |
583 | { | |
584 | String currName; | |
585 | long iterationID = this.getGroupsOwnedBegin( cell.getCellHandle(), name ); | |
586 | groupsOwnedNames = new ArrayList(); | |
587 | while( ( currName = this.getGroupsOwnedNextString( iterationID ) ) | |
588 | != null ) { | |
589 | groupsOwnedNames.add( currName ); | |
590 | } | |
591 | this.getGroupsOwnedDone( iterationID ); | |
592 | } | |
593 | ||
594 | /** | |
595 | * Refreshes the current information about the group objects that the user \ | |
596 | * owns. Does not refresh the information fields of the user or the groups | |
597 | * belonged to. | |
598 | * | |
599 | * @exception AFSException If an error occurs in the native code | |
600 | */ | |
601 | protected void refreshGroupsOwned() throws AFSException | |
602 | { | |
603 | Group currGroup; | |
604 | long iterationID = getGroupsOwnedBegin( cell.getCellHandle(), name ); | |
605 | groupsOwned = new ArrayList(); | |
606 | currGroup = new Group( cell ); | |
607 | while( getGroupsOwnedNext( cellHandle, iterationID, currGroup ) != 0 ) { | |
608 | groupsOwned.add( currGroup ); | |
609 | currGroup = new Group( cell ); | |
610 | } | |
611 | getGroupsOwnedDone( iterationID ); | |
612 | } | |
613 | ||
614 | /** | |
615 | * Adds an access control list entry for some AFS directory for this user. | |
616 | * | |
617 | * @param directory the full path of the place in the AFS file system | |
618 | * for which to add an entry | |
619 | * @param read whether or not to allow read access to this user | |
620 | * @param write whether or not to allow write access to this user | |
621 | * @param lookup whether or not to allow lookup access to this user | |
622 | * @param delete whether or not to allow deletion access to this user | |
623 | * @param insert whether or not to allow insertion access to this user | |
624 | * @param lock whether or not to allow lock access to this user | |
625 | * @param admin whether or not to allow admin access to this user | |
626 | * @exception AFSException If an error occurs in the native code | |
627 | public void setACL( String directory, boolean read, boolean write, boolean lookup, boolean delete, boolean insert, boolean lock, boolean admin ) throws AFSException | |
628 | { | |
629 | cell.setACL( directory, name, read, write, lookup, delete, insert, lock, admin ); | |
630 | } | |
631 | */ | |
632 | ||
633 | //////////////// ACCESSORS //////////////////////// | |
634 | ||
635 | /** | |
636 | * Returns the name of this user. | |
637 | * | |
638 | * @return the name of this user | |
639 | */ | |
640 | public String getName() | |
641 | { | |
642 | return name; | |
643 | } | |
644 | ||
645 | /** | |
646 | * Returns the Cell this user belongs to. | |
647 | * | |
648 | * @return the Cell this user belongs to | |
649 | */ | |
650 | public Cell getCell() | |
651 | { | |
652 | return cell; | |
653 | } | |
654 | ||
655 | /** | |
656 | * Returns whether or not this user has a kas entry. | |
657 | * | |
658 | * @return whether or not this user has a kas entry | |
659 | * @exception AFSException If an error occurs in the native code | |
660 | * @see #refresh() | |
661 | */ | |
662 | public boolean isKAS() throws AFSException | |
663 | { | |
664 | if ( !cachedInfo ) refreshInfo(); | |
665 | return kas; | |
666 | } | |
667 | ||
668 | /** | |
669 | * Returns whether or not this user has a pts entry. | |
670 | * | |
671 | * @return whether or not this user has a pts entry | |
672 | * @exception AFSException If an error occurs in the native code | |
673 | * @see #refresh() | |
674 | */ | |
675 | public boolean isPTS() throws AFSException | |
676 | { | |
677 | if( !cachedInfo ) refreshInfo(); | |
678 | return pts; | |
679 | } | |
680 | ||
681 | /** | |
682 | * PTS: Returns an array of the <code>Group</code> objects | |
683 | * to which this user belongs. | |
684 | * | |
685 | * @return an array of the groups to which this user belongs | |
686 | * @exception AFSException If an error occurs in the native code | |
687 | * @see #refresh() | |
688 | */ | |
689 | public Group[] getGroups() throws AFSException | |
690 | { | |
691 | if( groups == null ) refreshGroups(); | |
692 | return (Group[]) groups.toArray( new Group[groups.size()] ); | |
693 | } | |
694 | ||
695 | /** | |
696 | * PTS: Returns the total count of groups this user owns. | |
697 | * | |
698 | * <P>If the total list of groups or group names have already been | |
699 | * collected (see {@link #getGroupsOwned()}), then the returning value | |
700 | * will be calculated based upon the current list. Otherwise, PTS will | |
701 | * be explicitly queried for the information. | |
702 | * | |
703 | * @return total count of groups this user owns | |
704 | * @exception AFSException If an error occurs in the native code | |
705 | * @see #getGroupsOwned() | |
706 | * @see #getGroupsOwnedNames() | |
707 | */ | |
708 | public int getGroupsOwnedCount() throws AFSException | |
709 | { | |
710 | if( groupsOwned != null ) { | |
711 | return groupsOwned.size(); | |
712 | } else if ( groupsOwnedNames != null ) { | |
713 | return groupsOwnedNames.size(); | |
714 | } else { | |
715 | return getGroupsOwnedCount( cell.getCellHandle(), name ); | |
716 | } | |
717 | } | |
718 | ||
719 | /** | |
720 | * PTS: Returns an array of the <code>Group</code> objects | |
721 | * this user owns. | |
722 | * | |
723 | * @return an array of the <code>Groups</code> this user owns | |
724 | * @exception AFSException If an error occurs in the native code | |
725 | * @see #refresh() | |
726 | */ | |
727 | public Group[] getGroupsOwned() throws AFSException | |
728 | { | |
729 | if( groupsOwned == null ) refreshGroupsOwned(); | |
730 | return (Group[]) groupsOwned.toArray( new Group[groupsOwned.size()] ); | |
731 | } | |
732 | ||
733 | /** | |
734 | * PTS: Returns a <code>String</code> array of the group names | |
735 | * to which this user belongs. | |
736 | * | |
737 | * @return a <code>String</code> array of the groups to which this | |
738 | * user belongs | |
739 | * @exception AFSException If an error occurs in the native code | |
740 | * @see #refresh() | |
741 | */ | |
742 | public String[] getGroupNames() throws AFSException | |
743 | { | |
744 | if( groupNames == null ) refreshGroupNames(); | |
745 | return (String []) groupNames.toArray( new String[groupNames.size() ] ); | |
746 | } | |
747 | ||
748 | /** | |
749 | * PTS: Returns a <code>String</code> array of the group names | |
750 | * this user owns. | |
751 | * | |
752 | * @return a <code>String</code> array of the groups this user owns | |
753 | * @exception AFSException If an error occurs in the native code | |
754 | * @see #refresh() | |
755 | */ | |
756 | public String[] getGroupsOwnedNames() throws AFSException | |
757 | { | |
758 | if( groupsOwnedNames == null ) refreshGroupsOwnedNames(); | |
759 | return (String []) groupsOwnedNames.toArray( new String[groupsOwnedNames.size() ] ); | |
760 | } | |
761 | ||
762 | /** | |
763 | * PTS: Returns the numeric AFS id of this user. | |
764 | * | |
765 | * @return the AFS id of this user | |
766 | * @exception AFSException If an error occurs in the native code | |
767 | * @see #refresh() | |
768 | */ | |
769 | public int getUID() throws AFSException | |
770 | { | |
771 | if( !cachedInfo ) refreshInfo(); | |
772 | return nameUID; | |
773 | } | |
774 | ||
775 | /** | |
776 | * PTS: Returns how many more groups this user is allowed to create. | |
777 | * -1 indicates unlimited. | |
778 | * | |
779 | * @return the group creation quota | |
780 | * @exception AFSException If an error occurs in the native code | |
781 | * @see #refresh() | |
782 | */ | |
783 | public int getGroupCreationQuota() throws AFSException | |
784 | { | |
785 | if( !cachedInfo ) refreshInfo(); | |
786 | return groupCreationQuota; | |
787 | } | |
788 | ||
789 | /** | |
790 | * PTS: Returns the number of groups to which this user belongs. | |
791 | * | |
792 | * @return the group membership count | |
793 | * @exception AFSException If an error occurs in the native code | |
794 | * @see #refresh() | |
795 | */ | |
796 | public int getGroupMembershipCount() throws AFSException | |
797 | { | |
798 | if( !cachedInfo ) refreshInfo(); | |
799 | return groupMembershipCount; | |
800 | } | |
801 | ||
802 | /** | |
803 | * PTS: Returns the owner of this user in the form of a {@link PTSEntry}. | |
804 | * | |
805 | * <P>The returning object could be either a {@link User} or {@link Group}; | |
806 | * to determine what type of object the {@link PTSEntry} represents, | |
807 | * call the {@link PTSEntry#getType()} method. | |
808 | * | |
809 | * @return the owner of this user | |
810 | * @exception AFSException If an error occurs in the native code | |
811 | * @see PTSEntry | |
812 | * @see PTSEntry#getType() | |
813 | * @see #refresh() | |
814 | */ | |
815 | public PTSEntry getOwner() throws AFSException | |
816 | { | |
817 | if (!cachedInfo) refreshInfo(); | |
818 | if (owner == null) return null; | |
819 | if (ownerUID > 0) { | |
820 | return new User(owner, cell); | |
821 | } else { | |
822 | return new Group(owner, cell); | |
823 | } | |
824 | } | |
825 | ||
826 | /** | |
827 | * PTS: Returns the creator of this user in the form of a {@link PTSEntry}. | |
828 | * | |
829 | * <P>The returning object could be either a {@link User} or {@link Group}; | |
830 | * to determine what type of object the {@link PTSEntry} represents, | |
831 | * call the {@link PTSEntry#getType()} method. | |
832 | * | |
833 | * @return the creator of this user | |
834 | * @exception AFSException If an error occurs in the native code | |
835 | * @see PTSEntry | |
836 | * @see PTSEntry#getType() | |
837 | * @see #refresh() | |
838 | */ | |
839 | public PTSEntry getCreator() throws AFSException | |
840 | { | |
841 | if (!cachedInfo) refreshInfo(); | |
842 | if (creator == null) return null; | |
843 | if (creatorUID > 0) { | |
844 | return new User(creator, cell); | |
845 | } else { | |
846 | return new Group(creator, cell); | |
847 | } | |
848 | } | |
849 | ||
850 | /** | |
851 | * Returns the type of {@link PTSEntry} this object represents. | |
852 | * | |
853 | * <P>This method will always return {@link PTSEntry#PTS_USER}. | |
854 | * | |
855 | * @return the type of PTSEntry this object represents | |
856 | (will always return {@link PTSEntry#PTS_USER}) | |
857 | * @see PTSEntry | |
858 | * @see PTSEntry#getType() | |
859 | */ | |
860 | public short getType() | |
861 | { | |
862 | return PTSEntry.PTS_USER; | |
863 | } | |
864 | ||
865 | /** | |
866 | * PTS: Returns who can list the status (pts examine) of this user. | |
867 | * Valid values are: | |
868 | * <ul> | |
869 | * <li><code>{@link #USER_OWNER_ACCESS}</code> | |
870 | * -- only the owner has permission</li> | |
871 | * <li><code>{@link #USER_ANYUSER_ACCESS}</code> | |
872 | * -- any user has permission</li> | |
873 | * </ul> | |
874 | * | |
875 | * @return the status listing permission | |
876 | * @exception AFSException If an error occurs in the native code | |
877 | * @see #refresh() | |
878 | */ | |
879 | public int getListStatus() throws AFSException | |
880 | { | |
881 | if( !cachedInfo ) refreshInfo(); | |
882 | return listStatus; | |
883 | } | |
884 | ||
885 | /** | |
886 | * PTS: Returns who can list the groups owned (pts listowned) by this user. | |
887 | * Valid values are: | |
888 | * <ul> | |
889 | * <li><code>{@link #USER_OWNER_ACCESS}</code> | |
890 | * -- only the owner has permission</li> | |
891 | * <li><code>{@link #USER_ANYUSER_ACCESS}</code> | |
892 | * -- any user has permission</li> | |
893 | * </ul> | |
894 | * | |
895 | * @return the groups owned listing permission | |
896 | * @exception AFSException If an error occurs in the native code | |
897 | * @see #refresh() | |
898 | */ | |
899 | public int getListGroupsOwned() throws AFSException | |
900 | { | |
901 | if( !cachedInfo ) refreshInfo(); | |
902 | return listGroupsOwned; | |
903 | } | |
904 | ||
905 | /** | |
906 | * PTS: Returns who can list the groups (pts membership) to which this | |
907 | * user belongs. | |
908 | * Valid values are: | |
909 | * <ul> | |
910 | * <li><code>{@link #USER_OWNER_ACCESS}</code> | |
911 | * -- only the owner has permission</li> | |
912 | * <li><code>{@link #USER_ANYUSER_ACCESS}</code> | |
913 | * -- any user has permission</li> | |
914 | * </ul> | |
915 | * | |
916 | * @return the membership listing permission | |
917 | * @exception AFSException If an error occurs in the native code | |
918 | * @see #refresh() | |
919 | */ | |
920 | public int getListMembership() throws AFSException | |
921 | { | |
922 | if( !cachedInfo ) refreshInfo(); | |
923 | return listMembership; | |
924 | } | |
925 | ||
926 | /** | |
927 | * KAS: Returns whether or not this user has kas administrative privileges | |
928 | * | |
929 | * @return whether or not this user has kas administrative priveleges | |
930 | * @exception AFSException If an error occurs in the native code | |
931 | * @see #refresh() | |
932 | */ | |
933 | public boolean isAdmin() throws AFSException | |
934 | { | |
935 | if( !cachedInfo ) refreshInfo(); | |
936 | return (adminSetting == this.ADMIN); | |
937 | } | |
938 | ||
939 | /** | |
940 | * KAS: Returns whether or not TGS will issue tickets for this user | |
941 | * | |
942 | * @return whether or not TGS will issue tickets for this user | |
943 | * @exception AFSException If an error occurs in the native code | |
944 | * @see #refresh() | |
945 | */ | |
946 | public boolean willGrantTickets() throws AFSException | |
947 | { | |
948 | if( !cachedInfo ) refreshInfo(); | |
949 | return (tgsSetting == this.GRANT_TICKETS); | |
950 | } | |
951 | ||
952 | /** | |
953 | * KAS: Returns whether or not TGS can use this users ticket for an encryption key | |
954 | * | |
955 | * @return whether or not TGS can use this users ticket for an encryption key | |
956 | * @exception AFSException If an error occurs in the native code | |
957 | * @see #refresh() | |
958 | */ | |
959 | public boolean canEncrypt() throws AFSException | |
960 | { | |
961 | if( !cachedInfo ) refreshInfo(); | |
962 | return (encSetting == this.ENCRYPT); | |
963 | } | |
964 | ||
965 | /** | |
966 | * KAS: Returns whether or not the user can change their password | |
967 | * | |
968 | * @return whether or not the user can change their password | |
969 | * @exception AFSException If an error occurs in the native code | |
970 | * @see #refresh() | |
971 | */ | |
972 | public boolean canChangePassword() throws AFSException | |
973 | { | |
974 | if( !cachedInfo ) refreshInfo(); | |
975 | return (cpwSetting == this.CHANGE_PASSWORD); | |
976 | } | |
977 | ||
978 | /** | |
979 | * KAS: Returns whether or not the user can reuse their password | |
980 | * | |
981 | * @return whether or not the user can reuse their password | |
982 | * @exception AFSException If an error occurs in the native code | |
983 | * @see #refresh() | |
984 | */ | |
985 | public boolean canReusePassword() throws AFSException | |
986 | { | |
987 | if( !cachedInfo ) refreshInfo(); | |
988 | return (rpwSetting == this.REUSE_PASSWORD); | |
989 | } | |
990 | ||
991 | /** | |
992 | * KAS: Returns the date and time the user expires. | |
993 | * A <code>null</code> value indicates the user never exipres (or that | |
994 | * there is no kas entry for this user). | |
995 | * | |
996 | * @return the date and time the user expires | |
997 | * @exception AFSException If an error occurs in the native code | |
998 | * @see #refresh() | |
999 | */ | |
1000 | public int getUserExpiration() throws AFSException | |
1001 | { | |
1002 | if( !cachedInfo ) refreshInfo(); | |
1003 | return userExpiration; | |
1004 | } | |
1005 | /** | |
1006 | * KAS: Returns the date and time the user expires. | |
1007 | * A <code>null</code> value indicates the user never expires (or that | |
1008 | * there is no kas entry for this user). | |
1009 | * | |
1010 | * @return the date and time the user expires | |
1011 | * @exception AFSException If an error occurs in the native code | |
1012 | * @see #refresh() | |
1013 | */ | |
1014 | public GregorianCalendar getUserExpirationDate() throws AFSException | |
1015 | { | |
1016 | if( !cachedInfo ) refreshInfo(); | |
1017 | if( userExpirationDate == null && userExpiration != 0 ) { | |
1018 | // make it into a date . . . | |
1019 | if( userExpiration == 0 ) { | |
1020 | userExpirationDate = null; | |
1021 | } else { | |
1022 | userExpirationDate = new GregorianCalendar(); | |
1023 | long longTime = ((long) userExpiration)*1000; | |
1024 | Date d = new Date( longTime ); | |
1025 | userExpirationDate.setTime( d ); | |
1026 | } | |
1027 | } | |
1028 | return userExpirationDate; | |
1029 | } | |
1030 | ||
1031 | /** | |
1032 | * KAS: Returns the date and time (in UTC) the user's KAS entry was | |
1033 | * last modified. | |
1034 | * | |
1035 | * @return the date and time (in UTC) the user was last modified | |
1036 | * @exception AFSException If an error occurs in the native code | |
1037 | * @see #refresh() | |
1038 | */ | |
1039 | public int getLastModTime() throws AFSException | |
1040 | { | |
1041 | if( !cachedInfo ) refreshInfo(); | |
1042 | return lastModTime; | |
1043 | } | |
1044 | /** | |
1045 | * KAS: Returns the date and time the user was last modified. | |
1046 | * | |
1047 | * @return the date and time the user was last modified | |
1048 | * @exception AFSException If an error occurs in the native code | |
1049 | * @see #refresh() | |
1050 | */ | |
1051 | public GregorianCalendar getLastModTimeDate() throws AFSException | |
1052 | { | |
1053 | if( !cachedInfo ) refreshInfo(); | |
1054 | if( lastModTimeDate == null ) { | |
1055 | // make it into a date . . . | |
1056 | lastModTimeDate = new GregorianCalendar(); | |
1057 | long longTime = ((long) lastModTime)*1000; | |
1058 | Date d = new Date( longTime ); | |
1059 | lastModTimeDate.setTime( d ); | |
1060 | } | |
1061 | return lastModTimeDate; | |
1062 | } | |
1063 | ||
1064 | /** | |
1065 | * KAS: Returns the name of the user that last modified this user. | |
1066 | * | |
1067 | * @return the name of this user that last modified this user. | |
1068 | * @exception AFSException If an error occurs in the native code | |
1069 | * @see #refresh() | |
1070 | */ | |
1071 | public String getLastModName() throws AFSException | |
1072 | { | |
1073 | if( !cachedInfo ) refreshInfo(); | |
1074 | return lastModName; | |
1075 | } | |
1076 | ||
1077 | /** | |
1078 | * KAS: Returns the last date and time the user changed its password. | |
1079 | * | |
1080 | * @return the last date and time the user changed its password. | |
1081 | * @exception AFSException If an error occurs in the native code | |
1082 | * @see #refresh() | |
1083 | */ | |
1084 | public GregorianCalendar getLastChangePasswordTimeDate() | |
1085 | throws AFSException | |
1086 | { | |
1087 | if( !cachedInfo ) refreshInfo(); | |
1088 | if( lastChangePasswordTimeDate == null ) { | |
1089 | // make it into a date . . . | |
1090 | lastChangePasswordTimeDate = new GregorianCalendar(); | |
1091 | long longTime = ((long) lastChangePasswordTime)*1000; | |
1092 | Date d = new Date( longTime ); | |
1093 | lastChangePasswordTimeDate.setTime( d ); | |
1094 | } | |
1095 | return lastChangePasswordTimeDate; | |
1096 | } | |
1097 | ||
1098 | /** | |
1099 | * KAS: Returns the last date and time (in UTC) the user changed | |
1100 | * its password. | |
1101 | * | |
1102 | * @return the last date and time (in UTC) the user changed its password. | |
1103 | * @exception AFSException If an error occurs in the native code | |
1104 | * @see #refresh() | |
1105 | */ | |
1106 | public int getLastChangePasswordTime() throws AFSException | |
1107 | { | |
1108 | if( !cachedInfo ) refreshInfo(); | |
1109 | return lastChangePasswordTime; | |
1110 | } | |
1111 | ||
1112 | /** | |
1113 | * KAS: Returns the maximum lifetime of a ticket issued to this user | |
1114 | * (in seconds). | |
1115 | * | |
1116 | * @return the maximum lifetime of a ticket issued to this user (in seconds). | |
1117 | * @exception AFSException If an error occurs in the native code | |
1118 | * @see #refresh() | |
1119 | */ | |
1120 | public int getMaxTicketLifetime() throws AFSException | |
1121 | { | |
1122 | if( !cachedInfo ) refreshInfo(); | |
1123 | return maxTicketLifetime; | |
1124 | } | |
1125 | ||
1126 | /** | |
1127 | * KAS: Returns the number of days a password is valid before it expires. | |
1128 | * A value of 0 indicates passwords never expire. | |
1129 | * | |
1130 | * @return the number of days for which a password is valid | |
1131 | * @exception AFSException If an error occurs in the native code | |
1132 | * @see #refresh() | |
1133 | */ | |
1134 | public int getDaysToPasswordExpire() throws AFSException | |
1135 | { | |
1136 | if( !cachedInfo ) refreshInfo(); | |
1137 | return daysToPasswordExpire; | |
1138 | } | |
1139 | ||
1140 | /** | |
1141 | * KAS: Returns the number of failed login attempts this user is allowed | |
1142 | * before being locked out. A value of 0 indicates there is no limit. | |
1143 | * | |
1144 | * @return the number of failed login attempts a user is allowed | |
1145 | * @exception AFSException If an error occurs in the native code | |
1146 | * @see #refresh() | |
1147 | */ | |
1148 | public int getFailLoginCount() throws AFSException | |
1149 | { | |
1150 | if( !cachedInfo ) refreshInfo(); | |
1151 | return failLoginCount; | |
1152 | } | |
1153 | ||
1154 | /** | |
1155 | * KAS: Returns the amount of time (in seconds) a user is locked out when | |
1156 | * it exceeds the maximum number of allowable failed login attempts. | |
1157 | * A value of 0 indicates an infinite lockout time. | |
1158 | * | |
1159 | * @return the number of failed login attempts a user is allowed | |
1160 | * @exception AFSException If an error occurs in the native code | |
1161 | * @see #refresh() | |
1162 | */ | |
1163 | public int getLockTime() throws AFSException | |
1164 | { | |
1165 | if( !cachedInfo ) refreshInfo(); | |
1166 | return lockTime; | |
1167 | } | |
1168 | ||
1169 | /** | |
1170 | * KAS: Returns the encryption key, in octal form, of this user. An | |
1171 | * example of a key in octal form is: | |
1172 | * '\040\205\211\241\345\002\023\211'. | |
1173 | * | |
1174 | * @return the encryption key | |
1175 | * @exception AFSException If an error occurs in the native code | |
1176 | * @see #refresh() | |
1177 | */ | |
1178 | public String getEncryptionKey() throws AFSException | |
1179 | { | |
1180 | if( !cachedInfo ) refreshInfo(); | |
1181 | return encryptionKey; | |
1182 | } | |
1183 | ||
1184 | /** | |
1185 | * KAS: Returns the check sum of this user's key. | |
1186 | * | |
1187 | * @return the check sum | |
1188 | * @exception AFSException If an error occurs in the native code | |
1189 | * @see #refresh() | |
1190 | */ | |
1191 | public long getKeyCheckSum() throws AFSException | |
1192 | { | |
1193 | if( !cachedInfo ) refreshInfo(); | |
1194 | return keyCheckSum; | |
1195 | } | |
1196 | ||
1197 | /** | |
1198 | * KAS: Returns the version number of the user's key. | |
1199 | * | |
1200 | * @return the key version | |
1201 | * @exception AFSException If an error occurs in the native code | |
1202 | * @see #refresh() | |
1203 | */ | |
1204 | public int getKeyVersion() throws AFSException | |
1205 | { | |
1206 | if( !cachedInfo ) refreshInfo(); | |
1207 | return keyVersion; | |
1208 | } | |
1209 | ||
1210 | /** | |
1211 | * KAS: Returns the date and time (in UTC) at which the user stops | |
1212 | * being locked out. A value of 0 indicates the user is not currently | |
1213 | * locked out. If the user is locked out forever, the value | |
1214 | * will be equal to -1. | |
1215 | * | |
1216 | * @return the date and time (in UTC) at which the user stops being | |
1217 | * locked out | |
1218 | * @exception AFSException If an error occurs in the native code | |
1219 | * @see #refresh() | |
1220 | */ | |
1221 | public int getLockedUntil() throws AFSException | |
1222 | { | |
1223 | if( !cachedInfo ) refreshInfo(); | |
1224 | return lockedUntil; | |
1225 | } | |
1226 | ||
1227 | /** | |
1228 | * KAS: Returns the date and time at which the user stops being locked out. | |
1229 | * A value of <code>null</code> indicates the user is not currently locked | |
1230 | * out. If the user is locked out forever, the value | |
1231 | * <code>getLockedUntil().getTime().getTime()</code> will be equal to -1. | |
1232 | * | |
1233 | * @return the date and time at which the user stops being locked out | |
1234 | * @exception AFSException If an error occurs in the native code | |
1235 | * @see #refresh() | |
1236 | */ | |
1237 | public GregorianCalendar getLockedUntilDate() throws AFSException | |
1238 | { | |
1239 | if( !cachedInfo ) refreshInfo(); | |
1240 | if( lockedUntilDate == null ) { | |
1241 | // make it into a date . . . | |
1242 | Date d; | |
1243 | if( lockedUntil == 0 ) { | |
1244 | lockedUntilDate = null; | |
1245 | } else if( lockedUntil == -1 ) { | |
1246 | d = new Date( lockedUntil ); | |
1247 | lockedUntilDate = new GregorianCalendar(); | |
1248 | lockedUntilDate.setTime( d ); | |
1249 | } else { | |
1250 | d = new Date( ((long) lockedUntil)*1000 ); | |
1251 | lockedUntilDate = new GregorianCalendar(); | |
1252 | lockedUntilDate.setTime( d ); | |
1253 | } | |
1254 | } | |
1255 | return lockedUntilDate; | |
1256 | } | |
1257 | ||
1258 | /////////////// mutators //////////////////// | |
1259 | ||
1260 | /** | |
1261 | * PTS: Sets how many more groups this user is allowed to create. | |
1262 | * -1 indicates unlimited. | |
1263 | * | |
1264 | * @param quota the new group creation quota | |
1265 | */ | |
1266 | public void setGroupCreationQuota( int quota ) | |
1267 | { | |
1268 | groupCreationQuota = quota; | |
1269 | } | |
1270 | ||
1271 | ||
1272 | /** | |
1273 | * PTS: Sets who can list the status (pts examine) of this user. | |
1274 | * Valid values are: | |
1275 | * <ul> | |
1276 | * <li><code>{@link #USER_OWNER_ACCESS}</code> | |
1277 | * -- only the owner has permission</li> | |
1278 | * <li><code>{@link #USER_ANYUSER_ACCESS}</code> | |
1279 | * -- any user has permission</li> | |
1280 | * </ul> | |
1281 | * | |
1282 | * @param value the value of the new list status permission | |
1283 | * @exception AFSException if an error occurs in the native code | |
1284 | * @exception IllegalArgumentException if an invalud argument is provided | |
1285 | */ | |
1286 | public void setListStatus( int value ) throws AFSException | |
1287 | { | |
1288 | if( (value != this.USER_OWNER_ACCESS) && | |
1289 | (value != this.USER_ANYUSER_ACCESS) ) { | |
1290 | throw new IllegalArgumentException( "Cannot set listStatus to " | |
1291 | + value ); | |
1292 | } else { | |
1293 | listStatus = value; | |
1294 | } | |
1295 | } | |
1296 | ||
1297 | /** | |
1298 | * PTS: Sets who can list the groups owned (pts listowned) by this user. | |
1299 | * Valid values are: | |
1300 | * <ul> | |
1301 | * <li><code>{@link #USER_OWNER_ACCESS}</code> | |
1302 | * -- only the owner has permission</li> | |
1303 | * <li><code>{@link #USER_ANYUSER_ACCESS}</code> | |
1304 | * -- any user has permission</li> | |
1305 | * </ul> | |
1306 | * | |
1307 | * @param value the value of the new list groups owned permission | |
1308 | * @exception AFSException if an error occurs in the native code | |
1309 | * @exception IllegalArgumentException if an invalud argument is provided | |
1310 | */ | |
1311 | public void setListGroupsOwned( int value ) throws AFSException | |
1312 | { | |
1313 | if( (value != this.USER_OWNER_ACCESS) && | |
1314 | (value != this.USER_ANYUSER_ACCESS) ) { | |
1315 | throw new IllegalArgumentException( "Cannot set listGroupsOwned to " | |
1316 | + value ); | |
1317 | } else { | |
1318 | listGroupsOwned = value; | |
1319 | } | |
1320 | } | |
1321 | ||
1322 | /** | |
1323 | * PTS: Sets who can list the groups (pts membership) to which this | |
1324 | * user belongs. | |
1325 | * Valid values are: | |
1326 | * <ul> | |
1327 | * <li><code>{@link #USER_OWNER_ACCESS}</code> | |
1328 | * -- only the owner has permission</li> | |
1329 | * <li><code>{@link #USER_ANYUSER_ACCESS}</code> | |
1330 | * -- any user has permission</li> | |
1331 | * </ul> | |
1332 | * | |
1333 | * @param value the value of the new list membership permission | |
1334 | * @exception AFSException if an error occurs in the native code | |
1335 | * @exception IllegalArgumentException if an invalud argument is provided | |
1336 | */ | |
1337 | public void setListMembership( int value ) throws AFSException | |
1338 | { | |
1339 | if( (value != this.USER_OWNER_ACCESS) && | |
1340 | (value != this.USER_ANYUSER_ACCESS) ) { | |
1341 | throw new IllegalArgumentException( "Cannot set listMembership to " | |
1342 | + value ); | |
1343 | } else { | |
1344 | listMembership = value; | |
1345 | } | |
1346 | } | |
1347 | ||
1348 | /** | |
1349 | * KAS: Sets whether or not this user has kas administrative privileges | |
1350 | * | |
1351 | * @param setting whether or not this user has kas | |
1352 | * administrative privileges | |
1353 | */ | |
1354 | public void setAdmin( boolean setting ) | |
1355 | { | |
1356 | if ( setting ) { | |
1357 | adminSetting = this.ADMIN; | |
1358 | } else { | |
1359 | adminSetting = this.NO_ADMIN; | |
1360 | } | |
1361 | } | |
1362 | ||
1363 | /** | |
1364 | * KAS: Sets whether or not TGS will issue tickets for this user | |
1365 | * | |
1366 | * @param setting whether or not TGS will issue tickets for this user | |
1367 | */ | |
1368 | public void setGrantTickets( boolean setting ) | |
1369 | { | |
1370 | if ( setting ) { | |
1371 | tgsSetting = this.GRANT_TICKETS; | |
1372 | } else { | |
1373 | tgsSetting = this.NO_GRANT_TICKETS; | |
1374 | } | |
1375 | } | |
1376 | ||
1377 | /** | |
1378 | * KAS: Sets whether or not TGS can use this users ticket for an | |
1379 | * encryption key | |
1380 | * | |
1381 | * @param setting whether or not TGS can use this users ticket for an | |
1382 | * encryption key | |
1383 | */ | |
1384 | public void setEncrypt( boolean setting ) | |
1385 | { | |
1386 | if ( setting ) { | |
1387 | encSetting = this.ENCRYPT; | |
1388 | } else { | |
1389 | encSetting = this.NO_ENCRYPT; | |
1390 | } | |
1391 | } | |
1392 | ||
1393 | /** | |
1394 | * KAS: Sets whether or not the user can change their password | |
1395 | * | |
1396 | * @param setting whether or not the user can change their password | |
1397 | */ | |
1398 | public void setChangePassword( boolean setting ) | |
1399 | { | |
1400 | if ( setting ) { | |
1401 | cpwSetting = this.CHANGE_PASSWORD; | |
1402 | } else { | |
1403 | cpwSetting = this.NO_CHANGE_PASSWORD; | |
1404 | } | |
1405 | } | |
1406 | ||
1407 | /** | |
1408 | * KAS: Sets whether or not the user can reuse their password | |
1409 | * | |
1410 | * @param setting whether or not the user can reuse their password | |
1411 | */ | |
1412 | public void setReusePassword( boolean setting ) | |
1413 | { | |
1414 | if ( setting ) { | |
1415 | rpwSetting = this.REUSE_PASSWORD; | |
1416 | } else { | |
1417 | rpwSetting = this.NO_REUSE_PASSWORD; | |
1418 | } | |
1419 | } | |
1420 | ||
1421 | /** | |
1422 | * KAS: Sets the date and time the user expires. | |
1423 | * A <code>null</code> value indicates the user never exipres. | |
1424 | * | |
1425 | * @param expirationDate the date and time the user expires | |
1426 | */ | |
1427 | public void setUserExpiration( GregorianCalendar expirationDate ) | |
1428 | { | |
1429 | userExpirationDate = expirationDate; | |
1430 | if( expirationDate == null ) { | |
1431 | userExpiration = -1; | |
1432 | } else { | |
1433 | Date d = expirationDate.getTime(); | |
1434 | long millis = d.getTime(); | |
1435 | userExpiration = (int) (millis/((long)1000)); | |
1436 | } | |
1437 | } | |
1438 | ||
1439 | /** | |
1440 | * KAS: Sets the maximum lifetime of a ticket issued to this user | |
1441 | * (in seconds). | |
1442 | * | |
1443 | * @param seconds the maximum lifetime of a ticket issued to this user (in seconds). | |
1444 | */ | |
1445 | public void setMaxTicketLifetime( int seconds ) | |
1446 | { | |
1447 | maxTicketLifetime = seconds; | |
1448 | } | |
1449 | ||
1450 | /** | |
1451 | * KAS: Sets the number of days a password is valid before it expires. | |
1452 | * A value of 0 indicates passwords never expire. | |
1453 | * | |
1454 | * @param days the number of days for which a password is valid | |
1455 | */ | |
1456 | public void setDaysToPasswordExpire( int days ) | |
1457 | { | |
1458 | daysToPasswordExpire = days; | |
1459 | } | |
1460 | ||
1461 | /** | |
1462 | * KAS: Sets the number of failed login attempts this user is allowed before | |
1463 | * being locked out. A value of 0 indicates there is no limit. | |
1464 | * | |
1465 | * @param logins the number of failed login attempts a user is allowed | |
1466 | */ | |
1467 | public void setFailLoginCount( int logins ) | |
1468 | { | |
1469 | failLoginCount = logins; | |
1470 | } | |
1471 | ||
1472 | /** | |
1473 | * KAS: Sets the amount of time (in seconds) a user is locked out when it | |
1474 | * exceeds the maximum number of allowable failed login attempts. | |
1475 | * A value of 0 indicates an infinite lockout time. Any nonzero value gets | |
1476 | * rounded up to the next highest multiple of 8.5 minutes, and any value over | |
1477 | * 36 hours gets rounded down to 36 hours. | |
1478 | * | |
1479 | * @param seconds the number of failed login attempts a user is allowed | |
1480 | */ | |
1481 | public void setLockTime( int seconds ) | |
1482 | { | |
1483 | lockTime = seconds; | |
1484 | } | |
1485 | ||
1486 | /** | |
1487 | * Sets the password of this user to something new. Sets the key version | |
1488 | * to 0 automatically. | |
1489 | * | |
1490 | * @param newPassword the new password for this user | |
1491 | * @exception AFSException If an error occurs in the native code | |
1492 | */ | |
1493 | public void setPassword( String newPassword ) throws AFSException | |
1494 | { | |
1495 | this.setPassword( cell.getCellHandle(), name, newPassword ); | |
1496 | } | |
1497 | ||
1498 | /////////////// custom information methods //////////////////// | |
1499 | ||
1500 | /** | |
1501 | * Returns a <code>String</code> representation of this <code>User</code>. | |
1502 | * Contains the information fields and groups. | |
1503 | * | |
1504 | * @return a <code>String</code> representation of the <code>User</code> | |
1505 | */ | |
1506 | public String getInfo() | |
1507 | { | |
1508 | String r; | |
1509 | try { | |
1510 | ||
1511 | r = "User: " + name; | |
1512 | ||
1513 | if( pts ) { | |
1514 | r += ", uid: " + getUID(); | |
1515 | } | |
1516 | r += "\n"; | |
1517 | r += "\tKAS: " + isKAS() + "\tPTS: " + isPTS() + "\n"; | |
1518 | ||
1519 | if( pts ) { | |
1520 | r += "\towner: " + getOwner().getName() + ", uid: " | |
1521 | + getOwner().getUID() + "\n"; | |
1522 | r += "\tcreator: " + getCreator().getName() + ", uid: " | |
1523 | + getCreator().getUID() + "\n"; | |
1524 | r += "\tGroup creation quota: " + getGroupCreationQuota() + "\n"; | |
1525 | r += "\tGroup membership count: " + getGroupMembershipCount() | |
1526 | + "\n"; | |
1527 | r += "\tList status: " + getListStatus() + "\n"; | |
1528 | r += "\tList groups owned: " + getListGroupsOwned() + "\n"; | |
1529 | r += "\tList membership: " + getListMembership() + "\n"; | |
1530 | } | |
1531 | ||
1532 | if( kas ) { | |
1533 | r += "\tKAS admin status: "; | |
1534 | ||
1535 | if( isAdmin() ) { | |
1536 | r += "Yes\n"; | |
1537 | } else { | |
1538 | r += "No\n"; | |
1539 | } | |
1540 | ||
1541 | r += "\tTGS grant tickets: "; | |
1542 | if( willGrantTickets() ) { | |
1543 | r += "Yes\n"; | |
1544 | } else { | |
1545 | r += "No\n"; | |
1546 | } | |
1547 | ||
1548 | r += "\tUse key as encryption key: "; | |
1549 | if( canEncrypt() ) { | |
1550 | r += "Yes\n"; | |
1551 | } else { | |
1552 | r += "No\n"; | |
1553 | } | |
1554 | ||
1555 | ||
1556 | r += "\tCan change password: "; | |
1557 | ||
1558 | if( canChangePassword() ) { | |
1559 | r += "Yes\n"; | |
1560 | } else { | |
1561 | r += "No\n"; | |
1562 | } | |
1563 | ||
1564 | r += "\tCan reuse password: "; | |
1565 | if( canReusePassword() ) { | |
1566 | r += "Yes\n"; | |
1567 | } else { | |
1568 | r += "No\n"; | |
1569 | } | |
1570 | ||
1571 | if( userExpiration != 0 ) { | |
1572 | r += "\tExpiration date: " | |
1573 | + getUserExpirationDate().getTime() + "\n"; | |
1574 | } else { | |
1575 | r += "\tUser never expires\n"; | |
1576 | } | |
1577 | r += "\tLast modified " + getLastModTimeDate().getTime() | |
1578 | + " by " + getLastModName() + "\n"; | |
1579 | r += "\tLast changed password " | |
1580 | + getLastChangePasswordTimeDate().getTime() + "\n"; | |
1581 | r += "\tMax ticket lifetime: " + getMaxTicketLifetime() + "\n"; | |
1582 | r += "\tKey: " + getEncryptionKey() + ", version: " | |
1583 | + getKeyVersion() + ", checksum: " + getKeyCheckSum() + "\n"; | |
1584 | r += "\tDays till password expires: " + getDaysToPasswordExpire() | |
1585 | + "\n"; | |
1586 | r += "\tAllowed failed logins: " + getFailLoginCount() + "\n"; | |
1587 | r += "\tLock time after failed logins: " + getLockTime() + "\n"; | |
1588 | if( lockedUntil == 0 ) { | |
1589 | r += "\tNot locked\n"; | |
1590 | } else if( getLockedUntilDate().getTime().getTime() == -1 ) { | |
1591 | r += "\tLocked forever\n"; | |
1592 | } else { | |
1593 | r += "\tLocked until: " + getLockedUntilDate().getTime() | |
1594 | + "\n"; | |
1595 | } | |
1596 | ||
1597 | } | |
1598 | if( pts ) { | |
1599 | ||
1600 | r += "\tBelongs to groups: \n"; | |
1601 | ||
1602 | String grps[] = getGroupNames(); | |
1603 | for( int i = 0; i < grps.length; i++ ) { | |
1604 | r += "\t\t" + grps[i] + "\n"; | |
1605 | } | |
1606 | ||
1607 | r += "\tOwns groups: \n"; | |
1608 | grps = getGroupsOwnedNames(); | |
1609 | for( int i = 0; i < grps.length; i++ ) { | |
1610 | r += "\t\t" + grps[i] + "\n"; | |
1611 | } | |
1612 | ||
1613 | } | |
1614 | } catch( AFSException e ) { | |
1615 | return e.toString(); | |
1616 | } | |
1617 | return r; | |
1618 | } | |
1619 | ||
1620 | /** | |
1621 | * Returns a <code>String</code> containing the <code>String</code> | |
1622 | * representations of all the groups to which this user belongs. | |
1623 | * | |
1624 | * @return a <code>String</code> representation of the groups belonged to | |
1625 | * @see Group#toString | |
1626 | */ | |
1627 | public String getInfoGroups() throws AFSException | |
1628 | { | |
1629 | String r; | |
1630 | r = "User: " + name + "\n\n"; | |
1631 | r += "--Member of Groups:--\n"; | |
1632 | ||
1633 | Group grps[] = getGroups(); | |
1634 | for( int i = 0; i < grps.length; i++ ) { | |
1635 | r += grps[i].getInfo() + "\n"; | |
1636 | } | |
1637 | return r; | |
1638 | } | |
1639 | ||
1640 | /** | |
1641 | * Returns a <code>String</code> containing the <code>String</code> | |
1642 | * representations of all the groups that this user owns. | |
1643 | * | |
1644 | * @return a <code>String</code> representation of the groups owned | |
1645 | * @see Group#toString | |
1646 | */ | |
1647 | public String getInfoGroupsOwned() throws AFSException | |
1648 | { | |
1649 | String r; | |
1650 | r = "User: " + name + "\n\n"; | |
1651 | r += "--Owns Groups:--\n"; | |
1652 | Group grps[] = getGroupsOwned(); | |
1653 | for( int i = 0; i < grps.length; i++ ) { | |
1654 | r += grps[i].getInfo() + "\n"; | |
1655 | } | |
1656 | return r; | |
1657 | } | |
1658 | ||
1659 | /////////////// custom override methods //////////////////// | |
1660 | ||
1661 | /** | |
1662 | * Compares two User objects respective to their names and does not | |
1663 | * factor any other attribute. Alphabetic case is significant in | |
1664 | * comparing names. | |
1665 | * | |
1666 | * @param user The User object to be compared to this User instance | |
1667 | * | |
1668 | * @return Zero if the argument is equal to this User's name, a | |
1669 | * value less than zero if this User's name is | |
1670 | * lexicographically less than the argument, or a value greater | |
1671 | * than zero if this User's name is lexicographically | |
1672 | * greater than the argument | |
1673 | */ | |
1674 | public int compareTo(User user) | |
1675 | { | |
1676 | return this.getName().compareTo(user.getName()); | |
1677 | } | |
1678 | ||
1679 | /** | |
1680 | * Comparable interface method. | |
1681 | * | |
1682 | * @see #compareTo(User) | |
1683 | */ | |
1684 | public int compareTo(Object obj) | |
1685 | { | |
1686 | return compareTo((User)obj); | |
1687 | } | |
1688 | ||
1689 | /** | |
1690 | * Tests whether two <code>User</code> objects are equal, based on their | |
1691 | * names. | |
1692 | * | |
1693 | * @param otherUser the user to test | |
1694 | * @return whether the specifed user is the same as this user | |
1695 | */ | |
1696 | public boolean equals( User otherUser ) | |
1697 | { | |
1698 | return name.equals(otherUser.getName()); | |
1699 | } | |
1700 | ||
1701 | /** | |
1702 | * Returns the name of this <CODE>User</CODE> | |
1703 | * | |
1704 | * @return the name of this <CODE>User</CODE> | |
1705 | */ | |
1706 | public String toString() | |
1707 | { | |
1708 | return getName(); | |
1709 | } | |
1710 | ||
1711 | ||
1712 | /////////////// native methods //////////////////// | |
1713 | ||
1714 | /** | |
1715 | * Creates the kas and pts entries for a new user. Pass in 0 for the uid | |
1716 | * if pts is to automatically assign the user id. | |
1717 | * | |
1718 | * @param cellHandle the handle of the cell to which the user belongs | |
1719 | * @see Cell#getCellHandle | |
1720 | * @param userName the name of the user to create | |
1721 | * @param password the password for the new user | |
1722 | * @param uid the user id to assign to the user (0 to have one | |
1723 | * automatically assigned) | |
1724 | * @exception AFSException If an error occurs in the native code | |
1725 | */ | |
1726 | protected static native void create( long cellHandle, String userName, | |
1727 | String password, int uid ) | |
1728 | throws AFSException; | |
1729 | ||
1730 | /** | |
1731 | * Deletes the pts and kas entry for a user. Deletes this user from the | |
1732 | * membership list of the groups to which it belonged, but does not delete | |
1733 | * the groups owned by this user. | |
1734 | * | |
1735 | * @param cellHandle the handle of the cell to which the user belongs | |
1736 | * @see Cell#getCellHandle | |
1737 | * @param groupName the name of the user to delete | |
1738 | * @exception AFSException If an error occurs in the native code | |
1739 | */ | |
1740 | protected static native void delete( long cellHandle, String userName ) | |
1741 | throws AFSException; | |
1742 | ||
1743 | /** | |
1744 | * Unlocks a user. | |
1745 | * | |
1746 | * @param cellHandle the handle of the cell to which the user belongs | |
1747 | * @see Cell#getCellHandle | |
1748 | * @param groupName the name of the user to unlock | |
1749 | * @exception AFSException If an error occurs in the native code | |
1750 | */ | |
1751 | protected static native void unlock( long cellHandle, String userName ) | |
1752 | throws AFSException; | |
1753 | ||
1754 | /** | |
1755 | * Fills in the information fields of the provided <code>User</code>. | |
1756 | * Fills in values based on the current pts and kas information of the user. | |
1757 | * | |
1758 | * @param cellHandle the handle of the cell to which the user belongs | |
1759 | * @see Cell#getCellHandle | |
1760 | * @param name the name of the user for which to get the information | |
1761 | * @param user the <code>User</code> object in which to fill in the | |
1762 | * information | |
1763 | * @see User | |
1764 | * @exception AFSException If an error occurs in the native code | |
1765 | */ | |
1766 | protected static native void getUserInfo( long cellHandle, String name, | |
1767 | User user ) | |
1768 | throws AFSException; | |
1769 | ||
1770 | /** | |
1771 | * Sets the information values of this AFS user to be the parameter values. | |
1772 | * Sets both kas and pts fields. | |
1773 | * | |
1774 | * @param cellHandle the handle of the cell to which the user belongs | |
1775 | * @see Cell#getCellHandle | |
1776 | * @param name the name of the user for which to set the information | |
1777 | * @param theUser the <code>User</code> object containing the desired | |
1778 | * information | |
1779 | * @exception AFSException If an error occurs in the native code | |
1780 | */ | |
1781 | protected static native void setUserInfo( long cellHandle, String name, | |
1782 | User theUser ) | |
1783 | throws AFSException; | |
1784 | ||
1785 | /** | |
1786 | * Renames the given user. Does not update the info fields of the kas entry | |
1787 | * -- the calling code is responsible for that. | |
1788 | * | |
1789 | * @param cellHandle the handle of the cell to which the user belongs | |
1790 | * @see Cell#getCellHandle | |
1791 | * @param oldName the name of the user to rename | |
1792 | * @param newName the new name for the user | |
1793 | * @exception AFSException If an error occurs in the native code | |
1794 | */ | |
1795 | protected static native void rename( long cellHandle, String oldName, | |
1796 | String newName ) | |
1797 | throws AFSException; | |
1798 | ||
1799 | /** | |
1800 | * Sets the password of the given user. Sets the key version to 0. | |
1801 | * | |
1802 | * @param cellHandle the handle of the cell to which the user belongs | |
1803 | * @see Cell#getCellHandle | |
1804 | * @param userName the name of the user for which to set the password | |
1805 | * @param newPassword the new password for the user | |
1806 | * @exception AFSException If an error occurs in the native code | |
1807 | */ | |
1808 | protected static native void setPassword( long cellHandle, String userName, | |
1809 | String newPassword ) | |
1810 | throws AFSException; | |
1811 | ||
1812 | /** | |
1813 | * Begin the process of getting the groups to which the user belongs. | |
1814 | * Returns an iteration ID to be used by subsequent calls to | |
1815 | * <code>getUserGroupsNext</code> and <code>getUserGroupsDone</code>. | |
1816 | * | |
1817 | * @param cellHandle the handle of the cell to which the user belongs | |
1818 | * @see Cell#getCellHandle | |
1819 | * @param name the name of the user for which to get the groups | |
1820 | * @return an iteration ID | |
1821 | * @exception AFSException If an error occurs in the native code | |
1822 | */ | |
1823 | protected static native long getUserGroupsBegin( long cellHandle, String name ) | |
1824 | throws AFSException; | |
1825 | ||
1826 | /** | |
1827 | * Returns the next group to which the user belongs. Returns | |
1828 | * <code>null</code> if there are no more groups. | |
1829 | * | |
1830 | * @param iterationId the iteration ID of this iteration | |
1831 | * @see getUserGroupsBegin | |
1832 | * @return the name of the next group | |
1833 | * @exception AFSException If an error occurs in the native code | |
1834 | */ | |
1835 | protected static native String getUserGroupsNextString( long iterationId ) | |
1836 | throws AFSException; | |
1837 | ||
1838 | /** | |
1839 | * Fills the next group object of which the user belongs. Returns 0 if there | |
1840 | * are no more groups, != 0 otherwise. | |
1841 | * | |
1842 | * @param cellHandle the handle of the cell to which the users belong | |
1843 | * @see Cell#getCellHandle | |
1844 | * @param iterationId the iteration ID of this iteration | |
1845 | * @see getUserGroupsBegin | |
1846 | * @param theGroup a Group object to be populated with the values of the | |
1847 | * next group | |
1848 | * @return 0 if there are no more users, != 0 otherwise | |
1849 | * @exception AFSException If an error occurs in the native code | |
1850 | */ | |
1851 | protected static native int getUserGroupsNext( long cellHandle, | |
1852 | long iterationId, | |
1853 | Group theGroup ) | |
1854 | throws AFSException; | |
1855 | ||
1856 | /** | |
1857 | * Signals that the iteration is complete and will not be accessed anymore. | |
1858 | * | |
1859 | * @param iterationId the iteration ID of this iteration | |
1860 | * @see getUserGroupsBegin | |
1861 | * @exception AFSException If an error occurs in the native code | |
1862 | */ | |
1863 | protected static native void getUserGroupsDone( long iterationId ) | |
1864 | throws AFSException; | |
1865 | ||
1866 | /** | |
1867 | * Returns the total number of groups owned by the user. | |
1868 | * | |
1869 | * @param cellHandle the handle of the cell to which the user belongs | |
1870 | * @param name the name of the user for which to get the groups | |
1871 | * @return total number of groups owned by the user | |
1872 | * @exception AFSException If an error occurs in the native code | |
1873 | * @see Cell#getCellHandle | |
1874 | */ | |
1875 | protected static native int getGroupsOwnedCount( long cellHandle, String name ) | |
1876 | throws AFSException; | |
1877 | ||
1878 | /** | |
1879 | * Begin the process of getting the groups that a user or group owns. | |
1880 | * Returns an iteration ID to be used by subsequent calls to | |
1881 | * <code>getGroupsOwnedNext</code> and <code>getGroupsOwnedDone</code>. | |
1882 | * | |
1883 | * @param cellHandle the handle of the cell to which the user belongs | |
1884 | * @see Cell#getCellHandle | |
1885 | * @param name the name of the user or group for which to get the groups | |
1886 | * @return an iteration ID | |
1887 | * @exception AFSException If an error occurs in the native code | |
1888 | */ | |
1889 | protected static native long getGroupsOwnedBegin( long cellHandle, | |
1890 | String name ) | |
1891 | throws AFSException; | |
1892 | ||
1893 | /** | |
1894 | * Returns the next group the user or group owns. Returns <code>null</code> | |
1895 | * if there are no more groups. | |
1896 | * | |
1897 | * @param iterationId the iteration ID of this iteration | |
1898 | * @see getGroupsOwnedBegin | |
1899 | * @return the name of the next group | |
1900 | * @exception AFSException If an error occurs in the native code | |
1901 | */ | |
1902 | protected static native String getGroupsOwnedNextString( long iterationId ) | |
1903 | throws AFSException; | |
1904 | ||
1905 | /** | |
1906 | * Fills the next group object that the user or group owns. Returns 0 if | |
1907 | * there are no more groups, != 0 otherwise. | |
1908 | * | |
1909 | * @param cellHandle the handle of the cell to which the users belong | |
1910 | * @see Cell#getCellHandle | |
1911 | * @param iterationId the iteration ID of this iteration | |
1912 | * @see getGroupsOwnedBegin | |
1913 | * @param theGroup a Group object to be populated with the values of the | |
1914 | * next group | |
1915 | * @return 0 if there are no more users, != 0 otherwise | |
1916 | * @exception AFSException If an error occurs in the native code | |
1917 | */ | |
1918 | protected static native int getGroupsOwnedNext( long cellHandle, | |
1919 | long iterationId, | |
1920 | Group theGroup ) | |
1921 | throws AFSException; | |
1922 | ||
1923 | /** | |
1924 | * Signals that the iteration is complete and will not be accessed anymore. | |
1925 | * | |
1926 | * @param iterationId the iteration ID of this iteration | |
1927 | * @see getGroupsOwnedBegin | |
1928 | * @exception AFSException If an error occurs in the native code | |
1929 | */ | |
1930 | protected static native void getGroupsOwnedDone( long iterationId ) | |
1931 | throws AFSException; | |
1932 | ||
1933 | /** | |
1934 | * Reclaims all memory being saved by the user portion of the native library. | |
1935 | * This method should be called when no more <code>Users</code> are expected | |
1936 | * to be used. | |
1937 | */ | |
1938 | protected static native void reclaimUserMemory(); | |
1939 | } | |
1940 | ||
1941 | ||
1942 | ||
1943 | ||
1944 | ||
1945 | ||
1946 | ||
1947 | ||
1948 |