socket.h

Go to the documentation of this file.

/*
 * socket.h
 *
 * Berkley Socket channel ancestor class.
 *
 * Portable Tools Library
 *
 * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
 * All Rights Reserved.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 20624 $
 * $Author: rjongbloed $
 * $Date: 2008-07-25 23:56:27 +0000 (Fri, 25 Jul 2008) $
 */

#ifndef _PSOCKETS
#define _PSOCKETS

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptlib/channel.h>

#ifdef __NUCLEUS_PLUS__
#include <sys/socket.h>
#endif

class PSocket;

PLIST(PSocketList, PSocket);


class PSocket : public PChannel
{
  PCLASSINFO(PSocket, PChannel);

  protected:
    PSocket();

  public:
    virtual PBoolean Connect(
      const PString & address   
    );


    enum Reusability {
      CanReuseAddress,
      AddressIsExclusive
    };

    virtual PBoolean Listen(
      unsigned queueSize = 5,  
      WORD port = 0,           
      Reusability reuse = AddressIsExclusive 
    );


    virtual PBoolean Accept(
      PSocket & socket          
    );

    virtual PBoolean Shutdown(
      ShutdownValue option   
    );

    PBoolean SetOption(
      int option,             
      int value,              
      int level = SOL_SOCKET  
    );

    PBoolean SetOption(
      int option,             
      const void * valuePtr,  
      PINDEX valueSize,       
      int level = SOL_SOCKET  
    );

    PBoolean GetOption(
      int option,             
      int & value,            
      int level = SOL_SOCKET  
    );

    PBoolean GetOption(
      int option,             
      void * valuePtr,        
      PINDEX valueSize,       
      int level = SOL_SOCKET  
    );

    static WORD GetProtocolByName(
      const PString & name      
    );

    static PString GetNameByProtocol(
      WORD proto                
    );


    virtual WORD GetPortByService(
      const PString & service   
    ) const;
    static WORD GetPortByService(
      const char * protocol,     
      const PString & service    
    );

    virtual PString GetServiceByPort(
      WORD port   
    ) const;
    static PString GetServiceByPort(
      const char * protocol,  
      WORD port   
    );


    void SetPort(
      WORD port   
    );
    void SetPort(
      const PString & service   
    );

    WORD GetPort() const;

    PString GetService() const;


    class SelectList : public PSocketList
    {
      PCLASSINFO(SelectList, PSocketList)
      public:
        SelectList()
          { DisallowDeleteObjects(); }
        void operator+=(PSocket & sock )
          { Append(&sock); }
        void operator-=(PSocket & sock )
          { Remove(&sock); }
    };

    static int Select(
      PSocket & sock1,        
      PSocket & sock2         
    );
    static int Select(
      PSocket & sock1,        
      PSocket & sock2,        
      const PTimeInterval & timeout 
    );
    static Errors Select(
      SelectList & read       
    );
    static Errors Select(
      SelectList & read,      
      const PTimeInterval & timeout 
    );
    static Errors Select(
      SelectList & read,      
      SelectList & write      
    );
    static Errors Select(
      SelectList & read,      
      SelectList & write,     
      const PTimeInterval & timeout 
    );
    static Errors Select(
      SelectList & read,      
      SelectList & write,     
      SelectList & except     
    );
    static Errors Select(
      SelectList & read,      
      SelectList & write,     
      SelectList & except,    
      const PTimeInterval & timeout 
    );


    inline static WORD  Host2Net(WORD  v) { return htons(v); }
    inline static DWORD Host2Net(DWORD v) { return htonl(v); }

    inline static WORD  Net2Host(WORD  v) { return ntohs(v); }
    inline static DWORD Net2Host(DWORD v) { return ntohl(v); }

  protected:
    /*This function calls os_socket() with the correct parameters for the
       socket protocol type.
     */
    virtual PBoolean OpenSocket() = 0;

    virtual const char * GetProtocolName() const = 0;


    int os_close();
    int os_socket(int af, int type, int proto);
    PBoolean os_connect(
      struct sockaddr * sin,
      PINDEX size
    );
    PBoolean os_recvfrom(
      void * buf,
      PINDEX len,
      int flags,
      struct sockaddr * from,
      PINDEX * fromlen
    );
    PBoolean os_sendto(
      const void * buf,
      PINDEX len,
      int flags,
      struct sockaddr * to,
      PINDEX tolen
    );
    PBoolean os_accept(
      PSocket & listener,
      struct sockaddr * addr,
      PINDEX * size
    );


  // Member variables
    WORD port;

#if P_HAS_RECVMSG
    PBoolean catchReceiveToAddr;
    virtual void SetLastReceiveAddr(void * /*addr*/, int /*addrLen*/)
    { }
#endif

// Include platform dependent part of class
#ifdef _WIN32
#include "msos/ptlib/socket.h"
#else
#include "unix/ptlib/socket.h"
#endif
};


// Utility classes

class P_fd_set {
  public:
    P_fd_set();
    P_fd_set(SOCKET fd);
    ~P_fd_set()
      {
        free(set);
      }

    P_fd_set & operator=(SOCKET fd);
    P_fd_set & operator+=(SOCKET fd);
    P_fd_set & operator-=(SOCKET fd);

    void Zero();

    PBoolean IsPresent(SOCKET fd) const
      {
        return FD_ISSET(fd, set);
      }

    operator fd_set*() const
      {
        return set;
      }

  private:
    void Construct();

    SOCKET max_fd;
    fd_set * set;
};


class P_timeval {
  public:
    P_timeval();
    P_timeval(const PTimeInterval & time)
      {
        operator=(time);
      }

    P_timeval & operator=(const PTimeInterval & time);

    operator timeval*()
      {
        return infinite ? NULL : &tval;
      }

    timeval * operator->()
      {
        return &tval;
      }

    timeval & operator*()
      {
        return tval;
      }

  private:
    struct timeval tval;
    PBoolean infinite;
};

#ifdef _WIN32
class PWinSock : public PSocket
{
  PCLASSINFO(PWinSock, PSocket)
// Must be one and one only instance of this class, and it must be static!.
  public:
    PWinSock();
    ~PWinSock();
  private:
    virtual PBoolean OpenSocket();
    virtual const char * GetProtocolName() const;
};
#endif

#endif

// End Of File ///////////////////////////////////////////////////////////////

---