home *** CD-ROM | disk | FTP | other *** search
/ The Pier Shareware 6 / The_Pier_Shareware_Number_6_(The_Pier_Exchange)_(1995).iso / 024 / psi110g.zip / RSPFHDR.C < prev    next >
C/C++ Source or Header  |  1994-04-17  |  5KB  |  177 lines
  1. /* Mods by PA0GRI */
  2.   
  3. #include "global.h"
  4. #ifdef RSPF
  5. #include "mbuf.h"
  6. #include "internet.h"
  7. #include "ip.h"
  8. #include "timer.h"
  9. #include "rspf.h"
  10.   
  11. /* Convert RRH header in internal format to an mbuf in external format */
  12. struct mbuf *
  13. htonrrh(rrh,data,ph)
  14. struct rrh *rrh;
  15. struct mbuf *data;
  16. struct pseudo_header *ph;
  17. {
  18.     struct mbuf *bp;
  19.     register char *cp, *ck;
  20.     int16 checksum;
  21.   
  22.     /* Allocate RRH header and fill it in */
  23.     bp = pushdown(data,RRHLEN); /* pushdown never fails */
  24.   
  25.     cp = bp->data;
  26.     *cp++ = rrh->version;       /* Version number */
  27.     *cp++ = RSPF_RRH;       /* Type number */
  28.     ck = cp;
  29.     cp = put16(cp,0);       /* Clear checksum */
  30.     cp = put32(cp,rrh->addr);   /* Source address */
  31.     cp = put16(cp,rrh->seq);    /* Last packet sent sequence number */
  32.     *cp = rrh->flags;       /* Flags */
  33.   
  34.     /* All zeros and all ones is equivalent in one's complement arithmetic;
  35.      * the spec requires us to change zeros into ones to distinguish an
  36.      * all-zero checksum from no checksum at all
  37.      */
  38.     if((checksum = cksum(ph,bp,ph->length)) == 0)
  39.         checksum = 0xffffffffL;
  40.     put16(ck,checksum);
  41.     return bp;
  42. }
  43.   
  44. /* Convert RSPF packet header in internal format to an mbuf in external
  45.  * format, without calculating the checksum.
  46.  */
  47. struct mbuf *
  48. htonrspf(pkth,data)
  49. struct rspfpacketh *pkth;
  50. struct mbuf *data;
  51. {
  52.     struct mbuf *bp;
  53.     register unsigned char *cp;
  54.   
  55.     /* Allocate packet header and fill it in */
  56.     bp = pushdown(data,RSPFPKTLEN); /* pushdown never fails */
  57.   
  58.     cp = (unsigned char *) bp->data;
  59.     *cp++ = (char) pkth->version;   /* Version number */
  60.     *cp++ = (char) pkth->type;  /* Type number */
  61.     *cp++ = pkth->fragn;        /* The fragment number */
  62.     *cp++ = pkth->fragtot;      /* The total number of fragments */
  63.     cp = (unsigned char *) put16((char *)cp,pkth->csum); /* The checksum */
  64.     *cp++ = pkth->sync;     /* The sync octet */
  65.     *cp++ = pkth->nodes;        /* The number of nodes */
  66.     put16((char *)cp,pkth->envid);  /* The envelope-ID */
  67.     return bp;
  68. }
  69.   
  70. /* Convert RSPF header in mbuf to internal structure */
  71. int
  72. ntohrspf(rspf,bpp)
  73. union rspf *rspf;
  74. struct mbuf **bpp;
  75. {
  76.     if(len_p(*bpp) < RSPFPKTLEN) /* Packet too short */
  77.         return -1;
  78.     if((rspf->hdr.version = pullchar(bpp)) != RSPF_VERSION) {
  79.         ++Rspf_stat.badvers;
  80.         return -1;           /* Wrong version */
  81.     }
  82.   
  83.     switch (rspf->hdr.type = pullchar(bpp)){
  84.         case RSPF_RRH:
  85.             if(len_p(*bpp) < RRHLEN - 2)    /* Packet too small */
  86.                 return -1;
  87.             rspf->rrh.csum = (int16) pull16(bpp);
  88.             rspf->rrh.addr = pull32(bpp);
  89.             rspf->rrh.seq = (int16) pull16(bpp);
  90.             rspf->rrh.flags = pullchar(bpp);
  91.             break;
  92.         case RSPF_FULLPKT:
  93.             rspf->pkthdr.fragn = pullchar(bpp);
  94.             rspf->pkthdr.fragtot = pullchar(bpp);
  95.             rspf->pkthdr.csum = (int16) pull16(bpp);
  96.             rspf->pkthdr.sync = pullchar(bpp);
  97.             rspf->pkthdr.nodes = pullchar(bpp);
  98.             rspf->pkthdr.envid = (int16) pull16(bpp);
  99.             break;
  100.         default:
  101.             return -1;
  102.     }
  103.     return 0;
  104. }
  105.   
  106. /* Convert RSPF node header in internal format to an mbuf in external format */
  107. struct mbuf *
  108. htonrspfnode(nodeh,data)
  109. struct rspfnodeh *nodeh;
  110. struct mbuf *data;
  111. {
  112.     struct mbuf *bp;
  113.     register char *cp;
  114.   
  115.     /* Allocate node header and fill it in */
  116.     bp = pushdown(data,RSPFNODELEN);    /* pushdown never fails */
  117.   
  118.     cp = bp->data;
  119.     cp = put32(cp,nodeh->addr);     /* Reporting router address */
  120.     cp = put16(cp,(int16)nodeh->seq);   /* Sequence number */
  121.     *cp++ = nodeh->subseq;      /* Sub-sequence number */
  122.     *cp++ = nodeh->links;       /* Number of links */
  123.     return bp;
  124. }
  125.   
  126. /* Convert RSPF node header in mbuf to internal structure */
  127. int
  128. ntohrspfnode(nodeh,bpp)
  129. struct rspfnodeh *nodeh;
  130. struct mbuf **bpp;
  131. {
  132.     if(len_p(*bpp) < RSPFNODELEN) /* Packet too short */
  133.         return -1;
  134.     nodeh->addr = pull32(bpp);
  135.     nodeh->seq = (int16) pull16(bpp);
  136.     nodeh->subseq = (unsigned char) pullchar(bpp);
  137.     nodeh->links = (unsigned char) pullchar(bpp);
  138.     return 0;
  139. }
  140.   
  141. /* Convert RSPF link header in internal format to an mbuf in external format */
  142. struct mbuf *
  143. htonrspflink(linkh,data)
  144. struct rspflinkh *linkh;
  145. struct mbuf *data;
  146. {
  147.     struct mbuf *bp;
  148.     register unsigned char *cp;
  149.   
  150.     /* Allocate link header and fill it in */
  151.     bp = pushdown(data,RSPFLINKLEN);    /* pushdown never fails */
  152.   
  153.     cp = (unsigned char *) bp->data;
  154.     *cp++ = linkh->horizon;     /* Horizon */
  155.     *cp++ = linkh->erp;         /* ERP factor */
  156.     *cp++ = linkh->cost;        /* Link cost */
  157.     *cp++ = linkh->adjn;        /* Number of adjacencies */
  158.     return bp;
  159. }
  160.   
  161. /* Convert RSPF link header in mbuf to internal structure */
  162. int
  163. ntohrspflink(linkh,bpp)
  164. struct rspflinkh *linkh;
  165. struct mbuf **bpp;
  166. {
  167.     if(len_p(*bpp) < RSPFLINKLEN) /* Packet too short */
  168.         return -1;
  169.     linkh->horizon = (unsigned char) pullchar(bpp);
  170.     linkh->erp = (unsigned char) pullchar(bpp);
  171.     linkh->cost = (unsigned char) pullchar(bpp);
  172.     linkh->adjn = (unsigned char) pullchar(bpp);
  173.     return 0;
  174. }
  175. #endif /* RSPF */
  176.   
  177.