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