source4/libcli/raw/clisocket.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    SMB client socket context management functions
   5
   6    Copyright (C) Andrew Tridgell 1994-2005
   7    Copyright (C) James Myers 2003 <myersjj@samba.org>
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25 #include "events.h"
  26 #include "libcli/raw/libcliraw.h"
  27 #include "libcli/composite/composite.h"
  28
  29 /*
  30   this private structure is used during async connection handling
  31 */
  32 struct clisocket_connect {
  33         int port_num;
  34         int *iports;
  35         struct smbcli_socket *sock;
  36         const char *dest_host;
  37 };
  38
  39
  40 /*
  41   create a smbcli_socket context
  42   The event_ctx is optional - if not supplied one will be created
  43 */
  44 struct smbcli_socket *smbcli_sock_init(TALLOC_CTX *mem_ctx,
  45                                        struct event_context *event_ctx)
  46 {
  47         struct smbcli_socket *sock;
  48
  49         sock = talloc_zero(mem_ctx, struct smbcli_socket);
  50         if (!sock) {
  51                 return NULL;
  52         }
  53
  54         if (event_ctx) {
  55                 sock->event.ctx = talloc_reference(sock, event_ctx);
  56         } else {
  57                 sock->event.ctx = event_context_init(sock);
  58         }
  59         if (sock->event.ctx == NULL) {
  60                 talloc_free(sock);
  61                 return NULL;
  62         }
  63
  64         return sock;
  65 }
  66
  67 static NTSTATUS smbcli_sock_connect_one(struct smbcli_socket *sock,
  68                                         const char *hostaddr, int port,
  69                                         struct composite_context *c);
  70
  71 /*
  72   handle socket write events during an async connect. These happen when the OS
  73   has either completed the connect() or has returned an error
  74 */
  75 static void smbcli_sock_connect_handler(struct event_context *ev, struct fd_event *fde,
  76                                         uint16_t flags, void *private)
  77 {
  78         struct composite_context *c = talloc_get_type(private, struct composite_context);
  79         struct clisocket_connect *conn = talloc_get_type(c->private, struct clisocket_connect);
  80         int i;
  81
  82         c->status = socket_connect_complete(conn->sock->sock, 0);
  83         if (NT_STATUS_IS_OK(c->status)) {
  84                 socket_set_option(conn->sock->sock, lp_socket_options(), NULL);
  85                 conn->sock->hostname = talloc_strdup(conn->sock, conn->dest_host);
  86                 c->state = SMBCLI_REQUEST_DONE;
  87                 if (c->async.fn) {
  88                         c->async.fn(c);
  89                 }
  90                 return;
  91         }
  92
  93         /* that port failed - try the next port */
  94         for (i=conn->port_num+1;conn->iports[i];i++) {
  95                 conn->port_num = i;
  96                 c->status = smbcli_sock_connect_one(conn->sock,
  97                                                     conn->dest_host,
  98                                                     conn->iports[i], c);
  99                 if (NT_STATUS_IS_OK(c->status) ||
 100                     NT_STATUS_EQUAL(c->status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 101                         return;
 102                 }
 103         }
 104
 105         c->state = SMBCLI_REQUEST_ERROR;
 106         if (c->async.fn) {
 107                 c->async.fn(c);
 108         }
 109 }
 110
 111
 112 /*
 113   try to connect to the given address/port
 114 */
 115 static NTSTATUS smbcli_sock_connect_one(struct smbcli_socket *sock,
 116                                         const char *hostaddr, int port,
 117                                         struct composite_context *c)
 118 {
 119         NTSTATUS status;
 120
 121         if (sock->sock) {
 122                 talloc_free(sock->sock);
 123                 sock->sock = NULL;
 124         }
 125         talloc_free(sock->event.fde);
 126
 127         status = socket_create("ip", SOCKET_TYPE_STREAM, &sock->sock, 0);
 128         if (!NT_STATUS_IS_OK(status)) {
 129                 return status;
 130         }
 131
 132         talloc_steal(sock, sock->sock);
 133
 134         /* we initially look for write - see the man page on
 135            non-blocking connect */
 136         sock->event.fde = event_add_fd(sock->event.ctx, sock, socket_get_fd(sock->sock),
 137                                        EVENT_FD_WRITE, smbcli_sock_connect_handler, c);
 138
 139         sock->port = port;
 140         set_blocking(socket_get_fd(sock->sock), False);
 141
 142         return socket_connect(sock->sock, NULL, 0, hostaddr, port, 0);
 143 }
 144
 145
 146 /*
 147   connect a smbcli_socket context to an IP/port pair
 148   if port is 0 then choose 445 then 139
 149
 150   this is the async send side of the interface
 151 */
 152 struct composite_context *smbcli_sock_connect_send(struct smbcli_socket *sock,
 153                                                   const char *host_addr, int port)
 154 {
 155         struct composite_context *c;
 156         struct clisocket_connect *conn;
 157         int i;
 158
 159         c = talloc_zero(sock, struct composite_context);
 160         if (c == NULL) return NULL;
 161
 162         c->event_ctx = sock->event.ctx;
 163
 164         conn = talloc(c, struct clisocket_connect);
 165         if (conn == NULL) goto failed;
 166
 167         conn->sock = sock;
 168
 169         /* work out what ports we will try */
 170         if (port == 0) {
 171                 const char **ports = lp_smb_ports();
 172                 for (i=0;ports[i];i++) /* noop */ ;
 173                 conn->iports = talloc_array(c, int, i+1);
 174                 if (conn->iports == NULL) goto failed;
 175                 for (i=0;ports[i];i++) {
 176                         conn->iports[i] = atoi(ports[i]);
 177                 }
 178                 conn->iports[i] = 0;
 179         } else {
 180                 conn->iports = talloc_array(c, int, 2);
 181                 if (conn->iports == NULL) goto failed;
 182                 conn->iports[0] = port;
 183                 conn->iports[1] = 0;
 184         }
 185
 186         conn->dest_host = talloc_strdup(c, host_addr);
 187         if (conn->dest_host == NULL) goto failed;
 188
 189         c->private = conn;
 190         c->state = SMBCLI_REQUEST_SEND;
 191
 192         /* startup the connect process for each port in turn until one
 193            succeeds or tells us that it is pending */
 194         for (i=0;conn->iports[i];i++) {
 195                 conn->port_num = i;
 196                 conn->sock->port = conn->iports[i];
 197                 c->status = smbcli_sock_connect_one(sock,
 198                                                     conn->dest_host,
 199                                                     conn->iports[i], c);
 200                 if (NT_STATUS_IS_OK(c->status) ||
 201                     NT_STATUS_EQUAL(c->status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 202                         return c;
 203                 }
 204         }
 205
 206         c->state = SMBCLI_REQUEST_ERROR;
 207         return c;
 208
 209 failed:
 210         talloc_free(c);
 211         return NULL;
 212 }
 213
 214 /*
 215   finish a smbcli_sock_connect_send() operation
 216 */
 217 NTSTATUS smbcli_sock_connect_recv(struct composite_context *c)
 218 {
 219         NTSTATUS status;
 220         status = composite_wait(c);
 221         talloc_free(c);
 222         return status;
 223 }
 224
 225 /*
 226   connect a smbcli_socket context to an IP/port pair
 227   if port is 0 then choose the ports listed in smb.conf (normally 445 then 139)
 228
 229   sync version of the function
 230 */
 231 NTSTATUS smbcli_sock_connect(struct smbcli_socket *sock, const char *host_addr, int port)
 232 {
 233         struct composite_context *c;
 234
 235         c = smbcli_sock_connect_send(sock, host_addr, port);
 236         if (c == NULL) {
 237                 return NT_STATUS_NO_MEMORY;
 238         }
 239
 240         return smbcli_sock_connect_recv(c);
 241 }
 242
 243
 244 /****************************************************************************
 245  mark the socket as dead
 246 ****************************************************************************/
 247 void smbcli_sock_dead(struct smbcli_socket *sock)
 248 {
 249         if (sock->sock != NULL) {
 250                 talloc_free(sock->sock);
 251                 sock->sock = NULL;
 252         }
 253 }
 254
 255 /****************************************************************************
 256  Set socket options on a open connection.
 257 ****************************************************************************/
 258 void smbcli_sock_set_options(struct smbcli_socket *sock, const char *options)
 259 {
 260         socket_set_option(sock->sock, options, NULL);
 261 }
 262
 263 /****************************************************************************
 264  Write to socket. Return amount written.
 265 ****************************************************************************/
 266 ssize_t smbcli_sock_write(struct smbcli_socket *sock, const uint8_t *data, size_t len)
 267 {
 268         NTSTATUS status;
 269         DATA_BLOB blob;
 270         size_t nsent;
 271
 272         if (sock->sock == NULL) {
 273                 errno = EIO;
 274                 return -1;
 275         }
 276
 277         blob.data = discard_const(data);
 278         blob.length = len;
 279
 280         status = socket_send(sock->sock, &blob, &nsent, 0);
 281         if (NT_STATUS_IS_ERR(status)) {
 282                 return -1;
 283         }
 284
 285         return nsent;
 286 }
 287
 288
 289 /****************************************************************************
 290  Read from socket. return amount read
 291 ****************************************************************************/
 292 ssize_t smbcli_sock_read(struct smbcli_socket *sock, uint8_t *data, size_t len)
 293 {
 294         NTSTATUS status;
 295         size_t nread;
 296
 297         if (sock->sock == NULL) {
 298                 errno = EIO;
 299                 return -1;
 300         }
 301
 302         status = socket_recv(sock->sock, data, len, &nread, 0);
 303         if (NT_STATUS_IS_ERR(status)) {
 304                 return -1;
 305         }
 306
 307         return nread;
 308 }
 309
 310
 311 /****************************************************************************
 312 resolve a hostname and connect
 313 ****************************************************************************/
 314 BOOL smbcli_sock_connect_byname(struct smbcli_socket *sock, const char *host, int port)
 315 {
 316         int name_type = NBT_NAME_SERVER;
 317         const char *address;
 318         NTSTATUS status;
 319         struct nbt_name nbt_name;
 320         char *name, *p;
 321
 322         name = talloc_strdup(sock, host);
 323
 324         /* allow hostnames of the form NAME#xx and do a netbios lookup */
 325         if ((p = strchr(name, '#'))) {
 326                 name_type = strtol(p+1, NULL, 16);
 327                 *p = 0;
 328         }
 329
 330         nbt_name.name = name;
 331         nbt_name.type = name_type;
 332         nbt_name.scope = NULL;
 333
 334         status = resolve_name(&nbt_name, sock, &address);
 335         if (!NT_STATUS_IS_OK(status)) {
 336                 return False;
 337         }
 338
 339         sock->hostname = name;
 340
 341         status = smbcli_sock_connect(sock, address, port);
 342
 343         return NT_STATUS_IS_OK(status);
 344 }