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 (issafe(*s)) name[l++] = *s;
1555             s++;
1556           }
1557         name[l] = 0;
1558
1559         DEBUG(3,("Setting print name to %s\n",name));
1560
1561         for (i=0;i<MAX_OPEN_FILES;i++)
1562           if (Files[i].open && Files[i].print_file)
1563             {
1564               pstring wd;
1565               GetWd(wd);
1566               unbecome_user();
1567
1568               if (!become_user(Files[i].cnum,uid) ||
1569                   !become_service(Files[i].cnum,True))
1570                 break;
1571
1572               if (sys_rename(Files[i].name,name) == 0)
1573                 string_set(&Files[i].name,name);
1574               break;
1575             }
1576       }
1577     desc.errcode=NERR_Success;
1578
1579     break;
1580   default:                      /* not implemented */
1581     return False;
1582   }
1583
1584   SSVALS(*rparam,0,desc.errcode);
1585   SSVAL(*rparam,2,0);           /* converter word */
1586
1587   return(True);
1588 }
1589
1590
1591 /****************************************************************************
1592   get info about the server
1593   ****************************************************************************/
1594 static BOOL api_RNetServerGetInfo(int cnum,int uid, char *param,char *data,
1595                                   int mdrcnt,int mprcnt,
1596                                   char **rdata,char **rparam,
1597                                   int *rdata_len,int *rparam_len)
1598 {
1599   char *str1 = param+2;
1600   char *str2 = skip_string(str1,1);
1601   char *p = skip_string(str2,1);
1602   int uLevel = SVAL(p,0);
1603   char *p2;
1604   int struct_len;
1605
1606   DEBUG(4,("NetServerGetInfo level %d\n",uLevel));
1607
1608   /* check it's a supported varient */
1609   if (!prefix_ok(str1,"WrLh")) return False;
1610   switch( uLevel ) {
1611   case 0:
1612     if (strcmp(str2,"B16") != 0) return False;
1613     struct_len = 16;
1614     break;
1615   case 1:
1616     if (strcmp(str2,"B16BBDz") != 0) return False;
1617     struct_len = 26;
1618     break;
1619   case 2:
1620     if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWz")
1621         != 0) return False;
1622     struct_len = 134;
1623     break;
1624   case 3:
1625     if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWzDWz")
1626         != 0) return False;
1627     struct_len = 144;
1628     break;
1629   case 20:
1630     if (strcmp(str2,"DN") != 0) return False;
1631     struct_len = 6;
1632     break;
1633   case 50:
1634     if (strcmp(str2,"B16BBDzWWzzz") != 0) return False;
1635     struct_len = 42;
1636     break;
1637   default: return False;
1638   }
1639
1640   *rdata_len = mdrcnt;
1641   *rdata = REALLOC(*rdata,*rdata_len);
1642
1643   p = *rdata;
1644   p2 = p + struct_len;
1645   if (uLevel != 20) {
1646     StrnCpy(p,local_machine,16);
1647     strupper(p);
1648   }
1649   p += 16;
1650   if (uLevel > 0)
1651     {
1652       struct srv_info_struct *servers=NULL;
1653       int i,count;
1654       pstring comment;
1655       uint32 servertype=SV_TYPE_SERVER_UNIX|SV_TYPE_WORKSTATION|
1656         SV_TYPE_SERVER|SV_TYPE_TIME_SOURCE;
1657
1658       strcpy(comment,lp_serverstring());
1659
1660       if ((count=get_server_info(SV_TYPE_ALL,&servers))>0) {
1661         for (i=0;i<count;i++)
1662           if (strequal(servers[i].name,local_machine)) {
1663             servertype = servers[i].type;
1664             strcpy(comment,servers[i].comment);
1665           }
1666       }
1667       if (servers) free(servers);
1668
1669       SCVAL(p,0,2);             /* version_major */
1670       SCVAL(p,1,0);             /* version_minor */
1671       SIVAL(p,2,servertype);
1672       if (mdrcnt == struct_len) {
1673         SIVAL(p,6,0);
1674       } else {
1675         SIVAL(p,6,PTR_DIFF(p2,*rdata));
1676         standard_sub(cnum,comment);
1677         StrnCpy(p2,comment,MAX(mdrcnt - struct_len,0));
1678         p2 = skip_string(p2,1);
1679       }
1680     }
1681   if (uLevel > 1)
1682     {
1683       return False;             /* not yet implemented */
1684     }
1685
1686   *rdata_len = PTR_DIFF(p2,*rdata);
1687
1688   *rparam_len = 6;
1689   *rparam = REALLOC(*rparam,*rparam_len);
1690   SSVAL(*rparam,0,NERR_Success);
1691   SSVAL(*rparam,2,0);           /* converter word */
1692   SSVAL(*rparam,4,*rdata_len);
1693
1694   return(True);
1695 }
1696
1697
1698 /****************************************************************************
1699   get info about the server
1700   ****************************************************************************/
1701 static BOOL api_NetWkstaGetInfo(int cnum,int uid, char *param,char *data,
1702                                 int mdrcnt,int mprcnt,
1703                                 char **rdata,char **rparam,
1704                                 int *rdata_len,int *rparam_len)
1705 {
1706   char *str1 = param+2;
1707   char *str2 = skip_string(str1,1);
1708   char *p = skip_string(str2,1);
1709   char *p2;
1710   extern pstring sesssetup_user;
1711   int level = SVAL(p,0);
1712
1713   DEBUG(4,("NetWkstaGetInfo level %d\n",level));
1714
1715   *rparam_len = 6;
1716   *rparam = REALLOC(*rparam,*rparam_len);
1717
1718   /* check it's a supported varient */
1719   if (!(level==10 && strcsequal(str1,"WrLh") && strcsequal(str2,"zzzBBzz")))
1720     return(False);
1721
1722   *rdata_len = mdrcnt + 1024;
1723   *rdata = REALLOC(*rdata,*rdata_len);
1724
1725   SSVAL(*rparam,0,NERR_Success);
1726   SSVAL(*rparam,2,0);           /* converter word */
1727
1728   p = *rdata;
1729   p2 = p + 22;
1730
1731   SIVAL(p,0,PTR_DIFF(p2,*rdata));
1732   strcpy(p2,local_machine);
1733   p2 = skip_string(p2,1);
1734   p += 4;
1735
1736   SIVAL(p,0,PTR_DIFF(p2,*rdata));
1737   strcpy(p2,sesssetup_user);
1738   p2 = skip_string(p2,1);
1739   p += 4;
1740
1741   SIVAL(p,0,PTR_DIFF(p2,*rdata));
1742   strcpy(p2,my_workgroup());
1743   p2 = skip_string(p2,1);
1744   p += 4;
1745
1746   SCVAL(p,0,2); /* major version?? */
1747   SCVAL(p,1,1); /* minor version?? */
1748   p += 2;
1749
1750   SIVAL(p,0,PTR_DIFF(p2,*rdata));
1751   strcpy(p2,my_workgroup());    /* login domain?? */
1752   p2 = skip_string(p2,1);
1753   p += 4;
1754
1755   SIVAL(p,0,PTR_DIFF(p2,*rdata));
1756   strcpy(p2,"");
1757   p2 = skip_string(p2,1);
1758   p += 4;
1759
1760   *rdata_len = PTR_DIFF(p2,*rdata);
1761
1762   SSVAL(*rparam,4,*rdata_len);
1763
1764   return(True);
1765 }
1766
1767
1768 /****************************************************************************
1769   get info about a user
1770   ****************************************************************************/
1771
1772 #define USER_PRIV_GUEST 0
1773 #define USER_PRIV_USER 1
1774 #define USER_PRIV_ADMIN 2
1775
1776 static BOOL api_RNetUserGetInfo(int cnum,int uid, char *param,char *data,
1777                                 int mdrcnt,int mprcnt,
1778                                 char **rdata,char **rparam,
1779                                 int *rdata_len,int *rparam_len)
1780 {
1781   char *str1 = param+2;
1782   char *str2 = skip_string(str1,1);
1783   char *UserName = skip_string(str2,1);
1784   char *p = skip_string(UserName,1);
1785   int uLevel = SVAL(p,0);
1786   char *p2;
1787
1788   *rparam_len = 6;
1789   *rparam = REALLOC(*rparam,*rparam_len);
1790
1791   /* check it's a supported varient */
1792   if (strcmp(str1,"zWrLh") != 0) return False;
1793   switch( uLevel ) {
1794   case 0: p2 = "B21"; break;
1795   case 1: p2 = "B21BB16DWzzWz"; break;
1796   case 2: p2 = "B21BB16DWzzWzDzzzzDDDDWb21WWzWW"; break;
1797   case 10: p2 = "B21Bzzz"; break;
1798   case 11: p2 = "B21BzzzWDDzzDDWWzWzDWb21W"; break;
1799   default: return False;
1800   }
1801   if (strcmp(p2,str2) != 0) return False;
1802
1803   *rdata_len = mdrcnt + 1024;
1804   *rdata = REALLOC(*rdata,*rdata_len);
1805
1806   SSVAL(*rparam,0,NERR_Success);
1807   SSVAL(*rparam,2,0);           /* converter word */
1808
1809   p = *rdata;
1810   p2 = p + 86;
1811
1812   memset(p,0,21);
1813   strcpy(p,UserName);
1814   if (uLevel > 0) {
1815     SCVAL(p,21,0);
1816     *p2 = 0;
1817     if (uLevel >= 10) {
1818       SIVAL(p,22,PTR_DIFF(p2,p)); /* comment */
1819       strcpy(p2,"<Comment>");
1820       p2 = skip_string(p2,1);
1821       SIVAL(p,26,PTR_DIFF(p2,p)); /* user_comment */
1822       strcpy(p2,"<UserComment>");
1823       p2 = skip_string(p2,1);
1824       SIVAL(p,30,PTR_DIFF(p2,p)); /* full name */
1825       strcpy(p2,"<FullName>");
1826       p2 = skip_string(p2,1);
1827     }
1828     if (uLevel == 11) {         /* modelled after NTAS 3.51 reply */
1829       SSVAL(p,34,USER_PRIV_USER); /* user privilege */
1830       SIVAL(p,36,0);            /* auth flags */
1831       SIVALS(p,40,-1);          /* password age */
1832       SIVAL(p,44,PTR_DIFF(p2,p)); /* home dir */
1833       strcpy(p2,"\\\\%L\\HOMES");
1834       standard_sub_basic(p2);
1835       p2 = skip_string(p2,1);
1836       SIVAL(p,48,PTR_DIFF(p2,p)); /* parms */
1837       strcpy(p2,"");
1838       p2 = skip_string(p2,1);
1839       SIVAL(p,52,0);            /* last logon */
1840       SIVAL(p,56,0);            /* last logoff */
1841       SSVALS(p,60,-1);          /* bad pw counts */
1842       SSVALS(p,62,-1);          /* num logons */
1843       SIVAL(p,64,PTR_DIFF(p2,p)); /* logon server */
1844       strcpy(p2,"\\\\*");
1845       p2 = skip_string(p2,1);
1846       SSVAL(p,68,0);            /* country code */
1847
1848       SIVAL(p,70,PTR_DIFF(p2,p)); /* workstations */
1849       strcpy(p2,"");
1850       p2 = skip_string(p2,1);
1851
1852       SIVALS(p,74,-1);          /* max storage */
1853       SSVAL(p,78,168);          /* units per week */
1854       SIVAL(p,80,PTR_DIFF(p2,p)); /* logon hours */
1855       memset(p2,-1,21);
1856       SCVAL(p2,21,0);           /* fix zero termination */
1857       p2 = skip_string(p2,1);
1858
1859       SSVAL(p,84,0);            /* code page */
1860     }
1861     if (uLevel == 1 || uLevel == 2) {
1862       memset(p+22,' ',16);      /* password */
1863       SIVALS(p,38,-1);          /* password age */
1864       SSVAL(p,42,USER_PRIV_ADMIN); /* user privilege */
1865       SIVAL(p,44,PTR_DIFF(p2,*rdata)); /* home dir */
1866       strcpy(p2,"\\\\%L\\HOMES");
1867       standard_sub_basic(p2);
1868       p2 = skip_string(p2,1);
1869       SIVAL(p,48,PTR_DIFF(p2,*rdata)); /* comment */
1870       *p2++ = 0;
1871       SSVAL(p,52,0);            /* flags */
1872       SIVAL(p,54,0);            /* script_path */
1873       if (uLevel == 2) {
1874         SIVAL(p,60,0);          /* auth_flags */
1875         SIVAL(p,64,PTR_DIFF(p2,*rdata)); /* full_name */
1876         strcpy(p2,"<Full Name>");
1877         p2 = skip_string(p2,1);
1878         SIVAL(p,68,0);          /* urs_comment */
1879         SIVAL(p,72,PTR_DIFF(p2,*rdata)); /* parms */
1880         strcpy(p2,"");
1881         p2 = skip_string(p2,1);
1882         SIVAL(p,76,0);          /* workstations */
1883         SIVAL(p,80,0);          /* last_logon */
1884         SIVAL(p,84,0);          /* last_logoff */
1885         SIVALS(p,88,-1);                /* acct_expires */
1886         SIVALS(p,92,-1);                /* max_storage */
1887         SSVAL(p,96,168);        /* units_per_week */
1888         SIVAL(p,98,PTR_DIFF(p2,*rdata)); /* logon_hours */
1889         memset(p2,-1,21);
1890         p2 += 21;
1891         SSVALS(p,102,-1);       /* bad_pw_count */
1892         SSVALS(p,104,-1);       /* num_logons */
1893         SIVAL(p,106,PTR_DIFF(p2,*rdata)); /* logon_server */
1894         strcpy(p2,"\\\\%L");
1895         standard_sub_basic(p2);
1896         p2 = skip_string(p2,1);
1897         SSVAL(p,110,49);        /* country_code */
1898         SSVAL(p,112,860);       /* code page */
1899       }
1900     }
1901   }
1902
1903   *rdata_len = PTR_DIFF(p2,*rdata);
1904
1905   SSVAL(*rparam,4,*rdata_len);  /* is this right?? */
1906
1907   return(True);
1908 }
1909
1910
1911 /*******************************************************************
1912   get groups that a user is a member of
1913   ******************************************************************/
1914 static BOOL api_NetUserGetGroups(int cnum,int uid, char *param,char *data,
1915                                  int mdrcnt,int mprcnt,
1916                                  char **rdata,char **rparam,
1917                                  int *rdata_len,int *rparam_len)
1918 {
1919   char *str1 = param+2;
1920   char *str2 = skip_string(str1,1);
1921   char *UserName = skip_string(str2,1);
1922   char *p = skip_string(UserName,1);
1923   int uLevel = SVAL(p,0);
1924   char *p2;
1925   int count=0;
1926
1927   *rparam_len = 8;
1928   *rparam = REALLOC(*rparam,*rparam_len);
1929
1930   /* check it's a supported varient */
1931   if (strcmp(str1,"zWrLeh") != 0) return False;
1932   switch( uLevel ) {
1933   case 0: p2 = "B21"; break;
1934   default: return False;
1935   }
1936   if (strcmp(p2,str2) != 0) return False;
1937
1938   *rdata_len = mdrcnt + 1024;
1939   *rdata = REALLOC(*rdata,*rdata_len);
1940
1941   SSVAL(*rparam,0,NERR_Success);
1942   SSVAL(*rparam,2,0);           /* converter word */
1943
1944   p = *rdata;
1945
1946   /* XXXX we need a real SAM database some day */
1947   strcpy(p,"Users"); p += 21; count++;
1948   strcpy(p,"Domain Users"); p += 21; count++;
1949   strcpy(p,"Guests"); p += 21; count++;
1950   strcpy(p,"Domain Guests"); p += 21; count++;
1951
1952   *rdata_len = PTR_DIFF(p,*rdata);
1953
1954   SSVAL(*rparam,4,count);       /* is this right?? */
1955   SSVAL(*rparam,6,count);       /* is this right?? */
1956
1957   return(True);
1958 }
1959
1960
1961 static BOOL api_WWkstaUserLogon(int cnum,int uid, char *param,char *data,
1962                                 int mdrcnt,int mprcnt,
1963                                 char **rdata,char **rparam,
1964                                 int *rdata_len,int *rparam_len)
1965 {
1966   char *str1 = param+2;
1967   char *str2 = skip_string(str1,1);
1968   char *p = skip_string(str2,1);
1969   int uLevel;
1970   struct pack_desc desc;
1971   char* name;
1972
1973   uLevel = SVAL(p,0);
1974   name = p + 2;
1975
1976   bzero(&desc,sizeof(desc));
1977
1978   DEBUG(3,("WWkstaUserLogon uLevel=%d name=%s\n",uLevel,name));
1979
1980   /* check it's a supported varient */
1981   if (strcmp(str1,"OOWb54WrLh") != 0) return False;
1982   if (uLevel != 1 || strcmp(str2,"WB21BWDWWDDDDDDDzzzD") != 0) return False;
1983   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
1984   desc.base = *rdata;
1985   desc.buflen = mdrcnt;
1986   desc.subformat = NULL;
1987   desc.format = str2;
1988
1989
1990
1991   if (init_package(&desc,1,0)) {
1992     PACKI(&desc,"W",0);         /* code */
1993     PACKS(&desc,"B21",name);    /* eff. name */
1994     PACKS(&desc,"B","");                /* pad */
1995     PACKI(&desc,"W",
1996           Connections[cnum].admin_user?USER_PRIV_ADMIN:USER_PRIV_USER);
1997     PACKI(&desc,"D",0);         /* auth flags XXX */
1998     PACKI(&desc,"W",0);         /* num logons */
1999     PACKI(&desc,"W",0);         /* bad pw count */
2000     PACKI(&desc,"D",-1);                /* last logon */
2001     PACKI(&desc,"D",-1);                /* last logoff */
2002     PACKI(&desc,"D",-1);                /* logoff time */
2003     PACKI(&desc,"D",-1);                /* kickoff time */
2004     PACKI(&desc,"D",0);         /* password age */
2005     PACKI(&desc,"D",0);         /* password can change */
2006     PACKI(&desc,"D",-1);                /* password must change */
2007     {
2008       fstring mypath;
2009       strcpy(mypath,"\\\\");
2010       strcat(mypath,local_machine);
2011       strupper(mypath);
2012       PACKS(&desc,"z",mypath); /* computer */
2013     }
2014     PACKS(&desc,"z",my_workgroup());/* domain */
2015     PACKS(&desc,"z",lp_logon_script());         /* script path */
2016     PACKI(&desc,"D",0);         /* reserved */
2017   }
2018
2019   *rdata_len = desc.usedlen;
2020   *rparam_len = 6;
2021   *rparam = REALLOC(*rparam,*rparam_len);
2022   SSVALS(*rparam,0,desc.errcode);
2023   SSVAL(*rparam,2,0);
2024   SSVAL(*rparam,4,desc.neededlen);
2025
2026   DEBUG(4,("WWkstaUserLogon: errorcode %d\n",desc.errcode));
2027   return(True);
2028 }
2029
2030
2031 /****************************************************************************
2032   api_WAccessGetUserPerms
2033   ****************************************************************************/
2034 static BOOL api_WAccessGetUserPerms(int cnum,int uid, char *param,char *data,
2035                                     int mdrcnt,int mprcnt,
2036                                     char **rdata,char **rparam,
2037                                     int *rdata_len,int *rparam_len)
2038 {
2039   char *str1 = param+2;
2040   char *str2 = skip_string(str1,1);
2041   char *user = skip_string(str2,1);
2042   char *resource = skip_string(user,1);
2043
2044   DEBUG(3,("WAccessGetUserPerms user=%s resource=%s\n",user,resource));
2045
2046   /* check it's a supported varient */
2047   if (strcmp(str1,"zzh") != 0) return False;
2048   if (strcmp(str2,"") != 0) return False;
2049
2050   *rparam_len = 6;
2051   *rparam = REALLOC(*rparam,*rparam_len);
2052   SSVALS(*rparam,0,0);          /* errorcode */
2053   SSVAL(*rparam,2,0);           /* converter word */
2054   SSVAL(*rparam,4,0x7f);        /* permission flags */
2055
2056   return(True);
2057 }
2058
2059 /****************************************************************************
2060   api_WPrintJobEnumerate
2061   ****************************************************************************/
2062 static BOOL api_WPrintJobGetInfo(int cnum,int uid, char *param,char *data,
2063                                  int mdrcnt,int mprcnt,
2064                                  char **rdata,char **rparam,
2065                                  int *rdata_len,int *rparam_len)
2066 {
2067   char *str1 = param+2;
2068   char *str2 = skip_string(str1,1);
2069   char *p = skip_string(str2,1);
2070   int uJobId = SVAL(p,0);
2071   int uLevel,cbBuf;
2072   int count;
2073   int i;
2074   int snum;
2075   int job;
2076   struct pack_desc desc;
2077   print_queue_struct *queue=NULL;
2078   print_status_struct status;
2079
2080   uLevel = SVAL(p,2);
2081   cbBuf = SVAL(p,4);
2082
2083   bzero(&desc,sizeof(desc));
2084   bzero(&status,sizeof(status));
2085
2086   DEBUG(3,("WPrintJobGetInfo uLevel=%d uJobId=0x%X\n",uLevel,uJobId));
2087
2088   /* check it's a supported varient */
2089   if (strcmp(str1,"WWrLh") != 0) return False;
2090   if (!check_printjob_info(&desc,uLevel,str2)) return False;
2091
2092   snum = (unsigned int)uJobId >> 8; /*## valid serice number??*/
2093   job = uJobId & 0xFF;
2094
2095   if (snum < 0 || !VALID_SNUM(snum)) return(False);
2096
2097   count = get_printqueue(snum,cnum,&queue,&status);
2098   for (i = 0; i < count; i++) {
2099     if ((queue[i].job % 0xFF) == job) break;
2100   }
2101   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2102   desc.base = *rdata;
2103   desc.buflen = mdrcnt;
2104
2105   if (init_package(&desc,1,0)) {
2106     if (i < count) {
2107       fill_printjob_info(cnum,snum,uLevel,&desc,&queue[i],i);
2108       *rdata_len = desc.usedlen;
2109     }
2110     else {
2111       desc.errcode = NERR_JobNotFound;
2112       *rdata_len = 0;
2113     }
2114   }
2115
2116   *rparam_len = 6;
2117   *rparam = REALLOC(*rparam,*rparam_len);
2118   SSVALS(*rparam,0,desc.errcode);
2119   SSVAL(*rparam,2,0);
2120   SSVAL(*rparam,4,desc.neededlen);
2121
2122   if (queue) free(queue);
2123
2124   DEBUG(4,("WPrintJobGetInfo: errorcode %d\n",desc.errcode));
2125   return(True);
2126 }
2127
2128 static BOOL api_WPrintJobEnumerate(int cnum,int uid, char *param,char *data,
2129                                    int mdrcnt,int mprcnt,
2130                                    char **rdata,char **rparam,
2131                                    int *rdata_len,int *rparam_len)
2132 {
2133   char *str1 = param+2;
2134   char *str2 = skip_string(str1,1);
2135   char *p = skip_string(str2,1);
2136   char* name = p;
2137   int uLevel,cbBuf;
2138   int count;
2139   int i, succnt=0;
2140   int snum;
2141   struct pack_desc desc;
2142   print_queue_struct *queue=NULL;
2143   print_status_struct status;
2144
2145   bzero(&desc,sizeof(desc));
2146   bzero(&status,sizeof(status));
2147
2148   p = skip_string(p,1);
2149   uLevel = SVAL(p,0);
2150   cbBuf = SVAL(p,2);
2151
2152   DEBUG(3,("WPrintJobEnumerate uLevel=%d name=%s\n",uLevel,name));
2153
2154   /* check it's a supported varient */
2155   if (strcmp(str1,"zWrLeh") != 0) return False;
2156   if (uLevel > 2) return False; /* defined only for uLevel 0,1,2 */
2157   if (!check_printjob_info(&desc,uLevel,str2)) return False;
2158
2159   snum = lp_servicenumber(name);
2160   if (snum < 0 && pcap_printername_ok(name,NULL)) {
2161     int pnum = lp_servicenumber(PRINTERS_NAME);
2162     if (pnum >= 0) {
2163       lp_add_printer(name,pnum);
2164       snum = lp_servicenumber(name);
2165     }
2166   }
2167
2168   if (snum < 0 || !VALID_SNUM(snum)) return(False);
2169
2170   count = get_printqueue(snum,cnum,&queue,&status);
2171   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2172   desc.base = *rdata;
2173   desc.buflen = mdrcnt;
2174
2175   if (init_package(&desc,count,0)) {
2176     succnt = 0;
2177     for (i = 0; i < count; i++) {
2178       fill_printjob_info(cnum,snum,uLevel,&desc,&queue[i],i);
2179       if (desc.errcode == NERR_Success) succnt = i+1;
2180     }
2181   }
2182
2183   *rdata_len = desc.usedlen;
2184
2185   *rparam_len = 8;
2186   *rparam = REALLOC(*rparam,*rparam_len);
2187   SSVALS(*rparam,0,desc.errcode);
2188   SSVAL(*rparam,2,0);
2189   SSVAL(*rparam,4,succnt);
2190   SSVAL(*rparam,6,count);
2191
2192   if (queue) free(queue);
2193
2194   DEBUG(4,("WPrintJobEnumerate: errorcode %d\n",desc.errcode));
2195   return(True);
2196 }
2197
2198 static int check_printdest_info(struct pack_desc* desc,
2199                                 int uLevel, char* id)
2200 {
2201   desc->subformat = NULL;
2202   switch( uLevel ) {
2203   case 0: desc->format = "B9"; break;
2204   case 1: desc->format = "B9B21WWzW"; break;
2205   case 2: desc->format = "z"; break;
2206   case 3: desc->format = "zzzWWzzzWW"; break;
2207   default: return False;
2208   }
2209   if (strcmp(desc->format,id) != 0) return False;
2210   return True;
2211 }
2212
2213 static void fill_printdest_info(int cnum, int snum, int uLevel,
2214                                 struct pack_desc* desc)
2215 {
2216   char buf[100];
2217   strcpy(buf,SERVICE(snum));
2218   strupper(buf);
2219   if (uLevel <= 1) {
2220     PACKS(desc,"B9",buf);       /* szName */
2221     if (uLevel == 1) {
2222       PACKS(desc,"B21","");     /* szUserName */
2223       PACKI(desc,"W",0);                /* uJobId */
2224       PACKI(desc,"W",0);                /* fsStatus */
2225       PACKS(desc,"z","");       /* pszStatus */
2226       PACKI(desc,"W",0);                /* time */
2227     }
2228   }
2229   if (uLevel == 2 || uLevel == 3) {
2230     PACKS(desc,"z",buf);                /* pszPrinterName */
2231     if (uLevel == 3) {
2232       PACKS(desc,"z","");       /* pszUserName */
2233       PACKS(desc,"z","");       /* pszLogAddr */
2234       PACKI(desc,"W",0);                /* uJobId */
2235       PACKI(desc,"W",0);                /* fsStatus */
2236       PACKS(desc,"z","");       /* pszStatus */
2237       PACKS(desc,"z","");       /* pszComment */
2238       PACKS(desc,"z","NULL"); /* pszDrivers */
2239       PACKI(desc,"W",0);                /* time */
2240       PACKI(desc,"W",0);                /* pad1 */
2241     }
2242   }
2243 }
2244
2245 static BOOL api_WPrintDestGetInfo(int cnum,int uid, char *param,char *data,
2246                                   int mdrcnt,int mprcnt,
2247                                   char **rdata,char **rparam,
2248                                   int *rdata_len,int *rparam_len)
2249 {
2250   char *str1 = param+2;
2251   char *str2 = skip_string(str1,1);
2252   char *p = skip_string(str2,1);
2253   char* PrinterName = p;
2254   int uLevel,cbBuf;
2255   struct pack_desc desc;
2256   int snum;
2257
2258   bzero(&desc,sizeof(desc));
2259
2260   p = skip_string(p,1);
2261   uLevel = SVAL(p,0);
2262   cbBuf = SVAL(p,2);
2263
2264   DEBUG(3,("WPrintDestGetInfo uLevel=%d PrinterName=%s\n",uLevel,PrinterName));
2265
2266   /* check it's a supported varient */
2267   if (strcmp(str1,"zWrLh") != 0) return False;
2268   if (!check_printdest_info(&desc,uLevel,str2)) return False;
2269
2270   snum = lp_servicenumber(PrinterName);
2271   if (snum < 0 && pcap_printername_ok(PrinterName,NULL)) {
2272     int pnum = lp_servicenumber(PRINTERS_NAME);
2273     if (pnum >= 0) {
2274       lp_add_printer(PrinterName,pnum);
2275       snum = lp_servicenumber(PrinterName);
2276     }
2277   }
2278
2279   if (snum < 0) {
2280     *rdata_len = 0;
2281     desc.errcode = NERR_DestNotFound;
2282     desc.neededlen = 0;
2283   }
2284   else {
2285     if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2286     desc.base = *rdata;
2287     desc.buflen = mdrcnt;
2288     if (init_package(&desc,1,0)) {
2289       fill_printdest_info(cnum,snum,uLevel,&desc);
2290     }
2291     *rdata_len = desc.usedlen;
2292   }
2293
2294   *rparam_len = 6;
2295   *rparam = REALLOC(*rparam,*rparam_len);
2296   SSVALS(*rparam,0,desc.errcode);
2297   SSVAL(*rparam,2,0);
2298   SSVAL(*rparam,4,desc.neededlen);
2299
2300   DEBUG(4,("WPrintDestGetInfo: errorcode %d\n",desc.errcode));
2301   return(True);
2302 }
2303
2304 static BOOL api_WPrintDestEnum(int cnum,int uid, char *param,char *data,
2305                                int mdrcnt,int mprcnt,
2306                                char **rdata,char **rparam,
2307                                int *rdata_len,int *rparam_len)
2308 {
2309   char *str1 = param+2;
2310   char *str2 = skip_string(str1,1);
2311   char *p = skip_string(str2,1);
2312   int uLevel,cbBuf;
2313   int queuecnt;
2314   int i, n, succnt=0;
2315   struct pack_desc desc;
2316   int services = lp_numservices();
2317
2318   bzero(&desc,sizeof(desc));
2319
2320   uLevel = SVAL(p,0);
2321   cbBuf = SVAL(p,2);
2322
2323   DEBUG(3,("WPrintDestEnum uLevel=%d\n",uLevel));
2324
2325   /* check it's a supported varient */
2326   if (strcmp(str1,"WrLeh") != 0) return False;
2327   if (!check_printdest_info(&desc,uLevel,str2)) return False;
2328
2329   queuecnt = 0;
2330   for (i = 0; i < services; i++)
2331     if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i))
2332       queuecnt++;
2333
2334   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2335   desc.base = *rdata;
2336   desc.buflen = mdrcnt;
2337   if (init_package(&desc,queuecnt,0)) {
2338     succnt = 0;
2339     n = 0;
2340     for (i = 0; i < services; i++) {
2341       if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
2342         fill_printdest_info(cnum,i,uLevel,&desc);
2343         n++;
2344         if (desc.errcode == NERR_Success) succnt = n;
2345       }
2346     }
2347   }
2348
2349   *rdata_len = desc.usedlen;
2350
2351   *rparam_len = 8;
2352   *rparam = REALLOC(*rparam,*rparam_len);
2353   SSVALS(*rparam,0,desc.errcode);
2354   SSVAL(*rparam,2,0);
2355   SSVAL(*rparam,4,succnt);
2356   SSVAL(*rparam,6,queuecnt);
2357
2358   DEBUG(4,("WPrintDestEnumerate: errorcode %d\n",desc.errcode));
2359   return(True);
2360 }
2361
2362 static BOOL api_WPrintDriverEnum(int cnum,int uid, char *param,char *data,
2363                                  int mdrcnt,int mprcnt,
2364                                  char **rdata,char **rparam,
2365                                  int *rdata_len,int *rparam_len)
2366 {
2367   char *str1 = param+2;
2368   char *str2 = skip_string(str1,1);
2369   char *p = skip_string(str2,1);
2370   int uLevel,cbBuf;
2371   int succnt;
2372   struct pack_desc desc;
2373
2374   bzero(&desc,sizeof(desc));
2375
2376   uLevel = SVAL(p,0);
2377   cbBuf = SVAL(p,2);
2378
2379   DEBUG(3,("WPrintDriverEnum uLevel=%d\n",uLevel));
2380
2381   /* check it's a supported varient */
2382   if (strcmp(str1,"WrLeh") != 0) return False;
2383   if (uLevel != 0 || strcmp(str2,"B41") != 0) return False;
2384
2385   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2386   desc.base = *rdata;
2387   desc.buflen = mdrcnt;
2388   if (init_package(&desc,1,0)) {
2389     PACKS(&desc,"B41","NULL");
2390   }
2391
2392   succnt = (desc.errcode == NERR_Success ? 1 : 0);
2393
2394   *rdata_len = desc.usedlen;
2395
2396   *rparam_len = 8;
2397   *rparam = REALLOC(*rparam,*rparam_len);
2398   SSVALS(*rparam,0,desc.errcode);
2399   SSVAL(*rparam,2,0);
2400   SSVAL(*rparam,4,succnt);
2401   SSVAL(*rparam,6,1);
2402
2403   DEBUG(4,("WPrintDriverEnum: errorcode %d\n",desc.errcode));
2404   return(True);
2405 }
2406
2407 static BOOL api_WPrintQProcEnum(int cnum,int uid, char *param,char *data,
2408                                 int mdrcnt,int mprcnt,
2409                                 char **rdata,char **rparam,
2410                                 int *rdata_len,int *rparam_len)
2411 {
2412   char *str1 = param+2;
2413   char *str2 = skip_string(str1,1);
2414   char *p = skip_string(str2,1);
2415   int uLevel,cbBuf;
2416   int succnt;
2417   struct pack_desc desc;
2418
2419   bzero(&desc,sizeof(desc));
2420
2421   uLevel = SVAL(p,0);
2422   cbBuf = SVAL(p,2);
2423
2424   DEBUG(3,("WPrintQProcEnum uLevel=%d\n",uLevel));
2425
2426   /* check it's a supported varient */
2427   if (strcmp(str1,"WrLeh") != 0) return False;
2428   if (uLevel != 0 || strcmp(str2,"B13") != 0) return False;
2429
2430   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2431   desc.base = *rdata;
2432   desc.buflen = mdrcnt;
2433   desc.format = str2;
2434   if (init_package(&desc,1,0)) {
2435     PACKS(&desc,"B13","lpd");
2436   }
2437
2438   succnt = (desc.errcode == NERR_Success ? 1 : 0);
2439
2440   *rdata_len = desc.usedlen;
2441
2442   *rparam_len = 8;
2443   *rparam = REALLOC(*rparam,*rparam_len);
2444   SSVALS(*rparam,0,desc.errcode);
2445   SSVAL(*rparam,2,0);
2446   SSVAL(*rparam,4,succnt);
2447   SSVAL(*rparam,6,1);
2448
2449   DEBUG(4,("WPrintQProcEnum: errorcode %d\n",desc.errcode));
2450   return(True);
2451 }
2452
2453 static BOOL api_WPrintPortEnum(int cnum,int uid, char *param,char *data,
2454                                int mdrcnt,int mprcnt,
2455                                char **rdata,char **rparam,
2456                                int *rdata_len,int *rparam_len)
2457 {
2458   char *str1 = param+2;
2459   char *str2 = skip_string(str1,1);
2460   char *p = skip_string(str2,1);
2461   int uLevel,cbBuf;
2462   int succnt;
2463   struct pack_desc desc;
2464
2465   bzero(&desc,sizeof(desc));
2466
2467   uLevel = SVAL(p,0);
2468   cbBuf = SVAL(p,2);
2469
2470   DEBUG(3,("WPrintPortEnum uLevel=%d\n",uLevel));
2471
2472   /* check it's a supported varient */
2473   if (strcmp(str1,"WrLeh") != 0) return False;
2474   if (uLevel != 0 || strcmp(str2,"B9") != 0) return False;
2475
2476   if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
2477   bzero(&desc,sizeof(desc));
2478   desc.base = *rdata;
2479   desc.buflen = mdrcnt;
2480   desc.format = str2;
2481   if (init_package(&desc,1,0)) {
2482     PACKS(&desc,"B13","lp0");
2483   }
2484
2485   succnt = (desc.errcode == NERR_Success ? 1 : 0);
2486
2487   *rdata_len = desc.usedlen;
2488
2489   *rparam_len = 8;
2490   *rparam = REALLOC(*rparam,*rparam_len);
2491   SSVALS(*rparam,0,desc.errcode);
2492   SSVAL(*rparam,2,0);
2493   SSVAL(*rparam,4,succnt);
2494   SSVAL(*rparam,6,1);
2495
2496   DEBUG(4,("WPrintPortEnum: errorcode %d\n",desc.errcode));
2497   return(True);
2498 }
2499
2500 /****************************************************************************
2501   the buffer was too small
2502   ****************************************************************************/
2503 static BOOL api_TooSmall(int cnum,int uid, char *param,char *data,
2504                          int mdrcnt,int mprcnt,
2505                          char **rdata,char **rparam,
2506                          int *rdata_len,int *rparam_len)
2507 {
2508   *rparam_len = MIN(*rparam_len,mprcnt);
2509   *rparam = REALLOC(*rparam,*rparam_len);
2510
2511   *rdata_len = 0;
2512
2513   SSVAL(*rparam,0,NERR_BufTooSmall);
2514
2515   DEBUG(3,("Supplied buffer too small in API command\n"));
2516
2517   return(True);
2518 }
2519
2520
2521 /****************************************************************************
2522   the request is not supported
2523   ****************************************************************************/
2524 static BOOL api_Unsupported(int cnum,int uid, char *param,char *data,
2525                             int mdrcnt,int mprcnt,
2526                             char **rdata,char **rparam,
2527                             int *rdata_len,int *rparam_len)
2528 {
2529   *rparam_len = 4;
2530   *rparam = REALLOC(*rparam,*rparam_len);
2531
2532   *rdata_len = 0;
2533
2534   SSVAL(*rparam,0,NERR_notsupported);
2535   SSVAL(*rparam,2,0);           /* converter word */
2536
2537   DEBUG(3,("Unsupported API command\n"));
2538
2539   return(True);
2540 }
2541
2542
2543
2544
2545 struct
2546 {
2547   char *name;
2548   int id;
2549   BOOL (*fn)();
2550   int flags;
2551 } api_commands[] = {
2552   {"RNetShareEnum",     0,      api_RNetShareEnum,0},
2553   {"RNetShareGetInfo",  1,      api_RNetShareGetInfo,0},
2554   {"RNetServerGetInfo", 13,     api_RNetServerGetInfo,0},
2555   {"RNetUserGetInfo",   56,     api_RNetUserGetInfo,0},
2556   {"NetUserGetGroups",  59,     api_NetUserGetGroups,0},
2557   {"NetWkstaGetInfo",   63,     api_NetWkstaGetInfo,0},
2558   {"DosPrintQEnum",     69,     api_DosPrintQEnum,0},
2559   {"DosPrintQGetInfo",  70,     api_DosPrintQGetInfo,0},
2560   {"WPrintJobEnumerate",76,     api_WPrintJobEnumerate,0},
2561   {"WPrintJobGetInfo",  77,     api_WPrintJobGetInfo,0},
2562   {"RDosPrintJobDel",   81,     api_RDosPrintJobDel,0},
2563   {"RDosPrintJobPause", 82,     api_RDosPrintJobDel,0},
2564   {"RDosPrintJobResume",83,     api_RDosPrintJobDel,0},
2565   {"WPrintDestEnum",    84,     api_WPrintDestEnum,0},
2566   {"WPrintDestGetInfo", 85,     api_WPrintDestGetInfo,0},
2567   {"NetRemoteTOD",      91,     api_NetRemoteTOD,0},
2568   {"WPrintQueuePurge",  103,    api_WPrintQueuePurge,0},
2569   {"NetServerEnum",     104,    api_RNetServerEnum,0},
2570   {"WAccessGetUserPerms",105,   api_WAccessGetUserPerms,0},
2571   {"SetUserPassword",   115,    api_SetUserPassword,0},
2572   {"WWkstaUserLogon",   132,    api_WWkstaUserLogon,0},
2573   {"PrintJobInfo",      147,    api_PrintJobInfo,0},
2574   {"WPrintDriverEnum",  205,    api_WPrintDriverEnum,0},
2575   {"WPrintQProcEnum",   206,    api_WPrintQProcEnum,0},
2576   {"WPrintPortEnum",    207,    api_WPrintPortEnum,0},
2577   {NULL,                -1,     api_Unsupported,0}};
2578
2579
2580 /****************************************************************************
2581   handle remote api calls
2582   ****************************************************************************/
2583 static int api_reply(int cnum,int uid,char *outbuf,char *data,char *params,
2584                      int tdscnt,int tpscnt,int mdrcnt,int mprcnt)
2585 {
2586   int api_command = SVAL(params,0);
2587   char *rdata = NULL;
2588   char *rparam = NULL;
2589   int rdata_len = 0;
2590   int rparam_len = 0;
2591   BOOL reply=False;
2592   int i;
2593
2594   DEBUG(3,("Got API command %d of form <%s> <%s> (tdscnt=%d,tpscnt=%d,mdrcnt=%d,mprcnt=%d)\n",
2595            api_command,params+2,skip_string(params+2,1),
2596            tdscnt,tpscnt,mdrcnt,mprcnt));
2597
2598   for (i=0;api_commands[i].name;i++)
2599     if (api_commands[i].id == api_command && api_commands[i].fn)
2600       {
2601         DEBUG(3,("Doing %s\n",api_commands[i].name));
2602         break;
2603       }
2604
2605   rdata = (char *)malloc(1024); if (rdata) bzero(rdata,1024);
2606   rparam = (char *)malloc(1024); if (rparam) bzero(rparam,1024);
2607
2608   reply = api_commands[i].fn(cnum,uid,params,data,mdrcnt,mprcnt,
2609                              &rdata,&rparam,&rdata_len,&rparam_len);
2610
2611
2612   if (rdata_len > mdrcnt ||
2613       rparam_len > mprcnt)
2614     {
2615       reply = api_TooSmall(cnum,uid,params,data,mdrcnt,mprcnt,
2616                            &rdata,&rparam,&rdata_len,&rparam_len);
2617     }
2618
2619
2620   /* if we get False back then it's actually unsupported */
2621   if (!reply)
2622     api_Unsupported(cnum,uid,params,data,mdrcnt,mprcnt,
2623                     &rdata,&rparam,&rdata_len,&rparam_len);
2624
2625
2626
2627   /* now send the reply */
2628   send_trans_reply(outbuf,rdata,rparam,NULL,rdata_len,rparam_len,0);
2629
2630   if (rdata)
2631     free(rdata);
2632   if (rparam)
2633     free(rparam);
2634
2635   return(-1);
2636 }
2637
2638 /****************************************************************************
2639   handle named pipe commands
2640   ****************************************************************************/
2641 static int named_pipe(int cnum,int uid, char *outbuf,char *name,
2642                       uint16 *setup,char *data,char *params,
2643                       int suwcnt,int tdscnt,int tpscnt,
2644                       int msrcnt,int mdrcnt,int mprcnt)
2645 {
2646
2647   if (strequal(name,"LANMAN"))
2648     return(api_reply(cnum,uid,outbuf,data,params,tdscnt,tpscnt,mdrcnt,mprcnt));
2649
2650   DEBUG(3,("named pipe command on <%s> 0x%X setup1=%d\n",
2651            name,(int)setup[0],(int)setup[1]));
2652
2653   return(0);
2654 }
2655
2656
2657 /****************************************************************************
2658   reply to a SMBtrans
2659   ****************************************************************************/
2660 int reply_trans(char *inbuf,char *outbuf)
2661 {
2662   fstring name;
2663
2664   char *data=NULL,*params=NULL;
2665   uint16 *setup=NULL;
2666
2667   int outsize = 0;
2668   int cnum = SVAL(inbuf,smb_tid);
2669   int uid = SVAL(inbuf,smb_uid);
2670
2671   int tpscnt = SVAL(inbuf,smb_vwv0);
2672   int tdscnt = SVAL(inbuf,smb_vwv1);
2673   int mprcnt = SVAL(inbuf,smb_vwv2);
2674   int mdrcnt = SVAL(inbuf,smb_vwv3);
2675   int msrcnt = CVAL(inbuf,smb_vwv4);
2676   BOOL close_on_completion = BITSETW(inbuf+smb_vwv5,0);
2677   BOOL one_way = BITSETW(inbuf+smb_vwv5,1);
2678   int pscnt = SVAL(inbuf,smb_vwv9);
2679   int psoff = SVAL(inbuf,smb_vwv10);
2680   int dscnt = SVAL(inbuf,smb_vwv11);
2681   int dsoff = SVAL(inbuf,smb_vwv12);
2682   int suwcnt = CVAL(inbuf,smb_vwv13);
2683
2684   StrnCpy(name,smb_buf(inbuf),sizeof(name)-1);
2685
2686   if (tdscnt)
2687     {
2688       data = (char *)malloc(tdscnt);
2689       memcpy(data,smb_base(inbuf)+dsoff,dscnt);
2690     }
2691   if (tpscnt)
2692     {
2693       params = (char *)malloc(tpscnt);
2694       memcpy(params,smb_base(inbuf)+psoff,pscnt);
2695     }
2696
2697   if (suwcnt)
2698     {
2699       int i;
2700       setup = (uint16 *)malloc(suwcnt*sizeof(setup[0]));
2701       for (i=0;i<suwcnt;i++)
2702         setup[i] = SVAL(inbuf,smb_vwv14+i*SIZEOFWORD);
2703     }
2704
2705
2706   if (pscnt < tpscnt || dscnt < tdscnt)
2707     {
2708       /* We need to send an interim response then receive the rest
2709          of the parameter/data bytes */
2710       outsize = set_message(outbuf,0,0,True);
2711       show_msg(outbuf);
2712       send_smb(Client,outbuf);
2713     }
2714
2715   /* receive the rest of the trans packet */
2716   while (pscnt < tpscnt || dscnt < tdscnt)
2717     {
2718       int pcnt,poff,dcnt,doff,pdisp,ddisp;
2719
2720       receive_smb(Client,inbuf, 0);
2721       show_msg(inbuf);
2722
2723       /* Ensure this is still a trans packet (sanity check) */
2724       if(CVAL(inbuf, smb_com) != SMBtrans)
2725         {
2726           DEBUG(2,("Invalid secondary trans2 packet\n"));
2727           if (params) free(params);
2728           if (data) free(data);
2729           if (setup) free(setup);
2730           return(ERROR(ERRSRV,ERRerror));
2731         }
2732
2733       tpscnt = SVAL(inbuf,smb_vwv0);
2734       tdscnt = SVAL(inbuf,smb_vwv1);
2735
2736       pcnt = SVAL(inbuf,smb_vwv2);
2737       poff = SVAL(inbuf,smb_vwv3);
2738       pdisp = SVAL(inbuf,smb_vwv4);
2739
2740       dcnt = SVAL(inbuf,smb_vwv5);
2741       doff = SVAL(inbuf,smb_vwv6);
2742       ddisp = SVAL(inbuf,smb_vwv7);
2743
2744       pscnt += pcnt;
2745       dscnt += dcnt;
2746
2747       if (pcnt)
2748         memcpy(params+pdisp,smb_base(inbuf)+poff,pcnt);
2749       if (dcnt)
2750         memcpy(data+ddisp,smb_base(inbuf)+doff,dcnt);
2751     }
2752
2753
2754   DEBUG(3,("trans <%s> data=%d params=%d setup=%d\n",name,tdscnt,tpscnt,suwcnt));
2755
2756
2757   if (strncmp(name,"\\PIPE\\",strlen("\\PIPE\\")) == 0)
2758     outsize = named_pipe(cnum,uid,outbuf,name+strlen("\\PIPE\\"),setup,data,params,
2759                          suwcnt,tdscnt,tpscnt,msrcnt,mdrcnt,mprcnt);
2760
2761
2762   if (data) free(data);
2763   if (params) free(params);
2764   if (setup) free(setup);
2765
2766   if (close_on_completion)
2767     close_cnum(cnum,uid);
2768
2769   if (one_way)
2770     return(-1);
2771
2772   if (outsize == 0)
2773     return(ERROR(ERRSRV,ERRnosupport));
2774
2775   return(outsize);
2776 }
2777
2778