Return the same privilaged winbindd socket as we actually use.
[kai/samba.git] / source4 / winbind / wb_server.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Main winbindd server routines
4
5    Copyright (C) Stefan Metzmacher      2005
6    Copyright (C) Andrew Tridgell        2005
7    
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.
12    
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.
17    
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/>.
20 */
21
22 #include "includes.h"
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"
35
36 void wbsrv_terminate_connection(struct wbsrv_connection *wbconn, const char *reason)
37 {
38         stream_terminate_connection(wbconn->conn, reason);
39 }
40
41 /*
42   called on a tcp recv error
43 */
44 static void wbsrv_recv_error(void *private, NTSTATUS status)
45 {
46         struct wbsrv_connection *wbconn = talloc_get_type(private, struct wbsrv_connection);
47         wbsrv_terminate_connection(wbconn, nt_errstr(status));
48 }
49
50 static void wbsrv_accept(struct stream_connection *conn)
51 {
52         struct wbsrv_listen_socket *listen_socket = talloc_get_type(conn->private, 
53                                                                     struct wbsrv_listen_socket);
54         struct wbsrv_connection *wbconn;
55
56         wbconn = talloc_zero(conn, struct wbsrv_connection);
57         if (!wbconn) {
58                 stream_terminate_connection(conn, "wbsrv_accept: out of memory");
59                 return;
60         }
61         wbconn->conn          = conn;
62         wbconn->listen_socket = listen_socket;
63         wbconn->lp_ctx        = listen_socket->service->task->lp_ctx;
64         conn->private         = wbconn;
65
66         wbconn->packet = packet_init(wbconn);
67         if (wbconn->packet == NULL) {
68                 wbsrv_terminate_connection(wbconn, "wbsrv_accept: out of memory");
69                 return;
70         }
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);
79 }
80
81 /*
82   receive some data on a winbind connection
83 */
84 static void wbsrv_recv(struct stream_connection *conn, uint16_t flags)
85 {
86         struct wbsrv_connection *wbconn = talloc_get_type(conn->private, 
87                                                           struct wbsrv_connection);
88         packet_recv(wbconn->packet);
89
90 }
91
92 /*
93   called when we can write to a connection
94 */
95 static void wbsrv_send(struct stream_connection *conn, uint16_t flags)
96 {
97         struct wbsrv_connection *wbconn = talloc_get_type(conn->private, 
98                                                           struct wbsrv_connection);
99         packet_queue_run(wbconn->packet);
100 }
101
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
107 };
108
109 /*
110   startup the winbind task
111 */
112 static void winbind_task_init(struct task_server *task)
113 {
114         uint16_t port = 1;
115         const struct model_ops *model_ops;
116         NTSTATUS status;
117         struct wbsrv_service *service;
118         struct wbsrv_listen_socket *listen_socket;
119
120         task_server_set_title(task, "task[winbind]");
121
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_byname("single");
126         if (!model_ops) {
127                 task_server_terminate(task,
128                                       "Can't find 'single' process model_ops");
129                 return;
130         }
131
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");
136                 return;
137         }
138
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");
143                 return;
144         }
145
146         service = talloc_zero(task, struct wbsrv_service);
147         if (!service) goto nomem;
148         service->task   = task;
149
150         service->primary_sid = secrets_get_domain_sid(service,
151                                                       task->event_ctx,
152                                                       task->lp_ctx,
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));
157                 return;
158         }
159
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");
163                 return;
164         }
165
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,
176                                      &wbsrv_ops, "unix",
177                                      listen_socket->socket_path, &port,
178                                      lp_socket_options(task->lp_ctx), 
179                                      listen_socket);
180         if (!NT_STATUS_IS_OK(status)) goto listen_failed;
181
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,
195                                      &wbsrv_ops, "unix",
196                                      listen_socket->socket_path, &port,
197                                      lp_socket_options(task->lp_ctx), 
198                                      listen_socket);
199         if (!NT_STATUS_IS_OK(status)) goto listen_failed;
200
201         status = wbsrv_init_irpc(service);
202         if (!NT_STATUS_IS_OK(status)) goto irpc_failed;
203
204         return;
205
206 listen_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));
210         return;
211 irpc_failed:
212         DEBUG(0,("wbsrv_init_irpc() failed - %s\n",
213                  nt_errstr(status)));
214         task_server_terminate(task, nt_errstr(status));
215         return;
216 nomem:
217         task_server_terminate(task, nt_errstr(NT_STATUS_NO_MEMORY));
218         return;
219 }
220
221 /*
222   register ourselves as a available server
223 */
224 NTSTATUS server_service_winbind_init(void)
225 {
226         return register_server_service("winbind", winbind_task_init);
227 }