s3:libsmb: get rid of cli_state_*_sockaddr
[samba.git] / source3 / libsmb / clientgen.c
1 /* 
2    Unix SMB/CIFS implementation.
3    SMB client generic functions
4    Copyright (C) Andrew Tridgell 1994-1998
5    Copyright (C) Jeremy Allison 2007.
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "libsmb/libsmb.h"
23 #include "../lib/util/tevent_ntstatus.h"
24 #include "../libcli/smb/smb_signing.h"
25 #include "../libcli/smb/smb_seal.h"
26 #include "async_smb.h"
27 #include "../libcli/smb/smbXcli_base.h"
28 #include "../librpc/ndr/libndr.h"
29
30 /*******************************************************************
31  Setup the word count and byte count for a client smb message.
32 ********************************************************************/
33
34 int cli_set_message(char *buf,int num_words,int num_bytes,bool zero)
35 {
36         if (zero && (num_words || num_bytes)) {
37                 memset(buf + smb_size,'\0',num_words*2 + num_bytes);
38         }
39         SCVAL(buf,smb_wct,num_words);
40         SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
41         smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
42         return (smb_size + num_words*2 + num_bytes);
43 }
44
45 /****************************************************************************
46  Change the timeout (in milliseconds).
47 ****************************************************************************/
48
49 unsigned int cli_set_timeout(struct cli_state *cli, unsigned int timeout)
50 {
51         unsigned int old_timeout = cli->timeout;
52         cli->timeout = timeout;
53         return old_timeout;
54 }
55
56 /****************************************************************************
57  Set the 'backup_intent' flag.
58 ****************************************************************************/
59
60 bool cli_set_backup_intent(struct cli_state *cli, bool flag)
61 {
62         bool old_state = cli->backup_intent;
63         cli->backup_intent = flag;
64         return old_state;
65 }
66
67 /****************************************************************************
68  convenience routine to find if we negotiated ucs2
69 ****************************************************************************/
70
71 bool cli_ucs2(struct cli_state *cli)
72 {
73         return smbXcli_conn_use_unicode(cli->conn);
74 }
75
76 /****************************************************************************
77  Initialize Domain, user or password.
78 ****************************************************************************/
79
80 NTSTATUS cli_set_domain(struct cli_state *cli, const char *domain)
81 {
82         TALLOC_FREE(cli->domain);
83         cli->domain = talloc_strdup(cli, domain ? domain : "");
84         if (cli->domain == NULL) {
85                 return NT_STATUS_NO_MEMORY;
86         }
87         return NT_STATUS_OK;
88 }
89
90 NTSTATUS cli_set_username(struct cli_state *cli, const char *username)
91 {
92         TALLOC_FREE(cli->user_name);
93         cli->user_name = talloc_strdup(cli, username ? username : "");
94         if (cli->user_name == NULL) {
95                 return NT_STATUS_NO_MEMORY;
96         }
97         return NT_STATUS_OK;
98 }
99
100 NTSTATUS cli_set_password(struct cli_state *cli, const char *password)
101 {
102         TALLOC_FREE(cli->password);
103
104         /* Password can be NULL. */
105         if (password) {
106                 cli->password = talloc_strdup(cli, password);
107                 if (cli->password == NULL) {
108                         return NT_STATUS_NO_MEMORY;
109                 }
110         } else {
111                 /* Use zero NTLMSSP hashes and session key. */
112                 cli->password = NULL;
113         }
114
115         return NT_STATUS_OK;
116 }
117
118 /****************************************************************************
119  Initialise credentials of a client structure.
120 ****************************************************************************/
121
122 NTSTATUS cli_init_creds(struct cli_state *cli, const char *username, const char *domain, const char *password)
123 {
124         NTSTATUS status = cli_set_username(cli, username);
125         if (!NT_STATUS_IS_OK(status)) {
126                 return status;
127         }
128         status = cli_set_domain(cli, domain);
129         if (!NT_STATUS_IS_OK(status)) {
130                 return status;
131         }
132         DEBUG(10,("cli_init_creds: user %s domain %s\n", cli->user_name, cli->domain));
133
134         return cli_set_password(cli, password);
135 }
136
137 /****************************************************************************
138  Initialise a client structure. Always returns a talloc'ed struct.
139  Set the signing state (used from the command line).
140 ****************************************************************************/
141
142 struct cli_state *cli_state_create(TALLOC_CTX *mem_ctx,
143                                    int fd,
144                                    const char *remote_name,
145                                    const char *remote_realm,
146                                    int signing_state, int flags)
147 {
148         struct cli_state *cli = NULL;
149         bool use_spnego = lp_client_use_spnego();
150         bool force_dos_errors = false;
151         bool force_ascii = false;
152         bool use_level_II_oplocks = false;
153         uint32_t smb1_capabilities = 0;
154         uint32_t smb2_capabilities = 0;
155         struct GUID client_guid = GUID_random();
156
157         /* Check the effective uid - make sure we are not setuid */
158         if (is_setuid_root()) {
159                 DEBUG(0,("libsmb based programs must *NOT* be setuid root.\n"));
160                 return NULL;
161         }
162
163         cli = talloc_zero(mem_ctx, struct cli_state);
164         if (!cli) {
165                 return NULL;
166         }
167
168         cli->server_domain = talloc_strdup(cli, "");
169         if (!cli->server_domain) {
170                 goto error;
171         }
172         cli->server_os = talloc_strdup(cli, "");
173         if (!cli->server_os) {
174                 goto error;
175         }
176         cli->server_type = talloc_strdup(cli, "");
177         if (!cli->server_type) {
178                 goto error;
179         }
180
181         cli->dfs_mountpoint = talloc_strdup(cli, "");
182         if (!cli->dfs_mountpoint) {
183                 goto error;
184         }
185         cli->raw_status = NT_STATUS_INTERNAL_ERROR;
186         cli->map_dos_errors = true; /* remove this */
187         cli->timeout = 20000; /* Timeout is in milliseconds. */
188         cli->case_sensitive = false;
189
190         /* Set the CLI_FORCE_DOSERR environment variable to test
191            client routines using DOS errors instead of STATUS32
192            ones.  This intended only as a temporary hack. */    
193         if (getenv("CLI_FORCE_DOSERR")) {
194                 force_dos_errors = true;
195         }
196         if (flags & CLI_FULL_CONNECTION_FORCE_DOS_ERRORS) {
197                 force_dos_errors = true;
198         }
199
200         if (getenv("CLI_FORCE_ASCII")) {
201                 force_ascii = true;
202         }
203         if (flags & CLI_FULL_CONNECTION_FORCE_ASCII) {
204                 force_ascii = true;
205         }
206
207         if (flags & CLI_FULL_CONNECTION_DONT_SPNEGO) {
208                 use_spnego = false;
209         } else if (flags & CLI_FULL_CONNECTION_USE_KERBEROS) {
210                 cli->use_kerberos = true;
211         }
212         if ((flags & CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS) &&
213              cli->use_kerberos) {
214                 cli->fallback_after_kerberos = true;
215         }
216
217         if (flags & CLI_FULL_CONNECTION_USE_CCACHE) {
218                 cli->use_ccache = true;
219         }
220
221         if (flags & CLI_FULL_CONNECTION_OPLOCKS) {
222                 cli->use_oplocks = true;
223         }
224         if (flags & CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS) {
225                 use_level_II_oplocks = true;
226         }
227
228         if (signing_state == SMB_SIGNING_DEFAULT) {
229                 signing_state = lp_client_signing();
230         }
231
232         smb1_capabilities = 0;
233         smb1_capabilities |= CAP_LARGE_FILES;
234         smb1_capabilities |= CAP_NT_SMBS | CAP_RPC_REMOTE_APIS;
235         smb1_capabilities |= CAP_LOCK_AND_READ | CAP_NT_FIND;
236         smb1_capabilities |= CAP_DFS | CAP_W2K_SMBS;
237         smb1_capabilities |= CAP_LARGE_READX|CAP_LARGE_WRITEX;
238         smb1_capabilities |= CAP_LWIO;
239
240         if (!force_dos_errors) {
241                 smb1_capabilities |= CAP_STATUS32;
242         }
243
244         if (!force_ascii) {
245                 smb1_capabilities |= CAP_UNICODE;
246         }
247
248         if (use_spnego) {
249                 smb1_capabilities |= CAP_EXTENDED_SECURITY;
250         }
251
252         if (use_level_II_oplocks) {
253                 smb1_capabilities |= CAP_LEVEL_II_OPLOCKS;
254         }
255
256         smb2_capabilities = SMB2_CAP_ALL;
257
258         if (remote_realm) {
259                 cli->remote_realm = talloc_strdup(cli, remote_realm);
260                 if (cli->remote_realm == NULL) {
261                         goto error;
262                 }
263         }
264
265         cli->conn = smbXcli_conn_create(cli, fd, remote_name,
266                                         signing_state,
267                                         smb1_capabilities,
268                                         &client_guid,
269                                         smb2_capabilities);
270         if (cli->conn == NULL) {
271                 goto error;
272         }
273
274         cli->smb1.pid = (uint16_t)getpid();
275         cli->smb1.vc_num = cli->smb1.pid;
276         cli->smb1.tid = UINT16_MAX;
277         cli->smb1.uid = UID_FIELD_INVALID;
278
279         cli->initialised = 1;
280         return cli;
281
282         /* Clean up after malloc() error */
283
284  error:
285
286         TALLOC_FREE(cli);
287         return NULL;
288 }
289
290 bool cli_state_encryption_on(struct cli_state *cli)
291 {
292         return smb1cli_conn_encryption_on(cli->conn);
293 }
294
295
296 /****************************************************************************
297  Close all pipes open on this session.
298 ****************************************************************************/
299
300 void cli_nt_pipes_close(struct cli_state *cli)
301 {
302         while (cli->pipe_list != NULL) {
303                 /*
304                  * No TALLOC_FREE here!
305                  */
306                 talloc_free(cli->pipe_list);
307         }
308 }
309
310 /****************************************************************************
311  Shutdown a client structure.
312 ****************************************************************************/
313
314 static void _cli_shutdown(struct cli_state *cli)
315 {
316         cli_nt_pipes_close(cli);
317
318         /*
319          * tell our peer to free his resources.  Wihtout this, when an
320          * application attempts to do a graceful shutdown and calls
321          * smbc_free_context() to clean up all connections, some connections
322          * can remain active on the peer end, until some (long) timeout period
323          * later.  This tree disconnect forces the peer to clean up, since the
324          * connection will be going away.
325          */
326         if (cli_state_has_tcon(cli)) {
327                 cli_tdis(cli);
328         }
329         
330         data_blob_free(&cli->user_session_key);
331
332         cli_state_disconnect(cli);
333
334         TALLOC_FREE(cli);
335 }
336
337 void cli_shutdown(struct cli_state *cli)
338 {
339         struct cli_state *cli_head;
340         if (cli == NULL) {
341                 return;
342         }
343         DLIST_HEAD(cli, cli_head);
344         if (cli_head == cli) {
345                 /*
346                  * head of a DFS list, shutdown all subsidiary DFS
347                  * connections.
348                  */
349                 struct cli_state *p, *next;
350
351                 for (p = cli_head->next; p; p = next) {
352                         next = p->next;
353                         DLIST_REMOVE(cli_head, p);
354                         _cli_shutdown(p);
355                 }
356         } else {
357                 DLIST_REMOVE(cli_head, cli);
358         }
359
360         _cli_shutdown(cli);
361 }
362
363 const char *cli_state_remote_name(struct cli_state *cli)
364 {
365         return smbXcli_conn_remote_name(cli->conn);
366 }
367
368 const char *cli_state_remote_realm(struct cli_state *cli)
369 {
370         return cli->remote_realm;
371 }
372
373 uint16_t cli_state_get_vc_num(struct cli_state *cli)
374 {
375         return cli->smb1.vc_num;
376 }
377
378 uint32_t cli_state_server_session_key(struct cli_state *cli)
379 {
380         return smb1cli_conn_server_session_key(cli->conn);
381 }
382
383 /****************************************************************************
384  Set the PID to use for smb messages. Return the old pid.
385 ****************************************************************************/
386
387 uint16 cli_setpid(struct cli_state *cli, uint16 pid)
388 {
389         uint16_t ret = cli->smb1.pid;
390         cli->smb1.pid = pid;
391         return ret;
392 }
393
394 uint16_t cli_getpid(struct cli_state *cli)
395 {
396         return cli->smb1.pid;
397 }
398
399 bool cli_state_has_tcon(struct cli_state *cli)
400 {
401         if (cli->smb1.tid == UINT16_MAX) {
402                 return false;
403         }
404
405         return true;
406 }
407
408 uint16_t cli_state_get_tid(struct cli_state *cli)
409 {
410         return cli->smb1.tid;
411 }
412
413 uint16_t cli_state_set_tid(struct cli_state *cli, uint16_t tid)
414 {
415         uint16_t ret = cli->smb1.tid;
416         cli->smb1.tid = tid;
417         return ret;
418 }
419
420 uint16_t cli_state_get_uid(struct cli_state *cli)
421 {
422         return cli->smb1.uid;
423 }
424
425 uint16_t cli_state_set_uid(struct cli_state *cli, uint16_t uid)
426 {
427         uint16_t ret = cli->smb1.uid;
428         cli->smb1.uid = uid;
429         return ret;
430 }
431
432 /****************************************************************************
433  Set the case sensitivity flag on the packets. Returns old state.
434 ****************************************************************************/
435
436 bool cli_set_case_sensitive(struct cli_state *cli, bool case_sensitive)
437 {
438         bool ret = cli->case_sensitive;
439         cli->case_sensitive = case_sensitive;
440         return ret;
441 }
442
443 enum protocol_types cli_state_protocol(struct cli_state *cli)
444 {
445         return smbXcli_conn_protocol(cli->conn);
446 }
447
448 uint32_t cli_state_capabilities(struct cli_state *cli)
449 {
450         return smb1cli_conn_capabilities(cli->conn);
451 }
452
453 uint32_t cli_state_available_size(struct cli_state *cli, uint32_t ofs)
454 {
455         uint32_t ret = smb1cli_conn_max_xmit(cli->conn);
456
457         if (ofs >= ret) {
458                 return 0;
459         }
460
461         ret -= ofs;
462
463         return ret;
464 }
465
466 uint16_t cli_state_max_requests(struct cli_state *cli)
467 {
468         return smbXcli_conn_max_requests(cli->conn);
469 }
470
471 const uint8_t *cli_state_server_challenge(struct cli_state *cli)
472 {
473         return smb1cli_conn_server_challenge(cli->conn);
474 }
475
476 const DATA_BLOB *cli_state_server_gss_blob(struct cli_state *cli)
477 {
478         return smbXcli_conn_server_gss_blob(cli->conn);
479 }
480
481 uint16_t cli_state_security_mode(struct cli_state *cli)
482 {
483         return smb1cli_conn_server_security_mode(cli->conn);
484 }
485
486 int cli_state_server_time_zone(struct cli_state *cli)
487 {
488         return smb1cli_conn_server_time_zone(cli->conn);
489 }
490
491 time_t cli_state_server_time(struct cli_state *cli)
492 {
493         NTTIME nt;
494         time_t t;
495
496         nt = smbXcli_conn_server_system_time(cli->conn);
497         t = nt_time_to_unix(nt);
498
499         return t;
500 }
501
502 struct cli_echo_state {
503         uint16_t vwv[1];
504         DATA_BLOB data;
505         int num_echos;
506 };
507
508 static void cli_echo_done(struct tevent_req *subreq);
509
510 struct tevent_req *cli_echo_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
511                                  struct cli_state *cli, uint16_t num_echos,
512                                  DATA_BLOB data)
513 {
514         struct tevent_req *req, *subreq;
515         struct cli_echo_state *state;
516
517         req = tevent_req_create(mem_ctx, &state, struct cli_echo_state);
518         if (req == NULL) {
519                 return NULL;
520         }
521         SSVAL(state->vwv, 0, num_echos);
522         state->data = data;
523         state->num_echos = num_echos;
524
525         subreq = cli_smb_send(state, ev, cli, SMBecho, 0, 1, state->vwv,
526                               data.length, data.data);
527         if (subreq == NULL) {
528                 goto fail;
529         }
530         tevent_req_set_callback(subreq, cli_echo_done, req);
531         return req;
532  fail:
533         TALLOC_FREE(req);
534         return NULL;
535 }
536
537 static void cli_echo_done(struct tevent_req *subreq)
538 {
539         struct tevent_req *req = tevent_req_callback_data(
540                 subreq, struct tevent_req);
541         struct cli_echo_state *state = tevent_req_data(
542                 req, struct cli_echo_state);
543         NTSTATUS status;
544         uint32_t num_bytes;
545         uint8_t *bytes;
546         uint8_t *inbuf;
547
548         status = cli_smb_recv(subreq, state, &inbuf, 0, NULL, NULL,
549                               &num_bytes, &bytes);
550         if (!NT_STATUS_IS_OK(status)) {
551                 tevent_req_nterror(req, status);
552                 return;
553         }
554         if ((num_bytes != state->data.length)
555             || (memcmp(bytes, state->data.data, num_bytes) != 0)) {
556                 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
557                 return;
558         }
559
560         state->num_echos -=1;
561         if (state->num_echos == 0) {
562                 tevent_req_done(req);
563                 return;
564         }
565
566         if (!smbXcli_req_set_pending(subreq)) {
567                 tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
568                 return;
569         }
570 }
571
572 /**
573  * Get the result out from an echo request
574  * @param[in] req       The async_req from cli_echo_send
575  * @retval Did the server reply correctly?
576  */
577
578 NTSTATUS cli_echo_recv(struct tevent_req *req)
579 {
580         return tevent_req_simple_recv_ntstatus(req);
581 }
582
583 /**
584  * @brief Send/Receive SMBEcho requests
585  * @param[in] mem_ctx   The memory context to put the async_req on
586  * @param[in] ev        The event context that will call us back
587  * @param[in] cli       The connection to send the echo to
588  * @param[in] num_echos How many times do we want to get the reply?
589  * @param[in] data      The data we want to get back
590  * @retval Did the server reply correctly?
591  */
592
593 NTSTATUS cli_echo(struct cli_state *cli, uint16_t num_echos, DATA_BLOB data)
594 {
595         TALLOC_CTX *frame = talloc_stackframe();
596         struct event_context *ev;
597         struct tevent_req *req;
598         NTSTATUS status = NT_STATUS_OK;
599
600         if (cli_has_async_calls(cli)) {
601                 /*
602                  * Can't use sync call while an async call is in flight
603                  */
604                 status = NT_STATUS_INVALID_PARAMETER;
605                 goto fail;
606         }
607
608         ev = event_context_init(frame);
609         if (ev == NULL) {
610                 status = NT_STATUS_NO_MEMORY;
611                 goto fail;
612         }
613
614         req = cli_echo_send(frame, ev, cli, num_echos, data);
615         if (req == NULL) {
616                 status = NT_STATUS_NO_MEMORY;
617                 goto fail;
618         }
619
620         if (!tevent_req_poll(req, ev)) {
621                 status = map_nt_error_from_unix(errno);
622                 goto fail;
623         }
624
625         status = cli_echo_recv(req);
626  fail:
627         TALLOC_FREE(frame);
628         return status;
629 }
630
631 /**
632  * Is the SMB command able to hold an AND_X successor
633  * @param[in] cmd       The SMB command in question
634  * @retval Can we add a chained request after "cmd"?
635  */
636 bool is_andx_req(uint8_t cmd)
637 {
638         switch (cmd) {
639         case SMBtconX:
640         case SMBlockingX:
641         case SMBopenX:
642         case SMBreadX:
643         case SMBwriteX:
644         case SMBsesssetupX:
645         case SMBulogoffX:
646         case SMBntcreateX:
647                 return true;
648                 break;
649         default:
650                 break;
651         }
652
653         return false;
654 }
655
656 NTSTATUS cli_smb(TALLOC_CTX *mem_ctx, struct cli_state *cli,
657                  uint8_t smb_command, uint8_t additional_flags,
658                  uint8_t wct, uint16_t *vwv,
659                  uint32_t num_bytes, const uint8_t *bytes,
660                  struct tevent_req **result_parent,
661                  uint8_t min_wct, uint8_t *pwct, uint16_t **pvwv,
662                  uint32_t *pnum_bytes, uint8_t **pbytes)
663 {
664         struct tevent_context *ev;
665         struct tevent_req *req = NULL;
666         NTSTATUS status = NT_STATUS_NO_MEMORY;
667
668         if (cli_has_async_calls(cli)) {
669                 return NT_STATUS_INVALID_PARAMETER;
670         }
671         ev = tevent_context_init(mem_ctx);
672         if (ev == NULL) {
673                 goto fail;
674         }
675         req = cli_smb_send(mem_ctx, ev, cli, smb_command, additional_flags,
676                            wct, vwv, num_bytes, bytes);
677         if (req == NULL) {
678                 goto fail;
679         }
680         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
681                 goto fail;
682         }
683         status = cli_smb_recv(req, NULL, NULL, min_wct, pwct, pvwv,
684                               pnum_bytes, pbytes);
685 fail:
686         TALLOC_FREE(ev);
687         if (NT_STATUS_IS_OK(status) && (result_parent != NULL)) {
688                 *result_parent = req;
689         }
690         return status;
691 }