r4088: Get medieval on our ass about malloc.... :-). Take control of all our allocation
[tprouty/samba.git] / source / utils / net_rap.c
1 /* 
2    Samba Unix/Linux SMB client library 
3    Distributed SMB/CIFS Server Management Utility 
4    Copyright (C) 2001 Steve French  (sfrench@us.ibm.com)
5    Copyright (C) 2001 Jim McDonough (jmcd@us.ibm.com)
6    Copyright (C) 2001 Andrew Tridgell (tridge@samba.org)
7    Copyright (C) 2001 Andrew Bartlett (abartlet@samba.org)
8
9    Originally written by Steve and Jim. Largely rewritten by tridge in
10    November 2001.
11
12    This program is free software; you can redistribute it and/or modify
13    it under the terms of the GNU General Public License as published by
14    the Free Software Foundation; either version 2 of the License, or
15    (at your option) any later version.
16    
17    This program is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20    GNU General Public License for more details.
21    
22    You should have received a copy of the GNU General Public License
23    along with this program; if not, write to the Free Software
24    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
25
26 #include "includes.h"
27 #include "utils/net.h"
28
29 /* The following messages were for error checking that is not properly 
30    reported at the moment.  Which should be reinstated? */
31 #define ERRMSG_TARGET_WG_NOT_VALID      "\nTarget workgroup option not valid "\
32                                         "except on net rap server command, ignored"
33 #define ERRMSG_INVALID_HELP_OPTION      "\nInvalid help option\n"
34
35 #define ERRMSG_BOTH_SERVER_IPADDRESS    "\nTarget server and IP address both "\
36   "specified. Do not set both at the same time.  The target IP address was used\n"
37
38 const char *share_type[] = {
39   "Disk",
40   "Print",
41   "Dev",
42   "IPC"
43 };
44
45 static int errmsg_not_implemented(void)
46 {
47         d_printf("\nNot implemented\n");
48         return 0;
49 }
50
51 int net_rap_file_usage(int argc, const char **argv)
52 {
53         return net_help_file(argc, argv);
54 }
55
56 /***************************************************************************
57   list info on an open file
58 ***************************************************************************/
59 static void file_fn(const char * pPath, const char * pUser, uint16 perms, 
60                     uint16 locks, uint32 id)
61 {
62         d_printf("%-7.1d %-20.20s 0x%-4.2x %-6.1d %s\n",
63                  id, pUser, perms, locks, pPath);
64 }
65
66 static void one_file_fn(const char *pPath, const char *pUser, uint16 perms, 
67                         uint16 locks, uint32 id)
68 {
69         d_printf("File ID          %d\n"\
70                  "User name        %s\n"\
71                  "Locks            0x%-4.2x\n"\
72                  "Path             %s\n"\
73                  "Permissions      0x%x\n",
74                  id, pUser, locks, pPath, perms);
75 }
76
77
78 static int rap_file_close(int argc, const char **argv)
79 {
80         struct cli_state *cli;
81         int ret;
82         if (argc == 0) {
83                 d_printf("\nMissing fileid of file to close\n\n");
84                 return net_rap_file_usage(argc, argv);
85         }
86
87         if (!(cli = net_make_ipc_connection(0))) 
88                 return -1;
89
90         ret = cli_NetFileClose(cli, atoi(argv[0]));
91         cli_shutdown(cli);
92         return ret;
93 }
94
95 static int rap_file_info(int argc, const char **argv)
96 {
97         struct cli_state *cli;
98         int ret;
99         if (argc == 0)
100                 return net_rap_file_usage(argc, argv);
101         
102         if (!(cli = net_make_ipc_connection(0))) 
103                 return -1;
104
105         ret = cli_NetFileGetInfo(cli, atoi(argv[0]), one_file_fn);
106         cli_shutdown(cli);
107         return ret;
108 }
109
110 static int rap_file_user(int argc, const char **argv)
111 {
112         if (argc == 0)
113                 return net_rap_file_usage(argc, argv);
114
115         d_printf("net rap file user not implemented yet\n");
116         return -1;
117 }
118
119 int net_rap_file(int argc, const char **argv)
120 {
121         struct functable func[] = {
122                 {"CLOSE", rap_file_close},
123                 {"USER", rap_file_user},
124                 {"INFO", rap_file_info},
125                 {NULL, NULL}
126         };
127         
128         if (argc == 0) {
129                 struct cli_state *cli;
130                 int ret;
131                 
132                 if (!(cli = net_make_ipc_connection(0))) 
133                         return -1;
134
135                 /* list open files */
136                 d_printf(
137                  "\nEnumerating open files on remote server:\n\n"\
138                  "\nFileId  Opened by            Perms  Locks  Path \n"\
139                  "------  ---------            -----  -----  ---- \n");
140                 ret = cli_NetFileEnum(cli, NULL, NULL, file_fn);
141                 cli_shutdown(cli);
142                 return ret;
143         }
144         
145         return net_run_function(argc, argv, func, net_rap_file_usage);
146 }
147                        
148 int net_rap_share_usage(int argc, const char **argv)
149 {
150         return net_help_share(argc, argv);
151 }
152
153 static void long_share_fn(const char *share_name, uint32 type, 
154                           const char *comment, void *state)
155 {
156         d_printf("%-12s %-8.8s %-50s\n",
157                  share_name, share_type[type], comment);
158 }
159
160 static void share_fn(const char *share_name, uint32 type, 
161                      const char *comment, void *state)
162 {
163         d_printf("%s\n", share_name);
164 }
165
166 static int rap_share_delete(int argc, const char **argv)
167 {
168         struct cli_state *cli;
169         int ret;
170         
171         if (argc == 0) {
172                 d_printf("\n\nShare name not specified\n");
173                 return net_rap_share_usage(argc, argv);
174         }
175
176         if (!(cli = net_make_ipc_connection(0))) 
177                 return -1;
178
179         ret = cli_NetShareDelete(cli, argv[0]);
180         cli_shutdown(cli);
181         return ret;
182 }
183
184 static int rap_share_add(int argc, const char **argv)
185 {
186         struct cli_state *cli;
187         int ret;
188         
189         RAP_SHARE_INFO_2 sinfo;
190         char *p;
191         char *sharename;
192
193         if (argc == 0) {
194                 d_printf("\n\nShare name not specified\n");
195                 return net_rap_share_usage(argc, argv);
196         }
197                         
198         if (!(cli = net_make_ipc_connection(0))) 
199                 return -1;
200
201         sharename = SMB_STRDUP(argv[0]);
202         p = strchr(sharename, '=');
203         *p = 0;
204         strlcpy(sinfo.share_name, sharename, sizeof(sinfo.share_name));
205         sinfo.reserved1 = '\0';
206         sinfo.share_type = 0;
207         sinfo.comment = smb_xstrdup(opt_comment);
208         sinfo.perms = 0;
209         sinfo.maximum_users = opt_maxusers;
210         sinfo.active_users = 0;
211         sinfo.path = p+1;
212         memset(sinfo.password, '\0', sizeof(sinfo.password));
213         sinfo.reserved2 = '\0';
214         
215         ret = cli_NetShareAdd(cli, &sinfo);
216         cli_shutdown(cli);
217         return ret;
218 }
219
220
221 int net_rap_share(int argc, const char **argv)
222 {
223         struct functable func[] = {
224                 {"DELETE", rap_share_delete},
225                 {"CLOSE", rap_share_delete},
226                 {"ADD", rap_share_add},
227                 {NULL, NULL}
228         };
229
230         if (argc == 0) {
231                 struct cli_state *cli;
232                 int ret;
233                 
234                 if (!(cli = net_make_ipc_connection(0))) 
235                         return -1;
236                 
237                 if (opt_long_list_entries) {
238                         d_printf(
239         "\nEnumerating shared resources (exports) on remote server:\n\n"\
240         "\nShare name   Type     Description\n"\
241         "----------   ----     -----------\n");
242                         ret = cli_RNetShareEnum(cli, long_share_fn, NULL);
243                 } else {
244                         ret = cli_RNetShareEnum(cli, share_fn, NULL);
245                 }
246                 cli_shutdown(cli);
247                 return ret;
248         }
249
250         return net_run_function(argc, argv, func, net_rap_share_usage);
251 }
252                     
253                 
254 int net_rap_session_usage(int argc, const char **argv)
255 {
256         d_printf(
257          "\nnet rap session [misc. options] [targets]"\
258          "\n\tenumerates all active SMB/CIFS sessions on target server\n");
259         d_printf(
260          "\nnet rap session DELETE <client_name> [misc. options] [targets] \n"\
261          "\tor"\
262          "\nnet rap session CLOSE <client_name> [misc. options] [targets]"\
263          "\n\tDeletes (closes) a session from specified client to server\n");
264         d_printf(
265         "\nnet rap session INFO <client_name>"\
266         "\n\tEnumerates all open files in specified session\n");
267
268         net_common_flags_usage(argc, argv);
269         return -1;
270 }
271     
272 static void list_sessions_func(char *wsname, char *username, uint16 conns,
273                         uint16 opens, uint16 users, uint32 sess_time,
274                         uint32 idle_time, uint32 user_flags, char *clitype)
275 {
276         int hrs = idle_time / 3600;
277         int min = (idle_time / 60) % 60;
278         int sec = idle_time % 60;
279         
280         d_printf("\\\\%-18.18s %-20.20s %-18.18s %5d %2.2d:%2.2d:%2.2d\n",
281                  wsname, username, clitype, opens, hrs, min, sec);
282 }
283
284 static void display_session_func(const char *wsname, const char *username, 
285                                  uint16 conns, uint16 opens, uint16 users, 
286                                  uint32 sess_time, uint32 idle_time, 
287                                  uint32 user_flags, const char *clitype)
288 {
289         int ihrs = idle_time / 3600;
290         int imin = (idle_time / 60) % 60;
291         int isec = idle_time % 60;
292         int shrs = sess_time / 3600;
293         int smin = (sess_time / 60) % 60;
294         int ssec = sess_time % 60;
295         d_printf("User name       %-20.20s\n"\
296                  "Computer        %-20.20s\n"\
297                  "Guest logon     %-20.20s\n"\
298                  "Client Type     %-40.40s\n"\
299                  "Sess time       %2.2d:%2.2d:%2.2d\n"\
300                  "Idle time       %2.2d:%2.2d:%2.2d\n", 
301                  username, wsname, 
302                  (user_flags&0x0)?"yes":"no", clitype,
303                  shrs, smin, ssec, ihrs, imin, isec);
304 }
305
306 static void display_conns_func(uint16 conn_id, uint16 conn_type, uint16 opens,
307                                uint16 users, uint32 conn_time,
308                                const char *username, const char *netname)
309 {
310         d_printf("%-14.14s %-8.8s %5d\n",
311                  netname, share_type[conn_type], opens);
312 }
313
314 static int rap_session_info(int argc, const char **argv)
315 {
316         const char *sessname;
317         struct cli_state *cli;
318         int ret;
319         
320         if (!(cli = net_make_ipc_connection(0))) 
321                 return -1;
322
323         if (argc == 0) 
324                 return net_rap_session_usage(argc, argv);
325
326         sessname = argv[0];
327
328         ret = cli_NetSessionGetInfo(cli, sessname, display_session_func);
329         if (ret < 0) {
330                 cli_shutdown(cli);
331                 return ret;
332         }
333
334         d_printf("Share name     Type     # Opens\n-------------------------"\
335                  "-----------------------------------------------------\n");
336         ret = cli_NetConnectionEnum(cli, sessname, display_conns_func);
337         cli_shutdown(cli);
338         return ret;
339 }
340
341 static int rap_session_delete(int argc, const char **argv)
342 {
343         struct cli_state *cli;
344         int ret;
345         
346         if (!(cli = net_make_ipc_connection(0))) 
347                 return -1;
348
349         if (argc == 0) 
350                 return net_rap_session_usage(argc, argv);
351
352         ret = cli_NetSessionDel(cli, argv[0]);
353         cli_shutdown(cli);
354         return ret;
355 }
356
357 int net_rap_session(int argc, const char **argv)
358 {
359         struct functable func[] = {
360                 {"INFO", rap_session_info},
361                 {"DELETE", rap_session_delete},
362                 {"CLOSE", rap_session_delete},
363                 {NULL, NULL}
364         };
365
366         if (argc == 0) {
367                 struct cli_state *cli;
368                 int ret;
369                 
370                 if (!(cli = net_make_ipc_connection(0))) 
371                         return -1;
372
373                 d_printf("Computer             User name            "\
374                          "Client Type        Opens Idle time\n"\
375                          "------------------------------------------"\
376                          "------------------------------------\n");
377                 ret = cli_NetSessionEnum(cli, list_sessions_func);
378
379                 cli_shutdown(cli);
380                 return ret;
381         }
382
383         return net_run_function(argc, argv, func, net_rap_session_usage);
384 }
385         
386 /****************************************************************************
387 list a server name
388 ****************************************************************************/
389 static void display_server_func(const char *name, uint32 m,
390                                 const char *comment, void * reserved)
391 {
392         d_printf("\t%-16.16s     %s\n", name, comment);
393 }
394
395
396 int net_rap_server_usage(int argc, const char **argv)
397 {
398         d_printf("net rap server [misc. options] [target]\n\t"\
399                  "lists the servers in the specified domain or workgroup.\n");
400         d_printf("\n\tIf domain is not specified, it uses the current"\
401                  " domain or workgroup as\n\tthe default.\n");
402
403         net_common_flags_usage(argc, argv);
404         return -1;
405 }
406                     
407 int net_rap_server(int argc, const char **argv)
408 {
409         struct cli_state *cli;
410         int ret;
411         
412         if (!(cli = net_make_ipc_connection(0))) 
413                 return -1;
414
415         d_printf("\nEnumerating servers in this domain or workgroup: \n\n"\
416                  "\tServer name          Server description\n"\
417                  "\t-------------        ----------------------------\n");
418
419         ret = cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_ALL, 
420                                 display_server_func,NULL); 
421         cli_shutdown(cli);
422         return ret;     
423 }
424                       
425 int net_rap_domain_usage(int argc, const char **argv)
426 {
427         d_printf("net rap domain [misc. options] [target]\n\tlists the"\
428                  " domains or workgroups visible on the current network\n");
429
430         net_common_flags_usage(argc, argv);
431         return -1;
432 }
433
434                   
435 int net_rap_domain(int argc, const char **argv)
436 {
437         struct cli_state *cli;
438         int ret;
439         
440         if (!(cli = net_make_ipc_connection(0))) 
441                 return -1;
442
443         d_printf("\nEnumerating domains:\n\n"\
444                  "\tDomain name          Server name of Browse Master\n"\
445                  "\t-------------        ----------------------------\n");
446
447         ret = cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_DOMAIN_ENUM,
448                                 display_server_func,NULL);      
449         cli_shutdown(cli);
450         return ret;     
451 }
452                       
453 int net_rap_printq_usage(int argc, const char **argv)
454 {
455         d_printf(
456          "net rap printq [misc. options] [targets]\n"\
457          "\tor\n"\
458          "net rap printq list [<queue_name>] [misc. options] [targets]\n"\
459          "\tlists the specified queue and jobs on the target server.\n"\
460          "\tIf the queue name is not specified, all queues are listed.\n\n");
461         d_printf(
462          "net rap printq delete [<queue name>] [misc. options] [targets]\n"\
463          "\tdeletes the specified job number on the target server, or the\n"\
464          "\tprinter queue if no job number is specified\n");
465
466         net_common_flags_usage(argc, argv);
467
468         return -1;
469 }       
470
471 static void enum_queue(const char *queuename, uint16 pri, uint16 start, 
472                        uint16 until, const char *sep, const char *pproc, 
473                        const char *dest, const char *qparms, 
474                        const char *qcomment, uint16 status, uint16 jobcount) 
475 {
476         d_printf("%-17.17s Queue %5d jobs                      ",
477                  queuename, jobcount);
478
479         switch (status) {
480         case 0:
481                 d_printf("*Printer Active*\n");
482                 break;
483         case 1:
484                 d_printf("*Printer Paused*\n");
485                 break;
486         case 2:
487                 d_printf("*Printer error*\n");
488                 break;
489         case 3:
490                 d_printf("*Delete Pending*\n");
491                 break;
492         default:
493                 d_printf("**UNKNOWN STATUS**\n");
494         }
495 }
496
497 static void enum_jobs(uint16 jobid, const char *ownername, 
498                       const char *notifyname, const char *datatype,
499                       const char *jparms, uint16 pos, uint16 status, 
500                       const char *jstatus, unsigned int submitted, unsigned int jobsize, 
501                       const char *comment)
502 {
503         d_printf("     %-23.23s %5d %9d            ",
504                  ownername, jobid, jobsize);
505         switch (status) {
506         case 0:
507                 d_printf("Waiting\n");
508                 break;
509         case 1:
510                 d_printf("Held in queue\n");
511                 break;
512         case 2:
513                 d_printf("Spooling\n");
514                 break;
515         case 3:
516                 d_printf("Printing\n");
517                 break;
518         default:
519                 d_printf("**UNKNOWN STATUS**\n");
520         }
521 }
522
523 #define PRINTQ_ENUM_DISPLAY \
524     "Print queues at \\\\%s\n\n"\
525     "Name                         Job #      Size            Status\n\n"\
526     "------------------------------------------------------------------"\
527     "-------------\n"
528
529 static int rap_printq_info(int argc, const char **argv)
530 {
531         struct cli_state *cli;
532         int ret;
533         
534         if (argc == 0) 
535                 return net_rap_printq_usage(argc, argv);
536
537         if (!(cli = net_make_ipc_connection(0))) 
538                 return -1;
539
540         d_printf(PRINTQ_ENUM_DISPLAY, cli->desthost); /* list header */
541         ret = cli_NetPrintQGetInfo(cli, argv[0], enum_queue, enum_jobs);
542         cli_shutdown(cli);
543         return ret;
544 }
545
546 static int rap_printq_delete(int argc, const char **argv)
547 {
548         struct cli_state *cli;
549         int ret;
550         
551         if (argc == 0) 
552                 return net_rap_printq_usage(argc, argv);
553
554         if (!(cli = net_make_ipc_connection(0))) 
555                 return -1;
556
557         ret = cli_printjob_del(cli, atoi(argv[0]));
558         cli_shutdown(cli);
559         return ret;
560 }
561
562 int net_rap_printq(int argc, const char **argv)
563 {
564         struct cli_state *cli;
565         int ret;
566         
567         struct functable func[] = {
568                 {"INFO", rap_printq_info},
569                 {"DELETE", rap_printq_delete},
570                 {NULL, NULL}
571         };
572
573         if (argc == 0) {
574                 if (!(cli = net_make_ipc_connection(0))) 
575                         return -1;
576
577                 d_printf(PRINTQ_ENUM_DISPLAY, cli->desthost); /* list header */
578                 ret = cli_NetPrintQEnum(cli, enum_queue, enum_jobs);
579                 cli_shutdown(cli);
580                 return ret;
581         }
582
583         return net_run_function(argc, argv, func, net_rap_printq_usage);
584 }
585
586         
587 static int net_rap_user_usage(int argc, const char **argv)
588 {
589         return net_help_user(argc, argv);
590
591         
592 static void user_fn(const char *user_name, const char *comment,
593                     const char * home_dir, const char * logon_script,
594                     void *state)
595 {
596         d_printf("%-21.21s\n", user_name);
597 }
598
599 static void long_user_fn(const char *user_name, const char *comment,
600                          const char * home_dir, const char * logon_script, 
601                          void *state)
602 {
603         d_printf("%-21.21s %s\n",
604                  user_name, comment);
605 }
606
607 static void group_member_fn(const char *user_name, void *state)
608 {
609         d_printf("%-21.21s\n", user_name);
610 }
611
612 static int rap_user_delete(int argc, const char **argv)
613 {
614         struct cli_state *cli;
615         int ret;
616         
617         if (argc == 0) {
618                 d_printf("\n\nUser name not specified\n");
619                 return net_rap_user_usage(argc, argv);
620         }
621
622         if (!(cli = net_make_ipc_connection(0))) 
623                 return -1;
624
625         ret = cli_NetUserDelete(cli, argv[0]);
626         cli_shutdown(cli);
627         return ret;
628 }
629
630 static int rap_user_add(int argc, const char **argv)
631 {
632         struct cli_state *cli;
633         int ret;
634         RAP_USER_INFO_1 userinfo;
635
636         if (argc == 0) {
637                 d_printf("\n\nUser name not specified\n");
638                 return net_rap_user_usage(argc, argv);
639         }
640
641         if (!(cli = net_make_ipc_connection(0)))
642                 return -1;
643                         
644         safe_strcpy(userinfo.user_name, argv[0], sizeof(userinfo.user_name)-1);
645         if (opt_flags == -1) 
646                 opt_flags = 0x21; 
647                         
648         userinfo.userflags = opt_flags;
649         userinfo.reserved1 = '\0';
650         userinfo.comment = smb_xstrdup(opt_comment);
651         userinfo.priv = 1; 
652         userinfo.home_dir = NULL;
653         userinfo.logon_script = NULL;
654
655         ret = cli_NetUserAdd(cli, &userinfo);
656
657         cli_shutdown(cli);
658         return ret;
659 }
660
661 static int rap_user_info(int argc, const char **argv)
662 {
663         struct cli_state *cli;
664         int ret;
665         if (argc == 0) {
666                 d_printf("\n\nUser name not specified\n");
667                 return net_rap_user_usage(argc, argv);
668         }
669
670         if (!(cli = net_make_ipc_connection(0)))
671                 return -1;
672
673         ret = cli_NetUserGetGroups(cli, argv[0], group_member_fn, NULL);
674         cli_shutdown(cli);
675         return ret;
676 }
677
678 int net_rap_user(int argc, const char **argv)
679 {
680         int ret = -1;
681         struct functable func[] = {
682                 {"ADD", rap_user_add},
683                 {"INFO", rap_user_info},
684                 {"DELETE", rap_user_delete},
685                 {NULL, NULL}
686         };
687
688         if (argc == 0) {
689                 struct cli_state *cli;
690                 if (!(cli = net_make_ipc_connection(0)))
691                         goto done;
692                 if (opt_long_list_entries) {
693                         d_printf("\nUser name             Comment"\
694                                  "\n-----------------------------\n");
695                         ret = cli_RNetUserEnum(cli, long_user_fn, NULL);
696                         cli_shutdown(cli);
697                         goto done;
698                 }
699                 ret = cli_RNetUserEnum(cli, user_fn, NULL); 
700                 cli_shutdown(cli);
701                 goto done;
702         }
703
704         ret = net_run_function(argc, argv, func, net_rap_user_usage);
705  done:
706         if (ret != 0) {
707                 DEBUG(1, ("Net user returned: %d\n", ret));
708         }
709         return ret;
710 }
711
712
713 int net_rap_group_usage(int argc, const char **argv)
714 {
715         return net_help_group(argc, argv);
716 }
717
718 static void long_group_fn(const char *group_name, const char *comment,
719                           void *state)
720 {
721         d_printf("%-21.21s %s\n", group_name, comment);
722 }
723
724 static void group_fn(const char *group_name, const char *comment, void *state)
725 {
726         d_printf("%-21.21s\n", group_name);
727 }
728
729 static int rap_group_delete(int argc, const char **argv)
730 {
731         struct cli_state *cli;
732         int ret;
733         if (argc == 0) {
734                 d_printf("\n\nGroup name not specified\n");
735                 return net_rap_group_usage(argc, argv);
736         }
737
738         if (!(cli = net_make_ipc_connection(0)))
739                 return -1;
740
741         ret = cli_NetGroupDelete(cli, argv[0]);
742         cli_shutdown(cli);
743         return ret;
744 }
745
746 static int rap_group_add(int argc, const char **argv)
747 {
748         struct cli_state *cli;
749         int ret;
750         RAP_GROUP_INFO_1 grinfo;
751
752         if (argc == 0) {
753                 d_printf("\n\nGroup name not specified\n");
754                 return net_rap_group_usage(argc, argv);
755         }
756
757         if (!(cli = net_make_ipc_connection(0)))
758                 return -1;
759                         
760         /* BB check for length 21 or smaller explicitly ? BB */
761         safe_strcpy(grinfo.group_name, argv[0], sizeof(grinfo.group_name)-1);
762         grinfo.reserved1 = '\0';
763         grinfo.comment = smb_xstrdup(opt_comment);
764         
765         ret = cli_NetGroupAdd(cli, &grinfo);
766         cli_shutdown(cli);
767         return ret;
768 }
769
770 int net_rap_group(int argc, const char **argv)
771 {
772         struct functable func[] = {
773                 {"ADD", rap_group_add},
774                 {"DELETE", rap_group_delete},
775                 {NULL, NULL}
776         };
777
778         if (argc == 0) {
779                 struct cli_state *cli;
780                 int ret;
781                 if (!(cli = net_make_ipc_connection(0)))
782                         return -1;
783                 if (opt_long_list_entries) {
784                         d_printf("Group name            Comment\n");
785                         d_printf("-----------------------------\n");
786                         ret = cli_RNetGroupEnum(cli, long_group_fn, NULL);
787                         cli_shutdown(cli);
788                         return ret;
789                 }
790                 ret = cli_RNetGroupEnum(cli, group_fn, NULL); 
791                 cli_shutdown(cli);
792                 return ret;
793         }
794
795         return net_run_function(argc, argv, func, net_rap_group_usage);
796 }
797
798 int net_rap_groupmember_usage(int argc, const char **argv)
799 {
800         d_printf(
801          "net rap groupmember LIST <group> [misc. options] [targets]"\
802          "\n\t Enumerate users in a group\n"\
803          "\nnet rap groupmember DELETE <group> <user> [misc. options] "\
804          "[targets]\n\t Delete sepcified user from specified group\n"\
805          "\nnet rap groupmember ADD <group> <user> [misc. options] [targets]"\
806          "\n\t Add specified user to specified group\n");
807
808         net_common_flags_usage(argc, argv);
809         return -1;
810 }
811
812
813 static int rap_groupmember_add(int argc, const char **argv)
814 {
815         struct cli_state *cli;
816         int ret;
817         if (argc != 2) {
818                 d_printf("\n\nGroup or user name not specified\n");
819                 return net_rap_groupmember_usage(argc, argv);
820         }
821
822         if (!(cli = net_make_ipc_connection(0)))
823                 return -1;
824
825         ret = cli_NetGroupAddUser(cli, argv[0], argv[1]);
826         cli_shutdown(cli);
827         return ret;
828 }
829
830 static int rap_groupmember_delete(int argc, const char **argv)
831 {
832         struct cli_state *cli;
833         int ret;
834         if (argc != 2) {
835                 d_printf("\n\nGroup or user name not specified\n");
836                 return net_rap_groupmember_usage(argc, argv);
837         }
838         
839         if (!(cli = net_make_ipc_connection(0)))
840                 return -1;
841
842         ret = cli_NetGroupDelUser(cli, argv[0], argv[1]);
843         cli_shutdown(cli);
844         return ret;
845 }
846
847 static int rap_groupmember_list(int argc, const char **argv)
848 {
849         struct cli_state *cli;
850         int ret;
851         if (argc == 0) {
852                 d_printf("\n\nGroup name not specified\n");
853                 return net_rap_groupmember_usage(argc, argv);
854         }
855
856         if (!(cli = net_make_ipc_connection(0)))
857                 return -1;
858
859         ret = cli_NetGroupGetUsers(cli, argv[0], group_member_fn, NULL ); 
860         cli_shutdown(cli);
861         return ret;
862 }
863
864 int net_rap_groupmember(int argc, const char **argv)
865 {
866         struct functable func[] = {
867                 {"ADD", rap_groupmember_add},
868                 {"LIST", rap_groupmember_list},
869                 {"DELETE", rap_groupmember_delete},
870                 {NULL, NULL}
871         };
872         
873         return net_run_function(argc, argv, func, net_rap_groupmember_usage);
874 }
875
876 int net_rap_validate_usage(int argc, const char **argv)
877 {
878         d_printf("net rap validate <username> [password]\n"\
879                  "\tValidate user and password to check whether they"\
880                  " can access target server or domain\n");
881
882         net_common_flags_usage(argc, argv);
883         return -1;
884 }
885
886 int net_rap_validate(int argc, const char **argv)
887 {
888         return errmsg_not_implemented();
889 }
890
891 int net_rap_service_usage(int argc, const char **argv)
892 {
893         d_printf("net rap service [misc. options] [targets] \n"\
894                  "\tlists all running service daemons on target server\n");
895         d_printf("\nnet rap service START <name> [service startup arguments]"\
896                  " [misc. options] [targets]"\
897                  "\n\tStart named service on remote server\n");
898         d_printf("\nnet rap service STOP <name> [misc. options] [targets]\n"\
899                  "\n\tStop named service on remote server\n");
900     
901         net_common_flags_usage(argc, argv);
902         return -1;
903 }
904
905 static int rap_service_start(int argc, const char **argv)
906 {
907         return errmsg_not_implemented();
908 }
909
910 static int rap_service_stop(int argc, const char **argv)
911 {
912         return errmsg_not_implemented();
913 }
914
915 int net_rap_service(int argc, const char **argv)
916 {
917         struct functable func[] = {
918                 {"START", rap_service_start},
919                 {"STOP", rap_service_stop},
920                 {NULL, NULL}
921         };
922
923         if (argc == 0) {
924                 struct cli_state *cli;
925                 int ret;
926                 if (!(cli = net_make_ipc_connection(0))) 
927                         return -1;
928
929                 if (opt_long_list_entries) {
930                         d_printf("Service name          Comment\n");
931                         d_printf("-----------------------------\n");
932                         ret = cli_RNetServiceEnum(cli, long_group_fn, NULL);
933                 }
934                 ret = cli_RNetServiceEnum(cli, group_fn, NULL); 
935                 cli_shutdown(cli);
936                 return ret;
937         }
938
939         return net_run_function(argc, argv, func, net_rap_service_usage);
940 }
941
942 int net_rap_password_usage(int argc, const char **argv)
943 {
944         d_printf(
945          "net rap password <user> <oldpwo> <newpw> [misc. options] [target]\n"\
946          "\tchanges the password for the specified user at target\n"); 
947         
948         return -1;
949 }
950
951
952 int net_rap_password(int argc, const char **argv)
953 {
954         struct cli_state *cli;
955         int ret;
956         
957         if (argc < 3) 
958                 return net_rap_password_usage(argc, argv);
959
960         if (!(cli = net_make_ipc_connection(0))) 
961                 return -1;
962
963         /* BB Add check for password lengths? */
964         ret = cli_oem_change_password(cli, argv[0], argv[2], argv[1]);
965         cli_shutdown(cli);
966         return ret;
967 }
968
969 int net_rap_admin_usage(int argc, const char **argv)
970 {
971         d_printf(
972    "net rap admin <remote command> [cmd args [env]] [misc. options] [targets]"\
973    "\n\texecutes a remote command on an os/2 target server\n"); 
974         
975         return -1;
976 }
977
978
979 int net_rap_admin(int argc, const char **argv)
980 {
981         return errmsg_not_implemented();
982 }
983
984 /* The help subsystem for the RAP subcommand */
985
986 int net_rap_usage(int argc, const char **argv)
987 {
988         d_printf("  net rap domain \tto list domains \n"\
989                  "  net rap file \t\tto list open files on a server \n"\
990                  "  net rap group \tto list user groups  \n"\
991                  "  net rap groupmember \tto list users in a group \n"\
992                  "  net rap password \tto change the password of a user\n"\
993                  "  net rap printq \tto list the print queues on a server\n"\
994                  "  net rap server \tto list servers in a domain\n"\
995                  "  net rap session \tto list clients with open sessions to a server\n"\
996                  "  net rap share \tto list shares exported by a server\n"\
997                  "  net rap user \t\tto list users\n"\
998                  "  net rap validate \tto check whether a user and the corresponding password are valid\n"\
999                  "  net rap help\n"\
1000                  "\nType \"net help <option>\" to get more information on that option\n\n");
1001
1002         net_common_flags_usage(argc, argv);
1003         return -1;
1004 }
1005
1006 /*
1007   handle "net rap help *" subcommands
1008 */
1009 int net_rap_help(int argc, const char **argv)
1010 {
1011         struct functable func[] = {
1012                 {"FILE", net_rap_file_usage},
1013                 {"SHARE", net_rap_share_usage},
1014                 {"SESSION", net_rap_session_usage},
1015                 {"SERVER", net_rap_server_usage},
1016                 {"DOMAIN", net_rap_domain_usage},
1017                 {"PRINTQ", net_rap_printq_usage},
1018                 {"USER", net_rap_user_usage},
1019                 {"GROUP", net_rap_group_usage},
1020                 {"VALIDATE", net_rap_validate_usage},
1021                 {"GROUPMEMBER", net_rap_groupmember_usage},
1022                 {"ADMIN", net_rap_admin_usage},
1023                 {"SERVICE", net_rap_service_usage},
1024                 {"PASSWORD", net_rap_password_usage},
1025                 {NULL, NULL}};
1026
1027         return net_run_function(argc, argv, func, net_rap_usage);
1028 }
1029
1030 /* Entry-point for all the RAP functions. */
1031
1032 int net_rap(int argc, const char **argv)
1033 {
1034         struct functable func[] = {
1035                 {"FILE", net_rap_file},
1036                 {"SHARE", net_rap_share},
1037                 {"SESSION", net_rap_session},
1038                 {"SERVER", net_rap_server},
1039                 {"DOMAIN", net_rap_domain},
1040                 {"PRINTQ", net_rap_printq},
1041                 {"USER", net_rap_user},
1042                 {"GROUP", net_rap_group},
1043                 {"VALIDATE", net_rap_validate},
1044                 {"GROUPMEMBER", net_rap_groupmember},
1045                 {"ADMIN", net_rap_admin},
1046                 {"SERVICE", net_rap_service},   
1047                 {"PASSWORD", net_rap_password},
1048                 {"HELP", net_rap_help},
1049                 {NULL, NULL}
1050         };
1051         
1052         return net_run_function(argc, argv, func, net_rap_usage);
1053 }
1054