xref: /freebsd/usr.sbin/ppp/mp.c (revision 92b095588304eafcb4ba45699fe8afec726b5969)
13b0f8d2eSBrian Somers /*-
23b0f8d2eSBrian Somers  * Copyright (c) 1998 Brian Somers <brian@Awfulhak.org>
33b0f8d2eSBrian Somers  * All rights reserved.
43b0f8d2eSBrian Somers  *
53b0f8d2eSBrian Somers  * Redistribution and use in source and binary forms, with or without
63b0f8d2eSBrian Somers  * modification, are permitted provided that the following conditions
73b0f8d2eSBrian Somers  * are met:
83b0f8d2eSBrian Somers  * 1. Redistributions of source code must retain the above copyright
93b0f8d2eSBrian Somers  *    notice, this list of conditions and the following disclaimer.
103b0f8d2eSBrian Somers  * 2. Redistributions in binary form must reproduce the above copyright
113b0f8d2eSBrian Somers  *    notice, this list of conditions and the following disclaimer in the
123b0f8d2eSBrian Somers  *    documentation and/or other materials provided with the distribution.
133b0f8d2eSBrian Somers  *
143b0f8d2eSBrian Somers  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
153b0f8d2eSBrian Somers  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
163b0f8d2eSBrian Somers  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
173b0f8d2eSBrian Somers  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
183b0f8d2eSBrian Somers  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
193b0f8d2eSBrian Somers  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
203b0f8d2eSBrian Somers  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
213b0f8d2eSBrian Somers  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
223b0f8d2eSBrian Somers  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
233b0f8d2eSBrian Somers  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
243b0f8d2eSBrian Somers  * SUCH DAMAGE.
253b0f8d2eSBrian Somers  *
2692b09558SBrian Somers  *	$Id: mp.c,v 1.12 1998/06/30 23:04:17 brian Exp $
273b0f8d2eSBrian Somers  */
283b0f8d2eSBrian Somers 
293b0f8d2eSBrian Somers #include <sys/types.h>
303b0f8d2eSBrian Somers #include <netinet/in.h>
313b0f8d2eSBrian Somers #include <netinet/in_systm.h>
323b0f8d2eSBrian Somers #include <netinet/ip.h>
3349052c95SBrian Somers #include <arpa/inet.h>
3408676022SBrian Somers #include <net/if_dl.h>
3508676022SBrian Somers #include <sys/socket.h>
361fa665f5SBrian Somers #include <sys/un.h>
373b0f8d2eSBrian Somers 
3808676022SBrian Somers #include <errno.h>
391fa665f5SBrian Somers #include <paths.h>
403b0f8d2eSBrian Somers #include <stdlib.h>
4149052c95SBrian Somers #include <stdio.h>
423b0f8d2eSBrian Somers #include <string.h>
431fa665f5SBrian Somers #include <sys/stat.h>
443b0f8d2eSBrian Somers #include <termios.h>
4508676022SBrian Somers #include <unistd.h>
463b0f8d2eSBrian Somers 
47c9e11a11SBrian Somers #include "defs.h"
483b0f8d2eSBrian Somers #include "command.h"
493b0f8d2eSBrian Somers #include "mbuf.h"
503b0f8d2eSBrian Somers #include "log.h"
513b0f8d2eSBrian Somers #include "timer.h"
523b0f8d2eSBrian Somers #include "fsm.h"
533b0f8d2eSBrian Somers #include "iplist.h"
543b0f8d2eSBrian Somers #include "throughput.h"
553b0f8d2eSBrian Somers #include "slcompress.h"
563b0f8d2eSBrian Somers #include "ipcp.h"
573b0f8d2eSBrian Somers #include "auth.h"
583b0f8d2eSBrian Somers #include "lcp.h"
593b0f8d2eSBrian Somers #include "lqr.h"
603b0f8d2eSBrian Somers #include "hdlc.h"
613b0f8d2eSBrian Somers #include "async.h"
623b0f8d2eSBrian Somers #include "ccp.h"
633b0f8d2eSBrian Somers #include "link.h"
643b0f8d2eSBrian Somers #include "descriptor.h"
653b0f8d2eSBrian Somers #include "physical.h"
663b0f8d2eSBrian Somers #include "chat.h"
673b0f8d2eSBrian Somers #include "lcpproto.h"
683b0f8d2eSBrian Somers #include "filter.h"
693b0f8d2eSBrian Somers #include "mp.h"
703b0f8d2eSBrian Somers #include "chap.h"
7192b09558SBrian Somers #include "cbcp.h"
723b0f8d2eSBrian Somers #include "datalink.h"
733b0f8d2eSBrian Somers #include "bundle.h"
743b0f8d2eSBrian Somers #include "ip.h"
7549052c95SBrian Somers #include "prompt.h"
7608676022SBrian Somers #include "id.h"
7708676022SBrian Somers #include "arp.h"
783b0f8d2eSBrian Somers 
79643f4904SBrian Somers void
80643f4904SBrian Somers peerid_Init(struct peerid *peer)
81643f4904SBrian Somers {
82643f4904SBrian Somers   peer->enddisc.class = 0;
83643f4904SBrian Somers   *peer->enddisc.address = '\0';
84643f4904SBrian Somers   peer->enddisc.len = 0;
85643f4904SBrian Somers   *peer->authname = '\0';
86643f4904SBrian Somers }
87643f4904SBrian Somers 
88643f4904SBrian Somers int
89643f4904SBrian Somers peerid_Equal(const struct peerid *p1, const struct peerid *p2)
90643f4904SBrian Somers {
91643f4904SBrian Somers   return !strcmp(p1->authname, p2->authname) &&
92643f4904SBrian Somers          p1->enddisc.class == p2->enddisc.class &&
93643f4904SBrian Somers          p1->enddisc.len == p2->enddisc.len &&
94643f4904SBrian Somers          !memcmp(p1->enddisc.address, p2->enddisc.address, p1->enddisc.len);
95643f4904SBrian Somers }
96643f4904SBrian Somers 
973b0f8d2eSBrian Somers static u_int32_t
98147613eaSBrian Somers inc_seq(unsigned is12bit, u_int32_t seq)
993b0f8d2eSBrian Somers {
1003b0f8d2eSBrian Somers   seq++;
101147613eaSBrian Somers   if (is12bit) {
1023b0f8d2eSBrian Somers     if (seq & 0xfffff000)
1033b0f8d2eSBrian Somers       seq = 0;
1043b0f8d2eSBrian Somers   } else if (seq & 0xff000000)
1053b0f8d2eSBrian Somers     seq = 0;
1063b0f8d2eSBrian Somers   return seq;
1073b0f8d2eSBrian Somers }
1083b0f8d2eSBrian Somers 
1093b0f8d2eSBrian Somers static int
1101bcced10SBrian Somers isbefore(unsigned is12bit, u_int32_t seq1, u_int32_t seq2)
1111bcced10SBrian Somers {
112b4b280abSBrian Somers   u_int32_t max = (is12bit ? 0xfff : 0xffffff) - 0x200;
113b4b280abSBrian Somers 
114b4b280abSBrian Somers   if (seq1 > max) {
115b4b280abSBrian Somers     if (seq2 < 0x200 || seq2 > seq1)
116b4b280abSBrian Somers       return 1;
117b4b280abSBrian Somers   } else if ((seq1 > 0x200 || seq2 <= max) && seq1 < seq2)
118b4b280abSBrian Somers     return 1;
119b4b280abSBrian Somers 
120b4b280abSBrian Somers   return 0;
1211bcced10SBrian Somers }
1221bcced10SBrian Somers 
1231bcced10SBrian Somers static int
1243b0f8d2eSBrian Somers mp_ReadHeader(struct mp *mp, struct mbuf *m, struct mp_header *header)
1253b0f8d2eSBrian Somers {
12649052c95SBrian Somers   if (mp->local_is12bit) {
127ce828a6eSBrian Somers     header->seq = ntohs(*(u_int16_t *)MBUF_CTOP(m));
1283b0f8d2eSBrian Somers     if (header->seq & 0x3000) {
129dd7e2610SBrian Somers       log_Printf(LogWARN, "Oops - MP header without required zero bits\n");
1303b0f8d2eSBrian Somers       return 0;
1313b0f8d2eSBrian Somers     }
132ce828a6eSBrian Somers     header->begin = header->seq & 0x8000 ? 1 : 0;
133ce828a6eSBrian Somers     header->end = header->seq & 0x4000 ? 1 : 0;
1343b0f8d2eSBrian Somers     header->seq &= 0x0fff;
1353b0f8d2eSBrian Somers     return 2;
1363b0f8d2eSBrian Somers   } else {
137ce828a6eSBrian Somers     header->seq = ntohl(*(u_int32_t *)MBUF_CTOP(m));
1383b0f8d2eSBrian Somers     if (header->seq & 0x3f000000) {
139dd7e2610SBrian Somers       log_Printf(LogWARN, "Oops - MP header without required zero bits\n");
1403b0f8d2eSBrian Somers       return 0;
1413b0f8d2eSBrian Somers     }
142ce828a6eSBrian Somers     header->begin = header->seq & 0x80000000 ? 1 : 0;
143ce828a6eSBrian Somers     header->end = header->seq & 0x40000000 ? 1 : 0;
1443b0f8d2eSBrian Somers     header->seq &= 0x00ffffff;
1453b0f8d2eSBrian Somers     return 4;
1463b0f8d2eSBrian Somers   }
1473b0f8d2eSBrian Somers }
1483b0f8d2eSBrian Somers 
1493b0f8d2eSBrian Somers static void
1503b0f8d2eSBrian Somers mp_LayerStart(void *v, struct fsm *fp)
1513b0f8d2eSBrian Somers {
15249052c95SBrian Somers   /* The given FSM (ccp) is about to start up ! */
1533b0f8d2eSBrian Somers }
1543b0f8d2eSBrian Somers 
1553b0f8d2eSBrian Somers static void
1563b0f8d2eSBrian Somers mp_LayerUp(void *v, struct fsm *fp)
1573b0f8d2eSBrian Somers {
15849052c95SBrian Somers   /* The given fsm (ccp) is now up */
1593b0f8d2eSBrian Somers }
1603b0f8d2eSBrian Somers 
1613b0f8d2eSBrian Somers static void
1623b0f8d2eSBrian Somers mp_LayerDown(void *v, struct fsm *fp)
1633b0f8d2eSBrian Somers {
16449052c95SBrian Somers   /* The given FSM (ccp) has been told to come down */
1653b0f8d2eSBrian Somers }
1663b0f8d2eSBrian Somers 
1673b0f8d2eSBrian Somers static void
1683b0f8d2eSBrian Somers mp_LayerFinish(void *v, struct fsm *fp)
1693b0f8d2eSBrian Somers {
17049052c95SBrian Somers   /* The given fsm (ccp) is now down */
1710a1b5c9dSBrian Somers   if (fp->state == ST_CLOSED && fp->open_mode == OPEN_PASSIVE)
1720a1b5c9dSBrian Somers     fsm_Open(fp);		/* CCP goes to ST_STOPPED */
1733b0f8d2eSBrian Somers }
1743b0f8d2eSBrian Somers 
1753b0f8d2eSBrian Somers void
1763b0f8d2eSBrian Somers mp_Init(struct mp *mp, struct bundle *bundle)
1773b0f8d2eSBrian Somers {
17849052c95SBrian Somers   mp->peer_is12bit = mp->local_is12bit = 0;
17949052c95SBrian Somers   mp->peer_mrru = mp->local_mrru = 0;
180643f4904SBrian Somers 
181643f4904SBrian Somers   peerid_Init(&mp->peer);
182643f4904SBrian Somers 
1839c53a7b1SBrian Somers   mp->out.seq = 0;
1849c53a7b1SBrian Somers   mp->out.link = 0;
1853b0f8d2eSBrian Somers   mp->seq.min_in = 0;
1863b0f8d2eSBrian Somers   mp->seq.next_in = 0;
1873b0f8d2eSBrian Somers   mp->inbufs = NULL;
1883b0f8d2eSBrian Somers   mp->bundle = bundle;
1893b0f8d2eSBrian Somers 
1903b0f8d2eSBrian Somers   mp->link.type = MP_LINK;
1913b0f8d2eSBrian Somers   mp->link.name = "mp";
1923b0f8d2eSBrian Somers   mp->link.len = sizeof *mp;
193643f4904SBrian Somers 
1943b0f8d2eSBrian Somers   throughput_init(&mp->link.throughput);
1953b0f8d2eSBrian Somers   memset(mp->link.Queue, '\0', sizeof mp->link.Queue);
1963b0f8d2eSBrian Somers   memset(mp->link.proto_in, '\0', sizeof mp->link.proto_in);
1973b0f8d2eSBrian Somers   memset(mp->link.proto_out, '\0', sizeof mp->link.proto_out);
1983b0f8d2eSBrian Somers 
1993b0f8d2eSBrian Somers   mp->fsmp.LayerStart = mp_LayerStart;
2003b0f8d2eSBrian Somers   mp->fsmp.LayerUp = mp_LayerUp;
2013b0f8d2eSBrian Somers   mp->fsmp.LayerDown = mp_LayerDown;
2023b0f8d2eSBrian Somers   mp->fsmp.LayerFinish = mp_LayerFinish;
2033b0f8d2eSBrian Somers   mp->fsmp.object = mp;
2043b0f8d2eSBrian Somers 
2051fa665f5SBrian Somers   mpserver_Init(&mp->server);
2061fa665f5SBrian Somers 
20749052c95SBrian Somers   mp->cfg.mrru = 0;
20849052c95SBrian Somers   mp->cfg.shortseq = NEG_ENABLED|NEG_ACCEPTED;
20949052c95SBrian Somers   mp->cfg.enddisc.class = 0;
21049052c95SBrian Somers   *mp->cfg.enddisc.address = '\0';
21149052c95SBrian Somers   mp->cfg.enddisc.len = 0;
21249052c95SBrian Somers 
2133b0f8d2eSBrian Somers   lcp_Init(&mp->link.lcp, mp->bundle, &mp->link, NULL);
2143b0f8d2eSBrian Somers   ccp_Init(&mp->link.ccp, mp->bundle, &mp->link, &mp->fsmp);
21549052c95SBrian Somers }
21649052c95SBrian Somers 
21749052c95SBrian Somers int
2181fa665f5SBrian Somers mp_Up(struct mp *mp, struct datalink *dl)
21949052c95SBrian Somers {
2201fa665f5SBrian Somers   struct lcp *lcp = &dl->physical->link.lcp;
2211fa665f5SBrian Somers 
22249052c95SBrian Somers   if (mp->active) {
22349052c95SBrian Somers     /* We're adding a link - do a last validation on our parameters */
2241fa665f5SBrian Somers     if (!peerid_Equal(&dl->peer, &mp->peer)) {
225dd7e2610SBrian Somers       log_Printf(LogPHASE, "%s: Inappropriate peer !\n", dl->name);
2261fa665f5SBrian Somers       return MP_FAILED;
227643f4904SBrian Somers     }
2281fa665f5SBrian Somers     if (mp->local_mrru != lcp->want_mrru ||
2291fa665f5SBrian Somers         mp->peer_mrru != lcp->his_mrru ||
2301fa665f5SBrian Somers         mp->local_is12bit != lcp->want_shortseq ||
2311fa665f5SBrian Somers         mp->peer_is12bit != lcp->his_shortseq) {
232dd7e2610SBrian Somers       log_Printf(LogPHASE, "%s: Invalid MRRU/SHORTSEQ MP parameters !\n",
2331fa665f5SBrian Somers                 dl->name);
2341fa665f5SBrian Somers       return MP_FAILED;
23549052c95SBrian Somers     }
2361fa665f5SBrian Somers     return MP_ADDED;
23749052c95SBrian Somers   } else {
23849052c95SBrian Somers     /* First link in multilink mode */
23949052c95SBrian Somers 
2401fa665f5SBrian Somers     mp->local_mrru = lcp->want_mrru;
2411fa665f5SBrian Somers     mp->peer_mrru = lcp->his_mrru;
2421fa665f5SBrian Somers     mp->local_is12bit = lcp->want_shortseq;
2431fa665f5SBrian Somers     mp->peer_is12bit = lcp->his_shortseq;
2441fa665f5SBrian Somers     mp->peer = dl->peer;
24549052c95SBrian Somers 
246673903ecSBrian Somers     throughput_init(&mp->link.throughput);
247673903ecSBrian Somers     memset(mp->link.Queue, '\0', sizeof mp->link.Queue);
248673903ecSBrian Somers     memset(mp->link.proto_in, '\0', sizeof mp->link.proto_in);
249673903ecSBrian Somers     memset(mp->link.proto_out, '\0', sizeof mp->link.proto_out);
250673903ecSBrian Somers 
2519c53a7b1SBrian Somers     mp->out.seq = 0;
2529c53a7b1SBrian Somers     mp->out.link = 0;
253673903ecSBrian Somers     mp->seq.min_in = 0;
254673903ecSBrian Somers     mp->seq.next_in = 0;
255673903ecSBrian Somers 
2561fa665f5SBrian Somers     /*
2571fa665f5SBrian Somers      * Now we create our server socket.
2581fa665f5SBrian Somers      * If it already exists, join it.  Otherwise, create and own it
2591fa665f5SBrian Somers      */
26096c9bb21SBrian Somers     switch (mpserver_Open(&mp->server, &mp->peer)) {
26196c9bb21SBrian Somers     case MPSERVER_CONNECTED:
262dd7e2610SBrian Somers       log_Printf(LogPHASE, "mp: Transfer link on %s\n",
2636f384573SBrian Somers                 mp->server.socket.sun_path);
26496c9bb21SBrian Somers       mp->server.send.dl = dl;		/* Defer 'till it's safe to send */
2651fa665f5SBrian Somers       return MP_LINKSENT;
26696c9bb21SBrian Somers     case MPSERVER_FAILED:
2671fa665f5SBrian Somers       return MP_FAILED;
26896c9bb21SBrian Somers     case MPSERVER_LISTENING:
269dd7e2610SBrian Somers       log_Printf(LogPHASE, "mp: Listening on %s\n", mp->server.socket.sun_path);
270dd7e2610SBrian Somers       log_Printf(LogPHASE, "    First link: %s\n", dl->name);
2711fa665f5SBrian Somers 
27249052c95SBrian Somers       /* Re-point our IPCP layer at our MP link */
273ce828a6eSBrian Somers       ipcp_SetLink(&mp->bundle->ncp.ipcp, &mp->link);
2743b0f8d2eSBrian Somers 
2753b0f8d2eSBrian Somers       /* Our lcp's already up 'cos of the NULL parent */
27606337856SBrian Somers       if (ccp_SetOpenMode(&mp->link.ccp)) {
277dd7e2610SBrian Somers         fsm_Up(&mp->link.ccp.fsm);
278dd7e2610SBrian Somers         fsm_Open(&mp->link.ccp.fsm);
27906337856SBrian Somers       }
2803b0f8d2eSBrian Somers 
2813b0f8d2eSBrian Somers       mp->active = 1;
28296c9bb21SBrian Somers       break;
28349052c95SBrian Somers     }
2841fa665f5SBrian Somers   }
2853b0f8d2eSBrian Somers 
2861fa665f5SBrian Somers   return MP_UP;
2873b0f8d2eSBrian Somers }
2883b0f8d2eSBrian Somers 
2893b0f8d2eSBrian Somers void
290673903ecSBrian Somers mp_Down(struct mp *mp)
291673903ecSBrian Somers {
292673903ecSBrian Somers   if (mp->active) {
293673903ecSBrian Somers     struct mbuf *next;
294673903ecSBrian Somers 
2951fa665f5SBrian Somers     /* Don't want any more of these */
2961fa665f5SBrian Somers     mpserver_Close(&mp->server);
2971fa665f5SBrian Somers 
2981fa665f5SBrian Somers     /* CCP goes down with a bang */
29909206a6fSBrian Somers     fsm2initial(&mp->link.ccp.fsm);
300673903ecSBrian Somers 
301673903ecSBrian Somers     /* Received fragments go in the bit-bucket */
302673903ecSBrian Somers     while (mp->inbufs) {
303673903ecSBrian Somers       next = mp->inbufs->pnext;
304dd7e2610SBrian Somers       mbuf_Free(mp->inbufs);
305673903ecSBrian Somers       mp->inbufs = next;
306673903ecSBrian Somers     }
307673903ecSBrian Somers 
308643f4904SBrian Somers     peerid_Init(&mp->peer);
309673903ecSBrian Somers     mp->active = 0;
310673903ecSBrian Somers   }
311673903ecSBrian Somers }
312673903ecSBrian Somers 
313673903ecSBrian Somers void
3143b0f8d2eSBrian Somers mp_linkInit(struct mp_link *mplink)
3153b0f8d2eSBrian Somers {
3163b0f8d2eSBrian Somers   mplink->seq = 0;
3173b0f8d2eSBrian Somers   mplink->weight = 1500;
3183b0f8d2eSBrian Somers }
3193b0f8d2eSBrian Somers 
3203b0f8d2eSBrian Somers void
3213b0f8d2eSBrian Somers mp_Input(struct mp *mp, struct mbuf *m, struct physical *p)
3223b0f8d2eSBrian Somers {
3233b0f8d2eSBrian Somers   struct mp_header mh, h;
3243b0f8d2eSBrian Somers   struct mbuf *q, *last;
3253b0f8d2eSBrian Somers   int32_t seq;
3263b0f8d2eSBrian Somers 
32786b1f0d7SBrian Somers   /*
32886b1f0d7SBrian Somers    * When `m' and `p' are NULL, it means our oldest link has gone down.
32986b1f0d7SBrian Somers    * We want to determine a new min, and process any intermediate stuff
33086b1f0d7SBrian Somers    * as normal
33186b1f0d7SBrian Somers    */
33286b1f0d7SBrian Somers 
33386b1f0d7SBrian Somers   if (m && mp_ReadHeader(mp, m, &mh) == 0) {
334dd7e2610SBrian Somers     mbuf_Free(m);
3353b0f8d2eSBrian Somers     return;
3363b0f8d2eSBrian Somers   }
3373b0f8d2eSBrian Somers 
33886b1f0d7SBrian Somers   if (p) {
3393b0f8d2eSBrian Somers     seq = p->dl->mp.seq;
3403b0f8d2eSBrian Somers     p->dl->mp.seq = mh.seq;
34186b1f0d7SBrian Somers   } else
34286b1f0d7SBrian Somers     seq = mp->seq.min_in;
34386b1f0d7SBrian Somers 
3443b0f8d2eSBrian Somers   if (mp->seq.min_in == seq) {
3453b0f8d2eSBrian Somers     /*
3463b0f8d2eSBrian Somers      * We've received new data on the link that has our min (oldest) seq.
3473b0f8d2eSBrian Somers      * Figure out which link now has the smallest (oldest) seq.
3483b0f8d2eSBrian Somers      */
3493b0f8d2eSBrian Somers     struct datalink *dl;
3503b0f8d2eSBrian Somers 
35186b1f0d7SBrian Somers     mp->seq.min_in = (u_int32_t)-1;
3523b0f8d2eSBrian Somers     for (dl = mp->bundle->links; dl; dl = dl->next)
35386b1f0d7SBrian Somers       if (dl->state == DATALINK_OPEN &&
35486b1f0d7SBrian Somers           (mp->seq.min_in == -1 ||
35586b1f0d7SBrian Somers            isbefore(mp->local_is12bit, dl->mp.seq, mp->seq.min_in)))
3563b0f8d2eSBrian Somers         mp->seq.min_in = dl->mp.seq;
3573b0f8d2eSBrian Somers   }
3583b0f8d2eSBrian Somers 
3593b0f8d2eSBrian Somers   /*
3603b0f8d2eSBrian Somers    * Now process as many of our fragments as we can, adding our new
3613b0f8d2eSBrian Somers    * fragment in as we go, and ordering with the oldest at the top of
3623b0f8d2eSBrian Somers    * the queue.
3633b0f8d2eSBrian Somers    */
3643b0f8d2eSBrian Somers 
3653b0f8d2eSBrian Somers   if (!mp->inbufs) {
3663b0f8d2eSBrian Somers     mp->inbufs = m;
3673b0f8d2eSBrian Somers     m = NULL;
3683b0f8d2eSBrian Somers   }
3693b0f8d2eSBrian Somers 
3703b0f8d2eSBrian Somers   last = NULL;
3713b0f8d2eSBrian Somers   seq = mp->seq.next_in;
3723b0f8d2eSBrian Somers   q = mp->inbufs;
3733b0f8d2eSBrian Somers   while (q) {
3743b0f8d2eSBrian Somers     mp_ReadHeader(mp, q, &h);
3751bcced10SBrian Somers     if (m && isbefore(mp->local_is12bit, mh.seq, h.seq)) {
3763b0f8d2eSBrian Somers       /* Our received fragment fits in before this one, so link it in */
3773b0f8d2eSBrian Somers       if (last)
3783b0f8d2eSBrian Somers         last->pnext = m;
3793b0f8d2eSBrian Somers       else
3803b0f8d2eSBrian Somers         mp->inbufs = m;
3813b0f8d2eSBrian Somers       m->pnext = q;
3823b0f8d2eSBrian Somers       q = m;
3833b0f8d2eSBrian Somers       h = mh;
3843b0f8d2eSBrian Somers       m = NULL;
3853b0f8d2eSBrian Somers     }
3863b0f8d2eSBrian Somers 
3873b0f8d2eSBrian Somers     if (h.seq != seq) {
3883b0f8d2eSBrian Somers       /* we're missing something :-( */
3893b0f8d2eSBrian Somers       if (mp->seq.min_in > seq) {
3903b0f8d2eSBrian Somers         /* we're never gonna get it */
3913b0f8d2eSBrian Somers         struct mbuf *next;
3923b0f8d2eSBrian Somers 
3933b0f8d2eSBrian Somers         /* Zap all older fragments */
3943b0f8d2eSBrian Somers         while (mp->inbufs != q) {
395dd7e2610SBrian Somers           log_Printf(LogDEBUG, "Drop frag\n");
3963b0f8d2eSBrian Somers           next = mp->inbufs->pnext;
397dd7e2610SBrian Somers           mbuf_Free(mp->inbufs);
3983b0f8d2eSBrian Somers           mp->inbufs = next;
3993b0f8d2eSBrian Somers         }
4003b0f8d2eSBrian Somers 
4013b0f8d2eSBrian Somers         /*
4023b0f8d2eSBrian Somers          * Zap everything until the next `end' fragment OR just before
4033b0f8d2eSBrian Somers          * the next `begin' fragment OR 'till seq.min_in - whichever
4043b0f8d2eSBrian Somers          * comes first.
4053b0f8d2eSBrian Somers          */
4063b0f8d2eSBrian Somers         do {
4073b0f8d2eSBrian Somers           mp_ReadHeader(mp, mp->inbufs, &h);
4083b0f8d2eSBrian Somers           if (h.begin) {
409ce828a6eSBrian Somers             /* We might be able to process this ! */
4103b0f8d2eSBrian Somers             h.seq--;  /* We're gonna look for fragment with h.seq+1 */
4113b0f8d2eSBrian Somers             break;
4123b0f8d2eSBrian Somers           }
4133b0f8d2eSBrian Somers           next = mp->inbufs->pnext;
414dd7e2610SBrian Somers           log_Printf(LogDEBUG, "Drop frag %u\n", h.seq);
415dd7e2610SBrian Somers           mbuf_Free(mp->inbufs);
4163b0f8d2eSBrian Somers           mp->inbufs = next;
417ce828a6eSBrian Somers         } while (mp->inbufs && (h.seq >= mp->seq.min_in || h.end));
4183b0f8d2eSBrian Somers 
4193b0f8d2eSBrian Somers         /*
4203b0f8d2eSBrian Somers          * Continue processing things from here.
4213b0f8d2eSBrian Somers          * This deals with the possibility that we received a fragment
4223b0f8d2eSBrian Somers          * on the slowest link that invalidates some of our data (because
4233b0f8d2eSBrian Somers          * of the hole at `q'), but where there are subsequent `whole'
4243b0f8d2eSBrian Somers          * packets that have already been received.
4253b0f8d2eSBrian Somers          */
4263b0f8d2eSBrian Somers 
427147613eaSBrian Somers         mp->seq.next_in = seq = inc_seq(mp->local_is12bit, h.seq);
4283b0f8d2eSBrian Somers         last = NULL;
4293b0f8d2eSBrian Somers         q = mp->inbufs;
4303b0f8d2eSBrian Somers       } else
4313b0f8d2eSBrian Somers         /* we may still receive the missing fragment */
4323b0f8d2eSBrian Somers         break;
4333b0f8d2eSBrian Somers     } else if (h.end) {
4343b0f8d2eSBrian Somers       /* We've got something, reassemble */
4353b0f8d2eSBrian Somers       struct mbuf **frag = &q;
4363b0f8d2eSBrian Somers       int len;
437ce828a6eSBrian Somers       u_long first = -1;
4383b0f8d2eSBrian Somers 
4393b0f8d2eSBrian Somers       do {
4403b0f8d2eSBrian Somers         *frag = mp->inbufs;
4413b0f8d2eSBrian Somers         mp->inbufs = mp->inbufs->pnext;
4423b0f8d2eSBrian Somers         len = mp_ReadHeader(mp, *frag, &h);
443ce828a6eSBrian Somers         if (first == -1)
444ce828a6eSBrian Somers           first = h.seq;
4453b0f8d2eSBrian Somers         (*frag)->offset += len;
4463b0f8d2eSBrian Somers         (*frag)->cnt -= len;
4473b0f8d2eSBrian Somers         (*frag)->pnext = NULL;
4483b0f8d2eSBrian Somers         if (frag == &q && !h.begin) {
449dd7e2610SBrian Somers           log_Printf(LogWARN, "Oops - MP frag %lu should have a begin flag\n",
4503b0f8d2eSBrian Somers                     (u_long)h.seq);
451dd7e2610SBrian Somers           mbuf_Free(q);
4523b0f8d2eSBrian Somers           q = NULL;
4533b0f8d2eSBrian Somers         } else if (frag != &q && h.begin) {
454dd7e2610SBrian Somers           log_Printf(LogWARN, "Oops - MP frag %lu should have an end flag\n",
4553b0f8d2eSBrian Somers                     (u_long)h.seq - 1);
4563b0f8d2eSBrian Somers           /*
4573b0f8d2eSBrian Somers            * Stuff our fragment back at the front of the queue and zap
4583b0f8d2eSBrian Somers            * our half-assembed packet.
4593b0f8d2eSBrian Somers            */
4603b0f8d2eSBrian Somers           (*frag)->pnext = mp->inbufs;
4613b0f8d2eSBrian Somers           mp->inbufs = *frag;
4623b0f8d2eSBrian Somers           *frag = NULL;
463dd7e2610SBrian Somers           mbuf_Free(q);
4643b0f8d2eSBrian Somers           q = NULL;
4653b0f8d2eSBrian Somers           frag = &q;
4663b0f8d2eSBrian Somers           h.end = 0;	/* just in case it's a whole packet */
4673b0f8d2eSBrian Somers         } else
4683b0f8d2eSBrian Somers           do
4693b0f8d2eSBrian Somers             frag = &(*frag)->next;
470ce828a6eSBrian Somers           while (*frag != NULL);
4713b0f8d2eSBrian Somers       } while (!h.end);
4723b0f8d2eSBrian Somers 
4733b0f8d2eSBrian Somers       if (q) {
474673903ecSBrian Somers         u_short proto;
475673903ecSBrian Somers         u_char ch;
476673903ecSBrian Somers 
477dd7e2610SBrian Somers         q = mbuf_Read(q, &ch, 1);
478673903ecSBrian Somers         proto = ch;
479673903ecSBrian Somers         if (!(proto & 1)) {
480dd7e2610SBrian Somers           q = mbuf_Read(q, &ch, 1);
481673903ecSBrian Somers           proto <<= 8;
4823b0f8d2eSBrian Somers           proto += ch;
483673903ecSBrian Somers         }
484dd7e2610SBrian Somers         if (log_IsKept(LogDEBUG))
485dd7e2610SBrian Somers           log_Printf(LogDEBUG, "MP: Reassembled frags %ld-%lu, length %d\n",
486dd7e2610SBrian Somers                     first, (u_long)h.seq, mbuf_Length(q));
4873b0f8d2eSBrian Somers         hdlc_DecodePacket(mp->bundle, proto, q, &mp->link);
4883b0f8d2eSBrian Somers       }
4893b0f8d2eSBrian Somers 
490147613eaSBrian Somers       mp->seq.next_in = seq = inc_seq(mp->local_is12bit, h.seq);
4913b0f8d2eSBrian Somers       last = NULL;
4923b0f8d2eSBrian Somers       q = mp->inbufs;
4933b0f8d2eSBrian Somers     } else {
4943b0f8d2eSBrian Somers       /* Look for the next fragment */
495147613eaSBrian Somers       seq = inc_seq(mp->local_is12bit, seq);
4963b0f8d2eSBrian Somers       last = q;
4973b0f8d2eSBrian Somers       q = q->pnext;
4983b0f8d2eSBrian Somers     }
4993b0f8d2eSBrian Somers   }
5003b0f8d2eSBrian Somers 
5013b0f8d2eSBrian Somers   if (m) {
5023b0f8d2eSBrian Somers     /* We still have to find a home for our new fragment */
5033b0f8d2eSBrian Somers     last = NULL;
5043b0f8d2eSBrian Somers     for (q = mp->inbufs; q; last = q, q = q->pnext) {
5053b0f8d2eSBrian Somers       mp_ReadHeader(mp, q, &h);
5061bcced10SBrian Somers       if (isbefore(mp->local_is12bit, mh.seq, h.seq))
507147613eaSBrian Somers         break;
508147613eaSBrian Somers     }
509147613eaSBrian Somers     /* Our received fragment fits in here */
5103b0f8d2eSBrian Somers     if (last)
5113b0f8d2eSBrian Somers       last->pnext = m;
5123b0f8d2eSBrian Somers     else
5133b0f8d2eSBrian Somers       mp->inbufs = m;
5143b0f8d2eSBrian Somers     m->pnext = q;
5153b0f8d2eSBrian Somers   }
5163b0f8d2eSBrian Somers }
5173b0f8d2eSBrian Somers 
5183b0f8d2eSBrian Somers static void
519b4b280abSBrian Somers mp_Output(struct mp *mp, struct link *l, struct mbuf *m, u_int32_t begin,
520b4b280abSBrian Somers           u_int32_t end)
5213b0f8d2eSBrian Somers {
5223b0f8d2eSBrian Somers   struct mbuf *mo;
5233b0f8d2eSBrian Somers 
524ce828a6eSBrian Somers   /* Stuff an MP header on the front of our packet and send it */
525dd7e2610SBrian Somers   mo = mbuf_Alloc(4, MB_MP);
5263b0f8d2eSBrian Somers   mo->next = m;
52749052c95SBrian Somers   if (mp->peer_is12bit) {
528ce828a6eSBrian Somers     u_int16_t *seq16;
529ce828a6eSBrian Somers 
530ce828a6eSBrian Somers     seq16 = (u_int16_t *)MBUF_CTOP(mo);
5319c53a7b1SBrian Somers     *seq16 = htons((begin << 15) | (end << 14) | (u_int16_t)mp->out.seq);
5323b0f8d2eSBrian Somers     mo->cnt = 2;
5333b0f8d2eSBrian Somers   } else {
534ce828a6eSBrian Somers     u_int32_t *seq32;
535ce828a6eSBrian Somers 
536ce828a6eSBrian Somers     seq32 = (u_int32_t *)MBUF_CTOP(mo);
5379c53a7b1SBrian Somers     *seq32 = htonl((begin << 31) | (end << 30) | (u_int32_t)mp->out.seq);
5383b0f8d2eSBrian Somers     mo->cnt = 4;
5393b0f8d2eSBrian Somers   }
540dd7e2610SBrian Somers   if (log_IsKept(LogDEBUG))
5419c53a7b1SBrian Somers     log_Printf(LogDEBUG, "MP[frag %d]: Send %d bytes on link `%s'\n",
5429c53a7b1SBrian Somers               mp->out.seq, mbuf_Length(mo), l->name);
543147613eaSBrian Somers   mp->out.seq = inc_seq(mp->peer_is12bit, mp->out.seq);
5443b0f8d2eSBrian Somers 
5450a1b5c9dSBrian Somers   if (!ccp_Compress(&l->ccp, l, PRI_NORMAL, PROTO_MP, mo))
546dd7e2610SBrian Somers     hdlc_Output(l, PRI_NORMAL, PROTO_MP, mo);
5473b0f8d2eSBrian Somers }
5483b0f8d2eSBrian Somers 
5493b0f8d2eSBrian Somers int
5503b0f8d2eSBrian Somers mp_FillQueues(struct bundle *bundle)
5513b0f8d2eSBrian Somers {
5523b0f8d2eSBrian Somers   struct mp *mp = &bundle->ncp.mp;
5539c53a7b1SBrian Somers   struct datalink *dl, *fdl;
554b4b280abSBrian Somers   int total, add, len, thislink, nlinks;
555b4b280abSBrian Somers   u_int32_t begin, end;
5563b0f8d2eSBrian Somers   struct mbuf *m, *mo;
5573b0f8d2eSBrian Somers 
5589c53a7b1SBrian Somers   thislink = nlinks = 0;
5599c53a7b1SBrian Somers   for (fdl = NULL, dl = bundle->links; dl; dl = dl->next) {
56086b1f0d7SBrian Somers     /* Include non-open links here as mp->out.link will stay more correct */
5619c53a7b1SBrian Somers     if (!fdl) {
5629c53a7b1SBrian Somers       if (thislink == mp->out.link)
5639c53a7b1SBrian Somers         fdl = dl;
5649c53a7b1SBrian Somers       else
5659c53a7b1SBrian Somers         thislink++;
5669c53a7b1SBrian Somers     }
5679c53a7b1SBrian Somers     nlinks++;
5689c53a7b1SBrian Somers   }
5699c53a7b1SBrian Somers 
5709c53a7b1SBrian Somers   if (!fdl) {
5719c53a7b1SBrian Somers     fdl = bundle->links;
5721bc9b5baSBrian Somers     if (!fdl)
5731bc9b5baSBrian Somers       return 0;
5749c53a7b1SBrian Somers     thislink = 0;
5759c53a7b1SBrian Somers   }
5763b0f8d2eSBrian Somers 
5773b0f8d2eSBrian Somers   total = 0;
5789c53a7b1SBrian Somers   for (dl = fdl; nlinks > 0; dl = dl->next, nlinks--, thislink++) {
5799c53a7b1SBrian Somers     if (!dl) {
5809c53a7b1SBrian Somers       dl = bundle->links;
5819c53a7b1SBrian Somers       thislink = 0;
5829c53a7b1SBrian Somers     }
5839c53a7b1SBrian Somers 
5846f384573SBrian Somers     if (dl->state != DATALINK_OPEN)
5856f384573SBrian Somers       continue;
5869c53a7b1SBrian Somers 
5873b0f8d2eSBrian Somers     if (dl->physical->out)
5883b0f8d2eSBrian Somers       /* this link has suffered a short write.  Let it continue */
5893b0f8d2eSBrian Somers       continue;
5909c53a7b1SBrian Somers 
5913b0f8d2eSBrian Somers     add = link_QueueLen(&dl->physical->link);
5923b0f8d2eSBrian Somers     total += add;
5933b0f8d2eSBrian Somers     if (add)
5943b0f8d2eSBrian Somers       /* this link has got stuff already queued.  Let it continue */
5953b0f8d2eSBrian Somers       continue;
5969c53a7b1SBrian Somers 
597dd7e2610SBrian Somers     if (!link_QueueLen(&mp->link) && !ip_FlushPacket(&mp->link, bundle))
5983b0f8d2eSBrian Somers       /* Nothing else to send */
5993b0f8d2eSBrian Somers       break;
6003b0f8d2eSBrian Somers 
6013b0f8d2eSBrian Somers     m = link_Dequeue(&mp->link);
602dd7e2610SBrian Somers     len = mbuf_Length(m);
6033b0f8d2eSBrian Somers     begin = 1;
6043b0f8d2eSBrian Somers     end = 0;
6053b0f8d2eSBrian Somers 
6069c53a7b1SBrian Somers     while (!end) {
6079c53a7b1SBrian Somers       if (dl->state == DATALINK_OPEN) {
6083b0f8d2eSBrian Somers         if (len <= dl->mp.weight + LINK_MINWEIGHT) {
6099c53a7b1SBrian Somers           /*
6109c53a7b1SBrian Somers            * XXX: Should we remember how much of our `weight' wasn't sent
6119c53a7b1SBrian Somers            *      so that we can compensate next time ?
6129c53a7b1SBrian Somers            */
6133b0f8d2eSBrian Somers           mo = m;
6143b0f8d2eSBrian Somers           end = 1;
6153b0f8d2eSBrian Somers         } else {
616dd7e2610SBrian Somers           mo = mbuf_Alloc(dl->mp.weight, MB_MP);
6173b0f8d2eSBrian Somers           mo->cnt = dl->mp.weight;
6183b0f8d2eSBrian Somers           len -= mo->cnt;
619dd7e2610SBrian Somers           m = mbuf_Read(m, MBUF_CTOP(mo), mo->cnt);
6203b0f8d2eSBrian Somers         }
6213b0f8d2eSBrian Somers         mp_Output(mp, &dl->physical->link, mo, begin, end);
6223b0f8d2eSBrian Somers         begin = 0;
6233b0f8d2eSBrian Somers       }
6249c53a7b1SBrian Somers 
6259c53a7b1SBrian Somers       if (!end) {
6269c53a7b1SBrian Somers         nlinks--;
6279c53a7b1SBrian Somers         dl = dl->next;
6289c53a7b1SBrian Somers         if (!dl) {
6299c53a7b1SBrian Somers           dl = bundle->links;
6309c53a7b1SBrian Somers           thislink = 0;
6319c53a7b1SBrian Somers         } else
6329c53a7b1SBrian Somers           thislink++;
6333b0f8d2eSBrian Somers       }
6349c53a7b1SBrian Somers     }
6359c53a7b1SBrian Somers   }
6369c53a7b1SBrian Somers   mp->out.link = thislink;		/* Start here next time */
6373b0f8d2eSBrian Somers 
6383b0f8d2eSBrian Somers   return total;
6393b0f8d2eSBrian Somers }
6403b0f8d2eSBrian Somers 
6413b0f8d2eSBrian Somers int
6423b0f8d2eSBrian Somers mp_SetDatalinkWeight(struct cmdargs const *arg)
6433b0f8d2eSBrian Somers {
6443b0f8d2eSBrian Somers   int val;
6453b0f8d2eSBrian Somers 
64625092092SBrian Somers   if (arg->argc != arg->argn+1)
6473b0f8d2eSBrian Somers     return -1;
6483b0f8d2eSBrian Somers 
64925092092SBrian Somers   val = atoi(arg->argv[arg->argn]);
6503b0f8d2eSBrian Somers   if (val < LINK_MINWEIGHT) {
651dd7e2610SBrian Somers     log_Printf(LogWARN, "Link weights must not be less than %d\n",
6523b0f8d2eSBrian Somers               LINK_MINWEIGHT);
6533b0f8d2eSBrian Somers     return 1;
6543b0f8d2eSBrian Somers   }
6553b0f8d2eSBrian Somers   arg->cx->mp.weight = val;
6563b0f8d2eSBrian Somers   return 0;
6573b0f8d2eSBrian Somers }
65849052c95SBrian Somers 
65949052c95SBrian Somers int
66049052c95SBrian Somers mp_ShowStatus(struct cmdargs const *arg)
66149052c95SBrian Somers {
66249052c95SBrian Somers   struct mp *mp = &arg->bundle->ncp.mp;
66349052c95SBrian Somers 
66449052c95SBrian Somers   prompt_Printf(arg->prompt, "Multilink is %sactive\n", mp->active ? "" : "in");
6659c53a7b1SBrian Somers   if (mp->active) {
6669c53a7b1SBrian Somers     struct mbuf *m;
6679c53a7b1SBrian Somers     int bufs = 0;
6689c53a7b1SBrian Somers 
6691fa665f5SBrian Somers     prompt_Printf(arg->prompt, "Socket:         %s\n",
6706f384573SBrian Somers                   mp->server.socket.sun_path);
6719c53a7b1SBrian Somers     for (m = mp->inbufs; m; m = m->pnext)
6729c53a7b1SBrian Somers       bufs++;
6739c53a7b1SBrian Somers     prompt_Printf(arg->prompt, "Pending frags:  %d\n", bufs);
6749c53a7b1SBrian Somers   }
67549052c95SBrian Somers 
67649052c95SBrian Somers   prompt_Printf(arg->prompt, "\nMy Side:\n");
67749052c95SBrian Somers   if (mp->active) {
67849052c95SBrian Somers     prompt_Printf(arg->prompt, " MRRU:          %u\n", mp->local_mrru);
67949052c95SBrian Somers     prompt_Printf(arg->prompt, " Short Seq:     %s\n",
68049052c95SBrian Somers                   mp->local_is12bit ? "on" : "off");
68149052c95SBrian Somers   }
682643f4904SBrian Somers   prompt_Printf(arg->prompt, " Discriminator: %s\n",
68349052c95SBrian Somers                 mp_Enddisc(mp->cfg.enddisc.class, mp->cfg.enddisc.address,
68449052c95SBrian Somers                            mp->cfg.enddisc.len));
68549052c95SBrian Somers 
68649052c95SBrian Somers   prompt_Printf(arg->prompt, "\nHis Side:\n");
68749052c95SBrian Somers   if (mp->active) {
688643f4904SBrian Somers     prompt_Printf(arg->prompt, " Auth Name:     %s\n", mp->peer.authname);
6899c53a7b1SBrian Somers     prompt_Printf(arg->prompt, " Next SEQ:      %u\n", mp->out.seq);
69049052c95SBrian Somers     prompt_Printf(arg->prompt, " MRRU:          %u\n", mp->peer_mrru);
69149052c95SBrian Somers     prompt_Printf(arg->prompt, " Short Seq:     %s\n",
69249052c95SBrian Somers                   mp->peer_is12bit ? "on" : "off");
69349052c95SBrian Somers   }
694643f4904SBrian Somers   prompt_Printf(arg->prompt,   " Discriminator: %s\n",
695643f4904SBrian Somers                 mp_Enddisc(mp->peer.enddisc.class, mp->peer.enddisc.address,
696643f4904SBrian Somers                            mp->peer.enddisc.len));
69749052c95SBrian Somers 
69849052c95SBrian Somers   prompt_Printf(arg->prompt, "\nDefaults:\n");
69949052c95SBrian Somers 
70049052c95SBrian Somers   prompt_Printf(arg->prompt, " MRRU:          ");
70149052c95SBrian Somers   if (mp->cfg.mrru)
70249052c95SBrian Somers     prompt_Printf(arg->prompt, "%d (multilink enabled)\n", mp->cfg.mrru);
70349052c95SBrian Somers   else
70449052c95SBrian Somers     prompt_Printf(arg->prompt, "disabled\n");
70549052c95SBrian Somers   prompt_Printf(arg->prompt, " Short Seq:     %s\n",
70649052c95SBrian Somers                   command_ShowNegval(mp->cfg.shortseq));
70749052c95SBrian Somers 
70849052c95SBrian Somers   return 0;
70949052c95SBrian Somers }
71049052c95SBrian Somers 
71149052c95SBrian Somers const char *
71249052c95SBrian Somers mp_Enddisc(u_char c, const char *address, int len)
71349052c95SBrian Somers {
714d93d3a9cSBrian Somers   static char result[100];	/* Used immediately after it's returned */
71549052c95SBrian Somers   int f, header;
71649052c95SBrian Somers 
71749052c95SBrian Somers   switch (c) {
71808676022SBrian Somers     case ENDDISC_NULL:
71949052c95SBrian Somers       sprintf(result, "Null Class");
72049052c95SBrian Somers       break;
72149052c95SBrian Somers 
72208676022SBrian Somers     case ENDDISC_LOCAL:
72349052c95SBrian Somers       snprintf(result, sizeof result, "Local Addr: %.*s", len, address);
72449052c95SBrian Somers       break;
72549052c95SBrian Somers 
72608676022SBrian Somers     case ENDDISC_IP:
72749052c95SBrian Somers       if (len == 4)
72849052c95SBrian Somers         snprintf(result, sizeof result, "IP %s",
72949052c95SBrian Somers                  inet_ntoa(*(const struct in_addr *)address));
73049052c95SBrian Somers       else
73149052c95SBrian Somers         sprintf(result, "IP[%d] ???", len);
73249052c95SBrian Somers       break;
73349052c95SBrian Somers 
73408676022SBrian Somers     case ENDDISC_MAC:
73549052c95SBrian Somers       if (len == 6) {
73649052c95SBrian Somers         const u_char *m = (const u_char *)address;
73749052c95SBrian Somers         snprintf(result, sizeof result, "MAC %02x:%02x:%02x:%02x:%02x:%02x",
73849052c95SBrian Somers                  m[0], m[1], m[2], m[3], m[4], m[5]);
73949052c95SBrian Somers       } else
74049052c95SBrian Somers         sprintf(result, "MAC[%d] ???", len);
74149052c95SBrian Somers       break;
74249052c95SBrian Somers 
74308676022SBrian Somers     case ENDDISC_MAGIC:
74449052c95SBrian Somers       sprintf(result, "Magic: 0x");
74549052c95SBrian Somers       header = strlen(result);
74649052c95SBrian Somers       if (len > sizeof result - header - 1)
74749052c95SBrian Somers         len = sizeof result - header - 1;
74849052c95SBrian Somers       for (f = 0; f < len; f++)
74949052c95SBrian Somers         sprintf(result + header + 2 * f, "%02x", address[f]);
75049052c95SBrian Somers       break;
75149052c95SBrian Somers 
75208676022SBrian Somers     case ENDDISC_PSN:
75349052c95SBrian Somers       snprintf(result, sizeof result, "PSN: %.*s", len, address);
75449052c95SBrian Somers       break;
75549052c95SBrian Somers 
75649052c95SBrian Somers      default:
75749052c95SBrian Somers       sprintf(result, "%d: ", (int)c);
75849052c95SBrian Somers       header = strlen(result);
75949052c95SBrian Somers       if (len > sizeof result - header - 1)
76049052c95SBrian Somers         len = sizeof result - header - 1;
76149052c95SBrian Somers       for (f = 0; f < len; f++)
76249052c95SBrian Somers         sprintf(result + header + 2 * f, "%02x", address[f]);
76349052c95SBrian Somers       break;
76449052c95SBrian Somers   }
76549052c95SBrian Somers   return result;
76649052c95SBrian Somers }
76749052c95SBrian Somers 
76849052c95SBrian Somers int
76949052c95SBrian Somers mp_SetEnddisc(struct cmdargs const *arg)
77049052c95SBrian Somers {
77149052c95SBrian Somers   struct mp *mp = &arg->bundle->ncp.mp;
772d47dceb8SBrian Somers   struct in_addr addr;
77349052c95SBrian Somers 
77449052c95SBrian Somers   if (bundle_Phase(arg->bundle) != PHASE_DEAD) {
775dd7e2610SBrian Somers     log_Printf(LogWARN, "set enddisc: Only available at phase DEAD\n");
77649052c95SBrian Somers     return 1;
77749052c95SBrian Somers   }
77849052c95SBrian Somers 
77949052c95SBrian Somers   if (arg->argc == arg->argn) {
78049052c95SBrian Somers     mp->cfg.enddisc.class = 0;
78149052c95SBrian Somers     *mp->cfg.enddisc.address = '\0';
78249052c95SBrian Somers     mp->cfg.enddisc.len = 0;
783e43ebac1SBrian Somers   } else if (arg->argc > arg->argn) {
78408676022SBrian Somers     if (!strcasecmp(arg->argv[arg->argn], "label")) {
78508676022SBrian Somers       mp->cfg.enddisc.class = ENDDISC_LOCAL;
78608676022SBrian Somers       strcpy(mp->cfg.enddisc.address, arg->bundle->cfg.label);
78708676022SBrian Somers       mp->cfg.enddisc.len = strlen(mp->cfg.enddisc.address);
78808676022SBrian Somers     } else if (!strcasecmp(arg->argv[arg->argn], "ip")) {
789259a6191SBrian Somers       if (arg->bundle->ncp.ipcp.my_ip.s_addr == INADDR_ANY)
790259a6191SBrian Somers         addr = arg->bundle->ncp.ipcp.cfg.my_range.ipaddr;
791d47dceb8SBrian Somers       else
792259a6191SBrian Somers         addr = arg->bundle->ncp.ipcp.my_ip;
793d47dceb8SBrian Somers       memcpy(mp->cfg.enddisc.address, &addr.s_addr, sizeof addr.s_addr);
79408676022SBrian Somers       mp->cfg.enddisc.class = ENDDISC_IP;
79549052c95SBrian Somers       mp->cfg.enddisc.len = sizeof arg->bundle->ncp.ipcp.my_ip.s_addr;
79608676022SBrian Somers     } else if (!strcasecmp(arg->argv[arg->argn], "mac")) {
79708676022SBrian Somers       struct sockaddr_dl hwaddr;
79808676022SBrian Somers       int s;
79908676022SBrian Somers 
800259a6191SBrian Somers       if (arg->bundle->ncp.ipcp.my_ip.s_addr == INADDR_ANY)
801259a6191SBrian Somers         addr = arg->bundle->ncp.ipcp.cfg.my_range.ipaddr;
802d47dceb8SBrian Somers       else
803259a6191SBrian Somers         addr = arg->bundle->ncp.ipcp.my_ip;
804d47dceb8SBrian Somers 
80508676022SBrian Somers       s = ID0socket(AF_INET, SOCK_DGRAM, 0);
80608676022SBrian Somers       if (s < 0) {
807dd7e2610SBrian Somers         log_Printf(LogERROR, "set enddisc: socket(): %s\n", strerror(errno));
80808676022SBrian Somers         return 2;
80908676022SBrian Somers       }
810d47dceb8SBrian Somers       if (get_ether_addr(s, addr, &hwaddr)) {
81108676022SBrian Somers         mp->cfg.enddisc.class = ENDDISC_MAC;
81208676022SBrian Somers         memcpy(mp->cfg.enddisc.address, hwaddr.sdl_data + hwaddr.sdl_nlen,
81308676022SBrian Somers                hwaddr.sdl_alen);
81408676022SBrian Somers         mp->cfg.enddisc.len = hwaddr.sdl_alen;
81508676022SBrian Somers       } else {
816dd7e2610SBrian Somers         log_Printf(LogWARN, "set enddisc: Can't locate MAC address for %s\n",
817259a6191SBrian Somers                   inet_ntoa(addr));
81808676022SBrian Somers         close(s);
81908676022SBrian Somers         return 4;
82008676022SBrian Somers       }
82108676022SBrian Somers       close(s);
82249052c95SBrian Somers     } else if (!strcasecmp(arg->argv[arg->argn], "magic")) {
82349052c95SBrian Somers       int f;
82449052c95SBrian Somers 
82549052c95SBrian Somers       randinit();
82649052c95SBrian Somers       for (f = 0; f < 20; f += sizeof(long))
82749052c95SBrian Somers         *(long *)(mp->cfg.enddisc.address + f) = random();
82808676022SBrian Somers       mp->cfg.enddisc.class = ENDDISC_MAGIC;
82949052c95SBrian Somers       mp->cfg.enddisc.len = 20;
83049052c95SBrian Somers     } else if (!strcasecmp(arg->argv[arg->argn], "psn")) {
83149052c95SBrian Somers       if (arg->argc > arg->argn+1) {
83208676022SBrian Somers         mp->cfg.enddisc.class = ENDDISC_PSN;
83349052c95SBrian Somers         strcpy(mp->cfg.enddisc.address, arg->argv[arg->argn+1]);
83449052c95SBrian Somers         mp->cfg.enddisc.len = strlen(mp->cfg.enddisc.address);
83549052c95SBrian Somers       } else {
836dd7e2610SBrian Somers         log_Printf(LogWARN, "PSN endpoint requires additional data\n");
83708676022SBrian Somers         return 5;
83849052c95SBrian Somers       }
83949052c95SBrian Somers     } else {
840dd7e2610SBrian Somers       log_Printf(LogWARN, "%s: Unrecognised endpoint type\n",
84149052c95SBrian Somers                 arg->argv[arg->argn]);
84208676022SBrian Somers       return 6;
84349052c95SBrian Somers     }
844e43ebac1SBrian Somers   }
84549052c95SBrian Somers 
84649052c95SBrian Somers   return 0;
84749052c95SBrian Somers }
8481fa665f5SBrian Somers 
8491fa665f5SBrian Somers static int
8501fa665f5SBrian Somers mpserver_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e,
8511fa665f5SBrian Somers                    int *n)
8521fa665f5SBrian Somers {
8531fa665f5SBrian Somers   struct mpserver *s = descriptor2mpserver(d);
8540f2f3eb3SBrian Somers   int result;
8551fa665f5SBrian Somers 
8560f2f3eb3SBrian Somers   result = 0;
8576f384573SBrian Somers   if (s->send.dl != NULL) {
85896c9bb21SBrian Somers     /* We've connect()ed */
859b7c5748eSBrian Somers     if (!link_QueueLen(&s->send.dl->physical->link) &&
860b7c5748eSBrian Somers         !s->send.dl->physical->out) {
861b7c5748eSBrian Somers       /* Only send if we've transmitted all our data (i.e. the ConfigAck) */
8620f2f3eb3SBrian Somers       result -= datalink_RemoveFromSet(s->send.dl, r, w, e);
86396c9bb21SBrian Somers       bundle_SendDatalink(s->send.dl, s->fd, &s->socket);
8646f384573SBrian Somers       s->send.dl = NULL;
86596c9bb21SBrian Somers       s->fd = -1;
866ea722969SBrian Somers     } else
867ea722969SBrian Somers       /* Never read from a datalink that's on death row ! */
8680f2f3eb3SBrian Somers       result -= datalink_RemoveFromSet(s->send.dl, r, NULL, NULL);
86996c9bb21SBrian Somers   } else if (r && s->fd >= 0) {
8701fa665f5SBrian Somers     if (*n < s->fd + 1)
8711fa665f5SBrian Somers       *n = s->fd + 1;
8721fa665f5SBrian Somers     FD_SET(s->fd, r);
87324989c68SBrian Somers     log_Printf(LogTIMER, "mp: fdset(r) %d\n", s->fd);
8740f2f3eb3SBrian Somers     result++;
8751fa665f5SBrian Somers   }
8760f2f3eb3SBrian Somers   return result;
8771fa665f5SBrian Somers }
8781fa665f5SBrian Somers 
8791fa665f5SBrian Somers static int
8801fa665f5SBrian Somers mpserver_IsSet(struct descriptor *d, const fd_set *fdset)
8811fa665f5SBrian Somers {
8821fa665f5SBrian Somers   struct mpserver *s = descriptor2mpserver(d);
8831fa665f5SBrian Somers   return s->fd >= 0 && FD_ISSET(s->fd, fdset);
8841fa665f5SBrian Somers }
8851fa665f5SBrian Somers 
8861fa665f5SBrian Somers static void
8871fa665f5SBrian Somers mpserver_Read(struct descriptor *d, struct bundle *bundle, const fd_set *fdset)
8881fa665f5SBrian Somers {
8891fa665f5SBrian Somers   struct mpserver *s = descriptor2mpserver(d);
8906f384573SBrian Somers   struct sockaddr in;
8911fa665f5SBrian Somers   int fd, size;
8921fa665f5SBrian Somers 
8936f384573SBrian Somers   size = sizeof in;
8946f384573SBrian Somers   fd = accept(s->fd, &in, &size);
8951fa665f5SBrian Somers   if (fd < 0) {
896dd7e2610SBrian Somers     log_Printf(LogERROR, "mpserver_Read: accept(): %s\n", strerror(errno));
8971fa665f5SBrian Somers     return;
8981fa665f5SBrian Somers   }
8991fa665f5SBrian Somers 
9001bc9b5baSBrian Somers   if (in.sa_family == AF_LOCAL)
90196c9bb21SBrian Somers     bundle_ReceiveDatalink(bundle, fd, (struct sockaddr_un *)&in);
90254cd8e13SBrian Somers   else
9031fa665f5SBrian Somers     close(fd);
9041fa665f5SBrian Somers }
9051fa665f5SBrian Somers 
9061af29a6eSBrian Somers static int
9071fa665f5SBrian Somers mpserver_Write(struct descriptor *d, struct bundle *bundle, const fd_set *fdset)
9081fa665f5SBrian Somers {
9091fa665f5SBrian Somers   /* We never want to write here ! */
910a33b2ef7SBrian Somers   log_Printf(LogALERT, "mpserver_Write: Internal error: Bad call !\n");
9111af29a6eSBrian Somers   return 0;
9121fa665f5SBrian Somers }
9131fa665f5SBrian Somers 
9141fa665f5SBrian Somers void
9151fa665f5SBrian Somers mpserver_Init(struct mpserver *s)
9161fa665f5SBrian Somers {
9171fa665f5SBrian Somers   s->desc.type = MPSERVER_DESCRIPTOR;
9181fa665f5SBrian Somers   s->desc.UpdateSet = mpserver_UpdateSet;
9191fa665f5SBrian Somers   s->desc.IsSet = mpserver_IsSet;
9201fa665f5SBrian Somers   s->desc.Read = mpserver_Read;
9211fa665f5SBrian Somers   s->desc.Write = mpserver_Write;
9226f384573SBrian Somers   s->send.dl = NULL;
9231fa665f5SBrian Somers   s->fd = -1;
9246f384573SBrian Somers   memset(&s->socket, '\0', sizeof s->socket);
9251fa665f5SBrian Somers }
9261fa665f5SBrian Somers 
9271fa665f5SBrian Somers int
9281fa665f5SBrian Somers mpserver_Open(struct mpserver *s, struct peerid *peer)
9291fa665f5SBrian Somers {
93096c9bb21SBrian Somers   int f, l;
9311fa665f5SBrian Somers   mode_t mask;
9321fa665f5SBrian Somers 
9331fa665f5SBrian Somers   if (s->fd != -1) {
934a33b2ef7SBrian Somers     log_Printf(LogALERT, "Internal error !  mpserver already open\n");
9356f384573SBrian Somers     mpserver_Close(s);
9361fa665f5SBrian Somers   }
9371fa665f5SBrian Somers 
9386f384573SBrian Somers   l = snprintf(s->socket.sun_path, sizeof s->socket.sun_path, "%sppp-%s-%02x-",
9396f384573SBrian Somers                _PATH_VARRUN, peer->authname, peer->enddisc.class);
9401fa665f5SBrian Somers 
9416f384573SBrian Somers   for (f = 0; f < peer->enddisc.len && l < sizeof s->socket.sun_path - 2; f++) {
9426f384573SBrian Somers     snprintf(s->socket.sun_path + l, sizeof s->socket.sun_path - l,
9431fa665f5SBrian Somers              "%02x", *(u_char *)(peer->enddisc.address+f));
9446f384573SBrian Somers     l += 2;
9451fa665f5SBrian Somers   }
9461fa665f5SBrian Somers 
9476f384573SBrian Somers   s->socket.sun_family = AF_LOCAL;
9486f384573SBrian Somers   s->socket.sun_len = sizeof s->socket;
9491fa665f5SBrian Somers   s->fd = ID0socket(PF_LOCAL, SOCK_STREAM, 0);
9501fa665f5SBrian Somers   if (s->fd < 0) {
951dd7e2610SBrian Somers     log_Printf(LogERROR, "mpserver: socket: %s\n", strerror(errno));
95296c9bb21SBrian Somers     return MPSERVER_FAILED;
9531fa665f5SBrian Somers   }
9541fa665f5SBrian Somers 
9556f384573SBrian Somers   setsockopt(s->fd, SOL_SOCKET, SO_REUSEADDR, (struct sockaddr *)&s->socket,
9566f384573SBrian Somers              sizeof s->socket);
9571fa665f5SBrian Somers   mask = umask(0177);
9586f384573SBrian Somers   if (ID0bind_un(s->fd, &s->socket) < 0) {
9596f384573SBrian Somers     if (errno != EADDRINUSE) {
960dd7e2610SBrian Somers       log_Printf(LogPHASE, "mpserver: can't create bundle socket %s (%s)\n",
9616f384573SBrian Somers                 s->socket.sun_path, strerror(errno));
9621fa665f5SBrian Somers       umask(mask);
9631fa665f5SBrian Somers       close(s->fd);
9641fa665f5SBrian Somers       s->fd = -1;
96596c9bb21SBrian Somers       return MPSERVER_FAILED;
9666f384573SBrian Somers     }
9676f384573SBrian Somers     umask(mask);
9686f384573SBrian Somers     if (ID0connect_un(s->fd, &s->socket) < 0) {
969dd7e2610SBrian Somers       log_Printf(LogPHASE, "mpserver: can't connect to bundle socket %s (%s)\n",
9706f384573SBrian Somers                 s->socket.sun_path, strerror(errno));
9716f384573SBrian Somers       if (errno == ECONNREFUSED)
972dd7e2610SBrian Somers         log_Printf(LogPHASE, "          Has the previous server died badly ?\n");
9736f384573SBrian Somers       close(s->fd);
9746f384573SBrian Somers       s->fd = -1;
97596c9bb21SBrian Somers       return MPSERVER_FAILED;
9766f384573SBrian Somers     }
9776f384573SBrian Somers 
9786f384573SBrian Somers     /* Donate our link to the other guy */
97996c9bb21SBrian Somers     return MPSERVER_CONNECTED;
9801fa665f5SBrian Somers   }
9816f384573SBrian Somers 
9826f384573SBrian Somers   /* Listen for other ppp invocations that want to donate links */
9831fa665f5SBrian Somers   if (listen(s->fd, 5) != 0) {
984dd7e2610SBrian Somers     log_Printf(LogERROR, "mpserver: Unable to listen to socket"
9851fa665f5SBrian Somers               " - BUNDLE overload?\n");
9861fa665f5SBrian Somers     mpserver_Close(s);
9871fa665f5SBrian Somers   }
9881fa665f5SBrian Somers 
98996c9bb21SBrian Somers   return MPSERVER_LISTENING;
9901fa665f5SBrian Somers }
9911fa665f5SBrian Somers 
9921fa665f5SBrian Somers void
9931fa665f5SBrian Somers mpserver_Close(struct mpserver *s)
9941fa665f5SBrian Somers {
9956f384573SBrian Somers   if (s->send.dl != NULL) {
99696c9bb21SBrian Somers     bundle_SendDatalink(s->send.dl, s->fd, &s->socket);
9976f384573SBrian Somers     s->send.dl = NULL;
99896c9bb21SBrian Somers     s->fd = -1;
99996c9bb21SBrian Somers   } else if (s->fd >= 0) {
10001fa665f5SBrian Somers     close(s->fd);
10016f384573SBrian Somers     if (ID0unlink(s->socket.sun_path) == -1)
1002dd7e2610SBrian Somers       log_Printf(LogERROR, "%s: Failed to remove: %s\n", s->socket.sun_path,
10036f384573SBrian Somers                 strerror(errno));
10046f384573SBrian Somers     memset(&s->socket, '\0', sizeof s->socket);
10051fa665f5SBrian Somers     s->fd = -1;
10061fa665f5SBrian Somers   }
10071fa665f5SBrian Somers }
100886b1f0d7SBrian Somers 
100986b1f0d7SBrian Somers void
101086b1f0d7SBrian Somers mp_LinkLost(struct mp *mp, struct datalink *dl)
101186b1f0d7SBrian Somers {
101286b1f0d7SBrian Somers   if (mp->seq.min_in == dl->mp.seq)
101386b1f0d7SBrian Somers     /* We've lost the link that's holding everything up ! */
101486b1f0d7SBrian Somers     mp_Input(mp, NULL, NULL);
101586b1f0d7SBrian Somers }
1016