*/
#include "includes.h"
+#include "lib/socket/socket.h"
+#include "system/dir.h"
#include "system/filesys.h"
#include "dlinklist.h"
#include "lib/events/events.h"
#include "smbd/service_task.h"
#include "smbd/service_stream.h"
+#include "nsswitch/winbind_nss_config.h"
+#include "nsswitch/winbindd_nss.h"
+#include "winbind/wb_server.h"
-#define WINBINDD_DIR "/tmp/.winbindd/"
-#define WINBINDD_ECHO_SOCKET WINBINDD_DIR"echo"
-#define WINBINDD_ADDR_PREFIX "127.0.255."
-#define WINBINDD_ECHO_ADDR WINBINDD_ADDR_PREFIX"1"
-#define WINBINDD_ECHO_PORT 55555
-
-/*
- state of an open winbind connection
-*/
-struct wbserver_connection {
- DATA_BLOB blob;
- struct send_queue {
- struct send_queue *next, *prev;
- DATA_BLOB blob;
- } *queue;
-};
-
+void wbsrv_terminate_connection(struct wbsrv_connection *wbconn, const char *reason)
+{
+ stream_terminate_connection(wbconn->conn, reason);
+}
/*
called when we get a new connection
*/
-static void winbind_accept(struct stream_connection *conn)
+static void wbsrv_accept(struct stream_connection *conn)
{
- struct wbserver_connection *wbconn;
+ struct wbsrv_listen_socket *listen_socket =
+ talloc_get_type(conn->private, struct wbsrv_listen_socket);
+ struct wbsrv_connection *wbconn;
- wbconn = talloc_zero(conn, struct wbserver_connection);
- wbconn->blob = data_blob_talloc(wbconn, NULL, 1024);
-
+ wbconn = talloc_zero(conn, struct wbsrv_connection);
+ if (!wbconn) {
+ stream_terminate_connection(conn,
+ "wbsrv_accept: out of memory");
+ return;
+ }
+ wbconn->conn = conn;
+ wbconn->listen_socket = listen_socket;
conn->private = wbconn;
}
/*
receive some data on a winbind connection
*/
-static void winbind_recv(struct stream_connection *conn, uint16_t flags)
+static void wbsrv_recv(struct stream_connection *conn, uint16_t flags)
{
- struct wbserver_connection *wbconn = talloc_get_type(conn->private, struct wbserver_connection);
- NTSTATUS status;
+ struct wbsrv_connection *wbconn =
+ talloc_get_type(conn->private, struct wbsrv_connection);
+ const struct wbsrv_protocol_ops *ops = wbconn->listen_socket->ops;
+ struct wbsrv_call *call;
+ NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
size_t nread;
- struct send_queue *q;
- status = socket_recv(conn->socket, wbconn->blob.data, wbconn->blob.length, &nread, 0);
- if (NT_STATUS_IS_ERR(status)) {
- DEBUG(10,("socket_recv: %s\n",nt_errstr(status)));
- stream_terminate_connection(conn, "socket_recv: failed\n");
+ /* avoid recursion, because of half async code */
+ if (wbconn->processing) {
+ EVENT_FD_NOT_READABLE(conn->event.fde);
return;
}
- /* just reflect the data back down the socket */
- q = talloc(wbconn, struct send_queue);
- if (q == NULL) {
- stream_terminate_connection(conn, "winbind_recv: out of memory\n");
+ /* if the used protocol doesn't support pending requests disallow
+ * them */
+ if (wbconn->pending_calls && !ops->allow_pending_calls) {
+ EVENT_FD_NOT_READABLE(conn->event.fde);
return;
}
- q->blob = data_blob_talloc(q, wbconn->blob.data, nread);
- if (q->blob.data == NULL) {
- stream_terminate_connection(conn, "winbind_recv: out of memory\n");
+ if (wbconn->partial.length == 0) {
+ wbconn->partial = data_blob_talloc(wbconn, NULL, 4);
+ if (!wbconn->partial.data) goto nomem;
+
+ wbconn->partial_read = 0;
+ }
+
+ /* read in the packet length */
+ if (wbconn->partial_read < 4) {
+ uint32_t packet_length;
+
+ status = socket_recv(conn->socket,
+ wbconn->partial.data+wbconn->partial_read,
+ 4 - wbconn->partial_read,
+ &nread, 0);
+ if (NT_STATUS_IS_ERR(status)) goto failed;
+ if (!NT_STATUS_IS_OK(status)) return;
+
+ wbconn->partial_read += nread;
+ if (wbconn->partial_read != 4) return;
+
+ packet_length = ops->packet_length(wbconn->partial);
+
+ wbconn->partial.data =
+ talloc_realloc(wbconn, wbconn->partial.data, uint8_t,
+ packet_length);
+ if (!wbconn->partial.data) goto nomem;
+
+ wbconn->partial.length = packet_length;
+ }
+
+ /* read in the body */
+ status = socket_recv(conn->socket,
+ wbconn->partial.data + wbconn->partial_read,
+ wbconn->partial.length - wbconn->partial_read,
+ &nread, 0);
+ if (NT_STATUS_IS_ERR(status)) goto failed;
+ if (!NT_STATUS_IS_OK(status)) return;
+
+ wbconn->partial_read += nread;
+ if (wbconn->partial_read != wbconn->partial.length) return;
+
+ /* we have a full request - parse it */
+ status = ops->pull_request(wbconn->partial, wbconn, &call);
+ if (!NT_STATUS_IS_OK(status)) goto failed;
+ call->wbconn = wbconn;
+ call->event_ctx = conn->event.ctx;
+
+ /*
+ * we have parsed the request, so we can reset the
+ * wbconn->partial_read, maybe we could also free wbconn->partial, but
+ * for now we keep it, and overwrite it the next time
+ */
+ wbconn->partial_read = 0;
+
+ /* actually process the request */
+ wbconn->pending_calls++;
+ wbconn->processing = True;
+ status = ops->handle_call(call);
+ wbconn->processing = False;
+ if (!NT_STATUS_IS_OK(status)) goto failed;
+
+ /* if the backend want to reply later just return here */
+ if (call->flags & WBSRV_CALL_FLAGS_REPLY_ASYNC) {
return;
}
- DLIST_ADD_END(wbconn->queue, q, struct send_queue *);
+ /*
+ * and queue the reply, this implies talloc_free(call),
+ * and set the socket to readable again
+ */
+ status = wbsrv_send_reply(call);
+ if (!NT_STATUS_IS_OK(status)) goto failed;
- EVENT_FD_WRITEABLE(conn->event.fde);
+ return;
+nomem:
+ status = NT_STATUS_NO_MEMORY;
+failed:
+ wbsrv_terminate_connection(wbconn, nt_errstr(status));
+}
+
+/*
+ * queue a wbsrv_call reply on a wbsrv_connection
+ * NOTE: that this implies talloc_free(call),
+ * use talloc_reference(call) if you need it after
+ * calling wbsrv_queue_reply
+ * NOTE: if this function desn't return NT_STATUS_OK,
+ * the caller needs to call
+ * wbsrv_terminate_connection(call->wbconn, "reason...");
+ * return;
+ * to drop the connection
+ */
+NTSTATUS wbsrv_send_reply(struct wbsrv_call *call)
+{
+ struct wbsrv_connection *wbconn = call->wbconn;
+ const struct wbsrv_protocol_ops *ops = wbconn->listen_socket->ops;
+ struct data_blob_list_item *rep;
+ NTSTATUS status;
+
+ /* and now encode the reply */
+ rep = talloc(wbconn, struct data_blob_list_item);
+ NT_STATUS_HAVE_NO_MEMORY(rep);
+
+ status = ops->push_reply(call, rep, &rep->blob);
+ NT_STATUS_NOT_OK_RETURN(status);
+
+ if (!wbconn->send_queue) {
+ EVENT_FD_WRITEABLE(wbconn->conn->event.fde);
+ }
+ DLIST_ADD_END(wbconn->send_queue, rep, struct data_blob_list_item *);
+
+ EVENT_FD_READABLE(wbconn->conn->event.fde);
+
+ /* the call isn't needed any more */
+ wbconn->pending_calls--;
+ talloc_free(call);
+ return NT_STATUS_OK;
}
/*
called when we can write to a connection
*/
-static void winbind_send(struct stream_connection *conn, uint16_t flags)
+static void wbsrv_send(struct stream_connection *conn, uint16_t flags)
{
- struct wbserver_connection *wbconn = talloc_get_type(conn->private, struct wbserver_connection);
+ struct wbsrv_connection *wbconn = talloc_get_type(conn->private, struct wbsrv_connection);
+ NTSTATUS status;
- while (wbconn->queue) {
- struct send_queue *q = wbconn->queue;
- NTSTATUS status;
+ while (wbconn->send_queue) {
+ struct data_blob_list_item *q = wbconn->send_queue;
size_t sendlen;
status = socket_send(conn->socket, &q->blob, &sendlen, 0);
- if (NT_STATUS_IS_ERR(status)) {
- DEBUG(10,("socket_send() %s\n",nt_errstr(status)));
- stream_terminate_connection(conn, "socket_send: failed\n");
- return;
- }
- if (!NT_STATUS_IS_OK(status)) {
- return;
- }
+ if (NT_STATUS_IS_ERR(status)) goto failed;
+ if (!NT_STATUS_IS_OK(status)) return;
q->blob.length -= sendlen;
q->blob.data += sendlen;
if (q->blob.length == 0) {
- DLIST_REMOVE(wbconn->queue, q);
+ DLIST_REMOVE(wbconn->send_queue, q);
talloc_free(q);
}
}
EVENT_FD_NOT_WRITEABLE(conn->event.fde);
+ return;
+failed:
+ wbsrv_terminate_connection(wbconn, nt_errstr(status));
}
-static const struct stream_server_ops winbind_stream_ops = {
- .name = "winbind_echo",
- .accept_connection = winbind_accept,
- .recv_handler = winbind_recv,
- .send_handler = winbind_send,
+static const struct stream_server_ops wbsrv_ops = {
+ .name = "winbind",
+ .accept_connection = wbsrv_accept,
+ .recv_handler = wbsrv_recv,
+ .send_handler = wbsrv_send
+};
+
+static const struct wbsrv_protocol_ops wbsrv_samba3_protocol_ops = {
+ .name = "winbind samba3 protocol",
+ .allow_pending_calls = False,
+ .packet_length = wbsrv_samba3_packet_length,
+ .pull_request = wbsrv_samba3_pull_request,
+ .handle_call = wbsrv_samba3_handle_call,
+ .push_reply = wbsrv_samba3_push_reply
};
/*
uint16_t port = 1;
const struct model_ops *model_ops;
NTSTATUS status;
+ struct wbsrv_service *service;
+ struct wbsrv_listen_socket *listen_socket;
/* within the winbind task we want to be a single process, so
ask for the single process model ops and pass these to the
stream_setup_socket() call. */
model_ops = process_model_byname("single");
if (!model_ops) {
- task_terminate(task, "Can't find 'single' process model_ops");
+ task_server_terminate(task,
+ "Can't find 'single' process model_ops");
return;
}
/* Make sure the directory for NCALRPC exists */
- if (!directory_exist(WINBINDD_DIR, NULL)) {
+ if (!directory_exist(WINBINDD_DIR)) {
mkdir(WINBINDD_DIR, 0755);
}
- status = stream_setup_socket(task->event_ctx, model_ops, &winbind_stream_ops,
- "unix", WINBINDD_ECHO_SOCKET, &port, NULL);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0,("service_setup_stream_socket(path=%s) failed - %s\n",
- WINBINDD_ECHO_SOCKET, nt_errstr(status)));
- task_terminate(task, "winbind Failed to find to ECHO unix socket");
+ service = talloc_zero(task, struct wbsrv_service);
+ if (!service) goto nomem;
+ service->task = task;
+
+ service->primary_sid = secrets_get_domain_sid(service,
+ lp_workgroup());
+ if (service->primary_sid == NULL) {
+ task_server_terminate(
+ task, nt_errstr(NT_STATUS_CANT_ACCESS_DOMAIN_INFO));
return;
}
- port = WINBINDD_ECHO_PORT;
+ /* setup the unprivileged samba3 socket */
+ listen_socket = talloc(service, struct wbsrv_listen_socket);
+ if (!listen_socket) goto nomem;
+ listen_socket->socket_path = WINBINDD_SAMBA3_SOCKET;
+ if (!listen_socket->socket_path) goto nomem;
+ listen_socket->service = service;
+ listen_socket->privileged = False;
+ listen_socket->ops = &wbsrv_samba3_protocol_ops;
+ status = stream_setup_socket(task->event_ctx, model_ops,
+ &wbsrv_ops, "unix",
+ listen_socket->socket_path, &port,
+ listen_socket);
+ if (!NT_STATUS_IS_OK(status)) goto listen_failed;
- status = stream_setup_socket(task->event_ctx, model_ops, &winbind_stream_ops,
- "ipv4", WINBINDD_ECHO_ADDR, &port, NULL);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0,("service_setup_stream_socket(address=%s,port=%u) failed - %s\n",
- WINBINDD_ECHO_ADDR, port, nt_errstr(status)));
- task_terminate(task, "winbind Failed to find to ECHO tcp socket");
- return;
- }
+ /* setup the privileged samba3 socket */
+ listen_socket = talloc(service, struct wbsrv_listen_socket);
+ if (!listen_socket) goto nomem;
+ listen_socket->socket_path =
+ smbd_tmp_path(listen_socket,
+ WINBINDD_SAMBA3_PRIVILEGED_SOCKET);
+ if (!listen_socket->socket_path) goto nomem;
+ listen_socket->service = service;
+ listen_socket->privileged = True;
+ listen_socket->ops = &wbsrv_samba3_protocol_ops;
+ status = stream_setup_socket(task->event_ctx, model_ops,
+ &wbsrv_ops, "unix",
+ listen_socket->socket_path, &port,
+ listen_socket);
+ if (!NT_STATUS_IS_OK(status)) goto listen_failed;
+
+ return;
+
+listen_failed:
+ DEBUG(0,("stream_setup_socket(path=%s) failed - %s\n",
+ listen_socket->socket_path, nt_errstr(status)));
+ task_server_terminate(task, nt_errstr(status));
+ return;
+nomem:
+ task_server_terminate(task, nt_errstr(NT_STATUS_NO_MEMORY));
+ return;
}
/*
initialise the winbind server
*/
-static NTSTATUS winbind_init(struct event_context *event_ctx, const struct model_ops *model_ops)
+static NTSTATUS winbind_init(struct event_context *event_ctx,
+ const struct model_ops *model_ops)
{
return task_server_startup(event_ctx, model_ops, winbind_task_init);
}
git.samba.org / bbaumbach / samba-autobuild / .git / blobdiff