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