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>
26 * Generic fuction for converting input string to an integer. Pass
27 * the error_msg you want displayed if there is an error converting
32 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) {
52 pts_groupAccess_t access;
54 if (!strcasecmp("owner", in_str)) {
55 access = PTS_GROUP_OWNER_ACCESS;
56 } else if (!strcasecmp("group", in_str)) {
57 access = PTS_GROUP_ACCESS;
58 } else if (!strcasecmp("any", in_str)) {
59 access = PTS_GROUP_ANYUSER_ACCESS;
68 * Generic fuction for converting input string to an pts_userAccess_t. Pass
69 * the error_msg you want displayed if there is an error converting
73 static pts_userAccess_t
74 GetUserAccessFromString(const char *in_str, const char *error_msg) {
75 pts_userAccess_t access;
77 if (!strcasecmp("owner", in_str)) {
78 access = PTS_USER_OWNER_ACCESS;
79 } else if (!strcasecmp("any", in_str)) {
80 access = PTS_USER_ANYUSER_ACCESS;
89 DoPtsGroupMemberAdd(struct cmd_syndesc *as, char *arock)
91 typedef enum {USER, GROUP}
92 DoPtsGroupMemberAdd_parm_t;
94 const char *user = as->parms[USER].items->data;
95 const char *group = as->parms[GROUP].items->data;
97 if (!pts_GroupMemberAdd(cellHandle, user, group, &st)) {
98 ERR_ST_EXT("pts_GroupMemberAdd", st);
105 DoPtsGroupOwnerChange(struct cmd_syndesc *as, char *arock)
107 typedef enum {OWNER, GROUP}
108 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, char *arock)
123 typedef enum {OWNER, GROUP}
124 DoPtsGroupCreate_parm_t;
126 const char *owner = as->parms[OWNER].items->data;
127 const char *group = as->parms[GROUP].items->data;
130 if (!pts_GroupCreate(cellHandle, group, owner, &new_group_id, &st)) {
131 ERR_ST_EXT("pts_GroupMemberAdd", st);
134 printf("Group id %d\n", new_group_id);
140 Print_pts_groupAccess_p(pts_groupAccess_p access, const char *prefix)
142 if (*access == PTS_GROUP_OWNER_ACCESS) {
143 printf("%sPTS_GROUP_OWNER_ACCESS\n", prefix);
144 } else if (*access == PTS_GROUP_ACCESS) {
145 printf("%sPTS_GROUP_ACCESS\n", prefix);
146 } else if (*access == PTS_GROUP_ANYUSER_ACCESS) {
147 printf("%sPTS_GROUP_ANYUSER_ACCESS\n", prefix);
152 Print_pts_GroupEntry_p(pts_GroupEntry_p entry, const char *prefix)
154 printf("%sName %s Uid %d\n", prefix, entry->name, entry->nameUid);
155 printf("%sOwner %s Uid %d\n", prefix, entry->owner, entry->ownerUid);
156 printf("%sCreator %s Uid %d\n", prefix, entry->creator, entry->creatorUid);
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, char *arock)
174 DoPtsGroupGet_parm_t;
176 const char *group = as->parms[GROUP].items->data;
177 pts_GroupEntry_t entry;
179 if (!pts_GroupGet(cellHandle, group, &entry, &st)) {
180 ERR_ST_EXT("pts_GroupGet", st);
183 Print_pts_GroupEntry_p(&entry, "");
189 DoPtsGroupDelete(struct cmd_syndesc *as, char *arock)
192 DoPtsGroupDelete_parm_t;
194 const char *group = as->parms[GROUP].items->data;
196 if (!pts_GroupDelete(cellHandle, group, &st)) {
197 ERR_ST_EXT("pts_GroupDelete", st);
204 DoPtsGroupMaxGet(struct cmd_syndesc *as, char *arock)
209 if (!pts_GroupMaxGet(cellHandle, &max_group_id, &st)) {
210 ERR_ST_EXT("pts_GroupMaxGet", st);
217 DoPtsGroupMaxSet(struct cmd_syndesc *as, char *arock)
220 DoPtsGroupMaxSet_parm_t;
222 const char *max = as->parms[MAX].items->data;
225 max_group_id = GetIntFromString(max, "bad group id");
227 if (!pts_GroupMaxSet(cellHandle, max_group_id, &st)) {
228 ERR_ST_EXT("pts_GroupMaxSet", st);
235 DoPtsGroupMemberList(struct cmd_syndesc *as, char *arock)
238 DoPtsGroupMemberList_parm_t;
240 const char *group = as->parms[GROUP].items->data;
242 char member[PTS_MAX_NAME_LEN];
244 if (!pts_GroupMemberListBegin(cellHandle, group, &iter, &st)) {
245 ERR_ST_EXT("pts_GroupMemberListBegin", st);
248 printf("Listing members of group %s\n", group);
249 while(pts_GroupMemberListNext(iter, member, &st)) {
250 printf("\t%s\n", member);
253 if (st != ADMITERATORDONE) {
254 ERR_ST_EXT("pts_GroupMemberListNext", st);
257 if (!pts_GroupMemberListDone(iter, &st)) {
258 ERR_ST_EXT("pts_GroupMemberListDone", st);
265 DoPtsGroupMemberRemove(struct cmd_syndesc *as, char *arock)
267 typedef enum {USER, GROUP}
268 DoPtsGroupMemberRemove_parm_t;
270 const char *user = as->parms[USER].items->data;
271 const char *group = as->parms[GROUP].items->data;
273 if (!pts_GroupMemberRemove(cellHandle, user, group, &st)) {
274 ERR_ST_EXT("pts_GroupMemberRemove", st);
281 DoPtsGroupRename(struct cmd_syndesc *as, char *arock)
283 typedef enum {GROUP, NEWNAME}
284 DoPtsGroupRename_parm_t;
286 const char *group = as->parms[GROUP].items->data;
287 const char *new_name = as->parms[NEWNAME].items->data;
289 if (!pts_GroupRename(cellHandle, group, new_name, &st)) {
290 ERR_ST_EXT("pts_GroupRename", st);
297 DoPtsGroupModify(struct cmd_syndesc *as, char *arock)
299 typedef enum {GROUP, LISTSTATUS, LISTGROUPSOWNED, LISTMEMBERSHIP,
301 DoPtsGroupModify_parm_t;
303 const char *group = as->parms[GROUP].items->data;
304 pts_GroupUpdateEntry_t entry;
307 GetGroupAccessFromString(as->parms[LISTSTATUS].items->data,
308 "invalid permission specifier");
309 entry.listGroupsOwned =
310 GetGroupAccessFromString(as->parms[LISTGROUPSOWNED].items->data,
311 "invalid permission specifier");
312 entry.listMembership =
313 GetGroupAccessFromString(as->parms[LISTMEMBERSHIP].items->data,
314 "invalid permission specifier");
316 GetGroupAccessFromString(as->parms[LISTADD].items->data,
317 "invalid permission specifier");
319 GetGroupAccessFromString(as->parms[LISTDELTE].items->data,
320 "invalid permission specifier");
322 if (!pts_GroupModify(cellHandle, group, &entry, &st)) {
323 ERR_ST_EXT("pts_GroupModify", st);
330 DoPtsUserCreate(struct cmd_syndesc *as, char *arock)
333 DoPtsUserCreate_parm_t;
335 const char *user = as->parms[USER].items->data;
338 if (!pts_UserCreate(cellHandle, user, &new_user_id, &st)) {
339 ERR_ST_EXT("pts_UserCreate", st);
342 printf("Created user id %d\n", new_user_id);
348 DoPtsUserDelete(struct cmd_syndesc *as, char *arock)
351 DoPtsUserDelete_parm_t;
353 const char *user = as->parms[USER].items->data;
355 if (!pts_UserDelete(cellHandle, user, &st)) {
356 ERR_ST_EXT("pts_UserDelete", st);
363 Print_pts_userAccess_p(pts_userAccess_p access, const char *prefix)
365 if (*access == PTS_USER_OWNER_ACCESS) {
366 printf("%sPTS_USER_OWNER_ACCESS\n", prefix);
367 } else if (*access == PTS_USER_ANYUSER_ACCESS) {
368 printf("%sPTS_USER_ANYUSER_ACCESS\n", prefix);
373 Print_pts_UserEntry_p(pts_UserEntry_p entry, const char *prefix)
375 printf("%sName %s Uid %d\n", prefix, entry->name, entry->nameUid);
376 printf("%sOwner %s Uid %d\n", prefix, entry->owner, entry->ownerUid);
377 printf("%sCreator %s Uid %d\n", prefix, entry->creator, entry->creatorUid);
378 printf("%sGroup creation quota %d\n", prefix, entry->groupCreationQuota);
379 printf("%sGroup membership count %d\n",
381 entry->groupMembershipCount);
382 printf("%sList status permission\n", prefix);
383 Print_pts_userAccess_p(&entry->listStatus, " ");
384 printf("%sList groups owned permission\n", prefix);
385 Print_pts_userAccess_p(&entry->listGroupsOwned, " ");
386 printf("%sList membership permission\n", prefix);
387 Print_pts_userAccess_p(&entry->listMembership, " ");
388 printf("%s\n", prefix);
392 DoPtsUserGet(struct cmd_syndesc *as, char *arock)
397 const char *user = as->parms[USER].items->data;
398 pts_UserEntry_t entry;
400 if (!pts_UserGet(cellHandle, user, &entry, &st)) {
401 ERR_ST_EXT("pts_UserGet", st);
404 Print_pts_UserEntry_p(&entry, "");
410 DoPtsUserRename(struct cmd_syndesc *as, char *arock)
412 typedef enum {USER, NEWNAME}
413 DoPtsUserRename_parm_t;
415 const char *user = as->parms[USER].items->data;
416 const char *new_name = as->parms[NEWNAME].items->data;
418 if (!pts_UserRename(cellHandle, user, new_name, &st)) {
419 ERR_ST_EXT("pts_UserRename", st);
426 DoPtsUserModify(struct cmd_syndesc *as, char *arock)
428 typedef enum {USER, GROUPQUOTA, LISTSTATUS, LISTGROUPSOWNED, LISTMEMBERSHIP}
429 DoPtsUserModify_parm_t;
431 const char *user = as->parms[USER].items->data;
432 pts_UserUpdateEntry_t entry;
434 int have_list_status_perm = 0;
435 int have_list_groups_owned_perm = 0;
436 int have_list_membership_perm = 0;
440 if (as->parms[GROUPQUOTA].items) {
441 entry.groupCreationQuota =
442 GetIntFromString(as->parms[GROUPQUOTA].items->data, "bad quota");
443 entry.flag = PTS_USER_UPDATE_GROUP_CREATE_QUOTA;
447 if (as->parms[LISTSTATUS].items) {
449 GetUserAccessFromString(as->parms[LISTSTATUS].items->data,
450 "invalid permission specifier");
451 entry.flag |= PTS_USER_UPDATE_PERMISSIONS;
452 have_list_status_perm = 1;
455 if (as->parms[LISTGROUPSOWNED].items) {
456 entry.listGroupsOwned =
457 GetUserAccessFromString(as->parms[LISTGROUPSOWNED].items->data,
458 "invalid permission specifier");
459 entry.flag |= PTS_USER_UPDATE_PERMISSIONS;
460 have_list_groups_owned_perm = 1;
463 if (as->parms[LISTMEMBERSHIP].items) {
464 entry.listMembership =
465 GetUserAccessFromString(as->parms[LISTMEMBERSHIP].items->data,
466 "invalid permission specifier");
467 entry.flag |= PTS_USER_UPDATE_PERMISSIONS;
468 have_list_membership_perm = 1;
471 if (entry.flag == 0) {
472 ERR_EXT("you must specify either quota or permissions to modify");
474 if (entry.flag & PTS_USER_UPDATE_PERMISSIONS) {
475 if ((have_list_status_perm + have_list_groups_owned_perm +
476 have_list_membership_perm) != 3) {
477 ERR_EXT("you must completely specify all permissions "
478 "when modifying a user");
483 if (!pts_UserModify(cellHandle, user, &entry, &st)) {
484 ERR_ST_EXT("pts_UserModify", st);
491 DoPtsUserMaxGet(struct cmd_syndesc *as, char *arock)
496 if (!pts_UserMaxGet(cellHandle, &max_user_id, &st)) {
497 ERR_ST_EXT("pts_UserMaxGet", st);
504 DoPtsUserMaxSet(struct cmd_syndesc *as, char *arock)
507 DoPtsUserMaxSet_parm_t;
509 const char *max = as->parms[MAX].items->data;
512 max_user_id = GetIntFromString(max, "bad user id");
514 if (!pts_UserMaxSet(cellHandle, max_user_id, &st)) {
515 ERR_ST_EXT("pts_UserMaxSet", st);
522 DoPtsUserMemberList(struct cmd_syndesc *as, char *arock)
525 DoPtsUserMemberList_parm_t;
527 const char *user = as->parms[USER].items->data;
529 char group[PTS_MAX_NAME_LEN];
531 if (!pts_UserMemberListBegin(cellHandle, user, &iter, &st)) {
532 ERR_ST_EXT("pts_UserMemberListBegin", st);
535 printf("Listing group membership for %s\n", user);
537 while(pts_UserMemberListNext(iter, group, &st)) {
538 printf("\t%s\n", group);
541 if (st != ADMITERATORDONE) {
542 ERR_ST_EXT("pts_UserMemberListNext", st);
545 if (!pts_UserMemberListDone(iter, &st)) {
546 ERR_ST_EXT("pts_UserMemberListDone", st);
553 DoPtsOwnedGroupList(struct cmd_syndesc *as, char *arock)
556 DoPtsOwnedGroupList_parm_t;
558 const char *user = as->parms[USER].items->data;
560 char group[PTS_MAX_NAME_LEN];
562 if (!pts_OwnedGroupListBegin(cellHandle, user, &iter, &st)) {
563 ERR_ST_EXT("pts_OwnedGroupListBegin", st);
566 printf("Listing groups owned by %s\n", user);
568 while(pts_OwnedGroupListNext(iter, group, &st)) {
569 printf("\t%s\n", group);
572 if (st != ADMITERATORDONE) {
573 ERR_ST_EXT("pts_OwnedGroupListNext", st);
576 if (!pts_OwnedGroupListDone(iter, &st)) {
577 ERR_ST_EXT("pts_OwnedGroupListDone", st);
584 SetupPtsAdminCmd(void)
586 struct cmd_syndesc *ts;
588 ts = cmd_CreateSyntax("PtsGroupMemberAdd",
589 DoPtsGroupMemberAdd, 0,
590 "add a user to a group");
601 SetupCommonCmdArgs(ts);
603 ts = cmd_CreateSyntax("PtsGroupOwnerChange",
604 DoPtsGroupOwnerChange, 0,
605 "change the owner of a group");
616 SetupCommonCmdArgs(ts);
618 ts = cmd_CreateSyntax("PtsGroupCreate",
620 "create a new group");
631 SetupCommonCmdArgs(ts);
633 ts = cmd_CreateSyntax("PtsGroupGet",
635 "get information about a group");
641 SetupCommonCmdArgs(ts);
643 ts = cmd_CreateSyntax("PtsGroupDelete",
651 SetupCommonCmdArgs(ts);
653 ts = cmd_CreateSyntax("PtsGroupMaxGet",
655 "get the maximum group id");
656 SetupCommonCmdArgs(ts);
658 ts = cmd_CreateSyntax("PtsGroupMaxSet",
660 "set the maximum group id");
666 SetupCommonCmdArgs(ts);
668 ts = cmd_CreateSyntax("PtsGroupMemberList",
669 DoPtsGroupMemberList, 0,
670 "list members of a group");
676 SetupCommonCmdArgs(ts);
678 ts = cmd_CreateSyntax("PtsGroupMemberRemove",
679 DoPtsGroupMemberRemove, 0,
680 "remove a member from a group");
691 SetupCommonCmdArgs(ts);
693 ts = cmd_CreateSyntax("PtsGroupRename",
706 SetupCommonCmdArgs(ts);
708 ts = cmd_CreateSyntax("PtsGroupModify",
720 "list status permission <owner | group | any>");
725 "list groups owned permission <owner | any>");
730 "list membership permission <owner | group | any>");
735 "list add permission <owner | group | any>");
740 "list delete permission <owner | group>");
741 SetupCommonCmdArgs(ts);
743 ts = cmd_CreateSyntax("PtsUserCreate",
745 "create a new user");
751 SetupCommonCmdArgs(ts);
753 ts = cmd_CreateSyntax("PtsUserDelete",
761 SetupCommonCmdArgs(ts);
763 ts = cmd_CreateSyntax("PtsUserGet",
765 "get information about a user");
771 SetupCommonCmdArgs(ts);
773 ts = cmd_CreateSyntax("PtsUserRename",
786 SetupCommonCmdArgs(ts);
788 ts = cmd_CreateSyntax("PtsUserModify",
800 "group creation quota");
805 "list status permission <owner | any>");
810 "list groups owned permission <owner | any>");
815 "list membership permission <owner | any>");
816 SetupCommonCmdArgs(ts);
818 ts = cmd_CreateSyntax("PtsUserMaxGet",
820 "get the max user id");
821 SetupCommonCmdArgs(ts);
823 ts = cmd_CreateSyntax("PtsUserMaxSet",
825 "set the max user id");
831 SetupCommonCmdArgs(ts);
833 ts = cmd_CreateSyntax("PtsUserMemberList",
834 DoPtsUserMemberList, 0,
835 "list group membership for a user");
841 SetupCommonCmdArgs(ts);
843 ts = cmd_CreateSyntax("PtsOwnedGroupList",
844 DoPtsOwnedGroupList, 0,
845 "list groups owned by a user");
851 SetupCommonCmdArgs(ts);