diff options
Diffstat (limited to 'package/ppp/patches/500-add-pptp-plugin.patch')
| -rw-r--r-- | package/ppp/patches/500-add-pptp-plugin.patch | 3065 |
1 files changed, 0 insertions, 3065 deletions
diff --git a/package/ppp/patches/500-add-pptp-plugin.patch b/package/ppp/patches/500-add-pptp-plugin.patch deleted file mode 100644 index d984e1b..0000000 --- a/package/ppp/patches/500-add-pptp-plugin.patch +++ /dev/null @@ -1,3065 +0,0 @@ ---- a/configure -+++ b/configure -@@ -195,7 +195,7 @@ if [ -d "$ksrc" ]; then - mkmkf $ksrc/Makedefs$compiletype Makedefs.com - for dir in pppd pppstats chat pppdump pppd/plugins pppd/plugins/rp-pppoe \ - pppd/plugins/radius pppd/plugins/pppoatm \ -- pppd/plugins/pppol2tp; do -+ pppd/plugins/pppol2tp pppd/plugins/pptp ; do - mkmkf $dir/Makefile.$makext $dir/Makefile - done - if [ -f $ksrc/Makefile.$makext$archvariant ]; then ---- a/pppd/plugins/Makefile.linux -+++ b/pppd/plugins/Makefile.linux -@@ -9,7 +9,7 @@ BINDIR = $(DESTDIR)/sbin - MANDIR = $(DESTDIR)/share/man/man8 - LIBDIR = $(DESTDIR)/lib/pppd/$(VERSION) - --SUBDIRS := rp-pppoe pppoatm pppol2tp -+SUBDIRS := rp-pppoe pppoatm pppol2tp pptp - # Uncomment the next line to include the radius authentication plugin - SUBDIRS += radius - PLUGINS := minconn.so passprompt.so passwordfd.so winbind.so ---- /dev/null -+++ b/pppd/plugins/pptp/Makefile.linux -@@ -0,0 +1,31 @@ -+# -+# This program may be distributed according to the terms of the GNU -+# General Public License, version 2 or (at your option) any later version. -+# -+# $Id: Makefile.linux,v 1.9 2012/05/04 21:48:00 dgolle Exp $ -+#*********************************************************************** -+ -+DESTDIR = $(INSTROOT)@DESTDIR@ -+LIBDIR = $(DESTDIR)/lib/pppd/$(PPPDVERSION) -+ -+PPPDVERSION = $(shell awk -F '"' '/VERSION/ { print $$2; }' ../../patchlevel.h) -+ -+INSTALL = install -+ -+COPTS=-O2 -g -+CFLAGS = $(COPTS) -I. -I../.. -I../../../include -fPIC -DPPPD_VERSION=\"$(PPPDVERSION)\" -+all: pptp.so -+ -+%.o: %.c -+ $(CC) $(CFLAGS) -c -o $@ $< -+ -+pptp.so: dirutil.o orckit_quirks.o pptp.o pptp_callmgr.o pptp_ctrl.o pptp_quirks.o util.o vector.o -+ $(CC) -o pptp.so -shared dirutil.o orckit_quirks.o pptp.o pptp_callmgr.o pptp_ctrl.o pptp_quirks.o util.o vector.o -+ -+install: all -+ $(INSTALL) -d -m 755 $(LIBDIR) -+ $(INSTALL) -c -m 4550 pptp.so $(LIBDIR) -+ -+clean: -+ rm -f *.o *.so -+ ---- /dev/null -+++ b/pppd/plugins/pptp/dirutil.c -@@ -0,0 +1,68 @@ -+/* dirutil.c ... directory utilities. -+ * C. Scott Ananian <cananian@alumni.princeton.edu> -+ * -+ * $Id: dirutil.c,v 1.2 2003/06/17 17:25:47 reink Exp $ -+ */ -+ -+#include <sys/stat.h> -+#include <sys/types.h> -+#include <unistd.h> -+#include <string.h> -+#include <stdlib.h> -+#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; -+} ---- /dev/null -+++ b/pppd/plugins/pptp/dirutil.h -@@ -0,0 +1,14 @@ -+/* dirutil.h ... directory utilities. -+ * C. Scott Ananian <cananian@alumni.princeton.edu> -+ * -+ * $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); ---- /dev/null -+++ b/pppd/plugins/pptp/orckit_quirks.c -@@ -0,0 +1,86 @@ -+/* orckit_quirks.c ...... fix quirks in orckit adsl modems -+ * mulix <mulix@actcom.co.il> -+ * -+ * $Id: orckit_quirks.c,v 1.3 2002/03/01 01:23:36 quozl Exp $ -+ */ -+ -+#include <string.h> -+#include <sys/types.h> -+#include <netinet/in.h> -+#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; -+} -+ -+ ---- /dev/null -+++ b/pppd/plugins/pptp/orckit_quirks.h -@@ -0,0 +1,27 @@ -+/* orckit_quirks.h ...... fix quirks in orckit adsl modems -+ * mulix <mulix@actcom.co.il> -+ * -+ * $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_ */ ---- /dev/null -+++ b/pppd/plugins/pptp/pppd-pptp.8 -@@ -0,0 +1,68 @@ -+.\" manual page [] for 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. -+Default is 50 -+.TP -+.BI "pptp_phone " phone " (optional)" -+The phone string that sended to pptp server. -+.SH USAGE -+Sample configuration file: -+.nf -+plugin "pptp.so" -+pptp_server 192.168.0.1 -+pptp_window 100 -+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 ---- /dev/null -+++ b/pppd/plugins/pptp/pptp.c -@@ -0,0 +1,323 @@ -+/*************************************************************************** -+ * Copyright (C) 2006 by Kozlov D. <xeb@mail.ru> * -+ * some cleanup done (C) 2012 by Daniel Golle <dgolle@allnet.de> * -+ * * -+ * 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. * -+ ***************************************************************************/ -+ -+#define PPTP_VERSION "1.00" -+ -+#ifdef HAVE_CONFIG_H -+#include <config.h> -+#endif -+ -+#include <netinet/in.h> -+#include <arpa/inet.h> -+#include <sys/un.h> -+#include <netdb.h> -+#include <stdio.h> -+#include <string.h> -+#include <stdlib.h> -+#include <syslog.h> -+#include <unistd.h> -+#include <signal.h> -+#include <errno.h> -+#include <fcntl.h> -+#include <sys/wait.h> -+#include <sys/ioctl.h> -+ -+#include "pppd.h" -+#include "fsm.h" -+#include "lcp.h" -+#include "ipcp.h" -+#include "ccp.h" -+#include "pathnames.h" -+ -+#include "pptp_callmgr.h" -+#include <net/if.h> -+#include <net/ethernet.h> -+#include <linux/if_pppox.h> -+ -+#include <stdio.h> -+#include <stdlib.h> -+ -+ -+ -+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_window=50; -+int pptp_sock=-1; -+struct in_addr localbind = { INADDR_NONE }; -+ -+static int callmgr_sock; -+static int pptp_fd; -+int call_ID; -+ -+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 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" }, -+ { "pptp_window",o_int, &pptp_window, -+ "PPTP window" }, -+ { NULL } -+}; -+ -+static int pptp_connect(void); -+static void pptp_disconnect(void); -+ -+struct channel pptp_channel = { -+ options: Options, -+ check_options: NULL, -+ connect: &pptp_connect, -+ disconnect: &pptp_disconnect, -+ establish_ppp: &generic_establish_ppp, -+ disestablish_ppp: &generic_disestablish_ppp, -+ 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); -+ } -+ -+ src_addr.sa_family=AF_PPPOX; -+ src_addr.sa_protocol=PX_PROTO_PPTP; -+ src_addr.sa_addr.pptp.call_id=0; -+ -+ dst_addr.sa_family=AF_PPPOX; -+ dst_addr.sa_protocol=PX_PROTO_PPTP; -+ dst_addr.sa_addr.pptp.call_id=0; -+ -+ pptp_fd=socket(AF_PPPOX,SOCK_STREAM,PX_PROTO_PPTP); -+ if (pptp_fd<0) -+ { -+ error("PPTP: failed to create PPTP socket (%s)\n",strerror(errno)); -+ return -1; -+ } -+ if (bind(pptp_fd,(struct sockaddr*)&src_addr,sizeof(src_addr))) -+ { -+ close(pptp_fd); -+ error("PPTP: failed to bind PPTP socket (%s)\n",strerror(errno)); -+ return -1; -+ } -+ len=sizeof(src_addr); -+ getsockname(pptp_fd,(struct sockaddr*)&src_addr,&len); -+ call_ID=src_addr.sa_addr.pptp.call_id; -+ -+ do { -+ /* -+ * Open connection to call manager (Launch call manager if necessary.) -+ */ -+ callmgr_sock = open_callmgr(src_addr.sa_addr.pptp.call_id,dst_addr.sa_addr.pptp.sin_addr, pptp_phone, pptp_window); -+ if (callmgr_sock<0) -+ { -+ close(pptp_fd); -+ return -1; -+ } -+ /* Exchange PIDs, get call ID */ -+ } while (get_call_id(callmgr_sock, getpid(), getpid(), &dst_addr.sa_addr.pptp.call_id) < 0); -+ -+ if (connect(pptp_fd,(struct sockaddr*)&dst_addr,sizeof(dst_addr))) -+ { -+ close(callmgr_sock); -+ close(pptp_fd); -+ error("PPTP: failed to connect PPTP socket (%s)\n",strerror(errno)); -+ return -1; -+ } -+ -+ sprintf(ppp_devnam,"pptp (%s)",pptp_server); -+ -+ return pptp_fd; -+} -+static int pptp_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 the pty and gre in the call manager */ -+ close(fd); -+ close(pptp_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) -+{ -+ dbglog("pptp: call manager for %s\n", inet_ntoa(inetaddr)); -+ dbglog("window size:\t%d\n",window); -+ if (phonenr) dbglog("phone number:\t'%s'\n",phonenr); -+ dbglog("call id:\t%d\n",call_id); -+ exit(callmgr_main(inetaddr, phonenr, window, call_id)); -+} -+ -+/*** 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) -+{ -+ add_options(Options); -+ -+ info("PPTP plugin version %s", PPTP_VERSION); -+ -+ the_channel = &pptp_channel; -+ modem = 0; -+} ---- /dev/null -+++ b/pppd/plugins/pptp/pptp_callmgr.c -@@ -0,0 +1,381 @@ -+/* pptp_callmgr.c ... Call manager for PPTP connections. -+ * Handles TCP port 1723 protocol. -+ * C. Scott Ananian <cananian@alumni.princeton.edu> -+ * -+ * $Id: pptp_callmgr.c,v 1.20 2005/03/31 07:42:39 quozl Exp $ -+ */ -+#include <signal.h> -+#include <sys/time.h> -+#include <sys/types.h> -+#include <sys/stat.h> -+#include <sys/socket.h> -+#include <netinet/in.h> -+#include <arpa/inet.h> -+#include <sys/un.h> -+#include <unistd.h> -+#include <stdlib.h> -+#include <string.h> -+#include <assert.h> -+#include <setjmp.h> -+#include <stdio.h> -+#include <errno.h> -+#include "pptp_callmgr.h" -+#include "pptp_ctrl.h" -+#include "pptp_msg.h" -+#include "dirutil.h" -+#include "vector.h" -+#include "util.h" -+#include "pppd.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 */ -+ dbglog("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); -+ } -+ break; -+ default: -+ dbglog("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(struct in_addr inetaddr, char phonenr[], int window, int pcallid) -+{ -+ 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; -+ if (pcallid>0) call_ID=pcallid; -+ -+ /* Step 1: Open sockets. */ -+ if ((inet_sock = open_inetsock(inetaddr)) < 0) -+ 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", inet_ntoa(inetaddr)); -+ /* Step 1b: FORK and return status to calling process. */ -+ dbglog("unix_sock"); -+ -+ switch (fork()) { -+ case 0: /* child. stick around. */ -+ break; -+ case -1: /* failure. Fatal. */ -+ fatal("Could not fork."); -+ default: /* Parent. Return status to caller. */ -+ exit(0); -+ } -+ /* re-open stderr as /dev/null to release it */ -+ file2fd("/dev/null", "wb", STDERR_FILENO); -+ /* Step 1c: Clean up unix socket on TERM */ -+ if (sigsetjmp(callmgr_env, 1) != 0) -+ goto cleanup; -+ signal(SIGINT, callmgr_sighandler); -+ signal(SIGTERM, callmgr_sighandler); -+ signal(SIGPIPE, callmgr_do_nothing); -+ signal(SIGUSR1, callmgr_do_nothing); /* signal state change -+ wake up accept */ -+ /* Step 2: Open control connection and register callback */ -+ if ((conn = pptp_conn_open(inet_sock, 1, NULL/* callback */)) == NULL) { -+ close(unix_sock); close(inet_sock); fatal("Could not open connection."); -+ } -+ FD_ZERO(&call_set); -+ call_list = vector_create(); -+ { -+ struct local_conninfo *conninfo = malloc(sizeof(*conninfo)); -+ if (conninfo == NULL) { -+ close(unix_sock); close(inet_sock); fatal("No memory."); -+ } -+ conninfo->call_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); -+ dbglog("Closing connection (unhandled)"); -+ 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); -+ dbglog("Closing connection (shutdown)"); -+ pptp_call_close(conn, call); -+ } -+ /* 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); -+} ---- /dev/null -+++ b/pppd/plugins/pptp/pptp_callmgr.h -@@ -0,0 +1,17 @@ -+/* pptp_callmgr.h ... Call manager for PPTP connections. -+ * Handles TCP port 1723 protocol. -+ * C. Scott Ananian <cananian@alumni.princeton.edu> -+ * -+ * $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(struct in_addr inetaddr, -+ char phonenr[], -+ int window, -+ int pcallid); -+ -+void callmgr_name_unixsock(struct sockaddr_un *where, -+ struct in_addr inetaddr, -+ struct in_addr localbind); ---- /dev/null -+++ b/pppd/plugins/pptp/pptp_ctrl.c -@@ -0,0 +1,1077 @@ -+/* pptp_ctrl.c ... handle PPTP control connection. -+ * C. Scott Ananian <cananian@alumni.princeton.edu> -+ * -+ * $Id: pptp_ctrl.c,v 1.31 2005/03/31 07:42:39 quozl Exp $ -+ */ -+ -+#include <errno.h> -+#include <sys/time.h> -+#include <sys/types.h> -+#include <sys/socket.h> -+#include <netinet/in.h> -+#include <unistd.h> -+#include <stdlib.h> -+#include <assert.h> -+#include <signal.h> -+#include <string.h> -+#include <ctype.h> -+#include <fcntl.h> -+#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) -+ 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 -+ 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 ) -+ warn("Result code is something else then \"general error\", " -+ "so the following error is probably bogus."); -+ warn("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; -+ dbglog("%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 */ -+ info("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 */ -+ warn("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) { -+ warn("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) { -+ warn("read returned zero, peer has closed"); -+ return -1; -+ } -+ if (retval < 0) { -+ if (errno == EINTR || errno == EAGAIN) -+ return 0; -+ else { /* a real error */ -+ warn("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) -+ 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; -+ /* 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) { 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) -+ warn("%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) -+ warn("%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 */ -+ warn("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) { -+ warn("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. */ -+ dbglog("PPTP management message received, but not understood."); -+ break; -+ default: -+ dbglog("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) { -+ dbglog("Echo Re%s received.", type == PPTP_ECHO_RQST ? "quest" :"ply"); -+ if( --nlogecho == 0) -+ dbglog("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))) { -+ warn("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; -+ 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 */ -+ 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; -+ dbglog("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; -+ 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 (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) { -+ dbglog("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 */ -+ dbglog("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 -+ }; -+ 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) -+ conn->callback(conn, CONN_CLOSE_RQST); -+ conn->conn_state = CONN_IDLE; -+ return -1; -+ } -+ break; -+ } -+ case PPTP_STOP_CTRL_CONN_RPLY: -+ { -+ 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; -+ 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 -+ }; -+ 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)); -+ 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); -+ 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)); -+ break; -+ } -+ if (call->call_type != PPTP_CALL_PNS) { -+ dbglog("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. */ -+ 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, -+ 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); -+ dbglog("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} -+ }; -+ 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); -+ if (call->callback != NULL) -+ call->callback(conn, call, CALL_CLOSE_RQST); -+ pptp_send_ctrl_packet(conn, &reply, sizeof(reply)); -+ pptp_call_destroy(conn, call); -+ dbglog("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; -+ dbglog("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. */ -+ dbglog("PPTP_SET_LINK_INFO received from peer_callid %u", -+ (unsigned int) ntoh16(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)) -+ 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)); -+ /* 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 */ -+ 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 = { -+ 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(); -+} ---- /dev/null -+++ b/pppd/plugins/pptp/pptp_ctrl.h -@@ -0,0 +1,57 @@ -+/* pptp_ctrl.h ... handle PPTP control connection. -+ * C. Scott Ananian <cananian@alumni.princeton.edu> -+ * -+ * $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 <sys/types.h> -+ -+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 */ ---- /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 <cananian@alumni.princeton.edu> -+ * -+ * $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 <sys/types.h> -+/* 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 */ ---- /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 <cananian@alumni.princeton.edu> -+ * -+ * $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 */ ---- /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 <mulix@actcom.co.il> -+ * -+ * $Id: pptp_quirks.c,v 1.2 2001/11/23 03:42:51 quozl Exp $ -+ */ -+ -+#include <string.h> -+#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; -+} -+ -+ ---- /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 <mulix@actcom.co.il> -+ * -+ * $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 */ ---- /dev/null -+++ b/pppd/plugins/pptp/util.c -@@ -0,0 +1,109 @@ -+/* util.c ....... error message utilities. -+ * C. Scott Ananian <cananian@alumni.princeton.edu> -+ * -+ * $Id: util.c,v 1.11 2005/08/22 00:49:48 quozl Exp $ -+ */ -+ -+#include <stdio.h> -+#include <stdarg.h> -+#include <syslog.h> -+#include <unistd.h> -+#include <stdlib.h> -+#include "util.h" -+ -+#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) -+ -+/*** 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 <unistd.h> -+#include <fcntl.h> -+#include <signal.h> -+#include <string.h> -+ -+/* 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]); -+} -+ ---- /dev/null -+++ b/pppd/plugins/pptp/util.h -@@ -0,0 +1,31 @@ -+/* util.h ....... error message utilities. -+ * C. Scott Ananian <cananian@alumni.princeton.edu> -+ * -+ * $Id: util.h,v 1.6 2005/03/10 01:18:20 quozl Exp $ -+ */ -+ -+#ifndef INC_UTIL_H -+#define INC_UTIL_H -+ -+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 */ ---- /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 <cananian@alumni.princeton.edu> -+ * -+ * $Id: vector.c,v 1.3 2003/06/17 10:12:55 reink Exp $ -+ */ -+ -+#include <stdlib.h> -+#include <string.h> -+#include <assert.h> -+#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; -+} ---- /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 <cananian@alumni.princeton.edu> -+ * -+ * $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 */ |