1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1983, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of the University nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 */ 32 33 #ifndef lint 34 static const char copyright[] = 35 "@(#) Copyright (c) 1983, 1993\n\ 36 The Regents of the University of California. All rights reserved.\n"; 37 #endif /* not lint */ 38 39 #if 0 40 #ifndef lint 41 static char sccsid[] = "@(#)recvjob.c 8.2 (Berkeley) 4/27/95"; 42 #endif /* not lint */ 43 #endif 44 45 #include "lp.cdefs.h" /* A cross-platform version of <sys/cdefs.h> */ 46 __FBSDID("$FreeBSD$"); 47 48 /* 49 * Receive printer jobs from the network, queue them and 50 * start the printer daemon. 51 */ 52 #include <sys/param.h> 53 #include <sys/mount.h> 54 #include <sys/stat.h> 55 56 #include <unistd.h> 57 #include <signal.h> 58 #include <fcntl.h> 59 #include <dirent.h> 60 #include <errno.h> 61 #include <syslog.h> 62 #include <stdio.h> 63 #include <stdlib.h> 64 #include <string.h> 65 #include "lp.h" 66 #include "lp.local.h" 67 #include "ctlinfo.h" 68 #include "extern.h" 69 #include "pathnames.h" 70 71 #define ack() (void) write(STDOUT_FILENO, sp, (size_t)1) 72 73 /* 74 * The buffer size to use when reading/writing spool files. 75 */ 76 #define SPL_BUFSIZ BUFSIZ 77 78 static char dfname[NAME_MAX]; /* data files */ 79 static int minfree; /* keep at least minfree blocks available */ 80 static const char *sp = ""; 81 static char tfname[NAME_MAX]; /* tmp copy of cf before linking */ 82 83 static int chksize(int _size); 84 static void frecverr(const char *_msg, ...) __printf0like(1, 2); 85 static int noresponse(void); 86 static void rcleanup(int _signo); 87 static int read_number(const char *_fn); 88 static int readfile(struct printer *_pp, char *_file, size_t _size); 89 static int readjob(struct printer *_pp); 90 91 92 void 93 recvjob(const char *printer) 94 { 95 struct stat stb; 96 int status; 97 struct printer myprinter, *pp = &myprinter; 98 99 /* 100 * Perform lookup for printer name or abbreviation 101 */ 102 init_printer(pp); 103 status = getprintcap(printer, pp); 104 switch (status) { 105 case PCAPERR_OSERR: 106 frecverr("cannot open printer description file"); 107 break; 108 case PCAPERR_NOTFOUND: 109 frecverr("unknown printer %s", printer); 110 break; 111 case PCAPERR_TCLOOP: 112 fatal(pp, "potential reference loop detected in printcap file"); 113 default: 114 break; 115 } 116 117 (void) close(STDERR_FILENO); /* set up log file */ 118 if (open(pp->log_file, O_WRONLY|O_APPEND, 0664) < 0) { 119 syslog(LOG_ERR, "%s: %m", pp->log_file); 120 (void) open(_PATH_DEVNULL, O_WRONLY); 121 } 122 123 if (chdir(pp->spool_dir) < 0) 124 frecverr("%s: chdir(%s): %s", pp->printer, pp->spool_dir, 125 strerror(errno)); 126 if (stat(pp->lock_file, &stb) == 0) { 127 if (stb.st_mode & 010) { 128 /* queue is disabled */ 129 putchar('\1'); /* return error code */ 130 exit(1); 131 } 132 } else if (stat(pp->spool_dir, &stb) < 0) 133 frecverr("%s: stat(%s): %s", pp->printer, pp->spool_dir, 134 strerror(errno)); 135 minfree = 2 * read_number("minfree"); /* scale KB to 512 blocks */ 136 signal(SIGTERM, rcleanup); 137 signal(SIGPIPE, rcleanup); 138 139 if (readjob(pp)) 140 printjob(pp); 141 } 142 143 /* 144 * Read printer jobs sent by lpd and copy them to the spooling directory. 145 * Return the number of jobs successfully transferred. 146 */ 147 static int 148 readjob(struct printer *pp) 149 { 150 register int size; 151 int cfcnt, dfcnt; 152 char *cp, *clastp, *errmsg; 153 char givenid[32], givenhost[MAXHOSTNAMELEN]; 154 155 ack(); 156 cfcnt = 0; 157 dfcnt = 0; 158 for (;;) { 159 /* 160 * Read a command to tell us what to do 161 */ 162 cp = line; 163 clastp = line + sizeof(line) - 1; 164 do { 165 size = read(STDOUT_FILENO, cp, (size_t)1); 166 if (size != (ssize_t)1) { 167 if (size < (ssize_t)0) { 168 frecverr("%s: lost connection", 169 pp->printer); 170 /*NOTREACHED*/ 171 } 172 return (cfcnt); 173 } 174 } while ((*cp++ != '\n') && (cp <= clastp)); 175 if (cp > clastp) { 176 frecverr("%s: readjob overflow", pp->printer); 177 /*NOTREACHED*/ 178 } 179 *--cp = '\0'; 180 cp = line; 181 switch (*cp++) { 182 case '\1': /* cleanup because data sent was bad */ 183 rcleanup(0); 184 continue; 185 186 case '\2': /* read cf file */ 187 size = 0; 188 dfcnt = 0; 189 while (*cp >= '0' && *cp <= '9') 190 size = size * 10 + (*cp++ - '0'); 191 if (*cp++ != ' ') 192 break; 193 /* 194 * host name has been authenticated, we use our 195 * view of the host name since we may be passed 196 * something different than what gethostbyaddr() 197 * returns 198 */ 199 strlcpy(cp + 6, from_host, sizeof(line) 200 + (size_t)(line - cp - 6)); 201 if (strchr(cp, '/')) { 202 frecverr("readjob: %s: illegal path name", cp); 203 /*NOTREACHED*/ 204 } 205 strlcpy(tfname, cp, sizeof(tfname)); 206 tfname[sizeof (tfname) - 1] = '\0'; 207 tfname[0] = 't'; 208 if (!chksize(size)) { 209 (void) write(STDOUT_FILENO, "\2", (size_t)1); 210 continue; 211 } 212 if (!readfile(pp, tfname, (size_t)size)) { 213 rcleanup(0); 214 continue; 215 } 216 errmsg = ctl_renametf(pp->printer, tfname); 217 tfname[0] = '\0'; 218 if (errmsg != NULL) { 219 frecverr("%s: %s", pp->printer, errmsg); 220 /*NOTREACHED*/ 221 } 222 cfcnt++; 223 continue; 224 225 case '\3': /* read df file */ 226 *givenid = '\0'; 227 *givenhost = '\0'; 228 size = 0; 229 while (*cp >= '0' && *cp <= '9') 230 size = size * 10 + (*cp++ - '0'); 231 if (*cp++ != ' ') 232 break; 233 if (strchr(cp, '/')) { 234 frecverr("readjob: %s: illegal path name", cp); 235 /*NOTREACHED*/ 236 } 237 if (!chksize(size)) { 238 (void) write(STDOUT_FILENO, "\2", (size_t)1); 239 continue; 240 } 241 strlcpy(dfname, cp, sizeof(dfname)); 242 dfcnt++; 243 trstat_init(pp, dfname, dfcnt); 244 (void) readfile(pp, dfname, (size_t)size); 245 trstat_write(pp, TR_RECVING, (size_t)size, givenid, 246 from_host, givenhost); 247 continue; 248 } 249 frecverr("protocol screwup: %s", line); 250 /*NOTREACHED*/ 251 } 252 } 253 254 /* 255 * Read files send by lpd and copy them to the spooling directory. 256 */ 257 static int 258 readfile(struct printer *pp, char *file, size_t size) 259 { 260 register char *cp; 261 char buf[SPL_BUFSIZ]; 262 size_t amt, i; 263 int err, fd, j; 264 265 fd = open(file, O_CREAT|O_EXCL|O_WRONLY, FILMOD); 266 if (fd < 0) { 267 frecverr("%s: readfile: error on open(%s): %s", 268 pp->printer, file, strerror(errno)); 269 /*NOTREACHED*/ 270 } 271 ack(); 272 err = 0; 273 for (i = 0; i < size; i += SPL_BUFSIZ) { 274 amt = SPL_BUFSIZ; 275 cp = buf; 276 if (i + amt > size) 277 amt = size - i; 278 do { 279 j = read(STDOUT_FILENO, cp, amt); 280 if (j <= 0) { 281 frecverr("%s: lost connection", pp->printer); 282 /*NOTREACHED*/ 283 } 284 amt -= j; 285 cp += j; 286 } while (amt > 0); 287 amt = SPL_BUFSIZ; 288 if (i + amt > size) 289 amt = size - i; 290 if (write(fd, buf, amt) != (ssize_t)amt) { 291 err++; 292 break; 293 } 294 } 295 (void) close(fd); 296 if (err) { 297 frecverr("%s: write error on close(%s)", pp->printer, file); 298 /*NOTREACHED*/ 299 } 300 if (noresponse()) { /* file sent had bad data in it */ 301 if (strchr(file, '/') == NULL) 302 (void) unlink(file); 303 return (0); 304 } 305 ack(); 306 return (1); 307 } 308 309 static int 310 noresponse(void) 311 { 312 char resp; 313 314 if (read(STDOUT_FILENO, &resp, (size_t)1) != 1) { 315 frecverr("lost connection in noresponse()"); 316 /*NOTREACHED*/ 317 } 318 if (resp == '\0') 319 return(0); 320 return(1); 321 } 322 323 /* 324 * Check to see if there is enough space on the disk for size bytes. 325 * 1 == OK, 0 == Not OK. 326 */ 327 static int 328 chksize(int size) 329 { 330 int64_t spacefree; 331 struct statfs sfb; 332 333 if (statfs(".", &sfb) < 0) { 334 syslog(LOG_ERR, "%s: %m", "statfs(\".\")"); 335 return (1); 336 } 337 spacefree = sfb.f_bavail * (sfb.f_bsize / 512); 338 size = (size + 511) / 512; 339 if (minfree + size > spacefree) 340 return(0); 341 return(1); 342 } 343 344 static int 345 read_number(const char *fn) 346 { 347 char lin[80]; 348 register FILE *fp; 349 350 if ((fp = fopen(fn, "r")) == NULL) 351 return (0); 352 if (fgets(lin, sizeof(lin), fp) == NULL) { 353 fclose(fp); 354 return (0); 355 } 356 fclose(fp); 357 return (atoi(lin)); 358 } 359 360 /* 361 * Remove all the files associated with the current job being transferred. 362 */ 363 static void 364 rcleanup(int signo __unused) 365 { 366 if (tfname[0] && strchr(tfname, '/') == NULL) 367 (void) unlink(tfname); 368 if (dfname[0] && strchr(dfname, '/') == NULL) { 369 do { 370 do 371 (void) unlink(dfname); 372 while (dfname[2]-- != 'A'); 373 dfname[2] = 'z'; 374 } while (dfname[0]-- != 'd'); 375 } 376 dfname[0] = '\0'; 377 } 378 379 #include <stdarg.h> 380 381 static void 382 frecverr(const char *msg, ...) 383 { 384 va_list ap; 385 va_start(ap, msg); 386 syslog(LOG_ERR, "Error receiving job from %s:", from_host); 387 vsyslog(LOG_ERR, msg, ap); 388 va_end(ap); 389 /* 390 * rcleanup is not called until AFTER logging the error message, 391 * because rcleanup will zap some variables which may have been 392 * supplied as parameters for that msg... 393 */ 394 rcleanup(0); 395 /* 396 * Add a minimal delay before returning the final error code to 397 * the sending host. This just in case that machine responds 398 * this error by INSTANTLY retrying (and instantly re-failing...). 399 * It would be stupid of the sending host to do that, but if there 400 * was a broken implementation which did it, the result might be 401 * obscure performance problems and a flood of syslog messages on 402 * the receiving host. 403 */ 404 sleep(2); /* a paranoid throttling measure */ 405 putchar('\1'); /* return error code */ 406 exit(1); 407 } 408