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