source: branches/samba-3.0/source/libsmb/clirap2.c@ 935

Last change on this file since 935 was 26, checked in by Paul Smedley, 18 years ago

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