2 * Copyright 2000, International Business Machines Corporation and others.
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
11 * This file implements the pts related funtions for afscp
14 #include <afsconfig.h>
15 #include <afs/param.h>
25 * Generic fuction for converting input string to an integer. Pass
26 * the error_msg you want displayed if there is an error converting
31 GetIntFromString(const char *int_str, const char *error_msg)
34 char *bad_char = NULL;
36 i = strtoul(int_str, &bad_char, 10);
37 if ((bad_char == NULL) || (*bad_char == 0)) {
45 * Generic fuction for converting input string to an pts_groupAccess_t. Pass
46 * the error_msg you want displayed if there is an error converting
50 static pts_groupAccess_t
51 GetGroupAccessFromString(const char *in_str, const char *error_msg)
53 pts_groupAccess_t access;
55 if (!strcasecmp("owner", in_str)) {
56 access = PTS_GROUP_OWNER_ACCESS;
57 } else if (!strcasecmp("group", in_str)) {
58 access = PTS_GROUP_ACCESS;
59 } else if (!strcasecmp("any", in_str)) {
60 access = PTS_GROUP_ANYUSER_ACCESS;
69 * Generic fuction for converting input string to an pts_userAccess_t. Pass
70 * the error_msg you want displayed if there is an error converting
74 static pts_userAccess_t
75 GetUserAccessFromString(const char *in_str, const char *error_msg)
77 pts_userAccess_t access;
79 if (!strcasecmp("owner", in_str)) {
80 access = PTS_USER_OWNER_ACCESS;
81 } else if (!strcasecmp("any", in_str)) {
82 access = PTS_USER_ANYUSER_ACCESS;
91 DoPtsGroupMemberAdd(struct cmd_syndesc *as, void *arock)
93 typedef enum { USER, GROUP } DoPtsGroupMemberAdd_parm_t;
95 const char *user = as->parms[USER].items->data;
96 const char *group = as->parms[GROUP].items->data;
98 if (!pts_GroupMemberAdd(cellHandle, user, group, &st)) {
99 ERR_ST_EXT("pts_GroupMemberAdd", st);
106 DoPtsGroupOwnerChange(struct cmd_syndesc *as, void *arock)
108 typedef enum { OWNER, GROUP } DoPtsGroupOwnerChange_parm_t;
110 const char *owner = as->parms[OWNER].items->data;
111 const char *group = as->parms[GROUP].items->data;
113 if (!pts_GroupOwnerChange(cellHandle, group, owner, &st)) {
114 ERR_ST_EXT("pts_GroupOwnerChange", st);
121 DoPtsGroupCreate(struct cmd_syndesc *as, void *arock)
123 typedef enum { OWNER, GROUP } DoPtsGroupCreate_parm_t;
125 char *owner = as->parms[OWNER].items->data;
126 char *group = as->parms[GROUP].items->data;
129 if (!pts_GroupCreate(cellHandle, group, owner, &new_group_id, &st)) {
130 ERR_ST_EXT("pts_GroupMemberAdd", st);
133 printf("Group id %d\n", new_group_id);
139 Print_pts_groupAccess_p(pts_groupAccess_p access, const char *prefix)
141 if (*access == PTS_GROUP_OWNER_ACCESS) {
142 printf("%sPTS_GROUP_OWNER_ACCESS\n", prefix);
143 } else if (*access == PTS_GROUP_ACCESS) {
144 printf("%sPTS_GROUP_ACCESS\n", prefix);
145 } else if (*access == PTS_GROUP_ANYUSER_ACCESS) {
146 printf("%sPTS_GROUP_ANYUSER_ACCESS\n", prefix);
151 Print_pts_GroupEntry_p(pts_GroupEntry_p entry, const char *prefix)
153 printf("%sName %s Uid %d\n", prefix, entry->name, entry->nameUid);
154 printf("%sOwner %s Uid %d\n", prefix, entry->owner, entry->ownerUid);
155 printf("%sCreator %s Uid %d\n", prefix, entry->creator,
157 printf("%sMembership count %d\n", prefix, entry->membershipCount);
158 printf("%sList status permission:\n", prefix);
159 Print_pts_groupAccess_p(&entry->listStatus, " ");
160 printf("%sList groups owned permission:\n", prefix);
161 Print_pts_groupAccess_p(&entry->listGroupsOwned, " ");
162 printf("%sList membership permission:\n", prefix);
163 Print_pts_groupAccess_p(&entry->listMembership, " ");
164 printf("%sList add permission:\n", prefix);
165 Print_pts_groupAccess_p(&entry->listAdd, " ");
166 printf("%sList delete permission:\n", prefix);
167 Print_pts_groupAccess_p(&entry->listDelete, " ");
171 DoPtsGroupGet(struct cmd_syndesc *as, void *arock)
173 typedef enum { GROUP } DoPtsGroupGet_parm_t;
175 const char *group = as->parms[GROUP].items->data;
176 pts_GroupEntry_t entry;
178 if (!pts_GroupGet(cellHandle, group, &entry, &st)) {
179 ERR_ST_EXT("pts_GroupGet", st);
182 Print_pts_GroupEntry_p(&entry, "");
188 DoPtsGroupDelete(struct cmd_syndesc *as, void *arock)
190 typedef enum { GROUP } DoPtsGroupDelete_parm_t;
192 const char *group = as->parms[GROUP].items->data;
194 if (!pts_GroupDelete(cellHandle, group, &st)) {
195 ERR_ST_EXT("pts_GroupDelete", st);
202 DoPtsGroupMaxGet(struct cmd_syndesc *as, void *arock)
207 if (!pts_GroupMaxGet(cellHandle, &max_group_id, &st)) {
208 ERR_ST_EXT("pts_GroupMaxGet", st);
215 DoPtsGroupMaxSet(struct cmd_syndesc *as, void *arock)
217 typedef enum { MAX } DoPtsGroupMaxSet_parm_t;
219 const char *max = as->parms[MAX].items->data;
222 max_group_id = GetIntFromString(max, "bad group id");
224 if (!pts_GroupMaxSet(cellHandle, max_group_id, &st)) {
225 ERR_ST_EXT("pts_GroupMaxSet", st);
232 DoPtsGroupMemberList(struct cmd_syndesc *as, void *arock)
234 typedef enum { GROUP } DoPtsGroupMemberList_parm_t;
236 const char *group = as->parms[GROUP].items->data;
238 char member[PTS_MAX_NAME_LEN];
240 if (!pts_GroupMemberListBegin(cellHandle, group, &iter, &st)) {
241 ERR_ST_EXT("pts_GroupMemberListBegin", st);
244 printf("Listing members of group %s\n", group);
245 while (pts_GroupMemberListNext(iter, member, &st)) {
246 printf("\t%s\n", member);
249 if (st != ADMITERATORDONE) {
250 ERR_ST_EXT("pts_GroupMemberListNext", st);
253 if (!pts_GroupMemberListDone(iter, &st)) {
254 ERR_ST_EXT("pts_GroupMemberListDone", st);
261 DoPtsGroupMemberRemove(struct cmd_syndesc *as, void *arock)
263 typedef enum { USER, GROUP } DoPtsGroupMemberRemove_parm_t;
265 const char *user = as->parms[USER].items->data;
266 const char *group = as->parms[GROUP].items->data;
268 if (!pts_GroupMemberRemove(cellHandle, user, group, &st)) {
269 ERR_ST_EXT("pts_GroupMemberRemove", st);
276 DoPtsGroupRename(struct cmd_syndesc *as, void *arock)
278 typedef enum { GROUP, NEWNAME } DoPtsGroupRename_parm_t;
280 const char *group = as->parms[GROUP].items->data;
281 char *new_name = as->parms[NEWNAME].items->data;
283 if (!pts_GroupRename(cellHandle, group, new_name, &st)) {
284 ERR_ST_EXT("pts_GroupRename", st);
291 DoPtsGroupModify(struct cmd_syndesc *as, void *arock)
293 typedef enum { GROUP, LISTSTATUS, LISTGROUPSOWNED, LISTMEMBERSHIP,
295 } DoPtsGroupModify_parm_t;
297 const char *group = as->parms[GROUP].items->data;
298 pts_GroupUpdateEntry_t entry;
301 GetGroupAccessFromString(as->parms[LISTSTATUS].items->data,
302 "invalid permission specifier");
303 entry.listGroupsOwned =
304 GetGroupAccessFromString(as->parms[LISTGROUPSOWNED].items->data,
305 "invalid permission specifier");
306 entry.listMembership =
307 GetGroupAccessFromString(as->parms[LISTMEMBERSHIP].items->data,
308 "invalid permission specifier");
310 GetGroupAccessFromString(as->parms[LISTADD].items->data,
311 "invalid permission specifier");
313 GetGroupAccessFromString(as->parms[LISTDELTE].items->data,
314 "invalid permission specifier");
316 if (!pts_GroupModify(cellHandle, group, &entry, &st)) {
317 ERR_ST_EXT("pts_GroupModify", st);
324 DoPtsUserCreate(struct cmd_syndesc *as, void *arock)
326 typedef enum { USER } DoPtsUserCreate_parm_t;
328 char *user = as->parms[USER].items->data;
331 if (!pts_UserCreate(cellHandle, user, &new_user_id, &st)) {
332 ERR_ST_EXT("pts_UserCreate", st);
335 printf("Created user id %d\n", new_user_id);
341 DoPtsUserDelete(struct cmd_syndesc *as, void *arock)
343 typedef enum { USER } DoPtsUserDelete_parm_t;
345 const char *user = as->parms[USER].items->data;
347 if (!pts_UserDelete(cellHandle, user, &st)) {
348 ERR_ST_EXT("pts_UserDelete", st);
355 Print_pts_userAccess_p(pts_userAccess_p access, const char *prefix)
357 if (*access == PTS_USER_OWNER_ACCESS) {
358 printf("%sPTS_USER_OWNER_ACCESS\n", prefix);
359 } else if (*access == PTS_USER_ANYUSER_ACCESS) {
360 printf("%sPTS_USER_ANYUSER_ACCESS\n", prefix);
365 Print_pts_UserEntry_p(pts_UserEntry_p entry, const char *prefix)
367 printf("%sName %s Uid %d\n", prefix, entry->name, entry->nameUid);
368 printf("%sOwner %s Uid %d\n", prefix, entry->owner, entry->ownerUid);
369 printf("%sCreator %s Uid %d\n", prefix, entry->creator,
371 printf("%sGroup creation quota %d\n", prefix, entry->groupCreationQuota);
372 printf("%sGroup membership count %d\n", prefix,
373 entry->groupMembershipCount);
374 printf("%sList status permission\n", prefix);
375 Print_pts_userAccess_p(&entry->listStatus, " ");
376 printf("%sList groups owned permission\n", prefix);
377 Print_pts_userAccess_p(&entry->listGroupsOwned, " ");
378 printf("%sList membership permission\n", prefix);
379 Print_pts_userAccess_p(&entry->listMembership, " ");
380 printf("%s\n", prefix);
384 DoPtsUserGet(struct cmd_syndesc *as, void *arock)
386 typedef enum { USER } DoPtsUserGet_parm_t;
388 const char *user = as->parms[USER].items->data;
389 pts_UserEntry_t entry;
391 if (!pts_UserGet(cellHandle, user, &entry, &st)) {
392 ERR_ST_EXT("pts_UserGet", st);
395 Print_pts_UserEntry_p(&entry, "");
401 DoPtsUserRename(struct cmd_syndesc *as, void *arock)
403 typedef enum { USER, NEWNAME } DoPtsUserRename_parm_t;
405 const char *user = as->parms[USER].items->data;
406 char *new_name = as->parms[NEWNAME].items->data;
408 if (!pts_UserRename(cellHandle, user, new_name, &st)) {
409 ERR_ST_EXT("pts_UserRename", st);
416 DoPtsUserModify(struct cmd_syndesc *as, void *arock)
418 typedef enum { USER, GROUPQUOTA, LISTSTATUS, LISTGROUPSOWNED,
420 } DoPtsUserModify_parm_t;
422 const char *user = as->parms[USER].items->data;
423 pts_UserUpdateEntry_t entry;
425 int have_list_status_perm = 0;
426 int have_list_groups_owned_perm = 0;
427 int have_list_membership_perm = 0;
431 if (as->parms[GROUPQUOTA].items) {
432 entry.groupCreationQuota =
433 GetIntFromString(as->parms[GROUPQUOTA].items->data, "bad quota");
434 entry.flag = PTS_USER_UPDATE_GROUP_CREATE_QUOTA;
438 if (as->parms[LISTSTATUS].items) {
440 GetUserAccessFromString(as->parms[LISTSTATUS].items->data,
441 "invalid permission specifier");
442 entry.flag |= PTS_USER_UPDATE_PERMISSIONS;
443 have_list_status_perm = 1;
446 if (as->parms[LISTGROUPSOWNED].items) {
447 entry.listGroupsOwned =
448 GetUserAccessFromString(as->parms[LISTGROUPSOWNED].items->data,
449 "invalid permission specifier");
450 entry.flag |= PTS_USER_UPDATE_PERMISSIONS;
451 have_list_groups_owned_perm = 1;
454 if (as->parms[LISTMEMBERSHIP].items) {
455 entry.listMembership =
456 GetUserAccessFromString(as->parms[LISTMEMBERSHIP].items->data,
457 "invalid permission specifier");
458 entry.flag |= PTS_USER_UPDATE_PERMISSIONS;
459 have_list_membership_perm = 1;
462 if (entry.flag == 0) {
463 ERR_EXT("you must specify either quota or permissions to modify");
465 if (entry.flag & PTS_USER_UPDATE_PERMISSIONS) {
466 if ((have_list_status_perm + have_list_groups_owned_perm +
467 have_list_membership_perm) != 3) {
468 ERR_EXT("you must completely specify all permissions "
469 "when modifying a user");
474 if (!pts_UserModify(cellHandle, user, &entry, &st)) {
475 ERR_ST_EXT("pts_UserModify", st);
482 DoPtsUserMaxGet(struct cmd_syndesc *as, void *arock)
487 if (!pts_UserMaxGet(cellHandle, &max_user_id, &st)) {
488 ERR_ST_EXT("pts_UserMaxGet", st);
495 DoPtsUserMaxSet(struct cmd_syndesc *as, void *arock)
497 typedef enum { MAX } DoPtsUserMaxSet_parm_t;
499 const char *max = as->parms[MAX].items->data;
502 max_user_id = GetIntFromString(max, "bad user id");
504 if (!pts_UserMaxSet(cellHandle, max_user_id, &st)) {
505 ERR_ST_EXT("pts_UserMaxSet", st);
512 DoPtsUserMemberList(struct cmd_syndesc *as, void *arock)
514 typedef enum { USER } DoPtsUserMemberList_parm_t;
516 const char *user = as->parms[USER].items->data;
518 char group[PTS_MAX_NAME_LEN];
520 if (!pts_UserMemberListBegin(cellHandle, user, &iter, &st)) {
521 ERR_ST_EXT("pts_UserMemberListBegin", st);
524 printf("Listing group membership for %s\n", user);
526 while (pts_UserMemberListNext(iter, group, &st)) {
527 printf("\t%s\n", group);
530 if (st != ADMITERATORDONE) {
531 ERR_ST_EXT("pts_UserMemberListNext", st);
534 if (!pts_UserMemberListDone(iter, &st)) {
535 ERR_ST_EXT("pts_UserMemberListDone", st);
542 DoPtsOwnedGroupList(struct cmd_syndesc *as, void *arock)
544 typedef enum { USER } DoPtsOwnedGroupList_parm_t;
546 const char *user = as->parms[USER].items->data;
548 char group[PTS_MAX_NAME_LEN];
550 if (!pts_OwnedGroupListBegin(cellHandle, user, &iter, &st)) {
551 ERR_ST_EXT("pts_OwnedGroupListBegin", st);
554 printf("Listing groups owned by %s\n", user);
556 while (pts_OwnedGroupListNext(iter, group, &st)) {
557 printf("\t%s\n", group);
560 if (st != ADMITERATORDONE) {
561 ERR_ST_EXT("pts_OwnedGroupListNext", st);
564 if (!pts_OwnedGroupListDone(iter, &st)) {
565 ERR_ST_EXT("pts_OwnedGroupListDone", st);
572 SetupPtsAdminCmd(void)
574 struct cmd_syndesc *ts;
576 ts = cmd_CreateSyntax("PtsGroupMemberAdd", DoPtsGroupMemberAdd, NULL,
577 "add a user to a group");
578 cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to add");
579 cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to modify");
580 SetupCommonCmdArgs(ts);
582 ts = cmd_CreateSyntax("PtsGroupOwnerChange", DoPtsGroupOwnerChange, NULL,
583 "change the owner of a group");
584 cmd_AddParm(ts, "-owner", CMD_SINGLE, CMD_REQUIRED, "new owner");
585 cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to modify");
586 SetupCommonCmdArgs(ts);
588 ts = cmd_CreateSyntax("PtsGroupCreate", DoPtsGroupCreate, NULL,
589 "create a new group");
590 cmd_AddParm(ts, "-owner", CMD_SINGLE, CMD_REQUIRED, "owner of group");
591 cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to create");
592 SetupCommonCmdArgs(ts);
594 ts = cmd_CreateSyntax("PtsGroupGet", DoPtsGroupGet, NULL,
595 "get information about a group");
596 cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to query");
597 SetupCommonCmdArgs(ts);
599 ts = cmd_CreateSyntax("PtsGroupDelete", DoPtsGroupDelete, NULL,
601 cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to delete");
602 SetupCommonCmdArgs(ts);
604 ts = cmd_CreateSyntax("PtsGroupMaxGet", DoPtsGroupMaxGet, NULL,
605 "get the maximum group id");
606 SetupCommonCmdArgs(ts);
608 ts = cmd_CreateSyntax("PtsGroupMaxSet", DoPtsGroupMaxSet, NULL,
609 "set the maximum group id");
610 cmd_AddParm(ts, "-max", CMD_SINGLE, CMD_REQUIRED, "new max group id");
611 SetupCommonCmdArgs(ts);
613 ts = cmd_CreateSyntax("PtsGroupMemberList", DoPtsGroupMemberList, NULL,
614 "list members of a group");
615 cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to query");
616 SetupCommonCmdArgs(ts);
618 ts = cmd_CreateSyntax("PtsGroupMemberRemove", DoPtsGroupMemberRemove, NULL,
619 "remove a member from a group");
620 cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to remove");
621 cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to modify");
622 SetupCommonCmdArgs(ts);
624 ts = cmd_CreateSyntax("PtsGroupRename", DoPtsGroupRename, NULL,
626 cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to modify");
627 cmd_AddParm(ts, "-newname", CMD_SINGLE, CMD_REQUIRED, "new group name");
628 SetupCommonCmdArgs(ts);
630 ts = cmd_CreateSyntax("PtsGroupModify", DoPtsGroupModify, NULL,
632 cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to modify");
633 cmd_AddParm(ts, "-liststatus", CMD_SINGLE, CMD_REQUIRED,
634 "list status permission <owner | group | any>");
635 cmd_AddParm(ts, "-listgroupsowned", CMD_SINGLE, CMD_REQUIRED,
636 "list groups owned permission <owner | any>");
637 cmd_AddParm(ts, "-listmembership", CMD_SINGLE, CMD_REQUIRED,
638 "list membership permission <owner | group | any>");
639 cmd_AddParm(ts, "-listadd", CMD_SINGLE, CMD_REQUIRED,
640 "list add permission <owner | group | any>");
641 cmd_AddParm(ts, "-listdelete", CMD_SINGLE, CMD_REQUIRED,
642 "list delete permission <owner | group>");
643 SetupCommonCmdArgs(ts);
645 ts = cmd_CreateSyntax("PtsUserCreate", DoPtsUserCreate, NULL,
646 "create a new user");
647 cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to create");
648 SetupCommonCmdArgs(ts);
650 ts = cmd_CreateSyntax("PtsUserDelete", DoPtsUserDelete, NULL,
652 cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to delete");
653 SetupCommonCmdArgs(ts);
655 ts = cmd_CreateSyntax("PtsUserGet", DoPtsUserGet, NULL,
656 "get information about a user");
657 cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to query");
658 SetupCommonCmdArgs(ts);
660 ts = cmd_CreateSyntax("PtsUserRename", DoPtsUserRename, NULL,
662 cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to modify");
663 cmd_AddParm(ts, "-newname", CMD_SINGLE, CMD_REQUIRED, "new user name");
664 SetupCommonCmdArgs(ts);
666 ts = cmd_CreateSyntax("PtsUserModify", DoPtsUserModify, NULL,
668 cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to modify");
669 cmd_AddParm(ts, "-groupquota", CMD_SINGLE, CMD_OPTIONAL,
670 "group creation quota");
671 cmd_AddParm(ts, "-liststatus", CMD_SINGLE, CMD_OPTIONAL,
672 "list status permission <owner | any>");
673 cmd_AddParm(ts, "-listgroupsowned", CMD_SINGLE, CMD_OPTIONAL,
674 "list groups owned permission <owner | any>");
675 cmd_AddParm(ts, "-listmembership", CMD_SINGLE, CMD_OPTIONAL,
676 "list membership permission <owner | any>");
677 SetupCommonCmdArgs(ts);
679 ts = cmd_CreateSyntax("PtsUserMaxGet", DoPtsUserMaxGet, NULL,
680 "get the max user id");
681 SetupCommonCmdArgs(ts);
683 ts = cmd_CreateSyntax("PtsUserMaxSet", DoPtsUserMaxSet, NULL,
684 "set the max user id");
685 cmd_AddParm(ts, "-max", CMD_SINGLE, CMD_REQUIRED, "max user id");
686 SetupCommonCmdArgs(ts);
688 ts = cmd_CreateSyntax("PtsUserMemberList", DoPtsUserMemberList, NULL,
689 "list group membership for a user");
690 cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to query");
691 SetupCommonCmdArgs(ts);
693 ts = cmd_CreateSyntax("PtsOwnedGroupList", DoPtsOwnedGroupList, NULL,
694 "list groups owned by a user");
695 cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to query");
696 SetupCommonCmdArgs(ts);