11ae349f5Scvs2svn /* 21ae349f5Scvs2svn * User Process PPP 31ae349f5Scvs2svn * 41ae349f5Scvs2svn * Written by Toshiharu OHNO (tony-o@iij.ad.jp) 51ae349f5Scvs2svn * 61ae349f5Scvs2svn * Copyright (C) 1993, Internet Initiative Japan, Inc. All rights reserverd. 71ae349f5Scvs2svn * 81ae349f5Scvs2svn * Redistribution and use in source and binary forms are permitted 91ae349f5Scvs2svn * provided that the above copyright notice and this paragraph are 101ae349f5Scvs2svn * duplicated in all such forms and that any documentation, 111ae349f5Scvs2svn * advertising materials, and other materials related to such 121ae349f5Scvs2svn * distribution and use acknowledge that the software was developed 131ae349f5Scvs2svn * by the Internet Initiative Japan, Inc. The name of the 141ae349f5Scvs2svn * IIJ may not be used to endorse or promote products derived 151ae349f5Scvs2svn * from this software without specific prior written permission. 161ae349f5Scvs2svn * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR 171ae349f5Scvs2svn * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED 181ae349f5Scvs2svn * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. 191ae349f5Scvs2svn * 2068a0f0ccSBrian Somers * $Id: main.c,v 1.121.2.14 1998/02/08 11:07:31 brian Exp $ 211ae349f5Scvs2svn * 221ae349f5Scvs2svn * TODO: 231ae349f5Scvs2svn * o Add commands for traffic summary, version display, etc. 241ae349f5Scvs2svn * o Add signal handler for misc controls. 251ae349f5Scvs2svn */ 261ae349f5Scvs2svn #include <sys/param.h> 271ae349f5Scvs2svn #include <sys/time.h> 281ae349f5Scvs2svn #include <sys/select.h> 291ae349f5Scvs2svn #include <sys/socket.h> 301ae349f5Scvs2svn #include <net/if.h> 311ae349f5Scvs2svn #include <net/if_tun.h> 321ae349f5Scvs2svn #include <netinet/in.h> 331ae349f5Scvs2svn #include <netinet/in_systm.h> 341ae349f5Scvs2svn #include <netinet/ip.h> 351ae349f5Scvs2svn #include <arpa/inet.h> 361ae349f5Scvs2svn 371ae349f5Scvs2svn #include <errno.h> 381ae349f5Scvs2svn #include <fcntl.h> 391ae349f5Scvs2svn #include <paths.h> 401ae349f5Scvs2svn #include <signal.h> 411ae349f5Scvs2svn #include <stdio.h> 421ae349f5Scvs2svn #include <stdlib.h> 431ae349f5Scvs2svn #include <string.h> 441ae349f5Scvs2svn #include <sys/time.h> 451ae349f5Scvs2svn #include <sys/wait.h> 461ae349f5Scvs2svn #include <termios.h> 471ae349f5Scvs2svn #include <unistd.h> 481ae349f5Scvs2svn 491ae349f5Scvs2svn #include "command.h" 501ae349f5Scvs2svn #include "mbuf.h" 511ae349f5Scvs2svn #include "log.h" 521ae349f5Scvs2svn #include "defs.h" 531ae349f5Scvs2svn #include "id.h" 541ae349f5Scvs2svn #include "timer.h" 551ae349f5Scvs2svn #include "fsm.h" 561ae349f5Scvs2svn #include "modem.h" 577a6f8720SBrian Somers #include "bundle.h" 581ae349f5Scvs2svn #include "hdlc.h" 591ae349f5Scvs2svn #include "lcp.h" 601ae349f5Scvs2svn #include "ccp.h" 6129e275ceSBrian Somers #include "iplist.h" 6229e275ceSBrian Somers #include "throughput.h" 631ae349f5Scvs2svn #include "ipcp.h" 641ae349f5Scvs2svn #include "loadalias.h" 651ae349f5Scvs2svn #include "vars.h" 661ae349f5Scvs2svn #include "auth.h" 671ae349f5Scvs2svn #include "filter.h" 681ae349f5Scvs2svn #include "systems.h" 691ae349f5Scvs2svn #include "ip.h" 701ae349f5Scvs2svn #include "sig.h" 711ae349f5Scvs2svn #include "server.h" 721ae349f5Scvs2svn #include "main.h" 731ae349f5Scvs2svn #include "vjcomp.h" 741ae349f5Scvs2svn #include "async.h" 751ae349f5Scvs2svn #include "pathnames.h" 761ae349f5Scvs2svn #include "tun.h" 771ae349f5Scvs2svn #include "route.h" 788c07a7b2SBrian Somers #include "link.h" 7963b73463SBrian Somers #include "physical.h" 801ae349f5Scvs2svn 811ae349f5Scvs2svn #ifndef O_NONBLOCK 821ae349f5Scvs2svn #ifdef O_NDELAY 831ae349f5Scvs2svn #define O_NONBLOCK O_NDELAY 841ae349f5Scvs2svn #endif 851ae349f5Scvs2svn #endif 861ae349f5Scvs2svn 871ae349f5Scvs2svn int TermMode = 0; 881ae349f5Scvs2svn 891ae349f5Scvs2svn static struct termios oldtio; /* Original tty mode */ 901ae349f5Scvs2svn static struct termios comtio; /* Command level tty mode */ 911ae349f5Scvs2svn static pid_t BGPid = 0; 921ae349f5Scvs2svn static char pid_filename[MAXPATHLEN]; 931ae349f5Scvs2svn static int dial_up; 941ae349f5Scvs2svn 957a6f8720SBrian Somers static void DoLoop(struct bundle *); 961ae349f5Scvs2svn static void TerminalStop(int); 971ae349f5Scvs2svn static const char *ex_desc(int); 981ae349f5Scvs2svn 991ae349f5Scvs2svn static void 1001ae349f5Scvs2svn TtyInit(int DontWantInt) 1011ae349f5Scvs2svn { 1021ae349f5Scvs2svn struct termios newtio; 1031ae349f5Scvs2svn int stat; 1041ae349f5Scvs2svn 1051ae349f5Scvs2svn stat = fcntl(netfd, F_GETFL, 0); 1061ae349f5Scvs2svn if (stat > 0) { 1071ae349f5Scvs2svn stat |= O_NONBLOCK; 1081ae349f5Scvs2svn (void) fcntl(netfd, F_SETFL, stat); 1091ae349f5Scvs2svn } 1101ae349f5Scvs2svn newtio = oldtio; 1111ae349f5Scvs2svn newtio.c_lflag &= ~(ECHO | ISIG | ICANON); 1121ae349f5Scvs2svn newtio.c_iflag = 0; 1131ae349f5Scvs2svn newtio.c_oflag &= ~OPOST; 1141ae349f5Scvs2svn newtio.c_cc[VEOF] = _POSIX_VDISABLE; 1151ae349f5Scvs2svn if (DontWantInt) 1161ae349f5Scvs2svn newtio.c_cc[VINTR] = _POSIX_VDISABLE; 1171ae349f5Scvs2svn newtio.c_cc[VMIN] = 1; 1181ae349f5Scvs2svn newtio.c_cc[VTIME] = 0; 1191ae349f5Scvs2svn newtio.c_cflag |= CS8; 1201ae349f5Scvs2svn tcsetattr(netfd, TCSANOW, &newtio); 1211ae349f5Scvs2svn comtio = newtio; 1221ae349f5Scvs2svn } 1231ae349f5Scvs2svn 1241ae349f5Scvs2svn /* 1251ae349f5Scvs2svn * Set tty into command mode. We allow canonical input and echo processing. 1261ae349f5Scvs2svn */ 1271ae349f5Scvs2svn void 128455aabc3SBrian Somers TtyCommandMode(struct bundle *bundle, int prompt) 1291ae349f5Scvs2svn { 1301ae349f5Scvs2svn struct termios newtio; 1311ae349f5Scvs2svn int stat; 1321ae349f5Scvs2svn 1331ae349f5Scvs2svn if (!(mode & MODE_INTER)) 1341ae349f5Scvs2svn return; 1351ae349f5Scvs2svn tcgetattr(netfd, &newtio); 1361ae349f5Scvs2svn newtio.c_lflag |= (ECHO | ISIG | ICANON); 1371ae349f5Scvs2svn newtio.c_iflag = oldtio.c_iflag; 1381ae349f5Scvs2svn newtio.c_oflag |= OPOST; 1391ae349f5Scvs2svn tcsetattr(netfd, TCSADRAIN, &newtio); 1401ae349f5Scvs2svn stat = fcntl(netfd, F_GETFL, 0); 1411ae349f5Scvs2svn if (stat > 0) { 1421ae349f5Scvs2svn stat |= O_NONBLOCK; 1431ae349f5Scvs2svn (void) fcntl(netfd, F_SETFL, stat); 1441ae349f5Scvs2svn } 1451ae349f5Scvs2svn TermMode = 0; 1461ae349f5Scvs2svn if (prompt) 147455aabc3SBrian Somers Prompt(bundle); 1481ae349f5Scvs2svn } 1491ae349f5Scvs2svn 1501ae349f5Scvs2svn /* 1511ae349f5Scvs2svn * Set tty into terminal mode which is used while we invoke term command. 1521ae349f5Scvs2svn */ 1531ae349f5Scvs2svn void 1541ae349f5Scvs2svn TtyTermMode() 1551ae349f5Scvs2svn { 1561ae349f5Scvs2svn int stat; 1571ae349f5Scvs2svn 1581ae349f5Scvs2svn tcsetattr(netfd, TCSADRAIN, &comtio); 1591ae349f5Scvs2svn stat = fcntl(netfd, F_GETFL, 0); 1601ae349f5Scvs2svn if (stat > 0) { 1611ae349f5Scvs2svn stat &= ~O_NONBLOCK; 1621ae349f5Scvs2svn (void) fcntl(netfd, F_SETFL, stat); 1631ae349f5Scvs2svn } 1641ae349f5Scvs2svn TermMode = 1; 1651ae349f5Scvs2svn } 1661ae349f5Scvs2svn 1671ae349f5Scvs2svn void 1681ae349f5Scvs2svn TtyOldMode() 1691ae349f5Scvs2svn { 1701ae349f5Scvs2svn int stat; 1711ae349f5Scvs2svn 1721ae349f5Scvs2svn stat = fcntl(netfd, F_GETFL, 0); 1731ae349f5Scvs2svn if (stat > 0) { 1741ae349f5Scvs2svn stat &= ~O_NONBLOCK; 1751ae349f5Scvs2svn (void) fcntl(netfd, F_SETFL, stat); 1761ae349f5Scvs2svn } 1771ae349f5Scvs2svn tcsetattr(netfd, TCSADRAIN, &oldtio); 1781ae349f5Scvs2svn } 1791ae349f5Scvs2svn 18083d1af55SBrian Somers static struct bundle *SignalBundle; 181455aabc3SBrian Somers int CleaningUp; 1827a6f8720SBrian Somers 1831ae349f5Scvs2svn void 1841ae349f5Scvs2svn Cleanup(int excode) 1851ae349f5Scvs2svn { 186455aabc3SBrian Somers CleaningUp = 1; 187455aabc3SBrian Somers reconnect(RECON_FALSE); 188455aabc3SBrian Somers if (bundle_Phase(SignalBundle) != PHASE_DEAD) { 189455aabc3SBrian Somers bundle_Close(SignalBundle, NULL); 190455aabc3SBrian Somers return; 191455aabc3SBrian Somers } 1921afedc4bSBrian Somers AbortProgram(excode); 1931afedc4bSBrian Somers } 194455aabc3SBrian Somers 1951afedc4bSBrian Somers void 1961afedc4bSBrian Somers AbortProgram(int excode) 1971afedc4bSBrian Somers { 1981ae349f5Scvs2svn DropClient(1); 1991ae349f5Scvs2svn ServerClose(); 2001ae349f5Scvs2svn ID0unlink(pid_filename); 2011ae349f5Scvs2svn if (mode & MODE_BACKGROUND && BGFiledes[1] != -1) { 2021ae349f5Scvs2svn char c = EX_ERRDEAD; 2031ae349f5Scvs2svn 2041ae349f5Scvs2svn if (write(BGFiledes[1], &c, 1) == 1) 2051ae349f5Scvs2svn LogPrintf(LogPHASE, "Parent notified of failure.\n"); 2061ae349f5Scvs2svn else 2071ae349f5Scvs2svn LogPrintf(LogPHASE, "Failed to notify parent of failure.\n"); 2081ae349f5Scvs2svn close(BGFiledes[1]); 2091ae349f5Scvs2svn } 2101ae349f5Scvs2svn LogPrintf(LogPHASE, "PPP Terminated (%s).\n", ex_desc(excode)); 2111ae349f5Scvs2svn TtyOldMode(); 21283d1af55SBrian Somers link_Destroy(physical2link(SignalBundle->physical)); 2131ae349f5Scvs2svn LogClose(); 21468a0f0ccSBrian Somers bundle_Destroy(SignalBundle); 2151ae349f5Scvs2svn exit(excode); 2161ae349f5Scvs2svn } 2171ae349f5Scvs2svn 2181ae349f5Scvs2svn static void 2191ae349f5Scvs2svn CloseConnection(int signo) 2201ae349f5Scvs2svn { 2211ae349f5Scvs2svn /* NOTE, these are manual, we've done a setsid() */ 2221ae349f5Scvs2svn pending_signal(SIGINT, SIG_IGN); 2231ae349f5Scvs2svn LogPrintf(LogPHASE, "Caught signal %d, abort connection\n", signo); 2241ae349f5Scvs2svn reconnectState = RECON_FALSE; 2251ae349f5Scvs2svn reconnectCount = 0; 226455aabc3SBrian Somers link_Close(&SignalBundle->physical->link, SignalBundle, 0); 2271ae349f5Scvs2svn dial_up = 0; 2281ae349f5Scvs2svn pending_signal(SIGINT, CloseConnection); 2291ae349f5Scvs2svn } 2301ae349f5Scvs2svn 2311ae349f5Scvs2svn static void 2321ae349f5Scvs2svn CloseSession(int signo) 2331ae349f5Scvs2svn { 2341ae349f5Scvs2svn if (BGPid) { 2351ae349f5Scvs2svn kill(BGPid, SIGINT); 2361ae349f5Scvs2svn exit(EX_TERM); 2371ae349f5Scvs2svn } 2381ae349f5Scvs2svn LogPrintf(LogPHASE, "Signal %d, terminate.\n", signo); 2391ae349f5Scvs2svn Cleanup(EX_TERM); 2401ae349f5Scvs2svn } 2411ae349f5Scvs2svn 2421ae349f5Scvs2svn static void 2431ae349f5Scvs2svn TerminalCont(int signo) 2441ae349f5Scvs2svn { 2451ae349f5Scvs2svn pending_signal(SIGCONT, SIG_DFL); 2461ae349f5Scvs2svn pending_signal(SIGTSTP, TerminalStop); 247455aabc3SBrian Somers TtyCommandMode(SignalBundle, getpgrp() == tcgetpgrp(netfd)); 2481ae349f5Scvs2svn } 2491ae349f5Scvs2svn 2501ae349f5Scvs2svn static void 2511ae349f5Scvs2svn TerminalStop(int signo) 2521ae349f5Scvs2svn { 2531ae349f5Scvs2svn pending_signal(SIGCONT, TerminalCont); 2541ae349f5Scvs2svn TtyOldMode(); 2551ae349f5Scvs2svn pending_signal(SIGTSTP, SIG_DFL); 2561ae349f5Scvs2svn kill(getpid(), signo); 2571ae349f5Scvs2svn } 2581ae349f5Scvs2svn 2591ae349f5Scvs2svn static void 2601ae349f5Scvs2svn SetUpServer(int signo) 2611ae349f5Scvs2svn { 2621ae349f5Scvs2svn int res; 2631ae349f5Scvs2svn 2641ae349f5Scvs2svn VarHaveLocalAuthKey = 0; 2651ae349f5Scvs2svn LocalAuthInit(); 266455aabc3SBrian Somers if ((res = ServerTcpOpen(SERVER_PORT + SignalBundle->unit)) != 0) 2671ae349f5Scvs2svn LogPrintf(LogERROR, "SIGUSR1: Failed %d to open port %d\n", 268455aabc3SBrian Somers res, SERVER_PORT + SignalBundle->unit); 2691ae349f5Scvs2svn } 2701ae349f5Scvs2svn 2711ae349f5Scvs2svn static void 2721ae349f5Scvs2svn BringDownServer(int signo) 2731ae349f5Scvs2svn { 2741ae349f5Scvs2svn VarHaveLocalAuthKey = 0; 2751ae349f5Scvs2svn LocalAuthInit(); 2761ae349f5Scvs2svn ServerClose(); 2771ae349f5Scvs2svn } 2781ae349f5Scvs2svn 2791ae349f5Scvs2svn static const char * 2801ae349f5Scvs2svn ex_desc(int ex) 2811ae349f5Scvs2svn { 2821ae349f5Scvs2svn static char num[12]; 2831ae349f5Scvs2svn static const char *desc[] = { 2841ae349f5Scvs2svn "normal", "start", "sock", "modem", "dial", "dead", "done", 2851ae349f5Scvs2svn "reboot", "errdead", "hangup", "term", "nodial", "nologin" 2861ae349f5Scvs2svn }; 2871ae349f5Scvs2svn 2881ae349f5Scvs2svn if (ex >= 0 && ex < sizeof desc / sizeof *desc) 2891ae349f5Scvs2svn return desc[ex]; 2901ae349f5Scvs2svn snprintf(num, sizeof num, "%d", ex); 2911ae349f5Scvs2svn return num; 2921ae349f5Scvs2svn } 2931ae349f5Scvs2svn 2941ae349f5Scvs2svn static void 2951ae349f5Scvs2svn Usage(void) 2961ae349f5Scvs2svn { 2971ae349f5Scvs2svn fprintf(stderr, 2981ae349f5Scvs2svn "Usage: ppp [-auto | -background | -direct | -dedicated | -ddial ]" 2991ae349f5Scvs2svn #ifndef NOALIAS 3001ae349f5Scvs2svn " [ -alias ]" 3011ae349f5Scvs2svn #endif 3021ae349f5Scvs2svn " [system]\n"); 3031ae349f5Scvs2svn exit(EX_START); 3041ae349f5Scvs2svn } 3051ae349f5Scvs2svn 3061ae349f5Scvs2svn static char * 3071ae349f5Scvs2svn ProcessArgs(int argc, char **argv) 3081ae349f5Scvs2svn { 3091ae349f5Scvs2svn int optc; 3101ae349f5Scvs2svn char *cp; 3111ae349f5Scvs2svn 3121ae349f5Scvs2svn optc = 0; 3131ae349f5Scvs2svn mode = MODE_INTER; 3141ae349f5Scvs2svn while (argc > 0 && **argv == '-') { 3151ae349f5Scvs2svn cp = *argv + 1; 3161ae349f5Scvs2svn if (strcmp(cp, "auto") == 0) { 3171ae349f5Scvs2svn mode |= MODE_AUTO; 3181ae349f5Scvs2svn mode &= ~MODE_INTER; 3191ae349f5Scvs2svn } else if (strcmp(cp, "background") == 0) { 3201ae349f5Scvs2svn mode |= MODE_BACKGROUND; 3211ae349f5Scvs2svn mode &= ~MODE_INTER; 3221ae349f5Scvs2svn } else if (strcmp(cp, "direct") == 0) { 3231ae349f5Scvs2svn mode |= MODE_DIRECT; 3241ae349f5Scvs2svn mode &= ~MODE_INTER; 3251ae349f5Scvs2svn } else if (strcmp(cp, "dedicated") == 0) { 3261ae349f5Scvs2svn mode |= MODE_DEDICATED; 3271ae349f5Scvs2svn mode &= ~MODE_INTER; 3281ae349f5Scvs2svn } else if (strcmp(cp, "ddial") == 0) { 3291ae349f5Scvs2svn mode |= MODE_DDIAL; 3301ae349f5Scvs2svn mode &= ~MODE_INTER; 3311ae349f5Scvs2svn #ifndef NOALIAS 3321ae349f5Scvs2svn } else if (strcmp(cp, "alias") == 0) { 3331ae349f5Scvs2svn if (loadAliasHandlers(&VarAliasHandlers) == 0) 3341ae349f5Scvs2svn mode |= MODE_ALIAS; 3351ae349f5Scvs2svn else 3361ae349f5Scvs2svn LogPrintf(LogWARN, "Cannot load alias library\n"); 3371ae349f5Scvs2svn optc--; /* this option isn't exclusive */ 3381ae349f5Scvs2svn #endif 3391ae349f5Scvs2svn } else 3401ae349f5Scvs2svn Usage(); 3411ae349f5Scvs2svn optc++; 3421ae349f5Scvs2svn argv++; 3431ae349f5Scvs2svn argc--; 3441ae349f5Scvs2svn } 3451ae349f5Scvs2svn if (argc > 1) { 3461ae349f5Scvs2svn fprintf(stderr, "specify only one system label.\n"); 3471ae349f5Scvs2svn exit(EX_START); 3481ae349f5Scvs2svn } 3491ae349f5Scvs2svn 3501ae349f5Scvs2svn if (optc > 1) { 3511ae349f5Scvs2svn fprintf(stderr, "specify only one mode.\n"); 3521ae349f5Scvs2svn exit(EX_START); 3531ae349f5Scvs2svn } 3541ae349f5Scvs2svn 3551ae349f5Scvs2svn return argc == 1 ? *argv : NULL; /* Don't SetLabel yet ! */ 3561ae349f5Scvs2svn } 3571ae349f5Scvs2svn 3581ae349f5Scvs2svn int 3591ae349f5Scvs2svn main(int argc, char **argv) 3601ae349f5Scvs2svn { 3611ae349f5Scvs2svn FILE *lockfile; 3621ae349f5Scvs2svn char *name, *label; 3631ae349f5Scvs2svn int nfds; 3647a6f8720SBrian Somers struct bundle *bundle; 3651ae349f5Scvs2svn 3661ae349f5Scvs2svn nfds = getdtablesize(); 3671ae349f5Scvs2svn if (nfds >= FD_SETSIZE) 3681ae349f5Scvs2svn /* 3691ae349f5Scvs2svn * If we've got loads of file descriptors, make sure they're all 3701ae349f5Scvs2svn * closed. If they aren't, we may end up with a seg fault when our 3711ae349f5Scvs2svn * `fd_set's get too big when select()ing ! 3721ae349f5Scvs2svn */ 3731ae349f5Scvs2svn while (--nfds > 2) 3741ae349f5Scvs2svn close(nfds); 3751ae349f5Scvs2svn 3761ae349f5Scvs2svn VarTerm = 0; 3771ae349f5Scvs2svn name = strrchr(argv[0], '/'); 3781ae349f5Scvs2svn LogOpen(name ? name + 1 : argv[0]); 3791ae349f5Scvs2svn 3801ae349f5Scvs2svn tcgetattr(STDIN_FILENO, &oldtio); /* Save original tty mode */ 3811ae349f5Scvs2svn 3821ae349f5Scvs2svn argc--; 3831ae349f5Scvs2svn argv++; 3841ae349f5Scvs2svn label = ProcessArgs(argc, argv); 3851ae349f5Scvs2svn if (!(mode & MODE_DIRECT)) 3861ae349f5Scvs2svn VarTerm = stdout; 3871ae349f5Scvs2svn 3881ae349f5Scvs2svn ID0init(); 3891ae349f5Scvs2svn if (ID0realuid() != 0) { 3901ae349f5Scvs2svn char conf[200], *ptr; 3911ae349f5Scvs2svn 3921ae349f5Scvs2svn snprintf(conf, sizeof conf, "%s/%s", _PATH_PPP, CONFFILE); 3931ae349f5Scvs2svn do { 3941ae349f5Scvs2svn if (!access(conf, W_OK)) { 3951ae349f5Scvs2svn LogPrintf(LogALERT, "ppp: Access violation: Please protect %s\n", conf); 3961ae349f5Scvs2svn return -1; 3971ae349f5Scvs2svn } 3981ae349f5Scvs2svn ptr = conf + strlen(conf)-2; 3991ae349f5Scvs2svn while (ptr > conf && *ptr != '/') 4001ae349f5Scvs2svn *ptr-- = '\0'; 4011ae349f5Scvs2svn } while (ptr >= conf); 4021ae349f5Scvs2svn } 4031ae349f5Scvs2svn 4041ae349f5Scvs2svn if (!ValidSystem(label)) { 4051ae349f5Scvs2svn fprintf(stderr, "You may not use ppp in this mode with this label\n"); 4061ae349f5Scvs2svn if (mode & MODE_DIRECT) { 4071ae349f5Scvs2svn const char *l; 4081ae349f5Scvs2svn l = label ? label : "default"; 4091ae349f5Scvs2svn LogPrintf(LogWARN, "Label %s rejected -direct connection\n", l); 4101ae349f5Scvs2svn } 4111ae349f5Scvs2svn LogClose(); 4121ae349f5Scvs2svn return 1; 4131ae349f5Scvs2svn } 4141ae349f5Scvs2svn 4151ae349f5Scvs2svn if (mode & MODE_INTER) 4161ae349f5Scvs2svn VarLocalAuth = LOCAL_AUTH; 4171ae349f5Scvs2svn 4187a6f8720SBrian Somers if ((bundle = bundle_Create("/dev/tun")) == NULL) { 4197a6f8720SBrian Somers LogPrintf(LogWARN, "bundle_Create: %s\n", strerror(errno)); 4201ae349f5Scvs2svn return EX_START; 4211ae349f5Scvs2svn } 4227a6f8720SBrian Somers 4232289f246SBrian Somers if (!GetShortHost()) 4242289f246SBrian Somers return 1; 4252289f246SBrian Somers IsInteractive(1); 4262289f246SBrian Somers 42783d1af55SBrian Somers SignalBundle = bundle; 4287a6f8720SBrian Somers 4297a6f8720SBrian Somers if (SelectSystem(bundle, "default", CONFFILE) < 0 && VarTerm) 4307a6f8720SBrian Somers fprintf(VarTerm, "Warning: No default entry is given in config file.\n"); 4317a6f8720SBrian Somers 4321ae349f5Scvs2svn if ((mode & MODE_OUTGOING_DAEMON) && !(mode & MODE_DEDICATED)) 4331ae349f5Scvs2svn if (label == NULL) { 4341ae349f5Scvs2svn if (VarTerm) 4351ae349f5Scvs2svn fprintf(VarTerm, "Destination system must be specified in" 4361ae349f5Scvs2svn " auto, background or ddial mode.\n"); 4371ae349f5Scvs2svn return EX_START; 4381ae349f5Scvs2svn } 4391ae349f5Scvs2svn 4401ae349f5Scvs2svn pending_signal(SIGHUP, CloseSession); 4411ae349f5Scvs2svn pending_signal(SIGTERM, CloseSession); 4421ae349f5Scvs2svn pending_signal(SIGINT, CloseConnection); 4431ae349f5Scvs2svn pending_signal(SIGQUIT, CloseSession); 4441ae349f5Scvs2svn #ifdef SIGPIPE 4451ae349f5Scvs2svn signal(SIGPIPE, SIG_IGN); 4461ae349f5Scvs2svn #endif 4471ae349f5Scvs2svn #ifdef SIGALRM 4481ae349f5Scvs2svn pending_signal(SIGALRM, SIG_IGN); 4491ae349f5Scvs2svn #endif 4501ae349f5Scvs2svn if (mode & MODE_INTER) { 4511ae349f5Scvs2svn #ifdef SIGTSTP 4521ae349f5Scvs2svn pending_signal(SIGTSTP, TerminalStop); 4531ae349f5Scvs2svn #endif 4541ae349f5Scvs2svn #ifdef SIGTTIN 4551ae349f5Scvs2svn pending_signal(SIGTTIN, TerminalStop); 4561ae349f5Scvs2svn #endif 4571ae349f5Scvs2svn #ifdef SIGTTOU 4581ae349f5Scvs2svn pending_signal(SIGTTOU, SIG_IGN); 4591ae349f5Scvs2svn #endif 4601ae349f5Scvs2svn } 4611ae349f5Scvs2svn if (!(mode & MODE_INTER)) { 4621ae349f5Scvs2svn #ifdef SIGUSR1 4631ae349f5Scvs2svn pending_signal(SIGUSR1, SetUpServer); 4641ae349f5Scvs2svn #endif 4651ae349f5Scvs2svn #ifdef SIGUSR2 4661ae349f5Scvs2svn pending_signal(SIGUSR2, BringDownServer); 4671ae349f5Scvs2svn #endif 4681ae349f5Scvs2svn } 4691ae349f5Scvs2svn 4701ae349f5Scvs2svn if (label) { 4717a6f8720SBrian Somers if (SelectSystem(bundle, label, CONFFILE) < 0) { 4721ae349f5Scvs2svn LogPrintf(LogWARN, "Destination system %s not found in conf file.\n", 4731ae349f5Scvs2svn GetLabel()); 4741ae349f5Scvs2svn Cleanup(EX_START); 4751ae349f5Scvs2svn } 4761ae349f5Scvs2svn /* 4771ae349f5Scvs2svn * We don't SetLabel() 'till now in case SelectSystem() has an 4781ae349f5Scvs2svn * embeded load "otherlabel" command. 4791ae349f5Scvs2svn */ 4801ae349f5Scvs2svn SetLabel(label); 481aad81d1eSBrian Somers if (mode & MODE_AUTO && 48229e275ceSBrian Somers IpcpInfo.DefHisAddress.ipaddr.s_addr == INADDR_ANY) { 483aad81d1eSBrian Somers LogPrintf(LogWARN, "You must \"set ifaddr\" in label %s for auto mode.\n", 484aad81d1eSBrian Somers label); 4851ae349f5Scvs2svn Cleanup(EX_START); 4861ae349f5Scvs2svn } 4871ae349f5Scvs2svn } 4881ae349f5Scvs2svn 4891ae349f5Scvs2svn if (mode & MODE_DAEMON) { 4901ae349f5Scvs2svn if (mode & MODE_BACKGROUND) { 4911ae349f5Scvs2svn if (pipe(BGFiledes)) { 4921ae349f5Scvs2svn LogPrintf(LogERROR, "pipe: %s\n", strerror(errno)); 4931ae349f5Scvs2svn Cleanup(EX_SOCK); 4941ae349f5Scvs2svn } 4951ae349f5Scvs2svn } 4961ae349f5Scvs2svn 4971ae349f5Scvs2svn if (!(mode & MODE_DIRECT)) { 4981ae349f5Scvs2svn pid_t bgpid; 4991ae349f5Scvs2svn 5001ae349f5Scvs2svn bgpid = fork(); 5011ae349f5Scvs2svn if (bgpid == -1) { 5021ae349f5Scvs2svn LogPrintf(LogERROR, "fork: %s\n", strerror(errno)); 5031ae349f5Scvs2svn Cleanup(EX_SOCK); 5041ae349f5Scvs2svn } 5051ae349f5Scvs2svn if (bgpid) { 5061ae349f5Scvs2svn char c = EX_NORMAL; 5071ae349f5Scvs2svn 5081ae349f5Scvs2svn if (mode & MODE_BACKGROUND) { 5091ae349f5Scvs2svn /* Wait for our child to close its pipe before we exit. */ 5101ae349f5Scvs2svn BGPid = bgpid; 5111ae349f5Scvs2svn close(BGFiledes[1]); 5121ae349f5Scvs2svn if (read(BGFiledes[0], &c, 1) != 1) { 5131ae349f5Scvs2svn fprintf(VarTerm, "Child exit, no status.\n"); 5141ae349f5Scvs2svn LogPrintf(LogPHASE, "Parent: Child exit, no status.\n"); 5151ae349f5Scvs2svn } else if (c == EX_NORMAL) { 5161ae349f5Scvs2svn fprintf(VarTerm, "PPP enabled.\n"); 5171ae349f5Scvs2svn LogPrintf(LogPHASE, "Parent: PPP enabled.\n"); 5181ae349f5Scvs2svn } else { 5191ae349f5Scvs2svn fprintf(VarTerm, "Child failed (%s).\n", ex_desc((int) c)); 5201ae349f5Scvs2svn LogPrintf(LogPHASE, "Parent: Child failed (%s).\n", 5211ae349f5Scvs2svn ex_desc((int) c)); 5221ae349f5Scvs2svn } 5231ae349f5Scvs2svn close(BGFiledes[0]); 5241ae349f5Scvs2svn } 5251ae349f5Scvs2svn return c; 5261ae349f5Scvs2svn } else if (mode & MODE_BACKGROUND) 5271ae349f5Scvs2svn close(BGFiledes[0]); 5281ae349f5Scvs2svn } 5291ae349f5Scvs2svn 5301ae349f5Scvs2svn VarTerm = 0; /* We know it's currently stdout */ 5311ae349f5Scvs2svn close(STDOUT_FILENO); 5321ae349f5Scvs2svn close(STDERR_FILENO); 5331ae349f5Scvs2svn 5341ae349f5Scvs2svn if (mode & MODE_DIRECT) 535ecd5172aSBrian Somers /* STDIN_FILENO gets used by modem_Open in DIRECT mode */ 5361ae349f5Scvs2svn TtyInit(1); 5371ae349f5Scvs2svn else if (mode & MODE_DAEMON) { 5381ae349f5Scvs2svn setsid(); 5391ae349f5Scvs2svn close(STDIN_FILENO); 5401ae349f5Scvs2svn } 5411ae349f5Scvs2svn } else { 5421ae349f5Scvs2svn close(STDIN_FILENO); 5431ae349f5Scvs2svn if ((netfd = open(_PATH_TTY, O_RDONLY)) < 0) { 5441ae349f5Scvs2svn fprintf(stderr, "Cannot open %s for intput !\n", _PATH_TTY); 5451ae349f5Scvs2svn return 2; 5461ae349f5Scvs2svn } 5471ae349f5Scvs2svn close(STDERR_FILENO); 5481ae349f5Scvs2svn TtyInit(0); 549455aabc3SBrian Somers TtyCommandMode(bundle, 1); 5501ae349f5Scvs2svn } 5511ae349f5Scvs2svn 5521ae349f5Scvs2svn snprintf(pid_filename, sizeof pid_filename, "%stun%d.pid", 553455aabc3SBrian Somers _PATH_VARRUN, bundle->unit); 5541ae349f5Scvs2svn lockfile = ID0fopen(pid_filename, "w"); 5551ae349f5Scvs2svn if (lockfile != NULL) { 5561ae349f5Scvs2svn fprintf(lockfile, "%d\n", (int) getpid()); 5571ae349f5Scvs2svn fclose(lockfile); 5581ae349f5Scvs2svn } 5591ae349f5Scvs2svn #ifndef RELEASE_CRUNCH 5601ae349f5Scvs2svn else 5611ae349f5Scvs2svn LogPrintf(LogALERT, "Warning: Can't create %s: %s\n", 5621ae349f5Scvs2svn pid_filename, strerror(errno)); 5631ae349f5Scvs2svn #endif 5641ae349f5Scvs2svn 5651ae349f5Scvs2svn LogPrintf(LogPHASE, "PPP Started.\n"); 5661ae349f5Scvs2svn 5671ae349f5Scvs2svn 5681ae349f5Scvs2svn do 5697a6f8720SBrian Somers DoLoop(bundle); 5701ae349f5Scvs2svn while (mode & MODE_DEDICATED); 5711ae349f5Scvs2svn 5721afedc4bSBrian Somers AbortProgram(EX_NORMAL); 5731afedc4bSBrian Somers 5741afedc4bSBrian Somers return EX_NORMAL; 5751ae349f5Scvs2svn } 5761ae349f5Scvs2svn 5771ae349f5Scvs2svn /* 5781ae349f5Scvs2svn * Turn into packet mode, where we speak PPP. 5791ae349f5Scvs2svn */ 5801ae349f5Scvs2svn void 5817a6f8720SBrian Somers PacketMode(struct bundle *bundle, int delay) 5821ae349f5Scvs2svn { 5832289f246SBrian Somers if (modem_Raw(bundle->physical) < 0) { 5841ae349f5Scvs2svn LogPrintf(LogWARN, "PacketMode: Not connected.\n"); 5851ae349f5Scvs2svn return; 5861ae349f5Scvs2svn } 5872289f246SBrian Somers LcpInit(bundle, bundle->physical); 5882289f246SBrian Somers IpcpInit(bundle, physical2link(bundle->physical)); 5892289f246SBrian Somers CcpInit(bundle, physical2link(bundle->physical)); 5901ae349f5Scvs2svn LcpUp(); 5911ae349f5Scvs2svn 5921ae349f5Scvs2svn LcpOpen(delay); 5931ae349f5Scvs2svn if (mode & MODE_INTER) 594455aabc3SBrian Somers TtyCommandMode(bundle, 0); 5951ae349f5Scvs2svn if (VarTerm) { 5961ae349f5Scvs2svn fprintf(VarTerm, "Packet mode.\n"); 597455aabc3SBrian Somers /* aft_cmd = 1; */ 5981ae349f5Scvs2svn } 5991ae349f5Scvs2svn } 6001ae349f5Scvs2svn 6011ae349f5Scvs2svn static void 6021ae349f5Scvs2svn ShowHelp(void) 6031ae349f5Scvs2svn { 6041ae349f5Scvs2svn fprintf(stderr, "The following commands are available:\r\n"); 6051ae349f5Scvs2svn fprintf(stderr, " ~p\tEnter Packet mode\r\n"); 6061ae349f5Scvs2svn fprintf(stderr, " ~-\tDecrease log level\r\n"); 6071ae349f5Scvs2svn fprintf(stderr, " ~+\tIncrease log level\r\n"); 6081ae349f5Scvs2svn fprintf(stderr, " ~t\tShow timers (only in \"log debug\" mode)\r\n"); 6091ae349f5Scvs2svn fprintf(stderr, " ~m\tShow memory map (only in \"log debug\" mode)\r\n"); 6101ae349f5Scvs2svn fprintf(stderr, " ~.\tTerminate program\r\n"); 6111ae349f5Scvs2svn fprintf(stderr, " ~?\tThis help\r\n"); 6121ae349f5Scvs2svn } 6131ae349f5Scvs2svn 6141ae349f5Scvs2svn static void 6157a6f8720SBrian Somers ReadTty(struct bundle *bundle) 6161ae349f5Scvs2svn { 6171ae349f5Scvs2svn int n; 6181ae349f5Scvs2svn char ch; 6191ae349f5Scvs2svn static int ttystate; 6201ae349f5Scvs2svn char linebuff[LINE_LEN]; 6211ae349f5Scvs2svn 6221ae349f5Scvs2svn LogPrintf(LogDEBUG, "termode = %d, netfd = %d, mode = %d\n", 6231ae349f5Scvs2svn TermMode, netfd, mode); 6241ae349f5Scvs2svn if (!TermMode) { 6251ae349f5Scvs2svn n = read(netfd, linebuff, sizeof linebuff - 1); 6261ae349f5Scvs2svn if (n > 0) { 6271ae349f5Scvs2svn aft_cmd = 1; 6281ae349f5Scvs2svn if (linebuff[n-1] == '\n') 6291ae349f5Scvs2svn linebuff[--n] = '\0'; 6301ae349f5Scvs2svn else 6311ae349f5Scvs2svn linebuff[n] = '\0'; 6321ae349f5Scvs2svn if (n) 6337a6f8720SBrian Somers DecodeCommand(bundle, linebuff, n, IsInteractive(0) ? NULL : "Client"); 634455aabc3SBrian Somers Prompt(bundle); 6351ae349f5Scvs2svn } else if (n <= 0) { 6361ae349f5Scvs2svn LogPrintf(LogPHASE, "Client connection closed.\n"); 6371ae349f5Scvs2svn DropClient(0); 6381ae349f5Scvs2svn } 6391ae349f5Scvs2svn return; 6401ae349f5Scvs2svn } 6411ae349f5Scvs2svn 6421ae349f5Scvs2svn /* 6431ae349f5Scvs2svn * We are in terminal mode, decode special sequences 6441ae349f5Scvs2svn */ 6451ae349f5Scvs2svn n = read(netfd, &ch, 1); 6461ae349f5Scvs2svn LogPrintf(LogDEBUG, "Got %d bytes (reading from the terminal)\n", n); 6471ae349f5Scvs2svn 6481ae349f5Scvs2svn if (n > 0) { 6491ae349f5Scvs2svn switch (ttystate) { 6501ae349f5Scvs2svn case 0: 6511ae349f5Scvs2svn if (ch == '~') 6521ae349f5Scvs2svn ttystate++; 6531ae349f5Scvs2svn else 65463b73463SBrian Somers /* XXX missing return value check */ 6552289f246SBrian Somers Physical_Write(bundle->physical, &ch, n); 6561ae349f5Scvs2svn break; 6571ae349f5Scvs2svn case 1: 6581ae349f5Scvs2svn switch (ch) { 6591ae349f5Scvs2svn case '?': 6601ae349f5Scvs2svn ShowHelp(); 6611ae349f5Scvs2svn break; 6621ae349f5Scvs2svn case 'p': 6631ae349f5Scvs2svn 6641ae349f5Scvs2svn /* 6651ae349f5Scvs2svn * XXX: Should check carrier. 6661ae349f5Scvs2svn */ 6677308ec68SBrian Somers if (LcpInfo.fsm.state <= ST_CLOSED) 6687a6f8720SBrian Somers PacketMode(bundle, 0); 6691ae349f5Scvs2svn break; 6701ae349f5Scvs2svn case '.': 6711ae349f5Scvs2svn TermMode = 1; 6721ae349f5Scvs2svn aft_cmd = 1; 673455aabc3SBrian Somers TtyCommandMode(bundle, 1); 6741ae349f5Scvs2svn break; 6751ae349f5Scvs2svn case 't': 6761ae349f5Scvs2svn if (LogIsKept(LogDEBUG)) { 6771ae349f5Scvs2svn ShowTimers(); 6781ae349f5Scvs2svn break; 6791ae349f5Scvs2svn } 6801ae349f5Scvs2svn case 'm': 6811ae349f5Scvs2svn if (LogIsKept(LogDEBUG)) { 6821ae349f5Scvs2svn ShowMemMap(NULL); 6831ae349f5Scvs2svn break; 6841ae349f5Scvs2svn } 6851ae349f5Scvs2svn default: 6862289f246SBrian Somers if (Physical_Write(bundle->physical, &ch, n) < 0) 6871ae349f5Scvs2svn LogPrintf(LogERROR, "error writing to modem.\n"); 6881ae349f5Scvs2svn break; 6891ae349f5Scvs2svn } 6901ae349f5Scvs2svn ttystate = 0; 6911ae349f5Scvs2svn break; 6921ae349f5Scvs2svn } 6931ae349f5Scvs2svn } 6941ae349f5Scvs2svn } 6951ae349f5Scvs2svn 6961ae349f5Scvs2svn 6971ae349f5Scvs2svn /* 6981ae349f5Scvs2svn * Here, we'll try to detect HDLC frame 6991ae349f5Scvs2svn */ 7001ae349f5Scvs2svn 7011ae349f5Scvs2svn static const char *FrameHeaders[] = { 7021ae349f5Scvs2svn "\176\377\003\300\041", 7031ae349f5Scvs2svn "\176\377\175\043\300\041", 7041ae349f5Scvs2svn "\176\177\175\043\100\041", 7051ae349f5Scvs2svn "\176\175\337\175\043\300\041", 7061ae349f5Scvs2svn "\176\175\137\175\043\100\041", 7071ae349f5Scvs2svn NULL, 7081ae349f5Scvs2svn }; 7091ae349f5Scvs2svn 7101ae349f5Scvs2svn static const u_char * 71163b73463SBrian Somers HdlcDetect(struct physical *physical, u_char * cp, int n) 7121ae349f5Scvs2svn { 7131ae349f5Scvs2svn const char *ptr, *fp, **hp; 7141ae349f5Scvs2svn 7151ae349f5Scvs2svn cp[n] = '\0'; /* be sure to null terminated */ 7161ae349f5Scvs2svn ptr = NULL; 7171ae349f5Scvs2svn for (hp = FrameHeaders; *hp; hp++) { 7181ae349f5Scvs2svn fp = *hp; 71963b73463SBrian Somers if (Physical_IsSync(physical)) 7201ae349f5Scvs2svn fp++; 7211ae349f5Scvs2svn ptr = strstr((char *) cp, fp); 7221ae349f5Scvs2svn if (ptr) 7231ae349f5Scvs2svn break; 7241ae349f5Scvs2svn } 7251ae349f5Scvs2svn return ((const u_char *) ptr); 7261ae349f5Scvs2svn } 7271ae349f5Scvs2svn 7281ae349f5Scvs2svn static struct pppTimer RedialTimer; 7291ae349f5Scvs2svn 7301ae349f5Scvs2svn static void 7311ae349f5Scvs2svn RedialTimeout(void *v) 7321ae349f5Scvs2svn { 7331ae349f5Scvs2svn StopTimer(&RedialTimer); 7341ae349f5Scvs2svn LogPrintf(LogPHASE, "Redialing timer expired.\n"); 7351ae349f5Scvs2svn } 7361ae349f5Scvs2svn 7371ae349f5Scvs2svn static void 7381ae349f5Scvs2svn StartRedialTimer(int Timeout) 7391ae349f5Scvs2svn { 7401ae349f5Scvs2svn StopTimer(&RedialTimer); 7411ae349f5Scvs2svn 7421ae349f5Scvs2svn if (Timeout) { 7431ae349f5Scvs2svn RedialTimer.state = TIMER_STOPPED; 7441ae349f5Scvs2svn 7451ae349f5Scvs2svn if (Timeout > 0) 7461ae349f5Scvs2svn RedialTimer.load = Timeout * SECTICKS; 7471ae349f5Scvs2svn else 7481ae349f5Scvs2svn RedialTimer.load = (random() % REDIAL_PERIOD) * SECTICKS; 7491ae349f5Scvs2svn 7501ae349f5Scvs2svn LogPrintf(LogPHASE, "Enter pause (%d) for redialing.\n", 7511ae349f5Scvs2svn RedialTimer.load / SECTICKS); 7521ae349f5Scvs2svn 7531ae349f5Scvs2svn RedialTimer.func = RedialTimeout; 7541ae349f5Scvs2svn StartTimer(&RedialTimer); 7551ae349f5Scvs2svn } 7561ae349f5Scvs2svn } 7571ae349f5Scvs2svn 7581ae349f5Scvs2svn #define IN_SIZE sizeof(struct sockaddr_in) 7591ae349f5Scvs2svn #define UN_SIZE sizeof(struct sockaddr_in) 7601ae349f5Scvs2svn #define ADDRSZ (IN_SIZE > UN_SIZE ? IN_SIZE : UN_SIZE) 7611ae349f5Scvs2svn 7621ae349f5Scvs2svn static void 7637a6f8720SBrian Somers DoLoop(struct bundle *bundle) 7641ae349f5Scvs2svn { 7651ae349f5Scvs2svn fd_set rfds, wfds, efds; 7661ae349f5Scvs2svn int pri, i, n, wfd, nfds; 7671ae349f5Scvs2svn char hisaddr[ADDRSZ]; 7681ae349f5Scvs2svn struct sockaddr *sa = (struct sockaddr *)hisaddr; 7691ae349f5Scvs2svn struct sockaddr_in *sin = (struct sockaddr_in *)hisaddr; 7701ae349f5Scvs2svn struct timeval timeout, *tp; 7711ae349f5Scvs2svn int ssize = ADDRSZ; 7721ae349f5Scvs2svn const u_char *cp; 7731ae349f5Scvs2svn int tries; 7741ae349f5Scvs2svn int qlen; 7751ae349f5Scvs2svn int res; 7761ae349f5Scvs2svn struct tun_data tun; 7771ae349f5Scvs2svn #define rbuff tun.data 7781ae349f5Scvs2svn 7791ae349f5Scvs2svn if (mode & MODE_DIRECT) { 7801ae349f5Scvs2svn LogPrintf(LogDEBUG, "Opening modem\n"); 7812289f246SBrian Somers if (modem_Open(bundle->physical, bundle) < 0) 7821ae349f5Scvs2svn return; 7831ae349f5Scvs2svn LogPrintf(LogPHASE, "Packet mode enabled\n"); 7847a6f8720SBrian Somers PacketMode(bundle, VarOpenMode); 7851ae349f5Scvs2svn } else if (mode & MODE_DEDICATED) { 7862289f246SBrian Somers if (!link_IsActive(physical2link(bundle->physical))) 7872289f246SBrian Somers while (modem_Open(bundle->physical, bundle) < 0) 7881ae349f5Scvs2svn nointr_sleep(VarReconnectTimer); 7891ae349f5Scvs2svn } 7901ae349f5Scvs2svn fflush(VarTerm); 7911ae349f5Scvs2svn 7921ae349f5Scvs2svn timeout.tv_sec = 0; 7931ae349f5Scvs2svn timeout.tv_usec = 0; 7941ae349f5Scvs2svn reconnectState = RECON_UNKNOWN; 7951ae349f5Scvs2svn 7961ae349f5Scvs2svn if (mode & MODE_BACKGROUND) 7971ae349f5Scvs2svn dial_up = 1; /* Bring the line up */ 7981ae349f5Scvs2svn else 7991ae349f5Scvs2svn dial_up = 0; /* XXXX */ 8001ae349f5Scvs2svn tries = 0; 8011ae349f5Scvs2svn for (;;) { 8021ae349f5Scvs2svn nfds = 0; 8031ae349f5Scvs2svn FD_ZERO(&rfds); 8041ae349f5Scvs2svn FD_ZERO(&wfds); 8051ae349f5Scvs2svn FD_ZERO(&efds); 8061ae349f5Scvs2svn 8071ae349f5Scvs2svn /* 8081ae349f5Scvs2svn * If the link is down and we're in DDIAL mode, bring it back up. 8091ae349f5Scvs2svn */ 8107308ec68SBrian Somers if (mode & MODE_DDIAL && LcpInfo.fsm.state <= ST_CLOSED) 8111ae349f5Scvs2svn dial_up = 1; 8121ae349f5Scvs2svn 8131ae349f5Scvs2svn /* 8141ae349f5Scvs2svn * If we lost carrier and want to re-establish the connection due to the 8151ae349f5Scvs2svn * "set reconnect" value, we'd better bring the line back up. 8161ae349f5Scvs2svn */ 8177308ec68SBrian Somers if (LcpInfo.fsm.state <= ST_CLOSED) { 8181ae349f5Scvs2svn if (!dial_up && reconnectState == RECON_TRUE) { 8191ae349f5Scvs2svn if (++reconnectCount <= VarReconnectTries) { 8201ae349f5Scvs2svn LogPrintf(LogPHASE, "Connection lost, re-establish (%d/%d)\n", 8211ae349f5Scvs2svn reconnectCount, VarReconnectTries); 8221ae349f5Scvs2svn StartRedialTimer(VarReconnectTimer); 8231ae349f5Scvs2svn dial_up = 1; 8241ae349f5Scvs2svn } else { 8251ae349f5Scvs2svn if (VarReconnectTries) 8261ae349f5Scvs2svn LogPrintf(LogPHASE, "Connection lost, maximum (%d) times\n", 8271ae349f5Scvs2svn VarReconnectTries); 8281ae349f5Scvs2svn reconnectCount = 0; 8291ae349f5Scvs2svn if (mode & MODE_BACKGROUND) 8301ae349f5Scvs2svn Cleanup(EX_DEAD); 8311ae349f5Scvs2svn } 8321ae349f5Scvs2svn reconnectState = RECON_ENVOKED; 8331ae349f5Scvs2svn } else if (mode & MODE_DEDICATED) 8347a6f8720SBrian Somers PacketMode(bundle, VarOpenMode); 8351ae349f5Scvs2svn } 8361ae349f5Scvs2svn 8371ae349f5Scvs2svn /* 8381ae349f5Scvs2svn * If Ip packet for output is enqueued and require dial up, Just do it! 8391ae349f5Scvs2svn */ 8401ae349f5Scvs2svn if (dial_up && RedialTimer.state != TIMER_RUNNING) { 84163b73463SBrian Somers LogPrintf(LogDEBUG, "going to dial: modem = %d\n", 8422289f246SBrian Somers Physical_GetFD(bundle->physical)); 8432289f246SBrian Somers if (modem_Open(bundle->physical, bundle) < 0) { 8441ae349f5Scvs2svn tries++; 8451ae349f5Scvs2svn if (!(mode & MODE_DDIAL) && VarDialTries) 8461ae349f5Scvs2svn LogPrintf(LogCHAT, "Failed to open modem (attempt %u of %d)\n", 8471ae349f5Scvs2svn tries, VarDialTries); 8481ae349f5Scvs2svn else 8491ae349f5Scvs2svn LogPrintf(LogCHAT, "Failed to open modem (attempt %u)\n", tries); 8501ae349f5Scvs2svn 8511ae349f5Scvs2svn if (!(mode & MODE_DDIAL) && VarDialTries && tries >= VarDialTries) { 8521ae349f5Scvs2svn if (mode & MODE_BACKGROUND) 8531ae349f5Scvs2svn Cleanup(EX_DIAL); /* Can't get the modem */ 8541ae349f5Scvs2svn dial_up = 0; 8551ae349f5Scvs2svn reconnectState = RECON_UNKNOWN; 8561ae349f5Scvs2svn reconnectCount = 0; 8571ae349f5Scvs2svn tries = 0; 8581ae349f5Scvs2svn } else 8591ae349f5Scvs2svn StartRedialTimer(VarRedialTimeout); 8601ae349f5Scvs2svn } else { 8611ae349f5Scvs2svn tries++; /* Tries are per number, not per list of 8621ae349f5Scvs2svn * numbers. */ 8631ae349f5Scvs2svn if (!(mode & MODE_DDIAL) && VarDialTries) 8641ae349f5Scvs2svn LogPrintf(LogCHAT, "Dial attempt %u of %d\n", tries, VarDialTries); 8651ae349f5Scvs2svn else 8661ae349f5Scvs2svn LogPrintf(LogCHAT, "Dial attempt %u\n", tries); 8671ae349f5Scvs2svn 8682289f246SBrian Somers if ((res = modem_Dial(bundle->physical, bundle)) == EX_DONE) { 8697a6f8720SBrian Somers PacketMode(bundle, VarOpenMode); 8701ae349f5Scvs2svn dial_up = 0; 8711ae349f5Scvs2svn reconnectState = RECON_UNKNOWN; 8721ae349f5Scvs2svn tries = 0; 8731ae349f5Scvs2svn } else { 8741ae349f5Scvs2svn if (mode & MODE_BACKGROUND) { 8751ae349f5Scvs2svn if (VarNextPhone == NULL || res == EX_SIG) 8761ae349f5Scvs2svn Cleanup(EX_DIAL); /* Tried all numbers - no luck */ 8771ae349f5Scvs2svn else 8781ae349f5Scvs2svn /* Try all numbers in background mode */ 8791ae349f5Scvs2svn StartRedialTimer(VarRedialNextTimeout); 8801ae349f5Scvs2svn } else if (!(mode & MODE_DDIAL) && 8811ae349f5Scvs2svn ((VarDialTries && tries >= VarDialTries) || 8821ae349f5Scvs2svn res == EX_SIG)) { 8831ae349f5Scvs2svn /* I give up ! Can't get through :( */ 8841ae349f5Scvs2svn StartRedialTimer(VarRedialTimeout); 8851ae349f5Scvs2svn dial_up = 0; 8861ae349f5Scvs2svn reconnectState = RECON_UNKNOWN; 8871ae349f5Scvs2svn reconnectCount = 0; 8881ae349f5Scvs2svn tries = 0; 8891ae349f5Scvs2svn } else if (VarNextPhone == NULL) 8901ae349f5Scvs2svn /* Dial failed. Keep quite during redial wait period. */ 8911ae349f5Scvs2svn StartRedialTimer(VarRedialTimeout); 8921ae349f5Scvs2svn else 8931ae349f5Scvs2svn StartRedialTimer(VarRedialNextTimeout); 8941ae349f5Scvs2svn } 8951ae349f5Scvs2svn } 8961ae349f5Scvs2svn } 8971ae349f5Scvs2svn 8982289f246SBrian Somers qlen = link_QueueLen(physical2link(bundle->physical)); 8991ae349f5Scvs2svn if (qlen == 0) { 9002289f246SBrian Somers IpStartOutput(physical2link(bundle->physical)); 9012289f246SBrian Somers qlen = link_QueueLen(physical2link(bundle->physical)); 9021ae349f5Scvs2svn } 9038c07a7b2SBrian Somers 9042289f246SBrian Somers if (link_IsActive(physical2link(bundle->physical))) { 90563b73463SBrian Somers /* XXX-ML this should probably be abstracted */ 9062289f246SBrian Somers if (Physical_GetFD(bundle->physical) + 1 > nfds) 9072289f246SBrian Somers nfds = Physical_GetFD(bundle->physical) + 1; 9082289f246SBrian Somers Physical_FD_SET(bundle->physical, &rfds); 9092289f246SBrian Somers Physical_FD_SET(bundle->physical, &efds); 9101ae349f5Scvs2svn if (qlen > 0) { 9112289f246SBrian Somers Physical_FD_SET(bundle->physical, &wfds); 9121ae349f5Scvs2svn } 9131ae349f5Scvs2svn } 9141ae349f5Scvs2svn if (server >= 0) { 9151ae349f5Scvs2svn if (server + 1 > nfds) 9161ae349f5Scvs2svn nfds = server + 1; 9171ae349f5Scvs2svn FD_SET(server, &rfds); 9181ae349f5Scvs2svn } 9191ae349f5Scvs2svn 9201ae349f5Scvs2svn #ifndef SIGALRM 9211ae349f5Scvs2svn /* 9221ae349f5Scvs2svn * *** IMPORTANT *** 9231ae349f5Scvs2svn * CPU is serviced every TICKUNIT micro seconds. This value must be chosen 9241ae349f5Scvs2svn * with great care. If this values is too big, it results in loss of 9251ae349f5Scvs2svn * characters from the modem and poor response. If this value is too 9261ae349f5Scvs2svn * small, ppp eats too much CPU time. 9271ae349f5Scvs2svn */ 9281ae349f5Scvs2svn usleep(TICKUNIT); 9291ae349f5Scvs2svn TimerService(); 9301ae349f5Scvs2svn #else 9311ae349f5Scvs2svn handle_signals(); 9321ae349f5Scvs2svn #endif 9331ae349f5Scvs2svn 9341ae349f5Scvs2svn /* If there are aren't many packets queued, look for some more. */ 9357a6f8720SBrian Somers if (qlen < 20 && bundle->tun_fd >= 0) { 9367a6f8720SBrian Somers if (bundle->tun_fd + 1 > nfds) 9377a6f8720SBrian Somers nfds = bundle->tun_fd + 1; 9387a6f8720SBrian Somers FD_SET(bundle->tun_fd, &rfds); 9391ae349f5Scvs2svn } 9401ae349f5Scvs2svn if (netfd >= 0) { 9411ae349f5Scvs2svn if (netfd + 1 > nfds) 9421ae349f5Scvs2svn nfds = netfd + 1; 9431ae349f5Scvs2svn FD_SET(netfd, &rfds); 9441ae349f5Scvs2svn FD_SET(netfd, &efds); 9451ae349f5Scvs2svn } 9461ae349f5Scvs2svn #ifndef SIGALRM 9471ae349f5Scvs2svn 9481ae349f5Scvs2svn /* 9491ae349f5Scvs2svn * Normally, select() will not block because modem is writable. In AUTO 9501ae349f5Scvs2svn * mode, select will block until we find packet from tun 9511ae349f5Scvs2svn */ 9521ae349f5Scvs2svn tp = (RedialTimer.state == TIMER_RUNNING) ? &timeout : NULL; 9531ae349f5Scvs2svn i = select(nfds, &rfds, &wfds, &efds, tp); 9541ae349f5Scvs2svn #else 9551ae349f5Scvs2svn 9561ae349f5Scvs2svn /* 9571ae349f5Scvs2svn * When SIGALRM timer is running, a select function will be return -1 and 9581ae349f5Scvs2svn * EINTR after a Time Service signal hundler is done. If the redial 9591ae349f5Scvs2svn * timer is not running and we are trying to dial, poll with a 0 value 9601ae349f5Scvs2svn * timer. 9611ae349f5Scvs2svn */ 9621ae349f5Scvs2svn tp = (dial_up && RedialTimer.state != TIMER_RUNNING) ? &timeout : NULL; 9631ae349f5Scvs2svn i = select(nfds, &rfds, &wfds, &efds, tp); 9641ae349f5Scvs2svn #endif 9651ae349f5Scvs2svn 9661ae349f5Scvs2svn if (i == 0) { 9671ae349f5Scvs2svn continue; 9681ae349f5Scvs2svn } 9691ae349f5Scvs2svn if (i < 0) { 9701ae349f5Scvs2svn if (errno == EINTR) { 9711ae349f5Scvs2svn handle_signals(); 9721ae349f5Scvs2svn continue; 9731ae349f5Scvs2svn } 9741ae349f5Scvs2svn LogPrintf(LogERROR, "DoLoop: select(): %s\n", strerror(errno)); 9751ae349f5Scvs2svn break; 9761ae349f5Scvs2svn } 97763b73463SBrian Somers if ((netfd >= 0 && FD_ISSET(netfd, &efds)) || 9782289f246SBrian Somers (Physical_FD_ISSET(bundle->physical, &efds))) { 9791ae349f5Scvs2svn LogPrintf(LogALERT, "Exception detected.\n"); 9801ae349f5Scvs2svn break; 9811ae349f5Scvs2svn } 9821ae349f5Scvs2svn if (server >= 0 && FD_ISSET(server, &rfds)) { 9831ae349f5Scvs2svn wfd = accept(server, sa, &ssize); 9841ae349f5Scvs2svn if (wfd < 0) { 9851ae349f5Scvs2svn LogPrintf(LogERROR, "DoLoop: accept(): %s\n", strerror(errno)); 9861ae349f5Scvs2svn continue; 9871ae349f5Scvs2svn } 9881ae349f5Scvs2svn switch (sa->sa_family) { 9891ae349f5Scvs2svn case AF_LOCAL: 9901ae349f5Scvs2svn LogPrintf(LogPHASE, "Connected to local client.\n"); 9911ae349f5Scvs2svn break; 9921ae349f5Scvs2svn case AF_INET: 9931ae349f5Scvs2svn if (ntohs(sin->sin_port) < 1024) { 9941ae349f5Scvs2svn LogPrintf(LogALERT, "Rejected client connection from %s:%u" 9951ae349f5Scvs2svn "(invalid port number) !\n", 9961ae349f5Scvs2svn inet_ntoa(sin->sin_addr), ntohs(sin->sin_port)); 9971ae349f5Scvs2svn close(wfd); 9981ae349f5Scvs2svn continue; 9991ae349f5Scvs2svn } 10001ae349f5Scvs2svn LogPrintf(LogPHASE, "Connected to client from %s:%u\n", 10011ae349f5Scvs2svn inet_ntoa(sin->sin_addr), sin->sin_port); 10021ae349f5Scvs2svn break; 10031ae349f5Scvs2svn default: 10041ae349f5Scvs2svn write(wfd, "Unrecognised access !\n", 22); 10051ae349f5Scvs2svn close(wfd); 10061ae349f5Scvs2svn continue; 10071ae349f5Scvs2svn } 10081ae349f5Scvs2svn if (netfd >= 0) { 10091ae349f5Scvs2svn write(wfd, "Connection already in use.\n", 27); 10101ae349f5Scvs2svn close(wfd); 10111ae349f5Scvs2svn continue; 10121ae349f5Scvs2svn } 10131ae349f5Scvs2svn netfd = wfd; 10141ae349f5Scvs2svn VarTerm = fdopen(netfd, "a+"); 10151ae349f5Scvs2svn LocalAuthInit(); 10161ae349f5Scvs2svn IsInteractive(1); 1017455aabc3SBrian Somers Prompt(bundle); 10181ae349f5Scvs2svn } 10191ae349f5Scvs2svn if (netfd >= 0 && FD_ISSET(netfd, &rfds)) 10201ae349f5Scvs2svn /* something to read from tty */ 10217a6f8720SBrian Somers ReadTty(bundle); 10222289f246SBrian Somers if (Physical_FD_ISSET(bundle->physical, &wfds)) { 10231ae349f5Scvs2svn /* ready to write into modem */ 10242289f246SBrian Somers link_StartOutput(physical2link(bundle->physical)); 10252289f246SBrian Somers if (!link_IsActive(physical2link(bundle->physical))) 10261ae349f5Scvs2svn dial_up = 1; 10271ae349f5Scvs2svn } 10282289f246SBrian Somers if (Physical_FD_ISSET(bundle->physical, &rfds)) { 10291ae349f5Scvs2svn /* something to read from modem */ 10307308ec68SBrian Somers if (LcpInfo.fsm.state <= ST_CLOSED) 10311ae349f5Scvs2svn nointr_usleep(10000); 10322289f246SBrian Somers n = Physical_Read(bundle->physical, rbuff, sizeof rbuff); 10331ae349f5Scvs2svn if ((mode & MODE_DIRECT) && n <= 0) { 1034455aabc3SBrian Somers reconnect(RECON_TRUE); 1035455aabc3SBrian Somers link_Close(&bundle->physical->link, bundle, 0); 10361ae349f5Scvs2svn } else 10371ae349f5Scvs2svn LogDumpBuff(LogASYNC, "ReadFromModem", rbuff, n); 10381ae349f5Scvs2svn 10397308ec68SBrian Somers if (LcpInfo.fsm.state <= ST_CLOSED) { 10401ae349f5Scvs2svn /* 10411ae349f5Scvs2svn * In dedicated mode, we just discard input until LCP is started. 10421ae349f5Scvs2svn */ 10431ae349f5Scvs2svn if (!(mode & MODE_DEDICATED)) { 10442289f246SBrian Somers cp = HdlcDetect(bundle->physical, rbuff, n); 10451ae349f5Scvs2svn if (cp) { 10461ae349f5Scvs2svn /* 10471ae349f5Scvs2svn * LCP packet is detected. Turn ourselves into packet mode. 10481ae349f5Scvs2svn */ 10491ae349f5Scvs2svn if (cp != rbuff) { 105063b73463SBrian Somers /* XXX missing return value checks */ 10512289f246SBrian Somers Physical_Write(bundle->physical, rbuff, cp - rbuff); 10522289f246SBrian Somers Physical_Write(bundle->physical, "\r\n", 2); 10531ae349f5Scvs2svn } 10547a6f8720SBrian Somers PacketMode(bundle, 0); 10554a3762fbSBrian Somers } else if (VarTerm) 10561ae349f5Scvs2svn write(fileno(VarTerm), rbuff, n); 10571ae349f5Scvs2svn } 10581ae349f5Scvs2svn } else { 10591ae349f5Scvs2svn if (n > 0) 10602289f246SBrian Somers async_Input(bundle, rbuff, n, bundle->physical); 10611ae349f5Scvs2svn } 10621ae349f5Scvs2svn } 10637a6f8720SBrian Somers if (bundle->tun_fd >= 0 && FD_ISSET(bundle->tun_fd, &rfds)) { 10647a6f8720SBrian Somers /* something to read from tun */ 10657a6f8720SBrian Somers n = read(bundle->tun_fd, &tun, sizeof tun); 10661ae349f5Scvs2svn if (n < 0) { 10671ae349f5Scvs2svn LogPrintf(LogERROR, "read from tun: %s\n", strerror(errno)); 10681ae349f5Scvs2svn continue; 10691ae349f5Scvs2svn } 10701ae349f5Scvs2svn n -= sizeof tun - sizeof tun.data; 10711ae349f5Scvs2svn if (n <= 0) { 10721ae349f5Scvs2svn LogPrintf(LogERROR, "read from tun: Only %d bytes read\n", n); 10731ae349f5Scvs2svn continue; 10741ae349f5Scvs2svn } 10751ae349f5Scvs2svn if (!tun_check_header(tun, AF_INET)) 10761ae349f5Scvs2svn continue; 10771ae349f5Scvs2svn if (((struct ip *) rbuff)->ip_dst.s_addr == IpcpInfo.want_ipaddr.s_addr) { 10781ae349f5Scvs2svn /* we've been asked to send something addressed *to* us :( */ 10791ae349f5Scvs2svn if (VarLoopback) { 10801ae349f5Scvs2svn pri = PacketCheck(rbuff, n, FL_IN); 10811ae349f5Scvs2svn if (pri >= 0) { 10821ae349f5Scvs2svn struct mbuf *bp; 10831ae349f5Scvs2svn 10841ae349f5Scvs2svn #ifndef NOALIAS 10851ae349f5Scvs2svn if (mode & MODE_ALIAS) { 10861ae349f5Scvs2svn VarPacketAliasIn(rbuff, sizeof rbuff); 10871ae349f5Scvs2svn n = ntohs(((struct ip *) rbuff)->ip_len); 10881ae349f5Scvs2svn } 10891ae349f5Scvs2svn #endif 10901ae349f5Scvs2svn bp = mballoc(n, MB_IPIN); 10911ae349f5Scvs2svn memcpy(MBUF_CTOP(bp), rbuff, n); 10927a6f8720SBrian Somers IpInput(bundle, bp); 10931ae349f5Scvs2svn LogPrintf(LogDEBUG, "Looped back packet addressed to myself\n"); 10941ae349f5Scvs2svn } 10951ae349f5Scvs2svn continue; 10961ae349f5Scvs2svn } else 10971ae349f5Scvs2svn LogPrintf(LogDEBUG, "Oops - forwarding packet addressed to myself\n"); 10981ae349f5Scvs2svn } 10991ae349f5Scvs2svn 11001ae349f5Scvs2svn /* 11011ae349f5Scvs2svn * Process on-demand dialup. Output packets are queued within tunnel 11021ae349f5Scvs2svn * device until IPCP is opened. 11031ae349f5Scvs2svn */ 11047308ec68SBrian Somers if (LcpInfo.fsm.state <= ST_CLOSED && (mode & MODE_AUTO) && 11051ae349f5Scvs2svn (pri = PacketCheck(rbuff, n, FL_DIAL)) >= 0) 11061ae349f5Scvs2svn dial_up = 1; 11071ae349f5Scvs2svn 11081ae349f5Scvs2svn pri = PacketCheck(rbuff, n, FL_OUT); 11091ae349f5Scvs2svn if (pri >= 0) { 11101ae349f5Scvs2svn #ifndef NOALIAS 11111ae349f5Scvs2svn if (mode & MODE_ALIAS) { 11121ae349f5Scvs2svn VarPacketAliasOut(rbuff, sizeof rbuff); 11131ae349f5Scvs2svn n = ntohs(((struct ip *) rbuff)->ip_len); 11141ae349f5Scvs2svn } 11151ae349f5Scvs2svn #endif 11161ae349f5Scvs2svn IpEnqueue(pri, rbuff, n); 11171ae349f5Scvs2svn } 11181ae349f5Scvs2svn } 11191ae349f5Scvs2svn } 11201ae349f5Scvs2svn LogPrintf(LogDEBUG, "Job (DoLoop) done.\n"); 11211ae349f5Scvs2svn } 1122