Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: branches/samba-3.2.x/source/libsmb/clirap2.c@ 206

Visit:

Last change on this file since 206 was 133, checked in by Paul Smedley, 17 years ago
Update trunk to 3.2.0pre3
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
1860	memset(param, 0, sizeof(param));
1861
1862	/* send a SMBtrans command with api NetWkstaUserLogoff */
1863	p = make_header(param, RAP_WWkstaUserLogoff,
1864	RAP_NetWkstaUserLogoff_REQ, RAP_USER_LOGOFF_INFO_L1);
1865	PUTDWORD(p, 0); /* Null pointer */
1866	PUTDWORD(p, 0); /* Null pointer */
1867	strlcpy(upperbuf, user, sizeof(upperbuf));
1868	strupper_m(upperbuf);
1869	PUTSTRINGF(p, upperbuf, RAP_USERNAME_LEN);
1870	p++; /* strange format, but ok */
1871	strlcpy(upperbuf, workstation, sizeof(upperbuf));
1872	strupper_m(upperbuf);
1873	PUTSTRINGF(p, upperbuf, RAP_MACHNAME_LEN);
1874	PUTWORD(p, CLI_BUFFER_SIZE);
1875	PUTWORD(p, CLI_BUFFER_SIZE);
1876
1877	if (cli_api(cli,
1878	param, PTR_DIFF(p,param),1024, /* param, length, max */
1879	NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
1880	&rparam, &rprcnt, /* return params, return size */
1881	&rdata, &rdrcnt /* return data, return size */
1882	)) {
1883	char *endp = rparam + rprcnt;
1884	res = GETRES(rparam,endp);
1885	cli->rap_error = res;
1886
1887	if (cli->rap_error != 0) {
1888	DEBUG(4,("NetwkstaUserLogoff gave error %d\n", cli->rap_error));
1889	}
1890	}
1891
1892	SAFE_FREE(rparam);
1893	SAFE_FREE(rdata);
1894	return (cli->rap_error == 0);
1895	}
1896
1897	int cli_NetPrintQEnum(struct cli_state *cli,
1898	void (qfn)(const char,uint16,uint16,uint16,const char,const char,const char,const char,const char*,uint16,uint16),
1899	void (jfn)(uint16,const char,const char,const char,const char,uint16,uint16,const char,uint,uint,const char*))
1900	{
1901	char param[WORDSIZE /* api number */
1902	+sizeof(RAP_NetPrintQEnum_REQ) /* req string */
1903	+sizeof(RAP_PRINTQ_INFO_L2) /* return string */
1904	+WORDSIZE /* info level */
1905	+WORDSIZE /* buffer size */
1906	+sizeof(RAP_SMB_PRINT_JOB_L1)]; /* more ret data */
1907	char *p;
1908	char *rparam = NULL;
1909	char *rdata = NULL;
1910	unsigned int rprcnt, rdrcnt;
1911	int res = -1;
1912
1913	memset(param, '\0',sizeof(param));
1914	p = make_header(param, RAP_WPrintQEnum,
1915	RAP_NetPrintQEnum_REQ, RAP_PRINTQ_INFO_L2);
1916	PUTWORD(p,2); /* Info level 2 */
1917	PUTWORD(p,0xFFE0); /* Return buffer size */
1918	PUTSTRING(p, RAP_SMB_PRINT_JOB_L1, 0);
1919
1920	if (cli_api(cli,
1921	param, PTR_DIFF(p,param),1024,
1922	NULL, 0, CLI_BUFFER_SIZE,
1923	&rparam, &rprcnt,
1924	&rdata, &rdrcnt)) {
1925	char *endp = rparam + rprcnt;
1926	res = GETRES(rparam, endp);
1927	cli->rap_error = res;
1928	if (res != 0) {
1929	DEBUG(1,("NetPrintQEnum gave error %d\n", res));
1930	}
1931	}
1932
1933	if (!rdata) {
1934	DEBUG(4,("NetPrintQEnum no data returned\n"));
1935	goto out;
1936	}
1937
1938	if (res == 0 \|\| res == ERRmoredata) {
1939	TALLOC_CTX *frame = talloc_stackframe();
1940	char *endp = rparam + rprcnt;
1941	int i, converter = 0, count = 0;
1942
1943	p = rparam + WORDSIZE;
1944	GETWORD(p, converter, endp);
1945	GETWORD(p, count, endp);
1946
1947	p = rdata;
1948	endp = rdata + rdrcnt;
1949	for (i=0;i<count && p < endp;i++) {
1950	char qname[RAP_SHARENAME_LEN];
1951	char sep_file, print_proc, dest, parms, *comment;
1952	uint16_t jobcount = 0, priority = 0;
1953	uint16_t start_time = 0, until_time = 0, status = 0;
1954
1955	p += rap_getstringf(p,
1956	qname,
1957	RAP_SHARENAME_LEN,
1958	RAP_SHARENAME_LEN,
1959	endp);
1960	p++; /* pad */
1961	GETWORD(p, priority, endp);
1962	GETWORD(p, start_time, endp);
1963	GETWORD(p, until_time, endp);
1964	p += rap_getstringp(frame,
1965	p,
1966	&sep_file,
1967	rdata,
1968	converter,
1969	endp);
1970	p += rap_getstringp(frame,
1971	p,
1972	&print_proc,
1973	rdata,
1974	converter,
1975	endp);
1976	p += rap_getstringp(frame,
1977	p,
1978	&dest,
1979	rdata,
1980	converter,
1981	endp);
1982	p += rap_getstringp(frame,
1983	p,
1984	&parms,
1985	rdata,
1986	converter,
1987	endp);
1988	p += rap_getstringp(frame,
1989	p,
1990	&comment,
1991	rdata,
1992	converter,
1993	endp);
1994	GETWORD(p, status, endp);
1995	GETWORD(p, jobcount, endp);
1996
1997	if (sep_file && print_proc && dest && parms &&
1998	comment) {
1999	qfn(qname, priority, start_time, until_time, sep_file, print_proc,
2000	dest, parms, comment, status, jobcount);
2001	}
2002
2003	if (jobcount) {
2004	int j;
2005	for (j=0;j<jobcount;j++) {
2006	uint16 jid = 0, pos = 0, fsstatus = 0;
2007	char ownername[RAP_USERNAME_LEN];
2008	char notifyname[RAP_MACHNAME_LEN];
2009	char datatype[RAP_DATATYPE_LEN];
2010	char jparms, jstatus, *jcomment;
2011	unsigned int submitted = 0, jsize = 0;
2012
2013	GETWORD(p, jid, endp);
2014	p += rap_getstringf(p,
2015	ownername,
2016	RAP_USERNAME_LEN,
2017	RAP_USERNAME_LEN,
2018	endp);
2019	p++; /* pad byte */
2020	p += rap_getstringf(p,
2021	notifyname,
2022	RAP_MACHNAME_LEN,
2023	RAP_MACHNAME_LEN,
2024	endp);
2025	p += rap_getstringf(p,
2026	datatype,
2027	RAP_DATATYPE_LEN,
2028	RAP_DATATYPE_LEN,
2029	endp);
2030	p += rap_getstringp(frame,
2031	p,
2032	&jparms,
2033	rdata,
2034	converter,
2035	endp);
2036	GETWORD(p, pos, endp);
2037	GETWORD(p, fsstatus, endp);
2038	p += rap_getstringp(frame,
2039	p,
2040	&jstatus,
2041	rdata,
2042	converter,
2043	endp);
2044	GETDWORD(p, submitted, endp);
2045	GETDWORD(p, jsize, endp);
2046	p += rap_getstringp(frame,
2047	p,
2048	&jcomment,
2049	rdata,
2050	converter,
2051	endp);
2052
2053	if (jparms && jstatus && jcomment) {
2054	jfn(jid, ownername, notifyname, datatype, jparms, pos, fsstatus,
2055	jstatus, submitted, jsize, jcomment);
2056	}
2057	}
2058	}
2059	}
2060	TALLOC_FREE(frame);
2061	} else {
2062	DEBUG(4,("NetPrintQEnum res=%d\n", res));
2063	}
2064
2065	out:
2066
2067	SAFE_FREE(rparam);
2068	SAFE_FREE(rdata);
2069
2070	return res;
2071	}
2072
2073	int cli_NetPrintQGetInfo(struct cli_state cli, const char printer,
2074	void (qfn)(const char,uint16,uint16,uint16,const char,const char,const char,const char,const char*,uint16,uint16),
2075	void (jfn)(uint16,const char,const char,const char,const char,uint16,uint16,const char,uint,uint,const char*))
2076	{
2077	char param[WORDSIZE /* api number */
2078	+sizeof(RAP_NetPrintQGetInfo_REQ) /* req string */
2079	+sizeof(RAP_PRINTQ_INFO_L2) /* return string */
2080	+RAP_SHARENAME_LEN /* printer name */
2081	+WORDSIZE /* info level */
2082	+WORDSIZE /* buffer size */
2083	+sizeof(RAP_SMB_PRINT_JOB_L1)]; /* more ret data */
2084	char *p;
2085	char *rparam = NULL;
2086	char *rdata = NULL;
2087	unsigned int rprcnt, rdrcnt;
2088	int res = -1;
2089
2090	memset(param, '\0',sizeof(param));
2091	p = make_header(param, RAP_WPrintQGetInfo,
2092	RAP_NetPrintQGetInfo_REQ, RAP_PRINTQ_INFO_L2);
2093	PUTSTRING(p, printer, RAP_SHARENAME_LEN-1);
2094	PUTWORD(p, 2); /* Info level 2 */
2095	PUTWORD(p,0xFFE0); /* Return buffer size */
2096	PUTSTRING(p, RAP_SMB_PRINT_JOB_L1, 0);
2097
2098	if (cli_api(cli,
2099	param, PTR_DIFF(p,param),1024,
2100	NULL, 0, CLI_BUFFER_SIZE,
2101	&rparam, &rprcnt,
2102	&rdata, &rdrcnt)) {
2103	char *endp = rparam + rprcnt;
2104	res = GETRES(rparam, endp);
2105	cli->rap_error = res;
2106	if (res != 0) {
2107	DEBUG(1,("NetPrintQGetInfo gave error %d\n", res));
2108	}
2109	}
2110
2111	if (!rdata) {
2112	DEBUG(4,("NetPrintQGetInfo no data returned\n"));
2113	goto out;
2114	}
2115
2116	if (res == 0 \|\| res == ERRmoredata) {
2117	TALLOC_CTX *frame = talloc_stackframe();
2118	char *endp = rparam + rprcnt;
2119	int rsize = 0, converter = 0;
2120	char qname[RAP_SHARENAME_LEN];
2121	char sep_file, print_proc, dest, parms, *comment;
2122	uint16_t jobcount = 0, priority = 0;
2123	uint16_t start_time = 0, until_time = 0, status = 0;
2124
2125	p = rparam + WORDSIZE;
2126	GETWORD(p, converter, endp);
2127	GETWORD(p, rsize, endp);
2128
2129	p = rdata;
2130	endp = rdata + rdrcnt;
2131	p += rap_getstringf(p,
2132	qname,
2133	RAP_SHARENAME_LEN,
2134	RAP_SHARENAME_LEN,
2135	endp);
2136	p++; /* pad */
2137	GETWORD(p, priority, endp);
2138	GETWORD(p, start_time, endp);
2139	GETWORD(p, until_time, endp);
2140	p += rap_getstringp(frame,
2141	p,
2142	&sep_file,
2143	rdata,
2144	converter,
2145	endp);
2146	p += rap_getstringp(frame,
2147	p,
2148	&print_proc,
2149	rdata,
2150	converter,
2151	endp);
2152	p += rap_getstringp(frame,
2153	p,
2154	&dest,
2155	rdata,
2156	converter,
2157	endp);
2158	p += rap_getstringp(frame,
2159	p,
2160	&parms,
2161	rdata,
2162	converter,
2163	endp);
2164	p += rap_getstringp(frame,
2165	p,
2166	&comment,
2167	rdata,
2168	converter,
2169	endp);
2170	GETWORD(p, status, endp);
2171	GETWORD(p, jobcount, endp);
2172
2173	if (sep_file && print_proc && dest &&
2174	parms && comment) {
2175	qfn(qname, priority, start_time, until_time, sep_file, print_proc,
2176	dest, parms, comment, status, jobcount);
2177	}
2178	if (jobcount) {
2179	int j;
2180	for (j=0;(j<jobcount)&&(PTR_DIFF(p,rdata)< rsize)&&
2181	p<endp;j++) {
2182	uint16_t jid = 0, pos = 0, fsstatus = 0;
2183	char ownername[RAP_USERNAME_LEN];
2184	char notifyname[RAP_MACHNAME_LEN];
2185	char datatype[RAP_DATATYPE_LEN];
2186	char jparms, jstatus, *jcomment;
2187	unsigned int submitted = 0, jsize = 0;
2188
2189	GETWORD(p, jid, endp);
2190	p += rap_getstringf(p,
2191	ownername,
2192	RAP_USERNAME_LEN,
2193	RAP_USERNAME_LEN,
2194	endp);
2195	p++; /* pad byte */
2196	p += rap_getstringf(p,
2197	notifyname,
2198	RAP_MACHNAME_LEN,
2199	RAP_MACHNAME_LEN,
2200	endp);
2201	p += rap_getstringf(p,
2202	datatype,
2203	RAP_DATATYPE_LEN,
2204	RAP_DATATYPE_LEN,
2205	endp);
2206	p += rap_getstringp(frame,
2207	p,
2208	&jparms,
2209	rdata,
2210	converter,
2211	endp);
2212	GETWORD(p, pos,endp);
2213	GETWORD(p, fsstatus,endp);
2214	p += rap_getstringp(frame,
2215	p,
2216	&jstatus,
2217	rdata,
2218	converter,
2219	endp);
2220	GETDWORD(p, submitted,endp);
2221	GETDWORD(p, jsize,endp);
2222	p += rap_getstringp(frame,
2223	p,
2224	&jcomment,
2225	rdata,
2226	converter,
2227	endp);
2228
2229	if (jparms && jstatus && jcomment) {
2230	jfn(jid, ownername, notifyname, datatype, jparms, pos, fsstatus,
2231	jstatus, submitted, jsize, jcomment);
2232	}
2233	}
2234	}
2235	TALLOC_FREE(frame);
2236	} else {
2237	DEBUG(4,("NetPrintQGetInfo res=%d\n", res));
2238	}
2239
2240	out:
2241
2242	SAFE_FREE(rparam);
2243	SAFE_FREE(rdata);
2244
2245	return res;
2246	}
2247
2248	/****************************************************************************
2249	Call a NetServiceEnum - list running services on a different host.
2250	****************************************************************************/
2251
2252	int cli_RNetServiceEnum(struct cli_state cli, void (fn)(const char , const char , void ), void state)
2253	{
2254	char param[WORDSIZE /* api number */
2255	+sizeof(RAP_NetServiceEnum_REQ) /* parm string */
2256	+sizeof(RAP_SERVICE_INFO_L2) /* return string */
2257	+WORDSIZE /* info level */
2258	+WORDSIZE]; /* buffer size */
2259	char *p;
2260	char *rparam = NULL;
2261	char *rdata = NULL;
2262	unsigned int rprcnt, rdrcnt;
2263	int res = -1;
2264
2265	memset(param, '\0', sizeof(param));
2266	p = make_header(param, RAP_WServiceEnum,
2267	RAP_NetServiceEnum_REQ, RAP_SERVICE_INFO_L2);
2268	PUTWORD(p,2); /* Info level 2 */
2269	PUTWORD(p,0xFFE0); /* Return buffer size */
2270
2271	if (cli_api(cli,
2272	param, PTR_DIFF(p,param),8,
2273	NULL, 0, 0xFFE0 /* data area size */,
2274	&rparam, &rprcnt,
2275	&rdata, &rdrcnt)) {
2276	char *endp = rparam + rprcnt;
2277	res = GETRES(rparam, endp);
2278	cli->rap_error = res;
2279	if(cli->rap_error == 234) {
2280	DEBUG(1,("Not all service names were returned (such as those longer than 15 characters)\n"));
2281	} else if (cli->rap_error != 0) {
2282	DEBUG(1,("NetServiceEnum gave error %d\n", cli->rap_error));
2283	}
2284	}
2285
2286	if (!rdata) {
2287	DEBUG(4,("NetServiceEnum no data returned\n"));
2288	goto out;
2289	}
2290
2291	if (res == 0 \|\| res == ERRmoredata) {
2292	char *endp = rparam + rprcnt;
2293	int i, count = 0;
2294
2295	p = rparam + WORDSIZE + WORDSIZE; /* skip result and converter */
2296	GETWORD(p, count,endp);
2297
2298	endp = rdata + rdrcnt;
2299	for (i=0,p=rdata;i<count && p < endp;i++) {
2300	char comment[RAP_SRVCCMNT_LEN];
2301	char servicename[RAP_SRVCNAME_LEN];
2302
2303	p += rap_getstringf(p,
2304	servicename,
2305	RAP_SRVCNAME_LEN,
2306	RAP_SRVCNAME_LEN,
2307	endp);
2308	p+=8; /* pass status words */
2309	p += rap_getstringf(p,
2310	comment,
2311	RAP_SRVCCMNT_LEN,
2312	RAP_SRVCCMNT_LEN,
2313	endp);
2314
2315	if (servicename[0]) {
2316	fn(servicename, comment, cli); /* BB add status too */
2317	}
2318	}
2319	} else {
2320	DEBUG(4,("NetServiceEnum res=%d\n", res));
2321	}
2322
2323	out:
2324
2325	SAFE_FREE(rparam);
2326	SAFE_FREE(rdata);
2327
2328	return res;
2329	}
2330
2331	/****************************************************************************
2332	Call a NetSessionEnum - list workstations with sessions to an SMB server.
2333	****************************************************************************/
2334
2335	int cli_NetSessionEnum(struct cli_state cli, void (fn)(char , char , uint16, uint16, uint16, uint, uint, uint, char *))
2336	{
2337	char param[WORDSIZE /* api number */
2338	+sizeof(RAP_NetSessionEnum_REQ) /* parm string */
2339	+sizeof(RAP_SESSION_INFO_L2) /* return string */
2340	+WORDSIZE /* info level */
2341	+WORDSIZE]; /* buffer size */
2342	char *p;
2343	char *rparam = NULL;
2344	char *rdata = NULL;
2345	unsigned int rprcnt, rdrcnt;
2346	int res = -1;
2347
2348	memset(param, '\0', sizeof(param));
2349	p = make_header(param, RAP_WsessionEnum,
2350	RAP_NetSessionEnum_REQ, RAP_SESSION_INFO_L2);
2351	PUTWORD(p,2); /* Info level 2 */
2352	PUTWORD(p,0xFF); /* Return buffer size */
2353
2354	if (cli_api(cli,
2355	param, PTR_DIFF(p,param),8,
2356	NULL, 0, CLI_BUFFER_SIZE,
2357	&rparam, &rprcnt,
2358	&rdata, &rdrcnt)) {
2359	char *endp = rparam + rprcnt;
2360	res = GETRES(rparam, endp);
2361	cli->rap_error = res;
2362	if (res != 0) {
2363	DEBUG(1,("NetSessionEnum gave error %d\n", res));
2364	}
2365	}
2366
2367	if (!rdata) {
2368	DEBUG(4,("NetSesssionEnum no data returned\n"));
2369	goto out;
2370	}
2371
2372	if (res == 0 \|\| res == ERRmoredata) {
2373	TALLOC_CTX *frame = talloc_stackframe();
2374	char *endp = rparam + rprcnt;
2375	int i, converter = 0, count = 0;
2376
2377	p = rparam + WORDSIZE;
2378	GETWORD(p, converter, endp);
2379	GETWORD(p, count, endp);
2380
2381	endp = rdata + rdrcnt;
2382	for (i=0,p=rdata;i<count && p < endp;i++) {
2383	char wsname, username, *clitype_name;
2384	uint16_t num_conns = 0, num_opens = 0, num_users = 0;
2385	unsigned int sess_time = 0, idle_time = 0, user_flags = 0;
2386
2387	p += rap_getstringp(frame,
2388	p,
2389	&wsname,
2390	rdata,
2391	converter,
2392	endp);
2393	p += rap_getstringp(frame,
2394	p,
2395	&username,
2396	rdata,
2397	converter,
2398	endp);
2399	GETWORD(p, num_conns, endp);
2400	GETWORD(p, num_opens, endp);
2401	GETWORD(p, num_users, endp);
2402	GETDWORD(p, sess_time, endp);
2403	GETDWORD(p, idle_time, endp);
2404	GETDWORD(p, user_flags, endp);
2405	p += rap_getstringp(frame,
2406	p,
2407	&clitype_name,
2408	rdata,
2409	converter,
2410	endp);
2411
2412	if (wsname && username && clitype_name) {
2413	fn(wsname, username, num_conns, num_opens, num_users, sess_time,
2414	idle_time, user_flags, clitype_name);
2415	}
2416	}
2417	TALLOC_FREE(frame);
2418	} else {
2419	DEBUG(4,("NetSessionEnum res=%d\n", res));
2420	}
2421
2422	out:
2423
2424	SAFE_FREE(rparam);
2425	SAFE_FREE(rdata);
2426
2427	return res;
2428	}
2429
2430	/****************************************************************************
2431	Call a NetSessionGetInfo - get information about other session to an SMB server.
2432	****************************************************************************/
2433
2434	int cli_NetSessionGetInfo(struct cli_state cli, const char workstation,
2435	void (fn)(const char , const char , uint16, uint16, uint16, uint, uint, uint, const char ))
2436	{
2437	char param[WORDSIZE /* api number */
2438	+sizeof(RAP_NetSessionGetInfo_REQ) /* req string */
2439	+sizeof(RAP_SESSION_INFO_L2) /* return string */
2440	+RAP_MACHNAME_LEN /* wksta name */
2441	+WORDSIZE /* info level */
2442	+WORDSIZE]; /* buffer size */
2443	char *p;
2444	char *rparam = NULL;
2445	char *rdata = NULL;
2446	unsigned int rprcnt, rdrcnt;
2447	char *endp;
2448	int res = -1;
2449
2450	memset(param, '\0', sizeof(param));
2451	p = make_header(param, RAP_WsessionGetInfo,
2452	RAP_NetSessionGetInfo_REQ, RAP_SESSION_INFO_L2);
2453	PUTSTRING(p, workstation, RAP_MACHNAME_LEN-1);
2454	PUTWORD(p,2); /* Info level 2 */
2455	PUTWORD(p,0xFF); /* Return buffer size */
2456
2457	if (cli_api(cli,
2458	param, PTR_DIFF(p,param),PTR_DIFF(p,param),
2459	NULL, 0, CLI_BUFFER_SIZE,
2460	&rparam, &rprcnt,
2461	&rdata, &rdrcnt)) {
2462	endp = rparam + rprcnt;
2463	res = GETRES(rparam, endp);
2464	cli->rap_error = res;
2465	if (cli->rap_error != 0) {
2466	DEBUG(1,("NetSessionGetInfo gave error %d\n", cli->rap_error));
2467	}
2468	}
2469
2470	if (!rdata) {
2471	DEBUG(4,("NetSessionGetInfo no data returned\n"));
2472	goto out;
2473	}
2474
2475	endp = rparam + rprcnt;
2476	res = GETRES(rparam, endp);
2477
2478	if (res == 0 \|\| res == ERRmoredata) {
2479	TALLOC_CTX *frame = talloc_stackframe();
2480	int converter = 0;
2481	char wsname, username, *clitype_name;
2482	uint16_t num_conns = 0, num_opens = 0, num_users = 0;
2483	unsigned int sess_time = 0, idle_time = 0, user_flags = 0;
2484
2485	p = rparam + WORDSIZE;
2486	GETWORD(p, converter,endp);
2487	p += WORDSIZE; /* skip rsize */
2488
2489	p = rdata;
2490	endp = rdata + rdrcnt;
2491	p += rap_getstringp(frame,
2492	p,
2493	&wsname,
2494	rdata,
2495	converter,
2496	endp);
2497	p += rap_getstringp(frame,
2498	p,
2499	&username,
2500	rdata,
2501	converter,
2502	endp);
2503	GETWORD(p, num_conns, endp);
2504	GETWORD(p, num_opens, endp);
2505	GETWORD(p, num_users, endp);
2506	GETDWORD(p, sess_time, endp);
2507	GETDWORD(p, idle_time, endp);
2508	GETDWORD(p, user_flags, endp);
2509	p += rap_getstringp(frame,
2510	p,
2511	&clitype_name,
2512	rdata,
2513	converter,
2514	endp);
2515
2516	if (wsname && username && clitype_name) {
2517	fn(wsname, username, num_conns, num_opens, num_users, sess_time,
2518	idle_time, user_flags, clitype_name);
2519	}
2520	TALLOC_FREE(frame);
2521	} else {
2522	DEBUG(4,("NetSessionGetInfo res=%d\n", res));
2523	}
2524
2525	out:
2526
2527	SAFE_FREE(rparam);
2528	SAFE_FREE(rdata);
2529
2530	return res;
2531	}
2532
2533	/****************************************************************************
2534	Call a NetSessionDel - close a session to an SMB server.
2535	****************************************************************************/
2536
2537	int cli_NetSessionDel(struct cli_state cli, const char workstation)
2538	{
2539	char param[WORDSIZE /* api number */
2540	+sizeof(RAP_NetSessionDel_REQ) /* req string */
2541	+1 /* no return string */
2542	+RAP_MACHNAME_LEN /* workstation name */
2543	+WORDSIZE]; /* reserved (0) */
2544	char *p;
2545	char *rparam = NULL;
2546	char *rdata = NULL;
2547	unsigned int rprcnt, rdrcnt;
2548	int res = -1;
2549
2550	memset(param, '\0', sizeof(param));
2551	p = make_header(param, RAP_WsessionDel, RAP_NetSessionDel_REQ, NULL);
2552	PUTSTRING(p, workstation, RAP_MACHNAME_LEN-1);
2553	PUTWORD(p,0); /* reserved word of 0 */
2554
2555	if (cli_api(cli,
2556	param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
2557	NULL, 0, 200, /* data, length, maxlen */
2558	&rparam, &rprcnt, /* return params, length */
2559	&rdata, &rdrcnt)) /* return data, length */
2560	{
2561	char *endp = rparam + rprcnt;
2562	res = GETRES(rparam, endp);
2563	cli->rap_error = res;
2564
2565	if (res == 0) {
2566	/* nothing to do */
2567	} else {
2568	DEBUG(4,("NetFileClose2 res=%d\n", res));
2569	}
2570	} else {
2571	res = -1;
2572	DEBUG(4,("NetFileClose2 failed\n"));
2573	}
2574
2575	SAFE_FREE(rparam);
2576	SAFE_FREE(rdata);
2577
2578	return res;
2579	}
2580
2581	int cli_NetConnectionEnum(struct cli_state cli, const char qualifier,
2582	void (*fn)(uint16_t conid, uint16_t contype,
2583	uint16_t numopens, uint16_t numusers,
2584	uint32_t contime, const char *username,
2585	const char *netname))
2586	{
2587	char param[WORDSIZE /* api number */
2588	+sizeof(RAP_NetConnectionEnum_REQ) /* req string */
2589	+sizeof(RAP_CONNECTION_INFO_L1) /* return string */
2590	+RAP_MACHNAME_LEN /* wksta name */
2591	+WORDSIZE /* info level */
2592	+WORDSIZE]; /* buffer size */
2593	char *p;
2594	char *rparam = NULL;
2595	char *rdata = NULL;
2596	unsigned int rprcnt, rdrcnt;
2597	int res = -1;
2598
2599	memset(param, '\0', sizeof(param));
2600	p = make_header(param, RAP_WconnectionEnum,
2601	RAP_NetConnectionEnum_REQ, RAP_CONNECTION_INFO_L1);
2602	PUTSTRING(p, qualifier, RAP_MACHNAME_LEN-1);/* Workstation name */
2603	PUTWORD(p,1); /* Info level 1 */
2604	PUTWORD(p,0xFFE0); /* Return buffer size */
2605
2606	if (cli_api(cli,
2607	param, PTR_DIFF(p,param),PTR_DIFF(p,param),
2608	NULL, 0, CLI_BUFFER_SIZE,
2609	&rparam, &rprcnt,
2610	&rdata, &rdrcnt)) {
2611	char *endp = rparam + rprcnt;
2612	res = GETRES(rparam, endp);
2613	cli->rap_error = res;
2614	if (res != 0) {
2615	DEBUG(1,("NetConnectionEnum gave error %d\n", res));
2616	}
2617	}
2618
2619	if (!rdata) {
2620	DEBUG(4,("NetConnectionEnum no data returned\n"));
2621	goto out;
2622	}
2623
2624	if (res == 0 \|\| res == ERRmoredata) {
2625	TALLOC_CTX *frame = talloc_stackframe();
2626	char *endp = rparam + rprcnt;
2627	int i, converter = 0, count = 0;
2628
2629	p = rparam + WORDSIZE;
2630	GETWORD(p, converter, endp);
2631	GETWORD(p, count, endp);
2632
2633	endp = rdata + rdrcnt;
2634	for (i=0,p=rdata;i<count && p < endp;i++) {
2635	char netname, username;
2636	uint16_t conn_id = 0, conn_type = 0, num_opens = 0, num_users = 0;
2637	unsigned int conn_time = 0;
2638
2639	GETWORD(p,conn_id, endp);
2640	GETWORD(p,conn_type, endp);
2641	GETWORD(p,num_opens, endp);
2642	GETWORD(p,num_users, endp);
2643	GETDWORD(p,conn_time, endp);
2644	p += rap_getstringp(frame,
2645	p,
2646	&username,
2647	rdata,
2648	converter,
2649	endp);
2650	p += rap_getstringp(frame,
2651	p,
2652	&netname,
2653	rdata,
2654	converter,
2655	endp);
2656
2657	if (username && netname) {
2658	fn(conn_id, conn_type, num_opens, num_users, conn_time,
2659	username, netname);
2660	}
2661	}
2662	TALLOC_FREE(frame);
2663	} else {
2664	DEBUG(4,("NetConnectionEnum res=%d\n", res));
2665	}
2666
2667	out:
2668
2669	SAFE_FREE(rdata);
2670	SAFE_FREE(rparam);
2671	return res;
2672	}

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

Download in other formats: