ipcp
struct sipcp ipcp; /* IPCP params */
struct sipcp ipcp; /* IPCP params */
sp->ipcp.opts = 0;
sp->ipcp.flags = 0;
sppp_up_event(&ipcp, sp);
sppp_down_event(&ipcp, sp);
sp->ipcp.flags &= ~(IPCP_HISADDR_SEEN | IPCP_MYADDR_SEEN |
sp->ipcp.opts = 0;
sp->ipcp.flags |= IPCP_MYADDR_DYN;
sp->ipcp.opts |= (1 << IPCP_OPT_ADDRESS);
sp->ipcp.flags |= IPCP_MYADDR_SEEN;
sp->ipcp.opts |= (1 << IPCP_OPT_COMPRESSION);
sp->ipcp.max_state = MAX_STATES - 1;
sp->ipcp.compress_cid = 1;
sppp_open_event(&ipcp, sp);
sppp_close_event(&ipcp, sp);
if (sp->ipcp.flags & IPCP_MYADDR_DYN)
sppp_to_event(&ipcp, (struct sppp *)cookie);
sp->ipcp.flags |= IPCP_VJ;
sp->ipcp.max_state = p[4];
sp->ipcp.compress_cid = p[5];
p[4] = sp->ipcp.max_state;
p[5] = sp->ipcp.compress_cid;
sp->ipcp.flags |= IPCP_HISADDR_SEEN;
if (rlen == 0 && !(sp->ipcp.flags & IPCP_HISADDR_SEEN) && !gotmyaddr) {
sp->ipcp.opts &= ~(1 << IPCP_OPT_COMPRESSION);
sp->ipcp.opts &= ~(1 << IPCP_OPT_ADDRESS);
sp->ipcp.max_state = p[4];
sp->ipcp.compress_cid = p[5];
sp->ipcp.opts &=
sp->ipcp.opts |= (1 << IPCP_OPT_ADDRESS);
if (sp->ipcp.flags & IPCP_MYADDR_DYN) {
sp->ipcp.flags |= IPCP_MYADDR_SEEN;
if (sp->ipcp.opts & (1 << IPCP_OPT_COMPRESSION)) {
opt[i++] = sp->ipcp.max_state;
opt[i++] = sp->ipcp.compress_cid;
if (sp->ipcp.opts & (1 << IPCP_OPT_ADDRESS)) {
static const struct cp ipcp = {
&ipcp, /* IDX_IPCP */
spr->defs.ipcp = sp->ipcp;
sppp_cp_input(&ipcp, sp, m);
if (sp->pp_mode != IFF_CISCO && (sp->ipcp.flags & IPCP_VJ) &&
sp->ipcp.compress_cid)) {
ipcp_Setup(&bundle->ncp.ipcp, INADDR_NONE);
ipcp_Setup(&bundle->ncp.ipcp, bundle->radius.mask.s_addr);
ipcp_Setup(&bundle->ncp.ipcp, INADDR_NONE);
ipcp_Setup(&bundle->ncp.ipcp, INADDR_NONE);
if (bundle->ncp.ipcp.peer_ip.s_addr == INADDR_ANY) {
ipcp_InterfaceUp(&bundle->ncp.ipcp);
struct in_addr *dns = bundle->ncp.ipcp.ns.dns;
bundle->ncp.ipcp.my_ip.s_addr) {
if (arg->bundle->ncp.ipcp.fsm.state == ST_OPENED)
fsm_Reopen(&arg->bundle->ncp.ipcp.fsm);
memset(&ncp->ipcp.cfg.my_range, '\0', sizeof ncp->ipcp.cfg.my_range);
memset(&ncp->ipcp.cfg.peer_range, '\0', sizeof ncp->ipcp.cfg.peer_range);
ncp->ipcp.cfg.HaveTriggerAddress = 0;
ncp->ipcp.cfg.netmask.s_addr = INADDR_ANY;
iplist_reset(&ncp->ipcp.cfg.peer_list);
if (!ncprange_aton(&ncp->ipcp.cfg.my_range, ncp, arg->argv[arg->argn]))
ncp->ipcp.ifmask = ncp->ipcp.cfg.netmask =
ncp->ipcp.cfg.TriggerAddress = GetIpAddr(arg->argv[arg->argn+3]);
ncp->ipcp.cfg.HaveTriggerAddress = 1;
ncpaddr_getip4(&ncpaddr, &ncp->ipcp.my_ip);
ncprange_getaddr(&ncp->ipcp.cfg.my_range, &ncpaddr);
if (ncp->ipcp.my_ip.s_addr == INADDR_ANY)
ncprange_setwidth(&ncp->ipcp.cfg.my_range, 0);
&arg->bundle->ncp.ipcp.cfg.fsm.timeout,
&arg->bundle->ncp.ipcp.cfg.fsm.maxreq,
&arg->bundle->ncp.ipcp.cfg.fsm.maxtrm, DEF_FSMTRIES);
ipaddr = arg->bundle->ncp.ipcp.cfg.ns.dns;
ipaddr = arg->bundle->ncp.ipcp.cfg.ns.nbns;
host = arg->bundle->ncp.ipcp.my_ip;
host = arg->bundle->ncp.ipcp.peer_ip;
host = arg->bundle->ncp.ipcp.ns.dns[0];
host = arg->bundle->ncp.ipcp.ns.dns[1];
ncpaddr_setip4(&gw, arg->bundle->ncp.ipcp.peer_ip);
ncprange_setip4host(&dest, arg->bundle->ncp.ipcp.my_ip);
ncprange_setip4host(&dest, arg->bundle->ncp.ipcp.peer_ip);
ncprange_setip4host(&dest, arg->bundle->ncp.ipcp.ns.dns[0]);
ncprange_setip4host(&dest, arg->bundle->ncp.ipcp.ns.dns[1]);
if (arg->bundle->ncp.ipcp.fsm.state == ST_OPENED)
PacketAliasSetAddress(arg->bundle->ncp.ipcp.my_ip);
arg->bundle->ncp.ipcp.cfg.ns.dns_neg &= keep;
arg->bundle->ncp.ipcp.cfg.ns.dns_neg |= add;
arg->bundle->ncp.ipcp.cfg.vj.neg &= keep;
arg->bundle->ncp.ipcp.cfg.vj.neg |= add;
t = &arg->bundle->ncp.ipcp.throughput;
if (arg->bundle->ncp.ipcp.fsm.state == ST_OPENED &&
arg->bundle->ncp.ipcp.my_ip.s_addr == ifa4.s_addr) {
how = arg->bundle->ncp.ipcp.fsm.state == ST_OPENED ||
oin = bundle->ncp.ipcp.throughput.OctetsIn;
oout = bundle->ncp.ipcp.throughput.OctetsOut;
pin = bundle->ncp.ipcp.throughput.PacketsIn;
pout = bundle->ncp.ipcp.throughput.PacketsOut;
nargv[arg] = substip(nargv[arg], "DNS0", bundle->ncp.ipcp.ns.dns[0]);
nargv[arg] = substip(nargv[arg], "DNS1", bundle->ncp.ipcp.ns.dns[1]);
nargv[arg] = substip(nargv[arg], "HISADDR", bundle->ncp.ipcp.peer_ip);
bundle->ncp.ipcp.throughput.OctetsIn);
bundle->ncp.ipcp.throughput.OctetsOut);
bundle->ncp.ipcp.throughput.PacketsIn);
bundle->ncp.ipcp.throughput.PacketsOut);
nargv[arg] = substip(nargv[arg], "MYADDR", bundle->ncp.ipcp.my_ip);
ipcp_LoadDNS(&arg->bundle->ncp.ipcp);
ipcp_RestoreDNS(&arg->bundle->ncp.ipcp);
ipcp_WriteDNS(&arg->bundle->ncp.ipcp);
arg->bundle->ncp.ipcp.ns.writable = 0;
arg->bundle->ncp.ipcp.ns.writable = 1;
struct ipcp;
fsm_Close(&fp->bundle->ncp.ipcp.fsm);
if (bundle->ncp.ipcp.fsm.state != ST_OPENED) {
ipcp_AddInOctets(&bundle->ncp.ipcp, nb);
memcpy(dec->nakend, &ipcp->peer_ip.s_addr, 4);
!ncprange_containsip4(&ipcp->cfg.peer_range, ip)) {
if (ncprange_contains(&ipcp->cfg.peer_range, &iface->addr[n].peer)) {
memcpy(dec->nakend, &ipcp->peer_ip.s_addr, 4);
ipcp->peer_ip = ip;
struct ipcp *ipcp = fsm2ipcp(fp);
ipcp->peer_req = 1;
ipcp_ValidateReq(ipcp, ipaddr, dec);
if (ncprange_containsip4(&ipcp->cfg.my_range, ipaddr)) {
inet_ntoa(ipcp->my_ip));
ipcp->my_ip = ipaddr;
ncpaddr_setip4(&ncpaddr, ipcp->my_ip);
fsm_Close(&ipcp->fsm);
ipcp->peer_reject |= (1 << opt->hdr.id);
if (!IsAccepted(ipcp->cfg.vj.neg))
ipcp->heis1172 = 1;
ipcp->peer_compproto = compproto;
ipcp->peer_compproto = compproto;
ipcp->heis1172 = 0;
ipcp->heis1172 = 0;
tbuff, ipcp->my_compproto, compproto);
ipcp->my_compproto = compproto;
ipcp->peer_reject |= (1 << opt->hdr.id);
if (!IsAccepted(ipcp->cfg.ns.dns_neg)) {
ipcp->my_reject |= (1 << (opt->hdr.id - TY_ADJUST_NS));
have_ip = ipcp->ns.dns[opt->hdr.id == TY_PRIMARY_DNS ? 0 : 1];
ipaddr.s_addr == ipcp->ns.dns[1].s_addr) {
ipcp->ns.dns[0] = ipcp->ns.dns[1];
ipcp->ns.dns[1] = have_ip;
have_ip = ipcp->ns.dns[0];
if (IsEnabled(ipcp->cfg.ns.dns_neg)) {
memcpy(&ipcp->ns.dns[opt->hdr.id == TY_PRIMARY_DNS ? 0 : 1].s_addr,
ipcp->peer_reject |= (1 << (opt->hdr.id - TY_ADJUST_NS));
ipcp->cfg.ns.nbns[opt->hdr.id == TY_PRIMARY_NBNS ? 0 : 1].s_addr;
ipcp->my_reject |= (1 << (opt->hdr.id - TY_ADJUST_NS));
ipcp->my_reject |= (1 << opt->hdr.id);
if (ipcp->ns.writable) {
if (!ipcp_WriteDNS(ipcp)) {
ipcp->peer_reject |= (1 << (TY_PRIMARY_DNS - TY_ADJUST_NS));
ipcp->peer_reject |= (1 << (TY_SECONDARY_DNS - TY_ADJUST_NS));
if (mode_type == MODE_REQ && !ipcp->peer_req) {
ipcp->peer_req = 1;
ipcp_ValidateReq(ipcp, ipaddr, dec);
fsm_Input(&bundle->ncp.ipcp.fsm, bp);
struct ipcp *ipcp = &bundle->ncp.ipcp;
memset(&ipcp->cfg.peer_range, '\0', sizeof ipcp->cfg.peer_range);
iplist_reset(&ipcp->cfg.peer_list);
ipcp->peer_ip = hisaddr;
ncprange_setip4host(&ipcp->cfg.peer_range, hisaddr);
ncprange_getip4addr(&ipcp->cfg.my_range, &myaddr);
return ipcp_SetIPaddress(ipcp, myaddr, hisaddr);
struct ipcp *ipcp = &ncp->ipcp;
memset(&ipcp->cfg.peer_range, '\0', sizeof ipcp->cfg.peer_range);
iplist_reset(&ipcp->cfg.peer_list);
iplist_setsrc(&ipcp->cfg.peer_list, hisaddr);
if (iplist_isvalid(&ipcp->cfg.peer_list)) {
iplist_setrandpos(&ipcp->cfg.peer_list);
ipcp->peer_ip = ChooseHisAddr(bundle, ipcp->my_ip);
if (ipcp->peer_ip.s_addr == INADDR_ANY) {
log_Printf(LogWARN, "%s: None available !\n", ipcp->cfg.peer_list.src);
ncprange_setip4host(&ipcp->cfg.peer_range, ipcp->peer_ip);
} else if (ncprange_aton(&ipcp->cfg.peer_range, ncp, hisaddr) != 0) {
if (ncprange_family(&ipcp->cfg.my_range) != AF_INET) {
ncprange_getip4addr(&ipcp->cfg.my_range, &myaddr);
ncprange_getip4addr(&ipcp->cfg.peer_range, &ipcp->peer_ip);
if (setaddr && !ipcp_SetIPaddress(ipcp, myaddr, ipcp->peer_ip))
ncpaddr_setip4(&ncpaddr, ipcp->peer_ip);
ipcp_QueueLen(struct ipcp *ipcp)
for (q = ipcp->Queue; q < ipcp->Queue + IPCP_QUEUES(ipcp); q++)
ipcp_PushPacket(struct ipcp *ipcp, struct link *l)
struct bundle *bundle = ipcp->fsm.bundle;
if (ipcp->fsm.state != ST_OPENED)
queue = ipcp->Queue + IPCP_QUEUES(ipcp) - 1;
ipcp_AddOutOctets(ipcp, m_len);
} while (queue-- != ipcp->Queue);
ipcp_AddInOctets(struct ipcp *ipcp, int n)
throughput_addin(&ipcp->throughput, n);
ipcp_AddOutOctets(struct ipcp *ipcp, int n)
throughput_addout(&ipcp->throughput, n);
ipcp_LoadDNS(struct ipcp *ipcp)
ipcp->ns.dns[0].s_addr = ipcp->ns.dns[1].s_addr = INADDR_NONE;
if (ipcp->ns.resolv != NULL) {
free(ipcp->ns.resolv);
ipcp->ns.resolv = NULL;
if (ipcp->ns.resolv_nons != NULL) {
free(ipcp->ns.resolv_nons);
ipcp->ns.resolv_nons = NULL;
ipcp->ns.resolver = 0;
if ((ipcp->ns.resolv_nons = (char *)malloc(st.st_size + 1)) == NULL)
else if ((ipcp->ns.resolv = (char *)malloc(st.st_size + 1)) == NULL) {
free(ipcp->ns.resolv_nons);
ipcp->ns.resolv_nons = NULL;
} else if ((got = read(fd, ipcp->ns.resolv, st.st_size)) != st.st_size) {
free(ipcp->ns.resolv_nons);
ipcp->ns.resolv_nons = NULL;
free(ipcp->ns.resolv);
ipcp->ns.resolv = NULL;
ipcp->ns.resolv[st.st_size] = '\0';
ipcp->ns.resolver = 1;
cp_nons = ipcp->ns.resolv_nons;
cp = ipcp->ns.resolv;
if (n < 2 && inet_aton(cp, ipcp->ns.dns))
while (cp_nons >= ipcp->ns.resolv_nons && *cp_nons == '\n')
if (n == 2 && ipcp->ns.dns[0].s_addr == INADDR_ANY) {
ipcp->ns.dns[0].s_addr = ipcp->ns.dns[1].s_addr;
ipcp->ns.dns[1].s_addr = INADDR_ANY;
bundle_AdjustDNS(ipcp->fsm.bundle);
ipcp_WriteDNS(struct ipcp *ipcp)
if (ipcp->ns.dns[0].s_addr == INADDR_ANY &&
ipcp->ns.dns[1].s_addr == INADDR_ANY) {
if (ipcp->ns.dns[0].s_addr == INADDR_ANY) {
ipcp->ns.dns[0].s_addr = ipcp->ns.dns[1].s_addr;
ipcp->ns.dns[1].s_addr = INADDR_ANY;
if (ipcp->ns.resolv_nons)
fputs(ipcp->ns.resolv_nons, fp);
paddr = inet_ntoa(ipcp->ns.dns[0]);
if (ipcp->ns.dns[1].s_addr != INADDR_ANY &&
ipcp->ns.dns[1].s_addr != INADDR_NONE &&
ipcp->ns.dns[1].s_addr != ipcp->ns.dns[0].s_addr) {
paddr = inet_ntoa(ipcp->ns.dns[1]);
ipcp_RestoreDNS(struct ipcp *ipcp)
if (ipcp->ns.resolver) {
len = strlen(ipcp->ns.resolv);
if ((got = write(fd, ipcp->ns.resolv, len)) != len) {
struct ipcp *ipcp = &arg->bundle->ncp.ipcp;
prompt_Printf(arg->prompt, "%s [%s]\n", ipcp->fsm.name,
State2Nam(ipcp->fsm.state));
if (ipcp->fsm.state == ST_OPENED) {
inet_ntoa(ipcp->peer_ip), vj2asc(ipcp->peer_compproto));
inet_ntoa(ipcp->my_ip), vj2asc(ipcp->my_compproto));
(unsigned long)ipcp_QueueLen(ipcp));
" REQ%s, %u Term REQ%s\n", ipcp->cfg.fsm.timeout,
ipcp->cfg.fsm.maxreq, ipcp->cfg.fsm.maxreq == 1 ? "" : "s",
ipcp->cfg.fsm.maxtrm, ipcp->cfg.fsm.maxtrm == 1 ? "" : "s");
ncprange_ntoa(&ipcp->cfg.my_range));
if (ipcp->cfg.HaveTriggerAddress)
inet_ntoa(ipcp->cfg.TriggerAddress));
"compression)\n", command_ShowNegval(ipcp->cfg.vj.neg),
ipcp->cfg.vj.slots, ipcp->cfg.vj.slotcomp ? "with" : "without");
if (iplist_isvalid(&ipcp->cfg.peer_list))
ipcp->cfg.peer_list.src);
ncprange_ntoa(&ipcp->cfg.peer_range));
ipcp->cfg.ns.dns[0].s_addr == INADDR_NONE ?
"none" : inet_ntoa(ipcp->cfg.ns.dns[0]));
if (ipcp->cfg.ns.dns[1].s_addr != INADDR_NONE)
inet_ntoa(ipcp->cfg.ns.dns[1]));
command_ShowNegval(ipcp->cfg.ns.dns_neg));
ipcp->ns.dns[0].s_addr == INADDR_NONE ?
"none" : inet_ntoa(ipcp->ns.dns[0]));
if (ipcp->ns.dns[1].s_addr != INADDR_NONE &&
ipcp->ns.dns[1].s_addr != ipcp->ns.dns[0].s_addr)
inet_ntoa(ipcp->ns.dns[1]));
inet_ntoa(ipcp->cfg.ns.nbns[0]));
inet_ntoa(ipcp->cfg.ns.nbns[1]));
throughput_disp(&ipcp->throughput, arg->prompt);
arg->bundle->ncp.ipcp.cfg.vj.slots = slots;
arg->bundle->ncp.ipcp.cfg.vj.slotcomp = 1;
arg->bundle->ncp.ipcp.cfg.vj.slotcomp = 0;
ipcp_Init(struct ipcp *ipcp, struct bundle *bundle, struct link *l,
fsm_Init(&ipcp->fsm, "IPCP", PROTO_IPCP, 1, IPCP_MAXCODE, LogIPCP,
ipcp->cfg.vj.slots = DEF_VJ_STATES;
ipcp->cfg.vj.slotcomp = 1;
memset(&ipcp->cfg.my_range, '\0', sizeof ipcp->cfg.my_range);
ipcp->cfg.netmask.s_addr = INADDR_ANY;
ncprange_setip4(&ipcp->cfg.my_range, host, ipcp->cfg.netmask);
ncprange_setip4(&ipcp->cfg.peer_range, ipcp->cfg.netmask, ipcp->cfg.netmask);
iplist_setsrc(&ipcp->cfg.peer_list, "");
ipcp->cfg.HaveTriggerAddress = 0;
ipcp->cfg.ns.dns[0].s_addr = INADDR_NONE;
ipcp->cfg.ns.dns[1].s_addr = INADDR_NONE;
ipcp->cfg.ns.dns_neg = 0;
ipcp->cfg.ns.nbns[0].s_addr = INADDR_ANY;
ipcp->cfg.ns.nbns[1].s_addr = INADDR_ANY;
ipcp->cfg.fsm.timeout = DEF_FSMRETRY;
ipcp->cfg.fsm.maxreq = DEF_FSMTRIES;
ipcp->cfg.fsm.maxtrm = DEF_FSMTRIES;
ipcp->cfg.vj.neg = NEG_ENABLED|NEG_ACCEPTED;
memset(&ipcp->vj, '\0', sizeof ipcp->vj);
ipcp->ns.resolv = NULL;
ipcp->ns.resolv_nons = NULL;
ipcp->ns.writable = 1;
ipcp_LoadDNS(ipcp);
throughput_init(&ipcp->throughput, SAMPLE_PERIOD);
memset(ipcp->Queue, '\0', sizeof ipcp->Queue);
ipcp_Setup(ipcp, INADDR_NONE);
ipcp_Destroy(struct ipcp *ipcp)
throughput_destroy(&ipcp->throughput);
if (ipcp->ns.resolv != NULL) {
free(ipcp->ns.resolv);
ipcp->ns.resolv = NULL;
if (ipcp->ns.resolv_nons != NULL) {
free(ipcp->ns.resolv_nons);
ipcp->ns.resolv_nons = NULL;
ipcp_SetLink(struct ipcp *ipcp, struct link *l)
ipcp->fsm.link = l;
ipcp_Setup(struct ipcp *ipcp, u_int32_t mask)
struct iface *iface = ipcp->fsm.bundle->iface;
ipcp->fsm.open_mode = 0;
ipcp->ifmask.s_addr = mask == INADDR_NONE ? ipcp->cfg.netmask.s_addr : mask;
if (iplist_isvalid(&ipcp->cfg.peer_list)) {
if ((pos = iplist_ip2pos(&ipcp->cfg.peer_list, peer)) != -1) {
ncpaddr_setip4(&ipaddr, iplist_setcurpos(&ipcp->cfg.peer_list, pos));
ncpaddr_setip4(&ipaddr, iplist_setrandpos(&ipcp->cfg.peer_list));
ncprange_sethost(&ipcp->cfg.peer_range, &ipaddr);
ipcp->heis1172 = 0;
ipcp->peer_req = 0;
ncprange_getip4addr(&ipcp->cfg.peer_range, &ipcp->peer_ip);
ipcp->peer_compproto = 0;
if (ipcp->cfg.HaveTriggerAddress) {
ipcp->my_ip = ipcp->cfg.TriggerAddress;
inet_ntoa(ipcp->cfg.TriggerAddress));
if (ncprange_contains(&ipcp->cfg.my_range, &ipaddr)) {
ncpaddr_getip4(&ipaddr, &ipcp->my_ip);
ncprange_getip4addr(&ipcp->cfg.my_range, &ipcp->my_ip);
if (IsEnabled(ipcp->cfg.vj.neg)
|| (ipcp->fsm.bundle->radius.valid && ipcp->fsm.bundle->radius.vj)
ipcp->my_compproto = (PROTO_VJCOMP << 16) +
((ipcp->cfg.vj.slots - 1) << 8) +
ipcp->cfg.vj.slotcomp;
ipcp->my_compproto = 0;
sl_compress_init(&ipcp->vj.cslc, ipcp->cfg.vj.slots - 1);
ipcp->peer_reject = 0;
ipcp->my_reject = 0;
if (ipcp->cfg.ns.dns[0].s_addr != INADDR_NONE)
memcpy(ipcp->ns.dns, ipcp->cfg.ns.dns, sizeof ipcp->ns.dns);
ipcp_proxyarp(struct ipcp *ipcp,
struct bundle *bundle = ipcp->fsm.bundle;
ipcp_SetIPaddress(struct ipcp *ipcp, struct in_addr myaddr,
struct bundle *bundle = ipcp->fsm.bundle;
if (ipcp->ifmask.s_addr != INADDR_ANY &&
(ipcp->ifmask.s_addr & mask.s_addr) == mask.s_addr)
ncprange_setip4mask(&myrange, ipcp->ifmask);
for (f = 0; f < bundle->ncp.ipcp.cfg.peer_list.nItems; f++) {
try = iplist_next(&bundle->ncp.ipcp.cfg.peer_list);
if (ipcp_SetIPaddress(&bundle->ncp.ipcp, gw, try)) {
if (f == bundle->ncp.ipcp.cfg.peer_list.nItems) {
struct ipcp *ipcp = fsm2ipcp(fp);
fp->FsmTimer.load = ipcp->cfg.fsm.timeout * SECTICKS;
fp->restart = ipcp->cfg.fsm.maxreq;
fp->restart = ipcp->cfg.fsm.maxtrm;
struct ipcp *ipcp = fsm2ipcp(fp);
if ((p && !physical_IsSync(p)) || !REJECTED(ipcp, TY_IPADDR)) {
memcpy(o->data, &ipcp->my_ip.s_addr, 4);
if (ipcp->my_compproto && !REJECTED(ipcp, TY_COMPPROTO)) {
if (ipcp->heis1172) {
req.proto = htons(ipcp->my_compproto >> 16);
req.slots = (ipcp->my_compproto >> 8) & 255;
req.compcid = ipcp->my_compproto & 1;
if (IsEnabled(ipcp->cfg.ns.dns_neg)) {
if (!REJECTED(ipcp, TY_PRIMARY_DNS - TY_ADJUST_NS)) {
memcpy(o->data, &ipcp->ns.dns[0].s_addr, 4);
if (!REJECTED(ipcp, TY_SECONDARY_DNS - TY_ADJUST_NS)) {
memcpy(o->data, &ipcp->ns.dns[1].s_addr, 4);
struct ipcp *ipcp = fsm2ipcp(fp);
throughput_start(&ipcp->throughput, "IPCP throughput",
fp->more.reqs = fp->more.naks = fp->more.rejs = ipcp->cfg.fsm.maxreq * 3;
ipcp->peer_req = 0;
struct ipcp *ipcp = fsm2ipcp(fp);
throughput_stop(&ipcp->throughput);
throughput_log(&ipcp->throughput, LogIPCP, NULL);
ipcp_IfaceAddrAdded(struct ipcp *ipcp, const struct iface_addr *addr)
struct bundle *bundle = ipcp->fsm.bundle;
ipcp_proxyarp(ipcp, arp_SetProxy, addr);
ipcp_IfaceAddrDeleted(struct ipcp *ipcp, const struct iface_addr *addr)
struct bundle *bundle = ipcp->fsm.bundle;
ipcp_proxyarp(ipcp, arp_ClearProxy, addr);
struct ipcp *ipcp = fsm2ipcp(fp);
snprintf(addr, sizeof addr, "%s", inet_ntoa(ipcp->my_ip));
fp->bundle->links, RAD_STOP, &ipcp->peer_ip, &ipcp->ifmask,
&ipcp->throughput);
ipcp_Setup(ipcp, INADDR_NONE);
ipcp_InterfaceUp(struct ipcp *ipcp)
if (!ipcp_SetIPaddress(ipcp, ipcp->my_ip, ipcp->peer_ip)) {
if (!iface_SetFlags(ipcp->fsm.bundle->iface->name, IFF_UP)) {
ipcp->fsm.bundle->iface->name);
if (ipcp->fsm.bundle->NatEnabled)
PacketAliasSetAddress(ipcp->my_ip);
struct ipcp *ipcp = fsm2ipcp(fp);
snprintf(tbuff, sizeof tbuff, "%s", inet_ntoa(ipcp->my_ip));
tbuff, inet_ntoa(ipcp->peer_ip));
if (ipcp->peer_compproto >> 16 == PROTO_VJCOMP)
sl_compress_init(&ipcp->vj.cslc, (ipcp->peer_compproto >> 8) & 255);
if (!ipcp_InterfaceUp(ipcp))
RAD_START, &ipcp->peer_ip, &ipcp->ifmask, &ipcp->throughput);
fp->more.reqs = fp->more.naks = fp->more.rejs = ipcp->cfg.fsm.maxreq * 3;
ipcp_ValidateReq(struct ipcp *ipcp, struct in_addr ip, struct fsm_decode *dec)
struct bundle *bundle = ipcp->fsm.bundle;
if (iplist_isvalid(&ipcp->cfg.peer_list)) {
ncprange_getip4addr(&ipcp->cfg.my_range, &myaddr);
iplist_ip2pos(&ipcp->cfg.peer_list, ip) < 0 ||
!ipcp_SetIPaddress(ipcp, myaddr, ip)) {
if (iplist_ip2pos(&ipcp->cfg.peer_list, peer) >= 0) {
ipcp->peer_ip = peer;
ipcp->peer_ip = ChooseHisAddr(bundle, myaddr);
if (ipcp->peer_ip.s_addr == INADDR_ANY) {
#define fsm2ipcp(fp) (fp->proto == PROTO_IPCP ? (struct ipcp *)fp : NULL)
#define IPCP_QUEUES(ipcp) (sizeof ipcp->Queue / sizeof ipcp->Queue[0])
extern void ipcp_Init(struct ipcp *, struct bundle *, struct link *,
extern void ipcp_Destroy(struct ipcp *);
extern void ipcp_Setup(struct ipcp *, u_int32_t);
extern void ipcp_SetLink(struct ipcp *, struct link *);
extern void ipcp_AddInOctets(struct ipcp *, int);
extern void ipcp_AddOutOctets(struct ipcp *, int);
extern void ipcp_IfaceAddrAdded(struct ipcp *, const struct iface_addr *);
extern void ipcp_IfaceAddrDeleted(struct ipcp *, const struct iface_addr *);
extern int ipcp_InterfaceUp(struct ipcp *);
extern int ipcp_WriteDNS(struct ipcp *);
extern void ipcp_RestoreDNS(struct ipcp *);
extern void ipcp_LoadDNS(struct ipcp *);
extern size_t ipcp_QueueLen(struct ipcp *);
extern int ipcp_PushPacket(struct ipcp *, struct link *);
ncprange_family(&bundle->ncp.ipcp.cfg.peer_range) == AF_UNSPEC) {
addr = arg->bundle->ncp.ipcp.my_ip;
if (arg->bundle->ncp.ipcp.my_ip.s_addr == INADDR_ANY)
ncprange_getip4addr(&arg->bundle->ncp.ipcp.cfg.my_range, &addr);
addr = arg->bundle->ncp.ipcp.my_ip;
mp->cfg.enddisc.len = sizeof arg->bundle->ncp.ipcp.my_ip.s_addr;
if (arg->bundle->ncp.ipcp.my_ip.s_addr == INADDR_ANY)
ncprange_getip4addr(&arg->bundle->ncp.ipcp.cfg.my_range, &addr);
ipcp_Init(&ncp->ipcp, bundle, &bundle->links->physical->link,
ipcp_Destroy(&ncp->ipcp);
fsm_Up(&ncp->ipcp.fsm);
fsm_Open(&ncp->ipcp.fsm);
ipcp_IfaceAddrAdded(&ncp->ipcp, addr);
ipcp_IfaceAddrDeleted(&ncp->ipcp, addr);
ipcp_SetLink(&ncp->ipcp, l);
struct ipcp *ipcp = &ncp->ipcp;
if (pri >= IPCP_QUEUES(ipcp)) {
m_enqueue(ipcp->Queue + pri, bp);
if (pri >= IPV6CP_QUEUES(ipcp)) {
result = ipcp_QueueLen(&ncp->ipcp);
struct ipcp *ipcp = &ncp->ipcp;
for (q = ipcp->Queue; q < ipcp->Queue + IPCP_QUEUES(ipcp); q++)
if ((res = ipcp_PushPacket(&bundle->ncp.ipcp, l)))
res = ipcp_PushPacket(&bundle->ncp.ipcp, l);
res = ipcp_PushPacket(&bundle->ncp.ipcp, l);
n = !!(ncp->ipcp.fsm.state == ST_OPENED);
if (ncp->ipcp.fsm.state > ST_CLOSED ||
ncp->ipcp.fsm.state == ST_STARTING)
if (ncp->ipcp.fsm.state > ST_CLOSED ||
ncp->ipcp.fsm.state == ST_STARTING)
fsm_Close(&ncp->ipcp.fsm);
fsm2initial(&ncp->ipcp.fsm);
struct ipcp ipcp; /* Our IPCP FSM */
range->ncprange_ip4addr = ncp->ipcp.peer_ip;
range->ncprange_ip4addr = ncp->ipcp.my_ip;
range->ncprange_ip4addr = ncp->ipcp.ns.dns[0];
range->ncprange_ip4addr = ncp->ipcp.ns.dns[1];
if (p->bundle->ncp.ipcp.fsm.state == ST_OPENED)
ncpaddr_setip4(&gw, bundle->ncp.ipcp.peer_ip);
if (bundle->ncp.ipcp.ns.dns[0].s_addr == INADDR_NONE)
if (bundle->ncp.ipcp.ns.dns[1].s_addr == INADDR_NONE)
arg->bundle->ncp.ipcp.vj.slstat.sls_compressed,
arg->bundle->ncp.ipcp.vj.slstat.sls_packets);
arg->bundle->ncp.ipcp.vj.slstat.sls_misses,
arg->bundle->ncp.ipcp.vj.slstat.sls_searches);
arg->bundle->ncp.ipcp.vj.slstat.sls_compressedin,
arg->bundle->ncp.ipcp.vj.slstat.sls_uncompressedin);
arg->bundle->ncp.ipcp.vj.slstat.sls_errorin,
arg->bundle->ncp.ipcp.vj.slstat.sls_tossed);
VjUncompressTcp(struct ipcp *ipcp, struct mbuf *bp, u_char type)
len = sl_uncompress_tcp(&bufp, len, type, &ipcp->vj.cslc, &ipcp->vj.slstat,
(ipcp->my_compproto >> 8) & 255);
len = sl_uncompress_tcp(&bufp, olen, type, &ipcp->vj.cslc, &ipcp->vj.slstat,
(ipcp->my_compproto >> 8) & 255);
return VjUncompressTcp(&bundle->ncp.ipcp, bp, type);
u_short cproto = bundle->ncp.ipcp.peer_compproto >> 16;
type = sl_compress_tcp(bp, pip, &bundle->ncp.ipcp.vj.cslc,
&bundle->ncp.ipcp.vj.slstat,
bundle->ncp.ipcp.peer_compproto & 0xff);
struct ipcp;