source4/smbd/process_standard.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    process model: standard (1 process per client connection)
   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
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25 #include "lib/events/events.h"
  26 #include "smbd/process_model.h"
  27 #include "system/filesys.h"
  28 #include "cluster/cluster.h"
  29 #include "param/param.h"
  30 #include "ldb_wrap.h"
  31
  32 NTSTATUS process_model_standard_init(void);
  33
  34 /* we hold a pipe open in the parent, and the any child
  35    processes wait for EOF on that pipe. This ensures that
  36    children die when the parent dies */
  37 static int child_pipe[2];
  38
  39 /*
  40   called when the process model is selected
  41 */
  42 static void standard_model_init(void)
  43 {
  44         pipe(child_pipe);
  45         signal(SIGCHLD, SIG_IGN);
  46 }
  47
  48 /*
  49   handle EOF on the child pipe
  50 */
  51 static void standard_pipe_handler(struct tevent_context *event_ctx, struct tevent_fd *fde,
  52                                   uint16_t flags, void *private_data)
  53 {
  54         DEBUG(10,("Child %d exiting\n", (int)getpid()));
  55         exit(0);
  56 }
  57
  58 /*
  59   called when a listening socket becomes readable.
  60 */
  61 static void standard_accept_connection(struct tevent_context *ev,
  62                                        struct loadparm_context *lp_ctx,
  63                                        struct socket_context *sock,
  64                                        void (*new_conn)(struct tevent_context *,
  65                                                         struct loadparm_context *, struct socket_context *,
  66                                                         struct server_id , void *),
  67                                        void *private_data)
  68 {
  69         NTSTATUS status;
  70         struct socket_context *sock2;
  71         pid_t pid;
  72         struct socket_address *c, *s;
  73
  74         /* accept an incoming connection. */
  75         status = socket_accept(sock, &sock2);
  76         if (!NT_STATUS_IS_OK(status)) {
  77                 DEBUG(0,("standard_accept_connection: accept: %s\n",
  78                          nt_errstr(status)));
  79                 /* this looks strange, but is correct. We need to throttle things until
  80                    the system clears enough resources to handle this new socket */
  81                 sleep(1);
  82                 return;
  83         }
  84
  85         pid = fork();
  86
  87         if (pid != 0) {
  88                 /* parent or error code ... */
  89                 talloc_free(sock2);
  90                 /* go back to the event loop */
  91                 return;
  92         }
  93
  94         pid = getpid();
  95
  96         /* This is now the child code. We need a completely new event_context to work with */
  97
  98         if (tevent_re_initialise(ev) != 0) {
  99                 smb_panic("Failed to re-initialise tevent after fork");
 100         }
 101
 102         /* this will free all the listening sockets and all state that
 103            is not associated with this new connection */
 104         talloc_free(sock);
 105
 106         /* we don't care if the dup fails, as its only a select()
 107            speed optimisation */
 108         socket_dup(sock2);
 109
 110         /* tdb needs special fork handling */
 111         ldb_wrap_fork_hook();
 112
 113         tevent_add_fd(ev, ev, child_pipe[0], TEVENT_FD_READ,
 114                       standard_pipe_handler, NULL);
 115         close(child_pipe[1]);
 116
 117         /* Ensure that the forked children do not expose identical random streams */
 118         set_need_random_reseed();
 119
 120         /* setup the process title */
 121         c = socket_get_peer_addr(sock2, ev);
 122         s = socket_get_my_addr(sock2, ev);
 123         if (s && c) {
 124                 setproctitle("conn c[%s:%u] s[%s:%u] server_id[%d]",
 125                              c->addr, c->port, s->addr, s->port, (int)pid);
 126         }
 127         talloc_free(c);
 128         talloc_free(s);
 129
 130         /* setup this new connection.  Cluster ID is PID based for this process model */
 131         new_conn(ev, lp_ctx, sock2, cluster_id(pid, 0), private_data);
 132
 133         /* we can't return to the top level here, as that event context is gone,
 134            so we now process events in the new event context until there are no
 135            more to process */
 136         tevent_loop_wait(ev);
 137
 138         talloc_free(ev);
 139         exit(0);
 140 }
 141
 142 /*
 143   called to create a new server task
 144 */
 145 static void standard_new_task(struct tevent_context *ev,
 146                               struct loadparm_context *lp_ctx,
 147                               const char *service_name,
 148                               void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
 149                               void *private_data)
 150 {
 151         pid_t pid;
 152
 153         pid = fork();
 154
 155         if (pid != 0) {
 156                 /* parent or error code ... go back to the event loop */
 157                 return;
 158         }
 159
 160         pid = getpid();
 161
 162         /* this will free all the listening sockets and all state that
 163            is not associated with this new connection */
 164         if (tevent_re_initialise(ev) != 0) {
 165                 smb_panic("Failed to re-initialise tevent after fork");
 166         }
 167
 168         /* ldb/tdb need special fork handling */
 169         ldb_wrap_fork_hook();
 170
 171         tevent_add_fd(ev, ev, child_pipe[0], TEVENT_FD_READ,
 172                       standard_pipe_handler, NULL);
 173         close(child_pipe[1]);
 174
 175         /* Ensure that the forked children do not expose identical random streams */
 176         set_need_random_reseed();
 177
 178         setproctitle("task %s server_id[%d]", service_name, (int)pid);
 179
 180         /* setup this new task.  Cluster ID is PID based for this process model */
 181         new_task(ev, lp_ctx, cluster_id(pid, 0), private_data);
 182
 183         /* we can't return to the top level here, as that event context is gone,
 184            so we now process events in the new event context until there are no
 185            more to process */
 186         tevent_loop_wait(ev);
 187
 188         talloc_free(ev);
 189         exit(0);
 190 }
 191
 192
 193 /* called when a task goes down */
 194 _NORETURN_ static void standard_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx,
 195                                           const char *reason)
 196 {
 197         DEBUG(2,("standard_terminate: reason[%s]\n",reason));
 198
 199         talloc_free(ev);
 200
 201         /* this reload_charcnv() has the effect of freeing the iconv context memory,
 202            which makes leak checking easier */
 203         reload_charcnv(lp_ctx);
 204
 205         /* terminate this process */
 206         exit(0);
 207 }
 208
 209 /* called to set a title of a task or connection */
 210 static void standard_set_title(struct tevent_context *ev, const char *title)
 211 {
 212         if (title) {
 213                 setproctitle("%s", title);
 214         } else {
 215                 setproctitle(NULL);
 216         }
 217 }
 218
 219 static const struct model_ops standard_ops = {
 220         .name                   = "standard",
 221         .model_init             = standard_model_init,
 222         .accept_connection      = standard_accept_connection,
 223         .new_task               = standard_new_task,
 224         .terminate              = standard_terminate,
 225         .set_title              = standard_set_title,
 226 };
 227
 228 /*
 229   initialise the standard process model, registering ourselves with the process model subsystem
 230  */
 231 NTSTATUS process_model_standard_init(void)
 232 {
 233         return register_process_model(&standard_ops);
 234 }