summaryrefslogtreecommitdiff
path: root/accel-pptpd
diff options
context:
space:
mode:
authorKozlov Dmitry <dima@server>2010-08-17 17:29:46 +0400
committerKozlov Dmitry <dima@server>2010-08-17 17:29:46 +0400
commit760d8427f133df486a145e6e7ac7610caf2356fc (patch)
treeebd109efc8882e56165e05f050dd30c9313bb9c7 /accel-pptpd
parentab418b16bf2c9a57dbb7c18141af2eb283c44447 (diff)
downloadaccel-ppp-xebd-760d8427f133df486a145e6e7ac7610caf2356fc.tar.gz
accel-ppp-xebd-760d8427f133df486a145e6e7ac7610caf2356fc.zip
reworked/rewrited lcp handling code to become more abstract
Diffstat (limited to 'accel-pptpd')
-rw-r--r--accel-pptpd/CMakeLists.txt8
-rw-r--r--accel-pptpd/auth_pap.c134
-rw-r--r--accel-pptpd/lcp_base_opt.c75
-rw-r--r--accel-pptpd/lcp_opt_accomp.c92
-rw-r--r--accel-pptpd/lcp_opt_magic.c81
-rw-r--r--accel-pptpd/lcp_opt_mru.c97
-rw-r--r--accel-pptpd/lcp_opt_pcomp.c92
-rw-r--r--accel-pptpd/log.c15
-rw-r--r--accel-pptpd/ppp.c44
-rw-r--r--accel-pptpd/ppp.h26
-rw-r--r--accel-pptpd/ppp_auth.c282
-rw-r--r--accel-pptpd/ppp_auth.h34
-rw-r--r--accel-pptpd/ppp_ccp.c12
-rw-r--r--accel-pptpd/ppp_fsm.c118
-rw-r--r--accel-pptpd/ppp_fsm.h84
-rw-r--r--accel-pptpd/ppp_ipcp.c12
-rw-r--r--accel-pptpd/ppp_lcp.c638
-rw-r--r--accel-pptpd/ppp_lcp.h67
-rw-r--r--accel-pptpd/pwdb.c7
-rw-r--r--accel-pptpd/pwdb.h9
-rw-r--r--accel-pptpd/triton/timer.c5
21 files changed, 1402 insertions, 530 deletions
diff --git a/accel-pptpd/CMakeLists.txt b/accel-pptpd/CMakeLists.txt
index 2e46e5b..3279141 100644
--- a/accel-pptpd/CMakeLists.txt
+++ b/accel-pptpd/CMakeLists.txt
@@ -12,6 +12,14 @@ ADD_EXECUTABLE(pptpd
ppp.c
ppp_fsm.c
ppp_lcp.c
+ lcp_opt_mru.c
+ lcp_opt_magic.c
+ lcp_opt_pcomp.c
+ lcp_opt_accomp.c
ppp_auth.c
+ ppp_ccp.c
+ ppp_ipcp.c
+ auth_pap.c
+ pwdb.c
)
TARGET_LINK_LIBRARIES(pptpd pthread triton)
diff --git a/accel-pptpd/auth_pap.c b/accel-pptpd/auth_pap.c
index ed0f6bf..95d5b1e 100644
--- a/accel-pptpd/auth_pap.c
+++ b/accel-pptpd/auth_pap.c
@@ -1,3 +1,8 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <arpa/inet.h>
+
#include "log.h"
#include "ppp.h"
#include "ppp_auth.h"
@@ -7,14 +12,23 @@
#define HDR_LEN (sizeof(struct pap_hdr_t)-2)
-static int lcp_get_conf_req(struct auth_driver_t*, struct ppp_t*, struct lcp_opt32_t*);
-static int lcp_recv_conf_req(struct auth_driver_t*, struct ppp_t*, struct lcp_opt32_t*);
-static int begin(struct auth_driver_t*, struct ppp_t*);
-static int terminate(struct auth_driver_t*, struct ppp_t*);
+#define PAP_REQ 1
+#define PAP_ACK 2
+#define PAP_NAK 3
+
+char *strndup(const char *s, size_t n);
+
+static struct auth_data_t* auth_data_init(struct ppp_t *ppp);
+static void auth_data_free(struct ppp_t*, struct auth_data_t*);
+static int lcp_send_conf_req(struct ppp_t*, struct auth_data_t*, uint8_t*);
+static int lcp_recv_conf_req(struct ppp_t*, struct auth_data_t*, uint8_t*);
+static int pap_start(struct ppp_t*, struct auth_data_t*);
+static int pap_finish(struct ppp_t*, struct auth_data_t*);
static void pap_recv(struct ppp_handler_t*h);
-struct pap_proto_t
+struct pap_auth_data_t
{
+ struct auth_data_t auth;
struct ppp_handler_t h;
struct ppp_t *ppp;
};
@@ -34,91 +48,98 @@ struct pap_ack_t
char msg[0];
} __attribute__((packed));
-static struct auth_driver_t pap=
+static struct ppp_auth_handler_t pap=
{
- .type=PPP_PAP,
- .get_conf_req=lcp_get_conf_req,
+ .name="PAP",
+ .init=auth_data_init,
+ .free=auth_data_free,
+ .send_conf_req=lcp_send_conf_req,
.recv_conf_req=lcp_recv_conf_req,
.start=pap_start,
.finish=pap_finish,
};
+static struct auth_data_t* auth_data_init(struct ppp_t *ppp)
+{
+ struct pap_auth_data_t *d=malloc(sizeof(*d));
+
+ memset(d,0,sizeof(*d));
+ d->auth.proto=PPP_PAP;
+ d->ppp=ppp;
-int plugin_init(void)
+ return &d->auth;
+}
+
+static void auth_data_free(struct ppp_t *ppp,struct auth_data_t *auth)
{
- if (auth_register(&pap))
- {
- log_error("pap: failed to register driver\n");
- return -1;
- }
+ struct pap_auth_data_t *d=container_of(auth,typeof(*d),auth);
- return 0;
+ free(d);
}
-static int pap_start(struct auth_driver_t *d, struct ppp_t *ppp)
+static int pap_start(struct ppp_t *ppp, struct auth_data_t *auth)
{
- struct pap_proto_t *p=malloc(sizeof(*p));
+ struct pap_auth_data_t *d=container_of(auth,typeof(*d),auth);
- memset(&p,0,sizeof(*p));
- p->h.proto=PPP_PAP;
- p->h.recv=pap_recv;
- p->ppp=ppp;
- ppp->auth_pd=p;
+ d->h.proto=PPP_PAP;
+ d->h.recv=pap_recv;
- ppp_register_handler(p->ppp,p->h);
+ ppp_register_handler(ppp,&d->h);
return 0;
}
-static int pap_finish(struct auth_driver_t *d, struct ppp_t *ppp)
+static int pap_finish(struct ppp_t *ppp, struct auth_data_t *auth)
{
- struct pap_proto_t *p=(struct pap_proto_t*)ppp->auth_pd;
-
- ppp_unregister_handler(p->ppp,p->h);
+ struct pap_auth_data_t *d=container_of(auth,typeof(*d),auth);
- free(p);
+ ppp_unregister_handler(ppp,&d->h);
return 0;
}
-static int lcp_get_conf_req(struct auth_driver_t *d, struct ppp_t *ppp, struct lcp_opt32_t *opt)
+static int lcp_send_conf_req(struct ppp_t *ppp, struct auth_data_t *d, uint8_t *ptr)
{
return 0;
}
-static int lcp_recv_conf_req(struct auth_driver_t *d, struct ppp_t *ppp, struct lcp_opt32_t *opt)
+static int lcp_recv_conf_req(struct ppp_t *ppp, struct auth_data_t *d, uint8_t *ptr)
{
return 0;
}
-static void pap_send_ack(struct pap_proto_t *p, int id)
+static void pap_send_ack(struct pap_auth_data_t *p, int id)
{
uint8_t buf[128];
struct pap_ack_t *msg=(struct pap_ack_t*)buf;
- msg->hdr.proto=PPP_PAP;
+ msg->hdr.proto=htons(PPP_PAP);
msg->hdr.code=PAP_ACK;
msg->hdr.id=id;
- msg->hdr.len=HDR_LEN+1+sizeof(MSG_SUCCESSED);
- msg->len=sizeof(MSG_SUCCESSED);
+ msg->hdr.len=htons(HDR_LEN+1+sizeof(MSG_SUCCESSED));
+ msg->msg_len=sizeof(MSG_SUCCESSED)-1;
memcpy(msg->msg,MSG_SUCCESSED,sizeof(MSG_SUCCESSED));
- ppp_send(p->ppp,msg,msg->hdr.len+2);
+ log_debug("send [PAP AuthAck id=%x \"%s\"]\n",id,MSG_SUCCESSED);
+
+ ppp_send(p->ppp,msg,ntohs(msg->hdr.len)+2);
}
-static void pap_send_nack(struct pap_proto_t *p,int id)
+static void pap_send_nak(struct pap_auth_data_t *p,int id)
{
uint8_t buf[128];
struct pap_ack_t *msg=(struct pap_ack_t*)buf;
- msg->hdr.proto=PPP_PAP;
- msg->hdr.code=PAP_NACK;
+ msg->hdr.proto=htons(PPP_PAP);
+ msg->hdr.code=PAP_NAK;
msg->hdr.id=id;
- msg->hdr.len=HDR_LEN+1+sizeof(MSG_FAILED);
- msg->len=sizeof(MSG_FAILED);
+ msg->hdr.len=htons(HDR_LEN+1+sizeof(MSG_FAILED));
+ msg->msg_len=sizeof(MSG_FAILED)-1;
memcpy(msg->msg,MSG_FAILED,sizeof(MSG_FAILED));
- ppp_send(p->ppp,msg,msg->hdr.len+2);
+ log_debug("send [PAP AuthNak id=%x \"%s\"]\n",id,MSG_FAILED);
+
+ ppp_send(p->ppp,msg,ntohs(msg->hdr.len)+2);
}
-static int pap_recv_req(struct pap_proto_t *p,struct pap_hdr_t *hdr)
+static int pap_recv_req(struct pap_auth_data_t *p,struct pap_hdr_t *hdr)
{
int ret;
char *peer_id;
@@ -126,29 +147,31 @@ static int pap_recv_req(struct pap_proto_t *p,struct pap_hdr_t *hdr)
int peer_id_len;
int passwd_len;
uint8_t *ptr=(uint8_t*)(hdr+1);
-
+
+ log_debug("recv [PAP AuthReq id=%x]\n",hdr->id);
+
peer_id_len=*(uint8_t*)ptr; ptr++;
- if (peer_id_len>htons(hdr->len)-sizeof(*hdr)-1)
+ if (peer_id_len>ntohs(hdr->len)-sizeof(*hdr)+2-1)
{
log_warn("PAP: short packet received\n");
return -1;
}
- peer_id=ptr; ptr+=peer_id_len;
+ peer_id=(char*)ptr; ptr+=peer_id_len;
passwd_len=*(uint8_t*)ptr; ptr++;
- if (passwd_len>htons(hdr->len)-sizeof(*hdr)-2-peer_id_len)
+ if (passwd_len>ntohs(hdr->len)-sizeof(*hdr)+2-2-peer_id_len)
{
log_warn("PAP: short packet received\n");
return -1;
}
- peer_id=stdndup(peer_id,peer_id_len);
- passwd=stdndup(ptr,passwd_len);
+ peer_id=strndup((const char*)peer_id,peer_id_len);
+ passwd=strndup((const char*)ptr,passwd_len);
if (pwdb_check(peer_id,passwd))
{
log_warn("PAP: authentication error\n");
- pap_send_nack(p,hdr->id);
+ pap_send_nak(p,hdr->id);
auth_failed(p->ppp);
ret=-1;
}else
@@ -166,19 +189,24 @@ static int pap_recv_req(struct pap_proto_t *p,struct pap_hdr_t *hdr)
static void pap_recv(struct ppp_handler_t *h)
{
- struct pap_proto_t *p=container_of(h,typeof(*p),h);
- struct pap_hdr_t *hdr=(struct pap_hdr_t *)p->ppp->in_buf;
+ struct pap_auth_data_t *d=container_of(h,typeof(*d),h);
+ struct pap_hdr_t *hdr=(struct pap_hdr_t *)d->ppp->in_buf;
- if (p->ppp->in_buf_size<sizeof(*hdr) || htons(hdr->len)<HDR_LEN || htons(hdr->len)<p->ppp->in_buf_size-2)
+ if (d->ppp->in_buf_size<sizeof(*hdr) || ntohs(hdr->len)<HDR_LEN || ntohs(hdr->len)<d->ppp->in_buf_size-2)
{
log_warn("PAP: short packet received\n");
return;
}
- if (hdr->code==PAP_REQ) pap_recv_req(p,hdr);
+ if (hdr->code==PAP_REQ) pap_recv_req(d,hdr);
else
{
log_warn("PAP: unknown code received %x\n",hdr->code);
}
}
+static void __init auth_pap_init()
+{
+ ppp_auth_register_handler(&pap);
+}
+
diff --git a/accel-pptpd/lcp_base_opt.c b/accel-pptpd/lcp_base_opt.c
new file mode 100644
index 0000000..352dee2
--- /dev/null
+++ b/accel-pptpd/lcp_base_opt.c
@@ -0,0 +1,75 @@
+#include "ppp_lcp.h"
+
+static struct lcp_option_t *mru_init(struct ppp_lcp_t *lcp);
+static void mru_free(struct ppp_lcp_t *lcp, struct lcp_option_t *opt);
+static int mru_send_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static int mru_send_conf_nak(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static int mru_recv_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+
+struct mru_option_t
+{
+ struct lcp_option_t opt;
+ int mru;
+ int mtu;
+};
+
+static struct lcp_option_handler_t opt_mru=
+{
+ .id=CI_MRU,
+ .init=mru_init,
+ .send_conf_req=mru_send_conf_req,
+ .send_conf_nak=mru_send_conf_nak,
+ .recv_conf_req=mru_recv_conf_req,
+ .free=mru_free,
+};
+
+static struct lcp_option_t *mru_init(struct ppp_lcp_t *lcp)
+{
+ struct mru_option_t *mru_opt=malloc(sizeof(*mru_opt));
+ memset(mru_opt,0,sizeof(*mru_opt));
+ mru_opt->mtu=0;
+ mru_opt->mru=1500;
+ mru_opt->opt.len=4;
+
+ return &mru_opt->opt;
+}
+
+static void mru_free(struct ppp_lcp_t *lcp, struct lcp_option_t *opt)
+{
+ struct mru_option_t *mru_opt=container_of(opt,typeof(*mru_opt),opt);
+
+ free(mru_opt);
+}
+
+static int mru_send_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct mru_option_t *mru_opt=container_of(opt,typeof(*mru_opt),opt);
+ struct lcp_opt16_t *opt16=(struct lcp_opt16_t*)ptr;
+ opt16->hdr.type=CI_MRU;
+ opt16->hdr.len=4;
+ opt16->val=htons(mru_opt->mru);
+ return 4;
+}
+
+static int mru_send_conf_nak(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct mru_option_t *mru_opt=container_of(opt,typeof(*mru_opt),opt);
+ struct lcp_opt16_t *opt16=(struct lcp_opt16_t*)ptr;
+ opt16->hdr.type=CI_MRU;
+ opt16->hdr.len=4;
+ opt16->val=htons(mru_opt->mtu);
+ return 4;
+}
+
+static int mru_recv_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct mru_option_t *mru_opt=container_of(opt,typeof(*mru_opt),opt);
+ struct lcp_opt16_t *opt16=(struct lcp_opt16_t*)ptr;
+
+ if (!mru_opt->mtu || mru_opt->mtu==ntohs(opt16->val))
+ {
+ mru_opt->mtu=ntohs(opt16->val);
+ return LCP_OPT_ACK;
+ }else return LCP_OPT_NAK;
+}
+
diff --git a/accel-pptpd/lcp_opt_accomp.c b/accel-pptpd/lcp_opt_accomp.c
new file mode 100644
index 0000000..9191563
--- /dev/null
+++ b/accel-pptpd/lcp_opt_accomp.c
@@ -0,0 +1,92 @@
+#include <stdlib.h>
+#include <string.h>
+#include <arpa/inet.h>
+
+#include "ppp.h"
+#include "ppp_lcp.h"
+#include "log.h"
+
+static struct lcp_option_t *accomp_init(struct ppp_lcp_t *lcp);
+static void accomp_free(struct ppp_lcp_t *lcp, struct lcp_option_t *opt);
+static int accomp_send_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static int accomp_send_conf_nak(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static int accomp_recv_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static void accomp_print(void (*print)(const char *fmt,...),struct lcp_option_t*, uint8_t *ptr);
+
+struct accomp_option_t
+{
+ struct lcp_option_t opt;
+ int accomp; // 0 - disabled, 1 - enabled, 2 - allow,disabled, 3 - allow,enabled
+};
+
+static struct lcp_option_handler_t accomp_opt_hnd=
+{
+ .init=accomp_init,
+ .send_conf_req=accomp_send_conf_req,
+ .send_conf_nak=accomp_send_conf_nak,
+ .recv_conf_req=accomp_recv_conf_req,
+ .free=accomp_free,
+ .print=accomp_print,
+};
+
+static struct lcp_option_t *accomp_init(struct ppp_lcp_t *lcp)
+{
+ struct accomp_option_t *accomp_opt=malloc(sizeof(*accomp_opt));
+ memset(accomp_opt,0,sizeof(*accomp_opt));
+ accomp_opt->accomp=2;
+ accomp_opt->opt.id=CI_ACCOMP;
+ accomp_opt->opt.len=2;
+
+ return &accomp_opt->opt;
+}
+
+static void accomp_free(struct ppp_lcp_t *lcp, struct lcp_option_t *opt)
+{
+ struct accomp_option_t *accomp_opt=container_of(opt,typeof(*accomp_opt),opt);
+
+ free(accomp_opt);
+}
+
+static int accomp_send_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct accomp_option_t *accomp_opt=container_of(opt,typeof(*accomp_opt),opt);
+ struct lcp_opt_hdr_t *opt0=(struct lcp_opt_hdr_t*)ptr;
+ if (accomp_opt->accomp==1 || accomp_opt->accomp==3)
+ {
+ opt0->id=CI_ACCOMP;
+ opt0->len=2;
+ return 2;
+ }
+ return 0;
+}
+
+static int accomp_send_conf_nak(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct accomp_option_t *accomp_opt=container_of(opt,typeof(*accomp_opt),opt);
+ struct lcp_opt_hdr_t *opt0=(struct lcp_opt_hdr_t*)ptr;
+ opt0->id=CI_ACCOMP;
+ opt0->len=2;
+ return 2;
+}
+
+static int accomp_recv_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct accomp_option_t *accomp_opt=container_of(opt,typeof(*accomp_opt),opt);
+
+ if (accomp_opt->accomp>0)
+ {
+ accomp_opt->accomp=1;
+ return LCP_OPT_ACK;
+ }else return LCP_OPT_NAK;
+}
+
+static void accomp_print(void (*print)(const char *fmt,...),struct lcp_option_t *opt, uint8_t *ptr)
+{
+ print("<accomp>");
+}
+
+static void __init accomp_opt_init()
+{
+ lcp_option_register(&accomp_opt_hnd);
+}
+
diff --git a/accel-pptpd/lcp_opt_magic.c b/accel-pptpd/lcp_opt_magic.c
new file mode 100644
index 0000000..53438b9
--- /dev/null
+++ b/accel-pptpd/lcp_opt_magic.c
@@ -0,0 +1,81 @@
+#include <stdlib.h>
+#include <string.h>
+#include <arpa/inet.h>
+
+#include "ppp.h"
+#include "ppp_lcp.h"
+#include "log.h"
+
+static struct lcp_option_t *magic_init(struct ppp_lcp_t *lcp);
+static void magic_free(struct ppp_lcp_t *lcp, struct lcp_option_t *opt);
+static int magic_send_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static int magic_recv_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static void magic_print(void (*print)(const char *fmt,...),struct lcp_option_t*, uint8_t *ptr);
+
+struct magic_option_t
+{
+ struct lcp_option_t opt;
+ int magic;
+};
+
+static struct lcp_option_handler_t magic_opt_hnd=
+{
+ .init=magic_init,
+ .send_conf_req=magic_send_conf_req,
+ .recv_conf_req=magic_recv_conf_req,
+ .free=magic_free,
+ .print=magic_print,
+};
+
+static struct lcp_option_t *magic_init(struct ppp_lcp_t *lcp)
+{
+ struct magic_option_t *magic_opt=malloc(sizeof(*magic_opt));
+ memset(magic_opt,0,sizeof(*magic_opt));
+ magic_opt->magic=random();
+ magic_opt->opt.id=CI_MAGIC;
+ magic_opt->opt.len=6;
+
+ return &magic_opt->opt;
+}
+
+static void magic_free(struct ppp_lcp_t *lcp, struct lcp_option_t *opt)
+{
+ struct magic_option_t *magic_opt=container_of(opt,typeof(*magic_opt),opt);
+
+ free(magic_opt);
+}
+
+static int magic_send_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct magic_option_t *magic_opt=container_of(opt,typeof(*magic_opt),opt);
+ struct lcp_opt32_t *opt32=(struct lcp_opt32_t*)ptr;
+ opt32->hdr.id=CI_MAGIC;
+ opt32->hdr.len=6;
+ opt32->val=htonl(magic_opt->magic);
+ return 6;
+}
+
+static int magic_recv_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct magic_option_t *magic_opt=container_of(opt,typeof(*magic_opt),opt);
+ struct lcp_opt32_t *opt32=(struct lcp_opt32_t*)ptr;
+
+ if (magic_opt->magic==ntohl(opt32->val))
+ {
+ log_error("loop detected");
+ return -1;
+ }
+ return LCP_OPT_ACK;
+}
+
+static void magic_print(void (*print)(const char *fmt,...),struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct magic_option_t *magic_opt=container_of(opt,typeof(*magic_opt),opt);
+
+ print("<magic %04x>",magic_opt->magic);
+}
+
+static void __init magic_opt_init()
+{
+ lcp_option_register(&magic_opt_hnd);
+}
diff --git a/accel-pptpd/lcp_opt_mru.c b/accel-pptpd/lcp_opt_mru.c
new file mode 100644
index 0000000..153b0e0
--- /dev/null
+++ b/accel-pptpd/lcp_opt_mru.c
@@ -0,0 +1,97 @@
+#include <stdlib.h>
+#include <string.h>
+#include <arpa/inet.h>
+
+#include "ppp.h"
+#include "ppp_lcp.h"
+#include "log.h"
+
+static struct lcp_option_t *mru_init(struct ppp_lcp_t *lcp);
+static void mru_free(struct ppp_lcp_t *lcp, struct lcp_option_t *opt);
+static int mru_send_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static int mru_send_conf_nak(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static int mru_recv_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static void mru_print(void (*print)(const char *fmt,...),struct lcp_option_t*, uint8_t *ptr);
+
+struct mru_option_t
+{
+ struct lcp_option_t opt;
+ int mru;
+ int mtu;
+};
+
+static struct lcp_option_handler_t mru_opt_hnd=
+{
+ .init=mru_init,
+ .send_conf_req=mru_send_conf_req,
+ .send_conf_nak=mru_send_conf_nak,
+ .recv_conf_req=mru_recv_conf_req,
+ .free=mru_free,
+ .print=mru_print,
+};
+
+static struct lcp_option_t *mru_init(struct ppp_lcp_t *lcp)
+{
+ struct mru_option_t *mru_opt=malloc(sizeof(*mru_opt));
+ memset(mru_opt,0,sizeof(*mru_opt));
+ mru_opt->mtu=0;
+ mru_opt->mru=1500;
+ mru_opt->opt.id=CI_MRU;
+ mru_opt->opt.len=4;
+
+ return &mru_opt->opt;
+}
+
+static void mru_free(struct ppp_lcp_t *lcp, struct lcp_option_t *opt)
+{
+ struct mru_option_t *mru_opt=container_of(opt,typeof(*mru_opt),opt);
+
+ free(mru_opt);
+}
+
+static int mru_send_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct mru_option_t *mru_opt=container_of(opt,typeof(*mru_opt),opt);
+ struct lcp_opt16_t *opt16=(struct lcp_opt16_t*)ptr;
+ opt16->hdr.id=CI_MRU;
+ opt16->hdr.len=4;
+ opt16->val=htons(mru_opt->mru);
+ return 4;
+}
+
+static int mru_send_conf_nak(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct mru_option_t *mru_opt=container_of(opt,typeof(*mru_opt),opt);
+ struct lcp_opt16_t *opt16=(struct lcp_opt16_t*)ptr;
+ opt16->hdr.id=CI_MRU;
+ opt16->hdr.len=4;
+ opt16->val=htons(mru_opt->mtu);
+ return 4;
+}
+
+static int mru_recv_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct mru_option_t *mru_opt=container_of(opt,typeof(*mru_opt),opt);
+ struct lcp_opt16_t *opt16=(struct lcp_opt16_t*)ptr;
+
+ if (!mru_opt->mtu || mru_opt->mtu==ntohs(opt16->val))
+ {
+ mru_opt->mtu=ntohs(opt16->val);
+ return LCP_OPT_ACK;
+ }else return LCP_OPT_NAK;
+}
+
+static void mru_print(void (*print)(const char *fmt,...),struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct mru_option_t *mru_opt=container_of(opt,typeof(*mru_opt),opt);
+ struct lcp_opt16_t *opt16=(struct lcp_opt16_t*)ptr;
+
+ if (ptr) print("<mru %i>",ntohs(opt16->val));
+ else print("<mru %i>",mru_opt->mru);
+}
+
+static void __init mru_opt_init()
+{
+ lcp_option_register(&mru_opt_hnd);
+}
+
diff --git a/accel-pptpd/lcp_opt_pcomp.c b/accel-pptpd/lcp_opt_pcomp.c
new file mode 100644
index 0000000..79d77c6
--- /dev/null
+++ b/accel-pptpd/lcp_opt_pcomp.c
@@ -0,0 +1,92 @@
+#include <stdlib.h>
+#include <string.h>
+#include <arpa/inet.h>
+
+#include "ppp.h"
+#include "ppp_lcp.h"
+#include "log.h"
+
+static struct lcp_option_t *pcomp_init(struct ppp_lcp_t *lcp);
+static void pcomp_free(struct ppp_lcp_t *lcp, struct lcp_option_t *opt);
+static int pcomp_send_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static int pcomp_send_conf_nak(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static int pcomp_recv_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static void pcomp_print(void (*print)(const char *fmt,...),struct lcp_option_t*, uint8_t *ptr);
+
+struct pcomp_option_t
+{
+ struct lcp_option_t opt;
+ int pcomp; // 0 - disabled, 1 - enabled, 2 - allow,disabled, 3 - allow,enabled
+};
+
+static struct lcp_option_handler_t pcomp_opt_hnd=
+{
+ .init=pcomp_init,
+ .send_conf_req=pcomp_send_conf_req,
+ .send_conf_nak=pcomp_send_conf_nak,
+ .recv_conf_req=pcomp_recv_conf_req,
+ .free=pcomp_free,
+ .print=pcomp_print,
+};
+
+static struct lcp_option_t *pcomp_init(struct ppp_lcp_t *lcp)
+{
+ struct pcomp_option_t *pcomp_opt=malloc(sizeof(*pcomp_opt));
+ memset(pcomp_opt,0,sizeof(*pcomp_opt));
+ pcomp_opt->pcomp=2;
+ pcomp_opt->opt.id=CI_PCOMP;
+ pcomp_opt->opt.len=2;
+
+ return &pcomp_opt->opt;
+}
+
+static void pcomp_free(struct ppp_lcp_t *lcp, struct lcp_option_t *opt)
+{
+ struct pcomp_option_t *pcomp_opt=container_of(opt,typeof(*pcomp_opt),opt);
+
+ free(pcomp_opt);
+}
+
+static int pcomp_send_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct pcomp_option_t *pcomp_opt=container_of(opt,typeof(*pcomp_opt),opt);
+ struct lcp_opt_hdr_t *opt0=(struct lcp_opt_hdr_t*)ptr;
+ if (pcomp_opt->pcomp==1 || pcomp_opt->pcomp==3)
+ {
+ opt0->id=CI_PCOMP;
+ opt0->len=2;
+ return 2;
+ }
+ return 0;
+}
+
+static int pcomp_send_conf_nak(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct pcomp_option_t *pcomp_opt=container_of(opt,typeof(*pcomp_opt),opt);
+ struct lcp_opt_hdr_t *opt0=(struct lcp_opt_hdr_t*)ptr;
+ opt0->id=CI_PCOMP;
+ opt0->len=2;
+ return 2;
+}
+
+static int pcomp_recv_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct pcomp_option_t *pcomp_opt=container_of(opt,typeof(*pcomp_opt),opt);
+
+ if (pcomp_opt->pcomp>0)
+ {
+ pcomp_opt->pcomp=1;
+ return LCP_OPT_ACK;
+ }else return LCP_OPT_NAK;
+}
+
+static void pcomp_print(void (*print)(const char *fmt,...),struct lcp_option_t *opt, uint8_t *ptr)
+{
+ print("<pcomp>");
+}
+
+static void __init pcomp_opt_init()
+{
+ lcp_option_register(&pcomp_opt_hnd);
+}
+
diff --git a/accel-pptpd/log.c b/accel-pptpd/log.c
index 454e997..4ee86e1 100644
--- a/accel-pptpd/log.c
+++ b/accel-pptpd/log.c
@@ -34,7 +34,7 @@
#define LOG_DEBUG 3
static FILE *log_file=NULL;
-static int log_level=1;
+static int log_level=10;
static int log_color=1;
static const char* level_name[]={"error","warning","info","debug"};
static const char* level_color[]={RED_COLOR,YELLOW_COLOR,GREEN_COLOR,BLUE_COLOR};
@@ -46,15 +46,18 @@ static void do_log(int level,const char *fmt,va_list ap)
{
struct timeval tv;
- pthread_mutex_lock(&lock);
- gettimeofday(&tv,NULL);
- if (log_color) fprintf(log_file,"[%s%li.%03li] [%s]%s ",level_color[level],tv.tv_sec,tv.tv_usec/1000,NORMAL_COLOR,level_name[level]);
- else fprintf(log_file,"[%li.%03li] [%s] ",tv.tv_sec,tv.tv_usec/1000,level_name[level]);
+ //pthread_mutex_lock(&lock);
+ if (msg_completed)
+ {
+ gettimeofday(&tv,NULL);
+ if (log_color) fprintf(log_file,"[%s%li.%03li] [%s]%s ",level_color[level],tv.tv_sec,tv.tv_usec/1000,NORMAL_COLOR,level_name[level]);
+ else fprintf(log_file,"[%li.%03li] [%s] ",tv.tv_sec,tv.tv_usec/1000,level_name[level]);
+ }
vfprintf(log_file,fmt,ap);
msg_completed=fmt[strlen(fmt)-1]=='\n';
- if (msg_completed) pthread_mutex_unlock(&lock);
+ //if (msg_completed) pthread_mutex_unlock(&lock);
}
void log_error(const char *fmt,...)
{
diff --git a/accel-pptpd/ppp.c b/accel-pptpd/ppp.c
index f8a1be5..b032b06 100644
--- a/accel-pptpd/ppp.c
+++ b/accel-pptpd/ppp.c
@@ -86,13 +86,10 @@ int establish_ppp(struct ppp_t *ppp)
ppp->h->twait=-1;
triton_md_register_handler(ppp->h);
triton_md_enable_handler(ppp->h,MD_MODE_READ);
- INIT_LIST_HEAD(&ppp->layers);
+ INIT_LIST_HEAD(&ppp->handlers);
- ppp->lcp_layer=ppp_lcp_init(ppp);
- /*list_add_tail(&ppp->lcp_layer->entry,&ppp->layers);
- ppp_fsm_open(ppp->lcp_layer);
- ppp_fsm_lower_up(ppp->lcp_layer);*/
ppp->cur_layer=PPP_LAYER_LCP;
+
lcp_start(ppp);
return 0;
@@ -104,6 +101,14 @@ exit_close_chan:
return -1;
}
+void print_buf(uint8_t *buf,int size)
+{
+ int i;
+ for(i=0;i<size;i++)
+ printf("%x ",buf[i]);
+ printf("\n");
+}
+
int ppp_send(struct ppp_t *ppp, void *data, int size)
{
int n;
@@ -111,32 +116,38 @@ int ppp_send(struct ppp_t *ppp, void *data, int size)
if (ppp->out_buf_size) return -1;
if (size>PPP_MTU+PPP_HDRLEN) return -1;
+ printf("ppp: send: ");
+ print_buf((uint8_t*)data,size);
+
n=write(ppp->unit_fd,data,size);
- if (n>=0)
+ /*if (n>=0)
{
if (n!=ppp->out_buf_size-ppp->out_buf_pos)
{
ppp->out_buf_pos+=n;
triton_md_enable_handler(ppp->h,MD_MODE_WRITE);
}
- }
+ }*/
return n;
}
static void ppp_read(struct triton_md_handler_t*h)
{
struct ppp_t *ppp=(struct ppp_t *)h->pd;
- struct ppp_layer_t *l=NULL;
+ struct ppp_handler_t *ppp_h=NULL;
uint16_t proto;
ppp->in_buf_size=read(h->fd,ppp->in_buf,PPP_MRU+PPP_HDRLEN);
+ printf("ppp: recv: ");
+ print_buf(ppp->in_buf,ppp->in_buf_size);
+
proto=ntohs(*(uint16_t*)ppp->in_buf);
- list_for_each_entry(l,&ppp->layers,entry)
+ list_for_each_entry(ppp_h,&ppp->handlers,entry)
{
- if (l->proto==proto)
+ if (ppp_h->proto==proto)
{
- l->recv(l);
+ ppp_h->recv(ppp_h);
return;
}
}
@@ -166,7 +177,6 @@ static void ppp_timeout(struct triton_md_handler_t*h)
void ppp_layer_started(struct ppp_t *ppp)
{
- int i;
switch(ppp->cur_layer)
{
case PPP_LAYER_LCP:
@@ -204,3 +214,13 @@ void ppp_terminate(struct ppp_t *ppp)
}
}
+
+void ppp_register_handler(struct ppp_t *ppp,struct ppp_handler_t *h)
+{
+ list_add_tail(&h->entry,&ppp->handlers);
+}
+void ppp_unregister_handler(struct ppp_t *ppp,struct ppp_handler_t *h)
+{
+ list_del(&h->entry);
+}
+
diff --git a/accel-pptpd/ppp.h b/accel-pptpd/ppp.h
index 4a4c70e..83ad8ed 100644
--- a/accel-pptpd/ppp.h
+++ b/accel-pptpd/ppp.h
@@ -2,7 +2,7 @@
#define PPP_H
#include <sys/types.h>
-#include "ppp_fsm.h"
+#include "list.h"
/*
* Packet header = Code, id, length.
@@ -46,6 +46,10 @@
#define PPP_LAYER_CCP 3
#define PPP_LAYER_IPCP 4
+#define AUTH_MAX 3
+
+struct ppp_lcp_t;
+
struct ppp_t
{
struct triton_md_handler_t *h;
@@ -77,8 +81,7 @@ struct ppp_t
struct list_head handlers;
int cur_layer;
- struct ppp_layer_t *lcp_layer;
- void *auth_pd;
+ struct ppp_lcp_t *lcp;
};
struct ppp_handler_t
@@ -94,17 +97,30 @@ int ppp_send(struct ppp_t *ppp, void *data, int size);
void ppp_init(void);
-struct ppp_layer_t* ppp_lcp_init(struct ppp_t *ppp);
+struct ppp_fsm_t* ppp_lcp_init(struct ppp_t *ppp);
void ppp_layer_started(struct ppp_t *ppp);
void ppp_terminate(struct ppp_t *ppp);
+void ppp_register_handler(struct ppp_t*,struct ppp_handler_t*);
+void ppp_unregister_handler(struct ppp_t*,struct ppp_handler_t*);
+
+void lcp_start(struct ppp_t*);
+void lcp_finish(struct ppp_t*);
+int auth_start(struct ppp_t*);
+void auth_finish(struct ppp_t*);
+int ccp_start(struct ppp_t*);
+void ccp_finish(struct ppp_t*);
+int ipcp_start(struct ppp_t*);
+void ipcp_finish(struct ppp_t*);
+
+#define __init __attribute__((constructor))
+
#undef offsetof
#ifdef __compiler_offsetof
#define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
#else
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#endif
-#endif /* __KERNEL__ */
#define container_of(ptr, type, member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
diff --git a/accel-pptpd/ppp_auth.c b/accel-pptpd/ppp_auth.c
index 1117c21..6fc4801 100644
--- a/accel-pptpd/ppp_auth.c
+++ b/accel-pptpd/ppp_auth.c
@@ -1,129 +1,245 @@
-#include "triton/triton.h"
+#include <stdlib.h>
+#include <string.h>
+#include <arpa/inet.h>
#include "ppp.h"
#include "ppp_lcp.h"
-#include "ppp_fsm.h"
+#include "log.h"
+
#include "ppp_auth.h"
-static LIST_HEAD(drv_list);
-int auth_register(struct auth_driver_t *new)
+static LIST_HEAD(auth_handlers);
+static int extra_opt_len=0;
+
+static struct lcp_option_t *auth_init(struct ppp_lcp_t *lcp);
+static void auth_free(struct ppp_lcp_t *lcp, struct lcp_option_t *opt);
+static int auth_send_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static int auth_recv_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static int auth_recv_conf_nak(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static int auth_recv_conf_rej(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static int auth_recv_conf_ack(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr);
+static void auth_print(void (*print)(const char *fmt,...),struct lcp_option_t*, uint8_t *ptr);
+
+struct auth_option_t
+{
+ struct lcp_option_t opt;
+ struct list_head auth_list;
+ struct auth_data_t *auth;
+ struct auth_data_t *peer_auth;
+};
+
+static struct lcp_option_handler_t auth_opt_hnd=
{
- struct auth_driver_t *drv;
+ .init=auth_init,
+ .send_conf_req=auth_send_conf_req,
+ .send_conf_nak=auth_send_conf_req,
+ .recv_conf_req=auth_recv_conf_req,
+ .recv_conf_nak=auth_recv_conf_nak,
+ .recv_conf_rej=auth_recv_conf_rej,
+ .recv_conf_ack=auth_recv_conf_ack,
+ .free=auth_free,
+ .print=auth_print,
+};
- list_for_each_entry(drv,&drv_list,entry)
+static struct lcp_option_t *auth_init(struct ppp_lcp_t *lcp)
+{
+ struct ppp_auth_handler_t *h;
+ struct auth_data_t *d;
+ struct auth_option_t *auth_opt=malloc(sizeof(*auth_opt));
+ memset(auth_opt,0,sizeof(*auth_opt));
+ auth_opt->opt.id=CI_AUTH;
+ auth_opt->opt.len=4+extra_opt_len;
+
+ INIT_LIST_HEAD(&auth_opt->auth_list);
+
+ list_for_each_entry(h,&auth_handlers,entry)
{
- if (drv->type==new->type)
- return -1;
+ d=h->init(lcp->ppp);
+ d->h=h;
+ list_add_tail(&d->entry,&auth_opt->auth_list);
}
- list_add_tail(&new->entry,&drv_list);
- return 0;
+
+ return &auth_opt->opt;
}
-int auth_get_conf_req(struct ppp_layer_t *l, struct lcp_opt32_t *opt)
+static void auth_free(struct ppp_lcp_t *lcp, struct lcp_option_t *opt)
{
- int i,n;
- struct auth_driver_t *drv;
+ struct auth_option_t *auth_opt=container_of(opt,typeof(*auth_opt),opt);
+ struct auth_data_t *d;
- for(i=0; i<AUTH_MAX; i++)
- {
- if (l->ppp->auth[i] && l->options.lcp.neg_auth[i]>0)
- goto cont;
- }
- for(i=0; i<AUTH_MAX; i++)
+ while(!list_empty(&auth_opt->auth_list))
{
- if (l->ppp->auth[i] && l->options.lcp.neg_auth[i]==0)
- goto cont;
+ d=list_entry(auth_opt->auth_list.next,typeof(*d),entry);
+ list_del(&d->entry);
+ d->h->free(lcp->ppp,d);
}
- return -1;
-cont:
- list_for_each_entry(drv,&drv_list,entry)
+ free(auth_opt);
+}
+
+static int auth_send_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct auth_option_t *auth_opt=container_of(opt,typeof(*auth_opt),opt);
+ struct lcp_opt16_t *opt16=(struct lcp_opt16_t*)ptr;
+ struct auth_data_t *d;
+ int n;
+
+ if (list_empty(&auth_opt->auth_list)) return 0;
+
+ if (!auth_opt->auth)
{
- if (drv->type==l->ppp->auth[i])
- break;
+ d=list_entry(auth_opt->auth_list.next,typeof(*d),entry);
+ auth_opt->auth=d;
}
- n=drv->get_conf_req(drv,l,opt);
- opt->val=l->auth[i];
- opt->hdr.len=6+n;
- return 0;
+
+ opt16->hdr.id=CI_AUTH;
+ opt16->val=htons(auth_opt->auth->proto);
+ n=auth_opt->auth->h->send_conf_req(lcp->ppp,auth_opt->auth,(uint8_t*)(opt16+1));
+ opt16->hdr.len=4+n;
+
+ return 4+n;
}
-int auth_recv_conf_req(struct ppp_layer_t *l, struct lcp_opt_hdr_t *hdr)
+
+static int auth_recv_conf_req(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
{
- struct lcp_opt32_t *opt=(struct lcp_opt32_t*)hdr;
- struct auth_driver_t *drv;
- int i;
+ struct auth_option_t *auth_opt=container_of(opt,typeof(*auth_opt),opt);
+ struct lcp_opt16_t *opt16=(struct lcp_opt16_t*)ptr;
+ struct auth_data_t *d;
- for(i=0; i<AUTH_MAX; i++)
+ if (list_empty(&auth_opt->auth_list))
+ return LCP_OPT_REJ;
+
+ list_for_each_entry(d,&auth_opt->auth_list,entry)
{
- if (l->ppp->auth[i]==opt->val)
+ if (d->proto==ntohs(opt16->val))
{
- list_for_each_entry(drv,&drv_list,entry)
- {
- if (drv->type==l->ppp->auth[i])
- {
- if (drv->recv_conf_req(drv,l->ppp,opt))
- return -1;
- l->options.lcp.neg_auth[i]=1;
- return 0;
- }
- }
- return -1;
+ if (d->h->recv_conf_req(lcp->ppp,d,(uint8_t*)(opt16+1)))
+ break;
+ auth_opt->peer_auth=d;
+ return LCP_OPT_ACK;
}
}
- return -1;
+
+ list_for_each_entry(d,&auth_opt->auth_list,entry)
+ {
+ if (d->state!=LCP_OPT_NAK)
+ {
+ auth_opt->peer_auth=d;
+ return LCP_OPT_NAK;
+ }
+ }
+
+ log_msg("cann't negotiate authentication type\n");
+ return LCP_OPT_FAIL;
}
-int auth_recv_conf_rej(struct ppp_layer_t *l, struct lcp_opt_hdr_t *hdr)
+
+static int auth_recv_conf_ack(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
{
- struct lcp_opt32_t *opt=(struct lcp_opt32_t*)hdr;
- int i;
+ struct auth_option_t *auth_opt=container_of(opt,typeof(*auth_opt),opt);
+
+ auth_opt->peer_auth=NULL;
- for(i=0; i<AUTH_MAX; i++)
+ return 0;
+}
+
+static int auth_recv_conf_nak(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct auth_option_t *auth_opt=container_of(opt,typeof(*auth_opt),opt);
+ struct lcp_opt16_t *opt16=(struct lcp_opt16_t*)ptr;
+ struct auth_data_t *d;
+
+ list_for_each_entry(d,&auth_opt->auth_list,entry)
{
- if (l->ppp->auth[i]==opt->val)
+ if (d->proto==ntohs(opt16->val))
{
- l->options.lcp.neg_auth[i]=-1;
- break;
+ d->state=LCP_OPT_NAK;
+ if (d->h->recv_conf_req(lcp->ppp,d,(uint8_t*)(opt16+1)))
+ break;
+ auth_opt->auth=d;
+ return 0;
}
}
- for(i=0; i<AUTH_MAX; i++)
+
+ list_for_each_entry(d,&auth_opt->auth_list,entry)
{
- if (l->ppp->auth[i] && l->options.lcp.neg_auth[i]!=-1)
+ if (d->state!=LCP_OPT_NAK)
return 0;
}
+
+ log_msg("cann't negotiate authentication type\n");
+ return -1;
+}
+
+static int auth_recv_conf_rej(struct ppp_lcp_t *lcp, struct lcp_option_t *opt, uint8_t *ptr)
+{
+ struct auth_option_t *auth_opt=container_of(opt,typeof(*auth_opt),opt);
+
+ if (list_empty(&auth_opt->auth_list))
+ return 0;
+
+ log_msg("cann't negotiate authentication type\n");
return -1;
}
-int auth_recv_conf_nak(struct ppp_layer_t *l, struct lcp_opt_hdr_t *hdr)
+
+static void auth_print(void (*print)(const char *fmt,...),struct lcp_option_t *opt, uint8_t *ptr)
{
- struct lcp_opt32_t *opt=(struct lcp_opt32_t*)hdr;
- int i;
+ struct auth_option_t *auth_opt=container_of(opt,typeof(*auth_opt),opt);
+ struct lcp_opt16_t *opt16=(struct lcp_opt16_t*)ptr;
+ struct auth_data_t *d;
- for(i=0; i<AUTH_MAX; i++)
+ if (ptr)
{
- if (l->ppp->auth[i]==opt->val)
+ list_for_each_entry(d,&auth_opt->auth_list,entry)
{
- l->options.lcp.neg_auth[i]=2;
- return 0;
+ if (d->proto==ntohs(opt16->val))
+ goto print_d;
}
+
+ print("<auth %02x>",ntohs(opt16->val));
+ return;
}
- return -1;
+ else if (auth_opt->auth) d=auth_opt->auth;
+ else return;
+
+print_d:
+ print("<auth %s>",d->h->name);
}
+int ppp_auth_register_handler(struct ppp_auth_handler_t *h)
+{
+ list_add_tail(&h->entry,&auth_handlers);
+ return 0;
+}
+
+static void __init auth_opt_init()
+{
+ lcp_option_register(&auth_opt_hnd);
+}
+
+
+
+
+
+
+
+
int auth_start(struct ppp_t *ppp)
{
- int i;
- struct auth_driver_t *drv;
+ struct lcp_option_t *opt;
+ struct auth_option_t *auth_opt;
- for(i=0; i<AUTH_MAX; i++)
+ list_for_each_entry(opt,&ppp->lcp->options,entry)
{
- if (ppp->lcp_layer->options.lcp.neg_auth[i]==1)
+ if (opt->id==CI_AUTH)
{
- list_for_each_entry(drv,&drv_list,entry)
+ auth_opt=container_of(opt,typeof(*auth_opt),opt);
+ if (auth_opt->auth)
{
- if (drv->type==ppp->auth[i])
- return drv->start(ppp);
+ auth_opt->auth->h->start(ppp,auth_opt->auth);
+ return 1;
}
- return -1;
+ break;
}
}
@@ -132,21 +248,17 @@ int auth_start(struct ppp_t *ppp)
void auth_finish(struct ppp_t *ppp)
{
- int i;
- struct auth_driver_t *drv;
+ struct lcp_option_t *opt;
+ struct auth_option_t *auth_opt;
- for(i=0; i<AUTH_MAX; i++)
+ list_for_each_entry(opt,&ppp->lcp->options,entry)
{
- if (ppp->lcp_layer->options.lcp.neg_auth[i]==1)
+ if (opt->id==CI_AUTH)
{
- list_for_each_entry(drv,&drv_list,entry)
- {
- if (drv->type==ppp->auth[i])
- {
- drv->finish(ppp);
- return;
- }
- }
+ auth_opt=container_of(opt,typeof(*auth_opt),opt);
+ if (auth_opt->auth)
+ auth_opt->auth->h->finish(ppp,auth_opt->auth);
+ break;
}
}
}
diff --git a/accel-pptpd/ppp_auth.h b/accel-pptpd/ppp_auth.h
index 064bf24..f1880d5 100644
--- a/accel-pptpd/ppp_auth.h
+++ b/accel-pptpd/ppp_auth.h
@@ -3,24 +3,32 @@
#include "list.h"
-struct ppp_layer_t;
-struct lcp_opt_hdr_t;
-struct lcp_opt32_t;
+struct ppp_auth_handler_t;
-struct auth_driver_t
+struct auth_data_t
{
struct list_head entry;
- int type;
- int (*get_conf_req)(struct auth_driver_t*, struct ppp_t*, struct lcp_opt32_t*);
- int (*recv_conf_req)(struct auth_driver_t*, struct ppp_t*, struct lcp_opt32_t*);
- int (*begin)(struct auth_driver_t*, struct ppp_t*);
- int (*terminate)(struct auth_driver_t*, struct ppp_t*);
+ int proto;
+ int state;
+ struct ppp_auth_handler_t *h;
};
-int auth_get_conf_req(struct ppp_layer_t *l, struct lcp_opt32_t *);
-int auth_recv_conf_req(struct ppp_layer_t *l, struct lcp_opt_hdr_t *);
-int auth_recv_conf_rej(struct ppp_layer_t *l, struct lcp_opt_hdr_t *);
-int auth_recv_conf_nak(struct ppp_layer_t *l, struct lcp_opt_hdr_t *);
+struct ppp_auth_handler_t
+{
+ struct list_head entry;
+ const char *name;
+ struct auth_data_t* (*init)(struct ppp_t*);
+ int (*send_conf_req)(struct ppp_t*, struct auth_data_t*, uint8_t*);
+ int (*recv_conf_req)(struct ppp_t*, struct auth_data_t*, uint8_t*);
+ int (*start)(struct ppp_t*, struct auth_data_t*);
+ int (*finish)(struct ppp_t*, struct auth_data_t*);
+ void (*free)(struct ppp_t*,struct auth_data_t*);
+};
+
+int ppp_auth_register_handler(struct ppp_auth_handler_t*);
+
+void auth_successed(struct ppp_t *ppp);
+void auth_failed(struct ppp_t *ppp);
#endif
diff --git a/accel-pptpd/ppp_ccp.c b/accel-pptpd/ppp_ccp.c
new file mode 100644
index 0000000..2f3ce4a
--- /dev/null
+++ b/accel-pptpd/ppp_ccp.c
@@ -0,0 +1,12 @@
+#include "ppp.h"
+
+int ccp_start(struct ppp_t *ppp)
+{
+ return 0;
+}
+
+void ccp_finish(struct ppp_t *ppp)
+{
+
+}
+
diff --git a/accel-pptpd/ppp_fsm.c b/accel-pptpd/ppp_fsm.c
index fdbcbe9..e2884c2 100644
--- a/accel-pptpd/ppp_fsm.c
+++ b/accel-pptpd/ppp_fsm.c
@@ -14,16 +14,17 @@
#include "ppp.h"
#include "ppp_fsm.h"
#include "ppp_lcp.h"
+#include "log.h"
-void send_term_req(struct ppp_layer_t *layer);
-void send_term_ack(struct ppp_layer_t *layer);
-void send_echo_reply(struct ppp_layer_t *layer);
+void send_term_req(struct ppp_fsm_t *layer);
+void send_term_ack(struct ppp_fsm_t *layer);
+void send_echo_reply(struct ppp_fsm_t *layer);
-static void init_req_counter(struct ppp_layer_t *layer,int timeout);
-static void zero_req_counter(struct ppp_layer_t *layer);
+static void init_req_counter(struct ppp_fsm_t *layer,int timeout);
+static void zero_req_counter(struct ppp_fsm_t *layer);
static int restart_timer_func(struct triton_timer_t*t);
-void ppp_fsm_init(struct ppp_layer_t *layer)
+void ppp_fsm_init(struct ppp_fsm_t *layer)
{
layer->fsm_state=FSM_Initial;
layer->restart_timer.active=0;
@@ -34,10 +35,9 @@ void ppp_fsm_init(struct ppp_layer_t *layer)
layer->max_terminate=2;
layer->max_configure=10;
layer->max_failure=5;
- layer->id=0;
}
-void ppp_fsm_lower_up(struct ppp_layer_t *layer)
+void ppp_fsm_lower_up(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
@@ -55,7 +55,7 @@ void ppp_fsm_lower_up(struct ppp_layer_t *layer)
}
}
-void ppp_fsm_lower_down(struct ppp_layer_t *layer)
+void ppp_fsm_lower_down(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
@@ -82,7 +82,7 @@ void ppp_fsm_lower_down(struct ppp_layer_t *layer)
}
}
-void ppp_fsm_open(struct ppp_layer_t *layer)
+void ppp_fsm_open(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
@@ -103,18 +103,15 @@ void ppp_fsm_open(struct ppp_layer_t *layer)
layer->fsm_state=FSM_Stopping;
case FSM_Stopped:
case FSM_Opened:
- if (layer->opt_restart)
- {
- ppp_fsm_lower_down(layer);
- ppp_fsm_lower_up(layer);
- }
+ ppp_fsm_lower_down(layer);
+ ppp_fsm_lower_up(layer);
break;
default:
break;
}
}
-void ppp_fsm_close(struct ppp_layer_t *layer)
+void ppp_fsm_close(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
@@ -143,7 +140,7 @@ void ppp_fsm_close(struct ppp_layer_t *layer)
}
}
-void ppp_fsm_timeout0(struct ppp_layer_t *layer)
+void ppp_fsm_timeout0(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
@@ -162,7 +159,7 @@ void ppp_fsm_timeout0(struct ppp_layer_t *layer)
}
}
-void ppp_fsm_timeout1(struct ppp_layer_t *layer)
+void ppp_fsm_timeout1(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
@@ -179,14 +176,13 @@ void ppp_fsm_timeout1(struct ppp_layer_t *layer)
case FSM_Ack_Sent:
if (layer->layer_finished) layer->layer_finished(layer);
layer->fsm_state=FSM_Stopped;
- layer->opt_passive=1;
break;
default:
break;
}
}
-void ppp_fsm_recv_conf_req_good(struct ppp_layer_t *layer)
+void ppp_fsm_recv_conf_req_ack(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
@@ -219,7 +215,37 @@ void ppp_fsm_recv_conf_req_good(struct ppp_layer_t *layer)
}
}
-void ppp_fsm_recv_conf_req_bad(struct ppp_layer_t *layer)
+void ppp_fsm_recv_conf_req_nak(struct ppp_fsm_t *layer)
+{
+ switch(layer->fsm_state)
+ {
+ case FSM_Closed:
+ send_term_ack(layer);
+ break;
+ case FSM_Stopped:
+ //if (layer->init_req_cnt) layer->init_req_cnt(layer);
+ init_req_counter(layer,layer->max_configure);
+ if (layer->send_conf_req) layer->send_conf_req(layer);
+ case FSM_Ack_Sent:
+ if (layer->send_conf_nak) layer->send_conf_nak(layer);
+ layer->fsm_state=FSM_Req_Sent;
+ break;
+ case FSM_Req_Sent:
+ case FSM_Ack_Rcvd:
+ if (layer->send_conf_nak) layer->send_conf_nak(layer);
+ break;
+ case FSM_Opened:
+ if (layer->layer_down) layer->layer_down(layer);
+ if (layer->send_conf_req) layer->send_conf_req(layer);
+ if (layer->send_conf_nak) layer->send_conf_nak(layer);
+ layer->fsm_state=FSM_Req_Sent;
+ break;
+ default:
+ break;
+ }
+}
+
+void ppp_fsm_recv_conf_req_rej(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
@@ -249,7 +275,7 @@ void ppp_fsm_recv_conf_req_bad(struct ppp_layer_t *layer)
}
}
-void ppp_fsm_recv_conf_ack(struct ppp_layer_t *layer)
+void ppp_fsm_recv_conf_ack(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
@@ -282,7 +308,7 @@ void ppp_fsm_recv_conf_ack(struct ppp_layer_t *layer)
}
}
-void ppp_fsm_recv_conf_rej(struct ppp_layer_t *layer)
+void ppp_fsm_recv_conf_rej(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
@@ -314,7 +340,7 @@ void ppp_fsm_recv_conf_rej(struct ppp_layer_t *layer)
}
}
-void ppp_fsm_recv_term_req(struct ppp_layer_t *layer)
+void ppp_fsm_recv_term_req(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
@@ -337,7 +363,7 @@ void ppp_fsm_recv_term_req(struct ppp_layer_t *layer)
}
}
-void ppp_fsm_recv_term_ack(struct ppp_layer_t *layer)
+void ppp_fsm_recv_term_ack(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
@@ -362,12 +388,12 @@ void ppp_fsm_recv_term_ack(struct ppp_layer_t *layer)
}
}
-void ppp_fsm_recv_unk(struct ppp_layer_t *layer)
+void ppp_fsm_recv_unk(struct ppp_fsm_t *layer)
{
if (layer->send_conf_rej) layer->send_conf_rej(layer);
}
-void ppp_fsm_recv_code_rej_perm(struct ppp_layer_t *layer)
+void ppp_fsm_recv_code_rej_perm(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
@@ -379,15 +405,13 @@ void ppp_fsm_recv_code_rej_perm(struct ppp_layer_t *layer)
}
}
-void ppp_fsm_recv_code_rej_bad(struct ppp_layer_t *layer)
+void ppp_fsm_recv_code_rej_bad(struct ppp_fsm_t *layer)
{
switch(layer->fsm_state)
{
case FSM_Opened:
if (layer->layer_down) layer->layer_down(layer);
- //if (layer->init_req_cnt) layer->init_req_cnt(layer);
- init_req_counter(layer,layer->max_configure);
- if (layer->send_conf_req) layer->send_conf_req(layer);
+ send_term_req(layer);
layer->fsm_state=FSM_Stopping;
break;
case FSM_Closing:
@@ -406,53 +430,55 @@ void ppp_fsm_recv_code_rej_bad(struct ppp_layer_t *layer)
}
}
-void send_term_req(struct ppp_layer_t *layer)
+void send_term_req(struct ppp_fsm_t *layer)
{
struct lcp_hdr_t hdr={
- .proto=PPP_LCP,
+ .proto=htons(PPP_LCP),
.code=TERMREQ,
.id=++layer->id,
- .len=4,
+ .len=htons(4),
};
- ppp_send(layer->ppp,&hdr,hdr.len);
+ log_debug("send [LCP TermReq id=%i \"\"]\n",hdr.id);
+
+ ppp_send(layer->ppp,&hdr,6);
}
-void send_term_ack(struct ppp_layer_t *layer)
+void send_term_ack(struct ppp_fsm_t *layer)
{
struct lcp_hdr_t hdr={
- .proto=PPP_LCP,
+ .proto=htons(PPP_LCP),
.code=TERMACK,
.id=layer->recv_id,
- .len=4,
+ .len=htons(4),
};
- ppp_send(layer->ppp,&hdr,hdr.len);
-}
-void ppp_fsm_recv(struct ppp_layer_t *layer)
-{
+ log_debug("send [LCP TermAck id=%i \"\"]\n",hdr.id);
+
+ ppp_send(layer->ppp,&hdr,6);
}
-static void init_req_counter(struct ppp_layer_t *layer,int timeout)
+static void init_req_counter(struct ppp_fsm_t *layer,int timeout)
{
triton_timer_del(&layer->restart_timer);
+ layer->restart_timer.expire_tv.tv_sec=0;
triton_timer_add(&layer->restart_timer);
layer->restart_counter=timeout;
}
-static void zero_req_counter(struct ppp_layer_t *layer)
+static void zero_req_counter(struct ppp_fsm_t *layer)
{
triton_timer_del(&layer->restart_timer);
+ layer->restart_timer.expire_tv.tv_sec=0;
triton_timer_add(&layer->restart_timer);
layer->restart_counter=0;
}
static int restart_timer_func(struct triton_timer_t*t)
{
- struct ppp_layer_t *layer=(struct ppp_layer_t *)t->pd;
+ struct ppp_fsm_t *layer=(struct ppp_fsm_t *)t->pd;
if (layer->restart_counter)
{
ppp_fsm_timeout0(layer);
- layer->restart_counter--;
return 1;
}
diff --git a/accel-pptpd/ppp_fsm.h b/accel-pptpd/ppp_fsm.h
index 3ed6284..eddafcf 100644
--- a/accel-pptpd/ppp_fsm.h
+++ b/accel-pptpd/ppp_fsm.h
@@ -1,9 +1,6 @@
#ifndef PPP_FSM_H
#define PPP_FSM_H
-#include "triton/triton.h"
-#include "list.h"
-
typedef enum {FSM_Initial=0,FSM_Starting,FSM_Closed,FSM_Stopped,FSM_Closing,FSM_Stopping,FSM_Req_Sent,FSM_Ack_Rcvd,FSM_Ack_Sent,FSM_Opened} FSM_STATE;
/*
* CP (LCP, IPCP, etc.) codes.
@@ -18,35 +15,13 @@ typedef enum {FSM_Initial=0,FSM_Starting,FSM_Closed,FSM_Stopped,FSM_Closing,FSM_
#define ECHOREQ 9 /* Echo Request */
#define ECHOREP 10 /* Echo Reply */
-struct ppp_hdr_t;
-
-#define AUTH_MAX 3
-struct lcp_options_t
-{
- int magic;
- int mtu;
- int mru;
- int accomp; // 0 - disabled, 1 - enable, 2 - allow, disabled, 3 - allow,enabled
- int pcomp; // 0 - disabled, 1 - enable, 2 - allow, disabled, 3 - allow,enabled
- // negotiated options;
- int neg_mru;
- int neg_mtu;
- int neg_accomp; // -1 - rejected
- int neg_pcomp;
- int neg_auth[AUTH_MAX];
-};
+struct ppp_t;
-struct ppp_layer_t
+struct ppp_fsm_t
{
- struct ppp_handler_t h;
struct ppp_t *ppp;
FSM_STATE fsm_state;
- union
- {
- struct lcp_options_t lcp;
- } options;
-
struct triton_timer_t restart_timer;
int restart_counter;
int max_terminate;
@@ -56,38 +31,33 @@ struct ppp_layer_t
int id;
int recv_id;
- int opt_restart:1;
- int opt_passive:1;
-
- void *last_conf_req;
//fsm handling
- void (*layer_up)(struct ppp_layer_t*);
- void (*layer_down)(struct ppp_layer_t*);
- void (*layer_started)(struct ppp_layer_t*);
- void (*layer_finished)(struct ppp_layer_t*);
- void (*send_conf_req)(struct ppp_layer_t*);
- void (*send_conf_ack)(struct ppp_layer_t*);
- void (*send_conf_nak)(struct ppp_layer_t*);
- void (*send_conf_rej)(struct ppp_layer_t*);
+ void (*layer_up)(struct ppp_fsm_t*);
+ void (*layer_down)(struct ppp_fsm_t*);
+ void (*layer_started)(struct ppp_fsm_t*);
+ void (*layer_finished)(struct ppp_fsm_t*);
+ void (*send_conf_req)(struct ppp_fsm_t*);
+ void (*send_conf_ack)(struct ppp_fsm_t*);
+ void (*send_conf_nak)(struct ppp_fsm_t*);
+ void (*send_conf_rej)(struct ppp_fsm_t*);
};
-void ppp_fsm_init(struct ppp_layer_t*);
-void ppp_fsm_recv(struct ppp_layer_t*);
-
-void ppp_fsm_lower_up(struct ppp_layer_t *layer);
-void ppp_fsm_lower_down(struct ppp_layer_t *layer);
-void ppp_fsm_open(struct ppp_layer_t *layer);
-void ppp_fsm_close(struct ppp_layer_t *layer);
-void ppp_fsm_timeout0(struct ppp_layer_t *layer);
-void ppp_fsm_timeout1(struct ppp_layer_t *layer);
-void ppp_fsm_recv_conf_req_good(struct ppp_layer_t *layer);
-void ppp_fsm_recv_conf_req_bad(struct ppp_layer_t *layer);
-void ppp_fsm_recv_conf_ack(struct ppp_layer_t *layer);
-void ppp_fsm_recv_conf_rej(struct ppp_layer_t *layer);
-void ppp_fsm_recv_term_req(struct ppp_layer_t *layer);
-void ppp_fsm_recv_term_ack(struct ppp_layer_t *layer);
-void ppp_fsm_recv_unk(struct ppp_layer_t *layer);
-void ppp_fsm_recv_code_rej_bad(struct ppp_layer_t *layer);
-void ppp_fsm_recv_echo(struct ppp_layer_t *layer);
+void ppp_fsm_init(struct ppp_fsm_t*);
+
+void ppp_fsm_lower_up(struct ppp_fsm_t*);
+void ppp_fsm_lower_down(struct ppp_fsm_t*);
+void ppp_fsm_open(struct ppp_fsm_t*);
+void ppp_fsm_close(struct ppp_fsm_t*);
+void ppp_fsm_timeout0(struct ppp_fsm_t *layer);
+void ppp_fsm_timeout1(struct ppp_fsm_t *layer);
+void ppp_fsm_recv_conf_req_ack(struct ppp_fsm_t *layer);
+void ppp_fsm_recv_conf_req_nak(struct ppp_fsm_t *layer);
+void ppp_fsm_recv_conf_req_rej(struct ppp_fsm_t *layer);
+void ppp_fsm_recv_conf_ack(struct ppp_fsm_t *layer);
+void ppp_fsm_recv_conf_rej(struct ppp_fsm_t *layer);
+void ppp_fsm_recv_term_req(struct ppp_fsm_t *layer);
+void ppp_fsm_recv_term_ack(struct ppp_fsm_t *layer);
+void ppp_fsm_recv_unk(struct ppp_fsm_t *layer);
+void ppp_fsm_recv_code_rej_bad(struct ppp_fsm_t *layer);
#endif
diff --git a/accel-pptpd/ppp_ipcp.c b/accel-pptpd/ppp_ipcp.c
new file mode 100644
index 0000000..09b0483
--- /dev/null
+++ b/accel-pptpd/ppp_ipcp.c
@@ -0,0 +1,12 @@
+#include "ppp.h"
+
+int ipcp_start(struct ppp_t *ppp)
+{
+ return 0;
+}
+
+void ipcp_finish(struct ppp_t *ppp)
+{
+
+}
+
diff --git a/accel-pptpd/ppp_lcp.c b/accel-pptpd/ppp_lcp.c
index 2d1dee0..21b7fb2 100644
--- a/accel-pptpd/ppp_lcp.c
+++ b/accel-pptpd/ppp_lcp.c
@@ -10,318 +10,420 @@
#include "log.h"
#include "ppp.h"
-#include "ppp_fsm.h"
#include "ppp_lcp.h"
-#include "ppp_auth.h"
-
-char* accomp="allow,disabled";
-char* pcomp="allow,disabled";
-char* auth="pap,eap,mschap-v2";
-char* mppe="allow,disabled";
-char* pwdb="radius";
-
-static void lcp_layer_up(struct ppp_layer_t*);
-static void lcp_layer_down(struct ppp_layer_t*);
-static void send_conf_req(struct ppp_layer_t*);
-static void send_conf_ack(struct ppp_layer_t*);
-static void send_conf_nak(struct ppp_layer_t*);
-static void send_conf_rej(struct ppp_layer_t*);
-static void lcp_recv(struct ppp_layer_t*);
+
+struct recv_opt_t
+{
+ struct list_head entry;
+ struct lcp_opt_hdr_t *hdr;
+ int len;
+ int state;
+ struct lcp_option_t *lopt;
+};
+
+static LIST_HEAD(option_handlers);
+
+static void lcp_layer_up(struct ppp_fsm_t*);
+static void lcp_layer_down(struct ppp_fsm_t*);
+static void send_conf_req(struct ppp_fsm_t*);
+static void send_conf_ack(struct ppp_fsm_t*);
+static void send_conf_nak(struct ppp_fsm_t*);
+static void send_conf_rej(struct ppp_fsm_t*);
+static void lcp_recv(struct ppp_handler_t*);
+
+static void lcp_options_init(struct ppp_lcp_t *lcp)
+{
+ struct lcp_option_t *lopt;
+ struct lcp_option_handler_t *h;
+
+ INIT_LIST_HEAD(&lcp->options);
+
+ list_for_each_entry(h,&option_handlers,entry)
+ {
+ lopt=h->init(lcp);
+ if (lopt)
+ {
+ lopt->h=h;
+ list_add_tail(&lopt->entry,&lcp->options);
+ lcp->conf_req_len+=lopt->len;
+ }
+ }
+}
+
+static void lcp_options_free(struct ppp_lcp_t *lcp)
+{
+ struct lcp_option_t *lopt;
+
+ while(!list_empty(&lcp->options))
+ {
+ lopt=list_entry(lcp->options.next,typeof(*lopt),entry);
+ list_del(&lopt->entry);
+ lopt->h->free(lcp,lopt);
+ }
+}
void lcp_start(struct ppp_t *ppp)
{
- struct ppp_layer_t *layer=malloc(sizeof(*layer));
- memset(layer,0,sizeof(*layer));
+ struct ppp_lcp_t *lcp=malloc(sizeof(*lcp));
+ memset(lcp,0,sizeof(*lcp));
- layer->h.proto=PPP_LCP;
- layer->h.recv=lcp_recv;
+ lcp->ppp=ppp;
+ lcp->fsm.ppp=ppp;
- layer->ppp=ppp;
- ppp_fsm_init(layer);
+ lcp->hnd.proto=PPP_LCP;
+ lcp->hnd.recv=lcp_recv;
+
+ ppp_register_handler(ppp,&lcp->hnd);
+
+ ppp_fsm_init(&lcp->fsm);
- layer->layer_started=lcp_layer_started;
- layer->send_conf_req=send_conf_req;
- layer->send_conf_ack=send_conf_ack;
- layer->send_conf_nak=send_conf_nak;
- layer->send_conf_rej=send_conf_rej;
+ lcp->fsm.layer_up=lcp_layer_up;
+ lcp->fsm.layer_down=lcp_layer_down;
+ lcp->fsm.send_conf_req=send_conf_req;
+ lcp->fsm.send_conf_ack=send_conf_ack;
+ lcp->fsm.send_conf_nak=send_conf_nak;
+ lcp->fsm.send_conf_rej=send_conf_rej;
- ppp_fsm_init(layer);
- ppp_fsm_lower_up(layer);
- ppp_fsm_open(layer);
+ lcp_options_init(lcp);
+ INIT_LIST_HEAD(&lcp->ropt_list);
- ppp_register_handler(&layer->h);
+ ppp_fsm_lower_up(&lcp->fsm);
+ ppp_fsm_open(&lcp->fsm);
+
+ ppp->lcp=lcp;
}
-static void lcp_layer_up(struct ppp_layer_t *l)
+void lcp_finish(struct ppp_t *ppp)
{
- ppp_layer_started(l->ppp);
+ struct ppp_lcp_t *lcp=ppp->lcp;
+
+ ppp_unregister_handler(ppp,&lcp->hnd);
+ lcp_options_free(lcp);
+
+ free(lcp);
}
-static void lcp_layer_down(struct ppp_layer_t *l)
+
+static void lcp_layer_up(struct ppp_fsm_t *fsm)
{
- ppp_terminate(l->ppp);
+ struct ppp_lcp_t *lcp=container_of(fsm,typeof(*lcp),fsm);
+ ppp_layer_started(lcp->ppp);
}
-static void send_conf_req(struct ppp_layer_t*l)
+static void lcp_layer_down(struct ppp_fsm_t *fsm)
{
- uint8_t buf[128],*ptr=buf;
- struct lcp_opt_hdr_t *opt0;
- struct lcp_opt16_t *opt16;
- struct lcp_opt32_t *opt32;
- struct lcp_hdr_t *lcp_hdr=(struct lcp_hdr_t*)ptr; ptr+=sizeof(*lcp_hdr);
-
- log_msg("send [LCP ConfReq");
- lcp_hdr->proto=PPP_LCP;
- lcp_hdr->code=CONFREQ;
- lcp_hdr->id=++l->id;
- lcp_hdr->len=0;
- log_msg(" id=%x",lcp_hdr->id);
-
- //mru
- opt16=(struct lcp_opt16_t*)ptr; ptr+=sizeof(*opt16);
- opt16->hdr.type=CI_MRU;
- opt16->hdr.len=4;
- opt16->val=htons(l->options.lcp.mtu);
- log_msg(" <mru %i>",l->options.lcp.mtu);
-
- //auth
- opt32=(struct lcp_opt32_t*)ptr;;
- if (auth_get_conf_req(l,opt32))
- ptr+=opt32->hdr.len;
-
- //magic
- opt32=(struct lcp_opt32_t*)ptr; ptr+=sizeof(*opt32);
- opt32->hdr.type=CI_MAGIC;
- opt32->hdr.len=6;
- opt32->val=htonl(l->options.lcp.magic);
- log_msg(" <magic %x>",l->options.lcp.magic);
+ struct ppp_lcp_t *lcp=container_of(fsm,typeof(*lcp),fsm);
+ ppp_terminate(lcp->ppp);
+}
+static void print_ropt(struct recv_opt_t *ropt)
+{
+ int i;
+ uint8_t *ptr=(uint8_t*)ropt->hdr;
- //pcomp
- if (l->options.lcp.pcomp==1 || (l->options.lcp.pcomp==3 && l->options.lcp.neg_pcomp!=-1))
+ log_debug(" <");
+ for(i=0; i<ropt->len; i++)
{
- opt0=(struct lcp_opt_hdr_t*)ptr; ptr+=sizeof(*opt0);
- opt0->type=CI_PCOMP;
- opt0->len=2;
- log_msg(" <pcomp>");
+ log_debug(" %x",ptr[i]);
}
+ log_debug(">");
+}
- //acccomp
- if (l->options.lcp.accomp==1 || (l->options.lcp.accomp==3 && l->options.lcp.neg_accomp!=-1))
+static void send_conf_req(struct ppp_fsm_t *fsm)
+{
+ struct ppp_lcp_t *lcp=container_of(fsm,typeof(*lcp),fsm);
+ uint8_t *buf=malloc(lcp->conf_req_len), *ptr=buf;
+ struct lcp_hdr_t *lcp_hdr=(struct lcp_hdr_t*)ptr;
+ struct lcp_option_t *lopt;
+ int n;
+
+ log_debug("send [LCP ConfReq");
+ lcp_hdr->proto=htons(PPP_LCP);
+ lcp_hdr->code=CONFREQ;
+ lcp_hdr->id=++lcp->fsm.id;
+ lcp_hdr->len=0;
+ log_debug(" id=%x",lcp_hdr->id);
+
+ ptr+=sizeof(*lcp_hdr);
+
+ list_for_each_entry(lopt,&lcp->options,entry)
{
- opt0=(struct lcp_opt_hdr_t*)ptr; ptr+=sizeof(*opt0);
- opt0->type=CI_ACCOMP;
- opt0->len=2;
- log_msg(" <accomp>");
+ n=lopt->h->send_conf_req(lcp,lopt,ptr);
+ if (n)
+ {
+ log_debug(" ");
+ lopt->h->print(log_debug,lopt,NULL);
+ ptr+=n;
+ }
}
- log_msg("]\n");
+
+ log_debug("]\n");
- lcp_hdr->len=ptr-buf;
- ppp_send(l->ppp,lcp_hdr,lcp_hdr->len+2);
+ lcp_hdr->len=htons((ptr-buf)-2);
+ ppp_send(lcp->ppp,lcp_hdr,ptr-buf);
}
-static void send_conf_ack(struct ppp_layer_t*l)
+
+static void send_conf_ack(struct ppp_fsm_t *fsm)
{
- struct lcp_hdr_t *hdr=(struct lcp_hdr_t*)l->ppp->in_buf;
+ struct ppp_lcp_t *lcp=container_of(fsm,typeof(*lcp),fsm);
+ struct lcp_hdr_t *hdr=(struct lcp_hdr_t*)lcp->ppp->in_buf;
hdr->code=CONFACK;
- log_msg("send [LCP ConfAck id=%x\n",l->recv_id);
+ log_debug("send [LCP ConfAck id=%x ]\n",lcp->fsm.recv_id);
- ppp_send(l->ppp,hdr,hdr->len+2);
+ ppp_send(lcp->ppp,hdr,ntohs(hdr->len)+2);
}
-static void send_conf_nak(struct ppp_layer_t*l)
+
+static void send_conf_nak(struct ppp_fsm_t *fsm)
{
+ struct ppp_lcp_t *lcp=container_of(fsm,typeof(*lcp),fsm);
+ uint8_t *buf=malloc(lcp->conf_req_len), *ptr=buf;
+ struct lcp_hdr_t *lcp_hdr=(struct lcp_hdr_t*)ptr;
+ struct lcp_option_t *lopt;
+
+ log_debug("send [LCP ConfNak id=%x",lcp->fsm.recv_id);
+
+ lcp_hdr->proto=htons(PPP_LCP);
+ lcp_hdr->code=CONFNAK;
+ lcp_hdr->id=lcp->fsm.recv_id;
+ lcp_hdr->len=0;
+
+ ptr+=sizeof(*lcp_hdr);
+
+ list_for_each_entry(lopt,&lcp->options,entry)
+ {
+ if (lopt->state==LCP_OPT_NAK)
+ {
+ log_debug(" ");
+ lopt->h->print(log_debug,lopt,NULL);
+ ptr+=lopt->h->send_conf_nak(lcp,lopt,ptr);
+ }
+ }
+
+ log_debug("]\n");
+
+ lcp_hdr->len=htons((ptr-buf)-2);
+ ppp_send(lcp->ppp,lcp_hdr,ptr-buf);
}
-static void send_conf_rej(struct ppp_layer_t*l)
+
+static void send_conf_rej(struct ppp_fsm_t *fsm)
{
- struct lcp_hdr_t *hdr=(struct lcp_hdr_t*)l->ppp->in_buf;
+ struct ppp_lcp_t *lcp=container_of(fsm,typeof(*lcp),fsm);
+ uint8_t *buf=malloc(lcp->ropt_len), *ptr=buf;
+ struct lcp_hdr_t *lcp_hdr=(struct lcp_hdr_t*)ptr;
+ struct recv_opt_t *ropt;
+
+ log_debug("send [LCP ConfRej id=%x ",lcp->fsm.recv_id);
+
+ lcp_hdr->proto=htons(PPP_LCP);
+ lcp_hdr->code=CONFREJ;
+ lcp_hdr->id=lcp->fsm.recv_id;
+ lcp_hdr->len=0;
- hdr->code=CONFREJ;
- log_msg("send [LCP ConfRej id=%x\n",l->recv_id);
+ ptr+=sizeof(*lcp_hdr);
- ppp_send(l->ppp,hdr,hdr->len+2);
+ list_for_each_entry(ropt,&lcp->ropt_list,entry)
+ {
+ if (ropt->state==LCP_OPT_REJ)
+ {
+ log_debug(" ");
+ if (ropt->lopt) ropt->lopt->h->print(log_debug,ropt->lopt,(uint8_t*)ropt->hdr);
+ else print_ropt(ropt);
+ memcpy(ptr,ropt->hdr,ropt->len);
+ ptr+=ropt->len;
+ }
+ }
+
+ log_debug("]\n");
+
+ lcp_hdr->len=htons((ptr-buf)-2);
+ ppp_send(lcp->ppp,lcp_hdr,ptr-buf);
}
-static int lcp_recv_conf_req(struct ppp_layer_t*l,uint8_t *data,int size)
+static int lcp_recv_conf_req(struct ppp_lcp_t *lcp,uint8_t *data,int size)
{
- struct lcp_opt_hdr_t *opt;
- struct lcp_opt16_t *opt16;
+ struct lcp_opt_hdr_t *hdr;
+ struct recv_opt_t *ropt;
+ struct lcp_option_t *lopt;
+ int r,ret=1;
+
+ lcp->ropt_len=size;
+
+ while(size>0)
+ {
+ hdr=(struct lcp_opt_hdr_t *)data;
+
+ ropt=malloc(sizeof(*ropt));
+ if (hdr->len>size) ropt->len=size;
+ else ropt->len=hdr->len;
+ ropt->hdr=hdr;
+ ropt->state=LCP_OPT_NONE;
+ list_add_tail(&ropt->entry,&lcp->ropt_list);
+
+ data+=ropt->len;
+ size-=ropt->len;
+ }
+
+ list_for_each_entry(lopt,&lcp->options,entry)
+ lopt->state=LCP_OPT_NONE;
+
+ log_debug("recv [LCP ConfReq id=%x",lcp->fsm.recv_id);
+ list_for_each_entry(ropt,&lcp->ropt_list,entry)
+ {
+ list_for_each_entry(lopt,&lcp->options,entry)
+ {
+ if (lopt->id==ropt->hdr->id)
+ {
+ log_debug(" ");
+ lopt->h->print(log_debug,lopt,(uint8_t*)ropt->hdr);
+ r=lopt->h->recv_conf_req(lcp,lopt,(uint8_t*)ropt->hdr);
+ lopt->state=r;
+ ropt->state=r;
+ if (r<ret) ret=r;
+ }
+ }
+ }
+ log_debug("]\n");
+
+ /*list_for_each_entry(lopt,&lcp->options,entry)
+ {
+ if (lopt->state==LCP_OPT_NONE)
+ {
+ r=lopt->h->recv_conf_req(lcp,lopt,NULL);
+ lopt->state=r;
+ if (r<ret) ret=r;
+ }
+ }*/
+
+ return ret;
+}
+
+static void lcp_free_conf_req(struct ppp_lcp_t *lcp)
+{
+ struct recv_opt_t *ropt;
+
+ while(!list_empty(&lcp->ropt_list))
+ {
+ ropt=list_entry(lcp->ropt_list.next,typeof(*ropt),entry);
+ list_del(&ropt->entry);
+ free(ropt);
+ }
+}
+
+static int lcp_recv_conf_rej(struct ppp_lcp_t *lcp,uint8_t *data,int size)
+{
+ struct lcp_opt_hdr_t *hdr;
+ struct lcp_option_t *lopt;
int res=0;
- log_debug("recv [LCP ConfReq id=%x",l->recv_id);
+ log_debug("recv [LCP ConfRej id=%x",lcp->fsm.recv_id);
- while(size)
+ if (lcp->fsm.recv_id!=lcp->fsm.id)
{
- opt=(struct lcp_opt_hdr_t *)data;
- switch(opt->type)
+ log_debug(": id mismatch ]\n");
+ return 0;
+ }
+
+ while(size>0)
+ {
+ hdr=(struct lcp_opt_hdr_t *)data;
+
+ list_for_each_entry(lopt,&lcp->options,entry)
{
- case CI_MRU:
- opt16=(struct lcp_opt16_t*)data;
- l->options.lcp.neg_mru=ntohs(opt16->val);
- log_debug(" <mru %i>",l->options.lcp.neg_mru);
- break;
- case CI_ASYNCMAP:
- log_debug(" <asyncmap ...>");
- break;
- case CI_AUTHTYPE:
- if (auth_recv_conf_req(l,opt))
- res=-1;
- break;
- case CI_MAGIC:
- if (*(uint32_t*)data==l->options.lcp.magic)
- {
- log_error("loop detected\n");
- res=-1;
- }
- break;
- case CI_PCOMP:
- log_debug(" <pcomp>");
- if (l->options.lcp.pcomp>=1) l->options.lcp.neg_pcomp=1;
- else {
- l->options.lcp.neg_pcomp=-2;
- res=-1;
- }
- break;
- case CI_ACCOMP:
- log_debug(" <accomp>");
- if (l->options.lcp.accomp>=1) l->options.lcp.neg_accomp=1;
- else {
- l->options.lcp.neg_accomp=-2;
+ if (lopt->id==hdr->id)
+ {
+ if (lopt->h->recv_conf_rej(lcp,lopt,data))
res=-1;
- }
break;
+ }
}
- data+=opt->len;
- size-=opt->len;
+
+ data+=hdr->len;
+ size-=hdr->len;
}
- log_debug("\n");
+ log_debug("]\n");
return res;
}
-static int lcp_recv_conf_rej(struct ppp_layer_t*l,uint8_t *data,int size)
+static int lcp_recv_conf_nak(struct ppp_lcp_t *lcp,uint8_t *data,int size)
{
- struct lcp_opt_hdr_t *opt;
- struct lcp_opt16_t *opt16;
+ struct lcp_opt_hdr_t *hdr;
+ struct lcp_option_t *lopt;
int res=0;
- log_debug("recv [LCP ConfRej id=%x",l->recv_id);
+ log_debug("recv [LCP ConfNak id=%x",lcp->fsm.recv_id);
- if (l->recv_id!=l->id)
+ if (lcp->fsm.recv_id!=lcp->fsm.id)
{
- log_debug(": id mismatch\n");
+ log_debug(": id mismatch ]\n");
return 0;
}
- while(size)
+ while(size>0)
{
- opt=(struct lcp_opt_hdr_t *)data;
- switch(opt->type)
+ hdr=(struct lcp_opt_hdr_t *)data;
+
+ list_for_each_entry(lopt,&lcp->options,entry)
{
- case CI_MRU:
- opt16=(struct lcp_opt16_t*)data;
- log_debug(" <mru %i>",l->options.lcp.neg_mru);
- break;
- case CI_ASYNCMAP:
- log_debug(" <asyncmap ...>");
- break;
- case CI_AUTHTYPE:
- if (auth_recv_conf_rej(l,opt))
- res=-1;
- break;
- case CI_MAGIC:
- if (*(uint32_t*)data==l->options.lcp.magic)
- {
- log_error("loop detected\n");
+ if (lopt->id==hdr->id)
+ {
+ log_debug(" ");
+ lopt->h->print(log_debug,lopt,data);
+ if (lopt->h->recv_conf_nak(lcp,lopt,data))
res=-1;
- }
- break;
- case CI_PCOMP:
- log_debug(" <pcomp>");
- if (l->options.lcp.pcomp>=1) l->options.lcp.neg_pcomp=-1;
- else {
- l->options.lcp.neg_pcomp=-2;
- res=-1;
- }
- break;
- case CI_ACCOMP:
- log_debug(" <accomp>");
- if (l->options.lcp.accomp>=1) l->options.lcp.neg_accomp=-1;
- else {
- l->options.lcp.neg_accomp=-2;
- res=-1;
- }
break;
+ }
}
- data+=opt->len;
- size-=opt->len;
+
+ data+=hdr->len;
+ size-=hdr->len;
}
- log_debug("\n");
+ log_debug("]\n");
return res;
}
-static int lcp_recv_conf_nak(struct ppp_layer_t*l,uint8_t *data,int size)
+
+static int lcp_recv_conf_ack(struct ppp_lcp_t *lcp,uint8_t *data,int size)
{
- struct lcp_opt_hdr_t *opt;
- struct lcp_opt16_t *opt16;
+ struct lcp_opt_hdr_t *hdr;
+ struct lcp_option_t *lopt;
int res=0;
- log_debug("recv [LCP ConfNak id=%x",l->recv_id);
+ log_debug("recv [LCP ConfAck id=%x",lcp->fsm.recv_id);
- if (l->recv_id!=l->id)
+ if (lcp->fsm.recv_id!=lcp->fsm.id)
{
- log_debug(": id mismatch\n");
+ log_debug(": id mismatch ]\n");
return 0;
}
- while(size)
+ while(size>0)
{
- opt=(struct lcp_opt_hdr_t *)data;
- switch(opt->type)
+ hdr=(struct lcp_opt_hdr_t *)data;
+
+ list_for_each_entry(lopt,&lcp->options,entry)
{
- case CI_MRU:
- opt16=(struct lcp_opt16_t*)data;
- log_debug(" <mru %i>",l->options.lcp.neg_mru);
- break;
- case CI_ASYNCMAP:
- log_debug(" <asyncmap ...>");
- break;
- case CI_AUTHTYPE:
- if (auth_recv_conf_nak(l,opt))
- res=-1;
- break;
- case CI_MAGIC:
- if (*(uint32_t*)data==l->options.lcp.magic)
- {
- log_error("loop detected\n");
- res=-1;
- }
- break;
- case CI_PCOMP:
- log_debug(" <pcomp>");
- if (l->options.lcp.pcomp>=1) l->options.lcp.neg_pcomp=-1;
- else {
- l->options.lcp.neg_pcomp=-2;
- res=-1;
- }
- break;
- case CI_ACCOMP:
- log_debug(" <accomp>");
- if (l->options.lcp.accomp>=1) l->options.lcp.neg_accomp=-1;
- else {
- l->options.lcp.neg_accomp=-2;
- res=-1;
- }
+ if (lopt->id==hdr->id)
+ {
+ log_debug(" ");
+ lopt->h->print(log_debug,lopt,data);
+ if (lopt->h->recv_conf_ack)
+ lopt->h->recv_conf_ack(lcp,lopt,data);
break;
+ }
}
- data+=opt->len;
- size-=opt->len;
+
+ data+=hdr->len;
+ size-=hdr->len;
}
- log_debug("\n");
+ log_debug("]\n");
return res;
}
-static void lcp_recv_echo_repl(struct ppp_layer_t*l,uint8_t *data,int size)
+
+static void lcp_recv_echo_repl(struct ppp_lcp_t *lcp,uint8_t *data,int size)
{
}
-void send_echo_reply(struct ppp_layer_t *layer)
+void send_echo_reply(struct ppp_lcp_t *lcp)
{
struct lcp_echo_reply_t
{
@@ -329,73 +431,107 @@ void send_echo_reply(struct ppp_layer_t *layer)
struct lcp_opt32_t magic;
} __attribute__((packed)) msg =
{
- .hdr.proto=PPP_LCP,
+ .hdr.proto=htons(PPP_LCP),
.hdr.code=ECHOREP,
- .hdr.id=layer->recv_id,
- .hdr.len=8,
- .magic.val=layer->options.lcp.magic,
+ .hdr.id=lcp->fsm.recv_id,
+ .hdr.len=htons(8),
+ .magic.val=0,
};
- ppp_send(layer->ppp,&msg,msg.hdr.len+2);
+ ppp_send(lcp->ppp,&msg,ntohs(msg.hdr.len)+2);
}
static void lcp_recv(struct ppp_handler_t*h)
{
struct lcp_hdr_t *hdr;
- struct ppp_layer_t *l=container_of(h,typeof(*l),h);
+ struct ppp_lcp_t *lcp=container_of(h,typeof(*lcp),hnd);
+ int r;
+ char *term_msg;
- if (l->ppp->in_buf_size<PPP_HEADERLEN+2)
+ if (lcp->ppp->in_buf_size<PPP_HEADERLEN+2)
{
log_warn("LCP: short packet received\n");
return;
}
- hdr=(struct lcp_hdr_t *)l->ppp->in_buf;
+ hdr=(struct lcp_hdr_t *)lcp->ppp->in_buf;
if (ntohs(hdr->len)<PPP_HEADERLEN)
{
log_warn("LCP: short packet received\n");
return;
}
- l->recv_id=hdr->id;
+ lcp->fsm.recv_id=hdr->id;
switch(hdr->code)
{
case CONFREQ:
- if (lcp_recv_conf_req(l,(uint8_t*)(hdr+1),ntohs(hdr->len)-PPP_HDRLEN))
- ppp_fsm_recv_conf_req_bad(l);
- else
- ppp_fsm_recv_conf_req_good(l);
+ r=lcp_recv_conf_req(lcp,(uint8_t*)(hdr+1),ntohs(hdr->len)-PPP_HDRLEN);
+ switch(r)
+ {
+ case LCP_OPT_ACK:
+ ppp_fsm_recv_conf_req_ack(&lcp->fsm);
+ break;
+ case LCP_OPT_NAK:
+ ppp_fsm_recv_conf_req_nak(&lcp->fsm);
+ break;
+ case LCP_OPT_REJ:
+ ppp_fsm_recv_conf_req_rej(&lcp->fsm);
+ break;
+ }
+ lcp_free_conf_req(lcp);
+ if (r==LCP_OPT_FAIL)
+ ppp_terminate(lcp->ppp);
break;
case CONFACK:
- //lcp_recv_conf_ack(l,hdr+1,ntohs(hdr->len)-PPP_HDRLEN);
- ppp_fsm_recv_conf_ack(l);
+ lcp_recv_conf_ack(lcp,(uint8_t*)(hdr+1),ntohs(hdr->len)-PPP_HDRLEN);
+ ppp_fsm_recv_conf_ack(&lcp->fsm);
break;
case CONFNAK:
- lcp_recv_conf_nak(l,(uint8_t*)(hdr+1),ntohs(hdr->len)-PPP_HDRLEN);
- ppp_fsm_recv_conf_rej(l);
+ lcp_recv_conf_nak(lcp,(uint8_t*)(hdr+1),ntohs(hdr->len)-PPP_HDRLEN);
+ ppp_fsm_recv_conf_rej(&lcp->fsm);
break;
case CONFREJ:
- lcp_recv_conf_rej(l,(uint8_t*)(hdr+1),ntohs(hdr->len)-PPP_HDRLEN);
- ppp_fsm_recv_conf_rej(l);
+ lcp_recv_conf_rej(lcp,(uint8_t*)(hdr+1),ntohs(hdr->len)-PPP_HDRLEN);
+ ppp_fsm_recv_conf_rej(&lcp->fsm);
break;
case TERMREQ:
- ppp_fsm_recv_term_req(l);
+ term_msg=strndup((uint8_t*)(hdr+1),ntohs(hdr->len));
+ log_debug("recv [LCP TermReq id=%x \"%s\"]\n",hdr->id,term_msg);
+ free(term_msg);
+ ppp_fsm_recv_term_req(&lcp->fsm);
break;
case TERMACK:
- ppp_fsm_recv_term_ack(l);
+ term_msg=strndup((uint8_t*)(hdr+1),ntohs(hdr->len));
+ log_debug("recv [LCP TermAck id=%x \"%s\"]\n",hdr->id,term_msg);
+ free(term_msg);
+ ppp_fsm_recv_term_ack(&lcp->fsm);
break;
case CODEREJ:
- ppp_fsm_recv_code_rej_bad(l);
+ log_debug("recv [LCP CodeRej id=%x]\n",hdr->id);
+ ppp_fsm_recv_code_rej_bad(&lcp->fsm);
break;
case ECHOREQ:
- send_echo_reply(l);
+ send_echo_reply(lcp);
break;
case ECHOREP:
- lcp_recv_echo_repl(l,(uint8_t*)(hdr+1),ntohs(hdr->len)-PPP_HDRLEN);
+ lcp_recv_echo_repl(lcp,(uint8_t*)(hdr+1),ntohs(hdr->len)-PPP_HDRLEN);
break;
default:
- ppp_fsm_recv_unk(l);
+ ppp_fsm_recv_unk(&lcp->fsm);
break;
}
}
+int lcp_option_register(struct lcp_option_handler_t *h)
+{
+ /*struct lcp_option_drv_t *p;
+
+ list_for_each_entry(p,option_drv_list,entry)
+ if (p->id==h->id)
+ return -1;*/
+
+ list_add_tail(&h->entry,&option_handlers);
+
+ return 0;
+}
+
diff --git a/accel-pptpd/ppp_lcp.h b/accel-pptpd/ppp_lcp.h
index 5c77a3f..54235c4 100644
--- a/accel-pptpd/ppp_lcp.h
+++ b/accel-pptpd/ppp_lcp.h
@@ -3,13 +3,15 @@
#include <stdint.h>
+#include "triton/triton.h"
+#include "ppp_fsm.h"
/*
* Options.
*/
#define CI_VENDOR 0 /* Vendor Specific */
#define CI_MRU 1 /* Maximum Receive Unit */
#define CI_ASYNCMAP 2 /* Async Control Character Map */
-#define CI_AUTHTYPE 3 /* Authentication Type */
+#define CI_AUTH 3 /* Authentication Type */
#define CI_QUALITY 4 /* Quality Protocol */
#define CI_MAGIC 5 /* Magic Number */
#define CI_PCOMP 7 /* Protocol Field Compression */
@@ -39,7 +41,7 @@ struct lcp_hdr_t
} __attribute__((packed));
struct lcp_opt_hdr_t
{
- uint8_t type;
+ uint8_t id;
uint8_t len;
} __attribute__((packed));
struct lcp_opt8_t
@@ -58,7 +60,68 @@ struct lcp_opt32_t
uint32_t val;
} __attribute__((packed));
+/*struct lcp_options_t
+{
+ int magic;
+ int mtu;
+ int mru;
+ int accomp; // 0 - disabled, 1 - enable, 2 - allow, disabled, 3 - allow,enabled
+ int pcomp; // 0 - disabled, 1 - enable, 2 - allow, disabled, 3 - allow,enabled
+ // negotiated options;
+ int neg_mru;
+ int neg_mtu;
+ int neg_accomp; // -1 - rejected
+ int neg_pcomp;
+ int neg_auth[AUTH_MAX];
+};*/
+
+#define LCP_OPT_NONE 0
+#define LCP_OPT_ACK 1
+#define LCP_OPT_NAK -1
+#define LCP_OPT_REJ -2
+#define LCP_OPT_FAIL -3
+
+struct ppp_lcp_t;
+struct lcp_option_handler_t;
+
+struct lcp_option_t
+{
+ struct list_head entry;
+ int id;
+ int len;
+ int state;
+ struct lcp_option_handler_t *h;
+};
+
+struct lcp_option_handler_t
+{
+ struct list_head entry;
+ struct lcp_option_t* (*init)(struct ppp_lcp_t*);
+ int (*send_conf_req)(struct ppp_lcp_t*,struct lcp_option_t*,uint8_t*);
+ int (*send_conf_rej)(struct ppp_lcp_t*,struct lcp_option_t*,uint8_t*);
+ int (*send_conf_nak)(struct ppp_lcp_t*,struct lcp_option_t*,uint8_t*);
+ int (*recv_conf_req)(struct ppp_lcp_t*,struct lcp_option_t*,uint8_t*);
+ int (*recv_conf_rej)(struct ppp_lcp_t*,struct lcp_option_t*,uint8_t*);
+ int (*recv_conf_nak)(struct ppp_lcp_t*,struct lcp_option_t*,uint8_t*);
+ int (*recv_conf_ack)(struct ppp_lcp_t*,struct lcp_option_t*,uint8_t*);
+ void (*free)(struct ppp_lcp_t*,struct lcp_option_t*);
+ void (*print)(void (*print)(const char *fmt,...), struct lcp_option_t*,uint8_t*);
+};
+
+struct ppp_lcp_t
+{
+ struct ppp_handler_t hnd;
+ struct ppp_fsm_t fsm;
+ struct ppp_t *ppp;
+ struct list_head options;
+
+ struct list_head ropt_list; // last received ConfReq
+ int ropt_len;
+
+ int conf_req_len;
+};
+int lcp_option_register(struct lcp_option_handler_t *h);
#endif
diff --git a/accel-pptpd/pwdb.c b/accel-pptpd/pwdb.c
new file mode 100644
index 0000000..12130b3
--- /dev/null
+++ b/accel-pptpd/pwdb.c
@@ -0,0 +1,7 @@
+#include "pwdb.h"
+#include "ppp.h"
+
+int pwdb_check(struct ppp_t *ppp,const char *username,const char *password)
+{
+ return 0;
+}
diff --git a/accel-pptpd/pwdb.h b/accel-pptpd/pwdb.h
new file mode 100644
index 0000000..820e269
--- /dev/null
+++ b/accel-pptpd/pwdb.h
@@ -0,0 +1,9 @@
+#ifndef PWDB_H
+#define PWDB_H
+
+struct ppp_t;
+
+int pwdb_check(struct ppp_t*,const char *username,const char *password);
+
+#endif
+
diff --git a/accel-pptpd/triton/timer.c b/accel-pptpd/triton/timer.c
index 2ea36cb..2fa4be8 100644
--- a/accel-pptpd/triton/timer.c
+++ b/accel-pptpd/triton/timer.c
@@ -27,6 +27,11 @@ void triton_timer_add(struct triton_timer_t*tt)
{
struct timer_t *t=(struct timer_t *)malloc(sizeof(struct timer_t));
+ if (!tt->expire_tv.tv_sec)
+ {
+ gettimeofday(&tt->expire_tv,NULL);
+ tv_add(&tt->expire_tv,tt->period);
+ }
t->del=0;
t->timer=tt;
tt->active=1;