/*- * Copyright (c) 2001 Brian Somers * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $OpenBSD: ncp.c,v 1.4 2005/07/17 19:13:25 brad Exp $ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "layer.h" #include "defs.h" #include "command.h" #include "mbuf.h" #include "log.h" #include "timer.h" #include "fsm.h" #include "iplist.h" #include "throughput.h" #include "slcompress.h" #include "lqr.h" #include "hdlc.h" #include "lcp.h" #include "ncpaddr.h" #include "ipcp.h" #include "filter.h" #include "descriptor.h" #include "async.h" #include "ccp.h" #include "link.h" #include "physical.h" #include "mp.h" #ifndef NORADIUS #include "radius.h" #endif #include "ipv6cp.h" #include "ncp.h" #include "bundle.h" #include "prompt.h" #include "route.h" #include "iface.h" #include "chat.h" #include "auth.h" #include "chap.h" #include "cbcp.h" #include "datalink.h" static u_short default_urgent_tcp_ports[] = { 21, /* ftp */ 22, /* ssh */ 23, /* telnet */ 513, /* login */ 514, /* shell */ 543, /* klogin */ 544 /* kshell */ }; static u_short default_urgent_udp_ports[] = { }; #define NDEFTCPPORTS \ (sizeof default_urgent_tcp_ports / sizeof default_urgent_tcp_ports[0]) #define NDEFUDPPORTS \ (sizeof default_urgent_udp_ports / sizeof default_urgent_udp_ports[0]) void ncp_Init(struct ncp *ncp, struct bundle *bundle) { ncp->afq = AF_INET; ncp->route = NULL; ncp->cfg.urgent.tcp.port = (u_short *)malloc(NDEFTCPPORTS * sizeof(u_short)); if (ncp->cfg.urgent.tcp.port == NULL) { log_Printf(LogERROR, "ncp_Init: Out of memory allocating urgent ports\n"); ncp->cfg.urgent.tcp.nports = ncp->cfg.urgent.tcp.maxports = 0; } else { ncp->cfg.urgent.tcp.nports = ncp->cfg.urgent.tcp.maxports = NDEFTCPPORTS; memcpy(ncp->cfg.urgent.tcp.port, default_urgent_tcp_ports, NDEFTCPPORTS * sizeof(u_short)); } ncp->cfg.urgent.tos = 1; ncp->cfg.urgent.udp.nports = ncp->cfg.urgent.udp.maxports = NDEFUDPPORTS; ncp->cfg.urgent.udp.port = (u_short *)malloc(NDEFUDPPORTS * sizeof(u_short)); memcpy(ncp->cfg.urgent.udp.port, default_urgent_udp_ports, NDEFUDPPORTS * sizeof(u_short)); mp_Init(&ncp->mp, bundle); /* Send over the first physical link by default */ ipcp_Init(&ncp->ipcp, bundle, &bundle->links->physical->link, &bundle->fsm); #ifndef NOINET6 ipv6cp_Init(&ncp->ipv6cp, bundle, &bundle->links->physical->link, &bundle->fsm); #endif } void ncp_Destroy(struct ncp *ncp) { ipcp_Destroy(&ncp->ipcp); #ifndef NOINET6 ipv6cp_Destroy(&ncp->ipv6cp); #endif if (ncp->cfg.urgent.tcp.maxports) { ncp->cfg.urgent.tcp.nports = ncp->cfg.urgent.tcp.maxports = 0; free(ncp->cfg.urgent.tcp.port); ncp->cfg.urgent.tcp.port = NULL; } if (ncp->cfg.urgent.udp.maxports) { ncp->cfg.urgent.udp.nports = ncp->cfg.urgent.udp.maxports = 0; free(ncp->cfg.urgent.udp.port); ncp->cfg.urgent.udp.port = NULL; } } int ncp_fsmStart(struct ncp *ncp, struct bundle *bundle) { int res = 0; #ifndef NOINET6 if (Enabled(bundle, OPT_IPCP)) { #endif fsm_Up(&ncp->ipcp.fsm); fsm_Open(&ncp->ipcp.fsm); res++; #ifndef NOINET6 } if (Enabled(bundle, OPT_IPV6CP)) { fsm_Up(&ncp->ipv6cp.fsm); fsm_Open(&ncp->ipv6cp.fsm); res++; } #endif return res; } void ncp_IfaceAddrAdded(struct ncp *ncp, const struct iface_addr *addr) { switch (ncprange_family(&addr->ifa)) { case AF_INET: ipcp_IfaceAddrAdded(&ncp->ipcp, addr); break; #ifndef NOINET6 case AF_INET6: ipv6cp_IfaceAddrAdded(&ncp->ipv6cp, addr); break; #endif } } void ncp_IfaceAddrDeleted(struct ncp *ncp, const struct iface_addr *addr) { if (ncprange_family(&addr->ifa) == AF_INET) ipcp_IfaceAddrDeleted(&ncp->ipcp, addr); } void ncp_SetLink(struct ncp *ncp, struct link *l) { ipcp_SetLink(&ncp->ipcp, l); #ifndef NOINET6 ipv6cp_SetLink(&ncp->ipv6cp, l); #endif } /* * Enqueue a packet of the given address family. Nothing will make it * down to the physical link level 'till ncp_FillPhysicalQueues() is used. */ void ncp_Enqueue(struct ncp *ncp, int af, int pri, char *ptr, int count) { #ifndef NOINET6 struct ipv6cp *ipv6cp = &ncp->ipv6cp; #endif struct ipcp *ipcp = &ncp->ipcp; struct mbuf *bp; /* * We allocate an extra 6 bytes, four at the front and two at the end. * This is an optimisation so that we need to do less work in * m_prepend() in acf_LayerPush() and proto_LayerPush() and * appending in hdlc_LayerPush(). */ switch (af) { case AF_INET: if (pri < 0 || pri >= IPCP_QUEUES(ipcp)) { log_Printf(LogERROR, "Can't store in ip queue %d\n", pri); break; } bp = m_get(count + 6, MB_IPOUT); bp->m_offset += 4; bp->m_len -= 6; memcpy(MBUF_CTOP(bp), ptr, count); m_enqueue(ipcp->Queue + pri, bp); break; #ifndef NOINET6 case AF_INET6: if (pri < 0 || pri >= IPV6CP_QUEUES(ipcp)) { log_Printf(LogERROR, "Can't store in ipv6 queue %d\n", pri); break; } bp = m_get(count + 6, MB_IPOUT); bp->m_offset += 4; bp->m_len -= 6; memcpy(MBUF_CTOP(bp), ptr, count); m_enqueue(ipv6cp->Queue + pri, bp); break; #endif default: log_Printf(LogERROR, "Can't enqueue protocol family %d\n", af); } } /* * How many packets are queued to go out ? */ size_t ncp_QueueLen(struct ncp *ncp) { size_t result; result = ipcp_QueueLen(&ncp->ipcp); #ifndef NOINET6 result += ipv6cp_QueueLen(&ncp->ipv6cp); #endif result += mp_QueueLen(&ncp->mp); /* Usually empty */ return result; } /* * Ditch all queued packets. This is usually done after our choked timer * has fired - which happens because we couldn't send any traffic over * any links for some time. */ void ncp_DeleteQueues(struct ncp *ncp) { #ifndef NOINET6 struct ipv6cp *ipv6cp = &ncp->ipv6cp; #endif struct ipcp *ipcp = &ncp->ipcp; struct mp *mp = &ncp->mp; struct mqueue *q; for (q = ipcp->Queue; q < ipcp->Queue + IPCP_QUEUES(ipcp); q++) while (q->top) m_freem(m_dequeue(q)); #ifndef NOINET6 for (q = ipv6cp->Queue; q < ipv6cp->Queue + IPV6CP_QUEUES(ipv6cp); q++) while (q->top) m_freem(m_dequeue(q)); #endif link_DeleteQueue(&mp->link); /* Usually empty anyway */ } /* * Arrange that each of our links has at least one packet. We keep the * number of packets queued at the link level to a minimum so that the * loss of a link in multi-link mode results in the minimum number of * dropped packets. */ size_t ncp_FillPhysicalQueues(struct ncp *ncp, struct bundle *bundle) { size_t total; if (bundle->ncp.mp.active) total = mp_FillPhysicalQueues(bundle); else { struct datalink *dl; size_t add; for (total = 0, dl = bundle->links; dl; dl = dl->next) if (dl->state == DATALINK_OPEN) { add = link_QueueLen(&dl->physical->link); if (add == 0 && dl->physical->out == NULL) add = ncp_PushPacket(ncp, &ncp->afq, &dl->physical->link); total += add; } } return total + ncp_QueueLen(&bundle->ncp); } /* * Push a packet into the given link. ``af'' is used as a persistent record * of what is to be pushed next, coming either from mp->out or ncp->afq. */ int ncp_PushPacket(struct ncp *ncp, int *af, struct link *l) { struct bundle *bundle = l->lcp.fsm.bundle; int res; #ifndef NOINET6 if (*af == AF_INET) { if ((res = ipcp_PushPacket(&bundle->ncp.ipcp, l))) *af = AF_INET6; else res = ipv6cp_PushPacket(&bundle->ncp.ipv6cp, l); } else { if ((res = ipv6cp_PushPacket(&bundle->ncp.ipv6cp, l))) *af = AF_INET; else res = ipcp_PushPacket(&bundle->ncp.ipcp, l); } #else res = ipcp_PushPacket(&bundle->ncp.ipcp, l); #endif return res; } int ncp_IsUrgentPort(struct port_range *range, u_short src, u_short dst) { int f; for (f = 0; f < range->nports; f++) if (range->port[f] == src || range->port[f] == dst) return 1; return 0; } void ncp_AddUrgentPort(struct port_range *range, u_short port) { u_short *newport; int p; if (range->nports == range->maxports) { range->maxports += 10; newport = (u_short *)realloc(range->port, range->maxports * sizeof(u_short)); if (newport == NULL) { log_Printf(LogERROR, "ncp_AddUrgentPort: realloc: %s\n", strerror(errno)); range->maxports -= 10; return; } range->port = newport; } for (p = 0; p < range->nports; p++) if (range->port[p] == port) { log_Printf(LogWARN, "%u: Port already set to urgent\n", port); break; } else if (range->port[p] > port) { memmove(range->port + p + 1, range->port + p, (range->nports - p) * sizeof(u_short)); range->port[p] = port; range->nports++; break; } if (p == range->nports) range->port[range->nports++] = port; } void ncp_RemoveUrgentPort(struct port_range *range, u_short port) { int p; for (p = 0; p < range->nports; p++) if (range->port[p] == port) { if (p != range->nports - 1) memmove(range->port + p, range->port + p + 1, (range->nports - p - 1) * sizeof(u_short)); range->nports--; return; } if (p == range->nports) log_Printf(LogWARN, "%u: Port not set to urgent\n", port); } void ncp_ClearUrgentPorts(struct port_range *range) { range->nports = 0; } int ncp_Show(struct cmdargs const *arg) { struct ncp *ncp = &arg->bundle->ncp; int p; #ifndef NOINET6 prompt_Printf(arg->prompt, "Next queued AF: %s\n", ncp->afq == AF_INET6 ? "inet6" : "inet"); #endif if (ncp->route) { prompt_Printf(arg->prompt, "\n"); route_ShowSticky(arg->prompt, ncp->route, "Sticky routes", 1); } prompt_Printf(arg->prompt, "\nDefaults:\n"); prompt_Printf(arg->prompt, " sendpipe: "); if (ncp->cfg.sendpipe > 0) prompt_Printf(arg->prompt, "%-20ld\n", ncp->cfg.sendpipe); else prompt_Printf(arg->prompt, "unspecified\n"); prompt_Printf(arg->prompt, " recvpipe: "); if (ncp->cfg.recvpipe > 0) prompt_Printf(arg->prompt, "%ld\n", ncp->cfg.recvpipe); else prompt_Printf(arg->prompt, "unspecified\n"); prompt_Printf(arg->prompt, "\n Urgent ports\n"); prompt_Printf(arg->prompt, " TCP: "); if (ncp->cfg.urgent.tcp.nports == 0) prompt_Printf(arg->prompt, "none"); else for (p = 0; p < ncp->cfg.urgent.tcp.nports; p++) { if (p) prompt_Printf(arg->prompt, ", "); prompt_Printf(arg->prompt, "%u", ncp->cfg.urgent.tcp.port[p]); } prompt_Printf(arg->prompt, "\n UDP: "); if (ncp->cfg.urgent.udp.nports == 0) prompt_Printf(arg->prompt, "none"); else for (p = 0; p < ncp->cfg.urgent.udp.nports; p++) { if (p) prompt_Printf(arg->prompt, ", "); prompt_Printf(arg->prompt, "%u", ncp->cfg.urgent.udp.port[p]); } prompt_Printf(arg->prompt, "\n TOS: %s\n\n", ncp->cfg.urgent.tos ? "yes" : "no"); return 0; } int ncp_LayersOpen(struct ncp *ncp) { int n; n = !!(ncp->ipcp.fsm.state == ST_OPENED); #ifndef NOINET6 n += !!(ncp->ipv6cp.fsm.state == ST_OPENED); #endif return n; } int ncp_LayersUnfinished(struct ncp *ncp) { int n = 0; if (ncp->ipcp.fsm.state > ST_CLOSED || ncp->ipcp.fsm.state == ST_STARTING) n++; #ifndef NOINET6 if (ncp->ipv6cp.fsm.state > ST_CLOSED || ncp->ipv6cp.fsm.state == ST_STARTING) n++; #endif return n; } void ncp_Close(struct ncp *ncp) { if (ncp->ipcp.fsm.state > ST_CLOSED || ncp->ipcp.fsm.state == ST_STARTING) fsm_Close(&ncp->ipcp.fsm); #ifndef NOINET6 if (ncp->ipv6cp.fsm.state > ST_CLOSED || ncp->ipv6cp.fsm.state == ST_STARTING) fsm_Close(&ncp->ipv6cp.fsm); #endif } void ncp2initial(struct ncp *ncp) { fsm2initial(&ncp->ipcp.fsm); #ifndef NOINET6 fsm2initial(&ncp->ipv6cp.fsm); #endif }