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