Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

clirap2.c

Visit:

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago
Samba Server: updated trunk to 3.6.0
File size: 75.3 KB

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

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

Context Navigation

source: trunk/server/source3/libsmb/clirap2.c

Download in other formats: