#define NO_SYSLOG
#include "includes.h"
#define WORDSIZE 2
#define DWORDSIZE 4
#define PUTBYTE(p,b) do {SCVAL(p,0,b); p++;} while(0)
#define GETBYTE(p,b) do {b = CVAL(p,0); p++;} while(0)
#define PUTWORD(p,w) do {SSVAL(p,0,w); p += WORDSIZE;} while(0)
#define GETWORD(p,w) do {w = SVAL(p,0); p += WORDSIZE;} while(0)
#define PUTDWORD(p,d) do {SIVAL(p,0,d); p += DWORDSIZE;} while(0)
#define GETDWORD(p,d) do {d = IVAL(p,0); p += DWORDSIZE;} while(0)
#define GETRES(p) p ? SVAL(p,0) : -1
#define PUTSTRING(p,s,n) do {\
push_ascii(p,s?s:"",n?n:256,STR_TERMINATE);\
p = skip_string(p,1);\
} while(0)
#define PUTSTRINGF(p,s,l) do {\
push_ascii(p,s?s:"",l,STR_TERMINATE);\
p += l;\
} while (0)
#define PUTSTRINGP(p,s,r,o) do {\
if (s) {\
push_ascii(r+o,s,strlen(s)+1,STR_TERMINATE);\
PUTDWORD(p,o);\
o += strlen(s) + 1;\
} else PUTDWORD(p,0);\
}while(0);
#define GETSTRING(p,s) do {\
pull_ascii_pstring(s,p);\
p = skip_string(p,1);\
} while(0)
#define GETSTRINGF(p,s,l) do {\
pull_ascii_pstring(s,p);\
p += l;\
} while(0)
#define GETSTRINGP(p,s,r,c) do {\
uint32 off;\
GETDWORD(p,off);\
off &= 0x0000FFFF; \
pull_ascii_pstring(s, off?(r+off-c):"");\
} while(0)
static char *make_header(char *param, uint16 apinum, const char *reqfmt, const char *datafmt)
{
PUTWORD(param,apinum);
if (reqfmt)
PUTSTRING(param,reqfmt,0);
else
*param++ = (char) 0;
if (datafmt)
PUTSTRING(param,datafmt,0);
else
*param++ = (char) 0;
return param;
}
int cli_NetGroupDelete(struct cli_state *cli, const char *group_name )
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
int res;
char param[WORDSIZE
+sizeof(RAP_NetGroupDel_REQ)
+1
+RAP_GROUPNAME_LEN
+WORDSIZE];
p = make_header(param, RAP_WGroupDel, RAP_NetGroupDel_REQ, NULL);
PUTSTRING(p, group_name, RAP_GROUPNAME_LEN);
PUTWORD(p,0);
if (cli_api(cli,
param, PTR_DIFF(p,param), 1024,
NULL, 0, 200,
&rparam, &rprcnt,
&rdata, &rdrcnt))
{
res = GETRES(rparam);
if (res == 0) {
}
else if ((res == 5) || (res == 65)) {
DEBUG(1, ("Access Denied\n"));
}
else if (res == 2220) {
DEBUG (1, ("Group does not exist\n"));
}
else {
DEBUG(4,("NetGroupDelete res=%d\n", res));
}
} else {
res = -1;
DEBUG(4,("NetGroupDelete failed\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetGroupAdd(struct cli_state *cli, RAP_GROUP_INFO_1 * grinfo )
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
int res;
char param[WORDSIZE
+sizeof(RAP_NetGroupAdd_REQ)
+sizeof(RAP_GROUP_INFO_L1)
+WORDSIZE
+WORDSIZE];
char data[1024];
int soffset = RAP_GROUPNAME_LEN + 1 + DWORDSIZE;
p = make_header(param, RAP_WGroupAdd,
RAP_NetGroupAdd_REQ, RAP_GROUP_INFO_L1);
PUTWORD(p, 1);
PUTWORD(p, 0);
p = data;
PUTSTRINGF(p, grinfo->group_name, RAP_GROUPNAME_LEN);
PUTBYTE(p, 0);
PUTSTRINGP(p, grinfo->comment, data, soffset);
if (cli_api(cli,
param, sizeof(param), 1024,
data, soffset, sizeof(data),
&rparam, &rprcnt,
&rdata, &rdrcnt))
{
res = GETRES(rparam);
if (res == 0) {
} else if ((res == 5) || (res == 65)) {
DEBUG(1, ("Access Denied\n"));
}
else if (res == 2223) {
DEBUG (1, ("Group already exists\n"));
}
else {
DEBUG(4,("NetGroupAdd res=%d\n", res));
}
} else {
res = -1;
DEBUG(4,("NetGroupAdd failed\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_RNetGroupEnum(struct cli_state *cli, void (*fn)(const char *, const char *, void *), void *state)
{
char param[WORDSIZE
+sizeof(RAP_NetGroupEnum_REQ)
+sizeof(RAP_GROUP_INFO_L1)
+WORDSIZE
+WORDSIZE];
char *p;
char *rparam = NULL;
char *rdata = NULL;
unsigned int rprcnt, rdrcnt;
int res = -1;
memset(param, '\0', sizeof(param));
p = make_header(param, RAP_WGroupEnum,
RAP_NetGroupEnum_REQ, RAP_GROUP_INFO_L1);
PUTWORD(p,1);
PUTWORD(p,0xFFE0);
if (cli_api(cli,
param, PTR_DIFF(p,param),8,
NULL, 0, 0xFFE0 ,
&rparam, &rprcnt,
&rdata, &rdrcnt)) {
res = GETRES(rparam);
cli->rap_error = res;
if(cli->rap_error == 234)
DEBUG(1,("Not all group names were returned (such as those longer than 21 characters)\n"));
else if (cli->rap_error != 0) {
DEBUG(1,("NetGroupEnum gave error %d\n", cli->rap_error));
}
}
if (rdata) {
if (res == 0 || res == ERRmoredata) {
int i, converter, count;
p = rparam + WORDSIZE;
GETWORD(p, converter);
GETWORD(p, count);
for (i=0,p=rdata;i<count;i++) {
pstring comment;
char groupname[RAP_GROUPNAME_LEN];
GETSTRINGF(p, groupname, RAP_GROUPNAME_LEN);
p++;
GETSTRINGP(p, comment, rdata, converter);
fn(groupname, comment, cli);
}
} else {
DEBUG(4,("NetGroupEnum res=%d\n", res));
}
} else {
DEBUG(4,("NetGroupEnum no data returned\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetGroupDelUser(struct cli_state * cli, const char *group_name, const char *user_name)
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
int res;
char param[WORDSIZE
+sizeof(RAP_NetGroupDelUser_REQ)
+1
+RAP_GROUPNAME_LEN
+RAP_USERNAME_LEN];
p = make_header(param, RAP_WGroupDelUser, RAP_NetGroupDelUser_REQ, NULL);
PUTSTRING(p,group_name,RAP_GROUPNAME_LEN);
PUTSTRING(p,user_name,RAP_USERNAME_LEN);
if (cli_api(cli,
param, PTR_DIFF(p,param), 1024,
NULL, 0, 200,
&rparam, &rprcnt,
&rdata, &rdrcnt))
{
res = GETRES(rparam);
switch(res) {
case 0:
break;
case 5:
case 65:
DEBUG(1, ("Access Denied\n"));
break;
case 50:
DEBUG(1, ("Not supported by server\n"));
break;
case 2220:
DEBUG(1, ("Group does not exist\n"));
break;
case 2221:
DEBUG(1, ("User does not exist\n"));
break;
case 2237:
DEBUG(1, ("User is not in group\n"));
break;
default:
DEBUG(4,("NetGroupDelUser res=%d\n", res));
}
} else {
res = -1;
DEBUG(4,("NetGroupDelUser failed\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetGroupAddUser(struct cli_state * cli, const char *group_name, const char *user_name)
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
int res;
char param[WORDSIZE
+sizeof(RAP_NetGroupAddUser_REQ)
+1
+RAP_GROUPNAME_LEN
+RAP_USERNAME_LEN];
p = make_header(param, RAP_WGroupAddUser, RAP_NetGroupAddUser_REQ, NULL);
PUTSTRING(p,group_name,RAP_GROUPNAME_LEN);
PUTSTRING(p,user_name,RAP_USERNAME_LEN);
if (cli_api(cli,
param, PTR_DIFF(p,param), 1024,
NULL, 0, 200,
&rparam, &rprcnt,
&rdata, &rdrcnt))
{
res = GETRES(rparam);
switch(res) {
case 0:
break;
case 5:
case 65:
DEBUG(1, ("Access Denied\n"));
break;
case 50:
DEBUG(1, ("Not supported by server\n"));
break;
case 2220:
DEBUG(1, ("Group does not exist\n"));
break;
case 2221:
DEBUG(1, ("User does not exist\n"));
break;
default:
DEBUG(4,("NetGroupAddUser res=%d\n", res));
}
} else {
res = -1;
DEBUG(4,("NetGroupAddUser failed\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetGroupGetUsers(struct cli_state * cli, const char *group_name, void (*fn)(const char *, void *), void *state )
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
int res = -1;
char param[WORDSIZE
+sizeof(RAP_NetGroupGetUsers_REQ)
+sizeof(RAP_GROUP_USERS_INFO_0)
+RAP_GROUPNAME_LEN
+WORDSIZE
+WORDSIZE];
p = make_header(param, RAP_WGroupGetUsers,
RAP_NetGroupGetUsers_REQ, RAP_GROUP_USERS_INFO_0);
PUTSTRING(p,group_name,RAP_GROUPNAME_LEN-1);
PUTWORD(p,0);
PUTWORD(p,0xFFE0);
if (cli_api(cli,
param, PTR_DIFF(p,param),PTR_DIFF(p,param),
NULL, 0, CLI_BUFFER_SIZE,
&rparam, &rprcnt,
&rdata, &rdrcnt)) {
res = GETRES(rparam);
cli->rap_error = res;
if (res != 0) {
DEBUG(1,("NetGroupGetUsers gave error %d\n", res));
}
}
if (rdata) {
if (res == 0 || res == ERRmoredata) {
int i, converter, count;
fstring username;
p = rparam +WORDSIZE;
GETWORD(p, converter);
GETWORD(p, count);
for (i=0,p=rdata; i<count; i++) {
GETSTRINGF(p, username, RAP_USERNAME_LEN);
fn(username, state);
}
} else {
DEBUG(4,("NetGroupGetUsers res=%d\n", res));
}
} else {
DEBUG(4,("NetGroupGetUsers no data returned\n"));
}
SAFE_FREE(rdata);
SAFE_FREE(rparam);
return res;
}
int cli_NetUserGetGroups(struct cli_state * cli, const char *user_name, void (*fn)(const char *, void *), void *state )
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
int res = -1;
char param[WORDSIZE
+sizeof(RAP_NetUserGetGroups_REQ)
+sizeof(RAP_GROUP_USERS_INFO_0)
+RAP_USERNAME_LEN
+WORDSIZE
+WORDSIZE];
p = make_header(param, RAP_WUserGetGroups,
RAP_NetUserGetGroups_REQ, RAP_GROUP_USERS_INFO_0);
PUTSTRING(p,user_name,RAP_USERNAME_LEN-1);
PUTWORD(p,0);
PUTWORD(p,0xFFE0);
if (cli_api(cli,
param, PTR_DIFF(p,param),PTR_DIFF(p,param),
NULL, 0, CLI_BUFFER_SIZE,
&rparam, &rprcnt,
&rdata, &rdrcnt)) {
res = GETRES(rparam);
cli->rap_error = res;
if (res != 0) {
DEBUG(1,("NetUserGetGroups gave error %d\n", res));
}
}
if (rdata) {
if (res == 0 || res == ERRmoredata) {
int i, converter, count;
fstring groupname;
p = rparam +WORDSIZE;
GETWORD(p, converter);
GETWORD(p, count);
for (i=0,p=rdata; i<count; i++) {
GETSTRINGF(p, groupname, RAP_USERNAME_LEN);
fn(groupname, state);
}
} else {
DEBUG(4,("NetUserGetGroups res=%d\n", res));
}
} else {
DEBUG(4,("NetUserGetGroups no data returned\n"));
}
SAFE_FREE(rdata);
SAFE_FREE(rparam);
return res;
}
int cli_NetUserDelete(struct cli_state *cli, const char * user_name )
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
int res;
char param[WORDSIZE
+sizeof(RAP_NetGroupDel_REQ)
+1
+RAP_USERNAME_LEN
+WORDSIZE];
p = make_header(param, RAP_WUserDel, RAP_NetGroupDel_REQ, NULL);
PUTSTRING(p, user_name, RAP_USERNAME_LEN);
PUTWORD(p,0);
if (cli_api(cli,
param, PTR_DIFF(p,param), 1024,
NULL, 0, 200,
&rparam, &rprcnt,
&rdata, &rdrcnt))
{
res = GETRES(rparam);
if (res == 0) {
}
else if ((res == 5) || (res == 65)) {
DEBUG(1, ("Access Denied\n"));
}
else if (res == 2221) {
DEBUG (1, ("User does not exist\n"));
}
else {
DEBUG(4,("NetUserDelete res=%d\n", res));
}
} else {
res = -1;
DEBUG(4,("NetUserDelete failed\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetUserAdd(struct cli_state *cli, RAP_USER_INFO_1 * userinfo )
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
int res;
char param[WORDSIZE
+sizeof(RAP_NetUserAdd2_REQ)
+sizeof(RAP_USER_INFO_L1)
+WORDSIZE
+WORDSIZE
+WORDSIZE];
char data[1024];
int soffset=RAP_USERNAME_LEN+1
+ RAP_UPASSWD_LEN
+ DWORDSIZE
+ WORDSIZE
+ DWORDSIZE
+ DWORDSIZE
+ WORDSIZE
+ DWORDSIZE;
p = make_header(param, RAP_WUserAdd2,
RAP_NetUserAdd2_REQ, RAP_USER_INFO_L1);
PUTWORD(p, 1);
PUTWORD(p, 0);
if(userinfo->passwrd)
PUTWORD(p,MIN(strlen(userinfo->passwrd), RAP_UPASSWD_LEN));
else
PUTWORD(p, 0);
p = data;
memset(data, '\0', soffset);
PUTSTRINGF(p, userinfo->user_name, RAP_USERNAME_LEN);
PUTBYTE(p, 0);
PUTSTRINGF(p, userinfo->passwrd, RAP_UPASSWD_LEN);
PUTDWORD(p, 0);
PUTWORD(p, userinfo->priv);
PUTSTRINGP(p, userinfo->home_dir, data, soffset);
PUTSTRINGP(p, userinfo->comment, data, soffset);
PUTWORD(p, userinfo->userflags);
PUTSTRINGP(p, userinfo->logon_script, data, soffset);
if (cli_api(cli,
param, sizeof(param), 1024,
data, soffset, sizeof(data),
&rparam, &rprcnt,
&rdata, &rdrcnt))
{
res = GETRES(rparam);
if (res == 0) {
}
else if ((res == 5) || (res == 65)) {
DEBUG(1, ("Access Denied\n"));
}
else if (res == 2224) {
DEBUG (1, ("User already exists\n"));
}
else {
DEBUG(4,("NetUserAdd res=%d\n", res));
}
} else {
res = -1;
DEBUG(4,("NetUserAdd failed\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_RNetUserEnum(struct cli_state *cli, void (*fn)(const char *, const char *, const char *, const char *, void *), void *state)
{
char param[WORDSIZE
+sizeof(RAP_NetUserEnum_REQ)
+sizeof(RAP_USER_INFO_L1)
+WORDSIZE
+WORDSIZE];
char *p;
char *rparam = NULL;
char *rdata = NULL;
unsigned int rprcnt, rdrcnt;
int res = -1;
memset(param, '\0', sizeof(param));
p = make_header(param, RAP_WUserEnum,
RAP_NetUserEnum_REQ, RAP_USER_INFO_L1);
PUTWORD(p,1);
PUTWORD(p,0xFF00);
if (cli_api(cli,
param, PTR_DIFF(p,param),8,
NULL, 0, CLI_BUFFER_SIZE,
&rparam, &rprcnt,
&rdata, &rdrcnt)) {
res = GETRES(rparam);
cli->rap_error = res;
if (cli->rap_error != 0) {
DEBUG(1,("NetUserEnum gave error %d\n", cli->rap_error));
}
}
if (rdata) {
if (res == 0 || res == ERRmoredata) {
int i, converter, count;
char username[RAP_USERNAME_LEN];
char userpw[RAP_UPASSWD_LEN];
pstring comment, homedir, logonscript;
int pwage, priv, flags;
p = rparam + WORDSIZE;
GETWORD(p, converter);
GETWORD(p, count);
for (i=0,p=rdata;i<count;i++) {
GETSTRINGF(p, username, RAP_USERNAME_LEN);
p++;
GETSTRINGF(p, userpw, RAP_UPASSWD_LEN);
GETDWORD(p, pwage);
GETWORD(p, priv);
GETSTRINGP(p, homedir, rdata, converter);
GETSTRINGP(p, comment, rdata, converter);
GETWORD(p, flags);
GETSTRINGP(p, logonscript, rdata, converter);
fn(username, comment, homedir, logonscript, cli);
}
} else {
DEBUG(4,("NetUserEnum res=%d\n", res));
}
} else {
DEBUG(4,("NetUserEnum no data returned\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetFileClose(struct cli_state *cli, uint32 file_id )
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
char param[WORDSIZE
+sizeof(RAP_WFileClose2_REQ)
+1
+DWORDSIZE];
int res = -1;
p = make_header(param, RAP_WFileClose2, RAP_WFileClose2_REQ, NULL);
PUTDWORD(p, file_id);
if (cli_api(cli,
param, PTR_DIFF(p,param), 1024,
NULL, 0, 200,
&rparam, &rprcnt,
&rdata, &rdrcnt))
{
res = GETRES(rparam);
if (res == 0) {
} else if (res == 2314){
DEBUG(1, ("NetFileClose2 - attempt to close non-existant file open instance\n"));
} else {
DEBUG(4,("NetFileClose2 res=%d\n", res));
}
} else {
res = -1;
DEBUG(4,("NetFileClose2 failed\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetFileGetInfo(struct cli_state *cli, uint32 file_id, void (*fn)(const char *, const char *, uint16, uint16, uint32))
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
int res;
char param[WORDSIZE
+sizeof(RAP_WFileGetInfo2_REQ)
+sizeof(RAP_FILE_INFO_L3)
+DWORDSIZE
+WORDSIZE
+WORDSIZE];
p = make_header(param, RAP_WFileGetInfo2,
RAP_WFileGetInfo2_REQ, RAP_FILE_INFO_L3);
PUTDWORD(p, file_id);
PUTWORD(p, 3);
PUTWORD(p, 0x1000);
if (cli_api(cli,
param, PTR_DIFF(p,param), 1024,
NULL, 0, 0x1000,
&rparam, &rprcnt,
&rdata, &rdrcnt))
{
res = GETRES(rparam);
if (res == 0 || res == ERRmoredata) {
int converter,id, perms, locks;
pstring fpath, fuser;
p = rparam + WORDSIZE;
GETWORD(p, converter);
p = rdata;
GETDWORD(p, id);
GETWORD(p, perms);
GETWORD(p, locks);
GETSTRINGP(p, fpath, rdata, converter);
GETSTRINGP(p, fuser, rdata, converter);
fn(fpath, fuser, perms, locks, id);
} else {
DEBUG(4,("NetFileGetInfo2 res=%d\n", res));
}
} else {
res = -1;
DEBUG(4,("NetFileGetInfo2 failed\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetFileEnum(struct cli_state *cli, char * user, char * base_path, void (*fn)(const char *, const char *, uint16, uint16, uint32))
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
char param[WORDSIZE
+sizeof(RAP_WFileEnum2_REQ)
+sizeof(RAP_FILE_INFO_L3)
+256
+RAP_USERNAME_LEN
+WORDSIZE
+WORDSIZE
+DWORDSIZE
+DWORDSIZE];
int count = -1;
p = make_header(param, RAP_WFileEnum2,
RAP_WFileEnum2_REQ, RAP_FILE_INFO_L3);
PUTSTRING(p, base_path, 256);
PUTSTRING(p, user, RAP_USERNAME_LEN);
PUTWORD(p, 3);
PUTWORD(p, 0xFF00);
PUTDWORD(p, 0);
PUTDWORD(p, 0);
if (cli_api(cli,
param, PTR_DIFF(p,param), 1024,
NULL, 0, 0xFF00,
&rparam, &rprcnt,
&rdata, &rdrcnt))
{
int res = GETRES(rparam);
if (res == 0 || res == ERRmoredata) {
int converter, i;
p = rparam + WORDSIZE;
GETWORD(p, converter);
GETWORD(p, count);
p = rdata;
for (i=0; i<count; i++) {
int id, perms, locks;
pstring fpath, fuser;
GETDWORD(p, id);
GETWORD(p, perms);
GETWORD(p, locks);
GETSTRINGP(p, fpath, rdata, converter);
GETSTRINGP(p, fuser, rdata, converter);
fn(fpath, fuser, perms, locks, id);
}
} else {
DEBUG(4,("NetFileEnum2 res=%d\n", res));
}
} else {
DEBUG(4,("NetFileEnum2 failed\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return count;
}
int cli_NetShareAdd(struct cli_state *cli, RAP_SHARE_INFO_2 * sinfo )
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
int res;
char param[WORDSIZE
+sizeof(RAP_WShareAdd_REQ)
+sizeof(RAP_SHARE_INFO_L2)
+WORDSIZE
+WORDSIZE];
char data[1024];
int soffset = RAP_SHARENAME_LEN + 1
+ WORDSIZE
+ DWORDSIZE
+ WORDSIZE
+ WORDSIZE
+ WORDSIZE
+ DWORDSIZE
+ RAP_SPASSWD_LEN + 1;
memset(param,'\0',sizeof(param));
p = make_header(param, RAP_WshareAdd,
RAP_WShareAdd_REQ, RAP_SHARE_INFO_L2);
PUTWORD(p, 2);
PUTWORD(p, 0);
p = data;
PUTSTRINGF(p, sinfo->share_name, RAP_SHARENAME_LEN);
PUTBYTE(p, 0);
PUTWORD(p, sinfo->share_type);
PUTSTRINGP(p, sinfo->comment, data, soffset);
PUTWORD(p, sinfo->perms);
PUTWORD(p, sinfo->maximum_users);
PUTWORD(p, sinfo->active_users);
PUTSTRINGP(p, sinfo->path, data, soffset);
PUTSTRINGF(p, sinfo->password, RAP_SPASSWD_LEN);
SCVAL(p,-1,0x0A);
if (cli_api(cli,
param, sizeof(param), 1024,
data, soffset, sizeof(data),
&rparam, &rprcnt,
&rdata, &rdrcnt))
{
res = rparam? SVAL(rparam,0) : -1;
if (res == 0) {
}
else {
DEBUG(4,("NetShareAdd res=%d\n", res));
}
} else {
res = -1;
DEBUG(4,("NetShareAdd failed\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetShareDelete(struct cli_state *cli, const char * share_name )
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
int res;
char param[WORDSIZE
+sizeof(RAP_WShareDel_REQ)
+1
+RAP_SHARENAME_LEN
+WORDSIZE];
p = make_header(param, RAP_WshareDel, RAP_WShareDel_REQ, NULL);
PUTSTRING(p,share_name,RAP_SHARENAME_LEN);
PUTWORD(p,0);
if (cli_api(cli,
param, PTR_DIFF(p,param), 1024,
NULL, 0, 200,
&rparam, &rprcnt,
&rdata, &rdrcnt))
{
res = GETRES(rparam);
if (res == 0) {
}
else {
DEBUG(4,("NetShareDelete res=%d\n", res));
}
} else {
res = -1;
DEBUG(4,("NetShareDelete failed\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
BOOL cli_get_pdc_name(struct cli_state *cli, char *workgroup, char *pdc_name)
{
char *rparam = NULL;
char *rdata = NULL;
unsigned int rdrcnt,rprcnt;
char *p;
char param[WORDSIZE
+sizeof(RAP_NetServerEnum2_REQ)
+sizeof(RAP_SERVER_INFO_L1)
+WORDSIZE
+WORDSIZE
+DWORDSIZE
+RAP_MACHNAME_LEN];
int count = -1;
*pdc_name = '\0';
p = make_header(param, RAP_NetServerEnum2,
RAP_NetServerEnum2_REQ, RAP_SERVER_INFO_L1);
PUTWORD(p, 1);
PUTWORD(p, CLI_BUFFER_SIZE);
PUTDWORD(p, SV_TYPE_DOMAIN_CTRL);
PUTSTRING(p, workgroup, RAP_MACHNAME_LEN);
if (cli_api(cli,
param, PTR_DIFF(p,param), 8,
NULL, 0, CLI_BUFFER_SIZE,
&rparam, &rprcnt,
&rdata, &rdrcnt
)) {
cli->rap_error = GETRES(rparam);
if (cli->rap_error == 0) {
p = rparam + WORDSIZE + WORDSIZE;
GETWORD(p, count);
p = rdata;
if (count > 0)
GETSTRING(p, pdc_name);
}
else {
DEBUG(4,("cli_get_pdc_name: machine %s failed the NetServerEnum call. "
"Error was : %s.\n", cli->desthost, cli_errstr(cli) ));
}
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return(count > 0);
}
BOOL cli_get_server_domain(struct cli_state *cli)
{
char *rparam = NULL;
char *rdata = NULL;
unsigned int rdrcnt,rprcnt;
char *p;
char param[WORDSIZE
+sizeof(RAP_WWkstaGetInfo_REQ)
+sizeof(RAP_WKSTA_INFO_L10)
+WORDSIZE
+WORDSIZE];
int res = -1;
p = make_header(param, RAP_WWkstaGetInfo,
RAP_WWkstaGetInfo_REQ, RAP_WKSTA_INFO_L10);
PUTWORD(p, 10);
PUTWORD(p, CLI_BUFFER_SIZE);
if (cli_api(cli, param, PTR_DIFF(p,param), 8,
NULL, 0, CLI_BUFFER_SIZE,
&rparam, &rprcnt,
&rdata, &rdrcnt)) {
res = GETRES(rparam);
p = rdata;
if (res == 0) {
int converter;
p = rparam + WORDSIZE;
GETWORD(p, converter);
p = rdata + DWORDSIZE + DWORDSIZE;
GETSTRINGP(p, cli->server_domain, rdata, converter);
}
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return(res == 0);
}
BOOL cli_get_server_type(struct cli_state *cli, uint32 *pstype)
{
char *rparam = NULL;
char *rdata = NULL;
unsigned int rdrcnt,rprcnt;
char *p;
char param[WORDSIZE
+sizeof(RAP_WserverGetInfo_REQ)
+sizeof(RAP_SERVER_INFO_L1)
+WORDSIZE
+WORDSIZE];
int res = -1;
p = make_header(param, RAP_WserverGetInfo,
RAP_WserverGetInfo_REQ, RAP_SERVER_INFO_L1);
PUTWORD(p, 1);
PUTWORD(p, CLI_BUFFER_SIZE);
if (cli_api(cli,
param, PTR_DIFF(p,param), 8,
NULL, 0, CLI_BUFFER_SIZE,
&rparam, &rprcnt,
&rdata, &rdrcnt
)) {
res = GETRES(rparam);
if (res == 0 || res == ERRmoredata) {
p = rdata;
*pstype = IVAL(p,18) & ~SV_TYPE_LOCAL_LIST_ONLY;
}
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return(res == 0 || res == ERRmoredata);
}
BOOL cli_ns_check_server_type(struct cli_state *cli, char *workgroup, uint32 stype)
{
char *rparam = NULL;
char *rdata = NULL;
unsigned int rdrcnt,rprcnt;
char *p;
char param[WORDSIZE
+sizeof(RAP_NetServerEnum2_REQ)
+sizeof(RAP_SERVER_INFO_L0)
+WORDSIZE
+WORDSIZE
+DWORDSIZE
+RAP_MACHNAME_LEN];
BOOL found_server = False;
int res = -1;
p = make_header(param, RAP_NetServerEnum2,
RAP_NetServerEnum2_REQ, RAP_SERVER_INFO_L0);
PUTWORD(p, 0);
PUTWORD(p, CLI_BUFFER_SIZE);
PUTDWORD(p, stype);
PUTSTRING(p, workgroup, RAP_MACHNAME_LEN);
if (cli_api(cli,
param, PTR_DIFF(p,param), 8,
NULL, 0, CLI_BUFFER_SIZE,
&rparam, &rprcnt,
&rdata, &rdrcnt
)) {
res = GETRES(rparam);
cli->rap_error = res;
if (res == 0 || res == ERRmoredata) {
int i, converter, count;
p = rparam + WORDSIZE;
GETWORD(p, converter);
GETWORD(p, count);
p = rdata;
for (i = 0;i < count;i++, p += 16) {
char ret_server[RAP_MACHNAME_LEN];
GETSTRINGF(p, ret_server, RAP_MACHNAME_LEN);
if (strequal(ret_server, cli->desthost)) {
found_server = True;
break;
}
}
}
else {
DEBUG(4,("cli_ns_check_server_type: machine %s failed the NetServerEnum call. "
"Error was : %s.\n", cli->desthost, cli_errstr(cli) ));
}
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return found_server;
}
BOOL cli_NetWkstaUserLogoff(struct cli_state *cli,char *user, char *workstation)
{
char *rparam = NULL;
char *rdata = NULL;
char *p;
unsigned int rdrcnt,rprcnt;
char param[WORDSIZE
+sizeof(RAP_NetWkstaUserLogoff_REQ)
+sizeof(RAP_USER_LOGOFF_INFO_L1)
+RAP_USERNAME_LEN+1
+RAP_MACHNAME_LEN
+WORDSIZE
+WORDSIZE];
fstring upperbuf;
memset(param, 0, sizeof(param));
p = make_header(param, RAP_WWkstaUserLogoff,
RAP_NetWkstaUserLogoff_REQ, RAP_USER_LOGOFF_INFO_L1);
PUTDWORD(p, 0);
PUTDWORD(p, 0);
fstrcpy(upperbuf, user);
strupper_m(upperbuf);
PUTSTRINGF(p, upperbuf, RAP_USERNAME_LEN);
p++;
fstrcpy(upperbuf, workstation);
strupper_m(upperbuf);
PUTSTRINGF(p, upperbuf, RAP_MACHNAME_LEN);
PUTWORD(p, CLI_BUFFER_SIZE);
PUTWORD(p, CLI_BUFFER_SIZE);
if (cli_api(cli,
param, PTR_DIFF(p,param),1024,
NULL, 0, CLI_BUFFER_SIZE,
&rparam, &rprcnt,
&rdata, &rdrcnt
)) {
cli->rap_error = GETRES(rparam);
if (cli->rap_error != 0) {
DEBUG(4,("NetwkstaUserLogoff gave error %d\n", cli->rap_error));
}
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return (cli->rap_error == 0);
}
int cli_NetPrintQEnum(struct cli_state *cli,
void (*qfn)(const char*,uint16,uint16,uint16,const char*,const char*,const char*,const char*,const char*,uint16,uint16),
void (*jfn)(uint16,const char*,const char*,const char*,const char*,uint16,uint16,const char*,uint,uint,const char*))
{
char param[WORDSIZE
+sizeof(RAP_NetPrintQEnum_REQ)
+sizeof(RAP_PRINTQ_INFO_L2)
+WORDSIZE
+WORDSIZE
+sizeof(RAP_SMB_PRINT_JOB_L1)];
char *p;
char *rparam = NULL;
char *rdata = NULL;
unsigned int rprcnt, rdrcnt;
int res = -1;
memset(param, '\0',sizeof(param));
p = make_header(param, RAP_WPrintQEnum,
RAP_NetPrintQEnum_REQ, RAP_PRINTQ_INFO_L2);
PUTWORD(p,2);
PUTWORD(p,0xFFE0);
PUTSTRING(p, RAP_SMB_PRINT_JOB_L1, 0);
if (cli_api(cli,
param, PTR_DIFF(p,param),1024,
NULL, 0, CLI_BUFFER_SIZE,
&rparam, &rprcnt,
&rdata, &rdrcnt)) {
res = GETRES(rparam);
cli->rap_error = res;
if (res != 0) {
DEBUG(1,("NetPrintQEnum gave error %d\n", res));
}
}
if (rdata) {
if (res == 0 || res == ERRmoredata) {
int i, converter, count;
p = rparam + WORDSIZE;
GETWORD(p, converter);
GETWORD(p, count);
p = rdata;
for (i=0;i<count;i++) {
pstring qname, sep_file, print_proc, dest, parms, comment;
uint16 jobcount, priority, start_time, until_time, status;
GETSTRINGF(p, qname, RAP_SHARENAME_LEN);
p++;
GETWORD(p, priority);
GETWORD(p, start_time);
GETWORD(p, until_time);
GETSTRINGP(p, sep_file, rdata, converter);
GETSTRINGP(p, print_proc, rdata, converter);
GETSTRINGP(p, dest, rdata, converter);
GETSTRINGP(p, parms, rdata, converter);
GETSTRINGP(p, parms, comment, converter);
GETWORD(p, status);
GETWORD(p, jobcount);
qfn(qname, priority, start_time, until_time, sep_file, print_proc,
dest, parms, comment, status, jobcount);
if (jobcount) {
int j;
for (j=0;j<jobcount;j++) {
uint16 jid, pos, fsstatus;
pstring ownername, notifyname, datatype, jparms, jstatus, jcomment;
unsigned int submitted, jsize;
GETWORD(p, jid);
GETSTRINGF(p, ownername, RAP_USERNAME_LEN);
p++;
GETSTRINGF(p, notifyname, RAP_MACHNAME_LEN);
GETSTRINGF(p, datatype, RAP_DATATYPE_LEN);
GETSTRINGP(p, jparms, rdata, converter);
GETWORD(p, pos);
GETWORD(p, fsstatus);
GETSTRINGP(p, jstatus, rdata, converter);
GETDWORD(p, submitted);
GETDWORD(p, jsize);
GETSTRINGP(p, jcomment, rdata, converter);
jfn(jid, ownername, notifyname, datatype, jparms, pos, fsstatus,
jstatus, submitted, jsize, jcomment);
}
}
}
} else {
DEBUG(4,("NetPrintQEnum res=%d\n", res));
}
} else {
DEBUG(4,("NetPrintQEnum no data returned\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetPrintQGetInfo(struct cli_state *cli, const char *printer,
void (*qfn)(const char*,uint16,uint16,uint16,const char*,const char*,const char*,const char*,const char*,uint16,uint16),
void (*jfn)(uint16,const char*,const char*,const char*,const char*,uint16,uint16,const char*,uint,uint,const char*))
{
char param[WORDSIZE
+sizeof(RAP_NetPrintQGetInfo_REQ)
+sizeof(RAP_PRINTQ_INFO_L2)
+RAP_SHARENAME_LEN
+WORDSIZE
+WORDSIZE
+sizeof(RAP_SMB_PRINT_JOB_L1)];
char *p;
char *rparam = NULL;
char *rdata = NULL;
unsigned int rprcnt, rdrcnt;
int res = -1;
memset(param, '\0',sizeof(param));
p = make_header(param, RAP_WPrintQGetInfo,
RAP_NetPrintQGetInfo_REQ, RAP_PRINTQ_INFO_L2);
PUTSTRING(p, printer, RAP_SHARENAME_LEN-1);
PUTWORD(p, 2);
PUTWORD(p,0xFFE0);
PUTSTRING(p, RAP_SMB_PRINT_JOB_L1, 0);
if (cli_api(cli,
param, PTR_DIFF(p,param),1024,
NULL, 0, CLI_BUFFER_SIZE,
&rparam, &rprcnt,
&rdata, &rdrcnt)) {
res = GETRES(rparam);
cli->rap_error = res;
if (res != 0) {
DEBUG(1,("NetPrintQGetInfo gave error %d\n", res));
}
}
if (rdata) {
if (res == 0 || res == ERRmoredata) {
int rsize, converter;
pstring qname, sep_file, print_proc, dest, parms, comment;
uint16 jobcount, priority, start_time, until_time, status;
p = rparam + WORDSIZE;
GETWORD(p, converter);
GETWORD(p, rsize);
p = rdata;
GETSTRINGF(p, qname, RAP_SHARENAME_LEN);
p++;
GETWORD(p, priority);
GETWORD(p, start_time);
GETWORD(p, until_time);
GETSTRINGP(p, sep_file, rdata, converter);
GETSTRINGP(p, print_proc, rdata, converter);
GETSTRINGP(p, dest, rdata, converter);
GETSTRINGP(p, parms, rdata, converter);
GETSTRINGP(p, comment, rdata, converter);
GETWORD(p, status);
GETWORD(p, jobcount);
qfn(qname, priority, start_time, until_time, sep_file, print_proc,
dest, parms, comment, status, jobcount);
if (jobcount) {
int j;
for (j=0;(j<jobcount)&&(PTR_DIFF(p,rdata)< rsize);j++) {
uint16 jid, pos, fsstatus;
pstring ownername, notifyname, datatype, jparms, jstatus, jcomment;
unsigned int submitted, jsize;
GETWORD(p, jid);
GETSTRINGF(p, ownername, RAP_USERNAME_LEN);
p++;
GETSTRINGF(p, notifyname, RAP_MACHNAME_LEN);
GETSTRINGF(p, datatype, RAP_DATATYPE_LEN);
GETSTRINGP(p, jparms, rdata, converter);
GETWORD(p, pos);
GETWORD(p, fsstatus);
GETSTRINGP(p, jstatus, rdata, converter);
GETDWORD(p, submitted);
GETDWORD(p, jsize);
GETSTRINGP(p, jcomment, rdata, converter);
jfn(jid, ownername, notifyname, datatype, jparms, pos, fsstatus,
jstatus, submitted, jsize, jcomment);
}
}
} else {
DEBUG(4,("NetPrintQGetInfo res=%d\n", res));
}
} else {
DEBUG(4,("NetPrintQGetInfo no data returned\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_RNetServiceEnum(struct cli_state *cli, void (*fn)(const char *, const char *, void *), void *state)
{
char param[WORDSIZE
+sizeof(RAP_NetServiceEnum_REQ)
+sizeof(RAP_SERVICE_INFO_L2)
+WORDSIZE
+WORDSIZE];
char *p;
char *rparam = NULL;
char *rdata = NULL;
unsigned int rprcnt, rdrcnt;
int res = -1;
memset(param, '\0', sizeof(param));
p = make_header(param, RAP_WServiceEnum,
RAP_NetServiceEnum_REQ, RAP_SERVICE_INFO_L2);
PUTWORD(p,2);
PUTWORD(p,0xFFE0);
if (cli_api(cli,
param, PTR_DIFF(p,param),8,
NULL, 0, 0xFFE0 ,
&rparam, &rprcnt,
&rdata, &rdrcnt)) {
res = GETRES(rparam);
cli->rap_error = res;
if(cli->rap_error == 234)
DEBUG(1,("Not all service names were returned (such as those longer than 15 characters)\n"));
else if (cli->rap_error != 0) {
DEBUG(1,("NetServiceEnum gave error %d\n", cli->rap_error));
}
}
if (rdata) {
if (res == 0 || res == ERRmoredata) {
int i, converter, count;
p = rparam + WORDSIZE;
GETWORD(p, converter);
GETWORD(p, count);
for (i=0,p=rdata;i<count;i++) {
pstring comment;
char servicename[RAP_SRVCNAME_LEN];
GETSTRINGF(p, servicename, RAP_SRVCNAME_LEN);
p+=8;
GETSTRINGF(p, comment, RAP_SRVCCMNT_LEN);
fn(servicename, comment, cli);
}
} else {
DEBUG(4,("NetServiceEnum res=%d\n", res));
}
} else {
DEBUG(4,("NetServiceEnum no data returned\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetSessionEnum(struct cli_state *cli, void (*fn)(char *, char *, uint16, uint16, uint16, uint, uint, uint, char *))
{
char param[WORDSIZE
+sizeof(RAP_NetSessionEnum_REQ)
+sizeof(RAP_SESSION_INFO_L2)
+WORDSIZE
+WORDSIZE];
char *p;
char *rparam = NULL;
char *rdata = NULL;
unsigned int rprcnt, rdrcnt;
int res = -1;
memset(param, '\0', sizeof(param));
p = make_header(param, RAP_WsessionEnum,
RAP_NetSessionEnum_REQ, RAP_SESSION_INFO_L2);
PUTWORD(p,2);
PUTWORD(p,0xFF);
if (cli_api(cli,
param, PTR_DIFF(p,param),8,
NULL, 0, CLI_BUFFER_SIZE,
&rparam, &rprcnt,
&rdata, &rdrcnt)) {
res = GETRES(rparam);
cli->rap_error = res;
if (res != 0) {
DEBUG(1,("NetSessionEnum gave error %d\n", res));
}
}
if (rdata) {
if (res == 0 || res == ERRmoredata) {
int i, converter, count;
p = rparam + WORDSIZE;
GETWORD(p, converter);
GETWORD(p, count);
for (i=0,p=rdata;i<count;i++) {
pstring wsname, username, clitype_name;
uint16 num_conns, num_opens, num_users;
unsigned int sess_time, idle_time, user_flags;
GETSTRINGP(p, wsname, rdata, converter);
GETSTRINGP(p, username, rdata, converter);
GETWORD(p, num_conns);
GETWORD(p, num_opens);
GETWORD(p, num_users);
GETDWORD(p, sess_time);
GETDWORD(p, idle_time);
GETDWORD(p, user_flags);
GETSTRINGP(p, clitype_name, rdata, converter);
fn(wsname, username, num_conns, num_opens, num_users, sess_time,
idle_time, user_flags, clitype_name);
}
} else {
DEBUG(4,("NetSessionEnum res=%d\n", res));
}
} else {
DEBUG(4,("NetSesssionEnum no data returned\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetSessionGetInfo(struct cli_state *cli, const char *workstation, void (*fn)(const char *, const char *, uint16, uint16, uint16, uint, uint, uint, const char *))
{
char param[WORDSIZE
+sizeof(RAP_NetSessionGetInfo_REQ)
+sizeof(RAP_SESSION_INFO_L2)
+RAP_MACHNAME_LEN
+WORDSIZE
+WORDSIZE];
char *p;
char *rparam = NULL;
char *rdata = NULL;
unsigned int rprcnt, rdrcnt;
int res = -1;
memset(param, '\0', sizeof(param));
p = make_header(param, RAP_WsessionGetInfo,
RAP_NetSessionGetInfo_REQ, RAP_SESSION_INFO_L2);
PUTSTRING(p, workstation, RAP_MACHNAME_LEN-1);
PUTWORD(p,2);
PUTWORD(p,0xFF);
if (cli_api(cli,
param, PTR_DIFF(p,param),PTR_DIFF(p,param),
NULL, 0, CLI_BUFFER_SIZE,
&rparam, &rprcnt,
&rdata, &rdrcnt)) {
cli->rap_error = SVAL(rparam,0);
if (cli->rap_error != 0) {
DEBUG(1,("NetSessionGetInfo gave error %d\n", cli->rap_error));
}
}
if (rdata) {
res = GETRES(rparam);
if (res == 0 || res == ERRmoredata) {
int rsize, converter;
pstring wsname, username, clitype_name;
uint16 num_conns, num_opens, num_users;
unsigned int sess_time, idle_time, user_flags;
p = rparam + WORDSIZE;
GETWORD(p, converter);
GETWORD(p, rsize);
p = rdata;
GETSTRINGP(p, wsname, rdata, converter);
GETSTRINGP(p, username, rdata, converter);
GETWORD(p, num_conns);
GETWORD(p, num_opens);
GETWORD(p, num_users);
GETDWORD(p, sess_time);
GETDWORD(p, idle_time);
GETDWORD(p, user_flags);
GETSTRINGP(p, clitype_name, rdata, converter);
fn(wsname, username, num_conns, num_opens, num_users, sess_time,
idle_time, user_flags, clitype_name);
} else {
DEBUG(4,("NetSessionGetInfo res=%d\n", res));
}
} else {
DEBUG(4,("NetSessionGetInfo no data returned\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetSessionDel(struct cli_state *cli, const char *workstation)
{
char param[WORDSIZE
+sizeof(RAP_NetSessionDel_REQ)
+1
+RAP_MACHNAME_LEN
+WORDSIZE];
char *p;
char *rparam = NULL;
char *rdata = NULL;
unsigned int rprcnt, rdrcnt;
int res;
memset(param, '\0', sizeof(param));
p = make_header(param, RAP_WsessionDel, RAP_NetSessionDel_REQ, NULL);
PUTSTRING(p, workstation, RAP_MACHNAME_LEN-1);
PUTWORD(p,0);
if (cli_api(cli,
param, PTR_DIFF(p,param), 1024,
NULL, 0, 200,
&rparam, &rprcnt,
&rdata, &rdrcnt))
{
res = GETRES(rparam);
cli->rap_error = res;
if (res == 0) {
}
else {
DEBUG(4,("NetFileClose2 res=%d\n", res));
}
} else {
res = -1;
DEBUG(4,("NetFileClose2 failed\n"));
}
SAFE_FREE(rparam);
SAFE_FREE(rdata);
return res;
}
int cli_NetConnectionEnum(struct cli_state *cli, const char *qualifier, void (*fn)(uint16 conid, uint16 contype, uint16 numopens, uint16 numusers, uint32 contime, const char *username, const char *netname))
{
char param[WORDSIZE
+sizeof(RAP_NetConnectionEnum_REQ)
+sizeof(RAP_CONNECTION_INFO_L1)
+RAP_MACHNAME_LEN
+WORDSIZE
+WORDSIZE];
char *p;
char *rparam = NULL;
char *rdata = NULL;
unsigned int rprcnt, rdrcnt;
int res = -1;
memset(param, '\0', sizeof(param));
p = make_header(param, RAP_WconnectionEnum,
RAP_NetConnectionEnum_REQ, RAP_CONNECTION_INFO_L1);
PUTSTRING(p, qualifier, RAP_MACHNAME_LEN-1);
PUTWORD(p,1);
PUTWORD(p,0xFFE0);
if (cli_api(cli,
param, PTR_DIFF(p,param),PTR_DIFF(p,param),
NULL, 0, CLI_BUFFER_SIZE,
&rparam, &rprcnt,
&rdata, &rdrcnt)) {
res = GETRES(rparam);
cli->rap_error = res;
if (res != 0) {
DEBUG(1,("NetConnectionEnum gave error %d\n", res));
}
}
if (rdata) {
if (res == 0 || res == ERRmoredata) {
int i, converter, count;
p = rparam + WORDSIZE;
GETWORD(p, converter);
GETWORD(p, count);
for (i=0,p=rdata;i<count;i++) {
pstring netname, username;
uint16 conn_id, conn_type, num_opens, num_users;
unsigned int conn_time;
GETWORD(p,conn_id);
GETWORD(p,conn_type);
GETWORD(p,num_opens);
GETWORD(p,num_users);
GETDWORD(p,conn_time);
GETSTRINGP(p, username, rdata, converter);
GETSTRINGP(p, netname, rdata, converter);
fn(conn_id, conn_type, num_opens, num_users, conn_time,
username, netname);
}
} else {
DEBUG(4,("NetConnectionEnum res=%d\n", res));
}
} else {
DEBUG(4,("NetConnectionEnum no data returned\n"));
}
SAFE_FREE(rdata);
SAFE_FREE(rparam);
return res;
}