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) 2016-2020, 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_CURL_NTLM_CORE) &&  \
  27   (CURL_SIZEOF_CURL_OFF_T > 4)
  28
  29 #define BUILDING_CURL_SMB_C
  30
  31 #ifdef HAVE_PROCESS_H
  32 #include <process.h>
  33 #ifdef CURL_WINDOWS_APP
  34 #define getpid GetCurrentProcessId
  35 #elif !defined(MSDOS)
  36 #define getpid _getpid
  37 #endif
  38 #endif
  39
  40 #include "smb.h"
  41 #include "urldata.h"
  42 #include "sendf.h"
  43 #include "multiif.h"
  44 #include "connect.h"
  45 #include "progress.h"
  46 #include "transfer.h"
  47 #include "vtls/vtls.h"
  48 #include "curl_ntlm_core.h"
  49 #include "escape.h"
  50 #include "curl_endian.h"
  51
  52 /* The last #include files should be: */
  53 #include "curl_memory.h"
  54 #include "memdebug.h"
  55
  56 /* Local API functions */
  57 static CURLcode smb_setup_connection(struct connectdata *conn);
  58 static CURLcode smb_connect(struct connectdata *conn, bool *done);
  59 static CURLcode smb_connection_state(struct connectdata *conn, bool *done);
  60 static CURLcode smb_do(struct connectdata *conn, bool *done);
  61 static CURLcode smb_request_state(struct connectdata *conn, bool *done);
  62 static CURLcode smb_done(struct connectdata *conn, CURLcode status,
  63                          bool premature);
  64 static CURLcode smb_disconnect(struct connectdata *conn, bool dead);
  65 static int smb_getsock(struct connectdata *conn, curl_socket_t *socks);
  66 static CURLcode smb_parse_url_path(struct connectdata *conn);
  67
  68 /*
  69  * SMB handler interface
  70  */
  71 const struct Curl_handler Curl_handler_smb = {
  72   "SMB",                                /* scheme */
  73   smb_setup_connection,                 /* setup_connection */
  74   smb_do,                               /* do_it */
  75   smb_done,                             /* done */
  76   ZERO_NULL,                            /* do_more */
  77   smb_connect,                          /* connect_it */
  78   smb_connection_state,                 /* connecting */
  79   smb_request_state,                    /* doing */
  80   smb_getsock,                          /* proto_getsock */
  81   smb_getsock,                          /* doing_getsock */
  82   ZERO_NULL,                            /* domore_getsock */
  83   ZERO_NULL,                            /* perform_getsock */
  84   smb_disconnect,                       /* disconnect */
  85   ZERO_NULL,                            /* readwrite */
  86   ZERO_NULL,                            /* connection_check */
  87   PORT_SMB,                             /* defport */
  88   CURLPROTO_SMB,                        /* protocol */
  89   CURLPROTO_SMB,                        /* family */
  90   PROTOPT_NONE                          /* flags */
  91 };
  92
  93 #ifdef USE_SSL
  94 /*
  95  * SMBS handler interface
  96  */
  97 const struct Curl_handler Curl_handler_smbs = {
  98   "SMBS",                               /* scheme */
  99   smb_setup_connection,                 /* setup_connection */
 100   smb_do,                               /* do_it */
 101   smb_done,                             /* done */
 102   ZERO_NULL,                            /* do_more */
 103   smb_connect,                          /* connect_it */
 104   smb_connection_state,                 /* connecting */
 105   smb_request_state,                    /* doing */
 106   smb_getsock,                          /* proto_getsock */
 107   smb_getsock,                          /* doing_getsock */
 108   ZERO_NULL,                            /* domore_getsock */
 109   ZERO_NULL,                            /* perform_getsock */
 110   smb_disconnect,                       /* disconnect */
 111   ZERO_NULL,                            /* readwrite */
 112   ZERO_NULL,                            /* connection_check */
 113   PORT_SMBS,                            /* defport */
 114   CURLPROTO_SMBS,                       /* protocol */
 115   CURLPROTO_SMB,                        /* family */
 116   PROTOPT_SSL                           /* flags */
 117 };
 118 #endif
 119
 120 #define MAX_PAYLOAD_SIZE  0x8000
 121 #define MAX_MESSAGE_SIZE  (MAX_PAYLOAD_SIZE + 0x1000)
 122 #define CLIENTNAME        "curl"
 123 #define SERVICENAME       "?????"
 124
 125 /* Append a string to an SMB message */
 126 #define MSGCAT(str)                             \
 127   strcpy(p, (str));                             \
 128   p += strlen(str);
 129
 130 /* Append a null-terminated string to an SMB message */
 131 #define MSGCATNULL(str)                         \
 132   strcpy(p, (str));                             \
 133   p += strlen(str) + 1;
 134
 135 /* SMB is mostly little endian */
 136 #if (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) || \
 137   defined(__OS400__)
 138 static unsigned short smb_swap16(unsigned short x)
 139 {
 140   return (unsigned short) ((x << 8) | ((x >> 8) & 0xff));
 141 }
 142
 143 static unsigned int smb_swap32(unsigned int x)
 144 {
 145   return (x << 24) | ((x << 8) & 0xff0000) | ((x >> 8) & 0xff00) |
 146     ((x >> 24) & 0xff);
 147 }
 148
 149 static curl_off_t smb_swap64(curl_off_t x)
 150 {
 151   return ((curl_off_t) smb_swap32((unsigned int) x) << 32) |
 152     smb_swap32((unsigned int) (x >> 32));
 153 }
 154
 155 #else
 156 #  define smb_swap16(x) (x)
 157 #  define smb_swap32(x) (x)
 158 #  define smb_swap64(x) (x)
 159 #endif
 160
 161 /* SMB request state */
 162 enum smb_req_state {
 163   SMB_REQUESTING,
 164   SMB_TREE_CONNECT,
 165   SMB_OPEN,
 166   SMB_DOWNLOAD,
 167   SMB_UPLOAD,
 168   SMB_CLOSE,
 169   SMB_TREE_DISCONNECT,
 170   SMB_DONE
 171 };
 172
 173 /* SMB request data */
 174 struct smb_request {
 175   enum smb_req_state state;
 176   char *path;
 177   unsigned short tid; /* Even if we connect to the same tree as another */
 178   unsigned short fid; /* request, the tid will be different */
 179   CURLcode result;
 180 };
 181
 182 static void conn_state(struct connectdata *conn, enum smb_conn_state newstate)
 183 {
 184   struct smb_conn *smbc = &conn->proto.smbc;
 185 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
 186   /* For debug purposes */
 187   static const char * const names[] = {
 188     "SMB_NOT_CONNECTED",
 189     "SMB_CONNECTING",
 190     "SMB_NEGOTIATE",
 191     "SMB_SETUP",
 192     "SMB_CONNECTED",
 193     /* LAST */
 194   };
 195
 196   if(smbc->state != newstate)
 197     infof(conn->data, "SMB conn %p state change from %s to %s\n",
 198           (void *)smbc, names[smbc->state], names[newstate]);
 199 #endif
 200
 201   smbc->state = newstate;
 202 }
 203
 204 static void request_state(struct connectdata *conn,
 205                           enum smb_req_state newstate)
 206 {
 207   struct smb_request *req = conn->data->req.protop;
 208 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
 209   /* For debug purposes */
 210   static const char * const names[] = {
 211     "SMB_REQUESTING",
 212     "SMB_TREE_CONNECT",
 213     "SMB_OPEN",
 214     "SMB_DOWNLOAD",
 215     "SMB_UPLOAD",
 216     "SMB_CLOSE",
 217     "SMB_TREE_DISCONNECT",
 218     "SMB_DONE",
 219     /* LAST */
 220   };
 221
 222   if(req->state != newstate)
 223     infof(conn->data, "SMB request %p state change from %s to %s\n",
 224           (void *)req, names[req->state], names[newstate]);
 225 #endif
 226
 227   req->state = newstate;
 228 }
 229
 230 /* this should setup things in the connection, not in the easy
 231    handle */
 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   smbc->state = SMB_CONNECTING;
 258   smbc->recv_buf = malloc(MAX_MESSAGE_SIZE);
 259   if(!smbc->recv_buf)
 260     return CURLE_OUT_OF_MEMORY;
 261
 262   /* Multiple requests are allowed with this connection */
 263   connkeep(conn, "SMB default");
 264
 265   /* Parse the username, domain, and password */
 266   slash = strchr(conn->user, '/');
 267   if(!slash)
 268     slash = strchr(conn->user, '\\');
 269
 270   if(slash) {
 271     smbc->user = slash + 1;
 272     smbc->domain = strdup(conn->user);
 273     if(!smbc->domain)
 274       return CURLE_OUT_OF_MEMORY;
 275     smbc->domain[slash - conn->user] = 0;
 276   }
 277   else {
 278     smbc->user = conn->user;
 279     smbc->domain = strdup(conn->host.name);
 280     if(!smbc->domain)
 281       return CURLE_OUT_OF_MEMORY;
 282   }
 283
 284   return CURLE_OK;
 285 }
 286
 287 static CURLcode smb_recv_message(struct connectdata *conn, void **msg)
 288 {
 289   struct smb_conn *smbc = &conn->proto.smbc;
 290   char *buf = smbc->recv_buf;
 291   ssize_t bytes_read;
 292   size_t nbt_size;
 293   size_t msg_size;
 294   size_t len = MAX_MESSAGE_SIZE - smbc->got;
 295   CURLcode result;
 296
 297   result = Curl_read(conn, FIRSTSOCKET, buf + smbc->got, len, &bytes_read);
 298   if(result)
 299     return result;
 300
 301   if(!bytes_read)
 302     return CURLE_OK;
 303
 304   smbc->got += bytes_read;
 305
 306   /* Check for a 32-bit nbt header */
 307   if(smbc->got < sizeof(unsigned int))
 308     return CURLE_OK;
 309
 310   nbt_size = Curl_read16_be((const unsigned char *)
 311                             (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((const 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.ulbuf,
 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.ulbuf + 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   CURLcode result = Curl_get_upload_buffer(conn->data);
 412   if(result)
 413     return result;
 414   smb_format_message(conn, (struct smb_header *)conn->data->state.ulbuf,
 415                      cmd, msg_len);
 416   memcpy(conn->data->state.ulbuf + sizeof(struct smb_header),
 417          msg, msg_len);
 418
 419   return smb_send(conn, sizeof(struct smb_header) + msg_len, 0);
 420 }
 421
 422 static CURLcode smb_send_negotiate(struct connectdata *conn)
 423 {
 424   const char *msg = "\x00\x0c\x00\x02NT LM 0.12";
 425
 426   return smb_send_message(conn, SMB_COM_NEGOTIATE, msg, 15);
 427 }
 428
 429 static CURLcode smb_send_setup(struct connectdata *conn)
 430 {
 431   struct smb_conn *smbc = &conn->proto.smbc;
 432   struct smb_setup msg;
 433   char *p = msg.bytes;
 434   unsigned char lm_hash[21];
 435   unsigned char lm[24];
 436   unsigned char nt_hash[21];
 437   unsigned char nt[24];
 438
 439   size_t byte_count = sizeof(lm) + sizeof(nt);
 440   byte_count += strlen(smbc->user) + strlen(smbc->domain);
 441   byte_count += strlen(OS) + strlen(CLIENTNAME) + 4; /* 4 null chars */
 442   if(byte_count > sizeof(msg.bytes))
 443     return CURLE_FILESIZE_EXCEEDED;
 444
 445   Curl_ntlm_core_mk_lm_hash(conn->data, conn->passwd, lm_hash);
 446   Curl_ntlm_core_lm_resp(lm_hash, smbc->challenge, lm);
 447 #ifdef USE_NTRESPONSES
 448   Curl_ntlm_core_mk_nt_hash(conn->data, conn->passwd, nt_hash);
 449   Curl_ntlm_core_lm_resp(nt_hash, smbc->challenge, nt);
 450 #else
 451   memset(nt, 0, sizeof(nt));
 452 #endif
 453
 454   memset(&msg, 0, sizeof(msg));
 455   msg.word_count = SMB_WC_SETUP_ANDX;
 456   msg.andx.command = SMB_COM_NO_ANDX_COMMAND;
 457   msg.max_buffer_size = smb_swap16(MAX_MESSAGE_SIZE);
 458   msg.max_mpx_count = smb_swap16(1);
 459   msg.vc_number = smb_swap16(1);
 460   msg.session_key = smb_swap32(smbc->session_key);
 461   msg.capabilities = smb_swap32(SMB_CAP_LARGE_FILES);
 462   msg.lengths[0] = smb_swap16(sizeof(lm));
 463   msg.lengths[1] = smb_swap16(sizeof(nt));
 464   memcpy(p, lm, sizeof(lm));
 465   p += sizeof(lm);
 466   memcpy(p, nt, sizeof(nt));
 467   p += sizeof(nt);
 468   MSGCATNULL(smbc->user);
 469   MSGCATNULL(smbc->domain);
 470   MSGCATNULL(OS);
 471   MSGCATNULL(CLIENTNAME);
 472   byte_count = p - msg.bytes;
 473   msg.byte_count = smb_swap16((unsigned short)byte_count);
 474
 475   return smb_send_message(conn, SMB_COM_SETUP_ANDX, &msg,
 476                           sizeof(msg) - sizeof(msg.bytes) + byte_count);
 477 }
 478
 479 static CURLcode smb_send_tree_connect(struct connectdata *conn)
 480 {
 481   struct smb_tree_connect msg;
 482   struct smb_conn *smbc = &conn->proto.smbc;
 483   char *p = msg.bytes;
 484
 485   size_t byte_count = strlen(conn->host.name) + strlen(smbc->share);
 486   byte_count += strlen(SERVICENAME) + 5; /* 2 nulls and 3 backslashes */
 487   if(byte_count > sizeof(msg.bytes))
 488     return CURLE_FILESIZE_EXCEEDED;
 489
 490   memset(&msg, 0, sizeof(msg));
 491   msg.word_count = SMB_WC_TREE_CONNECT_ANDX;
 492   msg.andx.command = SMB_COM_NO_ANDX_COMMAND;
 493   msg.pw_len = 0;
 494   MSGCAT("\\\\");
 495   MSGCAT(conn->host.name);
 496   MSGCAT("\\");
 497   MSGCATNULL(smbc->share);
 498   MSGCATNULL(SERVICENAME); /* Match any type of service */
 499   byte_count = p - msg.bytes;
 500   msg.byte_count = smb_swap16((unsigned short)byte_count);
 501
 502   return smb_send_message(conn, SMB_COM_TREE_CONNECT_ANDX, &msg,
 503                           sizeof(msg) - sizeof(msg.bytes) + byte_count);
 504 }
 505
 506 static CURLcode smb_send_open(struct connectdata *conn)
 507 {
 508   struct smb_request *req = conn->data->req.protop;
 509   struct smb_nt_create msg;
 510   size_t byte_count;
 511
 512   if((strlen(req->path) + 1) > sizeof(msg.bytes))
 513     return CURLE_FILESIZE_EXCEEDED;
 514
 515   memset(&msg, 0, sizeof(msg));
 516   msg.word_count = SMB_WC_NT_CREATE_ANDX;
 517   msg.andx.command = SMB_COM_NO_ANDX_COMMAND;
 518   byte_count = strlen(req->path);
 519   msg.name_length = smb_swap16((unsigned short)byte_count);
 520   msg.share_access = smb_swap32(SMB_FILE_SHARE_ALL);
 521   if(conn->data->set.upload) {
 522     msg.access = smb_swap32(SMB_GENERIC_READ | SMB_GENERIC_WRITE);
 523     msg.create_disposition = smb_swap32(SMB_FILE_OVERWRITE_IF);
 524   }
 525   else {
 526     msg.access = smb_swap32(SMB_GENERIC_READ);
 527     msg.create_disposition = smb_swap32(SMB_FILE_OPEN);
 528   }
 529   msg.byte_count = smb_swap16((unsigned short) ++byte_count);
 530   strcpy(msg.bytes, req->path);
 531
 532   return smb_send_message(conn, SMB_COM_NT_CREATE_ANDX, &msg,
 533                           sizeof(msg) - sizeof(msg.bytes) + byte_count);
 534 }
 535
 536 static CURLcode smb_send_close(struct connectdata *conn)
 537 {
 538   struct smb_request *req = conn->data->req.protop;
 539   struct smb_close msg;
 540
 541   memset(&msg, 0, sizeof(msg));
 542   msg.word_count = SMB_WC_CLOSE;
 543   msg.fid = smb_swap16(req->fid);
 544
 545   return smb_send_message(conn, SMB_COM_CLOSE, &msg, sizeof(msg));
 546 }
 547
 548 static CURLcode smb_send_tree_disconnect(struct connectdata *conn)
 549 {
 550   struct smb_tree_disconnect msg;
 551
 552   memset(&msg, 0, sizeof(msg));
 553
 554   return smb_send_message(conn, SMB_COM_TREE_DISCONNECT, &msg, sizeof(msg));
 555 }
 556
 557 static CURLcode smb_send_read(struct connectdata *conn)
 558 {
 559   struct smb_request *req = conn->data->req.protop;
 560   curl_off_t offset = conn->data->req.offset;
 561   struct smb_read msg;
 562
 563   memset(&msg, 0, sizeof(msg));
 564   msg.word_count = SMB_WC_READ_ANDX;
 565   msg.andx.command = SMB_COM_NO_ANDX_COMMAND;
 566   msg.fid = smb_swap16(req->fid);
 567   msg.offset = smb_swap32((unsigned int) offset);
 568   msg.offset_high = smb_swap32((unsigned int) (offset >> 32));
 569   msg.min_bytes = smb_swap16(MAX_PAYLOAD_SIZE);
 570   msg.max_bytes = smb_swap16(MAX_PAYLOAD_SIZE);
 571
 572   return smb_send_message(conn, SMB_COM_READ_ANDX, &msg, sizeof(msg));
 573 }
 574
 575 static CURLcode smb_send_write(struct connectdata *conn)
 576 {
 577   struct smb_write *msg;
 578   struct smb_request *req = conn->data->req.protop;
 579   curl_off_t offset = conn->data->req.offset;
 580   curl_off_t upload_size = conn->data->req.size - conn->data->req.bytecount;
 581   CURLcode result = Curl_get_upload_buffer(conn->data);
 582   if(result)
 583     return result;
 584   msg = (struct smb_write *)conn->data->state.ulbuf;
 585
 586   if(upload_size >= MAX_PAYLOAD_SIZE - 1) /* There is one byte of padding */
 587     upload_size = MAX_PAYLOAD_SIZE - 1;
 588
 589   memset(msg, 0, sizeof(*msg));
 590   msg->word_count = SMB_WC_WRITE_ANDX;
 591   msg->andx.command = SMB_COM_NO_ANDX_COMMAND;
 592   msg->fid = smb_swap16(req->fid);
 593   msg->offset = smb_swap32((unsigned int) offset);
 594   msg->offset_high = smb_swap32((unsigned int) (offset >> 32));
 595   msg->data_length = smb_swap16((unsigned short) upload_size);
 596   msg->data_offset = smb_swap16(sizeof(*msg) - sizeof(unsigned int));
 597   msg->byte_count = smb_swap16((unsigned short) (upload_size + 1));
 598
 599   smb_format_message(conn, &msg->h, SMB_COM_WRITE_ANDX,
 600                      sizeof(*msg) - sizeof(msg->h) + (size_t) upload_size);
 601
 602   return smb_send(conn, sizeof(*msg), (size_t) upload_size);
 603 }
 604
 605 static CURLcode smb_send_and_recv(struct connectdata *conn, void **msg)
 606 {
 607   struct smb_conn *smbc = &conn->proto.smbc;
 608   CURLcode result;
 609   *msg = NULL; /* if it returns early */
 610
 611   /* Check if there is data in the transfer buffer */
 612   if(!smbc->send_size && smbc->upload_size) {
 613     size_t nread = smbc->upload_size > conn->data->set.upload_buffer_size ?
 614       conn->data->set.upload_buffer_size :
 615       smbc->upload_size;
 616     conn->data->req.upload_fromhere = conn->data->state.ulbuf;
 617     result = Curl_fillreadbuffer(conn, nread, &nread);
 618     if(result && result != CURLE_AGAIN)
 619       return result;
 620     if(!nread)
 621       return CURLE_OK;
 622
 623     smbc->upload_size -= nread;
 624     smbc->send_size = nread;
 625     smbc->sent = 0;
 626   }
 627
 628   /* Check if there is data to send */
 629   if(smbc->send_size) {
 630     result = smb_flush(conn);
 631     if(result)
 632       return result;
 633   }
 634
 635   /* Check if there is still data to be sent */
 636   if(smbc->send_size || smbc->upload_size)
 637     return CURLE_AGAIN;
 638
 639   return smb_recv_message(conn, msg);
 640 }
 641
 642 static CURLcode smb_connection_state(struct connectdata *conn, bool *done)
 643 {
 644   struct smb_conn *smbc = &conn->proto.smbc;
 645   struct smb_negotiate_response *nrsp;
 646   struct smb_header *h;
 647   CURLcode result;
 648   void *msg = NULL;
 649
 650   if(smbc->state == SMB_CONNECTING) {
 651 #ifdef USE_SSL
 652     if((conn->handler->flags & PROTOPT_SSL)) {
 653       bool ssl_done = FALSE;
 654       result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET, &ssl_done);
 655       if(result && result != CURLE_AGAIN)
 656         return result;
 657       if(!ssl_done)
 658         return CURLE_OK;
 659     }
 660 #endif
 661
 662     result = smb_send_negotiate(conn);
 663     if(result) {
 664       connclose(conn, "SMB: failed to send negotiate message");
 665       return result;
 666     }
 667
 668     conn_state(conn, SMB_NEGOTIATE);
 669   }
 670
 671   /* Send the previous message and check for a response */
 672   result = smb_send_and_recv(conn, &msg);
 673   if(result && result != CURLE_AGAIN) {
 674     connclose(conn, "SMB: failed to communicate");
 675     return result;
 676   }
 677
 678   if(!msg)
 679     return CURLE_OK;
 680
 681   h = msg;
 682
 683   switch(smbc->state) {
 684   case SMB_NEGOTIATE:
 685     if((smbc->got < sizeof(*nrsp) + sizeof(smbc->challenge) - 1) ||
 686        h->status) {
 687       connclose(conn, "SMB: negotiation failed");
 688       return CURLE_COULDNT_CONNECT;
 689     }
 690     nrsp = msg;
 691     memcpy(smbc->challenge, nrsp->bytes, sizeof(smbc->challenge));
 692     smbc->session_key = smb_swap32(nrsp->session_key);
 693     result = smb_send_setup(conn);
 694     if(result) {
 695       connclose(conn, "SMB: failed to send setup message");
 696       return result;
 697     }
 698     conn_state(conn, SMB_SETUP);
 699     break;
 700
 701   case SMB_SETUP:
 702     if(h->status) {
 703       connclose(conn, "SMB: authentication failed");
 704       return CURLE_LOGIN_DENIED;
 705     }
 706     smbc->uid = smb_swap16(h->uid);
 707     conn_state(conn, SMB_CONNECTED);
 708     *done = true;
 709     break;
 710
 711   default:
 712     smb_pop_message(conn);
 713     return CURLE_OK; /* ignore */
 714   }
 715
 716   smb_pop_message(conn);
 717
 718   return CURLE_OK;
 719 }
 720
 721 /*
 722  * Convert a timestamp from the Windows world (100 nsec units from 1 Jan 1601)
 723  * to Posix time. Cap the output to fit within a time_t.
 724  */
 725 static void get_posix_time(time_t *out, curl_off_t timestamp)
 726 {
 727   timestamp -= 116444736000000000;
 728   timestamp /= 10000000;
 729 #if SIZEOF_TIME_T < SIZEOF_CURL_OFF_T
 730   if(timestamp > TIME_T_MAX)
 731     *out = TIME_T_MAX;
 732   else if(timestamp < TIME_T_MIN)
 733     *out = TIME_T_MIN;
 734   else
 735 #endif
 736     *out = (time_t) timestamp;
 737 }
 738
 739 static CURLcode smb_request_state(struct connectdata *conn, bool *done)
 740 {
 741   struct smb_request *req = conn->data->req.protop;
 742   struct smb_header *h;
 743   struct smb_conn *smbc = &conn->proto.smbc;
 744   enum smb_req_state next_state = SMB_DONE;
 745   unsigned short len;
 746   unsigned short off;
 747   CURLcode result;
 748   void *msg = NULL;
 749   const struct smb_nt_create_response *smb_m;
 750
 751   /* Start the request */
 752   if(req->state == SMB_REQUESTING) {
 753     result = smb_send_tree_connect(conn);
 754     if(result) {
 755       connclose(conn, "SMB: failed to send tree connect message");
 756       return result;
 757     }
 758
 759     request_state(conn, SMB_TREE_CONNECT);
 760   }
 761
 762   /* Send the previous message and check for a response */
 763   result = smb_send_and_recv(conn, &msg);
 764   if(result && result != CURLE_AGAIN) {
 765     connclose(conn, "SMB: failed to communicate");
 766     return result;
 767   }
 768
 769   if(!msg)
 770     return CURLE_OK;
 771
 772   h = msg;
 773
 774   switch(req->state) {
 775   case SMB_TREE_CONNECT:
 776     if(h->status) {
 777       req->result = CURLE_REMOTE_FILE_NOT_FOUND;
 778       if(h->status == smb_swap32(SMB_ERR_NOACCESS))
 779         req->result = CURLE_REMOTE_ACCESS_DENIED;
 780       break;
 781     }
 782     req->tid = smb_swap16(h->tid);
 783     next_state = SMB_OPEN;
 784     break;
 785
 786   case SMB_OPEN:
 787     if(h->status || smbc->got < sizeof(struct smb_nt_create_response)) {
 788       req->result = CURLE_REMOTE_FILE_NOT_FOUND;
 789       if(h->status == smb_swap32(SMB_ERR_NOACCESS))
 790         req->result = CURLE_REMOTE_ACCESS_DENIED;
 791       next_state = SMB_TREE_DISCONNECT;
 792       break;
 793     }
 794     smb_m = (const struct smb_nt_create_response*) msg;
 795     req->fid = smb_swap16(smb_m->fid);
 796     conn->data->req.offset = 0;
 797     if(conn->data->set.upload) {
 798       conn->data->req.size = conn->data->state.infilesize;
 799       Curl_pgrsSetUploadSize(conn->data, conn->data->req.size);
 800       next_state = SMB_UPLOAD;
 801     }
 802     else {
 803       smb_m = (const struct smb_nt_create_response*) msg;
 804       conn->data->req.size = smb_swap64(smb_m->end_of_file);
 805       if(conn->data->req.size < 0) {
 806         req->result = CURLE_WEIRD_SERVER_REPLY;
 807         next_state = SMB_CLOSE;
 808       }
 809       else {
 810         Curl_pgrsSetDownloadSize(conn->data, conn->data->req.size);
 811         if(conn->data->set.get_filetime)
 812           get_posix_time(&conn->data->info.filetime, smb_m->last_change_time);
 813         next_state = SMB_DOWNLOAD;
 814       }
 815     }
 816     break;
 817
 818   case SMB_DOWNLOAD:
 819     if(h->status || smbc->got < sizeof(struct smb_header) + 14) {
 820       req->result = CURLE_RECV_ERROR;
 821       next_state = SMB_CLOSE;
 822       break;
 823     }
 824     len = Curl_read16_le(((const unsigned char *) msg) +
 825                          sizeof(struct smb_header) + 11);
 826     off = Curl_read16_le(((const unsigned char *) msg) +
 827                          sizeof(struct smb_header) + 13);
 828     if(len > 0) {
 829       if(off + sizeof(unsigned int) + len > smbc->got) {
 830         failf(conn->data, "Invalid input packet");
 831         result = CURLE_RECV_ERROR;
 832       }
 833       else
 834         result = Curl_client_write(conn, CLIENTWRITE_BODY,
 835                                    (char *)msg + off + sizeof(unsigned int),
 836                                    len);
 837       if(result) {
 838         req->result = result;
 839         next_state = SMB_CLOSE;
 840         break;
 841       }
 842     }
 843     conn->data->req.bytecount += len;
 844     conn->data->req.offset += len;
 845     Curl_pgrsSetDownloadCounter(conn->data, conn->data->req.bytecount);
 846     next_state = (len < MAX_PAYLOAD_SIZE) ? SMB_CLOSE : SMB_DOWNLOAD;
 847     break;
 848
 849   case SMB_UPLOAD:
 850     if(h->status || smbc->got < sizeof(struct smb_header) + 6) {
 851       req->result = CURLE_UPLOAD_FAILED;
 852       next_state = SMB_CLOSE;
 853       break;
 854     }
 855     len = Curl_read16_le(((const unsigned char *) msg) +
 856                          sizeof(struct smb_header) + 5);
 857     conn->data->req.bytecount += len;
 858     conn->data->req.offset += len;
 859     Curl_pgrsSetUploadCounter(conn->data, conn->data->req.bytecount);
 860     if(conn->data->req.bytecount >= conn->data->req.size)
 861       next_state = SMB_CLOSE;
 862     else
 863       next_state = SMB_UPLOAD;
 864     break;
 865
 866   case SMB_CLOSE:
 867     /* We don't care if the close failed, proceed to tree disconnect anyway */
 868     next_state = SMB_TREE_DISCONNECT;
 869     break;
 870
 871   case SMB_TREE_DISCONNECT:
 872     next_state = SMB_DONE;
 873     break;
 874
 875   default:
 876     smb_pop_message(conn);
 877     return CURLE_OK; /* ignore */
 878   }
 879
 880   smb_pop_message(conn);
 881
 882   switch(next_state) {
 883   case SMB_OPEN:
 884     result = smb_send_open(conn);
 885     break;
 886
 887   case SMB_DOWNLOAD:
 888     result = smb_send_read(conn);
 889     break;
 890
 891   case SMB_UPLOAD:
 892     result = smb_send_write(conn);
 893     break;
 894
 895   case SMB_CLOSE:
 896     result = smb_send_close(conn);
 897     break;
 898
 899   case SMB_TREE_DISCONNECT:
 900     result = smb_send_tree_disconnect(conn);
 901     break;
 902
 903   case SMB_DONE:
 904     result = req->result;
 905     *done = true;
 906     break;
 907
 908   default:
 909     break;
 910   }
 911
 912   if(result) {
 913     connclose(conn, "SMB: failed to send message");
 914     return result;
 915   }
 916
 917   request_state(conn, next_state);
 918
 919   return CURLE_OK;
 920 }
 921
 922 static CURLcode smb_done(struct connectdata *conn, CURLcode status,
 923                          bool premature)
 924 {
 925   (void) premature;
 926   Curl_safefree(conn->data->req.protop);
 927   return status;
 928 }
 929
 930 static CURLcode smb_disconnect(struct connectdata *conn, bool dead)
 931 {
 932   struct smb_conn *smbc = &conn->proto.smbc;
 933   (void) dead;
 934   Curl_safefree(smbc->share);
 935   Curl_safefree(smbc->domain);
 936   Curl_safefree(smbc->recv_buf);
 937   return CURLE_OK;
 938 }
 939
 940 static int smb_getsock(struct connectdata *conn, curl_socket_t *socks)
 941 {
 942   socks[0] = conn->sock[FIRSTSOCKET];
 943   return GETSOCK_READSOCK(0) | GETSOCK_WRITESOCK(0);
 944 }
 945
 946 static CURLcode smb_do(struct connectdata *conn, bool *done)
 947 {
 948   struct smb_conn *smbc = &conn->proto.smbc;
 949
 950   *done = FALSE;
 951   if(smbc->share) {
 952     return CURLE_OK;
 953   }
 954   return CURLE_URL_MALFORMAT;
 955 }
 956
 957 static CURLcode smb_parse_url_path(struct connectdata *conn)
 958 {
 959   struct Curl_easy *data = conn->data;
 960   struct smb_request *req = data->req.protop;
 961   struct smb_conn *smbc = &conn->proto.smbc;
 962   char *path;
 963   char *slash;
 964
 965   /* URL decode the path */
 966   CURLcode result = Curl_urldecode(data, data->state.up.path, 0, &path, NULL,
 967                                    REJECT_CTRL);
 968   if(result)
 969     return result;
 970
 971   /* Parse the path for the share */
 972   smbc->share = strdup((*path == '/' || *path == '\\') ? path + 1 : path);
 973   free(path);
 974   if(!smbc->share)
 975     return CURLE_OUT_OF_MEMORY;
 976
 977   slash = strchr(smbc->share, '/');
 978   if(!slash)
 979     slash = strchr(smbc->share, '\\');
 980
 981   /* The share must be present */
 982   if(!slash) {
 983     Curl_safefree(smbc->share);
 984     return CURLE_URL_MALFORMAT;
 985   }
 986
 987   /* Parse the path for the file path converting any forward slashes into
 988      backslashes */
 989   *slash++ = 0;
 990   req->path = slash;
 991
 992   for(; *slash; slash++) {
 993     if(*slash == '/')
 994       *slash = '\\';
 995   }
 996   return CURLE_OK;
 997 }
 998
 999 #endif /* CURL_DISABLE_SMB && USE_CURL_NTLM_CORE &&
1000           CURL_SIZEOF_CURL_OFF_T > 4 */