?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
smb_server/smb: trans(2) setup count is uint8_t
[Samba/ekacnet.git] / source4 / smb_server / smb / trans2.c
blob6dd69de436c176c73b64a3b36a40583be980695f
1 /*
2 Unix SMB/CIFS implementation.
3 transaction2 handling
4 Copyright (C) Andrew Tridgell 2003
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19 /*
20 This file handles the parsing of transact2 requests
21 */
22
23 #include "includes.h"
24 #include "lib/util/dlinklist.h"
25 #include "smb_server/smb_server.h"
26 #include "librpc/gen_ndr/ndr_misc.h"
27 #include "ntvfs/ntvfs.h"
28 #include "libcli/raw/libcliraw.h"
29 #include "libcli/raw/raw_proto.h"
30
31 #define TRANS2_CHECK_ASYNC_STATUS_SIMPLE do { \
32 if (!NT_STATUS_IS_OK(req->ntvfs->async_states->status)) { \
33 trans2_setup_reply(trans, 0, 0, 0);\
34 return req->ntvfs->async_states->status; \
35 } \
36 } while (0)
37 #define TRANS2_CHECK_ASYNC_STATUS(ptr, type) do { \
38 TRANS2_CHECK_ASYNC_STATUS_SIMPLE; \
39 ptr = talloc_get_type(op->op_info, type); \
40 } while (0)
41 #define TRANS2_CHECK(cmd) do { \
42 NTSTATUS _status; \
43 _status = cmd; \
44 NT_STATUS_NOT_OK_RETURN(_status); \
45 } while (0)
46
47 /*
48 hold the state of a nttrans op while in progress. Needed to allow for async backend
49 functions.
50 */
51 struct trans_op {
52 struct smbsrv_request *req;
53 struct smb_trans2 *trans;
54 uint8_t command;
55 NTSTATUS (*send_fn)(struct trans_op *);
56 void *op_info;
57 };
58
59 #define CHECK_MIN_BLOB_SIZE(blob, size) do { \
60 if ((blob)->length < (size)) { \
61 return NT_STATUS_INFO_LENGTH_MISMATCH; \
62 }} while (0)
63
64 /* setup a trans2 reply, given the data and params sizes */
65 static NTSTATUS trans2_setup_reply(struct smb_trans2 *trans,
66 uint16_t param_size, uint16_t data_size,
67 uint8_t setup_count)
68 {
69 trans->out.setup_count = setup_count;
70 if (setup_count > 0) {
71 trans->out.setup = talloc_zero_array(trans, uint16_t, setup_count);
72 NT_STATUS_HAVE_NO_MEMORY(trans->out.setup);
73 }
74 trans->out.params = data_blob_talloc(trans, NULL, param_size);
75 if (param_size > 0) NT_STATUS_HAVE_NO_MEMORY(trans->out.params.data);
76
77 trans->out.data = data_blob_talloc(trans, NULL, data_size);
78 if (data_size > 0) NT_STATUS_HAVE_NO_MEMORY(trans->out.data.data);
79
80 return NT_STATUS_OK;
81 }
82
83 static NTSTATUS trans2_push_fsinfo(struct smbsrv_connection *smb_conn,
84 TALLOC_CTX *mem_ctx,
85 DATA_BLOB *blob,
86 union smb_fsinfo *fsinfo,
87 int default_str_flags)
88 {
89 enum smb_fsinfo_level passthru_level;
90
91 switch (fsinfo->generic.level) {
92 case RAW_QFS_ALLOCATION:
93 TRANS2_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 18));
94
95 SIVAL(blob->data, 0, fsinfo->allocation.out.fs_id);
96 SIVAL(blob->data, 4, fsinfo->allocation.out.sectors_per_unit);
97 SIVAL(blob->data, 8, fsinfo->allocation.out.total_alloc_units);
98 SIVAL(blob->data, 12, fsinfo->allocation.out.avail_alloc_units);
99 SSVAL(blob->data, 16, fsinfo->allocation.out.bytes_per_sector);
100
101 return NT_STATUS_OK;
102
103 case RAW_QFS_VOLUME:
104 TRANS2_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 5));
105
106 SIVAL(blob->data, 0, fsinfo->volume.out.serial_number);
107 /* w2k3 implements this incorrectly for unicode - it
108 * leaves the last byte off the string */
109 TRANS2_CHECK(smbsrv_blob_append_string(mem_ctx, blob,
110 fsinfo->volume.out.volume_name.s,
111 4, default_str_flags,
112 STR_LEN8BIT|STR_NOALIGN));
113
114 return NT_STATUS_OK;
115
116 case RAW_QFS_VOLUME_INFO:
117 passthru_level = RAW_QFS_VOLUME_INFORMATION;
118 break;
119
120 case RAW_QFS_SIZE_INFO:
121 passthru_level = RAW_QFS_SIZE_INFORMATION;
122 break;
123
124 case RAW_QFS_DEVICE_INFO:
125 passthru_level = RAW_QFS_DEVICE_INFORMATION;
126 break;
127
128 case RAW_QFS_ATTRIBUTE_INFO:
129 passthru_level = RAW_QFS_ATTRIBUTE_INFORMATION;
130 break;
131
132 default:
133 passthru_level = fsinfo->generic.level;
134 break;
135 }
136
137 return smbsrv_push_passthru_fsinfo(mem_ctx, blob,
138 passthru_level, fsinfo,
139 default_str_flags);
140 }
141
142 /*
143 trans2 qfsinfo implementation send
144 */
145 static NTSTATUS trans2_qfsinfo_send(struct trans_op *op)
146 {
147 struct smbsrv_request *req = op->req;
148 struct smb_trans2 *trans = op->trans;
149 union smb_fsinfo *fsinfo;
150
151 TRANS2_CHECK_ASYNC_STATUS(fsinfo, union smb_fsinfo);
152
153 TRANS2_CHECK(trans2_setup_reply(trans, 0, 0, 0));
154
155 TRANS2_CHECK(trans2_push_fsinfo(req->smb_conn, trans,
156 &trans->out.data, fsinfo,
157 SMBSRV_REQ_DEFAULT_STR_FLAGS(req)));
158
159 return NT_STATUS_OK;
160 }
161
162 /*
163 trans2 qfsinfo implementation
164 */
165 static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct trans_op *op)
166 {
167 struct smb_trans2 *trans = op->trans;
168 union smb_fsinfo *fsinfo;
169 uint16_t level;
170
171 /* make sure we got enough parameters */
172 if (trans->in.params.length != 2) {
173 return NT_STATUS_FOOBAR;
174 }
175
176 fsinfo = talloc(op, union smb_fsinfo);
177 NT_STATUS_HAVE_NO_MEMORY(fsinfo);
178
179 level = SVAL(trans->in.params.data, 0);
180
181 /* work out the backend level - we make it 1-1 in the header */
182 fsinfo->generic.level = (enum smb_fsinfo_level)level;
183 if (fsinfo->generic.level >= RAW_QFS_GENERIC) {
184 return NT_STATUS_INVALID_LEVEL;
185 }
186
187 op->op_info = fsinfo;
188 op->send_fn = trans2_qfsinfo_send;
189
190 return ntvfs_fsinfo(req->ntvfs, fsinfo);
191 }
192
193
194 /*
195 trans2 open implementation send
196 */
197 static NTSTATUS trans2_open_send(struct trans_op *op)
198 {
199 struct smbsrv_request *req = op->req;
200 struct smb_trans2 *trans = op->trans;
201 union smb_open *io;
202
203 TRANS2_CHECK_ASYNC_STATUS(io, union smb_open);
204
205 TRANS2_CHECK(trans2_setup_reply(trans, 30, 0, 0));
206
207 smbsrv_push_fnum(trans->out.params.data, VWV(0), io->t2open.out.file.ntvfs);
208 SSVAL(trans->out.params.data, VWV(1), io->t2open.out.attrib);
209 srv_push_dos_date3(req->smb_conn, trans->out.params.data,
210 VWV(2), io->t2open.out.write_time);
211 SIVAL(trans->out.params.data, VWV(4), io->t2open.out.size);
212 SSVAL(trans->out.params.data, VWV(6), io->t2open.out.access);
213 SSVAL(trans->out.params.data, VWV(7), io->t2open.out.ftype);
214 SSVAL(trans->out.params.data, VWV(8), io->t2open.out.devstate);
215 SSVAL(trans->out.params.data, VWV(9), io->t2open.out.action);
216 SIVAL(trans->out.params.data, VWV(10), 0); /* reserved */
217 SSVAL(trans->out.params.data, VWV(12), 0); /* EaErrorOffset */
218 SIVAL(trans->out.params.data, VWV(13), 0); /* EaLength */
219
220 return NT_STATUS_OK;
221 }
222
223 /*
224 trans2 open implementation
225 */
226 static NTSTATUS trans2_open(struct smbsrv_request *req, struct trans_op *op)
227 {
228 struct smb_trans2 *trans = op->trans;
229 union smb_open *io;
230
231 /* make sure we got enough parameters */
232 if (trans->in.params.length < 29) {
233 return NT_STATUS_FOOBAR;
234 }
235
236 io = talloc(op, union smb_open);
237 NT_STATUS_HAVE_NO_MEMORY(io);
238
239 io->t2open.level = RAW_OPEN_T2OPEN;
240 io->t2open.in.flags = SVAL(trans->in.params.data, VWV(0));
241 io->t2open.in.open_mode = SVAL(trans->in.params.data, VWV(1));
242 io->t2open.in.search_attrs = SVAL(trans->in.params.data, VWV(2));
243 io->t2open.in.file_attrs = SVAL(trans->in.params.data, VWV(3));
244 io->t2open.in.write_time = srv_pull_dos_date(req->smb_conn,
245 trans->in.params.data + VWV(4));
246 io->t2open.in.open_func = SVAL(trans->in.params.data, VWV(6));
247 io->t2open.in.size = IVAL(trans->in.params.data, VWV(7));
248 io->t2open.in.timeout = IVAL(trans->in.params.data, VWV(9));
249 io->t2open.in.num_eas = 0;
250 io->t2open.in.eas = NULL;
251
252 smbsrv_blob_pull_string(&req->in.bufinfo, &trans->in.params, 28, &io->t2open.in.fname, 0);
253 if (io->t2open.in.fname == NULL) {
254 return NT_STATUS_FOOBAR;
255 }
256
257 TRANS2_CHECK(ea_pull_list(&trans->in.data, io, &io->t2open.in.num_eas, &io->t2open.in.eas));
258
259 op->op_info = io;
260 op->send_fn = trans2_open_send;
261
262 return ntvfs_open(req->ntvfs, io);
263 }
264
265
266 /*
267 trans2 simple send
268 */
269 static NTSTATUS trans2_simple_send(struct trans_op *op)
270 {
271 struct smbsrv_request *req = op->req;
272 struct smb_trans2 *trans = op->trans;
273
274 TRANS2_CHECK_ASYNC_STATUS_SIMPLE;
275
276 TRANS2_CHECK(trans2_setup_reply(trans, 2, 0, 0));
277
278 SSVAL(trans->out.params.data, VWV(0), 0);
279
280 return NT_STATUS_OK;
281 }
282
283 /*
284 trans2 mkdir implementation
285 */
286 static NTSTATUS trans2_mkdir(struct smbsrv_request *req, struct trans_op *op)
287 {
288 struct smb_trans2 *trans = op->trans;
289 union smb_mkdir *io;
290
291 /* make sure we got enough parameters */
292 if (trans->in.params.length < 5) {
293 return NT_STATUS_FOOBAR;
294 }
295
296 io = talloc(op, union smb_mkdir);
297 NT_STATUS_HAVE_NO_MEMORY(io);
298
299 io->t2mkdir.level = RAW_MKDIR_T2MKDIR;
300 smbsrv_blob_pull_string(&req->in.bufinfo, &trans->in.params, 4, &io->t2mkdir.in.path, 0);
301 if (io->t2mkdir.in.path == NULL) {
302 return NT_STATUS_FOOBAR;
303 }
304
305 TRANS2_CHECK(ea_pull_list(&trans->in.data, io,
306 &io->t2mkdir.in.num_eas,
307 &io->t2mkdir.in.eas));
308
309 op->op_info = io;
310 op->send_fn = trans2_simple_send;
311
312 return ntvfs_mkdir(req->ntvfs, io);
313 }
314
315 static NTSTATUS trans2_push_fileinfo(struct smbsrv_connection *smb_conn,
316 TALLOC_CTX *mem_ctx,
317 DATA_BLOB *blob,
318 union smb_fileinfo *st,
319 int default_str_flags)
320 {
321 uint32_t list_size;
322 enum smb_fileinfo_level passthru_level;
323
324 switch (st->generic.level) {
325 case RAW_FILEINFO_GENERIC:
326 case RAW_FILEINFO_GETATTR:
327 case RAW_FILEINFO_GETATTRE:
328 case RAW_FILEINFO_SEC_DESC:
329 case RAW_FILEINFO_SMB2_ALL_EAS:
330 case RAW_FILEINFO_SMB2_ALL_INFORMATION:
331 /* handled elsewhere */
332 return NT_STATUS_INVALID_LEVEL;
333
334 case RAW_FILEINFO_UNIX_BASIC:
335 case RAW_FILEINFO_UNIX_LINK:
336 /* not implemented yet */
337 return NT_STATUS_INVALID_LEVEL;
338
339 case RAW_FILEINFO_STANDARD:
340 TRANS2_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 22));
341
342 srv_push_dos_date2(smb_conn, blob->data, 0, st->standard.out.create_time);
343 srv_push_dos_date2(smb_conn, blob->data, 4, st->standard.out.access_time);
344 srv_push_dos_date2(smb_conn, blob->data, 8, st->standard.out.write_time);
345 SIVAL(blob->data, 12, st->standard.out.size);
346 SIVAL(blob->data, 16, st->standard.out.alloc_size);
347 SSVAL(blob->data, 20, st->standard.out.attrib);
348 return NT_STATUS_OK;
349
350 case RAW_FILEINFO_EA_SIZE:
351 TRANS2_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, 26));
352
353 srv_push_dos_date2(smb_conn, blob->data, 0, st->ea_size.out.create_time);
354 srv_push_dos_date2(smb_conn, blob->data, 4, st->ea_size.out.access_time);
355 srv_push_dos_date2(smb_conn, blob->data, 8, st->ea_size.out.write_time);
356 SIVAL(blob->data, 12, st->ea_size.out.size);
357 SIVAL(blob->data, 16, st->ea_size.out.alloc_size);
358 SSVAL(blob->data, 20, st->ea_size.out.attrib);
359 SIVAL(blob->data, 22, st->ea_size.out.ea_size);
360 return NT_STATUS_OK;
361
362 case RAW_FILEINFO_EA_LIST:
363 list_size = ea_list_size(st->ea_list.out.num_eas,
364 st->ea_list.out.eas);
365 TRANS2_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, list_size));
366
367 ea_put_list(blob->data,
368 st->ea_list.out.num_eas, st->ea_list.out.eas);
369 return NT_STATUS_OK;
370
371 case RAW_FILEINFO_ALL_EAS:
372 list_size = ea_list_size(st->all_eas.out.num_eas,
373 st->all_eas.out.eas);
374 TRANS2_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, list_size));
375
376 ea_put_list(blob->data,
377 st->all_eas.out.num_eas, st->all_eas.out.eas);
378 return NT_STATUS_OK;
379
380 case RAW_FILEINFO_IS_NAME_VALID:
381 return NT_STATUS_OK;
382
383 case RAW_FILEINFO_BASIC_INFO:
384 passthru_level = RAW_FILEINFO_BASIC_INFORMATION;
385 break;
386
387 case RAW_FILEINFO_STANDARD_INFO:
388 passthru_level = RAW_FILEINFO_STANDARD_INFORMATION;
389 break;
390
391 case RAW_FILEINFO_EA_INFO:
392 passthru_level = RAW_FILEINFO_EA_INFORMATION;
393 break;
394
395 case RAW_FILEINFO_COMPRESSION_INFO:
396 passthru_level = RAW_FILEINFO_COMPRESSION_INFORMATION;
397 break;
398
399 case RAW_FILEINFO_ALL_INFO:
400 passthru_level = RAW_FILEINFO_ALL_INFORMATION;
401 break;
402
403 case RAW_FILEINFO_NAME_INFO:
404 passthru_level = RAW_FILEINFO_NAME_INFORMATION;
405 break;
406
407 case RAW_FILEINFO_ALT_NAME_INFO:
408 passthru_level = RAW_FILEINFO_ALT_NAME_INFORMATION;
409 break;
410
411 case RAW_FILEINFO_STREAM_INFO:
412 passthru_level = RAW_FILEINFO_STREAM_INFORMATION;
413 break;
414
415 default:
416 passthru_level = st->generic.level;
417 break;
418 }
419
420 return smbsrv_push_passthru_fileinfo(mem_ctx, blob,
421 passthru_level, st,
422 default_str_flags);
423 }
424
425 /*
426 fill in the reply from a qpathinfo or qfileinfo call
427 */
428 static NTSTATUS trans2_fileinfo_send(struct trans_op *op)
429 {
430 struct smbsrv_request *req = op->req;
431 struct smb_trans2 *trans = op->trans;
432 union smb_fileinfo *st;
433
434 TRANS2_CHECK_ASYNC_STATUS(st, union smb_fileinfo);
435
436 TRANS2_CHECK(trans2_setup_reply(trans, 2, 0, 0));
437 SSVAL(trans->out.params.data, 0, 0);
438
439 TRANS2_CHECK(trans2_push_fileinfo(req->smb_conn, trans,
440 &trans->out.data, st,
441 SMBSRV_REQ_DEFAULT_STR_FLAGS(req)));
442
443 return NT_STATUS_OK;
444 }
445
446 /*
447 trans2 qpathinfo implementation
448 */
449 static NTSTATUS trans2_qpathinfo(struct smbsrv_request *req, struct trans_op *op)
450 {
451 struct smb_trans2 *trans = op->trans;
452 union smb_fileinfo *st;
453 uint16_t level;
454
455 /* make sure we got enough parameters */
456 if (trans->in.params.length < 2) {
457 return NT_STATUS_FOOBAR;
458 }
459
460 st = talloc(op, union smb_fileinfo);
461 NT_STATUS_HAVE_NO_MEMORY(st);
462
463 level = SVAL(trans->in.params.data, 0);
464
465 smbsrv_blob_pull_string(&req->in.bufinfo, &trans->in.params, 6, &st->generic.in.file.path, 0);
466 if (st->generic.in.file.path == NULL) {
467 return NT_STATUS_FOOBAR;
468 }
469
470 /* work out the backend level - we make it 1-1 in the header */
471 st->generic.level = (enum smb_fileinfo_level)level;
472 if (st->generic.level >= RAW_FILEINFO_GENERIC) {
473 return NT_STATUS_INVALID_LEVEL;
474 }
475
476 if (st->generic.level == RAW_FILEINFO_EA_LIST) {
477 TRANS2_CHECK(ea_pull_name_list(&trans->in.data, req,
478 &st->ea_list.in.num_names,
479 &st->ea_list.in.ea_names));
480 }
481
482 op->op_info = st;
483 op->send_fn = trans2_fileinfo_send;
484
485 return ntvfs_qpathinfo(req->ntvfs, st);
486 }
487
488
489 /*
490 trans2 qpathinfo implementation
491 */
492 static NTSTATUS trans2_qfileinfo(struct smbsrv_request *req, struct trans_op *op)
493 {
494 struct smb_trans2 *trans = op->trans;
495 union smb_fileinfo *st;
496 uint16_t level;
497 struct ntvfs_handle *h;
498
499 /* make sure we got enough parameters */
500 if (trans->in.params.length < 4) {
501 return NT_STATUS_FOOBAR;
502 }
503
504 st = talloc(op, union smb_fileinfo);
505 NT_STATUS_HAVE_NO_MEMORY(st);
506
507 h = smbsrv_pull_fnum(req, trans->in.params.data, 0);
508 level = SVAL(trans->in.params.data, 2);
509
510 st->generic.in.file.ntvfs = h;
511 /* work out the backend level - we make it 1-1 in the header */
512 st->generic.level = (enum smb_fileinfo_level)level;
513 if (st->generic.level >= RAW_FILEINFO_GENERIC) {
514 return NT_STATUS_INVALID_LEVEL;
515 }
516
517 if (st->generic.level == RAW_FILEINFO_EA_LIST) {
518 TRANS2_CHECK(ea_pull_name_list(&trans->in.data, req,
519 &st->ea_list.in.num_names,
520 &st->ea_list.in.ea_names));
521 }
522
523 op->op_info = st;
524 op->send_fn = trans2_fileinfo_send;
525
526 SMBSRV_CHECK_FILE_HANDLE_NTSTATUS(st->generic.in.file.ntvfs);
527 return ntvfs_qfileinfo(req->ntvfs, st);
528 }
529
530
531 /*
532 parse a trans2 setfileinfo/setpathinfo data blob
533 */
534 static NTSTATUS trans2_parse_sfileinfo(struct smbsrv_request *req,
535 union smb_setfileinfo *st,
536 const DATA_BLOB *blob)
537 {
538 enum smb_setfileinfo_level passthru_level;
539
540 switch (st->generic.level) {
541 case RAW_SFILEINFO_GENERIC:
542 case RAW_SFILEINFO_SETATTR:
543 case RAW_SFILEINFO_SETATTRE:
544 case RAW_SFILEINFO_SEC_DESC:
545 /* handled elsewhere */
546 return NT_STATUS_INVALID_LEVEL;
547
548 case RAW_SFILEINFO_STANDARD:
549 CHECK_MIN_BLOB_SIZE(blob, 12);
550
551 st->standard.in.create_time = srv_pull_dos_date2(req->smb_conn, blob->data + 0);
552 st->standard.in.access_time = srv_pull_dos_date2(req->smb_conn, blob->data + 4);
553 st->standard.in.write_time = srv_pull_dos_date2(req->smb_conn, blob->data + 8);
554
555 return NT_STATUS_OK;
556
557 case RAW_SFILEINFO_EA_SET:
558 return ea_pull_list(blob, req,
559 &st->ea_set.in.num_eas,
560 &st->ea_set.in.eas);
561
562 case SMB_SFILEINFO_BASIC_INFO:
563 case SMB_SFILEINFO_BASIC_INFORMATION:
564 passthru_level = SMB_SFILEINFO_BASIC_INFORMATION;
565 break;
566
567 case SMB_SFILEINFO_DISPOSITION_INFO:
568 case SMB_SFILEINFO_DISPOSITION_INFORMATION:
569 passthru_level = SMB_SFILEINFO_DISPOSITION_INFORMATION;
570 break;
571
572 case SMB_SFILEINFO_ALLOCATION_INFO:
573 case SMB_SFILEINFO_ALLOCATION_INFORMATION:
574 passthru_level = SMB_SFILEINFO_ALLOCATION_INFORMATION;
575 break;
576
577 case RAW_SFILEINFO_END_OF_FILE_INFO:
578 case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
579 passthru_level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
580 break;
581
582 case RAW_SFILEINFO_RENAME_INFORMATION:
583 case RAW_SFILEINFO_POSITION_INFORMATION:
584 case RAW_SFILEINFO_MODE_INFORMATION:
585 passthru_level = st->generic.level;
586 break;
587
588 case RAW_SFILEINFO_UNIX_BASIC:
589 case RAW_SFILEINFO_UNIX_LINK:
590 case RAW_SFILEINFO_UNIX_HLINK:
591 case RAW_SFILEINFO_PIPE_INFORMATION:
592 case RAW_SFILEINFO_VALID_DATA_INFORMATION:
593 case RAW_SFILEINFO_SHORT_NAME_INFORMATION:
594 case RAW_SFILEINFO_1025:
595 case RAW_SFILEINFO_1027:
596 case RAW_SFILEINFO_1029:
597 case RAW_SFILEINFO_1030:
598 case RAW_SFILEINFO_1031:
599 case RAW_SFILEINFO_1032:
600 case RAW_SFILEINFO_1036:
601 case RAW_SFILEINFO_1041:
602 case RAW_SFILEINFO_1042:
603 case RAW_SFILEINFO_1043:
604 case RAW_SFILEINFO_1044:
605 return NT_STATUS_INVALID_LEVEL;
606
607 default:
608 /* we need a default here to cope with invalid values on the wire */
609 return NT_STATUS_INVALID_LEVEL;
610 }
611
612 return smbsrv_pull_passthru_sfileinfo(st, passthru_level, st,
613 blob, SMBSRV_REQ_DEFAULT_STR_FLAGS(req),
614 &req->in.bufinfo);
615 }
616
617 /*
618 trans2 setfileinfo implementation
619 */
620 static NTSTATUS trans2_setfileinfo(struct smbsrv_request *req, struct trans_op *op)
621 {
622 struct smb_trans2 *trans = op->trans;
623 union smb_setfileinfo *st;
624 uint16_t level;
625 struct ntvfs_handle *h;
626
627 /* make sure we got enough parameters */
628 if (trans->in.params.length < 4) {
629 return NT_STATUS_FOOBAR;
630 }
631
632 st = talloc(op, union smb_setfileinfo);
633 NT_STATUS_HAVE_NO_MEMORY(st);
634
635 h = smbsrv_pull_fnum(req, trans->in.params.data, 0);
636 level = SVAL(trans->in.params.data, 2);
637
638 st->generic.in.file.ntvfs = h;
639 /* work out the backend level - we make it 1-1 in the header */
640 st->generic.level = (enum smb_setfileinfo_level)level;
641 if (st->generic.level >= RAW_SFILEINFO_GENERIC) {
642 return NT_STATUS_INVALID_LEVEL;
643 }
644
645 TRANS2_CHECK(trans2_parse_sfileinfo(req, st, &trans->in.data));
646
647 op->op_info = st;
648 op->send_fn = trans2_simple_send;
649
650 SMBSRV_CHECK_FILE_HANDLE_NTSTATUS(st->generic.in.file.ntvfs);
651 return ntvfs_setfileinfo(req->ntvfs, st);
652 }
653
654 /*
655 trans2 setpathinfo implementation
656 */
657 static NTSTATUS trans2_setpathinfo(struct smbsrv_request *req, struct trans_op *op)
658 {
659 struct smb_trans2 *trans = op->trans;
660 union smb_setfileinfo *st;
661 uint16_t level;
662
663 /* make sure we got enough parameters */
664 if (trans->in.params.length < 4) {
665 return NT_STATUS_FOOBAR;
666 }
667
668 st = talloc(op, union smb_setfileinfo);
669 NT_STATUS_HAVE_NO_MEMORY(st);
670
671 level = SVAL(trans->in.params.data, 0);
672
673 smbsrv_blob_pull_string(&req->in.bufinfo, &trans->in.params, 6, &st->generic.in.file.path, 0);
674 if (st->generic.in.file.path == NULL) {
675 return NT_STATUS_FOOBAR;
676 }
677
678 /* work out the backend level - we make it 1-1 in the header */
679 st->generic.level = (enum smb_setfileinfo_level)level;
680 if (st->generic.level >= RAW_SFILEINFO_GENERIC) {
681 return NT_STATUS_INVALID_LEVEL;
682 }
683
684 TRANS2_CHECK(trans2_parse_sfileinfo(req, st, &trans->in.data));
685
686 op->op_info = st;
687 op->send_fn = trans2_simple_send;
688
689 return ntvfs_setpathinfo(req->ntvfs, st);
690 }
691
692
693 /* a structure to encapsulate the state information about an in-progress ffirst/fnext operation */
694 struct find_state {
695 struct trans_op *op;
696 void *search;
697 enum smb_search_data_level data_level;
698 uint16_t last_entry_offset;
699 uint16_t flags;
700 };
701
702 /*
703 fill a single entry in a trans2 find reply
704 */
705 static NTSTATUS find_fill_info(struct find_state *state,
706 const union smb_search_data *file)
707 {
708 struct smbsrv_request *req = state->op->req;
709 struct smb_trans2 *trans = state->op->trans;
710 uint8_t *data;
711 uint_t ofs = trans->out.data.length;
712 uint32_t ea_size;
713
714 switch (state->data_level) {
715 case RAW_SEARCH_DATA_GENERIC:
716 case RAW_SEARCH_DATA_SEARCH:
717 /* handled elsewhere */
718 return NT_STATUS_INVALID_LEVEL;
719
720 case RAW_SEARCH_DATA_STANDARD:
721 if (state->flags & FLAG_TRANS2_FIND_REQUIRE_RESUME) {
722 TRANS2_CHECK(smbsrv_blob_grow_data(trans, &trans->out.data, ofs + 27));
723 SIVAL(trans->out.data.data, ofs, file->standard.resume_key);
724 ofs += 4;
725 } else {
726 TRANS2_CHECK(smbsrv_blob_grow_data(trans, &trans->out.data, ofs + 23));
727 }
728 data = trans->out.data.data + ofs;
729 srv_push_dos_date2(req->smb_conn, data, 0, file->standard.create_time);
730 srv_push_dos_date2(req->smb_conn, data, 4, file->standard.access_time);
731 srv_push_dos_date2(req->smb_conn, data, 8, file->standard.write_time);
732 SIVAL(data, 12, file->standard.size);
733 SIVAL(data, 16, file->standard.alloc_size);
734 SSVAL(data, 20, file->standard.attrib);
735 TRANS2_CHECK(smbsrv_blob_append_string(trans, &trans->out.data, file->standard.name.s,
736 ofs + 22, SMBSRV_REQ_DEFAULT_STR_FLAGS(req),
737 STR_LEN8BIT | STR_TERMINATE | STR_LEN_NOTERM));
738 break;
739
740 case RAW_SEARCH_DATA_EA_SIZE:
741 if (state->flags & FLAG_TRANS2_FIND_REQUIRE_RESUME) {
742 TRANS2_CHECK(smbsrv_blob_grow_data(trans, &trans->out.data, ofs + 31));
743 SIVAL(trans->out.data.data, ofs, file->ea_size.resume_key);
744 ofs += 4;
745 } else {
746 TRANS2_CHECK(smbsrv_blob_grow_data(trans, &trans->out.data, ofs + 27));
747 }
748 data = trans->out.data.data + ofs;
749 srv_push_dos_date2(req->smb_conn, data, 0, file->ea_size.create_time);
750 srv_push_dos_date2(req->smb_conn, data, 4, file->ea_size.access_time);
751 srv_push_dos_date2(req->smb_conn, data, 8, file->ea_size.write_time);
752 SIVAL(data, 12, file->ea_size.size);
753 SIVAL(data, 16, file->ea_size.alloc_size);
754 SSVAL(data, 20, file->ea_size.attrib);
755 SIVAL(data, 22, file->ea_size.ea_size);
756 TRANS2_CHECK(smbsrv_blob_append_string(trans, &trans->out.data, file->ea_size.name.s,
757 ofs + 26, SMBSRV_REQ_DEFAULT_STR_FLAGS(req),
758 STR_LEN8BIT | STR_NOALIGN));
759 TRANS2_CHECK(smbsrv_blob_fill_data(trans, &trans->out.data, trans->out.data.length + 1));
760 break;
761
762 case RAW_SEARCH_DATA_EA_LIST:
763 ea_size = ea_list_size(file->ea_list.eas.num_eas, file->ea_list.eas.eas);
764 if (state->flags & FLAG_TRANS2_FIND_REQUIRE_RESUME) {
765 TRANS2_CHECK(smbsrv_blob_grow_data(trans, &trans->out.data, ofs + 27 + ea_size));
766 SIVAL(trans->out.data.data, ofs, file->ea_list.resume_key);
767 ofs += 4;
768 } else {
769 TRANS2_CHECK(smbsrv_blob_grow_data(trans, &trans->out.data, ofs + 23 + ea_size));
770 }
771 data = trans->out.data.data + ofs;
772 srv_push_dos_date2(req->smb_conn, data, 0, file->ea_list.create_time);
773 srv_push_dos_date2(req->smb_conn, data, 4, file->ea_list.access_time);
774 srv_push_dos_date2(req->smb_conn, data, 8, file->ea_list.write_time);
775 SIVAL(data, 12, file->ea_list.size);
776 SIVAL(data, 16, file->ea_list.alloc_size);
777 SSVAL(data, 20, file->ea_list.attrib);
778 ea_put_list(data+22, file->ea_list.eas.num_eas, file->ea_list.eas.eas);
779 TRANS2_CHECK(smbsrv_blob_append_string(trans, &trans->out.data, file->ea_list.name.s,
780 ofs + 22 + ea_size, SMBSRV_REQ_DEFAULT_STR_FLAGS(req),
781 STR_LEN8BIT | STR_NOALIGN));
782 TRANS2_CHECK(smbsrv_blob_fill_data(trans, &trans->out.data, trans->out.data.length + 1));
783 break;
784
785 case RAW_SEARCH_DATA_DIRECTORY_INFO:
786 case RAW_SEARCH_DATA_FULL_DIRECTORY_INFO:
787 case RAW_SEARCH_DATA_NAME_INFO:
788 case RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO:
789 case RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO:
790 case RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO:
791 return smbsrv_push_passthru_search(trans, &trans->out.data, state->data_level, file,
792 SMBSRV_REQ_DEFAULT_STR_FLAGS(req));
793
794 case RAW_SEARCH_DATA_UNIX_INFO:
795 case RAW_SEARCH_DATA_UNIX_INFO2:
796 return NT_STATUS_INVALID_LEVEL;
797 }
798
799 return NT_STATUS_OK;
800 }
801
802 /* callback function for trans2 findfirst/findnext */
803 static bool find_callback(void *private, const union smb_search_data *file)
804 {
805 struct find_state *state = talloc_get_type(private, struct find_state);
806 struct smb_trans2 *trans = state->op->trans;
807 uint_t old_length;
808
809 old_length = trans->out.data.length;
810
811 if (!NT_STATUS_IS_OK(find_fill_info(state, file)) ||
812 trans->out.data.length > trans->in.max_data) {
813 /* restore the old length and tell the backend to stop */
814 smbsrv_blob_grow_data(trans, &trans->out.data, old_length);
815 return false;
816 }
817
818 state->last_entry_offset = old_length;
819 return true;
820 }
821
822 /*
823 trans2 findfirst send
824 */
825 static NTSTATUS trans2_findfirst_send(struct trans_op *op)
826 {
827 struct smbsrv_request *req = op->req;
828 struct smb_trans2 *trans = op->trans;
829 union smb_search_first *search;
830 struct find_state *state;
831 uint8_t *param;
832
833 TRANS2_CHECK_ASYNC_STATUS(state, struct find_state);
834 search = talloc_get_type(state->search, union smb_search_first);
835
836 /* fill in the findfirst reply header */
837 param = trans->out.params.data;
838 SSVAL(param, VWV(0), search->t2ffirst.out.handle);
839 SSVAL(param, VWV(1), search->t2ffirst.out.count);
840 SSVAL(param, VWV(2), search->t2ffirst.out.end_of_search);
841 SSVAL(param, VWV(3), 0);
842 SSVAL(param, VWV(4), state->last_entry_offset);
843
844 return NT_STATUS_OK;
845 }
846
847
848 /*
849 trans2 findfirst implementation
850 */
851 static NTSTATUS trans2_findfirst(struct smbsrv_request *req, struct trans_op *op)
852 {
853 struct smb_trans2 *trans = op->trans;
854 union smb_search_first *search;
855 uint16_t level;
856 struct find_state *state;
857
858 /* make sure we got all the parameters */
859 if (trans->in.params.length < 14) {
860 return NT_STATUS_FOOBAR;
861 }
862
863 search = talloc(op, union smb_search_first);
864 NT_STATUS_HAVE_NO_MEMORY(search);
865
866 search->t2ffirst.in.search_attrib = SVAL(trans->in.params.data, 0);
867 search->t2ffirst.in.max_count = SVAL(trans->in.params.data, 2);
868 search->t2ffirst.in.flags = SVAL(trans->in.params.data, 4);
869 level = SVAL(trans->in.params.data, 6);
870 search->t2ffirst.in.storage_type = IVAL(trans->in.params.data, 8);
871
872 smbsrv_blob_pull_string(&req->in.bufinfo, &trans->in.params, 12, &search->t2ffirst.in.pattern, 0);
873 if (search->t2ffirst.in.pattern == NULL) {
874 return NT_STATUS_FOOBAR;
875 }
876
877 search->t2ffirst.level = RAW_SEARCH_TRANS2;
878 search->t2ffirst.data_level = (enum smb_search_data_level)level;
879 if (search->t2ffirst.data_level >= RAW_SEARCH_DATA_GENERIC) {
880 return NT_STATUS_INVALID_LEVEL;
881 }
882
883 if (search->t2ffirst.data_level == RAW_SEARCH_DATA_EA_LIST) {
884 TRANS2_CHECK(ea_pull_name_list(&trans->in.data, req,
885 &search->t2ffirst.in.num_names,
886 &search->t2ffirst.in.ea_names));
887 }
888
889 /* setup the private state structure that the backend will
890 give us in the callback */
891 state = talloc(op, struct find_state);
892 NT_STATUS_HAVE_NO_MEMORY(state);
893 state->op = op;
894 state->search = search;
895 state->data_level = search->t2ffirst.data_level;
896 state->last_entry_offset= 0;
897 state->flags = search->t2ffirst.in.flags;
898
899 /* setup for just a header in the reply */
900 TRANS2_CHECK(trans2_setup_reply(trans, 10, 0, 0));
901
902 op->op_info = state;
903 op->send_fn = trans2_findfirst_send;
904
905 return ntvfs_search_first(req->ntvfs, search, state, find_callback);
906 }
907
908
909 /*
910 trans2 findnext send
911 */
912 static NTSTATUS trans2_findnext_send(struct trans_op *op)
913 {
914 struct smbsrv_request *req = op->req;
915 struct smb_trans2 *trans = op->trans;
916 union smb_search_next *search;
917 struct find_state *state;
918 uint8_t *param;
919
920 TRANS2_CHECK_ASYNC_STATUS(state, struct find_state);
921 search = talloc_get_type(state->search, union smb_search_next);
922
923 /* fill in the findfirst reply header */
924 param = trans->out.params.data;
925 SSVAL(param, VWV(0), search->t2fnext.out.count);
926 SSVAL(param, VWV(1), search->t2fnext.out.end_of_search);
927 SSVAL(param, VWV(2), 0);
928 SSVAL(param, VWV(3), state->last_entry_offset);
929
930 return NT_STATUS_OK;
931 }
932
933
934 /*
935 trans2 findnext implementation
936 */
937 static NTSTATUS trans2_findnext(struct smbsrv_request *req, struct trans_op *op)
938 {
939 struct smb_trans2 *trans = op->trans;
940 union smb_search_next *search;
941 uint16_t level;
942 struct find_state *state;
943
944 /* make sure we got all the parameters */
945 if (trans->in.params.length < 12) {
946 return NT_STATUS_FOOBAR;
947 }
948
949 search = talloc(op, union smb_search_next);
950 NT_STATUS_HAVE_NO_MEMORY(search);
951
952 search->t2fnext.in.handle = SVAL(trans->in.params.data, 0);
953 search->t2fnext.in.max_count = SVAL(trans->in.params.data, 2);
954 level = SVAL(trans->in.params.data, 4);
955 search->t2fnext.in.resume_key = IVAL(trans->in.params.data, 6);
956 search->t2fnext.in.flags = SVAL(trans->in.params.data, 10);
957
958 smbsrv_blob_pull_string(&req->in.bufinfo, &trans->in.params, 12, &search->t2fnext.in.last_name, 0);
959 if (search->t2fnext.in.last_name == NULL) {
960 return NT_STATUS_FOOBAR;
961 }
962
963 search->t2fnext.level = RAW_SEARCH_TRANS2;
964 search->t2fnext.data_level = (enum smb_search_data_level)level;
965 if (search->t2fnext.data_level >= RAW_SEARCH_DATA_GENERIC) {
966 return NT_STATUS_INVALID_LEVEL;
967 }
968
969 if (search->t2fnext.data_level == RAW_SEARCH_DATA_EA_LIST) {
970 TRANS2_CHECK(ea_pull_name_list(&trans->in.data, req,
971 &search->t2fnext.in.num_names,
972 &search->t2fnext.in.ea_names));
973 }
974
975 /* setup the private state structure that the backend will give us in the callback */
976 state = talloc(op, struct find_state);
977 NT_STATUS_HAVE_NO_MEMORY(state);
978 state->op = op;
979 state->search = search;
980 state->data_level = search->t2fnext.data_level;
981 state->last_entry_offset= 0;
982 state->flags = search->t2fnext.in.flags;
983
984 /* setup for just a header in the reply */
985 TRANS2_CHECK(trans2_setup_reply(trans, 8, 0, 0));
986
987 op->op_info = state;
988 op->send_fn = trans2_findnext_send;
989
990 return ntvfs_search_next(req->ntvfs, search, state, find_callback);
991 }
992
993
994 /*
995 backend for trans2 requests
996 */
997 static NTSTATUS trans2_backend(struct smbsrv_request *req, struct trans_op *op)
998 {
999 struct smb_trans2 *trans = op->trans;
1000 NTSTATUS status;
1001
1002 /* direct trans2 pass thru */
1003 status = ntvfs_trans2(req->ntvfs, trans);
1004 if (!NT_STATUS_EQUAL(NT_STATUS_NOT_IMPLEMENTED, status)) {
1005 return status;
1006 }
1007
1008 /* must have at least one setup word */
1009 if (trans->in.setup_count < 1) {
1010 return NT_STATUS_FOOBAR;
1011 }
1012
1013 /* the trans2 command is in setup[0] */
1014 switch (trans->in.setup[0]) {
1015 case TRANSACT2_FINDFIRST:
1016 return trans2_findfirst(req, op);
1017 case TRANSACT2_FINDNEXT:
1018 return trans2_findnext(req, op);
1019 case TRANSACT2_QPATHINFO:
1020 return trans2_qpathinfo(req, op);
1021 case TRANSACT2_QFILEINFO:
1022 return trans2_qfileinfo(req, op);
1023 case TRANSACT2_SETFILEINFO:
1024 return trans2_setfileinfo(req, op);
1025 case TRANSACT2_SETPATHINFO:
1026 return trans2_setpathinfo(req, op);
1027 case TRANSACT2_QFSINFO:
1028 return trans2_qfsinfo(req, op);
1029 case TRANSACT2_OPEN:
1030 return trans2_open(req, op);
1031 case TRANSACT2_MKDIR:
1032 return trans2_mkdir(req, op);
1033 }
1034
1035 /* an unknown trans2 command */
1036 return NT_STATUS_FOOBAR;
1037 }
1038
1039 static int smbsrv_trans_partial_destructor(struct smbsrv_trans_partial *tp)
1040 {
1041 DLIST_REMOVE(tp->req->smb_conn->trans_partial, tp);
1042 return 0;
1043 }
1044
1045
1046 /*
1047 send a continue request
1048 */
1049 static void reply_trans_continue(struct smbsrv_request *req, uint8_t command,
1050 struct smb_trans2 *trans)
1051 {
1052 struct smbsrv_request *req2;
1053 struct smbsrv_trans_partial *tp;
1054 int count;
1055
1056 /* make sure they don't flood us */
1057 for (count=0,tp=req->smb_conn->trans_partial;tp;tp=tp->next) count++;
1058 if (count > 100) {
1059 smbsrv_send_error(req, NT_STATUS_INSUFFICIENT_RESOURCES);
1060 return;
1061 }
1062
1063 tp = talloc(req, struct smbsrv_trans_partial);
1064
1065 tp->req = req;
1066 tp->trans = trans;
1067 tp->command = command;
1068
1069 DLIST_ADD(req->smb_conn->trans_partial, tp);
1070 talloc_set_destructor(tp, smbsrv_trans_partial_destructor);
1071
1072 req2 = smbsrv_setup_secondary_request(req);
1073
1074 /* send a 'please continue' reply */
1075 smbsrv_setup_reply(req2, 0, 0);
1076 smbsrv_send_reply(req2);
1077 }
1078
1079
1080 /*
1081 answer a reconstructed trans request
1082 */
1083 static void reply_trans_send(struct ntvfs_request *ntvfs)
1084 {
1085 struct smbsrv_request *req;
1086 struct trans_op *op;
1087 struct smb_trans2 *trans;
1088 uint16_t params_left, data_left;
1089 uint8_t *params, *data;
1090 int i;
1091
1092 SMBSRV_CHECK_ASYNC_STATUS_ERR(op, struct trans_op);
1093 trans = op->trans;
1094
1095 /* if this function needs work to form the nttrans reply buffer, then
1096 call that now */
1097 if (op->send_fn != NULL) {
1098 NTSTATUS status;
1099 status = op->send_fn(op);
1100 if (!NT_STATUS_IS_OK(status)) {
1101 smbsrv_send_error(req, status);
1102 return;
1103 }
1104 }
1105
1106 params_left = trans->out.params.length;
1107 data_left = trans->out.data.length;
1108 params = trans->out.params.data;
1109 data = trans->out.data.data;
1110
1111 smbsrv_setup_reply(req, 10 + trans->out.setup_count, 0);
1112
1113 if (!NT_STATUS_IS_OK(req->ntvfs->async_states->status)) {
1114 smbsrv_setup_error(req, req->ntvfs->async_states->status);
1115 }
1116
1117 /* we need to divide up the reply into chunks that fit into
1118 the negotiated buffer size */
1119 do {
1120 uint16_t this_data, this_param, max_bytes;
1121 uint_t align1 = 1, align2 = (params_left ? 2 : 0);
1122 struct smbsrv_request *this_req;
1123
1124 max_bytes = req_max_data(req) - (align1 + align2);
1125
1126 this_param = params_left;
1127 if (this_param > max_bytes) {
1128 this_param = max_bytes;
1129 }
1130 max_bytes -= this_param;
1131
1132 this_data = data_left;
1133 if (this_data > max_bytes) {
1134 this_data = max_bytes;
1135 }
1136
1137 /* don't destroy unless this is the last chunk */
1138 if (params_left - this_param != 0 ||
1139 data_left - this_data != 0) {
1140 this_req = smbsrv_setup_secondary_request(req);
1141 } else {
1142 this_req = req;
1143 }
1144
1145 req_grow_data(this_req, this_param + this_data + (align1 + align2));
1146
1147 SSVAL(this_req->out.vwv, VWV(0), trans->out.params.length);
1148 SSVAL(this_req->out.vwv, VWV(1), trans->out.data.length);
1149 SSVAL(this_req->out.vwv, VWV(2), 0);
1150
1151 SSVAL(this_req->out.vwv, VWV(3), this_param);
1152 SSVAL(this_req->out.vwv, VWV(4), align1 + PTR_DIFF(this_req->out.data, this_req->out.hdr));
1153 SSVAL(this_req->out.vwv, VWV(5), PTR_DIFF(params, trans->out.params.data));
1154
1155 SSVAL(this_req->out.vwv, VWV(6), this_data);
1156 SSVAL(this_req->out.vwv, VWV(7), align1 + align2 +
1157 PTR_DIFF(this_req->out.data + this_param, this_req->out.hdr));
1158 SSVAL(this_req->out.vwv, VWV(8), PTR_DIFF(data, trans->out.data.data));
1159
1160 SCVAL(this_req->out.vwv, VWV(9), trans->out.setup_count);
1161 SCVAL(this_req->out.vwv, VWV(9)+1, 0); /* reserved */
1162 for (i=0;i<trans->out.setup_count;i++) {
1163 SSVAL(this_req->out.vwv, VWV(10+i), trans->out.setup[i]);
1164 }
1165
1166 memset(this_req->out.data, 0, align1);
1167 if (this_param != 0) {
1168 memcpy(this_req->out.data + align1, params, this_param);
1169 }
1170 memset(this_req->out.data+this_param+align1, 0, align2);
1171 if (this_data != 0) {
1172 memcpy(this_req->out.data+this_param+align1+align2, data, this_data);
1173 }
1174
1175 params_left -= this_param;
1176 data_left -= this_data;
1177 params += this_param;
1178 data += this_data;
1179
1180 smbsrv_send_reply(this_req);
1181 } while (params_left != 0 || data_left != 0);
1182 }
1183
1184
1185 /*
1186 answer a reconstructed trans request
1187 */
1188 static void reply_trans_complete(struct smbsrv_request *req, uint8_t command,
1189 struct smb_trans2 *trans)
1190 {
1191 struct trans_op *op;
1192
1193 SMBSRV_TALLOC_IO_PTR(op, struct trans_op);
1194 SMBSRV_SETUP_NTVFS_REQUEST(reply_trans_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
1195
1196 op->req = req;
1197 op->trans = trans;
1198 op->command = command;
1199 op->op_info = NULL;
1200 op->send_fn = NULL;
1201
1202 /* its a full request, give it to the backend */
1203 if (command == SMBtrans) {
1204 SMBSRV_CALL_NTVFS_BACKEND(ntvfs_trans(req->ntvfs, trans));
1205 return;
1206 } else {
1207 SMBSRV_CALL_NTVFS_BACKEND(trans2_backend(req, op));
1208 return;
1209 }
1210 }
1211
1212 /*
1213 Reply to an SMBtrans or SMBtrans2 request
1214 */
1215 static void reply_trans_generic(struct smbsrv_request *req, uint8_t command)
1216 {
1217 struct smb_trans2 *trans;
1218 int i;
1219 uint16_t param_ofs, data_ofs;
1220 uint16_t param_count, data_count;
1221 uint16_t param_total, data_total;
1222
1223 /* parse request */
1224 if (req->in.wct < 14) {
1225 smbsrv_send_error(req, NT_STATUS_INVALID_PARAMETER);
1226 return;
1227 }
1228
1229 trans = talloc(req, struct smb_trans2);
1230 if (trans == NULL) {
1231 smbsrv_send_error(req, NT_STATUS_NO_MEMORY);
1232 return;
1233 }
1234
1235 param_total = SVAL(req->in.vwv, VWV(0));
1236 data_total = SVAL(req->in.vwv, VWV(1));
1237 trans->in.max_param = SVAL(req->in.vwv, VWV(2));
1238 trans->in.max_data = SVAL(req->in.vwv, VWV(3));
1239 trans->in.max_setup = CVAL(req->in.vwv, VWV(4));
1240 trans->in.flags = SVAL(req->in.vwv, VWV(5));
1241 trans->in.timeout = IVAL(req->in.vwv, VWV(6));
1242 param_count = SVAL(req->in.vwv, VWV(9));
1243 param_ofs = SVAL(req->in.vwv, VWV(10));
1244 data_count = SVAL(req->in.vwv, VWV(11));
1245 data_ofs = SVAL(req->in.vwv, VWV(12));
1246 trans->in.setup_count = CVAL(req->in.vwv, VWV(13));
1247
1248 if (req->in.wct != 14 + trans->in.setup_count) {
1249 smbsrv_send_error(req, NT_STATUS_DOS(ERRSRV, ERRerror));
1250 return;
1251 }
1252
1253 /* parse out the setup words */
1254 trans->in.setup = talloc_array(trans, uint16_t, trans->in.setup_count);
1255 if (trans->in.setup_count && !trans->in.setup) {
1256 smbsrv_send_error(req, NT_STATUS_NO_MEMORY);
1257 return;
1258 }
1259 for (i=0;i<trans->in.setup_count;i++) {
1260 trans->in.setup[i] = SVAL(req->in.vwv, VWV(14+i));
1261 }
1262
1263 if (command == SMBtrans) {
1264 req_pull_string(&req->in.bufinfo, &trans->in.trans_name, req->in.data, -1, STR_TERMINATE);
1265 }
1266
1267 if (!req_pull_blob(&req->in.bufinfo, req->in.hdr + param_ofs, param_count, &trans->in.params) ||
1268 !req_pull_blob(&req->in.bufinfo, req->in.hdr + data_ofs, data_count, &trans->in.data)) {
1269 smbsrv_send_error(req, NT_STATUS_FOOBAR);
1270 return;
1271 }
1272
1273 /* is it a partial request? if so, then send a 'send more' message */
1274 if (param_total > param_count || data_total > data_count) {
1275 reply_trans_continue(req, command, trans);
1276 return;
1277 }
1278
1279 reply_trans_complete(req, command, trans);
1280 }
1281
1282
1283 /*
1284 Reply to an SMBtranss2 request
1285 */
1286 static void reply_transs_generic(struct smbsrv_request *req, uint8_t command)
1287 {
1288 struct smbsrv_trans_partial *tp;
1289 struct smb_trans2 *trans = NULL;
1290 uint16_t param_ofs, data_ofs;
1291 uint16_t param_count, data_count;
1292 uint16_t param_disp, data_disp;
1293 uint16_t param_total, data_total;
1294 DATA_BLOB params, data;
1295 uint8_t wct;
1296
1297 if (command == SMBtrans2) {
1298 wct = 9;
1299 } else {
1300 wct = 8;
1301 }
1302
1303 /* parse request */
1304 if (req->in.wct != wct) {
1305 /*
1306 * TODO: add some error code tests
1307 * w2k3 returns NT_STATUS_DOS(ERRSRV, ERRerror) here
1308 */
1309 smbsrv_send_error(req, NT_STATUS_INVALID_PARAMETER);
1310 return;
1311 }
1312
1313 for (tp=req->smb_conn->trans_partial;tp;tp=tp->next) {
1314 if (tp->command == command &&
1315 SVAL(tp->req->in.hdr, HDR_MID) == SVAL(req->in.hdr, HDR_MID)) {
1316 /* TODO: check the VUID, PID and TID too? */
1317 break;
1318 }
1319 }
1320
1321 if (tp == NULL) {
1322 smbsrv_send_error(req, NT_STATUS_INVALID_PARAMETER);
1323 return;
1324 }
1325
1326 trans = tp->trans;
1327
1328 param_total = SVAL(req->in.vwv, VWV(0));
1329 data_total = SVAL(req->in.vwv, VWV(1));
1330 param_count = SVAL(req->in.vwv, VWV(2));
1331 param_ofs = SVAL(req->in.vwv, VWV(3));
1332 param_disp = SVAL(req->in.vwv, VWV(4));
1333 data_count = SVAL(req->in.vwv, VWV(5));
1334 data_ofs = SVAL(req->in.vwv, VWV(6));
1335 data_disp = SVAL(req->in.vwv, VWV(7));
1336
1337 if (!req_pull_blob(&req->in.bufinfo, req->in.hdr + param_ofs, param_count, &params) ||
1338 !req_pull_blob(&req->in.bufinfo, req->in.hdr + data_ofs, data_count, &data)) {
1339 smbsrv_send_error(req, NT_STATUS_INVALID_PARAMETER);
1340 return;
1341 }
1342
1343 /* only allow contiguous requests */
1344 if ((param_count != 0 &&
1345 param_disp != trans->in.params.length) ||
1346 (data_count != 0 &&
1347 data_disp != trans->in.data.length)) {
1348 smbsrv_send_error(req, NT_STATUS_INVALID_PARAMETER);
1349 return;
1350 }
1351
1352 /* add to the existing request */
1353 if (param_count != 0) {
1354 trans->in.params.data = talloc_realloc(trans,
1355 trans->in.params.data,
1356 uint8_t,
1357 param_disp + param_count);
1358 if (trans->in.params.data == NULL) {
1359 smbsrv_send_error(tp->req, NT_STATUS_NO_MEMORY);
1360 return;
1361 }
1362 trans->in.params.length = param_disp + param_count;
1363 }
1364
1365 if (data_count != 0) {
1366 trans->in.data.data = talloc_realloc(trans,
1367 trans->in.data.data,
1368 uint8_t,
1369 data_disp + data_count);
1370 if (trans->in.data.data == NULL) {
1371 smbsrv_send_error(tp->req, NT_STATUS_NO_MEMORY);
1372 return;
1373 }
1374 trans->in.data.length = data_disp + data_count;
1375 }
1376
1377 memcpy(trans->in.params.data + param_disp, params.data, params.length);
1378 memcpy(trans->in.data.data + data_disp, data.data, data.length);
1379
1380 /* the sequence number of the reply is taken from the last secondary
1381 response */
1382 tp->req->seq_num = req->seq_num;
1383
1384 /* we don't reply to Transs2 requests */
1385 talloc_free(req);
1386
1387 if (trans->in.params.length == param_total &&
1388 trans->in.data.length == data_total) {
1389 /* its now complete */
1390 req = tp->req;
1391 talloc_free(tp);
1392 reply_trans_complete(req, command, trans);
1393 }
1394 return;
1395 }
1396
1397
1398 /*
1399 Reply to an SMBtrans2
1400 */
1401 void smbsrv_reply_trans2(struct smbsrv_request *req)
1402 {
1403 reply_trans_generic(req, SMBtrans2);
1404 }
1405
1406 /*
1407 Reply to an SMBtrans
1408 */
1409 void smbsrv_reply_trans(struct smbsrv_request *req)
1410 {
1411 reply_trans_generic(req, SMBtrans);
1412 }
1413
1414 /*
1415 Reply to an SMBtranss request
1416 */
1417 void smbsrv_reply_transs(struct smbsrv_request *req)
1418 {
1419 reply_transs_generic(req, SMBtrans);
1420 }
1421
1422 /*
1423 Reply to an SMBtranss2 request
1424 */
1425 void smbsrv_reply_transs2(struct smbsrv_request *req)
1426 {
1427 reply_transs_generic(req, SMBtrans2);
1428 }