diff --git a/embedded/libpbl/src/pbl.h b/embedded/libpbl/src/pbl.h
index cd0ba5673..33bc64d31 100644
--- a/embedded/libpbl/src/pbl.h
+++ b/embedded/libpbl/src/pbl.h
@@ -70,6 +70,7 @@
 
 */
 
+#include <stdio.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
diff --git a/src/ev_mgr.c b/src/ev_mgr.c
index 5e35d1690..c79f16b6e 100644
--- a/src/ev_mgr.c
+++ b/src/ev_mgr.c
@@ -41,6 +41,8 @@ const char *null_str = "";
 char run_file[KSN_BUFFER_SIZE];
 
 ksnetEvMgrClass* __ke_from_command_class(ksnCommandClass *X){return ((ksnetEvMgrClass*)((ksnCoreClass*)X->kc)->ke); }
+ksnetEvMgrClass* __ke_from_L0_class(ksnLNullClass *X){return ((ksnetEvMgrClass*)X->ke); };
+
 ksnetArpClass* __arp_from_command_class(ksnCommandClass *X){return ((ksnetArpClass*)((ksnCoreClass*)X->kc)->ka); }
 
 // Local functions
diff --git a/src/ev_mgr.h b/src/ev_mgr.h
index e2638c1fe..4a5fbb26d 100644
--- a/src/ev_mgr.h
+++ b/src/ev_mgr.h
@@ -322,10 +322,12 @@ typedef struct ksnetEvMgrClass {
 } ksnetEvMgrClass;
 
 ksnetEvMgrClass* __ke_from_command_class(ksnCommandClass *X);
+ksnetEvMgrClass* __ke_from_L0_class(ksnLNullClass *X);
 ksnetArpClass* __arp_from_command_class(ksnCommandClass *X);
 
-#define EVENT_MANAGER_CLASS(X) _Generic((X), \
-      ksnCommandClass* : __ke_from_command_class) (X)
+#define EVENT_MANAGER_OBJECT(X) _Generic((X), \
+      ksnCommandClass* : __ke_from_command_class, \
+      ksnLNullClass *  : __ke_from_L0_class) (X)
 
 #define ARP_TABLE_CLASS(X) _Generic((X), \
       ksnCommandClass* : __arp_from_command_class) (X)
diff --git a/src/modules/l0-server.c b/src/modules/l0-server.c
index b4d4cf979..7cc802850 100644
--- a/src/modules/l0-server.c
+++ b/src/modules/l0-server.c
@@ -13,10 +13,10 @@
 #include <stdbool.h>
 #include <string.h>
 
-#include "jsmn.h"
 #include "ev_mgr.h"
 #include "l0-server.h"
 #include "utils/rlutil.h"
+#include "jsmn.h"
 
 #include "teonet_l0_client_crypt.h"
 
@@ -61,6 +61,8 @@ void teoLNullPacketCheckMiscrypted(ksnLNullClass *kl, ksnLNullData *kld,
         return;
     }
 
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
+
     uint8_t *p_data = teoLNullPacketGetPayload(packet);
     uint8_t data_check = get_byte_checksum(p_data, packet->data_length);
     if (data_check == 0) { data_check++; }
@@ -71,7 +73,7 @@ void teoLNullPacketCheckMiscrypted(ksnLNullClass *kl, ksnLNullData *kld,
     char hexdump[92];
     dump_bytes(hexdump, sizeof(hexdump), p_data, packet->data_length);
 
-    ksn_printf(kev, MODULE, DEBUG,
+    ksn_printf(ke, MODULE, DEBUG,
                "FAILED " _ANSI_RED "POST DECRYPTION " _ANSI_YELLOW
                "CHECK from %s:%d" _ANSI_LIGHTCYAN
                " cmd %u, peer '%s', data_length %d, checksum %d, "
@@ -167,14 +169,15 @@ void ksnLNullDestroy(ksnLNullClass *kl) {
  */
 static void cmd_l0_read_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
 
-    size_t data_len = KSN_BUFFER_DB_SIZE; // Buffer length
+    size_t buffer_len = KSN_BUFFER_DB_SIZE; // Buffer length
     ksnLNullClass *kl = w->data; // Pointer to ksnLNullClass
-    char data[data_len]; // Buffer
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
+    char buffer[buffer_len]; // Buffer
 
     // Read TCP data
-    ssize_t received = read(w->fd, data, data_len);
+    ssize_t received = read(w->fd, buffer, buffer_len);
     #ifdef DEBUG_KSNET
-    ksn_printf(kev, MODULE, DEBUG_VV,
+    ksn_printf(ke, MODULE, DEBUG_VV,
             "Got something from fd %d w->events = %d, received = %d ...\n",
             w->fd, w->events, (int)received);
     #endif
@@ -184,35 +187,26 @@ static void cmd_l0_read_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
     if(!received) {
 
         #ifdef DEBUG_KSNET
-        ksn_printf(kev, MODULE, DEBUG_VV,
+        ksn_printf(ke, MODULE, DEBUG_VV,
             "Connection closed. Stop listening fd %d ...\n",
             w->fd
         );
         #endif
 
         ksnLNullClientDisconnect(kl, w->fd, 1);
-    }
-
-    // \todo Process reading error
-    else if (received < 0) {
-
+    } else if (received < 0) { // \TODO: Process reading error
         //        if( errno == EINTR ) {
         //            // OK, just skip it
         //        }
-
-//        #ifdef DEBUG_KSNET
-//        ksnet_printf(
-//            &kev->ksn_cfg, DEBUG,
-//            "%sl0 Server:%s "
-//            "Read error ...%s\n",
-//            ANSI_LIGHTCYAN, ANSI_RED, ANSI_NONE
-//        );
-//        #endif
-    }
-
-    // Success read. Process package and resend it to teonet
-    else {
-
+        //        #ifdef DEBUG_KSNET
+        //        ksnet_printf(
+        //            &ke->ksn_cfg, DEBUG,
+        //            "%sl0 Server:%s "
+        //            "Read error ...%s\n",
+        //            ANSI_LIGHTCYAN, ANSI_RED, ANSI_NONE
+        //        );
+        //        #endif
+    } else { // Success read. Process package and resend it to teonet
         ksnLNullData* kld = ksnLNullGetClientConnection(kl, w->fd);
         if(kld != NULL) {
 
@@ -223,7 +217,7 @@ static void cmd_l0_read_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
             if(received > kld->read_buffer_size - kld->read_buffer_ptr) {
 
                 // Increase read buffer size
-                kld->read_buffer_size += data_len; //received;
+                kld->read_buffer_size += buffer_len; //received;
                 if(kld->read_buffer != NULL)
                     kld->read_buffer = realloc(kld->read_buffer,
                             kld->read_buffer_size);
@@ -231,13 +225,13 @@ static void cmd_l0_read_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
                     kld->read_buffer = malloc(kld->read_buffer_size);
 
                 #ifdef DEBUG_KSNET
-                ksn_printf(kev, MODULE, DEBUG_VV,
+                ksn_printf(ke, MODULE, DEBUG_VV,
                     "%s" "increase read buffer to new size: %d bytes ...%s\n",
                     ANSI_DARKGREY, kld->read_buffer_size,
                     ANSI_NONE);
                 #endif
             }
-            memmove(kld->read_buffer + kld->read_buffer_ptr, data, received);
+            memmove((uint8_t *)kld->read_buffer + kld->read_buffer_ptr, buffer, received);
             kld->read_buffer_ptr += received;
 
             teoLNullCPacket *packet = (teoLNullCPacket *)kld->read_buffer;
@@ -277,13 +271,13 @@ static void cmd_l0_read_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
                                 if (processKeyExchange(kl, kld, w->fd, kex,
                                                        packet->data_length)) {
                                     #ifdef DEBUG_KSNET
-                                    ksn_printf(kev, MODULE, DEBUG_VV,
+                                    ksn_printf(ke, MODULE, DEBUG_VV,
                                                "Encription established for fd %d ...\n",
                                                w->fd);
                                     #endif
                                 } else {
                                     #ifdef DEBUG_KSNET
-                                    ksn_printf(kev, MODULE, DEBUG_VV,
+                                    ksn_printf(ke, MODULE, DEBUG_VV,
                                                "Key exchange failed. Stop listening fd %d ...\n",
                                                w->fd);
                                     #endif
@@ -300,7 +294,7 @@ static void cmd_l0_read_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
                                     // Set temporary name (it will be changed after TEO_AUTH answer)
                                     ksnLNullClientAuthCheck(kl, kld, w->fd, packet);
                                 } else {
-                                    ksn_printf(kev, MODULE, ERROR_M,
+                                    ksn_printf(ke, MODULE, ERROR_M,
                                         "Invalid login packet from %s:%d\n",
                                         kld->t_addr, kld->t_port);
                                 }
@@ -315,7 +309,7 @@ static void cmd_l0_read_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
                             // Drop wrong packet
                             else {
                                 #ifdef DEBUG_KSNET
-                                ksn_printf(kev, MODULE, DEBUG,
+                                ksn_printf(ke, MODULE, DEBUG,
                                     "%s" "got valid packet from fd: %d before login command; packet ignored ...%s\n",
                                     ANSI_RED, w->fd, ANSI_NONE);
                                 #endif
@@ -323,7 +317,7 @@ static void cmd_l0_read_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
                         }
                     } else {
                         #ifdef DEBUG_KSNET
-                        ksn_printf(kev, MODULE, DEBUG,
+                        ksn_printf(ke, MODULE, DEBUG,
                                    _ANSI_RED
                                    "FAILED decrypt packet from "
                                    "fd: %d; packet ignored ..." _ANSI_NONE "\n",
@@ -335,28 +329,28 @@ static void cmd_l0_read_cb(struct ev_loop *loop, struct ev_io *w, int revents) {
                 // Wrong checksum - drop this packet
                 else {
                     #ifdef DEBUG_KSNET
-                    ksn_printf(kev, MODULE, DEBUG,
+                    ksn_printf(ke, MODULE, DEBUG,
                         "%s" "got wrong packet %d bytes length, from fd: %d; packet dropped ...%s\n",
                         ANSI_RED, len, w->fd, ANSI_NONE);
                     #endif
                 }
 
                 ptr += len;
-                packet = (void*)packet + len;
+                packet = (void *)((uint8_t*)packet + len);
             }
 
             // Check end of buffer
             if(kld->read_buffer_ptr - ptr > 0) {
 
                 #ifdef DEBUG_KSNET
-                ksn_printf(kev, MODULE, DEBUG_VV,
+                ksn_printf(ke, MODULE, DEBUG_VV,
                     "%s" "wait next part of packet, now it has %d bytes ...%s\n",
                     ANSI_DARKGREY, kld->read_buffer_ptr - ptr,
                     ANSI_NONE);
                 #endif
 
                 kld->read_buffer_ptr = kld->read_buffer_ptr - ptr;
-                memmove(kld->read_buffer, kld->read_buffer + ptr,
+                memmove(kld->read_buffer, (uint8_t *)kld->read_buffer + ptr,
                         kld->read_buffer_ptr);
             }
             else kld->read_buffer_ptr = 0;
@@ -387,7 +381,8 @@ ksnLNullSStat *ksnLNullStat(ksnLNullClass *kl) {
  */ 
 static int extendedLog(ksnLNullClass *kl) {
     int log_level = DEBUG_VV;
-    if(kev->ksn_cfg.l0_allow_f && kev->ksn_cfg.extended_l0_log_f) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
+    if(ke->ksn_cfg.l0_allow_f && ke->ksn_cfg.extended_l0_log_f) {
         log_level = DEBUG;
     }
     return log_level;
@@ -404,7 +399,7 @@ static int extendedLog(ksnLNullClass *kl) {
  */
 static ksnet_arp_data *ksnLNullSendFromL0(ksnLNullClass *kl, teoLNullCPacket *packet,
         char *cname, size_t cname_length) {
-
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
     size_t out_data_len = sizeof(ksnLNullSPacket) + cname_length +
             packet->data_length;
     char *out_data = malloc(out_data_len);
@@ -413,35 +408,35 @@ static ksnet_arp_data *ksnLNullSendFromL0(ksnLNullClass *kl, teoLNullCPacket *pa
 
     // Create teonet L0 packet
     spacket->cmd = packet->cmd;
-    spacket->from_length = cname_length;
-    memcpy(spacket->from, cname, cname_length);
+    spacket->client_name_length = cname_length;
+    memcpy(spacket->payload, cname, cname_length);
     spacket->data_length = packet->data_length;
-    memcpy(spacket->from + spacket->from_length,
+    memcpy(spacket->payload + spacket->client_name_length,
         packet->peer_name + packet->peer_name_length, spacket->data_length);
 
     // Send teonet L0 packet
     ksnet_arp_data *arp_data = NULL;
     #ifdef DEBUG_KSNET
-    ksn_printf(kev, MODULE, extendedLog(kl),
+    ksn_printf(ke, MODULE, extendedLog(kl),
         "send packet to peer \"%s\" from L0 client \"%s\" ...\n",
-        packet->peer_name, spacket->from);
+        packet->peer_name, spacket->payload);
     #endif
 
     // Send to peer
-    if(strlen((char*)packet->peer_name) && strcmp((char*)packet->peer_name, ksnetEvMgrGetHostName(kev))) {        
-        arp_data = ksnCoreSendCmdto(kev->kc, packet->peer_name, CMD_L0,
+    if(strlen((char*)packet->peer_name) && strcmp((char*)packet->peer_name, ksnetEvMgrGetHostName(ke))) {        
+        arp_data = ksnCoreSendCmdto(ke->kc, packet->peer_name, CMD_L0,
                 spacket, out_data_len);
     }
     // Send to this host
     else {
         // Create packet
         size_t pkg_len;
-        void *pkg = ksnCoreCreatePacket(kev->kc, CMD_L0, spacket, out_data_len, &pkg_len);
+        void *pkg = ksnCoreCreatePacket(ke->kc, CMD_L0, spacket, out_data_len, &pkg_len);
         struct sockaddr_storage addr;             // address structure
         socklen_t addrlen = sizeof(addr); // length of addresses
-        if(!make_addr(localhost, kev->kc->port, (__SOCKADDR_ARG) &addr, &addrlen)) {
-            ksnCoreProcessPacket(kev->kc, pkg, pkg_len, (__SOCKADDR_ARG) &addr);
-            arp_data = (ksnet_arp_data *)ksnetArpGet(kev->kc->ka, (char*)packet->peer_name);
+        if(!make_addr(localhost, ke->kc->port, (__SOCKADDR_ARG) &addr, &addrlen)) {
+            ksnCoreProcessPacket(ke->kc, pkg, pkg_len, (__SOCKADDR_ARG) &addr);
+            arp_data = (ksnet_arp_data *)ksnetArpGet(ke->kc->ka, (char*)packet->peer_name);
         }
         free(pkg);
     }
@@ -480,16 +475,16 @@ int ksnLNullSendToL0(void *ke, char *addr, int port, char *cname,
 
     // Create teonet L0 packet
     spacket->cmd = cmd;
-    spacket->from_length = cname_length;
-    memcpy(spacket->from, cname, cname_length);
+    spacket->client_name_length = cname_length;
+    memcpy(spacket->payload, cname, cname_length);
     spacket->data_length = data_len;
-    memcpy(spacket->from + spacket->from_length, data, data_len);
+    memcpy(spacket->payload + spacket->client_name_length, data, data_len);
 
     // Send command to client of L0 server
     #ifdef DEBUG_KSNET
     ksn_printf(((ksnetEvMgrClass*)ke), MODULE, DEBUG_VV,
         "send command to L0 server for client \"%s\" ...\n",
-        spacket->from);
+        spacket->payload);
     #endif
     int rv = ksnCoreSendto(((ksnetEvMgrClass*)ke)->kc, addr, port, CMD_L0_TO,
             out_data, out_data_len);
@@ -559,6 +554,7 @@ int ksnLNullSendEchoToL0A(void *ke, char *addr, int port, char *cname,
  * @return client, pointer to ksnLNullData
  */
 static ksnLNullData* ksnLNullClientRegister(ksnLNullClass *kl, int fd, const char *remote_addr, int remote_port) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
 
     ksnLNullData data;
     data.name = NULL;
@@ -576,7 +572,7 @@ static ksnLNullData* ksnLNullClientRegister(ksnLNullClass *kl, int fd, const cha
     ksnLNullData* kld = ksnLNullGetClientConnection(kl, fd);
     // #ifdef DEBUG_KSNET
     if (kld == NULL) {
-        ksn_printf(kev, MODULE, ERROR_M,
+        ksn_printf(ke, MODULE, ERROR_M,
                    "Failed L0 client registration with fd %d from %s:%d\n",
                    fd, remote_addr, remote_port);
         return NULL;
@@ -590,7 +586,7 @@ static ksnLNullData* ksnLNullClientRegister(ksnLNullClass *kl, int fd, const cha
 }
 
 
-void _send_subscribe_event_disconnected(ksnetEvMgrClass *ke, const char *payload,
+void _send_subscribe_event_disconnected(ksnetEvMgrClass *ke, char *payload,
         size_t payload_length) {
     teoSScrSend(ke->kc->kco->ksscr, EV_K_L0_DISCONNECTED, (void *)payload, payload_length, 0);
 }
@@ -599,7 +595,7 @@ void _send_subscribe_event_disconnected(ksnetEvMgrClass *ke, const char *payload
  * Send Connected event to all subscribers
  *
  */
-void _send_subscribe_event_connected(ksnetEvMgrClass *ke, const char *payload,
+void _send_subscribe_event_connected(ksnetEvMgrClass *ke, char *payload,
         size_t payload_length) {
 
     teoSScrSend(ke->kc->kco->ksscr, EV_K_L0_CONNECTED, (void *)payload, payload_length, 0);
@@ -647,8 +643,9 @@ static void stringViewReset(string_view *s) {
 
 
 static bool parseAuthPayload(ksnLNullClass *kl, uint8_t *payload, string_view *name, string_view *sign, string_view *auth_data_valid_until) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
     if (name == NULL || sign == NULL || auth_data_valid_until == NULL) {
-        ksn_printf(kev, MODULE, DEBUG, "Missing output params: name=%p, sign=%p, valid_ts=%p\n", name, sign, auth_data_valid_until);
+        ksn_printf(ke, MODULE, DEBUG, "Missing output params: name=%p, sign=%p, valid_ts=%p\n", name, sign, auth_data_valid_until);
         return false;
     }
 
@@ -695,15 +692,11 @@ static bool parseAuthPayload(ksnLNullClass *kl, uint8_t *payload, string_view *n
     return auth_data_valid_until->data != NULL && sign->data != NULL && name->data != NULL;
 }
 
-static bool checkAuthData(
-        ksnLNullClass *kl,
-        string_view *name,
-        string_view *auth_data_valid_until,
-        string_view *sign,
-        const char *secret) {
+static bool checkAuthData(ksnLNullClass *kl, string_view *name, string_view *auth_data_valid_until, string_view *sign, const char *secret) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
 
     if (sign->len != MD5_DIGEST_LENGTH*2) {
-        ksn_printf(kev, MODULE, DEBUG, "Invalid signature length:  %.*s\n",
+        ksn_printf(ke, MODULE, DEBUG, "Invalid signature length:  %.*s\n",
             sign->len, sign->data);
         return false;
     }
@@ -717,7 +710,7 @@ static bool checkAuthData(
     if ((current_time_str_len > auth_data_valid_until->len) ||
             (current_time_str_len == auth_data_valid_until->len &&
             strncmp(auth_data_valid_until->data, current_time_str, auth_data_valid_until->len) < 0)) {
-        ksn_printf(kev, MODULE, DEBUG, "timestamp %.*s outdated, current time: %d\n",
+        ksn_printf(ke, MODULE, DEBUG, "timestamp %.*s outdated, current time: %d\n",
             auth_data_valid_until->len, auth_data_valid_until->data, current_time);
         return false;
     }
@@ -750,7 +743,8 @@ static void updateClientName(ksnLNullClass *kl, ksnLNullData *kld, int fd, strin
     int fd_ex = ksnLNullClientIsConnected(kl, client_name);
     if(fd_ex) {
         #ifdef DEBUG_KSNET
-        ksn_printf(kev, MODULE, DEBUG,"User with name(id): %s is already connected, fd_ex: %d, fd: %d\n", client_name, fd_ex, fd);
+        ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
+        ksn_printf(ke, MODULE, DEBUG,"User with name(id): %s is already connected, fd_ex: %d, fd: %d\n", client_name, fd_ex, fd);
         #endif
         if(fd_ex != fd) ksnLNullClientDisconnect(kl, fd_ex, 1);
     }
@@ -763,6 +757,7 @@ static void updateClientName(ksnLNullClass *kl, ksnLNullData *kld, int fd, strin
 }
 
 static void sendConnectedEvent(ksnLNullClass *kl, ksnLNullData *kld) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
     // TODO: I must use kl->stat.clients or ke->kl->stat.visits ????? instead pblMapSize(kl->map)
     int playload_size = snprintf(0, 0, "{\"client_name\":\"%s\",\"trudp_ip\":\"%s\",\"count_of_clients\":%d}",
         kld->name, kld->t_addr ? kld->t_addr : "error", pblMapSize(kl->map));
@@ -770,19 +765,21 @@ static void sendConnectedEvent(ksnLNullClass *kl, ksnLNullData *kld) {
     snprintf(payload, playload_size + 1, "{\"client_name\":\"%s\",\"trudp_ip\":\"%s\",\"count_of_clients\":%d}",
         kld->name, kld->t_addr ? kld->t_addr : "error", pblMapSize(kl->map));
 
-    _send_subscribe_event_connected(kev, payload, playload_size + 1);
+    _send_subscribe_event_connected(ke, payload, playload_size + 1);
     free(payload);
 }
 
 static void confirmAuth(ksnLNullClass *kl, ksnLNullData *kld, int fd) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
+
     // Create L0 packet
-    size_t out_data_len = sizeof(teoLNullCPacket) + strlen(kev->ksn_cfg.host_name) + 1 + kld->name_length + 1;
+    size_t out_data_len = sizeof(teoLNullCPacket) + strlen(ke->ksn_cfg.host_name) + 1 + kld->name_length + 1;
     char *out_data = malloc(out_data_len);
     memset(out_data, 0, out_data_len);
 
     size_t packet_length =
         teoLNullPacketCreate(out_data, out_data_len,
-                                CMD_CONFIRM_AUTH, kev->ksn_cfg.host_name, (uint8_t*)kld->name, kld->name_length + 1);
+                                CMD_CONFIRM_AUTH, ke->ksn_cfg.host_name, (uint8_t*)kld->name, kld->name_length + 1);
 
     // Send confirmation of the client name
     ssize_t send_size = ksnLNullPacketSend(kl, fd, out_data, packet_length);
@@ -801,16 +798,17 @@ static void confirmAuth(ksnLNullClass *kl, ksnLNullData *kld, int fd) {
  */
 static bool ksnLNullClientAuthCheck(ksnLNullClass *kl, ksnLNullData *kld,
         int fd, teoLNullCPacket *packet) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
 
     if (((ksnetEvMgrClass*)kl->ke)->ksn_cfg.auth_secret[0] == '\0') {
-        ksn_printf(kev, MODULE, DEBUG, "secret not provided, disconnect %d\n", fd);
+        ksn_printf(ke, MODULE, DEBUG, "secret not provided, disconnect %d\n", fd);
         ksnLNullClientDisconnect(kl, fd, 1);
         return false;
     }
 
     uint8_t *payload = teoLNullPacketGetPayload(packet);
 
-    ksn_printf(kev, MODULE, DEBUG,"Checking payload from fd %d:\n%s\n", fd, (const char*)payload);
+    ksn_printf(ke, MODULE, DEBUG,"Checking payload from fd %d:\n%s\n", fd, (const char*)payload);
 
     //NOTE: string_views will be reseted inside parseAuthPayload
     string_view name;
@@ -818,13 +816,13 @@ static bool ksnLNullClientAuthCheck(ksnLNullClass *kl, ksnLNullData *kld,
     string_view auth_data_valid_until;
 
     if (!parseAuthPayload(kl, payload, &name, &sign, &auth_data_valid_until)) {
-        ksn_printf(kev, MODULE, DEBUG,"Invalid payload received from fd %d:\n%s\n", fd, (const char*)payload);
+        ksn_printf(ke, MODULE, DEBUG,"Invalid payload received from fd %d:\n%s\n", fd, (const char*)payload);
         ksnLNullClientDisconnect(kl, fd, 1);
         return false;
     }
 
     if (!checkAuthData(kl, &name, &auth_data_valid_until, &sign, ((ksnetEvMgrClass*)kl->ke)->ksn_cfg.auth_secret)) {
-        ksn_printf(kev, MODULE, DEBUG,"Failed to verify signature '%.*s' - '%.*s' - '%.*s' received from fd %d\n",
+        ksn_printf(ke, MODULE, DEBUG,"Failed to verify signature '%.*s' - '%.*s' - '%.*s' received from fd %d\n",
             name.len,
             name.data,
             auth_data_valid_until.len,
@@ -948,7 +946,8 @@ ssize_t ksnLNullPacketSend(ksnLNullClass *kl, int fd, void *pkg,
             trudpUdpMakeAddr(kld->t_addr, kld->t_port, (__SOCKADDR_ARG) &remaddr, &addrlen);
 
             #ifdef DEBUG_KSNET
-            ksn_printf(kev, MODULE, extendedLog(kl),
+            ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
+            ksn_printf(ke, MODULE, extendedLog(kl),
                        "send packet to trudp addr: %s:%d, cmd = %u, from "
                        "peer: %s, data: %s \n",
                        kld->t_addr, kld->t_port, (unsigned)packet->cmd,
@@ -963,7 +962,7 @@ ssize_t ksnLNullPacketSend(ksnLNullClass *kl, int fd, void *pkg,
                     (__CONST_SOCKADDR_ARG) &remaddr, addrlen);
                 pkg_length -= len;
                 if(!pkg_length) break;
-                pkg += len;
+                pkg = (uint8_t *)pkg + len;
             }
         }
     }
@@ -988,11 +987,12 @@ ssize_t ksnLNullPacketSend(ksnLNullClass *kl, int fd, void *pkg,
  * @param remote_port remote port
  */
 static void ksnLNullClientConnect(ksnLNullClass *kl, int fd, const char *remote_addr, int remote_port) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
 
     // Set TCP_NODELAY option
     teosockSetTcpNodelay(fd);
 
-    ksn_printf(kev, MODULE, DEBUG_VV,
+    ksn_printf(ke, MODULE, DEBUG_VV,
                "L0 client with fd %d connected from %s:%d\n",
                fd, remote_addr, remote_port);
 
@@ -1003,7 +1003,7 @@ static void ksnLNullClientConnect(ksnLNullClass *kl, int fd, const char *remote_
         ev_init (&kld->w, cmd_l0_read_cb);
         ev_io_set (&kld->w, fd, EV_READ);
         kld->w.data = kl;
-        ev_io_start (kev->ev_loop, &kld->w);
+        ev_io_start (ke->ev_loop, &kld->w);
 
     } else {
         // Error: can't register TCP fd in tcp proxy map
@@ -1026,6 +1026,7 @@ static void ksnLNullClientConnect(ksnLNullClass *kl, int fd, const char *remote_
  *
  */
 void ksnLNullClientDisconnect(ksnLNullClass *kl, int fd, int remove_f) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
 
     size_t valueLength;
 
@@ -1036,12 +1037,12 @@ void ksnLNullClientDisconnect(ksnLNullClass *kl, int fd, int remove_f) {
 
         // Stop L0 client watcher
         if(fd < MAX_FD_NUMBER) {
-            ev_io_stop(kev->ev_loop, &kld->w);
+            ev_io_stop(ke->ev_loop, &kld->w);
             if(remove_f != 2) close(fd);
         }
         if (kld->name != NULL  && !strstr(kld->name, "-new-")) {
             // Show disconnect message
-            ksn_printf(kev, MODULE, CONNECT, "### 0005,%s\n", kld->name);
+            ksn_printf(ke, MODULE, CONNECT, "### 0005,%s\n", kld->name);
         }
 
         // L0 statistic - client disconnect
@@ -1054,7 +1055,7 @@ void ksnLNullClientDisconnect(ksnLNullClass *kl, int fd, int remove_f) {
             char *payload = malloc(playload_size + 1);
             snprintf(payload, playload_size + 1, "{\"client_name\":\"%s\",\"trudp_ip\":\"%s\",\"count_of_clients\":%d}",
                 kld->name, kld->t_addr ? kld->t_addr : "error", kl->stat.clients);
-            _send_subscribe_event_disconnected(kev, payload, playload_size + 1);
+            _send_subscribe_event_disconnected(ke, payload, playload_size + 1);
             free(payload);
         }
 
@@ -1131,22 +1132,23 @@ static void cmd_l0_accept_cb(struct ev_loop *loop, struct ev_ksnet_io *w,
 void _check_connected(uint32_t id, int type, void *data) {
 
     ksnLNullClass *kl = data;
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
 
     // Disconnect all clients which don't send nothing during timeout
     PblIterator *it = pblMapIteratorReverseNew(kl->map);
     if(it != NULL) {
         while(pblIteratorHasPrevious(it) > 0) {
             void *entry = pblIteratorPrevious(it);
-            ksnLNullData *data = pblMapEntryValue(entry);
+            ksnLNullData *l0_data = pblMapEntryValue(entry);
             int *fd = (int *) pblMapEntryKey(entry);
             // Disconnect client
-            if(ksnetEvMgrGetTime(kl->ke) - data->last_time >= DISCONNECT_TIMEOUT) {
-                ksn_printf(kev, MODULE, DEBUG, "Disconnect client by timeout, fd: %d, name: %s\n", *fd, data->name);
+            if(ksnetEvMgrGetTime(kl->ke) - l0_data->last_time >= DISCONNECT_TIMEOUT) {
+                ksn_printf(ke, MODULE, DEBUG, "Disconnect client by timeout, fd: %d, name: %s\n", *fd, l0_data->name);
                 ksnLNullClientDisconnect(kl, *fd, 1);
             }
             // Send echo to client, if authorized
-            else if(data->name != NULL && ksnetEvMgrGetTime(kl->ke) - data->last_time >= SEND_PING_TIMEOUT) {
-                ksn_printf(kev, MODULE, DEBUG, "Send ping to client by timeout, fd: %d, name: %s\n", *fd, data->name);
+            else if(l0_data->name != NULL && ksnetEvMgrGetTime(kl->ke) - l0_data->last_time >= SEND_PING_TIMEOUT) {
+                ksn_printf(ke, MODULE, DEBUG, "Send ping to client by timeout, fd: %d, name: %s\n", *fd, l0_data->name);
 
                 // From this host(peer)
                 const char *from = ksnetEvMgrGetHostName(kl->ke);
@@ -1186,25 +1188,26 @@ void _check_connected(uint32_t id, int type, void *data) {
  * @return If return value > 0 than server was created successfully
  */
 static int ksnLNullStart(ksnLNullClass *kl) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
 
     int fd = 0;
 
-    if(kev->ksn_cfg.l0_allow_f) {
+    if(ke->ksn_cfg.l0_allow_f) {
 
         // Create l0 server at port, which will wait client connections
         int port_created;
         if((fd = ksnTcpServerCreate(
-                    kev->kt,
-                    kev->ksn_cfg.l0_tcp_port,
+                    ke->kt,
+                    ke->ksn_cfg.l0_tcp_port,
                     cmd_l0_accept_cb,
                     kl,
                     &port_created)) > 0) {
 
-            ksn_printf(kev, MODULE, MESSAGE,
+            ksn_printf(ke, MODULE, MESSAGE,
                     "l0 server fd %d started at port %d\n",
                     fd, port_created);
 
-            kev->ksn_cfg.l0_tcp_port = port_created;
+            ke->ksn_cfg.l0_tcp_port = port_created;
             kl->fd = fd;
 
             // Init check clients cque
@@ -1225,9 +1228,10 @@ static int ksnLNullStart(ksnLNullClass *kl) {
  *
  */
 static void ksnLNullStop(ksnLNullClass *kl) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
 
     // If server started
-    if(kev->ksn_cfg.l0_allow_f && kl->fd) {
+    if(ke->ksn_cfg.l0_allow_f && kl->fd) {
 
         // Disconnect all clients
         PblIterator *it = pblMapIteratorReverseNew(kl->map);
@@ -1247,7 +1251,7 @@ static void ksnLNullStop(ksnLNullClass *kl) {
         ksnCQueDestroy(kl->cque); // Init check clients cque
 
         // Stop the server
-        ksnTcpServerStop(kev->kt, kl->fd);
+        ksnTcpServerStop(ke->kt, kl->fd);
     }
 }
 
@@ -1290,34 +1294,32 @@ int cmd_l0_cb(ksnetEvMgrClass *ke, ksnCorePacketData *rd) {
        (data->cmd >= CMD_USER && data->cmd < CMD_192_RESERVED) ||
        (data->cmd >= CMD_USER_NR && data->cmd < CMD_LAST)) {
 
+        // \TODO: char *client_name = data->payload;
         #ifdef DEBUG_KSNET
         ksn_printf(ke, MODULE, DEBUG_VV,
             "got valid command No %d from %s client with %d bytes data ...\n",
-            data->cmd, data->from, data->data_length);
+            data->cmd, data->payload, data->data_length);
         #endif
 
         ksnCorePacketData *rds = rd;
 
         // Process command
         rds->cmd = data->cmd;
-        rds->from = data->from;
-        rds->from_len = data->from_length;
-        rds->data = data->from + data->from_length;
+        rds->from = data->payload;
+        rds->from_len = data->client_name_length;
+        rds->data = data->payload + data->client_name_length;
         rds->data_len = data->data_length;
         rds->l0_f = 1;
 
         // Execute L0 client command
         retval = ksnCommandCheck(ke->kc->kco, rds);
-    }
-    // Wrong command
-    else {
-
+    } else {
         #ifdef DEBUG_KSNET
         ksn_printf(ke, MODULE, DEBUG_VV,
             "%s" "got wrong command No %d from %s client with %d bytes data, "
             "the command skipped ...%s\n",
             ANSI_RED,
-            data->cmd, data->from, data->data_length,
+            data->cmd, data->payload, data->data_length,
             ANSI_NONE);
         #endif
     }
@@ -1358,7 +1360,7 @@ int cmd_l0_to_cb(ksnetEvMgrClass *ke, ksnCorePacketData *rd) {
     ksn_printf(ke, MODULE, extendedLog(ke->kl),
         "got command No %d for \"%s\" L0 client from peer \"%s\" "
         "with %d bytes data\n",
-        data->cmd, data->from, rd->from, data->data_length);
+        data->cmd, data->payload, rd->from, data->data_length);
     #endif
 
     // Got packet from peer statistic
@@ -1367,7 +1369,7 @@ int cmd_l0_to_cb(ksnetEvMgrClass *ke, ksnCorePacketData *rd) {
     // If l0 module is initialized
     if(ke->kl) {
 
-        int fd = ksnLNullClientIsConnected(ke->kl, data->from);
+        int fd = ksnLNullClientIsConnected(ke->kl, data->payload);
         if (fd) {
 
             // Create L0 packet
@@ -1376,14 +1378,12 @@ int cmd_l0_to_cb(ksnetEvMgrClass *ke, ksnCorePacketData *rd) {
             char *out_data = malloc(out_data_len);
             memset(out_data, 0, out_data_len);
             size_t packet_length = teoLNullPacketCreate(out_data, out_data_len,
-                    data->cmd, rd->from, (const uint8_t*)data->from + data->from_length,
+                    data->cmd, rd->from, (const uint8_t*)data->payload + data->client_name_length,
                     data->data_length);
 
             // Send command to L0 client
-            size_t snd;
-
-            //if((snd = write(*fd, out_data, packet_length)) >= 0);
-            if((snd = ksnLNullPacketSend(ke->kl, fd, out_data, packet_length)) >= 0);
+            ssize_t snd = ksnLNullPacketSend(ke->kl, fd, out_data, packet_length);
+            (void)snd;
 
             #ifdef DEBUG_KSNET
             teoLNullCPacket *packet = (teoLNullCPacket *)out_data;
@@ -1391,7 +1391,7 @@ int cmd_l0_to_cb(ksnetEvMgrClass *ke, ksnCorePacketData *rd) {
             ksn_printf(ke, MODULE, DEBUG_VV,
                 "send %d bytes to \"%s\" L0 client: %d bytes data, "
                 "from peer \"%s\"\n",
-                (int)snd, data->from,
+                (int)snd, data->payload,
                 packet->data_length, packet->peer_name);
             #endif
             free(out_data);
@@ -1403,7 +1403,7 @@ int cmd_l0_to_cb(ksnetEvMgrClass *ke, ksnCorePacketData *rd) {
             #ifdef DEBUG_KSNET
             ksn_printf(ke, MODULE, DEBUG_VV,
                 "%s" "the \"%s\" L0 client has not connected to the server%s\n",
-                ANSI_RED, data->from, ANSI_NONE);
+                ANSI_RED, data->payload, ANSI_NONE);
             #endif
         }
     }
@@ -1413,7 +1413,7 @@ int cmd_l0_to_cb(ksnetEvMgrClass *ke, ksnCorePacketData *rd) {
         #ifdef DEBUG_KSNET
             ksn_printf(ke, MODULE, ERROR_M,
                 "can't resend command %d to L0 client \"%s\" from peer \"%s\": " "%s" "the L0 module has not been initialized at this host%s\n",
-                data->cmd, data->from, rd->from, ANSI_RED, ANSI_NONE);
+                data->cmd, data->payload, rd->from, ANSI_RED, ANSI_NONE);
         #endif
     }
 
@@ -1562,9 +1562,9 @@ static int json_parse(char *data, json_param *jp) {
  * @return
  */
 int cmd_l0_check_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     int retval = 0;
-    ksnetEvMgrClass *ke = (ksnetEvMgrClass*)(((ksnCoreClass*)kco->kc)->ke);
 
     // Parse request
     char *json_data_unesc = rd->data;
@@ -1585,7 +1585,7 @@ int cmd_l0_check_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
     int fd_old;
     if(jp.userId && (fd_old = ksnLNullClientIsConnected(kl, jp.userId))) {
         #ifdef DEBUG_KSNET
-        ksn_printf(kev, MODULE, DEBUG, "User with name(id): %s is already connected, fd: %d\n", jp.userId, fd_old);
+        ksn_printf(ke, MODULE, DEBUG, "User with name(id): %s is already connected, fd: %d\n", jp.userId, fd_old);
         #endif
 
         // Send 99 command to user
@@ -1602,8 +1602,7 @@ int cmd_l0_check_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
     // Authorize new user
     int fd = ksnLNullClientIsConnected(kl, jp.accessToken);
     if(fd) {
-        size_t vl;
-        ksnLNullData* kld = pblMapGet(kl->map, &fd, sizeof(fd), &vl);
+        ksnLNullData* kld = pblMapGet(kl->map, &fd, sizeof(fd), NULL);
         if(kld != NULL) {
 
             // Rename client
@@ -1611,8 +1610,7 @@ int cmd_l0_check_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
                 // Remove existing name
                 if(kld->name != NULL) {
-                    size_t vl;
-                    pblMapRemoveFree(kl->map_n, kld->name, kld->name_length, &vl);
+                    pblMapRemoveFree(kl->map_n, kld->name, kld->name_length, NULL);
                     free(kld->name);
                 }
                 // Set new name
@@ -1627,11 +1625,10 @@ int cmd_l0_check_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
             if (kld->name != NULL) {
                 #ifdef DEBUG_KSNET
-                ksn_printf(kev, MODULE, DEBUG,
+                ksn_printf(ke, MODULE, DEBUG,
                     "connection initialized, client name is: %s, ip: %s, (username: %s)\n",
                     kld->name, kld->t_addr, jp.username);
                 #endif
-                ksnetEvMgrClass *ke = (ksnetEvMgrClass*)kl->ke;
                 // Show connected message
                 // #ifdef DEBUG_KSNET
                 ksn_printf(ke, MODULE, CONNECT, "### 0001,%s,%s\n", kld->name, kld->t_addr);
@@ -1640,11 +1637,10 @@ int cmd_l0_check_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
             // Send Connected event to all subscribers
             if(kld->name != NULL && !strcmp(rd->from, TEO_AUTH)) {
-                _send_subscribe_event_connected(kev, kld->name, kld->name_length);
+                _send_subscribe_event_connected(ke, kld->name, kld->name_length);
             }
 
             // Create & Send websocket allow answer message
-            size_t snd;
             char *ALLOW = ksnet_formatMessage("{ \"name\": \"%s\", \"networks\": %s }",
                     kld->name ? kld->name : "", jp.networks ? jp.networks : "null");
             size_t ALLOW_len = strlen(ALLOW) + 1;
@@ -1658,7 +1654,8 @@ int cmd_l0_check_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
                 teoLNullPacketCreate(out_data, out_data_len,
                                      CMD_L0_AUTH, rd->from, (uint8_t *)ALLOW, ALLOW_len);
             // Send websocket allow message
-            if((snd = ksnLNullPacketSend(ke->kl, fd, out_data, packet_length)) >= 0);
+            ssize_t snd = ksnLNullPacketSend(ke->kl, fd, out_data, packet_length);
+            (void)snd;
             free(out_data);
             free(ALLOW);
         }
@@ -1681,10 +1678,11 @@ int cmd_l0_check_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  * @return
  */
 teonet_client_data_ar *ksnLNullClientsList(ksnLNullClass *kl) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
 
     teonet_client_data_ar *data_ar = NULL;
 
-    if(kl != NULL && kev->ksn_cfg.l0_allow_f && kl->fd) {
+    if(kl != NULL && ke->ksn_cfg.l0_allow_f && kl->fd) {
 
         uint32_t length = pblMapSize(kl->map);
         data_ar = malloc(sizeof(teonet_client_data_ar) +
@@ -1835,13 +1833,14 @@ static bool sendKEXResponse(ksnLNullClass *kl, ksnLNullData *kld, int fd) {
 static bool processKeyExchange(ksnLNullClass *kl, ksnLNullData *kld, int fd,
                                KeyExchangePayload_Common *kex,
                                size_t kex_length) {
-
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
+    (void)ke;
     if (kld->server_crypt == NULL) {
         // Create compatible encryption context
         size_t crypt_size = teoLNullEncryptionContextSize(kex->protocolId);
         if (crypt_size == 0) {
             #ifdef DEBUG_KSNET
-            ksn_printf(kev, MODULE, ERROR_M,
+            ksn_printf(ke, MODULE, ERROR_M,
                        "Invalid KEX from %s:%d - can't create ctx(%d); disconnecting\n",
                        kld->t_addr, kld->t_port, (int)kex->protocolId);
             #endif
@@ -1857,7 +1856,7 @@ static bool processKeyExchange(ksnLNullClass *kl, ksnLNullData *kld, int fd,
     if (!teoLNullKEXValidate(kld->server_crypt, kex, kex_length)) {
         #ifdef DEBUG_KSNET
         ksn_printf(
-            kev, MODULE, ERROR_M,
+            ke, MODULE, ERROR_M,
             "Invalid KEX from %s:%d - failed validation; disconnecting\n",
             kld->t_addr, kld->t_port);
         #endif
@@ -1868,7 +1867,7 @@ static bool processKeyExchange(ksnLNullClass *kl, ksnLNullData *kld, int fd,
     if (!teoLNullEncryptionContextApplyKEX(kld->server_crypt, kex,
                                            kex_length)) {
         #ifdef DEBUG_KSNET
-        ksn_printf(kev, MODULE, ERROR_M,
+        ksn_printf(ke, MODULE, ERROR_M,
                    "Invalid KEX from %s:%d - can't apply; disconnecting\n",
                    kld->t_addr, kld->t_port);
         #endif
@@ -1879,7 +1878,7 @@ static bool processKeyExchange(ksnLNullClass *kl, ksnLNullData *kld, int fd,
     kld->server_crypt->state = SESCRYPT_PENDING;
     if (!sendKEXResponse(kl, kld, fd)) {
         #ifdef DEBUG_KSNET
-        ksn_printf(kev, MODULE, ERROR_M,
+        ksn_printf(ke, MODULE, ERROR_M,
                    "Failed to send KEX response to %s:%d; disconnecting\n",
                    kld->t_addr, kld->t_port);
         #endif
@@ -1906,9 +1905,11 @@ static bool processKeyExchange(ksnLNullClass *kl, ksnLNullData *kld, int fd,
 static int processPacket(ksnLNullClass *kl, ksnLNullData *kld,
                       ksnCorePacketData *rd, trudpChannelData *tcd,
                       teoLNullCPacket *packet, const char *packet_kind) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
+
     const bool was_encrypted = teoLNullPacketIsEncrypted(packet);
     if (!teoLNullPacketDecrypt(kld->server_crypt, packet)) {
-        ksn_printf(kev, MODULE, ERROR_M,
+        ksn_printf(ke, MODULE, ERROR_M,
                    "teoLNullPacketDecrypt failed fd %d/ ctx %p\n", tcd->fd,
                    kld->server_crypt);
         return 0;
@@ -1925,7 +1926,7 @@ static int processPacket(ksnLNullClass *kl, ksnLNullData *kld,
         strcpy(hexdump, "(null)");
     }
     const char *str_enc = was_encrypted ? " encrypted" : "";
-    ksn_printf(kev, MODULE, extendedLog(kl),
+    ksn_printf(ke, MODULE, extendedLog(kl),
                "got %s%s trudp packet, from: %s:%d, fd: %d, "
                "cmd: %u, to peer: %s, data: %s\n",
                packet_kind, str_enc, rd->addr, rd->port, tcd->fd,
@@ -1943,9 +1944,9 @@ static int processPacket(ksnLNullClass *kl, ksnLNullData *kld,
     case 0: {
         if (packet->peer_name_length == 1 && !packet->peer_name[0] &&
             packet->data_length) {
-            uint8_t *data = teoLNullPacketGetPayload(packet);
+            uint8_t *l0_data = teoLNullPacketGetPayload(packet);
             KeyExchangePayload_Common *kex =
-                teoLNullKEXGetFromPayload(data, packet->data_length);
+                teoLNullKEXGetFromPayload(l0_data, packet->data_length);
             if (kex) {
                 // received client keys
                 // must be first time or exactly the same as previous
@@ -1959,7 +1960,7 @@ static int processPacket(ksnLNullClass *kl, ksnLNullData *kld,
                     char saltdump[62];
                     uint8_t *salt = kld->server_crypt->keys.sessionsalt.data;
                     dump_bytes(saltdump, sizeof(saltdump), salt, sizeof(salt));
-                    ksn_printf(kev, MODULE, DEBUG_VV,
+                    ksn_printf(ke, MODULE, DEBUG_VV,
                                "got valid kex from %s:%d salt %s state %d\n",
                                kld->t_addr, kld->t_port, saltdump,
                                kld->server_crypt->state);
@@ -1975,7 +1976,7 @@ static int processPacket(ksnLNullClass *kl, ksnLNullData *kld,
                         trudp_ChannelSendReset(tcd);
                     }
                 } else {
-                    ksn_printf(kev, MODULE, ERROR_M,
+                    ksn_printf(ke, MODULE, ERROR_M,
                                "got invalid login packet from %s:%d\n", 
                                kld->t_addr, kld->t_port);
                     // Failed. disconnect user
@@ -2014,8 +2015,9 @@ static int processPacket(ksnLNullClass *kl, ksnLNullData *kld,
  * @return
  */
 int ksnLNulltrudpCheckPaket(ksnLNullClass *kl, ksnCorePacketData *rd) {
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kl);
 
-    trudpChannelData *tcd = trudpGetChannelAddr(kev->kc->ku, rd->addr, rd->port, 0);
+    trudpChannelData *tcd = trudpGetChannelAddr(ke->kc->ku, rd->addr, rd->port, 0);
     if (tcd == NULL || tcd == (void *)-1) {
         return 1;
     }
@@ -2042,14 +2044,12 @@ int ksnLNulltrudpCheckPaket(ksnLNullClass *kl, ksnCorePacketData *rd) {
     ssize_t rc = recvCheck(tcd, rd->data, rd->data_len);
     if (rc == -3) {
         #ifdef DEBUG_KSNET
-        ksn_printf(kev, MODULE, DEBUG_VV,
-                    "WRONG UDP PACKET %d\n", rc
-        );
+        ksn_printf(ke, MODULE, DEBUG_VV, "WRONG UDP PACKET %d\n", rc);
         #endif
         return 1; // TODO: Check this return value (may be it should be 0)
     } else if (rc <= 0) {
         #ifdef DEBUG_KSNET
-        ksn_printf(kev, MODULE, DEBUG_VV,
+        ksn_printf(ke, MODULE, DEBUG_VV,
                     "Wait next part of large packet %d status = %d\n",
                     rd->data_len, rc
         );
@@ -2079,4 +2079,3 @@ teoLNullEncryptionContext *ksnLNullClientGetCrypto(ksnLNullClass *kl, int fd) {
     return (kld == NULL) ? NULL : kld->server_crypt;
 }
 
-#undef kev
diff --git a/src/modules/l0-server.h b/src/modules/l0-server.h
index ad88a1f59..cabb84bff 100644
--- a/src/modules/l0-server.h
+++ b/src/modules/l0-server.h
@@ -8,7 +8,10 @@
 #ifndef L0_SERVER_H
 #define	L0_SERVER_H
 
+#include <ev.h>
 #include <pbl.h>
+#include "modules/cque.h"
+#include "net_com.h"
 #include "subscribe.h"
 #include "teonet_l0_client.h"
 
@@ -16,36 +19,33 @@
  * L0 Server map data structure
  * 
  */
-typedef struct ksnLNullData {
+typedef struct ksnLNullData { // \TODO: will be renamed to teoL0Data
+    ev_io   w;                 ///< TCP Client watcher
+    char   *name;              ///< Clients name
+    size_t  name_length;       ///< Clients name length
+    void   *read_buffer;       ///< Pointer to saved buffer
+    size_t  read_buffer_ptr;   ///< Pointer in read buffer
+    size_t  read_buffer_size;  ///< Read buffer size
     
-    ev_io w;                  ///< TCP Client watcher
-    char *name;               ///< Clients name
-    size_t name_length;       ///< Clients name length
-    void *read_buffer;        ///< Pointer to saved buffer
-    size_t read_buffer_ptr;   ///< Pointer in read buffer
-    size_t read_buffer_size;  ///< Read buffer size
-    
-    char *t_addr;             ///< TR-UDP IP address
-    int t_port;               ///< TR-UDP port
-    int t_channel;            ///< TR-UDP channel
-    double last_time;
+    char   *t_addr;            ///< TR-UDP IP address
+    int     t_port;            ///< TR-UDP port
+    int     t_channel;         ///< TR-UDP channel
+    double  last_time;
 
-    teoLNullEncryptionContext *server_crypt;
+    teoLNullEncryptionContext *server_crypt; // \TODO: will be renamed to teoL0EncryptionContext
 } ksnLNullData;
 
 /**
  * ksnLNull Class structure definition
  */
-typedef struct  ksnLNullClass {
-    
-    void *ke;           ///< Pointer to ksnEvMgrClass
-    PblMap *map;        ///< Pointer to the L0 clients map (by fd)
-    PblMap *map_n;      ///< Pointer to the L0 FDs map (by name)
-    int fd;             ///< L0 TCP Server FD
-    ksnLNullSStat stat; ///< L0 server statistic
-    int fd_trudp;       ///< Last free TR-UDP L0 FD
-    ksnCQueClass *cque; ///< CQUe to check dead clients
-    
+typedef struct  ksnLNullClass { // \TODO: will be renamed to teoL0Class
+    void           *ke;         ///< Pointer to ksnEvMgrClass
+    PblMap         *map;        ///< Pointer to the L0 clients map (by fd)
+    PblMap         *map_n;      ///< Pointer to the L0 FDs map (by name)
+    int             fd;         ///< L0 TCP Server FD
+    ksnLNullSStat   stat;       ///< L0 server statistic
+    int             fd_trudp;   ///< Last free TR-UDP L0 FD
+    ksnCQueClass   *cque;       ///< CQUe to check dead clients
 } ksnLNullClass;
 
 #pragma pack(push)
@@ -55,13 +55,11 @@ typedef struct  ksnLNullClass {
  * L0 Server resend to peer packet data structure
  * 
  */        
-typedef struct ksnLNullSPacket {
-
-    uint8_t cmd; ///< Command
-    uint8_t from_length; ///< From client name length (include leading zero)
-    uint16_t data_length; ///< Packet data length
-    char from[]; ///< From client name (include leading zero) + packet data
-
+typedef struct ksnLNullSPacket { // \TODO: will be renamed to teoL0SPacket
+    uint8_t     cmd;                ///< Command number
+    uint8_t     client_name_length; ///< Client name length (includes null terminated)
+    uint16_t    data_length;        ///< Packet data length
+    char        payload[];          ///< Сlient name (includes null terminated) + packet data
 } ksnLNullSPacket;
 
 #pragma pack(pop)
diff --git a/src/modules/subscribe.h b/src/modules/subscribe.h
index cd86a7ef8..aaea395d3 100644
--- a/src/modules/subscribe.h
+++ b/src/modules/subscribe.h
@@ -31,8 +31,8 @@ typedef struct teoSScrListData {
     uint16_t ev; ///< Event (used when send data to subscriber)
     uint8_t cmd; ///< Command ID (used when send data to subscriber)
     uint8_t l0_f; ///< This is L0 client. The L0 server name added to the beginning of data
-    char addr[ARP_TABLE_IP_SIZE]; ///< L0 peer IP address
     int16_t port; ///< L0 peer port    
+    char addr[ARP_TABLE_IP_SIZE]; ///< L0 peer IP address
     char data[]; ///< Remote peer name in list or data in CMD_SUBSCRIBE_ANSWER
         
 } teoSScrListData;
diff --git a/src/modules/vpn.h b/src/modules/vpn.h
index 8939cb4f5..ef164c428 100644
--- a/src/modules/vpn.h
+++ b/src/modules/vpn.h
@@ -11,10 +11,10 @@
 #ifndef VPN_H
 #define	VPN_H
 
+#include <ev.h>
 #include <stdio.h>
 #include <pbl.h>
 
-#include "ev_mgr.h"
 
 /**
  * KSNet VPN Class data
diff --git a/src/net_arp.h b/src/net_arp.h
index d54f3fb1f..067bd0ecd 100644
--- a/src/net_arp.h
+++ b/src/net_arp.h
@@ -16,7 +16,6 @@
 
 #include <pbl.h>
 
-#include "net_core.h"
 #include "teonet_l0_client.h"
 
 /**
diff --git a/src/net_com.c b/src/net_com.c
index ea38090a3..ee70a5870 100644
--- a/src/net_com.c
+++ b/src/net_com.c
@@ -88,7 +88,7 @@ void ksnCommandDestroy(ksnCommandClass *kco) {
  */
 int ksnCommandCheck(ksnCommandClass *kco, ksnCorePacketData *rd) {
  
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     int processed = 0;
 
@@ -254,7 +254,7 @@ int ksnCommandCheck(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 void *ksnCommandEchoBuffer(ksnCommandClass *kco, void *data, size_t data_len, size_t *data_t_len) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
     double ct = ksnetEvMgrGetTime(ke);
     *data_t_len = data_len + sizeof(double);
     void *data_t = malloc(*data_t_len);
@@ -282,7 +282,7 @@ int ksnCommandSendCmdEcho(ksnCommandClass *kco, char *to, void *data, size_t dat
 
     ksnet_arp_data * arp = ksnCoreSendCmdto(kco->kc, to, CMD_ECHO, data_t, data_t_len);
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
     if(arp != NULL) {
         arp->last_triptime_send = ksnetEvMgrGetTime(ke);
     }
@@ -316,7 +316,7 @@ int ksnCommandSendCmdConnect(ksnCommandClass *kco, char *to, char *name,
     fillConnectData(data, &ptr, name, addr, port);
 
     // TODO: duplicate code
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "send CMD_CONNECT = %u to peer by name %s. (Connect to peer: %s, addr: %s:%d)\n",
@@ -345,7 +345,7 @@ int ksnCommandSendCmdConnectA(ksnCommandClass *kco, char *to_addr, uint32_t to_p
     char data[KSN_BUFFER_DB_SIZE];
     fillConnectData(data, &ptr, name, addr, port);
     // TODO: duplicate code
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "send CMD_CONNECT = %u to peer by address %s:%d. (Connect to peer: %s, addr: %s:%d)\n",
@@ -390,7 +390,7 @@ static int cmd_reset_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 static int cmd_echo_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_ECHO (cmd = %u) command, from %s (%s:%d)\n",
@@ -410,7 +410,7 @@ static int cmd_echo_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
 static int cmd_echo_unr_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_ECHO_UNR (cmd = %u) command, from %s (%s:%d)\n",
@@ -432,7 +432,7 @@ static int cmd_echo_unr_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 static int cmd_peers_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
     ksnetArpClass *arp_class = ARP_TABLE_CLASS(kco);
 
     #ifdef DEBUG_KSNET
@@ -478,7 +478,7 @@ static int cmd_peers_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 static int cmd_peers_num_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
     ksnetArpClass *arp_class = ARP_TABLE_CLASS(kco);
 
     #ifdef DEBUG_KSNET
@@ -528,7 +528,7 @@ static int cmd_peers_num_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 static int cmd_l0_clients_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_L0_CLIENTS (cmd = %u) command, from %s (%s:%d)\n",
@@ -565,7 +565,7 @@ static int cmd_l0_clients_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 static int cmd_l0_clients_n_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_L0_CLIENTS_N (cmd = %u) command, from %s (%s:%d)\n",
@@ -610,7 +610,7 @@ static int cmd_l0_clients_n_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 static int cmd_l0_info_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_L0_INFO (cmd = %u) command, from %s (%s:%d)\n",
@@ -657,7 +657,7 @@ static int cmd_l0_info_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 static int cmd_l0_stat_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_L0_STAT (cmd = %u) command, from %s (%s:%d)\n",
@@ -708,7 +708,7 @@ static int cmd_l0_stat_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 static int cmd_host_info_answer_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
     
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
     ksnetArpClass *arp_class = ARP_TABLE_CLASS(kco);
 
     const int not_json = rd->data_len && ((char*)rd->data)[0] != '{' && ((char*)rd->data)[rd->data_len-1] != '}';
@@ -760,7 +760,7 @@ static int cmd_host_info_answer_cb(ksnCommandClass *kco, ksnCorePacketData *rd)
  */
 static int cmd_host_info_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_HOST_INFO = %u command, from %s (%s:%d)\n",
@@ -846,7 +846,7 @@ static int cmd_host_info_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  * @return
  */
 static int cmd_get_public_ip_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_GET_PUBLIC_IP (cmd = %u) command, from %s (%s:%d)\n",
@@ -905,7 +905,7 @@ static int cmd_get_public_ip_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  * @return
  */
 static int cmd_trudp_info_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_TRUDP_INFO (cmd = %u) command, from %s (%s:%d)\n",
@@ -944,7 +944,7 @@ static int cmd_trudp_info_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 static int cmd_resend_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_RESEND (cmd = %u) command, from %s (%s:%d)\n",
@@ -987,7 +987,7 @@ static int cmd_resend_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 inline int cmd_reconnect_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_RECONNECT (cmd = %u) command, from %s (%s:%d)\n",
@@ -1006,7 +1006,7 @@ inline int cmd_reconnect_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 inline static int cmd_reconnect_answer_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_RECONNECT_ANSWER (cmd = %u) command, from %s (%s:%d)\n",
@@ -1025,7 +1025,7 @@ inline static int cmd_reconnect_answer_cb(ksnCommandClass *kco, ksnCorePacketDat
  */
 static int cmd_echo_answer_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
 
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_ECHO_ANSWER (cmd = %u) command, from %s (%s:%d)\n",
@@ -1129,7 +1129,7 @@ int send_cmd_connect_cb_b(ksnetArpClass *ka, char *peer_name,
  */
 static int cmd_connect_r_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
     ksnetArpClass *arp_class = ARP_TABLE_CLASS(kco);
 
     #ifdef DEBUG_KSNET
@@ -1226,7 +1226,7 @@ static void cmd_connect_cque_cb(uint32_t id, int type, void *data) {
  */
 static int cmd_connect_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
     
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
     ksnetArpClass *arp_class = ARP_TABLE_CLASS(kco);
 
     /**
@@ -1286,7 +1286,7 @@ static int cmd_connect_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 int cmd_disconnected_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
     ksnetArpClass *arp_class = ARP_TABLE_CLASS(kco);
 
     #ifdef DEBUG_KSNET
@@ -1338,7 +1338,7 @@ int cmd_disconnected_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
  */
 static int cmd_split_cb(ksnCommandClass *kco, ksnCorePacketData *rd) {
 
-    ksnetEvMgrClass *ke = EVENT_MANAGER_CLASS(kco);
+    ksnetEvMgrClass *ke = EVENT_MANAGER_OBJECT(kco);
     
     #ifdef DEBUG_KSNET
     ksn_printf(ke, MODULE, DEBUG_VV, "process CMD_SPLIT (cmd = %u) command, from %s (%s:%d)\n",
diff --git a/src/net_com.h b/src/net_com.h
index 1bf9c98ce..006763504 100644
--- a/src/net_com.h
+++ b/src/net_com.h
@@ -13,6 +13,10 @@
 
 //#include "net_recon.h"
 
+
+#include "net_arp.h"
+#include "teonet_l0_client.h"
+#include <stdint.h>
 enum ksnCMD {
 
     // Core level not TR-UDP mode: 0...63
diff --git a/src/net_core.c b/src/net_core.c
index d8d575c45..e18f0a3e6 100644
--- a/src/net_core.c
+++ b/src/net_core.c
@@ -430,22 +430,22 @@ ksnet_arp_data *ksnCoreSendCmdto(ksnCoreClass *kc, char *to, uint8_t cmd,
                 "send command to L0 client \"%s\" to r-host\n", to);
         #endif
 
-        ssize_t snd;
-        ksnLNullSPacket *cmd_l0_data = data;
+        ksnLNullSPacket *spacket = data;
 
         const size_t buf_length = teoLNullBufferSize(
-                cmd_l0_data->from_length,
-                cmd_l0_data->data_length
+                spacket->client_name_length,
+                spacket->data_length
         );
 
         char *buf = malloc(buf_length);
         teoLNullPacketCreate(buf, buf_length,
-                cmd_l0_data->cmd,
-                cmd_l0_data->from,
-                (uint8_t *)cmd_l0_data->from + cmd_l0_data->from_length,
-                (size_t)cmd_l0_data->data_length);
+                spacket->cmd,
+                spacket->payload,
+                (uint8_t *)spacket->payload + spacket->client_name_length,
+                (size_t)spacket->data_length);
 
-        if((snd = ksnLNullPacketSend(ke->kl, fd, buf, buf_length)) >= 0);
+        ssize_t snd = ksnLNullPacketSend(ke->kl, fd, buf, buf_length);
+        (void)snd;
         free(buf);
     }
 
diff --git a/src/teonet.hpp b/src/teonet.hpp
index dd8248ed5..03357a289 100644
--- a/src/teonet.hpp
+++ b/src/teonet.hpp
@@ -135,7 +135,8 @@ class Teonet {
     ke = ksnetEvMgrInitPort(
         argc, argv,
         [](ksnetEvMgrClass* ke, teoEvents e, void* data, size_t data_len, void* user_data) {
-          ((Teonet*)ke->teo_class)->eventCb(e, data, data_len, user_data);
+          auto teonet_ptr = static_cast<Teonet*>(ke->teo_class);
+          teonet_ptr->eventCb(e, data, data_len, user_data);
         },
         options, port, user_data);
     if(ke) ke->teo_class = this;
@@ -587,7 +588,7 @@ class Teonet {
     ksnCQueClass* kq;
 
   public:
-    CQue(Teonet* t, bool send_event = false)
+    explicit CQue(Teonet* t, bool send_event = false)
         : teo(t), kq(ksnCQueInit(t->getKe(), send_event)) { /*std::cout << "CQue::CQue\n";*/
     }
     CQue(const CQue& obj) : teo(obj.teo), kq(obj.kq) { /*std::cout << "CQue::CQue copy\n";*/
@@ -615,7 +616,7 @@ class Teonet {
       userData* ud = new userData{user_data, cb};
       return ksnCQueAdd(kq,
                         [](uint32_t id, int type, void* data) {
-                          userData* ud = (userData*)data;
+                          userData* ud = static_cast<userData*>(data);
                           ud->cb(id, type, ud->user_data);
                           delete(ud);
                         },
@@ -697,7 +698,7 @@ class Teonet {
         void* user_data;
         void* cb;
       };
-      auto ud = (userData*)ksnCQueGetData(kq, id);
+      auto ud = static_cast<userData*>(ksnCQueGetData(kq, id));
       if(ud) {
         ud->user_data = data;
         retval = 0;
@@ -844,9 +845,9 @@ class Teonet {
       auto ud = new userData{user_data, cb};
       auto cq = cque.add(
           [](uint32_t id, int type, void* data) {
-            userData* ud = (userData*)data;
+            userData* ud = static_cast<userData*>(data);
             ud->cb(id, type, ud->user_data);
-            delete((TeoDB::teoDbCQueData*)ud->user_data);
+            delete(static_cast<TeoDB::teoDbCQueData*>(ud->user_data));
             delete(ud);
           },
           timeout, ud);
@@ -934,8 +935,8 @@ class Teonet {
     Teonet& teo;
 
   public:
-    LogReader(Teonet& teo) : teo(teo) {}
-    LogReader(Teonet* teo) : teo(*teo) {}
+    explicit LogReader(Teonet& teo) : teo(teo) {}
+    explicit LogReader(Teonet* teo) : teo(*teo) {}
 
     struct PUserData {
       virtual ~PUserData() { std::cout << "~PUserData" << std::endl; }
@@ -946,19 +947,20 @@ class Teonet {
                          const AnyCallback& cb = nullptr) const {
       struct UserData : PUserData {
         AnyCallback cb;
-        UserData(const AnyCallback& cb) : cb(cb) {}
+        explicit UserData(const AnyCallback& cb) : cb(cb) {}
         virtual ~UserData() { std::cout << "~UserData" << std::endl; }
       };
       auto ud = new UserData(cb);
       return teoLogReaderOpenCbPP(teo.getKe()->lr, name, file_name, flags,
                                   [](void* data, size_t data_length, Watcher* wd) {
-                                    ((UserData*)wd->user_data)->cb(data, data_length, wd);
+                                    auto ud = static_cast<UserData*>(wd->user_data);
+                                    ud->cb(data, data_length, wd);
                                   },
                                   ud);
     }
 
     inline int close(Watcher* wd) const {
-      if(wd->user_data) delete(PUserData*)wd->user_data;
+      if(wd->user_data) delete static_cast<PUserData*>(wd->user_data);
       return teoLogReaderClose(wd);
     }
   };
@@ -988,7 +990,7 @@ struct HostInfo {
     }
   }
 
-  HostInfo(void* data) {
+  explicit HostInfo(void* data) {
     auto host_info = (host_info_data*)data;
     makeTeonetVersion(host_info->ver);
     size_t ptr = 0;
@@ -1032,21 +1034,21 @@ class StringArray {
   }
 
   // Split from const char* constructor
-  StringArray(const char* str, const char* separators = ",", bool with_empty = true,
+  explicit StringArray(const char* str, const char* separators = ",", bool with_empty = true,
               int max_parts = 0) {
     // std::cout << "Split from const char* constructor" << std::endl;
     sa = split(str, separators, with_empty, max_parts);
   }
 
   // Split from std::string constructor
-  StringArray(const std::string& str, const std::string& separators = ",", bool with_empty = true,
+  explicit StringArray(const std::string& str, const std::string& separators = ",", bool with_empty = true,
               int max_parts = 0)
       : StringArray(str.c_str(), separators.c_str(), with_empty, max_parts) {
     // std::cout << "Split from std::string constructor" << std::endl;
   }
 
   // Combine from std::vector constructor
-  StringArray(const std::vector<const char*>& vstr, const char* separators = ",") {
+  explicit StringArray(const std::vector<const char*>& vstr, const char* separators = ",") {
     // std::cout << "Combine from std::vector constructor" << std::endl;
     sa = create();
     sep = separators;
diff --git a/src/utils/utils.c b/src/utils/utils.c
index e03f5d560..33d1f055d 100644
--- a/src/utils/utils.c
+++ b/src/utils/utils.c
@@ -21,6 +21,7 @@
 #include "utils.h"
 #include "ev_mgr.h"
 
+
 #define ADDRSTRLEN 128
 
 //double ksnetEvMgrGetTime(void *ke);