2 * CDE - Common Desktop Environment
4 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
6 * These libraries and programs are free software; you can
7 * redistribute them and/or modify them under the terms of the GNU
8 * Lesser General Public License as published by the Free Software
9 * Foundation; either version 2 of the License, or (at your option)
12 * These libraries and programs are distributed in the hope that
13 * they will be useful, but WITHOUT ANY WARRANTY; without even the
14 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15 * PURPOSE. See the GNU Lesser General Public License for more
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with these libraries and programs; if not, write
20 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
21 * Floor, Boston, MA 02110-1301 USA
23 /* $TOG: ParseJobs.C /main/12 1998/08/03 16:30:29 mgreess $ */
25 * (c) Copyright 1993, 1994 Hewlett-Packard Company *
26 * (c) Copyright 1993, 1994 International Business Machines Corp. *
27 * (c) Copyright 1993, 1994 Sun Microsystems, Inc. *
28 * (c) Copyright 1993, 1994 Novell, Inc. *
33 #include <sys/types.h>
34 #include <sys/socket.h>
35 #include <netinet/in.h>
38 * XXXXX - AIX hack alert!!! This is needed for an AIX defect
39 * in the definition of inet_addr in <arpa/inet.h>
41 extern "C" in_addr_t inet_addr(const char *);
43 #include <arpa/inet.h>
54 #include <X11/Intrinsic.h>
56 #include "dtprintinfomsg.h"
60 #if defined(SVR4) || defined(SYSV)
68 extern "C" { int rresvport(int *); }
72 #define SETEUID(id) setresuid(getuid(), (uid_t)id, (uid_t)0);
75 extern "C" { extern int seteuid(uid_t); }
77 #define SETEUID(id) seteuid((uid_t)id)
80 #include "ParseJobs.h"
83 static int G_AIX_LOCAL = 0;
85 int RemotePrintJobs(char *server, char *printer, char **job_list, int *n_jobs)
92 if ((sockfd = ConnectToPrintServer(server, 15)) == -1)
97 if (SendPrintJobStatusReguest(sockfd, printer))
102 output = (char *)malloc(512);
104 char *out2 = out1 + 511;
108 if ((n = read(sockfd, out1, len)) == len)
112 output = (char *)realloc(output, (ctr * 512));
113 out1 = output + ((ctr - 1) * 512);
119 len = out2 - out1 + 1;
131 rc = ParseRemotePrintJobs(printer, output, job_list, n_jobs);
137 int ParseRemotePrintJobs(char *printer, char *jobs, char **job_list,
146 switch (DetermineOutput(jobs))
149 rc = ParseAIXv2PrintJobs(printer, jobs, job_list, n_jobs);
152 rc = ParseAIXv3PrintJobs(printer, jobs, job_list, n_jobs);
155 rc = ParseBSDPrintJobs(printer, jobs, job_list, n_jobs);
166 static void connect_timeout(int not_used)
171 // Create a connection to the remote printer server.
172 int ConnectToPrintServer(const char *rhost, int timeout)
176 struct sockaddr_in sin;
177 int s, lport = IPPORT_RESERVED - 1;
179 // Get the host address and port number to connect to.
180 if (!(hp = gethostbyname(rhost)))
182 unsigned long tmpaddr = inet_addr(rhost);
183 hp = gethostbyaddr((char *)&tmpaddr, sizeof(tmpaddr), AF_INET);
187 if (!(sp = getservbyname("printer", "tcp")))
190 memset((char *)&sin, 0, sizeof(sin));
191 memcpy((char *)&sin.sin_addr, hp->h_addr, hp->h_length);
192 sin.sin_family = hp->h_addrtype;
193 sin.sin_port = sp->s_port;
195 // run as user's UID, but with privileges from root
198 // Try connecting to the server.
199 s = rresvport(&lport);
201 signal(SIGALRM, connect_timeout);
206 if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) < 0)
216 int SendPrintJobStatusReguest(int sockfd, const char *printer)
218 char *buf = new char[100];
221 sprintf(buf, "%c%s \n", '\4', printer);
224 size = write(sockfd, buf, size);
225 if (write(sockfd, buf, size) != size)
235 JobOutputType DetermineOutput(char *output)
239 static int first_time = 1;
241 static char *aixv2_pattern;
242 static char *aixv3_pattern;
243 static char *bsd_pattern;
245 * Due to bug in regcmp/regex (bug id 1191772), change to C locale for
246 * this parsing work. And change back at end of procedure. This workaround
247 * appears to be ok since the print service output parsed here is in a
248 * "C locale" 8-bit form for inter-machine networking.
250 setlocale(LC_ALL, "C");
254 aixv2_pattern = regcmp("dev.*arg.*status.*request", (char *)NULL);
255 aixv3_pattern = regcmp("Queue.*Dev.*Status.*Job", (char *)NULL);
256 bsd_pattern = regcmp(":.*\\[.*\\]", (char *)NULL);
260 static regex_t aixv2_pattern;
261 static regex_t aixv3_pattern;
262 static regex_t bsd_pattern;
266 regcomp(&aixv2_pattern, "dev.*arg.*status.*request", REG_NOSUB);
267 regcomp(&aixv3_pattern, "Queue.*Dev.*Status.*Job", REG_NOSUB);
268 regcomp(&bsd_pattern, ":.*\\[.*\\]", REG_NOSUB);
274 if (s1 = strchr(s, '\n'))
277 while (i < 10 && s && *s)
280 if (regex(bsd_pattern, s)) {
281 setlocale(LC_ALL, "");
284 if (regex(aixv3_pattern, s)) {
285 setlocale(LC_ALL, "");
286 return AIX_V3_OUTPUT;
288 if (regex(aixv2_pattern, s)) {
289 setlocale(LC_ALL, "");
290 return AIX_V2_OUTPUT;
293 if (!regexec(&bsd_pattern, s, (size_t)0, NULL, 0))
295 if (!regexec(&aixv3_pattern, s, (size_t)0, NULL, 0))
296 return AIX_V3_OUTPUT;
297 if (!regexec(&aixv2_pattern, s, (size_t)0, NULL, 0))
298 return AIX_V2_OUTPUT;
301 if (s1 = strchr(s, '\n'))
306 setlocale(LC_ALL, "");
308 return UNKNOWN_OUTPUT;
311 ///////////////////////////// LOCAL PARSERS /////////////////////////////////
314 void LocalPrintJobs(char *printer, char **job_list, int *n_jobs)
317 char *cmd = new char[60];
319 sprintf(cmd, "LANG=C enq -LP%s", printer);
320 Invoke *_thread = new Invoke(cmd, &output);
322 // run as user's UID, but with privileges from root
325 ParseAIXv3PrintJobs(printer, output, job_list, n_jobs);
337 // SUN LOCAL PARSER, actually this gets the local information from the file
338 // system, it should have the good performance since no processes (lpstat)
346 } StatusLineStruct, *StatusLine, **StatusLineList;
348 #define TMP_DIR "/var/spool/lp/tmp"
349 #define REQ_DIR "/var/spool/lp/requests/%s/"
350 #define SPOOL_DIR "/var/spool/lp/tmp/%s/"
352 static void check_dir(char *printer, char *tmp_dir, StatusLineList *job_list,
353 int *n_jobs, int prev_n_jobs);
354 static int SortJobs(const void *, const void *);
356 void LocalPrintJobs(char *printer, char **return_job_list, int *return_n_jobs)
359 struct dirent *dir_struct;
360 struct stat statbuff;
367 static char *job_list1 = NULL;
368 static int prev_buf_size = 0;
369 static StatusLineList job_list = NULL;
370 static int prev_n_jobs = 0;
372 if (prev_buf_size == 0)
374 prev_buf_size = BUFSIZ;
375 job_list1 = (char *)malloc(prev_buf_size);
382 // run as user's UID, but with privileges from root
386 if (getenv("TMP_DIR"))
387 chdir(getenv("TMP_DIR"));
390 if (!(lp_tmp_dir = opendir(".")))
392 *return_job_list = NULL;
399 dir_struct = readdir(lp_tmp_dir);
400 for ( ; dir_struct ; dir_struct = readdir(lp_tmp_dir))
402 if (*dir_struct->d_name == '.')
404 if (stat(dir_struct->d_name, &statbuff) >= 0 &&
405 statbuff.st_mode & S_IFDIR)
407 chdir(dir_struct->d_name);
408 check_dir(printer, dir_struct->d_name, &job_list, &n_jobs,
413 closedir(lp_tmp_dir);
414 prev_n_jobs = prev_n_jobs > n_jobs ? prev_n_jobs : n_jobs;
415 qsort(job_list, n_jobs, sizeof(StatusLineList), SortJobs);
416 for (i = 0; i < n_jobs; i++)
418 len = strlen(job_list[i]->line);
419 if (prev_buf_size < (current_size + len + 1))
420 job_list1 = (char *) realloc(job_list1, (current_size + len + 1) *
422 memcpy(job_list1 + current_size, job_list[i]->line, len);
425 *(job_list1 + current_size) = '\0';
426 prev_buf_size = prev_buf_size > current_size ? prev_buf_size : current_size;
427 *return_job_list = job_list1;
428 *return_n_jobs = n_jobs;
433 static void check_dir(char *printer, char *tmp_dir, StatusLineList *job_list,
434 int *n_jobs, int prev_n_jobs)
437 struct dirent *dir_struct;
453 StatusLineList j_list;
455 char *filename = new char[200];
456 char *filename1 = new char[200];
457 char *request = new char[300];
458 char *spool_dir = new char[300];
460 if (getenv("REQ_DIR"))
461 sprintf(request, getenv("REQ_DIR"), tmp_dir);
463 sprintf(request, REQ_DIR, tmp_dir);
464 req_len = strlen(request);
465 sprintf(spool_dir, SPOOL_DIR, tmp_dir);
466 spool_len = strlen(spool_dir);
468 if (!(lp_tmp_dir = opendir(".")))
477 dir_struct = readdir(lp_tmp_dir);
478 for ( ; dir_struct ; dir_struct = readdir(lp_tmp_dir))
480 int len = strlen(dir_struct->d_name);
483 if (strcmp(dir_struct->d_name + len - 2, "-0"))
485 *(request + req_len) = '\0';
486 strcat(request + req_len, dir_struct->d_name);
487 if (!(req = fopen(request, "r")))
489 if (!(job = fopen(dir_struct->d_name, "r")))
502 while (found && fgets(buf, 100, job))
504 line = strtok(buf, "\n");
508 if (!strcmp("immediate", line + 2))
512 if (strcmp(printer, line + 2))
516 *(spool_dir + spool_len) = '\0';
517 strncat(spool_dir, dir_struct->d_name, len - 1);
518 strcat(spool_dir, "1");
519 if (strcmp(spool_dir, line + 2))
520 strcpy(filename1, line + 2);
525 if (s = strrchr(line, ':'))
527 if (s = strrchr(line, '\''))
530 for ( ; *s == ' '; s++)
536 if (s = strstr(line, "-T"))
552 if (filename[i] != '\\')
567 if (s = strstr(line, "\\n"))
569 strcpy(title, line + 2);
578 fgets(buf, 100, req);
579 line = strtok(buf, "\n");
583 if (s = strchr(line, '!'))
590 if (s = strchr(owner, '.'))
596 case 5: strcpy(job_size, line); break;
598 secs = (time_t)atoi(line);
599 strftime(date_str, 100, "%b %e|%T", localtime(&secs));
605 if (s = strstr(dir_struct->d_name, "-0"))
615 sprintf(filename, "%s-%s", printer, dir_struct->d_name);
618 if (*n_jobs >= prev_n_jobs)
621 *job_list = (StatusLineList) malloc(sizeof(StatusLine));
623 *job_list = (StatusLineList) realloc(*job_list, (*n_jobs + 1) *
626 j_list[*n_jobs] = (StatusLine) malloc(sizeof(StatusLineStruct));
627 len = 7 + strlen(printer) + strlen(jobname) + strlen(date_str) +
628 strlen(dir_struct->d_name) + strlen(owner) + strlen(job_size);
629 j_list[*n_jobs]->line = (char *) malloc(len);
634 len = 7 + strlen(printer) + strlen(jobname) + strlen(date_str) +
635 strlen(dir_struct->d_name) + strlen(owner) + strlen(job_size);
636 j_list[*n_jobs]->line = (char *)realloc(j_list[*n_jobs]->line, len);
638 sprintf(j_list[*n_jobs]->line, "%s|%s|%s|%s|%s|%s\n", printer,
639 jobname, dir_struct->d_name, owner, date_str, job_size);
640 j_list[*n_jobs]->secs = (long) secs;
641 j_list[*n_jobs]->immediate = immediate;
647 closedir(lp_tmp_dir);
654 static int SortJobs(const void *_first, const void *_second)
656 StatusLineList first = (StatusLineList)_first;
657 StatusLineList second = (StatusLineList)_second;
659 if ((**first).immediate && !(**second).immediate)
661 if (!(**first).immediate && (**second).immediate)
663 if ((**first).immediate)
664 return (int)((**second).secs - (**first).secs);
666 return (int)((**first).secs - (**second).secs);
669 #endif // SUN LOCAL PARSER
673 /* HP LOCAL PARSER - have to parse the following
675 Need to parse the following 2 forms of output:
677 coseps-28 guest priority 0 Aug 9 12:54 on coseps
682 coseps-29 guest priority 0 Aug 9 12:56 on hostname
683 (standard input) 31160 bytes
686 void LocalPrintJobs(char *printer, char **return_job_list, int *return_n_jobs)
688 char *buf = new char[300];
703 static char *job_list = NULL;
704 static int prev_buf_size = 0;
706 sprintf(buf, "LANG=C lpstat -i -o%s", printer);
707 Invoke *_thread = new Invoke(buf, &output);
709 if (prev_buf_size == 0)
711 prev_buf_size = BUFSIZ;
712 job_list = (char *)malloc(prev_buf_size);
719 if (s1 = strchr(s, '\n'))
723 qname = strtok(s, "-");
724 jnumber = strtok(NULL, " ");
725 owner = strtok(NULL, " ");
728 month = strtok(NULL, " ");
729 day = strtok(NULL, " ");
730 stime = strtok(NULL, " \n");
732 hostname = strtok(NULL, " \n");
734 if (s1 = strchr(s, '\n'))
736 for (jname = s; *jname == '\t' || *jname == ' '; jname++)
738 jsize = strrchr(s, ' ');
740 jsize = strrchr(s, ' ') + 1;
741 for (c = jsize - 1; *c == ' '; c--)
744 if (hostname && strcmp(qname, hostname))
745 sprintf(buf, "%s|%s|%s|%s@%s|%s %s|%s|%s\n", qname, jname, jnumber,
746 owner, hostname, month, day, stime, jsize);
748 sprintf(buf, "%s|%s|%s|%s|%s %s|%s|%s\n", qname, jname, jnumber,
749 owner, month, day, stime, jsize);
752 if (prev_buf_size < (current_size + len + 1))
753 job_list = (char *) realloc(job_list, (current_size + len + 1) *
755 memcpy(job_list + current_size, buf, len);
759 if (s1 = strchr(s, '\n'))
762 *(job_list + current_size) = '\0';
763 prev_buf_size = prev_buf_size > current_size ? prev_buf_size : current_size;
764 *return_job_list = job_list;
769 #endif // HP LOCAL PARSER
771 #if defined(__linux__) || defined(CSRG_BASED)
775 #define NEXT_OUTPUT_LINE(line,rest) \
779 if (line && (rest = strchr(line, '\n'))) \
781 } while (NULL != line && 0 == *line);
783 void LocalPrintJobs(char *printer, char **return_job_list, int *return_n_jobs)
785 char *buf = new char[1000];
804 static char *job_list = NULL;
805 static int prev_buf_size = 0;
807 #if defined(__linux__) || defined(__OpenBSD__) || defined(__NetBSD__)
808 snprintf(buf, 1000, "LANG=C lpq -P%s", printer);
809 #elif defined(__FreeBSD__)
810 snprintf(buf, 1000, "LANG=C /usr/local/bin/lpq -P%s", printer);
813 Invoke *_thread = new Invoke(buf, &output);
815 if (prev_buf_size == 0)
817 prev_buf_size = BUFSIZ;
818 job_list = (char*) malloc(prev_buf_size);
826 NEXT_OUTPUT_LINE(s,s1);
829 // Parse the optional "Requests on" line of output to verify printer name.
830 // "Requests on ansel:"
833 char *opt_requests_on_line = "Requests on ";
834 if (0 == strncmp(s, opt_requests_on_line, strlen(opt_requests_on_line)))
836 char *requests = strtok(s, " ");
837 char *on = strtok(NULL, " ");
839 qname = strtok(NULL, " :\n");
840 if (0 != strncmp(qname, printer, strlen(qname)))
843 "Found the wrong printer: looking for '%s'; found '%s'\n",
846 NEXT_OUTPUT_LINE(s,s1);
851 // Parse the host/date line of output to collect host, date, and time.
852 // "Fri Oct 4 09:08:48 1996: "
855 hostname = strtok(s, ":");
856 day = strtok(NULL, " ");
857 month = strtok(NULL, " ");
858 date = strtok(NULL, " ");
859 stime = strtok(NULL, " ");
860 year = strtok(NULL, " \n");
863 NEXT_OUTPUT_LINE(s,s1);
866 // If this is the "no entries" line, we're done. Return.
870 char *no_entries_line = "no entries";
871 if (0 == strncmp(s, no_entries_line, strlen(no_entries_line)))
873 *return_job_list = job_list;
880 // Parse the optional printer status line.
881 // "federal is ready and printing via dev"
884 char *buffer = new char[128];
885 char *opt_status_line = buffer;
887 sprintf(buffer, "%s is ready and printing via ", printer);
888 if (0 == strncmp(s, opt_status_line, strlen(opt_status_line)))
890 qname = strtok(s, " \t");
896 network = strtok(s, " \n");
898 NEXT_OUTPUT_LINE(s,s1);
905 // Parse the legend line.
906 // "Rank Owner Job Files Total Size"
908 // "Rank Pri Owner Job Files Total Size"
913 tmp = strtok(s, " ");
914 if (strcmp(tmp, "Rank"))
915 fprintf(stderr, "Unexpected legend column: %s != Rank\n", tmp);
917 tmp = strtok(NULL, " ");
918 if (0 == strcmp(tmp, "Pri"))
921 tmp = strtok(NULL, " ");
923 if (strcmp(tmp, "Owner"))
924 fprintf(stderr, "Unexpected legend column: %s != Owner\n", tmp);
926 tmp = strtok(NULL, " ");
927 if (strcmp(tmp, "Job"))
928 fprintf(stderr, "Unexpected legend column: %s != Job\n", tmp);
930 tmp = strtok(NULL, " ");
931 if (strcmp(tmp, "Files"))
932 fprintf(stderr, "Unexpected legend column: %s != Files\n", tmp);
934 tmp = strtok(NULL, " ");
935 if (strcmp(tmp, "Total"))
936 fprintf(stderr, "Unexpected legend column: %s != Total\n", tmp);
938 tmp = strtok(NULL, " \n");
939 if (strcmp(tmp, "Size"))
940 fprintf(stderr, "Unexpected legend column: %s != Size\n", tmp);
944 NEXT_OUTPUT_LINE(s,s1);
947 // Parse the job lines.
948 // "active mgreess 65 (standard input) 13482 bytes"
950 // "1st 0 mgreess 7 ParseJobs.C 33367 bytes"
957 owner = strtok(NULL, " ");
958 jnumber = strtok(NULL, " ");
959 jname = strtok(NULL," ");
960 jsize = strtok(NULL," ");
962 if (NULL == owner || NULL == jnumber || NULL == jname || NULL == jsize)
964 NEXT_OUTPUT_LINE(s,s1);
971 if (hostname && strcmp(qname, hostname))
972 sprintf(buf, "%s|%s|%s|%s@%s|%s %s|%s|%s\n", qname, jname, jnumber,
973 owner, hostname, month, date, stime, jsize);
975 sprintf(buf, "%s|%s|%s|%s|%s %s|%s|%s\n", qname, jname, jnumber,
976 owner, month, date, stime, jsize);
978 printf("qname, jname, jnumber, owner, ");
979 printf("hostname, month, date, stime, jsize\n");
983 if (prev_buf_size < (current_size + len + 1))
985 (char*) realloc(job_list, (current_size + len + 1) * sizeof(char*));
986 memcpy(job_list + current_size, buf, len);
990 NEXT_OUTPUT_LINE(s,s1);
993 *(job_list + current_size) = '\0';
994 prev_buf_size = prev_buf_size > current_size ? prev_buf_size : current_size;
995 *return_job_list = job_list;
999 #endif // Linux local parser
1002 /* BSD PARSER - have to parse the following
1004 BSD, HP, and SUN output
1005 Warning: test1 is down: b906ps3 is ready and printing
1006 Warning: no daemon present
1008 root: 1st [job 006b906ps3.austin.ibm.com]
1010 root: 2nd [job 006b906ps3.austin.ibm.com]
1011 <File name not available> 421 bytes
1014 int ParseBSDPrintJobs(char *printer, char *jobs,
1015 char **return_job_list, int *return_n_jobs)
1027 char *buf = new char[300];
1028 static char *job_list = NULL;
1029 static int prev_buf_size = 0;
1030 static int first_time = 1;
1034 static char *bsd_pattern;
1036 * Due to bug in regcmp/regex (bug id 1191772), change to C locale for
1037 * this parsing work. And change back at end of procedure. This workaround
1038 * appears to be ok since the print service output parsed here is in a
1039 * "C locale" 8-bit form for inter-machine networking.
1041 setlocale(LC_ALL, "C");
1045 bsd_pattern = regcmp(":.*\\[.*\\]", (char *)NULL);
1049 static regex_t bsd_pattern;
1053 regcomp(&bsd_pattern, ":.*\\[.*\\]", REG_NOSUB);
1058 if (prev_buf_size == 0)
1060 prev_buf_size = BUFSIZ;
1061 job_list = (char *)malloc(prev_buf_size);
1067 sdate = MESSAGE(NotAvailableL);
1070 s = strtok(jobs, "\n");
1074 if (regex(bsd_pattern, s))
1076 if (!regexec(&bsd_pattern, s, (size_t)0, NULL, 0))
1084 for (s = strchr(s, ' ') + 1; isdigit((int)*s); s++)
1087 for (s1 = s; *s1 == ' '; s1++)
1090 if (s = strchr(hostname, '.'))
1093 *(strchr(hostname, ']')) = '\0';
1095 s = strtok(NULL, "\n");
1096 for (s1 = s; *s1 == ' ' || *s1 == '\t'; s1++)
1099 s1 = strrchr(s, ' ');
1101 s1 = strrchr(s, ' ');
1103 for ( ; *s1 == ' '; s1--)
1106 sprintf(buf, "%s|%s|%s|%s@%s|%s|%s|%s\n", printer, jname, jnumber,
1107 owner, hostname, sdate, stime, jsize);
1109 if (prev_buf_size < (current_size + len + 1))
1110 job_list = (char *) realloc(job_list, (current_size + len + 1) *
1112 memcpy(job_list + current_size, buf, len);
1113 current_size += len;
1118 if (strstr(s, "down"))
1121 s = strtok(NULL, "\n");
1123 *(job_list + current_size) = '\0';
1124 prev_buf_size = prev_buf_size > current_size ? prev_buf_size : current_size;
1125 *return_job_list = job_list;
1128 setlocale(LC_ALL, "");
1135 /* AIX version 3 and 4 PARSER - have to parse the following
1137 Queue Dev Status Job Name From To
1138 Submitted Rnk Pri Blks Cp PP %
1139 ------- ----- --------- --------- --- --- ----- --- ---- --
1140 bsh bshde RUNNING 956 STDIN.14937 root root
1141 08/02/94 09:55:44 1 15 1 1 0 0
1142 /var/spool/qdaemon/tOlkCSM
1146 Queue Dev Status Job Name From To
1147 Submitted Rnk Pri Blks Cp PP %
1148 ------- ----- --------- --------- --- --- ----- --- ---- --
1150 QUEUED 957 STDIN.14952 root root
1151 08/02/94 10:17:53 1 15 1 1
1152 /var/spool/qdaemon/tOmgCrx
1155 Also need to parse filenames that are titles: Example, "My Report" below.
1157 QUEUED 957 My Report root root
1158 08/02/94 10:17:53 1 15 1 1
1159 /var/spool/qdaemon/tOmgCrx
1163 int ParseAIXv3PrintJobs(char *_printer, char *jobs,
1164 char **return_job_list, int *return_n_jobs)
1166 char *buf = new char[300];
1167 struct stat statbuff;
1181 static char *job_list = NULL;
1182 static int prev_buf_size = 0;
1184 strcpy(printer, _printer);
1185 if (s = strchr(printer, ':'))
1188 if (prev_buf_size == 0)
1190 prev_buf_size = BUFSIZ;
1191 job_list = (char *)malloc(prev_buf_size);
1199 s1 = strchr(s, '\n');
1201 s1 = strchr(s, '\n');
1203 s1 = strchr(s, '\n');
1205 if (s1 = strchr(s, '\n'))
1207 if (strstr(s, "DOWN"))
1211 dollar1 = strtok(s, " ");
1212 if (!strncmp(dollar1, printer, strlen(dollar1)))
1217 jnumber = strtok(NULL, " ");
1218 if (!(jnumber && *jnumber))
1221 if (s1 = strchr(s, '\n'))
1225 jname = strtok(NULL, "\n");
1226 if (!(jname && *jname))
1229 if (s1 = strchr(s, '\n'))
1233 for (c = jname + strlen(jname) - 1; *c == ' '; c--)
1235 for ( ; *c != ' '; c--)
1237 for ( ; *c == ' '; c--)
1240 for ( ; *c != ' '; c--)
1243 for ( ; *c == ' '; c--)
1246 for (c = jname; *c == ' '; c++)
1250 if (s1 = strchr(s, '\n'))
1252 sdate = strtok(s, " ");
1253 stime = strtok(NULL, " ");
1256 jsize = strtok(NULL, " ");
1258 if (s1 = strchr(s, '\n'))
1260 c = strtok(s, " \n");
1261 if (strstr(c, jname))
1264 statbuff.st_size = atoi(jsize) * 512;
1265 else if (stat(c, &statbuff) < 0)
1266 statbuff.st_size = atoi(jsize) * 512;
1268 sprintf(buf, "%s|%s|%s|%s|%s|%s|%d\n", printer, jname, jnumber,
1269 owner, sdate, stime, (int)statbuff.st_size);
1271 if (prev_buf_size < (current_size + len + 1))
1272 job_list = (char *) realloc(job_list, (current_size + len + 1) *
1274 memcpy(job_list + current_size, buf, len);
1275 current_size += len;
1278 if (s1 = strchr(s, '\n'))
1281 *(job_list + current_size) = '\0';
1282 prev_buf_size = prev_buf_size > current_size ? prev_buf_size : current_size;
1283 *return_job_list = job_list;
1288 /* AIX version 2 PARSER - have to parse the following
1290 dev arg status request pp output % done
1291 --- ---------- ---------- -------------------- --------- ------
1298 queue user request blks cops pri time to
1299 ----- ----------------- -------------------- ---- ---- --- ----- --------
1300 ts1 root /etc/motd 2 1 15 15:57 root
1301 ts1 root@warpspeed /etc/rc.afs 3 1 15 16:03 root@war
1302 ts2 root /.profile 1 1 15 16:05 root
1303 ts2 root /.profile 1 1 15 16:06 root
1304 ts2 root@warpspeed /etc/rc.afs 3 1 15 16:07 root@war
1308 int ParseAIXv2PrintJobs(char *printer, char *jobs,
1309 char **return_job_list, int *return_n_jobs)
1311 char *buf = new char[300];
1325 static char *job_list = NULL;
1326 static int prev_buf_size = 0;
1328 if (prev_buf_size == 0)
1330 prev_buf_size = BUFSIZ;
1331 job_list = (char *)malloc(prev_buf_size);
1337 sdate = MESSAGE(NotAvailableL);
1341 s1 = strchr(s, '\n');
1343 s1 = strchr(s, '\n');
1345 if (s1 = strchr(s, '\n'))
1349 device = strtok(s, " ");
1350 tmp = strtok(NULL, " ");
1351 c = strtok(NULL, " ");
1352 if (!strcmp(tmp, printer))
1354 if (strstr(c, "OFF"))
1359 if (s1 = strchr(s, '\n'))
1363 if (s1 = strchr(s, '\n'))
1367 tmp = strtok(s, " ");
1368 if (!tmp || strcmp(tmp, device))
1372 if (s1 = strchr(s, '\n'))
1376 owner = strtok(NULL, " ");
1377 jname = strtok(NULL, " ");
1378 jsize = strtok(NULL, " ");
1381 stime = strtok(NULL, " ");
1382 if (c = strchr(owner, '.'))
1384 sprintf(buf, "%s|%s|%s|%s|%s|%s|%d\n", printer, jname, jnumber,
1385 owner, sdate, stime, atoi(jsize) * 512);
1387 if (prev_buf_size < (current_size + len + 1))
1388 job_list = (char *) realloc(job_list, (current_size + len + 1) *
1390 memcpy(job_list + current_size, buf, len);
1391 current_size += len;
1394 if (s1 = strchr(s, '\n'))
1397 *(job_list + current_size) = '\0';
1398 prev_buf_size = prev_buf_size > current_size ? prev_buf_size : current_size;
1399 *return_job_list = job_list;