2 Unix SMB/CIFS implementation.
3 Main winbindd server routines
5 Copyright (C) Stefan Metzmacher 2005
6 Copyright (C) Andrew Tridgell 2005
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "lib/socket/socket.h"
24 #include "../lib/util/dlinklist.h"
25 #include "lib/events/events.h"
26 #include "smbd/service_task.h"
27 #include "smbd/process_model.h"
28 #include "smbd/service_stream.h"
29 #include "nsswitch/winbind_nss_config.h"
30 #include "winbind/wb_server.h"
31 #include "lib/stream/packet.h"
32 #include "smbd/service.h"
33 #include "param/secrets.h"
34 #include "param/param.h"
36 void wbsrv_terminate_connection(struct wbsrv_connection
*wbconn
, const char *reason
)
38 stream_terminate_connection(wbconn
->conn
, reason
);
42 called on a tcp recv error
44 static void wbsrv_recv_error(void *private, NTSTATUS status
)
46 struct wbsrv_connection
*wbconn
= talloc_get_type(private, struct wbsrv_connection
);
47 wbsrv_terminate_connection(wbconn
, nt_errstr(status
));
50 static void wbsrv_accept(struct stream_connection
*conn
)
52 struct wbsrv_listen_socket
*listen_socket
= talloc_get_type(conn
->private,
53 struct wbsrv_listen_socket
);
54 struct wbsrv_connection
*wbconn
;
56 wbconn
= talloc_zero(conn
, struct wbsrv_connection
);
58 stream_terminate_connection(conn
, "wbsrv_accept: out of memory");
62 wbconn
->listen_socket
= listen_socket
;
63 wbconn
->lp_ctx
= listen_socket
->service
->task
->lp_ctx
;
64 conn
->private = wbconn
;
66 wbconn
->packet
= packet_init(wbconn
);
67 if (wbconn
->packet
== NULL
) {
68 wbsrv_terminate_connection(wbconn
, "wbsrv_accept: out of memory");
71 packet_set_private(wbconn
->packet
, wbconn
);
72 packet_set_socket(wbconn
->packet
, conn
->socket
);
73 packet_set_callback(wbconn
->packet
, wbsrv_samba3_process
);
74 packet_set_full_request(wbconn
->packet
, wbsrv_samba3_packet_full_request
);
75 packet_set_error_handler(wbconn
->packet
, wbsrv_recv_error
);
76 packet_set_event_context(wbconn
->packet
, conn
->event
.ctx
);
77 packet_set_fde(wbconn
->packet
, conn
->event
.fde
);
78 packet_set_serialise(wbconn
->packet
);
82 receive some data on a winbind connection
84 static void wbsrv_recv(struct stream_connection
*conn
, uint16_t flags
)
86 struct wbsrv_connection
*wbconn
= talloc_get_type(conn
->private,
87 struct wbsrv_connection
);
88 packet_recv(wbconn
->packet
);
93 called when we can write to a connection
95 static void wbsrv_send(struct stream_connection
*conn
, uint16_t flags
)
97 struct wbsrv_connection
*wbconn
= talloc_get_type(conn
->private,
98 struct wbsrv_connection
);
99 packet_queue_run(wbconn
->packet
);
102 static const struct stream_server_ops wbsrv_ops
= {
103 .name
= "winbind samba3 protocol",
104 .accept_connection
= wbsrv_accept
,
105 .recv_handler
= wbsrv_recv
,
106 .send_handler
= wbsrv_send
110 startup the winbind task
112 static void winbind_task_init(struct task_server
*task
)
115 const struct model_ops
*model_ops
;
117 struct wbsrv_service
*service
;
118 struct wbsrv_listen_socket
*listen_socket
;
120 task_server_set_title(task
, "task[winbind]");
122 /* within the winbind task we want to be a single process, so
123 ask for the single process model ops and pass these to the
124 stream_setup_socket() call. */
125 model_ops
= process_model_startup(task
->event_ctx
, "single");
127 task_server_terminate(task
,
128 "Can't find 'single' process model_ops");
132 /* Make sure the directory for the Samba3 socket exists, and is of the correct permissions */
133 if (!directory_create_or_exist(lp_winbindd_socket_directory(task
->lp_ctx
), geteuid(), 0755)) {
134 task_server_terminate(task
,
135 "Cannot create winbindd pipe directory");
139 /* Make sure the directory for the Samba3 socket exists, and is of the correct permissions */
140 if (!directory_create_or_exist(lp_winbindd_privileged_socket_directory(task
->lp_ctx
), geteuid(), 0750)) {
141 task_server_terminate(task
,
142 "Cannot create winbindd privileged pipe directory");
146 service
= talloc_zero(task
, struct wbsrv_service
);
147 if (!service
) goto nomem
;
148 service
->task
= task
;
150 service
->primary_sid
= secrets_get_domain_sid(service
,
153 lp_workgroup(task
->lp_ctx
));
154 if (service
->primary_sid
== NULL
) {
155 task_server_terminate(
156 task
, nt_errstr(NT_STATUS_CANT_ACCESS_DOMAIN_INFO
));
160 service
->idmap_ctx
= idmap_init(service
, task
->event_ctx
, task
->lp_ctx
);
161 if (service
->idmap_ctx
== NULL
) {
162 task_server_terminate(task
, "Failed to load idmap database");
166 /* setup the unprivileged samba3 socket */
167 listen_socket
= talloc(service
, struct wbsrv_listen_socket
);
168 if (!listen_socket
) goto nomem
;
169 listen_socket
->socket_path
= talloc_asprintf(listen_socket
, "%s/%s",
170 lp_winbindd_socket_directory(task
->lp_ctx
),
171 WINBINDD_SAMBA3_SOCKET
);
172 if (!listen_socket
->socket_path
) goto nomem
;
173 listen_socket
->service
= service
;
174 listen_socket
->privileged
= false;
175 status
= stream_setup_socket(task
->event_ctx
, task
->lp_ctx
, model_ops
,
177 listen_socket
->socket_path
, &port
,
178 lp_socket_options(task
->lp_ctx
),
180 if (!NT_STATUS_IS_OK(status
)) goto listen_failed
;
182 /* setup the privileged samba3 socket */
183 listen_socket
= talloc(service
, struct wbsrv_listen_socket
);
184 if (!listen_socket
) goto nomem
;
185 listen_socket
->socket_path
186 = service
->priv_socket_path
187 = talloc_asprintf(listen_socket
, "%s/%s",
188 lp_winbindd_privileged_socket_directory(task
->lp_ctx
),
189 WINBINDD_SAMBA3_SOCKET
);
190 if (!listen_socket
->socket_path
) goto nomem
;
191 if (!listen_socket
->socket_path
) goto nomem
;
192 listen_socket
->service
= service
;
193 listen_socket
->privileged
= true;
194 status
= stream_setup_socket(task
->event_ctx
, task
->lp_ctx
, model_ops
,
196 listen_socket
->socket_path
, &port
,
197 lp_socket_options(task
->lp_ctx
),
199 if (!NT_STATUS_IS_OK(status
)) goto listen_failed
;
201 status
= wbsrv_init_irpc(service
);
202 if (!NT_STATUS_IS_OK(status
)) goto irpc_failed
;
207 DEBUG(0,("stream_setup_socket(path=%s) failed - %s\n",
208 listen_socket
->socket_path
, nt_errstr(status
)));
209 task_server_terminate(task
, nt_errstr(status
));
212 DEBUG(0,("wbsrv_init_irpc() failed - %s\n",
214 task_server_terminate(task
, nt_errstr(status
));
217 task_server_terminate(task
, nt_errstr(NT_STATUS_NO_MEMORY
));
222 register ourselves as a available server
224 NTSTATUS
server_service_winbind_init(void)
226 return register_server_service("winbind", winbind_task_init
);