![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lpd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.lib / lpr|
Return to lpd.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.lib / lpr |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: char copyright[] =
9: "@(#) Copyright (c) 1983 Regents of the University of California.\n\
10: All rights reserved.\n";
11: #endif not lint
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)lpd.c 5.4 (Berkeley) 5/6/86";
15: #endif not lint
16:
17: /*
18: * lpd -- line printer daemon.
19: *
20: * Listen for a connection and perform the requested operation.
21: * Operations are:
22: * \1printer\n
23: * check the queue for jobs and print any found.
24: * \2printer\n
25: * receive a job from another machine and queue it.
26: * \3printer [users ...] [jobs ...]\n
27: * return the current state of the queue (short form).
28: * \4printer [users ...] [jobs ...]\n
29: * return the current state of the queue (long form).
30: * \5printer person [users ...] [jobs ...]\n
31: * remove jobs from the queue.
32: *
33: * Strategy to maintain protected spooling area:
34: * 1. Spooling area is writable only by daemon and spooling group
35: * 2. lpr runs setuid root and setgrp spooling group; it uses
36: * root to access any file it wants (verifying things before
37: * with an access call) and group id to know how it should
38: * set up ownership of files in the spooling area.
39: * 3. Files in spooling area are owned by root, group spooling
40: * group, with mode 660.
41: * 4. lpd, lpq and lprm run setuid daemon and setgrp spooling group to
42: * access files and printer. Users can't get to anything
43: * w/o help of lpq and lprm programs.
44: */
45:
46: #include "lp.h"
47:
48: int lflag; /* log requests flag */
49:
50: int reapchild();
51: int mcleanup();
52:
53: main(argc, argv)
54: int argc;
55: char **argv;
56: {
57: int f, funix, finet, options, defreadfds, fromlen;
58: struct sockaddr_un sun, fromunix;
59: struct sockaddr_in sin, frominet;
60: int omask, lfd;
61:
62: gethostname(host, sizeof(host));
63: name = argv[0];
64:
65: while (--argc > 0) {
66: argv++;
67: if (argv[0][0] == '-')
68: switch (argv[0][1]) {
69: case 'd':
70: options |= SO_DEBUG;
71: break;
72: case 'l':
73: lflag++;
74: break;
75: }
76: }
77:
78: #ifndef DEBUG
79: /*
80: * Set up standard environment by detaching from the parent.
81: */
82: if (fork())
83: exit(0);
84: for (f = 0; f < 5; f++)
85: (void) close(f);
86: (void) open("/dev/null", O_RDONLY);
87: (void) open("/dev/null", O_WRONLY);
88: (void) dup(1);
89: f = open("/dev/tty", O_RDWR);
90: if (f > 0) {
91: ioctl(f, TIOCNOTTY, 0);
92: (void) close(f);
93: }
94: #endif
95:
96: openlog("lpd", LOG_PID, LOG_LPR);
97: (void) umask(0);
98: lfd = open(MASTERLOCK, O_WRONLY|O_CREAT, 0644);
99: if (lfd < 0) {
100: syslog(LOG_ERR, "%s: %m", MASTERLOCK);
101: exit(1);
102: }
103: if (flock(lfd, LOCK_EX|LOCK_NB) < 0) {
104: if (errno == EWOULDBLOCK) /* active deamon present */
105: exit(0);
106: syslog(LOG_ERR, "%s: %m", MASTERLOCK);
107: exit(1);
108: }
109: ftruncate(lfd, 0);
110: /*
111: * write process id for others to know
112: */
113: sprintf(line, "%u\n", getpid());
114: f = strlen(line);
115: if (write(lfd, line, f) != f) {
116: syslog(LOG_ERR, "%s: %m", MASTERLOCK);
117: exit(1);
118: }
119: signal(SIGCHLD, reapchild);
120: /*
121: * Restart all the printers.
122: */
123: startup();
124: (void) unlink(SOCKETNAME);
125: funix = socket(AF_UNIX, SOCK_STREAM, 0);
126: if (funix < 0) {
127: syslog(LOG_ERR, "socket: %m");
128: exit(1);
129: }
130: #define mask(s) (1 << ((s) - 1))
131: omask = sigblock(mask(SIGHUP)|mask(SIGINT)|mask(SIGQUIT)|mask(SIGTERM));
132: signal(SIGHUP, mcleanup);
133: signal(SIGINT, mcleanup);
134: signal(SIGQUIT, mcleanup);
135: signal(SIGTERM, mcleanup);
136: sun.sun_family = AF_UNIX;
137: strcpy(sun.sun_path, SOCKETNAME);
138: if (bind(funix, &sun, strlen(sun.sun_path) + 2) < 0) {
139: syslog(LOG_ERR, "ubind: %m");
140: exit(1);
141: }
142: sigsetmask(omask);
143: defreadfds = 1 << funix;
144: listen(funix, 5);
145: finet = socket(AF_INET, SOCK_STREAM, 0);
146: if (finet >= 0) {
147: struct servent *sp;
148:
149: if (options & SO_DEBUG)
150: if (setsockopt(finet, SOL_SOCKET, SO_DEBUG, 0, 0) < 0) {
151: syslog(LOG_ERR, "setsockopt (SO_DEBUG): %m");
152: mcleanup();
153: }
154: sp = getservbyname("printer", "tcp");
155: if (sp == NULL) {
156: syslog(LOG_ERR, "printer/tcp: unknown service");
157: mcleanup();
158: }
159: sin.sin_family = AF_INET;
160: sin.sin_port = sp->s_port;
161: if (bind(finet, &sin, sizeof(sin), 0) < 0) {
162: syslog(LOG_ERR, "bind: %m");
163: mcleanup();
164: }
165: defreadfds |= 1 << finet;
166: listen(finet, 5);
167: }
168: /*
169: * Main loop: accept, do a request, continue.
170: */
171: for (;;) {
172: int domain, nfds, s, readfds = defreadfds;
173:
174: nfds = select(20, &readfds, 0, 0, 0);
175: if (nfds <= 0) {
176: if (nfds < 0 && errno != EINTR)
177: syslog(LOG_WARNING, "select: %m");
178: continue;
179: }
180: if (readfds & (1 << funix)) {
181: domain = AF_UNIX, fromlen = sizeof(fromunix);
182: s = accept(funix, &fromunix, &fromlen);
183: } else if (readfds & (1 << finet)) {
184: domain = AF_INET, fromlen = sizeof(frominet);
185: s = accept(finet, &frominet, &fromlen);
186: }
187: if (s < 0) {
188: if (errno != EINTR)
189: syslog(LOG_WARNING, "accept: %m");
190: continue;
191: }
192: if (fork() == 0) {
193: signal(SIGCHLD, SIG_IGN);
194: signal(SIGHUP, SIG_IGN);
195: signal(SIGINT, SIG_IGN);
196: signal(SIGQUIT, SIG_IGN);
197: signal(SIGTERM, SIG_IGN);
198: (void) close(funix);
199: (void) close(finet);
200: dup2(s, 1);
201: (void) close(s);
202: if (domain == AF_INET)
203: chkhost(&frominet);
204: doit();
205: exit(0);
206: }
207: (void) close(s);
208: }
209: }
210:
211: reapchild()
212: {
213: union wait status;
214:
215: while (wait3(&status, WNOHANG, 0) > 0)
216: ;
217: }
218:
219: mcleanup()
220: {
221: if (lflag)
222: syslog(LOG_INFO, "exiting");
223: unlink(SOCKETNAME);
224: exit(0);
225: }
226:
227: /*
228: * Stuff for handling job specifications
229: */
230: char *user[MAXUSERS]; /* users to process */
231: int users; /* # of users in user array */
232: int requ[MAXREQUESTS]; /* job number of spool entries */
233: int requests; /* # of spool requests */
234: char *person; /* name of person doing lprm */
235:
236: char fromb[32]; /* buffer for client's machine name */
237: char cbuf[BUFSIZ]; /* command line buffer */
238: char *cmdnames[] = {
239: "null",
240: "printjob",
241: "recvjob",
242: "displayq short",
243: "displayq long",
244: "rmjob"
245: };
246:
247: doit()
248: {
249: register char *cp;
250: register int n;
251:
252: for (;;) {
253: cp = cbuf;
254: do {
255: if (cp >= &cbuf[sizeof(cbuf) - 1])
256: fatal("Command line too long");
257: if ((n = read(1, cp, 1)) != 1) {
258: if (n < 0)
259: fatal("Lost connection");
260: return;
261: }
262: } while (*cp++ != '\n');
263: *--cp = '\0';
264: cp = cbuf;
265: if (lflag) {
266: if (*cp >= '\1' && *cp <= '\5')
267: syslog(LOG_INFO, "%s requests %s %s",
268: from, cmdnames[*cp], cp+1);
269: else
270: syslog(LOG_INFO, "bad request (%d) from %s",
271: *cp, from);
272: }
273: switch (*cp++) {
274: case '\1': /* check the queue and print any jobs there */
275: printer = cp;
276: printjob();
277: break;
278: case '\2': /* receive files to be queued */
279: printer = cp;
280: recvjob();
281: break;
282: case '\3': /* display the queue (short form) */
283: case '\4': /* display the queue (long form) */
284: printer = cp;
285: while (*cp) {
286: if (*cp != ' ') {
287: cp++;
288: continue;
289: }
290: *cp++ = '\0';
291: while (isspace(*cp))
292: cp++;
293: if (*cp == '\0')
294: break;
295: if (isdigit(*cp)) {
296: if (requests >= MAXREQUESTS)
297: fatal("Too many requests");
298: requ[requests++] = atoi(cp);
299: } else {
300: if (users >= MAXUSERS)
301: fatal("Too many users");
302: user[users++] = cp;
303: }
304: }
305: displayq(cbuf[0] - '\3');
306: exit(0);
307: case '\5': /* remove a job from the queue */
308: printer = cp;
309: while (*cp && *cp != ' ')
310: cp++;
311: if (!*cp)
312: break;
313: *cp++ = '\0';
314: person = cp;
315: while (*cp) {
316: if (*cp != ' ') {
317: cp++;
318: continue;
319: }
320: *cp++ = '\0';
321: while (isspace(*cp))
322: cp++;
323: if (*cp == '\0')
324: break;
325: if (isdigit(*cp)) {
326: if (requests >= MAXREQUESTS)
327: fatal("Too many requests");
328: requ[requests++] = atoi(cp);
329: } else {
330: if (users >= MAXUSERS)
331: fatal("Too many users");
332: user[users++] = cp;
333: }
334: }
335: rmjob();
336: break;
337: }
338: fatal("Illegal service request");
339: }
340: }
341:
342: /*
343: * Make a pass through the printcap database and start printing any
344: * files left from the last time the machine went down.
345: */
346: startup()
347: {
348: char buf[BUFSIZ];
349: register char *cp;
350: int pid;
351:
352: printer = buf;
353:
354: /*
355: * Restart the daemons.
356: */
357: while (getprent(buf) > 0) {
358: for (cp = buf; *cp; cp++)
359: if (*cp == '|' || *cp == ':') {
360: *cp = '\0';
361: break;
362: }
363: if ((pid = fork()) < 0) {
364: syslog(LOG_WARNING, "startup: cannot fork");
365: mcleanup();
366: }
367: if (!pid) {
368: endprent();
369: printjob();
370: }
371: }
372: }
373:
374: #define DUMMY ":nobody::"
375:
376: /*
377: * Check to see if the from host has access to the line printer.
378: */
379: chkhost(f)
380: struct sockaddr_in *f;
381: {
382: register struct hostent *hp;
383: register FILE *hostf;
384: register char *cp, *sp;
385: char ahost[50];
386: int first = 1;
387: extern char *inet_ntoa();
388: int baselen = -1;
389:
390: f->sin_port = ntohs(f->sin_port);
391: if (f->sin_family != AF_INET || f->sin_port >= IPPORT_RESERVED)
392: fatal("Malformed from address");
393: hp = gethostbyaddr(&f->sin_addr, sizeof(struct in_addr), f->sin_family);
394: if (hp == 0)
395: fatal("Host name for your address (%s) unknown",
396: inet_ntoa(f->sin_addr));
397:
398: strcpy(fromb, hp->h_name);
399: from = fromb;
400: if (!strcmp(from, host))
401: return;
402:
403: sp = fromb;
404: cp = ahost;
405: while (*sp) {
406: if (*sp == '.') {
407: if (baselen == -1)
408: baselen = sp - fromb;
409: *cp++ = *sp++;
410: } else {
411: *cp++ = isupper(*sp) ? tolower(*sp++) : *sp++;
412: }
413: }
414: *cp = '\0';
415: hostf = fopen("/etc/hosts.equiv", "r");
416: again:
417: if (hostf) {
418: if (!_validuser(hostf, ahost, DUMMY, DUMMY, baselen)) {
419: (void) fclose(hostf);
420: return;
421: }
422: (void) fclose(hostf);
423: }
424: if (first == 1) {
425: first = 0;
426: hostf = fopen("/etc/hosts.lpd", "r");
427: goto again;
428: }
429: fatal("Your host does not have line printer access");
430: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.