Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: branches/samba-3.3.x/source/libsmb/clirap2.c@ 435

Visit:

Last change on this file since 435 was 206, checked in by Herwig Bauernfeind, 16 years ago
Import Samba 3.3 branch at 3.0.0 level (psmedley's port)
File size: 72.4 KB

Line
1	/*
2	Samba Unix/Linux SMB client library
3	More client RAP (SMB Remote Procedure Calls) functions
4	Copyright (C) 2001 Steve French (sfrench@us.ibm.com)
5	Copyright (C) 2001 Jim McDonough (jmcd@us.ibm.com)
6	Copyright (C) 2007 Jeremy Allison. jra@samba.org
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	/*****************************************************/
23	/* */
24	/* Additional RAP functionality */
25	/* */
26	/* RAP is the original SMB RPC, documented */
27	/* by Microsoft and X/Open in the 1990s and */
28	/* supported by most SMB/CIFS servers although */
29	/* it is unlikely that any one implementation */
30	/* supports all RAP command codes since some */
31	/* are quite obsolete and a few are specific */
32	/* to a particular network operating system */
33	/* */
34	/* Although it has largely been replaced */
35	/* for complex remote admistration and management */
36	/* (of servers) by the relatively newer */
37	/* DCE/RPC based remote API (which better handles */
38	/* large >64K data structures), there are many */
39	/* important administrative and resource location */
40	/* tasks and user tasks (e.g. password change) */
41	/* that are performed via RAP. */
42	/* */
43	/* Although a few of the RAP calls are implemented */
44	/* in the Samba client library already (clirap.c) */
45	/* the new ones are in clirap2.c for easy patching */
46	/* and integration and a corresponding header */
47	/* file, rap.h, has been created. */
48	/* */
49	/* This is based on data from the CIFS spec */
50	/* and the LAN Server and LAN Manager */
51	/* Programming Reference books and published */
52	/* RAP document and CIFS forum postings and */
53	/* lots of trial and error */
54	/* */
55	/* Function names changed from API_ (as they are */
56	/* in the CIFS specification) to RAP_ in order */
57	/* to avoid confusion with other API calls */
58	/* sent via DCE RPC */
59	/* */
60	/*****************************************************/
61
62	/*****************************************************/
63	/* */
64	/* cifsrap.c already includes support for: */
65	/* */
66	/* WshareEnum ( API number 0, level 1) */
67	/* NetServerEnum2 (API num 104, level 1) */
68	/* WWkstaUserLogon (132) */
69	/* SamOEMchgPasswordUser2_P (214) */
70	/* */
71	/* cifsprint.c already includes support for: */
72	/* */
73	/* WPrintJobEnum (API num 76, level 2) */
74	/* WPrintJobDel (API num 81) */
75	/* */
76	/*****************************************************/
77
78	#include "includes.h"
79
80	#define WORDSIZE 2
81	#define DWORDSIZE 4
82
83	#define PUTBYTE(p,b) do {SCVAL(p,0,b); p++;} while(0)
84
85	#define GETBYTE(p,b,endp) \
86	do {\
87	if (p+1 < endp) {\
88	b = CVAL(p,0);\
89	}\
90	p++;\
91	} while(0)
92
93	#define PUTWORD(p,w) do {SSVAL(p,0,w); p += WORDSIZE;} while(0)
94
95	#define GETWORD(p,w,endp) \
96	do {\
97	if (p+WORDSIZE < endp) {\
98	w = SVAL(p,0);\
99	}\
100	p += WORDSIZE;\
101	} while(0)
102
103	#define PUTDWORD(p,d) do {SIVAL(p,0,d); p += DWORDSIZE;} while(0)
104
105	#define GETDWORD(p,d,endp) \
106	do {\
107	if (p+DWORDSIZE < endp) {\
108	d = IVAL(p,0);\
109	}\
110	p += DWORDSIZE;\
111	} while(0)
112
113	#define GETRES(p,endp) ((p && p+2 < endp) ? SVAL(p,0) : -1)
114
115	/* put string s at p with max len n and increment p past string */
116	#define PUTSTRING(p,s,n) \
117	do {\
118	push_ascii(p,s?s:"",n?n:256,STR_TERMINATE);\
119	p = push_skip_string(p);\
120	} while(0)
121
122	/* put string s and p, using fixed len l, and increment p by l */
123	#define PUTSTRINGF(p,s,l) \
124	do {\
125	push_ascii(p,s?s:"",l,STR_TERMINATE);\
126	p += l;\
127	} while (0)
128
129	/* put string pointer at p, supplying offset o from rdata r, store */
130	/* dword offset at p, increment p by 4 and o by length of s. This */
131	/* means on the first call, you must calc the offset yourself! */
132
133	#define PUTSTRINGP(p,s,r,o) \
134	do {\
135	if (s) {\
136	push_ascii(r+o,s,strlen(s)+1,STR_TERMINATE);\
137	PUTDWORD(p,o);\
138	o += strlen(s) + 1;\
139	} else {\
140	PUTDWORD(p,0);\
141	}\
142	}while(0);
143
144	/* get asciiz string dest from src, return increment past string */
145
146	static size_t rap_getstring(TALLOC_CTX ctx, char src, char *dest, const char endp)
147	{
148	char *p1;
149	size_t len;
150
151	*dest = NULL;
152	for (p1 = src, len = 0; *p1 && p1 < endp; len++)
153	p1++;
154	if (!*p1) {
155	len++;
156	}
157	pull_string_talloc(ctx,src,0,dest,src,len,STR_ASCII);
158	return len;
159	}
160
161	/* get fixed length l string dest from src, return increment for src */
162
163	static size_t rap_getstringf(char src, char dest, size_t l, size_t dlen, char *endp)
164	{
165	char *p1;
166	size_t len;
167
168	if (dlen) {
169	dest[0] = '\0';
170	}
171	for (p1 = src, len = 0; *p1 && p1 < endp; len++) {
172	p1++;
173	}
174	if (!*p1) {
175	len++;
176	}
177	if (len > l) {
178	len = l;
179	}
180	if (len) {
181	pull_ascii(dest,src,len,len,STR_ASCII);
182	}
183	return l;
184	}
185
186	/* get string dest from offset (obtained at p) from rdata r - converter c */
187	static size_t rap_getstringp(TALLOC_CTX ctx, char p, char *dest, char r, uint16_t c, char *endp)
188	{
189	uint32_t off = 0;
190	const char *src;
191	size_t len=0;
192
193	*dest = NULL;
194	if (p+4 < endp) {
195	GETDWORD(p,off,endp);
196	off &= 0x0000FFFF; /* mask the obsolete segment number from the offset */
197	off -= c;
198	}
199	if (r+off > endp \|\| r+off < r) {
200	src="";
201	len=1;
202	} else {
203	const char *p1;
204	src=r+off;
205	for (p1 = src, len = 0; *p1 && p1 < endp; len++) {
206	p1++;
207	}
208	if (!*p1) {
209	len++;
210	}
211	}
212	pull_string_talloc(ctx,src,0,dest,src,len,STR_ASCII);
213	return len;
214	}
215
216	static char make_header(char param, uint16 apinum, const char reqfmt, const char datafmt)
217	{
218	PUTWORD(param,apinum);
219	if (reqfmt)
220	PUTSTRING(param,reqfmt,0);
221	else
222	*param++ = (char) 0;
223
224	if (datafmt)
225	PUTSTRING(param,datafmt,0);
226	else
227	*param++ = (char) 0;
228
229	return param;
230	}
231
232	/****************************************************************************
233	call a NetGroupDelete - delete user group from remote server
234	****************************************************************************/
235
236	int cli_NetGroupDelete(struct cli_state cli, const char group_name)
237	{
238	char *rparam = NULL;
239	char *rdata = NULL;
240	char *p;
241	unsigned int rdrcnt,rprcnt;
242	int res = -1;
243	char param[WORDSIZE /* api number */
244	+sizeof(RAP_NetGroupDel_REQ) /* parm string */
245	+1 /* no ret string */
246	+RAP_GROUPNAME_LEN /* group to del */
247	+WORDSIZE]; /* reserved word */
248
249	/* now send a SMBtrans command with api GroupDel */
250	p = make_header(param, RAP_WGroupDel, RAP_NetGroupDel_REQ, NULL);
251	PUTSTRING(p, group_name, RAP_GROUPNAME_LEN);
252	PUTWORD(p,0); /* reserved word MBZ on input */
253
254	if (cli_api(cli,
255	param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
256	NULL, 0, 200, /* data, length, maxlen */
257	&rparam, &rprcnt, /* return params, length */
258	&rdata, &rdrcnt)) /* return data, length */
259	{
260	char *endp = rparam + rprcnt;
261	res = GETRES(rparam,endp);
262
263	if (res == 0) {
264	/* nothing to do */
265	} else if ((res == 5) \|\| (res == 65)) {
266	DEBUG(1, ("Access Denied\n"));
267	} else if (res == 2220) {
268	DEBUG (1, ("Group does not exist\n"));
269	} else {
270	DEBUG(4,("NetGroupDelete res=%d\n", res));
271	}
272	} else {
273	res = -1;
274	DEBUG(4,("NetGroupDelete failed\n"));
275	}
276
277	SAFE_FREE(rparam);
278	SAFE_FREE(rdata);
279
280	return res;
281	}
282
283	/****************************************************************************
284	call a NetGroupAdd - add user group to remote server
285	****************************************************************************/
286
287	int cli_NetGroupAdd(struct cli_state cli, RAP_GROUP_INFO_1 grinfo)
288	{
289	char *rparam = NULL;
290	char *rdata = NULL;
291	char *p;
292	unsigned int rdrcnt,rprcnt;
293	int res = -1;
294	char param[WORDSIZE /* api number */
295	+sizeof(RAP_NetGroupAdd_REQ) /* req string */
296	+sizeof(RAP_GROUP_INFO_L1) /* return string */
297	+WORDSIZE /* info level */
298	+WORDSIZE]; /* reserved word */
299
300	/* offset into data of free format strings. Will be updated */
301	/* by PUTSTRINGP macro and end up with total data length. */
302	int soffset = RAP_GROUPNAME_LEN + 1 + DWORDSIZE;
303	char *data;
304	size_t data_size;
305
306	/* Allocate data. */
307	data_size = MAX(soffset + strlen(grinfo->comment) + 1, 1024);
308
309	data = SMB_MALLOC_ARRAY(char, data_size);
310	if (!data) {
311	DEBUG (1, ("Malloc fail\n"));
312	return -1;
313	}
314
315	/* now send a SMBtrans command with api WGroupAdd */
316
317	p = make_header(param, RAP_WGroupAdd,
318	RAP_NetGroupAdd_REQ, RAP_GROUP_INFO_L1);
319	PUTWORD(p, 1); /* info level */
320	PUTWORD(p, 0); /* reserved word 0 */
321
322	p = data;
323	PUTSTRINGF(p, grinfo->group_name, RAP_GROUPNAME_LEN);
324	PUTBYTE(p, 0); /* pad byte 0 */
325	PUTSTRINGP(p, grinfo->comment, data, soffset);
326
327	if (cli_api(cli,
328	param, sizeof(param), 1024, /* Param, length, maxlen */
329	data, soffset, sizeof(data), /* data, length, maxlen */
330	&rparam, &rprcnt, /* return params, length */
331	&rdata, &rdrcnt)) /* return data, length */
332	{
333	char *endp = rparam + rprcnt;
334	res = GETRES(rparam, endp);
335
336	if (res == 0) {
337	/* nothing to do */
338	} else if ((res == 5) \|\| (res == 65)) {
339	DEBUG(1, ("Access Denied\n"));
340	} else if (res == 2223) {
341	DEBUG (1, ("Group already exists\n"));
342	} else {
343	DEBUG(4,("NetGroupAdd res=%d\n", res));
344	}
345	} else {
346	res = -1;
347	DEBUG(4,("NetGroupAdd failed\n"));
348	}
349
350	SAFE_FREE(data);
351	SAFE_FREE(rparam);
352	SAFE_FREE(rdata);
353
354	return res;
355	}
356
357	/****************************************************************************
358	Call a NetGroupEnum - try and list user groups on a different host.
359	****************************************************************************/
360
361	int cli_RNetGroupEnum(struct cli_state cli, void (fn)(const char , const char , void ), void state)
362	{
363	char param[WORDSIZE /* api number */
364	+sizeof(RAP_NetGroupEnum_REQ) /* parm string */
365	+sizeof(RAP_GROUP_INFO_L1) /* return string */
366	+WORDSIZE /* info level */
367	+WORDSIZE]; /* buffer size */
368	char *p;
369	char *rparam = NULL;
370	char *rdata = NULL;
371	unsigned int rprcnt, rdrcnt;
372	int res = -1;
373
374	memset(param, '\0', sizeof(param));
375	p = make_header(param, RAP_WGroupEnum,
376	RAP_NetGroupEnum_REQ, RAP_GROUP_INFO_L1);
377	PUTWORD(p,1); /* Info level 1 / / add level 0 */
378	PUTWORD(p,0xFFE0); /* Return buffer size */
379
380	if (cli_api(cli,
381	param, PTR_DIFF(p,param),8,
382	NULL, 0, 0xFFE0 /* data area size */,
383	&rparam, &rprcnt,
384	&rdata, &rdrcnt)) {
385	char *endp = rparam + rdrcnt;
386
387	res = GETRES(rparam, endp);
388	cli->rap_error = res;
389	if(cli->rap_error == 234) {
390	DEBUG(1,("Not all group names were returned (such as those longer than 21 characters)\n"));
391	} else if (cli->rap_error != 0) {
392	DEBUG(1,("NetGroupEnum gave error %d\n", cli->rap_error));
393	}
394	}
395
396	if (!rdata) {
397	DEBUG(4,("NetGroupEnum no data returned\n"));
398	goto out;
399	}
400
401	if (res == 0 \|\| res == ERRmoredata) {
402	char *endp = rparam + rprcnt;
403	int i, converter = 0, count = 0;
404	TALLOC_CTX *frame = talloc_stackframe();
405
406	p = rparam + WORDSIZE; /* skip result */
407	GETWORD(p, converter, endp);
408	GETWORD(p, count, endp);
409
410	endp = rdata + rdrcnt;
411	for (i=0,p=rdata; i<count && p < endp;i++) {
412	char *comment = NULL;
413	char groupname[RAP_GROUPNAME_LEN];
414
415	p += rap_getstringf(p,
416	groupname,
417	RAP_GROUPNAME_LEN,
418	RAP_GROUPNAME_LEN,
419	endp);
420	p++; /* pad byte */
421	p += rap_getstringp(frame,
422	p,
423	&comment,
424	rdata,
425	converter,
426	endp);
427
428	if (!comment \|\| !groupname[0]) {
429	break;
430	}
431
432	fn(groupname, comment, cli);
433	}
434	TALLOC_FREE(frame);
435	} else {
436	DEBUG(4,("NetGroupEnum res=%d\n", res));
437	}
438
439	out:
440
441	SAFE_FREE(rparam);
442	SAFE_FREE(rdata);
443
444	return res;
445	}
446
447	int cli_RNetGroupEnum0(struct cli_state *cli,
448	void (fn)(const char , void *),
449	void *state)
450	{
451	char param[WORDSIZE /* api number */
452	+sizeof(RAP_NetGroupEnum_REQ) /* parm string */
453	+sizeof(RAP_GROUP_INFO_L0) /* return string */
454	+WORDSIZE /* info level */
455	+WORDSIZE]; /* buffer size */
456	char *p;
457	char *rparam = NULL;
458	char *rdata = NULL;
459	unsigned int rprcnt, rdrcnt;
460	int res = -1;
461
462	memset(param, '\0', sizeof(param));
463	p = make_header(param, RAP_WGroupEnum,
464	RAP_NetGroupEnum_REQ, RAP_GROUP_INFO_L0);
465	PUTWORD(p,0); /* Info level 0 / / Hmmm. I very much suspect this
466	is the resume count, at least
467	that's what smbd believes... */
468	PUTWORD(p,0xFFE0); /* Return buffer size */
469
470	if (cli_api(cli,
471	param, PTR_DIFF(p,param),8,
472	NULL, 0, 0xFFE0 /* data area size */,
473	&rparam, &rprcnt,
474	&rdata, &rdrcnt)) {
475	char *endp = rparam+rprcnt;
476	res = GETRES(rparam,endp);
477	cli->rap_error = res;
478	if(cli->rap_error == 234) {
479	DEBUG(1,("Not all group names were returned (such as those longer than 21 characters)\n"));
480	} else if (cli->rap_error != 0) {
481	DEBUG(1,("NetGroupEnum gave error %d\n", cli->rap_error));
482	}
483	}
484
485	if (!rdata) {
486	DEBUG(4,("NetGroupEnum no data returned\n"));
487	goto out;
488	}
489
490	if (res == 0 \|\| res == ERRmoredata) {
491	char *endp = rparam + rprcnt;
492	int i, count = 0;
493
494	p = rparam + WORDSIZE + WORDSIZE; /* skip result and converter */
495	GETWORD(p, count, endp);
496
497	endp = rdata + rdrcnt;
498	for (i=0,p=rdata; i<count && p < endp;i++) {
499	char groupname[RAP_GROUPNAME_LEN];
500
501	p += rap_getstringf(p,
502	groupname,
503	RAP_GROUPNAME_LEN,
504	RAP_GROUPNAME_LEN,
505	endp);
506	if (groupname[0]) {
507	fn(groupname, cli);
508	}
509	}
510	} else {
511	DEBUG(4,("NetGroupEnum res=%d\n", res));
512	}
513
514	out:
515
516	SAFE_FREE(rparam);
517	SAFE_FREE(rdata);
518
519	return res;
520	}
521
522	int cli_NetGroupDelUser(struct cli_state * cli, const char group_name, const char user_name)
523	{
524	char *rparam = NULL;
525	char *rdata = NULL;
526	char *p;
527	unsigned int rdrcnt,rprcnt;
528	int res = -1;
529	char param[WORDSIZE /* api number */
530	+sizeof(RAP_NetGroupDelUser_REQ) /* parm string */
531	+1 /* no ret string */
532	+RAP_GROUPNAME_LEN /* group name */
533	+RAP_USERNAME_LEN]; /* user to del */
534
535	/* now send a SMBtrans command with api GroupMemberAdd */
536	p = make_header(param, RAP_WGroupDelUser, RAP_NetGroupDelUser_REQ, NULL);
537	PUTSTRING(p,group_name,RAP_GROUPNAME_LEN);
538	PUTSTRING(p,user_name,RAP_USERNAME_LEN);
539
540	if (cli_api(cli,
541	param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
542	NULL, 0, 200, /* data, length, maxlen */
543	&rparam, &rprcnt, /* return params, length */
544	&rdata, &rdrcnt)) /* return data, length */
545	{
546	char *endp = rparam + rprcnt;
547	res = GETRES(rparam,endp);
548
549	switch(res) {
550	case 0:
551	break;
552	case 5:
553	case 65:
554	DEBUG(1, ("Access Denied\n"));
555	break;
556	case 50:
557	DEBUG(1, ("Not supported by server\n"));
558	break;
559	case 2220:
560	DEBUG(1, ("Group does not exist\n"));
561	break;
562	case 2221:
563	DEBUG(1, ("User does not exist\n"));
564	break;
565	case 2237:
566	DEBUG(1, ("User is not in group\n"));
567	break;
568	default:
569	DEBUG(4,("NetGroupDelUser res=%d\n", res));
570	}
571	} else {
572	res = -1;
573	DEBUG(4,("NetGroupDelUser failed\n"));
574	}
575
576	SAFE_FREE(rparam);
577	SAFE_FREE(rdata);
578
579	return res;
580	}
581
582	int cli_NetGroupAddUser(struct cli_state * cli, const char group_name, const char user_name)
583	{
584	char *rparam = NULL;
585	char *rdata = NULL;
586	char *p;
587	unsigned int rdrcnt,rprcnt;
588	int res = -1;
589	char param[WORDSIZE /* api number */
590	+sizeof(RAP_NetGroupAddUser_REQ) /* parm string */
591	+1 /* no ret string */
592	+RAP_GROUPNAME_LEN /* group name */
593	+RAP_USERNAME_LEN]; /* user to add */
594
595	/* now send a SMBtrans command with api GroupMemberAdd */
596	p = make_header(param, RAP_WGroupAddUser, RAP_NetGroupAddUser_REQ, NULL);
597	PUTSTRING(p,group_name,RAP_GROUPNAME_LEN);
598	PUTSTRING(p,user_name,RAP_USERNAME_LEN);
599
600	if (cli_api(cli,
601	param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
602	NULL, 0, 200, /* data, length, maxlen */
603	&rparam, &rprcnt, /* return params, length */
604	&rdata, &rdrcnt)) /* return data, length */
605	{
606	char *endp = rparam + rprcnt;
607	res = GETRES(rparam,endp);
608
609	switch(res) {
610	case 0:
611	break;
612	case 5:
613	case 65:
614	DEBUG(1, ("Access Denied\n"));
615	break;
616	case 50:
617	DEBUG(1, ("Not supported by server\n"));
618	break;
619	case 2220:
620	DEBUG(1, ("Group does not exist\n"));
621	break;
622	case 2221:
623	DEBUG(1, ("User does not exist\n"));
624	break;
625	default:
626	DEBUG(4,("NetGroupAddUser res=%d\n", res));
627	}
628	} else {
629	res = -1;
630	DEBUG(4,("NetGroupAddUser failed\n"));
631	}
632
633	SAFE_FREE(rparam);
634	SAFE_FREE(rdata);
635
636	return res;
637	}
638
639
640	int cli_NetGroupGetUsers(struct cli_state * cli, const char group_name, void (fn)(const char , void ), void *state )
641	{
642	char *rparam = NULL;
643	char *rdata = NULL;
644	char *p;
645	unsigned int rdrcnt,rprcnt;
646	int res = -1;
647	char param[WORDSIZE /* api number */
648	+sizeof(RAP_NetGroupGetUsers_REQ)/* parm string */
649	+sizeof(RAP_GROUP_USERS_INFO_0) /* return string */
650	+RAP_GROUPNAME_LEN /* group name */
651	+WORDSIZE /* info level */
652	+WORDSIZE]; /* buffer size */
653
654	/* now send a SMBtrans command with api GroupGetUsers */
655	p = make_header(param, RAP_WGroupGetUsers,
656	RAP_NetGroupGetUsers_REQ, RAP_GROUP_USERS_INFO_0);
657	PUTSTRING(p,group_name,RAP_GROUPNAME_LEN-1);
658	PUTWORD(p,0); /* info level 0 */
659	PUTWORD(p,0xFFE0); /* return buffer size */
660
661	if (cli_api(cli,
662	param, PTR_DIFF(p,param),PTR_DIFF(p,param),
663	NULL, 0, CLI_BUFFER_SIZE,
664	&rparam, &rprcnt,
665	&rdata, &rdrcnt)) {
666	char *endp = rparam + rprcnt;
667	res = GETRES(rparam,endp);
668	cli->rap_error = res;
669	if (res != 0) {
670	DEBUG(1,("NetGroupGetUsers gave error %d\n", res));
671	}
672	}
673
674	if (!rdata) {
675	DEBUG(4,("NetGroupGetUsers no data returned\n"));
676	goto out;
677	}
678
679	if (res == 0 \|\| res == ERRmoredata) {
680	char *endp = rparam + rprcnt;
681	int i, count = 0;
682	char username[RAP_USERNAME_LEN];
683
684	p = rparam + WORDSIZE + WORDSIZE;
685	GETWORD(p, count, endp);
686
687	endp = rdata + rdrcnt;
688	for (i=0,p=rdata; i<count && p < endp; i++) {
689	p += rap_getstringf(p,
690	username,
691	RAP_USERNAME_LEN,
692	RAP_USERNAME_LEN,
693	endp);
694	if (username[0]) {
695	fn(username, state);
696	}
697	}
698	} else {
699	DEBUG(4,("NetGroupGetUsers res=%d\n", res));
700	}
701
702	out:
703
704	SAFE_FREE(rdata);
705	SAFE_FREE(rparam);
706	return res;
707	}
708
709	int cli_NetUserGetGroups(struct cli_state * cli, const char user_name, void (fn)(const char , void ), void *state )
710	{
711	char *rparam = NULL;
712	char *rdata = NULL;
713	char *p;
714	unsigned int rdrcnt,rprcnt;
715	int res = -1;
716	char param[WORDSIZE /* api number */
717	+sizeof(RAP_NetUserGetGroups_REQ)/* parm string */
718	+sizeof(RAP_GROUP_USERS_INFO_0) /* return string */
719	+RAP_USERNAME_LEN /* user name */
720	+WORDSIZE /* info level */
721	+WORDSIZE]; /* buffer size */
722
723	/* now send a SMBtrans command with api GroupGetUsers */
724	p = make_header(param, RAP_WUserGetGroups,
725	RAP_NetUserGetGroups_REQ, RAP_GROUP_USERS_INFO_0);
726	PUTSTRING(p,user_name,RAP_USERNAME_LEN-1);
727	PUTWORD(p,0); /* info level 0 */
728	PUTWORD(p,0xFFE0); /* return buffer size */
729
730	if (cli_api(cli,
731	param, PTR_DIFF(p,param),PTR_DIFF(p,param),
732	NULL, 0, CLI_BUFFER_SIZE,
733	&rparam, &rprcnt,
734	&rdata, &rdrcnt)) {
735	char *endp = rparam + rprcnt;
736	res = GETRES(rparam,endp);
737	cli->rap_error = res;
738	if (res != 0) {
739	DEBUG(1,("NetUserGetGroups gave error %d\n", res));
740	}
741	}
742
743	if (!rdata) {
744	DEBUG(4,("NetUserGetGroups no data returned\n"));
745	goto out;
746	}
747
748	if (res == 0 \|\| res == ERRmoredata) {
749	char *endp = rparam + rprcnt;
750	int i, count = 0;
751	char groupname[RAP_GROUPNAME_LEN];
752
753	p = rparam + WORDSIZE + WORDSIZE;
754	GETWORD(p, count, endp);
755
756	endp = rdata + rdrcnt;
757	for (i=0,p=rdata; i<count && p < endp; i++) {
758	p += rap_getstringf(p,
759	groupname,
760	RAP_GROUPNAME_LEN,
761	RAP_GROUPNAME_LEN,
762	endp);
763	if (groupname[0]) {
764	fn(groupname, state);
765	}
766	}
767	} else {
768	DEBUG(4,("NetUserGetGroups res=%d\n", res));
769	}
770
771	out:
772
773	SAFE_FREE(rdata);
774	SAFE_FREE(rparam);
775	return res;
776	}
777
778	/****************************************************************************
779	Call a NetUserDelete - delete user from remote server.
780	****************************************************************************/
781
782	int cli_NetUserDelete(struct cli_state cli, const char user_name )
783	{
784	char *rparam = NULL;
785	char *rdata = NULL;
786	char *p;
787	unsigned int rdrcnt,rprcnt;
788	int res = -1;
789	char param[WORDSIZE /* api number */
790	+sizeof(RAP_NetGroupDel_REQ) /* parm string */
791	+1 /* no ret string */
792	+RAP_USERNAME_LEN /* user to del */
793	+WORDSIZE]; /* reserved word */
794
795	/* now send a SMBtrans command with api UserDel */
796	p = make_header(param, RAP_WUserDel, RAP_NetGroupDel_REQ, NULL);
797	PUTSTRING(p, user_name, RAP_USERNAME_LEN);
798	PUTWORD(p,0); /* reserved word MBZ on input */
799
800	if (cli_api(cli,
801	param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
802	NULL, 0, 200, /* data, length, maxlen */
803	&rparam, &rprcnt, /* return params, length */
804	&rdata, &rdrcnt)) /* return data, length */
805	{
806	char *endp = rparam + rprcnt;
807	res = GETRES(rparam,endp);
808
809	if (res == 0) {
810	/* nothing to do */
811	} else if ((res == 5) \|\| (res == 65)) {
812	DEBUG(1, ("Access Denied\n"));
813	} else if (res == 2221) {
814	DEBUG (1, ("User does not exist\n"));
815	} else {
816	DEBUG(4,("NetUserDelete res=%d\n", res));
817	}
818	} else {
819	res = -1;
820	DEBUG(4,("NetUserDelete failed\n"));
821	}
822
823	SAFE_FREE(rparam);
824	SAFE_FREE(rdata);
825
826	return res;
827	}
828
829	/****************************************************************************
830	Call a NetUserAdd - add user to remote server.
831	****************************************************************************/
832
833	int cli_NetUserAdd(struct cli_state cli, RAP_USER_INFO_1 userinfo )
834	{
835	char *rparam = NULL;
836	char *rdata = NULL;
837	char *p;
838	unsigned int rdrcnt,rprcnt;
839	int res = -1;
840	char param[WORDSIZE /* api number */
841	+sizeof(RAP_NetUserAdd2_REQ) /* req string */
842	+sizeof(RAP_USER_INFO_L1) /* data string */
843	+WORDSIZE /* info level */
844	+WORDSIZE /* buffer length */
845	+WORDSIZE]; /* reserved */
846
847	char data[1024];
848	/* offset into data of free format strings. Will be updated */
849	/* by PUTSTRINGP macro and end up with total data length. */
850	int soffset=RAP_USERNAME_LEN+1 /* user name + pad */
851	+ RAP_UPASSWD_LEN /* password */
852	+ DWORDSIZE /* password age */
853	+ WORDSIZE /* privilege */
854	+ DWORDSIZE /* home dir ptr */
855	+ DWORDSIZE /* comment ptr */
856	+ WORDSIZE /* flags */
857	+ DWORDSIZE; /* login script ptr*/
858
859	/* now send a SMBtrans command with api NetUserAdd */
860	p = make_header(param, RAP_WUserAdd2,
861	RAP_NetUserAdd2_REQ, RAP_USER_INFO_L1);
862
863	PUTWORD(p, 1); /* info level */
864	PUTWORD(p, 0); /* pwencrypt */
865	if(userinfo->passwrd)
866	PUTWORD(p,MIN(strlen(userinfo->passwrd), RAP_UPASSWD_LEN));
867	else
868	PUTWORD(p, 0); /* password length */
869
870	p = data;
871	memset(data, '\0', soffset);
872
873	PUTSTRINGF(p, userinfo->user_name, RAP_USERNAME_LEN);
874	PUTBYTE(p, 0); /* pad byte 0 */
875	PUTSTRINGF(p, userinfo->passwrd, RAP_UPASSWD_LEN);
876	PUTDWORD(p, 0); /* pw age - n.a. on user add */
877	PUTWORD(p, userinfo->priv);
878	PUTSTRINGP(p, userinfo->home_dir, data, soffset);
879	PUTSTRINGP(p, userinfo->comment, data, soffset);
880	PUTWORD(p, userinfo->userflags);
881	PUTSTRINGP(p, userinfo->logon_script, data, soffset);
882
883	if (cli_api(cli,
884	param, sizeof(param), 1024, /* Param, length, maxlen */
885	data, soffset, sizeof(data), /* data, length, maxlen */
886	&rparam, &rprcnt, /* return params, length */
887	&rdata, &rdrcnt)) /* return data, length */
888	{
889	char *endp = rparam + rprcnt;
890	res = GETRES(rparam, endp);
891
892	if (res == 0) {
893	/* nothing to do */
894	} else if ((res == 5) \|\| (res == 65)) {
895	DEBUG(1, ("Access Denied\n"));
896	} else if (res == 2224) {
897	DEBUG (1, ("User already exists\n"));
898	} else {
899	DEBUG(4,("NetUserAdd res=%d\n", res));
900	}
901	} else {
902	res = -1;
903	DEBUG(4,("NetUserAdd failed\n"));
904	}
905
906	SAFE_FREE(rparam);
907	SAFE_FREE(rdata);
908
909	return res;
910	}
911
912	/****************************************************************************
913	call a NetUserEnum - try and list users on a different host
914	****************************************************************************/
915
916	int cli_RNetUserEnum(struct cli_state cli, void (fn)(const char , const char , const char , const char , void ), void state)
917	{
918	char param[WORDSIZE /* api number */
919	+sizeof(RAP_NetUserEnum_REQ) /* parm string */
920	+sizeof(RAP_USER_INFO_L1) /* return string */
921	+WORDSIZE /* info level */
922	+WORDSIZE]; /* buffer size */
923	char *p;
924	char *rparam = NULL;
925	char *rdata = NULL;
926	unsigned int rprcnt, rdrcnt;
927	int res = -1;
928
929	memset(param, '\0', sizeof(param));
930	p = make_header(param, RAP_WUserEnum,
931	RAP_NetUserEnum_REQ, RAP_USER_INFO_L1);
932	PUTWORD(p,1); /* Info level 1 */
933	PUTWORD(p,0xFF00); /* Return buffer size */
934
935	/* BB Fix handling of large numbers of users to be returned */
936	if (cli_api(cli,
937	param, PTR_DIFF(p,param),8,
938	NULL, 0, CLI_BUFFER_SIZE,
939	&rparam, &rprcnt,
940	&rdata, &rdrcnt)) {
941	char *endp = rparam + rprcnt;
942	res = GETRES(rparam,endp);
943	cli->rap_error = res;
944	if (cli->rap_error != 0) {
945	DEBUG(1,("NetUserEnum gave error %d\n", cli->rap_error));
946	}
947	}
948
949	if (!rdata) {
950	DEBUG(4,("NetUserEnum no data returned\n"));
951	goto out;
952	}
953
954	if (res == 0 \|\| res == ERRmoredata) {
955	int i, converter = 0, count = 0;
956	char username[RAP_USERNAME_LEN];
957	char userpw[RAP_UPASSWD_LEN];
958	char *endp = rparam + rprcnt;
959	char comment, homedir, *logonscript;
960	TALLOC_CTX *frame = talloc_stackframe();
961
962	p = rparam + WORDSIZE; /* skip result */
963	GETWORD(p, converter, endp);
964	GETWORD(p, count, endp);
965
966	endp = rdata + rdrcnt;
967	for (i=0,p=rdata;i<count && p < endp;i++) {
968	p += rap_getstringf(p,
969	username,
970	RAP_USERNAME_LEN,
971	RAP_USERNAME_LEN,
972	endp);
973	p++; /* pad byte */
974	p += rap_getstringf(p,
975	userpw,
976	RAP_UPASSWD_LEN,
977	RAP_UPASSWD_LEN,
978	endp);
979	p += DWORDSIZE; /* skip password age */
980	p += WORDSIZE; /* skip priv: 0=guest, 1=user, 2=admin */
981	p += rap_getstringp(frame,
982	p,
983	&homedir,
984	rdata,
985	converter,
986	endp);
987	p += rap_getstringp(frame,
988	p,
989	&comment,
990	rdata,
991	converter,
992	endp);
993	p += WORDSIZE; /* skip flags */
994	p += rap_getstringp(frame,
995	p,
996	&logonscript,
997	rdata,
998	converter,
999	endp);
1000	if (username[0] && comment &&
1001	homedir && logonscript) {
1002	fn(username,
1003	comment,
1004	homedir,
1005	logonscript,
1006	cli);
1007	}
1008	}
1009	TALLOC_FREE(frame);
1010	} else {
1011	DEBUG(4,("NetUserEnum res=%d\n", res));
1012	}
1013
1014	out:
1015
1016	SAFE_FREE(rparam);
1017	SAFE_FREE(rdata);
1018
1019	return res;
1020	}
1021
1022	int cli_RNetUserEnum0(struct cli_state *cli,
1023	void (fn)(const char , void *),
1024	void *state)
1025	{
1026	char param[WORDSIZE /* api number */
1027	+sizeof(RAP_NetUserEnum_REQ) /* parm string */
1028	+sizeof(RAP_USER_INFO_L0) /* return string */
1029	+WORDSIZE /* info level */
1030	+WORDSIZE]; /* buffer size */
1031	char *p;
1032	char *rparam = NULL;
1033	char *rdata = NULL;
1034	unsigned int rprcnt, rdrcnt;
1035	int res = -1;
1036
1037	memset(param, '\0', sizeof(param));
1038	p = make_header(param, RAP_WUserEnum,
1039	RAP_NetUserEnum_REQ, RAP_USER_INFO_L0);
1040	PUTWORD(p,0); /* Info level 1 */
1041	PUTWORD(p,0xFF00); /* Return buffer size */
1042
1043	/* BB Fix handling of large numbers of users to be returned */
1044	if (cli_api(cli,
1045	param, PTR_DIFF(p,param),8,
1046	NULL, 0, CLI_BUFFER_SIZE,
1047	&rparam, &rprcnt,
1048	&rdata, &rdrcnt)) {
1049	char *endp = rparam + rprcnt;
1050	res = GETRES(rparam,endp);
1051	cli->rap_error = res;
1052	if (cli->rap_error != 0) {
1053	DEBUG(1,("NetUserEnum gave error %d\n", cli->rap_error));
1054	}
1055	}
1056
1057	if (!rdata) {
1058	DEBUG(4,("NetUserEnum no data returned\n"));
1059	goto out;
1060	}
1061
1062	if (res == 0 \|\| res == ERRmoredata) {
1063	int i, count = 0;
1064	char *endp = rparam + rprcnt;
1065	char username[RAP_USERNAME_LEN];
1066
1067	p = rparam + WORDSIZE + WORDSIZE; /* skip result and converter */
1068	GETWORD(p, count, endp);
1069
1070	endp = rdata + rdrcnt;
1071	for (i=0,p=rdata;i<count && p < endp;i++) {
1072	p += rap_getstringf(p,
1073	username,
1074	RAP_USERNAME_LEN,
1075	RAP_USERNAME_LEN,
1076	endp);
1077	if (username[0]) {
1078	fn(username, cli);
1079	}
1080	}
1081	} else {
1082	DEBUG(4,("NetUserEnum res=%d\n", res));
1083	}
1084
1085	out:
1086
1087	SAFE_FREE(rparam);
1088	SAFE_FREE(rdata);
1089
1090	return res;
1091	}
1092
1093	/****************************************************************************
1094	Call a NetFileClose2 - close open file on another session to server.
1095	****************************************************************************/
1096
1097	int cli_NetFileClose(struct cli_state *cli, uint32 file_id )
1098	{
1099	char *rparam = NULL;
1100	char *rdata = NULL;
1101	char *p;
1102	unsigned int rdrcnt,rprcnt;
1103	char param[WORDSIZE /* api number */
1104	+sizeof(RAP_WFileClose2_REQ) /* req string */
1105	+1 /* no ret string */
1106	+DWORDSIZE]; /* file ID */
1107	int res = -1;
1108
1109	/* now send a SMBtrans command with api RNetShareEnum */
1110	p = make_header(param, RAP_WFileClose2, RAP_WFileClose2_REQ, NULL);
1111	PUTDWORD(p, file_id);
1112
1113	if (cli_api(cli,
1114	param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
1115	NULL, 0, 200, /* data, length, maxlen */
1116	&rparam, &rprcnt, /* return params, length */
1117	&rdata, &rdrcnt)) /* return data, length */
1118	{
1119	char *endp = rparam + rprcnt;
1120	res = GETRES(rparam, endp);
1121
1122	if (res == 0) {
1123	/* nothing to do */
1124	} else if (res == 2314){
1125	DEBUG(1, ("NetFileClose2 - attempt to close non-existant file open instance\n"));
1126	} else {
1127	DEBUG(4,("NetFileClose2 res=%d\n", res));
1128	}
1129	} else {
1130	res = -1;
1131	DEBUG(4,("NetFileClose2 failed\n"));
1132	}
1133
1134	SAFE_FREE(rparam);
1135	SAFE_FREE(rdata);
1136
1137	return res;
1138	}
1139
1140	/****************************************************************************
1141	Call a NetFileGetInfo - get information about server file opened from other
1142	workstation.
1143	****************************************************************************/
1144
1145	int cli_NetFileGetInfo(struct cli_state cli, uint32 file_id, void (fn)(const char , const char , uint16, uint16, uint32))
1146	{
1147	char *rparam = NULL;
1148	char *rdata = NULL;
1149	char *p;
1150	unsigned int rdrcnt,rprcnt;
1151	int res = -1;
1152	char param[WORDSIZE /* api number */
1153	+sizeof(RAP_WFileGetInfo2_REQ) /* req string */
1154	+sizeof(RAP_FILE_INFO_L3) /* return string */
1155	+DWORDSIZE /* file ID */
1156	+WORDSIZE /* info level */
1157	+WORDSIZE]; /* buffer size */
1158
1159	/* now send a SMBtrans command with api RNetShareEnum */
1160	p = make_header(param, RAP_WFileGetInfo2,
1161	RAP_WFileGetInfo2_REQ, RAP_FILE_INFO_L3);
1162	PUTDWORD(p, file_id);
1163	PUTWORD(p, 3); /* info level */
1164	PUTWORD(p, 0x1000); /* buffer size */
1165	if (cli_api(cli,
1166	param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
1167	NULL, 0, 0x1000, /* data, length, maxlen */
1168	&rparam, &rprcnt, /* return params, length */
1169	&rdata, &rdrcnt)) /* return data, length */
1170	{
1171	char *endp = rparam + rprcnt;
1172	res = GETRES(rparam,endp);
1173	if (res == 0 \|\| res == ERRmoredata) {
1174	TALLOC_CTX *frame = talloc_stackframe();
1175	int converter = 0,id = 0, perms = 0, locks = 0;
1176	char fpath, fuser;
1177
1178	p = rparam + WORDSIZE; /* skip result */
1179	GETWORD(p, converter, endp);
1180
1181	p = rdata;
1182	endp = rdata + rdrcnt;
1183
1184	GETDWORD(p, id, endp);
1185	GETWORD(p, perms, endp);
1186	GETWORD(p, locks, endp);
1187
1188	p += rap_getstringp(frame,
1189	p,
1190	&fpath,
1191	rdata,
1192	converter,
1193	endp);
1194	p += rap_getstringp(frame,
1195	p,
1196	&fuser,
1197	rdata,
1198	converter,
1199	endp);
1200
1201	if (fpath && fuser) {
1202	fn(fpath, fuser, perms, locks, id);
1203	}
1204
1205	TALLOC_FREE(frame);
1206	} else {
1207	DEBUG(4,("NetFileGetInfo2 res=%d\n", res));
1208	}
1209	} else {
1210	res = -1;
1211	DEBUG(4,("NetFileGetInfo2 failed\n"));
1212	}
1213
1214	SAFE_FREE(rparam);
1215	SAFE_FREE(rdata);
1216
1217	return res;
1218	}
1219
1220	/****************************************************************************
1221	* Call a NetFileEnum2 - list open files on an SMB server
1222	*
1223	* PURPOSE: Remotes a NetFileEnum API call to the current server or target
1224	* server listing the files open via the network (and their
1225	* corresponding open instance ids)
1226	*
1227	* Dependencies: none
1228	*
1229	* Parameters:
1230	* cli - pointer to cli_state structure
1231	* user - if present, return only files opened by this remote user
1232	* base_path - if present, return only files opened below this
1233	* base path
1234	* fn - display function to invoke for each entry in the result
1235	*
1236	*
1237	* Returns:
1238	* True - success
1239	* False - failure
1240	*
1241	****************************************************************************/
1242
1243	int cli_NetFileEnum(struct cli_state cli, const char user,
1244	const char * base_path,
1245	void (fn)(const char , const char *, uint16, uint16,
1246	uint32))
1247	{
1248	char *rparam = NULL;
1249	char *rdata = NULL;
1250	char *p;
1251	unsigned int rdrcnt,rprcnt;
1252	char param[WORDSIZE /* api number */
1253	+sizeof(RAP_WFileEnum2_REQ) /* req string */
1254	+sizeof(RAP_FILE_INFO_L3) /* return string */
1255	+1024 /* base path (opt) */
1256	+RAP_USERNAME_LEN /* user name (opt) */
1257	+WORDSIZE /* info level */
1258	+WORDSIZE /* buffer size */
1259	+DWORDSIZE /* resume key ? */
1260	+DWORDSIZE]; /* resume key ? */
1261	int count = -1;
1262	int res = -1;
1263
1264	/* now send a SMBtrans command with api RNetShareEnum */
1265	p = make_header(param, RAP_WFileEnum2,
1266	RAP_WFileEnum2_REQ, RAP_FILE_INFO_L3);
1267
1268	PUTSTRING(p, base_path, 1024);
1269	PUTSTRING(p, user, RAP_USERNAME_LEN);
1270	PUTWORD(p, 3); /* info level */
1271	PUTWORD(p, 0xFF00); /* buffer size */
1272	PUTDWORD(p, 0); /* zero out the resume key */
1273	PUTDWORD(p, 0); /* or is this one the resume key? */
1274
1275	if (cli_api(cli,
1276	param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
1277	NULL, 0, 0xFF00, /* data, length, maxlen */
1278	&rparam, &rprcnt, /* return params, length */
1279	&rdata, &rdrcnt)) /* return data, length */
1280	{
1281	char *endp = rparam + rprcnt;
1282	res = GETRES(rparam, endp);
1283
1284	if (res == 0 \|\| res == ERRmoredata) {
1285	TALLOC_CTX *frame = talloc_stackframe();
1286	int converter = 0, i;
1287
1288	p = rparam + WORDSIZE; /* skip result */
1289	GETWORD(p, converter, endp);
1290	GETWORD(p, count, endp);
1291
1292	p = rdata;
1293	endp = rdata + rdrcnt;
1294	for (i=0; i<count && p < endp; i++) {
1295	int id = 0, perms = 0, locks = 0;
1296	char fpath, fuser;
1297
1298	GETDWORD(p, id, endp);
1299	GETWORD(p, perms, endp);
1300	GETWORD(p, locks, endp);
1301	p += rap_getstringp(frame,
1302	p,
1303	&fpath,
1304	rdata,
1305	converter,
1306	endp);
1307	p += rap_getstringp(frame,
1308	p,
1309	&fuser,
1310	rdata,
1311	converter,
1312	endp);
1313
1314	if (fpath && fuser) {
1315	fn(fpath, fuser, perms, locks, id);
1316	}
1317	} /* BB fix ERRmoredata case to send resume request */
1318	TALLOC_FREE(frame);
1319	} else {
1320	DEBUG(4,("NetFileEnum2 res=%d\n", res));
1321	}
1322	} else {
1323	DEBUG(4,("NetFileEnum2 failed\n"));
1324	}
1325
1326	SAFE_FREE(rparam);
1327	SAFE_FREE(rdata);
1328
1329	return count;
1330	}
1331
1332	/****************************************************************************
1333	Call a NetShareAdd - share/export directory on remote server.
1334	****************************************************************************/
1335
1336	int cli_NetShareAdd(struct cli_state cli, RAP_SHARE_INFO_2 sinfo )
1337	{
1338	char *rparam = NULL;
1339	char *rdata = NULL;
1340	char *p;
1341	unsigned int rdrcnt,rprcnt;
1342	int res = -1;
1343	char param[WORDSIZE /* api number */
1344	+sizeof(RAP_WShareAdd_REQ) /* req string */
1345	+sizeof(RAP_SHARE_INFO_L2) /* return string */
1346	+WORDSIZE /* info level */
1347	+WORDSIZE]; /* reserved word */
1348	char data[1024];
1349	/* offset to free format string section following fixed length data. */
1350	/* will be updated by PUTSTRINGP macro and will end up with total len */
1351	int soffset = RAP_SHARENAME_LEN + 1 /* share name + pad */
1352	+ WORDSIZE /* share type */
1353	+ DWORDSIZE /* comment pointer */
1354	+ WORDSIZE /* permissions */
1355	+ WORDSIZE /* max users */
1356	+ WORDSIZE /* active users */
1357	+ DWORDSIZE /* share path */
1358	+ RAP_SPASSWD_LEN + 1; /* share password + pad */
1359
1360	memset(param,'\0',sizeof(param));
1361	/* now send a SMBtrans command with api RNetShareAdd */
1362	p = make_header(param, RAP_WshareAdd,
1363	RAP_WShareAdd_REQ, RAP_SHARE_INFO_L2);
1364	PUTWORD(p, 2); /* info level */
1365	PUTWORD(p, 0); /* reserved word 0 */
1366
1367	p = data;
1368	PUTSTRINGF(p, sinfo->share_name, RAP_SHARENAME_LEN);
1369	PUTBYTE(p, 0); /* pad byte 0 */
1370
1371	PUTWORD(p, sinfo->share_type);
1372	PUTSTRINGP(p, sinfo->comment, data, soffset);
1373	PUTWORD(p, sinfo->perms);
1374	PUTWORD(p, sinfo->maximum_users);
1375	PUTWORD(p, sinfo->active_users);
1376	PUTSTRINGP(p, sinfo->path, data, soffset);
1377	PUTSTRINGF(p, sinfo->password, RAP_SPASSWD_LEN);
1378	SCVAL(p,-1,0x0A); /* required 0x0A at end of password */
1379
1380	if (cli_api(cli,
1381	param, sizeof(param), 1024, /* Param, length, maxlen */
1382	data, soffset, sizeof(data), /* data, length, maxlen */
1383	&rparam, &rprcnt, /* return params, length */
1384	&rdata, &rdrcnt)) /* return data, length */
1385	{
1386	char *endp = rparam + rprcnt;
1387	res = GETRES(rparam, endp);
1388
1389	if (res == 0) {
1390	/* nothing to do */
1391	} else {
1392	DEBUG(4,("NetShareAdd res=%d\n", res));
1393	}
1394	} else {
1395	DEBUG(4,("NetShareAdd failed\n"));
1396	}
1397
1398	SAFE_FREE(rparam);
1399	SAFE_FREE(rdata);
1400
1401	return res;
1402	}
1403
1404	/****************************************************************************
1405	Call a NetShareDelete - unshare exported directory on remote server.
1406	****************************************************************************/
1407
1408	int cli_NetShareDelete(struct cli_state cli, const char share_name )
1409	{
1410	char *rparam = NULL;
1411	char *rdata = NULL;
1412	char *p;
1413	unsigned int rdrcnt,rprcnt;
1414	int res = -1;
1415	char param[WORDSIZE /* api number */
1416	+sizeof(RAP_WShareDel_REQ) /* req string */
1417	+1 /* no ret string */
1418	+RAP_SHARENAME_LEN /* share to del */
1419	+WORDSIZE]; /* reserved word */
1420
1421	/* now send a SMBtrans command with api RNetShareDelete */
1422	p = make_header(param, RAP_WshareDel, RAP_WShareDel_REQ, NULL);
1423	PUTSTRING(p,share_name,RAP_SHARENAME_LEN);
1424	PUTWORD(p,0); /* reserved word MBZ on input */
1425
1426	if (cli_api(cli,
1427	param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
1428	NULL, 0, 200, /* data, length, maxlen */
1429	&rparam, &rprcnt, /* return params, length */
1430	&rdata, &rdrcnt)) /* return data, length */
1431	{
1432	char *endp = rparam + rprcnt;
1433	res = GETRES(rparam, endp);
1434
1435	if (res == 0) {
1436	/* nothing to do */
1437	} else {
1438	DEBUG(4,("NetShareDelete res=%d\n", res));
1439	}
1440	} else {
1441	DEBUG(4,("NetShareDelete failed\n"));
1442	}
1443
1444	SAFE_FREE(rparam);
1445	SAFE_FREE(rdata);
1446
1447	return res;
1448	}
1449
1450	/*************************************************************************
1451	*
1452	* Function Name: cli_get_pdc_name
1453	*
1454	* PURPOSE: Remotes a NetServerEnum API call to the current server
1455	* requesting the name of a server matching the server
1456	* type of SV_TYPE_DOMAIN_CTRL (PDC).
1457	*
1458	* Dependencies: none
1459	*
1460	* Parameters:
1461	* cli - pointer to cli_state structure
1462	* workgroup - pointer to string containing name of domain
1463	* pdc_name - pointer to string that will contain PDC name
1464	* on successful return
1465	*
1466	* Returns:
1467	* True - success
1468	* False - failure
1469	*
1470	************************************************************************/
1471
1472	bool cli_get_pdc_name(struct cli_state cli, const char workgroup, char **pdc_name)
1473	{
1474	char *rparam = NULL;
1475	char *rdata = NULL;
1476	unsigned int rdrcnt,rprcnt;
1477	char *p;
1478	char param[WORDSIZE /* api number */
1479	+sizeof(RAP_NetServerEnum2_REQ) /* req string */
1480	+sizeof(RAP_SERVER_INFO_L1) /* return string */
1481	+WORDSIZE /* info level */
1482	+WORDSIZE /* buffer size */
1483	+DWORDSIZE /* server type */
1484	+RAP_MACHNAME_LEN]; /* workgroup */
1485	int count = -1;
1486	int res = -1;
1487
1488	*pdc_name = NULL;
1489
1490	/* send a SMBtrans command with api NetServerEnum */
1491	p = make_header(param, RAP_NetServerEnum2,
1492	RAP_NetServerEnum2_REQ, RAP_SERVER_INFO_L1);
1493	PUTWORD(p, 1); /* info level */
1494	PUTWORD(p, CLI_BUFFER_SIZE);
1495	PUTDWORD(p, SV_TYPE_DOMAIN_CTRL);
1496	PUTSTRING(p, workgroup, RAP_MACHNAME_LEN);
1497
1498	if (cli_api(cli,
1499	param, PTR_DIFF(p,param), 8, /* params, length, max */
1500	NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
1501	&rparam, &rprcnt, /* return params, return size */
1502	&rdata, &rdrcnt /* return data, return size */
1503	)) {
1504
1505	char *endp = rparam + rprcnt;
1506	res = GETRES(rparam, endp);
1507	cli->rap_error = res;
1508
1509	/*
1510	* We only really care to copy a name if the
1511	* API succeeded and we got back a name.
1512	*/
1513	if (cli->rap_error == 0) {
1514	p = rparam + WORDSIZE + WORDSIZE; /* skip result and converter */
1515	GETWORD(p, count, endp);
1516	p = rdata;
1517	endp = rdata + rdrcnt;
1518
1519	if (count > 0) {
1520	TALLOC_CTX *frame = talloc_stackframe();
1521	char *dcname;
1522	p += rap_getstring(frame,
1523	p,
1524	&dcname,
1525	endp);
1526	if (dcname) {
1527	*pdc_name = SMB_STRDUP(dcname);
1528	}
1529	TALLOC_FREE(frame);
1530	}
1531	} else {
1532	DEBUG(4,("cli_get_pdc_name: machine %s failed the NetServerEnum call. "
1533	"Error was : %s.\n", cli->desthost, cli_errstr(cli) ));
1534	}
1535	}
1536
1537	SAFE_FREE(rparam);
1538	SAFE_FREE(rdata);
1539
1540	return(count > 0);
1541	}
1542
1543	/*************************************************************************
1544	*
1545	* Function Name: cli_get_server_domain
1546	*
1547	* PURPOSE: Remotes a NetWkstaGetInfo API call to the current server
1548	* requesting wksta_info_10 level information to determine
1549	* the domain the server belongs to. On success, this
1550	* routine sets the server_domain field in the cli_state structure
1551	* to the server's domain name.
1552	*
1553	* Dependencies: none
1554	*
1555	* Parameters:
1556	* cli - pointer to cli_state structure
1557	*
1558	* Returns:
1559	* True - success
1560	* False - failure
1561	*
1562	* Origins: samba 2.0.6 source/libsmb/clientgen.c cli_NetServerEnum()
1563	*
1564	************************************************************************/
1565
1566	bool cli_get_server_domain(struct cli_state *cli)
1567	{
1568	char *rparam = NULL;
1569	char *rdata = NULL;
1570	unsigned int rdrcnt,rprcnt;
1571	char *p;
1572	char param[WORDSIZE /* api number */
1573	+sizeof(RAP_WWkstaGetInfo_REQ) /* req string */
1574	+sizeof(RAP_WKSTA_INFO_L10) /* return string */
1575	+WORDSIZE /* info level */
1576	+WORDSIZE]; /* buffer size */
1577	int res = -1;
1578
1579	/* send a SMBtrans command with api NetWkstaGetInfo */
1580	p = make_header(param, RAP_WWkstaGetInfo,
1581	RAP_WWkstaGetInfo_REQ, RAP_WKSTA_INFO_L10);
1582	PUTWORD(p, 10); /* info level */
1583	PUTWORD(p, CLI_BUFFER_SIZE);
1584
1585	if (cli_api(cli, param, PTR_DIFF(p,param), 8, /* params, length, max */
1586	NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
1587	&rparam, &rprcnt, /* return params, return size */
1588	&rdata, &rdrcnt)) { /* return data, return size */
1589	char *endp = rparam + rprcnt;
1590	res = GETRES(rparam, endp);
1591
1592	if (res == 0) {
1593	TALLOC_CTX *frame = talloc_stackframe();
1594	char *server_domain;
1595	int converter = 0;
1596
1597	p = rparam + WORDSIZE;
1598	GETWORD(p, converter, endp);
1599
1600	p = rdata + DWORDSIZE + DWORDSIZE; /* skip computer & user names */
1601	endp = rdata + rdrcnt;
1602	p += rap_getstringp(frame,
1603	p,
1604	&server_domain,
1605	rdata,
1606	converter,
1607	endp);
1608
1609	if (server_domain) {
1610	fstrcpy(cli->server_domain, server_domain);
1611	}
1612	TALLOC_FREE(frame);
1613	}
1614	}
1615
1616	SAFE_FREE(rparam);
1617	SAFE_FREE(rdata);
1618
1619	return(res == 0);
1620	}
1621
1622	/*************************************************************************
1623	*
1624	* Function Name: cli_get_server_type
1625	*
1626	* PURPOSE: Remotes a NetServerGetInfo API call to the current server
1627	* requesting server_info_1 level information to retrieve
1628	* the server type.
1629	*
1630	* Dependencies: none
1631	*
1632	* Parameters:
1633	* cli - pointer to cli_state structure
1634	* pstype - pointer to uint32 to contain returned server type
1635	*
1636	* Returns:
1637	* True - success
1638	* False - failure
1639	*
1640	* Origins: samba 2.0.6 source/libsmb/clientgen.c cli_NetServerEnum()
1641	*
1642	************************************************************************/
1643
1644	bool cli_get_server_type(struct cli_state cli, uint32 pstype)
1645	{
1646	char *rparam = NULL;
1647	char *rdata = NULL;
1648	unsigned int rdrcnt,rprcnt;
1649	char *p;
1650	char param[WORDSIZE /* api number */
1651	+sizeof(RAP_WserverGetInfo_REQ) /* req string */
1652	+sizeof(RAP_SERVER_INFO_L1) /* return string */
1653	+WORDSIZE /* info level */
1654	+WORDSIZE]; /* buffer size */
1655	int res = -1;
1656
1657	/* send a SMBtrans command with api NetServerGetInfo */
1658	p = make_header(param, RAP_WserverGetInfo,
1659	RAP_WserverGetInfo_REQ, RAP_SERVER_INFO_L1);
1660	PUTWORD(p, 1); /* info level */
1661	PUTWORD(p, CLI_BUFFER_SIZE);
1662
1663	if (cli_api(cli,
1664	param, PTR_DIFF(p,param), 8, /* params, length, max */
1665	NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
1666	&rparam, &rprcnt, /* return params, return size */
1667	&rdata, &rdrcnt /* return data, return size */
1668	)) {
1669	char *endp = rparam + rprcnt;
1670	res = GETRES(rparam,endp);
1671
1672	if (res == 0 \|\| res == ERRmoredata) {
1673	p = rdata;
1674	endp = rparam + rprcnt;
1675	p += 18;
1676	GETDWORD(p,*pstype,endp);
1677	*pstype &= ~SV_TYPE_LOCAL_LIST_ONLY;
1678	}
1679	}
1680
1681	SAFE_FREE(rparam);
1682	SAFE_FREE(rdata);
1683
1684	return(res == 0 \|\| res == ERRmoredata);
1685	}
1686
1687	bool cli_get_server_name(TALLOC_CTX mem_ctx, struct cli_state cli,
1688	char **servername)
1689	{
1690	char *rparam = NULL;
1691	char *rdata = NULL;
1692	unsigned int rdrcnt,rprcnt;
1693	char *p;
1694	char param[WORDSIZE /* api number */
1695	+sizeof(RAP_WserverGetInfo_REQ) /* req string */
1696	+sizeof(RAP_SERVER_INFO_L1) /* return string */
1697	+WORDSIZE /* info level */
1698	+WORDSIZE]; /* buffer size */
1699	bool res = false;
1700	char *endp;
1701	fstring tmp;
1702
1703	/* send a SMBtrans command with api NetServerGetInfo */
1704	p = make_header(param, RAP_WserverGetInfo,
1705	RAP_WserverGetInfo_REQ, RAP_SERVER_INFO_L1);
1706	PUTWORD(p, 1); /* info level */
1707	PUTWORD(p, CLI_BUFFER_SIZE);
1708
1709	if (!cli_api(cli,
1710	param, PTR_DIFF(p,param), 8, /* params, length, max */
1711	NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
1712	&rparam, &rprcnt, /* return params, return size */
1713	&rdata, &rdrcnt /* return data, return size */
1714	)) {
1715	goto failed;
1716	}
1717
1718	endp = rparam + rprcnt;
1719	if (GETRES(rparam, endp) != 0) {
1720	goto failed;
1721	}
1722
1723	if (rdrcnt < 16) {
1724	DEBUG(10, ("invalid data count %d, expected >= 16\n", rdrcnt));
1725	goto failed;
1726	}
1727
1728	if (pull_ascii(tmp, rdata, sizeof(tmp)-1, 16, STR_TERMINATE) == -1) {
1729	DEBUG(10, ("pull_ascii failed\n"));
1730	goto failed;
1731	}
1732
1733	if (!(*servername = talloc_strdup(mem_ctx, tmp))) {
1734	DEBUG(1, ("talloc_strdup failed\n"));
1735	goto failed;
1736	}
1737
1738	res = true;
1739
1740	failed:
1741	SAFE_FREE(rparam);
1742	SAFE_FREE(rdata);
1743	return res;
1744	}
1745
1746	/*************************************************************************
1747	*
1748	* Function Name: cli_ns_check_server_type
1749	*
1750	* PURPOSE: Remotes a NetServerEnum2 API call to the current server
1751	* requesting server_info_0 level information of machines
1752	* matching the given server type. If the returned server
1753	* list contains the machine name contained in cli->desthost
1754	* then we conclude the server type checks out. This routine
1755	* is useful to retrieve list of server's of a certain
1756	* type when all you have is a null session connection and
1757	* can't remote API calls such as NetWkstaGetInfo or
1758	* NetServerGetInfo.
1759	*
1760	* Dependencies: none
1761	*
1762	* Parameters:
1763	* cli - pointer to cli_state structure
1764	* workgroup - pointer to string containing domain
1765	* stype - server type
1766	*
1767	* Returns:
1768	* True - success
1769	* False - failure
1770	*
1771	************************************************************************/
1772
1773	bool cli_ns_check_server_type(struct cli_state cli, char workgroup, uint32 stype)
1774	{
1775	char *rparam = NULL;
1776	char *rdata = NULL;
1777	unsigned int rdrcnt,rprcnt;
1778	char *p;
1779	char param[WORDSIZE /* api number */
1780	+sizeof(RAP_NetServerEnum2_REQ) /* req string */
1781	+sizeof(RAP_SERVER_INFO_L0) /* return string */
1782	+WORDSIZE /* info level */
1783	+WORDSIZE /* buffer size */
1784	+DWORDSIZE /* server type */
1785	+RAP_MACHNAME_LEN]; /* workgroup */
1786	bool found_server = false;
1787	int res = -1;
1788
1789	/* send a SMBtrans command with api NetServerEnum */
1790	p = make_header(param, RAP_NetServerEnum2,
1791	RAP_NetServerEnum2_REQ, RAP_SERVER_INFO_L0);
1792	PUTWORD(p, 0); /* info level 0 */
1793	PUTWORD(p, CLI_BUFFER_SIZE);
1794	PUTDWORD(p, stype);
1795	PUTSTRING(p, workgroup, RAP_MACHNAME_LEN);
1796
1797	if (cli_api(cli,
1798	param, PTR_DIFF(p,param), 8, /* params, length, max */
1799	NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
1800	&rparam, &rprcnt, /* return params, return size */
1801	&rdata, &rdrcnt /* return data, return size */
1802	)) {
1803	char *endp = rparam + rprcnt;
1804	res = GETRES(rparam,endp);
1805	cli->rap_error = res;
1806
1807	if (res == 0 \|\| res == ERRmoredata) {
1808	int i, count = 0;
1809
1810	p = rparam + WORDSIZE + WORDSIZE;
1811	GETWORD(p, count,endp);
1812
1813	p = rdata;
1814	endp = rdata + rdrcnt;
1815	for (i = 0;i < count && p < endp;i++, p += 16) {
1816	char ret_server[RAP_MACHNAME_LEN];
1817
1818	p += rap_getstringf(p,
1819	ret_server,
1820	RAP_MACHNAME_LEN,
1821	RAP_MACHNAME_LEN,
1822	endp);
1823	if (strequal(ret_server, cli->desthost)) {
1824	found_server = true;
1825	break;
1826	}
1827	}
1828	} else {
1829	DEBUG(4,("cli_ns_check_server_type: machine %s failed the NetServerEnum call. "
1830	"Error was : %s.\n", cli->desthost, cli_errstr(cli) ));
1831	}
1832	}
1833
1834	SAFE_FREE(rparam);
1835	SAFE_FREE(rdata);
1836
1837	return found_server;
1838	}
1839
1840	/****************************************************************************
1841	Perform a NetWkstaUserLogoff.
1842	****************************************************************************/
1843
1844	bool cli_NetWkstaUserLogoff(struct cli_state cli, const char user, const char *workstation)
1845	{
1846	char *rparam = NULL;
1847	char *rdata = NULL;
1848	char *p;
1849	unsigned int rdrcnt,rprcnt;
1850	char param[WORDSIZE /* api number */
1851	+sizeof(RAP_NetWkstaUserLogoff_REQ) /* req string */
1852	+sizeof(RAP_USER_LOGOFF_INFO_L1) /* return string */
1853	+RAP_USERNAME_LEN+1 /* user name+pad */
1854	+RAP_MACHNAME_LEN /* wksta name */
1855	+WORDSIZE /* buffer size */
1856	+WORDSIZE]; /* buffer size? */
1857	char upperbuf[MAX(RAP_USERNAME_LEN,RAP_MACHNAME_LEN)];
1858	int res = -1;
1859	char *tmp = NULL;
1860
1861	memset(param, 0, sizeof(param));
1862
1863	/* send a SMBtrans command with api NetWkstaUserLogoff */
1864	p = make_header(param, RAP_WWkstaUserLogoff,
1865	RAP_NetWkstaUserLogoff_REQ, RAP_USER_LOGOFF_INFO_L1);
1866	PUTDWORD(p, 0); /* Null pointer */
1867	PUTDWORD(p, 0); /* Null pointer */
1868	strlcpy(upperbuf, user, sizeof(upperbuf));
1869	strupper_m(upperbuf);
1870	tmp = upperbuf;
1871	PUTSTRINGF(p, tmp, RAP_USERNAME_LEN);
1872	p++; /* strange format, but ok */
1873	strlcpy(upperbuf, workstation, sizeof(upperbuf));
1874	strupper_m(upperbuf);
1875	tmp = upperbuf;
1876	PUTSTRINGF(p, tmp, RAP_MACHNAME_LEN);
1877	PUTWORD(p, CLI_BUFFER_SIZE);
1878	PUTWORD(p, CLI_BUFFER_SIZE);
1879
1880	if (cli_api(cli,
1881	param, PTR_DIFF(p,param),1024, /* param, length, max */
1882	NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
1883	&rparam, &rprcnt, /* return params, return size */
1884	&rdata, &rdrcnt /* return data, return size */
1885	)) {
1886	char *endp = rparam + rprcnt;
1887	res = GETRES(rparam,endp);
1888	cli->rap_error = res;
1889
1890	if (cli->rap_error != 0) {
1891	DEBUG(4,("NetwkstaUserLogoff gave error %d\n", cli->rap_error));
1892	}
1893	}
1894
1895	SAFE_FREE(rparam);
1896	SAFE_FREE(rdata);
1897	return (cli->rap_error == 0);
1898	}
1899
1900	int cli_NetPrintQEnum(struct cli_state *cli,
1901	void (qfn)(const char,uint16,uint16,uint16,const char,const char,const char,const char,const char*,uint16,uint16),
1902	void (jfn)(uint16,const char,const char,const char,const char,uint16,uint16,const char,uint,uint,const char*))
1903	{
1904	char param[WORDSIZE /* api number */
1905	+sizeof(RAP_NetPrintQEnum_REQ) /* req string */
1906	+sizeof(RAP_PRINTQ_INFO_L2) /* return string */
1907	+WORDSIZE /* info level */
1908	+WORDSIZE /* buffer size */
1909	+sizeof(RAP_SMB_PRINT_JOB_L1)]; /* more ret data */
1910	char *p;
1911	char *rparam = NULL;
1912	char *rdata = NULL;
1913	unsigned int rprcnt, rdrcnt;
1914	int res = -1;
1915
1916	memset(param, '\0',sizeof(param));
1917	p = make_header(param, RAP_WPrintQEnum,
1918	RAP_NetPrintQEnum_REQ, RAP_PRINTQ_INFO_L2);
1919	PUTWORD(p,2); /* Info level 2 */
1920	PUTWORD(p,0xFFE0); /* Return buffer size */
1921	PUTSTRING(p, RAP_SMB_PRINT_JOB_L1, 0);
1922
1923	if (cli_api(cli,
1924	param, PTR_DIFF(p,param),1024,
1925	NULL, 0, CLI_BUFFER_SIZE,
1926	&rparam, &rprcnt,
1927	&rdata, &rdrcnt)) {
1928	char *endp = rparam + rprcnt;
1929	res = GETRES(rparam, endp);
1930	cli->rap_error = res;
1931	if (res != 0) {
1932	DEBUG(1,("NetPrintQEnum gave error %d\n", res));
1933	}
1934	}
1935
1936	if (!rdata) {
1937	DEBUG(4,("NetPrintQEnum no data returned\n"));
1938	goto out;
1939	}
1940
1941	if (res == 0 \|\| res == ERRmoredata) {
1942	TALLOC_CTX *frame = talloc_stackframe();
1943	char *endp = rparam + rprcnt;
1944	int i, converter = 0, count = 0;
1945
1946	p = rparam + WORDSIZE;
1947	GETWORD(p, converter, endp);
1948	GETWORD(p, count, endp);
1949
1950	p = rdata;
1951	endp = rdata + rdrcnt;
1952	for (i=0;i<count && p < endp;i++) {
1953	char qname[RAP_SHARENAME_LEN];
1954	char sep_file, print_proc, dest, parms, *comment;
1955	uint16_t jobcount = 0, priority = 0;
1956	uint16_t start_time = 0, until_time = 0, status = 0;
1957
1958	p += rap_getstringf(p,
1959	qname,
1960	RAP_SHARENAME_LEN,
1961	RAP_SHARENAME_LEN,
1962	endp);
1963	p++; /* pad */
1964	GETWORD(p, priority, endp);
1965	GETWORD(p, start_time, endp);
1966	GETWORD(p, until_time, endp);
1967	p += rap_getstringp(frame,
1968	p,
1969	&sep_file,
1970	rdata,
1971	converter,
1972	endp);
1973	p += rap_getstringp(frame,
1974	p,
1975	&print_proc,
1976	rdata,
1977	converter,
1978	endp);
1979	p += rap_getstringp(frame,
1980	p,
1981	&dest,
1982	rdata,
1983	converter,
1984	endp);
1985	p += rap_getstringp(frame,
1986	p,
1987	&parms,
1988	rdata,
1989	converter,
1990	endp);
1991	p += rap_getstringp(frame,
1992	p,
1993	&comment,
1994	rdata,
1995	converter,
1996	endp);
1997	GETWORD(p, status, endp);
1998	GETWORD(p, jobcount, endp);
1999
2000	if (sep_file && print_proc && dest && parms &&
2001	comment) {
2002	qfn(qname, priority, start_time, until_time, sep_file, print_proc,
2003	dest, parms, comment, status, jobcount);
2004	}
2005
2006	if (jobcount) {
2007	int j;
2008	for (j=0;j<jobcount;j++) {
2009	uint16 jid = 0, pos = 0, fsstatus = 0;
2010	char ownername[RAP_USERNAME_LEN];
2011	char notifyname[RAP_MACHNAME_LEN];
2012	char datatype[RAP_DATATYPE_LEN];
2013	char jparms, jstatus, *jcomment;
2014	unsigned int submitted = 0, jsize = 0;
2015
2016	GETWORD(p, jid, endp);
2017	p += rap_getstringf(p,
2018	ownername,
2019	RAP_USERNAME_LEN,
2020	RAP_USERNAME_LEN,
2021	endp);
2022	p++; /* pad byte */
2023	p += rap_getstringf(p,
2024	notifyname,
2025	RAP_MACHNAME_LEN,
2026	RAP_MACHNAME_LEN,
2027	endp);
2028	p += rap_getstringf(p,
2029	datatype,
2030	RAP_DATATYPE_LEN,
2031	RAP_DATATYPE_LEN,
2032	endp);
2033	p += rap_getstringp(frame,
2034	p,
2035	&jparms,
2036	rdata,
2037	converter,
2038	endp);
2039	GETWORD(p, pos, endp);
2040	GETWORD(p, fsstatus, endp);
2041	p += rap_getstringp(frame,
2042	p,
2043	&jstatus,
2044	rdata,
2045	converter,
2046	endp);
2047	GETDWORD(p, submitted, endp);
2048	GETDWORD(p, jsize, endp);
2049	p += rap_getstringp(frame,
2050	p,
2051	&jcomment,
2052	rdata,
2053	converter,
2054	endp);
2055
2056	if (jparms && jstatus && jcomment) {
2057	jfn(jid, ownername, notifyname, datatype, jparms, pos, fsstatus,
2058	jstatus, submitted, jsize, jcomment);
2059	}
2060	}
2061	}
2062	}
2063	TALLOC_FREE(frame);
2064	} else {
2065	DEBUG(4,("NetPrintQEnum res=%d\n", res));
2066	}
2067
2068	out:
2069
2070	SAFE_FREE(rparam);
2071	SAFE_FREE(rdata);
2072
2073	return res;
2074	}
2075
2076	int cli_NetPrintQGetInfo(struct cli_state cli, const char printer,
2077	void (qfn)(const char,uint16,uint16,uint16,const char,const char,const char,const char,const char*,uint16,uint16),
2078	void (jfn)(uint16,const char,const char,const char,const char,uint16,uint16,const char,uint,uint,const char*))
2079	{
2080	char param[WORDSIZE /* api number */
2081	+sizeof(RAP_NetPrintQGetInfo_REQ) /* req string */
2082	+sizeof(RAP_PRINTQ_INFO_L2) /* return string */
2083	+RAP_SHARENAME_LEN /* printer name */
2084	+WORDSIZE /* info level */
2085	+WORDSIZE /* buffer size */
2086	+sizeof(RAP_SMB_PRINT_JOB_L1)]; /* more ret data */
2087	char *p;
2088	char *rparam = NULL;
2089	char *rdata = NULL;
2090	unsigned int rprcnt, rdrcnt;
2091	int res = -1;
2092
2093	memset(param, '\0',sizeof(param));
2094	p = make_header(param, RAP_WPrintQGetInfo,
2095	RAP_NetPrintQGetInfo_REQ, RAP_PRINTQ_INFO_L2);
2096	PUTSTRING(p, printer, RAP_SHARENAME_LEN-1);
2097	PUTWORD(p, 2); /* Info level 2 */
2098	PUTWORD(p,0xFFE0); /* Return buffer size */
2099	PUTSTRING(p, RAP_SMB_PRINT_JOB_L1, 0);
2100
2101	if (cli_api(cli,
2102	param, PTR_DIFF(p,param),1024,
2103	NULL, 0, CLI_BUFFER_SIZE,
2104	&rparam, &rprcnt,
2105	&rdata, &rdrcnt)) {
2106	char *endp = rparam + rprcnt;
2107	res = GETRES(rparam, endp);
2108	cli->rap_error = res;
2109	if (res != 0) {
2110	DEBUG(1,("NetPrintQGetInfo gave error %d\n", res));
2111	}
2112	}
2113
2114	if (!rdata) {
2115	DEBUG(4,("NetPrintQGetInfo no data returned\n"));
2116	goto out;
2117	}
2118
2119	if (res == 0 \|\| res == ERRmoredata) {
2120	TALLOC_CTX *frame = talloc_stackframe();
2121	char *endp = rparam + rprcnt;
2122	int rsize = 0, converter = 0;
2123	char qname[RAP_SHARENAME_LEN];
2124	char sep_file, print_proc, dest, parms, *comment;
2125	uint16_t jobcount = 0, priority = 0;
2126	uint16_t start_time = 0, until_time = 0, status = 0;
2127
2128	p = rparam + WORDSIZE;
2129	GETWORD(p, converter, endp);
2130	GETWORD(p, rsize, endp);
2131
2132	p = rdata;
2133	endp = rdata + rdrcnt;
2134	p += rap_getstringf(p,
2135	qname,
2136	RAP_SHARENAME_LEN,
2137	RAP_SHARENAME_LEN,
2138	endp);
2139	p++; /* pad */
2140	GETWORD(p, priority, endp);
2141	GETWORD(p, start_time, endp);
2142	GETWORD(p, until_time, endp);
2143	p += rap_getstringp(frame,
2144	p,
2145	&sep_file,
2146	rdata,
2147	converter,
2148	endp);
2149	p += rap_getstringp(frame,
2150	p,
2151	&print_proc,
2152	rdata,
2153	converter,
2154	endp);
2155	p += rap_getstringp(frame,
2156	p,
2157	&dest,
2158	rdata,
2159	converter,
2160	endp);
2161	p += rap_getstringp(frame,
2162	p,
2163	&parms,
2164	rdata,
2165	converter,
2166	endp);
2167	p += rap_getstringp(frame,
2168	p,
2169	&comment,
2170	rdata,
2171	converter,
2172	endp);
2173	GETWORD(p, status, endp);
2174	GETWORD(p, jobcount, endp);
2175
2176	if (sep_file && print_proc && dest &&
2177	parms && comment) {
2178	qfn(qname, priority, start_time, until_time, sep_file, print_proc,
2179	dest, parms, comment, status, jobcount);
2180	}
2181	if (jobcount) {
2182	int j;
2183	for (j=0;(j<jobcount)&&(PTR_DIFF(p,rdata)< rsize)&&
2184	p<endp;j++) {
2185	uint16_t jid = 0, pos = 0, fsstatus = 0;
2186	char ownername[RAP_USERNAME_LEN];
2187	char notifyname[RAP_MACHNAME_LEN];
2188	char datatype[RAP_DATATYPE_LEN];
2189	char jparms, jstatus, *jcomment;
2190	unsigned int submitted = 0, jsize = 0;
2191
2192	GETWORD(p, jid, endp);
2193	p += rap_getstringf(p,
2194	ownername,
2195	RAP_USERNAME_LEN,
2196	RAP_USERNAME_LEN,
2197	endp);
2198	p++; /* pad byte */
2199	p += rap_getstringf(p,
2200	notifyname,
2201	RAP_MACHNAME_LEN,
2202	RAP_MACHNAME_LEN,
2203	endp);
2204	p += rap_getstringf(p,
2205	datatype,
2206	RAP_DATATYPE_LEN,
2207	RAP_DATATYPE_LEN,
2208	endp);
2209	p += rap_getstringp(frame,
2210	p,
2211	&jparms,
2212	rdata,
2213	converter,
2214	endp);
2215	GETWORD(p, pos,endp);
2216	GETWORD(p, fsstatus,endp);
2217	p += rap_getstringp(frame,
2218	p,
2219	&jstatus,
2220	rdata,
2221	converter,
2222	endp);
2223	GETDWORD(p, submitted,endp);
2224	GETDWORD(p, jsize,endp);
2225	p += rap_getstringp(frame,
2226	p,
2227	&jcomment,
2228	rdata,
2229	converter,
2230	endp);
2231
2232	if (jparms && jstatus && jcomment) {
2233	jfn(jid, ownername, notifyname, datatype, jparms, pos, fsstatus,
2234	jstatus, submitted, jsize, jcomment);
2235	}
2236	}
2237	}
2238	TALLOC_FREE(frame);
2239	} else {
2240	DEBUG(4,("NetPrintQGetInfo res=%d\n", res));
2241	}
2242
2243	out:
2244
2245	SAFE_FREE(rparam);
2246	SAFE_FREE(rdata);
2247
2248	return res;
2249	}
2250
2251	/****************************************************************************
2252	Call a NetServiceEnum - list running services on a different host.
2253	****************************************************************************/
2254
2255	int cli_RNetServiceEnum(struct cli_state cli, void (fn)(const char , const char , void ), void state)
2256	{
2257	char param[WORDSIZE /* api number */
2258	+sizeof(RAP_NetServiceEnum_REQ) /* parm string */
2259	+sizeof(RAP_SERVICE_INFO_L2) /* return string */
2260	+WORDSIZE /* info level */
2261	+WORDSIZE]; /* buffer size */
2262	char *p;
2263	char *rparam = NULL;
2264	char *rdata = NULL;
2265	unsigned int rprcnt, rdrcnt;
2266	int res = -1;
2267
2268	memset(param, '\0', sizeof(param));
2269	p = make_header(param, RAP_WServiceEnum,
2270	RAP_NetServiceEnum_REQ, RAP_SERVICE_INFO_L2);
2271	PUTWORD(p,2); /* Info level 2 */
2272	PUTWORD(p,0xFFE0); /* Return buffer size */
2273
2274	if (cli_api(cli,
2275	param, PTR_DIFF(p,param),8,
2276	NULL, 0, 0xFFE0 /* data area size */,
2277	&rparam, &rprcnt,
2278	&rdata, &rdrcnt)) {
2279	char *endp = rparam + rprcnt;
2280	res = GETRES(rparam, endp);
2281	cli->rap_error = res;
2282	if(cli->rap_error == 234) {
2283	DEBUG(1,("Not all service names were returned (such as those longer than 15 characters)\n"));
2284	} else if (cli->rap_error != 0) {
2285	DEBUG(1,("NetServiceEnum gave error %d\n", cli->rap_error));
2286	}
2287	}
2288
2289	if (!rdata) {
2290	DEBUG(4,("NetServiceEnum no data returned\n"));
2291	goto out;
2292	}
2293
2294	if (res == 0 \|\| res == ERRmoredata) {
2295	char *endp = rparam + rprcnt;
2296	int i, count = 0;
2297
2298	p = rparam + WORDSIZE + WORDSIZE; /* skip result and converter */
2299	GETWORD(p, count,endp);
2300
2301	endp = rdata + rdrcnt;
2302	for (i=0,p=rdata;i<count && p < endp;i++) {
2303	char comment[RAP_SRVCCMNT_LEN];
2304	char servicename[RAP_SRVCNAME_LEN];
2305
2306	p += rap_getstringf(p,
2307	servicename,
2308	RAP_SRVCNAME_LEN,
2309	RAP_SRVCNAME_LEN,
2310	endp);
2311	p+=8; /* pass status words */
2312	p += rap_getstringf(p,
2313	comment,
2314	RAP_SRVCCMNT_LEN,
2315	RAP_SRVCCMNT_LEN,
2316	endp);
2317
2318	if (servicename[0]) {
2319	fn(servicename, comment, cli); /* BB add status too */
2320	}
2321	}
2322	} else {
2323	DEBUG(4,("NetServiceEnum res=%d\n", res));
2324	}
2325
2326	out:
2327
2328	SAFE_FREE(rparam);
2329	SAFE_FREE(rdata);
2330
2331	return res;
2332	}
2333
2334	/****************************************************************************
2335	Call a NetSessionEnum - list workstations with sessions to an SMB server.
2336	****************************************************************************/
2337
2338	int cli_NetSessionEnum(struct cli_state cli, void (fn)(char , char , uint16, uint16, uint16, uint, uint, uint, char *))
2339	{
2340	char param[WORDSIZE /* api number */
2341	+sizeof(RAP_NetSessionEnum_REQ) /* parm string */
2342	+sizeof(RAP_SESSION_INFO_L2) /* return string */
2343	+WORDSIZE /* info level */
2344	+WORDSIZE]; /* buffer size */
2345	char *p;
2346	char *rparam = NULL;
2347	char *rdata = NULL;
2348	unsigned int rprcnt, rdrcnt;
2349	int res = -1;
2350
2351	memset(param, '\0', sizeof(param));
2352	p = make_header(param, RAP_WsessionEnum,
2353	RAP_NetSessionEnum_REQ, RAP_SESSION_INFO_L2);
2354	PUTWORD(p,2); /* Info level 2 */
2355	PUTWORD(p,0xFF); /* Return buffer size */
2356
2357	if (cli_api(cli,
2358	param, PTR_DIFF(p,param),8,
2359	NULL, 0, CLI_BUFFER_SIZE,
2360	&rparam, &rprcnt,
2361	&rdata, &rdrcnt)) {
2362	char *endp = rparam + rprcnt;
2363	res = GETRES(rparam, endp);
2364	cli->rap_error = res;
2365	if (res != 0) {
2366	DEBUG(1,("NetSessionEnum gave error %d\n", res));
2367	}
2368	}
2369
2370	if (!rdata) {
2371	DEBUG(4,("NetSesssionEnum no data returned\n"));
2372	goto out;
2373	}
2374
2375	if (res == 0 \|\| res == ERRmoredata) {
2376	TALLOC_CTX *frame = talloc_stackframe();
2377	char *endp = rparam + rprcnt;
2378	int i, converter = 0, count = 0;
2379
2380	p = rparam + WORDSIZE;
2381	GETWORD(p, converter, endp);
2382	GETWORD(p, count, endp);
2383
2384	endp = rdata + rdrcnt;
2385	for (i=0,p=rdata;i<count && p < endp;i++) {
2386	char wsname, username, *clitype_name;
2387	uint16_t num_conns = 0, num_opens = 0, num_users = 0;
2388	unsigned int sess_time = 0, idle_time = 0, user_flags = 0;
2389
2390	p += rap_getstringp(frame,
2391	p,
2392	&wsname,
2393	rdata,
2394	converter,
2395	endp);
2396	p += rap_getstringp(frame,
2397	p,
2398	&username,
2399	rdata,
2400	converter,
2401	endp);
2402	GETWORD(p, num_conns, endp);
2403	GETWORD(p, num_opens, endp);
2404	GETWORD(p, num_users, endp);
2405	GETDWORD(p, sess_time, endp);
2406	GETDWORD(p, idle_time, endp);
2407	GETDWORD(p, user_flags, endp);
2408	p += rap_getstringp(frame,
2409	p,
2410	&clitype_name,
2411	rdata,
2412	converter,
2413	endp);
2414
2415	if (wsname && username && clitype_name) {
2416	fn(wsname, username, num_conns, num_opens, num_users, sess_time,
2417	idle_time, user_flags, clitype_name);
2418	}
2419	}
2420	TALLOC_FREE(frame);
2421	} else {
2422	DEBUG(4,("NetSessionEnum res=%d\n", res));
2423	}
2424
2425	out:
2426
2427	SAFE_FREE(rparam);
2428	SAFE_FREE(rdata);
2429
2430	return res;
2431	}
2432
2433	/****************************************************************************
2434	Call a NetSessionGetInfo - get information about other session to an SMB server.
2435	****************************************************************************/
2436
2437	int cli_NetSessionGetInfo(struct cli_state cli, const char workstation,
2438	void (fn)(const char , const char , uint16, uint16, uint16, uint, uint, uint, const char ))
2439	{
2440	char param[WORDSIZE /* api number */
2441	+sizeof(RAP_NetSessionGetInfo_REQ) /* req string */
2442	+sizeof(RAP_SESSION_INFO_L2) /* return string */
2443	+RAP_MACHNAME_LEN /* wksta name */
2444	+WORDSIZE /* info level */
2445	+WORDSIZE]; /* buffer size */
2446	char *p;
2447	char *rparam = NULL;
2448	char *rdata = NULL;
2449	unsigned int rprcnt, rdrcnt;
2450	char *endp;
2451	int res = -1;
2452
2453	memset(param, '\0', sizeof(param));
2454	p = make_header(param, RAP_WsessionGetInfo,
2455	RAP_NetSessionGetInfo_REQ, RAP_SESSION_INFO_L2);
2456	PUTSTRING(p, workstation, RAP_MACHNAME_LEN-1);
2457	PUTWORD(p,2); /* Info level 2 */
2458	PUTWORD(p,0xFF); /* Return buffer size */
2459
2460	if (cli_api(cli,
2461	param, PTR_DIFF(p,param),PTR_DIFF(p,param),
2462	NULL, 0, CLI_BUFFER_SIZE,
2463	&rparam, &rprcnt,
2464	&rdata, &rdrcnt)) {
2465	endp = rparam + rprcnt;
2466	res = GETRES(rparam, endp);
2467	cli->rap_error = res;
2468	if (cli->rap_error != 0) {
2469	DEBUG(1,("NetSessionGetInfo gave error %d\n", cli->rap_error));
2470	}
2471	}
2472
2473	if (!rdata) {
2474	DEBUG(4,("NetSessionGetInfo no data returned\n"));
2475	goto out;
2476	}
2477
2478	endp = rparam + rprcnt;
2479	res = GETRES(rparam, endp);
2480
2481	if (res == 0 \|\| res == ERRmoredata) {
2482	TALLOC_CTX *frame = talloc_stackframe();
2483	int converter = 0;
2484	char wsname, username, *clitype_name;
2485	uint16_t num_conns = 0, num_opens = 0, num_users = 0;
2486	unsigned int sess_time = 0, idle_time = 0, user_flags = 0;
2487
2488	p = rparam + WORDSIZE;
2489	GETWORD(p, converter,endp);
2490	p += WORDSIZE; /* skip rsize */
2491
2492	p = rdata;
2493	endp = rdata + rdrcnt;
2494	p += rap_getstringp(frame,
2495	p,
2496	&wsname,
2497	rdata,
2498	converter,
2499	endp);
2500	p += rap_getstringp(frame,
2501	p,
2502	&username,
2503	rdata,
2504	converter,
2505	endp);
2506	GETWORD(p, num_conns, endp);
2507	GETWORD(p, num_opens, endp);
2508	GETWORD(p, num_users, endp);
2509	GETDWORD(p, sess_time, endp);
2510	GETDWORD(p, idle_time, endp);
2511	GETDWORD(p, user_flags, endp);
2512	p += rap_getstringp(frame,
2513	p,
2514	&clitype_name,
2515	rdata,
2516	converter,
2517	endp);
2518
2519	if (wsname && username && clitype_name) {
2520	fn(wsname, username, num_conns, num_opens, num_users, sess_time,
2521	idle_time, user_flags, clitype_name);
2522	}
2523	TALLOC_FREE(frame);
2524	} else {
2525	DEBUG(4,("NetSessionGetInfo res=%d\n", res));
2526	}
2527
2528	out:
2529
2530	SAFE_FREE(rparam);
2531	SAFE_FREE(rdata);
2532
2533	return res;
2534	}
2535
2536	/****************************************************************************
2537	Call a NetSessionDel - close a session to an SMB server.
2538	****************************************************************************/
2539
2540	int cli_NetSessionDel(struct cli_state cli, const char workstation)
2541	{
2542	char param[WORDSIZE /* api number */
2543	+sizeof(RAP_NetSessionDel_REQ) /* req string */
2544	+1 /* no return string */
2545	+RAP_MACHNAME_LEN /* workstation name */
2546	+WORDSIZE]; /* reserved (0) */
2547	char *p;
2548	char *rparam = NULL;
2549	char *rdata = NULL;
2550	unsigned int rprcnt, rdrcnt;
2551	int res = -1;
2552
2553	memset(param, '\0', sizeof(param));
2554	p = make_header(param, RAP_WsessionDel, RAP_NetSessionDel_REQ, NULL);
2555	PUTSTRING(p, workstation, RAP_MACHNAME_LEN-1);
2556	PUTWORD(p,0); /* reserved word of 0 */
2557
2558	if (cli_api(cli,
2559	param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
2560	NULL, 0, 200, /* data, length, maxlen */
2561	&rparam, &rprcnt, /* return params, length */
2562	&rdata, &rdrcnt)) /* return data, length */
2563	{
2564	char *endp = rparam + rprcnt;
2565	res = GETRES(rparam, endp);
2566	cli->rap_error = res;
2567
2568	if (res == 0) {
2569	/* nothing to do */
2570	} else {
2571	DEBUG(4,("NetFileClose2 res=%d\n", res));
2572	}
2573	} else {
2574	res = -1;
2575	DEBUG(4,("NetFileClose2 failed\n"));
2576	}
2577
2578	SAFE_FREE(rparam);
2579	SAFE_FREE(rdata);
2580
2581	return res;
2582	}
2583
2584	int cli_NetConnectionEnum(struct cli_state cli, const char qualifier,
2585	void (*fn)(uint16_t conid, uint16_t contype,
2586	uint16_t numopens, uint16_t numusers,
2587	uint32_t contime, const char *username,
2588	const char *netname))
2589	{
2590	char param[WORDSIZE /* api number */
2591	+sizeof(RAP_NetConnectionEnum_REQ) /* req string */
2592	+sizeof(RAP_CONNECTION_INFO_L1) /* return string */
2593	+RAP_MACHNAME_LEN /* wksta name */
2594	+WORDSIZE /* info level */
2595	+WORDSIZE]; /* buffer size */
2596	char *p;
2597	char *rparam = NULL;
2598	char *rdata = NULL;
2599	unsigned int rprcnt, rdrcnt;
2600	int res = -1;
2601
2602	memset(param, '\0', sizeof(param));
2603	p = make_header(param, RAP_WconnectionEnum,
2604	RAP_NetConnectionEnum_REQ, RAP_CONNECTION_INFO_L1);
2605	PUTSTRING(p, qualifier, RAP_MACHNAME_LEN-1);/* Workstation name */
2606	PUTWORD(p,1); /* Info level 1 */
2607	PUTWORD(p,0xFFE0); /* Return buffer size */
2608
2609	if (cli_api(cli,
2610	param, PTR_DIFF(p,param),PTR_DIFF(p,param),
2611	NULL, 0, CLI_BUFFER_SIZE,
2612	&rparam, &rprcnt,
2613	&rdata, &rdrcnt)) {
2614	char *endp = rparam + rprcnt;
2615	res = GETRES(rparam, endp);
2616	cli->rap_error = res;
2617	if (res != 0) {
2618	DEBUG(1,("NetConnectionEnum gave error %d\n", res));
2619	}
2620	}
2621
2622	if (!rdata) {
2623	DEBUG(4,("NetConnectionEnum no data returned\n"));
2624	goto out;
2625	}
2626
2627	if (res == 0 \|\| res == ERRmoredata) {
2628	TALLOC_CTX *frame = talloc_stackframe();
2629	char *endp = rparam + rprcnt;
2630	int i, converter = 0, count = 0;
2631
2632	p = rparam + WORDSIZE;
2633	GETWORD(p, converter, endp);
2634	GETWORD(p, count, endp);
2635
2636	endp = rdata + rdrcnt;
2637	for (i=0,p=rdata;i<count && p < endp;i++) {
2638	char netname, username;
2639	uint16_t conn_id = 0, conn_type = 0, num_opens = 0, num_users = 0;
2640	unsigned int conn_time = 0;
2641
2642	GETWORD(p,conn_id, endp);
2643	GETWORD(p,conn_type, endp);
2644	GETWORD(p,num_opens, endp);
2645	GETWORD(p,num_users, endp);
2646	GETDWORD(p,conn_time, endp);
2647	p += rap_getstringp(frame,
2648	p,
2649	&username,
2650	rdata,
2651	converter,
2652	endp);
2653	p += rap_getstringp(frame,
2654	p,
2655	&netname,
2656	rdata,
2657	converter,
2658	endp);
2659
2660	if (username && netname) {
2661	fn(conn_id, conn_type, num_opens, num_users, conn_time,
2662	username, netname);
2663	}
2664	}
2665	TALLOC_FREE(frame);
2666	} else {
2667	DEBUG(4,("NetConnectionEnum res=%d\n", res));
2668	}
2669
2670	out:
2671
2672	SAFE_FREE(rdata);
2673	SAFE_FREE(rparam);
2674	return res;
2675	}

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

Download in other formats: