/* icmp.c - icmp_init, icmp_in, icmp_register, icmp_recv, icmp_send,    */
/*              icmp_release, icmp_cksum, icmp_hton, icmp_ntoh          */

#include 

struct  icmpentry icmptab[ICMP_SLOTS];  /* Table of processes using ping*/

/*------------------------------------------------------------------------
 * icmp_init  -  Initialize icmp table
 *------------------------------------------------------------------------
 */
void    icmp_init(void) {

        int32   i;                      /* Table index */

        for(i=0; inet_ictype != ICMP_ECHOREPLY) &&
             (pkt->net_ictype != ICMP_ECHOREQST)  )     {
                freebuf((char *)pkt);
                restore(mask);
                return;
        }

        /* Handle Echo Request message */

        if (pkt->net_ictype == ICMP_ECHOREQST) {

                /* Send echo reply message */

                replypkt = icmp_mkpkt(pkt->net_ipsrc,ICMP_ECHOREPLY,
                                pkt->net_icident, pkt->net_icseq,
                                (char *) &pkt->net_icdata,
                                pkt->net_iplen-IP_HDR_LEN-ICMP_HDR_LEN);
                if ((int32)replypkt != SYSERR) {
                        ip_enqueue(replypkt);
                }
                freebuf((char *)pkt);
                restore(mask);
                return;
        }

        /* Handle Echo Reply message: verify that ID is valid */

        slot = pkt->net_icident;
        if ( (slot < 0) || (slot >= ICMP_SLOTS) ) {
                freebuf((char *)pkt);
                restore(mask);
                return;
        }

        /* Verify that slot in table is in use and IP address   */
        /*    in incomming packet matches IP address in table   */

        icmptr = &icmptab[slot];
        if (icmptr->icstate == ICMP_FREE) {
                freebuf((char *)pkt);
                restore(mask);
                return;
        }

        /* Check address in incoming packet */
        
        if ( (pkt->net_ipsrc != icmptr->icremip) &&
             (pkt->net_ipsrc != NetData.ipucast) &&
             ( (pkt->net_ipsrc&0x7f000000) !=
                        0x7f000000 ) ) {
                freebuf((char *)pkt);
                restore(mask);
                return;
        }

        /* Add packet to queue */

        icmptr->iccount++;
        icmptr->icqueue[icmptr->ictail++] = pkt;
        if (icmptr->ictail >= ICMP_QSIZ) {
                icmptr->ictail = 0;
        }
        if (icmptr->icstate == ICMP_RECV) {
                icmptr->icstate = ICMP_USED;
                send (icmptr->icpid, OK);
        }
        restore(mask);
        return;
}

/*------------------------------------------------------------------------
 * icmp_register  -  Register a remote IP address for ping replies
 *------------------------------------------------------------------------
 */
int32   icmp_register (
         uint32 remip                   /* Remote IP address            */
        )
{
        intmask mask;                   /* Saved interrupt mask         */
        int32   i;                      /* Index into icmptab           */
        int32   freeslot;               /* Index of slot to use         */
        struct  icmpentry *icmptr;      /* Pointer to icmptab entry     */

        mask = disable();

        /* Find a free slot in the table */

        freeslot = -1;
        for (i=0; iicstate == ICMP_FREE) {
                        if (freeslot == -1) {
                                freeslot = i;
                        }
                } else if (icmptr->icremip == remip) {
                        restore(mask);
                        return SYSERR;  /* Already registered */
                }
        }
        if (freeslot == -1) {  /* No free entries in table */

                restore(mask);
                return SYSERR;
        }

        /* Fill in table entry */

        icmptr = &icmptab[freeslot];
        icmptr->icstate = ICMP_USED;
        icmptr->icremip = remip;
        icmptr->iccount = 0;
        icmptr->ichead = icmptr->ictail = 0;
        icmptr->icpid = -1;
        restore(mask);
        return freeslot;
}

/*------------------------------------------------------------------------
 * icmp_recv  -  Receive an icmp echo reply packet
 *------------------------------------------------------------------------
 */
int32   icmp_recv (
         int32  icmpid,                 /* ICMP slot identifier         */
         char   *buff,                  /* Buffer to ICMP data          */
         int32  len,                    /* Length of buffer             */
         uint32 timeout                 /* Time to wait in msec         */
        )
{
        intmask mask;                   /* Saved interrupt mask         */
        struct  icmpentry *icmptr;      /* Pointer to icmptab entry     */
        umsg32  msg;                    /* Message from recvtime()      */
        struct  netpacket *pkt;         /* Pointer to packet being read */
        int32   datalen;                /* Length of ICMP data area     */
        char    *icdataptr;             /* Pointer to icmp data         */
        int32   i;                      /* Counter for data copy        */

        /* Verify that the ID is valid */

        if ( (icmpid < 0) || (icmpid >= ICMP_SLOTS) ) {
                return SYSERR;
        }

        /* Insure only one process touches the table at a time */

        mask = disable();

        /* Verify that the ID has been registered and is idle */

        icmptr = &icmptab[icmpid];
        if (icmptr->icstate != ICMP_USED) {
                restore(mask);
                return SYSERR;
        }

        if (icmptr->iccount == 0) {             /* No packet is waiting */
                icmptr->icstate = ICMP_RECV;
                icmptr->icpid = currpid;
                msg = recvclr();
                msg = recvtime(timeout);        /* Wait for a reply */
                icmptr->icstate = ICMP_USED;
                if (msg == TIMEOUT) {
                        restore(mask);
                        return TIMEOUT;
                } else if (msg != OK) {
                        restore(mask);
                        return SYSERR;
                }
        }

        /* Packet has arrived -- dequeue it */

        pkt = icmptr->icqueue[icmptr->ichead++];
        if (icmptr->ichead >= ICMP_SLOTS) {
                icmptr->ichead = 0;
        }
        icmptr->iccount--;

        /* Copy data from ICMP message into caller's buffer */

        datalen = pkt->net_iplen - IP_HDR_LEN - ICMP_HDR_LEN;
        icdataptr = (char *) &pkt->net_icdata;
        for (i=0; i= len) {
                        break;
                }
                *buff++ = *icdataptr++;
        }
        freebuf((char *)pkt);
        restore(mask);
        return i;
}

/*------------------------------------------------------------------------
 * icmp_send  -  Send an icmp packet
 *------------------------------------------------------------------------
 */
status  icmp_send (
         uint32 remip,                  /* Remote IP address to use     */
         uint16 type,                   /* ICMP type (req. or reply)    */
         uint16 ident,                  /* ICMP identifier value        */
         uint16 seq,                    /* ICMP sequence number         */
         char   *buf,                   /* Pointer to data buffer       */
         int32  len                     /* Length of data in buffer     */
        )
{
        intmask mask;                   /* Saved interrupt mask         */
        struct  netpacket *pkt;         /* Packet returned by icmp_mkpkt*/
        int32   retval;                 /* Value returned by ip_send    */

        mask = disable();

        /* Form a packet to send */

        pkt = icmp_mkpkt(remip, type, ident, seq, buf, len);
        if ((int32)pkt == SYSERR) {
                return SYSERR;
        }

        /* Send the packet */

        retval = ip_send(pkt);
        restore(mask);
        return retval;
}


/*------------------------------------------------------------------------
 * icmp_mkpkt  -  Make an icmp packet by filling in fields
 *------------------------------------------------------------------------
 */
struct  netpacket *icmp_mkpkt (
         uint32 remip,                  /* Remote IP address to use     */
         uint16 type,                   /* ICMP type (req. or reply)    */
         uint16 ident,                  /* ICMP identifier value        */
         uint16 seq,                    /* ICMP sequence number         */
         char   *buf,                   /* Pointer to data buffer       */
         int32  len                     /* Length of data in buffer     */
        )
{
        struct  netpacket *pkt;         /* Pointer to packet buffer     */
        static  uint32  ipident=32767;  /* IP ident field               */

        /* Allocate packet */

        pkt = (struct netpacket *)getbuf(netbufpool);

        if ((int32)pkt == SYSERR) {
                panic("icmp_mkpkt: cannot get a network buffer\n");
        }

        /* Create icmp packet in pkt */

        memcpy(pkt->net_ethsrc, NetData.ethucast, ETH_ADDR_LEN);
        pkt->net_ethtype = 0x800;       /* Type is IP */
        pkt->net_ipvh = 0x45;           /* IP version and hdr length    */
        pkt->net_iptos = 0x00;          /* Type of service              */
        pkt->net_iplen= IP_HDR_LEN+ICMP_HDR_LEN+len;/* datagram length  */
        pkt->net_ipid = ipident++;      /* Datagram gets next IDENT     */
        pkt->net_ipfrag = 0x0000;       /* IP flags & fragment offset   */
        pkt->net_ipttl = 0xff;          /* IP time-to-live              */
        pkt->net_ipproto = IP_ICMP;     /* Datagram carries icmp        */
        pkt->net_ipcksum = 0x0000;      /* Initial checksum             */
        pkt->net_ipsrc = NetData.ipucast; /* IP source address  */
        pkt->net_ipdst = remip;         /* IP destination address       */


        pkt->net_ictype = type;         /* ICMP type                    */
        pkt->net_iccode = 0;            /* Code is zero for ping        */
        pkt->net_iccksum = 0x0000;      /* Temporarily zero the cksum   */
        pkt->net_icident = ident;       /* ICMP identification          */
        pkt->net_icseq = seq;           /* ICMP sequence number         */
        memcpy(pkt->net_icdata, buf, len);

        /* Return packet to caller */

        return pkt;
}


/*------------------------------------------------------------------------
 * icmp_release  -  Release a previously-registered ICMP icmpid
 *------------------------------------------------------------------------
 */
status  icmp_release (
         int32  icmpid                  /* Slot in icmptab to release   */
        )
{
        intmask mask;                   /* Saved interrupt mask         */
        struct  icmpentry *icmptr;      /* Pointer to icmptab entry     */
        struct  netpacket *pkt;         /* Pointer to packet            */

        mask = disable();

        /* Check arg and insure entry in table is in use */

        if ( (icmpid < 0) || (icmpid >= ICMP_SLOTS) ) {
                restore(mask);
                return SYSERR;
        }
        icmptr = &icmptab[icmpid];
        if (icmptr->icstate != ICMP_USED) {
                restore(mask);
                return SYSERR;
        }

        /* Remove each packet from the queue and free the buffer */

        resched_cntl(DEFER_START);
        while (icmptr->iccount > 0) {
                pkt = icmptr->icqueue[icmptr->ichead++];
                if (icmptr->ichead >= ICMP_SLOTS) {
                        icmptr->ichead = 0;

                }
                freebuf((char *)pkt);
                icmptr->iccount--;
        }

        /* Mark the entry free */

        icmptr->icstate = ICMP_FREE;
        resched_cntl(DEFER_STOP);
        restore(mask);
        return OK;
}

/*------------------------------------------------------------------------
 * icmp_cksum  -  Compute a checksum for a specified set of data bytes
 *------------------------------------------------------------------------
 */
uint16  icmp_cksum (
         char   *buf,                   /* Buffer of items for checksum */
         int32  buflen                  /* Size of buffer in bytes      */
        )
{
        int32   scount;                 /* Number of 16-bit values buf  */
        uint32  cksum;                  /* Checksum being computed      */
        uint16  *sptr;                  /* Walks along buffer           */
        uint16  word;                   /* One 16-bit word              */

        /* Walk along buffer and sum all 16-bit values */

        scount = buflen >> 1;           /* Divide by 2 and round down   */
        sptr = (uint16 *)buf;
        cksum = 0;
        for (; scount > 0; scount--) {
                word = (uint32) *sptr++;
                cksum += ntohs(word);
        }

        /* If buffer lenght is odd, add last byte */

        if ( (buflen & 0x01) !=0 ) {
                cksum += 0xFFFF & ((uint32) (*((byte *) sptr) << 8));
        }
        cksum += (cksum >> 16);
        cksum = 0xffff & ~cksum;
        return (uint16) (0xffff & cksum);
}


/*------------------------------------------------------------------------
 * icmp_hton  -  Convert ICMP ping fields to network byte order
 *------------------------------------------------------------------------
 */
void    icmp_hton (
          struct netpacket *pktptr
        )
{
        pktptr->net_iccksum = htons(pktptr->net_iccksum);
        pktptr->net_icident = htons(pktptr->net_icident);
        pktptr->net_icseq = htons(pktptr->net_icseq);
}


/*------------------------------------------------------------------------
 * icmp_ntoh  -  Convert ICMP ping fields to host byte order
 *------------------------------------------------------------------------
 */
void    icmp_ntoh (
          struct netpacket *pktptr
        )
{
        pktptr->net_iccksum = ntohs(pktptr->net_iccksum);
        pktptr->net_icident = ntohs(pktptr->net_icident);
        pktptr->net_icseq = ntohs(pktptr->net_icseq);
}