Merging upstream version 1.44.3.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 396 insertions, 0 deletions

diff --git a/ml/dlib/dlib/sockets/sockets_kernel_2.h b/ml/dlib/dlib/sockets/sockets_kernel_2.h
new file mode 100644
index 000000000..f3bc94ec0
--- /dev/null
+++ b/ml/dlib/dlib/sockets/sockets_kernel_2.h
@@ -0,0 +1,396 @@
+// Copyright (C) 2003  Davis E. King (davis@dlib.net), Miguel Grinberg
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_SOCKETS_KERNEl_2_
+#define DLIB_SOCKETS_KERNEl_2_
+
+#ifdef DLIB_ISO_CPP_ONLY
+#error "DLIB_ISO_CPP_ONLY is defined so you can't use this OS dependent code.  Turn DLIB_ISO_CPP_ONLY off if you want to use it."
+#endif
+
+#include "../platform.h"
+
+#include "sockets_kernel_abstract.h"
+
+#define _BSD_SOCKLEN_T_
+
+#include <ctime>
+#include <memory>
+#include <string>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <errno.h>
+
+#ifndef HPUX
+#include <sys/select.h>
+#endif
+#include <arpa/inet.h>
+#include <signal.h>
+#include <inttypes.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <sys/param.h>
+
+#include <netinet/in.h>
+
+#include "../threads.h"
+#include "../algs.h"
+
+
+
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    // forward declarations
+    class socket_factory;
+    class listener;
+
+// ----------------------------------------------------------------------------------------
+
+    // lookup functions
+
+    int
+    get_local_hostname (
+        std::string& hostname
+    );
+
+// -----------------
+
+    int 
+    hostname_to_ip (
+        const std::string& hostname,
+        std::string& ip,
+        int n = 0
+    );
+
+// -----------------
+
+    int
+    ip_to_hostname (
+        const std::string& ip,
+        std::string& hostname
+    );
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+    // connection object
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    class connection
+    {
+        /*!
+            INITIAL_VALUE
+                sd                      == false
+                sdo                     == false
+                sdr                     == 0
+
+
+            CONVENTION
+                connection_socket       == the socket handle for this connection.  
+                connection_foreign_port == the port that foreign host is using for 
+                                           this connection
+                connection_foreign_ip   == a string containing the IP address of the 
+                                           foreign host
+                connection_local_port   == the port that the local host is using for 
+                                           this connection
+                connection_local_ip     == a string containing the IP address of the 
+                                           local interface being used by this connection
+
+                sd                      == if shutdown() has been called then true
+                                           else false
+                sdo                     == if shutdown_outgoing() has been called then true
+                                           else false
+                sdr                     == the return value of shutdown() if it has been
+                                           called.  if it hasn't been called then 0
+
+
+        !*/
+
+        friend class listener;                // make listener a friend of connection
+        // make create_connection a friend of connection
+        friend int create_connection ( 
+            connection*& new_connection,
+            unsigned short foreign_port, 
+            const std::string& foreign_ip, 
+            unsigned short local_port,
+            const std::string& local_ip
+        );
+
+    public:
+
+        ~connection();
+
+        void* user_data;
+
+        long write (
+            const char* buf, 
+            long num
+        );
+
+        long read (
+            char* buf, 
+            long num
+        );
+
+        long read (
+            char* buf, 
+            long num,
+            unsigned long timeout
+        );
+
+        int get_local_port (
+        ) const { return connection_local_port; }
+
+        int get_foreign_port ( 
+        ) const { return connection_foreign_port; }
+
+        const std::string& get_local_ip (
+        ) const { return connection_local_ip; }
+
+        const std::string& get_foreign_ip (
+        ) const { return connection_foreign_ip; }
+
+        int shutdown_outgoing (
+        ) 
+        {
+            sd_mutex.lock();
+            if (sdo || sd)
+            {
+                sd_mutex.unlock();
+                return sdr;
+            }
+            sdo = true;
+            sdr = ::shutdown(connection_socket,SHUT_WR); 
+            int temp = sdr;
+            sd_mutex.unlock();
+            return temp;  
+        }
+
+        int shutdown (
+        ) 
+        {
+            sd_mutex.lock();
+            if (sd)
+            {
+                sd_mutex.unlock();
+                return sdr;
+            }
+            sd = true;
+            sdr = ::shutdown(connection_socket,SHUT_RDWR); 
+            int temp = sdr;
+            sd_mutex.unlock();            
+            return temp;
+        }
+
+        int disable_nagle(
+        );
+
+        typedef int socket_descriptor_type;
+
+        socket_descriptor_type get_socket_descriptor (
+        ) const { return connection_socket; }
+
+    private:
+
+        bool readable (
+            unsigned long timeout 
+        ) const;
+        /*! 
+            requires 
+                - timeout < 2000000  
+            ensures 
+                - returns true if a read call on this connection will not block. 
+                - returns false if a read call on this connection will block or if 
+                  there was an error. 
+        !*/ 
+
+        bool sd_called (
+        )const
+        /*!
+            ensures
+                - returns true if shutdown() has been called else
+                - returns false
+        !*/
+        {
+            sd_mutex.lock();
+            bool temp = sd;
+            sd_mutex.unlock();
+            return temp;
+        }
+
+        bool sdo_called (
+        )const
+        /*!
+            ensures
+                - returns true if shutdown_outgoing() or shutdown() has been called
+                  else returns false
+        !*/
+        {
+            sd_mutex.lock();
+            bool temp = false;
+            if (sdo || sd)
+                temp = true;
+            sd_mutex.unlock();
+            return temp;
+        }
+
+
+        // data members
+        int connection_socket;
+        const int connection_foreign_port;
+        const std::string connection_foreign_ip; 
+        const int connection_local_port;
+        const std::string connection_local_ip;
+
+        bool sd;  // called shutdown
+        bool sdo; // called shutdown_outgoing
+        int sdr; // return value for shutdown 
+        mutex sd_mutex; // a lock for the three above vars
+
+        connection(
+            int sock,
+            int foreign_port, 
+            const std::string& foreign_ip, 
+            int local_port,
+            const std::string& local_ip
+        ); 
+        /*!
+            requires
+                - sock is a socket handle 
+                - sock is the handle for the connection between foreign_ip:foreign_port 
+                  and local_ip:local_port
+            ensures
+                - *this is initialized correctly with the above parameters
+        !*/
+
+
+        // restricted functions
+        connection();
+        connection(connection&);        // copy constructor
+        connection& operator=(connection&);    // assignement opertor
+    }; 
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+    // listener object
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    class listener
+    {
+        /*!
+            CONVENTION
+                if (inaddr_any == false)
+                {
+                    listening_ip == a string containing the address the listener is 
+                                    listening on
+                }
+                else
+                {
+                    the listener is listening on all interfaces
+                }
+                
+                listening_port == the port the listener is listening on
+                listening_socket == the listening socket handle for this object
+        !*/
+
+        // make the create_listener a friend of listener
+        friend int create_listener (
+            listener*& new_listener,
+            unsigned short port,
+            const std::string& ip
+        );
+
+    public:
+
+        ~listener();
+
+        int accept (
+            connection*& new_connection,
+            unsigned long timeout = 0
+        );
+
+        int accept (
+            std::unique_ptr<connection>& new_connection,
+            unsigned long timeout = 0
+        );
+
+        int get_listening_port (
+        ) const { return listening_port; }
+
+        const std::string& get_listening_ip (
+        ) const { return listening_ip; }
+
+    private:
+
+        // data members
+        int listening_socket;
+        const int listening_port;
+        const std::string listening_ip;
+        const bool inaddr_any;
+
+        listener(
+            int sock,
+            int port,
+            const std::string& ip
+        );
+        /*!
+            requires
+                - sock is a socket handle 
+                - sock is listening on the port and ip(may be "") indicated in the above 
+                  parameters
+            ensures
+                - *this is initialized correctly with the above parameters
+        !*/
+
+
+        // restricted functions
+        listener();
+        listener(listener&);        // copy constructor
+        listener& operator=(listener&);    // assignement opertor
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    int create_listener (
+        listener*& new_listener,
+        unsigned short port,
+        const std::string& ip = ""
+    );
+
+    int create_connection ( 
+        connection*& new_connection,
+        unsigned short foreign_port, 
+        const std::string& foreign_ip, 
+        unsigned short local_port = 0,
+        const std::string& local_ip = ""
+    );
+
+    int create_listener (
+        std::unique_ptr<listener>& new_listener,
+        unsigned short port,
+        const std::string& ip = ""
+    );
+
+    int create_connection ( 
+        std::unique_ptr<connection>& new_connection,
+        unsigned short foreign_port, 
+        const std::string& foreign_ip, 
+        unsigned short local_port = 0,
+        const std::string& local_ip = ""
+    );
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#ifdef NO_MAKEFILE
+#include "sockets_kernel_2.cpp"
+#endif
+
+#endif // DLIB_SOCKETS_KERNEl_2_
+