source4/smbd/process_onefork.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    process model: onefork (1 child process)
   5
   6    Copyright (C) Andrew Tridgell 1992-2005
   7    Copyright (C) James J Myers 2003 <myersjj@samba.org>
   8    Copyright (C) Stefan (metze) Metzmacher 2004
   9    Copyright (C) Andrew Bartlett 2008 <abartlet@samba.org>
  10    Copyright (C) David Disseldorp 2008 <ddiss@sgi.com>
  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 "lib/events/events.h"
  28 #include "lib/socket/socket.h"
  29 #include "smbd/process_model.h"
  30 #include "param/secrets.h"
  31 #include "system/filesys.h"
  32 #include "cluster/cluster.h"
  33 #include "param/param.h"
  34 #include "ldb_wrap.h"
  35
  36 #ifdef HAVE_SETPROCTITLE
  37 #ifdef HAVE_SETPROCTITLE_H
  38 #include <setproctitle.h>
  39 #endif
  40 #else
  41 #define setproctitle none_setproctitle
  42 static int none_setproctitle(const char *fmt, ...) PRINTF_ATTRIBUTE(1, 2);
  43 static int none_setproctitle(const char *fmt, ...)
  44 {
  45         return 0;
  46 }
  47 #endif
  48
  49 /*
  50   called when the process model is selected
  51 */
  52 static void onefork_model_init(struct tevent_context *ev)
  53 {
  54         signal(SIGCHLD, SIG_IGN);
  55 }
  56
  57 static void onefork_reload_after_fork(void)
  58 {
  59         ldb_wrap_fork_hook();
  60
  61         /* Ensure that the forked children do not expose identical random streams */
  62         set_need_random_reseed();
  63 }
  64
  65 /*
  66   called when a listening socket becomes readable.
  67 */
  68 static void onefork_accept_connection(struct tevent_context *ev,
  69                                       struct loadparm_context *lp_ctx,
  70                                       struct socket_context *listen_socket,
  71                                        void (*new_conn)(struct tevent_context *,
  72                                                         struct loadparm_context *, struct socket_context *,
  73                                                         struct server_id , void *),
  74                                        void *private_data)
  75 {
  76         NTSTATUS status;
  77         struct socket_context *connected_socket;
  78         pid_t pid = getpid();
  79
  80         /* accept an incoming connection. */
  81         status = socket_accept(listen_socket, &connected_socket);
  82         if (!NT_STATUS_IS_OK(status)) {
  83                 return;
  84         }
  85
  86         talloc_steal(private_data, connected_socket);
  87
  88         new_conn(ev, lp_ctx, connected_socket, cluster_id(pid, socket_get_fd(connected_socket)), private_data);
  89 }
  90
  91 /*
  92   called to create a new server task
  93 */
  94 static void onefork_new_task(struct tevent_context *ev,
  95                              struct loadparm_context *lp_ctx,
  96                              const char *service_name,
  97                              void (*new_task_fn)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
  98                              void *private_data)
  99 {
 100         pid_t pid;
 101
 102         pid = fork();
 103
 104         if (pid != 0) {
 105                 /* parent or error code ... go back to the event loop */
 106                 return;
 107         }
 108
 109         pid = getpid();
 110
 111         if (tevent_re_initialise(ev) != 0) {
 112                 smb_panic("Failed to re-initialise tevent after fork");
 113         }
 114
 115         setproctitle("task %s server_id[%d]", service_name, pid);
 116
 117         onefork_reload_after_fork();
 118
 119         /* setup this new connection: process will bind to it's sockets etc */
 120         new_task_fn(ev, lp_ctx, cluster_id(pid, 0), private_data);
 121
 122         event_loop_wait(ev);
 123
 124         talloc_free(ev);
 125         exit(0);
 126
 127 }
 128
 129
 130 /* called when a task goes down */
 131 static void onefork_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx, const char *reason)
 132 {
 133         DEBUG(2,("onefork_terminate: reason[%s]\n",reason));
 134 }
 135
 136 /* called to set a title of a task or connection */
 137 static void onefork_set_title(struct tevent_context *ev, const char *title)
 138 {
 139         if (title) {
 140                 setproctitle("%s", title);
 141         } else {
 142                 setproctitle(NULL);
 143         }
 144 }
 145
 146 static const struct model_ops onefork_ops = {
 147         .name                   = "onefork",
 148         .model_init             = onefork_model_init,
 149         .accept_connection      = onefork_accept_connection,
 150         .new_task               = onefork_new_task,
 151         .terminate              = onefork_terminate,
 152         .set_title              = onefork_set_title,
 153 };
 154
 155 /*
 156   initialise the onefork process model, registering ourselves with the process model subsystem
 157  */
 158 NTSTATUS process_model_onefork_init(void)
 159 {
 160         return register_process_model(&onefork_ops);
 161 }