src/libadmin/test/pts.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 pts related funtions for afscp
  12  */
  13
  14 #include <afsconfig.h>
  15 #include <afs/param.h>
  16
  17 RCSID("$Header$");
  18
  19 #include "pts.h"
  20
  21 /*
  22  * Utility functions
  23  */
  24
  25 /*
  26  * Generic fuction for converting input string to an integer.  Pass
  27  * the error_msg you want displayed if there is an error converting
  28  * the string.
  29  */
  30
  31 static int
  32 GetIntFromString(const char *int_str, const char *error_msg) {
  33     int i;
  34     char *bad_char = NULL;
  35
  36     i = strtoul(int_str, &bad_char, 10);
  37     if ((bad_char == NULL) || (*bad_char == 0)) {
  38         return i;
  39     }
  40
  41     ERR_EXT(error_msg);
  42 }
  43
  44 /*
  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
  47  * the string.
  48  */
  49
  50 static pts_groupAccess_t
  51 GetGroupAccessFromString(const char *in_str, const char *error_msg) {
  52     pts_groupAccess_t access;
  53
  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;
  60     } else {
  61         ERR_EXT(error_msg);
  62     }
  63
  64     return access;
  65 }
  66
  67 /*
  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
  70  * the string.
  71  */
  72
  73 static pts_userAccess_t
  74 GetUserAccessFromString(const char *in_str, const char *error_msg) {
  75     pts_userAccess_t access;
  76
  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;
  81     } else {
  82         ERR_EXT(error_msg);
  83     }
  84
  85     return access;
  86 }
  87
  88 int
  89 DoPtsGroupMemberAdd(struct cmd_syndesc *as, char *arock)
  90 {
  91     typedef enum {USER, GROUP}
  92       DoPtsGroupMemberAdd_parm_t;
  93     afs_status_t st = 0;
  94     const char *user = as->parms[USER].items->data;
  95     const char *group = as->parms[GROUP].items->data;
  96
  97     if (!pts_GroupMemberAdd(cellHandle, user, group, &st)) {
  98         ERR_ST_EXT("pts_GroupMemberAdd", st);
  99     }
 100
 101     return 0;
 102 }
 103
 104 int
 105 DoPtsGroupOwnerChange(struct cmd_syndesc *as, char *arock)
 106 {
 107     typedef enum {OWNER, GROUP}
 108       DoPtsGroupOwnerChange_parm_t;
 109     afs_status_t st = 0;
 110     const char *owner = as->parms[OWNER].items->data;
 111     const char *group = as->parms[GROUP].items->data;
 112
 113     if (!pts_GroupOwnerChange(cellHandle, group, owner, &st)) {
 114         ERR_ST_EXT("pts_GroupOwnerChange", st);
 115     }
 116
 117     return 0;
 118 }
 119
 120 int
 121 DoPtsGroupCreate(struct cmd_syndesc *as, char *arock)
 122 {
 123     typedef enum {OWNER, GROUP}
 124       DoPtsGroupCreate_parm_t;
 125     afs_status_t st = 0;
 126     const char *owner = as->parms[OWNER].items->data;
 127     const char *group = as->parms[GROUP].items->data;
 128     int new_group_id;
 129
 130     if (!pts_GroupCreate(cellHandle, group, owner, &new_group_id, &st)) {
 131         ERR_ST_EXT("pts_GroupMemberAdd", st);
 132     }
 133
 134     printf("Group id %d\n", new_group_id);
 135
 136     return 0;
 137 }
 138
 139 static void
 140 Print_pts_groupAccess_p(pts_groupAccess_p access, const char *prefix)
 141 {
 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);
 148     }
 149 }
 150
 151 static void
 152 Print_pts_GroupEntry_p(pts_GroupEntry_p entry, const char *prefix)
 153 {
 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, "    ");
 168 }
 169
 170 int
 171 DoPtsGroupGet(struct cmd_syndesc *as, char *arock)
 172 {
 173     typedef enum {GROUP}
 174       DoPtsGroupGet_parm_t;
 175     afs_status_t st = 0;
 176     const char *group = as->parms[GROUP].items->data;
 177     pts_GroupEntry_t entry;
 178
 179     if (!pts_GroupGet(cellHandle, group, &entry, &st)) {
 180         ERR_ST_EXT("pts_GroupGet", st);
 181     }
 182
 183     Print_pts_GroupEntry_p(&entry, "");
 184
 185     return 0;
 186 }
 187
 188 int
 189 DoPtsGroupDelete(struct cmd_syndesc *as, char *arock)
 190 {
 191     typedef enum {GROUP}
 192       DoPtsGroupDelete_parm_t;
 193     afs_status_t st = 0;
 194     const char *group = as->parms[GROUP].items->data;
 195
 196     if (!pts_GroupDelete(cellHandle, group, &st)) {
 197         ERR_ST_EXT("pts_GroupDelete", st);
 198     }
 199
 200     return 0;
 201 }
 202
 203 int
 204 DoPtsGroupMaxGet(struct cmd_syndesc *as, char *arock)
 205 {
 206     afs_status_t st = 0;
 207     int max_group_id;
 208
 209     if (!pts_GroupMaxGet(cellHandle, &max_group_id, &st)) {
 210         ERR_ST_EXT("pts_GroupMaxGet", st);
 211     }
 212
 213     return 0;
 214 }
 215
 216 int
 217 DoPtsGroupMaxSet(struct cmd_syndesc *as, char *arock)
 218 {
 219     typedef enum {MAX}
 220       DoPtsGroupMaxSet_parm_t;
 221     afs_status_t st = 0;
 222     const char *max = as->parms[MAX].items->data;
 223     int max_group_id;
 224
 225     max_group_id = GetIntFromString(max, "bad group id");
 226
 227     if (!pts_GroupMaxSet(cellHandle, max_group_id, &st)) {
 228         ERR_ST_EXT("pts_GroupMaxSet", st);
 229     }
 230
 231     return 0;
 232 }
 233
 234 int
 235 DoPtsGroupMemberList(struct cmd_syndesc *as, char *arock)
 236 {
 237     typedef enum {GROUP}
 238       DoPtsGroupMemberList_parm_t;
 239     afs_status_t st = 0;
 240     const char *group = as->parms[GROUP].items->data;
 241     void *iter;
 242     char member[PTS_MAX_NAME_LEN];
 243
 244     if (!pts_GroupMemberListBegin(cellHandle, group, &iter, &st)) {
 245         ERR_ST_EXT("pts_GroupMemberListBegin", st);
 246     }
 247
 248     printf("Listing members of group %s\n", group);
 249     while(pts_GroupMemberListNext(iter, member, &st)) {
 250         printf("\t%s\n", member);
 251     }
 252
 253     if (st != ADMITERATORDONE) {
 254         ERR_ST_EXT("pts_GroupMemberListNext", st);
 255     }
 256
 257     if (!pts_GroupMemberListDone(iter, &st)) {
 258         ERR_ST_EXT("pts_GroupMemberListDone", st);
 259     }
 260
 261     return 0;
 262 }
 263
 264 int
 265 DoPtsGroupMemberRemove(struct cmd_syndesc *as, char *arock)
 266 {
 267     typedef enum {USER, GROUP}
 268       DoPtsGroupMemberRemove_parm_t;
 269     afs_status_t st = 0;
 270     const char *user = as->parms[USER].items->data;
 271     const char *group = as->parms[GROUP].items->data;
 272
 273     if (!pts_GroupMemberRemove(cellHandle, user, group, &st)) {
 274         ERR_ST_EXT("pts_GroupMemberRemove", st);
 275     }
 276
 277     return 0;
 278 }
 279
 280 int
 281 DoPtsGroupRename(struct cmd_syndesc *as, char *arock)
 282 {
 283     typedef enum {GROUP, NEWNAME}
 284       DoPtsGroupRename_parm_t;
 285     afs_status_t st = 0;
 286     const char *group = as->parms[GROUP].items->data;
 287     const char *new_name = as->parms[NEWNAME].items->data;
 288
 289     if (!pts_GroupRename(cellHandle, group, new_name, &st)) {
 290         ERR_ST_EXT("pts_GroupRename", st);
 291     }
 292
 293     return 0;
 294 }
 295
 296 int
 297 DoPtsGroupModify(struct cmd_syndesc *as, char *arock)
 298 {
 299     typedef enum {GROUP, LISTSTATUS, LISTGROUPSOWNED, LISTMEMBERSHIP,
 300       LISTADD, LISTDELTE}
 301       DoPtsGroupModify_parm_t;
 302     afs_status_t st = 0;
 303     const char *group = as->parms[GROUP].items->data;
 304     pts_GroupUpdateEntry_t entry;
 305
 306     entry.listStatus =
 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");
 315     entry.listAdd =
 316         GetGroupAccessFromString(as->parms[LISTADD].items->data,
 317                                  "invalid permission specifier");
 318     entry.listDelete =
 319         GetGroupAccessFromString(as->parms[LISTDELTE].items->data,
 320                                  "invalid permission specifier");
 321
 322     if (!pts_GroupModify(cellHandle, group, &entry, &st)) {
 323         ERR_ST_EXT("pts_GroupModify", st);
 324     }
 325
 326     return 0;
 327 }
 328
 329 int
 330 DoPtsUserCreate(struct cmd_syndesc *as, char *arock)
 331 {
 332     typedef enum {USER}
 333       DoPtsUserCreate_parm_t;
 334     afs_status_t st = 0;
 335     const char *user = as->parms[USER].items->data;
 336     int new_user_id;
 337
 338     if (!pts_UserCreate(cellHandle, user, &new_user_id, &st)) {
 339         ERR_ST_EXT("pts_UserCreate", st);
 340     }
 341
 342     printf("Created user id %d\n", new_user_id);
 343
 344     return 0;
 345 }
 346
 347 int
 348 DoPtsUserDelete(struct cmd_syndesc *as, char *arock)
 349 {
 350     typedef enum {USER}
 351       DoPtsUserDelete_parm_t;
 352     afs_status_t st = 0;
 353     const char *user = as->parms[USER].items->data;
 354
 355     if (!pts_UserDelete(cellHandle, user, &st)) {
 356         ERR_ST_EXT("pts_UserDelete", st);
 357     }
 358
 359     return 0;
 360 }
 361
 362 static void
 363 Print_pts_userAccess_p(pts_userAccess_p access, const char *prefix)
 364 {
 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);
 369     }
 370 }
 371
 372 static void
 373 Print_pts_UserEntry_p(pts_UserEntry_p entry, const char *prefix)
 374 {
 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",
 380            prefix,
 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);
 389 }
 390
 391 int
 392 DoPtsUserGet(struct cmd_syndesc *as, char *arock)
 393 {
 394     typedef enum {USER}
 395       DoPtsUserGet_parm_t;
 396     afs_status_t st = 0;
 397     const char *user = as->parms[USER].items->data;
 398     pts_UserEntry_t entry;
 399
 400     if (!pts_UserGet(cellHandle, user, &entry, &st)) {
 401         ERR_ST_EXT("pts_UserGet", st);
 402     }
 403
 404     Print_pts_UserEntry_p(&entry, "");
 405
 406     return 0;
 407 }
 408
 409 int
 410 DoPtsUserRename(struct cmd_syndesc *as, char *arock)
 411 {
 412     typedef enum {USER, NEWNAME}
 413       DoPtsUserRename_parm_t;
 414     afs_status_t st = 0;
 415     const char *user = as->parms[USER].items->data;
 416     const char *new_name = as->parms[NEWNAME].items->data;
 417
 418     if (!pts_UserRename(cellHandle, user, new_name, &st)) {
 419         ERR_ST_EXT("pts_UserRename", st);
 420     }
 421
 422     return 0;
 423 }
 424
 425 int
 426 DoPtsUserModify(struct cmd_syndesc *as, char *arock)
 427 {
 428     typedef enum {USER, GROUPQUOTA, LISTSTATUS, LISTGROUPSOWNED, LISTMEMBERSHIP}
 429       DoPtsUserModify_parm_t;
 430     afs_status_t st = 0;
 431     const char *user = as->parms[USER].items->data;
 432     pts_UserUpdateEntry_t entry;
 433     int have_quota = 0;
 434     int have_list_status_perm = 0;
 435     int have_list_groups_owned_perm = 0;
 436     int have_list_membership_perm = 0;
 437
 438     entry.flag = 0;
 439
 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;
 444         have_quota = 1;
 445     }
 446
 447     if (as->parms[LISTSTATUS].items) {
 448         entry.listStatus =
 449             GetUserAccessFromString(as->parms[LISTSTATUS].items->data,
 450                                     "invalid permission specifier");
 451         entry.flag |= PTS_USER_UPDATE_PERMISSIONS;
 452         have_list_status_perm = 1;
 453     }
 454
 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;
 461     }
 462
 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;
 469     }
 470
 471     if (entry.flag == 0) {
 472         ERR_EXT("you must specify either quota or permissions to modify");
 473     } else {
 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");
 479             }
 480         }
 481     }
 482
 483     if (!pts_UserModify(cellHandle, user, &entry, &st)) {
 484         ERR_ST_EXT("pts_UserModify", st);
 485     }
 486
 487     return 0;
 488 }
 489
 490 int
 491 DoPtsUserMaxGet(struct cmd_syndesc *as, char *arock)
 492 {
 493     afs_status_t st = 0;
 494     int max_user_id;
 495
 496     if (!pts_UserMaxGet(cellHandle, &max_user_id, &st)) {
 497         ERR_ST_EXT("pts_UserMaxGet", st);
 498     }
 499
 500     return 0;
 501 }
 502
 503 int
 504 DoPtsUserMaxSet(struct cmd_syndesc *as, char *arock)
 505 {
 506     typedef enum {MAX}
 507       DoPtsUserMaxSet_parm_t;
 508     afs_status_t st = 0;
 509     const char *max = as->parms[MAX].items->data;
 510     int max_user_id;
 511
 512     max_user_id = GetIntFromString(max, "bad user id");
 513
 514     if (!pts_UserMaxSet(cellHandle, max_user_id, &st)) {
 515         ERR_ST_EXT("pts_UserMaxSet", st);
 516     }
 517
 518     return 0;
 519 }
 520
 521 int
 522 DoPtsUserMemberList(struct cmd_syndesc *as, char *arock)
 523 {
 524     typedef enum {USER}
 525       DoPtsUserMemberList_parm_t;
 526     afs_status_t st = 0;
 527     const char *user = as->parms[USER].items->data;
 528     void *iter;
 529     char group[PTS_MAX_NAME_LEN];
 530
 531     if (!pts_UserMemberListBegin(cellHandle, user, &iter, &st)) {
 532         ERR_ST_EXT("pts_UserMemberListBegin", st);
 533     }
 534
 535     printf("Listing group membership for %s\n", user);
 536
 537     while(pts_UserMemberListNext(iter, group, &st)) {
 538         printf("\t%s\n", group);
 539     }
 540
 541     if (st != ADMITERATORDONE) {
 542         ERR_ST_EXT("pts_UserMemberListNext", st);
 543     }
 544
 545     if (!pts_UserMemberListDone(iter, &st)) {
 546         ERR_ST_EXT("pts_UserMemberListDone", st);
 547     }
 548
 549     return 0;
 550 }
 551
 552 int
 553 DoPtsOwnedGroupList(struct cmd_syndesc *as, char *arock)
 554 {
 555     typedef enum {USER}
 556       DoPtsOwnedGroupList_parm_t;
 557     afs_status_t st = 0;
 558     const char *user = as->parms[USER].items->data;
 559     void *iter;
 560     char group[PTS_MAX_NAME_LEN];
 561
 562     if (!pts_OwnedGroupListBegin(cellHandle, user, &iter, &st)) {
 563         ERR_ST_EXT("pts_OwnedGroupListBegin", st);
 564     }
 565
 566     printf("Listing groups owned by %s\n", user);
 567
 568     while(pts_OwnedGroupListNext(iter, group, &st)) {
 569         printf("\t%s\n", group);
 570     }
 571
 572     if (st != ADMITERATORDONE) {
 573         ERR_ST_EXT("pts_OwnedGroupListNext", st);
 574     }
 575
 576     if (!pts_OwnedGroupListDone(iter, &st)) {
 577         ERR_ST_EXT("pts_OwnedGroupListDone", st);
 578     }
 579
 580     return 0;
 581 }
 582
 583 void
 584 SetupPtsAdminCmd(void)
 585 {
 586     struct cmd_syndesc  *ts;
 587
 588     ts = cmd_CreateSyntax("PtsGroupMemberAdd",
 589                           DoPtsGroupMemberAdd, 0,
 590                           "add a user to a group");
 591     cmd_AddParm(ts,
 592                 "-user",
 593                 CMD_SINGLE,
 594                 CMD_REQUIRED,
 595                 "user to add");
 596     cmd_AddParm(ts,
 597                 "-group",
 598                 CMD_SINGLE,
 599                 CMD_REQUIRED,
 600                 "group to modify");
 601     SetupCommonCmdArgs(ts);
 602
 603     ts = cmd_CreateSyntax("PtsGroupOwnerChange",
 604                           DoPtsGroupOwnerChange, 0,
 605                           "change the owner of a group");
 606     cmd_AddParm(ts,
 607                 "-owner",
 608                 CMD_SINGLE,
 609                 CMD_REQUIRED,
 610                 "new owner");
 611     cmd_AddParm(ts,
 612                 "-group",
 613                 CMD_SINGLE,
 614                 CMD_REQUIRED,
 615                 "group to modify");
 616     SetupCommonCmdArgs(ts);
 617
 618     ts = cmd_CreateSyntax("PtsGroupCreate",
 619                           DoPtsGroupCreate, 0,
 620                           "create a new group");
 621     cmd_AddParm(ts,
 622                 "-owner",
 623                 CMD_SINGLE,
 624                 CMD_REQUIRED,
 625                 "owner of group");
 626     cmd_AddParm(ts,
 627                 "-group",
 628                 CMD_SINGLE,
 629                 CMD_REQUIRED,
 630                 "group to create");
 631     SetupCommonCmdArgs(ts);
 632
 633     ts = cmd_CreateSyntax("PtsGroupGet",
 634                           DoPtsGroupGet, 0,
 635                           "get information about a group");
 636     cmd_AddParm(ts,
 637                 "-group",
 638                 CMD_SINGLE,
 639                 CMD_REQUIRED,
 640                 "group to query");
 641     SetupCommonCmdArgs(ts);
 642
 643     ts = cmd_CreateSyntax("PtsGroupDelete",
 644                           DoPtsGroupDelete, 0,
 645                           "delete a group");
 646     cmd_AddParm(ts,
 647                 "-group",
 648                 CMD_SINGLE,
 649                 CMD_REQUIRED,
 650                 "group to delete");
 651     SetupCommonCmdArgs(ts);
 652
 653     ts = cmd_CreateSyntax("PtsGroupMaxGet",
 654                           DoPtsGroupMaxGet, 0,
 655                           "get the maximum group id");
 656     SetupCommonCmdArgs(ts);
 657
 658     ts = cmd_CreateSyntax("PtsGroupMaxSet",
 659                           DoPtsGroupMaxSet, 0,
 660                           "set the maximum group id");
 661     cmd_AddParm(ts,
 662                 "-max",
 663                 CMD_SINGLE,
 664                 CMD_REQUIRED,
 665                 "new max group id");
 666     SetupCommonCmdArgs(ts);
 667
 668     ts = cmd_CreateSyntax("PtsGroupMemberList",
 669                           DoPtsGroupMemberList, 0,
 670                           "list members of a group");
 671     cmd_AddParm(ts,
 672                 "-group",
 673                 CMD_SINGLE,
 674                 CMD_REQUIRED,
 675                 "group to query");
 676     SetupCommonCmdArgs(ts);
 677
 678     ts = cmd_CreateSyntax("PtsGroupMemberRemove",
 679                           DoPtsGroupMemberRemove, 0,
 680                           "remove a member from a group");
 681     cmd_AddParm(ts,
 682                 "-user",
 683                 CMD_SINGLE,
 684                 CMD_REQUIRED,
 685                 "user to remove");
 686     cmd_AddParm(ts,
 687                 "-group",
 688                 CMD_SINGLE,
 689                 CMD_REQUIRED,
 690                 "group to modify");
 691     SetupCommonCmdArgs(ts);
 692
 693     ts = cmd_CreateSyntax("PtsGroupRename",
 694                           DoPtsGroupRename, 0,
 695                           "rename a group");
 696     cmd_AddParm(ts,
 697                 "-group",
 698                 CMD_SINGLE,
 699                 CMD_REQUIRED,
 700                 "group to modify");
 701     cmd_AddParm(ts,
 702                 "-newname",
 703                 CMD_SINGLE,
 704                 CMD_REQUIRED,
 705                 "new group name");
 706     SetupCommonCmdArgs(ts);
 707
 708     ts = cmd_CreateSyntax("PtsGroupModify",
 709                           DoPtsGroupModify, 0,
 710                           "modify a group");
 711     cmd_AddParm(ts,
 712                 "-group",
 713                 CMD_SINGLE,
 714                 CMD_REQUIRED,
 715                 "group to modify");
 716     cmd_AddParm(ts,
 717                 "-liststatus",
 718                 CMD_SINGLE,
 719                 CMD_REQUIRED,
 720                 "list status permission <owner | group | any>");
 721     cmd_AddParm(ts,
 722                 "-listgroupsowned",
 723                 CMD_SINGLE,
 724                 CMD_REQUIRED,
 725                 "list groups owned permission <owner | any>");
 726     cmd_AddParm(ts,
 727                 "-listmembership",
 728                 CMD_SINGLE,
 729                 CMD_REQUIRED,
 730                 "list membership permission <owner | group | any>");
 731     cmd_AddParm(ts,
 732                 "-listadd",
 733                 CMD_SINGLE,
 734                 CMD_REQUIRED,
 735                 "list add permission <owner | group | any>");
 736     cmd_AddParm(ts,
 737                 "-listdelete",
 738                 CMD_SINGLE,
 739                 CMD_REQUIRED,
 740                 "list delete permission <owner | group>");
 741     SetupCommonCmdArgs(ts);
 742
 743     ts = cmd_CreateSyntax("PtsUserCreate",
 744                           DoPtsUserCreate, 0,
 745                           "create a new user");
 746     cmd_AddParm(ts,
 747                 "-user",
 748                 CMD_SINGLE,
 749                 CMD_REQUIRED,
 750                 "user to create");
 751     SetupCommonCmdArgs(ts);
 752
 753     ts = cmd_CreateSyntax("PtsUserDelete",
 754                           DoPtsUserDelete, 0,
 755                           "delete a user");
 756     cmd_AddParm(ts,
 757                 "-user",
 758                 CMD_SINGLE,
 759                 CMD_REQUIRED,
 760                 "user to delete");
 761     SetupCommonCmdArgs(ts);
 762
 763     ts = cmd_CreateSyntax("PtsUserGet",
 764                           DoPtsUserGet, 0,
 765                           "get information about a user");
 766     cmd_AddParm(ts,
 767                 "-user",
 768                 CMD_SINGLE,
 769                 CMD_REQUIRED,
 770                 "user to query");
 771     SetupCommonCmdArgs(ts);
 772
 773     ts = cmd_CreateSyntax("PtsUserRename",
 774                           DoPtsUserRename, 0,
 775                           "rename a user");
 776     cmd_AddParm(ts,
 777                 "-user",
 778                 CMD_SINGLE,
 779                 CMD_REQUIRED,
 780                 "user to modify");
 781     cmd_AddParm(ts,
 782                 "-newname",
 783                 CMD_SINGLE,
 784                 CMD_REQUIRED,
 785                 "new user name");
 786     SetupCommonCmdArgs(ts);
 787
 788     ts = cmd_CreateSyntax("PtsUserModify",
 789                           DoPtsUserModify, 0,
 790                           "change a user");
 791     cmd_AddParm(ts,
 792                 "-user",
 793                 CMD_SINGLE,
 794                 CMD_REQUIRED,
 795                 "user to modify");
 796     cmd_AddParm(ts,
 797                 "-groupquota",
 798                 CMD_SINGLE,
 799                 CMD_OPTIONAL,
 800                 "group creation quota");
 801     cmd_AddParm(ts,
 802                 "-liststatus",
 803                 CMD_SINGLE,
 804                 CMD_OPTIONAL,
 805                 "list status permission <owner | any>");
 806     cmd_AddParm(ts,
 807                 "-listgroupsowned",
 808                 CMD_SINGLE,
 809                 CMD_OPTIONAL,
 810                 "list groups owned permission <owner | any>");
 811     cmd_AddParm(ts,
 812                 "-listmembership",
 813                 CMD_SINGLE,
 814                 CMD_OPTIONAL,
 815                 "list membership permission <owner | any>");
 816     SetupCommonCmdArgs(ts);
 817
 818     ts = cmd_CreateSyntax("PtsUserMaxGet",
 819                           DoPtsUserMaxGet, 0,
 820                           "get the max user id");
 821     SetupCommonCmdArgs(ts);
 822
 823     ts = cmd_CreateSyntax("PtsUserMaxSet",
 824                           DoPtsUserMaxSet, 0,
 825                           "set the max user id");
 826     cmd_AddParm(ts,
 827                 "-max",
 828                 CMD_SINGLE,
 829                 CMD_REQUIRED,
 830                 "max user id");
 831     SetupCommonCmdArgs(ts);
 832
 833     ts = cmd_CreateSyntax("PtsUserMemberList",
 834                           DoPtsUserMemberList, 0,
 835                           "list group membership for a user");
 836     cmd_AddParm(ts,
 837                 "-user",
 838                 CMD_SINGLE,
 839                 CMD_REQUIRED,
 840                 "user to query");
 841     SetupCommonCmdArgs(ts);
 842
 843     ts = cmd_CreateSyntax("PtsOwnedGroupList",
 844                           DoPtsOwnedGroupList, 0,
 845                           "list groups owned by a user");
 846     cmd_AddParm(ts,
 847                 "-user",
 848                 CMD_SINGLE,
 849                 CMD_REQUIRED,
 850                 "user to query");
 851     SetupCommonCmdArgs(ts);
 852 }