source: branches/samba-3.5.x/source4/smb_server/smb/trans2.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 15 years ago

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