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         /* the service has given us a private pointer that
 112            encapsulates the context it needs for this new connection -
 113            everything else will be freed */
 114         talloc_steal(ev2, private_data);
 115         talloc_steal(private_data, sock2);
 116
 117         /* this will free all the listening sockets and all state that
 118            is not associated with this new connection */
 119         talloc_free(sock);
 120         talloc_free(ev);
 121
 122         /* we don't care if the dup fails, as its only a select()
 123            speed optimisation */
 124         socket_dup(sock2);
 125
 126         /* tdb needs special fork handling */
 127         ldb_wrap_fork_hook();
 128
 129         tevent_add_fd(ev2, ev2, child_pipe[0], TEVENT_FD_READ,
 130                       standard_pipe_handler, NULL);
 131         close(child_pipe[1]);
 132
 133         /* Ensure that the forked children do not expose identical random streams */
 134         set_need_random_reseed();
 135
 136         /* setup the process title */
 137         c = socket_get_peer_addr(sock2, ev2);
 138         s = socket_get_my_addr(sock2, ev2);
 139         if (s && c) {
 140                 setproctitle("conn c[%s:%u] s[%s:%u] server_id[%d]",
 141                              c->addr, c->port, s->addr, s->port, pid);
 142         }
 143         talloc_free(c);
 144         talloc_free(s);
 145
 146         /* setup this new connection.  Cluster ID is PID based for this process modal */
 147         new_conn(ev2, lp_ctx, sock2, cluster_id(pid, 0), private_data);
 148
 149         /* we can't return to the top level here, as that event context is gone,
 150            so we now process events in the new event context until there are no
 151            more to process */
 152         event_loop_wait(ev2);
 153
 154         talloc_free(ev2);
 155         exit(0);
 156 }
 157
 158 /*
 159   called to create a new server task
 160 */
 161 static void standard_new_task(struct tevent_context *ev,
 162                               struct loadparm_context *lp_ctx,
 163                               const char *service_name,
 164                               void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
 165                               void *private_data)
 166 {
 167         pid_t pid;
 168         struct tevent_context *ev2;
 169
 170         pid = fork();
 171
 172         if (pid != 0) {
 173                 /* parent or error code ... go back to the event loop */
 174                 return;
 175         }
 176
 177         pid = getpid();
 178
 179         /* This is now the child code. We need a completely new event_context to work with */
 180         ev2 = s4_event_context_init(NULL);
 181
 182         /* the service has given us a private pointer that
 183            encapsulates the context it needs for this new connection -
 184            everything else will be freed */
 185         talloc_steal(ev2, private_data);
 186
 187         /* this will free all the listening sockets and all state that
 188            is not associated with this new connection */
 189         talloc_free(ev);
 190
 191         /* ldb/tdb need special fork handling */
 192         ldb_wrap_fork_hook();
 193
 194         tevent_add_fd(ev2, ev2, child_pipe[0], TEVENT_FD_READ,
 195                       standard_pipe_handler, NULL);
 196         close(child_pipe[1]);
 197
 198         /* Ensure that the forked children do not expose identical random streams */
 199         set_need_random_reseed();
 200
 201         setproctitle("task %s server_id[%d]", service_name, pid);
 202
 203         /* setup this new task.  Cluster ID is PID based for this process modal */
 204         new_task(ev2, lp_ctx, cluster_id(pid, 0), private_data);
 205
 206         /* we can't return to the top level here, as that event context is gone,
 207            so we now process events in the new event context until there are no
 208            more to process */
 209         event_loop_wait(ev2);
 210
 211         talloc_free(ev2);
 212         exit(0);
 213 }
 214
 215
 216 /* called when a task goes down */
 217 _NORETURN_ static void standard_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx,
 218                                           const char *reason)
 219 {
 220         DEBUG(2,("standard_terminate: reason[%s]\n",reason));
 221
 222         /* this reload_charcnv() has the effect of freeing the iconv context memory,
 223            which makes leak checking easier */
 224         reload_charcnv(lp_ctx);
 225
 226         talloc_free(ev);
 227
 228         /* terminate this process */
 229         exit(0);
 230 }
 231
 232 /* called to set a title of a task or connection */
 233 static void standard_set_title(struct tevent_context *ev, const char *title)
 234 {
 235         if (title) {
 236                 setproctitle("%s", title);
 237         } else {
 238                 setproctitle(NULL);
 239         }
 240 }
 241
 242 static const struct model_ops standard_ops = {
 243         .name                   = "standard",
 244         .model_init             = standard_model_init,
 245         .accept_connection      = standard_accept_connection,
 246         .new_task               = standard_new_task,
 247         .terminate              = standard_terminate,
 248         .set_title              = standard_set_title,
 249 };
 250
 251 /*
 252   initialise the standard process model, registering ourselves with the process model subsystem
 253  */
 254 NTSTATUS process_model_standard_init(void)
 255 {
 256         return register_process_model(&standard_ops);
 257 }