mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-25 11:37:56 +00:00
442f849547
(LCP/CCP/IPCP), one for urgent IP traffic and one for everything else. o Add the ``set urgent'' command for adjusting the list of urgent port numbers. The default urgent ports are 21, 22, 23, 513, 514, 543 and 544 (Ports 80 and 81 have been removed from the default priority list). o Increase the buffered packet threshold from 20 to 30. o Report the number of packets in the IP output queue and the list of urgent ports under ``show ipcp''.
363 lines
8.8 KiB
C
363 lines
8.8 KiB
C
/*-
|
|
* Copyright (c) 1998 Brian Somers <brian@Awfulhak.org>
|
|
* 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.
|
|
*
|
|
* $FreeBSD$
|
|
*
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
#include <netinet/in_systm.h>
|
|
#include <sys/un.h>
|
|
#include <netinet/in.h>
|
|
#include <netinet/ip.h>
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <termios.h>
|
|
|
|
#include "defs.h"
|
|
#include "layer.h"
|
|
#include "mbuf.h"
|
|
#include "log.h"
|
|
#include "timer.h"
|
|
#include "lqr.h"
|
|
#include "hdlc.h"
|
|
#include "throughput.h"
|
|
#include "proto.h"
|
|
#include "fsm.h"
|
|
#include "descriptor.h"
|
|
#include "lcp.h"
|
|
#include "ccp.h"
|
|
#include "link.h"
|
|
#include "prompt.h"
|
|
#include "async.h"
|
|
#include "physical.h"
|
|
#include "mp.h"
|
|
#include "iplist.h"
|
|
#include "slcompress.h"
|
|
#include "ipcp.h"
|
|
#include "ip.h"
|
|
#include "auth.h"
|
|
#include "pap.h"
|
|
#include "chap.h"
|
|
#include "cbcp.h"
|
|
#include "command.h"
|
|
|
|
static void Despatch(struct bundle *, struct link *, struct mbuf *, u_short);
|
|
|
|
void
|
|
link_AddInOctets(struct link *l, int n)
|
|
{
|
|
throughput_addin(&l->throughput, n);
|
|
}
|
|
|
|
void
|
|
link_AddOutOctets(struct link *l, int n)
|
|
{
|
|
throughput_addout(&l->throughput, n);
|
|
}
|
|
|
|
void
|
|
link_SequenceQueue(struct link *l)
|
|
{
|
|
struct mqueue *queue, *highest;
|
|
|
|
log_Printf(LogDEBUG, "link_SequenceQueue\n");
|
|
|
|
highest = LINK_HIGHQ(l);
|
|
for (queue = l->Queue; queue < highest; queue++)
|
|
while (queue->qlen)
|
|
mbuf_Enqueue(highest, mbuf_Dequeue(queue));
|
|
}
|
|
|
|
void
|
|
link_DeleteQueue(struct link *l)
|
|
{
|
|
struct mqueue *queue, *highest;
|
|
|
|
highest = LINK_HIGHQ(l);
|
|
for (queue = l->Queue; queue <= highest; queue++)
|
|
while (queue->top)
|
|
mbuf_Free(mbuf_Dequeue(queue));
|
|
}
|
|
|
|
int
|
|
link_QueueLen(struct link *l)
|
|
{
|
|
int i, len;
|
|
|
|
for (i = 0, len = 0; i < LINK_QUEUES(l); i++)
|
|
len += l->Queue[i].qlen;
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
link_QueueBytes(struct link *l)
|
|
{
|
|
int i, len, bytes;
|
|
struct mbuf *m;
|
|
|
|
bytes = 0;
|
|
for (i = 0, len = 0; i < LINK_QUEUES(l); i++) {
|
|
len = l->Queue[i].qlen;
|
|
m = l->Queue[i].top;
|
|
while (len--) {
|
|
bytes += mbuf_Length(m);
|
|
m = m->pnext;
|
|
}
|
|
}
|
|
|
|
return bytes;
|
|
}
|
|
|
|
struct mbuf *
|
|
link_Dequeue(struct link *l)
|
|
{
|
|
int pri;
|
|
struct mbuf *bp;
|
|
|
|
for (bp = NULL, pri = LINK_QUEUES(l) - 1; pri >= 0; pri--)
|
|
if (l->Queue[pri].qlen) {
|
|
bp = mbuf_Dequeue(l->Queue + pri);
|
|
log_Printf(LogDEBUG, "link_Dequeue: Dequeued from queue %d,"
|
|
" containing %d more packets\n", pri, l->Queue[pri].qlen);
|
|
break;
|
|
}
|
|
|
|
return bp;
|
|
}
|
|
|
|
static struct protostatheader {
|
|
u_short number;
|
|
const char *name;
|
|
} ProtocolStat[NPROTOSTAT] = {
|
|
{ PROTO_IP, "IP" },
|
|
{ PROTO_VJUNCOMP, "VJ_UNCOMP" },
|
|
{ PROTO_VJCOMP, "VJ_COMP" },
|
|
{ PROTO_COMPD, "COMPD" },
|
|
{ PROTO_ICOMPD, "ICOMPD" },
|
|
{ PROTO_LCP, "LCP" },
|
|
{ PROTO_IPCP, "IPCP" },
|
|
{ PROTO_CCP, "CCP" },
|
|
{ PROTO_PAP, "PAP" },
|
|
{ PROTO_LQR, "LQR" },
|
|
{ PROTO_CHAP, "CHAP" },
|
|
{ PROTO_MP, "MULTILINK" },
|
|
{ 0, "Others" }
|
|
};
|
|
|
|
void
|
|
link_ProtocolRecord(struct link *l, u_short proto, int type)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < NPROTOSTAT; i++)
|
|
if (ProtocolStat[i].number == proto)
|
|
break;
|
|
|
|
if (type == PROTO_IN)
|
|
l->proto_in[i]++;
|
|
else
|
|
l->proto_out[i]++;
|
|
}
|
|
|
|
void
|
|
link_ReportProtocolStatus(struct link *l, struct prompt *prompt)
|
|
{
|
|
int i;
|
|
|
|
prompt_Printf(prompt, " Protocol in out "
|
|
"Protocol in out\n");
|
|
for (i = 0; i < NPROTOSTAT; i++) {
|
|
prompt_Printf(prompt, " %-9s: %8lu, %8lu",
|
|
ProtocolStat[i].name, l->proto_in[i], l->proto_out[i]);
|
|
if ((i % 2) == 0)
|
|
prompt_Printf(prompt, "\n");
|
|
}
|
|
if (!(i % 2))
|
|
prompt_Printf(prompt, "\n");
|
|
}
|
|
|
|
void
|
|
link_PushPacket(struct link *l, struct mbuf *bp, struct bundle *b, int pri,
|
|
u_short proto)
|
|
{
|
|
int layer;
|
|
|
|
/*
|
|
* When we ``push'' a packet into the link, it gets processed by the
|
|
* ``push'' function in each layer starting at the top.
|
|
* We never expect the result of a ``push'' to be more than one
|
|
* packet (as we do with ``pull''s).
|
|
*/
|
|
|
|
if(pri < 0 || pri >= LINK_QUEUES(l))
|
|
pri = 0;
|
|
|
|
for (layer = l->nlayers; layer && bp; layer--)
|
|
if (l->layer[layer - 1]->push != NULL)
|
|
bp = (*l->layer[layer - 1]->push)(b, l, bp, pri, &proto);
|
|
|
|
if (bp) {
|
|
link_AddOutOctets(l, mbuf_Length(bp));
|
|
log_Printf(LogDEBUG, "link_PushPacket: Transmit proto 0x%04x\n", proto);
|
|
mbuf_Enqueue(l->Queue + pri, mbuf_Contiguous(bp));
|
|
}
|
|
}
|
|
|
|
void
|
|
link_PullPacket(struct link *l, char *buf, size_t len, struct bundle *b)
|
|
{
|
|
struct mbuf *bp, *lbp[LAYER_MAX], *next;
|
|
u_short lproto[LAYER_MAX], proto;
|
|
int layer;
|
|
|
|
/*
|
|
* When we ``pull'' a packet from the link, it gets processed by the
|
|
* ``pull'' function in each layer starting at the bottom.
|
|
* Each ``pull'' may produce multiple packets, chained together using
|
|
* bp->pnext.
|
|
* Each packet that results from each pull has to be pulled through
|
|
* all of the higher layers before the next resulting packet is pulled
|
|
* through anything; this ensures that packets that depend on the
|
|
* fsm state resulting from the receipt of the previous packet aren't
|
|
* surprised.
|
|
*/
|
|
|
|
link_AddInOctets(l, len);
|
|
|
|
memset(lbp, '\0', sizeof lbp);
|
|
lbp[0] = mbuf_Alloc(len, MB_UNKNOWN);
|
|
memcpy(MBUF_CTOP(lbp[0]), buf, len);
|
|
lproto[0] = 0;
|
|
layer = 0;
|
|
|
|
while (layer || lbp[layer]) {
|
|
if (lbp[layer] == NULL) {
|
|
layer--;
|
|
continue;
|
|
}
|
|
bp = lbp[layer];
|
|
lbp[layer] = bp->pnext;
|
|
bp->pnext = NULL;
|
|
proto = lproto[layer];
|
|
|
|
if (l->layer[layer]->pull != NULL)
|
|
bp = (*l->layer[layer]->pull)(b, l, bp, &proto);
|
|
|
|
if (layer == l->nlayers - 1) {
|
|
/* We've just done the top layer, despatch the packet(s) */
|
|
while (bp) {
|
|
next = bp->pnext;
|
|
bp->pnext = NULL;
|
|
log_Printf(LogDEBUG, "link_PullPacket: Despatch proto 0x%04x\n", proto);
|
|
Despatch(b, l, bp, proto);
|
|
bp = next;
|
|
}
|
|
} else {
|
|
lbp[++layer] = bp;
|
|
lproto[layer] = proto;
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
link_Stack(struct link *l, struct layer *layer)
|
|
{
|
|
if (l->nlayers == sizeof l->layer / sizeof l->layer[0]) {
|
|
log_Printf(LogERROR, "%s: Oops, cannot stack a %s layer...\n",
|
|
l->name, layer->name);
|
|
return 0;
|
|
}
|
|
l->layer[l->nlayers++] = layer;
|
|
return 1;
|
|
}
|
|
|
|
void
|
|
link_EmptyStack(struct link *l)
|
|
{
|
|
l->nlayers = 0;
|
|
}
|
|
|
|
static const struct {
|
|
u_short proto;
|
|
struct mbuf *(*fn)(struct bundle *, struct link *, struct mbuf *);
|
|
} despatcher[] = {
|
|
{ PROTO_IP, ip_Input },
|
|
{ PROTO_MP, mp_Input },
|
|
{ PROTO_LCP, lcp_Input },
|
|
{ PROTO_IPCP, ipcp_Input },
|
|
{ PROTO_PAP, pap_Input },
|
|
{ PROTO_CHAP, chap_Input },
|
|
{ PROTO_CCP, ccp_Input },
|
|
{ PROTO_LQR, lqr_Input },
|
|
{ PROTO_CBCP, cbcp_Input }
|
|
};
|
|
|
|
#define DSIZE (sizeof despatcher / sizeof despatcher[0])
|
|
|
|
static void
|
|
Despatch(struct bundle *bundle, struct link *l, struct mbuf *bp, u_short proto)
|
|
{
|
|
int f;
|
|
|
|
for (f = 0; f < DSIZE; f++)
|
|
if (despatcher[f].proto == proto) {
|
|
bp = (*despatcher[f].fn)(bundle, l, bp);
|
|
break;
|
|
}
|
|
|
|
if (bp) {
|
|
struct physical *p = link2physical(l);
|
|
|
|
log_Printf(LogPHASE, "%s protocol 0x%04x (%s)\n",
|
|
f == DSIZE ? "Unknown" : "Unexpected", proto,
|
|
hdlc_Protocol2Nam(proto));
|
|
bp = mbuf_Contiguous(proto_Prepend(bp, proto, 0, 0));
|
|
lcp_SendProtoRej(&l->lcp, MBUF_CTOP(bp), bp->cnt);
|
|
if (p) {
|
|
p->hdlc.lqm.SaveInDiscards++;
|
|
p->hdlc.stats.unknownproto++;
|
|
}
|
|
mbuf_Free(bp);
|
|
}
|
|
}
|
|
|
|
int
|
|
link_ShowLayers(struct cmdargs const *arg)
|
|
{
|
|
struct link *l = command_ChooseLink(arg);
|
|
int layer;
|
|
|
|
for (layer = l->nlayers; layer; layer--)
|
|
prompt_Printf(arg->prompt, "%s%s", layer == l->nlayers ? "" : ", ",
|
|
l->layer[layer - 1]->name);
|
|
if (l->nlayers)
|
|
prompt_Printf(arg->prompt, "\n");
|
|
|
|
return 0;
|
|
}
|