pppd/ipv6cp.c

   1 /*
   2  * ipv6cp.c - PPP IPV6 Control Protocol.
   3  *
   4  * Derived from :
   5  *
   6  *
   7  * ipcp.c - PPP IP Control Protocol.
   8  *
   9  * Copyright (c) 1989 Carnegie Mellon University.
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms are permitted
  13  * provided that the above copyright notice and this paragraph are
  14  * duplicated in all such forms and that any documentation,
  15  * advertising materials, and other materials related to such
  16  * distribution and use acknowledge that the software was developed
  17  * by Carnegie Mellon University.  The name of the
  18  * University may not be used to endorse or promote products derived
  19  * from this software without specific prior written permission.
  20  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  22  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  23  *
  24  * $Id: ipv6cp.c,v 1.2 1999/08/13 06:46:13 paulus Exp $
  25  *
  26  *
  27  * Original version by Inria (www.inria.fr)
  28  * Modified to match RFC2472 by Tommi Komulainen <Tommi.Komulainen@iki.fi>
  29  */
  30
  31 #define RCSID   "$Id: ipv6cp.c,v 1.2 1999/08/13 06:46:13 paulus Exp $"
  32
  33 /*
  34  * TODO:
  35  *
  36  * Better defines for selecting the ordering of
  37  *   interface up / set address. (currently checks for __linux__,
  38  *   since SVR4 && (SNI || __USLC__) didn't work properly)
  39  */
  40
  41 #include <stdio.h>
  42 #include <string.h>
  43 #include <unistd.h>
  44 #include <netdb.h>
  45 #include <sys/param.h>
  46 #include <sys/types.h>
  47 #include <sys/socket.h>
  48 #include <netinet/in.h>
  49
  50 #include "pppd.h"
  51 #include "fsm.h"
  52 #include "ipcp.h"
  53 #include "ipv6cp.h"
  54 #include "magic.h"
  55 #include "pathnames.h"
  56
  57 static const char rcsid[] = RCSID;
  58
  59 /* global vars */
  60 ipv6cp_options ipv6cp_wantoptions[NUM_PPP];     /* Options that we want to request */
  61 ipv6cp_options ipv6cp_gotoptions[NUM_PPP];      /* Options that peer ack'd */
  62 ipv6cp_options ipv6cp_allowoptions[NUM_PPP];    /* Options we allow peer to request */
  63 ipv6cp_options ipv6cp_hisoptions[NUM_PPP];      /* Options that we ack'd */
  64 int no_ifaceid_neg = 0;
  65
  66 /* local vars */
  67 static int ipv6cp_is_up;
  68
  69 /*
  70  * Callbacks for fsm code.  (CI = Configuration Information)
  71  */
  72 static void ipv6cp_resetci __P((fsm *));        /* Reset our CI */
  73 static int  ipv6cp_cilen __P((fsm *));          /* Return length of our CI */
  74 static void ipv6cp_addci __P((fsm *, u_char *, int *)); /* Add our CI */
  75 static int  ipv6cp_ackci __P((fsm *, u_char *, int));   /* Peer ack'd our CI */
  76 static int  ipv6cp_nakci __P((fsm *, u_char *, int));   /* Peer nak'd our CI */
  77 static int  ipv6cp_rejci __P((fsm *, u_char *, int));   /* Peer rej'd our CI */
  78 static int  ipv6cp_reqci __P((fsm *, u_char *, int *, int)); /* Rcv CI */
  79 static void ipv6cp_up __P((fsm *));             /* We're UP */
  80 static void ipv6cp_down __P((fsm *));           /* We're DOWN */
  81 static void ipv6cp_finished __P((fsm *));       /* Don't need lower layer */
  82
  83 fsm ipv6cp_fsm[NUM_PPP];                /* IPV6CP fsm structure */
  84
  85 static fsm_callbacks ipv6cp_callbacks = { /* IPV6CP callback routines */
  86     ipv6cp_resetci,             /* Reset our Configuration Information */
  87     ipv6cp_cilen,               /* Length of our Configuration Information */
  88     ipv6cp_addci,               /* Add our Configuration Information */
  89     ipv6cp_ackci,               /* ACK our Configuration Information */
  90     ipv6cp_nakci,               /* NAK our Configuration Information */
  91     ipv6cp_rejci,               /* Reject our Configuration Information */
  92     ipv6cp_reqci,               /* Request peer's Configuration Information */
  93     ipv6cp_up,                  /* Called when fsm reaches OPENED state */
  94     ipv6cp_down,                /* Called when fsm leaves OPENED state */
  95     NULL,                       /* Called when we want the lower layer up */
  96     ipv6cp_finished,            /* Called when we want the lower layer down */
  97     NULL,                       /* Called when Protocol-Reject received */
  98     NULL,                       /* Retransmission is necessary */
  99     NULL,                       /* Called to handle protocol-specific codes */
 100     "IPV6CP"                    /* String name of protocol */
 101 };
 102
 103 /*
 104  * Command-line options.
 105  */
 106 static int setifaceid __P((char *arg));
 107
 108 static option_t ipv6cp_option_list[] = {
 109     { "ipv6", o_special, setifaceid,
 110       "Set interface identifiers for IPV6" },
 111     { "noipv6", o_bool, &ipv6cp_protent.enabled_flag,
 112       "Disable IPv6 and IPv6CP" },
 113     { "-ipv6", o_bool, &ipv6cp_protent.enabled_flag,
 114       "Disable IPv6 and IPv6CP" },
 115
 116     { "ipv6cp-accept-local", o_bool, &ipv6cp_allowoptions[0].accept_local,
 117       "Accept peer's interface identifier for us", 1 },
 118     { "ipv6cp-use-ipaddr", o_bool, &ipv6cp_allowoptions[0].use_ip,
 119       "Use (default) IPv4 address as interface identifier", 0 },
 120
 121     { "ipv6cp-restart", o_int, &ipv6cp_fsm[0].timeouttime,
 122       "Set timeout for IPv6CP" },
 123     { "ipv6cp-max-terminate", o_int, &ipv6cp_fsm[0].maxtermtransmits,
 124       "Set max #xmits for term-reqs" },
 125     { "ipv6cp-max-configure", o_int, &ipv6cp_fsm[0].maxconfreqtransmits,
 126       "Set max #xmits for conf-reqs" },
 127     { "ipv6cp-max-failure", o_int, &ipv6cp_fsm[0].maxnakloops,
 128       "Set max #conf-naks for IPv6CP" },
 129
 130    { NULL }
 131 };
 132
 133
 134 /*
 135  * Protocol entry points from main code.
 136  */
 137 static void ipv6cp_init __P((int));
 138 static void ipv6cp_open __P((int));
 139 static void ipv6cp_close __P((int, char *));
 140 static void ipv6cp_lowerup __P((int));
 141 static void ipv6cp_lowerdown __P((int));
 142 static void ipv6cp_input __P((int, u_char *, int));
 143 static void ipv6cp_protrej __P((int));
 144 static int  ipv6cp_printpkt __P((u_char *, int,
 145                                void (*) __P((void *, char *, ...)), void *));
 146 static void ipv6_check_options __P((void));
 147 static int  ipv6_demand_conf __P((int));
 148 static int  ipv6_active_pkt __P((u_char *, int));
 149
 150 struct protent ipv6cp_protent = {
 151     PPP_IPV6CP,
 152     ipv6cp_init,
 153     ipv6cp_input,
 154     ipv6cp_protrej,
 155     ipv6cp_lowerup,
 156     ipv6cp_lowerdown,
 157     ipv6cp_open,
 158     ipv6cp_close,
 159     ipv6cp_printpkt,
 160     NULL,
 161     0,
 162     "IPV6CP",
 163     "IPV6",
 164     ipv6cp_option_list,
 165     ipv6_check_options,
 166     ipv6_demand_conf,
 167     ipv6_active_pkt
 168 };
 169
 170 static void ipv6cp_clear_addrs __P((int));
 171 static void ipv6cp_script __P((char *));
 172 static void ipv6cp_script_done __P((void *));
 173
 174 /*
 175  * Lengths of configuration options.
 176  */
 177 #define CILEN_VOID      2
 178 #define CILEN_COMPRESS  4       /* length for RFC2023 compress opt. */
 179 #define CILEN_IFACEID   10      /* RFC2472, interface identifier    */
 180
 181 #define CODENAME(x)     ((x) == CONFACK ? "ACK" : \
 182                          (x) == CONFNAK ? "NAK" : "REJ")
 183
 184 /*
 185  * This state variable is used to ensure that we don't
 186  * run an ipcp-up/down script while one is already running.
 187  */
 188 static enum script_state {
 189     s_down,
 190     s_up,
 191 } ipv6cp_script_state;
 192 static pid_t ipv6cp_script_pid;
 193
 194 /*
 195  * setifaceid - set the interface identifiers manually
 196  */
 197 static int
 198 setifaceid(arg)
 199     char *arg;
 200 {
 201     char *comma;
 202     ipv6cp_options *wo = &ipv6cp_wantoptions[0];
 203     struct in6_addr addr;
 204
 205 #define VALIDID(a) (    ((a).s6_addr64[0] == 0) && \
 206                         ((a).s6_addr64[1] != 0) )
 207
 208     if ((comma = strchr(arg, ',')) == NULL)
 209         comma = arg + strlen(arg);
 210
 211     /*
 212      * If comma first character, then no local identifier
 213      */
 214     if (comma != arg) {
 215         *comma = '\0';
 216
 217         if (inet_pton(AF_INET6, arg, &addr) == 0 || !VALIDID(addr)) {
 218             option_error("Illegal interface identifier: %s", arg);
 219             return 0;
 220         }
 221
 222         eui64_copy(addr.s6_addr32[2], wo->ourid);
 223         wo->opt_local = 1;
 224         *comma = ',';
 225     }
 226
 227     /*
 228      * If comma last character, the no remote identifier
 229      */
 230     if (*comma != 0 && *++comma != '\0') {
 231         if (inet_pton(AF_INET6, comma, &addr) == 0 || !VALIDID(addr)) {
 232             option_error("Illegal interface identifier: %s", comma);
 233             return 0;
 234         }
 235         eui64_copy(addr.s6_addr32[2], wo->hisid);
 236         wo->opt_remote = 1;
 237     }
 238
 239     return 1;
 240 }
 241
 242 /*
 243  * Make a string representation of a network address.
 244  */
 245 char *
 246 llv6_ntoa(ifaceid)
 247     eui64_t ifaceid;
 248 {
 249     static char b[64];
 250
 251     sprintf(b, "fe80::%s", eui64_ntoa(ifaceid));
 252     return b;
 253 }
 254
 255
 256 /*
 257  * ipv6cp_init - Initialize IPV6CP.
 258  */
 259 static void
 260 ipv6cp_init(unit)
 261     int unit;
 262 {
 263     fsm *f = &ipv6cp_fsm[unit];
 264     ipv6cp_options *wo = &ipv6cp_wantoptions[unit];
 265     ipv6cp_options *ao = &ipv6cp_allowoptions[unit];
 266
 267     f->unit = unit;
 268     f->protocol = PPP_IPV6CP;
 269     f->callbacks = &ipv6cp_callbacks;
 270     fsm_init(&ipv6cp_fsm[unit]);
 271
 272     memset(wo, 0, sizeof(*wo));
 273     memset(ao, 0, sizeof(*ao));
 274
 275     wo->accept_local = 1;
 276     wo->neg_ifaceid = 1;
 277     ao->neg_ifaceid = 1;
 278
 279 #ifdef IPV6CP_COMP
 280     wo->neg_vj = 1;
 281     ao->neg_vj = 1;
 282     wo->vj_protocol = IPV6CP_COMP;
 283 #endif
 284
 285 }
 286
 287
 288 /*
 289  * ipv6cp_open - IPV6CP is allowed to come up.
 290  */
 291 static void
 292 ipv6cp_open(unit)
 293     int unit;
 294 {
 295     fsm_open(&ipv6cp_fsm[unit]);
 296 }
 297
 298
 299 /*
 300  * ipv6cp_close - Take IPV6CP down.
 301  */
 302 static void
 303 ipv6cp_close(unit, reason)
 304     int unit;
 305     char *reason;
 306 {
 307     fsm_close(&ipv6cp_fsm[unit], reason);
 308 }
 309
 310
 311 /*
 312  * ipv6cp_lowerup - The lower layer is up.
 313  */
 314 static void
 315 ipv6cp_lowerup(unit)
 316     int unit;
 317 {
 318     fsm_lowerup(&ipv6cp_fsm[unit]);
 319 }
 320
 321
 322 /*
 323  * ipv6cp_lowerdown - The lower layer is down.
 324  */
 325 static void
 326 ipv6cp_lowerdown(unit)
 327     int unit;
 328 {
 329     fsm_lowerdown(&ipv6cp_fsm[unit]);
 330 }
 331
 332
 333 /*
 334  * ipv6cp_input - Input IPV6CP packet.
 335  */
 336 static void
 337 ipv6cp_input(unit, p, len)
 338     int unit;
 339     u_char *p;
 340     int len;
 341 {
 342     fsm_input(&ipv6cp_fsm[unit], p, len);
 343 }
 344
 345
 346 /*
 347  * ipv6cp_protrej - A Protocol-Reject was received for IPV6CP.
 348  *
 349  * Pretend the lower layer went down, so we shut up.
 350  */
 351 static void
 352 ipv6cp_protrej(unit)
 353     int unit;
 354 {
 355     fsm_lowerdown(&ipv6cp_fsm[unit]);
 356 }
 357
 358
 359 /*
 360  * ipv6cp_resetci - Reset our CI.
 361  */
 362 static void
 363 ipv6cp_resetci(f)
 364     fsm *f;
 365 {
 366     ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
 367     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 368
 369     wo->req_ifaceid = wo->neg_ifaceid && ipv6cp_allowoptions[f->unit].neg_ifaceid;
 370
 371     if (!wo->opt_local) {
 372         eui64_magic_nz(wo->ourid);
 373     }
 374
 375     *go = *wo;
 376     eui64_zero(go->hisid);      /* last proposed interface identifier */
 377 }
 378
 379
 380 /*
 381  * ipv6cp_cilen - Return length of our CI.
 382  */
 383 static int
 384 ipv6cp_cilen(f)
 385     fsm *f;
 386 {
 387     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 388
 389 #define LENCIVJ(neg)            (neg ? CILEN_COMPRESS : 0)
 390 #define LENCIIFACEID(neg)       (neg ? CILEN_IFACEID : 0)
 391
 392     return (LENCIIFACEID(go->neg_ifaceid) +
 393             LENCIVJ(go->neg_vj));
 394 }
 395
 396
 397 /*
 398  * ipv6cp_addci - Add our desired CIs to a packet.
 399  */
 400 static void
 401 ipv6cp_addci(f, ucp, lenp)
 402     fsm *f;
 403     u_char *ucp;
 404     int *lenp;
 405 {
 406     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 407     int len = *lenp;
 408
 409 #define ADDCIVJ(opt, neg, val) \
 410     if (neg) { \
 411         int vjlen = CILEN_COMPRESS; \
 412         if (len >= vjlen) { \
 413             PUTCHAR(opt, ucp); \
 414             PUTCHAR(vjlen, ucp); \
 415             PUTSHORT(val, ucp); \
 416             len -= vjlen; \
 417         } else \
 418             neg = 0; \
 419     }
 420
 421 #define ADDCIIFACEID(opt, neg, val1) \
 422     if (neg) { \
 423         int idlen = CILEN_IFACEID; \
 424         if (len >= idlen) { \
 425             PUTCHAR(opt, ucp); \
 426             PUTCHAR(idlen, ucp); \
 427             eui64_put(val1, ucp); \
 428             len -= idlen; \
 429         } else \
 430             neg = 0; \
 431     }
 432
 433     ADDCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid);
 434
 435     ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol);
 436
 437     *lenp -= len;
 438 }
 439
 440
 441 /*
 442  * ipv6cp_ackci - Ack our CIs.
 443  *
 444  * Returns:
 445  *      0 - Ack was bad.
 446  *      1 - Ack was good.
 447  */
 448 static int
 449 ipv6cp_ackci(f, p, len)
 450     fsm *f;
 451     u_char *p;
 452     int len;
 453 {
 454     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 455     u_short cilen, citype, cishort;
 456     eui64_t ifaceid;
 457
 458     /*
 459      * CIs must be in exactly the same order that we sent...
 460      * Check packet length and CI length at each step.
 461      * If we find any deviations, then this packet is bad.
 462      */
 463
 464 #define ACKCIVJ(opt, neg, val) \
 465     if (neg) { \
 466         int vjlen = CILEN_COMPRESS; \
 467         if ((len -= vjlen) < 0) \
 468             goto bad; \
 469         GETCHAR(citype, p); \
 470         GETCHAR(cilen, p); \
 471         if (cilen != vjlen || \
 472             citype != opt)  \
 473             goto bad; \
 474         GETSHORT(cishort, p); \
 475         if (cishort != val) \
 476             goto bad; \
 477     }
 478
 479 #define ACKCIIFACEID(opt, neg, val1) \
 480     if (neg) { \
 481         int idlen = CILEN_IFACEID; \
 482         if ((len -= idlen) < 0) \
 483             goto bad; \
 484         GETCHAR(citype, p); \
 485         GETCHAR(cilen, p); \
 486         if (cilen != idlen || \
 487             citype != opt) \
 488             goto bad; \
 489         eui64_get(ifaceid, p); \
 490         if (! eui64_equals(val1, ifaceid)) \
 491             goto bad; \
 492     }
 493
 494     ACKCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid);
 495
 496     ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol);
 497
 498     /*
 499      * If there are any remaining CIs, then this packet is bad.
 500      */
 501     if (len != 0)
 502         goto bad;
 503     return (1);
 504
 505 bad:
 506     IPV6CPDEBUG(("ipv6cp_ackci: received bad Ack!"));
 507     return (0);
 508 }
 509
 510 /*
 511  * ipv6cp_nakci - Peer has sent a NAK for some of our CIs.
 512  * This should not modify any state if the Nak is bad
 513  * or if IPV6CP is in the OPENED state.
 514  *
 515  * Returns:
 516  *      0 - Nak was bad.
 517  *      1 - Nak was good.
 518  */
 519 static int
 520 ipv6cp_nakci(f, p, len)
 521     fsm *f;
 522     u_char *p;
 523     int len;
 524 {
 525     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 526     u_char citype, cilen, *next;
 527     u_short cishort;
 528     eui64_t ifaceid;
 529     ipv6cp_options no;          /* options we've seen Naks for */
 530     ipv6cp_options try;         /* options to request next time */
 531
 532     BZERO(&no, sizeof(no));
 533     try = *go;
 534
 535     /*
 536      * Any Nak'd CIs must be in exactly the same order that we sent.
 537      * Check packet length and CI length at each step.
 538      * If we find any deviations, then this packet is bad.
 539      */
 540 #define NAKCIIFACEID(opt, neg, code) \
 541     if (go->neg && \
 542         len >= (cilen = CILEN_IFACEID) && \
 543         p[1] == cilen && \
 544         p[0] == opt) { \
 545         len -= cilen; \
 546         INCPTR(2, p); \
 547         eui64_get(ifaceid, p); \
 548         no.neg = 1; \
 549         code \
 550     }
 551
 552 #define NAKCIVJ(opt, neg, code) \
 553     if (go->neg && \
 554         ((cilen = p[1]) == CILEN_COMPRESS) && \
 555         len >= cilen && \
 556         p[0] == opt) { \
 557         len -= cilen; \
 558         INCPTR(2, p); \
 559         GETSHORT(cishort, p); \
 560         no.neg = 1; \
 561         code \
 562     }
 563
 564     /*
 565      * Accept the peer's idea of {our,his} interface identifier, if different
 566      * from our idea, only if the accept_{local,remote} flag is set.
 567      */
 568     NAKCIIFACEID(CI_IFACEID, neg_ifaceid,
 569               if (go->accept_local) {
 570                   while (eui64_iszero(ifaceid) ||
 571                          eui64_equals(ifaceid, go->hisid)) /* bad luck */
 572                       eui64_magic(ifaceid);
 573                   try.ourid = ifaceid;
 574                   IPV6CPDEBUG(("local LL address %s", llv6_ntoa(ifaceid)));
 575               }
 576               );
 577
 578 #ifdef IPV6CP_COMP
 579     NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
 580             {
 581                 if (cishort == IPV6CP_COMP) {
 582                     try.vj_protocol = cishort;
 583                 } else {
 584                     try.neg_vj = 0;
 585                 }
 586             }
 587             );
 588 #else
 589     NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
 590             {
 591                 try.neg_vj = 0;
 592             }
 593             );
 594 #endif
 595
 596     /*
 597      * There may be remaining CIs, if the peer is requesting negotiation
 598      * on an option that we didn't include in our request packet.
 599      * If they want to negotiate about interface identifier, we comply.
 600      * If they want us to ask for compression, we refuse.
 601      */
 602     while (len > CILEN_VOID) {
 603         GETCHAR(citype, p);
 604         GETCHAR(cilen, p);
 605         if( (len -= cilen) < 0 )
 606             goto bad;
 607         next = p + cilen - 2;
 608
 609         switch (citype) {
 610         case CI_COMPRESSTYPE:
 611             if (go->neg_vj || no.neg_vj ||
 612                 (cilen != CILEN_COMPRESS))
 613                 goto bad;
 614             no.neg_vj = 1;
 615             break;
 616         case CI_IFACEID:
 617             if (go->neg_ifaceid || no.neg_ifaceid || cilen != CILEN_IFACEID)
 618                 goto bad;
 619             try.neg_ifaceid = 1;
 620             eui64_get(ifaceid, p);
 621             if (go->accept_local) {
 622                 while (eui64_iszero(ifaceid) ||
 623                        eui64_equals(ifaceid, go->hisid)) /* bad luck */
 624                     eui64_magic(ifaceid);
 625                 try.ourid = ifaceid;
 626             }
 627             no.neg_ifaceid = 1;
 628             break;
 629         }
 630         p = next;
 631     }
 632
 633     /* If there is still anything left, this packet is bad. */
 634     if (len != 0)
 635         goto bad;
 636
 637     /*
 638      * OK, the Nak is good.  Now we can update state.
 639      */
 640     if (f->state != OPENED)
 641         *go = try;
 642
 643     return 1;
 644
 645 bad:
 646     IPV6CPDEBUG(("ipv6cp_nakci: received bad Nak!"));
 647     return 0;
 648 }
 649
 650
 651 /*
 652  * ipv6cp_rejci - Reject some of our CIs.
 653  */
 654 static int
 655 ipv6cp_rejci(f, p, len)
 656     fsm *f;
 657     u_char *p;
 658     int len;
 659 {
 660     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 661     u_char cilen;
 662     u_short cishort;
 663     eui64_t ifaceid;
 664     ipv6cp_options try;         /* options to request next time */
 665
 666     try = *go;
 667     /*
 668      * Any Rejected CIs must be in exactly the same order that we sent.
 669      * Check packet length and CI length at each step.
 670      * If we find any deviations, then this packet is bad.
 671      */
 672 #define REJCIIFACEID(opt, neg, val1) \
 673     if (go->neg && \
 674         len >= (cilen = CILEN_IFACEID) && \
 675         p[1] == cilen && \
 676         p[0] == opt) { \
 677         len -= cilen; \
 678         INCPTR(2, p); \
 679         eui64_get(ifaceid, p); \
 680         /* Check rejected value. */ \
 681         if (! eui64_equals(ifaceid, val1)) \
 682             goto bad; \
 683         try.neg = 0; \
 684     }
 685
 686 #define REJCIVJ(opt, neg, val) \
 687     if (go->neg && \
 688         p[1] == CILEN_COMPRESS && \
 689         len >= p[1] && \
 690         p[0] == opt) { \
 691         len -= p[1]; \
 692         INCPTR(2, p); \
 693         GETSHORT(cishort, p); \
 694         /* Check rejected value. */  \
 695         if (cishort != val) \
 696             goto bad; \
 697         try.neg = 0; \
 698      }
 699
 700     REJCIIFACEID(CI_IFACEID, neg_ifaceid, go->ourid);
 701
 702     REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol);
 703
 704     /*
 705      * If there are any remaining CIs, then this packet is bad.
 706      */
 707     if (len != 0)
 708         goto bad;
 709     /*
 710      * Now we can update state.
 711      */
 712     if (f->state != OPENED)
 713         *go = try;
 714     return 1;
 715
 716 bad:
 717     IPV6CPDEBUG(("ipv6cp_rejci: received bad Reject!"));
 718     return 0;
 719 }
 720
 721
 722 /*
 723  * ipv6cp_reqci - Check the peer's requested CIs and send appropriate response.
 724  *
 725  * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
 726  * appropriately.  If reject_if_disagree is non-zero, doesn't return
 727  * CONFNAK; returns CONFREJ if it can't return CONFACK.
 728  */
 729 static int
 730 ipv6cp_reqci(f, inp, len, reject_if_disagree)
 731     fsm *f;
 732     u_char *inp;                /* Requested CIs */
 733     int *len;                   /* Length of requested CIs */
 734     int reject_if_disagree;
 735 {
 736     ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
 737     ipv6cp_options *ho = &ipv6cp_hisoptions[f->unit];
 738     ipv6cp_options *ao = &ipv6cp_allowoptions[f->unit];
 739     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 740     u_char *cip, *next;         /* Pointer to current and next CIs */
 741     u_short cilen, citype;      /* Parsed len, type */
 742     u_short cishort;            /* Parsed short value */
 743     eui64_t ifaceid;            /* Parsed interface identifier */
 744     int rc = CONFACK;           /* Final packet return code */
 745     int orc;                    /* Individual option return code */
 746     u_char *p;                  /* Pointer to next char to parse */
 747     u_char *ucp = inp;          /* Pointer to current output char */
 748     int l = *len;               /* Length left */
 749
 750     /*
 751      * Reset all his options.
 752      */
 753     BZERO(ho, sizeof(*ho));
 754
 755     /*
 756      * Process all his options.
 757      */
 758     next = inp;
 759     while (l) {
 760         orc = CONFACK;                  /* Assume success */
 761         cip = p = next;                 /* Remember begining of CI */
 762         if (l < 2 ||                    /* Not enough data for CI header or */
 763             p[1] < 2 ||                 /*  CI length too small or */
 764             p[1] > l) {                 /*  CI length too big? */
 765             IPV6CPDEBUG(("ipv6cp_reqci: bad CI length!"));
 766             orc = CONFREJ;              /* Reject bad CI */
 767             cilen = l;                  /* Reject till end of packet */
 768             l = 0;                      /* Don't loop again */
 769             goto endswitch;
 770         }
 771         GETCHAR(citype, p);             /* Parse CI type */
 772         GETCHAR(cilen, p);              /* Parse CI length */
 773         l -= cilen;                     /* Adjust remaining length */
 774         next += cilen;                  /* Step to next CI */
 775
 776         switch (citype) {               /* Check CI type */
 777         case CI_IFACEID:
 778             IPV6CPDEBUG(("ipv6cp: received interface identifier "));
 779
 780             if (!ao->neg_ifaceid ||
 781                 cilen != CILEN_IFACEID) {       /* Check CI length */
 782                 orc = CONFREJ;          /* Reject CI */
 783                 break;
 784             }
 785
 786             /*
 787              * If he has no interface identifier, or if we both have same
 788              * identifier then NAK it with new idea.
 789              * In particular, if we don't know his identifier, but he does,
 790              * then accept it.
 791              */
 792             eui64_get(ifaceid, p);
 793             IPV6CPDEBUG(("(%s)", llv6_ntoa(ifaceid)));
 794             if (eui64_iszero(ifaceid) && eui64_iszero(go->ourid)) {
 795                 orc = CONFREJ;          /* Reject CI */
 796                 break;
 797             }
 798             if (!eui64_iszero(wo->hisid) &&
 799                 !eui64_equals(ifaceid, wo->hisid) &&
 800                 eui64_iszero(go->hisid)) {
 801
 802                 orc = CONFNAK;
 803                 ifaceid = wo->hisid;
 804                 go->hisid = ifaceid;
 805                 DECPTR(sizeof(ifaceid), p);
 806                 eui64_put(ifaceid, p);
 807             } else
 808             if (eui64_iszero(ifaceid) || eui64_equals(ifaceid, go->ourid)) {
 809                 orc = CONFNAK;
 810                 if (eui64_iszero(go->hisid))    /* first time, try option */
 811                     ifaceid = wo->hisid;
 812                 while (eui64_iszero(ifaceid) ||
 813                        eui64_equals(ifaceid, go->ourid)) /* bad luck */
 814                     eui64_magic(ifaceid);
 815                 go->hisid = ifaceid;
 816                 DECPTR(sizeof(ifaceid), p);
 817                 eui64_put(ifaceid, p);
 818             }
 819
 820             ho->neg_ifaceid = 1;
 821             ho->hisid = ifaceid;
 822             break;
 823
 824         case CI_COMPRESSTYPE:
 825             IPV6CPDEBUG(("ipv6cp: received COMPRESSTYPE "));
 826             if (!ao->neg_vj ||
 827                 (cilen != CILEN_COMPRESS)) {
 828                 orc = CONFREJ;
 829                 break;
 830             }
 831             GETSHORT(cishort, p);
 832             IPV6CPDEBUG(("(%d)", cishort));
 833
 834 #ifdef IPV6CP_COMP
 835             if (!(cishort == IPV6CP_COMP)) {
 836                 orc = CONFREJ;
 837                 break;
 838             }
 839 #else
 840             orc = CONFREJ;
 841             break;
 842 #endif
 843
 844             ho->neg_vj = 1;
 845             ho->vj_protocol = cishort;
 846             break;
 847
 848         default:
 849             orc = CONFREJ;
 850             break;
 851         }
 852
 853 endswitch:
 854         IPV6CPDEBUG((" (%s)\n", CODENAME(orc)));
 855
 856         if (orc == CONFACK &&           /* Good CI */
 857             rc != CONFACK)              /*  but prior CI wasnt? */
 858             continue;                   /* Don't send this one */
 859
 860         if (orc == CONFNAK) {           /* Nak this CI? */
 861             if (reject_if_disagree)     /* Getting fed up with sending NAKs? */
 862                 orc = CONFREJ;          /* Get tough if so */
 863             else {
 864                 if (rc == CONFREJ)      /* Rejecting prior CI? */
 865                     continue;           /* Don't send this one */
 866                 if (rc == CONFACK) {    /* Ack'd all prior CIs? */
 867                     rc = CONFNAK;       /* Not anymore... */
 868                     ucp = inp;          /* Backup */
 869                 }
 870             }
 871         }
 872
 873         if (orc == CONFREJ &&           /* Reject this CI */
 874             rc != CONFREJ) {            /*  but no prior ones? */
 875             rc = CONFREJ;
 876             ucp = inp;                  /* Backup */
 877         }
 878
 879         /* Need to move CI? */
 880         if (ucp != cip)
 881             BCOPY(cip, ucp, cilen);     /* Move it */
 882
 883         /* Update output pointer */
 884         INCPTR(cilen, ucp);
 885     }
 886
 887     /*
 888      * If we aren't rejecting this packet, and we want to negotiate
 889      * their identifier and they didn't send their identifier, then we
 890      * send a NAK with a CI_IFACEID option appended.  We assume the
 891      * input buffer is long enough that we can append the extra
 892      * option safely.
 893      */
 894     if (rc != CONFREJ && !ho->neg_ifaceid &&
 895         wo->req_ifaceid && !reject_if_disagree) {
 896         if (rc == CONFACK) {
 897             rc = CONFNAK;
 898             ucp = inp;                          /* reset pointer */
 899             wo->req_ifaceid = 0;                /* don't ask again */
 900         }
 901         PUTCHAR(CI_IFACEID, ucp);
 902         PUTCHAR(CILEN_IFACEID, ucp);
 903         eui64_put(wo->hisid, ucp);
 904     }
 905
 906     *len = ucp - inp;                   /* Compute output length */
 907     IPV6CPDEBUG(("ipv6cp: returning Configure-%s", CODENAME(rc)));
 908     return (rc);                        /* Return final code */
 909 }
 910
 911
 912 /*
 913  * ipv6_check_options - check that any IP-related options are OK,
 914  * and assign appropriate defaults.
 915  */
 916 static void
 917 ipv6_check_options()
 918 {
 919     ipv6cp_options *wo = &ipv6cp_wantoptions[0];
 920
 921     if (!wo->opt_local) {       /* init interface identifier */
 922         if (wo->use_ip && eui64_iszero(wo->ourid)) {
 923             eui64_setlo32(wo->ourid, ntohl(ipcp_wantoptions[0].ouraddr));
 924             if (!eui64_iszero(wo->ourid))
 925                 wo->opt_local = 1;
 926         }
 927
 928         while (eui64_iszero(wo->ourid))
 929             eui64_magic(wo->ourid);
 930     }
 931
 932     if (!wo->opt_remote) {
 933         if (wo->use_ip && eui64_iszero(wo->hisid)) {
 934             eui64_setlo32(wo->hisid, ntohl(ipcp_wantoptions[0].hisaddr));
 935             if (!eui64_iszero(wo->hisid))
 936                 wo->opt_remote = 1;
 937         }
 938     }
 939
 940     if (demand && (eui64_iszero(wo->ourid) || eui64_iszero(wo->hisid))) {
 941         option_error("local/remote LL address required for demand-dialling\n");
 942         exit(1);
 943     }
 944 }
 945
 946
 947 /*
 948  * ipv6_demand_conf - configure the interface as though
 949  * IPV6CP were up, for use with dial-on-demand.
 950  */
 951 static int
 952 ipv6_demand_conf(u)
 953     int u;
 954 {
 955     ipv6cp_options *wo = &ipv6cp_wantoptions[u];
 956
 957 #if defined(__linux__) || (defined(SVR4) && (defined(SNI) || defined(__USLC__)))
 958     if (!sifup(u, PPP_IPV6))
 959         return 0;
 960 #endif
 961     if (!sif6addr(u, wo->ourid, wo->hisid))
 962         return 0;
 963 #if !defined(__linux__) && !(defined(SVR4) && (defined(SNI) || defined(__USLC__)))
 964     if (!sifup(u, PPP_IPV6))
 965         return 0;
 966 #endif
 967     if (!sifnpmode(u, PPP_IPV6, NPMODE_QUEUE))
 968         return 0;
 969
 970     notice("ipv6_demand_conf");
 971     notice("local  LL address %s", llv6_ntoa(wo->ourid));
 972     notice("remote LL address %s", llv6_ntoa(wo->hisid));
 973
 974     return 1;
 975 }
 976
 977
 978 /*
 979  * ipv6cp_up - IPV6CP has come UP.
 980  *
 981  * Configure the IPv6 network interface appropriately and bring it up.
 982  */
 983 static void
 984 ipv6cp_up(f)
 985     fsm *f;
 986 {
 987     ipv6cp_options *ho = &ipv6cp_hisoptions[f->unit];
 988     ipv6cp_options *go = &ipv6cp_gotoptions[f->unit];
 989     ipv6cp_options *wo = &ipv6cp_wantoptions[f->unit];
 990
 991     IPV6CPDEBUG(("ipv6cp: up"));
 992
 993     /*
 994      * We must have a non-zero LL address for both ends of the link.
 995      */
 996     if (!ho->neg_ifaceid)
 997         ho->hisid = wo->hisid;
 998
 999     if(!no_ifaceid_neg) {
1000         if (eui64_iszero(ho->hisid)) {
1001             error("Could not determine remote LL address");
1002             ipv6cp_close(f->unit, "Could not determine remote LL address");
1003             return;
1004         }
1005         if (eui64_iszero(go->ourid)) {
1006             error("Could not determine local LL address");
1007             ipv6cp_close(f->unit, "Could not determine local LL address");
1008             return;
1009         }
1010         if (eui64_equals(go->ourid, ho->hisid)) {
1011             error("local and remote LL addresses are equal");
1012             ipv6cp_close(f->unit, "local and remote LL addresses are equal");
1013             return;
1014         }
1015     }
1016     script_setenv("LLLOCAL", llv6_ntoa(go->ourid));
1017     script_setenv("LLREMOTE", llv6_ntoa(ho->hisid));
1018
1019 #ifdef IPV6CP_COMP
1020     /* set tcp compression */
1021     sif6comp(f->unit, ho->neg_vj);
1022 #endif
1023
1024     /*
1025      * If we are doing dial-on-demand, the interface is already
1026      * configured, so we put out any saved-up packets, then set the
1027      * interface to pass IPv6 packets.
1028      */
1029     if (demand) {
1030         if (! eui64_equals(go->ourid, wo->ourid) ||
1031             ! eui64_equals(ho->hisid, wo->hisid)) {
1032             if (! eui64_equals(go->ourid, wo->ourid))
1033                 warn("Local LL address changed to %s",
1034                      llv6_ntoa(go->ourid));
1035             if (! eui64_equals(ho->hisid, wo->hisid))
1036                 warn("Remote LL address changed to %s",
1037                      llv6_ntoa(ho->hisid));
1038             ipv6cp_clear_addrs(f->unit);
1039
1040             /* Set the interface to the new addresses */
1041             if (!sif6addr(f->unit, go->ourid, ho->hisid)) {
1042                 if (debug)
1043                     warn("sif6addr failed");
1044                 ipv6cp_close(f->unit, "Interface configuration failed");
1045                 return;
1046             }
1047
1048         }
1049         demand_rexmit(PPP_IPV6);
1050         sifnpmode(f->unit, PPP_IPV6, NPMODE_PASS);
1051
1052     } else {
1053         /*
1054          * Set LL addresses
1055          */
1056 #if !defined(__linux__) && !(defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1057         if (!sif6addr(f->unit, go->ourid, ho->hisid)) {
1058             if (debug)
1059                 warn("sif6addr failed");
1060             ipv6cp_close(f->unit, "Interface configuration failed");
1061             return;
1062         }
1063 #endif
1064
1065         /* bring the interface up for IPv6 */
1066         if (!sifup(f->unit, PPP_IPV6)) {
1067             if (debug)
1068                 warn("sif6up failed");
1069             ipv6cp_close(f->unit, "Interface configuration failed");
1070             return;
1071         }
1072
1073 #if defined(__linux__) || (defined(SVR4) && (defined(SNI) || defined(__USLC__)))
1074         if (!sif6addr(f->unit, go->ourid, ho->hisid)) {
1075             if (debug)
1076                 warn("sif6addr failed");
1077             ipv6cp_close(f->unit, "Interface configuration failed");
1078             return;
1079         }
1080 #endif
1081         sifnpmode(f->unit, PPP_IPV6, NPMODE_PASS);
1082
1083         notice("local  LL address %s", llv6_ntoa(go->ourid));
1084         notice("remote LL address %s", llv6_ntoa(ho->hisid));
1085     }
1086
1087     np_up(f->unit, PPP_IPV6);
1088     ipv6cp_is_up = 1;
1089
1090     /*
1091      * Execute the ipv6-up script, like this:
1092      *  /etc/ppp/ipv6-up interface tty speed local-LL remote-LL
1093      */
1094     if (ipv6cp_script_state == s_down && ipv6cp_script_pid == 0) {
1095         ipv6cp_script_state = s_up;
1096         ipv6cp_script(_PATH_IPV6UP);
1097     }
1098 }
1099
1100
1101 /*
1102  * ipv6cp_down - IPV6CP has gone DOWN.
1103  *
1104  * Take the IPv6 network interface down, clear its addresses
1105  * and delete routes through it.
1106  */
1107 static void
1108 ipv6cp_down(f)
1109     fsm *f;
1110 {
1111     IPV6CPDEBUG(("ipv6cp: down"));
1112     update_link_stats(f->unit);
1113     if (ipv6cp_is_up) {
1114         ipv6cp_is_up = 0;
1115         np_down(f->unit, PPP_IPV6);
1116     }
1117 #ifdef IPV6CP_COMP
1118     sif6comp(f->unit, 0);
1119 #endif
1120
1121     /*
1122      * If we are doing dial-on-demand, set the interface
1123      * to queue up outgoing packets (for now).
1124      */
1125     if (demand) {
1126         sifnpmode(f->unit, PPP_IPV6, NPMODE_QUEUE);
1127     } else {
1128 #if !defined(__linux__) && !(defined(SVR4) && (defined(SNI) || defined(__USLC)))
1129         sifdown(f->unit, PPP_IPV6);
1130 #endif
1131         ipv6cp_clear_addrs(f->unit);
1132 #if defined(__linux__) || (defined(SVR4) && (defined(SNI) || defined(__USLC)))
1133         sifdown(f->unit, PPP_IPV6);
1134 #endif
1135     }
1136
1137     /* Execute the ipv6-down script */
1138     if (ipv6cp_script_state == s_up && ipv6cp_script_pid == 0) {
1139         ipv6cp_script_state = s_down;
1140         ipv6cp_script(_PATH_IPV6DOWN);
1141     }
1142 }
1143
1144
1145 /*
1146  * ipv6cp_clear_addrs() - clear the interface addresses, routes,
1147  * proxy arp entries, etc.
1148  */
1149 static void
1150 ipv6cp_clear_addrs(unit)
1151     int unit;
1152 {
1153     eui64_t ourid, hisid;
1154
1155     ourid = ipv6cp_gotoptions[unit].ourid;
1156     hisid = ipv6cp_hisoptions[unit].hisid;
1157     cif6addr(unit, ourid, hisid);
1158 }
1159
1160
1161 /*
1162  * ipv6cp_finished - possibly shut down the lower layers.
1163  */
1164 static void
1165 ipv6cp_finished(f)
1166     fsm *f;
1167 {
1168     np_finished(f->unit, PPP_IPV6);
1169 }
1170
1171
1172 /*
1173  * ipv6cp_script_done - called when the ipv6-up or ipv6-down script
1174  * has finished.
1175  */
1176 static void
1177 ipv6cp_script_done(arg)
1178     void *arg;
1179 {
1180     ipv6cp_script_pid = 0;
1181     switch (ipv6cp_script_state) {
1182     case s_up:
1183         if (ipv6cp_fsm[0].state != OPENED) {
1184             ipv6cp_script_state = s_down;
1185             ipv6cp_script(_PATH_IPV6DOWN);
1186         }
1187         break;
1188     case s_down:
1189         if (ipv6cp_fsm[0].state == OPENED) {
1190             ipv6cp_script_state = s_up;
1191             ipv6cp_script(_PATH_IPV6UP);
1192         }
1193         break;
1194     }
1195 }
1196
1197
1198 /*
1199  * ipv6cp_script - Execute a script with arguments
1200  * interface-name tty-name speed local-LL remote-LL.
1201  */
1202 static void
1203 ipv6cp_script(script)
1204     char *script;
1205 {
1206     char strspeed[32], strlocal[32], strremote[32];
1207     char *argv[8];
1208
1209     sprintf(strspeed, "%d", baud_rate);
1210     strcpy(strlocal, llv6_ntoa(ipv6cp_gotoptions[0].ourid));
1211     strcpy(strremote, llv6_ntoa(ipv6cp_hisoptions[0].hisid));
1212
1213     argv[0] = script;
1214     argv[1] = ifname;
1215     argv[2] = devnam;
1216     argv[3] = strspeed;
1217     argv[4] = strlocal;
1218     argv[5] = strremote;
1219     argv[6] = ipparam;
1220     argv[7] = NULL;
1221
1222     ipv6cp_script_pid = run_program(script, argv, 0, ipv6cp_script_done, NULL);
1223 }
1224
1225 /*
1226  * ipv6cp_printpkt - print the contents of an IPV6CP packet.
1227  */
1228 static char *ipv6cp_codenames[] = {
1229     "ConfReq", "ConfAck", "ConfNak", "ConfRej",
1230     "TermReq", "TermAck", "CodeRej"
1231 };
1232
1233 static int
1234 ipv6cp_printpkt(p, plen, printer, arg)
1235     u_char *p;
1236     int plen;
1237     void (*printer) __P((void *, char *, ...));
1238     void *arg;
1239 {
1240     int code, id, len, olen;
1241     u_char *pstart, *optend;
1242     u_short cishort;
1243     eui64_t ifaceid;
1244
1245     if (plen < HEADERLEN)
1246         return 0;
1247     pstart = p;
1248     GETCHAR(code, p);
1249     GETCHAR(id, p);
1250     GETSHORT(len, p);
1251     if (len < HEADERLEN || len > plen)
1252         return 0;
1253
1254     if (code >= 1 && code <= sizeof(ipv6cp_codenames) / sizeof(char *))
1255         printer(arg, " %s", ipv6cp_codenames[code-1]);
1256     else
1257         printer(arg, " code=0x%x", code);
1258     printer(arg, " id=0x%x", id);
1259     len -= HEADERLEN;
1260     switch (code) {
1261     case CONFREQ:
1262     case CONFACK:
1263     case CONFNAK:
1264     case CONFREJ:
1265         /* print option list */
1266         while (len >= 2) {
1267             GETCHAR(code, p);
1268             GETCHAR(olen, p);
1269             p -= 2;
1270             if (olen < 2 || olen > len) {
1271                 break;
1272             }
1273             printer(arg, " <");
1274             len -= olen;
1275             optend = p + olen;
1276             switch (code) {
1277             case CI_COMPRESSTYPE:
1278                 if (olen >= CILEN_COMPRESS) {
1279                     p += 2;
1280                     GETSHORT(cishort, p);
1281                     printer(arg, "compress ");
1282                     printer(arg, "0x%x", cishort);
1283                 }
1284                 break;
1285             case CI_IFACEID:
1286                 if (olen == CILEN_IFACEID) {
1287                     p += 2;
1288                     eui64_get(ifaceid, p);
1289                     printer(arg, "addr %s", llv6_ntoa(ifaceid));
1290                 }
1291                 break;
1292             }
1293             while (p < optend) {
1294                 GETCHAR(code, p);
1295                 printer(arg, " %.2x", code);
1296             }
1297             printer(arg, ">");
1298         }
1299         break;
1300
1301     case TERMACK:
1302     case TERMREQ:
1303         if (len > 0 && *p >= ' ' && *p < 0x7f) {
1304             printer(arg, " ");
1305             print_string(p, len, printer, arg);
1306             p += len;
1307             len = 0;
1308         }
1309         break;
1310     }
1311
1312     /* print the rest of the bytes in the packet */
1313     for (; len > 0; --len) {
1314         GETCHAR(code, p);
1315         printer(arg, " %.2x", code);
1316     }
1317
1318     return p - pstart;
1319 }
1320
1321 /*
1322  * ipv6_active_pkt - see if this IP packet is worth bringing the link up for.
1323  * We don't bring the link up for IP fragments or for TCP FIN packets
1324  * with no data.
1325  */
1326 #define IP6_HDRLEN      40      /* bytes */
1327 #define IP6_NHDR_FRAG   44      /* fragment IPv6 header */
1328 #define IPPROTO_TCP     6
1329 #define TCP_HDRLEN      20
1330 #define TH_FIN          0x01
1331
1332 /*
1333  * We use these macros because the IP header may be at an odd address,
1334  * and some compilers might use word loads to get th_off or ip_hl.
1335  */
1336
1337 #define get_ip6nh(x)    (((unsigned char *)(x))[6])
1338 #define get_tcpoff(x)   (((unsigned char *)(x))[12] >> 4)
1339 #define get_tcpflags(x) (((unsigned char *)(x))[13])
1340
1341 static int
1342 ipv6_active_pkt(pkt, len)
1343     u_char *pkt;
1344     int len;
1345 {
1346     u_char *tcp;
1347
1348     len -= PPP_HDRLEN;
1349     pkt += PPP_HDRLEN;
1350     if (len < IP6_HDRLEN)
1351         return 0;
1352     if (get_ip6nh(pkt) == IP6_NHDR_FRAG)
1353         return 0;
1354     if (get_ip6nh(pkt) != IPPROTO_TCP)
1355         return 1;
1356     if (len < IP6_HDRLEN + TCP_HDRLEN)
1357         return 0;
1358     tcp = pkt + IP6_HDRLEN;
1359     if ((get_tcpflags(tcp) & TH_FIN) != 0 && len == IP6_HDRLEN + get_tcpoff(tcp) * 4)
1360         return 0;
1361     return 1;
1362 }