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 #include "../include/client.h"
  30
  31 /*******************************************************************
  32  Setup the word count and byte count for a client smb message.
  33 ********************************************************************/
  34
  35 int cli_set_message(char *buf,int num_words,int num_bytes,bool zero)
  36 {
  37         if (zero && (num_words || num_bytes)) {
  38                 memset(buf + smb_size,'\0',num_words*2 + num_bytes);
  39         }
  40         SCVAL(buf,smb_wct,num_words);
  41         SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
  42         smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
  43         return (smb_size + num_words*2 + num_bytes);
  44 }
  45
  46 /****************************************************************************
  47  Change the timeout (in milliseconds).
  48 ****************************************************************************/
  49
  50 unsigned int cli_set_timeout(struct cli_state *cli, unsigned int timeout)
  51 {
  52         unsigned int old_timeout = cli->timeout;
  53         cli->timeout = timeout;
  54         return old_timeout;
  55 }
  56
  57 /****************************************************************************
  58  Set the 'backup_intent' flag.
  59 ****************************************************************************/
  60
  61 bool cli_set_backup_intent(struct cli_state *cli, bool flag)
  62 {
  63         bool old_state = cli->backup_intent;
  64         cli->backup_intent = flag;
  65         return old_state;
  66 }
  67
  68 /****************************************************************************
  69  Initialise a client structure. Always returns a talloc'ed struct.
  70  Set the signing state (used from the command line).
  71 ****************************************************************************/
  72
  73 struct GUID cli_state_client_guid;
  74
  75 struct cli_state *cli_state_create(TALLOC_CTX *mem_ctx,
  76                                    int fd,
  77                                    const char *remote_name,
  78                                    const char *remote_realm,
  79                                    int signing_state, int flags)
  80 {
  81         struct cli_state *cli = NULL;
  82         bool use_spnego = lp_client_use_spnego();
  83         bool force_dos_errors = false;
  84         bool force_ascii = false;
  85         bool use_level_II_oplocks = false;
  86         uint32_t smb1_capabilities = 0;
  87         uint32_t smb2_capabilities = 0;
  88         struct GUID client_guid;
  89
  90         if (!GUID_all_zero(&cli_state_client_guid)) {
  91                 client_guid = cli_state_client_guid;
  92         } else {
  93                 client_guid = GUID_random();
  94         }
  95
  96         /* Check the effective uid - make sure we are not setuid */
  97         if (is_setuid_root()) {
  98                 DEBUG(0,("libsmb based programs must *NOT* be setuid root.\n"));
  99                 return NULL;
 100         }
 101
 102         cli = talloc_zero(mem_ctx, struct cli_state);
 103         if (!cli) {
 104                 return NULL;
 105         }
 106
 107         cli->server_domain = talloc_strdup(cli, "");
 108         if (!cli->server_domain) {
 109                 goto error;
 110         }
 111         cli->server_os = talloc_strdup(cli, "");
 112         if (!cli->server_os) {
 113                 goto error;
 114         }
 115         cli->server_type = talloc_strdup(cli, "");
 116         if (!cli->server_type) {
 117                 goto error;
 118         }
 119
 120         cli->dfs_mountpoint = talloc_strdup(cli, "");
 121         if (!cli->dfs_mountpoint) {
 122                 goto error;
 123         }
 124         cli->raw_status = NT_STATUS_INTERNAL_ERROR;
 125         cli->map_dos_errors = true; /* remove this */
 126         cli->timeout = CLIENT_TIMEOUT;
 127
 128         /* Set the CLI_FORCE_DOSERR environment variable to test
 129            client routines using DOS errors instead of STATUS32
 130            ones.  This intended only as a temporary hack. */
 131         if (getenv("CLI_FORCE_DOSERR")) {
 132                 force_dos_errors = true;
 133         }
 134         if (flags & CLI_FULL_CONNECTION_FORCE_DOS_ERRORS) {
 135                 force_dos_errors = true;
 136         }
 137
 138         if (getenv("CLI_FORCE_ASCII")) {
 139                 force_ascii = true;
 140         }
 141         if (!lp_unicode()) {
 142                 force_ascii = true;
 143         }
 144         if (flags & CLI_FULL_CONNECTION_FORCE_ASCII) {
 145                 force_ascii = true;
 146         }
 147
 148         if (flags & CLI_FULL_CONNECTION_DONT_SPNEGO) {
 149                 use_spnego = false;
 150         } else if (flags & CLI_FULL_CONNECTION_USE_KERBEROS) {
 151                 cli->use_kerberos = true;
 152         }
 153         if ((flags & CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS) &&
 154              cli->use_kerberos) {
 155                 cli->fallback_after_kerberos = true;
 156         }
 157
 158         if (flags & CLI_FULL_CONNECTION_USE_CCACHE) {
 159                 cli->use_ccache = true;
 160         }
 161
 162         if (flags & CLI_FULL_CONNECTION_USE_NT_HASH) {
 163                 cli->pw_nt_hash = true;
 164         }
 165
 166         if (flags & CLI_FULL_CONNECTION_OPLOCKS) {
 167                 cli->use_oplocks = true;
 168         }
 169         if (flags & CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS) {
 170                 use_level_II_oplocks = true;
 171         }
 172
 173         if (signing_state == SMB_SIGNING_IPC_DEFAULT) {
 174                 /*
 175                  * Ensure for IPC/RPC the default is to require
 176                  * signing unless explicitly turned off by the
 177                  * administrator.
 178                  */
 179                 signing_state = lp_client_ipc_signing();
 180         }
 181
 182         if (signing_state == SMB_SIGNING_DEFAULT) {
 183                 signing_state = lp_client_signing();
 184         }
 185
 186         smb1_capabilities = 0;
 187         smb1_capabilities |= CAP_LARGE_FILES;
 188         smb1_capabilities |= CAP_NT_SMBS | CAP_RPC_REMOTE_APIS;
 189         smb1_capabilities |= CAP_LOCK_AND_READ | CAP_NT_FIND;
 190         smb1_capabilities |= CAP_DFS | CAP_W2K_SMBS;
 191         smb1_capabilities |= CAP_LARGE_READX|CAP_LARGE_WRITEX;
 192         smb1_capabilities |= CAP_LWIO;
 193
 194         if (!force_dos_errors) {
 195                 smb1_capabilities |= CAP_STATUS32;
 196         }
 197
 198         if (!force_ascii) {
 199                 smb1_capabilities |= CAP_UNICODE;
 200         }
 201
 202         if (use_spnego) {
 203                 smb1_capabilities |= CAP_EXTENDED_SECURITY;
 204         }
 205
 206         if (use_level_II_oplocks) {
 207                 smb1_capabilities |= CAP_LEVEL_II_OPLOCKS;
 208         }
 209
 210         smb2_capabilities = SMB2_CAP_ALL;
 211
 212         if (remote_realm) {
 213                 cli->remote_realm = talloc_strdup(cli, remote_realm);
 214                 if (cli->remote_realm == NULL) {
 215                         goto error;
 216                 }
 217         }
 218
 219         cli->conn = smbXcli_conn_create(cli, fd, remote_name,
 220                                         signing_state,
 221                                         smb1_capabilities,
 222                                         &client_guid,
 223                                         smb2_capabilities);
 224         if (cli->conn == NULL) {
 225                 goto error;
 226         }
 227
 228         cli->smb1.pid = (uint32_t)getpid();
 229         cli->smb1.vc_num = cli->smb1.pid;
 230         cli->smb1.tcon = smbXcli_tcon_create(cli);
 231         if (cli->smb1.tcon == NULL) {
 232                 goto error;
 233         }
 234         smb1cli_tcon_set_id(cli->smb1.tcon, UINT16_MAX);
 235         cli->smb1.session = smbXcli_session_create(cli, cli->conn);
 236         if (cli->smb1.session == NULL) {
 237                 goto error;
 238         }
 239
 240         cli->initialised = 1;
 241         return cli;
 242
 243         /* Clean up after malloc() error */
 244
 245  error:
 246
 247         TALLOC_FREE(cli);
 248         return NULL;
 249 }
 250
 251 /****************************************************************************
 252  Close all pipes open on this session.
 253 ****************************************************************************/
 254
 255 void cli_nt_pipes_close(struct cli_state *cli)
 256 {
 257         while (cli->pipe_list != NULL) {
 258                 /*
 259                  * No TALLOC_FREE here!
 260                  */
 261                 talloc_free(cli->pipe_list);
 262         }
 263 }
 264
 265 /****************************************************************************
 266  Shutdown a client structure.
 267 ****************************************************************************/
 268
 269 static void _cli_shutdown(struct cli_state *cli)
 270 {
 271         cli_nt_pipes_close(cli);
 272
 273         /*
 274          * tell our peer to free his resources.  Wihtout this, when an
 275          * application attempts to do a graceful shutdown and calls
 276          * smbc_free_context() to clean up all connections, some connections
 277          * can remain active on the peer end, until some (long) timeout period
 278          * later.  This tree disconnect forces the peer to clean up, since the
 279          * connection will be going away.
 280          */
 281         if (cli_state_has_tcon(cli)) {
 282                 cli_tdis(cli);
 283         }
 284
 285         smbXcli_conn_disconnect(cli->conn, NT_STATUS_OK);
 286
 287         TALLOC_FREE(cli);
 288 }
 289
 290 void cli_shutdown(struct cli_state *cli)
 291 {
 292         struct cli_state *cli_head;
 293         if (cli == NULL) {
 294                 return;
 295         }
 296         DLIST_HEAD(cli, cli_head);
 297         if (cli_head == cli) {
 298                 /*
 299                  * head of a DFS list, shutdown all subsidiary DFS
 300                  * connections.
 301                  */
 302                 struct cli_state *p, *next;
 303
 304                 for (p = cli_head->next; p; p = next) {
 305                         next = p->next;
 306                         DLIST_REMOVE(cli_head, p);
 307                         _cli_shutdown(p);
 308                 }
 309         } else {
 310                 DLIST_REMOVE(cli_head, cli);
 311         }
 312
 313         _cli_shutdown(cli);
 314 }
 315
 316 const char *cli_state_remote_realm(struct cli_state *cli)
 317 {
 318         return cli->remote_realm;
 319 }
 320
 321 uint16_t cli_state_get_vc_num(struct cli_state *cli)
 322 {
 323         return cli->smb1.vc_num;
 324 }
 325
 326 /****************************************************************************
 327  Set the PID to use for smb messages. Return the old pid.
 328 ****************************************************************************/
 329
 330 uint32_t cli_setpid(struct cli_state *cli, uint32_t pid)
 331 {
 332         uint32_t ret = cli->smb1.pid;
 333         cli->smb1.pid = pid;
 334         return ret;
 335 }
 336
 337 uint32_t cli_getpid(struct cli_state *cli)
 338 {
 339         return cli->smb1.pid;
 340 }
 341
 342 bool cli_state_has_tcon(struct cli_state *cli)
 343 {
 344         uint16_t tid = cli_state_get_tid(cli);
 345
 346         if (tid == UINT16_MAX) {
 347                 return false;
 348         }
 349
 350         return true;
 351 }
 352
 353 uint16_t cli_state_get_tid(struct cli_state *cli)
 354 {
 355         return smb1cli_tcon_current_id(cli->smb1.tcon);
 356 }
 357
 358 uint16_t cli_state_set_tid(struct cli_state *cli, uint16_t tid)
 359 {
 360         uint16_t ret = smb1cli_tcon_current_id(cli->smb1.tcon);
 361         smb1cli_tcon_set_id(cli->smb1.tcon, tid);
 362         return ret;
 363 }
 364
 365 uint16_t cli_state_get_uid(struct cli_state *cli)
 366 {
 367         return smb1cli_session_current_id(cli->smb1.session);
 368 }
 369
 370 uint16_t cli_state_set_uid(struct cli_state *cli, uint16_t uid)
 371 {
 372         uint16_t ret = smb1cli_session_current_id(cli->smb1.session);
 373         smb1cli_session_set_id(cli->smb1.session, uid);
 374         return ret;
 375 }
 376
 377 /****************************************************************************
 378  Set the case sensitivity flag on the packets. Returns old state.
 379 ****************************************************************************/
 380
 381 bool cli_set_case_sensitive(struct cli_state *cli, bool case_sensitive)
 382 {
 383         bool ret;
 384         uint32_t fs_attrs;
 385         struct smbXcli_tcon *tcon;
 386
 387         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
 388                 tcon = cli->smb2.tcon;
 389         } else {
 390                 tcon = cli->smb1.tcon;
 391         }
 392
 393         fs_attrs = smbXcli_tcon_get_fs_attributes(tcon);
 394         if (fs_attrs & FILE_CASE_SENSITIVE_SEARCH) {
 395                 ret = true;
 396         } else {
 397                 ret = false;
 398         }
 399         if (case_sensitive) {
 400                 fs_attrs |= FILE_CASE_SENSITIVE_SEARCH;
 401         } else {
 402                 fs_attrs &= ~FILE_CASE_SENSITIVE_SEARCH;
 403         }
 404         smbXcli_tcon_set_fs_attributes(tcon, fs_attrs);
 405
 406         return ret;
 407 }
 408
 409 uint32_t cli_state_available_size(struct cli_state *cli, uint32_t ofs)
 410 {
 411         uint32_t ret = smb1cli_conn_max_xmit(cli->conn);
 412
 413         if (ofs >= ret) {
 414                 return 0;
 415         }
 416
 417         ret -= ofs;
 418
 419         return ret;
 420 }
 421
 422 time_t cli_state_server_time(struct cli_state *cli)
 423 {
 424         NTTIME nt;
 425         time_t t;
 426
 427         nt = smbXcli_conn_server_system_time(cli->conn);
 428         t = nt_time_to_unix(nt);
 429
 430         return t;
 431 }
 432
 433 struct cli_echo_state {
 434         bool is_smb2;
 435 };
 436
 437 static void cli_echo_done(struct tevent_req *subreq);
 438
 439 struct tevent_req *cli_echo_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
 440                                  struct cli_state *cli, uint16_t num_echos,
 441                                  DATA_BLOB data)
 442 {
 443         struct tevent_req *req, *subreq;
 444         struct cli_echo_state *state;
 445
 446         req = tevent_req_create(mem_ctx, &state, struct cli_echo_state);
 447         if (req == NULL) {
 448                 return NULL;
 449         }
 450
 451         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
 452                 state->is_smb2 = true;
 453                 subreq = smb2cli_echo_send(state, ev,
 454                                            cli->conn,
 455                                            cli->timeout);
 456         } else {
 457                 subreq = smb1cli_echo_send(state, ev,
 458                                            cli->conn,
 459                                            cli->timeout,
 460                                            num_echos,
 461                                            data);
 462         }
 463         if (tevent_req_nomem(subreq, req)) {
 464                 return tevent_req_post(req, ev);
 465         }
 466         tevent_req_set_callback(subreq, cli_echo_done, req);
 467
 468         return req;
 469 }
 470
 471 static void cli_echo_done(struct tevent_req *subreq)
 472 {
 473         struct tevent_req *req = tevent_req_callback_data(
 474                 subreq, struct tevent_req);
 475         struct cli_echo_state *state = tevent_req_data(
 476                 req, struct cli_echo_state);
 477         NTSTATUS status;
 478
 479         if (state->is_smb2) {
 480                 status = smb2cli_echo_recv(subreq);
 481         } else {
 482                 status = smb1cli_echo_recv(subreq);
 483         }
 484         TALLOC_FREE(subreq);
 485         if (!NT_STATUS_IS_OK(status)) {
 486                 tevent_req_nterror(req, status);
 487                 return;
 488         }
 489
 490         tevent_req_done(req);
 491 }
 492
 493 /**
 494  * Get the result out from an echo request
 495  * @param[in] req       The async_req from cli_echo_send
 496  * @retval Did the server reply correctly?
 497  */
 498
 499 NTSTATUS cli_echo_recv(struct tevent_req *req)
 500 {
 501         return tevent_req_simple_recv_ntstatus(req);
 502 }
 503
 504 /**
 505  * @brief Send/Receive SMBEcho requests
 506  * @param[in] mem_ctx   The memory context to put the async_req on
 507  * @param[in] ev        The event context that will call us back
 508  * @param[in] cli       The connection to send the echo to
 509  * @param[in] num_echos How many times do we want to get the reply?
 510  * @param[in] data      The data we want to get back
 511  * @retval Did the server reply correctly?
 512  */
 513
 514 NTSTATUS cli_echo(struct cli_state *cli, uint16_t num_echos, DATA_BLOB data)
 515 {
 516         TALLOC_CTX *frame = talloc_stackframe();
 517         struct tevent_context *ev;
 518         struct tevent_req *req;
 519         NTSTATUS status = NT_STATUS_OK;
 520
 521         if (smbXcli_conn_has_async_calls(cli->conn)) {
 522                 /*
 523                  * Can't use sync call while an async call is in flight
 524                  */
 525                 status = NT_STATUS_INVALID_PARAMETER;
 526                 goto fail;
 527         }
 528
 529         ev = samba_tevent_context_init(frame);
 530         if (ev == NULL) {
 531                 status = NT_STATUS_NO_MEMORY;
 532                 goto fail;
 533         }
 534
 535         req = cli_echo_send(frame, ev, cli, num_echos, data);
 536         if (req == NULL) {
 537                 status = NT_STATUS_NO_MEMORY;
 538                 goto fail;
 539         }
 540
 541         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 542                 goto fail;
 543         }
 544
 545         status = cli_echo_recv(req);
 546  fail:
 547         TALLOC_FREE(frame);
 548         return status;
 549 }
 550
 551 /**
 552  * Is the SMB command able to hold an AND_X successor
 553  * @param[in] cmd       The SMB command in question
 554  * @retval Can we add a chained request after "cmd"?
 555  */
 556 bool is_andx_req(uint8_t cmd)
 557 {
 558         switch (cmd) {
 559         case SMBtconX:
 560         case SMBlockingX:
 561         case SMBopenX:
 562         case SMBreadX:
 563         case SMBwriteX:
 564         case SMBsesssetupX:
 565         case SMBulogoffX:
 566         case SMBntcreateX:
 567                 return true;
 568                 break;
 569         default:
 570                 break;
 571         }
 572
 573         return false;
 574 }
 575
 576 NTSTATUS cli_smb(TALLOC_CTX *mem_ctx, struct cli_state *cli,
 577                  uint8_t smb_command, uint8_t additional_flags,
 578                  uint8_t wct, uint16_t *vwv,
 579                  uint32_t num_bytes, const uint8_t *bytes,
 580                  struct tevent_req **result_parent,
 581                  uint8_t min_wct, uint8_t *pwct, uint16_t **pvwv,
 582                  uint32_t *pnum_bytes, uint8_t **pbytes)
 583 {
 584         struct tevent_context *ev;
 585         struct tevent_req *req = NULL;
 586         NTSTATUS status = NT_STATUS_NO_MEMORY;
 587
 588         if (smbXcli_conn_has_async_calls(cli->conn)) {
 589                 return NT_STATUS_INVALID_PARAMETER;
 590         }
 591         ev = samba_tevent_context_init(mem_ctx);
 592         if (ev == NULL) {
 593                 goto fail;
 594         }
 595         req = cli_smb_send(mem_ctx, ev, cli, smb_command, additional_flags, 0,
 596                            wct, vwv, num_bytes, bytes);
 597         if (req == NULL) {
 598                 goto fail;
 599         }
 600         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 601                 goto fail;
 602         }
 603         status = cli_smb_recv(req, NULL, NULL, min_wct, pwct, pvwv,
 604                               pnum_bytes, pbytes);
 605 fail:
 606         TALLOC_FREE(ev);
 607         if (NT_STATUS_IS_OK(status) && (result_parent != NULL)) {
 608                 *result_parent = req;
 609         }
 610         return status;
 611 }