lib/core: Renamed `Text::bytelen` to `Text::byte_length`

[nit.git] / lib / libevent.nit

diff --git a/lib/libevent.nit b/lib/libevent.nit
index 5ad186f..614f3d9 100644 (file)
--- a/lib/libevent.nit
+++ b/lib/libevent.nit
@@ -22,18 +22,25 @@
 module libevent is pkgconfig("libevent")
 
 in "C header" `{
-       #include <sys/stat.h>
-       #include <sys/types.h>
-       #include <fcntl.h>
-       #include <errno.h>
-       #include <sys/socket.h>
-
        #include <event2/listener.h>
        #include <event2/bufferevent.h>
        #include <event2/buffer.h>
 `}
 
 in "C" `{
+       #include <sys/stat.h>
+       #include <sys/types.h>
+       #include <fcntl.h>
+       #include <errno.h>
+       #include <string.h>
+
+       #include <sys/socket.h>
+       #include <arpa/inet.h>
+       #include <netinet/in.h>
+       #include <netinet/ip.h>
+
+// Protect callbacks for compatibility with light FFI
+#ifdef Connection_decr_ref
        // Callback forwarded to 'Connection.write_callback'
        static void c_write_cb(struct bufferevent *bev, Connection ctx) {
                Connection_write_callback(ctx);
@@ -48,23 +55,18 @@ in "C" `{
        // Callback forwarded to 'Connection.event_callback'
        static void c_event_cb(struct bufferevent *bev, short events, Connection ctx)
        {
-               Connection_event_callback(ctx, events);
-
-               // TODO move to Nit code
-               if (events & BEV_EVENT_ERROR)
-                       perror("Error from bufferevent");
-               if (events & (BEV_EVENT_EOF | BEV_EVENT_ERROR)) {
-                       bufferevent_free(bev);
-                       Connection_decr_ref(ctx);
-               }
+               int release = Connection_event_callback(ctx, events);
+               if (release) Connection_decr_ref(ctx);
        }
 
        // Callback forwarded to 'ConnectionFactory.accept_connection'
        static void accept_connection_cb(struct evconnlistener *listener, evutil_socket_t fd,
-               struct sockaddr *address, int socklen, ConnectionFactory ctx)
+               struct sockaddr *addrin, int socklen, ConnectionFactory ctx)
        {
-               ConnectionFactory_accept_connection(ctx, listener, fd, address, socklen);
+               ConnectionFactory_accept_connection(ctx, listener, fd, addrin, socklen);
        }
+#endif
+
 `}
 
 # Structure to hold information and state for a Libevent dispatch loop.
@@ -141,14 +143,25 @@ class Connection
                if close_requested then close
        end
 
-       # Callback method on events
-       fun event_callback(events: Int) do end
+       # Callback method on events: EOF, user-defined timeout and unrecoverable errors
+       #
+       # Returns `true` if the native handles to `self` can be released.
+       fun event_callback(events: Int): Bool
+       do
+               if events & bev_event_error != 0 or events & bev_event_eof != 0 then
+                       if events & bev_event_error != 0 then print_error "Error from bufferevent"
+                       close
+                       return true
+               end
+
+               return false
+       end
 
        # Write a string to the connection
        redef fun write(str)
        do
                if close_requested then return
-               native_buffer_event.write(str.to_cstring, str.bytelen)
+               native_buffer_event.write(str.to_cstring, str.byte_length)
        end
 
        redef fun write_byte(byte)
@@ -342,6 +355,10 @@ extern class ConnectionListener `{ struct evconnlistener * `}
 
                struct hostent *hostent = gethostbyname(address);
 
+               if (!hostent) {
+                       return NULL;
+               }
+
                memset(&sin, 0, sizeof(sin));
                sin.sin_family = hostent->h_addrtype;
                sin.sin_port = htons(port);
@@ -384,17 +401,26 @@ class ConnectionFactory
        # Accept a connection on `listener`
        #
        # By default, it creates a new NativeBufferEvent and calls `spawn_connection`.
-       fun accept_connection(listener: ConnectionListener, fd: Int, address: Pointer, socklen: Int)
+       fun accept_connection(listener: ConnectionListener, fd: Int, addrin: Pointer, socklen: Int)
        do
                var base = listener.base
                var bev = new NativeBufferEvent.socket(base, fd, bev_opt_close_on_free)
-               var conn = spawn_connection(bev)
+
+               # Human representation of remote client address
+               var addr_len = 46 # Longest possible IPv6 address + null byte
+               var addr_buf = new NativeString(addr_len)
+               addr_buf = addrin_to_address(addrin, addr_buf, addr_len)
+               var addr = if addr_buf.address_is_null then
+                               "Unknown address"
+                       else addr_buf.to_s
+
+               var conn = spawn_connection(bev, addr)
                bev.enable ev_read|ev_write
                bev.setcb conn
        end
 
        # Create a new `Connection` object for `buffer_event`
-       fun spawn_connection(buffer_event: NativeBufferEvent): Connection
+       fun spawn_connection(buffer_event: NativeBufferEvent, address: String): Connection
        do
                return new Connection(buffer_event)
        end
@@ -408,4 +434,19 @@ class ConnectionFactory
                end
                return listener
        end
+
+       # Put string representation of source `address` into `buf`
+       private fun addrin_to_address(address: Pointer, buf: NativeString, buf_len: Int): NativeString `{
+               struct sockaddr *addrin = (struct sockaddr*)address;
+
+               if (addrin->sa_family == AF_INET) {
+                       struct in_addr *src = &((struct sockaddr_in*)addrin)->sin_addr;
+                       return (char *)inet_ntop(addrin->sa_family, src, buf, buf_len);
+               }
+               else if (addrin->sa_family == AF_INET6) {
+                       struct in6_addr *src = &((struct sockaddr_in6*)addrin)->sin6_addr;
+                       return (char *)inet_ntop(addrin->sa_family, src, buf, buf_len);
+               }
+               return NULL;
+       `}
 end