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 "lib/ldb_wrap.h"
  31
  32 #ifdef HAVE_SETPROCTITLE
  33 #ifdef HAVE_SETPROCTITLE_H
  34 #include <setproctitle.h>
  35 #endif
  36 #else
  37 #define setproctitle none_setproctitle
  38 static int none_setproctitle(const char *fmt, ...) PRINTF_ATTRIBUTE(1, 2);
  39 static int none_setproctitle(const char *fmt, ...)
  40 {
  41         return 0;
  42 }
  43 #endif
  44
  45 /* we hold a pipe open in the parent, and the any child
  46    processes wait for EOF on that pipe. This ensures that
  47    children die when the parent dies */
  48 static int child_pipe[2];
  49
  50 /*
  51   called when the process model is selected
  52 */
  53 static void standard_model_init(struct tevent_context *ev)
  54 {
  55         pipe(child_pipe);
  56         signal(SIGCHLD, SIG_IGN);
  57 }
  58
  59 /*
  60   handle EOF on the child pipe
  61 */
  62 static void standard_pipe_handler(struct tevent_context *event_ctx, struct tevent_fd *fde,
  63                                   uint16_t flags, void *private_data)
  64 {
  65         DEBUG(10,("Child %d exiting\n", (int)getpid()));
  66         exit(0);
  67 }
  68
  69 /*
  70   called when a listening socket becomes readable.
  71 */
  72 static void standard_accept_connection(struct tevent_context *ev,
  73                                        struct loadparm_context *lp_ctx,
  74                                        struct socket_context *sock,
  75                                        void (*new_conn)(struct tevent_context *,
  76                                                         struct loadparm_context *, struct socket_context *,
  77                                                         struct server_id , void *),
  78                                        void *private_data)
  79 {
  80         NTSTATUS status;
  81         struct socket_context *sock2;
  82         pid_t pid;
  83         struct tevent_context *ev2;
  84         struct socket_address *c, *s;
  85
  86         /* accept an incoming connection. */
  87         status = socket_accept(sock, &sock2);
  88         if (!NT_STATUS_IS_OK(status)) {
  89                 DEBUG(0,("standard_accept_connection: accept: %s\n",
  90                          nt_errstr(status)));
  91                 /* this looks strange, but is correct. We need to throttle things until
  92                    the system clears enough resources to handle this new socket */
  93                 sleep(1);
  94                 return;
  95         }
  96
  97         pid = fork();
  98
  99         if (pid != 0) {
 100                 /* parent or error code ... */
 101                 talloc_free(sock2);
 102                 /* go back to the event loop */
 103                 return;
 104         }
 105
 106         pid = getpid();
 107
 108         /* This is now the child code. We need a completely new event_context to work with */
 109         ev2 = s4_event_context_init(NULL);
 110
 111         /* setup this as the default context */
 112         s4_event_context_set_default(ev2);
 113
 114         /* the service has given us a private pointer that
 115            encapsulates the context it needs for this new connection -
 116            everything else will be freed */
 117         talloc_steal(ev2, private_data);
 118         talloc_steal(private_data, sock2);
 119
 120         /* this will free all the listening sockets and all state that
 121            is not associated with this new connection */
 122         talloc_free(sock);
 123         talloc_free(ev);
 124
 125         /* we don't care if the dup fails, as its only a select()
 126            speed optimisation */
 127         socket_dup(sock2);
 128
 129         /* tdb needs special fork handling */
 130         ldb_wrap_fork_hook();
 131
 132         tevent_add_fd(ev2, ev2, child_pipe[0], TEVENT_FD_READ,
 133                       standard_pipe_handler, NULL);
 134         close(child_pipe[1]);
 135
 136         /* Ensure that the forked children do not expose identical random streams */
 137         set_need_random_reseed();
 138
 139         /* setup the process title */
 140         c = socket_get_peer_addr(sock2, ev2);
 141         s = socket_get_my_addr(sock2, ev2);
 142         if (s && c) {
 143                 setproctitle("conn c[%s:%u] s[%s:%u] server_id[%d]",
 144                              c->addr, c->port, s->addr, s->port, pid);
 145         }
 146         talloc_free(c);
 147         talloc_free(s);
 148
 149         /* setup this new connection.  Cluster ID is PID based for this process modal */
 150         new_conn(ev2, lp_ctx, sock2, cluster_id(pid, 0), private_data);
 151
 152         /* we can't return to the top level here, as that event context is gone,
 153            so we now process events in the new event context until there are no
 154            more to process */
 155         event_loop_wait(ev2);
 156
 157         talloc_free(ev2);
 158         exit(0);
 159 }
 160
 161 /*
 162   called to create a new server task
 163 */
 164 static void standard_new_task(struct tevent_context *ev,
 165                               struct loadparm_context *lp_ctx,
 166                               const char *service_name,
 167                               void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
 168                               void *private_data)
 169 {
 170         pid_t pid;
 171         struct tevent_context *ev2;
 172
 173         pid = fork();
 174
 175         if (pid != 0) {
 176                 /* parent or error code ... go back to the event loop */
 177                 return;
 178         }
 179
 180         pid = getpid();
 181
 182         /* This is now the child code. We need a completely new event_context to work with */
 183         ev2 = s4_event_context_init(NULL);
 184
 185         /* setup this as the default context */
 186         s4_event_context_set_default(ev2);
 187
 188         /* the service has given us a private pointer that
 189            encapsulates the context it needs for this new connection -
 190            everything else will be freed */
 191         talloc_steal(ev2, private_data);
 192
 193         /* this will free all the listening sockets and all state that
 194            is not associated with this new connection */
 195         talloc_free(ev);
 196
 197         /* ldb/tdb need special fork handling */
 198         ldb_wrap_fork_hook();
 199
 200         tevent_add_fd(ev2, ev2, child_pipe[0], TEVENT_FD_READ,
 201                       standard_pipe_handler, NULL);
 202         close(child_pipe[1]);
 203
 204         /* Ensure that the forked children do not expose identical random streams */
 205         set_need_random_reseed();
 206
 207         setproctitle("task %s server_id[%d]", service_name, pid);
 208
 209         /* setup this new task.  Cluster ID is PID based for this process modal */
 210         new_task(ev2, lp_ctx, cluster_id(pid, 0), private_data);
 211
 212         /* we can't return to the top level here, as that event context is gone,
 213            so we now process events in the new event context until there are no
 214            more to process */
 215         event_loop_wait(ev2);
 216
 217         talloc_free(ev2);
 218         exit(0);
 219 }
 220
 221
 222 /* called when a task goes down */
 223 _NORETURN_ static void standard_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx,
 224                                           const char *reason)
 225 {
 226         DEBUG(2,("standard_terminate: reason[%s]\n",reason));
 227
 228         talloc_free(ev);
 229
 230         /* this reload_charcnv() has the effect of freeing the iconv context memory,
 231            which makes leak checking easier */
 232         reload_charcnv(lp_ctx);
 233
 234         /* terminate this process */
 235         exit(0);
 236 }
 237
 238 /* called to set a title of a task or connection */
 239 static void standard_set_title(struct tevent_context *ev, const char *title)
 240 {
 241         if (title) {
 242                 setproctitle("%s", title);
 243         } else {
 244                 setproctitle(NULL);
 245         }
 246 }
 247
 248 static const struct model_ops standard_ops = {
 249         .name                   = "standard",
 250         .model_init             = standard_model_init,
 251         .accept_connection      = standard_accept_connection,
 252         .new_task               = standard_new_task,
 253         .terminate              = standard_terminate,
 254         .set_title              = standard_set_title,
 255 };
 256
 257 /*
 258   initialise the standard process model, registering ourselves with the process model subsystem
 259  */
 260 NTSTATUS process_model_standard_init(void)
 261 {
 262         return register_process_model(&standard_ops);
 263 }