1 /* $NetBSD: common.c,v 1.38 2007/12/01 09:26:58 mlelstv 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.38 2007/12/01 09:26:58 mlelstv 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 int 207 getline(FILE *cfp) 208 { 209 int linel = 0, c; 210 char *lp = line; 211 212 while ((c = getc(cfp)) != '\n' && linel+1<sizeof(line)) { 213 if (c == EOF) 214 return(0); 215 if (c == '\t') { 216 do { 217 *lp++ = ' '; 218 linel++; 219 } while ((linel & 07) != 0 && linel+1 < sizeof(line)); 220 continue; 221 } 222 *lp++ = c; 223 linel++; 224 } 225 *lp++ = '\0'; 226 return(linel); 227 } 228 229 /* 230 * Scan the current directory and make a list of daemon files sorted by 231 * creation time. 232 * Return the number of entries and a pointer to the list. 233 */ 234 int 235 getq(struct queue **namelist[]) 236 { 237 struct dirent *d; 238 struct queue *q, **queue = NULL, **nqueue; 239 struct stat stbuf; 240 DIR *dirp; 241 u_int nitems = 0, arraysz; 242 243 seteuid(euid); 244 dirp = opendir(SD); 245 seteuid(uid); 246 if (dirp == NULL) 247 return(-1); 248 if (fstat(dirp->dd_fd, &stbuf) < 0) 249 goto errdone; 250 251 /* 252 * Estimate the array size by taking the size of the directory file 253 * and dividing it by a multiple of the minimum size entry. 254 */ 255 arraysz = (int)(stbuf.st_size / 24); 256 queue = calloc(arraysz, sizeof(struct queue *)); 257 if (queue == NULL) 258 goto errdone; 259 260 while ((d = readdir(dirp)) != NULL) { 261 if (d->d_name[0] != 'c' || d->d_name[1] != 'f' 262 || d->d_name[2] == '\0') 263 continue; /* daemon control files only */ 264 seteuid(euid); 265 if (stat(d->d_name, &stbuf) < 0) { 266 seteuid(uid); 267 continue; /* Doesn't exist */ 268 } 269 seteuid(uid); 270 q = (struct queue *)malloc(sizeof(time_t)+strlen(d->d_name)+1); 271 if (q == NULL) 272 goto errdone; 273 q->q_time = stbuf.st_mtime; 274 strcpy(q->q_name, d->d_name); /* XXX: strcpy is safe */ 275 /* 276 * Check to make sure the array has space left and 277 * realloc the maximum size. 278 */ 279 if (++nitems > arraysz) { 280 nqueue = (struct queue **)realloc(queue, 281 arraysz * 2 * sizeof(struct queue *)); 282 if (nqueue == NULL) { 283 free(q); 284 goto errdone; 285 } 286 (void)memset(&nqueue[arraysz], 0, 287 arraysz * sizeof(struct queueue *)); 288 queue = nqueue; 289 arraysz *= 2; 290 } 291 queue[nitems-1] = q; 292 } 293 closedir(dirp); 294 if (nitems) 295 qsort(queue, nitems, sizeof(struct queue *), compar); 296 *namelist = queue; 297 return(nitems); 298 299 errdone: 300 freeq(queue, nitems); 301 closedir(dirp); 302 return(-1); 303 } 304 305 void 306 freeq(struct queue **namelist, u_int nitems) 307 { 308 u_int i; 309 if (namelist == NULL) 310 return; 311 for (i = 0; i < nitems; i++) 312 if (namelist[i]) 313 free(namelist[i]); 314 free(namelist); 315 } 316 317 /* 318 * Compare modification times. 319 */ 320 static int 321 compar(const void *p1, const void *p2) 322 { 323 const struct queue *const *q1 = p1; 324 const struct queue *const *q2 = p2; 325 int j1, j2; 326 327 if ((*q1)->q_time < (*q2)->q_time) 328 return -1; 329 if ((*q1)->q_time > (*q2)->q_time) 330 return 1; 331 332 j1 = atoi((*q1)->q_name+3); 333 j2 = atoi((*q2)->q_name+3); 334 335 if (j1 == j2) 336 return 0; 337 if ((j1 < j2 && j2-j1 < 500) || (j1 > j2 && j1-j2 > 500)) 338 return -1; 339 if ((j1 < j2 && j2-j1 > 500) || (j1 > j2 && j1-j2 < 500)) 340 return 1; 341 342 return 0; 343 } 344 345 /* 346 * Figure out whether the local machine is the same 347 * as the remote machine (RM) entry (if it exists). 348 */ 349 const char * 350 checkremote(void) 351 { 352 char lname[NI_MAXHOST], rname[NI_MAXHOST]; 353 struct addrinfo hints, *res, *res0; 354 static char errbuf[128]; 355 int error; 356 struct ifaddrs *ifap, *ifa; 357 const int niflags = NI_NUMERICHOST; 358 #ifdef __KAME__ 359 struct sockaddr_in6 sin6; 360 struct sockaddr_in6 *sin6p; 361 #endif 362 363 remote = 0; /* assume printer is local on failure */ 364 365 if (RM == NULL) 366 return NULL; 367 368 /* get the local interface addresses */ 369 if (getifaddrs(&ifap) < 0) { 370 (void)snprintf(errbuf, sizeof(errbuf), 371 "unable to get local interface address: %s", 372 strerror(errno)); 373 return errbuf; 374 } 375 376 /* get the remote host addresses (RM) */ 377 memset(&hints, 0, sizeof(hints)); 378 hints.ai_flags = AI_CANONNAME; 379 hints.ai_family = PF_UNSPEC; 380 hints.ai_socktype = SOCK_STREAM; 381 res = NULL; 382 error = getaddrinfo(gethost(RM), NULL, &hints, &res0); 383 if (error) { 384 (void)snprintf(errbuf, sizeof(errbuf), 385 "unable to resolve remote machine %s: %s", 386 RM, gai_strerror(error)); 387 freeifaddrs(ifap); 388 return errbuf; 389 } 390 391 remote = 1; /* assume printer is remote */ 392 393 for (res = res0; res; res = res->ai_next) { 394 if (getnameinfo(res->ai_addr, res->ai_addrlen, 395 rname, sizeof(rname), NULL, 0, niflags) != 0) 396 continue; 397 for (ifa = ifap; ifa; ifa = ifa->ifa_next) { 398 #ifdef __KAME__ 399 sin6p = (struct sockaddr_in6 *)ifa->ifa_addr; 400 if (ifa->ifa_addr->sa_family == AF_INET6 && 401 ifa->ifa_addr->sa_len == sizeof(sin6) && 402 IN6_IS_ADDR_LINKLOCAL(&sin6p->sin6_addr) && 403 *(u_int16_t *)&sin6p->sin6_addr.s6_addr[2]) { 404 /* kame scopeid hack */ 405 memcpy(&sin6, ifa->ifa_addr, sizeof(sin6)); 406 sin6.sin6_scope_id = 407 ntohs(*(u_int16_t *)&sin6p->sin6_addr.s6_addr[2]); 408 sin6.sin6_addr.s6_addr[2] = 0; 409 sin6.sin6_addr.s6_addr[3] = 0; 410 if (getnameinfo((struct sockaddr *)&sin6, 411 sin6.sin6_len, lname, sizeof(lname), 412 NULL, 0, niflags) != 0) 413 continue; 414 } else 415 #endif 416 if (getnameinfo(ifa->ifa_addr, ifa->ifa_addr->sa_len, 417 lname, sizeof(lname), NULL, 0, niflags) != 0) 418 continue; 419 420 if (strcmp(rname, lname) == 0) { 421 remote = 0; 422 goto done; 423 } 424 } 425 } 426 done: 427 freeaddrinfo(res0); 428 freeifaddrs(ifap); 429 return NULL; 430 } 431 432 /* sleep n milliseconds */ 433 void 434 delay(int n) 435 { 436 struct timespec tdelay; 437 438 if (n <= 0 || n > 10000) 439 fatal("unreasonable delay period (%d)", n); 440 tdelay.tv_sec = n / 1000; 441 tdelay.tv_nsec = (n % 1000) * 1000000; 442 nanosleep(&tdelay, NULL); 443 } 444 445 void 446 getprintcap(const char *pr) 447 { 448 char *cp; 449 const char *dp; 450 int i; 451 452 if ((i = cgetent(&bp, printcapdb, pr)) == -2) 453 fatal("can't open printer description file"); 454 else if (i == -1) 455 fatal("unknown printer: %s", pr); 456 else if (i == -3) 457 fatal("potential reference loop detected in printcap file"); 458 459 LP = cgetstr(bp, DEFLP, &cp) == -1 ? _PATH_DEFDEVLP : cp; 460 RP = cgetstr(bp, "rp", &cp) == -1 ? DEFLP : cp; 461 SD = cgetstr(bp, "sd", &cp) == -1 ? _PATH_DEFSPOOL : cp; 462 LO = cgetstr(bp, "lo", &cp) == -1 ? DEFLOCK : cp; 463 ST = cgetstr(bp, "st", &cp) == -1 ? DEFSTAT : cp; 464 RM = cgetstr(bp, "rm", &cp) == -1 ? NULL : cp; 465 if ((dp = checkremote()) != NULL) 466 printf("Warning: %s\n", dp); 467 LF = cgetstr(bp, "lf", &cp) == -1 ? _PATH_CONSOLE : cp; 468 } 469 470 /* 471 * Make sure there's some work to do before forking off a child 472 */ 473 int 474 ckqueue(char *cap) 475 { 476 struct dirent *d; 477 DIR *dirp; 478 const char *spooldir; 479 char *sd = NULL; 480 int rv = 0; 481 482 spooldir = cgetstr(cap, "sd", &sd) == -1 ? _PATH_DEFSPOOL : sd; 483 if ((dirp = opendir(spooldir)) == NULL) { 484 rv = -1; 485 goto out; 486 } 487 while ((d = readdir(dirp)) != NULL) { 488 if (d->d_name[0] != 'c' || d->d_name[1] != 'f') 489 continue; /* daemon control files only */ 490 rv = 1; 491 break; 492 } 493 out: 494 if (dirp != NULL) 495 closedir(dirp); 496 if (spooldir != sd) 497 free(sd); 498 return (rv); 499 } 500