CMakeLists.txt

@@ -2,7 +2,7 @@ project(cellframe-sdk C)
 cmake_minimum_required(VERSION 2.8)
 
 set(CMAKE_C_STANDARD 11)
-set(CELLFRAME_SDK_NATIVE_VERSION "2.6-40")
+set(CELLFRAME_SDK_NATIVE_VERSION "2.6-41")
 add_definitions ("-DCELLFRAME_SDK_VERSION=\"${CELLFRAME_SDK_NATIVE_VERSION}\"")
 
 set(DAPSDK_MODULES "")

dap-sdk/net/core/dap_server.c

@@ -178,6 +178,8 @@ dap_server_t* dap_server_new(dap_events_t *a_events, const char * a_addr, uint16
         l_callbacks.error_callback = a_callbacks->error_callback;
     }
 
+// if we have poll exclusive
+#if defined(DAP_EVENTS_CAPS_EPOLL)
     for(size_t l_worker_id = 0; l_worker_id < dap_events_worker_get_count() ; l_worker_id++){
         dap_worker_t *l_w = dap_events_worker_get(l_worker_id);
         assert(l_w);
@@ -200,6 +202,24 @@ dap_server_t* dap_server_new(dap_events_t *a_events, const char * a_addr, uint16
             return NULL;
         }
     }
+#else
+    // or not
+    dap_worker_t *l_w = dap_events_worker_get_auto();
+    assert(l_w);
+    dap_events_socket_t * l_es = dap_events_socket_wrap2( l_server, a_events, l_server->socket_listener, &l_callbacks);
+    if (l_es) {
+        l_server->es_listeners = dap_list_append(l_server->es_listeners, l_es);
+        l_es->type = l_server->type == DAP_SERVER_TCP ? DESCRIPTOR_TYPE_SOCKET_LISTENING : DESCRIPTOR_TYPE_SOCKET_UDP;
+        l_es->_inheritor = l_server;
+        pthread_mutex_lock(&l_server->started_mutex);
+        dap_worker_add_events_socket( l_es, l_w );
+        pthread_cond_wait(&l_server->started_cond, &l_server->started_mutex);
+        pthread_mutex_unlock(&l_server->started_mutex);
+    } else{
+        log_it(L_WARNING, "Can't wrap event socket for %s:%u server", a_addr, a_port);
+        return NULL;
+    }
+#endif
     return  l_server;
 }
 

dap-sdk/net/core/dap_worker.c

@@ -185,37 +185,24 @@ void *dap_worker_thread(void *arg)
 
             int l_sock_err = 0, l_sock_err_size = sizeof(l_sock_err);
             //connection already closed (EPOLLHUP - shutdown has been made in both directions)
-            if( l_flag_hup) {
+            if( l_flag_hup || l_flag_rdhup) {
                 switch (l_cur->type ){
-                    case DESCRIPTOR_TYPE_SOCKET_LISTENING:
+                case DESCRIPTOR_TYPE_SOCKET_UDP:
                     case DESCRIPTOR_TYPE_SOCKET:
                         getsockopt(l_cur->socket, SOL_SOCKET, SO_ERROR, (void *)&l_sock_err, (socklen_t *)&l_sock_err_size);
                         if (l_sock_err) {
-                            dap_events_socket_set_readable_unsafe(l_cur, false);
                             dap_events_socket_set_writable_unsafe(l_cur, false);
                             l_cur->buf_out_size = 0;
                             l_cur->flags |= DAP_SOCK_SIGNAL_CLOSE;
-                            l_flag_error = l_flag_read = l_flag_write = false;
+                            l_flag_error = l_flag_write = false;
                             l_cur->callbacks.error_callback(l_cur, l_sock_err); // Call callback to process error event
                             log_it(L_INFO, "Socket shutdown (EPOLLHUP): %s", strerror(l_sock_err));
                         }
                     break;
-                    default: log_it(L_WARNING, "Unimplemented EPOLLHUP for socket type %d", l_cur->type);
-                }
-            }
-
-            if (l_flag_rdhup ){ // Lets think thats disconnected state
-                switch (l_cur->type ){
-                    case DESCRIPTOR_TYPE_SOCKET:
-                    case DESCRIPTOR_TYPE_SOCKET_UDP:
-                        l_cur->flags |= DAP_SOCK_SIGNAL_CLOSE;
-                    break;
-                    default:{
+                    default:
                         if(s_debug_reactor)
                             log_it(L_INFO,"RDHUP event on esocket %p (%d) type %d", l_cur, l_cur->socket, l_cur->type );
-                    }
                 }
-                //l_cur->callbacks.error_callback(l_cur, l_sock_err); // Call callback to process error event
             }
 
             if(l_flag_nval ){