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