source3/libsmb/cli_smb2_fnum.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    smb2 lib
   4    Copyright (C) Jeremy Allison 2013
   5    Copyright (C) Volker Lendecke 2013
   6    Copyright (C) Stefan Metzmacher 2013
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 /*
  23  This code is a thin wrapper around the existing
  24  cli_smb2_XXXX() functions in libcli/smb/smb2cli_XXXXX.c,
  25  but allows the handles to be mapped to uint16_t fnums,
  26  which are easier for smbclient to use.
  27 */
  28
  29 #include "includes.h"
  30 #include "client.h"
  31 #include "async_smb.h"
  32 #include "../libcli/smb/smbXcli_base.h"
  33 #include "smb2cli.h"
  34 #include "cli_smb2_fnum.h"
  35 #include "trans2.h"
  36 #include "clirap.h"
  37 #include "../libcli/smb/smb2_create_blob.h"
  38 #include "libsmb/proto.h"
  39 #include "lib/util/tevent_ntstatus.h"
  40 #include "../libcli/security/security.h"
  41 #include "lib/util_ea.h"
  42
  43 struct smb2_hnd {
  44         uint64_t fid_persistent;
  45         uint64_t fid_volatile;
  46 };
  47
  48 /*
  49  * Handle mapping code.
  50  */
  51
  52 /***************************************************************
  53  Allocate a new fnum between 1 and 0xFFFE from an smb2_hnd.
  54  Ensures handle is owned by cli struct.
  55 ***************************************************************/
  56
  57 static NTSTATUS map_smb2_handle_to_fnum(struct cli_state *cli,
  58                                 const struct smb2_hnd *ph,      /* In */
  59                                 uint16_t *pfnum)                /* Out */
  60 {
  61         int ret;
  62         struct idr_context *idp = cli->smb2.open_handles;
  63         struct smb2_hnd *owned_h = talloc_memdup(cli,
  64                                                 ph,
  65                                                 sizeof(struct smb2_hnd));
  66
  67         if (owned_h == NULL) {
  68                 return NT_STATUS_NO_MEMORY;
  69         }
  70
  71         if (idp == NULL) {
  72                 /* Lazy init */
  73                 cli->smb2.open_handles = idr_init(cli);
  74                 if (cli->smb2.open_handles == NULL) {
  75                         TALLOC_FREE(owned_h);
  76                         return NT_STATUS_NO_MEMORY;
  77                 }
  78                 idp = cli->smb2.open_handles;
  79         }
  80
  81         ret = idr_get_new_above(idp, owned_h, 1, 0xFFFE);
  82         if (ret == -1) {
  83                 TALLOC_FREE(owned_h);
  84                 return NT_STATUS_NO_MEMORY;
  85         }
  86
  87         *pfnum = (uint16_t)ret;
  88         return NT_STATUS_OK;
  89 }
  90
  91 /***************************************************************
  92  Return the smb2_hnd pointer associated with the given fnum.
  93 ***************************************************************/
  94
  95 static NTSTATUS map_fnum_to_smb2_handle(struct cli_state *cli,
  96                                 uint16_t fnum,          /* In */
  97                                 struct smb2_hnd **pph)  /* Out */
  98 {
  99         struct idr_context *idp = cli->smb2.open_handles;
 100
 101         if (idp == NULL) {
 102                 return NT_STATUS_INVALID_PARAMETER;
 103         }
 104         *pph = (struct smb2_hnd *)idr_find(idp, fnum);
 105         if (*pph == NULL) {
 106                 return NT_STATUS_INVALID_HANDLE;
 107         }
 108         return NT_STATUS_OK;
 109 }
 110
 111 /***************************************************************
 112  Delete the fnum to smb2_hnd mapping. Zeros out handle on
 113  successful return.
 114 ***************************************************************/
 115
 116 static NTSTATUS delete_smb2_handle_mapping(struct cli_state *cli,
 117                                 struct smb2_hnd **pph,  /* In */
 118                                 uint16_t fnum)                  /* In */
 119 {
 120         struct idr_context *idp = cli->smb2.open_handles;
 121         struct smb2_hnd *ph;
 122
 123         if (idp == NULL) {
 124                 return NT_STATUS_INVALID_PARAMETER;
 125         }
 126
 127         ph = (struct smb2_hnd *)idr_find(idp, fnum);
 128         if (ph != *pph) {
 129                 return NT_STATUS_INVALID_PARAMETER;
 130         }
 131         idr_remove(idp, fnum);
 132         TALLOC_FREE(*pph);
 133         return NT_STATUS_OK;
 134 }
 135
 136 /***************************************************************
 137  Oplock mapping code.
 138 ***************************************************************/
 139
 140 static uint8_t flags_to_smb2_oplock(uint32_t create_flags)
 141 {
 142         if (create_flags & REQUEST_BATCH_OPLOCK) {
 143                 return SMB2_OPLOCK_LEVEL_BATCH;
 144         } else if (create_flags & REQUEST_OPLOCK) {
 145                 return SMB2_OPLOCK_LEVEL_EXCLUSIVE;
 146         }
 147
 148         /* create_flags doesn't do a level2 request. */
 149         return SMB2_OPLOCK_LEVEL_NONE;
 150 }
 151
 152 /***************************************************************
 153  Small wrapper that allows SMB2 create to return a uint16_t fnum.
 154  Synchronous only.
 155 ***************************************************************/
 156
 157 NTSTATUS cli_smb2_create_fnum(struct cli_state *cli,
 158                         const char *fname,
 159                         uint32_t create_flags,
 160                         uint32_t desired_access,
 161                         uint32_t file_attributes,
 162                         uint32_t share_access,
 163                         uint32_t create_disposition,
 164                         uint32_t create_options,
 165                         uint16_t *pfid,
 166                         struct smb2_create_returns *cr)
 167 {
 168         NTSTATUS status;
 169         struct smb2_hnd h;
 170
 171         if (smbXcli_conn_has_async_calls(cli->conn)) {
 172                 /*
 173                  * Can't use sync call while an async call is in flight
 174                  */
 175                 return NT_STATUS_INVALID_PARAMETER;
 176         }
 177
 178         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
 179                 return NT_STATUS_INVALID_PARAMETER;
 180         }
 181
 182         if (cli->backup_intent) {
 183                 create_options |= FILE_OPEN_FOR_BACKUP_INTENT;
 184         }
 185
 186         /* SMB2 is pickier about pathnames. Ensure it doesn't
 187            start in a '\' */
 188         if (*fname == '\\') {
 189                 fname++;
 190         }
 191
 192         status = smb2cli_create(cli->conn,
 193                                 cli->timeout,
 194                                 cli->smb2.session,
 195                                 cli->smb2.tcon,
 196                                 fname,
 197                                 flags_to_smb2_oplock(create_flags),
 198                                 SMB2_IMPERSONATION_IMPERSONATION,
 199                                 desired_access,
 200                                 file_attributes,
 201                                 share_access,
 202                                 create_disposition,
 203                                 create_options,
 204                                 NULL,
 205                                 &h.fid_persistent,
 206                                 &h.fid_volatile,
 207                                 cr);
 208
 209         if (NT_STATUS_IS_OK(status)) {
 210                 status = map_smb2_handle_to_fnum(cli, &h, pfid);
 211         }
 212
 213         return status;
 214 }
 215
 216 /***************************************************************
 217  Small wrapper that allows SMB2 close to use a uint16_t fnum.
 218  Synchronous only.
 219 ***************************************************************/
 220
 221 NTSTATUS cli_smb2_close_fnum(struct cli_state *cli, uint16_t fnum)
 222 {
 223         struct smb2_hnd *ph = NULL;
 224         NTSTATUS status;
 225
 226         if (smbXcli_conn_has_async_calls(cli->conn)) {
 227                 /*
 228                  * Can't use sync call while an async call is in flight
 229                  */
 230                 return NT_STATUS_INVALID_PARAMETER;
 231         }
 232
 233         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
 234                 return NT_STATUS_INVALID_PARAMETER;
 235         }
 236
 237         status = map_fnum_to_smb2_handle(cli,
 238                                         fnum,
 239                                         &ph);
 240         if (!NT_STATUS_IS_OK(status)) {
 241                 return status;
 242         }
 243
 244         status = smb2cli_close(cli->conn,
 245                                 cli->timeout,
 246                                 cli->smb2.session,
 247                                 cli->smb2.tcon,
 248                                 0,
 249                                 ph->fid_persistent,
 250                                 ph->fid_volatile);
 251
 252         /* Delete the fnum -> handle mapping. */
 253         if (NT_STATUS_IS_OK(status)) {
 254                 status = delete_smb2_handle_mapping(cli, &ph, fnum);
 255         }
 256
 257         return status;
 258 }
 259
 260 /***************************************************************
 261  Small wrapper that allows SMB2 to create a directory
 262  Synchronous only.
 263 ***************************************************************/
 264
 265 NTSTATUS cli_smb2_mkdir(struct cli_state *cli, const char *dname)
 266 {
 267         NTSTATUS status;
 268         uint16_t fnum;
 269
 270         if (smbXcli_conn_has_async_calls(cli->conn)) {
 271                 /*
 272                  * Can't use sync call while an async call is in flight
 273                  */
 274                 return NT_STATUS_INVALID_PARAMETER;
 275         }
 276
 277         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
 278                 return NT_STATUS_INVALID_PARAMETER;
 279         }
 280
 281         status = cli_smb2_create_fnum(cli,
 282                         dname,
 283                         0,                      /* create_flags */
 284                         FILE_READ_ATTRIBUTES,   /* desired_access */
 285                         FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
 286                         FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
 287                         FILE_CREATE,            /* create_disposition */
 288                         FILE_DIRECTORY_FILE,    /* create_options */
 289                         &fnum,
 290                         NULL);
 291
 292         if (!NT_STATUS_IS_OK(status)) {
 293                 return status;
 294         }
 295         return cli_smb2_close_fnum(cli, fnum);
 296 }
 297
 298 /***************************************************************
 299  Small wrapper that allows SMB2 to delete a directory
 300  Synchronous only.
 301 ***************************************************************/
 302
 303 NTSTATUS cli_smb2_rmdir(struct cli_state *cli, const char *dname)
 304 {
 305         NTSTATUS status;
 306         uint16_t fnum;
 307
 308         if (smbXcli_conn_has_async_calls(cli->conn)) {
 309                 /*
 310                  * Can't use sync call while an async call is in flight
 311                  */
 312                 return NT_STATUS_INVALID_PARAMETER;
 313         }
 314
 315         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
 316                 return NT_STATUS_INVALID_PARAMETER;
 317         }
 318
 319         status = cli_smb2_create_fnum(cli,
 320                         dname,
 321                         0,                      /* create_flags */
 322                         DELETE_ACCESS,          /* desired_access */
 323                         FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
 324                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
 325                         FILE_OPEN,              /* create_disposition */
 326                         FILE_DIRECTORY_FILE|FILE_DELETE_ON_CLOSE,       /* create_options */
 327                         &fnum,
 328                         NULL);
 329
 330         if (!NT_STATUS_IS_OK(status)) {
 331                 return status;
 332         }
 333         return cli_smb2_close_fnum(cli, fnum);
 334 }
 335
 336 /***************************************************************
 337  Small wrapper that allows SMB2 to unlink a pathname.
 338  Synchronous only.
 339 ***************************************************************/
 340
 341 NTSTATUS cli_smb2_unlink(struct cli_state *cli, const char *fname)
 342 {
 343         NTSTATUS status;
 344         uint16_t fnum;
 345
 346         if (smbXcli_conn_has_async_calls(cli->conn)) {
 347                 /*
 348                  * Can't use sync call while an async call is in flight
 349                  */
 350                 return NT_STATUS_INVALID_PARAMETER;
 351         }
 352
 353         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
 354                 return NT_STATUS_INVALID_PARAMETER;
 355         }
 356
 357         status = cli_smb2_create_fnum(cli,
 358                         fname,
 359                         0,                      /* create_flags */
 360                         DELETE_ACCESS,          /* desired_access */
 361                         FILE_ATTRIBUTE_NORMAL, /* file attributes */
 362                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
 363                         FILE_OPEN,              /* create_disposition */
 364                         FILE_DELETE_ON_CLOSE,   /* create_options */
 365                         &fnum,
 366                         NULL);
 367
 368         if (!NT_STATUS_IS_OK(status)) {
 369                 return status;
 370         }
 371         return cli_smb2_close_fnum(cli, fnum);
 372 }
 373
 374 /***************************************************************
 375  Utility function to parse a SMB2_FIND_ID_BOTH_DIRECTORY_INFO reply.
 376 ***************************************************************/
 377
 378 static NTSTATUS parse_finfo_id_both_directory_info(uint8_t *dir_data,
 379                                 uint32_t dir_data_length,
 380                                 struct file_info *finfo,
 381                                 uint32_t *next_offset)
 382 {
 383         size_t namelen = 0;
 384         size_t slen = 0;
 385         size_t ret = 0;
 386
 387         if (dir_data_length < 4) {
 388                 return NT_STATUS_INFO_LENGTH_MISMATCH;
 389         }
 390
 391         *next_offset = IVAL(dir_data, 0);
 392
 393         if (*next_offset > dir_data_length) {
 394                 return NT_STATUS_INFO_LENGTH_MISMATCH;
 395         }
 396
 397         if (*next_offset != 0) {
 398                 /* Ensure we only read what in this record. */
 399                 dir_data_length = *next_offset;
 400         }
 401
 402         if (dir_data_length < 105) {
 403                 return NT_STATUS_INFO_LENGTH_MISMATCH;
 404         }
 405
 406         finfo->atime_ts = interpret_long_date((const char *)dir_data + 16);
 407         finfo->mtime_ts = interpret_long_date((const char *)dir_data + 24);
 408         finfo->ctime_ts = interpret_long_date((const char *)dir_data + 32);
 409         finfo->size = IVAL2_TO_SMB_BIG_UINT(dir_data + 40, 0);
 410         finfo->mode = CVAL(dir_data + 56, 0);
 411         namelen = IVAL(dir_data + 60,0);
 412         if (namelen > (dir_data_length - 104)) {
 413                 return NT_STATUS_INFO_LENGTH_MISMATCH;
 414         }
 415         slen = CVAL(dir_data + 68, 0);
 416         if (slen > 24) {
 417                 return NT_STATUS_INFO_LENGTH_MISMATCH;
 418         }
 419         ret = pull_string_talloc(finfo,
 420                                 dir_data,
 421                                 FLAGS2_UNICODE_STRINGS,
 422                                 &finfo->short_name,
 423                                 dir_data + 70,
 424                                 slen,
 425                                 STR_UNICODE);
 426         if (ret == (size_t)-1) {
 427                 /* Bad conversion. */
 428                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 429         }
 430
 431         ret = pull_string_talloc(finfo,
 432                                 dir_data,
 433                                 FLAGS2_UNICODE_STRINGS,
 434                                 &finfo->name,
 435                                 dir_data + 104,
 436                                 namelen,
 437                                 STR_UNICODE);
 438         if (ret == (size_t)-1) {
 439                 /* Bad conversion. */
 440                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 441         }
 442         return NT_STATUS_OK;
 443 }
 444
 445 /*******************************************************************
 446  Given a filename - get its directory name
 447 ********************************************************************/
 448
 449 static bool windows_parent_dirname(TALLOC_CTX *mem_ctx,
 450                                 const char *dir,
 451                                 char **parent,
 452                                 const char **name)
 453 {
 454         char *p;
 455         ptrdiff_t len;
 456
 457         p = strrchr_m(dir, '\\'); /* Find final '\\', if any */
 458
 459         if (p == NULL) {
 460                 if (!(*parent = talloc_strdup(mem_ctx, "\\"))) {
 461                         return false;
 462                 }
 463                 if (name) {
 464                         *name = dir;
 465                 }
 466                 return true;
 467         }
 468
 469         len = p-dir;
 470
 471         if (!(*parent = (char *)talloc_memdup(mem_ctx, dir, len+1))) {
 472                 return false;
 473         }
 474         (*parent)[len] = '\0';
 475
 476         if (name) {
 477                 *name = p+1;
 478         }
 479         return true;
 480 }
 481
 482 /***************************************************************
 483  Wrapper that allows SMB2 to list a directory.
 484  Synchronous only.
 485 ***************************************************************/
 486
 487 NTSTATUS cli_smb2_list(struct cli_state *cli,
 488                         const char *pathname,
 489                         NTSTATUS (*fn)(const char *,
 490                                 struct file_info *,
 491                                 const char *,
 492                                 void *),
 493                         void *state)
 494 {
 495         NTSTATUS status;
 496         uint16_t fnum = 0xffff;
 497         char *parent_dir = NULL;
 498         const char *mask = NULL;
 499         struct smb2_hnd *ph = NULL;
 500         TALLOC_CTX *frame = talloc_stackframe();
 501         TALLOC_CTX *subframe = NULL;
 502
 503         if (smbXcli_conn_has_async_calls(cli->conn)) {
 504                 /*
 505                  * Can't use sync call while an async call is in flight
 506                  */
 507                 status = NT_STATUS_INVALID_PARAMETER;
 508                 goto fail;
 509         }
 510
 511         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
 512                 status = NT_STATUS_INVALID_PARAMETER;
 513                 goto fail;
 514         }
 515
 516         /* Get the directory name. */
 517         if (!windows_parent_dirname(frame,
 518                                 pathname,
 519                                 &parent_dir,
 520                                 &mask)) {
 521                 status = NT_STATUS_NO_MEMORY;
 522                 goto fail;
 523         }
 524
 525         status = cli_smb2_create_fnum(cli,
 526                         parent_dir,
 527                         0,                      /* create_flags */
 528                         SEC_DIR_LIST|SEC_DIR_READ_ATTRIBUTE,/* desired_access */
 529                         FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
 530                         FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
 531                         FILE_OPEN,              /* create_disposition */
 532                         FILE_DIRECTORY_FILE,    /* create_options */
 533                         &fnum,
 534                         NULL);
 535
 536         if (!NT_STATUS_IS_OK(status)) {
 537                 goto fail;
 538         }
 539
 540         status = map_fnum_to_smb2_handle(cli,
 541                                         fnum,
 542                                         &ph);
 543         if (!NT_STATUS_IS_OK(status)) {
 544                 goto fail;
 545         }
 546
 547         do {
 548                 uint8_t *dir_data = NULL;
 549                 uint32_t dir_data_length = 0;
 550                 uint32_t next_offset = 0;
 551                 subframe = talloc_stackframe();
 552
 553                 status = smb2cli_query_directory(cli->conn,
 554                                         cli->timeout,
 555                                         cli->smb2.session,
 556                                         cli->smb2.tcon,
 557                                         SMB2_FIND_ID_BOTH_DIRECTORY_INFO,
 558                                         0,      /* flags */
 559                                         0,      /* file_index */
 560                                         ph->fid_persistent,
 561                                         ph->fid_volatile,
 562                                         mask,
 563                                         0xffff,
 564                                         subframe,
 565                                         &dir_data,
 566                                         &dir_data_length);
 567
 568                 if (!NT_STATUS_IS_OK(status)) {
 569                         if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
 570                                 break;
 571                         }
 572                         goto fail;
 573                 }
 574
 575                 do {
 576                         struct file_info *finfo = talloc_zero(subframe,
 577                                                         struct file_info);
 578
 579                         if (finfo == NULL) {
 580                                 status = NT_STATUS_NO_MEMORY;
 581                                 goto fail;
 582                         }
 583
 584                         status = parse_finfo_id_both_directory_info(dir_data,
 585                                                 dir_data_length,
 586                                                 finfo,
 587                                                 &next_offset);
 588
 589                         if (!NT_STATUS_IS_OK(status)) {
 590                                 goto fail;
 591                         }
 592
 593                         status = fn(cli->dfs_mountpoint,
 594                                         finfo,
 595                                         pathname,
 596                                         state);
 597
 598                         if (!NT_STATUS_IS_OK(status)) {
 599                                 break;
 600                         }
 601
 602                         TALLOC_FREE(finfo);
 603
 604                         /* Move to next entry. */
 605                         if (next_offset) {
 606                                 dir_data += next_offset;
 607                                 dir_data_length -= next_offset;
 608                         }
 609                 } while (next_offset != 0);
 610
 611                 TALLOC_FREE(subframe);
 612
 613         } while (NT_STATUS_IS_OK(status));
 614
 615         if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
 616                 status = NT_STATUS_OK;
 617         }
 618
 619   fail:
 620
 621         if (fnum != 0xffff) {
 622                 cli_smb2_close_fnum(cli, fnum);
 623         }
 624         TALLOC_FREE(subframe);
 625         TALLOC_FREE(frame);
 626         return status;
 627 }
 628
 629 /***************************************************************
 630  Wrapper that allows SMB2 to query a path info (basic level).
 631  Synchronous only.
 632 ***************************************************************/
 633
 634 NTSTATUS cli_smb2_qpathinfo_basic(struct cli_state *cli,
 635                                 const char *name,
 636                                 SMB_STRUCT_STAT *sbuf,
 637                                 uint32_t *attributes)
 638 {
 639         NTSTATUS status;
 640         struct smb2_create_returns cr;
 641         uint16_t fnum = 0xffff;
 642         size_t namelen = strlen(name);
 643
 644         if (smbXcli_conn_has_async_calls(cli->conn)) {
 645                 /*
 646                  * Can't use sync call while an async call is in flight
 647                  */
 648                 return NT_STATUS_INVALID_PARAMETER;
 649         }
 650
 651         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
 652                 return NT_STATUS_INVALID_PARAMETER;
 653         }
 654
 655         /* SMB2 is pickier about pathnames. Ensure it doesn't
 656            end in a '\' */
 657         if (namelen > 0 && name[namelen-1] == '\\') {
 658                 char *modname = talloc_strdup(talloc_tos(), name);
 659                 modname[namelen-1] = '\0';
 660                 name = modname;
 661         }
 662
 663         /* This is commonly used as a 'cd'. Try qpathinfo on
 664            a directory handle first. */
 665
 666         status = cli_smb2_create_fnum(cli,
 667                         name,
 668                         0,                      /* create_flags */
 669                         FILE_READ_ATTRIBUTES,   /* desired_access */
 670                         FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
 671                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
 672                         FILE_OPEN,              /* create_disposition */
 673                         FILE_DIRECTORY_FILE,    /* create_options */
 674                         &fnum,
 675                         &cr);
 676
 677         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_A_DIRECTORY)) {
 678                 /* Maybe a file ? */
 679                 status = cli_smb2_create_fnum(cli,
 680                         name,
 681                         0,                      /* create_flags */
 682                         FILE_READ_ATTRIBUTES,           /* desired_access */
 683                         0, /* file attributes */
 684                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
 685                         FILE_OPEN,              /* create_disposition */
 686                         0,      /* create_options */
 687                         &fnum,
 688                         &cr);
 689         }
 690
 691         if (!NT_STATUS_IS_OK(status)) {
 692                 return status;
 693         }
 694
 695         cli_smb2_close_fnum(cli, fnum);
 696
 697         ZERO_STRUCTP(sbuf);
 698
 699         sbuf->st_ex_atime = nt_time_to_unix_timespec(&cr.last_access_time);
 700         sbuf->st_ex_mtime = nt_time_to_unix_timespec(&cr.last_write_time);
 701         sbuf->st_ex_ctime = nt_time_to_unix_timespec(&cr.change_time);
 702         sbuf->st_ex_size = cr.end_of_file;
 703         *attributes = cr.file_attributes;
 704
 705         return NT_STATUS_OK;
 706 }
 707
 708 /***************************************************************
 709  Helper function for pathname operations.
 710 ***************************************************************/
 711
 712 static NTSTATUS get_fnum_from_path(struct cli_state *cli,
 713                                 const char *name,
 714                                 uint32_t desired_access,
 715                                 uint16_t *pfnum)
 716 {
 717         NTSTATUS status;
 718         size_t namelen = strlen(name);
 719         TALLOC_CTX *frame = talloc_stackframe();
 720
 721         /* SMB2 is pickier about pathnames. Ensure it doesn't
 722            end in a '\' */
 723         if (namelen > 0 && name[namelen-1] == '\\') {
 724                 char *modname = talloc_strdup(frame, name);
 725                 if (modname == NULL) {
 726                         status = NT_STATUS_NO_MEMORY;
 727                         goto fail;
 728                 }
 729                 modname[namelen-1] = '\0';
 730                 name = modname;
 731         }
 732
 733         /* Try to open a file handle first. */
 734         status = cli_smb2_create_fnum(cli,
 735                         name,
 736                         0,                      /* create_flags */
 737                         desired_access,
 738                         0, /* file attributes */
 739                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
 740                         FILE_OPEN,              /* create_disposition */
 741                         0,      /* create_options */
 742                         pfnum,
 743                         NULL);
 744
 745         if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
 746                 status = cli_smb2_create_fnum(cli,
 747                         name,
 748                         0,                      /* create_flags */
 749                         desired_access,
 750                         FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
 751                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
 752                         FILE_OPEN,              /* create_disposition */
 753                         FILE_DIRECTORY_FILE,    /* create_options */
 754                         pfnum,
 755                         NULL);
 756         }
 757
 758   fail:
 759
 760         TALLOC_FREE(frame);
 761         return status;
 762 }
 763
 764 /***************************************************************
 765  Wrapper that allows SMB2 to query a path info (ALTNAME level).
 766  Synchronous only.
 767 ***************************************************************/
 768
 769 NTSTATUS cli_smb2_qpathinfo_alt_name(struct cli_state *cli,
 770                                 const char *name,
 771                                 fstring alt_name)
 772 {
 773         NTSTATUS status;
 774         DATA_BLOB outbuf = data_blob_null;
 775         uint16_t fnum = 0xffff;
 776         struct smb2_hnd *ph = NULL;
 777         uint32_t altnamelen = 0;
 778         TALLOC_CTX *frame = talloc_stackframe();
 779
 780         if (smbXcli_conn_has_async_calls(cli->conn)) {
 781                 /*
 782                  * Can't use sync call while an async call is in flight
 783                  */
 784                 status = NT_STATUS_INVALID_PARAMETER;
 785                 goto fail;
 786         }
 787
 788         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
 789                 status = NT_STATUS_INVALID_PARAMETER;
 790                 goto fail;
 791         }
 792
 793         status = get_fnum_from_path(cli,
 794                                 name,
 795                                 FILE_READ_ATTRIBUTES,
 796                                 &fnum);
 797
 798         if (!NT_STATUS_IS_OK(status)) {
 799                 goto fail;
 800         }
 801
 802         status = map_fnum_to_smb2_handle(cli,
 803                                         fnum,
 804                                         &ph);
 805         if (!NT_STATUS_IS_OK(status)) {
 806                 goto fail;
 807         }
 808
 809         /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
 810            level SMB_FILE_ALTERNATE_NAME_INFORMATION (1021) == SMB2 21 */
 811
 812         status = smb2cli_query_info(cli->conn,
 813                                 cli->timeout,
 814                                 cli->smb2.session,
 815                                 cli->smb2.tcon,
 816                                 1, /* in_info_type */
 817                                 (SMB_FILE_ALTERNATE_NAME_INFORMATION - 1000), /* in_file_info_class */
 818                                 0xFFFF, /* in_max_output_length */
 819                                 NULL, /* in_input_buffer */
 820                                 0, /* in_additional_info */
 821                                 0, /* in_flags */
 822                                 ph->fid_persistent,
 823                                 ph->fid_volatile,
 824                                 frame,
 825                                 &outbuf);
 826
 827         if (!NT_STATUS_IS_OK(status)) {
 828                 goto fail;
 829         }
 830
 831         /* Parse the reply. */
 832         if (outbuf.length < 4) {
 833                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
 834                 goto fail;
 835         }
 836
 837         altnamelen = IVAL(outbuf.data, 0);
 838         if (altnamelen > outbuf.length - 4) {
 839                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
 840                 goto fail;
 841         }
 842
 843         if (altnamelen > 0) {
 844                 size_t ret = 0;
 845                 char *short_name = NULL;
 846                 ret = pull_string_talloc(frame,
 847                                 outbuf.data,
 848                                 FLAGS2_UNICODE_STRINGS,
 849                                 &short_name,
 850                                 outbuf.data + 4,
 851                                 altnamelen,
 852                                 STR_UNICODE);
 853                 if (ret == (size_t)-1) {
 854                         /* Bad conversion. */
 855                         status = NT_STATUS_INVALID_NETWORK_RESPONSE;
 856                         goto fail;
 857                 }
 858
 859                 fstrcpy(alt_name, short_name);
 860         } else {
 861                 alt_name[0] = '\0';
 862         }
 863
 864         status = NT_STATUS_OK;
 865
 866   fail:
 867
 868         if (fnum != 0xffff) {
 869                 cli_smb2_close_fnum(cli, fnum);
 870         }
 871         TALLOC_FREE(frame);
 872         return status;
 873 }
 874
 875
 876 /***************************************************************
 877  Wrapper that allows SMB2 to query a fnum info (basic level).
 878  Synchronous only.
 879 ***************************************************************/
 880
 881 NTSTATUS cli_smb2_qfileinfo_basic(struct cli_state *cli,
 882                         uint16_t fnum,
 883                         uint16_t *mode,
 884                         off_t *size,
 885                         struct timespec *create_time,
 886                         struct timespec *access_time,
 887                         struct timespec *write_time,
 888                         struct timespec *change_time,
 889                         SMB_INO_T *ino)
 890 {
 891         NTSTATUS status;
 892         DATA_BLOB outbuf = data_blob_null;
 893         struct smb2_hnd *ph = NULL;
 894         TALLOC_CTX *frame = talloc_stackframe();
 895
 896         if (smbXcli_conn_has_async_calls(cli->conn)) {
 897                 /*
 898                  * Can't use sync call while an async call is in flight
 899                  */
 900                 status = NT_STATUS_INVALID_PARAMETER;
 901                 goto fail;
 902         }
 903
 904         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
 905                 status = NT_STATUS_INVALID_PARAMETER;
 906                 goto fail;
 907         }
 908
 909         status = map_fnum_to_smb2_handle(cli,
 910                                         fnum,
 911                                         &ph);
 912         if (!NT_STATUS_IS_OK(status)) {
 913                 goto fail;
 914         }
 915
 916         /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
 917            level 0x12 (SMB2_FILE_ALL_INFORMATION). */
 918
 919         status = smb2cli_query_info(cli->conn,
 920                                 cli->timeout,
 921                                 cli->smb2.session,
 922                                 cli->smb2.tcon,
 923                                 1, /* in_info_type */
 924                                 (SMB_FILE_ALL_INFORMATION - 1000), /* in_file_info_class */
 925                                 0xFFFF, /* in_max_output_length */
 926                                 NULL, /* in_input_buffer */
 927                                 0, /* in_additional_info */
 928                                 0, /* in_flags */
 929                                 ph->fid_persistent,
 930                                 ph->fid_volatile,
 931                                 frame,
 932                                 &outbuf);
 933         if (!NT_STATUS_IS_OK(status)) {
 934                 goto fail;
 935         }
 936
 937         /* Parse the reply. */
 938         if (outbuf.length < 0x60) {
 939                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
 940                 goto fail;
 941         }
 942
 943         if (create_time) {
 944                 *create_time = interpret_long_date((const char *)outbuf.data + 0x0);
 945         }
 946         if (access_time) {
 947                 *access_time = interpret_long_date((const char *)outbuf.data + 0x8);
 948         }
 949         if (write_time) {
 950                 *write_time = interpret_long_date((const char *)outbuf.data + 0x10);
 951         }
 952         if (change_time) {
 953                 *change_time = interpret_long_date((const char *)outbuf.data + 0x18);
 954         }
 955         if (mode) {
 956                 uint32_t attr = IVAL(outbuf.data, 0x20);
 957                 *mode = (uint16_t)attr;
 958         }
 959         if (size) {
 960                 uint64_t file_size = BVAL(outbuf.data, 0x30);
 961                 *size = (off_t)file_size;
 962         }
 963         if (ino) {
 964                 uint64_t file_index = BVAL(outbuf.data, 0x40);
 965                 *ino = (SMB_INO_T)file_index;
 966         }
 967
 968   fail:
 969
 970         TALLOC_FREE(frame);
 971         return status;
 972 }
 973
 974 /***************************************************************
 975  Wrapper that allows SMB2 to query an fnum.
 976  Implement on top of cli_smb2_qfileinfo_basic().
 977  Synchronous only.
 978 ***************************************************************/
 979
 980 NTSTATUS cli_smb2_getattrE(struct cli_state *cli,
 981                         uint16_t fnum,
 982                         uint16_t *attr,
 983                         off_t *size,
 984                         time_t *change_time,
 985                         time_t *access_time,
 986                         time_t *write_time)
 987 {
 988         struct timespec access_time_ts;
 989         struct timespec write_time_ts;
 990         struct timespec change_time_ts;
 991         NTSTATUS status = cli_smb2_qfileinfo_basic(cli,
 992                                         fnum,
 993                                         attr,
 994                                         size,
 995                                         NULL,
 996                                         &access_time_ts,
 997                                         &write_time_ts,
 998                                         &change_time_ts,
 999                                         NULL);
1000
1001         if (!NT_STATUS_IS_OK(status)) {
1002                 return status;
1003         }
1004
1005         if (change_time) {
1006                 *change_time = change_time_ts.tv_sec;
1007         }
1008         if (access_time) {
1009                 *access_time = access_time_ts.tv_sec;
1010         }
1011         if (write_time) {
1012                 *write_time = write_time_ts.tv_sec;
1013         }
1014         return NT_STATUS_OK;
1015 }
1016
1017 /***************************************************************
1018  Wrapper that allows SMB2 to get pathname attributes.
1019  Synchronous only.
1020 ***************************************************************/
1021
1022 NTSTATUS cli_smb2_getatr(struct cli_state *cli,
1023                         const char *name,
1024                         uint16_t *attr,
1025                         off_t *size,
1026                         time_t *write_time)
1027 {
1028         NTSTATUS status;
1029         uint16_t fnum = 0xffff;
1030         struct smb2_hnd *ph = NULL;
1031         TALLOC_CTX *frame = talloc_stackframe();
1032
1033         if (smbXcli_conn_has_async_calls(cli->conn)) {
1034                 /*
1035                  * Can't use sync call while an async call is in flight
1036                  */
1037                 status = NT_STATUS_INVALID_PARAMETER;
1038                 goto fail;
1039         }
1040
1041         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1042                 status = NT_STATUS_INVALID_PARAMETER;
1043                 goto fail;
1044         }
1045
1046         status = get_fnum_from_path(cli,
1047                                 name,
1048                                 FILE_READ_ATTRIBUTES,
1049                                 &fnum);
1050
1051         if (!NT_STATUS_IS_OK(status)) {
1052                 goto fail;
1053         }
1054
1055         status = map_fnum_to_smb2_handle(cli,
1056                                         fnum,
1057                                         &ph);
1058         if (!NT_STATUS_IS_OK(status)) {
1059                 goto fail;
1060         }
1061         status = cli_smb2_getattrE(cli,
1062                                 fnum,
1063                                 attr,
1064                                 size,
1065                                 NULL,
1066                                 NULL,
1067                                 write_time);
1068         if (!NT_STATUS_IS_OK(status)) {
1069                 goto fail;
1070         }
1071
1072   fail:
1073
1074         if (fnum != 0xffff) {
1075                 cli_smb2_close_fnum(cli, fnum);
1076         }
1077
1078         TALLOC_FREE(frame);
1079         return status;
1080 }
1081
1082 /***************************************************************
1083  Wrapper that allows SMB2 to query a pathname info (basic level).
1084  Implement on top of cli_smb2_qfileinfo_basic().
1085  Synchronous only.
1086 ***************************************************************/
1087
1088 NTSTATUS cli_smb2_qpathinfo2(struct cli_state *cli,
1089                         const char *name,
1090                         struct timespec *create_time,
1091                         struct timespec *access_time,
1092                         struct timespec *write_time,
1093                         struct timespec *change_time,
1094                         off_t *size,
1095                         uint16_t *mode,
1096                         SMB_INO_T *ino)
1097 {
1098         NTSTATUS status;
1099         struct smb2_hnd *ph = NULL;
1100         uint16_t fnum = 0xffff;
1101         TALLOC_CTX *frame = talloc_stackframe();
1102
1103         if (smbXcli_conn_has_async_calls(cli->conn)) {
1104                 /*
1105                  * Can't use sync call while an async call is in flight
1106                  */
1107                 status = NT_STATUS_INVALID_PARAMETER;
1108                 goto fail;
1109         }
1110
1111         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1112                 status = NT_STATUS_INVALID_PARAMETER;
1113                 goto fail;
1114         }
1115
1116         status = get_fnum_from_path(cli,
1117                                         name,
1118                                         FILE_READ_ATTRIBUTES,
1119                                         &fnum);
1120
1121         if (!NT_STATUS_IS_OK(status)) {
1122                 goto fail;
1123         }
1124
1125         status = map_fnum_to_smb2_handle(cli,
1126                                         fnum,
1127                                         &ph);
1128         if (!NT_STATUS_IS_OK(status)) {
1129                 goto fail;
1130         }
1131
1132         status = cli_smb2_qfileinfo_basic(cli,
1133                                         fnum,
1134                                         mode,
1135                                         size,
1136                                         create_time,
1137                                         access_time,
1138                                         write_time,
1139                                         change_time,
1140                                         ino);
1141
1142   fail:
1143
1144         if (fnum != 0xffff) {
1145                 cli_smb2_close_fnum(cli, fnum);
1146         }
1147
1148         TALLOC_FREE(frame);
1149         return status;
1150 }
1151
1152 /***************************************************************
1153  Wrapper that allows SMB2 to query pathname streams.
1154  Synchronous only.
1155 ***************************************************************/
1156
1157 NTSTATUS cli_smb2_qpathinfo_streams(struct cli_state *cli,
1158                                 const char *name,
1159                                 TALLOC_CTX *mem_ctx,
1160                                 unsigned int *pnum_streams,
1161                                 struct stream_struct **pstreams)
1162 {
1163         NTSTATUS status;
1164         struct smb2_hnd *ph = NULL;
1165         uint16_t fnum = 0xffff;
1166         DATA_BLOB outbuf = data_blob_null;
1167         TALLOC_CTX *frame = talloc_stackframe();
1168
1169         if (smbXcli_conn_has_async_calls(cli->conn)) {
1170                 /*
1171                  * Can't use sync call while an async call is in flight
1172                  */
1173                 status = NT_STATUS_INVALID_PARAMETER;
1174                 goto fail;
1175         }
1176
1177         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1178                 status = NT_STATUS_INVALID_PARAMETER;
1179                 goto fail;
1180         }
1181
1182         status = get_fnum_from_path(cli,
1183                                 name,
1184                                 FILE_READ_ATTRIBUTES,
1185                                 &fnum);
1186
1187         if (!NT_STATUS_IS_OK(status)) {
1188                 goto fail;
1189         }
1190
1191         status = map_fnum_to_smb2_handle(cli,
1192                                         fnum,
1193                                         &ph);
1194         if (!NT_STATUS_IS_OK(status)) {
1195                 goto fail;
1196         }
1197
1198         /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
1199            level 22 (SMB2_FILE_STREAM_INFORMATION). */
1200
1201         status = smb2cli_query_info(cli->conn,
1202                                 cli->timeout,
1203                                 cli->smb2.session,
1204                                 cli->smb2.tcon,
1205                                 1, /* in_info_type */
1206                                 (SMB_FILE_STREAM_INFORMATION - 1000), /* in_file_info_class */
1207                                 0xFFFF, /* in_max_output_length */
1208                                 NULL, /* in_input_buffer */
1209                                 0, /* in_additional_info */
1210                                 0, /* in_flags */
1211                                 ph->fid_persistent,
1212                                 ph->fid_volatile,
1213                                 frame,
1214                                 &outbuf);
1215
1216         if (!NT_STATUS_IS_OK(status)) {
1217                 goto fail;
1218         }
1219
1220         /* Parse the reply. */
1221         if (!parse_streams_blob(mem_ctx,
1222                                 outbuf.data,
1223                                 outbuf.length,
1224                                 pnum_streams,
1225                                 pstreams)) {
1226                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1227                 goto fail;
1228         }
1229
1230   fail:
1231
1232         if (fnum != 0xffff) {
1233                 cli_smb2_close_fnum(cli, fnum);
1234         }
1235
1236         TALLOC_FREE(frame);
1237         return status;
1238 }
1239
1240 /***************************************************************
1241  Wrapper that allows SMB2 to set pathname attributes.
1242  Synchronous only.
1243 ***************************************************************/
1244
1245 NTSTATUS cli_smb2_setatr(struct cli_state *cli,
1246                         const char *name,
1247                         uint16_t attr,
1248                         time_t mtime)
1249 {
1250         NTSTATUS status;
1251         uint16_t fnum = 0xffff;
1252         struct smb2_hnd *ph = NULL;
1253         uint8_t inbuf_store[40];
1254         DATA_BLOB inbuf = data_blob_null;
1255         TALLOC_CTX *frame = talloc_stackframe();
1256
1257         if (smbXcli_conn_has_async_calls(cli->conn)) {
1258                 /*
1259                  * Can't use sync call while an async call is in flight
1260                  */
1261                 status = NT_STATUS_INVALID_PARAMETER;
1262                 goto fail;
1263         }
1264
1265         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1266                 status = NT_STATUS_INVALID_PARAMETER;
1267                 goto fail;
1268         }
1269
1270         status = get_fnum_from_path(cli,
1271                                 name,
1272                                 FILE_WRITE_ATTRIBUTES,
1273                                 &fnum);
1274
1275         if (!NT_STATUS_IS_OK(status)) {
1276                 goto fail;
1277         }
1278
1279         status = map_fnum_to_smb2_handle(cli,
1280                                         fnum,
1281                                         &ph);
1282         if (!NT_STATUS_IS_OK(status)) {
1283                 goto fail;
1284         }
1285
1286         /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
1287            level 4 (SMB_FILE_BASIC_INFORMATION - 1000). */
1288
1289         inbuf.data = inbuf_store;
1290         inbuf.length = sizeof(inbuf_store);
1291         data_blob_clear(&inbuf);
1292
1293         SIVAL(inbuf.data,32,attr);
1294         if (mtime != 0) {
1295                 put_long_date((char *)inbuf.data + 16,mtime);
1296         }
1297         /* Set all the other times to -1. */
1298         SBVAL(inbuf.data, 0, 0xFFFFFFFFFFFFFFFFLL);
1299         SBVAL(inbuf.data, 8, 0xFFFFFFFFFFFFFFFFLL);
1300         SBVAL(inbuf.data, 24, 0xFFFFFFFFFFFFFFFFLL);
1301
1302         status = smb2cli_set_info(cli->conn,
1303                                 cli->timeout,
1304                                 cli->smb2.session,
1305                                 cli->smb2.tcon,
1306                                 1, /* in_info_type */
1307                                 SMB_FILE_BASIC_INFORMATION - 1000, /* in_file_info_class */
1308                                 &inbuf, /* in_input_buffer */
1309                                 0, /* in_additional_info */
1310                                 ph->fid_persistent,
1311                                 ph->fid_volatile);
1312   fail:
1313
1314         if (fnum != 0xffff) {
1315                 cli_smb2_close_fnum(cli, fnum);
1316         }
1317
1318         TALLOC_FREE(frame);
1319         return status;
1320 }
1321
1322 /***************************************************************
1323  Wrapper that allows SMB2 to set file handle times.
1324  Synchronous only.
1325 ***************************************************************/
1326
1327 NTSTATUS cli_smb2_setattrE(struct cli_state *cli,
1328                         uint16_t fnum,
1329                         time_t change_time,
1330                         time_t access_time,
1331                         time_t write_time)
1332 {
1333         NTSTATUS status;
1334         struct smb2_hnd *ph = NULL;
1335         uint8_t inbuf_store[40];
1336         DATA_BLOB inbuf = data_blob_null;
1337
1338         if (smbXcli_conn_has_async_calls(cli->conn)) {
1339                 /*
1340                  * Can't use sync call while an async call is in flight
1341                  */
1342                 return NT_STATUS_INVALID_PARAMETER;
1343         }
1344
1345         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1346                 return NT_STATUS_INVALID_PARAMETER;
1347         }
1348
1349         status = map_fnum_to_smb2_handle(cli,
1350                                         fnum,
1351                                         &ph);
1352         if (!NT_STATUS_IS_OK(status)) {
1353                 return status;
1354         }
1355
1356         /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
1357            level 4 (SMB_FILE_BASIC_INFORMATION - 1000). */
1358
1359         inbuf.data = inbuf_store;
1360         inbuf.length = sizeof(inbuf_store);
1361         data_blob_clear(&inbuf);
1362
1363         SBVAL(inbuf.data, 0, 0xFFFFFFFFFFFFFFFFLL);
1364         if (change_time != 0) {
1365                 put_long_date((char *)inbuf.data + 24, change_time);
1366         }
1367         if (access_time != 0) {
1368                 put_long_date((char *)inbuf.data + 8, access_time);
1369         }
1370         if (write_time != 0) {
1371                 put_long_date((char *)inbuf.data + 16, write_time);
1372         }
1373
1374         return smb2cli_set_info(cli->conn,
1375                                 cli->timeout,
1376                                 cli->smb2.session,
1377                                 cli->smb2.tcon,
1378                                 1, /* in_info_type */
1379                                 SMB_FILE_BASIC_INFORMATION - 1000, /* in_file_info_class */
1380                                 &inbuf, /* in_input_buffer */
1381                                 0, /* in_additional_info */
1382                                 ph->fid_persistent,
1383                                 ph->fid_volatile);
1384 }
1385
1386 /***************************************************************
1387  Wrapper that allows SMB2 to query disk attributes (size).
1388  Synchronous only.
1389 ***************************************************************/
1390
1391 NTSTATUS cli_smb2_dskattr(struct cli_state *cli, int *bsize, int *total, int *avail)
1392 {
1393         NTSTATUS status;
1394         uint16_t fnum = 0xffff;
1395         DATA_BLOB outbuf = data_blob_null;
1396         struct smb2_hnd *ph = NULL;
1397         uint32_t sectors_per_unit = 0;
1398         uint32_t bytes_per_sector = 0;
1399         uint64_t total_size = 0;
1400         uint64_t size_free = 0;
1401         TALLOC_CTX *frame = talloc_stackframe();
1402
1403         if (smbXcli_conn_has_async_calls(cli->conn)) {
1404                 /*
1405                  * Can't use sync call while an async call is in flight
1406                  */
1407                 status = NT_STATUS_INVALID_PARAMETER;
1408                 goto fail;
1409         }
1410
1411         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1412                 status = NT_STATUS_INVALID_PARAMETER;
1413                 goto fail;
1414         }
1415
1416         /* First open the top level directory. */
1417         status = cli_smb2_create_fnum(cli,
1418                         "",
1419                         0,                      /* create_flags */
1420                         FILE_READ_ATTRIBUTES,   /* desired_access */
1421                         FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
1422                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1423                         FILE_OPEN,              /* create_disposition */
1424                         FILE_DIRECTORY_FILE,    /* create_options */
1425                         &fnum,
1426                         NULL);
1427
1428         if (!NT_STATUS_IS_OK(status)) {
1429                 goto fail;
1430         }
1431
1432         status = map_fnum_to_smb2_handle(cli,
1433                                         fnum,
1434                                         &ph);
1435         if (!NT_STATUS_IS_OK(status)) {
1436                 goto fail;
1437         }
1438
1439         /* getinfo on the returned handle with info_type SMB2_GETINFO_FS (2),
1440            level 3 (SMB_FS_SIZE_INFORMATION). */
1441
1442         status = smb2cli_query_info(cli->conn,
1443                                 cli->timeout,
1444                                 cli->smb2.session,
1445                                 cli->smb2.tcon,
1446                                 2, /* in_info_type */
1447                                 3, /* in_file_info_class */
1448                                 0xFFFF, /* in_max_output_length */
1449                                 NULL, /* in_input_buffer */
1450                                 0, /* in_additional_info */
1451                                 0, /* in_flags */
1452                                 ph->fid_persistent,
1453                                 ph->fid_volatile,
1454                                 frame,
1455                                 &outbuf);
1456         if (!NT_STATUS_IS_OK(status)) {
1457                 goto fail;
1458         }
1459
1460         /* Parse the reply. */
1461         if (outbuf.length != 24) {
1462                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1463                 goto fail;
1464         }
1465
1466         total_size = BVAL(outbuf.data, 0);
1467         size_free = BVAL(outbuf.data, 8);
1468         sectors_per_unit = IVAL(outbuf.data, 16);
1469         bytes_per_sector = IVAL(outbuf.data, 20);
1470
1471         if (bsize) {
1472                 *bsize = (int)(sectors_per_unit * bytes_per_sector);
1473         }
1474         if (total) {
1475                 *total = (int)total_size;
1476         }
1477         if (avail) {
1478                 *avail = (int)size_free;
1479         }
1480
1481         status = NT_STATUS_OK;
1482
1483   fail:
1484
1485         if (fnum != 0xffff) {
1486                 cli_smb2_close_fnum(cli, fnum);
1487         }
1488
1489         TALLOC_FREE(frame);
1490         return status;
1491 }
1492
1493 /***************************************************************
1494  Wrapper that allows SMB2 to query a security descriptor.
1495  Synchronous only.
1496 ***************************************************************/
1497
1498 NTSTATUS cli_smb2_query_security_descriptor(struct cli_state *cli,
1499                                         uint16_t fnum,
1500                                         uint32_t sec_info,
1501                                         TALLOC_CTX *mem_ctx,
1502                                         struct security_descriptor **ppsd)
1503 {
1504         NTSTATUS status;
1505         DATA_BLOB outbuf = data_blob_null;
1506         struct smb2_hnd *ph = NULL;
1507         struct security_descriptor *lsd = NULL;
1508         TALLOC_CTX *frame = talloc_stackframe();
1509
1510         if (smbXcli_conn_has_async_calls(cli->conn)) {
1511                 /*
1512                  * Can't use sync call while an async call is in flight
1513                  */
1514                 status = NT_STATUS_INVALID_PARAMETER;
1515                 goto fail;
1516         }
1517
1518         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1519                 status = NT_STATUS_INVALID_PARAMETER;
1520                 goto fail;
1521         }
1522
1523         status = map_fnum_to_smb2_handle(cli,
1524                                         fnum,
1525                                         &ph);
1526         if (!NT_STATUS_IS_OK(status)) {
1527                 goto fail;
1528         }
1529
1530         /* getinfo on the returned handle with info_type SMB2_GETINFO_SEC (3) */
1531
1532         status = smb2cli_query_info(cli->conn,
1533                                 cli->timeout,
1534                                 cli->smb2.session,
1535                                 cli->smb2.tcon,
1536                                 3, /* in_info_type */
1537                                 0, /* in_file_info_class */
1538                                 0xFFFF, /* in_max_output_length */
1539                                 NULL, /* in_input_buffer */
1540                                 sec_info, /* in_additional_info */
1541                                 0, /* in_flags */
1542                                 ph->fid_persistent,
1543                                 ph->fid_volatile,
1544                                 frame,
1545                                 &outbuf);
1546
1547         if (!NT_STATUS_IS_OK(status)) {
1548                 goto fail;
1549         }
1550
1551         /* Parse the reply. */
1552         status = unmarshall_sec_desc(mem_ctx,
1553                                 outbuf.data,
1554                                 outbuf.length,
1555                                 &lsd);
1556
1557         if (!NT_STATUS_IS_OK(status)) {
1558                 goto fail;
1559         }
1560
1561         if (ppsd != NULL) {
1562                 *ppsd = lsd;
1563         } else {
1564                 TALLOC_FREE(lsd);
1565         }
1566
1567   fail:
1568
1569         TALLOC_FREE(frame);
1570         return status;
1571 }
1572
1573 /***************************************************************
1574  Wrapper that allows SMB2 to set a security descriptor.
1575  Synchronous only.
1576 ***************************************************************/
1577
1578 NTSTATUS cli_smb2_set_security_descriptor(struct cli_state *cli,
1579                                         uint16_t fnum,
1580                                         uint32_t sec_info,
1581                                         const struct security_descriptor *sd)
1582 {
1583         NTSTATUS status;
1584         DATA_BLOB inbuf = data_blob_null;
1585         struct smb2_hnd *ph = NULL;
1586         TALLOC_CTX *frame = talloc_stackframe();
1587
1588         if (smbXcli_conn_has_async_calls(cli->conn)) {
1589                 /*
1590                  * Can't use sync call while an async call is in flight
1591                  */
1592                 status = NT_STATUS_INVALID_PARAMETER;
1593                 goto fail;
1594         }
1595
1596         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1597                 status = NT_STATUS_INVALID_PARAMETER;
1598                 goto fail;
1599         }
1600
1601         status = map_fnum_to_smb2_handle(cli,
1602                                         fnum,
1603                                         &ph);
1604         if (!NT_STATUS_IS_OK(status)) {
1605                 goto fail;
1606         }
1607
1608         status = marshall_sec_desc(frame,
1609                                 sd,
1610                                 &inbuf.data,
1611                                 &inbuf.length);
1612
1613         if (!NT_STATUS_IS_OK(status)) {
1614                 goto fail;
1615         }
1616
1617         /* setinfo on the returned handle with info_type SMB2_SETINFO_SEC (3) */
1618
1619         status = smb2cli_set_info(cli->conn,
1620                                 cli->timeout,
1621                                 cli->smb2.session,
1622                                 cli->smb2.tcon,
1623                                 3, /* in_info_type */
1624                                 0, /* in_file_info_class */
1625                                 &inbuf, /* in_input_buffer */
1626                                 sec_info, /* in_additional_info */
1627                                 ph->fid_persistent,
1628                                 ph->fid_volatile);
1629
1630   fail:
1631
1632         TALLOC_FREE(frame);
1633         return status;
1634 }
1635
1636 /***************************************************************
1637  Wrapper that allows SMB2 to rename a file.
1638  Synchronous only.
1639 ***************************************************************/
1640
1641 NTSTATUS cli_smb2_rename(struct cli_state *cli,
1642                         const char *fname_src,
1643                         const char *fname_dst)
1644 {
1645         NTSTATUS status;
1646         DATA_BLOB inbuf = data_blob_null;
1647         uint16_t fnum = 0xffff;
1648         struct smb2_hnd *ph = NULL;
1649         smb_ucs2_t *converted_str = NULL;
1650         size_t converted_size_bytes = 0;
1651         size_t namelen = 0;
1652         TALLOC_CTX *frame = talloc_stackframe();
1653
1654         if (smbXcli_conn_has_async_calls(cli->conn)) {
1655                 /*
1656                  * Can't use sync call while an async call is in flight
1657                  */
1658                 status = NT_STATUS_INVALID_PARAMETER;
1659                 goto fail;
1660         }
1661
1662         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1663                 status = NT_STATUS_INVALID_PARAMETER;
1664                 goto fail;
1665         }
1666
1667         status = get_fnum_from_path(cli,
1668                                 fname_src,
1669                                 DELETE_ACCESS,
1670                                 &fnum);
1671
1672         if (!NT_STATUS_IS_OK(status)) {
1673                 goto fail;
1674         }
1675
1676         status = map_fnum_to_smb2_handle(cli,
1677                                         fnum,
1678                                         &ph);
1679         if (!NT_STATUS_IS_OK(status)) {
1680                 goto fail;
1681         }
1682
1683         /* SMB2 is pickier about pathnames. Ensure it doesn't
1684            start in a '\' */
1685         if (*fname_dst == '\\') {
1686                 fname_dst++;
1687         }
1688
1689         /* SMB2 is pickier about pathnames. Ensure it doesn't
1690            end in a '\' */
1691         namelen = strlen(fname_dst);
1692         if (namelen > 0 && fname_dst[namelen-1] == '\\') {
1693                 char *modname = talloc_strdup(frame, fname_dst);
1694                 modname[namelen-1] = '\0';
1695                 fname_dst = modname;
1696         }
1697
1698         if (!push_ucs2_talloc(frame,
1699                                 &converted_str,
1700                                 fname_dst,
1701                                 &converted_size_bytes)) {
1702                 status = NT_STATUS_INVALID_PARAMETER;
1703                 goto fail;
1704         }
1705
1706         /* W2K8 insists the dest name is not null
1707            terminated. Remove the last 2 zero bytes
1708            and reduce the name length. */
1709
1710         if (converted_size_bytes < 2) {
1711                 status = NT_STATUS_INVALID_PARAMETER;
1712                 goto fail;
1713         }
1714         converted_size_bytes -= 2;
1715
1716         inbuf = data_blob_talloc_zero(frame,
1717                                 20 + converted_size_bytes);
1718         if (inbuf.data == NULL) {
1719                 status = NT_STATUS_NO_MEMORY;
1720                 goto fail;
1721         }
1722
1723         SIVAL(inbuf.data, 16, converted_size_bytes);
1724         memcpy(inbuf.data + 20, converted_str, converted_size_bytes);
1725
1726         /* setinfo on the returned handle with info_type SMB2_GETINFO_FILE (1),
1727            level SMB2_FILE_RENAME_INFORMATION (SMB_FILE_RENAME_INFORMATION - 1000) */
1728
1729         status = smb2cli_set_info(cli->conn,
1730                                 cli->timeout,
1731                                 cli->smb2.session,
1732                                 cli->smb2.tcon,
1733                                 1, /* in_info_type */
1734                                 SMB_FILE_RENAME_INFORMATION - 1000, /* in_file_info_class */
1735                                 &inbuf, /* in_input_buffer */
1736                                 0, /* in_additional_info */
1737                                 ph->fid_persistent,
1738                                 ph->fid_volatile);
1739
1740   fail:
1741
1742         if (fnum != 0xffff) {
1743                 cli_smb2_close_fnum(cli, fnum);
1744         }
1745
1746         TALLOC_FREE(frame);
1747         return status;
1748 }
1749
1750 /***************************************************************
1751  Wrapper that allows SMB2 to set an EA on a fnum.
1752  Synchronous only.
1753 ***************************************************************/
1754
1755 NTSTATUS cli_smb2_set_ea_fnum(struct cli_state *cli,
1756                         uint16_t fnum,
1757                         const char *ea_name,
1758                         const char *ea_val,
1759                         size_t ea_len)
1760 {
1761         NTSTATUS status;
1762         DATA_BLOB inbuf = data_blob_null;
1763         size_t bloblen = 0;
1764         char *ea_name_ascii = NULL;
1765         size_t namelen = 0;
1766         struct smb2_hnd *ph = NULL;
1767         TALLOC_CTX *frame = talloc_stackframe();
1768
1769         if (smbXcli_conn_has_async_calls(cli->conn)) {
1770                 /*
1771                  * Can't use sync call while an async call is in flight
1772                  */
1773                 status = NT_STATUS_INVALID_PARAMETER;
1774                 goto fail;
1775         }
1776
1777         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1778                 status = NT_STATUS_INVALID_PARAMETER;
1779                 goto fail;
1780         }
1781
1782         status = map_fnum_to_smb2_handle(cli,
1783                                         fnum,
1784                                         &ph);
1785         if (!NT_STATUS_IS_OK(status)) {
1786                 goto fail;
1787         }
1788
1789         /* Marshall the SMB2 EA data. */
1790         if (ea_len > 0xFFFF) {
1791                 status = NT_STATUS_INVALID_PARAMETER;
1792                 goto fail;
1793         }
1794
1795         if (!push_ascii_talloc(frame,
1796                                 &ea_name_ascii,
1797                                 ea_name,
1798                                 &namelen)) {
1799                 status = NT_STATUS_INVALID_PARAMETER;
1800                 goto fail;
1801         }
1802
1803         if (namelen < 2 || namelen > 0xFF) {
1804                 status = NT_STATUS_INVALID_PARAMETER;
1805                 goto fail;
1806         }
1807
1808         bloblen = 8 + ea_len + namelen;
1809         /* Round up to a 4 byte boundary. */
1810         bloblen = ((bloblen + 3)&~3);
1811
1812         inbuf = data_blob_talloc_zero(frame, bloblen);
1813         if (inbuf.data == NULL) {
1814                 status = NT_STATUS_NO_MEMORY;
1815                 goto fail;
1816         }
1817         /* namelen doesn't include the NULL byte. */
1818         SCVAL(inbuf.data, 5, namelen - 1);
1819         SSVAL(inbuf.data, 6, ea_len);
1820         memcpy(inbuf.data + 8, ea_name_ascii, namelen);
1821         memcpy(inbuf.data + 8 + namelen, ea_val, ea_len);
1822
1823         /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
1824            level 15 (SMB_FILE_FULL_EA_INFORMATION - 1000). */
1825
1826         status = smb2cli_set_info(cli->conn,
1827                                 cli->timeout,
1828                                 cli->smb2.session,
1829                                 cli->smb2.tcon,
1830                                 1, /* in_info_type */
1831                                 SMB_FILE_FULL_EA_INFORMATION - 1000, /* in_file_info_class */
1832                                 &inbuf, /* in_input_buffer */
1833                                 0, /* in_additional_info */
1834                                 ph->fid_persistent,
1835                                 ph->fid_volatile);
1836
1837   fail:
1838
1839         TALLOC_FREE(frame);
1840         return status;
1841 }
1842
1843 /***************************************************************
1844  Wrapper that allows SMB2 to set an EA on a pathname.
1845  Synchronous only.
1846 ***************************************************************/
1847
1848 NTSTATUS cli_smb2_set_ea_path(struct cli_state *cli,
1849                         const char *name,
1850                         const char *ea_name,
1851                         const char *ea_val,
1852                         size_t ea_len)
1853 {
1854         NTSTATUS status;
1855         uint16_t fnum = 0xffff;
1856
1857         if (smbXcli_conn_has_async_calls(cli->conn)) {
1858                 /*
1859                  * Can't use sync call while an async call is in flight
1860                  */
1861                 status = NT_STATUS_INVALID_PARAMETER;
1862                 goto fail;
1863         }
1864
1865         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1866                 status = NT_STATUS_INVALID_PARAMETER;
1867                 goto fail;
1868         }
1869
1870         status = get_fnum_from_path(cli,
1871                                 name,
1872                                 FILE_WRITE_EA,
1873                                 &fnum);
1874
1875         if (!NT_STATUS_IS_OK(status)) {
1876                 goto fail;
1877         }
1878
1879         status = cli_set_ea_fnum(cli,
1880                                 fnum,
1881                                 ea_name,
1882                                 ea_val,
1883                                 ea_len);
1884         if (!NT_STATUS_IS_OK(status)) {
1885                 goto fail;
1886         }
1887
1888   fail:
1889
1890         if (fnum != 0xffff) {
1891                 cli_smb2_close_fnum(cli, fnum);
1892         }
1893
1894         return status;
1895 }
1896
1897 /***************************************************************
1898  Wrapper that allows SMB2 to get an EA list on a pathname.
1899  Synchronous only.
1900 ***************************************************************/
1901
1902 NTSTATUS cli_smb2_get_ea_list_path(struct cli_state *cli,
1903                                 const char *name,
1904                                 TALLOC_CTX *ctx,
1905                                 size_t *pnum_eas,
1906                                 struct ea_struct **pea_array)
1907 {
1908         NTSTATUS status;
1909         uint16_t fnum = 0xffff;
1910         DATA_BLOB outbuf = data_blob_null;
1911         struct smb2_hnd *ph = NULL;
1912         struct ea_list *ea_list = NULL;
1913         struct ea_list *eal = NULL;
1914         size_t ea_count = 0;
1915         TALLOC_CTX *frame = talloc_stackframe();
1916
1917         *pnum_eas = 0;
1918         *pea_array = NULL;
1919
1920         if (smbXcli_conn_has_async_calls(cli->conn)) {
1921                 /*
1922                  * Can't use sync call while an async call is in flight
1923                  */
1924                 status = NT_STATUS_INVALID_PARAMETER;
1925                 goto fail;
1926         }
1927
1928         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1929                 status = NT_STATUS_INVALID_PARAMETER;
1930                 goto fail;
1931         }
1932
1933         status = get_fnum_from_path(cli,
1934                                 name,
1935                                 FILE_READ_EA,
1936                                 &fnum);
1937
1938         if (!NT_STATUS_IS_OK(status)) {
1939                 goto fail;
1940         }
1941
1942         status = map_fnum_to_smb2_handle(cli,
1943                                         fnum,
1944                                         &ph);
1945         if (!NT_STATUS_IS_OK(status)) {
1946                 goto fail;
1947         }
1948
1949         /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
1950            level 15 (SMB_FILE_FULL_EA_INFORMATION - 1000). */
1951
1952         status = smb2cli_query_info(cli->conn,
1953                                 cli->timeout,
1954                                 cli->smb2.session,
1955                                 cli->smb2.tcon,
1956                                 1, /* in_info_type */
1957                                 SMB_FILE_FULL_EA_INFORMATION - 1000, /* in_file_info_class */
1958                                 0xFFFF, /* in_max_output_length */
1959                                 NULL, /* in_input_buffer */
1960                                 0, /* in_additional_info */
1961                                 0, /* in_flags */
1962                                 ph->fid_persistent,
1963                                 ph->fid_volatile,
1964                                 frame,
1965                                 &outbuf);
1966
1967         if (!NT_STATUS_IS_OK(status)) {
1968                 goto fail;
1969         }
1970
1971         /* Parse the reply. */
1972         ea_list = read_nttrans_ea_list(ctx,
1973                                 (const char *)outbuf.data,
1974                                 outbuf.length);
1975         if (ea_list == NULL) {
1976                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1977                 goto fail;
1978         }
1979
1980         /* Convert to an array. */
1981         for (eal = ea_list; eal; eal = eal->next) {
1982                 ea_count++;
1983         }
1984
1985         if (ea_count) {
1986                 *pea_array = talloc_array(ctx, struct ea_struct, ea_count);
1987                 if (*pea_array == NULL) {
1988                         status = NT_STATUS_NO_MEMORY;
1989                         goto fail;
1990                 }
1991                 ea_count = 0;
1992                 for (eal = ea_list; eal; eal = eal->next) {
1993                         (*pea_array)[ea_count++] = ea_list->ea;
1994                 }
1995                 *pnum_eas = ea_count;
1996         }
1997
1998   fail:
1999
2000         TALLOC_FREE(frame);
2001         return status;
2002 }
2003
2004 struct cli_smb2_read_state {
2005         struct tevent_context *ev;
2006         struct cli_state *cli;
2007         struct smb2_hnd *ph;
2008         uint64_t start_offset;
2009         uint32_t size;
2010         uint32_t received;
2011         uint8_t *buf;
2012 };
2013
2014 static void cli_smb2_read_done(struct tevent_req *subreq);
2015
2016 struct tevent_req *cli_smb2_read_send(TALLOC_CTX *mem_ctx,
2017                                 struct tevent_context *ev,
2018                                 struct cli_state *cli,
2019                                 uint16_t fnum,
2020                                 off_t offset,
2021                                 size_t size)
2022 {
2023         NTSTATUS status;
2024         struct tevent_req *req, *subreq;
2025         struct cli_smb2_read_state *state;
2026
2027         req = tevent_req_create(mem_ctx, &state, struct cli_smb2_read_state);
2028         if (req == NULL) {
2029                 return NULL;
2030         }
2031         state->ev = ev;
2032         state->cli = cli;
2033         state->start_offset = (uint64_t)offset;
2034         state->size = (uint32_t)size;
2035         state->received = 0;
2036         state->buf = NULL;
2037
2038         status = map_fnum_to_smb2_handle(cli,
2039                                         fnum,
2040                                         &state->ph);
2041         if (tevent_req_nterror(req, status)) {
2042                 return tevent_req_post(req, ev);
2043         }
2044
2045         subreq = smb2cli_read_send(state,
2046                                 state->ev,
2047                                 state->cli->conn,
2048                                 state->cli->timeout,
2049                                 state->cli->smb2.session,
2050                                 state->cli->smb2.tcon,
2051                                 state->size,
2052                                 state->start_offset,
2053                                 state->ph->fid_persistent,
2054                                 state->ph->fid_volatile,
2055                                 0, /* minimum_count */
2056                                 0); /* remaining_bytes */
2057
2058         if (tevent_req_nomem(subreq, req)) {
2059                 return tevent_req_post(req, ev);
2060         }
2061         tevent_req_set_callback(subreq, cli_smb2_read_done, req);
2062         return req;
2063 }
2064
2065 static void cli_smb2_read_done(struct tevent_req *subreq)
2066 {
2067         struct tevent_req *req = tevent_req_callback_data(
2068                 subreq, struct tevent_req);
2069         struct cli_smb2_read_state *state = tevent_req_data(
2070                 req, struct cli_smb2_read_state);
2071         NTSTATUS status;
2072
2073         status = smb2cli_read_recv(subreq, state,
2074                                    &state->buf, &state->received);
2075         if (tevent_req_nterror(req, status)) {
2076                 return;
2077         }
2078
2079         if (state->received > state->size) {
2080                 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
2081                 return;
2082         }
2083
2084         tevent_req_done(req);
2085 }
2086
2087 NTSTATUS cli_smb2_read_recv(struct tevent_req *req,
2088                                 ssize_t *received,
2089                                 uint8_t **rcvbuf)
2090 {
2091         NTSTATUS status;
2092         struct cli_smb2_read_state *state = tevent_req_data(
2093                                 req, struct cli_smb2_read_state);
2094
2095         if (tevent_req_is_nterror(req, &status)) {
2096                 return status;
2097         }
2098         /*
2099          * As in cli_read_andx_recv() rcvbuf is talloced from the request, so
2100          * better make sure that you copy it away before you talloc_free(req).
2101          * "rcvbuf" is NOT a talloc_ctx of its own, so do not talloc_move it!
2102          */
2103         *received = (ssize_t)state->received;
2104         *rcvbuf = state->buf;
2105         return NT_STATUS_OK;
2106 }
2107
2108 struct cli_smb2_write_state {
2109         struct tevent_context *ev;
2110         struct cli_state *cli;
2111         struct smb2_hnd *ph;
2112         uint32_t flags;
2113         const uint8_t *buf;
2114         uint64_t offset;
2115         uint32_t size;
2116         uint32_t written;
2117 };
2118
2119 static void cli_smb2_write_written(struct tevent_req *req);
2120
2121 struct tevent_req *cli_smb2_write_send(TALLOC_CTX *mem_ctx,
2122                                         struct tevent_context *ev,
2123                                         struct cli_state *cli,
2124                                         uint16_t fnum,
2125                                         uint16_t mode,
2126                                         const uint8_t *buf,
2127                                         off_t offset,
2128                                         size_t size)
2129 {
2130         NTSTATUS status;
2131         struct tevent_req *req, *subreq = NULL;
2132         struct cli_smb2_write_state *state = NULL;
2133
2134         req = tevent_req_create(mem_ctx, &state, struct cli_smb2_write_state);
2135         if (req == NULL) {
2136                 return NULL;
2137         }
2138         state->ev = ev;
2139         state->cli = cli;
2140         /* Both SMB1 and SMB2 use 1 in the following meaning write-through. */
2141         state->flags = (uint32_t)mode;
2142         state->buf = buf;
2143         state->offset = (uint64_t)offset;
2144         state->size = (uint32_t)size;
2145         state->written = 0;
2146
2147         status = map_fnum_to_smb2_handle(cli,
2148                                         fnum,
2149                                         &state->ph);
2150         if (tevent_req_nterror(req, status)) {
2151                 return tevent_req_post(req, ev);
2152         }
2153
2154         subreq = smb2cli_write_send(state,
2155                                 state->ev,
2156                                 state->cli->conn,
2157                                 state->cli->timeout,
2158                                 state->cli->smb2.session,
2159                                 state->cli->smb2.tcon,
2160                                 state->size,
2161                                 state->offset,
2162                                 state->ph->fid_persistent,
2163                                 state->ph->fid_volatile,
2164                                 0, /* remaining_bytes */
2165                                 state->flags, /* flags */
2166                                 state->buf);
2167
2168         if (tevent_req_nomem(subreq, req)) {
2169                 return tevent_req_post(req, ev);
2170         }
2171         tevent_req_set_callback(subreq, cli_smb2_write_written, req);
2172         return req;
2173 }
2174
2175 static void cli_smb2_write_written(struct tevent_req *subreq)
2176 {
2177         struct tevent_req *req = tevent_req_callback_data(
2178                 subreq, struct tevent_req);
2179         struct cli_smb2_write_state *state = tevent_req_data(
2180                 req, struct cli_smb2_write_state);
2181         NTSTATUS status;
2182         uint32_t written;
2183
2184         status = smb2cli_write_recv(subreq, &written);
2185         TALLOC_FREE(subreq);
2186         if (tevent_req_nterror(req, status)) {
2187                 return;
2188         }
2189
2190         state->written = written;
2191
2192         tevent_req_done(req);
2193 }
2194
2195 NTSTATUS cli_smb2_write_recv(struct tevent_req *req,
2196                              size_t *pwritten)
2197 {
2198         struct cli_smb2_write_state *state = tevent_req_data(
2199                 req, struct cli_smb2_write_state);
2200         NTSTATUS status;
2201
2202         if (tevent_req_is_nterror(req, &status)) {
2203                 tevent_req_received(req);
2204                 return status;
2205         }
2206
2207         if (pwritten != NULL) {
2208                 *pwritten = (size_t)state->written;
2209         }
2210         tevent_req_received(req);
2211         return NT_STATUS_OK;
2212 }
2213
2214 /***************************************************************
2215  Wrapper that allows SMB2 async write using an fnum.
2216  This is mostly cut-and-paste from Volker's code inside
2217  source3/libsmb/clireadwrite.c, adapted for SMB2.
2218
2219  Done this way so I can reuse all the logic inside cli_push()
2220  for free :-).
2221 ***************************************************************/
2222
2223 struct cli_smb2_writeall_state {
2224         struct tevent_context *ev;
2225         struct cli_state *cli;
2226         struct smb2_hnd *ph;
2227         uint32_t flags;
2228         const uint8_t *buf;
2229         uint64_t offset;
2230         uint32_t size;
2231         uint32_t written;
2232 };
2233
2234 static void cli_smb2_writeall_written(struct tevent_req *req);
2235
2236 struct tevent_req *cli_smb2_writeall_send(TALLOC_CTX *mem_ctx,
2237                                         struct tevent_context *ev,
2238                                         struct cli_state *cli,
2239                                         uint16_t fnum,
2240                                         uint16_t mode,
2241                                         const uint8_t *buf,
2242                                         off_t offset,
2243                                         size_t size)
2244 {
2245         NTSTATUS status;
2246         struct tevent_req *req, *subreq = NULL;
2247         struct cli_smb2_writeall_state *state = NULL;
2248         uint32_t to_write;
2249         uint32_t max_size;
2250         bool ok;
2251
2252         req = tevent_req_create(mem_ctx, &state, struct cli_smb2_writeall_state);
2253         if (req == NULL) {
2254                 return NULL;
2255         }
2256         state->ev = ev;
2257         state->cli = cli;
2258         /* Both SMB1 and SMB2 use 1 in the following meaning write-through. */
2259         state->flags = (uint32_t)mode;
2260         state->buf = buf;
2261         state->offset = (uint64_t)offset;
2262         state->size = (uint32_t)size;
2263         state->written = 0;
2264
2265         status = map_fnum_to_smb2_handle(cli,
2266                                         fnum,
2267                                         &state->ph);
2268         if (tevent_req_nterror(req, status)) {
2269                 return tevent_req_post(req, ev);
2270         }
2271
2272         to_write = state->size;
2273         max_size = smb2cli_conn_max_write_size(state->cli->conn);
2274         to_write = MIN(max_size, to_write);
2275         ok = smb2cli_conn_req_possible(state->cli->conn, &max_size);
2276         if (ok) {
2277                 to_write = MIN(max_size, to_write);
2278         }
2279
2280         subreq = smb2cli_write_send(state,
2281                                 state->ev,
2282                                 state->cli->conn,
2283                                 state->cli->timeout,
2284                                 state->cli->smb2.session,
2285                                 state->cli->smb2.tcon,
2286                                 to_write,
2287                                 state->offset,
2288                                 state->ph->fid_persistent,
2289                                 state->ph->fid_volatile,
2290                                 0, /* remaining_bytes */
2291                                 state->flags, /* flags */
2292                                 state->buf + state->written);
2293
2294         if (tevent_req_nomem(subreq, req)) {
2295                 return tevent_req_post(req, ev);
2296         }
2297         tevent_req_set_callback(subreq, cli_smb2_writeall_written, req);
2298         return req;
2299 }
2300
2301 static void cli_smb2_writeall_written(struct tevent_req *subreq)
2302 {
2303         struct tevent_req *req = tevent_req_callback_data(
2304                 subreq, struct tevent_req);
2305         struct cli_smb2_writeall_state *state = tevent_req_data(
2306                 req, struct cli_smb2_writeall_state);
2307         NTSTATUS status;
2308         uint32_t written, to_write;
2309         uint32_t max_size;
2310         bool ok;
2311
2312         status = smb2cli_write_recv(subreq, &written);
2313         TALLOC_FREE(subreq);
2314         if (tevent_req_nterror(req, status)) {
2315                 return;
2316         }
2317
2318         state->written += written;
2319
2320         if (state->written > state->size) {
2321                 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
2322                 return;
2323         }
2324
2325         to_write = state->size - state->written;
2326
2327         if (to_write == 0) {
2328                 tevent_req_done(req);
2329                 return;
2330         }
2331
2332         max_size = smb2cli_conn_max_write_size(state->cli->conn);
2333         to_write = MIN(max_size, to_write);
2334         ok = smb2cli_conn_req_possible(state->cli->conn, &max_size);
2335         if (ok) {
2336                 to_write = MIN(max_size, to_write);
2337         }
2338
2339         subreq = smb2cli_write_send(state,
2340                                 state->ev,
2341                                 state->cli->conn,
2342                                 state->cli->timeout,
2343                                 state->cli->smb2.session,
2344                                 state->cli->smb2.tcon,
2345                                 to_write,
2346                                 state->offset + state->written,
2347                                 state->ph->fid_persistent,
2348                                 state->ph->fid_volatile,
2349                                 0, /* remaining_bytes */
2350                                 state->flags, /* flags */
2351                                 state->buf + state->written);
2352
2353         if (tevent_req_nomem(subreq, req)) {
2354                 return;
2355         }
2356         tevent_req_set_callback(subreq, cli_smb2_writeall_written, req);
2357 }
2358
2359 NTSTATUS cli_smb2_writeall_recv(struct tevent_req *req,
2360                                 size_t *pwritten)
2361 {
2362         struct cli_smb2_writeall_state *state = tevent_req_data(
2363                 req, struct cli_smb2_writeall_state);
2364         NTSTATUS status;
2365
2366         if (tevent_req_is_nterror(req, &status)) {
2367                 return status;
2368         }
2369         if (pwritten != NULL) {
2370                 *pwritten = (size_t)state->written;
2371         }
2372         return NT_STATUS_OK;
2373 }