1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * PPPoE Server-mode daemon for use with Solaris PPP 4.0.
23  *
24  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
25  * Use is subject to license terms.
26  */
27 
28 #include <stdio.h>
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <unistd.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <fcntl.h>
35 #include <errno.h>
36 #include <signal.h>
37 #include <stropts.h>
38 #include <wait.h>
39 #include <sys/resource.h>
40 #include <netinet/in.h>
41 #include <net/sppptun.h>
42 #include <net/pppoe.h>
43 
44 #include "common.h"
45 #include "pppoed.h"
46 #include "logging.h"
47 
48 static int tunfd;		/* Global connection to tunnel device */
49 
50 char *myname;			/* Copied from argv[0] for logging */
51 static int main_argc;		/* Saved for reparse on SIGHUP */
52 static char **main_argv;	/* Saved for reparse on SIGHUP */
53 
54 static time_t time_started;	/* Time daemon was started; for debug */
55 static time_t last_reread;	/* Last time configuration was read. */
56 
57 /* Various operational statistics. */
58 static unsigned long input_packets, padi_packets, padr_packets;
59 static unsigned long output_packets;
60 static unsigned long sessions_started;
61 
62 static sigset_t sigmask;	/* Global signal mask */
63 
64 /*
65  * Used for handling errors that occur before we daemonize.
66  */
67 static void
early_error(const char * str)68 early_error(const char *str)
69 {
70 	const char *cp;
71 
72 	cp = mystrerror(errno);
73 	if (isatty(2)) {
74 		(void) fprintf(stderr, "%s: %s: %s\n", myname, str, cp);
75 	} else {
76 		reopen_log();
77 		logerr("%s: %s", str, cp);
78 	}
79 	exit(1);
80 }
81 
82 /*
83  * Open the sppptun driver.
84  */
85 static void
open_tunnel_dev(void)86 open_tunnel_dev(void)
87 {
88 	struct ppptun_peer ptp;
89 
90 	tunfd = open(tunnam, O_RDWR);
91 	if (tunfd == -1) {
92 		early_error(tunnam);
93 	}
94 
95 	/*
96 	 * Tell the device driver that I'm a daemon handling inbound
97 	 * connections, not a PPP session.
98 	 */
99 	(void) memset(&ptp, '\0', sizeof (ptp));
100 	ptp.ptp_style = PTS_PPPOE;
101 	ptp.ptp_flags = PTPF_DAEMON;
102 	(void) memcpy(ptp.ptp_address.pta_pppoe.ptma_mac, ether_bcast,
103 	    sizeof (ptp.ptp_address.pta_pppoe.ptma_mac));
104 	if (strioctl(tunfd, PPPTUN_SPEER, &ptp, sizeof (ptp), sizeof (ptp)) <
105 	    0) {
106 		myperror("PPPTUN_SPEER");
107 		exit(1);
108 	}
109 }
110 
111 /*
112  * Callback function for fdwalk.  Closes everything but the tunnel
113  * file descriptor when becoming daemon.  (Log file must be reopened
114  * manually, since syslog file descriptor, if any, is unknown.)
115  */
116 /*ARGSUSED*/
117 static int
fdcloser(void * arg,int fd)118 fdcloser(void *arg, int fd)
119 {
120 	if (fd != tunfd)
121 		(void) close(fd);
122 	return (0);
123 }
124 
125 /*
126  * Become a daemon.
127  */
128 static void
daemonize(void)129 daemonize(void)
130 {
131 	pid_t cpid;
132 
133 	/*
134 	 * A little bit of magic here.  By the first fork+setsid, we
135 	 * disconnect from our current controlling terminal and become
136 	 * a session group leader.  By forking again without setsid,
137 	 * we make certain that we're not the session group leader and
138 	 * can never reacquire a controlling terminal.
139 	 */
140 	if ((cpid = fork()) == (pid_t)-1) {
141 		early_error("fork 1");
142 	}
143 	if (cpid != 0) {
144 		(void) wait(NULL);
145 		_exit(0);
146 	}
147 	if (setsid() == (pid_t)-1) {
148 		early_error("setsid");
149 	}
150 	if ((cpid = fork()) == (pid_t)-1) {
151 		early_error("fork 2");
152 	}
153 	if (cpid != 0) {
154 		/* Parent just exits */
155 		(void) printf("%d\n", (int)cpid);
156 		(void) fflush(stdout);
157 		_exit(0);
158 	}
159 	(void) chdir("/");
160 	(void) umask(0);
161 	(void) fdwalk(fdcloser, NULL);
162 	reopen_log();
163 }
164 
165 /*
166  * Handle SIGHUP -- close and reopen non-syslog log files and reparse
167  * options.
168  */
169 /*ARGSUSED*/
170 static void
handle_hup(int sig)171 handle_hup(int sig)
172 {
173 	close_log_files();
174 	global_logging();
175 	last_reread = time(NULL);
176 	parse_options(tunfd, main_argc, main_argv);
177 }
178 
179 /*
180  * Handle SIGINT -- write current daemon status to /tmp.
181  */
182 /*ARGSUSED*/
183 static void
handle_int(int sig)184 handle_int(int sig)
185 {
186 	FILE *fp;
187 	char dumpname[MAXPATHLEN];
188 	time_t now;
189 	struct rusage rusage;
190 
191 	(void) snprintf(dumpname, sizeof (dumpname), "/tmp/pppoed.%ld",
192 	    getpid());
193 	if ((fp = fopen(dumpname, "w+")) == NULL) {
194 		logerr("%s: %s", dumpname, mystrerror(errno));
195 		return;
196 	}
197 	now = time(NULL);
198 	(void) fprintf(fp, "pppoed running %s", ctime(&now));
199 	(void) fprintf(fp, "Started on     %s", ctime(&time_started));
200 	if (last_reread != 0)
201 		(void) fprintf(fp, "Last reconfig  %s", ctime(&last_reread));
202 	(void) putc('\n', fp);
203 	if (getrusage(RUSAGE_SELF, &rusage) == 0) {
204 		(void) fprintf(fp,
205 		    "CPU usage:  user %ld.%06ld, system %ld.%06ld\n",
206 		    rusage.ru_utime.tv_sec, rusage.ru_utime.tv_usec,
207 		    rusage.ru_stime.tv_sec, rusage.ru_stime.tv_usec);
208 	}
209 	(void) fprintf(fp, "Packets:  %lu received (%lu PADI, %lu PADR), ",
210 	    input_packets, padi_packets, padr_packets);
211 	(void) fprintf(fp, "%lu transmitted\n", output_packets);
212 	(void) fprintf(fp, "Sessions started:  %lu\n\n", sessions_started);
213 	dump_configuration(fp);
214 	(void) fclose(fp);
215 }
216 
217 static void
add_signal_handlers(void)218 add_signal_handlers(void)
219 {
220 	struct sigaction sa;
221 
222 	(void) sigemptyset(&sigmask);
223 	(void) sigaddset(&sigmask, SIGHUP);
224 	(void) sigaddset(&sigmask, SIGCHLD);
225 	(void) sigaddset(&sigmask, SIGINT);
226 	(void) sigprocmask(SIG_BLOCK, &sigmask, NULL);
227 
228 	sa.sa_mask = sigmask;
229 	sa.sa_flags = 0;
230 
231 	/* Signals to handle */
232 	sa.sa_handler = handle_hup;
233 	if (sigaction(SIGHUP, &sa, NULL) < 0)
234 		early_error("sigaction HUP");
235 	sa.sa_handler = handle_int;
236 	if (sigaction(SIGINT, &sa, NULL) < 0)
237 		early_error("sigaction INT");
238 
239 	/*
240 	 * Signals to ignore.  Ignoring SIGCHLD in this way makes the
241 	 * children exit without ever creating zombies.  (No wait(2)
242 	 * call required.)
243 	 */
244 	sa.sa_handler = SIG_IGN;
245 	if (sigaction(SIGPIPE, &sa, NULL) < 0)
246 		early_error("sigaction PIPE");
247 	sa.sa_flags = SA_NOCLDWAIT;
248 	if (sigaction(SIGCHLD, &sa, NULL) < 0)
249 		early_error("sigaction CHLD");
250 }
251 
252 /*
253  * Dispatch a message from the tunnel driver.  It could be an actual
254  * PPPoE message or just an event notification.
255  */
256 static void
handle_input(uint32_t * ctrlbuf,int ctrllen,uint32_t * databuf,int datalen)257 handle_input(uint32_t *ctrlbuf, int ctrllen, uint32_t *databuf, int datalen)
258 {
259 	poep_t *poep = (poep_t *)databuf;
260 	union ppptun_name ptn;
261 	int retv;
262 	struct strbuf ctrl;
263 	struct strbuf data;
264 	void *srvp;
265 	boolean_t launch;
266 	struct ppptun_control *ptc;
267 
268 	if (ctrllen != sizeof (*ptc)) {
269 		logdbg("bogus %d byte control message from driver",
270 		    ctrllen);
271 		return;
272 	}
273 	ptc = (struct ppptun_control *)ctrlbuf;
274 
275 	/* Switch out on event notifications. */
276 	switch (ptc->ptc_action) {
277 	case PTCA_TEST:
278 		logdbg("test reply for discriminator %X", ptc->ptc_discrim);
279 		return;
280 
281 	case PTCA_CONTROL:
282 		break;
283 
284 	case PTCA_DISCONNECT:
285 		logdbg("session %d disconnected on %s; send PADT",
286 		    ptc->ptc_rsessid, ptc->ptc_name);
287 		poep = poe_mkheader(pkt_output, POECODE_PADT,
288 		    ptc->ptc_rsessid);
289 		ptc->ptc_action = PTCA_CONTROL;
290 		ctrl.len = sizeof (*ptc);
291 		ctrl.buf = (caddr_t)ptc;
292 		data.len = poe_length(poep) + sizeof (*poep);
293 		data.buf = (caddr_t)poep;
294 		if (putmsg(tunfd, &ctrl, &data, 0) < 0) {
295 			logerr("putmsg PADT: %s", mystrerror(errno));
296 		} else {
297 			output_packets++;
298 		}
299 		return;
300 
301 	case PTCA_UNPLUMB:
302 		logdbg("%s unplumbed", ptc->ptc_name);
303 		return;
304 
305 	case PTCA_BADCTRL:
306 		logwarn("bad control data on %s for session %u", ptc->ptc_name,
307 		    ptc->ptc_rsessid);
308 		return;
309 
310 	default:
311 		logdbg("unexpected code %d from driver", ptc->ptc_action);
312 		return;
313 	}
314 
315 	/* Only PPPoE control messages get here. */
316 
317 	input_packets++;
318 	if (datalen < sizeof (*poep)) {
319 		logdbg("incomplete PPPoE message from %s/%s",
320 		    ehost(&ptc->ptc_address), ptc->ptc_name);
321 		return;
322 	}
323 
324 	/* Server handles only PADI and PADR; all others are ignored. */
325 	if (poep->poep_code == POECODE_PADI) {
326 		padi_packets++;
327 	} else if (poep->poep_code == POECODE_PADR) {
328 		padr_packets++;
329 	} else {
330 		loginfo("unexpected %s from %s",
331 		    poe_codename(poep->poep_code), ehost(&ptc->ptc_address));
332 		return;
333 	}
334 	logdbg("Recv from %s/%s: %s", ehost(&ptc->ptc_address), ptc->ptc_name,
335 	    poe_codename(poep->poep_code));
336 
337 	/* Parse out service and formulate template reply. */
338 	retv = locate_service(poep, datalen, ptc->ptc_name, &ptc->ptc_address,
339 	    pkt_output, &srvp);
340 
341 	/* Continue formulating reply */
342 	launch = B_FALSE;
343 	if (retv != 1) {
344 		/* Ignore initiation if we don't offer a service. */
345 		if (retv <= 0 && poep->poep_code == POECODE_PADI) {
346 			logdbg("no services; no reply");
347 			return;
348 		}
349 		if (retv == 0)
350 			(void) poe_add_str((poep_t *)pkt_output, POETT_NAMERR,
351 			    "No such service.");
352 	} else {
353 		/* Exactly one service chosen; if it's PADR, then we start. */
354 		if (poep->poep_code == POECODE_PADR) {
355 			launch = B_TRUE;
356 		}
357 	}
358 	poep = (poep_t *)pkt_output;
359 
360 	/* Select control interface for output. */
361 	(void) strncpy(ptn.ptn_name, ptc->ptc_name, sizeof (ptn.ptn_name));
362 	if (strioctl(tunfd, PPPTUN_SCTL, &ptn, sizeof (ptn), 0) < 0) {
363 		logerr("PPPTUN_SCTL %s: %s", ptn.ptn_name, mystrerror(errno));
364 		return;
365 	}
366 
367 	/* Launch the PPP service */
368 	if (launch && launch_service(tunfd, poep, srvp, ptc))
369 		sessions_started++;
370 
371 	/* Send the reply. */
372 	ctrl.len = sizeof (*ptc);
373 	ctrl.buf = (caddr_t)ptc;
374 	data.len = poe_length(poep) + sizeof (*poep);
375 	data.buf = (caddr_t)poep;
376 	if (putmsg(tunfd, &ctrl, &data, 0) < 0) {
377 		logerr("putmsg %s: %s", ptc->ptc_name, mystrerror(errno));
378 	} else {
379 		output_packets++;
380 		logdbg("Send to   %s/%s: %s", ehost(&ptc->ptc_address),
381 		    ptc->ptc_name, poe_codename(poep->poep_code));
382 	}
383 }
384 
385 static void
main_loop(void)386 main_loop(void)
387 {
388 	struct strbuf ctrl;
389 	struct strbuf data;
390 	int flags;
391 	int rc;
392 	int err;
393 
394 	for (;;) {
395 		ctrl.maxlen = PKT_OCTL_LEN;
396 		ctrl.buf = (caddr_t)pkt_octl;
397 		data.maxlen = PKT_INPUT_LEN;
398 		data.buf = (caddr_t)pkt_input;
399 		/* Allow signals only while idle */
400 		(void) sigprocmask(SIG_UNBLOCK, &sigmask, NULL);
401 		errno = 0;
402 		flags = 0;
403 		rc = mygetmsg(tunfd, &ctrl, &data, &flags);
404 		err = errno;
405 		/*
406 		 * Block signals -- data structures must not change
407 		 * while we're busy dispatching the client's request
408 		 */
409 		(void) sigprocmask(SIG_BLOCK, &sigmask, NULL);
410 		if (rc == -1) {
411 			if (err == EAGAIN || err == EINTR)
412 				continue;
413 			logerr("%s getmsg: %s", tunnam, mystrerror(err));
414 			exit(1);
415 		}
416 		if (rc > 0)
417 			logwarn("%s returned truncated data", tunnam);
418 		else
419 			handle_input(pkt_octl, ctrl.len, pkt_input, data.len);
420 	}
421 }
422 
423 int
main(int argc,char ** argv)424 main(int argc, char **argv)
425 {
426 	prog_name = "pppoed";
427 	log_level = 1;		/* Default to error messages only at first */
428 
429 	time_started = time(NULL);
430 
431 	if ((myname = argv[0]) == NULL)
432 		myname = "pppoed";
433 
434 	main_argc = argc;
435 	main_argv = argv;
436 
437 	open_tunnel_dev();
438 	add_signal_handlers();
439 	daemonize();
440 
441 	parse_options(tunfd, argc, argv);
442 	main_loop();
443 
444 	return (0);
445 }
446