libadmin: minor warning fix
[openafs.git] / src / libadmin / test / kas.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * This file implements the kas related funtions for afscp
12  */
13
14 #include <afsconfig.h>
15 #include <afs/param.h>
16
17 #include <roken.h>
18
19 #include "kas.h"
20 #include <time.h>
21
22 /*
23  * Utility functions
24  */
25
26 /*
27  * Generic fuction for converting input string to an integer.  Pass
28  * the error_msg you want displayed if there is an error converting
29  * the string.
30  */
31
32 static int
33 GetIntFromString(const char *int_str, const char *error_msg)
34 {
35     int i;
36     char *bad_char = NULL;
37
38     i = strtoul(int_str, &bad_char, 10);
39     if ((bad_char == NULL) || (*bad_char == 0)) {
40         return i;
41     }
42
43     ERR_EXT(error_msg);
44 }
45
46 int
47 DoKasPrincipalCreate(struct cmd_syndesc *as, void *arock)
48 {
49     typedef enum { PRINCIPAL, INSTANCE,
50         PASSWORD
51     } DoKasPrincipalCreate_parm_t;
52     afs_status_t st = 0;
53     kas_identity_t user;
54     const char *password;
55
56     strcpy(user.principal, as->parms[PRINCIPAL].items->data);
57
58     if (as->parms[INSTANCE].items) {
59         strcpy(user.instance, as->parms[INSTANCE].items->data);
60     } else {
61         user.instance[0] = 0;
62     }
63
64     password = as->parms[PASSWORD].items->data;
65
66     if (!kas_PrincipalCreate(cellHandle, 0, &user, password, &st)) {
67         ERR_ST_EXT("kas_PrincipalCreate", st);
68     }
69
70     return 0;
71 }
72
73 int
74 DoKasPrincipalDelete(struct cmd_syndesc *as, void *arock)
75 {
76     typedef enum { PRINCIPAL, INSTANCE } DoKasPrincipalGet_parm_t;
77     afs_status_t st = 0;
78     kas_identity_t user;
79
80     strcpy(user.principal, as->parms[PRINCIPAL].items->data);
81
82     if (as->parms[INSTANCE].items) {
83         strcpy(user.instance, as->parms[PRINCIPAL].items->data);
84     } else {
85         user.instance[0] = 0;
86     }
87
88     if (!kas_PrincipalDelete(cellHandle, 0, &user, &st)) {
89         ERR_ST_EXT("kas_PrincipalDelete", st);
90     }
91
92     return 0;
93 }
94
95 static void
96 Print_kas_principalEntry_p(kas_principalEntry_p principal, const char *prefix)
97 {
98     int i;
99
100     if (principal->adminSetting == KAS_ADMIN) {
101         printf("%sAdmin setting: KAS_ADMIN\n", prefix);
102     } else {
103         printf("%sAdmin setting: NO_KAS_ADMIN\n", prefix);
104     }
105
106     if (principal->tgsSetting == TGS) {
107         printf("%sTGS setting: TGS\n", prefix);
108     } else {
109         printf("%sTGS setting: NO_TGS\n", prefix);
110     }
111
112     if (principal->encSetting == ENCRYPT) {
113         printf("%sEncrypt setting: ENCRYPT\n", prefix);
114     } else {
115         printf("%sEncrypt setting: NO_ENCRYPT\n", prefix);
116     }
117
118     if (principal->cpwSetting == CHANGE_PASSWORD) {
119         printf("%sChange password setting: CHANGE_PASSWORD\n", prefix);
120     } else {
121         printf("%sChange password setting: NO_CHANGE_PASSWORD\n", prefix);
122     }
123
124     if (principal->rpwSetting == REUSE_PASSWORD) {
125         printf("%sReuse password setting: REUSE_PASSWORD\n", prefix);
126     } else {
127         printf("%sReuse password setting: NO_REUSE_PASSWORD\n", prefix);
128     }
129
130     printf("%sExpiration: %u\n", prefix, principal->userExpiration);
131     printf("%sLast modification time %u\n", prefix, principal->lastModTime);
132     printf("%sLast modifying principal %s", prefix,
133            principal->lastModPrincipal.principal);
134     if (principal->lastModPrincipal.instance[0] != 0) {
135         printf(".%s\n", principal->lastModPrincipal.instance);
136     } else {
137         printf("\n");
138     }
139
140     printf("%sLast change password time %u\n", prefix,
141            principal->lastChangePasswordTime);
142     printf("%sMax ticket lifetime %d\n", prefix,
143            principal->maxTicketLifetime);
144     printf("%sKey version number %d\n", prefix, principal->keyVersion);
145
146     printf("%sKey contents :", prefix);
147     for (i = 0; i < KAS_ENCRYPTION_KEY_LEN; i++) {
148         printf("%d ", principal->key.key[i]);
149     }
150     printf("\n");
151
152     printf("%sKey checksum %u\n", prefix, principal->keyCheckSum);
153     printf("%sDays to password expire %d\n", prefix,
154            principal->daysToPasswordExpire);
155     printf("%sFailed login count %d\n", prefix, principal->failLoginCount);
156     printf("%sLock time %d\n", prefix, principal->lockTime);
157 }
158
159 int
160 DoKasPrincipalGet(struct cmd_syndesc *as, void *arock)
161 {
162     typedef enum { PRINCIPAL, INSTANCE } DoKasPrincipalGet_parm_t;
163     afs_status_t st = 0;
164     kas_identity_t user;
165     kas_principalEntry_t principal;
166
167     strcpy(user.principal, as->parms[PRINCIPAL].items->data);
168
169     if (as->parms[INSTANCE].items) {
170         strcpy(user.instance, as->parms[PRINCIPAL].items->data);
171     } else {
172         user.instance[0] = 0;
173     }
174
175     if (!kas_PrincipalGet(cellHandle, 0, &user, &principal, &st)) {
176         ERR_ST_EXT("kas_PrincipalGet", st);
177     }
178
179     Print_kas_principalEntry_p(&principal, "");
180
181     return 0;
182 }
183
184 int
185 DoKasPrincipalList(struct cmd_syndesc *as, void *arock)
186 {
187     afs_status_t st = 0;
188     void *iter;
189     kas_identity_t prin;
190
191     if (!kas_PrincipalGetBegin(cellHandle, 0, &iter, &st)) {
192         ERR_ST_EXT("kas_PrincipalGetBegin", st);
193     }
194
195     printf("Listing principals:\n");
196     while (kas_PrincipalGetNext(iter, &prin, &st)) {
197         printf("%s", prin.principal);
198         if (prin.instance[0] != 0) {
199             printf(".%s\n", prin.instance);
200         } else {
201             printf("\n");
202         }
203     }
204
205     if (st != ADMITERATORDONE) {
206         ERR_ST_EXT("kas_PrincipalGetNext", st);
207     }
208
209     if (!kas_PrincipalGetDone(iter, &st)) {
210         ERR_ST_EXT("kas_PrincipalGetDone", st);
211     }
212
213     return 0;
214 }
215
216 int
217 DoKasPrincipalKeySet(struct cmd_syndesc *as, void *arock)
218 {
219     typedef enum { PRINCIPAL, INSTANCE, PASSWORD,
220         KEYVERSION
221     } DoKasPrincipalKeySet_parm_t;
222     afs_status_t st = 0;
223     kas_encryptionKey_t key;
224     kas_identity_t user;
225     int key_version;
226     const char *cell;
227     const char *password;
228
229     strcpy(user.principal, as->parms[PRINCIPAL].items->data);
230
231     if (as->parms[INSTANCE].items) {
232         strcpy(user.instance, as->parms[INSTANCE].items->data);
233     } else {
234         user.instance[0] = 0;
235     }
236
237     if (!afsclient_CellNameGet(cellHandle, &cell, &st)) {
238         ERR_ST_EXT("afsclient_CellNameGet", st);
239     }
240
241     password = as->parms[PASSWORD].items->data;
242     key_version =
243         GetIntFromString(as->parms[KEYVERSION].items->data,
244                          "invalid key version number");
245     if (!kas_StringToKey(cell, password, &key, &st)) {
246         ERR_ST_EXT("kas_StringToKey", st);
247     }
248
249     if (!kas_PrincipalKeySet(cellHandle, 0, &user, key_version, &key, &st)) {
250         ERR_ST_EXT("kas_PrincipalKeySet", st);
251     }
252
253     return 0;
254 }
255
256 int
257 DoKasPrincipalLockStatusGet(struct cmd_syndesc *as, void *arock)
258 {
259     typedef enum { PRINCIPAL, INSTANCE } DoKasPrincipalLockStatusGet_parm_t;
260     afs_status_t st = 0;
261     kas_identity_t user;
262     unsigned int lock_end_time = 0;
263
264     strcpy(user.principal, as->parms[PRINCIPAL].items->data);
265
266     if (as->parms[INSTANCE].items) {
267         strcpy(user.instance, as->parms[INSTANCE].items->data);
268     } else {
269         user.instance[0] = 0;
270     }
271
272     if (!kas_PrincipalLockStatusGet
273         (cellHandle, 0, &user, &lock_end_time, &st)) {
274         ERR_ST_EXT("kas_PrincipalLockStatusGet", st);
275     }
276
277     printf("The lock end time is %u\n", lock_end_time);
278
279     return 0;
280 }
281
282 int
283 DoKasPrincipalUnlock(struct cmd_syndesc *as, void *arock)
284 {
285     typedef enum { PRINCIPAL, INSTANCE } DoKasPrincipalUnlock_parm_t;
286     afs_status_t st = 0;
287     kas_identity_t user;
288
289     strcpy(user.principal, as->parms[PRINCIPAL].items->data);
290
291     if (as->parms[INSTANCE].items) {
292         strcpy(user.instance, as->parms[INSTANCE].items->data);
293     } else {
294         user.instance[0] = 0;
295     }
296
297     if (!kas_PrincipalUnlock(cellHandle, 0, &user, &st)) {
298         ERR_ST_EXT("kas_PrincipalUnlock", st);
299     }
300
301     return 0;
302 }
303
304 int
305 DoKasPrincipalFieldsSet(struct cmd_syndesc *as, void *arock)
306 {
307     typedef enum { PRINCIPAL, INSTANCE, ADMIN, NOADMIN, GRANTTICKET,
308         NOGRANTTICKET, ENCRYPT2, NOENCRYPT, CHANGEPASSWORD,
309         NOCHANGEPASSWORD, REUSEPASSWORD, NOREUSEPASSWORD,
310         EXPIRES, MAXTICKETLIFETIME, PASSWORDEXPIRES,
311         FAILEDPASSWORDATTEMPTS, FAILEDPASSWORDLOCKTIME
312     } DoKasPrincipalFieldsSet_parm_t;
313     afs_status_t st = 0;
314     kas_identity_t user;
315     kas_admin_t admin;
316     kas_admin_p admin_ptr = NULL;
317     int have_admin = 0;
318     kas_tgs_t tgs;
319     kas_tgs_p tgs_ptr = NULL;
320     int have_tgs = 0;
321     kas_enc_t enc;
322     kas_enc_p enc_ptr = NULL;
323     int have_enc = 0;
324     kas_cpw_t cpw;
325     kas_cpw_p cpw_ptr = NULL;
326     int have_cpw = 0;
327     kas_rpw_t reuse;
328     kas_rpw_p reuse_ptr = NULL;
329     int have_reuse = 0;
330     unsigned int expire;
331     unsigned int *expire_ptr = NULL;
332     int have_expire = 0;
333     unsigned int max_ticket;
334     unsigned int *max_ticket_ptr = NULL;
335     int have_max_ticket = 0;
336     unsigned int password_expire;
337     unsigned int *password_expire_ptr = NULL;
338     int have_password_expire = 0;
339     unsigned int failed_password_attempts;
340     unsigned int *failed_password_attempts_ptr = NULL;
341     int have_failed_password_attempts = 0;
342     unsigned int failed_password_lock_time;
343     unsigned int *failed_password_lock_time_ptr = NULL;
344     int have_failed_password_lock_time = 0;
345
346     strcpy(user.principal, as->parms[PRINCIPAL].items->data);
347
348     if (as->parms[INSTANCE].items) {
349         strcpy(user.instance, as->parms[INSTANCE].items->data);
350     } else {
351         user.instance[0] = 0;
352     }
353
354     if (as->parms[ADMIN].items) {
355         admin = KAS_ADMIN;
356         admin_ptr = &admin;
357         have_admin = 1;
358     }
359
360     if (as->parms[NOADMIN].items) {
361         admin = NO_KAS_ADMIN;
362         admin_ptr = &admin;
363         if (have_admin) {
364             ERR_EXT("specify either admin or noadmin, not both");
365         }
366         have_admin = 1;
367     }
368
369     if (as->parms[GRANTTICKET].items) {
370         tgs = TGS;
371         tgs_ptr = &tgs;
372         have_tgs = 1;
373     }
374
375     if (as->parms[NOGRANTTICKET].items) {
376         tgs = NO_TGS;
377         tgs_ptr = &tgs;
378         if (have_tgs) {
379             ERR_EXT("specify either grantticket or nograntticket, not both");
380         }
381         have_tgs = 1;
382     }
383
384     if (as->parms[ENCRYPT2].items) {
385         enc = ENCRYPT;
386         enc_ptr = &enc;
387         have_enc = 1;
388     }
389
390     if (as->parms[NOENCRYPT].items) {
391         enc = NO_ENCRYPT;
392         enc_ptr = &enc;
393         if (have_tgs) {
394             ERR_EXT("specify either encrypt or noencrypt, not both");
395         }
396         have_enc = 1;
397     }
398
399     if (as->parms[CHANGEPASSWORD].items) {
400         cpw = CHANGE_PASSWORD;
401         cpw_ptr = &cpw;
402         have_cpw = 1;
403     }
404
405     if (as->parms[NOCHANGEPASSWORD].items) {
406         cpw = NO_CHANGE_PASSWORD;
407         cpw_ptr = &cpw;
408         if (have_tgs) {
409             ERR_EXT("specify either changepassword or "
410                     "nochangepassword, not both");
411         }
412         have_cpw = 1;
413     }
414
415     if (as->parms[REUSEPASSWORD].items) {
416         reuse = REUSE_PASSWORD;
417         reuse_ptr = &reuse;
418         have_reuse = 1;
419     }
420
421     if (as->parms[REUSEPASSWORD].items) {
422         reuse = NO_REUSE_PASSWORD;
423         reuse_ptr = &reuse;
424         if (have_reuse) {
425             ERR_EXT("specify either reusepassword or "
426                     "noreusepassword, not both");
427         }
428         have_reuse = 1;
429     }
430
431     if (as->parms[EXPIRES].items) {
432         expire =
433             GetIntFromString(as->parms[EXPIRES].items->data,
434                              "bad expiration date");
435         expire_ptr = &expire;
436         have_expire = 1;
437     }
438
439     if (as->parms[MAXTICKETLIFETIME].items) {
440         max_ticket =
441             GetIntFromString(as->parms[MAXTICKETLIFETIME].items->data,
442                              "bad max ticket lifetime");
443         max_ticket_ptr = &max_ticket;
444         have_max_ticket = 1;
445     }
446
447     if (as->parms[PASSWORDEXPIRES].items) {
448         password_expire =
449             GetIntFromString(as->parms[PASSWORDEXPIRES].items->data,
450                              "bad expiration date");
451         password_expire_ptr = &password_expire;
452         have_password_expire = 1;
453     }
454
455     if (as->parms[FAILEDPASSWORDATTEMPTS].items) {
456         failed_password_attempts =
457             GetIntFromString(as->parms[FAILEDPASSWORDATTEMPTS].items->data,
458                              "bad expiration date");
459         failed_password_attempts_ptr = &failed_password_attempts;
460         have_failed_password_attempts = 1;
461     }
462
463     if (as->parms[FAILEDPASSWORDLOCKTIME].items) {
464         failed_password_lock_time =
465             GetIntFromString(as->parms[FAILEDPASSWORDLOCKTIME].items->data,
466                              "bad expiration date");
467         failed_password_lock_time_ptr = &failed_password_lock_time;
468         have_failed_password_lock_time = 1;
469     }
470
471     if ((have_admin + have_tgs + have_enc + have_cpw + have_reuse +
472          have_expire + have_max_ticket + have_password_expire +
473          have_failed_password_attempts + have_failed_password_lock_time) ==
474         0) {
475         ERR_EXT("You must specify at least one attribute to change");
476     }
477
478     if (!kas_PrincipalFieldsSet
479         (cellHandle, 0, &user, admin_ptr, tgs_ptr, enc_ptr, cpw_ptr,
480          expire_ptr, max_ticket_ptr, password_expire_ptr, reuse_ptr,
481          failed_password_attempts_ptr, failed_password_lock_time_ptr, &st)) {
482         ERR_ST_EXT("kas_PrincipalFieldsSet", st);
483     }
484
485     return 0;
486 }
487
488 static void
489 Print_kas_serverStats_p(kas_serverStats_p stats, const char *prefix)
490 {
491     time_t stime = stats->serverStartTime;
492
493     printf("%sAllocations %d\n", prefix, stats->allocations);
494     printf("%sFrees %d\n", prefix, stats->frees);
495     printf("%sChange password requests %d\n", prefix,
496            stats->changePasswordRequests);
497     printf("%sAdmin accounts %d\n", prefix, stats->adminAccounts);
498     printf("%sHost %x\n", prefix, stats->host);
499     printf("%sServer start time %s\n", prefix, ctime(&stime));
500     printf("%sUser time %ld secs %ld usec\n", prefix, stats->userTime.tv_sec,
501            (long) stats->userTime.tv_usec);
502     printf("%sSystem time %ld secs %ld usec\n", prefix,
503            stats->systemTime.tv_sec, (long) stats->systemTime.tv_usec);
504     printf("%sData size %d\n", prefix, stats->dataSize);
505     printf("%sStack size %d\n", prefix, stats->stackSize);
506     printf("%sPage faults %d\n", prefix, stats->pageFaults);
507     printf("%sHash table utilization %d\n", prefix,
508            stats->hashTableUtilization);
509     printf("%sAuthentication requests %d aborts %d\n", prefix,
510            stats->authenticate.requests, stats->authenticate.aborts);
511     printf("%sChange password requests %d aborts %d\n", prefix,
512            stats->changePassword.requests, stats->changePassword.aborts);
513     printf("%sGet ticket requests %d aborts %d\n", prefix,
514            stats->getTicket.requests, stats->getTicket.aborts);
515     printf("%sCreate user requests %d aborts %d\n", prefix,
516            stats->createUser.requests, stats->createUser.aborts);
517     printf("%sSet password requests %d aborts %d\n", prefix,
518            stats->setPassword.requests, stats->setPassword.aborts);
519     printf("%sSet fields requests %d aborts %d\n", prefix,
520            stats->setFields.requests, stats->setFields.aborts);
521     printf("%sDelete user requests %d aborts %d\n", prefix,
522            stats->deleteUser.requests, stats->deleteUser.aborts);
523     printf("%sGet entry requests %d aborts %d\n", prefix,
524            stats->getEntry.requests, stats->getEntry.aborts);
525     printf("%sList entry requests %d aborts %d\n", prefix,
526            stats->listEntry.requests, stats->listEntry.aborts);
527     printf("%sGet stats requests %d aborts %d\n", prefix,
528            stats->getStats.requests, stats->getStats.aborts);
529     printf("%sGet password requests %d aborts %d\n", prefix,
530            stats->getPassword.requests, stats->getPassword.aborts);
531     printf("%sGet random key requests %d aborts %d\n", prefix,
532            stats->getRandomKey.requests, stats->getRandomKey.aborts);
533     printf("%sDebug requests %d aborts %d\n", prefix, stats->debug.requests,
534            stats->debug.aborts);
535     printf("%sUDP authenticate requests %d aborts %d\n", prefix,
536            stats->udpAuthenticate.requests, stats->udpAuthenticate.aborts);
537     printf("%sUDP get ticket requests %d aborts %d\n", prefix,
538            stats->udpGetTicket.requests, stats->udpGetTicket.aborts);
539     printf("%sUnlock requests %d aborts %d\n", prefix, stats->unlock.requests,
540            stats->unlock.aborts);
541     printf("%sLock status requests %d aborts %d\n", prefix,
542            stats->lockStatus.requests, stats->lockStatus.aborts);
543     printf("%sString checks %d\n", prefix, stats->stringChecks);
544 }
545
546 int
547 DoKasServerStatsGet(struct cmd_syndesc *as, void *arock)
548 {
549     typedef enum { SERVER } DoKasServerStatsGet_parm_t;
550     afs_status_t st = 0;
551     const char *server_list[2] = { 0, 0 };
552     void *kas_server = NULL;
553     kas_serverStats_t stats;
554
555     if (as->parms[SERVER].items) {
556         server_list[0] = as->parms[SERVER].items->data;
557     }
558
559     if (!kas_ServerOpen(cellHandle, server_list, &kas_server, &st)) {
560         ERR_ST_EXT("kas_ServerOpen", st);
561     }
562
563     if (!kas_ServerStatsGet(0, kas_server, &stats, &st)) {
564         ERR_ST_EXT("kas_ServerStatsGet", st);
565     }
566
567     Print_kas_serverStats_p(&stats, "");
568
569     kas_ServerClose(kas_server, 0);
570
571     return 0;
572 }
573
574 static void
575 Print_kas_serverDebugInfo_p(kas_serverDebugInfo_p debug, const char *prefix)
576 {
577     time_t time;
578     int i;
579
580     printf("%sHost %x\n", prefix, debug->host);
581     time = debug->serverStartTime;
582     printf("%sServer start time %s\n", prefix, ctime(&time));
583     time = debug->currentTime;
584     printf("%sCurrent time %s\n", prefix, ctime(&time));
585     printf("%sNo auth %d\n", prefix, debug->noAuth);
586     time = debug->lastTransaction;
587     printf("%sLast transaction %s\n", prefix, ctime(&time));
588     printf("%sLast operation %s\n", prefix, debug->lastOperation);
589     printf("%sLast principal auth %s\n", prefix, debug->lastPrincipalAuth);
590     printf("%sLast principal UDP auth %s\n", prefix,
591            debug->lastPrincipalUDPAuth);
592     printf("%sLast principal TGS auth %s\n", prefix, debug->lastPrincipalTGS);
593     printf("%sLast principal UDP TGS auth %s\n", prefix,
594            debug->lastPrincipalUDPTGS);
595     printf("%sLast principal admin %s\n", prefix, debug->lastPrincipalAdmin);
596     printf("%sLast server TGS %s\n", prefix, debug->lastServerTGS);
597     printf("%sLast server UDP TGS %s\n", prefix, debug->lastServerUDPTGS);
598     time = debug->nextAutoCheckPointWrite;
599     printf("%sNext auto check point write %s\n", prefix, ctime(&time));
600     printf("%sUpdates remaining before ACPW %d\n", prefix,
601            debug->updatesRemainingBeforeAutoCheckPointWrite);
602     time = debug->dbHeaderRead;
603     printf("%sDatabase header read %s\n", prefix, ctime(&time));
604     printf("%sDatabase version %d\n", prefix, debug->dbVersion);
605     printf("%sDatabase free ptr %d\n", prefix, debug->dbFreePtr);
606     printf("%sDatabase EOF ptr %d\n", prefix, debug->dbEOFPtr);
607     printf("%sDatabase kvno ptr %d\n", prefix, debug->dbKvnoPtr);
608     printf("%sDatabase special keys version%d\n", prefix,
609            debug->dbSpecialKeysVersion);
610     printf("%sDatabase header lock %d\n", prefix, debug->dbHeaderLock);
611     printf("%sKey cache lock %d\n", prefix, debug->keyCacheLock);
612     printf("%sKey cache version %d\n", prefix, debug->keyCacheVersion);
613     printf("%sKey cache size %d\n", prefix, debug->keyCacheSize);
614     printf("%sKey cache used %d\n", prefix, debug->keyCacheUsed);
615
616     printf("%sKey cache\n", prefix);
617
618     for (i = 0; i < debug->keyCacheUsed; i++) {
619         printf("%s\tPrincipal %s\n", prefix, debug->keyCache[i].principal);
620         time = debug->keyCache[i].lastUsed;
621         printf("%s\tLast used %s\n", prefix, ctime(&time));
622         printf("%s\tVersion number %d\n", prefix,
623                debug->keyCache[i].keyVersionNumber);
624         printf("%s\tPrimary %d\n", prefix, debug->keyCache[i].primary);
625         printf("%s\tCheck sum %d\n", prefix, debug->keyCache[i].keyCheckSum);
626         printf("\n");
627     }
628
629 }
630
631 int
632 DoKasServerDebugGet(struct cmd_syndesc *as, void *arock)
633 {
634     typedef enum { SERVER } DoKasServerDebugGet_parm_t;
635     afs_status_t st = 0;
636     const char *server_list[2] = { 0, 0 };
637     void *kas_server = NULL;
638     kas_serverDebugInfo_t debug;
639
640     if (as->parms[SERVER].items) {
641         server_list[0] = as->parms[SERVER].items->data;
642     }
643
644     if (!kas_ServerOpen(cellHandle, server_list, &kas_server, &st)) {
645         ERR_ST_EXT("kas_ServerOpen", st);
646     }
647
648     if (!kas_ServerDebugGet(0, kas_server, &debug, &st)) {
649         ERR_ST_EXT("kas_ServerDebugGet", st);
650     }
651
652     Print_kas_serverDebugInfo_p(&debug, "");
653
654     kas_ServerClose(kas_server, 0);
655
656     return 0;
657 }
658
659 int
660 DoKasServerRandomKeyGet(struct cmd_syndesc *as, void *arock)
661 {
662     afs_status_t st = 0;
663     kas_encryptionKey_t key;
664     int i;
665
666     if (!kas_ServerRandomKeyGet(cellHandle, 0, &key, &st)) {
667         ERR_ST_EXT("kas_ServerRandomKeyGet", st);
668     }
669
670     printf("Key: ");
671     for (i = 0; i < KAS_ENCRYPTION_KEY_LEN; i++) {
672         printf("%d ", key.key[i]);
673     }
674     printf("\n");
675
676     return 0;
677 }
678
679 void
680 SetupKasAdminCmd(void)
681 {
682     struct cmd_syndesc *ts;
683
684     ts = cmd_CreateSyntax("KasPrincipalCreate", DoKasPrincipalCreate, NULL,
685                           "create a new principal");
686     cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
687                 "principal to create");
688     cmd_AddParm(ts, "-instance", CMD_SINGLE, CMD_OPTIONAL,
689                 "principal instance");
690     cmd_AddParm(ts, "-password", CMD_SINGLE, CMD_REQUIRED,
691                 "initial principal password");
692     SetupCommonCmdArgs(ts);
693
694     ts = cmd_CreateSyntax("KasPrincipalDelete", DoKasPrincipalDelete, NULL,
695                           "delete a principal");
696     cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
697                 "principal to delete");
698     cmd_AddParm(ts, "-instance", CMD_SINGLE, CMD_OPTIONAL,
699                 "principal instance");
700     SetupCommonCmdArgs(ts);
701
702     ts = cmd_CreateSyntax("KasPrincipalGet", DoKasPrincipalGet, NULL,
703                           "get information about a principal");
704     cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
705                 "principal to get");
706     cmd_AddParm(ts, "-instance", CMD_SINGLE, CMD_OPTIONAL,
707                 "principal instance");
708     SetupCommonCmdArgs(ts);
709
710     ts = cmd_CreateSyntax("KasPrincipalList", DoKasPrincipalList, NULL,
711                           "list all principals");
712     SetupCommonCmdArgs(ts);
713
714     ts = cmd_CreateSyntax("KasPrincipalKeySet", DoKasPrincipalKeySet, NULL,
715                           "set the password for a principal");
716     cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
717                 "principal to modify");
718     cmd_AddParm(ts, "-instance", CMD_SINGLE, CMD_OPTIONAL,
719                 "principal instance");
720     cmd_AddParm(ts, "-password", CMD_SINGLE, CMD_REQUIRED,
721                 "new principal password");
722     cmd_AddParm(ts, "-version", CMD_SINGLE, CMD_REQUIRED,
723                 "password version number");
724     SetupCommonCmdArgs(ts);
725
726     ts = cmd_CreateSyntax("KasPrincipalLockStatusGet",
727                           DoKasPrincipalLockStatusGet, NULL,
728                           "get the lock status of a principal");
729     cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
730                 "principal to query");
731     cmd_AddParm(ts, "-instance", CMD_SINGLE, CMD_OPTIONAL,
732                 "principal instance");
733     SetupCommonCmdArgs(ts);
734
735     ts = cmd_CreateSyntax("KasPrincipalUnlock", DoKasPrincipalUnlock, NULL,
736                           "unlock a principal");
737     cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
738                 "principal to unlock");
739     cmd_AddParm(ts, "-instance", CMD_SINGLE, CMD_OPTIONAL,
740                 "principal instance");
741     SetupCommonCmdArgs(ts);
742
743     ts = cmd_CreateSyntax("KasPrincipalFieldsSet", DoKasPrincipalFieldsSet, NULL,
744                           "modify a principal");
745     cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
746                 "principal to modify");
747     cmd_AddParm(ts, "-instance", CMD_SINGLE, CMD_OPTIONAL,
748                 "principal instance");
749     cmd_AddParm(ts, "-admin", CMD_FLAG, CMD_OPTIONAL,
750                 "make this principal an admin");
751     cmd_AddParm(ts, "-noadmin", CMD_FLAG, CMD_OPTIONAL,
752                 "remove admin from this principal");
753     cmd_AddParm(ts, "-grantticket", CMD_FLAG, CMD_OPTIONAL,
754                 "this principal can grant server tickets");
755     cmd_AddParm(ts, "-nograntticket", CMD_FLAG, CMD_OPTIONAL,
756                 "this principal cannot grant server tickets");
757     cmd_AddParm(ts, "-encrypt", CMD_FLAG, CMD_OPTIONAL,
758                 "this principal can encrypt data");
759     cmd_AddParm(ts, "-noencrypt", CMD_FLAG, CMD_OPTIONAL,
760                 "this principal cannot encrypt data");
761     cmd_AddParm(ts, "-changepassword", CMD_FLAG, CMD_OPTIONAL,
762                 "this principal can change its password");
763     cmd_AddParm(ts, "-nochangepassword", CMD_FLAG, CMD_OPTIONAL,
764                 "this principal cannot change its password");
765     cmd_AddParm(ts, "-reusepassword", CMD_FLAG, CMD_OPTIONAL,
766                 "this principal can reuse its password");
767     cmd_AddParm(ts, "-noreusepassword", CMD_FLAG, CMD_OPTIONAL,
768                 "this principal cannot reuse its password");
769     cmd_AddParm(ts, "-expires", CMD_SINGLE, CMD_OPTIONAL,
770                 "the time at which this principal expires");
771     cmd_AddParm(ts, "-maxticketlifetime", CMD_SINGLE, CMD_OPTIONAL,
772                 "the maximum ticket lifetime this principal can request");
773     cmd_AddParm(ts, "-passwordexpires", CMD_SINGLE, CMD_OPTIONAL,
774                 "the time at which this principal's password expires");
775     cmd_AddParm(ts, "-failedpasswordattempts", CMD_SINGLE, CMD_OPTIONAL,
776                 "the number of failed password attempts this principal "
777                 "can incur before it is locked");
778     cmd_AddParm(ts, "-failedpasswordlocktime", CMD_SINGLE, CMD_OPTIONAL,
779                 "the amount of time this principal will be locked if the "
780                 "maximum failed password attempts is exceeded");
781     SetupCommonCmdArgs(ts);
782
783     ts = cmd_CreateSyntax("KasServerStatsGet", DoKasServerStatsGet, NULL,
784                           "get stats on a kaserver");
785     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
786     SetupCommonCmdArgs(ts);
787
788     ts = cmd_CreateSyntax("KasServerDebugGet", DoKasServerDebugGet, NULL,
789                           "get debug info from a kaserver");
790     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
791     SetupCommonCmdArgs(ts);
792
793     ts = cmd_CreateSyntax("KasServerRandomKeyGet", DoKasServerRandomKeyGet, NULL,
794                           "create a random key");
795     SetupCommonCmdArgs(ts);
796
797 }