2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Jeremy Allison 2001-2002
6 Copyright (C) James Myers 2003
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.
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.
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/>.
24 #include "libcli/raw/libcliraw.h"
25 #include "libcli/raw/raw_proto.h"
26 #include "librpc/gen_ndr/ndr_security.h"
28 #define SETUP_REQUEST(cmd, wct, buflen) do { \
29 req = smbcli_request_setup(tree, cmd, wct, buflen); \
30 if (!req) return NULL; \
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)
39 struct smbcli_request *req = NULL;
40 struct smb_nttrans nt;
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);
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);
60 case RAW_RENAME_NTTRANS:
62 mem_ctx = talloc_new(tree);
67 nt.in.setup_count = 0;
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);
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);
76 smbcli_blob_append_string(tree->session, mem_ctx,
77 &nt.in.params, parms->nttrans.in.new_name,
80 req = smb_raw_nttrans_send(tree, &nt);
85 if (!smbcli_request_send(req)) {
86 smbcli_request_destroy(req);
93 /****************************************************************************
94 Rename a file - sync interface
95 ****************************************************************************/
96 _PUBLIC_ NTSTATUS smb_raw_rename(struct smbcli_tree *tree,
97 union smb_rename *parms)
99 struct smbcli_request *req = smb_raw_rename_send(tree, parms);
100 return smbcli_request_simple_recv(req);
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)
110 struct smbcli_request *req;
112 SETUP_REQUEST(SMBunlink, 1, 0);
114 SSVAL(req->out.vwv, VWV(0), parms->unlink.in.attrib);
115 smbcli_req_append_ascii4(req, parms->unlink.in.pattern, STR_TERMINATE);
117 if (!smbcli_request_send(req)) {
118 smbcli_request_destroy(req);
125 delete a file - sync interface
127 _PUBLIC_ NTSTATUS smb_raw_unlink(struct smbcli_tree *tree,
128 union smb_unlink *parms)
130 struct smbcli_request *req = smb_raw_unlink_send(tree, parms);
131 return smbcli_request_simple_recv(req);
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)
141 struct smb_trans2 t2;
142 uint16_t setup = TRANSACT2_MKDIR;
144 struct smbcli_request *req;
147 mem_ctx = talloc_init("t2mkdir");
149 data_total = ea_list_size(parms->t2mkdir.in.num_eas, parms->t2mkdir.in.eas);
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);
161 SIVAL(t2.in.params.data, VWV(0), 0); /* reserved */
163 smbcli_blob_append_string(tree->session, mem_ctx,
164 &t2.in.params, parms->t2mkdir.in.path, STR_TERMINATE);
166 ea_put_list(t2.in.data.data, parms->t2mkdir.in.num_eas, parms->t2mkdir.in.eas);
168 req = smb_raw_trans2_send(tree, &t2);
170 talloc_free(mem_ctx);
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)
181 struct smbcli_request *req;
183 if (parms->generic.level == RAW_MKDIR_T2MKDIR) {
184 return smb_raw_t2mkdir_send(tree, parms);
187 if (parms->generic.level != RAW_MKDIR_MKDIR) {
191 SETUP_REQUEST(SMBmkdir, 0, 0);
193 smbcli_req_append_ascii4(req, parms->mkdir.in.path, STR_TERMINATE);
195 if (!smbcli_request_send(req)) {
202 /****************************************************************************
203 Create a directory - sync interface
204 ****************************************************************************/
205 _PUBLIC_ NTSTATUS smb_raw_mkdir(struct smbcli_tree *tree,
206 union smb_mkdir *parms)
208 struct smbcli_request *req = smb_raw_mkdir_send(tree, parms);
209 return smbcli_request_simple_recv(req);
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)
218 struct smbcli_request *req;
220 SETUP_REQUEST(SMBrmdir, 0, 0);
222 smbcli_req_append_ascii4(req, parms->in.path, STR_TERMINATE);
224 if (!smbcli_request_send(req)) {
225 smbcli_request_destroy(req);
232 /****************************************************************************
233 Remove a directory - sync interface
234 ****************************************************************************/
235 _PUBLIC_ NTSTATUS smb_raw_rmdir(struct smbcli_tree *tree,
236 struct smb_rmdir *parms)
238 struct smbcli_request *req = smb_raw_rmdir_send(tree, parms);
239 return smbcli_request_simple_recv(req);
244 Open a file using TRANSACT2_OPEN - async recv
246 static NTSTATUS smb_raw_nttrans_create_recv(struct smbcli_request *req,
248 union smb_open *parms)
251 struct smb_nttrans nt;
254 status = smb_raw_nttrans_recv(req, mem_ctx, &nt);
255 if (!NT_STATUS_IS_OK(status)) return status;
257 if (nt.out.params.length < 69) {
258 return NT_STATUS_INVALID_PARAMETER;
261 params = nt.out.params.data;
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);
282 Open a file using NTTRANS CREATE - async send
284 static struct smbcli_request *smb_raw_nttrans_create_send(struct smbcli_tree *tree,
285 union smb_open *parms)
287 struct smb_nttrans nt;
289 TALLOC_CTX *mem_ctx = talloc_new(tree);
291 DATA_BLOB sd_blob, ea_blob;
292 struct smbcli_request *req;
295 nt.in.max_param = 101;
297 nt.in.setup_count = 0;
298 nt.in.function = NT_TRANSACT_CREATE;
301 sd_blob = data_blob(NULL, 0);
302 ea_blob = data_blob(NULL, 0);
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);
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) {
322 ea_put_list_chained(ea_blob.data,
323 parms->ntcreatex.in.ea_list->num_eas,
324 parms->ntcreatex.in.ea_list->eas, 4);
327 nt.in.params = data_blob_talloc(mem_ctx, NULL, 53);
328 if (nt.in.params.data == NULL) {
329 talloc_free(mem_ctx);
333 /* build the parameter section */
334 params = nt.in.params.data;
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);
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);
354 SIVAL(nt.in.params.data, 44, fname_len);
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);
361 /* send the request on its way */
362 req = smb_raw_nttrans_send(tree, &nt);
364 talloc_free(mem_ctx);
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)
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;
382 list_size = ea_list_size(parms->t2open.in.num_eas, parms->t2open.in.eas);
384 t2.in.max_param = 30;
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);
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);
406 smbcli_blob_append_string(tree->session, mem_ctx,
407 &t2.in.params, parms->t2open.in.fname,
410 ea_put_list(t2.in.data.data, parms->t2open.in.num_eas, parms->t2open.in.eas);
412 req = smb_raw_trans2_send(tree, &t2);
414 talloc_free(mem_ctx);
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)
425 struct smbcli_transport *transport = req->transport;
426 struct smb_trans2 t2;
429 status = smb_raw_trans2_recv(req, mem_ctx, &t2);
430 if (!NT_STATUS_IS_OK(status)) return status;
432 if (t2.out.params.length < 30) {
433 return NT_STATUS_INFO_LENGTH_MISMATCH;
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));
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)
455 struct smbcli_request *req = NULL;
456 bool bigoffset = false;
458 switch (parms->generic.level) {
459 case RAW_OPEN_T2OPEN:
460 return smb_raw_t2open_send(tree, parms);
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);
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);
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);
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);
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);
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);
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);
532 smbcli_req_append_string_len(req, parms->ntcreatex.in.fname, STR_TERMINATE, &len);
533 SSVAL(req->out.vwv, 5, len);
536 case RAW_OPEN_NTTRANS_CREATE:
537 return smb_raw_nttrans_create_send(tree, parms);
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);
556 if (tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES) {
560 smbcli_chained_request_setup(req, SMBreadX, bigoffset ? 12 : 10, 0);
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);
571 SIVAL(req->out.vwv, VWV(10),parms->openxreadx.in.offset>>32);
578 if (!smbcli_request_send(req)) {
579 smbcli_request_destroy(req);
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)
593 if (!smbcli_request_receive(req) ||
594 smbcli_request_is_error(req)) {
598 switch (parms->openold.level) {
599 case RAW_OPEN_T2OPEN:
600 return smb_raw_t2open_recv(req, mem_ctx, parms);
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));
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));
628 parms->openx.out.access_mask = 0;
629 parms->openx.out.unknown = 0;
634 SMBCLI_CHECK_WCT(req, 1);
635 parms->mknew.out.file.fnum = SVAL(req->in.vwv, VWV(0));
638 case RAW_OPEN_CREATE:
639 SMBCLI_CHECK_WCT(req, 1);
640 parms->create.out.file.fnum = SVAL(req->in.vwv, VWV(0));
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);
649 case RAW_OPEN_SPLOPEN:
650 SMBCLI_CHECK_WCT(req, 1);
651 parms->splopen.out.file.fnum = SVAL(req->in.vwv, VWV(0));
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);
671 case RAW_OPEN_NTTRANS_CREATE:
672 return smb_raw_nttrans_create_recv(req, mem_ctx, parms);
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));
690 parms->openxreadx.out.access_mask = 0;
691 parms->openxreadx.out.unknown = 0;
694 status = smbcli_chained_advance(req);
695 if (!NT_STATUS_IS_OK(status)) {
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;
712 req->status = NT_STATUS_INTERNAL_ERROR;
717 return smbcli_request_destroy(req);
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)
726 struct smbcli_request *req = smb_raw_open_send(tree, parms);
727 return smb_raw_open_recv(req, mem_ctx, parms);
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)
736 struct smbcli_request *req = NULL;
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);
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 */
756 if (!req) return NULL;
758 if (!smbcli_request_send(req)) {
759 smbcli_request_destroy(req);
767 /****************************************************************************
768 Close a file - sync interface
769 ****************************************************************************/
770 _PUBLIC_ NTSTATUS smb_raw_close(struct smbcli_tree *tree, union smb_close *parms)
772 struct smbcli_request *req = smb_raw_close_send(tree, parms);
773 return smbcli_request_simple_recv(req);
777 /****************************************************************************
778 Locking calls - async interface
779 ****************************************************************************/
780 struct smbcli_request *smb_raw_lock_send(struct smbcli_tree *tree, union smb_lock *parms)
782 struct smbcli_request *req = NULL;
784 switch (parms->generic.level) {
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);
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);
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;
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);
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);
826 SIVAL(p, 2, lockp[i].offset);
827 SIVAL(p, 6, lockp[i].count);
836 if (!smbcli_request_send(req)) {
837 smbcli_request_destroy(req);
844 /****************************************************************************
845 Locking calls - sync interface
846 ****************************************************************************/
847 _PUBLIC_ NTSTATUS smb_raw_lock(struct smbcli_tree *tree, union smb_lock *parms)
849 struct smbcli_request *req = smb_raw_lock_send(tree, parms);
850 return smbcli_request_simple_recv(req);
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)
859 struct smbcli_request *req;
861 SETUP_REQUEST(SMBchkpth, 0, 0);
863 smbcli_req_append_ascii4(req, parms->chkpath.in.path, STR_TERMINATE);
865 if (!smbcli_request_send(req)) {
866 smbcli_request_destroy(req);
873 /****************************************************************************
874 Check for existence of a dir - sync interface
875 ****************************************************************************/
876 NTSTATUS smb_raw_chkpath(struct smbcli_tree *tree, union smb_chkpath *parms)
878 struct smbcli_request *req = smb_raw_chkpath_send(tree, parms);
879 return smbcli_request_simple_recv(req);
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)
888 struct smbcli_request *req;
891 switch (parms->generic.level) {
892 case RAW_FLUSH_FLUSH:
893 fnum = parms->flush.in.file.fnum;
902 SETUP_REQUEST(SMBflush, 1, 0);
903 SSVAL(req->out.vwv, VWV(0), fnum);
905 if (!smbcli_request_send(req)) {
906 smbcli_request_destroy(req);
914 /****************************************************************************
915 flush a file - sync interface
916 ****************************************************************************/
917 _PUBLIC_ NTSTATUS smb_raw_flush(struct smbcli_tree *tree, union smb_flush *parms)
919 struct smbcli_request *req = smb_raw_flush_send(tree, parms);
920 return smbcli_request_simple_recv(req);
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)
930 struct smbcli_request *req;
932 SETUP_REQUEST(SMBlseek, 4, 0);
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);
938 if (!smbcli_request_send(req)) {
939 smbcli_request_destroy(req);
945 /****************************************************************************
946 seek a file - async receive
947 ****************************************************************************/
948 NTSTATUS smb_raw_seek_recv(struct smbcli_request *req,
949 union smb_seek *parms)
951 if (!smbcli_request_receive(req) ||
952 smbcli_request_is_error(req)) {
953 return smbcli_request_destroy(req);
956 SMBCLI_CHECK_WCT(req, 2);
957 parms->lseek.out.offset = IVAL(req->in.vwv, VWV(0));
960 return smbcli_request_destroy(req);
964 seek a file - sync interface
966 _PUBLIC_ NTSTATUS smb_raw_seek(struct smbcli_tree *tree,
967 union smb_seek *parms)
969 struct smbcli_request *req = smb_raw_seek_send(tree, parms);
970 return smb_raw_seek_recv(req, parms);