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