void launch_callmgr(struct in_addr inetaddr, int argc,char**argv,char**envp) {
pid_t pid;
int status;
const char *callmgr = PPTP_CALLMGR_BINARY;
/* fork and launch call manager process */
switch (pid=vfork()) {
case -1: /* baaad */
pptp_error("callmgr vfork failed: %s", strerror(errno));
break;
case 0: /* child */
{
#if 0
int callmgr_main(int argc, char**argv, char**envp);
char *my_argv[2] = { argv[0], inet_ntoa(inetaddr) };
char buf[128];
snprintf(buf, sizeof(buf), "pptp: call manager for %s", my_argv[1]);
inststr(argc,argv,envp,buf);
exit(callmgr_main(2, my_argv, envp));
#endif
execlp(callmgr, callmgr, inet_ntoa(inetaddr), NULL);
pptp_error("execlp() of call manager [%s] failed: %s",
callmgr, strerror(errno));
exit(1); /* or we trash our parents stack */
}
default: /* parent */
#if 0 /* we don't care about status */
waitpid(pid, &status, 0);
if (status!=0)
pptp_error("Call manager exited with error %d", status);
#endif
break;
}
}
/*** call the call manager main ***********************************************/
static void launch_callmgr(int call_id, struct in_addr inetaddr, char *phonenr, int window)
{
char win[10];
char call[10];
char *my_argv[9] = { "pptp", inet_ntoa(inetaddr), "--call_id", call, "--phone", phonenr, "--window", win, NULL };
char buf[128];
int argc = 0;
char **argv = environ;
sprintf(win, "%u", window);
sprintf(call, "%u", call_id);
snprintf(buf, sizeof(buf), "pptp: call manager for %s", my_argv[1]);
if (argv && *argv)
argv--;
if (argv && *argv == NULL && progname)
do {
argv--;
argc++;
} while (argv && *argv && *argv > progname);
if (argv && *argv == progname)
inststr(argc, argv, environ, buf);
exit(callmgr_main(8, my_argv, environ));
}
/*** call the call manager main ***********************************************/
void launch_callmgr(struct in_addr inetaddr, char *phonenr, int argc,
char**argv,char**envp)
{
char *my_argv[3] = { argv[0], inet_ntoa(inetaddr), phonenr };
char buf[128];
snprintf(buf, sizeof(buf), "pptp: call manager for %s", my_argv[1]);
inststr(argc, argv, envp, buf);
exit(callmgr_main(3, my_argv, envp));
}
void my_setproctitle(int argc, char **argv, const char *format, ...) {
char proctitle[64];
va_list parms;
va_start(parms, format);
vsnprintf(proctitle, sizeof(proctitle), format, parms);
#ifndef HAVE_SETPROCTITLE
inststr(argc, argv, proctitle);
#else
setproctitle(proctitle);
#endif
va_end(parms);
}
/*** call the call manager main ***********************************************/
void launch_callmgr(struct in_addr inetaddr, char *phonenr, int argc __attribute__ ((unused)),
char**argv,char**envp)
{
char *my_argv[3] = { argv[0], inet_ntoa(inetaddr), phonenr };
char buf[128];
snprintf(buf, sizeof(buf), "pptp: call manager for %s", my_argv[1]);
#ifdef PR_SET_NAME
int rc;
rc = prctl(PR_SET_NAME, "pptpcm", 0, 0, 0);
if (rc != 0) perror("prctl");
#else
inststr(argc, argv, envp, buf);
#endif
exit(callmgr_main(3, my_argv, envp));
}
/*** call the call manager main ***********************************************/
void launch_callmgr(struct in_addr inetaddr, char *phonenr, int argc,
char**argv,char**envp)
{
char *my_argv[3] = { argv[0], inet_ntoa(inetaddr), phonenr };
char buf[128];
snprintf(buf, sizeof(buf), "pptp: call manager for %s", my_argv[1]);
inststr(argc, argv, envp, buf);
/* Foxconn modified start, Winster Chan, 06/26/2006 */
//exit(callmgr_main(3, my_argv, envp));
int ret = callmgr_main(3, my_argv, envp);
pptp_pppox_release(&poxfd, &pppfd);
exit(ret);
/* Foxconn modified end, Winster Chan, 06/26/2006 */
}
/* 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);
}
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);
}