Merge remote-tracking branch 'origin/CrossPlatformDev' into CrossPlatformDev

CMakeLists.txt

@@ -32,6 +32,8 @@ set(CMAKE_CXX_STANDARD 11)
 option(BUILD_TESTING "Build the project test case." OFF)
 option(INSTALL_INCLUDE_FILES "Enable installation of include header file or third_party" ON)
 
+set(SIMULATE_DEV_AND_TEST_TEMP ON)
+
 # 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/addin/cmake/ )
 include(CheckStructHasMember)
@@ -82,24 +84,30 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 
+if(MSVC)
+set(LIB_PREFIX "")
+set(LIB_SUFFIX ".dll")
+set(ROOT_INI_NAME "root.ini.win32")
+else()
+set(LIB_PREFIX "lib")
+set(LIB_SUFFIX ".so")
+set(ROOT_INI_NAME "root.ini.unix")
+endif(MSVC)
 
+if(SIMULATE_DEV_AND_TEST_TEMP)
 # simulate the real executive path environment, for debug easily.
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/run/version/1.2.3.4/bin")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
 file(MAKE_DIRECTORY  ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
 file(MAKE_DIRECTORY  "${CMAKE_BINARY_DIR}/run/hardwarecfg")
 file(MAKE_DIRECTORY  "${CMAKE_BINARY_DIR}/run/version/1.2.3.4/cfg")
 file(MAKE_DIRECTORY  "${CMAKE_BINARY_DIR}/run/version/1.2.3.4/mod")
-if(MSVC)
-	set(ROOT_INI_NAME "root.ini.win32")
-else()
-	set(ROOT_INI_NAME "root.ini.unix")
-endif(MSVC)
 file(COPY "${CMAKE_SOURCE_DIR}/addin/hardwarecfg/${ROOT_INI_NAME}" DESTINATION "${CMAKE_BINARY_DIR}/run/hardwarecfg")
 file(RENAME "${CMAKE_BINARY_DIR}/run/hardwarecfg/${ROOT_INI_NAME}" "${CMAKE_BINARY_DIR}/run/hardwarecfg/root.ini")
 file(GLOB SIMU_CONFIG_FILE "${CMAKE_SOURCE_DIR}/addin/cfg/*.ini")
 file(COPY ${SIMU_CONFIG_FILE} DESTINATION "${CMAKE_BINARY_DIR}/run/version/1.2.3.4/cfg")
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/addin/cfg/shell.ini.in" "${CMAKE_BINARY_DIR}/run/version/1.2.3.4/cfg/shell.ini" @ONLY)
-#end simulate
+endif(SIMULATE_DEV_AND_TEST_TEMP)#end simulate
 
 if(BUILD_TESTING)
 	include(CTest)

Common/AutoArray.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #ifndef _WIN32
+#include <assert.h>
 #define _ASSERT assert
 #include <winpr/interlocked.h>
 #else

Common/SpBase.h

@@ -39,7 +39,7 @@
 #ifdef _WIN32
 #include<wtypes.h>
 #else
-#include <winpr/wtypes.h>
+#include <winpr/library.h>
 #include <winpr/synch.h>
 #endif // _WIN32
 

Common/SpSecureClient.h

@@ -20,11 +20,11 @@ struct ENTITY_CONNECT_INFO;
 
 enum RvcCommStateEnum : DWORD
 {
-	CS_Stop = 0,		// 停止状态
-	CS_Connectting,	// 连接中
+	CS_Stop = 0,		    // 停止状态
+	CS_Connectting,	    // 连接中
 	CS_Fail,					// 连接失败
 	CS_Connected,		// 连接建立
-	CS_Break,				// 异常中断
+	CS_Break,				    // 异常中断
 };
 
 class SPBASE_API SpSecureClient : public CSecureClientBase

RVCComm/CMakeLists.txt

@@ -45,7 +45,7 @@ target_compile_definitions(${MODULE_NAME} PRIVATE "-DRVCCOMM_EXPORTS=1")
 
 if (BUILD_TESTING)
 	add_library(${MODULE_NAME}_a STATIC ${${MODULE_PREFIX}_SRCS})
-	target_link_libraries(${MODULE_NAME}_a ssl)
+	target_link_libraries(${MODULE_NAME}_a ssl winpr)
 	target_compile_definitions(${MODULE_NAME}_a PRIVATE "-DRVCCOMM_LINKED_AS_STATIC_LIBRARY")
 	add_subdirectory(test)
 endif()

addin/cfg/shell.ini.in

@@ -4,8 +4,8 @@ SoftwareVersion=@RVC_FRAMEWORK_VERSION@
 [Entity]
 
 ;ÆäËû
-HelloClient=0,mod_helloclient.dll,0x901
-HelloService=0,mod_helloservice.dll,0x902
+HelloClient=0,@LIB_PREFIX@mod_helloclient@LIB_SUFFIX@,0x901
+HelloService=0,@LIB_PREFIX@mod_helloservice@LIB_SUFFIX@,0x902
 
 [Startup]
 Number=2

libtoolkit/bus-unix.c

@@ -39,6 +39,8 @@ struct bus_endpt_t {
 		SOCKET sock_handle;
 	};
 	char* url;
+	/*define here or iom_t area, this is definitely a problem for now.*/
+	evtpoll_t* ep;
 	bus_endpt_callback callback;
 	struct list_head msg_list;
 	spinlock_t msg_lock;
@@ -48,6 +50,7 @@ struct bus_endpt_t {
 	OVERLAPPED rx_overlapped;
 	int rx_pending;
 	int rx_pending_pkt_len;
+	int rx_pending_pkt_uc_len;
 	iobuffer_queue_t* rx_buf_queue;
 	volatile int quit_flag;
 };
@@ -151,7 +154,7 @@ static int tcp_send_buf(bus_endpt_t* endpt, const char* buf, int n)
 {
 	DWORD left = n;
 	DWORD offset = 0;
-
+	WLog_DBG(TAG, "fd(%d): tcp send buf len: %d", endpt->sock_handle, n);
 	while (left > 0) {
 		BOOL ret;
 		WSABUF wsabuf;
@@ -165,7 +168,7 @@ static int tcp_send_buf(bus_endpt_t* endpt, const char* buf, int n)
 		ret = FALSE;
 		n = _send(endpt->sock_handle, wsabuf.buf, wsabuf.len, 0);
 		if (n == -1) {
-			if (WSAGetLastError() == WSAEWOULDBLOCK) {
+			if (errno == EAGAIN || errno == EWOULDBLOCK) {
 				fd_set wfds;
 				struct timeval tv;
 				int retval;
@@ -184,8 +187,7 @@ static int tcp_send_buf(bus_endpt_t* endpt, const char* buf, int n)
 						ret = TRUE;
 						dwBytesTransfer = n;
 					}
-				}
-				else {
+				} else {
 					WLog_WARN(TAG, "write timeout");
 					ret = TRUE;
 					dwBytesTransfer = 0;
@@ -297,19 +299,11 @@ static int tcp_recv_buf(bus_endpt_t* endpt, char* buf, DWORD n)
 
 	while (left > 0) {
 		BOOL ret;
-		DWORD dwFlags = 0;
-		WSABUF wsabuf;
 		DWORD dwBytesTransfer;
-		OVERLAPPED overlapped;
-		memset(&overlapped, 0, sizeof(overlapped));
-		overlapped.hEvent = endpt->rx_evt;
-		wsabuf.buf = buf + offset;
-		wsabuf.len = left;
-		ResetEvent(overlapped.hEvent);
 		ret = FALSE;
-		n = _recv(endpt->sock_handle, wsabuf.buf, wsabuf.len, 0);
+		n = _recv(endpt->sock_handle, buf + offset, left, 0);
 		if (n == -1) {
-			if (WSAGetLastError() == WSAEWOULDBLOCK) {
+			if (errno == EAGAIN || errno == EWOULDBLOCK) {
 				fd_set rfds;
 				struct timeval tv;
 				int retval;
@@ -323,7 +317,7 @@ static int tcp_recv_buf(bus_endpt_t* endpt, char* buf, DWORD n)
 				}
 				else if (retval && FD_ISSET(endpt->sock_handle, &rfds) > 0) {
 					WLog_INFO(TAG, "can read");
-					n = _recv(endpt->sock_handle, wsabuf.buf, wsabuf.len, 0);
+					n = _recv(endpt->sock_handle, buf + offset, left, 0);
 					if (n >= 0) {
 						ret = TRUE;
 						dwBytesTransfer = n;
@@ -349,10 +343,11 @@ static int tcp_recv_buf(bus_endpt_t* endpt, char* buf, DWORD n)
 			return -1;
 		}
 	}
-
+	WLog_DBG(TAG, "fd(%d): tcp recv buf len:%d", endpt->sock_handle, n);
 	return 0;
 }
 
+/*read data block, n is the dream length of data to read which will store in buf*/
 static int recv_buf(bus_endpt_t* endpt, char* buf, DWORD n)
 {
 	if (endpt->type == TYPE_PIPE) {
@@ -398,8 +393,11 @@ static int start_read_pkt(bus_endpt_t* endpt, iobuffer_t** p_pkt)
 	WLog_DBG(TAG, "==> start_read_pkt");
 
 	ResetEvent(endpt->rx_evt);
-	memset(&endpt->rx_overlapped, 0, sizeof(OVERLAPPED));
+	/*we control it.*/
+	//memset(&endpt->rx_overlapped, 0, sizeof(OVERLAPPED));
+	//ioqueue_overlapped_set_mask(&endpt->rx_overlapped, sizeof(OVERLAPPED));
 	endpt->rx_overlapped.hEvent = endpt->rx_evt;
+	endpt->rx_pending_pkt_uc_len = 0;
 
 	if (endpt->type == TYPE_PIPE) {
 		ret = ReadFile(endpt->pipe_handle,
@@ -409,25 +407,24 @@ static int start_read_pkt(bus_endpt_t* endpt, iobuffer_t** p_pkt)
 			&endpt->rx_overlapped);
 	}
 	else if (endpt->type == TYPE_TCP) {
-		WSABUF wsabuf;
-		wsabuf.buf = (char*)&endpt->rx_pending_pkt_len;
-		wsabuf.len = 4;
-		ret = _recv(endpt->sock_handle, wsabuf.buf, wsabuf.len, 0);
+		ret = _recv(endpt->sock_handle, (char*)&endpt->rx_pending_pkt_len, 4, 0);
 	}
 	else {
 		return -1;
 	}
-
 	if (ret >= 0) {
 		dwBytesTransferred = ret;
+		endpt->rx_pending_pkt_uc_len = ret;
 		if (dwBytesTransferred == 0)
 			return -1;
 		if (dwBytesTransferred < 4) {
 			rc = recv_buf(endpt, (char*)&endpt->rx_pending_pkt_len + dwBytesTransferred, 4 - dwBytesTransferred);
-			if (rc < 0)
+			if (rc < 0) {
 				return rc;
+			}
 		}
 		pkt = iobuffer_create(0, endpt->rx_pending_pkt_len);
+		endpt->rx_pending_pkt_uc_len = 0;
 		if (endpt->rx_pending_pkt_len > 0) {
 			rc = recv_buf(endpt, iobuffer_data(pkt, 0), endpt->rx_pending_pkt_len);
 			if (rc < 0) {
@@ -437,16 +434,14 @@ static int start_read_pkt(bus_endpt_t* endpt, iobuffer_t** p_pkt)
 			iobuffer_push_count(pkt, endpt->rx_pending_pkt_len);
 		}
 		*p_pkt = pkt;
+		return 0;
 	}
-	else {
-		if (errno == EAGAIN) {
-			endpt->rx_pending = 1;
-		}
-		else {
-			return -1;
-		}
+	else if(errno == EAGAIN || errno == EWOULDBLOCK) {
+		WLog_DBG(TAG, "set rx pending flag.");
+		endpt->rx_pending = 1;
+		return 0;
 	}
-	return 0;
+	return -1;
 }
 
 static int read_left_pkt(bus_endpt_t* endpt, iobuffer_t** p_pkt)
@@ -455,25 +450,34 @@ static int read_left_pkt(bus_endpt_t* endpt, iobuffer_t** p_pkt)
 	int rc;
 	DWORD dwBytesTransferred;
 	iobuffer_t* pkt = NULL;
-
+	WLog_DBG(TAG, "==> fd(%d): read left pkt", endpt->sock_handle);
 	if (endpt->type == TYPE_PIPE) {
 		ret = GetOverlappedResult(endpt->pipe_handle, &endpt->rx_overlapped, &dwBytesTransferred, TRUE);
 	}
 	else if (endpt->type == TYPE_TCP) {
-		DWORD dwFlags = 0;
-		ret = WSAGetOverlappedResult(endpt->sock_handle, &endpt->rx_overlapped, &dwBytesTransferred, TRUE, &dwFlags);
+		do 
+		{
+			ret = _recv(endpt->sock_handle,
+				(char*)&endpt->rx_pending_pkt_len + endpt->rx_pending_pkt_uc_len,
+				4 - endpt->rx_pending_pkt_uc_len, 0);
+		} while (ret == -1 && errno == EINTR);
 	}
-
-	if (!ret || dwBytesTransferred == 0) {
-		DWORD dwError = GetLastError();
+	if (ret < 0) {
+		WLog_ERR(TAG, "<== fd(%d): read left pkt failed: ret %d, err: %s", endpt->sock_handle, ret, strerror(errno));
 		return -1;
 	}
+	else if(ret == 0) {
+		WLog_WARN(TAG, "<== fd(%d): peer socket close.", endpt->sock_handle);
+	}
+
 	if (dwBytesTransferred < 4) {
 		rc = recv_buf(endpt, (char*)&endpt->rx_pending_pkt_len + dwBytesTransferred, 4 - dwBytesTransferred);
 		if (rc < 0)
 			return rc;
 	}
+	/*the first 4 bytes indicates the length of content and then read the buffer content.*/
 	pkt = iobuffer_create(-1, endpt->rx_pending_pkt_len);
+	WLog_DBG(TAG, "after read pkt len, start to read pkt's content: %d", endpt->rx_pending_pkt_len);
 	rc = recv_buf(endpt, iobuffer_data(pkt, 0), endpt->rx_pending_pkt_len);
 	if (rc < 0) {
 		iobuffer_destroy(pkt);
@@ -532,17 +536,25 @@ TOOLKIT_API int bus_endpt_create(const char* url, int epid, const bus_endpt_call
 		endpt->sock_handle = create_socket_handle(uf.host, uf.port);
 		if (endpt->sock_handle == INVALID_SOCKET)
 			goto on_error;
+		WLog_INFO(TAG, "bus endpt socket fd: %d", endpt->sock_handle);
 	}
 	else if (_stricmp(uf.scheme, "pipe") == 0) {
 		endpt->type = TYPE_PIPE;
 		endpt->pipe_handle = create_pipe_handle(uf.host);
 		if (endpt->pipe_handle == INVALID_HANDLE_VALUE)
 			goto on_error;
+		WLog_INFO(TAG, "bus endpt pipe fd: %d", endpt->sock_handle);
 	}
 	else {
 		goto on_error;
 	}
 
+	endpt->ep = evtpoll_create();
+	if (!endpt->ep) {
+		WLog_ERR(TAG, "evtpoll create failed!");
+		goto on_error;
+	}
+
 	endpt->epid = epid;
 	endpt->tx_evt = CreateEventA(NULL, TRUE, FALSE, NULL);
 	endpt->rx_evt = CreateEventA(NULL, TRUE, FALSE, NULL);
@@ -565,7 +577,6 @@ TOOLKIT_API int bus_endpt_create(const char* url, int epid, const bus_endpt_call
 	rc = recv_pkt_raw(endpt, &ans_buf);
 	WLog_INFO(TAG, "recv_pkt_raw return %d", rc);
 	if (rc != 0) {
-		DWORD dwError = GetLastError();
 		goto on_error;
 	}
 	iobuffer_read(ans_buf, IOBUF_T_I4, &v, 0);
@@ -579,8 +590,17 @@ TOOLKIT_API int bus_endpt_create(const char* url, int epid, const bus_endpt_call
 	if (ans_buf)
 		iobuffer_destroy(ans_buf);
 
+	/* subscribe read event [3/27/2020 Gifur] */
+	ioqueue_overlapped_set_mask(&endpt->rx_overlapped, sizeof(OVERLAPPED));
+	if (evtpoll_attach(endpt->ep, endpt->sock_handle)) {
+		WLog_ERR(TAG, "epoll attch bus endpt failed.");
+		goto on_error;
+	}
+	if (evtpoll_subscribe(endpt->ep, EV_READ, endpt->sock_handle, &endpt->rx_overlapped, NULL)) {
+		WLog_ERR(TAG, "epoll subscribe bus endpt failed.");
+		goto on_error;
+	}
 	*p_endpt = endpt;
-
 	return 0;
 
 on_error:
@@ -661,6 +681,10 @@ on_error:
 		CloseHandle(endpt->rx_evt);
 	if (endpt->rx_buf_queue)
 		iobuffer_queue_destroy(endpt->rx_buf_queue);
+
+	assert(endpt->ep);
+	evtpoll_destroy(endpt->ep);
+
 	if (endpt->url)
 		free(endpt->url);
 	free(endpt);
@@ -679,65 +703,80 @@ static int bus_endpt_poll_internal(bus_endpt_t* endpt, int* result, int timeout)
 
 	// peek first packge type
 	if (iobuffer_queue_count(endpt->rx_buf_queue) > 0) {
-		iobuffer_t* pkt = iobuffer_queue_head(endpt->rx_buf_queue);
-		int pkt_type;
-		int read_state = iobuffer_get_read_state(pkt);
-		iobuffer_read(pkt, IOBUF_T_I4, &pkt_type, NULL);
-		iobuffer_restore_read_state(pkt, read_state);
-		*result = to_result(pkt_type);
-		if (*result == BUS_RESULT_UNKNOWN) {
-			WLog_ERR(TAG, "bug: unknown pkt type!");
-			return -1;
-		}
-		return 1;
+		pkt = iobuffer_queue_head(endpt->rx_buf_queue);
 	}
-
-	// no received package, try to receive one
-	if (!endpt->rx_pending) {
-		rc = start_read_pkt(endpt, &pkt);
-		if (rc < 0)
-			return rc;
-		if (pkt) {
-			WLog_ERR(TAG, "pkt has read");
-			rc = append_rx_pkt(endpt, pkt);
+	else {
+		// no received package, try to receive one
+		if (!endpt->rx_pending) {
+			rc = start_read_pkt(endpt, &pkt);
 			if (rc < 0) {
-				iobuffer_destroy(pkt);
-				return -1;
-			}
-		}
-		else {
-			WLog_ERR(TAG, "pending");
-		}
-	}
-
-	// if receive is pending, wait for send or receive complete event
-	if (!pkt) {
-		HANDLE hs[] = { endpt->msg_sem, endpt->rx_evt };
-		WLog_DBG(TAG, "wait msg sem or received event.");
-		ret = WaitForMultipleObjects(array_size(hs), &hs[0], FALSE, (DWORD)timeout);
-		if (ret == WAIT_TIMEOUT) {
-			return 0;
-		}
-		else if (ret == WAIT_OBJECT_0) {
-			*result = BUS_RESULT_MSG;			// indicate send package event
-			return 1;
-		}
-		else if (ret == WAIT_OBJECT_0 + 1) {
-			rc = read_left_pkt(endpt, &pkt);
-			if (rc < 0)
+				WLog_ERR(TAG, "start read pkt failed.");
 				return rc;
-
+			}
 			if (pkt) {
-				rc = append_rx_pkt(endpt, pkt);
+				WLog_INFO(TAG, "pkt has read");
+				rc = append_rx_pkt(endpt, pkt); // append pkt to rx_buf_queue
 				if (rc < 0) {
 					iobuffer_destroy(pkt);
 					return -1;
 				}
 			}
 		}
-	}
-	else {
-		WLog_ERR(TAG, "pkt has readed");
+		else {
+			WLog_ERR(TAG, "is pending now.");
+		}
+		// if receive is pending, wait for send or receive complete event
+		if (!pkt) {
+			WLog_DBG(TAG, "wait msg sem or received event. tiemout: %d", timeout);
+			{
+				int nfds;
+				int ret;
+				int i;
+				struct epoll_event events[MAX_EPOLL_EVENT];
+				struct epoll_event* pe;
+				nfds = epoll_wait(evtpoll_get_epoll_fd(endpt->ep) , events, MAX_EPOLL_EVENT, timeout);
+				if (nfds == 0) {
+					assert(timeout != -1);
+					WLog_DBG(TAG, "epoll wait timeout.");
+					return 0; //timeout
+				}
+				if (nfds == -1 && errno != EINTR) {
+					WLog_ERR(TAG, "epoll wait error: %s(%d)", strerror(errno), errno);
+					return -1;
+				}
+				WLog_DBG(TAG, "epoll wait return nfd: %d", nfds);
+				for (i = 0; i < nfds; ++i) {
+					void* io_ctx = NULL;
+					pe = events + i;
+					WLog_INFO(TAG, "loop events[%d]::fd(0x%08X) OUT:%d, IN:%d", i, pe->data.fd,
+						pe->events & EPOLLOUT ? 1 : 0, pe->events & EPOLLIN ? 1 : 0);
+					assert(pe->events & EPOLLIN);
+					ret = evtpoll_deal(endpt->ep, pe, &io_ctx);
+					if (ret > 0) {
+						assert(io_ctx);
+#if 1 //DEBUG
+						uint32_t io_type = ioqueue_overlapped_get_type(io_ctx);
+						assert(io_type == EV_BUS_ENDPOINT);
+#endif
+						{
+							rc = read_left_pkt(endpt, &pkt);
+							if (rc < 0)
+								return rc;
+							if (pkt) {
+								rc = append_rx_pkt(endpt, pkt);
+								if (rc < 0) {
+									iobuffer_destroy(pkt);
+									return -1;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		else {
+			WLog_ERR(TAG, "pkt has readed");
+		}
 	}
 
 	if (pkt) {
@@ -750,12 +789,9 @@ static int bus_endpt_poll_internal(bus_endpt_t* endpt, int* result, int timeout)
 			WLog_ERR(TAG, "bug: unknown pkt type!");
 			return -1;
 		}
+		return 1;
 	}
-	else {
-		return -1;
-	}
-
-	return 1;
+	return -1;
 }
 
 static int recv_until(bus_endpt_t* endpt, int type, iobuffer_t** p_ansbuf)
@@ -1145,6 +1181,7 @@ TOOLKIT_API int bus_endpt_poll(bus_endpt_t* endpt, int timeout)
 	iobuffer_t* pkt = NULL;
 
 	rc = bus_endpt_poll_internal(endpt, &result, timeout);
+	WLog_DBG(TAG, "bus endpt poll internal: %d, %d", rc, result);
 	if (rc > 0) {
 		if (result == BUS_RESULT_DATA) {
 			bus_endpt_recv_pkt(endpt, &epid, &type, &pkt);

libtoolkit/bus.h

@@ -43,6 +43,7 @@ typedef struct bus_endpt_callback {
 	void *user_data;
 }bus_endpt_callback;
 
+/*create bus_endpt object and sync {BUS_TYPE_ENDPT_REGISTER} messge.*/
 TOOLKIT_API int bus_endpt_create(const char *url, int epid, const bus_endpt_callback *callback, bus_endpt_t **p_endpt);
 TOOLKIT_API void bus_endpt_destroy(bus_endpt_t *endpt);
 TOOLKIT_API int bus_endpt_poll(bus_endpt_t *endpt, int timeout);

libtoolkit/bus_daemon-unix.c

@@ -37,7 +37,7 @@ struct endpt_session_t
 	};
 	CRITICAL_SECTION lock;
 	time_t start_time;
-	int err;
+	LONG err;
 	int rx_pending_pkt_len;
 	int type;
 	int tx_pending;
@@ -120,6 +120,7 @@ static void session_unlock(endpt_session_t *session)
 
 static void add_unregistered_list(endpt_session_t *session)
 {
+	WLog_DBG(TAG, "add session(%d) to unregistered_list", session->epid);
 	bus_daemon_t *daemon = session->daemon;
 	daemon_lock(daemon);
 	list_add_tail(&session->entry, &daemon->unregistered_session_list);
@@ -128,6 +129,7 @@ static void add_unregistered_list(endpt_session_t *session)
 
 static void remove_session_list(endpt_session_t *session)
 {
+	WLog_DBG(TAG, "remove session(%d) from register list", session->epid);
 	bus_daemon_t *daemon = session->daemon;
 	daemon_lock(daemon);
 	list_del(&session->entry);
@@ -142,11 +144,13 @@ static void remove_session_list(endpt_session_t *session)
 
 static void move_to_registered_session(endpt_session_t *session)
 {
+	WLog_DBG(TAG, "session(%d) move to registered list", session->epid);
 	bus_daemon_t *daemon = session->daemon;
 	daemon_lock(daemon);
 	{
 		endpt_session_t *pos, *n;
 		list_for_each_entry_safe(pos, n, &daemon->registered_session_list, endpt_session_t, entry) {
+			/*tell other session, a new member joins us ???*/
 			queue_sys_pkt(pos, session->epid, BUS_STATE_ON);
 		}
 	}
@@ -166,7 +170,6 @@ static endpt_session_t* create_session(daemon_accetpor_t *acceptor, int type, in
 {
 	int rc;
 	endpt_session_t *session;
-
 	session = ZALLOC_T(endpt_session_t);
 
 	if (type == TYPE_PIPE) {
@@ -237,7 +240,12 @@ static endpt_session_t *find_session(bus_daemon_t *daemon, int epid)
 		}
 	}
 	daemon_unlock(daemon);
-
+#ifndef NDEBUG
+	if (!session)
+		WLog_ERR(TAG, "find session failed.");
+	else
+		WLog_DBG(TAG, "find session.");
+#endif // !NDEBUG
 	return session;
 }
 
@@ -339,7 +347,7 @@ static int start_send_pkt(endpt_session_t *session, iobuffer_t **pkt)
 {
 	int rc = -1;
 	int v;
-
+	WLog_DBG(TAG, "==>session(%d) start send pkt(err=%d)", session->epid, session->err);
 	if (session->err < 0)
 		return rc;
 
@@ -347,7 +355,6 @@ static int start_send_pkt(endpt_session_t *session, iobuffer_t **pkt)
 	iobuffer_write_head(*pkt, IOBUF_T_I4, &v, 0);
 
 	endpt_session_inc_ref(session);
-
 	session->tx_pending_buf = *pkt;
 	*pkt = NULL;
 
@@ -370,6 +377,8 @@ static int start_send_pkt(endpt_session_t *session, iobuffer_t **pkt)
 	if (rc < 0) {
 		*pkt = session->tx_pending_buf;
 		endpt_session_dec_ref(session);
+
+		WLog_ERR(TAG, "session(%d) start_send_pkt failed: %d", session->epid, rc);
 	}
 
 	return rc;
@@ -378,9 +387,8 @@ static int start_send_pkt(endpt_session_t *session, iobuffer_t **pkt)
 static int queue_tx_pkt(endpt_session_t *session, iobuffer_t **pkt)
 {
 	int rc = -1;
-
 	session_lock(session);
-
+	WLog_DBG(TAG, "==>session(%d) queue_tx_pkt, pending: %d", session->epid, session->tx_pending);
 	if (session->tx_pending) {
 		iobuffer_queue_enqueue(session->tx_iobuf_queue, *pkt);
 		*pkt = NULL;
@@ -389,7 +397,6 @@ static int queue_tx_pkt(endpt_session_t *session, iobuffer_t **pkt)
 		session->tx_pending = 1;
 		rc = start_send_pkt(session, pkt);
 	}
-
 	session_unlock(session);
 
 	if (rc < 0) {
@@ -414,6 +421,7 @@ static iobuffer_t *make_ans_pkt(int rc)
 
 static int queue_ans_pkt(endpt_session_t *session, int rc)
 {
+	WLog_DBG(TAG, "session(%d) queue ans pkt rc=%d", session->epid, rc);
 	iobuffer_t *pkt = make_ans_pkt(rc);
 	int err = queue_tx_pkt(session, &pkt);
 	if (pkt) {
@@ -483,7 +491,7 @@ static int on_process_pkt(endpt_session_t *session, iobuffer_t **ppkt)
 	read_state = iobuffer_get_read_state(pkt);
 
 	iobuffer_read(pkt, IOBUF_T_I4, &type, 0);
-
+	WLog_DBG(TAG, "==> process pkt which type: 0x%08X", type);
 	if (session->registered) {
 		if (type == BUS_TYPE_ENDPT_UNREGISTER) {
 			move_to_unregistered_session(session);
@@ -603,7 +611,7 @@ static int on_process_pkt(endpt_session_t *session, iobuffer_t **ppkt)
 static void on_recv_body(endpt_session_t *session, unsigned int transfer_bytes, int err)
 {
 	int rc = -1;
-
+	WLog_DBG(TAG, "==> on_recv_body(err=%d)", err);
 	if (!err) {
 		iobuffer_t *pkt = session->rx_pending_buf;
 		session->rx_pending_buf = NULL;
@@ -615,14 +623,12 @@ static void on_recv_body(endpt_session_t *session, unsigned int transfer_bytes,
 		if (pkt)
 			iobuffer_dec_ref(pkt);
 	}
-
 	if (rc < 0) {
-		if (InterlockedCompareExchange((LONG*)&session->err, rc, 0) == 0) {
+		if (InterlockedCompareExchange(&session->err, rc, 0) == 0) {
 			remove_session_list(session);
 			endpt_session_dec_ref(session);
 		}
 	}
-
 	endpt_session_dec_ref(session);
 }
 
@@ -648,7 +654,7 @@ static void on_tcp_recv_body(ioqueue_tcpsock_t* tcpsock,
 static int session_start_recv_body(endpt_session_t *session)
 {
 	int rc = -1;
-
+	WLog_DBG(TAG, "==> session(%d) start recv body(err=%d)", session->epid, session->err);
 	if (session->err < 0)
 		return rc;
 
@@ -683,13 +689,13 @@ static int session_start_recv_body(endpt_session_t *session)
 static void on_recv_hdr(endpt_session_t *session, int err)
 {
 	int rc = -1;
-
+	WLog_DBG(TAG, "==> on_recv_hdr(err=%d)", err);
 	if (!err) {
 		rc = session_start_recv_body(session);
 	}
 
 	if (rc < 0) {
-		if (InterlockedCompareExchange((LONG*)&session->err, rc, 0) == 0) {
+		if (InterlockedCompareExchange(&session->err, rc, 0) == 0) {
 			remove_session_list(session);
 			endpt_session_dec_ref(session);
 		}
@@ -721,7 +727,7 @@ static void on_tcp_recv_hdr(ioqueue_tcpsock_t *tcpsock,
 static int session_start_recv_hdr(endpt_session_t *session)
 {
 	int rc = -1;
-
+	WLog_DBG(TAG, "==> session(%d) start recv hdr(err=%d)", session->epid, session->err);
 	if (session->err < 0)
 		return rc;
 
@@ -751,6 +757,7 @@ static int session_start_recv_hdr(endpt_session_t *session)
 
 static int on_msg(unsigned short msg_id, int param1, int param2)
 {
+	WLog_DBG(TAG, "==> on_msg(id=%d, param1=%d, param2=%d)", msg_id, param1, param2);
 	if (msg_id == MSG_REMOVE_REGISTAR) {
 		endpt_session_t *session = (endpt_session_t*)param1;
 		remove_session_list(session);
@@ -762,7 +769,7 @@ static int on_msg(unsigned short msg_id, int param1, int param2)
 static int on_accept(daemon_accetpor_t *dacceptor, void *user_data, int fd, int err)
 {
 	int idx = (int)user_data;
-
+	WLog_DBG(TAG, "==> on_accept(fd=%d, err=%d)", fd, err);
 	if (!err) {
 		endpt_session_t *session = create_session(dacceptor, dacceptor->type, fd);
 		if (session) {

libtoolkit/evtpoll.c

@@ -6,6 +6,7 @@
 #include "array.h"
 #include "refcnt.h"
 #include "evtpoll.h"
+#include "ioqueue.h"
 #include <winpr/wlog.h>
 #define TAG TOOLKIT_TAG("evtpoll")
 
@@ -188,25 +189,24 @@ static int evtpoll__ctl(evtpoll_t* ep, int event_mask, int ctrl_mod, int fd, voi
 {
 	int ret = -1;
 	struct epoll_event ee;
-	if (ep) {
-		ee.events = event_mask;
-		if (data) {
-			ee.data.ptr = data;
-		}
-		else {
-			ee.data.fd = fd;
-		}
-		ret = epoll_ctl(evtpoll_get_epoll_fd(ep), ctrl_mod, fd, &ee);
-		if (ret == -1) {
-			WLog_ERR(TAG, "epoll ctl failed: %s", strerror(errno));
-		}
-		else {
-			WLog_INFO(TAG, "fd(%d), epoll_ctl: OUT:%d, IN:%d, OTHERS:0x%08X, ADD:%d, MOD:%d, data:0x%X ret:%d",
-				fd,
-				(event_mask & EPOLLOUT) > 0 ? 1 : 0, (event_mask & EPOLLIN) > 0 ? 1 : 0,
-				(event_mask & ~(EPOLLOUT | EPOLLIN)),
-				ctrl_mod == EPOLL_CTL_ADD ? 1 : 0, ctrl_mod == EPOLL_CTL_MOD ? 1 : 0, data, ret);
-		}
+	assert(ep);
+	ee.events = event_mask;
+	if (data) {
+		ee.data.ptr = data;
+	}
+	else {//data is union type.
+		ee.data.fd = fd;
+	}
+	ret = epoll_ctl(evtpoll_get_epoll_fd(ep), ctrl_mod, fd, &ee);
+	if (ret == -1) {
+		WLog_ERR(TAG, "epoll ctl failed: %s", strerror(errno));
+	}
+	else {
+		WLog_INFO(TAG, "fd(%d), epoll_ctl: OUT:%d, IN:%d, OTHERS:0x%08X, ADD:%d, MOD:%d, data:0x%X ret:%d",
+			fd,
+			(event_mask & EPOLLOUT) > 0 ? 1 : 0, (event_mask & EPOLLIN) > 0 ? 1 : 0,
+			(event_mask & ~(EPOLLOUT | EPOLLIN)),
+			ctrl_mod == EPOLL_CTL_ADD ? 1 : 0, ctrl_mod == EPOLL_CTL_MOD ? 1 : 0, data, ret);
 	}
 	return ret;
 }
@@ -385,14 +385,15 @@ static int evtpoll__subscribe_precheck(evtpoll_interest_entry_t* entry, int exis
 			WLog_ERR(TAG, "the entry is still pending...");
 			return -1;
 		}
-		else if (entry->io == data) {
+		else if ((uintptr_t)entry->io == (uintptr_t)data) {
 			WLog_WARN(TAG, "entry already exists and seems same, return previously.");
 			return 0;
 		}
+		WLog_DBG(TAG, "io:0x%08X vs data:0x%08X", entry->io, data);
 	}
 	if (data != NULL) {
 		const int io_type = ioqueue_overlapped_get_type(data);
-		WLog_INFO(TAG, "epueue ov type for subscribing: 0x%X", io_type);
+		WLog_INFO(TAG, "ioqueue ov type for subscribing: 0x%X", io_type);
 	}
 	else if (!entry->io) {
 		WLog_ERR(TAG, "no io data for event!");
@@ -673,4 +674,37 @@ int evtpoll_deal(evtpoll_t* ep, struct epoll_event* event, void** p_io)
 	return -1;
 }
 
+int evtpoll_loop(evtpoll_t* ep, int timeout)
+{
+	int nfds;
+	int ret = -1;
+	int i;
+	struct epoll_event events[MAX_EPOLL_EVENT];
+	nfds = epoll_wait(ep->epfd, events, MAX_EPOLL_EVENT, timeout);
+	if (nfds == 0) {
+		assert(timeout != -1);
+		return 0; //timeout
+	}
+	if (nfds == -1) {
+		WLog_ERR(TAG, "epoll wait error: %s(%d)", strerror(errno), errno);
+		return -1;
+	}
+
+	for (i = 0; i < nfds; ++i) {
+		ioqueue_overlapped_t* io_ctx = NULL;
+		WLog_INFO(TAG, "loop events[%d] OUT:%d, IN:%d", i, events[i].events & EPOLLOUT ? 1 : 0, events[i].events & EPOLLIN ? 1 : 0);
+		ret = evtpoll_deal(ep, &events[i], &io_ctx);
+		if (ret > 0) {
+			assert(io_ctx);
+			assert(events[i].events & EPOLLIN);
+			uint32_t io_type = ioqueue_overlapped_get_mask(io_ctx);
+			if (io_type == EV_BUS_ENDPOINT) {
+				WLog_DBG(TAG, "set endpoint event!");
+				SetEvent(((OVERLAPPED*)io_ctx)->hEvent);
+			}
+		}
+	}
+	return ret;
+}
+
 #endif //NOT _WIN32

libtoolkit/evtpoll.h

@@ -13,9 +13,10 @@ level-triggered(LT): default
 
 #define MAX_EPOLL_EVENT 1024
 
-#define EV_READ EPOLLIN
-#define EV_ACCEPT EPOLLIN
-#define EV_WRITE EPOLLOUT
+/*event mask*/
+#define EV_READ			EPOLLIN
+#define EV_ACCEPT		EPOLLIN
+#define EV_WRITE		EPOLLOUT
 /*to disable the associated fd after the receipt of an event*/
 #define EV_READ_ONCE (EPOLLIN | EPOLLONESHOT)
 #define EV_WRITE_ONCE (EPOLLOUT | EPOLLONESHOT)
@@ -27,6 +28,8 @@ level-triggered(LT): default
 #define EV_INTEREST_ENTRY_OUT_IDX          1
 #define EV_INTEREST_ENTRY_ERR_IDX           2
 
+#define EV_BUS_ENDPOINT (((uint32_t)(1)) << 16)
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -49,6 +52,8 @@ extern "C" {
 
 	int evtpoll_unsubscribe(evtpoll_t* ep, int event_mask, int fd, int only_reset);
 
+	int evtpoll_loop(evtpoll_t* ep, int timeout);
+
 #ifdef __cplusplus
 } // extern "C" {
 #endif

libtoolkit/fileutil.c

@@ -17,6 +17,8 @@
 #include "fileutil.h"
 #include "strutil.h"
 
+#include <winpr/wlog.h>
+#define TAG TOOLKIT_TAG("fileutil")
 
 TOOLKIT_API BOOL CreateDirA(LPCSTR lpDirPath, BOOL bRecursive)
 {
@@ -689,11 +691,11 @@ void _splitpath(const char* path, char* drive, char* dir, char* fname, char* ext
 	}
 	
 	if (realpath(path, resolved_path) == NULL) {
-		fprintf(stderr, "realpath failed: %s\n", strerror(errno));
+		WLog_ERR(TAG, "realpath failed: %s", strerror(errno));
 		strcpy(resolved_path, path);
 	}
 	else {
-		printf("resolved_path: %s\n", resolved_path);
+		WLog_DBG(TAG, "resolved_path: %s", resolved_path);
 	}
 	len = strlen(resolved_path);
 	if (resolved_path[0] == '/') {

libtoolkit/ioqueue-unix.c

@@ -518,33 +518,31 @@ static int pre_dispatch_network(BOOL* ret, DWORD* dwBytesTransfer, ioqueue_overl
 			ioqueue_recvn_overlapped_t* overlapped = (ioqueue_recvn_overlapped_t*)io_ctx;
 			ioqueue_tcpsock_t* tcpsock = overlapped->base.handle_ctx;
 			n = 0;
-			for (; n < overlapped->wsabuf.len;) {
-				nread = read(tcpsock->u.sock, overlapped->wsabuf.buf + n, overlapped->wsabuf.len - n);
-				if (nread < 0) {
-					if (errno == EAGAIN) {
-						/* that means we have read all data. So go back to the main loop. */
-						nread = 0;
-					}
-					else if (errno == EINTR) {
-						continue;
-					}
-					else {
-						WLog_ERR(TAG, "read error: %d", errno);
-					}
-					break;
+			for (; n < overlapped->wsabuf.len;)
+			{
+				do  
+				{
+					nread = _recv(tcpsock->u.sock, overlapped->wsabuf.buf + n, overlapped->wsabuf.len - n, 0);
+				} while (nread < 0 && errno == EINTR);
+				if (nread > 0) {
+					n += nread;
+					continue;
 				}
-				else if (nread == 0) {
+				if (nread == 0) {
+					/*remote socket break*/
+					WLog_WARN(TAG, "remote socket exit.");
+				} else if (errno == EAGAIN || errno == EWOULDBLOCK) {
+					nread = 0;
+					break;
+				} else {
+					WLog_ERR(TAG, "read error: %s(%d)", strerror(errno), errno);
 					break;
 				}
-				else {
-					n += nread;
-				}
-			}
-			if (nread < 0) {
-				WLog_WARN(TAG, "read op occurs exception");
 			}
 			WLog_INFO(TAG, "<OV_RECVN>: total_recv: %d/%d, cur_recv: %d", n, overlapped->wsabuf.len, nread);
-			if (ret) *ret = nread < 0 ? FALSE : TRUE;
+			if (ret) {
+				*ret = (n == 0 && n <= nread) ? FALSE : TRUE;
+			}
 			if (dwBytesTransfer) *dwBytesTransfer = n;
 			err = 1;
 		}
@@ -630,6 +628,7 @@ static void dispatch_network(BOOL ret, DWORD dwBytesTransfer, ioqueue_overlapped
 							overlapped->base.ov.InternalHigh = 0;
 							overlapped->base.ov.Offset = 0;
 							overlapped->base.ov.OffsetHigh = 0;
+							ioqueue_overlapped_set_mask(io_ctx, sizeof(ioqueue_sendn_overlapped_t));
 							WLog_WARN(TAG, "OV_SENDN: Must be due with this situation %d < %d", overlapped->sended_bytes, overlapped->total_bytes);
 							evtpoll_subscribe(ioqueue_tcpsock_get_owned_ioqueue(tcpsock)->ep, EV_WRITE, tcpsock->u.sock, NULL, io_ctx);
 							//if (rc != 0 && WSAGetLastError() != WSA_IO_PENDING) {
@@ -673,6 +672,7 @@ static void dispatch_network(BOOL ret, DWORD dwBytesTransfer, ioqueue_overlapped
 								overlapped->base.ov.Offset = 0;
 								overlapped->base.ov.OffsetHigh = 0;
 								overlapped->dwFlags = 0;
+								ioqueue_overlapped_set_mask(io_ctx, sizeof(ioqueue_recvuntil_overlapped_t));
 								rc = WSARecv(handle_ctx->u.sock, &overlapped->wsabuf, 1, &bytesRead, &overlapped->dwFlags, 
 									&overlapped->base.ov, NULL);
 								if (rc != 0 && WSAGetLastError() != WSA_IO_PENDING) {
@@ -706,6 +706,7 @@ static void dispatch_network(BOOL ret, DWORD dwBytesTransfer, ioqueue_overlapped
 							overlapped->base.ov.Offset = 0;
 							overlapped->base.ov.OffsetHigh = 0;
 							overlapped->dwFlags = 0;
+							ioqueue_overlapped_set_mask(io_ctx, sizeof(ioqueue_recvn_overlapped_t));
 							WLog_WARN(TAG, "OV_RECVN: Must be due with this situation %d < %d", overlapped->recved_bytes, overlapped->total_bytes);
 							evtpoll_subscribe(ioqueue_tcpsock_get_owned_ioqueue(tcpsock)->ep,  EV_READ, tcpsock->u.sock, io_ctx, NULL);
 							//if (rc != 0 && WSAGetLastError() != WSA_IO_PENDING) {
@@ -753,6 +754,7 @@ static void dispatch_network(BOOL ret, DWORD dwBytesTransfer, ioqueue_overlapped
 							overlapped->base.ov.Offset += dwBytesTransfer;
 							if (overlapped->base.ov.Offset < dwBytesTransfer)
 								overlapped->base.ov.OffsetHigh += 1;
+							ioqueue_overlapped_set_mask(io_ctx, sizeof(ioqueue_readfilen_overlapped_t));
 							ret = ReadFile(handle_ctx->u.file, overlapped->buf+overlapped->recved_bytes, left, NULL, &overlapped->base.ov);
 							if (!ret && GetLastError() != ERROR_IO_PENDING) {
 								dec_pending_io(handle_ctx);
@@ -787,6 +789,7 @@ static void dispatch_network(BOOL ret, DWORD dwBytesTransfer, ioqueue_overlapped
 							overlapped->base.ov.Offset += dwBytesTransfer;
 							if (overlapped->base.ov.Offset < dwBytesTransfer)
 								overlapped->base.ov.OffsetHigh += 1;
+							ioqueue_overlapped_set_mask(io_ctx, sizeof(ioqueue_writefilen_overlapped_t));
 							ret = WriteFile(handle_ctx->u.file, overlapped->buf+overlapped->sended_bytes, left, NULL, &overlapped->base.ov);
 							if (!ret && GetLastError() != ERROR_IO_PENDING) {
 								dec_pending_io(handle_ctx);
@@ -928,6 +931,7 @@ TOOLKIT_API int ioqueue_poll(ioqueue_t* q, int timeout)
 	static int flag = 0;
 	bus_daemon_t* deamon;
 	struct epoll_event events[MAX_EPOLL_EVENT];
+	struct epoll_event* pe = NULL;
 	deamon = (bus_daemon_t*)ioqueue_get_user_data(ioq);
 	assert(deamon != NULL);
 	/* network and msg, dispatch until no events */
@@ -938,22 +942,22 @@ TOOLKIT_API int ioqueue_poll(ioqueue_t* q, int timeout)
 		//有时会出现惊群的问题！！
 		int epfd = evtpoll_get_epoll_fd(ioq->ep);
 		nfds = epoll_wait(epfd, events, MAX_EPOLL_EVENT, t ? 0 : timeout);
-		if ((nfds < 0 && EINTR != errno) || nfds == 0) {
+		if ((nfds < 0 && EINTR == errno) || nfds == 0) {
 			t = 0;
 		}
 		for (i = 0; i < nfds; ++i) {
 			int n = 1;
-			WLog_INFO(TAG, "poll events[%d] OUT:%d, IN:%d", i 
-				,events[i].events & EPOLLOUT ? 1: 0
-				,events[i].events & EPOLLIN ? 1: 0);
+			pe = events + i;
+			WLog_INFO(TAG, "poll events[%d]::fd(0x%08X) OUT:%d, IN:%d", i, pe->data.fd
+				, pe->events & EPOLLOUT ? 1: 0 ,pe->events & EPOLLIN ? 1: 0);
 
-			if (events[i].events & EPOLLOUT) {
+			if (pe->events & EPOLLOUT) {
 				flag = 1;
 			}
 
 			while (n >= 0) {
 				ioqueue_overlapped_t* io_ctx = NULL;
-				n = evtpoll_deal(ioq->ep, &events[i], &io_ctx);
+				n = evtpoll_deal(ioq->ep, pe, &io_ctx);
 				if (n > 0) {
 					assert(io_ctx);
 					pre_dispatch_network(&ret, &dwBytesTransfer, io_ctx, epfd);
@@ -1064,8 +1068,10 @@ TOOLKIT_API int ioqueue_acceptor_create(ioqueue_t *ioq,
 	service.sin_family = AF_INET;
 	service.sin_port = htons(port);
 	service.sin_addr.s_addr = ip ? inet_addr(ip) : htonl(INADDR_ANY);
-	if (bind(acceptor->u.sock, (struct sockaddr*)&service, sizeof(struct sockaddr)) != 0)
+	if (bind(acceptor->u.sock, (struct sockaddr*) & service, sizeof(struct sockaddr)) != 0) {
+		WLog_ERR(TAG, "bind sockect %d failed: %s", acceptor->u.sock, strerror(errno));
 		goto on_error;
+	}
 	if (evtpoll_attach(ioq->ep, acceptor->u.sock)) {
 		goto on_error;
 	}
@@ -1128,6 +1134,7 @@ TOOLKIT_API int ioqueue_acceptor_async_accept(ioqueue_acceptor_t* acceptor,
 		return -1;
 	overlapped = (ioqueue_accept_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_accept_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_accept_overlapped_t));
 	overlapped->client = INVALID_SOCKET;
 	fastlock_enter(acceptor->ov_pending_list_lock);
 	list_add_tail(&overlapped->base.pending_entry, &acceptor->ov_pending_list);
@@ -1202,6 +1209,7 @@ TOOLKIT_API int ioqueue_acceptor_create_client(ioqueue_acceptor_t* acceptor, SOC
 	}
 	add_handler_list(tcpsock, ioq);
 	inc_ref(ioqueue_handle_context, tcpsock);
+	WLog_DBG(TAG, "create a tcp session, fd=%d", s);
 	return 0;
 }
 
@@ -1328,6 +1336,7 @@ TOOLKIT_API int ioqueue_tcpsock_async_connect(ioqueue_tcpsock_t *tcpsock,
 	ioq = tcpsock->owner;
 	overlapped = (ioqueue_connect_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_connect_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_connect_overlapped_t));
 	fastlock_enter(tcpsock->ov_pending_list_lock);
 	list_add_tail(&overlapped->base.pending_entry, &tcpsock->ov_pending_list);
 	fastlock_leave(tcpsock->ov_pending_list_lock);
@@ -1455,6 +1464,7 @@ TOOLKIT_API int ioqueue_tcpsock_async_sendsome(ioqueue_tcpsock_t *tcpsock,
 
 	overlapped = (ioqueue_sendsome_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_sendsome_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_sendsome_overlapped_t));
 	fastlock_enter(tcpsock->ov_pending_list_lock);
 	list_add_tail(&overlapped->base.pending_entry, &tcpsock->ov_pending_list);
 	fastlock_leave(tcpsock->ov_pending_list_lock);
@@ -1496,9 +1506,10 @@ TOOLKIT_API int ioqueue_tcpsock_async_sendn(ioqueue_tcpsock_t *tcpsock,
 	ioq = ioqueue_tcpsock_get_owned_ioqueue(tcpsock);
 	if (ioq->stop)
 		return -1;
-
+	WLog_INFO(TAG, "fd(%d): ioqueue_tcpsock_async_sendn fired:  buf len: %d", tcpsock->u.sock, len);
 	overlapped = (ioqueue_sendn_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_sendn_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_sendn_overlapped_t));
 	fastlock_enter(tcpsock->ov_pending_list_lock);
 	list_add_tail(&overlapped->base.pending_entry, &tcpsock->ov_pending_list);
 	fastlock_leave(tcpsock->ov_pending_list_lock);
@@ -1512,7 +1523,6 @@ TOOLKIT_API int ioqueue_tcpsock_async_sendn(ioqueue_tcpsock_t *tcpsock,
 	overlapped->sended_bytes = 0;
 	overlapped->total_bytes = len;
 	inc_pending_io(tcpsock);
-	WLog_INFO(TAG, "ioqueue_tcpsock_async_sendn fired! sock: %d", tcpsock->u.sock);
 	rc = evtpoll_subscribe(ioq->ep, EV_WRITE, tcpsock->u.sock, NULL, ov);
 	if (!rc) {
 		return 0;
@@ -1598,6 +1608,7 @@ TOOLKIT_API int ioqueue_tcpsock_async_recvsome(ioqueue_tcpsock_t *tcpsock,
 
 	overlapped = (ioqueue_recvsome_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_recvsome_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_recvsome_overlapped_t));
 	fastlock_enter(tcpsock->ov_pending_list_lock);
 	list_add_tail(&overlapped->base.pending_entry, &tcpsock->ov_pending_list);
 	fastlock_leave(tcpsock->ov_pending_list_lock);
@@ -1643,6 +1654,7 @@ TOOLKIT_API int ioqueue_tcpsock_async_recvn(ioqueue_tcpsock_t *tcpsock,
 
 	overlapped = (ioqueue_recvn_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_recvn_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_recvn_overlapped_t));
 	fastlock_enter(tcpsock->ov_pending_list_lock);
 	list_add_tail(&overlapped->base.pending_entry, &tcpsock->ov_pending_list);
 	fastlock_leave(tcpsock->ov_pending_list_lock);
@@ -1694,6 +1706,7 @@ TOOLKIT_API int ioqueue_tcpsock_async_recvuntil(ioqueue_tcpsock_t *tcpsock,
 
 	overlapped = (ioqueue_recvuntil_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_recvuntil_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_recvuntil_overlapped_t));
 	fastlock_enter(tcpsock->ov_pending_list_lock);
 	list_add_tail(&overlapped->base.pending_entry, &tcpsock->ov_pending_list);
 	fastlock_leave(tcpsock->ov_pending_list_lock);
@@ -1892,6 +1905,7 @@ TOOLKIT_API int ioqueue_udpsock_async_sendto(ioqueue_udpsock_t* udpsock,
 
 	overlapped = (ioqueue_sendto_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_sendto_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_sendto_overlapped_t));
 	fastlock_enter(udpsock->ov_pending_list_lock);
 	list_add_tail(&overlapped->base.pending_entry, &udpsock->ov_pending_list);
 	fastlock_leave(udpsock->ov_pending_list_lock);
@@ -1946,6 +1960,7 @@ TOOLKIT_API int ioqueue_udpsock_async_recvfrom(ioqueue_udpsock_t* udpsock,
 
 	overlapped = (ioqueue_recvfrom_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_recvfrom_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_recvfrom_overlapped_t));
 	fastlock_enter(udpsock->ov_pending_list_lock);
 	list_add_tail(&overlapped->base.pending_entry, &udpsock->ov_pending_list);
 	fastlock_leave(udpsock->ov_pending_list_lock);
@@ -2135,6 +2150,7 @@ TOOLKIT_API int ioqueue_file_async_readsome_at(ioqueue_file_t* file,
 
 	overlapped = (ioqueue_readfilesome_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_readfilesome_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_readfilesome_overlapped_t));
 	fastlock_enter(file->ov_pending_list_lock);
 	list_add_tail(&overlapped->base.pending_entry, &file->ov_pending_list);
 	fastlock_leave(file->ov_pending_list_lock);
@@ -2182,6 +2198,7 @@ TOOLKIT_API int ioqueue_file_async_readn_at(ioqueue_file_t* file,
 
 	overlapped = (ioqueue_readfilen_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_readfilen_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_readfilen_overlapped_t));
 	fastlock_enter(file->ov_pending_list_lock);
 	list_add_tail(&overlapped->base.pending_entry, &file->ov_pending_list);
 	fastlock_leave(file->ov_pending_list_lock);
@@ -2342,6 +2359,7 @@ TOOLKIT_API int ioqueue_file_async_writesome_at(ioqueue_file_t* file,
 
 	overlapped = (ioqueue_writefilesome_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_writefilesome_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_writefilesome_overlapped_t));
 	fastlock_enter(file->ov_pending_list_lock);
 	list_add_tail(&overlapped->base.pending_entry, &file->ov_pending_list);
 	fastlock_leave(file->ov_pending_list_lock);
@@ -2389,6 +2407,7 @@ TOOLKIT_API int ioqueue_file_async_writen_at(ioqueue_file_t* file,
 
 	overlapped = (ioqueue_writefilen_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_writefilen_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_writefilen_overlapped_t));
 	fastlock_enter(file->ov_pending_list_lock);
 	list_add_tail(&overlapped->base.pending_entry, &file->ov_pending_list);
 	fastlock_leave(file->ov_pending_list_lock);
@@ -2593,6 +2612,7 @@ TOOLKIT_API int ioqueue_pipe_acceptor_async_accept(ioqueue_pipe_acceptor_t *acce
 
 	overlapped = (ioqueue_connectpipe_overlapped_t*)ov;
 	memset(overlapped, 0, sizeof(ioqueue_connectpipe_overlapped_t));
+	ioqueue_overlapped_set_mask(ov, sizeof(ioqueue_connectpipe_overlapped_t));
 	overlapped->client = CreateNamedPipeA(acceptor->u.pipe_name, 
 		PIPE_ACCESS_DUPLEX|FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE, 
 		PIPE_UNLIMITED_INSTANCES, 3072, 3072, NMPWAIT_WAIT_FOREVER, NULL);
@@ -2724,8 +2744,13 @@ TOOLKIT_API void ioqueue_overlapped_set_mask(ioqueue_overlapped_t* io, int mask_
 	base_ov->ov.Internal = mask_value;
 }
 
-TOOLKIT_API int ioqueue_overlapped_get_type(const ioqueue_overlapped_t* const io)
+/*at first, this function is only used evtpoll for dispatch, after then, bus_endpt seems involved*/
+TOOLKIT_API uint32_t ioqueue_overlapped_get_type(const ioqueue_overlapped_t* const io)
 {
+	if (ioqueue_overlapped_get_mask(io) == sizeof(OVERLAPPED)) {
+		return EV_BUS_ENDPOINT;
+	}
+	/*idx of acceptor*/
 	int sub_type = 0;
 	const ioqueue_base_overlapped_t* base_ov = (ioqueue_base_overlapped_t*)io;
 	const ioqueue_handle_context* handle_ctx = base_ov->handle_ctx;

libtoolkit/ioqueue.h

@@ -779,7 +779,7 @@ TOOLKIT_API int ioqueue_pipe_acceptor_close_pending_handle(ioqueue_pipe_acceptor
 
 TOOLKIT_API int ioqueue_overlapped_get_mask(const ioqueue_overlapped_t* const io);
 TOOLKIT_API void ioqueue_overlapped_set_mask(ioqueue_overlapped_t* io, int mask_value);
-TOOLKIT_API int ioqueue_overlapped_get_type(const ioqueue_overlapped_t* const io);
+TOOLKIT_API uint32_t ioqueue_overlapped_get_type(const ioqueue_overlapped_t* const io);
 
 #endif //NOT _WIN32
 

libtoolkit/process.c

@@ -95,7 +95,7 @@ TOOLKIT_API int process_spawn(const tk_process_option_t* option, tk_process_t**
 		new_process->handle = pi.hProcess;
 	}
 	else {
-		WLog_ERR(TAG, "create process  failed.");
+		WLog_ERR(TAG, "create process  failed, GetLastError(%d).", GetLastError());
 		FREE(new_process);
 		ret = -1;
 	}

libtoolkit/test/test_process.cpp

@@ -3,6 +3,7 @@
 #include <cstring>
 #include <gtest/gtest.h>
 #include "process_monitor.h"
+#include "toolkit.h"
 #include "list.h"
 #ifndef _WIN32
 #include <winpr/thread.h>
@@ -60,9 +61,30 @@ static int create_process_test(tk_process_t* new_process)
 		std::cerr << "create process failed, error: " << GetLastError() << std::endl;
 		return -1;
 	}
+
 	return 0;
 }
 
+//TEST(TestProcessCreate, CreateProcessTest)
+//{
+//	char path[MAX_PATH];
+//	char app[MAX_PATH] = { '\0' };
+//	char tmp[32];
+//	tk_process_t* process1 = NULL;
+//	tk_process_option_t option;
+//#ifdef _WIN32
+//	sprintf(app, ".\\bin\\sphost.exe 254");
+//#else
+//	sprintf(app, "./bin/sphost  254");
+//#endif //_WIN32
+//	option.exit_cb = NULL;
+//	option.file = NULL;
+//	option.flags = 0;
+//	option.params = app;
+//	EXPECT_TRUE(process_spawn(&option, &process1) == 0);
+//	EXPECT_TRUE(process1 != NULL);
+//}
+
 TEST(TestProcessMonitor, TestProcess)
 {
 	char* pt = NULL;

spbase/SpBase.cpp

@@ -385,9 +385,9 @@ extern "C" SPBASE_API int __stdcall SpRun(const char *mod_name, int epid, int ra
 		goto on_error;
 	}
 #endif //_WIN32
-
+	sp_dbg_debug("before set thread priority");
 	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
-
+	sp_dbg_debug("after set thread priority");
 #ifdef _WIN32
 	if (!SetSpModule(mod_name, curModule))
 		goto on_error;
@@ -400,6 +400,7 @@ extern "C" SPBASE_API int __stdcall SpRun(const char *mod_name, int epid, int ra
 	delete curModule;
 	curModule = NULL;
 #else
+
 	Error = g_module->Run();
 	g_module->Term();
 	FreeLibrary(hModule);

spbase/sp_cfg.cpp

@@ -26,6 +26,11 @@
 #include <winpr/string.h>
 
 #define MAX_ENTITY_LEN	33
+#ifdef _WIN32
+#define MOD_LIB_SUFFIX ".dll"
+#else
+#define MOD_LIB_SUFFIX ".so"
+#endif //_WIN32
 
 #define T_MALLOC_T(type, shm) \
 	shm ? (type*)shm_malloc(sizeof(type)) : (type*)malloc(sizeof(type))
@@ -579,7 +584,8 @@ static int load_shell_ini(sp_dir_t *dir, sp_cfg_shell_ini_t *shell, sp_cfg_root_
 		mod->company = shm_strdup(shellVerInfo.strCompanyName);
 		mod->name = shm_strdup("SpShell");
 		mod->mem_trace = inifile_read_int(file, "MemTrace", mod->name, 0);
-		mod->idx = shell->arr_module->nelts;
+		mod->idx = shell->arr_module->nelts; //the first mod id is spshell
+		/*increment netls at the same time*/
 		SHM_ARRAY_PUSH(shell->arr_module, sp_cfg_shell_module_t*) = mod;
 		ent = (sp_cfg_shell_entity_t *)shm_malloc(sizeof(sp_cfg_shell_entity_t));
 		memset(ent, 0, sizeof(sp_cfg_shell_entity_t));
@@ -617,20 +623,17 @@ static int load_shell_ini(sp_dir_t *dir, sp_cfg_shell_ini_t *shell, sp_cfg_root_
 			ret = inifile_format_read(file, sectionName, entity->name, "%d,%[^,],%x", &entity->privilege, tmp, &entity->devel_id);
 			if (ret == 3) {
 				sp_cfg_shell_module_t *mod;
-#ifdef _WIN32
-				if (str_has_suffix(tmp, ".dll")) {
-#else
-				if (str_has_suffix(tmp, ".so")) {
-#endif //_WIN32
-				int len = strlen(tmp);
-				tmp[len-4] = 0;
-			}
+				if (str_has_suffix(tmp, MOD_LIB_SUFFIX)) {
+					int len = strlen(tmp);
+					tmp[len-strlen(MOD_LIB_SUFFIX)] = 0;
+				}
 				mod = find_module(shell, tmp);
 				if (!mod) {
 					char sal_tmp[MAX_PATH];
+					int len = (strstr(tmp, "lib") == tmp) ? 3 : 0;
 					mod = (sp_cfg_shell_module_t *)shm_malloc(sizeof(sp_cfg_shell_module_t));
 					memset(mod, 0, sizeof(sp_cfg_shell_module_t));
-					mod->name = shm_strdup(tmp);
+					mod->name = shm_strdup(tmp + len);
 					tmp[strlen(tmp)] = '.';
 					sprintf(sal_tmp, "%s" SPLIT_SLASH_STR "%s", dir->mod_path, tmp);
 				mod->group = curGroup;

spbase/sp_dir.c

@@ -168,68 +168,46 @@ static int __dir_get_path(char *base_dir, int flag, const char *cat_name, char *
 	else if (flag == SP_DIR_RUNINFO_INI)
 	{
 		strcpy(buf, base_dir);
-#ifdef _WIN32
-		strcat(buf, "\\runcfg\\");
-#else
-		strcat(buf, "/runcfg/");
-#endif //_WIN32
+		strcat(buf, SPLIT_SLASH_STR "runcfg" SPLIT_SLASH_STR);
 		strcat(buf, cat_name);
 		strcat(buf, ".ini");
 	}	
 	else if (flag == SP_DIR_RUNINFO_BOOT_LOG) {
 		strcpy(buf, base_dir);
-#ifdef _WIN32
-		strcat(buf, "\\bootrec\\");
-#else
-		strcat(buf, "/bootrec/");
-#endif //_WIN32
+		strcat(buf, SPLIT_SLASH_STR "bootrec" SPLIT_SLASH_STR);
 		strcat(buf, cat_name);
 		strcat(buf, ".log");
 	}else if (flag == SP_DIR_SHELLVAR_INI){
 		strcpy(buf, base_dir);
-#ifdef _WIN32
-		strcat(buf, "\\runcfg\\shellVar.ini");
-#else
-		strcat(buf, "/runcfg/shellVar.ini");
-#endif //_WIN32
+		strcat(buf, SPLIT_SLASH_STR "runcfg" SPLIT_SLASH_STR "shellVar.ini");
 	}else if (flag == SP_DIR_SHELL_INI) {
 		strcpy(buf, base_dir);
-#ifdef _WIN32
-		strcat(buf, "\\shell.ini");
-#else
-		strcat(buf, "/shell.ini");
-#endif //_WIN32
+		strcat(buf, SPLIT_SLASH_STR "shell.ini");
 	} else if (flag == SP_DIR_MODULE_BIN) {
 		strcpy(buf, base_dir);
 		strcat(buf, SPLIT_SLASH_STR);
+#ifdef _WIN32
 		strcat(buf, cat_name);
 		strcat(buf, ".dll");
-	} else if (flag == SP_DIR_ROOT_INI) {
-		strcpy(buf, base_dir);
-#ifdef _WIN32
-		strcat(buf, "\\root.ini");
 #else
-		strcat(buf, "/root.ini");
+		strcat(buf, "lib");
+		strcat(buf, cat_name);
+		strcat(buf, ".so");
 #endif //_WIN32
+
+	} else if (flag == SP_DIR_ROOT_INI) {
+		strcpy(buf, base_dir);
+		strcat(buf, SPLIT_SLASH_STR "root.ini");
 	} else if (flag == SP_DIR_INSTALL_INI) {
 		strcpy(buf, base_dir);
-#ifdef _WIN32
-		strcat(buf, "\\install.ini");
-#else
-		strcat(buf, "/install.ini");
-#endif //_WIN32
+		strcat(buf, SPLIT_SLASH_STR "install.ini");
 	}
 	else if (flag == SP_DIR_CENTER_SETTING_INI)
 	{
 		// 为了兼容旧版本实体，此处仍返回原有配置名
 		strcpy(buf, base_dir);
-#ifdef _WIN32
-		strcat(buf, "\\CenterSetting.ini");
-#else
-		strcat(buf, "/CenterSetting.ini");
-#endif //_WIN32
+		strcat(buf, SPLIT_SLASH_STR  "CenterSetting.ini");
 	}
-
 	return rc;
 }
 
@@ -399,30 +377,17 @@ int sp_dir_get_path_version(sp_dir_t* dir, int major, int minor, int revision, i
 	} else if (flag == SP_DIR_RUNINFO_INI || flag == SP_DIR_RUNINFO_BOOT_LOG) {
 		base_path = dir->root_runinfo_path;
 	} else if (flag == SP_DIR_SHELL_INI || flag == SP_DIR_ENTITY_INI) {
-#ifdef _WIN32
-		sprintf(tmp, "%s\\%d.%d.%d.%d\\cfg", dir->root_ver_path, major, minor, revision, build);
-#else
-		sprintf(tmp, "%s/%d.%d.%d.%d/cfg", dir->root_ver_path, major, minor, revision, build);
-#endif //_WIN32
+		sprintf(tmp, "%s" SPLIT_SLASH_STR "%d.%d.%d.%d" SPLIT_SLASH_STR "cfg", dir->root_ver_path, major, minor, revision, build);
 		base_path = tmp;
 	} else if (flag == SP_DIR_MODULE_BIN) {
-#ifdef _WIN32
-		sprintf(tmp, "%s\\%d.%d.%d.%d\\mod", dir->root_ver_path, major, minor, revision, build);
-#else
-		sprintf(tmp, "%s/%d.%d.%d.%d/mod", dir->root_ver_path, major, minor, revision, build);
-#endif //_WIN32
+		sprintf(tmp, "%s" SPLIT_SLASH_STR "%d.%d.%d.%d" SPLIT_SLASH_STR "mod", dir->root_ver_path, major, minor, revision, build);
 		base_path = tmp;
 	} else if (flag == SP_DIR_INSTALL_INI) {
-#ifdef _WIN32
-		sprintf(tmp, "%s\\%d.%d.%d.%d", dir->root_ver_path, major, minor, revision, build);
-#else
-		sprintf(tmp, "%s/%d.%d.%d.%d", dir->root_ver_path, major, minor, revision, build);
-#endif //_WIN32
+		sprintf(tmp, "%s" SPLIT_SLASH_STR "%d.%d.%d.%d", dir->root_ver_path, major, minor, revision, build);
 		base_path = tmp;
 	} else {
 		return Error_Param;
 	}
-	
 	return __dir_get_path(base_path, flag, cat_name, buf, len, NULL);
 }
 

spbase/sp_iom.c

@@ -361,17 +361,26 @@ static int sp_iom_poll(sp_iom_t *iom, int *timeout)
 		if (timerPlayTime > 500)	//timer play time over than 500ms, it may make the main thread run slow
 			sp_dbg_info("cur Timer %d has run %d ms", cnt, timerPlayTime);
 		iom_tm_unlock(iom);
-		if (!cnt)		// µ±Ç°Ã»Óж¨Ê±Æ÷Ö´ÐÐ
+		if (!cnt)	 {
+			//sp_dbg_debug("no timer execute current times.");
 			break;
+		}
 	}
-
 	return rc;
 }
 
 int sp_iom_run(sp_iom_t *iom)
 {
 	int timeout = POLL_INTERVAL;
-	while (InterlockedExchangeAdd((LONG*)&iom->stop, 0) == 0 || timer_queue_get_count(iom->tm_queue) > 0) {
+	while (
+#ifdef _WIN32
+		InterlockedExchangeAdd((LONG*)&iom->stop, 0) == 0
+#else
+		/*the adapte func 'InterlockedExchangeAdd' implemented under winpr went wrong, maybe 64bit has responsibility*/
+		iom->stop == 0
+#endif //_WIN32
+		|| timer_queue_get_count(iom->tm_queue) > 0) 
+{
 		int rc = sp_iom_poll(iom, &timeout);
 		if (rc >= 0) {
 			if (timeout > POLL_INTERVAL || timeout < 0)

spbase/sp_mod.c

@@ -818,7 +818,7 @@ static int create_module_process(const char *mod_name, int epid, int range, int
 #else
 	tk_process_t* process = NULL;
 	tk_process_option_t option;
-	sprintf(app, "./bin/sphost.out %d %s %d", range, mod_name, epid);
+	sprintf(app, "./bin/sphost %d %s %d", range, mod_name, epid);
 	option.exit_cb = NULL;
 	option.file = NULL;
 	option.flags = 0;
@@ -1626,7 +1626,7 @@ static int load_module(sp_mod_mgr_t *mgr, sp_mod_t *mod, int trigger_entity_id)
 		int i;
 
 		ResetEvent(mod->evt_wait_handle);
-
+		sp_dbg_debug("get remote entitiy state...");
 		for (i = 0; i < tries; ++i) {
 			int state = BUS_STATE_OFF;
 			rc = sp_svc_get_state(mgr->shell_svc, mod->cfg->idx, &state);

spbase/test/SpBaseMiscTest.cpp

@@ -1,7 +1,9 @@
 #include "precompile.h"
-#include "CodeSignVerify.h"
+
 #include <gtest/gtest.h>
 
+#ifdef _WIN32
+#include "CodeSignVerify.h"
 TEST(SpBaseMisc, FileVersionTest)
 {
 	CCodeSignVerify ver;
@@ -9,6 +11,7 @@ TEST(SpBaseMisc, FileVersionTest)
 	EXPECT_TRUE(ver.GetVersionInfo("Spshell.exe", verInfo));
 	EXPECT_TRUE(verInfo.FileVersion.IsValid());
 }
+#endif //_WIN32
 
 #include "sp_dir.h"
 TEST(SpBaseMisc, DirTest)

spbase/test/SpCommTest.cpp

@@ -79,6 +79,9 @@ TEST(SimpleStringTest, CharTypeTest)
 	ASSERT_TRUE(str5.Compare(str7, true) == 0);
 }
 
+#ifdef _WIN32
+
+
 TEST(SimpleStringTest, WideCharTypeTest)
 {
 	CSimpleStringW s1(L"123456 7890");
@@ -163,3 +166,6 @@ TEST(SimpleStringTest, WideCharTransferTest)
 	CSimpleStringW wstr = CSimpleStringA2W(str);
 	ASSERT_TRUE(wstr.Compare(L"testString") == 0);
 }
+
+
+#endif //_WIN32

spbase/test/SpModTest.cpp

@@ -28,9 +28,9 @@ TEST(SpModTest, LoadModuleTest)
 	memset(mod, 0, sizeof(sp_cfg_shell_module_t));
 	sp_version_t ver = { 1, 0, 1, 0 };
 	sp_version_copy(&mod->version, &ver);
-	mod->author = _strdup("tester");
-	mod->company = _strdup("tester");
-	mod->name = _strdup("test_mod_name");
+	mod->author = strdup("tester");
+	mod->company = strdup("tester");
+	mod->name = strdup("test_mod_name");
 	mod->mem_trace = 0;
 	mod->idx = 1;
 	
@@ -38,7 +38,7 @@ TEST(SpModTest, LoadModuleTest)
 	ASSERT_TRUE(ent != NULL);
 	memset(ent, 0, sizeof(sp_cfg_shell_entity_t));
 	ent->mod = mod;
-	ent->name = _strdup("test_entity_name");
+	ent->name = strdup("test_entity_name");
 	ent->idx = 1;
 	ent->privilege = 1;
 	ent->debug_level = 0;

spbase/test/SpRunTaskTest.cpp

@@ -6,8 +6,10 @@
 #include "sp_runTask.h"
 #include <gtest/gtest.h>
 
+#ifdef _WIN32
 TEST(SpRunTask, ControlProcessTest)
 {
-    EXPECT_TRUE(sp_runtask_killprocess() == 0);
-    EXPECT_TRUE(sp_runtask_startprocess() == 0);
-}
+	EXPECT_TRUE(sp_runtask_killprocess() == 0);
+	EXPECT_TRUE(sp_runtask_startprocess() == 0);
+}
+#endif //_WIN32

spshell/app.cpp

@@ -110,6 +110,7 @@ static int kickoff_startlist()
 	}
 	return Error_Resource;
 }
+
 #include "sp_runTask.h"
 int  RenameLightPacks(const char *pszAdPath)
 {
@@ -311,9 +312,6 @@ int app_init()
 	// 检查轻量更新包是否有.new文件
 	RenameLightPacks(env->cfg->root_ini->ref_addata_path);
 
-	// reg dbg log handler
-	//sp_dbg_reg_handler(log_on_dbg_log_callback);
-
 	rc = sp_var_daemon_create(g_app.svc, &g_app.var_daemon);	// add workitem daemon_on_pkt and daemon_on_sys
 	if (rc != 0) {
 		sp_dbg_error("var daemon create failed!");

test/module/CMakeLists.txt

@@ -1,3 +1,5 @@
+
+#设置实体名称 ${MODULE_NAME}，和实体前缀定义 ${MODULE_PREFIX}
 macro(define_moudle _module_name)
 	set(MODULE_NAME "mod_${_module_name}")
 	string(TOUPPER "MOD_${MODULE_NAME}" MODULE_PREFIX)
@@ -6,6 +8,8 @@ endmacro(define_moudle)
 #macro(add_module _module_prefix _module_name)
 #endmacro(add_module)
 
+#对于 Windows 设置实体的版本信息
+#定义共享库输出
 macro(add_module_libraries _module_prefix _module_name)
 	if(WIN32)
 	    set (RC_VERSION_MAJOR ${RVC_VERSION_MAJOR})
@@ -21,9 +25,14 @@ macro(add_module_libraries _module_prefix _module_name)
     endif(WIN32)
     add_library(${_module_name} SHARED ${${_module_prefix}_SRCS})
     # 设置工程输出路径
-    # set_target_properties(${_module_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${RVC_MODULE_LIBRARY_PATH}")
+    if(SIMULATE_DEV_AND_TEST_TEMP)
+        set_target_properties(${_module_name} 
+        PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/run/version/1.2.3.4/mod")
+    endif(SIMULATE_DEV_AND_TEST_TEMP)
 endmacro(add_module_libraries)
 
+# 设置实体的安装拷贝路径
+# 对于 Windows 设置实体项目工程在解决方案的节点
 macro(deploy_module _module_prefix _module_name)
     install(TARGETS ${_module_name} 
     RUNTIME DESTINATION "${RVC_MODULE_PATH}"
@@ -37,7 +46,9 @@ endmacro(deploy_module)
 #set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} winpr freerdp)
 #set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} msimg32)
 #target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})
+set(MODULE_BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
+# 遍历实体
 file(GLOB module_dirs RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "${CMAKE_CURRENT_SOURCE_DIR}/*")
 set(module_list "")
 foreach(module_dir ${module_dirs})

test/module/mod_helloclient/CMakeLists.txt

@@ -1,8 +1,15 @@
+# 定义实体名称
 define_moudle("helloclient")
+
 set(${MODULE_PREFIX}_SRCS
 	mod_helloclient.cpp)
 
 add_module_libraries(${MODULE_PREFIX} ${MODULE_NAME})
+target_include_directories(${MODULE_NAME}
+	PRIVATE ${MODULE_BASE_DIR}/mod_helloservice
+)
+
+# 添加实体需要依赖的其他共享库（包括系统库）
 set(${MODULE_PREFIX}_LIBS spbase)
 target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})
 

test/module/mod_helloclient/mod_helloclient.cpp

@@ -1,7 +1,7 @@
 #include "stdafx.h"
 #include "SpBase.h"
 
-#include "..\mod_helloservice\HelloService_client_g.h"
+#include "HelloService_client_g.h"
 
 using namespace HelloService;
 

test/module/mod_helloservice/HelloService_def_g.h

@@ -5,7 +5,7 @@
 
 // This code is generated by spgen tool!
 
-#include "spHelper.h"
+#include "SpHelper.h"
 
 namespace HelloService {
 //

test/module/mod_helloservice/HelloService_msg_g.h

@@ -6,7 +6,7 @@
 
 // This code is generated by spgen tool!
 
-#include "spHelper.h"
+#include "SpHelper.h"
 
 namespace HelloService {
 #define eMsg_TestEvent 0

winpr/include/winpr/thread.h

@@ -99,7 +99,6 @@ extern "C"
 #define STARTF_TITLEISAPPID 0x00001000
 #define STARTF_PREVENTPINNING 0x00002000
 
-
 #define THREAD_BASE_PRIORITY_LOWRT  15  // value that gets a thread to LowRealtime-1
 #define THREAD_BASE_PRIORITY_MAX    2   // maximum thread base priority boost
 #define THREAD_BASE_PRIORITY_MIN    (-2)  // minimum thread base priority boost

winpr/libwinpr/handle/handle.h

@@ -40,6 +40,8 @@
 #define HANDLE_TYPE_TIMER_QUEUE_TIMER 12
 #define HANDLE_TYPE_COMM 13
 
+#define THREAD_CUR_ONE_HANDLE ((HANDLE)(LONG_PTR)-2)
+
 #define WINPR_HANDLE_DEF() \
 	ULONG Type;            \
 	ULONG Mode;            \
@@ -131,16 +133,16 @@ static INLINE BOOL winpr_Handle_GetInfo(HANDLE handle, ULONG* pType, WINPR_HANDL
 
 	if (handle == NULL)
 		return FALSE;
-
 		/* INVALID_HANDLE_VALUE is an invalid value for every handle, but it
 		 * confuses the clang scanbuild analyzer. */
 #ifndef __clang_analyzer__
 	if (handle == INVALID_HANDLE_VALUE)
 		return FALSE;
 #endif
-
+	if (handle == THREAD_CUR_ONE_HANDLE) 		{
+		return FALSE;
+	}
 	wHandle = (WINPR_HANDLE*)handle;
-
 	*pType = wHandle->Type;
 	*pObject = handle;
 

winpr/libwinpr/interlocked/test/TestInterlockedAccess.c

@@ -89,6 +89,18 @@ int TestInterlockedAccess(int argc, char* argv[])
 		return -1;
 	}
 
+	*Addend = 0;
+	oldValue = InterlockedExchangeAdd(Addend, 0);
+	if (oldValue != 0) {
+		printf("InterlockedExchangeAdd failure: Actual: %" PRId32 ", Expected: 0\n", oldValue);
+		return -1;
+	}
+
+	if (*Addend != 0) {
+		printf("InterlockedExchangeAdd failure: Actual: %" PRId32 ", Expected: 0\n", *Addend);
+		return -1;
+	}
+
 	/* InterlockedCompareExchange (*Destination == Comparand) */
 
 	Destination = _aligned_malloc(sizeof(LONG), sizeof(LONG));

winpr/libwinpr/library/library.c

@@ -107,34 +107,13 @@ BOOL SetDefaultDllDirectories(DWORD DirectoryFlags)
 
 HMODULE LoadLibraryA(LPCSTR lpLibFileName)
 {
-#if defined(_UWP)
-	int status;
-	HMODULE hModule = NULL;
-	WCHAR* filenameW = NULL;
-
-	if (!lpLibFileName)
-		return NULL;
-
-	status = ConvertToUnicode(CP_UTF8, 0, lpLibFileName, -1, &filenameW, 0);
-
-	if (status < 1)
-		return NULL;
-
-	hModule = LoadLibraryW(filenameW);
-	free(filenameW);
-	return hModule;
-#else
 	HMODULE library;
 	library = dlopen(lpLibFileName, RTLD_LOCAL | RTLD_LAZY);
-
-	if (!library)
-	{
+	if (!library) {
 		WLog_ERR(TAG, "%s failed with %s", __FUNCTION__, dlerror());
 		return NULL;
 	}
-
 	return library;
-#endif
 }
 
 HMODULE LoadLibraryW(LPCWSTR lpLibFileName)

winpr/libwinpr/thread/process.c

@@ -61,6 +61,8 @@
 #include <stdarg.h>
 #include <sys/wait.h>
 #include <signal.h>
+#include "../log.h"
+#define TAG WINPR_TAG("process")
 
 #include "thread.h"
 
@@ -100,43 +102,35 @@ static char* FindApplicationPath(char* application)
 
 	if (!application)
 		return NULL;
-
-	if (application[0] == '/')
+	if (application[0] == '/') {
 		return _strdup(application);
-
+	}
+	else if (PathFileExistsA(application)) {
+		return _strdup(application);
+	}
 	nSize = GetEnvironmentVariableA(pathName, NULL, 0);
-
 	if (!nSize)
 		return _strdup(application);
-
 	lpSystemPath = (LPSTR)malloc(nSize);
-
 	if (!lpSystemPath)
 		return NULL;
-
 	if (GetEnvironmentVariableA(pathName, lpSystemPath, nSize) != nSize - 1)
 	{
 		free(lpSystemPath);
 		return NULL;
 	}
-
 	save = NULL;
 	path = strtok_s(lpSystemPath, ":", &save);
-
 	while (path)
 	{
 		filename = GetCombinedPath(path, application);
-
-		if (PathFileExistsA(filename))
-		{
+		if (PathFileExistsA(filename)) {
 			break;
 		}
-
 		free(filename);
 		filename = NULL;
 		path = strtok_s(NULL, ":", &save);
 	}
-
 	free(lpSystemPath);
 	return filename;
 }
@@ -169,11 +163,11 @@ static BOOL _CreateProcessExA(HANDLE hToken, DWORD dwLogonFlags, LPCSTR lpApplic
 	lpszEnvironmentBlock = NULL;
 	pArgs = CommandLineToArgvA(lpCommandLine, &numArgs);
 
-	if (!pArgs)
+	if (!pArgs) {
+		WLog_ERR(TAG, "CommandLineToArgvA failed.");
 		return FALSE;
-
+	}
 	token = (WINPR_ACCESS_TOKEN*)hToken;
-
 	if (lpEnvironment)
 	{
 		envp = EnvironmentBlockToEnvpA(lpEnvironment);
@@ -181,19 +175,17 @@ static BOOL _CreateProcessExA(HANDLE hToken, DWORD dwLogonFlags, LPCSTR lpApplic
 	else
 	{
 		lpszEnvironmentBlock = GetEnvironmentStrings();
-
 		if (!lpszEnvironmentBlock)
 			goto finish;
-
 		envp = EnvironmentBlockToEnvpA(lpszEnvironmentBlock);
 	}
-
 	if (!envp)
 		goto finish;
 	if(lpApplicationName == NULL)
 	{
 		filename = FindApplicationPath(pArgs[0]);
-	} else
+	} 
+	else
 	{
 		lpszAppName = _strdup(lpApplicationName);
 		//lpszAppName = (char*)malloc(strlen(lpApplicationName)+1);
@@ -205,8 +197,11 @@ static BOOL _CreateProcessExA(HANDLE hToken, DWORD dwLogonFlags, LPCSTR lpApplic
 			free(lpszAppName);
 		}
 	}
-	if (NULL == filename)
+	if (NULL == filename) {
+		WLog_WARN(TAG, "filename is needed");
+		SetLastError(ERROR_PATH_NOT_FOUND);
 		goto finish;
+	}
 
 	/* block all signals so that the child can safely reset the caller's handlers */
 	sigfillset(&newSigMask);
@@ -217,15 +212,14 @@ static BOOL _CreateProcessExA(HANDLE hToken, DWORD dwLogonFlags, LPCSTR lpApplic
 	if (pid < 0)
 	{
 		/* fork failure */
+		WLog_ERR(TAG, "fork failed: %s", strerror(errno));
 		goto finish;
 	}
 
 	if (pid == 0)
 	{
 		/* child process */
-#ifndef __sun
 		int maxfd;
-#endif
 		int fd;
 		int sig;
 		sigset_t set;
@@ -261,10 +255,6 @@ static BOOL _CreateProcessExA(HANDLE hToken, DWORD dwLogonFlags, LPCSTR lpApplic
 			if (handle_fd != -1)
 				dup2(handle_fd, STDIN_FILENO);
 		}
-
-#ifdef __sun
-		closefrom(3);
-#else
 #ifdef F_MAXFD // on some BSD derivates
 		maxfd = fcntl(0, F_MAXFD);
 #else
@@ -273,9 +263,6 @@ static BOOL _CreateProcessExA(HANDLE hToken, DWORD dwLogonFlags, LPCSTR lpApplic
 
 		for (fd = 3; fd < maxfd; fd++)
 			close(fd);
-
-#endif // __sun
-
 		if (token)
 		{
 			if (token->GroupId)
@@ -314,6 +301,7 @@ static BOOL _CreateProcessExA(HANDLE hToken, DWORD dwLogonFlags, LPCSTR lpApplic
 
 	if (!process)
 	{
+		WLog_ERR(TAG, "CreateProcessHandle failed: %s", strerror(errno));
 		goto finish;
 	}
 
@@ -321,6 +309,7 @@ static BOOL _CreateProcessExA(HANDLE hToken, DWORD dwLogonFlags, LPCSTR lpApplic
 
 	if (!thread)
 	{
+		WLog_ERR(TAG, "CreateNoneHandle failed");
 		ProcessHandleCloseHandle(process);
 		goto finish;
 	}

winpr/libwinpr/thread/test/TestThreadPriority.c

@@ -46,6 +46,10 @@ int TestThreadPriority(int argc, char* argv[])
         return -1;
     }
     CloseHandle(thread);
+
+    if (FALSE == SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL)) {
+        fprintf(stderr, "set thread prioprity with THREAD_PRIORITY_ABOVE_NORMAL failed.\n ");
+    }
     return 0;
 }
 

winpr/libwinpr/thread/thread.c

@@ -482,7 +482,7 @@ HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize
 
 	WINPR_HANDLE_SET_TYPE_AND_MODE(thread, HANDLE_TYPE_THREAD, WINPR_FD_READ);
 	handle = (HANDLE)thread;
-
+	assert(handle != THREAD_CUR_ONE_HANDLE);
 	if (!thread_list)
 	{
 		thread_list = ListDictionary_New(TRUE);
@@ -624,18 +624,14 @@ VOID ExitThread(DWORD dwExitCode)
 {
 	DWORD rc;
 	pthread_t tid = pthread_self();
-
-	if (!thread_list)
-	{
-		WLog_ERR(TAG, "function called without existing thread list!");
-#if defined(WITH_DEBUG_THREADS)
-		DumpThreadHandles();
-#endif
-		pthread_exit(0);
-	}
-	else if (!ListDictionary_Contains(thread_list, &tid))
+	if (!thread_list || !ListDictionary_Contains(thread_list, &tid))
 	{
-		WLog_ERR(TAG, "function called, but no matching entry in thread list!");
+		if (!thread_list) {
+			WLog_ERR(TAG, "%s called without existing thread list!", __FUNCTION__);
+		}
+		else {
+			WLog_ERR(TAG, "function called, but no matching entry in thread list!");
+		}
 #if defined(WITH_DEBUG_THREADS)
 		DumpThreadHandles();
 #endif
@@ -679,19 +675,15 @@ BOOL GetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode)
 
 HANDLE _GetCurrentThread(VOID)
 {
-	HANDLE hdl = NULL;
+	HANDLE hdl = THREAD_CUR_ONE_HANDLE;
 	pthread_t tid = pthread_self();
-
-	if (!thread_list)
-	{
-		WLog_ERR(TAG, "function called without existing thread list!");
-#if defined(WITH_DEBUG_THREADS)
-		DumpThreadHandles();
-#endif
-	}
-	else if (!ListDictionary_Contains(thread_list, &tid))
-	{
-		WLog_ERR(TAG, "function called, but no matching entry in thread list!");
+	if (!thread_list || !ListDictionary_Contains(thread_list, &tid)) {
+		if (!thread_list) {
+			WLog_WARN(TAG, "%s called without existing thread list!", __FUNCTION__);
+		}
+		else {
+			WLog_WARN(TAG, "%s called, but no matching entry in thread list!", __FUNCTION__);
+		}
 #if defined(WITH_DEBUG_THREADS)
 		DumpThreadHandles();
 #endif
@@ -700,7 +692,6 @@ HANDLE _GetCurrentThread(VOID)
 	{
 		hdl = ListDictionary_GetItemValue(thread_list, &tid);
 	}
-
 	return hdl;
 }
 
@@ -802,16 +793,12 @@ HANDLE OpenThread(DWORD dwDesiredAccess, BOOL  bInheritHandle, DWORD dwThreadId)
 	if(bInheritHandle) {
 		WLog_WARN(TAG, "bInheritHandle is not supported now.");
 	}
-	if (!thread_list)
-	{
-		WLog_ERR(TAG, "function called without existing thread list!");
-#if defined(WITH_DEBUG_THREADS)
-		DumpThreadHandles();
-#endif
-	}
-	else if (!ListDictionary_Contains(thread_list, &tid))
+	if (!thread_list || !ListDictionary_Contains(thread_list, &tid))
 	{
-		WLog_ERR(TAG, "function called, but no matching entry in thread list!");
+		if(!thread_list)
+			WLog_ERR(TAG, "%s called without existing thread list!", __FUNCTION__);
+		else
+			WLog_ERR(TAG, "function called, but no matching entry in thread list!");
 #if defined(WITH_DEBUG_THREADS)
 		DumpThreadHandles();
 #endif
@@ -820,7 +807,6 @@ HANDLE OpenThread(DWORD dwDesiredAccess, BOOL  bInheritHandle, DWORD dwThreadId)
 	{
 		hdl = ListDictionary_GetItemValue(thread_list, &tid);
 	}
-
 	return hdl;
 }
 
@@ -830,19 +816,28 @@ BOOL SetThreadPriority(HANDLE hThread, int nPriority)
 	BOOL result = TRUE;
 	ULONG Type;
 	WINPR_HANDLE* Object;
-	WINPR_THREAD* thread;
+	WINPR_THREAD* thread = NULL;
 	struct sched_param param;
 	pthread_attr_t attr;
+	pthread_t cur_thread;
 	int policy = 0;
 	int max_prio_for_policy = 0;
 	int min_prio_for_policy = 0;
 	int ret = 0;
 	if (!winpr_Handle_GetInfo(hThread, &Type, &Object))
 	{
-		WLog_ERR(TAG, "get thread handle information failed!");
-		return FALSE;
+		if (hThread == THREAD_CUR_ONE_HANDLE) {
+			WLog_DBG(TAG, "current thread flag.");
+			cur_thread = pthread_self();
+		} else {
+			WLog_ERR(TAG, "get thread handle information failed!");
+			return FALSE;
+		}
+	}
+	else {
+		thread = (WINPR_THREAD*)Object;
+		cur_thread = thread->thread;
 	}
-	thread = (WINPR_THREAD*)Object;
 
 #if 0
 	/*https://pubs.opengroup.org/onlinepubs/009695399/functions/pthread_setschedprio.html*/
@@ -853,14 +848,14 @@ BOOL SetThreadPriority(HANDLE hThread, int nPriority)
 		/*
 		 * set the scheduling priority for the thread to prio
 		 */
-		if(0 != pthread_setschedprio(thread->thread, max_prio_for_policy)) {
+		if(0 != pthread_setschedprio(cur_thread, max_prio_for_policy)) {
 			result = FALSE;
 		}
 	}
 	pthread_attr_destroy(&attr);
 #else
 	/*it might be preferable conceptually to solve this problem.*/
-	ret = pthread_getschedparam(thread->thread, &policy, &param);
+	ret = pthread_getschedparam(cur_thread, &policy, &param);
 	if(0 != ret)
 	{
 		WLog_ERR(TAG, "get thread schedule param failed, err: %d", ret);
@@ -894,7 +889,7 @@ BOOL SetThreadPriority(HANDLE hThread, int nPriority)
 	 * the caller does not have appropriate permission to set either the scheduling
 	 * parameters or the scheduling policy of the specified thread.
 	 */
-	ret = pthread_setschedparam(thread->thread, policy, &param);
+	ret = pthread_setschedparam(cur_thread, policy, &param);
 	if (0 != ret) {
 		WLog_ERR(TAG, "set scheduled param failed! policy: %d, priority: %d, err: %d",
 			policy, param.sched_priority, ret);