/* TODO: redesign to avoid longjmp/setjmp. Several variables here
have a volatile qualifier to silence warnings from gcc < 3.0.
Remove the volatile qualifiers if longjmp/setjmp are removed.
*/
int main(int argc, char **argv, char **envp)
{
struct in_addr inetaddr;
volatile int callmgr_sock = -1;
char ttydev[PATH_MAX];
int pty_fd, tty_fd, gre_fd, rc;
volatile pid_t parent_pid, child_pid;
u_int16_t call_id, peer_call_id;
char buf[128];
int pppdargc;
char **pppdargv;
char phonenrbuf[65]; /* maximum length of field plus one for the trailing
* '\0' */
char * volatile phonenr = NULL;
volatile int launchpppd = 1, debug = 0, nodaemon = 0;
while(1){
/* structure with all recognised options for pptp */
static struct option long_options[] = {
{"phone", 1, 0, 0},
{"nolaunchpppd", 0, 0, 0},
{"quirks", 1, 0, 0},
{"debug", 0, 0, 0},
{"sync", 0, 0, 0},
{"timeout", 1, 0, 0},
{"logstring", 1, 0, 0},
{"localbind", 1, 0, 0},
{"loglevel", 1, 0, 0},
{"nobuffer", 0, 0, 0},
{"idle-wait", 1, 0, 0},
{"max-echo-wait", 1, 0, 0},
{"version", 0, 0, 0},
{"nodaemon", 0, 0, 0},
{0, 0, 0, 0}
};
int option_index = 0;
int c;
c = getopt_long (argc, argv, "", long_options, &option_index);
if (c == -1) break; /* no more options */
switch (c) {
case 0:
if (option_index == 0) { /* --phone specified */
/* copy it to a buffer, as the argv's will be overwritten
* by inststr() */
strncpy(phonenrbuf,optarg,sizeof(phonenrbuf));
phonenrbuf[sizeof(phonenrbuf) - 1] = '\0';
phonenr = phonenrbuf;
} else if (option_index == 1) {/* --nolaunchpppd specified */
launchpppd = 0;
} else if (option_index == 2) {/* --quirks specified */
if (set_quirk_index(find_quirk(optarg)))
usage(argv[0]);
} else if (option_index == 3) {/* --debug */
debug = 1;
} else if (option_index == 4) {/* --sync specified */
syncppp = 1;
} else if (option_index == 5) {/* --timeout */
float new_packet_timeout = atof(optarg);
if (new_packet_timeout < 0.0099 ||
new_packet_timeout > 10) {
fprintf(stderr, "Packet timeout %s (%f) out of range: "
"should be between 0.01 and 10 seconds\n",
optarg, new_packet_timeout);
log("Packet timeout %s (%f) out of range: should be"
"between 0.01 and 10 seconds", optarg,
new_packet_timeout);
exit(2);
} else {
packet_timeout_usecs = new_packet_timeout * 1000000;
}
} else if (option_index == 6) {/* --logstring */
log_string = strdup(optarg);
} else if (option_index == 7) {/* --localbind */
if (inet_pton(AF_INET, optarg, (void *) &localbind) < 1) {
fprintf(stderr, "Local bind address %s invalid\n",
optarg);
log("Local bind address %s invalid\n", optarg);
exit(2);
}
} else if (option_index == 8) { /* --loglevel */
log_level = atoi(optarg);
if (log_level < 0 || log_level > 2)
usage(argv[0]);
} else if (option_index == 9) { /* --nobuffer */
disable_buffer = 1;
} else if (option_index == 10) { /* --idle-wait */
int x = atoi(optarg);
if (x < 0) {
fprintf(stderr, "--idle-wait must not be negative\n");
log("--idle-wait must not be negative\n");
exit(2);
} else {
idle_wait = x;
}
} else if (option_index == 11) { /* --max-echo-wait */
int x = atoi(optarg);
if (x < 0) {
fprintf(stderr, "--max-echo-wait must not be negative\n");
log("--max-echo-wait must not be negative\n");
exit(2);
} else {
max_echo_wait = x;
}
fprintf(stderr, "--max-echo-wait ignored, not yet implemented\n");
} else if (option_index == 12) { /* --version */
fprintf(stdout, "%s\n", version);
exit(0);
} else if (option_index == 13) {/* --nodaemon */
nodaemon = 1;
}
break;
case '?': /* unrecognised option */
/* fall through */
default:
usage(argv[0]);
}
if (c == -1) break; /* no more options for pptp */
}
/* at least one argument is required */
if (argc <= optind)
usage(argv[0]);
/* Get IP address for the hostname in argv[1] */
inetaddr = get_ip_address(argv[optind]);
optind++;
/* Find the ppp options, extract phone number */
pppdargc = argc - optind;
pppdargv = argv + optind;
log("The synchronous pptp option is %sactivated\n", syncppp ? "" : "NOT ");
/* Now we have the peer address, bind the GRE socket early,
before starting pppd. This prevents the ICMP Unreachable bug
documented in <1026868263.2855.67.camel@jander> */
gre_fd = pptp_gre_bind(inetaddr);
if (gre_fd < 0) {
close(callmgr_sock);
fatal("Cannot bind GRE socket, aborting.");
}
/* Find an open pty/tty pair. */
if(launchpppd){
rc = openpty (&pty_fd, &tty_fd, ttydev, NULL, NULL);
if (rc < 0) {
close(callmgr_sock);
fatal("Could not find free pty.");
}
#if defined(__linux__)
/*
* if we do not turn off echo now, then if pppd sleeps for any
* length of time (DNS timeouts or whatever) the other end of the
* connect may detect the link as looped. Other OSen may want this
* as well, but for now linux gets it.
*/
{
struct termios tios;
tcgetattr(tty_fd, &tios);
cfmakeraw(&tios);
tcsetattr(tty_fd, TCSAFLUSH, &tios);
}
#endif
/* fork and wait. */
signal(SIGUSR1, do_nothing); /* don't die */
signal(SIGCHLD, do_nothing); /* don't ignore SIGCHLD */
parent_pid = getpid();
switch (child_pid = fork()) {
case -1:
fatal("Could not fork pppd process");
case 0: /* I'm the child! */
close (tty_fd);
signal(SIGUSR1, SIG_DFL);
child_pid = getpid();
break;
default: /* parent */
close (pty_fd);
close (gre_fd);
/*
* There is still a very small race condition here. If a signal
* occurs after signaled is checked but before pause is called,
* things will hang.
*/
if (!signaled) {
pause(); /* wait for the signal */
}
if (signaled == SIGCHLD)
fatal("Child process died");
launch_pppd(ttydev, pppdargc, pppdargv); /* launch pppd */
perror("Error");
fatal("Could not launch pppd");
}
} else { /* ! launchpppd */
pty_fd = tty_fd = STDIN_FILENO;
/* close unused file descriptor, that is redirected to the pty */
close(STDOUT_FILENO);
child_pid = getpid();
parent_pid = 0; /* don't kill pppd */
}
do {
/*
* Open connection to call manager (Launch call manager if necessary.)
*/
callmgr_sock = open_callmgr(inetaddr, phonenr, argc, argv, envp,
pty_fd, gre_fd);
/* Exchange PIDs, get call ID */
} while (get_call_id(callmgr_sock, parent_pid, child_pid,
&call_id, &peer_call_id) < 0);
/* Send signal to wake up pppd task */
if (launchpppd) {
kill(parent_pid, SIGUSR1);
sleep(2);
/* become a daemon */
if (!(debug || nodaemon) && daemon(0, 0) != 0) {
perror("daemon");
}
} else {
/* re-open stderr as /dev/null to release it */
file2fd("/dev/null", "wb", STDERR_FILENO);
}
snprintf(buf, sizeof(buf), "pptp: GRE-to-PPP gateway on %s",
ttyname(tty_fd));
#ifdef PR_SET_NAME
rc = prctl(PR_SET_NAME, "pptpgw", 0, 0, 0);
if (rc != 0) perror("prctl");
#endif
inststr(argc, argv, envp, buf);
if (sigsetjmp(env, 1)!= 0) goto shutdown;
signal(SIGINT, sighandler);
signal(SIGTERM, sighandler);
signal(SIGKILL, sighandler);
signal(SIGCHLD, sighandler);
signal(SIGUSR1, sigstats);
/* Do GRE copy until close. */
pptp_gre_copy(call_id, peer_call_id, pty_fd, gre_fd);
shutdown:
/* on close, kill all. */
if(launchpppd)
kill(parent_pid, SIGTERM);
close(pty_fd);
close(callmgr_sock);
exit(0);
}
static int pptp_start_client(void)
{
socklen_t len;
struct sockaddr_pppox src_addr,dst_addr;
struct hostent *hostinfo;
hostinfo=gethostbyname(pptp_server);
if (!hostinfo)
{
error("PPTP: Unknown host %s\n", pptp_server);
return -1;
}
dst_addr.sa_addr.pptp.sin_addr=*(struct in_addr*)hostinfo->h_addr;
{
int sock;
struct sockaddr_in addr;
len=sizeof(addr);
addr.sin_addr=dst_addr.sa_addr.pptp.sin_addr;
addr.sin_family=AF_INET;
addr.sin_port=htons(1700);
sock=socket(AF_INET,SOCK_DGRAM,0);
if (connect(sock,(struct sockaddr*)&addr,sizeof(addr)))
{
close(sock);
error("PPTP: connect failed (%s)\n",strerror(errno));
return -1;
}
getsockname(sock,(struct sockaddr*)&addr,&len);
src_addr.sa_addr.pptp.sin_addr=addr.sin_addr;
close(sock);
}
src_addr.sa_family=AF_PPPOX;
src_addr.sa_protocol=PX_PROTO_PPTP;
src_addr.sa_addr.pptp.call_id=0;
dst_addr.sa_family=AF_PPPOX;
dst_addr.sa_protocol=PX_PROTO_PPTP;
dst_addr.sa_addr.pptp.call_id=0;
pptp_fd=socket(AF_PPPOX,SOCK_STREAM,PX_PROTO_PPTP);
if (pptp_fd<0)
{
error("PPTP: failed to create PPTP socket (%s)\n",strerror(errno));
return -1;
}
if (bind(pptp_fd,(struct sockaddr*)&src_addr,sizeof(src_addr)))
{
close(pptp_fd);
error("PPTP: failed to bind PPTP socket (%s)\n",strerror(errno));
return -1;
}
len=sizeof(src_addr);
getsockname(pptp_fd,(struct sockaddr*)&src_addr,&len);
call_ID=src_addr.sa_addr.pptp.call_id;
do {
/*
* Open connection to call manager (Launch call manager if necessary.)
*/
callmgr_sock = open_callmgr(src_addr.sa_addr.pptp.call_id,dst_addr.sa_addr.pptp.sin_addr, pptp_phone, pptp_window);
if (callmgr_sock<0)
{
close(pptp_fd);
return -1;
}
/* Exchange PIDs, get call ID */
} while (get_call_id(callmgr_sock, getpid(), getpid(), &dst_addr.sa_addr.pptp.call_id) < 0);
if (connect(pptp_fd,(struct sockaddr*)&dst_addr,sizeof(dst_addr)))
{
close(callmgr_sock);
close(pptp_fd);
error("PPTP: failed to connect PPTP socket (%s)\n",strerror(errno));
return -1;
}
sprintf(ppp_devnam,"pptp (%s)",pptp_server);
return pptp_fd;
}
static int pptp_start_client(void)
{
socklen_t len;
struct sockaddr_pppox src_addr,dst_addr;
struct hostent *hostinfo;
#if !defined(__UCLIBC__) \
|| (__UCLIBC_MAJOR__ == 0 \
&& (__UCLIBC_MINOR__ < 9 || (__UCLIBC_MINOR__ == 9 && __UCLIBC_SUBLEVEL__ < 31)))
/* force ns refresh from resolv.conf with uClibc pre-0.9.31 */
res_init();
#endif
hostinfo=gethostbyname(pptp_server);
if (!hostinfo)
{
error("PPTP: Unknown host %s\n", pptp_server);
return -1;
}
dst_addr.sa_addr.pptp.sin_addr=*(struct in_addr*)hostinfo->h_addr;
route_del(&rt);
if (route2man)
route_add(dst_addr.sa_addr.pptp.sin_addr, &rt);
{
int sock;
struct sockaddr_in addr;
len=sizeof(addr);
addr.sin_addr=dst_addr.sa_addr.pptp.sin_addr;
addr.sin_family=AF_INET;
addr.sin_port=htons(1700);
sock=socket(AF_INET,SOCK_DGRAM,0);
if (connect(sock,(struct sockaddr*)&addr,sizeof(addr)))
{
close(sock);
error("PPTP: connect failed (%s)\n",strerror(errno));
route_del(&rt);
return -1;
}
getsockname(sock,(struct sockaddr*)&addr,&len);
src_addr.sa_addr.pptp.sin_addr=addr.sin_addr;
close(sock);
}
//info("PPTP: connect server=%s\n",inet_ntoa(conn.sin_addr));
//conn.loc_addr.s_addr=INADDR_NONE;
//conn.timeout=1;
//conn.window=pptp_window;
src_addr.sa_family=AF_PPPOX;
src_addr.sa_protocol=PX_PROTO_PPTP;
src_addr.sa_addr.pptp.call_id=0;
dst_addr.sa_family=AF_PPPOX;
dst_addr.sa_protocol=PX_PROTO_PPTP;
dst_addr.sa_addr.pptp.call_id=0;
pptp_fd=socket(AF_PPPOX,SOCK_STREAM,PX_PROTO_PPTP);
if (pptp_fd<0)
{
error("PPTP: failed to create PPTP socket (%s)\n",strerror(errno));
route_del(&rt);
return -1;
}
if (bind(pptp_fd,(struct sockaddr*)&src_addr,sizeof(src_addr)))
{
close(pptp_fd);
error("PPTP: failed to bind PPTP socket (%s)\n",strerror(errno));
route_del(&rt);
return -1;
}
len=sizeof(src_addr);
getsockname(pptp_fd,(struct sockaddr*)&src_addr,&len);
call_ID=src_addr.sa_addr.pptp.call_id;
/*
* Open connection to call manager (Launch call manager if necessary.)
*/
callmgr_sock = -1;
do {
if (callmgr_sock >= 0)
close(callmgr_sock);
callmgr_sock = open_callmgr(src_addr.sa_addr.pptp.call_id, dst_addr.sa_addr.pptp.sin_addr, pptp_phone, 50);
if (callmgr_sock < 0)
{
close(pptp_fd);
route_del(&rt);
return -1;
}
/* Exchange PIDs, get call ID */
} while (get_call_id(callmgr_sock, getpid(), getpid(), &dst_addr.sa_addr.pptp.call_id) < 0);
if (connect(pptp_fd,(struct sockaddr*)&dst_addr,sizeof(dst_addr)))
{
close(callmgr_sock);
close(pptp_fd);
error("PPTP: failed to connect PPTP socket (%s)\n",strerror(errno));
route_del(&rt);
return -1;
}
sprintf(ppp_devnam,"pptp (%s)", inet_ntoa(dst_addr.sa_addr.pptp.sin_addr));
return pptp_fd;
}
int main(int argc, char **argv, char **envp) {
struct in_addr inetaddr;
int callmgr_sock = -1;
char ptydev[PTYMAX], ttydev[TTYMAX];
int pty_fd = -1;
int gre_fd = -1;
static volatile pid_t child_pid;
u_int16_t call_id, peer_call_id;
#ifdef EMBED
openlog(argv[0],LOG_PID,LOG_USER);
#endif
if (argc < 2)
usage(argv[0]);
/* Step 1: Get IP address for the hostname in argv[1] */
for (;;) {
inetaddr = get_ip_address(argv[1]);
if(inetaddr.s_addr != 0)
break;
sleep(RESPAWN_DELAY);
}
/*
* open the GRE socket early so that we do not get
* ENOPROTOOPT errors if the other end responds too
* quickly to our initial connection
*/
gre_fd = socket(AF_INET, SOCK_RAW, PPTP_PROTO);
if (gre_fd < 0) {
pptp_error("socket: %s\n", strerror(errno));
sleep(RESPAWN_DELAY);
exit(1);
}
for (;;) {
/* Step 2: Open connection to call manager
* (Launch call manager if necessary.)
*/
callmgr_sock = open_callmgr(inetaddr, argc,argv,envp);
if(callmgr_sock < 0){
close(gre_fd);
pptp_error("Could not open connection to call manager - terminating");
sleep(RESPAWN_DELAY);
exit(1);
}
pptp_debug("callmgr opened - fd = %x", callmgr_sock);
/* Step 5: Exchange PIDs, get call ID */
if (get_call_id(callmgr_sock, getpid(), &call_id, &peer_call_id) >= 0)
break;
close(callmgr_sock);
}
/* Step 3: Find an open pty/tty pair. */
pty_fd = getpseudotty(ttydev, ptydev);
if (pty_fd < 0) {
close(gre_fd);
close(callmgr_sock);
pptp_error("Could not find free pty.");
sleep(RESPAWN_DELAY);
exit(1);
}
pptp_debug("got a free ttydev");
/* Step 4: fork and wait. */
signal(SIGUSR1, do_nothing); /* don't die */
switch (child_pid = vfork()) {
case -1:
signal(SIGUSR1, SIG_DFL);
pptp_debug("vfork failed %s", strerror(errno));
sleep(RESPAWN_DELAY);
goto shutdown;
case 0: /* I'm the child! */
// signal(SIGUSR1, SIG_DFL);
pptp_debug("entered child");
pptp_debug("callids established..");
close(callmgr_sock);
close(gre_fd);
close(pty_fd);
launch_pppd(ttydev, argc-2, argv+2); /* launch pppd */
sleep(RESPAWN_DELAY);
exit(1); /* in case launch_pppd returns */
break;
default: /* parent */
/*
* There is still a very small race condition here. If a signal
* occurs after signaled is checked but before pause is called,
* things will hang.
*/
#if 0
if (!signaled) {
pause(); /* wait for the signal */
}
pptp_error("Error %s", strerror(errno));
#endif /*0*/
break;
}
#if 0
/* Step 5b: Send signal to wake up pppd task */
kill(parent_pid, SIGUSR1);
sleep(2);
#endif /*0*/
if (sigsetjmp(env, 1)!=0) goto shutdown;
signal(SIGINT, sighandler);
signal(SIGTERM, sighandler);
signal(SIGKILL, sighandler);
{
char buf[128];
snprintf(buf, sizeof(buf), "pptp: GRE-to-PPP gateway on %s", ptydev);
inststr(argc,argv,envp, buf);
}
/* Step 6: Do GRE copy until close. */
pptp_gre_copy(peer_call_id, call_id, pty_fd, gre_fd, inetaddr);
shutdown:
/* Make sure pppd exits as well */
if (child_pid > 0)
kill(child_pid, SIGTERM);
if (gre_fd != -1)
close(gre_fd);
if (pty_fd != -1)
close(pty_fd);
if (callmgr_sock != -1)
close(callmgr_sock);
exit(0);
}
