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