From 65a0041542996c16e11bdf77d130c7af5635a627 Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Sun, 7 Jun 2026 12:14:52 +0700 Subject: [PATCH 01/17] import original accel-pptp-0.8.5 plugin code Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/Makefile.am | 13 + pppd/plugins/pptp/dirutil.c | 68 ++ pppd/plugins/pptp/dirutil.h | 14 + pppd/plugins/pptp/if_pppox.h | 1 + pppd/plugins/pptp/orckit_quirks.c | 86 +++ pppd/plugins/pptp/orckit_quirks.h | 27 + pppd/plugins/pptp/pppd-pptp.8 | 71 ++ pppd/plugins/pptp/pptp.c | 344 +++++++++ pppd/plugins/pptp/pptp_callmgr.c | 403 +++++++++++ pppd/plugins/pptp/pptp_callmgr.h | 13 + pppd/plugins/pptp/pptp_ctrl.c | 1077 +++++++++++++++++++++++++++++ pppd/plugins/pptp/pptp_ctrl.h | 57 ++ pppd/plugins/pptp/pptp_msg.h | 303 ++++++++ pppd/plugins/pptp/pptp_options.h | 41 ++ pppd/plugins/pptp/pptp_quirks.c | 54 ++ pppd/plugins/pptp/pptp_quirks.h | 59 ++ pppd/plugins/pptp/util.c | 158 +++++ pppd/plugins/pptp/util.h | 54 ++ pppd/plugins/pptp/vector.c | 209 ++++++ pppd/plugins/pptp/vector.h | 31 + 20 files changed, 3083 insertions(+) create mode 100644 pppd/plugins/pptp/Makefile.am create mode 100644 pppd/plugins/pptp/dirutil.c create mode 100644 pppd/plugins/pptp/dirutil.h create mode 120000 pppd/plugins/pptp/if_pppox.h create mode 100644 pppd/plugins/pptp/orckit_quirks.c create mode 100644 pppd/plugins/pptp/orckit_quirks.h create mode 100644 pppd/plugins/pptp/pppd-pptp.8 create mode 100644 pppd/plugins/pptp/pptp.c create mode 100644 pppd/plugins/pptp/pptp_callmgr.c create mode 100644 pppd/plugins/pptp/pptp_callmgr.h create mode 100644 pppd/plugins/pptp/pptp_ctrl.c create mode 100644 pppd/plugins/pptp/pptp_ctrl.h create mode 100644 pppd/plugins/pptp/pptp_msg.h create mode 100644 pppd/plugins/pptp/pptp_options.h create mode 100644 pppd/plugins/pptp/pptp_quirks.c create mode 100644 pppd/plugins/pptp/pptp_quirks.h create mode 100644 pppd/plugins/pptp/util.c create mode 100644 pppd/plugins/pptp/util.h create mode 100644 pppd/plugins/pptp/vector.c create mode 100644 pppd/plugins/pptp/vector.h diff --git a/pppd/plugins/pptp/Makefile.am b/pppd/plugins/pptp/Makefile.am new file mode 100644 index 000000000..6c4282c42 --- /dev/null +++ b/pppd/plugins/pptp/Makefile.am @@ -0,0 +1,13 @@ + +# set the include path found by configure +INCLUDES = $(all_includes) + +# the library search path. +lib_LTLIBRARIES = pptp.la +pptp_la_LDFLAGS = -module +pptp_la_SOURCES = pptp.c pptp_callmgr.c pptp_ctrl.c util.c vector.c \ + dirutil.c pptp_quirks.c orckit_quirks.c +noinst_HEADERS = pptp_callmgr.h pptp_ctrl.h util.h vector.h pptp_options.h \ + dirutil.h pptp_quirks.h orckit_quirks.h if_pppox.h +AM_CFLAGS = -Wall +man_MANS = pppd-pptp.8 diff --git a/pppd/plugins/pptp/dirutil.c b/pppd/plugins/pptp/dirutil.c new file mode 100644 index 000000000..e7b1a773e --- /dev/null +++ b/pppd/plugins/pptp/dirutil.c @@ -0,0 +1,68 @@ +/* dirutil.c ... directory utilities. + * C. Scott Ananian + * + * $Id: dirutil.c,v 1.2 2003/06/17 17:25:47 reink Exp $ + */ + +#include +#include +#include +#include +#include +#include "dirutil.h" + +/* Returned malloc'ed string representing basename */ +char *basenamex(char *pathname) +{ + char *dup = strdup(pathname); + char *ptr = strrchr(stripslash(dup), '/'); + if (ptr == NULL) return dup; + ptr = strdup(ptr+1); + free(dup); + return ptr; +} + +/* Return malloc'ed string representing directory name (no trailing slash) */ +char *dirnamex(char *pathname) +{ + char *dup = strdup(pathname); + char *ptr = strrchr(stripslash(dup), '/'); + if (ptr == NULL) { free(dup); return strdup("."); } + if (ptr == dup && dup[0] == '/') ptr++; + *ptr = '\0'; + return dup; +} + +/* In-place modify a string to remove trailing slashes. Returns arg. + * stripslash("/") returns "/"; + */ +char *stripslash(char *pathname) { + int len = strlen(pathname); + while (len > 1 && pathname[len - 1] == '/') + pathname[--len] = '\0'; + return pathname; +} + +/* ensure dirname exists, creating it if necessary. */ +int make_valid_path(char *dir, mode_t mode) +{ + struct stat st; + char *tmp = NULL, *path = stripslash(strdup(dir)); + int retval; + if (stat(path, &st) == 0) { /* file exists */ + if (S_ISDIR(st.st_mode)) { retval = 1; goto end; } + else { retval = 0; goto end; } /* not a directory. Oops. */ + } + /* Directory doesn't exist. Let's make it. */ + /* Make parent first. */ + if (!make_valid_path(tmp = dirnamex(path), mode)) { retval = 0; goto end; } + /* Now make this 'un. */ + if (mkdir(path, mode) < 0) { retval = 0; goto end; } + /* Success. */ + retval = 1; + +end: + if (tmp != NULL) free(tmp); + if (path != NULL) free(path); + return retval; +} diff --git a/pppd/plugins/pptp/dirutil.h b/pppd/plugins/pptp/dirutil.h new file mode 100644 index 000000000..4c9aa874c --- /dev/null +++ b/pppd/plugins/pptp/dirutil.h @@ -0,0 +1,14 @@ +/* dirutil.h ... directory utilities. + * C. Scott Ananian + * + * $Id: dirutil.h,v 1.1.1.1 2000/12/23 08:19:51 scott Exp $ + */ + +/* Returned malloc'ed string representing basename */ +char *basenamex(char *pathname); +/* Return malloc'ed string representing directory name (no trailing slash) */ +char *dirnamex(char *pathname); +/* In-place modify a string to remove trailing slashes. Returns arg. */ +char *stripslash(char *pathname); +/* ensure dirname exists, creating it if necessary. */ +int make_valid_path(char *dirname, mode_t mode); diff --git a/pppd/plugins/pptp/if_pppox.h b/pppd/plugins/pptp/if_pppox.h new file mode 120000 index 000000000..48a1663c1 --- /dev/null +++ b/pppd/plugins/pptp/if_pppox.h @@ -0,0 +1 @@ +../../kernel/driver/if_pppox.h \ No newline at end of file diff --git a/pppd/plugins/pptp/orckit_quirks.c b/pppd/plugins/pptp/orckit_quirks.c new file mode 100644 index 000000000..1d0373782 --- /dev/null +++ b/pppd/plugins/pptp/orckit_quirks.c @@ -0,0 +1,86 @@ +/* orckit_quirks.c ...... fix quirks in orckit adsl modems + * mulix + * + * $Id: orckit_quirks.c,v 1.3 2002/03/01 01:23:36 quozl Exp $ + */ + +#include +#include +#include +#include "pptp_msg.h" +#include "pptp_options.h" +#include "pptp_ctrl.h" +#include "util.h" + + + +/* return 0 on success, non zero otherwise */ +int +orckit_atur3_build_hook(struct pptp_out_call_rqst* packet) +{ + unsigned int name_length = 10; + + struct pptp_out_call_rqst fixed_packet = { + PPTP_HEADER_CTRL(PPTP_OUT_CALL_RQST), + 0, /* hton16(call->callid) */ + 0, /* hton16(call->sernum) */ + hton32(PPTP_BPS_MIN), hton32(PPTP_BPS_MAX), + hton32(PPTP_BEARER_DIGITAL), hton32(PPTP_FRAME_ANY), + hton16(PPTP_WINDOW), 0, hton16(name_length), 0, + {'R','E','L','A','Y','_','P','P','P','1',0}, {0} + }; + + if (!packet) + return -1; + + memcpy(packet, &fixed_packet, sizeof(*packet)); + + return 0; +} + +/* return 0 on success, non zero otherwise */ +int +orckit_atur3_set_link_hook(struct pptp_set_link_info* packet, + int peer_call_id) +{ + struct pptp_set_link_info fixed_packet = { + PPTP_HEADER_CTRL(PPTP_SET_LINK_INFO), + hton16(peer_call_id), + 0, + 0xffffffff, + 0xffffffff}; + + if (!packet) + return -1; + + memcpy(packet, &fixed_packet, sizeof(*packet)); + return 0; +} + +/* return 0 on success, non 0 otherwise */ +int +orckit_atur3_start_ctrl_conn_hook(struct pptp_start_ctrl_conn* packet) +{ + struct pptp_start_ctrl_conn fixed_packet = { + {0}, /* we'll set the header later */ + hton16(PPTP_VERSION), 0, 0, + hton32(PPTP_FRAME_ASYNC), hton32(PPTP_BEARER_ANALOG), + hton16(0) /* max channels */, + hton16(0x6021), + {'R','E','L','A','Y','_','P','P','P','1',0}, /* hostname */ + {'M','S',' ','W','i','n',' ','N','T',0} /* vendor */ + }; + + if (!packet) + return -1; + + /* grab the header from the original packet, since we dont + know if this is a request or a reply */ + memcpy(&fixed_packet.header, &packet->header, sizeof(struct pptp_header)); + + /* and now overwrite the full packet, effectively preserving the header */ + memcpy(packet, &fixed_packet, sizeof(*packet)); + return 0; +} + + diff --git a/pppd/plugins/pptp/orckit_quirks.h b/pppd/plugins/pptp/orckit_quirks.h new file mode 100644 index 000000000..ad0193d82 --- /dev/null +++ b/pppd/plugins/pptp/orckit_quirks.h @@ -0,0 +1,27 @@ +/* orckit_quirks.h ...... fix quirks in orckit adsl modems + * mulix + * + * $Id: orckit_quirks.h,v 1.2 2001/11/23 03:42:51 quozl Exp $ + */ + +#ifndef INC_ORCKIT_QUIRKS_H_ +#define INC_ORCKIT_QUIRKS_H_ + +#include "pptp_options.h" +#include "pptp_ctrl.h" +#include "pptp_msg.h" + +/* return 0 on success, non zero otherwise */ +int +orckit_atur3_build_hook(struct pptp_out_call_rqst* packt); + +/* return 0 on success, non zero otherwise */ +int +orckit_atur3_set_link_hook(struct pptp_set_link_info* packet, + int peer_call_id); + +/* return 0 on success, non zero otherwise */ +int +orckit_atur3_start_ctrl_conn_hook(struct pptp_start_ctrl_conn* packet); + +#endif /* INC_ORCKIT_QUIRKS_H_ */ diff --git a/pppd/plugins/pptp/pppd-pptp.8 b/pppd/plugins/pptp/pppd-pptp.8 new file mode 100644 index 000000000..85b31b21a --- /dev/null +++ b/pppd/plugins/pptp/pppd-pptp.8 @@ -0,0 +1,71 @@ +.\" manual page [] for ACCEL-PPTP plugin for pppd 2.4 +.\" $Id: pppd-pptp.8,v 1.0 2007/10/17 13:27:17 kad Exp $ +.\" SH section heading +.\" SS subsection heading +.\" LP paragraph +.\" IP indented paragraph +.\" TP hanging label +.TH PPPD-PPTP 8 +.SH NAME +pptp.so \- PPTP VPN plugin for +.BR pppd (8) +.SH SYNOPSIS +.B pppd +[ +.I options +] +plugin pptp.so +.SH DESCRIPTION +.LP +The PPTP plugin for pppd performs interaction with pptp kernel module +and has built-in call manager (client part of PPTP). +It pasees necessary paremeters from \fIoptions\fR into kernel module +to configure ppp-pptp channel. If it runs in client mode, then additionally +call manager starts up. PPTPD daemon automaticaly invokes this plugin +in server mode and passes necessary options, so additional configuration +is not needed. + +.SH OPTIONS for client mode +The PPTP plugin introduces one additional pppd option: +.TP +.BI "pptp_server " server " (required)" +Specifies ip address or hostname of pptp server. +.TP +.BI "pptp_window " packets " (optional)" +The amount of sliding window size. +Set to 0 to turn off sliding window. + to 3-10 for low speed connections. + to >10 for hi speed connections. +.TP +.BI "pptp_phone " phone " (optional)" +The phone string that sended to pptp server. +.TP +.BI "pptp_timeout " miliseconds " (optional)" +Specifies timeout for waiting "ack" packet from server. + +.SH USAGE +Sample configuration file: +.nf +plugin "pptp.so" +pptp_server 192.168.0.1 +pptp_window 50 +name myname +remotename pptp +noauth +refuse-eap +refuse-chap +refuse-mschap +nobsdcomp +nodeflate +novj +novjccomp +require-mppe-128 +lcp-echo-interval 20 +lcp-echo-failure 3 +.fi + +.SH SEE ALSO +.BR pppd (8) " " pptpd (8) " " pptpd.conf (5) + +.SH AUTHOR +xeb xeb@mail.ru diff --git a/pppd/plugins/pptp/pptp.c b/pppd/plugins/pptp/pptp.c new file mode 100644 index 000000000..1522d19c7 --- /dev/null +++ b/pppd/plugins/pptp/pptp.c @@ -0,0 +1,344 @@ +/*************************************************************************** + * Copyright (C) 2006 by Kozlov D. * + * xeb@mail.ru * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + ***************************************************************************/ + + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "pppd/pppd.h" +#include "pppd/fsm.h" +#include "pppd/lcp.h" +#include "pppd/ipcp.h" +#include "pppd/ccp.h" +#include "pppd/pathnames.h" + +#include "pptp_callmgr.h" +#include +#include +#include "if_pppox.h" + +#include +#include + + + +extern char** environ; + +char pppd_version[] = PPPD_VERSION; +extern int new_style_driver; + + +char *pptp_server = NULL; +char *pptp_client = NULL; +char *pptp_phone = NULL; +int pptp_sock=-1; +int pptp_timeout=100000; +struct in_addr localbind = { INADDR_NONE }; + +static int callmgr_sock; +static int pptp_fd; +int call_ID; + +//static struct in_addr get_ip_address(char *name); +static int open_callmgr(int call_id,struct in_addr inetaddr, char *phonenr,int window); +static void launch_callmgr(int call_is,struct in_addr inetaddr, char *phonenr,int window); +static int get_call_id(int sock, pid_t gre, pid_t pppd, u_int16_t *peer_call_id); + +//static int pptp_devname_hook(char *cmd, char **argv, int doit); +static option_t Options[] = +{ + { "pptp_server", o_string, &pptp_server, + "PPTP Server" }, + { "pptp_client", o_string, &pptp_client, + "PPTP Client" }, + { "pptp_sock",o_int, &pptp_sock, + "PPTP socket" }, + { "pptp_phone", o_string, &pptp_phone, + "PPTP Phone number" }, + { NULL } +}; + +static int pptp_connect(void); +//static void pptp_send_config(int mtu,u_int32_t asyncmap,int pcomp,int accomp); +//static void pptp_recv_config(int mru,u_int32_t asyncmap,int pcomp,int accomp); +static void pptp_disconnect(void); + +struct channel pptp_channel = { + options: Options, + //process_extra_options: &PPPOEDeviceOptions, + check_options: NULL, + connect: &pptp_connect, + disconnect: &pptp_disconnect, + establish_ppp: &generic_establish_ppp, + disestablish_ppp: &generic_disestablish_ppp, + //send_config: &pptp_send_config, + //recv_config: &pptp_recv_config, + close: NULL, + cleanup: NULL +}; + +static int pptp_start_server(void) +{ + pptp_fd=pptp_sock; + sprintf(ppp_devnam,"pptp (%s)",pptp_client); + + return pptp_fd; +} +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); + } + //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)); + 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,50); + 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_connect(void) +{ + if ((!pptp_server && !pptp_client) || (pptp_server && pptp_client)) + { + fatal("PPTP: unknown mode (you must specify pptp_server or pptp_client option)"); + return -1; + } + + if (pptp_server) return pptp_start_client(); + return pptp_start_server(); +} + +static void pptp_disconnect(void) +{ + if (pptp_server) close(callmgr_sock); + close(pptp_fd); +} + +static int open_callmgr(int call_id,struct in_addr inetaddr, char *phonenr,int window) +{ + /* Try to open unix domain socket to call manager. */ + struct sockaddr_un where; + const int NUM_TRIES = 3; + int i, fd; + pid_t pid; + int status; + /* Open socket */ + if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) + { + fatal("Could not create unix domain socket: %s", strerror(errno)); + } + /* Make address */ + callmgr_name_unixsock(&where, inetaddr, localbind); + for (i = 0; i < NUM_TRIES; i++) + { + if (connect(fd, (struct sockaddr *) &where, sizeof(where)) < 0) + { + /* couldn't connect. We'll have to launch this guy. */ + + unlink (where.sun_path); + + /* fork and launch call manager process */ + switch (pid = fork()) + { + case -1: /* failure */ + fatal("fork() to launch call manager failed."); + case 0: /* child */ + { + close (fd); + close(pptp_fd); + /* close the pty and gre in the call manager */ + // close(pty_fd); + //close(gre_fd); + launch_callmgr(call_id,inetaddr, phonenr,window); + } + default: /* parent */ + waitpid(pid, &status, 0); + if (status!= 0) + { + close(fd); + error("Call manager exited with error %d", status); + return -1; + } + break; + } + sleep(1); + } + else return fd; + } + close(fd); + error("Could not launch call manager after %d tries.", i); + return -1; /* make gcc happy */ +} + +/*** 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]; + sprintf(win,"%u",window); + sprintf(call,"%u",call_id); + snprintf(buf, sizeof(buf), "pptp: call manager for %s", my_argv[1]); + //inststr(argc, argv, envp, buf); + exit(callmgr_main(8, my_argv, environ)); +} + +/*** exchange data with the call manager *************************************/ +/* XXX need better error checking XXX */ +static int get_call_id(int sock, pid_t gre, pid_t pppd, + u_int16_t *peer_call_id) +{ + u_int16_t m_call_id, m_peer_call_id; + /* write pid's to socket */ + /* don't bother with network byte order, because pid's are meaningless + * outside the local host. + */ + int rc; + rc = write(sock, &gre, sizeof(gre)); + if (rc != sizeof(gre)) + return -1; + rc = write(sock, &pppd, sizeof(pppd)); + if (rc != sizeof(pppd)) + return -1; + rc = read(sock, &m_call_id, sizeof(m_call_id)); + if (rc != sizeof(m_call_id)) + return -1; + rc = read(sock, &m_peer_call_id, sizeof(m_peer_call_id)); + if (rc != sizeof(m_peer_call_id)) + return -1; + /* + * XXX FIXME ... DO ERROR CHECKING & TIME-OUTS XXX + * (Rhialto: I am assuming for now that timeouts are not relevant + * here, because the read and write calls would return -1 (fail) when + * the peer goes away during the process. We know it is (or was) + * running because the connect() call succeeded.) + * (James: on the other hand, if the route to the peer goes away, we + * wouldn't get told by read() or write() for quite some time.) + */ + *peer_call_id = m_peer_call_id; + return 0; +} + +void plugin_init(void) +{ + /*if (!ppp_available() && !new_style_driver) + { + fatal("Linux kernel does not support PPP -- are you running 2.4.x?"); + }*/ + + add_options(Options); + + info("PPTP plugin version %s compiled for pppd-%s, linux-%s", + VERSION, PPPD_VERSION,KERNELVERSION); + + the_channel = &pptp_channel; + modem = 0; +} + diff --git a/pppd/plugins/pptp/pptp_callmgr.c b/pppd/plugins/pptp/pptp_callmgr.c new file mode 100644 index 000000000..20bb7369a --- /dev/null +++ b/pppd/plugins/pptp/pptp_callmgr.c @@ -0,0 +1,403 @@ +/* pptp_callmgr.c ... Call manager for PPTP connections. + * Handles TCP port 1723 protocol. + * C. Scott Ananian + * + * $Id: pptp_callmgr.c,v 1.20 2005/03/31 07:42:39 quozl Exp $ + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "pptp_callmgr.h" +#include "pptp_ctrl.h" +#include "pptp_msg.h" +#include "dirutil.h" +#include "vector.h" +#include "util.h" + +extern struct in_addr localbind; /* from pptp.c */ +extern int call_ID; + +int open_inetsock(struct in_addr inetaddr); +int open_unixsock(struct in_addr inetaddr); +void close_inetsock(int fd, struct in_addr inetaddr); +void close_unixsock(int fd, struct in_addr inetaddr); + +sigjmp_buf callmgr_env; + +void callmgr_sighandler(int sig) { + /* TODO: according to signal(2), siglongjmp() is unsafe used here */ + siglongjmp (callmgr_env, 1); +} + +void callmgr_do_nothing(int sig) { + /* do nothing signal handler */ +} + +struct local_callinfo { + int unix_sock; + pid_t pid[2]; +}; + +struct local_conninfo { + VECTOR * call_list; + fd_set * call_set; +}; + +/* Call callback */ +void call_callback(PPTP_CONN *conn, PPTP_CALL *call, enum call_state state) +{ + struct local_callinfo *lci; + struct local_conninfo *conninfo; + u_int16_t call_id[2]; + switch(state) { + case CALL_OPEN_DONE: + /* okey dokey. This means that the call_id and peer_call_id are + * now valid, so lets send them on to our friends who requested + * this call. */ + lci = pptp_call_closure_get(conn, call); assert(lci != NULL); + pptp_call_get_ids(conn, call, &call_id[0], &call_id[1]); + write(lci->unix_sock, &call_id, sizeof(call_id)); + /* Our duty to the fatherland is now complete. */ + break; + case CALL_OPEN_FAIL: + case CALL_CLOSE_RQST: + case CALL_CLOSE_DONE: + /* don't need to do anything here, except make sure tables + * are sync'ed */ + log("Closing connection (call state)"); + conninfo = pptp_conn_closure_get(conn); + lci = pptp_call_closure_get(conn, call); + assert(lci != NULL && conninfo != NULL); + if (vector_contains(conninfo->call_list, lci->unix_sock)) { + vector_remove(conninfo->call_list, lci->unix_sock); + close(lci->unix_sock); + FD_CLR(lci->unix_sock, conninfo->call_set); + //if(lci->pid[0] > 1) kill(lci->pid[0], SIGTERM); + //if(lci->pid[1] > 1) kill(lci->pid[1], SIGTERM); + } + break; + default: + log("Unhandled call callback state [%d].", (int) state); + break; + } +} + +/****************************************************************************** + * NOTE ABOUT 'VOLATILE': + * several variables here get a volatile qualifier to silence warnings + * from older (before 3.0) gccs. if the longjmp stuff is removed, + * the volatile qualifiers should be removed as well. + *****************************************************************************/ + +/*** Call Manager *************************************************************/ +int callmgr_main(int argc, char **argv, char **envp) +{ + struct in_addr inetaddr; + int inet_sock, unix_sock; + fd_set call_set; + PPTP_CONN * conn; + VECTOR * call_list; + int max_fd = 0; + volatile int first = 1; + int retval; + int i; + char * volatile phonenr=NULL; + int volatile window=10; + //int volatile call_id=0; + /* Step 0: Check arguments */ + if (argc < 2) + fatal("Usage: %s ip.add.ress.here [--phone ]", argv[0]); + //phonenr = argc == 3 ? argv[2] : NULL; + for(i=2; icall_list = call_list; + conninfo->call_set = &call_set; + pptp_conn_closure_put(conn, conninfo); + } + if (sigsetjmp(callmgr_env, 1) != 0) goto shutdown; + /* Step 3: Get FD_SETs */ + max_fd = unix_sock; + do { + int rc; + fd_set read_set = call_set, write_set; + FD_ZERO (&write_set); + if (pptp_conn_established(conn)) { + FD_SET (unix_sock, &read_set); + if (unix_sock > max_fd) max_fd = unix_sock; + } + pptp_fd_set(conn, &read_set, &write_set, &max_fd); + for (; max_fd > 0 ; max_fd--) { + if (FD_ISSET (max_fd, &read_set) || + FD_ISSET (max_fd, &write_set)) + break; + } + /* Step 4: Wait on INET or UNIX event */ + if ((rc = select(max_fd + 1, &read_set, &write_set, NULL, NULL)) <0) { + if (errno == EBADF) break; + /* a signal or somesuch. */ + continue; + } + /* Step 5a: Handle INET events */ + rc = pptp_dispatch(conn, &read_set, &write_set); + if (rc < 0) + break; + /* Step 5b: Handle new connection to UNIX socket */ + if (FD_ISSET(unix_sock, &read_set)) { + /* New call! */ + struct sockaddr_un from; + int len = sizeof(from); + PPTP_CALL * call; + struct local_callinfo *lci; + int s; + /* Accept the socket */ + FD_CLR (unix_sock, &read_set); + if ((s = accept(unix_sock, (struct sockaddr *) &from, &len)) < 0) { + warn("Socket not accepted: %s", strerror(errno)); + goto skip_accept; + } + /* Allocate memory for local call information structure. */ + if ((lci = malloc(sizeof(*lci))) == NULL) { + warn("Out of memory."); close(s); goto skip_accept; + } + lci->unix_sock = s; + /* Give the initiator time to write the PIDs while we open + * the call */ + call = pptp_call_open(conn, call_ID,call_callback, phonenr,window); + /* Read and store the associated pids */ + read(s, &lci->pid[0], sizeof(lci->pid[0])); + read(s, &lci->pid[1], sizeof(lci->pid[1])); + /* associate the local information with the call */ + pptp_call_closure_put(conn, call, (void *) lci); + /* The rest is done on callback. */ + /* Keep alive; wait for close */ + retval = vector_insert(call_list, s, call); assert(retval); + if (s > max_fd) max_fd = s; + FD_SET(s, &call_set); + first = 0; + } +skip_accept: /* Step 5c: Handle socket close */ + for (i = 0; i < max_fd + 1; i++) + if (FD_ISSET(i, &read_set)) { + /* close it */ + PPTP_CALL * call; + retval = vector_search(call_list, i, &call); + if (retval) { + struct local_callinfo *lci = + pptp_call_closure_get(conn, call); + log("Closing connection (unhandled)"); + //if(lci->pid[0] > 1) kill(lci->pid[0], SIGTERM); + //if(lci->pid[1] > 1) kill(lci->pid[1], SIGTERM); + free(lci); + /* soft shutdown. Callback will do hard shutdown later */ + pptp_call_close(conn, call); + vector_remove(call_list, i); + } + FD_CLR(i, &call_set); + close(i); + } + } while (vector_size(call_list) > 0 || first); +shutdown: + { + int rc; + fd_set read_set, write_set; + struct timeval tv; + signal(SIGINT, callmgr_do_nothing); + signal(SIGTERM, callmgr_do_nothing); + /* warn("Shutdown"); */ + /* kill all open calls */ + for (i = 0; i < vector_size(call_list); i++) { + PPTP_CALL *call = vector_get_Nth(call_list, i); + //struct local_callinfo *lci = pptp_call_closure_get(conn, call); + log("Closing connection (shutdown)"); + pptp_call_close(conn, call); + //if(lci->pid[0] > 1) kill(lci->pid[0], SIGTERM); + //if(lci->pid[1] > 1) kill(lci->pid[1], SIGTERM); + } + /* attempt to dispatch these messages */ + FD_ZERO(&read_set); + FD_ZERO(&write_set); + pptp_fd_set(conn, &read_set, &write_set, &max_fd); + tv.tv_sec = 0; + tv.tv_usec = 0; + select(max_fd + 1, &read_set, &write_set, NULL, &tv); + rc = pptp_dispatch(conn, &read_set, &write_set); + if (rc > 0) { + /* wait for a respond, a timeout because there might not be one */ + FD_ZERO(&read_set); + FD_ZERO(&write_set); + pptp_fd_set(conn, &read_set, &write_set, &max_fd); + tv.tv_sec = 2; + tv.tv_usec = 0; + select(max_fd + 1, &read_set, &write_set, NULL, &tv); + rc = pptp_dispatch(conn, &read_set, &write_set); + if (rc > 0) { + if (i > 0) sleep(2); + /* no more open calls. Close the connection. */ + pptp_conn_close(conn, PPTP_STOP_LOCAL_SHUTDOWN); + /* wait for a respond, a timeout because there might not be one */ + FD_ZERO(&read_set); + FD_ZERO(&write_set); + pptp_fd_set(conn, &read_set, &write_set, &max_fd); + tv.tv_sec = 2; + tv.tv_usec = 0; + select(max_fd + 1, &read_set, &write_set, NULL, &tv); + pptp_dispatch(conn, &read_set, &write_set); + if (rc > 0) sleep(2); + } + } + /* with extreme prejudice */ + pptp_conn_destroy(conn); + vector_destroy(call_list); + } +cleanup: + signal(SIGINT, callmgr_do_nothing); + signal(SIGTERM, callmgr_do_nothing); + close_inetsock(inet_sock, inetaddr); + close_unixsock(unix_sock, inetaddr); + return 0; +} + +/*** open_inetsock ************************************************************/ +int open_inetsock(struct in_addr inetaddr) +{ + struct sockaddr_in dest, src; + int s; + dest.sin_family = AF_INET; + dest.sin_port = htons(PPTP_PORT); + dest.sin_addr = inetaddr; + if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) { + warn("socket: %s", strerror(errno)); + return s; + } + if (localbind.s_addr != INADDR_NONE) { + bzero(&src, sizeof(src)); + src.sin_family = AF_INET; + src.sin_addr = localbind; + if (bind(s, (struct sockaddr *) &src, sizeof(src)) != 0) { + warn("bind: %s", strerror(errno)); + close(s); return -1; + } + } + if (connect(s, (struct sockaddr *) &dest, sizeof(dest)) < 0) { + warn("connect: %s", strerror(errno)); + close(s); return -1; + } + return s; +} + +/*** open_unixsock ************************************************************/ +int open_unixsock(struct in_addr inetaddr) +{ + struct sockaddr_un where; + struct stat st; + char *dir; + int s; + if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { + warn("socket: %s", strerror(errno)); + return s; + } + callmgr_name_unixsock( &where, inetaddr, localbind); + if (stat(where.sun_path, &st) >= 0) + { + warn("Call manager for %s is already running.", inet_ntoa(inetaddr)); + close(s); return -1; + } + /* Make sure path is valid. */ + dir = dirnamex(where.sun_path); + if (!make_valid_path(dir, 0770)) + fatal("Could not make path to %s: %s", where.sun_path, strerror(errno)); + free(dir); + if (bind(s, (struct sockaddr *) &where, sizeof(where)) < 0) { + warn("bind: %s", strerror(errno)); + close(s); return -1; + } + chmod(where.sun_path, 0777); + listen(s, 127); + return s; +} + +/*** close_inetsock ***********************************************************/ +void close_inetsock(int fd, struct in_addr inetaddr) +{ + close(fd); +} + +/*** close_unixsock ***********************************************************/ +void close_unixsock(int fd, struct in_addr inetaddr) +{ + struct sockaddr_un where; + close(fd); + callmgr_name_unixsock(&where, inetaddr, localbind); + unlink(where.sun_path); +} + +/*** make a unix socket address ***********************************************/ +void callmgr_name_unixsock(struct sockaddr_un *where, + struct in_addr inetaddr, + struct in_addr localbind) +{ + char localaddr[16], remoteaddr[16]; + where->sun_family = AF_UNIX; + strncpy(localaddr, inet_ntoa(localbind), 16); + strncpy(remoteaddr, inet_ntoa(inetaddr), 16); + snprintf(where->sun_path, sizeof(where->sun_path), + PPTP_SOCKET_PREFIX "%s:%i", remoteaddr,call_ID); +} diff --git a/pppd/plugins/pptp/pptp_callmgr.h b/pppd/plugins/pptp/pptp_callmgr.h new file mode 100644 index 000000000..d7bc2d651 --- /dev/null +++ b/pppd/plugins/pptp/pptp_callmgr.h @@ -0,0 +1,13 @@ +/* pptp_callmgr.h ... Call manager for PPTP connections. + * Handles TCP port 1723 protocol. + * C. Scott Ananian + * + * $Id: pptp_callmgr.h,v 1.3 2003/02/17 00:22:17 quozl Exp $ + */ + +#define PPTP_SOCKET_PREFIX "/var/run/pptp/" + +int callmgr_main(int argc, char**argv, char**envp); +void callmgr_name_unixsock(struct sockaddr_un *where, + struct in_addr inetaddr, + struct in_addr localbind); diff --git a/pppd/plugins/pptp/pptp_ctrl.c b/pppd/plugins/pptp/pptp_ctrl.c new file mode 100644 index 000000000..1bab3f9ab --- /dev/null +++ b/pppd/plugins/pptp/pptp_ctrl.c @@ -0,0 +1,1077 @@ +/* pptp_ctrl.c ... handle PPTP control connection. + * C. Scott Ananian + * + * $Id: pptp_ctrl.c,v 1.31 2005/03/31 07:42:39 quozl Exp $ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "pptp_msg.h" +#include "pptp_ctrl.h" +#include "pptp_options.h" +#include "vector.h" +#include "util.h" +#include "pptp_quirks.h" + +/* BECAUSE OF SIGNAL LIMITATIONS, EACH PROCESS CAN ONLY MANAGE ONE + * CONNECTION. SO THIS 'PPTP_CONN' STRUCTURE IS A BIT MISLEADING. + * WE'LL KEEP CONNECTION-SPECIFIC INFORMATION IN THERE ANYWAY (AS + * OPPOSED TO USING GLOBAL VARIABLES), BUT BEWARE THAT THE ENTIRE + * UNIX SIGNAL-HANDLING SEMANTICS WOULD HAVE TO CHANGE (OR THE + * TIME-OUT CODE DRASTICALLY REWRITTEN) BEFORE YOU COULD DO A + * PPTP_CONN_OPEN MORE THAN ONCE PER PROCESS AND GET AWAY WITH IT. + */ + +/* This structure contains connection-specific information that the + * signal handler needs to see. Thus, it needs to be in a global + * variable. If you end up using pthreads or something (why not + * just processes?), this would have to be placed in a thread-specific + * data area, using pthread_get|set_specific, etc., so I've + * conveniently encapsulated it for you. + * [linux threads will have to support thread-specific signals + * before this would work at all, which, as of this writing + * (linux-threads v0.6, linux kernel 2.1.72), it does not.] + */ + +/* Globals */ + +/* control the number of times echo packets will be logged */ +static int nlogecho = 10; + +static struct thread_specific { + struct sigaction old_sigaction; /* evil signals */ + PPTP_CONN * conn; +} global; + +#define INITIAL_BUFSIZE 512 /* initial i/o buffer size. */ + +struct PPTP_CONN { + int inet_sock; + /* Connection States */ + enum { + CONN_IDLE, CONN_WAIT_CTL_REPLY, CONN_WAIT_STOP_REPLY, CONN_ESTABLISHED + } conn_state; /* on startup: CONN_IDLE */ + /* Keep-alive states */ + enum { + KA_NONE, KA_OUTSTANDING + } ka_state; /* on startup: KA_NONE */ + /* Keep-alive ID; monotonically increasing (watch wrap-around!) */ + u_int32_t ka_id; /* on startup: 1 */ + /* Other properties. */ + u_int16_t version; + u_int16_t firmware_rev; + u_int8_t hostname[64], vendor[64]; + /* XXX these are only PNS properties, currently XXX */ + /* Call assignment information. */ + u_int16_t call_serial_number; + VECTOR *call; + void * closure; + pptp_conn_cb callback; + /******* IO buffers ******/ + char * read_buffer, *write_buffer; + size_t read_alloc, write_alloc; + size_t read_size, write_size; +}; + +struct PPTP_CALL { + /* Call properties */ + enum { + PPTP_CALL_PAC, PPTP_CALL_PNS + } call_type; + union { + enum pptp_pac_state { + PAC_IDLE, PAC_WAIT_REPLY, PAC_ESTABLISHED, PAC_WAIT_CS_ANS + } pac; + enum pptp_pns_state { + PNS_IDLE, PNS_WAIT_REPLY, PNS_ESTABLISHED, PNS_WAIT_DISCONNECT + } pns; + } state; + u_int16_t call_id, peer_call_id; + u_int16_t sernum; + u_int32_t speed; + /* For user data: */ + pptp_call_cb callback; + void * closure; +}; + + +/* PPTP error codes: ----------------------------------------------*/ + +/* (General Error Codes) */ +static const struct { + const char *name, *desc; +} pptp_general_errors[] = { +#define PPTP_GENERAL_ERROR_NONE 0 + { "(None)", "No general error" }, +#define PPTP_GENERAL_ERROR_NOT_CONNECTED 1 + { "(Not-Connected)", "No control connection exists yet for this " + "PAC-PNS pair" }, +#define PPTP_GENERAL_ERROR_BAD_FORMAT 2 + { "(Bad-Format)", "Length is wrong or Magic Cookie value is incorrect" }, +#define PPTP_GENERAL_ERROR_BAD_VALUE 3 + { "(Bad-Value)", "One of the field values was out of range or " + "reserved field was non-zero" }, +#define PPTP_GENERAL_ERROR_NO_RESOURCE 4 + { "(No-Resource)", "Insufficient resources to handle this command now" }, +#define PPTP_GENERAL_ERROR_BAD_CALLID 5 + { "(Bad-Call ID)", "The Call ID is invalid in this context" }, +#define PPTP_GENERAL_ERROR_PAC_ERROR 6 + { "(PAC-Error)", "A generic vendor-specific error occured in the PAC" } +}; + +#define MAX_GENERAL_ERROR ( sizeof(pptp_general_errors) / \ + sizeof(pptp_general_errors[0]) - 1) + +/* Outgoing Call Reply Result Codes */ +static const char *pptp_out_call_reply_result[] = { +/* 0 */ "Unknown Result Code", +/* 1 */ "Connected", +/* 2 */ "General Error", +/* 3 */ "No Carrier Detected", +/* 4 */ "Busy Signal", +/* 5 */ "No Dial Tone", +/* 6 */ "Time Out", +/* 7 */ "Not Accepted, Call is administratively prohibited" }; + +#define MAX_OUT_CALL_REPLY_RESULT 7 + +/* Call Disconnect Notify Result Codes */ +static const char *pptp_call_disc_ntfy[] = { +/* 0 */ "Unknown Result Code", +/* 1 */ "Lost Carrier", +/* 2 */ "General Error", +/* 3 */ "Administrative Shutdown", +/* 4 */ "(your) Request" }; + +#define MAX_CALL_DISC_NTFY 4 + +/* Call Disconnect Notify Result Codes */ +static const char *pptp_start_ctrl_conn_rply[] = { +/* 0 */ "Unknown Result Code", +/* 1 */ "Successful Channel Establishment", +/* 2 */ "General Error", +/* 3 */ "Command Channel Already Exists", +/* 4 */ "Requester is not Authorized" }; + +#define MAX_START_CTRL_CONN_REPLY 4 + +/* timing options */ +int idle_wait = PPTP_TIMEOUT; +int max_echo_wait = PPTP_TIMEOUT; + +/* Local prototypes */ +static void pptp_reset_timer(void); +static void pptp_handle_timer(); +/* Write/read as much as we can without blocking. */ +int pptp_write_some(PPTP_CONN * conn); +int pptp_read_some(PPTP_CONN * conn); +/* Make valid packets from read_buffer */ +int pptp_make_packet(PPTP_CONN * conn, void **buf, size_t *size); +/* Add packet to write_buffer */ +int pptp_send_ctrl_packet(PPTP_CONN * conn, void * buffer, size_t size); +/* Dispatch packets (general) */ +int pptp_dispatch_packet(PPTP_CONN * conn, void * buffer, size_t size); +/* Dispatch packets (control messages) */ +int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size); +/* Set link info, for pptp servers that need it. + this is a noop, unless the user specified a quirk and + there's a set_link hook defined in the quirks table + for that quirk */ +void pptp_set_link(PPTP_CONN * conn, int peer_call_id); + +/*** log error information in control packets *********************************/ +static void ctrlp_error( int result, int error, int cause, + const char *result_text[], int max_result) +{ + if( cause >= 0) + log("Result code is %d '%s'. Error code is %d, Cause code is %d", + result, result_text[result <= max_result ? result : 0], error, + cause ); + else + log("Reply result code is %d '%s'. Error code is %d", + result, result_text[result <= max_result ? result : 0], error); + if ((error > 0) && (error <= MAX_GENERAL_ERROR)){ + if( result != PPTP_RESULT_GENERAL_ERROR ) + log("Result code is something else then \"general error\", " + "so the following error is probably bogus."); + log("Error is '%s', Error message: '%s'", + pptp_general_errors[error].name, + pptp_general_errors[error].desc); + } +} + +static const char *ctrl_msg_types[] = { + "invalid control message type", +/* (Control Connection Management) */ + "Start-Control-Connection-Request", /* 1 */ + "Start-Control-Connection-Reply", /* 2 */ + "Stop-Control-Connection-Request", /* 3 */ + "Stop-Control-Connection-Reply", /* 4 */ + "Echo-Request", /* 5 */ + "Echo-Reply", /* 6 */ +/* (Call Management) */ + "Outgoing-Call-Request", /* 7 */ + "Outgoing-Call-Reply", /* 8 */ + "Incoming-Call-Request", /* 9 */ + "Incoming-Call-Reply", /* 10 */ + "Incoming-Call-Connected", /* 11 */ + "Call-Clear-Request", /* 12 */ + "Call-Disconnect-Notify", /* 13 */ +/* (Error Reporting) */ + "WAN-Error-Notify", /* 14 */ +/* (PPP Session Control) */ + "Set-Link-Info" /* 15 */ +}; +#define MAX_CTRLMSG_TYPE 15 + +/*** report a sent packet ****************************************************/ +static void ctrlp_rep( void * buffer, int size, int isbuff) +{ + struct pptp_header *packet = buffer; + unsigned int type; + if(size < sizeof(struct pptp_header)) return; + type = ntoh16(packet->ctrl_type); + /* FIXME: do not report sending echo requests as long as they are + * sent in a signal handler. This may dead lock as the syslog call + * is not reentrant */ + if( type == PPTP_ECHO_RQST ) return; + /* don't keep reporting sending of echo's */ + if( (type == PPTP_ECHO_RQST || type == PPTP_ECHO_RPLY) && nlogecho <= 0 ) return; + log("%s control packet type is %d '%s'\n",isbuff ? "Buffered" : "Sent", + type, ctrl_msg_types[type <= MAX_CTRLMSG_TYPE ? type : 0]); + +} + + + +/* Open new pptp_connection. Returns NULL on failure. */ +PPTP_CONN * pptp_conn_open(int inet_sock, int isclient, pptp_conn_cb callback) +{ + PPTP_CONN *conn; + /* Allocate structure */ + if ((conn = malloc(sizeof(*conn))) == NULL) return NULL; + if ((conn->call = vector_create()) == NULL) { free(conn); return NULL; } + /* Initialize */ + conn->inet_sock = inet_sock; + conn->conn_state = CONN_IDLE; + conn->ka_state = KA_NONE; + conn->ka_id = 1; + conn->call_serial_number = 0; + conn->callback = callback; + /* Create I/O buffers */ + conn->read_size = conn->write_size = 0; + conn->read_alloc = conn->write_alloc = INITIAL_BUFSIZE; + conn->read_buffer = + malloc(sizeof(*(conn->read_buffer)) * conn->read_alloc); + conn->write_buffer = + malloc(sizeof(*(conn->write_buffer)) * conn->write_alloc); + if (conn->read_buffer == NULL || conn->write_buffer == NULL) { + if (conn->read_buffer != NULL) free(conn->read_buffer); + if (conn->write_buffer != NULL) free(conn->write_buffer); + vector_destroy(conn->call); free(conn); return NULL; + } + /* Make this socket non-blocking. */ + fcntl(conn->inet_sock, F_SETFL, O_NONBLOCK); + /* Request connection from server, if this is a client */ + if (isclient) { + struct pptp_start_ctrl_conn packet = { + PPTP_HEADER_CTRL(PPTP_START_CTRL_CONN_RQST), + hton16(PPTP_VERSION), 0, 0, + hton32(PPTP_FRAME_CAP), hton32(PPTP_BEARER_CAP), + hton16(PPTP_MAX_CHANNELS), hton16(PPTP_FIRMWARE_VERSION), + PPTP_HOSTNAME, PPTP_VENDOR + }; + /* fix this packet, if necessary */ + int idx, rc; + idx = get_quirk_index(); + if (idx != -1 && pptp_fixups[idx].start_ctrl_conn) { + if ((rc = pptp_fixups[idx].start_ctrl_conn(&packet))) + warn("calling the start_ctrl_conn hook failed (%d)", rc); + } + if (pptp_send_ctrl_packet(conn, &packet, sizeof(packet))) + conn->conn_state = CONN_WAIT_CTL_REPLY; + else + return NULL; /* could not send initial start request. */ + } + /* Set up interval/keep-alive timer */ + /* First, register handler for SIGALRM */ + sigpipe_create(); + sigpipe_assign(SIGALRM); + global.conn = conn; + /* Reset event timer */ + pptp_reset_timer(); + /* all done. */ + return conn; +} + +int pptp_conn_established(PPTP_CONN *conn) { + return (conn->conn_state == CONN_ESTABLISHED); +} + +/* This currently *only* works for client call requests. + * We need to do something else to allocate calls for incoming requests. + */ +PPTP_CALL * pptp_call_open(PPTP_CONN * conn, int call_id,pptp_call_cb callback, + char *phonenr,int window) +{ + PPTP_CALL * call; + int idx, rc; + /* Send off the call request */ + struct pptp_out_call_rqst packet = { + PPTP_HEADER_CTRL(PPTP_OUT_CALL_RQST), + 0,0, /*call_id, sernum */ + hton32(PPTP_BPS_MIN), hton32(PPTP_BPS_MAX), + hton32(PPTP_BEARER_CAP), hton32(PPTP_FRAME_CAP), + hton16(window), 0, 0, 0, {0}, {0} + }; + assert(conn && conn->call); + assert(conn->conn_state == CONN_ESTABLISHED); + /* Assign call id */ + if (!call_id && !vector_scan(conn->call, 0, PPTP_MAX_CHANNELS - 1, &call_id)) + /* no more calls available! */ + return NULL; + /* allocate structure. */ + if ((call = malloc(sizeof(*call))) == NULL) return NULL; + /* Initialize call structure */ + call->call_type = PPTP_CALL_PNS; + call->state.pns = PNS_IDLE; + call->call_id = (u_int16_t) call_id; + call->sernum = conn->call_serial_number++; + call->callback = callback; + call->closure = NULL; + packet.call_id = htons(call->call_id); + packet.call_sernum = htons(call->sernum); + /* if we have a quirk, build a new packet to fit it */ + idx = get_quirk_index(); + if (idx != -1 && pptp_fixups[idx].out_call_rqst_hook) { + if ((rc = pptp_fixups[idx].out_call_rqst_hook(&packet))) + warn("calling the out_call_rqst hook failed (%d)", rc); + } + /* fill in the phone number if it was specified */ + if (phonenr) { + strncpy(packet.phone_num, phonenr, sizeof(packet.phone_num)); + packet.phone_len = strlen(phonenr); + if( packet.phone_len > sizeof(packet.phone_num)) + packet.phone_len = sizeof(packet.phone_num); + packet.phone_len = hton16 (packet.phone_len); + } + if (pptp_send_ctrl_packet(conn, &packet, sizeof(packet))) { + pptp_reset_timer(); + call->state.pns = PNS_WAIT_REPLY; + /* and add it to the call vector */ + vector_insert(conn->call, call_id, call); + return call; + } else { /* oops, unsuccessful. Deallocate. */ + free(call); + return NULL; + } +} + +/*** pptp_call_close **********************************************************/ +void pptp_call_close(PPTP_CONN * conn, PPTP_CALL * call) +{ + struct pptp_call_clear_rqst rqst = { + PPTP_HEADER_CTRL(PPTP_CALL_CLEAR_RQST), 0, 0 + }; + assert(conn && conn->call); assert(call); + assert(vector_contains(conn->call, call->call_id)); + /* haven't thought about PAC yet */ + assert(call->call_type == PPTP_CALL_PNS); + assert(call->state.pns != PNS_IDLE); + rqst.call_id = hton16(call->call_id); + /* don't check state against WAIT_DISCONNECT... allow multiple disconnect + * requests to be made. + */ + pptp_send_ctrl_packet(conn, &rqst, sizeof(rqst)); + pptp_reset_timer(); + call->state.pns = PNS_WAIT_DISCONNECT; + /* call structure will be freed when we have confirmation of disconnect. */ +} + +/*** hard close ***************************************************************/ +void pptp_call_destroy(PPTP_CONN *conn, PPTP_CALL *call) +{ + assert(conn && conn->call); assert(call); + assert(vector_contains(conn->call, call->call_id)); + /* notify */ + if (call->callback != NULL) call->callback(conn, call, CALL_CLOSE_DONE); + /* deallocate */ + vector_remove(conn->call, call->call_id); + free(call); +} + +/*** this is a soft close *****************************************************/ +void pptp_conn_close(PPTP_CONN * conn, u_int8_t close_reason) +{ + struct pptp_stop_ctrl_conn rqst = { + PPTP_HEADER_CTRL(PPTP_STOP_CTRL_CONN_RQST), + hton8(close_reason), 0, 0 + }; + int i; + assert(conn && conn->call); + /* avoid repeated close attempts */ + if (conn->conn_state == CONN_IDLE || conn->conn_state == CONN_WAIT_STOP_REPLY) + return; + /* close open calls, if any */ + for (i = 0; i < vector_size(conn->call); i++) + pptp_call_close(conn, vector_get_Nth(conn->call, i)); + /* now close connection */ + log("Closing PPTP connection"); + pptp_send_ctrl_packet(conn, &rqst, sizeof(rqst)); + pptp_reset_timer(); /* wait 60 seconds for reply */ + conn->conn_state = CONN_WAIT_STOP_REPLY; + return; +} + +/*** this is a hard close *****************************************************/ +void pptp_conn_destroy(PPTP_CONN * conn) +{ + int i; + assert(conn != NULL); assert(conn->call != NULL); + /* destroy all open calls */ + for (i = 0; i < vector_size(conn->call); i++) + pptp_call_destroy(conn, vector_get_Nth(conn->call, i)); + /* notify */ + if (conn->callback != NULL) conn->callback(conn, CONN_CLOSE_DONE); + sigpipe_close(); + close(conn->inet_sock); + /* deallocate */ + vector_destroy(conn->call); + free(conn); +} + +/*** Deal with messages, in a non-blocking manner + * Add file descriptors used by pptp to fd_set. + */ +void pptp_fd_set(PPTP_CONN * conn, fd_set * read_set, fd_set * write_set, + int * max_fd) +{ + assert(conn && conn->call); + /* Add fd to write_set if there are outstanding writes. */ + if (conn->write_size > 0) + FD_SET(conn->inet_sock, write_set); + /* Always add fd to read_set. (always want something to read) */ + FD_SET(conn->inet_sock, read_set); + if (*max_fd < conn->inet_sock) *max_fd = conn->inet_sock; + /* Add signal pipe file descriptor to set */ + int sig_fd = sigpipe_fd(); + FD_SET(sig_fd, read_set); + if (*max_fd < sig_fd) *max_fd = sig_fd; +} + +/*** handle any pptp file descriptors set in fd_set, and clear them ***********/ +int pptp_dispatch(PPTP_CONN * conn, fd_set * read_set, fd_set * write_set) +{ + int r = 0; + assert(conn && conn->call); + /* Check for signals */ + if (FD_ISSET(sigpipe_fd(), read_set)) { + if (sigpipe_read() == SIGALRM) pptp_handle_timer(); + FD_CLR(sigpipe_fd(), read_set); + } + /* Check write_set could be set. */ + if (FD_ISSET(conn->inet_sock, write_set)) { + FD_CLR(conn->inet_sock, write_set); + if (conn->write_size > 0) + r = pptp_write_some(conn);/* write as much as we can without blocking */ + } + /* Check read_set */ + if (r >= 0 && FD_ISSET(conn->inet_sock, read_set)) { + void *buffer; size_t size; + FD_CLR(conn->inet_sock, read_set); + r = pptp_read_some(conn); /* read as much as we can without blocking */ + if (r < 0) + return r; + /* make packets of the buffer, while we can. */ + while (r >= 0 && pptp_make_packet(conn, &buffer, &size)) { + r = pptp_dispatch_packet(conn, buffer, size); + free(buffer); + } + } + /* That's all, folks. Simple, eh? */ + return r; +} + +/*** Non-blocking write *******************************************************/ +int pptp_write_some(PPTP_CONN * conn) { + ssize_t retval; + assert(conn && conn->call); + retval = write(conn->inet_sock, conn->write_buffer, conn->write_size); + if (retval < 0) { /* error. */ + if (errno == EAGAIN || errno == EINTR) { + return 0; + } else { /* a real error */ + log("write error: %s", strerror(errno)); + return -1; + } + } + assert(retval <= conn->write_size); + conn->write_size -= retval; + memmove(conn->write_buffer, conn->write_buffer + retval, conn->write_size); + ctrlp_rep(conn->write_buffer, retval, 0); + return 0; +} + +/*** Non-blocking read ********************************************************/ +int pptp_read_some(PPTP_CONN * conn) +{ + ssize_t retval; + assert(conn && conn->call); + if (conn->read_size == conn->read_alloc) { /* need to alloc more memory */ + char *new_buffer = realloc(conn->read_buffer, + sizeof(*(conn->read_buffer)) * conn->read_alloc * 2); + if (new_buffer == NULL) { + log("Out of memory"); return -1; + } + conn->read_alloc *= 2; + conn->read_buffer = new_buffer; + } + retval = read(conn->inet_sock, conn->read_buffer + conn->read_size, + conn->read_alloc - conn->read_size); + if (retval == 0) { + log("read returned zero, peer has closed"); + return -1; + } + if (retval < 0) { + if (errno == EINTR || errno == EAGAIN) + return 0; + else { /* a real error */ + log("read error: %s", strerror(errno)); + return -1; + } + } + conn->read_size += retval; + assert(conn->read_size <= conn->read_alloc); + return 0; +} + +/*** Packet formation *********************************************************/ +int pptp_make_packet(PPTP_CONN * conn, void **buf, size_t *size) +{ + struct pptp_header *header; + size_t bad_bytes = 0; + assert(conn && conn->call); assert(buf != NULL); assert(size != NULL); + /* Give up unless there are at least sizeof(pptp_header) bytes */ + while ((conn->read_size-bad_bytes) >= sizeof(struct pptp_header)) { + /* Throw out bytes until we have a valid header. */ + header = (struct pptp_header *) (conn->read_buffer + bad_bytes); + if (ntoh32(header->magic) != PPTP_MAGIC) goto throwitout; + if (ntoh16(header->reserved0) != 0) + log("reserved0 field is not zero! (0x%x) Cisco feature? \n", + ntoh16(header->reserved0)); + if (ntoh16(header->length) < sizeof(struct pptp_header)) goto throwitout; + if (ntoh16(header->length) > PPTP_CTRL_SIZE_MAX) goto throwitout; + /* well. I guess it's good. Let's see if we've got it all. */ + if (ntoh16(header->length) > (conn->read_size-bad_bytes)) + /* nope. Let's wait until we've got it, then. */ + goto flushbadbytes; + /* One last check: */ + if ((ntoh16(header->pptp_type) == PPTP_MESSAGE_CONTROL) && + (ntoh16(header->length) != + PPTP_CTRL_SIZE(ntoh16(header->ctrl_type)))) + goto throwitout; + /* well, I guess we've got it. */ + *size = ntoh16(header->length); + *buf = malloc(*size); + if (*buf == NULL) { log("Out of memory."); return 0; /* ack! */ } + memcpy(*buf, conn->read_buffer + bad_bytes, *size); + /* Delete this packet from the read_buffer. */ + conn->read_size -= (bad_bytes + *size); + memmove(conn->read_buffer, conn->read_buffer + bad_bytes + *size, + conn->read_size); + if (bad_bytes > 0) + log("%lu bad bytes thrown away.", (unsigned long) bad_bytes); + return 1; +throwitout: + bad_bytes++; + } +flushbadbytes: + /* no more packets. Let's get rid of those bad bytes */ + conn->read_size -= bad_bytes; + memmove(conn->read_buffer, conn->read_buffer + bad_bytes, conn->read_size); + if (bad_bytes > 0) + log("%lu bad bytes thrown away.", (unsigned long) bad_bytes); + return 0; +} + +/*** pptp_send_ctrl_packet ****************************************************/ +int pptp_send_ctrl_packet(PPTP_CONN * conn, void * buffer, size_t size) +{ + assert(conn && conn->call); assert(buffer); + if( conn->write_size > 0) pptp_write_some( conn); + if( conn->write_size == 0) { + ssize_t retval; + retval = write(conn->inet_sock, buffer, size); + if (retval < 0) { /* error. */ + if (errno == EAGAIN || errno == EINTR) { + /* ignore */; + retval = 0; + } else { /* a real error */ + log("write error: %s", strerror(errno)); + pptp_conn_destroy(conn); /* shut down fast. */ + return 0; + } + } + ctrlp_rep( buffer, retval, 0); + size -= retval; + if( size <= 0) return 1; + } + /* Shove anything not written into the write buffer */ + if (conn->write_size + size > conn->write_alloc) { /* need more memory */ + char *new_buffer = realloc(conn->write_buffer, + sizeof(*(conn->write_buffer)) * conn->write_alloc * 2); + if (new_buffer == NULL) { + log("Out of memory"); return 0; + } + conn->write_alloc *= 2; + conn->write_buffer = new_buffer; + } + memcpy(conn->write_buffer + conn->write_size, buffer, size); + conn->write_size += size; + ctrlp_rep( buffer,size,1); + return 1; +} + +/*** Packet Dispatch **********************************************************/ +int pptp_dispatch_packet(PPTP_CONN * conn, void * buffer, size_t size) +{ + int r = 0; + struct pptp_header *header = (struct pptp_header *)buffer; + assert(conn && conn->call); assert(buffer); + assert(ntoh32(header->magic) == PPTP_MAGIC); + assert(ntoh16(header->length) == size); + switch (ntoh16(header->pptp_type)) { + case PPTP_MESSAGE_CONTROL: + r = ctrlp_disp(conn, buffer, size); + break; + case PPTP_MESSAGE_MANAGE: + /* MANAGEMENT messages aren't even part of the spec right now. */ + log("PPTP management message received, but not understood."); + break; + default: + log("Unknown PPTP control message type received: %u", + (unsigned int) ntoh16(header->pptp_type)); + break; + } + return r; +} + +/*** log echo request/replies *************************************************/ +static void logecho( int type) +{ + /* hack to stop flooding the log files (the most interesting part is right + * after the connection built-up) */ + if( nlogecho > 0) { + log( "Echo Re%s received.", type == PPTP_ECHO_RQST ? "quest" :"ply"); + if( --nlogecho == 0) + log("no more Echo Reply/Request packets will be reported."); + } +} + +/*** pptp_dispatch_ctrl_packet ************************************************/ +int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) +{ + struct pptp_header *header = (struct pptp_header *)buffer; + u_int8_t close_reason = PPTP_STOP_NONE; + assert(conn && conn->call); assert(buffer); + assert(ntoh32(header->magic) == PPTP_MAGIC); + assert(ntoh16(header->length) == size); + assert(ntoh16(header->pptp_type) == PPTP_MESSAGE_CONTROL); + if (size < PPTP_CTRL_SIZE(ntoh16(header->ctrl_type))) { + log("Invalid packet received [type: %d; length: %d].", + (int) ntoh16(header->ctrl_type), (int) size); + return 0; + } + switch (ntoh16(header->ctrl_type)) { + /* ----------- STANDARD Start-Session MESSAGES ------------ */ + case PPTP_START_CTRL_CONN_RQST: + { + struct pptp_start_ctrl_conn *packet = + (struct pptp_start_ctrl_conn *) buffer; + struct pptp_start_ctrl_conn reply = { + PPTP_HEADER_CTRL(PPTP_START_CTRL_CONN_RPLY), + hton16(PPTP_VERSION), 0, 0, + hton32(PPTP_FRAME_CAP), hton32(PPTP_BEARER_CAP), + hton16(PPTP_MAX_CHANNELS), hton16(PPTP_FIRMWARE_VERSION), + PPTP_HOSTNAME, PPTP_VENDOR }; + int idx, rc; + log("Received Start Control Connection Request"); + /* fix this packet, if necessary */ + idx = get_quirk_index(); + if (idx != -1 && pptp_fixups[idx].start_ctrl_conn) { + if ((rc = pptp_fixups[idx].start_ctrl_conn(&reply))) + warn("calling the start_ctrl_conn hook failed (%d)", rc); + } + if (conn->conn_state == CONN_IDLE) { + if (ntoh16(packet->version) < PPTP_VERSION) { + /* Can't support this (earlier) PPTP_VERSION */ + reply.version = packet->version; + /* protocol version not supported */ + reply.result_code = hton8(5); + pptp_send_ctrl_packet(conn, &reply, sizeof(reply)); + pptp_reset_timer(); /* give sender a chance for a retry */ + } else { /* same or greater version */ + if (pptp_send_ctrl_packet(conn, &reply, sizeof(reply))) { + conn->conn_state = CONN_ESTABLISHED; + log("server connection ESTABLISHED."); + pptp_reset_timer(); + } + } + } + break; + } + case PPTP_START_CTRL_CONN_RPLY: + { + struct pptp_start_ctrl_conn *packet = + (struct pptp_start_ctrl_conn *) buffer; + log("Received Start Control Connection Reply"); + if (conn->conn_state == CONN_WAIT_CTL_REPLY) { + /* XXX handle collision XXX [see rfc] */ + if (ntoh16(packet->version) != PPTP_VERSION) { + if (conn->callback != NULL) + conn->callback(conn, CONN_OPEN_FAIL); + close_reason = PPTP_STOP_PROTOCOL; + goto pptp_conn_close; + } + if (ntoh8(packet->result_code) != 1 && + /* J'ai change le if () afin que la connection ne se ferme + * pas pour un "rien" :p adel@cybercable.fr - + * + * Don't close the connection if the result code is zero + * (feature found in certain ADSL modems) + */ + ntoh8(packet->result_code) != 0) { + log("Negative reply received to our Start Control " + "Connection Request"); + ctrlp_error(packet->result_code, packet->error_code, + -1, pptp_start_ctrl_conn_rply, + MAX_START_CTRL_CONN_REPLY); + if (conn->callback != NULL) + conn->callback(conn, CONN_OPEN_FAIL); + close_reason = PPTP_STOP_PROTOCOL; + goto pptp_conn_close; + } + conn->conn_state = CONN_ESTABLISHED; + /* log session properties */ + conn->version = ntoh16(packet->version); + conn->firmware_rev = ntoh16(packet->firmware_rev); + memcpy(conn->hostname, packet->hostname, sizeof(conn->hostname)); + memcpy(conn->vendor, packet->vendor, sizeof(conn->vendor)); + pptp_reset_timer(); /* 60 seconds until keep-alive */ + log("Client connection established."); + if (conn->callback != NULL) + conn->callback(conn, CONN_OPEN_DONE); + } /* else goto pptp_conn_close; */ + break; + } + /* ----------- STANDARD Stop-Session MESSAGES ------------ */ + case PPTP_STOP_CTRL_CONN_RQST: + { + /* conn_state should be CONN_ESTABLISHED, but it could be + * something else */ + struct pptp_stop_ctrl_conn reply = { + PPTP_HEADER_CTRL(PPTP_STOP_CTRL_CONN_RPLY), + hton8(1), hton8(PPTP_GENERAL_ERROR_NONE), 0 + }; + log("Received Stop Control Connection Request."); + if (conn->conn_state == CONN_IDLE) break; + if (pptp_send_ctrl_packet(conn, &reply, sizeof(reply))) { + if (conn->callback != NULL) + conn->callback(conn, CONN_CLOSE_RQST); + conn->conn_state = CONN_IDLE; + return -1; + } + break; + } + case PPTP_STOP_CTRL_CONN_RPLY: + { + log("Received Stop Control Connection Reply."); + /* conn_state should be CONN_WAIT_STOP_REPLY, but it + * could be something else */ + if (conn->conn_state == CONN_IDLE) break; + conn->conn_state = CONN_IDLE; + return -1; + } + /* ----------- STANDARD Echo/Keepalive MESSAGES ------------ */ + case PPTP_ECHO_RPLY: + { + struct pptp_echo_rply *packet = + (struct pptp_echo_rply *) buffer; + logecho( PPTP_ECHO_RPLY); + if ((conn->ka_state == KA_OUTSTANDING) && + (ntoh32(packet->identifier) == conn->ka_id)) { + conn->ka_id++; + conn->ka_state = KA_NONE; + pptp_reset_timer(); + } + break; + } + case PPTP_ECHO_RQST: + { + struct pptp_echo_rqst *packet = + (struct pptp_echo_rqst *) buffer; + struct pptp_echo_rply reply = { + PPTP_HEADER_CTRL(PPTP_ECHO_RPLY), + packet->identifier, /* skip hton32(ntoh32(id)) */ + hton8(1), hton8(PPTP_GENERAL_ERROR_NONE), 0 + }; + logecho( PPTP_ECHO_RQST); + pptp_send_ctrl_packet(conn, &reply, sizeof(reply)); + pptp_reset_timer(); + break; + } + /* ----------- OUTGOING CALL MESSAGES ------------ */ + case PPTP_OUT_CALL_RQST: + { + struct pptp_out_call_rqst *packet = + (struct pptp_out_call_rqst *)buffer; + struct pptp_out_call_rply reply = { + PPTP_HEADER_CTRL(PPTP_OUT_CALL_RPLY), + 0 /* callid */, packet->call_id, 1, PPTP_GENERAL_ERROR_NONE, 0, + hton32(PPTP_CONNECT_SPEED), + hton16(PPTP_WINDOW), hton16(PPTP_DELAY), 0 + }; + log("Received Outgoing Call Request."); + /* XXX PAC: eventually this should make an outgoing call. XXX */ + reply.result_code = hton8(7); /* outgoing calls verboten */ + pptp_send_ctrl_packet(conn, &reply, sizeof(reply)); + break; + } + case PPTP_OUT_CALL_RPLY: + { + struct pptp_out_call_rply *packet = + (struct pptp_out_call_rply *)buffer; + PPTP_CALL * call; + u_int16_t callid = ntoh16(packet->call_id_peer); + log("Received Outgoing Call Reply."); + if (!vector_search(conn->call, (int) callid, &call)) { + log("PPTP_OUT_CALL_RPLY received for non-existant call: " + "peer call ID (us) %d call ID (them) %d.", + callid, ntoh16(packet->call_id)); + break; + } + if (call->call_type != PPTP_CALL_PNS) { + log("Ack! How did this call_type get here?"); /* XXX? */ + break; + } + if (call->state.pns != PNS_WAIT_REPLY) { + warn("Unexpected(?) Outgoing Call Reply will be ignored."); + break; + } + /* check for errors */ + if (packet->result_code != 1) { + /* An error. Log it verbosely. */ + log("Our outgoing call request [callid %d] has not been " + "accepted.", (int) callid); + ctrlp_error(packet->result_code, packet->error_code, + packet->cause_code, pptp_out_call_reply_result, + MAX_OUT_CALL_REPLY_RESULT); + call->state.pns = PNS_IDLE; + if (call->callback != NULL) + call->callback(conn, call, CALL_OPEN_FAIL); + pptp_call_destroy(conn, call); + } else { + /* connection established */ + call->state.pns = PNS_ESTABLISHED; + call->peer_call_id = ntoh16(packet->call_id); + call->speed = ntoh32(packet->speed); + pptp_reset_timer(); + /* call pptp_set_link. unless the user specified a quirk + and this quirk has a set_link hook, this is a noop */ + pptp_set_link(conn, call->peer_call_id); + if (call->callback != NULL) + call->callback(conn, call, CALL_OPEN_DONE); + log("Outgoing call established (call ID %u, peer's " + "call ID %u).\n", call->call_id, call->peer_call_id); + } + break; + } + /* ----------- INCOMING CALL MESSAGES ------------ */ + /* XXX write me XXX */ + /* ----------- CALL CONTROL MESSAGES ------------ */ + case PPTP_CALL_CLEAR_RQST: + { + struct pptp_call_clear_rqst *packet = + (struct pptp_call_clear_rqst *)buffer; + struct pptp_call_clear_ntfy reply = { + PPTP_HEADER_CTRL(PPTP_CALL_CLEAR_NTFY), packet->call_id, + 1, PPTP_GENERAL_ERROR_NONE, 0, 0, {0} + }; + log("Received Call Clear Request."); + if (vector_contains(conn->call, ntoh16(packet->call_id))) { + PPTP_CALL * call; + vector_search(conn->call, ntoh16(packet->call_id), &call); + if (call->callback != NULL) + call->callback(conn, call, CALL_CLOSE_RQST); + pptp_send_ctrl_packet(conn, &reply, sizeof(reply)); + pptp_call_destroy(conn, call); + log("Call closed (RQST) (call id %d)", (int) call->call_id); + } + break; + } + case PPTP_CALL_CLEAR_NTFY: + { + struct pptp_call_clear_ntfy *packet = + (struct pptp_call_clear_ntfy *)buffer; + log("Call disconnect notification received (call id %d)", + ntoh16(packet->call_id)); + if (vector_contains(conn->call, ntoh16(packet->call_id))) { + PPTP_CALL * call; + ctrlp_error(packet->result_code, packet->error_code, + packet->cause_code, pptp_call_disc_ntfy, + MAX_CALL_DISC_NTFY); + vector_search(conn->call, ntoh16(packet->call_id), &call); + pptp_call_destroy(conn, call); + } + /* XXX we could log call stats here XXX */ + /* XXX not all servers send this XXX */ + break; + } + case PPTP_SET_LINK_INFO: + { + /* I HAVE NO CLUE WHAT TO DO IF send_accm IS NOT 0! */ + /* this is really dealt with in the HDLC deencapsulation, anyway. */ + struct pptp_set_link_info *packet = + (struct pptp_set_link_info *)buffer; + /* log it. */ + log("PPTP_SET_LINK_INFO received from peer_callid %u", + (unsigned int) ntoh16(packet->call_id_peer)); + log(" send_accm is %08lX, recv_accm is %08lX", + (unsigned long) ntoh32(packet->send_accm), + (unsigned long) ntoh32(packet->recv_accm)); + if (!(ntoh32(packet->send_accm) == 0 && + ntoh32(packet->recv_accm) == 0)) + warn("Non-zero Async Control Character Maps are not supported!"); + break; + } + default: + log("Unrecognized Packet %d received.", + (int) ntoh16(((struct pptp_header *)buffer)->ctrl_type)); + /* goto pptp_conn_close; */ + break; + } + return 0; +pptp_conn_close: + warn("pptp_conn_close(%d)", (int) close_reason); + pptp_conn_close(conn, close_reason); + return 0; +} + +/*** pptp_set_link **************************************************************/ +void pptp_set_link(PPTP_CONN* conn, int peer_call_id) +{ + int idx, rc; + /* if we need to send a set_link packet because of buggy + hardware or pptp server, do it now */ + if ((idx = get_quirk_index()) != -1 && pptp_fixups[idx].set_link_hook) { + struct pptp_set_link_info packet; + if ((rc = pptp_fixups[idx].set_link_hook(&packet, peer_call_id))) + warn("calling the set_link hook failed (%d)", rc); + if (pptp_send_ctrl_packet(conn, &packet, sizeof(packet))) { + pptp_reset_timer(); + } + } +} + +/*** Get info from call structure *********************************************/ +/* NOTE: The peer_call_id is undefined until we get a server response. */ +void pptp_call_get_ids(PPTP_CONN * conn, PPTP_CALL * call, + u_int16_t * call_id, u_int16_t * peer_call_id) +{ + assert(conn != NULL); assert(call != NULL); + *call_id = call->call_id; + *peer_call_id = call->peer_call_id; +} + +/*** pptp_call_closure_put ****************************************************/ +void pptp_call_closure_put(PPTP_CONN * conn, PPTP_CALL * call, void *cl) +{ + assert(conn != NULL); assert(call != NULL); + call->closure = cl; +} + +/*** pptp_call_closure_get ****************************************************/ +void * pptp_call_closure_get(PPTP_CONN * conn, PPTP_CALL * call) +{ + assert(conn != NULL); assert(call != NULL); + return call->closure; +} + +/*** pptp_conn_closure_put ****************************************************/ +void pptp_conn_closure_put(PPTP_CONN * conn, void *cl) +{ + assert(conn != NULL); + conn->closure = cl; +} + +/*** pptp_conn_closure_get ****************************************************/ +void * pptp_conn_closure_get(PPTP_CONN * conn) +{ + assert(conn != NULL); + return conn->closure; +} + +/*** Reset keep-alive timer ***************************************************/ +static void pptp_reset_timer(void) +{ + const struct itimerval tv = { { 0, 0 }, /* stop on time-out */ + { idle_wait, 0 } }; + if (idle_wait) setitimer(ITIMER_REAL, &tv, NULL); +} + + +/*** Handle keep-alive timer **************************************************/ +static void pptp_handle_timer() +{ + int i; + /* "Keep Alives and Timers, 1": check connection state */ + if (global.conn->conn_state != CONN_ESTABLISHED) { + if (global.conn->conn_state == CONN_WAIT_STOP_REPLY) + /* hard close. */ + pptp_conn_destroy(global.conn); + else /* soft close */ + pptp_conn_close(global.conn, PPTP_STOP_NONE); + } + /* "Keep Alives and Timers, 2": check echo status */ + if (global.conn->ka_state == KA_OUTSTANDING) { + /* no response to keep-alive */ + log ("closing control connection due to missing echo reply"); + pptp_conn_close(global.conn, PPTP_STOP_NONE); + } else { /* ka_state == NONE */ /* send keep-alive */ + struct pptp_echo_rqst rqst = { + PPTP_HEADER_CTRL(PPTP_ECHO_RQST), hton32(global.conn->ka_id) }; + pptp_send_ctrl_packet(global.conn, &rqst, sizeof(rqst)); + global.conn->ka_state = KA_OUTSTANDING; + } + /* check incoming/outgoing call states for !IDLE && !ESTABLISHED */ + for (i = 0; i < vector_size(global.conn->call); i++) { + PPTP_CALL * call = vector_get_Nth(global.conn->call, i); + if (call->call_type == PPTP_CALL_PNS) { + if (call->state.pns == PNS_WAIT_REPLY) { + /* send close request */ + pptp_call_close(global.conn, call); + assert(call->state.pns == PNS_WAIT_DISCONNECT); + } else if (call->state.pns == PNS_WAIT_DISCONNECT) { + /* hard-close the call */ + pptp_call_destroy(global.conn, call); + } + } else if (call->call_type == PPTP_CALL_PAC) { + if (call->state.pac == PAC_WAIT_REPLY) { + /* XXX FIXME -- drop the PAC connection XXX */ + } else if (call->state.pac == PAC_WAIT_CS_ANS) { + /* XXX FIXME -- drop the PAC connection XXX */ + } + } + } + pptp_reset_timer(); +} diff --git a/pppd/plugins/pptp/pptp_ctrl.h b/pppd/plugins/pptp/pptp_ctrl.h new file mode 100644 index 000000000..a7bb5067d --- /dev/null +++ b/pppd/plugins/pptp/pptp_ctrl.h @@ -0,0 +1,57 @@ +/* pptp_ctrl.h ... handle PPTP control connection. + * C. Scott Ananian + * + * $Id: pptp_ctrl.h,v 1.5 2004/11/09 01:42:32 quozl Exp $ + */ + +#ifndef INC_PPTP_CTRL_H +#define INC_PPTP_CTRL_H +#include + +typedef struct PPTP_CONN PPTP_CONN; +typedef struct PPTP_CALL PPTP_CALL; + +enum call_state { CALL_OPEN_RQST, CALL_OPEN_DONE, CALL_OPEN_FAIL, + CALL_CLOSE_RQST, CALL_CLOSE_DONE }; +enum conn_state { CONN_OPEN_RQST, CONN_OPEN_DONE, CONN_OPEN_FAIL, + CONN_CLOSE_RQST, CONN_CLOSE_DONE }; + +typedef void (*pptp_call_cb)(PPTP_CONN*, PPTP_CALL*, enum call_state); +typedef void (*pptp_conn_cb)(PPTP_CONN*, enum conn_state); + +/* if 'isclient' is true, then will send 'conn open' packet to other host. + * not necessary if this is being opened by a server process after + * receiving a conn_open packet from client. + */ +PPTP_CONN * pptp_conn_open(int inet_sock, int isclient, + pptp_conn_cb callback); +PPTP_CALL * pptp_call_open(PPTP_CONN * conn, int call_id, + pptp_call_cb callback, char *phonenr,int window); +int pptp_conn_established(PPTP_CONN * conn); +/* soft close. Will callback on completion. */ +void pptp_call_close(PPTP_CONN * conn, PPTP_CALL * call); +/* hard close. */ +void pptp_call_destroy(PPTP_CONN *conn, PPTP_CALL *call); +/* soft close. Will callback on completion. */ +void pptp_conn_close(PPTP_CONN * conn, u_int8_t close_reason); +/* hard close */ +void pptp_conn_destroy(PPTP_CONN * conn); + +/* Add file descriptors used by pptp to fd_set. */ +void pptp_fd_set(PPTP_CONN * conn, fd_set * read_set, fd_set * write_set, int *max_fd); +/* handle any pptp file descriptors set in fd_set, and clear them */ +int pptp_dispatch(PPTP_CONN * conn, fd_set * read_set, fd_set * write_set); + +/* Get info about connection, call */ +void pptp_call_get_ids(PPTP_CONN * conn, PPTP_CALL * call, + u_int16_t * call_id, u_int16_t * peer_call_id); +/* Arbitrary user data about this call/connection. + * It is the caller's responsibility to free this data before calling + * pptp_call|conn_close() + */ +void * pptp_conn_closure_get(PPTP_CONN * conn); +void pptp_conn_closure_put(PPTP_CONN * conn, void *cl); +void * pptp_call_closure_get(PPTP_CONN * conn, PPTP_CALL * call); +void pptp_call_closure_put(PPTP_CONN * conn, PPTP_CALL * call, void *cl); + +#endif /* INC_PPTP_CTRL_H */ diff --git a/pppd/plugins/pptp/pptp_msg.h b/pppd/plugins/pptp/pptp_msg.h new file mode 100644 index 000000000..e50ce0cda --- /dev/null +++ b/pppd/plugins/pptp/pptp_msg.h @@ -0,0 +1,303 @@ +/* pptp.h: packet structures and magic constants for the PPTP protocol + * C. Scott Ananian + * + * $Id: pptp_msg.h,v 1.3 2003/02/15 10:37:21 quozl Exp $ + */ + +#ifndef INC_PPTP_H +#define INC_PPTP_H + +/* Grab definitions of int16, int32, etc. */ +#include +/* define "portable" htons, etc. */ +#define hton8(x) (x) +#define ntoh8(x) (x) +#define hton16(x) htons(x) +#define ntoh16(x) ntohs(x) +#define hton32(x) htonl(x) +#define ntoh32(x) ntohl(x) + +/* PPTP magic numbers: ----------------------------------------- */ + +#define PPTP_MAGIC 0x1A2B3C4D /* Magic cookie for PPTP datagrams */ +#define PPTP_PORT 1723 /* PPTP TCP port number */ +#define PPTP_PROTO 47 /* PPTP IP protocol number */ + +/* Control Connection Message Types: --------------------------- */ + +#define PPTP_MESSAGE_CONTROL 1 +#define PPTP_MESSAGE_MANAGE 2 + +/* Control Message Types: -------------------------------------- */ + +/* (Control Connection Management) */ +#define PPTP_START_CTRL_CONN_RQST 1 +#define PPTP_START_CTRL_CONN_RPLY 2 +#define PPTP_STOP_CTRL_CONN_RQST 3 +#define PPTP_STOP_CTRL_CONN_RPLY 4 +#define PPTP_ECHO_RQST 5 +#define PPTP_ECHO_RPLY 6 + +/* (Call Management) */ +#define PPTP_OUT_CALL_RQST 7 +#define PPTP_OUT_CALL_RPLY 8 +#define PPTP_IN_CALL_RQST 9 +#define PPTP_IN_CALL_RPLY 10 +#define PPTP_IN_CALL_CONNECT 11 +#define PPTP_CALL_CLEAR_RQST 12 +#define PPTP_CALL_CLEAR_NTFY 13 + +/* (Error Reporting) */ +#define PPTP_WAN_ERR_NTFY 14 + +/* (PPP Session Control) */ +#define PPTP_SET_LINK_INFO 15 + +/* PPTP version information: --------------------------------------*/ +#define PPTP_VERSION_STRING "1.00" +#define PPTP_VERSION 0x100 +#define PPTP_FIRMWARE_STRING "0.01" +#define PPTP_FIRMWARE_VERSION 0x001 + +/* PPTP capabilities: ---------------------------------------------*/ + +/* (Framing capabilities for msg sender) */ +#define PPTP_FRAME_ASYNC 1 +#define PPTP_FRAME_SYNC 2 +#define PPTP_FRAME_ANY 3 + +/* (Bearer capabilities for msg sender) */ +#define PPTP_BEARER_ANALOG 1 +#define PPTP_BEARER_DIGITAL 2 +#define PPTP_BEARER_ANY 3 + +#define PPTP_RESULT_GENERAL_ERROR 2 + +/* (Reasons to close a connection) */ +#define PPTP_STOP_NONE 1 /* no good reason */ +#define PPTP_STOP_PROTOCOL 2 /* can't support peer's protocol version */ +#define PPTP_STOP_LOCAL_SHUTDOWN 3 /* requester is being shut down */ + +/* PPTP datagram structures (all data in network byte order): ----------*/ + +struct pptp_header { + u_int16_t length; /* message length in octets, including header */ + u_int16_t pptp_type; /* PPTP message type. 1 for control message. */ + u_int32_t magic; /* this should be PPTP_MAGIC. */ + u_int16_t ctrl_type; /* Control message type (0-15) */ + u_int16_t reserved0; /* reserved. MUST BE ZERO. */ +}; + +struct pptp_start_ctrl_conn { /* for control message types 1 and 2 */ + struct pptp_header header; + + u_int16_t version; /* PPTP protocol version. = PPTP_VERSION */ + u_int8_t result_code; /* these two fields should be zero on rqst msg*/ + u_int8_t error_code; /* 0 unless result_code==2 (General Error) */ + u_int32_t framing_cap; /* Framing capabilities */ + u_int32_t bearer_cap; /* Bearer Capabilities */ + u_int16_t max_channels; /* Maximum Channels (=0 for PNS, PAC ignores) */ + u_int16_t firmware_rev; /* Firmware or Software Revision */ + u_int8_t hostname[64]; /* Host Name (64 octets, zero terminated) */ + u_int8_t vendor[64]; /* Vendor string (64 octets, zero term.) */ + /* MS says that end of hostname/vendor fields should be filled with */ + /* octets of value 0, but Win95 PPTP driver doesn't do this. */ +}; + +struct pptp_stop_ctrl_conn { /* for control message types 3 and 4 */ + struct pptp_header header; + + u_int8_t reason_result; /* reason for rqst, result for rply */ + u_int8_t error_code; /* MUST be 0, unless rply result==2 (general err)*/ + u_int16_t reserved1; /* MUST be 0 */ +}; + +struct pptp_echo_rqst { /* for control message type 5 */ + struct pptp_header header; + u_int32_t identifier; /* arbitrary value set by sender which is used */ + /* to match up reply and request */ +}; + +struct pptp_echo_rply { /* for control message type 6 */ + struct pptp_header header; + u_int32_t identifier; /* should correspond to id of rqst */ + u_int8_t result_code; + u_int8_t error_code; /* =0, unless result_code==2 (general error) */ + u_int16_t reserved1; /* MUST BE ZERO */ +}; + +struct pptp_out_call_rqst { /* for control message type 7 */ + struct pptp_header header; + u_int16_t call_id; /* Call ID (unique id used to multiplex data) */ + u_int16_t call_sernum; /* Call Serial Number (used for logging) */ + u_int32_t bps_min; /* Minimum BPS (lowest acceptable line speed) */ + u_int32_t bps_max; /* Maximum BPS (highest acceptable line speed) */ + u_int32_t bearer; /* Bearer type */ + u_int32_t framing; /* Framing type */ + u_int16_t recv_size; /* Recv. Window Size (no. of buffered packets) */ + u_int16_t delay; /* Packet Processing Delay (in 1/10 sec) */ + u_int16_t phone_len; /* Phone Number Length (num. of valid digits) */ + u_int16_t reserved1; /* MUST BE ZERO */ + u_int8_t phone_num[64]; /* Phone Number (64 octets, null term.) */ + u_int8_t subaddress[64]; /* Subaddress (64 octets, null term.) */ +}; + +struct pptp_out_call_rply { /* for control message type 8 */ + struct pptp_header header; + u_int16_t call_id; /* Call ID (used to multiplex data over tunnel)*/ + u_int16_t call_id_peer; /* Peer's Call ID (call_id of pptp_out_call_rqst)*/ + u_int8_t result_code; /* Result Code (1 is no errors) */ + u_int8_t error_code; /* Error Code (=0 unless result_code==2) */ + u_int16_t cause_code; /* Cause Code (addt'l failure information) */ + u_int32_t speed; /* Connect Speed (in BPS) */ + u_int16_t recv_size; /* Recv. Window Size (no. of buffered packets) */ + u_int16_t delay; /* Packet Processing Delay (in 1/10 sec) */ + u_int32_t channel; /* Physical Channel ID (for logging) */ +}; + +struct pptp_in_call_rqst { /* for control message type 9 */ + struct pptp_header header; + u_int16_t call_id; /* Call ID (unique id used to multiplex data) */ + u_int16_t call_sernum; /* Call Serial Number (used for logging) */ + u_int32_t bearer; /* Bearer type */ + u_int32_t channel; /* Physical Channel ID (for logging) */ + u_int16_t dialed_len; /* Dialed Number Length (# of valid digits) */ + u_int16_t dialing_len; /* Dialing Number Length (# of valid digits) */ + u_int8_t dialed_num[64]; /* Dialed Number (64 octets, zero term.) */ + u_int8_t dialing_num[64]; /* Dialing Number (64 octets, zero term.) */ + u_int8_t subaddress[64]; /* Subaddress (64 octets, zero term.) */ +}; + +struct pptp_in_call_rply { /* for control message type 10 */ + struct pptp_header header; + u_int16_t call_id; /* Call ID (used to multiplex data over tunnel)*/ + u_int16_t call_id_peer; /* Peer's Call ID (call_id of pptp_out_call_rqst)*/ + u_int8_t result_code; /* Result Code (1 is no errors) */ + u_int8_t error_code; /* Error Code (=0 unless result_code==2) */ + u_int16_t recv_size; /* Recv. Window Size (no. of buffered packets) */ + u_int16_t delay; /* Packet Processing Delay (in 1/10 sec) */ + u_int16_t reserved1; /* MUST BE ZERO */ +}; + +struct pptp_in_call_connect { /* for control message type 11 */ + struct pptp_header header; + u_int16_t call_id_peer; /* Peer's Call ID (call_id of pptp_out_call_rqst)*/ + u_int16_t reserved1; /* MUST BE ZERO */ + u_int32_t speed; /* Connect Speed (in BPS) */ + u_int16_t recv_size; /* Recv. Window Size (no. of buffered packets) */ + u_int16_t delay; /* Packet Processing Delay (in 1/10 sec) */ + u_int32_t framing; /* Framing type */ +}; + +struct pptp_call_clear_rqst { /* for control message type 12 */ + struct pptp_header header; + u_int16_t call_id; /* Call ID (used to multiplex data over tunnel)*/ + u_int16_t reserved1; /* MUST BE ZERO */ +}; + +struct pptp_call_clear_ntfy { /* for control message type 13 */ + struct pptp_header header; + u_int16_t call_id; /* Call ID (used to multiplex data over tunnel)*/ + u_int8_t result_code; /* Result Code */ + u_int8_t error_code; /* Error Code (=0 unless result_code==2) */ + u_int16_t cause_code; /* Cause Code (for ISDN, is Q.931 cause code) */ + u_int16_t reserved1; /* MUST BE ZERO */ + u_int8_t call_stats[128]; /* Call Statistics: 128 octets, ascii, 0-term */ +}; + +struct pptp_wan_err_ntfy { /* for control message type 14 */ + struct pptp_header header; + u_int16_t call_id_peer; /* Peer's Call ID (call_id of pptp_out_call_rqst)*/ + u_int16_t reserved1; /* MUST BE ZERO */ + u_int32_t crc_errors; /* CRC errors */ + u_int32_t frame_errors; /* Framing errors */ + u_int32_t hard_errors; /* Hardware overruns */ + u_int32_t buff_errors; /* Buffer overruns */ + u_int32_t time_errors; /* Time-out errors */ + u_int32_t align_errors; /* Alignment errors */ +}; + +struct pptp_set_link_info { /* for control message type 15 */ + struct pptp_header header; + u_int16_t call_id_peer; /* Peer's Call ID (call_id of pptp_out_call_rqst) */ + u_int16_t reserved1; /* MUST BE ZERO */ + u_int32_t send_accm; /* Send ACCM (for PPP packets; default 0xFFFFFFFF)*/ + u_int32_t recv_accm; /* Receive ACCM (for PPP pack.;default 0xFFFFFFFF)*/ +}; + +/* helpful #defines: -------------------------------------------- */ +#define pptp_isvalid_ctrl(header, type, length) \ + (!( ( ntoh16(((struct pptp_header *)header)->length) < (length) ) || \ + ( ntoh16(((struct pptp_header *)header)->pptp_type) !=(type) ) || \ + ( ntoh32(((struct pptp_header *)header)->magic) !=PPTP_MAGIC) || \ + ( ntoh16(((struct pptp_header *)header)->ctrl_type) > PPTP_SET_LINK_INFO) || \ + ( ntoh16(((struct pptp_header *)header)->reserved0) !=0 ) )) + +#define PPTP_HEADER_CTRL(type) \ +{ hton16(PPTP_CTRL_SIZE(type)), \ + hton16(PPTP_MESSAGE_CONTROL), \ + hton32(PPTP_MAGIC), \ + hton16(type), 0 } + +#define PPTP_CTRL_SIZE(type) ( \ +(type==PPTP_START_CTRL_CONN_RQST)?sizeof(struct pptp_start_ctrl_conn): \ +(type==PPTP_START_CTRL_CONN_RPLY)?sizeof(struct pptp_start_ctrl_conn): \ +(type==PPTP_STOP_CTRL_CONN_RQST )?sizeof(struct pptp_stop_ctrl_conn): \ +(type==PPTP_STOP_CTRL_CONN_RPLY )?sizeof(struct pptp_stop_ctrl_conn): \ +(type==PPTP_ECHO_RQST )?sizeof(struct pptp_echo_rqst): \ +(type==PPTP_ECHO_RPLY )?sizeof(struct pptp_echo_rply): \ +(type==PPTP_OUT_CALL_RQST )?sizeof(struct pptp_out_call_rqst): \ +(type==PPTP_OUT_CALL_RPLY )?sizeof(struct pptp_out_call_rply): \ +(type==PPTP_IN_CALL_RQST )?sizeof(struct pptp_in_call_rqst): \ +(type==PPTP_IN_CALL_RPLY )?sizeof(struct pptp_in_call_rply): \ +(type==PPTP_IN_CALL_CONNECT )?sizeof(struct pptp_in_call_connect): \ +(type==PPTP_CALL_CLEAR_RQST )?sizeof(struct pptp_call_clear_rqst): \ +(type==PPTP_CALL_CLEAR_NTFY )?sizeof(struct pptp_call_clear_ntfy): \ +(type==PPTP_WAN_ERR_NTFY )?sizeof(struct pptp_wan_err_ntfy): \ +(type==PPTP_SET_LINK_INFO )?sizeof(struct pptp_set_link_info): \ +0) +#define max(a,b) (((a)>(b))?(a):(b)) +#define PPTP_CTRL_SIZE_MAX ( \ +max(sizeof(struct pptp_start_ctrl_conn), \ +max(sizeof(struct pptp_echo_rqst), \ +max(sizeof(struct pptp_echo_rply), \ +max(sizeof(struct pptp_out_call_rqst), \ +max(sizeof(struct pptp_out_call_rply), \ +max(sizeof(struct pptp_in_call_rqst), \ +max(sizeof(struct pptp_in_call_rply), \ +max(sizeof(struct pptp_in_call_connect), \ +max(sizeof(struct pptp_call_clear_rqst), \ +max(sizeof(struct pptp_call_clear_ntfy), \ +max(sizeof(struct pptp_wan_err_ntfy), \ +max(sizeof(struct pptp_set_link_info), 0))))))))))))) + + +/* gre header structure: -------------------------------------------- */ + +#define PPTP_GRE_PROTO 0x880B +#define PPTP_GRE_VER 0x1 + +#define PPTP_GRE_FLAG_C 0x80 +#define PPTP_GRE_FLAG_R 0x40 +#define PPTP_GRE_FLAG_K 0x20 +#define PPTP_GRE_FLAG_S 0x10 +#define PPTP_GRE_FLAG_A 0x80 + +#define PPTP_GRE_IS_C(f) ((f)&PPTP_GRE_FLAG_C) +#define PPTP_GRE_IS_R(f) ((f)&PPTP_GRE_FLAG_R) +#define PPTP_GRE_IS_K(f) ((f)&PPTP_GRE_FLAG_K) +#define PPTP_GRE_IS_S(f) ((f)&PPTP_GRE_FLAG_S) +#define PPTP_GRE_IS_A(f) ((f)&PPTP_GRE_FLAG_A) + +struct pptp_gre_header { + u_int8_t flags; /* bitfield */ + u_int8_t ver; /* should be PPTP_GRE_VER (enhanced GRE) */ + u_int16_t protocol; /* should be PPTP_GRE_PROTO (ppp-encaps) */ + u_int16_t payload_len; /* size of ppp payload, not inc. gre header */ + u_int16_t call_id; /* peer's call_id for this session */ + u_int32_t seq; /* sequence number. Present if S==1 */ + u_int32_t ack; /* seq number of highest packet recieved by */ + /* sender in this session */ +}; + +#endif /* INC_PPTP_H */ diff --git a/pppd/plugins/pptp/pptp_options.h b/pppd/plugins/pptp/pptp_options.h new file mode 100644 index 000000000..ebc1c316e --- /dev/null +++ b/pppd/plugins/pptp/pptp_options.h @@ -0,0 +1,41 @@ +/* pptp_options.h ...... various constants used in the PPTP protocol. + * #define STANDARD to emulate NT 4.0 exactly. + * C. Scott Ananian + * + * $Id: pptp_options.h,v 1.3 2004/11/09 01:42:32 quozl Exp $ + */ + +#ifndef INC_PPTP_OPTIONS_H +#define INC_PPTP_OPTIONS_H + +#undef PPTP_FIRMWARE_STRING +#undef PPTP_FIRMWARE_VERSION +#define PPTP_BUF_MAX 65536 +#define PPTP_TIMEOUT 60 /* seconds */ +extern int idle_wait; +extern int max_echo_wait; +#define PPTP_CONNECT_SPEED 1000000000 +#define PPTP_WINDOW 3 +#define PPTP_DELAY 0 +#define PPTP_BPS_MIN 2400 +#define PPTP_BPS_MAX 1000000000 + +#ifndef STANDARD +#define PPTP_MAX_CHANNELS 65535 +#define PPTP_FIRMWARE_STRING "0.01" +#define PPTP_FIRMWARE_VERSION 0x001 +#define PPTP_HOSTNAME {'l','o','c','a','l',0} +#define PPTP_VENDOR {'c','a','n','a','n','i','a','n',0} +#define PPTP_FRAME_CAP PPTP_FRAME_ANY +#define PPTP_BEARER_CAP PPTP_BEARER_ANY +#else +#define PPTP_MAX_CHANNELS 5 +#define PPTP_FIRMWARE_STRING "0.01" +#define PPTP_FIRMWARE_VERSION 0 +#define PPTP_HOSTNAME {'l','o','c','a','l',0} +#define PPTP_VENDOR {'N','T',0} +#define PPTP_FRAME_CAP 2 +#define PPTP_BEARER_CAP 1 +#endif + +#endif /* INC_PPTP_OPTIONS_H */ diff --git a/pppd/plugins/pptp/pptp_quirks.c b/pppd/plugins/pptp/pptp_quirks.c new file mode 100644 index 000000000..e4c90139b --- /dev/null +++ b/pppd/plugins/pptp/pptp_quirks.c @@ -0,0 +1,54 @@ +/* pptp_quirks.c ...... various options to fix quirks found in buggy adsl modems + * mulix + * + * $Id: pptp_quirks.c,v 1.2 2001/11/23 03:42:51 quozl Exp $ + */ + +#include +#include "orckit_quirks.h" +#include "pptp_quirks.h" + +static int quirk_index = -1; + +struct pptp_fixup pptp_fixups[] = { + {BEZEQ_ISRAEL, ORCKIT, ORCKIT_ATUR3, + orckit_atur3_build_hook, + orckit_atur3_start_ctrl_conn_hook, + orckit_atur3_set_link_hook} +}; + +static int fixups_sz = sizeof(pptp_fixups)/sizeof(pptp_fixups[0]); + +/* return 0 on success, non 0 otherwise */ +int set_quirk_index(int index) +{ + if (index >= 0 && index < fixups_sz) { + quirk_index = index; + return 0; + } + + return -1; +} + +int get_quirk_index() +{ + return quirk_index; +} + +/* return the index for this isp in the quirks table, -1 if not found */ +int find_quirk(const char* isp_name) +{ + int i = 0; + if (isp_name) { + while (i < fixups_sz && pptp_fixups[i].isp) { + if (!strcmp(pptp_fixups[i].isp, isp_name)) { + return i; + } + ++i; + } + } + + return -1; +} + + diff --git a/pppd/plugins/pptp/pptp_quirks.h b/pppd/plugins/pptp/pptp_quirks.h new file mode 100644 index 000000000..291f3d6df --- /dev/null +++ b/pppd/plugins/pptp/pptp_quirks.h @@ -0,0 +1,59 @@ +/* pptp_quirks.h ...... various options to fix quirks found in buggy adsl modems + * mulix + * + * $Id: pptp_quirks.h,v 1.1 2001/11/20 06:30:10 quozl Exp $ + */ + +#ifndef INC_PPTP_QUIRKS_H +#define INC_PPTP_QUIRKS_H + +/* isp defs - correspond to slots in the fixups table */ +#define BEZEQ_ISRAEL "BEZEQ_ISRAEL" + +/* vendor defs */ + +#define ORCKIT 1 +#define ALCATEL 2 + +/* device defs */ + +#define ORCKIT_ATUR2 1 +#define ORCKIT_ATUR3 2 + +#include "pptp_msg.h" +#include "pptp_ctrl.h" + +struct pptp_fixup { + const char* isp; /* which isp? e.g. Bezeq in Israel */ + int vendor; /* which vendor? e.g. Orckit */ + int device; /* which device? e.g. Orckit Atur3 */ + + /* use this hook to build your own out call request packet */ + int (*out_call_rqst_hook)(struct pptp_out_call_rqst* packet); + + /* use this hook to build your own start control connection packet */ + /* note that this hook is called from two different places, depending + on whether this is a request or reply */ + int (*start_ctrl_conn)(struct pptp_start_ctrl_conn* packet); + + /* use this hook if you need to send a 'set_link' packet once + the connection is established */ + int (*set_link_hook)(struct pptp_set_link_info* packet, + int peer_call_id); +}; + +extern struct pptp_fixup pptp_fixups[]; + +/* find the index for this isp in the quirks table */ +/* return the index on success, -1 if not found */ +int find_quirk(const char* isp_name); + +/* set the global quirk index. return 0 on success, non 0 otherwise */ +int set_quirk_index(int index); + +/* get the global quirk index. return the index on success, + -1 if no quirk is defined */ +int get_quirk_index(); + + +#endif /* INC_PPTP_QUIRKS_H */ diff --git a/pppd/plugins/pptp/util.c b/pppd/plugins/pptp/util.c new file mode 100644 index 000000000..dabddbec6 --- /dev/null +++ b/pppd/plugins/pptp/util.c @@ -0,0 +1,158 @@ +/* util.c ....... error message utilities. + * C. Scott Ananian + * + * $Id: util.c,v 1.11 2005/08/22 00:49:48 quozl Exp $ + */ + +#include +#include +#include +#include +#include +#include "util.h" + +#ifndef PROGRAM_NAME +#define PROGRAM_NAME "pptp" +#endif + +/* implementation of log_string, defined as extern in util.h */ +char *log_string = "anon"; + +static void open_log(void) __attribute__ ((constructor)); +static void close_log(void) __attribute__ ((destructor)); + +#define MAKE_STRING(label) \ +va_list ap; \ +char buf[256], string[256]; \ +va_start(ap, format); \ +vsnprintf(buf, sizeof(buf), format, ap); \ +snprintf(string, sizeof(string), "%s %s[%s:%s:%d]: %s", \ + log_string, label, func, file, line, buf); \ +va_end(ap) + +/*** open log *****************************************************************/ +static void open_log(void) { + openlog(PROGRAM_NAME, LOG_PID, LOG_DAEMON); +} + +/*** close log ****************************************************************/ +static void close_log(void) +{ + closelog(); +} + +/*** print a message to syslog ************************************************/ +void _log(const char *func, const char *file, int line, const char *format, ...) +{ + MAKE_STRING("log"); + open_log(); + syslog(LOG_NOTICE, "%s", string); + close_log(); +} + +/*** print a warning to syslog ************************************************/ +void _warn(const char *func, const char *file, int line, const char *format, ...) +{ + MAKE_STRING("warn"); + open_log(); + fprintf(stderr, "%s\n", string); + syslog(LOG_WARNING, "%s", string); + close_log(); +} + +/*** print a fatal warning to syslog and exit *********************************/ +void _fatal(const char *func, const char *file, int line, const char *format, ...) +{ + MAKE_STRING("fatal"); + fprintf(stderr, "%s\n", string); + syslog(LOG_CRIT, "%s", string); + exit(1); +} + +/*** connect a file to a file descriptor **************************************/ +int file2fd(const char *path, const char *mode, int fd) +{ + int ok = 0; + FILE *file = NULL; + file = fopen(path, mode); + if (file != NULL && dup2(fileno(file), fd) != -1) + ok = 1; + if (file) fclose(file); + return ok; +} + +/* signal to pipe delivery implementation */ +#include +#include +#include +#include + +/* pipe private to process */ +static int sigpipe[2]; + +/* create a signal pipe, returns 0 for success, -1 with errno for failure */ +int sigpipe_create() +{ + int rc; + + rc = pipe(sigpipe); + if (rc < 0) return rc; + + fcntl(sigpipe[0], F_SETFD, FD_CLOEXEC); + fcntl(sigpipe[1], F_SETFD, FD_CLOEXEC); + +#ifdef O_NONBLOCK +#define FLAG_TO_SET O_NONBLOCK +#else +#ifdef SYSV +#define FLAG_TO_SET O_NDELAY +#else /* BSD */ +#define FLAG_TO_SET FNDELAY +#endif +#endif + + rc = fcntl(sigpipe[1], F_GETFL); + if (rc != -1) + rc = fcntl(sigpipe[1], F_SETFL, rc | FLAG_TO_SET); + if (rc < 0) return rc; + return 0; +#undef FLAG_TO_SET +} + +/* generic handler for signals, writes signal number to pipe */ +void sigpipe_handler(int signum) +{ + write(sigpipe[1], &signum, sizeof(signum)); + signal(signum, sigpipe_handler); +} + +/* assign a signal number to the pipe */ +void sigpipe_assign(int signum) +{ + struct sigaction sa; + + memset(&sa, 0, sizeof(sa)); + sa.sa_handler = sigpipe_handler; + sigaction(signum, &sa, NULL); +} + +/* return the signal pipe read file descriptor for select(2) */ +int sigpipe_fd() +{ + return sigpipe[0]; +} + +/* read and return the pending signal from the pipe */ +int sigpipe_read() +{ + int signum; + read(sigpipe[0], &signum, sizeof(signum)); + return signum; +} + +void sigpipe_close() +{ + close(sigpipe[0]); + close(sigpipe[1]); +} + diff --git a/pppd/plugins/pptp/util.h b/pppd/plugins/pptp/util.h new file mode 100644 index 000000000..1ed5079f8 --- /dev/null +++ b/pppd/plugins/pptp/util.h @@ -0,0 +1,54 @@ +/* util.h ....... error message utilities. + * C. Scott Ananian + * + * $Id: util.h,v 1.6 2005/03/10 01:18:20 quozl Exp $ + */ + +#ifndef INC_UTIL_H +#define INC_UTIL_H + +/* log_string is an identifier for this pptp process, passed from + command line using --log-string=X, and included with every log message. + Useful for people with multiple pptp sessions open at a time */ +extern char * log_string; + +/* log_level sets the logging verbosity. Values range from 0 (errors only) + to 1 (errors and warnings) to 2 (high verbosity, for debugging) */ +extern int log_level; + +void _log(const char *func, const char *file, int line, const char *format, ...) + __attribute__ ((format (printf, 4, 5))); +void _warn(const char *func, const char *file, int line, const char *format, ...) + __attribute__ ((format (printf, 4, 5))); +void _fatal(const char *func, const char *file, int line, const char *format, ...) + __attribute__ ((format (printf, 4, 5))) __attribute__ ((noreturn)); + +#define log(format, args...) \ + _log(__FUNCTION__,__FILE__,__LINE__, format , ## args) +#define warn(format, args...) \ + _warn(__FUNCTION__,__FILE__,__LINE__, format , ## args) +#define fatal(format, args...) \ + _fatal(__FUNCTION__,__FILE__,__LINE__, format , ## args) + +int file2fd(const char *path, const char *mode, int fd); + +/* signal to pipe delivery implementation */ + +/* create a signal pipe, returns 0 for success, -1 with errno for failure */ +int sigpipe_create(); + +/* generic handler for signals, writes signal number to pipe */ +void sigpipe_handler(int signum); + +/* assign a signal number to the pipe */ +void sigpipe_assign(int signum); + +/* return the signal pipe read file descriptor for select(2) */ +int sigpipe_fd(); + +/* read and return the pending signal from the pipe */ +int sigpipe_read(); + +void sigpipe_close(); + +#endif /* INC_UTIL_H */ diff --git a/pppd/plugins/pptp/vector.c b/pppd/plugins/pptp/vector.c new file mode 100644 index 000000000..a26c5debc --- /dev/null +++ b/pppd/plugins/pptp/vector.c @@ -0,0 +1,209 @@ +/* vector.c ..... store a vector of PPTP_CALL information and search it + * efficiently. + * C. Scott Ananian + * + * $Id: vector.c,v 1.3 2003/06/17 10:12:55 reink Exp $ + */ + +#include +#include +#include +#include "pptp_ctrl.h" +#include "vector.h" +/* #define VECTOR_DEBUG */ +#ifndef TRUE +#define TRUE 1 +#endif +#ifndef FALSE +#define FALSE 0 +#endif + +struct vector_item { + int key; + PPTP_CALL *call; +}; + +struct vector_struct { + struct vector_item *item; + int size; + int alloc; +#ifdef VECTOR_DEBUG + int key_max; +#endif +}; + +static struct vector_item *binary_search(VECTOR *v, int key); + +/*** vector_create ************************************************************/ +VECTOR *vector_create() +{ + const int INITIAL_SIZE = 4; + + VECTOR *v = malloc(sizeof(*v)); + if (v == NULL) return v; + + v->size = 0; + v->alloc = INITIAL_SIZE; + v->item = malloc(sizeof(*(v->item)) * (v->alloc)); +#ifdef VECTOR_DEBUG + v->key_max = -1; +#endif + if (v->item == NULL) { free(v); return NULL; } + else return v; +} + +/*** vector_destroy ***********************************************************/ +void vector_destroy(VECTOR *v) +{ + free(v->item); +#ifdef VECTOR_DEBUG + v->item = NULL; +#endif + free(v); +} + +/*** vector_size **************************************************************/ +int vector_size(VECTOR *v) +{ + assert(v != NULL); + return v->size; +} + +/*** vector_insert************************************************************* + * nice thing about file descriptors is that we are assured by POSIX + * that they are monotonically increasing. + */ +int vector_insert(VECTOR *v, int key, PPTP_CALL * call) +{ + int i; + assert(v != NULL && call != NULL); + assert(!vector_contains(v, key)); +#ifdef VECTOR_DEBUG + assert(v->key_max < key); +#endif + if (!(v->size < v->alloc)) { + void *tmp = realloc(v->item, sizeof(*(v->item)) * 2 * v->alloc); + if (tmp != NULL) { + v->alloc *= 2; + v->item = tmp; + } else return FALSE; /* failed to alloc memory. */ + } + assert(v->size < v->alloc); + /* for safety, we make this work in the general case; + * but this is optimized for adding call to the end of the vector. + */ + for(i = v->size - 1; i >= 0; i--) + if (v->item[i].key < key) + break; + /* insert after item i */ + memmove(&v->item[i + 2], &v->item[i + 1], + (v->size - i - 1) * sizeof(*(v->item))); + v->item[i + 1].key = key; + v->item[i + 1].call = call; + v->size++; +#ifdef VECTOR_DEBUG + if (v->key_max < key) /* ie, always. */ + v->key_max = key; +#endif + return TRUE; +} + +/*** vector_remove ************************************************************/ +int vector_remove(VECTOR *v, int key) +{ + struct vector_item *tmp; + assert(v != NULL); + if ((tmp =binary_search(v,key)) == NULL) return FALSE; + assert(tmp >= v->item && tmp < v->item + v->size); + memmove(tmp, tmp + 1, (v->size - (v->item - tmp) - 1) * sizeof(*(v->item))); + v->size--; + return TRUE; +} + +/*** vector_search ************************************************************/ +int vector_search(VECTOR *v, int key, PPTP_CALL **call) +{ + struct vector_item *tmp; + assert(v != NULL); + tmp = binary_search(v, key); + if (tmp ==NULL) return FALSE; + *call = tmp->call; + return TRUE; +} + +/*** vector_contains **********************************************************/ +int vector_contains(VECTOR *v, int key) +{ + assert(v != NULL); + return (binary_search(v, key) != NULL); +} + +/*** vector_item **************************************************************/ +static struct vector_item *binary_search(VECTOR *v, int key) +{ + int l,r,x; + l = 0; + r = v->size - 1; + while (r >= l) { + x = (l + r)/2; + if (key < v->item[x].key) r = x - 1; else l = x + 1; + if (key == v->item[x].key) return &(v->item[x]); + } + return NULL; +} + +/*** vector_scan *************************************************************** + * Hmm. Let's be fancy and use a binary search for the first + * unused key, taking advantage of the list is stored sorted; ie + * we can look at pointers and keys at two different locations, + * and if (ptr1 - ptr2) = (key1 - key2) then all the slots + * between ptr1 and ptr2 are filled. Note that ptr1-ptr2 should + * never be greater than key1-key2 (no duplicate keys!)... we + * check for this. + */ +int vector_scan(VECTOR *v, int lo, int hi, int *key) +{ + int l,r,x; + assert(v != NULL); + assert(key != NULL); + if ((v->size<1) || (lo < v->item[0].key)) { *key = lo; return TRUE; } + /* our array bounds */ + l = 0; r = v->size - 1; + while (r > l) { + /* check for a free spot right after l */ + if (v->item[l].key + 1 < v->item[l + 1].key) { /* found it! */ + *key = v->item[l].key + 1; + return TRUE; + } + /* no dice. Let's see if the free spot is before or after the midpoint */ + x = (l + r)/2; + /* Okay, we have right (r), left (l) and the probe (x). */ + assert(x - l <= v->item[x].key - v->item[l].key); + assert(r - x <= v->item[r].key - v->item[x].key); + if (x - l < v->item[x].key - v->item[l].key) + /* room between l and x */ + r = x; + else /* no room between l and x */ + if (r - x < v->item[r].key - v->item[x].key) + /* room between x and r */ + l = x; + else /* no room between x and r, either */ + break; /* game over, man. */ + } + /* no room found in already allocated space. Check to see if + * there's free space above allocated entries. */ + if (v->item[v->size - 1].key < hi) { + *key = v->item[v->size - 1].key + 1; + return TRUE; + } + /* outta luck */ + return FALSE; +} + +/*** vector_get_Nth ***********************************************************/ +PPTP_CALL * vector_get_Nth(VECTOR *v, int n) +{ + assert(v != NULL); + assert(0 <= n && n < vector_size(v)); + return v->item[n].call; +} diff --git a/pppd/plugins/pptp/vector.h b/pppd/plugins/pptp/vector.h new file mode 100644 index 000000000..b18899fbc --- /dev/null +++ b/pppd/plugins/pptp/vector.h @@ -0,0 +1,31 @@ +/* vector.h ..... store a vector of PPTP_CALL information and search it + * efficiently. + * C. Scott Ananian + * + * $Id: vector.h,v 1.1.1.1 2000/12/23 08:19:51 scott Exp $ + */ + +#ifndef INC_VECTOR_H +#define INC_VECTOR_H + +#include "pptp_ctrl.h" /* for definition of PPTP_CALL */ + +typedef struct vector_struct VECTOR; + +VECTOR *vector_create(); +void vector_destroy(VECTOR *v); + +int vector_size(VECTOR *v); + +/* vector_insert and vector_search return TRUE on success, FALSE on failure. */ +int vector_insert(VECTOR *v, int key, PPTP_CALL * call); +int vector_remove(VECTOR *v, int key); +int vector_search(VECTOR *v, int key, PPTP_CALL ** call); +/* vector_contains returns FALSE if not found, TRUE if found. */ +int vector_contains(VECTOR *v, int key); +/* find first unused key. Returns TRUE on success, FALSE if no. */ +int vector_scan(VECTOR *v, int lo, int hi, int *key); +/* get a specific PPTP_CALL ... useful only when iterating. */ +PPTP_CALL * vector_get_Nth(VECTOR *v, int n); + +#endif /* INC_VECTOR_H */ From 1d7267f22f50ed82ba685a77ff87ae2c8f048119 Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Thu, 4 Jun 2026 21:57:56 +0700 Subject: [PATCH 02/17] disable nagle to lower latency Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/pptp_ctrl.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pppd/plugins/pptp/pptp_ctrl.c b/pppd/plugins/pptp/pptp_ctrl.c index 1bab3f9ab..f945c099c 100644 --- a/pppd/plugins/pptp/pptp_ctrl.c +++ b/pppd/plugins/pptp/pptp_ctrl.c @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -258,6 +259,7 @@ static void ctrlp_rep( void * buffer, int size, int isbuff) PPTP_CONN * pptp_conn_open(int inet_sock, int isclient, pptp_conn_cb callback) { PPTP_CONN *conn; + int on = 1; /* Allocate structure */ if ((conn = malloc(sizeof(*conn))) == NULL) return NULL; if ((conn->call = vector_create()) == NULL) { free(conn); return NULL; } @@ -282,6 +284,9 @@ PPTP_CONN * pptp_conn_open(int inet_sock, int isclient, pptp_conn_cb callback) } /* Make this socket non-blocking. */ fcntl(conn->inet_sock, F_SETFL, O_NONBLOCK); + /* Disable nagle */ + setsockopt(conn->inet_sock, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)); + /* Request connection from server, if this is a client */ if (isclient) { struct pptp_start_ctrl_conn packet = { From 3784baf70015a8ad0074db972625b4555791d397 Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Thu, 4 Jun 2026 22:00:57 +0700 Subject: [PATCH 03/17] pass status on exit Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/pptp.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pppd/plugins/pptp/pptp.c b/pppd/plugins/pptp/pptp.c index 1522d19c7..0e0d1abed 100644 --- a/pppd/plugins/pptp/pptp.c +++ b/pppd/plugins/pptp/pptp.c @@ -259,6 +259,8 @@ static int open_callmgr(int call_id,struct in_addr inetaddr, char *phonenr,int w } default: /* parent */ waitpid(pid, &status, 0); + if (WIFEXITED(status)) + status = WEXITSTATUS(status); if (status!= 0) { close(fd); From f160722af0f32b14770255ebdd31ea31547cbf15 Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Thu, 4 Jun 2026 22:05:26 +0700 Subject: [PATCH 04/17] fix socket leak in callmgr Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/pptp.c | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/pppd/plugins/pptp/pptp.c b/pppd/plugins/pptp/pptp.c index 0e0d1abed..cf9ac9dea 100644 --- a/pppd/plugins/pptp/pptp.c +++ b/pppd/plugins/pptp/pptp.c @@ -177,18 +177,21 @@ static int pptp_start_client(void) 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,50); - 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); + 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); + 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))) { From 73f3e166a05f9936307938c3d23f9cfaea3090db Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Thu, 4 Jun 2026 22:20:29 +0700 Subject: [PATCH 05/17] avoid invalid state on dead connections Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/pptp_callmgr.c | 3 ++ pppd/plugins/pptp/pptp_ctrl.c | 62 ++++++++++++++++++++------------ pppd/plugins/pptp/pptp_ctrl.h | 2 ++ 3 files changed, 45 insertions(+), 22 deletions(-) diff --git a/pppd/plugins/pptp/pptp_callmgr.c b/pppd/plugins/pptp/pptp_callmgr.c index 20bb7369a..60bcfd584 100644 --- a/pppd/plugins/pptp/pptp_callmgr.c +++ b/pppd/plugins/pptp/pptp_callmgr.c @@ -178,6 +178,8 @@ int callmgr_main(int argc, char **argv, char **envp) do { int rc; fd_set read_set = call_set, write_set; + if (pptp_conn_dead(conn)) + break; FD_ZERO (&write_set); if (pptp_conn_established(conn)) { FD_SET (unix_sock, &read_set); @@ -305,6 +307,7 @@ int callmgr_main(int argc, char **argv, char **envp) } /* with extreme prejudice */ pptp_conn_destroy(conn); + pptp_conn_free(conn); vector_destroy(call_list); } cleanup: diff --git a/pppd/plugins/pptp/pptp_ctrl.c b/pppd/plugins/pptp/pptp_ctrl.c index f945c099c..19d791e9c 100644 --- a/pppd/plugins/pptp/pptp_ctrl.c +++ b/pppd/plugins/pptp/pptp_ctrl.c @@ -60,7 +60,7 @@ struct PPTP_CONN { int inet_sock; /* Connection States */ enum { - CONN_IDLE, CONN_WAIT_CTL_REPLY, CONN_WAIT_STOP_REPLY, CONN_ESTABLISHED + CONN_IDLE, CONN_WAIT_CTL_REPLY, CONN_WAIT_STOP_REPLY, CONN_ESTABLISHED, CONN_DEAD } conn_state; /* on startup: CONN_IDLE */ /* Keep-alive states */ enum { @@ -323,6 +323,10 @@ int pptp_conn_established(PPTP_CONN *conn) { return (conn->conn_state == CONN_ESTABLISHED); } +int pptp_conn_dead(PPTP_CONN *conn) { + return (conn->conn_state == CONN_DEAD); +} + /* This currently *only* works for client call requests. * We need to do something else to allocate calls for incoming requests. */ @@ -397,9 +401,10 @@ void pptp_call_close(PPTP_CONN * conn, PPTP_CALL * call) /* don't check state against WAIT_DISCONNECT... allow multiple disconnect * requests to be made. */ - pptp_send_ctrl_packet(conn, &rqst, sizeof(rqst)); - pptp_reset_timer(); - call->state.pns = PNS_WAIT_DISCONNECT; + if (pptp_send_ctrl_packet(conn, &rqst, sizeof(rqst))) { + pptp_reset_timer(); + call->state.pns = PNS_WAIT_DISCONNECT; + } /* call structure will be freed when we have confirmation of disconnect. */ } @@ -425,24 +430,26 @@ void pptp_conn_close(PPTP_CONN * conn, u_int8_t close_reason) int i; assert(conn && conn->call); /* avoid repeated close attempts */ - if (conn->conn_state == CONN_IDLE || conn->conn_state == CONN_WAIT_STOP_REPLY) + if (pptp_conn_dead(conn) || conn->conn_state == CONN_IDLE || conn->conn_state == CONN_WAIT_STOP_REPLY) return; /* close open calls, if any */ for (i = 0; i < vector_size(conn->call); i++) pptp_call_close(conn, vector_get_Nth(conn->call, i)); /* now close connection */ log("Closing PPTP connection"); - pptp_send_ctrl_packet(conn, &rqst, sizeof(rqst)); - pptp_reset_timer(); /* wait 60 seconds for reply */ - conn->conn_state = CONN_WAIT_STOP_REPLY; - return; + if (pptp_send_ctrl_packet(conn, &rqst, sizeof(rqst))) { + pptp_reset_timer(); /* wait 60 seconds for reply */ + conn->conn_state = CONN_WAIT_STOP_REPLY; + } } /*** this is a hard close *****************************************************/ void pptp_conn_destroy(PPTP_CONN * conn) { int i; - assert(conn != NULL); assert(conn->call != NULL); + assert(conn && conn->call); + if (pptp_conn_dead(conn)) + return; /* destroy all open calls */ for (i = 0; i < vector_size(conn->call); i++) pptp_call_destroy(conn, vector_get_Nth(conn->call, i)); @@ -452,6 +459,12 @@ void pptp_conn_destroy(PPTP_CONN * conn) close(conn->inet_sock); /* deallocate */ vector_destroy(conn->call); + conn->conn_state = CONN_DEAD; +} + +void pptp_conn_free(PPTP_CONN * conn) +{ + assert(conn != NULL); free(conn); } @@ -723,8 +736,8 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) reply.version = packet->version; /* protocol version not supported */ reply.result_code = hton8(5); - pptp_send_ctrl_packet(conn, &reply, sizeof(reply)); - pptp_reset_timer(); /* give sender a chance for a retry */ + if (pptp_send_ctrl_packet(conn, &reply, sizeof(reply))) + pptp_reset_timer(); /* give sender a chance for a retry */ } else { /* same or greater version */ if (pptp_send_ctrl_packet(conn, &reply, sizeof(reply))) { conn->conn_state = CONN_ESTABLISHED; @@ -831,8 +844,8 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) hton8(1), hton8(PPTP_GENERAL_ERROR_NONE), 0 }; logecho( PPTP_ECHO_RQST); - pptp_send_ctrl_packet(conn, &reply, sizeof(reply)); - pptp_reset_timer(); + if(pptp_send_ctrl_packet(conn, &reply, sizeof(reply))) + pptp_reset_timer(); break; } /* ----------- OUTGOING CALL MESSAGES ------------ */ @@ -918,9 +931,10 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) vector_search(conn->call, ntoh16(packet->call_id), &call); if (call->callback != NULL) call->callback(conn, call, CALL_CLOSE_RQST); - pptp_send_ctrl_packet(conn, &reply, sizeof(reply)); - pptp_call_destroy(conn, call); - log("Call closed (RQST) (call id %d)", (int) call->call_id); + if (pptp_send_ctrl_packet(conn, &reply, sizeof(reply))) { + pptp_call_destroy(conn, call); + log("Call closed (RQST) (call id %d)", (int) call->call_id); + } } break; } @@ -1041,11 +1055,15 @@ static void pptp_handle_timer() int i; /* "Keep Alives and Timers, 1": check connection state */ if (global.conn->conn_state != CONN_ESTABLISHED) { - if (global.conn->conn_state == CONN_WAIT_STOP_REPLY) + if (pptp_conn_dead(global.conn)) + return; + if (global.conn->conn_state == CONN_WAIT_STOP_REPLY) { /* hard close. */ pptp_conn_destroy(global.conn); - else /* soft close */ - pptp_conn_close(global.conn, PPTP_STOP_NONE); + return; + } + /* soft close */ + pptp_conn_close(global.conn, PPTP_STOP_NONE); } /* "Keep Alives and Timers, 2": check echo status */ if (global.conn->ka_state == KA_OUTSTANDING) { @@ -1055,8 +1073,8 @@ static void pptp_handle_timer() } else { /* ka_state == NONE */ /* send keep-alive */ struct pptp_echo_rqst rqst = { PPTP_HEADER_CTRL(PPTP_ECHO_RQST), hton32(global.conn->ka_id) }; - pptp_send_ctrl_packet(global.conn, &rqst, sizeof(rqst)); - global.conn->ka_state = KA_OUTSTANDING; + if(pptp_send_ctrl_packet(global.conn, &rqst, sizeof(rqst))) + global.conn->ka_state = KA_OUTSTANDING; } /* check incoming/outgoing call states for !IDLE && !ESTABLISHED */ for (i = 0; i < vector_size(global.conn->call); i++) { diff --git a/pppd/plugins/pptp/pptp_ctrl.h b/pppd/plugins/pptp/pptp_ctrl.h index a7bb5067d..a49bb649c 100644 --- a/pppd/plugins/pptp/pptp_ctrl.h +++ b/pppd/plugins/pptp/pptp_ctrl.h @@ -28,6 +28,7 @@ PPTP_CONN * pptp_conn_open(int inet_sock, int isclient, PPTP_CALL * pptp_call_open(PPTP_CONN * conn, int call_id, pptp_call_cb callback, char *phonenr,int window); int pptp_conn_established(PPTP_CONN * conn); +int pptp_conn_dead(PPTP_CONN *conn); /* soft close. Will callback on completion. */ void pptp_call_close(PPTP_CONN * conn, PPTP_CALL * call); /* hard close. */ @@ -36,6 +37,7 @@ void pptp_call_destroy(PPTP_CONN *conn, PPTP_CALL *call); void pptp_conn_close(PPTP_CONN * conn, u_int8_t close_reason); /* hard close */ void pptp_conn_destroy(PPTP_CONN * conn); +void pptp_conn_free(PPTP_CONN * conn); /* Add file descriptors used by pptp to fd_set. */ void pptp_fd_set(PPTP_CONN * conn, fd_set * read_set, fd_set * write_set, int *max_fd); From 38899ec1ac7c4ec5bb4040e1fe721e6aa30dfec7 Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Fri, 5 Jun 2026 11:57:36 +0700 Subject: [PATCH 06/17] avoid unaligned memory access Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/pptp.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/pppd/plugins/pptp/pptp.c b/pppd/plugins/pptp/pptp.c index cf9ac9dea..44f1c849b 100644 --- a/pppd/plugins/pptp/pptp.c +++ b/pppd/plugins/pptp/pptp.c @@ -122,6 +122,7 @@ static int pptp_start_client(void) socklen_t len; struct sockaddr_pppox src_addr,dst_addr; struct hostent *hostinfo; + u_int16_t new_call_id; hostinfo=gethostbyname(pptp_server); if (!hostinfo) @@ -159,7 +160,6 @@ static int pptp_start_client(void) 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) @@ -191,7 +191,9 @@ static int pptp_start_client(void) return -1; } /* Exchange PIDs, get call ID */ - } while (get_call_id(callmgr_sock, getpid(), getpid(), &dst_addr.sa_addr.pptp.call_id) < 0); + } while (get_call_id(callmgr_sock, getpid(), getpid(), &new_call_id) < 0); + + dst_addr.sa_addr.pptp.call_id = new_call_id; if (connect(pptp_fd,(struct sockaddr*)&dst_addr,sizeof(dst_addr))) { From 3c09ab1077e976f8219944164175687f2eba4579 Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Sun, 7 Jun 2026 16:53:58 +0700 Subject: [PATCH 07/17] change function calls to match new ppp code Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/Makefile.am | 2 +- pppd/plugins/pptp/if_pppox.h | 1 - pppd/plugins/pptp/pptp.c | 42 +++++++++++++++++------------------ 3 files changed, 22 insertions(+), 23 deletions(-) delete mode 120000 pppd/plugins/pptp/if_pppox.h diff --git a/pppd/plugins/pptp/Makefile.am b/pppd/plugins/pptp/Makefile.am index 6c4282c42..26e31236c 100644 --- a/pppd/plugins/pptp/Makefile.am +++ b/pppd/plugins/pptp/Makefile.am @@ -8,6 +8,6 @@ pptp_la_LDFLAGS = -module pptp_la_SOURCES = pptp.c pptp_callmgr.c pptp_ctrl.c util.c vector.c \ dirutil.c pptp_quirks.c orckit_quirks.c noinst_HEADERS = pptp_callmgr.h pptp_ctrl.h util.h vector.h pptp_options.h \ - dirutil.h pptp_quirks.h orckit_quirks.h if_pppox.h + dirutil.h pptp_quirks.h orckit_quirks.h AM_CFLAGS = -Wall man_MANS = pppd-pptp.8 diff --git a/pppd/plugins/pptp/if_pppox.h b/pppd/plugins/pptp/if_pppox.h deleted file mode 120000 index 48a1663c1..000000000 --- a/pppd/plugins/pptp/if_pppox.h +++ /dev/null @@ -1 +0,0 @@ -../../kernel/driver/if_pppox.h \ No newline at end of file diff --git a/pppd/plugins/pptp/pptp.c b/pppd/plugins/pptp/pptp.c index 44f1c849b..0ddd89c98 100644 --- a/pppd/plugins/pptp/pptp.c +++ b/pppd/plugins/pptp/pptp.c @@ -38,17 +38,16 @@ #include #include -#include "pppd/pppd.h" -#include "pppd/fsm.h" -#include "pppd/lcp.h" -#include "pppd/ipcp.h" -#include "pppd/ccp.h" -#include "pppd/pathnames.h" +#include +#include +#include +#include +#include #include "pptp_callmgr.h" #include #include -#include "if_pppox.h" +#include #include #include @@ -74,7 +73,7 @@ int call_ID; //static struct in_addr get_ip_address(char *name); static int open_callmgr(int call_id,struct in_addr inetaddr, char *phonenr,int window); -static void launch_callmgr(int call_is,struct in_addr inetaddr, char *phonenr,int window); +static void launch_callmgr(int call_id,struct in_addr inetaddr, char *phonenr,int window); static int get_call_id(int sock, pid_t gre, pid_t pppd, u_int16_t *peer_call_id); //static int pptp_devname_hook(char *cmd, char **argv, int doit); @@ -102,8 +101,8 @@ struct channel pptp_channel = { check_options: NULL, connect: &pptp_connect, disconnect: &pptp_disconnect, - establish_ppp: &generic_establish_ppp, - disestablish_ppp: &generic_disestablish_ppp, + establish_ppp: &ppp_generic_establish, + disestablish_ppp: &ppp_generic_disestablish, //send_config: &pptp_send_config, //recv_config: &pptp_recv_config, close: NULL, @@ -113,7 +112,10 @@ struct channel pptp_channel = { static int pptp_start_server(void) { pptp_fd=pptp_sock; - sprintf(ppp_devnam,"pptp (%s)",pptp_client); + + char _tmp_buf[64]; + snprintf(_tmp_buf, sizeof(_tmp_buf), "pptp (%s)", pptp_client); + ppp_set_devnam(_tmp_buf); return pptp_fd; } @@ -203,7 +205,9 @@ static int pptp_start_client(void) return -1; } - sprintf(ppp_devnam,"pptp (%s)",pptp_server); + char _tmp_buf[64]; + snprintf(_tmp_buf, sizeof(_tmp_buf), "pptp (%s)", pptp_server); + ppp_set_devnam(_tmp_buf); return pptp_fd; } @@ -335,17 +339,13 @@ static int get_call_id(int sock, pid_t gre, pid_t pppd, void plugin_init(void) { - /*if (!ppp_available() && !new_style_driver) - { - fatal("Linux kernel does not support PPP -- are you running 2.4.x?"); - }*/ - - add_options(Options); +#if !defined(__linux__) + fatal("No PPTP support on this OS"); +#endif - info("PPTP plugin version %s compiled for pppd-%s, linux-%s", - VERSION, PPPD_VERSION,KERNELVERSION); + ppp_add_options(Options); the_channel = &pptp_channel; - modem = 0; + ppp_set_modem(0); } From ebb475752170b27ebf0ad76bacce383489db9194 Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Sun, 7 Jun 2026 17:21:58 +0700 Subject: [PATCH 08/17] in-tree build target done Signed-off-by: [anp/hsw] --- configure.ac | 1 + pppd/plugins/Makefile.am | 2 +- pppd/plugins/pptp/Makefile.am | 17 +++++++---------- pppd/plugins/pptp/pptp.c | 1 + 4 files changed, 10 insertions(+), 11 deletions(-) diff --git a/configure.ac b/configure.ac index 69d4bd243..ff75f5194 100644 --- a/configure.ac +++ b/configure.ac @@ -329,6 +329,7 @@ AC_CONFIG_FILES([ pppd/plugins/pppoe/Makefile pppd/plugins/pppoatm/Makefile pppd/plugins/pppol2tp/Makefile + pppd/plugins/pptp/Makefile pppd/plugins/radius/Makefile pppd/plugins/dhcpv6relay/Makefile pppdump/Makefile diff --git a/pppd/plugins/Makefile.am b/pppd/plugins/Makefile.am index 267d6697d..6b89b94c2 100644 --- a/pppd/plugins/Makefile.am +++ b/pppd/plugins/Makefile.am @@ -17,5 +17,5 @@ winbind_la_LDFLAGS = $(PLUGIN_LDFLAGS) winbind_la_SOURCES = winbind.c if !SUNOS -SUBDIRS = pppoe pppoatm pppol2tp radius dhcpv6relay +SUBDIRS = pppoe pppoatm pppol2tp pptp radius dhcpv6relay endif diff --git a/pppd/plugins/pptp/Makefile.am b/pppd/plugins/pptp/Makefile.am index 26e31236c..c75f5eb7c 100644 --- a/pppd/plugins/pptp/Makefile.am +++ b/pppd/plugins/pptp/Makefile.am @@ -1,13 +1,10 @@ +pppd_plugin_LTLIBRARIES = pptp.la +pppd_plugindir = $(PPPD_PLUGIN_DIR) -# set the include path found by configure -INCLUDES = $(all_includes) +noinst_HEADERS = pptp_callmgr.h pptp_ctrl.h util.h vector.h pptp_options.h \ + dirutil.h pptp_quirks.h orckit_quirks.h -# the library search path. -lib_LTLIBRARIES = pptp.la -pptp_la_LDFLAGS = -module +pptp_la_CPPFLAGS = -I${top_srcdir} +pptp_la_LDFLAGS = -module -avoid-version pptp_la_SOURCES = pptp.c pptp_callmgr.c pptp_ctrl.c util.c vector.c \ - dirutil.c pptp_quirks.c orckit_quirks.c -noinst_HEADERS = pptp_callmgr.h pptp_ctrl.h util.h vector.h pptp_options.h \ - dirutil.h pptp_quirks.h orckit_quirks.h -AM_CFLAGS = -Wall -man_MANS = pppd-pptp.8 + dirutil.c pptp_quirks.c orckit_quirks.c diff --git a/pppd/plugins/pptp/pptp.c b/pppd/plugins/pptp/pptp.c index 0ddd89c98..0b420b00e 100644 --- a/pppd/plugins/pptp/pptp.c +++ b/pppd/plugins/pptp/pptp.c @@ -39,6 +39,7 @@ #include #include +#include #include #include #include From 6492d19600d5b6c904f6540c6c5ebbd959903800 Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Sun, 7 Jun 2026 17:38:26 +0700 Subject: [PATCH 09/17] fix dist headers Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/Makefile.am | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pppd/plugins/pptp/Makefile.am b/pppd/plugins/pptp/Makefile.am index c75f5eb7c..120743341 100644 --- a/pppd/plugins/pptp/Makefile.am +++ b/pppd/plugins/pptp/Makefile.am @@ -1,8 +1,8 @@ pppd_plugin_LTLIBRARIES = pptp.la pppd_plugindir = $(PPPD_PLUGIN_DIR) -noinst_HEADERS = pptp_callmgr.h pptp_ctrl.h util.h vector.h pptp_options.h \ - dirutil.h pptp_quirks.h orckit_quirks.h +noinst_HEADERS = pptp_callmgr.h pptp_ctrl.h pptp_msg.h pptp_options.h \ + util.h vector.h dirutil.h pptp_quirks.h orckit_quirks.h pptp_la_CPPFLAGS = -I${top_srcdir} pptp_la_LDFLAGS = -module -avoid-version From 4b1dd932e6a92eb0fa933a90eee5d430312b8c1e Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Wed, 22 Jul 2026 18:49:34 +0700 Subject: [PATCH 10/17] update manual page Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/pppd-pptp.8 | 31 +++++++++++++++++++++---------- 1 file changed, 21 insertions(+), 10 deletions(-) diff --git a/pppd/plugins/pptp/pppd-pptp.8 b/pppd/plugins/pptp/pppd-pptp.8 index 85b31b21a..ce110fc73 100644 --- a/pppd/plugins/pptp/pppd-pptp.8 +++ b/pppd/plugins/pptp/pppd-pptp.8 @@ -17,34 +17,43 @@ pptp.so \- PPTP VPN plugin for plugin pptp.so .SH DESCRIPTION .LP -The PPTP plugin for pppd performs interaction with pptp kernel module +The PPTP plugin for pppd performs interaction with the pptp kernel module and has built-in call manager (client part of PPTP). -It pasees necessary paremeters from \fIoptions\fR into kernel module +It passes necessary parameters from \fIoptions\fR into the kernel module to configure ppp-pptp channel. If it runs in client mode, then additionally call manager starts up. PPTPD daemon automaticaly invokes this plugin in server mode and passes necessary options, so additional configuration is not needed. .SH OPTIONS for client mode -The PPTP plugin introduces one additional pppd option: +The PPTP plugin introduces additional pppd options: .TP .BI "pptp_server " server " (required)" -Specifies ip address or hostname of pptp server. +Specifies IP address or hostname of the pptp server. .TP .BI "pptp_window " packets " (optional)" -The amount of sliding window size. +The size of the sliding window. Set to 0 to turn off sliding window. to 3-10 for low speed connections. to >10 for hi speed connections. .TP .BI "pptp_phone " phone " (optional)" -The phone string that sended to pptp server. +The phone string sent to the pptp server. .TP -.BI "pptp_timeout " miliseconds " (optional)" -Specifies timeout for waiting "ack" packet from server. +.BI "pptp_timeout " milliseconds " (optional)" +Specifies timeout for waiting for an "ack" packet from server. + +.SH OPTIONS for server mode (intended to be run by pptpd) +.TP +.BI "pptp_client " client " (required)" +Specifies the IP address or hostname of the pptp client. +.TP +.BI "pptp_sock " socket " (required)" +The socket to communicate with the client. + .SH USAGE -Sample configuration file: +Sample client configuration file: .nf plugin "pptp.so" pptp_server 192.168.0.1 @@ -67,5 +76,7 @@ lcp-echo-failure 3 .SH SEE ALSO .BR pppd (8) " " pptpd (8) " " pptpd.conf (5) -.SH AUTHOR +.SH AUTHORS xeb xeb@mail.ru + +[anp/hsw] sysop@880.ru From 0ef183a5fcf662416d4ba3982eb59d7aacd5a9f2 Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Wed, 22 Jul 2026 20:36:33 +0700 Subject: [PATCH 11/17] use native pppd logging functions Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/orckit_quirks.c | 3 -- pppd/plugins/pptp/pptp_callmgr.c | 17 ++++--- pppd/plugins/pptp/pptp_ctrl.c | 83 ++++++++++++++++--------------- pppd/plugins/pptp/util.c | 58 --------------------- pppd/plugins/pptp/util.h | 23 --------- 5 files changed, 51 insertions(+), 133 deletions(-) diff --git a/pppd/plugins/pptp/orckit_quirks.c b/pppd/plugins/pptp/orckit_quirks.c index 1d0373782..ef284dbaf 100644 --- a/pppd/plugins/pptp/orckit_quirks.c +++ b/pppd/plugins/pptp/orckit_quirks.c @@ -10,9 +10,6 @@ #include "pptp_msg.h" #include "pptp_options.h" #include "pptp_ctrl.h" -#include "util.h" - - /* return 0 on success, non zero otherwise */ int diff --git a/pppd/plugins/pptp/pptp_callmgr.c b/pppd/plugins/pptp/pptp_callmgr.c index 60bcfd584..5c535031e 100644 --- a/pppd/plugins/pptp/pptp_callmgr.c +++ b/pppd/plugins/pptp/pptp_callmgr.c @@ -25,6 +25,7 @@ #include "dirutil.h" #include "vector.h" #include "util.h" +#include extern struct in_addr localbind; /* from pptp.c */ extern int call_ID; @@ -76,7 +77,7 @@ void call_callback(PPTP_CONN *conn, PPTP_CALL *call, enum call_state state) case CALL_CLOSE_DONE: /* don't need to do anything here, except make sure tables * are sync'ed */ - log("Closing connection (call state)"); + dbglog("Closing connection (call state)"); conninfo = pptp_conn_closure_get(conn); lci = pptp_call_closure_get(conn, call); assert(lci != NULL && conninfo != NULL); @@ -89,7 +90,7 @@ void call_callback(PPTP_CONN *conn, PPTP_CALL *call, enum call_state state) } break; default: - log("Unhandled call callback state [%d].", (int) state); + dbglog("Unhandled call callback state [%d].", (int) state); break; } } @@ -122,22 +123,22 @@ int callmgr_main(int argc, char **argv, char **envp) //phonenr = argc == 3 ? argv[2] : NULL; for(i=2; ipid[0] > 1) kill(lci->pid[0], SIGTERM); //if(lci->pid[1] > 1) kill(lci->pid[1], SIGTERM); free(lci); @@ -268,7 +269,7 @@ int callmgr_main(int argc, char **argv, char **envp) for (i = 0; i < vector_size(call_list); i++) { PPTP_CALL *call = vector_get_Nth(call_list, i); //struct local_callinfo *lci = pptp_call_closure_get(conn, call); - log("Closing connection (shutdown)"); + dbglog("Closing connection (shutdown)"); pptp_call_close(conn, call); //if(lci->pid[0] > 1) kill(lci->pid[0], SIGTERM); //if(lci->pid[1] > 1) kill(lci->pid[1], SIGTERM); diff --git a/pppd/plugins/pptp/pptp_ctrl.c b/pppd/plugins/pptp/pptp_ctrl.c index 19d791e9c..2d5cf254c 100644 --- a/pppd/plugins/pptp/pptp_ctrl.c +++ b/pppd/plugins/pptp/pptp_ctrl.c @@ -23,6 +23,7 @@ #include "vector.h" #include "util.h" #include "pptp_quirks.h" +#include /* BECAUSE OF SIGNAL LIMITATIONS, EACH PROCESS CAN ONLY MANAGE ONE * CONNECTION. SO THIS 'PPTP_CONN' STRUCTURE IS A BIT MISLEADING. @@ -195,17 +196,17 @@ static void ctrlp_error( int result, int error, int cause, const char *result_text[], int max_result) { if( cause >= 0) - log("Result code is %d '%s'. Error code is %d, Cause code is %d", + warn("Result code is %d '%s'. Error code is %d, Cause code is %d", result, result_text[result <= max_result ? result : 0], error, cause ); else - log("Reply result code is %d '%s'. Error code is %d", + warn("Reply result code is %d '%s'. Error code is %d", result, result_text[result <= max_result ? result : 0], error); if ((error > 0) && (error <= MAX_GENERAL_ERROR)){ if( result != PPTP_RESULT_GENERAL_ERROR ) - log("Result code is something else then \"general error\", " + warn("Result code is something else then \"general error\", " "so the following error is probably bogus."); - log("Error is '%s', Error message: '%s'", + warn("Error is '%s', Error message: '%s'", pptp_general_errors[error].name, pptp_general_errors[error].desc); } @@ -248,7 +249,7 @@ static void ctrlp_rep( void * buffer, int size, int isbuff) if( type == PPTP_ECHO_RQST ) return; /* don't keep reporting sending of echo's */ if( (type == PPTP_ECHO_RQST || type == PPTP_ECHO_RPLY) && nlogecho <= 0 ) return; - log("%s control packet type is %d '%s'\n",isbuff ? "Buffered" : "Sent", + dbglog("%s control packet type is %d '%s'\n",isbuff ? "Buffered" : "Sent", type, ctrl_msg_types[type <= MAX_CTRLMSG_TYPE ? type : 0]); } @@ -436,7 +437,7 @@ void pptp_conn_close(PPTP_CONN * conn, u_int8_t close_reason) for (i = 0; i < vector_size(conn->call); i++) pptp_call_close(conn, vector_get_Nth(conn->call, i)); /* now close connection */ - log("Closing PPTP connection"); + info("Closing PPTP connection"); if (pptp_send_ctrl_packet(conn, &rqst, sizeof(rqst))) { pptp_reset_timer(); /* wait 60 seconds for reply */ conn->conn_state = CONN_WAIT_STOP_REPLY; @@ -529,7 +530,7 @@ int pptp_write_some(PPTP_CONN * conn) { if (errno == EAGAIN || errno == EINTR) { return 0; } else { /* a real error */ - log("write error: %s", strerror(errno)); + warn("write error: %s", strerror(errno)); return -1; } } @@ -549,7 +550,7 @@ int pptp_read_some(PPTP_CONN * conn) char *new_buffer = realloc(conn->read_buffer, sizeof(*(conn->read_buffer)) * conn->read_alloc * 2); if (new_buffer == NULL) { - log("Out of memory"); return -1; + warn("Out of memory"); return -1; } conn->read_alloc *= 2; conn->read_buffer = new_buffer; @@ -557,14 +558,14 @@ int pptp_read_some(PPTP_CONN * conn) retval = read(conn->inet_sock, conn->read_buffer + conn->read_size, conn->read_alloc - conn->read_size); if (retval == 0) { - log("read returned zero, peer has closed"); + warn("read returned zero, peer has closed"); return -1; } if (retval < 0) { if (errno == EINTR || errno == EAGAIN) return 0; else { /* a real error */ - log("read error: %s", strerror(errno)); + warn("read error: %s", strerror(errno)); return -1; } } @@ -585,7 +586,7 @@ int pptp_make_packet(PPTP_CONN * conn, void **buf, size_t *size) header = (struct pptp_header *) (conn->read_buffer + bad_bytes); if (ntoh32(header->magic) != PPTP_MAGIC) goto throwitout; if (ntoh16(header->reserved0) != 0) - log("reserved0 field is not zero! (0x%x) Cisco feature? \n", + warn("reserved0 field is not zero! (0x%x) Cisco feature? \n", ntoh16(header->reserved0)); if (ntoh16(header->length) < sizeof(struct pptp_header)) goto throwitout; if (ntoh16(header->length) > PPTP_CTRL_SIZE_MAX) goto throwitout; @@ -601,14 +602,14 @@ int pptp_make_packet(PPTP_CONN * conn, void **buf, size_t *size) /* well, I guess we've got it. */ *size = ntoh16(header->length); *buf = malloc(*size); - if (*buf == NULL) { log("Out of memory."); return 0; /* ack! */ } + if (*buf == NULL) { warn("Out of memory."); return 0; /* ack! */ } memcpy(*buf, conn->read_buffer + bad_bytes, *size); /* Delete this packet from the read_buffer. */ conn->read_size -= (bad_bytes + *size); memmove(conn->read_buffer, conn->read_buffer + bad_bytes + *size, conn->read_size); if (bad_bytes > 0) - log("%lu bad bytes thrown away.", (unsigned long) bad_bytes); + warn("%lu bad bytes thrown away.", (unsigned long) bad_bytes); return 1; throwitout: bad_bytes++; @@ -618,7 +619,7 @@ int pptp_make_packet(PPTP_CONN * conn, void **buf, size_t *size) conn->read_size -= bad_bytes; memmove(conn->read_buffer, conn->read_buffer + bad_bytes, conn->read_size); if (bad_bytes > 0) - log("%lu bad bytes thrown away.", (unsigned long) bad_bytes); + warn("%lu bad bytes thrown away.", (unsigned long) bad_bytes); return 0; } @@ -635,7 +636,7 @@ int pptp_send_ctrl_packet(PPTP_CONN * conn, void * buffer, size_t size) /* ignore */; retval = 0; } else { /* a real error */ - log("write error: %s", strerror(errno)); + warn("write error: %s", strerror(errno)); pptp_conn_destroy(conn); /* shut down fast. */ return 0; } @@ -649,7 +650,7 @@ int pptp_send_ctrl_packet(PPTP_CONN * conn, void * buffer, size_t size) char *new_buffer = realloc(conn->write_buffer, sizeof(*(conn->write_buffer)) * conn->write_alloc * 2); if (new_buffer == NULL) { - log("Out of memory"); return 0; + warn("Out of memory"); return 0; } conn->write_alloc *= 2; conn->write_buffer = new_buffer; @@ -674,10 +675,10 @@ int pptp_dispatch_packet(PPTP_CONN * conn, void * buffer, size_t size) break; case PPTP_MESSAGE_MANAGE: /* MANAGEMENT messages aren't even part of the spec right now. */ - log("PPTP management message received, but not understood."); + dbglog("PPTP management message received, but not understood."); break; default: - log("Unknown PPTP control message type received: %u", + dbglog("Unknown PPTP control message type received: %u", (unsigned int) ntoh16(header->pptp_type)); break; } @@ -690,9 +691,9 @@ static void logecho( int type) /* hack to stop flooding the log files (the most interesting part is right * after the connection built-up) */ if( nlogecho > 0) { - log( "Echo Re%s received.", type == PPTP_ECHO_RQST ? "quest" :"ply"); + dbglog("Echo Re%s received.", type == PPTP_ECHO_RQST ? "quest" :"ply"); if( --nlogecho == 0) - log("no more Echo Reply/Request packets will be reported."); + dbglog("no more Echo Reply/Request packets will be reported."); } } @@ -706,7 +707,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) assert(ntoh16(header->length) == size); assert(ntoh16(header->pptp_type) == PPTP_MESSAGE_CONTROL); if (size < PPTP_CTRL_SIZE(ntoh16(header->ctrl_type))) { - log("Invalid packet received [type: %d; length: %d].", + warn("Invalid packet received [type: %d; length: %d].", (int) ntoh16(header->ctrl_type), (int) size); return 0; } @@ -723,7 +724,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) hton16(PPTP_MAX_CHANNELS), hton16(PPTP_FIRMWARE_VERSION), PPTP_HOSTNAME, PPTP_VENDOR }; int idx, rc; - log("Received Start Control Connection Request"); + dbglog("Received Start Control Connection Request"); /* fix this packet, if necessary */ idx = get_quirk_index(); if (idx != -1 && pptp_fixups[idx].start_ctrl_conn) { @@ -741,7 +742,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) } else { /* same or greater version */ if (pptp_send_ctrl_packet(conn, &reply, sizeof(reply))) { conn->conn_state = CONN_ESTABLISHED; - log("server connection ESTABLISHED."); + dbglog("server connection ESTABLISHED."); pptp_reset_timer(); } } @@ -752,7 +753,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) { struct pptp_start_ctrl_conn *packet = (struct pptp_start_ctrl_conn *) buffer; - log("Received Start Control Connection Reply"); + dbglog("Received Start Control Connection Reply"); if (conn->conn_state == CONN_WAIT_CTL_REPLY) { /* XXX handle collision XXX [see rfc] */ if (ntoh16(packet->version) != PPTP_VERSION) { @@ -769,7 +770,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) * (feature found in certain ADSL modems) */ ntoh8(packet->result_code) != 0) { - log("Negative reply received to our Start Control " + dbglog("Negative reply received to our Start Control " "Connection Request"); ctrlp_error(packet->result_code, packet->error_code, -1, pptp_start_ctrl_conn_rply, @@ -786,7 +787,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) memcpy(conn->hostname, packet->hostname, sizeof(conn->hostname)); memcpy(conn->vendor, packet->vendor, sizeof(conn->vendor)); pptp_reset_timer(); /* 60 seconds until keep-alive */ - log("Client connection established."); + dbglog("Client connection established."); if (conn->callback != NULL) conn->callback(conn, CONN_OPEN_DONE); } /* else goto pptp_conn_close; */ @@ -801,7 +802,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) PPTP_HEADER_CTRL(PPTP_STOP_CTRL_CONN_RPLY), hton8(1), hton8(PPTP_GENERAL_ERROR_NONE), 0 }; - log("Received Stop Control Connection Request."); + dbglog("Received Stop Control Connection Request."); if (conn->conn_state == CONN_IDLE) break; if (pptp_send_ctrl_packet(conn, &reply, sizeof(reply))) { if (conn->callback != NULL) @@ -813,7 +814,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) } case PPTP_STOP_CTRL_CONN_RPLY: { - log("Received Stop Control Connection Reply."); + dbglog("Received Stop Control Connection Reply."); /* conn_state should be CONN_WAIT_STOP_REPLY, but it * could be something else */ if (conn->conn_state == CONN_IDLE) break; @@ -859,7 +860,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) hton32(PPTP_CONNECT_SPEED), hton16(PPTP_WINDOW), hton16(PPTP_DELAY), 0 }; - log("Received Outgoing Call Request."); + dbglog("Received Outgoing Call Request."); /* XXX PAC: eventually this should make an outgoing call. XXX */ reply.result_code = hton8(7); /* outgoing calls verboten */ pptp_send_ctrl_packet(conn, &reply, sizeof(reply)); @@ -871,15 +872,15 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) (struct pptp_out_call_rply *)buffer; PPTP_CALL * call; u_int16_t callid = ntoh16(packet->call_id_peer); - log("Received Outgoing Call Reply."); + dbglog("Received Outgoing Call Reply."); if (!vector_search(conn->call, (int) callid, &call)) { - log("PPTP_OUT_CALL_RPLY received for non-existant call: " + dbglog("PPTP_OUT_CALL_RPLY received for non-existant call: " "peer call ID (us) %d call ID (them) %d.", callid, ntoh16(packet->call_id)); break; } if (call->call_type != PPTP_CALL_PNS) { - log("Ack! How did this call_type get here?"); /* XXX? */ + dbglog("Ack! How did this call_type get here?"); /* XXX? */ break; } if (call->state.pns != PNS_WAIT_REPLY) { @@ -889,7 +890,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) /* check for errors */ if (packet->result_code != 1) { /* An error. Log it verbosely. */ - log("Our outgoing call request [callid %d] has not been " + dbglog("Our outgoing call request [callid %d] has not been " "accepted.", (int) callid); ctrlp_error(packet->result_code, packet->error_code, packet->cause_code, pptp_out_call_reply_result, @@ -909,7 +910,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) pptp_set_link(conn, call->peer_call_id); if (call->callback != NULL) call->callback(conn, call, CALL_OPEN_DONE); - log("Outgoing call established (call ID %u, peer's " + dbglog("Outgoing call established (call ID %u, peer's " "call ID %u).\n", call->call_id, call->peer_call_id); } break; @@ -925,7 +926,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) PPTP_HEADER_CTRL(PPTP_CALL_CLEAR_NTFY), packet->call_id, 1, PPTP_GENERAL_ERROR_NONE, 0, 0, {0} }; - log("Received Call Clear Request."); + dbglog("Received Call Clear Request."); if (vector_contains(conn->call, ntoh16(packet->call_id))) { PPTP_CALL * call; vector_search(conn->call, ntoh16(packet->call_id), &call); @@ -933,7 +934,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) call->callback(conn, call, CALL_CLOSE_RQST); if (pptp_send_ctrl_packet(conn, &reply, sizeof(reply))) { pptp_call_destroy(conn, call); - log("Call closed (RQST) (call id %d)", (int) call->call_id); + dbglog("Call closed (RQST) (call id %d)", (int) call->call_id); } } break; @@ -942,7 +943,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) { struct pptp_call_clear_ntfy *packet = (struct pptp_call_clear_ntfy *)buffer; - log("Call disconnect notification received (call id %d)", + dbglog("Call disconnect notification received (call id %d)", ntoh16(packet->call_id)); if (vector_contains(conn->call, ntoh16(packet->call_id))) { PPTP_CALL * call; @@ -963,9 +964,9 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) struct pptp_set_link_info *packet = (struct pptp_set_link_info *)buffer; /* log it. */ - log("PPTP_SET_LINK_INFO received from peer_callid %u", + dbglog("PPTP_SET_LINK_INFO received from peer_callid %u", (unsigned int) ntoh16(packet->call_id_peer)); - log(" send_accm is %08lX, recv_accm is %08lX", + dbglog(" send_accm is %08lX, recv_accm is %08lX", (unsigned long) ntoh32(packet->send_accm), (unsigned long) ntoh32(packet->recv_accm)); if (!(ntoh32(packet->send_accm) == 0 && @@ -974,7 +975,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) break; } default: - log("Unrecognized Packet %d received.", + dbglog("Unrecognized Packet %d received.", (int) ntoh16(((struct pptp_header *)buffer)->ctrl_type)); /* goto pptp_conn_close; */ break; @@ -1068,7 +1069,7 @@ static void pptp_handle_timer() /* "Keep Alives and Timers, 2": check echo status */ if (global.conn->ka_state == KA_OUTSTANDING) { /* no response to keep-alive */ - log ("closing control connection due to missing echo reply"); + info("closing control connection due to missing echo reply"); pptp_conn_close(global.conn, PPTP_STOP_NONE); } else { /* ka_state == NONE */ /* send keep-alive */ struct pptp_echo_rqst rqst = { diff --git a/pppd/plugins/pptp/util.c b/pppd/plugins/pptp/util.c index dabddbec6..1832c0c8d 100644 --- a/pppd/plugins/pptp/util.c +++ b/pppd/plugins/pptp/util.c @@ -11,64 +11,6 @@ #include #include "util.h" -#ifndef PROGRAM_NAME -#define PROGRAM_NAME "pptp" -#endif - -/* implementation of log_string, defined as extern in util.h */ -char *log_string = "anon"; - -static void open_log(void) __attribute__ ((constructor)); -static void close_log(void) __attribute__ ((destructor)); - -#define MAKE_STRING(label) \ -va_list ap; \ -char buf[256], string[256]; \ -va_start(ap, format); \ -vsnprintf(buf, sizeof(buf), format, ap); \ -snprintf(string, sizeof(string), "%s %s[%s:%s:%d]: %s", \ - log_string, label, func, file, line, buf); \ -va_end(ap) - -/*** open log *****************************************************************/ -static void open_log(void) { - openlog(PROGRAM_NAME, LOG_PID, LOG_DAEMON); -} - -/*** close log ****************************************************************/ -static void close_log(void) -{ - closelog(); -} - -/*** print a message to syslog ************************************************/ -void _log(const char *func, const char *file, int line, const char *format, ...) -{ - MAKE_STRING("log"); - open_log(); - syslog(LOG_NOTICE, "%s", string); - close_log(); -} - -/*** print a warning to syslog ************************************************/ -void _warn(const char *func, const char *file, int line, const char *format, ...) -{ - MAKE_STRING("warn"); - open_log(); - fprintf(stderr, "%s\n", string); - syslog(LOG_WARNING, "%s", string); - close_log(); -} - -/*** print a fatal warning to syslog and exit *********************************/ -void _fatal(const char *func, const char *file, int line, const char *format, ...) -{ - MAKE_STRING("fatal"); - fprintf(stderr, "%s\n", string); - syslog(LOG_CRIT, "%s", string); - exit(1); -} - /*** connect a file to a file descriptor **************************************/ int file2fd(const char *path, const char *mode, int fd) { diff --git a/pppd/plugins/pptp/util.h b/pppd/plugins/pptp/util.h index 1ed5079f8..acc5a4f7d 100644 --- a/pppd/plugins/pptp/util.h +++ b/pppd/plugins/pptp/util.h @@ -7,29 +7,6 @@ #ifndef INC_UTIL_H #define INC_UTIL_H -/* log_string is an identifier for this pptp process, passed from - command line using --log-string=X, and included with every log message. - Useful for people with multiple pptp sessions open at a time */ -extern char * log_string; - -/* log_level sets the logging verbosity. Values range from 0 (errors only) - to 1 (errors and warnings) to 2 (high verbosity, for debugging) */ -extern int log_level; - -void _log(const char *func, const char *file, int line, const char *format, ...) - __attribute__ ((format (printf, 4, 5))); -void _warn(const char *func, const char *file, int line, const char *format, ...) - __attribute__ ((format (printf, 4, 5))); -void _fatal(const char *func, const char *file, int line, const char *format, ...) - __attribute__ ((format (printf, 4, 5))) __attribute__ ((noreturn)); - -#define log(format, args...) \ - _log(__FUNCTION__,__FILE__,__LINE__, format , ## args) -#define warn(format, args...) \ - _warn(__FUNCTION__,__FILE__,__LINE__, format , ## args) -#define fatal(format, args...) \ - _fatal(__FUNCTION__,__FILE__,__LINE__, format , ## args) - int file2fd(const char *path, const char *mode, int fd); /* signal to pipe delivery implementation */ From 8a36f2425accabdfb89ab3a03eaf6c4f89b10791 Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Wed, 22 Jul 2026 20:43:05 +0700 Subject: [PATCH 12/17] use native code instead of dirutil Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/Makefile.am | 4 +- pppd/plugins/pptp/dirutil.c | 68 -------------------------------- pppd/plugins/pptp/dirutil.h | 14 ------- pppd/plugins/pptp/pptp_callmgr.c | 10 ++--- pppd/plugins/pptp/pptp_callmgr.h | 2 +- 5 files changed, 7 insertions(+), 91 deletions(-) delete mode 100644 pppd/plugins/pptp/dirutil.c delete mode 100644 pppd/plugins/pptp/dirutil.h diff --git a/pppd/plugins/pptp/Makefile.am b/pppd/plugins/pptp/Makefile.am index 120743341..22446182e 100644 --- a/pppd/plugins/pptp/Makefile.am +++ b/pppd/plugins/pptp/Makefile.am @@ -2,9 +2,9 @@ pppd_plugin_LTLIBRARIES = pptp.la pppd_plugindir = $(PPPD_PLUGIN_DIR) noinst_HEADERS = pptp_callmgr.h pptp_ctrl.h pptp_msg.h pptp_options.h \ - util.h vector.h dirutil.h pptp_quirks.h orckit_quirks.h + util.h vector.h pptp_quirks.h orckit_quirks.h pptp_la_CPPFLAGS = -I${top_srcdir} pptp_la_LDFLAGS = -module -avoid-version pptp_la_SOURCES = pptp.c pptp_callmgr.c pptp_ctrl.c util.c vector.c \ - dirutil.c pptp_quirks.c orckit_quirks.c + pptp_quirks.c orckit_quirks.c diff --git a/pppd/plugins/pptp/dirutil.c b/pppd/plugins/pptp/dirutil.c deleted file mode 100644 index e7b1a773e..000000000 --- a/pppd/plugins/pptp/dirutil.c +++ /dev/null @@ -1,68 +0,0 @@ -/* dirutil.c ... directory utilities. - * C. Scott Ananian - * - * $Id: dirutil.c,v 1.2 2003/06/17 17:25:47 reink Exp $ - */ - -#include -#include -#include -#include -#include -#include "dirutil.h" - -/* Returned malloc'ed string representing basename */ -char *basenamex(char *pathname) -{ - char *dup = strdup(pathname); - char *ptr = strrchr(stripslash(dup), '/'); - if (ptr == NULL) return dup; - ptr = strdup(ptr+1); - free(dup); - return ptr; -} - -/* Return malloc'ed string representing directory name (no trailing slash) */ -char *dirnamex(char *pathname) -{ - char *dup = strdup(pathname); - char *ptr = strrchr(stripslash(dup), '/'); - if (ptr == NULL) { free(dup); return strdup("."); } - if (ptr == dup && dup[0] == '/') ptr++; - *ptr = '\0'; - return dup; -} - -/* In-place modify a string to remove trailing slashes. Returns arg. - * stripslash("/") returns "/"; - */ -char *stripslash(char *pathname) { - int len = strlen(pathname); - while (len > 1 && pathname[len - 1] == '/') - pathname[--len] = '\0'; - return pathname; -} - -/* ensure dirname exists, creating it if necessary. */ -int make_valid_path(char *dir, mode_t mode) -{ - struct stat st; - char *tmp = NULL, *path = stripslash(strdup(dir)); - int retval; - if (stat(path, &st) == 0) { /* file exists */ - if (S_ISDIR(st.st_mode)) { retval = 1; goto end; } - else { retval = 0; goto end; } /* not a directory. Oops. */ - } - /* Directory doesn't exist. Let's make it. */ - /* Make parent first. */ - if (!make_valid_path(tmp = dirnamex(path), mode)) { retval = 0; goto end; } - /* Now make this 'un. */ - if (mkdir(path, mode) < 0) { retval = 0; goto end; } - /* Success. */ - retval = 1; - -end: - if (tmp != NULL) free(tmp); - if (path != NULL) free(path); - return retval; -} diff --git a/pppd/plugins/pptp/dirutil.h b/pppd/plugins/pptp/dirutil.h deleted file mode 100644 index 4c9aa874c..000000000 --- a/pppd/plugins/pptp/dirutil.h +++ /dev/null @@ -1,14 +0,0 @@ -/* dirutil.h ... directory utilities. - * C. Scott Ananian - * - * $Id: dirutil.h,v 1.1.1.1 2000/12/23 08:19:51 scott Exp $ - */ - -/* Returned malloc'ed string representing basename */ -char *basenamex(char *pathname); -/* Return malloc'ed string representing directory name (no trailing slash) */ -char *dirnamex(char *pathname); -/* In-place modify a string to remove trailing slashes. Returns arg. */ -char *stripslash(char *pathname); -/* ensure dirname exists, creating it if necessary. */ -int make_valid_path(char *dirname, mode_t mode); diff --git a/pppd/plugins/pptp/pptp_callmgr.c b/pppd/plugins/pptp/pptp_callmgr.c index 5c535031e..465e85955 100644 --- a/pppd/plugins/pptp/pptp_callmgr.c +++ b/pppd/plugins/pptp/pptp_callmgr.c @@ -22,10 +22,10 @@ #include "pptp_callmgr.h" #include "pptp_ctrl.h" #include "pptp_msg.h" -#include "dirutil.h" #include "vector.h" #include "util.h" #include +#include extern struct in_addr localbind; /* from pptp.c */ extern int call_ID; @@ -352,7 +352,6 @@ int open_unixsock(struct in_addr inetaddr) { struct sockaddr_un where; struct stat st; - char *dir; int s; if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { warn("socket: %s", strerror(errno)); @@ -365,10 +364,9 @@ int open_unixsock(struct in_addr inetaddr) close(s); return -1; } /* Make sure path is valid. */ - dir = dirnamex(where.sun_path); - if (!make_valid_path(dir, 0770)) + if (!mkdir_recursive(PPTP_SOCKET_PREFIX)) fatal("Could not make path to %s: %s", where.sun_path, strerror(errno)); - free(dir); + chmod(PPTP_SOCKET_PREFIX, 0770); if (bind(s, (struct sockaddr *) &where, sizeof(where)) < 0) { warn("bind: %s", strerror(errno)); close(s); return -1; @@ -403,5 +401,5 @@ void callmgr_name_unixsock(struct sockaddr_un *where, strncpy(localaddr, inet_ntoa(localbind), 16); strncpy(remoteaddr, inet_ntoa(inetaddr), 16); snprintf(where->sun_path, sizeof(where->sun_path), - PPTP_SOCKET_PREFIX "%s:%i", remoteaddr,call_ID); + PPTP_SOCKET_PREFIX "/" "%s:%i", remoteaddr,call_ID); } diff --git a/pppd/plugins/pptp/pptp_callmgr.h b/pppd/plugins/pptp/pptp_callmgr.h index d7bc2d651..ece868efe 100644 --- a/pppd/plugins/pptp/pptp_callmgr.h +++ b/pppd/plugins/pptp/pptp_callmgr.h @@ -5,7 +5,7 @@ * $Id: pptp_callmgr.h,v 1.3 2003/02/17 00:22:17 quozl Exp $ */ -#define PPTP_SOCKET_PREFIX "/var/run/pptp/" +#define PPTP_SOCKET_PREFIX "/var/run/pptp" int callmgr_main(int argc, char**argv, char**envp); void callmgr_name_unixsock(struct sockaddr_un *where, From 711405f8cc7a2150f5f2442c08250cc35b69b90a Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Fri, 7 Aug 2026 01:43:02 +0700 Subject: [PATCH 13/17] remove quirks it's very unlikely that such equipment is still exist Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/Makefile.am | 5 +- pppd/plugins/pptp/orckit_quirks.c | 83 ------------------------------- pppd/plugins/pptp/orckit_quirks.h | 27 ---------- pppd/plugins/pptp/pptp_ctrl.c | 45 ----------------- pppd/plugins/pptp/pptp_quirks.c | 54 -------------------- pppd/plugins/pptp/pptp_quirks.h | 59 ---------------------- 6 files changed, 2 insertions(+), 271 deletions(-) delete mode 100644 pppd/plugins/pptp/orckit_quirks.c delete mode 100644 pppd/plugins/pptp/orckit_quirks.h delete mode 100644 pppd/plugins/pptp/pptp_quirks.c delete mode 100644 pppd/plugins/pptp/pptp_quirks.h diff --git a/pppd/plugins/pptp/Makefile.am b/pppd/plugins/pptp/Makefile.am index 22446182e..49f25a561 100644 --- a/pppd/plugins/pptp/Makefile.am +++ b/pppd/plugins/pptp/Makefile.am @@ -2,9 +2,8 @@ pppd_plugin_LTLIBRARIES = pptp.la pppd_plugindir = $(PPPD_PLUGIN_DIR) noinst_HEADERS = pptp_callmgr.h pptp_ctrl.h pptp_msg.h pptp_options.h \ - util.h vector.h pptp_quirks.h orckit_quirks.h + util.h vector.h pptp_la_CPPFLAGS = -I${top_srcdir} pptp_la_LDFLAGS = -module -avoid-version -pptp_la_SOURCES = pptp.c pptp_callmgr.c pptp_ctrl.c util.c vector.c \ - pptp_quirks.c orckit_quirks.c +pptp_la_SOURCES = pptp.c pptp_callmgr.c pptp_ctrl.c util.c vector.c diff --git a/pppd/plugins/pptp/orckit_quirks.c b/pppd/plugins/pptp/orckit_quirks.c deleted file mode 100644 index ef284dbaf..000000000 --- a/pppd/plugins/pptp/orckit_quirks.c +++ /dev/null @@ -1,83 +0,0 @@ -/* orckit_quirks.c ...... fix quirks in orckit adsl modems - * mulix - * - * $Id: orckit_quirks.c,v 1.3 2002/03/01 01:23:36 quozl Exp $ - */ - -#include -#include -#include -#include "pptp_msg.h" -#include "pptp_options.h" -#include "pptp_ctrl.h" - -/* return 0 on success, non zero otherwise */ -int -orckit_atur3_build_hook(struct pptp_out_call_rqst* packet) -{ - unsigned int name_length = 10; - - struct pptp_out_call_rqst fixed_packet = { - PPTP_HEADER_CTRL(PPTP_OUT_CALL_RQST), - 0, /* hton16(call->callid) */ - 0, /* hton16(call->sernum) */ - hton32(PPTP_BPS_MIN), hton32(PPTP_BPS_MAX), - hton32(PPTP_BEARER_DIGITAL), hton32(PPTP_FRAME_ANY), - hton16(PPTP_WINDOW), 0, hton16(name_length), 0, - {'R','E','L','A','Y','_','P','P','P','1',0}, {0} - }; - - if (!packet) - return -1; - - memcpy(packet, &fixed_packet, sizeof(*packet)); - - return 0; -} - -/* return 0 on success, non zero otherwise */ -int -orckit_atur3_set_link_hook(struct pptp_set_link_info* packet, - int peer_call_id) -{ - struct pptp_set_link_info fixed_packet = { - PPTP_HEADER_CTRL(PPTP_SET_LINK_INFO), - hton16(peer_call_id), - 0, - 0xffffffff, - 0xffffffff}; - - if (!packet) - return -1; - - memcpy(packet, &fixed_packet, sizeof(*packet)); - return 0; -} - -/* return 0 on success, non 0 otherwise */ -int -orckit_atur3_start_ctrl_conn_hook(struct pptp_start_ctrl_conn* packet) -{ - struct pptp_start_ctrl_conn fixed_packet = { - {0}, /* we'll set the header later */ - hton16(PPTP_VERSION), 0, 0, - hton32(PPTP_FRAME_ASYNC), hton32(PPTP_BEARER_ANALOG), - hton16(0) /* max channels */, - hton16(0x6021), - {'R','E','L','A','Y','_','P','P','P','1',0}, /* hostname */ - {'M','S',' ','W','i','n',' ','N','T',0} /* vendor */ - }; - - if (!packet) - return -1; - - /* grab the header from the original packet, since we dont - know if this is a request or a reply */ - memcpy(&fixed_packet.header, &packet->header, sizeof(struct pptp_header)); - - /* and now overwrite the full packet, effectively preserving the header */ - memcpy(packet, &fixed_packet, sizeof(*packet)); - return 0; -} - - diff --git a/pppd/plugins/pptp/orckit_quirks.h b/pppd/plugins/pptp/orckit_quirks.h deleted file mode 100644 index ad0193d82..000000000 --- a/pppd/plugins/pptp/orckit_quirks.h +++ /dev/null @@ -1,27 +0,0 @@ -/* orckit_quirks.h ...... fix quirks in orckit adsl modems - * mulix - * - * $Id: orckit_quirks.h,v 1.2 2001/11/23 03:42:51 quozl Exp $ - */ - -#ifndef INC_ORCKIT_QUIRKS_H_ -#define INC_ORCKIT_QUIRKS_H_ - -#include "pptp_options.h" -#include "pptp_ctrl.h" -#include "pptp_msg.h" - -/* return 0 on success, non zero otherwise */ -int -orckit_atur3_build_hook(struct pptp_out_call_rqst* packt); - -/* return 0 on success, non zero otherwise */ -int -orckit_atur3_set_link_hook(struct pptp_set_link_info* packet, - int peer_call_id); - -/* return 0 on success, non zero otherwise */ -int -orckit_atur3_start_ctrl_conn_hook(struct pptp_start_ctrl_conn* packet); - -#endif /* INC_ORCKIT_QUIRKS_H_ */ diff --git a/pppd/plugins/pptp/pptp_ctrl.c b/pppd/plugins/pptp/pptp_ctrl.c index 2d5cf254c..5248a7893 100644 --- a/pppd/plugins/pptp/pptp_ctrl.c +++ b/pppd/plugins/pptp/pptp_ctrl.c @@ -22,7 +22,6 @@ #include "pptp_options.h" #include "vector.h" #include "util.h" -#include "pptp_quirks.h" #include /* BECAUSE OF SIGNAL LIMITATIONS, EACH PROCESS CAN ONLY MANAGE ONE @@ -185,11 +184,6 @@ int pptp_send_ctrl_packet(PPTP_CONN * conn, void * buffer, size_t size); int pptp_dispatch_packet(PPTP_CONN * conn, void * buffer, size_t size); /* Dispatch packets (control messages) */ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size); -/* Set link info, for pptp servers that need it. - this is a noop, unless the user specified a quirk and - there's a set_link hook defined in the quirks table - for that quirk */ -void pptp_set_link(PPTP_CONN * conn, int peer_call_id); /*** log error information in control packets *********************************/ static void ctrlp_error( int result, int error, int cause, @@ -297,13 +291,6 @@ PPTP_CONN * pptp_conn_open(int inet_sock, int isclient, pptp_conn_cb callback) hton16(PPTP_MAX_CHANNELS), hton16(PPTP_FIRMWARE_VERSION), PPTP_HOSTNAME, PPTP_VENDOR }; - /* fix this packet, if necessary */ - int idx, rc; - idx = get_quirk_index(); - if (idx != -1 && pptp_fixups[idx].start_ctrl_conn) { - if ((rc = pptp_fixups[idx].start_ctrl_conn(&packet))) - warn("calling the start_ctrl_conn hook failed (%d)", rc); - } if (pptp_send_ctrl_packet(conn, &packet, sizeof(packet))) conn->conn_state = CONN_WAIT_CTL_REPLY; else @@ -335,7 +322,6 @@ PPTP_CALL * pptp_call_open(PPTP_CONN * conn, int call_id,pptp_call_cb callback, char *phonenr,int window) { PPTP_CALL * call; - int idx, rc; /* Send off the call request */ struct pptp_out_call_rqst packet = { PPTP_HEADER_CTRL(PPTP_OUT_CALL_RQST), @@ -361,12 +347,6 @@ PPTP_CALL * pptp_call_open(PPTP_CONN * conn, int call_id,pptp_call_cb callback, call->closure = NULL; packet.call_id = htons(call->call_id); packet.call_sernum = htons(call->sernum); - /* if we have a quirk, build a new packet to fit it */ - idx = get_quirk_index(); - if (idx != -1 && pptp_fixups[idx].out_call_rqst_hook) { - if ((rc = pptp_fixups[idx].out_call_rqst_hook(&packet))) - warn("calling the out_call_rqst hook failed (%d)", rc); - } /* fill in the phone number if it was specified */ if (phonenr) { strncpy(packet.phone_num, phonenr, sizeof(packet.phone_num)); @@ -725,12 +705,6 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) PPTP_HOSTNAME, PPTP_VENDOR }; int idx, rc; dbglog("Received Start Control Connection Request"); - /* fix this packet, if necessary */ - idx = get_quirk_index(); - if (idx != -1 && pptp_fixups[idx].start_ctrl_conn) { - if ((rc = pptp_fixups[idx].start_ctrl_conn(&reply))) - warn("calling the start_ctrl_conn hook failed (%d)", rc); - } if (conn->conn_state == CONN_IDLE) { if (ntoh16(packet->version) < PPTP_VERSION) { /* Can't support this (earlier) PPTP_VERSION */ @@ -905,9 +879,6 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) call->peer_call_id = ntoh16(packet->call_id); call->speed = ntoh32(packet->speed); pptp_reset_timer(); - /* call pptp_set_link. unless the user specified a quirk - and this quirk has a set_link hook, this is a noop */ - pptp_set_link(conn, call->peer_call_id); if (call->callback != NULL) call->callback(conn, call, CALL_OPEN_DONE); dbglog("Outgoing call established (call ID %u, peer's " @@ -987,22 +958,6 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) return 0; } -/*** pptp_set_link **************************************************************/ -void pptp_set_link(PPTP_CONN* conn, int peer_call_id) -{ - int idx, rc; - /* if we need to send a set_link packet because of buggy - hardware or pptp server, do it now */ - if ((idx = get_quirk_index()) != -1 && pptp_fixups[idx].set_link_hook) { - struct pptp_set_link_info packet; - if ((rc = pptp_fixups[idx].set_link_hook(&packet, peer_call_id))) - warn("calling the set_link hook failed (%d)", rc); - if (pptp_send_ctrl_packet(conn, &packet, sizeof(packet))) { - pptp_reset_timer(); - } - } -} - /*** Get info from call structure *********************************************/ /* NOTE: The peer_call_id is undefined until we get a server response. */ void pptp_call_get_ids(PPTP_CONN * conn, PPTP_CALL * call, diff --git a/pppd/plugins/pptp/pptp_quirks.c b/pppd/plugins/pptp/pptp_quirks.c deleted file mode 100644 index e4c90139b..000000000 --- a/pppd/plugins/pptp/pptp_quirks.c +++ /dev/null @@ -1,54 +0,0 @@ -/* pptp_quirks.c ...... various options to fix quirks found in buggy adsl modems - * mulix - * - * $Id: pptp_quirks.c,v 1.2 2001/11/23 03:42:51 quozl Exp $ - */ - -#include -#include "orckit_quirks.h" -#include "pptp_quirks.h" - -static int quirk_index = -1; - -struct pptp_fixup pptp_fixups[] = { - {BEZEQ_ISRAEL, ORCKIT, ORCKIT_ATUR3, - orckit_atur3_build_hook, - orckit_atur3_start_ctrl_conn_hook, - orckit_atur3_set_link_hook} -}; - -static int fixups_sz = sizeof(pptp_fixups)/sizeof(pptp_fixups[0]); - -/* return 0 on success, non 0 otherwise */ -int set_quirk_index(int index) -{ - if (index >= 0 && index < fixups_sz) { - quirk_index = index; - return 0; - } - - return -1; -} - -int get_quirk_index() -{ - return quirk_index; -} - -/* return the index for this isp in the quirks table, -1 if not found */ -int find_quirk(const char* isp_name) -{ - int i = 0; - if (isp_name) { - while (i < fixups_sz && pptp_fixups[i].isp) { - if (!strcmp(pptp_fixups[i].isp, isp_name)) { - return i; - } - ++i; - } - } - - return -1; -} - - diff --git a/pppd/plugins/pptp/pptp_quirks.h b/pppd/plugins/pptp/pptp_quirks.h deleted file mode 100644 index 291f3d6df..000000000 --- a/pppd/plugins/pptp/pptp_quirks.h +++ /dev/null @@ -1,59 +0,0 @@ -/* pptp_quirks.h ...... various options to fix quirks found in buggy adsl modems - * mulix - * - * $Id: pptp_quirks.h,v 1.1 2001/11/20 06:30:10 quozl Exp $ - */ - -#ifndef INC_PPTP_QUIRKS_H -#define INC_PPTP_QUIRKS_H - -/* isp defs - correspond to slots in the fixups table */ -#define BEZEQ_ISRAEL "BEZEQ_ISRAEL" - -/* vendor defs */ - -#define ORCKIT 1 -#define ALCATEL 2 - -/* device defs */ - -#define ORCKIT_ATUR2 1 -#define ORCKIT_ATUR3 2 - -#include "pptp_msg.h" -#include "pptp_ctrl.h" - -struct pptp_fixup { - const char* isp; /* which isp? e.g. Bezeq in Israel */ - int vendor; /* which vendor? e.g. Orckit */ - int device; /* which device? e.g. Orckit Atur3 */ - - /* use this hook to build your own out call request packet */ - int (*out_call_rqst_hook)(struct pptp_out_call_rqst* packet); - - /* use this hook to build your own start control connection packet */ - /* note that this hook is called from two different places, depending - on whether this is a request or reply */ - int (*start_ctrl_conn)(struct pptp_start_ctrl_conn* packet); - - /* use this hook if you need to send a 'set_link' packet once - the connection is established */ - int (*set_link_hook)(struct pptp_set_link_info* packet, - int peer_call_id); -}; - -extern struct pptp_fixup pptp_fixups[]; - -/* find the index for this isp in the quirks table */ -/* return the index on success, -1 if not found */ -int find_quirk(const char* isp_name); - -/* set the global quirk index. return 0 on success, non 0 otherwise */ -int set_quirk_index(int index); - -/* get the global quirk index. return the index on success, - -1 if no quirk is defined */ -int get_quirk_index(); - - -#endif /* INC_PPTP_QUIRKS_H */ From 7db7079167c100c3979f263d583313bb86a4d20b Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Tue, 11 Aug 2026 09:08:16 +0700 Subject: [PATCH 14/17] use common rundir for sockets Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/Makefile.am | 2 +- pppd/plugins/pptp/pptp_callmgr.c | 8 ++------ pppd/plugins/pptp/pptp_callmgr.h | 2 -- 3 files changed, 3 insertions(+), 9 deletions(-) diff --git a/pppd/plugins/pptp/Makefile.am b/pppd/plugins/pptp/Makefile.am index 49f25a561..ccf5e615d 100644 --- a/pppd/plugins/pptp/Makefile.am +++ b/pppd/plugins/pptp/Makefile.am @@ -4,6 +4,6 @@ pppd_plugindir = $(PPPD_PLUGIN_DIR) noinst_HEADERS = pptp_callmgr.h pptp_ctrl.h pptp_msg.h pptp_options.h \ util.h vector.h -pptp_la_CPPFLAGS = -I${top_srcdir} +pptp_la_CPPFLAGS = -I${top_srcdir} -DPPPD_RUNTIME_DIR='"@PPPD_RUNTIME_DIR@"' pptp_la_LDFLAGS = -module -avoid-version pptp_la_SOURCES = pptp.c pptp_callmgr.c pptp_ctrl.c util.c vector.c diff --git a/pppd/plugins/pptp/pptp_callmgr.c b/pppd/plugins/pptp/pptp_callmgr.c index 465e85955..cf2fa05a1 100644 --- a/pppd/plugins/pptp/pptp_callmgr.c +++ b/pppd/plugins/pptp/pptp_callmgr.c @@ -26,6 +26,7 @@ #include "util.h" #include #include +#include extern struct in_addr localbind; /* from pptp.c */ extern int call_ID; @@ -363,15 +364,10 @@ int open_unixsock(struct in_addr inetaddr) warn("Call manager for %s is already running.", inet_ntoa(inetaddr)); close(s); return -1; } - /* Make sure path is valid. */ - if (!mkdir_recursive(PPTP_SOCKET_PREFIX)) - fatal("Could not make path to %s: %s", where.sun_path, strerror(errno)); - chmod(PPTP_SOCKET_PREFIX, 0770); if (bind(s, (struct sockaddr *) &where, sizeof(where)) < 0) { warn("bind: %s", strerror(errno)); close(s); return -1; } - chmod(where.sun_path, 0777); listen(s, 127); return s; } @@ -401,5 +397,5 @@ void callmgr_name_unixsock(struct sockaddr_un *where, strncpy(localaddr, inet_ntoa(localbind), 16); strncpy(remoteaddr, inet_ntoa(inetaddr), 16); snprintf(where->sun_path, sizeof(where->sun_path), - PPTP_SOCKET_PREFIX "/" "%s:%i", remoteaddr,call_ID); + PPP_PATH_VARRUN "/pptp_socket_%s:%i", remoteaddr,call_ID); } diff --git a/pppd/plugins/pptp/pptp_callmgr.h b/pppd/plugins/pptp/pptp_callmgr.h index ece868efe..5d1293eef 100644 --- a/pppd/plugins/pptp/pptp_callmgr.h +++ b/pppd/plugins/pptp/pptp_callmgr.h @@ -5,8 +5,6 @@ * $Id: pptp_callmgr.h,v 1.3 2003/02/17 00:22:17 quozl Exp $ */ -#define PPTP_SOCKET_PREFIX "/var/run/pptp" - int callmgr_main(int argc, char**argv, char**envp); void callmgr_name_unixsock(struct sockaddr_un *where, struct in_addr inetaddr, From a4b7616a547ac5d12735a23b94794f2d419c5656 Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Tue, 11 Aug 2026 10:40:21 +0700 Subject: [PATCH 15/17] use direct callmgr_main call Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/pptp.c | 25 ++++-------------------- pppd/plugins/pptp/pptp_callmgr.c | 33 +++++++++++--------------------- pppd/plugins/pptp/pptp_callmgr.h | 6 +++++- 3 files changed, 20 insertions(+), 44 deletions(-) diff --git a/pppd/plugins/pptp/pptp.c b/pppd/plugins/pptp/pptp.c index 0b420b00e..56d1ecce4 100644 --- a/pppd/plugins/pptp/pptp.c +++ b/pppd/plugins/pptp/pptp.c @@ -44,6 +44,7 @@ #include #include #include +#include #include "pptp_callmgr.h" #include @@ -114,9 +115,7 @@ static int pptp_start_server(void) { pptp_fd=pptp_sock; - char _tmp_buf[64]; - snprintf(_tmp_buf, sizeof(_tmp_buf), "pptp (%s)", pptp_client); - ppp_set_devnam(_tmp_buf); + sprintf(ppp_devname,"pptp (%s)",pptp_client); return pptp_fd; } @@ -206,9 +205,7 @@ static int pptp_start_client(void) return -1; } - char _tmp_buf[64]; - snprintf(_tmp_buf, sizeof(_tmp_buf), "pptp (%s)", pptp_server); - ppp_set_devnam(_tmp_buf); + sprintf(ppp_devname,"pptp (%s)",pptp_server); return pptp_fd; } @@ -265,7 +262,7 @@ static int open_callmgr(int call_id,struct in_addr inetaddr, char *phonenr,int w /* close the pty and gre in the call manager */ // close(pty_fd); //close(gre_fd); - launch_callmgr(call_id,inetaddr, phonenr,window); + callmgr_main(call_id, inetaddr, phonenr, window); } default: /* parent */ waitpid(pid, &status, 0); @@ -288,20 +285,6 @@ static int open_callmgr(int call_id,struct in_addr inetaddr, char *phonenr,int w return -1; /* make gcc happy */ } -/*** 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]; - sprintf(win,"%u",window); - sprintf(call,"%u",call_id); - snprintf(buf, sizeof(buf), "pptp: call manager for %s", my_argv[1]); - //inststr(argc, argv, envp, buf); - exit(callmgr_main(8, my_argv, environ)); -} - /*** exchange data with the call manager *************************************/ /* XXX need better error checking XXX */ static int get_call_id(int sock, pid_t gre, pid_t pppd, diff --git a/pppd/plugins/pptp/pptp_callmgr.c b/pppd/plugins/pptp/pptp_callmgr.c index cf2fa05a1..98a99512e 100644 --- a/pppd/plugins/pptp/pptp_callmgr.c +++ b/pppd/plugins/pptp/pptp_callmgr.c @@ -104,9 +104,8 @@ void call_callback(PPTP_CONN *conn, PPTP_CALL *call, enum call_state state) *****************************************************************************/ /*** Call Manager *************************************************************/ -int callmgr_main(int argc, char **argv, char **envp) +int callmgr_main(int pcallid, struct in_addr inetaddr, char phonenr[], int window) { - struct in_addr inetaddr; int inet_sock, unix_sock; fd_set call_set; PPTP_CONN * conn; @@ -115,29 +114,19 @@ int callmgr_main(int argc, char **argv, char **envp) volatile int first = 1; int retval; int i; - char * volatile phonenr=NULL; - int volatile window=10; - //int volatile call_id=0; - /* Step 0: Check arguments */ - if (argc < 2) - fatal("Usage: %s ip.add.ress.here [--phone ]", argv[0]); - //phonenr = argc == 3 ? argv[2] : NULL; - for(i=2; i 0) call_ID = pcallid; + + dbglog("pptp: call manager for %s\n", inet_ntoa(inetaddr)); + dbglog("window: %d, call_id: %d\n", window, call_ID); + if (phonenr) dbglog("phone number:\t'%s'\n", phonenr); + /* Step 1: Open sockets. */ if ((inet_sock = open_inetsock(inetaddr)) < 0) - fatal("Could not open control connection to %s", argv[1]); + fatal("Could not open control connection to %s", inet_ntoa(inetaddr)); dbglog("control connection"); if ((unix_sock = open_unixsock(inetaddr)) < 0) - fatal("Could not open unix socket for %s", argv[1]); + fatal("Could not open unix socket for %s", inet_ntoa(inetaddr)); /* Step 1b: FORK and return status to calling process. */ dbglog("unix_sock"); @@ -317,7 +306,7 @@ int callmgr_main(int argc, char **argv, char **envp) signal(SIGTERM, callmgr_do_nothing); close_inetsock(inet_sock, inetaddr); close_unixsock(unix_sock, inetaddr); - return 0; + exit(0); // work done, terminate fork } /*** open_inetsock ************************************************************/ diff --git a/pppd/plugins/pptp/pptp_callmgr.h b/pppd/plugins/pptp/pptp_callmgr.h index 5d1293eef..a9ad37e61 100644 --- a/pppd/plugins/pptp/pptp_callmgr.h +++ b/pppd/plugins/pptp/pptp_callmgr.h @@ -5,7 +5,11 @@ * $Id: pptp_callmgr.h,v 1.3 2003/02/17 00:22:17 quozl Exp $ */ -int callmgr_main(int argc, char**argv, char**envp); +int callmgr_main(int pcallid, + struct in_addr inetaddr, + char phonenr[], + int window); + void callmgr_name_unixsock(struct sockaddr_un *where, struct in_addr inetaddr, struct in_addr localbind); From 134e1b3f1a2c0dc399aa7fdcaa8cb67bf97adb87 Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Tue, 11 Aug 2026 12:16:07 +0700 Subject: [PATCH 16/17] headers cleanup Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/pptp_ctrl.c | 126 +++++++++++++++---------------- pppd/plugins/pptp/pptp_msg.h | 54 +------------ pppd/plugins/pptp/pptp_options.h | 15 ---- 3 files changed, 67 insertions(+), 128 deletions(-) diff --git a/pppd/plugins/pptp/pptp_ctrl.c b/pppd/plugins/pptp/pptp_ctrl.c index 5248a7893..301e6ab65 100644 --- a/pppd/plugins/pptp/pptp_ctrl.c +++ b/pppd/plugins/pptp/pptp_ctrl.c @@ -236,7 +236,7 @@ static void ctrlp_rep( void * buffer, int size, int isbuff) struct pptp_header *packet = buffer; unsigned int type; if(size < sizeof(struct pptp_header)) return; - type = ntoh16(packet->ctrl_type); + type = ntohs(packet->ctrl_type); /* FIXME: do not report sending echo requests as long as they are * sent in a signal handler. This may dead lock as the syslog call * is not reentrant */ @@ -286,9 +286,9 @@ PPTP_CONN * pptp_conn_open(int inet_sock, int isclient, pptp_conn_cb callback) if (isclient) { struct pptp_start_ctrl_conn packet = { PPTP_HEADER_CTRL(PPTP_START_CTRL_CONN_RQST), - hton16(PPTP_VERSION), 0, 0, - hton32(PPTP_FRAME_CAP), hton32(PPTP_BEARER_CAP), - hton16(PPTP_MAX_CHANNELS), hton16(PPTP_FIRMWARE_VERSION), + htons(PPTP_VERSION), 0, 0, + htonl(PPTP_FRAME_CAP), htonl(PPTP_BEARER_CAP), + htons(PPTP_MAX_CHANNELS), htons(PPTP_FIRMWARE_VERSION), PPTP_HOSTNAME, PPTP_VENDOR }; if (pptp_send_ctrl_packet(conn, &packet, sizeof(packet))) @@ -326,9 +326,9 @@ PPTP_CALL * pptp_call_open(PPTP_CONN * conn, int call_id,pptp_call_cb callback, struct pptp_out_call_rqst packet = { PPTP_HEADER_CTRL(PPTP_OUT_CALL_RQST), 0,0, /*call_id, sernum */ - hton32(PPTP_BPS_MIN), hton32(PPTP_BPS_MAX), - hton32(PPTP_BEARER_CAP), hton32(PPTP_FRAME_CAP), - hton16(window), 0, 0, 0, {0}, {0} + htonl(PPTP_BPS_MIN), htonl(PPTP_BPS_MAX), + htonl(PPTP_BEARER_CAP), htonl(PPTP_FRAME_CAP), + htons(window), 0, 0, 0, {0}, {0} }; assert(conn && conn->call); assert(conn->conn_state == CONN_ESTABLISHED); @@ -353,7 +353,7 @@ PPTP_CALL * pptp_call_open(PPTP_CONN * conn, int call_id,pptp_call_cb callback, packet.phone_len = strlen(phonenr); if( packet.phone_len > sizeof(packet.phone_num)) packet.phone_len = sizeof(packet.phone_num); - packet.phone_len = hton16 (packet.phone_len); + packet.phone_len = htons(packet.phone_len); } if (pptp_send_ctrl_packet(conn, &packet, sizeof(packet))) { pptp_reset_timer(); @@ -378,7 +378,7 @@ void pptp_call_close(PPTP_CONN * conn, PPTP_CALL * call) /* haven't thought about PAC yet */ assert(call->call_type == PPTP_CALL_PNS); assert(call->state.pns != PNS_IDLE); - rqst.call_id = hton16(call->call_id); + rqst.call_id = htons(call->call_id); /* don't check state against WAIT_DISCONNECT... allow multiple disconnect * requests to be made. */ @@ -406,7 +406,7 @@ void pptp_conn_close(PPTP_CONN * conn, u_int8_t close_reason) { struct pptp_stop_ctrl_conn rqst = { PPTP_HEADER_CTRL(PPTP_STOP_CTRL_CONN_RQST), - hton8(close_reason), 0, 0 + close_reason, 0, 0 }; int i; assert(conn && conn->call); @@ -564,23 +564,23 @@ int pptp_make_packet(PPTP_CONN * conn, void **buf, size_t *size) while ((conn->read_size-bad_bytes) >= sizeof(struct pptp_header)) { /* Throw out bytes until we have a valid header. */ header = (struct pptp_header *) (conn->read_buffer + bad_bytes); - if (ntoh32(header->magic) != PPTP_MAGIC) goto throwitout; - if (ntoh16(header->reserved0) != 0) + if (ntohl(header->magic) != PPTP_MAGIC) goto throwitout; + if (ntohs(header->reserved0) != 0) warn("reserved0 field is not zero! (0x%x) Cisco feature? \n", - ntoh16(header->reserved0)); - if (ntoh16(header->length) < sizeof(struct pptp_header)) goto throwitout; - if (ntoh16(header->length) > PPTP_CTRL_SIZE_MAX) goto throwitout; + ntohs(header->reserved0)); + if (ntohs(header->length) < sizeof(struct pptp_header)) goto throwitout; + if (ntohs(header->length) > PPTP_CTRL_SIZE_MAX) goto throwitout; /* well. I guess it's good. Let's see if we've got it all. */ - if (ntoh16(header->length) > (conn->read_size-bad_bytes)) + if (ntohs(header->length) > (conn->read_size-bad_bytes)) /* nope. Let's wait until we've got it, then. */ goto flushbadbytes; /* One last check: */ - if ((ntoh16(header->pptp_type) == PPTP_MESSAGE_CONTROL) && - (ntoh16(header->length) != - PPTP_CTRL_SIZE(ntoh16(header->ctrl_type)))) + if ((ntohs(header->pptp_type) == PPTP_MESSAGE_CONTROL) && + (ntohs(header->length) != + PPTP_CTRL_SIZE(ntohs(header->ctrl_type)))) goto throwitout; /* well, I guess we've got it. */ - *size = ntoh16(header->length); + *size = ntohs(header->length); *buf = malloc(*size); if (*buf == NULL) { warn("Out of memory."); return 0; /* ack! */ } memcpy(*buf, conn->read_buffer + bad_bytes, *size); @@ -647,9 +647,9 @@ int pptp_dispatch_packet(PPTP_CONN * conn, void * buffer, size_t size) int r = 0; struct pptp_header *header = (struct pptp_header *)buffer; assert(conn && conn->call); assert(buffer); - assert(ntoh32(header->magic) == PPTP_MAGIC); - assert(ntoh16(header->length) == size); - switch (ntoh16(header->pptp_type)) { + assert(ntohl(header->magic) == PPTP_MAGIC); + assert(ntohs(header->length) == size); + switch (ntohs(header->pptp_type)) { case PPTP_MESSAGE_CONTROL: r = ctrlp_disp(conn, buffer, size); break; @@ -659,7 +659,7 @@ int pptp_dispatch_packet(PPTP_CONN * conn, void * buffer, size_t size) break; default: dbglog("Unknown PPTP control message type received: %u", - (unsigned int) ntoh16(header->pptp_type)); + (unsigned int) ntohs(header->pptp_type)); break; } return r; @@ -683,15 +683,15 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) struct pptp_header *header = (struct pptp_header *)buffer; u_int8_t close_reason = PPTP_STOP_NONE; assert(conn && conn->call); assert(buffer); - assert(ntoh32(header->magic) == PPTP_MAGIC); - assert(ntoh16(header->length) == size); - assert(ntoh16(header->pptp_type) == PPTP_MESSAGE_CONTROL); - if (size < PPTP_CTRL_SIZE(ntoh16(header->ctrl_type))) { + assert(ntohl(header->magic) == PPTP_MAGIC); + assert(ntohs(header->length) == size); + assert(ntohs(header->pptp_type) == PPTP_MESSAGE_CONTROL); + if (size < PPTP_CTRL_SIZE(ntohs(header->ctrl_type))) { warn("Invalid packet received [type: %d; length: %d].", - (int) ntoh16(header->ctrl_type), (int) size); + (int) ntohs(header->ctrl_type), (int) size); return 0; } - switch (ntoh16(header->ctrl_type)) { + switch (ntohs(header->ctrl_type)) { /* ----------- STANDARD Start-Session MESSAGES ------------ */ case PPTP_START_CTRL_CONN_RQST: { @@ -699,18 +699,18 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) (struct pptp_start_ctrl_conn *) buffer; struct pptp_start_ctrl_conn reply = { PPTP_HEADER_CTRL(PPTP_START_CTRL_CONN_RPLY), - hton16(PPTP_VERSION), 0, 0, - hton32(PPTP_FRAME_CAP), hton32(PPTP_BEARER_CAP), - hton16(PPTP_MAX_CHANNELS), hton16(PPTP_FIRMWARE_VERSION), + htons(PPTP_VERSION), 0, 0, + htonl(PPTP_FRAME_CAP), htonl(PPTP_BEARER_CAP), + htons(PPTP_MAX_CHANNELS), htons(PPTP_FIRMWARE_VERSION), PPTP_HOSTNAME, PPTP_VENDOR }; int idx, rc; dbglog("Received Start Control Connection Request"); if (conn->conn_state == CONN_IDLE) { - if (ntoh16(packet->version) < PPTP_VERSION) { + if (ntohs(packet->version) < PPTP_VERSION) { /* Can't support this (earlier) PPTP_VERSION */ reply.version = packet->version; /* protocol version not supported */ - reply.result_code = hton8(5); + reply.result_code = 5; if (pptp_send_ctrl_packet(conn, &reply, sizeof(reply))) pptp_reset_timer(); /* give sender a chance for a retry */ } else { /* same or greater version */ @@ -730,20 +730,20 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) dbglog("Received Start Control Connection Reply"); if (conn->conn_state == CONN_WAIT_CTL_REPLY) { /* XXX handle collision XXX [see rfc] */ - if (ntoh16(packet->version) != PPTP_VERSION) { + if (ntohs(packet->version) != PPTP_VERSION) { if (conn->callback != NULL) conn->callback(conn, CONN_OPEN_FAIL); close_reason = PPTP_STOP_PROTOCOL; goto pptp_conn_close; } - if (ntoh8(packet->result_code) != 1 && + if (packet->result_code != 1 && /* J'ai change le if () afin que la connection ne se ferme * pas pour un "rien" :p adel@cybercable.fr - * * Don't close the connection if the result code is zero * (feature found in certain ADSL modems) */ - ntoh8(packet->result_code) != 0) { + packet->result_code != 0) { dbglog("Negative reply received to our Start Control " "Connection Request"); ctrlp_error(packet->result_code, packet->error_code, @@ -756,8 +756,8 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) } conn->conn_state = CONN_ESTABLISHED; /* log session properties */ - conn->version = ntoh16(packet->version); - conn->firmware_rev = ntoh16(packet->firmware_rev); + conn->version = ntohs(packet->version); + conn->firmware_rev = ntohs(packet->firmware_rev); memcpy(conn->hostname, packet->hostname, sizeof(conn->hostname)); memcpy(conn->vendor, packet->vendor, sizeof(conn->vendor)); pptp_reset_timer(); /* 60 seconds until keep-alive */ @@ -774,7 +774,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) * something else */ struct pptp_stop_ctrl_conn reply = { PPTP_HEADER_CTRL(PPTP_STOP_CTRL_CONN_RPLY), - hton8(1), hton8(PPTP_GENERAL_ERROR_NONE), 0 + 1, PPTP_GENERAL_ERROR_NONE, 0 }; dbglog("Received Stop Control Connection Request."); if (conn->conn_state == CONN_IDLE) break; @@ -802,7 +802,7 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) (struct pptp_echo_rply *) buffer; logecho( PPTP_ECHO_RPLY); if ((conn->ka_state == KA_OUTSTANDING) && - (ntoh32(packet->identifier) == conn->ka_id)) { + (ntohl(packet->identifier) == conn->ka_id)) { conn->ka_id++; conn->ka_state = KA_NONE; pptp_reset_timer(); @@ -815,8 +815,8 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) (struct pptp_echo_rqst *) buffer; struct pptp_echo_rply reply = { PPTP_HEADER_CTRL(PPTP_ECHO_RPLY), - packet->identifier, /* skip hton32(ntoh32(id)) */ - hton8(1), hton8(PPTP_GENERAL_ERROR_NONE), 0 + packet->identifier, /* skip htonl(ntohl(id)) */ + 1, PPTP_GENERAL_ERROR_NONE, 0 }; logecho( PPTP_ECHO_RQST); if(pptp_send_ctrl_packet(conn, &reply, sizeof(reply))) @@ -831,12 +831,12 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) struct pptp_out_call_rply reply = { PPTP_HEADER_CTRL(PPTP_OUT_CALL_RPLY), 0 /* callid */, packet->call_id, 1, PPTP_GENERAL_ERROR_NONE, 0, - hton32(PPTP_CONNECT_SPEED), - hton16(PPTP_WINDOW), hton16(PPTP_DELAY), 0 + htonl(PPTP_CONNECT_SPEED), + htons(PPTP_WINDOW), htons(PPTP_DELAY), 0 }; dbglog("Received Outgoing Call Request."); /* XXX PAC: eventually this should make an outgoing call. XXX */ - reply.result_code = hton8(7); /* outgoing calls verboten */ + reply.result_code = 7; /* outgoing calls verboten */ pptp_send_ctrl_packet(conn, &reply, sizeof(reply)); break; } @@ -845,12 +845,12 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) struct pptp_out_call_rply *packet = (struct pptp_out_call_rply *)buffer; PPTP_CALL * call; - u_int16_t callid = ntoh16(packet->call_id_peer); + u_int16_t callid = ntohs(packet->call_id_peer); dbglog("Received Outgoing Call Reply."); if (!vector_search(conn->call, (int) callid, &call)) { dbglog("PPTP_OUT_CALL_RPLY received for non-existant call: " "peer call ID (us) %d call ID (them) %d.", - callid, ntoh16(packet->call_id)); + callid, ntohs(packet->call_id)); break; } if (call->call_type != PPTP_CALL_PNS) { @@ -876,8 +876,8 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) } else { /* connection established */ call->state.pns = PNS_ESTABLISHED; - call->peer_call_id = ntoh16(packet->call_id); - call->speed = ntoh32(packet->speed); + call->peer_call_id = ntohs(packet->call_id); + call->speed = ntohl(packet->speed); pptp_reset_timer(); if (call->callback != NULL) call->callback(conn, call, CALL_OPEN_DONE); @@ -898,9 +898,9 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) 1, PPTP_GENERAL_ERROR_NONE, 0, 0, {0} }; dbglog("Received Call Clear Request."); - if (vector_contains(conn->call, ntoh16(packet->call_id))) { + if (vector_contains(conn->call, ntohs(packet->call_id))) { PPTP_CALL * call; - vector_search(conn->call, ntoh16(packet->call_id), &call); + vector_search(conn->call, ntohs(packet->call_id), &call); if (call->callback != NULL) call->callback(conn, call, CALL_CLOSE_RQST); if (pptp_send_ctrl_packet(conn, &reply, sizeof(reply))) { @@ -915,13 +915,13 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) struct pptp_call_clear_ntfy *packet = (struct pptp_call_clear_ntfy *)buffer; dbglog("Call disconnect notification received (call id %d)", - ntoh16(packet->call_id)); - if (vector_contains(conn->call, ntoh16(packet->call_id))) { + ntohs(packet->call_id)); + if (vector_contains(conn->call, ntohs(packet->call_id))) { PPTP_CALL * call; ctrlp_error(packet->result_code, packet->error_code, packet->cause_code, pptp_call_disc_ntfy, MAX_CALL_DISC_NTFY); - vector_search(conn->call, ntoh16(packet->call_id), &call); + vector_search(conn->call, ntohs(packet->call_id), &call); pptp_call_destroy(conn, call); } /* XXX we could log call stats here XXX */ @@ -936,18 +936,18 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) (struct pptp_set_link_info *)buffer; /* log it. */ dbglog("PPTP_SET_LINK_INFO received from peer_callid %u", - (unsigned int) ntoh16(packet->call_id_peer)); + (unsigned int) ntohs(packet->call_id_peer)); dbglog(" send_accm is %08lX, recv_accm is %08lX", - (unsigned long) ntoh32(packet->send_accm), - (unsigned long) ntoh32(packet->recv_accm)); - if (!(ntoh32(packet->send_accm) == 0 && - ntoh32(packet->recv_accm) == 0)) + (unsigned long) ntohl(packet->send_accm), + (unsigned long) ntohl(packet->recv_accm)); + if (!(ntohl(packet->send_accm) == 0 && + ntohl(packet->recv_accm) == 0)) warn("Non-zero Async Control Character Maps are not supported!"); break; } default: dbglog("Unrecognized Packet %d received.", - (int) ntoh16(((struct pptp_header *)buffer)->ctrl_type)); + (int) ntohs(((struct pptp_header *)buffer)->ctrl_type)); /* goto pptp_conn_close; */ break; } @@ -1028,7 +1028,7 @@ static void pptp_handle_timer() pptp_conn_close(global.conn, PPTP_STOP_NONE); } else { /* ka_state == NONE */ /* send keep-alive */ struct pptp_echo_rqst rqst = { - PPTP_HEADER_CTRL(PPTP_ECHO_RQST), hton32(global.conn->ka_id) }; + PPTP_HEADER_CTRL(PPTP_ECHO_RQST), htonl(global.conn->ka_id) }; if(pptp_send_ctrl_packet(global.conn, &rqst, sizeof(rqst))) global.conn->ka_state = KA_OUTSTANDING; } diff --git a/pppd/plugins/pptp/pptp_msg.h b/pppd/plugins/pptp/pptp_msg.h index e50ce0cda..2881ab5a7 100644 --- a/pppd/plugins/pptp/pptp_msg.h +++ b/pppd/plugins/pptp/pptp_msg.h @@ -7,16 +7,6 @@ #ifndef INC_PPTP_H #define INC_PPTP_H -/* Grab definitions of int16, int32, etc. */ -#include -/* define "portable" htons, etc. */ -#define hton8(x) (x) -#define ntoh8(x) (x) -#define hton16(x) htons(x) -#define ntoh16(x) ntohs(x) -#define hton32(x) htonl(x) -#define ntoh32(x) ntohl(x) - /* PPTP magic numbers: ----------------------------------------- */ #define PPTP_MAGIC 0x1A2B3C4D /* Magic cookie for PPTP datagrams */ @@ -226,18 +216,11 @@ struct pptp_set_link_info { /* for control message type 15 */ }; /* helpful #defines: -------------------------------------------- */ -#define pptp_isvalid_ctrl(header, type, length) \ - (!( ( ntoh16(((struct pptp_header *)header)->length) < (length) ) || \ - ( ntoh16(((struct pptp_header *)header)->pptp_type) !=(type) ) || \ - ( ntoh32(((struct pptp_header *)header)->magic) !=PPTP_MAGIC) || \ - ( ntoh16(((struct pptp_header *)header)->ctrl_type) > PPTP_SET_LINK_INFO) || \ - ( ntoh16(((struct pptp_header *)header)->reserved0) !=0 ) )) - #define PPTP_HEADER_CTRL(type) \ -{ hton16(PPTP_CTRL_SIZE(type)), \ - hton16(PPTP_MESSAGE_CONTROL), \ - hton32(PPTP_MAGIC), \ - hton16(type), 0 } +{ htons(PPTP_CTRL_SIZE(type)), \ + htons(PPTP_MESSAGE_CONTROL), \ + htonl(PPTP_MAGIC), \ + htons(type), 0 } #define PPTP_CTRL_SIZE(type) ( \ (type==PPTP_START_CTRL_CONN_RQST)?sizeof(struct pptp_start_ctrl_conn): \ @@ -271,33 +254,4 @@ max(sizeof(struct pptp_call_clear_ntfy), \ max(sizeof(struct pptp_wan_err_ntfy), \ max(sizeof(struct pptp_set_link_info), 0))))))))))))) - -/* gre header structure: -------------------------------------------- */ - -#define PPTP_GRE_PROTO 0x880B -#define PPTP_GRE_VER 0x1 - -#define PPTP_GRE_FLAG_C 0x80 -#define PPTP_GRE_FLAG_R 0x40 -#define PPTP_GRE_FLAG_K 0x20 -#define PPTP_GRE_FLAG_S 0x10 -#define PPTP_GRE_FLAG_A 0x80 - -#define PPTP_GRE_IS_C(f) ((f)&PPTP_GRE_FLAG_C) -#define PPTP_GRE_IS_R(f) ((f)&PPTP_GRE_FLAG_R) -#define PPTP_GRE_IS_K(f) ((f)&PPTP_GRE_FLAG_K) -#define PPTP_GRE_IS_S(f) ((f)&PPTP_GRE_FLAG_S) -#define PPTP_GRE_IS_A(f) ((f)&PPTP_GRE_FLAG_A) - -struct pptp_gre_header { - u_int8_t flags; /* bitfield */ - u_int8_t ver; /* should be PPTP_GRE_VER (enhanced GRE) */ - u_int16_t protocol; /* should be PPTP_GRE_PROTO (ppp-encaps) */ - u_int16_t payload_len; /* size of ppp payload, not inc. gre header */ - u_int16_t call_id; /* peer's call_id for this session */ - u_int32_t seq; /* sequence number. Present if S==1 */ - u_int32_t ack; /* seq number of highest packet recieved by */ - /* sender in this session */ -}; - #endif /* INC_PPTP_H */ diff --git a/pppd/plugins/pptp/pptp_options.h b/pppd/plugins/pptp/pptp_options.h index ebc1c316e..18072dd22 100644 --- a/pppd/plugins/pptp/pptp_options.h +++ b/pppd/plugins/pptp/pptp_options.h @@ -1,5 +1,4 @@ /* pptp_options.h ...... various constants used in the PPTP protocol. - * #define STANDARD to emulate NT 4.0 exactly. * C. Scott Ananian * * $Id: pptp_options.h,v 1.3 2004/11/09 01:42:32 quozl Exp $ @@ -8,9 +7,6 @@ #ifndef INC_PPTP_OPTIONS_H #define INC_PPTP_OPTIONS_H -#undef PPTP_FIRMWARE_STRING -#undef PPTP_FIRMWARE_VERSION -#define PPTP_BUF_MAX 65536 #define PPTP_TIMEOUT 60 /* seconds */ extern int idle_wait; extern int max_echo_wait; @@ -20,22 +16,11 @@ extern int max_echo_wait; #define PPTP_BPS_MIN 2400 #define PPTP_BPS_MAX 1000000000 -#ifndef STANDARD #define PPTP_MAX_CHANNELS 65535 -#define PPTP_FIRMWARE_STRING "0.01" #define PPTP_FIRMWARE_VERSION 0x001 #define PPTP_HOSTNAME {'l','o','c','a','l',0} #define PPTP_VENDOR {'c','a','n','a','n','i','a','n',0} #define PPTP_FRAME_CAP PPTP_FRAME_ANY #define PPTP_BEARER_CAP PPTP_BEARER_ANY -#else -#define PPTP_MAX_CHANNELS 5 -#define PPTP_FIRMWARE_STRING "0.01" -#define PPTP_FIRMWARE_VERSION 0 -#define PPTP_HOSTNAME {'l','o','c','a','l',0} -#define PPTP_VENDOR {'N','T',0} -#define PPTP_FRAME_CAP 2 -#define PPTP_BEARER_CAP 1 -#endif #endif /* INC_PPTP_OPTIONS_H */ From e1611d5bea5c57b818fa2b9132d21a215b4cc17c Mon Sep 17 00:00:00 2001 From: "[anp/hsw]" Date: Tue, 11 Aug 2026 12:32:53 +0700 Subject: [PATCH 17/17] remove unused code Signed-off-by: [anp/hsw] --- pppd/plugins/pptp/pptp.c | 13 ------------- pppd/plugins/pptp/pptp_callmgr.c | 7 ------- pppd/plugins/pptp/pptp_ctrl.c | 1 - 3 files changed, 21 deletions(-) diff --git a/pppd/plugins/pptp/pptp.c b/pppd/plugins/pptp/pptp.c index 56d1ecce4..cffaa22d9 100644 --- a/pppd/plugins/pptp/pptp.c +++ b/pppd/plugins/pptp/pptp.c @@ -93,20 +93,15 @@ static option_t Options[] = }; static int pptp_connect(void); -//static void pptp_send_config(int mtu,u_int32_t asyncmap,int pcomp,int accomp); -//static void pptp_recv_config(int mru,u_int32_t asyncmap,int pcomp,int accomp); static void pptp_disconnect(void); struct channel pptp_channel = { options: Options, - //process_extra_options: &PPPOEDeviceOptions, check_options: NULL, connect: &pptp_connect, disconnect: &pptp_disconnect, establish_ppp: &ppp_generic_establish, disestablish_ppp: &ppp_generic_disestablish, - //send_config: &pptp_send_config, - //recv_config: &pptp_recv_config, close: NULL, cleanup: NULL }; @@ -151,10 +146,6 @@ static int pptp_start_client(void) 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; @@ -259,9 +250,6 @@ static int open_callmgr(int call_id,struct in_addr inetaddr, char *phonenr,int w { close (fd); close(pptp_fd); - /* close the pty and gre in the call manager */ - // close(pty_fd); - //close(gre_fd); callmgr_main(call_id, inetaddr, phonenr, window); } default: /* parent */ @@ -332,4 +320,3 @@ void plugin_init(void) the_channel = &pptp_channel; ppp_set_modem(0); } - diff --git a/pppd/plugins/pptp/pptp_callmgr.c b/pppd/plugins/pptp/pptp_callmgr.c index 98a99512e..f7453b5bc 100644 --- a/pppd/plugins/pptp/pptp_callmgr.c +++ b/pppd/plugins/pptp/pptp_callmgr.c @@ -86,8 +86,6 @@ void call_callback(PPTP_CONN *conn, PPTP_CALL *call, enum call_state state) vector_remove(conninfo->call_list, lci->unix_sock); close(lci->unix_sock); FD_CLR(lci->unix_sock, conninfo->call_set); - //if(lci->pid[0] > 1) kill(lci->pid[0], SIGTERM); - //if(lci->pid[1] > 1) kill(lci->pid[1], SIGTERM); } break; default: @@ -236,8 +234,6 @@ int callmgr_main(int pcallid, struct in_addr inetaddr, char phonenr[], int windo struct local_callinfo *lci = pptp_call_closure_get(conn, call); dbglog("Closing connection (unhandled)"); - //if(lci->pid[0] > 1) kill(lci->pid[0], SIGTERM); - //if(lci->pid[1] > 1) kill(lci->pid[1], SIGTERM); free(lci); /* soft shutdown. Callback will do hard shutdown later */ pptp_call_close(conn, call); @@ -258,11 +254,8 @@ int callmgr_main(int pcallid, struct in_addr inetaddr, char phonenr[], int windo /* kill all open calls */ for (i = 0; i < vector_size(call_list); i++) { PPTP_CALL *call = vector_get_Nth(call_list, i); - //struct local_callinfo *lci = pptp_call_closure_get(conn, call); dbglog("Closing connection (shutdown)"); pptp_call_close(conn, call); - //if(lci->pid[0] > 1) kill(lci->pid[0], SIGTERM); - //if(lci->pid[1] > 1) kill(lci->pid[1], SIGTERM); } /* attempt to dispatch these messages */ FD_ZERO(&read_set); diff --git a/pppd/plugins/pptp/pptp_ctrl.c b/pppd/plugins/pptp/pptp_ctrl.c index 301e6ab65..708705905 100644 --- a/pppd/plugins/pptp/pptp_ctrl.c +++ b/pppd/plugins/pptp/pptp_ctrl.c @@ -703,7 +703,6 @@ int ctrlp_disp(PPTP_CONN * conn, void * buffer, size_t size) htonl(PPTP_FRAME_CAP), htonl(PPTP_BEARER_CAP), htons(PPTP_MAX_CHANNELS), htons(PPTP_FIRMWARE_VERSION), PPTP_HOSTNAME, PPTP_VENDOR }; - int idx, rc; dbglog("Received Start Control Connection Request"); if (conn->conn_state == CONN_IDLE) { if (ntohs(packet->version) < PPTP_VERSION) {