Example #1
0
/*------------------------------------------------------------------------
 *  netnum  -  compute the network portion of a given IP address
 *------------------------------------------------------------------------
 */
IPaddr
netnum(IPaddr ipa)
{
	IPaddr	mask = ~0;

	if (IP_CLASSA(ipa)) mask = hl2net(0xff000000);
	if (IP_CLASSB(ipa)) mask = hl2net(0xffff0000);
	if (IP_CLASSC(ipa)) mask = hl2net(0xffffff00);
	return ipa & mask;
}
/*------------------------------------------------------------------------
 *  dd_queue - generate Data Description packets
 *------------------------------------------------------------------------
 */
void
dd_queue(struct ospf_if *pif, struct ospf_nb *pnb)
{
	struct	ep	*pep;
	struct	ip	*pip;
	struct	ospf	*po;
	struct	ospf_dd	*pdd;

	pep = ospfddtmpl(pif);
	if (pep == 0)
		return;
	pip = (struct ip *)pep->ep_data;
	po = (struct ospf *)pip->ip_data;
	pdd = (struct ospf_dd *)po->ospf_data;

	if (pnb->nb_state == NBS_EXSTART) {
		pdd->dd_control = DDC_INIT | DDC_MORE | DDC_MSTR;
		pdd->dd_seq = hl2net(pnb->nb_seq);
		if (enq(pnb->nb_dsl, pep, 0) < 0)
			freebuf(pep);
		dd_xmit(pif, pnb);
		pnb->nb_trexmt = pif->if_rintv;
		return;
	}
	/* else we're in EXCHANGE state */
	lss_build(pif, pnb, pep);
	dd_xmit(pif, pnb);
	if (pnb->nb_master)
		pnb->nb_trexmt = pif->if_rintv;
}
Example #3
0
/*------------------------------------------------------------------------
 *  netmask  -  set the default mask for the given net
 *------------------------------------------------------------------------
 */
IPaddr
netmask(IPaddr net)
{
	IPaddr	netpart;
	int	i;

	if (net == 0)
		return net;
	/* check for net match (for subnets) */

	netpart = netnum(net);
	for (i=0; i<Net.nif; ++i)
		if (nif[i].ni_svalid && nif[i].ni_ivalid &&
		    nif[i].ni_net == netpart)
			return nif[i].ni_mask;
	if (IP_CLASSA(net)) return hl2net(0xff000000);
	if (IP_CLASSB(net)) return hl2net(0xffff0000);
	if (IP_CLASSC(net)) return hl2net(0xffffff00);
	return ~0;
}
Example #4
0
/**
 * Send an ICMP Echo (Ping) Request.
 * @param dst destination address
 * @param id  ping stream identifier
 * @param seq sequence number
 * @return OK if packet was sent, otherwise SYSERR
 */
syscall icmpEchoRequest(struct netaddr *dst, ushort id, ushort seq)
{
    struct packet *pkt = NULL;
    struct icmpEcho *echo = NULL;
    int result = OK;
    irqmask im;

    ICMP_TRACE("echo request(%d, %d)", id, seq);
    pkt = netGetbuf();
    if (SYSERR == (int)pkt)
    {
        ICMP_TRACE("Failed to acquire packet buffer");
        return SYSERR;
    }

    pkt->len = sizeof(struct icmpEcho);
    pkt->curr -= pkt->len;

    echo = (struct icmpEcho *)pkt->curr;
    echo->id = hs2net(id);
    echo->seq = hs2net(seq);
    /* Our optional data payload includes room for the departure */
    /*  and arrival timestamps, in seconds, milliseconds, and    */
    /*  clock cycles.                                            */
    im = disable();
    echo->timecyc = hl2net(clkcount());
    echo->timetic = hl2net(clkticks);
    echo->timesec = hl2net(clktime);
    restore(im);
    echo->arrivcyc = 0;
    echo->arrivtic = 0;
    echo->arrivsec = 0;

    ICMP_TRACE("Sending Echo Request id = %d, seq = %d, time = %d.%d",
               net2hs(echo->id), net2hs(echo->seq),
               net2hl(echo->timesec), net2hl(echo->timetic));

    result = icmpSend(pkt, ICMP_ECHO, 0, sizeof(struct icmpEcho), dst);
    netFreebuf(pkt);
    return result;
}
Example #5
0
/*-------------------------------------------------------------------------
 * make_bootp_packet -
 *-------------------------------------------------------------------------
 */
static int make_bootp_packet(struct bootp_msg *bptr, int secs)
{
    bzero(bptr, BOOTP_SIZE);
    bptr->op = BOOTREQUEST;
    bptr->htype = AR_HARDWARE;
    bptr->hlen = EP_ALEN;
    bptr->xid = 47;             /* just a random number that's nonzero */
    bptr->secs = hs2net(secs);
    blkcopy(bptr->chaddr, (char *)&(mon_eth[0].ed_paddr), EP_ALEN);
    *(int *)bptr->vend = hl2net(RFC1084);
    bptr->vend[5] = 0xff;
#ifdef DEBUG
    kprintf("Using ethernet address %02x:%02x:%02x:%02x:%02x:%02x\n",
            bptr->chaddr[0], bptr->chaddr[1], bptr->chaddr[2],
            bptr->chaddr[3], bptr->chaddr[4], bptr->chaddr[5]);
#endif
    return(OK);
}
Example #6
0
/*------------------------------------------------------------------------
 *  rwhod  -  Periodically clean cache and (optionally) send rwho packets
 *------------------------------------------------------------------------
 */
PROCESS
rwhod(void)
{
    STATWORD ps;
    char	*p;
    int	i, j;
    struct	rwent	*rwptr;
    struct	rwent	*myptr;
    struct	rwhopac	*rpacptr;
    struct	rw_who	*rwwptr;
    struct	ep	*pep;
    u_long	now;
    int	len;

    /* Initialize rwho information */

    Rwho.rwnent = 1;
    Rwho.rwsend = TRUE;
    getutim(&Rwho.rwbtime);
    myptr = &Rwho.rwcache[0];

    myptr->rwboot = myptr->rwlast = myptr->rwslast = Rwho.rwbtime;
    for (i=0 ; i<3 ; i++)
        myptr->rwload[i] = 0L;
    myptr->rwusers = 1;

    for( ; TRUE ; sleep(RWDELAY) ) {
        if (getname(myptr->rwmach) == SYSERR)
            continue;
        if (p = index(myptr->rwmach, '.'))
            *p = '\0';
        getutim(&now);
        myptr->rwlast = myptr->rwslast = now;
        disable(ps);
        for (i=0 ; i<Rwho.rwnent ; i++) {
            rwptr = &Rwho.rwcache[i];
            if (now - rwptr->rwlast > RWMAXDT) {
                Rwho.rwnent--;
                for (j=i-- ; j<Rwho.rwnent ; j++)
                    Rwho.rwcache[j] = Rwho.rwcache[j+1];
            }
        }
        restore(ps);
        if (!Rwho.rwsend)
            continue;
        pep = (struct ep *)getbuf(Net.netpool);
        rpacptr = (struct rwhopac *)
                  ((struct udp *)
                   (((struct ip *)pep->ep_data)->ip_data))->u_data;
        rpacptr->rw_vers = RWVERSION;
        rpacptr->rw_type= RWSTATUS;
        rpacptr->rw_sndtim = hl2net(now);
        rpacptr->rw_rtim = 0L;
        getname(rpacptr->rw_host);
        if (p = index(rpacptr->rw_host, '.'))
            *p = '\0';
        for (j=0 ; j<RWNLOAD ; j++)
            rpacptr->rw_load[j] = 0L;
        rpacptr->rw_btim = hl2net(Rwho.rwbtime);
        len = RWMINP;
        if ( marked(Shl.shmark) && Shl.shused ) {
            rwwptr = &rpacptr->rw_rww[0];
            strcpy (rwwptr->rw_tty, "Console");
            strncpy(rwwptr->rw_nam, Shl.shuser, RWNLEN);
            rwwptr->rw_ton = hl2net(Shl.shlogon);
            rwwptr->rw_idle = hl2net(now - Shl.shlast);
            len += sizeof(struct rw_who);
        }
        for (i=0; i<(Net.nif-1); ++i) {
            struct	ep	*pep2;

            if (i == NI_LOCAL)
                continue;
            if (nif[i].ni_state != NIS_UP)
                continue;
            pep2 = (struct ep *)getbuf(Net.netpool);
            if (pep2 == (struct ep *)SYSERR)
                break;
            memcpy(pep2, pep, EP_HLEN+IP_ALEN+len);
            udpsend(nif[i].ni_brc, UP_RWHO, UP_RWHO,
                    pep2, len, 1);
        }
        udpsend(nif[i].ni_brc, UP_RWHO, UP_RWHO, pep,
                len, 1);
    }
}
Example #7
0
//------------------------------------------------------------------------
// rwhod - Periodically clean cache and (optionally) send rwho packets
//------------------------------------------------------------------------
PROCESS
rwhod(void)
{
	int i, j;
	struct rwent *rwptr;
	struct rwent *myptr;
	struct rwhopac *rpacptr;
	struct rw_who *rwwptr;
	struct epacket *packet;
	IPaddr mynet;
	long now;
	int len;
	int ps;

	// Initialize rwho information

	Rwho.rwnent = 1;
	Rwho.rwsend = TRUE;
	getutime(&Rwho.rwbtime);
	myptr = &Rwho.rwcache[0];
	getname(myptr->rwmach, RMACLEN);
	myptr->rwboot = myptr->rwlast = myptr->rwslast = Rwho.rwbtime;
	for (i = 0; i < 3; i++)
		myptr->rwload[i] = 0L;
	myptr->rwusers = 1;

	getnet(mynet);
	for (; TRUE; sleep(RWDELAY)) {
		getutime(&now);
		myptr->rwlast = myptr->rwslast = now;
		ps = disable();
		for (i = 0; i < Rwho.rwnent; i++) {
			rwptr = &Rwho.rwcache[i];
			if (now - rwptr->rwlast > RWMAXDT) {
				Rwho.rwnent--;
				for (j = i--; j < Rwho.rwnent; j++)
					Rwho.rwcache[j] =
					    Rwho.rwcache[j + 1];
			}
		}
		restore(ps);
		if (!Rwho.rwsend)
			continue;
		packet = (struct epacket *)getbuf(Net.netpool);
		rpacptr = (struct rwhopac *)
		    ((struct udp *)
		     (((struct ip *)packet->ep_data)->i_data))->u_data;
		rpacptr->rw_vers = RWVERSION;
		rpacptr->rw_type = RWSTATUS;
		rpacptr->rw_sndtim = hl2net(now);
		rpacptr->rw_rtim = 0L;
		getname(rpacptr->rw_host, sizeof(rpacptr->rw_host));
		for (j = 0; j < RWNLOAD; j++)
			rpacptr->rw_load[j] = 0L;
		rpacptr->rw_btim = hl2net(Rwho.rwbtime);
		len = RWMINP;
		if (marked(Shl.shmark) && Shl.shused) {
			rwwptr = &rpacptr->rw_rww[0];
			strlcpy(rwwptr->rw_tty, "Console", RWNLEN);
			strncpy(rwwptr->rw_nam, Shl.shuser, RWNLEN);
			rwwptr->rw_ton = hl2net(Shl.shlogon);
			rwwptr->rw_idle = hl2net(now - Shl.shlast);
			len += sizeof(struct rw_who);
		}
		udpsend(mynet, URWHO, URWHO, packet, len);
	}
}
Example #8
0
/**
 * Sends a reset in response to an incorrect TCP packet
 * @param pkt incoming packet which requires a reset response
 * @param src source IP address of the packet	
 * @param dst destination IP address of the packet	
 */
int tcpSendRst(struct packet *pkt, struct netaddr *src,
               struct netaddr *dst)
{
    struct packet *out;
    struct tcpPkt *tcp;
    struct tcpPkt *outtcp;
    ushort datalen;
    int result;
    ushort tcplen;

    /* Setup packet pointers */
    tcp = (struct tcpPkt *)pkt->curr;
    tcplen = pkt->len - (pkt->curr - pkt->linkhdr);

    /* Verify not sending a reset in response to a reset */
    if (tcp->control & TCP_CTRL_RST)
    {
        return OK;
    }

    /* Get space to construct packet */
    out = netGetbuf();
    if (SYSERR == (int)out)
    {
        return SYSERR;
    }
    out->curr -= TCP_HDR_LEN;
    out->len += TCP_HDR_LEN;

    /* Set TCP header fields */
    outtcp = (struct tcpPkt *)out->curr;
    outtcp->srcpt = tcp->dstpt;
    outtcp->dstpt = tcp->srcpt;
    outtcp->offset = octets2offset(TCP_HDR_LEN);
    outtcp->control = TCP_CTRL_RST;
    if (tcp->control & TCP_CTRL_ACK)
    {
        outtcp->seqnum = tcp->acknum;
    }
    else
    {
        outtcp->seqnum = 0;
        outtcp->control |= TCP_CTRL_ACK;
    }
    datalen = tcplen - offset2octets(tcp->offset);
    if (tcp->control & TCP_CTRL_SYN)
    {
        datalen++;
    }
    if (tcp->control & TCP_CTRL_FIN)
    {
        datalen++;
    }
    outtcp->acknum = tcp->seqnum + datalen;

    /* Convert TCP header fields to net order */
    outtcp->srcpt = hs2net(outtcp->srcpt);
    outtcp->dstpt = hs2net(outtcp->dstpt);
    outtcp->seqnum = hl2net(outtcp->seqnum);
    outtcp->acknum = hl2net(outtcp->acknum);
    outtcp->window = hs2net(outtcp->window);
    outtcp->urgent = hs2net(outtcp->urgent);

    /* Calculate TCP checksum */
    outtcp->chksum = tcpChksum(out, TCP_HDR_LEN, src, dst);

    /* Send TCP packet */
    result = ipv4Send(out, src, dst, IPv4_PROTO_TCP);

    if (SYSERR == netFreebuf(out))
    {
        return SYSERR;
    }

    return result;
}