source4/libcli/raw/rawfile.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    client file operations
   4    Copyright (C) Andrew Tridgell 1994-1998
   5    Copyright (C) Jeremy Allison 2001-2002
   6    Copyright (C) James Myers 2003
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "smb.h"
  24 #include "libcli/raw/libcliraw.h"
  25 #include "libcli/raw/raw_proto.h"
  26 #include "librpc/gen_ndr/ndr_security.h"
  27
  28 #define SETUP_REQUEST(cmd, wct, buflen) do { \
  29         req = smbcli_request_setup(tree, cmd, wct, buflen); \
  30         if (!req) return NULL; \
  31 } while (0)
  32
  33 /****************************************************************************
  34  Rename a file - async interface
  35 ****************************************************************************/
  36 struct smbcli_request *smb_raw_rename_send(struct smbcli_tree *tree,
  37                                         union smb_rename *parms)
  38 {
  39         struct smbcli_request *req = NULL;
  40         struct smb_nttrans nt;
  41         TALLOC_CTX *mem_ctx;
  42
  43         switch (parms->generic.level) {
  44         case RAW_RENAME_RENAME:
  45                 SETUP_REQUEST(SMBmv, 1, 0);
  46                 SSVAL(req->out.vwv, VWV(0), parms->rename.in.attrib);
  47                 smbcli_req_append_ascii4(req, parms->rename.in.pattern1, STR_TERMINATE);
  48                 smbcli_req_append_ascii4(req, parms->rename.in.pattern2, STR_TERMINATE);
  49                 break;
  50
  51         case RAW_RENAME_NTRENAME:
  52                 SETUP_REQUEST(SMBntrename, 4, 0);
  53                 SSVAL(req->out.vwv, VWV(0), parms->ntrename.in.attrib);
  54                 SSVAL(req->out.vwv, VWV(1), parms->ntrename.in.flags);
  55                 SIVAL(req->out.vwv, VWV(2), parms->ntrename.in.cluster_size);
  56                 smbcli_req_append_ascii4(req, parms->ntrename.in.old_name, STR_TERMINATE);
  57                 smbcli_req_append_ascii4(req, parms->ntrename.in.new_name, STR_TERMINATE);
  58                 break;
  59
  60         case RAW_RENAME_NTTRANS:
  61
  62                 mem_ctx = talloc_new(tree);
  63
  64                 nt.in.max_setup = 0;
  65                 nt.in.max_param = 0;
  66                 nt.in.max_data = 0;
  67                 nt.in.setup_count = 0;
  68                 nt.in.setup = NULL;
  69                 nt.in.function = NT_TRANSACT_RENAME;
  70                 nt.in.params = data_blob_talloc(mem_ctx, NULL, 4);
  71                 nt.in.data = data_blob(NULL, 0);
  72
  73                 SSVAL(nt.in.params.data, VWV(0), parms->nttrans.in.file.fnum);
  74                 SSVAL(nt.in.params.data, VWV(1), parms->nttrans.in.flags);
  75
  76                 smbcli_blob_append_string(tree->session, mem_ctx,
  77                                           &nt.in.params, parms->nttrans.in.new_name,
  78                                           STR_TERMINATE);
  79
  80                 req = smb_raw_nttrans_send(tree, &nt);
  81                 talloc_free(mem_ctx);
  82                 return req;
  83         }
  84
  85         if (!smbcli_request_send(req)) {
  86                 smbcli_request_destroy(req);
  87                 return NULL;
  88         }
  89
  90         return req;
  91 }
  92
  93 /****************************************************************************
  94  Rename a file - sync interface
  95 ****************************************************************************/
  96 _PUBLIC_ NTSTATUS smb_raw_rename(struct smbcli_tree *tree,
  97                         union smb_rename *parms)
  98 {
  99         struct smbcli_request *req = smb_raw_rename_send(tree, parms);
 100         return smbcli_request_simple_recv(req);
 101 }
 102
 103
 104 /****************************************************************************
 105  Delete a file - async interface
 106 ****************************************************************************/
 107 struct smbcli_request *smb_raw_unlink_send(struct smbcli_tree *tree,
 108                                            union smb_unlink *parms)
 109 {
 110         struct smbcli_request *req;
 111
 112         SETUP_REQUEST(SMBunlink, 1, 0);
 113
 114         SSVAL(req->out.vwv, VWV(0), parms->unlink.in.attrib);
 115         smbcli_req_append_ascii4(req, parms->unlink.in.pattern, STR_TERMINATE);
 116
 117         if (!smbcli_request_send(req)) {
 118                 smbcli_request_destroy(req);
 119                 return NULL;
 120         }
 121         return req;
 122 }
 123
 124 /*
 125   delete a file - sync interface
 126 */
 127 _PUBLIC_ NTSTATUS smb_raw_unlink(struct smbcli_tree *tree,
 128                         union smb_unlink *parms)
 129 {
 130         struct smbcli_request *req = smb_raw_unlink_send(tree, parms);
 131         return smbcli_request_simple_recv(req);
 132 }
 133
 134
 135 /****************************************************************************
 136  create a directory  using TRANSACT2_MKDIR - async interface
 137 ****************************************************************************/
 138 static struct smbcli_request *smb_raw_t2mkdir_send(struct smbcli_tree *tree,
 139                                                 union smb_mkdir *parms)
 140 {
 141         struct smb_trans2 t2;
 142         uint16_t setup = TRANSACT2_MKDIR;
 143         TALLOC_CTX *mem_ctx;
 144         struct smbcli_request *req;
 145         uint16_t data_total;
 146
 147         mem_ctx = talloc_init("t2mkdir");
 148
 149         data_total = ea_list_size(parms->t2mkdir.in.num_eas, parms->t2mkdir.in.eas);
 150
 151         t2.in.max_param = 2;
 152         t2.in.max_data = 0;
 153         t2.in.max_setup = 0;
 154         t2.in.flags = 0;
 155         t2.in.timeout = 0;
 156         t2.in.setup_count = 1;
 157         t2.in.setup = &setup;
 158         t2.in.params = data_blob_talloc(mem_ctx, NULL, 4);
 159         t2.in.data = data_blob_talloc(mem_ctx, NULL, data_total);
 160
 161         SIVAL(t2.in.params.data, VWV(0), 0); /* reserved */
 162
 163         smbcli_blob_append_string(tree->session, mem_ctx,
 164                                   &t2.in.params, parms->t2mkdir.in.path, STR_TERMINATE);
 165
 166         ea_put_list(t2.in.data.data, parms->t2mkdir.in.num_eas, parms->t2mkdir.in.eas);
 167
 168         req = smb_raw_trans2_send(tree, &t2);
 169
 170         talloc_free(mem_ctx);
 171
 172         return req;
 173 }
 174
 175 /****************************************************************************
 176  Create a directory - async interface
 177 ****************************************************************************/
 178 struct smbcli_request *smb_raw_mkdir_send(struct smbcli_tree *tree,
 179                                        union smb_mkdir *parms)
 180 {
 181         struct smbcli_request *req;
 182
 183         if (parms->generic.level == RAW_MKDIR_T2MKDIR) {
 184                 return smb_raw_t2mkdir_send(tree, parms);
 185         }
 186
 187         if (parms->generic.level != RAW_MKDIR_MKDIR) {
 188                 return NULL;
 189         }
 190
 191         SETUP_REQUEST(SMBmkdir, 0, 0);
 192
 193         smbcli_req_append_ascii4(req, parms->mkdir.in.path, STR_TERMINATE);
 194
 195         if (!smbcli_request_send(req)) {
 196                 return NULL;
 197         }
 198
 199         return req;
 200 }
 201
 202 /****************************************************************************
 203  Create a directory - sync interface
 204 ****************************************************************************/
 205 _PUBLIC_ NTSTATUS smb_raw_mkdir(struct smbcli_tree *tree,
 206                        union smb_mkdir *parms)
 207 {
 208         struct smbcli_request *req = smb_raw_mkdir_send(tree, parms);
 209         return smbcli_request_simple_recv(req);
 210 }
 211
 212 /****************************************************************************
 213  Remove a directory - async interface
 214 ****************************************************************************/
 215 struct smbcli_request *smb_raw_rmdir_send(struct smbcli_tree *tree,
 216                                        struct smb_rmdir *parms)
 217 {
 218         struct smbcli_request *req;
 219
 220         SETUP_REQUEST(SMBrmdir, 0, 0);
 221
 222         smbcli_req_append_ascii4(req, parms->in.path, STR_TERMINATE);
 223
 224         if (!smbcli_request_send(req)) {
 225                 smbcli_request_destroy(req);
 226                 return NULL;
 227         }
 228
 229         return req;
 230 }
 231
 232 /****************************************************************************
 233  Remove a directory - sync interface
 234 ****************************************************************************/
 235 _PUBLIC_ NTSTATUS smb_raw_rmdir(struct smbcli_tree *tree,
 236                        struct smb_rmdir *parms)
 237 {
 238         struct smbcli_request *req = smb_raw_rmdir_send(tree, parms);
 239         return smbcli_request_simple_recv(req);
 240 }
 241
 242
 243 /*
 244  Open a file using TRANSACT2_OPEN - async recv
 245 */
 246 static NTSTATUS smb_raw_nttrans_create_recv(struct smbcli_request *req,
 247                                             TALLOC_CTX *mem_ctx,
 248                                             union smb_open *parms)
 249 {
 250         NTSTATUS status;
 251         struct smb_nttrans nt;
 252         uint8_t *params;
 253
 254         status = smb_raw_nttrans_recv(req, mem_ctx, &nt);
 255         if (!NT_STATUS_IS_OK(status)) return status;
 256
 257         if (nt.out.params.length < 69) {
 258                 return NT_STATUS_INVALID_PARAMETER;
 259         }
 260
 261         params = nt.out.params.data;
 262
 263         parms->ntcreatex.out.oplock_level =                 CVAL(params, 0);
 264         parms->ntcreatex.out.file.fnum =                    SVAL(params, 2);
 265         parms->ntcreatex.out.create_action =                IVAL(params, 4);
 266         parms->ntcreatex.out.create_time =   smbcli_pull_nttime(params, 12);
 267         parms->ntcreatex.out.access_time =   smbcli_pull_nttime(params, 20);
 268         parms->ntcreatex.out.write_time =    smbcli_pull_nttime(params, 28);
 269         parms->ntcreatex.out.change_time =   smbcli_pull_nttime(params, 36);
 270         parms->ntcreatex.out.attrib =                      IVAL(params, 44);
 271         parms->ntcreatex.out.alloc_size =                  BVAL(params, 48);
 272         parms->ntcreatex.out.size =                        BVAL(params, 56);
 273         parms->ntcreatex.out.file_type =                   SVAL(params, 64);
 274         parms->ntcreatex.out.ipc_state =                   SVAL(params, 66);
 275         parms->ntcreatex.out.is_directory =                CVAL(params, 68);
 276
 277         return NT_STATUS_OK;
 278 }
 279
 280
 281 /*
 282  Open a file using NTTRANS CREATE - async send
 283 */
 284 static struct smbcli_request *smb_raw_nttrans_create_send(struct smbcli_tree *tree,
 285                                                           union smb_open *parms)
 286 {
 287         struct smb_nttrans nt;
 288         uint8_t *params;
 289         TALLOC_CTX *mem_ctx = talloc_new(tree);
 290         uint16_t fname_len;
 291         DATA_BLOB sd_blob, ea_blob;
 292         struct smbcli_request *req;
 293
 294         nt.in.max_setup = 0;
 295         nt.in.max_param = 101;
 296         nt.in.max_data  = 0;
 297         nt.in.setup_count = 0;
 298         nt.in.function = NT_TRANSACT_CREATE;
 299         nt.in.setup = NULL;
 300
 301         sd_blob = data_blob(NULL, 0);
 302         ea_blob = data_blob(NULL, 0);
 303
 304         if (parms->ntcreatex.in.sec_desc) {
 305                 enum ndr_err_code ndr_err;
 306                 ndr_err = ndr_push_struct_blob(&sd_blob, mem_ctx, NULL,
 307                                                parms->ntcreatex.in.sec_desc,
 308                                                (ndr_push_flags_fn_t)ndr_push_security_descriptor);
 309                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 310                         talloc_free(mem_ctx);
 311                         return NULL;
 312                 }
 313         }
 314
 315         if (parms->ntcreatex.in.ea_list) {
 316                 uint32_t ea_size = ea_list_size_chained(parms->ntcreatex.in.ea_list->num_eas,
 317                                                         parms->ntcreatex.in.ea_list->eas, 4);
 318                 ea_blob = data_blob_talloc(mem_ctx, NULL, ea_size);
 319                 if (ea_blob.data == NULL) {
 320                         return NULL;
 321                 }
 322                 ea_put_list_chained(ea_blob.data,
 323                                     parms->ntcreatex.in.ea_list->num_eas,
 324                                     parms->ntcreatex.in.ea_list->eas, 4);
 325         }
 326
 327         nt.in.params = data_blob_talloc(mem_ctx, NULL, 53);
 328         if (nt.in.params.data == NULL) {
 329                 talloc_free(mem_ctx);
 330                 return NULL;
 331         }
 332
 333         /* build the parameter section */
 334         params = nt.in.params.data;
 335
 336         SIVAL(params,  0, parms->ntcreatex.in.flags);
 337         SIVAL(params,  4, parms->ntcreatex.in.root_fid);
 338         SIVAL(params,  8, parms->ntcreatex.in.access_mask);
 339         SBVAL(params, 12, parms->ntcreatex.in.alloc_size);
 340         SIVAL(params, 20, parms->ntcreatex.in.file_attr);
 341         SIVAL(params, 24, parms->ntcreatex.in.share_access);
 342         SIVAL(params, 28, parms->ntcreatex.in.open_disposition);
 343         SIVAL(params, 32, parms->ntcreatex.in.create_options);
 344         SIVAL(params, 36, sd_blob.length);
 345         SIVAL(params, 40, ea_blob.length);
 346         SIVAL(params, 48, parms->ntcreatex.in.impersonation);
 347         SCVAL(params, 52, parms->ntcreatex.in.security_flags);
 348
 349         /* the empty string first forces the correct alignment */
 350         smbcli_blob_append_string(tree->session, mem_ctx, &nt.in.params,"", 0);
 351         fname_len = smbcli_blob_append_string(tree->session, mem_ctx, &nt.in.params,
 352                                               parms->ntcreatex.in.fname, STR_TERMINATE);
 353
 354         SIVAL(nt.in.params.data, 44, fname_len);
 355
 356         /* build the data section */
 357         nt.in.data = data_blob_talloc(mem_ctx, NULL, sd_blob.length + ea_blob.length);
 358         memcpy(nt.in.data.data, sd_blob.data, sd_blob.length);
 359         memcpy(nt.in.data.data+sd_blob.length, ea_blob.data, ea_blob.length);
 360
 361         /* send the request on its way */
 362         req = smb_raw_nttrans_send(tree, &nt);
 363
 364         talloc_free(mem_ctx);
 365
 366         return req;
 367 }
 368
 369
 370 /****************************************************************************
 371  Open a file using TRANSACT2_OPEN - async send
 372 ****************************************************************************/
 373 static struct smbcli_request *smb_raw_t2open_send(struct smbcli_tree *tree,
 374                                                union smb_open *parms)
 375 {
 376         struct smb_trans2 t2;
 377         uint16_t setup = TRANSACT2_OPEN;
 378         TALLOC_CTX *mem_ctx = talloc_init("smb_raw_t2open");
 379         struct smbcli_request *req;
 380         uint16_t list_size;
 381
 382         list_size = ea_list_size(parms->t2open.in.num_eas, parms->t2open.in.eas);
 383
 384         t2.in.max_param = 30;
 385         t2.in.max_data = 0;
 386         t2.in.max_setup = 0;
 387         t2.in.flags = 0;
 388         t2.in.timeout = 0;
 389         t2.in.setup_count = 1;
 390         t2.in.setup = &setup;
 391         t2.in.params = data_blob_talloc(mem_ctx, NULL, 28);
 392         t2.in.data = data_blob_talloc(mem_ctx, NULL, list_size);
 393
 394         SSVAL(t2.in.params.data, VWV(0), parms->t2open.in.flags);
 395         SSVAL(t2.in.params.data, VWV(1), parms->t2open.in.open_mode);
 396         SSVAL(t2.in.params.data, VWV(2), parms->t2open.in.search_attrs);
 397         SSVAL(t2.in.params.data, VWV(3), parms->t2open.in.file_attrs);
 398         raw_push_dos_date(tree->session->transport,
 399                           t2.in.params.data, VWV(4), parms->t2open.in.write_time);
 400         SSVAL(t2.in.params.data, VWV(6), parms->t2open.in.open_func);
 401         SIVAL(t2.in.params.data, VWV(7), parms->t2open.in.size);
 402         SIVAL(t2.in.params.data, VWV(9), parms->t2open.in.timeout);
 403         SIVAL(t2.in.params.data, VWV(11), 0);
 404         SSVAL(t2.in.params.data, VWV(13), 0);
 405
 406         smbcli_blob_append_string(tree->session, mem_ctx,
 407                                   &t2.in.params, parms->t2open.in.fname,
 408                                   STR_TERMINATE);
 409
 410         ea_put_list(t2.in.data.data, parms->t2open.in.num_eas, parms->t2open.in.eas);
 411
 412         req = smb_raw_trans2_send(tree, &t2);
 413
 414         talloc_free(mem_ctx);
 415
 416         return req;
 417 }
 418
 419
 420 /****************************************************************************
 421  Open a file using TRANSACT2_OPEN - async recv
 422 ****************************************************************************/
 423 static NTSTATUS smb_raw_t2open_recv(struct smbcli_request *req, TALLOC_CTX *mem_ctx, union smb_open *parms)
 424 {
 425         struct smbcli_transport *transport = req->transport;
 426         struct smb_trans2 t2;
 427         NTSTATUS status;
 428
 429         status = smb_raw_trans2_recv(req, mem_ctx, &t2);
 430         if (!NT_STATUS_IS_OK(status)) return status;
 431
 432         if (t2.out.params.length < 30) {
 433                 return NT_STATUS_INFO_LENGTH_MISMATCH;
 434         }
 435
 436         parms->t2open.out.file.fnum =   SVAL(t2.out.params.data, VWV(0));
 437         parms->t2open.out.attrib =      SVAL(t2.out.params.data, VWV(1));
 438         parms->t2open.out.write_time =  raw_pull_dos_date3(transport, t2.out.params.data + VWV(2));
 439         parms->t2open.out.size =        IVAL(t2.out.params.data, VWV(4));
 440         parms->t2open.out.access =      SVAL(t2.out.params.data, VWV(6));
 441         parms->t2open.out.ftype =       SVAL(t2.out.params.data, VWV(7));
 442         parms->t2open.out.devstate =    SVAL(t2.out.params.data, VWV(8));
 443         parms->t2open.out.action =      SVAL(t2.out.params.data, VWV(9));
 444         parms->t2open.out.file_id =     SVAL(t2.out.params.data, VWV(10));
 445
 446         return NT_STATUS_OK;
 447 }
 448
 449 /****************************************************************************
 450  Open a file - async send
 451 ****************************************************************************/
 452 _PUBLIC_ struct smbcli_request *smb_raw_open_send(struct smbcli_tree *tree, union smb_open *parms)
 453 {
 454         int len;
 455         struct smbcli_request *req = NULL;
 456         bool bigoffset = false;
 457
 458         switch (parms->generic.level) {
 459         case RAW_OPEN_T2OPEN:
 460                 return smb_raw_t2open_send(tree, parms);
 461
 462         case RAW_OPEN_OPEN:
 463                 SETUP_REQUEST(SMBopen, 2, 0);
 464                 SSVAL(req->out.vwv, VWV(0), parms->openold.in.open_mode);
 465                 SSVAL(req->out.vwv, VWV(1), parms->openold.in.search_attrs);
 466                 smbcli_req_append_ascii4(req, parms->openold.in.fname, STR_TERMINATE);
 467                 break;
 468
 469         case RAW_OPEN_OPENX:
 470                 SETUP_REQUEST(SMBopenX, 15, 0);
 471                 SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
 472                 SSVAL(req->out.vwv, VWV(1), 0);
 473                 SSVAL(req->out.vwv, VWV(2), parms->openx.in.flags);
 474                 SSVAL(req->out.vwv, VWV(3), parms->openx.in.open_mode);
 475                 SSVAL(req->out.vwv, VWV(4), parms->openx.in.search_attrs);
 476                 SSVAL(req->out.vwv, VWV(5), parms->openx.in.file_attrs);
 477                 raw_push_dos_date3(tree->session->transport,
 478                                   req->out.vwv, VWV(6), parms->openx.in.write_time);
 479                 SSVAL(req->out.vwv, VWV(8), parms->openx.in.open_func);
 480                 SIVAL(req->out.vwv, VWV(9), parms->openx.in.size);
 481                 SIVAL(req->out.vwv, VWV(11),parms->openx.in.timeout);
 482                 SIVAL(req->out.vwv, VWV(13),0); /* reserved */
 483                 smbcli_req_append_string(req, parms->openx.in.fname, STR_TERMINATE);
 484                 break;
 485
 486         case RAW_OPEN_MKNEW:
 487                 SETUP_REQUEST(SMBmknew, 3, 0);
 488                 SSVAL(req->out.vwv, VWV(0), parms->mknew.in.attrib);
 489                 raw_push_dos_date3(tree->session->transport,
 490                                   req->out.vwv, VWV(1), parms->mknew.in.write_time);
 491                 smbcli_req_append_ascii4(req, parms->mknew.in.fname, STR_TERMINATE);
 492                 break;
 493
 494         case RAW_OPEN_CREATE:
 495                 SETUP_REQUEST(SMBcreate, 3, 0);
 496                 SSVAL(req->out.vwv, VWV(0), parms->create.in.attrib);
 497                 raw_push_dos_date3(tree->session->transport,
 498                                   req->out.vwv, VWV(1), parms->create.in.write_time);
 499                 smbcli_req_append_ascii4(req, parms->create.in.fname, STR_TERMINATE);
 500                 break;
 501
 502         case RAW_OPEN_CTEMP:
 503                 SETUP_REQUEST(SMBctemp, 3, 0);
 504                 SSVAL(req->out.vwv, VWV(0), parms->ctemp.in.attrib);
 505                 raw_push_dos_date3(tree->session->transport,
 506                                   req->out.vwv, VWV(1), parms->ctemp.in.write_time);
 507                 smbcli_req_append_ascii4(req, parms->ctemp.in.directory, STR_TERMINATE);
 508                 break;
 509
 510         case RAW_OPEN_SPLOPEN:
 511                 SETUP_REQUEST(SMBsplopen, 2, 0);
 512                 SSVAL(req->out.vwv, VWV(0), parms->splopen.in.setup_length);
 513                 SSVAL(req->out.vwv, VWV(1), parms->splopen.in.mode);
 514                 break;
 515
 516         case RAW_OPEN_NTCREATEX:
 517                 SETUP_REQUEST(SMBntcreateX, 24, 0);
 518                 SSVAL(req->out.vwv, VWV(0),SMB_CHAIN_NONE);
 519                 SSVAL(req->out.vwv, VWV(1),0);
 520                 SCVAL(req->out.vwv, VWV(2),0); /* padding */
 521                 SIVAL(req->out.vwv,  7, parms->ntcreatex.in.flags);
 522                 SIVAL(req->out.vwv, 11, parms->ntcreatex.in.root_fid);
 523                 SIVAL(req->out.vwv, 15, parms->ntcreatex.in.access_mask);
 524                 SBVAL(req->out.vwv, 19, parms->ntcreatex.in.alloc_size);
 525                 SIVAL(req->out.vwv, 27, parms->ntcreatex.in.file_attr);
 526                 SIVAL(req->out.vwv, 31, parms->ntcreatex.in.share_access);
 527                 SIVAL(req->out.vwv, 35, parms->ntcreatex.in.open_disposition);
 528                 SIVAL(req->out.vwv, 39, parms->ntcreatex.in.create_options);
 529                 SIVAL(req->out.vwv, 43, parms->ntcreatex.in.impersonation);
 530                 SCVAL(req->out.vwv, 47, parms->ntcreatex.in.security_flags);
 531
 532                 smbcli_req_append_string_len(req, parms->ntcreatex.in.fname, STR_TERMINATE, &len);
 533                 SSVAL(req->out.vwv, 5, len);
 534                 break;
 535
 536         case RAW_OPEN_NTTRANS_CREATE:
 537                 return smb_raw_nttrans_create_send(tree, parms);
 538
 539
 540         case RAW_OPEN_OPENX_READX:
 541                 SETUP_REQUEST(SMBopenX, 15, 0);
 542                 SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
 543                 SSVAL(req->out.vwv, VWV(1), 0);
 544                 SSVAL(req->out.vwv, VWV(2), parms->openxreadx.in.flags);
 545                 SSVAL(req->out.vwv, VWV(3), parms->openxreadx.in.open_mode);
 546                 SSVAL(req->out.vwv, VWV(4), parms->openxreadx.in.search_attrs);
 547                 SSVAL(req->out.vwv, VWV(5), parms->openxreadx.in.file_attrs);
 548                 raw_push_dos_date3(tree->session->transport,
 549                                   req->out.vwv, VWV(6), parms->openxreadx.in.write_time);
 550                 SSVAL(req->out.vwv, VWV(8), parms->openxreadx.in.open_func);
 551                 SIVAL(req->out.vwv, VWV(9), parms->openxreadx.in.size);
 552                 SIVAL(req->out.vwv, VWV(11),parms->openxreadx.in.timeout);
 553                 SIVAL(req->out.vwv, VWV(13),0);
 554                 smbcli_req_append_string(req, parms->openxreadx.in.fname, STR_TERMINATE);
 555
 556                 if (tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES) {
 557                         bigoffset = true;
 558                 }
 559
 560                 smbcli_chained_request_setup(req, SMBreadX, bigoffset ? 12 : 10, 0);
 561
 562                 SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
 563                 SSVAL(req->out.vwv, VWV(1), 0);
 564                 SSVAL(req->out.vwv, VWV(2), 0);
 565                 SIVAL(req->out.vwv, VWV(3), parms->openxreadx.in.offset);
 566                 SSVAL(req->out.vwv, VWV(5), parms->openxreadx.in.maxcnt & 0xFFFF);
 567                 SSVAL(req->out.vwv, VWV(6), parms->openxreadx.in.mincnt);
 568                 SIVAL(req->out.vwv, VWV(7), parms->openxreadx.in.maxcnt >> 16);
 569                 SSVAL(req->out.vwv, VWV(9), parms->openxreadx.in.remaining);
 570                 if (bigoffset) {
 571                         SIVAL(req->out.vwv, VWV(10),parms->openxreadx.in.offset>>32);
 572                 }
 573                 break;
 574         case RAW_OPEN_SMB2:
 575                 return NULL;
 576         }
 577
 578         if (!smbcli_request_send(req)) {
 579                 smbcli_request_destroy(req);
 580                 return NULL;
 581         }
 582
 583         return req;
 584 }
 585
 586 /****************************************************************************
 587  Open a file - async recv
 588 ****************************************************************************/
 589 _PUBLIC_ NTSTATUS smb_raw_open_recv(struct smbcli_request *req, TALLOC_CTX *mem_ctx, union smb_open *parms)
 590 {
 591         NTSTATUS status;
 592
 593         if (!smbcli_request_receive(req) ||
 594             smbcli_request_is_error(req)) {
 595                 goto failed;
 596         }
 597
 598         switch (parms->openold.level) {
 599         case RAW_OPEN_T2OPEN:
 600                 return smb_raw_t2open_recv(req, mem_ctx, parms);
 601
 602         case RAW_OPEN_OPEN:
 603                 SMBCLI_CHECK_WCT(req, 7);
 604                 parms->openold.out.file.fnum = SVAL(req->in.vwv, VWV(0));
 605                 parms->openold.out.attrib = SVAL(req->in.vwv, VWV(1));
 606                 parms->openold.out.write_time = raw_pull_dos_date3(req->transport,
 607                                                                 req->in.vwv + VWV(2));
 608                 parms->openold.out.size = IVAL(req->in.vwv, VWV(4));
 609                 parms->openold.out.rmode = SVAL(req->in.vwv, VWV(6));
 610                 break;
 611
 612         case RAW_OPEN_OPENX:
 613                 SMBCLI_CHECK_MIN_WCT(req, 15);
 614                 parms->openx.out.file.fnum = SVAL(req->in.vwv, VWV(2));
 615                 parms->openx.out.attrib = SVAL(req->in.vwv, VWV(3));
 616                 parms->openx.out.write_time = raw_pull_dos_date3(req->transport,
 617                                                                  req->in.vwv + VWV(4));
 618                 parms->openx.out.size = IVAL(req->in.vwv, VWV(6));
 619                 parms->openx.out.access = SVAL(req->in.vwv, VWV(8));
 620                 parms->openx.out.ftype = SVAL(req->in.vwv, VWV(9));
 621                 parms->openx.out.devstate = SVAL(req->in.vwv, VWV(10));
 622                 parms->openx.out.action = SVAL(req->in.vwv, VWV(11));
 623                 parms->openx.out.unique_fid = IVAL(req->in.vwv, VWV(12));
 624                 if (req->in.wct >= 19) {
 625                         parms->openx.out.access_mask = IVAL(req->in.vwv, VWV(15));
 626                         parms->openx.out.unknown =     IVAL(req->in.vwv, VWV(17));
 627                 } else {
 628                         parms->openx.out.access_mask = 0;
 629                         parms->openx.out.unknown = 0;
 630                 }
 631                 break;
 632
 633         case RAW_OPEN_MKNEW:
 634                 SMBCLI_CHECK_WCT(req, 1);
 635                 parms->mknew.out.file.fnum = SVAL(req->in.vwv, VWV(0));
 636                 break;
 637
 638         case RAW_OPEN_CREATE:
 639                 SMBCLI_CHECK_WCT(req, 1);
 640                 parms->create.out.file.fnum = SVAL(req->in.vwv, VWV(0));
 641                 break;
 642
 643         case RAW_OPEN_CTEMP:
 644                 SMBCLI_CHECK_WCT(req, 1);
 645                 parms->ctemp.out.file.fnum = SVAL(req->in.vwv, VWV(0));
 646                 smbcli_req_pull_string(&req->in.bufinfo, mem_ctx, &parms->ctemp.out.name, req->in.data, -1, STR_TERMINATE | STR_ASCII);
 647                 break;
 648
 649         case RAW_OPEN_SPLOPEN:
 650                 SMBCLI_CHECK_WCT(req, 1);
 651                 parms->splopen.out.file.fnum = SVAL(req->in.vwv, VWV(0));
 652                 break;
 653
 654         case RAW_OPEN_NTCREATEX:
 655                 SMBCLI_CHECK_MIN_WCT(req, 34);
 656                 parms->ntcreatex.out.oplock_level =              CVAL(req->in.vwv, 4);
 657                 parms->ntcreatex.out.file.fnum =                 SVAL(req->in.vwv, 5);
 658                 parms->ntcreatex.out.create_action =             IVAL(req->in.vwv, 7);
 659                 parms->ntcreatex.out.create_time =   smbcli_pull_nttime(req->in.vwv, 11);
 660                 parms->ntcreatex.out.access_time =   smbcli_pull_nttime(req->in.vwv, 19);
 661                 parms->ntcreatex.out.write_time =    smbcli_pull_nttime(req->in.vwv, 27);
 662                 parms->ntcreatex.out.change_time =   smbcli_pull_nttime(req->in.vwv, 35);
 663                 parms->ntcreatex.out.attrib =                   IVAL(req->in.vwv, 43);
 664                 parms->ntcreatex.out.alloc_size =               BVAL(req->in.vwv, 47);
 665                 parms->ntcreatex.out.size =                     BVAL(req->in.vwv, 55);
 666                 parms->ntcreatex.out.file_type =                SVAL(req->in.vwv, 63);
 667                 parms->ntcreatex.out.ipc_state =                SVAL(req->in.vwv, 65);
 668                 parms->ntcreatex.out.is_directory =             CVAL(req->in.vwv, 67);
 669                 break;
 670
 671         case RAW_OPEN_NTTRANS_CREATE:
 672                 return smb_raw_nttrans_create_recv(req, mem_ctx, parms);
 673
 674         case RAW_OPEN_OPENX_READX:
 675                 SMBCLI_CHECK_MIN_WCT(req, 15);
 676                 parms->openxreadx.out.file.fnum = SVAL(req->in.vwv, VWV(2));
 677                 parms->openxreadx.out.attrib = SVAL(req->in.vwv, VWV(3));
 678                 parms->openxreadx.out.write_time = raw_pull_dos_date3(req->transport,
 679                                                                  req->in.vwv + VWV(4));
 680                 parms->openxreadx.out.size = IVAL(req->in.vwv, VWV(6));
 681                 parms->openxreadx.out.access = SVAL(req->in.vwv, VWV(8));
 682                 parms->openxreadx.out.ftype = SVAL(req->in.vwv, VWV(9));
 683                 parms->openxreadx.out.devstate = SVAL(req->in.vwv, VWV(10));
 684                 parms->openxreadx.out.action = SVAL(req->in.vwv, VWV(11));
 685                 parms->openxreadx.out.unique_fid = IVAL(req->in.vwv, VWV(12));
 686                 if (req->in.wct >= 19) {
 687                         parms->openxreadx.out.access_mask = IVAL(req->in.vwv, VWV(15));
 688                         parms->openxreadx.out.unknown =     IVAL(req->in.vwv, VWV(17));
 689                 } else {
 690                         parms->openxreadx.out.access_mask = 0;
 691                         parms->openxreadx.out.unknown = 0;
 692                 }
 693
 694                 status = smbcli_chained_advance(req);
 695                 if (!NT_STATUS_IS_OK(status)) {
 696                         return status;
 697                 }
 698
 699                 SMBCLI_CHECK_WCT(req, 12);
 700                 parms->openxreadx.out.remaining       = SVAL(req->in.vwv, VWV(2));
 701                 parms->openxreadx.out.compaction_mode = SVAL(req->in.vwv, VWV(3));
 702                 parms->openxreadx.out.nread = SVAL(req->in.vwv, VWV(5));
 703                 if (parms->openxreadx.out.nread >
 704                     MAX(parms->openxreadx.in.mincnt, parms->openxreadx.in.maxcnt) ||
 705                     !smbcli_raw_pull_data(&req->in.bufinfo, req->in.hdr + SVAL(req->in.vwv, VWV(6)),
 706                                           parms->openxreadx.out.nread,
 707                                           parms->openxreadx.out.data)) {
 708                         req->status = NT_STATUS_BUFFER_TOO_SMALL;
 709                 }
 710                 break;
 711         case RAW_OPEN_SMB2:
 712                 req->status = NT_STATUS_INTERNAL_ERROR;
 713                 break;
 714         }
 715
 716 failed:
 717         return smbcli_request_destroy(req);
 718 }
 719
 720
 721 /****************************************************************************
 722  Open a file - sync interface
 723 ****************************************************************************/
 724 _PUBLIC_ NTSTATUS smb_raw_open(struct smbcli_tree *tree, TALLOC_CTX *mem_ctx, union smb_open *parms)
 725 {
 726         struct smbcli_request *req = smb_raw_open_send(tree, parms);
 727         return smb_raw_open_recv(req, mem_ctx, parms);
 728 }
 729
 730
 731 /****************************************************************************
 732  Close a file - async send
 733 ****************************************************************************/
 734 _PUBLIC_ struct smbcli_request *smb_raw_close_send(struct smbcli_tree *tree, union smb_close *parms)
 735 {
 736         struct smbcli_request *req = NULL;
 737
 738         switch (parms->generic.level) {
 739         case RAW_CLOSE_CLOSE:
 740                 SETUP_REQUEST(SMBclose, 3, 0);
 741                 SSVAL(req->out.vwv, VWV(0), parms->close.in.file.fnum);
 742                 raw_push_dos_date3(tree->session->transport,
 743                                   req->out.vwv, VWV(1), parms->close.in.write_time);
 744                 break;
 745
 746         case RAW_CLOSE_SPLCLOSE:
 747                 SETUP_REQUEST(SMBsplclose, 3, 0);
 748                 SSVAL(req->out.vwv, VWV(0), parms->splclose.in.file.fnum);
 749                 SIVAL(req->out.vwv, VWV(1), 0); /* reserved */
 750                 break;
 751
 752         case RAW_CLOSE_SMB2:
 753                 return NULL;
 754         }
 755
 756         if (!req) return NULL;
 757
 758         if (!smbcli_request_send(req)) {
 759                 smbcli_request_destroy(req);
 760                 return NULL;
 761         }
 762
 763         return req;
 764 }
 765
 766
 767 /****************************************************************************
 768  Close a file - sync interface
 769 ****************************************************************************/
 770 _PUBLIC_ NTSTATUS smb_raw_close(struct smbcli_tree *tree, union smb_close *parms)
 771 {
 772         struct smbcli_request *req = smb_raw_close_send(tree, parms);
 773         return smbcli_request_simple_recv(req);
 774 }
 775
 776
 777 /****************************************************************************
 778  Locking calls - async interface
 779 ****************************************************************************/
 780 struct smbcli_request *smb_raw_lock_send(struct smbcli_tree *tree, union smb_lock *parms)
 781 {
 782         struct smbcli_request *req = NULL;
 783
 784         switch (parms->generic.level) {
 785         case RAW_LOCK_LOCK:
 786                 SETUP_REQUEST(SMBlock, 5, 0);
 787                 SSVAL(req->out.vwv, VWV(0), parms->lock.in.file.fnum);
 788                 SIVAL(req->out.vwv, VWV(1), parms->lock.in.count);
 789                 SIVAL(req->out.vwv, VWV(3), parms->lock.in.offset);
 790                 break;
 791
 792         case RAW_LOCK_UNLOCK:
 793                 SETUP_REQUEST(SMBunlock, 5, 0);
 794                 SSVAL(req->out.vwv, VWV(0), parms->unlock.in.file.fnum);
 795                 SIVAL(req->out.vwv, VWV(1), parms->unlock.in.count);
 796                 SIVAL(req->out.vwv, VWV(3), parms->unlock.in.offset);
 797                 break;
 798
 799         case RAW_LOCK_LOCKX: {
 800                 struct smb_lock_entry *lockp;
 801                 uint_t lck_size = (parms->lockx.in.mode & LOCKING_ANDX_LARGE_FILES)? 20 : 10;
 802                 uint_t lock_count = parms->lockx.in.ulock_cnt + parms->lockx.in.lock_cnt;
 803                 int i;
 804
 805                 SETUP_REQUEST(SMBlockingX, 8, lck_size * lock_count);
 806                 SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
 807                 SSVAL(req->out.vwv, VWV(1), 0);
 808                 SSVAL(req->out.vwv, VWV(2), parms->lockx.in.file.fnum);
 809                 SSVAL(req->out.vwv, VWV(3), parms->lockx.in.mode);
 810                 SIVAL(req->out.vwv, VWV(4), parms->lockx.in.timeout);
 811                 SSVAL(req->out.vwv, VWV(6), parms->lockx.in.ulock_cnt);
 812                 SSVAL(req->out.vwv, VWV(7), parms->lockx.in.lock_cnt);
 813
 814                 /* copy in all the locks */
 815                 lockp = &parms->lockx.in.locks[0];
 816                 for (i = 0; i < lock_count; i++) {
 817                         uint8_t *p = req->out.data + lck_size * i;
 818                         SSVAL(p, 0, lockp[i].pid);
 819                         if (parms->lockx.in.mode & LOCKING_ANDX_LARGE_FILES) {
 820                                 SSVAL(p,  2, 0); /* reserved */
 821                                 SIVAL(p,  4, lockp[i].offset>>32);
 822                                 SIVAL(p,  8, lockp[i].offset);
 823                                 SIVAL(p, 12, lockp[i].count>>32);
 824                                 SIVAL(p, 16, lockp[i].count);
 825                         } else {
 826                                 SIVAL(p, 2, lockp[i].offset);
 827                                 SIVAL(p, 6, lockp[i].count);
 828                         }
 829                 }
 830                 break;
 831         }
 832         case RAW_LOCK_SMB2:
 833                 return NULL;
 834         }
 835
 836         if (!smbcli_request_send(req)) {
 837                 smbcli_request_destroy(req);
 838                 return NULL;
 839         }
 840
 841         return req;
 842 }
 843
 844 /****************************************************************************
 845  Locking calls - sync interface
 846 ****************************************************************************/
 847 _PUBLIC_ NTSTATUS smb_raw_lock(struct smbcli_tree *tree, union smb_lock *parms)
 848 {
 849         struct smbcli_request *req = smb_raw_lock_send(tree, parms);
 850         return smbcli_request_simple_recv(req);
 851 }
 852
 853
 854 /****************************************************************************
 855  Check for existence of a dir - async send
 856 ****************************************************************************/
 857 struct smbcli_request *smb_raw_chkpath_send(struct smbcli_tree *tree, union smb_chkpath *parms)
 858 {
 859         struct smbcli_request *req;
 860
 861         SETUP_REQUEST(SMBchkpth, 0, 0);
 862
 863         smbcli_req_append_ascii4(req, parms->chkpath.in.path, STR_TERMINATE);
 864
 865         if (!smbcli_request_send(req)) {
 866                 smbcli_request_destroy(req);
 867                 return NULL;
 868         }
 869
 870         return req;
 871 }
 872
 873 /****************************************************************************
 874  Check for existence of a dir - sync interface
 875 ****************************************************************************/
 876 NTSTATUS smb_raw_chkpath(struct smbcli_tree *tree, union smb_chkpath *parms)
 877 {
 878         struct smbcli_request *req = smb_raw_chkpath_send(tree, parms);
 879         return smbcli_request_simple_recv(req);
 880 }
 881
 882 /****************************************************************************
 883  flush a file - async send
 884  a flush with RAW_FLUSH_ALL will flush all files
 885 ****************************************************************************/
 886 struct smbcli_request *smb_raw_flush_send(struct smbcli_tree *tree, union smb_flush *parms)
 887 {
 888         struct smbcli_request *req;
 889         uint16_t fnum=0;
 890
 891         switch (parms->generic.level) {
 892         case RAW_FLUSH_FLUSH:
 893                 fnum = parms->flush.in.file.fnum;
 894                 break;
 895         case RAW_FLUSH_ALL:
 896                 fnum = 0xFFFF;
 897                 break;
 898         case RAW_FLUSH_SMB2:
 899                 return NULL;
 900         }
 901
 902         SETUP_REQUEST(SMBflush, 1, 0);
 903         SSVAL(req->out.vwv, VWV(0), fnum);
 904
 905         if (!smbcli_request_send(req)) {
 906                 smbcli_request_destroy(req);
 907                 return NULL;
 908         }
 909
 910         return req;
 911 }
 912
 913
 914 /****************************************************************************
 915  flush a file - sync interface
 916 ****************************************************************************/
 917 _PUBLIC_ NTSTATUS smb_raw_flush(struct smbcli_tree *tree, union smb_flush *parms)
 918 {
 919         struct smbcli_request *req = smb_raw_flush_send(tree, parms);
 920         return smbcli_request_simple_recv(req);
 921 }
 922
 923
 924 /****************************************************************************
 925  seek a file - async send
 926 ****************************************************************************/
 927 struct smbcli_request *smb_raw_seek_send(struct smbcli_tree *tree,
 928                                          union smb_seek *parms)
 929 {
 930         struct smbcli_request *req;
 931
 932         SETUP_REQUEST(SMBlseek, 4, 0);
 933
 934         SSVAL(req->out.vwv, VWV(0), parms->lseek.in.file.fnum);
 935         SSVAL(req->out.vwv, VWV(1), parms->lseek.in.mode);
 936         SIVALS(req->out.vwv, VWV(2), parms->lseek.in.offset);
 937
 938         if (!smbcli_request_send(req)) {
 939                 smbcli_request_destroy(req);
 940                 return NULL;
 941         }
 942         return req;
 943 }
 944
 945 /****************************************************************************
 946  seek a file - async receive
 947 ****************************************************************************/
 948 NTSTATUS smb_raw_seek_recv(struct smbcli_request *req,
 949                            union smb_seek *parms)
 950 {
 951         if (!smbcli_request_receive(req) ||
 952             smbcli_request_is_error(req)) {
 953                 return smbcli_request_destroy(req);
 954         }
 955
 956         SMBCLI_CHECK_WCT(req, 2);
 957         parms->lseek.out.offset = IVAL(req->in.vwv, VWV(0));
 958
 959 failed:
 960         return smbcli_request_destroy(req);
 961 }
 962
 963 /*
 964   seek a file - sync interface
 965 */
 966 _PUBLIC_ NTSTATUS smb_raw_seek(struct smbcli_tree *tree,
 967                       union smb_seek *parms)
 968 {
 969         struct smbcli_request *req = smb_raw_seek_send(tree, parms);
 970         return smb_raw_seek_recv(req, parms);
 971 }