source3/printing/printing.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    printing routines
   5    Copyright (C) Andrew Tridgell 1992-1995
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23 #include "loadparm.h"
  24 extern int DEBUGLEVEL;
  25 extern connection_struct Connections[];
  26 extern files_struct Files[];
  27
  28 static BOOL * lpq_cache_reset=NULL;
  29
  30 static int check_lpq_cache(int snum) {
  31   static int lpq_caches=0;
  32
  33   if (lpq_caches <= snum) {
  34       BOOL * p;
  35       p = (BOOL *) Realloc(lpq_cache_reset,(snum+1)*sizeof(BOOL));
  36       if (p) {
  37          lpq_cache_reset=p;
  38          lpq_caches = snum+1;
  39       }
  40   }
  41   return lpq_caches;
  42 }
  43
  44 void lpq_reset(int snum)
  45 {
  46   if (check_lpq_cache(snum) > snum) lpq_cache_reset[snum]=True;
  47 }
  48
  49
  50 /****************************************************************************
  51 Build the print command in the supplied buffer. This means getting the
  52 print command for the service and inserting the printer name and the
  53 print file name. Return NULL on error, else the passed buffer pointer.
  54 ****************************************************************************/
  55 static char *build_print_command(int cnum, char *command, char *syscmd, char *filename1)
  56 {
  57   int snum = SNUM(cnum);
  58   char *tstr;
  59   pstring filename;
  60
  61   /* get the print command for the service. */
  62   tstr = command;
  63   if (!syscmd || !tstr) {
  64     DEBUG(0,("No print command for service `%s'\n", SERVICE(snum)));
  65     return (NULL);
  66   }
  67
  68   /* copy the command into the buffer for extensive meddling. */
  69   StrnCpy(syscmd, tstr, sizeof(pstring) - 1);
  70
  71   /* look for "%s" in the string. If there is no %s, we cannot print. */
  72   if (!strstr(syscmd, "%s") && !strstr(syscmd, "%f")) {
  73     DEBUG(2,("WARNING! No placeholder for the filename in the print command for service %s!\n", SERVICE(snum)));
  74   }
  75
  76   if (strstr(syscmd,"%s")) {
  77     int iOffset = strstr(syscmd, "%s") - syscmd;
  78
  79     /* construct the full path for the filename, shouldn't be necessary unless
  80        the subshell causes a "cd" to be executed.
  81        Only use the full path if there isn't a / preceding the %s */
  82     if (iOffset==0 || syscmd[iOffset-1] != '/') {
  83       StrnCpy(filename,Connections[cnum].connectpath,sizeof(filename)-1);
  84       trim_string(filename,"","/");
  85       strcat(filename,"/");
  86       strcat(filename,filename1);
  87     }
  88     else
  89       strcpy(filename,filename1);
  90
  91     string_sub(syscmd, "%s", filename);
  92   }
  93
  94   string_sub(syscmd, "%f", filename1);
  95
  96   /* Does the service have a printername? If not, make a fake and empty    */
  97   /* printer name. That way a %p is treated sanely if no printer */
  98   /* name was specified to replace it. This eventuality is logged.         */
  99   tstr = PRINTERNAME(snum);
 100   if (tstr == NULL || tstr[0] == '\0') {
 101     DEBUG(3,( "No printer name - using %s.\n", SERVICE(snum)));
 102     tstr = SERVICE(snum);
 103   }
 104
 105   string_sub(syscmd, "%p", tstr);
 106
 107   standard_sub(cnum,syscmd);
 108
 109   return (syscmd);
 110 }
 111
 112
 113 /****************************************************************************
 114 print a file - called on closing the file
 115 ****************************************************************************/
 116 void print_file(int fnum)
 117 {
 118   pstring syscmd;
 119   int cnum = Files[fnum].cnum;
 120   int snum=SNUM(cnum);
 121   char *tempstr;
 122
 123   *syscmd = 0;
 124
 125   if (file_size(Files[fnum].name) <= 0) {
 126     DEBUG(3,("Discarding null print job %s\n",Files[fnum].name));
 127     sys_unlink(Files[fnum].name);
 128     return;
 129   }
 130
 131   tempstr = build_print_command(cnum, PRINTCOMMAND(snum), syscmd, Files[fnum].name);
 132   if (tempstr != NULL)
 133     {
 134       int ret = smbrun(syscmd,NULL);
 135       DEBUG(3,("Running the command `%s' gave %d\n",syscmd,ret));
 136     }
 137   else
 138     DEBUG(0,("Null print command?\n"));
 139
 140   lpq_reset(snum);
 141 }
 142
 143 static char *Months[13] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 144                               "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "Err"};
 145
 146
 147 /*******************************************************************
 148 process time fields
 149 ********************************************************************/
 150 static time_t EntryTime(string tok[], int ptr, int count, int minimum)
 151 {
 152   time_t jobtime;
 153
 154   jobtime = time(NULL);         /* default case: take current time */
 155   if (count >= minimum) {
 156     struct tm *t;
 157     int i, day, hour, min, sec;
 158     char   *c;
 159
 160     for (i=0; i<13; i++) if (!strncmp(tok[ptr], Months[i],3)) break; /* Find month */
 161     if (i<12) {
 162       t = localtime(&jobtime);
 163       day = atoi(tok[ptr+1]);
 164       c=(char *)(tok[ptr+2]);
 165       *(c+2)=0;
 166       hour = atoi(c);
 167       *(c+5)=0;
 168       min = atoi(c+3);
 169       if(*(c+6) != 0)sec = atoi(c+6);
 170       else  sec=0;
 171
 172       if ((t->tm_mon < i)||
 173           ((t->tm_mon == i)&&
 174            ((t->tm_mday < day)||
 175             ((t->tm_mday == day)&&
 176              (t->tm_hour*60+t->tm_min < hour*60+min)))))
 177         t->tm_year--;           /* last year's print job */
 178
 179       t->tm_mon = i;
 180       t->tm_mday = day;
 181       t->tm_hour = hour;
 182       t->tm_min = min;
 183       t->tm_sec = sec;
 184       jobtime = mktime(t);
 185     }
 186   }
 187   return jobtime;
 188 }
 189
 190
 191 /****************************************************************************
 192 parse a lpq line
 193
 194 here is an example of lpq output under bsd
 195
 196 Warning: no daemon present
 197 Rank   Owner      Job  Files                                 Total Size
 198 1st    tridge     148  README                                8096 bytes
 199
 200 here is an example of lpq output under osf/1
 201
 202 Warning: no daemon present
 203 Rank   Pri Owner      Job  Files                             Total Size
 204 1st    0   tridge     148  README                            8096 bytes
 205 ****************************************************************************/
 206 static BOOL parse_lpq_bsd(char *line,print_queue_struct *buf,BOOL first)
 207 {
 208 #ifdef  OSF1
 209 #define RANKTOK 0
 210 #define PRIOTOK 1
 211 #define USERTOK 2
 212 #define JOBTOK  3
 213 #define FILETOK 4
 214 #define TOTALTOK 5
 215 #define NTOK    6
 216 #else   /* OSF1 */
 217 #define RANKTOK 0
 218 #define USERTOK 1
 219 #define JOBTOK  2
 220 #define FILETOK 3
 221 #define TOTALTOK 4
 222 #define NTOK    5
 223 #endif  /* OSF1 */
 224
 225   string tok[NTOK];
 226   int count=0;
 227
 228 #ifdef  OSF1
 229   int length;
 230   length = strlen(line);
 231   if (line[length-3] == ':')
 232         return(False);
 233 #endif  /* OSF1 */
 234
 235   /* handle the case of "(standard input)" as a filename */
 236   string_sub(line,"standard input","STDIN");
 237   string_sub(line,"(","\"");
 238   string_sub(line,")","\"");
 239
 240   for (count=0; count<NTOK && next_token(&line,tok[count],NULL); count++) ;
 241
 242   /* we must get NTOK tokens */
 243   if (count < NTOK)
 244     return(False);
 245
 246   /* the Job and Total columns must be integer */
 247   if (!isdigit(*tok[JOBTOK]) || !isdigit(*tok[TOTALTOK])) return(False);
 248
 249   /* if the fname contains a space then use STDIN */
 250   if (strchr(tok[FILETOK],' '))
 251     strcpy(tok[FILETOK],"STDIN");
 252
 253   /* only take the last part of the filename */
 254   {
 255     string tmp;
 256     char *p = strrchr(tok[FILETOK],'/');
 257     if (p)
 258       {
 259         strcpy(tmp,p+1);
 260         strcpy(tok[FILETOK],tmp);
 261       }
 262   }
 263
 264
 265   buf->job = atoi(tok[JOBTOK]);
 266   buf->size = atoi(tok[TOTALTOK]);
 267   buf->status = strequal(tok[RANKTOK],"active")?LPQ_PRINTING:LPQ_QUEUED;
 268   buf->time = time(NULL);
 269   StrnCpy(buf->user,tok[USERTOK],sizeof(buf->user)-1);
 270   StrnCpy(buf->file,tok[FILETOK],sizeof(buf->file)-1);
 271 #ifdef PRIOTOK
 272   buf->priority = atoi(tok[PRIOTOK]);
 273 #else
 274   buf->priority = 1;
 275 #endif
 276   return(True);
 277 }
 278
 279
 280
 281 /*******************************************************************
 282 parse lpq on an aix system
 283
 284 Queue   Dev   Status    Job Files              User         PP %   Blks  Cp Rnk
 285 ------- ----- --------- --- ------------------ ---------- ---- -- ----- --- ---
 286 lazer   lazer READY
 287 lazer   lazer RUNNING   537 6297doc.A          kvintus@IE    0 10  2445   1   1
 288               QUEUED    538 C.ps               root@IEDVB           124   1   2
 289               QUEUED    539 E.ps               root@IEDVB            28   1   3
 290               QUEUED    540 L.ps               root@IEDVB           172   1   4
 291               QUEUED    541 P.ps               root@IEDVB            22   1   5
 292 ********************************************************************/
 293 static BOOL parse_lpq_aix(char *line,print_queue_struct *buf,BOOL first)
 294 {
 295   string tok[11];
 296   int count=0;
 297
 298   /* handle the case of "(standard input)" as a filename */
 299   string_sub(line,"standard input","STDIN");
 300   string_sub(line,"(","\"");
 301   string_sub(line,")","\"");
 302
 303   for (count=0; count<10 && next_token(&line,tok[count],NULL); count++) ;
 304
 305   /* we must get 6 tokens */
 306   if (count < 10)
 307   {
 308       if ((count == 7) && (strcmp(tok[0],"QUEUED") == 0))
 309       {
 310           /* the 2nd and 5th columns must be integer */
 311           if (!isdigit(*tok[1]) || !isdigit(*tok[4])) return(False);
 312           buf->size = atoi(tok[4]) * 1024;
 313           /* if the fname contains a space then use STDIN */
 314           if (strchr(tok[2],' '))
 315             strcpy(tok[2],"STDIN");
 316
 317           /* only take the last part of the filename */
 318           {
 319             string tmp;
 320             char *p = strrchr(tok[2],'/');
 321             if (p)
 322               {
 323                 strcpy(tmp,p+1);
 324                 strcpy(tok[2],tmp);
 325               }
 326           }
 327
 328
 329           buf->job = atoi(tok[1]);
 330           buf->status = LPQ_QUEUED;
 331           buf->priority = 0;
 332           buf->time = time(NULL);
 333           StrnCpy(buf->user,tok[3],sizeof(buf->user)-1);
 334           StrnCpy(buf->file,tok[2],sizeof(buf->file)-1);
 335       }
 336       else
 337       {
 338           DEBUG(6,("parse_lpq_aix count=%d\n", count));
 339           return(False);
 340       }
 341   }
 342   else
 343   {
 344       /* the 4th and 9th columns must be integer */
 345       if (!isdigit(*tok[3]) || !isdigit(*tok[8])) return(False);
 346       buf->size = atoi(tok[8]) * 1024;
 347       /* if the fname contains a space then use STDIN */
 348       if (strchr(tok[4],' '))
 349         strcpy(tok[4],"STDIN");
 350
 351       /* only take the last part of the filename */
 352       {
 353         string tmp;
 354         char *p = strrchr(tok[4],'/');
 355         if (p)
 356           {
 357             strcpy(tmp,p+1);
 358             strcpy(tok[4],tmp);
 359           }
 360       }
 361
 362
 363       buf->job = atoi(tok[3]);
 364       buf->status = strequal(tok[2],"RUNNING")?LPQ_PRINTING:LPQ_QUEUED;
 365       buf->priority = 0;
 366       buf->time = time(NULL);
 367       StrnCpy(buf->user,tok[5],sizeof(buf->user)-1);
 368       StrnCpy(buf->file,tok[4],sizeof(buf->file)-1);
 369   }
 370
 371
 372   return(True);
 373 }
 374
 375
 376 /****************************************************************************
 377 parse a lpq line
 378 here is an example of lpq output under hpux; note there's no space after -o !
 379 $> lpstat -oljplus
 380 ljplus-2153         user           priority 0  Jan 19 08:14 on ljplus
 381       util.c                                  125697 bytes
 382       server.c                                110712 bytes
 383 ljplus-2154         user           priority 0  Jan 19 08:14 from client
 384       (standard input)                          7551 bytes
 385 ****************************************************************************/
 386 static BOOL parse_lpq_hpux(char * line, print_queue_struct *buf, BOOL first)
 387 {
 388   /* must read two lines to process, therefore keep some values static */
 389   static BOOL header_line_ok=False, base_prio_reset=False;
 390   static string jobuser;
 391   static int jobid;
 392   static int jobprio;
 393   static time_t jobtime;
 394   static int jobstat=LPQ_QUEUED;
 395   /* to store minimum priority to print, lpstat command should be invoked
 396      with -p option first, to work */
 397   static int base_prio;
 398
 399   int count;
 400   char TAB = '\011';
 401   string tok[12];
 402
 403   /* If a line begins with a horizontal TAB, it is a subline type */
 404
 405   if (line[0] == TAB) { /* subline */
 406     /* check if it contains the base priority */
 407     if (!strncmp(line,"\tfence priority : ",18)) {
 408        base_prio=atoi(&line[18]);
 409        DEBUG(4, ("fence priority set at %d\n", base_prio));
 410     }
 411     if (!header_line_ok) return (False); /* incorrect header line */
 412     /* handle the case of "(standard input)" as a filename */
 413     string_sub(line,"standard input","STDIN");
 414     string_sub(line,"(","\"");
 415     string_sub(line,")","\"");
 416
 417     for (count=0; count<2 && next_token(&line,tok[count],NULL); count++) ;
 418     /* we must get 2 tokens */
 419     if (count < 2) return(False);
 420
 421     /* the 2nd column must be integer */
 422     if (!isdigit(*tok[1])) return(False);
 423
 424     /* if the fname contains a space then use STDIN */
 425     if (strchr(tok[0],' '))
 426       strcpy(tok[0],"STDIN");
 427
 428     buf->size = atoi(tok[1]);
 429     StrnCpy(buf->file,tok[0],sizeof(buf->file)-1);
 430
 431     /* fill things from header line */
 432     buf->time = jobtime;
 433     buf->job = jobid;
 434     buf->status = jobstat;
 435     buf->priority = jobprio;
 436     StrnCpy(buf->user,jobuser,sizeof(buf->user)-1);
 437
 438     return(True);
 439   }
 440   else { /* header line */
 441     header_line_ok=False; /* reset it */
 442     if (first) {
 443        if (!base_prio_reset) {
 444           base_prio=0; /* reset it */
 445           base_prio_reset=True;
 446        }
 447     }
 448     else if (base_prio) base_prio_reset=False;
 449
 450     /* handle the dash in the job id */
 451     string_sub(line,"-"," ");
 452
 453     for (count=0; count<12 && next_token(&line,tok[count],NULL); count++) ;
 454
 455     /* we must get 8 tokens */
 456     if (count < 8) return(False);
 457
 458     /* first token must be printer name (cannot check ?) */
 459     /* the 2nd, 5th & 7th column must be integer */
 460     if (!isdigit(*tok[1]) || !isdigit(*tok[4]) || !isdigit(*tok[6])) return(False);
 461     jobid = atoi(tok[1]);
 462     StrnCpy(jobuser,tok[2],sizeof(buf->user)-1);
 463     jobprio = atoi(tok[4]);
 464
 465     /* process time */
 466     jobtime=EntryTime(tok, 5, count, 8);
 467     if (jobprio < base_prio) {
 468        jobstat = LPQ_PAUSED;
 469        DEBUG (4, ("job %d is paused: prio %d < %d; jobstat=%d\n", jobid, jobprio, base_prio, jobstat));
 470     }
 471     else {
 472        jobstat = LPQ_QUEUED;
 473        if ((count >8) && (((strequal(tok[8],"on")) ||
 474                            ((strequal(tok[8],"from")) &&
 475                             ((count > 10)&&(strequal(tok[10],"on")))))))
 476          jobstat = LPQ_PRINTING;
 477     }
 478
 479     header_line_ok=True; /* information is correct */
 480     return(False); /* need subline info to include into queuelist */
 481   }
 482 }
 483
 484
 485 /****************************************************************************
 486 parse a lpq line
 487
 488 here is an example of "lpstat -o dcslw" output under sysv
 489
 490 dcslw-896               tridge            4712   Dec 20 10:30:30 on dcslw
 491 dcslw-897               tridge            4712   Dec 20 10:30:30 being held
 492
 493 ****************************************************************************/
 494 static BOOL parse_lpq_sysv(char *line,print_queue_struct *buf,BOOL first)
 495 {
 496   string tok[9];
 497   int count=0;
 498   char *p;
 499
 500   /* handle the dash in the job id */
 501   string_sub(line,"-"," ");
 502
 503   for (count=0; count<9 && next_token(&line,tok[count],NULL); count++) ;
 504
 505   /* we must get 7 tokens */
 506   if (count < 7)
 507     return(False);
 508
 509   /* the 2nd and 4th, 6th columns must be integer */
 510   if (!isdigit(*tok[1]) || !isdigit(*tok[3])) return(False);
 511   if (!isdigit(*tok[5])) return(False);
 512
 513   /* if the user contains a ! then trim the first part of it */
 514   if ((p=strchr(tok[2],'!')))
 515     {
 516       string tmp;
 517       strcpy(tmp,p+1);
 518       strcpy(tok[2],tmp);
 519     }
 520
 521
 522   buf->job = atoi(tok[1]);
 523   buf->size = atoi(tok[3]);
 524   if (count > 7 && strequal(tok[7],"on"))
 525     buf->status = LPQ_PRINTING;
 526   else if (count > 8 && strequal(tok[7],"being") && strequal(tok[8],"held"))
 527     buf->status = LPQ_PAUSED;
 528   else
 529     buf->status = LPQ_QUEUED;
 530   buf->priority = 0;
 531   buf->time = EntryTime(tok, 4, count, 7);
 532   StrnCpy(buf->user,tok[2],sizeof(buf->user)-1);
 533   StrnCpy(buf->file,tok[2],sizeof(buf->file)-1);
 534   return(True);
 535 }
 536
 537 /****************************************************************************
 538 parse a lpq line
 539
 540 here is an example of lpq output under qnx
 541 Spooler: /qnx/spooler, on node 1
 542 Printer: txt        (ready)
 543 0000:     root  [job #1    ]   active 1146 bytes        /etc/profile
 544 0001:     root  [job #2    ]    ready 2378 bytes        /etc/install
 545 0002:     root  [job #3    ]    ready 1146 bytes        -- standard input --
 546 ****************************************************************************/
 547 static BOOL parse_lpq_qnx(char *line,print_queue_struct *buf,BOOL first)
 548 {
 549   string tok[7];
 550   int count=0;
 551
 552   DEBUG(0,("antes [%s]\n", line));
 553
 554   /* handle the case of "-- standard input --" as a filename */
 555   string_sub(line,"standard input","STDIN");
 556   DEBUG(0,("despues [%s]\n", line));
 557   string_sub(line,"-- ","\"");
 558   string_sub(line," --","\"");
 559   DEBUG(0,("despues 1 [%s]\n", line));
 560
 561   string_sub(line,"[job #","");
 562   string_sub(line,"]","");
 563   DEBUG(0,("despues 2 [%s]\n", line));
 564
 565
 566
 567   for (count=0; count<7 && next_token(&line,tok[count],NULL); count++) ;
 568
 569   /* we must get 7 tokens */
 570   if (count < 7)
 571     return(False);
 572
 573   /* the 3rd and 5th columns must be integer */
 574   if (!isdigit(*tok[2]) || !isdigit(*tok[4])) return(False);
 575
 576   /* only take the last part of the filename */
 577   {
 578     string tmp;
 579     char *p = strrchr(tok[6],'/');
 580     if (p)
 581       {
 582         strcpy(tmp,p+1);
 583         strcpy(tok[6],tmp);
 584       }
 585   }
 586
 587
 588   buf->job = atoi(tok[2]);
 589   buf->size = atoi(tok[4]);
 590   buf->status = strequal(tok[3],"active")?LPQ_PRINTING:LPQ_QUEUED;
 591   buf->priority = 0;
 592   buf->time = time(NULL);
 593   StrnCpy(buf->user,tok[1],sizeof(buf->user)-1);
 594   StrnCpy(buf->file,tok[6],sizeof(buf->file)-1);
 595   return(True);
 596 }
 597
 598
 599
 600 char *stat0_strings[] = { "enabled", "online", "idle", "no entries", "free", "ready", NULL };
 601 char *stat1_strings[] = { "offline", "disabled", "down", "off", "waiting", "no daemon", NULL };
 602 char *stat2_strings[] = { "jam", "paper", "error", "responding", "not accepting", "not running", "turned off", NULL };
 603
 604 /****************************************************************************
 605 parse a lpq line. Choose printing style
 606 ****************************************************************************/
 607 static BOOL parse_lpq_entry(int snum,char *line,
 608                             print_queue_struct *buf,
 609                             print_status_struct *status,BOOL first)
 610 {
 611   BOOL ret;
 612
 613   switch (lp_printing())
 614     {
 615     case PRINT_SYSV:
 616       ret = parse_lpq_sysv(line,buf,first);
 617       break;
 618     case PRINT_AIX:
 619       ret = parse_lpq_aix(line,buf,first);
 620       break;
 621     case PRINT_HPUX:
 622       ret = parse_lpq_hpux(line,buf,first);
 623       break;
 624     case PRINT_QNX:
 625       ret = parse_lpq_qnx(line,buf,first);
 626       break;
 627     default:
 628       ret = parse_lpq_bsd(line,buf,first);
 629       break;
 630     }
 631
 632 #ifdef LPQ_GUEST_TO_USER
 633   if (ret) {
 634     extern pstring sesssetup_user;
 635     /* change guest entries to the current logged in user to make
 636        them appear deletable to windows */
 637     if (sesssetup_user[0] && strequal(buf->user,lp_guestaccount(snum)))
 638       strcpy(buf->user,sesssetup_user);
 639   }
 640 #endif
 641
 642   if (status && !ret)
 643     {
 644       /* a few simple checks to see if the line might be a
 645          printer status line:
 646          handle them so that most severe condition is shown */
 647       int i;
 648       strlower(line);
 649
 650       switch (status->status) {
 651       case LPSTAT_OK:
 652         for (i=0; stat0_strings[i]; i++)
 653           if (strstr(line,stat0_strings[i])) {
 654             StrnCpy(status->message,line,sizeof(status->message)-1);
 655             status->status=LPSTAT_OK;
 656           }
 657       case LPSTAT_STOPPED:
 658         for (i=0; stat1_strings[i]; i++)
 659           if (strstr(line,stat1_strings[i])) {
 660             StrnCpy(status->message,line,sizeof(status->message)-1);
 661             status->status=LPSTAT_STOPPED;
 662           }
 663       case LPSTAT_ERROR:
 664         for (i=0; stat2_strings[i]; i++)
 665           if (strstr(line,stat2_strings[i])) {
 666             StrnCpy(status->message,line,sizeof(status->message)-1);
 667             status->status=LPSTAT_ERROR;
 668           }
 669         break;
 670       }
 671     }
 672
 673   return(ret);
 674 }
 675
 676 /****************************************************************************
 677 get a printer queue
 678 ****************************************************************************/
 679 int get_printqueue(int snum,int cnum,print_queue_struct **queue,
 680                    print_status_struct *status)
 681 {
 682   char *lpq_command = lp_lpqcommand(snum);
 683   char *printername = PRINTERNAME(snum);
 684   int ret=0,count=0;
 685   pstring syscmd;
 686   fstring outfile;
 687   pstring line;
 688   FILE *f;
 689   struct stat sbuf;
 690   BOOL dorun=True;
 691   int cachetime = lp_lpqcachetime();
 692   int lfd = -1;
 693
 694   *line = 0;
 695   check_lpq_cache(snum);
 696
 697   if (!printername || !*printername)
 698     {
 699       DEBUG(6,("replacing printer name with service (snum=(%s,%d))\n",
 700             lp_servicename(snum),snum));
 701       printername = lp_servicename(snum);
 702     }
 703
 704   if (!lpq_command || !(*lpq_command))
 705     {
 706       DEBUG(5,("No lpq command\n"));
 707       return(0);
 708     }
 709
 710   strcpy(syscmd,lpq_command);
 711   string_sub(syscmd,"%p",printername);
 712
 713   standard_sub(cnum,syscmd);
 714
 715   sprintf(outfile,"/tmp/lpq.%08x",str_checksum(syscmd));
 716
 717   if (!lpq_cache_reset[snum] && cachetime && !stat(outfile,&sbuf))
 718     {
 719       if (time(NULL) - sbuf.st_mtime < cachetime) {
 720         DEBUG(3,("Using cached lpq output\n"));
 721         dorun = False;
 722       }
 723
 724       if (dorun) {
 725         lfd = file_lock(outfile,LPQ_LOCK_TIMEOUT);
 726         if (lfd<0 ||
 727             (!fstat(lfd,&sbuf) && (time(NULL) - sbuf.st_mtime)<cachetime)) {
 728           DEBUG(3,("Using cached lpq output\n"));
 729           dorun = False;
 730           file_unlock(lfd); lfd = -1;
 731         }
 732       }
 733     }
 734
 735   if (dorun) {
 736     ret = smbrun(syscmd,outfile);
 737     DEBUG(3,("Running the command `%s' gave %d\n",syscmd,ret));
 738   }
 739
 740   lpq_cache_reset[snum] = False;
 741
 742   f = fopen(outfile,"r");
 743   if (!f) {
 744     if (lfd >= 0) file_unlock(lfd);
 745     return(0);
 746   }
 747
 748   if (status) {
 749     strcpy(status->message,"");
 750     status->status = LPSTAT_OK;
 751   }
 752
 753   while (fgets(line,sizeof(pstring),f))
 754     {
 755       DEBUG(6,("QUEUE2: %s\n",line));
 756
 757       *queue = Realloc(*queue,sizeof(print_queue_struct)*(count+1));
 758       if (! *queue)
 759         {
 760           count = 0;
 761           break;
 762         }
 763
 764       bzero((char *)&(*queue)[count],sizeof(**queue));
 765
 766       /* parse it */
 767       if (!parse_lpq_entry(snum,line,&(*queue)[count],status,count==0))
 768         continue;
 769
 770       count++;
 771     }
 772
 773   fclose(f);
 774
 775   if (lfd >= 0) file_unlock(lfd);
 776
 777   if (!cachetime)
 778     unlink(outfile);
 779   else
 780     chmod(outfile,0666);
 781   return(count);
 782 }
 783
 784
 785 /****************************************************************************
 786 delete a printer queue entry
 787 ****************************************************************************/
 788 void del_printqueue(int cnum,int snum,int jobid)
 789 {
 790   char *lprm_command = lp_lprmcommand(snum);
 791   char *printername = PRINTERNAME(snum);
 792   pstring syscmd;
 793   char jobstr[20];
 794   int ret;
 795
 796   if (!printername || !*printername)
 797     {
 798       DEBUG(6,("replacing printer name with service (snum=(%s,%d))\n",
 799             lp_servicename(snum),snum));
 800       printername = lp_servicename(snum);
 801     }
 802
 803   if (!lprm_command || !(*lprm_command))
 804     {
 805       DEBUG(5,("No lprm command\n"));
 806       return;
 807     }
 808
 809   sprintf(jobstr,"%d",jobid);
 810
 811   strcpy(syscmd,lprm_command);
 812   string_sub(syscmd,"%p",printername);
 813   string_sub(syscmd,"%j",jobstr);
 814   standard_sub(cnum,syscmd);
 815
 816   ret = smbrun(syscmd,NULL);
 817   DEBUG(3,("Running the command `%s' gave %d\n",syscmd,ret));
 818   lpq_reset(snum); /* queue has changed */
 819 }
 820
 821 /****************************************************************************
 822 change status of a printer queue entry
 823 ****************************************************************************/
 824 void status_printjob(int cnum,int snum,int jobid,int status)
 825 {
 826   char *lpstatus_command =
 827     (status==LPQ_PAUSED?lp_lppausecommand(snum):lp_lpresumecommand(snum));
 828   char *printername = PRINTERNAME(snum);
 829   pstring syscmd;
 830   char jobstr[20];
 831   int ret;
 832
 833   if (!printername || !*printername)
 834     {
 835       DEBUG(6,("replacing printer name with service (snum=(%s,%d))\n",
 836             lp_servicename(snum),snum));
 837       printername = lp_servicename(snum);
 838     }
 839
 840   if (!lpstatus_command || !(*lpstatus_command))
 841     {
 842       DEBUG(5,("No lpstatus command to %s job\n",
 843                (status==LPQ_PAUSED?"pause":"resume")));
 844       return;
 845     }
 846
 847   sprintf(jobstr,"%d",jobid);
 848
 849   strcpy(syscmd,lpstatus_command);
 850   string_sub(syscmd,"%p",printername);
 851   string_sub(syscmd,"%j",jobstr);
 852   standard_sub(cnum,syscmd);
 853
 854   ret = smbrun(syscmd,NULL);
 855   DEBUG(3,("Running the command `%s' gave %d\n",syscmd,ret));
 856   lpq_reset(snum); /* queue has changed */
 857 }
 858
 859