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