Context Navigation

source: vendor/3.6.0/source3/libsmb/clirap.c

Visit:

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: 34.2 KB

Line
1	/*
2	Unix SMB/CIFS implementation.
3	client RAP calls
4	Copyright (C) Andrew Tridgell 1994-1998
5	Copyright (C) Gerald (Jerry) Carter 2004
6	Copyright (C) James Peach 2007
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/auth/libcli_auth.h"
24	#include "../librpc/gen_ndr/rap.h"
25	#include "../lib/crypto/arcfour.h"
26	#include "../lib/util/tevent_ntstatus.h"
27	#include "async_smb.h"
28	#include "libsmb/libsmb.h"
29	#include "libsmb/clirap.h"
30	#include "trans2.h"
31
32	#define PIPE_LANMAN "\\PIPE\\LANMAN"
33
34	/****************************************************************************
35	Call a remote api
36	****************************************************************************/
37
38	bool cli_api(struct cli_state *cli,
39	char *param, int prcnt, int mprcnt,
40	char *data, int drcnt, int mdrcnt,
41	char *rparam, unsigned int rprcnt,
42	char *rdata, unsigned int rdrcnt)
43	{
44	NTSTATUS status;
45
46	uint8_t my_rparam, my_rdata;
47	uint32_t num_my_rparam, num_my_rdata;
48
49	status = cli_trans(talloc_tos(), cli, SMBtrans,
50	PIPE_LANMAN, 0, /* name, fid */
51	0, 0, /* function, flags */
52	NULL, 0, 0, /* setup */
53	(uint8_t )param, prcnt, mprcnt, / Params, length, max */
54	(uint8_t )data, drcnt, mdrcnt, / Data, length, max */
55	NULL, /* recv_flags2 */
56	NULL, 0, NULL, /* rsetup */
57	&my_rparam, 0, &num_my_rparam,
58	&my_rdata, 0, &num_my_rdata);
59	if (!NT_STATUS_IS_OK(status)) {
60	return false;
61	}
62
63	/*
64	* I know this memcpy massively hurts, but there are just tons
65	* of callers of cli_api that eventually need changing to
66	* talloc
67	*/
68
69	rparam = (char )memdup(my_rparam, num_my_rparam);
70	if (*rparam == NULL) {
71	goto fail;
72	}
73	*rprcnt = num_my_rparam;
74	TALLOC_FREE(my_rparam);
75
76	rdata = (char )memdup(my_rdata, num_my_rdata);
77	if (*rdata == NULL) {
78	goto fail;
79	}
80	*rdrcnt = num_my_rdata;
81	TALLOC_FREE(my_rdata);
82
83	return true;
84	fail:
85	TALLOC_FREE(my_rdata);
86	TALLOC_FREE(my_rparam);
87	*rparam = NULL;
88	*rprcnt = 0;
89	*rdata = NULL;
90	*rdrcnt = 0;
91	return false;
92	}
93
94	/****************************************************************************
95	Perform a NetWkstaUserLogon.
96	****************************************************************************/
97
98	bool cli_NetWkstaUserLogon(struct cli_state cli,char user, char *workstation)
99	{
100	char *rparam = NULL;
101	char *rdata = NULL;
102	char *p;
103	unsigned int rdrcnt,rprcnt;
104	char param[1024];
105
106	memset(param, 0, sizeof(param));
107
108	/* send a SMBtrans command with api NetWkstaUserLogon */
109	p = param;
110	SSVAL(p,0,132); /* api number */
111	p += 2;
112	strlcpy(p,"OOWb54WrLh",sizeof(param)-PTR_DIFF(p,param));
113	p = skip_string(param,sizeof(param),p);
114	strlcpy(p,"WB21BWDWWDDDDDDDzzzD",sizeof(param)-PTR_DIFF(p,param));
115	p = skip_string(param,sizeof(param),p);
116	SSVAL(p,0,1);
117	p += 2;
118	strlcpy(p,user,sizeof(param)-PTR_DIFF(p,param));
119	strupper_m(p);
120	p += 21;
121	p++;
122	p += 15;
123	p++;
124	strlcpy(p, workstation,sizeof(param)-PTR_DIFF(p,param));
125	strupper_m(p);
126	p += 16;
127	SSVAL(p, 0, CLI_BUFFER_SIZE);
128	p += 2;
129	SSVAL(p, 0, CLI_BUFFER_SIZE);
130	p += 2;
131
132	if (cli_api(cli,
133	param, PTR_DIFF(p,param),1024, /* param, length, max */
134	NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
135	&rparam, &rprcnt, /* return params, return size */
136	&rdata, &rdrcnt /* return data, return size */
137	)) {
138	cli->rap_error = rparam? SVAL(rparam,0) : -1;
139	p = rdata;
140
141	if (cli->rap_error == 0) {
142	DEBUG(4,("NetWkstaUserLogon success\n"));
143	cli->privileges = SVAL(p, 24);
144	/* The cli->eff_name field used to be set here
145	but it wasn't used anywhere else. */
146	} else {
147	DEBUG(1,("NetwkstaUserLogon gave error %d\n", cli->rap_error));
148	}
149	}
150
151	SAFE_FREE(rparam);
152	SAFE_FREE(rdata);
153	return (cli->rap_error == 0);
154	}
155
156	/****************************************************************************
157	Call a NetShareEnum - try and browse available connections on a host.
158	****************************************************************************/
159
160	int cli_RNetShareEnum(struct cli_state cli, void (fn)(const char , uint32, const char , void ), void state)
161	{
162	char *rparam = NULL;
163	char *rdata = NULL;
164	char *p;
165	unsigned int rdrcnt,rprcnt;
166	char param[1024];
167	int count = -1;
168
169	/* now send a SMBtrans command with api RNetShareEnum */
170	p = param;
171	SSVAL(p,0,0); /* api number */
172	p += 2;
173	strlcpy(p,"WrLeh",sizeof(param)-PTR_DIFF(p,param));
174	p = skip_string(param,sizeof(param),p);
175	strlcpy(p,"B13BWz",sizeof(param)-PTR_DIFF(p,param));
176	p = skip_string(param,sizeof(param),p);
177	SSVAL(p,0,1);
178	/*
179	* Win2k needs a smaller buffer than 0xFFFF here -
180	* it returns "out of server memory" with 0xFFFF !!! JRA.
181	*/
182	SSVAL(p,2,0xFFE0);
183	p += 4;
184
185	if (cli_api(cli,
186	param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
187	NULL, 0, 0xFFE0, /* data, length, maxlen - Win2k needs a small buffer here too ! */
188	&rparam, &rprcnt, /* return params, length */
189	&rdata, &rdrcnt)) /* return data, length */
190	{
191	int res = rparam? SVAL(rparam,0) : -1;
192
193	if (res == 0 \|\| res == ERRmoredata) {
194	int converter=SVAL(rparam,2);
195	int i;
196	char *rdata_end = rdata + rdrcnt;
197
198	count=SVAL(rparam,4);
199	p = rdata;
200
201	for (i=0;i<count;i++,p+=20) {
202	char *sname;
203	int type;
204	int comment_offset;
205	const char *cmnt;
206	const char *p1;
207	char s1, s2;
208	size_t len;
209	TALLOC_CTX *frame = talloc_stackframe();
210
211	if (p + 20 > rdata_end) {
212	TALLOC_FREE(frame);
213	break;
214	}
215
216	sname = p;
217	type = SVAL(p,14);
218	comment_offset = (IVAL(p,16) & 0xFFFF) - converter;
219	if (comment_offset < 0 \|\|
220	comment_offset > (int)rdrcnt) {
221	TALLOC_FREE(frame);
222	break;
223	}
224	cmnt = comment_offset?(rdata+comment_offset):"";
225
226	/* Work out the comment length. */
227	for (p1 = cmnt, len = 0; *p1 &&
228	p1 < rdata_end; len++)
229	p1++;
230	if (!*p1) {
231	len++;
232	}
233	pull_string_talloc(frame,rdata,0,
234	&s1,sname,14,STR_ASCII);
235	pull_string_talloc(frame,rdata,0,
236	&s2,cmnt,len,STR_ASCII);
237	if (!s1 \|\| !s2) {
238	TALLOC_FREE(frame);
239	continue;
240	}
241
242	fn(s1, type, s2, state);
243
244	TALLOC_FREE(frame);
245	}
246	} else {
247	DEBUG(4,("NetShareEnum res=%d\n", res));
248	}
249	} else {
250	DEBUG(4,("NetShareEnum failed\n"));
251	}
252
253	SAFE_FREE(rparam);
254	SAFE_FREE(rdata);
255
256	return count;
257	}
258
259	/****************************************************************************
260	Call a NetServerEnum for the specified workgroup and servertype mask. This
261	function then calls the specified callback function for each name returned.
262
263	The callback function takes 4 arguments: the machine name, the server type,
264	the comment and a state pointer.
265	****************************************************************************/
266
267	bool cli_NetServerEnum(struct cli_state cli, char workgroup, uint32 stype,
268	void (fn)(const char , uint32, const char , void ),
269	void *state)
270	{
271	char *rparam = NULL;
272	char *rdata = NULL;
273	char *rdata_end = NULL;
274	unsigned int rdrcnt,rprcnt;
275	char *p;
276	char param[1024];
277	int uLevel = 1;
278	size_t len;
279	uint32 func = RAP_NetServerEnum2;
280	char *last_entry = NULL;
281	int total_cnt = 0;
282	int return_cnt = 0;
283	int res;
284
285	errno = 0; /* reset */
286
287	/*
288	* This may take more than one transaction, so we should loop until
289	* we no longer get a more data to process or we have all of the
290	* items.
291	*/
292	do {
293	/* send a SMBtrans command with api NetServerEnum */
294	p = param;
295	SIVAL(p,0,func); /* api number */
296	p += 2;
297
298	if (func == RAP_NetServerEnum3) {
299	strlcpy(p,"WrLehDzz", sizeof(param)-PTR_DIFF(p,param));
300	} else {
301	strlcpy(p,"WrLehDz", sizeof(param)-PTR_DIFF(p,param));
302	}
303
304	p = skip_string(param, sizeof(param), p);
305	strlcpy(p,"B16BBDz", sizeof(param)-PTR_DIFF(p,param));
306
307	p = skip_string(param, sizeof(param), p);
308	SSVAL(p,0,uLevel);
309	SSVAL(p,2,CLI_BUFFER_SIZE);
310	p += 4;
311	SIVAL(p,0,stype);
312	p += 4;
313
314	/* If we have more data, tell the server where
315	* to continue from.
316	*/
317	len = push_ascii(p,
318	workgroup,
319	sizeof(param) - PTR_DIFF(p,param) - 1,
320	STR_TERMINATE\|STR_UPPER);
321
322	if (len == (size_t)-1) {
323	SAFE_FREE(last_entry);
324	return false;
325	}
326	p += len;
327
328	if (func == RAP_NetServerEnum3) {
329	len = push_ascii(p,
330	last_entry ? last_entry : "",
331	sizeof(param) - PTR_DIFF(p,param) - 1,
332	STR_TERMINATE);
333
334	if (len == (size_t)-1) {
335	SAFE_FREE(last_entry);
336	return false;
337	}
338	p += len;
339	}
340
341	/* Next time through we need to use the continue api */
342	func = RAP_NetServerEnum3;
343
344	if (!cli_api(cli,
345	param, PTR_DIFF(p,param), 8, /* params, length, max */
346	NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
347	&rparam, &rprcnt, /* return params, return size */
348	&rdata, &rdrcnt)) { /* return data, return size */
349
350	/* break out of the loop on error */
351	res = -1;
352	break;
353	}
354
355	rdata_end = rdata + rdrcnt;
356	res = rparam ? SVAL(rparam,0) : -1;
357
358	if (res == 0 \|\| res == ERRmoredata \|\|
359	(res != -1 && cli_errno(cli) == 0)) {
360	char *sname = NULL;
361	int i, count;
362	int converter=SVAL(rparam,2);
363
364	/* Get the number of items returned in this buffer */
365	count = SVAL(rparam, 4);
366
367	/* The next field contains the number of items left,
368	* including those returned in this buffer. So the
369	* first time through this should contain all of the
370	* entries.
371	*/
372	if (total_cnt == 0) {
373	total_cnt = SVAL(rparam, 6);
374	}
375
376	/* Keep track of how many we have read */
377	return_cnt += count;
378	p = rdata;
379
380	/* The last name in the previous NetServerEnum reply is
381	* sent back to server in the NetServerEnum3 request
382	* (last_entry). The next reply should repeat this entry
383	* as the first element. We have no proof that this is
384	* always true, but from traces that seems to be the
385	* behavior from Window Servers. So first lets do a lot
386	* of checking, just being paranoid. If the string
387	* matches then we already saw this entry so skip it.
388	*
389	* NOTE: sv1_name field must be null terminated and has
390	* a max size of 16 (NetBIOS Name).
391	*/
392	if (last_entry && count && p &&
393	(strncmp(last_entry, p, 16) == 0)) {
394	count -= 1; /* Skip this entry */
395	return_cnt = -1; /* Not part of total, so don't count. */
396	p = rdata + 26; /* Skip the whole record */
397	}
398
399	for (i = 0; i < count; i++, p += 26) {
400	int comment_offset;
401	const char *cmnt;
402	const char *p1;
403	char s1, s2;
404	TALLOC_CTX *frame = talloc_stackframe();
405	uint32_t entry_stype;
406
407	if (p + 26 > rdata_end) {
408	TALLOC_FREE(frame);
409	break;
410	}
411
412	sname = p;
413	comment_offset = (IVAL(p,22) & 0xFFFF)-converter;
414	cmnt = comment_offset?(rdata+comment_offset):"";
415
416	if (comment_offset < 0 \|\| comment_offset >= (int)rdrcnt) {
417	TALLOC_FREE(frame);
418	continue;
419	}
420
421	/* Work out the comment length. */
422	for (p1 = cmnt, len = 0; *p1 &&
423	p1 < rdata_end; len++)
424	p1++;
425	if (!*p1) {
426	len++;
427	}
428
429	entry_stype = IVAL(p,18) & ~SV_TYPE_LOCAL_LIST_ONLY;
430
431	pull_string_talloc(frame,rdata,0,
432	&s1,sname,16,STR_ASCII);
433	pull_string_talloc(frame,rdata,0,
434	&s2,cmnt,len,STR_ASCII);
435
436	if (!s1 \|\| !s2) {
437	TALLOC_FREE(frame);
438	continue;
439	}
440
441	fn(s1, entry_stype, s2, state);
442	TALLOC_FREE(frame);
443	}
444
445	/* We are done with the old last entry, so now we can free it */
446	if (last_entry) {
447	SAFE_FREE(last_entry); /* This will set it to null */
448	}
449
450	/* We always make a copy of the last entry if we have one */
451	if (sname) {
452	last_entry = smb_xstrdup(sname);
453	}
454
455	/* If we have more data, but no last entry then error out */
456	if (!last_entry && (res == ERRmoredata)) {
457	errno = EINVAL;
458	res = 0;
459	}
460
461	}
462
463	SAFE_FREE(rparam);
464	SAFE_FREE(rdata);
465	} while ((res == ERRmoredata) && (total_cnt > return_cnt));
466
467	SAFE_FREE(rparam);
468	SAFE_FREE(rdata);
469	SAFE_FREE(last_entry);
470
471	if (res == -1) {
472	errno = cli_errno(cli);
473	} else {
474	if (!return_cnt) {
475	/* this is a very special case, when the domain master for the
476	work group isn't part of the work group itself, there is something
477	wild going on */
478	errno = ENOENT;
479	}
480	}
481
482	return(return_cnt > 0);
483	}
484
485	/****************************************************************************
486	Send a SamOEMChangePassword command.
487	****************************************************************************/
488
489	bool cli_oem_change_password(struct cli_state cli, const char user, const char *new_password,
490	const char *old_password)
491	{
492	char param[1024];
493	unsigned char data[532];
494	char *p = param;
495	unsigned char old_pw_hash[16];
496	unsigned char new_pw_hash[16];
497	unsigned int data_len;
498	unsigned int param_len = 0;
499	char *rparam = NULL;
500	char *rdata = NULL;
501	unsigned int rprcnt, rdrcnt;
502
503	if (strlen(user) >= sizeof(fstring)-1) {
504	DEBUG(0,("cli_oem_change_password: user name %s is too long.\n", user));
505	return False;
506	}
507
508	SSVAL(p,0,214); /* SamOEMChangePassword command. */
509	p += 2;
510	strlcpy(p, "zsT", sizeof(param)-PTR_DIFF(p,param));
511	p = skip_string(param,sizeof(param),p);
512	strlcpy(p, "B516B16", sizeof(param)-PTR_DIFF(p,param));
513	p = skip_string(param,sizeof(param),p);
514	strlcpy(p,user, sizeof(param)-PTR_DIFF(p,param));
515	p = skip_string(param,sizeof(param),p);
516	SSVAL(p,0,532);
517	p += 2;
518
519	param_len = PTR_DIFF(p,param);
520
521	/*
522	* Get the Lanman hash of the old password, we
523	* use this as the key to make_oem_passwd_hash().
524	*/
525	E_deshash(old_password, old_pw_hash);
526
527	encode_pw_buffer(data, new_password, STR_ASCII);
528
529	#ifdef DEBUG_PASSWORD
530	DEBUG(100,("make_oem_passwd_hash\n"));
531	dump_data(100, data, 516);
532	#endif
533	arcfour_crypt( (unsigned char )data, (unsigned char )old_pw_hash, 516);
534
535	/*
536	* Now place the old password hash in the data.
537	*/
538	E_deshash(new_password, new_pw_hash);
539
540	E_old_pw_hash( new_pw_hash, old_pw_hash, (uchar *)&data[516]);
541
542	data_len = 532;
543
544	if (!cli_api(cli,
545	param, param_len, 4, /* param, length, max */
546	(char )data, data_len, 0, / data, length, max */
547	&rparam, &rprcnt,
548	&rdata, &rdrcnt)) {
549	DEBUG(0,("cli_oem_change_password: Failed to send password change for user %s\n",
550	user ));
551	return False;
552	}
553
554	if (rparam) {
555	cli->rap_error = SVAL(rparam,0);
556	}
557
558	SAFE_FREE(rparam);
559	SAFE_FREE(rdata);
560
561	return (cli->rap_error == 0);
562	}
563
564	/****************************************************************************
565	Send a qpathinfo call.
566	****************************************************************************/
567
568	struct cli_qpathinfo1_state {
569	struct cli_state *cli;
570	uint32_t num_data;
571	uint8_t *data;
572	};
573
574	static void cli_qpathinfo1_done(struct tevent_req *subreq);
575
576	struct tevent_req cli_qpathinfo1_send(TALLOC_CTX mem_ctx,
577	struct event_context *ev,
578	struct cli_state *cli,
579	const char *fname)
580	{
581	struct tevent_req req = NULL, subreq = NULL;
582	struct cli_qpathinfo1_state *state = NULL;
583
584	req = tevent_req_create(mem_ctx, &state, struct cli_qpathinfo1_state);
585	if (req == NULL) {
586	return NULL;
587	}
588	state->cli = cli;
589	subreq = cli_qpathinfo_send(state, ev, cli, fname, SMB_INFO_STANDARD,
590	22, cli->max_xmit);
591	if (tevent_req_nomem(subreq, req)) {
592	return tevent_req_post(req, ev);
593	}
594	tevent_req_set_callback(subreq, cli_qpathinfo1_done, req);
595	return req;
596	}
597
598	static void cli_qpathinfo1_done(struct tevent_req *subreq)
599	{
600	struct tevent_req *req = tevent_req_callback_data(
601	subreq, struct tevent_req);
602	struct cli_qpathinfo1_state *state = tevent_req_data(
603	req, struct cli_qpathinfo1_state);
604	NTSTATUS status;
605
606	status = cli_qpathinfo_recv(subreq, state, &state->data,
607	&state->num_data);
608	TALLOC_FREE(subreq);
609	if (!NT_STATUS_IS_OK(status)) {
610	tevent_req_nterror(req, status);
611	return;
612	}
613	tevent_req_done(req);
614	}
615
616	NTSTATUS cli_qpathinfo1_recv(struct tevent_req *req,
617	time_t *change_time,
618	time_t *access_time,
619	time_t *write_time,
620	SMB_OFF_T *size,
621	uint16 *mode)
622	{
623	struct cli_qpathinfo1_state *state = tevent_req_data(
624	req, struct cli_qpathinfo1_state);
625	NTSTATUS status;
626
627	time_t (date_fn)(const void buf, int serverzone);
628
629	if (tevent_req_is_nterror(req, &status)) {
630	return status;
631	}
632
633	if (state->cli->win95) {
634	date_fn = make_unix_date;
635	} else {
636	date_fn = make_unix_date2;
637	}
638
639	if (change_time) {
640	*change_time = date_fn(state->data+0, state->cli->serverzone);
641	}
642	if (access_time) {
643	*access_time = date_fn(state->data+4, state->cli->serverzone);
644	}
645	if (write_time) {
646	*write_time = date_fn(state->data+8, state->cli->serverzone);
647	}
648	if (size) {
649	*size = IVAL(state->data, 12);
650	}
651	if (mode) {
652	*mode = SVAL(state->data, l1_attrFile);
653	}
654	return NT_STATUS_OK;
655	}
656
657	NTSTATUS cli_qpathinfo1(struct cli_state *cli,
658	const char *fname,
659	time_t *change_time,
660	time_t *access_time,
661	time_t *write_time,
662	SMB_OFF_T *size,
663	uint16 *mode)
664	{
665	TALLOC_CTX *frame = talloc_stackframe();
666	struct event_context *ev;
667	struct tevent_req *req;
668	NTSTATUS status = NT_STATUS_NO_MEMORY;
669
670	if (cli_has_async_calls(cli)) {
671	/*
672	* Can't use sync call while an async call is in flight
673	*/
674	status = NT_STATUS_INVALID_PARAMETER;
675	goto fail;
676	}
677	ev = event_context_init(frame);
678	if (ev == NULL) {
679	goto fail;
680	}
681	req = cli_qpathinfo1_send(frame, ev, cli, fname);
682	if (req == NULL) {
683	goto fail;
684	}
685	if (!tevent_req_poll_ntstatus(req, ev, &status)) {
686	goto fail;
687	}
688	status = cli_qpathinfo1_recv(req, change_time, access_time,
689	write_time, size, mode);
690	fail:
691	TALLOC_FREE(frame);
692	if (!NT_STATUS_IS_OK(status)) {
693	cli_set_error(cli, status);
694	}
695	return status;
696	}
697
698	/****************************************************************************
699	Send a setpathinfo call.
700	****************************************************************************/
701
702	NTSTATUS cli_setpathinfo_basic(struct cli_state cli, const char fname,
703	time_t create_time,
704	time_t access_time,
705	time_t write_time,
706	time_t change_time,
707	uint16 mode)
708	{
709	unsigned int data_len = 0;
710	char data[40];
711	char *p;
712
713	p = data;
714
715	/*
716	* Add the create, last access, modification, and status change times
717	*/
718	put_long_date(p, create_time);
719	p += 8;
720
721	put_long_date(p, access_time);
722	p += 8;
723
724	put_long_date(p, write_time);
725	p += 8;
726
727	put_long_date(p, change_time);
728	p += 8;
729
730	/* Add attributes */
731	SIVAL(p, 0, mode);
732	p += 4;
733
734	/* Add padding */
735	SIVAL(p, 0, 0);
736	p += 4;
737
738	data_len = PTR_DIFF(p, data);
739
740	return cli_setpathinfo(cli, SMB_FILE_BASIC_INFORMATION, fname,
741	(uint8_t *)data, data_len);
742	}
743
744	/****************************************************************************
745	Send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level.
746	****************************************************************************/
747
748	struct cli_qpathinfo2_state {
749	uint32_t num_data;
750	uint8_t *data;
751	};
752
753	static void cli_qpathinfo2_done(struct tevent_req *subreq);
754
755	struct tevent_req cli_qpathinfo2_send(TALLOC_CTX mem_ctx,
756	struct event_context *ev,
757	struct cli_state *cli,
758	const char *fname)
759	{
760	struct tevent_req req = NULL, subreq = NULL;
761	struct cli_qpathinfo2_state *state = NULL;
762
763	req = tevent_req_create(mem_ctx, &state, struct cli_qpathinfo2_state);
764	if (req == NULL) {
765	return NULL;
766	}
767	subreq = cli_qpathinfo_send(state, ev, cli, fname,
768	SMB_QUERY_FILE_ALL_INFO,
769	68, cli->max_xmit);
770	if (tevent_req_nomem(subreq, req)) {
771	return tevent_req_post(req, ev);
772	}
773	tevent_req_set_callback(subreq, cli_qpathinfo2_done, req);
774	return req;
775	}
776
777	static void cli_qpathinfo2_done(struct tevent_req *subreq)
778	{
779	struct tevent_req *req = tevent_req_callback_data(
780	subreq, struct tevent_req);
781	struct cli_qpathinfo2_state *state = tevent_req_data(
782	req, struct cli_qpathinfo2_state);
783	NTSTATUS status;
784
785	status = cli_qpathinfo_recv(subreq, state, &state->data,
786	&state->num_data);
787	TALLOC_FREE(subreq);
788	if (!NT_STATUS_IS_OK(status)) {
789	tevent_req_nterror(req, status);
790	return;
791	}
792	tevent_req_done(req);
793	}
794
795	NTSTATUS cli_qpathinfo2_recv(struct tevent_req *req,
796	struct timespec *create_time,
797	struct timespec *access_time,
798	struct timespec *write_time,
799	struct timespec *change_time,
800	SMB_OFF_T size, uint16 mode,
801	SMB_INO_T *ino)
802	{
803	struct cli_qpathinfo2_state *state = tevent_req_data(
804	req, struct cli_qpathinfo2_state);
805	NTSTATUS status;
806
807	if (tevent_req_is_nterror(req, &status)) {
808	return status;
809	}
810
811	if (create_time) {
812	create_time = interpret_long_date((char )state->data+0);
813	}
814	if (access_time) {
815	access_time = interpret_long_date((char )state->data+8);
816	}
817	if (write_time) {
818	write_time = interpret_long_date((char )state->data+16);
819	}
820	if (change_time) {
821	change_time = interpret_long_date((char )state->data+24);
822	}
823	if (mode) {
824	*mode = SVAL(state->data, 32);
825	}
826	if (size) {
827	*size = IVAL2_TO_SMB_BIG_UINT(state->data,48);
828	}
829	if (ino) {
830	*ino = IVAL(state->data, 64);
831	}
832	return NT_STATUS_OK;
833	}
834
835	NTSTATUS cli_qpathinfo2(struct cli_state cli, const char fname,
836	struct timespec *create_time,
837	struct timespec *access_time,
838	struct timespec *write_time,
839	struct timespec *change_time,
840	SMB_OFF_T size, uint16 mode,
841	SMB_INO_T *ino)
842	{
843	TALLOC_CTX *frame = talloc_stackframe();
844	struct event_context *ev;
845	struct tevent_req *req;
846	NTSTATUS status = NT_STATUS_NO_MEMORY;
847
848	if (cli_has_async_calls(cli)) {
849	/*
850	* Can't use sync call while an async call is in flight
851	*/
852	status = NT_STATUS_INVALID_PARAMETER;
853	goto fail;
854	}
855	ev = event_context_init(frame);
856	if (ev == NULL) {
857	goto fail;
858	}
859	req = cli_qpathinfo2_send(frame, ev, cli, fname);
860	if (req == NULL) {
861	goto fail;
862	}
863	if (!tevent_req_poll_ntstatus(req, ev, &status)) {
864	goto fail;
865	}
866	status = cli_qpathinfo2_recv(req, create_time, access_time,
867	write_time, change_time, size, mode, ino);
868	fail:
869	TALLOC_FREE(frame);
870	if (!NT_STATUS_IS_OK(status)) {
871	cli_set_error(cli, status);
872	}
873	return status;
874	}
875
876	/****************************************************************************
877	Get the stream info
878	****************************************************************************/
879
880	static bool parse_streams_blob(TALLOC_CTX mem_ctx, const uint8_t data,
881	size_t data_len,
882	unsigned int *pnum_streams,
883	struct stream_struct **pstreams);
884
885	struct cli_qpathinfo_streams_state {
886	uint32_t num_data;
887	uint8_t *data;
888	};
889
890	static void cli_qpathinfo_streams_done(struct tevent_req *subreq);
891
892	struct tevent_req cli_qpathinfo_streams_send(TALLOC_CTX mem_ctx,
893	struct tevent_context *ev,
894	struct cli_state *cli,
895	const char *fname)
896	{
897	struct tevent_req req = NULL, subreq = NULL;
898	struct cli_qpathinfo_streams_state *state = NULL;
899
900	req = tevent_req_create(mem_ctx, &state,
901	struct cli_qpathinfo_streams_state);
902	if (req == NULL) {
903	return NULL;
904	}
905	subreq = cli_qpathinfo_send(state, ev, cli, fname,
906	SMB_FILE_STREAM_INFORMATION,
907	0, cli->max_xmit);
908	if (tevent_req_nomem(subreq, req)) {
909	return tevent_req_post(req, ev);
910	}
911	tevent_req_set_callback(subreq, cli_qpathinfo_streams_done, req);
912	return req;
913	}
914
915	static void cli_qpathinfo_streams_done(struct tevent_req *subreq)
916	{
917	struct tevent_req *req = tevent_req_callback_data(
918	subreq, struct tevent_req);
919	struct cli_qpathinfo_streams_state *state = tevent_req_data(
920	req, struct cli_qpathinfo_streams_state);
921	NTSTATUS status;
922
923	status = cli_qpathinfo_recv(subreq, state, &state->data,
924	&state->num_data);
925	TALLOC_FREE(subreq);
926	if (!NT_STATUS_IS_OK(status)) {
927	tevent_req_nterror(req, status);
928	return;
929	}
930	tevent_req_done(req);
931	}
932
933	NTSTATUS cli_qpathinfo_streams_recv(struct tevent_req *req,
934	TALLOC_CTX *mem_ctx,
935	unsigned int *pnum_streams,
936	struct stream_struct **pstreams)
937	{
938	struct cli_qpathinfo_streams_state *state = tevent_req_data(
939	req, struct cli_qpathinfo_streams_state);
940	NTSTATUS status;
941
942	if (tevent_req_is_nterror(req, &status)) {
943	return status;
944	}
945	if (!parse_streams_blob(mem_ctx, state->data, state->num_data,
946	pnum_streams, pstreams)) {
947	return NT_STATUS_INVALID_NETWORK_RESPONSE;
948	}
949	return NT_STATUS_OK;
950	}
951
952	NTSTATUS cli_qpathinfo_streams(struct cli_state cli, const char fname,
953	TALLOC_CTX *mem_ctx,
954	unsigned int *pnum_streams,
955	struct stream_struct **pstreams)
956	{
957	TALLOC_CTX *frame = talloc_stackframe();
958	struct event_context *ev;
959	struct tevent_req *req;
960	NTSTATUS status = NT_STATUS_NO_MEMORY;
961
962	if (cli_has_async_calls(cli)) {
963	/*
964	* Can't use sync call while an async call is in flight
965	*/
966	status = NT_STATUS_INVALID_PARAMETER;
967	goto fail;
968	}
969	ev = event_context_init(frame);
970	if (ev == NULL) {
971	goto fail;
972	}
973	req = cli_qpathinfo_streams_send(frame, ev, cli, fname);
974	if (req == NULL) {
975	goto fail;
976	}
977	if (!tevent_req_poll_ntstatus(req, ev, &status)) {
978	goto fail;
979	}
980	status = cli_qpathinfo_streams_recv(req, mem_ctx, pnum_streams,
981	pstreams);
982	fail:
983	TALLOC_FREE(frame);
984	if (!NT_STATUS_IS_OK(status)) {
985	cli_set_error(cli, status);
986	}
987	return status;
988	}
989
990	static bool parse_streams_blob(TALLOC_CTX mem_ctx, const uint8_t rdata,
991	size_t data_len,
992	unsigned int *pnum_streams,
993	struct stream_struct **pstreams)
994	{
995	unsigned int num_streams;
996	struct stream_struct *streams;
997	unsigned int ofs;
998
999	num_streams = 0;
1000	streams = NULL;
1001	ofs = 0;
1002
1003	while ((data_len > ofs) && (data_len - ofs >= 24)) {
1004	uint32_t nlen, len;
1005	size_t size;
1006	void *vstr;
1007	struct stream_struct *tmp;
1008	uint8_t *tmp_buf;
1009
1010	tmp = TALLOC_REALLOC_ARRAY(mem_ctx, streams,
1011	struct stream_struct,
1012	num_streams+1);
1013
1014	if (tmp == NULL) {
1015	goto fail;
1016	}
1017	streams = tmp;
1018
1019	nlen = IVAL(rdata, ofs + 0x04);
1020
1021	streams[num_streams].size = IVAL_TO_SMB_OFF_T(
1022	rdata, ofs + 0x08);
1023	streams[num_streams].alloc_size = IVAL_TO_SMB_OFF_T(
1024	rdata, ofs + 0x10);
1025
1026	if (nlen > data_len - (ofs + 24)) {
1027	goto fail;
1028	}
1029
1030	/*
1031	* We need to null-terminate src, how do I do this with
1032	* convert_string_talloc??
1033	*/
1034
1035	tmp_buf = TALLOC_ARRAY(streams, uint8_t, nlen+2);
1036	if (tmp_buf == NULL) {
1037	goto fail;
1038	}
1039
1040	memcpy(tmp_buf, rdata+ofs+24, nlen);
1041	tmp_buf[nlen] = 0;
1042	tmp_buf[nlen+1] = 0;
1043
1044	if (!convert_string_talloc(streams, CH_UTF16, CH_UNIX, tmp_buf,
1045	nlen+2, &vstr, &size, false))
1046	{
1047	TALLOC_FREE(tmp_buf);
1048	goto fail;
1049	}
1050
1051	TALLOC_FREE(tmp_buf);
1052	streams[num_streams].name = (char *)vstr;
1053	num_streams++;
1054
1055	len = IVAL(rdata, ofs);
1056	if (len > data_len - ofs) {
1057	goto fail;
1058	}
1059	if (len == 0) break;
1060	ofs += len;
1061	}
1062
1063	*pnum_streams = num_streams;
1064	*pstreams = streams;
1065	return true;
1066
1067	fail:
1068	TALLOC_FREE(streams);
1069	return false;
1070	}
1071
1072	/****************************************************************************
1073	Send a qfileinfo QUERY_FILE_NAME_INFO call.
1074	****************************************************************************/
1075
1076	NTSTATUS cli_qfilename(struct cli_state cli, uint16_t fnum, char name,
1077	size_t namelen)
1078	{
1079	uint8_t *rdata;
1080	uint32_t num_rdata;
1081	NTSTATUS status;
1082
1083	status = cli_qfileinfo(talloc_tos(), cli, fnum,
1084	SMB_QUERY_FILE_NAME_INFO,
1085	4, cli->max_xmit,
1086	&rdata, &num_rdata);
1087	if (!NT_STATUS_IS_OK(status)) {
1088	return status;
1089	}
1090
1091	clistr_pull(cli->inbuf, name, rdata+4, namelen, IVAL(rdata, 0),
1092	STR_UNICODE);
1093	TALLOC_FREE(rdata);
1094	return NT_STATUS_OK;
1095	}
1096
1097	/****************************************************************************
1098	Send a qfileinfo call.
1099	****************************************************************************/
1100
1101	NTSTATUS cli_qfileinfo_basic(struct cli_state *cli, uint16_t fnum,
1102	uint16 mode, SMB_OFF_T size,
1103	struct timespec *create_time,
1104	struct timespec *access_time,
1105	struct timespec *write_time,
1106	struct timespec *change_time,
1107	SMB_INO_T *ino)
1108	{
1109	uint8_t *rdata;
1110	uint32_t num_rdata;
1111	NTSTATUS status;
1112
1113	/* if its a win95 server then fail this - win95 totally screws it
1114	up */
1115	if (cli->win95) {
1116	return NT_STATUS_NOT_SUPPORTED;
1117	}
1118
1119	status = cli_qfileinfo(talloc_tos(), cli, fnum,
1120	SMB_QUERY_FILE_ALL_INFO,
1121	68, MIN(cli->max_xmit, 0xffff),
1122	&rdata, &num_rdata);
1123	if (!NT_STATUS_IS_OK(status)) {
1124	return status;
1125	}
1126
1127	if (create_time) {
1128	create_time = interpret_long_date((char )rdata+0);
1129	}
1130	if (access_time) {
1131	access_time = interpret_long_date((char )rdata+8);
1132	}
1133	if (write_time) {
1134	write_time = interpret_long_date((char )rdata+16);
1135	}
1136	if (change_time) {
1137	change_time = interpret_long_date((char )rdata+24);
1138	}
1139	if (mode) {
1140	*mode = SVAL(rdata, 32);
1141	}
1142	if (size) {
1143	*size = IVAL2_TO_SMB_BIG_UINT(rdata,48);
1144	}
1145	if (ino) {
1146	*ino = IVAL(rdata, 64);
1147	}
1148
1149	TALLOC_FREE(rdata);
1150	return NT_STATUS_OK;
1151	}
1152
1153	/****************************************************************************
1154	Send a qpathinfo BASIC_INFO call.
1155	****************************************************************************/
1156
1157	struct cli_qpathinfo_basic_state {
1158	uint32_t num_data;
1159	uint8_t *data;
1160	};
1161
1162	static void cli_qpathinfo_basic_done(struct tevent_req *subreq);
1163
1164	struct tevent_req cli_qpathinfo_basic_send(TALLOC_CTX mem_ctx,
1165	struct event_context *ev,
1166	struct cli_state *cli,
1167	const char *fname)
1168	{
1169	struct tevent_req req = NULL, subreq = NULL;
1170	struct cli_qpathinfo_basic_state *state = NULL;
1171
1172	req = tevent_req_create(mem_ctx, &state,
1173	struct cli_qpathinfo_basic_state);
1174	if (req == NULL) {
1175	return NULL;
1176	}
1177	subreq = cli_qpathinfo_send(state, ev, cli, fname,
1178	SMB_QUERY_FILE_BASIC_INFO,
1179	36, cli->max_xmit);
1180	if (tevent_req_nomem(subreq, req)) {
1181	return tevent_req_post(req, ev);
1182	}
1183	tevent_req_set_callback(subreq, cli_qpathinfo_basic_done, req);
1184	return req;
1185	}
1186
1187	static void cli_qpathinfo_basic_done(struct tevent_req *subreq)
1188	{
1189	struct tevent_req *req = tevent_req_callback_data(
1190	subreq, struct tevent_req);
1191	struct cli_qpathinfo_basic_state *state = tevent_req_data(
1192	req, struct cli_qpathinfo_basic_state);
1193	NTSTATUS status;
1194
1195	status = cli_qpathinfo_recv(subreq, state, &state->data,
1196	&state->num_data);
1197	TALLOC_FREE(subreq);
1198	if (!NT_STATUS_IS_OK(status)) {
1199	tevent_req_nterror(req, status);
1200	return;
1201	}
1202	tevent_req_done(req);
1203	}
1204
1205	NTSTATUS cli_qpathinfo_basic_recv(struct tevent_req *req,
1206	SMB_STRUCT_STAT sbuf, uint32 attributes)
1207	{
1208	struct cli_qpathinfo_basic_state *state = tevent_req_data(
1209	req, struct cli_qpathinfo_basic_state);
1210	NTSTATUS status;
1211
1212	if (tevent_req_is_nterror(req, &status)) {
1213	return status;
1214	}
1215
1216	sbuf->st_ex_atime = interpret_long_date((char *)state->data+8);
1217	sbuf->st_ex_mtime = interpret_long_date((char *)state->data+16);
1218	sbuf->st_ex_ctime = interpret_long_date((char *)state->data+24);
1219	*attributes = IVAL(state->data, 32);
1220	return NT_STATUS_OK;
1221	}
1222
1223	NTSTATUS cli_qpathinfo_basic(struct cli_state cli, const char name,
1224	SMB_STRUCT_STAT sbuf, uint32 attributes)
1225	{
1226	TALLOC_CTX *frame = talloc_stackframe();
1227	struct event_context *ev;
1228	struct tevent_req *req;
1229	NTSTATUS status = NT_STATUS_NO_MEMORY;
1230
1231	if (cli_has_async_calls(cli)) {
1232	/*
1233	* Can't use sync call while an async call is in flight
1234	*/
1235	status = NT_STATUS_INVALID_PARAMETER;
1236	goto fail;
1237	}
1238	ev = event_context_init(frame);
1239	if (ev == NULL) {
1240	goto fail;
1241	}
1242	req = cli_qpathinfo_basic_send(frame, ev, cli, name);
1243	if (req == NULL) {
1244	goto fail;
1245	}
1246	if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1247	goto fail;
1248	}
1249	status = cli_qpathinfo_basic_recv(req, sbuf, attributes);
1250	fail:
1251	TALLOC_FREE(frame);
1252	if (!NT_STATUS_IS_OK(status)) {
1253	cli_set_error(cli, status);
1254	}
1255	return status;
1256	}
1257
1258	/****************************************************************************
1259	Send a qpathinfo SMB_QUERY_FILE_ALT_NAME_INFO call.
1260	****************************************************************************/
1261
1262	NTSTATUS cli_qpathinfo_alt_name(struct cli_state cli, const char fname, fstring alt_name)
1263	{
1264	uint8_t *rdata;
1265	uint32_t num_rdata;
1266	unsigned int len;
1267	char *converted = NULL;
1268	size_t converted_size = 0;
1269	NTSTATUS status;
1270
1271	status = cli_qpathinfo(talloc_tos(), cli, fname,
1272	SMB_QUERY_FILE_ALT_NAME_INFO,
1273	4, cli->max_xmit, &rdata, &num_rdata);
1274	if (!NT_STATUS_IS_OK(status)) {
1275	return status;
1276	}
1277
1278	len = IVAL(rdata, 0);
1279
1280	if (len > num_rdata - 4) {
1281	return NT_STATUS_INVALID_NETWORK_RESPONSE;
1282	}
1283
1284	/* The returned data is a pushed string, not raw data. */
1285	if (!convert_string_talloc(talloc_tos(),
1286	cli_ucs2(cli) ? CH_UTF16LE : CH_DOS,
1287	CH_UNIX,
1288	rdata + 4,
1289	len,
1290	&converted,
1291	&converted_size,
1292	true)) {
1293	return NT_STATUS_NO_MEMORY;
1294	}
1295	fstrcpy(alt_name, converted);
1296
1297	TALLOC_FREE(converted);
1298	TALLOC_FREE(rdata);
1299
1300	return NT_STATUS_OK;
1301	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: