00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include "includes.h"
00027 #include "utils/net.h"
00028
00029
00030
00031 #define ERRMSG_TARGET_WG_NOT_VALID "\nTarget workgroup option not valid "\
00032 "except on net rap server command, ignored"
00033 #define ERRMSG_INVALID_HELP_OPTION "\nInvalid help option\n"
00034
00035 #define ERRMSG_BOTH_SERVER_IPADDRESS "\nTarget server and IP address both "\
00036 "specified. Do not set both at the same time. The target IP address was used\n"
00037
00038 const char *share_type[] = {
00039 "Disk",
00040 "Print",
00041 "Dev",
00042 "IPC"
00043 };
00044
00045 static int errmsg_not_implemented(void)
00046 {
00047 d_printf("\nNot implemented\n");
00048 return 0;
00049 }
00050
00051 int net_rap_file_usage(int argc, const char **argv)
00052 {
00053 return net_help_file(argc, argv);
00054 }
00055
00056
00057
00058
00059 static void file_fn(const char * pPath, const char * pUser, uint16 perms,
00060 uint16 locks, uint32 id)
00061 {
00062 d_printf("%-7.1d %-20.20s 0x%-4.2x %-6.1d %s\n",
00063 id, pUser, perms, locks, pPath);
00064 }
00065
00066 static void one_file_fn(const char *pPath, const char *pUser, uint16 perms,
00067 uint16 locks, uint32 id)
00068 {
00069 d_printf("File ID %d\n"\
00070 "User name %s\n"\
00071 "Locks 0x%-4.2x\n"\
00072 "Path %s\n"\
00073 "Permissions 0x%x\n",
00074 id, pUser, locks, pPath, perms);
00075 }
00076
00077
00078 static int rap_file_close(int argc, const char **argv)
00079 {
00080 struct cli_state *cli;
00081 int ret;
00082 if (argc == 0) {
00083 d_printf("\nMissing fileid of file to close\n\n");
00084 return net_rap_file_usage(argc, argv);
00085 }
00086
00087 if (!(cli = net_make_ipc_connection(0)))
00088 return -1;
00089
00090 ret = cli_NetFileClose(cli, atoi(argv[0]));
00091 cli_shutdown(cli);
00092 return ret;
00093 }
00094
00095 static int rap_file_info(int argc, const char **argv)
00096 {
00097 struct cli_state *cli;
00098 int ret;
00099 if (argc == 0)
00100 return net_rap_file_usage(argc, argv);
00101
00102 if (!(cli = net_make_ipc_connection(0)))
00103 return -1;
00104
00105 ret = cli_NetFileGetInfo(cli, atoi(argv[0]), one_file_fn);
00106 cli_shutdown(cli);
00107 return ret;
00108 }
00109
00110 static int rap_file_user(int argc, const char **argv)
00111 {
00112 if (argc == 0)
00113 return net_rap_file_usage(argc, argv);
00114
00115 d_fprintf(stderr, "net rap file user not implemented yet\n");
00116 return -1;
00117 }
00118
00119 int net_rap_file(int argc, const char **argv)
00120 {
00121 struct functable func[] = {
00122 {"CLOSE", rap_file_close},
00123 {"USER", rap_file_user},
00124 {"INFO", rap_file_info},
00125 {NULL, NULL}
00126 };
00127
00128 if (argc == 0) {
00129 struct cli_state *cli;
00130 int ret;
00131
00132 if (!(cli = net_make_ipc_connection(0)))
00133 return -1;
00134
00135
00136 d_printf(
00137 "\nEnumerating open files on remote server:\n\n"\
00138 "\nFileId Opened by Perms Locks Path \n"\
00139 "------ --------- ----- ----- ---- \n");
00140 ret = cli_NetFileEnum(cli, NULL, NULL, file_fn);
00141 cli_shutdown(cli);
00142 return ret;
00143 }
00144
00145 return net_run_function(argc, argv, func, net_rap_file_usage);
00146 }
00147
00148 int net_rap_share_usage(int argc, const char **argv)
00149 {
00150 return net_help_share(argc, argv);
00151 }
00152
00153 static void long_share_fn(const char *share_name, uint32 type,
00154 const char *comment, void *state)
00155 {
00156 d_printf("%-12s %-8.8s %-50s\n",
00157 share_name, share_type[type], comment);
00158 }
00159
00160 static void share_fn(const char *share_name, uint32 type,
00161 const char *comment, void *state)
00162 {
00163 d_printf("%s\n", share_name);
00164 }
00165
00166 static int rap_share_delete(int argc, const char **argv)
00167 {
00168 struct cli_state *cli;
00169 int ret;
00170
00171 if (argc == 0) {
00172 d_printf("\n\nShare name not specified\n");
00173 return net_rap_share_usage(argc, argv);
00174 }
00175
00176 if (!(cli = net_make_ipc_connection(0)))
00177 return -1;
00178
00179 ret = cli_NetShareDelete(cli, argv[0]);
00180 cli_shutdown(cli);
00181 return ret;
00182 }
00183
00184 static int rap_share_add(int argc, const char **argv)
00185 {
00186 struct cli_state *cli;
00187 int ret;
00188
00189 RAP_SHARE_INFO_2 sinfo;
00190 char *p;
00191 char *sharename;
00192
00193 if (argc == 0) {
00194 d_printf("\n\nShare name not specified\n");
00195 return net_rap_share_usage(argc, argv);
00196 }
00197
00198 if (!(cli = net_make_ipc_connection(0)))
00199 return -1;
00200
00201 sharename = SMB_STRDUP(argv[0]);
00202 p = strchr(sharename, '=');
00203 if (p == NULL) {
00204 d_printf("Server path not specified\n");
00205 return net_rap_share_usage(argc, argv);
00206 }
00207 *p = 0;
00208 strlcpy(sinfo.share_name, sharename, sizeof(sinfo.share_name));
00209 sinfo.reserved1 = '\0';
00210 sinfo.share_type = 0;
00211 sinfo.comment = smb_xstrdup(opt_comment);
00212 sinfo.perms = 0;
00213 sinfo.maximum_users = opt_maxusers;
00214 sinfo.active_users = 0;
00215 sinfo.path = p+1;
00216 memset(sinfo.password, '\0', sizeof(sinfo.password));
00217 sinfo.reserved2 = '\0';
00218
00219 ret = cli_NetShareAdd(cli, &sinfo);
00220 cli_shutdown(cli);
00221 return ret;
00222 }
00223
00224
00225 int net_rap_share(int argc, const char **argv)
00226 {
00227 struct functable func[] = {
00228 {"DELETE", rap_share_delete},
00229 {"CLOSE", rap_share_delete},
00230 {"ADD", rap_share_add},
00231 {NULL, NULL}
00232 };
00233
00234 if (argc == 0) {
00235 struct cli_state *cli;
00236 int ret;
00237
00238 if (!(cli = net_make_ipc_connection(0)))
00239 return -1;
00240
00241 if (opt_long_list_entries) {
00242 d_printf(
00243 "\nEnumerating shared resources (exports) on remote server:\n\n"\
00244 "\nShare name Type Description\n"\
00245 "---------- ---- -----------\n");
00246 ret = cli_RNetShareEnum(cli, long_share_fn, NULL);
00247 } else {
00248 ret = cli_RNetShareEnum(cli, share_fn, NULL);
00249 }
00250 cli_shutdown(cli);
00251 return ret;
00252 }
00253
00254 return net_run_function(argc, argv, func, net_rap_share_usage);
00255 }
00256
00257
00258 int net_rap_session_usage(int argc, const char **argv)
00259 {
00260 d_printf(
00261 "\nnet rap session [misc. options] [targets]"\
00262 "\n\tenumerates all active SMB/CIFS sessions on target server\n");
00263 d_printf(
00264 "\nnet rap session DELETE <client_name> [misc. options] [targets] \n"\
00265 "\tor"\
00266 "\nnet rap session CLOSE <client_name> [misc. options] [targets]"\
00267 "\n\tDeletes (closes) a session from specified client to server\n");
00268 d_printf(
00269 "\nnet rap session INFO <client_name>"\
00270 "\n\tEnumerates all open files in specified session\n");
00271
00272 net_common_flags_usage(argc, argv);
00273 return -1;
00274 }
00275
00276 static void list_sessions_func(char *wsname, char *username, uint16 conns,
00277 uint16 opens, uint16 users, uint32 sess_time,
00278 uint32 idle_time, uint32 user_flags, char *clitype)
00279 {
00280 int hrs = idle_time / 3600;
00281 int min = (idle_time / 60) % 60;
00282 int sec = idle_time % 60;
00283
00284 d_printf("\\\\%-18.18s %-20.20s %-18.18s %5d %2.2d:%2.2d:%2.2d\n",
00285 wsname, username, clitype, opens, hrs, min, sec);
00286 }
00287
00288 static void display_session_func(const char *wsname, const char *username,
00289 uint16 conns, uint16 opens, uint16 users,
00290 uint32 sess_time, uint32 idle_time,
00291 uint32 user_flags, const char *clitype)
00292 {
00293 int ihrs = idle_time / 3600;
00294 int imin = (idle_time / 60) % 60;
00295 int isec = idle_time % 60;
00296 int shrs = sess_time / 3600;
00297 int smin = (sess_time / 60) % 60;
00298 int ssec = sess_time % 60;
00299 d_printf("User name %-20.20s\n"\
00300 "Computer %-20.20s\n"\
00301 "Guest logon %-20.20s\n"\
00302 "Client Type %-40.40s\n"\
00303 "Sess time %2.2d:%2.2d:%2.2d\n"\
00304 "Idle time %2.2d:%2.2d:%2.2d\n",
00305 username, wsname,
00306 (user_flags&0x0)?"yes":"no", clitype,
00307 shrs, smin, ssec, ihrs, imin, isec);
00308 }
00309
00310 static void display_conns_func(uint16 conn_id, uint16 conn_type, uint16 opens,
00311 uint16 users, uint32 conn_time,
00312 const char *username, const char *netname)
00313 {
00314 d_printf("%-14.14s %-8.8s %5d\n",
00315 netname, share_type[conn_type], opens);
00316 }
00317
00318 static int rap_session_info(int argc, const char **argv)
00319 {
00320 const char *sessname;
00321 struct cli_state *cli;
00322 int ret;
00323
00324 if (!(cli = net_make_ipc_connection(0)))
00325 return -1;
00326
00327 if (argc == 0)
00328 return net_rap_session_usage(argc, argv);
00329
00330 sessname = argv[0];
00331
00332 ret = cli_NetSessionGetInfo(cli, sessname, display_session_func);
00333 if (ret < 0) {
00334 cli_shutdown(cli);
00335 return ret;
00336 }
00337
00338 d_printf("Share name Type # Opens\n-------------------------"\
00339 "-----------------------------------------------------\n");
00340 ret = cli_NetConnectionEnum(cli, sessname, display_conns_func);
00341 cli_shutdown(cli);
00342 return ret;
00343 }
00344
00345 static int rap_session_delete(int argc, const char **argv)
00346 {
00347 struct cli_state *cli;
00348 int ret;
00349
00350 if (!(cli = net_make_ipc_connection(0)))
00351 return -1;
00352
00353 if (argc == 0)
00354 return net_rap_session_usage(argc, argv);
00355
00356 ret = cli_NetSessionDel(cli, argv[0]);
00357 cli_shutdown(cli);
00358 return ret;
00359 }
00360
00361 int net_rap_session(int argc, const char **argv)
00362 {
00363 struct functable func[] = {
00364 {"INFO", rap_session_info},
00365 {"DELETE", rap_session_delete},
00366 {"CLOSE", rap_session_delete},
00367 {NULL, NULL}
00368 };
00369
00370 if (argc == 0) {
00371 struct cli_state *cli;
00372 int ret;
00373
00374 if (!(cli = net_make_ipc_connection(0)))
00375 return -1;
00376
00377 d_printf("Computer User name "\
00378 "Client Type Opens Idle time\n"\
00379 "------------------------------------------"\
00380 "------------------------------------\n");
00381 ret = cli_NetSessionEnum(cli, list_sessions_func);
00382
00383 cli_shutdown(cli);
00384 return ret;
00385 }
00386
00387 return net_run_function(argc, argv, func, net_rap_session_usage);
00388 }
00389
00390
00391
00392
00393 static void display_server_func(const char *name, uint32 m,
00394 const char *comment, void * reserved)
00395 {
00396 d_printf("\t%-16.16s %s\n", name, comment);
00397 }
00398
00399
00400 int net_rap_server_usage(int argc, const char **argv)
00401 {
00402 d_printf("net rap server [misc. options] [target]\n\t"\
00403 "lists the servers in the specified domain or workgroup.\n");
00404 d_printf("\n\tIf domain is not specified, it uses the current"\
00405 " domain or workgroup as\n\tthe default.\n");
00406
00407 net_common_flags_usage(argc, argv);
00408 return -1;
00409 }
00410
00411 static int net_rap_server_name(int argc, const char *argv[])
00412 {
00413 struct cli_state *cli;
00414 char *name;
00415
00416 if (!(cli = net_make_ipc_connection(0)))
00417 return -1;
00418
00419 if (!cli_get_server_name(NULL, cli, &name)) {
00420 d_fprintf(stderr, "cli_get_server_name failed\n");
00421 cli_shutdown(cli);
00422 return -1;
00423 }
00424
00425 d_printf("Server name = %s\n", name);
00426
00427 TALLOC_FREE(name);
00428 cli_shutdown(cli);
00429 return 0;
00430 }
00431
00432 int net_rap_server(int argc, const char **argv)
00433 {
00434 struct cli_state *cli;
00435 int ret;
00436
00437 if (argc > 0) {
00438 if (strequal(argv[0], "name")) {
00439 return net_rap_server_name(argc, argv);
00440 }
00441
00442
00443 if (!strequal(argv[0], "domain")) {
00444 return net_rap_server_usage(argc-1, argv+1);
00445 }
00446 }
00447
00448 if (!(cli = net_make_ipc_connection(0)))
00449 return -1;
00450
00451 d_printf("\nEnumerating servers in this domain or workgroup: \n\n"\
00452 "\tServer name Server description\n"\
00453 "\t------------- ----------------------------\n");
00454
00455 ret = cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_ALL,
00456 display_server_func,NULL);
00457 cli_shutdown(cli);
00458 return ret;
00459 }
00460
00461 int net_rap_domain_usage(int argc, const char **argv)
00462 {
00463 d_printf("net rap domain [misc. options] [target]\n\tlists the"\
00464 " domains or workgroups visible on the current network\n");
00465
00466 net_common_flags_usage(argc, argv);
00467 return -1;
00468 }
00469
00470
00471 int net_rap_domain(int argc, const char **argv)
00472 {
00473 struct cli_state *cli;
00474 int ret;
00475
00476 if (!(cli = net_make_ipc_connection(0)))
00477 return -1;
00478
00479 d_printf("\nEnumerating domains:\n\n"\
00480 "\tDomain name Server name of Browse Master\n"\
00481 "\t------------- ----------------------------\n");
00482
00483 ret = cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_DOMAIN_ENUM,
00484 display_server_func,NULL);
00485 cli_shutdown(cli);
00486 return ret;
00487 }
00488
00489 int net_rap_printq_usage(int argc, const char **argv)
00490 {
00491 d_printf(
00492 "net rap printq [misc. options] [targets]\n"\
00493 "\tor\n"\
00494 "net rap printq list [<queue_name>] [misc. options] [targets]\n"\
00495 "\tlists the specified queue and jobs on the target server.\n"\
00496 "\tIf the queue name is not specified, all queues are listed.\n\n");
00497 d_printf(
00498 "net rap printq delete [<queue name>] [misc. options] [targets]\n"\
00499 "\tdeletes the specified job number on the target server, or the\n"\
00500 "\tprinter queue if no job number is specified\n");
00501
00502 net_common_flags_usage(argc, argv);
00503
00504 return -1;
00505 }
00506
00507 static void enum_queue(const char *queuename, uint16 pri, uint16 start,
00508 uint16 until, const char *sep, const char *pproc,
00509 const char *dest, const char *qparms,
00510 const char *qcomment, uint16 status, uint16 jobcount)
00511 {
00512 d_printf("%-17.17s Queue %5d jobs ",
00513 queuename, jobcount);
00514
00515 switch (status) {
00516 case 0:
00517 d_printf("*Printer Active*\n");
00518 break;
00519 case 1:
00520 d_printf("*Printer Paused*\n");
00521 break;
00522 case 2:
00523 d_printf("*Printer error*\n");
00524 break;
00525 case 3:
00526 d_printf("*Delete Pending*\n");
00527 break;
00528 default:
00529 d_printf("**UNKNOWN STATUS**\n");
00530 }
00531 }
00532
00533 static void enum_jobs(uint16 jobid, const char *ownername,
00534 const char *notifyname, const char *datatype,
00535 const char *jparms, uint16 pos, uint16 status,
00536 const char *jstatus, unsigned int submitted, unsigned int jobsize,
00537 const char *comment)
00538 {
00539 d_printf(" %-23.23s %5d %9d ",
00540 ownername, jobid, jobsize);
00541 switch (status) {
00542 case 0:
00543 d_printf("Waiting\n");
00544 break;
00545 case 1:
00546 d_printf("Held in queue\n");
00547 break;
00548 case 2:
00549 d_printf("Spooling\n");
00550 break;
00551 case 3:
00552 d_printf("Printing\n");
00553 break;
00554 default:
00555 d_printf("**UNKNOWN STATUS**\n");
00556 }
00557 }
00558
00559 #define PRINTQ_ENUM_DISPLAY \
00560 "Print queues at \\\\%s\n\n"\
00561 "Name Job # Size Status\n\n"\
00562 "------------------------------------------------------------------"\
00563 "-------------\n"
00564
00565 static int rap_printq_info(int argc, const char **argv)
00566 {
00567 struct cli_state *cli;
00568 int ret;
00569
00570 if (argc == 0)
00571 return net_rap_printq_usage(argc, argv);
00572
00573 if (!(cli = net_make_ipc_connection(0)))
00574 return -1;
00575
00576 d_printf(PRINTQ_ENUM_DISPLAY, cli->desthost);
00577 ret = cli_NetPrintQGetInfo(cli, argv[0], enum_queue, enum_jobs);
00578 cli_shutdown(cli);
00579 return ret;
00580 }
00581
00582 static int rap_printq_delete(int argc, const char **argv)
00583 {
00584 struct cli_state *cli;
00585 int ret;
00586
00587 if (argc == 0)
00588 return net_rap_printq_usage(argc, argv);
00589
00590 if (!(cli = net_make_ipc_connection(0)))
00591 return -1;
00592
00593 ret = cli_printjob_del(cli, atoi(argv[0]));
00594 cli_shutdown(cli);
00595 return ret;
00596 }
00597
00598 int net_rap_printq(int argc, const char **argv)
00599 {
00600 struct cli_state *cli;
00601 int ret;
00602
00603 struct functable func[] = {
00604 {"INFO", rap_printq_info},
00605 {"DELETE", rap_printq_delete},
00606 {NULL, NULL}
00607 };
00608
00609 if (argc == 0) {
00610 if (!(cli = net_make_ipc_connection(0)))
00611 return -1;
00612
00613 d_printf(PRINTQ_ENUM_DISPLAY, cli->desthost);
00614 ret = cli_NetPrintQEnum(cli, enum_queue, enum_jobs);
00615 cli_shutdown(cli);
00616 return ret;
00617 }
00618
00619 return net_run_function(argc, argv, func, net_rap_printq_usage);
00620 }
00621
00622
00623 static int net_rap_user_usage(int argc, const char **argv)
00624 {
00625 return net_help_user(argc, argv);
00626 }
00627
00628 static void user_fn(const char *user_name, void *state)
00629 {
00630 d_printf("%-21.21s\n", user_name);
00631 }
00632
00633 static void long_user_fn(const char *user_name, const char *comment,
00634 const char * home_dir, const char * logon_script,
00635 void *state)
00636 {
00637 d_printf("%-21.21s %s\n",
00638 user_name, comment);
00639 }
00640
00641 static void group_member_fn(const char *user_name, void *state)
00642 {
00643 d_printf("%-21.21s\n", user_name);
00644 }
00645
00646 static int rap_user_delete(int argc, const char **argv)
00647 {
00648 struct cli_state *cli;
00649 int ret;
00650
00651 if (argc == 0) {
00652 d_printf("\n\nUser name not specified\n");
00653 return net_rap_user_usage(argc, argv);
00654 }
00655
00656 if (!(cli = net_make_ipc_connection(0)))
00657 return -1;
00658
00659 ret = cli_NetUserDelete(cli, argv[0]);
00660 cli_shutdown(cli);
00661 return ret;
00662 }
00663
00664 static int rap_user_add(int argc, const char **argv)
00665 {
00666 struct cli_state *cli;
00667 int ret;
00668 RAP_USER_INFO_1 userinfo;
00669
00670 if (argc == 0) {
00671 d_printf("\n\nUser name not specified\n");
00672 return net_rap_user_usage(argc, argv);
00673 }
00674
00675 if (!(cli = net_make_ipc_connection(0)))
00676 return -1;
00677
00678 safe_strcpy(userinfo.user_name, argv[0], sizeof(userinfo.user_name)-1);
00679 if (opt_flags == -1)
00680 opt_flags = 0x21;
00681
00682 userinfo.userflags = opt_flags;
00683 userinfo.reserved1 = '\0';
00684 userinfo.comment = smb_xstrdup(opt_comment);
00685 userinfo.priv = 1;
00686 userinfo.home_dir = NULL;
00687 userinfo.logon_script = NULL;
00688
00689 ret = cli_NetUserAdd(cli, &userinfo);
00690
00691 cli_shutdown(cli);
00692 return ret;
00693 }
00694
00695 static int rap_user_info(int argc, const char **argv)
00696 {
00697 struct cli_state *cli;
00698 int ret;
00699 if (argc == 0) {
00700 d_printf("\n\nUser name not specified\n");
00701 return net_rap_user_usage(argc, argv);
00702 }
00703
00704 if (!(cli = net_make_ipc_connection(0)))
00705 return -1;
00706
00707 ret = cli_NetUserGetGroups(cli, argv[0], group_member_fn, NULL);
00708 cli_shutdown(cli);
00709 return ret;
00710 }
00711
00712 int net_rap_user(int argc, const char **argv)
00713 {
00714 int ret = -1;
00715 struct functable func[] = {
00716 {"ADD", rap_user_add},
00717 {"INFO", rap_user_info},
00718 {"DELETE", rap_user_delete},
00719 {NULL, NULL}
00720 };
00721
00722 if (argc == 0) {
00723 struct cli_state *cli;
00724 if (!(cli = net_make_ipc_connection(0)))
00725 goto done;
00726 if (opt_long_list_entries) {
00727 d_printf("\nUser name Comment"\
00728 "\n-----------------------------\n");
00729 ret = cli_RNetUserEnum(cli, long_user_fn, NULL);
00730 cli_shutdown(cli);
00731 goto done;
00732 }
00733 ret = cli_RNetUserEnum0(cli, user_fn, NULL);
00734 cli_shutdown(cli);
00735 goto done;
00736 }
00737
00738 ret = net_run_function(argc, argv, func, net_rap_user_usage);
00739 done:
00740 if (ret != 0) {
00741 DEBUG(1, ("Net user returned: %d\n", ret));
00742 }
00743 return ret;
00744 }
00745
00746
00747 int net_rap_group_usage(int argc, const char **argv)
00748 {
00749 return net_help_group(argc, argv);
00750 }
00751
00752 static void long_group_fn(const char *group_name, const char *comment,
00753 void *state)
00754 {
00755 d_printf("%-21.21s %s\n", group_name, comment);
00756 }
00757
00758 static void group_fn(const char *group_name, void *state)
00759 {
00760 d_printf("%-21.21s\n", group_name);
00761 }
00762
00763 static int rap_group_delete(int argc, const char **argv)
00764 {
00765 struct cli_state *cli;
00766 int ret;
00767 if (argc == 0) {
00768 d_printf("\n\nGroup name not specified\n");
00769 return net_rap_group_usage(argc, argv);
00770 }
00771
00772 if (!(cli = net_make_ipc_connection(0)))
00773 return -1;
00774
00775 ret = cli_NetGroupDelete(cli, argv[0]);
00776 cli_shutdown(cli);
00777 return ret;
00778 }
00779
00780 static int rap_group_add(int argc, const char **argv)
00781 {
00782 struct cli_state *cli;
00783 int ret;
00784 RAP_GROUP_INFO_1 grinfo;
00785
00786 if (argc == 0) {
00787 d_printf("\n\nGroup name not specified\n");
00788 return net_rap_group_usage(argc, argv);
00789 }
00790
00791 if (!(cli = net_make_ipc_connection(0)))
00792 return -1;
00793
00794
00795 safe_strcpy(grinfo.group_name, argv[0], sizeof(grinfo.group_name)-1);
00796 grinfo.reserved1 = '\0';
00797 grinfo.comment = smb_xstrdup(opt_comment);
00798
00799 ret = cli_NetGroupAdd(cli, &grinfo);
00800 cli_shutdown(cli);
00801 return ret;
00802 }
00803
00804 int net_rap_group(int argc, const char **argv)
00805 {
00806 struct functable func[] = {
00807 {"ADD", rap_group_add},
00808 {"DELETE", rap_group_delete},
00809 {NULL, NULL}
00810 };
00811
00812 if (argc == 0) {
00813 struct cli_state *cli;
00814 int ret;
00815 if (!(cli = net_make_ipc_connection(0)))
00816 return -1;
00817 if (opt_long_list_entries) {
00818 d_printf("Group name Comment\n");
00819 d_printf("-----------------------------\n");
00820 ret = cli_RNetGroupEnum(cli, long_group_fn, NULL);
00821 cli_shutdown(cli);
00822 return ret;
00823 }
00824 ret = cli_RNetGroupEnum0(cli, group_fn, NULL);
00825 cli_shutdown(cli);
00826 return ret;
00827 }
00828
00829 return net_run_function(argc, argv, func, net_rap_group_usage);
00830 }
00831
00832 int net_rap_groupmember_usage(int argc, const char **argv)
00833 {
00834 d_printf(
00835 "net rap groupmember LIST <group> [misc. options] [targets]"\
00836 "\n\t Enumerate users in a group\n"\
00837 "\nnet rap groupmember DELETE <group> <user> [misc. options] "\
00838 "[targets]\n\t Delete sepcified user from specified group\n"\
00839 "\nnet rap groupmember ADD <group> <user> [misc. options] [targets]"\
00840 "\n\t Add specified user to specified group\n");
00841
00842 net_common_flags_usage(argc, argv);
00843 return -1;
00844 }
00845
00846
00847 static int rap_groupmember_add(int argc, const char **argv)
00848 {
00849 struct cli_state *cli;
00850 int ret;
00851 if (argc != 2) {
00852 d_printf("\n\nGroup or user name not specified\n");
00853 return net_rap_groupmember_usage(argc, argv);
00854 }
00855
00856 if (!(cli = net_make_ipc_connection(0)))
00857 return -1;
00858
00859 ret = cli_NetGroupAddUser(cli, argv[0], argv[1]);
00860 cli_shutdown(cli);
00861 return ret;
00862 }
00863
00864 static int rap_groupmember_delete(int argc, const char **argv)
00865 {
00866 struct cli_state *cli;
00867 int ret;
00868 if (argc != 2) {
00869 d_printf("\n\nGroup or user name not specified\n");
00870 return net_rap_groupmember_usage(argc, argv);
00871 }
00872
00873 if (!(cli = net_make_ipc_connection(0)))
00874 return -1;
00875
00876 ret = cli_NetGroupDelUser(cli, argv[0], argv[1]);
00877 cli_shutdown(cli);
00878 return ret;
00879 }
00880
00881 static int rap_groupmember_list(int argc, const char **argv)
00882 {
00883 struct cli_state *cli;
00884 int ret;
00885 if (argc == 0) {
00886 d_printf("\n\nGroup name not specified\n");
00887 return net_rap_groupmember_usage(argc, argv);
00888 }
00889
00890 if (!(cli = net_make_ipc_connection(0)))
00891 return -1;
00892
00893 ret = cli_NetGroupGetUsers(cli, argv[0], group_member_fn, NULL );
00894 cli_shutdown(cli);
00895 return ret;
00896 }
00897
00898 int net_rap_groupmember(int argc, const char **argv)
00899 {
00900 struct functable func[] = {
00901 {"ADD", rap_groupmember_add},
00902 {"LIST", rap_groupmember_list},
00903 {"DELETE", rap_groupmember_delete},
00904 {NULL, NULL}
00905 };
00906
00907 return net_run_function(argc, argv, func, net_rap_groupmember_usage);
00908 }
00909
00910 int net_rap_validate_usage(int argc, const char **argv)
00911 {
00912 d_printf("net rap validate <username> [password]\n"\
00913 "\tValidate user and password to check whether they"\
00914 " can access target server or domain\n");
00915
00916 net_common_flags_usage(argc, argv);
00917 return -1;
00918 }
00919
00920 int net_rap_validate(int argc, const char **argv)
00921 {
00922 return errmsg_not_implemented();
00923 }
00924
00925 int net_rap_service_usage(int argc, const char **argv)
00926 {
00927 d_printf("net rap service [misc. options] [targets] \n"\
00928 "\tlists all running service daemons on target server\n");
00929 d_printf("\nnet rap service START <name> [service startup arguments]"\
00930 " [misc. options] [targets]"\
00931 "\n\tStart named service on remote server\n");
00932 d_printf("\nnet rap service STOP <name> [misc. options] [targets]\n"\
00933 "\n\tStop named service on remote server\n");
00934
00935 net_common_flags_usage(argc, argv);
00936 return -1;
00937 }
00938
00939 static int rap_service_start(int argc, const char **argv)
00940 {
00941 return errmsg_not_implemented();
00942 }
00943
00944 static int rap_service_stop(int argc, const char **argv)
00945 {
00946 return errmsg_not_implemented();
00947 }
00948
00949 static void service_fn(const char *service_name, const char *dummy,
00950 void *state)
00951 {
00952 d_printf("%-21.21s\n", service_name);
00953 }
00954
00955 int net_rap_service(int argc, const char **argv)
00956 {
00957 struct functable func[] = {
00958 {"START", rap_service_start},
00959 {"STOP", rap_service_stop},
00960 {NULL, NULL}
00961 };
00962
00963 if (argc == 0) {
00964 struct cli_state *cli;
00965 int ret;
00966 if (!(cli = net_make_ipc_connection(0)))
00967 return -1;
00968
00969 if (opt_long_list_entries) {
00970 d_printf("Service name Comment\n");
00971 d_printf("-----------------------------\n");
00972 ret = cli_RNetServiceEnum(cli, long_group_fn, NULL);
00973 }
00974 ret = cli_RNetServiceEnum(cli, service_fn, NULL);
00975 cli_shutdown(cli);
00976 return ret;
00977 }
00978
00979 return net_run_function(argc, argv, func, net_rap_service_usage);
00980 }
00981
00982 int net_rap_password_usage(int argc, const char **argv)
00983 {
00984 d_printf(
00985 "net rap password <user> <oldpwo> <newpw> [misc. options] [target]\n"\
00986 "\tchanges the password for the specified user at target\n");
00987
00988 return -1;
00989 }
00990
00991
00992 int net_rap_password(int argc, const char **argv)
00993 {
00994 struct cli_state *cli;
00995 int ret;
00996
00997 if (argc < 3)
00998 return net_rap_password_usage(argc, argv);
00999
01000 if (!(cli = net_make_ipc_connection(0)))
01001 return -1;
01002
01003
01004 ret = cli_oem_change_password(cli, argv[0], argv[2], argv[1]);
01005 cli_shutdown(cli);
01006 return ret;
01007 }
01008
01009 int net_rap_admin_usage(int argc, const char **argv)
01010 {
01011 d_printf(
01012 "net rap admin <remote command> [cmd args [env]] [misc. options] [targets]"\
01013 "\n\texecutes a remote command on an os/2 target server\n");
01014
01015 return -1;
01016 }
01017
01018
01019 int net_rap_admin(int argc, const char **argv)
01020 {
01021 return errmsg_not_implemented();
01022 }
01023
01024
01025
01026 int net_rap_usage(int argc, const char **argv)
01027 {
01028 d_printf(" net rap domain \tto list domains \n"\
01029 " net rap file \t\tto list open files on a server \n"\
01030 " net rap group \tto list user groups \n"\
01031 " net rap groupmember \tto list users in a group \n"\
01032 " net rap password \tto change the password of a user\n"\
01033 " net rap printq \tto list the print queues on a server\n"\
01034 " net rap server \tto list servers in a domain\n"\
01035 " net rap session \tto list clients with open sessions to a server\n"\
01036 " net rap share \tto list shares exported by a server\n"\
01037 " net rap user \t\tto list users\n"\
01038 " net rap validate \tto check whether a user and the corresponding password are valid\n"\
01039 " net rap help\n"\
01040 "\nType \"net help <option>\" to get more information on that option\n\n");
01041
01042 net_common_flags_usage(argc, argv);
01043 return -1;
01044 }
01045
01046
01047
01048
01049 int net_rap_help(int argc, const char **argv)
01050 {
01051 struct functable func[] = {
01052 {"FILE", net_rap_file_usage},
01053 {"SHARE", net_rap_share_usage},
01054 {"SESSION", net_rap_session_usage},
01055 {"SERVER", net_rap_server_usage},
01056 {"DOMAIN", net_rap_domain_usage},
01057 {"PRINTQ", net_rap_printq_usage},
01058 {"USER", net_rap_user_usage},
01059 {"GROUP", net_rap_group_usage},
01060 {"VALIDATE", net_rap_validate_usage},
01061 {"GROUPMEMBER", net_rap_groupmember_usage},
01062 {"ADMIN", net_rap_admin_usage},
01063 {"SERVICE", net_rap_service_usage},
01064 {"PASSWORD", net_rap_password_usage},
01065 {NULL, NULL}};
01066
01067 return net_run_function(argc, argv, func, net_rap_usage);
01068 }
01069
01070
01071
01072 int net_rap(int argc, const char **argv)
01073 {
01074 struct functable func[] = {
01075 {"FILE", net_rap_file},
01076 {"SHARE", net_rap_share},
01077 {"SESSION", net_rap_session},
01078 {"SERVER", net_rap_server},
01079 {"DOMAIN", net_rap_domain},
01080 {"PRINTQ", net_rap_printq},
01081 {"USER", net_rap_user},
01082 {"GROUP", net_rap_group},
01083 {"VALIDATE", net_rap_validate},
01084 {"GROUPMEMBER", net_rap_groupmember},
01085 {"ADMIN", net_rap_admin},
01086 {"SERVICE", net_rap_service},
01087 {"PASSWORD", net_rap_password},
01088 {"HELP", net_rap_help},
01089 {NULL, NULL}
01090 };
01091
01092 return net_run_function(argc, argv, func, net_rap_usage);
01093 }
01094