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