source3/libsmb/clifile.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    client file operations
   4    Copyright (C) Andrew Tridgell 1994-1998
   5    Copyright (C) Jeremy Allison 2001-2009
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "includes.h"
  22 #include "system/filesys.h"
  23 #include "libsmb/libsmb.h"
  24 #include "../lib/util/tevent_ntstatus.h"
  25 #include "async_smb.h"
  26 #include "libsmb/clirap.h"
  27 #include "trans2.h"
  28 #include "ntioctl.h"
  29 #include "libcli/security/secdesc.h"
  30 #include "../libcli/smb/smbXcli_base.h"
  31
  32 struct cli_setpathinfo_state {
  33         uint16_t setup;
  34         uint8_t *param;
  35 };
  36
  37 static void cli_setpathinfo_done(struct tevent_req *subreq);
  38
  39 struct tevent_req *cli_setpathinfo_send(TALLOC_CTX *mem_ctx,
  40                                         struct tevent_context *ev,
  41                                         struct cli_state *cli,
  42                                         uint16_t level,
  43                                         const char *path,
  44                                         uint8_t *data,
  45                                         size_t data_len)
  46 {
  47         struct tevent_req *req, *subreq;
  48         struct cli_setpathinfo_state *state;
  49         uint16_t additional_flags2 = 0;
  50
  51         req = tevent_req_create(mem_ctx, &state,
  52                                 struct cli_setpathinfo_state);
  53         if (req == NULL) {
  54                 return NULL;
  55         }
  56
  57         /* Setup setup word. */
  58         SSVAL(&state->setup, 0, TRANSACT2_SETPATHINFO);
  59
  60         /* Setup param array. */
  61         state->param = talloc_zero_array(state, uint8_t, 6);
  62         if (tevent_req_nomem(state->param, req)) {
  63                 return tevent_req_post(req, ev);
  64         }
  65         SSVAL(state->param, 0, level);
  66
  67         state->param = trans2_bytes_push_str(
  68                 state->param, smbXcli_conn_use_unicode(cli->conn), path, strlen(path)+1, NULL);
  69         if (tevent_req_nomem(state->param, req)) {
  70                 return tevent_req_post(req, ev);
  71         }
  72
  73         if (clistr_is_previous_version_path(path, NULL, NULL, NULL) &&
  74                         !INFO_LEVEL_IS_UNIX(level)) {
  75                 additional_flags2 = FLAGS2_REPARSE_PATH;
  76         }
  77
  78         subreq = cli_trans_send(
  79                 state,                  /* mem ctx. */
  80                 ev,                     /* event ctx. */
  81                 cli,                    /* cli_state. */
  82                 additional_flags2,      /* additional_flags2 */
  83                 SMBtrans2,              /* cmd. */
  84                 NULL,                   /* pipe name. */
  85                 -1,                     /* fid. */
  86                 0,                      /* function. */
  87                 0,                      /* flags. */
  88                 &state->setup,          /* setup. */
  89                 1,                      /* num setup uint16_t words. */
  90                 0,                      /* max returned setup. */
  91                 state->param,           /* param. */
  92                 talloc_get_size(state->param),  /* num param. */
  93                 2,                      /* max returned param. */
  94                 data,                   /* data. */
  95                 data_len,               /* num data. */
  96                 0);                     /* max returned data. */
  97
  98         if (tevent_req_nomem(subreq, req)) {
  99                 return tevent_req_post(req, ev);
 100         }
 101         tevent_req_set_callback(subreq, cli_setpathinfo_done, req);
 102         return req;
 103 }
 104
 105 static void cli_setpathinfo_done(struct tevent_req *subreq)
 106 {
 107         NTSTATUS status = cli_trans_recv(subreq, NULL, NULL, NULL, 0, NULL,
 108                                          NULL, 0, NULL, NULL, 0, NULL);
 109         tevent_req_simple_finish_ntstatus(subreq, status);
 110 }
 111
 112 NTSTATUS cli_setpathinfo_recv(struct tevent_req *req)
 113 {
 114         return tevent_req_simple_recv_ntstatus(req);
 115 }
 116
 117 NTSTATUS cli_setpathinfo(struct cli_state *cli,
 118                          uint16_t level,
 119                          const char *path,
 120                          uint8_t *data,
 121                          size_t data_len)
 122 {
 123         TALLOC_CTX *frame = talloc_stackframe();
 124         struct tevent_context *ev;
 125         struct tevent_req *req;
 126         NTSTATUS status = NT_STATUS_NO_MEMORY;
 127
 128         if (smbXcli_conn_has_async_calls(cli->conn)) {
 129                 /*
 130                  * Can't use sync call while an async call is in flight
 131                  */
 132                 status = NT_STATUS_INVALID_PARAMETER;
 133                 goto fail;
 134         }
 135         ev = samba_tevent_context_init(frame);
 136         if (ev == NULL) {
 137                 goto fail;
 138         }
 139         req = cli_setpathinfo_send(ev, ev, cli, level, path, data, data_len);
 140         if (req == NULL) {
 141                 goto fail;
 142         }
 143         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 144                 goto fail;
 145         }
 146         status = cli_setpathinfo_recv(req);
 147  fail:
 148         TALLOC_FREE(frame);
 149         return status;
 150 }
 151
 152 /****************************************************************************
 153  Hard/Symlink a file (UNIX extensions).
 154  Creates new name (sym)linked to oldname.
 155 ****************************************************************************/
 156
 157 struct cli_posix_link_internal_state {
 158         uint8_t *data;
 159 };
 160
 161 static void cli_posix_link_internal_done(struct tevent_req *subreq);
 162
 163 static struct tevent_req *cli_posix_link_internal_send(TALLOC_CTX *mem_ctx,
 164                                         struct tevent_context *ev,
 165                                         struct cli_state *cli,
 166                                         uint16_t level,
 167                                         const char *oldname,
 168                                         const char *newname)
 169 {
 170         struct tevent_req *req = NULL, *subreq = NULL;
 171         struct cli_posix_link_internal_state *state = NULL;
 172
 173         req = tevent_req_create(mem_ctx, &state,
 174                                 struct cli_posix_link_internal_state);
 175         if (req == NULL) {
 176                 return NULL;
 177         }
 178
 179         /* Setup data array. */
 180         state->data = talloc_array(state, uint8_t, 0);
 181         if (tevent_req_nomem(state->data, req)) {
 182                 return tevent_req_post(req, ev);
 183         }
 184         state->data = trans2_bytes_push_str(
 185                 state->data, smbXcli_conn_use_unicode(cli->conn), oldname, strlen(oldname)+1, NULL);
 186
 187         subreq = cli_setpathinfo_send(
 188                 state, ev, cli, level, newname,
 189                 state->data, talloc_get_size(state->data));
 190         if (tevent_req_nomem(subreq, req)) {
 191                 return tevent_req_post(req, ev);
 192         }
 193         tevent_req_set_callback(subreq, cli_posix_link_internal_done, req);
 194         return req;
 195 }
 196
 197 static void cli_posix_link_internal_done(struct tevent_req *subreq)
 198 {
 199         NTSTATUS status = cli_setpathinfo_recv(subreq);
 200         tevent_req_simple_finish_ntstatus(subreq, status);
 201 }
 202
 203 /****************************************************************************
 204  Symlink a file (UNIX extensions).
 205 ****************************************************************************/
 206
 207 struct tevent_req *cli_posix_symlink_send(TALLOC_CTX *mem_ctx,
 208                                         struct tevent_context *ev,
 209                                         struct cli_state *cli,
 210                                         const char *oldname,
 211                                         const char *newname)
 212 {
 213         return cli_posix_link_internal_send(
 214                 mem_ctx, ev, cli, SMB_SET_FILE_UNIX_LINK, oldname, newname);
 215 }
 216
 217 NTSTATUS cli_posix_symlink_recv(struct tevent_req *req)
 218 {
 219         return tevent_req_simple_recv_ntstatus(req);
 220 }
 221
 222 NTSTATUS cli_posix_symlink(struct cli_state *cli,
 223                         const char *oldname,
 224                         const char *newname)
 225 {
 226         TALLOC_CTX *frame = talloc_stackframe();
 227         struct tevent_context *ev = NULL;
 228         struct tevent_req *req = NULL;
 229         NTSTATUS status = NT_STATUS_OK;
 230
 231         if (smbXcli_conn_has_async_calls(cli->conn)) {
 232                 /*
 233                  * Can't use sync call while an async call is in flight
 234                  */
 235                 status = NT_STATUS_INVALID_PARAMETER;
 236                 goto fail;
 237         }
 238
 239         ev = samba_tevent_context_init(frame);
 240         if (ev == NULL) {
 241                 status = NT_STATUS_NO_MEMORY;
 242                 goto fail;
 243         }
 244
 245         req = cli_posix_symlink_send(frame,
 246                                 ev,
 247                                 cli,
 248                                 oldname,
 249                                 newname);
 250         if (req == NULL) {
 251                 status = NT_STATUS_NO_MEMORY;
 252                 goto fail;
 253         }
 254
 255         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 256                 goto fail;
 257         }
 258
 259         status = cli_posix_symlink_recv(req);
 260
 261  fail:
 262         TALLOC_FREE(frame);
 263         return status;
 264 }
 265
 266 /****************************************************************************
 267  Read a POSIX symlink.
 268 ****************************************************************************/
 269
 270 struct readlink_state {
 271         uint8_t *data;
 272         uint32_t num_data;
 273 };
 274
 275 static void cli_posix_readlink_done(struct tevent_req *subreq);
 276
 277 struct tevent_req *cli_posix_readlink_send(TALLOC_CTX *mem_ctx,
 278                                         struct tevent_context *ev,
 279                                         struct cli_state *cli,
 280                                         const char *fname,
 281                                         size_t len)
 282 {
 283         struct tevent_req *req = NULL, *subreq = NULL;
 284         struct readlink_state *state = NULL;
 285         uint32_t maxbytelen = (uint32_t)(smbXcli_conn_use_unicode(cli->conn) ? len*3 : len);
 286
 287         req = tevent_req_create(mem_ctx, &state, struct readlink_state);
 288         if (req == NULL) {
 289                 return NULL;
 290         }
 291
 292         /*
 293          * Len is in bytes, we need it in UCS2 units.
 294          */
 295         if ((2*len < len) || (maxbytelen < len)) {
 296                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
 297                 return tevent_req_post(req, ev);
 298         }
 299
 300         subreq = cli_qpathinfo_send(state, ev, cli, fname,
 301                                     SMB_QUERY_FILE_UNIX_LINK, 1, maxbytelen);
 302         if (tevent_req_nomem(subreq, req)) {
 303                 return tevent_req_post(req, ev);
 304         }
 305         tevent_req_set_callback(subreq, cli_posix_readlink_done, req);
 306         return req;
 307 }
 308
 309 static void cli_posix_readlink_done(struct tevent_req *subreq)
 310 {
 311         struct tevent_req *req = tevent_req_callback_data(
 312                 subreq, struct tevent_req);
 313         struct readlink_state *state = tevent_req_data(
 314                 req, struct readlink_state);
 315         NTSTATUS status;
 316
 317         status = cli_qpathinfo_recv(subreq, state, &state->data,
 318                                     &state->num_data);
 319         TALLOC_FREE(subreq);
 320         if (tevent_req_nterror(req, status)) {
 321                 return;
 322         }
 323         /*
 324          * num_data is > 1, we've given 1 as minimum to cli_qpathinfo_send
 325          */
 326         if (state->data[state->num_data-1] != '\0') {
 327                 tevent_req_nterror(req, NT_STATUS_DATA_ERROR);
 328                 return;
 329         }
 330         tevent_req_done(req);
 331 }
 332
 333 NTSTATUS cli_posix_readlink_recv(struct tevent_req *req, struct cli_state *cli,
 334                                 char *retpath, size_t len)
 335 {
 336         NTSTATUS status;
 337         char *converted = NULL;
 338         size_t converted_size = 0;
 339         struct readlink_state *state = tevent_req_data(req, struct readlink_state);
 340
 341         if (tevent_req_is_nterror(req, &status)) {
 342                 return status;
 343         }
 344         /* The returned data is a pushed string, not raw data. */
 345         if (!convert_string_talloc(state,
 346                                 smbXcli_conn_use_unicode(cli->conn) ? CH_UTF16LE : CH_DOS,
 347                                 CH_UNIX,
 348                                 state->data,
 349                                 state->num_data,
 350                                 &converted,
 351                                 &converted_size)) {
 352                 return NT_STATUS_NO_MEMORY;
 353         }
 354
 355         len = MIN(len,converted_size);
 356         if (len == 0) {
 357                 return NT_STATUS_DATA_ERROR;
 358         }
 359         memcpy(retpath, converted, len);
 360         return NT_STATUS_OK;
 361 }
 362
 363 NTSTATUS cli_posix_readlink(struct cli_state *cli, const char *fname,
 364                                 char *linkpath, size_t len)
 365 {
 366         TALLOC_CTX *frame = talloc_stackframe();
 367         struct tevent_context *ev = NULL;
 368         struct tevent_req *req = NULL;
 369         NTSTATUS status = NT_STATUS_OK;
 370
 371         if (smbXcli_conn_has_async_calls(cli->conn)) {
 372                 /*
 373                  * Can't use sync call while an async call is in flight
 374                  */
 375                 status = NT_STATUS_INVALID_PARAMETER;
 376                 goto fail;
 377         }
 378
 379         ev = samba_tevent_context_init(frame);
 380         if (ev == NULL) {
 381                 status = NT_STATUS_NO_MEMORY;
 382                 goto fail;
 383         }
 384
 385         req = cli_posix_readlink_send(frame,
 386                                 ev,
 387                                 cli,
 388                                 fname,
 389                                 len);
 390         if (req == NULL) {
 391                 status = NT_STATUS_NO_MEMORY;
 392                 goto fail;
 393         }
 394
 395         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 396                 goto fail;
 397         }
 398
 399         status = cli_posix_readlink_recv(req, cli, linkpath, len);
 400
 401  fail:
 402         TALLOC_FREE(frame);
 403         return status;
 404 }
 405
 406 /****************************************************************************
 407  Hard link a file (UNIX extensions).
 408 ****************************************************************************/
 409
 410 struct tevent_req *cli_posix_hardlink_send(TALLOC_CTX *mem_ctx,
 411                                         struct tevent_context *ev,
 412                                         struct cli_state *cli,
 413                                         const char *oldname,
 414                                         const char *newname)
 415 {
 416         return cli_posix_link_internal_send(
 417                 mem_ctx, ev, cli, SMB_SET_FILE_UNIX_HLINK, oldname, newname);
 418 }
 419
 420 NTSTATUS cli_posix_hardlink_recv(struct tevent_req *req)
 421 {
 422         return tevent_req_simple_recv_ntstatus(req);
 423 }
 424
 425 NTSTATUS cli_posix_hardlink(struct cli_state *cli,
 426                         const char *oldname,
 427                         const char *newname)
 428 {
 429         TALLOC_CTX *frame = talloc_stackframe();
 430         struct tevent_context *ev = NULL;
 431         struct tevent_req *req = NULL;
 432         NTSTATUS status = NT_STATUS_OK;
 433
 434         if (smbXcli_conn_has_async_calls(cli->conn)) {
 435                 /*
 436                  * Can't use sync call while an async call is in flight
 437                  */
 438                 status = NT_STATUS_INVALID_PARAMETER;
 439                 goto fail;
 440         }
 441
 442         ev = samba_tevent_context_init(frame);
 443         if (ev == NULL) {
 444                 status = NT_STATUS_NO_MEMORY;
 445                 goto fail;
 446         }
 447
 448         req = cli_posix_hardlink_send(frame,
 449                                 ev,
 450                                 cli,
 451                                 oldname,
 452                                 newname);
 453         if (req == NULL) {
 454                 status = NT_STATUS_NO_MEMORY;
 455                 goto fail;
 456         }
 457
 458         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 459                 goto fail;
 460         }
 461
 462         status = cli_posix_hardlink_recv(req);
 463
 464  fail:
 465         TALLOC_FREE(frame);
 466         return status;
 467 }
 468
 469 /****************************************************************************
 470  Do a POSIX getacl - pathname based ACL get (UNIX extensions).
 471 ****************************************************************************/
 472
 473 struct getacl_state {
 474         uint32_t num_data;
 475         uint8_t *data;
 476 };
 477
 478 static void cli_posix_getacl_done(struct tevent_req *subreq);
 479
 480 struct tevent_req *cli_posix_getacl_send(TALLOC_CTX *mem_ctx,
 481                                         struct tevent_context *ev,
 482                                         struct cli_state *cli,
 483                                         const char *fname)
 484 {
 485         struct tevent_req *req = NULL, *subreq = NULL;
 486         struct getacl_state *state = NULL;
 487
 488         req = tevent_req_create(mem_ctx, &state, struct getacl_state);
 489         if (req == NULL) {
 490                 return NULL;
 491         }
 492         subreq = cli_qpathinfo_send(state, ev, cli, fname, SMB_QUERY_POSIX_ACL,
 493                                     0, CLI_BUFFER_SIZE);
 494         if (tevent_req_nomem(subreq, req)) {
 495                 return tevent_req_post(req, ev);
 496         }
 497         tevent_req_set_callback(subreq, cli_posix_getacl_done, req);
 498         return req;
 499 }
 500
 501 static void cli_posix_getacl_done(struct tevent_req *subreq)
 502 {
 503         struct tevent_req *req = tevent_req_callback_data(
 504                 subreq, struct tevent_req);
 505         struct getacl_state *state = tevent_req_data(
 506                 req, struct getacl_state);
 507         NTSTATUS status;
 508
 509         status = cli_qpathinfo_recv(subreq, state, &state->data,
 510                                     &state->num_data);
 511         TALLOC_FREE(subreq);
 512         if (tevent_req_nterror(req, status)) {
 513                 return;
 514         }
 515         tevent_req_done(req);
 516 }
 517
 518 NTSTATUS cli_posix_getacl_recv(struct tevent_req *req,
 519                                 TALLOC_CTX *mem_ctx,
 520                                 size_t *prb_size,
 521                                 char **retbuf)
 522 {
 523         struct getacl_state *state = tevent_req_data(req, struct getacl_state);
 524         NTSTATUS status;
 525
 526         if (tevent_req_is_nterror(req, &status)) {
 527                 return status;
 528         }
 529         *prb_size = (size_t)state->num_data;
 530         *retbuf = (char *)talloc_move(mem_ctx, &state->data);
 531         return NT_STATUS_OK;
 532 }
 533
 534 NTSTATUS cli_posix_getacl(struct cli_state *cli,
 535                         const char *fname,
 536                         TALLOC_CTX *mem_ctx,
 537                         size_t *prb_size,
 538                         char **retbuf)
 539 {
 540         TALLOC_CTX *frame = talloc_stackframe();
 541         struct tevent_context *ev = NULL;
 542         struct tevent_req *req = NULL;
 543         NTSTATUS status = NT_STATUS_OK;
 544
 545         if (smbXcli_conn_has_async_calls(cli->conn)) {
 546                 /*
 547                  * Can't use sync call while an async call is in flight
 548                  */
 549                 status = NT_STATUS_INVALID_PARAMETER;
 550                 goto fail;
 551         }
 552
 553         ev = samba_tevent_context_init(frame);
 554         if (ev == NULL) {
 555                 status = NT_STATUS_NO_MEMORY;
 556                 goto fail;
 557         }
 558
 559         req = cli_posix_getacl_send(frame,
 560                                 ev,
 561                                 cli,
 562                                 fname);
 563         if (req == NULL) {
 564                 status = NT_STATUS_NO_MEMORY;
 565                 goto fail;
 566         }
 567
 568         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 569                 goto fail;
 570         }
 571
 572         status = cli_posix_getacl_recv(req, mem_ctx, prb_size, retbuf);
 573
 574  fail:
 575         TALLOC_FREE(frame);
 576         return status;
 577 }
 578
 579 /****************************************************************************
 580  Do a POSIX setacl - pathname based ACL set (UNIX extensions).
 581 ****************************************************************************/
 582
 583 struct setacl_state {
 584         uint8_t *data;
 585 };
 586
 587 static void cli_posix_setacl_done(struct tevent_req *subreq);
 588
 589 struct tevent_req *cli_posix_setacl_send(TALLOC_CTX *mem_ctx,
 590                                         struct tevent_context *ev,
 591                                         struct cli_state *cli,
 592                                         const char *fname,
 593                                         const void *data,
 594                                         size_t num_data)
 595 {
 596         struct tevent_req *req = NULL, *subreq = NULL;
 597         struct setacl_state *state = NULL;
 598
 599         req = tevent_req_create(mem_ctx, &state, struct setacl_state);
 600         if (req == NULL) {
 601                 return NULL;
 602         }
 603         state->data = talloc_memdup(state, data, num_data);
 604         if (tevent_req_nomem(state->data, req)) {
 605                 return tevent_req_post(req, ev);
 606         }
 607
 608         subreq = cli_setpathinfo_send(state,
 609                                 ev,
 610                                 cli,
 611                                 SMB_SET_POSIX_ACL,
 612                                 fname,
 613                                 state->data,
 614                                 num_data);
 615         if (tevent_req_nomem(subreq, req)) {
 616                 return tevent_req_post(req, ev);
 617         }
 618         tevent_req_set_callback(subreq, cli_posix_setacl_done, req);
 619         return req;
 620 }
 621
 622 static void cli_posix_setacl_done(struct tevent_req *subreq)
 623 {
 624         NTSTATUS status = cli_setpathinfo_recv(subreq);
 625         tevent_req_simple_finish_ntstatus(subreq, status);
 626 }
 627
 628 NTSTATUS cli_posix_setacl_recv(struct tevent_req *req)
 629 {
 630         return tevent_req_simple_recv_ntstatus(req);
 631 }
 632
 633 NTSTATUS cli_posix_setacl(struct cli_state *cli,
 634                         const char *fname,
 635                         const void *acl_buf,
 636                         size_t acl_buf_size)
 637 {
 638         TALLOC_CTX *frame = talloc_stackframe();
 639         struct tevent_context *ev = NULL;
 640         struct tevent_req *req = NULL;
 641         NTSTATUS status = NT_STATUS_OK;
 642
 643         if (smbXcli_conn_has_async_calls(cli->conn)) {
 644                 /*
 645                  * Can't use sync call while an async call is in flight
 646                  */
 647                 status = NT_STATUS_INVALID_PARAMETER;
 648                 goto fail;
 649         }
 650
 651         ev = samba_tevent_context_init(frame);
 652         if (ev == NULL) {
 653                 status = NT_STATUS_NO_MEMORY;
 654                 goto fail;
 655         }
 656
 657         req = cli_posix_setacl_send(frame,
 658                                 ev,
 659                                 cli,
 660                                 fname,
 661                                 acl_buf,
 662                                 acl_buf_size);
 663         if (req == NULL) {
 664                 status = NT_STATUS_NO_MEMORY;
 665                 goto fail;
 666         }
 667
 668         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 669                 goto fail;
 670         }
 671
 672         status = cli_posix_setacl_recv(req);
 673
 674  fail:
 675         TALLOC_FREE(frame);
 676         return status;
 677 }
 678
 679 /****************************************************************************
 680  Stat a file (UNIX extensions).
 681 ****************************************************************************/
 682
 683 struct stat_state {
 684         uint32_t num_data;
 685         uint8_t *data;
 686 };
 687
 688 static void cli_posix_stat_done(struct tevent_req *subreq);
 689
 690 struct tevent_req *cli_posix_stat_send(TALLOC_CTX *mem_ctx,
 691                                         struct tevent_context *ev,
 692                                         struct cli_state *cli,
 693                                         const char *fname)
 694 {
 695         struct tevent_req *req = NULL, *subreq = NULL;
 696         struct stat_state *state = NULL;
 697
 698         req = tevent_req_create(mem_ctx, &state, struct stat_state);
 699         if (req == NULL) {
 700                 return NULL;
 701         }
 702         subreq = cli_qpathinfo_send(state, ev, cli, fname,
 703                                     SMB_QUERY_FILE_UNIX_BASIC, 100, 100);
 704         if (tevent_req_nomem(subreq, req)) {
 705                 return tevent_req_post(req, ev);
 706         }
 707         tevent_req_set_callback(subreq, cli_posix_stat_done, req);
 708         return req;
 709 }
 710
 711 static void cli_posix_stat_done(struct tevent_req *subreq)
 712 {
 713         struct tevent_req *req = tevent_req_callback_data(
 714                                 subreq, struct tevent_req);
 715         struct stat_state *state = tevent_req_data(req, struct stat_state);
 716         NTSTATUS status;
 717
 718         status = cli_qpathinfo_recv(subreq, state, &state->data,
 719                                     &state->num_data);
 720         TALLOC_FREE(subreq);
 721         if (tevent_req_nterror(req, status)) {
 722                 return;
 723         }
 724         tevent_req_done(req);
 725 }
 726
 727 NTSTATUS cli_posix_stat_recv(struct tevent_req *req,
 728                                 SMB_STRUCT_STAT *sbuf)
 729 {
 730         struct stat_state *state = tevent_req_data(req, struct stat_state);
 731         NTSTATUS status;
 732
 733         if (tevent_req_is_nterror(req, &status)) {
 734                 return status;
 735         }
 736
 737         sbuf->st_ex_size = IVAL2_TO_SMB_BIG_UINT(state->data,0);     /* total size, in bytes */
 738         sbuf->st_ex_blocks = IVAL2_TO_SMB_BIG_UINT(state->data,8);   /* number of blocks allocated */
 739 #if defined (HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
 740         sbuf->st_ex_blocks /= STAT_ST_BLOCKSIZE;
 741 #else
 742         /* assume 512 byte blocks */
 743         sbuf->st_ex_blocks /= 512;
 744 #endif
 745         sbuf->st_ex_ctime = interpret_long_date((char *)(state->data + 16));    /* time of last change */
 746         sbuf->st_ex_atime = interpret_long_date((char *)(state->data + 24));    /* time of last access */
 747         sbuf->st_ex_mtime = interpret_long_date((char *)(state->data + 32));    /* time of last modification */
 748
 749         sbuf->st_ex_uid = (uid_t) IVAL(state->data,40);      /* user ID of owner */
 750         sbuf->st_ex_gid = (gid_t) IVAL(state->data,48);      /* group ID of owner */
 751         sbuf->st_ex_mode = unix_filetype_from_wire(IVAL(state->data, 56));
 752 #if defined(HAVE_MAKEDEV)
 753         {
 754                 uint32_t dev_major = IVAL(state->data,60);
 755                 uint32_t dev_minor = IVAL(state->data,68);
 756                 sbuf->st_ex_rdev = makedev(dev_major, dev_minor);
 757         }
 758 #endif
 759         sbuf->st_ex_ino = (SMB_INO_T)IVAL2_TO_SMB_BIG_UINT(state->data,76);      /* inode */
 760         sbuf->st_ex_mode |= wire_perms_to_unix(IVAL(state->data,84));     /* protection */
 761         sbuf->st_ex_nlink = BIG_UINT(state->data,92); /* number of hard links */
 762
 763         return NT_STATUS_OK;
 764 }
 765
 766 NTSTATUS cli_posix_stat(struct cli_state *cli,
 767                         const char *fname,
 768                         SMB_STRUCT_STAT *sbuf)
 769 {
 770         TALLOC_CTX *frame = talloc_stackframe();
 771         struct tevent_context *ev = NULL;
 772         struct tevent_req *req = NULL;
 773         NTSTATUS status = NT_STATUS_OK;
 774
 775         if (smbXcli_conn_has_async_calls(cli->conn)) {
 776                 /*
 777                  * Can't use sync call while an async call is in flight
 778                  */
 779                 status = NT_STATUS_INVALID_PARAMETER;
 780                 goto fail;
 781         }
 782
 783         ev = samba_tevent_context_init(frame);
 784         if (ev == NULL) {
 785                 status = NT_STATUS_NO_MEMORY;
 786                 goto fail;
 787         }
 788
 789         req = cli_posix_stat_send(frame,
 790                                 ev,
 791                                 cli,
 792                                 fname);
 793         if (req == NULL) {
 794                 status = NT_STATUS_NO_MEMORY;
 795                 goto fail;
 796         }
 797
 798         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 799                 goto fail;
 800         }
 801
 802         status = cli_posix_stat_recv(req, sbuf);
 803
 804  fail:
 805         TALLOC_FREE(frame);
 806         return status;
 807 }
 808
 809 /****************************************************************************
 810  Chmod or chown a file internal (UNIX extensions).
 811 ****************************************************************************/
 812
 813 struct cli_posix_chown_chmod_internal_state {
 814         uint8_t data[100];
 815 };
 816
 817 static void cli_posix_chown_chmod_internal_done(struct tevent_req *subreq);
 818
 819 static struct tevent_req *cli_posix_chown_chmod_internal_send(TALLOC_CTX *mem_ctx,
 820                                         struct tevent_context *ev,
 821                                         struct cli_state *cli,
 822                                         const char *fname,
 823                                         uint32_t mode,
 824                                         uint32_t uid,
 825                                         uint32_t gid)
 826 {
 827         struct tevent_req *req = NULL, *subreq = NULL;
 828         struct cli_posix_chown_chmod_internal_state *state = NULL;
 829
 830         req = tevent_req_create(mem_ctx, &state,
 831                                 struct cli_posix_chown_chmod_internal_state);
 832         if (req == NULL) {
 833                 return NULL;
 834         }
 835
 836         memset(state->data, 0xff, 40); /* Set all sizes/times to no change. */
 837         memset(&state->data[40], '\0', 60);
 838         SIVAL(state->data,40,uid);
 839         SIVAL(state->data,48,gid);
 840         SIVAL(state->data,84,mode);
 841
 842         subreq = cli_setpathinfo_send(state, ev, cli, SMB_SET_FILE_UNIX_BASIC,
 843                                       fname, state->data, sizeof(state->data));
 844         if (tevent_req_nomem(subreq, req)) {
 845                 return tevent_req_post(req, ev);
 846         }
 847         tevent_req_set_callback(subreq, cli_posix_chown_chmod_internal_done,
 848                                 req);
 849         return req;
 850 }
 851
 852 static void cli_posix_chown_chmod_internal_done(struct tevent_req *subreq)
 853 {
 854         NTSTATUS status = cli_setpathinfo_recv(subreq);
 855         tevent_req_simple_finish_ntstatus(subreq, status);
 856 }
 857
 858 /****************************************************************************
 859  chmod a file (UNIX extensions).
 860 ****************************************************************************/
 861
 862 struct tevent_req *cli_posix_chmod_send(TALLOC_CTX *mem_ctx,
 863                                         struct tevent_context *ev,
 864                                         struct cli_state *cli,
 865                                         const char *fname,
 866                                         mode_t mode)
 867 {
 868         return cli_posix_chown_chmod_internal_send(mem_ctx, ev, cli,
 869                         fname,
 870                         unix_perms_to_wire(mode),
 871                         SMB_UID_NO_CHANGE,
 872                         SMB_GID_NO_CHANGE);
 873 }
 874
 875 NTSTATUS cli_posix_chmod_recv(struct tevent_req *req)
 876 {
 877         return tevent_req_simple_recv_ntstatus(req);
 878 }
 879
 880 NTSTATUS cli_posix_chmod(struct cli_state *cli, const char *fname, mode_t mode)
 881 {
 882         TALLOC_CTX *frame = talloc_stackframe();
 883         struct tevent_context *ev = NULL;
 884         struct tevent_req *req = NULL;
 885         NTSTATUS status = NT_STATUS_OK;
 886
 887         if (smbXcli_conn_has_async_calls(cli->conn)) {
 888                 /*
 889                  * Can't use sync call while an async call is in flight
 890                  */
 891                 status = NT_STATUS_INVALID_PARAMETER;
 892                 goto fail;
 893         }
 894
 895         ev = samba_tevent_context_init(frame);
 896         if (ev == NULL) {
 897                 status = NT_STATUS_NO_MEMORY;
 898                 goto fail;
 899         }
 900
 901         req = cli_posix_chmod_send(frame,
 902                                 ev,
 903                                 cli,
 904                                 fname,
 905                                 mode);
 906         if (req == NULL) {
 907                 status = NT_STATUS_NO_MEMORY;
 908                 goto fail;
 909         }
 910
 911         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 912                 goto fail;
 913         }
 914
 915         status = cli_posix_chmod_recv(req);
 916
 917  fail:
 918         TALLOC_FREE(frame);
 919         return status;
 920 }
 921
 922 /****************************************************************************
 923  chown a file (UNIX extensions).
 924 ****************************************************************************/
 925
 926 struct tevent_req *cli_posix_chown_send(TALLOC_CTX *mem_ctx,
 927                                         struct tevent_context *ev,
 928                                         struct cli_state *cli,
 929                                         const char *fname,
 930                                         uid_t uid,
 931                                         gid_t gid)
 932 {
 933         return cli_posix_chown_chmod_internal_send(mem_ctx, ev, cli,
 934                         fname,
 935                         SMB_MODE_NO_CHANGE,
 936                         (uint32_t)uid,
 937                         (uint32_t)gid);
 938 }
 939
 940 NTSTATUS cli_posix_chown_recv(struct tevent_req *req)
 941 {
 942         return tevent_req_simple_recv_ntstatus(req);
 943 }
 944
 945 NTSTATUS cli_posix_chown(struct cli_state *cli,
 946                         const char *fname,
 947                         uid_t uid,
 948                         gid_t gid)
 949 {
 950         TALLOC_CTX *frame = talloc_stackframe();
 951         struct tevent_context *ev = NULL;
 952         struct tevent_req *req = NULL;
 953         NTSTATUS status = NT_STATUS_OK;
 954
 955         if (smbXcli_conn_has_async_calls(cli->conn)) {
 956                 /*
 957                  * Can't use sync call while an async call is in flight
 958                  */
 959                 status = NT_STATUS_INVALID_PARAMETER;
 960                 goto fail;
 961         }
 962
 963         ev = samba_tevent_context_init(frame);
 964         if (ev == NULL) {
 965                 status = NT_STATUS_NO_MEMORY;
 966                 goto fail;
 967         }
 968
 969         req = cli_posix_chown_send(frame,
 970                                 ev,
 971                                 cli,
 972                                 fname,
 973                                 uid,
 974                                 gid);
 975         if (req == NULL) {
 976                 status = NT_STATUS_NO_MEMORY;
 977                 goto fail;
 978         }
 979
 980         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 981                 goto fail;
 982         }
 983
 984         status = cli_posix_chown_recv(req);
 985
 986  fail:
 987         TALLOC_FREE(frame);
 988         return status;
 989 }
 990
 991 /****************************************************************************
 992  Rename a file.
 993 ****************************************************************************/
 994
 995 static struct tevent_req *cli_cifs_rename_send(TALLOC_CTX *mem_ctx,
 996                                                struct tevent_context *ev,
 997                                                struct cli_state *cli,
 998                                                const char *fname_src,
 999                                                const char *fname_dst,
1000                                                bool replace);
1001
1002 static struct tevent_req *cli_smb1_rename_send(TALLOC_CTX *mem_ctx,
1003                                                struct tevent_context *ev,
1004                                                struct cli_state *cli,
1005                                                const char *fname_src,
1006                                                const char *fname_dst,
1007                                                bool replace);
1008
1009 struct tevent_req *cli_rename_send(TALLOC_CTX *mem_ctx,
1010                                    struct tevent_context *ev,
1011                                    struct cli_state *cli,
1012                                    const char *fname_src,
1013                                    const char *fname_dst,
1014                                    bool replace)
1015 {
1016         if (replace && smbXcli_conn_support_passthrough(cli->conn)) {
1017                 return cli_smb1_rename_send(mem_ctx, ev, cli, fname_src,
1018                                             fname_dst, replace);
1019         } else {
1020                 return cli_cifs_rename_send(mem_ctx, ev, cli, fname_src,
1021                                             fname_dst, replace);
1022         }
1023 }
1024
1025 struct cli_smb1_rename_state {
1026         uint8_t *data;
1027 };
1028
1029 static void cli_smb1_rename_done(struct tevent_req *subreq);
1030
1031 static struct tevent_req *cli_smb1_rename_send(TALLOC_CTX *mem_ctx,
1032                                                struct tevent_context *ev,
1033                                                struct cli_state *cli,
1034                                                const char *fname_src,
1035                                                const char *fname_dst,
1036                                                bool replace)
1037 {
1038         NTSTATUS status;
1039         struct tevent_req *req = NULL, *subreq = NULL;
1040         struct cli_smb1_rename_state *state = NULL;
1041         smb_ucs2_t *converted_str = NULL;
1042         size_t converted_size_bytes = 0;
1043
1044         req = tevent_req_create(mem_ctx, &state, struct cli_smb1_rename_state);
1045         if (req == NULL) {
1046                 return NULL;
1047         }
1048
1049         if (!push_ucs2_talloc(talloc_tos(), &converted_str, fname_dst,
1050                               &converted_size_bytes)) {
1051                 status = NT_STATUS_INVALID_PARAMETER;
1052                 goto fail;
1053         }
1054
1055         /* W2K8 insists the dest name is not null
1056            terminated. Remove the last 2 zero bytes
1057            and reduce the name length. */
1058
1059         if (converted_size_bytes < 2) {
1060                 status = NT_STATUS_INVALID_PARAMETER;
1061                 goto fail;
1062         }
1063         converted_size_bytes -= 2;
1064
1065         state->data =
1066             talloc_zero_array(state, uint8_t, 12 + converted_size_bytes);
1067         if (state->data == NULL) {
1068                 status = NT_STATUS_NO_MEMORY;
1069                 goto fail;
1070         }
1071
1072         if (replace) {
1073                 SCVAL(state->data, 0, 1);
1074         }
1075
1076         SIVAL(state->data, 8, converted_size_bytes);
1077         memcpy(state->data + 12, converted_str, converted_size_bytes);
1078
1079         TALLOC_FREE(converted_str);
1080
1081         subreq = cli_setpathinfo_send(
1082             state, ev, cli, SMB_FILE_RENAME_INFORMATION, fname_src, state->data,
1083             talloc_get_size(state->data));
1084         if (tevent_req_nomem(subreq, req)) {
1085                 status = NT_STATUS_NO_MEMORY;
1086                 goto fail;
1087         }
1088         tevent_req_set_callback(subreq, cli_smb1_rename_done, req);
1089         return req;
1090
1091 fail:
1092         TALLOC_FREE(converted_str);
1093         tevent_req_nterror(req, status);
1094         return tevent_req_post(req, ev);
1095 }
1096
1097 static void cli_smb1_rename_done(struct tevent_req *subreq)
1098 {
1099         NTSTATUS status = cli_setpathinfo_recv(subreq);
1100         tevent_req_simple_finish_ntstatus(subreq, status);
1101 }
1102
1103 static void cli_cifs_rename_done(struct tevent_req *subreq);
1104
1105 struct cli_cifs_rename_state {
1106         uint16_t vwv[1];
1107 };
1108
1109 static struct tevent_req *cli_cifs_rename_send(TALLOC_CTX *mem_ctx,
1110                                                struct tevent_context *ev,
1111                                                struct cli_state *cli,
1112                                                const char *fname_src,
1113                                                const char *fname_dst,
1114                                                bool replace)
1115 {
1116         struct tevent_req *req = NULL, *subreq = NULL;
1117         struct cli_cifs_rename_state *state = NULL;
1118         uint8_t additional_flags = 0;
1119         uint16_t additional_flags2 = 0;
1120         uint8_t *bytes = NULL;
1121
1122         req = tevent_req_create(mem_ctx, &state, struct cli_cifs_rename_state);
1123         if (req == NULL) {
1124                 return NULL;
1125         }
1126
1127         if (replace) {
1128                 /*
1129                  * CIFS doesn't support replace
1130                  */
1131                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
1132                 return tevent_req_post(req, ev);
1133         }
1134
1135         SSVAL(state->vwv+0, 0, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY);
1136
1137         bytes = talloc_array(state, uint8_t, 1);
1138         if (tevent_req_nomem(bytes, req)) {
1139                 return tevent_req_post(req, ev);
1140         }
1141         bytes[0] = 4;
1142         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), fname_src,
1143                                    strlen(fname_src)+1, NULL);
1144         if (tevent_req_nomem(bytes, req)) {
1145                 return tevent_req_post(req, ev);
1146         }
1147
1148         if (clistr_is_previous_version_path(fname_src, NULL, NULL, NULL)) {
1149                 additional_flags2 = FLAGS2_REPARSE_PATH;
1150         }
1151
1152         bytes = talloc_realloc(state, bytes, uint8_t,
1153                         talloc_get_size(bytes)+1);
1154         if (tevent_req_nomem(bytes, req)) {
1155                 return tevent_req_post(req, ev);
1156         }
1157
1158         bytes[talloc_get_size(bytes)-1] = 4;
1159         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), fname_dst,
1160                                    strlen(fname_dst)+1, NULL);
1161         if (tevent_req_nomem(bytes, req)) {
1162                 return tevent_req_post(req, ev);
1163         }
1164
1165         subreq = cli_smb_send(state, ev, cli, SMBmv, additional_flags,
1166                         additional_flags2,
1167                         1, state->vwv, talloc_get_size(bytes), bytes);
1168         if (tevent_req_nomem(subreq, req)) {
1169                 return tevent_req_post(req, ev);
1170         }
1171         tevent_req_set_callback(subreq, cli_cifs_rename_done, req);
1172         return req;
1173 }
1174
1175 static void cli_cifs_rename_done(struct tevent_req *subreq)
1176 {
1177         struct tevent_req *req = tevent_req_callback_data(
1178                                 subreq, struct tevent_req);
1179         NTSTATUS status;
1180
1181         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
1182         TALLOC_FREE(subreq);
1183         if (tevent_req_nterror(req, status)) {
1184                 return;
1185         }
1186         tevent_req_done(req);
1187 }
1188
1189 NTSTATUS cli_rename_recv(struct tevent_req *req)
1190 {
1191         return tevent_req_simple_recv_ntstatus(req);
1192 }
1193
1194 NTSTATUS cli_rename(struct cli_state *cli,
1195                     const char *fname_src,
1196                     const char *fname_dst,
1197                     bool replace)
1198 {
1199         TALLOC_CTX *frame = NULL;
1200         struct tevent_context *ev;
1201         struct tevent_req *req;
1202         NTSTATUS status = NT_STATUS_OK;
1203
1204         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1205                 return cli_smb2_rename(cli, fname_src, fname_dst, replace);
1206         }
1207
1208         frame = talloc_stackframe();
1209
1210         if (smbXcli_conn_has_async_calls(cli->conn)) {
1211                 /*
1212                  * Can't use sync call while an async call is in flight
1213                  */
1214                 status = NT_STATUS_INVALID_PARAMETER;
1215                 goto fail;
1216         }
1217
1218         ev = samba_tevent_context_init(frame);
1219         if (ev == NULL) {
1220                 status = NT_STATUS_NO_MEMORY;
1221                 goto fail;
1222         }
1223
1224         req = cli_rename_send(frame, ev, cli, fname_src, fname_dst, replace);
1225         if (req == NULL) {
1226                 status = NT_STATUS_NO_MEMORY;
1227                 goto fail;
1228         }
1229
1230         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1231                 goto fail;
1232         }
1233
1234         status = cli_rename_recv(req);
1235
1236  fail:
1237         TALLOC_FREE(frame);
1238         return status;
1239 }
1240
1241 /****************************************************************************
1242  NT Rename a file.
1243 ****************************************************************************/
1244
1245 static void cli_ntrename_internal_done(struct tevent_req *subreq);
1246
1247 struct cli_ntrename_internal_state {
1248         uint16_t vwv[4];
1249 };
1250
1251 static struct tevent_req *cli_ntrename_internal_send(TALLOC_CTX *mem_ctx,
1252                                 struct tevent_context *ev,
1253                                 struct cli_state *cli,
1254                                 const char *fname_src,
1255                                 const char *fname_dst,
1256                                 uint16_t rename_flag)
1257 {
1258         struct tevent_req *req = NULL, *subreq = NULL;
1259         struct cli_ntrename_internal_state *state = NULL;
1260         uint8_t additional_flags = 0;
1261         uint16_t additional_flags2 = 0;
1262         uint8_t *bytes = NULL;
1263
1264         req = tevent_req_create(mem_ctx, &state,
1265                                 struct cli_ntrename_internal_state);
1266         if (req == NULL) {
1267                 return NULL;
1268         }
1269
1270         SSVAL(state->vwv+0, 0 ,FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY);
1271         SSVAL(state->vwv+1, 0, rename_flag);
1272
1273         bytes = talloc_array(state, uint8_t, 1);
1274         if (tevent_req_nomem(bytes, req)) {
1275                 return tevent_req_post(req, ev);
1276         }
1277         bytes[0] = 4;
1278         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), fname_src,
1279                                    strlen(fname_src)+1, NULL);
1280         if (tevent_req_nomem(bytes, req)) {
1281                 return tevent_req_post(req, ev);
1282         }
1283
1284         if (clistr_is_previous_version_path(fname_src, NULL, NULL, NULL)) {
1285                 additional_flags2 = FLAGS2_REPARSE_PATH;
1286         }
1287
1288         bytes = talloc_realloc(state, bytes, uint8_t,
1289                         talloc_get_size(bytes)+1);
1290         if (tevent_req_nomem(bytes, req)) {
1291                 return tevent_req_post(req, ev);
1292         }
1293
1294         bytes[talloc_get_size(bytes)-1] = 4;
1295         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), fname_dst,
1296                                    strlen(fname_dst)+1, NULL);
1297         if (tevent_req_nomem(bytes, req)) {
1298                 return tevent_req_post(req, ev);
1299         }
1300
1301         subreq = cli_smb_send(state, ev, cli, SMBntrename, additional_flags,
1302                         additional_flags2,
1303                         4, state->vwv, talloc_get_size(bytes), bytes);
1304         if (tevent_req_nomem(subreq, req)) {
1305                 return tevent_req_post(req, ev);
1306         }
1307         tevent_req_set_callback(subreq, cli_ntrename_internal_done, req);
1308         return req;
1309 }
1310
1311 static void cli_ntrename_internal_done(struct tevent_req *subreq)
1312 {
1313         struct tevent_req *req = tevent_req_callback_data(
1314                                 subreq, struct tevent_req);
1315         NTSTATUS status;
1316
1317         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
1318         TALLOC_FREE(subreq);
1319         if (tevent_req_nterror(req, status)) {
1320                 return;
1321         }
1322         tevent_req_done(req);
1323 }
1324
1325 static NTSTATUS cli_ntrename_internal_recv(struct tevent_req *req)
1326 {
1327         return tevent_req_simple_recv_ntstatus(req);
1328 }
1329
1330 struct tevent_req *cli_ntrename_send(TALLOC_CTX *mem_ctx,
1331                                 struct tevent_context *ev,
1332                                 struct cli_state *cli,
1333                                 const char *fname_src,
1334                                 const char *fname_dst)
1335 {
1336         return cli_ntrename_internal_send(mem_ctx,
1337                                           ev,
1338                                           cli,
1339                                           fname_src,
1340                                           fname_dst,
1341                                           RENAME_FLAG_RENAME);
1342 }
1343
1344 NTSTATUS cli_ntrename_recv(struct tevent_req *req)
1345 {
1346         return cli_ntrename_internal_recv(req);
1347 }
1348
1349 NTSTATUS cli_ntrename(struct cli_state *cli, const char *fname_src, const char *fname_dst)
1350 {
1351         TALLOC_CTX *frame = talloc_stackframe();
1352         struct tevent_context *ev;
1353         struct tevent_req *req;
1354         NTSTATUS status = NT_STATUS_OK;
1355
1356         if (smbXcli_conn_has_async_calls(cli->conn)) {
1357                 /*
1358                  * Can't use sync call while an async call is in flight
1359                  */
1360                 status = NT_STATUS_INVALID_PARAMETER;
1361                 goto fail;
1362         }
1363
1364         ev = samba_tevent_context_init(frame);
1365         if (ev == NULL) {
1366                 status = NT_STATUS_NO_MEMORY;
1367                 goto fail;
1368         }
1369
1370         req = cli_ntrename_send(frame, ev, cli, fname_src, fname_dst);
1371         if (req == NULL) {
1372                 status = NT_STATUS_NO_MEMORY;
1373                 goto fail;
1374         }
1375
1376         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1377                 goto fail;
1378         }
1379
1380         status = cli_ntrename_recv(req);
1381
1382  fail:
1383         TALLOC_FREE(frame);
1384         return status;
1385 }
1386
1387 /****************************************************************************
1388  NT hardlink a file.
1389 ****************************************************************************/
1390
1391 struct tevent_req *cli_nt_hardlink_send(TALLOC_CTX *mem_ctx,
1392                                 struct tevent_context *ev,
1393                                 struct cli_state *cli,
1394                                 const char *fname_src,
1395                                 const char *fname_dst)
1396 {
1397         return cli_ntrename_internal_send(mem_ctx,
1398                                           ev,
1399                                           cli,
1400                                           fname_src,
1401                                           fname_dst,
1402                                           RENAME_FLAG_HARD_LINK);
1403 }
1404
1405 NTSTATUS cli_nt_hardlink_recv(struct tevent_req *req)
1406 {
1407         return cli_ntrename_internal_recv(req);
1408 }
1409
1410 NTSTATUS cli_nt_hardlink(struct cli_state *cli, const char *fname_src, const char *fname_dst)
1411 {
1412         TALLOC_CTX *frame = talloc_stackframe();
1413         struct tevent_context *ev;
1414         struct tevent_req *req;
1415         NTSTATUS status = NT_STATUS_OK;
1416
1417         if (smbXcli_conn_has_async_calls(cli->conn)) {
1418                 /*
1419                  * Can't use sync call while an async call is in flight
1420                  */
1421                 status = NT_STATUS_INVALID_PARAMETER;
1422                 goto fail;
1423         }
1424
1425         ev = samba_tevent_context_init(frame);
1426         if (ev == NULL) {
1427                 status = NT_STATUS_NO_MEMORY;
1428                 goto fail;
1429         }
1430
1431         req = cli_nt_hardlink_send(frame, ev, cli, fname_src, fname_dst);
1432         if (req == NULL) {
1433                 status = NT_STATUS_NO_MEMORY;
1434                 goto fail;
1435         }
1436
1437         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1438                 goto fail;
1439         }
1440
1441         status = cli_nt_hardlink_recv(req);
1442
1443  fail:
1444         TALLOC_FREE(frame);
1445         return status;
1446 }
1447
1448 /****************************************************************************
1449  Delete a file.
1450 ****************************************************************************/
1451
1452 static void cli_unlink_done(struct tevent_req *subreq);
1453
1454 struct cli_unlink_state {
1455         uint16_t vwv[1];
1456 };
1457
1458 struct tevent_req *cli_unlink_send(TALLOC_CTX *mem_ctx,
1459                                 struct tevent_context *ev,
1460                                 struct cli_state *cli,
1461                                 const char *fname,
1462                                 uint16_t mayhave_attrs)
1463 {
1464         struct tevent_req *req = NULL, *subreq = NULL;
1465         struct cli_unlink_state *state = NULL;
1466         uint8_t additional_flags = 0;
1467         uint16_t additional_flags2 = 0;
1468         uint8_t *bytes = NULL;
1469
1470         req = tevent_req_create(mem_ctx, &state, struct cli_unlink_state);
1471         if (req == NULL) {
1472                 return NULL;
1473         }
1474
1475         SSVAL(state->vwv+0, 0, mayhave_attrs);
1476
1477         bytes = talloc_array(state, uint8_t, 1);
1478         if (tevent_req_nomem(bytes, req)) {
1479                 return tevent_req_post(req, ev);
1480         }
1481         bytes[0] = 4;
1482         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), fname,
1483                                    strlen(fname)+1, NULL);
1484
1485         if (tevent_req_nomem(bytes, req)) {
1486                 return tevent_req_post(req, ev);
1487         }
1488
1489         if (clistr_is_previous_version_path(fname, NULL, NULL, NULL)) {
1490                 additional_flags2 = FLAGS2_REPARSE_PATH;
1491         }
1492
1493         subreq = cli_smb_send(state, ev, cli, SMBunlink, additional_flags,
1494                                 additional_flags2,
1495                                 1, state->vwv, talloc_get_size(bytes), bytes);
1496         if (tevent_req_nomem(subreq, req)) {
1497                 return tevent_req_post(req, ev);
1498         }
1499         tevent_req_set_callback(subreq, cli_unlink_done, req);
1500         return req;
1501 }
1502
1503 static void cli_unlink_done(struct tevent_req *subreq)
1504 {
1505         struct tevent_req *req = tevent_req_callback_data(
1506                 subreq, struct tevent_req);
1507         NTSTATUS status;
1508
1509         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
1510         TALLOC_FREE(subreq);
1511         if (tevent_req_nterror(req, status)) {
1512                 return;
1513         }
1514         tevent_req_done(req);
1515 }
1516
1517 NTSTATUS cli_unlink_recv(struct tevent_req *req)
1518 {
1519         return tevent_req_simple_recv_ntstatus(req);
1520 }
1521
1522 NTSTATUS cli_unlink(struct cli_state *cli, const char *fname, uint16_t mayhave_attrs)
1523 {
1524         TALLOC_CTX *frame = NULL;
1525         struct tevent_context *ev;
1526         struct tevent_req *req;
1527         NTSTATUS status = NT_STATUS_OK;
1528
1529         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1530                 return cli_smb2_unlink(cli, fname);
1531         }
1532
1533         frame = talloc_stackframe();
1534
1535         if (smbXcli_conn_has_async_calls(cli->conn)) {
1536                 /*
1537                  * Can't use sync call while an async call is in flight
1538                  */
1539                 status = NT_STATUS_INVALID_PARAMETER;
1540                 goto fail;
1541         }
1542
1543         ev = samba_tevent_context_init(frame);
1544         if (ev == NULL) {
1545                 status = NT_STATUS_NO_MEMORY;
1546                 goto fail;
1547         }
1548
1549         req = cli_unlink_send(frame, ev, cli, fname, mayhave_attrs);
1550         if (req == NULL) {
1551                 status = NT_STATUS_NO_MEMORY;
1552                 goto fail;
1553         }
1554
1555         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1556                 goto fail;
1557         }
1558
1559         status = cli_unlink_recv(req);
1560
1561  fail:
1562         TALLOC_FREE(frame);
1563         return status;
1564 }
1565
1566 /****************************************************************************
1567  Create a directory.
1568 ****************************************************************************/
1569
1570 static void cli_mkdir_done(struct tevent_req *subreq);
1571
1572 struct cli_mkdir_state {
1573         int dummy;
1574 };
1575
1576 struct tevent_req *cli_mkdir_send(TALLOC_CTX *mem_ctx,
1577                                   struct tevent_context *ev,
1578                                   struct cli_state *cli,
1579                                   const char *dname)
1580 {
1581         struct tevent_req *req = NULL, *subreq = NULL;
1582         struct cli_mkdir_state *state = NULL;
1583         uint8_t additional_flags = 0;
1584         uint16_t additional_flags2 = 0;
1585         uint8_t *bytes = NULL;
1586
1587         req = tevent_req_create(mem_ctx, &state, struct cli_mkdir_state);
1588         if (req == NULL) {
1589                 return NULL;
1590         }
1591
1592         bytes = talloc_array(state, uint8_t, 1);
1593         if (tevent_req_nomem(bytes, req)) {
1594                 return tevent_req_post(req, ev);
1595         }
1596         bytes[0] = 4;
1597         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), dname,
1598                                    strlen(dname)+1, NULL);
1599
1600         if (tevent_req_nomem(bytes, req)) {
1601                 return tevent_req_post(req, ev);
1602         }
1603
1604         if (clistr_is_previous_version_path(dname, NULL, NULL, NULL)) {
1605                 additional_flags2 = FLAGS2_REPARSE_PATH;
1606         }
1607
1608         subreq = cli_smb_send(state, ev, cli, SMBmkdir, additional_flags,
1609                         additional_flags2,
1610                         0, NULL, talloc_get_size(bytes), bytes);
1611         if (tevent_req_nomem(subreq, req)) {
1612                 return tevent_req_post(req, ev);
1613         }
1614         tevent_req_set_callback(subreq, cli_mkdir_done, req);
1615         return req;
1616 }
1617
1618 static void cli_mkdir_done(struct tevent_req *subreq)
1619 {
1620         struct tevent_req *req = tevent_req_callback_data(
1621                 subreq, struct tevent_req);
1622         NTSTATUS status;
1623
1624         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
1625         TALLOC_FREE(subreq);
1626         if (tevent_req_nterror(req, status)) {
1627                 return;
1628         }
1629         tevent_req_done(req);
1630 }
1631
1632 NTSTATUS cli_mkdir_recv(struct tevent_req *req)
1633 {
1634         return tevent_req_simple_recv_ntstatus(req);
1635 }
1636
1637 NTSTATUS cli_mkdir(struct cli_state *cli, const char *dname)
1638 {
1639         TALLOC_CTX *frame = NULL;
1640         struct tevent_context *ev;
1641         struct tevent_req *req;
1642         NTSTATUS status = NT_STATUS_OK;
1643
1644         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1645                 return cli_smb2_mkdir(cli, dname);
1646         }
1647
1648         frame = talloc_stackframe();
1649
1650         if (smbXcli_conn_has_async_calls(cli->conn)) {
1651                 /*
1652                  * Can't use sync call while an async call is in flight
1653                  */
1654                 status = NT_STATUS_INVALID_PARAMETER;
1655                 goto fail;
1656         }
1657
1658         ev = samba_tevent_context_init(frame);
1659         if (ev == NULL) {
1660                 status = NT_STATUS_NO_MEMORY;
1661                 goto fail;
1662         }
1663
1664         req = cli_mkdir_send(frame, ev, cli, dname);
1665         if (req == NULL) {
1666                 status = NT_STATUS_NO_MEMORY;
1667                 goto fail;
1668         }
1669
1670         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1671                 goto fail;
1672         }
1673
1674         status = cli_mkdir_recv(req);
1675
1676  fail:
1677         TALLOC_FREE(frame);
1678         return status;
1679 }
1680
1681 /****************************************************************************
1682  Remove a directory.
1683 ****************************************************************************/
1684
1685 static void cli_rmdir_done(struct tevent_req *subreq);
1686
1687 struct cli_rmdir_state {
1688         int dummy;
1689 };
1690
1691 struct tevent_req *cli_rmdir_send(TALLOC_CTX *mem_ctx,
1692                                   struct tevent_context *ev,
1693                                   struct cli_state *cli,
1694                                   const char *dname)
1695 {
1696         struct tevent_req *req = NULL, *subreq = NULL;
1697         struct cli_rmdir_state *state = NULL;
1698         uint8_t additional_flags = 0;
1699         uint16_t additional_flags2 = 0;
1700         uint8_t *bytes = NULL;
1701
1702         req = tevent_req_create(mem_ctx, &state, struct cli_rmdir_state);
1703         if (req == NULL) {
1704                 return NULL;
1705         }
1706
1707         bytes = talloc_array(state, uint8_t, 1);
1708         if (tevent_req_nomem(bytes, req)) {
1709                 return tevent_req_post(req, ev);
1710         }
1711         bytes[0] = 4;
1712         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), dname,
1713                                    strlen(dname)+1, NULL);
1714
1715         if (tevent_req_nomem(bytes, req)) {
1716                 return tevent_req_post(req, ev);
1717         }
1718
1719         if (clistr_is_previous_version_path(dname, NULL, NULL, NULL)) {
1720                 additional_flags2 = FLAGS2_REPARSE_PATH;
1721         }
1722
1723         subreq = cli_smb_send(state, ev, cli, SMBrmdir, additional_flags,
1724                         additional_flags2,
1725                         0, NULL, talloc_get_size(bytes), bytes);
1726         if (tevent_req_nomem(subreq, req)) {
1727                 return tevent_req_post(req, ev);
1728         }
1729         tevent_req_set_callback(subreq, cli_rmdir_done, req);
1730         return req;
1731 }
1732
1733 static void cli_rmdir_done(struct tevent_req *subreq)
1734 {
1735         struct tevent_req *req = tevent_req_callback_data(
1736                 subreq, struct tevent_req);
1737         NTSTATUS status;
1738
1739         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
1740         TALLOC_FREE(subreq);
1741         if (tevent_req_nterror(req, status)) {
1742                 return;
1743         }
1744         tevent_req_done(req);
1745 }
1746
1747 NTSTATUS cli_rmdir_recv(struct tevent_req *req)
1748 {
1749         return tevent_req_simple_recv_ntstatus(req);
1750 }
1751
1752 NTSTATUS cli_rmdir(struct cli_state *cli, const char *dname)
1753 {
1754         TALLOC_CTX *frame = NULL;
1755         struct tevent_context *ev;
1756         struct tevent_req *req;
1757         NTSTATUS status = NT_STATUS_OK;
1758
1759         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1760                 return cli_smb2_rmdir(cli, dname);
1761         }
1762
1763         frame = talloc_stackframe();
1764
1765         if (smbXcli_conn_has_async_calls(cli->conn)) {
1766                 /*
1767                  * Can't use sync call while an async call is in flight
1768                  */
1769                 status = NT_STATUS_INVALID_PARAMETER;
1770                 goto fail;
1771         }
1772
1773         ev = samba_tevent_context_init(frame);
1774         if (ev == NULL) {
1775                 status = NT_STATUS_NO_MEMORY;
1776                 goto fail;
1777         }
1778
1779         req = cli_rmdir_send(frame, ev, cli, dname);
1780         if (req == NULL) {
1781                 status = NT_STATUS_NO_MEMORY;
1782                 goto fail;
1783         }
1784
1785         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1786                 goto fail;
1787         }
1788
1789         status = cli_rmdir_recv(req);
1790
1791  fail:
1792         TALLOC_FREE(frame);
1793         return status;
1794 }
1795
1796 /****************************************************************************
1797  Set or clear the delete on close flag.
1798 ****************************************************************************/
1799
1800 struct doc_state {
1801         uint16_t setup;
1802         uint8_t param[6];
1803         uint8_t data[1];
1804 };
1805
1806 static void cli_nt_delete_on_close_smb1_done(struct tevent_req *subreq);
1807 static void cli_nt_delete_on_close_smb2_done(struct tevent_req *subreq);
1808
1809 struct tevent_req *cli_nt_delete_on_close_send(TALLOC_CTX *mem_ctx,
1810                                         struct tevent_context *ev,
1811                                         struct cli_state *cli,
1812                                         uint16_t fnum,
1813                                         bool flag)
1814 {
1815         struct tevent_req *req = NULL, *subreq = NULL;
1816         struct doc_state *state = NULL;
1817
1818         req = tevent_req_create(mem_ctx, &state, struct doc_state);
1819         if (req == NULL) {
1820                 return NULL;
1821         }
1822
1823         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
1824                 subreq = cli_smb2_delete_on_close_send(state, ev, cli,
1825                                                        fnum, flag);
1826                 if (tevent_req_nomem(subreq, req)) {
1827                         return tevent_req_post(req, ev);
1828                 }
1829                 tevent_req_set_callback(subreq,
1830                                         cli_nt_delete_on_close_smb2_done,
1831                                         req);
1832                 return req;
1833         }
1834
1835         /* Setup setup word. */
1836         SSVAL(&state->setup, 0, TRANSACT2_SETFILEINFO);
1837
1838         /* Setup param array. */
1839         SSVAL(state->param,0,fnum);
1840         SSVAL(state->param,2,SMB_SET_FILE_DISPOSITION_INFO);
1841
1842         /* Setup data array. */
1843         SCVAL(&state->data[0], 0, flag ? 1 : 0);
1844
1845         subreq = cli_trans_send(state,                  /* mem ctx. */
1846                                 ev,                     /* event ctx. */
1847                                 cli,                    /* cli_state. */
1848                                 0,                      /* additional_flags2 */
1849                                 SMBtrans2,              /* cmd. */
1850                                 NULL,                   /* pipe name. */
1851                                 -1,                     /* fid. */
1852                                 0,                      /* function. */
1853                                 0,                      /* flags. */
1854                                 &state->setup,          /* setup. */
1855                                 1,                      /* num setup uint16_t words. */
1856                                 0,                      /* max returned setup. */
1857                                 state->param,           /* param. */
1858                                 6,                      /* num param. */
1859                                 2,                      /* max returned param. */
1860                                 state->data,            /* data. */
1861                                 1,                      /* num data. */
1862                                 0);                     /* max returned data. */
1863
1864         if (tevent_req_nomem(subreq, req)) {
1865                 return tevent_req_post(req, ev);
1866         }
1867         tevent_req_set_callback(subreq,
1868                                 cli_nt_delete_on_close_smb1_done,
1869                                 req);
1870         return req;
1871 }
1872
1873 static void cli_nt_delete_on_close_smb1_done(struct tevent_req *subreq)
1874 {
1875         NTSTATUS status = cli_trans_recv(subreq, NULL, NULL, NULL, 0, NULL,
1876                                          NULL, 0, NULL, NULL, 0, NULL);
1877         tevent_req_simple_finish_ntstatus(subreq, status);
1878 }
1879
1880 static void cli_nt_delete_on_close_smb2_done(struct tevent_req *subreq)
1881 {
1882         NTSTATUS status = cli_smb2_delete_on_close_recv(subreq);
1883         tevent_req_simple_finish_ntstatus(subreq, status);
1884 }
1885
1886 NTSTATUS cli_nt_delete_on_close_recv(struct tevent_req *req)
1887 {
1888         return tevent_req_simple_recv_ntstatus(req);
1889 }
1890
1891 NTSTATUS cli_nt_delete_on_close(struct cli_state *cli, uint16_t fnum, bool flag)
1892 {
1893         TALLOC_CTX *frame = talloc_stackframe();
1894         struct tevent_context *ev = NULL;
1895         struct tevent_req *req = NULL;
1896         NTSTATUS status = NT_STATUS_OK;
1897
1898         if (smbXcli_conn_has_async_calls(cli->conn)) {
1899                 /*
1900                  * Can't use sync call while an async call is in flight
1901                  */
1902                 status = NT_STATUS_INVALID_PARAMETER;
1903                 goto fail;
1904         }
1905
1906         ev = samba_tevent_context_init(frame);
1907         if (ev == NULL) {
1908                 status = NT_STATUS_NO_MEMORY;
1909                 goto fail;
1910         }
1911
1912         req = cli_nt_delete_on_close_send(frame,
1913                                 ev,
1914                                 cli,
1915                                 fnum,
1916                                 flag);
1917         if (req == NULL) {
1918                 status = NT_STATUS_NO_MEMORY;
1919                 goto fail;
1920         }
1921
1922         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1923                 goto fail;
1924         }
1925
1926         status = cli_nt_delete_on_close_recv(req);
1927
1928  fail:
1929         TALLOC_FREE(frame);
1930         return status;
1931 }
1932
1933 struct cli_ntcreate1_state {
1934         uint16_t vwv[24];
1935         uint16_t fnum;
1936         struct smb_create_returns cr;
1937         struct tevent_req *subreq;
1938 };
1939
1940 static void cli_ntcreate1_done(struct tevent_req *subreq);
1941 static bool cli_ntcreate1_cancel(struct tevent_req *req);
1942
1943 static struct tevent_req *cli_ntcreate1_send(TALLOC_CTX *mem_ctx,
1944                                              struct tevent_context *ev,
1945                                              struct cli_state *cli,
1946                                              const char *fname,
1947                                              uint32_t CreatFlags,
1948                                              uint32_t DesiredAccess,
1949                                              uint32_t FileAttributes,
1950                                              uint32_t ShareAccess,
1951                                              uint32_t CreateDisposition,
1952                                              uint32_t CreateOptions,
1953                                              uint8_t SecurityFlags)
1954 {
1955         struct tevent_req *req, *subreq;
1956         struct cli_ntcreate1_state *state;
1957         uint16_t *vwv;
1958         uint8_t *bytes;
1959         size_t converted_len;
1960         uint16_t additional_flags2 = 0;
1961
1962         req = tevent_req_create(mem_ctx, &state, struct cli_ntcreate1_state);
1963         if (req == NULL) {
1964                 return NULL;
1965         }
1966
1967         vwv = state->vwv;
1968
1969         SCVAL(vwv+0, 0, 0xFF);
1970         SCVAL(vwv+0, 1, 0);
1971         SSVAL(vwv+1, 0, 0);
1972         SCVAL(vwv+2, 0, 0);
1973
1974         if (cli->use_oplocks) {
1975                 CreatFlags |= (REQUEST_OPLOCK|REQUEST_BATCH_OPLOCK);
1976         }
1977         SIVAL(vwv+3, 1, CreatFlags);
1978         SIVAL(vwv+5, 1, 0x0);   /* RootDirectoryFid */
1979         SIVAL(vwv+7, 1, DesiredAccess);
1980         SIVAL(vwv+9, 1, 0x0);   /* AllocationSize */
1981         SIVAL(vwv+11, 1, 0x0);  /* AllocationSize */
1982         SIVAL(vwv+13, 1, FileAttributes);
1983         SIVAL(vwv+15, 1, ShareAccess);
1984         SIVAL(vwv+17, 1, CreateDisposition);
1985         SIVAL(vwv+19, 1, CreateOptions |
1986                 (cli->backup_intent ? FILE_OPEN_FOR_BACKUP_INTENT : 0));
1987         SIVAL(vwv+21, 1, 0x02); /* ImpersonationLevel */
1988         SCVAL(vwv+23, 1, SecurityFlags);
1989
1990         bytes = talloc_array(state, uint8_t, 0);
1991         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn),
1992                                    fname, strlen(fname)+1,
1993                                    &converted_len);
1994
1995         if (clistr_is_previous_version_path(fname, NULL, NULL, NULL)) {
1996                 additional_flags2 = FLAGS2_REPARSE_PATH;
1997         }
1998
1999         /* sigh. this copes with broken netapp filer behaviour */
2000         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), "", 1, NULL);
2001
2002         if (tevent_req_nomem(bytes, req)) {
2003                 return tevent_req_post(req, ev);
2004         }
2005
2006         SSVAL(vwv+2, 1, converted_len);
2007
2008         subreq = cli_smb_send(state, ev, cli, SMBntcreateX, 0,
2009                         additional_flags2, 24, vwv,
2010                         talloc_get_size(bytes), bytes);
2011         if (tevent_req_nomem(subreq, req)) {
2012                 return tevent_req_post(req, ev);
2013         }
2014         tevent_req_set_callback(subreq, cli_ntcreate1_done, req);
2015
2016         state->subreq = subreq;
2017         tevent_req_set_cancel_fn(req, cli_ntcreate1_cancel);
2018
2019         return req;
2020 }
2021
2022 static void cli_ntcreate1_done(struct tevent_req *subreq)
2023 {
2024         struct tevent_req *req = tevent_req_callback_data(
2025                 subreq, struct tevent_req);
2026         struct cli_ntcreate1_state *state = tevent_req_data(
2027                 req, struct cli_ntcreate1_state);
2028         uint8_t wct;
2029         uint16_t *vwv;
2030         uint32_t num_bytes;
2031         uint8_t *bytes;
2032         NTSTATUS status;
2033
2034         status = cli_smb_recv(subreq, state, NULL, 34, &wct, &vwv,
2035                               &num_bytes, &bytes);
2036         TALLOC_FREE(subreq);
2037         if (tevent_req_nterror(req, status)) {
2038                 return;
2039         }
2040         state->cr.oplock_level = CVAL(vwv+2, 0);
2041         state->fnum = SVAL(vwv+2, 1);
2042         state->cr.create_action = IVAL(vwv+3, 1);
2043         state->cr.creation_time = BVAL(vwv+5, 1);
2044         state->cr.last_access_time = BVAL(vwv+9, 1);
2045         state->cr.last_write_time = BVAL(vwv+13, 1);
2046         state->cr.change_time   = BVAL(vwv+17, 1);
2047         state->cr.file_attributes = IVAL(vwv+21, 1);
2048         state->cr.allocation_size = BVAL(vwv+23, 1);
2049         state->cr.end_of_file   = BVAL(vwv+27, 1);
2050
2051         tevent_req_done(req);
2052 }
2053
2054 static bool cli_ntcreate1_cancel(struct tevent_req *req)
2055 {
2056         struct cli_ntcreate1_state *state = tevent_req_data(
2057                 req, struct cli_ntcreate1_state);
2058         return tevent_req_cancel(state->subreq);
2059 }
2060
2061 static NTSTATUS cli_ntcreate1_recv(struct tevent_req *req,
2062                                    uint16_t *pfnum,
2063                                    struct smb_create_returns *cr)
2064 {
2065         struct cli_ntcreate1_state *state = tevent_req_data(
2066                 req, struct cli_ntcreate1_state);
2067         NTSTATUS status;
2068
2069         if (tevent_req_is_nterror(req, &status)) {
2070                 return status;
2071         }
2072         *pfnum = state->fnum;
2073         if (cr != NULL) {
2074                 *cr = state->cr;
2075         }
2076         return NT_STATUS_OK;
2077 }
2078
2079 struct cli_ntcreate_state {
2080         NTSTATUS (*recv)(struct tevent_req *req, uint16_t *fnum,
2081                          struct smb_create_returns *cr);
2082         struct smb_create_returns cr;
2083         uint16_t fnum;
2084         struct tevent_req *subreq;
2085 };
2086
2087 static void cli_ntcreate_done(struct tevent_req *subreq);
2088 static bool cli_ntcreate_cancel(struct tevent_req *req);
2089
2090 struct tevent_req *cli_ntcreate_send(TALLOC_CTX *mem_ctx,
2091                                      struct tevent_context *ev,
2092                                      struct cli_state *cli,
2093                                      const char *fname,
2094                                      uint32_t create_flags,
2095                                      uint32_t desired_access,
2096                                      uint32_t file_attributes,
2097                                      uint32_t share_access,
2098                                      uint32_t create_disposition,
2099                                      uint32_t create_options,
2100                                      uint8_t security_flags)
2101 {
2102         struct tevent_req *req, *subreq;
2103         struct cli_ntcreate_state *state;
2104
2105         req = tevent_req_create(mem_ctx, &state, struct cli_ntcreate_state);
2106         if (req == NULL) {
2107                 return NULL;
2108         }
2109
2110         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
2111                 state->recv = cli_smb2_create_fnum_recv;
2112
2113                 if (cli->use_oplocks) {
2114                         create_flags |= REQUEST_OPLOCK|REQUEST_BATCH_OPLOCK;
2115                 }
2116
2117                 subreq = cli_smb2_create_fnum_send(
2118                         state, ev, cli, fname, create_flags, desired_access,
2119                         file_attributes, share_access, create_disposition,
2120                         create_options);
2121         } else {
2122                 state->recv = cli_ntcreate1_recv;
2123                 subreq = cli_ntcreate1_send(
2124                         state, ev, cli, fname, create_flags, desired_access,
2125                         file_attributes, share_access, create_disposition,
2126                         create_options, security_flags);
2127         }
2128         if (tevent_req_nomem(subreq, req)) {
2129                 return tevent_req_post(req, ev);
2130         }
2131         tevent_req_set_callback(subreq, cli_ntcreate_done, req);
2132
2133         state->subreq = subreq;
2134         tevent_req_set_cancel_fn(req, cli_ntcreate_cancel);
2135
2136         return req;
2137 }
2138
2139 static void cli_ntcreate_done(struct tevent_req *subreq)
2140 {
2141         struct tevent_req *req = tevent_req_callback_data(
2142                 subreq, struct tevent_req);
2143         struct cli_ntcreate_state *state = tevent_req_data(
2144                 req, struct cli_ntcreate_state);
2145         NTSTATUS status;
2146
2147         status = state->recv(subreq, &state->fnum, &state->cr);
2148         TALLOC_FREE(subreq);
2149         if (tevent_req_nterror(req, status)) {
2150                 return;
2151         }
2152         tevent_req_done(req);
2153 }
2154
2155 static bool cli_ntcreate_cancel(struct tevent_req *req)
2156 {
2157         struct cli_ntcreate_state *state = tevent_req_data(
2158                 req, struct cli_ntcreate_state);
2159         return tevent_req_cancel(state->subreq);
2160 }
2161
2162 NTSTATUS cli_ntcreate_recv(struct tevent_req *req, uint16_t *fnum,
2163                            struct smb_create_returns *cr)
2164 {
2165         struct cli_ntcreate_state *state = tevent_req_data(
2166                 req, struct cli_ntcreate_state);
2167         NTSTATUS status;
2168
2169         if (tevent_req_is_nterror(req, &status)) {
2170                 return status;
2171         }
2172         if (fnum != NULL) {
2173                 *fnum = state->fnum;
2174         }
2175         if (cr != NULL) {
2176                 *cr = state->cr;
2177         }
2178         return NT_STATUS_OK;
2179 }
2180
2181 NTSTATUS cli_ntcreate(struct cli_state *cli,
2182                       const char *fname,
2183                       uint32_t CreatFlags,
2184                       uint32_t DesiredAccess,
2185                       uint32_t FileAttributes,
2186                       uint32_t ShareAccess,
2187                       uint32_t CreateDisposition,
2188                       uint32_t CreateOptions,
2189                       uint8_t SecurityFlags,
2190                       uint16_t *pfid,
2191                       struct smb_create_returns *cr)
2192 {
2193         TALLOC_CTX *frame = talloc_stackframe();
2194         struct tevent_context *ev;
2195         struct tevent_req *req;
2196         NTSTATUS status = NT_STATUS_NO_MEMORY;
2197
2198         if (smbXcli_conn_has_async_calls(cli->conn)) {
2199                 /*
2200                  * Can't use sync call while an async call is in flight
2201                  */
2202                 status = NT_STATUS_INVALID_PARAMETER;
2203                 goto fail;
2204         }
2205
2206         ev = samba_tevent_context_init(frame);
2207         if (ev == NULL) {
2208                 goto fail;
2209         }
2210
2211         req = cli_ntcreate_send(frame, ev, cli, fname, CreatFlags,
2212                                 DesiredAccess, FileAttributes, ShareAccess,
2213                                 CreateDisposition, CreateOptions,
2214                                 SecurityFlags);
2215         if (req == NULL) {
2216                 goto fail;
2217         }
2218
2219         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
2220                 goto fail;
2221         }
2222
2223         status = cli_ntcreate_recv(req, pfid, cr);
2224  fail:
2225         TALLOC_FREE(frame);
2226         return status;
2227 }
2228
2229 struct cli_nttrans_create_state {
2230         uint16_t fnum;
2231         struct smb_create_returns cr;
2232 };
2233
2234 static void cli_nttrans_create_done(struct tevent_req *subreq);
2235
2236 struct tevent_req *cli_nttrans_create_send(TALLOC_CTX *mem_ctx,
2237                                            struct tevent_context *ev,
2238                                            struct cli_state *cli,
2239                                            const char *fname,
2240                                            uint32_t CreatFlags,
2241                                            uint32_t DesiredAccess,
2242                                            uint32_t FileAttributes,
2243                                            uint32_t ShareAccess,
2244                                            uint32_t CreateDisposition,
2245                                            uint32_t CreateOptions,
2246                                            uint8_t SecurityFlags,
2247                                            struct security_descriptor *secdesc,
2248                                            struct ea_struct *eas,
2249                                            int num_eas)
2250 {
2251         struct tevent_req *req, *subreq;
2252         struct cli_nttrans_create_state *state;
2253         uint8_t *param;
2254         uint8_t *secdesc_buf;
2255         size_t secdesc_len;
2256         NTSTATUS status;
2257         size_t converted_len;
2258         uint16_t additional_flags2 = 0;
2259
2260         req = tevent_req_create(mem_ctx,
2261                                 &state, struct cli_nttrans_create_state);
2262         if (req == NULL) {
2263                 return NULL;
2264         }
2265
2266         if (secdesc != NULL) {
2267                 status = marshall_sec_desc(talloc_tos(), secdesc,
2268                                            &secdesc_buf, &secdesc_len);
2269                 if (tevent_req_nterror(req, status)) {
2270                         DEBUG(10, ("marshall_sec_desc failed: %s\n",
2271                                    nt_errstr(status)));
2272                         return tevent_req_post(req, ev);
2273                 }
2274         } else {
2275                 secdesc_buf = NULL;
2276                 secdesc_len = 0;
2277         }
2278
2279         if (num_eas != 0) {
2280                 /*
2281                  * TODO ;-)
2282                  */
2283                 tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
2284                 return tevent_req_post(req, ev);
2285         }
2286
2287         param = talloc_array(state, uint8_t, 53);
2288         if (tevent_req_nomem(param, req)) {
2289                 return tevent_req_post(req, ev);
2290         }
2291
2292         param = trans2_bytes_push_str(param, smbXcli_conn_use_unicode(cli->conn),
2293                                       fname, strlen(fname),
2294                                       &converted_len);
2295         if (tevent_req_nomem(param, req)) {
2296                 return tevent_req_post(req, ev);
2297         }
2298
2299         if (clistr_is_previous_version_path(fname, NULL, NULL, NULL)) {
2300                 additional_flags2 = FLAGS2_REPARSE_PATH;
2301         }
2302
2303         SIVAL(param, 0, CreatFlags);
2304         SIVAL(param, 4, 0x0);   /* RootDirectoryFid */
2305         SIVAL(param, 8, DesiredAccess);
2306         SIVAL(param, 12, 0x0);  /* AllocationSize */
2307         SIVAL(param, 16, 0x0);  /* AllocationSize */
2308         SIVAL(param, 20, FileAttributes);
2309         SIVAL(param, 24, ShareAccess);
2310         SIVAL(param, 28, CreateDisposition);
2311         SIVAL(param, 32, CreateOptions |
2312                 (cli->backup_intent ? FILE_OPEN_FOR_BACKUP_INTENT : 0));
2313         SIVAL(param, 36, secdesc_len);
2314         SIVAL(param, 40, 0);     /* EA length*/
2315         SIVAL(param, 44, converted_len);
2316         SIVAL(param, 48, 0x02); /* ImpersonationLevel */
2317         SCVAL(param, 52, SecurityFlags);
2318
2319         subreq = cli_trans_send(state, ev, cli,
2320                                 additional_flags2, /* additional_flags2 */
2321                                 SMBnttrans,
2322                                 NULL, -1, /* name, fid */
2323                                 NT_TRANSACT_CREATE, 0,
2324                                 NULL, 0, 0, /* setup */
2325                                 param, talloc_get_size(param), 128, /* param */
2326                                 secdesc_buf, secdesc_len, 0); /* data */
2327         if (tevent_req_nomem(subreq, req)) {
2328                 return tevent_req_post(req, ev);
2329         }
2330         tevent_req_set_callback(subreq, cli_nttrans_create_done, req);
2331         return req;
2332 }
2333
2334 static void cli_nttrans_create_done(struct tevent_req *subreq)
2335 {
2336         struct tevent_req *req = tevent_req_callback_data(
2337                 subreq, struct tevent_req);
2338         struct cli_nttrans_create_state *state = tevent_req_data(
2339                 req, struct cli_nttrans_create_state);
2340         uint8_t *param;
2341         uint32_t num_param;
2342         NTSTATUS status;
2343
2344         status = cli_trans_recv(subreq, talloc_tos(), NULL,
2345                                 NULL, 0, NULL, /* rsetup */
2346                                 &param, 69, &num_param,
2347                                 NULL, 0, NULL);
2348         if (tevent_req_nterror(req, status)) {
2349                 return;
2350         }
2351         state->cr.oplock_level = CVAL(param, 0);
2352         state->fnum = SVAL(param, 2);
2353         state->cr.create_action = IVAL(param, 4);
2354         state->cr.creation_time = BVAL(param, 12);
2355         state->cr.last_access_time = BVAL(param, 20);
2356         state->cr.last_write_time = BVAL(param, 28);
2357         state->cr.change_time   = BVAL(param, 36);
2358         state->cr.file_attributes = IVAL(param, 44);
2359         state->cr.allocation_size = BVAL(param, 48);
2360         state->cr.end_of_file   = BVAL(param, 56);
2361
2362         TALLOC_FREE(param);
2363         tevent_req_done(req);
2364 }
2365
2366 NTSTATUS cli_nttrans_create_recv(struct tevent_req *req,
2367                         uint16_t *fnum,
2368                         struct smb_create_returns *cr)
2369 {
2370         struct cli_nttrans_create_state *state = tevent_req_data(
2371                 req, struct cli_nttrans_create_state);
2372         NTSTATUS status;
2373
2374         if (tevent_req_is_nterror(req, &status)) {
2375                 return status;
2376         }
2377         *fnum = state->fnum;
2378         if (cr != NULL) {
2379                 *cr = state->cr;
2380         }
2381         return NT_STATUS_OK;
2382 }
2383
2384 NTSTATUS cli_nttrans_create(struct cli_state *cli,
2385                             const char *fname,
2386                             uint32_t CreatFlags,
2387                             uint32_t DesiredAccess,
2388                             uint32_t FileAttributes,
2389                             uint32_t ShareAccess,
2390                             uint32_t CreateDisposition,
2391                             uint32_t CreateOptions,
2392                             uint8_t SecurityFlags,
2393                             struct security_descriptor *secdesc,
2394                             struct ea_struct *eas,
2395                             int num_eas,
2396                             uint16_t *pfid,
2397                             struct smb_create_returns *cr)
2398 {
2399         TALLOC_CTX *frame = talloc_stackframe();
2400         struct tevent_context *ev;
2401         struct tevent_req *req;
2402         NTSTATUS status = NT_STATUS_NO_MEMORY;
2403
2404         if (smbXcli_conn_has_async_calls(cli->conn)) {
2405                 /*
2406                  * Can't use sync call while an async call is in flight
2407                  */
2408                 status = NT_STATUS_INVALID_PARAMETER;
2409                 goto fail;
2410         }
2411         ev = samba_tevent_context_init(frame);
2412         if (ev == NULL) {
2413                 goto fail;
2414         }
2415         req = cli_nttrans_create_send(frame, ev, cli, fname, CreatFlags,
2416                                       DesiredAccess, FileAttributes,
2417                                       ShareAccess, CreateDisposition,
2418                                       CreateOptions, SecurityFlags,
2419                                       secdesc, eas, num_eas);
2420         if (req == NULL) {
2421                 goto fail;
2422         }
2423         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
2424                 goto fail;
2425         }
2426         status = cli_nttrans_create_recv(req, pfid, cr);
2427  fail:
2428         TALLOC_FREE(frame);
2429         return status;
2430 }
2431
2432 /****************************************************************************
2433  Open a file
2434  WARNING: if you open with O_WRONLY then getattrE won't work!
2435 ****************************************************************************/
2436
2437 struct cli_openx_state {
2438         const char *fname;
2439         uint16_t vwv[15];
2440         uint16_t fnum;
2441         struct iovec bytes;
2442 };
2443
2444 static void cli_openx_done(struct tevent_req *subreq);
2445
2446 struct tevent_req *cli_openx_create(TALLOC_CTX *mem_ctx,
2447                                    struct tevent_context *ev,
2448                                    struct cli_state *cli, const char *fname,
2449                                    int flags, int share_mode,
2450                                    struct tevent_req **psmbreq)
2451 {
2452         struct tevent_req *req, *subreq;
2453         struct cli_openx_state *state;
2454         unsigned openfn;
2455         unsigned accessmode;
2456         uint8_t additional_flags;
2457         uint16_t additional_flags2 = 0;
2458         uint8_t *bytes;
2459
2460         req = tevent_req_create(mem_ctx, &state, struct cli_openx_state);
2461         if (req == NULL) {
2462                 return NULL;
2463         }
2464
2465         openfn = 0;
2466         if (flags & O_CREAT) {
2467                 openfn |= (1<<4);
2468         }
2469         if (!(flags & O_EXCL)) {
2470                 if (flags & O_TRUNC)
2471                         openfn |= (1<<1);
2472                 else
2473                         openfn |= (1<<0);
2474         }
2475
2476         accessmode = (share_mode<<4);
2477
2478         if ((flags & O_ACCMODE) == O_RDWR) {
2479                 accessmode |= 2;
2480         } else if ((flags & O_ACCMODE) == O_WRONLY) {
2481                 accessmode |= 1;
2482         }
2483
2484 #if defined(O_SYNC)
2485         if ((flags & O_SYNC) == O_SYNC) {
2486                 accessmode |= (1<<14);
2487         }
2488 #endif /* O_SYNC */
2489
2490         if (share_mode == DENY_FCB) {
2491                 accessmode = 0xFF;
2492         }
2493
2494         SCVAL(state->vwv + 0, 0, 0xFF);
2495         SCVAL(state->vwv + 0, 1, 0);
2496         SSVAL(state->vwv + 1, 0, 0);
2497         SSVAL(state->vwv + 2, 0, 0);  /* no additional info */
2498         SSVAL(state->vwv + 3, 0, accessmode);
2499         SSVAL(state->vwv + 4, 0, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2500         SSVAL(state->vwv + 5, 0, 0);
2501         SIVAL(state->vwv + 6, 0, 0);
2502         SSVAL(state->vwv + 8, 0, openfn);
2503         SIVAL(state->vwv + 9, 0, 0);
2504         SIVAL(state->vwv + 11, 0, 0);
2505         SIVAL(state->vwv + 13, 0, 0);
2506
2507         additional_flags = 0;
2508
2509         if (cli->use_oplocks) {
2510                 /* if using oplocks then ask for a batch oplock via
2511                    core and extended methods */
2512                 additional_flags =
2513                         FLAG_REQUEST_OPLOCK|FLAG_REQUEST_BATCH_OPLOCK;
2514                 SSVAL(state->vwv+2, 0, SVAL(state->vwv+2, 0) | 6);
2515         }
2516
2517         bytes = talloc_array(state, uint8_t, 0);
2518         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), fname,
2519                                    strlen(fname)+1, NULL);
2520
2521         if (tevent_req_nomem(bytes, req)) {
2522                 return tevent_req_post(req, ev);
2523         }
2524
2525         if (clistr_is_previous_version_path(fname, NULL, NULL, NULL)) {
2526                 additional_flags2 = FLAGS2_REPARSE_PATH;
2527         }
2528
2529         state->bytes.iov_base = (void *)bytes;
2530         state->bytes.iov_len = talloc_get_size(bytes);
2531
2532         subreq = cli_smb_req_create(state, ev, cli, SMBopenX, additional_flags,
2533                         additional_flags2, 15, state->vwv, 1, &state->bytes);
2534         if (subreq == NULL) {
2535                 TALLOC_FREE(req);
2536                 return NULL;
2537         }
2538         tevent_req_set_callback(subreq, cli_openx_done, req);
2539         *psmbreq = subreq;
2540         return req;
2541 }
2542
2543 struct tevent_req *cli_openx_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
2544                                  struct cli_state *cli, const char *fname,
2545                                  int flags, int share_mode)
2546 {
2547         struct tevent_req *req, *subreq;
2548         NTSTATUS status;
2549
2550         req = cli_openx_create(mem_ctx, ev, cli, fname, flags, share_mode,
2551                               &subreq);
2552         if (req == NULL) {
2553                 return NULL;
2554         }
2555
2556         status = smb1cli_req_chain_submit(&subreq, 1);
2557         if (tevent_req_nterror(req, status)) {
2558                 return tevent_req_post(req, ev);
2559         }
2560         return req;
2561 }
2562
2563 static void cli_openx_done(struct tevent_req *subreq)
2564 {
2565         struct tevent_req *req = tevent_req_callback_data(
2566                 subreq, struct tevent_req);
2567         struct cli_openx_state *state = tevent_req_data(
2568                 req, struct cli_openx_state);
2569         uint8_t wct;
2570         uint16_t *vwv;
2571         NTSTATUS status;
2572
2573         status = cli_smb_recv(subreq, state, NULL, 3, &wct, &vwv, NULL,
2574                               NULL);
2575         TALLOC_FREE(subreq);
2576         if (tevent_req_nterror(req, status)) {
2577                 return;
2578         }
2579         state->fnum = SVAL(vwv+2, 0);
2580         tevent_req_done(req);
2581 }
2582
2583 NTSTATUS cli_openx_recv(struct tevent_req *req, uint16_t *pfnum)
2584 {
2585         struct cli_openx_state *state = tevent_req_data(
2586                 req, struct cli_openx_state);
2587         NTSTATUS status;
2588
2589         if (tevent_req_is_nterror(req, &status)) {
2590                 return status;
2591         }
2592         *pfnum = state->fnum;
2593         return NT_STATUS_OK;
2594 }
2595
2596 NTSTATUS cli_openx(struct cli_state *cli, const char *fname, int flags,
2597              int share_mode, uint16_t *pfnum)
2598 {
2599         TALLOC_CTX *frame = talloc_stackframe();
2600         struct tevent_context *ev;
2601         struct tevent_req *req;
2602         NTSTATUS status = NT_STATUS_NO_MEMORY;
2603
2604         if (smbXcli_conn_has_async_calls(cli->conn)) {
2605                 /*
2606                  * Can't use sync call while an async call is in flight
2607                  */
2608                 status = NT_STATUS_INVALID_PARAMETER;
2609                 goto fail;
2610         }
2611
2612         ev = samba_tevent_context_init(frame);
2613         if (ev == NULL) {
2614                 goto fail;
2615         }
2616
2617         req = cli_openx_send(frame, ev, cli, fname, flags, share_mode);
2618         if (req == NULL) {
2619                 goto fail;
2620         }
2621
2622         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
2623                 goto fail;
2624         }
2625
2626         status = cli_openx_recv(req, pfnum);
2627  fail:
2628         TALLOC_FREE(frame);
2629         return status;
2630 }
2631 /****************************************************************************
2632  Synchronous wrapper function that does an NtCreateX open by preference
2633  and falls back to openX if this fails.
2634 ****************************************************************************/
2635
2636 NTSTATUS cli_open(struct cli_state *cli, const char *fname, int flags,
2637                         int share_mode_in, uint16_t *pfnum)
2638 {
2639         NTSTATUS status;
2640         unsigned int openfn = 0;
2641         unsigned int dos_deny = 0;
2642         uint32_t access_mask, share_mode, create_disposition, create_options;
2643         struct smb_create_returns cr;
2644
2645         /* Do the initial mapping into OpenX parameters. */
2646         if (flags & O_CREAT) {
2647                 openfn |= (1<<4);
2648         }
2649         if (!(flags & O_EXCL)) {
2650                 if (flags & O_TRUNC)
2651                         openfn |= (1<<1);
2652                 else
2653                         openfn |= (1<<0);
2654         }
2655
2656         dos_deny = (share_mode_in<<4);
2657
2658         if ((flags & O_ACCMODE) == O_RDWR) {
2659                 dos_deny |= 2;
2660         } else if ((flags & O_ACCMODE) == O_WRONLY) {
2661                 dos_deny |= 1;
2662         }
2663
2664 #if defined(O_SYNC)
2665         if ((flags & O_SYNC) == O_SYNC) {
2666                 dos_deny |= (1<<14);
2667         }
2668 #endif /* O_SYNC */
2669
2670         if (share_mode_in == DENY_FCB) {
2671                 dos_deny = 0xFF;
2672         }
2673
2674 #if 0
2675         /* Hmmm. This is what I think the above code
2676            should look like if it's using the constants
2677            we #define. JRA. */
2678
2679         if (flags & O_CREAT) {
2680                 openfn |= OPENX_FILE_CREATE_IF_NOT_EXIST;
2681         }
2682         if (!(flags & O_EXCL)) {
2683                 if (flags & O_TRUNC)
2684                         openfn |= OPENX_FILE_EXISTS_TRUNCATE;
2685                 else
2686                         openfn |= OPENX_FILE_EXISTS_OPEN;
2687         }
2688
2689         dos_deny = SET_DENY_MODE(share_mode_in);
2690
2691         if ((flags & O_ACCMODE) == O_RDWR) {
2692                 dos_deny |= DOS_OPEN_RDWR;
2693         } else if ((flags & O_ACCMODE) == O_WRONLY) {
2694                 dos_deny |= DOS_OPEN_WRONLY;
2695         }
2696
2697 #if defined(O_SYNC)
2698         if ((flags & O_SYNC) == O_SYNC) {
2699                 dos_deny |= FILE_SYNC_OPENMODE;
2700         }
2701 #endif /* O_SYNC */
2702
2703         if (share_mode_in == DENY_FCB) {
2704                 dos_deny = 0xFF;
2705         }
2706 #endif
2707
2708         if (!map_open_params_to_ntcreate(fname, dos_deny,
2709                                         openfn, &access_mask,
2710                                         &share_mode, &create_disposition,
2711                                         &create_options, NULL)) {
2712                 goto try_openx;
2713         }
2714
2715         status = cli_ntcreate(cli,
2716                                 fname,
2717                                 0,
2718                                 access_mask,
2719                                 0,
2720                                 share_mode,
2721                                 create_disposition,
2722                                 create_options,
2723                                 0,
2724                                 pfnum,
2725                                 &cr);
2726
2727         /* Try and cope will all varients of "we don't do this call"
2728            and fall back to openX. */
2729
2730         if (NT_STATUS_EQUAL(status,NT_STATUS_NOT_IMPLEMENTED) ||
2731                         NT_STATUS_EQUAL(status,NT_STATUS_INVALID_INFO_CLASS) ||
2732                         NT_STATUS_EQUAL(status,NT_STATUS_PROCEDURE_NOT_FOUND) ||
2733                         NT_STATUS_EQUAL(status,NT_STATUS_INVALID_LEVEL) ||
2734                         NT_STATUS_EQUAL(status,NT_STATUS_INVALID_PARAMETER) ||
2735                         NT_STATUS_EQUAL(status,NT_STATUS_INVALID_DEVICE_REQUEST) ||
2736                         NT_STATUS_EQUAL(status,NT_STATUS_INVALID_DEVICE_STATE) ||
2737                         NT_STATUS_EQUAL(status,NT_STATUS_CTL_FILE_NOT_SUPPORTED) ||
2738                         NT_STATUS_EQUAL(status,NT_STATUS_UNSUCCESSFUL)) {
2739                 goto try_openx;
2740         }
2741
2742         if (NT_STATUS_IS_OK(status) &&
2743             (create_options & FILE_NON_DIRECTORY_FILE) &&
2744             (cr.file_attributes & FILE_ATTRIBUTE_DIRECTORY))
2745         {
2746                 /*
2747                  * Some (broken) servers return a valid handle
2748                  * for directories even if FILE_NON_DIRECTORY_FILE
2749                  * is set. Just close the handle and set the
2750                  * error explicitly to NT_STATUS_FILE_IS_A_DIRECTORY.
2751                  */
2752                 status = cli_close(cli, *pfnum);
2753                 if (!NT_STATUS_IS_OK(status)) {
2754                         return status;
2755                 }
2756                 status = NT_STATUS_FILE_IS_A_DIRECTORY;
2757                 /* Set this so libsmbclient can retrieve it. */
2758                 cli->raw_status = status;
2759         }
2760
2761         return status;
2762
2763   try_openx:
2764
2765         return cli_openx(cli, fname, flags, share_mode_in, pfnum);
2766 }
2767
2768 /****************************************************************************
2769  Close a file.
2770 ****************************************************************************/
2771
2772 struct cli_close_state {
2773         uint16_t vwv[3];
2774 };
2775
2776 static void cli_close_done(struct tevent_req *subreq);
2777
2778 struct tevent_req *cli_close_create(TALLOC_CTX *mem_ctx,
2779                                 struct tevent_context *ev,
2780                                 struct cli_state *cli,
2781                                 uint16_t fnum,
2782                                 struct tevent_req **psubreq)
2783 {
2784         struct tevent_req *req, *subreq;
2785         struct cli_close_state *state;
2786
2787         req = tevent_req_create(mem_ctx, &state, struct cli_close_state);
2788         if (req == NULL) {
2789                 return NULL;
2790         }
2791
2792         SSVAL(state->vwv+0, 0, fnum);
2793         SIVALS(state->vwv+1, 0, -1);
2794
2795         subreq = cli_smb_req_create(state, ev, cli, SMBclose, 0, 0,
2796                                 3, state->vwv, 0, NULL);
2797         if (subreq == NULL) {
2798                 TALLOC_FREE(req);
2799                 return NULL;
2800         }
2801         tevent_req_set_callback(subreq, cli_close_done, req);
2802         *psubreq = subreq;
2803         return req;
2804 }
2805
2806 struct tevent_req *cli_close_send(TALLOC_CTX *mem_ctx,
2807                                 struct tevent_context *ev,
2808                                 struct cli_state *cli,
2809                                 uint16_t fnum)
2810 {
2811         struct tevent_req *req, *subreq;
2812         NTSTATUS status;
2813
2814         req = cli_close_create(mem_ctx, ev, cli, fnum, &subreq);
2815         if (req == NULL) {
2816                 return NULL;
2817         }
2818
2819         status = smb1cli_req_chain_submit(&subreq, 1);
2820         if (tevent_req_nterror(req, status)) {
2821                 return tevent_req_post(req, ev);
2822         }
2823         return req;
2824 }
2825
2826 static void cli_close_done(struct tevent_req *subreq)
2827 {
2828         struct tevent_req *req = tevent_req_callback_data(
2829                 subreq, struct tevent_req);
2830         NTSTATUS status;
2831
2832         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
2833         TALLOC_FREE(subreq);
2834         if (tevent_req_nterror(req, status)) {
2835                 return;
2836         }
2837         tevent_req_done(req);
2838 }
2839
2840 NTSTATUS cli_close_recv(struct tevent_req *req)
2841 {
2842         return tevent_req_simple_recv_ntstatus(req);
2843 }
2844
2845 NTSTATUS cli_close(struct cli_state *cli, uint16_t fnum)
2846 {
2847         TALLOC_CTX *frame = NULL;
2848         struct tevent_context *ev;
2849         struct tevent_req *req;
2850         NTSTATUS status = NT_STATUS_OK;
2851
2852         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
2853                 return cli_smb2_close_fnum(cli, fnum);
2854         }
2855
2856         frame = talloc_stackframe();
2857
2858         if (smbXcli_conn_has_async_calls(cli->conn)) {
2859                 /*
2860                  * Can't use sync call while an async call is in flight
2861                  */
2862                 status = NT_STATUS_INVALID_PARAMETER;
2863                 goto fail;
2864         }
2865
2866         ev = samba_tevent_context_init(frame);
2867         if (ev == NULL) {
2868                 status = NT_STATUS_NO_MEMORY;
2869                 goto fail;
2870         }
2871
2872         req = cli_close_send(frame, ev, cli, fnum);
2873         if (req == NULL) {
2874                 status = NT_STATUS_NO_MEMORY;
2875                 goto fail;
2876         }
2877
2878         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
2879                 goto fail;
2880         }
2881
2882         status = cli_close_recv(req);
2883  fail:
2884         TALLOC_FREE(frame);
2885         return status;
2886 }
2887
2888 /****************************************************************************
2889  Truncate a file to a specified size
2890 ****************************************************************************/
2891
2892 struct ftrunc_state {
2893         uint16_t setup;
2894         uint8_t param[6];
2895         uint8_t data[8];
2896 };
2897
2898 static void cli_ftruncate_done(struct tevent_req *subreq)
2899 {
2900         NTSTATUS status = cli_trans_recv(subreq, NULL, NULL, NULL, 0, NULL,
2901                                          NULL, 0, NULL, NULL, 0, NULL);
2902         tevent_req_simple_finish_ntstatus(subreq, status);
2903 }
2904
2905 struct tevent_req *cli_ftruncate_send(TALLOC_CTX *mem_ctx,
2906                                         struct tevent_context *ev,
2907                                         struct cli_state *cli,
2908                                         uint16_t fnum,
2909                                         uint64_t size)
2910 {
2911         struct tevent_req *req = NULL, *subreq = NULL;
2912         struct ftrunc_state *state = NULL;
2913
2914         req = tevent_req_create(mem_ctx, &state, struct ftrunc_state);
2915         if (req == NULL) {
2916                 return NULL;
2917         }
2918
2919         /* Setup setup word. */
2920         SSVAL(&state->setup, 0, TRANSACT2_SETFILEINFO);
2921
2922         /* Setup param array. */
2923         SSVAL(state->param,0,fnum);
2924         SSVAL(state->param,2,SMB_SET_FILE_END_OF_FILE_INFO);
2925         SSVAL(state->param,4,0);
2926
2927         /* Setup data array. */
2928         SBVAL(state->data, 0, size);
2929
2930         subreq = cli_trans_send(state,                  /* mem ctx. */
2931                                 ev,                     /* event ctx. */
2932                                 cli,                    /* cli_state. */
2933                                 0,                      /* additional_flags2 */
2934                                 SMBtrans2,              /* cmd. */
2935                                 NULL,                   /* pipe name. */
2936                                 -1,                     /* fid. */
2937                                 0,                      /* function. */
2938                                 0,                      /* flags. */
2939                                 &state->setup,          /* setup. */
2940                                 1,                      /* num setup uint16_t words. */
2941                                 0,                      /* max returned setup. */
2942                                 state->param,           /* param. */
2943                                 6,                      /* num param. */
2944                                 2,                      /* max returned param. */
2945                                 state->data,            /* data. */
2946                                 8,                      /* num data. */
2947                                 0);                     /* max returned data. */
2948
2949         if (tevent_req_nomem(subreq, req)) {
2950                 return tevent_req_post(req, ev);
2951         }
2952         tevent_req_set_callback(subreq, cli_ftruncate_done, req);
2953         return req;
2954 }
2955
2956 NTSTATUS cli_ftruncate_recv(struct tevent_req *req)
2957 {
2958         return tevent_req_simple_recv_ntstatus(req);
2959 }
2960
2961 NTSTATUS cli_ftruncate(struct cli_state *cli, uint16_t fnum, uint64_t size)
2962 {
2963         TALLOC_CTX *frame = NULL;
2964         struct tevent_context *ev = NULL;
2965         struct tevent_req *req = NULL;
2966         NTSTATUS status = NT_STATUS_OK;
2967
2968         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
2969                 return cli_smb2_ftruncate(cli, fnum, size);
2970         }
2971
2972         frame = talloc_stackframe();
2973
2974         if (smbXcli_conn_has_async_calls(cli->conn)) {
2975                 /*
2976                  * Can't use sync call while an async call is in flight
2977                  */
2978                 status = NT_STATUS_INVALID_PARAMETER;
2979                 goto fail;
2980         }
2981
2982         ev = samba_tevent_context_init(frame);
2983         if (ev == NULL) {
2984                 status = NT_STATUS_NO_MEMORY;
2985                 goto fail;
2986         }
2987
2988         req = cli_ftruncate_send(frame,
2989                                 ev,
2990                                 cli,
2991                                 fnum,
2992                                 size);
2993         if (req == NULL) {
2994                 status = NT_STATUS_NO_MEMORY;
2995                 goto fail;
2996         }
2997
2998         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
2999                 goto fail;
3000         }
3001
3002         status = cli_ftruncate_recv(req);
3003
3004  fail:
3005         TALLOC_FREE(frame);
3006         return status;
3007 }
3008
3009 /****************************************************************************
3010  send a lock with a specified locktype
3011  this is used for testing LOCKING_ANDX_CANCEL_LOCK
3012 ****************************************************************************/
3013
3014 NTSTATUS cli_locktype(struct cli_state *cli, uint16_t fnum,
3015                       uint32_t offset, uint32_t len,
3016                       int timeout, unsigned char locktype)
3017 {
3018         uint16_t vwv[8];
3019         uint8_t bytes[10];
3020         NTSTATUS status;
3021         unsigned int set_timeout = 0;
3022         unsigned int saved_timeout = 0;
3023
3024         SCVAL(vwv + 0, 0, 0xff);
3025         SCVAL(vwv + 0, 1, 0);
3026         SSVAL(vwv + 1, 0, 0);
3027         SSVAL(vwv + 2, 0, fnum);
3028         SCVAL(vwv + 3, 0, locktype);
3029         SCVAL(vwv + 3, 1, 0);
3030         SIVALS(vwv + 4, 0, timeout);
3031         SSVAL(vwv + 6, 0, 0);
3032         SSVAL(vwv + 7, 0, 1);
3033
3034         SSVAL(bytes, 0, cli_getpid(cli));
3035         SIVAL(bytes, 2, offset);
3036         SIVAL(bytes, 6, len);
3037
3038         if (timeout != 0) {
3039                 if (timeout == -1) {
3040                         set_timeout = 0x7FFFFFFF;
3041                 } else {
3042                         set_timeout = timeout + 2*1000;
3043                 }
3044                 saved_timeout = cli_set_timeout(cli, set_timeout);
3045         }
3046
3047         status = cli_smb(talloc_tos(), cli, SMBlockingX, 0, 8, vwv,
3048                          10, bytes, NULL, 0, NULL, NULL, NULL, NULL);
3049
3050         if (saved_timeout != 0) {
3051                 cli_set_timeout(cli, saved_timeout);
3052         }
3053
3054         return status;
3055 }
3056
3057 /****************************************************************************
3058  Lock a file.
3059  note that timeout is in units of 2 milliseconds
3060 ****************************************************************************/
3061
3062 NTSTATUS cli_lock32(struct cli_state *cli, uint16_t fnum,
3063                   uint32_t offset, uint32_t len, int timeout,
3064                   enum brl_type lock_type)
3065 {
3066         NTSTATUS status;
3067
3068         status = cli_locktype(cli, fnum, offset, len, timeout,
3069                               (lock_type == READ_LOCK? 1 : 0));
3070         return status;
3071 }
3072
3073 /****************************************************************************
3074  Unlock a file.
3075 ****************************************************************************/
3076
3077 struct cli_unlock_state {
3078         uint16_t vwv[8];
3079         uint8_t data[10];
3080 };
3081
3082 static void cli_unlock_done(struct tevent_req *subreq);
3083
3084 struct tevent_req *cli_unlock_send(TALLOC_CTX *mem_ctx,
3085                                 struct tevent_context *ev,
3086                                 struct cli_state *cli,
3087                                 uint16_t fnum,
3088                                 uint64_t offset,
3089                                 uint64_t len)
3090
3091 {
3092         struct tevent_req *req = NULL, *subreq = NULL;
3093         struct cli_unlock_state *state = NULL;
3094         uint8_t additional_flags = 0;
3095
3096         req = tevent_req_create(mem_ctx, &state, struct cli_unlock_state);
3097         if (req == NULL) {
3098                 return NULL;
3099         }
3100
3101         SCVAL(state->vwv+0, 0, 0xFF);
3102         SSVAL(state->vwv+2, 0, fnum);
3103         SCVAL(state->vwv+3, 0, 0);
3104         SIVALS(state->vwv+4, 0, 0);
3105         SSVAL(state->vwv+6, 0, 1);
3106         SSVAL(state->vwv+7, 0, 0);
3107
3108         SSVAL(state->data, 0, cli_getpid(cli));
3109         SIVAL(state->data, 2, offset);
3110         SIVAL(state->data, 6, len);
3111
3112         subreq = cli_smb_send(state, ev, cli, SMBlockingX, additional_flags, 0,
3113                                 8, state->vwv, 10, state->data);
3114         if (tevent_req_nomem(subreq, req)) {
3115                 return tevent_req_post(req, ev);
3116         }
3117         tevent_req_set_callback(subreq, cli_unlock_done, req);
3118         return req;
3119 }
3120
3121 static void cli_unlock_done(struct tevent_req *subreq)
3122 {
3123         struct tevent_req *req = tevent_req_callback_data(
3124                                 subreq, struct tevent_req);
3125         NTSTATUS status;
3126
3127         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
3128         TALLOC_FREE(subreq);
3129         if (tevent_req_nterror(req, status)) {
3130                 return;
3131         }
3132         tevent_req_done(req);
3133 }
3134
3135 NTSTATUS cli_unlock_recv(struct tevent_req *req)
3136 {
3137         return tevent_req_simple_recv_ntstatus(req);
3138 }
3139
3140 NTSTATUS cli_unlock(struct cli_state *cli,
3141                         uint16_t fnum,
3142                         uint32_t offset,
3143                         uint32_t len)
3144 {
3145         TALLOC_CTX *frame = talloc_stackframe();
3146         struct tevent_context *ev;
3147         struct tevent_req *req;
3148         NTSTATUS status = NT_STATUS_OK;
3149
3150         if (smbXcli_conn_has_async_calls(cli->conn)) {
3151                 /*
3152                  * Can't use sync call while an async call is in flight
3153                  */
3154                 status = NT_STATUS_INVALID_PARAMETER;
3155                 goto fail;
3156         }
3157
3158         ev = samba_tevent_context_init(frame);
3159         if (ev == NULL) {
3160                 status = NT_STATUS_NO_MEMORY;
3161                 goto fail;
3162         }
3163
3164         req = cli_unlock_send(frame, ev, cli,
3165                         fnum, offset, len);
3166         if (req == NULL) {
3167                 status = NT_STATUS_NO_MEMORY;
3168                 goto fail;
3169         }
3170
3171         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
3172                 goto fail;
3173         }
3174
3175         status = cli_unlock_recv(req);
3176
3177  fail:
3178         TALLOC_FREE(frame);
3179         return status;
3180 }
3181
3182 /****************************************************************************
3183  Lock a file with 64 bit offsets.
3184 ****************************************************************************/
3185
3186 NTSTATUS cli_lock64(struct cli_state *cli, uint16_t fnum,
3187                     uint64_t offset, uint64_t len, int timeout,
3188                     enum brl_type lock_type)
3189 {
3190         uint16_t vwv[8];
3191         uint8_t bytes[20];
3192         unsigned int set_timeout = 0;
3193         unsigned int saved_timeout = 0;
3194         int ltype;
3195         NTSTATUS status;
3196
3197         if (! (smb1cli_conn_capabilities(cli->conn) & CAP_LARGE_FILES)) {
3198                 return cli_lock32(cli, fnum, offset, len, timeout, lock_type);
3199         }
3200
3201         ltype = (lock_type == READ_LOCK? 1 : 0);
3202         ltype |= LOCKING_ANDX_LARGE_FILES;
3203
3204         SCVAL(vwv + 0, 0, 0xff);
3205         SCVAL(vwv + 0, 1, 0);
3206         SSVAL(vwv + 1, 0, 0);
3207         SSVAL(vwv + 2, 0, fnum);
3208         SCVAL(vwv + 3, 0, ltype);
3209         SCVAL(vwv + 3, 1, 0);
3210         SIVALS(vwv + 4, 0, timeout);
3211         SSVAL(vwv + 6, 0, 0);
3212         SSVAL(vwv + 7, 0, 1);
3213
3214         SIVAL(bytes, 0, cli_getpid(cli));
3215         SOFF_T_R(bytes, 4, offset);
3216         SOFF_T_R(bytes, 12, len);
3217
3218         if (timeout != 0) {
3219                 if (timeout == -1) {
3220                         set_timeout = 0x7FFFFFFF;
3221                 } else {
3222                         set_timeout = timeout + 2*1000;
3223                 }
3224                 saved_timeout = cli_set_timeout(cli, set_timeout);
3225         }
3226
3227         status = cli_smb(talloc_tos(), cli, SMBlockingX, 0, 8, vwv,
3228                          20, bytes, NULL, 0, NULL, NULL, NULL, NULL);
3229
3230         if (saved_timeout != 0) {
3231                 cli_set_timeout(cli, saved_timeout);
3232         }
3233
3234         return status;
3235 }
3236
3237 /****************************************************************************
3238  Unlock a file with 64 bit offsets.
3239 ****************************************************************************/
3240
3241 struct cli_unlock64_state {
3242         uint16_t vwv[8];
3243         uint8_t data[20];
3244 };
3245
3246 static void cli_unlock64_done(struct tevent_req *subreq);
3247
3248 struct tevent_req *cli_unlock64_send(TALLOC_CTX *mem_ctx,
3249                                 struct tevent_context *ev,
3250                                 struct cli_state *cli,
3251                                 uint16_t fnum,
3252                                 uint64_t offset,
3253                                 uint64_t len)
3254
3255 {
3256         struct tevent_req *req = NULL, *subreq = NULL;
3257         struct cli_unlock64_state *state = NULL;
3258         uint8_t additional_flags = 0;
3259
3260         req = tevent_req_create(mem_ctx, &state, struct cli_unlock64_state);
3261         if (req == NULL) {
3262                 return NULL;
3263         }
3264
3265         SCVAL(state->vwv+0, 0, 0xff);
3266         SSVAL(state->vwv+2, 0, fnum);
3267         SCVAL(state->vwv+3, 0,LOCKING_ANDX_LARGE_FILES);
3268         SIVALS(state->vwv+4, 0, 0);
3269         SSVAL(state->vwv+6, 0, 1);
3270         SSVAL(state->vwv+7, 0, 0);
3271
3272         SIVAL(state->data, 0, cli_getpid(cli));
3273         SOFF_T_R(state->data, 4, offset);
3274         SOFF_T_R(state->data, 12, len);
3275
3276         subreq = cli_smb_send(state, ev, cli, SMBlockingX, additional_flags, 0,
3277                                 8, state->vwv, 20, state->data);
3278         if (tevent_req_nomem(subreq, req)) {
3279                 return tevent_req_post(req, ev);
3280         }
3281         tevent_req_set_callback(subreq, cli_unlock64_done, req);
3282         return req;
3283 }
3284
3285 static void cli_unlock64_done(struct tevent_req *subreq)
3286 {
3287         struct tevent_req *req = tevent_req_callback_data(
3288                                 subreq, struct tevent_req);
3289         NTSTATUS status;
3290
3291         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
3292         TALLOC_FREE(subreq);
3293         if (tevent_req_nterror(req, status)) {
3294                 return;
3295         }
3296         tevent_req_done(req);
3297 }
3298
3299 NTSTATUS cli_unlock64_recv(struct tevent_req *req)
3300 {
3301         return tevent_req_simple_recv_ntstatus(req);
3302 }
3303
3304 NTSTATUS cli_unlock64(struct cli_state *cli,
3305                                 uint16_t fnum,
3306                                 uint64_t offset,
3307                                 uint64_t len)
3308 {
3309         TALLOC_CTX *frame = talloc_stackframe();
3310         struct tevent_context *ev;
3311         struct tevent_req *req;
3312         NTSTATUS status = NT_STATUS_OK;
3313
3314         if (! (smb1cli_conn_capabilities(cli->conn) & CAP_LARGE_FILES)) {
3315                 return cli_unlock(cli, fnum, offset, len);
3316         }
3317
3318         if (smbXcli_conn_has_async_calls(cli->conn)) {
3319                 /*
3320                  * Can't use sync call while an async call is in flight
3321                  */
3322                 status = NT_STATUS_INVALID_PARAMETER;
3323                 goto fail;
3324         }
3325
3326         ev = samba_tevent_context_init(frame);
3327         if (ev == NULL) {
3328                 status = NT_STATUS_NO_MEMORY;
3329                 goto fail;
3330         }
3331
3332         req = cli_unlock64_send(frame, ev, cli,
3333                         fnum, offset, len);
3334         if (req == NULL) {
3335                 status = NT_STATUS_NO_MEMORY;
3336                 goto fail;
3337         }
3338
3339         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
3340                 goto fail;
3341         }
3342
3343         status = cli_unlock64_recv(req);
3344
3345  fail:
3346         TALLOC_FREE(frame);
3347         return status;
3348 }
3349
3350 /****************************************************************************
3351  Get/unlock a POSIX lock on a file - internal function.
3352 ****************************************************************************/
3353
3354 struct posix_lock_state {
3355         uint16_t setup;
3356         uint8_t param[4];
3357         uint8_t data[POSIX_LOCK_DATA_SIZE];
3358 };
3359
3360 static void cli_posix_unlock_internal_done(struct tevent_req *subreq)
3361 {
3362         NTSTATUS status = cli_trans_recv(subreq, NULL, NULL, NULL, 0, NULL,
3363                                          NULL, 0, NULL, NULL, 0, NULL);
3364         tevent_req_simple_finish_ntstatus(subreq, status);
3365 }
3366
3367 static struct tevent_req *cli_posix_lock_internal_send(TALLOC_CTX *mem_ctx,
3368                                         struct tevent_context *ev,
3369                                         struct cli_state *cli,
3370                                         uint16_t fnum,
3371                                         uint64_t offset,
3372                                         uint64_t len,
3373                                         bool wait_lock,
3374                                         enum brl_type lock_type)
3375 {
3376         struct tevent_req *req = NULL, *subreq = NULL;
3377         struct posix_lock_state *state = NULL;
3378
3379         req = tevent_req_create(mem_ctx, &state, struct posix_lock_state);
3380         if (req == NULL) {
3381                 return NULL;
3382         }
3383
3384         /* Setup setup word. */
3385         SSVAL(&state->setup, 0, TRANSACT2_SETFILEINFO);
3386
3387         /* Setup param array. */
3388         SSVAL(&state->param, 0, fnum);
3389         SSVAL(&state->param, 2, SMB_SET_POSIX_LOCK);
3390
3391         /* Setup data array. */
3392         switch (lock_type) {
3393                 case READ_LOCK:
3394                         SSVAL(&state->data, POSIX_LOCK_TYPE_OFFSET,
3395                                 POSIX_LOCK_TYPE_READ);
3396                         break;
3397                 case WRITE_LOCK:
3398                         SSVAL(&state->data, POSIX_LOCK_TYPE_OFFSET,
3399                                 POSIX_LOCK_TYPE_WRITE);
3400                         break;
3401                 case UNLOCK_LOCK:
3402                         SSVAL(&state->data, POSIX_LOCK_TYPE_OFFSET,
3403                                 POSIX_LOCK_TYPE_UNLOCK);
3404                         break;
3405                 default:
3406                         return NULL;
3407         }
3408
3409         if (wait_lock) {
3410                 SSVAL(&state->data, POSIX_LOCK_FLAGS_OFFSET,
3411                                 POSIX_LOCK_FLAG_WAIT);
3412         } else {
3413                 SSVAL(state->data, POSIX_LOCK_FLAGS_OFFSET,
3414                                 POSIX_LOCK_FLAG_NOWAIT);
3415         }
3416
3417         SIVAL(&state->data, POSIX_LOCK_PID_OFFSET, cli_getpid(cli));
3418         SOFF_T(&state->data, POSIX_LOCK_START_OFFSET, offset);
3419         SOFF_T(&state->data, POSIX_LOCK_LEN_OFFSET, len);
3420
3421         subreq = cli_trans_send(state,                  /* mem ctx. */
3422                                 ev,                     /* event ctx. */
3423                                 cli,                    /* cli_state. */
3424                                 0,                      /* additional_flags2 */
3425                                 SMBtrans2,              /* cmd. */
3426                                 NULL,                   /* pipe name. */
3427                                 -1,                     /* fid. */
3428                                 0,                      /* function. */
3429                                 0,                      /* flags. */
3430                                 &state->setup,          /* setup. */
3431                                 1,                      /* num setup uint16_t words. */
3432                                 0,                      /* max returned setup. */
3433                                 state->param,           /* param. */
3434                                 4,                      /* num param. */
3435                                 2,                      /* max returned param. */
3436                                 state->data,            /* data. */
3437                                 POSIX_LOCK_DATA_SIZE,   /* num data. */
3438                                 0);                     /* max returned data. */
3439
3440         if (tevent_req_nomem(subreq, req)) {
3441                 return tevent_req_post(req, ev);
3442         }
3443         tevent_req_set_callback(subreq, cli_posix_unlock_internal_done, req);
3444         return req;
3445 }
3446
3447 /****************************************************************************
3448  POSIX Lock a file.
3449 ****************************************************************************/
3450
3451 struct tevent_req *cli_posix_lock_send(TALLOC_CTX *mem_ctx,
3452                                         struct tevent_context *ev,
3453                                         struct cli_state *cli,
3454                                         uint16_t fnum,
3455                                         uint64_t offset,
3456                                         uint64_t len,
3457                                         bool wait_lock,
3458                                         enum brl_type lock_type)
3459 {
3460         return cli_posix_lock_internal_send(mem_ctx, ev, cli, fnum, offset, len,
3461                                         wait_lock, lock_type);
3462 }
3463
3464 NTSTATUS cli_posix_lock_recv(struct tevent_req *req)
3465 {
3466         return tevent_req_simple_recv_ntstatus(req);
3467 }
3468
3469 NTSTATUS cli_posix_lock(struct cli_state *cli, uint16_t fnum,
3470                         uint64_t offset, uint64_t len,
3471                         bool wait_lock, enum brl_type lock_type)
3472 {
3473         TALLOC_CTX *frame = talloc_stackframe();
3474         struct tevent_context *ev = NULL;
3475         struct tevent_req *req = NULL;
3476         NTSTATUS status = NT_STATUS_OK;
3477
3478         if (smbXcli_conn_has_async_calls(cli->conn)) {
3479                 /*
3480                  * Can't use sync call while an async call is in flight
3481                  */
3482                 status = NT_STATUS_INVALID_PARAMETER;
3483                 goto fail;
3484         }
3485
3486         if (lock_type != READ_LOCK && lock_type != WRITE_LOCK) {
3487                 status = NT_STATUS_INVALID_PARAMETER;
3488                 goto fail;
3489         }
3490
3491         ev = samba_tevent_context_init(frame);
3492         if (ev == NULL) {
3493                 status = NT_STATUS_NO_MEMORY;
3494                 goto fail;
3495         }
3496
3497         req = cli_posix_lock_send(frame,
3498                                 ev,
3499                                 cli,
3500                                 fnum,
3501                                 offset,
3502                                 len,
3503                                 wait_lock,
3504                                 lock_type);
3505         if (req == NULL) {
3506                 status = NT_STATUS_NO_MEMORY;
3507                 goto fail;
3508         }
3509
3510         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
3511                 goto fail;
3512         }
3513
3514         status = cli_posix_lock_recv(req);
3515
3516  fail:
3517         TALLOC_FREE(frame);
3518         return status;
3519 }
3520
3521 /****************************************************************************
3522  POSIX Unlock a file.
3523 ****************************************************************************/
3524
3525 struct tevent_req *cli_posix_unlock_send(TALLOC_CTX *mem_ctx,
3526                                         struct tevent_context *ev,
3527                                         struct cli_state *cli,
3528                                         uint16_t fnum,
3529                                         uint64_t offset,
3530                                         uint64_t len)
3531 {
3532         return cli_posix_lock_internal_send(mem_ctx, ev, cli, fnum, offset, len,
3533                                         false, UNLOCK_LOCK);
3534 }
3535
3536 NTSTATUS cli_posix_unlock_recv(struct tevent_req *req)
3537 {
3538         return tevent_req_simple_recv_ntstatus(req);
3539 }
3540
3541 NTSTATUS cli_posix_unlock(struct cli_state *cli, uint16_t fnum, uint64_t offset, uint64_t len)
3542 {
3543         TALLOC_CTX *frame = talloc_stackframe();
3544         struct tevent_context *ev = NULL;
3545         struct tevent_req *req = NULL;
3546         NTSTATUS status = NT_STATUS_OK;
3547
3548         if (smbXcli_conn_has_async_calls(cli->conn)) {
3549                 /*
3550                  * Can't use sync call while an async call is in flight
3551                  */
3552                 status = NT_STATUS_INVALID_PARAMETER;
3553                 goto fail;
3554         }
3555
3556         ev = samba_tevent_context_init(frame);
3557         if (ev == NULL) {
3558                 status = NT_STATUS_NO_MEMORY;
3559                 goto fail;
3560         }
3561
3562         req = cli_posix_unlock_send(frame,
3563                                 ev,
3564                                 cli,
3565                                 fnum,
3566                                 offset,
3567                                 len);
3568         if (req == NULL) {
3569                 status = NT_STATUS_NO_MEMORY;
3570                 goto fail;
3571         }
3572
3573         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
3574                 goto fail;
3575         }
3576
3577         status = cli_posix_unlock_recv(req);
3578
3579  fail:
3580         TALLOC_FREE(frame);
3581         return status;
3582 }
3583
3584 /****************************************************************************
3585  Do a SMBgetattrE call.
3586 ****************************************************************************/
3587
3588 static void cli_getattrE_done(struct tevent_req *subreq);
3589
3590 struct cli_getattrE_state {
3591         uint16_t vwv[1];
3592         int zone_offset;
3593         uint16_t attr;
3594         off_t size;
3595         time_t change_time;
3596         time_t access_time;
3597         time_t write_time;
3598 };
3599
3600 struct tevent_req *cli_getattrE_send(TALLOC_CTX *mem_ctx,
3601                                 struct tevent_context *ev,
3602                                 struct cli_state *cli,
3603                                 uint16_t fnum)
3604 {
3605         struct tevent_req *req = NULL, *subreq = NULL;
3606         struct cli_getattrE_state *state = NULL;
3607         uint8_t additional_flags = 0;
3608
3609         req = tevent_req_create(mem_ctx, &state, struct cli_getattrE_state);
3610         if (req == NULL) {
3611                 return NULL;
3612         }
3613
3614         state->zone_offset = smb1cli_conn_server_time_zone(cli->conn);
3615         SSVAL(state->vwv+0,0,fnum);
3616
3617         subreq = cli_smb_send(state, ev, cli, SMBgetattrE, additional_flags, 0,
3618                               1, state->vwv, 0, NULL);
3619         if (tevent_req_nomem(subreq, req)) {
3620                 return tevent_req_post(req, ev);
3621         }
3622         tevent_req_set_callback(subreq, cli_getattrE_done, req);
3623         return req;
3624 }
3625
3626 static void cli_getattrE_done(struct tevent_req *subreq)
3627 {
3628         struct tevent_req *req = tevent_req_callback_data(
3629                 subreq, struct tevent_req);
3630         struct cli_getattrE_state *state = tevent_req_data(
3631                 req, struct cli_getattrE_state);
3632         uint8_t wct;
3633         uint16_t *vwv = NULL;
3634         NTSTATUS status;
3635
3636         status = cli_smb_recv(subreq, state, NULL, 11, &wct, &vwv,
3637                               NULL, NULL);
3638         TALLOC_FREE(subreq);
3639         if (tevent_req_nterror(req, status)) {
3640                 return;
3641         }
3642
3643         state->size = (off_t)IVAL(vwv+6,0);
3644         state->attr = SVAL(vwv+10,0);
3645         state->change_time = make_unix_date2(vwv+0, state->zone_offset);
3646         state->access_time = make_unix_date2(vwv+2, state->zone_offset);
3647         state->write_time = make_unix_date2(vwv+4, state->zone_offset);
3648
3649         tevent_req_done(req);
3650 }
3651
3652 NTSTATUS cli_getattrE_recv(struct tevent_req *req,
3653                         uint16_t *attr,
3654                         off_t *size,
3655                         time_t *change_time,
3656                         time_t *access_time,
3657                         time_t *write_time)
3658 {
3659         struct cli_getattrE_state *state = tevent_req_data(
3660                                 req, struct cli_getattrE_state);
3661         NTSTATUS status;
3662
3663         if (tevent_req_is_nterror(req, &status)) {
3664                 return status;
3665         }
3666         if (attr) {
3667                 *attr = state->attr;
3668         }
3669         if (size) {
3670                 *size = state->size;
3671         }
3672         if (change_time) {
3673                 *change_time = state->change_time;
3674         }
3675         if (access_time) {
3676                 *access_time = state->access_time;
3677         }
3678         if (write_time) {
3679                 *write_time = state->write_time;
3680         }
3681         return NT_STATUS_OK;
3682 }
3683
3684 NTSTATUS cli_getattrE(struct cli_state *cli,
3685                         uint16_t fnum,
3686                         uint16_t *attr,
3687                         off_t *size,
3688                         time_t *change_time,
3689                         time_t *access_time,
3690                         time_t *write_time)
3691 {
3692         TALLOC_CTX *frame = NULL;
3693         struct tevent_context *ev = NULL;
3694         struct tevent_req *req = NULL;
3695         NTSTATUS status = NT_STATUS_OK;
3696
3697         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
3698                 return cli_smb2_getattrE(cli,
3699                                         fnum,
3700                                         attr,
3701                                         size,
3702                                         change_time,
3703                                         access_time,
3704                                         write_time);
3705         }
3706
3707         frame = talloc_stackframe();
3708
3709         if (smbXcli_conn_has_async_calls(cli->conn)) {
3710                 /*
3711                  * Can't use sync call while an async call is in flight
3712                  */
3713                 status = NT_STATUS_INVALID_PARAMETER;
3714                 goto fail;
3715         }
3716
3717         ev = samba_tevent_context_init(frame);
3718         if (ev == NULL) {
3719                 status = NT_STATUS_NO_MEMORY;
3720                 goto fail;
3721         }
3722
3723         req = cli_getattrE_send(frame, ev, cli, fnum);
3724         if (req == NULL) {
3725                 status = NT_STATUS_NO_MEMORY;
3726                 goto fail;
3727         }
3728
3729         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
3730                 goto fail;
3731         }
3732
3733         status = cli_getattrE_recv(req,
3734                                         attr,
3735                                         size,
3736                                         change_time,
3737                                         access_time,
3738                                         write_time);
3739
3740  fail:
3741         TALLOC_FREE(frame);
3742         return status;
3743 }
3744
3745 /****************************************************************************
3746  Do a SMBgetatr call
3747 ****************************************************************************/
3748
3749 static void cli_getatr_done(struct tevent_req *subreq);
3750
3751 struct cli_getatr_state {
3752         int zone_offset;
3753         uint16_t attr;
3754         off_t size;
3755         time_t write_time;
3756 };
3757
3758 struct tevent_req *cli_getatr_send(TALLOC_CTX *mem_ctx,
3759                                 struct tevent_context *ev,
3760                                 struct cli_state *cli,
3761                                 const char *fname)
3762 {
3763         struct tevent_req *req = NULL, *subreq = NULL;
3764         struct cli_getatr_state *state = NULL;
3765         uint8_t additional_flags = 0;
3766         uint16_t additional_flags2 = 0;
3767         uint8_t *bytes = NULL;
3768
3769         req = tevent_req_create(mem_ctx, &state, struct cli_getatr_state);
3770         if (req == NULL) {
3771                 return NULL;
3772         }
3773
3774         state->zone_offset = smb1cli_conn_server_time_zone(cli->conn);
3775
3776         bytes = talloc_array(state, uint8_t, 1);
3777         if (tevent_req_nomem(bytes, req)) {
3778                 return tevent_req_post(req, ev);
3779         }
3780         bytes[0] = 4;
3781         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), fname,
3782                                    strlen(fname)+1, NULL);
3783
3784         if (tevent_req_nomem(bytes, req)) {
3785                 return tevent_req_post(req, ev);
3786         }
3787
3788         if (clistr_is_previous_version_path(fname, NULL, NULL, NULL)) {
3789                 additional_flags2 = FLAGS2_REPARSE_PATH;
3790         }
3791
3792         subreq = cli_smb_send(state, ev, cli, SMBgetatr, additional_flags,
3793                         additional_flags2,
3794                         0, NULL, talloc_get_size(bytes), bytes);
3795         if (tevent_req_nomem(subreq, req)) {
3796                 return tevent_req_post(req, ev);
3797         }
3798         tevent_req_set_callback(subreq, cli_getatr_done, req);
3799         return req;
3800 }
3801
3802 static void cli_getatr_done(struct tevent_req *subreq)
3803 {
3804         struct tevent_req *req = tevent_req_callback_data(
3805                 subreq, struct tevent_req);
3806         struct cli_getatr_state *state = tevent_req_data(
3807                 req, struct cli_getatr_state);
3808         uint8_t wct;
3809         uint16_t *vwv = NULL;
3810         NTSTATUS status;
3811
3812         status = cli_smb_recv(subreq, state, NULL, 4, &wct, &vwv, NULL,
3813                               NULL);
3814         TALLOC_FREE(subreq);
3815         if (tevent_req_nterror(req, status)) {
3816                 return;
3817         }
3818
3819         state->attr = SVAL(vwv+0,0);
3820         state->size = (off_t)IVAL(vwv+3,0);
3821         state->write_time = make_unix_date3(vwv+1, state->zone_offset);
3822
3823         tevent_req_done(req);
3824 }
3825
3826 NTSTATUS cli_getatr_recv(struct tevent_req *req,
3827                         uint16_t *attr,
3828                         off_t *size,
3829                         time_t *write_time)
3830 {
3831         struct cli_getatr_state *state = tevent_req_data(
3832                                 req, struct cli_getatr_state);
3833         NTSTATUS status;
3834
3835         if (tevent_req_is_nterror(req, &status)) {
3836                 return status;
3837         }
3838         if (attr) {
3839                 *attr = state->attr;
3840         }
3841         if (size) {
3842                 *size = state->size;
3843         }
3844         if (write_time) {
3845                 *write_time = state->write_time;
3846         }
3847         return NT_STATUS_OK;
3848 }
3849
3850 NTSTATUS cli_getatr(struct cli_state *cli,
3851                         const char *fname,
3852                         uint16_t *attr,
3853                         off_t *size,
3854                         time_t *write_time)
3855 {
3856         TALLOC_CTX *frame = NULL;
3857         struct tevent_context *ev = NULL;
3858         struct tevent_req *req = NULL;
3859         NTSTATUS status = NT_STATUS_OK;
3860
3861         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
3862                 return cli_smb2_getatr(cli,
3863                                         fname,
3864                                         attr,
3865                                         size,
3866                                         write_time);
3867         }
3868
3869         frame = talloc_stackframe();
3870
3871         if (smbXcli_conn_has_async_calls(cli->conn)) {
3872                 /*
3873                  * Can't use sync call while an async call is in flight
3874                  */
3875                 status = NT_STATUS_INVALID_PARAMETER;
3876                 goto fail;
3877         }
3878
3879         ev = samba_tevent_context_init(frame);
3880         if (ev == NULL) {
3881                 status = NT_STATUS_NO_MEMORY;
3882                 goto fail;
3883         }
3884
3885         req = cli_getatr_send(frame, ev, cli, fname);
3886         if (req == NULL) {
3887                 status = NT_STATUS_NO_MEMORY;
3888                 goto fail;
3889         }
3890
3891         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
3892                 goto fail;
3893         }
3894
3895         status = cli_getatr_recv(req,
3896                                 attr,
3897                                 size,
3898                                 write_time);
3899
3900  fail:
3901         TALLOC_FREE(frame);
3902         return status;
3903 }
3904
3905 /****************************************************************************
3906  Do a SMBsetattrE call.
3907 ****************************************************************************/
3908
3909 static void cli_setattrE_done(struct tevent_req *subreq);
3910
3911 struct cli_setattrE_state {
3912         uint16_t vwv[7];
3913 };
3914
3915 struct tevent_req *cli_setattrE_send(TALLOC_CTX *mem_ctx,
3916                                 struct tevent_context *ev,
3917                                 struct cli_state *cli,
3918                                 uint16_t fnum,
3919                                 time_t change_time,
3920                                 time_t access_time,
3921                                 time_t write_time)
3922 {
3923         struct tevent_req *req = NULL, *subreq = NULL;
3924         struct cli_setattrE_state *state = NULL;
3925         uint8_t additional_flags = 0;
3926
3927         req = tevent_req_create(mem_ctx, &state, struct cli_setattrE_state);
3928         if (req == NULL) {
3929                 return NULL;
3930         }
3931
3932         SSVAL(state->vwv+0, 0, fnum);
3933         push_dos_date2((uint8_t *)&state->vwv[1], 0, change_time,
3934                        smb1cli_conn_server_time_zone(cli->conn));
3935         push_dos_date2((uint8_t *)&state->vwv[3], 0, access_time,
3936                        smb1cli_conn_server_time_zone(cli->conn));
3937         push_dos_date2((uint8_t *)&state->vwv[5], 0, write_time,
3938                        smb1cli_conn_server_time_zone(cli->conn));
3939
3940         subreq = cli_smb_send(state, ev, cli, SMBsetattrE, additional_flags, 0,
3941                               7, state->vwv, 0, NULL);
3942         if (tevent_req_nomem(subreq, req)) {
3943                 return tevent_req_post(req, ev);
3944         }
3945         tevent_req_set_callback(subreq, cli_setattrE_done, req);
3946         return req;
3947 }
3948
3949 static void cli_setattrE_done(struct tevent_req *subreq)
3950 {
3951         struct tevent_req *req = tevent_req_callback_data(
3952                 subreq, struct tevent_req);
3953         NTSTATUS status;
3954
3955         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
3956         TALLOC_FREE(subreq);
3957         if (tevent_req_nterror(req, status)) {
3958                 return;
3959         }
3960         tevent_req_done(req);
3961 }
3962
3963 NTSTATUS cli_setattrE_recv(struct tevent_req *req)
3964 {
3965         return tevent_req_simple_recv_ntstatus(req);
3966 }
3967
3968 NTSTATUS cli_setattrE(struct cli_state *cli,
3969                         uint16_t fnum,
3970                         time_t change_time,
3971                         time_t access_time,
3972                         time_t write_time)
3973 {
3974         TALLOC_CTX *frame = NULL;
3975         struct tevent_context *ev = NULL;
3976         struct tevent_req *req = NULL;
3977         NTSTATUS status = NT_STATUS_OK;
3978
3979         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
3980                 return cli_smb2_setattrE(cli,
3981                                         fnum,
3982                                         change_time,
3983                                         access_time,
3984                                         write_time);
3985         }
3986
3987         frame = talloc_stackframe();
3988
3989         if (smbXcli_conn_has_async_calls(cli->conn)) {
3990                 /*
3991                  * Can't use sync call while an async call is in flight
3992                  */
3993                 status = NT_STATUS_INVALID_PARAMETER;
3994                 goto fail;
3995         }
3996
3997         ev = samba_tevent_context_init(frame);
3998         if (ev == NULL) {
3999                 status = NT_STATUS_NO_MEMORY;
4000                 goto fail;
4001         }
4002
4003         req = cli_setattrE_send(frame, ev,
4004                         cli,
4005                         fnum,
4006                         change_time,
4007                         access_time,
4008                         write_time);
4009
4010         if (req == NULL) {
4011                 status = NT_STATUS_NO_MEMORY;
4012                 goto fail;
4013         }
4014
4015         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
4016                 goto fail;
4017         }
4018
4019         status = cli_setattrE_recv(req);
4020
4021  fail:
4022         TALLOC_FREE(frame);
4023         return status;
4024 }
4025
4026 /****************************************************************************
4027  Do a SMBsetatr call.
4028 ****************************************************************************/
4029
4030 static void cli_setatr_done(struct tevent_req *subreq);
4031
4032 struct cli_setatr_state {
4033         uint16_t vwv[8];
4034 };
4035
4036 struct tevent_req *cli_setatr_send(TALLOC_CTX *mem_ctx,
4037                                 struct tevent_context *ev,
4038                                 struct cli_state *cli,
4039                                 const char *fname,
4040                                 uint16_t attr,
4041                                 time_t mtime)
4042 {
4043         struct tevent_req *req = NULL, *subreq = NULL;
4044         struct cli_setatr_state *state = NULL;
4045         uint8_t additional_flags = 0;
4046         uint16_t additional_flags2 = 0;
4047         uint8_t *bytes = NULL;
4048
4049         req = tevent_req_create(mem_ctx, &state, struct cli_setatr_state);
4050         if (req == NULL) {
4051                 return NULL;
4052         }
4053
4054         SSVAL(state->vwv+0, 0, attr);
4055         push_dos_date3((uint8_t *)&state->vwv[1], 0, mtime, smb1cli_conn_server_time_zone(cli->conn));
4056
4057         bytes = talloc_array(state, uint8_t, 1);
4058         if (tevent_req_nomem(bytes, req)) {
4059                 return tevent_req_post(req, ev);
4060         }
4061         bytes[0] = 4;
4062         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), fname,
4063                                    strlen(fname)+1, NULL);
4064         if (tevent_req_nomem(bytes, req)) {
4065                 return tevent_req_post(req, ev);
4066         }
4067         bytes = talloc_realloc(state, bytes, uint8_t,
4068                         talloc_get_size(bytes)+1);
4069         if (tevent_req_nomem(bytes, req)) {
4070                 return tevent_req_post(req, ev);
4071         }
4072
4073         bytes[talloc_get_size(bytes)-1] = 4;
4074         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), "",
4075                                    1, NULL);
4076         if (tevent_req_nomem(bytes, req)) {
4077                 return tevent_req_post(req, ev);
4078         }
4079
4080         if (clistr_is_previous_version_path(fname, NULL, NULL, NULL)) {
4081                 additional_flags2 = FLAGS2_REPARSE_PATH;
4082         }
4083
4084         subreq = cli_smb_send(state, ev, cli, SMBsetatr, additional_flags,
4085                         additional_flags2,
4086                         8, state->vwv, talloc_get_size(bytes), bytes);
4087         if (tevent_req_nomem(subreq, req)) {
4088                 return tevent_req_post(req, ev);
4089         }
4090         tevent_req_set_callback(subreq, cli_setatr_done, req);
4091         return req;
4092 }
4093
4094 static void cli_setatr_done(struct tevent_req *subreq)
4095 {
4096         struct tevent_req *req = tevent_req_callback_data(
4097                 subreq, struct tevent_req);
4098         NTSTATUS status;
4099
4100         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
4101         TALLOC_FREE(subreq);
4102         if (tevent_req_nterror(req, status)) {
4103                 return;
4104         }
4105         tevent_req_done(req);
4106 }
4107
4108 NTSTATUS cli_setatr_recv(struct tevent_req *req)
4109 {
4110         return tevent_req_simple_recv_ntstatus(req);
4111 }
4112
4113 NTSTATUS cli_setatr(struct cli_state *cli,
4114                 const char *fname,
4115                 uint16_t attr,
4116                 time_t mtime)
4117 {
4118         TALLOC_CTX *frame = NULL;
4119         struct tevent_context *ev = NULL;
4120         struct tevent_req *req = NULL;
4121         NTSTATUS status = NT_STATUS_OK;
4122
4123         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
4124                 return cli_smb2_setatr(cli,
4125                                         fname,
4126                                         attr,
4127                                         mtime);
4128         }
4129
4130         frame = talloc_stackframe();
4131
4132         if (smbXcli_conn_has_async_calls(cli->conn)) {
4133                 /*
4134                  * Can't use sync call while an async call is in flight
4135                  */
4136                 status = NT_STATUS_INVALID_PARAMETER;
4137                 goto fail;
4138         }
4139
4140         ev = samba_tevent_context_init(frame);
4141         if (ev == NULL) {
4142                 status = NT_STATUS_NO_MEMORY;
4143                 goto fail;
4144         }
4145
4146         req = cli_setatr_send(frame, ev, cli, fname, attr, mtime);
4147         if (req == NULL) {
4148                 status = NT_STATUS_NO_MEMORY;
4149                 goto fail;
4150         }
4151
4152         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
4153                 goto fail;
4154         }
4155
4156         status = cli_setatr_recv(req);
4157
4158  fail:
4159         TALLOC_FREE(frame);
4160         return status;
4161 }
4162
4163 /****************************************************************************
4164  Check for existence of a dir.
4165 ****************************************************************************/
4166
4167 static void cli_chkpath_done(struct tevent_req *subreq);
4168
4169 struct cli_chkpath_state {
4170         int dummy;
4171 };
4172
4173 struct tevent_req *cli_chkpath_send(TALLOC_CTX *mem_ctx,
4174                                   struct tevent_context *ev,
4175                                   struct cli_state *cli,
4176                                   const char *fname)
4177 {
4178         struct tevent_req *req = NULL, *subreq = NULL;
4179         struct cli_chkpath_state *state = NULL;
4180         uint8_t additional_flags = 0;
4181         uint16_t additional_flags2 = 0;
4182         uint8_t *bytes = NULL;
4183
4184         req = tevent_req_create(mem_ctx, &state, struct cli_chkpath_state);
4185         if (req == NULL) {
4186                 return NULL;
4187         }
4188
4189         bytes = talloc_array(state, uint8_t, 1);
4190         if (tevent_req_nomem(bytes, req)) {
4191                 return tevent_req_post(req, ev);
4192         }
4193         bytes[0] = 4;
4194         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), fname,
4195                                    strlen(fname)+1, NULL);
4196
4197         if (tevent_req_nomem(bytes, req)) {
4198                 return tevent_req_post(req, ev);
4199         }
4200
4201         if (clistr_is_previous_version_path(fname, NULL, NULL, NULL)) {
4202                 additional_flags2 = FLAGS2_REPARSE_PATH;
4203         }
4204
4205         subreq = cli_smb_send(state, ev, cli, SMBcheckpath, additional_flags,
4206                         additional_flags2,
4207                         0, NULL, talloc_get_size(bytes), bytes);
4208         if (tevent_req_nomem(subreq, req)) {
4209                 return tevent_req_post(req, ev);
4210         }
4211         tevent_req_set_callback(subreq, cli_chkpath_done, req);
4212         return req;
4213 }
4214
4215 static void cli_chkpath_done(struct tevent_req *subreq)
4216 {
4217         struct tevent_req *req = tevent_req_callback_data(
4218                 subreq, struct tevent_req);
4219         NTSTATUS status;
4220
4221         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
4222         TALLOC_FREE(subreq);
4223         if (tevent_req_nterror(req, status)) {
4224                 return;
4225         }
4226         tevent_req_done(req);
4227 }
4228
4229 NTSTATUS cli_chkpath_recv(struct tevent_req *req)
4230 {
4231         return tevent_req_simple_recv_ntstatus(req);
4232 }
4233
4234 NTSTATUS cli_chkpath(struct cli_state *cli, const char *path)
4235 {
4236         TALLOC_CTX *frame = NULL;
4237         struct tevent_context *ev = NULL;
4238         struct tevent_req *req = NULL;
4239         char *path2 = NULL;
4240         NTSTATUS status = NT_STATUS_OK;
4241
4242         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
4243                 return cli_smb2_chkpath(cli, path);
4244         }
4245
4246         frame = talloc_stackframe();
4247
4248         if (smbXcli_conn_has_async_calls(cli->conn)) {
4249                 /*
4250                  * Can't use sync call while an async call is in flight
4251                  */
4252                 status = NT_STATUS_INVALID_PARAMETER;
4253                 goto fail;
4254         }
4255
4256         path2 = talloc_strdup(frame, path);
4257         if (!path2) {
4258                 status = NT_STATUS_NO_MEMORY;
4259                 goto fail;
4260         }
4261         trim_char(path2,'\0','\\');
4262         if (!*path2) {
4263                 path2 = talloc_strdup(frame, "\\");
4264                 if (!path2) {
4265                         status = NT_STATUS_NO_MEMORY;
4266                         goto fail;
4267                 }
4268         }
4269
4270         ev = samba_tevent_context_init(frame);
4271         if (ev == NULL) {
4272                 status = NT_STATUS_NO_MEMORY;
4273                 goto fail;
4274         }
4275
4276         req = cli_chkpath_send(frame, ev, cli, path2);
4277         if (req == NULL) {
4278                 status = NT_STATUS_NO_MEMORY;
4279                 goto fail;
4280         }
4281
4282         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
4283                 goto fail;
4284         }
4285
4286         status = cli_chkpath_recv(req);
4287
4288  fail:
4289         TALLOC_FREE(frame);
4290         return status;
4291 }
4292
4293 /****************************************************************************
4294  Query disk space.
4295 ****************************************************************************/
4296
4297 static void cli_dskattr_done(struct tevent_req *subreq);
4298
4299 struct cli_dskattr_state {
4300         int bsize;
4301         int total;
4302         int avail;
4303 };
4304
4305 struct tevent_req *cli_dskattr_send(TALLOC_CTX *mem_ctx,
4306                                   struct tevent_context *ev,
4307                                   struct cli_state *cli)
4308 {
4309         struct tevent_req *req = NULL, *subreq = NULL;
4310         struct cli_dskattr_state *state = NULL;
4311         uint8_t additional_flags = 0;
4312
4313         req = tevent_req_create(mem_ctx, &state, struct cli_dskattr_state);
4314         if (req == NULL) {
4315                 return NULL;
4316         }
4317
4318         subreq = cli_smb_send(state, ev, cli, SMBdskattr, additional_flags, 0,
4319                               0, NULL, 0, NULL);
4320         if (tevent_req_nomem(subreq, req)) {
4321                 return tevent_req_post(req, ev);
4322         }
4323         tevent_req_set_callback(subreq, cli_dskattr_done, req);
4324         return req;
4325 }
4326
4327 static void cli_dskattr_done(struct tevent_req *subreq)
4328 {
4329         struct tevent_req *req = tevent_req_callback_data(
4330                 subreq, struct tevent_req);
4331         struct cli_dskattr_state *state = tevent_req_data(
4332                 req, struct cli_dskattr_state);
4333         uint8_t wct;
4334         uint16_t *vwv = NULL;
4335         NTSTATUS status;
4336
4337         status = cli_smb_recv(subreq, state, NULL, 4, &wct, &vwv, NULL,
4338                               NULL);
4339         TALLOC_FREE(subreq);
4340         if (tevent_req_nterror(req, status)) {
4341                 return;
4342         }
4343         state->bsize = SVAL(vwv+1, 0)*SVAL(vwv+2,0);
4344         state->total = SVAL(vwv+0, 0);
4345         state->avail = SVAL(vwv+3, 0);
4346         tevent_req_done(req);
4347 }
4348
4349 NTSTATUS cli_dskattr_recv(struct tevent_req *req, int *bsize, int *total, int *avail)
4350 {
4351         struct cli_dskattr_state *state = tevent_req_data(
4352                                 req, struct cli_dskattr_state);
4353         NTSTATUS status;
4354
4355         if (tevent_req_is_nterror(req, &status)) {
4356                 return status;
4357         }
4358         *bsize = state->bsize;
4359         *total = state->total;
4360         *avail = state->avail;
4361         return NT_STATUS_OK;
4362 }
4363
4364 NTSTATUS cli_dskattr(struct cli_state *cli, int *bsize, int *total, int *avail)
4365 {
4366         TALLOC_CTX *frame = NULL;
4367         struct tevent_context *ev = NULL;
4368         struct tevent_req *req = NULL;
4369         NTSTATUS status = NT_STATUS_OK;
4370
4371         frame = talloc_stackframe();
4372
4373         if (smbXcli_conn_has_async_calls(cli->conn)) {
4374                 /*
4375                  * Can't use sync call while an async call is in flight
4376                  */
4377                 status = NT_STATUS_INVALID_PARAMETER;
4378                 goto fail;
4379         }
4380
4381         ev = samba_tevent_context_init(frame);
4382         if (ev == NULL) {
4383                 status = NT_STATUS_NO_MEMORY;
4384                 goto fail;
4385         }
4386
4387         req = cli_dskattr_send(frame, ev, cli);
4388         if (req == NULL) {
4389                 status = NT_STATUS_NO_MEMORY;
4390                 goto fail;
4391         }
4392
4393         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
4394                 goto fail;
4395         }
4396
4397         status = cli_dskattr_recv(req, bsize, total, avail);
4398
4399  fail:
4400         TALLOC_FREE(frame);
4401         return status;
4402 }
4403
4404 NTSTATUS cli_disk_size(struct cli_state *cli, const char *path, uint64_t *bsize,
4405                        uint64_t *total, uint64_t *avail)
4406 {
4407         uint64_t sectors_per_block;
4408         uint64_t bytes_per_sector;
4409         int old_bsize, old_total, old_avail;
4410         NTSTATUS status;
4411
4412         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
4413                 return cli_smb2_dskattr(cli, path, bsize, total, avail);
4414         }
4415
4416         /*
4417          * Try the trans2 disk full size info call first.
4418          * We already use this in SMBC_fstatvfs_ctx().
4419          * Ignore 'actual_available_units' as we only
4420          * care about the quota for the caller.
4421          */
4422
4423         status = cli_get_fs_full_size_info(cli,
4424                         total,
4425                         avail,
4426                         NULL,
4427                         &sectors_per_block,
4428                         &bytes_per_sector);
4429
4430         /* Try and cope will all varients of "we don't do this call"
4431            and fall back to cli_dskattr. */
4432
4433         if (NT_STATUS_EQUAL(status,NT_STATUS_NOT_IMPLEMENTED) ||
4434                         NT_STATUS_EQUAL(status,NT_STATUS_NOT_SUPPORTED) ||
4435                         NT_STATUS_EQUAL(status,NT_STATUS_INVALID_INFO_CLASS) ||
4436                         NT_STATUS_EQUAL(status,NT_STATUS_PROCEDURE_NOT_FOUND) ||
4437                         NT_STATUS_EQUAL(status,NT_STATUS_INVALID_LEVEL) ||
4438                         NT_STATUS_EQUAL(status,NT_STATUS_INVALID_PARAMETER) ||
4439                         NT_STATUS_EQUAL(status,NT_STATUS_INVALID_DEVICE_REQUEST) ||
4440                         NT_STATUS_EQUAL(status,NT_STATUS_INVALID_DEVICE_STATE) ||
4441                         NT_STATUS_EQUAL(status,NT_STATUS_CTL_FILE_NOT_SUPPORTED) ||
4442                         NT_STATUS_EQUAL(status,NT_STATUS_UNSUCCESSFUL)) {
4443                 goto try_dskattr;
4444         }
4445
4446         if (!NT_STATUS_IS_OK(status)) {
4447                 return status;
4448         }
4449
4450         if (bsize) {
4451                 *bsize = sectors_per_block *
4452                          bytes_per_sector;
4453         }
4454
4455         return NT_STATUS_OK;
4456
4457   try_dskattr:
4458
4459         /* Old SMB1 core protocol fallback. */
4460         status = cli_dskattr(cli, &old_bsize, &old_total, &old_avail);
4461         if (!NT_STATUS_IS_OK(status)) {
4462                 return status;
4463         }
4464         if (bsize) {
4465                 *bsize = (uint64_t)old_bsize;
4466         }
4467         if (total) {
4468                 *total = (uint64_t)old_total;
4469         }
4470         if (avail) {
4471                 *avail = (uint64_t)old_avail;
4472         }
4473         return NT_STATUS_OK;
4474 }
4475
4476 /****************************************************************************
4477  Create and open a temporary file.
4478 ****************************************************************************/
4479
4480 static void cli_ctemp_done(struct tevent_req *subreq);
4481
4482 struct ctemp_state {
4483         uint16_t vwv[3];
4484         char *ret_path;
4485         uint16_t fnum;
4486 };
4487
4488 struct tevent_req *cli_ctemp_send(TALLOC_CTX *mem_ctx,
4489                                 struct tevent_context *ev,
4490                                 struct cli_state *cli,
4491                                 const char *path)
4492 {
4493         struct tevent_req *req = NULL, *subreq = NULL;
4494         struct ctemp_state *state = NULL;
4495         uint8_t additional_flags = 0;
4496         uint16_t additional_flags2 = 0;
4497         uint8_t *bytes = NULL;
4498
4499         req = tevent_req_create(mem_ctx, &state, struct ctemp_state);
4500         if (req == NULL) {
4501                 return NULL;
4502         }
4503
4504         SSVAL(state->vwv,0,0);
4505         SIVALS(state->vwv+1,0,-1);
4506
4507         bytes = talloc_array(state, uint8_t, 1);
4508         if (tevent_req_nomem(bytes, req)) {
4509                 return tevent_req_post(req, ev);
4510         }
4511         bytes[0] = 4;
4512         bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), path,
4513                                    strlen(path)+1, NULL);
4514         if (tevent_req_nomem(bytes, req)) {
4515                 return tevent_req_post(req, ev);
4516         }
4517
4518         if (clistr_is_previous_version_path(path, NULL, NULL, NULL)) {
4519                 additional_flags2 = FLAGS2_REPARSE_PATH;
4520         }
4521
4522         subreq = cli_smb_send(state, ev, cli, SMBctemp, additional_flags,
4523                         additional_flags2,
4524                         3, state->vwv, talloc_get_size(bytes), bytes);
4525         if (tevent_req_nomem(subreq, req)) {
4526                 return tevent_req_post(req, ev);
4527         }
4528         tevent_req_set_callback(subreq, cli_ctemp_done, req);
4529         return req;
4530 }
4531
4532 static void cli_ctemp_done(struct tevent_req *subreq)
4533 {
4534         struct tevent_req *req = tevent_req_callback_data(
4535                                 subreq, struct tevent_req);
4536         struct ctemp_state *state = tevent_req_data(
4537                                 req, struct ctemp_state);
4538         NTSTATUS status;
4539         uint8_t wcnt;
4540         uint16_t *vwv;
4541         uint32_t num_bytes = 0;
4542         uint8_t *bytes = NULL;
4543
4544         status = cli_smb_recv(subreq, state, NULL, 1, &wcnt, &vwv,
4545                               &num_bytes, &bytes);
4546         TALLOC_FREE(subreq);
4547         if (tevent_req_nterror(req, status)) {
4548                 return;
4549         }
4550
4551         state->fnum = SVAL(vwv+0, 0);
4552
4553         /* From W2K3, the result is just the ASCII name */
4554         if (num_bytes < 2) {
4555                 tevent_req_nterror(req, NT_STATUS_DATA_ERROR);
4556                 return;
4557         }
4558
4559         if (pull_string_talloc(state,
4560                         NULL,
4561                         0,
4562                         &state->ret_path,
4563                         bytes,
4564                         num_bytes,
4565                         STR_ASCII) == 0) {
4566                 tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
4567                 return;
4568         }
4569         tevent_req_done(req);
4570 }
4571
4572 NTSTATUS cli_ctemp_recv(struct tevent_req *req,
4573                         TALLOC_CTX *ctx,
4574                         uint16_t *pfnum,
4575                         char **outfile)
4576 {
4577         struct ctemp_state *state = tevent_req_data(req,
4578                         struct ctemp_state);
4579         NTSTATUS status;
4580
4581         if (tevent_req_is_nterror(req, &status)) {
4582                 return status;
4583         }
4584         *pfnum = state->fnum;
4585         *outfile = talloc_strdup(ctx, state->ret_path);
4586         if (!*outfile) {
4587                 return NT_STATUS_NO_MEMORY;
4588         }
4589         return NT_STATUS_OK;
4590 }
4591
4592 NTSTATUS cli_ctemp(struct cli_state *cli,
4593                         TALLOC_CTX *ctx,
4594                         const char *path,
4595                         uint16_t *pfnum,
4596                         char **out_path)
4597 {
4598         TALLOC_CTX *frame = talloc_stackframe();
4599         struct tevent_context *ev;
4600         struct tevent_req *req;
4601         NTSTATUS status = NT_STATUS_OK;
4602
4603         if (smbXcli_conn_has_async_calls(cli->conn)) {
4604                 /*
4605                  * Can't use sync call while an async call is in flight
4606                  */
4607                 status = NT_STATUS_INVALID_PARAMETER;
4608                 goto fail;
4609         }
4610
4611         ev = samba_tevent_context_init(frame);
4612         if (ev == NULL) {
4613                 status = NT_STATUS_NO_MEMORY;
4614                 goto fail;
4615         }
4616
4617         req = cli_ctemp_send(frame, ev, cli, path);
4618         if (req == NULL) {
4619                 status = NT_STATUS_NO_MEMORY;
4620                 goto fail;
4621         }
4622
4623         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
4624                 goto fail;
4625         }
4626
4627         status = cli_ctemp_recv(req, ctx, pfnum, out_path);
4628
4629  fail:
4630         TALLOC_FREE(frame);
4631         return status;
4632 }
4633
4634 /*
4635    send a raw ioctl - used by the torture code
4636 */
4637 NTSTATUS cli_raw_ioctl(struct cli_state *cli, uint16_t fnum, uint32_t code, DATA_BLOB *blob)
4638 {
4639         uint16_t vwv[3];
4640         NTSTATUS status;
4641
4642         SSVAL(vwv+0, 0, fnum);
4643         SSVAL(vwv+1, 0, code>>16);
4644         SSVAL(vwv+2, 0, (code&0xFFFF));
4645
4646         status = cli_smb(talloc_tos(), cli, SMBioctl, 0, 3, vwv, 0, NULL,
4647                          NULL, 0, NULL, NULL, NULL, NULL);
4648         if (!NT_STATUS_IS_OK(status)) {
4649                 return status;
4650         }
4651         *blob = data_blob_null;
4652         return NT_STATUS_OK;
4653 }
4654
4655 /*********************************************************
4656  Set an extended attribute utility fn.
4657 *********************************************************/
4658
4659 static NTSTATUS cli_set_ea(struct cli_state *cli, uint16_t setup_val,
4660                            uint8_t *param, unsigned int param_len,
4661                            const char *ea_name,
4662                            const char *ea_val, size_t ea_len)
4663 {
4664         uint16_t setup[1];
4665         unsigned int data_len = 0;
4666         uint8_t *data = NULL;
4667         char *p;
4668         size_t ea_namelen = strlen(ea_name);
4669         NTSTATUS status;
4670
4671         SSVAL(setup, 0, setup_val);
4672
4673         if (ea_namelen == 0 && ea_len == 0) {
4674                 data_len = 4;
4675                 data = talloc_array(talloc_tos(),
4676                                 uint8_t,
4677                                 data_len);
4678                 if (!data) {
4679                         return NT_STATUS_NO_MEMORY;
4680                 }
4681                 p = (char *)data;
4682                 SIVAL(p,0,data_len);
4683         } else {
4684                 data_len = 4 + 4 + ea_namelen + 1 + ea_len;
4685                 data = talloc_array(talloc_tos(),
4686                                 uint8_t,
4687                                 data_len);
4688                 if (!data) {
4689                         return NT_STATUS_NO_MEMORY;
4690                 }
4691                 p = (char *)data;
4692                 SIVAL(p,0,data_len);
4693                 p += 4;
4694                 SCVAL(p, 0, 0); /* EA flags. */
4695                 SCVAL(p, 1, ea_namelen);
4696                 SSVAL(p, 2, ea_len);
4697                 memcpy(p+4, ea_name, ea_namelen+1); /* Copy in the name. */
4698                 memcpy(p+4+ea_namelen+1, ea_val, ea_len);
4699         }
4700
4701         /*
4702          * FIXME - if we want to do previous version path
4703          * processing on an EA set call we need to turn this
4704          * into calls to cli_trans_send()/cli_trans_recv()
4705          * with a temporary event context, as cli_trans_send()
4706          * have access to the additional_flags2 needed to
4707          * send @GMT- paths. JRA.
4708          */
4709
4710         status = cli_trans(talloc_tos(), cli, SMBtrans2, NULL, -1, 0, 0,
4711                            setup, 1, 0,
4712                            param, param_len, 2,
4713                            data,  data_len, 0,
4714                            NULL,
4715                            NULL, 0, NULL, /* rsetup */
4716                            NULL, 0, NULL, /* rparam */
4717                            NULL, 0, NULL); /* rdata */
4718         talloc_free(data);
4719         return status;
4720 }
4721
4722 /*********************************************************
4723  Set an extended attribute on a pathname.
4724 *********************************************************/
4725
4726 NTSTATUS cli_set_ea_path(struct cli_state *cli, const char *path,
4727                          const char *ea_name, const char *ea_val,
4728                          size_t ea_len)
4729 {
4730         unsigned int param_len = 0;
4731         uint8_t *param;
4732         NTSTATUS status;
4733         TALLOC_CTX *frame = NULL;
4734
4735         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
4736                 return cli_smb2_set_ea_path(cli,
4737                                         path,
4738                                         ea_name,
4739                                         ea_val,
4740                                         ea_len);
4741         }
4742
4743         frame = talloc_stackframe();
4744
4745         param = talloc_array(frame, uint8_t, 6);
4746         if (!param) {
4747                 status = NT_STATUS_NO_MEMORY;
4748                 goto fail;
4749         }
4750         SSVAL(param,0,SMB_INFO_SET_EA);
4751         SSVAL(param,2,0);
4752         SSVAL(param,4,0);
4753
4754         param = trans2_bytes_push_str(param, smbXcli_conn_use_unicode(cli->conn),
4755                                       path, strlen(path)+1,
4756                                       NULL);
4757         param_len = talloc_get_size(param);
4758
4759         status = cli_set_ea(cli, TRANSACT2_SETPATHINFO, param, param_len,
4760                             ea_name, ea_val, ea_len);
4761
4762   fail:
4763
4764         TALLOC_FREE(frame);
4765         return status;
4766 }
4767
4768 /*********************************************************
4769  Set an extended attribute on an fnum.
4770 *********************************************************/
4771
4772 NTSTATUS cli_set_ea_fnum(struct cli_state *cli, uint16_t fnum,
4773                          const char *ea_name, const char *ea_val,
4774                          size_t ea_len)
4775 {
4776         uint8_t param[6];
4777
4778         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
4779                 return cli_smb2_set_ea_fnum(cli,
4780                                         fnum,
4781                                         ea_name,
4782                                         ea_val,
4783                                         ea_len);
4784         }
4785
4786         memset(param, 0, 6);
4787         SSVAL(param,0,fnum);
4788         SSVAL(param,2,SMB_INFO_SET_EA);
4789
4790         return cli_set_ea(cli, TRANSACT2_SETFILEINFO, param, 6,
4791                           ea_name, ea_val, ea_len);
4792 }
4793
4794 /*********************************************************
4795  Get an extended attribute list utility fn.
4796 *********************************************************/
4797
4798 static bool parse_ea_blob(TALLOC_CTX *ctx, const uint8_t *rdata,
4799                           size_t rdata_len,
4800                           size_t *pnum_eas, struct ea_struct **pea_list)
4801 {
4802         struct ea_struct *ea_list = NULL;
4803         size_t num_eas;
4804         size_t ea_size;
4805         const uint8_t *p;
4806
4807         if (rdata_len < 4) {
4808                 return false;
4809         }
4810
4811         ea_size = (size_t)IVAL(rdata,0);
4812         if (ea_size > rdata_len) {
4813                 return false;
4814         }
4815
4816         if (ea_size == 0) {
4817                 /* No EA's present. */
4818                 *pnum_eas = 0;
4819                 *pea_list = NULL;
4820                 return true;
4821         }
4822
4823         p = rdata + 4;
4824         ea_size -= 4;
4825
4826         /* Validate the EA list and count it. */
4827         for (num_eas = 0; ea_size >= 4; num_eas++) {
4828                 unsigned int ea_namelen = CVAL(p,1);
4829                 unsigned int ea_valuelen = SVAL(p,2);
4830                 if (ea_namelen == 0) {
4831                         return false;
4832                 }
4833                 if (4 + ea_namelen + 1 + ea_valuelen > ea_size) {
4834                         return false;
4835                 }
4836                 ea_size -= 4 + ea_namelen + 1 + ea_valuelen;
4837                 p += 4 + ea_namelen + 1 + ea_valuelen;
4838         }
4839
4840         if (num_eas == 0) {
4841                 *pnum_eas = 0;
4842                 *pea_list = NULL;
4843                 return true;
4844         }
4845
4846         *pnum_eas = num_eas;
4847         if (!pea_list) {
4848                 /* Caller only wants number of EA's. */
4849                 return true;
4850         }
4851
4852         ea_list = talloc_array(ctx, struct ea_struct, num_eas);
4853         if (!ea_list) {
4854                 return false;
4855         }
4856
4857         ea_size = (size_t)IVAL(rdata,0);
4858         p = rdata + 4;
4859
4860         for (num_eas = 0; num_eas < *pnum_eas; num_eas++ ) {
4861                 struct ea_struct *ea = &ea_list[num_eas];
4862                 fstring unix_ea_name;
4863                 unsigned int ea_namelen = CVAL(p,1);
4864                 unsigned int ea_valuelen = SVAL(p,2);
4865
4866                 ea->flags = CVAL(p,0);
4867                 unix_ea_name[0] = '\0';
4868                 pull_ascii(unix_ea_name, p + 4, sizeof(unix_ea_name), rdata_len - PTR_DIFF(p+4, rdata), STR_TERMINATE);
4869                 ea->name = talloc_strdup(ea_list, unix_ea_name);
4870                 if (!ea->name) {
4871                         goto fail;
4872                 }
4873                 /* Ensure the value is null terminated (in case it's a string). */
4874                 ea->value = data_blob_talloc(ea_list, NULL, ea_valuelen + 1);
4875                 if (!ea->value.data) {
4876                         goto fail;
4877                 }
4878                 if (ea_valuelen) {
4879                         memcpy(ea->value.data, p+4+ea_namelen+1, ea_valuelen);
4880                 }
4881                 ea->value.data[ea_valuelen] = 0;
4882                 ea->value.length--;
4883                 p += 4 + ea_namelen + 1 + ea_valuelen;
4884         }
4885
4886         *pea_list = ea_list;
4887         return true;
4888
4889 fail:
4890         TALLOC_FREE(ea_list);
4891         return false;
4892 }
4893
4894 /*********************************************************
4895  Get an extended attribute list from a pathname.
4896 *********************************************************/
4897
4898 struct cli_get_ea_list_path_state {
4899         uint32_t num_data;
4900         uint8_t *data;
4901 };
4902
4903 static void cli_get_ea_list_path_done(struct tevent_req *subreq);
4904
4905 struct tevent_req *cli_get_ea_list_path_send(TALLOC_CTX *mem_ctx,
4906                                              struct tevent_context *ev,
4907                                              struct cli_state *cli,
4908                                              const char *fname)
4909 {
4910         struct tevent_req *req, *subreq;
4911         struct cli_get_ea_list_path_state *state;
4912
4913         req = tevent_req_create(mem_ctx, &state,
4914                                 struct cli_get_ea_list_path_state);
4915         if (req == NULL) {
4916                 return NULL;
4917         }
4918         subreq = cli_qpathinfo_send(state, ev, cli, fname,
4919                                     SMB_INFO_QUERY_ALL_EAS, 4,
4920                                     CLI_BUFFER_SIZE);
4921         if (tevent_req_nomem(subreq, req)) {
4922                 return tevent_req_post(req, ev);
4923         }
4924         tevent_req_set_callback(subreq, cli_get_ea_list_path_done, req);
4925         return req;
4926 }
4927
4928 static void cli_get_ea_list_path_done(struct tevent_req *subreq)
4929 {
4930         struct tevent_req *req = tevent_req_callback_data(
4931                                 subreq, struct tevent_req);
4932         struct cli_get_ea_list_path_state *state = tevent_req_data(
4933                 req, struct cli_get_ea_list_path_state);
4934         NTSTATUS status;
4935
4936         status = cli_qpathinfo_recv(subreq, state, &state->data,
4937                                     &state->num_data);
4938         TALLOC_FREE(subreq);
4939         if (tevent_req_nterror(req, status)) {
4940                 return;
4941         }
4942         tevent_req_done(req);
4943 }
4944
4945 NTSTATUS cli_get_ea_list_path_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
4946                                    size_t *pnum_eas, struct ea_struct **peas)
4947 {
4948         struct cli_get_ea_list_path_state *state = tevent_req_data(
4949                 req, struct cli_get_ea_list_path_state);
4950         NTSTATUS status;
4951
4952         if (tevent_req_is_nterror(req, &status)) {
4953                 return status;
4954         }
4955         if (!parse_ea_blob(mem_ctx, state->data, state->num_data,
4956                            pnum_eas, peas)) {
4957                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
4958         }
4959         return NT_STATUS_OK;
4960 }
4961
4962 NTSTATUS cli_get_ea_list_path(struct cli_state *cli, const char *path,
4963                 TALLOC_CTX *ctx,
4964                 size_t *pnum_eas,
4965                 struct ea_struct **pea_list)
4966 {
4967         TALLOC_CTX *frame = NULL;
4968         struct tevent_context *ev = NULL;
4969         struct tevent_req *req = NULL;
4970         NTSTATUS status = NT_STATUS_NO_MEMORY;
4971
4972         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
4973                 return cli_smb2_get_ea_list_path(cli,
4974                                         path,
4975                                         ctx,
4976                                         pnum_eas,
4977                                         pea_list);
4978         }
4979
4980         frame = talloc_stackframe();
4981
4982         if (smbXcli_conn_has_async_calls(cli->conn)) {
4983                 /*
4984                  * Can't use sync call while an async call is in flight
4985                  */
4986                 status = NT_STATUS_INVALID_PARAMETER;
4987                 goto fail;
4988         }
4989         ev = samba_tevent_context_init(frame);
4990         if (ev == NULL) {
4991                 goto fail;
4992         }
4993         req = cli_get_ea_list_path_send(frame, ev, cli, path);
4994         if (req == NULL) {
4995                 goto fail;
4996         }
4997         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
4998                 goto fail;
4999         }
5000         status = cli_get_ea_list_path_recv(req, ctx, pnum_eas, pea_list);
5001  fail:
5002         TALLOC_FREE(frame);
5003         return status;
5004 }
5005
5006 /****************************************************************************
5007  Convert open "flags" arg to uint32_t on wire.
5008 ****************************************************************************/
5009
5010 static uint32_t open_flags_to_wire(int flags)
5011 {
5012         int open_mode = flags & O_ACCMODE;
5013         uint32_t ret = 0;
5014
5015         switch (open_mode) {
5016                 case O_WRONLY:
5017                         ret |= SMB_O_WRONLY;
5018                         break;
5019                 case O_RDWR:
5020                         ret |= SMB_O_RDWR;
5021                         break;
5022                 default:
5023                 case O_RDONLY:
5024                         ret |= SMB_O_RDONLY;
5025                         break;
5026         }
5027
5028         if (flags & O_CREAT) {
5029                 ret |= SMB_O_CREAT;
5030         }
5031         if (flags & O_EXCL) {
5032                 ret |= SMB_O_EXCL;
5033         }
5034         if (flags & O_TRUNC) {
5035                 ret |= SMB_O_TRUNC;
5036         }
5037 #if defined(O_SYNC)
5038         if (flags & O_SYNC) {
5039                 ret |= SMB_O_SYNC;
5040         }
5041 #endif /* O_SYNC */
5042         if (flags & O_APPEND) {
5043                 ret |= SMB_O_APPEND;
5044         }
5045 #if defined(O_DIRECT)
5046         if (flags & O_DIRECT) {
5047                 ret |= SMB_O_DIRECT;
5048         }
5049 #endif
5050 #if defined(O_DIRECTORY)
5051         if (flags & O_DIRECTORY) {
5052                 ret |= SMB_O_DIRECTORY;
5053         }
5054 #endif
5055         return ret;
5056 }
5057
5058 /****************************************************************************
5059  Open a file - POSIX semantics. Returns fnum. Doesn't request oplock.
5060 ****************************************************************************/
5061
5062 struct posix_open_state {
5063         uint16_t setup;
5064         uint8_t *param;
5065         uint8_t data[18];
5066         uint16_t fnum; /* Out */
5067 };
5068
5069 static void cli_posix_open_internal_done(struct tevent_req *subreq)
5070 {
5071         struct tevent_req *req = tevent_req_callback_data(
5072                                 subreq, struct tevent_req);
5073         struct posix_open_state *state = tevent_req_data(req, struct posix_open_state);
5074         NTSTATUS status;
5075         uint8_t *data;
5076         uint32_t num_data;
5077
5078         status = cli_trans_recv(subreq, state, NULL, NULL, 0, NULL,
5079                                 NULL, 0, NULL, &data, 12, &num_data);
5080         TALLOC_FREE(subreq);
5081         if (tevent_req_nterror(req, status)) {
5082                 return;
5083         }
5084         state->fnum = SVAL(data,2);
5085         tevent_req_done(req);
5086 }
5087
5088 static struct tevent_req *cli_posix_open_internal_send(TALLOC_CTX *mem_ctx,
5089                                         struct tevent_context *ev,
5090                                         struct cli_state *cli,
5091                                         const char *fname,
5092                                         int flags,
5093                                         mode_t mode,
5094                                         bool is_dir)
5095 {
5096         struct tevent_req *req = NULL, *subreq = NULL;
5097         struct posix_open_state *state = NULL;
5098         uint32_t wire_flags = open_flags_to_wire(flags);
5099
5100         req = tevent_req_create(mem_ctx, &state, struct posix_open_state);
5101         if (req == NULL) {
5102                 return NULL;
5103         }
5104
5105         /* Setup setup word. */
5106         SSVAL(&state->setup, 0, TRANSACT2_SETPATHINFO);
5107
5108         /* Setup param array. */
5109         state->param = talloc_array(state, uint8_t, 6);
5110         if (tevent_req_nomem(state->param, req)) {
5111                 return tevent_req_post(req, ev);
5112         }
5113         memset(state->param, '\0', 6);
5114         SSVAL(state->param, 0, SMB_POSIX_PATH_OPEN);
5115
5116         state->param = trans2_bytes_push_str(state->param, smbXcli_conn_use_unicode(cli->conn), fname,
5117                                    strlen(fname)+1, NULL);
5118
5119         if (tevent_req_nomem(state->param, req)) {
5120                 return tevent_req_post(req, ev);
5121         }
5122
5123         /* Setup data words. */
5124         if (is_dir) {
5125                 wire_flags |= SMB_O_DIRECTORY;
5126         }
5127
5128         SIVAL(state->data,0,0); /* No oplock. */
5129         SIVAL(state->data,4,wire_flags);
5130         SIVAL(state->data,8,unix_perms_to_wire(mode));
5131         SIVAL(state->data,12,0); /* Top bits of perms currently undefined. */
5132         SSVAL(state->data,16,SMB_NO_INFO_LEVEL_RETURNED); /* No info level returned. */
5133
5134         subreq = cli_trans_send(state,                  /* mem ctx. */
5135                                 ev,                     /* event ctx. */
5136                                 cli,                    /* cli_state. */
5137                                 0,                      /* additional_flags2 */
5138                                 SMBtrans2,              /* cmd. */
5139                                 NULL,                   /* pipe name. */
5140                                 -1,                     /* fid. */
5141                                 0,                      /* function. */
5142                                 0,                      /* flags. */
5143                                 &state->setup,          /* setup. */
5144                                 1,                      /* num setup uint16_t words. */
5145                                 0,                      /* max returned setup. */
5146                                 state->param,           /* param. */
5147                                 talloc_get_size(state->param),/* num param. */
5148                                 2,                      /* max returned param. */
5149                                 state->data,            /* data. */
5150                                 18,                     /* num data. */
5151                                 12);                    /* max returned data. */
5152
5153         if (tevent_req_nomem(subreq, req)) {
5154                 return tevent_req_post(req, ev);
5155         }
5156         tevent_req_set_callback(subreq, cli_posix_open_internal_done, req);
5157         return req;
5158 }
5159
5160 struct tevent_req *cli_posix_open_send(TALLOC_CTX *mem_ctx,
5161                                         struct tevent_context *ev,
5162                                         struct cli_state *cli,
5163                                         const char *fname,
5164                                         int flags,
5165                                         mode_t mode)
5166 {
5167         return cli_posix_open_internal_send(mem_ctx, ev,
5168                                 cli, fname, flags, mode, false);
5169 }
5170
5171 NTSTATUS cli_posix_open_recv(struct tevent_req *req, uint16_t *pfnum)
5172 {
5173         struct posix_open_state *state = tevent_req_data(req, struct posix_open_state);
5174         NTSTATUS status;
5175
5176         if (tevent_req_is_nterror(req, &status)) {
5177                 return status;
5178         }
5179         *pfnum = state->fnum;
5180         return NT_STATUS_OK;
5181 }
5182
5183 /****************************************************************************
5184  Open - POSIX semantics. Doesn't request oplock.
5185 ****************************************************************************/
5186
5187 NTSTATUS cli_posix_open(struct cli_state *cli, const char *fname,
5188                         int flags, mode_t mode, uint16_t *pfnum)
5189 {
5190
5191         TALLOC_CTX *frame = talloc_stackframe();
5192         struct tevent_context *ev = NULL;
5193         struct tevent_req *req = NULL;
5194         NTSTATUS status = NT_STATUS_OK;
5195
5196         if (smbXcli_conn_has_async_calls(cli->conn)) {
5197                 /*
5198                  * Can't use sync call while an async call is in flight
5199                  */
5200                 status = NT_STATUS_INVALID_PARAMETER;
5201                 goto fail;
5202         }
5203
5204         ev = samba_tevent_context_init(frame);
5205         if (ev == NULL) {
5206                 status = NT_STATUS_NO_MEMORY;
5207                 goto fail;
5208         }
5209
5210         req = cli_posix_open_send(frame,
5211                                 ev,
5212                                 cli,
5213                                 fname,
5214                                 flags,
5215                                 mode);
5216         if (req == NULL) {
5217                 status = NT_STATUS_NO_MEMORY;
5218                 goto fail;
5219         }
5220
5221         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
5222                 goto fail;
5223         }
5224
5225         status = cli_posix_open_recv(req, pfnum);
5226
5227  fail:
5228         TALLOC_FREE(frame);
5229         return status;
5230 }
5231
5232 struct tevent_req *cli_posix_mkdir_send(TALLOC_CTX *mem_ctx,
5233                                         struct tevent_context *ev,
5234                                         struct cli_state *cli,
5235                                         const char *fname,
5236                                         mode_t mode)
5237 {
5238         return cli_posix_open_internal_send(mem_ctx, ev,
5239                                 cli, fname, O_CREAT, mode, true);
5240 }
5241
5242 NTSTATUS cli_posix_mkdir_recv(struct tevent_req *req)
5243 {
5244         return tevent_req_simple_recv_ntstatus(req);
5245 }
5246
5247 NTSTATUS cli_posix_mkdir(struct cli_state *cli, const char *fname, mode_t mode)
5248 {
5249         TALLOC_CTX *frame = talloc_stackframe();
5250         struct tevent_context *ev = NULL;
5251         struct tevent_req *req = NULL;
5252         NTSTATUS status = NT_STATUS_OK;
5253
5254         if (smbXcli_conn_has_async_calls(cli->conn)) {
5255                 /*
5256                  * Can't use sync call while an async call is in flight
5257                  */
5258                 status = NT_STATUS_INVALID_PARAMETER;
5259                 goto fail;
5260         }
5261
5262         ev = samba_tevent_context_init(frame);
5263         if (ev == NULL) {
5264                 status = NT_STATUS_NO_MEMORY;
5265                 goto fail;
5266         }
5267
5268         req = cli_posix_mkdir_send(frame,
5269                                 ev,
5270                                 cli,
5271                                 fname,
5272                                 mode);
5273         if (req == NULL) {
5274                 status = NT_STATUS_NO_MEMORY;
5275                 goto fail;
5276         }
5277
5278         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
5279                 goto fail;
5280         }
5281
5282         status = cli_posix_mkdir_recv(req);
5283
5284  fail:
5285         TALLOC_FREE(frame);
5286         return status;
5287 }
5288
5289 /****************************************************************************
5290  unlink or rmdir - POSIX semantics.
5291 ****************************************************************************/
5292
5293 struct cli_posix_unlink_internal_state {
5294         uint8_t data[2];
5295 };
5296
5297 static void cli_posix_unlink_internal_done(struct tevent_req *subreq);
5298
5299 static struct tevent_req *cli_posix_unlink_internal_send(TALLOC_CTX *mem_ctx,
5300                                         struct tevent_context *ev,
5301                                         struct cli_state *cli,
5302                                         const char *fname,
5303                                         uint16_t level)
5304 {
5305         struct tevent_req *req = NULL, *subreq = NULL;
5306         struct cli_posix_unlink_internal_state *state = NULL;
5307
5308         req = tevent_req_create(mem_ctx, &state,
5309                                 struct cli_posix_unlink_internal_state);
5310         if (req == NULL) {
5311                 return NULL;
5312         }
5313
5314         /* Setup data word. */
5315         SSVAL(state->data, 0, level);
5316
5317         subreq = cli_setpathinfo_send(state, ev, cli,
5318                                       SMB_POSIX_PATH_UNLINK,
5319                                       fname,
5320                                       state->data, sizeof(state->data));
5321         if (tevent_req_nomem(subreq, req)) {
5322                 return tevent_req_post(req, ev);
5323         }
5324         tevent_req_set_callback(subreq, cli_posix_unlink_internal_done, req);
5325         return req;
5326 }
5327
5328 static void cli_posix_unlink_internal_done(struct tevent_req *subreq)
5329 {
5330         NTSTATUS status = cli_setpathinfo_recv(subreq);
5331         tevent_req_simple_finish_ntstatus(subreq, status);
5332 }
5333
5334 struct tevent_req *cli_posix_unlink_send(TALLOC_CTX *mem_ctx,
5335                                         struct tevent_context *ev,
5336                                         struct cli_state *cli,
5337                                         const char *fname)
5338 {
5339         return cli_posix_unlink_internal_send(mem_ctx, ev, cli, fname,
5340                                               SMB_POSIX_UNLINK_FILE_TARGET);
5341 }
5342
5343 NTSTATUS cli_posix_unlink_recv(struct tevent_req *req)
5344 {
5345         return tevent_req_simple_recv_ntstatus(req);
5346 }
5347
5348 /****************************************************************************
5349  unlink - POSIX semantics.
5350 ****************************************************************************/
5351
5352 NTSTATUS cli_posix_unlink(struct cli_state *cli, const char *fname)
5353 {
5354         TALLOC_CTX *frame = talloc_stackframe();
5355         struct tevent_context *ev = NULL;
5356         struct tevent_req *req = NULL;
5357         NTSTATUS status = NT_STATUS_OK;
5358
5359         if (smbXcli_conn_has_async_calls(cli->conn)) {
5360                 /*
5361                  * Can't use sync call while an async call is in flight
5362                  */
5363                 status = NT_STATUS_INVALID_PARAMETER;
5364                 goto fail;
5365         }
5366
5367         ev = samba_tevent_context_init(frame);
5368         if (ev == NULL) {
5369                 status = NT_STATUS_NO_MEMORY;
5370                 goto fail;
5371         }
5372
5373         req = cli_posix_unlink_send(frame,
5374                                 ev,
5375                                 cli,
5376                                 fname);
5377         if (req == NULL) {
5378                 status = NT_STATUS_NO_MEMORY;
5379                 goto fail;
5380         }
5381
5382         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
5383                 goto fail;
5384         }
5385
5386         status = cli_posix_unlink_recv(req);
5387
5388  fail:
5389         TALLOC_FREE(frame);
5390         return status;
5391 }
5392
5393 /****************************************************************************
5394  rmdir - POSIX semantics.
5395 ****************************************************************************/
5396
5397 struct tevent_req *cli_posix_rmdir_send(TALLOC_CTX *mem_ctx,
5398                                         struct tevent_context *ev,
5399                                         struct cli_state *cli,
5400                                         const char *fname)
5401 {
5402         return cli_posix_unlink_internal_send(
5403                 mem_ctx, ev, cli, fname,
5404                 SMB_POSIX_UNLINK_DIRECTORY_TARGET);
5405 }
5406
5407 NTSTATUS cli_posix_rmdir_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
5408 {
5409         return tevent_req_simple_recv_ntstatus(req);
5410 }
5411
5412 NTSTATUS cli_posix_rmdir(struct cli_state *cli, const char *fname)
5413 {
5414         TALLOC_CTX *frame = talloc_stackframe();
5415         struct tevent_context *ev = NULL;
5416         struct tevent_req *req = NULL;
5417         NTSTATUS status = NT_STATUS_OK;
5418
5419         if (smbXcli_conn_has_async_calls(cli->conn)) {
5420                 /*
5421                  * Can't use sync call while an async call is in flight
5422                  */
5423                 status = NT_STATUS_INVALID_PARAMETER;
5424                 goto fail;
5425         }
5426
5427         ev = samba_tevent_context_init(frame);
5428         if (ev == NULL) {
5429                 status = NT_STATUS_NO_MEMORY;
5430                 goto fail;
5431         }
5432
5433         req = cli_posix_rmdir_send(frame,
5434                                 ev,
5435                                 cli,
5436                                 fname);
5437         if (req == NULL) {
5438                 status = NT_STATUS_NO_MEMORY;
5439                 goto fail;
5440         }
5441
5442         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
5443                 goto fail;
5444         }
5445
5446         status = cli_posix_rmdir_recv(req, frame);
5447
5448  fail:
5449         TALLOC_FREE(frame);
5450         return status;
5451 }
5452
5453 /****************************************************************************
5454  filechangenotify
5455 ****************************************************************************/
5456
5457 struct cli_notify_state {
5458         uint8_t setup[8];
5459         uint32_t num_changes;
5460         struct notify_change *changes;
5461 };
5462
5463 static void cli_notify_done(struct tevent_req *subreq);
5464
5465 struct tevent_req *cli_notify_send(TALLOC_CTX *mem_ctx,
5466                                    struct tevent_context *ev,
5467                                    struct cli_state *cli, uint16_t fnum,
5468                                    uint32_t buffer_size,
5469                                    uint32_t completion_filter, bool recursive)
5470 {
5471         struct tevent_req *req, *subreq;
5472         struct cli_notify_state *state;
5473         unsigned old_timeout;
5474
5475         req = tevent_req_create(mem_ctx, &state, struct cli_notify_state);
5476         if (req == NULL) {
5477                 return NULL;
5478         }
5479
5480         SIVAL(state->setup, 0, completion_filter);
5481         SSVAL(state->setup, 4, fnum);
5482         SSVAL(state->setup, 6, recursive);
5483
5484         /*
5485          * Notifies should not time out
5486          */
5487         old_timeout = cli_set_timeout(cli, 0);
5488
5489         subreq = cli_trans_send(
5490                 state,                  /* mem ctx. */
5491                 ev,                     /* event ctx. */
5492                 cli,                    /* cli_state. */
5493                 0,                      /* additional_flags2 */
5494                 SMBnttrans,             /* cmd. */
5495                 NULL,                   /* pipe name. */
5496                 -1,                     /* fid. */
5497                 NT_TRANSACT_NOTIFY_CHANGE, /* function. */
5498                 0,                      /* flags. */
5499                 (uint16_t *)state->setup, /* setup. */
5500                 4,                      /* num setup uint16_t words. */
5501                 0,                      /* max returned setup. */
5502                 NULL,                   /* param. */
5503                 0,                      /* num param. */
5504                 buffer_size,            /* max returned param. */
5505                 NULL,                   /* data. */
5506                 0,                      /* num data. */
5507                 0);                     /* max returned data. */
5508
5509         cli_set_timeout(cli, old_timeout);
5510
5511         if (tevent_req_nomem(subreq, req)) {
5512                 return tevent_req_post(req, ev);
5513         }
5514         tevent_req_set_callback(subreq, cli_notify_done, req);
5515         return req;
5516 }
5517
5518 static void cli_notify_done(struct tevent_req *subreq)
5519 {
5520         struct tevent_req *req = tevent_req_callback_data(
5521                 subreq, struct tevent_req);
5522         struct cli_notify_state *state = tevent_req_data(
5523                 req, struct cli_notify_state);
5524         NTSTATUS status;
5525         uint8_t *params;
5526         uint32_t i, ofs, num_params;
5527         uint16_t flags2;
5528
5529         status = cli_trans_recv(subreq, talloc_tos(), &flags2, NULL, 0, NULL,
5530                                 &params, 0, &num_params, NULL, 0, NULL);
5531         TALLOC_FREE(subreq);
5532         if (tevent_req_nterror(req, status)) {
5533                 DEBUG(10, ("cli_trans_recv returned %s\n", nt_errstr(status)));
5534                 return;
5535         }
5536
5537         state->num_changes = 0;
5538         ofs = 0;
5539
5540         while (num_params - ofs > 12) {
5541                 uint32_t next = IVAL(params, ofs);
5542                 state->num_changes += 1;
5543
5544                 if ((next == 0) || (ofs+next >= num_params)) {
5545                         break;
5546                 }
5547                 ofs += next;
5548         }
5549
5550         state->changes = talloc_array(state, struct notify_change,
5551                                       state->num_changes);
5552         if (tevent_req_nomem(state->changes, req)) {
5553                 TALLOC_FREE(params);
5554                 return;
5555         }
5556
5557         ofs = 0;
5558
5559         for (i=0; i<state->num_changes; i++) {
5560                 uint32_t next = IVAL(params, ofs);
5561                 uint32_t len = IVAL(params, ofs+8);
5562                 ssize_t ret;
5563                 char *name;
5564
5565                 if (trans_oob(num_params, ofs + 12, len)) {
5566                         TALLOC_FREE(params);
5567                         tevent_req_nterror(
5568                                 req, NT_STATUS_INVALID_NETWORK_RESPONSE);
5569                         return;
5570                 }
5571
5572                 state->changes[i].action = IVAL(params, ofs+4);
5573                 ret = clistr_pull_talloc(state->changes, (char *)params, flags2,
5574                                          &name, params+ofs+12, len,
5575                                          STR_TERMINATE|STR_UNICODE);
5576                 if (ret == -1) {
5577                         TALLOC_FREE(params);
5578                         tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
5579                         return;
5580                 }
5581                 state->changes[i].name = name;
5582                 ofs += next;
5583         }
5584
5585         TALLOC_FREE(params);
5586         tevent_req_done(req);
5587 }
5588
5589 NTSTATUS cli_notify_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
5590                          uint32_t *pnum_changes,
5591                          struct notify_change **pchanges)
5592 {
5593         struct cli_notify_state *state = tevent_req_data(
5594                 req, struct cli_notify_state);
5595         NTSTATUS status;
5596
5597         if (tevent_req_is_nterror(req, &status)) {
5598                 return status;
5599         }
5600
5601         *pnum_changes = state->num_changes;
5602         *pchanges = talloc_move(mem_ctx, &state->changes);
5603         return NT_STATUS_OK;
5604 }
5605
5606 NTSTATUS cli_notify(struct cli_state *cli, uint16_t fnum, uint32_t buffer_size,
5607                     uint32_t completion_filter, bool recursive,
5608                     TALLOC_CTX *mem_ctx, uint32_t *pnum_changes,
5609                     struct notify_change **pchanges)
5610 {
5611         TALLOC_CTX *frame;
5612         struct tevent_context *ev;
5613         struct tevent_req *req;
5614         NTSTATUS status = NT_STATUS_NO_MEMORY;
5615
5616         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
5617                 return cli_smb2_notify(cli, fnum, buffer_size,
5618                                        completion_filter, recursive,
5619                                        mem_ctx, pchanges, pnum_changes);
5620         }
5621
5622         frame = talloc_stackframe();
5623
5624         if (smbXcli_conn_has_async_calls(cli->conn)) {
5625                 /*
5626                  * Can't use sync call while an async call is in flight
5627                  */
5628                 status = NT_STATUS_INVALID_PARAMETER;
5629                 goto fail;
5630         }
5631         ev = samba_tevent_context_init(frame);
5632         if (ev == NULL) {
5633                 goto fail;
5634         }
5635         req = cli_notify_send(ev, ev, cli, fnum, buffer_size,
5636                               completion_filter, recursive);
5637         if (req == NULL) {
5638                 goto fail;
5639         }
5640         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
5641                 goto fail;
5642         }
5643         status = cli_notify_recv(req, mem_ctx, pnum_changes, pchanges);
5644  fail:
5645         TALLOC_FREE(frame);
5646         return status;
5647 }
5648
5649 struct cli_qpathinfo_state {
5650         uint8_t *param;
5651         uint8_t *data;
5652         uint16_t setup[1];
5653         uint32_t min_rdata;
5654         uint8_t *rdata;
5655         uint32_t num_rdata;
5656 };
5657
5658 static void cli_qpathinfo_done(struct tevent_req *subreq);
5659
5660 struct tevent_req *cli_qpathinfo_send(TALLOC_CTX *mem_ctx,
5661                                       struct tevent_context *ev,
5662                                       struct cli_state *cli, const char *fname,
5663                                       uint16_t level, uint32_t min_rdata,
5664                                       uint32_t max_rdata)
5665 {
5666         struct tevent_req *req, *subreq;
5667         struct cli_qpathinfo_state *state;
5668         uint16_t additional_flags2 = 0;
5669
5670         req = tevent_req_create(mem_ctx, &state, struct cli_qpathinfo_state);
5671         if (req == NULL) {
5672                 return NULL;
5673         }
5674         state->min_rdata = min_rdata;
5675         SSVAL(state->setup, 0, TRANSACT2_QPATHINFO);
5676
5677         state->param = talloc_zero_array(state, uint8_t, 6);
5678         if (tevent_req_nomem(state->param, req)) {
5679                 return tevent_req_post(req, ev);
5680         }
5681         SSVAL(state->param, 0, level);
5682         state->param = trans2_bytes_push_str(
5683                 state->param, smbXcli_conn_use_unicode(cli->conn), fname, strlen(fname)+1, NULL);
5684         if (tevent_req_nomem(state->param, req)) {
5685                 return tevent_req_post(req, ev);
5686         }
5687
5688         if (clistr_is_previous_version_path(fname, NULL, NULL, NULL) &&
5689                         !INFO_LEVEL_IS_UNIX(level)) {
5690                 additional_flags2 = FLAGS2_REPARSE_PATH;
5691         }
5692
5693         subreq = cli_trans_send(
5694                 state,                  /* mem ctx. */
5695                 ev,                     /* event ctx. */
5696                 cli,                    /* cli_state. */
5697                 additional_flags2,      /* additional_flags2 */
5698                 SMBtrans2,              /* cmd. */
5699                 NULL,                   /* pipe name. */
5700                 -1,                     /* fid. */
5701                 0,                      /* function. */
5702                 0,                      /* flags. */
5703                 state->setup,           /* setup. */
5704                 1,                      /* num setup uint16_t words. */
5705                 0,                      /* max returned setup. */
5706                 state->param,           /* param. */
5707                 talloc_get_size(state->param),  /* num param. */
5708                 2,                      /* max returned param. */
5709                 NULL,                   /* data. */
5710                 0,                      /* num data. */
5711                 max_rdata);             /* max returned data. */
5712
5713         if (tevent_req_nomem(subreq, req)) {
5714                 return tevent_req_post(req, ev);
5715         }
5716         tevent_req_set_callback(subreq, cli_qpathinfo_done, req);
5717         return req;
5718 }
5719
5720 static void cli_qpathinfo_done(struct tevent_req *subreq)
5721 {
5722         struct tevent_req *req = tevent_req_callback_data(
5723                 subreq, struct tevent_req);
5724         struct cli_qpathinfo_state *state = tevent_req_data(
5725                 req, struct cli_qpathinfo_state);
5726         NTSTATUS status;
5727
5728         status = cli_trans_recv(subreq, state, NULL, NULL, 0, NULL,
5729                                 NULL, 0, NULL,
5730                                 &state->rdata, state->min_rdata,
5731                                 &state->num_rdata);
5732         if (tevent_req_nterror(req, status)) {
5733                 return;
5734         }
5735         tevent_req_done(req);
5736 }
5737
5738 NTSTATUS cli_qpathinfo_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
5739                             uint8_t **rdata, uint32_t *num_rdata)
5740 {
5741         struct cli_qpathinfo_state *state = tevent_req_data(
5742                 req, struct cli_qpathinfo_state);
5743         NTSTATUS status;
5744
5745         if (tevent_req_is_nterror(req, &status)) {
5746                 return status;
5747         }
5748         if (rdata != NULL) {
5749                 *rdata = talloc_move(mem_ctx, &state->rdata);
5750         } else {
5751                 TALLOC_FREE(state->rdata);
5752         }
5753         if (num_rdata != NULL) {
5754                 *num_rdata = state->num_rdata;
5755         }
5756         return NT_STATUS_OK;
5757 }
5758
5759 NTSTATUS cli_qpathinfo(TALLOC_CTX *mem_ctx, struct cli_state *cli,
5760                        const char *fname, uint16_t level, uint32_t min_rdata,
5761                        uint32_t max_rdata,
5762                        uint8_t **rdata, uint32_t *num_rdata)
5763 {
5764         TALLOC_CTX *frame = talloc_stackframe();
5765         struct tevent_context *ev;
5766         struct tevent_req *req;
5767         NTSTATUS status = NT_STATUS_NO_MEMORY;
5768
5769         if (smbXcli_conn_has_async_calls(cli->conn)) {
5770                 /*
5771                  * Can't use sync call while an async call is in flight
5772                  */
5773                 status = NT_STATUS_INVALID_PARAMETER;
5774                 goto fail;
5775         }
5776         ev = samba_tevent_context_init(frame);
5777         if (ev == NULL) {
5778                 goto fail;
5779         }
5780         req = cli_qpathinfo_send(frame, ev, cli, fname, level, min_rdata,
5781                                  max_rdata);
5782         if (req == NULL) {
5783                 goto fail;
5784         }
5785         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
5786                 goto fail;
5787         }
5788         status = cli_qpathinfo_recv(req, mem_ctx, rdata, num_rdata);
5789  fail:
5790         TALLOC_FREE(frame);
5791         return status;
5792 }
5793
5794 struct cli_qfileinfo_state {
5795         uint16_t setup[1];
5796         uint8_t param[4];
5797         uint8_t *data;
5798         uint16_t recv_flags2;
5799         uint32_t min_rdata;
5800         uint8_t *rdata;
5801         uint32_t num_rdata;
5802 };
5803
5804 static void cli_qfileinfo_done(struct tevent_req *subreq);
5805
5806 struct tevent_req *cli_qfileinfo_send(TALLOC_CTX *mem_ctx,
5807                                       struct tevent_context *ev,
5808                                       struct cli_state *cli, uint16_t fnum,
5809                                       uint16_t level, uint32_t min_rdata,
5810                                       uint32_t max_rdata)
5811 {
5812         struct tevent_req *req, *subreq;
5813         struct cli_qfileinfo_state *state;
5814
5815         req = tevent_req_create(mem_ctx, &state, struct cli_qfileinfo_state);
5816         if (req == NULL) {
5817                 return NULL;
5818         }
5819         state->min_rdata = min_rdata;
5820         SSVAL(state->param, 0, fnum);
5821         SSVAL(state->param, 2, level);
5822         SSVAL(state->setup, 0, TRANSACT2_QFILEINFO);
5823
5824         subreq = cli_trans_send(
5825                 state,                  /* mem ctx. */
5826                 ev,                     /* event ctx. */
5827                 cli,                    /* cli_state. */
5828                 0,                      /* additional_flags2 */
5829                 SMBtrans2,              /* cmd. */
5830                 NULL,                   /* pipe name. */
5831                 -1,                     /* fid. */
5832                 0,                      /* function. */
5833                 0,                      /* flags. */
5834                 state->setup,           /* setup. */
5835                 1,                      /* num setup uint16_t words. */
5836                 0,                      /* max returned setup. */
5837                 state->param,           /* param. */
5838                 sizeof(state->param),   /* num param. */
5839                 2,                      /* max returned param. */
5840                 NULL,                   /* data. */
5841                 0,                      /* num data. */
5842                 max_rdata);             /* max returned data. */
5843
5844         if (tevent_req_nomem(subreq, req)) {
5845                 return tevent_req_post(req, ev);
5846         }
5847         tevent_req_set_callback(subreq, cli_qfileinfo_done, req);
5848         return req;
5849 }
5850
5851 static void cli_qfileinfo_done(struct tevent_req *subreq)
5852 {
5853         struct tevent_req *req = tevent_req_callback_data(
5854                 subreq, struct tevent_req);
5855         struct cli_qfileinfo_state *state = tevent_req_data(
5856                 req, struct cli_qfileinfo_state);
5857         NTSTATUS status;
5858
5859         status = cli_trans_recv(subreq, state,
5860                                 &state->recv_flags2,
5861                                 NULL, 0, NULL,
5862                                 NULL, 0, NULL,
5863                                 &state->rdata, state->min_rdata,
5864                                 &state->num_rdata);
5865         if (tevent_req_nterror(req, status)) {
5866                 return;
5867         }
5868         tevent_req_done(req);
5869 }
5870
5871 NTSTATUS cli_qfileinfo_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
5872                             uint16_t *recv_flags2,
5873                             uint8_t **rdata, uint32_t *num_rdata)
5874 {
5875         struct cli_qfileinfo_state *state = tevent_req_data(
5876                 req, struct cli_qfileinfo_state);
5877         NTSTATUS status;
5878
5879         if (tevent_req_is_nterror(req, &status)) {
5880                 return status;
5881         }
5882
5883         if (recv_flags2 != NULL) {
5884                 *recv_flags2 = state->recv_flags2;
5885         }
5886         if (rdata != NULL) {
5887                 *rdata = talloc_move(mem_ctx, &state->rdata);
5888         } else {
5889                 TALLOC_FREE(state->rdata);
5890         }
5891         if (num_rdata != NULL) {
5892                 *num_rdata = state->num_rdata;
5893         }
5894         return NT_STATUS_OK;
5895 }
5896
5897 NTSTATUS cli_qfileinfo(TALLOC_CTX *mem_ctx, struct cli_state *cli,
5898                        uint16_t fnum, uint16_t level, uint32_t min_rdata,
5899                        uint32_t max_rdata, uint16_t *recv_flags2,
5900                        uint8_t **rdata, uint32_t *num_rdata)
5901 {
5902         TALLOC_CTX *frame = talloc_stackframe();
5903         struct tevent_context *ev;
5904         struct tevent_req *req;
5905         NTSTATUS status = NT_STATUS_NO_MEMORY;
5906
5907         if (smbXcli_conn_has_async_calls(cli->conn)) {
5908                 /*
5909                  * Can't use sync call while an async call is in flight
5910                  */
5911                 status = NT_STATUS_INVALID_PARAMETER;
5912                 goto fail;
5913         }
5914         ev = samba_tevent_context_init(frame);
5915         if (ev == NULL) {
5916                 goto fail;
5917         }
5918         req = cli_qfileinfo_send(frame, ev, cli, fnum, level, min_rdata,
5919                                  max_rdata);
5920         if (req == NULL) {
5921                 goto fail;
5922         }
5923         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
5924                 goto fail;
5925         }
5926         status = cli_qfileinfo_recv(req, mem_ctx, recv_flags2, rdata, num_rdata);
5927  fail:
5928         TALLOC_FREE(frame);
5929         return status;
5930 }
5931
5932 struct cli_flush_state {
5933         uint16_t vwv[1];
5934 };
5935
5936 static void cli_flush_done(struct tevent_req *subreq);
5937
5938 struct tevent_req *cli_flush_send(TALLOC_CTX *mem_ctx,
5939                                   struct tevent_context *ev,
5940                                   struct cli_state *cli,
5941                                   uint16_t fnum)
5942 {
5943         struct tevent_req *req, *subreq;
5944         struct cli_flush_state *state;
5945
5946         req = tevent_req_create(mem_ctx, &state, struct cli_flush_state);
5947         if (req == NULL) {
5948                 return NULL;
5949         }
5950         SSVAL(state->vwv + 0, 0, fnum);
5951
5952         subreq = cli_smb_send(state, ev, cli, SMBflush, 0, 0, 1, state->vwv,
5953                               0, NULL);
5954         if (tevent_req_nomem(subreq, req)) {
5955                 return tevent_req_post(req, ev);
5956         }
5957         tevent_req_set_callback(subreq, cli_flush_done, req);
5958         return req;
5959 }
5960
5961 static void cli_flush_done(struct tevent_req *subreq)
5962 {
5963         struct tevent_req *req = tevent_req_callback_data(
5964                 subreq, struct tevent_req);
5965         NTSTATUS status;
5966
5967         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
5968         TALLOC_FREE(subreq);
5969         if (tevent_req_nterror(req, status)) {
5970                 return;
5971         }
5972         tevent_req_done(req);
5973 }
5974
5975 NTSTATUS cli_flush_recv(struct tevent_req *req)
5976 {
5977         return tevent_req_simple_recv_ntstatus(req);
5978 }
5979
5980 NTSTATUS cli_flush(TALLOC_CTX *mem_ctx, struct cli_state *cli, uint16_t fnum)
5981 {
5982         TALLOC_CTX *frame = talloc_stackframe();
5983         struct tevent_context *ev;
5984         struct tevent_req *req;
5985         NTSTATUS status = NT_STATUS_NO_MEMORY;
5986
5987         if (smbXcli_conn_has_async_calls(cli->conn)) {
5988                 /*
5989                  * Can't use sync call while an async call is in flight
5990                  */
5991                 status = NT_STATUS_INVALID_PARAMETER;
5992                 goto fail;
5993         }
5994         ev = samba_tevent_context_init(frame);
5995         if (ev == NULL) {
5996                 goto fail;
5997         }
5998         req = cli_flush_send(frame, ev, cli, fnum);
5999         if (req == NULL) {
6000                 goto fail;
6001         }
6002         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
6003                 goto fail;
6004         }
6005         status = cli_flush_recv(req);
6006  fail:
6007         TALLOC_FREE(frame);
6008         return status;
6009 }
6010
6011 struct cli_shadow_copy_data_state {
6012         uint16_t setup[4];
6013         uint8_t *data;
6014         uint32_t num_data;
6015         bool get_names;
6016 };
6017
6018 static void cli_shadow_copy_data_done(struct tevent_req *subreq);
6019
6020 struct tevent_req *cli_shadow_copy_data_send(TALLOC_CTX *mem_ctx,
6021                                              struct tevent_context *ev,
6022                                              struct cli_state *cli,
6023                                              uint16_t fnum,
6024                                              bool get_names)
6025 {
6026         struct tevent_req *req, *subreq;
6027         struct cli_shadow_copy_data_state *state;
6028         uint32_t ret_size;
6029
6030         req = tevent_req_create(mem_ctx, &state,
6031                                 struct cli_shadow_copy_data_state);
6032         if (req == NULL) {
6033                 return NULL;
6034         }
6035         state->get_names = get_names;
6036         ret_size = get_names ? CLI_BUFFER_SIZE : 16;
6037
6038         SIVAL(state->setup + 0, 0, FSCTL_GET_SHADOW_COPY_DATA);
6039         SSVAL(state->setup + 2, 0, fnum);
6040         SCVAL(state->setup + 3, 0, 1); /* isFsctl */
6041         SCVAL(state->setup + 3, 1, 0); /* compfilter, isFlags (WSSP) */
6042
6043         subreq = cli_trans_send(
6044                 state, ev, cli, 0, SMBnttrans, NULL, 0, NT_TRANSACT_IOCTL, 0,
6045                 state->setup, ARRAY_SIZE(state->setup),
6046                 ARRAY_SIZE(state->setup),
6047                 NULL, 0, 0,
6048                 NULL, 0, ret_size);
6049         if (tevent_req_nomem(subreq, req)) {
6050                 return tevent_req_post(req, ev);
6051         }
6052         tevent_req_set_callback(subreq, cli_shadow_copy_data_done, req);
6053         return req;
6054 }
6055
6056 static void cli_shadow_copy_data_done(struct tevent_req *subreq)
6057 {
6058         struct tevent_req *req = tevent_req_callback_data(
6059                 subreq, struct tevent_req);
6060         struct cli_shadow_copy_data_state *state = tevent_req_data(
6061                 req, struct cli_shadow_copy_data_state);
6062         NTSTATUS status;
6063
6064         status = cli_trans_recv(subreq, state, NULL,
6065                                 NULL, 0, NULL, /* setup */
6066                                 NULL, 0, NULL, /* param */
6067                                 &state->data, 12, &state->num_data);
6068         TALLOC_FREE(subreq);
6069         if (tevent_req_nterror(req, status)) {
6070                 return;
6071         }
6072         tevent_req_done(req);
6073 }
6074
6075 NTSTATUS cli_shadow_copy_data_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
6076                                    char ***pnames, int *pnum_names)
6077 {
6078         struct cli_shadow_copy_data_state *state = tevent_req_data(
6079                 req, struct cli_shadow_copy_data_state);
6080         char **names = NULL;
6081         uint32_t i, num_names;
6082         uint32_t dlength;
6083         uint8_t *endp = NULL;
6084         NTSTATUS status;
6085
6086         if (tevent_req_is_nterror(req, &status)) {
6087                 return status;
6088         }
6089
6090         if (state->num_data < 16) {
6091                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
6092         }
6093
6094         num_names = IVAL(state->data, 4);
6095         dlength = IVAL(state->data, 8);
6096
6097         if (num_names > 0x7FFFFFFF) {
6098                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
6099         }
6100
6101         if (!state->get_names) {
6102                 *pnum_names = (int)num_names;
6103                 return NT_STATUS_OK;
6104         }
6105
6106         if (dlength + 12 < 12) {
6107                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
6108         }
6109         if (dlength + 12 > state->num_data) {
6110                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
6111         }
6112         if (state->num_data + (2 * sizeof(SHADOW_COPY_LABEL)) <
6113                         state->num_data) {
6114                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
6115         }
6116
6117         names = talloc_array(mem_ctx, char *, num_names);
6118         if (names == NULL) {
6119                 return NT_STATUS_NO_MEMORY;
6120         }
6121
6122         endp = state->data + state->num_data;
6123
6124         for (i=0; i<num_names; i++) {
6125                 bool ret;
6126                 uint8_t *src;
6127                 size_t converted_size;
6128
6129                 src = state->data + 12 + i * 2 * sizeof(SHADOW_COPY_LABEL);
6130
6131                 if (src + (2 * sizeof(SHADOW_COPY_LABEL)) > endp) {
6132                         return NT_STATUS_INVALID_NETWORK_RESPONSE;
6133                 }
6134
6135                 ret = convert_string_talloc(
6136                         names, CH_UTF16LE, CH_UNIX,
6137                         src, 2 * sizeof(SHADOW_COPY_LABEL),
6138                         &names[i], &converted_size);
6139                 if (!ret) {
6140                         TALLOC_FREE(names);
6141                         return NT_STATUS_INVALID_NETWORK_RESPONSE;
6142                 }
6143         }
6144         *pnum_names = (int)num_names;
6145         *pnames = names;
6146         return NT_STATUS_OK;
6147 }
6148
6149 NTSTATUS cli_shadow_copy_data(TALLOC_CTX *mem_ctx, struct cli_state *cli,
6150                               uint16_t fnum, bool get_names,
6151                               char ***pnames, int *pnum_names)
6152 {
6153         TALLOC_CTX *frame = NULL;
6154         struct tevent_context *ev;
6155         struct tevent_req *req;
6156         NTSTATUS status = NT_STATUS_NO_MEMORY;
6157
6158         if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
6159                 return cli_smb2_shadow_copy_data(mem_ctx,
6160                                         cli,
6161                                         fnum,
6162                                         get_names,
6163                                         pnames,
6164                                         pnum_names);
6165         }
6166
6167         frame = talloc_stackframe();
6168
6169         if (smbXcli_conn_has_async_calls(cli->conn)) {
6170                 /*
6171                  * Can't use sync call while an async call is in flight
6172                  */
6173                 status = NT_STATUS_INVALID_PARAMETER;
6174                 goto fail;
6175         }
6176         ev = samba_tevent_context_init(frame);
6177         if (ev == NULL) {
6178                 goto fail;
6179         }
6180         req = cli_shadow_copy_data_send(frame, ev, cli, fnum, get_names);
6181         if (req == NULL) {
6182                 goto fail;
6183         }
6184         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
6185                 goto fail;
6186         }
6187         status = cli_shadow_copy_data_recv(req, mem_ctx, pnames, pnum_names);
6188  fail:
6189         TALLOC_FREE(frame);
6190         return status;
6191 }