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