Context Navigation

clirap.c@ 888

Visit:

Last change on this file since 888 was 874, checked in by Silvan Scherrer, 11 years ago
samba server 3.6: update trunk to 3.6.24
File size: 32.7 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 == 0) {
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 == 0) {
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	return status;
693	}
694
695	/****************************************************************************
696	Send a setpathinfo call.
697	****************************************************************************/
698
699	NTSTATUS cli_setpathinfo_basic(struct cli_state cli, const char fname,
700	time_t create_time,
701	time_t access_time,
702	time_t write_time,
703	time_t change_time,
704	uint16 mode)
705	{
706	unsigned int data_len = 0;
707	char data[40];
708	char *p;
709
710	p = data;
711
712	/*
713	* Add the create, last access, modification, and status change times
714	*/
715	put_long_date(p, create_time);
716	p += 8;
717
718	put_long_date(p, access_time);
719	p += 8;
720
721	put_long_date(p, write_time);
722	p += 8;
723
724	put_long_date(p, change_time);
725	p += 8;
726
727	/* Add attributes */
728	SIVAL(p, 0, mode);
729	p += 4;
730
731	/* Add padding */
732	SIVAL(p, 0, 0);
733	p += 4;
734
735	data_len = PTR_DIFF(p, data);
736
737	return cli_setpathinfo(cli, SMB_FILE_BASIC_INFORMATION, fname,
738	(uint8_t *)data, data_len);
739	}
740
741	/****************************************************************************
742	Send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level.
743	****************************************************************************/
744
745	struct cli_qpathinfo2_state {
746	uint32_t num_data;
747	uint8_t *data;
748	};
749
750	static void cli_qpathinfo2_done(struct tevent_req *subreq);
751
752	struct tevent_req cli_qpathinfo2_send(TALLOC_CTX mem_ctx,
753	struct event_context *ev,
754	struct cli_state *cli,
755	const char *fname)
756	{
757	struct tevent_req req = NULL, subreq = NULL;
758	struct cli_qpathinfo2_state *state = NULL;
759
760	req = tevent_req_create(mem_ctx, &state, struct cli_qpathinfo2_state);
761	if (req == NULL) {
762	return NULL;
763	}
764	subreq = cli_qpathinfo_send(state, ev, cli, fname,
765	SMB_QUERY_FILE_ALL_INFO,
766	68, cli->max_xmit);
767	if (tevent_req_nomem(subreq, req)) {
768	return tevent_req_post(req, ev);
769	}
770	tevent_req_set_callback(subreq, cli_qpathinfo2_done, req);
771	return req;
772	}
773
774	static void cli_qpathinfo2_done(struct tevent_req *subreq)
775	{
776	struct tevent_req *req = tevent_req_callback_data(
777	subreq, struct tevent_req);
778	struct cli_qpathinfo2_state *state = tevent_req_data(
779	req, struct cli_qpathinfo2_state);
780	NTSTATUS status;
781
782	status = cli_qpathinfo_recv(subreq, state, &state->data,
783	&state->num_data);
784	TALLOC_FREE(subreq);
785	if (!NT_STATUS_IS_OK(status)) {
786	tevent_req_nterror(req, status);
787	return;
788	}
789	tevent_req_done(req);
790	}
791
792	NTSTATUS cli_qpathinfo2_recv(struct tevent_req *req,
793	struct timespec *create_time,
794	struct timespec *access_time,
795	struct timespec *write_time,
796	struct timespec *change_time,
797	SMB_OFF_T size, uint16 mode,
798	SMB_INO_T *ino)
799	{
800	struct cli_qpathinfo2_state *state = tevent_req_data(
801	req, struct cli_qpathinfo2_state);
802	NTSTATUS status;
803
804	if (tevent_req_is_nterror(req, &status)) {
805	return status;
806	}
807
808	if (create_time) {
809	create_time = interpret_long_date((char )state->data+0);
810	}
811	if (access_time) {
812	access_time = interpret_long_date((char )state->data+8);
813	}
814	if (write_time) {
815	write_time = interpret_long_date((char )state->data+16);
816	}
817	if (change_time) {
818	change_time = interpret_long_date((char )state->data+24);
819	}
820	if (mode) {
821	*mode = SVAL(state->data, 32);
822	}
823	if (size) {
824	*size = IVAL2_TO_SMB_BIG_UINT(state->data,48);
825	}
826	if (ino) {
827	*ino = IVAL(state->data, 64);
828	}
829	return NT_STATUS_OK;
830	}
831
832	NTSTATUS cli_qpathinfo2(struct cli_state cli, const char fname,
833	struct timespec *create_time,
834	struct timespec *access_time,
835	struct timespec *write_time,
836	struct timespec *change_time,
837	SMB_OFF_T size, uint16 mode,
838	SMB_INO_T *ino)
839	{
840	TALLOC_CTX *frame = talloc_stackframe();
841	struct event_context *ev;
842	struct tevent_req *req;
843	NTSTATUS status = NT_STATUS_NO_MEMORY;
844
845	if (cli_has_async_calls(cli)) {
846	/*
847	* Can't use sync call while an async call is in flight
848	*/
849	status = NT_STATUS_INVALID_PARAMETER;
850	goto fail;
851	}
852	ev = event_context_init(frame);
853	if (ev == NULL) {
854	goto fail;
855	}
856	req = cli_qpathinfo2_send(frame, ev, cli, fname);
857	if (req == NULL) {
858	goto fail;
859	}
860	if (!tevent_req_poll_ntstatus(req, ev, &status)) {
861	goto fail;
862	}
863	status = cli_qpathinfo2_recv(req, create_time, access_time,
864	write_time, change_time, size, mode, ino);
865	fail:
866	TALLOC_FREE(frame);
867	return status;
868	}
869
870	/****************************************************************************
871	Get the stream info
872	****************************************************************************/
873
874	static bool parse_streams_blob(TALLOC_CTX mem_ctx, const uint8_t data,
875	size_t data_len,
876	unsigned int *pnum_streams,
877	struct stream_struct **pstreams);
878
879	struct cli_qpathinfo_streams_state {
880	uint32_t num_data;
881	uint8_t *data;
882	};
883
884	static void cli_qpathinfo_streams_done(struct tevent_req *subreq);
885
886	struct tevent_req cli_qpathinfo_streams_send(TALLOC_CTX mem_ctx,
887	struct tevent_context *ev,
888	struct cli_state *cli,
889	const char *fname)
890	{
891	struct tevent_req req = NULL, subreq = NULL;
892	struct cli_qpathinfo_streams_state *state = NULL;
893
894	req = tevent_req_create(mem_ctx, &state,
895	struct cli_qpathinfo_streams_state);
896	if (req == NULL) {
897	return NULL;
898	}
899	subreq = cli_qpathinfo_send(state, ev, cli, fname,
900	SMB_FILE_STREAM_INFORMATION,
901	0, cli->max_xmit);
902	if (tevent_req_nomem(subreq, req)) {
903	return tevent_req_post(req, ev);
904	}
905	tevent_req_set_callback(subreq, cli_qpathinfo_streams_done, req);
906	return req;
907	}
908
909	static void cli_qpathinfo_streams_done(struct tevent_req *subreq)
910	{
911	struct tevent_req *req = tevent_req_callback_data(
912	subreq, struct tevent_req);
913	struct cli_qpathinfo_streams_state *state = tevent_req_data(
914	req, struct cli_qpathinfo_streams_state);
915	NTSTATUS status;
916
917	status = cli_qpathinfo_recv(subreq, state, &state->data,
918	&state->num_data);
919	TALLOC_FREE(subreq);
920	if (!NT_STATUS_IS_OK(status)) {
921	tevent_req_nterror(req, status);
922	return;
923	}
924	tevent_req_done(req);
925	}
926
927	NTSTATUS cli_qpathinfo_streams_recv(struct tevent_req *req,
928	TALLOC_CTX *mem_ctx,
929	unsigned int *pnum_streams,
930	struct stream_struct **pstreams)
931	{
932	struct cli_qpathinfo_streams_state *state = tevent_req_data(
933	req, struct cli_qpathinfo_streams_state);
934	NTSTATUS status;
935
936	if (tevent_req_is_nterror(req, &status)) {
937	return status;
938	}
939	if (!parse_streams_blob(mem_ctx, state->data, state->num_data,
940	pnum_streams, pstreams)) {
941	return NT_STATUS_INVALID_NETWORK_RESPONSE;
942	}
943	return NT_STATUS_OK;
944	}
945
946	NTSTATUS cli_qpathinfo_streams(struct cli_state cli, const char fname,
947	TALLOC_CTX *mem_ctx,
948	unsigned int *pnum_streams,
949	struct stream_struct **pstreams)
950	{
951	TALLOC_CTX *frame = talloc_stackframe();
952	struct event_context *ev;
953	struct tevent_req *req;
954	NTSTATUS status = NT_STATUS_NO_MEMORY;
955
956	if (cli_has_async_calls(cli)) {
957	/*
958	* Can't use sync call while an async call is in flight
959	*/
960	status = NT_STATUS_INVALID_PARAMETER;
961	goto fail;
962	}
963	ev = event_context_init(frame);
964	if (ev == NULL) {
965	goto fail;
966	}
967	req = cli_qpathinfo_streams_send(frame, ev, cli, fname);
968	if (req == NULL) {
969	goto fail;
970	}
971	if (!tevent_req_poll_ntstatus(req, ev, &status)) {
972	goto fail;
973	}
974	status = cli_qpathinfo_streams_recv(req, mem_ctx, pnum_streams,
975	pstreams);
976	fail:
977	TALLOC_FREE(frame);
978	return status;
979	}
980
981	static bool parse_streams_blob(TALLOC_CTX mem_ctx, const uint8_t rdata,
982	size_t data_len,
983	unsigned int *pnum_streams,
984	struct stream_struct **pstreams)
985	{
986	unsigned int num_streams;
987	struct stream_struct *streams;
988	unsigned int ofs;
989
990	num_streams = 0;
991	streams = NULL;
992	ofs = 0;
993
994	while ((data_len > ofs) && (data_len - ofs >= 24)) {
995	uint32_t nlen, len;
996	size_t size;
997	void *vstr;
998	struct stream_struct *tmp;
999	uint8_t *tmp_buf;
1000
1001	tmp = TALLOC_REALLOC_ARRAY(mem_ctx, streams,
1002	struct stream_struct,
1003	num_streams+1);
1004
1005	if (tmp == NULL) {
1006	goto fail;
1007	}
1008	streams = tmp;
1009
1010	nlen = IVAL(rdata, ofs + 0x04);
1011
1012	streams[num_streams].size = IVAL_TO_SMB_OFF_T(
1013	rdata, ofs + 0x08);
1014	streams[num_streams].alloc_size = IVAL_TO_SMB_OFF_T(
1015	rdata, ofs + 0x10);
1016
1017	if (nlen > data_len - (ofs + 24)) {
1018	goto fail;
1019	}
1020
1021	/*
1022	* We need to null-terminate src, how do I do this with
1023	* convert_string_talloc??
1024	*/
1025
1026	tmp_buf = TALLOC_ARRAY(streams, uint8_t, nlen+2);
1027	if (tmp_buf == NULL) {
1028	goto fail;
1029	}
1030
1031	memcpy(tmp_buf, rdata+ofs+24, nlen);
1032	tmp_buf[nlen] = 0;
1033	tmp_buf[nlen+1] = 0;
1034
1035	if (!convert_string_talloc(streams, CH_UTF16, CH_UNIX, tmp_buf,
1036	nlen+2, &vstr, &size, false))
1037	{
1038	TALLOC_FREE(tmp_buf);
1039	goto fail;
1040	}
1041
1042	TALLOC_FREE(tmp_buf);
1043	streams[num_streams].name = (char *)vstr;
1044	num_streams++;
1045
1046	len = IVAL(rdata, ofs);
1047	if (len > data_len - ofs) {
1048	goto fail;
1049	}
1050	if (len == 0) break;
1051	ofs += len;
1052	}
1053
1054	*pnum_streams = num_streams;
1055	*pstreams = streams;
1056	return true;
1057
1058	fail:
1059	TALLOC_FREE(streams);
1060	return false;
1061	}
1062
1063	/****************************************************************************
1064	Send a qfileinfo QUERY_FILE_NAME_INFO call.
1065	****************************************************************************/
1066
1067	NTSTATUS cli_qfilename(struct cli_state cli, uint16_t fnum, char name,
1068	size_t namelen)
1069	{
1070	uint8_t *rdata;
1071	uint32_t num_rdata;
1072	NTSTATUS status;
1073
1074	status = cli_qfileinfo(talloc_tos(), cli, fnum,
1075	SMB_QUERY_FILE_NAME_INFO,
1076	4, cli->max_xmit,
1077	&rdata, &num_rdata);
1078	if (!NT_STATUS_IS_OK(status)) {
1079	return status;
1080	}
1081
1082	clistr_pull(cli->inbuf, name, rdata+4, namelen, IVAL(rdata, 0),
1083	STR_UNICODE);
1084	TALLOC_FREE(rdata);
1085	return NT_STATUS_OK;
1086	}
1087
1088	/****************************************************************************
1089	Send a qfileinfo call.
1090	****************************************************************************/
1091
1092	NTSTATUS cli_qfileinfo_basic(struct cli_state *cli, uint16_t fnum,
1093	uint16 mode, SMB_OFF_T size,
1094	struct timespec *create_time,
1095	struct timespec *access_time,
1096	struct timespec *write_time,
1097	struct timespec *change_time,
1098	SMB_INO_T *ino)
1099	{
1100	uint8_t *rdata;
1101	uint32_t num_rdata;
1102	NTSTATUS status;
1103
1104	/* if its a win95 server then fail this - win95 totally screws it
1105	up */
1106	if (cli->win95) {
1107	return NT_STATUS_NOT_SUPPORTED;
1108	}
1109
1110	status = cli_qfileinfo(talloc_tos(), cli, fnum,
1111	SMB_QUERY_FILE_ALL_INFO,
1112	68, MIN(cli->max_xmit, 0xffff),
1113	&rdata, &num_rdata);
1114	if (!NT_STATUS_IS_OK(status)) {
1115	return status;
1116	}
1117
1118	if (create_time) {
1119	create_time = interpret_long_date((char )rdata+0);
1120	}
1121	if (access_time) {
1122	access_time = interpret_long_date((char )rdata+8);
1123	}
1124	if (write_time) {
1125	write_time = interpret_long_date((char )rdata+16);
1126	}
1127	if (change_time) {
1128	change_time = interpret_long_date((char )rdata+24);
1129	}
1130	if (mode) {
1131	*mode = SVAL(rdata, 32);
1132	}
1133	if (size) {
1134	*size = IVAL2_TO_SMB_BIG_UINT(rdata,48);
1135	}
1136	if (ino) {
1137	*ino = IVAL(rdata, 64);
1138	}
1139
1140	TALLOC_FREE(rdata);
1141	return NT_STATUS_OK;
1142	}
1143
1144	/****************************************************************************
1145	Send a qpathinfo BASIC_INFO call.
1146	****************************************************************************/
1147
1148	struct cli_qpathinfo_basic_state {
1149	uint32_t num_data;
1150	uint8_t *data;
1151	};
1152
1153	static void cli_qpathinfo_basic_done(struct tevent_req *subreq);
1154
1155	struct tevent_req cli_qpathinfo_basic_send(TALLOC_CTX mem_ctx,
1156	struct event_context *ev,
1157	struct cli_state *cli,
1158	const char *fname)
1159	{
1160	struct tevent_req req = NULL, subreq = NULL;
1161	struct cli_qpathinfo_basic_state *state = NULL;
1162
1163	req = tevent_req_create(mem_ctx, &state,
1164	struct cli_qpathinfo_basic_state);
1165	if (req == NULL) {
1166	return NULL;
1167	}
1168	subreq = cli_qpathinfo_send(state, ev, cli, fname,
1169	SMB_QUERY_FILE_BASIC_INFO,
1170	36, cli->max_xmit);
1171	if (tevent_req_nomem(subreq, req)) {
1172	return tevent_req_post(req, ev);
1173	}
1174	tevent_req_set_callback(subreq, cli_qpathinfo_basic_done, req);
1175	return req;
1176	}
1177
1178	static void cli_qpathinfo_basic_done(struct tevent_req *subreq)
1179	{
1180	struct tevent_req *req = tevent_req_callback_data(
1181	subreq, struct tevent_req);
1182	struct cli_qpathinfo_basic_state *state = tevent_req_data(
1183	req, struct cli_qpathinfo_basic_state);
1184	NTSTATUS status;
1185
1186	status = cli_qpathinfo_recv(subreq, state, &state->data,
1187	&state->num_data);
1188	TALLOC_FREE(subreq);
1189	if (!NT_STATUS_IS_OK(status)) {
1190	tevent_req_nterror(req, status);
1191	return;
1192	}
1193	tevent_req_done(req);
1194	}
1195
1196	NTSTATUS cli_qpathinfo_basic_recv(struct tevent_req *req,
1197	SMB_STRUCT_STAT sbuf, uint32 attributes)
1198	{
1199	struct cli_qpathinfo_basic_state *state = tevent_req_data(
1200	req, struct cli_qpathinfo_basic_state);
1201	NTSTATUS status;
1202
1203	if (tevent_req_is_nterror(req, &status)) {
1204	return status;
1205	}
1206
1207	sbuf->st_ex_atime = interpret_long_date((char *)state->data+8);
1208	sbuf->st_ex_mtime = interpret_long_date((char *)state->data+16);
1209	sbuf->st_ex_ctime = interpret_long_date((char *)state->data+24);
1210	*attributes = IVAL(state->data, 32);
1211	return NT_STATUS_OK;
1212	}
1213
1214	NTSTATUS cli_qpathinfo_basic(struct cli_state cli, const char name,
1215	SMB_STRUCT_STAT sbuf, uint32 attributes)
1216	{
1217	TALLOC_CTX *frame = talloc_stackframe();
1218	struct event_context *ev;
1219	struct tevent_req *req;
1220	NTSTATUS status = NT_STATUS_NO_MEMORY;
1221
1222	if (cli_has_async_calls(cli)) {
1223	/*
1224	* Can't use sync call while an async call is in flight
1225	*/
1226	status = NT_STATUS_INVALID_PARAMETER;
1227	goto fail;
1228	}
1229	ev = event_context_init(frame);
1230	if (ev == NULL) {
1231	goto fail;
1232	}
1233	req = cli_qpathinfo_basic_send(frame, ev, cli, name);
1234	if (req == NULL) {
1235	goto fail;
1236	}
1237	if (!tevent_req_poll_ntstatus(req, ev, &status)) {
1238	goto fail;
1239	}
1240	status = cli_qpathinfo_basic_recv(req, sbuf, attributes);
1241	fail:
1242	TALLOC_FREE(frame);
1243	return status;
1244	}
1245
1246	/****************************************************************************
1247	Send a qpathinfo SMB_QUERY_FILE_ALT_NAME_INFO call.
1248	****************************************************************************/
1249
1250	NTSTATUS cli_qpathinfo_alt_name(struct cli_state cli, const char fname, fstring alt_name)
1251	{
1252	uint8_t *rdata;
1253	uint32_t num_rdata;
1254	unsigned int len;
1255	char *converted = NULL;
1256	size_t converted_size = 0;
1257	NTSTATUS status;
1258
1259	status = cli_qpathinfo(talloc_tos(), cli, fname,
1260	SMB_QUERY_FILE_ALT_NAME_INFO,
1261	4, cli->max_xmit, &rdata, &num_rdata);
1262	if (!NT_STATUS_IS_OK(status)) {
1263	return status;
1264	}
1265
1266	len = IVAL(rdata, 0);
1267
1268	if (len > num_rdata - 4) {
1269	return NT_STATUS_INVALID_NETWORK_RESPONSE;
1270	}
1271
1272	/* The returned data is a pushed string, not raw data. */
1273	if (!convert_string_talloc(talloc_tos(),
1274	cli_ucs2(cli) ? CH_UTF16LE : CH_DOS,
1275	CH_UNIX,
1276	rdata + 4,
1277	len,
1278	&converted,
1279	&converted_size,
1280	true)) {
1281	return NT_STATUS_NO_MEMORY;
1282	}
1283	fstrcpy(alt_name, converted);
1284
1285	TALLOC_FREE(converted);
1286	TALLOC_FREE(rdata);
1287
1288	return NT_STATUS_OK;
1289	}

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

Context Navigation

source: trunk/server/source3/libsmb/clirap.c@ 888

Download in other formats: