?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
preparing for release of 3.0-alpha11
[Samba/ekacnet.git] / source / libsmb / clirap2.c
blob2fde0c70e501269f863f2b3ed3c7b150d1c88722
1 /*
2 Samba Unix/Linux SMB client library
3 Version 3.0
4 More client RAP (SMB Remote Procedure Calls) functions
5 Copyright (C) 2001 Steve French (sfrench@us.ibm.com)
6 Copyright (C) 2001 Jim McDonough (jmcd@us.ibm.com)
7
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 /*****************************************************/
25 /* */
26 /* Additional RAP functionality */
27 /* */
28 /* RAP is the original SMB RPC, documented */
29 /* by Microsoft and X/Open in the 1990s and */
30 /* supported by most SMB/CIFS servers although */
31 /* it is unlikely that any one implementation */
32 /* supports all RAP command codes since some */
33 /* are quite obsolete and a few are specific */
34 /* to a particular network operating system */
35 /* */
36 /* Although it has largely been replaced */
37 /* for complex remote admistration and management */
38 /* (of servers) by the relatively newer */
39 /* DCE/RPC based remote API (which better handles */
40 /* large >64K data structures), there are many */
41 /* important administrative and resource location */
42 /* tasks and user tasks (e.g. password change) */
43 /* that are performed via RAP. */
44 /* */
45 /* Although a few of the RAP calls are implemented */
46 /* in the Samba client library already (clirap.c) */
47 /* the new ones are in clirap2.c for easy patching */
48 /* and integration and a corresponding header */
49 /* file, rap.h, has been created. */
50 /* */
51 /* This is based on data from the CIFS spec */
52 /* and the LAN Server and LAN Manager */
53 /* Programming Reference books and published */
54 /* RAP document and CIFS forum postings and */
55 /* lots of trial and error */
56 /* */
57 /* Function names changed from API_ (as they are */
58 /* in the CIFS specification) to RAP_ in order */
59 /* to avoid confusion with other API calls */
60 /* sent via DCE RPC */
61 /* */
62 /*****************************************************/
63
64 /*****************************************************/
65 /* */
66 /* cifsrap.c already includes support for: */
67 /* */
68 /* WshareEnum ( API number 0, level 1) */
69 /* NetServerEnum2 (API num 104, level 1) */
70 /* WWkstaUserLogon (132) */
71 /* SamOEMchgPasswordUser2_P (214) */
72 /* */
73 /* cifsprint.c already includes support for: */
74 /* */
75 /* WPrintJobEnum (API num 76, level 2) */
76 /* WPrintJobDel (API num 81) */
77 /* */
78 /*****************************************************/
79
80 #define NO_SYSLOG
81
82 #include "includes.h"
83
84 #define WORDSIZE 2
85 #define DWORDSIZE 4
86
87 #define PUTBYTE(p,b) do {SCVAL(p,0,b); p++;} while(0)
88 #define GETBYTE(p,b) do {b = CVAL(p,0); p++;} while(0)
89 #define PUTWORD(p,w) do {SSVAL(p,0,w); p += WORDSIZE;} while(0)
90 #define GETWORD(p,w) do {w = SVAL(p,0); p += WORDSIZE;} while(0)
91 #define PUTDWORD(p,d) do {SIVAL(p,0,d); p += DWORDSIZE;} while(0)
92 #define GETDWORD(p,d) do {d = IVAL(p,0); p += DWORDSIZE;} while(0)
93 #define GETRES(p) p ? SVAL(p,0) : -1
94 /* put string s at p with max len n and increment p past string */
95 #define PUTSTRING(p,s,n) do {\
96 push_ascii(p,s?s:"",n?n:256,STR_TERMINATE);\
97 p = skip_string(p,1);\
98 } while(0)
99 /* put string s and p, using fixed len l, and increment p by l */
100 #define PUTSTRINGF(p,s,l) do {\
101 push_ascii(p,s?s:"",l,STR_TERMINATE);\
102 p += l;\
103 } while (0)
104 /* put string pointer at p, supplying offset o from rdata r, store */
105 /* dword offset at p, increment p by 4 and o by length of s. This */
106 /* means on the first call, you must calc the offset yourself! */
107 #define PUTSTRINGP(p,s,r,o) do {\
108 if (s) {\
109 push_ascii(r+o,s,strlen(s)+1,STR_TERMINATE);\
110 PUTDWORD(p,o);\
111 o += strlen(s) + 1;\
112 } else PUTDWORD(p,0);\
113 }while(0);
114 /* get asciiz string s from p, increment p past string */
115 #define GETSTRING(p,s) do {\
116 pull_ascii_pstring(s,p);\
117 p = skip_string(p,1);\
118 } while(0)
119 /* get fixed length l string s from p, increment p by l */
120 #define GETSTRINGF(p,s,l) do {\
121 pull_ascii_pstring(s,p);\
122 p += l;\
123 } while(0)
124 /* get string s from offset (obtained at p) from rdata r - converter c */
125 #define GETSTRINGP(p,s,r,c) do {\
126 uint32 off;\
127 GETDWORD(p,off);\
128 off &= 0x0000FFFF; /* mask the obsolete segment number from the offset */ \
129 pull_ascii_pstring(s, off?(r+off-c):"");\
130 } while(0)
131
132 static char *make_header(char *param, uint16 apinum, char *reqfmt, char *datafmt)
133 {
134 PUTWORD(param,apinum);
135 if (reqfmt)
136 PUTSTRING(param,reqfmt,0);
137 else
138 *param++ = (char) 0;
139
140 if (datafmt)
141 PUTSTRING(param,datafmt,0);
142 else
143 *param++ = (char) 0;
144
145 return param;
146 }
147
148
149 /****************************************************************************
150 call a NetGroupDelete - delete user group from remote server
151 ****************************************************************************/
152 int cli_NetGroupDelete(struct cli_state *cli, const char *group_name )
153 {
154 char *rparam = NULL;
155 char *rdata = NULL;
156 char *p;
157 int rdrcnt,rprcnt, res;
158 char param[WORDSIZE /* api number */
159 +sizeof(RAP_NetGroupDel_REQ) /* parm string */
160 +1 /* no ret string */
161 +RAP_GROUPNAME_LEN /* group to del */
162 +WORDSIZE]; /* reserved word */
163
164 /* now send a SMBtrans command with api GroupDel */
165 p = make_header(param, RAP_WGroupDel, RAP_NetGroupDel_REQ, NULL);
166 PUTSTRING(p, group_name, RAP_GROUPNAME_LEN);
167 PUTWORD(p,0); /* reserved word MBZ on input */
168
169 if (cli_api(cli,
170 param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
171 NULL, 0, 200, /* data, length, maxlen */
172 &rparam, &rprcnt, /* return params, length */
173 &rdata, &rdrcnt)) /* return data, length */
174 {
175 res = GETRES(rparam);
176
177 if (res == 0) {
178 /* nothing to do */
179 }
180 else if ((res == 5) || (res == 65)) {
181 DEBUG(1, ("Access Denied\n"));
182 }
183 else if (res == 2220) {
184 DEBUG (1, ("Group does not exist\n"));
185 }
186 else {
187 DEBUG(4,("NetGroupDelete res=%d\n", res));
188 }
189 } else {
190 res = -1;
191 DEBUG(4,("NetGroupDelete failed\n"));
192 }
193
194 SAFE_FREE(rparam);
195 SAFE_FREE(rdata);
196
197 return res;
198 }
199
200 /****************************************************************************
201 call a NetGroupAdd - add user group to remote server
202 ****************************************************************************/
203 int cli_NetGroupAdd(struct cli_state *cli, RAP_GROUP_INFO_1 * grinfo )
204 {
205 char *rparam = NULL;
206 char *rdata = NULL;
207 char *p;
208 int rdrcnt,rprcnt,res;
209 char param[WORDSIZE /* api number */
210 +sizeof(RAP_NetGroupAdd_REQ) /* req string */
211 +sizeof(RAP_GROUP_INFO_L1) /* return string */
212 +WORDSIZE /* info level */
213 +WORDSIZE]; /* reserved word */
214
215 char data[1024];
216
217 /* offset into data of free format strings. Will be updated */
218 /* by PUTSTRINGP macro and end up with total data length. */
219 int soffset = RAP_GROUPNAME_LEN + 1 + DWORDSIZE;
220
221 /* now send a SMBtrans command with api WGroupAdd */
222
223 p = make_header(param, RAP_WGroupAdd,
224 RAP_NetGroupAdd_REQ, RAP_GROUP_INFO_L1);
225 PUTWORD(p, 1); /* info level */
226 PUTWORD(p, 0); /* reserved word 0 */
227
228 p = data;
229 PUTSTRINGF(p, grinfo->group_name, RAP_GROUPNAME_LEN);
230 PUTBYTE(p, 0); /* pad byte 0 */
231 PUTSTRINGP(p, grinfo->comment, data, soffset);
232
233 if (cli_api(cli,
234 param, sizeof(param), 1024, /* Param, length, maxlen */
235 data, soffset, sizeof(data), /* data, length, maxlen */
236 &rparam, &rprcnt, /* return params, length */
237 &rdata, &rdrcnt)) /* return data, length */
238 {
239 res = GETRES(rparam);
240
241 if (res == 0) {
242 /* nothing to do */
243 } else if ((res == 5) || (res == 65)) {
244 DEBUG(1, ("Access Denied\n"));
245 }
246 else if (res == 2223) {
247 DEBUG (1, ("Group already exists\n"));
248 }
249 else {
250 DEBUG(4,("NetGroupAdd res=%d\n", res));
251 }
252 } else {
253 res = -1;
254 DEBUG(4,("NetGroupAdd failed\n"));
255 }
256
257 SAFE_FREE(rparam);
258 SAFE_FREE(rdata);
259
260 return res;
261 }
262
263 /****************************************************************************
264 call a NetGroupEnum - try and list user groups on a different host
265 ****************************************************************************/
266 int cli_RNetGroupEnum(struct cli_state *cli, void (*fn)(const char *, const char *, void *), void *state)
267 {
268 char param[WORDSIZE /* api number */
269 +sizeof(RAP_NetGroupEnum_REQ) /* parm string */
270 +sizeof(RAP_GROUP_INFO_L1) /* return string */
271 +WORDSIZE /* info level */
272 +WORDSIZE]; /* buffer size */
273 char *p;
274 char *rparam = NULL;
275 char *rdata = NULL;
276 int rprcnt, rdrcnt;
277 int res = -1;
278
279
280 memset(param, '\0', sizeof(param));
281 p = make_header(param, RAP_WGroupEnum,
282 RAP_NetGroupEnum_REQ, RAP_GROUP_INFO_L1);
283 PUTWORD(p,1); /* Info level 1 */ /* add level 0 */
284 PUTWORD(p,0xFFE0); /* Return buffer size */
285
286 if (cli_api(cli,
287 param, PTR_DIFF(p,param),8,
288 NULL, 0, 0xFFE0 /* data area size */,
289 &rparam, &rprcnt,
290 &rdata, &rdrcnt)) {
291 res = GETRES(rparam);
292 cli->rap_error = res;
293 if(cli->rap_error == 234)
294 DEBUG(1,("Not all group names were returned (such as those longer than 21 characters)\n"));
295 else if (cli->rap_error != 0) {
296 DEBUG(1,("NetGroupEnum gave error %d\n", cli->rap_error));
297 }
298 }
299
300 if (rdata) {
301 if (res == 0 || res == ERRmoredata) {
302 int i, converter, count;
303
304 p = rparam + WORDSIZE; /* skip result */
305 GETWORD(p, converter);
306 GETWORD(p, count);
307
308 for (i=0,p=rdata;i<count;i++) {
309 pstring comment;
310 char groupname[RAP_GROUPNAME_LEN];
311
312 GETSTRINGF(p, groupname, RAP_GROUPNAME_LEN);
313 p++; /* pad byte */
314 GETSTRINGP(p, comment, rdata, converter);
315
316 fn(groupname, comment, cli);
317 }
318 } else {
319 DEBUG(4,("NetGroupEnum res=%d\n", res));
320 }
321 } else {
322 DEBUG(4,("NetGroupEnum no data returned\n"));
323 }
324
325 SAFE_FREE(rparam);
326 SAFE_FREE(rdata);
327
328 return res;
329 }
330
331 int cli_NetGroupDelUser(struct cli_state * cli, const char *group_name, const char *user_name)
332 {
333 char *rparam = NULL;
334 char *rdata = NULL;
335 char *p;
336 int rdrcnt,rprcnt,res;
337 char param[WORDSIZE /* api number */
338 +sizeof(RAP_NetGroupDelUser_REQ) /* parm string */
339 +1 /* no ret string */
340 +RAP_GROUPNAME_LEN /* group name */
341 +RAP_USERNAME_LEN]; /* user to del */
342
343 /* now send a SMBtrans command with api GroupMemberAdd */
344 p = make_header(param, RAP_WGroupDelUser, RAP_NetGroupDelUser_REQ, NULL);
345 PUTSTRING(p,group_name,RAP_GROUPNAME_LEN);
346 PUTSTRING(p,user_name,RAP_USERNAME_LEN);
347
348 if (cli_api(cli,
349 param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
350 NULL, 0, 200, /* data, length, maxlen */
351 &rparam, &rprcnt, /* return params, length */
352 &rdata, &rdrcnt)) /* return data, length */
353 {
354 res = GETRES(rparam);
355
356 switch(res) {
357 case 0:
358 break;
359 case 5:
360 case 65:
361 DEBUG(1, ("Access Denied\n"));
362 break;
363 case 50:
364 DEBUG(1, ("Not supported by server\n"));
365 break;
366 case 2220:
367 DEBUG(1, ("Group does not exist\n"));
368 break;
369 case 2221:
370 DEBUG(1, ("User does not exist\n"));
371 break;
372 case 2237:
373 DEBUG(1, ("User is not in group\n"));
374 break;
375 default:
376 DEBUG(4,("NetGroupDelUser res=%d\n", res));
377 }
378 } else {
379 res = -1;
380 DEBUG(4,("NetGroupDelUser failed\n"));
381 }
382
383 SAFE_FREE(rparam);
384 SAFE_FREE(rdata);
385
386 return res;
387 }
388
389 int cli_NetGroupAddUser(struct cli_state * cli, const char *group_name, const char *user_name)
390 {
391 char *rparam = NULL;
392 char *rdata = NULL;
393 char *p;
394 int rdrcnt,rprcnt,res;
395 char param[WORDSIZE /* api number */
396 +sizeof(RAP_NetGroupAddUser_REQ) /* parm string */
397 +1 /* no ret string */
398 +RAP_GROUPNAME_LEN /* group name */
399 +RAP_USERNAME_LEN]; /* user to add */
400
401 /* now send a SMBtrans command with api GroupMemberAdd */
402 p = make_header(param, RAP_WGroupAddUser, RAP_NetGroupAddUser_REQ, NULL);
403 PUTSTRING(p,group_name,RAP_GROUPNAME_LEN);
404 PUTSTRING(p,user_name,RAP_USERNAME_LEN);
405
406 if (cli_api(cli,
407 param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
408 NULL, 0, 200, /* data, length, maxlen */
409 &rparam, &rprcnt, /* return params, length */
410 &rdata, &rdrcnt)) /* return data, length */
411 {
412 res = GETRES(rparam);
413
414 switch(res) {
415 case 0:
416 break;
417 case 5:
418 case 65:
419 DEBUG(1, ("Access Denied\n"));
420 break;
421 case 50:
422 DEBUG(1, ("Not supported by server\n"));
423 break;
424 case 2220:
425 DEBUG(1, ("Group does not exist\n"));
426 break;
427 case 2221:
428 DEBUG(1, ("User does not exist\n"));
429 break;
430 default:
431 DEBUG(4,("NetGroupAddUser res=%d\n", res));
432 }
433 } else {
434 res = -1;
435 DEBUG(4,("NetGroupAddUser failed\n"));
436 }
437
438 SAFE_FREE(rparam);
439 SAFE_FREE(rdata);
440
441 return res;
442 }
443
444
445 int cli_NetGroupGetUsers(struct cli_state * cli, const char *group_name, void (*fn)(const char *, void *), void *state )
446 {
447 char *rparam = NULL;
448 char *rdata = NULL;
449 char *p;
450 int rdrcnt,rprcnt;
451 int res = -1;
452 char param[WORDSIZE /* api number */
453 +sizeof(RAP_NetGroupGetUsers_REQ)/* parm string */
454 +sizeof(RAP_GROUP_USERS_INFO_0) /* return string */
455 +RAP_GROUPNAME_LEN /* group name */
456 +WORDSIZE /* info level */
457 +WORDSIZE]; /* buffer size */
458
459 /* now send a SMBtrans command with api GroupGetUsers */
460 p = make_header(param, RAP_WGroupGetUsers,
461 RAP_NetGroupGetUsers_REQ, RAP_GROUP_USERS_INFO_0);
462 PUTSTRING(p,group_name,RAP_GROUPNAME_LEN-1);
463 PUTWORD(p,0); /* info level 0 */
464 PUTWORD(p,0xFFE0); /* return buffer size */
465
466 if (cli_api(cli,
467 param, PTR_DIFF(p,param),PTR_DIFF(p,param),
468 NULL, 0, CLI_BUFFER_SIZE,
469 &rparam, &rprcnt,
470 &rdata, &rdrcnt)) {
471 res = GETRES(rparam);
472 cli->rap_error = res;
473 if (res != 0) {
474 DEBUG(1,("NetGroupGetUsers gave error %d\n", res));
475 }
476 }
477 if (rdata) {
478 if (res == 0 || res == ERRmoredata) {
479 int i, converter, count;
480 fstring username;
481 p = rparam +WORDSIZE;
482 GETWORD(p, converter);
483 GETWORD(p, count);
484
485 for (i=0,p=rdata; i<count; i++) {
486 GETSTRINGF(p, username, RAP_USERNAME_LEN);
487 fn(username, state);
488 }
489 } else {
490 DEBUG(4,("NetGroupGetUsers res=%d\n", res));
491 }
492 } else {
493 DEBUG(4,("NetGroupGetUsers no data returned\n"));
494 }
495 SAFE_FREE(rdata);
496 SAFE_FREE(rparam);
497 return res;
498 }
499
500 int cli_NetUserGetGroups(struct cli_state * cli, const char *user_name, void (*fn)(const char *, void *), void *state )
501 {
502 char *rparam = NULL;
503 char *rdata = NULL;
504 char *p;
505 int rdrcnt,rprcnt;
506 int res = -1;
507 char param[WORDSIZE /* api number */
508 +sizeof(RAP_NetUserGetGroups_REQ)/* parm string */
509 +sizeof(RAP_GROUP_USERS_INFO_0) /* return string */
510 +RAP_USERNAME_LEN /* user name */
511 +WORDSIZE /* info level */
512 +WORDSIZE]; /* buffer size */
513
514 /* now send a SMBtrans command with api GroupGetUsers */
515 p = make_header(param, RAP_WUserGetGroups,
516 RAP_NetUserGetGroups_REQ, RAP_GROUP_USERS_INFO_0);
517 PUTSTRING(p,user_name,RAP_USERNAME_LEN-1);
518 PUTWORD(p,0); /* info level 0 */
519 PUTWORD(p,0xFFE0); /* return buffer size */
520
521 if (cli_api(cli,
522 param, PTR_DIFF(p,param),PTR_DIFF(p,param),
523 NULL, 0, CLI_BUFFER_SIZE,
524 &rparam, &rprcnt,
525 &rdata, &rdrcnt)) {
526 res = GETRES(rparam);
527 cli->rap_error = res;
528 if (res != 0) {
529 DEBUG(1,("NetUserGetGroups gave error %d\n", res));
530 }
531 }
532 if (rdata) {
533 if (res == 0 || res == ERRmoredata) {
534 int i, converter, count;
535 fstring groupname;
536 p = rparam +WORDSIZE;
537 GETWORD(p, converter);
538 GETWORD(p, count);
539
540 for (i=0,p=rdata; i<count; i++) {
541 GETSTRINGF(p, groupname, RAP_USERNAME_LEN);
542 fn(groupname, state);
543 }
544 } else {
545 DEBUG(4,("NetUserGetGroups res=%d\n", res));
546 }
547 } else {
548 DEBUG(4,("NetUserGetGroups no data returned\n"));
549 }
550 SAFE_FREE(rdata);
551 SAFE_FREE(rparam);
552 return res;
553 }
554
555
556 /****************************************************************************
557 call a NetUserDelete - delete user from remote server
558 ****************************************************************************/
559 int cli_NetUserDelete(struct cli_state *cli, const char * user_name )
560 {
561 char *rparam = NULL;
562 char *rdata = NULL;
563 char *p;
564 int rdrcnt,rprcnt, res;
565 char param[WORDSIZE /* api number */
566 +sizeof(RAP_NetGroupDel_REQ) /* parm string */
567 +1 /* no ret string */
568 +RAP_USERNAME_LEN /* user to del */
569 +WORDSIZE]; /* reserved word */
570
571 /* now send a SMBtrans command with api UserDel */
572 p = make_header(param, RAP_WUserDel, RAP_NetGroupDel_REQ, NULL);
573 PUTSTRING(p, user_name, RAP_USERNAME_LEN);
574 PUTWORD(p,0); /* reserved word MBZ on input */
575
576 if (cli_api(cli,
577 param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
578 NULL, 0, 200, /* data, length, maxlen */
579 &rparam, &rprcnt, /* return params, length */
580 &rdata, &rdrcnt)) /* return data, length */
581 {
582 res = GETRES(rparam);
583
584 if (res == 0) {
585 /* nothing to do */
586 }
587 else if ((res == 5) || (res == 65)) {
588 DEBUG(1, ("Access Denied\n"));
589 }
590 else if (res == 2221) {
591 DEBUG (1, ("User does not exist\n"));
592 }
593 else {
594 DEBUG(4,("NetUserDelete res=%d\n", res));
595 }
596 } else {
597 res = -1;
598 DEBUG(4,("NetUserDelete failed\n"));
599 }
600
601 SAFE_FREE(rparam);
602 SAFE_FREE(rdata);
603
604 return res;
605 }
606
607 /****************************************************************************
608 call a NetUserAdd - add user to remote server
609 ****************************************************************************/
610 int cli_NetUserAdd(struct cli_state *cli, RAP_USER_INFO_1 * userinfo )
611 {
612
613
614
615 char *rparam = NULL;
616 char *rdata = NULL;
617 char *p;
618 int rdrcnt,rprcnt,res;
619 char param[WORDSIZE /* api number */
620 +sizeof(RAP_NetUserAdd2_REQ) /* req string */
621 +sizeof(RAP_USER_INFO_L1) /* data string */
622 +WORDSIZE /* info level */
623 +WORDSIZE /* buffer length */
624 +WORDSIZE]; /* reserved */
625
626 char data[1024];
627 /* offset into data of free format strings. Will be updated */
628 /* by PUTSTRINGP macro and end up with total data length. */
629 int soffset=RAP_USERNAME_LEN+1 /* user name + pad */
630 + RAP_UPASSWD_LEN /* password */
631 + DWORDSIZE /* password age */
632 + WORDSIZE /* privilege */
633 + DWORDSIZE /* home dir ptr */
634 + DWORDSIZE /* comment ptr */
635 + WORDSIZE /* flags */
636 + DWORDSIZE; /* login script ptr*/
637
638 /* now send a SMBtrans command with api NetUserAdd */
639 p = make_header(param, RAP_WUserAdd2,
640 RAP_NetUserAdd2_REQ, RAP_USER_INFO_L1);
641 PUTWORD(p, 1); /* info level */
642
643 PUTWORD(p, 0); /* pwencrypt */
644 if(userinfo->passwrd)
645 PUTWORD(p,MIN(strlen(userinfo->passwrd), RAP_UPASSWD_LEN));
646 else
647 PUTWORD(p, 0); /* password length */
648
649 p = data;
650 memset(data, '\0', soffset);
651
652 PUTSTRINGF(p, userinfo->user_name, RAP_USERNAME_LEN);
653 PUTBYTE(p, 0); /* pad byte 0 */
654 PUTSTRINGF(p, userinfo->passwrd, RAP_UPASSWD_LEN);
655 PUTDWORD(p, 0); /* pw age - n.a. on user add */
656 PUTWORD(p, userinfo->priv);
657 PUTSTRINGP(p, userinfo->home_dir, data, soffset);
658 PUTSTRINGP(p, userinfo->comment, data, soffset);
659 PUTWORD(p, userinfo->userflags);
660 PUTSTRINGP(p, userinfo->logon_script, data, soffset);
661
662 if (cli_api(cli,
663 param, sizeof(param), 1024, /* Param, length, maxlen */
664 data, soffset, sizeof(data), /* data, length, maxlen */
665 &rparam, &rprcnt, /* return params, length */
666 &rdata, &rdrcnt)) /* return data, length */
667 {
668 res = GETRES(rparam);
669
670 if (res == 0) {
671 /* nothing to do */
672 }
673 else if ((res == 5) || (res == 65)) {
674 DEBUG(1, ("Access Denied\n"));
675 }
676 else if (res == 2224) {
677 DEBUG (1, ("User already exists\n"));
678 }
679 else {
680 DEBUG(4,("NetUserAdd res=%d\n", res));
681 }
682 } else {
683 res = -1;
684 DEBUG(4,("NetUserAdd failed\n"));
685 }
686
687 SAFE_FREE(rparam);
688 SAFE_FREE(rdata);
689
690 return res;
691 }
692
693 /****************************************************************************
694 call a NetUserEnum - try and list users on a different host
695 ****************************************************************************/
696 int cli_RNetUserEnum(struct cli_state *cli, void (*fn)(const char *, const char *, const char *, const char *, void *), void *state)
697 {
698 char param[WORDSIZE /* api number */
699 +sizeof(RAP_NetUserEnum_REQ) /* parm string */
700 +sizeof(RAP_USER_INFO_L1) /* return string */
701 +WORDSIZE /* info level */
702 +WORDSIZE]; /* buffer size */
703 char *p;
704 char *rparam = NULL;
705 char *rdata = NULL;
706 int rprcnt, rdrcnt;
707 int res = -1;
708
709
710 memset(param, '\0', sizeof(param));
711 p = make_header(param, RAP_WUserEnum,
712 RAP_NetUserEnum_REQ, RAP_USER_INFO_L1);
713 PUTWORD(p,1); /* Info level 1 */
714 PUTWORD(p,0xFF00); /* Return buffer size */
715
716 /* BB Fix handling of large numbers of users to be returned */
717 if (cli_api(cli,
718 param, PTR_DIFF(p,param),8,
719 NULL, 0, CLI_BUFFER_SIZE,
720 &rparam, &rprcnt,
721 &rdata, &rdrcnt)) {
722 res = GETRES(rparam);
723 cli->rap_error = res;
724 if (cli->rap_error != 0) {
725 DEBUG(1,("NetUserEnum gave error %d\n", cli->rap_error));
726 }
727 }
728 if (rdata) {
729 if (res == 0 || res == ERRmoredata) {
730 int i, converter, count;
731 char username[RAP_USERNAME_LEN];
732 char userpw[RAP_UPASSWD_LEN];
733 pstring comment, homedir, logonscript;
734 int pwage, priv, flags;
735
736 p = rparam + WORDSIZE; /* skip result */
737 GETWORD(p, converter);
738 GETWORD(p, count);
739
740 for (i=0,p=rdata;i<count;i++) {
741 GETSTRINGF(p, username, RAP_USERNAME_LEN);
742 p++; /* pad byte */
743 GETSTRINGF(p, userpw, RAP_UPASSWD_LEN);
744 GETDWORD(p, pwage); /* password age */
745 GETWORD(p, priv); /* 0=guest, 1=user, 2=admin */
746 GETSTRINGP(p, homedir, rdata, converter);
747 GETSTRINGP(p, comment, rdata, converter);
748 GETWORD(p, flags);
749 GETSTRINGP(p, logonscript, rdata, converter);
750
751 fn(username, comment, homedir, logonscript, cli);
752 }
753 } else {
754 DEBUG(4,("NetUserEnum res=%d\n", res));
755 }
756 } else {
757 DEBUG(4,("NetUserEnum no data returned\n"));
758 }
759
760 SAFE_FREE(rparam);
761 SAFE_FREE(rdata);
762
763 return res;
764 }
765
766 /****************************************************************************
767 call a NetFileClose2 - close open file on another session to server
768 ****************************************************************************/
769 int cli_NetFileClose(struct cli_state *cli, uint32 file_id )
770 {
771 char *rparam = NULL;
772 char *rdata = NULL;
773 char *p;
774 int rdrcnt,rprcnt;
775 char param[WORDSIZE /* api number */
776 +sizeof(RAP_WFileClose2_REQ) /* req string */
777 +1 /* no ret string */
778 +DWORDSIZE]; /* file ID */
779 int res = -1;
780
781 /* now send a SMBtrans command with api RNetShareEnum */
782 p = make_header(param, RAP_WFileClose2, RAP_WFileClose2_REQ, NULL);
783 PUTDWORD(p, file_id);
784
785 if (cli_api(cli,
786 param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
787 NULL, 0, 200, /* data, length, maxlen */
788 &rparam, &rprcnt, /* return params, length */
789 &rdata, &rdrcnt)) /* return data, length */
790 {
791 res = GETRES(rparam);
792
793 if (res == 0) {
794 /* nothing to do */
795 } else if (res == 2314){
796 DEBUG(1, ("NetFileClose2 - attempt to close non-existant file open instance\n"));
797 } else {
798 DEBUG(4,("NetFileClose2 res=%d\n", res));
799 }
800 } else {
801 res = -1;
802 DEBUG(4,("NetFileClose2 failed\n"));
803 }
804
805 SAFE_FREE(rparam);
806 SAFE_FREE(rdata);
807
808 return res;
809 }
810
811 /****************************************************************************
812 call a NetFileGetInfo - get information about server file opened from other
813 workstation
814 ****************************************************************************/
815 int cli_NetFileGetInfo(struct cli_state *cli, uint32 file_id, void (*fn)(const char *, const char *, uint16, uint16, uint32))
816 {
817 char *rparam = NULL;
818 char *rdata = NULL;
819 char *p;
820 int rdrcnt,rprcnt, res;
821 char param[WORDSIZE /* api number */
822 +sizeof(RAP_WFileGetInfo2_REQ) /* req string */
823 +sizeof(RAP_FILE_INFO_L3) /* return string */
824 +DWORDSIZE /* file ID */
825 +WORDSIZE /* info level */
826 +WORDSIZE]; /* buffer size */
827
828 /* now send a SMBtrans command with api RNetShareEnum */
829 p = make_header(param, RAP_WFileGetInfo2,
830 RAP_WFileGetInfo2_REQ, RAP_FILE_INFO_L3);
831 PUTDWORD(p, file_id);
832 PUTWORD(p, 3); /* info level */
833 PUTWORD(p, 0x1000); /* buffer size */
834 if (cli_api(cli,
835 param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
836 NULL, 0, 0x1000, /* data, length, maxlen */
837 &rparam, &rprcnt, /* return params, length */
838 &rdata, &rdrcnt)) /* return data, length */
839 {
840 res = GETRES(rparam);
841 if (res == 0 || res == ERRmoredata) {
842 int converter,id, perms, locks;
843 pstring fpath, fuser;
844
845 p = rparam + WORDSIZE; /* skip result */
846 GETWORD(p, converter);
847
848 p = rdata;
849 GETDWORD(p, id);
850 GETWORD(p, perms);
851 GETWORD(p, locks);
852 GETSTRINGP(p, fpath, rdata, converter);
853 GETSTRINGP(p, fuser, rdata, converter);
854
855 fn(fpath, fuser, perms, locks, id);
856 } else {
857 DEBUG(4,("NetFileGetInfo2 res=%d\n", res));
858 }
859 } else {
860 res = -1;
861 DEBUG(4,("NetFileGetInfo2 failed\n"));
862 }
863
864 SAFE_FREE(rparam);
865 SAFE_FREE(rdata);
866
867 return res;
868 }
869
870 /****************************************************************************
871 * Call a NetFileEnum2 - list open files on an SMB server
872 *
873 * PURPOSE: Remotes a NetFileEnum API call to the current server or target
874 * server listing the files open via the network (and their
875 * corresponding open instance ids)
876 *
877 * Dependencies: none
878 *
879 * Parameters:
880 * cli - pointer to cli_state structure
881 * user - if present, return only files opened by this remote user
882 * base_path - if present, return only files opened below this
883 * base path
884 * fn - display function to invoke for each entry in the result
885 *
886 *
887 * Returns:
888 * True - success
889 * False - failure
890 *
891 ****************************************************************************/
892 int cli_NetFileEnum(struct cli_state *cli, char * user, char * base_path, void (*fn)(const char *, const char *, uint16, uint16, uint32))
893 {
894 char *rparam = NULL;
895 char *rdata = NULL;
896 char *p;
897 int rdrcnt,rprcnt;
898 char param[WORDSIZE /* api number */
899 +sizeof(RAP_WFileEnum2_REQ) /* req string */
900 +sizeof(RAP_FILE_INFO_L3) /* return string */
901 +256 /* base path (opt) */
902 +RAP_USERNAME_LEN /* user name (opt) */
903 +WORDSIZE /* info level */
904 +WORDSIZE /* buffer size */
905 +DWORDSIZE /* resume key ? */
906 +DWORDSIZE]; /* resume key ? */
907 int count = -1;
908
909 /* now send a SMBtrans command with api RNetShareEnum */
910 p = make_header(param, RAP_WFileEnum2,
911 RAP_WFileEnum2_REQ, RAP_FILE_INFO_L3);
912
913 PUTSTRING(p, base_path, 256);
914 PUTSTRING(p, user, RAP_USERNAME_LEN);
915 PUTWORD(p, 3); /* info level */
916 PUTWORD(p, 0xFF00); /* buffer size */
917 PUTDWORD(p, 0); /* zero out the resume key */
918 PUTDWORD(p, 0); /* or is this one the resume key? */
919
920 if (cli_api(cli,
921 param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
922 NULL, 0, 0xFF00, /* data, length, maxlen */
923 &rparam, &rprcnt, /* return params, length */
924 &rdata, &rdrcnt)) /* return data, length */
925 {
926 int res = GETRES(rparam);
927
928 if (res == 0 || res == ERRmoredata) {
929 int converter, i;
930
931 p = rparam + WORDSIZE; /* skip result */
932 GETWORD(p, converter);
933 GETWORD(p, count);
934
935 p = rdata;
936 for (i=0; i<count; i++) {
937 int id, perms, locks;
938 pstring fpath, fuser;
939
940 GETDWORD(p, id);
941 GETWORD(p, perms);
942 GETWORD(p, locks);
943 GETSTRINGP(p, fpath, rdata, converter);
944 GETSTRINGP(p, fuser, rdata, converter);
945
946 fn(fpath, fuser, perms, locks, id);
947 } /* BB fix ERRmoredata case to send resume request */
948 } else {
949 DEBUG(4,("NetFileEnum2 res=%d\n", res));
950 }
951 } else {
952 DEBUG(4,("NetFileEnum2 failed\n"));
953 }
954
955 SAFE_FREE(rparam);
956 SAFE_FREE(rdata);
957
958 return count;
959 }
960
961 /****************************************************************************
962 call a NetShareAdd - share/export directory on remote server
963 ****************************************************************************/
964 int cli_NetShareAdd(struct cli_state *cli, RAP_SHARE_INFO_2 * sinfo )
965 {
966 char *rparam = NULL;
967 char *rdata = NULL;
968 char *p;
969 int rdrcnt,rprcnt,res;
970 char param[WORDSIZE /* api number */
971 +sizeof(RAP_WShareAdd_REQ) /* req string */
972 +sizeof(RAP_SHARE_INFO_L2) /* return string */
973 +WORDSIZE /* info level */
974 +WORDSIZE]; /* reserved word */
975 char data[1024];
976 /* offset to free format string section following fixed length data. */
977 /* will be updated by PUTSTRINGP macro and will end up with total len */
978 int soffset = RAP_SHARENAME_LEN + 1 /* share name + pad */
979 + WORDSIZE /* share type */
980 + DWORDSIZE /* comment pointer */
981 + WORDSIZE /* permissions */
982 + WORDSIZE /* max users */
983 + WORDSIZE /* active users */
984 + DWORDSIZE /* share path */
985 + RAP_SPASSWD_LEN + 1; /* share password + pad */
986
987 memset(param,'\0',sizeof(param));
988 /* now send a SMBtrans command with api RNetShareAdd */
989 p = make_header(param, RAP_WshareAdd,
990 RAP_WShareAdd_REQ, RAP_SHARE_INFO_L2);
991 PUTWORD(p, 2); /* info level */
992 PUTWORD(p, 0); /* reserved word 0 */
993
994 p = data;
995 PUTSTRINGF(p, sinfo->share_name, RAP_SHARENAME_LEN);
996 PUTBYTE(p, 0); /* pad byte 0 */
997
998 PUTWORD(p, sinfo->share_type);
999 PUTSTRINGP(p, sinfo->comment, data, soffset);
1000 PUTWORD(p, sinfo->perms);
1001 PUTWORD(p, sinfo->maximum_users);
1002 PUTWORD(p, sinfo->active_users);
1003 PUTSTRINGP(p, sinfo->path, data, soffset);
1004 PUTSTRINGF(p, sinfo->password, RAP_SPASSWD_LEN);
1005 SCVAL(p,-1,0x0A); /* required 0x0A at end of password */
1006
1007 if (cli_api(cli,
1008 param, sizeof(param), 1024, /* Param, length, maxlen */
1009 data, soffset, sizeof(data), /* data, length, maxlen */
1010 &rparam, &rprcnt, /* return params, length */
1011 &rdata, &rdrcnt)) /* return data, length */
1012 {
1013 res = rparam? SVAL(rparam,0) : -1;
1014
1015 if (res == 0) {
1016 /* nothing to do */
1017 }
1018 else {
1019 DEBUG(4,("NetShareAdd res=%d\n", res));
1020 }
1021 } else {
1022 res = -1;
1023 DEBUG(4,("NetShareAdd failed\n"));
1024 }
1025
1026 SAFE_FREE(rparam);
1027 SAFE_FREE(rdata);
1028
1029 return res;
1030 }
1031 /****************************************************************************
1032 call a NetShareDelete - unshare exported directory on remote server
1033 ****************************************************************************/
1034 int cli_NetShareDelete(struct cli_state *cli, const char * share_name )
1035 {
1036 char *rparam = NULL;
1037 char *rdata = NULL;
1038 char *p;
1039 int rdrcnt,rprcnt, res;
1040 char param[WORDSIZE /* api number */
1041 +sizeof(RAP_WShareDel_REQ) /* req string */
1042 +1 /* no ret string */
1043 +RAP_SHARENAME_LEN /* share to del */
1044 +WORDSIZE]; /* reserved word */
1045
1046
1047 /* now send a SMBtrans command with api RNetShareDelete */
1048 p = make_header(param, RAP_WshareDel, RAP_WShareDel_REQ, NULL);
1049 PUTSTRING(p,share_name,RAP_SHARENAME_LEN);
1050 PUTWORD(p,0); /* reserved word MBZ on input */
1051
1052 if (cli_api(cli,
1053 param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
1054 NULL, 0, 200, /* data, length, maxlen */
1055 &rparam, &rprcnt, /* return params, length */
1056 &rdata, &rdrcnt)) /* return data, length */
1057 {
1058 res = GETRES(rparam);
1059
1060 if (res == 0) {
1061 /* nothing to do */
1062 }
1063 else {
1064 DEBUG(4,("NetShareDelete res=%d\n", res));
1065 }
1066 } else {
1067 res = -1;
1068 DEBUG(4,("NetShareDelete failed\n"));
1069 }
1070
1071 SAFE_FREE(rparam);
1072 SAFE_FREE(rdata);
1073
1074 return res;
1075 }
1076 /*************************************************************************
1077 *
1078 * Function Name: cli_get_pdc_name
1079 *
1080 * PURPOSE: Remotes a NetServerEnum API call to the current server
1081 * requesting the name of a server matching the server
1082 * type of SV_TYPE_DOMAIN_CTRL (PDC).
1083 *
1084 * Dependencies: none
1085 *
1086 * Parameters:
1087 * cli - pointer to cli_state structure
1088 * workgroup - pointer to string containing name of domain
1089 * pdc_name - pointer to string that will contain PDC name
1090 * on successful return
1091 *
1092 * Returns:
1093 * True - success
1094 * False - failure
1095 *
1096 ************************************************************************/
1097 BOOL cli_get_pdc_name(struct cli_state *cli, char *workgroup, char *pdc_name)
1098 {
1099 char *rparam = NULL;
1100 char *rdata = NULL;
1101 int rdrcnt,rprcnt;
1102 char *p;
1103 char param[WORDSIZE /* api number */
1104 +sizeof(RAP_NetServerEnum2_REQ) /* req string */
1105 +sizeof(RAP_SERVER_INFO_L1) /* return string */
1106 +WORDSIZE /* info level */
1107 +WORDSIZE /* buffer size */
1108 +DWORDSIZE /* server type */
1109 +RAP_MACHNAME_LEN]; /* workgroup */
1110 int count = -1;
1111
1112 *pdc_name = '\0';
1113
1114 /* send a SMBtrans command with api NetServerEnum */
1115 p = make_header(param, RAP_NetServerEnum2,
1116 RAP_NetServerEnum2_REQ, RAP_SERVER_INFO_L1);
1117 PUTWORD(p, 1); /* info level */
1118 PUTWORD(p, CLI_BUFFER_SIZE);
1119 PUTDWORD(p, SV_TYPE_DOMAIN_CTRL);
1120 PUTSTRING(p, workgroup, RAP_MACHNAME_LEN);
1121
1122 if (cli_api(cli,
1123 param, PTR_DIFF(p,param), 8, /* params, length, max */
1124 NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
1125 &rparam, &rprcnt, /* return params, return size */
1126 &rdata, &rdrcnt /* return data, return size */
1127 )) {
1128 cli->rap_error = GETRES(rparam);
1129
1130 /*
1131 * We only really care to copy a name if the
1132 * API succeeded and we got back a name.
1133 */
1134 if (cli->rap_error == 0) {
1135 p = rparam + WORDSIZE + WORDSIZE; /* skip result and converter */
1136 GETWORD(p, count);
1137 p = rdata;
1138
1139 if (count > 0)
1140 GETSTRING(p, pdc_name);
1141 }
1142 else {
1143 DEBUG(4,("cli_get_pdc_name: machine %s failed the NetServerEnum call. "
1144 "Error was : %s.\n", cli->desthost, cli_errstr(cli) ));
1145 }
1146 }
1147
1148 SAFE_FREE(rparam);
1149 SAFE_FREE(rdata);
1150
1151 return(count > 0);
1152 }
1153
1154
1155 /*************************************************************************
1156 *
1157 * Function Name: cli_get_server_domain
1158 *
1159 * PURPOSE: Remotes a NetWkstaGetInfo API call to the current server
1160 * requesting wksta_info_10 level information to determine
1161 * the domain the server belongs to. On success, this
1162 * routine sets the server_domain field in the cli_state structure
1163 * to the server's domain name.
1164 *
1165 * Dependencies: none
1166 *
1167 * Parameters:
1168 * cli - pointer to cli_state structure
1169 *
1170 * Returns:
1171 * True - success
1172 * False - failure
1173 *
1174 * Origins: samba 2.0.6 source/libsmb/clientgen.c cli_NetServerEnum()
1175 *
1176 ************************************************************************/
1177 BOOL cli_get_server_domain(struct cli_state *cli)
1178 {
1179 char *rparam = NULL;
1180 char *rdata = NULL;
1181 int rdrcnt,rprcnt;
1182 char *p;
1183 char param[WORDSIZE /* api number */
1184 +sizeof(RAP_WWkstaGetInfo_REQ) /* req string */
1185 +sizeof(RAP_WKSTA_INFO_L10) /* return string */
1186 +WORDSIZE /* info level */
1187 +WORDSIZE]; /* buffer size */
1188 int res = -1;
1189
1190 /* send a SMBtrans command with api NetWkstaGetInfo */
1191 p = make_header(param, RAP_WWkstaGetInfo,
1192 RAP_WWkstaGetInfo_REQ, RAP_WKSTA_INFO_L10);
1193 PUTWORD(p, 10); /* info level */
1194 PUTWORD(p, CLI_BUFFER_SIZE);
1195
1196 if (cli_api(cli, param, PTR_DIFF(p,param), 8, /* params, length, max */
1197 NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
1198 &rparam, &rprcnt, /* return params, return size */
1199 &rdata, &rdrcnt)) { /* return data, return size */
1200 res = GETRES(rparam);
1201 p = rdata;
1202
1203 if (res == 0) {
1204 int converter;
1205
1206 p = rparam + WORDSIZE;
1207 GETWORD(p, converter);
1208
1209 p = rdata + DWORDSIZE + DWORDSIZE; /* skip computer & user names */
1210 GETSTRINGP(p, cli->server_domain, rdata, converter);
1211 }
1212 }
1213
1214 SAFE_FREE(rparam);
1215 SAFE_FREE(rdata);
1216
1217 return(res == 0);
1218 }
1219
1220
1221 /*************************************************************************
1222 *
1223 * Function Name: cli_get_server_type
1224 *
1225 * PURPOSE: Remotes a NetServerGetInfo API call to the current server
1226 * requesting server_info_1 level information to retrieve
1227 * the server type.
1228 *
1229 * Dependencies: none
1230 *
1231 * Parameters:
1232 * cli - pointer to cli_state structure
1233 * pstype - pointer to uint32 to contain returned server type
1234 *
1235 * Returns:
1236 * True - success
1237 * False - failure
1238 *
1239 * Origins: samba 2.0.6 source/libsmb/clientgen.c cli_NetServerEnum()
1240 *
1241 ************************************************************************/
1242 BOOL cli_get_server_type(struct cli_state *cli, uint32 *pstype)
1243 {
1244 char *rparam = NULL;
1245 char *rdata = NULL;
1246 int rdrcnt,rprcnt;
1247 char *p;
1248 char param[WORDSIZE /* api number */
1249 +sizeof(RAP_WserverGetInfo_REQ) /* req string */
1250 +sizeof(RAP_SERVER_INFO_L1) /* return string */
1251 +WORDSIZE /* info level */
1252 +WORDSIZE]; /* buffer size */
1253 int res = -1;
1254
1255 /* send a SMBtrans command with api NetServerGetInfo */
1256 p = make_header(param, RAP_WserverGetInfo,
1257 RAP_WserverGetInfo_REQ, RAP_SERVER_INFO_L1);
1258 PUTWORD(p, 1); /* info level */
1259 PUTWORD(p, CLI_BUFFER_SIZE);
1260
1261 if (cli_api(cli,
1262 param, PTR_DIFF(p,param), 8, /* params, length, max */
1263 NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
1264 &rparam, &rprcnt, /* return params, return size */
1265 &rdata, &rdrcnt /* return data, return size */
1266 )) {
1267
1268 res = GETRES(rparam);
1269
1270 if (res == 0 || res == ERRmoredata) {
1271 p = rdata;
1272 *pstype = IVAL(p,18) & ~SV_TYPE_LOCAL_LIST_ONLY;
1273 }
1274 }
1275
1276 SAFE_FREE(rparam);
1277 SAFE_FREE(rdata);
1278
1279 return(res == 0 || res == ERRmoredata);
1280 }
1281
1282
1283 /*************************************************************************
1284 *
1285 * Function Name: cli_ns_check_server_type
1286 *
1287 * PURPOSE: Remotes a NetServerEnum2 API call to the current server
1288 * requesting server_info_0 level information of machines
1289 * matching the given server type. If the returned server
1290 * list contains the machine name contained in cli->desthost
1291 * then we conclude the server type checks out. This routine
1292 * is useful to retrieve list of server's of a certain
1293 * type when all you have is a null session connection and
1294 * can't remote API calls such as NetWkstaGetInfo or
1295 * NetServerGetInfo.
1296 *
1297 * Dependencies: none
1298 *
1299 * Parameters:
1300 * cli - pointer to cli_state structure
1301 * workgroup - pointer to string containing domain
1302 * stype - server type
1303 *
1304 * Returns:
1305 * True - success
1306 * False - failure
1307 *
1308 ************************************************************************/
1309 BOOL cli_ns_check_server_type(struct cli_state *cli, char *workgroup, uint32 stype)
1310 {
1311 char *rparam = NULL;
1312 char *rdata = NULL;
1313 int rdrcnt,rprcnt;
1314 char *p;
1315 char param[WORDSIZE /* api number */
1316 +sizeof(RAP_NetServerEnum2_REQ) /* req string */
1317 +sizeof(RAP_SERVER_INFO_L0) /* return string */
1318 +WORDSIZE /* info level */
1319 +WORDSIZE /* buffer size */
1320 +DWORDSIZE /* server type */
1321 +RAP_MACHNAME_LEN]; /* workgroup */
1322 BOOL found_server = False;
1323 int res = -1;
1324
1325 /* send a SMBtrans command with api NetServerEnum */
1326 p = make_header(param, RAP_NetServerEnum2,
1327 RAP_NetServerEnum2_REQ, RAP_SERVER_INFO_L0);
1328 PUTWORD(p, 0); /* info level 0 */
1329 PUTWORD(p, CLI_BUFFER_SIZE);
1330 PUTDWORD(p, stype);
1331 PUTSTRING(p, workgroup, RAP_MACHNAME_LEN);
1332
1333 if (cli_api(cli,
1334 param, PTR_DIFF(p,param), 8, /* params, length, max */
1335 NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
1336 &rparam, &rprcnt, /* return params, return size */
1337 &rdata, &rdrcnt /* return data, return size */
1338 )) {
1339
1340 res = GETRES(rparam);
1341 cli->rap_error = res;
1342
1343 if (res == 0 || res == ERRmoredata) {
1344 int i, converter, count;
1345
1346 p = rparam + WORDSIZE;
1347 GETWORD(p, converter);
1348 GETWORD(p, count);
1349
1350 p = rdata;
1351 for (i = 0;i < count;i++, p += 16) {
1352 char ret_server[RAP_MACHNAME_LEN];
1353
1354 GETSTRINGF(p, ret_server, RAP_MACHNAME_LEN);
1355 if (strequal(ret_server, cli->desthost)) {
1356 found_server = True;
1357 break;
1358 }
1359 }
1360 }
1361 else {
1362 DEBUG(4,("cli_ns_check_server_type: machine %s failed the NetServerEnum call. "
1363 "Error was : %s.\n", cli->desthost, cli_errstr(cli) ));
1364 }
1365 }
1366
1367 SAFE_FREE(rparam);
1368 SAFE_FREE(rdata);
1369
1370 return found_server;
1371 }
1372
1373
1374 /****************************************************************************
1375 perform a NetWkstaUserLogoff
1376 ****************************************************************************/
1377 BOOL cli_NetWkstaUserLogoff(struct cli_state *cli,char *user, char *workstation)
1378 {
1379 char *rparam = NULL;
1380 char *rdata = NULL;
1381 char *p;
1382 int rdrcnt,rprcnt;
1383 char param[WORDSIZE /* api number */
1384 +sizeof(RAP_NetWkstaUserLogoff_REQ) /* req string */
1385 +sizeof(RAP_USER_LOGOFF_INFO_L1) /* return string */
1386 +RAP_USERNAME_LEN+1 /* user name+pad */
1387 +RAP_MACHNAME_LEN /* wksta name */
1388 +WORDSIZE /* buffer size */
1389 +WORDSIZE]; /* buffer size? */
1390 fstring upperbuf;
1391
1392 memset(param, 0, sizeof(param));
1393
1394 /* send a SMBtrans command with api NetWkstaUserLogoff */
1395 p = make_header(param, RAP_WWkstaUserLogoff,
1396 RAP_NetWkstaUserLogoff_REQ, RAP_USER_LOGOFF_INFO_L1);
1397 PUTDWORD(p, 0); /* Null pointer */
1398 PUTDWORD(p, 0); /* Null pointer */
1399 fstrcpy(upperbuf, user);
1400 strupper(upperbuf);
1401 PUTSTRINGF(p, upperbuf, RAP_USERNAME_LEN);
1402 p++; /* strange format, but ok */
1403 fstrcpy(upperbuf, workstation);
1404 strupper(upperbuf);
1405 PUTSTRINGF(p, upperbuf, RAP_MACHNAME_LEN);
1406 PUTWORD(p, CLI_BUFFER_SIZE);
1407 PUTWORD(p, CLI_BUFFER_SIZE);
1408
1409 if (cli_api(cli,
1410 param, PTR_DIFF(p,param),1024, /* param, length, max */
1411 NULL, 0, CLI_BUFFER_SIZE, /* data, length, max */
1412 &rparam, &rprcnt, /* return params, return size */
1413 &rdata, &rdrcnt /* return data, return size */
1414 )) {
1415 cli->rap_error = GETRES(rparam);
1416
1417 if (cli->rap_error != 0) {
1418 DEBUG(4,("NetwkstaUserLogoff gave error %d\n", cli->rap_error));
1419 }
1420 }
1421
1422 SAFE_FREE(rparam);
1423 SAFE_FREE(rdata);
1424 return (cli->rap_error == 0);
1425 }
1426
1427 int cli_NetPrintQEnum(struct cli_state *cli,
1428 void (*qfn)(const char*,uint16,uint16,uint16,const char*,const char*,const char*,const char*,const char*,uint16,uint16),
1429 void (*jfn)(uint16,const char*,const char*,const char*,const char*,uint16,uint16,const char*,uint,uint,const char*))
1430 {
1431 char param[WORDSIZE /* api number */
1432 +sizeof(RAP_NetPrintQEnum_REQ) /* req string */
1433 +sizeof(RAP_PRINTQ_INFO_L2) /* return string */
1434 +WORDSIZE /* info level */
1435 +WORDSIZE /* buffer size */
1436 +sizeof(RAP_SMB_PRINT_JOB_L1)]; /* more ret data */
1437 char *p;
1438 char *rparam = NULL;
1439 char *rdata = NULL;
1440 int rprcnt, rdrcnt;
1441 int res = -1;
1442
1443
1444 memset(param, '\0',sizeof(param));
1445 p = make_header(param, RAP_WPrintQEnum,
1446 RAP_NetPrintQEnum_REQ, RAP_PRINTQ_INFO_L2);
1447 PUTWORD(p,2); /* Info level 2 */
1448 PUTWORD(p,0xFFE0); /* Return buffer size */
1449 PUTSTRING(p, RAP_SMB_PRINT_JOB_L1, 0);
1450
1451 if (cli_api(cli,
1452 param, PTR_DIFF(p,param),1024,
1453 NULL, 0, CLI_BUFFER_SIZE,
1454 &rparam, &rprcnt,
1455 &rdata, &rdrcnt)) {
1456 res = GETRES(rparam);
1457 cli->rap_error = res;
1458 if (res != 0) {
1459 DEBUG(1,("NetPrintQEnum gave error %d\n", res));
1460 }
1461 }
1462
1463 if (rdata) {
1464 if (res == 0 || res == ERRmoredata) {
1465 int i, converter, count;
1466
1467 p = rparam + WORDSIZE;
1468 GETWORD(p, converter);
1469 GETWORD(p, count);
1470
1471 p = rdata;
1472 for (i=0;i<count;i++) {
1473 pstring qname, sep_file, print_proc, dest, parms, comment;
1474 uint16 jobcount, priority, start_time, until_time, status;
1475
1476 GETSTRINGF(p, qname, RAP_SHARENAME_LEN);
1477 p++; /* pad */
1478 GETWORD(p, priority);
1479 GETWORD(p, start_time);
1480 GETWORD(p, until_time);
1481 GETSTRINGP(p, sep_file, rdata, converter);
1482 GETSTRINGP(p, print_proc, rdata, converter);
1483 GETSTRINGP(p, dest, rdata, converter);
1484 GETSTRINGP(p, parms, rdata, converter);
1485 GETSTRINGP(p, parms, comment, converter);
1486 GETWORD(p, status);
1487 GETWORD(p, jobcount);
1488
1489 qfn(qname, priority, start_time, until_time, sep_file, print_proc,
1490 dest, parms, comment, status, jobcount);
1491
1492 if (jobcount) {
1493 int j;
1494 for (j=0;j<jobcount;j++) {
1495 uint16 jid, pos, fsstatus;
1496 pstring ownername, notifyname, datatype, jparms, jstatus, jcomment;
1497 uint submitted, jsize;
1498
1499 GETWORD(p, jid);
1500 GETSTRINGF(p, ownername, RAP_USERNAME_LEN);
1501 p++; /* pad byte */
1502 GETSTRINGF(p, notifyname, RAP_MACHNAME_LEN);
1503 GETSTRINGF(p, datatype, RAP_DATATYPE_LEN);
1504 GETSTRINGP(p, jparms, rdata, converter);
1505 GETWORD(p, pos);
1506 GETWORD(p, fsstatus);
1507 GETSTRINGP(p, jstatus, rdata, converter);
1508 GETDWORD(p, submitted);
1509 GETDWORD(p, jsize);
1510 GETSTRINGP(p, jcomment, rdata, converter);
1511
1512 jfn(jid, ownername, notifyname, datatype, jparms, pos, fsstatus,
1513 jstatus, submitted, jsize, jcomment);
1514 }
1515 }
1516 }
1517 } else {
1518 DEBUG(4,("NetPrintQEnum res=%d\n", res));
1519 }
1520 } else {
1521 DEBUG(4,("NetPrintQEnum no data returned\n"));
1522 }
1523
1524 SAFE_FREE(rparam);
1525 SAFE_FREE(rdata);
1526
1527 return res;
1528 }
1529
1530 int cli_NetPrintQGetInfo(struct cli_state *cli, const char *printer,
1531 void (*qfn)(const char*,uint16,uint16,uint16,const char*,const char*,const char*,const char*,const char*,uint16,uint16),
1532 void (*jfn)(uint16,const char*,const char*,const char*,const char*,uint16,uint16,const char*,uint,uint,const char*))
1533 {
1534 char param[WORDSIZE /* api number */
1535 +sizeof(RAP_NetPrintQGetInfo_REQ) /* req string */
1536 +sizeof(RAP_PRINTQ_INFO_L2) /* return string */
1537 +RAP_SHARENAME_LEN /* printer name */
1538 +WORDSIZE /* info level */
1539 +WORDSIZE /* buffer size */
1540 +sizeof(RAP_SMB_PRINT_JOB_L1)]; /* more ret data */
1541 char *p;
1542 char *rparam = NULL;
1543 char *rdata = NULL;
1544 int rprcnt, rdrcnt;
1545 int res = -1;
1546
1547
1548 memset(param, '\0',sizeof(param));
1549 p = make_header(param, RAP_WPrintQGetInfo,
1550 RAP_NetPrintQGetInfo_REQ, RAP_PRINTQ_INFO_L2);
1551 PUTSTRING(p, printer, RAP_SHARENAME_LEN-1);
1552 PUTWORD(p, 2); /* Info level 2 */
1553 PUTWORD(p,0xFFE0); /* Return buffer size */
1554 PUTSTRING(p, RAP_SMB_PRINT_JOB_L1, 0);
1555
1556 if (cli_api(cli,
1557 param, PTR_DIFF(p,param),1024,
1558 NULL, 0, CLI_BUFFER_SIZE,
1559 &rparam, &rprcnt,
1560 &rdata, &rdrcnt)) {
1561 res = GETRES(rparam);
1562 cli->rap_error = res;
1563 if (res != 0) {
1564 DEBUG(1,("NetPrintQGetInfo gave error %d\n", res));
1565 }
1566 }
1567
1568 if (rdata) {
1569 if (res == 0 || res == ERRmoredata) {
1570 int rsize, converter;
1571 pstring qname, sep_file, print_proc, dest, parms, comment;
1572 uint16 jobcount, priority, start_time, until_time, status;
1573
1574 p = rparam + WORDSIZE;
1575 GETWORD(p, converter);
1576 GETWORD(p, rsize);
1577
1578 p = rdata;
1579 GETSTRINGF(p, qname, RAP_SHARENAME_LEN);
1580 p++; /* pad */
1581 GETWORD(p, priority);
1582 GETWORD(p, start_time);
1583 GETWORD(p, until_time);
1584 GETSTRINGP(p, sep_file, rdata, converter);
1585 GETSTRINGP(p, print_proc, rdata, converter);
1586 GETSTRINGP(p, dest, rdata, converter);
1587 GETSTRINGP(p, parms, rdata, converter);
1588 GETSTRINGP(p, comment, rdata, converter);
1589 GETWORD(p, status);
1590 GETWORD(p, jobcount);
1591 qfn(qname, priority, start_time, until_time, sep_file, print_proc,
1592 dest, parms, comment, status, jobcount);
1593 if (jobcount) {
1594 int j;
1595 for (j=0;(j<jobcount)&&(PTR_DIFF(p,rdata)< rsize);j++) {
1596 uint16 jid, pos, fsstatus;
1597 pstring ownername, notifyname, datatype, jparms, jstatus, jcomment;
1598 uint submitted, jsize;
1599
1600 GETWORD(p, jid);
1601 GETSTRINGF(p, ownername, RAP_USERNAME_LEN);
1602 p++; /* pad byte */
1603 GETSTRINGF(p, notifyname, RAP_MACHNAME_LEN);
1604 GETSTRINGF(p, datatype, RAP_DATATYPE_LEN);
1605 GETSTRINGP(p, jparms, rdata, converter);
1606 GETWORD(p, pos);
1607 GETWORD(p, fsstatus);
1608 GETSTRINGP(p, jstatus, rdata, converter);
1609 GETDWORD(p, submitted);
1610 GETDWORD(p, jsize);
1611 GETSTRINGP(p, jcomment, rdata, converter);
1612
1613 jfn(jid, ownername, notifyname, datatype, jparms, pos, fsstatus,
1614 jstatus, submitted, jsize, jcomment);
1615 }
1616 }
1617 } else {
1618 DEBUG(4,("NetPrintQGetInfo res=%d\n", res));
1619 }
1620 } else {
1621 DEBUG(4,("NetPrintQGetInfo no data returned\n"));
1622 }
1623
1624 SAFE_FREE(rparam);
1625 SAFE_FREE(rdata);
1626
1627 return res;
1628 }
1629
1630 /****************************************************************************
1631 call a NetServiceEnum - list running services on a different host
1632 ****************************************************************************/
1633 int cli_RNetServiceEnum(struct cli_state *cli, void (*fn)(const char *, const char *, void *), void *state)
1634 {
1635 char param[WORDSIZE /* api number */
1636 +sizeof(RAP_NetServiceEnum_REQ) /* parm string */
1637 +sizeof(RAP_SERVICE_INFO_L2) /* return string */
1638 +WORDSIZE /* info level */
1639 +WORDSIZE]; /* buffer size */
1640 char *p;
1641 char *rparam = NULL;
1642 char *rdata = NULL;
1643 int rprcnt, rdrcnt;
1644 int res = -1;
1645
1646
1647 memset(param, '\0', sizeof(param));
1648 p = make_header(param, RAP_WServiceEnum,
1649 RAP_NetServiceEnum_REQ, RAP_SERVICE_INFO_L2);
1650 PUTWORD(p,2); /* Info level 2 */
1651 PUTWORD(p,0xFFE0); /* Return buffer size */
1652
1653 if (cli_api(cli,
1654 param, PTR_DIFF(p,param),8,
1655 NULL, 0, 0xFFE0 /* data area size */,
1656 &rparam, &rprcnt,
1657 &rdata, &rdrcnt)) {
1658 res = GETRES(rparam);
1659 cli->rap_error = res;
1660 if(cli->rap_error == 234)
1661 DEBUG(1,("Not all service names were returned (such as those longer than 15 characters)\n"));
1662 else if (cli->rap_error != 0) {
1663 DEBUG(1,("NetServiceEnum gave error %d\n", cli->rap_error));
1664 }
1665 }
1666
1667 if (rdata) {
1668 if (res == 0 || res == ERRmoredata) {
1669 int i, converter, count;
1670
1671 p = rparam + WORDSIZE; /* skip result */
1672 GETWORD(p, converter);
1673 GETWORD(p, count);
1674
1675 for (i=0,p=rdata;i<count;i++) {
1676 pstring comment;
1677 char servicename[RAP_SRVCNAME_LEN];
1678
1679 GETSTRINGF(p, servicename, RAP_SRVCNAME_LEN);
1680 p+=8; /* pass status words */
1681 GETSTRINGF(p, comment, RAP_SRVCCMNT_LEN);
1682
1683 fn(servicename, comment, cli); /* BB add status too */
1684 }
1685 } else {
1686 DEBUG(4,("NetServiceEnum res=%d\n", res));
1687 }
1688 } else {
1689 DEBUG(4,("NetServiceEnum no data returned\n"));
1690 }
1691
1692 SAFE_FREE(rparam);
1693 SAFE_FREE(rdata);
1694
1695 return res;
1696 }
1697
1698
1699 /****************************************************************************
1700 call a NetSessionEnum - list workstations with sessions to an SMB server
1701 ****************************************************************************/
1702 int cli_NetSessionEnum(struct cli_state *cli, void (*fn)(char *, char *, uint16, uint16, uint16, uint, uint, uint, char *))
1703 {
1704 char param[WORDSIZE /* api number */
1705 +sizeof(RAP_NetSessionEnum_REQ) /* parm string */
1706 +sizeof(RAP_SESSION_INFO_L2) /* return string */
1707 +WORDSIZE /* info level */
1708 +WORDSIZE]; /* buffer size */
1709 char *p;
1710 char *rparam = NULL;
1711 char *rdata = NULL;
1712 int rprcnt, rdrcnt;
1713 int res = -1;
1714
1715 memset(param, '\0', sizeof(param));
1716 p = make_header(param, RAP_WsessionEnum,
1717 RAP_NetSessionEnum_REQ, RAP_SESSION_INFO_L2);
1718 PUTWORD(p,2); /* Info level 2 */
1719 PUTWORD(p,0xFF); /* Return buffer size */
1720
1721 if (cli_api(cli,
1722 param, PTR_DIFF(p,param),8,
1723 NULL, 0, CLI_BUFFER_SIZE,
1724 &rparam, &rprcnt,
1725 &rdata, &rdrcnt)) {
1726 res = GETRES(rparam);
1727 cli->rap_error = res;
1728 if (res != 0) {
1729 DEBUG(1,("NetSessionEnum gave error %d\n", res));
1730 }
1731 }
1732
1733 if (rdata) {
1734 if (res == 0 || res == ERRmoredata) {
1735 int i, converter, count;
1736
1737 p = rparam + WORDSIZE;
1738 GETWORD(p, converter);
1739 GETWORD(p, count);
1740
1741 for (i=0,p=rdata;i<count;i++) {
1742 pstring wsname, username, clitype_name;
1743 uint16 num_conns, num_opens, num_users;
1744 uint sess_time, idle_time, user_flags;
1745
1746 GETSTRINGP(p, wsname, rdata, converter);
1747 GETSTRINGP(p, username, rdata, converter);
1748 GETWORD(p, num_conns);
1749 GETWORD(p, num_opens);
1750 GETWORD(p, num_users);
1751 GETDWORD(p, sess_time);
1752 GETDWORD(p, idle_time);
1753 GETDWORD(p, user_flags);
1754 GETSTRINGP(p, clitype_name, rdata, converter);
1755
1756 fn(wsname, username, num_conns, num_opens, num_users, sess_time,
1757 idle_time, user_flags, clitype_name);
1758 }
1759
1760 } else {
1761 DEBUG(4,("NetSessionEnum res=%d\n", res));
1762 }
1763 } else {
1764 DEBUG(4,("NetSesssionEnum no data returned\n"));
1765 }
1766
1767 SAFE_FREE(rparam);
1768 SAFE_FREE(rdata);
1769
1770 return res;
1771 }
1772
1773 /****************************************************************************
1774 Call a NetSessionGetInfo - get information about other session to an SMB server.
1775 ****************************************************************************/
1776
1777 int cli_NetSessionGetInfo(struct cli_state *cli, const char *workstation, void (*fn)(const char *, const char *, uint16, uint16, uint16, uint, uint, uint, const char *))
1778 {
1779 char param[WORDSIZE /* api number */
1780 +sizeof(RAP_NetSessionGetInfo_REQ) /* req string */
1781 +sizeof(RAP_SESSION_INFO_L2) /* return string */
1782 +RAP_MACHNAME_LEN /* wksta name */
1783 +WORDSIZE /* info level */
1784 +WORDSIZE]; /* buffer size */
1785 char *p;
1786 char *rparam = NULL;
1787 char *rdata = NULL;
1788 int rprcnt, rdrcnt;
1789 int res = -1;
1790
1791
1792 memset(param, '\0', sizeof(param));
1793 p = make_header(param, RAP_WsessionGetInfo,
1794 RAP_NetSessionGetInfo_REQ, RAP_SESSION_INFO_L2);
1795 PUTSTRING(p, workstation, RAP_MACHNAME_LEN-1);
1796 PUTWORD(p,2); /* Info level 2 */
1797 PUTWORD(p,0xFF); /* Return buffer size */
1798
1799 if (cli_api(cli,
1800 param, PTR_DIFF(p,param),PTR_DIFF(p,param),
1801 NULL, 0, CLI_BUFFER_SIZE,
1802 &rparam, &rprcnt,
1803 &rdata, &rdrcnt)) {
1804 cli->rap_error = SVAL(rparam,0);
1805 if (cli->rap_error != 0) {
1806 DEBUG(1,("NetSessionGetInfo gave error %d\n", cli->rap_error));
1807 }
1808 }
1809
1810 if (rdata) {
1811 res = GETRES(rparam);
1812
1813 if (res == 0 || res == ERRmoredata) {
1814 int rsize, converter;
1815 pstring wsname, username, clitype_name;
1816 uint16 num_conns, num_opens, num_users;
1817 uint sess_time, idle_time, user_flags;
1818
1819 p = rparam + WORDSIZE;
1820 GETWORD(p, converter);
1821 GETWORD(p, rsize);
1822
1823 p = rdata;
1824 GETSTRINGP(p, wsname, rdata, converter);
1825 GETSTRINGP(p, username, rdata, converter);
1826 GETWORD(p, num_conns);
1827 GETWORD(p, num_opens);
1828 GETWORD(p, num_users);
1829 GETDWORD(p, sess_time);
1830 GETDWORD(p, idle_time);
1831 GETDWORD(p, user_flags);
1832 GETSTRINGP(p, clitype_name, rdata, converter);
1833
1834 fn(wsname, username, num_conns, num_opens, num_users, sess_time,
1835 idle_time, user_flags, clitype_name);
1836 } else {
1837 DEBUG(4,("NetSessionGetInfo res=%d\n", res));
1838 }
1839 } else {
1840 DEBUG(4,("NetSessionGetInfo no data returned\n"));
1841 }
1842
1843 SAFE_FREE(rparam);
1844 SAFE_FREE(rdata);
1845
1846 return res;
1847 }
1848
1849 /****************************************************************************
1850 call a NetSessionDel - close a session to an SMB server
1851 ****************************************************************************/
1852 int cli_NetSessionDel(struct cli_state *cli, const char *workstation)
1853 {
1854 char param[WORDSIZE /* api number */
1855 +sizeof(RAP_NetSessionDel_REQ) /* req string */
1856 +1 /* no return string */
1857 +RAP_MACHNAME_LEN /* workstation name */
1858 +WORDSIZE]; /* reserved (0) */
1859 char *p;
1860 char *rparam = NULL;
1861 char *rdata = NULL;
1862 int rprcnt, rdrcnt;
1863 int res;
1864
1865 memset(param, '\0', sizeof(param));
1866 p = make_header(param, RAP_WsessionDel, RAP_NetSessionDel_REQ, NULL);
1867 PUTSTRING(p, workstation, RAP_MACHNAME_LEN-1);
1868 PUTWORD(p,0); /* reserved word of 0 */
1869 if (cli_api(cli,
1870 param, PTR_DIFF(p,param), 1024, /* Param, length, maxlen */
1871 NULL, 0, 200, /* data, length, maxlen */
1872 &rparam, &rprcnt, /* return params, length */
1873 &rdata, &rdrcnt)) /* return data, length */
1874 {
1875 res = GETRES(rparam);
1876 cli->rap_error = res;
1877
1878 if (res == 0) {
1879 /* nothing to do */
1880 }
1881 else {
1882 DEBUG(4,("NetFileClose2 res=%d\n", res));
1883 }
1884 } else {
1885 res = -1;
1886 DEBUG(4,("NetFileClose2 failed\n"));
1887 }
1888
1889 SAFE_FREE(rparam);
1890 SAFE_FREE(rdata);
1891
1892 return res;
1893 }
1894
1895
1896 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))
1897 {
1898 char param[WORDSIZE /* api number */
1899 +sizeof(RAP_NetConnectionEnum_REQ) /* req string */
1900 +sizeof(RAP_CONNECTION_INFO_L1) /* return string */
1901 +RAP_MACHNAME_LEN /* wksta name */
1902 +WORDSIZE /* info level */
1903 +WORDSIZE]; /* buffer size */
1904 char *p;
1905 char *rparam = NULL;
1906 char *rdata = NULL;
1907 int rprcnt, rdrcnt;
1908 int res = -1;
1909
1910 memset(param, '\0', sizeof(param));
1911 p = make_header(param, RAP_WconnectionEnum,
1912 RAP_NetConnectionEnum_REQ, RAP_CONNECTION_INFO_L1);
1913 PUTSTRING(p, qualifier, RAP_MACHNAME_LEN-1);/* Workstation name */
1914 PUTWORD(p,1); /* Info level 1 */
1915 PUTWORD(p,0xFFE0); /* Return buffer size */
1916
1917 if (cli_api(cli,
1918 param, PTR_DIFF(p,param),PTR_DIFF(p,param),
1919 NULL, 0, CLI_BUFFER_SIZE,
1920 &rparam, &rprcnt,
1921 &rdata, &rdrcnt)) {
1922 res = GETRES(rparam);
1923 cli->rap_error = res;
1924 if (res != 0) {
1925 DEBUG(1,("NetConnectionEnum gave error %d\n", res));
1926 }
1927 }
1928 if (rdata) {
1929 if (res == 0 || res == ERRmoredata) {
1930 int i, converter, count;
1931
1932 p = rparam + WORDSIZE;
1933 GETWORD(p, converter);
1934 GETWORD(p, count);
1935
1936 for (i=0,p=rdata;i<count;i++) {
1937 pstring netname, username;
1938 uint16 conn_id, conn_type, num_opens, num_users;
1939 uint conn_time;
1940
1941 GETWORD(p,conn_id);
1942 GETWORD(p,conn_type);
1943 GETWORD(p,num_opens);
1944 GETWORD(p,num_users);
1945 GETDWORD(p,conn_time);
1946 GETSTRINGP(p, username, rdata, converter);
1947 GETSTRINGP(p, netname, rdata, converter);
1948
1949 fn(conn_id, conn_type, num_opens, num_users, conn_time,
1950 username, netname);
1951 }
1952
1953 } else {
1954 DEBUG(4,("NetConnectionEnum res=%d\n", res));
1955 }
1956 } else {
1957 DEBUG(4,("NetConnectionEnum no data returned\n"));
1958 }
1959 SAFE_FREE(rdata);
1960 SAFE_FREE(rparam);
1961 return res;
1962 }