2 Unix SMB/CIFS implementation.
3 client trans2 operations
4 Copyright (C) James Myers 2003
5 Copyright (C) Andrew Tridgell 2003
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 2 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, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 /* local macros to make the code more readable */
25 #define FINFO_CHECK_MIN_SIZE(size) if (blob->length < (size)) { \
26 DEBUG(1,("Unexpected FILEINFO reply size %d for level %u - expected min of %d\n", \
27 blob->length, parms->generic.level, (size))); \
28 return NT_STATUS_INFO_LENGTH_MISMATCH; \
30 #define FINFO_CHECK_SIZE(size) if (blob->length != (size)) { \
31 DEBUG(1,("Unexpected FILEINFO reply size %d for level %u - expected %d\n", \
32 blob->length, parms->generic.level, (size))); \
33 return NT_STATUS_INFO_LENGTH_MISMATCH; \
36 /****************************************************************************
37 Handle qfileinfo/qpathinfo trans2 backend.
38 ****************************************************************************/
39 static NTSTATUS smb_raw_info_backend(struct cli_session *session,
41 union smb_fileinfo *parms,
46 switch (parms->generic.level) {
47 case RAW_FILEINFO_GENERIC:
48 case RAW_FILEINFO_GETATTR:
49 case RAW_FILEINFO_GETATTRE:
50 /* not handled here */
51 return NT_STATUS_INVALID_LEVEL;
53 case RAW_FILEINFO_STANDARD:
55 parms->standard.out.create_time = make_unix_date2(blob->data + 0);
56 parms->standard.out.access_time = make_unix_date2(blob->data + 4);
57 parms->standard.out.write_time = make_unix_date2(blob->data + 8);
58 parms->standard.out.size = IVAL(blob->data, 12);
59 parms->standard.out.alloc_size = IVAL(blob->data, 16);
60 parms->standard.out.attrib = SVAL(blob->data, 20);
63 case RAW_FILEINFO_EA_SIZE:
65 parms->ea_size.out.create_time = make_unix_date2(blob->data + 0);
66 parms->ea_size.out.access_time = make_unix_date2(blob->data + 4);
67 parms->ea_size.out.write_time = make_unix_date2(blob->data + 8);
68 parms->ea_size.out.size = IVAL(blob->data, 12);
69 parms->ea_size.out.alloc_size = IVAL(blob->data, 16);
70 parms->ea_size.out.attrib = SVAL(blob->data, 20);
71 parms->ea_size.out.ea_size = IVAL(blob->data, 22);
74 case RAW_FILEINFO_ALL_EAS:
75 FINFO_CHECK_MIN_SIZE(4);
76 return ea_pull_list(blob, mem_ctx,
77 &parms->all_eas.out.num_eas,
78 &parms->all_eas.out.eas);
80 case RAW_FILEINFO_IS_NAME_VALID:
85 case RAW_FILEINFO_BASIC_INFO:
86 case RAW_FILEINFO_BASIC_INFORMATION:
87 /* some servers return 40 bytes and some 36. w2k3 return 40, so thats
88 what we should do, but we need to accept 36 */
89 if (blob->length != 36) {
92 parms->basic_info.out.create_time = cli_pull_nttime(blob->data, 0);
93 parms->basic_info.out.access_time = cli_pull_nttime(blob->data, 8);
94 parms->basic_info.out.write_time = cli_pull_nttime(blob->data, 16);
95 parms->basic_info.out.change_time = cli_pull_nttime(blob->data, 24);
96 parms->basic_info.out.attrib = IVAL(blob->data, 32);
99 case RAW_FILEINFO_STANDARD_INFO:
100 case RAW_FILEINFO_STANDARD_INFORMATION:
101 FINFO_CHECK_SIZE(24);
102 parms->standard_info.out.alloc_size = BVAL(blob->data, 0);
103 parms->standard_info.out.size = BVAL(blob->data, 8);
104 parms->standard_info.out.nlink = IVAL(blob->data, 16);
105 parms->standard_info.out.delete_pending = CVAL(blob->data, 20);
106 parms->standard_info.out.directory = CVAL(blob->data, 21);
109 case RAW_FILEINFO_EA_INFO:
110 case RAW_FILEINFO_EA_INFORMATION:
112 parms->ea_info.out.ea_size = IVAL(blob->data, 0);
115 case RAW_FILEINFO_NAME_INFO:
116 case RAW_FILEINFO_NAME_INFORMATION:
117 FINFO_CHECK_MIN_SIZE(4);
118 cli_blob_pull_string(session, mem_ctx, blob,
119 &parms->name_info.out.fname, 0, 4, STR_UNICODE);
122 case RAW_FILEINFO_ALL_INFO:
123 case RAW_FILEINFO_ALL_INFORMATION:
124 FINFO_CHECK_MIN_SIZE(72);
125 parms->all_info.out.create_time = cli_pull_nttime(blob->data, 0);
126 parms->all_info.out.access_time = cli_pull_nttime(blob->data, 8);
127 parms->all_info.out.write_time = cli_pull_nttime(blob->data, 16);
128 parms->all_info.out.change_time = cli_pull_nttime(blob->data, 24);
129 parms->all_info.out.attrib = IVAL(blob->data, 32);
130 parms->all_info.out.alloc_size = BVAL(blob->data, 40);
131 parms->all_info.out.size = BVAL(blob->data, 48);
132 parms->all_info.out.nlink = IVAL(blob->data, 56);
133 parms->all_info.out.delete_pending = CVAL(blob->data, 60);
134 parms->all_info.out.directory = CVAL(blob->data, 61);
135 parms->all_info.out.ea_size = IVAL(blob->data, 64);
136 cli_blob_pull_string(session, mem_ctx, blob,
137 &parms->all_info.out.fname, 68, 72, STR_UNICODE);
140 case RAW_FILEINFO_ALT_NAME_INFO:
141 case RAW_FILEINFO_ALT_NAME_INFORMATION:
142 FINFO_CHECK_MIN_SIZE(4);
143 cli_blob_pull_string(session, mem_ctx, blob,
144 &parms->alt_name_info.out.fname, 0, 4, STR_UNICODE);
147 case RAW_FILEINFO_STREAM_INFO:
148 case RAW_FILEINFO_STREAM_INFORMATION:
149 FINFO_CHECK_MIN_SIZE(0);
151 parms->stream_info.out.num_streams = 0;
152 parms->stream_info.out.streams = NULL;
154 while (blob->length - ofs >= 24) {
155 uint_t n = parms->stream_info.out.num_streams;
156 parms->stream_info.out.streams =
157 talloc_realloc(mem_ctx,parms->stream_info.out.streams,
158 (n+1) * sizeof(parms->stream_info.out.streams[0]));
159 if (!parms->stream_info.out.streams) {
160 return NT_STATUS_NO_MEMORY;
162 parms->stream_info.out.streams[n].size = BVAL(blob->data, ofs + 8);
163 parms->stream_info.out.streams[n].alloc_size = BVAL(blob->data, ofs + 16);
164 cli_blob_pull_string(session, mem_ctx, blob,
165 &parms->stream_info.out.streams[n].stream_name,
166 ofs+4, ofs+24, STR_UNICODE);
167 parms->stream_info.out.num_streams++;
168 len = IVAL(blob->data, ofs);
169 if (len > blob->length - ofs) return NT_STATUS_INFO_LENGTH_MISMATCH;
175 case RAW_FILEINFO_INTERNAL_INFORMATION:
177 parms->internal_information.out.device = IVAL(blob->data, 0);
178 parms->internal_information.out.inode = IVAL(blob->data, 4);
181 case RAW_FILEINFO_ACCESS_INFORMATION:
183 parms->access_information.out.access_flags = IVAL(blob->data, 0);
186 case RAW_FILEINFO_POSITION_INFORMATION:
188 parms->position_information.out.position = BVAL(blob->data, 0);
191 case RAW_FILEINFO_MODE_INFORMATION:
193 parms->mode_information.out.mode = IVAL(blob->data, 0);
196 case RAW_FILEINFO_ALIGNMENT_INFORMATION:
198 parms->alignment_information.out.alignment_requirement
199 = IVAL(blob->data, 0);
202 case RAW_FILEINFO_COMPRESSION_INFO:
203 case RAW_FILEINFO_COMPRESSION_INFORMATION:
204 FINFO_CHECK_SIZE(16);
205 parms->compression_info.out.compressed_size = BVAL(blob->data, 0);
206 parms->compression_info.out.format = SVAL(blob->data, 8);
207 parms->compression_info.out.unit_shift = CVAL(blob->data, 10);
208 parms->compression_info.out.chunk_shift = CVAL(blob->data, 11);
209 parms->compression_info.out.cluster_shift = CVAL(blob->data, 12);
210 /* 3 bytes of padding */
213 case RAW_FILEINFO_UNIX_BASIC:
214 FINFO_CHECK_SIZE(100);
215 parms->unix_basic_info.out.end_of_file = BVAL(blob->data, 0);
216 parms->unix_basic_info.out.num_bytes = BVAL(blob->data, 8);
217 parms->unix_basic_info.out.status_change_time = cli_pull_nttime(blob->data, 16);
218 parms->unix_basic_info.out.access_time = cli_pull_nttime(blob->data, 24);
219 parms->unix_basic_info.out.change_time = cli_pull_nttime(blob->data, 32);
220 parms->unix_basic_info.out.uid = BVAL(blob->data, 40);
221 parms->unix_basic_info.out.gid = BVAL(blob->data, 48);
222 parms->unix_basic_info.out.file_type = IVAL(blob->data, 52);
223 parms->unix_basic_info.out.dev_major = BVAL(blob->data, 60);
224 parms->unix_basic_info.out.dev_minor = BVAL(blob->data, 68);
225 parms->unix_basic_info.out.unique_id = BVAL(blob->data, 76);
226 parms->unix_basic_info.out.permissions = BVAL(blob->data, 84);
227 parms->unix_basic_info.out.nlink = BVAL(blob->data, 92);
230 case RAW_FILEINFO_UNIX_LINK:
231 FINFO_CHECK_MIN_SIZE(0);
232 cli_blob_pull_string(session, mem_ctx, blob,
233 &parms->unix_link_info.out.link_dest, 0, 4, STR_UNICODE);
236 case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
237 FINFO_CHECK_SIZE(56);
238 parms->network_open_information.out.create_time = cli_pull_nttime(blob->data, 0);
239 parms->network_open_information.out.access_time = cli_pull_nttime(blob->data, 8);
240 parms->network_open_information.out.write_time = cli_pull_nttime(blob->data, 16);
241 parms->network_open_information.out.change_time = cli_pull_nttime(blob->data, 24);
242 parms->network_open_information.out.alloc_size = BVAL(blob->data, 32);
243 parms->network_open_information.out.size = BVAL(blob->data, 40);
244 parms->network_open_information.out.attrib = IVAL(blob->data, 48);
247 case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
249 parms->attribute_tag_information.out.attrib = IVAL(blob->data, 0);
250 parms->attribute_tag_information.out.reparse_tag = IVAL(blob->data, 4);
254 return NT_STATUS_INVALID_LEVEL;
257 /****************************************************************************
258 Very raw query file info - returns param/data blobs - (async send)
259 ****************************************************************************/
260 static struct cli_request *smb_raw_fileinfo_blob_send(struct cli_tree *tree,
261 uint16 fnum, uint16 info_level)
263 struct smb_trans2 tp;
264 uint16 setup = TRANSACT2_QFILEINFO;
265 struct cli_request *req;
266 TALLOC_CTX *mem_ctx = talloc_init("raw_fileinfo");
271 tp.in.setup_count = 1;
272 tp.in.data = data_blob(NULL, 0);
274 tp.in.max_data = 0xFFFF;
275 tp.in.setup = &setup;
277 tp.in.params = data_blob_talloc(mem_ctx, NULL, 4);
278 if (!tp.in.params.data) {
279 talloc_destroy(mem_ctx);
283 SIVAL(tp.in.params.data, 0, fnum);
284 SSVAL(tp.in.params.data, 2, info_level);
286 req = smb_raw_trans2_send(tree, &tp);
288 talloc_destroy(mem_ctx);
294 /****************************************************************************
295 Very raw query file info - returns param/data blobs - (async recv)
296 ****************************************************************************/
297 static NTSTATUS smb_raw_fileinfo_blob_recv(struct cli_request *req,
301 struct smb_trans2 tp;
302 NTSTATUS status = smb_raw_trans2_recv(req, mem_ctx, &tp);
303 if (NT_STATUS_IS_OK(status)) {
309 /****************************************************************************
310 Very raw query path info - returns param/data blobs (async send)
311 ****************************************************************************/
312 static struct cli_request *smb_raw_pathinfo_blob_send(struct cli_tree *tree,
316 struct smb_trans2 tp;
317 uint16 setup = TRANSACT2_QPATHINFO;
318 struct cli_request *req;
319 TALLOC_CTX *mem_ctx = talloc_init("raw_pathinfo");
324 tp.in.setup_count = 1;
325 tp.in.data = data_blob(NULL, 0);
327 tp.in.max_data = 0xFFFF;
328 tp.in.setup = &setup;
330 tp.in.params = data_blob_talloc(mem_ctx, NULL, 6);
331 if (!tp.in.params.data) {
332 talloc_destroy(mem_ctx);
336 SSVAL(tp.in.params.data, 0, info_level);
337 SIVAL(tp.in.params.data, 2, 0);
338 cli_blob_append_string(tree->session, mem_ctx, &tp.in.params,
339 fname, STR_TERMINATE);
341 req = smb_raw_trans2_send(tree, &tp);
343 talloc_destroy(mem_ctx);
348 /****************************************************************************
349 send a SMBgetatr (async send)
350 ****************************************************************************/
351 static struct cli_request *smb_raw_getattr_send(struct cli_tree *tree,
352 union smb_fileinfo *parms)
354 struct cli_request *req;
356 req = cli_request_setup(tree, SMBgetatr, 0, 0);
357 if (!req) return NULL;
359 cli_req_append_ascii4(req, parms->getattr.in.fname, STR_TERMINATE);
361 if (!cli_request_send(req)) {
362 cli_request_destroy(req);
369 /****************************************************************************
370 send a SMBgetatr (async recv)
371 ****************************************************************************/
372 static NTSTATUS smb_raw_getattr_recv(struct cli_request *req,
373 union smb_fileinfo *parms)
375 if (!cli_request_receive(req) ||
376 cli_request_is_error(req)) {
377 return cli_request_destroy(req);
380 CLI_CHECK_WCT(req, 10);
381 parms->getattr.out.attrib = SVAL(req->in.vwv, VWV(0));
382 parms->getattr.out.write_time = make_unix_date3(req->in.vwv + VWV(1));
383 parms->getattr.out.size = IVAL(req->in.vwv, VWV(3));
386 return cli_request_destroy(req);
390 /****************************************************************************
391 Handle SMBgetattrE (async send)
392 ****************************************************************************/
393 static struct cli_request *smb_raw_getattrE_send(struct cli_tree *tree,
394 union smb_fileinfo *parms)
396 struct cli_request *req;
398 req = cli_request_setup(tree, SMBgetattrE, 1, 0);
399 if (!req) return NULL;
401 SSVAL(req->out.vwv, VWV(0), parms->getattre.in.fnum);
402 if (!cli_request_send(req)) {
403 cli_request_destroy(req);
410 /****************************************************************************
411 Handle SMBgetattrE (async send)
412 ****************************************************************************/
413 static NTSTATUS smb_raw_getattrE_recv(struct cli_request *req,
414 union smb_fileinfo *parms)
416 if (!cli_request_receive(req) ||
417 cli_request_is_error(req)) {
418 return cli_request_destroy(req);
421 CLI_CHECK_WCT(req, 11);
422 parms->getattre.out.create_time = make_unix_date2(req->in.vwv + VWV(0));
423 parms->getattre.out.access_time = make_unix_date2(req->in.vwv + VWV(2));
424 parms->getattre.out.write_time = make_unix_date2(req->in.vwv + VWV(4));
425 parms->getattre.out.size = IVAL(req->in.vwv, VWV(6));
426 parms->getattre.out.alloc_size = IVAL(req->in.vwv, VWV(8));
427 parms->getattre.out.attrib = SVAL(req->in.vwv, VWV(10));
430 return cli_request_destroy(req);
434 /****************************************************************************
435 Query file info (async send)
436 ****************************************************************************/
437 struct cli_request *smb_raw_fileinfo_send(struct cli_tree *tree,
438 union smb_fileinfo *parms)
440 /* pass off the non-trans2 level to specialised functions */
441 if (parms->generic.level == RAW_FILEINFO_GETATTRE) {
442 return smb_raw_getattrE_send(tree, parms);
444 if (parms->generic.level >= RAW_FILEINFO_GENERIC) {
448 return smb_raw_fileinfo_blob_send(tree,
449 parms->generic.in.fnum,
450 parms->generic.level);
453 /****************************************************************************
454 Query file info (async recv)
455 ****************************************************************************/
456 NTSTATUS smb_raw_fileinfo_recv(struct cli_request *req,
458 union smb_fileinfo *parms)
462 struct cli_session *session = req?req->session:NULL;
464 if (parms->generic.level == RAW_FILEINFO_GETATTRE) {
465 return smb_raw_getattrE_recv(req, parms);
467 if (parms->generic.level == RAW_FILEINFO_GETATTR) {
468 return smb_raw_getattr_recv(req, parms);
471 status = smb_raw_fileinfo_blob_recv(req, mem_ctx, &blob);
472 if (!NT_STATUS_IS_OK(status)) {
476 return smb_raw_info_backend(session, mem_ctx, parms, &blob);
479 /****************************************************************************
480 Query file info (sync interface)
481 ****************************************************************************/
482 NTSTATUS smb_raw_fileinfo(struct cli_tree *tree,
484 union smb_fileinfo *parms)
486 struct cli_request *req = smb_raw_fileinfo_send(tree, parms);
487 return smb_raw_fileinfo_recv(req, mem_ctx, parms);
490 /****************************************************************************
491 Query path info (async send)
492 ****************************************************************************/
493 struct cli_request *smb_raw_pathinfo_send(struct cli_tree *tree,
494 union smb_fileinfo *parms)
496 if (parms->generic.level == RAW_FILEINFO_GETATTR) {
497 return smb_raw_getattr_send(tree, parms);
499 if (parms->generic.level >= RAW_FILEINFO_GENERIC) {
503 return smb_raw_pathinfo_blob_send(tree, parms->generic.in.fname,
504 parms->generic.level);
507 /****************************************************************************
508 Query path info (async recv)
509 ****************************************************************************/
510 NTSTATUS smb_raw_pathinfo_recv(struct cli_request *req,
512 union smb_fileinfo *parms)
514 /* recv is idential to fileinfo */
515 return smb_raw_fileinfo_recv(req, mem_ctx, parms);
518 /****************************************************************************
519 Query path info (sync interface)
520 ****************************************************************************/
521 NTSTATUS smb_raw_pathinfo(struct cli_tree *tree,
523 union smb_fileinfo *parms)
525 struct cli_request *req = smb_raw_pathinfo_send(tree, parms);
526 return smb_raw_pathinfo_recv(req, mem_ctx, parms);