source/smbd/lanman.c

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