/branches/gl-inet/package/network/services/ppp/patches/500-add-pptp-plugin.patch |
@@ -0,0 +1,3066 @@ |
--- 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,1078 @@ |
+/* 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 "pppd.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 */ |