Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 :
4 : process model: process (1 process handles all client connections)
5 :
6 : Copyright (C) Andrew Tridgell 2003
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 "samba/process_model.h"
26 : #include "system/filesys.h"
27 : #include "cluster/cluster.h"
28 :
29 : NTSTATUS process_model_single_init(TALLOC_CTX *);
30 :
31 : /*
32 : called when the process model is selected
33 : */
34 58 : static void single_model_init(void)
35 : {
36 58 : }
37 :
38 : /*
39 : called when a listening socket becomes readable.
40 : */
41 24932 : static void single_accept_connection(struct tevent_context *ev,
42 : struct loadparm_context *lp_ctx,
43 : struct socket_context *listen_socket,
44 : void (*new_conn)(struct tevent_context *,
45 : struct loadparm_context *,
46 : struct socket_context *,
47 : struct server_id, void *,
48 : void *),
49 : void *private_data,
50 : void *process_context)
51 : {
52 : NTSTATUS status;
53 : struct socket_context *connected_socket;
54 24932 : pid_t pid = getpid();
55 :
56 : /* accept an incoming connection. */
57 24932 : status = socket_accept(listen_socket, &connected_socket);
58 24932 : if (!NT_STATUS_IS_OK(status)) {
59 0 : DBG_ERR("single_accept_connection: accept: %s\n",
60 : nt_errstr(status));
61 : /* this looks strange, but is correct.
62 :
63 : We can only be here if woken up from select, due to
64 : an incoming connection.
65 :
66 : We need to throttle things until the system clears
67 : enough resources to handle this new socket.
68 :
69 : If we don't then we will spin filling the log and
70 : causing more problems. We don't panic as this is
71 : probably a temporary resource constraint */
72 0 : sleep(1);
73 0 : return;
74 : }
75 :
76 24932 : talloc_steal(private_data, connected_socket);
77 :
78 : /*
79 : * We use the PID so we cannot collide in with cluster ids
80 : * generated in other single mode tasks, and, and won't
81 : * collide with PIDs from process model standard because a the
82 : * combination of pid/fd should be unique system-wide
83 : */
84 24932 : new_conn(ev, lp_ctx, connected_socket,
85 24932 : cluster_id(pid, socket_get_fd(connected_socket)), private_data,
86 : process_context);
87 : }
88 :
89 : /*
90 : called to startup a new task
91 : */
92 42 : static void single_new_task(struct tevent_context *ev,
93 : struct loadparm_context *lp_ctx,
94 : const char *service_name,
95 : struct task_server *(*new_task)(struct tevent_context *,
96 : struct loadparm_context *,
97 : struct server_id, void *, void *),
98 : void *private_data,
99 : const struct service_details *service_details,
100 : int from_parent_fd)
101 : {
102 42 : pid_t pid = getpid();
103 : /* start our taskids at MAX_INT32, the first 2^31 tasks are is reserved for fd numbers */
104 : static uint32_t taskid = INT32_MAX;
105 42 : struct task_server *task = NULL;
106 : /*
107 : * We use the PID so we cannot collide in with cluster ids
108 : * generated in other single mode tasks, and, and won't
109 : * collide with PIDs from process model starndard because a the
110 : * combination of pid/task_id should be unique system-wide
111 : *
112 : * Using the pid unaltered makes debugging of which process
113 : * owns the messaging socket easier.
114 : */
115 42 : task = new_task(ev, lp_ctx, cluster_id(pid, taskid++), private_data, NULL);
116 42 : if (task != NULL && service_details->post_fork != NULL) {
117 9 : struct process_details pd = initial_process_details;
118 9 : service_details->post_fork(task, &pd);
119 : }
120 42 : }
121 :
122 : /*
123 : * Called when a task goes down
124 : */
125 0 : static void single_terminate_task(struct tevent_context *ev,
126 : struct loadparm_context *lp_ctx,
127 : const char *reason,
128 : bool fatal,
129 : void *process_context)
130 : {
131 0 : DBG_NOTICE("single_terminate: reason[%s]\n",reason);
132 0 : }
133 :
134 : /*
135 : * Called when a connection has ended
136 : */
137 24922 : static void single_terminate_connection(struct tevent_context *ev,
138 : struct loadparm_context *lp_ctx,
139 : const char *reason,
140 : void *process_context)
141 : {
142 24922 : }
143 :
144 : /* called to set a title of a task or connection */
145 24974 : static void single_set_title(struct tevent_context *ev, const char *title)
146 : {
147 24974 : }
148 :
149 : const struct model_ops single_ops = {
150 : .name = "single",
151 : .model_init = single_model_init,
152 : .new_task = single_new_task,
153 : .accept_connection = single_accept_connection,
154 : .terminate_task = single_terminate_task,
155 : .terminate_connection = single_terminate_connection,
156 : .set_title = single_set_title,
157 : };
158 :
159 : /*
160 : initialise the single process model, registering ourselves with the
161 : process model subsystem
162 : */
163 55 : NTSTATUS process_model_single_init(TALLOC_CTX *ctx)
164 : {
165 55 : return register_process_model(&single_ops);
166 : }
|
