Sync up with 2.0 code.
[tprouty/samba.git] / source / smbd / ipc.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    Inter-process communication and named pipe handling
5    Copyright (C) Andrew Tridgell 1992-1998
6
7    SMB Version handling
8    Copyright (C) John H Terpstra 1995-1998
9    
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14    
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19    
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23    */
24 /*
25    This file handles the named pipe and mailslot calls
26    in the SMBtrans protocol
27    */
28
29 #include "includes.h"
30 #include "nterr.h"
31
32 #ifdef CHECK_TYPES
33 #undef CHECK_TYPES
34 #endif
35 #define CHECK_TYPES 0
36
37 extern int DEBUGLEVEL;
38 extern int max_send;
39
40 extern fstring local_machine;
41 extern fstring global_myworkgroup;
42
43 #define NERR_Success 0
44 #define NERR_badpass 86
45 #define NERR_notsupported 50
46
47 #define NERR_BASE (2100)
48 #define NERR_BufTooSmall (NERR_BASE+23)
49 #define NERR_JobNotFound (NERR_BASE+51)
50 #define NERR_DestNotFound (NERR_BASE+52)
51 #define ERROR_INVALID_LEVEL 124
52
53 #define ACCESS_READ 0x01
54 #define ACCESS_WRITE 0x02
55 #define ACCESS_CREATE 0x04
56
57 #define SHPWLEN 8               /* share password length */
58 #define NNLEN 12                /* 8.3 net name length */
59 #define SNLEN 15                /* service name length */
60 #define QNLEN 12                /* queue name maximum length */
61
62 extern int Client;
63 extern int smb_read_error;
64
65 static BOOL api_Unsupported(connection_struct *conn,uint16 vuid, char *param,char *data,
66                             int mdrcnt,int mprcnt,
67                             char **rdata,char **rparam,
68                             int *rdata_len,int *rparam_len);
69 static BOOL api_TooSmall(connection_struct *conn,uint16 vuid, char *param,char *data,
70                          int mdrcnt,int mprcnt,
71                          char **rdata,char **rparam,
72                          int *rdata_len,int *rparam_len);
73
74
75 static int CopyExpanded(connection_struct *conn, 
76                         int snum, char** dst, char* src, int* n)
77 {
78         pstring buf;
79         int l;
80
81         if (!src || !dst || !n || !(*dst)) return(0);
82
83         StrnCpy(buf,src,sizeof(buf)/2);
84         string_sub(buf,"%S",lp_servicename(snum));
85         standard_sub(conn,buf);
86         StrnCpy(*dst,buf,*n);
87         l = strlen(*dst) + 1;
88         (*dst) += l;
89         (*n) -= l;
90         return l;
91 }
92
93 static int CopyAndAdvance(char** dst, char* src, int* n)
94 {
95   int l;
96   if (!src || !dst || !n || !(*dst)) return(0);
97   StrnCpy(*dst,src,*n);
98   l = strlen(*dst) + 1;
99   (*dst) += l;
100   (*n) -= l;
101   return l;
102 }
103
104 static int StrlenExpanded(connection_struct *conn, int snum, char* s)
105 {
106         pstring buf;
107         if (!s) return(0);
108         StrnCpy(buf,s,sizeof(buf)/2);
109         string_sub(buf,"%S",lp_servicename(snum));
110         standard_sub(conn,buf);
111         return strlen(buf) + 1;
112 }
113
114 static char* Expand(connection_struct *conn, int snum, char* s)
115 {
116         static pstring buf;
117         if (!s) return(NULL);
118         StrnCpy(buf,s,sizeof(buf)/2);
119         string_sub(buf,"%S",lp_servicename(snum));
120         standard_sub(conn,buf);
121         return &buf[0];
122 }
123
124 /*******************************************************************
125   check a API string for validity when we only need to check the prefix
126   ******************************************************************/
127 static BOOL prefix_ok(char *str,char *prefix)
128 {
129   return(strncmp(str,prefix,strlen(prefix)) == 0);
130 }
131
132 /*******************************************************************
133  copies parameters and data, as needed, into the smb buffer
134
135  *both* the data and params sections should be aligned.  this
136  is fudged in the rpc pipes by 
137  at present, only the data section is.  this may be a possible
138  cause of some of the ipc problems being experienced.  lkcl26dec97
139
140  ******************************************************************/
141 static void copy_trans_params_and_data(char *outbuf, int align,
142                                 struct mem_buf *rparam, struct mem_buf *rdata,
143                                 int param_offset, int data_offset,
144                                 int param_len, int data_len)
145 {
146         char *copy_into = smb_buf(outbuf)+1;
147
148         DEBUG(5,("copy_trans_params_and_data: params[%d..%d] data[%d..%d]\n",
149                         param_offset, param_offset + param_len,
150                         data_offset , data_offset  + data_len));
151
152         if (param_len) mem_buf_copy(copy_into, rparam, param_offset, param_len);
153         copy_into += param_len + align;
154         if (data_len ) mem_buf_copy(copy_into, rdata , data_offset , data_len);
155 }
156
157 /****************************************************************************
158   send a trans reply
159   ****************************************************************************/
160 static void send_trans_reply(char *outbuf,
161                                 struct mem_buf *rdata,
162                                 struct mem_buf *rparam,
163                                 uint16 *setup, int lsetup, int max_data_ret)
164 {
165         int i;
166         int this_ldata,this_lparam;
167         int tot_data=0,tot_param=0;
168         int align;
169
170         int ldata  = rdata  ? mem_buf_len(rdata ) : 0;
171         int lparam = rparam ? mem_buf_len(rparam) : 0;
172
173         BOOL buffer_too_large = max_data_ret ? ldata > max_data_ret : False;
174
175         if (buffer_too_large)
176         {
177                 DEBUG(5,("send_trans_reply: buffer %d too large %d\n", ldata, max_data_ret));
178                 ldata = max_data_ret;
179         }
180
181         this_lparam = MIN(lparam,max_send - (500+lsetup*SIZEOFWORD)); /* hack */
182         this_ldata  = MIN(ldata,max_send - (500+lsetup*SIZEOFWORD+this_lparam));
183
184         align = ((this_lparam)%4);
185
186         set_message(outbuf,10+lsetup,1+align+this_ldata+this_lparam,True);
187
188         if (buffer_too_large)
189         {
190                 /* issue a buffer size warning.  on a DCE/RPC pipe, expect an SMBreadX... */
191                 SIVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
192                 SIVAL(outbuf, smb_rcls, 0x80000000 | NT_STATUS_ACCESS_VIOLATION);
193         }
194
195         copy_trans_params_and_data(outbuf, align,
196                                    rparam     , rdata,
197                                    tot_param  , tot_data,
198                                    this_lparam, this_ldata);
199
200         SSVAL(outbuf,smb_vwv0,lparam);
201         SSVAL(outbuf,smb_vwv1,ldata);
202         SSVAL(outbuf,smb_vwv3,this_lparam);
203         SSVAL(outbuf,smb_vwv4,smb_offset(smb_buf(outbuf)+1,outbuf));
204         SSVAL(outbuf,smb_vwv5,0);
205         SSVAL(outbuf,smb_vwv6,this_ldata);
206         SSVAL(outbuf,smb_vwv7,smb_offset(smb_buf(outbuf)+1+this_lparam+align,outbuf));
207         SSVAL(outbuf,smb_vwv8,0);
208         SSVAL(outbuf,smb_vwv9,lsetup);
209
210         for (i=0;i<lsetup;i++)
211         {
212                 SSVAL(outbuf,smb_vwv10+i*SIZEOFWORD,setup[i]);
213         }
214
215         show_msg(outbuf);
216         send_smb(Client,outbuf);
217
218         tot_data = this_ldata;
219         tot_param = this_lparam;
220
221         while (tot_data < ldata || tot_param < lparam)
222         {
223                 this_lparam = MIN(lparam-tot_param, max_send - 500); /* hack */
224                 this_ldata  = MIN(ldata -tot_data , max_send - (500+this_lparam));
225
226                 align = (this_lparam%4);
227
228                 set_message(outbuf,10,1+this_ldata+this_lparam+align,False);
229
230                 copy_trans_params_and_data(outbuf, align,
231                                            rparam     , rdata,
232                                            tot_param  , tot_data,
233                                            this_lparam, this_ldata);
234
235                 SSVAL(outbuf,smb_vwv3,this_lparam);
236                 SSVAL(outbuf,smb_vwv4,smb_offset(smb_buf(outbuf)+1,outbuf));
237                 SSVAL(outbuf,smb_vwv5,tot_param);
238                 SSVAL(outbuf,smb_vwv6,this_ldata);
239                 SSVAL(outbuf,smb_vwv7,smb_offset(smb_buf(outbuf)+1+this_lparam+align,outbuf));
240                 SSVAL(outbuf,smb_vwv8,tot_data);
241                 SSVAL(outbuf,smb_vwv9,0);
242
243                 show_msg(outbuf);
244                 send_smb(Client,outbuf);
245
246                 tot_data  += this_ldata;
247                 tot_param += this_lparam;
248         }
249 }
250
251 struct pack_desc {
252   char* format;     /* formatstring for structure */
253   char* subformat;  /* subformat for structure */
254   char* base;       /* baseaddress of buffer */
255   int buflen;      /* remaining size for fixed part; on init: length of base */
256   int subcount;     /* count of substructures */
257   char* structbuf;  /* pointer into buffer for remaining fixed part */
258   int stringlen;    /* remaining size for variable part */              
259   char* stringbuf;  /* pointer into buffer for remaining variable part */
260   int neededlen;    /* total needed size */
261   int usedlen;      /* total used size (usedlen <= neededlen and usedlen <= buflen) */
262   char* curpos;     /* current position; pointer into format or subformat */
263   int errcode;
264 };
265
266 static int get_counter(char** p)
267 {
268   int i, n;
269   if (!p || !(*p)) return(1);
270   if (!isdigit((int)**p)) return 1;
271   for (n = 0;;) {
272     i = **p;
273     if (isdigit(i))
274       n = 10 * n + (i - '0');
275     else
276       return n;
277     (*p)++;
278   }
279 }
280
281 static int getlen(char* p)
282 {
283   int n = 0;
284   if (!p) return(0);
285   while (*p) {
286     switch( *p++ ) {
287     case 'W':                   /* word (2 byte) */
288       n += 2;
289       break;
290     case 'N':                   /* count of substructures (word) at end */
291       n += 2;
292       break;
293     case 'D':                   /* double word (4 byte) */
294     case 'z':                   /* offset to zero terminated string (4 byte) */
295     case 'l':                   /* offset to user data (4 byte) */
296       n += 4;
297       break;
298     case 'b':                   /* offset to data (with counter) (4 byte) */
299       n += 4;
300       get_counter(&p);
301       break;
302     case 'B':                   /* byte (with optional counter) */
303       n += get_counter(&p);
304       break;
305     }
306   }
307   return n;
308 }
309
310 static BOOL init_package(struct pack_desc* p, int count, int subcount)
311 {
312   int n = p->buflen;
313   int i;
314
315   if (!p->format || !p->base) return(False);
316
317   i = count * getlen(p->format);
318   if (p->subformat) i += subcount * getlen(p->subformat);
319   p->structbuf = p->base;
320   p->neededlen = 0;
321   p->usedlen = 0;
322   p->subcount = 0;
323   p->curpos = p->format;
324   if (i > n) {
325     p->neededlen = i;
326     i = n = 0;
327     p->errcode = ERRmoredata;
328   }
329   else
330     p->errcode = NERR_Success;
331   p->buflen = i;
332   n -= i;
333   p->stringbuf = p->base + i;
334   p->stringlen = n;
335   return(p->errcode == NERR_Success);
336 }
337
338 #ifdef HAVE_STDARG_H
339 static int package(struct pack_desc* p, ...)
340 {
341 #else
342 static int package(va_alist)
343 va_dcl
344 {
345   struct pack_desc* p;
346 #endif
347   va_list args;
348   int needed=0, stringneeded;
349   char* str=NULL;
350   int is_string=0, stringused;
351   int32 temp;
352
353 #ifdef HAVE_STDARG_H
354   va_start(args,p);
355 #else
356   va_start(args);
357   p = va_arg(args,struct pack_desc *);
358 #endif
359
360   if (!*p->curpos) {
361     if (!p->subcount)
362       p->curpos = p->format;
363     else {
364       p->curpos = p->subformat;
365       p->subcount--;
366     }
367   }
368 #if CHECK_TYPES
369   str = va_arg(args,char*);
370   SMB_ASSERT(strncmp(str,p->curpos,strlen(str)) == 0);
371 #endif
372   stringneeded = -1;
373
374   if (!p->curpos) return(0);
375
376   switch( *p->curpos++ ) {
377   case 'W':                     /* word (2 byte) */
378     needed = 2;
379     temp = va_arg(args,int);
380     if (p->buflen >= needed) SSVAL(p->structbuf,0,temp);
381     break;
382   case 'N':                     /* count of substructures (word) at end */
383     needed = 2;
384     p->subcount = va_arg(args,int);
385     if (p->buflen >= needed) SSVAL(p->structbuf,0,p->subcount);
386     break;
387   case 'D':                     /* double word (4 byte) */
388     needed = 4;
389     temp = va_arg(args,int);
390     if (p->buflen >= needed) SIVAL(p->structbuf,0,temp);
391     break;
392   case 'B':                     /* byte (with optional counter) */
393     needed = get_counter(&p->curpos);
394     {
395       char *s = va_arg(args,char*);
396       if (p->buflen >= needed) StrnCpy(p->structbuf,s?s:"",needed);
397     }
398     break;
399   case 'z':                     /* offset to zero terminated string (4 byte) */
400     str = va_arg(args,char*);
401     stringneeded = (str ? strlen(str)+1 : 0);
402     is_string = 1;
403     break;
404   case 'l':                     /* offset to user data (4 byte) */
405     str = va_arg(args,char*);
406     stringneeded = va_arg(args,int);
407     is_string = 0;
408     break;
409   case 'b':                     /* offset to data (with counter) (4 byte) */
410     str = va_arg(args,char*);
411     stringneeded = get_counter(&p->curpos);
412     is_string = 0;
413     break;
414   }
415   va_end(args);
416   if (stringneeded >= 0) {
417     needed = 4;
418     if (p->buflen >= needed) {
419       stringused = stringneeded;
420       if (stringused > p->stringlen) {
421         stringused = (is_string ? p->stringlen : 0);
422         if (p->errcode == NERR_Success) p->errcode = ERRmoredata;
423       }
424       if (!stringused)
425         SIVAL(p->structbuf,0,0);
426       else {
427         SIVAL(p->structbuf,0,PTR_DIFF(p->stringbuf,p->base));
428         memcpy(p->stringbuf,str?str:"",stringused);
429         if (is_string) p->stringbuf[stringused-1] = '\0';
430         p->stringbuf += stringused;
431         p->stringlen -= stringused;
432         p->usedlen += stringused;
433       }
434     }
435     p->neededlen += stringneeded;
436   }
437   p->neededlen += needed;
438   if (p->buflen >= needed) {
439     p->structbuf += needed;
440     p->buflen -= needed;
441     p->usedlen += needed;
442   }
443   else {
444     if (p->errcode == NERR_Success) p->errcode = ERRmoredata;
445   }
446   return 1;
447 }
448
449 #if CHECK_TYPES
450 #define PACK(desc,t,v) package(desc,t,v,0,0,0,0)
451 #define PACKl(desc,t,v,l) package(desc,t,v,l,0,0,0,0)
452 #else
453 #define PACK(desc,t,v) package(desc,v)
454 #define PACKl(desc,t,v,l) package(desc,v,l)
455 #endif
456
457 static void PACKI(struct pack_desc* desc,char *t,int v)
458 {
459   PACK(desc,t,v);
460 }
461
462 static void PACKS(struct pack_desc* desc,char *t,char *v)
463 {
464   PACK(desc,t,v);
465 }
466
467
468 /****************************************************************************
469   get a print queue
470   ****************************************************************************/
471
472 static void PackDriverData(struct pack_desc* desc)
473 {
474   char drivdata[4+4+32];
475   SIVAL(drivdata,0,sizeof drivdata); /* cb */
476   SIVAL(drivdata,4,1000);       /* lVersion */
477   memset(drivdata+8,0,32);      /* szDeviceName */
478   pstrcpy(drivdata+8,"NULL");
479   PACKl(desc,"l",drivdata,sizeof drivdata); /* pDriverData */
480 }
481
482 static int check_printq_info(struct pack_desc* desc,
483                              int uLevel, char *id1, char *id2)
484 {
485   desc->subformat = NULL;
486   switch( uLevel ) {
487   case 0:
488     desc->format = "B13";
489     break;
490   case 1:
491     desc->format = "B13BWWWzzzzzWW";
492     break;
493   case 2:
494     desc->format = "B13BWWWzzzzzWN";
495     desc->subformat = "WB21BB16B10zWWzDDz";
496     break;
497   case 3:
498     desc->format = "zWWWWzzzzWWzzl";
499     break;
500   case 4:
501     desc->format = "zWWWWzzzzWNzzl";
502     desc->subformat = "WWzWWDDzz";
503     break;
504   case 5:
505     desc->format = "z";
506     break;
507   case 52:
508     desc->format = "WzzzzzzzzN";
509     desc->subformat = "z";
510     break;
511   default: return False;
512   }
513   if (strcmp(desc->format,id1) != 0) return False;
514   if (desc->subformat && strcmp(desc->subformat,id2) != 0) return False;
515   return True;
516 }
517
518 static void fill_printjob_info(connection_struct *conn, int snum, int uLevel,
519                                struct pack_desc* desc,
520                                print_queue_struct* queue, int n)
521 {
522   time_t t = queue->time;
523
524   /* the client expects localtime */
525   t -= TimeDiff(t);
526
527   PACKI(desc,"W",printjob_encode(snum, queue->job)); /* uJobId */
528   if (uLevel == 1) {
529     PACKS(desc,"B21",queue->user); /* szUserName */
530     PACKS(desc,"B","");         /* pad */
531     PACKS(desc,"B16","");       /* szNotifyName */
532     PACKS(desc,"B10","PM_Q_RAW"); /* szDataType */
533     PACKS(desc,"z","");         /* pszParms */
534     PACKI(desc,"W",n+1);                /* uPosition */
535     PACKI(desc,"W",queue->status); /* fsStatus */
536     PACKS(desc,"z","");         /* pszStatus */
537     PACKI(desc,"D",t); /* ulSubmitted */
538     PACKI(desc,"D",queue->size); /* ulSize */
539     PACKS(desc,"z",queue->file); /* pszComment */
540   }
541   if (uLevel == 2 || uLevel == 3) {
542     PACKI(desc,"W",queue->priority);            /* uPriority */
543     PACKS(desc,"z",queue->user); /* pszUserName */
544     PACKI(desc,"W",n+1);                /* uPosition */
545     PACKI(desc,"W",queue->status); /* fsStatus */
546     PACKI(desc,"D",t); /* ulSubmitted */
547     PACKI(desc,"D",queue->size); /* ulSize */
548     PACKS(desc,"z","Samba");    /* pszComment */
549     PACKS(desc,"z",queue->file); /* pszDocument */
550     if (uLevel == 3) {
551       PACKS(desc,"z","");       /* pszNotifyName */
552       PACKS(desc,"z","PM_Q_RAW"); /* pszDataType */
553       PACKS(desc,"z","");       /* pszParms */
554       PACKS(desc,"z","");       /* pszStatus */
555       PACKS(desc,"z",SERVICE(snum)); /* pszQueue */
556       PACKS(desc,"z","lpd");    /* pszQProcName */
557       PACKS(desc,"z","");       /* pszQProcParms */
558       PACKS(desc,"z","NULL"); /* pszDriverName */
559       PackDriverData(desc);     /* pDriverData */
560       PACKS(desc,"z","");       /* pszPrinterName */
561     }
562   }
563 }
564
565 static void fill_printq_info(connection_struct *conn, int snum, int uLevel,
566                              struct pack_desc* desc,
567                              int count, print_queue_struct* queue,
568                              print_status_struct* status)
569 {
570   switch (uLevel) {
571     case 1:
572     case 2:
573       PACKS(desc,"B13",SERVICE(snum));
574       break;
575     case 3:
576     case 4:
577     case 5:
578       PACKS(desc,"z",Expand(conn,snum,SERVICE(snum)));
579       break;
580   }
581
582   if (uLevel == 1 || uLevel == 2) {
583     PACKS(desc,"B","");         /* alignment */
584     PACKI(desc,"W",5);          /* priority */
585     PACKI(desc,"W",0);          /* start time */
586     PACKI(desc,"W",0);          /* until time */
587     PACKS(desc,"z","");         /* pSepFile */
588     PACKS(desc,"z","lpd");      /* pPrProc */
589     PACKS(desc,"z",SERVICE(snum)); /* pDestinations */
590     PACKS(desc,"z","");         /* pParms */
591     if (snum < 0) {
592       PACKS(desc,"z","UNKNOWN PRINTER");
593       PACKI(desc,"W",LPSTAT_ERROR);
594     }
595     else if (!status || !status->message[0]) {
596       PACKS(desc,"z",Expand(conn,snum,lp_comment(snum)));
597       PACKI(desc,"W",LPSTAT_OK); /* status */
598     } else {
599       PACKS(desc,"z",status->message);
600       PACKI(desc,"W",status->status); /* status */
601     }
602     PACKI(desc,(uLevel == 1 ? "W" : "N"),count);
603   }
604   if (uLevel == 3 || uLevel == 4) {
605     PACKI(desc,"W",5);          /* uPriority */
606     PACKI(desc,"W",0);          /* uStarttime */
607     PACKI(desc,"W",0);          /* uUntiltime */
608     PACKI(desc,"W",5);          /* pad1 */
609     PACKS(desc,"z","");         /* pszSepFile */
610     PACKS(desc,"z","WinPrint"); /* pszPrProc */
611     PACKS(desc,"z","");         /* pszParms */
612     if (!status || !status->message[0]) {
613       PACKS(desc,"z",Expand(conn,snum,lp_comment(snum))); /* pszComment */
614       PACKI(desc,"W",LPSTAT_OK); /* fsStatus */
615     } else {
616       PACKS(desc,"z",status->message); /* pszComment */
617       PACKI(desc,"W",status->status); /* fsStatus */
618     }
619     PACKI(desc,(uLevel == 3 ? "W" : "N"),count);        /* cJobs */
620     PACKS(desc,"z",SERVICE(snum)); /* pszPrinters */
621     PACKS(desc,"z",lp_printerdriver(snum));             /* pszDriverName */
622     PackDriverData(desc);       /* pDriverData */
623   }
624   if (uLevel == 2 || uLevel == 4) {
625     int i;
626     for (i=0;i<count;i++)
627       fill_printjob_info(conn,snum,uLevel == 2 ? 1 : 2,desc,&queue[i],i);
628   }
629
630   if (uLevel==52) {
631     int i,ok=0;
632     pstring tok,driver,datafile,langmon,helpfile,datatype;
633     char *p,*q;
634     FILE *f;
635     pstring fname;
636
637     pstrcpy(fname,lp_driverfile());
638     f=sys_fopen(fname,"r");
639     if (!f) {
640       DEBUG(3,("fill_printq_info: Can't open %s - %s\n",fname,strerror(errno)));
641       desc->errcode=NERR_notsupported;
642       return;
643     }
644
645     if((p=(char *)malloc(8192*sizeof(char))) == NULL) {
646       DEBUG(0,("fill_printq_info: malloc fail !\n"));
647       desc->errcode=NERR_notsupported;
648       fclose(f);
649       return;
650     }
651
652     bzero(p, 8192*sizeof(char));
653     q=p;
654
655     /* lookup the long printer driver name in the file description */
656     while (f && !feof(f) && !ok)
657     {
658       p = q;                    /* reset string pointer */
659       fgets(p,8191,f);
660       p[strlen(p)-1]='\0';
661       if (next_token(&p,tok,":",sizeof(tok)) &&
662         (strlen(lp_printerdriver(snum)) == strlen(tok)) &&
663         (!strncmp(tok,lp_printerdriver(snum),strlen(lp_printerdriver(snum)))))
664         ok=1;
665     }
666     fclose(f);
667
668     /* driver file name */
669     if (ok && !next_token(&p,driver,":",sizeof(driver))) ok = 0;
670     /* data file name */
671     if (ok && !next_token(&p,datafile,":",sizeof(datafile))) ok = 0;
672       /*
673        * for the next tokens - which may be empty - I have to check for empty
674        * tokens first because the next_token function will skip all empty
675        * token fields 
676        */
677     if (ok) {
678       /* help file */
679       if (*p == ':') {
680           *helpfile = '\0';
681           p++;
682       } else if (!next_token(&p,helpfile,":",sizeof(helpfile))) ok = 0;
683     }
684
685     if (ok) {
686       /* language monitor */
687       if (*p == ':') {
688           *langmon = '\0';
689           p++;
690       } else if (!next_token(&p,langmon,":",sizeof(langmon))) ok = 0;
691     }
692
693     /* default data type */
694     if (ok && !next_token(&p,datatype,":",sizeof(datatype))) ok = 0;
695
696     if (ok) {
697       PACKI(desc,"W",0x0400);                    /* don't know */
698       PACKS(desc,"z",lp_printerdriver(snum));    /* long printer name */
699       PACKS(desc,"z",driver);                    /* Driverfile Name */
700       PACKS(desc,"z",datafile);                  /* Datafile name */
701       PACKS(desc,"z",langmon);                   /* language monitor */
702       PACKS(desc,"z",lp_driverlocation(snum));   /* share to retrieve files */
703       PACKS(desc,"z",datatype);                  /* default data type */
704       PACKS(desc,"z",helpfile);                  /* helpfile name */
705       PACKS(desc,"z",driver);                    /* driver name */
706       DEBUG(3,("Driver:%s:\n",driver));
707       DEBUG(3,("Data File:%s:\n",datafile));
708       DEBUG(3,("Language Monitor:%s:\n",langmon));
709       DEBUG(3,("Data Type:%s:\n",datatype));
710       DEBUG(3,("Help File:%s:\n",helpfile));
711       PACKI(desc,"N",count);                     /* number of files to copy */
712       for (i=0;i<count;i++)
713       {
714         /* no need to check return value here - it was already tested in
715          * get_printerdrivernumber
716          */
717         next_token(&p,tok,",",sizeof(tok));
718         PACKS(desc,"z",tok);                        /* driver files to copy */
719         DEBUG(3,("file:%s:\n",tok));
720       }
721
722       DEBUG(3,("fill_printq_info on <%s> gave %d entries\n",
723             SERVICE(snum),count));
724     } else {
725       DEBUG(3,("fill_printq_info: Can't supply driver files\n"));
726       desc->errcode=NERR_notsupported;
727     }
728     free(q);
729   }
730 }
731
732 /* This function returns the number of files for a given driver */
733 static int get_printerdrivernumber(int snum)
734 {
735   int i=0,ok=0;
736   pstring tok;
737   char *p,*q;
738   FILE *f;
739   pstring fname;
740
741   pstrcpy(fname,lp_driverfile());
742
743   DEBUG(4,("In get_printerdrivernumber: %s\n",fname));
744   f=sys_fopen(fname,"r");
745   if (!f) {
746     DEBUG(3,("get_printerdrivernumber: Can't open %s - %s\n",fname,strerror(errno)));
747     return(0);
748   }
749
750   if((p=(char *)malloc(8192*sizeof(char))) == NULL) {
751     DEBUG(3,("get_printerdrivernumber: malloc fail !\n"));
752     fclose(f);
753     return 0;
754   }
755
756   q=p; /* need it to free memory because p change ! */
757
758   /* lookup the long printer driver name in the file description */
759   while (!feof(f) && !ok)
760   {
761     p = q;                      /* reset string pointer */
762     fgets(p,8191,f);
763     if (next_token(&p,tok,":",sizeof(tok)) &&
764       (!strncmp(tok,lp_printerdriver(snum),strlen(lp_printerdriver(snum))))) 
765         ok=1;
766   }
767   fclose(f);
768
769   if (ok) {
770     /* skip 5 fields */
771     i = 5;
772     while (*p && i) {
773       if (*p++ == ':') i--;
774     }
775     if (!*p || i)
776       return(0);
777
778     /* count the number of files */
779     while (next_token(&p,tok,",",sizeof(tok)))
780        i++;
781   }
782   free(q);
783
784   return(i);
785 }
786
787 static BOOL api_DosPrintQGetInfo(connection_struct *conn,
788                                  uint16 vuid, char *param,char *data,
789                                  int mdrcnt,int mprcnt,
790                                  char **rdata,char **rparam,
791                                  int *rdata_len,int *rparam_len)
792 {
793   char *str1 = param+2;
794   char *str2 = skip_string(str1,1);
795   char *p = skip_string(str2,1);
796   char *QueueName = p;
797   int uLevel;
798   int count=0;
799   int snum;
800   char* str3;
801   struct pack_desc desc;
802   print_queue_struct *queue=NULL;
803   print_status_struct status;
804   
805   bzero(&status,sizeof(status));
806   bzero(&desc,sizeof(desc));
807  
808   p = skip_string(p,1);
809   uLevel = SVAL(p,0);
810   str3 = p + 4;
811  
812   /* remove any trailing username */
813   if ((p = strchr(QueueName,'%'))) *p = 0;
814  
815   DEBUG(3,("PrintQueue uLevel=%d name=%s\n",uLevel,QueueName));
816  
817   /* check it's a supported varient */
818   if (!prefix_ok(str1,"zWrLh")) return False;
819   if (!check_printq_info(&desc,uLevel,str2,str3)) return False;
820  
821   snum = lp_servicenumber(QueueName);
822   if (snum < 0 && pcap_printername_ok(QueueName,NULL)) {
823     int pnum = lp_servicenumber(PRINTERS_NAME);
824     if (pnum >= 0) {
825       lp_add_printer(QueueName,pnum);
826       snum = lp_servicenumber(QueueName);
827     }
828   }
829   
830   if (snum < 0 || !VALID_SNUM(snum)) return(False);
831
832   if (uLevel==52) {
833           count = get_printerdrivernumber(snum);
834           DEBUG(3,("api_DosPrintQGetInfo: Driver files count: %d\n",count));
835   } else {
836           count = get_printqueue(snum, conn,&queue,&status);
837   }
838
839   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
840   desc.base = *rdata;
841   desc.buflen = mdrcnt;
842   if (init_package(&desc,1,count)) {
843           desc.subcount = count;
844           fill_printq_info(conn,snum,uLevel,&desc,count,queue,&status);
845   } else if(uLevel == 0) {
846         /*
847          * This is a *disgusting* hack.
848          * This is *so* bad that even I'm embarrassed (and I
849          * have no shame). Here's the deal :
850          * Until we get the correct SPOOLSS code into smbd
851          * then when we're running with NT SMB support then
852          * NT makes this call with a level of zero, and then
853          * immediately follows it with an open request to
854          * the \\SRVSVC pipe. If we allow that open to
855          * succeed then NT barfs when it cannot open the
856          * \\SPOOLSS pipe immediately after and continually
857          * whines saying "Printer name is invalid" forever
858          * after. If we cause *JUST THIS NEXT OPEN* of \\SRVSVC
859          * to fail, then NT downgrades to using the downlevel code
860          * and everything works as well as before. I hate
861          * myself for adding this code.... JRA.
862          */
863
864         fail_next_srvsvc_open();
865   }
866
867   *rdata_len = desc.usedlen;
868   
869   *rparam_len = 6;
870   *rparam = REALLOC(*rparam,*rparam_len);
871   SSVALS(*rparam,0,desc.errcode);
872   SSVAL(*rparam,2,0);
873   SSVAL(*rparam,4,desc.neededlen);
874   
875   DEBUG(4,("printqgetinfo: errorcode %d\n",desc.errcode));
876
877   if (queue) free(queue);
878   
879   return(True);
880 }
881
882
883 /****************************************************************************
884   view list of all print jobs on all queues
885   ****************************************************************************/
886 static BOOL api_DosPrintQEnum(connection_struct *conn, uint16 vuid, char* param, char* data,
887                               int mdrcnt, int mprcnt,
888                               char **rdata, char** rparam,
889                               int *rdata_len, int *rparam_len)
890 {
891   char *param_format = param+2;
892   char *output_format1 = skip_string(param_format,1);
893   char *p = skip_string(output_format1,1);
894   int uLevel = SVAL(p,0);
895   char *output_format2 = p + 4;
896   int services = lp_numservices();
897   int i, n;
898   struct pack_desc desc;
899   print_queue_struct **queue = NULL;
900   print_status_struct *status = NULL;
901   int* subcntarr = NULL;
902   int queuecnt, subcnt=0, succnt=0;
903  
904   bzero(&desc,sizeof(desc));
905
906   DEBUG(3,("DosPrintQEnum uLevel=%d\n",uLevel));
907  
908   if (!prefix_ok(param_format,"WrLeh")) return False;
909   if (!check_printq_info(&desc,uLevel,output_format1,output_format2))
910     return False;
911   queuecnt = 0;
912   for (i = 0; i < services; i++)
913     if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i))
914       queuecnt++;
915   if (uLevel > 0) {
916     if((queue = (print_queue_struct**)malloc(queuecnt*sizeof(print_queue_struct*))) == NULL) {
917       DEBUG(0,("api_DosPrintQEnum: malloc fail !\n"));
918       return False;
919     }
920     memset(queue,0,queuecnt*sizeof(print_queue_struct*));
921     if((status = (print_status_struct*)malloc(queuecnt*sizeof(print_status_struct))) == NULL) {
922       DEBUG(0,("api_DosPrintQEnum: malloc fail !\n"));
923       return False;
924     }
925     memset(status,0,queuecnt*sizeof(print_status_struct));
926     if((subcntarr = (int*)malloc(queuecnt*sizeof(int))) == NULL) {
927       DEBUG(0,("api_DosPrintQEnum: malloc fail !\n"));
928       return False;
929     }
930     subcnt = 0;
931     n = 0;
932     for (i = 0; i < services; i++)
933       if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
934         subcntarr[n] = get_printqueue(i, conn,&queue[n],&status[n]);
935         subcnt += subcntarr[n];
936         n++;
937       }
938   }
939   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
940   desc.base = *rdata;
941   desc.buflen = mdrcnt;
942
943   if (init_package(&desc,queuecnt,subcnt)) {
944     n = 0;
945     succnt = 0;
946     for (i = 0; i < services; i++)
947       if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
948         fill_printq_info(conn,i,uLevel,&desc,subcntarr[n],queue[n],&status[n]);
949         n++;
950         if (desc.errcode == NERR_Success) succnt = n;
951       }
952   }
953
954   if (subcntarr) free(subcntarr);
955  
956   *rdata_len = desc.usedlen;
957   *rparam_len = 8;
958   *rparam = REALLOC(*rparam,*rparam_len);
959   SSVALS(*rparam,0,desc.errcode);
960   SSVAL(*rparam,2,0);
961   SSVAL(*rparam,4,succnt);
962   SSVAL(*rparam,6,queuecnt);
963   
964   for (i = 0; i < queuecnt; i++) {
965     if (queue && queue[i]) free(queue[i]);
966   }
967
968   if (queue) free(queue);
969   if (status) free(status);
970   
971   return True;
972 }
973
974 /****************************************************************************
975   get info level for a server list query
976   ****************************************************************************/
977 static BOOL check_server_info(int uLevel, char* id)
978 {
979   switch( uLevel ) {
980   case 0:
981     if (strcmp(id,"B16") != 0) return False;
982     break;
983   case 1:
984     if (strcmp(id,"B16BBDz") != 0) return False;
985     break;
986   default: 
987     return False;
988   }
989   return True;
990 }
991
992 struct srv_info_struct
993 {
994   fstring name;
995   uint32 type;
996   fstring comment;
997   fstring domain;
998   BOOL server_added;
999 };
1000
1001
1002 /*******************************************************************
1003   get server info lists from the files saved by nmbd. Return the
1004   number of entries
1005   ******************************************************************/
1006 static int get_server_info(uint32 servertype, 
1007                            struct srv_info_struct **servers,
1008                            char *domain)
1009 {
1010   FILE *f;
1011   pstring fname;
1012   int count=0;
1013   int alloced=0;
1014   pstring line;
1015   BOOL local_list_only;
1016
1017   pstrcpy(fname,lp_lockdir());
1018   trim_string(fname,NULL,"/");
1019   pstrcat(fname,"/");
1020   pstrcat(fname,SERVER_LIST);
1021
1022   f = sys_fopen(fname,"r");
1023
1024   if (!f) {
1025     DEBUG(4,("Can't open %s - %s\n",fname,strerror(errno)));
1026     return(0);
1027   }
1028
1029   /* request for everything is code for request all servers */
1030   if (servertype == SV_TYPE_ALL) 
1031         servertype &= ~(SV_TYPE_DOMAIN_ENUM|SV_TYPE_LOCAL_LIST_ONLY);
1032
1033   local_list_only = (servertype & SV_TYPE_LOCAL_LIST_ONLY);
1034
1035   DEBUG(4,("Servertype search: %8x\n",servertype));
1036
1037   while (!feof(f))
1038   {
1039     fstring stype;
1040     struct srv_info_struct *s;
1041     char *ptr = line;
1042     BOOL ok = True;
1043     *ptr = 0;
1044
1045     fgets(line,sizeof(line)-1,f);
1046     if (!*line) continue;
1047     
1048     if (count == alloced) {
1049       alloced += 10;
1050       (*servers) = (struct srv_info_struct *)
1051         Realloc(*servers,sizeof(**servers)*alloced);
1052       if (!(*servers)) return(0);
1053       bzero((char *)((*servers)+count),sizeof(**servers)*(alloced-count));
1054     }
1055     s = &(*servers)[count];
1056     
1057     if (!next_token(&ptr,s->name   , NULL, sizeof(s->name))) continue;
1058     if (!next_token(&ptr,stype     , NULL, sizeof(stype))) continue;
1059     if (!next_token(&ptr,s->comment, NULL, sizeof(s->comment))) continue;
1060     if (!next_token(&ptr,s->domain , NULL, sizeof(s->domain))) {
1061       /* this allows us to cope with an old nmbd */
1062       pstrcpy(s->domain,global_myworkgroup); 
1063     }
1064     
1065     if (sscanf(stype,"%X",&s->type) != 1) { 
1066       DEBUG(4,("r:host file ")); 
1067       ok = False; 
1068     }
1069     
1070         /* Filter the servers/domains we return based on what was asked for. */
1071
1072         /* Check to see if we are being asked for a local list only. */
1073         if(local_list_only && ((s->type & SV_TYPE_LOCAL_LIST_ONLY) == 0)) {
1074           DEBUG(4,("r: local list only"));
1075           ok = False;
1076         }
1077
1078     /* doesn't match up: don't want it */
1079     if (!(servertype & s->type)) { 
1080       DEBUG(4,("r:serv type ")); 
1081       ok = False; 
1082     }
1083     
1084     if ((servertype & SV_TYPE_DOMAIN_ENUM) != 
1085         (s->type & SV_TYPE_DOMAIN_ENUM))
1086       {
1087         DEBUG(4,("s: dom mismatch "));
1088         ok = False;
1089       }
1090     
1091     if (!strequal(domain, s->domain) && !(servertype & SV_TYPE_DOMAIN_ENUM))
1092       {
1093         ok = False;
1094       }
1095     
1096         /* We should never return a server type with a SV_TYPE_LOCAL_LIST_ONLY set. */
1097         s->type &= ~SV_TYPE_LOCAL_LIST_ONLY;
1098
1099     if (ok)
1100       {
1101         DEBUG(4,("**SV** %20s %8x %25s %15s\n",
1102                  s->name, s->type, s->comment, s->domain));
1103         
1104         s->server_added = True;
1105         count++;
1106       }
1107     else
1108       {
1109         DEBUG(4,("%20s %8x %25s %15s\n",
1110                  s->name, s->type, s->comment, s->domain));
1111       }
1112   }
1113   
1114   fclose(f);
1115   return(count);
1116 }
1117
1118
1119 /*******************************************************************
1120   fill in a server info structure
1121   ******************************************************************/
1122 static int fill_srv_info(struct srv_info_struct *service, 
1123                          int uLevel, char **buf, int *buflen, 
1124                          char **stringbuf, int *stringspace, char *baseaddr)
1125 {
1126   int struct_len;
1127   char* p;
1128   char* p2;
1129   int l2;
1130   int len;
1131  
1132   switch (uLevel) {
1133   case 0: struct_len = 16; break;
1134   case 1: struct_len = 26; break;
1135   default: return -1;
1136   }  
1137  
1138   if (!buf)
1139     {
1140       len = 0;
1141       switch (uLevel) 
1142         {
1143         case 1:
1144           len = strlen(service->comment)+1;
1145           break;
1146         }
1147
1148       if (buflen) *buflen = struct_len;
1149       if (stringspace) *stringspace = len;
1150       return struct_len + len;
1151     }
1152   
1153   len = struct_len;
1154   p = *buf;
1155   if (*buflen < struct_len) return -1;
1156   if (stringbuf)
1157     {
1158       p2 = *stringbuf;
1159       l2 = *stringspace;
1160     }
1161   else
1162     {
1163       p2 = p + struct_len;
1164       l2 = *buflen - struct_len;
1165     }
1166   if (!baseaddr) baseaddr = p;
1167   
1168   switch (uLevel)
1169     {
1170     case 0:
1171       StrnCpy(p,service->name,15);
1172       break;
1173
1174     case 1:
1175       StrnCpy(p,service->name,15);
1176       SIVAL(p,18,service->type);
1177       SIVAL(p,22,PTR_DIFF(p2,baseaddr));
1178       len += CopyAndAdvance(&p2,service->comment,&l2);
1179       break;
1180     }
1181
1182   if (stringbuf)
1183     {
1184       *buf = p + struct_len;
1185       *buflen -= struct_len;
1186       *stringbuf = p2;
1187       *stringspace = l2;
1188     }
1189   else
1190     {
1191       *buf = p2;
1192       *buflen -= len;
1193     }
1194   return len;
1195 }
1196
1197
1198 static BOOL srv_comp(struct srv_info_struct *s1,struct srv_info_struct *s2)
1199 {
1200   return(strcmp(s1->name,s2->name));
1201 }
1202
1203 /****************************************************************************
1204   view list of servers available (or possibly domains). The info is
1205   extracted from lists saved by nmbd on the local host
1206   ****************************************************************************/
1207 static BOOL api_RNetServerEnum(connection_struct *conn, uint16 vuid, char *param, char *data,
1208                                int mdrcnt, int mprcnt, char **rdata, 
1209                                char **rparam, int *rdata_len, int *rparam_len)
1210 {
1211   char *str1 = param+2;
1212   char *str2 = skip_string(str1,1);
1213   char *p = skip_string(str2,1);
1214   int uLevel = SVAL(p,0);
1215   int buf_len = SVAL(p,2);
1216   uint32 servertype = IVAL(p,4);
1217   char *p2;
1218   int data_len, fixed_len, string_len;
1219   int f_len = 0, s_len = 0;
1220   struct srv_info_struct *servers=NULL;
1221   int counted=0,total=0;
1222   int i,missed;
1223   fstring domain;
1224   BOOL domain_request;
1225   BOOL local_request;
1226
1227   /* If someone sets all the bits they don't really mean to set
1228      DOMAIN_ENUM and LOCAL_LIST_ONLY, they just want all the
1229      known servers. */
1230
1231   if (servertype == SV_TYPE_ALL) 
1232     servertype &= ~(SV_TYPE_DOMAIN_ENUM|SV_TYPE_LOCAL_LIST_ONLY);
1233
1234   /* If someone sets SV_TYPE_LOCAL_LIST_ONLY but hasn't set
1235      any other bit (they may just set this bit on it's own) they 
1236      want all the locally seen servers. However this bit can be 
1237      set on its own so set the requested servers to be 
1238      ALL - DOMAIN_ENUM. */
1239
1240   if ((servertype & SV_TYPE_LOCAL_LIST_ONLY) && !(servertype & SV_TYPE_DOMAIN_ENUM)) 
1241     servertype = SV_TYPE_ALL & ~(SV_TYPE_DOMAIN_ENUM);
1242
1243   domain_request = ((servertype & SV_TYPE_DOMAIN_ENUM) != 0);
1244   local_request = ((servertype & SV_TYPE_LOCAL_LIST_ONLY) != 0);
1245
1246   p += 8;
1247
1248   if (!prefix_ok(str1,"WrLehD")) return False;
1249   if (!check_server_info(uLevel,str2)) return False;
1250   
1251   DEBUG(4, ("server request level: %s %8x ", str2, servertype));
1252   DEBUG(4, ("domains_req:%s ", BOOLSTR(domain_request)));
1253   DEBUG(4, ("local_only:%s\n", BOOLSTR(local_request)));
1254
1255   if (strcmp(str1, "WrLehDz") == 0) {
1256     StrnCpy(domain, p, sizeof(fstring)-1);
1257   } else {
1258     StrnCpy(domain, global_myworkgroup, sizeof(fstring)-1);    
1259   }
1260
1261   if (lp_browse_list())
1262     total = get_server_info(servertype,&servers,domain);
1263
1264   data_len = fixed_len = string_len = 0;
1265   missed = 0;
1266
1267   qsort(servers,total,sizeof(servers[0]),QSORT_CAST srv_comp);
1268
1269   {
1270     char *lastname=NULL;
1271
1272     for (i=0;i<total;i++)
1273     {
1274       struct srv_info_struct *s = &servers[i];
1275       if (lastname && strequal(lastname,s->name)) continue;
1276       lastname = s->name;
1277       data_len += fill_srv_info(s,uLevel,0,&f_len,0,&s_len,0);
1278       DEBUG(4,("fill_srv_info %20s %8x %25s %15s\n",
1279                s->name, s->type, s->comment, s->domain));
1280       
1281       if (data_len <= buf_len) {
1282           counted++;
1283           fixed_len += f_len;
1284           string_len += s_len;
1285       } else {
1286         missed++;
1287       }
1288     }
1289   }
1290
1291   *rdata_len = fixed_len + string_len;
1292   *rdata = REALLOC(*rdata,*rdata_len);
1293   bzero(*rdata,*rdata_len);
1294   
1295   p2 = (*rdata) + fixed_len;    /* auxilliary data (strings) will go here */
1296   p = *rdata;
1297   f_len = fixed_len;
1298   s_len = string_len;
1299
1300   {
1301     char *lastname=NULL;
1302     int count2 = counted;
1303     for (i = 0; i < total && count2;i++)
1304       {
1305         struct srv_info_struct *s = &servers[i];
1306         if (lastname && strequal(lastname,s->name)) continue;
1307         lastname = s->name;
1308         fill_srv_info(s,uLevel,&p,&f_len,&p2,&s_len,*rdata);
1309         DEBUG(4,("fill_srv_info %20s %8x %25s %15s\n",
1310                  s->name, s->type, s->comment, s->domain));
1311         count2--;
1312       }
1313   }
1314   
1315   *rparam_len = 8;
1316   *rparam = REALLOC(*rparam,*rparam_len);
1317   SSVAL(*rparam,0,(missed == 0 ? NERR_Success : ERRmoredata));
1318   SSVAL(*rparam,2,0);
1319   SSVAL(*rparam,4,counted);
1320   SSVAL(*rparam,6,counted+missed);
1321
1322   if (servers) free(servers);
1323
1324   DEBUG(3,("NetServerEnum domain = %s uLevel=%d counted=%d total=%d\n",
1325            domain,uLevel,counted,counted+missed));
1326
1327   return(True);
1328 }
1329
1330 /****************************************************************************
1331   command 0x34 - suspected of being a "Lookup Names" stub api
1332   ****************************************************************************/
1333 static BOOL api_RNetGroupGetUsers(connection_struct *conn, uint16 vuid, char *param, char *data,
1334                                int mdrcnt, int mprcnt, char **rdata, 
1335                                char **rparam, int *rdata_len, int *rparam_len)
1336 {
1337   char *str1 = param+2;
1338   char *str2 = skip_string(str1,1);
1339   char *p = skip_string(str2,1);
1340   int uLevel = SVAL(p,0);
1341   int buf_len = SVAL(p,2);
1342   int counted=0;
1343   int missed=0;
1344
1345         DEBUG(5,("RNetGroupGetUsers: %s %s %s %d %d\n",
1346                 str1, str2, p, uLevel, buf_len));
1347
1348   if (!prefix_ok(str1,"zWrLeh")) return False;
1349   
1350   *rdata_len = 0;
1351   *rdata = NULL;
1352   
1353   *rparam_len = 8;
1354   *rparam = REALLOC(*rparam,*rparam_len);
1355
1356   SSVAL(*rparam,0,0x08AC); /* informational warning message */
1357   SSVAL(*rparam,2,0);
1358   SSVAL(*rparam,4,counted);
1359   SSVAL(*rparam,6,counted+missed);
1360
1361   return(True);
1362 }
1363
1364 /****************************************************************************
1365   get info about a share
1366   ****************************************************************************/
1367 static BOOL check_share_info(int uLevel, char* id)
1368 {
1369   switch( uLevel ) {
1370   case 0:
1371     if (strcmp(id,"B13") != 0) return False;
1372     break;
1373   case 1:
1374     if (strcmp(id,"B13BWz") != 0) return False;
1375     break;
1376   case 2:
1377     if (strcmp(id,"B13BWzWWWzB9B") != 0) return False;
1378     break;
1379   case 91:
1380     if (strcmp(id,"B13BWzWWWzB9BB9BWzWWzWW") != 0) return False;
1381     break;
1382   default: return False;
1383   }
1384   return True;
1385 }
1386
1387 static int fill_share_info(connection_struct *conn, int snum, int uLevel,
1388                            char** buf, int* buflen,
1389                            char** stringbuf, int* stringspace, char* baseaddr)
1390 {
1391   int struct_len;
1392   char* p;
1393   char* p2;
1394   int l2;
1395   int len;
1396  
1397   switch( uLevel ) {
1398   case 0: struct_len = 13; break;
1399   case 1: struct_len = 20; break;
1400   case 2: struct_len = 40; break;
1401   case 91: struct_len = 68; break;
1402   default: return -1;
1403   }
1404   
1405  
1406   if (!buf)
1407     {
1408       len = 0;
1409       if (uLevel > 0) len += StrlenExpanded(conn,snum,lp_comment(snum));
1410       if (uLevel > 1) len += strlen(lp_pathname(snum)) + 1;
1411       if (buflen) *buflen = struct_len;
1412       if (stringspace) *stringspace = len;
1413       return struct_len + len;
1414     }
1415   
1416   len = struct_len;
1417   p = *buf;
1418   if ((*buflen) < struct_len) return -1;
1419   if (stringbuf)
1420     {
1421       p2 = *stringbuf;
1422       l2 = *stringspace;
1423     }
1424   else
1425     {
1426       p2 = p + struct_len;
1427       l2 = (*buflen) - struct_len;
1428     }
1429   if (!baseaddr) baseaddr = p;
1430   
1431   StrnCpy(p,lp_servicename(snum),13);
1432   
1433   if (uLevel > 0)
1434     {
1435       int type;
1436       CVAL(p,13) = 0;
1437       type = STYPE_DISKTREE;
1438       if (lp_print_ok(snum)) type = STYPE_PRINTQ;
1439       if (strequal("IPC$",lp_servicename(snum))) type = STYPE_IPC;
1440       SSVAL(p,14,type);         /* device type */
1441       SIVAL(p,16,PTR_DIFF(p2,baseaddr));
1442       len += CopyExpanded(conn,snum,&p2,lp_comment(snum),&l2);
1443     }
1444   
1445   if (uLevel > 1)
1446     {
1447       SSVAL(p,20,ACCESS_READ|ACCESS_WRITE|ACCESS_CREATE); /* permissions */
1448       SSVALS(p,22,-1);          /* max uses */
1449       SSVAL(p,24,1); /* current uses */
1450       SIVAL(p,26,PTR_DIFF(p2,baseaddr)); /* local pathname */
1451       len += CopyAndAdvance(&p2,lp_pathname(snum),&l2);
1452       memset(p+30,0,SHPWLEN+2); /* passwd (reserved), pad field */
1453     }
1454   
1455   if (uLevel > 2)
1456     {
1457       memset(p+40,0,SHPWLEN+2);
1458       SSVAL(p,50,0);
1459       SIVAL(p,52,0);
1460       SSVAL(p,56,0);
1461       SSVAL(p,58,0);
1462       SIVAL(p,60,0);
1463       SSVAL(p,64,0);
1464       SSVAL(p,66,0);
1465     }
1466        
1467   if (stringbuf)
1468     {
1469       (*buf) = p + struct_len;
1470       (*buflen) -= struct_len;
1471       (*stringbuf) = p2;
1472       (*stringspace) = l2;
1473     }
1474   else
1475     {
1476       (*buf) = p2;
1477       (*buflen) -= len;
1478     }
1479   return len;
1480 }
1481
1482 static BOOL api_RNetShareGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
1483                                  int mdrcnt,int mprcnt,
1484                                  char **rdata,char **rparam,
1485                                  int *rdata_len,int *rparam_len)
1486 {
1487   char *str1 = param+2;
1488   char *str2 = skip_string(str1,1);
1489   char *netname = skip_string(str2,1);
1490   char *p = skip_string(netname,1);
1491   int uLevel = SVAL(p,0);
1492   int snum = find_service(netname);
1493   
1494   if (snum < 0) return False;
1495   
1496   /* check it's a supported varient */
1497   if (!prefix_ok(str1,"zWrLh")) return False;
1498   if (!check_share_info(uLevel,str2)) return False;
1499  
1500   *rdata = REALLOC(*rdata,mdrcnt);
1501   p = *rdata;
1502   *rdata_len = fill_share_info(conn,snum,uLevel,&p,&mdrcnt,0,0,0);
1503   if (*rdata_len < 0) return False;
1504  
1505   *rparam_len = 6;
1506   *rparam = REALLOC(*rparam,*rparam_len);
1507   SSVAL(*rparam,0,NERR_Success);
1508   SSVAL(*rparam,2,0);           /* converter word */
1509   SSVAL(*rparam,4,*rdata_len);
1510  
1511   return(True);
1512 }
1513
1514 /****************************************************************************
1515   view list of shares available
1516   ****************************************************************************/
1517 static BOOL api_RNetShareEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
1518                               int mdrcnt,int mprcnt,
1519                               char **rdata,char **rparam,
1520                               int *rdata_len,int *rparam_len)
1521 {
1522   char *str1 = param+2;
1523   char *str2 = skip_string(str1,1);
1524   char *p = skip_string(str2,1);
1525   int uLevel = SVAL(p,0);
1526   int buf_len = SVAL(p,2);
1527   char *p2;
1528   int count=lp_numservices();
1529   int total=0,counted=0;
1530   BOOL missed = False;
1531   int i;
1532   int data_len, fixed_len, string_len;
1533   int f_len = 0, s_len = 0;
1534  
1535   if (!prefix_ok(str1,"WrLeh")) return False;
1536   if (!check_share_info(uLevel,str2)) return False;
1537   
1538   data_len = fixed_len = string_len = 0;
1539   for (i=0;i<count;i++)
1540     if (lp_browseable(i) && lp_snum_ok(i))
1541     {
1542       total++;
1543       data_len += fill_share_info(conn,i,uLevel,0,&f_len,0,&s_len,0);
1544       if (data_len <= buf_len)
1545       {
1546         counted++;
1547         fixed_len += f_len;
1548         string_len += s_len;
1549       }
1550       else
1551         missed = True;
1552     }
1553   *rdata_len = fixed_len + string_len;
1554   *rdata = REALLOC(*rdata,*rdata_len);
1555   memset(*rdata,0,*rdata_len);
1556   
1557   p2 = (*rdata) + fixed_len;    /* auxillery data (strings) will go here */
1558   p = *rdata;
1559   f_len = fixed_len;
1560   s_len = string_len;
1561   for (i = 0; i < count;i++)
1562     if (lp_browseable(i) && lp_snum_ok(i))
1563       if (fill_share_info(conn,i,uLevel,&p,&f_len,&p2,&s_len,*rdata) < 0)
1564         break;
1565   
1566   *rparam_len = 8;
1567   *rparam = REALLOC(*rparam,*rparam_len);
1568   SSVAL(*rparam,0,missed ? ERRmoredata : NERR_Success);
1569   SSVAL(*rparam,2,0);
1570   SSVAL(*rparam,4,counted);
1571   SSVAL(*rparam,6,total);
1572   
1573   DEBUG(3,("RNetShareEnum gave %d entries of %d (%d %d %d %d)\n",
1574            counted,total,uLevel,
1575            buf_len,*rdata_len,mdrcnt));
1576   return(True);
1577 }
1578
1579
1580
1581 /****************************************************************************
1582   get the time of day info
1583   ****************************************************************************/
1584 static BOOL api_NetRemoteTOD(connection_struct *conn,uint16 vuid, char *param,char *data,
1585                              int mdrcnt,int mprcnt,
1586                              char **rdata,char **rparam,
1587                              int *rdata_len,int *rparam_len)
1588 {
1589   char *p;
1590   *rparam_len = 4;
1591   *rparam = REALLOC(*rparam,*rparam_len);
1592
1593   *rdata_len = 21;
1594   *rdata = REALLOC(*rdata,*rdata_len);
1595
1596   SSVAL(*rparam,0,NERR_Success);
1597   SSVAL(*rparam,2,0);           /* converter word */
1598
1599   p = *rdata;
1600
1601   {
1602     struct tm *t;
1603     time_t unixdate = time(NULL);
1604
1605     put_dos_date3(p,0,unixdate); /* this is the time that is looked at
1606                                     by NT in a "net time" operation,
1607                                     it seems to ignore the one below */
1608
1609     /* the client expects to get localtime, not GMT, in this bit 
1610        (I think, this needs testing) */
1611     t = LocalTime(&unixdate);
1612
1613     SIVAL(p,4,0);               /* msecs ? */
1614     CVAL(p,8) = t->tm_hour;
1615     CVAL(p,9) = t->tm_min;
1616     CVAL(p,10) = t->tm_sec;
1617     CVAL(p,11) = 0;             /* hundredths of seconds */
1618     SSVALS(p,12,TimeDiff(unixdate)/60); /* timezone in minutes from GMT */
1619     SSVAL(p,14,10000);          /* timer interval in 0.0001 of sec */
1620     CVAL(p,16) = t->tm_mday;
1621     CVAL(p,17) = t->tm_mon + 1;
1622     SSVAL(p,18,1900+t->tm_year);
1623     CVAL(p,20) = t->tm_wday;
1624   }
1625
1626
1627   return(True);
1628 }
1629
1630 /****************************************************************************
1631   set the user password
1632   ****************************************************************************/
1633 static BOOL api_SetUserPassword(connection_struct *conn,uint16 vuid, char *param,char *data,
1634                                 int mdrcnt,int mprcnt,
1635                                 char **rdata,char **rparam,
1636                                 int *rdata_len,int *rparam_len)
1637 {
1638   char *p = skip_string(param+2,2);
1639   fstring user;
1640   fstring pass1,pass2;
1641
1642   fstrcpy(user,p);
1643
1644   p = skip_string(p,1);
1645
1646   memcpy(pass1,p,16);
1647   memcpy(pass2,p+16,16);
1648
1649   *rparam_len = 4;
1650   *rparam = REALLOC(*rparam,*rparam_len);
1651
1652   *rdata_len = 0;
1653
1654   SSVAL(*rparam,0,NERR_badpass);
1655   SSVAL(*rparam,2,0);           /* converter word */
1656
1657   DEBUG(3,("Set password for <%s>\n",user));
1658
1659   /*
1660    * Pass the user through the NT -> unix user mapping
1661    * function.
1662    */
1663
1664   (void)map_username(user);
1665
1666   /*
1667    * Do any UNIX username case mangling.
1668    */
1669   (void)Get_Pwnam( user, True);
1670
1671   /*
1672    * Attempt the plaintext password change first.
1673    * Older versions of Windows seem to do this.
1674    */
1675
1676   if (password_ok(user, pass1,strlen(pass1),NULL) &&
1677       chgpasswd(user,pass1,pass2,False))
1678   {
1679     SSVAL(*rparam,0,NERR_Success);
1680   }
1681
1682   /*
1683    * If the plaintext change failed, attempt
1684    * the encrypted. NT will generate this
1685    * after trying the samr method.
1686    */
1687
1688   if(SVAL(*rparam,0) != NERR_Success)
1689   {
1690     struct smb_passwd *sampw = NULL;
1691
1692     if(check_lanman_password(user,(unsigned char *)pass1,(unsigned char *)pass2, &sampw) && 
1693        change_lanman_password(sampw,(unsigned char *)pass1,(unsigned char *)pass2))
1694     {
1695       SSVAL(*rparam,0,NERR_Success);
1696     }
1697   }
1698
1699   bzero(pass1,sizeof(fstring));
1700   bzero(pass2,sizeof(fstring));  
1701          
1702   return(True);
1703 }
1704
1705 /****************************************************************************
1706   Set the user password (SamOEM version - gets plaintext).
1707 ****************************************************************************/
1708
1709 static BOOL api_SamOEMChangePassword(connection_struct *conn,uint16 vuid, char *param,char *data,
1710                                 int mdrcnt,int mprcnt,
1711                                 char **rdata,char **rparam,
1712                                 int *rdata_len,int *rparam_len)
1713 {
1714   fstring user;
1715   char *p = param + 2;
1716   *rparam_len = 2;
1717   *rparam = REALLOC(*rparam,*rparam_len);
1718
1719   *rdata_len = 0;
1720
1721   SSVAL(*rparam,0,NERR_badpass);
1722
1723   /*
1724    * Check the parameter definition is correct.
1725    */
1726   if(!strequal(param + 2, "zsT")) {
1727     DEBUG(0,("api_SamOEMChangePassword: Invalid parameter string %s\n", param + 2));
1728     return False;
1729   }
1730   p = skip_string(p, 1);
1731
1732   if(!strequal(p, "B516B16")) {
1733     DEBUG(0,("api_SamOEMChangePassword: Invalid data parameter string %s\n", p));
1734     return False;
1735   }
1736   p = skip_string(p,1);
1737
1738   fstrcpy(user,p);
1739   p = skip_string(p,1);
1740
1741   DEBUG(3,("api_SamOEMChangePassword: Change password for <%s>\n",user));
1742
1743   /*
1744    * Pass the user through the NT -> unix user mapping
1745    * function.
1746    */
1747
1748   (void)map_username(user);
1749
1750   /*
1751    * Do any UNIX username case mangling.
1752    */
1753   (void)Get_Pwnam( user, True);
1754
1755   if (pass_oem_change(user, (uchar*) data, (uchar *)&data[516], NULL, NULL))
1756   {
1757     SSVAL(*rparam,0,NERR_Success);
1758   }
1759
1760   return(True);
1761 }
1762
1763 /****************************************************************************
1764   delete a print job
1765   Form: <W> <> 
1766   ****************************************************************************/
1767 static BOOL api_RDosPrintJobDel(connection_struct *conn,uint16 vuid, char *param,char *data,
1768                                 int mdrcnt,int mprcnt,
1769                                 char **rdata,char **rparam,
1770                                 int *rdata_len,int *rparam_len)
1771 {
1772   int function = SVAL(param,0);
1773   char *str1 = param+2;
1774   char *str2 = skip_string(str1,1);
1775   char *p = skip_string(str2,1);
1776   int jobid, snum;
1777   int i, count;
1778
1779   printjob_decode(SVAL(p,0), &snum, &jobid);
1780
1781   /* check it's a supported varient */
1782   if (!(strcsequal(str1,"W") && strcsequal(str2,"")))
1783     return(False);
1784
1785   *rparam_len = 4;
1786   *rparam = REALLOC(*rparam,*rparam_len);
1787
1788   *rdata_len = 0;
1789
1790   SSVAL(*rparam,0,NERR_Success);
1791
1792   if (snum >= 0 && VALID_SNUM(snum))
1793     {
1794       print_queue_struct *queue=NULL;
1795       lpq_reset(snum);
1796       count = get_printqueue(snum,conn,&queue,NULL);
1797   
1798       for (i=0;i<count;i++)
1799         if ((queue[i].job&0xFF) == jobid)
1800           {
1801             switch (function) {
1802             case 81:            /* delete */ 
1803               DEBUG(3,("Deleting queue entry %d\n",queue[i].job));
1804               del_printqueue(conn,snum,queue[i].job);
1805               break;
1806             case 82:            /* pause */
1807             case 83:            /* resume */
1808               DEBUG(3,("%s queue entry %d\n",
1809                        (function==82?"pausing":"resuming"),queue[i].job));
1810               status_printjob(conn,snum,queue[i].job,
1811                               (function==82?LPQ_PAUSED:LPQ_QUEUED));
1812               break;
1813             }
1814             break;
1815           }
1816   
1817       if (i==count)
1818         SSVAL(*rparam,0,NERR_JobNotFound);
1819
1820       if (queue) free(queue);
1821     }
1822
1823   SSVAL(*rparam,2,0);           /* converter word */
1824
1825   return(True);
1826 }
1827
1828 /****************************************************************************
1829   Purge a print queue - or pause or resume it.
1830   ****************************************************************************/
1831 static BOOL api_WPrintQueuePurge(connection_struct *conn,uint16 vuid, char *param,char *data,
1832                                  int mdrcnt,int mprcnt,
1833                                  char **rdata,char **rparam,
1834                                  int *rdata_len,int *rparam_len)
1835 {
1836   int function = SVAL(param,0);
1837   char *str1 = param+2;
1838   char *str2 = skip_string(str1,1);
1839   char *QueueName = skip_string(str2,1);
1840   int snum;
1841
1842   /* check it's a supported varient */
1843   if (!(strcsequal(str1,"z") && strcsequal(str2,"")))
1844     return(False);
1845
1846   *rparam_len = 4;
1847   *rparam = REALLOC(*rparam,*rparam_len);
1848
1849   *rdata_len = 0;
1850
1851   SSVAL(*rparam,0,NERR_Success);
1852   SSVAL(*rparam,2,0);           /* converter word */
1853
1854   snum = lp_servicenumber(QueueName);
1855   if (snum < 0 && pcap_printername_ok(QueueName,NULL)) {
1856     int pnum = lp_servicenumber(PRINTERS_NAME);
1857     if (pnum >= 0) {
1858       lp_add_printer(QueueName,pnum);
1859       snum = lp_servicenumber(QueueName);
1860     }
1861   }
1862
1863   if (snum >= 0 && VALID_SNUM(snum)) {
1864     lpq_reset(snum);
1865     
1866     switch (function) {
1867     case 74: /* Pause queue */
1868     case 75: /* Resume queue */
1869       status_printqueue(conn,snum,(function==74?LPSTAT_STOPPED:LPSTAT_OK));
1870       DEBUG(3,("Print queue %s, queue=%s\n",
1871             (function==74?"pause":"resume"),QueueName));
1872       break;
1873     case 103: /* Purge */
1874       {
1875         print_queue_struct *queue=NULL;
1876         int i, count;
1877         count = get_printqueue(snum,conn,&queue,NULL);
1878         for (i = 0; i < count; i++)
1879           del_printqueue(conn,snum,queue[i].job);
1880  
1881         if (queue) free(queue);
1882         DEBUG(3,("Print queue purge, queue=%s\n",QueueName));
1883         break;
1884       }
1885     }
1886   }
1887
1888   return(True);
1889 }
1890
1891
1892 /****************************************************************************
1893   set the property of a print job (undocumented?)
1894   ? function = 0xb -> set name of print job
1895   ? function = 0x6 -> move print job up/down
1896   Form: <WWsTP> <WWzWWDDzzzzzzzzzzlz> 
1897   or   <WWsTP> <WB21BB16B10zWWzDDz> 
1898 ****************************************************************************/
1899 static int check_printjob_info(struct pack_desc* desc,
1900                                int uLevel, char* id)
1901 {
1902   desc->subformat = NULL;
1903   switch( uLevel ) {
1904   case 0: desc->format = "W"; break;
1905   case 1: desc->format = "WB21BB16B10zWWzDDz"; break;
1906   case 2: desc->format = "WWzWWDDzz"; break;
1907   case 3: desc->format = "WWzWWDDzzzzzzzzzzlz"; break;
1908   default: return False;
1909   }
1910   if (strcmp(desc->format,id) != 0) return False;
1911   return True;
1912 }
1913
1914 static BOOL api_PrintJobInfo(connection_struct *conn,uint16 vuid,char *param,char *data,
1915                              int mdrcnt,int mprcnt,
1916                              char **rdata,char **rparam,
1917                              int *rdata_len,int *rparam_len)
1918 {
1919         struct pack_desc desc;
1920         char *str1 = param+2;
1921         char *str2 = skip_string(str1,1);
1922         char *p = skip_string(str2,1);
1923         int jobid, snum;
1924         int uLevel = SVAL(p,2);
1925         int function = SVAL(p,4);       /* what is this ?? */
1926         int i;
1927         char *s = data;
1928         files_struct *fsp;
1929
1930         printjob_decode(SVAL(p,0), &snum, &jobid);
1931    
1932         *rparam_len = 4;
1933         *rparam = REALLOC(*rparam,*rparam_len);
1934   
1935         *rdata_len = 0;
1936         
1937         /* check it's a supported varient */
1938         if ((strcmp(str1,"WWsTP")) || 
1939             (!check_printjob_info(&desc,uLevel,str2)))
1940                 return(False);
1941    
1942         switch (function) {
1943         case 0x6:       /* change job place in the queue, 
1944                            data gives the new place */
1945                 if (snum >= 0 && VALID_SNUM(snum)) {
1946                         print_queue_struct *queue=NULL;
1947                         int count;
1948   
1949                         lpq_reset(snum);
1950                         count = get_printqueue(snum,conn,&queue,NULL);
1951                         for (i=0;i<count;i++)   /* find job */
1952                                 if ((queue[i].job&0xFF) == jobid) break;
1953             
1954                         if (i==count) {
1955                                 desc.errcode=NERR_JobNotFound;
1956                                 if (queue) free(queue);
1957                         } else {
1958                                 desc.errcode=NERR_Success;
1959                                 i++;
1960 #if 0   
1961                                 {
1962                                         int place= SVAL(data,0);
1963                                         /* we currently have no way of
1964                                            doing this. Can any unix do it? */
1965                                         if (i < place)  /* move down */;
1966                                         else if (i > place )    /* move up */;
1967                                 }
1968 #endif
1969                                 desc.errcode=NERR_notsupported; /* not yet 
1970                                                                    supported */
1971                                 if (queue) free(queue);
1972                         }
1973                 } else {
1974                         desc.errcode=NERR_JobNotFound;
1975                 }
1976                 break;
1977
1978         case 0xb:   /* change print job name, data gives the name */
1979                 /* jobid, snum should be zero */
1980                 if (isalpha((int)*s)) {
1981                         pstring name;
1982                         int l = 0;
1983                         while (l<64 && *s) {
1984                                 if (issafe(*s)) name[l++] = *s;
1985                                 s++;
1986                         }      
1987                         name[l] = 0;
1988         
1989                         DEBUG(3,("Setting print name to %s\n",name));
1990         
1991                         fsp = file_find_print();        
1992
1993                         if (fsp) {
1994                                 connection_struct *fconn = fsp->conn;
1995                                 unbecome_user();
1996               
1997                                 if (!become_user(fconn,vuid) || 
1998                                     !become_service(fconn,True))
1999                                         break;
2000               
2001                                 if (dos_rename(fsp->fsp_name,name) == 0) {
2002                                         string_set(&fsp->fsp_name,name);
2003                                 }
2004                                 break;
2005                         }
2006                 }
2007                 desc.errcode=NERR_Success;
2008                 break;
2009
2010         default:                        /* not implemented */
2011                 return False;
2012         }
2013  
2014         SSVALS(*rparam,0,desc.errcode);
2015         SSVAL(*rparam,2,0);             /* converter word */
2016         
2017         return(True);
2018 }
2019
2020
2021 /****************************************************************************
2022   get info about the server
2023   ****************************************************************************/
2024 static BOOL api_RNetServerGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
2025                                   int mdrcnt,int mprcnt,
2026                                   char **rdata,char **rparam,
2027                                   int *rdata_len,int *rparam_len)
2028 {
2029   char *str1 = param+2;
2030   char *str2 = skip_string(str1,1);
2031   char *p = skip_string(str2,1);
2032   int uLevel = SVAL(p,0);
2033   char *p2;
2034   int struct_len;
2035
2036   DEBUG(4,("NetServerGetInfo level %d\n",uLevel));
2037
2038   /* check it's a supported varient */
2039   if (!prefix_ok(str1,"WrLh")) return False;
2040   switch( uLevel ) {
2041   case 0:
2042     if (strcmp(str2,"B16") != 0) return False;
2043     struct_len = 16;
2044     break;
2045   case 1:
2046     if (strcmp(str2,"B16BBDz") != 0) return False;
2047     struct_len = 26;
2048     break;
2049   case 2:
2050     if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWz")
2051         != 0) return False;
2052     struct_len = 134;
2053     break;
2054   case 3:
2055     if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWzDWz")
2056         != 0) return False;
2057     struct_len = 144;
2058     break;
2059   case 20:
2060     if (strcmp(str2,"DN") != 0) return False;
2061     struct_len = 6;
2062     break;
2063   case 50:
2064     if (strcmp(str2,"B16BBDzWWzzz") != 0) return False;
2065     struct_len = 42;
2066     break;
2067   default: return False;
2068   }
2069
2070   *rdata_len = mdrcnt;
2071   *rdata = REALLOC(*rdata,*rdata_len);
2072
2073   p = *rdata;
2074   p2 = p + struct_len;
2075   if (uLevel != 20) {
2076     StrnCpy(p,local_machine,16);
2077     strupper(p);
2078   }
2079   p += 16;
2080   if (uLevel > 0)
2081     {
2082       struct srv_info_struct *servers=NULL;
2083       int i,count;
2084       pstring comment;
2085       uint32 servertype= lp_default_server_announce();
2086
2087       pstrcpy(comment,lp_serverstring());
2088
2089       if ((count=get_server_info(SV_TYPE_ALL,&servers,global_myworkgroup))>0) {
2090         for (i=0;i<count;i++)
2091           if (strequal(servers[i].name,local_machine))
2092       {
2093             servertype = servers[i].type;
2094             pstrcpy(comment,servers[i].comment);            
2095           }
2096       }
2097       if (servers) free(servers);
2098
2099       SCVAL(p,0,lp_major_announce_version());
2100       SCVAL(p,1,lp_minor_announce_version());
2101       SIVAL(p,2,servertype);
2102
2103       if (mdrcnt == struct_len) {
2104         SIVAL(p,6,0);
2105       } else {
2106         SIVAL(p,6,PTR_DIFF(p2,*rdata));
2107         standard_sub(conn,comment);
2108         StrnCpy(p2,comment,MAX(mdrcnt - struct_len,0));
2109         p2 = skip_string(p2,1);
2110       }
2111     }
2112   if (uLevel > 1)
2113     {
2114       return False;             /* not yet implemented */
2115     }
2116
2117   *rdata_len = PTR_DIFF(p2,*rdata);
2118
2119   *rparam_len = 6;
2120   *rparam = REALLOC(*rparam,*rparam_len);
2121   SSVAL(*rparam,0,NERR_Success);
2122   SSVAL(*rparam,2,0);           /* converter word */
2123   SSVAL(*rparam,4,*rdata_len);
2124
2125   return(True);
2126 }
2127
2128
2129 /****************************************************************************
2130   get info about the server
2131   ****************************************************************************/
2132 static BOOL api_NetWkstaGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
2133                                 int mdrcnt,int mprcnt,
2134                                 char **rdata,char **rparam,
2135                                 int *rdata_len,int *rparam_len)
2136 {
2137   char *str1 = param+2;
2138   char *str2 = skip_string(str1,1);
2139   char *p = skip_string(str2,1);
2140   char *p2;
2141   extern pstring sesssetup_user;
2142   int level = SVAL(p,0);
2143
2144   DEBUG(4,("NetWkstaGetInfo level %d\n",level));
2145
2146   *rparam_len = 6;
2147   *rparam = REALLOC(*rparam,*rparam_len);
2148
2149   /* check it's a supported varient */
2150   if (!(level==10 && strcsequal(str1,"WrLh") && strcsequal(str2,"zzzBBzz")))
2151     return(False);
2152
2153   *rdata_len = mdrcnt + 1024;
2154   *rdata = REALLOC(*rdata,*rdata_len);
2155
2156   SSVAL(*rparam,0,NERR_Success);
2157   SSVAL(*rparam,2,0);           /* converter word */
2158
2159   p = *rdata;
2160   p2 = p + 22;
2161
2162
2163   SIVAL(p,0,PTR_DIFF(p2,*rdata)); /* host name */
2164   pstrcpy(p2,local_machine);
2165   strupper(p2);
2166   p2 = skip_string(p2,1);
2167   p += 4;
2168
2169   SIVAL(p,0,PTR_DIFF(p2,*rdata));
2170   pstrcpy(p2,sesssetup_user);
2171   p2 = skip_string(p2,1);
2172   p += 4;
2173
2174   SIVAL(p,0,PTR_DIFF(p2,*rdata)); /* login domain */
2175   pstrcpy(p2,global_myworkgroup);
2176   strupper(p2);
2177   p2 = skip_string(p2,1);
2178   p += 4;
2179
2180   SCVAL(p,0,lp_major_announce_version()); /* system version - e.g 4 in 4.1 */
2181   SCVAL(p,1,lp_minor_announce_version()); /* system version - e.g .1 in 4.1 */
2182   p += 2;
2183
2184   SIVAL(p,0,PTR_DIFF(p2,*rdata));
2185   pstrcpy(p2,global_myworkgroup);       /* don't know.  login domain?? */
2186   p2 = skip_string(p2,1);
2187   p += 4;
2188
2189   SIVAL(p,0,PTR_DIFF(p2,*rdata)); /* don't know */
2190   pstrcpy(p2,"");
2191   p2 = skip_string(p2,1);
2192   p += 4;
2193
2194   *rdata_len = PTR_DIFF(p2,*rdata);
2195
2196   SSVAL(*rparam,4,*rdata_len);
2197
2198   return(True);
2199 }
2200
2201 /****************************************************************************
2202   get info about a user
2203
2204     struct user_info_11 {
2205         char                usri11_name[21];  0-20 
2206         char                usri11_pad;       21 
2207         char                *usri11_comment;  22-25 
2208         char            *usri11_usr_comment;  26-29
2209         unsigned short      usri11_priv;      30-31
2210         unsigned long       usri11_auth_flags; 32-35
2211         long                usri11_password_age; 36-39
2212         char                *usri11_homedir; 40-43
2213         char            *usri11_parms; 44-47
2214         long                usri11_last_logon; 48-51
2215         long                usri11_last_logoff; 52-55
2216         unsigned short      usri11_bad_pw_count; 56-57
2217         unsigned short      usri11_num_logons; 58-59
2218         char                *usri11_logon_server; 60-63
2219         unsigned short      usri11_country_code; 64-65
2220         char            *usri11_workstations; 66-69
2221         unsigned long       usri11_max_storage; 70-73
2222         unsigned short      usri11_units_per_week; 74-75
2223         unsigned char       *usri11_logon_hours; 76-79
2224         unsigned short      usri11_code_page; 80-81
2225     };
2226
2227 where:
2228
2229   usri11_name specifies the user name for which information is retireved
2230
2231   usri11_pad aligns the next data structure element to a word boundary
2232
2233   usri11_comment is a null terminated ASCII comment
2234
2235   usri11_user_comment is a null terminated ASCII comment about the user
2236
2237   usri11_priv specifies the level of the privilege assigned to the user.
2238        The possible values are:
2239
2240 Name             Value  Description
2241 USER_PRIV_GUEST  0      Guest privilege
2242 USER_PRIV_USER   1      User privilege
2243 USER_PRV_ADMIN   2      Administrator privilege
2244
2245   usri11_auth_flags specifies the account operator privileges. The
2246        possible values are:
2247
2248 Name            Value   Description
2249 AF_OP_PRINT     0       Print operator
2250
2251
2252 Leach, Naik                                        [Page 28]\r\f
2253
2254
2255 INTERNET-DRAFT   CIFS Remote Admin Protocol     January 10, 1997
2256
2257
2258 AF_OP_COMM      1       Communications operator
2259 AF_OP_SERVER    2       Server operator
2260 AF_OP_ACCOUNTS  3       Accounts operator
2261
2262
2263   usri11_password_age specifies how many seconds have elapsed since the
2264        password was last changed.
2265
2266   usri11_home_dir points to a null terminated ASCII string that contains
2267        the path name of the user's home directory.
2268
2269   usri11_parms points to a null terminated ASCII string that is set
2270        aside for use by applications.
2271
2272   usri11_last_logon specifies the time when the user last logged on.
2273        This value is stored as the number of seconds elapsed since
2274        00:00:00, January 1, 1970.
2275
2276   usri11_last_logoff specifies the time when the user last logged off.
2277        This value is stored as the number of seconds elapsed since
2278        00:00:00, January 1, 1970. A value of 0 means the last logoff
2279        time is unknown.
2280
2281   usri11_bad_pw_count specifies the number of incorrect passwords
2282        entered since the last successful logon.
2283
2284   usri11_log1_num_logons specifies the number of times this user has
2285        logged on. A value of -1 means the number of logons is unknown.
2286
2287   usri11_logon_server points to a null terminated ASCII string that
2288        contains the name of the server to which logon requests are sent.
2289        A null string indicates logon requests should be sent to the
2290        domain controller.
2291
2292   usri11_country_code specifies the country code for the user's language
2293        of choice.
2294
2295   usri11_workstations points to a null terminated ASCII string that
2296        contains the names of workstations the user may log on from.
2297        There may be up to 8 workstations, with the names separated by
2298        commas. A null strings indicates there are no restrictions.
2299
2300   usri11_max_storage specifies the maximum amount of disk space the user
2301        can occupy. A value of 0xffffffff indicates there are no
2302        restrictions.
2303
2304   usri11_units_per_week specifies the equal number of time units into
2305        which a week is divided. This value must be equal to 168.
2306
2307   usri11_logon_hours points to a 21 byte (168 bits) string that
2308        specifies the time during which the user can log on. Each bit
2309        represents one unique hour in a week. The first bit (bit 0, word
2310        0) is Sunday, 0:00 to 0:59, the second bit (bit 1, word 0) is
2311
2312
2313
2314 Leach, Naik                                        [Page 29]\r\f
2315
2316
2317 INTERNET-DRAFT   CIFS Remote Admin Protocol     January 10, 1997
2318
2319
2320        Sunday, 1:00 to 1:59 and so on. A null pointer indicates there
2321        are no restrictions.
2322
2323   usri11_code_page specifies the code page for the user's language of
2324        choice
2325
2326 All of the pointers in this data structure need to be treated
2327 specially. The  pointer is a 32 bit pointer. The higher 16 bits need
2328 to be ignored. The converter word returned in the parameters section
2329 needs to be subtracted from the lower 16 bits to calculate an offset
2330 into the return buffer where this ASCII string resides.
2331
2332 There is no auxiliary data in the response.
2333
2334   ****************************************************************************/
2335
2336 #define usri11_name           0 
2337 #define usri11_pad            21
2338 #define usri11_comment        22
2339 #define usri11_usr_comment    26
2340 #define usri11_full_name      30
2341 #define usri11_priv           34
2342 #define usri11_auth_flags     36
2343 #define usri11_password_age   40
2344 #define usri11_homedir        44
2345 #define usri11_parms          48
2346 #define usri11_last_logon     52
2347 #define usri11_last_logoff    56
2348 #define usri11_bad_pw_count   60
2349 #define usri11_num_logons     62
2350 #define usri11_logon_server   64
2351 #define usri11_country_code   68
2352 #define usri11_workstations   70
2353 #define usri11_max_storage    74
2354 #define usri11_units_per_week 78
2355 #define usri11_logon_hours    80
2356 #define usri11_code_page      84
2357 #define usri11_end            86
2358
2359 #define USER_PRIV_GUEST 0
2360 #define USER_PRIV_USER 1
2361 #define USER_PRIV_ADMIN 2
2362
2363 #define AF_OP_PRINT     0 
2364 #define AF_OP_COMM      1
2365 #define AF_OP_SERVER    2
2366 #define AF_OP_ACCOUNTS  3
2367
2368
2369 static BOOL api_RNetUserGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
2370                                 int mdrcnt,int mprcnt,
2371                                 char **rdata,char **rparam,
2372                                 int *rdata_len,int *rparam_len)
2373 {
2374         char *str1 = param+2;
2375         char *str2 = skip_string(str1,1);
2376         char *UserName = skip_string(str2,1);
2377         char *p = skip_string(UserName,1);
2378         int uLevel = SVAL(p,0);
2379         char *p2;
2380
2381     /* get NIS home of a previously validated user - simeon */
2382     /* With share level security vuid will always be zero.
2383        Don't depend on vuser being non-null !!. JRA */
2384     user_struct *vuser = get_valid_user_struct(vuid);
2385     if(vuser != NULL)
2386       DEBUG(3,("  Username of UID %d is %s\n", (int)vuser->uid, vuser->name));
2387
2388     *rparam_len = 6;
2389     *rparam = REALLOC(*rparam,*rparam_len);
2390
2391     DEBUG(4,("RNetUserGetInfo level=%d\n", uLevel));
2392   
2393         /* check it's a supported variant */
2394         if (strcmp(str1,"zWrLh") != 0) return False;
2395         switch( uLevel )
2396         {
2397                 case 0: p2 = "B21"; break;
2398                 case 1: p2 = "B21BB16DWzzWz"; break;
2399                 case 2: p2 = "B21BB16DWzzWzDzzzzDDDDWb21WWzWW"; break;
2400                 case 10: p2 = "B21Bzzz"; break;
2401                 case 11: p2 = "B21BzzzWDDzzDDWWzWzDWb21W"; break;
2402                 default: return False;
2403         }
2404
2405         if (strcmp(p2,str2) != 0) return False;
2406
2407         *rdata_len = mdrcnt + 1024;
2408         *rdata = REALLOC(*rdata,*rdata_len);
2409
2410         SSVAL(*rparam,0,NERR_Success);
2411         SSVAL(*rparam,2,0);             /* converter word */
2412
2413         p = *rdata;
2414         p2 = p + usri11_end;
2415
2416         memset(p,0,21); 
2417         fstrcpy(p+usri11_name,UserName); /* 21 bytes - user name */
2418
2419         if (uLevel > 0)
2420         {
2421                 SCVAL(p,usri11_pad,0); /* padding - 1 byte */
2422                 *p2 = 0;
2423         }
2424         if (uLevel >= 10)
2425         {
2426                 SIVAL(p,usri11_comment,PTR_DIFF(p2,p)); /* comment */
2427                 pstrcpy(p2,"Comment");
2428                 p2 = skip_string(p2,1);
2429
2430                 SIVAL(p,usri11_usr_comment,PTR_DIFF(p2,p)); /* user_comment */
2431                 pstrcpy(p2,"UserComment");
2432                 p2 = skip_string(p2,1);
2433
2434                 /* EEK! the cifsrap.txt doesn't have this in!!!! */
2435                 SIVAL(p,usri11_full_name,PTR_DIFF(p2,p)); /* full name */
2436                 pstrcpy(p2,((vuser != NULL) ? vuser->real_name : UserName));
2437                 p2 = skip_string(p2,1);
2438         }
2439
2440         if (uLevel == 11) /* modelled after NTAS 3.51 reply */
2441         {         
2442                 SSVAL(p,usri11_priv,conn->admin_user?USER_PRIV_ADMIN:USER_PRIV_USER); 
2443                 SIVAL(p,usri11_auth_flags,AF_OP_PRINT);         /* auth flags */
2444                 SIVALS(p,usri11_password_age,-1);               /* password age */
2445                 SIVAL(p,usri11_homedir,PTR_DIFF(p2,p)); /* home dir */
2446                 pstrcpy(p2, lp_logon_path());
2447                 p2 = skip_string(p2,1);
2448                 SIVAL(p,usri11_parms,PTR_DIFF(p2,p)); /* parms */
2449                 pstrcpy(p2,"");
2450                 p2 = skip_string(p2,1);
2451                 SIVAL(p,usri11_last_logon,0);           /* last logon */
2452                 SIVAL(p,usri11_last_logoff,0);          /* last logoff */
2453                 SSVALS(p,usri11_bad_pw_count,-1);       /* bad pw counts */
2454                 SSVALS(p,usri11_num_logons,-1);         /* num logons */
2455                 SIVAL(p,usri11_logon_server,PTR_DIFF(p2,p)); /* logon server */
2456                 pstrcpy(p2,"\\\\*");
2457                 p2 = skip_string(p2,1);
2458                 SSVAL(p,usri11_country_code,0);         /* country code */
2459
2460                 SIVAL(p,usri11_workstations,PTR_DIFF(p2,p)); /* workstations */
2461                 pstrcpy(p2,"");
2462                 p2 = skip_string(p2,1);
2463
2464                 SIVALS(p,usri11_max_storage,-1);                /* max storage */
2465                 SSVAL(p,usri11_units_per_week,168);             /* units per week */
2466                 SIVAL(p,usri11_logon_hours,PTR_DIFF(p2,p)); /* logon hours */
2467
2468                 /* a simple way to get logon hours at all times. */
2469                 memset(p2,0xff,21);
2470                 SCVAL(p2,21,0);           /* fix zero termination */
2471                 p2 = skip_string(p2,1);
2472
2473                 SSVAL(p,usri11_code_page,0);            /* code page */
2474         }
2475         if (uLevel == 1 || uLevel == 2)
2476         {
2477                 memset(p+22,' ',16);    /* password */
2478                 SIVALS(p,38,-1);                /* password age */
2479                 SSVAL(p,42,
2480                 conn->admin_user?USER_PRIV_ADMIN:USER_PRIV_USER);
2481                 SIVAL(p,44,PTR_DIFF(p2,*rdata)); /* home dir */
2482                 pstrcpy(p2,lp_logon_path());
2483                 p2 = skip_string(p2,1);
2484                 SIVAL(p,48,PTR_DIFF(p2,*rdata)); /* comment */
2485                 *p2++ = 0;
2486                 SSVAL(p,52,0);          /* flags */
2487                 SIVAL(p,54,0);          /* script_path */
2488                 if (uLevel == 2)
2489                 {
2490                         SIVAL(p,60,0);          /* auth_flags */
2491                         SIVAL(p,64,PTR_DIFF(p2,*rdata)); /* full_name */
2492                         pstrcpy(p2,((vuser != NULL) ? vuser->real_name : UserName));
2493                         p2 = skip_string(p2,1);
2494                         SIVAL(p,68,0);          /* urs_comment */
2495                         SIVAL(p,72,PTR_DIFF(p2,*rdata)); /* parms */
2496                         pstrcpy(p2,"");
2497                         p2 = skip_string(p2,1);
2498                         SIVAL(p,76,0);          /* workstations */
2499                         SIVAL(p,80,0);          /* last_logon */
2500                         SIVAL(p,84,0);          /* last_logoff */
2501                         SIVALS(p,88,-1);                /* acct_expires */
2502                         SIVALS(p,92,-1);                /* max_storage */
2503                         SSVAL(p,96,168);        /* units_per_week */
2504                         SIVAL(p,98,PTR_DIFF(p2,*rdata)); /* logon_hours */
2505                         memset(p2,-1,21);
2506                         p2 += 21;
2507                         SSVALS(p,102,-1);       /* bad_pw_count */
2508                         SSVALS(p,104,-1);       /* num_logons */
2509                         SIVAL(p,106,PTR_DIFF(p2,*rdata)); /* logon_server */
2510                         pstrcpy(p2,"\\\\%L");
2511                         standard_sub_basic(p2);
2512                         p2 = skip_string(p2,1);
2513                         SSVAL(p,110,49);        /* country_code */
2514                         SSVAL(p,112,860);       /* code page */
2515                 }
2516         }
2517
2518         *rdata_len = PTR_DIFF(p2,*rdata);
2519
2520         SSVAL(*rparam,4,*rdata_len);    /* is this right?? */
2521
2522         return(True);
2523 }
2524
2525 /*******************************************************************
2526   get groups that a user is a member of
2527   ******************************************************************/
2528 static BOOL api_NetUserGetGroups(connection_struct *conn,uint16 vuid, char *param,char *data,
2529                                  int mdrcnt,int mprcnt,
2530                                  char **rdata,char **rparam,
2531                                  int *rdata_len,int *rparam_len)
2532 {
2533   char *str1 = param+2;
2534   char *str2 = skip_string(str1,1);
2535   char *UserName = skip_string(str2,1);
2536   char *p = skip_string(UserName,1);
2537   int uLevel = SVAL(p,0);
2538   char *p2;
2539   int count=0;
2540
2541   *rparam_len = 8;
2542   *rparam = REALLOC(*rparam,*rparam_len);
2543
2544   /* check it's a supported varient */
2545   if (strcmp(str1,"zWrLeh") != 0) return False;
2546   switch( uLevel ) {
2547   case 0: p2 = "B21"; break;
2548   default: return False;
2549   }
2550   if (strcmp(p2,str2) != 0) return False;
2551
2552   *rdata_len = mdrcnt + 1024;
2553   *rdata = REALLOC(*rdata,*rdata_len);
2554
2555   SSVAL(*rparam,0,NERR_Success);
2556   SSVAL(*rparam,2,0);           /* converter word */
2557
2558   p = *rdata;
2559
2560   /* XXXX we need a real SAM database some day */
2561   pstrcpy(p,"Users"); p += 21; count++;
2562   pstrcpy(p,"Domain Users"); p += 21; count++;
2563   pstrcpy(p,"Guests"); p += 21; count++;
2564   pstrcpy(p,"Domain Guests"); p += 21; count++;
2565
2566   *rdata_len = PTR_DIFF(p,*rdata);
2567
2568   SSVAL(*rparam,4,count);       /* is this right?? */
2569   SSVAL(*rparam,6,count);       /* is this right?? */
2570
2571   return(True);
2572 }
2573
2574
2575 static BOOL api_WWkstaUserLogon(connection_struct *conn,uint16 vuid, char *param,char *data,
2576                                 int mdrcnt,int mprcnt,
2577                                 char **rdata,char **rparam,
2578                                 int *rdata_len,int *rparam_len)
2579 {
2580   char *str1 = param+2;
2581   char *str2 = skip_string(str1,1);
2582   char *p = skip_string(str2,1);
2583   int uLevel;
2584   struct pack_desc desc;
2585   char* name;
2586   char* logon_script;
2587
2588   uLevel = SVAL(p,0);
2589   name = p + 2;
2590
2591   bzero(&desc,sizeof(desc));
2592
2593   DEBUG(3,("WWkstaUserLogon uLevel=%d name=%s\n",uLevel,name));
2594
2595   /* check it's a supported varient */
2596   if (strcmp(str1,"OOWb54WrLh") != 0) return False;
2597   if (uLevel != 1 || strcmp(str2,"WB21BWDWWDDDDDDDzzzD") != 0) return False;
2598   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2599   desc.base = *rdata;
2600   desc.buflen = mdrcnt;
2601   desc.subformat = NULL;
2602   desc.format = str2;
2603   
2604   if (init_package(&desc,1,0))
2605   {
2606     PACKI(&desc,"W",0);         /* code */
2607     PACKS(&desc,"B21",name);    /* eff. name */
2608     PACKS(&desc,"B","");                /* pad */
2609     PACKI(&desc,"W",
2610           conn->admin_user?USER_PRIV_ADMIN:USER_PRIV_USER);
2611     PACKI(&desc,"D",0);         /* auth flags XXX */
2612     PACKI(&desc,"W",0);         /* num logons */
2613     PACKI(&desc,"W",0);         /* bad pw count */
2614     PACKI(&desc,"D",0);         /* last logon */
2615     PACKI(&desc,"D",-1);                /* last logoff */
2616     PACKI(&desc,"D",-1);                /* logoff time */
2617     PACKI(&desc,"D",-1);                /* kickoff time */
2618     PACKI(&desc,"D",0);         /* password age */
2619     PACKI(&desc,"D",0);         /* password can change */
2620     PACKI(&desc,"D",-1);                /* password must change */
2621     {
2622       fstring mypath;
2623       fstrcpy(mypath,"\\\\");
2624       fstrcat(mypath,local_machine);
2625       strupper(mypath);
2626       PACKS(&desc,"z",mypath); /* computer */
2627     }
2628     PACKS(&desc,"z",global_myworkgroup);/* domain */
2629
2630 /* JHT - By calling lp_logon_script() and standard_sub() we have */
2631 /* made sure all macros are fully substituted and available */
2632     logon_script = lp_logon_script();
2633     standard_sub( conn, logon_script );
2634     PACKS(&desc,"z", logon_script);             /* script path */
2635 /* End of JHT mods */
2636
2637     PACKI(&desc,"D",0x00000000);                /* reserved */
2638   }
2639
2640   *rdata_len = desc.usedlen;
2641   *rparam_len = 6;
2642   *rparam = REALLOC(*rparam,*rparam_len);
2643   SSVALS(*rparam,0,desc.errcode);
2644   SSVAL(*rparam,2,0);
2645   SSVAL(*rparam,4,desc.neededlen);
2646
2647   DEBUG(4,("WWkstaUserLogon: errorcode %d\n",desc.errcode));
2648   return(True);
2649 }
2650
2651
2652 /****************************************************************************
2653   api_WAccessGetUserPerms
2654   ****************************************************************************/
2655 static BOOL api_WAccessGetUserPerms(connection_struct *conn,uint16 vuid, char *param,char *data,
2656                                     int mdrcnt,int mprcnt,
2657                                     char **rdata,char **rparam,
2658                                     int *rdata_len,int *rparam_len)
2659 {
2660   char *str1 = param+2;
2661   char *str2 = skip_string(str1,1);
2662   char *user = skip_string(str2,1);
2663   char *resource = skip_string(user,1);
2664
2665   DEBUG(3,("WAccessGetUserPerms user=%s resource=%s\n",user,resource));
2666
2667   /* check it's a supported varient */
2668   if (strcmp(str1,"zzh") != 0) return False;
2669   if (strcmp(str2,"") != 0) return False;
2670
2671   *rparam_len = 6;
2672   *rparam = REALLOC(*rparam,*rparam_len);
2673   SSVALS(*rparam,0,0);          /* errorcode */
2674   SSVAL(*rparam,2,0);           /* converter word */
2675   SSVAL(*rparam,4,0x7f);        /* permission flags */
2676
2677   return(True);
2678 }
2679
2680 /****************************************************************************
2681   api_WPrintJobEnumerate
2682   ****************************************************************************/
2683 static BOOL api_WPrintJobGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
2684                                  int mdrcnt,int mprcnt,
2685                                  char **rdata,char **rparam,
2686                                  int *rdata_len,int *rparam_len)
2687 {
2688   char *str1 = param+2;
2689   char *str2 = skip_string(str1,1);
2690   char *p = skip_string(str2,1);
2691   int uLevel;
2692   int count;
2693   int i;
2694   int snum;
2695   int job;
2696   struct pack_desc desc;
2697   print_queue_struct *queue=NULL;
2698   print_status_struct status;
2699
2700   uLevel = SVAL(p,2);
2701
2702   bzero(&desc,sizeof(desc));
2703   bzero(&status,sizeof(status));
2704
2705   DEBUG(3,("WPrintJobGetInfo uLevel=%d uJobId=0x%X\n",uLevel,SVAL(p,0)));
2706
2707   /* check it's a supported varient */
2708   if (strcmp(str1,"WWrLh") != 0) return False;
2709   if (!check_printjob_info(&desc,uLevel,str2)) return False;
2710
2711   printjob_decode(SVAL(p,0), &snum, &job);
2712
2713   if (snum < 0 || !VALID_SNUM(snum)) return(False);
2714
2715   count = get_printqueue(snum,conn,&queue,&status);
2716   for (i = 0; i < count; i++) {
2717     if ((queue[i].job & 0xFF) == job) break;
2718   }
2719   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2720   desc.base = *rdata;
2721   desc.buflen = mdrcnt;
2722
2723   if (init_package(&desc,1,0)) {
2724     if (i < count) {
2725       fill_printjob_info(conn,snum,uLevel,&desc,&queue[i],i);
2726       *rdata_len = desc.usedlen;
2727     }
2728     else {
2729       desc.errcode = NERR_JobNotFound;
2730       *rdata_len = 0;
2731     }
2732   }
2733
2734   *rparam_len = 6;
2735   *rparam = REALLOC(*rparam,*rparam_len);
2736   SSVALS(*rparam,0,desc.errcode);
2737   SSVAL(*rparam,2,0);
2738   SSVAL(*rparam,4,desc.neededlen);
2739
2740   if (queue) free(queue);
2741
2742   DEBUG(4,("WPrintJobGetInfo: errorcode %d\n",desc.errcode));
2743   return(True);
2744 }
2745
2746 static BOOL api_WPrintJobEnumerate(connection_struct *conn,uint16 vuid, char *param,char *data,
2747                                    int mdrcnt,int mprcnt,
2748                                    char **rdata,char **rparam,
2749                                    int *rdata_len,int *rparam_len)
2750 {
2751   char *str1 = param+2;
2752   char *str2 = skip_string(str1,1);
2753   char *p = skip_string(str2,1);
2754   char* name = p;
2755   int uLevel;
2756   int count;
2757   int i, succnt=0;
2758   int snum;
2759   struct pack_desc desc;
2760   print_queue_struct *queue=NULL;
2761   print_status_struct status;
2762
2763   bzero(&desc,sizeof(desc));
2764   bzero(&status,sizeof(status));
2765
2766   p = skip_string(p,1);
2767   uLevel = SVAL(p,0);
2768
2769   DEBUG(3,("WPrintJobEnumerate uLevel=%d name=%s\n",uLevel,name));
2770
2771   /* check it's a supported varient */
2772   if (strcmp(str1,"zWrLeh") != 0) return False;
2773   if (uLevel > 2) return False; /* defined only for uLevel 0,1,2 */
2774   if (!check_printjob_info(&desc,uLevel,str2)) return False;
2775
2776   snum = lp_servicenumber(name);
2777   if (snum < 0 && pcap_printername_ok(name,NULL)) {
2778     int pnum = lp_servicenumber(PRINTERS_NAME);
2779     if (pnum >= 0) {
2780       lp_add_printer(name,pnum);
2781       snum = lp_servicenumber(name);
2782     }
2783   }
2784
2785   if (snum < 0 || !VALID_SNUM(snum)) return(False);
2786
2787   count = get_printqueue(snum,conn,&queue,&status);
2788   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2789   desc.base = *rdata;
2790   desc.buflen = mdrcnt;
2791
2792   if (init_package(&desc,count,0)) {
2793     succnt = 0;
2794     for (i = 0; i < count; i++) {
2795       fill_printjob_info(conn,snum,uLevel,&desc,&queue[i],i);
2796       if (desc.errcode == NERR_Success) succnt = i+1;
2797     }
2798   }
2799
2800   *rdata_len = desc.usedlen;
2801
2802   *rparam_len = 8;
2803   *rparam = REALLOC(*rparam,*rparam_len);
2804   SSVALS(*rparam,0,desc.errcode);
2805   SSVAL(*rparam,2,0);
2806   SSVAL(*rparam,4,succnt);
2807   SSVAL(*rparam,6,count);
2808
2809   if (queue) free(queue);
2810
2811   DEBUG(4,("WPrintJobEnumerate: errorcode %d\n",desc.errcode));
2812   return(True);
2813 }
2814
2815 static int check_printdest_info(struct pack_desc* desc,
2816                                 int uLevel, char* id)
2817 {
2818   desc->subformat = NULL;
2819   switch( uLevel ) {
2820   case 0: desc->format = "B9"; break;
2821   case 1: desc->format = "B9B21WWzW"; break;
2822   case 2: desc->format = "z"; break;
2823   case 3: desc->format = "zzzWWzzzWW"; break;
2824   default: return False;
2825   }
2826   if (strcmp(desc->format,id) != 0) return False;
2827   return True;
2828 }
2829
2830 static void fill_printdest_info(connection_struct *conn, int snum, int uLevel,
2831                                 struct pack_desc* desc)
2832 {
2833   char buf[100];
2834   strncpy(buf,SERVICE(snum),sizeof(buf)-1);
2835   buf[sizeof(buf)-1] = 0;
2836   strupper(buf);
2837   if (uLevel <= 1) {
2838     PACKS(desc,"B9",buf);       /* szName */
2839     if (uLevel == 1) {
2840       PACKS(desc,"B21","");     /* szUserName */
2841       PACKI(desc,"W",0);                /* uJobId */
2842       PACKI(desc,"W",0);                /* fsStatus */
2843       PACKS(desc,"z","");       /* pszStatus */
2844       PACKI(desc,"W",0);                /* time */
2845     }
2846   }
2847   if (uLevel == 2 || uLevel == 3) {
2848     PACKS(desc,"z",buf);                /* pszPrinterName */
2849     if (uLevel == 3) {
2850       PACKS(desc,"z","");       /* pszUserName */
2851       PACKS(desc,"z","");       /* pszLogAddr */
2852       PACKI(desc,"W",0);                /* uJobId */
2853       PACKI(desc,"W",0);                /* fsStatus */
2854       PACKS(desc,"z","");       /* pszStatus */
2855       PACKS(desc,"z","");       /* pszComment */
2856       PACKS(desc,"z","NULL"); /* pszDrivers */
2857       PACKI(desc,"W",0);                /* time */
2858       PACKI(desc,"W",0);                /* pad1 */
2859     }
2860   }
2861 }
2862
2863 static BOOL api_WPrintDestGetInfo(connection_struct *conn,uint16 vuid, char *param,char *data,
2864                                   int mdrcnt,int mprcnt,
2865                                   char **rdata,char **rparam,
2866                                   int *rdata_len,int *rparam_len)
2867 {
2868   char *str1 = param+2;
2869   char *str2 = skip_string(str1,1);
2870   char *p = skip_string(str2,1);
2871   char* PrinterName = p;
2872   int uLevel;
2873   struct pack_desc desc;
2874   int snum;
2875
2876   bzero(&desc,sizeof(desc));
2877
2878   p = skip_string(p,1);
2879   uLevel = SVAL(p,0);
2880
2881   DEBUG(3,("WPrintDestGetInfo uLevel=%d PrinterName=%s\n",uLevel,PrinterName));
2882
2883   /* check it's a supported varient */
2884   if (strcmp(str1,"zWrLh") != 0) return False;
2885   if (!check_printdest_info(&desc,uLevel,str2)) return False;
2886
2887   snum = lp_servicenumber(PrinterName);
2888   if (snum < 0 && pcap_printername_ok(PrinterName,NULL)) {
2889     int pnum = lp_servicenumber(PRINTERS_NAME);
2890     if (pnum >= 0) {
2891       lp_add_printer(PrinterName,pnum);
2892       snum = lp_servicenumber(PrinterName);
2893     }
2894   }
2895
2896   if (snum < 0) {
2897     *rdata_len = 0;
2898     desc.errcode = NERR_DestNotFound;
2899     desc.neededlen = 0;
2900   }
2901   else {
2902     if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2903     desc.base = *rdata;
2904     desc.buflen = mdrcnt;
2905     if (init_package(&desc,1,0)) {
2906       fill_printdest_info(conn,snum,uLevel,&desc);
2907     }
2908     *rdata_len = desc.usedlen;
2909   }
2910
2911   *rparam_len = 6;
2912   *rparam = REALLOC(*rparam,*rparam_len);
2913   SSVALS(*rparam,0,desc.errcode);
2914   SSVAL(*rparam,2,0);
2915   SSVAL(*rparam,4,desc.neededlen);
2916
2917   DEBUG(4,("WPrintDestGetInfo: errorcode %d\n",desc.errcode));
2918   return(True);
2919 }
2920
2921 static BOOL api_WPrintDestEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
2922                                int mdrcnt,int mprcnt,
2923                                char **rdata,char **rparam,
2924                                int *rdata_len,int *rparam_len)
2925 {
2926   char *str1 = param+2;
2927   char *str2 = skip_string(str1,1);
2928   char *p = skip_string(str2,1);
2929   int uLevel;
2930   int queuecnt;
2931   int i, n, succnt=0;
2932   struct pack_desc desc;
2933   int services = lp_numservices();
2934
2935   bzero(&desc,sizeof(desc));
2936
2937   uLevel = SVAL(p,0);
2938
2939   DEBUG(3,("WPrintDestEnum uLevel=%d\n",uLevel));
2940
2941   /* check it's a supported varient */
2942   if (strcmp(str1,"WrLeh") != 0) return False;
2943   if (!check_printdest_info(&desc,uLevel,str2)) return False;
2944
2945   queuecnt = 0;
2946   for (i = 0; i < services; i++)
2947     if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i))
2948       queuecnt++;
2949
2950   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2951   desc.base = *rdata;
2952   desc.buflen = mdrcnt;
2953   if (init_package(&desc,queuecnt,0)) {    
2954     succnt = 0;
2955     n = 0;
2956     for (i = 0; i < services; i++) {
2957       if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
2958         fill_printdest_info(conn,i,uLevel,&desc);
2959         n++;
2960         if (desc.errcode == NERR_Success) succnt = n;
2961       }
2962     }
2963   }
2964
2965   *rdata_len = desc.usedlen;
2966
2967   *rparam_len = 8;
2968   *rparam = REALLOC(*rparam,*rparam_len);
2969   SSVALS(*rparam,0,desc.errcode);
2970   SSVAL(*rparam,2,0);
2971   SSVAL(*rparam,4,succnt);
2972   SSVAL(*rparam,6,queuecnt);
2973
2974   DEBUG(4,("WPrintDestEnumerate: errorcode %d\n",desc.errcode));
2975   return(True);
2976 }
2977
2978 static BOOL api_WPrintDriverEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
2979                                  int mdrcnt,int mprcnt,
2980                                  char **rdata,char **rparam,
2981                                  int *rdata_len,int *rparam_len)
2982 {
2983   char *str1 = param+2;
2984   char *str2 = skip_string(str1,1);
2985   char *p = skip_string(str2,1);
2986   int uLevel;
2987   int succnt;
2988   struct pack_desc desc;
2989
2990   bzero(&desc,sizeof(desc));
2991
2992   uLevel = SVAL(p,0);
2993
2994   DEBUG(3,("WPrintDriverEnum uLevel=%d\n",uLevel));
2995
2996   /* check it's a supported varient */
2997   if (strcmp(str1,"WrLeh") != 0) return False;
2998   if (uLevel != 0 || strcmp(str2,"B41") != 0) return False;
2999
3000   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
3001   desc.base = *rdata;
3002   desc.buflen = mdrcnt;
3003   if (init_package(&desc,1,0)) {
3004     PACKS(&desc,"B41","NULL");
3005   }
3006
3007   succnt = (desc.errcode == NERR_Success ? 1 : 0);
3008
3009   *rdata_len = desc.usedlen;
3010
3011   *rparam_len = 8;
3012   *rparam = REALLOC(*rparam,*rparam_len);
3013   SSVALS(*rparam,0,desc.errcode);
3014   SSVAL(*rparam,2,0);
3015   SSVAL(*rparam,4,succnt);
3016   SSVAL(*rparam,6,1);
3017
3018   DEBUG(4,("WPrintDriverEnum: errorcode %d\n",desc.errcode));
3019   return(True);
3020 }
3021
3022 static BOOL api_WPrintQProcEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
3023                                 int mdrcnt,int mprcnt,
3024                                 char **rdata,char **rparam,
3025                                 int *rdata_len,int *rparam_len)
3026 {
3027   char *str1 = param+2;
3028   char *str2 = skip_string(str1,1);
3029   char *p = skip_string(str2,1);
3030   int uLevel;
3031   int succnt;
3032   struct pack_desc desc;
3033
3034   bzero(&desc,sizeof(desc));
3035
3036   uLevel = SVAL(p,0);
3037
3038   DEBUG(3,("WPrintQProcEnum uLevel=%d\n",uLevel));
3039
3040   /* check it's a supported varient */
3041   if (strcmp(str1,"WrLeh") != 0) return False;
3042   if (uLevel != 0 || strcmp(str2,"B13") != 0) return False;
3043
3044   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
3045   desc.base = *rdata;
3046   desc.buflen = mdrcnt;
3047   desc.format = str2;
3048   if (init_package(&desc,1,0)) {
3049     PACKS(&desc,"B13","lpd");
3050   }
3051
3052   succnt = (desc.errcode == NERR_Success ? 1 : 0);
3053
3054   *rdata_len = desc.usedlen;
3055
3056   *rparam_len = 8;
3057   *rparam = REALLOC(*rparam,*rparam_len);
3058   SSVALS(*rparam,0,desc.errcode);
3059   SSVAL(*rparam,2,0);
3060   SSVAL(*rparam,4,succnt);
3061   SSVAL(*rparam,6,1);
3062
3063   DEBUG(4,("WPrintQProcEnum: errorcode %d\n",desc.errcode));
3064   return(True);
3065 }
3066
3067 static BOOL api_WPrintPortEnum(connection_struct *conn,uint16 vuid, char *param,char *data,
3068                                int mdrcnt,int mprcnt,
3069                                char **rdata,char **rparam,
3070                                int *rdata_len,int *rparam_len)
3071 {
3072   char *str1 = param+2;
3073   char *str2 = skip_string(str1,1);
3074   char *p = skip_string(str2,1);
3075   int uLevel;
3076   int succnt;
3077   struct pack_desc desc;
3078
3079   bzero(&desc,sizeof(desc));
3080
3081   uLevel = SVAL(p,0);
3082
3083   DEBUG(3,("WPrintPortEnum uLevel=%d\n",uLevel));
3084
3085   /* check it's a supported varient */
3086   if (strcmp(str1,"WrLeh") != 0) return False;
3087   if (uLevel != 0 || strcmp(str2,"B9") != 0) return False;
3088
3089   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
3090   bzero(&desc,sizeof(desc));
3091   desc.base = *rdata;
3092   desc.buflen = mdrcnt;
3093   desc.format = str2;
3094   if (init_package(&desc,1,0)) {
3095     PACKS(&desc,"B13","lp0");
3096   }
3097
3098   succnt = (desc.errcode == NERR_Success ? 1 : 0);
3099
3100   *rdata_len = desc.usedlen;
3101
3102   *rparam_len = 8;
3103   *rparam = REALLOC(*rparam,*rparam_len);
3104   SSVALS(*rparam,0,desc.errcode);
3105   SSVAL(*rparam,2,0);
3106   SSVAL(*rparam,4,succnt);
3107   SSVAL(*rparam,6,1);
3108
3109   DEBUG(4,("WPrintPortEnum: errorcode %d\n",desc.errcode));
3110   return(True);
3111 }
3112
3113 static void api_rpc_trans_reply(char *outbuf,
3114                                 pipes_struct *p,
3115                                 prs_struct *pd)
3116 {
3117         send_trans_reply(outbuf, p->rhdr.data, NULL, NULL, 0, p->file_offset);
3118
3119         if (mem_buf_len(p->rhdr.data) <= p->file_offset)
3120         {
3121                 /* all of data was sent: no need to wait for SMBreadX calls */
3122                 mem_free_data(p->rhdr .data);
3123                 mem_free_data(p->rdata.data);
3124                 mem_free_data(p->rdata_i.data);
3125         }
3126 }
3127
3128 /****************************************************************************
3129  WaitNamedPipeHandleState 
3130 ****************************************************************************/
3131 static BOOL api_WNPHS(char *outbuf, pipes_struct *p, char *param)
3132 {
3133         uint16 priority;
3134
3135         if (!param) return False;
3136
3137         priority = param[0] + (param[1] << 8);
3138         DEBUG(4,("WaitNamedPipeHandleState priority %x\n", priority));
3139
3140         if (wait_rpc_pipe_hnd_state(p, priority))
3141         {
3142                 /* now send the reply */
3143                 send_trans_reply(outbuf, NULL, NULL, NULL, 0, p->file_offset);
3144
3145                 return True;
3146         }
3147         return False;
3148 }
3149
3150
3151 /****************************************************************************
3152  SetNamedPipeHandleState 
3153 ****************************************************************************/
3154 static BOOL api_SNPHS(char *outbuf, pipes_struct *p, char *param)
3155 {
3156         uint16 id;
3157
3158         if (!param) return False;
3159
3160         id = param[0] + (param[1] << 8);
3161         DEBUG(4,("SetNamedPipeHandleState to code %x\n", id));
3162
3163         if (set_rpc_pipe_hnd_state(p, id))
3164         {
3165                 /* now send the reply */
3166                 send_trans_reply(outbuf, NULL, NULL, NULL, 0, p->file_offset);
3167
3168                 return True;
3169         }
3170         return False;
3171 }
3172
3173
3174 /****************************************************************************
3175  when no reply is generated, indicate unsupported.
3176  ****************************************************************************/
3177 static BOOL api_no_reply(char *outbuf, int max_rdata_len)
3178 {
3179         struct mem_buf rparam;
3180
3181         mem_init(&rparam, 0);
3182         mem_alloc_data(&rparam, 4);
3183
3184         rparam.offset.start = 0;
3185         rparam.offset.end   = 4;
3186
3187         /* unsupported */
3188         SSVAL(rparam.data,0,NERR_notsupported);
3189         SSVAL(rparam.data,2,0); /* converter word */
3190
3191         DEBUG(3,("Unsupported API fd command\n"));
3192
3193         /* now send the reply */
3194         send_trans_reply(outbuf, NULL, &rparam, NULL, 0, max_rdata_len);
3195
3196         mem_free_data(&rparam);
3197
3198         return(-1);
3199 }
3200
3201 /****************************************************************************
3202   handle remote api calls delivered to a named pipe already opened.
3203   ****************************************************************************/
3204 static int api_fd_reply(connection_struct *conn,uint16 vuid,char *outbuf,
3205                         uint16 *setup,char *data,char *params,
3206                         int suwcnt,int tdscnt,int tpscnt,int mdrcnt,int mprcnt)
3207 {
3208         BOOL reply    = False;
3209
3210         int pnum;
3211         int subcommand;
3212         pipes_struct *p = NULL;
3213         prs_struct pd;
3214
3215         DEBUG(5,("api_fd_reply\n"));
3216
3217         /* make a static data parsing structure from the api_fd_reply data */
3218         prs_init(&pd, 0, 4, 0, True);
3219         mem_create(pd.data, data, 0, tdscnt, 0, False);
3220
3221         /* First find out the name of this file. */
3222         if (suwcnt != 2)
3223         {
3224                 DEBUG(0,("Unexpected named pipe transaction.\n"));
3225                 return(-1);
3226         }
3227
3228         /* Get the file handle and hence the file name. */
3229         pnum = setup[1];
3230         subcommand = setup[0];
3231         p = get_rpc_pipe(pnum);
3232
3233         if (p != NULL)
3234         {
3235                 DEBUG(3,("Got API command 0x%x on pipe \"%s\" (pnum %x)",
3236                                   subcommand, p->name, pnum));
3237
3238                 /* record maximum data length that can be transmitted in an SMBtrans */
3239                 p->file_offset = mdrcnt;
3240
3241                 DEBUG(10,("api_fd_reply: p:%p file_offset: %d\n",
3242                            p, p->file_offset));
3243
3244                 switch (subcommand)
3245                 {
3246                         case 0x26:
3247                         {
3248                                 /* dce/rpc command */
3249                                 reply = rpc_command(p, &pd);
3250                                 if (reply)
3251                                 {
3252                                         api_rpc_trans_reply(outbuf, p, &pd);
3253                                 }
3254                                 break;
3255                         }
3256                         case 0x53:
3257                         {
3258                                 /* Wait Named Pipe Handle state */
3259                                 reply = api_WNPHS(outbuf, p, params);
3260                                 break;
3261                         }
3262                         case 0x01:
3263                         {
3264                                 /* Set Named Pipe Handle state */
3265                                 reply = api_SNPHS(outbuf, p, params);
3266                                 break;
3267                         }
3268                 }
3269         }
3270         else
3271         {
3272                 DEBUG(1,("api_fd_reply: INVALID PIPE HANDLE: %x\n", pnum));
3273         }
3274
3275         mem_free_data(pd.data);
3276
3277         if (!reply)
3278         {
3279                 return api_no_reply(outbuf, mdrcnt);
3280         }
3281         return -1;
3282 }
3283
3284 /****************************************************************************
3285   the buffer was too small
3286   ****************************************************************************/
3287 static BOOL api_TooSmall(connection_struct *conn,uint16 vuid, char *param,char *data,
3288                          int mdrcnt,int mprcnt,
3289                          char **rdata,char **rparam,
3290                          int *rdata_len,int *rparam_len)
3291 {
3292   *rparam_len = MIN(*rparam_len,mprcnt);
3293   *rparam = REALLOC(*rparam,*rparam_len);
3294
3295   *rdata_len = 0;
3296
3297   SSVAL(*rparam,0,NERR_BufTooSmall);
3298
3299   DEBUG(3,("Supplied buffer too small in API command\n"));
3300
3301   return(True);
3302 }
3303
3304
3305 /****************************************************************************
3306   the request is not supported
3307   ****************************************************************************/
3308 static BOOL api_Unsupported(connection_struct *conn,uint16 vuid, char *param,char *data,
3309                             int mdrcnt,int mprcnt,
3310                             char **rdata,char **rparam,
3311                             int *rdata_len,int *rparam_len)
3312 {
3313   *rparam_len = 4;
3314   *rparam = REALLOC(*rparam,*rparam_len);
3315
3316   *rdata_len = 0;
3317
3318   SSVAL(*rparam,0,NERR_notsupported);
3319   SSVAL(*rparam,2,0);           /* converter word */
3320
3321   DEBUG(3,("Unsupported API command\n"));
3322
3323   return(True);
3324 }
3325
3326
3327
3328
3329 struct
3330 {
3331   char *name;
3332   int id;
3333   BOOL (*fn)(connection_struct *,uint16,char *,char *,
3334              int,int,char **,char **,int *,int *);
3335   int flags;
3336 } api_commands[] = {
3337   {"RNetShareEnum",     0,      api_RNetShareEnum,0},
3338   {"RNetShareGetInfo",  1,      api_RNetShareGetInfo,0},
3339   {"RNetServerGetInfo", 13,     api_RNetServerGetInfo,0},
3340   {"RNetGroupGetUsers", 52,     api_RNetGroupGetUsers,0},
3341   {"RNetUserGetInfo",   56,     api_RNetUserGetInfo,0},
3342   {"NetUserGetGroups",  59,     api_NetUserGetGroups,0},
3343   {"NetWkstaGetInfo",   63,     api_NetWkstaGetInfo,0},
3344   {"DosPrintQEnum",     69,     api_DosPrintQEnum,0},
3345   {"DosPrintQGetInfo",  70,     api_DosPrintQGetInfo,0},
3346   {"WPrintQueuePause",  74, api_WPrintQueuePurge,0},
3347   {"WPrintQueueResume", 75, api_WPrintQueuePurge,0},
3348   {"WPrintJobEnumerate",76,     api_WPrintJobEnumerate,0},
3349   {"WPrintJobGetInfo",  77,     api_WPrintJobGetInfo,0},
3350   {"RDosPrintJobDel",   81,     api_RDosPrintJobDel,0},
3351   {"RDosPrintJobPause", 82,     api_RDosPrintJobDel,0},
3352   {"RDosPrintJobResume",83,     api_RDosPrintJobDel,0},
3353   {"WPrintDestEnum",    84,     api_WPrintDestEnum,0},
3354   {"WPrintDestGetInfo", 85,     api_WPrintDestGetInfo,0},
3355   {"NetRemoteTOD",      91,     api_NetRemoteTOD,0},
3356   {"WPrintQueuePurge",  103,    api_WPrintQueuePurge,0},
3357   {"NetServerEnum",     104,    api_RNetServerEnum,0},
3358   {"WAccessGetUserPerms",105,   api_WAccessGetUserPerms,0},
3359   {"SetUserPassword",   115,    api_SetUserPassword,0},
3360   {"WWkstaUserLogon",   132,    api_WWkstaUserLogon,0},
3361   {"PrintJobInfo",      147,    api_PrintJobInfo,0},
3362   {"WPrintDriverEnum",  205,    api_WPrintDriverEnum,0},
3363   {"WPrintQProcEnum",   206,    api_WPrintQProcEnum,0},
3364   {"WPrintPortEnum",    207,    api_WPrintPortEnum,0},
3365   {"SamOEMChangePassword", 214, api_SamOEMChangePassword,0},
3366   {NULL,                -1,     api_Unsupported,0}};
3367
3368
3369 /****************************************************************************
3370   handle remote api calls
3371   ****************************************************************************/
3372 static int api_reply(connection_struct *conn,uint16 vuid,char *outbuf,char *data,char *params,
3373                      int tdscnt,int tpscnt,int mdrcnt,int mprcnt)
3374 {
3375   int api_command;
3376   struct mem_buf rdata_buf;
3377   struct mem_buf rparam_buf;
3378   char *rdata = NULL;
3379   char *rparam = NULL;
3380   int rdata_len = 0;
3381   int rparam_len = 0;
3382   BOOL reply=False;
3383   int i;
3384
3385   SMB_ASSERT(params != 0);
3386
3387   api_command = SVAL(params,0);
3388
3389   DEBUG(3,("Got API command %d of form <%s> <%s> (tdscnt=%d,tpscnt=%d,mdrcnt=%d,mprcnt=%d)\n",
3390            api_command,
3391            params+2,
3392            skip_string(params+2,1),
3393            tdscnt,tpscnt,mdrcnt,mprcnt));
3394
3395   for (i=0;api_commands[i].name;i++)
3396     if (api_commands[i].id == api_command && api_commands[i].fn)
3397       {
3398         DEBUG(3,("Doing %s\n",api_commands[i].name));
3399         break;
3400       }
3401
3402   rdata = (char *)malloc(1024); if (rdata) bzero(rdata,1024);
3403   rparam = (char *)malloc(1024); if (rparam) bzero(rparam,1024);
3404
3405   if(!rdata || !rparam) {
3406     DEBUG(0,("api_reply: malloc fail !\n"));
3407     return -1;
3408   }
3409
3410   reply = api_commands[i].fn(conn,vuid,params,data,mdrcnt,mprcnt,
3411                              &rdata,&rparam,&rdata_len,&rparam_len);
3412
3413
3414   if (rdata_len > mdrcnt ||
3415       rparam_len > mprcnt)
3416     {
3417       reply = api_TooSmall(conn,vuid,params,data,mdrcnt,mprcnt,
3418                            &rdata,&rparam,&rdata_len,&rparam_len);
3419     }
3420             
3421
3422   /* if we get False back then it's actually unsupported */
3423   if (!reply)
3424     api_Unsupported(conn,vuid,params,data,mdrcnt,mprcnt,
3425                     &rdata,&rparam,&rdata_len,&rparam_len);
3426
3427       
3428   mem_create(&rdata_buf , rdata , 0, rdata_len , 0, False);
3429   mem_create(&rparam_buf, rparam, 0, rparam_len, 0, False);
3430
3431   /* now send the reply */
3432   send_trans_reply(outbuf, &rdata_buf, &rparam_buf, NULL, 0, 0);
3433
3434   if (rdata ) free(rdata);
3435   if (rparam) free(rparam);
3436   
3437   return(-1);
3438 }
3439
3440 /****************************************************************************
3441   handle named pipe commands
3442   ****************************************************************************/
3443 static int named_pipe(connection_struct *conn,uint16 vuid, char *outbuf,char *name,
3444                       uint16 *setup,char *data,char *params,
3445                       int suwcnt,int tdscnt,int tpscnt,
3446                       int msrcnt,int mdrcnt,int mprcnt)
3447 {
3448         DEBUG(3,("named pipe command on <%s> name\n", name));
3449
3450         if (strequal(name,"LANMAN"))
3451         {
3452                 return api_reply(conn,vuid,outbuf,data,params,tdscnt,tpscnt,mdrcnt,mprcnt);
3453         }
3454
3455         if (strequal(name,"WKSSVC") ||
3456             strequal(name,"SRVSVC") ||
3457             strequal(name,"WINREG") ||
3458             strequal(name,"SAMR") ||
3459             strequal(name,"LSARPC"))
3460         {
3461                 DEBUG(4,("named pipe command from Win95 (wow!)\n"));
3462                 return api_fd_reply(conn,vuid,outbuf,setup,data,params,suwcnt,tdscnt,tpscnt,mdrcnt,mprcnt);
3463         }
3464
3465         if (strlen(name) < 1)
3466         {
3467                 return api_fd_reply(conn,vuid,outbuf,setup,data,params,suwcnt,tdscnt,tpscnt,mdrcnt,mprcnt);
3468         }
3469
3470         if (setup)
3471         {
3472                 DEBUG(3,("unknown named pipe: setup 0x%X setup1=%d\n", (int)setup[0],(int)setup[1]));
3473         }
3474
3475         return 0;
3476 }
3477
3478
3479 /****************************************************************************
3480   reply to a SMBtrans
3481   ****************************************************************************/
3482 int reply_trans(connection_struct *conn, char *inbuf,char *outbuf, int size, int bufsize)
3483 {
3484         fstring name;
3485         int name_offset = 0;
3486         char *data=NULL,*params=NULL;
3487         uint16 *setup=NULL;
3488         int outsize = 0;
3489         uint16 vuid = SVAL(inbuf,smb_uid);
3490         int tpscnt = SVAL(inbuf,smb_vwv0);
3491         int tdscnt = SVAL(inbuf,smb_vwv1);
3492         int mprcnt = SVAL(inbuf,smb_vwv2);
3493         int mdrcnt = SVAL(inbuf,smb_vwv3);
3494         int msrcnt = CVAL(inbuf,smb_vwv4);
3495         BOOL close_on_completion = BITSETW(inbuf+smb_vwv5,0);
3496         BOOL one_way = BITSETW(inbuf+smb_vwv5,1);
3497         int pscnt = SVAL(inbuf,smb_vwv9);
3498         int psoff = SVAL(inbuf,smb_vwv10);
3499         int dscnt = SVAL(inbuf,smb_vwv11);
3500         int dsoff = SVAL(inbuf,smb_vwv12);
3501         int suwcnt = CVAL(inbuf,smb_vwv13);
3502
3503         bzero(name, sizeof(name));
3504         fstrcpy(name,smb_buf(inbuf));
3505
3506         if (dscnt > tdscnt || pscnt > tpscnt) {
3507                 exit_server("invalid trans parameters\n");
3508         }
3509   
3510         if (tdscnt)  {
3511                 if((data = (char *)malloc(tdscnt)) == NULL) {
3512                         DEBUG(0,("reply_trans: data malloc fail for %d bytes !\n", tdscnt));
3513                         return(ERROR(ERRDOS,ERRnomem));
3514                 } 
3515                 memcpy(data,smb_base(inbuf)+dsoff,dscnt);
3516         }
3517
3518         if (tpscnt) {
3519                 if((params = (char *)malloc(tpscnt)) == NULL) {
3520                         DEBUG(0,("reply_trans: param malloc fail for %d bytes !\n", tpscnt));
3521                         return(ERROR(ERRDOS,ERRnomem));
3522                 } 
3523                 memcpy(params,smb_base(inbuf)+psoff,pscnt);
3524         }
3525
3526         if (suwcnt) {
3527                 int i;
3528                 if((setup = (uint16 *)malloc(suwcnt*sizeof(uint16))) == NULL) {
3529           DEBUG(0,("reply_trans: setup malloc fail for %d bytes !\n", suwcnt * sizeof(uint16)));
3530                   return(ERROR(ERRDOS,ERRnomem));
3531         } 
3532                 for (i=0;i<suwcnt;i++)
3533                         setup[i] = SVAL(inbuf,smb_vwv14+i*SIZEOFWORD);
3534         }
3535
3536
3537         if (pscnt < tpscnt || dscnt < tdscnt) {
3538                 /* We need to send an interim response then receive the rest
3539                    of the parameter/data bytes */
3540                 outsize = set_message(outbuf,0,0,True);
3541                 show_msg(outbuf);
3542                 send_smb(Client,outbuf);
3543         }
3544
3545         /* receive the rest of the trans packet */
3546         while (pscnt < tpscnt || dscnt < tdscnt) {
3547                 BOOL ret;
3548                 int pcnt,poff,dcnt,doff,pdisp,ddisp;
3549       
3550                 ret = receive_next_smb(inbuf,bufsize,SMB_SECONDARY_WAIT);
3551
3552                 if ((ret && (CVAL(inbuf, smb_com) != SMBtrans)) || !ret) {
3553                         if(ret) {
3554                                 DEBUG(0,("reply_trans: Invalid secondary trans packet\n"));
3555                         } else {
3556                                 DEBUG(0,("reply_trans: %s in getting secondary trans response.\n",
3557                                          (smb_read_error == READ_ERROR) ? "error" : "timeout" ));
3558                         }
3559                         if (params) free(params);
3560                         if (data) free(data);
3561                         if (setup) free(setup);
3562                         return(ERROR(ERRSRV,ERRerror));
3563                 }
3564
3565                 show_msg(inbuf);
3566       
3567                 tpscnt = SVAL(inbuf,smb_vwv0);
3568                 tdscnt = SVAL(inbuf,smb_vwv1);
3569
3570                 pcnt = SVAL(inbuf,smb_vwv2);
3571                 poff = SVAL(inbuf,smb_vwv3);
3572                 pdisp = SVAL(inbuf,smb_vwv4);
3573                 
3574                 dcnt = SVAL(inbuf,smb_vwv5);
3575                 doff = SVAL(inbuf,smb_vwv6);
3576                 ddisp = SVAL(inbuf,smb_vwv7);
3577                 
3578                 pscnt += pcnt;
3579                 dscnt += dcnt;
3580                 
3581                 if (dscnt > tdscnt || pscnt > tpscnt) {
3582                         exit_server("invalid trans parameters\n");
3583                 }
3584                 
3585                 if (pcnt)
3586                         memcpy(params+pdisp,smb_base(inbuf)+poff,pcnt);
3587                 if (dcnt)
3588                         memcpy(data+ddisp,smb_base(inbuf)+doff,dcnt);      
3589         }
3590         
3591         
3592         DEBUG(3,("trans <%s> data=%d params=%d setup=%d\n",
3593                  name,tdscnt,tpscnt,suwcnt));
3594         
3595         /*
3596          * WinCE wierdness....
3597          */
3598
3599         if (name[0] == '\\' && (StrnCaseCmp(&name[1],local_machine,
3600                                 strlen(local_machine)) == 0)) {
3601           name_offset = strlen(local_machine)+1;
3602         }
3603
3604         if (strncmp(&name[name_offset],"\\PIPE\\",strlen("\\PIPE\\")) == 0) {
3605                 DEBUG(5,("calling named_pipe\n"));
3606                 outsize = named_pipe(conn,vuid,outbuf,
3607                                      name+name_offset+strlen("\\PIPE\\"),setup,data,params,
3608                                      suwcnt,tdscnt,tpscnt,msrcnt,mdrcnt,mprcnt);
3609         } else {
3610                 DEBUG(3,("invalid pipe name\n"));
3611                 outsize = 0;
3612         }
3613
3614         
3615         if (data) free(data);
3616         if (params) free(params);
3617         if (setup) free(setup);
3618         
3619         if (close_on_completion)
3620                 close_cnum(conn,vuid);
3621
3622         if (one_way)
3623                 return(-1);
3624         
3625         if (outsize == 0)
3626                 return(ERROR(ERRSRV,ERRnosupport));
3627         
3628         return(outsize);
3629 }