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