From 6e635934c1ec68996bb3f4d5d1172092952d73b5 Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sat, 23 Sep 2023 12:47:00 +0800
Subject: [PATCH 01/14] disable warning C4858

---
 .gitignore          | 1 +
 src/libipc/waiter.h | 8 ++++++--
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index 9bca0610..b8573713 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,6 +28,7 @@ ui_*.h
 *.jsc
 Makefile*
 *build-*
+*build_*
 
 # Qt unit tests
 target_wrapper.*
diff --git a/src/libipc/waiter.h b/src/libipc/waiter.h
index ee45fe35..bb5b3b34 100644
--- a/src/libipc/waiter.h
+++ b/src/libipc/waiter.h
@@ -64,12 +64,16 @@ class waiter {
     }
 
     bool notify() noexcept {
-        std::lock_guard<ipc::sync::mutex>{lock_}; // barrier
+        {
+            IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> barrier{lock_}; // barrier
+        }
         return cond_.notify(lock_);
     }
 
     bool broadcast() noexcept {
-        std::lock_guard<ipc::sync::mutex>{lock_}; // barrier
+        {
+            IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> barrier{lock_}; // barrier
+        }
         return cond_.broadcast(lock_);
     }
 

From 2d8d6facc32154471f70bb75f7f1f4ec4ca166ed Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sat, 23 Sep 2023 14:03:13 +0800
Subject: [PATCH 02/14] Windows services can communicate with common processes.

---
 CMakeLists.txt                          |   4 +
 demo/win_service/client/CMakeLists.txt  |   8 +
 demo/win_service/client/main.cpp        |  28 ++++
 demo/win_service/service/CMakeLists.txt |   8 +
 demo/win_service/service/main.cpp       | 189 ++++++++++++++++++++++++
 src/libipc/platform/win/mutex.h         |   2 +-
 src/libipc/platform/win/semaphore.h     |   2 +-
 src/libipc/platform/win/shm_win.cpp     |   2 +-
 8 files changed, 240 insertions(+), 3 deletions(-)
 create mode 100644 demo/win_service/client/CMakeLists.txt
 create mode 100644 demo/win_service/client/main.cpp
 create mode 100644 demo/win_service/service/CMakeLists.txt
 create mode 100644 demo/win_service/service/main.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6d9b2a57..12cebd4e 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -59,6 +59,10 @@ if (LIBIPC_BUILD_DEMOS)
     add_subdirectory(demo/chat)
     add_subdirectory(demo/msg_que)
     add_subdirectory(demo/send_recv)
+    if (MSVC)
+        add_subdirectory(demo/win_service/service)
+        add_subdirectory(demo/win_service/client)
+    endif()
 endif()
 
 install(
diff --git a/demo/win_service/client/CMakeLists.txt b/demo/win_service/client/CMakeLists.txt
new file mode 100644
index 00000000..2dc03d5a
--- /dev/null
+++ b/demo/win_service/client/CMakeLists.txt
@@ -0,0 +1,8 @@
+project(win_client)
+
+file(GLOB SRC_FILES ./*.cpp)
+file(GLOB HEAD_FILES ./*.h)
+
+add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
+
+target_link_libraries(${PROJECT_NAME} ipc)
diff --git a/demo/win_service/client/main.cpp b/demo/win_service/client/main.cpp
new file mode 100644
index 00000000..fea348e9
--- /dev/null
+++ b/demo/win_service/client/main.cpp
@@ -0,0 +1,28 @@
+/// \brief To create a basic Windows command line program.
+
+#include <Windows.h>
+#include <tchar.h>
+#include <stdio.h>
+
+#include "libipc/ipc.h"
+
+int _tmain (int argc, TCHAR *argv[]) {
+    _tprintf(_T("My Sample Client: Entry\n"));
+    ipc::channel ipc_r{"service ipc r", ipc::receiver};
+    ipc::channel ipc_w{"service ipc w", ipc::sender};
+    while (1) {
+        auto msg = ipc_r.recv();
+        if (msg.empty()) {
+            _tprintf(_T("My Sample Client: message recv error\n"));
+            return -1;
+        }
+        printf("My Sample Client: message recv: [%s]\n", (char const *)msg.data());
+        while (!ipc_w.send("Copy.")) {
+            _tprintf(_T("My Sample Client: message send error\n"));
+            Sleep(1000);
+        }
+        _tprintf(_T("My Sample Client: message send [Copy]\n"));
+    }
+    _tprintf(_T("My Sample Client: Exit\n"));
+    return 0;
+}
diff --git a/demo/win_service/service/CMakeLists.txt b/demo/win_service/service/CMakeLists.txt
new file mode 100644
index 00000000..b7bb3574
--- /dev/null
+++ b/demo/win_service/service/CMakeLists.txt
@@ -0,0 +1,8 @@
+project(win_service)
+
+file(GLOB SRC_FILES ./*.cpp)
+file(GLOB HEAD_FILES ./*.h)
+
+add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
+
+target_link_libraries(${PROJECT_NAME} ipc)
diff --git a/demo/win_service/service/main.cpp b/demo/win_service/service/main.cpp
new file mode 100644
index 00000000..109c5603
--- /dev/null
+++ b/demo/win_service/service/main.cpp
@@ -0,0 +1,189 @@
+/// \brief To create a basic Windows Service in C++.
+/// \see https://www.codeproject.com/Articles/499465/Simple-Windows-Service-in-Cplusplus
+
+#include <Windows.h>
+#include <tchar.h>
+#include <string>
+
+#include "libipc/ipc.h"
+
+SERVICE_STATUS        g_ServiceStatus = {0};
+SERVICE_STATUS_HANDLE g_StatusHandle = NULL;
+HANDLE                g_ServiceStopEvent = INVALID_HANDLE_VALUE;
+
+VOID WINAPI ServiceMain (DWORD argc, LPTSTR *argv);
+VOID WINAPI ServiceCtrlHandler (DWORD);
+DWORD WINAPI ServiceWorkerThread (LPVOID lpParam);
+
+#define SERVICE_NAME  _T("My Sample Service")
+
+int _tmain (int argc, TCHAR *argv[]) {
+    OutputDebugString(_T("My Sample Service: Main: Entry"));
+
+    SERVICE_TABLE_ENTRY ServiceTable[] = {
+        {SERVICE_NAME, (LPSERVICE_MAIN_FUNCTION) ServiceMain},
+        {NULL, NULL}
+    };
+
+    if (StartServiceCtrlDispatcher (ServiceTable) == FALSE) {
+        OutputDebugString(_T("My Sample Service: Main: StartServiceCtrlDispatcher returned error"));
+        return GetLastError ();
+    }
+
+    OutputDebugString(_T("My Sample Service: Main: Exit"));
+    return 0;
+}
+
+VOID WINAPI ServiceMain (DWORD argc, LPTSTR *argv) {
+    DWORD Status = E_FAIL;
+
+    OutputDebugString(_T("My Sample Service: ServiceMain: Entry"));
+
+    g_StatusHandle = RegisterServiceCtrlHandler (SERVICE_NAME, ServiceCtrlHandler);
+
+    if (g_StatusHandle == NULL) {
+        OutputDebugString(_T("My Sample Service: ServiceMain: RegisterServiceCtrlHandler returned error"));
+        goto EXIT;
+    }
+
+    // Tell the service controller we are starting
+    ZeroMemory (&g_ServiceStatus, sizeof (g_ServiceStatus));
+    g_ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
+    g_ServiceStatus.dwControlsAccepted = 0;
+    g_ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
+    g_ServiceStatus.dwWin32ExitCode = 0;
+    g_ServiceStatus.dwServiceSpecificExitCode = 0;
+    g_ServiceStatus.dwCheckPoint = 0;
+
+    if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
+        OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
+    }
+
+    /* 
+     * Perform tasks neccesary to start the service here
+     */
+    OutputDebugString(_T("My Sample Service: ServiceMain: Performing Service Start Operations"));
+
+    // Create stop event to wait on later.
+    g_ServiceStopEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
+    if (g_ServiceStopEvent == NULL) {
+        OutputDebugString(_T("My Sample Service: ServiceMain: CreateEvent(g_ServiceStopEvent) returned error"));
+
+        g_ServiceStatus.dwControlsAccepted = 0;
+        g_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
+        g_ServiceStatus.dwWin32ExitCode = GetLastError();
+        g_ServiceStatus.dwCheckPoint = 1;
+
+        if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
+		    OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
+	    }
+        goto EXIT; 
+    }    
+
+    // Tell the service controller we are started
+    g_ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
+    g_ServiceStatus.dwCurrentState = SERVICE_RUNNING;
+    g_ServiceStatus.dwWin32ExitCode = 0;
+    g_ServiceStatus.dwCheckPoint = 0;
+
+    if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
+	    OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
+    }
+
+    // Start the thread that will perform the main task of the service
+    HANDLE hThread = CreateThread (NULL, 0, ServiceWorkerThread, NULL, 0, NULL);
+
+    OutputDebugString(_T("My Sample Service: ServiceMain: Waiting for Worker Thread to complete"));
+
+    // Wait until our worker thread exits effectively signaling that the service needs to stop
+    WaitForSingleObject (hThread, INFINITE);
+    
+    OutputDebugString(_T("My Sample Service: ServiceMain: Worker Thread Stop Event signaled"));
+    
+    
+    /* 
+     * Perform any cleanup tasks
+     */
+    OutputDebugString(_T("My Sample Service: ServiceMain: Performing Cleanup Operations"));
+
+    CloseHandle (g_ServiceStopEvent);
+
+    g_ServiceStatus.dwControlsAccepted = 0;
+    g_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
+    g_ServiceStatus.dwWin32ExitCode = 0;
+    g_ServiceStatus.dwCheckPoint = 3;
+
+    if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
+	    OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
+    }
+    
+EXIT:
+    OutputDebugString(_T("My Sample Service: ServiceMain: Exit"));
+    return;
+}
+
+VOID WINAPI ServiceCtrlHandler (DWORD CtrlCode) {
+    OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: Entry"));
+
+    switch (CtrlCode) {
+    case SERVICE_CONTROL_STOP :
+
+        OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: SERVICE_CONTROL_STOP Request"));
+
+        if (g_ServiceStatus.dwCurrentState != SERVICE_RUNNING)
+           break;
+
+        /* 
+         * Perform tasks neccesary to stop the service here 
+         */
+        
+        g_ServiceStatus.dwControlsAccepted = 0;
+        g_ServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
+        g_ServiceStatus.dwWin32ExitCode = 0;
+        g_ServiceStatus.dwCheckPoint = 4;
+
+        if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
+			OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: SetServiceStatus returned error"));
+		}
+
+        // This will signal the worker thread to start shutting down
+        SetEvent (g_ServiceStopEvent);
+
+        break;
+
+    default:
+        break;
+    }
+
+    OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: Exit"));
+}
+
+DWORD WINAPI ServiceWorkerThread (LPVOID lpParam) {
+    OutputDebugString(_T("My Sample Service: ServiceWorkerThread: Entry"));
+    ipc::channel ipc_r{"service ipc r", ipc::sender};
+    ipc::channel ipc_w{"service ipc w", ipc::receiver};
+
+    //  Periodically check if the service has been requested to stop
+    while (WaitForSingleObject(g_ServiceStopEvent, 0) != WAIT_OBJECT_0) {        
+        /* 
+         * Perform main service function here
+         */
+        if (!ipc_r.send("Hello, World!")) {
+            OutputDebugString(_T("My Sample Service: send failed."));
+        }
+        else {
+            OutputDebugString(_T("My Sample Service: send [Hello, World!]"));
+            auto msg = ipc_w.recv(1000);
+            if (msg.empty()) {
+                OutputDebugString(_T("My Sample Service: recv error"));
+            } else {
+                OutputDebugStringA((std::string{"My Sample Service: recv ["} + msg.get<char const *>() + "]").c_str());
+            }
+        }
+        Sleep(3000);
+    }
+
+    OutputDebugString(_T("My Sample Service: ServiceWorkerThread: Exit"));
+
+    return ERROR_SUCCESS;
+}
diff --git a/src/libipc/platform/win/mutex.h b/src/libipc/platform/win/mutex.h
index 8ecaf476..97f4a64c 100644
--- a/src/libipc/platform/win/mutex.h
+++ b/src/libipc/platform/win/mutex.h
@@ -33,7 +33,7 @@ class mutex {
 
     bool open(char const *name) noexcept {
         close();
-        h_ = ::CreateMutex(detail::get_sa(), FALSE, ipc::detail::to_tchar(name).c_str());
+        h_ = ::CreateMutex(detail::get_sa(), FALSE, ipc::detail::to_tchar(ipc::string{"Global\\"} + name).c_str());
         if (h_ == NULL) {
             ipc::error("fail CreateMutex[%lu]: %s\n", ::GetLastError(), name);
             return false;
diff --git a/src/libipc/platform/win/semaphore.h b/src/libipc/platform/win/semaphore.h
index 47fd45d1..b979ba3a 100644
--- a/src/libipc/platform/win/semaphore.h
+++ b/src/libipc/platform/win/semaphore.h
@@ -32,7 +32,7 @@ class semaphore {
         close();
         h_ = ::CreateSemaphore(detail::get_sa(), 
                                static_cast<LONG>(count), LONG_MAX, 
-                               ipc::detail::to_tchar(name).c_str());
+                               ipc::detail::to_tchar(ipc::string{"Global\\"} + name).c_str());
         if (h_ == NULL) {
             ipc::error("fail CreateSemaphore[%lu]: %s\n", ::GetLastError(), name);
             return false;
diff --git a/src/libipc/platform/win/shm_win.cpp b/src/libipc/platform/win/shm_win.cpp
index 366e8bd1..be3fd45c 100755
--- a/src/libipc/platform/win/shm_win.cpp
+++ b/src/libipc/platform/win/shm_win.cpp
@@ -33,7 +33,7 @@ id_t acquire(char const * name, std::size_t size, unsigned mode) {
         return nullptr;
     }
     HANDLE h;
-    auto fmt_name = ipc::detail::to_tchar(ipc::string{"__IPC_SHM__"} + name);
+    auto fmt_name = ipc::detail::to_tchar(ipc::string{"Global\\__IPC_SHM__"} + name);
     // Opens a named file mapping object.
     if (mode == open) {
         h = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, fmt_name.c_str());

From b6c25760cfecd921e2293522119fb5005152ac4a Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sat, 23 Sep 2023 14:19:12 +0800
Subject: [PATCH 03/14] Supplement similar demo under linux.

---
 CMakeLists.txt                            |  3 ++
 demo/linux_service/client/CMakeLists.txt  |  8 ++++++
 demo/linux_service/client/main.cpp        | 28 ++++++++++++++++++
 demo/linux_service/service/CMakeLists.txt |  8 ++++++
 demo/linux_service/service/main.cpp       | 35 +++++++++++++++++++++++
 src/libipc/platform/posix/shm_posix.cpp   |  4 ++-
 6 files changed, 85 insertions(+), 1 deletion(-)
 create mode 100644 demo/linux_service/client/CMakeLists.txt
 create mode 100644 demo/linux_service/client/main.cpp
 create mode 100644 demo/linux_service/service/CMakeLists.txt
 create mode 100644 demo/linux_service/service/main.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 12cebd4e..7e07dd3c 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -62,6 +62,9 @@ if (LIBIPC_BUILD_DEMOS)
     if (MSVC)
         add_subdirectory(demo/win_service/service)
         add_subdirectory(demo/win_service/client)
+    else()
+        add_subdirectory(demo/linux_service/service)
+        add_subdirectory(demo/linux_service/client)
     endif()
 endif()
 
diff --git a/demo/linux_service/client/CMakeLists.txt b/demo/linux_service/client/CMakeLists.txt
new file mode 100644
index 00000000..b7d83920
--- /dev/null
+++ b/demo/linux_service/client/CMakeLists.txt
@@ -0,0 +1,8 @@
+project(linux_client)
+
+file(GLOB SRC_FILES ./*.cpp)
+file(GLOB HEAD_FILES ./*.h)
+
+add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
+
+target_link_libraries(${PROJECT_NAME} ipc)
diff --git a/demo/linux_service/client/main.cpp b/demo/linux_service/client/main.cpp
new file mode 100644
index 00000000..9839be92
--- /dev/null
+++ b/demo/linux_service/client/main.cpp
@@ -0,0 +1,28 @@
+/// \brief To create a basic command line program.
+
+#include <stdio.h>
+#include <thread>
+#include <chrono>
+
+#include "libipc/ipc.h"
+
+int main(int argc, char *argv[]) {
+    printf("My Sample Client: Entry\n");
+    ipc::channel ipc_r{"service ipc r", ipc::receiver};
+    ipc::channel ipc_w{"service ipc w", ipc::sender};
+    while (1) {
+        auto msg = ipc_r.recv();
+        if (msg.empty()) {
+            printf("My Sample Client: message recv error\n");
+            return -1;
+        }
+        printf("My Sample Client: message recv: [%s]\n", (char const *)msg.data());
+        while (!ipc_w.send("Copy.")) {
+            printf("My Sample Client: message send error\n");
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+        }
+        printf("My Sample Client: message send [Copy]\n");
+    }
+    printf("My Sample Client: Exit\n");
+    return 0;
+}
diff --git a/demo/linux_service/service/CMakeLists.txt b/demo/linux_service/service/CMakeLists.txt
new file mode 100644
index 00000000..a8773377
--- /dev/null
+++ b/demo/linux_service/service/CMakeLists.txt
@@ -0,0 +1,8 @@
+project(linux_service)
+
+file(GLOB SRC_FILES ./*.cpp)
+file(GLOB HEAD_FILES ./*.h)
+
+add_executable(${PROJECT_NAME} ${SRC_FILES} ${HEAD_FILES})
+
+target_link_libraries(${PROJECT_NAME} ipc)
diff --git a/demo/linux_service/service/main.cpp b/demo/linux_service/service/main.cpp
new file mode 100644
index 00000000..ec2f4a9a
--- /dev/null
+++ b/demo/linux_service/service/main.cpp
@@ -0,0 +1,35 @@
+/// \brief To create a basic Windows Service in C++.
+/// \see https://www.codeproject.com/Articles/499465/Simple-Windows-Service-in-Cplusplus
+
+#include <stdio.h>
+#include <string>
+#include <thread>
+#include <chrono>
+
+#include "libipc/ipc.h"
+
+int main(int argc, char *argv[]) {
+    printf("My Sample Service: Main: Entry\n");
+
+    ipc::channel ipc_r{"service ipc r", ipc::sender};
+    ipc::channel ipc_w{"service ipc w", ipc::receiver};
+
+    while (1) {
+        if (!ipc_r.send("Hello, World!")) {
+            printf("My Sample Service: send failed.\n");
+        }
+        else {
+            printf("My Sample Service: send [Hello, World!]\n");
+            auto msg = ipc_w.recv(1000);
+            if (msg.empty()) {
+                printf("My Sample Service: recv error\n");
+            } else {
+                printf("%s\n", (std::string{"My Sample Service: recv ["} + msg.get<char const *>() + "]").c_str());
+            }
+        }
+        std::this_thread::sleep_for(std::chrono::seconds(3));
+    }
+
+    printf("My Sample Service: Main: Exit\n");
+    return 0;
+}
diff --git a/src/libipc/platform/posix/shm_posix.cpp b/src/libipc/platform/posix/shm_posix.cpp
index 7f70b070..b0bfdef6 100644
--- a/src/libipc/platform/posix/shm_posix.cpp
+++ b/src/libipc/platform/posix/shm_posix.cpp
@@ -49,7 +49,9 @@ id_t acquire(char const * name, std::size_t size, unsigned mode) {
         ipc::error("fail acquire: name is empty\n");
         return nullptr;
     }
-    ipc::string op_name = ipc::string{"__IPC_SHM__"} + name;
+    // For portable use, a shared memory object should be identified by name of the form /somename.
+    // see: https://man7.org/linux/man-pages/man3/shm_open.3.html
+    ipc::string op_name = ipc::string{"/__IPC_SHM__"} + name;
     // Open the object for read-write access.
     int flag = O_RDWR;
     switch (mode) {

From 3824b8f6e22e3656d43597970a46e35d4864e363 Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sat, 23 Sep 2023 14:29:00 +0800
Subject: [PATCH 04/14] =?UTF-8?q?=E8=B0=83=E6=95=B4=E6=B3=A8=E9=87=8A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 demo/linux_service/service/main.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/demo/linux_service/service/main.cpp b/demo/linux_service/service/main.cpp
index ec2f4a9a..cf8dec37 100644
--- a/demo/linux_service/service/main.cpp
+++ b/demo/linux_service/service/main.cpp
@@ -1,5 +1,4 @@
-/// \brief To create a basic Windows Service in C++.
-/// \see https://www.codeproject.com/Articles/499465/Simple-Windows-Service-in-Cplusplus
+/// \brief To create a basic command line program.
 
 #include <stdio.h>
 #include <string>

From 8064e50bcf72b820264406ded489d0942f42bf81 Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sat, 23 Sep 2023 14:31:37 +0800
Subject: [PATCH 05/14] =?UTF-8?q?=E8=B0=83=E6=95=B4=E7=A9=BA=E7=99=BD?=
 =?UTF-8?q?=E6=A0=BC=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 demo/win_service/service/main.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/demo/win_service/service/main.cpp b/demo/win_service/service/main.cpp
index 109c5603..d61b08d5 100644
--- a/demo/win_service/service/main.cpp
+++ b/demo/win_service/service/main.cpp
@@ -75,8 +75,8 @@ VOID WINAPI ServiceMain (DWORD argc, LPTSTR *argv) {
         g_ServiceStatus.dwCheckPoint = 1;
 
         if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
-		    OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
-	    }
+            OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
+        }
         goto EXIT; 
     }    
 
@@ -87,7 +87,7 @@ VOID WINAPI ServiceMain (DWORD argc, LPTSTR *argv) {
     g_ServiceStatus.dwCheckPoint = 0;
 
     if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
-	    OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
+        OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
     }
 
     // Start the thread that will perform the main task of the service
@@ -114,7 +114,7 @@ VOID WINAPI ServiceMain (DWORD argc, LPTSTR *argv) {
     g_ServiceStatus.dwCheckPoint = 3;
 
     if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
-	    OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
+        OutputDebugString(_T("My Sample Service: ServiceMain: SetServiceStatus returned error"));
     }
     
 EXIT:
@@ -143,8 +143,8 @@ VOID WINAPI ServiceCtrlHandler (DWORD CtrlCode) {
         g_ServiceStatus.dwCheckPoint = 4;
 
         if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE) {
-			OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: SetServiceStatus returned error"));
-		}
+            OutputDebugString(_T("My Sample Service: ServiceCtrlHandler: SetServiceStatus returned error"));
+        }
 
         // This will signal the worker thread to start shutting down
         SetEvent (g_ServiceStopEvent);

From 1753178db8c6681d8db05a780a4a57199a32607b Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sat, 23 Sep 2023 19:15:52 +0800
Subject: [PATCH 06/14] Identify the user group and add the appropriate prefix
 to the names.

---
 src/libipc/platform/win/comfortable_prefix.h | 44 ++++++++++++++++++++
 src/libipc/platform/win/mutex.h              |  4 +-
 src/libipc/platform/win/semaphore.h          |  3 +-
 src/libipc/platform/win/shm_win.cpp          |  3 +-
 src/libipc/sync/condition.cpp                |  5 +++
 src/libipc/sync/mutex.cpp                    |  5 +++
 src/libipc/sync/semaphore.cpp                |  5 +++
 7 files changed, 66 insertions(+), 3 deletions(-)
 create mode 100644 src/libipc/platform/win/comfortable_prefix.h

diff --git a/src/libipc/platform/win/comfortable_prefix.h b/src/libipc/platform/win/comfortable_prefix.h
new file mode 100644
index 00000000..92f7ac18
--- /dev/null
+++ b/src/libipc/platform/win/comfortable_prefix.h
@@ -0,0 +1,44 @@
+#pragma once
+
+#include <Windows.h>
+
+#include "libipc/memory/resource.h"
+
+namespace ipc {
+namespace detail {
+
+/// \brief This routine returns `true` if the caller's process is a member of the Administrators local group. 
+///        Caller is NOT expected to be impersonating anyone and is expected to be able to open its own process and process token.
+/// \return true  - Caller has Administrators local group.
+///         false - Caller does not have Administrators local group.
+/// \see https://learn.microsoft.com/en-us/windows/win32/api/securitybaseapi/nf-securitybaseapi-checktokenmembership
+inline bool is_user_admin() {
+    SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
+    PSID AdministratorsGroup; 
+    BOOL b = AllocateAndInitializeSid(&NtAuthority,
+                                      2,
+                                      SECURITY_BUILTIN_DOMAIN_RID,
+                                      DOMAIN_ALIAS_RID_ADMINS,
+                                      0, 0, 0, 0, 0, 0,
+                                      &AdministratorsGroup); 
+    if (b) {
+        if (!CheckTokenMembership(NULL, AdministratorsGroup, &b)) {
+            b = FALSE;
+        }
+        FreeSid(AdministratorsGroup); 
+    }
+    return !!(b);
+}
+
+/// \brief Identify the user group and add the appropriate prefix to the string.
+/// \see http://msdn.microsoft.com/en-us/library/aa366551(v=VS.85).aspx
+///      https://stackoverflow.com/questions/3999157/system-error-0x5-createfilemapping
+inline ipc::string make_comfortable_prefix(ipc::string &&txt) {
+    if (is_user_admin()) {
+        return ipc::string{"Global\\"} + txt;
+    }
+    return txt;
+}
+
+} // namespace detail
+} // namespace ipc
diff --git a/src/libipc/platform/win/mutex.h b/src/libipc/platform/win/mutex.h
index 97f4a64c..49244d8b 100644
--- a/src/libipc/platform/win/mutex.h
+++ b/src/libipc/platform/win/mutex.h
@@ -9,6 +9,7 @@
 
 #include "to_tchar.h"
 #include "get_sa.h"
+#include "comfortable_prefix.h"
 
 namespace ipc {
 namespace detail {
@@ -33,7 +34,8 @@ class mutex {
 
     bool open(char const *name) noexcept {
         close();
-        h_ = ::CreateMutex(detail::get_sa(), FALSE, ipc::detail::to_tchar(ipc::string{"Global\\"} + name).c_str());
+        h_ = ::CreateMutex(detail::get_sa(), FALSE, 
+                           detail::to_tchar(detail::make_comfortable_prefix(name)).c_str());
         if (h_ == NULL) {
             ipc::error("fail CreateMutex[%lu]: %s\n", ::GetLastError(), name);
             return false;
diff --git a/src/libipc/platform/win/semaphore.h b/src/libipc/platform/win/semaphore.h
index b979ba3a..39184e97 100644
--- a/src/libipc/platform/win/semaphore.h
+++ b/src/libipc/platform/win/semaphore.h
@@ -8,6 +8,7 @@
 
 #include "to_tchar.h"
 #include "get_sa.h"
+#include "comfortable_prefix.h"
 
 namespace ipc {
 namespace detail {
@@ -32,7 +33,7 @@ class semaphore {
         close();
         h_ = ::CreateSemaphore(detail::get_sa(), 
                                static_cast<LONG>(count), LONG_MAX, 
-                               ipc::detail::to_tchar(ipc::string{"Global\\"} + name).c_str());
+                               detail::to_tchar(detail::make_comfortable_prefix(name)).c_str());
         if (h_ == NULL) {
             ipc::error("fail CreateSemaphore[%lu]: %s\n", ::GetLastError(), name);
             return false;
diff --git a/src/libipc/platform/win/shm_win.cpp b/src/libipc/platform/win/shm_win.cpp
index be3fd45c..c1718350 100755
--- a/src/libipc/platform/win/shm_win.cpp
+++ b/src/libipc/platform/win/shm_win.cpp
@@ -13,6 +13,7 @@
 
 #include "to_tchar.h"
 #include "get_sa.h"
+#include "comfortable_prefix.h"
 
 namespace {
 
@@ -33,7 +34,7 @@ id_t acquire(char const * name, std::size_t size, unsigned mode) {
         return nullptr;
     }
     HANDLE h;
-    auto fmt_name = ipc::detail::to_tchar(ipc::string{"Global\\__IPC_SHM__"} + name);
+    auto fmt_name = ipc::detail::to_tchar(detail::make_comfortable_prefix("__IPC_SHM__") + name);
     // Opens a named file mapping object.
     if (mode == open) {
         h = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, fmt_name.c_str());
diff --git a/src/libipc/sync/condition.cpp b/src/libipc/sync/condition.cpp
index 06d90e19..b97d09be 100644
--- a/src/libipc/sync/condition.cpp
+++ b/src/libipc/sync/condition.cpp
@@ -2,6 +2,7 @@
 #include "libipc/condition.h"
 
 #include "libipc/utility/pimpl.h"
+#include "libipc/utility/log.h"
 #include "libipc/memory/resource.h"
 #include "libipc/platform/detail.h"
 #if defined(IPC_OS_WINDOWS_)
@@ -49,6 +50,10 @@ bool condition::valid() const noexcept {
 }
 
 bool condition::open(char const *name) noexcept {
+    if (name == nullptr || name[0] == '\0') {
+        ipc::error("fail condition open: name is empty\n");
+        return false;
+    }
     return impl(p_)->cond_.open(name);
 }
 
diff --git a/src/libipc/sync/mutex.cpp b/src/libipc/sync/mutex.cpp
index 79f1a910..40aad651 100644
--- a/src/libipc/sync/mutex.cpp
+++ b/src/libipc/sync/mutex.cpp
@@ -2,6 +2,7 @@
 #include "libipc/mutex.h"
 
 #include "libipc/utility/pimpl.h"
+#include "libipc/utility/log.h"
 #include "libipc/memory/resource.h"
 #include "libipc/platform/detail.h"
 #if defined(IPC_OS_WINDOWS_)
@@ -49,6 +50,10 @@ bool mutex::valid() const noexcept {
 }
 
 bool mutex::open(char const *name) noexcept {
+    if (name == nullptr || name[0] == '\0') {
+        ipc::error("fail mutex open: name is empty\n");
+        return false;
+    }
     return impl(p_)->lock_.open(name);
 }
 
diff --git a/src/libipc/sync/semaphore.cpp b/src/libipc/sync/semaphore.cpp
index 23f6bdce..33539f10 100644
--- a/src/libipc/sync/semaphore.cpp
+++ b/src/libipc/sync/semaphore.cpp
@@ -2,6 +2,7 @@
 #include "libipc/semaphore.h"
 
 #include "libipc/utility/pimpl.h"
+#include "libipc/utility/log.h"
 #include "libipc/memory/resource.h"
 #include "libipc/platform/detail.h"
 #if defined(IPC_OS_WINDOWS_)
@@ -47,6 +48,10 @@ bool semaphore::valid() const noexcept {
 }
 
 bool semaphore::open(char const *name, std::uint32_t count) noexcept {
+    if (name == nullptr || name[0] == '\0') {
+        ipc::error("fail semaphore open: name is empty\n");
+        return false;
+    }
     return impl(p_)->sem_.open(name, count);
 }
 

From e99fe22e9c27005a43db2a94ee36fd3f7a1591e0 Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sat, 23 Sep 2023 21:38:47 +0800
Subject: [PATCH 07/14] =?UTF-8?q?=E5=BE=AE=E8=B0=83=E6=B3=A8=E9=87=8A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 include/libipc/ipc.h | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/include/libipc/ipc.h b/include/libipc/ipc.h
index 882367c8..99a6b100 100755
--- a/include/libipc/ipc.h
+++ b/include/libipc/ipc.h
@@ -169,26 +169,22 @@ template <relat Rp, relat Rc, trans Ts>
 using chan = chan_wrapper<ipc::wr<Rp, Rc, Ts>>;
 
 /**
- * class route
+ * \class route
  *
- * You could use one producer/server/sender for sending messages to a route,
- * then all the consumers/clients/receivers which are receiving with this route,
- * would receive your sent messages.
- *
- * A route could only be used in 1 to N
- * (one producer/writer to multi consumers/readers)
+ * \note You could use one producer/server/sender for sending messages to a route,
+ *       then all the consumers/clients/receivers which are receiving with this route,
+ *       would receive your sent messages.
+ *       A route could only be used in 1 to N (one producer/writer to multi consumers/readers).
 */
-
 using route = chan<relat::single, relat::multi, trans::broadcast>;
 
 /**
- * class channel
+ * \class channel
  *
- * You could use multi producers/writers for sending messages to a channel,
- * then all the consumers/readers which are receiving with this channel,
- * would receive your sent messages.
+ * \note You could use multi producers/writers for sending messages to a channel,
+ *       then all the consumers/readers which are receiving with this channel,
+ *       would receive your sent messages.
 */
-
 using channel = chan<relat::multi, relat::multi, trans::broadcast>;
 
 } // namespace ipc

From 6d4cf141325acbdcd565a7d55e109285c63f45fc Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sun, 24 Sep 2023 14:25:46 +0800
Subject: [PATCH 08/14] Check illegal parameter.

---
 src/libipc/shm.cpp | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/libipc/shm.cpp b/src/libipc/shm.cpp
index 92f96ef4..c8763a84 100755
--- a/src/libipc/shm.cpp
+++ b/src/libipc/shm.cpp
@@ -5,6 +5,7 @@
 #include "libipc/shm.h"
 
 #include "libipc/utility/pimpl.h"
+#include "libipc/utility/log.h"
 #include "libipc/memory/resource.h"
 
 namespace ipc {
@@ -68,8 +69,17 @@ void handle::sub_ref() noexcept {
 }
 
 bool handle::acquire(char const * name, std::size_t size, unsigned mode) {
+    if (name == nullptr || name[0] == '\0') {
+        ipc::error("fail acquire: name is empty\n");
+        return false;
+    }
+    if (size == 0) {
+        ipc::error("fail acquire: size is 0\n");
+        return false;
+    }
     release();
-    impl(p_)->id_ = shm::acquire((impl(p_)->n_ = name).c_str(), size, mode);
+    impl(p_)->n_  = name;
+    impl(p_)->id_ = shm::acquire(name, size, mode);
     impl(p_)->m_  = shm::get_mem(impl(p_)->id_, &(impl(p_)->s_));
     return valid();
 }

From 21648c5f47c46ecd41fc4941bc6495d5f9ebab37 Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sun, 24 Sep 2023 15:42:10 +0800
Subject: [PATCH 09/14] Add a user interface with a custom name prefix.

---
 include/libipc/def.h                         |   5 +
 include/libipc/ipc.h                         |  10 +
 src/libipc/circ/elem_array.h                 |   4 +-
 src/libipc/ipc.cpp                           | 188 +++++++++++--------
 src/libipc/memory/resource.h                 |  20 ++
 src/libipc/platform/detail.h                 |   3 +-
 src/libipc/platform/posix/shm_posix.cpp      |  13 +-
 src/libipc/platform/win/comfortable_prefix.h |  44 -----
 src/libipc/platform/win/condition.h          |   2 +-
 src/libipc/platform/win/mutex.h              |   4 +-
 src/libipc/platform/win/semaphore.h          |   3 +-
 src/libipc/platform/win/shm_win.cpp          |   3 +-
 src/libipc/platform/win/to_tchar.h           |   4 +-
 13 files changed, 160 insertions(+), 143 deletions(-)
 delete mode 100644 src/libipc/platform/win/comfortable_prefix.h

diff --git a/include/libipc/def.h b/include/libipc/def.h
index 8c1a72ba..45cd7801 100755
--- a/include/libipc/def.h
+++ b/include/libipc/def.h
@@ -65,4 +65,9 @@ struct relat_trait<wr<Rp, Rc, Ts>> {
 template <template <typename> class Policy, typename Flag>
 struct relat_trait<Policy<Flag>> : relat_trait<Flag> {};
 
+// the prefix tag of a channel
+struct prefix {
+    char const *str;
+};
+
 } // namespace ipc
diff --git a/include/libipc/ipc.h b/include/libipc/ipc.h
index 99a6b100..881ef260 100755
--- a/include/libipc/ipc.h
+++ b/include/libipc/ipc.h
@@ -22,6 +22,7 @@ struct IPC_EXPORT chan_impl {
     static ipc::handle_t inited();
 
     static bool connect   (ipc::handle_t * ph, char const * name, unsigned mode);
+    static bool connect   (ipc::handle_t * ph, prefix, char const * name, unsigned mode);
     static bool reconnect (ipc::handle_t * ph, unsigned mode);
     static void disconnect(ipc::handle_t h);
     static void destroy   (ipc::handle_t h);
@@ -54,6 +55,10 @@ class chan_wrapper {
         : connected_{this->connect(name, mode)} {
     }
 
+    chan_wrapper(prefix pref, char const * name, unsigned mode = ipc::sender)
+        : connected_{this->connect(pref, name, mode)} {
+    }
+
     chan_wrapper(chan_wrapper&& rhs) noexcept
         : chan_wrapper{} {
         swap(rhs);
@@ -102,6 +107,11 @@ class chan_wrapper {
         detail_t::disconnect(h_); // clear old connection
         return connected_ = detail_t::connect(&h_, name, mode_ = mode);
     }
+    bool connect(prefix pref, char const * name, unsigned mode = ipc::sender | ipc::receiver) {
+        if (name == nullptr || name[0] == '\0') return false;
+        detail_t::disconnect(h_); // clear old connection
+        return connected_ = detail_t::connect(&h_, pref, name, mode_ = mode);
+    }
 
     /**
      * Try connecting with new mode flags.
diff --git a/src/libipc/circ/elem_array.h b/src/libipc/circ/elem_array.h
index 0b21f486..adadf941 100755
--- a/src/libipc/circ/elem_array.h
+++ b/src/libipc/circ/elem_array.h
@@ -37,8 +37,8 @@ class elem_array : public ipc::circ::conn_head<Policy> {
     elem_t   block_[elem_max] {};
 
     /**
-     * @remarks 'warning C4348: redefinition of default parameter' with MSVC.
-     * @see
+     * \remarks 'warning C4348: redefinition of default parameter' with MSVC.
+     * \see
      *  - https://stackoverflow.com/questions/12656239/redefinition-of-default-template-parameter
      *  - https://developercommunity.visualstudio.com/content/problem/425978/incorrect-c4348-warning-in-nested-template-declara.html
     */
diff --git a/src/libipc/ipc.cpp b/src/libipc/ipc.cpp
index f09f9725..a892c486 100755
--- a/src/libipc/ipc.cpp
+++ b/src/libipc/ipc.cpp
@@ -69,6 +69,11 @@ ipc::buff_t make_cache(T& data, std::size_t size) {
     return { ptr, size, ipc::mem::free };
 }
 
+acc_t *cc_acc() {
+    static ipc::shm::handle acc_h("__CA_CONN__", sizeof(acc_t));
+    return static_cast<acc_t *>(acc_h.get());
+}
+
 struct cache_t {
     std::size_t fill_;
     ipc::buff_t buff_;
@@ -85,10 +90,39 @@ struct cache_t {
     }
 };
 
-auto cc_acc() {
-    static ipc::shm::handle acc_h("__CA_CONN__", sizeof(acc_t));
-    return static_cast<acc_t*>(acc_h.get());
-}
+struct conn_info_head {
+
+    ipc::string prefix_;
+    ipc::string name_;
+    msg_id_t    cc_id_; // connection-info id
+    ipc::detail::waiter cc_waiter_, wt_waiter_, rd_waiter_;
+    ipc::shm::handle acc_h_;
+
+    conn_info_head(char const * prefix, char const * name)
+        : prefix_   {ipc::make_string(prefix)}
+        , name_     {ipc::make_string(name)}
+        , cc_id_    {(cc_acc() == nullptr) ? 0 : cc_acc()->fetch_add(1, std::memory_order_relaxed)}
+        , cc_waiter_{ipc::make_prefix(prefix_, {"CC_CONN__", name_}).c_str()}
+        , wt_waiter_{ipc::make_prefix(prefix_, {"WT_CONN__", name_}).c_str()}
+        , rd_waiter_{ipc::make_prefix(prefix_, {"RD_CONN__", name_}).c_str()}
+        , acc_h_    {ipc::make_prefix(prefix_, {"AC_CONN__", name_}).c_str(), sizeof(acc_t)} {
+    }
+
+    void quit_waiting() {
+        cc_waiter_.quit_waiting();
+        wt_waiter_.quit_waiting();
+        rd_waiter_.quit_waiting();
+    }
+
+    auto acc() {
+        return static_cast<acc_t*>(acc_h_.get());
+    }
+
+    auto& recv_cache() {
+        thread_local ipc::unordered_map<msg_id_t, cache_t> tls;
+        return tls;
+    }
+};
 
 IPC_CONSTEXPR_ std::size_t align_chunk_size(std::size_t size) noexcept {
     return (((size - 1) / ipc::large_msg_align) + 1) * ipc::large_msg_align;
@@ -130,17 +164,27 @@ struct chunk_info_t {
 
 auto& chunk_storages() {
     class chunk_handle_t {
-        ipc::shm::handle handle_;
+        ipc::unordered_map<ipc::string, ipc::shm::handle> handles_;
 
-    public:
-        chunk_info_t *get_info(std::size_t chunk_size) {
-            if (!handle_.valid() &&
-                !handle_.acquire( ("__CHUNK_INFO__" + ipc::to_string(chunk_size)).c_str(), 
-                                  sizeof(chunk_info_t) + chunk_info_t::chunks_mem_size(chunk_size) )) {
+        static bool make_handle(ipc::shm::handle &h, ipc::string const &shm_name, std::size_t chunk_size) {
+            if (!h.valid() &&
+                !h.acquire( shm_name.c_str(), 
+                            sizeof(chunk_info_t) + chunk_info_t::chunks_mem_size(chunk_size) )) {
                 ipc::error("[chunk_storages] chunk_shm.id_info_.acquire failed: chunk_size = %zd\n", chunk_size);
+                return false;
+            }
+            return true;
+        }
+
+    public:
+        chunk_info_t *get_info(conn_info_head *inf, std::size_t chunk_size) {
+            ipc::string pref {(inf == nullptr) ? ipc::string{} : inf->prefix_};
+            ipc::string shm_name {ipc::make_prefix(pref, {"CHUNK_INFO__", ipc::to_string(chunk_size)})};
+            ipc::shm::handle &h = handles_[pref];
+            if (!make_handle(h, shm_name, chunk_size)) {
                 return nullptr;
             }
-            auto info = static_cast<chunk_info_t*>(handle_.get());
+            auto *info = static_cast<chunk_info_t*>(h.get());
             if (info == nullptr) {
                 ipc::error("[chunk_storages] chunk_shm.id_info_.get failed: chunk_size = %zd\n", chunk_size);
                 return nullptr;
@@ -152,7 +196,7 @@ auto& chunk_storages() {
     return chunk_hs;
 }
 
-chunk_info_t *chunk_storage_info(std::size_t chunk_size) {
+chunk_info_t *chunk_storage_info(conn_info_head *inf, std::size_t chunk_size) {
     auto &storages = chunk_storages();
     std::decay_t<decltype(storages)>::iterator it;
     {
@@ -165,12 +209,12 @@ chunk_info_t *chunk_storage_info(std::size_t chunk_size) {
             it = storages.emplace(chunk_size, chunk_handle_t{}).first;
         }
     }
-    return it->second.get_info(chunk_size);
+    return it->second.get_info(inf, chunk_size);
 }
 
-std::pair<ipc::storage_id_t, void*> acquire_storage(std::size_t size, ipc::circ::cc_t conns) {
+std::pair<ipc::storage_id_t, void*> acquire_storage(conn_info_head *inf, std::size_t size, ipc::circ::cc_t conns) {
     std::size_t chunk_size = calc_chunk_size(size);
-    auto info = chunk_storage_info(chunk_size);
+    auto info = chunk_storage_info(inf, chunk_size);
     if (info == nullptr) return {};
 
     info->lock_.lock();
@@ -185,24 +229,24 @@ std::pair<ipc::storage_id_t, void*> acquire_storage(std::size_t size, ipc::circ:
     return { id, chunk->data() };
 }
 
-void *find_storage(ipc::storage_id_t id, std::size_t size) {
+void *find_storage(ipc::storage_id_t id, conn_info_head *inf, std::size_t size) {
     if (id < 0) {
         ipc::error("[find_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
         return nullptr;
     }
     std::size_t chunk_size = calc_chunk_size(size);
-    auto info = chunk_storage_info(chunk_size);
+    auto info = chunk_storage_info(inf, chunk_size);
     if (info == nullptr) return nullptr;
     return info->at(chunk_size, id)->data();
 }
 
-void release_storage(ipc::storage_id_t id, std::size_t size) {
+void release_storage(ipc::storage_id_t id, conn_info_head *inf, std::size_t size) {
     if (id < 0) {
         ipc::error("[release_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
         return;
     }
     std::size_t chunk_size = calc_chunk_size(size);
-    auto info = chunk_storage_info(chunk_size);
+    auto info = chunk_storage_info(inf, chunk_size);
     if (info == nullptr) return;
     info->lock_.lock();
     info->pool_.release(id);
@@ -229,13 +273,13 @@ bool sub_rc(ipc::wr<Rp, Rc, ipc::trans::broadcast>,
 }
 
 template <typename Flag>
-void recycle_storage(ipc::storage_id_t id, std::size_t size, ipc::circ::cc_t curr_conns, ipc::circ::cc_t conn_id) {
+void recycle_storage(ipc::storage_id_t id, conn_info_head *inf, std::size_t size, ipc::circ::cc_t curr_conns, ipc::circ::cc_t conn_id) {
     if (id < 0) {
         ipc::error("[recycle_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
         return;
     }
     std::size_t chunk_size = calc_chunk_size(size);
-    auto info = chunk_storage_info(chunk_size);
+    auto info = chunk_storage_info(inf, chunk_size);
     if (info == nullptr) return;
 
     auto chunk = info->at(chunk_size, id);
@@ -250,7 +294,7 @@ void recycle_storage(ipc::storage_id_t id, std::size_t size, ipc::circ::cc_t cur
 }
 
 template <typename MsgT>
-bool clear_message(void* p) {
+bool clear_message(conn_info_head *inf, void* p) {
     auto msg = static_cast<MsgT*>(p);
     if (msg->storage_) {
         std::int32_t r_size = static_cast<std::int32_t>(ipc::data_length) + msg->remain_;
@@ -258,45 +302,12 @@ bool clear_message(void* p) {
             ipc::error("[clear_message] invalid msg size: %d\n", (int)r_size);
             return true;
         }
-        release_storage(
-            *reinterpret_cast<ipc::storage_id_t*>(&msg->data_),
-            static_cast<std::size_t>(r_size));
+        release_storage(*reinterpret_cast<ipc::storage_id_t*>(&msg->data_),
+                        inf, static_cast<std::size_t>(r_size));
     }
     return true;
 }
 
-struct conn_info_head {
-
-    ipc::string name_;
-    msg_id_t    cc_id_; // connection-info id
-    ipc::detail::waiter cc_waiter_, wt_waiter_, rd_waiter_;
-    ipc::shm::handle acc_h_;
-
-    conn_info_head(char const * name)
-        : name_     {name}
-        , cc_id_    {(cc_acc() == nullptr) ? 0 : cc_acc()->fetch_add(1, std::memory_order_relaxed)}
-        , cc_waiter_{("__CC_CONN__" + name_).c_str()}
-        , wt_waiter_{("__WT_CONN__" + name_).c_str()}
-        , rd_waiter_{("__RD_CONN__" + name_).c_str()}
-        , acc_h_    {("__AC_CONN__" + name_).c_str(), sizeof(acc_t)} {
-    }
-
-    void quit_waiting() {
-        cc_waiter_.quit_waiting();
-        wt_waiter_.quit_waiting();
-        rd_waiter_.quit_waiting();
-    }
-
-    auto acc() {
-        return static_cast<acc_t*>(acc_h_.get());
-    }
-
-    auto& recv_cache() {
-        thread_local ipc::unordered_map<msg_id_t, cache_t> tls;
-        return tls;
-    }
-};
-
 template <typename W, typename F>
 bool wait_for(W& waiter, F&& pred, std::uint64_t tm) {
     if (tm == 0) return !pred();
@@ -322,11 +333,13 @@ struct queue_generator {
     struct conn_info_t : conn_info_head {
         queue_t que_;
 
-        conn_info_t(char const * name)
-            : conn_info_head{name}
-            , que_{("__QU_CONN__" +
-                    ipc::to_string(DataSize) + "__" +
-                    ipc::to_string(AlignSize) + "__" + name).c_str()} {
+        conn_info_t(char const * pref, char const * name)
+            : conn_info_head{pref, name}
+            , que_{ipc::make_prefix(prefix_, {
+                    "QU_CONN__",
+                    ipc::to_string(DataSize), "__",
+                    ipc::to_string(AlignSize), "__", 
+                    name}).c_str()} {
         }
 
         void disconnect_receiver() {
@@ -389,14 +402,18 @@ static bool reconnect(ipc::handle_t * ph, bool start_to_recv) {
     return que->ready_sending();
 }
 
-static bool connect(ipc::handle_t * ph, char const * name, bool start_to_recv) {
+static bool connect(ipc::handle_t * ph, ipc::prefix pref, char const * name, bool start_to_recv) {
     assert(ph != nullptr);
     if (*ph == nullptr) {
-        *ph = ipc::mem::alloc<conn_info_t>(name);
+        *ph = ipc::mem::alloc<conn_info_t>(pref.str, name);
     }
     return reconnect(ph, start_to_recv);
 }
 
+static bool connect(ipc::handle_t * ph, char const * name, bool start_to_recv) {
+    return connect(ph, {nullptr}, name, start_to_recv);
+}
+
 static void destroy(ipc::handle_t h) {
     disconnect(h);
     ipc::mem::free(info_of(h));
@@ -445,15 +462,16 @@ static bool send(F&& gen_push, ipc::handle_t h, void const * data, std::size_t s
         return false;
     }
     // calc a new message id
-    auto acc = info_of(h)->acc();
+    conn_info_t *inf = info_of(h);
+    auto acc = inf->acc();
     if (acc == nullptr) {
         ipc::error("fail: send, info_of(h)->acc() == nullptr\n");
         return false;
     }
     auto msg_id   = acc->fetch_add(1, std::memory_order_relaxed);
-    auto try_push = std::forward<F>(gen_push)(info_of(h), que, msg_id);
+    auto try_push = std::forward<F>(gen_push)(inf, que, msg_id);
     if (size > ipc::large_msg_limit) {
-        auto   dat = acquire_storage(size, conns);
+        auto   dat = acquire_storage(inf, size, conns);
         void * buf = dat.second;
         if (buf != nullptr) {
             std::memcpy(buf, data, size);
@@ -484,7 +502,7 @@ static bool send(F&& gen_push, ipc::handle_t h, void const * data, std::size_t s
 }
 
 static bool send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
-    return send([tm](auto info, auto que, auto msg_id) {
+    return send([tm](auto *info, auto *que, auto msg_id) {
         return [tm, info, que, msg_id](std::int32_t remain, void const * data, std::size_t size) {
             if (!wait_for(info->wt_waiter_, [&] {
                     return !que->push(
@@ -493,7 +511,7 @@ static bool send(ipc::handle_t h, void const * data, std::size_t size, std::uint
                 }, tm)) {
                 ipc::log("force_push: msg_id = %zd, remain = %d, size = %zd\n", msg_id, remain, size);
                 if (!que->force_push(
-                        clear_message<typename queue_t::value_t>,
+                        [info](void* p) { return clear_message<typename queue_t::value_t>(info, p); },
                         info->cc_id_, msg_id, remain, data, size)) {
                     return false;
                 }
@@ -505,7 +523,7 @@ static bool send(ipc::handle_t h, void const * data, std::size_t size, std::uint
 }
 
 static bool try_send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
-    return send([tm](auto info, auto que, auto msg_id) {
+    return send([tm](auto *info, auto *que, auto msg_id) {
         return [tm, info, que, msg_id](std::int32_t remain, void const * data, std::size_t size) {
             if (!wait_for(info->wt_waiter_, [&] {
                     return !que->push(
@@ -530,18 +548,19 @@ static ipc::buff_t recv(ipc::handle_t h, std::uint64_t tm) {
         // hasn't connected yet, just return.
         return {};
     }
-    auto& rc = info_of(h)->recv_cache();
+    conn_info_t *inf = info_of(h);
+    auto& rc = inf->recv_cache();
     for (;;) {
         // pop a new message
         typename queue_t::value_t msg {};
-        if (!wait_for(info_of(h)->rd_waiter_, [que, &msg] {
+        if (!wait_for(inf->rd_waiter_, [que, &msg] {
                 return !que->pop(msg);
             }, tm)) {
             // pop failed, just return.
             return {};
         }
-        info_of(h)->wt_waiter_.broadcast();
-        if ((info_of(h)->acc() != nullptr) && (msg.cc_id_ == info_of(h)->cc_id_)) {
+        inf->wt_waiter_.broadcast();
+        if ((inf->acc() != nullptr) && (msg.cc_id_ == inf->cc_id_)) {
             continue; // ignore message to self
         }
         // msg.remain_ may minus & abs(msg.remain_) < data_length
@@ -554,14 +573,18 @@ static ipc::buff_t recv(ipc::handle_t h, std::uint64_t tm) {
         // large message
         if (msg.storage_) {
             ipc::storage_id_t buf_id = *reinterpret_cast<ipc::storage_id_t*>(&msg.data_);
-            void* buf = find_storage(buf_id, msg_size);
+            void* buf = find_storage(buf_id, inf, msg_size);
             if (buf != nullptr) {
                 struct recycle_t {
                     ipc::storage_id_t storage_id;
+                    conn_info_t *     inf;
                     ipc::circ::cc_t   curr_conns;
                     ipc::circ::cc_t   conn_id;
                 } *r_info = ipc::mem::alloc<recycle_t>(recycle_t{
-                    buf_id, que->elems()->connections(std::memory_order_relaxed), que->connected_id()
+                    buf_id, 
+                    inf, 
+                    que->elems()->connections(std::memory_order_relaxed), 
+                    que->connected_id()
                 });
                 if (r_info == nullptr) {
                     ipc::log("fail: ipc::mem::alloc<recycle_t>.\n");
@@ -572,7 +595,11 @@ static ipc::buff_t recv(ipc::handle_t h, std::uint64_t tm) {
                         IPC_UNUSED_ auto finally = ipc::guard([r_info] {
                             ipc::mem::free(r_info);
                         });
-                        recycle_storage<flag_t>(r_info->storage_id, size, r_info->curr_conns, r_info->conn_id);
+                        recycle_storage<flag_t>(r_info->storage_id, 
+                                                r_info->inf, 
+                                                size, 
+                                                r_info->curr_conns, 
+                                                r_info->conn_id);
                     }, r_info};
                 }
             } else {
@@ -641,6 +668,11 @@ bool chan_impl<Flag>::connect(ipc::handle_t * ph, char const * name, unsigned mo
     return detail_impl<policy_t<Flag>>::connect(ph, name, mode & receiver);
 }
 
+template <typename Flag>
+bool chan_impl<Flag>::connect(ipc::handle_t * ph, prefix pref, char const * name, unsigned mode) {
+    return detail_impl<policy_t<Flag>>::connect(ph, pref, name, mode & receiver);
+}
+
 template <typename Flag>
 bool chan_impl<Flag>::reconnect(ipc::handle_t * ph, unsigned mode) {
     return detail_impl<policy_t<Flag>>::reconnect(ph, mode & receiver);
@@ -658,7 +690,7 @@ void chan_impl<Flag>::destroy(ipc::handle_t h) {
 
 template <typename Flag>
 char const * chan_impl<Flag>::name(ipc::handle_t h) {
-    auto info = detail_impl<policy_t<Flag>>::info_of(h);
+    auto *info = detail_impl<policy_t<Flag>>::info_of(h);
     return (info == nullptr) ? nullptr : info->name_.c_str();
 }
 
diff --git a/src/libipc/memory/resource.h b/src/libipc/memory/resource.h
index 38b6fb68..cb50c92c 100755
--- a/src/libipc/memory/resource.h
+++ b/src/libipc/memory/resource.h
@@ -87,4 +87,24 @@ ipc::string to_string(T val) {
     return {};
 }
 
+/// \brief Check string validity.
+constexpr bool is_valid_string(char const *str) noexcept {
+    return (str != nullptr) && (str[0] != '\0');
+}
+
+/// \brief Make a valid string.
+inline ipc::string make_string(char const *str) {
+    return is_valid_string(str) ? ipc::string{str} : ipc::string{};
+}
+
+/// \brief Combine prefix from a list of strings.
+inline ipc::string make_prefix(ipc::string prefix, std::initializer_list<ipc::string> args) {
+    prefix += "__IPC_SHM__";
+    for (auto const &txt: args) {
+        if (txt.empty()) continue;
+        prefix += txt;
+    }
+    return prefix;
+}
+
 } // namespace ipc
diff --git a/src/libipc/platform/detail.h b/src/libipc/platform/detail.h
index e93c1d29..3eac15e6 100755
--- a/src/libipc/platform/detail.h
+++ b/src/libipc/platform/detail.h
@@ -24,6 +24,7 @@
 #include <type_traits>
 #include <tuple>
 #include <algorithm>
+#include <initializer_list>
 
 // pre-defined
 
@@ -133,4 +134,4 @@ constexpr const T& (min)(const T& a, const T& b) {
 } // namespace ipc
 
 #endif // defined(__cplusplus)
-#endif // LIBIPC_SRC_PLATFORM_DETAIL_H_
\ No newline at end of file
+#endif // LIBIPC_SRC_PLATFORM_DETAIL_H_
diff --git a/src/libipc/platform/posix/shm_posix.cpp b/src/libipc/platform/posix/shm_posix.cpp
index b0bfdef6..7ce90428 100644
--- a/src/libipc/platform/posix/shm_posix.cpp
+++ b/src/libipc/platform/posix/shm_posix.cpp
@@ -49,9 +49,6 @@ id_t acquire(char const * name, std::size_t size, unsigned mode) {
         ipc::error("fail acquire: name is empty\n");
         return nullptr;
     }
-    // For portable use, a shared memory object should be identified by name of the form /somename.
-    // see: https://man7.org/linux/man-pages/man3/shm_open.3.html
-    ipc::string op_name = ipc::string{"/__IPC_SHM__"} + name;
     // Open the object for read-write access.
     int flag = O_RDWR;
     switch (mode) {
@@ -68,9 +65,9 @@ id_t acquire(char const * name, std::size_t size, unsigned mode) {
         flag |= O_CREAT;
         break;
     }
-    int fd = ::shm_open(op_name.c_str(), flag, S_IRUSR | S_IWUSR |
-                                               S_IRGRP | S_IWGRP |
-                                               S_IROTH | S_IWOTH);
+    int fd = ::shm_open(name, flag, S_IRUSR | S_IWUSR |
+                                    S_IRGRP | S_IWGRP |
+                                    S_IROTH | S_IWOTH);
     if (fd == -1) {
         ipc::error("fail shm_open[%d]: %s\n", errno, name);
         return nullptr;
@@ -78,7 +75,7 @@ id_t acquire(char const * name, std::size_t size, unsigned mode) {
     auto ii = mem::alloc<id_info_t>();
     ii->fd_   = fd;
     ii->size_ = size;
-    ii->name_ = std::move(op_name);
+    ii->name_ = name;
     return ii;
 }
 
@@ -192,7 +189,7 @@ void remove(char const * name) {
         ipc::error("fail remove: name is empty\n");
         return;
     }
-    ::shm_unlink((ipc::string{"__IPC_SHM__"} + name).c_str());
+    ::shm_unlink(name);
 }
 
 } // namespace shm
diff --git a/src/libipc/platform/win/comfortable_prefix.h b/src/libipc/platform/win/comfortable_prefix.h
deleted file mode 100644
index 92f7ac18..00000000
--- a/src/libipc/platform/win/comfortable_prefix.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#pragma once
-
-#include <Windows.h>
-
-#include "libipc/memory/resource.h"
-
-namespace ipc {
-namespace detail {
-
-/// \brief This routine returns `true` if the caller's process is a member of the Administrators local group. 
-///        Caller is NOT expected to be impersonating anyone and is expected to be able to open its own process and process token.
-/// \return true  - Caller has Administrators local group.
-///         false - Caller does not have Administrators local group.
-/// \see https://learn.microsoft.com/en-us/windows/win32/api/securitybaseapi/nf-securitybaseapi-checktokenmembership
-inline bool is_user_admin() {
-    SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
-    PSID AdministratorsGroup; 
-    BOOL b = AllocateAndInitializeSid(&NtAuthority,
-                                      2,
-                                      SECURITY_BUILTIN_DOMAIN_RID,
-                                      DOMAIN_ALIAS_RID_ADMINS,
-                                      0, 0, 0, 0, 0, 0,
-                                      &AdministratorsGroup); 
-    if (b) {
-        if (!CheckTokenMembership(NULL, AdministratorsGroup, &b)) {
-            b = FALSE;
-        }
-        FreeSid(AdministratorsGroup); 
-    }
-    return !!(b);
-}
-
-/// \brief Identify the user group and add the appropriate prefix to the string.
-/// \see http://msdn.microsoft.com/en-us/library/aa366551(v=VS.85).aspx
-///      https://stackoverflow.com/questions/3999157/system-error-0x5-createfilemapping
-inline ipc::string make_comfortable_prefix(ipc::string &&txt) {
-    if (is_user_admin()) {
-        return ipc::string{"Global\\"} + txt;
-    }
-    return txt;
-}
-
-} // namespace detail
-} // namespace ipc
diff --git a/src/libipc/platform/win/condition.h b/src/libipc/platform/win/condition.h
index e477bff0..7f853c02 100644
--- a/src/libipc/platform/win/condition.h
+++ b/src/libipc/platform/win/condition.h
@@ -76,7 +76,7 @@ class condition {
         }
         DWORD ms = (tm == invalid_value) ? INFINITE : static_cast<DWORD>(tm);
         /**
-         * @see
+         * \see
          *  - https://www.microsoft.com/en-us/research/wp-content/uploads/2004/12/ImplementingCVs.pdf
          *  - https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-signalobjectandwait
         */
diff --git a/src/libipc/platform/win/mutex.h b/src/libipc/platform/win/mutex.h
index 49244d8b..c0cb543d 100644
--- a/src/libipc/platform/win/mutex.h
+++ b/src/libipc/platform/win/mutex.h
@@ -9,7 +9,6 @@
 
 #include "to_tchar.h"
 #include "get_sa.h"
-#include "comfortable_prefix.h"
 
 namespace ipc {
 namespace detail {
@@ -34,8 +33,7 @@ class mutex {
 
     bool open(char const *name) noexcept {
         close();
-        h_ = ::CreateMutex(detail::get_sa(), FALSE, 
-                           detail::to_tchar(detail::make_comfortable_prefix(name)).c_str());
+        h_ = ::CreateMutex(detail::get_sa(), FALSE, detail::to_tchar(name).c_str());
         if (h_ == NULL) {
             ipc::error("fail CreateMutex[%lu]: %s\n", ::GetLastError(), name);
             return false;
diff --git a/src/libipc/platform/win/semaphore.h b/src/libipc/platform/win/semaphore.h
index 39184e97..5c44846b 100644
--- a/src/libipc/platform/win/semaphore.h
+++ b/src/libipc/platform/win/semaphore.h
@@ -8,7 +8,6 @@
 
 #include "to_tchar.h"
 #include "get_sa.h"
-#include "comfortable_prefix.h"
 
 namespace ipc {
 namespace detail {
@@ -33,7 +32,7 @@ class semaphore {
         close();
         h_ = ::CreateSemaphore(detail::get_sa(), 
                                static_cast<LONG>(count), LONG_MAX, 
-                               detail::to_tchar(detail::make_comfortable_prefix(name)).c_str());
+                               detail::to_tchar(name).c_str());
         if (h_ == NULL) {
             ipc::error("fail CreateSemaphore[%lu]: %s\n", ::GetLastError(), name);
             return false;
diff --git a/src/libipc/platform/win/shm_win.cpp b/src/libipc/platform/win/shm_win.cpp
index c1718350..4979e001 100755
--- a/src/libipc/platform/win/shm_win.cpp
+++ b/src/libipc/platform/win/shm_win.cpp
@@ -13,7 +13,6 @@
 
 #include "to_tchar.h"
 #include "get_sa.h"
-#include "comfortable_prefix.h"
 
 namespace {
 
@@ -34,7 +33,7 @@ id_t acquire(char const * name, std::size_t size, unsigned mode) {
         return nullptr;
     }
     HANDLE h;
-    auto fmt_name = ipc::detail::to_tchar(detail::make_comfortable_prefix("__IPC_SHM__") + name);
+    auto fmt_name = ipc::detail::to_tchar(name);
     // Opens a named file mapping object.
     if (mode == open) {
         h = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, fmt_name.c_str());
diff --git a/src/libipc/platform/win/to_tchar.h b/src/libipc/platform/win/to_tchar.h
index 892177e2..94bc83e8 100755
--- a/src/libipc/platform/win/to_tchar.h
+++ b/src/libipc/platform/win/to_tchar.h
@@ -41,8 +41,8 @@ constexpr auto to_tchar(ipc::string &&str) -> IsSameChar<T, ipc::string, ipc::st
 }
 
 /**
- * @remarks codecvt_utf8_utf16/std::wstring_convert is deprecated
- * @see https://codingtidbit.com/2020/02/09/c17-codecvt_utf8-is-deprecated/
+ * \remarks codecvt_utf8_utf16/std::wstring_convert is deprecated
+ * \see https://codingtidbit.com/2020/02/09/c17-codecvt_utf8-is-deprecated/
  *      https://stackoverflow.com/questions/42946335/deprecated-header-codecvt-replacement
  *      https://en.cppreference.com/w/cpp/locale/codecvt/in
  *      https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-multibytetowidechar

From 6f311805a0ea9dbdd94a4fea8d05d35d59e39a74 Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sun, 24 Sep 2023 16:19:12 +0800
Subject: [PATCH 10/14] The global sender could not be obtained due to
 different prefixes.

---
 demo/win_service/client/main.cpp    |  4 ++--
 demo/win_service/service/main.cpp   |  4 ++--
 src/libipc/ipc.cpp                  | 25 +++++++++++++++++++++----
 src/libipc/platform/win/condition.h |  6 +++---
 src/libipc/waiter.h                 |  4 ++--
 5 files changed, 30 insertions(+), 13 deletions(-)

diff --git a/demo/win_service/client/main.cpp b/demo/win_service/client/main.cpp
index fea348e9..5e62d2c4 100644
--- a/demo/win_service/client/main.cpp
+++ b/demo/win_service/client/main.cpp
@@ -8,8 +8,8 @@
 
 int _tmain (int argc, TCHAR *argv[]) {
     _tprintf(_T("My Sample Client: Entry\n"));
-    ipc::channel ipc_r{"service ipc r", ipc::receiver};
-    ipc::channel ipc_w{"service ipc w", ipc::sender};
+    ipc::channel ipc_r{ipc::prefix{"Global\\"}, "service ipc r", ipc::receiver};
+    ipc::channel ipc_w{ipc::prefix{"Global\\"}, "service ipc w", ipc::sender};
     while (1) {
         auto msg = ipc_r.recv();
         if (msg.empty()) {
diff --git a/demo/win_service/service/main.cpp b/demo/win_service/service/main.cpp
index d61b08d5..ce522280 100644
--- a/demo/win_service/service/main.cpp
+++ b/demo/win_service/service/main.cpp
@@ -160,8 +160,8 @@ VOID WINAPI ServiceCtrlHandler (DWORD CtrlCode) {
 
 DWORD WINAPI ServiceWorkerThread (LPVOID lpParam) {
     OutputDebugString(_T("My Sample Service: ServiceWorkerThread: Entry"));
-    ipc::channel ipc_r{"service ipc r", ipc::sender};
-    ipc::channel ipc_w{"service ipc w", ipc::receiver};
+    ipc::channel ipc_r{ipc::prefix{"Global\\"}, "service ipc r", ipc::sender};
+    ipc::channel ipc_w{ipc::prefix{"Global\\"}, "service ipc w", ipc::receiver};
 
     //  Periodically check if the service has been requested to stop
     while (WaitForSingleObject(g_ServiceStopEvent, 0) != WAIT_OBJECT_0) {        
diff --git a/src/libipc/ipc.cpp b/src/libipc/ipc.cpp
index a892c486..3f3d3178 100755
--- a/src/libipc/ipc.cpp
+++ b/src/libipc/ipc.cpp
@@ -9,6 +9,7 @@
 #include <vector>
 #include <array>
 #include <cassert>
+#include <mutex>
 
 #include "libipc/ipc.h"
 #include "libipc/def.h"
@@ -69,9 +70,21 @@ ipc::buff_t make_cache(T& data, std::size_t size) {
     return { ptr, size, ipc::mem::free };
 }
 
-acc_t *cc_acc() {
-    static ipc::shm::handle acc_h("__CA_CONN__", sizeof(acc_t));
-    return static_cast<acc_t *>(acc_h.get());
+acc_t *cc_acc(ipc::string const &pref) {
+    static ipc::unordered_map<ipc::string, ipc::shm::handle> handles;
+    static std::mutex lock;
+    std::lock_guard<std::mutex> guard {lock};
+    auto it = handles.find(pref);
+    if (it == handles.end()) {
+        ipc::string shm_name {ipc::make_prefix(pref, {"CA_CONN__"})};
+        ipc::shm::handle h;
+        if (!h.acquire(shm_name.c_str(), sizeof(acc_t))) {
+            ipc::error("[cc_acc] acquire failed: %s\n", shm_name.c_str());
+            return nullptr;
+        }
+        it = handles.emplace(pref, std::move(h)).first;
+    }
+    return static_cast<acc_t *>(it->second.get());
 }
 
 struct cache_t {
@@ -101,11 +114,15 @@ struct conn_info_head {
     conn_info_head(char const * prefix, char const * name)
         : prefix_   {ipc::make_string(prefix)}
         , name_     {ipc::make_string(name)}
-        , cc_id_    {(cc_acc() == nullptr) ? 0 : cc_acc()->fetch_add(1, std::memory_order_relaxed)}
+        , cc_id_    {}
         , cc_waiter_{ipc::make_prefix(prefix_, {"CC_CONN__", name_}).c_str()}
         , wt_waiter_{ipc::make_prefix(prefix_, {"WT_CONN__", name_}).c_str()}
         , rd_waiter_{ipc::make_prefix(prefix_, {"RD_CONN__", name_}).c_str()}
         , acc_h_    {ipc::make_prefix(prefix_, {"AC_CONN__", name_}).c_str(), sizeof(acc_t)} {
+        acc_t *pacc = cc_acc(prefix_);
+        if (pacc != nullptr) {
+            cc_id_ = pacc->fetch_add(1, std::memory_order_relaxed);
+        }
     }
 
     void quit_waiting() {
diff --git a/src/libipc/platform/win/condition.h b/src/libipc/platform/win/condition.h
index 7f853c02..538aa082 100644
--- a/src/libipc/platform/win/condition.h
+++ b/src/libipc/platform/win/condition.h
@@ -44,15 +44,15 @@ class condition {
 
     bool open(char const *name) noexcept {
         close();
-        if (!sem_.open((std::string{"_cond_sem_"} + name).c_str())) {
+        if (!sem_.open((std::string{name} + "_COND_SEM_").c_str())) {
             return false;
         }
         auto finally_sem = ipc::guard([this] { sem_.close(); }); // close when failed
-        if (!lock_.open((std::string{"_cond_lock_"} + name).c_str())) {
+        if (!lock_.open((std::string{name} + "_COND_LOCK_").c_str())) {
             return false;
         }
         auto finally_lock = ipc::guard([this] { lock_.close(); }); // close when failed
-        if (!shm_.acquire((std::string{"_cond_shm_"} + name).c_str(), sizeof(std::int32_t))) {
+        if (!shm_.acquire((std::string{name} + "_COND_SHM_").c_str(), sizeof(std::int32_t))) {
             return false;
         }
         finally_lock.dismiss();
diff --git a/src/libipc/waiter.h b/src/libipc/waiter.h
index bb5b3b34..628ce5ea 100644
--- a/src/libipc/waiter.h
+++ b/src/libipc/waiter.h
@@ -36,10 +36,10 @@ class waiter {
 
     bool open(char const *name) noexcept {
         quit_.store(false, std::memory_order_relaxed);
-        if (!cond_.open((std::string{"_waiter_cond_"} + name).c_str())) {
+        if (!cond_.open((std::string{name} + "_WAITER_COND_").c_str())) {
             return false;
         }
-        if (!lock_.open((std::string{"_waiter_lock_"} + name).c_str())) {
+        if (!lock_.open((std::string{name} + "_WAITER_LOCK_").c_str())) {
             cond_.close();
             return false;
         }

From f52b125c3f94ff2c2e37659667472e066e822eb2 Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sun, 24 Sep 2023 16:52:48 +0800
Subject: [PATCH 11/14] =?UTF-8?q?=E7=BB=9F=E4=B8=80=E5=AD=97=E7=AC=A6?=
 =?UTF-8?q?=E4=B8=B2=E6=9C=89=E6=95=88=E6=80=A7=E5=88=A4=E6=96=AD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/libipc/platform/posix/shm_posix.cpp | 4 ++--
 src/libipc/platform/win/shm_win.cpp     | 4 ++--
 src/libipc/queue.h                      | 3 ++-
 src/libipc/shm.cpp                      | 2 +-
 src/libipc/sync/condition.cpp           | 2 +-
 src/libipc/sync/mutex.cpp               | 2 +-
 src/libipc/sync/semaphore.cpp           | 2 +-
 7 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/libipc/platform/posix/shm_posix.cpp b/src/libipc/platform/posix/shm_posix.cpp
index 7ce90428..c111aa54 100644
--- a/src/libipc/platform/posix/shm_posix.cpp
+++ b/src/libipc/platform/posix/shm_posix.cpp
@@ -45,7 +45,7 @@ namespace ipc {
 namespace shm {
 
 id_t acquire(char const * name, std::size_t size, unsigned mode) {
-    if (name == nullptr || name[0] == '\0') {
+    if (!is_valid_string(name)) {
         ipc::error("fail acquire: name is empty\n");
         return nullptr;
     }
@@ -185,7 +185,7 @@ void remove(id_t id) {
 }
 
 void remove(char const * name) {
-    if (name == nullptr || name[0] == '\0') {
+    if (!is_valid_string(name)) {
         ipc::error("fail remove: name is empty\n");
         return;
     }
diff --git a/src/libipc/platform/win/shm_win.cpp b/src/libipc/platform/win/shm_win.cpp
index 4979e001..75c2a95c 100755
--- a/src/libipc/platform/win/shm_win.cpp
+++ b/src/libipc/platform/win/shm_win.cpp
@@ -28,7 +28,7 @@ namespace ipc {
 namespace shm {
 
 id_t acquire(char const * name, std::size_t size, unsigned mode) {
-    if (name == nullptr || name[0] == '\0') {
+    if (!is_valid_string(name)) {
         ipc::error("fail acquire: name is empty\n");
         return nullptr;
     }
@@ -124,7 +124,7 @@ void remove(id_t id) {
 }
 
 void remove(char const * name) {
-    if (name == nullptr || name[0] == '\0') {
+    if (!is_valid_string(name)) {
         ipc::error("fail remove: name is empty\n");
         return;
     }
diff --git a/src/libipc/queue.h b/src/libipc/queue.h
index f66860b8..bb925ce3 100755
--- a/src/libipc/queue.h
+++ b/src/libipc/queue.h
@@ -18,6 +18,7 @@
 #include "libipc/utility/log.h"
 #include "libipc/platform/detail.h"
 #include "libipc/circ/elem_def.h"
+#include "libipc/memory/resource.h"
 
 namespace ipc {
 namespace detail {
@@ -29,7 +30,7 @@ class queue_conn {
 
     template <typename Elems>
     Elems* open(char const * name) {
-        if (name == nullptr || name[0] == '\0') {
+        if (!is_valid_string(name)) {
             ipc::error("fail open waiter: name is empty!\n");
             return nullptr;
         }
diff --git a/src/libipc/shm.cpp b/src/libipc/shm.cpp
index c8763a84..08454741 100755
--- a/src/libipc/shm.cpp
+++ b/src/libipc/shm.cpp
@@ -69,7 +69,7 @@ void handle::sub_ref() noexcept {
 }
 
 bool handle::acquire(char const * name, std::size_t size, unsigned mode) {
-    if (name == nullptr || name[0] == '\0') {
+    if (!is_valid_string(name)) {
         ipc::error("fail acquire: name is empty\n");
         return false;
     }
diff --git a/src/libipc/sync/condition.cpp b/src/libipc/sync/condition.cpp
index b97d09be..36896a7e 100644
--- a/src/libipc/sync/condition.cpp
+++ b/src/libipc/sync/condition.cpp
@@ -50,7 +50,7 @@ bool condition::valid() const noexcept {
 }
 
 bool condition::open(char const *name) noexcept {
-    if (name == nullptr || name[0] == '\0') {
+    if (!is_valid_string(name)) {
         ipc::error("fail condition open: name is empty\n");
         return false;
     }
diff --git a/src/libipc/sync/mutex.cpp b/src/libipc/sync/mutex.cpp
index 40aad651..91bd0bbc 100644
--- a/src/libipc/sync/mutex.cpp
+++ b/src/libipc/sync/mutex.cpp
@@ -50,7 +50,7 @@ bool mutex::valid() const noexcept {
 }
 
 bool mutex::open(char const *name) noexcept {
-    if (name == nullptr || name[0] == '\0') {
+    if (!is_valid_string(name)) {
         ipc::error("fail mutex open: name is empty\n");
         return false;
     }
diff --git a/src/libipc/sync/semaphore.cpp b/src/libipc/sync/semaphore.cpp
index 33539f10..e58e8ec4 100644
--- a/src/libipc/sync/semaphore.cpp
+++ b/src/libipc/sync/semaphore.cpp
@@ -48,7 +48,7 @@ bool semaphore::valid() const noexcept {
 }
 
 bool semaphore::open(char const *name, std::uint32_t count) noexcept {
-    if (name == nullptr || name[0] == '\0') {
+    if (!is_valid_string(name)) {
         ipc::error("fail semaphore open: name is empty\n");
         return false;
     }

From 8c02f37ff9e6f26d168cb08d0caa1aab7800afe4 Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sun, 24 Sep 2023 18:02:37 +0800
Subject: [PATCH 12/14] Fixed memory access exception in multithreading.

---
 3rdparty/gtest/src/gtest-death-test.cc  |  4 ++--
 src/libipc/ipc.cpp                      | 30 ++++++++++++++++---------
 src/libipc/platform/posix/shm_posix.cpp | 16 ++++++++-----
 test/test_ipc.cpp                       | 10 ++++++---
 test/test_sync.cpp                      |  2 +-
 5 files changed, 40 insertions(+), 22 deletions(-)

diff --git a/3rdparty/gtest/src/gtest-death-test.cc b/3rdparty/gtest/src/gtest-death-test.cc
index da09a1cf..7419ba2c 100644
--- a/3rdparty/gtest/src/gtest-death-test.cc
+++ b/3rdparty/gtest/src/gtest-death-test.cc
@@ -1296,8 +1296,8 @@ static void StackLowerThanAddress(const void* ptr, bool* result) {
 GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
 GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
 static bool StackGrowsDown() {
-  int dummy;
-  bool result;
+  int dummy {};
+  bool result {};
   StackLowerThanAddress(&dummy, &result);
   return result;
 }
diff --git a/src/libipc/ipc.cpp b/src/libipc/ipc.cpp
index 3f3d3178..38e3f1d7 100755
--- a/src/libipc/ipc.cpp
+++ b/src/libipc/ipc.cpp
@@ -182,6 +182,7 @@ struct chunk_info_t {
 auto& chunk_storages() {
     class chunk_handle_t {
         ipc::unordered_map<ipc::string, ipc::shm::handle> handles_;
+        std::mutex lock_;
 
         static bool make_handle(ipc::shm::handle &h, ipc::string const &shm_name, std::size_t chunk_size) {
             if (!h.valid() &&
@@ -197,11 +198,15 @@ auto& chunk_storages() {
         chunk_info_t *get_info(conn_info_head *inf, std::size_t chunk_size) {
             ipc::string pref {(inf == nullptr) ? ipc::string{} : inf->prefix_};
             ipc::string shm_name {ipc::make_prefix(pref, {"CHUNK_INFO__", ipc::to_string(chunk_size)})};
-            ipc::shm::handle &h = handles_[pref];
-            if (!make_handle(h, shm_name, chunk_size)) {
-                return nullptr;
+            ipc::shm::handle *h;
+            {
+                std::lock_guard<std::mutex> guard {lock_};
+                h = &(handles_[pref]);
+                if (!make_handle(*h, shm_name, chunk_size)) {
+                    return nullptr;
+                }
             }
-            auto *info = static_cast<chunk_info_t*>(h.get());
+            auto *info = static_cast<chunk_info_t*>(h->get());
             if (info == nullptr) {
                 ipc::error("[chunk_storages] chunk_shm.id_info_.get failed: chunk_size = %zd\n", chunk_size);
                 return nullptr;
@@ -209,7 +214,9 @@ auto& chunk_storages() {
             return info;
         }
     };
-    static ipc::map<std::size_t, chunk_handle_t> chunk_hs;
+    using deleter_t = void (*)(chunk_handle_t*);
+    using chunk_handle_ptr_t = std::unique_ptr<chunk_handle_t, deleter_t>;
+    static ipc::map<std::size_t, chunk_handle_ptr_t> chunk_hs;
     return chunk_hs;
 }
 
@@ -220,13 +227,17 @@ chunk_info_t *chunk_storage_info(conn_info_head *inf, std::size_t chunk_size) {
         static ipc::rw_lock lock;
         IPC_UNUSED_ std::shared_lock<ipc::rw_lock> guard {lock};
         if ((it = storages.find(chunk_size)) == storages.end()) {
-            using chunk_handle_t = std::decay_t<decltype(storages)>::value_type::second_type;
+            using chunk_handle_ptr_t = std::decay_t<decltype(storages)>::value_type::second_type;
+            using chunk_handle_t     = chunk_handle_ptr_t::element_type;
             guard.unlock();
             IPC_UNUSED_ std::lock_guard<ipc::rw_lock> guard {lock};
-            it = storages.emplace(chunk_size, chunk_handle_t{}).first;
+            it = storages.emplace(chunk_size, chunk_handle_ptr_t{
+                ipc::mem::alloc<chunk_handle_t>(), [](chunk_handle_t *p) {
+                    ipc::mem::destruct(p);
+                }}).first;
         }
     }
-    return it->second.get_info(inf, chunk_size);
+    return it->second->get_info(inf, chunk_size);
 }
 
 std::pair<ipc::storage_id_t, void*> acquire_storage(conn_info_head *inf, std::size_t size, ipc::circ::cc_t conns) {
@@ -356,8 +367,7 @@ struct queue_generator {
                     "QU_CONN__",
                     ipc::to_string(DataSize), "__",
                     ipc::to_string(AlignSize), "__", 
-                    name}).c_str()} {
-        }
+                    name}).c_str()} {}
 
         void disconnect_receiver() {
             bool dis = que_.disconnect();
diff --git a/src/libipc/platform/posix/shm_posix.cpp b/src/libipc/platform/posix/shm_posix.cpp
index c111aa54..e29bd6f2 100644
--- a/src/libipc/platform/posix/shm_posix.cpp
+++ b/src/libipc/platform/posix/shm_posix.cpp
@@ -49,6 +49,9 @@ id_t acquire(char const * name, std::size_t size, unsigned mode) {
         ipc::error("fail acquire: name is empty\n");
         return nullptr;
     }
+    // For portable use, a shared memory object should be identified by name of the form /somename.
+    // see: https://man7.org/linux/man-pages/man3/shm_open.3.html
+    ipc::string op_name = ipc::string{"/"} + name;
     // Open the object for read-write access.
     int flag = O_RDWR;
     switch (mode) {
@@ -65,17 +68,17 @@ id_t acquire(char const * name, std::size_t size, unsigned mode) {
         flag |= O_CREAT;
         break;
     }
-    int fd = ::shm_open(name, flag, S_IRUSR | S_IWUSR |
-                                    S_IRGRP | S_IWGRP |
-                                    S_IROTH | S_IWOTH);
+    int fd = ::shm_open(op_name.c_str(), flag, S_IRUSR | S_IWUSR |
+                                               S_IRGRP | S_IWGRP |
+                                               S_IROTH | S_IWOTH);
     if (fd == -1) {
-        ipc::error("fail shm_open[%d]: %s\n", errno, name);
+        ipc::error("fail shm_open[%d]: %s\n", errno, op_name.c_str());
         return nullptr;
     }
     auto ii = mem::alloc<id_info_t>();
     ii->fd_   = fd;
     ii->size_ = size;
-    ii->name_ = name;
+    ii->name_ = std::move(op_name);
     return ii;
 }
 
@@ -158,7 +161,8 @@ std::int32_t release(id_t id) {
     std::int32_t ret = -1;
     auto ii = static_cast<id_info_t*>(id);
     if (ii->mem_ == nullptr || ii->size_ == 0) {
-        ipc::error("fail release: invalid id (mem = %p, size = %zd)\n", ii->mem_, ii->size_);
+        ipc::error("fail release: invalid id (mem = %p, size = %zd), name = %s\n", 
+                    ii->mem_, ii->size_, ii->name_.c_str());
     }
     else if ((ret = acc_of(ii->mem_, ii->size_).fetch_sub(1, std::memory_order_acq_rel)) <= 1) {
         ::munmap(ii->mem_, ii->size_);
diff --git a/test/test_ipc.cpp b/test/test_ipc.cpp
index a1f01083..fb46670a 100755
--- a/test/test_ipc.cpp
+++ b/test/test_ipc.cpp
@@ -151,11 +151,15 @@ void test_sr(char const * name, int s_cnt, int r_cnt) {
 
 } // internal-linkage
 
-TEST(IPC, basic) {
+TEST(IPC, basic_ssu) {
     test_basic<relat::single, relat::single, trans::unicast  >("ssu");
-    //test_basic<relat::single, relat::multi , trans::unicast  >("smu");
-    //test_basic<relat::multi , relat::multi , trans::unicast  >("mmu");
+}
+
+TEST(IPC, basic_smb) {
     test_basic<relat::single, relat::multi , trans::broadcast>("smb");
+}
+
+TEST(IPC, basic_mmb) {
     test_basic<relat::multi , relat::multi , trans::broadcast>("mmb");
 }
 
diff --git a/test/test_sync.cpp b/test/test_sync.cpp
index 4cb82e68..e905df98 100644
--- a/test/test_sync.cpp
+++ b/test/test_sync.cpp
@@ -131,7 +131,7 @@ TEST(Sync, Condition) {
             {
                 std::lock_guard<ipc::sync::mutex> guard {lock};
                 while (que.empty()) {
-                    EXPECT_TRUE(cond.wait(lock, 1000));
+                    ASSERT_TRUE(cond.wait(lock, 1000));
                 }
                 val = que.front();
                 que.pop_front();

From fb52c813fa7058c1806eeffdd9dc6e81f171e6c3 Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sun, 24 Sep 2023 18:07:02 +0800
Subject: [PATCH 13/14] =?UTF-8?q?=E5=9B=9E=E6=BB=9A=E5=A4=9A=E4=BD=99?=
 =?UTF-8?q?=E7=9A=84=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/libipc/platform/detail.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/libipc/platform/detail.h b/src/libipc/platform/detail.h
index 3eac15e6..4d6a27cf 100755
--- a/src/libipc/platform/detail.h
+++ b/src/libipc/platform/detail.h
@@ -24,7 +24,6 @@
 #include <type_traits>
 #include <tuple>
 #include <algorithm>
-#include <initializer_list>
 
 // pre-defined
 

From 76d9b41005412ff00b194e9cc288ab71090c11d9 Mon Sep 17 00:00:00 2001
From: mutouyun <orz@orzz.org>
Date: Sat, 21 Oct 2023 15:46:16 +0800
Subject: [PATCH 14/14] `reconnect` cannot reconnect when you are out of
 authority

---
 demo/win_service/client/main.cpp    | 17 ++++++-
 src/libipc/ipc.cpp                  | 72 ++++++++++++++++++-----------
 src/libipc/platform/win/shm_win.cpp | 17 ++++---
 src/libipc/queue.h                  |  8 +++-
 4 files changed, 78 insertions(+), 36 deletions(-)

diff --git a/demo/win_service/client/main.cpp b/demo/win_service/client/main.cpp
index 5e62d2c4..44a9ba62 100644
--- a/demo/win_service/client/main.cpp
+++ b/demo/win_service/client/main.cpp
@@ -11,14 +11,27 @@ int _tmain (int argc, TCHAR *argv[]) {
     ipc::channel ipc_r{ipc::prefix{"Global\\"}, "service ipc r", ipc::receiver};
     ipc::channel ipc_w{ipc::prefix{"Global\\"}, "service ipc w", ipc::sender};
     while (1) {
+        if (!ipc_r.reconnect(ipc::receiver)) {
+            Sleep(1000);
+            continue;
+        }
         auto msg = ipc_r.recv();
         if (msg.empty()) {
             _tprintf(_T("My Sample Client: message recv error\n"));
-            return -1;
+            ipc_r.disconnect();
+            continue;
         }
         printf("My Sample Client: message recv: [%s]\n", (char const *)msg.data());
-        while (!ipc_w.send("Copy.")) {
+        for (;;) {
+            if (!ipc_w.reconnect(ipc::sender)) {
+                Sleep(1000);
+                continue;
+            }
+            if (ipc_w.send("Copy.")) {
+                break;
+            }
             _tprintf(_T("My Sample Client: message send error\n"));
+            ipc_w.disconnect();
             Sleep(1000);
         }
         _tprintf(_T("My Sample Client: message send [Copy]\n"));
diff --git a/src/libipc/ipc.cpp b/src/libipc/ipc.cpp
index 38e3f1d7..6b6432e1 100755
--- a/src/libipc/ipc.cpp
+++ b/src/libipc/ipc.cpp
@@ -112,16 +112,27 @@ struct conn_info_head {
     ipc::shm::handle acc_h_;
 
     conn_info_head(char const * prefix, char const * name)
-        : prefix_   {ipc::make_string(prefix)}
-        , name_     {ipc::make_string(name)}
-        , cc_id_    {}
-        , cc_waiter_{ipc::make_prefix(prefix_, {"CC_CONN__", name_}).c_str()}
-        , wt_waiter_{ipc::make_prefix(prefix_, {"WT_CONN__", name_}).c_str()}
-        , rd_waiter_{ipc::make_prefix(prefix_, {"RD_CONN__", name_}).c_str()}
-        , acc_h_    {ipc::make_prefix(prefix_, {"AC_CONN__", name_}).c_str(), sizeof(acc_t)} {
+        : prefix_{ipc::make_string(prefix)}
+        , name_  {ipc::make_string(name)}
+        , cc_id_ {} {}
+
+    void init() {
+        if (!cc_waiter_.valid()) cc_waiter_.open(ipc::make_prefix(prefix_, {"CC_CONN__", name_}).c_str());
+        if (!wt_waiter_.valid()) wt_waiter_.open(ipc::make_prefix(prefix_, {"WT_CONN__", name_}).c_str());
+        if (!rd_waiter_.valid()) rd_waiter_.open(ipc::make_prefix(prefix_, {"RD_CONN__", name_}).c_str());
+        if (!acc_h_.valid()) acc_h_.acquire(ipc::make_prefix(prefix_, {"AC_CONN__", name_}).c_str(), sizeof(acc_t));
+        if (cc_id_ != 0) {
+            return;
+        }
         acc_t *pacc = cc_acc(prefix_);
-        if (pacc != nullptr) {
-            cc_id_ = pacc->fetch_add(1, std::memory_order_relaxed);
+        if (pacc == nullptr) {
+            // Failed to obtain the global accumulator.
+            return;
+        }
+        cc_id_ = pacc->fetch_add(1, std::memory_order_relaxed) + 1;
+        if (cc_id_ == 0) {
+            // The identity cannot be 0.
+            cc_id_ = pacc->fetch_add(1, std::memory_order_relaxed) + 1;
         }
     }
 
@@ -362,12 +373,18 @@ struct queue_generator {
         queue_t que_;
 
         conn_info_t(char const * pref, char const * name)
-            : conn_info_head{pref, name}
-            , que_{ipc::make_prefix(prefix_, {
-                    "QU_CONN__",
-                    ipc::to_string(DataSize), "__",
-                    ipc::to_string(AlignSize), "__", 
-                    name}).c_str()} {}
+            : conn_info_head{pref, name} { init(); }
+
+        void init() {
+            conn_info_head::init();
+            if (!que_.valid()) {
+                que_.open(ipc::make_prefix(prefix_, {
+                          "QU_CONN__",
+                          ipc::to_string(DataSize), "__",
+                          ipc::to_string(AlignSize), "__", 
+                          this->name_}).c_str());
+            }
+        }
 
         void disconnect_receiver() {
             bool dis = que_.disconnect();
@@ -397,6 +414,18 @@ constexpr static queue_t* queue_of(ipc::handle_t h) noexcept {
 
 /* API implementations */
 
+static bool connect(ipc::handle_t * ph, ipc::prefix pref, char const * name, bool start_to_recv) {
+    assert(ph != nullptr);
+    if (*ph == nullptr) {
+        *ph = ipc::mem::alloc<conn_info_t>(pref.str, name);
+    }
+    return reconnect(ph, start_to_recv);
+}
+
+static bool connect(ipc::handle_t * ph, char const * name, bool start_to_recv) {
+    return connect(ph, {nullptr}, name, start_to_recv);
+}
+
 static void disconnect(ipc::handle_t h) {
     auto que = queue_of(h);
     if (que == nullptr) {
@@ -414,6 +443,7 @@ static bool reconnect(ipc::handle_t * ph, bool start_to_recv) {
     if (que == nullptr) {
         return false;
     }
+    info_of(*ph)->init();
     if (start_to_recv) {
         que->shut_sending();
         if (que->connect()) { // wouldn't connect twice
@@ -429,18 +459,6 @@ static bool reconnect(ipc::handle_t * ph, bool start_to_recv) {
     return que->ready_sending();
 }
 
-static bool connect(ipc::handle_t * ph, ipc::prefix pref, char const * name, bool start_to_recv) {
-    assert(ph != nullptr);
-    if (*ph == nullptr) {
-        *ph = ipc::mem::alloc<conn_info_t>(pref.str, name);
-    }
-    return reconnect(ph, start_to_recv);
-}
-
-static bool connect(ipc::handle_t * ph, char const * name, bool start_to_recv) {
-    return connect(ph, {nullptr}, name, start_to_recv);
-}
-
 static void destroy(ipc::handle_t h) {
     disconnect(h);
     ipc::mem::free(info_of(h));
diff --git a/src/libipc/platform/win/shm_win.cpp b/src/libipc/platform/win/shm_win.cpp
index 75c2a95c..4b7016ef 100755
--- a/src/libipc/platform/win/shm_win.cpp
+++ b/src/libipc/platform/win/shm_win.cpp
@@ -37,21 +37,26 @@ id_t acquire(char const * name, std::size_t size, unsigned mode) {
     // Opens a named file mapping object.
     if (mode == open) {
         h = ::OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, fmt_name.c_str());
+        if (h == NULL) {
+          ipc::error("fail OpenFileMapping[%d]: %s\n", static_cast<int>(::GetLastError()), name);
+          return nullptr;
+        }
     }
     // Creates or opens a named file mapping object for a specified file.
     else {
         h = ::CreateFileMapping(INVALID_HANDLE_VALUE, detail::get_sa(), PAGE_READWRITE | SEC_COMMIT,
                                 0, static_cast<DWORD>(size), fmt_name.c_str());
+        DWORD err = ::GetLastError();
         // If the object exists before the function call, the function returns a handle to the existing object 
         // (with its current size, not the specified size), and GetLastError returns ERROR_ALREADY_EXISTS.
-        if ((mode == create) && (::GetLastError() == ERROR_ALREADY_EXISTS)) {
-            ::CloseHandle(h);
+        if ((mode == create) && (err == ERROR_ALREADY_EXISTS)) {
+            if (h != NULL) ::CloseHandle(h);
             h = NULL;
         }
-    }
-    if (h == NULL) {
-        ipc::error("fail CreateFileMapping/OpenFileMapping[%d]: %s\n", static_cast<int>(::GetLastError()), name);
-        return nullptr;
+        if (h == NULL) {
+          ipc::error("fail CreateFileMapping[%d]: %s\n", static_cast<int>(err), name);
+          return nullptr;
+        }
     }
     auto ii = mem::alloc<id_info_t>();
     ii->h_    = h;
diff --git a/src/libipc/queue.h b/src/libipc/queue.h
index bb925ce3..e38fe778 100755
--- a/src/libipc/queue.h
+++ b/src/libipc/queue.h
@@ -104,7 +104,7 @@ class queue_base : public queue_conn {
 
     explicit queue_base(char const * name)
         : queue_base{} {
-        elems_ = open<elems_t>(name);
+        elems_ = queue_conn::template open<elems_t>(name);
     }
 
     explicit queue_base(elems_t * elems) noexcept
@@ -117,6 +117,12 @@ class queue_base : public queue_conn {
         base_t::close();
     }
 
+    bool open(char const * name) noexcept {
+        base_t::close();
+        elems_ = queue_conn::template open<elems_t>(name);
+        return elems_ != nullptr;
+    }
+
     elems_t       * elems()       noexcept { return elems_; }
     elems_t const * elems() const noexcept { return elems_; }