8852e57e8b6d251404212572264feefe45bb3966
[bbaumbach/samba-autobuild/.git] / source3 / 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-1995
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20    */
21 /*
22    This file handles the named pipe and mailslot calls
23    in the SMBtrans protocol
24    */
25
26 #include "includes.h"
27 #include "loadparm.h"
28 #include "pcap.h"
29
30 #ifdef CHECK_TYPES
31 #undef CHECK_TYPES
32 #endif
33 #define CHECK_TYPES 0
34
35 extern int DEBUGLEVEL;
36 extern int maxxmit;
37 extern files_struct Files[];
38 extern connection_struct Connections[];
39
40 extern fstring local_machine;
41
42 #define NERR_Success 0
43 #define NERR_badpass 86
44 #define NERR_notsupported 50
45
46 #define NERR_BASE (2100)
47 #define NERR_BufTooSmall (NERR_BASE+23)
48 #define NERR_JobNotFound (NERR_BASE+51)
49 #define NERR_DestNotFound (NERR_BASE+52)
50 #define ERROR_INVALID_LEVEL 124
51 #define ERROR_MORE_DATA 234
52
53 #define REALLOC(ptr,size) Realloc(ptr,MAX((size),4*1024))
54
55 #define ACCESS_READ 0x01
56 #define ACCESS_WRITE 0x02
57 #define ACCESS_CREATE 0x04
58
59 #define SHPWLEN 8               /* share password length */
60 #define NNLEN 12                /* 8.3 net name length */
61 #define SNLEN 15                /* service name length */
62 #define QNLEN 12                /* queue name maximum length */
63
64 extern int Client;
65
66 static int CopyExpanded(int cnum, int snum, char** dst, char* src, int* n)
67 {
68   pstring buf;
69   int l;
70
71   if (!src || !dst || !n || !(*dst)) return(0);
72
73   StrnCpy(buf,src,sizeof(buf)/2);
74   string_sub(buf,"%S",lp_servicename(snum));
75   standard_sub(cnum,buf);
76   StrnCpy(*dst,buf,*n);
77   l = strlen(*dst) + 1;
78   (*dst) += l;
79   (*n) -= l;
80   return l;
81 }
82
83 static int CopyAndAdvance(char** dst, char* src, int* n)
84 {
85   int l;
86   if (!src || !dst || !n || !(*dst)) return(0);
87   StrnCpy(*dst,src,*n);
88   l = strlen(*dst) + 1;
89   (*dst) += l;
90   (*n) -= l;
91   return l;
92 }
93
94 static int StrlenExpanded(int cnum, int snum, char* s)
95 {
96   pstring buf;
97   if (!s) return(0);
98   StrnCpy(buf,s,sizeof(buf)/2);
99   string_sub(buf,"%S",lp_servicename(snum));
100   standard_sub(cnum,buf);
101   return strlen(buf) + 1;
102 }
103
104 static char* Expand(int cnum, int snum, char* s)
105 {
106   static pstring buf;
107   if (!s) return(NULL);
108   StrnCpy(buf,s,sizeof(buf)/2);
109   string_sub(buf,"%S",lp_servicename(snum));
110   standard_sub(cnum,buf);
111   return &buf[0];
112 }
113
114 /*******************************************************************
115   check a API string for validity when we only need to check the prefix
116   ******************************************************************/
117 static BOOL prefix_ok(char *str,char *prefix)
118 {
119   return(strncmp(str,prefix,strlen(prefix)) == 0);
120 }
121
122
123 /****************************************************************************
124   send a trans reply
125   ****************************************************************************/
126 static void send_trans_reply(char *outbuf,char *data,char *param,uint16 *setup,
127                              int ldata,int lparam,int lsetup)
128 {
129   int i;
130   int this_ldata,this_lparam;
131   int tot_data=0,tot_param=0;
132   int align;
133
134   this_lparam = MIN(lparam,maxxmit - (500+lsetup*SIZEOFWORD)); /* hack */
135   this_ldata = MIN(ldata,maxxmit - (500+lsetup*SIZEOFWORD+this_lparam));
136
137   align = (this_lparam%4);
138
139   set_message(outbuf,10+lsetup,align+this_ldata+this_lparam,True);
140   if (this_lparam)
141     memcpy(smb_buf(outbuf),param,this_lparam);
142   if (this_ldata)
143     memcpy(smb_buf(outbuf)+this_lparam+align,data,this_ldata);
144
145   SSVAL(outbuf,smb_vwv0,lparam);
146   SSVAL(outbuf,smb_vwv1,ldata);
147   SSVAL(outbuf,smb_vwv3,this_lparam);
148   SSVAL(outbuf,smb_vwv4,smb_offset(smb_buf(outbuf),outbuf));
149   SSVAL(outbuf,smb_vwv5,0);
150   SSVAL(outbuf,smb_vwv6,this_ldata);
151   SSVAL(outbuf,smb_vwv7,smb_offset(smb_buf(outbuf)+this_lparam+align,outbuf));
152   SSVAL(outbuf,smb_vwv8,0);
153   SSVAL(outbuf,smb_vwv9,lsetup);
154   for (i=0;i<lsetup;i++)
155     SSVAL(outbuf,smb_vwv10+i*SIZEOFWORD,setup[i]);
156
157   show_msg(outbuf);
158   send_smb(Client,outbuf);
159
160   tot_data = this_ldata;
161   tot_param = this_lparam;
162
163   while (tot_data < ldata || tot_param < lparam)
164     {
165       this_lparam = MIN(lparam-tot_param,maxxmit - 500); /* hack */
166       this_ldata = MIN(ldata-tot_data,maxxmit - (500+this_lparam));
167
168       align = (this_lparam%4);
169
170       set_message(outbuf,10,this_ldata+this_lparam+align,False);
171       if (this_lparam)
172         memcpy(smb_buf(outbuf),param+tot_param,this_lparam);
173       if (this_ldata)
174         memcpy(smb_buf(outbuf)+this_lparam+align,data+tot_data,this_ldata);
175
176       SSVAL(outbuf,smb_vwv3,this_lparam);
177       SSVAL(outbuf,smb_vwv4,smb_offset(smb_buf(outbuf),outbuf));
178       SSVAL(outbuf,smb_vwv5,tot_param);
179       SSVAL(outbuf,smb_vwv6,this_ldata);
180       SSVAL(outbuf,smb_vwv7,smb_offset(smb_buf(outbuf)+this_lparam+align,outbuf));
181       SSVAL(outbuf,smb_vwv8,tot_data);
182       SSVAL(outbuf,smb_vwv9,0);
183
184       show_msg(outbuf);
185       send_smb(Client,outbuf);
186
187       tot_data += this_ldata;
188       tot_param += this_lparam;
189     }
190 }
191
192
193
194 /****************************************************************************
195   get a print queue
196   ****************************************************************************/
197
198 struct pack_desc {
199   char* format;     /* formatstring for structure */
200   char* subformat;  /* subformat for structure */
201   char* base;       /* baseaddress of buffer */
202   int buflen;      /* remaining size for fixed part; on init: length of base */
203   int subcount;     /* count of substructures */
204   char* structbuf;  /* pointer into buffer for remaining fixed part */
205   int stringlen;    /* remaining size for variable part */              
206   char* stringbuf;  /* pointer into buffer for remaining variable part */
207   int neededlen;    /* total needed size */
208   int usedlen;      /* total used size (usedlen <= neededlen and usedlen <= buflen) */
209   char* curpos;     /* current position; pointer into format or subformat */
210   int errcode;
211 };
212
213 static int get_counter(char** p)
214 {
215   int i, n;
216   if (!p || !(*p)) return(1);
217   if (!isdigit(**p)) return 1;
218   for (n = 0;;) {
219     i = **p;
220     if (isdigit(i))
221       n = 10 * n + (i - '0');
222     else
223       return n;
224     (*p)++;
225   }
226 }
227
228 static int getlen(char* p)
229 {
230   int n = 0;
231   if (!p) return(0);
232   while (*p) {
233     switch( *p++ ) {
234     case 'W':                   /* word (2 byte) */
235       n += 2;
236       break;
237     case 'N':                   /* count of substructures (word) at end */
238       n += 2;
239       break;
240     case 'D':                   /* double word (4 byte) */
241     case 'z':                   /* offset to zero terminated string (4 byte) */
242     case 'l':                   /* offset to user data (4 byte) */
243       n += 4;
244       break;
245     case 'b':                   /* offset to data (with counter) (4 byte) */
246       n += 4;
247       get_counter(&p);
248       break;
249     case 'B':                   /* byte (with optional counter) */
250       n += get_counter(&p);
251       break;
252     }
253   }
254   return n;
255 }
256
257 static BOOL init_package(struct pack_desc* p, int count, int subcount)
258 {
259   int n = p->buflen;
260   int i;
261
262   if (!p->format || !p->base) return(False);
263
264   i = count * getlen(p->format);
265   if (p->subformat) i += subcount * getlen(p->subformat);
266   p->structbuf = p->base;
267   p->neededlen = 0;
268   p->usedlen = 0;
269   p->subcount = 0;
270   p->curpos = p->format;
271   if (i > n) {
272     i = n = 0;
273     p->errcode = NERR_BufTooSmall;
274   }
275
276   p->errcode = NERR_Success;
277   p->buflen = i;
278   n -= i;
279   p->stringbuf = p->base + i;
280   p->stringlen = n;
281   return(p->errcode == NERR_Success);
282 }
283
284 #ifdef __STDC__
285 static int package(struct pack_desc* p, ...)
286 {
287 #else
288 static int package(va_alist)
289 va_dcl
290 {
291   struct pack_desc* p;
292 #endif
293   va_list args;
294   int needed=0, stringneeded;
295   char* str=NULL;
296   int is_string=0, stringused;
297   int32 temp;
298
299 #ifdef __STDC__
300   va_start(args,p);
301 #else
302   va_start(args);
303   p = va_arg(args,struct pack_desc *);
304 #endif
305
306   if (!*p->curpos) {
307     if (!p->subcount)
308       p->curpos = p->format;
309     else {
310       p->curpos = p->subformat;
311       p->subcount--;
312     }
313   }
314 #if CHECK_TYPES
315   str = va_arg(args,char*);
316   if (strncmp(str,p->curpos,strlen(str)) != 0) {
317     DEBUG(2,("type error in package: %s instead of %*s\n",str,
318              strlen(str),p->curpos));
319     va_end(args);
320 #if AJT
321     ajt_panic();
322 #endif  
323     return 0;
324   }
325 #endif
326   stringneeded = -1;
327
328   if (!p->curpos) return(0);
329
330   switch( *p->curpos++ ) {
331   case 'W':                     /* word (2 byte) */
332     needed = 2;
333     temp = va_arg(args,int);
334     if (p->buflen >= needed) SSVAL(p->structbuf,0,temp);
335     break;
336   case 'N':                     /* count of substructures (word) at end */
337     needed = 2;
338     p->subcount = va_arg(args,int);
339     if (p->buflen >= needed) SSVAL(p->structbuf,0,p->subcount);
340     break;
341   case 'D':                     /* double word (4 byte) */
342     needed = 4;
343     temp = va_arg(args,int);
344     if (p->buflen >= needed) SIVAL(p->structbuf,0,temp);
345     break;
346   case 'B':                     /* byte (with optional counter) */
347     needed = get_counter(&p->curpos);
348     {
349       char *s = va_arg(args,char*);
350       if (p->buflen >= needed) StrnCpy(p->structbuf,s?s:"",needed);
351     }
352     break;
353   case 'z':                     /* offset to zero terminated string (4 byte) */
354     str = va_arg(args,char*);
355     stringneeded = (str ? strlen(str)+1 : 0);
356     is_string = 1;
357     break;
358   case 'l':                     /* offset to user data (4 byte) */
359     str = va_arg(args,char*);
360     stringneeded = va_arg(args,int);
361     is_string = 0;
362     break;
363   case 'b':                     /* offset to data (with counter) (4 byte) */
364     str = va_arg(args,char*);
365     stringneeded = get_counter(&p->curpos);
366     is_string = 0;
367     break;
368   }
369   va_end(args);
370   if (stringneeded >= 0) {
371     needed = 4;
372     if (p->buflen >= needed) {
373       stringused = stringneeded;
374       if (stringused > p->stringlen) {
375         stringused = (is_string ? p->stringlen : 0);
376         if (p->errcode == NERR_Success) p->errcode = ERROR_MORE_DATA;
377       }
378       if (!stringused)
379         SIVAL(p->structbuf,0,0);
380       else {
381         SIVAL(p->structbuf,0,PTR_DIFF(p->stringbuf,p->base));
382         memcpy(p->stringbuf,str?str:"",stringused);
383         if (is_string) p->stringbuf[stringused-1] = '\0';
384         p->stringbuf += stringused;
385         p->stringlen -= stringused;
386         p->usedlen += stringused;
387       }
388     }
389     p->neededlen += stringneeded;
390   }
391   p->neededlen += needed;
392   if (p->buflen >= needed) {
393     p->structbuf += needed;
394     p->buflen -= needed;
395     p->usedlen += needed;
396   }
397   else {
398     if (p->errcode == NERR_Success) p->errcode = NERR_BufTooSmall;
399   }
400   return 1;
401 }
402
403 #if CHECK_TYPES
404 #define PACK(desc,t,v) package(desc,t,v,0,0,0,0)
405 #define PACKl(desc,t,v,l) package(desc,t,v,l,0,0,0,0)
406 #else
407 #define PACK(desc,t,v) package(desc,v)
408 #define PACKl(desc,t,v,l) package(desc,v,l)
409 #endif
410
411 static void PACKI(struct pack_desc* desc,char *t,int v)
412 {
413   PACK(desc,t,v);
414 }
415
416 static void PACKS(struct pack_desc* desc,char *t,char *v)
417 {
418   PACK(desc,t,v);
419 }
420
421 static void PackDriverData(struct pack_desc* desc)
422 {
423   char drivdata[4+4+32];
424   SIVAL(drivdata,0,sizeof drivdata); /* cb */
425   SIVAL(drivdata,4,1000);       /* lVersion */
426   memset(drivdata+8,0,32);      /* szDeviceName */
427   strcpy(drivdata+8,"NULL");
428   PACKl(desc,"l",drivdata,sizeof drivdata); /* pDriverData */
429 }
430
431 static int check_printq_info(struct pack_desc* desc,
432                              int uLevel, const char* id1, const char* id2)
433 {
434   desc->subformat = NULL;
435   switch( uLevel ) {
436   case 0:
437     desc->format = "B13";
438     break;
439   case 1:
440     desc->format = "B13BWWWzzzzzWW";
441     break;
442   case 2:
443     desc->format = "B13BWWWzzzzzWN";
444     desc->subformat = "WB21BB16B10zWWzDDz";
445     break;
446   case 3:
447     desc->format = "zWWWWzzzzWWzzl";
448     break;
449   case 4:
450     desc->format = "zWWWWzzzzWNzzl";
451     desc->subformat = "WWzWWDDzz";
452     break;
453   case 5:
454     desc->format = "z";
455     break;
456   default: return False;
457   }
458   if (strcmp(desc->format,id1) != 0) return False;
459   if (desc->subformat && strcmp(desc->subformat,id2) != 0) return False;
460   return True;
461 }
462
463 static void fill_printjob_info(int cnum, int snum, int uLevel,
464                                struct pack_desc* desc,
465                                print_queue_struct* queue, int n)
466 {
467   time_t t = queue->time;
468
469   /* the client expects localtime */
470   t += GMT_TO_LOCAL*TimeDiff(t);
471
472   PACKI(desc,"W",((snum%0xFF)<<8) | (queue->job%0xFF)); /* uJobId */
473   if (uLevel == 1) {
474     PACKS(desc,"B21",queue->user); /* szUserName */
475     PACKS(desc,"B","");         /* pad */
476     PACKS(desc,"B16","");       /* szNotifyName */
477     PACKS(desc,"B10","PM_Q_RAW"); /* szDataType */
478     PACKS(desc,"z","");         /* pszParms */
479     PACKI(desc,"W",n+1);                /* uPosition */
480     PACKI(desc,"W",queue->status); /* fsStatus */
481     PACKS(desc,"z","");         /* pszStatus */
482     PACKI(desc,"D",queue->time); /* ulSubmitted */
483     PACKI(desc,"D",queue->size); /* ulSize */
484     PACKS(desc,"z",queue->file); /* pszComment */
485   }
486   if (uLevel == 2 || uLevel == 3) {
487     PACKI(desc,"W",queue->priority);            /* uPriority */
488     PACKS(desc,"z",queue->user); /* pszUserName */
489     PACKI(desc,"W",n+1);                /* uPosition */
490     PACKI(desc,"W",queue->status); /* fsStatus */
491     PACKI(desc,"D",queue->time); /* ulSubmitted */
492     PACKI(desc,"D",queue->size); /* ulSize */
493     PACKS(desc,"z","Samba");    /* pszComment */
494     PACKS(desc,"z",queue->file); /* pszDocument */
495     if (uLevel == 3) {
496       PACKS(desc,"z","");       /* pszNotifyName */
497       PACKS(desc,"z","PM_Q_RAW"); /* pszDataType */
498       PACKS(desc,"z","");       /* pszParms */
499       PACKS(desc,"z","");       /* pszStatus */
500       PACKS(desc,"z",SERVICE(snum)); /* pszQueue */
501       PACKS(desc,"z","lpd");    /* pszQProcName */
502       PACKS(desc,"z","");       /* pszQProcParms */
503       PACKS(desc,"z","NULL"); /* pszDriverName */
504       PackDriverData(desc);     /* pDriverData */
505       PACKS(desc,"z","");       /* pszPrinterName */
506     }
507   }
508 }
509
510 static void fill_printq_info(int cnum, int snum, int uLevel,
511                              struct pack_desc* desc,
512                              int count, print_queue_struct* queue,
513                              print_status_struct* status)
514 {
515   if (uLevel < 3) {
516     PACKS(desc,"B13",SERVICE(snum));
517   } else {
518     PACKS(desc,"z",Expand(cnum,snum,SERVICE(snum)));
519   }
520   if (uLevel == 1 || uLevel == 2) {
521     PACKS(desc,"B","");         /* alignment */
522     PACKI(desc,"W",5);          /* priority */
523     PACKI(desc,"W",0);          /* start time */
524     PACKI(desc,"W",0);          /* until time */
525     PACKS(desc,"z","");         /* pSepFile */
526     PACKS(desc,"z","lpd");      /* pPrProc */
527     PACKS(desc,"z",SERVICE(snum)); /* pDestinations */
528     PACKS(desc,"z","");         /* pParms */
529     if (snum < 0) {
530       PACKS(desc,"z","UNKNOWN PRINTER");
531       PACKI(desc,"W",LPSTAT_ERROR);
532     }
533     else if (!status || !status->message[0]) {
534       PACKS(desc,"z",Expand(cnum,snum,lp_comment(snum)));
535       PACKI(desc,"W",LPSTAT_OK); /* status */
536     } else {
537       PACKS(desc,"z",status->message);
538       PACKI(desc,"W",status->status); /* status */
539     }
540     PACKI(desc,(uLevel == 1 ? "W" : "N"),count);
541   }
542   if (uLevel == 3 || uLevel == 4) {
543     PACKI(desc,"W",5);          /* uPriority */
544     PACKI(desc,"W",0);          /* uStarttime */
545     PACKI(desc,"W",0);          /* uUntiltime */
546     PACKI(desc,"W",5);          /* pad1 */
547     PACKS(desc,"z","");         /* pszSepFile */
548     PACKS(desc,"z","lpd");      /* pszPrProc */
549     PACKS(desc,"z","");         /* pszParms */
550     if (!status || !status->message[0]) {
551       PACKS(desc,"z",Expand(cnum,snum,lp_comment(snum))); /* pszComment */
552       PACKI(desc,"W",LPSTAT_OK); /* fsStatus */
553     } else {
554       PACKS(desc,"z",status->message); /* pszComment */
555       PACKI(desc,"W",status->status); /* fsStatus */
556     }
557     PACKI(desc,(uLevel == 3 ? "W" : "N"),count);        /* cJobs */
558     PACKS(desc,"z",SERVICE(snum)); /* pszPrinters */
559     PACKS(desc,"z","NULL");     /* pszDriverName */
560     PackDriverData(desc);       /* pDriverData */
561   }
562   if (uLevel == 2 || uLevel == 4) {
563     int i;
564     for (i=0;i<count;i++)
565       fill_printjob_info(cnum,snum,uLevel == 2 ? 1 : 2,desc,&queue[i],i);
566   }
567  
568   DEBUG(3,("fill_printq_info on <%s> gave %d entries\n",SERVICE(snum),count));
569 }
570
571 static BOOL api_DosPrintQGetInfo(int cnum,int uid, char *param,char *data,
572                                  int mdrcnt,int mprcnt,
573                                  char **rdata,char **rparam,
574                                  int *rdata_len,int *rparam_len)
575 {
576   char *str1 = param+2;
577   char *str2 = skip_string(str1,1);
578   char *p = skip_string(str2,1);
579   char *QueueName = p;
580   int uLevel,cbBuf;
581   int count=0;
582   int snum;
583   char* str3;
584   struct pack_desc desc;
585   print_queue_struct *queue=NULL;
586   print_status_struct status;
587   
588   bzero(&status,sizeof(status));
589   bzero(&desc,sizeof(desc));
590  
591   p = skip_string(p,1);
592   uLevel = SVAL(p,0);
593   cbBuf = SVAL(p,2);
594   str3 = p + 4;
595  
596   if ((p = strchr(QueueName,'%'))) *p = 0;
597  
598   DEBUG(3,("PrintQueue uLevel=%d name=%s\n",uLevel,QueueName));
599  
600   /* check it's a supported varient */
601   if (!prefix_ok(str1,"zWrLh")) return False;
602   if (!check_printq_info(&desc,uLevel,str2,str3)) return False;
603  
604   snum = lp_servicenumber(QueueName);
605   if (snum < 0 && pcap_printername_ok(QueueName,NULL)) {
606     int pnum = lp_servicenumber(PRINTERS_NAME);
607     if (pnum >= 0) {
608       lp_add_printer(QueueName,pnum);
609       snum = lp_servicenumber(QueueName);
610     }
611   }
612   
613   if (snum < 0 || !VALID_SNUM(snum)) return(False);
614
615   count = get_printqueue(snum,cnum,&queue,&status);
616   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
617   desc.base = *rdata;
618   desc.buflen = mdrcnt;
619   if (init_package(&desc,1,count)) {
620     desc.subcount = count;
621     fill_printq_info(cnum,snum,uLevel,&desc,count,queue,&status);
622   }
623
624   *rdata_len = desc.usedlen;
625   
626   *rparam_len = 6;
627   *rparam = REALLOC(*rparam,*rparam_len);
628   SSVALS(*rparam,0,desc.errcode);
629   SSVAL(*rparam,2,0);
630   SSVAL(*rparam,4,desc.neededlen);
631   
632   DEBUG(4,("printqgetinfo: errorcode %d\n",desc.errcode));
633
634   if (queue) free(queue);
635   
636   return(True);
637 }
638
639
640 /****************************************************************************
641   view list of all print jobs on all queues
642   ****************************************************************************/
643 static BOOL api_DosPrintQEnum(int cnum, int uid, char* param, char* data,
644                               int mdrcnt, int mprcnt,
645                               char **rdata, char** rparam,
646                               int *rdata_len, int *rparam_len)
647 {
648   char *param_format = param+2;
649   char *output_format1 = skip_string(param_format,1);
650   char *p = skip_string(output_format1,1);
651   int uLevel = SVAL(p,0);
652   char *output_format2 = p + 4;
653   int services = lp_numservices();
654   int i, n;
655   struct pack_desc desc;
656   print_queue_struct **queue = NULL;
657   print_status_struct *status = NULL;
658   int* subcntarr = NULL;
659   int queuecnt, subcnt=0, succnt=0;
660  
661   bzero(&desc,sizeof(desc));
662
663   DEBUG(3,("DosPrintQEnum uLevel=%d\n",uLevel));
664  
665   if (prefix_ok(param_format,"WrLeh")) return False;
666   if (!check_printq_info(&desc,uLevel,output_format1,output_format2))
667     return False;
668   queuecnt = 0;
669   for (i = 0; i < services; i++)
670     if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i))
671       queuecnt++;
672   if (uLevel > 0) {
673     queue = (print_queue_struct**)malloc(queuecnt*sizeof(print_queue_struct*));
674     memset(queue,0,queuecnt*sizeof(print_queue_struct*));
675     status = (print_status_struct*)malloc(queuecnt*sizeof(print_status_struct));
676     memset(status,0,queuecnt*sizeof(print_status_struct));
677     subcntarr = (int*)malloc(queuecnt*sizeof(int));
678     subcnt = 0;
679     n = 0;
680     for (i = 0; i < services; i++)
681       if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
682         subcntarr[n] = get_printqueue(i,cnum,&queue[n],&status[n]);
683         subcnt += subcntarr[n];
684         n++;
685       }
686   }
687   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
688   desc.base = *rdata;
689   desc.buflen = mdrcnt;
690
691   if (init_package(&desc,queuecnt,subcnt)) {
692     n = 0;
693     succnt = 0;
694     for (i = 0; i < services; i++)
695       if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
696         fill_printq_info(cnum,i,uLevel,&desc,subcntarr[n],queue[n],&status[n]);
697         n++;
698         if (desc.errcode == NERR_Success) succnt = n;
699       }
700   }
701
702   if (subcntarr) free(subcntarr);
703  
704   *rdata_len = desc.usedlen;
705   *rparam_len = 8;
706   *rparam = REALLOC(*rparam,*rparam_len);
707   SSVALS(*rparam,0,desc.errcode);
708   SSVAL(*rparam,2,0);
709   SSVAL(*rparam,4,succnt);
710   SSVAL(*rparam,6,queuecnt);
711   
712   for (i = 0; i < queuecnt; i++) {
713     if (queue && queue[i]) free(queue[i]);
714   }
715
716   if (queue) free(queue);
717   if (status) free(status);
718   
719   return True;
720 }
721
722 /****************************************************************************
723   get info level for a server list query
724   ****************************************************************************/
725 static BOOL check_server_info(int uLevel, char* id)
726 {
727   switch( uLevel ) {
728   case 0:
729     if (strcmp(id,"B16") != 0) return False;
730     break;
731   case 1:
732     if (strcmp(id,"B16BBDz") != 0) return False;
733     break;
734   default: 
735     return False;
736   }
737   return True;
738 }
739
740 /* used for server information: client, nameserv and ipc */
741 struct srv_info_struct
742 {
743   fstring name;
744   uint32 type;
745   fstring comment;
746   fstring domain; /* used ONLY in ipc.c NOT namework.c */
747   BOOL server_added; /* used ONLY in ipc.c NOT namework.c */
748 };
749
750 /*******************************************************************
751   filter out unwanted server info 
752   ******************************************************************/
753 static BOOL filter_server_info(struct srv_info_struct *server, 
754                                char *domain)
755 {
756   if (*domain)
757     return(strequal(domain, server->domain));
758   
759   return (True); /* be indiscriminate: get all servers! */
760 }
761
762 /*******************************************************************
763   find server in the files saved by nmbd. Return True if we find it.
764   ******************************************************************/
765 static BOOL find_server(struct srv_info_struct *servers, int num_servers,
766                  char *domain, char *name)
767 {
768   int count;
769
770   if (!servers || num_servers == 0) return (False);
771
772   for (count = 0; count < num_servers; count++) {
773     struct srv_info_struct *s;
774
775     s = &servers[count];
776
777     if (strequal(name, s->name)) {
778       StrnCpy(domain, s->domain, sizeof(pstring)-1);
779       return (True);
780     }
781   }
782   return (False);
783 }
784
785
786 /*******************************************************************
787   get server info lists from the files saved by nmbd. Return the
788   number of entries
789   ******************************************************************/
790 static int get_server_info(uint32 servertype, 
791                            struct srv_info_struct **servers)
792 {
793   FILE *f;
794   pstring fname;
795   int count=0;
796   int alloced=0;
797   pstring line;
798
799   strcpy(fname,lp_lockdir());
800   trim_string(fname,NULL,"/");
801   strcat(fname,"/");
802   strcat(fname,SERVER_LIST);
803
804   f = fopen(fname,"r");
805
806   if (!f) {
807     DEBUG(4,("Can't open %s - %s\n",fname,strerror(errno)));
808     return(0);
809   }
810   if (servertype == SV_TYPE_ALL) servertype &= ~SV_TYPE_DOMAIN_ENUM;
811
812   while (!feof(f))
813   {
814     fstring stype;
815     struct srv_info_struct *s;
816     char *ptr = line;
817     *ptr = 0;
818
819     fgets(line,sizeof(line)-1,f);
820     if (!*line) continue;
821
822     if (count == alloced) {
823       alloced += 10;
824       (*servers) = (struct srv_info_struct *)
825         Realloc(*servers,sizeof(**servers)*alloced);
826       if (!(*servers)) return(0);
827       bzero((char *)((*servers)+count),sizeof(**servers)*(alloced-count));
828     }
829     s = &(*servers)[count];
830
831     s->server_added = True;
832
833     if (!next_token(&ptr,s->name   , NULL)) continue;
834     if (!next_token(&ptr,stype     , NULL)) continue;
835     if (!next_token(&ptr,s->comment, NULL)) continue;
836     if (!next_token(&ptr,s->domain , NULL)) {
837       /* this allows us to cop with an old nmbd */
838       strcpy(s->domain,my_workgroup()); 
839     }
840
841     if (sscanf(stype,"%X",&s->type) != 1) continue;
842
843     /* doesn't match up: don't want it */
844     if (!(servertype & s->type)) continue;
845
846     /* server entry is a domain, we haven't asked for domains: don't want it */
847     if ((s->type&SV_TYPE_DOMAIN_ENUM) && !(servertype&SV_TYPE_DOMAIN_ENUM))
848       continue;
849
850     DEBUG(4,("Server %20s %8x %25s %15s\n",
851              s->name, stype, s->comment, s->domain));
852
853     count++;
854   }
855
856   fclose(f);
857   return(count);
858 }
859
860 /*******************************************************************
861   fill in a server info structure
862   ******************************************************************/
863 static int fill_srv_info(struct srv_info_struct *service, 
864                          int uLevel, char **buf, int *buflen, 
865                          char **stringbuf, int *stringspace, char *baseaddr)
866 {
867   int struct_len;
868   char* p;
869   char* p2;
870   int l2;
871   int len;
872  
873   switch (uLevel) {
874   case 0: struct_len = 16; break;
875   case 1: struct_len = 26; break;
876   default: return -1;
877   }  
878  
879   if (!buf)
880     {
881       len = 0;
882       switch (uLevel) 
883         {
884         case 1:
885           len = strlen(service->comment)+1;
886           break;
887         }
888
889       if (buflen) *buflen = struct_len;
890       if (stringspace) *stringspace = len;
891       return struct_len + len;
892     }
893   
894   len = struct_len;
895   p = *buf;
896   if (*buflen < struct_len) return -1;
897   if (stringbuf)
898     {
899       p2 = *stringbuf;
900       l2 = *stringspace;
901     }
902   else
903     {
904       p2 = p + struct_len;
905       l2 = *buflen - struct_len;
906     }
907   if (!baseaddr) baseaddr = p;
908   
909   switch (uLevel)
910     {
911     case 0:
912       StrnCpy(p,service->name,15);
913       break;
914
915     case 1:
916       StrnCpy(p,service->name,15);
917       SIVAL(p,18,service->type);
918       SIVAL(p,22,PTR_DIFF(p2,baseaddr));
919       len += CopyAndAdvance(&p2,service->comment,&l2);
920       break;
921     }
922
923   if (stringbuf)
924     {
925       *buf = p + struct_len;
926       *buflen -= struct_len;
927       *stringbuf = p2;
928       *stringspace = l2;
929     }
930   else
931     {
932       *buf = p2;
933       *buflen -= len;
934     }
935   return len;
936 }
937
938
939 /****************************************************************************
940   view list of servers available (or possibly domains). The info is
941   extracted from lists saved by nmbd on the local host
942   ****************************************************************************/
943 static BOOL api_RNetServerEnum(int cnum, int uid, char *param, char *data,
944                                int mdrcnt, int mprcnt, char **rdata, 
945                                char **rparam, int *rdata_len, int *rparam_len)
946 {
947   char *str1 = param+2;
948   char *str2 = skip_string(str1,1);
949   char *p = skip_string(str2,1);
950   int uLevel = SVAL(p,0);
951   int buf_len = SVAL(p,2);
952   uint32 servertype = IVAL(p,4);
953   char *p2;
954   int data_len, fixed_len, string_len;
955   int f_len, s_len;
956   struct srv_info_struct *servers=NULL;
957   int counted=0,total=0;
958   int i;
959   fstring domain;
960   BOOL domain_request = (servertype & SV_TYPE_DOMAIN_ENUM) &&
961                        !(servertype == SV_TYPE_ALL);
962
963   domain[0] = 0;
964   p += 8;
965
966   if (!prefix_ok(str1,"WrLehD")) return False;
967   if (!check_server_info(uLevel,str2)) return False;
968   
969   DEBUG(4, ("server request level: %s\n", str2));
970
971   if (strcmp(str1, "WrLehDO") == 0)
972   {
973     /* asking for servers. we will have to work out which workgroup was
974        requested, as we maintain lists for multiple workgroups */
975   }
976   else if (strcmp(str1, "WrLehDz") == 0)
977   {
978     /* asking for a specific workgroup */
979     StrnCpy(domain, p, sizeof(fstring)-1);
980   }
981
982   if (lp_browse_list())
983   {
984     total = get_server_info(servertype,&servers);
985   }
986
987   if (!domain[0] && !domain_request) {
988     extern fstring remote_machine;
989     /* must be a server request with an assumed domain. find a domain */
990     
991     if (find_server(servers, total, domain, remote_machine)) {
992       DEBUG(4, ("No domain specified: using %s for %s\n",
993                 domain, remote_machine));
994     } else {
995       /* default to soemthing sensible */
996       strcpy(domain,my_workgroup());
997     }
998   }
999
1000   data_len = fixed_len = string_len = 0;
1001
1002   for (i=0;i<total;i++)
1003     if (filter_server_info(&servers[i],domain)) {
1004       data_len += fill_srv_info(&servers[i],uLevel,0,&f_len,0,&s_len,0);
1005       if (data_len <= buf_len)
1006         {
1007           counted++;
1008           fixed_len += f_len;
1009           string_len += s_len;
1010         }
1011     }
1012
1013   *rdata_len = fixed_len + string_len;
1014   *rdata = REALLOC(*rdata,*rdata_len);
1015   bzero(*rdata,*rdata_len);
1016   
1017   p2 = (*rdata) + fixed_len;    /* auxilliary data (strings) will go here */
1018   p = *rdata;
1019   f_len = fixed_len;
1020   s_len = string_len;
1021
1022   {
1023     int count2 = counted;
1024     for (i = 0; i < total && count2;i++) {
1025       if (filter_server_info(&servers[i],domain)) {
1026         fill_srv_info(&servers[i],uLevel,&p,&f_len,&p2,&s_len,*rdata);
1027         count2--;
1028       }
1029     }
1030   }
1031   
1032   *rparam_len = 8;
1033   *rparam = REALLOC(*rparam,*rparam_len);
1034   SSVAL(*rparam,0,NERR_Success);
1035   SSVAL(*rparam,2,0);
1036   SSVAL(*rparam,4,counted);
1037   SSVAL(*rparam,6,total);
1038
1039   if (servers) free(servers);
1040
1041   DEBUG(3,("NetServerEnum domain = %s uLevel=%d counted=%d total=%d\n",
1042            domain,uLevel,counted,total));
1043
1044   return(True);
1045 }
1046
1047
1048 /****************************************************************************
1049   get info about a share
1050   ****************************************************************************/
1051 static BOOL check_share_info(int uLevel, char* id)
1052 {
1053   switch( uLevel ) {
1054   case 0:
1055     if (strcmp(id,"B13") != 0) return False;
1056     break;
1057   case 1:
1058     if (strcmp(id,"B13BWz") != 0) return False;
1059     break;
1060   case 2:
1061     if (strcmp(id,"B13BWzWWWzB9B") != 0) return False;
1062     break;
1063   case 91:
1064     if (strcmp(id,"B13BWzWWWzB9BB9BWzWWzWW") != 0) return False;
1065     break;
1066   default: return False;
1067   }
1068   return True;
1069 }
1070
1071 static int fill_share_info(int cnum, int snum, int uLevel,
1072                            char** buf, int* buflen,
1073                            char** stringbuf, int* stringspace, char* baseaddr)
1074 {
1075   int struct_len;
1076   char* p;
1077   char* p2;
1078   int l2;
1079   int len;
1080  
1081   switch( uLevel ) {
1082   case 0: struct_len = 13; break;
1083   case 1: struct_len = 20; break;
1084   case 2: struct_len = 40; break;
1085   case 91: struct_len = 68; break;
1086   default: return -1;
1087   }
1088   
1089  
1090   if (!buf)
1091     {
1092       len = 0;
1093       if (uLevel > 0) len += StrlenExpanded(cnum,snum,lp_comment(snum));
1094       if (uLevel > 1) len += strlen(lp_pathname(snum)) + 1;
1095       if (buflen) *buflen = struct_len;
1096       if (stringspace) *stringspace = len;
1097       return struct_len + len;
1098     }
1099   
1100   len = struct_len;
1101   p = *buf;
1102   if ((*buflen) < struct_len) return -1;
1103   if (stringbuf)
1104     {
1105       p2 = *stringbuf;
1106       l2 = *stringspace;
1107     }
1108   else
1109     {
1110       p2 = p + struct_len;
1111       l2 = (*buflen) - struct_len;
1112     }
1113   if (!baseaddr) baseaddr = p;
1114   
1115   StrnCpy(p,lp_servicename(snum),13);
1116   
1117   if (uLevel > 0)
1118     {
1119       int type;
1120       CVAL(p,13) = 0;
1121       type = STYPE_DISKTREE;
1122       if (lp_print_ok(snum)) type = STYPE_PRINTQ;
1123       if (strequal("IPC$",lp_servicename(snum))) type = STYPE_IPC;
1124       SSVAL(p,14,type);         /* device type */
1125       SIVAL(p,16,PTR_DIFF(p2,baseaddr));
1126       len += CopyExpanded(cnum,snum,&p2,lp_comment(snum),&l2);
1127     }
1128   
1129   if (uLevel > 1)
1130     {
1131       SSVAL(p,20,ACCESS_READ|ACCESS_WRITE|ACCESS_CREATE); /* permissions */
1132       SSVALS(p,22,-1);          /* max uses */
1133       SSVAL(p,24,1); /* current uses */
1134       SIVAL(p,26,PTR_DIFF(p2,baseaddr)); /* local pathname */
1135       len += CopyAndAdvance(&p2,lp_pathname(snum),&l2);
1136       memset(p+30,0,SHPWLEN+2); /* passwd (reserved), pad field */
1137     }
1138   
1139   if (uLevel > 2)
1140     {
1141       memset(p+40,0,SHPWLEN+2);
1142       SSVAL(p,50,0);
1143       SIVAL(p,52,0);
1144       SSVAL(p,56,0);
1145       SSVAL(p,58,0);
1146       SIVAL(p,60,0);
1147       SSVAL(p,64,0);
1148       SSVAL(p,66,0);
1149     }
1150        
1151   if (stringbuf)
1152     {
1153       (*buf) = p + struct_len;
1154       (*buflen) -= struct_len;
1155       (*stringbuf) = p2;
1156       (*stringspace) = l2;
1157     }
1158   else
1159     {
1160       (*buf) = p2;
1161       (*buflen) -= len;
1162     }
1163   return len;
1164 }
1165
1166 static BOOL api_RNetShareGetInfo(int cnum,int uid, char *param,char *data,
1167                                  int mdrcnt,int mprcnt,
1168                                  char **rdata,char **rparam,
1169                                  int *rdata_len,int *rparam_len)
1170 {
1171   char *str1 = param+2;
1172   char *str2 = skip_string(str1,1);
1173   char *netname = skip_string(str2,1);
1174   char *p = skip_string(netname,1);
1175   int uLevel = SVAL(p,0);
1176   int snum = find_service(netname);
1177   
1178   if (snum < 0) return False;
1179   
1180   /* check it's a supported varient */
1181   if (!prefix_ok(str1,"zWrLh")) return False;
1182   if (!check_share_info(uLevel,str2)) return False;
1183  
1184   *rdata = REALLOC(*rdata,mdrcnt);
1185   p = *rdata;
1186   *rdata_len = fill_share_info(cnum,snum,uLevel,&p,&mdrcnt,0,0,0);
1187   if (*rdata_len < 0) return False;
1188  
1189   *rparam_len = 6;
1190   *rparam = REALLOC(*rparam,*rparam_len);
1191   SSVAL(*rparam,0,NERR_Success);
1192   SSVAL(*rparam,2,0);           /* converter word */
1193   SSVAL(*rparam,4,*rdata_len);
1194  
1195   return(True);
1196 }
1197
1198 /****************************************************************************
1199   view list of shares available
1200   ****************************************************************************/
1201 static BOOL api_RNetShareEnum(int cnum,int uid, char *param,char *data,
1202                               int mdrcnt,int mprcnt,
1203                               char **rdata,char **rparam,
1204                               int *rdata_len,int *rparam_len)
1205 {
1206   char *str1 = param+2;
1207   char *str2 = skip_string(str1,1);
1208   char *p = skip_string(str2,1);
1209   int uLevel = SVAL(p,0);
1210   int buf_len = SVAL(p,2);
1211   char *p2;
1212   int count=lp_numservices();
1213   int total=0,counted=0;
1214   int i;
1215   int data_len, fixed_len, string_len;
1216   int f_len, s_len;
1217  
1218   if (!prefix_ok(str1,"WrLeh")) return False;
1219   if (!check_share_info(uLevel,str2)) return False;
1220   
1221   data_len = fixed_len = string_len = 0;
1222   for (i=0;i<count;i++)
1223     if (lp_browseable(i) && lp_snum_ok(i))
1224       {
1225         total++;
1226         data_len += fill_share_info(cnum,i,uLevel,0,&f_len,0,&s_len,0);
1227         if (data_len <= buf_len)
1228           {
1229             counted++;
1230             fixed_len += f_len;
1231             string_len += s_len;
1232           }
1233       }
1234   *rdata_len = fixed_len + string_len;
1235   *rdata = REALLOC(*rdata,*rdata_len);
1236   memset(*rdata,0,*rdata_len);
1237   
1238   p2 = (*rdata) + fixed_len;    /* auxillery data (strings) will go here */
1239   p = *rdata;
1240   f_len = fixed_len;
1241   s_len = string_len;
1242   for (i = 0; i < count;i++)
1243     if (lp_browseable(i) && lp_snum_ok(i))
1244       if (fill_share_info(cnum,i,uLevel,&p,&f_len,&p2,&s_len,*rdata) < 0)
1245         break;
1246   
1247   *rparam_len = 8;
1248   *rparam = REALLOC(*rparam,*rparam_len);
1249   SSVAL(*rparam,0,NERR_Success);
1250   SSVAL(*rparam,2,0);
1251   SSVAL(*rparam,4,counted);
1252   SSVAL(*rparam,6,total);
1253   
1254   DEBUG(3,("RNetShareEnum gave %d entries of %d (%d %d %d %d)\n",
1255            counted,total,uLevel,
1256            buf_len,*rdata_len,mdrcnt));
1257   return(True);
1258 }
1259
1260
1261
1262 /****************************************************************************
1263   get the time of day info
1264   ****************************************************************************/
1265 static BOOL api_NetRemoteTOD(int cnum,int uid, char *param,char *data,
1266                              int mdrcnt,int mprcnt,
1267                              char **rdata,char **rparam,
1268                              int *rdata_len,int *rparam_len)
1269 {
1270   char *p;
1271   *rparam_len = 4;
1272   *rparam = REALLOC(*rparam,*rparam_len);
1273
1274   *rdata_len = 21;
1275   *rdata = REALLOC(*rdata,*rdata_len);
1276
1277   SSVAL(*rparam,0,NERR_Success);
1278   SSVAL(*rparam,2,0);           /* converter word */
1279
1280   p = *rdata;
1281
1282   {
1283     struct tm *t;
1284     time_t unixdate = time(NULL);
1285
1286     put_dos_date3(p,0,unixdate); /* this is the time that is looked at
1287                                     by NT in a "net time" operation,
1288                                     it seems to ignore the one below */
1289
1290     /* the client expects to get localtime, not GMT, in this bit 
1291        (I think, this needs testing) */
1292     t = LocalTime(&unixdate,GMT_TO_LOCAL);
1293
1294     SIVAL(p,4,0);               /* msecs ? */
1295     CVAL(p,8) = t->tm_hour;
1296     CVAL(p,9) = t->tm_min;
1297     CVAL(p,10) = t->tm_sec;
1298     CVAL(p,11) = 0;             /* hundredths of seconds */
1299     SSVALS(p,12,TimeDiff(unixdate)/60); /* timezone in minutes from GMT */
1300     SSVAL(p,14,10000);          /* timer interval in 0.0001 of sec */
1301     CVAL(p,16) = t->tm_mday;
1302     CVAL(p,17) = t->tm_mon + 1;
1303     SSVAL(p,18,1900+t->tm_year);
1304     CVAL(p,20) = t->tm_wday;
1305   }
1306
1307
1308   return(True);
1309 }
1310
1311 /****************************************************************************
1312   set the user password
1313   ****************************************************************************/
1314 static BOOL api_SetUserPassword(int cnum,int uid, char *param,char *data,
1315                                 int mdrcnt,int mprcnt,
1316                                 char **rdata,char **rparam,
1317                                 int *rdata_len,int *rparam_len)
1318 {
1319   char *p = skip_string(param+2,2);
1320   fstring user;
1321   fstring pass1,pass2;
1322
1323   strcpy(user,p);
1324
1325   p = skip_string(p,1);
1326
1327   StrnCpy(pass1,p,16);
1328   StrnCpy(pass2,p+16,16);
1329
1330   *rparam_len = 4;
1331   *rparam = REALLOC(*rparam,*rparam_len);
1332
1333   *rdata_len = 0;
1334
1335   SSVAL(*rparam,0,NERR_Success);
1336   SSVAL(*rparam,2,0);           /* converter word */
1337
1338   DEBUG(3,("Set password for <%s>\n",user));
1339
1340   if (!password_ok(user,pass1,strlen(pass1),NULL,False) || 
1341       !chgpasswd(user,pass1,pass2))
1342     SSVAL(*rparam,0,NERR_badpass);
1343
1344   bzero(pass1,sizeof(fstring));
1345   bzero(pass2,sizeof(fstring));  
1346          
1347   return(True);
1348 }
1349
1350 /****************************************************************************
1351   delete a print job
1352   Form: <W> <> 
1353   ****************************************************************************/
1354 static BOOL api_RDosPrintJobDel(int cnum,int uid, char *param,char *data,
1355                                 int mdrcnt,int mprcnt,
1356                                 char **rdata,char **rparam,
1357                                 int *rdata_len,int *rparam_len)
1358 {
1359   int function = SVAL(param,0);
1360   char *str1 = param+2;
1361   char *str2 = skip_string(str1,1);
1362   char *p = skip_string(str2,1);
1363   int jobid = (SVAL(p,0)&0xFF); /* the snum and jobid are encoded
1364                                    by the print queue api */
1365   int snum = (SVAL(p,0)>>8);  
1366   int i, count;
1367
1368
1369   /* check it's a supported varient */
1370   if (!(strcsequal(str1,"W") && strcsequal(str2,"")))
1371     return(False);
1372
1373   *rparam_len = 4;
1374   *rparam = REALLOC(*rparam,*rparam_len);
1375
1376   *rdata_len = 0;
1377
1378   SSVAL(*rparam,0,NERR_Success);
1379
1380   if (snum >= 0 && VALID_SNUM(snum))
1381     {
1382       print_queue_struct *queue=NULL;
1383       lpq_reset(snum);
1384       count = get_printqueue(snum,cnum,&queue,NULL);
1385   
1386       for (i=0;i<count;i++)
1387         if ((queue[i].job%0xFF) == jobid)
1388           {
1389             switch (function) {
1390             case 81:            /* delete */ 
1391               DEBUG(3,("Deleting queue entry %d\n",queue[i].job));
1392               del_printqueue(cnum,snum,queue[i].job);
1393               break;
1394             case 82:            /* pause */
1395             case 83:            /* resume */
1396               DEBUG(3,("%s queue entry %d\n",
1397                        (function==82?"pausing":"resuming"),queue[i].job));
1398               status_printjob(cnum,snum,queue[i].job,
1399                               (function==82?LPQ_PAUSED:LPQ_QUEUED));
1400               break;
1401             }
1402             break;
1403           }
1404   
1405       if (i==count)
1406         SSVAL(*rparam,0,NERR_JobNotFound);
1407
1408       if (queue) free(queue);
1409     }
1410
1411   SSVAL(*rparam,2,0);           /* converter word */
1412
1413   return(True);
1414 }
1415
1416 static BOOL api_WPrintQueuePurge(int cnum,int uid, char *param,char *data,
1417                                  int mdrcnt,int mprcnt,
1418                                  char **rdata,char **rparam,
1419                                  int *rdata_len,int *rparam_len)
1420 {
1421   char *str1 = param+2;
1422   char *str2 = skip_string(str1,1);
1423   char *QueueName = skip_string(str2,1);
1424   int snum;
1425
1426   /* check it's a supported varient */
1427   if (!(strcsequal(str1,"z") && strcsequal(str2,"")))
1428     return(False);
1429
1430   *rparam_len = 4;
1431   *rparam = REALLOC(*rparam,*rparam_len);
1432
1433   *rdata_len = 0;
1434
1435   SSVAL(*rparam,0,NERR_Success);
1436   SSVAL(*rparam,2,0);           /* converter word */
1437
1438   snum = lp_servicenumber(QueueName);
1439   if (snum < 0 && pcap_printername_ok(QueueName,NULL)) {
1440     int pnum = lp_servicenumber(PRINTERS_NAME);
1441     if (pnum >= 0) {
1442       lp_add_printer(QueueName,pnum);
1443       snum = lp_servicenumber(QueueName);
1444     }
1445   }
1446
1447   if (snum >= 0 && VALID_SNUM(snum)) {
1448     print_queue_struct *queue=NULL;
1449     int i, count;
1450     lpq_reset(snum);
1451     
1452     count = get_printqueue(snum,cnum,&queue,NULL);
1453     for (i = 0; i < count; i++)
1454       del_printqueue(cnum,snum,queue[i].job);
1455     
1456     if (queue) free(queue);
1457   }
1458
1459   DEBUG(3,("Print queue purge, queue=%s\n",QueueName));
1460
1461   return(True);
1462 }
1463
1464
1465 /****************************************************************************
1466   set the property of a print job (undocumented?)
1467   ? function = 0xb -> set name of print job
1468   ? function = 0x6 -> move print job up/down
1469   Form: <WWsTP> <WWzWWDDzzzzzzzzzzlz> 
1470   or   <WWsTP> <WB21BB16B10zWWzDDz> 
1471 ****************************************************************************/
1472 static int check_printjob_info(struct pack_desc* desc,
1473                                int uLevel, char* id)
1474 {
1475   desc->subformat = NULL;
1476   switch( uLevel ) {
1477   case 0: desc->format = "W"; break;
1478   case 1: desc->format = "WB21BB16B10zWWzDDz"; break;
1479   case 2: desc->format = "WWzWWDDzz"; break;
1480   case 3: desc->format = "WWzWWDDzzzzzzzzzzlz"; break;
1481   default: return False;
1482   }
1483   if (strcmp(desc->format,id) != 0) return False;
1484   return True;
1485 }
1486
1487 static BOOL api_PrintJobInfo(int cnum,int uid,char *param,char *data,
1488                              int mdrcnt,int mprcnt,
1489                              char **rdata,char **rparam,
1490                              int *rdata_len,int *rparam_len)
1491 {
1492   struct pack_desc desc;
1493   char *str1 = param+2;
1494   char *str2 = skip_string(str1,1);
1495   char *p = skip_string(str2,1);
1496   int jobid = (SVAL(p,0)&0xFF); /* the snum and jobid are encoded
1497                                    by the print queue api */
1498   int snum = (SVAL(p,0)>>8);
1499   int uLevel = SVAL(p,2);
1500   int function = SVAL(p,4);     /* what is this ?? */
1501   int i;
1502   char *s = data;
1503    
1504   *rparam_len = 4;
1505   *rparam = REALLOC(*rparam,*rparam_len);
1506   
1507   *rdata_len = 0;
1508   
1509   /* check it's a supported varient */
1510   if ((strcmp(str1,"WWsTP")) || (!check_printjob_info(&desc,uLevel,str2)))
1511     return(False);
1512    
1513   switch (function) {
1514   case 0x6:     /* change job place in the queue, data gives the new place */
1515     if (snum >= 0 && VALID_SNUM(snum))
1516       {
1517         print_queue_struct *queue=NULL;
1518         int count;
1519   
1520         lpq_reset(snum);
1521         count = get_printqueue(snum,cnum,&queue,NULL);
1522         for (i=0;i<count;i++)   /* find job */
1523           if ((queue[i].job%0xFF) == jobid) break;
1524             
1525         if (i==count) {
1526           desc.errcode=NERR_JobNotFound;
1527           if (queue) free(queue);
1528         }
1529         else {
1530           desc.errcode=NERR_Success;
1531           i++;
1532 #if 0   
1533           {
1534             int place= SVAL(data,0);
1535             /* we currently have no way of doing this. Can any unix do it? */
1536             if (i < place)      /* move down */;
1537             else if (i > place )        /* move up */;
1538           }
1539 #endif
1540           desc.errcode=NERR_notsupported; /* not yet supported */
1541           if (queue) free(queue);
1542         }
1543       }
1544     else desc.errcode=NERR_JobNotFound;
1545     break;
1546   case 0xb:   /* change print job name, data gives the name */
1547     /* jobid, snum should be zero */
1548     if (isalpha(*s))
1549       {
1550         pstring name;
1551         int l = 0;
1552         while (l<64 && *s)
1553           {
1554             if (isalnum(*s) || strchr("-._",*s))
1555               name[l++] = *s;
1556             s++;
1557           }      
1558         name[l] = 0;
1559         
1560         DEBUG(3,("Setting print name to %s\n",name));
1561         
1562         for (i=0;i<MAX_OPEN_FILES;i++)
1563           if (Files[i].open && Files[i].print_file)
1564             {
1565               pstring wd;
1566               GetWd(wd);
1567               unbecome_user();
1568               
1569               if (!become_user(Files[i].cnum,uid) || 
1570                   !become_service(Files[i].cnum,True))
1571                 break;
1572               
1573               if (sys_rename(Files[i].name,name) == 0)
1574                 string_set(&Files[i].name,name);
1575               break;
1576             }
1577       }
1578     desc.errcode=NERR_Success;
1579   
1580     break;
1581   default:                      /* not implemented */
1582     return False;
1583   }
1584  
1585   SSVALS(*rparam,0,desc.errcode);
1586   SSVAL(*rparam,2,0);           /* converter word */
1587   
1588   return(True);
1589 }
1590
1591
1592 /****************************************************************************
1593   get info about the server
1594   ****************************************************************************/
1595 static BOOL api_RNetServerGetInfo(int cnum,int uid, char *param,char *data,
1596                                   int mdrcnt,int mprcnt,
1597                                   char **rdata,char **rparam,
1598                                   int *rdata_len,int *rparam_len)
1599 {
1600   char *str1 = param+2;
1601   char *str2 = skip_string(str1,1);
1602   char *p = skip_string(str2,1);
1603   int uLevel = SVAL(p,0);
1604   char *p2;
1605   int struct_len;
1606
1607   DEBUG(4,("NetServerGetInfo level %d\n",uLevel));
1608
1609   /* check it's a supported varient */
1610   if (!prefix_ok(str1,"WrLh")) return False;
1611   switch( uLevel ) {
1612   case 0:
1613     if (strcmp(str2,"B16") != 0) return False;
1614     struct_len = 16;
1615     break;
1616   case 1:
1617     if (strcmp(str2,"B16BBDz") != 0) return False;
1618     struct_len = 26;
1619     break;
1620   case 2:
1621     if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWz")
1622         != 0) return False;
1623     struct_len = 134;
1624     break;
1625   case 3:
1626     if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWzDWz")
1627         != 0) return False;
1628     struct_len = 144;
1629     break;
1630   case 20:
1631     if (strcmp(str2,"DN") != 0) return False;
1632     struct_len = 6;
1633     break;
1634   case 50:
1635     if (strcmp(str2,"B16BBDzWWzzz") != 0) return False;
1636     struct_len = 42;
1637     break;
1638   default: return False;
1639   }
1640
1641   *rdata_len = mdrcnt;
1642   *rdata = REALLOC(*rdata,*rdata_len);
1643
1644   p = *rdata;
1645   p2 = p + struct_len;
1646   if (uLevel != 20) {
1647     StrnCpy(p,local_machine,16);
1648     strupper(p);
1649   }
1650   p += 16;
1651   if (uLevel > 0)
1652     {
1653       struct srv_info_struct *servers=NULL;
1654       int i,count;
1655       pstring comment;
1656       uint32 servertype=SV_TYPE_SERVER_UNIX|SV_TYPE_WORKSTATION|
1657         SV_TYPE_SERVER|SV_TYPE_TIME_SOURCE;
1658
1659       strcpy(comment,lp_serverstring());
1660
1661       if ((count=get_server_info(SV_TYPE_ALL,&servers))>0) {
1662         for (i=0;i<count;i++)
1663           if (strequal(servers[i].name,local_machine)) {
1664             servertype = servers[i].type;
1665             strcpy(comment,servers[i].comment);     
1666           }
1667       }
1668       if (servers) free(servers);
1669
1670       SCVAL(p,0,2);             /* version_major */
1671       SCVAL(p,1,0);             /* version_minor */
1672       SIVAL(p,2,servertype);
1673       if (mdrcnt == struct_len) {
1674         SIVAL(p,6,0);
1675       } else {
1676         SIVAL(p,6,PTR_DIFF(p2,*rdata));
1677         standard_sub(cnum,comment);
1678         StrnCpy(p2,comment,MAX(mdrcnt - struct_len,0));
1679         p2 = skip_string(p2,1);
1680       }
1681     }
1682   if (uLevel > 1)
1683     {
1684       return False;             /* not yet implemented */
1685     }
1686
1687   *rdata_len = PTR_DIFF(p2,*rdata);
1688
1689   *rparam_len = 6;
1690   *rparam = REALLOC(*rparam,*rparam_len);
1691   SSVAL(*rparam,0,NERR_Success);
1692   SSVAL(*rparam,2,0);           /* converter word */
1693   SSVAL(*rparam,4,*rdata_len);
1694
1695   return(True);
1696 }
1697
1698
1699 /****************************************************************************
1700   get info about the server
1701   ****************************************************************************/
1702 static BOOL api_NetWkstaGetInfo(int cnum,int uid, char *param,char *data,
1703                                 int mdrcnt,int mprcnt,
1704                                 char **rdata,char **rparam,
1705                                 int *rdata_len,int *rparam_len)
1706 {
1707   char *str1 = param+2;
1708   char *str2 = skip_string(str1,1);
1709   char *p = skip_string(str2,1);
1710   char *p2;
1711   extern pstring sesssetup_user;
1712   int level = SVAL(p,0);
1713
1714   DEBUG(4,("NetWkstaGetInfo level %d\n",level));
1715
1716   *rparam_len = 6;
1717   *rparam = REALLOC(*rparam,*rparam_len);
1718
1719   /* check it's a supported varient */
1720   if (!(level==10 && strcsequal(str1,"WrLh") && strcsequal(str2,"zzzBBzz")))
1721     return(False);
1722
1723   *rdata_len = mdrcnt + 1024;
1724   *rdata = REALLOC(*rdata,*rdata_len);
1725
1726   SSVAL(*rparam,0,NERR_Success);
1727   SSVAL(*rparam,2,0);           /* converter word */
1728
1729   p = *rdata;
1730   p2 = p + 22;
1731
1732   SIVAL(p,0,PTR_DIFF(p2,*rdata));
1733   strcpy(p2,local_machine);
1734   p2 = skip_string(p2,1);
1735   p += 4;
1736
1737   SIVAL(p,0,PTR_DIFF(p2,*rdata));
1738   strcpy(p2,sesssetup_user);
1739   p2 = skip_string(p2,1);
1740   p += 4;
1741
1742   SIVAL(p,0,PTR_DIFF(p2,*rdata));
1743   strcpy(p2,my_workgroup());
1744   p2 = skip_string(p2,1);
1745   p += 4;
1746
1747   SCVAL(p,0,2); /* major version?? */
1748   SCVAL(p,1,1); /* minor version?? */
1749   p += 2;
1750
1751   SIVAL(p,0,PTR_DIFF(p2,*rdata));
1752   strcpy(p2,my_workgroup());    /* login domain?? */
1753   p2 = skip_string(p2,1);
1754   p += 4;
1755
1756   SIVAL(p,0,PTR_DIFF(p2,*rdata));
1757   strcpy(p2,"");
1758   p2 = skip_string(p2,1);
1759   p += 4;
1760
1761   *rdata_len = PTR_DIFF(p2,*rdata);
1762
1763   SSVAL(*rparam,4,*rdata_len);
1764
1765   return(True);
1766 }
1767
1768
1769 /****************************************************************************
1770   get info about a user
1771   ****************************************************************************/
1772
1773 #define USER_PRIV_GUEST 0
1774 #define USER_PRIV_USER 1
1775 #define USER_PRIV_ADMIN 2
1776
1777 static BOOL api_RNetUserGetInfo(int cnum,int uid, char *param,char *data,
1778                                 int mdrcnt,int mprcnt,
1779                                 char **rdata,char **rparam,
1780                                 int *rdata_len,int *rparam_len)
1781 {
1782   char *str1 = param+2;
1783   char *str2 = skip_string(str1,1);
1784   char *UserName = skip_string(str2,1);
1785   char *p = skip_string(UserName,1);
1786   int uLevel = SVAL(p,0);
1787   char *p2;
1788
1789   *rparam_len = 6;
1790   *rparam = REALLOC(*rparam,*rparam_len);
1791
1792   /* check it's a supported varient */
1793   if (strcmp(str1,"zWrLh") != 0) return False;
1794   switch( uLevel ) {
1795   case 0: p2 = "B21"; break;
1796   case 1: p2 = "B21BB16DWzzWz"; break;
1797   case 2: p2 = "B21BB16DWzzWzDzzzzDDDDWb21WWzWW"; break;
1798   case 10: p2 = "B21Bzzz"; break;
1799   case 11: p2 = "B21BzzzWDDzzDDWWzWzDWb21W"; break;
1800   default: return False;
1801   }
1802   if (strcmp(p2,str2) != 0) return False;
1803
1804   *rdata_len = mdrcnt + 1024;
1805   *rdata = REALLOC(*rdata,*rdata_len);
1806
1807   SSVAL(*rparam,0,NERR_Success);
1808   SSVAL(*rparam,2,0);           /* converter word */
1809
1810   p = *rdata;
1811   p2 = p + 86;
1812
1813   memset(p,0,21);
1814   strcpy(p,UserName);
1815   if (uLevel > 0) {
1816     SCVAL(p,21,0);
1817     *p2 = 0;
1818     if (uLevel >= 10) {
1819       SIVAL(p,22,PTR_DIFF(p2,p)); /* comment */
1820       strcpy(p2,"<Comment>");
1821       p2 = skip_string(p2,1);
1822       SIVAL(p,26,PTR_DIFF(p2,p)); /* user_comment */
1823       strcpy(p2,"<UserComment>");
1824       p2 = skip_string(p2,1);
1825       SIVAL(p,30,PTR_DIFF(p2,p)); /* full name */
1826       strcpy(p2,"<FullName>");
1827       p2 = skip_string(p2,1);
1828     }
1829     if (uLevel == 11) {         /* modelled after NTAS 3.51 reply */
1830       SSVAL(p,34,USER_PRIV_USER); /* user privilege */
1831       SIVAL(p,36,0);            /* auth flags */
1832       SIVALS(p,40,-1);          /* password age */
1833       SIVAL(p,44,PTR_DIFF(p2,p)); /* home dir */
1834       strcpy(p2,"\\\\%L\\HOMES");
1835       standard_sub_basic(p2);
1836       p2 = skip_string(p2,1);
1837       SIVAL(p,48,PTR_DIFF(p2,p)); /* parms */
1838       strcpy(p2,"");
1839       p2 = skip_string(p2,1);
1840       SIVAL(p,52,0);            /* last logon */
1841       SIVAL(p,56,0);            /* last logoff */
1842       SSVALS(p,60,-1);          /* bad pw counts */
1843       SSVALS(p,62,-1);          /* num logons */
1844       SIVAL(p,64,PTR_DIFF(p2,p)); /* logon server */
1845       strcpy(p2,"\\\\*");
1846       p2 = skip_string(p2,1);
1847       SSVAL(p,68,0);            /* country code */
1848
1849       SIVAL(p,70,PTR_DIFF(p2,p)); /* workstations */
1850       strcpy(p2,"");
1851       p2 = skip_string(p2,1);
1852
1853       SIVALS(p,74,-1);          /* max storage */
1854       SSVAL(p,78,168);          /* units per week */
1855       SIVAL(p,80,PTR_DIFF(p2,p)); /* logon hours */
1856       memset(p2,-1,21);
1857       SCVAL(p2,21,0);           /* fix zero termination */
1858       p2 = skip_string(p2,1);
1859
1860       SSVAL(p,84,0);            /* code page */
1861     }
1862     if (uLevel == 1 || uLevel == 2) {
1863       memset(p+22,' ',16);      /* password */
1864       SIVALS(p,38,-1);          /* password age */
1865       SSVAL(p,42,USER_PRIV_ADMIN); /* user privilege */
1866       SIVAL(p,44,PTR_DIFF(p2,*rdata)); /* home dir */
1867       strcpy(p2,"\\\\%L\\HOMES");
1868       standard_sub_basic(p2);
1869       p2 = skip_string(p2,1);
1870       SIVAL(p,48,PTR_DIFF(p2,*rdata)); /* comment */
1871       *p2++ = 0;
1872       SSVAL(p,52,0);            /* flags */
1873       SIVAL(p,54,0);            /* script_path */
1874       if (uLevel == 2) {
1875         SIVAL(p,60,0);          /* auth_flags */
1876         SIVAL(p,64,PTR_DIFF(p2,*rdata)); /* full_name */
1877         strcpy(p2,"<Full Name>");
1878         p2 = skip_string(p2,1);
1879         SIVAL(p,68,0);          /* urs_comment */
1880         SIVAL(p,72,PTR_DIFF(p2,*rdata)); /* parms */
1881         strcpy(p2,"");
1882         p2 = skip_string(p2,1);
1883         SIVAL(p,76,0);          /* workstations */
1884         SIVAL(p,80,0);          /* last_logon */
1885         SIVAL(p,84,0);          /* last_logoff */
1886         SIVALS(p,88,-1);                /* acct_expires */
1887         SIVALS(p,92,-1);                /* max_storage */
1888         SSVAL(p,96,168);        /* units_per_week */
1889         SIVAL(p,98,PTR_DIFF(p2,*rdata)); /* logon_hours */
1890         memset(p2,-1,21);
1891         p2 += 21;
1892         SSVALS(p,102,-1);       /* bad_pw_count */
1893         SSVALS(p,104,-1);       /* num_logons */
1894         SIVAL(p,106,PTR_DIFF(p2,*rdata)); /* logon_server */
1895         strcpy(p2,"\\\\%L");
1896         standard_sub_basic(p2);
1897         p2 = skip_string(p2,1);
1898         SSVAL(p,110,49);        /* country_code */
1899         SSVAL(p,112,860);       /* code page */
1900       }
1901     }
1902   }
1903
1904   *rdata_len = PTR_DIFF(p2,*rdata);
1905
1906   SSVAL(*rparam,4,*rdata_len);  /* is this right?? */
1907
1908   return(True);
1909 }
1910
1911
1912 /*******************************************************************
1913   get groups that a user is a member of
1914   ******************************************************************/
1915 static BOOL api_NetUserGetGroups(int cnum,int uid, char *param,char *data,
1916                                  int mdrcnt,int mprcnt,
1917                                  char **rdata,char **rparam,
1918                                  int *rdata_len,int *rparam_len)
1919 {
1920   char *str1 = param+2;
1921   char *str2 = skip_string(str1,1);
1922   char *UserName = skip_string(str2,1);
1923   char *p = skip_string(UserName,1);
1924   int uLevel = SVAL(p,0);
1925   char *p2;
1926   int count=0;
1927
1928   *rparam_len = 8;
1929   *rparam = REALLOC(*rparam,*rparam_len);
1930
1931   /* check it's a supported varient */
1932   if (strcmp(str1,"zWrLeh") != 0) return False;
1933   switch( uLevel ) {
1934   case 0: p2 = "B21"; break;
1935   default: return False;
1936   }
1937   if (strcmp(p2,str2) != 0) return False;
1938
1939   *rdata_len = mdrcnt + 1024;
1940   *rdata = REALLOC(*rdata,*rdata_len);
1941
1942   SSVAL(*rparam,0,NERR_Success);
1943   SSVAL(*rparam,2,0);           /* converter word */
1944
1945   p = *rdata;
1946
1947   /* XXXX we need a real SAM database some day */
1948   strcpy(p,"Users"); p += 21; count++;
1949   strcpy(p,"Domain Users"); p += 21; count++;
1950   strcpy(p,"Guests"); p += 21; count++;
1951   strcpy(p,"Domain Guests"); p += 21; count++;
1952
1953   *rdata_len = PTR_DIFF(p,*rdata);
1954
1955   SSVAL(*rparam,4,count);       /* is this right?? */
1956   SSVAL(*rparam,6,count);       /* is this right?? */
1957
1958   return(True);
1959 }
1960
1961
1962 static BOOL api_WWkstaUserLogon(int cnum,int uid, char *param,char *data,
1963                                 int mdrcnt,int mprcnt,
1964                                 char **rdata,char **rparam,
1965                                 int *rdata_len,int *rparam_len)
1966 {
1967   char *str1 = param+2;
1968   char *str2 = skip_string(str1,1);
1969   char *p = skip_string(str2,1);
1970   int uLevel;
1971   struct pack_desc desc;
1972   char* name;
1973
1974   uLevel = SVAL(p,0);
1975   name = p + 2;
1976
1977   bzero(&desc,sizeof(desc));
1978
1979   DEBUG(3,("WWkstaUserLogon uLevel=%d name=%s\n",uLevel,name));
1980
1981   /* check it's a supported varient */
1982   if (strcmp(str1,"OOWb54WrLh") != 0) return False;
1983   if (uLevel != 1 || strcmp(str2,"WB21BWDWWDDDDDDDzzzD") != 0) return False;
1984   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
1985   desc.base = *rdata;
1986   desc.buflen = mdrcnt;
1987   desc.subformat = NULL;
1988   desc.format = str2;
1989   
1990   
1991
1992   if (init_package(&desc,1,0)) {
1993     PACKI(&desc,"W",0);         /* code */
1994     PACKS(&desc,"B21",name);    /* eff. name */
1995     PACKS(&desc,"B","");                /* pad */
1996     PACKI(&desc,"W",
1997           Connections[cnum].admin_user?USER_PRIV_ADMIN:USER_PRIV_USER);
1998     PACKI(&desc,"D",0);         /* auth flags XXX */
1999     PACKI(&desc,"W",0);         /* num logons */
2000     PACKI(&desc,"W",0);         /* bad pw count */
2001     PACKI(&desc,"D",-1);                /* last logon */
2002     PACKI(&desc,"D",-1);                /* last logoff */
2003     PACKI(&desc,"D",-1);                /* logoff time */
2004     PACKI(&desc,"D",-1);                /* kickoff time */
2005     PACKI(&desc,"D",0);         /* password age */
2006     PACKI(&desc,"D",0);         /* password can change */
2007     PACKI(&desc,"D",-1);                /* password must change */
2008     {
2009       fstring mypath;
2010       strcpy(mypath,"\\\\");
2011       strcat(mypath,local_machine);
2012       strupper(mypath);
2013       PACKS(&desc,"z",mypath); /* computer */
2014     }
2015     PACKS(&desc,"z",my_workgroup());/* domain */
2016     PACKS(&desc,"z",lp_logon_script());         /* script path */
2017     PACKI(&desc,"D",0);         /* reserved */
2018   }
2019
2020   *rdata_len = desc.usedlen;
2021   *rparam_len = 6;
2022   *rparam = REALLOC(*rparam,*rparam_len);
2023   SSVALS(*rparam,0,desc.errcode);
2024   SSVAL(*rparam,2,0);
2025   SSVAL(*rparam,4,desc.neededlen);
2026
2027   DEBUG(4,("WWkstaUserLogon: errorcode %d\n",desc.errcode));
2028   return(True);
2029 }
2030
2031
2032 /****************************************************************************
2033   api_WAccessGetUserPerms
2034   ****************************************************************************/
2035 static BOOL api_WAccessGetUserPerms(int cnum,int uid, char *param,char *data,
2036                                     int mdrcnt,int mprcnt,
2037                                     char **rdata,char **rparam,
2038                                     int *rdata_len,int *rparam_len)
2039 {
2040   char *str1 = param+2;
2041   char *str2 = skip_string(str1,1);
2042   char *user = skip_string(str2,1);
2043   char *resource = skip_string(user,1);
2044
2045   DEBUG(3,("WAccessGetUserPerms user=%s resource=%s\n",user,resource));
2046
2047   /* check it's a supported varient */
2048   if (strcmp(str1,"zzh") != 0) return False;
2049   if (strcmp(str2,"") != 0) return False;
2050
2051   *rparam_len = 6;
2052   *rparam = REALLOC(*rparam,*rparam_len);
2053   SSVALS(*rparam,0,0);          /* errorcode */
2054   SSVAL(*rparam,2,0);           /* converter word */
2055   SSVAL(*rparam,4,0x7f);        /* permission flags */
2056
2057   return(True);
2058 }
2059
2060 /****************************************************************************
2061   api_WPrintJobEnumerate
2062   ****************************************************************************/
2063 static BOOL api_WPrintJobGetInfo(int cnum,int uid, char *param,char *data,
2064                                  int mdrcnt,int mprcnt,
2065                                  char **rdata,char **rparam,
2066                                  int *rdata_len,int *rparam_len)
2067 {
2068   char *str1 = param+2;
2069   char *str2 = skip_string(str1,1);
2070   char *p = skip_string(str2,1);
2071   int uJobId = SVAL(p,0);
2072   int uLevel,cbBuf;
2073   int count;
2074   int i;
2075   int snum;
2076   int job;
2077   struct pack_desc desc;
2078   print_queue_struct *queue=NULL;
2079   print_status_struct status;
2080
2081   uLevel = SVAL(p,2);
2082   cbBuf = SVAL(p,4);
2083
2084   bzero(&desc,sizeof(desc));
2085   bzero(&status,sizeof(status));
2086
2087   DEBUG(3,("WPrintJobGetInfo uLevel=%d uJobId=0x%X\n",uLevel,uJobId));
2088
2089   /* check it's a supported varient */
2090   if (strcmp(str1,"WWrLh") != 0) return False;
2091   if (!check_printjob_info(&desc,uLevel,str2)) return False;
2092
2093   snum = (unsigned int)uJobId >> 8; /*## valid serice number??*/
2094   job = uJobId & 0xFF;
2095
2096   if (snum < 0 || !VALID_SNUM(snum)) return(False);
2097
2098   count = get_printqueue(snum,cnum,&queue,&status);
2099   for (i = 0; i < count; i++) {
2100     if ((queue[i].job % 0xFF) == job) break;
2101   }
2102   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2103   desc.base = *rdata;
2104   desc.buflen = mdrcnt;
2105
2106   if (init_package(&desc,1,0)) {
2107     if (i < count) {
2108       fill_printjob_info(cnum,snum,uLevel,&desc,&queue[i],i);
2109       *rdata_len = desc.usedlen;
2110     }
2111     else {
2112       desc.errcode = NERR_JobNotFound;
2113       *rdata_len = 0;
2114     }
2115   }
2116
2117   *rparam_len = 6;
2118   *rparam = REALLOC(*rparam,*rparam_len);
2119   SSVALS(*rparam,0,desc.errcode);
2120   SSVAL(*rparam,2,0);
2121   SSVAL(*rparam,4,desc.neededlen);
2122
2123   if (queue) free(queue);
2124
2125   DEBUG(4,("WPrintJobGetInfo: errorcode %d\n",desc.errcode));
2126   return(True);
2127 }
2128
2129 static BOOL api_WPrintJobEnumerate(int cnum,int uid, char *param,char *data,
2130                                    int mdrcnt,int mprcnt,
2131                                    char **rdata,char **rparam,
2132                                    int *rdata_len,int *rparam_len)
2133 {
2134   char *str1 = param+2;
2135   char *str2 = skip_string(str1,1);
2136   char *p = skip_string(str2,1);
2137   char* name = p;
2138   int uLevel,cbBuf;
2139   int count;
2140   int i, succnt=0;
2141   int snum;
2142   struct pack_desc desc;
2143   print_queue_struct *queue=NULL;
2144   print_status_struct status;
2145
2146   bzero(&desc,sizeof(desc));
2147   bzero(&status,sizeof(status));
2148
2149   p = skip_string(p,1);
2150   uLevel = SVAL(p,0);
2151   cbBuf = SVAL(p,2);
2152
2153   DEBUG(3,("WPrintJobEnumerate uLevel=%d name=%s\n",uLevel,name));
2154
2155   /* check it's a supported varient */
2156   if (strcmp(str1,"zWrLeh") != 0) return False;
2157   if (uLevel > 2) return False; /* defined only for uLevel 0,1,2 */
2158   if (!check_printjob_info(&desc,uLevel,str2)) return False;
2159
2160   snum = lp_servicenumber(name);
2161   if (snum < 0 && pcap_printername_ok(name,NULL)) {
2162     int pnum = lp_servicenumber(PRINTERS_NAME);
2163     if (pnum >= 0) {
2164       lp_add_printer(name,pnum);
2165       snum = lp_servicenumber(name);
2166     }
2167   }
2168
2169   if (snum < 0 || !VALID_SNUM(snum)) return(False);
2170
2171   count = get_printqueue(snum,cnum,&queue,&status);
2172   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2173   desc.base = *rdata;
2174   desc.buflen = mdrcnt;
2175
2176   if (init_package(&desc,count,0)) {
2177     succnt = 0;
2178     for (i = 0; i < count; i++) {
2179       fill_printjob_info(cnum,snum,uLevel,&desc,&queue[i],i);
2180       if (desc.errcode == NERR_Success) succnt = i+1;
2181     }
2182   }
2183
2184   *rdata_len = desc.usedlen;
2185
2186   *rparam_len = 8;
2187   *rparam = REALLOC(*rparam,*rparam_len);
2188   SSVALS(*rparam,0,desc.errcode);
2189   SSVAL(*rparam,2,0);
2190   SSVAL(*rparam,4,succnt);
2191   SSVAL(*rparam,6,count);
2192
2193   if (queue) free(queue);
2194
2195   DEBUG(4,("WPrintJobEnumerate: errorcode %d\n",desc.errcode));
2196   return(True);
2197 }
2198
2199 static int check_printdest_info(struct pack_desc* desc,
2200                                 int uLevel, char* id)
2201 {
2202   desc->subformat = NULL;
2203   switch( uLevel ) {
2204   case 0: desc->format = "B9"; break;
2205   case 1: desc->format = "B9B21WWzW"; break;
2206   case 2: desc->format = "z"; break;
2207   case 3: desc->format = "zzzWWzzzWW"; break;
2208   default: return False;
2209   }
2210   if (strcmp(desc->format,id) != 0) return False;
2211   return True;
2212 }
2213
2214 static void fill_printdest_info(int cnum, int snum, int uLevel,
2215                                 struct pack_desc* desc)
2216 {
2217   char buf[100];
2218   strcpy(buf,SERVICE(snum));
2219   strupper(buf);
2220   if (uLevel <= 1) {
2221     PACKS(desc,"B9",buf);       /* szName */
2222     if (uLevel == 1) {
2223       PACKS(desc,"B21","");     /* szUserName */
2224       PACKI(desc,"W",0);                /* uJobId */
2225       PACKI(desc,"W",0);                /* fsStatus */
2226       PACKS(desc,"z","");       /* pszStatus */
2227       PACKI(desc,"W",0);                /* time */
2228     }
2229   }
2230   if (uLevel == 2 || uLevel == 3) {
2231     PACKS(desc,"z",buf);                /* pszPrinterName */
2232     if (uLevel == 3) {
2233       PACKS(desc,"z","");       /* pszUserName */
2234       PACKS(desc,"z","");       /* pszLogAddr */
2235       PACKI(desc,"W",0);                /* uJobId */
2236       PACKI(desc,"W",0);                /* fsStatus */
2237       PACKS(desc,"z","");       /* pszStatus */
2238       PACKS(desc,"z","");       /* pszComment */
2239       PACKS(desc,"z","NULL"); /* pszDrivers */
2240       PACKI(desc,"W",0);                /* time */
2241       PACKI(desc,"W",0);                /* pad1 */
2242     }
2243   }
2244 }
2245
2246 static BOOL api_WPrintDestGetInfo(int cnum,int uid, char *param,char *data,
2247                                   int mdrcnt,int mprcnt,
2248                                   char **rdata,char **rparam,
2249                                   int *rdata_len,int *rparam_len)
2250 {
2251   char *str1 = param+2;
2252   char *str2 = skip_string(str1,1);
2253   char *p = skip_string(str2,1);
2254   char* PrinterName = p;
2255   int uLevel,cbBuf;
2256   struct pack_desc desc;
2257   int snum;
2258
2259   bzero(&desc,sizeof(desc));
2260
2261   p = skip_string(p,1);
2262   uLevel = SVAL(p,0);
2263   cbBuf = SVAL(p,2);
2264
2265   DEBUG(3,("WPrintDestGetInfo uLevel=%d PrinterName=%s\n",uLevel,PrinterName));
2266
2267   /* check it's a supported varient */
2268   if (strcmp(str1,"zWrLh") != 0) return False;
2269   if (!check_printdest_info(&desc,uLevel,str2)) return False;
2270
2271   snum = lp_servicenumber(PrinterName);
2272   if (snum < 0 && pcap_printername_ok(PrinterName,NULL)) {
2273     int pnum = lp_servicenumber(PRINTERS_NAME);
2274     if (pnum >= 0) {
2275       lp_add_printer(PrinterName,pnum);
2276       snum = lp_servicenumber(PrinterName);
2277     }
2278   }
2279
2280   if (snum < 0) {
2281     *rdata_len = 0;
2282     desc.errcode = NERR_DestNotFound;
2283     desc.neededlen = 0;
2284   }
2285   else {
2286     if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2287     desc.base = *rdata;
2288     desc.buflen = mdrcnt;
2289     if (init_package(&desc,1,0)) {
2290       fill_printdest_info(cnum,snum,uLevel,&desc);
2291     }
2292     *rdata_len = desc.usedlen;
2293   }
2294
2295   *rparam_len = 6;
2296   *rparam = REALLOC(*rparam,*rparam_len);
2297   SSVALS(*rparam,0,desc.errcode);
2298   SSVAL(*rparam,2,0);
2299   SSVAL(*rparam,4,desc.neededlen);
2300
2301   DEBUG(4,("WPrintDestGetInfo: errorcode %d\n",desc.errcode));
2302   return(True);
2303 }
2304
2305 static BOOL api_WPrintDestEnum(int cnum,int uid, char *param,char *data,
2306                                int mdrcnt,int mprcnt,
2307                                char **rdata,char **rparam,
2308                                int *rdata_len,int *rparam_len)
2309 {
2310   char *str1 = param+2;
2311   char *str2 = skip_string(str1,1);
2312   char *p = skip_string(str2,1);
2313   int uLevel,cbBuf;
2314   int queuecnt;
2315   int i, n, succnt=0;
2316   struct pack_desc desc;
2317   int services = lp_numservices();
2318
2319   bzero(&desc,sizeof(desc));
2320
2321   uLevel = SVAL(p,0);
2322   cbBuf = SVAL(p,2);
2323
2324   DEBUG(3,("WPrintDestEnum uLevel=%d\n",uLevel));
2325
2326   /* check it's a supported varient */
2327   if (strcmp(str1,"WrLeh") != 0) return False;
2328   if (!check_printdest_info(&desc,uLevel,str2)) return False;
2329
2330   queuecnt = 0;
2331   for (i = 0; i < services; i++)
2332     if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i))
2333       queuecnt++;
2334
2335   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2336   desc.base = *rdata;
2337   desc.buflen = mdrcnt;
2338   if (init_package(&desc,queuecnt,0)) {    
2339     succnt = 0;
2340     n = 0;
2341     for (i = 0; i < services; i++) {
2342       if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
2343         fill_printdest_info(cnum,i,uLevel,&desc);
2344         n++;
2345         if (desc.errcode == NERR_Success) succnt = n;
2346       }
2347     }
2348   }
2349
2350   *rdata_len = desc.usedlen;
2351
2352   *rparam_len = 8;
2353   *rparam = REALLOC(*rparam,*rparam_len);
2354   SSVALS(*rparam,0,desc.errcode);
2355   SSVAL(*rparam,2,0);
2356   SSVAL(*rparam,4,succnt);
2357   SSVAL(*rparam,6,queuecnt);
2358
2359   DEBUG(4,("WPrintDestEnumerate: errorcode %d\n",desc.errcode));
2360   return(True);
2361 }
2362
2363 static BOOL api_WPrintDriverEnum(int cnum,int uid, char *param,char *data,
2364                                  int mdrcnt,int mprcnt,
2365                                  char **rdata,char **rparam,
2366                                  int *rdata_len,int *rparam_len)
2367 {
2368   char *str1 = param+2;
2369   char *str2 = skip_string(str1,1);
2370   char *p = skip_string(str2,1);
2371   int uLevel,cbBuf;
2372   int succnt;
2373   struct pack_desc desc;
2374
2375   bzero(&desc,sizeof(desc));
2376
2377   uLevel = SVAL(p,0);
2378   cbBuf = SVAL(p,2);
2379
2380   DEBUG(3,("WPrintDriverEnum uLevel=%d\n",uLevel));
2381
2382   /* check it's a supported varient */
2383   if (strcmp(str1,"WrLeh") != 0) return False;
2384   if (uLevel != 0 || strcmp(str2,"B41") != 0) return False;
2385
2386   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2387   desc.base = *rdata;
2388   desc.buflen = mdrcnt;
2389   if (init_package(&desc,1,0)) {
2390     PACKS(&desc,"B41","NULL");
2391   }
2392
2393   succnt = (desc.errcode == NERR_Success ? 1 : 0);
2394
2395   *rdata_len = desc.usedlen;
2396
2397   *rparam_len = 8;
2398   *rparam = REALLOC(*rparam,*rparam_len);
2399   SSVALS(*rparam,0,desc.errcode);
2400   SSVAL(*rparam,2,0);
2401   SSVAL(*rparam,4,succnt);
2402   SSVAL(*rparam,6,1);
2403
2404   DEBUG(4,("WPrintDriverEnum: errorcode %d\n",desc.errcode));
2405   return(True);
2406 }
2407
2408 static BOOL api_WPrintQProcEnum(int cnum,int uid, char *param,char *data,
2409                                 int mdrcnt,int mprcnt,
2410                                 char **rdata,char **rparam,
2411                                 int *rdata_len,int *rparam_len)
2412 {
2413   char *str1 = param+2;
2414   char *str2 = skip_string(str1,1);
2415   char *p = skip_string(str2,1);
2416   int uLevel,cbBuf;
2417   int succnt;
2418   struct pack_desc desc;
2419
2420   bzero(&desc,sizeof(desc));
2421
2422   uLevel = SVAL(p,0);
2423   cbBuf = SVAL(p,2);
2424
2425   DEBUG(3,("WPrintQProcEnum uLevel=%d\n",uLevel));
2426
2427   /* check it's a supported varient */
2428   if (strcmp(str1,"WrLeh") != 0) return False;
2429   if (uLevel != 0 || strcmp(str2,"B13") != 0) return False;
2430
2431   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2432   desc.base = *rdata;
2433   desc.buflen = mdrcnt;
2434   desc.format = str2;
2435   if (init_package(&desc,1,0)) {
2436     PACKS(&desc,"B13","lpd");
2437   }
2438
2439   succnt = (desc.errcode == NERR_Success ? 1 : 0);
2440
2441   *rdata_len = desc.usedlen;
2442
2443   *rparam_len = 8;
2444   *rparam = REALLOC(*rparam,*rparam_len);
2445   SSVALS(*rparam,0,desc.errcode);
2446   SSVAL(*rparam,2,0);
2447   SSVAL(*rparam,4,succnt);
2448   SSVAL(*rparam,6,1);
2449
2450   DEBUG(4,("WPrintQProcEnum: errorcode %d\n",desc.errcode));
2451   return(True);
2452 }
2453
2454 static BOOL api_WPrintPortEnum(int cnum,int uid, char *param,char *data,
2455                                int mdrcnt,int mprcnt,
2456                                char **rdata,char **rparam,
2457                                int *rdata_len,int *rparam_len)
2458 {
2459   char *str1 = param+2;
2460   char *str2 = skip_string(str1,1);
2461   char *p = skip_string(str2,1);
2462   int uLevel,cbBuf;
2463   int succnt;
2464   struct pack_desc desc;
2465
2466   bzero(&desc,sizeof(desc));
2467
2468   uLevel = SVAL(p,0);
2469   cbBuf = SVAL(p,2);
2470
2471   DEBUG(3,("WPrintPortEnum uLevel=%d\n",uLevel));
2472
2473   /* check it's a supported varient */
2474   if (strcmp(str1,"WrLeh") != 0) return False;
2475   if (uLevel != 0 || strcmp(str2,"B9") != 0) return False;
2476
2477   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2478   bzero(&desc,sizeof(desc));
2479   desc.base = *rdata;
2480   desc.buflen = mdrcnt;
2481   desc.format = str2;
2482   if (init_package(&desc,1,0)) {
2483     PACKS(&desc,"B13","lp0");
2484   }
2485
2486   succnt = (desc.errcode == NERR_Success ? 1 : 0);
2487
2488   *rdata_len = desc.usedlen;
2489
2490   *rparam_len = 8;
2491   *rparam = REALLOC(*rparam,*rparam_len);
2492   SSVALS(*rparam,0,desc.errcode);
2493   SSVAL(*rparam,2,0);
2494   SSVAL(*rparam,4,succnt);
2495   SSVAL(*rparam,6,1);
2496
2497   DEBUG(4,("WPrintPortEnum: errorcode %d\n",desc.errcode));
2498   return(True);
2499 }
2500
2501 /****************************************************************************
2502   the buffer was too small
2503   ****************************************************************************/
2504 static BOOL api_TooSmall(int cnum,int uid, char *param,char *data,
2505                          int mdrcnt,int mprcnt,
2506                          char **rdata,char **rparam,
2507                          int *rdata_len,int *rparam_len)
2508 {
2509   *rparam_len = MIN(*rparam_len,mprcnt);
2510   *rparam = REALLOC(*rparam,*rparam_len);
2511
2512   *rdata_len = 0;
2513
2514   SSVAL(*rparam,0,NERR_BufTooSmall);
2515
2516   DEBUG(3,("Supplied buffer too small in API command\n"));
2517
2518   return(True);
2519 }
2520
2521
2522 /****************************************************************************
2523   the request is not supported
2524   ****************************************************************************/
2525 static BOOL api_Unsupported(int cnum,int uid, char *param,char *data,
2526                             int mdrcnt,int mprcnt,
2527                             char **rdata,char **rparam,
2528                             int *rdata_len,int *rparam_len)
2529 {
2530   *rparam_len = 4;
2531   *rparam = REALLOC(*rparam,*rparam_len);
2532
2533   *rdata_len = 0;
2534
2535   SSVAL(*rparam,0,NERR_notsupported);
2536   SSVAL(*rparam,2,0);           /* converter word */
2537
2538   DEBUG(3,("Unsupported API command\n"));
2539
2540   return(True);
2541 }
2542
2543
2544
2545
2546 struct
2547 {
2548   char *name;
2549   int id;
2550   BOOL (*fn)();
2551   int flags;
2552 } api_commands[] = {
2553   {"RNetShareEnum",     0,      api_RNetShareEnum,0},
2554   {"RNetShareGetInfo",  1,      api_RNetShareGetInfo,0},
2555   {"RNetServerGetInfo", 13,     api_RNetServerGetInfo,0},
2556   {"RNetUserGetInfo",   56,     api_RNetUserGetInfo,0},
2557   {"NetUserGetGroups",  59,     api_NetUserGetGroups,0},
2558   {"NetWkstaGetInfo",   63,     api_NetWkstaGetInfo,0},
2559   {"DosPrintQEnum",     69,     api_DosPrintQEnum,0},
2560   {"DosPrintQGetInfo",  70,     api_DosPrintQGetInfo,0},
2561   {"WPrintJobEnumerate",76,     api_WPrintJobEnumerate,0},
2562   {"WPrintJobGetInfo",  77,     api_WPrintJobGetInfo,0},
2563   {"RDosPrintJobDel",   81,     api_RDosPrintJobDel,0},
2564   {"RDosPrintJobPause", 82,     api_RDosPrintJobDel,0},
2565   {"RDosPrintJobResume",83,     api_RDosPrintJobDel,0},
2566   {"WPrintDestEnum",    84,     api_WPrintDestEnum,0},
2567   {"WPrintDestGetInfo", 85,     api_WPrintDestGetInfo,0},
2568   {"NetRemoteTOD",      91,     api_NetRemoteTOD,0},
2569   {"WPrintQueuePurge",  103,    api_WPrintQueuePurge,0},
2570   {"NetServerEnum",     104,    api_RNetServerEnum,0},
2571   {"WAccessGetUserPerms",105,   api_WAccessGetUserPerms,0},
2572   {"SetUserPassword",   115,    api_SetUserPassword,0},
2573   {"WWkstaUserLogon",   132,    api_WWkstaUserLogon,0},
2574   {"PrintJobInfo",      147,    api_PrintJobInfo,0},
2575   {"WPrintDriverEnum",  205,    api_WPrintDriverEnum,0},
2576   {"WPrintQProcEnum",   206,    api_WPrintQProcEnum,0},
2577   {"WPrintPortEnum",    207,    api_WPrintPortEnum,0},
2578   {NULL,                -1,     api_Unsupported,0}};
2579
2580
2581 /****************************************************************************
2582   handle remote api calls
2583   ****************************************************************************/
2584 static int api_reply(int cnum,int uid,char *outbuf,char *data,char *params,
2585                      int tdscnt,int tpscnt,int mdrcnt,int mprcnt)
2586 {
2587   int api_command = SVAL(params,0);
2588   char *rdata = NULL;
2589   char *rparam = NULL;
2590   int rdata_len = 0;
2591   int rparam_len = 0;
2592   BOOL reply=False;
2593   int i;
2594
2595   DEBUG(3,("Got API command %d of form <%s> <%s> (tdscnt=%d,tpscnt=%d,mdrcnt=%d,mprcnt=%d)\n",
2596            api_command,params+2,skip_string(params+2,1),
2597            tdscnt,tpscnt,mdrcnt,mprcnt));
2598
2599   for (i=0;api_commands[i].name;i++)
2600     if (api_commands[i].id == api_command && api_commands[i].fn)
2601       {
2602         DEBUG(3,("Doing %s\n",api_commands[i].name));
2603         break;
2604       }
2605
2606   rdata = (char *)malloc(1024); if (rdata) bzero(rdata,1024);
2607   rparam = (char *)malloc(1024); if (rparam) bzero(rparam,1024);
2608
2609   reply = api_commands[i].fn(cnum,uid,params,data,mdrcnt,mprcnt,
2610                              &rdata,&rparam,&rdata_len,&rparam_len);
2611
2612
2613   if (rdata_len > mdrcnt ||
2614       rparam_len > mprcnt)
2615     {
2616       reply = api_TooSmall(cnum,uid,params,data,mdrcnt,mprcnt,
2617                            &rdata,&rparam,&rdata_len,&rparam_len);
2618     }
2619             
2620
2621   /* if we get False back then it's actually unsupported */
2622   if (!reply)
2623     api_Unsupported(cnum,uid,params,data,mdrcnt,mprcnt,
2624                     &rdata,&rparam,&rdata_len,&rparam_len);
2625
2626       
2627
2628   /* now send the reply */
2629   send_trans_reply(outbuf,rdata,rparam,NULL,rdata_len,rparam_len,0);
2630
2631   if (rdata)
2632     free(rdata);
2633   if (rparam)
2634     free(rparam);
2635   
2636   return(-1);
2637 }
2638
2639 /****************************************************************************
2640   handle named pipe commands
2641   ****************************************************************************/
2642 static int named_pipe(int cnum,int uid, char *outbuf,char *name,
2643                       uint16 *setup,char *data,char *params,
2644                       int suwcnt,int tdscnt,int tpscnt,
2645                       int msrcnt,int mdrcnt,int mprcnt)
2646 {
2647
2648   if (strequal(name,"LANMAN"))
2649     return(api_reply(cnum,uid,outbuf,data,params,tdscnt,tpscnt,mdrcnt,mprcnt));
2650
2651   DEBUG(3,("named pipe command on <%s> 0x%X setup1=%d\n",
2652            name,(int)setup[0],(int)setup[1]));
2653   
2654   return(0);
2655 }
2656
2657
2658 /****************************************************************************
2659   reply to a SMBtrans
2660   ****************************************************************************/
2661 int reply_trans(char *inbuf,char *outbuf)
2662 {
2663   fstring name;
2664
2665   char *data=NULL,*params=NULL;
2666   uint16 *setup=NULL;
2667
2668   int outsize = 0;
2669   int cnum = SVAL(inbuf,smb_tid);
2670   int uid = SVAL(inbuf,smb_uid);
2671
2672   int tpscnt = SVAL(inbuf,smb_vwv0);
2673   int tdscnt = SVAL(inbuf,smb_vwv1);
2674   int mprcnt = SVAL(inbuf,smb_vwv2);
2675   int mdrcnt = SVAL(inbuf,smb_vwv3);
2676   int msrcnt = CVAL(inbuf,smb_vwv4);
2677   BOOL close_on_completion = BITSETW(inbuf+smb_vwv5,0);
2678   BOOL one_way = BITSETW(inbuf+smb_vwv5,1);
2679   int pscnt = SVAL(inbuf,smb_vwv9);
2680   int psoff = SVAL(inbuf,smb_vwv10);
2681   int dscnt = SVAL(inbuf,smb_vwv11);
2682   int dsoff = SVAL(inbuf,smb_vwv12);
2683   int suwcnt = CVAL(inbuf,smb_vwv13);
2684
2685   StrnCpy(name,smb_buf(inbuf),sizeof(name)-1);
2686   
2687   if (tdscnt)
2688     {
2689       data = (char *)malloc(tdscnt);
2690       memcpy(data,smb_base(inbuf)+dsoff,dscnt);
2691     }
2692   if (tpscnt)
2693     {
2694       params = (char *)malloc(tpscnt);
2695       memcpy(params,smb_base(inbuf)+psoff,pscnt);
2696     }
2697
2698   if (suwcnt)
2699     {
2700       int i;
2701       setup = (uint16 *)malloc(suwcnt*sizeof(setup[0]));
2702       for (i=0;i<suwcnt;i++)
2703         setup[i] = SVAL(inbuf,smb_vwv14+i*SIZEOFWORD);
2704     }
2705
2706
2707   if (pscnt < tpscnt || dscnt < tdscnt)
2708     {
2709       /* We need to send an interim response then receive the rest
2710          of the parameter/data bytes */
2711       outsize = set_message(outbuf,0,0,True);
2712       show_msg(outbuf);
2713       send_smb(Client,outbuf);
2714     }
2715
2716   /* receive the rest of the trans packet */
2717   while (pscnt < tpscnt || dscnt < tdscnt)
2718     {
2719       int pcnt,poff,dcnt,doff,pdisp,ddisp;
2720
2721       receive_smb(Client,inbuf, 0);
2722       show_msg(inbuf);
2723           
2724       /* Ensure this is still a trans packet (sanity check) */
2725       if(CVAL(inbuf, smb_com) != SMBtrans)
2726         {
2727           DEBUG(2,("Invalid secondary trans2 packet\n"));
2728           if (params) free(params);
2729           if (data) free(data);
2730           if (setup) free(setup);
2731           return(ERROR(ERRSRV,ERRerror));
2732         }
2733       
2734       tpscnt = SVAL(inbuf,smb_vwv0);
2735       tdscnt = SVAL(inbuf,smb_vwv1);
2736
2737       pcnt = SVAL(inbuf,smb_vwv2);
2738       poff = SVAL(inbuf,smb_vwv3);
2739       pdisp = SVAL(inbuf,smb_vwv4);
2740       
2741       dcnt = SVAL(inbuf,smb_vwv5);
2742       doff = SVAL(inbuf,smb_vwv6);
2743       ddisp = SVAL(inbuf,smb_vwv7);
2744       
2745       pscnt += pcnt;
2746       dscnt += dcnt;
2747
2748       if (pcnt)
2749         memcpy(params+pdisp,smb_base(inbuf)+poff,pcnt);
2750       if (dcnt)
2751         memcpy(data+ddisp,smb_base(inbuf)+doff,dcnt);      
2752     }
2753
2754
2755   DEBUG(3,("trans <%s> data=%d params=%d setup=%d\n",name,tdscnt,tpscnt,suwcnt));
2756   
2757
2758   if (strncmp(name,"\\PIPE\\",strlen("\\PIPE\\")) == 0)
2759     outsize = named_pipe(cnum,uid,outbuf,name+strlen("\\PIPE\\"),setup,data,params,
2760                          suwcnt,tdscnt,tpscnt,msrcnt,mdrcnt,mprcnt);
2761
2762
2763   if (data) free(data);
2764   if (params) free(params);
2765   if (setup) free(setup);
2766
2767   if (close_on_completion)
2768     close_cnum(cnum,uid);
2769
2770   if (one_way)
2771     return(-1);
2772   
2773   if (outsize == 0)
2774     return(ERROR(ERRSRV,ERRnosupport));
2775
2776   return(outsize);
2777 }
2778
2779