framexmit/framexmittypes.hh

/* -*- mode: c++; c-basic-offset: 3; -*- */
#ifndef _GDS_FRAMEXMITTYPE_H
#define _GDS_FRAMEXMITTYPE_H
/*----------------------------------------------------------------------*/
/*                                                                      */
/* Module Name: framexmit                                               */
/*                                                                      */
/* Module Description: API for broadcasting frames                      */
/*                     implements a reliable UDP/IP broadcast for       */
/*                     large data sets over high speed links            */
/*                                                                      */
/* Module Arguments: none                                               */
/*                                                                      */
/* Revision History:                                                    */
/* Rel   Date     Programmer    Comments                                */
/* 1.0   10Aug99  D. Sigg       First release                           */
/*                                                                      */
/* Documentation References:                                            */
/*      Man Pages: doc/index.html (use doc++)                           */
/*      References: none                                                */
/*                                                                      */
/* Author Information:                                                  */
/* Name          Telephone       Fax             e-mail                 */
/* Daniel Sigg   (509) 372-8132  (509) 372-8137  sigg_d@ligo.mit.edu    */
/*                                                                      */
/* Code Compilation and Runtime Specifications:                         */
/*      Code Compiled on: Ultra-Enterprise, Solaris 5.7                 */
/*      Compiler Used: egcs-1.1.2                                       */
/*      Runtime environment: sparc/solaris                              */
/*                                                                      */
/* Code Standards Conformance:                                          */
/*      Code Conforms to: LIGO standards.       OK                      */
/*                        Lint.                 TBD                     */
/*                        ANSI                  OK                      */
/*                        POSIX                 OK                      */
/*                                                                      */
/* Known Bugs, Limitations, Caveats:                                    */
/*                                                                      */
/*                                                                      */
/*                                                                      */
/*                      -------------------                             */
/*                                                                      */
/*                             LIGO                                     */
/*                                                                      */
/*        THE LASER INTERFEROMETER GRAVITATIONAL WAVE OBSERVATORY.      */
/*                                                                      */
/*                     (C) The LIGO Project, 1996.                      */
/*                                                                      */
/*                                                                      */
/* California Institute of Technology                                   */
/* LIGO Project MS 51-33                                                */
/* Pasadena CA 91125                                                    */
/*                                                                      */
/* Massachusetts Institute of Technology                                */
/* LIGO Project MS NW17-161                                             */
/* Cambridge MA 01239                                                   */
/*                                                                      */
/* LIGO Hanford Observatory                                             */
/* P.O. Box 1970 S9-02                                                  */
/* Richland WA 99352                                                    */
/*                                                                      */
/* LIGO Livingston Observatory                                          */
/* 19100 LIGO Lane Rd.                                                  */
/* Livingston, LA 70754                                                 */
/*                                                                      */
/*----------------------------------------------------------------------*/

// include files
#include <sys/types.h>
#include <netinet/in.h>
#include <inttypes.h>

namespace framexmit {



   const int            frameXmitPort = 7096;
   const unsigned char  mcast_TTL = 1;
   const int            daemonPriority = 1;
   const int            sndDefaultBuffers = 7;
   const int            packetSize = 64000;
   const int            packetBurst = 4;
   const int            packetBurstInterval = 1000;
   const int            sndDelayTick = 1000;
   const int            rcvDelayTick = 1000;
   const int            maximumRetransmit = 200;
   const int            sndInBuffersize = 65536;
   const int            sndOutBuffersize = 4 * 65536;
   const int            rcvInBuffersize = 4 * 65536;
   const int            rcvInBufferMax = 16 * 65536;
   const int            rcvOutBuffersize = 65536;
   const int            rcvpacketbuffersize = 1024;
   const int            maxRetry = 5;
   const int            retryTimeout = 250000;
   const int            maxSequenceOutOfSync = 5;
   const double         retransmissionAverage = 10.1;
   const double         rcvErrorRate = 0;

   const int            PKT_BROADCAST = 123;
   const int            PKT_REBROADCAST = 124;
   const int            PKT_REQUEST_RETRANSMIT = 125;

   struct packetHeader {
      int32_t           pktType;
      int32_t           pktLen;
      uint32_t          seq;
      int32_t           pktNum;
      int32_t           pktTotal;
      uint32_t          checksum;
      uint32_t          timestamp;
      uint32_t          duration;
      inline void hton();
      inline void ntoh();
   };

   struct packet {
      packetHeader      header;
      char              payload[packetSize];
      inline void hton();
      inline void ntoh();
   };

   struct retransmitpacket {
      packetHeader      header;
      int32_t           pktResend[packetSize / sizeof (int32_t)];
      inline void hton();
      inline void ntoh();
   };


   class auto_pkt_ptr {
   private:
      packet* ptr;
      mutable bool owns;
   public:
   
      explicit auto_pkt_ptr (packet* p = 0) : ptr(p), owns(p) {
      }

      auto_pkt_ptr (const auto_pkt_ptr& a) : ptr(a.ptr), owns(a.owns) {
         a.owns = 0;
      }

      auto_pkt_ptr& operator= (const auto_pkt_ptr& a) {
         if (&a != this) {
            if (owns)
               delete ptr;
            owns = a.owns;
            ptr = a.ptr;
            a.owns = 0;
         }
         return *this;
      }

      ~auto_pkt_ptr() {
         if (owns)
            delete ptr;
      }

      packet& operator*() const { 
         return *ptr; }

      packet* operator->() const { 
         return ptr; }

      packet* get() const  { 
         return ptr; }

      packet* release() const { 
         owns = false; 
         return ptr; }
   
      bool operator== (const auto_pkt_ptr& a) const {
         if (!owns || !a.owns) {
            return false;
         }
         return ((ptr->header.seq == a.ptr->header.seq) && 
                (ptr->header.pktNum == a.ptr->header.pktNum));
      }

      bool operator< (const auto_pkt_ptr& a) const {
         if (!owns || !a.owns) {
            return owns;
         }
         return ((ptr->header.seq < a.ptr->header.seq) || 
                ((ptr->header.seq == a.ptr->header.seq) &&
                (ptr->header.pktNum < a.ptr->header.pktNum)));
      }
   };

   inline void packetHeader::hton()
   {
      pktType = htonl (pktType);
      pktLen = htonl (pktLen);
      seq = htonl (seq);
      pktNum = htonl (pktNum);
      pktTotal = htonl (pktTotal);
      checksum = htonl (checksum);
      timestamp = htonl (timestamp);
      duration = htonl (duration);
   }

   inline void packetHeader::ntoh()
   {
      pktType = ntohl (pktType);
      pktLen = ntohl (pktLen);
      seq = ntohl (seq);
      pktNum = ntohl (pktNum);
      pktTotal = ntohl (pktTotal);
      checksum = ntohl (checksum);
      timestamp = ntohl (timestamp);
      duration = ntohl (duration);
   }

   inline void packet::hton()
   {
      // payload not swapped
      header.hton();
   }

   inline void packet::ntoh()
   {
      header.ntoh();
      // payload not swapped
   }

   inline void retransmitpacket::hton()
   {
      for (int i = 0; i < header.pktLen/(int)sizeof(int32_t); ++i) 
         pktResend[i] = htonl (pktResend[i]);
      header.hton();
   }

   inline void retransmitpacket::ntoh()
   {
      header.ntoh();
      for (int i = 0; i < header.pktLen/(int)sizeof(int32_t); ++i) 
         pktResend[i] = ntohl (pktResend[i]);
   }

}

#endif // _GDS_FRAMEXMITTYPE_H

---