sfml3-rb 0.0.1 → 0.2.2

data/ext/network/packet.c

@@ -0,0 +1,189 @@
+#include "network/packet.h"
+
+#include <ruby.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+/* Strings are NUL-terminated on the wire and carry no length, so readString
+   has to be handed a buffer. This bounds a single read; longer strings are
+   still read correctly by CSFML, they just cannot be returned safely. */
+#define PACKET_STRING_BUFFER 4096
+
+typedef struct {
+    sfPacket *packet;
+} Packet;
+
+static VALUE rb_cPacket;
+
+static void Packet_free(void *ptr) {
+    Packet *packet = ptr;
+
+    sfPacket_destroy(packet->packet);
+    free(packet);
+}
+
+static const rb_data_type_t Packet_data_type = {
+    .wrap_struct_name = "SFML::Packet",
+    .function = {.dmark = NULL, .dfree = Packet_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Packet_wrap(VALUE klass, sfPacket *packet) {
+    Packet *ptr;
+
+    if (packet == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create packet");
+    }
+
+    ptr = malloc(sizeof(Packet));
+    ptr->packet = packet;
+
+    return TypedData_Wrap_Struct(klass, &Packet_data_type, ptr);
+}
+
+static VALUE Packet_new(VALUE klass) {
+    return Packet_wrap(klass, sfPacket_create());
+}
+
+static VALUE Packet_copy(VALUE self) {
+    return Packet_wrap(Get_Klass_Packet(), sfPacket_copy(Get_Packet_Struct(self)));
+}
+
+static VALUE Packet_append(VALUE self, VALUE rb_data) {
+    StringValue(rb_data);
+
+    sfPacket_append(Get_Packet_Struct(self), RSTRING_PTR(rb_data), (size_t) RSTRING_LEN(rb_data));
+
+    return self;
+}
+
+static VALUE Packet_clear(VALUE self) {
+    sfPacket_clear(Get_Packet_Struct(self));
+    return self;
+}
+
+static VALUE Packet_data(VALUE self) {
+    const void *data = sfPacket_getData(Get_Packet_Struct(self));
+
+    return rb_str_new((const char *) data, (long) sfPacket_getDataSize(Get_Packet_Struct(self)));
+}
+
+static VALUE Packet_data_size(VALUE self) {
+    return SIZET2NUM(sfPacket_getDataSize(Get_Packet_Struct(self)));
+}
+
+static VALUE Packet_read_position(VALUE self) {
+    return SIZET2NUM(sfPacket_getReadPosition(Get_Packet_Struct(self)));
+}
+
+static VALUE Packet_end_of_packet(VALUE self) {
+    return BOOL2RB(sfPacket_endOfPacket(Get_Packet_Struct(self)));
+}
+
+static VALUE Packet_can_read(VALUE self) {
+    return BOOL2RB(sfPacket_canRead(Get_Packet_Struct(self)));
+}
+
+#define PACKET_READER(name, c_type, conv)                      \
+    static VALUE Packet_read_##name(VALUE self) {              \
+        return conv(sfPacket_read##c_type(Get_Packet_Struct(self))); \
+    }
+
+#define PACKET_WRITER(name, c_type, num2)                                    \
+    static VALUE Packet_write_##name(VALUE self, VALUE rb_value) {           \
+        sfPacket_write##c_type(Get_Packet_Struct(self), num2(rb_value));     \
+        return rb_value;                                                     \
+    }
+
+PACKET_READER(bool, Bool, BOOL2RB)
+PACKET_READER(int8, Int8, INT2NUM)
+PACKET_READER(uint8, Uint8, UINT2NUM)
+PACKET_READER(int16, Int16, INT2NUM)
+PACKET_READER(uint16, Uint16, UINT2NUM)
+PACKET_READER(int32, Int32, INT2NUM)
+PACKET_READER(uint32, Uint32, UINT2NUM)
+PACKET_READER(int64, Int64, LL2NUM)
+PACKET_READER(uint64, Uint64, ULL2NUM)
+PACKET_READER(float, Float, DBL2NUM)
+PACKET_READER(double, Double, DBL2NUM)
+
+PACKET_WRITER(bool, Bool, RTEST)
+PACKET_WRITER(int8, Int8, (int8_t) NUM2INT)
+PACKET_WRITER(uint8, Uint8, (uint8_t) NUM2INT)
+PACKET_WRITER(int16, Int16, (int16_t) NUM2INT)
+PACKET_WRITER(uint16, Uint16, (uint16_t) NUM2INT)
+PACKET_WRITER(int32, Int32, (int32_t) NUM2INT)
+PACKET_WRITER(uint32, Uint32, (uint32_t) NUM2UINT)
+PACKET_WRITER(int64, Int64, (int64_t) NUM2LL)
+PACKET_WRITER(uint64, Uint64, (uint64_t) NUM2ULL)
+PACKET_WRITER(float, Float, (float) NUM2DBL)
+PACKET_WRITER(double, Double, NUM2DBL)
+
+static VALUE Packet_read_string(VALUE self) {
+    char buffer[PACKET_STRING_BUFFER];
+
+    buffer[0] = '\0';
+    sfPacket_readString(Get_Packet_Struct(self), buffer);
+    buffer[PACKET_STRING_BUFFER - 1] = '\0';
+
+    return rb_str_new_cstr(buffer);
+}
+
+static VALUE Packet_write_string(VALUE self, VALUE rb_value) {
+    sfPacket_writeString(Get_Packet_Struct(self), StringValueCStr(rb_value));
+    return rb_value;
+}
+
+void Init_Packet(VALUE rb_module) {
+    rb_cPacket = rb_define_class_under(rb_module, "Packet", rb_cObject);
+
+    rb_define_singleton_method(rb_cPacket, "new", Packet_new, 0);
+
+    rb_define_method(rb_cPacket, "copy", Packet_copy, 0);
+    rb_define_method(rb_cPacket, "append", Packet_append, 1);
+    rb_define_method(rb_cPacket, "clear", Packet_clear, 0);
+    rb_define_method(rb_cPacket, "data", Packet_data, 0);
+    rb_define_method(rb_cPacket, "data_size", Packet_data_size, 0);
+    rb_define_method(rb_cPacket, "read_position", Packet_read_position, 0);
+    rb_define_method(rb_cPacket, "end_of_packet?", Packet_end_of_packet, 0);
+    rb_define_method(rb_cPacket, "can_read?", Packet_can_read, 0);
+
+    rb_define_method(rb_cPacket, "read_bool", Packet_read_bool, 0);
+    rb_define_method(rb_cPacket, "read_int8", Packet_read_int8, 0);
+    rb_define_method(rb_cPacket, "read_uint8", Packet_read_uint8, 0);
+    rb_define_method(rb_cPacket, "read_int16", Packet_read_int16, 0);
+    rb_define_method(rb_cPacket, "read_uint16", Packet_read_uint16, 0);
+    rb_define_method(rb_cPacket, "read_int32", Packet_read_int32, 0);
+    rb_define_method(rb_cPacket, "read_uint32", Packet_read_uint32, 0);
+    rb_define_method(rb_cPacket, "read_int64", Packet_read_int64, 0);
+    rb_define_method(rb_cPacket, "read_uint64", Packet_read_uint64, 0);
+    rb_define_method(rb_cPacket, "read_float", Packet_read_float, 0);
+    rb_define_method(rb_cPacket, "read_double", Packet_read_double, 0);
+    rb_define_method(rb_cPacket, "read_string", Packet_read_string, 0);
+
+    rb_define_method(rb_cPacket, "write_bool", Packet_write_bool, 1);
+    rb_define_method(rb_cPacket, "write_int8", Packet_write_int8, 1);
+    rb_define_method(rb_cPacket, "write_uint8", Packet_write_uint8, 1);
+    rb_define_method(rb_cPacket, "write_int16", Packet_write_int16, 1);
+    rb_define_method(rb_cPacket, "write_uint16", Packet_write_uint16, 1);
+    rb_define_method(rb_cPacket, "write_int32", Packet_write_int32, 1);
+    rb_define_method(rb_cPacket, "write_uint32", Packet_write_uint32, 1);
+    rb_define_method(rb_cPacket, "write_int64", Packet_write_int64, 1);
+    rb_define_method(rb_cPacket, "write_uint64", Packet_write_uint64, 1);
+    rb_define_method(rb_cPacket, "write_float", Packet_write_float, 1);
+    rb_define_method(rb_cPacket, "write_double", Packet_write_double, 1);
+    rb_define_method(rb_cPacket, "write_string", Packet_write_string, 1);
+}
+
+VALUE Get_Klass_Packet(void) {
+    return rb_cPacket;
+}
+
+void *Get_Packet_Struct(VALUE self) {
+    Packet *ptr;
+    TypedData_Get_Struct(self, Packet, &Packet_data_type, ptr);
+    return ptr->packet;
+}

data/ext/network/packet.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_NETWORK_PACKET_H
+#define SFML_RB_NETWORK_PACKET_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Packet(VALUE rb_module);
+
+VALUE Get_Klass_Packet(void);
+
+void *Get_Packet_Struct(VALUE self);
+
+#endif //SFML_RB_NETWORK_PACKET_H

data/ext/network/socket_selector.c

@@ -0,0 +1,142 @@
+#include "network/socket_selector.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "core/exceptions.h"
+#include "core/macros.h"
+#include "network/tcp_listener.h"
+#include "network/tcp_socket.h"
+#include "network/udp_socket.h"
+#include "system/time.h"
+
+typedef struct {
+    sfSocketSelector *handle;
+} SocketSelector;
+
+static VALUE rb_cSocketSelector;
+
+static void SocketSelector_free(void *ptr) {
+    SocketSelector *selector = ptr;
+
+    sfSocketSelector_destroy(selector->handle);
+    free(selector);
+}
+
+static const rb_data_type_t SocketSelector_data_type = {
+    .wrap_struct_name = "SFML::SocketSelector",
+    .function = {.dmark = NULL, .dfree = SocketSelector_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE SocketSelector_wrap(VALUE klass, sfSocketSelector *handle) {
+    SocketSelector *ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create socket selector");
+    }
+
+    ptr = malloc(sizeof(SocketSelector));
+    ptr->handle = handle;
+
+    return TypedData_Wrap_Struct(klass, &SocketSelector_data_type, ptr);
+}
+
+static VALUE SocketSelector_new(VALUE klass) {
+    return SocketSelector_wrap(klass, sfSocketSelector_create());
+}
+
+static VALUE SocketSelector_copy(VALUE self) {
+    return SocketSelector_wrap(Get_Klass_SocketSelector(),
+                               sfSocketSelector_copy(Get_SocketSelector_Struct(self)));
+}
+
+static VALUE SocketSelector_add(VALUE self, VALUE rb_socket) {
+    sfSocketSelector *selector = Get_SocketSelector_Struct(self);
+
+    if (rb_obj_is_kind_of(rb_socket, Get_Klass_TcpListener())) {
+        sfSocketSelector_addTcpListener(selector, Get_TcpListener_Struct(rb_socket));
+    } else if (rb_obj_is_kind_of(rb_socket, Get_Klass_TcpSocket())) {
+        sfSocketSelector_addTcpSocket(selector, Get_TcpSocket_Struct(rb_socket));
+    } else if (rb_obj_is_kind_of(rb_socket, Get_Klass_UdpSocket())) {
+        sfSocketSelector_addUdpSocket(selector, Get_UdpSocket_Struct(rb_socket));
+    } else {
+        rb_raise(rb_eTypeError, "expected an SFML::TcpListener, TcpSocket or UdpSocket");
+    }
+
+    return self;
+}
+
+static VALUE SocketSelector_remove(VALUE self, VALUE rb_socket) {
+    sfSocketSelector *selector = Get_SocketSelector_Struct(self);
+
+    if (rb_obj_is_kind_of(rb_socket, Get_Klass_TcpListener())) {
+        sfSocketSelector_removeTcpListener(selector, Get_TcpListener_Struct(rb_socket));
+    } else if (rb_obj_is_kind_of(rb_socket, Get_Klass_TcpSocket())) {
+        sfSocketSelector_removeTcpSocket(selector, Get_TcpSocket_Struct(rb_socket));
+    } else if (rb_obj_is_kind_of(rb_socket, Get_Klass_UdpSocket())) {
+        sfSocketSelector_removeUdpSocket(selector, Get_UdpSocket_Struct(rb_socket));
+    } else {
+        rb_raise(rb_eTypeError, "expected an SFML::TcpListener, TcpSocket or UdpSocket");
+    }
+
+    return self;
+}
+
+static VALUE SocketSelector_clear(VALUE self) {
+    sfSocketSelector_clear(Get_SocketSelector_Struct(self));
+    return self;
+}
+
+static VALUE SocketSelector_wait(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_timeout;
+    sfTime timeout = sfTime_Zero;
+
+    rb_scan_args(argc, argv, "01", &rb_timeout);
+
+    if (!NIL_P(rb_timeout)) {
+        timeout = time_from_rb(rb_timeout);
+    }
+
+    return BOOL2RB(sfSocketSelector_wait(Get_SocketSelector_Struct(self), timeout));
+}
+
+static VALUE SocketSelector_tcp_listener_ready(VALUE self, VALUE rb_socket) {
+    return BOOL2RB(sfSocketSelector_isTcpListenerReady(Get_SocketSelector_Struct(self),
+                                                       Get_TcpListener_Struct(rb_socket)));
+}
+
+static VALUE SocketSelector_tcp_socket_ready(VALUE self, VALUE rb_socket) {
+    return BOOL2RB(
+        sfSocketSelector_isTcpSocketReady(Get_SocketSelector_Struct(self), Get_TcpSocket_Struct(rb_socket)));
+}
+
+static VALUE SocketSelector_udp_socket_ready(VALUE self, VALUE rb_socket) {
+    return BOOL2RB(
+        sfSocketSelector_isUdpSocketReady(Get_SocketSelector_Struct(self), Get_UdpSocket_Struct(rb_socket)));
+}
+
+void Init_SocketSelector(VALUE rb_module) {
+    rb_cSocketSelector = rb_define_class_under(rb_module, "SocketSelector", rb_cObject);
+
+    rb_define_singleton_method(rb_cSocketSelector, "new", SocketSelector_new, 0);
+
+    rb_define_method(rb_cSocketSelector, "copy", SocketSelector_copy, 0);
+    rb_define_method(rb_cSocketSelector, "add", SocketSelector_add, 1);
+    rb_define_method(rb_cSocketSelector, "remove", SocketSelector_remove, 1);
+    rb_define_method(rb_cSocketSelector, "clear", SocketSelector_clear, 0);
+    rb_define_method(rb_cSocketSelector, "wait", SocketSelector_wait, -1);
+    rb_define_method(rb_cSocketSelector, "tcp_listener_ready?", SocketSelector_tcp_listener_ready, 1);
+    rb_define_method(rb_cSocketSelector, "tcp_socket_ready?", SocketSelector_tcp_socket_ready, 1);
+    rb_define_method(rb_cSocketSelector, "udp_socket_ready?", SocketSelector_udp_socket_ready, 1);
+}
+
+VALUE Get_Klass_SocketSelector(void) {
+    return rb_cSocketSelector;
+}
+
+void *Get_SocketSelector_Struct(VALUE self) {
+    SocketSelector *ptr;
+    TypedData_Get_Struct(self, SocketSelector, &SocketSelector_data_type, ptr);
+    return ptr->handle;
+}

data/ext/network/socket_selector.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_NETWORK_SOCKET_SELECTOR_H
+#define SFML_RB_NETWORK_SOCKET_SELECTOR_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_SocketSelector(VALUE rb_module);
+
+VALUE Get_Klass_SocketSelector(void);
+
+void *Get_SocketSelector_Struct(VALUE self);
+
+#endif //SFML_RB_NETWORK_SOCKET_SELECTOR_H

data/ext/network/tcp_listener.c

@@ -0,0 +1,115 @@
+#include "network/tcp_listener.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "core/macros.h"
+#include "network/ip_address.h"
+#include "network/network_enums.h"
+#include "network/tcp_socket.h"
+
+typedef struct {
+    sfTcpListener *handle;
+} TcpListener;
+
+static VALUE rb_cTcpListener;
+
+static void TcpListener_free(void *ptr) {
+    TcpListener *listener = ptr;
+
+    if (listener->handle != NULL) {
+        sfTcpListener_destroy(listener->handle);
+    }
+
+    free(listener);
+}
+
+static const rb_data_type_t TcpListener_data_type = {
+    .wrap_struct_name = "SFML::TcpListener",
+    .function = {.dmark = NULL, .dfree = TcpListener_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE TcpListener_wrap(VALUE klass, sfTcpListener *handle) {
+    TcpListener *ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create TCP listener");
+    }
+
+    ptr = malloc(sizeof(TcpListener));
+    ptr->handle = handle;
+
+    return TypedData_Wrap_Struct(klass, &TcpListener_data_type, ptr);
+}
+
+static VALUE TcpListener_new(VALUE klass) {
+    return TcpListener_wrap(klass, sfTcpListener_create());
+}
+
+static VALUE TcpListener_any_port(VALUE klass) {
+    return UINT2NUM(sfTcpListener_anyPort());
+}
+
+static VALUE TcpListener_blocking(VALUE self) {
+    return BOOL2RB(sfTcpListener_isBlocking(Get_TcpListener_Struct(self)));
+}
+
+static VALUE TcpListener_set_blocking(VALUE self, VALUE rb_value) {
+    sfTcpListener_setBlocking(Get_TcpListener_Struct(self), RTEST(rb_value));
+    return rb_value;
+}
+
+static VALUE TcpListener_local_port(VALUE self) {
+    return UINT2NUM(sfTcpListener_getLocalPort(Get_TcpListener_Struct(self)));
+}
+
+static VALUE TcpListener_listen(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_port, rb_address;
+
+    rb_scan_args(argc, argv, "11", &rb_port, &rb_address);
+
+    return ID2SYM(rb_intern(socket_status_name(sfTcpListener_listen(
+        Get_TcpListener_Struct(self), (unsigned short) NUM2INT(rb_port),
+        ip_address_from_rb(rb_address, sfIpAddress_Any)))));
+}
+
+static VALUE TcpListener_close(VALUE self) {
+    sfTcpListener_close(Get_TcpListener_Struct(self));
+    return self;
+}
+
+static VALUE TcpListener_accept(VALUE self) {
+    sfTcpSocket *socket = NULL;
+    sfSocketStatus status = sfTcpListener_accept(Get_TcpListener_Struct(self), &socket);
+    VALUE rb_result = rb_ary_new_capa(2);
+
+    rb_ary_push(rb_result, status == sfSocketDone ? tcp_socket_from_handle(socket) : Qnil);
+    rb_ary_push(rb_result, ID2SYM(rb_intern(socket_status_name(status))));
+
+    return rb_result;
+}
+
+void Init_TcpListener(VALUE rb_module) {
+    rb_cTcpListener = rb_define_class_under(rb_module, "TcpListener", rb_cObject);
+
+    rb_define_singleton_method(rb_cTcpListener, "new", TcpListener_new, 0);
+    rb_define_singleton_method(rb_cTcpListener, "any_port", TcpListener_any_port, 0);
+
+    rb_define_method(rb_cTcpListener, "blocking?", TcpListener_blocking, 0);
+    rb_define_method(rb_cTcpListener, "blocking=", TcpListener_set_blocking, 1);
+    rb_define_method(rb_cTcpListener, "local_port", TcpListener_local_port, 0);
+    rb_define_method(rb_cTcpListener, "listen", TcpListener_listen, -1);
+    rb_define_method(rb_cTcpListener, "close", TcpListener_close, 0);
+    rb_define_method(rb_cTcpListener, "accept", TcpListener_accept, 0);
+}
+
+VALUE Get_Klass_TcpListener(void) {
+    return rb_cTcpListener;
+}
+
+void *Get_TcpListener_Struct(VALUE self) {
+    TcpListener *ptr;
+    TypedData_Get_Struct(self, TcpListener, &TcpListener_data_type, ptr);
+    return ptr->handle;
+}

data/ext/network/tcp_listener.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_NETWORK_TCP_LISTENER_H
+#define SFML_RB_NETWORK_TCP_LISTENER_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_TcpListener(VALUE rb_module);
+
+VALUE Get_Klass_TcpListener(void);
+
+void *Get_TcpListener_Struct(VALUE self);
+
+#endif //SFML_RB_NETWORK_TCP_LISTENER_H

data/ext/network/tcp_socket.c

@@ -0,0 +1,199 @@
+#include "network/tcp_socket.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "core/macros.h"
+#include "network/ip_address.h"
+#include "network/network_enums.h"
+#include "network/packet.h"
+#include "system/time.h"
+
+typedef struct {
+    sfTcpSocket *handle;
+} TcpSocket;
+
+static VALUE rb_cTcpSocket;
+
+static void TcpSocket_free(void *ptr) {
+    TcpSocket *socket = ptr;
+
+    if (socket->handle != NULL) {
+        sfTcpSocket_destroy(socket->handle);
+    }
+
+    free(socket);
+}
+
+static const rb_data_type_t TcpSocket_data_type = {
+    .wrap_struct_name = "SFML::TcpSocket",
+    .function = {.dmark = NULL, .dfree = TcpSocket_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE TcpSocket_wrap(VALUE klass, sfTcpSocket *handle) {
+    TcpSocket *ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create TCP socket");
+    }
+
+    ptr = malloc(sizeof(TcpSocket));
+    ptr->handle = handle;
+
+    return TypedData_Wrap_Struct(klass, &TcpSocket_data_type, ptr);
+}
+
+VALUE tcp_socket_from_handle(sfTcpSocket *socket) {
+    return TcpSocket_wrap(rb_cTcpSocket, socket);
+}
+
+static VALUE TcpSocket_new(VALUE klass) {
+    return TcpSocket_wrap(klass, sfTcpSocket_create());
+}
+
+static VALUE TcpSocket_blocking(VALUE self) {
+    return BOOL2RB(sfTcpSocket_isBlocking(Get_TcpSocket_Struct(self)));
+}
+
+static VALUE TcpSocket_set_blocking(VALUE self, VALUE rb_value) {
+    sfTcpSocket_setBlocking(Get_TcpSocket_Struct(self), RTEST(rb_value));
+    return rb_value;
+}
+
+static VALUE TcpSocket_local_port(VALUE self) {
+    return UINT2NUM(sfTcpSocket_getLocalPort(Get_TcpSocket_Struct(self)));
+}
+
+static VALUE TcpSocket_remote_address(VALUE self) {
+    return ip_address_to_rb(sfTcpSocket_getRemoteAddress(Get_TcpSocket_Struct(self)));
+}
+
+static VALUE TcpSocket_remote_port(VALUE self) {
+    return UINT2NUM(sfTcpSocket_getRemotePort(Get_TcpSocket_Struct(self)));
+}
+
+static VALUE TcpSocket_connect(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_address, rb_port, rb_timeout;
+    sfTime timeout = sfTime_Zero;
+
+    rb_scan_args(argc, argv, "21", &rb_address, &rb_port, &rb_timeout);
+
+    if (!NIL_P(rb_timeout)) {
+        timeout = time_from_rb(rb_timeout);
+    }
+
+    return ID2SYM(rb_intern(socket_status_name(sfTcpSocket_connect(
+        Get_TcpSocket_Struct(self), ip_address_from_rb(rb_address, sfIpAddress_None),
+        (unsigned short) NUM2INT(rb_port), timeout))));
+}
+
+static VALUE TcpSocket_disconnect(VALUE self) {
+    sfTcpSocket_disconnect(Get_TcpSocket_Struct(self));
+    return self;
+}
+
+static VALUE TcpSocket_send(VALUE self, VALUE rb_data) {
+    StringValue(rb_data);
+
+    return ID2SYM(rb_intern(socket_status_name(
+        sfTcpSocket_send(Get_TcpSocket_Struct(self), RSTRING_PTR(rb_data),
+                         (size_t) RSTRING_LEN(rb_data)))));
+}
+
+static VALUE TcpSocket_send_partial(VALUE self, VALUE rb_data) {
+    size_t sent = 0;
+    sfSocketStatus status;
+    VALUE rb_result;
+
+    StringValue(rb_data);
+
+    status = sfTcpSocket_sendPartial(Get_TcpSocket_Struct(self), RSTRING_PTR(rb_data),
+                                     (size_t) RSTRING_LEN(rb_data), &sent);
+
+    rb_result = rb_ary_new_capa(2);
+    rb_ary_push(rb_result, SIZET2NUM(sent));
+    rb_ary_push(rb_result, ID2SYM(rb_intern(socket_status_name(status))));
+
+    return rb_result;
+}
+
+/* Receive needs a maximum size up front because CSFML fills a caller buffer.
+   Returns [data, status], where data is empty unless the status is :done. */
+static VALUE TcpSocket_receive(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_max_length;
+    long max_length = 1024;
+    char *buffer;
+    size_t received = 0;
+    sfSocketStatus status;
+    VALUE rb_result;
+
+    rb_scan_args(argc, argv, "01", &rb_max_length);
+
+    if (!NIL_P(rb_max_length)) {
+        max_length = NUM2LONG(rb_max_length);
+    }
+
+    if (max_length <= 0) {
+        rb_raise(rb_eArgError, "maximum length must be positive");
+    }
+
+    buffer = malloc((size_t) max_length);
+
+    status = sfTcpSocket_receive(Get_TcpSocket_Struct(self), buffer, (size_t) max_length, &received);
+
+    rb_result = rb_ary_new_capa(2);
+    rb_ary_push(rb_result, rb_str_new(buffer, (long) received));
+    rb_ary_push(rb_result, ID2SYM(rb_intern(socket_status_name(status))));
+
+    free(buffer);
+
+    return rb_result;
+}
+
+static VALUE TcpSocket_send_packet(VALUE self, VALUE rb_packet) {
+    if (!rb_obj_is_kind_of(rb_packet, Get_Klass_Packet())) {
+        rb_raise(rb_eTypeError, "expected an SFML::Packet");
+    }
+
+    return ID2SYM(rb_intern(socket_status_name(
+        sfTcpSocket_sendPacket(Get_TcpSocket_Struct(self), Get_Packet_Struct(rb_packet)))));
+}
+
+static VALUE TcpSocket_receive_packet(VALUE self, VALUE rb_packet) {
+    if (!rb_obj_is_kind_of(rb_packet, Get_Klass_Packet())) {
+        rb_raise(rb_eTypeError, "expected an SFML::Packet");
+    }
+
+    return ID2SYM(rb_intern(socket_status_name(
+        sfTcpSocket_receivePacket(Get_TcpSocket_Struct(self), Get_Packet_Struct(rb_packet)))));
+}
+
+void Init_TcpSocket(VALUE rb_module) {
+    rb_cTcpSocket = rb_define_class_under(rb_module, "TcpSocket", rb_cObject);
+
+    rb_define_singleton_method(rb_cTcpSocket, "new", TcpSocket_new, 0);
+
+    rb_define_method(rb_cTcpSocket, "blocking?", TcpSocket_blocking, 0);
+    rb_define_method(rb_cTcpSocket, "blocking=", TcpSocket_set_blocking, 1);
+    rb_define_method(rb_cTcpSocket, "local_port", TcpSocket_local_port, 0);
+    rb_define_method(rb_cTcpSocket, "remote_address", TcpSocket_remote_address, 0);
+    rb_define_method(rb_cTcpSocket, "remote_port", TcpSocket_remote_port, 0);
+    rb_define_method(rb_cTcpSocket, "connect", TcpSocket_connect, -1);
+    rb_define_method(rb_cTcpSocket, "disconnect", TcpSocket_disconnect, 0);
+    rb_define_method(rb_cTcpSocket, "send", TcpSocket_send, 1);
+    rb_define_method(rb_cTcpSocket, "send_partial", TcpSocket_send_partial, 1);
+    rb_define_method(rb_cTcpSocket, "receive", TcpSocket_receive, -1);
+    rb_define_method(rb_cTcpSocket, "send_packet", TcpSocket_send_packet, 1);
+    rb_define_method(rb_cTcpSocket, "receive_packet", TcpSocket_receive_packet, 1);
+}
+
+VALUE Get_Klass_TcpSocket(void) {
+    return rb_cTcpSocket;
+}
+
+void *Get_TcpSocket_Struct(VALUE self) {
+    TcpSocket *ptr;
+    TypedData_Get_Struct(self, TcpSocket, &TcpSocket_data_type, ptr);
+    return ptr->handle;
+}