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