1f1f92b4955dd68ced3d64d801decfb3bc800a7d
[jelmer/samba4-debian.git] / source / smbd / service_stream.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    helper functions for stream based servers
5
6    Copyright (C) Andrew Tridgell 2003-2005
7    Copyright (C) Stefan (metze) Metzmacher      2004
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "process_model.h"
25 #include "lib/events/events.h"
26 #include "lib/socket/socket.h"
27 #include "smbd/service.h"
28 #include "smbd/service_stream.h"
29 #include "lib/messaging/irpc.h"
30 #include "cluster/cluster.h"
31 #include "param/param.h"
32
33 /* the range of ports to try for dcerpc over tcp endpoints */
34 #define SERVER_TCP_LOW_PORT  1024
35 #define SERVER_TCP_HIGH_PORT 1300
36
37 /* size of listen() backlog in smbd */
38 #define SERVER_LISTEN_BACKLOG 10
39
40
41 /*
42   private structure for a single listening stream socket
43 */
44 struct stream_socket {
45         const struct stream_server_ops *ops;
46         struct event_context *event_ctx;
47         const struct model_ops *model_ops;
48         struct socket_context *sock;
49         void *private;
50 };
51
52
53 /*
54   close the socket and shutdown a stream_connection
55 */
56 void stream_terminate_connection(struct stream_connection *srv_conn, const char *reason)
57 {
58         struct event_context *event_ctx = srv_conn->event.ctx;
59         const struct model_ops *model_ops = srv_conn->model_ops;
60
61         if (!reason) reason = "unknown reason";
62
63         srv_conn->terminate = reason;
64
65         if (srv_conn->processing) {
66                 /* 
67                  * if we're currently inside the stream_io_handler(),
68                  * defer the termination to the end of stream_io_hendler()
69                  *
70                  * and we don't want to read or write to the connection...
71                  */
72                 event_set_fd_flags(srv_conn->event.fde, 0);
73                 return;
74         }
75
76         talloc_free(srv_conn->event.fde);
77         srv_conn->event.fde = NULL;
78         talloc_free(srv_conn);
79         model_ops->terminate(event_ctx, reason);
80 }
81
82 /*
83   the select loop has indicated that a stream is ready for IO
84 */
85 static void stream_io_handler(struct stream_connection *conn, uint16_t flags)
86 {
87         conn->processing = True;
88         if (flags & EVENT_FD_WRITE) {
89                 conn->ops->send_handler(conn, flags);
90         } else if (flags & EVENT_FD_READ) {
91                 conn->ops->recv_handler(conn, flags);
92         }
93         conn->processing = False;
94
95         if (conn->terminate) {
96                 stream_terminate_connection(conn, conn->terminate);
97         }
98 }
99
100 static void stream_io_handler_fde(struct event_context *ev, struct fd_event *fde, 
101                                   uint16_t flags, void *private)
102 {
103         struct stream_connection *conn = talloc_get_type(private, 
104                                                          struct stream_connection);
105         stream_io_handler(conn, flags);
106 }
107
108 void stream_io_handler_callback(void *private, uint16_t flags) 
109 {
110         struct stream_connection *conn = talloc_get_type(private, 
111                                                          struct stream_connection);
112         stream_io_handler(conn, flags);
113 }
114
115 /*
116   this creates a stream_connection from an already existing connection,
117   used for protocols, where a client connection needs to switched into
118   a server connection
119 */
120 NTSTATUS stream_new_connection_merge(struct event_context *ev,
121                                      const struct model_ops *model_ops,
122                                      struct socket_context *sock,
123                                      const struct stream_server_ops *stream_ops,
124                                      struct messaging_context *msg_ctx,
125                                      void *private_data,
126                                      struct stream_connection **_srv_conn)
127 {
128         struct stream_connection *srv_conn;
129
130         srv_conn = talloc_zero(ev, struct stream_connection);
131         NT_STATUS_HAVE_NO_MEMORY(srv_conn);
132
133         talloc_steal(srv_conn, sock);
134
135         srv_conn->private       = private_data;
136         srv_conn->model_ops     = model_ops;
137         srv_conn->socket        = sock;
138         srv_conn->server_id     = cluster_id(0);
139         srv_conn->ops           = stream_ops;
140         srv_conn->msg_ctx       = msg_ctx;
141         srv_conn->event.ctx     = ev;
142         srv_conn->event.fde     = event_add_fd(ev, srv_conn, socket_get_fd(sock),
143                                                EVENT_FD_READ, 
144                                                stream_io_handler_fde, srv_conn);
145         *_srv_conn = srv_conn;
146         return NT_STATUS_OK;
147 }
148
149 /*
150   called when a new socket connection has been established. This is called in the process
151   context of the new process (if appropriate)
152 */
153 static void stream_new_connection(struct event_context *ev,
154                                   struct socket_context *sock, 
155                                   struct server_id server_id, void *private)
156 {
157         struct stream_socket *stream_socket = talloc_get_type(private, struct stream_socket);
158         struct stream_connection *srv_conn;
159         struct socket_address *c, *s;
160
161         srv_conn = talloc_zero(ev, struct stream_connection);
162         if (!srv_conn) {
163                 DEBUG(0,("talloc(mem_ctx, struct stream_connection) failed\n"));
164                 return;
165         }
166
167         talloc_steal(srv_conn, sock);
168
169         srv_conn->private       = stream_socket->private;
170         srv_conn->model_ops     = stream_socket->model_ops;
171         srv_conn->socket        = sock;
172         srv_conn->server_id     = server_id;
173         srv_conn->ops           = stream_socket->ops;
174         srv_conn->event.ctx     = ev;
175         srv_conn->event.fde     = event_add_fd(ev, srv_conn, socket_get_fd(sock),
176                                                0, stream_io_handler_fde, srv_conn);
177
178         if (!socket_check_access(sock, "smbd", lp_hostsallow(NULL), lp_hostsdeny(NULL))) {
179                 stream_terminate_connection(srv_conn, "denied by access rules");
180                 return;
181         }
182
183         /* setup to receive internal messages on this connection */
184         srv_conn->msg_ctx = messaging_init(srv_conn, srv_conn->server_id, ev);
185         if (!srv_conn->msg_ctx) {
186                 stream_terminate_connection(srv_conn, "messaging_init() failed");
187                 return;
188         }
189
190         c = socket_get_peer_addr(sock, ev);
191         s = socket_get_my_addr(sock, ev);
192         if (s && c) {
193                 const char *title;
194                 title = talloc_asprintf(s, "conn[%s] c[%s:%u] s[%s:%u] server_id[%s]",
195                                         stream_socket->ops->name, 
196                                         c->addr, c->port, s->addr, s->port,
197                                         cluster_id_string(s, server_id));
198                 if (title) {
199                         stream_connection_set_title(srv_conn, title);
200                 }
201         }
202         talloc_free(c);
203         talloc_free(s);
204
205         /* we're now ready to start receiving events on this stream */
206         EVENT_FD_READABLE(srv_conn->event.fde);
207
208         /* call the server specific accept code */
209         stream_socket->ops->accept_connection(srv_conn);
210 }
211
212
213 /*
214   called when someone opens a connection to one of our listening ports
215 */
216 static void stream_accept_handler(struct event_context *ev, struct fd_event *fde, 
217                                   uint16_t flags, void *private)
218 {
219         struct stream_socket *stream_socket = talloc_get_type(private, struct stream_socket);
220
221         /* ask the process model to create us a process for this new
222            connection.  When done, it calls stream_new_connection()
223            with the newly created socket */
224         stream_socket->model_ops->accept_connection(ev, stream_socket->sock, 
225                                                     stream_new_connection, stream_socket);
226 }
227
228 /*
229   setup a listen stream socket
230   if you pass *port == 0, then a port > 1024 is used
231
232   FIXME: This function is TCP/IP specific - uses an int rather than 
233          a string for the port. Should leave allocating a port nr 
234          to the socket implementation - JRV20070903
235  */
236 NTSTATUS stream_setup_socket(struct event_context *event_context,
237                              const struct model_ops *model_ops,
238                              const struct stream_server_ops *stream_ops,
239                              const char *family,
240                              const char *sock_addr,
241                              uint16_t *port,
242                              void *private)
243 {
244         NTSTATUS status;
245         struct stream_socket *stream_socket;
246         struct socket_address *socket_address;
247         int i;
248
249         stream_socket = talloc_zero(event_context, struct stream_socket);
250         NT_STATUS_HAVE_NO_MEMORY(stream_socket);
251
252         status = socket_create(family, SOCKET_TYPE_STREAM, &stream_socket->sock, 0);
253         NT_STATUS_NOT_OK_RETURN(status);
254
255         talloc_steal(stream_socket, stream_socket->sock);
256
257         /* ready to listen */
258         status = socket_set_option(stream_socket->sock, "SO_KEEPALIVE", NULL);
259         NT_STATUS_NOT_OK_RETURN(status);
260
261         status = socket_set_option(stream_socket->sock, lp_socket_options(global_loadparm), 
262                                    NULL);
263         NT_STATUS_NOT_OK_RETURN(status);
264
265         /* TODO: set socket ACL's here when they're implemented */
266
267         if (*port == 0) {
268                 for (i=SERVER_TCP_LOW_PORT;i<= SERVER_TCP_HIGH_PORT;i++) {
269                         socket_address = socket_address_from_strings(stream_socket, 
270                                                                      stream_socket->sock->backend_name,
271                                                                      sock_addr, i);
272                         NT_STATUS_HAVE_NO_MEMORY(socket_address);
273                         status = socket_listen(stream_socket->sock, socket_address, 
274                                                SERVER_LISTEN_BACKLOG, 0);
275                         talloc_free(socket_address);
276                         if (NT_STATUS_IS_OK(status)) {
277                                 *port = i;
278                                 break;
279                         }
280                 }
281         } else {
282                 socket_address = socket_address_from_strings(stream_socket, 
283                                                              stream_socket->sock->backend_name,
284                                                              sock_addr, *port);
285                 NT_STATUS_HAVE_NO_MEMORY(socket_address);
286                 status = socket_listen(stream_socket->sock, socket_address, SERVER_LISTEN_BACKLOG, 0);
287                 talloc_free(socket_address);
288         }
289
290         if (!NT_STATUS_IS_OK(status)) {
291                 DEBUG(0,("Failed to listen on %s:%u - %s\n",
292                         sock_addr, *port, nt_errstr(status)));
293                 talloc_free(stream_socket);
294                 return status;
295         }
296
297         /* we will close the socket using the events system */
298         socket_set_flags(stream_socket->sock, SOCKET_FLAG_NOCLOSE);
299
300         event_add_fd(event_context, stream_socket->sock, 
301                      socket_get_fd(stream_socket->sock), 
302                      EVENT_FD_READ|EVENT_FD_AUTOCLOSE, 
303                      stream_accept_handler, stream_socket);
304
305         stream_socket->private          = talloc_reference(stream_socket, private);
306         stream_socket->ops              = stream_ops;
307         stream_socket->event_ctx        = event_context;
308         stream_socket->model_ops        = model_ops;
309
310         return NT_STATUS_OK;
311 }
312
313 /*
314   setup a connection title 
315 */
316 void stream_connection_set_title(struct stream_connection *conn, const char *title)
317 {
318         conn->model_ops->set_title(conn->event.ctx, title);
319 }