lib/smb.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 2014, Bill Nagel <wnagel@tycoint.com>, Exacq Technologies
   9  * Copyright (C) 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
  10  *
  11  * This software is licensed as described in the file COPYING, which
  12  * you should have received as part of this distribution. The terms
  13  * are also available at https://curl.haxx.se/docs/copyright.html.
  14  *
  15  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  16  * copies of the Software, and permit persons to whom the Software is
  17  * furnished to do so, under the terms of the COPYING file.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  ***************************************************************************/
  23
  24 #include "curl_setup.h"
  25
  26 #if !defined(CURL_DISABLE_SMB) && defined(USE_NTLM) && \
  27     (CURL_SIZEOF_CURL_OFF_T > 4)
  28
  29 #if !defined(USE_WINDOWS_SSPI) || defined(USE_WIN32_CRYPTO)
  30
  31 #define BUILDING_CURL_SMB_C
  32
  33 #ifdef HAVE_PROCESS_H
  34 #include <process.h>
  35 #define getpid _getpid
  36 #endif
  37
  38 #include "smb.h"
  39 #include "urldata.h"
  40 #include "sendf.h"
  41 #include "multiif.h"
  42 #include "connect.h"
  43 #include "progress.h"
  44 #include "transfer.h"
  45 #include "vtls/vtls.h"
  46 #include "curl_ntlm_core.h"
  47 #include "escape.h"
  48 #include "curl_endian.h"
  49
  50 /* The last #include files should be: */
  51 #include "curl_memory.h"
  52 #include "memdebug.h"
  53
  54 /* Local API functions */
  55 static CURLcode smb_setup_connection(struct connectdata *conn);
  56 static CURLcode smb_connect(struct connectdata *conn, bool *done);
  57 static CURLcode smb_connection_state(struct connectdata *conn, bool *done);
  58 static CURLcode smb_request_state(struct connectdata *conn, bool *done);
  59 static CURLcode smb_done(struct connectdata *conn, CURLcode status,
  60                          bool premature);
  61 static CURLcode smb_disconnect(struct connectdata *conn, bool dead);
  62 static int smb_getsock(struct connectdata *conn, curl_socket_t *socks,
  63                        int numsocks);
  64 static CURLcode smb_parse_url_path(struct connectdata *conn);
  65
  66 /*
  67  * SMB handler interface
  68  */
  69 const struct Curl_handler Curl_handler_smb = {
  70   "SMB",                                /* scheme */
  71   smb_setup_connection,                 /* setup_connection */
  72   ZERO_NULL,                            /* do_it */
  73   smb_done,                             /* done */
  74   ZERO_NULL,                            /* do_more */
  75   smb_connect,                          /* connect_it */
  76   smb_connection_state,                 /* connecting */
  77   smb_request_state,                    /* doing */
  78   smb_getsock,                          /* proto_getsock */
  79   smb_getsock,                          /* doing_getsock */
  80   ZERO_NULL,                            /* domore_getsock */
  81   ZERO_NULL,                            /* perform_getsock */
  82   smb_disconnect,                       /* disconnect */
  83   ZERO_NULL,                            /* readwrite */
  84   PORT_SMB,                             /* defport */
  85   CURLPROTO_SMB,                        /* protocol */
  86   PROTOPT_NONE                          /* flags */
  87 };
  88
  89 #ifdef USE_SSL
  90 /*
  91  * SMBS handler interface
  92  */
  93 const struct Curl_handler Curl_handler_smbs = {
  94   "SMBS",                               /* scheme */
  95   smb_setup_connection,                 /* setup_connection */
  96   ZERO_NULL,                            /* do_it */
  97   smb_done,                             /* done */
  98   ZERO_NULL,                            /* do_more */
  99   smb_connect,                          /* connect_it */
 100   smb_connection_state,                 /* connecting */
 101   smb_request_state,                    /* doing */
 102   smb_getsock,                          /* proto_getsock */
 103   smb_getsock,                          /* doing_getsock */
 104   ZERO_NULL,                            /* domore_getsock */
 105   ZERO_NULL,                            /* perform_getsock */
 106   smb_disconnect,                       /* disconnect */
 107   ZERO_NULL,                            /* readwrite */
 108   PORT_SMBS,                            /* defport */
 109   CURLPROTO_SMBS,                       /* protocol */
 110   PROTOPT_SSL                           /* flags */
 111 };
 112 #endif
 113
 114 #define MAX_PAYLOAD_SIZE  0x8000
 115 #define MAX_MESSAGE_SIZE  (MAX_PAYLOAD_SIZE + 0x1000)
 116 #define CLIENTNAME        "curl"
 117 #define SERVICENAME       "?????"
 118
 119 /* Append a string to an SMB message */
 120 #define MSGCAT(str) \
 121   strcpy(p, (str)); \
 122   p += strlen(str);
 123
 124 /* Append a null-terminated string to an SMB message */
 125 #define MSGCATNULL(str) \
 126   strcpy(p, (str)); \
 127   p += strlen(str) + 1;
 128
 129 /* SMB is mostly little endian */
 130 #if (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) || \
 131    defined(__OS400__)
 132 static unsigned short smb_swap16(unsigned short x)
 133 {
 134   return (unsigned short) ((x << 8) | ((x >> 8) & 0xff));
 135 }
 136
 137 static unsigned int smb_swap32(unsigned int x)
 138 {
 139   return (x << 24) | ((x << 8) & 0xff0000) | ((x >> 8) & 0xff00) |
 140          ((x >> 24) & 0xff);
 141 }
 142
 143 #ifdef HAVE_LONGLONG
 144 static unsigned long long smb_swap64(unsigned long long x)
 145 {
 146   return ((unsigned long long) smb_swap32((unsigned int) x) << 32) |
 147           smb_swap32((unsigned int) (x >> 32));
 148 }
 149 #else
 150 static unsigned __int64 smb_swap64(unsigned __int64 x)
 151 {
 152   return ((unsigned __int64) smb_swap32((unsigned int) x) << 32) |
 153           smb_swap32((unsigned int) (x >> 32));
 154 }
 155 #endif
 156 #else
 157 #  define smb_swap16(x) (x)
 158 #  define smb_swap32(x) (x)
 159 #  define smb_swap64(x) (x)
 160 #endif
 161
 162 /* SMB request state */
 163 enum smb_req_state {
 164   SMB_REQUESTING,
 165   SMB_TREE_CONNECT,
 166   SMB_OPEN,
 167   SMB_DOWNLOAD,
 168   SMB_UPLOAD,
 169   SMB_CLOSE,
 170   SMB_TREE_DISCONNECT,
 171   SMB_DONE
 172 };
 173
 174 /* SMB request data */
 175 struct smb_request {
 176   enum smb_req_state state;
 177   char *share;
 178   char *path;
 179   unsigned short tid; /* Even if we connect to the same tree as another */
 180   unsigned short fid; /* request, the tid will be different */
 181   CURLcode result;
 182 };
 183
 184 static void conn_state(struct connectdata *conn, enum smb_conn_state newstate)
 185 {
 186   struct smb_conn *smb = &conn->proto.smbc;
 187 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
 188   /* For debug purposes */
 189   static const char * const names[] = {
 190     "SMB_NOT_CONNECTED",
 191     "SMB_CONNECTING",
 192     "SMB_NEGOTIATE",
 193     "SMB_SETUP",
 194     "SMB_CONNECTED",
 195     /* LAST */
 196   };
 197
 198   if(smb->state != newstate)
 199     infof(conn->data, "SMB conn %p state change from %s to %s\n",
 200     (void *)smb, names[smb->state], names[newstate]);
 201 #endif
 202
 203   smb->state = newstate;
 204 }
 205
 206 static void request_state(struct connectdata *conn,
 207                           enum smb_req_state newstate)
 208 {
 209   struct smb_request *req = conn->data->req.protop;
 210 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
 211   /* For debug purposes */
 212   static const char * const names[] = {
 213     "SMB_REQUESTING",
 214     "SMB_TREE_CONNECT",
 215     "SMB_OPEN",
 216     "SMB_DOWNLOAD",
 217     "SMB_UPLOAD",
 218     "SMB_CLOSE",
 219     "SMB_TREE_DISCONNECT",
 220     "SMB_DONE",
 221     /* LAST */
 222   };
 223
 224   if(req->state != newstate)
 225     infof(conn->data, "SMB request %p state change from %s to %s\n",
 226     (void *)req, names[req->state], names[newstate]);
 227 #endif
 228
 229   req->state = newstate;
 230 }
 231
 232 static CURLcode smb_setup_connection(struct connectdata *conn)
 233 {
 234   struct smb_request *req;
 235
 236   /* Initialize the request state */
 237   conn->data->req.protop = req = calloc(1, sizeof(struct smb_request));
 238   if(!req)
 239     return CURLE_OUT_OF_MEMORY;
 240
 241   /* Parse the URL path */
 242   return smb_parse_url_path(conn);
 243 }
 244
 245 static CURLcode smb_connect(struct connectdata *conn, bool *done)
 246 {
 247   struct smb_conn *smbc = &conn->proto.smbc;
 248   char *slash;
 249
 250   (void) done;
 251
 252   /* Check we have a username and password to authenticate with */
 253   if(!conn->bits.user_passwd)
 254     return CURLE_LOGIN_DENIED;
 255
 256   /* Initialize the connection state */
 257   memset(smbc, 0, sizeof(*smbc));
 258   smbc->state = SMB_CONNECTING;
 259   smbc->recv_buf = malloc(MAX_MESSAGE_SIZE);
 260   if(!smbc->recv_buf)
 261     return CURLE_OUT_OF_MEMORY;
 262
 263   /* Multiple requests are allowed with this connection */
 264   connkeep(conn, "SMB default");
 265
 266   /* Parse the username, domain, and password */
 267   slash = strchr(conn->user, '/');
 268   if(!slash)
 269     slash = strchr(conn->user, '\\');
 270
 271   if(slash) {
 272     smbc->user = slash + 1;
 273     smbc->domain = strdup(conn->user);
 274     if(!smbc->domain)
 275       return CURLE_OUT_OF_MEMORY;
 276     smbc->domain[slash - conn->user] = 0;
 277   }
 278   else {
 279     smbc->user = conn->user;
 280     smbc->domain = strdup(conn->host.name);
 281     if(!smbc->domain)
 282       return CURLE_OUT_OF_MEMORY;
 283   }
 284
 285   return CURLE_OK;
 286 }
 287
 288 static CURLcode smb_recv_message(struct connectdata *conn, void **msg)
 289 {
 290   struct smb_conn *smbc = &conn->proto.smbc;
 291   char *buf = smbc->recv_buf;
 292   ssize_t bytes_read;
 293   size_t nbt_size;
 294   size_t msg_size;
 295   size_t len = MAX_MESSAGE_SIZE - smbc->got;
 296   CURLcode result;
 297
 298   result = Curl_read(conn, FIRSTSOCKET, buf + smbc->got, len, &bytes_read);
 299   if(result)
 300     return result;
 301
 302   if(!bytes_read)
 303     return CURLE_OK;
 304
 305   smbc->got += bytes_read;
 306
 307   /* Check for a 32-bit nbt header */
 308   if(smbc->got < sizeof(unsigned int))
 309     return CURLE_OK;
 310
 311   nbt_size = Curl_read16_be((unsigned char *)(buf + sizeof(unsigned short))) +
 312              sizeof(unsigned int);
 313   if(smbc->got < nbt_size)
 314     return CURLE_OK;
 315
 316   msg_size = sizeof(struct smb_header);
 317   if(nbt_size >= msg_size + 1) {
 318     /* Add the word count */
 319     msg_size += 1 + ((unsigned char) buf[msg_size]) * sizeof(unsigned short);
 320     if(nbt_size >= msg_size + sizeof(unsigned short)) {
 321       /* Add the byte count */
 322       msg_size += sizeof(unsigned short) +
 323                   Curl_read16_le((unsigned char *)&buf[msg_size]);
 324       if(nbt_size < msg_size)
 325         return CURLE_READ_ERROR;
 326     }
 327   }
 328
 329   *msg = buf;
 330
 331   return CURLE_OK;
 332 }
 333
 334 static void smb_pop_message(struct connectdata *conn)
 335 {
 336   struct smb_conn *smbc = &conn->proto.smbc;
 337
 338   smbc->got = 0;
 339 }
 340
 341 static void smb_format_message(struct connectdata *conn, struct smb_header *h,
 342                                unsigned char cmd, size_t len)
 343 {
 344   struct smb_conn *smbc = &conn->proto.smbc;
 345   struct smb_request *req = conn->data->req.protop;
 346   unsigned int pid;
 347
 348   memset(h, 0, sizeof(*h));
 349   h->nbt_length = htons((unsigned short) (sizeof(*h) - sizeof(unsigned int) +
 350                                           len));
 351   memcpy((char *)h->magic, "\xffSMB", 4);
 352   h->command = cmd;
 353   h->flags = SMB_FLAGS_CANONICAL_PATHNAMES | SMB_FLAGS_CASELESS_PATHNAMES;
 354   h->flags2 = smb_swap16(SMB_FLAGS2_IS_LONG_NAME | SMB_FLAGS2_KNOWS_LONG_NAME);
 355   h->uid = smb_swap16(smbc->uid);
 356   h->tid = smb_swap16(req->tid);
 357   pid = getpid();
 358   h->pid_high = smb_swap16((unsigned short)(pid >> 16));
 359   h->pid = smb_swap16((unsigned short) pid);
 360 }
 361
 362 static CURLcode smb_send(struct connectdata *conn, ssize_t len,
 363                          size_t upload_size)
 364 {
 365   struct smb_conn *smbc = &conn->proto.smbc;
 366   ssize_t bytes_written;
 367   CURLcode result;
 368
 369   result = Curl_write(conn, FIRSTSOCKET, conn->data->state.uploadbuffer,
 370                       len, &bytes_written);
 371   if(result)
 372     return result;
 373
 374   if(bytes_written != len) {
 375     smbc->send_size = len;
 376     smbc->sent = bytes_written;
 377   }
 378
 379   smbc->upload_size = upload_size;
 380
 381   return CURLE_OK;
 382 }
 383
 384 static CURLcode smb_flush(struct connectdata *conn)
 385 {
 386   struct smb_conn *smbc = &conn->proto.smbc;
 387   ssize_t bytes_written;
 388   ssize_t len = smbc->send_size - smbc->sent;
 389   CURLcode result;
 390
 391   if(!smbc->send_size)
 392     return CURLE_OK;
 393
 394   result = Curl_write(conn, FIRSTSOCKET,
 395                       conn->data->state.uploadbuffer + smbc->sent,
 396                       len, &bytes_written);
 397   if(result)
 398     return result;
 399
 400   if(bytes_written != len)
 401     smbc->sent += bytes_written;
 402   else
 403     smbc->send_size = 0;
 404
 405   return CURLE_OK;
 406 }
 407
 408 static CURLcode smb_send_message(struct connectdata *conn, unsigned char cmd,
 409                                  const void *msg, size_t msg_len)
 410 {
 411   smb_format_message(conn, (struct smb_header *)conn->data->state.uploadbuffer,
 412                      cmd, msg_len);
 413   memcpy(conn->data->state.uploadbuffer + sizeof(struct smb_header),
 414          msg, msg_len);
 415
 416   return smb_send(conn, sizeof(struct smb_header) + msg_len, 0);
 417 }
 418
 419 static CURLcode smb_send_negotiate(struct connectdata *conn)
 420 {
 421   const char *msg = "\x00\x0c\x00\x02NT LM 0.12";
 422
 423   return smb_send_message(conn, SMB_COM_NEGOTIATE, msg, 15);
 424 }
 425
 426 static CURLcode smb_send_setup(struct connectdata *conn)
 427 {
 428   struct smb_conn *smbc = &conn->proto.smbc;
 429   struct smb_setup msg;
 430   char *p = msg.bytes;
 431   unsigned char lm_hash[21];
 432   unsigned char lm[24];
 433   unsigned char nt_hash[21];
 434   unsigned char nt[24];
 435
 436   size_t byte_count = sizeof(lm) + sizeof(nt);
 437   byte_count += strlen(smbc->user) + strlen(smbc->domain);
 438   byte_count += strlen(OS) + strlen(CLIENTNAME) + 4; /* 4 null chars */
 439   if(byte_count > sizeof(msg.bytes))
 440     return CURLE_FILESIZE_EXCEEDED;
 441
 442   Curl_ntlm_core_mk_lm_hash(conn->data, conn->passwd, lm_hash);
 443   Curl_ntlm_core_lm_resp(lm_hash, smbc->challenge, lm);
 444 #if USE_NTRESPONSES
 445   Curl_ntlm_core_mk_nt_hash(conn->data, conn->passwd, nt_hash);
 446   Curl_ntlm_core_lm_resp(nt_hash, smbc->challenge, nt);
 447 #else
 448   memset(nt, 0, sizeof(nt));
 449 #endif
 450
 451   memset(&msg, 0, sizeof(msg));
 452   msg.word_count = SMB_WC_SETUP_ANDX;
 453   msg.andx.command = SMB_COM_NO_ANDX_COMMAND;
 454   msg.max_buffer_size = smb_swap16(MAX_MESSAGE_SIZE);
 455   msg.max_mpx_count = smb_swap16(1);
 456   msg.vc_number = smb_swap16(1);
 457   msg.session_key = smb_swap32(smbc->session_key);
 458   msg.capabilities = smb_swap32(SMB_CAP_LARGE_FILES);
 459   msg.lengths[0] = smb_swap16(sizeof(lm));
 460   msg.lengths[1] = smb_swap16(sizeof(nt));
 461   memcpy(p, lm, sizeof(lm));
 462   p += sizeof(lm);
 463   memcpy(p, nt, sizeof(nt));
 464   p += sizeof(nt);
 465   MSGCATNULL(smbc->user);
 466   MSGCATNULL(smbc->domain);
 467   MSGCATNULL(OS);
 468   MSGCATNULL(CLIENTNAME);
 469   byte_count = p - msg.bytes;
 470   msg.byte_count = smb_swap16((unsigned short)byte_count);
 471
 472   return smb_send_message(conn, SMB_COM_SETUP_ANDX, &msg,
 473                           sizeof(msg) - sizeof(msg.bytes) + byte_count);
 474 }
 475
 476 static CURLcode smb_send_tree_connect(struct connectdata *conn)
 477 {
 478   struct smb_request *req = conn->data->req.protop;
 479   struct smb_tree_connect msg;
 480   char *p = msg.bytes;
 481
 482   size_t byte_count = strlen(conn->host.name) + strlen(req->share);
 483   byte_count += strlen(SERVICENAME) + 5; /* 2 nulls and 3 backslashes */
 484   if(byte_count > sizeof(msg.bytes))
 485     return CURLE_FILESIZE_EXCEEDED;
 486
 487   memset(&msg, 0, sizeof(msg));
 488   msg.word_count = SMB_WC_TREE_CONNECT_ANDX;
 489   msg.andx.command = SMB_COM_NO_ANDX_COMMAND;
 490   msg.pw_len = 0;
 491   MSGCAT("\\\\");
 492   MSGCAT(conn->host.name);
 493   MSGCAT("\\");
 494   MSGCATNULL(req->share);
 495   MSGCATNULL(SERVICENAME); /* Match any type of service */
 496   byte_count = p - msg.bytes;
 497   msg.byte_count = smb_swap16((unsigned short)byte_count);
 498
 499   return smb_send_message(conn, SMB_COM_TREE_CONNECT_ANDX, &msg,
 500                           sizeof(msg) - sizeof(msg.bytes) + byte_count);
 501 }
 502
 503 static CURLcode smb_send_open(struct connectdata *conn)
 504 {
 505   struct smb_request *req = conn->data->req.protop;
 506   struct smb_nt_create msg;
 507   size_t byte_count;
 508
 509   if((strlen(req->path) + 1) > sizeof(msg.bytes))
 510     return CURLE_FILESIZE_EXCEEDED;
 511
 512   memset(&msg, 0, sizeof(msg));
 513   msg.word_count = SMB_WC_NT_CREATE_ANDX;
 514   msg.andx.command = SMB_COM_NO_ANDX_COMMAND;
 515   byte_count = strlen(req->path);
 516   msg.name_length = smb_swap16((unsigned short)byte_count);
 517   msg.share_access = smb_swap32(SMB_FILE_SHARE_ALL);
 518   if(conn->data->set.upload) {
 519     msg.access = smb_swap32(SMB_GENERIC_READ | SMB_GENERIC_WRITE);
 520     msg.create_disposition = smb_swap32(SMB_FILE_OVERWRITE_IF);
 521   }
 522   else {
 523     msg.access = smb_swap32(SMB_GENERIC_READ);
 524     msg.create_disposition = smb_swap32(SMB_FILE_OPEN);
 525   }
 526   msg.byte_count = smb_swap16((unsigned short) ++byte_count);
 527   strcpy(msg.bytes, req->path);
 528
 529   return smb_send_message(conn, SMB_COM_NT_CREATE_ANDX, &msg,
 530                           sizeof(msg) - sizeof(msg.bytes) + byte_count);
 531 }
 532
 533 static CURLcode smb_send_close(struct connectdata *conn)
 534 {
 535   struct smb_request *req = conn->data->req.protop;
 536   struct smb_close msg;
 537
 538   memset(&msg, 0, sizeof(msg));
 539   msg.word_count = SMB_WC_CLOSE;
 540   msg.fid = smb_swap16(req->fid);
 541
 542   return smb_send_message(conn, SMB_COM_CLOSE, &msg, sizeof(msg));
 543 }
 544
 545 static CURLcode smb_send_tree_disconnect(struct connectdata *conn)
 546 {
 547   struct smb_tree_disconnect msg;
 548
 549   memset(&msg, 0, sizeof(msg));
 550
 551   return smb_send_message(conn, SMB_COM_TREE_DISCONNECT, &msg, sizeof(msg));
 552 }
 553
 554 static CURLcode smb_send_read(struct connectdata *conn)
 555 {
 556   struct smb_request *req = conn->data->req.protop;
 557   curl_off_t offset = conn->data->req.offset;
 558   struct smb_read msg;
 559
 560   memset(&msg, 0, sizeof(msg));
 561   msg.word_count = SMB_WC_READ_ANDX;
 562   msg.andx.command = SMB_COM_NO_ANDX_COMMAND;
 563   msg.fid = smb_swap16(req->fid);
 564   msg.offset = smb_swap32((unsigned int) offset);
 565   msg.offset_high = smb_swap32((unsigned int) (offset >> 32));
 566   msg.min_bytes = smb_swap16(MAX_PAYLOAD_SIZE);
 567   msg.max_bytes = smb_swap16(MAX_PAYLOAD_SIZE);
 568
 569   return smb_send_message(conn, SMB_COM_READ_ANDX, &msg, sizeof(msg));
 570 }
 571
 572 static CURLcode smb_send_write(struct connectdata *conn)
 573 {
 574   struct smb_write *msg = (struct smb_write *)conn->data->state.uploadbuffer;
 575   struct smb_request *req = conn->data->req.protop;
 576   curl_off_t offset = conn->data->req.offset;
 577
 578   curl_off_t upload_size = conn->data->req.size - conn->data->req.bytecount;
 579   if(upload_size >= MAX_PAYLOAD_SIZE - 1) /* There is one byte of padding */
 580     upload_size = MAX_PAYLOAD_SIZE - 1;
 581
 582   memset(msg, 0, sizeof(*msg));
 583   msg->word_count = SMB_WC_WRITE_ANDX;
 584   msg->andx.command = SMB_COM_NO_ANDX_COMMAND;
 585   msg->fid = smb_swap16(req->fid);
 586   msg->offset = smb_swap32((unsigned int) offset);
 587   msg->offset_high = smb_swap32((unsigned int) (offset >> 32));
 588   msg->data_length = smb_swap16((unsigned short) upload_size);
 589   msg->data_offset = smb_swap16(sizeof(*msg) - sizeof(unsigned int));
 590   msg->byte_count = smb_swap16((unsigned short) (upload_size + 1));
 591
 592   smb_format_message(conn, &msg->h, SMB_COM_WRITE_ANDX,
 593                      sizeof(*msg) - sizeof(msg->h) + (size_t) upload_size);
 594
 595   return smb_send(conn, sizeof(*msg), (size_t) upload_size);
 596 }
 597
 598 static CURLcode smb_send_and_recv(struct connectdata *conn, void **msg)
 599 {
 600   struct smb_conn *smbc = &conn->proto.smbc;
 601   CURLcode result;
 602
 603   /* Check if there is data in the transfer buffer */
 604   if(!smbc->send_size && smbc->upload_size) {
 605     int nread = smbc->upload_size > BUFSIZE ? BUFSIZE :
 606                                               (int) smbc->upload_size;
 607     conn->data->req.upload_fromhere = conn->data->state.uploadbuffer;
 608     result = Curl_fillreadbuffer(conn, nread, &nread);
 609     if(result && result != CURLE_AGAIN)
 610       return result;
 611     if(!nread)
 612       return CURLE_OK;
 613
 614     smbc->upload_size -= nread;
 615     smbc->send_size = nread;
 616     smbc->sent = 0;
 617   }
 618
 619   /* Check if there is data to send */
 620   if(smbc->send_size) {
 621     result = smb_flush(conn);
 622     if(result)
 623       return result;
 624   }
 625
 626   /* Check if there is still data to be sent */
 627   if(smbc->send_size || smbc->upload_size)
 628     return CURLE_AGAIN;
 629
 630   return smb_recv_message(conn, msg);
 631 }
 632
 633 static CURLcode smb_connection_state(struct connectdata *conn, bool *done)
 634 {
 635   struct smb_conn *smbc = &conn->proto.smbc;
 636   struct smb_negotiate_response *nrsp;
 637   struct smb_header *h;
 638   CURLcode result;
 639   void *msg = NULL;
 640
 641   if(smbc->state == SMB_CONNECTING) {
 642 #ifdef USE_SSL
 643     if((conn->handler->flags & PROTOPT_SSL)) {
 644       bool ssl_done;
 645       result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &ssl_done);
 646       if(result && result != CURLE_AGAIN)
 647         return result;
 648       if(!ssl_done)
 649         return CURLE_OK;
 650     }
 651 #endif
 652
 653     result = smb_send_negotiate(conn);
 654     if(result) {
 655       connclose(conn, "SMB: failed to send negotiate message");
 656       return result;
 657     }
 658
 659     conn_state(conn, SMB_NEGOTIATE);
 660   }
 661
 662   /* Send the previous message and check for a response */
 663   result = smb_send_and_recv(conn, &msg);
 664   if(result && result != CURLE_AGAIN) {
 665     connclose(conn, "SMB: failed to communicate");
 666     return result;
 667   }
 668
 669   if(!msg)
 670     return CURLE_OK;
 671
 672   h = msg;
 673
 674   switch(smbc->state) {
 675   case SMB_NEGOTIATE:
 676     if(h->status) {
 677       connclose(conn, "SMB: negotiation failed");
 678       return CURLE_COULDNT_CONNECT;
 679     }
 680     nrsp = msg;
 681     memcpy(smbc->challenge, nrsp->bytes, sizeof(smbc->challenge));
 682     smbc->session_key = smb_swap32(nrsp->session_key);
 683     result = smb_send_setup(conn);
 684     if(result) {
 685       connclose(conn, "SMB: failed to send setup message");
 686       return result;
 687     }
 688     conn_state(conn, SMB_SETUP);
 689     break;
 690
 691   case SMB_SETUP:
 692     if(h->status) {
 693       connclose(conn, "SMB: authentication failed");
 694       return CURLE_LOGIN_DENIED;
 695     }
 696     smbc->uid = smb_swap16(h->uid);
 697     conn_state(conn, SMB_CONNECTED);
 698     *done = true;
 699     break;
 700
 701   default:
 702     smb_pop_message(conn);
 703     return CURLE_OK; /* ignore */
 704   }
 705
 706   smb_pop_message(conn);
 707
 708   return CURLE_OK;
 709 }
 710
 711 static CURLcode smb_request_state(struct connectdata *conn, bool *done)
 712 {
 713   struct smb_request *req = conn->data->req.protop;
 714   struct smb_header *h;
 715   enum smb_req_state next_state = SMB_DONE;
 716   unsigned short len;
 717   unsigned short off;
 718   CURLcode result;
 719   void *msg = NULL;
 720
 721   /* Start the request */
 722   if(req->state == SMB_REQUESTING) {
 723     result = smb_send_tree_connect(conn);
 724     if(result) {
 725       connclose(conn, "SMB: failed to send tree connect message");
 726       return result;
 727     }
 728
 729     request_state(conn, SMB_TREE_CONNECT);
 730   }
 731
 732   /* Send the previous message and check for a response */
 733   result = smb_send_and_recv(conn, &msg);
 734   if(result && result != CURLE_AGAIN) {
 735     connclose(conn, "SMB: failed to communicate");
 736     return result;
 737   }
 738
 739   if(!msg)
 740     return CURLE_OK;
 741
 742   h = msg;
 743
 744   switch(req->state) {
 745   case SMB_TREE_CONNECT:
 746     if(h->status) {
 747       req->result = CURLE_REMOTE_FILE_NOT_FOUND;
 748       if(h->status == smb_swap32(SMB_ERR_NOACCESS))
 749         req->result = CURLE_REMOTE_ACCESS_DENIED;
 750       break;
 751     }
 752     req->tid = smb_swap16(h->tid);
 753     next_state = SMB_OPEN;
 754     break;
 755
 756   case SMB_OPEN:
 757     if(h->status) {
 758       req->result = CURLE_REMOTE_FILE_NOT_FOUND;
 759       next_state = SMB_TREE_DISCONNECT;
 760       break;
 761     }
 762     req->fid = smb_swap16(((struct smb_nt_create_response *)msg)->fid);
 763     conn->data->req.offset = 0;
 764     if(conn->data->set.upload) {
 765       conn->data->req.size = conn->data->state.infilesize;
 766       Curl_pgrsSetUploadSize(conn->data, conn->data->req.size);
 767       next_state = SMB_UPLOAD;
 768     }
 769     else {
 770       conn->data->req.size =
 771         smb_swap64(((struct smb_nt_create_response *)msg)->end_of_file);
 772       Curl_pgrsSetDownloadSize(conn->data, conn->data->req.size);
 773       next_state = SMB_DOWNLOAD;
 774     }
 775     break;
 776
 777   case SMB_DOWNLOAD:
 778     if(h->status) {
 779       req->result = CURLE_RECV_ERROR;
 780       next_state = SMB_CLOSE;
 781       break;
 782     }
 783     len = Curl_read16_le(((unsigned char *) msg) +
 784                          sizeof(struct smb_header) + 11);
 785     off = Curl_read16_le(((unsigned char *) msg) +
 786                          sizeof(struct smb_header) + 13);
 787     if(len > 0) {
 788       struct smb_conn *smbc = &conn->proto.smbc;
 789       if(off + sizeof(unsigned int) + len > smbc->got) {
 790         failf(conn->data, "Invalid input packet");
 791         result = CURLE_RECV_ERROR;
 792       }
 793       else
 794         result = Curl_client_write(conn, CLIENTWRITE_BODY,
 795                                    (char *)msg + off + sizeof(unsigned int),
 796                                    len);
 797       if(result) {
 798         req->result = result;
 799         next_state = SMB_CLOSE;
 800         break;
 801       }
 802     }
 803     conn->data->req.bytecount += len;
 804     conn->data->req.offset += len;
 805     Curl_pgrsSetDownloadCounter(conn->data, conn->data->req.bytecount);
 806     next_state = (len < MAX_PAYLOAD_SIZE) ? SMB_CLOSE : SMB_DOWNLOAD;
 807     break;
 808
 809   case SMB_UPLOAD:
 810     if(h->status) {
 811       req->result = CURLE_UPLOAD_FAILED;
 812       next_state = SMB_CLOSE;
 813       break;
 814     }
 815     len = Curl_read16_le(((unsigned char *) msg) +
 816                          sizeof(struct smb_header) + 5);
 817     conn->data->req.bytecount += len;
 818     conn->data->req.offset += len;
 819     Curl_pgrsSetUploadCounter(conn->data, conn->data->req.bytecount);
 820     if(conn->data->req.bytecount >= conn->data->req.size)
 821       next_state = SMB_CLOSE;
 822     else
 823       next_state = SMB_UPLOAD;
 824     break;
 825
 826   case SMB_CLOSE:
 827     /* We don't care if the close failed, proceed to tree disconnect anyway */
 828     next_state = SMB_TREE_DISCONNECT;
 829     break;
 830
 831   case SMB_TREE_DISCONNECT:
 832     next_state = SMB_DONE;
 833     break;
 834
 835   default:
 836     smb_pop_message(conn);
 837     return CURLE_OK; /* ignore */
 838   }
 839
 840   smb_pop_message(conn);
 841
 842   switch(next_state) {
 843   case SMB_OPEN:
 844     result = smb_send_open(conn);
 845     break;
 846
 847   case SMB_DOWNLOAD:
 848     result = smb_send_read(conn);
 849     break;
 850
 851   case SMB_UPLOAD:
 852     result = smb_send_write(conn);
 853     break;
 854
 855   case SMB_CLOSE:
 856     result = smb_send_close(conn);
 857     break;
 858
 859   case SMB_TREE_DISCONNECT:
 860     result = smb_send_tree_disconnect(conn);
 861     break;
 862
 863   case SMB_DONE:
 864     result = req->result;
 865     *done = true;
 866     break;
 867
 868   default:
 869     break;
 870   }
 871
 872   if(result) {
 873     connclose(conn, "SMB: failed to send message");
 874     return result;
 875   }
 876
 877   request_state(conn, next_state);
 878
 879   return CURLE_OK;
 880 }
 881
 882 static CURLcode smb_done(struct connectdata *conn, CURLcode status,
 883                          bool premature)
 884 {
 885   struct smb_request *req = conn->data->req.protop;
 886
 887   (void) premature;
 888
 889   Curl_safefree(req->share);
 890   Curl_safefree(conn->data->req.protop);
 891
 892   return status;
 893 }
 894
 895 static CURLcode smb_disconnect(struct connectdata *conn, bool dead)
 896 {
 897   struct smb_conn *smbc = &conn->proto.smbc;
 898   struct smb_request *req = conn->data->req.protop;
 899
 900   (void) dead;
 901
 902   Curl_safefree(smbc->domain);
 903   Curl_safefree(smbc->recv_buf);
 904
 905   /* smb_done is not always called, so cleanup the request */
 906   if(req) {
 907     Curl_safefree(req->share);
 908   }
 909
 910   return CURLE_OK;
 911 }
 912
 913 static int smb_getsock(struct connectdata *conn, curl_socket_t *socks,
 914                        int numsocks)
 915 {
 916   struct smb_conn *smbc = &conn->proto.smbc;
 917
 918   if(!numsocks)
 919     return GETSOCK_BLANK;
 920
 921   socks[0] = conn->sock[FIRSTSOCKET];
 922
 923   if(smbc->send_size || smbc->upload_size)
 924     return GETSOCK_WRITESOCK(0);
 925
 926   return GETSOCK_READSOCK(0);
 927 }
 928
 929 static CURLcode smb_parse_url_path(struct connectdata *conn)
 930 {
 931   CURLcode result = CURLE_OK;
 932   struct Curl_easy *data = conn->data;
 933   struct smb_request *req = data->req.protop;
 934   char *path;
 935   char *slash;
 936
 937   /* URL decode the path */
 938   result = Curl_urldecode(data, data->state.path, 0, &path, NULL, TRUE);
 939   if(result)
 940     return result;
 941
 942   /* Parse the path for the share */
 943   req->share = strdup((*path == '/' || *path == '\\') ? path + 1 : path);
 944   if(!req->share) {
 945     free(path);
 946
 947     return CURLE_OUT_OF_MEMORY;
 948   }
 949
 950   slash = strchr(req->share, '/');
 951   if(!slash)
 952     slash = strchr(req->share, '\\');
 953
 954   /* The share must be present */
 955   if(!slash) {
 956     free(path);
 957
 958     return CURLE_URL_MALFORMAT;
 959   }
 960
 961   /* Parse the path for the file path converting any forward slashes into
 962      backslashes */
 963   *slash++ = 0;
 964   req->path = slash;
 965   for(; *slash; slash++) {
 966     if(*slash == '/')
 967       *slash = '\\';
 968   }
 969
 970   free(path);
 971
 972   return CURLE_OK;
 973 }
 974
 975 #endif /* !USE_WINDOWS_SSPI || USE_WIN32_CRYPTO */
 976
 977 #endif /* CURL_DISABLE_SMB && USE_NTLM && CURL_SIZEOF_CURL_OFF_T > 4 */