Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

rawfile.c

Visit:

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago
Samba Server: updated trunk 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	**/
35	char 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	****************************************************************************/
81	struct 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	****************************************************************************/
152	struct 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	****************************************************************************/
183	static 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	****************************************************************************/
223	struct 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	****************************************************************************/
260	struct 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	*/
291	static 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	*/
329	static 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	****************************************************************************/
418	static 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	****************************************************************************/
468	static 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
835	failed:
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	****************************************************************************/
900	struct 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	****************************************************************************/
977	struct 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	****************************************************************************/
996	NTSTATUS 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	****************************************************************************/
1006	struct 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	****************************************************************************/
1047	struct 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	****************************************************************************/
1068	NTSTATUS 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
1079	failed:
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.

Context Navigation

source: trunk/server/source4/libcli/raw/rawfile.c

Download in other formats: