Changeset 314

Timestamp:

04/28/07 09:52:16 (2 years ago)

Author:

blackhedd

Message:

supported connections to Unix-domain sockets. This will eventually need to be refactored,
as there is some namespace pollution between the TCP-support and the Unix-domain-support
method.

Files:

• version_0/ext/cmain.cpp (modified) (1 diff)
• version_0/ext/em.cpp (modified) (1 diff)
• version_0/ext/em.h (modified) (1 diff)
• version_0/ext/eventmachine.h (modified) (1 diff)
• version_0/ext/rubymain.cpp (modified) (2 diffs)
• version_0/lib/eventmachine.rb (modified) (1 diff)

version_0/ext/cmain.cpp

@@ -94 +94 @@
-}
-
+/***************************
+evma_connect_to_unix_server
+***************************/
+
+extern "C" const char *evma_connect_to_unix_server (const char *server)
+{
+        if (!EventMachine)
+                throw std::runtime_error ("not initialized");
+        return EventMachine->ConnectToUnixServer (server);
+}
+
-
-/**********************

version_0/ext/em.cpp

@@ -647 +647 @@
-}
-
+/***********************************
+EventMachine_t::ConnectToUnixServer
+***********************************/
+
+const char *EventMachine_t::ConnectToUnixServer (const char *server)
+{
+        /* Connect to a Unix-domain server, which by definition is running
+         * on the same host.
+         * There is no meaningful implementation on Windows.
+         * There's no need to do a nonblocking connect, since the connection
+         * is always local and can always be fulfilled immediately.
+         */
+
+        #ifdef OS_WIN32
+        throw std::runtime_error ("unix-domain connection unavailable on this platform");
+        return NULL;
+        #endif
+
+        // The whole rest of this function is only compiled on Unix systems.
+        #ifdef OS_UNIX
+
+        const char *out = NULL;
+
+        if (!server || !*server)
+                return NULL;
+
+        sockaddr_un pun;
+        memset (&pun, 0, sizeof(pun));
+        pun.sun_family = AF_LOCAL;
+
+        // You ordinarily expect the server name field to be at least 1024 bytes long,
+        // but on Linux it can be MUCH shorter.
+        if (strlen(server) >= sizeof(pun.sun_path))
+                throw std::runtime_error ("unix-domain server name is too long");
+
+
+        strcpy (pun.sun_path, server);
+
+        int fd = socket (AF_LOCAL, SOCK_STREAM, 0);
+        if (fd == INVALID_SOCKET)
+                return NULL;
+
+        // From here on, ALL error returns must close the socket.
+        // NOTE: At this point, the socket is still a blocking socket.
+        if (connect (fd, (struct sockaddr*)&pun, sizeof(pun)) != 0) {
+                closesocket (fd);
+                return NULL;
+        }
+
+        // Set the newly-connected socket nonblocking.
+        if (!SetSocketNonblocking (fd)) {
+                closesocket (fd);
+                return NULL;
+        }
+
+        // Set up a connection descriptor and add it to the event-machine.
+        // Observe, even though we know the connection status is connect-success,
+        // we still set the "pending" flag, so some needed initializations take
+        // place.
+        ConnectionDescriptor *cd = new ConnectionDescriptor (fd);
+        if (!cd)
+                throw std::runtime_error ("no connection allocated");
+        cd->SetConnectPending (true);
+        Add (cd);
+        out = cd->GetBinding().c_str();
+
+        if (out == NULL)
+                closesocket (fd);
+
+        return out;
+        #endif
+}
+
-
-/*******************************

version_0/ext/em.h

@@ -73 +73 @@
-                const char *InstallOneshotTimer (int);
-                const char *ConnectToServer (const char *, int);
+                const char *ConnectToUnixServer (const char *);
-                const char *CreateTcpServer (const char *, int);
-                const char *OpenDatagramSocket (const char *, int);

version_0/ext/eventmachine.h

@@ -37 +37 @@
-        const char *evma_install_oneshot_timer (int seconds);
-        const char *evma_connect_to_server (const char *server, int port);
+        const char *evma_connect_to_unix_server (const char *server);
-        const char *evma_create_tcp_server (const char *address, int port);
-        const char *evma_create_unix_domain_server (const char *filename);

version_0/ext/rubymain.cpp

@@ -206 +206 @@
-
-        const char *f = evma_connect_to_server (StringValuePtr(server), NUM2INT(port));
+        if (!f || !*f)
+                rb_raise (rb_eRuntimeError, "no connection");
+        return rb_str_new2 (f);
+}
+
+/*********************
+t_connect_unix_server
+*********************/
+
+static VALUE t_connect_unix_server (VALUE self, VALUE serversocket)
+{
+        const char *f = evma_connect_to_unix_server (StringValuePtr(serversocket));
-        if (!f || !*f)
-                rb_raise (rb_eRuntimeError, "no connection");
@@ -323 +335 @@
-        rb_define_module_function (EmModule, "close_connection", (VALUE(*)(...))t_close_connection, 2);
-        rb_define_module_function (EmModule, "connect_server", (VALUE(*)(...))t_connect_server, 2);
+        rb_define_module_function (EmModule, "connect_unix_server", (VALUE(*)(...))t_connect_unix_server, 1);
-        rb_define_module_function (EmModule, "open_udp_socket", (VALUE(*)(...))t_open_udp_socket, 2);
-        rb_define_module_function (EmModule, "release_machine", (VALUE(*)(...))t_release_machine, 0);

version_0/lib/eventmachine.rb

@@ -606 +606 @@
-
-
+
+
+        # Make a connection to a Unix-domain socket. This is not implemented on Windows platforms.
+        # The parameter socketname is a String which identifies the Unix-domain socket you want
+        # to connect to. socketname is the name of a file on your local system, and in most cases
+        # is a fully-qualified path name. Make sure that your process has enough local permissions
+        # to open the Unix-domain socket.
+        # See also the documentation for #connect_server. This method behaves like #connect_server
+        # in all respects except for the fact that it makes a connection to a local Unix-domain
+        # socket rather than a TCP socket.
+        #--
+        # For making connections to Unix-domain sockets.
+        # Eventually this has to get properly documented and unified with the TCP-connect methods.
+        # Note how nearly identical this is to EventMachine#connect
+        def EventMachine::connect_unix socketname, handler=nil
+                klass = if (handler and handler.is_a?(Class))
+                        handler
+                else
+                        Class.new( Connection ) {handler and include handler}
+                end
+
+                s = connect_unix_server socketname
+                c = klass.new s
+                @conns[s] = c
+                block_given? and yield c
+                c
+        end
+
+
-  # EventMachine#open_datagram_socket is for support of UDP-based
-  # protocols. Its usage is similar to that of EventMachine#start_server.