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