MNUDPSocket.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_UDPSOCKET_H
#define MN_OS_NET_UDPSOCKET_H

/*************************************************************
 * Classes defined in this header file:
 * MNUDPSocket
 * MNUDPClientSocket
 */

#include "MNSocket.h"
#include "MNRope.h"
#include <sys/uio.h>
#include <assert.h>

class MNSelector;
class MNRope;

/* 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 */ 

/***********************************************************************
 * MNUDPSocket
 ***********************************************************************/

class MNUDPSocket : public MNSocket
{
public:
  /*********************************************************************
   * MNUDPSocket::CallbackMode
   **********************************************************************/

  enum CallbackMode
  {
      ClientMode,
      IovecMode,
      RopeMode
  };

  /*********************************************************************
   * MNUDPSocket::CallbackSetting
   **********************************************************************/

  /*
   * The callback settings are intended as a means for existing MN software
   * to co-existing with stream handler approaches that rely on the same
   * basic classes. Finally, it may be a good idea to remove one of the
   * approaches or to copy this class for size and efficiency reasons. For
   * the integration, it is good to support Iovecs as well as ropes.
   *
   * The 3 modes have default values for buffer spaces requests. For the
   * client mode, receive buffers are not initialized, since there is no
   * need for receive buffers in a client-only (=send-only) environment.
   * For the Iovec mode, 3 buffers sized 8,8,128 are default, for backward
   * compatibility.
   * For Rope mode, 8*512 buffers are default, which seems like a good
   * trade-off between allocation size and overhead in the RTP receive
   * settings.
   */
  class CallbackSetting
  {
  protected:
      const CallbackMode _cm;
      size_t*            _buf_sizes;
      int                _buf_num;

      friend class MNUDPSocket;

  public:
      CallbackSetting( CallbackMode cm );
      CallbackSetting( CallbackMode cm, size_t size, int count );
      CallbackSetting( CallbackMode cm, const size_t* sizes, int count );
      CallbackSetting( const CallbackSetting& cs );
      ~CallbackSetting( );
  };

private:
  const CallbackSetting _cs;

protected:
  inline CallbackMode cm() const { return _cs._cm; }

private:
  /*
   * no copy constructor or assignment operator allowed
   */
  MNUDPSocket( const MNUDPSocket& orig );
  MNUDPSocket& operator=( const MNSocket& orig );

public:
  MNUDPSocket ( MNSocket& orig, int copyflags );
  MNUDPSocket ( CallbackSetting cm, MNSocket& orig, int copyflags );
  MNUDPSocket ( CallbackSetting cm );
  MNUDPSocket ( CallbackSetting cm, int sockfd );
  virtual ~MNUDPSocket ( );

  virtual void callback ( MNSelector* select, int fd );
  
  inline virtual bool isUdp() const {return true;}

  bool join_mc( int port, const char *hostname, char *ifnamei, int onoff );

  virtual struct iovec* set_buffers ( int& iovlen );
  virtual void          unset_buffers ( struct iovec* iov, int iovlen );
  MNRope*               buffers_to_rope( struct iovec* iov,
                                         int& iovlen,
                                         size_t bytesused );

  /*
   * recvfrom()
   * All calls are implemented by the system's recvfrom() function.
   * Originally, all sock_addr variables were only internal. For UDP servers,
   * it is appropriate to respond to calls without some connect-like operation.
   * The fd parameter should always be identical to get_sockdesc() and is
   * allowed only for backward compatibility.
   */
  int recvfrom ( char* buffer,
                 int   buflen);
  int recvfrom ( char*               buffer,
                 int                 buflen,
                 struct sockaddr_in& sock_addr,
                 unsigned&    sock_size );

  int sendto ( const void*               buf,
               int                       buflen,
               const struct sockaddr_in* server_addr );
  int sendto ( const char* buff,
               int         len,
               int         port,
               const char* hostname );

  virtual int reader ( struct iovec*        iov,
                       int                  len,
                       struct sockaddr_in*& dest ) = 0;

  virtual void writer ( ) = 0; 
  
  virtual int reader ( MNRope*&             rope,
                       struct sockaddr_in*& dest ) = 0;

  void connect(int port, char* hostname);
};

/***********************************************************************
 * MNUDPClientSocket
 * The MNUDPClientSocket exists only to keep a socket alive for later
 * re-use in a different UDP socket class. It has been introduced to
 * prevent inefficient, stupid, unreliable, opening and closing of
 * sockets that is done for nothing else but to check whether a port is
 * free.
 ***********************************************************************/

class MNUDPClientSocket : public MNUDPSocket
{
public:
    MNUDPClientSocket( )
        : MNUDPSocket ( MNUDPSocket::ClientMode )
    { }

  virtual int reader ( struct iovec*, int, struct sockaddr_in*& )
  {
      MN_FATAL("reader() not implemented for MNUDPClientSocket");
      return 0;
  }

  virtual int reader ( MNRope*& , struct sockaddr_in*& )
  {
      MN_FATAL("reader() not implemented for MNUDPClientSocket");
      return 0;
  }

  virtual void writer ( )
  {
      MN_FATAL("writer() not implemented for MNUDPClientSocket");
  }

};


#endif /* MN_OS_NET_UDPSOCKET_H */

---