int level = SOL_SOCKET  /// Level for option    );    /**Get options on the socket. These options are defined as Berkeley socket       options of the class SOL_SOCKET.       @return       TRUE if the option was successfully retreived.     */    BOOL GetOption(      int option,             /// Option to get.      void * valuePtr,        /// Pointer to buffer for value.      PINDEX valueSize,       /// Size of buffer to receive value.      int level = SOL_SOCKET  /// Level for option    );  //@}  /**@name Port/Service database functions */  //@{    /**Get the number of the protocol associated with the specified name.       @return       Number of protocol or 0 if the protocol was not found.     */    static WORD GetProtocolByName(      const PString & name      /// Name of protocol    );    /**Get the name of the protocol number specified.       @return       Name of protocol or the number if the protocol was not found.     */    static PString GetNameByProtocol(      WORD proto                /// Number of protocol    );    /**Get the port number for the specified service name. */    virtual WORD GetPortByService(      const PString & service   /// Name of service to get port number for.    ) const;    /**Get the port number for the specified service name.           A name is a unique string contained in a system database. The parameter       here may be either this unique name, an integer value or both separated       by a space (name then integer). In the latter case the integer value is       used if the name cannot be found in the database.           The exact behviour of this function is dependent on whether TCP or UDP       transport is being used. The #PTCPSocket# and #PUDPSocket#       classes will implement this function.       The static version of the function is independent of the socket type as       its first parameter may be "tcp" or "udp",        @return       Port number for service name, or 0 if service cannot be found.     */    static WORD GetPortByService(      const char * protocol,     /// Protocol type for port lookup      const PString & service    /// Name of service to get port number for.    );    /**Get the service name from the port number. */    virtual PString GetServiceByPort(      WORD port   /// Number for service to find name of.    ) const;    /**Get the service name from the port number.           A service name is a unique string contained in a system database. The       parameter here may be either this unique name, an integer value or both       separated by a space (name then integer). In the latter case the       integer value is used if the name cannot be found in the database.           The exact behviour of this function is dependent on whether TCP or UDP       transport is being used. The #PTCPSocket# and #PUDPSocket#       classes will implement this function.       The static version of the function is independent of the socket type as       its first parameter may be "tcp" or "udp",        @return       Service name for port number.     */    static PString GetServiceByPort(      const char * protocol,  /// Protocol type for port lookup      WORD port   /// Number for service to find name of.    );    /**Set the port number for the channel. */    void SetPort(      WORD port   /// New port number for the channel.    );    /**Set the port number for the channel. This a 16 bit number representing       an agreed high level protocol type. The string version looks up a       database of names to find the number for the string name.       A service name is a unique string contained in a system database. The       parameter here may be either this unique name, an integer value or both       separated by a space (name then integer). In the latter case the       integer value is used if the name cannot be found in the database.           The port number may not be changed while the port is open and the       function will assert if an attempt is made to do so.     */    void SetPort(      const PString & service   /// Service name to describe the port number.    );    /**Get the port the TCP socket channel object instance is using.       @return       Port number.     */    WORD GetPort() const;    /**Get a service name for the port number the TCP socket channel object       instance is using.       @return       string service name or a string representation of the port number if no       service with that number can be found.     */    PString GetService() const;  //@}  /**@name Multiple socket selection functions */  //@{    /// List of sockets used for #Select()# function    class SelectList : public PSocketList    {      PCLASSINFO(SelectList, PSocketList)      public:        SelectList()          { DisallowDeleteObjects(); }        /** Add a socket to list .*/        void operator+=(PSocket & sock /** Socket to add. */)          { Append(&sock); }        /** Remove a socket from list .*/        void operator-=(PSocket & sock /** Socket to remove. */)          { Remove(&sock); }    };    /**Select a socket with available data. */    static int Select(      PSocket & sock1,        /// First socket to check for readability.      PSocket & sock2         /// Second socket to check for readability.    );    /**Select a socket with available data. */    static int Select(      PSocket & sock1,        /// First socket to check for readability.      PSocket & sock2,        /// Second socket to check for readability.      const PTimeInterval & timeout /// Timeout for wait on read/write data.    );    /**Select a socket with available data. */    static Errors Select(      SelectList & read       /// List of sockets to check for readability.    );    /**Select a socket with available data. */    static Errors Select(      SelectList & read,      /// List of sockets to check for readability.      const PTimeInterval & timeout /// Timeout for wait on read/write data.    );    /**Select a socket with available data. */    static Errors Select(      SelectList & read,      /// List of sockets to check for readability.      SelectList & write      /// List of sockets to check for writability.    );    /**Select a socket with available data. */    static Errors Select(      SelectList & read,      /// List of sockets to check for readability.      SelectList & write,     /// List of sockets to check for writability.      const PTimeInterval & timeout /// Timeout for wait on read/write data.    );    /**Select a socket with available data. */    static Errors Select(      SelectList & read,      /// List of sockets to check for readability.      SelectList & write,     /// List of sockets to check for writability.      SelectList & except     /// List of sockets to check for exceptions.    );    /**Select a socket with available data. This function will block until the       timeout or data is available to be read or written to the specified       sockets.       The #read#, #write# and #except# lists       are modified by the call so that only the sockets that have data       available are present. If the call timed out then all of these lists       will be empty.       If no timeout is specified then the call will block until a socket       has data available.       @return       TRUE if the select was successful or timed out, FALSE if an error       occurred. If a timeout occurred then the lists returned will be empty.       For the versions taking sockets directly instead of lists the integer       returned is >0 for an error being a value from the PChannel::Errors       enum, 0 for a timeout, -1 for the first socket having read data,       -2 for the second socket and -3 for both.     */    static Errors Select(      SelectList & read,      /// List of sockets to check for readability.      SelectList & write,     /// List of sockets to check for writability.      SelectList & except,    /// List of sockets to check for exceptions.      const PTimeInterval & timeout /// Timeout for wait on read/write data.    );  //@}  /**@name Integer conversion functions */  //@{    /// Convert from host to network byte order    inline static WORD  Host2Net(WORD  v) { return htons(v); }    /// Convert from host to network byte order    inline static DWORD Host2Net(DWORD v) { return htonl(v); }    /// Convert from network to host byte order    inline static WORD  Net2Host(WORD  v) { return ntohs(v); }    /// Convert from network to host byte order    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 BOOL OpenSocket() = 0;    /**This function returns the protocol name for the socket type.     */    virtual const char * GetProtocolName() const = 0;    int os_close();    int os_socket(int af, int type, int proto);    int os_connect(      struct sockaddr * sin,      PINDEX size    );    int os_recvfrom(      void * buf,      PINDEX len,      int flags,      struct sockaddr * from,      PINDEX * fromlen    );    int os_sendto(      const void * buf,      PINDEX len,      int flags,      struct sockaddr * to,      PINDEX tolen    );    int os_accept(      int sock,      struct sockaddr * addr,      PINDEX * size,      const PTimeInterval & timeout    );    static int os_select(      int maxfds,      fd_set & readfds,      fd_set & writefds,      fd_set & exceptfds,      const PIntArray & allfds,      const PTimeInterval & timeout    );  // Member variables    /// Port to be used by the socket when opening the channel.    WORD port;#ifdef DOC_PLUS_PLUS};#endif// Class declaration continued in platform specific header file ///////////////