source: vendor/3.6.0/source4/libcli/raw/rawfile.c

Last change on this file was 740, checked in by Silvan Scherrer, 13 years ago

Samba Server: update vendor to 3.6.0
File size: 37.1 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 client file operations
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Jeremy Allison 2001-2002
6 Copyright (C) James Myers 2003
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20*/
21
22#include "includes.h"
23#include "libcli/raw/libcliraw.h"
24#include "libcli/raw/raw_proto.h"
25#include "librpc/gen_ndr/ndr_security.h"
26
27#define SETUP_REQUEST(cmd, wct, buflen) do { \
28 req = smbcli_request_setup(tree, cmd, wct, buflen); \
29 if (!req) return NULL; \
30} while (0)
31
32/**
33 Return a string representing a CIFS attribute for a file.
34**/
35char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
36{
37 int i, len;
38 const struct {
39 char c;
40 uint16_t attr;
41 } attr_strs[] = {
42 {'V', FILE_ATTRIBUTE_VOLUME},
43 {'D', FILE_ATTRIBUTE_DIRECTORY},
44 {'A', FILE_ATTRIBUTE_ARCHIVE},
45 {'H', FILE_ATTRIBUTE_HIDDEN},
46 {'S', FILE_ATTRIBUTE_SYSTEM},
47 {'N', FILE_ATTRIBUTE_NORMAL},
48 {'R', FILE_ATTRIBUTE_READONLY},
49 {'d', FILE_ATTRIBUTE_DEVICE},
50 {'t', FILE_ATTRIBUTE_TEMPORARY},
51 {'s', FILE_ATTRIBUTE_SPARSE},
52 {'r', FILE_ATTRIBUTE_REPARSE_POINT},
53 {'c', FILE_ATTRIBUTE_COMPRESSED},
54 {'o', FILE_ATTRIBUTE_OFFLINE},
55 {'n', FILE_ATTRIBUTE_NONINDEXED},
56 {'e', FILE_ATTRIBUTE_ENCRYPTED}
57 };
58 char *ret;
59
60 ret = talloc_array(mem_ctx, char, ARRAY_SIZE(attr_strs)+1);
61 if (!ret) {
62 return NULL;
63 }
64
65 for (len=i=0; i<ARRAY_SIZE(attr_strs); i++) {
66 if (attrib & attr_strs[i].attr) {
67 ret[len++] = attr_strs[i].c;
68 }
69 }
70
71 ret[len] = 0;
72
73 talloc_set_name_const(ret, ret);
74
75 return ret;
76}
77
78/****************************************************************************
79 Rename a file - async interface
80****************************************************************************/
81struct smbcli_request *smb_raw_rename_send(struct smbcli_tree *tree,
82 union smb_rename *parms)
83{
84 struct smbcli_request *req = NULL;
85 struct smb_nttrans nt;
86 TALLOC_CTX *mem_ctx;
87
88 switch (parms->generic.level) {
89 case RAW_RENAME_RENAME:
90 SETUP_REQUEST(SMBmv, 1, 0);
91 SSVAL(req->out.vwv, VWV(0), parms->rename.in.attrib);
92 smbcli_req_append_ascii4(req, parms->rename.in.pattern1, STR_TERMINATE);
93 smbcli_req_append_ascii4(req, parms->rename.in.pattern2, STR_TERMINATE);
94 break;
95
96 case RAW_RENAME_NTRENAME:
97 SETUP_REQUEST(SMBntrename, 4, 0);
98 SSVAL(req->out.vwv, VWV(0), parms->ntrename.in.attrib);
99 SSVAL(req->out.vwv, VWV(1), parms->ntrename.in.flags);
100 SIVAL(req->out.vwv, VWV(2), parms->ntrename.in.cluster_size);
101 smbcli_req_append_ascii4(req, parms->ntrename.in.old_name, STR_TERMINATE);
102 smbcli_req_append_ascii4(req, parms->ntrename.in.new_name, STR_TERMINATE);
103 break;
104
105 case RAW_RENAME_NTTRANS:
106
107 mem_ctx = talloc_new(tree);
108
109 nt.in.max_setup = 0;
110 nt.in.max_param = 0;
111 nt.in.max_data = 0;
112 nt.in.setup_count = 0;
113 nt.in.setup = NULL;
114 nt.in.function = NT_TRANSACT_RENAME;
115 nt.in.params = data_blob_talloc(mem_ctx, NULL, 4);
116 nt.in.data = data_blob(NULL, 0);
117
118 SSVAL(nt.in.params.data, VWV(0), parms->nttrans.in.file.fnum);
119 SSVAL(nt.in.params.data, VWV(1), parms->nttrans.in.flags);
120
121 smbcli_blob_append_string(tree->session, mem_ctx,
122 &nt.in.params, parms->nttrans.in.new_name,
123 STR_TERMINATE);
124
125 req = smb_raw_nttrans_send(tree, &nt);
126 talloc_free(mem_ctx);
127 return req;
128 }
129
130 if (!smbcli_request_send(req)) {
131 smbcli_request_destroy(req);
132 return NULL;
133 }
134
135 return req;
136}
137
138/****************************************************************************
139 Rename a file - sync interface
140****************************************************************************/
141_PUBLIC_ NTSTATUS smb_raw_rename(struct smbcli_tree *tree,
142 union smb_rename *parms)
143{
144 struct smbcli_request *req = smb_raw_rename_send(tree, parms);
145 return smbcli_request_simple_recv(req);
146}
147
148
149/****************************************************************************
150 Delete a file - async interface
151****************************************************************************/
152struct smbcli_request *smb_raw_unlink_send(struct smbcli_tree *tree,
153 union smb_unlink *parms)
154{
155 struct smbcli_request *req;
156
157 SETUP_REQUEST(SMBunlink, 1, 0);
158
159 SSVAL(req->out.vwv, VWV(0), parms->unlink.in.attrib);
160 smbcli_req_append_ascii4(req, parms->unlink.in.pattern, STR_TERMINATE);
161
162 if (!smbcli_request_send(req)) {
163 smbcli_request_destroy(req);
164 return NULL;
165 }
166 return req;
167}
168
169/*
170 delete a file - sync interface
171*/
172_PUBLIC_ NTSTATUS smb_raw_unlink(struct smbcli_tree *tree,
173 union smb_unlink *parms)
174{
175 struct smbcli_request *req = smb_raw_unlink_send(tree, parms);
176 return smbcli_request_simple_recv(req);
177}
178
179
180/****************************************************************************
181 create a directory using TRANSACT2_MKDIR - async interface
182****************************************************************************/
183static struct smbcli_request *smb_raw_t2mkdir_send(struct smbcli_tree *tree,
184 union smb_mkdir *parms)
185{
186 struct smb_trans2 t2;
187 uint16_t setup = TRANSACT2_MKDIR;
188 TALLOC_CTX *mem_ctx;
189 struct smbcli_request *req;
190 uint16_t data_total;
191
192 mem_ctx = talloc_init("t2mkdir");
193
194 data_total = ea_list_size(parms->t2mkdir.in.num_eas, parms->t2mkdir.in.eas);
195
196 t2.in.max_param = 2;
197 t2.in.max_data = 0;
198 t2.in.max_setup = 0;
199 t2.in.flags = 0;
200 t2.in.timeout = 0;
201 t2.in.setup_count = 1;
202 t2.in.setup = &setup;
203 t2.in.params = data_blob_talloc(mem_ctx, NULL, 4);
204 t2.in.data = data_blob_talloc(mem_ctx, NULL, data_total);
205
206 SIVAL(t2.in.params.data, VWV(0), 0); /* reserved */
207
208 smbcli_blob_append_string(tree->session, mem_ctx,
209 &t2.in.params, parms->t2mkdir.in.path, STR_TERMINATE);
210
211 ea_put_list(t2.in.data.data, parms->t2mkdir.in.num_eas, parms->t2mkdir.in.eas);
212
213 req = smb_raw_trans2_send(tree, &t2);
214
215 talloc_free(mem_ctx);
216
217 return req;
218}
219
220/****************************************************************************
221 Create a directory - async interface
222****************************************************************************/
223struct smbcli_request *smb_raw_mkdir_send(struct smbcli_tree *tree,
224 union smb_mkdir *parms)
225{
226 struct smbcli_request *req;
227
228 if (parms->generic.level == RAW_MKDIR_T2MKDIR) {
229 return smb_raw_t2mkdir_send(tree, parms);
230 }
231
232 if (parms->generic.level != RAW_MKDIR_MKDIR) {
233 return NULL;
234 }
235
236 SETUP_REQUEST(SMBmkdir, 0, 0);
237
238 smbcli_req_append_ascii4(req, parms->mkdir.in.path, STR_TERMINATE);
239
240 if (!smbcli_request_send(req)) {
241 return NULL;
242 }
243
244 return req;
245}
246
247/****************************************************************************
248 Create a directory - sync interface
249****************************************************************************/
250_PUBLIC_ NTSTATUS smb_raw_mkdir(struct smbcli_tree *tree,
251 union smb_mkdir *parms)
252{
253 struct smbcli_request *req = smb_raw_mkdir_send(tree, parms);
254 return smbcli_request_simple_recv(req);
255}
256
257/****************************************************************************
258 Remove a directory - async interface
259****************************************************************************/
260struct smbcli_request *smb_raw_rmdir_send(struct smbcli_tree *tree,
261 struct smb_rmdir *parms)
262{
263 struct smbcli_request *req;
264
265 SETUP_REQUEST(SMBrmdir, 0, 0);
266
267 smbcli_req_append_ascii4(req, parms->in.path, STR_TERMINATE);
268
269 if (!smbcli_request_send(req)) {
270 smbcli_request_destroy(req);
271 return NULL;
272 }
273
274 return req;
275}
276
277/****************************************************************************
278 Remove a directory - sync interface
279****************************************************************************/
280_PUBLIC_ NTSTATUS smb_raw_rmdir(struct smbcli_tree *tree,
281 struct smb_rmdir *parms)
282{
283 struct smbcli_request *req = smb_raw_rmdir_send(tree, parms);
284 return smbcli_request_simple_recv(req);
285}
286
287
288/*
289 Open a file using TRANSACT2_OPEN - async recv
290*/
291static NTSTATUS smb_raw_nttrans_create_recv(struct smbcli_request *req,
292 TALLOC_CTX *mem_ctx,
293 union smb_open *parms)
294{
295 NTSTATUS status;
296 struct smb_nttrans nt;
297 uint8_t *params;
298
299 status = smb_raw_nttrans_recv(req, mem_ctx, &nt);
300 if (!NT_STATUS_IS_OK(status)) return status;
301
302 if (nt.out.params.length < 69) {
303 return NT_STATUS_INVALID_PARAMETER;
304 }
305
306 params = nt.out.params.data;
307
308 parms->ntcreatex.out.oplock_level = CVAL(params, 0);
309 parms->ntcreatex.out.file.fnum = SVAL(params, 2);
310 parms->ntcreatex.out.create_action = IVAL(params, 4);
311 parms->ntcreatex.out.create_time = smbcli_pull_nttime(params, 12);
312 parms->ntcreatex.out.access_time = smbcli_pull_nttime(params, 20);
313 parms->ntcreatex.out.write_time = smbcli_pull_nttime(params, 28);
314 parms->ntcreatex.out.change_time = smbcli_pull_nttime(params, 36);
315 parms->ntcreatex.out.attrib = IVAL(params, 44);
316 parms->ntcreatex.out.alloc_size = BVAL(params, 48);
317 parms->ntcreatex.out.size = BVAL(params, 56);
318 parms->ntcreatex.out.file_type = SVAL(params, 64);
319 parms->ntcreatex.out.ipc_state = SVAL(params, 66);
320 parms->ntcreatex.out.is_directory = CVAL(params, 68);
321
322 return NT_STATUS_OK;
323}
324
325
326/*
327 Open a file using NTTRANS CREATE - async send
328*/
329static struct smbcli_request *smb_raw_nttrans_create_send(struct smbcli_tree *tree,
330 union smb_open *parms)
331{
332 struct smb_nttrans nt;
333 uint8_t *params;
334 TALLOC_CTX *mem_ctx = talloc_new(tree);
335 uint16_t fname_len;
336 DATA_BLOB sd_blob, ea_blob;
337 struct smbcli_request *req;
338
339 nt.in.max_setup = 0;
340 nt.in.max_param = 101;
341 nt.in.max_data = 0;
342 nt.in.setup_count = 0;
343 nt.in.function = NT_TRANSACT_CREATE;
344 nt.in.setup = NULL;
345
346 sd_blob = data_blob(NULL, 0);
347 ea_blob = data_blob(NULL, 0);
348
349 if (parms->ntcreatex.in.sec_desc) {
350 enum ndr_err_code ndr_err;
351 ndr_err = ndr_push_struct_blob(&sd_blob, mem_ctx,
352 parms->ntcreatex.in.sec_desc,
353 (ndr_push_flags_fn_t)ndr_push_security_descriptor);
354 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
355 talloc_free(mem_ctx);
356 return NULL;
357 }
358 }
359
360 if (parms->ntcreatex.in.ea_list) {
361 uint32_t ea_size = ea_list_size_chained(parms->ntcreatex.in.ea_list->num_eas,
362 parms->ntcreatex.in.ea_list->eas, 4);
363 ea_blob = data_blob_talloc(mem_ctx, NULL, ea_size);
364 if (ea_blob.data == NULL) {
365 return NULL;
366 }
367 ea_put_list_chained(ea_blob.data,
368 parms->ntcreatex.in.ea_list->num_eas,
369 parms->ntcreatex.in.ea_list->eas, 4);
370 }
371
372 nt.in.params = data_blob_talloc(mem_ctx, NULL, 53);
373 if (nt.in.params.data == NULL) {
374 talloc_free(mem_ctx);
375 return NULL;
376 }
377
378 /* build the parameter section */
379 params = nt.in.params.data;
380
381 SIVAL(params, 0, parms->ntcreatex.in.flags);
382 SIVAL(params, 4, parms->ntcreatex.in.root_fid.fnum);
383 SIVAL(params, 8, parms->ntcreatex.in.access_mask);
384 SBVAL(params, 12, parms->ntcreatex.in.alloc_size);
385 SIVAL(params, 20, parms->ntcreatex.in.file_attr);
386 SIVAL(params, 24, parms->ntcreatex.in.share_access);
387 SIVAL(params, 28, parms->ntcreatex.in.open_disposition);
388 SIVAL(params, 32, parms->ntcreatex.in.create_options);
389 SIVAL(params, 36, sd_blob.length);
390 SIVAL(params, 40, ea_blob.length);
391 SIVAL(params, 48, parms->ntcreatex.in.impersonation);
392 SCVAL(params, 52, parms->ntcreatex.in.security_flags);
393
394 /* the empty string first forces the correct alignment */
395 smbcli_blob_append_string(tree->session, mem_ctx, &nt.in.params,"", 0);
396 fname_len = smbcli_blob_append_string(tree->session, mem_ctx, &nt.in.params,
397 parms->ntcreatex.in.fname, STR_TERMINATE);
398
399 SIVAL(nt.in.params.data, 44, fname_len);
400
401 /* build the data section */
402 nt.in.data = data_blob_talloc(mem_ctx, NULL, sd_blob.length + ea_blob.length);
403 memcpy(nt.in.data.data, sd_blob.data, sd_blob.length);
404 memcpy(nt.in.data.data+sd_blob.length, ea_blob.data, ea_blob.length);
405
406 /* send the request on its way */
407 req = smb_raw_nttrans_send(tree, &nt);
408
409 talloc_free(mem_ctx);
410
411 return req;
412}
413
414
415/****************************************************************************
416 Open a file using TRANSACT2_OPEN - async send
417****************************************************************************/
418static struct smbcli_request *smb_raw_t2open_send(struct smbcli_tree *tree,
419 union smb_open *parms)
420{
421 struct smb_trans2 t2;
422 uint16_t setup = TRANSACT2_OPEN;
423 TALLOC_CTX *mem_ctx = talloc_init("smb_raw_t2open");
424 struct smbcli_request *req;
425 uint16_t list_size;
426
427 list_size = ea_list_size(parms->t2open.in.num_eas, parms->t2open.in.eas);
428
429 t2.in.max_param = 30;
430 t2.in.max_data = 0;
431 t2.in.max_setup = 0;
432 t2.in.flags = 0;
433 t2.in.timeout = 0;
434 t2.in.setup_count = 1;
435 t2.in.setup = &setup;
436 t2.in.params = data_blob_talloc(mem_ctx, NULL, 28);
437 t2.in.data = data_blob_talloc(mem_ctx, NULL, list_size);
438
439 SSVAL(t2.in.params.data, VWV(0), parms->t2open.in.flags);
440 SSVAL(t2.in.params.data, VWV(1), parms->t2open.in.open_mode);
441 SSVAL(t2.in.params.data, VWV(2), parms->t2open.in.search_attrs);
442 SSVAL(t2.in.params.data, VWV(3), parms->t2open.in.file_attrs);
443 raw_push_dos_date(tree->session->transport,
444 t2.in.params.data, VWV(4), parms->t2open.in.write_time);
445 SSVAL(t2.in.params.data, VWV(6), parms->t2open.in.open_func);
446 SIVAL(t2.in.params.data, VWV(7), parms->t2open.in.size);
447 SIVAL(t2.in.params.data, VWV(9), parms->t2open.in.timeout);
448 SIVAL(t2.in.params.data, VWV(11), 0);
449 SSVAL(t2.in.params.data, VWV(13), 0);
450
451 smbcli_blob_append_string(tree->session, mem_ctx,
452 &t2.in.params, parms->t2open.in.fname,
453 STR_TERMINATE);
454
455 ea_put_list(t2.in.data.data, parms->t2open.in.num_eas, parms->t2open.in.eas);
456
457 req = smb_raw_trans2_send(tree, &t2);
458
459 talloc_free(mem_ctx);
460
461 return req;
462}
463
464
465/****************************************************************************
466 Open a file using TRANSACT2_OPEN - async recv
467****************************************************************************/
468static NTSTATUS smb_raw_t2open_recv(struct smbcli_request *req, TALLOC_CTX *mem_ctx, union smb_open *parms)
469{
470 struct smbcli_transport *transport = req->transport;
471 struct smb_trans2 t2;
472 NTSTATUS status;
473
474 status = smb_raw_trans2_recv(req, mem_ctx, &t2);
475 if (!NT_STATUS_IS_OK(status)) return status;
476
477 if (t2.out.params.length < 30) {
478 return NT_STATUS_INFO_LENGTH_MISMATCH;
479 }
480
481 parms->t2open.out.file.fnum = SVAL(t2.out.params.data, VWV(0));
482 parms->t2open.out.attrib = SVAL(t2.out.params.data, VWV(1));
483 parms->t2open.out.write_time = raw_pull_dos_date3(transport, t2.out.params.data + VWV(2));
484 parms->t2open.out.size = IVAL(t2.out.params.data, VWV(4));
485 parms->t2open.out.access = SVAL(t2.out.params.data, VWV(6));
486 parms->t2open.out.ftype = SVAL(t2.out.params.data, VWV(7));
487 parms->t2open.out.devstate = SVAL(t2.out.params.data, VWV(8));
488 parms->t2open.out.action = SVAL(t2.out.params.data, VWV(9));
489 parms->t2open.out.file_id = SVAL(t2.out.params.data, VWV(10));
490
491 return NT_STATUS_OK;
492}
493
494/****************************************************************************
495 Open a file - async send
496****************************************************************************/
497_PUBLIC_ struct smbcli_request *smb_raw_open_send(struct smbcli_tree *tree, union smb_open *parms)
498{
499 int len;
500 struct smbcli_request *req = NULL;
501 bool bigoffset = false;
502
503 switch (parms->generic.level) {
504 case RAW_OPEN_T2OPEN:
505 return smb_raw_t2open_send(tree, parms);
506
507 case RAW_OPEN_OPEN:
508 SETUP_REQUEST(SMBopen, 2, 0);
509 SSVAL(req->out.vwv, VWV(0), parms->openold.in.open_mode);
510 SSVAL(req->out.vwv, VWV(1), parms->openold.in.search_attrs);
511 smbcli_req_append_ascii4(req, parms->openold.in.fname, STR_TERMINATE);
512 break;
513
514 case RAW_OPEN_OPENX:
515 SETUP_REQUEST(SMBopenX, 15, 0);
516 SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
517 SSVAL(req->out.vwv, VWV(1), 0);
518 SSVAL(req->out.vwv, VWV(2), parms->openx.in.flags);
519 SSVAL(req->out.vwv, VWV(3), parms->openx.in.open_mode);
520 SSVAL(req->out.vwv, VWV(4), parms->openx.in.search_attrs);
521 SSVAL(req->out.vwv, VWV(5), parms->openx.in.file_attrs);
522 raw_push_dos_date3(tree->session->transport,
523 req->out.vwv, VWV(6), parms->openx.in.write_time);
524 SSVAL(req->out.vwv, VWV(8), parms->openx.in.open_func);
525 SIVAL(req->out.vwv, VWV(9), parms->openx.in.size);
526 SIVAL(req->out.vwv, VWV(11),parms->openx.in.timeout);
527 SIVAL(req->out.vwv, VWV(13),0); /* reserved */
528 smbcli_req_append_string(req, parms->openx.in.fname, STR_TERMINATE);
529 break;
530
531 case RAW_OPEN_MKNEW:
532 SETUP_REQUEST(SMBmknew, 3, 0);
533 SSVAL(req->out.vwv, VWV(0), parms->mknew.in.attrib);
534 raw_push_dos_date3(tree->session->transport,
535 req->out.vwv, VWV(1), parms->mknew.in.write_time);
536 smbcli_req_append_ascii4(req, parms->mknew.in.fname, STR_TERMINATE);
537 break;
538
539 case RAW_OPEN_CREATE:
540 SETUP_REQUEST(SMBcreate, 3, 0);
541 SSVAL(req->out.vwv, VWV(0), parms->create.in.attrib);
542 raw_push_dos_date3(tree->session->transport,
543 req->out.vwv, VWV(1), parms->create.in.write_time);
544 smbcli_req_append_ascii4(req, parms->create.in.fname, STR_TERMINATE);
545 break;
546
547 case RAW_OPEN_CTEMP:
548 SETUP_REQUEST(SMBctemp, 3, 0);
549 SSVAL(req->out.vwv, VWV(0), parms->ctemp.in.attrib);
550 raw_push_dos_date3(tree->session->transport,
551 req->out.vwv, VWV(1), parms->ctemp.in.write_time);
552 smbcli_req_append_ascii4(req, parms->ctemp.in.directory, STR_TERMINATE);
553 break;
554
555 case RAW_OPEN_SPLOPEN:
556 SETUP_REQUEST(SMBsplopen, 2, 0);
557 SSVAL(req->out.vwv, VWV(0), parms->splopen.in.setup_length);
558 SSVAL(req->out.vwv, VWV(1), parms->splopen.in.mode);
559 break;
560
561 case RAW_OPEN_NTCREATEX:
562 SETUP_REQUEST(SMBntcreateX, 24, 0);
563 SSVAL(req->out.vwv, VWV(0),SMB_CHAIN_NONE);
564 SSVAL(req->out.vwv, VWV(1),0);
565 SCVAL(req->out.vwv, VWV(2),0); /* padding */
566 SIVAL(req->out.vwv, 7, parms->ntcreatex.in.flags);
567 SIVAL(req->out.vwv, 11, parms->ntcreatex.in.root_fid.fnum);
568 SIVAL(req->out.vwv, 15, parms->ntcreatex.in.access_mask);
569 SBVAL(req->out.vwv, 19, parms->ntcreatex.in.alloc_size);
570 SIVAL(req->out.vwv, 27, parms->ntcreatex.in.file_attr);
571 SIVAL(req->out.vwv, 31, parms->ntcreatex.in.share_access);
572 SIVAL(req->out.vwv, 35, parms->ntcreatex.in.open_disposition);
573 SIVAL(req->out.vwv, 39, parms->ntcreatex.in.create_options);
574 SIVAL(req->out.vwv, 43, parms->ntcreatex.in.impersonation);
575 SCVAL(req->out.vwv, 47, parms->ntcreatex.in.security_flags);
576
577 smbcli_req_append_string_len(req, parms->ntcreatex.in.fname, STR_TERMINATE, &len);
578 SSVAL(req->out.vwv, 5, len);
579 break;
580
581 case RAW_OPEN_NTTRANS_CREATE:
582 return smb_raw_nttrans_create_send(tree, parms);
583
584
585 case RAW_OPEN_OPENX_READX:
586 SETUP_REQUEST(SMBopenX, 15, 0);
587 SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
588 SSVAL(req->out.vwv, VWV(1), 0);
589 SSVAL(req->out.vwv, VWV(2), parms->openxreadx.in.flags);
590 SSVAL(req->out.vwv, VWV(3), parms->openxreadx.in.open_mode);
591 SSVAL(req->out.vwv, VWV(4), parms->openxreadx.in.search_attrs);
592 SSVAL(req->out.vwv, VWV(5), parms->openxreadx.in.file_attrs);
593 raw_push_dos_date3(tree->session->transport,
594 req->out.vwv, VWV(6), parms->openxreadx.in.write_time);
595 SSVAL(req->out.vwv, VWV(8), parms->openxreadx.in.open_func);
596 SIVAL(req->out.vwv, VWV(9), parms->openxreadx.in.size);
597 SIVAL(req->out.vwv, VWV(11),parms->openxreadx.in.timeout);
598 SIVAL(req->out.vwv, VWV(13),0);
599 smbcli_req_append_string(req, parms->openxreadx.in.fname, STR_TERMINATE);
600
601 if (tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES) {
602 bigoffset = true;
603 }
604
605 smbcli_chained_request_setup(req, SMBreadX, bigoffset ? 12 : 10, 0);
606
607 SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
608 SSVAL(req->out.vwv, VWV(1), 0);
609 SSVAL(req->out.vwv, VWV(2), 0);
610 SIVAL(req->out.vwv, VWV(3), parms->openxreadx.in.offset);
611 SSVAL(req->out.vwv, VWV(5), parms->openxreadx.in.maxcnt & 0xFFFF);
612 SSVAL(req->out.vwv, VWV(6), parms->openxreadx.in.mincnt);
613 SIVAL(req->out.vwv, VWV(7), parms->openxreadx.in.maxcnt >> 16);
614 SSVAL(req->out.vwv, VWV(9), parms->openxreadx.in.remaining);
615 if (bigoffset) {
616 SIVAL(req->out.vwv, VWV(10),parms->openxreadx.in.offset>>32);
617 }
618 break;
619
620 case RAW_OPEN_NTCREATEX_READX:
621 SETUP_REQUEST(SMBntcreateX, 24, 0);
622 SSVAL(req->out.vwv, VWV(0),SMB_CHAIN_NONE);
623 SSVAL(req->out.vwv, VWV(1),0);
624 SCVAL(req->out.vwv, VWV(2),0); /* padding */
625 SIVAL(req->out.vwv, 7, parms->ntcreatexreadx.in.flags);
626 SIVAL(req->out.vwv, 11, parms->ntcreatexreadx.in.root_fid.fnum);
627 SIVAL(req->out.vwv, 15, parms->ntcreatexreadx.in.access_mask);
628 SBVAL(req->out.vwv, 19, parms->ntcreatexreadx.in.alloc_size);
629 SIVAL(req->out.vwv, 27, parms->ntcreatexreadx.in.file_attr);
630 SIVAL(req->out.vwv, 31, parms->ntcreatexreadx.in.share_access);
631 SIVAL(req->out.vwv, 35, parms->ntcreatexreadx.in.open_disposition);
632 SIVAL(req->out.vwv, 39, parms->ntcreatexreadx.in.create_options);
633 SIVAL(req->out.vwv, 43, parms->ntcreatexreadx.in.impersonation);
634 SCVAL(req->out.vwv, 47, parms->ntcreatexreadx.in.security_flags);
635
636 smbcli_req_append_string_len(req, parms->ntcreatexreadx.in.fname, STR_TERMINATE, &len);
637 SSVAL(req->out.vwv, 5, len);
638
639 if (tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES) {
640 bigoffset = true;
641 }
642
643 smbcli_chained_request_setup(req, SMBreadX, bigoffset ? 12 : 10, 0);
644
645 SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
646 SSVAL(req->out.vwv, VWV(1), 0);
647 SSVAL(req->out.vwv, VWV(2), 0);
648 SIVAL(req->out.vwv, VWV(3), parms->ntcreatexreadx.in.offset);
649 SSVAL(req->out.vwv, VWV(5), parms->ntcreatexreadx.in.maxcnt & 0xFFFF);
650 SSVAL(req->out.vwv, VWV(6), parms->ntcreatexreadx.in.mincnt);
651 SIVAL(req->out.vwv, VWV(7), parms->ntcreatexreadx.in.maxcnt >> 16);
652 SSVAL(req->out.vwv, VWV(9), parms->ntcreatexreadx.in.remaining);
653 if (bigoffset) {
654 SIVAL(req->out.vwv, VWV(10),parms->ntcreatexreadx.in.offset>>32);
655 }
656 break;
657
658 case RAW_OPEN_SMB2:
659 return NULL;
660 }
661
662 if (!smbcli_request_send(req)) {
663 smbcli_request_destroy(req);
664 return NULL;
665 }
666
667 return req;
668}
669
670/****************************************************************************
671 Open a file - async recv
672****************************************************************************/
673_PUBLIC_ NTSTATUS smb_raw_open_recv(struct smbcli_request *req, TALLOC_CTX *mem_ctx, union smb_open *parms)
674{
675 NTSTATUS status;
676
677 if (!smbcli_request_receive(req) ||
678 smbcli_request_is_error(req)) {
679 goto failed;
680 }
681
682 switch (parms->openold.level) {
683 case RAW_OPEN_T2OPEN:
684 return smb_raw_t2open_recv(req, mem_ctx, parms);
685
686 case RAW_OPEN_OPEN:
687 SMBCLI_CHECK_WCT(req, 7);
688 parms->openold.out.file.fnum = SVAL(req->in.vwv, VWV(0));
689 parms->openold.out.attrib = SVAL(req->in.vwv, VWV(1));
690 parms->openold.out.write_time = raw_pull_dos_date3(req->transport,
691 req->in.vwv + VWV(2));
692 parms->openold.out.size = IVAL(req->in.vwv, VWV(4));
693 parms->openold.out.rmode = SVAL(req->in.vwv, VWV(6));
694 break;
695
696 case RAW_OPEN_OPENX:
697 SMBCLI_CHECK_MIN_WCT(req, 15);
698 parms->openx.out.file.fnum = SVAL(req->in.vwv, VWV(2));
699 parms->openx.out.attrib = SVAL(req->in.vwv, VWV(3));
700 parms->openx.out.write_time = raw_pull_dos_date3(req->transport,
701 req->in.vwv + VWV(4));
702 parms->openx.out.size = IVAL(req->in.vwv, VWV(6));
703 parms->openx.out.access = SVAL(req->in.vwv, VWV(8));
704 parms->openx.out.ftype = SVAL(req->in.vwv, VWV(9));
705 parms->openx.out.devstate = SVAL(req->in.vwv, VWV(10));
706 parms->openx.out.action = SVAL(req->in.vwv, VWV(11));
707 parms->openx.out.unique_fid = IVAL(req->in.vwv, VWV(12));
708 if (req->in.wct >= 19) {
709 parms->openx.out.access_mask = IVAL(req->in.vwv, VWV(15));
710 parms->openx.out.unknown = IVAL(req->in.vwv, VWV(17));
711 } else {
712 parms->openx.out.access_mask = 0;
713 parms->openx.out.unknown = 0;
714 }
715 break;
716
717 case RAW_OPEN_MKNEW:
718 SMBCLI_CHECK_WCT(req, 1);
719 parms->mknew.out.file.fnum = SVAL(req->in.vwv, VWV(0));
720 break;
721
722 case RAW_OPEN_CREATE:
723 SMBCLI_CHECK_WCT(req, 1);
724 parms->create.out.file.fnum = SVAL(req->in.vwv, VWV(0));
725 break;
726
727 case RAW_OPEN_CTEMP:
728 SMBCLI_CHECK_WCT(req, 1);
729 parms->ctemp.out.file.fnum = SVAL(req->in.vwv, VWV(0));
730 smbcli_req_pull_string(&req->in.bufinfo, mem_ctx, &parms->ctemp.out.name, req->in.data, -1, STR_TERMINATE | STR_ASCII);
731 break;
732
733 case RAW_OPEN_SPLOPEN:
734 SMBCLI_CHECK_WCT(req, 1);
735 parms->splopen.out.file.fnum = SVAL(req->in.vwv, VWV(0));
736 break;
737
738 case RAW_OPEN_NTCREATEX:
739 SMBCLI_CHECK_MIN_WCT(req, 34);
740 parms->ntcreatex.out.oplock_level = CVAL(req->in.vwv, 4);
741 parms->ntcreatex.out.file.fnum = SVAL(req->in.vwv, 5);
742 parms->ntcreatex.out.create_action = IVAL(req->in.vwv, 7);
743 parms->ntcreatex.out.create_time = smbcli_pull_nttime(req->in.vwv, 11);
744 parms->ntcreatex.out.access_time = smbcli_pull_nttime(req->in.vwv, 19);
745 parms->ntcreatex.out.write_time = smbcli_pull_nttime(req->in.vwv, 27);
746 parms->ntcreatex.out.change_time = smbcli_pull_nttime(req->in.vwv, 35);
747 parms->ntcreatex.out.attrib = IVAL(req->in.vwv, 43);
748 parms->ntcreatex.out.alloc_size = BVAL(req->in.vwv, 47);
749 parms->ntcreatex.out.size = BVAL(req->in.vwv, 55);
750 parms->ntcreatex.out.file_type = SVAL(req->in.vwv, 63);
751 parms->ntcreatex.out.ipc_state = SVAL(req->in.vwv, 65);
752 parms->ntcreatex.out.is_directory = CVAL(req->in.vwv, 67);
753 break;
754
755 case RAW_OPEN_NTTRANS_CREATE:
756 return smb_raw_nttrans_create_recv(req, mem_ctx, parms);
757
758 case RAW_OPEN_OPENX_READX:
759 SMBCLI_CHECK_MIN_WCT(req, 15);
760 parms->openxreadx.out.file.fnum = SVAL(req->in.vwv, VWV(2));
761 parms->openxreadx.out.attrib = SVAL(req->in.vwv, VWV(3));
762 parms->openxreadx.out.write_time = raw_pull_dos_date3(req->transport,
763 req->in.vwv + VWV(4));
764 parms->openxreadx.out.size = IVAL(req->in.vwv, VWV(6));
765 parms->openxreadx.out.access = SVAL(req->in.vwv, VWV(8));
766 parms->openxreadx.out.ftype = SVAL(req->in.vwv, VWV(9));
767 parms->openxreadx.out.devstate = SVAL(req->in.vwv, VWV(10));
768 parms->openxreadx.out.action = SVAL(req->in.vwv, VWV(11));
769 parms->openxreadx.out.unique_fid = IVAL(req->in.vwv, VWV(12));
770 if (req->in.wct >= 19) {
771 parms->openxreadx.out.access_mask = IVAL(req->in.vwv, VWV(15));
772 parms->openxreadx.out.unknown = IVAL(req->in.vwv, VWV(17));
773 } else {
774 parms->openxreadx.out.access_mask = 0;
775 parms->openxreadx.out.unknown = 0;
776 }
777
778 status = smbcli_chained_advance(req);
779 if (!NT_STATUS_IS_OK(status)) {
780 return status;
781 }
782
783 SMBCLI_CHECK_WCT(req, 12);
784 parms->openxreadx.out.remaining = SVAL(req->in.vwv, VWV(2));
785 parms->openxreadx.out.compaction_mode = SVAL(req->in.vwv, VWV(3));
786 parms->openxreadx.out.nread = SVAL(req->in.vwv, VWV(5));
787 if (parms->openxreadx.out.nread >
788 MAX(parms->openxreadx.in.mincnt, parms->openxreadx.in.maxcnt) ||
789 !smbcli_raw_pull_data(&req->in.bufinfo, req->in.hdr + SVAL(req->in.vwv, VWV(6)),
790 parms->openxreadx.out.nread,
791 parms->openxreadx.out.data)) {
792 req->status = NT_STATUS_BUFFER_TOO_SMALL;
793 }
794 break;
795
796 case RAW_OPEN_NTCREATEX_READX:
797 SMBCLI_CHECK_MIN_WCT(req, 34);
798 parms->ntcreatexreadx.out.oplock_level = CVAL(req->in.vwv, 4);
799 parms->ntcreatexreadx.out.file.fnum = SVAL(req->in.vwv, 5);
800 parms->ntcreatexreadx.out.create_action = IVAL(req->in.vwv, 7);
801 parms->ntcreatexreadx.out.create_time = smbcli_pull_nttime(req->in.vwv, 11);
802 parms->ntcreatexreadx.out.access_time = smbcli_pull_nttime(req->in.vwv, 19);
803 parms->ntcreatexreadx.out.write_time = smbcli_pull_nttime(req->in.vwv, 27);
804 parms->ntcreatexreadx.out.change_time = smbcli_pull_nttime(req->in.vwv, 35);
805 parms->ntcreatexreadx.out.attrib = IVAL(req->in.vwv, 43);
806 parms->ntcreatexreadx.out.alloc_size = BVAL(req->in.vwv, 47);
807 parms->ntcreatexreadx.out.size = BVAL(req->in.vwv, 55);
808 parms->ntcreatexreadx.out.file_type = SVAL(req->in.vwv, 63);
809 parms->ntcreatexreadx.out.ipc_state = SVAL(req->in.vwv, 65);
810 parms->ntcreatexreadx.out.is_directory = CVAL(req->in.vwv, 67);
811
812 status = smbcli_chained_advance(req);
813 if (!NT_STATUS_IS_OK(status)) {
814 return status;
815 }
816
817 SMBCLI_CHECK_WCT(req, 12);
818 parms->ntcreatexreadx.out.remaining = SVAL(req->in.vwv, VWV(2));
819 parms->ntcreatexreadx.out.compaction_mode = SVAL(req->in.vwv, VWV(3));
820 parms->ntcreatexreadx.out.nread = SVAL(req->in.vwv, VWV(5));
821 if (parms->ntcreatexreadx.out.nread >
822 MAX(parms->ntcreatexreadx.in.mincnt, parms->ntcreatexreadx.in.maxcnt) ||
823 !smbcli_raw_pull_data(&req->in.bufinfo, req->in.hdr + SVAL(req->in.vwv, VWV(6)),
824 parms->ntcreatexreadx.out.nread,
825 parms->ntcreatexreadx.out.data)) {
826 req->status = NT_STATUS_BUFFER_TOO_SMALL;
827 }
828 break;
829
830 case RAW_OPEN_SMB2:
831 req->status = NT_STATUS_INTERNAL_ERROR;
832 break;
833 }
834
835failed:
836 return smbcli_request_destroy(req);
837}
838
839
840/****************************************************************************
841 Open a file - sync interface
842****************************************************************************/
843_PUBLIC_ NTSTATUS smb_raw_open(struct smbcli_tree *tree, TALLOC_CTX *mem_ctx, union smb_open *parms)
844{
845 struct smbcli_request *req = smb_raw_open_send(tree, parms);
846 return smb_raw_open_recv(req, mem_ctx, parms);
847}
848
849
850/****************************************************************************
851 Close a file - async send
852****************************************************************************/
853_PUBLIC_ struct smbcli_request *smb_raw_close_send(struct smbcli_tree *tree, union smb_close *parms)
854{
855 struct smbcli_request *req = NULL;
856
857 switch (parms->generic.level) {
858 case RAW_CLOSE_CLOSE:
859 SETUP_REQUEST(SMBclose, 3, 0);
860 SSVAL(req->out.vwv, VWV(0), parms->close.in.file.fnum);
861 raw_push_dos_date3(tree->session->transport,
862 req->out.vwv, VWV(1), parms->close.in.write_time);
863 break;
864
865 case RAW_CLOSE_SPLCLOSE:
866 SETUP_REQUEST(SMBsplclose, 3, 0);
867 SSVAL(req->out.vwv, VWV(0), parms->splclose.in.file.fnum);
868 SIVAL(req->out.vwv, VWV(1), 0); /* reserved */
869 break;
870
871 case RAW_CLOSE_SMB2:
872 case RAW_CLOSE_GENERIC:
873 return NULL;
874 }
875
876 if (!req) return NULL;
877
878 if (!smbcli_request_send(req)) {
879 smbcli_request_destroy(req);
880 return NULL;
881 }
882
883 return req;
884}
885
886
887/****************************************************************************
888 Close a file - sync interface
889****************************************************************************/
890_PUBLIC_ NTSTATUS smb_raw_close(struct smbcli_tree *tree, union smb_close *parms)
891{
892 struct smbcli_request *req = smb_raw_close_send(tree, parms);
893 return smbcli_request_simple_recv(req);
894}
895
896
897/****************************************************************************
898 Locking calls - async interface
899****************************************************************************/
900struct smbcli_request *smb_raw_lock_send(struct smbcli_tree *tree, union smb_lock *parms)
901{
902 struct smbcli_request *req = NULL;
903
904 switch (parms->generic.level) {
905 case RAW_LOCK_LOCK:
906 SETUP_REQUEST(SMBlock, 5, 0);
907 SSVAL(req->out.vwv, VWV(0), parms->lock.in.file.fnum);
908 SIVAL(req->out.vwv, VWV(1), parms->lock.in.count);
909 SIVAL(req->out.vwv, VWV(3), parms->lock.in.offset);
910 break;
911
912 case RAW_LOCK_UNLOCK:
913 SETUP_REQUEST(SMBunlock, 5, 0);
914 SSVAL(req->out.vwv, VWV(0), parms->unlock.in.file.fnum);
915 SIVAL(req->out.vwv, VWV(1), parms->unlock.in.count);
916 SIVAL(req->out.vwv, VWV(3), parms->unlock.in.offset);
917 break;
918
919 case RAW_LOCK_LOCKX: {
920 struct smb_lock_entry *lockp;
921 unsigned int lck_size = (parms->lockx.in.mode & LOCKING_ANDX_LARGE_FILES)? 20 : 10;
922 unsigned int lock_count = parms->lockx.in.ulock_cnt + parms->lockx.in.lock_cnt;
923 int i;
924
925 SETUP_REQUEST(SMBlockingX, 8, lck_size * lock_count);
926 SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
927 SSVAL(req->out.vwv, VWV(1), 0);
928 SSVAL(req->out.vwv, VWV(2), parms->lockx.in.file.fnum);
929 SSVAL(req->out.vwv, VWV(3), parms->lockx.in.mode);
930 SIVAL(req->out.vwv, VWV(4), parms->lockx.in.timeout);
931 SSVAL(req->out.vwv, VWV(6), parms->lockx.in.ulock_cnt);
932 SSVAL(req->out.vwv, VWV(7), parms->lockx.in.lock_cnt);
933
934 /* copy in all the locks */
935 lockp = &parms->lockx.in.locks[0];
936 for (i = 0; i < lock_count; i++) {
937 uint8_t *p = req->out.data + lck_size * i;
938 SSVAL(p, 0, lockp[i].pid);
939 if (parms->lockx.in.mode & LOCKING_ANDX_LARGE_FILES) {
940 SSVAL(p, 2, 0); /* reserved */
941 SIVAL(p, 4, lockp[i].offset>>32);
942 SIVAL(p, 8, lockp[i].offset);
943 SIVAL(p, 12, lockp[i].count>>32);
944 SIVAL(p, 16, lockp[i].count);
945 } else {
946 SIVAL(p, 2, lockp[i].offset);
947 SIVAL(p, 6, lockp[i].count);
948 }
949 }
950 break;
951 }
952 case RAW_LOCK_SMB2:
953 return NULL;
954 }
955
956 if (!smbcli_request_send(req)) {
957 smbcli_request_destroy(req);
958 return NULL;
959 }
960
961 return req;
962}
963
964/****************************************************************************
965 Locking calls - sync interface
966****************************************************************************/
967_PUBLIC_ NTSTATUS smb_raw_lock(struct smbcli_tree *tree, union smb_lock *parms)
968{
969 struct smbcli_request *req = smb_raw_lock_send(tree, parms);
970 return smbcli_request_simple_recv(req);
971}
972
973
974/****************************************************************************
975 Check for existence of a dir - async send
976****************************************************************************/
977struct smbcli_request *smb_raw_chkpath_send(struct smbcli_tree *tree, union smb_chkpath *parms)
978{
979 struct smbcli_request *req;
980
981 SETUP_REQUEST(SMBchkpth, 0, 0);
982
983 smbcli_req_append_ascii4(req, parms->chkpath.in.path, STR_TERMINATE);
984
985 if (!smbcli_request_send(req)) {
986 smbcli_request_destroy(req);
987 return NULL;
988 }
989
990 return req;
991}
992
993/****************************************************************************
994 Check for existence of a dir - sync interface
995****************************************************************************/
996NTSTATUS smb_raw_chkpath(struct smbcli_tree *tree, union smb_chkpath *parms)
997{
998 struct smbcli_request *req = smb_raw_chkpath_send(tree, parms);
999 return smbcli_request_simple_recv(req);
1000}
1001
1002/****************************************************************************
1003 flush a file - async send
1004 a flush with RAW_FLUSH_ALL will flush all files
1005****************************************************************************/
1006struct smbcli_request *smb_raw_flush_send(struct smbcli_tree *tree, union smb_flush *parms)
1007{
1008 struct smbcli_request *req;
1009 uint16_t fnum=0;
1010
1011 switch (parms->generic.level) {
1012 case RAW_FLUSH_FLUSH:
1013 fnum = parms->flush.in.file.fnum;
1014 break;
1015 case RAW_FLUSH_ALL:
1016 fnum = 0xFFFF;
1017 break;
1018 case RAW_FLUSH_SMB2:
1019 return NULL;
1020 }
1021
1022 SETUP_REQUEST(SMBflush, 1, 0);
1023 SSVAL(req->out.vwv, VWV(0), fnum);
1024
1025 if (!smbcli_request_send(req)) {
1026 smbcli_request_destroy(req);
1027 return NULL;
1028 }
1029
1030 return req;
1031}
1032
1033
1034/****************************************************************************
1035 flush a file - sync interface
1036****************************************************************************/
1037_PUBLIC_ NTSTATUS smb_raw_flush(struct smbcli_tree *tree, union smb_flush *parms)
1038{
1039 struct smbcli_request *req = smb_raw_flush_send(tree, parms);
1040 return smbcli_request_simple_recv(req);
1041}
1042
1043
1044/****************************************************************************
1045 seek a file - async send
1046****************************************************************************/
1047struct smbcli_request *smb_raw_seek_send(struct smbcli_tree *tree,
1048 union smb_seek *parms)
1049{
1050 struct smbcli_request *req;
1051
1052 SETUP_REQUEST(SMBlseek, 4, 0);
1053
1054 SSVAL(req->out.vwv, VWV(0), parms->lseek.in.file.fnum);
1055 SSVAL(req->out.vwv, VWV(1), parms->lseek.in.mode);
1056 SIVALS(req->out.vwv, VWV(2), parms->lseek.in.offset);
1057
1058 if (!smbcli_request_send(req)) {
1059 smbcli_request_destroy(req);
1060 return NULL;
1061 }
1062 return req;
1063}
1064
1065/****************************************************************************
1066 seek a file - async receive
1067****************************************************************************/
1068NTSTATUS smb_raw_seek_recv(struct smbcli_request *req,
1069 union smb_seek *parms)
1070{
1071 if (!smbcli_request_receive(req) ||
1072 smbcli_request_is_error(req)) {
1073 return smbcli_request_destroy(req);
1074 }
1075
1076 SMBCLI_CHECK_WCT(req, 2);
1077 parms->lseek.out.offset = IVAL(req->in.vwv, VWV(0));
1078
1079failed:
1080 return smbcli_request_destroy(req);
1081}
1082
1083/*
1084 seek a file - sync interface
1085*/
1086_PUBLIC_ NTSTATUS smb_raw_seek(struct smbcli_tree *tree,
1087 union smb_seek *parms)
1088{
1089 struct smbcli_request *req = smb_raw_seek_send(tree, parms);
1090 return smb_raw_seek_recv(req, parms);
1091}
Note: See TracBrowser for help on using the repository browser.