usr.sbin/lpr/common_source/common.c

   1 /*      $NetBSD: common.c,v 1.39 2009/01/18 09:57:26 lukem Exp $        */
   2
   3 /*
   4  * Copyright (c) 1983, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  * (c) UNIX System Laboratories, Inc.
   7  * All or some portions of this file are derived from material licensed
   8  * to the University of California by American Telephone and Telegraph
   9  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  10  * the permission of UNIX System Laboratories, Inc.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  */
  36
  37 #include <sys/cdefs.h>
  38 #ifndef lint
  39 #if 0
  40 static char sccsid[] = "@(#)common.c    8.5 (Berkeley) 4/28/95";
  41 #else
  42 __RCSID("$NetBSD: common.c,v 1.39 2009/01/18 09:57:26 lukem Exp $");
  43 #endif
  44 #endif /* not lint */
  45
  46 #include <sys/param.h>
  47 #include <sys/stat.h>
  48 #include <sys/time.h>
  49
  50 #include <sys/socket.h>
  51 #include <netinet/in.h>
  52 #include <arpa/inet.h>
  53 #include <netdb.h>
  54
  55 #include <dirent.h>
  56 #include <errno.h>
  57 #include <unistd.h>
  58 #include <stdlib.h>
  59 #include <stdio.h>
  60 #include <string.h>
  61 #include <ifaddrs.h>
  62 #include "lp.h"
  63 #include "lp.local.h"
  64 #include "pathnames.h"
  65
  66 /*
  67  * Routines and data common to all the line printer functions.
  68  */
  69
  70 const char      *AF;            /* accounting file */
  71 long             BR;            /* baud rate if lp is a tty */
  72 const char      *CF;            /* name of cifplot filter (per job) */
  73 const char      *DF;            /* name of tex filter (per job) */
  74 long             DU;            /* daeomon user-id */
  75 long             FC;            /* flags to clear if lp is a tty */
  76 const char      *FF;            /* form feed string */
  77 long             FS;            /* flags to set if lp is a tty */
  78 const char      *GF;            /* name of graph(1G) filter (per job) */
  79 long             HL;            /* print header last */
  80 const char      *IF;            /* name of input filter (created per job) */
  81 const char      *LF;            /* log file for error messages */
  82 const char      *LO;            /* lock file name */
  83 const char      *LP;            /* line printer device name */
  84 long             MC;            /* maximum number of copies allowed */
  85 const char      *MS;            /* stty flags to set if lp is a tty */
  86 long             MX;            /* maximum number of blocks to copy */
  87 const char      *NF;            /* name of ditroff filter (per job) */
  88 const char      *OF;            /* name of output filter (created once) */
  89 const char      *PF;            /* name of postscript filter (per job) */
  90 long             PL;            /* page length */
  91 long             PW;            /* page width */
  92 long             PX;            /* page width in pixels */
  93 long             PY;            /* page length in pixels */
  94 const char      *RF;            /* name of fortran text filter (per job) */
  95 const char      *RG;            /* resricted group */
  96 const char      *RM;            /* remote machine name */
  97 const char      *RP;            /* remote printer name */
  98 long             RS;            /* restricted to those with local accounts */
  99 long             RW;            /* open LP for reading and writing */
 100 long             SB;            /* short banner instead of normal header */
 101 long             SC;            /* suppress multiple copies */
 102 const char      *SD;            /* spool directory */
 103 long             SF;            /* suppress FF on each print job */
 104 long             SH;            /* suppress header page */
 105 const char      *ST;            /* status file name */
 106 const char      *TF;            /* name of troff filter (per job) */
 107 const char      *TR;            /* trailer string to be output when Q empties */
 108 const char      *VF;            /* name of vplot/vrast filter (per job) */
 109 long             XC;            /* flags to clear for local mode */
 110 long             XS;            /* flags to set for local mode */
 111
 112 char    line[BUFSIZ];
 113 int     remote;         /* true if sending files to a remote host */
 114
 115 extern uid_t    uid, euid;
 116
 117 static int compar(const void *, const void *);
 118
 119 const char *
 120 gethost(const char *hname)
 121 {
 122         const char *p = strchr(hname, '@');
 123         return p ? ++p : hname;
 124 }
 125
 126 /*
 127  * Create a TCP connection to host "rhost". If "rhost" is of the
 128  * form port@host, use the specified port. Otherwise use the
 129  * default printer port. Most of this code comes from rcmd.c.
 130  */
 131 int
 132 getport(const char *rhost)
 133 {
 134         struct addrinfo hints, *res, *r;
 135         u_int timo = 1;
 136         int s, lport = IPPORT_RESERVED - 1;
 137         int error;
 138         int refuse, trial;
 139         char hbuf[NI_MAXSERV], *ptr;
 140         const char *port = "printer";
 141         const char *hostname = rhost;
 142
 143         /*
 144          * Get the host address and port number to connect to.
 145          */
 146         if (rhost == NULL)
 147                 fatal("no remote host to connect to");
 148         (void)strlcpy(hbuf, rhost, sizeof(hbuf));
 149         for (ptr = hbuf; *ptr; ptr++)
 150                 if (*ptr == '@') {
 151                         *ptr++ = '\0';
 152                         port = hbuf;
 153                         hostname = ptr;
 154                         break;
 155                 }
 156         (void)memset(&hints, 0, sizeof(hints));
 157         hints.ai_family = PF_UNSPEC;
 158         hints.ai_socktype = SOCK_STREAM;
 159         error = getaddrinfo(hostname, port, &hints, &res);
 160         if (error)
 161                 fatal("printer/tcp: %s", gai_strerror(error));
 162
 163         /*
 164          * Try connecting to the server.
 165          */
 166 retry:
 167         s = -1;
 168         refuse = trial = 0;
 169         for (r = res; r; r = r->ai_next) {
 170                 trial++;
 171 retryport:
 172                 seteuid(euid);
 173                 s = rresvport_af(&lport, r->ai_family);
 174                 seteuid(uid);
 175                 if (s < 0)
 176                         return(-1);
 177                 if (connect(s, r->ai_addr, r->ai_addrlen) < 0) {
 178                         error = errno;
 179                         (void)close(s);
 180                         s = -1;
 181                         errno = error;
 182                         if (errno == EADDRINUSE) {
 183                                 lport--;
 184                                 goto retryport;
 185                         } else if (errno == ECONNREFUSED)
 186                                 refuse++;
 187                         continue;
 188                 } else
 189                         break;
 190         }
 191         if (s < 0 && trial == refuse && timo <= 16) {
 192                 sleep(timo);
 193                 timo *= 2;
 194                 goto retry;
 195         }
 196         if (res)
 197                 freeaddrinfo(res);
 198         return(s);
 199 }
 200
 201 /*
 202  * Getline reads a line from the control file cfp, removes tabs, converts
 203  *  new-line to null and leaves it in line.
 204  * Returns 0 at EOF or the number of characters read.
 205  */
 206 size_t
 207 get_line(FILE *cfp)
 208 {
 209         size_t linel = 0;
 210         int c;
 211         char *lp = line;
 212
 213         while ((c = getc(cfp)) != '\n' && linel+1<sizeof(line)) {
 214                 if (c == EOF)
 215                         return(0);
 216                 if (c == '\t') {
 217                         do {
 218                                 *lp++ = ' ';
 219                                 linel++;
 220                         } while ((linel & 07) != 0 && linel+1 < sizeof(line));
 221                         continue;
 222                 }
 223                 *lp++ = c;
 224                 linel++;
 225         }
 226         *lp++ = '\0';
 227         return(linel);
 228 }
 229
 230 /*
 231  * Scan the current directory and make a list of daemon files sorted by
 232  * creation time.
 233  * Return the number of entries and a pointer to the list.
 234  */
 235 int
 236 getq(struct queue **namelist[])
 237 {
 238         struct dirent *d;
 239         struct queue *q, **queue = NULL, **nqueue;
 240         struct stat stbuf;
 241         DIR *dirp;
 242         u_int nitems = 0, arraysz;
 243
 244         seteuid(euid);
 245         dirp = opendir(SD);
 246         seteuid(uid);
 247         if (dirp == NULL)
 248                 return(-1);
 249         if (fstat(dirp->dd_fd, &stbuf) < 0)
 250                 goto errdone;
 251
 252         /*
 253          * Estimate the array size by taking the size of the directory file
 254          * and dividing it by a multiple of the minimum size entry.
 255          */
 256         arraysz = (int)(stbuf.st_size / 24);
 257         queue = calloc(arraysz, sizeof(struct queue *));
 258         if (queue == NULL)
 259                 goto errdone;
 260
 261         while ((d = readdir(dirp)) != NULL) {
 262                 if (d->d_name[0] != 'c' || d->d_name[1] != 'f'
 263                     || d->d_name[2] == '\0')
 264                         continue;       /* daemon control files only */
 265                 seteuid(euid);
 266                 if (stat(d->d_name, &stbuf) < 0) {
 267                         seteuid(uid);
 268                         continue;       /* Doesn't exist */
 269                 }
 270                 seteuid(uid);
 271                 q = (struct queue *)malloc(sizeof(time_t)+strlen(d->d_name)+1);
 272                 if (q == NULL)
 273                         goto errdone;
 274                 q->q_time = stbuf.st_mtime;
 275                 strcpy(q->q_name, d->d_name);   /* XXX: strcpy is safe */
 276                 /*
 277                  * Check to make sure the array has space left and
 278                  * realloc the maximum size.
 279                  */
 280                 if (++nitems > arraysz) {
 281                         nqueue = (struct queue **)realloc(queue,
 282                                 arraysz * 2 * sizeof(struct queue *));
 283                         if (nqueue == NULL) {
 284                                 free(q);
 285                                 goto errdone;
 286                         }
 287                         (void)memset(&nqueue[arraysz], 0,
 288                             arraysz * sizeof(struct queueue *));
 289                         queue = nqueue;
 290                         arraysz *= 2;
 291                 }
 292                 queue[nitems-1] = q;
 293         }
 294         closedir(dirp);
 295         if (nitems)
 296                 qsort(queue, nitems, sizeof(struct queue *), compar);
 297         *namelist = queue;
 298         return(nitems);
 299
 300 errdone:
 301         freeq(queue, nitems);
 302         closedir(dirp);
 303         return(-1);
 304 }
 305
 306 void
 307 freeq(struct queue **namelist, u_int nitems)
 308 {
 309         u_int i;
 310         if (namelist == NULL)
 311                 return;
 312         for (i = 0; i < nitems; i++)
 313                 if (namelist[i])
 314                         free(namelist[i]);
 315         free(namelist);
 316 }
 317
 318 /*
 319  * Compare modification times.
 320  */
 321 static int
 322 compar(const void *p1, const void *p2)
 323 {
 324         const struct queue *const *q1 = p1;
 325         const struct queue *const *q2 = p2;
 326         int j1, j2;
 327
 328         if ((*q1)->q_time < (*q2)->q_time)
 329                 return -1;
 330         if ((*q1)->q_time > (*q2)->q_time)
 331                 return 1;
 332
 333         j1 = atoi((*q1)->q_name+3);
 334         j2 = atoi((*q2)->q_name+3);
 335
 336         if (j1 == j2)
 337                 return 0;
 338         if ((j1 < j2 && j2-j1 < 500) || (j1 > j2 && j1-j2 > 500))
 339                 return -1;
 340         if ((j1 < j2 && j2-j1 > 500) || (j1 > j2 && j1-j2 < 500))
 341                 return 1;
 342
 343         return 0;
 344 }
 345
 346 /*
 347  * Figure out whether the local machine is the same
 348  * as the remote machine (RM) entry (if it exists).
 349  */
 350 const char *
 351 checkremote(void)
 352 {
 353         char lname[NI_MAXHOST], rname[NI_MAXHOST];
 354         struct addrinfo hints, *res, *res0;
 355         static char errbuf[128];
 356         int error;
 357         struct ifaddrs *ifap, *ifa;
 358         const int niflags = NI_NUMERICHOST;
 359 #ifdef __KAME__
 360         struct sockaddr_in6 sin6;
 361         struct sockaddr_in6 *sin6p;
 362 #endif
 363
 364         remote = 0;     /* assume printer is local on failure */
 365
 366         if (RM == NULL)
 367                 return NULL;
 368
 369         /* get the local interface addresses */
 370         if (getifaddrs(&ifap) < 0) {
 371                 (void)snprintf(errbuf, sizeof(errbuf),
 372                     "unable to get local interface address: %s",
 373                     strerror(errno));
 374                 return errbuf;
 375         }
 376
 377         /* get the remote host addresses (RM) */
 378         memset(&hints, 0, sizeof(hints));
 379         hints.ai_flags = AI_CANONNAME;
 380         hints.ai_family = PF_UNSPEC;
 381         hints.ai_socktype = SOCK_STREAM;
 382         res = NULL;
 383         error = getaddrinfo(gethost(RM), NULL, &hints, &res0);
 384         if (error) {
 385                 (void)snprintf(errbuf, sizeof(errbuf),
 386                     "unable to resolve remote machine %s: %s",
 387                     RM, gai_strerror(error));
 388                 freeifaddrs(ifap);
 389                 return errbuf;
 390         }
 391
 392         remote = 1;     /* assume printer is remote */
 393
 394         for (res = res0; res; res = res->ai_next) {
 395                 if (getnameinfo(res->ai_addr, res->ai_addrlen,
 396                     rname, sizeof(rname), NULL, 0, niflags) != 0)
 397                         continue;
 398                 for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
 399 #ifdef __KAME__
 400                         sin6p = (struct sockaddr_in6 *)ifa->ifa_addr;
 401                         if (ifa->ifa_addr->sa_family == AF_INET6 &&
 402                             ifa->ifa_addr->sa_len == sizeof(sin6) &&
 403                             IN6_IS_ADDR_LINKLOCAL(&sin6p->sin6_addr) &&
 404                             *(u_int16_t *)&sin6p->sin6_addr.s6_addr[2]) {
 405                                 /* kame scopeid hack */
 406                                 memcpy(&sin6, ifa->ifa_addr, sizeof(sin6));
 407                                 sin6.sin6_scope_id =
 408                                     ntohs(*(u_int16_t *)&sin6p->sin6_addr.s6_addr[2]);
 409                                 sin6.sin6_addr.s6_addr[2] = 0;
 410                                 sin6.sin6_addr.s6_addr[3] = 0;
 411                                 if (getnameinfo((struct sockaddr *)&sin6,
 412                                     sin6.sin6_len, lname, sizeof(lname),
 413                                     NULL, 0, niflags) != 0)
 414                                         continue;
 415                         } else
 416 #endif
 417                         if (getnameinfo(ifa->ifa_addr, ifa->ifa_addr->sa_len,
 418                             lname, sizeof(lname), NULL, 0, niflags) != 0)
 419                                 continue;
 420
 421                         if (strcmp(rname, lname) == 0) {
 422                                 remote = 0;
 423                                 goto done;
 424                         }
 425                 }
 426         }
 427 done:
 428         freeaddrinfo(res0);
 429         freeifaddrs(ifap);
 430         return NULL;
 431 }
 432
 433 /* sleep n milliseconds */
 434 void
 435 delay(int n)
 436 {
 437         struct timespec tdelay;
 438
 439         if (n <= 0 || n > 10000)
 440                 fatal("unreasonable delay period (%d)", n);
 441         tdelay.tv_sec = n / 1000;
 442         tdelay.tv_nsec = (n % 1000) * 1000000;
 443         nanosleep(&tdelay, NULL);
 444 }
 445
 446 void
 447 getprintcap(const char *pr)
 448 {
 449         char *cp;
 450         const char *dp;
 451         int i;
 452
 453         if ((i = cgetent(&bp, printcapdb, pr)) == -2)
 454                 fatal("can't open printer description file");
 455         else if (i == -1)
 456                 fatal("unknown printer: %s", pr);
 457         else if (i == -3)
 458                 fatal("potential reference loop detected in printcap file");
 459
 460         LP = cgetstr(bp, DEFLP, &cp) == -1 ? _PATH_DEFDEVLP : cp;
 461         RP = cgetstr(bp, "rp", &cp) == -1 ? DEFLP : cp;
 462         SD = cgetstr(bp, "sd", &cp) == -1 ? _PATH_DEFSPOOL : cp;
 463         LO = cgetstr(bp, "lo", &cp) == -1 ? DEFLOCK : cp;
 464         ST = cgetstr(bp, "st", &cp) == -1 ? DEFSTAT : cp;
 465         RM = cgetstr(bp, "rm", &cp) == -1 ? NULL : cp;
 466         if ((dp = checkremote()) != NULL)
 467                 printf("Warning: %s\n", dp);
 468         LF = cgetstr(bp, "lf", &cp) == -1 ? _PATH_CONSOLE : cp;
 469 }
 470
 471 /*
 472  * Make sure there's some work to do before forking off a child
 473  */
 474 int
 475 ckqueue(char *cap)
 476 {
 477         struct dirent *d;
 478         DIR *dirp;
 479         const char *spooldir;
 480         char *sd = NULL;
 481         int rv = 0;
 482
 483         spooldir = cgetstr(cap, "sd", &sd) == -1 ? _PATH_DEFSPOOL : sd;
 484         if ((dirp = opendir(spooldir)) == NULL) {
 485                 rv = -1;
 486                 goto out;
 487         }
 488         while ((d = readdir(dirp)) != NULL) {
 489                 if (d->d_name[0] != 'c' || d->d_name[1] != 'f')
 490                         continue;       /* daemon control files only */
 491                 rv = 1;
 492                 break;
 493         }
 494 out:
 495         if (dirp != NULL)
 496                 closedir(dirp);
 497         if (spooldir != sd)
 498                 free(sd);
 499         return (rv);
 500 }