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