MNSocket.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_SOCKET_H
#define MN_OS_NET_SOCKET_H

#include <config.h>

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

/*************************************************************
 * MNSocket
 */


#include <sys/types.h>
#include <sys/socket.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <netinet/in.h>

#include "mnstream.h"
#include "MNSocketBase.h"
 
class MNSelector;

#define IFI_NAME        16             /* same as IFNAMSIZ in <net/if.h> */
#define IFI_HADDR        8             /* allow for 64-bit EUI-64 in future */
#define IFI_ALIAS        1             /* ifi_addr is an alias */

ostream& operator<<( ostream& ostr, const struct sockaddr_in& addr );

/***********************************************************************
 * ifi_info - interface information
 ***********************************************************************/

struct ifi_info
{
    char    ifi_name[IFI_NAME];   /* interface name, null terminated */
    u_char  ifi_haddr[IFI_HADDR]; /* hardware address */
    u_short ifi_hlen;             /* #bytes in hardware address: 0, 6, 8 */
    short   ifi_flags;            /* IFF_xxx constants from <net/if.h> */
    short   ifi_myflags;          /* our own IFI_xxx flags */
    struct sockaddr  *ifi_addr;   /* primary address */
    struct sockaddr  *ifi_brdaddr;/* broadcast address */
    struct sockaddr  *ifi_dstaddr;/* destination address */
    struct ifi_info  *ifi_next;   /* next of these structures */
}; 

/***********************************************************************
 * MNSocket
 ***********************************************************************/

class MNSocket    
    : public MNSocketBase
{
  int            my_socket;
  int            my_ok;
  int            my_port;
  struct in_addr my_address; 
  bool           _master;
  bool           _is_mc;     

public:
  /*
   * socketflags for the modified copy constructor
   */
  enum SocketFlags
  {
      TakeoverFlag = 0x1
  };

public:
  bool mcast_join_new( struct sockaddr *sa, char *ifname );
  int mcast_leave(int sockfd, const struct sockaddr *sa, char *ifname);
  int mcast_set_if(int sockfd, const char *ifname);
  int mcast_set_loop(int sockfd, int onoff);
  int mcast_set_ttl(int sockfd, int val);
  int mcast_get_if(int sockfd);
  int mcast_get_loop(int sockfd);
  int mcast_get_ttl(int sockfd);

  static bool set_addr ( int                 port,
                         const char*         hostname,
                         struct sockaddr_in& server_addr );

  void make_socket ( int type );
  void make_socket ( int domain, int type );
  void remake_socket ( int type );             // close and reopen
  void remake_socket ( int domain, int type ); // close and reopen
  void listen ( );

  int  bind ( int port );

  int  bind ( int port, const char* hostname );

  void broadcast ( );

    const char* get_ipaddr( char* buffer, size_t len );

  bool get_sock_name( struct sockaddr_in& addr ) const;

  inline bool get_addr( struct sockaddr_in& addr ) const {
      return get_sock_name( addr );
  }

  int get_socktype();

private:
  MNSocket( const MNSocket& orig );

  MNSocket& operator=( const MNSocket& orig );

public:
  MNSocket ( MNSocket& orig, int socketflags = 0 );
  MNSocket ( );
  MNSocket ( int sock );
  virtual ~MNSocket ( );

  static bool isMulticast( const char* hname ); 

  static const char* getLocalNameForAddr( struct in_addr* addr, char* buffer );

  int  ok ( );
  int  port ( );
  void master ( bool controlSocket );
  virtual int  get_sockdesc ( ) const { return my_socket; }
  virtual void set_sockdesc ( int socket ) { my_socket = socket; }
  virtual void update_ports ( );
  inline virtual bool isUdp() const = 0;

  int l1_receive ( struct msghdr* hdr );
  int l1_receive ( struct iovec*       iov,
                   int                 iovlen,
                   struct sockaddr_in* dest );
  int l1_receive ( char* buffer, int max_len );

  int send ( struct iovec*             iov,
             int                       iov_count,
             const struct sockaddr_in* dest ); 

  void reuseaddress ( );
  void linger ( );
  void nolinger ( );
  void nodelay ( );
  void noblock ( );
  // const char* str_errno ( );

  virtual void connection_closed ( );

  virtual const char* get_title ( );
};

#endif /* MN_OS_NET_SOCKET_H */

---