/* $NetBSD: pcnfsd_print.c,v 1.12 2011/08/16 14:29:16 mbalmer Exp $ */ /* RE_SID: @(%)/usr/dosnfs/shades_SCCS/unix/pcnfsd/v2/src/SCCS/s.pcnfsd_print.c 1.7 92/01/24 19:58:58 SMI */ /* **===================================================================== ** Copyright (c) 1986,1987,1988,1989,1990,1991 by Sun Microsystems, Inc. ** @(#)pcnfsd_print.c 1.7 1/24/92 **===================================================================== */ /* **===================================================================== ** I N C L U D E F I L E S E C T I O N * ** * ** If your port requires different include files, add a suitable * ** #define in the customization section, and make the inclusion or * ** exclusion of the files conditional on this. * **===================================================================== */ #include #include #include #include #include #include #include #include #include #include #include #include #ifndef SYSV #include #endif #ifdef ISC_2_0 #include #endif #ifdef SHADOW_SUPPORT #include #endif #include "paths.h" #include "common.h" #include "pcnfsd.h" #include "extern.h" /* **--------------------------------------------------------------------- ** Other #define's **--------------------------------------------------------------------- */ #ifndef MAXPATHLEN #define MAXPATHLEN 1024 #endif /* ** The following definitions give the maximum time allowed for ** an external command to run (in seconds) */ #define MAXTIME_FOR_PRINT 10 #define MAXTIME_FOR_QUEUE 10 #define MAXTIME_FOR_CANCEL 10 #define MAXTIME_FOR_STATUS 10 #define QMAX 50 /* ** The following is derived from ucb/lpd/displayq.c */ #define SIZECOL 62 #define FILECOL 24 char *expand_alias __P((char *, char *, char *, char *)); pr_list list_virtual_printers __P((void)); char *map_printer_name __P((char *)); void substitute __P((char *, const char *, const char *)); int suspicious __P((char *)); int valid_pr __P((char *)); /* **--------------------------------------------------------------------- ** Misc. variable definitions **--------------------------------------------------------------------- */ struct stat statbuf; char pathname[MAXPATHLEN]; char new_pathname[MAXPATHLEN]; char sp_name[MAXPATHLEN] = SPOOLDIR; char tempstr[256]; char delims[] = " \t\r\n:()"; pr_list printers = NULL; pr_queue queue = NULL; /* **===================================================================== ** C O D E S E C T I O N * **===================================================================== */ /* * This is the latest word on the security check. The following * routine "suspicious()" returns non-zero if the character string * passed to it contains any shell metacharacters. * Callers will typically code * * if(suspicious(some_parameter)) reject(); */ int suspicious(s) char *s; { if (strpbrk(s, ";|&<>`'#!?*()[]^/${}\n\r\"\\:") != NULL) return 1; return 0; } int valid_pr(pr) char *pr; { char *p; pr_list curr; if (printers == NULL) build_pr_list(); if (printers == NULL) return (1); /* can't tell - assume it's good */ p = map_printer_name(pr); if (p == NULL) return (1); /* must be ok is maps to NULL! */ curr = printers; while (curr) { if (!strcmp(p, curr->pn)) return (1); curr = curr->pr_next; } return (0); } /* * get pathname of current directory and return to client * * Note: This runs as root on behalf of a client request. * As described in CERT advisory CA-96.08, be careful about * doing a chmod on something that could be a symlink... */ pirstat pr_init(sys, pr, sp) char *sys; char *pr; char **sp; { int dir_mode = 0777; int rc; mode_t oldmask; *sp = &pathname[0]; pathname[0] = '\0'; if (suspicious(sys) || suspicious(pr)) return (PI_RES_FAIL); /* * Make sure the server spool directory exists. * Never create it here - the sysadmin does that. */ if (stat(sp_name, &statbuf) || !S_ISDIR(statbuf.st_mode)) goto badspool; /* * Create the client spool directory if needed. * Just do the mkdir call and ignore EEXIST. * Mode of client directory should be 777. */ (void) snprintf(pathname, sizeof(pathname), "%s/%s", sp_name, sys); oldmask = umask(0); rc = mkdir(pathname, dir_mode); /* DON'T ignore this return code */ umask(oldmask); if ((rc < 0) && (errno != EEXIST)) goto badspool; /* By this point the client spool dir should exist. */ if (stat(pathname, &statbuf) || !S_ISDIR(statbuf.st_mode)) { /* No spool directory... */ badspool: (void) snprintf(tempstr, sizeof(tempstr), "rpc.pcnfsd: unable to set up spool directory %s\n", pathname); msg_out(tempstr); pathname[0] = '\0'; /* null to tell client bad vibes */ return (PI_RES_FAIL); } /* OK, we have a spool directory. */ if (!valid_pr(pr)) { pathname[0] = '\0'; /* null to tell client bad vibes */ return (PI_RES_NO_SUCH_PRINTER); } return (PI_RES_OK); } psrstat pr_start2(sys, pr, user, fname, opts, id) char *sys; char *pr; char *user; char *fname; char *opts; char **id; { char snum[20]; static char req_id[256]; char cmdbuf[256]; char resbuf[256]; FILE *fd; int i; char *xcmd; int failed = 0; #ifdef HACK_FOR_ROTATED_TRANSCRIPT char scratch[512]; #endif if (suspicious(sys) || suspicious(pr) || suspicious(user) || suspicious(fname)) return (PS_RES_FAIL); (void) snprintf(pathname, sizeof(pathname), "%s/%s/%s", sp_name, sys, fname); *id = &req_id[0]; req_id[0] = '\0'; if (stat(pathname, &statbuf)) { /* **----------------------------------------------------------------- ** We can't stat the file. Let's try appending '.spl' and ** see if it's already in progress. **----------------------------------------------------------------- */ (void) strlcat(pathname, ".spl", sizeof(pathname)); if (stat(pathname, &statbuf)) { /* **---------------------------------------------------------------- ** It really doesn't exist. **---------------------------------------------------------------- */ return (PS_RES_NO_FILE); } /* **------------------------------------------------------------- ** It is already on the way. **------------------------------------------------------------- */ return (PS_RES_ALREADY); } if (statbuf.st_size == 0) { /* **------------------------------------------------------------- ** Null file - don't print it, just kill it. **------------------------------------------------------------- */ (void) unlink(pathname); return (PS_RES_NULL); } /* **------------------------------------------------------------- ** The file is real, has some data, and is not already going out. ** We rename it by appending '.spl' and exec "lpr" to do the ** actual work. **------------------------------------------------------------- */ (void) strlcpy(new_pathname, pathname, sizeof(new_pathname)); (void) strlcat(new_pathname, ".spl", sizeof(new_pathname)); /* **------------------------------------------------------------- ** See if the new filename exists so as not to overwrite it. **------------------------------------------------------------- */ if (!stat(new_pathname, &statbuf)) { (void) strlcpy(new_pathname, pathname, sizeof(new_pathname)); /* rebuild a new name */ (void) snprintf(snum, sizeof(snum), "%d", rand()); /* get some number */ (void) strlcat(new_pathname, snum, 4); (void) strlcat(new_pathname, ".spl", sizeof(new_pathname)); /* new spool file */ } if (rename(pathname, new_pathname)) { /* **--------------------------------------------------------------- ** Should never happen. **--------------------------------------------------------------- */ (void) snprintf(tempstr, sizeof(tempstr), "rpc.pcnfsd: spool file rename (%s->%s) failed.\n", pathname, new_pathname); msg_out(tempstr); return (PS_RES_FAIL); } if (*opts == 'd') { /* **------------------------------------------------------ ** This is a Diablo print stream. Apply the ps630 ** filter with the appropriate arguments. **------------------------------------------------------ */ #if 0 /* XXX: Temporary fix for CERT advisory * CA-96.08 */ (void) run_ps630(new_pathname, opts); #else (void) snprintf(tempstr, sizeof(tempstr), "rpc.pcnfsd: ps630 filter disabled for %s\n", pathname); msg_out(tempstr); return (PS_RES_FAIL); #endif } /* ** Try to match to an aliased printer */ xcmd = expand_alias(pr, new_pathname, user, sys); if (!xcmd) { #ifdef SVR4 /* * Use the copy option so we can remove the orignal * spooled nfs file from the spool directory. */ snprintf(cmdbuf, sizeof(cmdbuf), "/usr/bin/lp -c -d%s %s", pr, new_pathname); #else /* SVR4 */ /* BSD way: lpr */ snprintf(cmdbuf, sizeof(cmdbuf), "%s/lpr -P%s %s", LPRDIR, pr, new_pathname); #endif /* SVR4 */ xcmd = cmdbuf; } if ((fd = su_popen(user, xcmd, MAXTIME_FOR_PRINT)) == NULL) { msg_out("rpc.pcnfsd: su_popen failed"); return (PS_RES_FAIL); } req_id[0] = '\0'; /* assume failure */ while (fgets(resbuf, 255, fd) != NULL) { i = strlen(resbuf); if (i) resbuf[i - 1] = '\0'; /* trim NL */ if (!strncmp(resbuf, "request id is ", 14)) /* New - just the first word is needed */ strlcpy(req_id, strtok(&resbuf[14], delims), sizeof(req_id)); else if (strembedded("disabled", resbuf)) failed = 1; } if (su_pclose(fd) == 255) msg_out("rpc.pcnfsd: su_pclose alert"); (void) unlink(new_pathname); return ((failed | interrupted) ? PS_RES_FAIL : PS_RES_OK); } /* * build_pr_list: determine which printers are valid. * on SVR4 use "lpstat -v" * on BSD use "lpc status" */ #ifdef SVR4 /* * In SVR4 the command to determine which printers are * valid is lpstat -v. The output is something like this: * * device for lp: /dev/lp0 * system for pcdslw: hinode * system for bletch: hinode (as printer hisname) * * On SunOS using the SysV compatibility package, the output * is more like: * * device for lp is /dev/lp0 * device for pcdslw is the remote printer pcdslw on hinode * device for bletch is the remote printer hisname on hinode * * It is fairly simple to create logic that will handle either * possibility: */ int build_pr_list() { pr_list last = NULL; pr_list curr = NULL; char buff[256]; FILE *p; char *cp; int saw_system; p = popen("lpstat -v", "r"); if (p == NULL) { msg_out("rpc.pcnfsd: unable to popen() lp status"); return (0); } while (fgets(buff, 255, p) != NULL) { cp = strtok(buff, delims); if (!cp) continue; if (!strcmp(cp, "device")) saw_system = 0; else if (!strcmp(cp, "system")) saw_system = 1; else continue; cp = strtok(NULL, delims); if (!cp || strcmp(cp, "for")) continue; cp = strtok(NULL, delims); if (!cp) continue; curr = (struct pr_list_item *) grab(sizeof(struct pr_list_item)); curr->pn = strdup(cp); curr->device = NULL; curr->remhost = NULL; curr->cm = strdup("-"); curr->pr_next = NULL; cp = strtok(NULL, delims); if (cp && !strcmp(cp, "is")) cp = strtok(NULL, delims); if (!cp) { free_pr_list_item(curr); continue; } if (saw_system) { /* "system" OR "system (as printer pname)" */ curr->remhost = strdup(cp); cp = strtok(NULL, delims); if (!cp) { /* simple format */ curr->device = strdup(curr->pn); } else { /* "sys (as printer pname)" */ if (strcmp(cp, "as")) { free_pr_list_item(curr); continue; } cp = strtok(NULL, delims); if (!cp || strcmp(cp, "printer")) { free_pr_list_item(curr); continue; } cp = strtok(NULL, delims); if (!cp) { free_pr_list_item(curr); continue; } curr->device = strdup(cp); } } else if (!strcmp(cp, "the")) { /* start of "the remote printer foo on bar" */ cp = strtok(NULL, delims); if (!cp || strcmp(cp, "remote")) { free_pr_list_item(curr); continue; } cp = strtok(NULL, delims); if (!cp || strcmp(cp, "printer")) { free_pr_list_item(curr); continue; } cp = strtok(NULL, delims); if (!cp) { free_pr_list_item(curr); continue; } curr->device = strdup(cp); cp = strtok(NULL, delims); if (!cp || strcmp(cp, "on")) { free_pr_list_item(curr); continue; } cp = strtok(NULL, delims); if (!cp) { free_pr_list_item(curr); continue; } curr->remhost = strdup(cp); } else { /* the local name */ curr->device = strdup(cp); curr->remhost = strdup(""); } if (last == NULL) printers = curr; else last->pr_next = curr; last = curr; } (void) pclose(p); /* ** Now add on the virtual printers, if any */ if (last == NULL) printers = list_virtual_printers(); else last->pr_next = list_virtual_printers(); return (1); } #else /* SVR4 */ /* * BSD way: lpc stat */ int build_pr_list() { pr_list last = NULL; pr_list curr = NULL; char buff[256]; FILE *p; char *cp; snprintf(buff, sizeof(buff), "%s/lpc status", LPCDIR); p = popen(buff, "r"); if (p == NULL) { msg_out("rpc.pcnfsd: unable to popen lpc stat"); return (0); } while (fgets(buff, 255, p) != NULL) { if (isspace((unsigned char)buff[0])) continue; if ((cp = strtok(buff, delims)) == NULL) continue; curr = (struct pr_list_item *) grab(sizeof(struct pr_list_item)); /* XXX - Should distinguish remote printers. */ curr->pn = strdup(cp); curr->device = strdup(cp); curr->remhost = strdup(""); curr->cm = strdup("-"); curr->pr_next = NULL; if (last == NULL) printers = curr; else last->pr_next = curr; last = curr; } (void) pclose(p); /* ** Now add on the virtual printers, if any */ if (last == NULL) printers = list_virtual_printers(); else last->pr_next = list_virtual_printers(); return (1); } #endif /* SVR4 */ void * grab(n) int n; { void *p; p = (void *) malloc(n); if (p == NULL) { msg_out("rpc.pcnfsd: malloc failure"); exit(1); } return (p); } void free_pr_list_item(curr) pr_list curr; { if (curr->pn) free(curr->pn); if (curr->device) free(curr->device); if (curr->remhost) free(curr->remhost); if (curr->cm) free(curr->cm); if (curr->pr_next) free_pr_list_item(curr->pr_next); /* recurse */ free(curr); } /* * build_pr_queue: used to show the print queue. * * Note that the first thing we do is to discard any * existing queue. */ #ifdef SVR4 /* ** In SVR4 the command to list the print jobs for printer ** lp is "lpstat lp" (or, equivalently, "lpstat -p lp"). ** The output looks like this: ** ** lp-2 root 939 Jul 10 21:56 ** lp-5 geoff 15 Jul 12 23:23 ** lp-6 geoff 15 Jul 12 23:23 ** ** If the first job is actually printing the first line ** is modified, as follows: ** ** lp-2 root 939 Jul 10 21:56 on lp ** ** I don't yet have any info on what it looks like if the printer ** is remote and we're spooling over the net. However for ** the purposes of rpc.pcnfsd we can simply say that field 1 is the ** job ID, field 2 is the submitter, and field 3 is the size. ** We can check for the presence of the string " on " in the ** first record to determine if we should count it as rank 0 or rank 1, ** but it won't hurt if we get it wrong. **/ pirstat build_pr_queue(pn, user, just_mine, p_qlen, p_qshown) printername pn; username user; int just_mine; int *p_qlen; int *p_qshown; { pr_queue last = NULL; pr_queue curr = NULL; char buff[256]; FILE *p; char *owner; char *job; char *totsize; if (queue) { free_pr_queue_item(queue); queue = NULL; } *p_qlen = 0; *p_qshown = 0; pn = map_printer_name(pn); if (pn == NULL || !valid_pr(pn) || suspicious(pn)) return (PI_RES_NO_SUCH_PRINTER); snprintf(buff, sizeof(buff), "/usr/bin/lpstat %s", pn); p = su_popen(user, buff, MAXTIME_FOR_QUEUE); if (p == NULL) { msg_out("rpc.pcnfsd: unable to popen() lpstat queue query"); return (PI_RES_FAIL); } while (fgets(buff, 255, p) != NULL) { job = strtok(buff, delims); if (!job) continue; owner = strtok(NULL, delims); if (!owner) continue; totsize = strtok(NULL, delims); if (!totsize) continue; *p_qlen += 1; if (*p_qshown > QMAX) continue; if (just_mine && strcasecmp(owner, user)) continue; *p_qshown += 1; curr = (struct pr_queue_item *) grab(sizeof(struct pr_queue_item)); curr->position = *p_qlen; curr->id = strdup(job); curr->size = strdup(totsize); curr->status = strdup(""); curr->system = strdup(""); curr->user = strdup(owner); curr->file = strdup(""); curr->cm = strdup("-"); curr->pr_next = NULL; if (last == NULL) queue = curr; else last->pr_next = curr; last = curr; } (void) su_pclose(p); return (PI_RES_OK); } #else /* SVR4 */ pirstat build_pr_queue(pn, user, just_mine, p_qlen, p_qshown) printername pn; username user; int just_mine; int *p_qlen; int *p_qshown; { pr_queue last = NULL; pr_queue curr = NULL; char buff[256]; FILE *p; char *cp; int i; char *rank; char *owner; char *job; char *files; char *totsize; if (queue) { free_pr_queue_item(queue); queue = NULL; } *p_qlen = 0; *p_qshown = 0; pn = map_printer_name(pn); if (pn == NULL || suspicious(pn)) return (PI_RES_NO_SUCH_PRINTER); snprintf(buff, sizeof(buff), "%s/lpq -P%s", LPRDIR, pn); p = su_popen(user, buff, MAXTIME_FOR_QUEUE); if (p == NULL) { msg_out("rpc.pcnfsd: unable to popen() lpq"); return (PI_RES_FAIL); } while (fgets(buff, 255, p) != NULL) { i = strlen(buff) - 1; buff[i] = '\0'; /* zap trailing NL */ if (i < SIZECOL) continue; if (!strncasecmp(buff, "rank", 4)) continue; totsize = &buff[SIZECOL - 1]; files = &buff[FILECOL - 1]; cp = totsize; cp--; while (cp > files && isspace((unsigned char)*cp)) *cp-- = '\0'; buff[FILECOL - 2] = '\0'; cp = strtok(buff, delims); if (!cp) continue; rank = cp; cp = strtok(NULL, delims); if (!cp) continue; owner = cp; cp = strtok(NULL, delims); if (!cp) continue; job = cp; *p_qlen += 1; if (*p_qshown > QMAX) continue; if (just_mine && strcasecmp(owner, user)) continue; *p_qshown += 1; curr = (struct pr_queue_item *) grab(sizeof(struct pr_queue_item)); curr->position = atoi(rank); /* active -> 0 */ curr->id = strdup(job); curr->size = strdup(totsize); curr->status = strdup(rank); curr->system = strdup(""); curr->user = strdup(owner); curr->file = strdup(files); curr->cm = strdup("-"); curr->pr_next = NULL; if (last == NULL) queue = curr; else last->pr_next = curr; last = curr; } (void) su_pclose(p); return (PI_RES_OK); } #endif /* SVR4 */ void free_pr_queue_item(curr) pr_queue curr; { if (curr->id) free(curr->id); if (curr->size) free(curr->size); if (curr->status) free(curr->status); if (curr->system) free(curr->system); if (curr->user) free(curr->user); if (curr->file) free(curr->file); if (curr->cm) free(curr->cm); if (curr->pr_next) free_pr_queue_item(curr->pr_next); /* recurse */ free(curr); } #ifdef SVR4 /* ** New - SVR4 printer status handling. ** ** The command we'll use for checking the status of printer "lp" ** is "lpstat -a lp -p lp". Here are some sample outputs: ** ** ** lp accepting requests since Wed Jul 10 21:49:25 EDT 1991 ** printer lp disabled since Thu Feb 21 22:52:36 EST 1991. available. ** new printer ** --- ** pcdslw not accepting requests since Fri Jul 12 22:30:00 EDT 1991 - ** unknown reason ** printer pcdslw disabled since Fri Jul 12 22:15:37 EDT 1991. available. ** new printer ** --- ** lp accepting requests since Wed Jul 10 21:49:25 EDT 1991 ** printer lp now printing lp-2. enabled since Sat Jul 13 12:02:17 EDT 1991. available. ** --- ** lp accepting requests since Wed Jul 10 21:49:25 EDT 1991 ** printer lp now printing lp-2. enabled since Sat Jul 13 12:02:17 EDT 1991. available. ** --- ** lp accepting requests since Wed Jul 10 21:49:25 EDT 1991 ** printer lp disabled since Sat Jul 13 12:05:20 EDT 1991. available. ** unknown reason ** --- ** pcdslw not accepting requests since Fri Jul 12 22:30:00 EDT 1991 - ** unknown reason ** printer pcdslw is idle. enabled since Sat Jul 13 12:05:28 EDT 1991. available. ** ** Note that these are actual outputs. The format (which is totally ** different from the lpstat in SunOS) seems to break down as ** follows: ** (1) The first line has the form "printername [not] accepting requests,,," ** This is trivial to decode. ** (2) The second line has several forms, all beginning "printer printername": ** (2.1) "... disabled" ** (2.2) "... is idle" ** (2.3) "... now printing jobid" ** The "available" comment seems to be meaningless. The next line ** is the "reason" code which the operator can supply when issuing ** a "disable" or "reject" command. ** Note that there is no way to check the number of entries in the ** queue except to ask for the queue and count them. */ pirstat get_pr_status(pn, avail, printing, qlen, needs_operator, status) printername pn; bool_t *avail; bool_t *printing; int *qlen; bool_t *needs_operator; char *status; { char buff[256]; char cmd[64]; FILE *p; int n; pirstat stat = PI_RES_NO_SUCH_PRINTER; /* assume the worst */ *avail = FALSE; *printing = FALSE; *needs_operator = FALSE; *qlen = 0; *status = '\0'; pn = map_printer_name(pn); if (pn == NULL || !valid_pr(pn) || suspicious(pn)) return (PI_RES_NO_SUCH_PRINTER); n = strlen(pn); snprintf(cmd, sizeof(cmd), "/usr/bin/lpstat -a %s -p %s", pn, pn); p = popen(cmd, "r"); if (p == NULL) { msg_out("rpc.pcnfsd: unable to popen() lp status"); return (PI_RES_FAIL); } stat = PI_RES_OK; while (fgets(buff, 255, p) != NULL) { if (!strncmp(buff, pn, n)) { if (!strstr(buff, "not accepting")) *avail = TRUE; continue; } if (!strncmp(buff, "printer ", 8)) { if (!strstr(buff, "disabled")) *printing = TRUE; if (strstr(buff, "printing")) strlcpy(status, "printing", sizeof(status)); else if (strstr(buff, "idle")) strlcpy(status, "idle", sizeof(status)); continue; } if (!strncmp(buff, "UX:", 3)) { stat = PI_RES_NO_SUCH_PRINTER; } } (void) pclose(p); return (stat); } #else /* SVR4 */ /* * BSD way: lpc status */ pirstat get_pr_status(pn, avail, printing, qlen, needs_operator, status) printername pn; bool_t *avail; bool_t *printing; int *qlen; bool_t *needs_operator; char *status; { char cmd[128]; char buff[256]; char buff2[256]; char pname[64]; FILE *p; char *cp; char *cp1; char *cp2; int n; pirstat pstat = PI_RES_NO_SUCH_PRINTER; /* assume the worst */ *avail = FALSE; *printing = FALSE; *needs_operator = FALSE; *qlen = 0; *status = '\0'; pn = map_printer_name(pn); if (pn == NULL || suspicious(pn)) return (PI_RES_NO_SUCH_PRINTER); snprintf(pname, sizeof(pname), "%s:", pn); n = strlen(pname); snprintf(cmd, sizeof(cmd), "%s/lpc status %s", LPCDIR, pn); p = popen(cmd, "r"); if (p == NULL) { msg_out("rpc.pcnfsd: unable to popen() lp status"); return (PI_RES_FAIL); } while (fgets(buff, 255, p) != NULL) { if (strncmp(buff, pname, n)) continue; /* ** We have a match. The only failure now is PI_RES_FAIL if ** lpstat output cannot be decoded */ pstat = PI_RES_FAIL; /* ** The next four lines are usually if the form ** ** queuing is [enabled|disabled] ** printing is [enabled|disabled] ** [no entries | N entr[y|ies] in spool area] ** */ while (fgets(buff, 255, p) != NULL && isspace((unsigned char)buff[0])) { cp = buff; while (isspace((unsigned char)*cp)) cp++; if (*cp == '\0') break; cp1 = cp; cp2 = buff2; while (*cp1 && *cp1 != '\n') { *cp2++ = tolower((unsigned char)*cp1); cp1++; } *cp1 = '\0'; *cp2 = '\0'; /* ** Now buff2 has a lower-cased copy and cp points at the original; ** both are null terminated without any newline */ if (!strncmp(buff2, "queuing", 7)) { *avail = (strstr(buff2, "enabled") != NULL); continue; } if (!strncmp(buff2, "printing", 8)) { *printing = (strstr(buff2, "enabled") != NULL); continue; } if (isdigit((unsigned char)buff2[0]) && (strstr(buff2, "entr") != NULL)) { *qlen = atoi(buff2); continue; } if (strstr(buff2, "attention") != NULL || strstr(buff2, "error") != NULL) *needs_operator = TRUE; if (*needs_operator || strstr(buff2, "waiting") != NULL) strlcpy(status, cp, sizeof(status)); } pstat = PI_RES_OK; break; } (void) pclose(p); return (pstat); } #endif /* SVR4 */ /* * pr_cancel: cancel a print job */ #ifdef SVR4 /* ** For SVR4 we have to be prepared for the following kinds of output: ** ** # cancel lp-6 ** request "lp-6" cancelled ** # cancel lp-33 ** UX:cancel: WARNING: Request "lp-33" doesn't exist. ** # cancel foo-88 ** UX:cancel: WARNING: Request "foo-88" doesn't exist. ** # cancel foo ** UX:cancel: WARNING: "foo" is not a request id or a printer. ** TO FIX: Cancel requests by id or by ** name of printer where printing. ** # su geoff ** $ cancel lp-2 ** UX:cancel: WARNING: Can't cancel request "lp-2". ** TO FIX: You are not allowed to cancel ** another's request. ** ** There are probably other variations for remote printers. ** Basically, if the reply begins with the string ** "UX:cancel: WARNING: " ** we can strip this off and look for one of the following ** (1) 'R' - should be part of "Request "xxxx" doesn't exist." ** (2) '"' - should be start of ""foo" is not a request id or..." ** (3) 'C' - should be start of "Can't cancel request..." ** ** The fly in the ointment: all of this can change if these ** messages are localized..... :-( */ pcrstat pr_cancel(pr, user, id) char *pr; char *user; char *id; { char cmdbuf[256]; char resbuf[256]; FILE *fd; pcrstat stat = PC_RES_NO_SUCH_JOB; pr = map_printer_name(pr); if (pr == NULL || suspicious(pr)) return (PC_RES_NO_SUCH_PRINTER); if (suspicious(id)) return (PC_RES_NO_SUCH_JOB); snprintf(cmdbuf, sizeof(cmdbuf), "/usr/bin/cancel %s", id); if ((fd = su_popen(user, cmdbuf, MAXTIME_FOR_CANCEL)) == NULL) { msg_out("rpc.pcnfsd: su_popen failed"); return (PC_RES_FAIL); } if (fgets(resbuf, 255, fd) == NULL) stat = PC_RES_FAIL; else if (!strstr(resbuf, "UX:")) stat = PC_RES_OK; else if (strstr(resbuf, "doesn't exist")) stat = PC_RES_NO_SUCH_JOB; else if (strstr(resbuf, "not a request id")) stat = PC_RES_NO_SUCH_JOB; else if (strstr(resbuf, "Can't cancel request")) stat = PC_RES_NOT_OWNER; else stat = PC_RES_FAIL; if (su_pclose(fd) == 255) msg_out("rpc.pcnfsd: su_pclose alert"); return (stat); } #else /* SVR4 */ /* * BSD way: lprm */ pcrstat pr_cancel(pr, user, id) char *pr; char *user; char *id; { char cmdbuf[256]; char resbuf[256]; FILE *fd; int i; pcrstat pstat = PC_RES_NO_SUCH_JOB; pr = map_printer_name(pr); if (pr == NULL || suspicious(pr)) return (PC_RES_NO_SUCH_PRINTER); if (suspicious(id)) return (PC_RES_NO_SUCH_JOB); snprintf(cmdbuf, sizeof(cmdbuf), "%s/lprm -P%s %s", LPRDIR, pr, id); if ((fd = su_popen(user, cmdbuf, MAXTIME_FOR_CANCEL)) == NULL) { msg_out("rpc.pcnfsd: su_popen failed"); return (PC_RES_FAIL); } while (fgets(resbuf, 255, fd) != NULL) { i = strlen(resbuf); if (i) resbuf[i - 1] = '\0'; /* trim NL */ if (strstr(resbuf, "dequeued") != NULL) pstat = PC_RES_OK; if (strstr(resbuf, "unknown printer") != NULL) pstat = PC_RES_NO_SUCH_PRINTER; if (strstr(resbuf, "Permission denied") != NULL) pstat = PC_RES_NOT_OWNER; } if (su_pclose(fd) == 255) msg_out("rpc.pcnfsd: su_pclose alert"); return (pstat); } #endif /* SVR4 */ /* ** New subsystem here. We allow the administrator to define ** up to NPRINTERDEFS aliases for printer names. This is done ** using the "/etc/pcnfsd.conf" file, which is read at startup. ** There are three entry points to this subsystem ** ** void add_printer_alias(char *printer, char *alias_for, char *command) ** ** This is invoked from "config_from_file()" for each ** "printer" line. "printer" is the name of a printer; note that ** it is possible to redefine an existing printer. "alias_for" ** is the name of the underlying printer, used for queue listing ** and other control functions. If it is "-", there is no ** underlying printer, or the administrative functions are ** not applicable to this printer. "command" ** is the command which should be run (via "su_popen()") if a ** job is printed on this printer. The following tokens may be ** embedded in the command, and are substituted as follows: ** ** $FILE - path to the file containing the print data ** $USER - login of user ** $HOST - hostname from which job originated ** ** Tokens may occur multiple times. If The command includes no ** $FILE token, the string " $FILE" is silently appended. ** ** pr_list list_virtual_printers() ** ** This is invoked from build_pr_list to generate a list of aliased ** printers, so that the client that asks for a list of valid printers ** will see these ones. ** ** char *map_printer_name(char *printer) ** ** If "printer" identifies an aliased printer, this function returns ** the "alias_for" name, or NULL if the "alias_for" was given as "-". ** Otherwise it returns its argument. ** ** char *expand_alias(char *printer, char *file, char *user, char *host) ** ** If "printer" is an aliased printer, this function returns a ** pointer to a static string in which the corresponding command ** has been expanded. Otherwise ot returns NULL. */ #define NPRINTERDEFS 16 int num_aliases = 0; struct { char *a_printer; char *a_alias_for; char *a_command; } alias[NPRINTERDEFS]; void add_printer_alias(printer, alias_for, command) char *printer; char *alias_for; char *command; { size_t l; if (num_aliases < NPRINTERDEFS) { alias[num_aliases].a_printer = strdup(printer); alias[num_aliases].a_alias_for = (strcmp(alias_for, "-") ? strdup(alias_for) : NULL); if (strstr(command, "$FILE")) alias[num_aliases].a_command = strdup(command); else { l = strlen(command) + 8; alias[num_aliases].a_command = (char *) grab(l); strlcpy(alias[num_aliases].a_command, command, l); strlcat(alias[num_aliases].a_command, " $FILE", l); } num_aliases++; } } pr_list list_virtual_printers() { pr_list first = NULL; pr_list last = NULL; pr_list curr = NULL; int i; if (num_aliases == 0) return (NULL); for (i = 0; i < num_aliases; i++) { curr = (struct pr_list_item *) grab(sizeof(struct pr_list_item)); curr->pn = strdup(alias[i].a_printer); if (alias[i].a_alias_for == NULL) curr->device = strdup(""); else curr->device = strdup(alias[i].a_alias_for); curr->remhost = strdup(""); curr->cm = strdup("(alias)"); curr->pr_next = NULL; if (last == NULL) first = curr; else last->pr_next = curr; last = curr; } return (first); } char * map_printer_name(printer) char *printer; { int i; for (i = 0; i < num_aliases; i++) { if (!strcmp(printer, alias[i].a_printer)) return (alias[i].a_alias_for); } return (printer); } void substitute(string, token, data) char *string; const char *token; const char *data; { char temp[512]; char *c; while ((c = strstr(string, token)) != NULL) { *c = '\0'; strlcpy(temp, string, sizeof(temp)); strlcat(temp, data, sizeof(temp)); c += strlen(token); strlcat(temp, c, sizeof(temp)); strcpy(string, temp); } } char * expand_alias(printer, file, user, host) char *printer; char *file; char *user; char *host; { static char expansion[512]; int i; for (i = 0; i < num_aliases; i++) { if (!strcmp(printer, alias[i].a_printer)) { strlcpy(expansion, alias[i].a_command, sizeof(expansion)); substitute(expansion, "$FILE", file); substitute(expansion, "$USER", user); substitute(expansion, "$HOST", host); return (expansion); } } return (NULL); }