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"
28 #define BLOB_CHECK(cmd) do { \
31 NT_STATUS_NOT_OK_RETURN(_status); \
34 #define BLOB_CHECK_MIN_SIZE(blob, size) do { \
35 if ((blob)->length < (size)) { \
36 return NT_STATUS_INFO_LENGTH_MISMATCH; \
41 /* align the end of the blob on an 8 byte boundary */
42 #define BLOB_ALIGN(blob, alignment) do { \
43 if ((blob)->length & ((alignment)-1)) { \
44 uint8_t _pad = (alignment) - ((blob)->length & ((alignment)-1)); \
45 BLOB_CHECK(smbsrv_blob_fill_data(blob, blob, (blob)->length+_pad)); \
49 /* grow the data size of a trans2 reply */
50 NTSTATUS smbsrv_blob_grow_data(TALLOC_CTX *mem_ctx,
54 if (new_size > blob->length) {
56 p = talloc_realloc(mem_ctx, blob->data, uint8_t, new_size);
57 NT_STATUS_HAVE_NO_MEMORY(p);
60 blob->length = new_size;
64 /* grow the data, zero filling any new bytes */
65 NTSTATUS smbsrv_blob_fill_data(TALLOC_CTX *mem_ctx,
69 uint32_t old_size = blob->length;
70 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, new_size));
71 if (new_size > old_size) {
72 memset(blob->data + old_size, 0, new_size - old_size);
78 pull a string from a blob in a trans2 request
80 size_t smbsrv_blob_pull_string(struct smbsrv_request *req,
81 const DATA_BLOB *blob,
87 /* we use STR_NO_RANGE_CHECK because the params are allocated
88 separately in a DATA_BLOB, so we need to do our own range
90 if (offset >= blob->length) {
94 return req_pull_string(req, str,
96 blob->length - offset,
97 STR_NO_RANGE_CHECK | flags);
101 push a string into the data section of a trans2 request
102 return the number of bytes consumed in the output
104 size_t smbsrv_blob_push_string(TALLOC_CTX *mem_ctx,
113 int alignment = 0, ret = 0, pkt_len;
115 /* we use STR_NO_RANGE_CHECK because the params are allocated
116 separately in a DATA_BLOB, so we need to do our own range
118 if (!str || offset >= blob->length) {
119 if (flags & STR_LEN8BIT) {
120 SCVAL(blob->data, len_offset, 0);
122 SIVAL(blob->data, len_offset, 0);
127 flags |= STR_NO_RANGE_CHECK;
129 if (dest_len == -1 || (dest_len > blob->length - offset)) {
130 dest_len = blob->length - offset;
133 if (!(flags & (STR_ASCII|STR_UNICODE))) {
134 flags |= default_flags;
137 if ((offset&1) && (flags & STR_UNICODE) && !(flags & STR_NOALIGN)) {
140 SCVAL(blob->data + offset, 0, 0);
141 ret = push_string(blob->data + offset + 1, str, dest_len-1, flags);
144 ret = push_string(blob->data + offset, str, dest_len, flags);
147 /* sometimes the string needs to be terminated, but the length
148 on the wire must not include the termination! */
151 if ((flags & STR_LEN_NOTERM) && (flags & STR_TERMINATE)) {
152 if ((flags & STR_UNICODE) && ret >= 2) {
155 if ((flags & STR_ASCII) && ret >= 1) {
160 if (flags & STR_LEN8BIT) {
161 SCVAL(blob->data, len_offset, pkt_len);
163 SIVAL(blob->data, len_offset, pkt_len);
166 return ret + alignment;
170 append a string to the data section of a trans2 reply
171 len_offset points to the place in the packet where the length field
174 NTSTATUS smbsrv_blob_append_string(TALLOC_CTX *mem_ctx,
183 const int max_bytes_per_char = 3;
185 offset = blob->length;
186 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, offset + (2+strlen_m(str))*max_bytes_per_char));
187 ret = smbsrv_blob_push_string(mem_ctx, blob, len_offset, offset, str, -1, default_flags, flags);
189 return NT_STATUS_FOOBAR;
191 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, offset + ret));
195 NTSTATUS smbsrv_push_passthru_fsinfo(TALLOC_CTX *mem_ctx,
197 enum smb_fsinfo_level level,
198 union smb_fsinfo *fsinfo,
199 int default_str_flags)
205 case RAW_QFS_VOLUME_INFORMATION:
206 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 18));
208 push_nttime(blob->data, 0, fsinfo->volume_info.out.create_time);
209 SIVAL(blob->data, 8, fsinfo->volume_info.out.serial_number);
210 SSVAL(blob->data, 16, 0); /* padding */
211 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
212 fsinfo->volume_info.out.volume_name.s,
213 12, default_str_flags,
218 case RAW_QFS_SIZE_INFORMATION:
219 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 24));
221 SBVAL(blob->data, 0, fsinfo->size_info.out.total_alloc_units);
222 SBVAL(blob->data, 8, fsinfo->size_info.out.avail_alloc_units);
223 SIVAL(blob->data, 16, fsinfo->size_info.out.sectors_per_unit);
224 SIVAL(blob->data, 20, fsinfo->size_info.out.bytes_per_sector);
228 case RAW_QFS_DEVICE_INFORMATION:
229 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 8));
231 SIVAL(blob->data, 0, fsinfo->device_info.out.device_type);
232 SIVAL(blob->data, 4, fsinfo->device_info.out.characteristics);
236 case RAW_QFS_ATTRIBUTE_INFORMATION:
237 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 12));
239 SIVAL(blob->data, 0, fsinfo->attribute_info.out.fs_attr);
240 SIVAL(blob->data, 4, fsinfo->attribute_info.out.max_file_component_length);
241 /* this must not be null terminated or win98 gets
242 confused! also note that w2k3 returns this as
243 unicode even when ascii is negotiated */
244 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
245 fsinfo->attribute_info.out.fs_type.s,
246 8, default_str_flags,
251 case RAW_QFS_QUOTA_INFORMATION:
252 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 48));
254 SBVAL(blob->data, 0, fsinfo->quota_information.out.unknown[0]);
255 SBVAL(blob->data, 8, fsinfo->quota_information.out.unknown[1]);
256 SBVAL(blob->data, 16, fsinfo->quota_information.out.unknown[2]);
257 SBVAL(blob->data, 24, fsinfo->quota_information.out.quota_soft);
258 SBVAL(blob->data, 32, fsinfo->quota_information.out.quota_hard);
259 SBVAL(blob->data, 40, fsinfo->quota_information.out.quota_flags);
264 case RAW_QFS_FULL_SIZE_INFORMATION:
265 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 32));
267 SBVAL(blob->data, 0, fsinfo->full_size_information.out.total_alloc_units);
268 SBVAL(blob->data, 8, fsinfo->full_size_information.out.call_avail_alloc_units);
269 SBVAL(blob->data, 16, fsinfo->full_size_information.out.actual_avail_alloc_units);
270 SIVAL(blob->data, 24, fsinfo->full_size_information.out.sectors_per_unit);
271 SIVAL(blob->data, 28, fsinfo->full_size_information.out.bytes_per_sector);
275 case RAW_QFS_OBJECTID_INFORMATION:
276 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 64));
278 BLOB_CHECK(ndr_push_struct_blob(&guid_blob, mem_ctx,
279 &fsinfo->objectid_information.out.guid,
280 (ndr_push_flags_fn_t)ndr_push_GUID));
281 memcpy(blob->data, guid_blob.data, guid_blob.length);
284 SBVAL(blob->data, 16 + 8*i, fsinfo->objectid_information.out.unknown[i]);
290 return NT_STATUS_INVALID_LEVEL;
293 return NT_STATUS_INVALID_LEVEL;
296 NTSTATUS smbsrv_push_passthru_fileinfo(TALLOC_CTX *mem_ctx,
298 enum smb_fileinfo_level level,
299 union smb_fileinfo *st,
300 int default_str_flags)
306 case RAW_FILEINFO_BASIC_INFORMATION:
307 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 40));
309 push_nttime(blob->data, 0, st->basic_info.out.create_time);
310 push_nttime(blob->data, 8, st->basic_info.out.access_time);
311 push_nttime(blob->data, 16, st->basic_info.out.write_time);
312 push_nttime(blob->data, 24, st->basic_info.out.change_time);
313 SIVAL(blob->data, 32, st->basic_info.out.attrib);
314 SIVAL(blob->data, 36, 0); /* padding */
317 case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
318 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 56));
320 push_nttime(blob->data, 0, st->network_open_information.out.create_time);
321 push_nttime(blob->data, 8, st->network_open_information.out.access_time);
322 push_nttime(blob->data, 16, st->network_open_information.out.write_time);
323 push_nttime(blob->data, 24, st->network_open_information.out.change_time);
324 SBVAL(blob->data, 32, st->network_open_information.out.alloc_size);
325 SBVAL(blob->data, 40, st->network_open_information.out.size);
326 SIVAL(blob->data, 48, st->network_open_information.out.attrib);
327 SIVAL(blob->data, 52, 0); /* padding */
330 case RAW_FILEINFO_STANDARD_INFORMATION:
331 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 24));
333 SBVAL(blob->data, 0, st->standard_info.out.alloc_size);
334 SBVAL(blob->data, 8, st->standard_info.out.size);
335 SIVAL(blob->data, 16, st->standard_info.out.nlink);
336 SCVAL(blob->data, 20, st->standard_info.out.delete_pending);
337 SCVAL(blob->data, 21, st->standard_info.out.directory);
338 SSVAL(blob->data, 22, 0); /* padding */
341 case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
342 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 8));
344 SIVAL(blob->data, 0, st->attribute_tag_information.out.attrib);
345 SIVAL(blob->data, 4, st->attribute_tag_information.out.reparse_tag);
348 case RAW_FILEINFO_EA_INFORMATION:
349 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 4));
351 SIVAL(blob->data, 0, st->ea_info.out.ea_size);
354 case RAW_FILEINFO_MODE_INFORMATION:
355 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 4));
357 SIVAL(blob->data, 0, st->mode_information.out.mode);
360 case RAW_FILEINFO_ALIGNMENT_INFORMATION:
361 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 4));
364 st->alignment_information.out.alignment_requirement);
367 case RAW_FILEINFO_ACCESS_INFORMATION:
368 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 4));
370 SIVAL(blob->data, 0, st->access_information.out.access_flags);
373 case RAW_FILEINFO_POSITION_INFORMATION:
374 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 8));
376 SBVAL(blob->data, 0, st->position_information.out.position);
379 case RAW_FILEINFO_COMPRESSION_INFORMATION:
380 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 16));
382 SBVAL(blob->data, 0, st->compression_info.out.compressed_size);
383 SSVAL(blob->data, 8, st->compression_info.out.format);
384 SCVAL(blob->data, 10, st->compression_info.out.unit_shift);
385 SCVAL(blob->data, 11, st->compression_info.out.chunk_shift);
386 SCVAL(blob->data, 12, st->compression_info.out.cluster_shift);
387 SSVAL(blob->data, 13, 0); /* 3 bytes padding */
388 SCVAL(blob->data, 15, 0);
391 case RAW_FILEINFO_INTERNAL_INFORMATION:
392 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 8));
394 SBVAL(blob->data, 0, st->internal_information.out.file_id);
397 case RAW_FILEINFO_ALL_INFORMATION:
398 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 72));
400 push_nttime(blob->data, 0, st->all_info.out.create_time);
401 push_nttime(blob->data, 8, st->all_info.out.access_time);
402 push_nttime(blob->data, 16, st->all_info.out.write_time);
403 push_nttime(blob->data, 24, st->all_info.out.change_time);
404 SIVAL(blob->data, 32, st->all_info.out.attrib);
405 SIVAL(blob->data, 36, 0); /* padding */
406 SBVAL(blob->data, 40, st->all_info.out.alloc_size);
407 SBVAL(blob->data, 48, st->all_info.out.size);
408 SIVAL(blob->data, 56, st->all_info.out.nlink);
409 SCVAL(blob->data, 60, st->all_info.out.delete_pending);
410 SCVAL(blob->data, 61, st->all_info.out.directory);
411 SSVAL(blob->data, 62, 0); /* padding */
412 SIVAL(blob->data, 64, st->all_info.out.ea_size);
413 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
414 st->all_info.out.fname.s,
415 68, default_str_flags,
419 case RAW_FILEINFO_NAME_INFORMATION:
420 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 4));
422 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
423 st->name_info.out.fname.s,
424 0, default_str_flags,
428 case RAW_FILEINFO_ALT_NAME_INFORMATION:
429 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 4));
431 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
432 st->alt_name_info.out.fname.s,
433 0, default_str_flags,
437 case RAW_FILEINFO_STREAM_INFORMATION:
438 for (i=0;i<st->stream_info.out.num_streams;i++) {
439 uint32_t data_size = blob->length;
442 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, data_size + 24));
443 data = blob->data + data_size;
444 SBVAL(data, 8, st->stream_info.out.streams[i].size);
445 SBVAL(data, 16, st->stream_info.out.streams[i].alloc_size);
446 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
447 st->stream_info.out.streams[i].stream_name.s,
448 data_size + 4, default_str_flags,
450 if (i == st->stream_info.out.num_streams - 1) {
451 SIVAL(blob->data, data_size, 0);
453 BLOB_CHECK(smbsrv_blob_fill_data(mem_ctx, blob, (blob->length+7)&~7));
454 SIVAL(blob->data, data_size,
455 blob->length - data_size);
460 case RAW_FILEINFO_SMB2_ALL_EAS:
461 /* if no eas are returned the backend should
462 * have returned NO_EAS_ON_FILE or NO_MORE_EAS
464 * so it's a programmer error if num_eas == 0
466 if (st->all_eas.out.num_eas == 0) {
467 smb_panic("0 eas for SMB2_ALL_EAS - programmer error in ntvfs backend");
470 list_size = ea_list_size_chained(st->all_eas.out.num_eas,
471 st->all_eas.out.eas);
472 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, list_size));
474 ea_put_list_chained(blob->data,
475 st->all_eas.out.num_eas,
476 st->all_eas.out.eas);
479 case RAW_FILEINFO_SMB2_ALL_INFORMATION:
480 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 0x64));
482 push_nttime(blob->data, 0x00, st->all_info2.out.create_time);
483 push_nttime(blob->data, 0x08, st->all_info2.out.access_time);
484 push_nttime(blob->data, 0x10, st->all_info2.out.write_time);
485 push_nttime(blob->data, 0x18, st->all_info2.out.change_time);
486 SIVAL(blob->data, 0x20, st->all_info2.out.attrib);
487 SIVAL(blob->data, 0x24, st->all_info2.out.unknown1);
488 SBVAL(blob->data, 0x28, st->all_info2.out.alloc_size);
489 SBVAL(blob->data, 0x30, st->all_info2.out.size);
490 SIVAL(blob->data, 0x38, st->all_info2.out.nlink);
491 SCVAL(blob->data, 0x3C, st->all_info2.out.delete_pending);
492 SCVAL(blob->data, 0x3D, st->all_info2.out.directory);
493 SSVAL(blob->data, 0x3E, 0); /* padding */
494 SBVAL(blob->data, 0x40, st->all_info2.out.file_id);
495 SIVAL(blob->data, 0x48, st->all_info2.out.ea_size);
496 SIVAL(blob->data, 0x4C, st->all_info2.out.access_mask);
497 SBVAL(blob->data, 0x50, st->all_info2.out.position);
498 SBVAL(blob->data, 0x58, st->all_info2.out.mode);
499 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
500 st->all_info2.out.fname.s,
501 0x60, default_str_flags,
506 return NT_STATUS_INVALID_LEVEL;
509 return NT_STATUS_INVALID_LEVEL;
512 NTSTATUS smbsrv_pull_passthru_sfileinfo(TALLOC_CTX *mem_ctx,
513 enum smb_setfileinfo_level level,
514 union smb_setfileinfo *st,
515 const DATA_BLOB *blob,
516 int default_str_flags,
517 struct smbsrv_request *req)
523 case SMB_SFILEINFO_BASIC_INFORMATION:
524 BLOB_CHECK_MIN_SIZE(blob, 36);
526 st->basic_info.in.create_time = pull_nttime(blob->data, 0);
527 st->basic_info.in.access_time = pull_nttime(blob->data, 8);
528 st->basic_info.in.write_time = pull_nttime(blob->data, 16);
529 st->basic_info.in.change_time = pull_nttime(blob->data, 24);
530 st->basic_info.in.attrib = IVAL(blob->data, 32);
534 case SMB_SFILEINFO_DISPOSITION_INFORMATION:
535 BLOB_CHECK_MIN_SIZE(blob, 1);
537 st->disposition_info.in.delete_on_close = CVAL(blob->data, 0);
541 case SMB_SFILEINFO_ALLOCATION_INFORMATION:
542 BLOB_CHECK_MIN_SIZE(blob, 8);
544 st->allocation_info.in.alloc_size = BVAL(blob->data, 0);
548 case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
549 BLOB_CHECK_MIN_SIZE(blob, 8);
551 st->end_of_file_info.in.size = BVAL(blob->data, 0);
555 case RAW_SFILEINFO_RENAME_INFORMATION:
558 * TODO: get rid of smbsrv_request argument of
559 * smbsrv_blob_pull_string()
561 return NT_STATUS_NOT_IMPLEMENTED;
563 BLOB_CHECK_MIN_SIZE(blob, 12);
565 st->rename_information.in.overwrite = CVAL(blob->data, 0);
566 st->rename_information.in.root_fid = IVAL(blob->data, 4);
567 len = IVAL(blob->data, 8);
568 str_blob.data = blob->data+12;
569 str_blob.length = MIN(blob->length, len);
570 smbsrv_blob_pull_string(req, &str_blob, 0,
571 &st->rename_information.in.new_name,
573 if (st->rename_information.in.new_name == NULL) {
574 return NT_STATUS_FOOBAR;
579 case RAW_SFILEINFO_POSITION_INFORMATION:
580 BLOB_CHECK_MIN_SIZE(blob, 8);
582 st->position_information.in.position = BVAL(blob->data, 0);
586 case RAW_SFILEINFO_MODE_INFORMATION:
587 BLOB_CHECK_MIN_SIZE(blob, 4);
589 st->mode_information.in.mode = IVAL(blob->data, 0);
594 return NT_STATUS_INVALID_LEVEL;
597 return NT_STATUS_INVALID_LEVEL;
601 fill a single entry in a trans2 find reply
603 NTSTATUS smbsrv_push_passthru_search(TALLOC_CTX *mem_ctx,
605 enum smb_search_data_level level,
606 const union smb_search_data *file,
607 int default_str_flags)
610 uint_t ofs = blob->length;
613 case RAW_SEARCH_DATA_DIRECTORY_INFO:
614 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 64));
615 data = blob->data + ofs;
616 SIVAL(data, 4, file->directory_info.file_index);
617 push_nttime(data, 8, file->directory_info.create_time);
618 push_nttime(data, 16, file->directory_info.access_time);
619 push_nttime(data, 24, file->directory_info.write_time);
620 push_nttime(data, 32, file->directory_info.change_time);
621 SBVAL(data, 40, file->directory_info.size);
622 SBVAL(data, 48, file->directory_info.alloc_size);
623 SIVAL(data, 56, file->directory_info.attrib);
624 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob, file->directory_info.name.s,
625 ofs + 60, default_str_flags,
626 STR_TERMINATE_ASCII));
628 data = blob->data + ofs;
629 SIVAL(data, 0, blob->length - ofs);
632 case RAW_SEARCH_DATA_FULL_DIRECTORY_INFO:
633 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 68));
634 data = blob->data + ofs;
635 SIVAL(data, 4, file->full_directory_info.file_index);
636 push_nttime(data, 8, file->full_directory_info.create_time);
637 push_nttime(data, 16, file->full_directory_info.access_time);
638 push_nttime(data, 24, file->full_directory_info.write_time);
639 push_nttime(data, 32, file->full_directory_info.change_time);
640 SBVAL(data, 40, file->full_directory_info.size);
641 SBVAL(data, 48, file->full_directory_info.alloc_size);
642 SIVAL(data, 56, file->full_directory_info.attrib);
643 SIVAL(data, 64, file->full_directory_info.ea_size);
644 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob, file->full_directory_info.name.s,
645 ofs + 60, default_str_flags,
646 STR_TERMINATE_ASCII));
648 data = blob->data + ofs;
649 SIVAL(data, 0, blob->length - ofs);
652 case RAW_SEARCH_DATA_NAME_INFO:
653 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 12));
654 data = blob->data + ofs;
655 SIVAL(data, 4, file->name_info.file_index);
656 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob, file->name_info.name.s,
657 ofs + 8, default_str_flags,
658 STR_TERMINATE_ASCII));
660 data = blob->data + ofs;
661 SIVAL(data, 0, blob->length - ofs);
664 case RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO:
665 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 94));
666 data = blob->data + ofs;
667 SIVAL(data, 4, file->both_directory_info.file_index);
668 push_nttime(data, 8, file->both_directory_info.create_time);
669 push_nttime(data, 16, file->both_directory_info.access_time);
670 push_nttime(data, 24, file->both_directory_info.write_time);
671 push_nttime(data, 32, file->both_directory_info.change_time);
672 SBVAL(data, 40, file->both_directory_info.size);
673 SBVAL(data, 48, file->both_directory_info.alloc_size);
674 SIVAL(data, 56, file->both_directory_info.attrib);
675 SIVAL(data, 64, file->both_directory_info.ea_size);
676 SCVAL(data, 69, 0); /* reserved */
677 memset(data+70,0,24);
678 smbsrv_blob_push_string(mem_ctx, blob,
680 file->both_directory_info.short_name.s,
681 24, default_str_flags,
682 STR_UNICODE | STR_LEN8BIT);
683 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob, file->both_directory_info.name.s,
684 ofs + 60, default_str_flags,
685 STR_TERMINATE_ASCII));
687 data = blob->data + ofs;
688 SIVAL(data, 0, blob->length - ofs);
691 case RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO:
692 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 80));
693 data = blob->data + ofs;
694 SIVAL(data, 4, file->id_full_directory_info.file_index);
695 push_nttime(data, 8, file->id_full_directory_info.create_time);
696 push_nttime(data, 16, file->id_full_directory_info.access_time);
697 push_nttime(data, 24, file->id_full_directory_info.write_time);
698 push_nttime(data, 32, file->id_full_directory_info.change_time);
699 SBVAL(data, 40, file->id_full_directory_info.size);
700 SBVAL(data, 48, file->id_full_directory_info.alloc_size);
701 SIVAL(data, 56, file->id_full_directory_info.attrib);
702 SIVAL(data, 64, file->id_full_directory_info.ea_size);
703 SIVAL(data, 68, 0); /* padding */
704 SBVAL(data, 72, file->id_full_directory_info.file_id);
705 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob, file->id_full_directory_info.name.s,
706 ofs + 60, default_str_flags,
707 STR_TERMINATE_ASCII));
709 data = blob->data + ofs;
710 SIVAL(data, 0, blob->length - ofs);
713 case RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO:
714 BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 104));
715 data = blob->data + ofs;
716 SIVAL(data, 4, file->id_both_directory_info.file_index);
717 push_nttime(data, 8, file->id_both_directory_info.create_time);
718 push_nttime(data, 16, file->id_both_directory_info.access_time);
719 push_nttime(data, 24, file->id_both_directory_info.write_time);
720 push_nttime(data, 32, file->id_both_directory_info.change_time);
721 SBVAL(data, 40, file->id_both_directory_info.size);
722 SBVAL(data, 48, file->id_both_directory_info.alloc_size);
723 SIVAL(data, 56, file->id_both_directory_info.attrib);
724 SIVAL(data, 64, file->id_both_directory_info.ea_size);
725 SCVAL(data, 69, 0); /* reserved */
726 memset(data+70,0,26);
727 smbsrv_blob_push_string(mem_ctx, blob,
729 file->id_both_directory_info.short_name.s,
730 24, default_str_flags,
731 STR_UNICODE | STR_LEN8BIT);
732 SBVAL(data, 96, file->id_both_directory_info.file_id);
733 BLOB_CHECK(smbsrv_blob_append_string(mem_ctx, blob, file->id_both_directory_info.name.s,
734 ofs + 60, default_str_flags,
735 STR_TERMINATE_ASCII));
737 data = blob->data + ofs;
738 SIVAL(data, 0, blob->length - ofs);
742 return NT_STATUS_INVALID_LEVEL;
745 return NT_STATUS_INVALID_LEVEL;