xref: /titanic_50/usr/src/cmd/gss/gsscred/gsscred.c (revision 3f7d54a6b84904c8f4d8daa4c7b577bede7df8b9) 
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 1997-2002 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*
30  *  gsscred utility
31  *  Manages mapping between a security principal name and unix uid
32  */
33 
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <pwd.h>
37 #include <unistd.h>
38 #include <string.h>
39 #include <gssapi/gssapi_ext.h>
40 #include "gsscred.h"
41 
42 #define	MAX_STR_LEN	1024
43 
44 
45 /*
46  * Internal Functions
47  */
48 static void usage(void);
49 static void addUser(const char *name, const char *oid, const char *userUid,
50 		const char *userComment, const char *userMech);
51 static int file_listUsers(const gss_OID mechOid, const char *userUid,
52 		char **errDetails);
53 static int listUsers(const char *name, const char *nameTypeOid,
54 		const char *uid, const char *mechOid);
55 static int file_removeUsers(const gss_OID mechOid, const char *userUid,
56 		char **errDetails);
57 static int removeUsers(const char *name, const char *nameTypeOid,
58 		const char *uid, const char *mechOid);
59 
60 /*
61  * Global variables
62  */
63 static int tableSource;
64 static char *PROG_NAME = NULL;
65 
66 int
67 main(int argc, char *args[])
68 {
69 	char *userName = NULL, *nameTypeOID = NULL,
70 		*uid = NULL, *comment = NULL, *mech = NULL,
71 		operation = '0';
72 	int c, errflag = 0;
73 	extern char *optarg;
74 
75 	PROG_NAME = *args;
76 
77 	/* set locale and domain for internationalization */
78 	setlocale(LC_ALL, "");
79 	textdomain(TEXT_DOMAIN);
80 
81 	if (argc < 2)
82 		usage();
83 
84 	/* Process the input arguments */
85 	while ((c = getopt(argc, args, "arln:o:u:m:c:")) != EOF) {
86 
87 		switch (c) {
88 		case 'n':
89 			userName = optarg;
90 			break;
91 
92 		case 'o':
93 			nameTypeOID = optarg;
94 			break;
95 
96 		case 'u':
97 			uid = optarg;
98 			break;
99 
100 		case 'm':
101 			mech = optarg;
102 			break;
103 
104 		case 'c':
105 			comment = optarg;
106 			break;
107 
108 		case 'a':
109 		case 'r':
110 		case 'l':
111 			operation = c;
112 			errflag++;
113 			if (errflag > 1)
114 				usage();
115 			break;
116 
117 		default:
118 			usage();
119 		}
120 	}
121 
122 	/* determine which back-end to use as the gsscred store */
123 	tableSource = gsscred_read_config_file();
124 
125 	/* perform the requested operation */
126 	switch (operation) {
127 		case 'a':
128 			addUser(userName, nameTypeOID, uid, comment, mech);
129 			break;
130 
131 		case 'r':
132 			removeUsers(userName, nameTypeOID, uid, mech);
133 			break;
134 
135 		case 'l':
136 			listUsers(userName, nameTypeOID, uid, mech);
137 			break;
138 
139 		default:
140 			usage();
141 	}
142 	fprintf(stdout, "\n");
143 	return (0);
144 }  /* main */
145 
146 /*
147  * Handles the addition of users to the gsscred table.
148  */
149 static void
150 addUser(const char *name, const char *nameOidStr,
151 	    const char *userUid, const char *userComment,
152 	    const char *mechOidStr)
153 {
154 	gss_OID mechOid;
155 	gss_buffer_desc fullName = GSS_C_EMPTY_BUFFER,
156 		hexBufDesc = GSS_C_EMPTY_BUFFER,
157 		hexMechOid = GSS_C_EMPTY_BUFFER;
158 	char comment[MAX_STR_LEN+1], hexBuf[MAX_STR_LEN+MAX_STR_LEN+1],
159 		hexMechOidBuf[MAX_STR_LEN+1], *commentPtr = NULL,
160 		*errDetail = NULL, uidStr[256], *uidPtr;
161 	struct passwd *aUser;
162 	OM_uint32 minor;
163 	int count = 0, retCode;
164 
165 	hexMechOid.length = MAX_STR_LEN;
166 	hexMechOid.value = (void*)hexMechOidBuf;
167 
168 	/* addition of users can only be performed by super users */
169 	if (getuid()) {
170 		fprintf(stderr,
171 			gettext("\nUser addition requires"
172 				" root privileges."));
173 		return;
174 	}
175 
176 	/* the mechanism OID is required */
177 	if (mechOidStr == NULL) {
178 		fprintf(stderr, gettext("\nUnspecified mechanism."));
179 		usage();
180 	}
181 
182 	/* Convert from string mechanism Oid to ASN.1 oid and then hex */
183 	if (__gss_mech_to_oid(mechOidStr, &mechOid) != GSS_S_COMPLETE) {
184 		fprintf(stderr,
185 			gettext("\nInvalid mechanism specified [%s]."),
186 			mechOidStr);
187 		return;
188 	}
189 
190 	hexBufDesc.length = mechOid->length;
191 	hexBufDesc.value = mechOid->elements;
192 
193 	if (!gsscred_AsHex(&hexBufDesc, &hexMechOid)) {
194 		fprintf(stderr,
195 			gettext("\nInternal error.  "
196 				"Conversion to hex failed."));
197 		return;
198 	}
199 
200 	/*
201 	 * if the name is specified, then do single addition.
202 	 * Might have to look up the uid.
203 	 */
204 	if (name != NULL) {
205 		hexBufDesc.length = sizeof (hexBuf);
206 		hexBufDesc.value = hexBuf;
207 
208 		/* build the name as needed */
209 		if (!gsscred_MakeName(mechOid, name, nameOidStr, &fullName)) {
210 			fprintf(stderr,
211 				gettext("\nError adding user [%s]."), name);
212 			return;
213 		}
214 
215 		/* convert it to hex */
216 		if (!gsscred_AsHex(&fullName, &hexBufDesc)) {
217 			gss_release_buffer(&minor, &fullName);
218 			fprintf(stderr,
219 				gettext("\nInternal error.  "
220 					"Conversion to hex failed."));
221 			return;
222 		}
223 
224 		/* might require the lookup of the uid if one not specified */
225 		if (userUid == NULL) {
226 
227 			if ((aUser = getpwnam(name)) == NULL) {
228 				fprintf(stderr,
229 					gettext("\nUnable to obtain password"
230 						" information for [%s]."),
231 					name);
232 				gss_release_buffer(&minor, &fullName);
233 				return;
234 			}
235 			sprintf(uidStr, "%ld", aUser->pw_uid);
236 			uidPtr = uidStr;
237 		}
238 		else
239 			uidPtr = (char *)userUid;
240 
241 		if (userComment == NULL) {
242 			sprintf(comment, "%s, %s", name, mechOidStr);
243 			commentPtr = comment;
244 		} else
245 			commentPtr = (char *)userComment;
246 
247 		if (tableSource == GSSCRED_FLAT_FILE)
248 			retCode = file_addGssCredEntry(&hexBufDesc,
249 					uidPtr, commentPtr, &errDetail);
250 		else
251 			/* other backends (ldap, dss) coming soon */
252 			retCode	= 0;
253 
254 		if (!retCode) {
255 			fprintf(stderr, gettext("\nError adding user [%s]."),
256 				commentPtr);
257 
258 			if (errDetail) {
259 				fprintf(stderr, "\n%s\n", errDetail);
260 				free(errDetail);
261 				errDetail = NULL;
262 			}
263 		}
264 
265 		gss_release_buffer(&minor, &fullName);
266 		return;
267 	}
268 
269 	/*
270 	 * since no name specified, then we will load everyone from
271 	 * password table.  This means that -u and -o options are invalid.
272 	 * We just ignore it, but we could flag it as error.
273 	 */
274 	setpwent();
275 
276 	while ((aUser = getpwent()) != NULL) {
277 		hexBufDesc.length = sizeof (hexBuf);
278 		hexBufDesc.value = hexBuf;
279 
280 		if (!gsscred_MakeName(mechOid, aUser->pw_name,
281 			nameOidStr, &fullName)) {
282 			fprintf(stderr,
283 				gettext("\nError adding user [%s]."),
284 				aUser->pw_name);
285 			continue;
286 		}
287 
288 		if (!gsscred_AsHex(&fullName, &hexBufDesc)) {
289 			gss_release_buffer(&minor, &fullName);
290 			fprintf(stderr,
291 				gettext("\nInternal error.  "
292 					"Conversion to hex failed."));
293 			continue;
294 		}
295 
296 		sprintf(uidStr, "%ld", aUser->pw_uid);
297 		sprintf(comment, "%s, %s", aUser->pw_name, mechOidStr);
298 		if (tableSource == GSSCRED_FLAT_FILE)
299 			retCode = file_addGssCredEntry(&hexBufDesc,
300 					uidStr, comment, &errDetail);
301 		else
302 			retCode	= 0;
303 
304 		if (!retCode) {
305 			fprintf(stderr,
306 				gettext("\nError adding user [%s]."),
307 				comment);
308 
309 			if (errDetail) {
310 				fprintf(stderr, "\n%s\n", errDetail);
311 				free(errDetail);
312 				errDetail = NULL;
313 			}
314 		} else {
315 			count++;
316 			if ((count % 50) == 0)
317 				fprintf(stdout,
318 					gettext("\n[%d] users added..."),
319 					count);
320 		}
321 		gss_release_buffer(&minor, &fullName);
322 	}
323 	endpwent();
324 }  /* addUser */
325 
326 
327 /*
328  *  Handles the searching of the gsscred table.
329  */
330 static int listUsers(const char *name, const char *nameOidStr,
331 		const char *uidStr, const char *mechOidStr)
332 {
333 	GssCredEntry *entryPtr, *entryTmpPtr;
334 	char hexMech[256],
335 		hexName[(MAX_STR_LEN *2) + 1];
336 	gss_OID anOid = NULL, userMechOid = NULL;
337 	gss_OID_set mechSet = NULL;
338 	gss_buffer_desc inBufDesc = GSS_C_EMPTY_BUFFER,
339 		outBufDesc = GSS_C_EMPTY_BUFFER,
340 		searchName = GSS_C_EMPTY_BUFFER;
341 	int status = 1, numOfMechs, i;
342 	OM_uint32 minor;
343 	char *errDetails = NULL;
344 
345 	/* Do we need to convert the mechanism oid? */
346 	if (mechOidStr != NULL) {
347 
348 		if (__gss_mech_to_oid(mechOidStr, &userMechOid) !=
349 			GSS_S_COMPLETE) {
350 			fprintf(stderr,
351 				gettext("\nInvalid mechanism specified [%s]."),
352 				mechOidStr);
353 			return (0);
354 		}
355 		inBufDesc.length = userMechOid->length;
356 		inBufDesc.value = userMechOid->elements;
357 		outBufDesc.length = sizeof (hexMech);
358 		outBufDesc.value = hexMech;
359 
360 		if (!gsscred_AsHex(&inBufDesc, &outBufDesc)) {
361 			fprintf(stderr,
362 				gettext("\nInternal error.  "
363 					"Conversion to hex failed."));
364 			status = 0;
365 			goto cleanup;
366 		}
367 
368 	}	/* mechOidStr != NULL */
369 
370 	/* are we retrieving everyone ? or searching by mech ? */
371 	if ((name == NULL && uidStr == NULL && mechOidStr == NULL) ||
372 	    (name == NULL && uidStr == NULL)) {
373 
374 		if (tableSource == GSSCRED_FLAT_FILE) {
375 			file_listUsers(userMechOid, NULL, &errDetails);
376 
377 			if (errDetails) {
378 				fprintf(stderr,
379 					gettext("\nError searching gsscred"
380 						" table [%s]."),
381 					errDetails);
382 				free(errDetails);
383 				errDetails = NULL;
384 				return (0);
385 			}
386 			return (1);
387 		}
388 
389 	}
390 
391 	/* Are we searching by uid or uid and mech? */
392 	if (name == NULL && uidStr != NULL) {
393 
394 		if (tableSource == GSSCRED_FLAT_FILE)
395 			file_listUsers(userMechOid, uidStr, &errDetails);
396 		else {
397 			entryPtr = NULL;
398 			while (entryPtr != NULL) {
399 				fprintf(stdout, "\n%s\t%d\t%s",
400 					entryPtr->principal_name,
401 					entryPtr->unix_uid, entryPtr->comment);
402 				free(entryPtr->principal_name);
403 				free(entryPtr->comment);
404 				entryTmpPtr = entryPtr->next;
405 				free(entryPtr);
406 				entryPtr = entryTmpPtr;
407 			}
408 		}
409 
410 		/* check for any errors */
411 		if (errDetails) {
412 			fprintf(stderr,
413 				gettext("\nError searching gsscred table "
414 					"[%s]."),
415 				errDetails);
416 			free(errDetails);
417 			errDetails = NULL;
418 			status = 0;
419 		}
420 
421 		goto cleanup;
422 	}
423 
424 	/*
425 	 * We are searching by name;
426 	 * how many mechs must we check?
427 	 */
428 	if (mechOidStr == NULL) {
429 
430 		if (gss_indicate_mechs(&minor, &mechSet) != GSS_S_COMPLETE) {
431 			fprintf(stderr,
432 				gettext("\nInternal error.  "
433 					"GSS-API call failed."));
434 			return (0);
435 		}
436 		numOfMechs = mechSet->count;
437 	}
438 	else
439 		numOfMechs = 1;
440 
441 	/* now look through all the mechs searching */
442 	for (i = 0; i < numOfMechs; i++) {
443 
444 		if (mechOidStr == NULL) {
445 			anOid = &mechSet->elements[i];
446 			inBufDesc.length = anOid->length;
447 			inBufDesc.value = anOid->elements;
448 			outBufDesc.length = sizeof (hexMech);
449 			outBufDesc.value = hexMech;
450 
451 			if (!gsscred_AsHex(&inBufDesc, &outBufDesc))
452 				continue;
453 		} else
454 			anOid = userMechOid;
455 
456 		/* create a gss name */
457 		if (!gsscred_MakeName(anOid, name, nameOidStr, &outBufDesc))
458 			continue;
459 
460 		/* now convert it to hex, and find it */
461 		searchName.value = hexName;
462 		searchName.length = sizeof (hexName);
463 		status = gsscred_AsHex(&outBufDesc, &searchName);
464 		free(outBufDesc.value);
465 
466 		if (!status)
467 			continue;
468 
469 		if (tableSource == GSSCRED_FLAT_FILE)
470 			file_getGssCredEntry(&searchName, uidStr, &errDetails);
471 		else {
472 			entryPtr = NULL;  /* other backends coming soon */
473 			while (entryPtr != NULL) {
474 				fprintf(stdout, "\n%s\t%d\t%s",
475 					entryPtr->principal_name,
476 					entryPtr->unix_uid, entryPtr->comment);
477 				free(entryPtr->principal_name);
478 				free(entryPtr->comment);
479 				entryTmpPtr = entryPtr->next;
480 				free(entryPtr);
481 				entryPtr = entryTmpPtr;
482 			}
483 		}
484 
485 		/* any errors to display */
486 		if (errDetails) {
487 			fprintf(stderr,
488 				gettext("\nError searching gsscred table "
489 					"[%s]."),
490 				errDetails);
491 			free(errDetails);
492 			errDetails = NULL;
493 			status = 0;
494 		}
495 	}	/* for */
496 
497 cleanup:
498 	if (mechSet != NULL)
499 		gss_release_oid_set(&minor, &mechSet);
500 
501 	return (status);
502 }  /* listUsers */
503 
504 /*
505  * Performs additional handling while searching for users
506  * stored in the flat file table.
507  */
508 int
509 file_listUsers(const gss_OID mechOid, const char *unixUid,
510 		char **errDetails)
511 {
512 	gss_buffer_desc mechBufDesc = GSS_C_EMPTY_BUFFER,
513 		mechHexBufDesc = GSS_C_EMPTY_BUFFER;
514 	char mechBuf[128], mechHexBuf[256];
515 
516 	if (mechOid != NULL) {
517 		/* must make the name header whic contains mech oid */
518 		mechBufDesc.value = (void *) mechBuf;
519 		mechBufDesc.length = sizeof (mechBuf);
520 		mechHexBufDesc.value = (void*) mechHexBuf;
521 		mechHexBufDesc.length = sizeof (mechHexBuf);
522 
523 		if ((!gsscred_MakeNameHeader(mechOid, &mechBufDesc)) ||
524 			(!gsscred_AsHex(&mechBufDesc, &mechHexBufDesc))) {
525 			(*errDetails) = strdup(
526 					gettext("\nInternal error. "
527 					" Conversion to hex failed."));
528 			return (0);
529 		}
530 
531 		return (file_getGssCredEntry(&mechHexBufDesc,
532 				unixUid, errDetails));
533 	}
534 
535 	return (file_getGssCredEntry(NULL, unixUid, errDetails));
536 }  /* file_listUsers */
537 
538 
539 /*
540  *  Handles the deletion of users.
541  */
542 static int removeUsers(const char *name, const char *nameOidStr,
543 		const char *uidStr, const char *mechOidStr)
544 {
545 	char hexMech[256],
546 		hexName[(MAX_STR_LEN *2) + 1],
547 		*errDetails = NULL;
548 	gss_OID anOid = NULL, userMechOid = NULL;
549 	gss_OID_set mechSet = NULL;
550 	gss_buffer_desc inBufDesc = GSS_C_EMPTY_BUFFER,
551 		outBufDesc = GSS_C_EMPTY_BUFFER,
552 		searchName = GSS_C_EMPTY_BUFFER;
553 	int status = 0, numOfMechs, i;
554 	OM_uint32 minor;
555 
556 
557 	/* user deletion can only be performed by super user */
558 	if (getuid()) {
559 
560 		fprintf(stderr,
561 			gettext("\nUser deletion requires"
562 				" root privileges."));
563 		return (0);
564 	}
565 
566 	/* do we need to convert the mechanism oid? */
567 	if (mechOidStr != NULL) {
568 		if (__gss_mech_to_oid(mechOidStr, &userMechOid) !=
569 		GSS_S_COMPLETE) {
570 			fprintf(stderr,
571 				gettext("\nInvalid mechanism specified [%s]."),
572 				mechOidStr);
573 			return (0);
574 		}
575 
576 		inBufDesc.length = userMechOid->length;
577 		inBufDesc.value = userMechOid->elements;
578 		outBufDesc.length = sizeof (hexMech);
579 		outBufDesc.value = hexMech;
580 
581 		if (!gsscred_AsHex(&inBufDesc, &outBufDesc)) {
582 			fprintf(stderr,
583 				gettext("\nInternal error."
584 					"  Conversion to hex failed."));
585 			status = 0;
586 			goto cleanup;
587 		}
588 
589 	}	 /* mechOidStr != NULL */
590 
591 	/* are we deleting the entire table or an entire mech ? */
592 	if (name == NULL && uidStr == NULL) {
593 
594 		if (tableSource == GSSCRED_FLAT_FILE)
595 			status = file_removeUsers(userMechOid,
596 					NULL, &errDetails);
597 		else
598 			status = 0;
599 
600 		/* display any errors */
601 		if (errDetails) {
602 			fprintf(stderr,
603 				gettext("\nError deleting gsscred entry "
604 					"[%s]."),
605 				errDetails);
606 			free(errDetails);
607 			errDetails = NULL;
608 		}
609 		goto cleanup;
610 	}
611 
612 	/* are we deleting by uid or uid and mech? */
613 	if (name == NULL && uidStr != NULL) {
614 
615 		if (tableSource == GSSCRED_FLAT_FILE)
616 			status = file_removeUsers(userMechOid, uidStr,
617 						&errDetails);
618 		else
619 			status = 0;
620 
621 		/* check for any errors */
622 		if (errDetails) {
623 			fprintf(stderr,
624 				gettext("\nError deleting gsscred entry "
625 					"[%s]."),
626 				errDetails);
627 			free(errDetails);
628 			errDetails = NULL;
629 		}
630 		goto cleanup;
631 	}
632 
633 	/*
634 	 * We are deleting by name;
635 	 * how many mechs must we check?
636 	 */
637 	if (mechOidStr == NULL) {
638 
639 		if (gss_indicate_mechs(&minor, &mechSet) != GSS_S_COMPLETE) {
640 			fprintf(stderr,
641 				gettext("\nInternal error.  "
642 					"GSS-API call failed."));
643 			status = 0;
644 			goto cleanup;
645 		}
646 		numOfMechs = mechSet->count;
647 	}
648 	else
649 		numOfMechs = 1;
650 
651 	/* now look through all the mechs, deleting */
652 	for (i = 0; i < numOfMechs; i++) {
653 
654 		if (mechOidStr == NULL) {
655 			anOid = &mechSet->elements[i];
656 			inBufDesc.length = anOid->length;
657 			inBufDesc.value = anOid->elements;
658 			outBufDesc.length = sizeof (hexMech);
659 			outBufDesc.value = hexMech;
660 			if (!gsscred_AsHex(&inBufDesc, &outBufDesc))
661 				continue;
662 		} else
663 			anOid = userMechOid;
664 
665 		/* create a gss name */
666 		if (!gsscred_MakeName(anOid, name, nameOidStr, &outBufDesc))
667 			continue;
668 
669 		/* now convert it to hex, and delete it */
670 		searchName.value = hexName;
671 		searchName.length = sizeof (hexName);
672 		status = gsscred_AsHex(&outBufDesc, &searchName);
673 		free(outBufDesc.value);
674 
675 		if (!status)
676 			continue;
677 
678 		if (tableSource == GSSCRED_FLAT_FILE)
679 			status = file_deleteGssCredEntry(&searchName,
680 					uidStr, &errDetails);
681 		else
682 			status = 0;
683 
684 		/* check for any errors */
685 		if (errDetails) {
686 			fprintf(stderr,
687 				gettext("\nError deleting gsscred entry"
688 					" [%s]."),
689 				errDetails);
690 			free(errDetails);
691 			errDetails = NULL;
692 		}
693 	}	 /* for */
694 
695 cleanup:
696 	if (mechSet != NULL)
697 		gss_release_oid_set(&minor, &mechSet);
698 
699 	return (status);
700 }  /* removeUsers */
701 
702 
703 /*
704  * Performs additional handling while deleting users
705  * stored in the flat file table.
706  */
707 int file_removeUsers(const gss_OID mechOid, const char *unixUid,
708 		char **errDetails)
709 {
710 	gss_buffer_desc mechBufDesc = GSS_C_EMPTY_BUFFER,
711 		mechHexBufDesc = GSS_C_EMPTY_BUFFER;
712 	char mechBuf[128], mechHexBuf[256];
713 
714 	if (mechOid != NULL) {
715 		/*
716 		 * need to create the buffer header which contains
717 		 * the mechanism oid.
718 		 */
719 		mechBufDesc.value = (void*) mechBuf;
720 		mechBufDesc.length = sizeof (mechBuf);
721 		mechHexBufDesc.value = (void *) mechHexBuf;
722 		mechHexBufDesc.length = sizeof (mechHexBuf);
723 
724 		if ((!gsscred_MakeNameHeader(mechOid, &mechBufDesc)) ||
725 		    (!gsscred_AsHex(&mechBufDesc, &mechHexBufDesc))) {
726 			(*errDetails) = strdup(
727 				gettext("\nInternal error."
728 					"  Conversion to hex failed."));
729 			return (0);
730 		}
731 
732 		return (file_deleteGssCredEntry(&mechHexBufDesc, unixUid,
733 						errDetails));
734 	}
735 
736 	return (file_deleteGssCredEntry(NULL, unixUid, errDetails));
737 }  /* file_removeUsers */
738 
739 
740 /*
741  * Prints the usage string, and terminates.
742  */
743 static void usage(void)
744 {
745 
746 	fprintf(stderr,
747 		gettext("\nUsage:\t %s [-n user [-o oid] [-u uid]]"
748 			" [-c comment] -m mech -a"
749 			"\n\t %s [-n user [-o oid]] [-u uid] [-m mech] -r"
750 			"\n\t %s [-n user [-o oid]] [-u uid] [-m mech] -l\n"),
751 		PROG_NAME, PROG_NAME, PROG_NAME);
752 	exit(1);
753 }  /* usage */
754