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