Fix #6: Changed coding style to match UFO Project

7 files changed, 566 insertions, 519 deletions

diff --git a/src/kiro-client.c b/src/kiro-client.c
index 1fd7860..b930595 100644
--- a/src/kiro-client.c
+++ b/src/kiro-client.c
@@ -53,23 +53,25 @@ struct _KiroClientPrivate {
     /* (Not accessible by properties) */
     struct rdma_event_channel   *ec;        // Main Event Channel
     struct rdma_cm_id           *conn;      // Connection to the Server
-    
+
 };
 
 
 G_DEFINE_TYPE (KiroClient, kiro_client, G_TYPE_OBJECT);
 
 
-KiroClient*
-kiro_client_new (void) {
+KiroClient *
+kiro_client_new (void)
+{
     return g_object_new (KIRO_TYPE_CLIENT, NULL);
 }
 
 
-static void kiro_client_init (KiroClient *self)
+static void
+kiro_client_init (KiroClient *self)
 {
-    KiroClientPrivate *priv = KIRO_CLIENT_GET_PRIVATE(self);
-    memset(priv, 0, sizeof(&priv));
+    KiroClientPrivate *priv = KIRO_CLIENT_GET_PRIVATE (self);
+    memset (priv, 0, sizeof (&priv));
 }
 
 static void
@@ -83,177 +85,183 @@ kiro_client_finalize (GObject *object)
 static void
 kiro_client_class_init (KiroClientClass *klass)
 {
-    GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
+    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
     gobject_class->finalize = kiro_client_finalize;
-    g_type_class_add_private(klass, sizeof(KiroClientPrivate));
+    g_type_class_add_private (klass, sizeof (KiroClientPrivate));
 }
 
 
 
-int kiro_client_connect (KiroClient *self, char *address, char* port)
+int
+kiro_client_connect (KiroClient *self, char *address, char *port)
 {
-    KiroClientPrivate *priv = KIRO_CLIENT_GET_PRIVATE(self);
+    KiroClientPrivate *priv = KIRO_CLIENT_GET_PRIVATE (self);
 
-    if(priv->conn)
-    {
-        printf("Already connected to server.\n");
+    if (priv->conn) {
+        printf ("Already connected to server.\n");
         return -1;
     }
-    
+
     struct rdma_addrinfo hints, *res_addrinfo;
-    memset(&hints, 0, sizeof(hints));
+
+    memset (&hints, 0, sizeof (hints));
+
     hints.ai_port_space = RDMA_PS_IB;
-    if(rdma_getaddrinfo(address, port, &hints, &res_addrinfo))
-    {
-        printf("Failed to contruct address information for %s:%s\n",address, port);
+
+    if (rdma_getaddrinfo (address, port, &hints, &res_addrinfo)) {
+        printf ("Failed to contruct address information for %s:%s\n", address, port);
         return -1;
     }
-    printf("Address information created.\n");
-    
+
+    printf ("Address information created.\n");
     struct ibv_qp_init_attr qp_attr;
-    memset(&qp_attr, 0, sizeof(qp_attr));
+    memset (&qp_attr, 0, sizeof (qp_attr));
     qp_attr.cap.max_send_wr = 10;
     qp_attr.cap.max_recv_wr = 10;
     qp_attr.cap.max_send_sge = 1;
     qp_attr.cap.max_recv_sge = 1;
     qp_attr.qp_context = priv->conn;
     qp_attr.sq_sig_all = 1;
-    
-    if(rdma_create_ep(&(priv->conn), res_addrinfo, NULL, &qp_attr))
-    {
-        printf("Endpoint creation failed with error: %i\n", errno);
+
+    if (rdma_create_ep (& (priv->conn), res_addrinfo, NULL, &qp_attr)) {
+        printf ("Endpoint creation failed with error: %i\n", errno);
         return -1;
     }
-    printf("Route to server resolved.\n");
-    
-    struct kiro_connection_context *ctx = (struct kiro_connection_context *)calloc(1,sizeof(struct kiro_connection_context));
-    if(!ctx)
-    {
-        printf("Failed to create connection context.\n");
-        rdma_destroy_ep(priv->conn);
+
+    printf ("Route to server resolved.\n");
+    struct kiro_connection_context *ctx = (struct kiro_connection_context *)calloc (1, sizeof (struct kiro_connection_context));
+
+    if (!ctx) {
+        printf ("Failed to create connection context.\n");
+        rdma_destroy_ep (priv->conn);
         return -1;
     }
-    
-    ctx->cf_mr_send = (struct kiro_rdma_mem *)calloc(1, sizeof(struct kiro_rdma_mem));
-    ctx->cf_mr_recv = (struct kiro_rdma_mem *)calloc(1, sizeof(struct kiro_rdma_mem));
-    if(!ctx->cf_mr_recv || !ctx->cf_mr_send)
-    {
-        printf("Failed to allocate Control Flow Memory Container.\n");
-        kiro_destroy_connection_context(&ctx);
-        rdma_destroy_ep(priv->conn);
+
+    ctx->cf_mr_send = (struct kiro_rdma_mem *)calloc (1, sizeof (struct kiro_rdma_mem));
+    ctx->cf_mr_recv = (struct kiro_rdma_mem *)calloc (1, sizeof (struct kiro_rdma_mem));
+
+    if (!ctx->cf_mr_recv || !ctx->cf_mr_send) {
+        printf ("Failed to allocate Control Flow Memory Container.\n");
+        kiro_destroy_connection_context (&ctx);
+        rdma_destroy_ep (priv->conn);
         return -1;
     }
-    
-    ctx->cf_mr_recv = kiro_create_rdma_memory(priv->conn->pd, sizeof(struct kiro_ctrl_msg), IBV_ACCESS_LOCAL_WRITE);
-    ctx->cf_mr_send = kiro_create_rdma_memory(priv->conn->pd, sizeof(struct kiro_ctrl_msg), IBV_ACCESS_LOCAL_WRITE);
-    if(!ctx->cf_mr_recv || !ctx->cf_mr_send)
-    {
-        printf("Failed to register control message memory.\n");
-        kiro_destroy_connection_context(&ctx);
-        rdma_destroy_ep(priv->conn);
+
+    ctx->cf_mr_recv = kiro_create_rdma_memory (priv->conn->pd, sizeof (struct kiro_ctrl_msg), IBV_ACCESS_LOCAL_WRITE);
+    ctx->cf_mr_send = kiro_create_rdma_memory (priv->conn->pd, sizeof (struct kiro_ctrl_msg), IBV_ACCESS_LOCAL_WRITE);
+
+    if (!ctx->cf_mr_recv || !ctx->cf_mr_send) {
+        printf ("Failed to register control message memory.\n");
+        kiro_destroy_connection_context (&ctx);
+        rdma_destroy_ep (priv->conn);
         return -1;
     }
-    ctx->cf_mr_recv->size = ctx->cf_mr_send->size = sizeof(struct kiro_ctrl_msg);
+
+    ctx->cf_mr_recv->size = ctx->cf_mr_send->size = sizeof (struct kiro_ctrl_msg);
     priv->conn->context = ctx;
-    
-    if(rdma_post_recv(priv->conn, priv->conn, ctx->cf_mr_recv->mem, ctx->cf_mr_recv->size, ctx->cf_mr_recv->mr))
-    {
-        printf("Posting preemtive receive for connection failed with error: %i\n", errno);
-        kiro_destroy_connection_context(&ctx);
-        rdma_destroy_ep(priv->conn);
+
+    if (rdma_post_recv (priv->conn, priv->conn, ctx->cf_mr_recv->mem, ctx->cf_mr_recv->size, ctx->cf_mr_recv->mr)) {
+        printf ("Posting preemtive receive for connection failed with error: %i\n", errno);
+        kiro_destroy_connection_context (&ctx);
+        rdma_destroy_ep (priv->conn);
         return -1;
     }
-    
-    if(rdma_connect(priv->conn, NULL))
-    {
-        printf("Failed to establish connection to the server.\n");
-        kiro_destroy_connection_context(&ctx);
-        rdma_destroy_ep(priv->conn);
+
+    if (rdma_connect (priv->conn, NULL)) {
+        printf ("Failed to establish connection to the server.\n");
+        kiro_destroy_connection_context (&ctx);
+        rdma_destroy_ep (priv->conn);
         return -1;
     }
-    printf("Connected to server.\n");
-    
-    
+
+    printf ("Connected to server.\n");
     struct ibv_wc wc;
-    if(rdma_get_recv_comp(priv->conn, &wc) < 0)
-    {
-        printf("Failure waiting for POST from server.\n");
-        rdma_disconnect(priv->conn);
-        kiro_destroy_connection_context(&ctx);
-        rdma_destroy_ep(priv->conn);
+
+    if (rdma_get_recv_comp (priv->conn, &wc) < 0) {
+        printf ("Failure waiting for POST from server.\n");
+        rdma_disconnect (priv->conn);
+        kiro_destroy_connection_context (&ctx);
+        rdma_destroy_ep (priv->conn);
         return -1;
     }
-    printf("Got Message from Server.\n");
-    ctx->peer_mr = (((struct kiro_ctrl_msg *)(ctx->cf_mr_recv->mem))->peer_mri);
-    printf("Expected Memory Size is: %u\n",ctx->peer_mr.length);
-    
-    ctx->rdma_mr = kiro_create_rdma_memory(priv->conn->pd, ctx->peer_mr.length, IBV_ACCESS_LOCAL_WRITE);
-    if(!ctx->rdma_mr)
-    {
-        printf("Failed to allocate memory for receive buffer.\n");
-        rdma_disconnect(priv->conn);
-        kiro_destroy_connection_context(&ctx);
-        rdma_destroy_ep(priv->conn);
+
+    printf ("Got Message from Server.\n");
+    ctx->peer_mr = (((struct kiro_ctrl_msg *) (ctx->cf_mr_recv->mem))->peer_mri);
+    printf ("Expected Memory Size is: %u\n", ctx->peer_mr.length);
+    ctx->rdma_mr = kiro_create_rdma_memory (priv->conn->pd, ctx->peer_mr.length, IBV_ACCESS_LOCAL_WRITE);
+
+    if (!ctx->rdma_mr) {
+        printf ("Failed to allocate memory for receive buffer.\n");
+        rdma_disconnect (priv->conn);
+        kiro_destroy_connection_context (&ctx);
+        rdma_destroy_ep (priv->conn);
         return -1;
     }
-    printf("Connection setup completed successfully!\n");
-    
+
+    printf ("Connection setup completed successfully!\n");
     return 0;
 }
 
 
 
-int kiro_client_sync (KiroClient *self)
-{   
-    KiroClientPrivate *priv = KIRO_CLIENT_GET_PRIVATE(self);
+int
+kiro_client_sync (KiroClient *self)
+{
+    KiroClientPrivate *priv = KIRO_CLIENT_GET_PRIVATE (self);
     struct kiro_connection_context *ctx = (struct kiro_connection_context *)priv->conn->context;
-    
-    if(rdma_post_read(priv->conn, priv->conn, ctx->rdma_mr->mem, ctx->peer_mr.length, ctx->rdma_mr->mr, 0, ctx->peer_mr.addr, ctx->peer_mr.rkey))
-    {
-        printf("Failed to read from server.\n");
-        rdma_disconnect(priv->conn);
-        kiro_destroy_connection_context(&ctx);
-        rdma_destroy_ep(priv->conn);
+
+    if (rdma_post_read (priv->conn, priv->conn, ctx->rdma_mr->mem, ctx->peer_mr.length, ctx->rdma_mr->mr, 0, ctx->peer_mr.addr, ctx->peer_mr.rkey)) {
+        printf ("Failed to read from server.\n");
+        rdma_disconnect (priv->conn);
+        kiro_destroy_connection_context (&ctx);
+        rdma_destroy_ep (priv->conn);
         return -1;
     }
-    
+
     struct ibv_wc wc;
-    if(rdma_get_send_comp(priv->conn, &wc) < 0)
-    {
-        printf("Failure reading from server.\n");
-        rdma_disconnect(priv->conn);
-        kiro_destroy_connection_context(&ctx);
-        rdma_destroy_ep(priv->conn);
+
+    if (rdma_get_send_comp (priv->conn, &wc) < 0) {
+        printf ("Failure reading from server.\n");
+        rdma_disconnect (priv->conn);
+        kiro_destroy_connection_context (&ctx);
+        rdma_destroy_ep (priv->conn);
         return -1;
     }
+
     return 0;
 }
 
 
-void* kiro_client_get_memory (KiroClient *self)
+void *
+kiro_client_get_memory (KiroClient *self)
 {
-    KiroClientPrivate *priv = KIRO_CLIENT_GET_PRIVATE(self);
-    if(!priv->conn)
+    KiroClientPrivate *priv = KIRO_CLIENT_GET_PRIVATE (self);
+
+    if (!priv->conn)
         return NULL;
 
     struct kiro_connection_context *ctx = (struct kiro_connection_context *)priv->conn->context;
-    if(!ctx->rdma_mr)
+
+    if (!ctx->rdma_mr)
         return NULL;
-        
+
     return ctx->rdma_mr->mem;
 }
 
 
-size_t kiro_client_get_memory_size (KiroClient *self)
+size_t 
+kiro_client_get_memory_size (KiroClient *self)
 {
-    KiroClientPrivate *priv = KIRO_CLIENT_GET_PRIVATE(self);
-    if(!priv->conn)
+    KiroClientPrivate *priv = KIRO_CLIENT_GET_PRIVATE (self);
+
+    if (!priv->conn)
         return 0;
 
     struct kiro_connection_context *ctx = (struct kiro_connection_context *)priv->conn->context;
-    if(!ctx->rdma_mr)
+
+    if (!ctx->rdma_mr)
         return 0;
-        
+
     return ctx->rdma_mr->size;
 }
 
diff --git a/src/kiro-client.h b/src/kiro-client.h
index fc98b3f..146845b 100644
--- a/src/kiro-client.h
+++ b/src/kiro-client.h
@@ -24,7 +24,7 @@
  * KiroClient implements the client / active / consumer side of the the RDMA
  * Communication Channel. It uses a KIRO-CLIENT to manage data read from the Server.
  */
- 
+
 #ifndef __KIRO_CLIENT_H
 #define __KIRO_CLIENT_H
 
@@ -47,9 +47,9 @@ typedef struct _KiroClientPrivate    KiroClientPrivate;
 
 
 struct _KiroClient {
-    
+
     GObject parent;
-    
+
     /*< private >*/
     KiroClientPrivate *priv;
 };
@@ -62,9 +62,9 @@ struct _KiroClient {
  */
 
 struct _KiroClientClass {
-    
+
     GObjectClass parent_class;
-       
+
 };
 
 
@@ -72,18 +72,18 @@ struct _KiroClientClass {
 /* GObject and GType functions */
 GType       kiro_client_get_type            (void);
 
-KiroClient* kiro_client_new                 (void);
+KiroClient *kiro_client_new                 (void);
 
 /* client functions */
 
 
-int         kiro_client_connect             (KiroClient* client, char* dest_addr, char* dest_port);
+int         kiro_client_connect             (KiroClient *client, char *dest_addr, char *dest_port);
 
-int         kiro_client_sync                (KiroClient* client);
+int         kiro_client_sync                (KiroClient *client);
 
-void*       kiro_client_get_memory          (KiroClient* client);
+void       *kiro_client_get_memory          (KiroClient *client);
 
-size_t      kior_client_get_memory_size     (KiroClient* client);
+size_t      kior_client_get_memory_size     (KiroClient *client);
 
 G_END_DECLS
 
diff --git a/src/kiro-rdma.h b/src/kiro-rdma.h
index 8779b2e..2ebbcf6 100644
--- a/src/kiro-rdma.h
+++ b/src/kiro-rdma.h
@@ -25,9 +25,9 @@
 
 #include <rdma/rdma_cma.h>
 
-  
+
 struct kiro_connection_context {
-        
+
     // Information and necessary structurs
     uint32_t                identifier;             // Unique Identifier for this connection (Application Specific)
     struct kiro_rdma_mem    *cf_mr_recv;            // Control-Flow Memory Region Receive
@@ -35,52 +35,52 @@ struct kiro_connection_context {
     struct kiro_rdma_mem    *rdma_mr;               // Memory Region for RDMA Operations
 
     struct ibv_mr           peer_mr;                // RDMA Memory Region Information of the peer
-    
+
     enum {
         KIRO_IDLE,
         KIRO_MRI_REQUESTED,                         // Memory Region Information Requested
         KIRO_RDMA_ESTABLISHED,                      // MRI Exchange complete. RDMA is ready
         KIRO_RDMA_ACTIVE                            // RDMA Operation is being performed
     } rdma_state;
-    
+
 };
 
 
 struct kiro_ctrl_msg {
-    
+
     enum {
         KIRO_REQ_RDMA,                              // Requesting RDMA Access to/from the peer
         KIRO_ACK_RDMA,                              // acknowledge RDMA Request and provide Memory Region Information
         KIRO_REJ_RDMA                               // RDMA Request rejected :(  (peer_mri will be invalid)
     } msg_type;
-    
+
     struct ibv_mr peer_mri;
-    
+
 };
 
 
 struct kiro_rdma_mem {
-    
-    void            *mem;   // Pointer to the beginning of the memory block           
+
+    void            *mem;   // Pointer to the beginning of the memory block
     struct ibv_mr   *mr;    // Memory Region associated with the memory
     size_t          size;   // Size in Bytes of the memory block
 
 };
 
 
-static int kiro_attach_qp (struct rdma_cm_id *id)
+static int
+kiro_attach_qp (struct rdma_cm_id *id)
 {
-    if(!id)
+    if (!id)
         return -1;
-    
-    id->pd = ibv_alloc_pd(id->verbs);
-    id->send_cq_channel = ibv_create_comp_channel(id->verbs);
+
+    id->pd = ibv_alloc_pd (id->verbs);
+    id->send_cq_channel = ibv_create_comp_channel (id->verbs);
     id->recv_cq_channel = id->send_cq_channel; //we use one shared completion channel
-    id->send_cq = ibv_create_cq(id->verbs, 1, id, id->send_cq_channel, 0);
+    id->send_cq = ibv_create_cq (id->verbs, 1, id, id->send_cq_channel, 0);
     id->recv_cq = id->send_cq; //we use one shared completion queue
-    
     struct ibv_qp_init_attr qp_attr;
-    memset(&qp_attr, 0, sizeof(struct ibv_qp_init_attr));
+    memset (&qp_attr, 0, sizeof (struct ibv_qp_init_attr));
     qp_attr.qp_context = (uintptr_t)id;
     qp_attr.send_cq = id->send_cq;
     qp_attr.recv_cq = id->recv_cq;
@@ -89,131 +89,129 @@ static int kiro_attach_qp (struct rdma_cm_id *id)
     qp_attr.cap.max_recv_wr = 1;
     qp_attr.cap.max_send_sge = 1;
     qp_attr.cap.max_recv_sge = 1;
-    
-    return rdma_create_qp(id, id->pd, &qp_attr);
+    return rdma_create_qp (id, id->pd, &qp_attr);
 }
 
 
-static int kiro_register_rdma_memory (struct ibv_pd *pd, struct ibv_mr **mr, void *mem, size_t mem_size, int access)
+static int
+kiro_register_rdma_memory (struct ibv_pd *pd, struct ibv_mr **mr, void *mem, size_t mem_size, int access)
 {
-    
-    if(mem_size == 0)
-    {    
-        printf("Cant allocate memory of size '0'.\n");
+    if (mem_size == 0) {
+        printf ("Cant allocate memory of size '0'.\n");
         return -1;
     }
-    
+
     void *mem_handle = mem;
-    
-    if(!mem_handle)
-        mem_handle = malloc(mem_size);
-        
-    if(!mem_handle)
-    {
-        printf("Failed to allocate memory [Register Memory].");
+
+    if (!mem_handle)
+        mem_handle = malloc (mem_size);
+
+    if (!mem_handle) {
+        printf ("Failed to allocate memory [Register Memory].");
         return -1;
-    }        
-    
-    *mr = ibv_reg_mr(pd, mem_handle, mem_size, access);
-    if(!(*mr))
-    {
+    }
+
+    *mr = ibv_reg_mr (pd, mem_handle, mem_size, access);
+
+    if (! (*mr)) {
         // Memory Registration failed
-        printf("Failed to register memory region!\n");
-        free(mem_handle);
+        printf ("Failed to register memory region!\n");
+        free (mem_handle);
         return -1;
     }
-    
+
     return 0;
 }
 
 
-static struct kiro_rdma_mem* kiro_create_rdma_memory (struct ibv_pd *pd, size_t mem_size, int access)
+static struct kiro_rdma_mem *
+kiro_create_rdma_memory (struct ibv_pd *pd, size_t mem_size, int access)
 {
-    if(mem_size == 0)
-    {    
-        printf("Cant allocate memory of size '0'.\n");
+    if (mem_size == 0) {
+        printf ("Cant allocate memory of size '0'.\n");
         return NULL;
     }
-    
-    struct kiro_rdma_mem *krm = (struct kiro_rdma_mem *)calloc(1, sizeof(struct kiro_rdma_mem));
-    if(!krm)
-    {
-        printf("Failed to create new KIRO RDMA Memory.\n");
+
+    struct kiro_rdma_mem *krm = (struct kiro_rdma_mem *)calloc (1, sizeof (struct kiro_rdma_mem));
+
+    if (!krm) {
+        printf ("Failed to create new KIRO RDMA Memory.\n");
         return NULL;
     }
-    
-    if(kiro_register_rdma_memory(pd, &(krm->mr), krm->mem, mem_size, access))
-    {
-        free(krm);
+
+    if (kiro_register_rdma_memory (pd, & (krm->mr), krm->mem, mem_size, access)) {
+        free (krm);
         return NULL;
     }
-    
-    if(!krm->mem)
+
+    if (!krm->mem)
         krm->mem = krm->mr->addr;
-    
-    
+
     return krm;
-    
 }
 
 
-static void kiro_destroy_rdma_memory (struct kiro_rdma_mem *krm)
+static void
+kiro_destroy_rdma_memory (struct kiro_rdma_mem *krm)
 {
-    if(!krm)
+    if (!krm)
         return;
-        
-    if(krm->mr)
-        ibv_dereg_mr(krm->mr);
-        
-    if(krm->mem)
-        free(krm->mem);
-        
-    free(krm);
+
+    if (krm->mr)
+        ibv_dereg_mr (krm->mr);
+
+    if (krm->mem)
+        free (krm->mem);
+
+    free (krm);
     krm = NULL;
 }
 
 
-static void kiro_destroy_connection_context (struct kiro_connection_context **ctx)
+static void
+kiro_destroy_connection_context (struct kiro_connection_context **ctx)
 {
-    if(!ctx)
+    if (!ctx)
         return;
-    
-    if(!(*ctx))
+
+    if (! (*ctx))
         return;
-        
-    if((*ctx)->cf_mr_recv)
-        kiro_destroy_rdma_memory((*ctx)->cf_mr_recv);
-    if((*ctx)->cf_mr_send)
-        kiro_destroy_rdma_memory((*ctx)->cf_mr_send);
-        
+
+    if ((*ctx)->cf_mr_recv)
+        kiro_destroy_rdma_memory ((*ctx)->cf_mr_recv);
+
+    if ((*ctx)->cf_mr_send)
+        kiro_destroy_rdma_memory ((*ctx)->cf_mr_send);
+
     //The RDMA-Memory Region normally contains allocated memory from the USER that has
     //just been 'registered' for RDMA. DON'T free it! Just deregister it. The user is
-    //responsible for freeing this memory. 
-    if((*ctx)->rdma_mr)
-    {
-        if((*ctx)->rdma_mr->mr)
-            ibv_dereg_mr((*ctx)->rdma_mr->mr);
-           
-        free((*ctx)->rdma_mr);
+    //responsible for freeing this memory.
+    if ((*ctx)->rdma_mr) {
+        if ((*ctx)->rdma_mr->mr)
+            ibv_dereg_mr ((*ctx)->rdma_mr->mr);
+
+        free ((*ctx)->rdma_mr);
         (*ctx)->rdma_mr = NULL;
     }
 
-    free(*ctx);
+    free (*ctx);
     *ctx = NULL;
 }
 
 
-static void kiro_destroy_connection (struct rdma_cm_id **conn)
+static void
+kiro_destroy_connection (struct rdma_cm_id **conn)
 {
-    if(!(*conn))
+    if (! (*conn))
         return;
-        
-    rdma_disconnect(*conn);
-    struct kiro_connection_context *ctx = (struct kiro_connection_context *)((*conn)->context);
-    if(ctx)
-        kiro_destroy_connection_context(&ctx);
-        
-    rdma_destroy_ep(*conn);
+
+    rdma_disconnect (*conn);
+    struct kiro_connection_context *ctx = (struct kiro_connection_context *) ((*conn)->context);
+
+    if (ctx)
+        kiro_destroy_connection_context (&ctx);
+
+    rdma_destroy_ep (*conn);
     *conn = NULL;
 }
 
diff --git a/src/kiro-server.c b/src/kiro-server.c
index 15a8ccb..c69b6e7 100644
--- a/src/kiro-server.c
+++ b/src/kiro-server.c
@@ -65,265 +65,261 @@ struct _KiroServerPrivate {
 G_DEFINE_TYPE (KiroServer, kiro_server, G_TYPE_OBJECT);
 
 
-KiroServer*
-kiro_server_new (void) {
+KiroServer *
+kiro_server_new (void)
+{
     return g_object_new (KIRO_TYPE_SERVER, NULL);
 }
 
 
-static void kiro_server_init (KiroServer *self)
+static void
+kiro_server_init (KiroServer *self)
 {
-    KiroServerPrivate *priv = KIRO_SERVER_GET_PRIVATE(self);
-    memset(priv, 0, sizeof(&priv));
+    KiroServerPrivate *priv = KIRO_SERVER_GET_PRIVATE (self);
+    memset (priv, 0, sizeof (&priv));
 }
 
 
 static void
 kiro_server_finalize (GObject *object)
 {
-    KiroServer *self = KIRO_SERVER(object);
-    
+    KiroServer *self = KIRO_SERVER (object);
     //Clean up the server
-    kiro_server_stop(self);
+    kiro_server_stop (self);
 }
 
 
 static void
 kiro_server_class_init (KiroServerClass *klass)
 {
-    GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
+    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
     gobject_class->finalize = kiro_server_finalize;
-    g_type_class_add_private(klass, sizeof(KiroServerPrivate));
+    g_type_class_add_private (klass, sizeof (KiroServerPrivate));
 }
 
 
-static int connect_client (struct rdma_cm_id *client)
+static int
+connect_client (struct rdma_cm_id *client)
 {
-    if(!client)
+    if (!client)
         return -1;
-        
-    if( -1 == kiro_attach_qp(client))
-    {
-        printf("Could not create a QP for the new connection.\n");
-        rdma_destroy_id(client);
+
+    if ( -1 == kiro_attach_qp (client)) {
+        printf ("Could not create a QP for the new connection.\n");
+        rdma_destroy_id (client);
         return -1;
     }
-    
-    struct kiro_connection_context *ctx = (struct kiro_connection_context *)calloc(1,sizeof(struct kiro_connection_context));
-    if(!ctx)
-    {
-        printf("Failed to create connection context.\n");
-        rdma_destroy_id(client);
+
+    struct kiro_connection_context *ctx = (struct kiro_connection_context *)calloc (1, sizeof (struct kiro_connection_context));
+
+    if (!ctx) {
+        printf ("Failed to create connection context.\n");
+        rdma_destroy_id (client);
         return -1;
     }
-    
-    ctx->cf_mr_send = (struct kiro_rdma_mem *)calloc(1, sizeof(struct kiro_rdma_mem));
-    ctx->cf_mr_recv = (struct kiro_rdma_mem *)calloc(1, sizeof(struct kiro_rdma_mem));
-    if(!ctx->cf_mr_recv || !ctx->cf_mr_send)
-    {
-        printf("Failed to allocate Control Flow Memory Container.\n");
+
+    ctx->cf_mr_send = (struct kiro_rdma_mem *)calloc (1, sizeof (struct kiro_rdma_mem));
+    ctx->cf_mr_recv = (struct kiro_rdma_mem *)calloc (1, sizeof (struct kiro_rdma_mem));
+
+    if (!ctx->cf_mr_recv || !ctx->cf_mr_send) {
+        printf ("Failed to allocate Control Flow Memory Container.\n");
         goto error;
     }
-    
-    ctx->cf_mr_recv = kiro_create_rdma_memory(client->pd, sizeof(struct kiro_ctrl_msg), IBV_ACCESS_LOCAL_WRITE);
-    ctx->cf_mr_send = kiro_create_rdma_memory(client->pd, sizeof(struct kiro_ctrl_msg), IBV_ACCESS_LOCAL_WRITE);
-    if(!ctx->cf_mr_recv || !ctx->cf_mr_send)
-    {
-        printf("Failed to register control message memory.\n");
+
+    ctx->cf_mr_recv = kiro_create_rdma_memory (client->pd, sizeof (struct kiro_ctrl_msg), IBV_ACCESS_LOCAL_WRITE);
+    ctx->cf_mr_send = kiro_create_rdma_memory (client->pd, sizeof (struct kiro_ctrl_msg), IBV_ACCESS_LOCAL_WRITE);
+
+    if (!ctx->cf_mr_recv || !ctx->cf_mr_send) {
+        printf ("Failed to register control message memory.\n");
         goto error;
     }
-    ctx->cf_mr_recv->size = ctx->cf_mr_send->size = sizeof(struct kiro_ctrl_msg);
+
+    ctx->cf_mr_recv->size = ctx->cf_mr_send->size = sizeof (struct kiro_ctrl_msg);
     client->context = ctx;
-    
-    if(rdma_post_recv(client, client, ctx->cf_mr_recv->mem, ctx->cf_mr_recv->size, ctx->cf_mr_recv->mr))
-    {
-        printf("Posting preemtive receive for connection failed.\n");
+
+    if (rdma_post_recv (client, client, ctx->cf_mr_recv->mem, ctx->cf_mr_recv->size, ctx->cf_mr_recv->mr)) {
+        printf ("Posting preemtive receive for connection failed.\n");
         goto error;
     }
-    
-    if(rdma_accept(client, NULL))
-    {
-        printf("Failed to establish connection to the client with error: %i.\n", errno);
+
+    if (rdma_accept (client, NULL)) {
+        printf ("Failed to establish connection to the client with error: %i.\n", errno);
         goto error;
     }
-    printf("Client Connected.\n");
-    return 0;
-
 
+    printf ("Client Connected.\n");
+    return 0;
 error:
-    rdma_reject(client, NULL, 0);
-    kiro_destroy_connection_context(&ctx);
-    rdma_destroy_id(client);
+    rdma_reject (client, NULL, 0);
+    kiro_destroy_connection_context (&ctx);
+    rdma_destroy_id (client);
     return -1;
 }
 
 
-static int welcome_client (struct rdma_cm_id *client, void *mem, size_t mem_size)
+static int
+welcome_client (struct rdma_cm_id *client, void *mem, size_t mem_size)
 {
-    struct kiro_connection_context *ctx = (struct kiro_connection_context *)(client->context);
-    ctx->rdma_mr = (struct kiro_rdma_mem *)calloc(1, sizeof(struct kiro_rdma_mem));
-    if(!ctx->rdma_mr)
-    {
-        printf("Failed to allocate RDMA Memory Container.\n");
+    struct kiro_connection_context *ctx = (struct kiro_connection_context *) (client->context);
+    ctx->rdma_mr = (struct kiro_rdma_mem *)calloc (1, sizeof (struct kiro_rdma_mem));
+
+    if (!ctx->rdma_mr) {
+        printf ("Failed to allocate RDMA Memory Container.\n");
         return -1;
     }
-    
+
     ctx->rdma_mr->mem = mem;
     ctx->rdma_mr->size = mem_size;
-    ctx->rdma_mr->mr = rdma_reg_read(client, ctx->rdma_mr->mem, ctx->rdma_mr->size);
-    if(!ctx->rdma_mr->mr)
-    {
-        printf("Failed to register RDMA Memory Region.\n");
-        kiro_destroy_rdma_memory(ctx->rdma_mr);
+    ctx->rdma_mr->mr = rdma_reg_read (client, ctx->rdma_mr->mem, ctx->rdma_mr->size);
+
+    if (!ctx->rdma_mr->mr) {
+        printf ("Failed to register RDMA Memory Region.\n");
+        kiro_destroy_rdma_memory (ctx->rdma_mr);
         return -1;
     }
-    
-    struct kiro_ctrl_msg *msg = (struct kiro_ctrl_msg *)(ctx->cf_mr_send->mem);
+
+    struct kiro_ctrl_msg *msg = (struct kiro_ctrl_msg *) (ctx->cf_mr_send->mem);
+
     msg->msg_type = KIRO_ACK_RDMA;
-    msg->peer_mri = *(ctx->rdma_mr->mr);
-    
-    if(rdma_post_send(client, client, ctx->cf_mr_send->mem, ctx->cf_mr_send->size, ctx->cf_mr_send->mr, IBV_SEND_SIGNALED))
-    {
-        printf("Failure while trying to post SEND.\n");
-        kiro_destroy_rdma_memory(ctx->rdma_mr);
+
+    msg->peer_mri = * (ctx->rdma_mr->mr);
+
+    if (rdma_post_send (client, client, ctx->cf_mr_send->mem, ctx->cf_mr_send->size, ctx->cf_mr_send->mr, IBV_SEND_SIGNALED)) {
+        printf ("Failure while trying to post SEND.\n");
+        kiro_destroy_rdma_memory (ctx->rdma_mr);
         return -1;
     }
-    
+
     struct ibv_wc wc;
-    
-    if(rdma_get_send_comp(client, &wc) < 0)
-    {
-        printf("Failed to post RDMA MRI to client.\n");
-        kiro_destroy_rdma_memory(ctx->rdma_mr);
+
+    if (rdma_get_send_comp (client, &wc) < 0) {
+        printf ("Failed to post RDMA MRI to client.\n");
+        kiro_destroy_rdma_memory (ctx->rdma_mr);
         return -1;
     }
-    printf("RDMA MRI sent to client.\n");
 
+    printf ("RDMA MRI sent to client.\n");
     return 0;
 }
 
 
-void * event_loop (void *self)
+void *
+event_loop (void *self)
 {
-    KiroServerPrivate *priv = KIRO_SERVER_GET_PRIVATE((KiroServer *)self);
+    KiroServerPrivate *priv = KIRO_SERVER_GET_PRIVATE ((KiroServer *)self);
     struct rdma_cm_event *active_event;
 
-    while(0 == priv->close_signal) {
-        if(0 <= rdma_get_cm_event(priv->ec, &active_event))
-        {
+    while (0 == priv->close_signal) {
+        if (0 <= rdma_get_cm_event (priv->ec, &active_event)) {
             //Disable cancellation to prevent undefined states during shutdown
-            pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
-                        
-            struct rdma_cm_event *ev = malloc(sizeof(*active_event));
-            if(!ev)
-            {
-                printf("Unable to allocate memory for Event handling!\n");
-                rdma_ack_cm_event(active_event); 
+            pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, NULL);
+            struct rdma_cm_event *ev = malloc (sizeof (*active_event));
+
+            if (!ev) {
+                printf ("Unable to allocate memory for Event handling!\n");
+                rdma_ack_cm_event (active_event);
                 continue;
             }
-            memcpy(ev, active_event, sizeof(*active_event));
-            rdma_ack_cm_event(active_event);            
-            
-            if (ev->event == RDMA_CM_EVENT_CONNECT_REQUEST)
-            {
-                
-                if (0 != priv->close_signal)
-                {
+
+            memcpy (ev, active_event, sizeof (*active_event));
+            rdma_ack_cm_event (active_event);
+
+            if (ev->event == RDMA_CM_EVENT_CONNECT_REQUEST) {
+                if (0 != priv->close_signal) {
                     //Main thread has signalled shutdown!
-                    //Don't connect this client any more
+                    //Don't connect this client any more.
                     //Sorry mate!
-                    rdma_reject(ev->id, NULL, 0);
+                    rdma_reject (ev->id, NULL, 0);
                 }
-                
-                if(0 == connect_client(ev->id)) {
+
+                if (0 == connect_client (ev->id)) {
                     // Post a welcoming "Recieve" for handshaking
-                    if (0 == welcome_client(ev->id, priv->mem, priv->mem_size)) {
+                    if (0 == welcome_client (ev->id, priv->mem, priv->mem_size)) {
                         // Connection set-up successfully! (Server)
-                        struct kiro_connection_context *ctx = (struct kiro_connection_context *)(ev->id->context);
+                        struct kiro_connection_context *ctx = (struct kiro_connection_context *) (ev->id->context);
                         ctx->identifier = priv->next_client_id++;
                         priv->clients = g_list_append (priv->clients, (gpointer)ev->id);
-                        printf("Client id %u connected\n", ctx->identifier);
-                        printf("Currently %u clients in total are connected.\n", g_list_length (priv->clients));
+                        printf ("Client id %u connected\n", ctx->identifier);
+                        printf ("Currently %u clients in total are connected.\n", g_list_length (priv->clients));
                     }
                 }
             }
-            else if(ev->event == RDMA_CM_EVENT_DISCONNECTED)
-            {
+            else if (ev->event == RDMA_CM_EVENT_DISCONNECTED) {
                 GList *client = g_list_find (priv->clients, (gconstpointer) ev->id);
+
                 if (client) {
-                    struct kiro_connection_context *ctx = (struct kiro_connection_context *)(ev->id->context);
+                    struct kiro_connection_context *ctx = (struct kiro_connection_context *) (ev->id->context);
                     printf ("Got disconnect request from client %u.\n", ctx->identifier);
                     priv->clients = g_list_delete_link (priv->clients, client);
                 }
                 else
-                    printf("Got disconnect request from unknown client.\n");
+                    printf ("Got disconnect request from unknown client.\n");
 
-                kiro_destroy_connection(&(ev->id));
-                printf("Connection closed successfully. %u connected clients remaining.\n", g_list_length (priv->clients));
-            }            
-            free(ev);
+                kiro_destroy_connection (& (ev->id));
+                printf ("Connection closed successfully. %u connected clients remaining.\n", g_list_length (priv->clients));
+            }
+
+            free (ev);
         }
-        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+
+        pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL);
     }
 
-    printf("Closing Event Listener Thread\n");
+    printf ("Closing Event Listener Thread\n");
     return NULL;
 }
 
 
 
 
-int kiro_server_start (KiroServer *self, char *address, char *port, void* mem, size_t mem_size)
+int
+kiro_server_start (KiroServer *self, char *address, char *port, void *mem, size_t mem_size)
 {
-    KiroServerPrivate *priv = KIRO_SERVER_GET_PRIVATE(self);
+    KiroServerPrivate *priv = KIRO_SERVER_GET_PRIVATE (self);
 
-    if(priv->base)
-    {
-        printf("Server already started.\n");
+    if (priv->base) {
+        printf ("Server already started.\n");
         return -1;
     }
-    
-    if(!mem || mem_size == 0)
-    {
-        printf("Invalid memory given to provide.\n");
+
+    if (!mem || mem_size == 0) {
+        printf ("Invalid memory given to provide.\n");
         return -1;
     }
-    
+
     struct rdma_addrinfo hints, *res_addrinfo;
-    memset(&hints, 0, sizeof(hints));
+    memset (&hints, 0, sizeof (hints));
     hints.ai_port_space = RDMA_PS_IB;
     hints.ai_flags = RAI_PASSIVE;
-    if(rdma_getaddrinfo(address, port, &hints, &res_addrinfo))
-    {
-        printf("Failed to create address information.");
+
+    if (rdma_getaddrinfo (address, port, &hints, &res_addrinfo)) {
+        printf ("Failed to create address information.");
         return -1;
     }
-    
+
     struct ibv_qp_init_attr qp_attr;
-    memset(&qp_attr, 0, sizeof(qp_attr));
+    memset (&qp_attr, 0, sizeof (qp_attr));
     qp_attr.cap.max_send_wr = 10;
     qp_attr.cap.max_recv_wr = 10;
     qp_attr.cap.max_send_sge = 1;
     qp_attr.cap.max_recv_sge = 1;
     qp_attr.qp_context = priv->base;
     qp_attr.sq_sig_all = 1;
-    
-    if(rdma_create_ep(&(priv->base), res_addrinfo, NULL, &qp_attr))
-    {
-        printf("Endpoint creation failed: %s.\n", strerror (errno));
+
+    if (rdma_create_ep (& (priv->base), res_addrinfo, NULL, &qp_attr)) {
+        printf ("Endpoint creation failed: %s.\n", strerror (errno));
         return -1;
     }
-    printf("Endpoint created.\n");
-    
+
+    printf ("Endpoint created.\n");
     char *addr_local = NULL;
-    struct sockaddr* src_addr = rdma_get_local_addr(priv->base);
-    if(!src_addr)
-    {
+    struct sockaddr *src_addr = rdma_get_local_addr (priv->base);
+
+    if (!src_addr) {
         addr_local = "NONE";
     }
-    else
-    {
-        addr_local = inet_ntoa(((struct sockaddr_in *)src_addr)->sin_addr);
+    else {
+        addr_local = inet_ntoa (((struct sockaddr_in *)src_addr)->sin_addr);
         /*
         if(src_addr->sa_family == AF_INET)
             addr_local = &(((struct sockaddr_in*)src_addr)->sin_addr);
@@ -331,32 +327,28 @@ int kiro_server_start (KiroServer *self, char *address, char *port, void* mem, s
             addr_local = &(((struct sockaddr_in6*)src_addr)->sin6_addr);
         */
     }
-    
-    printf("Bound to address %s:%s\n",addr_local, port);
-    
-    if(rdma_listen(priv->base, 0))
-    {
-        printf("Failed to put server into listening state.\n");
-        rdma_destroy_ep(priv->base);
+
+    printf ("Bound to address %s:%s\n", addr_local, port);
+
+    if (rdma_listen (priv->base, 0)) {
+        printf ("Failed to put server into listening state.\n");
+        rdma_destroy_ep (priv->base);
         return -1;
     }
-    
+
     priv->mem = mem;
     priv->mem_size = mem_size;
+    priv->ec = rdma_create_event_channel();
 
-    priv->ec = rdma_create_event_channel();   
-    if(rdma_migrate_id(priv->base, priv->ec))
-    {
-        printf("Was unable to migrate connection to new Event Channel.\n");
-        rdma_destroy_ep(priv->base);
+    if (rdma_migrate_id (priv->base, priv->ec)) {
+        printf ("Was unable to migrate connection to new Event Channel.\n");
+        rdma_destroy_ep (priv->base);
         return -1;
     }
 
-    pthread_create(&(priv->event_listener), NULL, event_loop, self);
-
-    printf("Enpoint listening.\n");
-    
-    sleep(1);
+    pthread_create (& (priv->event_listener), NULL, event_loop, self);
+    printf ("Enpoint listening.\n");
+    sleep (1);
     return 0;
 }
 
@@ -366,7 +358,7 @@ disconnect_client (gpointer data, gpointer user_data)
 {
     if (data) {
         struct rdma_cm_id *id = (struct rdma_cm_id *)data;
-        struct kiro_connection_context *ctx = (struct kiro_connection_context *)(id->context);
+        struct kiro_connection_context *ctx = (struct kiro_connection_context *) (id->context);
         printf ("Disconnecting client: %u.\n", ctx->identifier);
         rdma_disconnect ((struct rdma_cm_id *) data);
     }
@@ -376,30 +368,29 @@ disconnect_client (gpointer data, gpointer user_data)
 void
 kiro_server_stop (KiroServer *self)
 {
-    if(!self)
+    if (!self)
         return;
-        
+
     KiroServerPrivate *priv = KIRO_SERVER_GET_PRIVATE (self);
-    
-    if(!priv->base)
+
+    if (!priv->base)
         return;
-    
+
     //Shut down the listener-thread
     priv->close_signal = 1;
-    pthread_cancel(priv->event_listener);
-    pthread_join(priv->event_listener, NULL);
-    printf("Event Listener Thread stopped.\n");
+    pthread_cancel (priv->event_listener);
+    pthread_join (priv->event_listener, NULL);
+    printf ("Event Listener Thread stopped.\n");
     priv->close_signal = 0;
     
     g_list_foreach (priv->clients, disconnect_client, NULL);
     g_list_free (priv->clients);
-     
-    rdma_destroy_ep(priv->base);
+    
+    rdma_destroy_ep (priv->base);
     priv->base = NULL;
-    rdma_destroy_event_channel(priv->ec);
+    rdma_destroy_event_channel (priv->ec);
     priv->ec = NULL;
-    
-    printf("Server stopped successfully.\n");
+    printf ("Server stopped successfully.\n");
 }
 
 
diff --git a/src/kiro-server.h b/src/kiro-server.h
index 9a70488..e0de71c 100644
--- a/src/kiro-server.h
+++ b/src/kiro-server.h
@@ -24,7 +24,7 @@
  * KiroServer implements the server / passive / provider side of the the RDMA
  * Communication Channel. It uses a KIRO-TRB to manage its data.
  */
- 
+
 #ifndef __KIRO_SERVER_H
 #define __KIRO_SERVER_H
 
@@ -47,9 +47,9 @@ typedef struct _KiroServerPrivate    KiroServerPrivate;
 
 
 struct _KiroServer {
-    
+
     GObject parent;
-    
+
     /*< private >*/
     KiroServerPrivate *priv;
 };
@@ -62,9 +62,9 @@ struct _KiroServer {
  */
 
 struct _KiroServerClass {
-    
+
     GObjectClass parent_class;
-       
+
 };
 
 
@@ -99,7 +99,7 @@ KiroServer*  kiro_server_new                 (void);
  *   kiro_trb_reshape, kiro_trb_adopt,
  *   kiro_trb_clone
  */
-int kiro_server_start (KiroServer* server, char* bind_addr, char* bind_port, void* mem, size_t mem_size);
+int kiro_server_start (KiroServer *server, char *bind_addr, char *bind_port, void *mem, size_t mem_size);
 
 /**
  * kiro_server_stop - Stops the server
@@ -109,7 +109,7 @@ int kiro_server_start (KiroServer* server, char* bind_addr, char* bind_port, voi
  * See also:
  *   kiro_server_start
  */
-void kiro_server_stop (KiroServer* server);
+void kiro_server_stop (KiroServer *server);
 
 G_END_DECLS
 
diff --git a/src/kiro-trb.c b/src/kiro-trb.c
index bb4a769..6737f83 100644
--- a/src/kiro-trb.c
+++ b/src/kiro-trb.c
@@ -27,7 +27,7 @@
  */
 
 #include <stdio.h>
- 
+
 #include <stdlib.h>
 #include <string.h>
 #include <glib.h>
@@ -51,10 +51,10 @@ struct _KiroTrbPrivate {
     void        *mem;            // Access to the actual buffer in Memory
     void        *frame_top;      // First byte of the buffer storage
     void        *current;        // Pointer to the current fill state
-    uint64_t    element_size;   
+    uint64_t    element_size;
     uint64_t    max_elements;
     uint64_t    iteration;      // How many times the buffer has wraped around
-    
+
     /* easy access */
     uint64_t    buff_size;
 };
@@ -63,8 +63,9 @@ struct _KiroTrbPrivate {
 G_DEFINE_TYPE (KiroTrb, kiro_trb, G_TYPE_OBJECT);
 
 
-KiroTrb*
-kiro_trb_new (void) {
+KiroTrb *
+kiro_trb_new (void)
+{
     return g_object_new (KIRO_TYPE_TRB, NULL);
 }
 
@@ -72,111 +73,131 @@ kiro_trb_new (void) {
 static
 void kiro_trb_init (KiroTrb *self)
 {
-    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE(self);
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
     priv->initialized = 0;
 }
 
 static void
 kiro_trb_finalize (GObject *object)
 {
-    KiroTrb *self = KIRO_TRB(object);
-    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE(self);
-    if(priv->mem)
-        free(priv->mem);
+    KiroTrb *self = KIRO_TRB (object);
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
+
+    if (priv->mem)
+        free (priv->mem);
 }
 
 static void
 kiro_trb_class_init (KiroTrbClass *klass)
 {
-    GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
+    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
     gobject_class->finalize = kiro_trb_finalize;
-    g_type_class_add_private(klass, sizeof(KiroTrbPrivate));
+    g_type_class_add_private (klass, sizeof (KiroTrbPrivate));
 }
 
 
 /* Privat functions */
 
-void write_header (KiroTrbPrivate* priv)
+void
+write_header (KiroTrbPrivate *priv)
 {
-    if(!priv)
+    if (!priv)
         return;
-    struct KiroTrbInfo* tmp_info = (struct KiroTrbInfo*)priv->mem;
+
+    struct KiroTrbInfo *tmp_info = (struct KiroTrbInfo *)priv->mem;
     tmp_info->buffer_size_bytes = priv->buff_size;
     tmp_info->element_size = priv->element_size;
     tmp_info->offset = (priv->iteration * priv->max_elements) + ((priv->current - priv->frame_top) / priv->element_size);
-    memcpy(priv->mem, tmp_info, sizeof(struct KiroTrbInfo));
+    memcpy (priv->mem, tmp_info, sizeof (struct KiroTrbInfo));
 }
 
 
 
 /* TRB functions */
 
-uint64_t kiro_trb_get_element_size (KiroTrb* self)
+uint64_t
+kiro_trb_get_element_size (KiroTrb *self)
 {
-    KiroTrbPrivate* priv = KIRO_TRB_GET_PRIVATE(self);
-    if(priv->initialized != 1)
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
+
+    if (priv->initialized != 1)
         return 0;
+
     return priv->element_size;
 }
 
 
-uint64_t kiro_trb_get_max_elements (KiroTrb* self)
+uint64_t
+kiro_trb_get_max_elements (KiroTrb *self)
 {
-    KiroTrbPrivate* priv = KIRO_TRB_GET_PRIVATE(self);
-    if(priv->initialized != 1)
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
+
+    if (priv->initialized != 1)
         return 0;
+
     return priv->max_elements;
 }
 
 
-uint64_t kiro_trb_get_raw_size (KiroTrb* self)
+uint64_t
+kiro_trb_get_raw_size (KiroTrb *self)
 {
-    KiroTrbPrivate* priv = KIRO_TRB_GET_PRIVATE(self);
-    if(priv->initialized != 1)
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
+
+    if (priv->initialized != 1)
         return 0;
+
     return priv->buff_size;
 }
 
 
-void* kiro_trb_get_raw_buffer (KiroTrb* self)
+void *
+kiro_trb_get_raw_buffer (KiroTrb *self)
 {
-    KiroTrbPrivate* priv = KIRO_TRB_GET_PRIVATE(self); 
-    if(priv->initialized != 1)
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
+
+    if (priv->initialized != 1)
         return NULL;
-    write_header(priv);
+
+    write_header (priv);
     return priv->mem;
 }
 
 
 
-void* kiro_trb_get_element (KiroTrb* self, uint64_t element)
+void *
+kiro_trb_get_element (KiroTrb *self, uint64_t element)
 {
-    KiroTrbPrivate* priv = KIRO_TRB_GET_PRIVATE(self);
-    if(priv->initialized != 1)
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
+
+    if (priv->initialized != 1)
         return NULL;
-    
-    uint64_t relative = 0;    
-    if(priv->iteration == 0)
+
+    uint64_t relative = 0;
+
+    if (priv->iteration == 0)
         relative = element * priv->element_size;
     else
-        relative = ((priv->current - priv->frame_top) + (priv->element_size * element)) % (priv->buff_size - sizeof(struct KiroTrbInfo));
-        
+        relative = ((priv->current - priv->frame_top) + (priv->element_size * element)) % (priv->buff_size - sizeof (struct KiroTrbInfo));
+
     return priv->frame_top + relative;
 }
 
 
-void kiro_trb_flush (KiroTrb *self)
+void
+kiro_trb_flush (KiroTrb *self)
 {
-    KiroTrbPrivate* priv = KIRO_TRB_GET_PRIVATE(self);
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
     priv->iteration = 0;
     priv->current = priv->frame_top;
-    write_header(priv);
+    write_header (priv);
 }
 
 
-void kiro_trb_purge (KiroTrb* self, gboolean free_memory)
+void
+kiro_trb_purge (KiroTrb *self, gboolean free_memory)
 {
-    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE(self);
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
     priv->iteration = 0;
     priv->current = NULL;
     priv->initialized = 0;
@@ -184,114 +205,143 @@ void kiro_trb_purge (KiroTrb* self, gboolean free_memory)
     priv->buff_size = 0;
     priv->frame_top = NULL;
     priv->element_size = 0;
-    if(free_memory)
-        free(priv->mem);
+
+    if (free_memory)
+        free (priv->mem);
+
     priv->mem = NULL;
 }
 
 
-int kiro_trb_is_setup (KiroTrb *self)
+int
+kiro_trb_is_setup (KiroTrb *self)
 {
-    KiroTrbPrivate* priv = KIRO_TRB_GET_PRIVATE(self);
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
     return priv->initialized;
 }
 
 
-int kiro_trb_reshape (KiroTrb *self, uint64_t element_size, uint64_t element_count)
+int
+kiro_trb_reshape (KiroTrb *self, uint64_t element_size, uint64_t element_count)
 {
-    if(element_size < 1 || element_count < 1)
+    if (element_size < 1 || element_count < 1)
         return -1;
-    size_t new_size = (element_size * element_count) + sizeof(struct KiroTrbInfo);
-    void* newmem = malloc(new_size);
-    if(!newmem)
+
+    size_t new_size = (element_size * element_count) + sizeof (struct KiroTrbInfo);
+    void *newmem = malloc (new_size);
+
+    if (!newmem)
         return -1;
+
     ((struct KiroTrbInfo *)newmem)->buffer_size_bytes = new_size;
     ((struct KiroTrbInfo *)newmem)->element_size = element_size;
     ((struct KiroTrbInfo *)newmem)->offset = 0;
-    kiro_trb_adopt(self, newmem);
+    kiro_trb_adopt (self, newmem);
     return 0;
 }
 
 
-int kiro_trb_push (KiroTrb *self, void *element_in)
+int
+kiro_trb_push (KiroTrb *self, void *element_in)
 {
-    KiroTrbPrivate* priv = KIRO_TRB_GET_PRIVATE(self);
-    if(priv->initialized != 1)
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
+
+    if (priv->initialized != 1)
         return -1;
-    if((priv->current + priv->element_size) > (priv->mem + priv->buff_size))
+
+    if ((priv->current + priv->element_size) > (priv->mem + priv->buff_size))
         return -1;
-    memcpy(priv->current, element_in, priv->element_size);
+
+    memcpy (priv->current, element_in, priv->element_size);
     priv->current += priv->element_size;
-    if(priv->current >= priv->frame_top + (priv->element_size * priv->max_elements))
-    {
+
+    if (priv->current >= priv->frame_top + (priv->element_size * priv->max_elements)) {
         priv->current = priv->frame_top;
         priv->iteration++;
     }
-    write_header(priv);
-    return 0;        
+
+    write_header (priv);
+    return 0;
 }
 
 
-void* kiro_trb_dma_push (KiroTrb *self)
+void *
+kiro_trb_dma_push (KiroTrb *self)
 {
-    KiroTrbPrivate* priv = KIRO_TRB_GET_PRIVATE(self);
-    if(priv->initialized != 1)
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
+
+    if (priv->initialized != 1)
         return NULL;
-    if((priv->current + priv->element_size) > (priv->mem + priv->buff_size))
+
+    if ((priv->current + priv->element_size) > (priv->mem + priv->buff_size))
         return NULL;
+
     void *mem_out = priv->current;
     priv->current += priv->element_size;
-    if(priv->current >= priv->frame_top + (priv->element_size * priv->max_elements))
-    {
+
+    if (priv->current >= priv->frame_top + (priv->element_size * priv->max_elements)) {
         priv->current = priv->frame_top;
         priv->iteration++;
     }
-    write_header(priv);
-    return mem_out;        
+
+    write_header (priv);
+    return mem_out;
 }
 
 
-void kiro_trb_refresh (KiroTrb *self)
+void
+kiro_trb_refresh (KiroTrb *self)
 {
-    KiroTrbPrivate* priv = KIRO_TRB_GET_PRIVATE(self);
-    if(priv->initialized != 1)
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
+
+    if (priv->initialized != 1)
         return;
+
     struct KiroTrbInfo *tmp = (struct KiroTrbInfo *)priv->mem;
     priv->buff_size = tmp->buffer_size_bytes;
     priv->element_size = tmp->element_size;
-    priv->max_elements = (tmp->buffer_size_bytes - sizeof(struct KiroTrbInfo)) / tmp->element_size;
+    priv->max_elements = (tmp->buffer_size_bytes - sizeof (struct KiroTrbInfo)) / tmp->element_size;
     priv->iteration = tmp->offset / priv->max_elements;
-    priv->frame_top = priv->mem + sizeof(struct KiroTrbInfo);
+    priv->frame_top = priv->mem + sizeof (struct KiroTrbInfo);
     priv->current = priv->frame_top + ((tmp->offset % priv->max_elements) * priv->element_size);
     priv->initialized = 1;
 }
 
 
-void kiro_trb_adopt (KiroTrb *self, void *buff_in)
+void
+kiro_trb_adopt (KiroTrb *self, void *buff_in)
 {
-    if(!buff_in)
+    if (!buff_in)
         return;
-    KiroTrbPrivate* priv = KIRO_TRB_GET_PRIVATE(self);
-    if(priv->mem)
-        free(priv->mem);
+
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
+
+    if (priv->mem)
+        free (priv->mem);
+
     priv->mem = buff_in;
     priv->initialized = 1;
-    kiro_trb_refresh(self);
+    kiro_trb_refresh (self);
 }
 
 
-int kiro_trb_clone (KiroTrb *self, void *buff_in)
+int
+kiro_trb_clone (KiroTrb *self, void *buff_in)
 {
-    KiroTrbPrivate* priv = KIRO_TRB_GET_PRIVATE(self);
+    KiroTrbPrivate *priv = KIRO_TRB_GET_PRIVATE (self);
     struct KiroTrbInfo *header = (struct KiroTrbInfo *)buff_in;
-    void *newmem = malloc(header->buffer_size_bytes);
-    if(!newmem)
+    void *newmem = malloc (header->buffer_size_bytes);
+
+    if (!newmem)
         return -1;
-    memcpy(newmem, buff_in, header->buffer_size_bytes);
-    if(priv->mem)
-        free(priv->mem);
+
+    memcpy (newmem, buff_in, header->buffer_size_bytes);
+
+    if (priv->mem)
+        free (priv->mem);
+
     priv->mem = newmem;
     priv->initialized = 1;
-    kiro_trb_refresh(self);
+    kiro_trb_refresh (self);
     return 0;
 }
diff --git a/src/kiro-trb.h b/src/kiro-trb.h
index 3753b29..36d3b5e 100644
--- a/src/kiro-trb.h
+++ b/src/kiro-trb.h
@@ -25,7 +25,7 @@
  * about its content inside itself, so its data can be exchanged between different
  * instances of the KiroTrb Class and/or sent over a network.
  */
- 
+
 #ifndef __KIRO_TRB_H
 #define __KIRO_TBR_H
 
@@ -48,7 +48,7 @@ typedef struct _KiroTrbPrivate    KiroTrbPrivate;
 
 
 struct _KiroTrb {
-    
+
     GObject parent;
 
 };
@@ -61,20 +61,20 @@ struct _KiroTrb {
  */
 
 struct _KiroTrbClass {
-    
+
     GObjectClass parent_class;
-       
+
 };
 
 
 struct KiroTrbInfo {
-    
+
     /* internal information about the buffer */
     uint64_t buffer_size_bytes;  // Size in bytes INCLUDING this header
     uint64_t element_size;       // Size in bytes of one single element
     uint64_t offset;             // Current Offset to access the 'oldest' element (in element count!)
-    
-} __attribute__((packed));
+
+} __attribute__ ((packed));
 
 
 /* GObject and GType functions */
@@ -94,10 +94,10 @@ KiroTrb*    kiro_trb_new                (void);
  * See also:
  *   kiro_trb_reshape, kiro_trb_adopt, kiro_trb_clone
  */
-uint64_t kiro_trb_get_element_size (KiroTrb* trb);
+uint64_t kiro_trb_get_element_size (KiroTrb *trb);
 
 /**
- * kiro_trb_get_max_elements: 
+ * kiro_trb_get_max_elements:
  * Returns the capacity of the buffer
  * @trb: #KiroTrb to perform the operation on
  * Description:
@@ -107,11 +107,11 @@ uint64_t kiro_trb_get_element_size (KiroTrb* trb);
  *   kiro_trb_get_element_size, kiro_trb_reshape, kiro_trb_adopt,
  *   kiro_trb_clone
  */
-uint64_t kiro_trb_get_max_elements (KiroTrb* trb);
+uint64_t kiro_trb_get_max_elements (KiroTrb *trb);
 
 
 /**
- * kiro_trb_get_raw_size: 
+ * kiro_trb_get_raw_size:
  * Returns the size of the buffer memory
  * @trb: #KiroTrb to perform the operation on
  * Description:
@@ -123,11 +123,11 @@ uint64_t kiro_trb_get_max_elements (KiroTrb* trb);
  *   kiro_trb_reshape, kiro_trb_adopt,
  *   kiro_trb_clone
  */
-uint64_t kiro_trb_get_raw_size (KiroTrb* trb);
+uint64_t kiro_trb_get_raw_size (KiroTrb *trb);
 
 
 /**
- * kiro_trb_get_raw_buffer: 
+ * kiro_trb_get_raw_buffer:
  * @trb: #KiroTrb to perform the operation on
  * Description:
  *   Returns a pointer to the memory structure of the given buffer.
@@ -148,11 +148,11 @@ uint64_t kiro_trb_get_raw_size (KiroTrb* trb);
  * See also:
  *   kiro_trb_refesh, kiro_trb_reshape, kiro_trb_adopt, kiro_trb_clone
  */
-void* kiro_trb_get_raw_buffer (KiroTrb* trb);
+void* kiro_trb_get_raw_buffer (KiroTrb *trb);
 
 
 /**
- * kiro_trb_get_element: 
+ * kiro_trb_get_element:
  * @trb: #KiroTrb to perform the operation on
  * @index: Index of the element in the buffer to access
  * Description:
@@ -172,11 +172,11 @@ void* kiro_trb_get_raw_buffer (KiroTrb* trb);
  * See also:
  *   kiro_trb_get_element_size, kiro_trb_get_raw_buffer
  */
-void* kiro_trb_get_element (KiroTrb* trb, uint64_t index);
+void* kiro_trb_get_element (KiroTrb *trb, uint64_t index);
 
 
 /**
- * kiro_trb_dma_push: 
+ * kiro_trb_dma_push:
  * Gives DMA to the next element and pushes the buffer
  * @trb: #KiroTrb to perform the operation on
  * Description:
@@ -198,11 +198,11 @@ void* kiro_trb_get_element (KiroTrb* trb, uint64_t index);
  * See also:
  *   kiro_trb_push, kiro_trb_get_element_size, kiro_trb_get_raw_buffer
  */
-void* kiro_trb_dma_push (KiroTrb* trb);
+void* kiro_trb_dma_push (KiroTrb *trb);
 
 
 /**
- * kiro_trb_flush: 
+ * kiro_trb_flush:
  * Flushes the buffer
  * @trb: #KiroTrb to perform the operation on
  * Description:
@@ -214,11 +214,11 @@ void* kiro_trb_dma_push (KiroTrb* trb);
  * See also:
  *   kiro_trb_reshape, kiro_trb_adopt, kiro_trb_clone
  */
-void kiro_trb_flush (KiroTrb* trb);
+void kiro_trb_flush (KiroTrb *trb);
 
 
 /**
- * kiro_trb_purge: 
+ * kiro_trb_purge:
  * Completely resets the Buffer
  * @trb: #KiroTrb to perform the operation on
  * @free_memory: True = internal memory will be free()'d,
@@ -233,11 +233,11 @@ void kiro_trb_flush (KiroTrb* trb);
  * See also:
  *   kiro_trb_reshape, kiro_trb_adopt, kiro_trb_clone
  */
-void kiro_trb_purge (KiroTrb* trb, gboolean free_memory);
+void kiro_trb_purge (KiroTrb *trb, gboolean free_memory);
 
 
 /**
- * kiro_trb_is_setup: 
+ * kiro_trb_is_setup:
  * Returns the setup status of the buffer
  * @trb: #KiroTrb to perform the operation on
  * Description:
@@ -250,11 +250,11 @@ void kiro_trb_purge (KiroTrb* trb, gboolean free_memory);
  * See also:
  *   kiro_trb_reshape, kiro_trb_adopt, kiro_trb_clone
  */
-int kiro_trb_is_setup (KiroTrb* trb);
+int kiro_trb_is_setup (KiroTrb *trb);
 
 
 /**
- * kiro_trb_reshape: 
+ * kiro_trb_reshape:
  * Reallocates internal memory and structures
  * @trb: #KiroTrb to perform the operation on
  * @element_size: Individual size of the elements to store in bytes
@@ -270,11 +270,11 @@ int kiro_trb_is_setup (KiroTrb* trb);
  * See also:
  *   kiro_trb_is_setup, kiro_trb_reshape, kiro_trb_adopt, kiro_trb_clone
  */
-int kiro_trb_reshape (KiroTrb* trb, uint64_t element_size, uint64_t element_count);
+int kiro_trb_reshape (KiroTrb *trb, uint64_t element_size, uint64_t element_count);
 
 
 /**
- * kiro_trb_clone: 
+ * kiro_trb_clone:
  * Clones the given memory into the internal memory
  * @trb: #KiroTrb to perform the operation on
  * @source: Pointer to the source memory to clone from
@@ -293,11 +293,11 @@ int kiro_trb_reshape (KiroTrb* trb, uint64_t element_size, uint64_t element_coun
  * See also:
  *   kiro_trb_reshape, kiro_trb_adopt
  */
-int kiro_trb_clone (KiroTrb* trb, void* source);
+int kiro_trb_clone (KiroTrb *trb, void *source);
 
 
 /**
- * kiro_trb_push: 
+ * kiro_trb_push:
  * Adds an element into the buffer
  * @trb: #KiroTrb to perform the operation on
  * @source: Pointer to the memory of the element to add
@@ -314,11 +314,11 @@ int kiro_trb_clone (KiroTrb* trb, void* source);
  *   kiro_trb_dma_push, kiro_trb_get_element_size, kiro_trb_clone,
  *   kiro_trb_adopt
  */
-int kiro_trb_push (KiroTrb* trb, void* source);
+int kiro_trb_push (KiroTrb *trb, void *source);
 
 
 /**
- * kiro_trb_refresh: 
+ * kiro_trb_refresh:
  * Re-reads the TRBs memory header
  * @trb: #KiroTrb to perform the operation on
  * Description:
@@ -333,11 +333,11 @@ int kiro_trb_push (KiroTrb* trb, void* source);
  * See also:
  *   kiro_trb_get_raw_buffer, kiro_trb_push_dma, kiro_trb_adopt
  */
-void kiro_trb_refresh (KiroTrb* trb);
+void kiro_trb_refresh (KiroTrb *trb);
 
 
 /**
- * kiro_trb_adopt: 
+ * kiro_trb_adopt:
  * Adopts the given memory into the TRB
  * @trb: #KiroTrb to perform the operation on
  * @source: Pointer to the source memory to adopt
@@ -356,7 +356,7 @@ void kiro_trb_refresh (KiroTrb* trb);
  * See also:
  *   kiro_trb_clone, kiro_trb_reshape
  */
-void kiro_trb_adopt (KiroTrb* trb, void* source);
+void kiro_trb_adopt (KiroTrb *trb, void *source);
 
 G_END_DECLS