#include "includes.h"
static const char *Months[13] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "Err"};
static time_t EntryTime(fstring tok[], int ptr, int count, int minimum)
{
time_t jobtime,jobtime1;
jobtime = time(NULL);
if (count >= minimum) {
struct tm *t;
int i, day, hour, min, sec;
char *c;
for (i=0; i<13; i++) if (!strncmp(tok[ptr], Months[i],3)) break;
if (i<12) {
t = localtime(&jobtime);
day = atoi(tok[ptr+1]);
c=(char *)(tok[ptr+2]);
*(c+2)=0;
hour = atoi(c);
*(c+5)=0;
min = atoi(c+3);
if(*(c+6) != 0)sec = atoi(c+6);
else sec=0;
if ((t->tm_mon < i)||
((t->tm_mon == i)&&
((t->tm_mday < day)||
((t->tm_mday == day)&&
(t->tm_hour*60+t->tm_min < hour*60+min)))))
t->tm_year--;
t->tm_mon = i;
t->tm_mday = day;
t->tm_hour = hour;
t->tm_min = min;
t->tm_sec = sec;
jobtime1 = mktime(t);
if (jobtime1 != (time_t)-1)
jobtime = jobtime1;
}
}
return jobtime;
}
static BOOL parse_lpq_bsd(char *line,print_queue_struct *buf,BOOL first)
{
#ifdef OSF1
#define RANKTOK 0
#define PRIOTOK 1
#define USERTOK 2
#define JOBTOK 3
#define FILETOK 4
#define TOTALTOK (count - 2)
#define NTOK 6
#define MAXTOK 128
#else
#define RANKTOK 0
#define USERTOK 1
#define JOBTOK 2
#define FILETOK 3
#define TOTALTOK (count - 2)
#define NTOK 5
#define MAXTOK 128
#endif
char *tok[MAXTOK];
int count = 0;
pstring line2;
pstrcpy(line2,line);
#ifdef OSF1
{
size_t length;
length = strlen(line2);
if (line2[length-3] == ':')
return(False);
}
#endif
tok[0] = strtok(line2," \t");
count++;
while (((tok[count] = strtok(NULL," \t")) != NULL) && (count < MAXTOK)) {
count++;
}
if (count < NTOK)
return(False);
if (!isdigit((int)*tok[JOBTOK]) || !isdigit((int)*tok[TOTALTOK])) return(False);
buf->job = atoi(tok[JOBTOK]);
buf->size = atoi(tok[TOTALTOK]);
buf->status = strequal(tok[RANKTOK],"active")?LPQ_PRINTING:LPQ_QUEUED;
buf->time = time(NULL);
fstrcpy(buf->fs_user,tok[USERTOK]);
fstrcpy(buf->fs_file,tok[FILETOK]);
if ((FILETOK + 1) != TOTALTOK) {
int i;
for (i = (FILETOK + 1); i < TOTALTOK; i++) {
fstrcat(buf->fs_file, " ");
fstrcat(buf->fs_file, tok[i]);
}
fstrterminate(buf->fs_file);
}
#ifdef PRIOTOK
buf->priority = atoi(tok[PRIOTOK]);
#else
buf->priority = 1;
#endif
return(True);
}
static time_t LPRng_time(char *time_string)
{
time_t jobtime;
struct tm t;
jobtime = time(NULL);
t = *localtime(&jobtime);
if ( atoi(time_string) < 24 ){
t.tm_hour = atoi(time_string);
t.tm_min = atoi(time_string+3);
t.tm_sec = atoi(time_string+6);
} else {
t.tm_year = atoi(time_string)-1900;
t.tm_mon = atoi(time_string+5)-1;
t.tm_mday = atoi(time_string+8);
t.tm_hour = atoi(time_string+11);
t.tm_min = atoi(time_string+14);
t.tm_sec = atoi(time_string+17);
}
jobtime = mktime(&t);
return jobtime;
}
static BOOL parse_lpq_lprng(char *line,print_queue_struct *buf,BOOL first)
{
#define LPRNG_RANKTOK 0
#define LPRNG_USERTOK 1
#define LPRNG_PRIOTOK 2
#define LPRNG_JOBTOK 3
#define LPRNG_FILETOK 4
#define LPRNG_TOTALTOK (num_tok - 2)
#define LPRNG_TIMETOK (num_tok - 1)
#define LPRNG_NTOK 7
#define LPRNG_MAXTOK 128
fstring tokarr[LPRNG_MAXTOK];
const char *cptr;
char *ptr;
int num_tok = 0;
cptr = line;
while(next_token( &cptr, tokarr[num_tok], " \t", sizeof(fstring)) && (num_tok < LPRNG_MAXTOK))
num_tok++;
if (num_tok < LPRNG_NTOK) {
return(False);
}
if (!isdigit((int)*tokarr[LPRNG_JOBTOK]) || !isdigit((int)*tokarr[LPRNG_TOTALTOK])) {
return(False);
}
buf->job = atoi(tokarr[LPRNG_JOBTOK]);
buf->size = atoi(tokarr[LPRNG_TOTALTOK]);
if (strequal(tokarr[LPRNG_RANKTOK],"active")) {
buf->status = LPQ_PRINTING;
} else if (strequal(tokarr[LPRNG_RANKTOK],"done")) {
buf->status = LPQ_PRINTED;
} else if (isdigit((int)*tokarr[LPRNG_RANKTOK])) {
buf->status = LPQ_QUEUED;
} else {
buf->status = LPQ_PAUSED;
}
buf->priority = *tokarr[LPRNG_PRIOTOK] -'A';
buf->time = LPRng_time(tokarr[LPRNG_TIMETOK]);
fstrcpy(buf->fs_user,tokarr[LPRNG_USERTOK]);
if ((ptr = strchr_m(buf->fs_user,'@')) != NULL) {
*ptr = '\0';
}
fstrcpy(buf->fs_file,tokarr[LPRNG_FILETOK]);
if ((LPRNG_FILETOK + 1) != LPRNG_TOTALTOK) {
int i;
for (i = (LPRNG_FILETOK + 1); i < LPRNG_TOTALTOK; i++) {
fstrcat(buf->fs_file, " ");
fstrcat(buf->fs_file, tokarr[i]);
}
fstrterminate(buf->fs_file);
}
return(True);
}
static BOOL parse_lpq_aix(char *line,print_queue_struct *buf,BOOL first)
{
fstring tok[11];
int count=0;
const char *cline = line;
string_sub(line,"standard input","STDIN",0);
all_string_sub(line,"(","\"",0);
all_string_sub(line,")","\"",0);
for (count=0;
count<10 &&
next_token(&cline,tok[count],NULL, sizeof(tok[count]));
count++) ;
if (count < 10)
{
if ((count == 7) && ((strcmp(tok[0],"QUEUED") == 0) || (strcmp(tok[0],"HELD") == 0)))
{
if (!isdigit((int)*tok[1]) || !isdigit((int)*tok[4])) return(False);
buf->size = atoi(tok[4]) * 1024;
if (strchr_m(tok[2],' '))
fstrcpy(tok[2],"STDIN");
{
fstring tmp;
char *p = strrchr_m(tok[2],'/');
if (p)
{
fstrcpy(tmp,p+1);
fstrcpy(tok[2],tmp);
}
}
buf->job = atoi(tok[1]);
buf->status = strequal(tok[0],"HELD")?LPQ_PAUSED:LPQ_QUEUED;
buf->priority = 0;
buf->time = time(NULL);
fstrcpy(buf->fs_user,tok[3]);
fstrcpy(buf->fs_file,tok[2]);
}
else
{
DEBUG(6,("parse_lpq_aix count=%d\n", count));
return(False);
}
}
else
{
if (!isdigit((int)*tok[3]) || !isdigit((int)*tok[8])) return(False);
buf->size = atoi(tok[8]) * 1024;
if (strchr_m(tok[4],' '))
fstrcpy(tok[4],"STDIN");
{
fstring tmp;
char *p = strrchr_m(tok[4],'/');
if (p)
{
fstrcpy(tmp,p+1);
fstrcpy(tok[4],tmp);
}
}
buf->job = atoi(tok[3]);
buf->status = strequal(tok[2],"RUNNING")?LPQ_PRINTING:LPQ_QUEUED;
buf->priority = 0;
buf->time = time(NULL);
fstrcpy(buf->fs_user,tok[5]);
fstrcpy(buf->fs_file,tok[4]);
}
return(True);
}
static BOOL parse_lpq_hpux(char *line, print_queue_struct *buf, BOOL first)
{
static BOOL header_line_ok=False, base_prio_reset=False;
static fstring jobuser;
static int jobid;
static int jobprio;
static time_t jobtime;
static int jobstat=LPQ_QUEUED;
static int base_prio;
int count;
char htab = '\011';
const char *cline = line;
fstring tok[12];
if (line[0] == htab) {
if (!strncmp(line,"\tfence priority : ",18)) {
base_prio=atoi(&line[18]);
DEBUG(4, ("fence priority set at %d\n", base_prio));
}
if (!header_line_ok) return (False);
string_sub(line,"standard input","STDIN",0);
all_string_sub(line,"(","\"",0);
all_string_sub(line,")","\"",0);
for (count=0; count<2 && next_token(&cline,tok[count],NULL,sizeof(tok[count])); count++) ;
if (count < 2) return(False);
if (!isdigit((int)*tok[1])) return(False);
if (strchr_m(tok[0],' '))
fstrcpy(tok[0],"STDIN");
buf->size = atoi(tok[1]);
fstrcpy(buf->fs_file,tok[0]);
buf->time = jobtime;
buf->job = jobid;
buf->status = jobstat;
buf->priority = jobprio;
fstrcpy(buf->fs_user,jobuser);
return(True);
}
else {
header_line_ok=False;
if (first) {
if (!base_prio_reset) {
base_prio=0;
base_prio_reset=True;
}
}
else if (base_prio) base_prio_reset=False;
string_sub(line,"-"," ",0);
for (count=0; count<12 && next_token(&cline,tok[count],NULL,sizeof(tok[count])); count++) ;
if (count < 8) return(False);
if (!isdigit((int)*tok[1]) || !isdigit((int)*tok[4]) || !isdigit((int)*tok[6])) return(False);
jobid = atoi(tok[1]);
fstrcpy(jobuser,tok[2]);
jobprio = atoi(tok[4]);
jobtime=EntryTime(tok, 5, count, 8);
if (jobprio < base_prio) {
jobstat = LPQ_PAUSED;
DEBUG (4, ("job %d is paused: prio %d < %d; jobstat=%d\n", jobid, jobprio, base_prio, jobstat));
}
else {
jobstat = LPQ_QUEUED;
if ((count >8) && (((strequal(tok[8],"on")) ||
((strequal(tok[8],"from")) &&
((count > 10)&&(strequal(tok[10],"on")))))))
jobstat = LPQ_PRINTING;
}
header_line_ok=True;
return(False);
}
}
static BOOL parse_lpq_sysv(char *line,print_queue_struct *buf,BOOL first)
{
fstring tok[9];
int count=0;
char *p;
const char *cline = line;
for (p = line ; !isspace(*p) && *p; p++)
;
for (; (p >= line) && (*p != '-'); p--)
;
if((p >= line) && (*p == '-'))
*p = ' ';
for (count=0; count<9 && next_token(&cline,tok[count],NULL,sizeof(tok[count])); count++)
;
if (count < 7)
return(False);
if (!isdigit((int)*tok[1]) || !isdigit((int)*tok[3]))
return(False);
if (!isdigit((int)*tok[5]))
return(False);
if ((p=strchr_m(tok[2],'!'))) {
fstring tmp;
fstrcpy(tmp,p+1);
fstrcpy(tok[2],tmp);
}
buf->job = atoi(tok[1]);
buf->size = atoi(tok[3]);
if (count > 7 && strequal(tok[7],"on"))
buf->status = LPQ_PRINTING;
else if (count > 8 && strequal(tok[7],"being") && strequal(tok[8],"held"))
buf->status = LPQ_PAUSED;
else
buf->status = LPQ_QUEUED;
buf->priority = 0;
buf->time = EntryTime(tok, 4, count, 7);
fstrcpy(buf->fs_user,tok[2]);
fstrcpy(buf->fs_file,tok[2]);
return(True);
}
static BOOL parse_lpq_qnx(char *line,print_queue_struct *buf,BOOL first)
{
fstring tok[7];
int count=0;
const char *cline = line;
DEBUG(4,("antes [%s]\n", line));
string_sub(line,"standard input","STDIN",0);
DEBUG(4,("despues [%s]\n", line));
all_string_sub(line,"-- ","\"",0);
all_string_sub(line," --","\"",0);
DEBUG(4,("despues 1 [%s]\n", line));
string_sub(line,"[job #","",0);
string_sub(line,"]","",0);
DEBUG(4,("despues 2 [%s]\n", line));
for (count=0; count<7 && next_token(&cline,tok[count],NULL,sizeof(tok[count])); count++) ;
if (count < 7)
return(False);
if (!isdigit((int)*tok[2]) || !isdigit((int)*tok[4])) return(False);
{
fstring tmp;
char *p = strrchr_m(tok[6],'/');
if (p)
{
fstrcpy(tmp,p+1);
fstrcpy(tok[6],tmp);
}
}
buf->job = atoi(tok[2]);
buf->size = atoi(tok[4]);
buf->status = strequal(tok[3],"active")?LPQ_PRINTING:LPQ_QUEUED;
buf->priority = 0;
buf->time = time(NULL);
fstrcpy(buf->fs_user,tok[1]);
fstrcpy(buf->fs_file,tok[6]);
return(True);
}
static BOOL parse_lpq_plp(char *line,print_queue_struct *buf,BOOL first)
{
fstring tok[11];
int count=0;
const char *cline = line;
string_sub(line,"stdin","STDIN",0);
all_string_sub(line,"(","\"",0);
all_string_sub(line,")","\"",0);
for (count=0; count<11 && next_token(&cline,tok[count],NULL,sizeof(tok[count])); count++) ;
if (count < 11)
return(False);
if (strcmp(tok[0],"active") && !isdigit((int)tok[0][0]))
return(False);
if (!isdigit((int)*tok[4]) || !isdigit((int)*tok[7]))
return(False);
if (strchr_m(tok[6],' '))
fstrcpy(tok[6],"STDIN");
{
fstring tmp;
char *p = strrchr_m(tok[6],'/');
if (p)
{
fstrcpy(tmp,p+1);
fstrcpy(tok[6],tmp);
}
}
buf->job = atoi(tok[4]);
buf->size = atoi(tok[7]);
if (strchr_m(tok[7],'K'))
buf->size *= 1024;
if (strchr_m(tok[7],'M'))
buf->size *= 1024*1024;
buf->status = strequal(tok[0],"active")?LPQ_PRINTING:LPQ_QUEUED;
buf->priority = 0;
buf->time = time(NULL);
fstrcpy(buf->fs_user,tok[1]);
fstrcpy(buf->fs_file,tok[6]);
return(True);
}
static BOOL parse_lpq_nt(char *line,print_queue_struct *buf,BOOL first)
{
#define LPRNT_OWNSIZ 11
#define LPRNT_STATSIZ 9
#define LPRNT_JOBSIZ 19
#define LPRNT_IDSIZ 6
#define LPRNT_SIZSIZ 9
typedef struct
{
char owner[LPRNT_OWNSIZ];
char space1;
char status[LPRNT_STATSIZ];
char space2;
char jobname[LPRNT_JOBSIZ];
char space3;
char jobid[LPRNT_IDSIZ];
char space4;
char size[LPRNT_SIZSIZ];
char terminator;
} nt_lpq_line;
nt_lpq_line parse_line;
#define LPRNT_PRINTING "Printing"
#define LPRNT_WAITING "Waiting"
#define LPRNT_PAUSED "Paused"
memset(&parse_line, '\0', sizeof(parse_line));
strncpy((char *) &parse_line, line, sizeof(parse_line) -1);
if (strlen((char *) &parse_line) != sizeof(parse_line) - 1)
return(False);
if (strchr_m(parse_line.owner, ' '))
*(strchr_m(parse_line.owner, ' ')) = '\0';
else
parse_line.space1 = '\0';
if (!strlen(parse_line.owner))
return(False);
parse_line.space2 = '\0';
trim_char(parse_line.status, '\0', ' ');
if (!strequal(parse_line.status, LPRNT_PRINTING) &&
!strequal(parse_line.status, LPRNT_PAUSED) &&
!strequal(parse_line.status, LPRNT_WAITING))
return(False);
parse_line.space3 = '\0';
trim_char(parse_line.jobname, '\0', ' ');
buf->job = atoi(parse_line.jobid);
buf->priority = 0;
buf->size = atoi(parse_line.size);
buf->time = time(NULL);
fstrcpy(buf->fs_user, parse_line.owner);
fstrcpy(buf->fs_file, parse_line.jobname);
if (strequal(parse_line.status, LPRNT_PRINTING))
buf->status = LPQ_PRINTING;
else if (strequal(parse_line.status, LPRNT_PAUSED))
buf->status = LPQ_PAUSED;
else
buf->status = LPQ_QUEUED;
return(True);
}
static BOOL parse_lpq_os2(char *line,print_queue_struct *buf,BOOL first)
{
#define LPROS2_IDSIZ 5
#define LPROS2_JOBSIZ 15
#define LPROS2_SIZSIZ 8
#define LPROS2_STATSIZ 12
#define LPROS2_OWNSIZ 12
typedef struct
{
char jobid[LPROS2_IDSIZ];
char space1[2];
char jobname[LPROS2_JOBSIZ];
char space2[14];
char size[LPROS2_SIZSIZ];
char space3[4];
char status[LPROS2_STATSIZ];
char space4[4];
char owner[LPROS2_OWNSIZ];
char terminator;
} os2_lpq_line;
os2_lpq_line parse_line;
#define LPROS2_PRINTING "Printing"
#define LPROS2_WAITING "Queued"
#define LPROS2_PAUSED "Paused"
memset(&parse_line, '\0', sizeof(parse_line));
strncpy((char *) &parse_line, line, sizeof(parse_line) -1);
if (strlen((char *) &parse_line) != sizeof(parse_line) - 1)
return(False);
buf->job = atoi(parse_line.jobid);
parse_line.space2[0] = '\0';
trim_char(parse_line.jobname, '\0', ' ');
fstrcpy(buf->fs_file, parse_line.jobname);
buf->priority = 0;
buf->size = atoi(parse_line.size);
buf->time = time(NULL);
if (!strlen(parse_line.owner))
return(False);
parse_line.space4[0] = '\0';
trim_char(parse_line.status, '\0', ' ');
if (!strequal(parse_line.status, LPROS2_PRINTING) &&
!strequal(parse_line.status, LPROS2_PAUSED) &&
!strequal(parse_line.status, LPROS2_WAITING))
return(False);
fstrcpy(buf->fs_user, parse_line.owner);
if (strequal(parse_line.status, LPROS2_PRINTING))
buf->status = LPQ_PRINTING;
else if (strequal(parse_line.status, LPROS2_PAUSED))
buf->status = LPQ_PAUSED;
else
buf->status = LPQ_QUEUED;
return(True);
}
static const char *stat0_strings[] = { "enabled", "online", "idle", "no entries", "free", "ready", NULL };
static const char *stat1_strings[] = { "offline", "disabled", "down", "off", "waiting", "no daemon", NULL };
static const char *stat2_strings[] = { "jam", "paper", "error", "responding", "not accepting", "not running", "turned off", NULL };
#ifdef DEVELOPER
static BOOL parse_lpq_vlp(char *line,print_queue_struct *buf,BOOL first)
{
int toknum = 0;
fstring tok;
const char *cline = line;
if (!isdigit(line[0])) return False;
while(next_token(&cline, tok, NULL, sizeof(fstring))) {
switch (toknum) {
case 0:
buf->job = atoi(tok);
break;
case 1:
buf->size = atoi(tok);
break;
case 2:
buf->status = atoi(tok);
break;
case 3:
buf->time = atoi(tok);
break;
case 4:
fstrcpy(buf->fs_user, tok);
break;
case 5:
fstrcpy(buf->fs_file, tok);
break;
}
toknum++;
}
return True;
}
#endif
BOOL parse_lpq_entry(enum printing_types printing_type,char *line,
print_queue_struct *buf,
print_status_struct *status,BOOL first)
{
BOOL ret;
switch (printing_type)
{
case PRINT_SYSV:
ret = parse_lpq_sysv(line,buf,first);
break;
case PRINT_AIX:
ret = parse_lpq_aix(line,buf,first);
break;
case PRINT_HPUX:
ret = parse_lpq_hpux(line,buf,first);
break;
case PRINT_QNX:
ret = parse_lpq_qnx(line,buf,first);
break;
case PRINT_LPRNG:
ret = parse_lpq_lprng(line,buf,first);
break;
case PRINT_PLP:
ret = parse_lpq_plp(line,buf,first);
break;
case PRINT_LPRNT:
ret = parse_lpq_nt(line,buf,first);
break;
case PRINT_LPROS2:
ret = parse_lpq_os2(line,buf,first);
break;
#ifdef DEVELOPER
case PRINT_VLP:
case PRINT_TEST:
ret = parse_lpq_vlp(line,buf,first);
break;
#endif
default:
ret = parse_lpq_bsd(line,buf,first);
break;
}
{
char *p = strchr_m(line,'\n');
if (p) *p = 0;
}
if (line && !ret && (printing_type==PRINT_LPRNG) )
{
if (line[0]==' ')
return ret;
}
if (status && !ret)
{
int i;
strlower_m(line);
switch (status->status) {
case LPSTAT_OK:
for (i=0; stat0_strings[i]; i++)
if (strstr_m(line,stat0_strings[i])) {
fstrcpy(status->message,line);
status->status=LPSTAT_OK;
return ret;
}
case LPSTAT_STOPPED:
for (i=0; stat1_strings[i]; i++)
if (strstr_m(line,stat1_strings[i])) {
fstrcpy(status->message,line);
status->status=LPSTAT_STOPPED;
return ret;
}
case LPSTAT_ERROR:
for (i=0; stat2_strings[i]; i++)
if (strstr_m(line,stat2_strings[i])) {
fstrcpy(status->message,line);
status->status=LPSTAT_ERROR;
return ret;
}
break;
}
}
return(ret);
}