source/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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "dlinklist.h"
  25 #include "lib/events/events.h"
  26 #include "smbd/service_task.h"
  27 #include "smbd/service_stream.h"
  28
  29 #define WINBINDD_DIR "/tmp/.winbindd/"
  30 #define WINBINDD_ECHO_SOCKET  WINBINDD_DIR"echo"
  31 #define WINBINDD_ADDR_PREFIX "127.0.255."
  32 #define WINBINDD_ECHO_ADDR WINBINDD_ADDR_PREFIX"1"
  33 #define WINBINDD_ECHO_PORT 55555
  34
  35 /*
  36   state of an open winbind connection
  37 */
  38 struct wbserver_connection {
  39         DATA_BLOB blob;
  40         struct send_queue {
  41                 struct send_queue *next, *prev;
  42                 DATA_BLOB blob;
  43         } *queue;
  44 };
  45
  46
  47 /*
  48   called when we get a new connection
  49 */
  50 static void winbind_accept(struct stream_connection *conn)
  51 {
  52         struct wbserver_connection *wbconn;
  53
  54         wbconn = talloc_zero(conn, struct wbserver_connection);
  55         wbconn->blob = data_blob_talloc(wbconn, NULL, 1024);
  56
  57         conn->private = wbconn;
  58 }
  59
  60 /*
  61   receive some data on a winbind connection
  62 */
  63 static void winbind_recv(struct stream_connection *conn, uint16_t flags)
  64 {
  65         struct wbserver_connection *wbconn = talloc_get_type(conn->private, struct wbserver_connection);
  66         NTSTATUS status;
  67         size_t nread;
  68         struct send_queue *q;
  69
  70         status = socket_recv(conn->socket, wbconn->blob.data, wbconn->blob.length, &nread, 0);
  71         if (NT_STATUS_IS_ERR(status)) {
  72                 DEBUG(10,("socket_recv: %s\n",nt_errstr(status)));
  73                 stream_terminate_connection(conn, "socket_recv: failed\n");
  74                 return;
  75         }
  76
  77         /* just reflect the data back down the socket */
  78         q = talloc(wbconn, struct send_queue);
  79         if (q == NULL) {
  80                 stream_terminate_connection(conn, "winbind_recv: out of memory\n");
  81                 return;
  82         }
  83
  84         q->blob = data_blob_talloc(q, wbconn->blob.data, nread);
  85         if (q->blob.data == NULL) {
  86                 stream_terminate_connection(conn, "winbind_recv: out of memory\n");
  87                 return;
  88         }
  89
  90         DLIST_ADD_END(wbconn->queue, q, struct send_queue *);
  91
  92         EVENT_FD_WRITEABLE(conn->event.fde);
  93 }
  94
  95 /*
  96   called when we can write to a connection
  97 */
  98 static void winbind_send(struct stream_connection *conn, uint16_t flags)
  99 {
 100         struct wbserver_connection *wbconn = talloc_get_type(conn->private, struct wbserver_connection);
 101
 102         while (wbconn->queue) {
 103                 struct send_queue *q = wbconn->queue;
 104                 NTSTATUS status;
 105                 size_t sendlen;
 106
 107                 status = socket_send(conn->socket, &q->blob, &sendlen, 0);
 108                 if (NT_STATUS_IS_ERR(status)) {
 109                         DEBUG(10,("socket_send() %s\n",nt_errstr(status)));
 110                         stream_terminate_connection(conn, "socket_send: failed\n");
 111                         return;
 112                 }
 113                 if (!NT_STATUS_IS_OK(status)) {
 114                         return;
 115                 }
 116
 117                 q->blob.length -= sendlen;
 118                 q->blob.data   += sendlen;
 119
 120                 if (q->blob.length == 0) {
 121                         DLIST_REMOVE(wbconn->queue, q);
 122                         talloc_free(q);
 123                 }
 124         }
 125
 126         EVENT_FD_NOT_WRITEABLE(conn->event.fde);
 127 }
 128
 129 static const struct stream_server_ops winbind_stream_ops = {
 130         .name                   = "winbind_echo",
 131         .accept_connection      = winbind_accept,
 132         .recv_handler           = winbind_recv,
 133         .send_handler           = winbind_send,
 134 };
 135
 136 /*
 137   startup the winbind task
 138 */
 139 static void winbind_task_init(struct task_server *task)
 140 {
 141         uint16_t port = 1;
 142         const struct model_ops *model_ops;
 143         NTSTATUS status;
 144
 145         /* within the winbind task we want to be a single process, so
 146            ask for the single process model ops and pass these to the
 147            stream_setup_socket() call. */
 148         model_ops = process_model_byname("single");
 149         if (!model_ops) {
 150                 task_terminate(task, "Can't find 'single' process model_ops");
 151                 return;
 152         }
 153
 154         /* Make sure the directory for NCALRPC exists */
 155         if (!directory_exist(WINBINDD_DIR, NULL)) {
 156                 mkdir(WINBINDD_DIR, 0755);
 157         }
 158
 159         status = stream_setup_socket(task->event_ctx, model_ops, &winbind_stream_ops,
 160                                      "unix", WINBINDD_ECHO_SOCKET, &port, NULL);
 161         if (!NT_STATUS_IS_OK(status)) {
 162                 DEBUG(0,("service_setup_stream_socket(path=%s) failed - %s\n",
 163                          WINBINDD_ECHO_SOCKET, nt_errstr(status)));
 164                 task_terminate(task, "winbind Failed to find to ECHO unix socket");
 165                 return;
 166         }
 167
 168         port = WINBINDD_ECHO_PORT;
 169
 170         status = stream_setup_socket(task->event_ctx, model_ops, &winbind_stream_ops,
 171                                      "ipv4", WINBINDD_ECHO_ADDR, &port, NULL);
 172         if (!NT_STATUS_IS_OK(status)) {
 173                 DEBUG(0,("service_setup_stream_socket(address=%s,port=%u) failed - %s\n",
 174                          WINBINDD_ECHO_ADDR, port, nt_errstr(status)));
 175                 task_terminate(task, "winbind Failed to find to ECHO tcp socket");
 176                 return;
 177         }
 178 }
 179
 180 /*
 181   initialise the winbind server
 182  */
 183 static NTSTATUS winbind_init(struct event_context *event_ctx, const struct model_ops *model_ops)
 184 {
 185         return task_server_startup(event_ctx, model_ops, winbind_task_init);
 186 }
 187
 188 /*
 189   register ourselves as a available server
 190 */
 191 NTSTATUS server_service_winbind_init(void)
 192 {
 193         return register_server_service("winbind", winbind_init);
 194 }