source3/utils/smbcontrol.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Send messages to other Samba daemons
   5
   6    Copyright (C) Tim Potter 2003
   7    Copyright (C) Andrew Tridgell 1994-1998
   8    Copyright (C) Martin Pool 2001-2002
   9    Copyright (C) Simo Sorce 2002
  10    Copyright (C) James Peach 2006
  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
  26 #include "includes.h"
  27 #include "system/filesys.h"
  28 #include "popt_common.h"
  29 #include "librpc/gen_ndr/spoolss.h"
  30 #include "nt_printing.h"
  31 #include "printing/notify.h"
  32 #include "libsmb/nmblib.h"
  33 #include "messages.h"
  34 #include "util_tdb.h"
  35
  36 #if HAVE_LIBUNWIND_H
  37 #include <libunwind.h>
  38 #endif
  39
  40 #if HAVE_LIBUNWIND_PTRACE_H
  41 #include <libunwind-ptrace.h>
  42 #endif
  43
  44 #if HAVE_SYS_PTRACE_H
  45 #include <sys/ptrace.h>
  46 #endif
  47
  48 /* Default timeout value when waiting for replies (in seconds) */
  49
  50 #define DEFAULT_TIMEOUT 10
  51
  52 static int timeout = DEFAULT_TIMEOUT;
  53 static int num_replies;         /* Used by message callback fns */
  54
  55 /* Send a message to a destination pid.  Zero means broadcast smbd. */
  56
  57 static bool send_message(struct messaging_context *msg_ctx,
  58                          struct server_id pid, int msg_type,
  59                          const void *buf, int len)
  60 {
  61         bool ret;
  62         int n_sent = 0;
  63
  64         if (procid_to_pid(&pid) != 0)
  65                 return NT_STATUS_IS_OK(
  66                         messaging_send_buf(msg_ctx, pid, msg_type,
  67                                            (const uint8 *)buf, len));
  68
  69         ret = message_send_all(msg_ctx, msg_type, buf, len, &n_sent);
  70         DEBUG(10,("smbcontrol/send_message: broadcast message to "
  71                   "%d processes\n", n_sent));
  72
  73         return ret;
  74 }
  75
  76 static void smbcontrol_timeout(struct tevent_context *event_ctx,
  77                                struct tevent_timer *te,
  78                                struct timeval now,
  79                                void *private_data)
  80 {
  81         bool *timed_out = (bool *)private_data;
  82         TALLOC_FREE(te);
  83         *timed_out = True;
  84 }
  85
  86 /* Wait for one or more reply messages */
  87
  88 static void wait_replies(struct tevent_context *ev_ctx,
  89                          struct messaging_context *msg_ctx,
  90                          bool multiple_replies)
  91 {
  92         struct tevent_timer *te;
  93         bool timed_out = False;
  94
  95         if (!(te = tevent_add_timer(ev_ctx, NULL,
  96                                     timeval_current_ofs(timeout, 0),
  97                                     smbcontrol_timeout, (void *)&timed_out))) {
  98                 DEBUG(0, ("tevent_add_timer failed\n"));
  99                 return;
 100         }
 101
 102         while (!timed_out) {
 103                 int ret;
 104                 if (num_replies > 0 && !multiple_replies)
 105                         break;
 106                 ret = tevent_loop_once(ev_ctx);
 107                 if (ret != 0) {
 108                         break;
 109                 }
 110         }
 111 }
 112
 113 /* Message handler callback that displays the PID and a string on stdout */
 114
 115 static void print_pid_string_cb(struct messaging_context *msg,
 116                                 void *private_data,
 117                                 uint32_t msg_type,
 118                                 struct server_id pid,
 119                                 DATA_BLOB *data)
 120 {
 121         char *pidstr;
 122
 123         pidstr = server_id_str(talloc_tos(), &pid);
 124         printf("PID %s: %.*s", pidstr, (int)data->length,
 125                (const char *)data->data);
 126         TALLOC_FREE(pidstr);
 127         num_replies++;
 128 }
 129
 130 /* Message handler callback that displays a string on stdout */
 131
 132 static void print_string_cb(struct messaging_context *msg,
 133                             void *private_data,
 134                             uint32_t msg_type,
 135                             struct server_id pid,
 136                             DATA_BLOB *data)
 137 {
 138         printf("%*s", (int)data->length, (const char *)data->data);
 139         num_replies++;
 140 }
 141
 142 /* Send no message.  Useful for testing. */
 143
 144 static bool do_noop(struct tevent_context *ev_ctx,
 145                     struct messaging_context *msg_ctx,
 146                     const struct server_id pid,
 147                     const int argc, const char **argv)
 148 {
 149         if (argc != 1) {
 150                 fprintf(stderr, "Usage: smbcontrol <dest> noop\n");
 151                 return False;
 152         }
 153
 154         /* Move along, nothing to see here */
 155
 156         return True;
 157 }
 158
 159 /* Send a debug string */
 160
 161 static bool do_debug(struct tevent_context *ev_ctx,
 162                      struct messaging_context *msg_ctx,
 163                      const struct server_id pid,
 164                      const int argc, const char **argv)
 165 {
 166         if (argc != 2) {
 167                 fprintf(stderr, "Usage: smbcontrol <dest> debug "
 168                         "<debug-string>\n");
 169                 return False;
 170         }
 171
 172         return send_message(msg_ctx, pid, MSG_DEBUG, argv[1],
 173                             strlen(argv[1]) + 1);
 174 }
 175
 176
 177 static bool do_idmap(struct tevent_context *ev,
 178                      struct messaging_context *msg_ctx,
 179                      const struct server_id pid,
 180                      const int argc, const char **argv)
 181 {
 182         static const char* usage = "Usage: "
 183                 "smbcontrol <dest> idmap <cmd> [arg]\n"
 184                 "\tcmd:"
 185                 "\tdelete \"UID <uid>\"|\"GID <gid>\"|<sid>\n"
 186                 "\t\tkill \"UID <uid>\"|\"GID <gid>\"|<sid>\n";
 187         const char* arg = NULL;
 188         int arglen = 0;
 189         int msg_type;
 190
 191         switch (argc) {
 192         case 2:
 193                 break;
 194         case 3:
 195                 arg = argv[2];
 196                 arglen = strlen(arg) + 1;
 197                 break;
 198         default:
 199                 fprintf(stderr, "%s", usage);
 200                 return false;
 201         }
 202
 203         if (strcmp(argv[1], "delete") == 0) {
 204                 msg_type = ID_CACHE_DELETE;
 205         }
 206         else if (strcmp(argv[1], "kill") == 0) {
 207                 msg_type = ID_CACHE_KILL;
 208         }
 209         else if (strcmp(argv[1], "help") == 0) {
 210                 fprintf(stdout, "%s", usage);
 211                 return true;
 212         }
 213         else {
 214                 fprintf(stderr, "%s", usage);
 215                 return false;
 216         }
 217
 218         return send_message(msg_ctx, pid, msg_type, arg, arglen);
 219 }
 220
 221
 222 #if defined(HAVE_LIBUNWIND_PTRACE) && defined(HAVE_LINUX_PTRACE)
 223
 224 /* Return the name of a process given it's PID. This will only work on Linux,
 225  * but that's probably moot since this whole stack tracing implementatino is
 226  * Linux-specific anyway.
 227  */
 228 static const char * procname(pid_t pid, char * buf, size_t bufsz)
 229 {
 230         char path[64];
 231         FILE * fp;
 232
 233         snprintf(path, sizeof(path), "/proc/%llu/cmdline",
 234                 (unsigned long long)pid);
 235         if ((fp = fopen(path, "r")) == NULL) {
 236                 return NULL;
 237         }
 238
 239         fgets(buf, bufsz, fp);
 240
 241         fclose(fp);
 242         return buf;
 243 }
 244
 245 static void print_stack_trace(pid_t pid, int * count)
 246 {
 247         void *              pinfo = NULL;
 248         unw_addr_space_t    aspace = NULL;
 249         unw_cursor_t        cursor;
 250         unw_word_t          ip, sp;
 251
 252         char                nbuf[256];
 253         unw_word_t          off;
 254
 255         int ret;
 256
 257         if (ptrace(PTRACE_ATTACH, pid, NULL, NULL) < 0) {
 258                 fprintf(stderr,
 259                         "Failed to attach to process %llu: %s\n",
 260                         (unsigned long long)pid, strerror(errno));
 261                 return;
 262         }
 263
 264         /* Wait until the attach is complete. */
 265         waitpid(pid, NULL, 0);
 266
 267         if (((pinfo = _UPT_create(pid)) == NULL) ||
 268             ((aspace = unw_create_addr_space(&_UPT_accessors, 0)) == NULL)) {
 269                 /* Probably out of memory. */
 270                 fprintf(stderr,
 271                         "Unable to initialize stack unwind for process %llu\n",
 272                         (unsigned long long)pid);
 273                 goto cleanup;
 274         }
 275
 276         if ((ret = unw_init_remote(&cursor, aspace, pinfo))) {
 277                 fprintf(stderr,
 278                         "Unable to unwind stack for process %llu: %s\n",
 279                         (unsigned long long)pid, unw_strerror(ret));
 280                 goto cleanup;
 281         }
 282
 283         if (*count > 0) {
 284                 printf("\n");
 285         }
 286
 287         if (procname(pid, nbuf, sizeof(nbuf))) {
 288                 printf("Stack trace for process %llu (%s):\n",
 289                         (unsigned long long)pid, nbuf);
 290         } else {
 291                 printf("Stack trace for process %llu:\n",
 292                         (unsigned long long)pid);
 293         }
 294
 295         while (unw_step(&cursor) > 0) {
 296                 ip = sp = off = 0;
 297                 unw_get_reg(&cursor, UNW_REG_IP, &ip);
 298                 unw_get_reg(&cursor, UNW_REG_SP, &sp);
 299
 300                 ret = unw_get_proc_name(&cursor, nbuf, sizeof(nbuf), &off);
 301                 if (ret != 0 && ret != -UNW_ENOMEM) {
 302                         snprintf(nbuf, sizeof(nbuf), "<unknown symbol>");
 303                 }
 304                 printf("    %s + %#llx [ip=%#llx] [sp=%#llx]\n",
 305                         nbuf, (long long)off, (long long)ip,
 306                         (long long)sp);
 307         }
 308
 309         (*count)++;
 310
 311 cleanup:
 312         if (aspace) {
 313                 unw_destroy_addr_space(aspace);
 314         }
 315
 316         if (pinfo) {
 317                 _UPT_destroy(pinfo);
 318         }
 319
 320         ptrace(PTRACE_DETACH, pid, NULL, NULL);
 321 }
 322
 323 static int stack_trace_connection(const struct connections_key *key,
 324                                   const struct connections_data *crec,
 325                                   void *priv)
 326 {
 327         print_stack_trace(procid_to_pid(&crec->pid), (int *)priv);
 328
 329         return 0;
 330 }
 331
 332 static bool do_daemon_stack_trace(struct tevent_context *ev_ctx,
 333                                   struct messaging_context *msg_ctx,
 334                                   const struct server_id pid,
 335                                   const int argc, const char **argv)
 336 {
 337         pid_t   dest;
 338         int     count = 0;
 339
 340         if (argc != 1) {
 341                 fprintf(stderr, "Usage: smbcontrol <dest> stacktrace\n");
 342                 return False;
 343         }
 344
 345         dest = procid_to_pid(&pid);
 346
 347         if (dest != 0) {
 348                 /* It would be nice to be able to make sure that this PID is
 349                  * the PID of a smbd/winbind/nmbd process, not some random PID
 350                  * the user liked the look of. It doesn't seem like it's worth
 351                  * the effort at the moment, however.
 352                  */
 353                 print_stack_trace(dest, &count);
 354         } else {
 355                 connections_forall_read(stack_trace_connection, &count);
 356         }
 357
 358         return True;
 359 }
 360
 361 #else /* defined(HAVE_LIBUNWIND_PTRACE) && defined(HAVE_LINUX_PTRACE) */
 362
 363 static bool do_daemon_stack_trace(struct tevent_context *ev_ctx,
 364                                   struct messaging_context *msg_ctx,
 365                                   const struct server_id pid,
 366                                   const int argc, const char **argv)
 367 {
 368         fprintf(stderr,
 369                 "Daemon stack tracing is not supported on this platform\n");
 370         return False;
 371 }
 372
 373 #endif /* defined(HAVE_LIBUNWIND_PTRACE) && defined(HAVE_LINUX_PTRACE) */
 374
 375 /* Inject a fault (fatal signal) into a running smbd */
 376
 377 static bool do_inject_fault(struct tevent_context *ev_ctx,
 378                             struct messaging_context *msg_ctx,
 379                             const struct server_id pid,
 380                             const int argc, const char **argv)
 381 {
 382         if (argc != 2) {
 383                 fprintf(stderr, "Usage: smbcontrol <dest> inject "
 384                         "<bus|hup|term|internal|segv>\n");
 385                 return False;
 386         }
 387
 388 #ifndef DEVELOPER
 389         fprintf(stderr, "Fault injection is only available in "
 390                 "developer builds\n");
 391         return False;
 392 #else /* DEVELOPER */
 393         {
 394                 int sig = 0;
 395
 396                 if (strcmp(argv[1], "bus") == 0) {
 397                         sig = SIGBUS;
 398                 } else if (strcmp(argv[1], "hup") == 0) {
 399                         sig = SIGHUP;
 400                 } else if (strcmp(argv[1], "term") == 0) {
 401                         sig = SIGTERM;
 402                 } else if (strcmp(argv[1], "segv") == 0) {
 403                         sig = SIGSEGV;
 404                 } else if (strcmp(argv[1], "internal") == 0) {
 405                         /* Force an internal error, ie. an unclean exit. */
 406                         sig = -1;
 407                 } else {
 408                         fprintf(stderr, "Unknown signal name '%s'\n", argv[1]);
 409                         return False;
 410                 }
 411
 412                 return send_message(msg_ctx, pid, MSG_SMB_INJECT_FAULT,
 413                                     &sig, sizeof(int));
 414         }
 415 #endif /* DEVELOPER */
 416 }
 417
 418 /* Force a browser election */
 419
 420 static bool do_election(struct tevent_context *ev_ctx,
 421                         struct messaging_context *msg_ctx,
 422                         const struct server_id pid,
 423                         const int argc, const char **argv)
 424 {
 425         if (argc != 1) {
 426                 fprintf(stderr, "Usage: smbcontrol <dest> force-election\n");
 427                 return False;
 428         }
 429
 430         return send_message(msg_ctx, pid, MSG_FORCE_ELECTION, NULL, 0);
 431 }
 432
 433 /* Ping a samba daemon process */
 434
 435 static void pong_cb(struct messaging_context *msg,
 436                     void *private_data,
 437                     uint32_t msg_type,
 438                     struct server_id pid,
 439                     DATA_BLOB *data)
 440 {
 441         char *src_string = server_id_str(NULL, &pid);
 442         printf("PONG from pid %s\n", src_string);
 443         TALLOC_FREE(src_string);
 444         num_replies++;
 445 }
 446
 447 static bool do_ping(struct tevent_context *ev_ctx,
 448                     struct messaging_context *msg_ctx,
 449                     const struct server_id pid,
 450                     const int argc, const char **argv)
 451 {
 452         if (argc != 1) {
 453                 fprintf(stderr, "Usage: smbcontrol <dest> ping\n");
 454                 return False;
 455         }
 456
 457         /* Send a message and register our interest in a reply */
 458
 459         if (!send_message(msg_ctx, pid, MSG_PING, NULL, 0))
 460                 return False;
 461
 462         messaging_register(msg_ctx, NULL, MSG_PONG, pong_cb);
 463
 464         wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
 465
 466         /* No replies were received within the timeout period */
 467
 468         if (num_replies == 0)
 469                 printf("No replies received\n");
 470
 471         messaging_deregister(msg_ctx, MSG_PONG, NULL);
 472
 473         return num_replies;
 474 }
 475
 476 /* Set profiling options */
 477
 478 static bool do_profile(struct tevent_context *ev_ctx,
 479                        struct messaging_context *msg_ctx,
 480                        const struct server_id pid,
 481                        const int argc, const char **argv)
 482 {
 483         int v;
 484
 485         if (argc != 2) {
 486                 fprintf(stderr, "Usage: smbcontrol <dest> profile "
 487                         "<off|count|on|flush>\n");
 488                 return False;
 489         }
 490
 491         if (strcmp(argv[1], "off") == 0) {
 492                 v = 0;
 493         } else if (strcmp(argv[1], "count") == 0) {
 494                 v = 1;
 495         } else if (strcmp(argv[1], "on") == 0) {
 496                 v = 2;
 497         } else if (strcmp(argv[1], "flush") == 0) {
 498                 v = 3;
 499         } else {
 500                 fprintf(stderr, "Unknown profile command '%s'\n", argv[1]);
 501                 return False;
 502         }
 503
 504         return send_message(msg_ctx, pid, MSG_PROFILE, &v, sizeof(int));
 505 }
 506
 507 /* Return the profiling level */
 508
 509 static void profilelevel_cb(struct messaging_context *msg_ctx,
 510                             void *private_data,
 511                             uint32_t msg_type,
 512                             struct server_id pid,
 513                             DATA_BLOB *data)
 514 {
 515         int level;
 516         const char *s;
 517
 518         num_replies++;
 519
 520         if (data->length != sizeof(int)) {
 521                 fprintf(stderr, "invalid message length %ld returned\n",
 522                         (unsigned long)data->length);
 523                 return;
 524         }
 525
 526         memcpy(&level, data->data, sizeof(int));
 527
 528         switch (level) {
 529         case 0:
 530                 s = "not enabled";
 531                 break;
 532         case 1:
 533                 s = "off";
 534                 break;
 535         case 3:
 536                 s = "count only";
 537                 break;
 538         case 7:
 539                 s = "count and time";
 540                 break;
 541         default:
 542                 s = "BOGUS";
 543                 break;
 544         }
 545
 546         printf("Profiling %s on pid %u\n",s,(unsigned int)procid_to_pid(&pid));
 547 }
 548
 549 static void profilelevel_rqst(struct messaging_context *msg_ctx,
 550                               void *private_data,
 551                               uint32_t msg_type,
 552                               struct server_id pid,
 553                               DATA_BLOB *data)
 554 {
 555         int v = 0;
 556
 557         /* Send back a dummy reply */
 558
 559         send_message(msg_ctx, pid, MSG_PROFILELEVEL, &v, sizeof(int));
 560 }
 561
 562 static bool do_profilelevel(struct tevent_context *ev_ctx,
 563                             struct messaging_context *msg_ctx,
 564                             const struct server_id pid,
 565                             const int argc, const char **argv)
 566 {
 567         if (argc != 1) {
 568                 fprintf(stderr, "Usage: smbcontrol <dest> profilelevel\n");
 569                 return False;
 570         }
 571
 572         /* Send a message and register our interest in a reply */
 573
 574         if (!send_message(msg_ctx, pid, MSG_REQ_PROFILELEVEL, NULL, 0))
 575                 return False;
 576
 577         messaging_register(msg_ctx, NULL, MSG_PROFILELEVEL, profilelevel_cb);
 578         messaging_register(msg_ctx, NULL, MSG_REQ_PROFILELEVEL,
 579                            profilelevel_rqst);
 580
 581         wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
 582
 583         /* No replies were received within the timeout period */
 584
 585         if (num_replies == 0)
 586                 printf("No replies received\n");
 587
 588         messaging_deregister(msg_ctx, MSG_PROFILE, NULL);
 589
 590         return num_replies;
 591 }
 592
 593 /* Display debug level settings */
 594
 595 static bool do_debuglevel(struct tevent_context *ev_ctx,
 596                           struct messaging_context *msg_ctx,
 597                           const struct server_id pid,
 598                           const int argc, const char **argv)
 599 {
 600         if (argc != 1) {
 601                 fprintf(stderr, "Usage: smbcontrol <dest> debuglevel\n");
 602                 return False;
 603         }
 604
 605         /* Send a message and register our interest in a reply */
 606
 607         if (!send_message(msg_ctx, pid, MSG_REQ_DEBUGLEVEL, NULL, 0))
 608                 return False;
 609
 610         messaging_register(msg_ctx, NULL, MSG_DEBUGLEVEL, print_pid_string_cb);
 611
 612         wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
 613
 614         /* No replies were received within the timeout period */
 615
 616         if (num_replies == 0)
 617                 printf("No replies received\n");
 618
 619         messaging_deregister(msg_ctx, MSG_DEBUGLEVEL, NULL);
 620
 621         return num_replies;
 622 }
 623
 624 /* Send a print notify message */
 625
 626 static bool do_printnotify(struct tevent_context *ev_ctx,
 627                            struct messaging_context *msg_ctx,
 628                            const struct server_id pid,
 629                            const int argc, const char **argv)
 630 {
 631         const char *cmd;
 632
 633         /* Check for subcommand */
 634
 635         if (argc == 1) {
 636                 fprintf(stderr, "Must specify subcommand:\n");
 637                 fprintf(stderr, "\tqueuepause <printername>\n");
 638                 fprintf(stderr, "\tqueueresume <printername>\n");
 639                 fprintf(stderr, "\tjobpause <printername> <unix jobid>\n");
 640                 fprintf(stderr, "\tjobresume <printername> <unix jobid>\n");
 641                 fprintf(stderr, "\tjobdelete <printername> <unix jobid>\n");
 642                 fprintf(stderr, "\tprinter <printername> <comment|port|"
 643                         "driver> <value>\n");
 644
 645                 return False;
 646         }
 647
 648         cmd = argv[1];
 649
 650         if (strcmp(cmd, "queuepause") == 0) {
 651
 652                 if (argc != 3) {
 653                         fprintf(stderr, "Usage: smbcontrol <dest> printnotify"
 654                                 " queuepause <printername>\n");
 655                         return False;
 656                 }
 657
 658                 notify_printer_status_byname(ev_ctx, msg_ctx, argv[2],
 659                                              PRINTER_STATUS_PAUSED);
 660
 661                 goto send;
 662
 663         } else if (strcmp(cmd, "queueresume") == 0) {
 664
 665                 if (argc != 3) {
 666                         fprintf(stderr, "Usage: smbcontrol <dest> printnotify"
 667                                 " queuereume <printername>\n");
 668                         return False;
 669                 }
 670
 671                 notify_printer_status_byname(ev_ctx, msg_ctx, argv[2],
 672                                              PRINTER_STATUS_OK);
 673
 674                 goto send;
 675
 676         } else if (strcmp(cmd, "jobpause") == 0) {
 677                 int jobid;
 678
 679                 if (argc != 4) {
 680                         fprintf(stderr, "Usage: smbcontrol <dest> printnotify"
 681                                 " jobpause <printername> <unix-jobid>\n");
 682                         return False;
 683                 }
 684
 685                 jobid = atoi(argv[3]);
 686
 687                 notify_job_status_byname(
 688                         ev_ctx, msg_ctx,
 689                         argv[2], jobid, JOB_STATUS_PAUSED,
 690                         SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
 691
 692                 goto send;
 693
 694         } else if (strcmp(cmd, "jobresume") == 0) {
 695                 int jobid;
 696
 697                 if (argc != 4) {
 698                         fprintf(stderr, "Usage: smbcontrol <dest> printnotify"
 699                                 " jobpause <printername> <unix-jobid>\n");
 700                         return False;
 701                 }
 702
 703                 jobid = atoi(argv[3]);
 704
 705                 notify_job_status_byname(
 706                         ev_ctx, msg_ctx,
 707                         argv[2], jobid, JOB_STATUS_QUEUED,
 708                         SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
 709
 710                 goto send;
 711
 712         } else if (strcmp(cmd, "jobdelete") == 0) {
 713                 int jobid;
 714
 715                 if (argc != 4) {
 716                         fprintf(stderr, "Usage: smbcontrol <dest> printnotify"
 717                                 " jobpause <printername> <unix-jobid>\n");
 718                         return False;
 719                 }
 720
 721                 jobid = atoi(argv[3]);
 722
 723                 notify_job_status_byname(
 724                         ev_ctx, msg_ctx,
 725                         argv[2], jobid, JOB_STATUS_DELETING,
 726                         SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
 727
 728                 notify_job_status_byname(
 729                         ev_ctx, msg_ctx,
 730                         argv[2], jobid, JOB_STATUS_DELETING|
 731                         JOB_STATUS_DELETED,
 732                         SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
 733
 734                 goto send;
 735
 736         } else if (strcmp(cmd, "printer") == 0) {
 737                 uint32 attribute;
 738
 739                 if (argc != 5) {
 740                         fprintf(stderr, "Usage: smbcontrol <dest> printnotify "
 741                                 "printer <printername> <comment|port|driver> "
 742                                 "<value>\n");
 743                         return False;
 744                 }
 745
 746                 if (strcmp(argv[3], "comment") == 0) {
 747                         attribute = PRINTER_NOTIFY_FIELD_COMMENT;
 748                 } else if (strcmp(argv[3], "port") == 0) {
 749                         attribute = PRINTER_NOTIFY_FIELD_PORT_NAME;
 750                 } else if (strcmp(argv[3], "driver") == 0) {
 751                         attribute = PRINTER_NOTIFY_FIELD_DRIVER_NAME;
 752                 } else {
 753                         fprintf(stderr, "Invalid printer command '%s'\n",
 754                                 argv[3]);
 755                         return False;
 756                 }
 757
 758                 notify_printer_byname(ev_ctx, msg_ctx, argv[2], attribute,
 759                                       discard_const_p(char, argv[4]));
 760
 761                 goto send;
 762         }
 763
 764         fprintf(stderr, "Invalid subcommand '%s'\n", cmd);
 765         return False;
 766
 767 send:
 768         print_notify_send_messages(msg_ctx, 0);
 769         return True;
 770 }
 771
 772 /* Close a share */
 773
 774 static bool do_closeshare(struct tevent_context *ev_ctx,
 775                           struct messaging_context *msg_ctx,
 776                           const struct server_id pid,
 777                           const int argc, const char **argv)
 778 {
 779         if (argc != 2) {
 780                 fprintf(stderr, "Usage: smbcontrol <dest> close-share "
 781                         "<sharename>\n");
 782                 return False;
 783         }
 784
 785         return send_message(msg_ctx, pid, MSG_SMB_FORCE_TDIS, argv[1],
 786                             strlen(argv[1]) + 1);
 787 }
 788
 789 /* Tell winbindd an IP got dropped */
 790
 791 static bool do_ip_dropped(struct tevent_context *ev_ctx,
 792                           struct messaging_context *msg_ctx,
 793                           const struct server_id pid,
 794                           const int argc, const char **argv)
 795 {
 796         if (argc != 2) {
 797                 fprintf(stderr, "Usage: smbcontrol <dest> ip-dropped "
 798                         "<ip-address>\n");
 799                 return False;
 800         }
 801
 802         return send_message(msg_ctx, pid, MSG_WINBIND_IP_DROPPED, argv[1],
 803                             strlen(argv[1]) + 1);
 804 }
 805
 806 /* force a blocking lock retry */
 807
 808 static bool do_lockretry(struct tevent_context *ev_ctx,
 809                          struct messaging_context *msg_ctx,
 810                          const struct server_id pid,
 811                          const int argc, const char **argv)
 812 {
 813         if (argc != 1) {
 814                 fprintf(stderr, "Usage: smbcontrol <dest> lockretry\n");
 815                 return False;
 816         }
 817
 818         return send_message(msg_ctx, pid, MSG_SMB_UNLOCK, NULL, 0);
 819 }
 820
 821 /* force a validation of all brl entries, including re-sends. */
 822
 823 static bool do_brl_revalidate(struct tevent_context *ev_ctx,
 824                               struct messaging_context *msg_ctx,
 825                               const struct server_id pid,
 826                               const int argc, const char **argv)
 827 {
 828         if (argc != 1) {
 829                 fprintf(stderr, "Usage: smbcontrol <dest> brl-revalidate\n");
 830                 return False;
 831         }
 832
 833         return send_message(msg_ctx, pid, MSG_SMB_BRL_VALIDATE, NULL, 0);
 834 }
 835
 836 /* Display talloc pool usage */
 837
 838 static bool do_poolusage(struct tevent_context *ev_ctx,
 839                          struct messaging_context *msg_ctx,
 840                          const struct server_id pid,
 841                          const int argc, const char **argv)
 842 {
 843         if (argc != 1) {
 844                 fprintf(stderr, "Usage: smbcontrol <dest> pool-usage\n");
 845                 return False;
 846         }
 847
 848         messaging_register(msg_ctx, NULL, MSG_POOL_USAGE, print_string_cb);
 849
 850         /* Send a message and register our interest in a reply */
 851
 852         if (!send_message(msg_ctx, pid, MSG_REQ_POOL_USAGE, NULL, 0))
 853                 return False;
 854
 855         wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
 856
 857         /* No replies were received within the timeout period */
 858
 859         if (num_replies == 0)
 860                 printf("No replies received\n");
 861
 862         messaging_deregister(msg_ctx, MSG_POOL_USAGE, NULL);
 863
 864         return num_replies;
 865 }
 866
 867 /* Perform a dmalloc mark */
 868
 869 static bool do_dmalloc_mark(struct tevent_context *ev_ctx,
 870                             struct messaging_context *msg_ctx,
 871                             const struct server_id pid,
 872                             const int argc, const char **argv)
 873 {
 874         if (argc != 1) {
 875                 fprintf(stderr, "Usage: smbcontrol <dest> dmalloc-mark\n");
 876                 return False;
 877         }
 878
 879         return send_message(msg_ctx, pid, MSG_REQ_DMALLOC_MARK, NULL, 0);
 880 }
 881
 882 /* Perform a dmalloc changed */
 883
 884 static bool do_dmalloc_changed(struct tevent_context *ev_ctx,
 885                                struct messaging_context *msg_ctx,
 886                                const struct server_id pid,
 887                                const int argc, const char **argv)
 888 {
 889         if (argc != 1) {
 890                 fprintf(stderr, "Usage: smbcontrol <dest> "
 891                         "dmalloc-log-changed\n");
 892                 return False;
 893         }
 894
 895         return send_message(msg_ctx, pid, MSG_REQ_DMALLOC_LOG_CHANGED,
 896                             NULL, 0);
 897 }
 898
 899 /* Shutdown a server process */
 900
 901 static bool do_shutdown(struct tevent_context *ev_ctx,
 902                         struct messaging_context *msg_ctx,
 903                         const struct server_id pid,
 904                         const int argc, const char **argv)
 905 {
 906         if (argc != 1) {
 907                 fprintf(stderr, "Usage: smbcontrol <dest> shutdown\n");
 908                 return False;
 909         }
 910
 911         return send_message(msg_ctx, pid, MSG_SHUTDOWN, NULL, 0);
 912 }
 913
 914 /* Notify a driver upgrade */
 915
 916 static bool do_drvupgrade(struct tevent_context *ev_ctx,
 917                           struct messaging_context *msg_ctx,
 918                           const struct server_id pid,
 919                           const int argc, const char **argv)
 920 {
 921         if (argc != 2) {
 922                 fprintf(stderr, "Usage: smbcontrol <dest> drvupgrade "
 923                         "<driver-name>\n");
 924                 return False;
 925         }
 926
 927         return send_message(msg_ctx, pid, MSG_DEBUG, argv[1],
 928                             strlen(argv[1]) + 1);
 929 }
 930
 931 static bool do_winbind_online(struct tevent_context *ev_ctx,
 932                               struct messaging_context *msg_ctx,
 933                               const struct server_id pid,
 934                               const int argc, const char **argv)
 935 {
 936         TDB_CONTEXT *tdb;
 937
 938         if (argc != 1) {
 939                 fprintf(stderr, "Usage: smbcontrol winbindd online\n");
 940                 return False;
 941         }
 942
 943         /* Remove the entry in the winbindd_cache tdb to tell a later
 944            starting winbindd that we're online. */
 945
 946         tdb = tdb_open_log(state_path("winbindd_cache.tdb"), 0, TDB_DEFAULT, O_RDWR, 0600);
 947         if (!tdb) {
 948                 fprintf(stderr, "Cannot open the tdb %s for writing.\n",
 949                         state_path("winbindd_cache.tdb"));
 950                 return False;
 951         }
 952
 953         tdb_delete_bystring(tdb, "WINBINDD_OFFLINE");
 954         tdb_close(tdb);
 955
 956         return send_message(msg_ctx, pid, MSG_WINBIND_ONLINE, NULL, 0);
 957 }
 958
 959 static bool do_winbind_offline(struct tevent_context *ev_ctx,
 960                                struct messaging_context *msg_ctx,
 961                                const struct server_id pid,
 962                                const int argc, const char **argv)
 963 {
 964         TDB_CONTEXT *tdb;
 965         bool ret = False;
 966         int retry = 0;
 967
 968         if (argc != 1) {
 969                 fprintf(stderr, "Usage: smbcontrol winbindd offline\n");
 970                 return False;
 971         }
 972
 973         /* Create an entry in the winbindd_cache tdb to tell a later
 974            starting winbindd that we're offline. We may actually create
 975            it here... */
 976
 977         tdb = tdb_open_log(state_path("winbindd_cache.tdb"),
 978                                 WINBINDD_CACHE_TDB_DEFAULT_HASH_SIZE,
 979                                 TDB_DEFAULT|TDB_INCOMPATIBLE_HASH /* TDB_CLEAR_IF_FIRST */,
 980                                 O_RDWR|O_CREAT, 0600);
 981
 982         if (!tdb) {
 983                 fprintf(stderr, "Cannot open the tdb %s for writing.\n",
 984                         state_path("winbindd_cache.tdb"));
 985                 return False;
 986         }
 987
 988         /* There's a potential race condition that if a child
 989            winbindd detects a domain is online at the same time
 990            we're trying to tell it to go offline that it might
 991            delete the record we add between us adding it and
 992            sending the message. Minimize this by retrying up to
 993            5 times. */
 994
 995         for (retry = 0; retry < 5; retry++) {
 996                 TDB_DATA d;
 997                 uint8 buf[4];
 998
 999                 ZERO_STRUCT(d);
1000
1001                 SIVAL(buf, 0, time(NULL));
1002                 d.dptr = buf;
1003                 d.dsize = 4;
1004
1005                 tdb_store_bystring(tdb, "WINBINDD_OFFLINE", d, TDB_INSERT);
1006
1007                 ret = send_message(msg_ctx, pid, MSG_WINBIND_OFFLINE,
1008                                    NULL, 0);
1009
1010                 /* Check that the entry "WINBINDD_OFFLINE" still exists. */
1011                 d = tdb_fetch_bystring( tdb, "WINBINDD_OFFLINE" );
1012
1013                 if (!d.dptr || d.dsize != 4) {
1014                         SAFE_FREE(d.dptr);
1015                         DEBUG(10,("do_winbind_offline: offline state not set - retrying.\n"));
1016                 } else {
1017                         SAFE_FREE(d.dptr);
1018                         break;
1019                 }
1020         }
1021
1022         tdb_close(tdb);
1023         return ret;
1024 }
1025
1026 static bool do_winbind_onlinestatus(struct tevent_context *ev_ctx,
1027                                     struct messaging_context *msg_ctx,
1028                                     const struct server_id pid,
1029                                     const int argc, const char **argv)
1030 {
1031         struct server_id myid;
1032
1033         myid = messaging_server_id(msg_ctx);
1034
1035         if (argc != 1) {
1036                 fprintf(stderr, "Usage: smbcontrol winbindd onlinestatus\n");
1037                 return False;
1038         }
1039
1040         messaging_register(msg_ctx, NULL, MSG_WINBIND_ONLINESTATUS,
1041                            print_pid_string_cb);
1042
1043         if (!send_message(msg_ctx, pid, MSG_WINBIND_ONLINESTATUS, &myid,
1044                           sizeof(myid)))
1045                 return False;
1046
1047         wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
1048
1049         /* No replies were received within the timeout period */
1050
1051         if (num_replies == 0)
1052                 printf("No replies received\n");
1053
1054         messaging_deregister(msg_ctx, MSG_WINBIND_ONLINESTATUS, NULL);
1055
1056         return num_replies;
1057 }
1058
1059 static bool do_dump_event_list(struct tevent_context *ev_ctx,
1060                                struct messaging_context *msg_ctx,
1061                                const struct server_id pid,
1062                                const int argc, const char **argv)
1063 {
1064         if (argc != 1) {
1065                 fprintf(stderr, "Usage: smbcontrol <dest> dump-event-list\n");
1066                 return False;
1067         }
1068
1069         return send_message(msg_ctx, pid, MSG_DUMP_EVENT_LIST, NULL, 0);
1070 }
1071
1072 static bool do_winbind_dump_domain_list(struct tevent_context *ev_ctx,
1073                                         struct messaging_context *msg_ctx,
1074                                         const struct server_id pid,
1075                                         const int argc, const char **argv)
1076 {
1077         const char *domain = NULL;
1078         int domain_len = 0;
1079         struct server_id myid;
1080         uint8_t *buf = NULL;
1081         int buf_len = 0;
1082
1083         myid = messaging_server_id(msg_ctx);
1084
1085         if (argc < 1 || argc > 2) {
1086                 fprintf(stderr, "Usage: smbcontrol <dest> dump-domain-list "
1087                         "<domain>\n");
1088                 return false;
1089         }
1090
1091         if (argc == 2) {
1092                 domain = argv[1];
1093                 domain_len = strlen(argv[1]) + 1;
1094         }
1095
1096         messaging_register(msg_ctx, NULL, MSG_WINBIND_DUMP_DOMAIN_LIST,
1097                            print_pid_string_cb);
1098
1099         buf_len = sizeof(myid)+domain_len;
1100         buf = SMB_MALLOC_ARRAY(uint8_t, buf_len);
1101         if (!buf) {
1102                 return false;
1103         }
1104
1105         memcpy(buf, &myid, sizeof(myid));
1106         memcpy(&buf[sizeof(myid)], domain, domain_len);
1107
1108         if (!send_message(msg_ctx, pid, MSG_WINBIND_DUMP_DOMAIN_LIST,
1109                           buf, buf_len))
1110         {
1111                 SAFE_FREE(buf);
1112                 return false;
1113         }
1114
1115         wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
1116
1117         /* No replies were received within the timeout period */
1118
1119         SAFE_FREE(buf);
1120         if (num_replies == 0) {
1121                 printf("No replies received\n");
1122         }
1123
1124         messaging_deregister(msg_ctx, MSG_WINBIND_DUMP_DOMAIN_LIST, NULL);
1125
1126         return num_replies;
1127 }
1128
1129 static void winbind_validate_cache_cb(struct messaging_context *msg,
1130                                       void *private_data,
1131                                       uint32_t msg_type,
1132                                       struct server_id pid,
1133                                       DATA_BLOB *data)
1134 {
1135         char *src_string = server_id_str(NULL, &pid);
1136         printf("Winbindd cache is %svalid. (answer from pid %s)\n",
1137                (*(data->data) == 0 ? "" : "NOT "), src_string);
1138         TALLOC_FREE(src_string);
1139         num_replies++;
1140 }
1141
1142 static bool do_winbind_validate_cache(struct tevent_context *ev_ctx,
1143                                       struct messaging_context *msg_ctx,
1144                                       const struct server_id pid,
1145                                       const int argc, const char **argv)
1146 {
1147         struct server_id myid;
1148
1149         myid = messaging_server_id(msg_ctx);
1150
1151         if (argc != 1) {
1152                 fprintf(stderr, "Usage: smbcontrol winbindd validate-cache\n");
1153                 return False;
1154         }
1155
1156         messaging_register(msg_ctx, NULL, MSG_WINBIND_VALIDATE_CACHE,
1157                            winbind_validate_cache_cb);
1158
1159         if (!send_message(msg_ctx, pid, MSG_WINBIND_VALIDATE_CACHE, &myid,
1160                           sizeof(myid))) {
1161                 return False;
1162         }
1163
1164         wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
1165
1166         if (num_replies == 0) {
1167                 printf("No replies received\n");
1168         }
1169
1170         messaging_deregister(msg_ctx, MSG_WINBIND_VALIDATE_CACHE, NULL);
1171
1172         return num_replies;
1173 }
1174
1175 static bool do_reload_config(struct tevent_context *ev_ctx,
1176                              struct messaging_context *msg_ctx,
1177                              const struct server_id pid,
1178                              const int argc, const char **argv)
1179 {
1180         if (argc != 1) {
1181                 fprintf(stderr, "Usage: smbcontrol <dest> reload-config\n");
1182                 return False;
1183         }
1184
1185         return send_message(msg_ctx, pid, MSG_SMB_CONF_UPDATED, NULL, 0);
1186 }
1187
1188 static bool do_reload_printers(struct tevent_context *ev_ctx,
1189                                struct messaging_context *msg_ctx,
1190                                const struct server_id pid,
1191                                const int argc, const char **argv)
1192 {
1193         if (argc != 1) {
1194                 fprintf(stderr, "Usage: smbcontrol <dest> reload-printers\n");
1195                 return False;
1196         }
1197
1198         return send_message(msg_ctx, pid, MSG_PRINTER_PCAP, NULL, 0);
1199 }
1200
1201 static void my_make_nmb_name( struct nmb_name *n, const char *name, int type)
1202 {
1203         fstring unix_name;
1204         memset( (char *)n, '\0', sizeof(struct nmb_name) );
1205         fstrcpy(unix_name, name);
1206         strupper_m(unix_name);
1207         push_ascii(n->name, unix_name, sizeof(n->name), STR_TERMINATE);
1208         n->name_type = (unsigned int)type & 0xFF;
1209         push_ascii(n->scope,  lp_netbios_scope(), 64, STR_TERMINATE);
1210 }
1211
1212 static bool do_nodestatus(struct tevent_context *ev_ctx,
1213                           struct messaging_context *msg_ctx,
1214                           const struct server_id pid,
1215                           const int argc, const char **argv)
1216 {
1217         struct packet_struct p;
1218
1219         if (argc != 2) {
1220                 fprintf(stderr, "Usage: smbcontrol nmbd nodestatus <ip>\n");
1221                 return False;
1222         }
1223
1224         ZERO_STRUCT(p);
1225
1226         p.ip = interpret_addr2(argv[1]);
1227         p.port = 137;
1228         p.packet_type = NMB_PACKET;
1229
1230         p.packet.nmb.header.name_trn_id = 10;
1231         p.packet.nmb.header.opcode = 0;
1232         p.packet.nmb.header.response = False;
1233         p.packet.nmb.header.nm_flags.bcast = False;
1234         p.packet.nmb.header.nm_flags.recursion_available = False;
1235         p.packet.nmb.header.nm_flags.recursion_desired = False;
1236         p.packet.nmb.header.nm_flags.trunc = False;
1237         p.packet.nmb.header.nm_flags.authoritative = False;
1238         p.packet.nmb.header.rcode = 0;
1239         p.packet.nmb.header.qdcount = 1;
1240         p.packet.nmb.header.ancount = 0;
1241         p.packet.nmb.header.nscount = 0;
1242         p.packet.nmb.header.arcount = 0;
1243         my_make_nmb_name(&p.packet.nmb.question.question_name, "*", 0x00);
1244         p.packet.nmb.question.question_type = 0x21;
1245         p.packet.nmb.question.question_class = 0x1;
1246
1247         return send_message(msg_ctx, pid, MSG_SEND_PACKET, &p, sizeof(p));
1248 }
1249
1250 static bool do_notify_cleanup(struct tevent_context *ev_ctx,
1251                               struct messaging_context *msg_ctx,
1252                               const struct server_id pid,
1253                               const int argc, const char **argv)
1254 {
1255         if (argc != 1) {
1256                 fprintf(stderr, "Usage: smbcontrol smbd notify-cleanup\n");
1257                 return false;
1258         }
1259         return send_message(msg_ctx, pid, MSG_SMB_NOTIFY_CLEANUP, NULL, 0);
1260 }
1261
1262 /* A list of message type supported */
1263
1264 static const struct {
1265         const char *name;       /* Option name */
1266         bool (*fn)(struct tevent_context *ev_ctx,
1267                    struct messaging_context *msg_ctx,
1268                    const struct server_id pid,
1269                    const int argc, const char **argv);
1270         const char *help;       /* Short help text */
1271 } msg_types[] = {
1272         { "debug", do_debug, "Set debuglevel"  },
1273         { "idmap", do_idmap, "Manipulate idmap cache" },
1274         { "force-election", do_election,
1275           "Force a browse election" },
1276         { "ping", do_ping, "Elicit a response" },
1277         { "profile", do_profile, "" },
1278         { "inject", do_inject_fault,
1279             "Inject a fatal signal into a running smbd"},
1280         { "stacktrace", do_daemon_stack_trace,
1281             "Display a stack trace of a daemon" },
1282         { "profilelevel", do_profilelevel, "" },
1283         { "debuglevel", do_debuglevel, "Display current debuglevels" },
1284         { "printnotify", do_printnotify, "Send a print notify message" },
1285         { "close-share", do_closeshare, "Forcibly disconnect a share" },
1286         { "ip-dropped", do_ip_dropped, "Tell winbind that an IP got dropped" },
1287         { "lockretry", do_lockretry, "Force a blocking lock retry" },
1288         { "brl-revalidate", do_brl_revalidate, "Revalidate all brl entries" },
1289         { "pool-usage", do_poolusage, "Display talloc memory usage" },
1290         { "dmalloc-mark", do_dmalloc_mark, "" },
1291         { "dmalloc-log-changed", do_dmalloc_changed, "" },
1292         { "shutdown", do_shutdown, "Shut down daemon" },
1293         { "drvupgrade", do_drvupgrade, "Notify a printer driver has changed" },
1294         { "reload-config", do_reload_config, "Force smbd or winbindd to reload config file"},
1295         { "reload-printers", do_reload_printers, "Force smbd to reload printers"},
1296         { "nodestatus", do_nodestatus, "Ask nmbd to do a node status request"},
1297         { "online", do_winbind_online, "Ask winbind to go into online state"},
1298         { "offline", do_winbind_offline, "Ask winbind to go into offline state"},
1299         { "onlinestatus", do_winbind_onlinestatus, "Request winbind online status"},
1300         { "dump-event-list", do_dump_event_list, "Dump event list"},
1301         { "validate-cache" , do_winbind_validate_cache,
1302           "Validate winbind's credential cache" },
1303         { "dump-domain-list", do_winbind_dump_domain_list, "Dump winbind domain list"},
1304         { "notify-cleanup", do_notify_cleanup },
1305         { "noop", do_noop, "Do nothing" },
1306         { NULL }
1307 };
1308
1309 /* Display usage information */
1310
1311 static void usage(poptContext pc)
1312 {
1313         int i;
1314
1315         poptPrintHelp(pc, stderr, 0);
1316
1317         fprintf(stderr, "\n");
1318         fprintf(stderr, "<destination> is one of \"nmbd\", \"smbd\", \"winbindd\" or a "
1319                 "process ID\n");
1320
1321         fprintf(stderr, "\n");
1322         fprintf(stderr, "<message-type> is one of:\n");
1323
1324         for (i = 0; msg_types[i].name; i++)
1325             fprintf(stderr, "\t%-30s%s\n", msg_types[i].name,
1326                     msg_types[i].help);
1327
1328         fprintf(stderr, "\n");
1329
1330         exit(1);
1331 }
1332
1333 /* Return the pid number for a string destination */
1334
1335 static struct server_id parse_dest(struct messaging_context *msg,
1336                                    const char *dest)
1337 {
1338         struct server_id result = {-1};
1339         pid_t pid;
1340
1341         /* Zero is a special return value for broadcast to all processes */
1342
1343         if (strequal(dest, "all")) {
1344                 return interpret_pid(MSG_BROADCAST_PID_STR);
1345         }
1346
1347         /* Try self - useful for testing */
1348
1349         if (strequal(dest, "self")) {
1350                 return messaging_server_id(msg);
1351         }
1352
1353         /* Fix winbind typo. */
1354         if (strequal(dest, "winbind")) {
1355                 dest = "winbindd";
1356         }
1357
1358         /* Check for numeric pid number */
1359         result = interpret_pid(dest);
1360
1361         /* Zero isn't valid if not "all". */
1362         if (result.pid && procid_valid(&result)) {
1363                 return result;
1364         }
1365
1366         /* Look up other destinations in pidfile directory */
1367
1368         if ((pid = pidfile_pid(dest)) != 0) {
1369                 return pid_to_procid(pid);
1370         }
1371
1372         fprintf(stderr,"Can't find pid for destination '%s'\n", dest);
1373
1374         return result;
1375 }
1376
1377 /* Execute smbcontrol command */
1378
1379 static bool do_command(struct tevent_context *ev_ctx,
1380                        struct messaging_context *msg_ctx,
1381                        int argc, const char **argv)
1382 {
1383         const char *dest = argv[0], *command = argv[1];
1384         struct server_id pid;
1385         int i;
1386
1387         /* Check destination */
1388
1389         pid = parse_dest(msg_ctx, dest);
1390         if (!procid_valid(&pid)) {
1391                 return False;
1392         }
1393
1394         /* Check command */
1395
1396         for (i = 0; msg_types[i].name; i++) {
1397                 if (strequal(command, msg_types[i].name))
1398                         return msg_types[i].fn(ev_ctx, msg_ctx, pid,
1399                                                argc - 1, argv + 1);
1400         }
1401
1402         fprintf(stderr, "smbcontrol: unknown command '%s'\n", command);
1403
1404         return False;
1405 }
1406
1407 static void smbcontrol_help(poptContext pc,
1408                     enum poptCallbackReason preason,
1409                     struct poptOption * poption,
1410                     const char * parg,
1411                     void * pdata)
1412 {
1413         if (poption->shortName != '?') {
1414                 poptPrintUsage(pc, stdout, 0);
1415         } else {
1416                 usage(pc);
1417         }
1418
1419         exit(0);
1420 }
1421
1422 struct poptOption help_options[] = {
1423         { NULL, '\0', POPT_ARG_CALLBACK, (void *)&smbcontrol_help, '\0',
1424           NULL, NULL },
1425         { "help", '?', 0, NULL, '?', "Show this help message", NULL },
1426         { "usage", '\0', 0, NULL, 'u', "Display brief usage message", NULL },
1427         { NULL }
1428 } ;
1429
1430 /* Main program */
1431
1432 int main(int argc, const char **argv)
1433 {
1434         poptContext pc;
1435         int opt;
1436         struct tevent_context *evt_ctx;
1437         struct messaging_context *msg_ctx;
1438
1439         static struct poptOption long_options[] = {
1440                 /* POPT_AUTOHELP */
1441                 { NULL, '\0', POPT_ARG_INCLUDE_TABLE, help_options,
1442                                         0, "Help options:", NULL },
1443                 { "timeout", 't', POPT_ARG_INT, &timeout, 't',
1444                   "Set timeout value in seconds", "TIMEOUT" },
1445
1446                 POPT_COMMON_SAMBA
1447                 POPT_TABLEEND
1448         };
1449         TALLOC_CTX *frame = talloc_stackframe();
1450         int ret = 0;
1451
1452         load_case_tables();
1453
1454         setup_logging(argv[0], DEBUG_STDOUT);
1455
1456         /* Parse command line arguments using popt */
1457
1458         pc = poptGetContext(
1459                 "smbcontrol", argc, (const char **)argv, long_options, 0);
1460
1461         poptSetOtherOptionHelp(pc, "[OPTION...] <destination> <message-type> "
1462                                "<parameters>");
1463
1464         if (argc == 1)
1465                 usage(pc);
1466
1467         while ((opt = poptGetNextOpt(pc)) != -1) {
1468                 switch(opt) {
1469                 case 't':       /* --timeout */
1470                         break;
1471                 default:
1472                         fprintf(stderr, "Invalid option\n");
1473                         poptPrintHelp(pc, stderr, 0);
1474                         break;
1475                 }
1476         }
1477
1478         /* We should now have the remaining command line arguments in
1479            argv.  The argc parameter should have been decremented to the
1480            correct value in the above switch statement. */
1481
1482         argv = (const char **)poptGetArgs(pc);
1483         argc = 0;
1484         if (argv != NULL) {
1485                 while (argv[argc] != NULL) {
1486                         argc++;
1487                 }
1488         }
1489
1490         if (argc <= 1)
1491                 usage(pc);
1492
1493         lp_load_global(get_dyn_CONFIGFILE());
1494
1495         /* Need to invert sense of return code -- samba
1496          * routines mostly return True==1 for success, but
1497          * shell needs 0. */
1498
1499         if (!(evt_ctx = tevent_context_init(NULL)) ||
1500             !(msg_ctx = messaging_init(NULL, evt_ctx))) {
1501                 fprintf(stderr, "could not init messaging context\n");
1502                 TALLOC_FREE(frame);
1503                 exit(1);
1504         }
1505
1506         ret = !do_command(evt_ctx, msg_ctx, argc, argv);
1507         TALLOC_FREE(frame);
1508         return ret;
1509 }