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