1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 2014, Bill Nagel <wnagel@tycoint.com>, Exacq Technologies
9 * Copyright (C) 2016-2019, 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#ifdef CURL_WINDOWS_APP
36#define getpid GetCurrentProcessId
37#elif !defined(MSDOS)
38#define getpid _getpid
39#endif
40#endif
41
42#include "smb.h"
43#include "urldata.h"
44#include "sendf.h"
45#include "multiif.h"
46#include "connect.h"
47#include "progress.h"
48#include "transfer.h"
49#include "vtls/vtls.h"
50#include "curl_ntlm_core.h"
51#include "escape.h"
52#include "curl_endian.h"
53
54/* The last #include files should be: */
55#include "curl_memory.h"
56#include "memdebug.h"
57
58/* Local API functions */
59static CURLcode smb_setup_connection(struct connectdata *conn);
60static CURLcode smb_connect(struct connectdata *conn, bool *done);
61static CURLcode smb_connection_state(struct connectdata *conn, bool *done);
62static CURLcode smb_do(struct connectdata *conn, bool *done);
63static CURLcode smb_request_state(struct connectdata *conn, bool *done);
64static CURLcode smb_done(struct connectdata *conn, CURLcode status,
65 bool premature);
66static CURLcode smb_disconnect(struct connectdata *conn, bool dead);
67static int smb_getsock(struct connectdata *conn, curl_socket_t *socks);
68static CURLcode smb_parse_url_path(struct connectdata *conn);
69
70/*
71 * SMB handler interface
72 */
73const struct Curl_handler Curl_handler_smb = {
74 "SMB", /* scheme */
75 smb_setup_connection, /* setup_connection */
76 smb_do, /* do_it */
77 smb_done, /* done */
78 ZERO_NULL, /* do_more */
79 smb_connect, /* connect_it */
80 smb_connection_state, /* connecting */
81 smb_request_state, /* doing */
82 smb_getsock, /* proto_getsock */
83 smb_getsock, /* doing_getsock */
84 ZERO_NULL, /* domore_getsock */
85 ZERO_NULL, /* perform_getsock */
86 smb_disconnect, /* disconnect */
87 ZERO_NULL, /* readwrite */
88 ZERO_NULL, /* connection_check */
89 PORT_SMB, /* defport */
90 CURLPROTO_SMB, /* protocol */
91 PROTOPT_NONE /* flags */
92};
93
94#ifdef USE_SSL
95/*
96 * SMBS handler interface
97 */
98const struct Curl_handler Curl_handler_smbs = {
99 "SMBS", /* scheme */
100 smb_setup_connection, /* setup_connection */
101 smb_do, /* do_it */
102 smb_done, /* done */
103 ZERO_NULL, /* do_more */
104 smb_connect, /* connect_it */
105 smb_connection_state, /* connecting */
106 smb_request_state, /* doing */
107 smb_getsock, /* proto_getsock */
108 smb_getsock, /* doing_getsock */
109 ZERO_NULL, /* domore_getsock */
110 ZERO_NULL, /* perform_getsock */
111 smb_disconnect, /* disconnect */
112 ZERO_NULL, /* readwrite */
113 ZERO_NULL, /* connection_check */
114 PORT_SMBS, /* defport */
115 CURLPROTO_SMBS, /* protocol */
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__)
138static unsigned short smb_swap16(unsigned short x)
139{
140 return (unsigned short) ((x << 8) | ((x >> 8) & 0xff));
141}
142
143static unsigned int smb_swap32(unsigned int x)
144{
145 return (x << 24) | ((x << 8) & 0xff0000) | ((x >> 8) & 0xff00) |
146 ((x >> 24) & 0xff);
147}
148
149static 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 */
162enum 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 */
174struct 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
182static 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
204static 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 */
232static 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
245static 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
287static 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
334static void smb_pop_message(struct connectdata *conn)
335{
336 struct smb_conn *smbc = &conn->proto.smbc;
337
338 smbc->got = 0;
339}
340
341static 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
362static 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
384static 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
408static 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
422static 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
429static 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
479static 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
506static 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
536static 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
548static 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
557static 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
575static 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
605static 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
642static 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 */
725static 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
739static 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
922static 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
930static 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
940static 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
946static 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
957static 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 TRUE);
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 /* !USE_WINDOWS_SSPI || USE_WIN32_CRYPTO */
1000
1001#endif /* CURL_DISABLE_SMB && USE_NTLM && CURL_SIZEOF_CURL_OFF_T > 4 */
1002