1/*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 1998 Brian Somers <brian@Awfulhak.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29#include <sys/param.h> 30#include <sys/socket.h> 31#include <netinet/in.h> 32#include <net/if.h> 33#include <net/if_tun.h> /* For TUNS* ioctls */ 34#include <net/route.h> 35#include <netinet/in_systm.h> 36#include <netinet/ip.h> 37#include <sys/un.h> 38 39#include <errno.h> 40#include <fcntl.h> 41#ifdef __OpenBSD__ 42#include <util.h> 43#else 44#include <libutil.h> 45#endif 46#include <paths.h> 47#include <stdarg.h> 48#include <stdio.h> 49#include <stdlib.h> 50#include <string.h> 51#include <sys/uio.h> 52#include <sys/wait.h> 53#include <termios.h> 54#include <unistd.h> 55 56#include "layer.h" 57#include "defs.h" 58#include "command.h" 59#include "mbuf.h" 60#include "log.h" 61#include "id.h" 62#include "timer.h" 63#include "fsm.h" 64#include "iplist.h" 65#include "lqr.h" 66#include "hdlc.h" 67#include "throughput.h" 68#include "slcompress.h" 69#include "ncpaddr.h" 70#include "ip.h" 71#include "ipcp.h" 72#include "filter.h" 73#include "descriptor.h" 74#include "route.h" 75#include "lcp.h" 76#include "ccp.h" 77#include "link.h" 78#include "mp.h" 79#ifndef NORADIUS 80#include "radius.h" 81#endif 82#include "ipv6cp.h" 83#include "ncp.h" 84#include "bundle.h" 85#include "async.h" 86#include "physical.h" 87#include "auth.h" 88#include "proto.h" 89#include "chap.h" 90#include "tun.h" 91#include "prompt.h" 92#include "chat.h" 93#include "cbcp.h" 94#include "datalink.h" 95#include "iface.h" 96#include "server.h" 97#include "probe.h" 98#ifndef NODES 99#include "mppe.h" 100#endif 101 102#define SCATTER_SEGMENTS 7 /* version, datalink, name, physical, 103 throughput, throughput, device */ 104 105#define SEND_MAXFD 3 /* Max file descriptors passed through 106 the local domain socket */ 107 108static int bundle_RemainingIdleTime(struct bundle *); 109 110static const char * const PhaseNames[] = { 111 "Dead", "Establish", "Authenticate", "Network", "Terminate" 112}; 113 114const char * 115bundle_PhaseName(struct bundle *bundle) 116{ 117 return bundle->phase <= PHASE_TERMINATE ? 118 PhaseNames[bundle->phase] : "unknown"; 119} 120 121void 122bundle_NewPhase(struct bundle *bundle, u_int new) 123{ 124 if (new == bundle->phase) 125 return; 126 127 if (new <= PHASE_TERMINATE) 128 log_Printf(LogPHASE, "bundle: %s\n", PhaseNames[new]); 129 130 switch (new) { 131 case PHASE_DEAD: 132 bundle->phase = new; 133#ifndef NODES 134 MPPE_MasterKeyValid = 0; 135#endif 136 log_DisplayPrompts(); 137 break; 138 139 case PHASE_ESTABLISH: 140 bundle->phase = new; 141 break; 142 143 case PHASE_AUTHENTICATE: 144 bundle->phase = new; 145 log_DisplayPrompts(); 146 break; 147 148 case PHASE_NETWORK: 149 if (ncp_fsmStart(&bundle->ncp, bundle)) { 150 bundle->phase = new; 151 log_DisplayPrompts(); 152 } else { 153 log_Printf(LogPHASE, "bundle: All NCPs are disabled\n"); 154 bundle_Close(bundle, NULL, CLOSE_STAYDOWN); 155 } 156 break; 157 158 case PHASE_TERMINATE: 159 bundle->phase = new; 160 mp_Down(&bundle->ncp.mp); 161 log_DisplayPrompts(); 162 break; 163 } 164} 165 166static void 167bundle_LayerStart(void *v __unused, struct fsm *fp __unused) 168{ 169 /* The given FSM is about to start up ! */ 170} 171 172 173void 174bundle_Notify(struct bundle *bundle, char c) 175{ 176 if (bundle->notify.fd != -1) { 177 int ret; 178 179 ret = write(bundle->notify.fd, &c, 1); 180 if (c != EX_REDIAL && c != EX_RECONNECT) { 181 if (ret == 1) 182 log_Printf(LogCHAT, "Parent notified of %s\n", 183 c == EX_NORMAL ? "success" : "failure"); 184 else 185 log_Printf(LogERROR, "Failed to notify parent of success\n"); 186 close(bundle->notify.fd); 187 bundle->notify.fd = -1; 188 } else if (ret == 1) 189 log_Printf(LogCHAT, "Parent notified of %s\n", ex_desc(c)); 190 else 191 log_Printf(LogERROR, "Failed to notify parent of %s\n", ex_desc(c)); 192 } 193} 194 195static void 196bundle_ClearQueues(void *v) 197{ 198 struct bundle *bundle = (struct bundle *)v; 199 struct datalink *dl; 200 201 log_Printf(LogPHASE, "Clearing choked output queue\n"); 202 timer_Stop(&bundle->choked.timer); 203 204 /* 205 * Emergency time: 206 * 207 * We've had a full queue for PACKET_DEL_SECS seconds without being 208 * able to get rid of any of the packets. We've probably given up 209 * on the redials at this point, and the queued data has almost 210 * definitely been timed out by the layer above. As this is preventing 211 * us from reading the TUN_NAME device (we don't want to buffer stuff 212 * indefinitely), we may as well nuke this data and start with a clean 213 * slate ! 214 * 215 * Unfortunately, this has the side effect of shafting any compression 216 * dictionaries in use (causing the relevant RESET_REQ/RESET_ACK). 217 */ 218 219 ncp_DeleteQueues(&bundle->ncp); 220 for (dl = bundle->links; dl; dl = dl->next) 221 physical_DeleteQueue(dl->physical); 222} 223 224static void 225bundle_LinkAdded(struct bundle *bundle, struct datalink *dl) 226{ 227 bundle->phys_type.all |= dl->physical->type; 228 if (dl->state == DATALINK_OPEN) 229 bundle->phys_type.open |= dl->physical->type; 230 231#ifndef NORADIUS 232 if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) 233 != bundle->phys_type.open && bundle->session.timer.state == TIMER_STOPPED) 234 if (bundle->radius.sessiontime) 235 bundle_StartSessionTimer(bundle, 0); 236#endif 237 238 if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) 239 != bundle->phys_type.open && bundle->idle.timer.state == TIMER_STOPPED) 240 /* We may need to start our idle timer */ 241 bundle_StartIdleTimer(bundle, 0); 242} 243 244void 245bundle_LinksRemoved(struct bundle *bundle) 246{ 247 struct datalink *dl; 248 249 bundle->phys_type.all = bundle->phys_type.open = 0; 250 for (dl = bundle->links; dl; dl = dl->next) 251 bundle_LinkAdded(bundle, dl); 252 253 bundle_CalculateBandwidth(bundle); 254 mp_CheckAutoloadTimer(&bundle->ncp.mp); 255 256 if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) 257 == bundle->phys_type.open) { 258#ifndef NORADIUS 259 if (bundle->radius.sessiontime) 260 bundle_StopSessionTimer(bundle); 261#endif 262 bundle_StopIdleTimer(bundle); 263 } 264} 265 266static void 267bundle_LayerUp(void *v, struct fsm *fp) 268{ 269 /* 270 * The given fsm is now up 271 * If it's an LCP, adjust our phys_mode.open value and check the 272 * autoload timer. 273 * If it's the first NCP, calculate our bandwidth 274 * If it's the first NCP, set our ``upat'' time 275 * If it's the first NCP, start the idle timer. 276 * If it's an NCP, tell our -background parent to go away. 277 * If it's the first NCP, start the autoload timer 278 */ 279 struct bundle *bundle = (struct bundle *)v; 280 281 if (fp->proto == PROTO_LCP) { 282 struct physical *p = link2physical(fp->link); 283 284 bundle_LinkAdded(bundle, p->dl); 285 mp_CheckAutoloadTimer(&bundle->ncp.mp); 286 } else if (isncp(fp->proto)) { 287 if (ncp_LayersOpen(&fp->bundle->ncp) == 1) { 288 bundle_CalculateBandwidth(fp->bundle); 289 time(&bundle->upat); 290#ifndef NORADIUS 291 if (bundle->radius.sessiontime) 292 bundle_StartSessionTimer(bundle, 0); 293#endif 294 bundle_StartIdleTimer(bundle, 0); 295 mp_CheckAutoloadTimer(&fp->bundle->ncp.mp); 296 } 297 bundle_Notify(bundle, EX_NORMAL); 298 } else if (fp->proto == PROTO_CCP) 299 bundle_CalculateBandwidth(fp->bundle); /* Against ccp_MTUOverhead */ 300} 301 302static void 303bundle_LayerDown(void *v, struct fsm *fp) 304{ 305 /* 306 * The given FSM has been told to come down. 307 * If it's our last NCP, stop the idle timer. 308 * If it's our last NCP, clear our ``upat'' value. 309 * If it's our last NCP, stop the autoload timer 310 * If it's an LCP, adjust our phys_type.open value and any timers. 311 * If it's an LCP and we're in multilink mode, adjust our tun 312 * If it's the last LCP, down all NCPs 313 * speed and make sure our minimum sequence number is adjusted. 314 */ 315 316 struct bundle *bundle = (struct bundle *)v; 317 318 if (isncp(fp->proto)) { 319 if (ncp_LayersOpen(&fp->bundle->ncp) == 0) { 320#ifndef NORADIUS 321 if (bundle->radius.sessiontime) 322 bundle_StopSessionTimer(bundle); 323#endif 324 bundle_StopIdleTimer(bundle); 325 bundle->upat = 0; 326 mp_StopAutoloadTimer(&bundle->ncp.mp); 327 } 328 } else if (fp->proto == PROTO_LCP) { 329 struct datalink *dl; 330 struct datalink *lost; 331 int others_active; 332 333 bundle_LinksRemoved(bundle); /* adjust timers & phys_type values */ 334 335 lost = NULL; 336 others_active = 0; 337 for (dl = bundle->links; dl; dl = dl->next) { 338 if (fp == &dl->physical->link.lcp.fsm) 339 lost = dl; 340 else if (dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP) 341 others_active++; 342 } 343 344 if (bundle->ncp.mp.active) { 345 bundle_CalculateBandwidth(bundle); 346 347 if (lost) 348 mp_LinkLost(&bundle->ncp.mp, lost); 349 else 350 log_Printf(LogALERT, "Oops, lost an unrecognised datalink (%s) !\n", 351 fp->link->name); 352 } 353 354 if (!others_active) { 355 /* Down the NCPs. We don't expect to get fsm_Close()d ourself ! */ 356 ncp2initial(&bundle->ncp); 357 mp_Down(&bundle->ncp.mp); 358 } 359 } 360} 361 362static void 363bundle_LayerFinish(void *v, struct fsm *fp) 364{ 365 /* The given fsm is now down (fp cannot be NULL) 366 * 367 * If it's the last NCP, fsm_Close all LCPs 368 * If it's the last NCP, bring any MP layer down 369 */ 370 371 struct bundle *bundle = (struct bundle *)v; 372 struct datalink *dl; 373 374 if (isncp(fp->proto) && !ncp_LayersUnfinished(&bundle->ncp)) { 375 if (bundle_Phase(bundle) != PHASE_DEAD) 376 bundle_NewPhase(bundle, PHASE_TERMINATE); 377 for (dl = bundle->links; dl; dl = dl->next) 378 if (dl->state == DATALINK_OPEN) 379 datalink_Close(dl, CLOSE_STAYDOWN); 380 fsm2initial(fp); 381 mp_Down(&bundle->ncp.mp); 382 } 383} 384 385void 386bundle_Close(struct bundle *bundle, const char *name, int how) 387{ 388 /* 389 * Please close the given datalink. 390 * If name == NULL or name is the last datalink, fsm_Close all NCPs 391 * (except our MP) 392 * If it isn't the last datalink, just Close that datalink. 393 */ 394 395 struct datalink *dl, *this_dl; 396 int others_active; 397 398 others_active = 0; 399 this_dl = NULL; 400 401 for (dl = bundle->links; dl; dl = dl->next) { 402 if (name && !strcasecmp(name, dl->name)) 403 this_dl = dl; 404 if (name == NULL || this_dl == dl) { 405 switch (how) { 406 case CLOSE_LCP: 407 datalink_DontHangup(dl); 408 break; 409 case CLOSE_STAYDOWN: 410 datalink_StayDown(dl); 411 break; 412 } 413 } else if (dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP) 414 others_active++; 415 } 416 417 if (name && this_dl == NULL) { 418 log_Printf(LogWARN, "%s: Invalid datalink name\n", name); 419 return; 420 } 421 422 if (!others_active) { 423#ifndef NORADIUS 424 if (bundle->radius.sessiontime) 425 bundle_StopSessionTimer(bundle); 426#endif 427 bundle_StopIdleTimer(bundle); 428 if (ncp_LayersUnfinished(&bundle->ncp)) 429 ncp_Close(&bundle->ncp); 430 else { 431 ncp2initial(&bundle->ncp); 432 mp_Down(&bundle->ncp.mp); 433 for (dl = bundle->links; dl; dl = dl->next) 434 datalink_Close(dl, how); 435 } 436 } else if (this_dl && this_dl->state != DATALINK_CLOSED && 437 this_dl->state != DATALINK_HANGUP) 438 datalink_Close(this_dl, how); 439} 440 441void 442bundle_Down(struct bundle *bundle, int how) 443{ 444 struct datalink *dl; 445 446 for (dl = bundle->links; dl; dl = dl->next) 447 datalink_Down(dl, how); 448} 449 450static int 451bundle_UpdateSet(struct fdescriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n) 452{ 453 struct bundle *bundle = descriptor2bundle(d); 454 struct datalink *dl; 455 int result, nlinks; 456 u_short ifqueue; 457 size_t queued; 458 459 result = 0; 460 461 /* If there are aren't many packets queued, look for some more. */ 462 for (nlinks = 0, dl = bundle->links; dl; dl = dl->next) 463 nlinks++; 464 465 if (nlinks) { 466 queued = r ? ncp_FillPhysicalQueues(&bundle->ncp, bundle) : 467 ncp_QueueLen(&bundle->ncp); 468 469 if (r && (bundle->phase == PHASE_NETWORK || 470 bundle->phys_type.all & PHYS_AUTO)) { 471 /* enough surplus so that we can tell if we're getting swamped */ 472 ifqueue = nlinks > bundle->cfg.ifqueue ? nlinks : bundle->cfg.ifqueue; 473 if (queued < ifqueue) { 474 /* Not enough - select() for more */ 475 if (bundle->choked.timer.state == TIMER_RUNNING) 476 timer_Stop(&bundle->choked.timer); /* Not needed any more */ 477 FD_SET(bundle->dev.fd, r); 478 if (*n < bundle->dev.fd + 1) 479 *n = bundle->dev.fd + 1; 480 log_Printf(LogTIMER, "%s: fdset(r) %d\n", TUN_NAME, bundle->dev.fd); 481 result++; 482 } else if (bundle->choked.timer.state == TIMER_STOPPED) { 483 bundle->choked.timer.func = bundle_ClearQueues; 484 bundle->choked.timer.name = "output choke"; 485 bundle->choked.timer.load = bundle->cfg.choked.timeout * SECTICKS; 486 bundle->choked.timer.arg = bundle; 487 timer_Start(&bundle->choked.timer); 488 } 489 } 490 } 491 492#ifndef NORADIUS 493 result += descriptor_UpdateSet(&bundle->radius.desc, r, w, e, n); 494#endif 495 496 /* Which links need a select() ? */ 497 for (dl = bundle->links; dl; dl = dl->next) 498 result += descriptor_UpdateSet(&dl->desc, r, w, e, n); 499 500 /* 501 * This *MUST* be called after the datalink UpdateSet()s as it 502 * might be ``holding'' one of the datalinks (death-row) and 503 * wants to be able to de-select() it from the descriptor set. 504 */ 505 result += descriptor_UpdateSet(&bundle->ncp.mp.server.desc, r, w, e, n); 506 507 return result; 508} 509 510static int 511bundle_IsSet(struct fdescriptor *d, const fd_set *fdset) 512{ 513 struct bundle *bundle = descriptor2bundle(d); 514 struct datalink *dl; 515 516 for (dl = bundle->links; dl; dl = dl->next) 517 if (descriptor_IsSet(&dl->desc, fdset)) 518 return 1; 519 520#ifndef NORADIUS 521 if (descriptor_IsSet(&bundle->radius.desc, fdset)) 522 return 1; 523#endif 524 525 if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 526 return 1; 527 528 return FD_ISSET(bundle->dev.fd, fdset); 529} 530 531static void 532bundle_DescriptorRead(struct fdescriptor *d __unused, struct bundle *bundle, 533 const fd_set *fdset) 534{ 535 struct datalink *dl; 536 unsigned secs; 537 u_int32_t af; 538 539 if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 540 descriptor_Read(&bundle->ncp.mp.server.desc, bundle, fdset); 541 542 for (dl = bundle->links; dl; dl = dl->next) 543 if (descriptor_IsSet(&dl->desc, fdset)) 544 descriptor_Read(&dl->desc, bundle, fdset); 545 546#ifndef NORADIUS 547 if (descriptor_IsSet(&bundle->radius.desc, fdset)) 548 descriptor_Read(&bundle->radius.desc, bundle, fdset); 549#endif 550 551 if (FD_ISSET(bundle->dev.fd, fdset)) { 552 struct tun_data tun; 553 int n, pri; 554 u_char *data; 555 size_t sz; 556 557 if (bundle->dev.header) { 558 data = (u_char *)&tun; 559 sz = sizeof tun; 560 } else { 561 data = tun.data; 562 sz = sizeof tun.data; 563 } 564 565 /* something to read from tun */ 566 567 n = read(bundle->dev.fd, data, sz); 568 if (n < 0) { 569 log_Printf(LogWARN, "%s: read: %s\n", bundle->dev.Name, strerror(errno)); 570 return; 571 } 572 573 if (bundle->dev.header) { 574 n -= sz - sizeof tun.data; 575 if (n <= 0) { 576 log_Printf(LogERROR, "%s: read: Got only %d bytes of data !\n", 577 bundle->dev.Name, n); 578 return; 579 } 580 af = ntohl(tun.header.family); 581#ifndef NOINET6 582 if (af != AF_INET && af != AF_INET6) 583#else 584 if (af != AF_INET) 585#endif 586 /* XXX: Should be maintaining drop/family counts ! */ 587 return; 588 } else 589 af = AF_INET; 590 591 if (af == AF_INET && ((struct ip *)tun.data)->ip_dst.s_addr == 592 bundle->ncp.ipcp.my_ip.s_addr) { 593 /* we've been asked to send something addressed *to* us :( */ 594 if (Enabled(bundle, OPT_LOOPBACK)) { 595 pri = PacketCheck(bundle, af, tun.data, n, &bundle->filter.in, 596 NULL, NULL); 597 if (pri >= 0) { 598 n += sz - sizeof tun.data; 599 write(bundle->dev.fd, data, n); 600 log_Printf(LogDEBUG, "Looped back packet addressed to myself\n"); 601 } 602 return; 603 } else 604 log_Printf(LogDEBUG, "Oops - forwarding packet addressed to myself\n"); 605 } 606 607 /* 608 * Process on-demand dialup. Output packets are queued within the tunnel 609 * device until the appropriate NCP is opened. 610 */ 611 612 if (bundle_Phase(bundle) == PHASE_DEAD) { 613 /* 614 * Note, we must be in AUTO mode :-/ otherwise our interface should 615 * *not* be UP and we can't receive data 616 */ 617 pri = PacketCheck(bundle, af, tun.data, n, &bundle->filter.dial, 618 NULL, NULL); 619 if (pri >= 0) 620 bundle_Open(bundle, NULL, PHYS_AUTO, 0); 621 else 622 /* 623 * Drop the packet. If we were to queue it, we'd just end up with 624 * a pile of timed-out data in our output queue by the time we get 625 * around to actually dialing. We'd also prematurely reach the 626 * threshold at which we stop select()ing to read() the tun 627 * device - breaking auto-dial. 628 */ 629 return; 630 } 631 632 secs = 0; 633 pri = PacketCheck(bundle, af, tun.data, n, &bundle->filter.out, 634 NULL, &secs); 635 if (pri >= 0) { 636 /* Prepend the number of seconds timeout given in the filter */ 637 tun.header.timeout = secs; 638 ncp_Enqueue(&bundle->ncp, af, pri, (char *)&tun, n + sizeof tun.header); 639 } 640 } 641} 642 643static int 644bundle_DescriptorWrite(struct fdescriptor *d __unused, struct bundle *bundle, 645 const fd_set *fdset) 646{ 647 struct datalink *dl; 648 int result = 0; 649 650 /* This is not actually necessary as struct mpserver doesn't Write() */ 651 if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 652 if (descriptor_Write(&bundle->ncp.mp.server.desc, bundle, fdset) == 1) 653 result++; 654 655 for (dl = bundle->links; dl; dl = dl->next) 656 if (descriptor_IsSet(&dl->desc, fdset)) 657 switch (descriptor_Write(&dl->desc, bundle, fdset)) { 658 case -1: 659 datalink_ComeDown(dl, CLOSE_NORMAL); 660 break; 661 case 1: 662 result++; 663 } 664 665 return result; 666} 667 668void 669bundle_LockTun(struct bundle *bundle) 670{ 671 FILE *lockfile; 672 char pidfile[PATH_MAX]; 673 674 snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit); 675 lockfile = ID0fopen(pidfile, "w"); 676 if (lockfile != NULL) { 677 fprintf(lockfile, "%d\n", (int)getpid()); 678 fclose(lockfile); 679 } else 680 log_Printf(LogERROR, "Warning: Can't create %s: %s\n", 681 pidfile, strerror(errno)); 682} 683 684static void 685bundle_UnlockTun(struct bundle *bundle) 686{ 687 char pidfile[PATH_MAX]; 688 689 snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit); 690 ID0unlink(pidfile); 691} 692 693struct bundle * 694bundle_Create(const char *prefix, int type, int unit) 695{ 696 static struct bundle bundle; /* there can be only one */ 697 int enoentcount, err, minunit, maxunit; 698 const char *ifname; 699#if defined(__FreeBSD__) && !defined(NOKLDLOAD) 700 int kldtried; 701#endif 702#if defined(TUNSIFMODE) || defined(TUNSLMODE) || defined(TUNSIFHEAD) 703 int iff; 704#endif 705 706 if (bundle.iface != NULL) { /* Already allocated ! */ 707 log_Printf(LogALERT, "bundle_Create: There's only one BUNDLE !\n"); 708 return NULL; 709 } 710 711 if (unit == -1) { 712 minunit = 0; 713 maxunit = -1; 714 } else { 715 minunit = unit; 716 maxunit = unit + 1; 717 } 718 err = ENOENT; 719 enoentcount = 0; 720#if defined(__FreeBSD__) && !defined(NOKLDLOAD) 721 kldtried = 0; 722#endif 723 for (bundle.unit = minunit; bundle.unit != maxunit; bundle.unit++) { 724 snprintf(bundle.dev.Name, sizeof bundle.dev.Name, "%s%d", 725 prefix, bundle.unit); 726 bundle.dev.fd = ID0open(bundle.dev.Name, O_RDWR); 727 if (bundle.dev.fd >= 0) 728 break; 729 else if (errno == ENXIO || errno == ENOENT) { 730#if defined(__FreeBSD__) && !defined(NOKLDLOAD) 731 if (bundle.unit == minunit && !kldtried++) { 732 /* 733 * Attempt to load the tunnel interface KLD if it isn't loaded 734 * already. 735 */ 736 if (loadmodules(LOAD_VERBOSLY, "if_tun", NULL)) 737 bundle.unit--; 738 continue; 739 } 740#endif 741 if (errno != ENOENT || ++enoentcount > 2) { 742 err = errno; 743 break; 744 } 745 } else 746 err = errno; 747 } 748 749 if (bundle.dev.fd < 0) { 750 if (unit == -1) 751 log_Printf(LogWARN, "No available tunnel devices found (%s)\n", 752 strerror(err)); 753 else 754 log_Printf(LogWARN, "%s%d: %s\n", prefix, unit, strerror(err)); 755 return NULL; 756 } 757 758 log_SetTun(bundle.unit, NULL); 759 760 ifname = strrchr(bundle.dev.Name, '/'); 761 if (ifname == NULL) 762 ifname = bundle.dev.Name; 763 else 764 ifname++; 765 766 bundle.iface = iface_Create(ifname); 767 if (bundle.iface == NULL) { 768 close(bundle.dev.fd); 769 return NULL; 770 } 771 772#ifdef TUNSIFMODE 773 /* Make sure we're POINTOPOINT & IFF_MULTICAST */ 774 iff = IFF_POINTOPOINT | IFF_MULTICAST; 775 if (ID0ioctl(bundle.dev.fd, TUNSIFMODE, &iff) < 0) 776 log_Printf(LogERROR, "bundle_Create: ioctl(TUNSIFMODE): %s\n", 777 strerror(errno)); 778#endif 779 780#ifdef TUNSLMODE 781 /* Make sure we're not prepending sockaddrs */ 782 iff = 0; 783 if (ID0ioctl(bundle.dev.fd, TUNSLMODE, &iff) < 0) 784 log_Printf(LogERROR, "bundle_Create: ioctl(TUNSLMODE): %s\n", 785 strerror(errno)); 786#endif 787 788#ifdef TUNSIFHEAD 789 /* We want the address family please ! */ 790 iff = 1; 791 if (ID0ioctl(bundle.dev.fd, TUNSIFHEAD, &iff) < 0) { 792 log_Printf(LogERROR, "bundle_Create: ioctl(TUNSIFHEAD): %s\n", 793 strerror(errno)); 794 bundle.dev.header = 0; 795 } else 796 bundle.dev.header = 1; 797#else 798#ifdef __OpenBSD__ 799 /* Always present for OpenBSD */ 800 bundle.dev.header = 1; 801#else 802 /* 803 * If TUNSIFHEAD isn't available and we're not OpenBSD, assume 804 * everything's AF_INET (hopefully the tun device won't pass us 805 * anything else !). 806 */ 807 bundle.dev.header = 0; 808#endif 809#endif 810 811 log_Printf(LogPHASE, "Using interface: %s\n", ifname); 812 813 bundle.bandwidth = 0; 814 bundle.routing_seq = 0; 815 bundle.phase = PHASE_DEAD; 816 bundle.CleaningUp = 0; 817 bundle.NatEnabled = 0; 818 819 bundle.fsm.LayerStart = bundle_LayerStart; 820 bundle.fsm.LayerUp = bundle_LayerUp; 821 bundle.fsm.LayerDown = bundle_LayerDown; 822 bundle.fsm.LayerFinish = bundle_LayerFinish; 823 bundle.fsm.object = &bundle; 824 825 bundle.cfg.idle.timeout = NCP_IDLE_TIMEOUT; 826 bundle.cfg.idle.min_timeout = 0; 827 *bundle.cfg.auth.name = '\0'; 828 *bundle.cfg.auth.key = '\0'; 829 bundle.cfg.optmask = (1ull << OPT_IDCHECK) | (1ull << OPT_LOOPBACK) | 830 (1ull << OPT_SROUTES) | (1ull << OPT_TCPMSSFIXUP) | 831 (1ull << OPT_THROUGHPUT) | (1ull << OPT_UTMP) | 832 (1ull << OPT_NAS_IP_ADDRESS) | 833 (1ull << OPT_NAS_IDENTIFIER); 834#ifndef NOINET6 835 opt_enable(&bundle, OPT_IPCP); 836 if (probe.ipv6_available) 837 opt_enable(&bundle, OPT_IPV6CP); 838#endif 839 *bundle.cfg.label = '\0'; 840 bundle.cfg.ifqueue = DEF_IFQUEUE; 841 bundle.cfg.choked.timeout = CHOKED_TIMEOUT; 842 bundle.phys_type.all = type; 843 bundle.phys_type.open = 0; 844 bundle.upat = 0; 845 846 bundle.links = datalink_Create("deflink", &bundle, type); 847 if (bundle.links == NULL) { 848 log_Printf(LogALERT, "Cannot create data link: %s\n", strerror(errno)); 849 iface_Free(bundle.iface); 850 bundle.iface = NULL; 851 close(bundle.dev.fd); 852 return NULL; 853 } 854 855 bundle.desc.type = BUNDLE_DESCRIPTOR; 856 bundle.desc.UpdateSet = bundle_UpdateSet; 857 bundle.desc.IsSet = bundle_IsSet; 858 bundle.desc.Read = bundle_DescriptorRead; 859 bundle.desc.Write = bundle_DescriptorWrite; 860 861 ncp_Init(&bundle.ncp, &bundle); 862 863 memset(&bundle.filter, '\0', sizeof bundle.filter); 864 bundle.filter.in.fragok = bundle.filter.in.logok = 1; 865 bundle.filter.in.name = "IN"; 866 bundle.filter.out.fragok = bundle.filter.out.logok = 1; 867 bundle.filter.out.name = "OUT"; 868 bundle.filter.dial.name = "DIAL"; 869 bundle.filter.dial.logok = 1; 870 bundle.filter.alive.name = "ALIVE"; 871 bundle.filter.alive.logok = 1; 872 { 873 int i; 874 for (i = 0; i < MAXFILTERS; i++) { 875 bundle.filter.in.rule[i].f_action = A_NONE; 876 bundle.filter.out.rule[i].f_action = A_NONE; 877 bundle.filter.dial.rule[i].f_action = A_NONE; 878 bundle.filter.alive.rule[i].f_action = A_NONE; 879 } 880 } 881 memset(&bundle.idle.timer, '\0', sizeof bundle.idle.timer); 882 bundle.idle.done = 0; 883 bundle.notify.fd = -1; 884 memset(&bundle.choked.timer, '\0', sizeof bundle.choked.timer); 885#ifndef NORADIUS 886 radius_Init(&bundle.radius); 887#endif 888 889 /* Clean out any leftover crud */ 890 iface_Clear(bundle.iface, &bundle.ncp, 0, IFACE_CLEAR_ALL); 891 892 bundle_LockTun(&bundle); 893 894 return &bundle; 895} 896 897static void 898bundle_DownInterface(struct bundle *bundle) 899{ 900 route_IfDelete(bundle, 1); 901 iface_ClearFlags(bundle->iface->name, IFF_UP); 902} 903 904void 905bundle_Destroy(struct bundle *bundle) 906{ 907 struct datalink *dl; 908 909 /* 910 * Clean up the interface. We don't really need to do the timer_Stop()s, 911 * mp_Down(), iface_Clear() and bundle_DownInterface() unless we're getting 912 * out under exceptional conditions such as a descriptor exception. 913 */ 914 timer_Stop(&bundle->idle.timer); 915 timer_Stop(&bundle->choked.timer); 916 mp_Down(&bundle->ncp.mp); 917 iface_Clear(bundle->iface, &bundle->ncp, 0, IFACE_CLEAR_ALL); 918 bundle_DownInterface(bundle); 919 920#ifndef NORADIUS 921 /* Tell the radius server the bad news */ 922 radius_Destroy(&bundle->radius); 923#endif 924 925 /* Again, these are all DATALINK_CLOSED unless we're abending */ 926 dl = bundle->links; 927 while (dl) 928 dl = datalink_Destroy(dl); 929 930 ncp_Destroy(&bundle->ncp); 931 932 close(bundle->dev.fd); 933 bundle_UnlockTun(bundle); 934 935 /* In case we never made PHASE_NETWORK */ 936 bundle_Notify(bundle, EX_ERRDEAD); 937 938 iface_Destroy(bundle->iface); 939 bundle->iface = NULL; 940} 941 942void 943bundle_LinkClosed(struct bundle *bundle, struct datalink *dl) 944{ 945 /* 946 * Our datalink has closed. 947 * CleanDatalinks() (called from DoLoop()) will remove closed 948 * BACKGROUND, FOREGROUND and DIRECT links. 949 * If it's the last data link, enter phase DEAD. 950 * 951 * NOTE: dl may not be in our list (bundle_SendDatalink()) ! 952 */ 953 954 struct datalink *odl; 955 int other_links; 956 957 log_SetTtyCommandMode(dl); 958 959 other_links = 0; 960 for (odl = bundle->links; odl; odl = odl->next) 961 if (odl != dl && odl->state != DATALINK_CLOSED) 962 other_links++; 963 964 if (!other_links) { 965 if (dl->physical->type != PHYS_AUTO) /* Not in -auto mode */ 966 bundle_DownInterface(bundle); 967 ncp2initial(&bundle->ncp); 968 mp_Down(&bundle->ncp.mp); 969 bundle_NewPhase(bundle, PHASE_DEAD); 970#ifndef NORADIUS 971 if (bundle->radius.sessiontime) 972 bundle_StopSessionTimer(bundle); 973#endif 974 bundle_StopIdleTimer(bundle); 975 } 976} 977 978void 979bundle_Open(struct bundle *bundle, const char *name, int mask, int force) 980{ 981 /* 982 * Please open the given datalink, or all if name == NULL 983 */ 984 struct datalink *dl; 985 986 for (dl = bundle->links; dl; dl = dl->next) 987 if (name == NULL || !strcasecmp(dl->name, name)) { 988 if ((mask & dl->physical->type) && 989 (dl->state == DATALINK_CLOSED || 990 (force && dl->state == DATALINK_OPENING && 991 dl->dial.timer.state == TIMER_RUNNING) || 992 dl->state == DATALINK_READY)) { 993 timer_Stop(&dl->dial.timer); /* We're finished with this */ 994 datalink_Up(dl, 1, 1); 995 if (mask & PHYS_AUTO) 996 break; /* Only one AUTO link at a time */ 997 } 998 if (name != NULL) 999 break; 1000 } 1001} 1002 1003struct datalink * 1004bundle2datalink(struct bundle *bundle, const char *name) 1005{ 1006 struct datalink *dl; 1007 1008 if (name != NULL) { 1009 for (dl = bundle->links; dl; dl = dl->next) 1010 if (!strcasecmp(dl->name, name)) 1011 return dl; 1012 } else if (bundle->links && !bundle->links->next) 1013 return bundle->links; 1014 1015 return NULL; 1016} 1017 1018int 1019bundle_ShowLinks(struct cmdargs const *arg) 1020{ 1021 struct datalink *dl; 1022 struct pppThroughput *t; 1023 unsigned long long octets; 1024 int secs; 1025 1026 for (dl = arg->bundle->links; dl; dl = dl->next) { 1027 octets = MAX(dl->physical->link.stats.total.in.OctetsPerSecond, 1028 dl->physical->link.stats.total.out.OctetsPerSecond); 1029 1030 prompt_Printf(arg->prompt, "Name: %s [%s, %s]", 1031 dl->name, mode2Nam(dl->physical->type), datalink_State(dl)); 1032 if (dl->physical->link.stats.total.rolling && dl->state == DATALINK_OPEN) 1033 prompt_Printf(arg->prompt, " bandwidth %d, %llu bps (%llu bytes/sec)", 1034 dl->mp.bandwidth ? dl->mp.bandwidth : 1035 physical_GetSpeed(dl->physical), 1036 octets * 8, octets); 1037 prompt_Printf(arg->prompt, "\n"); 1038 } 1039 1040 t = &arg->bundle->ncp.mp.link.stats.total; 1041 octets = MAX(t->in.OctetsPerSecond, t->out.OctetsPerSecond); 1042 secs = t->downtime ? 0 : throughput_uptime(t); 1043 if (secs > t->SamplePeriod) 1044 secs = t->SamplePeriod; 1045 if (secs) 1046 prompt_Printf(arg->prompt, "Currently averaging %llu bps (%llu bytes/sec)" 1047 " over the last %d secs\n", octets * 8, octets, secs); 1048 1049 return 0; 1050} 1051 1052static const char * 1053optval(struct bundle *bundle, int opt) 1054{ 1055 return Enabled(bundle, opt) ? "enabled" : "disabled"; 1056} 1057 1058int 1059bundle_ShowStatus(struct cmdargs const *arg) 1060{ 1061 int remaining; 1062 1063 prompt_Printf(arg->prompt, "Phase %s\n", bundle_PhaseName(arg->bundle)); 1064 prompt_Printf(arg->prompt, " Device: %s\n", arg->bundle->dev.Name); 1065 prompt_Printf(arg->prompt, " Interface: %s @ %lubps", 1066 arg->bundle->iface->name, arg->bundle->bandwidth); 1067 1068 if (arg->bundle->upat) { 1069 int secs = bundle_Uptime(arg->bundle); 1070 1071 prompt_Printf(arg->prompt, ", up time %d:%02d:%02d", secs / 3600, 1072 (secs / 60) % 60, secs % 60); 1073 } 1074 prompt_Printf(arg->prompt, "\n Queued: %lu of %u\n", 1075 (unsigned long)ncp_QueueLen(&arg->bundle->ncp), 1076 arg->bundle->cfg.ifqueue); 1077 1078 prompt_Printf(arg->prompt, "\nDefaults:\n"); 1079 prompt_Printf(arg->prompt, " Label: %s\n", 1080 arg->bundle->cfg.label); 1081 prompt_Printf(arg->prompt, " Auth name: %s\n", 1082 arg->bundle->cfg.auth.name); 1083 prompt_Printf(arg->prompt, " Diagnostic socket: "); 1084 if (*server.cfg.sockname != '\0') { 1085 prompt_Printf(arg->prompt, "%s", server.cfg.sockname); 1086 if (server.cfg.mask != (mode_t)-1) 1087 prompt_Printf(arg->prompt, ", mask 0%03o", (int)server.cfg.mask); 1088 prompt_Printf(arg->prompt, "%s\n", server.fd == -1 ? " (not open)" : ""); 1089 } else if (server.cfg.port != 0) 1090 prompt_Printf(arg->prompt, "TCP port %d%s\n", server.cfg.port, 1091 server.fd == -1 ? " (not open)" : ""); 1092 else 1093 prompt_Printf(arg->prompt, "none\n"); 1094 1095 prompt_Printf(arg->prompt, " Choked Timer: %us\n", 1096 arg->bundle->cfg.choked.timeout); 1097 1098#ifndef NORADIUS 1099 radius_Show(&arg->bundle->radius, arg->prompt); 1100#endif 1101 1102 prompt_Printf(arg->prompt, " Idle Timer: "); 1103 if (arg->bundle->cfg.idle.timeout) { 1104 prompt_Printf(arg->prompt, "%us", arg->bundle->cfg.idle.timeout); 1105 if (arg->bundle->cfg.idle.min_timeout) 1106 prompt_Printf(arg->prompt, ", min %us", 1107 arg->bundle->cfg.idle.min_timeout); 1108 remaining = bundle_RemainingIdleTime(arg->bundle); 1109 if (remaining != -1) 1110 prompt_Printf(arg->prompt, " (%ds remaining)", remaining); 1111 prompt_Printf(arg->prompt, "\n"); 1112 } else 1113 prompt_Printf(arg->prompt, "disabled\n"); 1114 1115 prompt_Printf(arg->prompt, " Filter Decap: %-20.20s", 1116 optval(arg->bundle, OPT_FILTERDECAP)); 1117 prompt_Printf(arg->prompt, " ID check: %s\n", 1118 optval(arg->bundle, OPT_IDCHECK)); 1119 prompt_Printf(arg->prompt, " Iface-Alias: %-20.20s", 1120 optval(arg->bundle, OPT_IFACEALIAS)); 1121#ifndef NOINET6 1122 prompt_Printf(arg->prompt, " IPCP: %s\n", 1123 optval(arg->bundle, OPT_IPCP)); 1124 prompt_Printf(arg->prompt, " IPV6CP: %-20.20s", 1125 optval(arg->bundle, OPT_IPV6CP)); 1126#endif 1127 prompt_Printf(arg->prompt, " Keep-Session: %s\n", 1128 optval(arg->bundle, OPT_KEEPSESSION)); 1129 prompt_Printf(arg->prompt, " Loopback: %-20.20s", 1130 optval(arg->bundle, OPT_LOOPBACK)); 1131 prompt_Printf(arg->prompt, " PasswdAuth: %s\n", 1132 optval(arg->bundle, OPT_PASSWDAUTH)); 1133 prompt_Printf(arg->prompt, " Proxy: %-20.20s", 1134 optval(arg->bundle, OPT_PROXY)); 1135 prompt_Printf(arg->prompt, " Proxyall: %s\n", 1136 optval(arg->bundle, OPT_PROXYALL)); 1137 prompt_Printf(arg->prompt, " Sticky Routes: %-20.20s", 1138 optval(arg->bundle, OPT_SROUTES)); 1139 prompt_Printf(arg->prompt, " TCPMSS Fixup: %s\n", 1140 optval(arg->bundle, OPT_TCPMSSFIXUP)); 1141 prompt_Printf(arg->prompt, " Throughput: %-20.20s", 1142 optval(arg->bundle, OPT_THROUGHPUT)); 1143 prompt_Printf(arg->prompt, " Utmp Logging: %s\n", 1144 optval(arg->bundle, OPT_UTMP)); 1145 prompt_Printf(arg->prompt, " NAS-IP-Address: %-20.20s", 1146 optval(arg->bundle, OPT_NAS_IP_ADDRESS)); 1147 prompt_Printf(arg->prompt, " NAS-Identifier: %s\n", 1148 optval(arg->bundle, OPT_NAS_IDENTIFIER)); 1149 1150 return 0; 1151} 1152 1153static void 1154bundle_IdleTimeout(void *v) 1155{ 1156 struct bundle *bundle = (struct bundle *)v; 1157 1158 log_Printf(LogPHASE, "Idle timer expired\n"); 1159 bundle_StopIdleTimer(bundle); 1160 bundle_Close(bundle, NULL, CLOSE_STAYDOWN); 1161} 1162 1163/* 1164 * Start Idle timer. If timeout is reached, we call bundle_Close() to 1165 * close LCP and link. 1166 */ 1167void 1168bundle_StartIdleTimer(struct bundle *bundle, unsigned secs) 1169{ 1170 timer_Stop(&bundle->idle.timer); 1171 if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) != 1172 bundle->phys_type.open && bundle->cfg.idle.timeout) { 1173 time_t now = time(NULL); 1174 1175 if (secs == 0) 1176 secs = bundle->cfg.idle.timeout; 1177 1178 /* We want at least `secs' */ 1179 if (bundle->cfg.idle.min_timeout > secs && bundle->upat) { 1180 unsigned up = now - bundle->upat; 1181 1182 if (bundle->cfg.idle.min_timeout > up && 1183 bundle->cfg.idle.min_timeout - up > (long long)secs) 1184 /* Only increase from the current `remaining' value */ 1185 secs = bundle->cfg.idle.min_timeout - up; 1186 } 1187 bundle->idle.timer.func = bundle_IdleTimeout; 1188 bundle->idle.timer.name = "idle"; 1189 bundle->idle.timer.load = secs * SECTICKS; 1190 bundle->idle.timer.arg = bundle; 1191 timer_Start(&bundle->idle.timer); 1192 bundle->idle.done = now + secs; 1193 } 1194} 1195 1196void 1197bundle_SetIdleTimer(struct bundle *bundle, unsigned timeout, 1198 unsigned min_timeout) 1199{ 1200 bundle->cfg.idle.timeout = timeout; 1201 bundle->cfg.idle.min_timeout = min_timeout; 1202 if (ncp_LayersOpen(&bundle->ncp)) 1203 bundle_StartIdleTimer(bundle, 0); 1204} 1205 1206void 1207bundle_StopIdleTimer(struct bundle *bundle) 1208{ 1209 timer_Stop(&bundle->idle.timer); 1210 bundle->idle.done = 0; 1211} 1212 1213static int 1214bundle_RemainingIdleTime(struct bundle *bundle) 1215{ 1216 if (bundle->idle.done) 1217 return bundle->idle.done - time(NULL); 1218 return -1; 1219} 1220 1221#ifndef NORADIUS 1222 1223static void 1224bundle_SessionTimeout(void *v) 1225{ 1226 struct bundle *bundle = (struct bundle *)v; 1227 1228 log_Printf(LogPHASE, "Session-Timeout timer expired\n"); 1229 bundle_StopSessionTimer(bundle); 1230 bundle_Close(bundle, NULL, CLOSE_STAYDOWN); 1231} 1232 1233void 1234bundle_StartSessionTimer(struct bundle *bundle, unsigned secs) 1235{ 1236 timer_Stop(&bundle->session.timer); 1237 if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) != 1238 bundle->phys_type.open && bundle->radius.sessiontime) { 1239 time_t now = time(NULL); 1240 1241 if (secs == 0) 1242 secs = bundle->radius.sessiontime; 1243 1244 bundle->session.timer.func = bundle_SessionTimeout; 1245 bundle->session.timer.name = "session"; 1246 bundle->session.timer.load = secs * SECTICKS; 1247 bundle->session.timer.arg = bundle; 1248 timer_Start(&bundle->session.timer); 1249 bundle->session.done = now + secs; 1250 } 1251} 1252 1253void 1254bundle_StopSessionTimer(struct bundle *bundle) 1255{ 1256 timer_Stop(&bundle->session.timer); 1257 bundle->session.done = 0; 1258} 1259 1260#endif 1261 1262int 1263bundle_IsDead(struct bundle *bundle) 1264{ 1265 return !bundle->links || (bundle->phase == PHASE_DEAD && bundle->CleaningUp); 1266} 1267 1268static struct datalink * 1269bundle_DatalinkLinkout(struct bundle *bundle, struct datalink *dl) 1270{ 1271 struct datalink **dlp; 1272 1273 for (dlp = &bundle->links; *dlp; dlp = &(*dlp)->next) 1274 if (*dlp == dl) { 1275 *dlp = dl->next; 1276 dl->next = NULL; 1277 bundle_LinksRemoved(bundle); 1278 return dl; 1279 } 1280 1281 return NULL; 1282} 1283 1284static void 1285bundle_DatalinkLinkin(struct bundle *bundle, struct datalink *dl) 1286{ 1287 struct datalink **dlp = &bundle->links; 1288 1289 while (*dlp) 1290 dlp = &(*dlp)->next; 1291 1292 *dlp = dl; 1293 dl->next = NULL; 1294 1295 bundle_LinkAdded(bundle, dl); 1296 mp_CheckAutoloadTimer(&bundle->ncp.mp); 1297} 1298 1299void 1300bundle_CleanDatalinks(struct bundle *bundle) 1301{ 1302 struct datalink **dlp = &bundle->links; 1303 int found = 0; 1304 1305 while (*dlp) 1306 if ((*dlp)->state == DATALINK_CLOSED && 1307 (*dlp)->physical->type & 1308 (PHYS_DIRECT|PHYS_BACKGROUND|PHYS_FOREGROUND)) { 1309 *dlp = datalink_Destroy(*dlp); 1310 found++; 1311 } else 1312 dlp = &(*dlp)->next; 1313 1314 if (found) 1315 bundle_LinksRemoved(bundle); 1316} 1317 1318int 1319bundle_DatalinkClone(struct bundle *bundle, struct datalink *dl, 1320 const char *name) 1321{ 1322 if (bundle2datalink(bundle, name)) { 1323 log_Printf(LogWARN, "Clone: %s: name already exists\n", name); 1324 return 0; 1325 } 1326 1327 bundle_DatalinkLinkin(bundle, datalink_Clone(dl, name)); 1328 return 1; 1329} 1330 1331void 1332bundle_DatalinkRemove(struct bundle *bundle, struct datalink *dl) 1333{ 1334 dl = bundle_DatalinkLinkout(bundle, dl); 1335 if (dl) 1336 datalink_Destroy(dl); 1337} 1338 1339void 1340bundle_SetLabel(struct bundle *bundle, const char *label) 1341{ 1342 if (label) 1343 strncpy(bundle->cfg.label, label, sizeof bundle->cfg.label - 1); 1344 else 1345 *bundle->cfg.label = '\0'; 1346} 1347 1348const char * 1349bundle_GetLabel(struct bundle *bundle) 1350{ 1351 return *bundle->cfg.label ? bundle->cfg.label : NULL; 1352} 1353 1354int 1355bundle_LinkSize(void) 1356{ 1357 struct iovec iov[SCATTER_SEGMENTS]; 1358 int niov, expect, f; 1359 1360 iov[0].iov_len = strlen(Version) + 1; 1361 iov[0].iov_base = NULL; 1362 niov = 1; 1363 if (datalink2iov(NULL, iov, &niov, SCATTER_SEGMENTS, NULL, NULL) == -1) { 1364 log_Printf(LogERROR, "Cannot determine space required for link\n"); 1365 return 0; 1366 } 1367 1368 for (f = expect = 0; f < niov; f++) 1369 expect += iov[f].iov_len; 1370 1371 return expect; 1372} 1373 1374void 1375bundle_ReceiveDatalink(struct bundle *bundle, int s) 1376{ 1377 char cmsgbuf[sizeof(struct cmsghdr) + sizeof(int) * SEND_MAXFD]; 1378 int niov, expect, f, *fd, nfd, onfd; 1379 ssize_t got; 1380 struct iovec iov[SCATTER_SEGMENTS]; 1381 struct cmsghdr *cmsg; 1382 struct msghdr msg; 1383 struct datalink *dl; 1384 pid_t pid; 1385 1386 log_Printf(LogPHASE, "Receiving datalink\n"); 1387 1388 /* 1389 * Create our scatter/gather array - passing NULL gets the space 1390 * allocation requirement rather than actually flattening the 1391 * structures. 1392 */ 1393 iov[0].iov_len = strlen(Version) + 1; 1394 iov[0].iov_base = NULL; 1395 niov = 1; 1396 if (datalink2iov(NULL, iov, &niov, SCATTER_SEGMENTS, NULL, NULL) == -1) { 1397 log_Printf(LogERROR, "Cannot determine space required for link\n"); 1398 return; 1399 } 1400 1401 /* Allocate the scatter/gather array for recvmsg() */ 1402 for (f = expect = 0; f < niov; f++) { 1403 if ((iov[f].iov_base = malloc(iov[f].iov_len)) == NULL) { 1404 log_Printf(LogERROR, "Cannot allocate space to receive link\n"); 1405 return; 1406 } 1407 if (f) 1408 expect += iov[f].iov_len; 1409 } 1410 1411 /* Set up our message */ 1412 cmsg = (struct cmsghdr *)cmsgbuf; 1413 cmsg->cmsg_len = sizeof cmsgbuf; 1414 cmsg->cmsg_level = SOL_SOCKET; 1415 cmsg->cmsg_type = 0; 1416 1417 memset(&msg, '\0', sizeof msg); 1418 msg.msg_name = NULL; 1419 msg.msg_namelen = 0; 1420 msg.msg_iov = iov; 1421 msg.msg_iovlen = 1; /* Only send the version at the first pass */ 1422 msg.msg_control = cmsgbuf; 1423 msg.msg_controllen = sizeof cmsgbuf; 1424 1425 log_Printf(LogDEBUG, "Expecting %u scatter/gather bytes\n", 1426 (unsigned)iov[0].iov_len); 1427 1428 if ((got = recvmsg(s, &msg, MSG_WAITALL)) != (ssize_t)iov[0].iov_len) { 1429 if (got == -1) 1430 log_Printf(LogERROR, "Failed recvmsg: %s\n", strerror(errno)); 1431 else 1432 log_Printf(LogERROR, "Failed recvmsg: Got %zd, not %u\n", 1433 got, (unsigned)iov[0].iov_len); 1434 while (niov--) 1435 free(iov[niov].iov_base); 1436 return; 1437 } 1438 1439 if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) { 1440 log_Printf(LogERROR, "Recvmsg: no descriptors received !\n"); 1441 while (niov--) 1442 free(iov[niov].iov_base); 1443 return; 1444 } 1445 1446 fd = (int *)CMSG_DATA(cmsg); 1447 nfd = ((caddr_t)cmsg + cmsg->cmsg_len - (caddr_t)fd) / sizeof(int); 1448 1449 if (nfd < 2) { 1450 log_Printf(LogERROR, "Recvmsg: %d descriptor%s received (too few) !\n", 1451 nfd, nfd == 1 ? "" : "s"); 1452 while (nfd--) 1453 close(fd[nfd]); 1454 while (niov--) 1455 free(iov[niov].iov_base); 1456 return; 1457 } 1458 1459 /* 1460 * We've successfully received two or more open file descriptors 1461 * through our socket, plus a version string. Make sure it's the 1462 * correct version, and drop the connection if it's not. 1463 */ 1464 if (strncmp(Version, iov[0].iov_base, iov[0].iov_len)) { 1465 log_Printf(LogWARN, "Cannot receive datalink, incorrect version" 1466 " (\"%.*s\", not \"%s\")\n", (int)iov[0].iov_len, 1467 (char *)iov[0].iov_base, Version); 1468 while (nfd--) 1469 close(fd[nfd]); 1470 while (niov--) 1471 free(iov[niov].iov_base); 1472 return; 1473 } 1474 1475 /* 1476 * Everything looks good. Send the other side our process id so that 1477 * they can transfer lock ownership, and wait for them to send the 1478 * actual link data. 1479 */ 1480 pid = getpid(); 1481 if ((got = write(fd[1], &pid, sizeof pid)) != sizeof pid) { 1482 if (got == -1) 1483 log_Printf(LogERROR, "Failed write: %s\n", strerror(errno)); 1484 else 1485 log_Printf(LogERROR, "Failed write: Got %zd, not %d\n", got, 1486 (int)(sizeof pid)); 1487 while (nfd--) 1488 close(fd[nfd]); 1489 while (niov--) 1490 free(iov[niov].iov_base); 1491 return; 1492 } 1493 1494 if ((got = readv(fd[1], iov + 1, niov - 1)) != expect) { 1495 if (got == -1) 1496 log_Printf(LogERROR, "Failed write: %s\n", strerror(errno)); 1497 else 1498 log_Printf(LogERROR, "Failed write: Got %zd, not %d\n", got, expect); 1499 while (nfd--) 1500 close(fd[nfd]); 1501 while (niov--) 1502 free(iov[niov].iov_base); 1503 return; 1504 } 1505 close(fd[1]); 1506 1507 onfd = nfd; /* We've got this many in our array */ 1508 nfd -= 2; /* Don't include p->fd and our reply descriptor */ 1509 niov = 1; /* Skip the version id */ 1510 dl = iov2datalink(bundle, iov, &niov, sizeof iov / sizeof *iov, fd[0], 1511 fd + 2, &nfd); 1512 if (dl) { 1513 1514 if (nfd) { 1515 log_Printf(LogERROR, "bundle_ReceiveDatalink: Failed to handle %d " 1516 "auxiliary file descriptors (%d remain)\n", onfd, nfd); 1517 datalink_Destroy(dl); 1518 while (nfd--) 1519 close(fd[onfd--]); 1520 close(fd[0]); 1521 } else { 1522 bundle_DatalinkLinkin(bundle, dl); 1523 datalink_AuthOk(dl); 1524 bundle_CalculateBandwidth(dl->bundle); 1525 } 1526 } else { 1527 while (nfd--) 1528 close(fd[onfd--]); 1529 close(fd[0]); 1530 close(fd[1]); 1531 } 1532 1533 free(iov[0].iov_base); 1534} 1535 1536void 1537bundle_SendDatalink(struct datalink *dl, int s, struct sockaddr_un *sun) 1538{ 1539 char cmsgbuf[CMSG_SPACE(sizeof(int) * SEND_MAXFD)]; 1540 const char *constlock; 1541 char *lock; 1542 struct cmsghdr *cmsg; 1543 struct msghdr msg; 1544 struct iovec iov[SCATTER_SEGMENTS]; 1545 int niov, f, expect, newsid, fd[SEND_MAXFD], nfd, reply[2]; 1546 ssize_t got; 1547 pid_t newpid; 1548 1549 log_Printf(LogPHASE, "Transmitting datalink %s\n", dl->name); 1550 1551 /* Record the base device name for a lock transfer later */ 1552 constlock = physical_LockedDevice(dl->physical); 1553 if (constlock) { 1554 lock = alloca(strlen(constlock) + 1); 1555 strcpy(lock, constlock); 1556 } else 1557 lock = NULL; 1558 1559 bundle_LinkClosed(dl->bundle, dl); 1560 bundle_DatalinkLinkout(dl->bundle, dl); 1561 1562 /* Build our scatter/gather array */ 1563 iov[0].iov_len = strlen(Version) + 1; 1564 iov[0].iov_base = strdup(Version); 1565 niov = 1; 1566 nfd = 0; 1567 1568 fd[0] = datalink2iov(dl, iov, &niov, SCATTER_SEGMENTS, fd + 2, &nfd); 1569 1570 if (fd[0] != -1 && socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, reply) != -1) { 1571 /* 1572 * fd[1] is used to get the peer process id back, then to confirm that 1573 * we've transferred any device locks to that process id. 1574 */ 1575 fd[1] = reply[1]; 1576 1577 nfd += 2; /* Include fd[0] and fd[1] */ 1578 memset(&msg, '\0', sizeof msg); 1579 1580 msg.msg_name = NULL; 1581 msg.msg_namelen = 0; 1582 /* 1583 * Only send the version to start... We used to send the whole lot, but 1584 * this caused problems with our RECVBUF size as a single link is about 1585 * 22k ! This way, we should bump into no limits. 1586 */ 1587 msg.msg_iovlen = 1; 1588 msg.msg_iov = iov; 1589 msg.msg_control = cmsgbuf; 1590 msg.msg_controllen = CMSG_SPACE(sizeof(int) * nfd); 1591 msg.msg_flags = 0; 1592 1593 cmsg = (struct cmsghdr *)cmsgbuf; 1594 cmsg->cmsg_len = msg.msg_controllen; 1595 cmsg->cmsg_level = SOL_SOCKET; 1596 cmsg->cmsg_type = SCM_RIGHTS; 1597 1598 for (f = 0; f < nfd; f++) 1599 *((int *)CMSG_DATA(cmsg) + f) = fd[f]; 1600 1601 for (f = 1, expect = 0; f < niov; f++) 1602 expect += iov[f].iov_len; 1603 1604 if (setsockopt(reply[0], SOL_SOCKET, SO_SNDBUF, &expect, sizeof(int)) == -1) 1605 log_Printf(LogERROR, "setsockopt(SO_RCVBUF, %d): %s\n", expect, 1606 strerror(errno)); 1607 if (setsockopt(reply[1], SOL_SOCKET, SO_RCVBUF, &expect, sizeof(int)) == -1) 1608 log_Printf(LogERROR, "setsockopt(SO_RCVBUF, %d): %s\n", expect, 1609 strerror(errno)); 1610 1611 log_Printf(LogDEBUG, "Sending %d descriptor%s and %u bytes in scatter" 1612 "/gather array\n", nfd, nfd == 1 ? "" : "s", 1613 (unsigned)iov[0].iov_len); 1614 1615 if ((got = sendmsg(s, &msg, 0)) == -1) 1616 log_Printf(LogERROR, "Failed sendmsg: %s: %s\n", 1617 sun->sun_path, strerror(errno)); 1618 else if (got != (ssize_t)iov[0].iov_len) 1619 log_Printf(LogERROR, "%s: Failed initial sendmsg: Only sent %zd of %u\n", 1620 sun->sun_path, got, (unsigned)iov[0].iov_len); 1621 else { 1622 /* We must get the ACK before closing the descriptor ! */ 1623 int res; 1624 1625 if ((got = read(reply[0], &newpid, sizeof newpid)) == sizeof newpid) { 1626 log_Printf(LogDEBUG, "Received confirmation from pid %ld\n", 1627 (long)newpid); 1628 if (lock && (res = ID0uu_lock_txfr(lock, newpid)) != UU_LOCK_OK) 1629 log_Printf(LogERROR, "uu_lock_txfr: %s\n", uu_lockerr(res)); 1630 1631 log_Printf(LogDEBUG, "Transmitting link (%d bytes)\n", expect); 1632 if ((got = writev(reply[0], iov + 1, niov - 1)) != expect) { 1633 if (got == -1) 1634 log_Printf(LogERROR, "%s: Failed writev: %s\n", 1635 sun->sun_path, strerror(errno)); 1636 else 1637 log_Printf(LogERROR, "%s: Failed writev: Wrote %zd of %d\n", 1638 sun->sun_path, got, expect); 1639 } 1640 } else if (got == -1) 1641 log_Printf(LogERROR, "%s: Failed socketpair read: %s\n", 1642 sun->sun_path, strerror(errno)); 1643 else 1644 log_Printf(LogERROR, "%s: Failed socketpair read: Got %zd of %d\n", 1645 sun->sun_path, got, (int)(sizeof newpid)); 1646 } 1647 1648 close(reply[0]); 1649 close(reply[1]); 1650 1651 newsid = Enabled(dl->bundle, OPT_KEEPSESSION) || 1652 tcgetpgrp(fd[0]) == getpgrp(); 1653 while (nfd) 1654 close(fd[--nfd]); 1655 if (newsid) 1656 bundle_setsid(dl->bundle, got != -1); 1657 } 1658 close(s); 1659 1660 while (niov--) 1661 free(iov[niov].iov_base); 1662} 1663 1664int 1665bundle_RenameDatalink(struct bundle *bundle, struct datalink *ndl, 1666 const char *name) 1667{ 1668 struct datalink *dl; 1669 1670 if (!strcasecmp(ndl->name, name)) 1671 return 1; 1672 1673 for (dl = bundle->links; dl; dl = dl->next) 1674 if (!strcasecmp(dl->name, name)) 1675 return 0; 1676 1677 datalink_Rename(ndl, name); 1678 return 1; 1679} 1680 1681int 1682bundle_SetMode(struct bundle *bundle, struct datalink *dl, int mode) 1683{ 1684 int omode; 1685 1686 omode = dl->physical->type; 1687 if (omode == mode) 1688 return 1; 1689 1690 if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO)) 1691 /* First auto link */ 1692 if (bundle->ncp.ipcp.peer_ip.s_addr == INADDR_ANY) { 1693 log_Printf(LogWARN, "You must `set ifaddr' or `open' before" 1694 " changing mode to %s\n", mode2Nam(mode)); 1695 return 0; 1696 } 1697 1698 if (!datalink_SetMode(dl, mode)) 1699 return 0; 1700 1701 if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO) && 1702 bundle->phase != PHASE_NETWORK) 1703 /* First auto link, we need an interface */ 1704 ipcp_InterfaceUp(&bundle->ncp.ipcp); 1705 1706 /* Regenerate phys_type and adjust idle timer */ 1707 bundle_LinksRemoved(bundle); 1708 1709 return 1; 1710} 1711 1712void 1713bundle_setsid(struct bundle *bundle, int holdsession) 1714{ 1715 /* 1716 * Lose the current session. This means getting rid of our pid 1717 * too so that the tty device will really go away, and any getty 1718 * etc will be allowed to restart. 1719 */ 1720 pid_t pid, orig; 1721 int fds[2]; 1722 char done; 1723 struct datalink *dl; 1724 1725 if (!holdsession && bundle_IsDead(bundle)) { 1726 /* 1727 * No need to lose our session after all... we're going away anyway 1728 * 1729 * We should really stop the timer and pause if holdsession is set and 1730 * the bundle's dead, but that leaves other resources lying about :-( 1731 */ 1732 return; 1733 } 1734 1735 orig = getpid(); 1736 if (pipe(fds) == -1) { 1737 log_Printf(LogERROR, "pipe: %s\n", strerror(errno)); 1738 return; 1739 } 1740 switch ((pid = fork())) { 1741 case -1: 1742 log_Printf(LogERROR, "fork: %s\n", strerror(errno)); 1743 close(fds[0]); 1744 close(fds[1]); 1745 return; 1746 case 0: 1747 close(fds[1]); 1748 read(fds[0], &done, 1); /* uu_locks are mine ! */ 1749 close(fds[0]); 1750 if (pipe(fds) == -1) { 1751 log_Printf(LogERROR, "pipe(2): %s\n", strerror(errno)); 1752 return; 1753 } 1754 switch ((pid = fork())) { 1755 case -1: 1756 log_Printf(LogERROR, "fork(2): %s\n", strerror(errno)); 1757 close(fds[0]); 1758 close(fds[1]); 1759 return; 1760 case 0: 1761 close(fds[1]); 1762 bundle_LockTun(bundle); /* update pid */ 1763 read(fds[0], &done, 1); /* uu_locks are mine ! */ 1764 close(fds[0]); 1765 setsid(); 1766 bundle_ChangedPID(bundle); 1767 log_Printf(LogDEBUG, "%ld -> %ld: %s session control\n", 1768 (long)orig, (long)getpid(), 1769 holdsession ? "Passed" : "Dropped"); 1770 timer_InitService(0); /* Start the Timer Service */ 1771 break; 1772 default: 1773 close(fds[0]); 1774 /* Give away all our physical locks (to the final process) */ 1775 for (dl = bundle->links; dl; dl = dl->next) 1776 if (dl->state != DATALINK_CLOSED) 1777 physical_ChangedPid(dl->physical, pid); 1778 write(fds[1], "!", 1); /* done */ 1779 close(fds[1]); 1780 _exit(0); 1781 break; 1782 } 1783 break; 1784 default: 1785 close(fds[0]); 1786 /* Give away all our physical locks (to the intermediate process) */ 1787 for (dl = bundle->links; dl; dl = dl->next) 1788 if (dl->state != DATALINK_CLOSED) 1789 physical_ChangedPid(dl->physical, pid); 1790 write(fds[1], "!", 1); /* done */ 1791 close(fds[1]); 1792 if (holdsession) { 1793 int fd, status; 1794 1795 timer_TermService(); 1796 signal(SIGPIPE, SIG_DFL); 1797 signal(SIGALRM, SIG_DFL); 1798 signal(SIGHUP, SIG_DFL); 1799 signal(SIGTERM, SIG_DFL); 1800 signal(SIGINT, SIG_DFL); 1801 signal(SIGQUIT, SIG_DFL); 1802 for (fd = getdtablesize(); fd >= 0; fd--) 1803 close(fd); 1804 /* 1805 * Reap the intermediate process. As we're not exiting but the 1806 * intermediate is, we don't want it to become defunct. 1807 */ 1808 waitpid(pid, &status, 0); 1809 /* Tweak our process arguments.... */ 1810 SetTitle("session owner"); 1811#ifndef NOSUID 1812 setuid(ID0realuid()); 1813#endif 1814 /* 1815 * Hang around for a HUP. This should happen as soon as the 1816 * ppp that we passed our ctty descriptor to closes it. 1817 * NOTE: If this process dies, the passed descriptor becomes 1818 * invalid and will give a select() error by setting one 1819 * of the error fds, aborting the other ppp. We don't 1820 * want that to happen ! 1821 */ 1822 pause(); 1823 } 1824 _exit(0); 1825 break; 1826 } 1827} 1828 1829unsigned 1830bundle_HighestState(struct bundle *bundle) 1831{ 1832 struct datalink *dl; 1833 unsigned result = DATALINK_CLOSED; 1834 1835 for (dl = bundle->links; dl; dl = dl->next) 1836 if (result < dl->state) 1837 result = dl->state; 1838 1839 return result; 1840} 1841 1842int 1843bundle_Exception(struct bundle *bundle, int fd) 1844{ 1845 struct datalink *dl; 1846 1847 for (dl = bundle->links; dl; dl = dl->next) 1848 if (dl->physical->fd == fd) { 1849 datalink_Down(dl, CLOSE_NORMAL); 1850 return 1; 1851 } 1852 1853 return 0; 1854} 1855 1856void 1857bundle_AdjustFilters(struct bundle *bundle, struct ncpaddr *local, 1858 struct ncpaddr *remote) 1859{ 1860 filter_AdjustAddr(&bundle->filter.in, local, remote, NULL); 1861 filter_AdjustAddr(&bundle->filter.out, local, remote, NULL); 1862 filter_AdjustAddr(&bundle->filter.dial, local, remote, NULL); 1863 filter_AdjustAddr(&bundle->filter.alive, local, remote, NULL); 1864} 1865 1866void 1867bundle_AdjustDNS(struct bundle *bundle) 1868{ 1869 struct in_addr *dns = bundle->ncp.ipcp.ns.dns; 1870 1871 filter_AdjustAddr(&bundle->filter.in, NULL, NULL, dns); 1872 filter_AdjustAddr(&bundle->filter.out, NULL, NULL, dns); 1873 filter_AdjustAddr(&bundle->filter.dial, NULL, NULL, dns); 1874 filter_AdjustAddr(&bundle->filter.alive, NULL, NULL, dns); 1875} 1876 1877void 1878bundle_CalculateBandwidth(struct bundle *bundle) 1879{ 1880 struct datalink *dl; 1881 int sp, overhead, maxoverhead; 1882 1883 bundle->bandwidth = 0; 1884 bundle->iface->mtu = 0; 1885 maxoverhead = 0; 1886 1887 for (dl = bundle->links; dl; dl = dl->next) { 1888 overhead = ccp_MTUOverhead(&dl->physical->link.ccp); 1889 if (maxoverhead < overhead) 1890 maxoverhead = overhead; 1891 if (dl->state == DATALINK_OPEN) { 1892 if ((sp = dl->mp.bandwidth) == 0 && 1893 (sp = physical_GetSpeed(dl->physical)) == 0) 1894 log_Printf(LogDEBUG, "%s: %s: Cannot determine bandwidth\n", 1895 dl->name, dl->physical->name.full); 1896 else 1897 bundle->bandwidth += sp; 1898 if (!bundle->ncp.mp.active) { 1899 bundle->iface->mtu = dl->physical->link.lcp.his_mru; 1900 break; 1901 } 1902 } 1903 } 1904 1905 if (bundle->bandwidth == 0) 1906 bundle->bandwidth = 115200; /* Shrug */ 1907 1908 if (bundle->ncp.mp.active) { 1909 bundle->iface->mtu = bundle->ncp.mp.peer_mrru; 1910 overhead = ccp_MTUOverhead(&bundle->ncp.mp.link.ccp); 1911 if (maxoverhead < overhead) 1912 maxoverhead = overhead; 1913 } else if (!bundle->iface->mtu) 1914 bundle->iface->mtu = DEF_MRU; 1915 1916#ifndef NORADIUS 1917 if (bundle->radius.valid && bundle->radius.mtu && 1918 bundle->radius.mtu < bundle->iface->mtu) { 1919 log_Printf(LogLCP, "Reducing MTU to radius value %lu\n", 1920 bundle->radius.mtu); 1921 bundle->iface->mtu = bundle->radius.mtu; 1922 } 1923#endif 1924 1925 if (maxoverhead) { 1926 log_Printf(LogLCP, "Reducing MTU from %lu to %lu (CCP requirement)\n", 1927 bundle->iface->mtu, bundle->iface->mtu - maxoverhead); 1928 bundle->iface->mtu -= maxoverhead; 1929 } 1930 1931 tun_configure(bundle); 1932 1933 route_UpdateMTU(bundle); 1934} 1935 1936void 1937bundle_AutoAdjust(struct bundle *bundle, int percent, int what) 1938{ 1939 struct datalink *dl, *choice, *otherlinkup; 1940 1941 choice = otherlinkup = NULL; 1942 for (dl = bundle->links; dl; dl = dl->next) 1943 if (dl->physical->type == PHYS_AUTO) { 1944 if (dl->state == DATALINK_OPEN) { 1945 if (what == AUTO_DOWN) { 1946 if (choice) 1947 otherlinkup = choice; 1948 choice = dl; 1949 } 1950 } else if (dl->state == DATALINK_CLOSED) { 1951 if (what == AUTO_UP) { 1952 choice = dl; 1953 break; 1954 } 1955 } else { 1956 /* An auto link in an intermediate state - forget it for the moment */ 1957 choice = NULL; 1958 break; 1959 } 1960 } else if (dl->state == DATALINK_OPEN && what == AUTO_DOWN) 1961 otherlinkup = dl; 1962 1963 if (choice) { 1964 if (what == AUTO_UP) { 1965 log_Printf(LogPHASE, "%d%% saturation -> Opening link ``%s''\n", 1966 percent, choice->name); 1967 datalink_Up(choice, 1, 1); 1968 mp_CheckAutoloadTimer(&bundle->ncp.mp); 1969 } else if (otherlinkup) { /* Only bring the second-last link down */ 1970 log_Printf(LogPHASE, "%d%% saturation -> Closing link ``%s''\n", 1971 percent, choice->name); 1972 datalink_Close(choice, CLOSE_STAYDOWN); 1973 mp_CheckAutoloadTimer(&bundle->ncp.mp); 1974 } 1975 } 1976} 1977 1978int 1979bundle_WantAutoloadTimer(struct bundle *bundle) 1980{ 1981 struct datalink *dl; 1982 int autolink, opened; 1983 1984 if (bundle->phase == PHASE_NETWORK) { 1985 for (autolink = opened = 0, dl = bundle->links; dl; dl = dl->next) 1986 if (dl->physical->type == PHYS_AUTO) { 1987 if (++autolink == 2 || (autolink == 1 && opened)) 1988 /* Two auto links or one auto and one open in NETWORK phase */ 1989 return 1; 1990 } else if (dl->state == DATALINK_OPEN) { 1991 opened++; 1992 if (autolink) 1993 /* One auto and one open link in NETWORK phase */ 1994 return 1; 1995 } 1996 } 1997 1998 return 0; 1999} 2000 2001void 2002bundle_ChangedPID(struct bundle *bundle) 2003{ 2004#ifdef TUNSIFPID 2005 ioctl(bundle->dev.fd, TUNSIFPID, 0); 2006#endif 2007} 2008 2009int 2010bundle_Uptime(struct bundle *bundle) 2011{ 2012 if (bundle->upat) 2013 return time(NULL) - bundle->upat; 2014 2015 return 0; 2016} 2017