2 Unix SMB/CIFS implementation.
3 client trans2 operations
4 Copyright (C) James Myers 2003
5 Copyright (C) Andrew Tridgell 2003
6 Copyright (C) James Peach 2007
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/>.
23 #include "libcli/raw/libcliraw.h"
24 #include "librpc/gen_ndr/ndr_security.h"
26 /* local macros to make the code more readable */
27 #define FINFO_CHECK_MIN_SIZE(size) if (blob->length < (size)) { \
28 DEBUG(1,("Unexpected FILEINFO reply size %d for level %u - expected min of %d\n", \
29 (int)blob->length, parms->generic.level, (size))); \
30 return NT_STATUS_INFO_LENGTH_MISMATCH; \
32 #define FINFO_CHECK_SIZE(size) if (blob->length != (size)) { \
33 DEBUG(1,("Unexpected FILEINFO reply size %d for level %u - expected %d\n", \
34 (int)blob->length, parms->generic.level, (size))); \
35 return NT_STATUS_INFO_LENGTH_MISMATCH; \
39 parse a stream information structure
41 NTSTATUS smbcli_parse_stream_info(DATA_BLOB blob, TALLOC_CTX *mem_ctx,
42 struct stream_information *io)
48 while (blob.length - ofs >= 24) {
49 uint_t n = io->num_streams;
54 talloc_realloc(mem_ctx, io->streams, struct stream_struct, n+1);
56 return NT_STATUS_NO_MEMORY;
58 nlen = IVAL(blob.data, ofs + 0x04);
59 io->streams[n].size = BVAL(blob.data, ofs + 0x08);
60 io->streams[n].alloc_size = BVAL(blob.data, ofs + 0x10);
61 if (nlen > blob.length - (ofs + 24)) {
62 return NT_STATUS_INFO_LENGTH_MISMATCH;
64 size = convert_string_talloc(io->streams, CH_UTF16, CH_UNIX,
65 blob.data+ofs+24, nlen, &vstr);
67 return NT_STATUS_ILLEGAL_CHARACTER;
69 io->streams[n].stream_name.s = (const char *)vstr;
70 io->streams[n].stream_name.private_length = nlen;
72 len = IVAL(blob.data, ofs);
73 if (len > blob.length - ofs) {
74 return NT_STATUS_INFO_LENGTH_MISMATCH;
84 parse the fsinfo 'passthru' level replies
86 NTSTATUS smb_raw_fileinfo_passthru_parse(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx,
87 enum smb_fileinfo_level level,
88 union smb_fileinfo *parms)
91 case RAW_FILEINFO_BASIC_INFORMATION:
92 /* some servers return 40 bytes and some 36. w2k3 return 40, so thats
93 what we should do, but we need to accept 36 */
94 if (blob->length != 36) {
97 parms->basic_info.out.create_time = smbcli_pull_nttime(blob->data, 0);
98 parms->basic_info.out.access_time = smbcli_pull_nttime(blob->data, 8);
99 parms->basic_info.out.write_time = smbcli_pull_nttime(blob->data, 16);
100 parms->basic_info.out.change_time = smbcli_pull_nttime(blob->data, 24);
101 parms->basic_info.out.attrib = IVAL(blob->data, 32);
104 case RAW_FILEINFO_STANDARD_INFORMATION:
105 FINFO_CHECK_SIZE(24);
106 parms->standard_info.out.alloc_size = BVAL(blob->data, 0);
107 parms->standard_info.out.size = BVAL(blob->data, 8);
108 parms->standard_info.out.nlink = IVAL(blob->data, 16);
109 parms->standard_info.out.delete_pending = CVAL(blob->data, 20);
110 parms->standard_info.out.directory = CVAL(blob->data, 21);
113 case RAW_FILEINFO_EA_INFORMATION:
115 parms->ea_info.out.ea_size = IVAL(blob->data, 0);
118 case RAW_FILEINFO_NAME_INFORMATION:
119 FINFO_CHECK_MIN_SIZE(4);
120 smbcli_blob_pull_string(NULL, mem_ctx, blob,
121 &parms->name_info.out.fname, 0, 4, STR_UNICODE);
124 case RAW_FILEINFO_ALL_INFORMATION:
125 FINFO_CHECK_MIN_SIZE(72);
126 parms->all_info.out.create_time = smbcli_pull_nttime(blob->data, 0);
127 parms->all_info.out.access_time = smbcli_pull_nttime(blob->data, 8);
128 parms->all_info.out.write_time = smbcli_pull_nttime(blob->data, 16);
129 parms->all_info.out.change_time = smbcli_pull_nttime(blob->data, 24);
130 parms->all_info.out.attrib = IVAL(blob->data, 32);
131 parms->all_info.out.alloc_size = BVAL(blob->data, 40);
132 parms->all_info.out.size = BVAL(blob->data, 48);
133 parms->all_info.out.nlink = IVAL(blob->data, 56);
134 parms->all_info.out.delete_pending = CVAL(blob->data, 60);
135 parms->all_info.out.directory = CVAL(blob->data, 61);
137 parms->all_info.out.ea_size = IVAL(blob->data, 64);
138 smbcli_blob_pull_string(NULL, mem_ctx, blob,
139 &parms->all_info.out.fname, 68, 72, STR_UNICODE);
141 /* this is what the CIFS spec says - and its totally
142 wrong, but its useful having it here so we can
143 quickly adapt to broken servers when running
145 parms->all_info.out.ea_size = IVAL(blob->data, 72);
146 /* access flags 4 bytes at 76
147 current_position 8 bytes at 80
149 alignment 4 bytes at 92
151 smbcli_blob_pull_string(NULL, mem_ctx, blob,
152 &parms->all_info.out.fname, 96, 100, STR_UNICODE);
156 case RAW_FILEINFO_ALT_NAME_INFORMATION:
157 FINFO_CHECK_MIN_SIZE(4);
158 smbcli_blob_pull_string(NULL, mem_ctx, blob,
159 &parms->alt_name_info.out.fname, 0, 4, STR_UNICODE);
162 case RAW_FILEINFO_STREAM_INFORMATION:
163 return smbcli_parse_stream_info(*blob, mem_ctx, &parms->stream_info.out);
165 case RAW_FILEINFO_INTERNAL_INFORMATION:
167 parms->internal_information.out.file_id = BVAL(blob->data, 0);
170 case RAW_FILEINFO_ACCESS_INFORMATION:
172 parms->access_information.out.access_flags = IVAL(blob->data, 0);
175 case RAW_FILEINFO_POSITION_INFORMATION:
177 parms->position_information.out.position = BVAL(blob->data, 0);
180 case RAW_FILEINFO_MODE_INFORMATION:
182 parms->mode_information.out.mode = IVAL(blob->data, 0);
185 case RAW_FILEINFO_ALIGNMENT_INFORMATION:
187 parms->alignment_information.out.alignment_requirement
188 = IVAL(blob->data, 0);
191 case RAW_FILEINFO_COMPRESSION_INFORMATION:
192 FINFO_CHECK_SIZE(16);
193 parms->compression_info.out.compressed_size = BVAL(blob->data, 0);
194 parms->compression_info.out.format = SVAL(blob->data, 8);
195 parms->compression_info.out.unit_shift = CVAL(blob->data, 10);
196 parms->compression_info.out.chunk_shift = CVAL(blob->data, 11);
197 parms->compression_info.out.cluster_shift = CVAL(blob->data, 12);
198 /* 3 bytes of padding */
201 case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
202 FINFO_CHECK_SIZE(56);
203 parms->network_open_information.out.create_time = smbcli_pull_nttime(blob->data, 0);
204 parms->network_open_information.out.access_time = smbcli_pull_nttime(blob->data, 8);
205 parms->network_open_information.out.write_time = smbcli_pull_nttime(blob->data, 16);
206 parms->network_open_information.out.change_time = smbcli_pull_nttime(blob->data, 24);
207 parms->network_open_information.out.alloc_size = BVAL(blob->data, 32);
208 parms->network_open_information.out.size = BVAL(blob->data, 40);
209 parms->network_open_information.out.attrib = IVAL(blob->data, 48);
212 case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
214 parms->attribute_tag_information.out.attrib = IVAL(blob->data, 0);
215 parms->attribute_tag_information.out.reparse_tag = IVAL(blob->data, 4);
218 case RAW_FILEINFO_SMB2_ALL_EAS:
219 FINFO_CHECK_MIN_SIZE(4);
220 return ea_pull_list_chained(blob, mem_ctx,
221 &parms->all_eas.out.num_eas,
222 &parms->all_eas.out.eas);
224 case RAW_FILEINFO_SMB2_ALL_INFORMATION:
225 FINFO_CHECK_MIN_SIZE(0x64);
226 parms->all_info2.out.create_time = smbcli_pull_nttime(blob->data, 0x00);
227 parms->all_info2.out.access_time = smbcli_pull_nttime(blob->data, 0x08);
228 parms->all_info2.out.write_time = smbcli_pull_nttime(blob->data, 0x10);
229 parms->all_info2.out.change_time = smbcli_pull_nttime(blob->data, 0x18);
230 parms->all_info2.out.attrib = IVAL(blob->data, 0x20);
231 parms->all_info2.out.unknown1 = IVAL(blob->data, 0x24);
232 parms->all_info2.out.alloc_size = BVAL(blob->data, 0x28);
233 parms->all_info2.out.size = BVAL(blob->data, 0x30);
234 parms->all_info2.out.nlink = IVAL(blob->data, 0x38);
235 parms->all_info2.out.delete_pending = CVAL(blob->data, 0x3C);
236 parms->all_info2.out.directory = CVAL(blob->data, 0x3D);
237 /* 0x3E-0x3F padding */
238 parms->all_info2.out.file_id = BVAL(blob->data, 0x40);
239 parms->all_info2.out.ea_size = IVAL(blob->data, 0x48);
240 parms->all_info2.out.access_mask = IVAL(blob->data, 0x4C);
241 parms->all_info2.out.position = BVAL(blob->data, 0x50);
242 parms->all_info2.out.mode = BVAL(blob->data, 0x58);
243 smbcli_blob_pull_string(NULL, mem_ctx, blob,
244 &parms->all_info2.out.fname, 0x60, 0x64, STR_UNICODE);
247 case RAW_FILEINFO_SEC_DESC: {
250 parms->query_secdesc.out.sd = talloc(mem_ctx, struct security_descriptor);
251 NT_STATUS_HAVE_NO_MEMORY(parms->query_secdesc.out.sd);
253 status = ndr_pull_struct_blob(blob, mem_ctx,
254 parms->query_secdesc.out.sd,
255 (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
256 NT_STATUS_NOT_OK_RETURN(status);
265 return NT_STATUS_INVALID_LEVEL;
269 /****************************************************************************
270 Handle qfileinfo/qpathinfo trans2 backend.
271 ****************************************************************************/
272 static NTSTATUS smb_raw_info_backend(struct smbcli_session *session,
274 union smb_fileinfo *parms,
277 switch (parms->generic.level) {
278 case RAW_FILEINFO_GENERIC:
279 case RAW_FILEINFO_GETATTR:
280 case RAW_FILEINFO_GETATTRE:
281 case RAW_FILEINFO_SEC_DESC:
282 /* not handled here */
283 return NT_STATUS_INVALID_LEVEL;
285 case RAW_FILEINFO_STANDARD:
286 FINFO_CHECK_SIZE(22);
287 parms->standard.out.create_time = raw_pull_dos_date2(session->transport,
289 parms->standard.out.access_time = raw_pull_dos_date2(session->transport,
291 parms->standard.out.write_time = raw_pull_dos_date2(session->transport,
293 parms->standard.out.size = IVAL(blob->data, 12);
294 parms->standard.out.alloc_size = IVAL(blob->data, 16);
295 parms->standard.out.attrib = SVAL(blob->data, 20);
298 case RAW_FILEINFO_EA_SIZE:
299 FINFO_CHECK_SIZE(26);
300 parms->ea_size.out.create_time = raw_pull_dos_date2(session->transport,
302 parms->ea_size.out.access_time = raw_pull_dos_date2(session->transport,
304 parms->ea_size.out.write_time = raw_pull_dos_date2(session->transport,
306 parms->ea_size.out.size = IVAL(blob->data, 12);
307 parms->ea_size.out.alloc_size = IVAL(blob->data, 16);
308 parms->ea_size.out.attrib = SVAL(blob->data, 20);
309 parms->ea_size.out.ea_size = IVAL(blob->data, 22);
312 case RAW_FILEINFO_EA_LIST:
313 FINFO_CHECK_MIN_SIZE(4);
314 return ea_pull_list(blob, mem_ctx,
315 &parms->ea_list.out.num_eas,
316 &parms->ea_list.out.eas);
318 case RAW_FILEINFO_ALL_EAS:
319 FINFO_CHECK_MIN_SIZE(4);
320 return ea_pull_list(blob, mem_ctx,
321 &parms->all_eas.out.num_eas,
322 &parms->all_eas.out.eas);
324 case RAW_FILEINFO_IS_NAME_VALID:
329 case RAW_FILEINFO_BASIC_INFO:
330 case RAW_FILEINFO_BASIC_INFORMATION:
331 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
332 RAW_FILEINFO_BASIC_INFORMATION, parms);
334 case RAW_FILEINFO_STANDARD_INFO:
335 case RAW_FILEINFO_STANDARD_INFORMATION:
336 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
337 RAW_FILEINFO_STANDARD_INFORMATION, parms);
339 case RAW_FILEINFO_EA_INFO:
340 case RAW_FILEINFO_EA_INFORMATION:
341 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
342 RAW_FILEINFO_EA_INFORMATION, parms);
344 case RAW_FILEINFO_NAME_INFO:
345 case RAW_FILEINFO_NAME_INFORMATION:
346 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
347 RAW_FILEINFO_NAME_INFORMATION, parms);
349 case RAW_FILEINFO_ALL_INFO:
350 case RAW_FILEINFO_ALL_INFORMATION:
351 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
352 RAW_FILEINFO_ALL_INFORMATION, parms);
354 case RAW_FILEINFO_ALT_NAME_INFO:
355 case RAW_FILEINFO_ALT_NAME_INFORMATION:
356 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
357 RAW_FILEINFO_ALT_NAME_INFORMATION, parms);
359 case RAW_FILEINFO_STREAM_INFO:
360 case RAW_FILEINFO_STREAM_INFORMATION:
361 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
362 RAW_FILEINFO_STREAM_INFORMATION, parms);
364 case RAW_FILEINFO_INTERNAL_INFORMATION:
365 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
366 RAW_FILEINFO_INTERNAL_INFORMATION, parms);
368 case RAW_FILEINFO_ACCESS_INFORMATION:
369 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
370 RAW_FILEINFO_ACCESS_INFORMATION, parms);
372 case RAW_FILEINFO_POSITION_INFORMATION:
373 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
374 RAW_FILEINFO_POSITION_INFORMATION, parms);
376 case RAW_FILEINFO_MODE_INFORMATION:
377 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
378 RAW_FILEINFO_MODE_INFORMATION, parms);
380 case RAW_FILEINFO_ALIGNMENT_INFORMATION:
381 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
382 RAW_FILEINFO_ALIGNMENT_INFORMATION, parms);
384 case RAW_FILEINFO_COMPRESSION_INFO:
385 case RAW_FILEINFO_COMPRESSION_INFORMATION:
386 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
387 RAW_FILEINFO_COMPRESSION_INFORMATION, parms);
389 case RAW_FILEINFO_UNIX_BASIC:
390 FINFO_CHECK_SIZE(100);
391 parms->unix_basic_info.out.end_of_file = BVAL(blob->data, 0);
392 parms->unix_basic_info.out.num_bytes = BVAL(blob->data, 8);
393 parms->unix_basic_info.out.status_change_time = smbcli_pull_nttime(blob->data, 16);
394 parms->unix_basic_info.out.access_time = smbcli_pull_nttime(blob->data, 24);
395 parms->unix_basic_info.out.change_time = smbcli_pull_nttime(blob->data, 32);
396 parms->unix_basic_info.out.uid = BVAL(blob->data, 40);
397 parms->unix_basic_info.out.gid = BVAL(blob->data, 48);
398 parms->unix_basic_info.out.file_type = IVAL(blob->data, 52);
399 parms->unix_basic_info.out.dev_major = BVAL(blob->data, 60);
400 parms->unix_basic_info.out.dev_minor = BVAL(blob->data, 68);
401 parms->unix_basic_info.out.unique_id = BVAL(blob->data, 76);
402 parms->unix_basic_info.out.permissions = BVAL(blob->data, 84);
403 parms->unix_basic_info.out.nlink = BVAL(blob->data, 92);
406 case RAW_FILEINFO_UNIX_INFO2:
407 FINFO_CHECK_SIZE(116);
408 parms->unix_info2.out.end_of_file = BVAL(blob->data, 0);
409 parms->unix_info2.out.num_bytes = BVAL(blob->data, 8);
410 parms->unix_info2.out.status_change_time = smbcli_pull_nttime(blob->data, 16);
411 parms->unix_info2.out.access_time = smbcli_pull_nttime(blob->data, 24);
412 parms->unix_info2.out.change_time = smbcli_pull_nttime(blob->data, 32);
413 parms->unix_info2.out.uid = BVAL(blob->data, 40);
414 parms->unix_info2.out.gid = BVAL(blob->data, 48);
415 parms->unix_info2.out.file_type = IVAL(blob->data, 52);
416 parms->unix_info2.out.dev_major = BVAL(blob->data, 60);
417 parms->unix_info2.out.dev_minor = BVAL(blob->data, 68);
418 parms->unix_info2.out.unique_id = BVAL(blob->data, 76);
419 parms->unix_info2.out.permissions = BVAL(blob->data, 84);
420 parms->unix_info2.out.nlink = BVAL(blob->data, 92);
421 parms->unix_info2.out.create_time = smbcli_pull_nttime(blob->data, 100);
422 parms->unix_info2.out.file_flags = IVAL(blob->data, 108);
423 parms->unix_info2.out.flags_mask = IVAL(blob->data, 112);
426 case RAW_FILEINFO_UNIX_LINK:
427 smbcli_blob_pull_string(session, mem_ctx, blob,
428 &parms->unix_link_info.out.link_dest, 0, 4, STR_UNICODE);
431 case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
432 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
433 RAW_FILEINFO_NETWORK_OPEN_INFORMATION, parms);
435 case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
436 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
437 RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION, parms);
439 case RAW_FILEINFO_SMB2_ALL_INFORMATION:
440 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
441 RAW_FILEINFO_SMB2_ALL_INFORMATION, parms);
443 case RAW_FILEINFO_SMB2_ALL_EAS:
444 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
445 RAW_FILEINFO_SMB2_ALL_EAS, parms);
449 return NT_STATUS_INVALID_LEVEL;
453 /****************************************************************************
454 Very raw query file info - returns param/data blobs - (async send)
455 ****************************************************************************/
456 static struct smbcli_request *smb_raw_fileinfo_blob_send(struct smbcli_tree *tree,
461 struct smb_trans2 tp;
462 uint16_t setup = TRANSACT2_QFILEINFO;
463 struct smbcli_request *req;
464 TALLOC_CTX *mem_ctx = talloc_init("raw_fileinfo");
469 tp.in.setup_count = 1;
472 tp.in.max_data = 0xFFFF;
473 tp.in.setup = &setup;
475 tp.in.params = data_blob_talloc(mem_ctx, NULL, 4);
476 if (!tp.in.params.data) {
477 talloc_free(mem_ctx);
481 SSVAL(tp.in.params.data, 0, fnum);
482 SSVAL(tp.in.params.data, 2, info_level);
484 req = smb_raw_trans2_send(tree, &tp);
486 talloc_free(mem_ctx);
492 /****************************************************************************
493 Very raw query file info - returns param/data blobs - (async recv)
494 ****************************************************************************/
495 static NTSTATUS smb_raw_fileinfo_blob_recv(struct smbcli_request *req,
499 struct smb_trans2 tp;
500 NTSTATUS status = smb_raw_trans2_recv(req, mem_ctx, &tp);
501 if (NT_STATUS_IS_OK(status)) {
507 /****************************************************************************
508 Very raw query path info - returns param/data blobs (async send)
509 ****************************************************************************/
510 static struct smbcli_request *smb_raw_pathinfo_blob_send(struct smbcli_tree *tree,
515 struct smb_trans2 tp;
516 uint16_t setup = TRANSACT2_QPATHINFO;
517 struct smbcli_request *req;
518 TALLOC_CTX *mem_ctx = talloc_init("raw_pathinfo");
523 tp.in.setup_count = 1;
526 tp.in.max_data = 0xFFFF;
527 tp.in.setup = &setup;
529 tp.in.params = data_blob_talloc(mem_ctx, NULL, 6);
530 if (!tp.in.params.data) {
531 talloc_free(mem_ctx);
535 SSVAL(tp.in.params.data, 0, info_level);
536 SIVAL(tp.in.params.data, 2, 0);
537 smbcli_blob_append_string(tree->session, mem_ctx, &tp.in.params,
538 fname, STR_TERMINATE);
540 req = smb_raw_trans2_send(tree, &tp);
542 talloc_free(mem_ctx);
547 /****************************************************************************
548 send a SMBgetatr (async send)
549 ****************************************************************************/
550 static struct smbcli_request *smb_raw_getattr_send(struct smbcli_tree *tree,
551 union smb_fileinfo *parms)
553 struct smbcli_request *req;
555 req = smbcli_request_setup(tree, SMBgetatr, 0, 0);
556 if (!req) return NULL;
558 smbcli_req_append_ascii4(req, parms->getattr.in.file.path, STR_TERMINATE);
560 if (!smbcli_request_send(req)) {
561 smbcli_request_destroy(req);
568 /****************************************************************************
569 send a SMBgetatr (async recv)
570 ****************************************************************************/
571 static NTSTATUS smb_raw_getattr_recv(struct smbcli_request *req,
572 union smb_fileinfo *parms)
574 if (!smbcli_request_receive(req) ||
575 smbcli_request_is_error(req)) {
576 return smbcli_request_destroy(req);
579 SMBCLI_CHECK_WCT(req, 10);
580 parms->getattr.out.attrib = SVAL(req->in.vwv, VWV(0));
581 parms->getattr.out.write_time = raw_pull_dos_date3(req->transport,
582 req->in.vwv + VWV(1));
583 parms->getattr.out.size = IVAL(req->in.vwv, VWV(3));
586 return smbcli_request_destroy(req);
590 /****************************************************************************
591 Handle SMBgetattrE (async send)
592 ****************************************************************************/
593 static struct smbcli_request *smb_raw_getattrE_send(struct smbcli_tree *tree,
594 union smb_fileinfo *parms)
596 struct smbcli_request *req;
598 req = smbcli_request_setup(tree, SMBgetattrE, 1, 0);
599 if (!req) return NULL;
601 SSVAL(req->out.vwv, VWV(0), parms->getattre.in.file.fnum);
602 if (!smbcli_request_send(req)) {
603 smbcli_request_destroy(req);
610 /****************************************************************************
611 Handle SMBgetattrE (async send)
612 ****************************************************************************/
613 static NTSTATUS smb_raw_getattrE_recv(struct smbcli_request *req,
614 union smb_fileinfo *parms)
616 if (!smbcli_request_receive(req) ||
617 smbcli_request_is_error(req)) {
618 return smbcli_request_destroy(req);
621 SMBCLI_CHECK_WCT(req, 11);
622 parms->getattre.out.create_time = raw_pull_dos_date2(req->transport,
623 req->in.vwv + VWV(0));
624 parms->getattre.out.access_time = raw_pull_dos_date2(req->transport,
625 req->in.vwv + VWV(2));
626 parms->getattre.out.write_time = raw_pull_dos_date2(req->transport,
627 req->in.vwv + VWV(4));
628 parms->getattre.out.size = IVAL(req->in.vwv, VWV(6));
629 parms->getattre.out.alloc_size = IVAL(req->in.vwv, VWV(8));
630 parms->getattre.out.attrib = SVAL(req->in.vwv, VWV(10));
633 return smbcli_request_destroy(req);
637 /****************************************************************************
638 Query file info (async send)
639 ****************************************************************************/
640 struct smbcli_request *smb_raw_fileinfo_send(struct smbcli_tree *tree,
641 union smb_fileinfo *parms)
644 struct smbcli_request *req;
646 /* pass off the non-trans2 level to specialised functions */
647 if (parms->generic.level == RAW_FILEINFO_GETATTRE) {
648 return smb_raw_getattrE_send(tree, parms);
650 if (parms->generic.level == RAW_FILEINFO_SEC_DESC) {
651 return smb_raw_query_secdesc_send(tree, parms);
653 if (parms->generic.level >= RAW_FILEINFO_GENERIC) {
657 data = data_blob(NULL, 0);
659 if (parms->generic.level == RAW_FILEINFO_EA_LIST) {
660 if (!ea_push_name_list(tree,
662 parms->ea_list.in.num_names,
663 parms->ea_list.in.ea_names)) {
668 req = smb_raw_fileinfo_blob_send(tree,
669 parms->generic.in.file.fnum,
670 parms->generic.level, data);
672 data_blob_free(&data);
677 /****************************************************************************
678 Query file info (async recv)
679 ****************************************************************************/
680 NTSTATUS smb_raw_fileinfo_recv(struct smbcli_request *req,
682 union smb_fileinfo *parms)
686 struct smbcli_session *session = req?req->session:NULL;
688 if (parms->generic.level == RAW_FILEINFO_GETATTRE) {
689 return smb_raw_getattrE_recv(req, parms);
691 if (parms->generic.level == RAW_FILEINFO_SEC_DESC) {
692 return smb_raw_query_secdesc_recv(req, mem_ctx, parms);
694 if (parms->generic.level == RAW_FILEINFO_GETATTR) {
695 return smb_raw_getattr_recv(req, parms);
698 status = smb_raw_fileinfo_blob_recv(req, mem_ctx, &blob);
699 if (!NT_STATUS_IS_OK(status)) {
703 return smb_raw_info_backend(session, mem_ctx, parms, &blob);
706 /****************************************************************************
707 Query file info (sync interface)
708 ****************************************************************************/
709 NTSTATUS smb_raw_fileinfo(struct smbcli_tree *tree,
711 union smb_fileinfo *parms)
713 struct smbcli_request *req = smb_raw_fileinfo_send(tree, parms);
714 return smb_raw_fileinfo_recv(req, mem_ctx, parms);
717 /****************************************************************************
718 Query path info (async send)
719 ****************************************************************************/
720 struct smbcli_request *smb_raw_pathinfo_send(struct smbcli_tree *tree,
721 union smb_fileinfo *parms)
724 struct smbcli_request *req;
726 if (parms->generic.level == RAW_FILEINFO_GETATTR) {
727 return smb_raw_getattr_send(tree, parms);
729 if (parms->generic.level >= RAW_FILEINFO_GENERIC) {
733 data = data_blob(NULL, 0);
735 if (parms->generic.level == RAW_FILEINFO_EA_LIST) {
736 if (!ea_push_name_list(tree,
738 parms->ea_list.in.num_names,
739 parms->ea_list.in.ea_names)) {
744 req = smb_raw_pathinfo_blob_send(tree, parms->generic.in.file.path,
745 parms->generic.level, data);
746 data_blob_free(&data);
751 /****************************************************************************
752 Query path info (async recv)
753 ****************************************************************************/
754 NTSTATUS smb_raw_pathinfo_recv(struct smbcli_request *req,
756 union smb_fileinfo *parms)
758 /* recv is idential to fileinfo */
759 return smb_raw_fileinfo_recv(req, mem_ctx, parms);
762 /****************************************************************************
763 Query path info (sync interface)
764 ****************************************************************************/
765 NTSTATUS smb_raw_pathinfo(struct smbcli_tree *tree,
767 union smb_fileinfo *parms)
769 struct smbcli_request *req = smb_raw_pathinfo_send(tree, parms);
770 return smb_raw_pathinfo_recv(req, mem_ctx, parms);