Merge branch 'marchcat/w-whitespace' into marchcat/x-ws-merge

1 files changed, 244 insertions, 244 deletions

diff --git a/indra/llmessage/lliosocket.h b/indra/llmessage/lliosocket.h
index a62b3c0204..0a3f2617e6 100644
--- a/indra/llmessage/lliosocket.h
+++ b/indra/llmessage/lliosocket.h
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file lliosocket.h
  * @author Phoenix
  * @date 2005-07-31
@@ -7,21 +7,21 @@
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -29,7 +29,7 @@
 #ifndef LL_LLIOSOCKET_H
 #define LL_LLIOSOCKET_H
 
-/** 
+/**
  * The socket interface provided here is a simple wraper around apr
  * sockets, with a pipe source and sink to read and write off of the
  * socket. Every socket only performs non-blocking operations except
@@ -48,7 +48,7 @@ extern const std::string CONTEXT_REMOTE_PORT;
 
 class LLHost;
 
-/** 
+/**
  * @class LLSocket
  * @brief Implementation of a wrapper around a socket.
  *
@@ -62,134 +62,134 @@ class LLHost;
 class LLSocket
 {
 public:
-	/** 
-	 * @brief Reference counted shared pointers to sockets.
-	 */
-	typedef std::shared_ptr<LLSocket> ptr_t;
-
-	/** 
-	 * @brief Type of socket to create.
-	 */
-	enum EType
-	{
-		STREAM_TCP,
-		DATAGRAM_UDP,
-	};
-
-	/** 
-	 * @brief Anonymous enumeration to help identify ports
-	 */
-	enum
-	{
-		PORT_INVALID = (U16)-1,
-		PORT_EPHEMERAL = 0,
-	};
-
-	/** 
-	 * @brief Create a socket.
-	 *
-	 * This is the call you would use if you intend to create a listen
-	 * socket. If you intend the socket to be known to external
-	 * clients without prior port notification, do not use
-	 * PORT_EPHEMERAL.
-	 * @param pool The apr pool to use. A child pool will be created
-	 * and associated with the socket.
-	 * @param type The type of socket to create
-	 * @param port The port for the socket
-	 * @param hostname e.g. APR_ANYADDR to listen openly, or "127.0.0.1"
-	 * @return A valid socket shared pointer if the call worked.
-	 */
-	static ptr_t create(
-		apr_pool_t* pool,
-		EType type,
-		U16 port = PORT_EPHEMERAL,
-		const char *hostname = APR_ANYADDR);
-
-	/** 
-	 * @brief Create a LLSocket when you already have an apr socket.
-	 *
-	 * This method assumes an ephemeral port. This is typically used
-	 * by calls which spawn a socket such as a call to
-	 * <code>accept()</code> as in the server socket. This call should
-	 * not fail if you have a valid apr socket.
-	 * Because of the nature of how accept() works, you are expected
-	 * to create a new pool for the socket, use that pool for the
-	 * accept, and pass it in here where it will be bound with the
-	 * socket and destroyed at the same time.
-	 * @param socket The apr socket to use 
-	 * @param pool The pool used to create the socket. *NOTE: The pool
-	 * passed in will be DESTROYED.
-	 * @return A valid socket shared pointer if the call worked.
-	 */
-	static ptr_t create(apr_socket_t* socket, apr_pool_t* pool);
-
-	/** 
-	 * @brief Perform a blocking connect to a host. Do not use in production.
-	 *
-	 * @param host The host to connect this socket to.
-	 * @return Returns true if the connect was successful.
-	 */
-	bool blockingConnect(const LLHost& host);
-
-	/** 
-	 * @brief Get the type of socket
-	 */
-	//EType getType() const { return mType; }
-
-	/** 
-	 * @brief Get the port.
-	 *
-	 * This will return PORT_EPHEMERAL if bind was never called.
-	 * @return Returns the port associated with this socket.
-	 */
-	U16 getPort() const { return mPort; }
-
-	/** 
-	 * @brief Get the apr socket implementation.
-	 *
-	 * @return Returns the raw apr socket.
-	 */
-	apr_socket_t* getSocket() const { return mSocket; }
-
-	/** 
-	 * @brief Set default socket options, with SO_NONBLOCK = 0 and a timeout in us.
-	 * @param timeout Number of microseconds to wait on this socket. Any
-	 * negative number means block-forever. TIMEOUT OF 0 IS NON-PORTABLE.
-	 */
-	void setBlocking(S32 timeout);
-
-	/**
-	 * @brief Set default socket options, with SO_NONBLOCK = 1 and timeout = 0.
-	 */
-	void setNonBlocking();
+    /**
+     * @brief Reference counted shared pointers to sockets.
+     */
+    typedef std::shared_ptr<LLSocket> ptr_t;
+
+    /**
+     * @brief Type of socket to create.
+     */
+    enum EType
+    {
+        STREAM_TCP,
+        DATAGRAM_UDP,
+    };
+
+    /**
+     * @brief Anonymous enumeration to help identify ports
+     */
+    enum
+    {
+        PORT_INVALID = (U16)-1,
+        PORT_EPHEMERAL = 0,
+    };
+
+    /**
+     * @brief Create a socket.
+     *
+     * This is the call you would use if you intend to create a listen
+     * socket. If you intend the socket to be known to external
+     * clients without prior port notification, do not use
+     * PORT_EPHEMERAL.
+     * @param pool The apr pool to use. A child pool will be created
+     * and associated with the socket.
+     * @param type The type of socket to create
+     * @param port The port for the socket
+     * @param hostname e.g. APR_ANYADDR to listen openly, or "127.0.0.1"
+     * @return A valid socket shared pointer if the call worked.
+     */
+    static ptr_t create(
+        apr_pool_t* pool,
+        EType type,
+        U16 port = PORT_EPHEMERAL,
+        const char *hostname = APR_ANYADDR);
+
+    /**
+     * @brief Create a LLSocket when you already have an apr socket.
+     *
+     * This method assumes an ephemeral port. This is typically used
+     * by calls which spawn a socket such as a call to
+     * <code>accept()</code> as in the server socket. This call should
+     * not fail if you have a valid apr socket.
+     * Because of the nature of how accept() works, you are expected
+     * to create a new pool for the socket, use that pool for the
+     * accept, and pass it in here where it will be bound with the
+     * socket and destroyed at the same time.
+     * @param socket The apr socket to use
+     * @param pool The pool used to create the socket. *NOTE: The pool
+     * passed in will be DESTROYED.
+     * @return A valid socket shared pointer if the call worked.
+     */
+    static ptr_t create(apr_socket_t* socket, apr_pool_t* pool);
+
+    /**
+     * @brief Perform a blocking connect to a host. Do not use in production.
+     *
+     * @param host The host to connect this socket to.
+     * @return Returns true if the connect was successful.
+     */
+    bool blockingConnect(const LLHost& host);
+
+    /**
+     * @brief Get the type of socket
+     */
+    //EType getType() const { return mType; }
+
+    /**
+     * @brief Get the port.
+     *
+     * This will return PORT_EPHEMERAL if bind was never called.
+     * @return Returns the port associated with this socket.
+     */
+    U16 getPort() const { return mPort; }
+
+    /**
+     * @brief Get the apr socket implementation.
+     *
+     * @return Returns the raw apr socket.
+     */
+    apr_socket_t* getSocket() const { return mSocket; }
+
+    /**
+     * @brief Set default socket options, with SO_NONBLOCK = 0 and a timeout in us.
+     * @param timeout Number of microseconds to wait on this socket. Any
+     * negative number means block-forever. TIMEOUT OF 0 IS NON-PORTABLE.
+     */
+    void setBlocking(S32 timeout);
+
+    /**
+     * @brief Set default socket options, with SO_NONBLOCK = 1 and timeout = 0.
+     */
+    void setNonBlocking();
 
 protected:
-	/**
-	 * @brief Protected constructor since should only make sockets
-	 * with one of the two <code>create()</code> calls.
-	 */
-	LLSocket(apr_socket_t* socket, apr_pool_t* pool);
+    /**
+     * @brief Protected constructor since should only make sockets
+     * with one of the two <code>create()</code> calls.
+     */
+    LLSocket(apr_socket_t* socket, apr_pool_t* pool);
 
 public:
-	/** 
-	 * @brief Do not call this directly.
-	 */
-	~LLSocket();
+    /**
+     * @brief Do not call this directly.
+     */
+    ~LLSocket();
 
 protected:
-	// The apr socket.
-	apr_socket_t* mSocket;
+    // The apr socket.
+    apr_socket_t* mSocket;
 
-	// our memory pool
-	apr_pool_t* mPool;
+    // our memory pool
+    apr_pool_t* mPool;
 
-	// The port if we know it.
-	U16 mPort;
+    // The port if we know it.
+    U16 mPort;
 
-	//EType mType;
+    //EType mType;
 };
 
-/** 
+/**
  * @class LLIOSocketReader
  * @brief An LLIOPipe implementation which reads from a socket.
  * @see LLIOPipe
@@ -201,44 +201,44 @@ protected:
 class LLIOSocketReader : public LLIOPipe
 {
 public:
-	LLIOSocketReader(LLSocket::ptr_t socket);
-	~LLIOSocketReader();
+    LLIOSocketReader(LLSocket::ptr_t socket);
+    ~LLIOSocketReader();
 
 protected:
-	/* @name LLIOPipe virtual implementations
-	 */
-	//@{
-	/** 
-	 * @brief Process the data coming in the socket.
-	 *
-	 * Since the socket and next pipe must exist for process to make
-	 * any sense, this method will return STATUS_PRECONDITION_NOT_MET
-	 * unless if they are not known.
-	 * If a STATUS_STOP returned by the next link in the chain, this
-	 * reader will turn of the socket polling.
-	 * @param buffer Pointer to a buffer which needs processing. Probably NULL.
-	 * @param bytes Number of bytes to in buffer to process. Probably 0.
-	 * @param eos True if this function is the last. Almost always false.
-	 * @param read Number of bytes actually processed.
-	 * @param pump The pump which is calling process. May be NULL.
-	 * @param context A data structure to pass structured data
-	 * @return STATUS_OK unless the preconditions are not met.
-	 */
-	virtual EStatus process_impl(
-		const LLChannelDescriptors& channels,
-		buffer_ptr_t& buffer,
-		bool& eos,
-		LLSD& context,
-		LLPumpIO* pump);
-	//@}
+    /* @name LLIOPipe virtual implementations
+     */
+    //@{
+    /**
+     * @brief Process the data coming in the socket.
+     *
+     * Since the socket and next pipe must exist for process to make
+     * any sense, this method will return STATUS_PRECONDITION_NOT_MET
+     * unless if they are not known.
+     * If a STATUS_STOP returned by the next link in the chain, this
+     * reader will turn of the socket polling.
+     * @param buffer Pointer to a buffer which needs processing. Probably NULL.
+     * @param bytes Number of bytes to in buffer to process. Probably 0.
+     * @param eos True if this function is the last. Almost always false.
+     * @param read Number of bytes actually processed.
+     * @param pump The pump which is calling process. May be NULL.
+     * @param context A data structure to pass structured data
+     * @return STATUS_OK unless the preconditions are not met.
+     */
+    virtual EStatus process_impl(
+        const LLChannelDescriptors& channels,
+        buffer_ptr_t& buffer,
+        bool& eos,
+        LLSD& context,
+        LLPumpIO* pump);
+    //@}
 
 protected:
-	LLSocket::ptr_t mSource;
-	std::vector<U8> mBuffer;
-	bool mInitialized;
+    LLSocket::ptr_t mSource;
+    std::vector<U8> mBuffer;
+    bool mInitialized;
 };
 
-/** 
+/**
  * @class LLIOSocketWriter
  * @brief An LLIOPipe implementation which writes to a socket
  * @see LLIOPipe
@@ -249,42 +249,42 @@ protected:
 class LLIOSocketWriter : public LLIOPipe
 {
 public:
-	LLIOSocketWriter(LLSocket::ptr_t socket);
-	~LLIOSocketWriter();
+    LLIOSocketWriter(LLSocket::ptr_t socket);
+    ~LLIOSocketWriter();
 
 protected:
-	/* @name LLIOPipe virtual implementations
-	 */
-	//@{
-	/** 
-	 * @brief Write the data in buffer to the socket.
-	 *
-	 * Since the socket pipe must exist for process to make any sense,
-	 * this method will return STATUS_PRECONDITION_NOT_MET if it is
-	 * not known.
-	 * @param buffer Pointer to a buffer which needs processing.
-	 * @param bytes Number of bytes to in buffer to process.
-	 * @param eos True if this function is the last.
-	 * @param read Number of bytes actually processed.
-	 * @param pump The pump which is calling process. May be NULL.
-	 * @param context A data structure to pass structured data
-	 * @return A return code for the write.
-	 */
-	virtual EStatus process_impl(
-		const LLChannelDescriptors& channels,
-		buffer_ptr_t& buffer,
-		bool& eos,
-		LLSD& context,
-		LLPumpIO* pump);
-	//@}
+    /* @name LLIOPipe virtual implementations
+     */
+    //@{
+    /**
+     * @brief Write the data in buffer to the socket.
+     *
+     * Since the socket pipe must exist for process to make any sense,
+     * this method will return STATUS_PRECONDITION_NOT_MET if it is
+     * not known.
+     * @param buffer Pointer to a buffer which needs processing.
+     * @param bytes Number of bytes to in buffer to process.
+     * @param eos True if this function is the last.
+     * @param read Number of bytes actually processed.
+     * @param pump The pump which is calling process. May be NULL.
+     * @param context A data structure to pass structured data
+     * @return A return code for the write.
+     */
+    virtual EStatus process_impl(
+        const LLChannelDescriptors& channels,
+        buffer_ptr_t& buffer,
+        bool& eos,
+        LLSD& context,
+        LLPumpIO* pump);
+    //@}
 
 protected:
-	LLSocket::ptr_t mDestination;
-	U8* mLastWritten;
-	bool mInitialized;
+    LLSocket::ptr_t mDestination;
+    U8* mLastWritten;
+    bool mInitialized;
 };
 
-/** 
+/**
  * @class LLIOServerSocket
  * @brief An IOPipe implementation which listens and spawns connected
  * sockets.
@@ -304,49 +304,49 @@ protected:
 class LLIOServerSocket : public LLIOPipe
 {
 public:
-	typedef LLSocket::ptr_t socket_t;
-	typedef std::shared_ptr<LLChainIOFactory> factory_t;
-	LLIOServerSocket(apr_pool_t* pool, socket_t listener, factory_t reactor);
-	virtual ~LLIOServerSocket();
-
-	/** 
-	 * @brief Set the timeout for the generated chains.
-	 *
-	 * This value is passed directly to the LLPumpIO::addChain()
-	 * method. The default on construction is set to
-	 * DEFAULT_CHAIN_EXPIRY_SECS which is a reasonable value for most
-	 * applications based on this library. Avoid passing in
-	 * NEVER_CHAIN_EXPIRY_SECS unless you have another method of
-	 * harvesting chains.
-	 * @param timeout_secs The seconds before timeout for the response chain. 
-	 */
-	void setResponseTimeout(F32 timeout_secs);
-
-	/* @name LLIOPipe virtual implementations
-	 */
-	//@{
+    typedef LLSocket::ptr_t socket_t;
+    typedef std::shared_ptr<LLChainIOFactory> factory_t;
+    LLIOServerSocket(apr_pool_t* pool, socket_t listener, factory_t reactor);
+    virtual ~LLIOServerSocket();
+
+    /**
+     * @brief Set the timeout for the generated chains.
+     *
+     * This value is passed directly to the LLPumpIO::addChain()
+     * method. The default on construction is set to
+     * DEFAULT_CHAIN_EXPIRY_SECS which is a reasonable value for most
+     * applications based on this library. Avoid passing in
+     * NEVER_CHAIN_EXPIRY_SECS unless you have another method of
+     * harvesting chains.
+     * @param timeout_secs The seconds before timeout for the response chain.
+     */
+    void setResponseTimeout(F32 timeout_secs);
+
+    /* @name LLIOPipe virtual implementations
+     */
+    //@{
 protected:
-	/** 
-	 * @brief Process the data in buffer
-	 */
-	virtual EStatus process_impl(
-		const LLChannelDescriptors& channels,
-		buffer_ptr_t& buffer,
-		bool& eos,
-		LLSD& context,
-		LLPumpIO* pump);
-	//@}
+    /**
+     * @brief Process the data in buffer
+     */
+    virtual EStatus process_impl(
+        const LLChannelDescriptors& channels,
+        buffer_ptr_t& buffer,
+        bool& eos,
+        LLSD& context,
+        LLPumpIO* pump);
+    //@}
 
 protected:
-	apr_pool_t* mPool;
-	socket_t mListenSocket;
-	factory_t mReactor;
-	bool mInitialized;
-	F32 mResponseTimeout;
+    apr_pool_t* mPool;
+    socket_t mListenSocket;
+    factory_t mReactor;
+    bool mInitialized;
+    F32 mResponseTimeout;
 };
 
 #if 0
-/** 
+/**
  * @class LLIODataSocket
  * @brief BRIEF_DESC
  *
@@ -355,31 +355,31 @@ protected:
 class LLIODataSocket : public LLIOSocket
 {
 public:
-	/**
-	 * @brief Construct a datagram socket.
-	 *
-	 * If you pass in LLIOSocket::PORT_EPHEMERAL as the suggested
-	 * port, The socket will not be in a 'listen' mode, but can still
-	 * read data sent back to it's port. When suggested_port is not
-	 * ephemeral or invalid and bind fails, the port discovery
-	 * algorithm will search through a limited set of ports to
-	 * try to find an open port. If that process fails, getPort() will
-	 * return LLIOSocket::PORT_INVALID
-	 * @param suggested_port The port you would like to bind. Use
-	 * LLIOSocket::PORT_EPHEMERAL for an unspecified port.
-	 * @param start_discovery_port The start range for
-	 * @param pool The pool to use for allocation.
-	 */
-	LLIODataSocket(
-		U16 suggested_port,
-		U16 start_discovery_port,
-		apr_pool_t* pool);
-	virtual ~LLIODataSocket();
+    /**
+     * @brief Construct a datagram socket.
+     *
+     * If you pass in LLIOSocket::PORT_EPHEMERAL as the suggested
+     * port, The socket will not be in a 'listen' mode, but can still
+     * read data sent back to it's port. When suggested_port is not
+     * ephemeral or invalid and bind fails, the port discovery
+     * algorithm will search through a limited set of ports to
+     * try to find an open port. If that process fails, getPort() will
+     * return LLIOSocket::PORT_INVALID
+     * @param suggested_port The port you would like to bind. Use
+     * LLIOSocket::PORT_EPHEMERAL for an unspecified port.
+     * @param start_discovery_port The start range for
+     * @param pool The pool to use for allocation.
+     */
+    LLIODataSocket(
+        U16 suggested_port,
+        U16 start_discovery_port,
+        apr_pool_t* pool);
+    virtual ~LLIODataSocket();
 
 protected:
 
 private:
-	apr_socket_t* mSocket;
+    apr_socket_t* mSocket;
 };
 #endif