834758356bc6ed07390bc8bbc474cc2c1112b011
[sfrench/samba-autobuild/.git] / source4 / rpc_server / dcerpc_sock.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    server side dcerpc using various kinds of sockets (tcp, unix domain)
5
6    Copyright (C) Andrew Tridgell 2003
7    Copyright (C) Stefan (metze) Metzmacher 2004-2005  
8    Copyright (C) Jelmer Vernooij 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/socket/socket.h"
26 #include "lib/events/events.h"
27 #include "rpc_server/dcerpc_server.h"
28 #include "smbd/service_stream.h"
29 #include "smbd/service.h"
30 #include "lib/messaging/irpc.h"
31 #include "system/network.h"
32 #include "lib/socket/netif.h"
33 #include "auth/auth.h"
34
35 struct dcesrv_socket_context {
36         const struct dcesrv_endpoint *endpoint;
37         struct dcesrv_context *dcesrv_ctx;
38 };
39
40 /*
41   write_fn callback for dcesrv_output()
42 */
43 static NTSTATUS dcerpc_write_fn(void *private_data, DATA_BLOB *out, size_t *nwritten)
44 {
45         NTSTATUS status;
46         struct socket_context *sock = talloc_get_type(private_data, struct socket_context);
47         size_t sendlen;
48
49         status = socket_send(sock, out, &sendlen);
50         NT_STATUS_IS_ERR_RETURN(status);
51
52         *nwritten = sendlen;
53         return status;
54 }
55
56 static void dcesrv_terminate_connection(struct dcesrv_connection *dce_conn, const char *reason)
57 {
58         struct stream_connection *srv_conn;
59         srv_conn = talloc_get_type(dce_conn->transport.private_data,
60                                    struct stream_connection);
61
62         stream_terminate_connection(srv_conn, reason);
63 }
64
65 static void dcesrv_sock_report_output_data(struct dcesrv_connection *dcesrv_conn)
66 {
67         struct stream_connection *srv_conn;
68         srv_conn = talloc_get_type(dcesrv_conn->transport.private_data,
69                                    struct stream_connection);
70
71         if (srv_conn && srv_conn->event.fde) {
72                 EVENT_FD_WRITEABLE(srv_conn->event.fde);
73         }
74 }
75
76 static struct socket_address *dcesrv_sock_get_my_addr(struct dcesrv_connection *dcesrv_conn, TALLOC_CTX *mem_ctx)
77 {
78         struct stream_connection *srv_conn;
79         srv_conn = talloc_get_type(dcesrv_conn->transport.private_data,
80                                    struct stream_connection);
81
82         return socket_get_my_addr(srv_conn->socket, mem_ctx);
83 }
84
85 static struct socket_address *dcesrv_sock_get_peer_addr(struct dcesrv_connection *dcesrv_conn, TALLOC_CTX *mem_ctx)
86 {
87         struct stream_connection *srv_conn;
88         srv_conn = talloc_get_type(dcesrv_conn->transport.private_data,
89                                    struct stream_connection);
90
91         return socket_get_peer_addr(srv_conn->socket, mem_ctx);
92 }
93
94 static void dcesrv_sock_accept(struct stream_connection *srv_conn)
95 {
96         NTSTATUS status;
97         struct dcesrv_socket_context *dcesrv_sock = 
98                 talloc_get_type(srv_conn->private, struct dcesrv_socket_context);
99         struct dcesrv_connection *dcesrv_conn = NULL;
100         struct auth_session_info *session_info = NULL;
101
102         status = auth_anonymous_session_info(srv_conn, &session_info);
103         if (!NT_STATUS_IS_OK(status)) {
104                 DEBUG(0,("dcesrv_sock_accept: auth_anonymous_session_info failed: %s\n", 
105                         nt_errstr(status)));
106                 stream_terminate_connection(srv_conn, nt_errstr(status));
107                 return;
108         }
109
110         status = dcesrv_endpoint_connect(dcesrv_sock->dcesrv_ctx,
111                                          srv_conn,
112                                          dcesrv_sock->endpoint,
113                                          session_info,
114                                          srv_conn->event.ctx,
115                                          srv_conn->msg_ctx,
116                                          srv_conn->server_id,
117                                          DCESRV_CALL_STATE_FLAG_MAY_ASYNC,
118                                          &dcesrv_conn);
119         if (!NT_STATUS_IS_OK(status)) {
120                 DEBUG(0,("dcesrv_sock_accept: dcesrv_endpoint_connect failed: %s\n", 
121                         nt_errstr(status)));
122                 stream_terminate_connection(srv_conn, nt_errstr(status));
123                 return;
124         }
125
126         dcesrv_conn->transport.private_data             = srv_conn;
127         dcesrv_conn->transport.report_output_data       = dcesrv_sock_report_output_data;
128         dcesrv_conn->transport.get_my_addr              = dcesrv_sock_get_my_addr;
129         dcesrv_conn->transport.get_peer_addr            = dcesrv_sock_get_peer_addr;
130
131         srv_conn->private = dcesrv_conn;
132
133         irpc_add_name(srv_conn->msg_ctx, "rpc_server");
134
135         return; 
136 }
137
138 static void dcesrv_sock_recv(struct stream_connection *conn, uint16_t flags)
139 {
140         NTSTATUS status;
141         struct dcesrv_connection *dce_conn = talloc_get_type(conn->private, struct dcesrv_connection);
142         DATA_BLOB tmp_blob;
143         size_t nread;
144
145         if (dce_conn->processing) {
146                 EVENT_FD_NOT_READABLE(conn->event.fde);
147                 return;
148         }
149
150         tmp_blob = data_blob_talloc(conn->socket, NULL, 0x1000);
151         if (tmp_blob.data == NULL) {
152                 dcesrv_terminate_connection(dce_conn, "out of memory");
153                 return;
154         }
155
156         status = socket_recv(conn->socket, tmp_blob.data, tmp_blob.length, &nread);
157         if (NT_STATUS_IS_ERR(status)) {
158                 dcesrv_terminate_connection(dce_conn, nt_errstr(status));
159                 return;
160         }
161         if (nread == 0) {
162                 talloc_free(tmp_blob.data);
163                 return;
164         }
165
166         tmp_blob.length = nread;
167
168         dce_conn->processing = True;
169         status = dcesrv_input(dce_conn, &tmp_blob);
170         dce_conn->processing = False;
171         talloc_free(tmp_blob.data);
172
173         EVENT_FD_READABLE(conn->event.fde);
174
175         if (!NT_STATUS_IS_OK(status)) {
176                 dcesrv_terminate_connection(dce_conn, nt_errstr(status));
177                 return;
178         }
179
180         if (dce_conn->call_list && dce_conn->call_list->replies) {
181                 EVENT_FD_WRITEABLE(conn->event.fde);
182         }
183 }
184
185 static void dcesrv_sock_send(struct stream_connection *conn, uint16_t flags)
186 {
187         struct dcesrv_connection *dce_conn = talloc_get_type(conn->private, struct dcesrv_connection);
188         NTSTATUS status;
189
190         status = dcesrv_output(dce_conn, conn->socket, dcerpc_write_fn);
191         if (NT_STATUS_IS_ERR(status)) {
192                 dcesrv_terminate_connection(dce_conn, "eof on socket");
193                 return;
194         }
195
196         if (!dce_conn->call_list || !dce_conn->call_list->replies) {
197                 EVENT_FD_NOT_WRITEABLE(conn->event.fde);
198         }
199 }
200
201
202 static const struct stream_server_ops dcesrv_stream_ops = {
203         .name                   = "rpc",
204         .accept_connection      = dcesrv_sock_accept,
205         .recv_handler           = dcesrv_sock_recv,
206         .send_handler           = dcesrv_sock_send,
207 };
208
209
210
211 NTSTATUS dcesrv_add_ep_unix(struct dcesrv_context *dce_ctx, struct dcesrv_endpoint *e,
212                                     struct event_context *event_ctx, const struct model_ops *model_ops)
213 {
214         struct dcesrv_socket_context *dcesrv_sock;
215         uint16_t port = 1;
216         NTSTATUS status;
217
218         dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
219         NT_STATUS_HAVE_NO_MEMORY(dcesrv_sock);
220
221         /* remember the endpoint of this socket */
222         dcesrv_sock->endpoint           = e;
223         dcesrv_sock->dcesrv_ctx         = talloc_reference(dcesrv_sock, dce_ctx);
224
225         status = stream_setup_socket(event_ctx, model_ops, &dcesrv_stream_ops, 
226                                      "unix", e->ep_description->endpoint, &port, 
227                                      dcesrv_sock);
228         if (!NT_STATUS_IS_OK(status)) {
229                 DEBUG(0,("service_setup_stream_socket(path=%s) failed - %s\n",
230                          e->ep_description->endpoint, nt_errstr(status)));
231         }
232
233         return status;
234 }
235
236 NTSTATUS dcesrv_add_ep_ncalrpc(struct dcesrv_context *dce_ctx, struct dcesrv_endpoint *e,
237                                        struct event_context *event_ctx, const struct model_ops *model_ops)
238 {
239         struct dcesrv_socket_context *dcesrv_sock;
240         uint16_t port = 1;
241         char *full_path;
242         NTSTATUS status;
243
244         if (!e->ep_description->endpoint) {
245                 /* No identifier specified: use DEFAULT. 
246                  * DO NOT hardcode this value anywhere else. Rather, specify 
247                  * no endpoint and let the epmapper worry about it. */
248                 e->ep_description->endpoint = talloc_strdup(dce_ctx, "DEFAULT");
249         }
250
251         full_path = talloc_asprintf(dce_ctx, "%s/%s", lp_ncalrpc_dir(), e->ep_description->endpoint);
252
253         dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
254         NT_STATUS_HAVE_NO_MEMORY(dcesrv_sock);
255
256         /* remember the endpoint of this socket */
257         dcesrv_sock->endpoint           = e;
258         dcesrv_sock->dcesrv_ctx         = talloc_reference(dcesrv_sock, dce_ctx);
259
260         status = stream_setup_socket(event_ctx, model_ops, &dcesrv_stream_ops, 
261                                      "unix", full_path, &port, dcesrv_sock);
262         if (!NT_STATUS_IS_OK(status)) {
263                 DEBUG(0,("service_setup_stream_socket(identifier=%s,path=%s) failed - %s\n",
264                          e->ep_description->endpoint, full_path, nt_errstr(status)));
265         }
266         return status;
267 }
268
269
270 /*
271   add a socket address to the list of events, one event per dcerpc endpoint
272 */
273 static NTSTATUS add_socket_rpc_pipe_iface(struct dcesrv_context *dce_ctx, struct dcesrv_endpoint *e,
274                                          struct event_context *event_ctx, const struct model_ops *model_ops)
275 {
276         struct dcesrv_socket_context *dcesrv_sock;
277         NTSTATUS status;
278                         
279         if (e->ep_description->endpoint == NULL) {
280                 DEBUG(0, ("Endpoint mandatory for named pipes\n"));
281                 return NT_STATUS_INVALID_PARAMETER;
282         }
283
284         dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
285         NT_STATUS_HAVE_NO_MEMORY(dcesrv_sock);
286
287         /* remember the endpoint of this socket */
288         dcesrv_sock->endpoint           = e;
289         dcesrv_sock->dcesrv_ctx         = talloc_reference(dcesrv_sock, dce_ctx);
290
291         status = NT_STATUS_OK;
292 #if 0
293
294         status = stream_setup_smb_pipe(event_ctx, model_ops, &dcesrv_stream_ops, 
295                                      e->ep_description->endpoint, dcesrv_sock);
296         if (!NT_STATUS_IS_OK(status)) {
297                 DEBUG(0,("service_setup_stream_socket(path=%s) failed - %s\n", 
298                          e->ep_description->endpoint, nt_errstr(status)));
299         }
300 #endif
301         return status;
302 }
303
304 NTSTATUS dcesrv_add_ep_np(struct dcesrv_context *dce_ctx, struct dcesrv_endpoint *e,
305                                    struct event_context *event_ctx, const struct model_ops *model_ops)
306 {
307         NTSTATUS status;
308
309         status = add_socket_rpc_pipe_iface(dce_ctx, e, event_ctx, model_ops);
310         NT_STATUS_NOT_OK_RETURN(status);
311
312         return status;
313 }
314
315 /*
316   add a socket address to the list of events, one event per dcerpc endpoint
317 */
318 static NTSTATUS add_socket_rpc_tcp_iface(struct dcesrv_context *dce_ctx, struct dcesrv_endpoint *e,
319                                          struct event_context *event_ctx, const struct model_ops *model_ops,
320                                          const char *address)
321 {
322         struct dcesrv_socket_context *dcesrv_sock;
323         uint16_t port = 0;
324         NTSTATUS status;
325                         
326         if (e->ep_description->endpoint) {
327                 port = atoi(e->ep_description->endpoint);
328         }
329
330         dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
331         NT_STATUS_HAVE_NO_MEMORY(dcesrv_sock);
332
333         /* remember the endpoint of this socket */
334         dcesrv_sock->endpoint           = e;
335         dcesrv_sock->dcesrv_ctx         = talloc_reference(dcesrv_sock, dce_ctx);
336
337         status = stream_setup_socket(event_ctx, model_ops, &dcesrv_stream_ops, 
338                                      "ipv4", address, &port, dcesrv_sock);
339         if (!NT_STATUS_IS_OK(status)) {
340                 DEBUG(0,("service_setup_stream_socket(address=%s,port=%u) failed - %s\n", 
341                          address, port, nt_errstr(status)));
342         }
343
344         if (e->ep_description->endpoint == NULL) {
345                 e->ep_description->endpoint = talloc_asprintf(dce_ctx, "%d", port);
346         }
347
348         return status;
349 }
350
351 NTSTATUS dcesrv_add_ep_tcp(struct dcesrv_context *dce_ctx, struct dcesrv_endpoint *e,
352                                    struct event_context *event_ctx, const struct model_ops *model_ops)
353 {
354         NTSTATUS status;
355
356         /* Add TCP/IP sockets */
357         if (lp_interfaces() && lp_bind_interfaces_only()) {
358                 int num_interfaces = iface_count();
359                 int i;
360                 for(i = 0; i < num_interfaces; i++) {
361                         const char *address = iface_n_ip(i);
362                         status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx, model_ops, address);
363                         NT_STATUS_NOT_OK_RETURN(status);
364                 }
365         } else {
366                 status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx, model_ops, lp_socket_address());
367                 NT_STATUS_NOT_OK_RETURN(status);
368         }
369
370         return NT_STATUS_OK;
371 }