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: 32474 $
 * $Author: rjongbloed $
 * $Date: 2014-08-09 14:23:47 +1000 (Sat, 09 Aug 2014) $
 */

#ifndef PTLIB_SOCKET_H
#define PTLIB_SOCKET_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptlib/channel.h>

#ifdef P_OPENBSD
#include <sys/uio.h>
#endif

#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); }


#if _WIN32
    struct Slice : public WSABUF 
    {
      Slice()
      { buf = (char *)0; len = 0; }

      Slice(void * v, const size_t len)
      { SetBase(v); SetLength(len); }

      Slice(const void * v, const size_t len)
      { SetBase(v); SetLength(len); }

      void SetBase(const void * v)   { buf = (char *)v; }
      void SetBase(void * v)         { buf = (char *)v; }
      void * GetBase() const         { return buf; }

      void SetLength(size_t v)  { len = (ULONG)v; }
      size_t GetLength() const  { return len; }
    };
#else
#if P_HAS_RECVMSG
    struct Slice : public iovec
    {
#else
    struct Slice 
    {
      protected:
        void * iov_base;
        size_t iov_len;
      public:
#endif
      Slice()
      { SetBase(NULL); SetLength(0); }

      Slice(void * v, size_t len)
      { SetBase(v); SetLength(len); }

      void SetBase(void * v) { iov_base = v; }
      void * GetBase() const   { return iov_base; }
      void SetLength(size_t v) { iov_len = v; }
      size_t GetLength() const  { return iov_len; }
    };
#endif

    virtual bool Read(
      Slice * slices,    // slices to read to
      size_t sliceCount
    );

    virtual bool Write(
      const Slice * slices,  // slices to write from
      size_t sliceCount
    );

  protected:
    virtual PBoolean ConvertOSError(P_INT_PTR libcReturnValue, ErrorGroup group = LastGeneralError);

    /*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,
      socklen_t size
    );

    PBoolean os_vread(
      Slice * slices,
      size_t sliceCount,
      int flags,
      struct sockaddr * from,
      socklen_t * fromlen
    );

    PBoolean os_vwrite(
      const Slice * slices,
      size_t sliceCount,
      int flags,
      struct sockaddr * to,
      socklen_t tolen
    );

    PBoolean os_accept(
      PSocket & listener,
      struct sockaddr * addr,
      socklen_t * size
    );

    virtual int os_errno() const;


  // Member variables
    WORD port;

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

    operator fd_set*() const
      {
        return set;
      }

  protected:
    void Construct();

    SOCKET max_fd;
    fd_set * set;

  private:
#ifdef __MINGW32__
  // avoid compile error when this declaration is private
  // this could be a gcc bug
  public:
    P_fd_set(const P_fd_set &) {}
  private:
#else
    P_fd_set(const P_fd_set &) {}
#endif
    void operator=(const P_fd_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;
};


#endif // PTLIB_SOCKET_H


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