spfutil.c

BCAST Implementation for NS2

      case LOG_NEWGRP:
        return("New group");
      case LOG_GRPEXP:
        return("Group expired");
      case IGMP_RCV:
	return("Received IGMP packet, type");
      case LOG_SPFDEBUG:
	return("DEBUG");
      case LOG_KRTSYNC:
	return("Synching kernel routing entry");
      case LOG_REMNANT:
	return("Deleting remnant");
      case LOG_DEBUGGING:
	return("");
      case LOG_HITLESSPREP:
	return("Preparing for hitless restart");
      case LOG_PHASEFAIL:
	return("Hitless restart preparation failure:");
      case LOG_PREPDONE:
	return("Hitless restart preparation complete");
      case LOG_RESIGNDR:
	return("Resigned DR");
      case LOG_GRACEACKS:
	return("Grace-LSAs acked");
      case LOG_GRACERX:
	return("Grace-LSA received");
      case LOG_HELPER_START:
        return("Entering helper mode");
      case LOG_HELPER_STOP:
	return("Leaving helper mode");
      case LOG_GRACE_REJECT:
	return("Rejecting grace request");
      case LOG_HTLEXIT:
	return("Exiting hitless restart:");
      default:
	break;
    }
    return("(Unknown)");
}

/* Finish the printing of a log message.
 * If none in progress, does nothing.
 */

void OSPF::logflush()

{
    if (logptr == &logbuf[0])
	return;
    // Null terminate string
    *logptr = '\0';
    sys->sys_spflog(logno, &logbuf[0]);
    logptr = &logbuf[0];
}
 
/* Begin to print out a log message.
 */

bool OSPF::spflog(int msgno, int priority)

{
    // flush any pending log message
    logflush();

    if (msgno > MAXLOG)
	return(false);
    else if (disabled_msgno[msgno])
	return(false);
    else if (!enabled_msgno[msgno] && priority < base_priority)
	return(false);

    // Reset pointer into logging buffer
    logno = msgno;
    log(msgtext(msgno));
    log(" ");
    return(true);
}

// Packet type strings
const char *pktype[] = {
    "",
    "Hello",
    "DD",
    "LsReq",
    "LsUpd",
    "LsAck",
};

/* Standard functions to print strings, integers,
 * and characters to the logging stream.
 */

void OSPF::log(const char *s)

{
    int len;
    len = strlen(s);
    if (logptr + len < logend) {
        memcpy(logptr, s, len);
	logptr += len;
    }
}

void OSPF::log(int val)

{
    char temp[20];
    sprintf(temp, "%d", val);
    log(temp);
}

/* Print information about a packet on the logging
 * stream.
 */

void OSPF::log(Pkt *p)

{
    int ptype=p->spfpkt->ptype;
    InAddr s_addr;
    InAddr d_addr;

    if (ptype >= SPT_HELLO && ptype <= SPT_LSACK)
	log(pktype[ptype]);
    else {
	log("Pkt type ");
	log(ptype);
    }
    s_addr = ntoh32(p->iphdr->i_src);
    d_addr = ntoh32(p->iphdr->i_dest);
    log(" ");
    log(&s_addr);
    log("->");
    log(&d_addr);
}

/* Print information about an IP packet on the logging
 * stream.
 */

void OSPF::log(InPkt *p)

{
    InAddr s_addr;
    InAddr d_addr;

    s_addr = ntoh32(p->i_src);
    d_addr = ntoh32(p->i_dest);
    log(" ");
    log(&s_addr);
    log("->");
    log(&d_addr);
}

/* Print LSA information onto the logging stream.
 */

const char *lsatype[] = {
    "",
    "rtrlsa",
    "netlsa",
    "netsumm",
    "asbrsumm",
    "extlsa",
    "grplsa",
    "t7lsa",
    "exattr",
};

void OSPF::log(LShdr *hdr)

{
    int type=hdr->ls_type;
    InAddr lsid=ntoh32(hdr->ls_id);
    InAddr advrtr=ntoh32(hdr->ls_org);

    log("LSA(");
    log(type);
    log(",");
    log(&lsid);
    log(",");
    log(&advrtr);
    log(")");
}

void OSPF::log(LSA *lsap)

{
    int type=lsap->ls_type();
    InAddr lsid=lsap->ls_id();
    InAddr advrtr=lsap->adv_rtr();

    log("LSA(");
    log(type);
    log(",");
    log(&lsid);
    log(",");
    log(&advrtr);
    log(")");
}

/* Print Iterface identifier onto the logging stream.
 */

void OSPF::log(SpfArea *ap)

{
    InAddr addr;

    addr = ap->a_id;
    log(" Area ");
    log(&addr);
}

/* Print Iterface identifier onto the logging stream.
 */

void OSPF::log(SpfIfc *ip)

{
    if (ip->is_virtual()) {
	log(" VL ");
	log(ip->transit_area());
	log(" Endpt ");
	log(ip->vl_endpt());
    }
    else {
	log(" Ifc ");
	if (ip->unnumbered())
	    log(sys->phyname(ip->if_phyint));
	else
	    log(&ip->if_addr);
    }
}

/* Print neighbor identifer onto the logging stream.
 */

void OSPF::log(SpfNbr *np)

{
    log(" Nbr ");
    if (np->ifc()->is_multi_access())
	log(&np->n_addr);
    else {
	log(&np->n_id);
	log(np->n_ifp);
    }
}

/* Print an IP routing tabe entry
 */

void OSPF::log(INrte *rte)

{
    InAddr net; 
    int prefix_len;
    int bit;

    net = rte->net();
    prefix_len = 32;
    bit = 1;
    while (prefix_len > 0 && (bit & rte->mask()) == 0) {
	prefix_len--;
	bit = bit << 1;
    }
    log(&net);
    log("/");
    log(prefix_len);
    log(" ");
    switch (rte->r_type) {
      case RT_SPF:	// Intra-area
	log("intra-area cost ");
	log(rte->cost);
	log(" ");
	break;
      case RT_SPFIA:	// Inter-area
	log("inter-area cost ");
	log(rte->cost);
	log(" ");
	break;
      case RT_EXTT1:	// External type 1
	log("external type 1 cost ");
	log(rte->cost);
	log(" ");
	break;
      case RT_EXTT2:	// External type 2
	log("external type 2 cost ");
	log(rte->t2cost);
	log(" ");
	break;
      case RT_REJECT:	// Reject route, for own area ranges
	log("reject ");
	break;
      case RT_STATIC:	// External routes we're importing
	log("static cost ");
	log(rte->t2cost == Infinity ? rte->cost : rte->t2cost);
	log(" ");
	break;
      default:
      case RT_NONE:	// Deleted, inactive
	break;
    }
}

/* Print out IP addresses. Assumed that they are passed in machine
 * byte-order.
 */

void OSPF::log(InAddr *addr)

{
    byte *ptr;
    uns32 netaddr;

    netaddr = hton32(*addr);
    ptr = (byte *) &netaddr;

    log((int) ptr[0]);
    log(".");
    log((int) ptr[1]);
    log(".");
    log((int) ptr[2]);
    log(".");
    log((int) ptr[3]);
}

/* Log a network/mask combination in CIDR format.
 */

void OSPF::log(InAddr *addr, InMask *mask)

{
    int prefix_len;
    int bit;

    prefix_len = 32;
    bit = 1;
    while (prefix_len > 0 && (bit & *mask) == 0) {
	prefix_len--;
	bit = bit << 1;
    }

    log(addr);
    log("/");
    log(prefix_len);
}


/* Initialize the OspfSysCalls class. Time begins at zero.
 */

OspfSysCalls::OspfSysCalls()

{	
    sys_etime.sec = 0;
    sys_etime.msec = 0;
}

/* Decide whether a multicast datagram's receiving interface
 * is valid, according to the matching cache entry.
 */

bool MCache::valid_incoming(int in_phyint)

{
    int i;

    if (in_phyint == -1)
        return(true);
    for (i = 0; i < n_upstream; i++) {
        if (up_phys[i] == in_phyint)
	    return(true);
    }

    return(false);
}

/* Decide whether a multicast datagram would be forwarded
 * out a given interface, and if so, what the minimum ttl
 * would have to be.
 */

bool MCache::valid_outgoing(int phyint, InAddr nbr_addr, byte &ttl)

{
    int i;

    for (i = 0; i < n_downstream; i++) {
        if (down_str[i].phyint != phyint)
	    continue;
	if (down_str[i].nbr_addr != 0 && down_str[i].nbr_addr != nbr_addr)
	    continue;
	// We would forward. Set necessary ttl for packet
	ttl = down_str[i].ttl;
	return(true);
    }

    return(false);
}