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