MNUDPServerSocket.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef MN_OS_NET_UDPSERVERSOCKET_H
#define MN_OS_NET_UDPSERVERSOCKET_H

/*************************************************************
 * Classes defined in this header file:
 * MNUDPServerSocket 
 */

/*************************************************************
 * UDPSocket
 */

#include <strings.h>
#include <sys/uio.h>
#include "MNSocket.h"
#include "MNSelector.h"
#include "MNThread.h"
#include "MNMutex.h"
#include "MNUDPSocket.h"
#include "MNValid.h"

/* The Linux netinet header files are a shame, because they're completely
 * inconsitant compared to what the standards define.
 * Better check if this is defined in the 2.2.2 Kernel
 */

#define IP_RECVDSTADDR  7       /* bool; receive IP dst addr w/datagram */ 

/**********************************************************************/
/* MNUDPServerSocket                                                  */
/**********************************************************************/

class MNUDPServerSocket : public MNUDPSocket
{
    DECLARE_VALID

public:
  class Interfaces
  {
      struct ifi_info* interf;

      void delete_interf()
      {
          // free ifi_info in iface

          struct ifi_info* ifi;
          struct ifi_info* ifinext;

          for (ifi = interf; ifi != NULL; ifi = ifinext)
          {
              if (ifi->ifi_addr != NULL)  free(ifi->ifi_addr);
              if (ifi->ifi_brdaddr != NULL)  free(ifi->ifi_brdaddr);
              if (ifi->ifi_dstaddr != NULL)  free(ifi->ifi_dstaddr);

              // can't fetch ifi_next after free()
              ifinext = ifi->ifi_next;

              // free the ifi_info{} itself
              free(ifi);
          }
          interf = NULL;
      }

  public:
      Interfaces ( )
      {
          interf = NULL;
      }

      ~Interfaces ( )
      {
          delete_interf();
      }

      struct ifi_info* get_interf() {
          return interf;
      };

      void set_interf( struct ifi_info* ifi ) {
          delete_interf();
          interf = ifi;
      };
  };

private:
    class Dest
    {
        const char* destname;
    public:
        int         destport;

        Dest& operator=( const Dest& orig )
        {
            destname = strdup(orig.destname);
            destport = orig.destport;
            return *this;
        }

        Dest( const Dest& orig )
        {
            destname = strdup(orig.destname);
            destport = orig.destport;
        }

        Dest()
        {
            destname = NULL;
            destport = 0;
        }

        Dest( const char* name, int port )
          : destport(port)
        {
            destname = strdup(name);
        }
    }; 
    struct Dest* _dest;

    MNSelector&   _selector;

    /*
     * Protect the stop function from reentry.
     */
    MNMutex               _stopEntryLock;

    typedef MNUDPSocket::CallbackSetting CBSetting;
public:
    

    MNUDPServerSocket ( MNUDPServerSocket& orig );

    MNUDPServerSocket ( MNSelector&  sel,
                        CBSetting    cs );

    MNUDPServerSocket ( MNSelector&  sel,
                        int          fd,
                        int          zero,
                        CBSetting    cs );

    MNUDPServerSocket ( MNSelector&  sel,
                        int          port,
                        CBSetting    cs );

    MNUDPServerSocket ( MNSelector&  sel,
                        int          port,
                        char*        hostname,
                        CBSetting    cs );

    MNUDPServerSocket ( MNSelector&  sel,
                        int          port,
                        char*        hostname,
                        Interfaces*  intf );
  
    MNUDPServerSocket ( MNSelector&  sel,
                        MNSocket&    orig,
                        CBSetting    cs        = MNUDPSocket::IovecMode,
                        int          copyflags = MNSocket::TakeoverFlag );
    virtual ~MNUDPServerSocket ( );

    virtual void activate();

    void         stopUdpServer();
  
    MNSelector& getSelector( );

    int mc_join_all(int port, const char* hostname, Interfaces* intf);
    int mc_leave_all(int sockfd, struct sockaddr *sock_addr, Interfaces* intf);
};

#endif /* MN_OS_NET_UDPSERVERSOCKET_H */

---