?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
librpc/ndr: remove 'async' from ndr_interface_call
[Samba/gebeck_regimport.git] / source3 / utils / net_rap.c
blob04e81f95f737538ff063daef322bb12ad783f8cd
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 3 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, see <http://www.gnu.org/licenses/>. */
24
25 #include "includes.h"
26 #include "../librpc/gen_ndr/rap.h"
27 #include "../librpc/gen_ndr/svcctl.h"
28 #include "utils/net.h"
29
30 /* The following messages were for error checking that is not properly
31 reported at the moment. Which should be reinstated? */
32 #define ERRMSG_TARGET_WG_NOT_VALID "\nTarget workgroup option not valid "\
33 "except on net rap server command, ignored"
34 #define ERRMSG_INVALID_HELP_OPTION "\nInvalid help option\n"
35
36 #define ERRMSG_BOTH_SERVER_IPADDRESS "\nTarget server and IP address both "\
37 "specified. Do not set both at the same time. The target IP address was used\n"
38
39 static int errmsg_not_implemented(void)
40 {
41 d_printf(_("\nNot implemented\n"));
42 return 0;
43 }
44
45 int net_rap_file_usage(struct net_context *c, int argc, const char **argv)
46 {
47 return net_file_usage(c, argc, argv);
48 }
49
50 /***************************************************************************
51 list info on an open file
52 ***************************************************************************/
53 static void file_fn(const char * pPath, const char * pUser, uint16 perms,
54 uint16 locks, uint32 id)
55 {
56 d_printf("%-7.1d %-20.20s 0x%-4.2x %-6.1d %s\n",
57 id, pUser, perms, locks, pPath);
58 }
59
60 static void one_file_fn(const char *pPath, const char *pUser, uint16 perms,
61 uint16 locks, uint32 id)
62 {
63 d_printf(_("File ID %d\n"
64 "User name %s\n"
65 "Locks 0x%-4.2x\n"
66 "Path %s\n"
67 "Permissions 0x%x\n"),
68 id, pUser, locks, pPath, perms);
69 }
70
71
72 static int rap_file_close(struct net_context *c, int argc, const char **argv)
73 {
74 struct cli_state *cli;
75 int ret;
76 if (argc == 0 || c->display_usage) {
77 return net_rap_file_usage(c, argc, argv);
78 }
79
80 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
81 return -1;
82
83 ret = cli_NetFileClose(cli, atoi(argv[0]));
84 cli_shutdown(cli);
85 return ret;
86 }
87
88 static int rap_file_info(struct net_context *c, int argc, const char **argv)
89 {
90 struct cli_state *cli;
91 int ret;
92 if (argc == 0 || c->display_usage)
93 return net_rap_file_usage(c, argc, argv);
94
95 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
96 return -1;
97
98 ret = cli_NetFileGetInfo(cli, atoi(argv[0]), one_file_fn);
99 cli_shutdown(cli);
100 return ret;
101 }
102
103 static int rap_file_user(struct net_context *c, int argc, const char **argv)
104 {
105 struct cli_state *cli;
106 int ret;
107
108 if (argc == 0 || c->display_usage)
109 return net_rap_file_usage(c, argc, argv);
110
111 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
112 return -1;
113
114 /* list open files */
115
116 d_printf(_("\nEnumerating open files on remote server:\n\n"
117 "\nFileId Opened by Perms Locks Path \n"
118 "------ --------- ----- ----- ---- \n"));
119 ret = cli_NetFileEnum(cli, argv[0], NULL, file_fn);
120
121 if (ret == -1)
122 d_printf(_("\nOperation not supported by server!\n\n"));
123
124 cli_shutdown(cli);
125 return ret;
126 }
127
128 int net_rap_file(struct net_context *c, int argc, const char **argv)
129 {
130 struct functable func[] = {
131 {
132 "close",
133 rap_file_close,
134 NET_TRANSPORT_RAP,
135 N_("Close specified file on server"),
136 N_("net rap file close\n"
137 " Close specified file on server")
138 },
139 {
140 "user",
141 rap_file_user,
142 NET_TRANSPORT_RAP,
143 N_("List all files opened by username"),
144 N_("net rap file user\n"
145 " List all files opened by username")
146 },
147 {
148 "info",
149 rap_file_info,
150 NET_TRANSPORT_RAP,
151 N_("Display info about an opened file"),
152 N_("net rap file info\n"
153 " Display info about an opened file")
154 },
155 {NULL, NULL, 0, NULL, NULL}
156 };
157
158 if (argc == 0) {
159 struct cli_state *cli;
160 int ret;
161
162 if (c->display_usage) {
163 d_printf(_("Usage:\n"));
164 d_printf(_("net rap file\n"
165 " List all open files on rempte "
166 "server\n"));
167 net_display_usage_from_functable(func);
168 return 0;
169 }
170
171 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
172 return -1;
173
174 /* list open files */
175
176 d_printf(_("\nEnumerating open files on remote server:\n\n"
177 "\nFileId Opened by Perms Locks Path\n"
178 "------ --------- ----- ----- ----\n"));
179 ret = cli_NetFileEnum(cli, NULL, NULL, file_fn);
180
181 if (ret == -1)
182 d_printf(_("\nOperation not supported by server!\n\n"));
183
184 cli_shutdown(cli);
185 return ret;
186 }
187
188 return net_run_function(c, argc, argv, "net rap file", func);
189 }
190
191 int net_rap_share_usage(struct net_context *c, int argc, const char **argv)
192 {
193 return net_share_usage(c, argc, argv);
194 }
195
196 static void long_share_fn(const char *share_name, uint32 type,
197 const char *comment, void *state)
198 {
199 d_printf("%-12s %-8.8s %-50s\n",
200 share_name, net_share_type_str(type), comment);
201 }
202
203 static void share_fn(const char *share_name, uint32 type,
204 const char *comment, void *state)
205 {
206 d_printf("%s\n", share_name);
207 }
208
209 static int rap_share_delete(struct net_context *c, int argc, const char **argv)
210 {
211 struct cli_state *cli;
212 int ret;
213
214 if (argc == 0 || c->display_usage) {
215 return net_rap_share_usage(c, argc, argv);
216 }
217
218 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
219 return -1;
220
221 ret = cli_NetShareDelete(cli, argv[0]);
222 cli_shutdown(cli);
223 return ret;
224 }
225
226 static int rap_share_add(struct net_context *c, int argc, const char **argv)
227 {
228 struct cli_state *cli;
229 int ret;
230
231 struct rap_share_info_2 sinfo;
232 char *p;
233 char *sharename;
234
235 if (argc == 0 || c->display_usage) {
236 return net_rap_share_usage(c, argc, argv);
237 }
238
239 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
240 return -1;
241
242 sharename = SMB_STRDUP(argv[0]);
243 p = strchr(sharename, '=');
244 if (p == NULL) {
245 d_printf(_("Server path not specified\n"));
246 SAFE_FREE(sharename);
247 return net_rap_share_usage(c, argc, argv);
248 }
249 *p = 0;
250 strlcpy((char *)sinfo.share_name, sharename, sizeof(sinfo.share_name));
251 sinfo.reserved1 = '\0';
252 sinfo.share_type = 0;
253 sinfo.comment = c->opt_comment ? smb_xstrdup(c->opt_comment) : "";
254 sinfo.perms = 0;
255 sinfo.maximum_users = c->opt_maxusers;
256 sinfo.active_users = 0;
257 sinfo.path = p+1;
258 memset(sinfo.password, '\0', sizeof(sinfo.password));
259 sinfo.reserved2 = '\0';
260
261 ret = cli_NetShareAdd(cli, &sinfo);
262 cli_shutdown(cli);
263 SAFE_FREE(sharename);
264 return ret;
265 }
266
267
268 int net_rap_share(struct net_context *c, int argc, const char **argv)
269 {
270 struct functable func[] = {
271 {
272 "delete",
273 rap_share_delete,
274 NET_TRANSPORT_RAP,
275 N_("Delete a share from server"),
276 N_("net rap share delete\n"
277 " Delete a share from server")
278 },
279 {
280 "close",
281 rap_share_delete,
282 NET_TRANSPORT_RAP,
283 N_("Delete a share from server"),
284 N_("net rap share close\n"
285 " Delete a share from server\n"
286 " Alias for net rap share delete")
287 },
288 {
289 "add",
290 rap_share_add,
291 NET_TRANSPORT_RAP,
292 N_("Add a share to server"),
293 N_("net rap share add\n"
294 " Add a share to server")
295 },
296 {NULL, NULL, 0, NULL, NULL}
297 };
298
299 if (argc == 0) {
300 struct cli_state *cli;
301 int ret;
302
303 if (c->display_usage) {
304 d_printf(_("Usage:\n"));
305 d_printf(_("net rap share\n"
306 " List all shares on remote server\n"));
307 net_display_usage_from_functable(func);
308 return 0;
309 }
310
311 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
312 return -1;
313
314 if (c->opt_long_list_entries) {
315 d_printf(_(
316 "\nEnumerating shared resources (exports) on remote server:\n\n"
317 "\nShare name Type Description\n"
318 "---------- ---- -----------\n"));
319 ret = cli_RNetShareEnum(cli, long_share_fn, NULL);
320 } else {
321 ret = cli_RNetShareEnum(cli, share_fn, NULL);
322 }
323 cli_shutdown(cli);
324 return ret;
325 }
326
327 return net_run_function(c, argc, argv, "net rap share", func);
328 }
329
330 int net_rap_session_usage(struct net_context *c, int argc, const char **argv)
331 {
332 d_printf(_(
333 "\nnet rap session [misc. options] [targets]"
334 "\n\tenumerates all active SMB/CIFS sessions on target server\n"));
335 d_printf(_(
336 "\nnet rap session DELETE <client_name> [misc. options] [targets] \n"
337 "\tor"
338 "\nnet rap session CLOSE <client_name> [misc. options] [targets]"
339 "\n\tDeletes (closes) a session from specified client to server\n"));
340 d_printf(_(
341 "\nnet rap session INFO <client_name>"
342 "\n\tEnumerates all open files in specified session\n"));
343
344 net_common_flags_usage(c, argc, argv);
345 return -1;
346 }
347
348 static void list_sessions_func(char *wsname, char *username, uint16 conns,
349 uint16 opens, uint16 users, uint32 sess_time,
350 uint32 idle_time, uint32 user_flags, char *clitype)
351 {
352 int hrs = idle_time / 3600;
353 int min = (idle_time / 60) % 60;
354 int sec = idle_time % 60;
355
356 d_printf("\\\\%-18.18s %-20.20s %-18.18s %5d %2.2d:%2.2d:%2.2d\n",
357 wsname, username, clitype, opens, hrs, min, sec);
358 }
359
360 static void display_session_func(const char *wsname, const char *username,
361 uint16 conns, uint16 opens, uint16 users,
362 uint32 sess_time, uint32 idle_time,
363 uint32 user_flags, const char *clitype)
364 {
365 int ihrs = idle_time / 3600;
366 int imin = (idle_time / 60) % 60;
367 int isec = idle_time % 60;
368 int shrs = sess_time / 3600;
369 int smin = (sess_time / 60) % 60;
370 int ssec = sess_time % 60;
371 d_printf(_("User name %-20.20s\n"
372 "Computer %-20.20s\n"
373 "Guest logon %-20.20s\n"
374 "Client Type %-40.40s\n"
375 "Sess time %2.2d:%2.2d:%2.2d\n"
376 "Idle time %2.2d:%2.2d:%2.2d\n"),
377 username, wsname,
378 (user_flags&0x0)?_("yes"):_("no"), clitype,
379 shrs, smin, ssec, ihrs, imin, isec);
380 }
381
382 static void display_conns_func(uint16 conn_id, uint16 conn_type, uint16 opens,
383 uint16 users, uint32 conn_time,
384 const char *username, const char *netname)
385 {
386 d_printf("%-14.14s %-8.8s %5d\n",
387 netname, net_share_type_str(conn_type), opens);
388 }
389
390 static int rap_session_info(struct net_context *c, int argc, const char **argv)
391 {
392 const char *sessname;
393 struct cli_state *cli;
394 int ret;
395
396 if (argc == 0 || c->display_usage)
397 return net_rap_session_usage(c, argc, argv);
398
399 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
400 return -1;
401
402 sessname = argv[0];
403
404 ret = cli_NetSessionGetInfo(cli, sessname, display_session_func);
405 if (ret < 0) {
406 cli_shutdown(cli);
407 return ret;
408 }
409
410 d_printf(_("Share name Type # Opens\n-------------------------"
411 "-----------------------------------------------------\n"));
412 ret = cli_NetConnectionEnum(cli, sessname, display_conns_func);
413 cli_shutdown(cli);
414 return ret;
415 }
416
417 static int rap_session_delete(struct net_context *c, int argc, const char **argv)
418 {
419 struct cli_state *cli;
420 int ret;
421
422 if (argc == 0 || c->display_usage)
423 return net_rap_session_usage(c, argc, argv);
424
425 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
426 return -1;
427
428 ret = cli_NetSessionDel(cli, argv[0]);
429 cli_shutdown(cli);
430 return ret;
431 }
432
433 int net_rap_session(struct net_context *c, int argc, const char **argv)
434 {
435 struct functable func[] = {
436 {
437 "info",
438 rap_session_info,
439 NET_TRANSPORT_RAP,
440 N_("Display information about session"),
441 N_("net rap session info\n"
442 " Display information about session")
443 },
444 {
445 "delete",
446 rap_session_delete,
447 NET_TRANSPORT_RAP,
448 N_("Close specified session"),
449 N_("net rap session delete\n"
450 " Close specified session\n"
451 " Alias for net rap session close")
452 },
453 {
454 "close",
455 rap_session_delete,
456 NET_TRANSPORT_RAP,
457 N_("Close specified session"),
458 N_("net rap session close\n"
459 " Close specified session")
460 },
461 {NULL, NULL, 0, NULL, NULL}
462 };
463
464 if (argc == 0) {
465 struct cli_state *cli;
466 int ret;
467
468 if (c->display_usage) {
469 d_printf(_("Usage:\n"));
470 d_printf(_("net rap session\n"
471 " List all open sessions on remote "
472 "server\n"));
473 net_display_usage_from_functable(func);
474 return 0;
475 }
476
477 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
478 return -1;
479
480 d_printf(_("Computer User name "
481 "Client Type Opens Idle time\n"
482 "------------------------------------------"
483 "------------------------------------\n"));
484 ret = cli_NetSessionEnum(cli, list_sessions_func);
485
486 cli_shutdown(cli);
487 return ret;
488 }
489
490 return net_run_function(c, argc, argv, "net rap session", func);
491 }
492
493 /****************************************************************************
494 list a server name
495 ****************************************************************************/
496 static void display_server_func(const char *name, uint32 m,
497 const char *comment, void * reserved)
498 {
499 d_printf("\t%-16.16s %s\n", name, comment);
500 }
501
502 static int net_rap_server_name(struct net_context *c, int argc, const char *argv[])
503 {
504 struct cli_state *cli;
505 char *name;
506
507 if (c->display_usage) {
508 d_printf("%s\n%s",
509 _("Usage:"),
510 _("net rap server name\n"
511 " Get the name of the server\n"));
512 return 0;
513 }
514
515 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
516 return -1;
517
518 if (!cli_get_server_name(NULL, cli, &name)) {
519 d_fprintf(stderr, _("cli_get_server_name failed\n"));
520 cli_shutdown(cli);
521 return -1;
522 }
523
524 d_printf(_("Server name = %s\n"), name);
525
526 TALLOC_FREE(name);
527 cli_shutdown(cli);
528 return 0;
529 }
530
531 static int net_rap_server_domain(struct net_context *c, int argc,
532 const char **argv)
533 {
534 struct cli_state *cli;
535 int ret;
536
537 if (c->display_usage) {
538 d_printf("%s\n%s",
539 _("Usage:"),
540 _("net rap server domain\n"
541 " Enumerate servers in this domain/workgroup\n"));
542 return 0;
543 }
544
545 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
546 return -1;
547
548 d_printf(_("\nEnumerating servers in this domain or workgroup: \n\n"
549 "\tServer name Server description\n"
550 "\t------------- ----------------------------\n"));
551
552 ret = cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_ALL,
553 display_server_func,NULL);
554 cli_shutdown(cli);
555 return ret;
556 }
557
558 int net_rap_server(struct net_context *c, int argc, const char **argv)
559 {
560 struct functable func[] = {
561 {
562 "name",
563 net_rap_server_name,
564 NET_TRANSPORT_RAP,
565 N_("Get the name of the server"),
566 N_("net rap server name\n"
567 " Get the name of the server")
568 },
569 {
570 "domain",
571 net_rap_server_domain,
572 NET_TRANSPORT_RAP,
573 N_("Get the servers in this domain/workgroup"),
574 N_("net rap server domain\n"
575 " Get the servers in this domain/workgroup")
576 },
577 {NULL, NULL, 0, NULL, NULL}
578 };
579
580 /* smb4k uses 'net [rap|rpc] server domain' to query servers in a domain */
581 /* Fall through for 'domain', any other forms will cause to show usage message */
582 return net_run_function(c, argc, argv, "net rap server", func);
583
584 }
585
586 int net_rap_domain_usage(struct net_context *c, int argc, const char **argv)
587 {
588 d_printf(_("net rap domain [misc. options] [target]\n\tlists the"
589 " domains or workgroups visible on the current network\n"));
590
591 net_common_flags_usage(c, argc, argv);
592 return -1;
593 }
594
595 int net_rap_domain(struct net_context *c, int argc, const char **argv)
596 {
597 struct cli_state *cli;
598 int ret;
599
600 if (c->display_usage)
601 return net_rap_domain_usage(c, argc, argv);
602
603 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
604 return -1;
605
606 d_printf(_("\nEnumerating domains:\n\n"
607 "\tDomain name Server name of Browse Master\n"
608 "\t------------- ----------------------------\n"));
609
610 ret = cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_DOMAIN_ENUM,
611 display_server_func,NULL);
612 cli_shutdown(cli);
613 return ret;
614 }
615
616 int net_rap_printq_usage(struct net_context *c, int argc, const char **argv)
617 {
618 d_printf(_(
619 "net rap printq [misc. options] [targets]\n"
620 "\tor\n"
621 "net rap printq info [<queue_name>] [misc. options] [targets]\n"
622 "\tlists the specified queue and jobs on the target server.\n"
623 "\tIf the queue name is not specified, all queues are listed.\n\n"));
624 d_printf(_(
625 "net rap printq delete [<queue name>] [misc. options] [targets]\n"
626 "\tdeletes the specified job number on the target server, or the\n"
627 "\tprinter queue if no job number is specified\n"));
628
629 net_common_flags_usage(c, argc, argv);
630
631 return -1;
632 }
633
634 static void enum_queue(const char *queuename, uint16 pri, uint16 start,
635 uint16 until, const char *sep, const char *pproc,
636 const char *dest, const char *qparms,
637 const char *qcomment, uint16 status, uint16 jobcount)
638 {
639 d_printf(_("%-17.17s Queue %5d jobs "),
640 queuename, jobcount);
641
642 switch (status) {
643 case 0:
644 d_printf(_("*Printer Active*\n"));
645 break;
646 case 1:
647 d_printf(_("*Printer Paused*\n"));
648 break;
649 case 2:
650 d_printf(_("*Printer error*\n"));
651 break;
652 case 3:
653 d_printf(_("*Delete Pending*\n"));
654 break;
655 default:
656 d_printf(_("**UNKNOWN STATUS**\n"));
657 }
658 }
659
660 static void enum_jobs(uint16 jobid, const char *ownername,
661 const char *notifyname, const char *datatype,
662 const char *jparms, uint16 pos, uint16 status,
663 const char *jstatus, unsigned int submitted, unsigned int jobsize,
664 const char *comment)
665 {
666 d_printf(" %-23.23s %5d %9d ",
667 ownername, jobid, jobsize);
668 switch (status) {
669 case 0:
670 d_printf(_("Waiting\n"));
671 break;
672 case 1:
673 d_printf(_("Held in queue\n"));
674 break;
675 case 2:
676 d_printf(_("Spooling\n"));
677 break;
678 case 3:
679 d_printf(_("Printing\n"));
680 break;
681 default:
682 d_printf(_("**UNKNOWN STATUS**\n"));
683 }
684 }
685
686 #define PRINTQ_ENUM_DISPLAY \
687 _("Print queues at \\\\%s\n\n"\
688 "Name Job # Size Status\n\n"\
689 "------------------------------------------------------------------"\
690 "-------------\n")
691
692 static int rap_printq_info(struct net_context *c, int argc, const char **argv)
693 {
694 struct cli_state *cli;
695 int ret;
696
697 if (argc == 0 || c->display_usage)
698 return net_rap_printq_usage(c, argc, argv);
699
700 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
701 return -1;
702
703 d_printf(PRINTQ_ENUM_DISPLAY, cli->desthost); /* list header */
704 ret = cli_NetPrintQGetInfo(cli, argv[0], enum_queue, enum_jobs);
705 cli_shutdown(cli);
706 return ret;
707 }
708
709 static int rap_printq_delete(struct net_context *c, int argc, const char **argv)
710 {
711 struct cli_state *cli;
712 int ret;
713
714 if (argc == 0 || c->display_usage)
715 return net_rap_printq_usage(c, argc, argv);
716
717 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
718 return -1;
719
720 ret = cli_printjob_del(cli, atoi(argv[0]));
721 cli_shutdown(cli);
722 return ret;
723 }
724
725 int net_rap_printq(struct net_context *c, int argc, const char **argv)
726 {
727 struct cli_state *cli;
728 int ret;
729
730 struct functable func[] = {
731 {
732 "info",
733 rap_printq_info,
734 NET_TRANSPORT_RAP,
735 N_("Display info about print queues and jobs"),
736 N_("net rap printq info [queue]\n"
737 " Display info about print jobs in queue.\n"
738 " If queue is not specified, all queues are "
739 "listed")
740 },
741 {
742 "delete",
743 rap_printq_delete,
744 NET_TRANSPORT_RAP,
745 N_("Delete print job(s)"),
746 N_("net rap printq delete\n"
747 " Delete print job(s)")
748 },
749 {NULL, NULL, 0, NULL, NULL}
750 };
751
752 if (argc == 0) {
753 if (c->display_usage) {
754 d_printf(_("Usage:\n"));
755 d_printf(_("net rap printq\n"
756 " List the print queue\n"));
757 net_display_usage_from_functable(func);
758 return 0;
759 }
760
761 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
762 return -1;
763
764 d_printf(PRINTQ_ENUM_DISPLAY, cli->desthost); /* list header */
765 ret = cli_NetPrintQEnum(cli, enum_queue, enum_jobs);
766 cli_shutdown(cli);
767 return ret;
768 }
769
770 return net_run_function(c, argc, argv, "net rap printq", func);
771 }
772
773 static int net_rap_user_usage(struct net_context *c, int argc, const char **argv)
774 {
775 return net_user_usage(c, argc, argv);
776 }
777
778 static void user_fn(const char *user_name, void *state)
779 {
780 d_printf("%-21.21s\n", user_name);
781 }
782
783 static void long_user_fn(const char *user_name, const char *comment,
784 const char * home_dir, const char * logon_script,
785 void *state)
786 {
787 d_printf("%-21.21s %s\n",
788 user_name, comment);
789 }
790
791 static void group_member_fn(const char *user_name, void *state)
792 {
793 d_printf("%-21.21s\n", user_name);
794 }
795
796 static int rap_user_delete(struct net_context *c, int argc, const char **argv)
797 {
798 struct cli_state *cli;
799 int ret;
800
801 if (argc == 0 || c->display_usage) {
802 return net_rap_user_usage(c, argc, argv);
803 }
804
805 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
806 return -1;
807
808 ret = cli_NetUserDelete(cli, argv[0]);
809 cli_shutdown(cli);
810 return ret;
811 }
812
813 static int rap_user_add(struct net_context *c, int argc, const char **argv)
814 {
815 struct cli_state *cli;
816 int ret;
817 struct rap_user_info_1 userinfo;
818
819 if (argc == 0 || c->display_usage) {
820 return net_rap_user_usage(c, argc, argv);
821 }
822
823 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
824 return -1;
825
826 safe_strcpy((char *)userinfo.user_name, argv[0], sizeof(userinfo.user_name)-1);
827 if (c->opt_flags == -1)
828 c->opt_flags = 0x21;
829
830 userinfo.userflags = c->opt_flags;
831 userinfo.reserved1 = '\0';
832 userinfo.comment = smb_xstrdup(c->opt_comment ? c->opt_comment : "");
833 userinfo.priv = 1;
834 userinfo.home_dir = NULL;
835 userinfo.logon_script = NULL;
836 userinfo.passwrd[0] = '\0';
837
838 ret = cli_NetUserAdd(cli, &userinfo);
839
840 cli_shutdown(cli);
841 return ret;
842 }
843
844 static int rap_user_info(struct net_context *c, int argc, const char **argv)
845 {
846 struct cli_state *cli;
847 int ret;
848 if (argc == 0 || c->display_usage) {
849 return net_rap_user_usage(c, argc, argv);
850 }
851
852 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
853 return -1;
854
855 ret = cli_NetUserGetGroups(cli, argv[0], group_member_fn, NULL);
856 cli_shutdown(cli);
857 return ret;
858 }
859
860 int net_rap_user(struct net_context *c, int argc, const char **argv)
861 {
862 int ret = -1;
863 struct functable func[] = {
864 {
865 "add",
866 rap_user_add,
867 NET_TRANSPORT_RAP,
868 N_("Add specified user"),
869 N_("net rap user add\n"
870 " Add specified user")
871 },
872 {
873 "info",
874 rap_user_info,
875 NET_TRANSPORT_RAP,
876 N_("List domain groups of specified user"),
877 N_("net rap user info\n"
878 " List domain groups of specified user")
879
880 },
881 {
882 "delete",
883 rap_user_delete,
884 NET_TRANSPORT_RAP,
885 N_("Remove specified user"),
886 N_("net rap user delete\n"
887 " Remove specified user")
888 },
889 {NULL, NULL, 0, NULL, NULL}
890 };
891
892 if (argc == 0) {
893 struct cli_state *cli;
894 if (c->display_usage) {
895 d_printf(_("Usage:\n"));
896 d_printf(_("net rap user\n"
897 " List all users\n"));
898 net_display_usage_from_functable(func);
899 return 0;
900 }
901
902 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
903 goto done;
904 if (c->opt_long_list_entries) {
905 d_printf(_("\nUser name Comment"
906 "\n-----------------------------\n"));
907 ret = cli_RNetUserEnum(cli, long_user_fn, NULL);
908 cli_shutdown(cli);
909 goto done;
910 }
911 ret = cli_RNetUserEnum0(cli, user_fn, NULL);
912 cli_shutdown(cli);
913 goto done;
914 }
915
916 ret = net_run_function(c, argc, argv, "net rap user", func);
917 done:
918 if (ret != 0) {
919 DEBUG(1, (_("Net user returned: %d\n"), ret));
920 }
921 return ret;
922 }
923
924
925 int net_rap_group_usage(struct net_context *c, int argc, const char **argv)
926 {
927 return net_group_usage(c, argc, argv);
928 }
929
930 static void long_group_fn(const char *group_name, const char *comment,
931 void *state)
932 {
933 d_printf("%-21.21s %s\n", group_name, comment);
934 }
935
936 static void group_fn(const char *group_name, void *state)
937 {
938 d_printf("%-21.21s\n", group_name);
939 }
940
941 static int rap_group_delete(struct net_context *c, int argc, const char **argv)
942 {
943 struct cli_state *cli;
944 int ret;
945 if (argc == 0 || c->display_usage) {
946 return net_rap_group_usage(c, argc, argv);
947 }
948
949 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
950 return -1;
951
952 ret = cli_NetGroupDelete(cli, argv[0]);
953 cli_shutdown(cli);
954 return ret;
955 }
956
957 static int rap_group_add(struct net_context *c, int argc, const char **argv)
958 {
959 struct cli_state *cli;
960 int ret;
961 struct rap_group_info_1 grinfo;
962
963 if (argc == 0 || c->display_usage) {
964 return net_rap_group_usage(c, argc, argv);
965 }
966
967 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
968 return -1;
969
970 /* BB check for length 21 or smaller explicitly ? BB */
971 safe_strcpy((char *)grinfo.group_name, argv[0], sizeof(grinfo.group_name)-1);
972 grinfo.reserved1 = '\0';
973 grinfo.comment = smb_xstrdup(c->opt_comment ? c->opt_comment : "");
974
975 ret = cli_NetGroupAdd(cli, &grinfo);
976 cli_shutdown(cli);
977 return ret;
978 }
979
980 int net_rap_group(struct net_context *c, int argc, const char **argv)
981 {
982 struct functable func[] = {
983 {
984 "add",
985 rap_group_add,
986 NET_TRANSPORT_RAP,
987 N_("Add specified group"),
988 N_("net rap group add\n"
989 " Add specified group")
990 },
991 {
992 "delete",
993 rap_group_delete,
994 NET_TRANSPORT_RAP,
995 N_("Delete specified group"),
996 N_("net rap group delete\n"
997 " Delete specified group")
998 },
999 {NULL, NULL, 0, NULL, NULL}
1000 };
1001
1002 if (argc == 0) {
1003 struct cli_state *cli;
1004 int ret;
1005 if (c->display_usage) {
1006 d_printf(_("Usage:\n"));
1007 d_printf(_("net rap group\n"
1008 " List all groups\n"));
1009 net_display_usage_from_functable(func);
1010 return 0;
1011 }
1012
1013 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
1014 return -1;
1015 if (c->opt_long_list_entries) {
1016 d_printf(_("Group name Comment\n"
1017 "-----------------------------\n"));
1018 ret = cli_RNetGroupEnum(cli, long_group_fn, NULL);
1019 cli_shutdown(cli);
1020 return ret;
1021 }
1022 ret = cli_RNetGroupEnum0(cli, group_fn, NULL);
1023 cli_shutdown(cli);
1024 return ret;
1025 }
1026
1027 return net_run_function(c, argc, argv, "net rap group", func);
1028 }
1029
1030 int net_rap_groupmember_usage(struct net_context *c, int argc, const char **argv)
1031 {
1032 d_printf(_(
1033 "net rap groupmember LIST <group> [misc. options] [targets]"
1034 "\n\t Enumerate users in a group\n"
1035 "\nnet rap groupmember DELETE <group> <user> [misc. options] "
1036 "[targets]\n\t Delete specified user from specified group\n"
1037 "\nnet rap groupmember ADD <group> <user> [misc. options] [targets]"
1038 "\n\t Add specified user to specified group\n"));
1039
1040 net_common_flags_usage(c, argc, argv);
1041 return -1;
1042 }
1043
1044
1045 static int rap_groupmember_add(struct net_context *c, int argc, const char **argv)
1046 {
1047 struct cli_state *cli;
1048 int ret;
1049 if (argc != 2 || c->display_usage) {
1050 return net_rap_groupmember_usage(c, argc, argv);
1051 }
1052
1053 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
1054 return -1;
1055
1056 ret = cli_NetGroupAddUser(cli, argv[0], argv[1]);
1057 cli_shutdown(cli);
1058 return ret;
1059 }
1060
1061 static int rap_groupmember_delete(struct net_context *c, int argc, const char **argv)
1062 {
1063 struct cli_state *cli;
1064 int ret;
1065 if (argc != 2 || c->display_usage) {
1066 return net_rap_groupmember_usage(c, argc, argv);
1067 }
1068
1069 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
1070 return -1;
1071
1072 ret = cli_NetGroupDelUser(cli, argv[0], argv[1]);
1073 cli_shutdown(cli);
1074 return ret;
1075 }
1076
1077 static int rap_groupmember_list(struct net_context *c, int argc, const char **argv)
1078 {
1079 struct cli_state *cli;
1080 int ret;
1081 if (argc == 0 || c->display_usage) {
1082 return net_rap_groupmember_usage(c, argc, argv);
1083 }
1084
1085 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
1086 return -1;
1087
1088 ret = cli_NetGroupGetUsers(cli, argv[0], group_member_fn, NULL );
1089 cli_shutdown(cli);
1090 return ret;
1091 }
1092
1093 int net_rap_groupmember(struct net_context *c, int argc, const char **argv)
1094 {
1095 struct functable func[] = {
1096 {
1097 "add",
1098 rap_groupmember_add,
1099 NET_TRANSPORT_RAP,
1100 N_("Add specified user to group"),
1101 N_("net rap groupmember add\n"
1102 " Add specified user to group")
1103 },
1104 {
1105 "list",
1106 rap_groupmember_list,
1107 NET_TRANSPORT_RAP,
1108 N_("List users in group"),
1109 N_("net rap groupmember list\n"
1110 " List users in group")
1111 },
1112 {
1113 "delete",
1114 rap_groupmember_delete,
1115 NET_TRANSPORT_RAP,
1116 N_("Remove user from group"),
1117 N_("net rap groupmember delete\n"
1118 " Remove user from group")
1119 },
1120 {NULL, NULL, 0, NULL, NULL}
1121 };
1122
1123 return net_run_function(c, argc, argv, "net rap groupmember", func);
1124 }
1125
1126 int net_rap_validate_usage(struct net_context *c, int argc, const char **argv)
1127 {
1128 d_printf(_("net rap validate <username> [password]\n"
1129 "\tValidate user and password to check whether they"
1130 " can access target server or domain\n"));
1131
1132 net_common_flags_usage(c, argc, argv);
1133 return -1;
1134 }
1135
1136 int net_rap_validate(struct net_context *c, int argc, const char **argv)
1137 {
1138 return errmsg_not_implemented();
1139 }
1140
1141 int net_rap_service_usage(struct net_context *c, int argc, const char **argv)
1142 {
1143 d_printf(_("net rap service [misc. options] [targets] \n"
1144 "\tlists all running service daemons on target server\n"));
1145 d_printf(_("\nnet rap service START <name> [service startup arguments]"
1146 " [misc. options] [targets]"
1147 "\n\tStart named service on remote server\n"));
1148 d_printf(_("\nnet rap service STOP <name> [misc. options] [targets]\n"
1149 "\n\tStop named service on remote server\n"));
1150
1151 net_common_flags_usage(c, argc, argv);
1152 return -1;
1153 }
1154
1155 static int rap_service_start(struct net_context *c, int argc, const char **argv)
1156 {
1157 return errmsg_not_implemented();
1158 }
1159
1160 static int rap_service_stop(struct net_context *c, int argc, const char **argv)
1161 {
1162 return errmsg_not_implemented();
1163 }
1164
1165 static void service_fn(const char *service_name, const char *dummy,
1166 void *state)
1167 {
1168 d_printf("%-21.21s\n", service_name);
1169 }
1170
1171 int net_rap_service(struct net_context *c, int argc, const char **argv)
1172 {
1173 struct functable func[] = {
1174 {
1175 "start",
1176 rap_service_start,
1177 NET_TRANSPORT_RAP,
1178 N_("Start service on remote server"),
1179 N_("net rap service start\n"
1180 " Start service on remote server")
1181 },
1182 {
1183 "stop",
1184 rap_service_stop,
1185 NET_TRANSPORT_RAP,
1186 N_("Stop named serve on remote server"),
1187 N_("net rap service stop\n"
1188 " Stop named serve on remote server")
1189 },
1190 {NULL, NULL, 0, NULL, NULL}
1191 };
1192
1193 if (argc == 0) {
1194 struct cli_state *cli;
1195 int ret;
1196 if (c->display_usage) {
1197 d_printf(_("Usage:\n"));
1198 d_printf(_("net rap service\n"
1199 " List services on remote server\n"));
1200 net_display_usage_from_functable(func);
1201 return 0;
1202 }
1203
1204 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
1205 return -1;
1206
1207 if (c->opt_long_list_entries) {
1208 d_printf(_("Service name Comment\n"
1209 "-----------------------------\n"));
1210 ret = cli_RNetServiceEnum(cli, long_group_fn, NULL);
1211 }
1212 ret = cli_RNetServiceEnum(cli, service_fn, NULL);
1213 cli_shutdown(cli);
1214 return ret;
1215 }
1216
1217 return net_run_function(c, argc, argv, "net rap service", func);
1218 }
1219
1220 int net_rap_password_usage(struct net_context *c, int argc, const char **argv)
1221 {
1222 d_printf(_(
1223 "net rap password <user> <oldpwo> <newpw> [misc. options] [target]\n"
1224 "\tchanges the password for the specified user at target\n"));
1225
1226 return -1;
1227 }
1228
1229
1230 int net_rap_password(struct net_context *c, int argc, const char **argv)
1231 {
1232 struct cli_state *cli;
1233 int ret;
1234
1235 if (argc < 3 || c->display_usage)
1236 return net_rap_password_usage(c, argc, argv);
1237
1238 if (!NT_STATUS_IS_OK(net_make_ipc_connection(c, 0, &cli)))
1239 return -1;
1240
1241 /* BB Add check for password lengths? */
1242 ret = cli_oem_change_password(cli, argv[0], argv[2], argv[1]);
1243 cli_shutdown(cli);
1244 return ret;
1245 }
1246
1247 int net_rap_admin_usage(struct net_context *c, int argc, const char **argv)
1248 {
1249 d_printf(_(
1250 "net rap admin <remote command> [cmd args [env]] [misc. options] [targets]"
1251 "\n\texecutes a remote command on an os/2 target server\n"));
1252
1253 return -1;
1254 }
1255
1256
1257 int net_rap_admin(struct net_context *c, int argc, const char **argv)
1258 {
1259 return errmsg_not_implemented();
1260 }
1261
1262 /* Entry-point for all the RAP functions. */
1263
1264 int net_rap(struct net_context *c, int argc, const char **argv)
1265 {
1266 struct functable func[] = {
1267 {
1268 "file",
1269 net_rap_file,
1270 NET_TRANSPORT_RAP,
1271 N_("List open files"),
1272 N_("net rap file\n"
1273 " List open files")
1274 },
1275 {
1276 "share",
1277 net_rap_share,
1278 NET_TRANSPORT_RAP,
1279 N_("List shares exported by server"),
1280 N_("net rap share\n"
1281 " List shares exported by server")
1282 },
1283 {
1284 "session",
1285 net_rap_session,
1286 NET_TRANSPORT_RAP,
1287 N_("List open sessions"),
1288 N_("net rap session\n"
1289 " List open sessions")
1290 },
1291 {
1292 "server",
1293 net_rap_server,
1294 NET_TRANSPORT_RAP,
1295 N_("List servers in workgroup"),
1296 N_("net rap server\n"
1297 " List servers in domain/workgroup")
1298 },
1299 {
1300 "domain",
1301 net_rap_domain,
1302 NET_TRANSPORT_RAP,
1303 N_("List domains in network"),
1304 N_("net rap domain\n"
1305 " List domains in network")
1306 },
1307 {
1308 "printq",
1309 net_rap_printq,
1310 NET_TRANSPORT_RAP,
1311 N_("List printer queues on server"),
1312 N_("net rap printq\n"
1313 " List printer queues on server")
1314 },
1315 {
1316 "user",
1317 net_rap_user,
1318 NET_TRANSPORT_RAP,
1319 N_("List users"),
1320 N_("net rap user\n"
1321 " List users")
1322 },
1323 {
1324 "group",
1325 net_rap_group,
1326 NET_TRANSPORT_RAP,
1327 N_("List user groups"),
1328 N_("net rap group\n"
1329 " List user groups")
1330 },
1331 {
1332 "validate",
1333 net_rap_validate,
1334 NET_TRANSPORT_RAP,
1335 N_("Check username/password"),
1336 N_("net rap validate\n"
1337 " Check username/password")
1338 },
1339 {
1340 "groupmember",
1341 net_rap_groupmember,
1342 NET_TRANSPORT_RAP,
1343 N_("List/modify group memberships"),
1344 N_("net rap groupmember\n"
1345 " List/modify group memberships")
1346 },
1347 {
1348 "admin",
1349 net_rap_admin,
1350 NET_TRANSPORT_RAP,
1351 N_("Execute commands on remote OS/2"),
1352 N_("net rap admin\n"
1353 " Execute commands on remote OS/2")
1354 },
1355 {
1356 "service",
1357 net_rap_service,
1358 NET_TRANSPORT_RAP,
1359 N_("Start/stop remote service"),
1360 N_("net rap service\n"
1361 " Start/stop remote service")
1362 },
1363 {
1364 "password",
1365 net_rap_password,
1366 NET_TRANSPORT_RAP,
1367 N_("Change user password"),
1368 N_("net rap password\n"
1369 " Change user password")
1370 },
1371 {NULL, NULL, 0, NULL, NULL}
1372 };
1373
1374 return net_run_function(c, argc, argv, "net rap", func);
1375 }
1376
reg import