INetCfg接口Initialize方法返回未文档化RPC错误码的问题咨询

问题描述 #

使用Windows API的INetCfg接口时，首次初始化网络配置实例正常，但后续调用netCfg->Initialize(NULL)时，会返回未文档化的错误码-2147416372（即0x800106CC，对应RPC_S_DUPLICATE_ENDPOINT）。根据官方文档，该方法仅应返回S_OK或Netcfgx.h中定义的NETCFG_*错误码。

通过重试初始化可规避此问题：第二次调用Initialize通常能返回S_OK，之后可正常使用INetCfg接口执行所需操作。

应用通过自定义NetworkConfiguration类封装INetCfg的初始化与清理逻辑，在工作线程中执行网络配置（每次线程均调用CoInitializeEx/CoUninitialize，无多线程并发，不跨线程共享COM对象），即使移除多线程逻辑仍会复现问题。

复现代码 #

#include <netcfgx.h> // For INetCfg and related interfaces

#include <future>
#include <string>
#include <iostream>
#include <format>

class NetworkConfiguration
{
public:
    NetworkConfiguration() : pNetCfg(NULL), pNetCfgLock(NULL)
    {
        const auto createInstanceRc = CoCreateInstance(CLSID_CNetCfg, NULL, CLSCTX_SERVER, IID_INetCfg, (LPVOID*)&pNetCfg);
        if (createInstanceRc != S_OK)
        {
            throw std::runtime_error(std::format("CoCreateInstance error: {}", createInstanceRc));
        }

        const auto queryInterfaceRc = pNetCfg->QueryInterface(IID_INetCfgLock, (LPVOID*)&pNetCfgLock);
        if (queryInterfaceRc != S_OK)
        {
            pNetCfg->Release();

            throw std::runtime_error(std::format("QueryInterface error: {}", queryInterfaceRc));
        }

        LPWSTR szwrClient = NULL;
        const auto acquireLockRc = pNetCfgLock->AcquireWriteLock(5000, L"MyApp", &szwrClient);
        if (acquireLockRc != S_OK)
        {
            pNetCfg->Release();

            throw std::runtime_error(std::format("AcquireWriteLock error: {}", acquireLockRc));
        }

        // With reattempts
        constexpr auto ErrorMask = (1 << 16) - 1;
        HRESULT initNetCfgRc = S_FALSE;
        for (int i = 0; i < 10; i++)
        {
            initNetCfgRc = pNetCfg->Initialize(NULL);
            if (initNetCfgRc == S_OK)
            {
                break;
            }

            // Try to re-initialise. Once we've flushed this state that seems to be OK
            if ((initNetCfgRc & ErrorMask) != RPC_S_DUPLICATE_ENDPOINT)
            {
                break;
            }

            std::cout << "Encountered duplicate endpoint. Continuing...\n";
        }

        // Without reattempts - Comment above and uncomment this to experience the error
        // const auto initNetCfgRc = pNetCfg->Initialize(NULL);

        if (initNetCfgRc != S_OK)
        {
            pNetCfgLock->ReleaseWriteLock();
            pNetCfg->Release();

            throw std::runtime_error(std::format("Initialise error: {}", initNetCfgRc));
        }
    }

    ~NetworkConfiguration()
    {
        const auto applyRc = pNetCfg->Apply();
        if (applyRc != S_OK)
        {
            std::cout << "Error applying network configuration. Error code: " << applyRc << "\n";
        }

        const auto uninitialiseRc = pNetCfg->Uninitialize();
        if (uninitialiseRc != S_OK)
        {
            std::cout << "Error uninitialising network configuration interface. Error code: " << uninitialiseRc << "\n";
        }

        const auto releaseLockRc = pNetCfgLock->ReleaseWriteLock();
        if (releaseLockRc != S_OK)
        {
            std::cout << "Error releasing write lock. Error code: " << releaseLockRc << "\n";
        }

        pNetCfg->Release();
    }

private:
    INetCfg* pNetCfg;
    INetCfgLock* pNetCfgLock;
};

int main(int argc, char** argv)
{
    for (int i = 0; i < 5; i++)
    {
        auto fut = std::async(std::launch::async, []() -> int {
            int rc = 0;
            try
            {
                const auto initRc = CoInitializeEx(NULL, COINIT_MULTITHREADED);
                if (initRc != S_OK)
                {
                    const auto err = std::format("CoInitialise error: {}", initRc);
                    CoUninitialize();
                    throw std::runtime_error(err);
                }

                {
                    NetworkConfiguration configuration;
                    // Network configuration performed here in the real app
                }

                CoUninitialize();
            }
            catch (const std::exception& e)
            {
                std::cout << "Exception: " << e.what() << "\n";
                rc = -1;
            }
            return rc;
            });

        fut.wait();
        std::cout << "Round " << i + 1 << " return code: " << fut.get() << "\n";
    }
    return 0;
}

环境说明：Visual Studio 2022，Windows 10

疑问 #

1. 为何INetCfg接口的Initialize方法会返回未文档化的RPC错误码？
2. 对于该未文档化的错误码，API使用者应如何处理？
3. 为何重试初始化后，就能正常使用INetCfg接口？

1. 为何返回未文档化的RPC错误码？ #

INetCfg底层依赖RPC与系统网络配置服务通信。当服务端的RPC端点还未完全释放上一次会话的资源，而客户端又尝试建立新连接时，就会触发RPC_S_DUPLICATE_ENDPOINT错误。官方文档未提及此错误，是因为这属于底层通信层的偶发异常，而非INetCfg接口本身的业务错误，微软文档通常不会枚举所有可能的底层RPC异常。

即使移除多线程逻辑仍复现，说明问题不在于线程模型，而是系统服务端资源释放存在延迟——上一次INetCfg实例的清理（Uninitialize、Release）完成后，服务端的RPC端点并未立刻回收，此时新实例调用Initialize就会产生冲突。

2. 如何处理该未文档化的错误码？ #

• 有限次数重试：针对RPC_S_DUPLICATE_ENDPOINT（0x800106CC）错误进行最多3-5次重试，每次重试前可短暂休眠100-200ms，避免频繁重试加重系统负担。
• 错误过滤处理：仅对明确的RPC_S_DUPLICATE_ENDPOINT错误执行重试，其他错误按正常流程抛出或处理，避免掩盖真正的业务错误（如权限不足、资源耗尽等）。
• 规范资源清理：确保INetCfg实例的清理流程完全执行——严格按照Apply()→Uninitialize()→ReleaseWriteLock()→Release()的顺序调用，减少服务端资源残留的概率。

3. 为何重试后能正常使用？ #

重试的等待窗口内，系统网络配置服务完成了上一次RPC端点的资源回收或状态重置。第二次调用Initialize时，服务端已经可以分配新的端点或复用已释放的资源，因此能正常建立通信并返回S_OK。这种情况属于典型的竞态条件——客户端的初始化速度快于服务端的资源释放速度，重试相当于给了服务端足够的时间完成清理。

内容的提问来源于stack exchange，提问作者Ben