diff options
Diffstat (limited to 'accel-pppd/ppp/ppp_ccp.c')
| -rw-r--r-- | accel-pppd/ppp/ppp_ccp.c | 759 |
1 files changed, 759 insertions, 0 deletions
diff --git a/accel-pppd/ppp/ppp_ccp.c b/accel-pppd/ppp/ppp_ccp.c new file mode 100644 index 00000000..721dd9b6 --- /dev/null +++ b/accel-pppd/ppp/ppp_ccp.c @@ -0,0 +1,759 @@ +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <sys/socket.h> +#include <sys/ioctl.h> +#include "linux_ppp.h" + +#include "triton.h" + +#include "log.h" +#include "events.h" + +#include "ppp.h" +#include "ppp_ccp.h" + +#include "memdebug.h" + +struct recv_opt_t +{ + struct list_head entry; + struct ccp_opt_hdr_t *hdr; + int len; + int state; + struct ccp_option_t *lopt; +}; + +static int conf_ccp = 1; + +static struct ppp_layer_t ccp_layer; +static LIST_HEAD(option_handlers); + +static void ccp_layer_up(struct ppp_fsm_t*); +static void ccp_layer_down(struct ppp_fsm_t*); +static int 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 send_term_req(struct ppp_fsm_t *fsm); +static void send_term_ack(struct ppp_fsm_t *fsm); +static void ccp_recv(struct ppp_handler_t*); +static void ccp_recv_proto_rej(struct ppp_handler_t*); + +static void ccp_options_init(struct ppp_ccp_t *ccp) +{ + struct ccp_option_t *lopt; + struct ccp_option_handler_t *h; + + ccp->conf_req_len = sizeof(struct ccp_hdr_t); + + list_for_each_entry(h, &option_handlers, entry) { + lopt = h->init(ccp); + if (lopt) { + lopt->h = h; + list_add_tail(&lopt->entry, &ccp->options); + ccp->conf_req_len += lopt->len; + } + } +} + +static void ccp_options_free(struct ppp_ccp_t *ccp) +{ + struct ccp_option_t *lopt; + + while (!list_empty(&ccp->options)) { + lopt = list_entry(ccp->options.next, typeof(*lopt), entry); + list_del(&lopt->entry); + lopt->h->free(ccp, lopt); + } +} + +static int ccp_set_flags(int fd, int isopen, int isup) +{ + int flags; + + if (ioctl(fd, PPPIOCGFLAGS, &flags)) { + log_ppp_error("ccp: failed to get flags: %s\n", strerror(errno)); + return -1; + } + + flags &= ~(SC_CCP_OPEN | SC_CCP_UP); + flags |= (isopen ? SC_CCP_OPEN : 0) | (isup ? SC_CCP_UP : 0); + + if (ioctl(fd, PPPIOCSFLAGS, &flags)) { + log_ppp_error("ccp: failed to set flags: %s\n", strerror(errno)); + return -1; + } + + return 0; +} + +static struct ppp_layer_data_t *ccp_layer_init(struct ppp_t *ppp) +{ + struct ppp_ccp_t *ccp = _malloc(sizeof(*ccp)); + memset(ccp, 0, sizeof(*ccp)); + + log_ppp_debug("ccp_layer_init\n"); + + ccp->ppp = ppp; + ccp->fsm.ppp = ppp; + + ccp->hnd.proto = PPP_CCP; + ccp->hnd.recv = ccp_recv; + ccp->hnd.recv_proto_rej = ccp_recv_proto_rej; + + ppp_register_unit_handler(ppp, &ccp->hnd); + + INIT_LIST_HEAD(&ccp->options); + ccp_options_init(ccp); + + ccp->passive = 0; + + ccp->fsm.proto = PPP_CCP; + ppp_fsm_init(&ccp->fsm); + + ccp->fsm.layer_up = ccp_layer_up; + ccp->fsm.layer_finished = ccp_layer_down; + ccp->fsm.send_conf_req = send_conf_req; + ccp->fsm.send_conf_ack = send_conf_ack; + ccp->fsm.send_conf_nak = send_conf_nak; + ccp->fsm.send_conf_rej = send_conf_rej; + ccp->fsm.send_term_req = send_term_req; + ccp->fsm.send_term_ack = send_term_ack; + + INIT_LIST_HEAD(&ccp->ropt_list); + + return &ccp->ld; +} + +int ccp_layer_start(struct ppp_layer_data_t *ld) +{ + struct ppp_ccp_t *ccp = container_of(ld, typeof(*ccp), ld); + + log_ppp_debug("ccp_layer_start\n"); + + if (list_empty(&ccp->options) || !conf_ccp) { + ppp_layer_started(ccp->ppp, &ccp->ld); + return 0; + } + + ppp_fsm_lower_up(&ccp->fsm); + if (ppp_fsm_open(&ccp->fsm)) + return -1; + + if (ccp_set_flags(ccp->ppp->unit_fd, 1, 0)) { + ppp_fsm_close(&ccp->fsm); + return -1; + } + + return 0; +} + +void ccp_layer_finish(struct ppp_layer_data_t *ld) +{ + struct ppp_ccp_t *ccp = container_of(ld, typeof(*ccp), ld); + + log_ppp_debug("ccp_layer_finish\n"); + + ccp_set_flags(ccp->ppp->unit_fd, 0, 0); + + ccp->fsm.fsm_state = FSM_Closed; + + log_ppp_debug("ccp_layer_finished\n"); + ppp_layer_finished(ccp->ppp, &ccp->ld); +} + +void ccp_layer_free(struct ppp_layer_data_t *ld) +{ + struct ppp_ccp_t *ccp = container_of(ld, typeof(*ccp), ld); + + log_ppp_debug("ccp_layer_free\n"); + + ppp_unregister_handler(ccp->ppp, &ccp->hnd); + ccp_options_free(ccp); + ppp_fsm_free(&ccp->fsm); + + _free(ccp); +} + +static void ccp_layer_up(struct ppp_fsm_t *fsm) +{ + struct ppp_ccp_t *ccp = container_of(fsm, typeof(*ccp), fsm); + + log_ppp_debug("ccp_layer_started\n"); + + if (!ccp->started) { + ccp->started = 1; + if (ccp_set_flags(ccp->ppp->unit_fd, 1, 1)) { + ppp_terminate(ccp->ppp, TERM_NAS_ERROR, 0); + return; + } + ppp_layer_started(ccp->ppp, &ccp->ld); + } +} + +static void ccp_layer_down(struct ppp_fsm_t *fsm) +{ + struct ppp_ccp_t *ccp = container_of(fsm, typeof(*ccp), fsm); + + log_ppp_debug("ccp_layer_finished\n"); + + if (!ccp->started) + ppp_layer_started(ccp->ppp, &ccp->ld); + ccp->started = 0; + ppp_layer_finished(ccp->ppp, &ccp->ld); +} + +static void print_ropt(struct recv_opt_t *ropt) +{ + int i; + uint8_t *ptr = (uint8_t*)ropt->hdr; + + log_ppp_info2("<"); + for (i = 0; i < ropt->len; i++) { + log_ppp_info2(" %x", ptr[i]); + } + log_ppp_info2(" >"); +} + +static int send_conf_req(struct ppp_fsm_t *fsm) +{ + struct ppp_ccp_t *ccp = container_of(fsm, typeof(*ccp), fsm); + uint8_t *buf, *ptr; + struct ccp_hdr_t *ccp_hdr; + struct ccp_option_t *lopt; + int n; + + ccp->need_req = 0; + + if (ccp->passive) { + ccp->passive--; + return 0; + } + + buf = _malloc(ccp->conf_req_len); + ccp_hdr = (struct ccp_hdr_t*)buf; + + ccp_hdr->proto = htons(PPP_CCP); + ccp_hdr->code = CONFREQ; + ccp_hdr->id = ++ccp->fsm.id; + ccp_hdr->len = 0; + + ptr = (uint8_t*)(ccp_hdr + 1); + + if (conf_ppp_verbose) + log_ppp_info2("send [CCP ConfReq id=%x", ccp_hdr->id); + + list_for_each_entry(lopt, &ccp->options, entry) { + n = lopt->h->send_conf_req(ccp, lopt, ptr); + if (n < 0) + return -1; + if (n) { + if (conf_ppp_verbose) { + log_ppp_info2(" "); + lopt->h->print(log_ppp_info2, lopt, NULL); + } + } + ptr += n; + } + + if (conf_ppp_verbose) + log_ppp_info2("]\n"); + + ccp_hdr->len = htons(ptr - buf - 2); + ppp_unit_send(ccp->ppp, ccp_hdr, ptr - buf); + + _free(buf); + + return 0; +} + +static void send_conf_ack(struct ppp_fsm_t *fsm) +{ + struct ppp_ccp_t *ccp = container_of(fsm, typeof(*ccp), fsm); + struct ccp_hdr_t *hdr = (struct ccp_hdr_t*)ccp->ppp->unit_buf; + + hdr->code = CONFACK; + + if (conf_ppp_verbose) + log_ppp_info2("send [CCP ConfAck id=%x]\n", ccp->fsm.recv_id); + + ppp_unit_send(ccp->ppp,hdr,ntohs(hdr->len)+2); +} + +static void send_conf_nak(struct ppp_fsm_t *fsm) +{ + struct ppp_ccp_t *ccp = container_of(fsm, typeof(*ccp), fsm); + uint8_t *buf = _malloc(ccp->conf_req_len), *ptr = buf; + struct ccp_hdr_t *ccp_hdr = (struct ccp_hdr_t*)ptr; + struct recv_opt_t *ropt; + + if (conf_ppp_verbose) + log_ppp_info2("send [CCP ConfNak id=%x", ccp->fsm.recv_id); + + ccp_hdr->proto = htons(PPP_CCP); + ccp_hdr->code = CONFNAK; + ccp_hdr->id = ccp->fsm.recv_id; + ccp_hdr->len = 0; + + ptr += sizeof(*ccp_hdr); + + list_for_each_entry(ropt, &ccp->ropt_list, entry) { + if (ropt->state == CCP_OPT_NAK) { + if (conf_ppp_verbose) { + log_ppp_info2(" "); + ropt->lopt->h->print(log_ppp_info2, ropt->lopt, NULL); + } + ptr += ropt->lopt->h->send_conf_nak(ccp, ropt->lopt, ptr); + } + } + + if (conf_ppp_verbose) + log_ppp_info2("]\n"); + + ccp_hdr->len = htons(ptr - buf - 2); + ppp_unit_send(ccp->ppp, ccp_hdr, ptr - buf); + + _free(buf); +} + +static void send_conf_rej(struct ppp_fsm_t *fsm) +{ + struct ppp_ccp_t *ccp = container_of(fsm, typeof(*ccp), fsm); + uint8_t *buf = _malloc(ccp->ropt_len + sizeof(struct ccp_hdr_t)), *ptr = buf; + struct ccp_hdr_t *ccp_hdr = (struct ccp_hdr_t*)ptr; + struct recv_opt_t *ropt; + + if (conf_ppp_verbose) + log_ppp_info2("send [CCP ConfRej id=%x", ccp->fsm.recv_id); + + ccp_hdr->proto = htons(PPP_CCP); + ccp_hdr->code = CONFREJ; + ccp_hdr->id = ccp->fsm.recv_id; + ccp_hdr->len = 0; + + ptr += sizeof(*ccp_hdr); + + list_for_each_entry(ropt, &ccp->ropt_list, entry) { + if (ropt->state == CCP_OPT_REJ) { + if (conf_ppp_verbose) { + log_ppp_info2(" "); + if (ropt->lopt) + ropt->lopt->h->print(log_ppp_info2, ropt->lopt, (uint8_t*)ropt->hdr); + else + print_ropt(ropt); + } + memcpy(ptr, ropt->hdr, ropt->len); + ptr += ropt->len; + } + } + + if (conf_ppp_verbose) + log_ppp_info2("]\n"); + + ccp_hdr->len = htons(ptr - buf - 2); + ppp_unit_send(ccp->ppp, ccp_hdr, ptr-buf); + + _free(buf); +} + +static int ccp_recv_conf_req(struct ppp_ccp_t *ccp, uint8_t *data, int size) +{ + struct ccp_opt_hdr_t *hdr; + struct recv_opt_t *ropt; + struct ccp_option_t *lopt; + int r, ret = 1, ack = 0; + + ccp->need_req = 0; + ccp->ropt_len = size; + + while (size > 0) { + hdr = (struct ccp_opt_hdr_t *)data; + + ropt = _malloc(sizeof(*ropt)); + memset(ropt, 0, sizeof(*ropt)); + + if (hdr->len > size) + ropt->len = size; + else + ropt->len = hdr->len; + + ropt->hdr = hdr; + ropt->state = CCP_OPT_NONE; + list_add_tail(&ropt->entry, &ccp->ropt_list); + + data += ropt->len; + size -= ropt->len; + } + + if (conf_ppp_verbose) + log_ppp_info2("recv [CCP ConfReq id=%x", ccp->fsm.recv_id); + + list_for_each_entry(ropt, &ccp->ropt_list, entry) { + list_for_each_entry(lopt, &ccp->options, entry) { + if (lopt->id == ropt->hdr->id) { + if (conf_ppp_verbose) { + log_ppp_info2(" "); + lopt->h->print(log_ppp_info2, lopt, (uint8_t*)ropt->hdr); + } + r = lopt->h->recv_conf_req(ccp, lopt, (uint8_t*)ropt->hdr); + if (ack) { + lopt->state = CCP_OPT_REJ; + ropt->state = CCP_OPT_REJ; + } else { + /*if (lopt->state == CCP_OPT_NAK && r == CCP_OPT_ACK) + ccp->need_req = 1;*/ + lopt->state = r; + ropt->state = r; + } + ropt->lopt = lopt; + if (r < ret) + ret = r; + break; + } + } + if (ropt->state == CCP_OPT_ACK || ropt->state == CCP_OPT_NAK) + ack = 1; + else if (!ropt->lopt) { + if (conf_ppp_verbose) { + log_ppp_info2(" "); + print_ropt(ropt); + } + ropt->state = CCP_OPT_REJ; + ret = CCP_OPT_REJ; + } + } + + if (conf_ppp_verbose) + log_ppp_info2("]\n"); + + /*list_for_each_entry(lopt,&ccp->options,entry) + { + if (lopt->state==CCP_OPT_NONE) + { + r=lopt->h->recv_conf_req(ccp,lopt,NULL); + lopt->state=r; + if (r<ret) ret=r; + } + }*/ + + return ret; +} + +static void ccp_free_conf_req(struct ppp_ccp_t *ccp) +{ + struct recv_opt_t *ropt; + + while (!list_empty(&ccp->ropt_list)) { + ropt = list_entry(ccp->ropt_list.next, typeof(*ropt), entry); + list_del(&ropt->entry); + _free(ropt); + } +} + +static int ccp_recv_conf_rej(struct ppp_ccp_t *ccp, uint8_t *data, int size) +{ + struct ccp_opt_hdr_t *hdr; + struct ccp_option_t *lopt; + int res = 0; + + if (conf_ppp_verbose) + log_ppp_info2("recv [CCP ConfRej id=%x", ccp->fsm.recv_id); + + if (ccp->fsm.recv_id != ccp->fsm.id) { + if (conf_ppp_verbose) + log_ppp_info2(": id mismatch ]\n"); + return 0; + } + + while (size > 0) { + hdr = (struct ccp_opt_hdr_t *)data; + + list_for_each_entry(lopt, &ccp->options, entry) { + if (lopt->id == hdr->id) { + if (!lopt->h->recv_conf_rej) + res = -1; + else if (lopt->h->recv_conf_rej(ccp, lopt, data)) + res = -1; + break; + } + } + + data += hdr->len; + size -= hdr->len; + } + + if (conf_ppp_verbose) + log_ppp_info2("]\n"); + + return res; +} + +static int ccp_recv_conf_nak(struct ppp_ccp_t *ccp, uint8_t *data, int size) +{ + struct ccp_opt_hdr_t *hdr; + struct ccp_option_t *lopt; + int res = 0; + + if (conf_ppp_verbose) + log_ppp_info2("recv [CCP ConfNak id=%x", ccp->fsm.recv_id); + + if (ccp->fsm.recv_id != ccp->fsm.id) { + if (conf_ppp_verbose) + log_ppp_info2(": id mismatch ]\n"); + return 0; + } + + while (size > 0) { + hdr = (struct ccp_opt_hdr_t *)data; + + list_for_each_entry(lopt, &ccp->options, entry) { + if (lopt->id == hdr->id) { + if (conf_ppp_verbose) { + log_ppp_info2(" "); + lopt->h->print(log_ppp_info2, lopt, data); + } + if (lopt->h->recv_conf_nak && lopt->h->recv_conf_nak(ccp, lopt, data)) + res = -1; + //lopt->state = CCP_OPT_NAK; + //ccp->need_req = 1; + break; + } + } + + data += hdr->len; + size -= hdr->len; + } + + if (conf_ppp_verbose) + log_ppp_info2("]\n"); + + return res; +} + +static int ccp_recv_conf_ack(struct ppp_ccp_t *ccp, uint8_t *data, int size) +{ + struct ccp_opt_hdr_t *hdr; + struct ccp_option_t *lopt; + int res = 0; + + if (conf_ppp_verbose) + log_ppp_info2("recv [CCP ConfAck id=%x", ccp->fsm.recv_id); + + if (ccp->fsm.recv_id != ccp->fsm.id) { + if (conf_ppp_verbose) + log_ppp_info2(": id mismatch ]\n"); + return 0; + } + + while (size > 0) { + hdr = (struct ccp_opt_hdr_t *)data; + + list_for_each_entry(lopt, &ccp->options, entry) { + if (lopt->id == hdr->id) { + if (conf_ppp_verbose) { + log_ppp_info2(" "); + lopt->h->print(log_ppp_info2,lopt,data); + } + if (!lopt->h->recv_conf_ack) + break; + if (lopt->h->recv_conf_ack(ccp, lopt, data)) + res = -1; + break; + } + } + + data += hdr->len; + size -= hdr->len; + } + + if (conf_ppp_verbose) + log_ppp_info2("]\n"); + + return res; +} + +static void send_term_req(struct ppp_fsm_t *fsm) +{ + struct ppp_ccp_t *ccp = container_of(fsm, typeof(*ccp), fsm); + struct ccp_hdr_t hdr = { + .proto = htons(PPP_CCP), + .code = TERMREQ, + .id = ++ccp->fsm.id, + .len = htons(4), + }; + + if (conf_ppp_verbose) + log_ppp_info2("send [CCP TermReq id=%i]\n", hdr.id); + + ppp_chan_send(ccp->ppp, &hdr, 6); +} + +static void send_term_ack(struct ppp_fsm_t *fsm) +{ + struct ppp_ccp_t *ccp = container_of(fsm, typeof(*ccp), fsm); + struct ccp_hdr_t hdr = { + .proto = htons(PPP_CCP), + .code = TERMACK, + .id = ccp->fsm.recv_id, + .len = htons(4), + }; + + if (conf_ppp_verbose) + log_ppp_info2("send [CCP TermAck id=%i]\n", hdr.id); + + ppp_chan_send(ccp->ppp, &hdr, 6); +} + +static void ccp_recv(struct ppp_handler_t*h) +{ + struct ccp_hdr_t *hdr; + struct ppp_ccp_t *ccp = container_of(h, typeof(*ccp), hnd); + int r; + + if (ccp->fsm.fsm_state == FSM_Initial || ccp->fsm.fsm_state == FSM_Closed || ccp->ppp->terminating) { + if (conf_ppp_verbose) + log_ppp_warn("CCP: discarding packet\n"); + if (ccp->fsm.fsm_state == FSM_Closed || !conf_ccp) + lcp_send_proto_rej(ccp->ppp, PPP_CCP); + return; + } + + if (ccp->ppp->unit_buf_size < PPP_HEADERLEN + 2) { + log_ppp_warn("CCP: short packet received\n"); + return; + } + + hdr = (struct ccp_hdr_t *)ccp->ppp->unit_buf; + if (ntohs(hdr->len) < PPP_HEADERLEN) { + log_ppp_warn("CCP: short packet received\n"); + return; + } + + ccp->fsm.recv_id = hdr->id; + switch(hdr->code) { + case CONFREQ: + r = ccp_recv_conf_req(ccp, (uint8_t*)(hdr + 1), ntohs(hdr->len) - PPP_HDRLEN); + switch(r) { + case CCP_OPT_ACK: + ppp_fsm_recv_conf_req_ack(&ccp->fsm); + break; + case CCP_OPT_NAK: + ppp_fsm_recv_conf_req_nak(&ccp->fsm); + break; + case CCP_OPT_REJ: + ppp_fsm_recv_conf_req_rej(&ccp->fsm); + break; + } + ccp_free_conf_req(ccp); + + if (r == CCP_OPT_ACK && ccp->passive) { + ccp->passive = 0; + send_conf_req(&ccp->fsm); + } + if (r == CCP_OPT_FAIL) + ppp_terminate(ccp->ppp, TERM_USER_ERROR, 0); + break; + case CONFACK: + if (ccp_recv_conf_ack(ccp, (uint8_t*)(hdr + 1), ntohs(hdr->len) - PPP_HDRLEN)) + ppp_terminate(ccp->ppp, TERM_USER_ERROR, 0); + else { + ppp_fsm_recv_conf_ack(&ccp->fsm); + if (ccp->need_req) + send_conf_req(&ccp->fsm); + } + break; + case CONFNAK: + ccp_recv_conf_nak(ccp, (uint8_t*)(hdr + 1), ntohs(hdr->len) - PPP_HDRLEN); + ppp_fsm_recv_conf_rej(&ccp->fsm); + break; + case CONFREJ: + if (ccp_recv_conf_rej(ccp, (uint8_t*)(hdr + 1),ntohs(hdr->len) - PPP_HDRLEN)) + ppp_terminate(ccp->ppp, TERM_USER_ERROR, 0); + else + ppp_fsm_recv_conf_rej(&ccp->fsm); + break; + case TERMREQ: + if (conf_ppp_verbose) + log_ppp_info2("recv [CCP TermReq id=%x]\n", hdr->id); + ppp_fsm_recv_term_req(&ccp->fsm); + ppp_fsm_close(&ccp->fsm); + break; + case TERMACK: + if (conf_ppp_verbose) + log_ppp_info2("recv [CCP TermAck id=%x]\n", hdr->id); + ppp_fsm_recv_term_ack(&ccp->fsm); + break; + case CODEREJ: + if (conf_ppp_verbose) + log_ppp_info2("recv [CCP CodeRej id=%x]\n", hdr->id); + ppp_fsm_recv_code_rej_bad(&ccp->fsm); + break; + default: + ppp_fsm_recv_unk(&ccp->fsm); + break; + } +} + +static void ccp_recv_proto_rej(struct ppp_handler_t *h) +{ + struct ppp_ccp_t *ccp = container_of(h, typeof(*ccp), hnd); + + if (ccp->fsm.fsm_state == FSM_Initial || ccp->fsm.fsm_state == FSM_Closed) + return; + + ppp_fsm_lower_down(&ccp->fsm); + ppp_fsm_close(&ccp->fsm); +} + +int ccp_option_register(struct ccp_option_handler_t *h) +{ + /*struct ccp_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; +} + +struct ccp_option_t *ccp_find_option(struct ppp_t *ppp, struct ccp_option_handler_t *h) +{ + struct ppp_ccp_t *ccp = container_of(ppp_find_layer_data(ppp, &ccp_layer), typeof(*ccp), ld); + struct ccp_option_t *opt; + + list_for_each_entry(opt, &ccp->options, entry) + if (opt->h == h) + return opt; + + log_emerg("ccp: BUG: option not found\n"); + abort(); +} + +static struct ppp_layer_t ccp_layer= +{ + .init = ccp_layer_init, + .start = ccp_layer_start, + .finish = ccp_layer_finish, + .free = ccp_layer_free, +}; + +static void load_config(void) +{ + const char *opt; + + opt = conf_get_opt("ppp", "ccp"); + if (opt && atoi(opt) >= 0) + conf_ccp = atoi(opt); +} + +static void __init ccp_init(void) +{ + ppp_register_layer("ccp", &ccp_layer); + + load_config(); + triton_event_register_handler(EV_CONFIG_RELOAD, (triton_event_func)load_config); +} + |