2 Unix SMB/CIFS implementation.
4 smbd-specific dcerpc server code
6 Copyright (C) Andrew Tridgell 2003-2005
7 Copyright (C) Stefan (metze) Metzmacher 2004-2005
8 Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2004,2007
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.
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.
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/>.
25 #include "librpc/gen_ndr/ndr_dcerpc.h"
26 #include "auth/auth.h"
27 #include "auth/gensec/gensec.h"
28 #include "lib/util/dlinklist.h"
29 #include "rpc_server/dcerpc_server.h"
30 #include "lib/events/events.h"
31 #include "smbd/service_task.h"
32 #include "smbd/service_stream.h"
33 #include "smbd/service.h"
34 #include "system/filesys.h"
35 #include "libcli/security/security.h"
36 #include "lib/socket/socket.h"
37 #include "lib/messaging/irpc.h"
38 #include "system/network.h"
39 #include "lib/socket/netif.h"
41 #include "param/param.h"
43 struct dcesrv_socket_context {
44 const struct dcesrv_endpoint *endpoint;
45 struct dcesrv_context *dcesrv_ctx;
49 write_fn callback for dcesrv_output()
51 static NTSTATUS dcerpc_write_fn(void *private_data, DATA_BLOB *out, size_t *nwritten)
54 struct socket_context *sock = talloc_get_type(private_data, struct socket_context);
57 status = socket_send(sock, out, &sendlen);
58 NT_STATUS_IS_ERR_RETURN(status);
64 static void dcesrv_terminate_connection(struct dcesrv_connection *dce_conn, const char *reason)
66 struct stream_connection *srv_conn;
67 srv_conn = talloc_get_type(dce_conn->transport.private_data,
68 struct stream_connection);
70 stream_terminate_connection(srv_conn, reason);
73 static void dcesrv_sock_report_output_data(struct dcesrv_connection *dcesrv_conn)
75 struct stream_connection *srv_conn;
76 srv_conn = talloc_get_type(dcesrv_conn->transport.private_data,
77 struct stream_connection);
79 if (srv_conn && srv_conn->event.fde) {
80 EVENT_FD_WRITEABLE(srv_conn->event.fde);
84 static struct socket_address *dcesrv_sock_get_my_addr(struct dcesrv_connection *dcesrv_conn, TALLOC_CTX *mem_ctx)
86 struct stream_connection *srv_conn;
87 srv_conn = talloc_get_type(dcesrv_conn->transport.private_data,
88 struct stream_connection);
90 return socket_get_my_addr(srv_conn->socket, mem_ctx);
93 static struct socket_address *dcesrv_sock_get_peer_addr(struct dcesrv_connection *dcesrv_conn, TALLOC_CTX *mem_ctx)
95 struct stream_connection *srv_conn;
96 srv_conn = talloc_get_type(dcesrv_conn->transport.private_data,
97 struct stream_connection);
99 return socket_get_peer_addr(srv_conn->socket, mem_ctx);
102 static void dcesrv_sock_accept(struct stream_connection *srv_conn)
105 struct dcesrv_socket_context *dcesrv_sock =
106 talloc_get_type(srv_conn->private, struct dcesrv_socket_context);
107 struct dcesrv_connection *dcesrv_conn = NULL;
108 struct auth_session_info *session_info = NULL;
110 status = auth_anonymous_session_info(srv_conn, dcesrv_sock->dcesrv_ctx->lp_ctx, &session_info);
111 if (!NT_STATUS_IS_OK(status)) {
112 DEBUG(0,("dcesrv_sock_accept: auth_anonymous_session_info failed: %s\n",
114 stream_terminate_connection(srv_conn, nt_errstr(status));
118 status = dcesrv_endpoint_connect(dcesrv_sock->dcesrv_ctx,
120 dcesrv_sock->endpoint,
125 DCESRV_CALL_STATE_FLAG_MAY_ASYNC,
127 if (!NT_STATUS_IS_OK(status)) {
128 DEBUG(0,("dcesrv_sock_accept: dcesrv_endpoint_connect failed: %s\n",
130 stream_terminate_connection(srv_conn, nt_errstr(status));
134 dcesrv_conn->transport.private_data = srv_conn;
135 dcesrv_conn->transport.report_output_data = dcesrv_sock_report_output_data;
136 dcesrv_conn->transport.get_my_addr = dcesrv_sock_get_my_addr;
137 dcesrv_conn->transport.get_peer_addr = dcesrv_sock_get_peer_addr;
139 srv_conn->private = dcesrv_conn;
141 irpc_add_name(srv_conn->msg_ctx, "rpc_server");
146 static void dcesrv_sock_recv(struct stream_connection *conn, uint16_t flags)
149 struct dcesrv_connection *dce_conn = talloc_get_type(conn->private, struct dcesrv_connection);
153 if (dce_conn->processing) {
154 EVENT_FD_NOT_READABLE(conn->event.fde);
158 tmp_blob = data_blob_talloc(conn->socket, NULL, 0x1000);
159 if (tmp_blob.data == NULL) {
160 dcesrv_terminate_connection(dce_conn, "out of memory");
164 status = socket_recv(conn->socket, tmp_blob.data, tmp_blob.length, &nread);
165 if (NT_STATUS_IS_ERR(status)) {
166 dcesrv_terminate_connection(dce_conn, nt_errstr(status));
170 talloc_free(tmp_blob.data);
174 tmp_blob.length = nread;
176 dce_conn->processing = true;
177 status = dcesrv_input(dce_conn, &tmp_blob);
178 dce_conn->processing = false;
179 talloc_free(tmp_blob.data);
181 EVENT_FD_READABLE(conn->event.fde);
183 if (!NT_STATUS_IS_OK(status)) {
184 dcesrv_terminate_connection(dce_conn, nt_errstr(status));
188 if (dce_conn->call_list && dce_conn->call_list->replies) {
189 EVENT_FD_WRITEABLE(conn->event.fde);
193 static void dcesrv_sock_send(struct stream_connection *conn, uint16_t flags)
195 struct dcesrv_connection *dce_conn = talloc_get_type(conn->private, struct dcesrv_connection);
198 status = dcesrv_output(dce_conn, conn->socket, dcerpc_write_fn);
199 if (NT_STATUS_IS_ERR(status)) {
200 dcesrv_terminate_connection(dce_conn, "eof on socket");
204 if (!dce_conn->call_list || !dce_conn->call_list->replies) {
205 EVENT_FD_NOT_WRITEABLE(conn->event.fde);
210 static const struct stream_server_ops dcesrv_stream_ops = {
212 .accept_connection = dcesrv_sock_accept,
213 .recv_handler = dcesrv_sock_recv,
214 .send_handler = dcesrv_sock_send,
219 static NTSTATUS dcesrv_add_ep_unix(struct dcesrv_context *dce_ctx,
220 struct loadparm_context *lp_ctx,
221 struct dcesrv_endpoint *e,
222 struct event_context *event_ctx, const struct model_ops *model_ops)
224 struct dcesrv_socket_context *dcesrv_sock;
228 dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
229 NT_STATUS_HAVE_NO_MEMORY(dcesrv_sock);
231 /* remember the endpoint of this socket */
232 dcesrv_sock->endpoint = e;
233 dcesrv_sock->dcesrv_ctx = talloc_reference(dcesrv_sock, dce_ctx);
235 status = stream_setup_socket(event_ctx, lp_ctx,
236 model_ops, &dcesrv_stream_ops,
237 "unix", e->ep_description->endpoint, &port,
238 lp_socket_options(lp_ctx),
240 if (!NT_STATUS_IS_OK(status)) {
241 DEBUG(0,("service_setup_stream_socket(path=%s) failed - %s\n",
242 e->ep_description->endpoint, nt_errstr(status)));
248 static NTSTATUS dcesrv_add_ep_ncalrpc(struct dcesrv_context *dce_ctx,
249 struct loadparm_context *lp_ctx,
250 struct dcesrv_endpoint *e,
251 struct event_context *event_ctx, const struct model_ops *model_ops)
253 struct dcesrv_socket_context *dcesrv_sock;
258 if (!e->ep_description->endpoint) {
259 /* No identifier specified: use DEFAULT.
260 * DO NOT hardcode this value anywhere else. Rather, specify
261 * no endpoint and let the epmapper worry about it. */
262 e->ep_description->endpoint = talloc_strdup(dce_ctx, "DEFAULT");
265 full_path = talloc_asprintf(dce_ctx, "%s/%s", lp_ncalrpc_dir(lp_ctx),
266 e->ep_description->endpoint);
268 dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
269 NT_STATUS_HAVE_NO_MEMORY(dcesrv_sock);
271 /* remember the endpoint of this socket */
272 dcesrv_sock->endpoint = e;
273 dcesrv_sock->dcesrv_ctx = talloc_reference(dcesrv_sock, dce_ctx);
275 status = stream_setup_socket(event_ctx, lp_ctx,
276 model_ops, &dcesrv_stream_ops,
277 "unix", full_path, &port,
278 lp_socket_options(lp_ctx),
280 if (!NT_STATUS_IS_OK(status)) {
281 DEBUG(0,("service_setup_stream_socket(identifier=%s,path=%s) failed - %s\n",
282 e->ep_description->endpoint, full_path, nt_errstr(status)));
289 add a socket address to the list of events, one event per dcerpc endpoint
291 static NTSTATUS add_socket_rpc_pipe_iface(struct dcesrv_context *dce_ctx, struct dcesrv_endpoint *e,
292 struct event_context *event_ctx, const struct model_ops *model_ops)
294 struct dcesrv_socket_context *dcesrv_sock;
297 if (e->ep_description->endpoint == NULL) {
298 DEBUG(0, ("Endpoint mandatory for named pipes\n"));
299 return NT_STATUS_INVALID_PARAMETER;
302 dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
303 NT_STATUS_HAVE_NO_MEMORY(dcesrv_sock);
305 /* remember the endpoint of this socket */
306 dcesrv_sock->endpoint = e;
307 dcesrv_sock->dcesrv_ctx = talloc_reference(dcesrv_sock, dce_ctx);
309 status = NT_STATUS_OK;
312 status = stream_setup_smb_pipe(event_ctx, model_ops, &dcesrv_stream_ops,
313 e->ep_description->endpoint, dcesrv_sock);
314 if (!NT_STATUS_IS_OK(status)) {
315 DEBUG(0,("service_setup_stream_socket(path=%s) failed - %s\n",
316 e->ep_description->endpoint, nt_errstr(status)));
322 static NTSTATUS dcesrv_add_ep_np(struct dcesrv_context *dce_ctx,
323 struct loadparm_context *lp_ctx,
324 struct dcesrv_endpoint *e,
325 struct event_context *event_ctx, const struct model_ops *model_ops)
329 status = add_socket_rpc_pipe_iface(dce_ctx, e, event_ctx, model_ops);
330 NT_STATUS_NOT_OK_RETURN(status);
336 add a socket address to the list of events, one event per dcerpc endpoint
338 static NTSTATUS add_socket_rpc_tcp_iface(struct dcesrv_context *dce_ctx, struct dcesrv_endpoint *e,
339 struct event_context *event_ctx, const struct model_ops *model_ops,
342 struct dcesrv_socket_context *dcesrv_sock;
346 if (e->ep_description->endpoint) {
347 port = atoi(e->ep_description->endpoint);
350 dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
351 NT_STATUS_HAVE_NO_MEMORY(dcesrv_sock);
353 /* remember the endpoint of this socket */
354 dcesrv_sock->endpoint = e;
355 dcesrv_sock->dcesrv_ctx = talloc_reference(dcesrv_sock, dce_ctx);
357 status = stream_setup_socket(event_ctx, dce_ctx->lp_ctx,
358 model_ops, &dcesrv_stream_ops,
359 "ipv4", address, &port,
360 lp_socket_options(dce_ctx->lp_ctx),
362 if (!NT_STATUS_IS_OK(status)) {
363 DEBUG(0,("service_setup_stream_socket(address=%s,port=%u) failed - %s\n",
364 address, port, nt_errstr(status)));
367 if (e->ep_description->endpoint == NULL) {
368 e->ep_description->endpoint = talloc_asprintf(dce_ctx, "%d", port);
374 static NTSTATUS dcesrv_add_ep_tcp(struct dcesrv_context *dce_ctx,
375 struct loadparm_context *lp_ctx,
376 struct dcesrv_endpoint *e,
377 struct event_context *event_ctx, const struct model_ops *model_ops)
381 /* Add TCP/IP sockets */
382 if (lp_interfaces(lp_ctx) && lp_bind_interfaces_only(lp_ctx)) {
385 struct interface *ifaces;
387 load_interfaces(dce_ctx, lp_interfaces(lp_ctx), &ifaces);
389 num_interfaces = iface_count(ifaces);
390 for(i = 0; i < num_interfaces; i++) {
391 const char *address = iface_n_ip(ifaces, i);
392 status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx, model_ops, address);
393 NT_STATUS_NOT_OK_RETURN(status);
396 status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx, model_ops,
397 lp_socket_address(lp_ctx));
398 NT_STATUS_NOT_OK_RETURN(status);
405 static NTSTATUS dcesrv_add_ep(struct dcesrv_context *dce_ctx,
406 struct loadparm_context *lp_ctx,
407 struct dcesrv_endpoint *e,
408 struct event_context *event_ctx, const struct model_ops *model_ops)
410 switch (e->ep_description->transport) {
411 case NCACN_UNIX_STREAM:
412 return dcesrv_add_ep_unix(dce_ctx, lp_ctx, e, event_ctx, model_ops);
415 return dcesrv_add_ep_ncalrpc(dce_ctx, lp_ctx, e, event_ctx, model_ops);
418 return dcesrv_add_ep_tcp(dce_ctx, lp_ctx, e, event_ctx, model_ops);
421 return dcesrv_add_ep_np(dce_ctx, lp_ctx, e, event_ctx, model_ops);
424 return NT_STATUS_NOT_SUPPORTED;
429 open the dcerpc server sockets
431 static void dcesrv_task_init(struct task_server *task)
434 struct dcesrv_context *dce_ctx;
435 struct dcesrv_endpoint *e;
437 task_server_set_title(task, "task[dcesrv]");
439 status = dcesrv_init_context(task->event_ctx,
441 lp_dcerpc_endpoint_servers(task->lp_ctx),
443 if (!NT_STATUS_IS_OK(status)) goto failed;
445 /* Make sure the directory for NCALRPC exists */
446 if (!directory_exist(lp_ncalrpc_dir(task->lp_ctx))) {
447 mkdir(lp_ncalrpc_dir(task->lp_ctx), 0755);
450 for (e=dce_ctx->endpoint_list;e;e=e->next) {
451 status = dcesrv_add_ep(dce_ctx, task->lp_ctx, e, task->event_ctx, task->model_ops);
452 if (!NT_STATUS_IS_OK(status)) goto failed;
457 task_server_terminate(task, "Failed to startup dcerpc server task");
461 called on startup of the smb server service It's job is to start
462 listening on all configured sockets
464 static NTSTATUS dcesrv_init(struct event_context *event_context,
465 struct loadparm_context *lp_ctx,
466 const struct model_ops *model_ops)
468 return task_server_startup(event_context, lp_ctx, "rpc",
469 model_ops, dcesrv_task_init);
472 NTSTATUS server_service_rpc_init(void)
474 init_module_fn static_init[] = { STATIC_dcerpc_server_MODULES };
475 init_module_fn *shared_init = load_samba_modules(NULL, global_loadparm, "dcerpc_server");
477 run_init_functions(static_init);
478 run_init_functions(shared_init);
480 talloc_free(shared_init);
482 return register_server_service("rpc", dcesrv_init);