2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 2003
5 Copyright (C) Stefan Metzmacher 2006
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 #include "lib/util/dlinklist.h"
23 #include "smb_server/smb_server.h"
24 #include "librpc/gen_ndr/ndr_misc.h"
25 #include "ntvfs/ntvfs.h"
26 #include "libcli/raw/libcliraw.h"
27 #include "libcli/raw/raw_proto.h"
28 #include "param/param.h"
30 #define BLOB_CHECK(cmd) do { \
33 NT_STATUS_NOT_OK_RETURN(_status); \
36 #define BLOB_CHECK_MIN_SIZE(blob, size) do { \
37 if ((blob)->length < (size)) { \
38 return NT_STATUS_INVALID_PARAMETER; \
43 /* align the end of the blob on an 8 byte boundary */
44 #define BLOB_ALIGN(blob, alignment) do { \
45 if ((blob)->length & ((alignment)-1)) { \
46 uint8_t _pad = (alignment) - ((blob)->length & ((alignment)-1)); \
47 BLOB_CHECK(smbsrv_blob_fill_data(blob, blob, (blob)->length+_pad)); \
51 /* grow the data size of a trans2 reply */
52 NTSTATUS smbsrv_blob_grow_data(TALLOC_CTX *mem_ctx,
56 if (new_size > blob->length) {
58 p = talloc_realloc(mem_ctx, blob->data, uint8_t, new_size);
59 NT_STATUS_HAVE_NO_MEMORY(p);
62 blob->length = new_size;
66 /* grow the data, zero filling any new bytes */
67 NTSTATUS smbsrv_blob_fill_data(TALLOC_CTX *mem_ctx,
71 uint32_t old_size = blob->length;
72 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, new_size));
73 if (new_size > old_size) {
74 memset(blob->data + old_size, 0, new_size - old_size);
80 pull a string from a blob in a trans2 request
82 size_t smbsrv_blob_pull_string(struct request_bufinfo *bufinfo,
83 const DATA_BLOB *blob,
89 /* we use STR_NO_RANGE_CHECK because the params are allocated
90 separately in a DATA_BLOB, so we need to do our own range
92 if (offset >= blob->length) {
96 return req_pull_string(bufinfo, str,
98 blob->length - offset,
99 STR_NO_RANGE_CHECK | flags);
103 push a string into the data section of a trans2 request
104 return the number of bytes consumed in the output
106 size_t smbsrv_blob_push_string(TALLOC_CTX *mem_ctx,
115 int alignment = 0, ret = 0, pkt_len;
117 /* we use STR_NO_RANGE_CHECK because the params are allocated
118 separately in a DATA_BLOB, so we need to do our own range
120 if (!str || offset >= blob->length) {
121 if (flags & STR_LEN8BIT) {
122 SCVAL(blob->data, len_offset, 0);
124 SIVAL(blob->data, len_offset, 0);
129 flags |= STR_NO_RANGE_CHECK;
131 if (dest_len == -1 || (dest_len > blob->length - offset)) {
132 dest_len = blob->length - offset;
135 if (!(flags & (STR_ASCII|STR_UNICODE))) {
136 flags |= default_flags;
139 if ((offset&1) && (flags & STR_UNICODE) && !(flags & STR_NOALIGN)) {
142 SCVAL(blob->data + offset, 0, 0);
143 ret = push_string(lp_iconv_convenience(global_loadparm), blob->data + offset + 1, str, dest_len-1, flags);
146 ret = push_string(lp_iconv_convenience(global_loadparm), blob->data + offset, str, dest_len, flags);
149 /* sometimes the string needs to be terminated, but the length
150 on the wire must not include the termination! */
153 if ((flags & STR_LEN_NOTERM) && (flags & STR_TERMINATE)) {
154 if ((flags & STR_UNICODE) && ret >= 2) {
157 if ((flags & STR_ASCII) && ret >= 1) {
162 if (flags & STR_LEN8BIT) {
163 SCVAL(blob->data, len_offset, pkt_len);
165 SIVAL(blob->data, len_offset, pkt_len);
168 return ret + alignment;
172 append a string to the data section of a trans2 reply
173 len_offset points to the place in the packet where the length field
176 NTSTATUS smbsrv_blob_append_string(TALLOC_CTX *mem_ctx,
185 const int max_bytes_per_char = 3;
187 offset = blob->length;
188 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, offset + (2+strlen_m(str))*max_bytes_per_char));
189 ret = smbsrv_blob_push_string(mem_ctx, blob, len_offset, offset, str, -1, default_flags, flags);
191 return NT_STATUS_FOOBAR;
193 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, offset + ret));
197 NTSTATUS smbsrv_push_passthru_fsinfo(TALLOC_CTX *mem_ctx,
199 enum smb_fsinfo_level level,
200 union smb_fsinfo *fsinfo,
201 int default_str_flags)
207 case RAW_QFS_VOLUME_INFORMATION:
208 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 18));
210 push_nttime(blob->data, 0, fsinfo->volume_info.out.create_time);
211 SIVAL(blob->data, 8, fsinfo->volume_info.out.serial_number);
212 SSVAL(blob->data, 16, 0); /* padding */
213 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
214 fsinfo->volume_info.out.volume_name.s,
215 12, default_str_flags,
220 case RAW_QFS_SIZE_INFORMATION:
221 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 24));
223 SBVAL(blob->data, 0, fsinfo->size_info.out.total_alloc_units);
224 SBVAL(blob->data, 8, fsinfo->size_info.out.avail_alloc_units);
225 SIVAL(blob->data, 16, fsinfo->size_info.out.sectors_per_unit);
226 SIVAL(blob->data, 20, fsinfo->size_info.out.bytes_per_sector);
230 case RAW_QFS_DEVICE_INFORMATION:
231 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 8));
233 SIVAL(blob->data, 0, fsinfo->device_info.out.device_type);
234 SIVAL(blob->data, 4, fsinfo->device_info.out.characteristics);
238 case RAW_QFS_ATTRIBUTE_INFORMATION:
239 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 12));
241 SIVAL(blob->data, 0, fsinfo->attribute_info.out.fs_attr);
242 SIVAL(blob->data, 4, fsinfo->attribute_info.out.max_file_component_length);
243 /* this must not be null terminated or win98 gets
244 confused! also note that w2k3 returns this as
245 unicode even when ascii is negotiated */
246 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
247 fsinfo->attribute_info.out.fs_type.s,
248 8, default_str_flags,
253 case RAW_QFS_QUOTA_INFORMATION:
254 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 48));
256 SBVAL(blob->data, 0, fsinfo->quota_information.out.unknown[0]);
257 SBVAL(blob->data, 8, fsinfo->quota_information.out.unknown[1]);
258 SBVAL(blob->data, 16, fsinfo->quota_information.out.unknown[2]);
259 SBVAL(blob->data, 24, fsinfo->quota_information.out.quota_soft);
260 SBVAL(blob->data, 32, fsinfo->quota_information.out.quota_hard);
261 SBVAL(blob->data, 40, fsinfo->quota_information.out.quota_flags);
266 case RAW_QFS_FULL_SIZE_INFORMATION:
267 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 32));
269 SBVAL(blob->data, 0, fsinfo->full_size_information.out.total_alloc_units);
270 SBVAL(blob->data, 8, fsinfo->full_size_information.out.call_avail_alloc_units);
271 SBVAL(blob->data, 16, fsinfo->full_size_information.out.actual_avail_alloc_units);
272 SIVAL(blob->data, 24, fsinfo->full_size_information.out.sectors_per_unit);
273 SIVAL(blob->data, 28, fsinfo->full_size_information.out.bytes_per_sector);
277 case RAW_QFS_OBJECTID_INFORMATION: {
278 enum ndr_err_code ndr_err;
280 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 64));
282 ndr_err = ndr_push_struct_blob(&guid_blob, mem_ctx, NULL,
283 &fsinfo->objectid_information.out.guid,
284 (ndr_push_flags_fn_t)ndr_push_GUID);
285 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
286 BLOB_CHECK(ndr_map_error2ntstatus(ndr_err));
289 memcpy(blob->data, guid_blob.data, guid_blob.length);
292 SBVAL(blob->data, 16 + 8*i, fsinfo->objectid_information.out.unknown[i]);
298 return NT_STATUS_INVALID_LEVEL;
301 return NT_STATUS_INVALID_LEVEL;
304 NTSTATUS smbsrv_push_passthru_fileinfo(TALLOC_CTX *mem_ctx,
306 enum smb_fileinfo_level level,
307 union smb_fileinfo *st,
308 int default_str_flags)
314 case RAW_FILEINFO_BASIC_INFORMATION:
315 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 40));
317 push_nttime(blob->data, 0, st->basic_info.out.create_time);
318 push_nttime(blob->data, 8, st->basic_info.out.access_time);
319 push_nttime(blob->data, 16, st->basic_info.out.write_time);
320 push_nttime(blob->data, 24, st->basic_info.out.change_time);
321 SIVAL(blob->data, 32, st->basic_info.out.attrib);
322 SIVAL(blob->data, 36, 0); /* padding */
325 case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
326 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 56));
328 push_nttime(blob->data, 0, st->network_open_information.out.create_time);
329 push_nttime(blob->data, 8, st->network_open_information.out.access_time);
330 push_nttime(blob->data, 16, st->network_open_information.out.write_time);
331 push_nttime(blob->data, 24, st->network_open_information.out.change_time);
332 SBVAL(blob->data, 32, st->network_open_information.out.alloc_size);
333 SBVAL(blob->data, 40, st->network_open_information.out.size);
334 SIVAL(blob->data, 48, st->network_open_information.out.attrib);
335 SIVAL(blob->data, 52, 0); /* padding */
338 case RAW_FILEINFO_STANDARD_INFORMATION:
339 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 24));
341 SBVAL(blob->data, 0, st->standard_info.out.alloc_size);
342 SBVAL(blob->data, 8, st->standard_info.out.size);
343 SIVAL(blob->data, 16, st->standard_info.out.nlink);
344 SCVAL(blob->data, 20, st->standard_info.out.delete_pending);
345 SCVAL(blob->data, 21, st->standard_info.out.directory);
346 SSVAL(blob->data, 22, 0); /* padding */
349 case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
350 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 8));
352 SIVAL(blob->data, 0, st->attribute_tag_information.out.attrib);
353 SIVAL(blob->data, 4, st->attribute_tag_information.out.reparse_tag);
356 case RAW_FILEINFO_EA_INFORMATION:
357 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 4));
359 SIVAL(blob->data, 0, st->ea_info.out.ea_size);
362 case RAW_FILEINFO_MODE_INFORMATION:
363 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 4));
365 SIVAL(blob->data, 0, st->mode_information.out.mode);
368 case RAW_FILEINFO_ALIGNMENT_INFORMATION:
369 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 4));
372 st->alignment_information.out.alignment_requirement);
375 case RAW_FILEINFO_ACCESS_INFORMATION:
376 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 4));
378 SIVAL(blob->data, 0, st->access_information.out.access_flags);
381 case RAW_FILEINFO_POSITION_INFORMATION:
382 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 8));
384 SBVAL(blob->data, 0, st->position_information.out.position);
387 case RAW_FILEINFO_COMPRESSION_INFORMATION:
388 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 16));
390 SBVAL(blob->data, 0, st->compression_info.out.compressed_size);
391 SSVAL(blob->data, 8, st->compression_info.out.format);
392 SCVAL(blob->data, 10, st->compression_info.out.unit_shift);
393 SCVAL(blob->data, 11, st->compression_info.out.chunk_shift);
394 SCVAL(blob->data, 12, st->compression_info.out.cluster_shift);
395 SSVAL(blob->data, 13, 0); /* 3 bytes padding */
396 SCVAL(blob->data, 15, 0);
399 case RAW_FILEINFO_INTERNAL_INFORMATION:
400 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 8));
402 SBVAL(blob->data, 0, st->internal_information.out.file_id);
405 case RAW_FILEINFO_ALL_INFORMATION:
406 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 72));
408 push_nttime(blob->data, 0, st->all_info.out.create_time);
409 push_nttime(blob->data, 8, st->all_info.out.access_time);
410 push_nttime(blob->data, 16, st->all_info.out.write_time);
411 push_nttime(blob->data, 24, st->all_info.out.change_time);
412 SIVAL(blob->data, 32, st->all_info.out.attrib);
413 SIVAL(blob->data, 36, 0); /* padding */
414 SBVAL(blob->data, 40, st->all_info.out.alloc_size);
415 SBVAL(blob->data, 48, st->all_info.out.size);
416 SIVAL(blob->data, 56, st->all_info.out.nlink);
417 SCVAL(blob->data, 60, st->all_info.out.delete_pending);
418 SCVAL(blob->data, 61, st->all_info.out.directory);
419 SSVAL(blob->data, 62, 0); /* padding */
420 SIVAL(blob->data, 64, st->all_info.out.ea_size);
421 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
422 st->all_info.out.fname.s,
423 68, default_str_flags,
427 case RAW_FILEINFO_NAME_INFORMATION:
428 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 4));
430 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
431 st->name_info.out.fname.s,
432 0, default_str_flags,
436 case RAW_FILEINFO_ALT_NAME_INFORMATION:
437 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 4));
439 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
440 st->alt_name_info.out.fname.s,
441 0, default_str_flags,
445 case RAW_FILEINFO_STREAM_INFORMATION:
446 for (i=0;i<st->stream_info.out.num_streams;i++) {
447 uint32_t data_size = blob->length;
450 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, data_size + 24));
451 data = blob->data + data_size;
452 SBVAL(data, 8, st->stream_info.out.streams[i].size);
453 SBVAL(data, 16, st->stream_info.out.streams[i].alloc_size);
454 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
455 st->stream_info.out.streams[i].stream_name.s,
456 data_size + 4, default_str_flags,
458 if (i == st->stream_info.out.num_streams - 1) {
459 SIVAL(blob->data, data_size, 0);
461 BLOB_CHECK(smbsrv_blob_fill_data(mem_ctx, blob, (blob->length+7)&~7));
462 SIVAL(blob->data, data_size,
463 blob->length - data_size);
468 case RAW_FILEINFO_SMB2_ALL_EAS:
469 /* if no eas are returned the backend should
470 * have returned NO_EAS_ON_FILE or NO_MORE_EAS
472 * so it's a programmer error if num_eas == 0
474 if (st->all_eas.out.num_eas == 0) {
475 smb_panic("0 eas for SMB2_ALL_EAS - programmer error in ntvfs backend");
478 list_size = ea_list_size_chained(st->all_eas.out.num_eas,
479 st->all_eas.out.eas, 4);
480 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, list_size));
482 ea_put_list_chained(blob->data,
483 st->all_eas.out.num_eas,
484 st->all_eas.out.eas, 4);
487 case RAW_FILEINFO_SMB2_ALL_INFORMATION:
488 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 0x64));
490 push_nttime(blob->data, 0x00, st->all_info2.out.create_time);
491 push_nttime(blob->data, 0x08, st->all_info2.out.access_time);
492 push_nttime(blob->data, 0x10, st->all_info2.out.write_time);
493 push_nttime(blob->data, 0x18, st->all_info2.out.change_time);
494 SIVAL(blob->data, 0x20, st->all_info2.out.attrib);
495 SIVAL(blob->data, 0x24, st->all_info2.out.unknown1);
496 SBVAL(blob->data, 0x28, st->all_info2.out.alloc_size);
497 SBVAL(blob->data, 0x30, st->all_info2.out.size);
498 SIVAL(blob->data, 0x38, st->all_info2.out.nlink);
499 SCVAL(blob->data, 0x3C, st->all_info2.out.delete_pending);
500 SCVAL(blob->data, 0x3D, st->all_info2.out.directory);
501 SSVAL(blob->data, 0x3E, 0); /* padding */
502 SBVAL(blob->data, 0x40, st->all_info2.out.file_id);
503 SIVAL(blob->data, 0x48, st->all_info2.out.ea_size);
504 SIVAL(blob->data, 0x4C, st->all_info2.out.access_mask);
505 SBVAL(blob->data, 0x50, st->all_info2.out.position);
506 SIVAL(blob->data, 0x58, st->all_info2.out.mode);
507 SIVAL(blob->data, 0x5C, st->all_info2.out.alignment_requirement);
508 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
509 st->all_info2.out.fname.s,
510 0x60, default_str_flags,
515 return NT_STATUS_INVALID_LEVEL;
518 return NT_STATUS_INVALID_LEVEL;
521 NTSTATUS smbsrv_pull_passthru_sfileinfo(TALLOC_CTX *mem_ctx,
522 enum smb_setfileinfo_level level,
523 union smb_setfileinfo *st,
524 const DATA_BLOB *blob,
525 int default_str_flags,
526 struct request_bufinfo *bufinfo)
532 case SMB_SFILEINFO_BASIC_INFORMATION:
533 BLOB_CHECK_MIN_SIZE(blob, 40);
535 st->basic_info.in.create_time = pull_nttime(blob->data, 0);
536 st->basic_info.in.access_time = pull_nttime(blob->data, 8);
537 st->basic_info.in.write_time = pull_nttime(blob->data, 16);
538 st->basic_info.in.change_time = pull_nttime(blob->data, 24);
539 st->basic_info.in.attrib = IVAL(blob->data, 32);
540 st->basic_info.in.reserved = IVAL(blob->data, 36);
544 case SMB_SFILEINFO_DISPOSITION_INFORMATION:
545 BLOB_CHECK_MIN_SIZE(blob, 1);
547 st->disposition_info.in.delete_on_close = CVAL(blob->data, 0);
551 case SMB_SFILEINFO_ALLOCATION_INFORMATION:
552 BLOB_CHECK_MIN_SIZE(blob, 8);
554 st->allocation_info.in.alloc_size = BVAL(blob->data, 0);
558 case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
559 BLOB_CHECK_MIN_SIZE(blob, 8);
561 st->end_of_file_info.in.size = BVAL(blob->data, 0);
565 case RAW_SFILEINFO_RENAME_INFORMATION:
567 return NT_STATUS_INTERNAL_ERROR;
569 BLOB_CHECK_MIN_SIZE(blob, 12);
570 st->rename_information.in.overwrite = CVAL(blob->data, 0);
571 st->rename_information.in.root_fid = IVAL(blob->data, 4);
572 len = IVAL(blob->data, 8);
575 str_blob.length = MIN(str_blob.length, ofs+len);
576 smbsrv_blob_pull_string(bufinfo, &str_blob, ofs,
577 &st->rename_information.in.new_name,
579 if (st->rename_information.in.new_name == NULL) {
580 return NT_STATUS_FOOBAR;
586 case RAW_SFILEINFO_LINK_INFORMATION:
588 return NT_STATUS_INTERNAL_ERROR;
590 BLOB_CHECK_MIN_SIZE(blob, 20);
591 st->link_information.in.overwrite = CVAL(blob->data, 0);
592 st->link_information.in.root_fid = IVAL(blob->data, 8);
593 len = IVAL(blob->data, 16);
596 str_blob.length = MIN(str_blob.length, ofs+len);
597 smbsrv_blob_pull_string(bufinfo, &str_blob, ofs,
598 &st->link_information.in.new_name,
600 if (st->link_information.in.new_name == NULL) {
601 return NT_STATUS_FOOBAR;
606 case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
607 /* SMB2 uses a different format for rename information */
609 return NT_STATUS_INTERNAL_ERROR;
611 BLOB_CHECK_MIN_SIZE(blob, 20);
612 st->rename_information.in.overwrite = CVAL(blob->data, 0);
613 st->rename_information.in.root_fid = BVAL(blob->data, 8);
614 len = IVAL(blob->data,16);
617 str_blob.length = MIN(str_blob.length, ofs+len);
618 smbsrv_blob_pull_string(bufinfo, &str_blob, ofs,
619 &st->rename_information.in.new_name,
621 if (st->rename_information.in.new_name == NULL) {
622 return NT_STATUS_FOOBAR;
627 case RAW_SFILEINFO_POSITION_INFORMATION:
628 BLOB_CHECK_MIN_SIZE(blob, 8);
630 st->position_information.in.position = BVAL(blob->data, 0);
634 case RAW_SFILEINFO_MODE_INFORMATION:
635 BLOB_CHECK_MIN_SIZE(blob, 4);
637 st->mode_information.in.mode = IVAL(blob->data, 0);
642 return NT_STATUS_INVALID_LEVEL;
645 return NT_STATUS_INVALID_LEVEL;
649 fill a single entry in a trans2 find reply
651 NTSTATUS smbsrv_push_passthru_search(TALLOC_CTX *mem_ctx,
653 enum smb_search_data_level level,
654 const union smb_search_data *file,
655 int default_str_flags)
658 uint_t ofs = blob->length;
661 case RAW_SEARCH_DATA_DIRECTORY_INFO:
662 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 64));
663 data = blob->data + ofs;
664 SIVAL(data, 4, file->directory_info.file_index);
665 push_nttime(data, 8, file->directory_info.create_time);
666 push_nttime(data, 16, file->directory_info.access_time);
667 push_nttime(data, 24, file->directory_info.write_time);
668 push_nttime(data, 32, file->directory_info.change_time);
669 SBVAL(data, 40, file->directory_info.size);
670 SBVAL(data, 48, file->directory_info.alloc_size);
671 SIVAL(data, 56, file->directory_info.attrib);
672 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob, file->directory_info.name.s,
673 ofs + 60, default_str_flags,
674 STR_TERMINATE_ASCII));
676 data = blob->data + ofs;
677 SIVAL(data, 0, blob->length - ofs);
680 case RAW_SEARCH_DATA_FULL_DIRECTORY_INFO:
681 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 68));
682 data = blob->data + ofs;
683 SIVAL(data, 4, file->full_directory_info.file_index);
684 push_nttime(data, 8, file->full_directory_info.create_time);
685 push_nttime(data, 16, file->full_directory_info.access_time);
686 push_nttime(data, 24, file->full_directory_info.write_time);
687 push_nttime(data, 32, file->full_directory_info.change_time);
688 SBVAL(data, 40, file->full_directory_info.size);
689 SBVAL(data, 48, file->full_directory_info.alloc_size);
690 SIVAL(data, 56, file->full_directory_info.attrib);
691 SIVAL(data, 64, file->full_directory_info.ea_size);
692 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob, file->full_directory_info.name.s,
693 ofs + 60, default_str_flags,
694 STR_TERMINATE_ASCII));
696 data = blob->data + ofs;
697 SIVAL(data, 0, blob->length - ofs);
700 case RAW_SEARCH_DATA_NAME_INFO:
701 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 12));
702 data = blob->data + ofs;
703 SIVAL(data, 4, file->name_info.file_index);
704 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob, file->name_info.name.s,
705 ofs + 8, default_str_flags,
706 STR_TERMINATE_ASCII));
708 data = blob->data + ofs;
709 SIVAL(data, 0, blob->length - ofs);
712 case RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO:
713 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 94));
714 data = blob->data + ofs;
715 SIVAL(data, 4, file->both_directory_info.file_index);
716 push_nttime(data, 8, file->both_directory_info.create_time);
717 push_nttime(data, 16, file->both_directory_info.access_time);
718 push_nttime(data, 24, file->both_directory_info.write_time);
719 push_nttime(data, 32, file->both_directory_info.change_time);
720 SBVAL(data, 40, file->both_directory_info.size);
721 SBVAL(data, 48, file->both_directory_info.alloc_size);
722 SIVAL(data, 56, file->both_directory_info.attrib);
723 SIVAL(data, 64, file->both_directory_info.ea_size);
724 SCVAL(data, 69, 0); /* reserved */
725 memset(data+70,0,24);
726 smbsrv_blob_push_string(mem_ctx, blob,
728 file->both_directory_info.short_name.s,
729 24, default_str_flags,
730 STR_UNICODE | STR_LEN8BIT);
731 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob, file->both_directory_info.name.s,
732 ofs + 60, default_str_flags,
733 STR_TERMINATE_ASCII));
735 data = blob->data + ofs;
736 SIVAL(data, 0, blob->length - ofs);
739 case RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO:
740 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 80));
741 data = blob->data + ofs;
742 SIVAL(data, 4, file->id_full_directory_info.file_index);
743 push_nttime(data, 8, file->id_full_directory_info.create_time);
744 push_nttime(data, 16, file->id_full_directory_info.access_time);
745 push_nttime(data, 24, file->id_full_directory_info.write_time);
746 push_nttime(data, 32, file->id_full_directory_info.change_time);
747 SBVAL(data, 40, file->id_full_directory_info.size);
748 SBVAL(data, 48, file->id_full_directory_info.alloc_size);
749 SIVAL(data, 56, file->id_full_directory_info.attrib);
750 SIVAL(data, 64, file->id_full_directory_info.ea_size);
751 SIVAL(data, 68, 0); /* padding */
752 SBVAL(data, 72, file->id_full_directory_info.file_id);
753 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob, file->id_full_directory_info.name.s,
754 ofs + 60, default_str_flags,
755 STR_TERMINATE_ASCII));
757 data = blob->data + ofs;
758 SIVAL(data, 0, blob->length - ofs);
761 case RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO:
762 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 104));
763 data = blob->data + ofs;
764 SIVAL(data, 4, file->id_both_directory_info.file_index);
765 push_nttime(data, 8, file->id_both_directory_info.create_time);
766 push_nttime(data, 16, file->id_both_directory_info.access_time);
767 push_nttime(data, 24, file->id_both_directory_info.write_time);
768 push_nttime(data, 32, file->id_both_directory_info.change_time);
769 SBVAL(data, 40, file->id_both_directory_info.size);
770 SBVAL(data, 48, file->id_both_directory_info.alloc_size);
771 SIVAL(data, 56, file->id_both_directory_info.attrib);
772 SIVAL(data, 64, file->id_both_directory_info.ea_size);
773 SCVAL(data, 69, 0); /* reserved */
774 memset(data+70,0,26);
775 smbsrv_blob_push_string(mem_ctx, blob,
777 file->id_both_directory_info.short_name.s,
778 24, default_str_flags,
779 STR_UNICODE | STR_LEN8BIT);
780 SBVAL(data, 96, file->id_both_directory_info.file_id);
781 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob, file->id_both_directory_info.name.s,
782 ofs + 60, default_str_flags,
783 STR_TERMINATE_ASCII));
785 data = blob->data + ofs;
786 SIVAL(data, 0, blob->length - ofs);
790 return NT_STATUS_INVALID_LEVEL;
793 return NT_STATUS_INVALID_LEVEL;