当设备都有相同的IrDA时，是否有一种方法，而不是枚举，来获取许多deviceID设备的套接字？

Question

自从发布了关于枚举多个设备的original question之后，我已经发现了多个枚举没有出现的原因；这些设备都具有相同的deviceID。有了这个发现，我想提出一个新的问题，满怀希望地引出一个关于.

编辑

新问题：

当所有设备使用相同的deviceID时，是否有唯一枚举以外的方法可用于为每个设备获取专用套接字？

场景和规则：

我正在Windows 7上开发一个应用程序，使用Microsoft和ANSI C编译器。应用程序设计要求它检测范围内的任何IrDA设备，使用套接字进行连接，并进行通信。通信将通过多个IrDA连接器(每个设备一根)与多个设备通信，每个设备通过USB连接到PC上。注意:避免使用虚拟COM端口。

的目标：将每个设备连接到自己的套接字上，在它和应用软件之间提供一个专用的通信通道。

下面是示例和源代码(用于枚举IrDA设备)。

编辑

演示1:总体场景：

演示2:来自设备管理器：

演示3:每个“找到的”IrDA设备的属性：

​

这里是枚举两个或多个唯一的IrDA设备的代码：(测试和工作良好)

    //Adapted from:  http://msdn.microsoft.com/en-us/library/windows/desktop/ms738544(v=vs.85).aspx
    #include <winsock2.h>
    #include <ws2tcpip.h>
    #include <af_irda.h>
    #include <stdio.h>
    #include <windows.h>

    // link with Ws2_32.lib
    char* iGetLastErrorText(DWORD nErrorCode);


    int __cdecl main(void)
    {

        //-----------------------------------------
        // Declare and initialize variables
        WSADATA wsaData;

        int iResult;
        int i, tries = 0;
        DWORD dwError;

        SOCKET Sock = INVALID_SOCKET;

    #define DEVICE_LIST_LEN    10


        SOCKADDR_IRDA DestSockAddr = { AF_IRDA, 0, 0, 0, 0, "SampleIrDAService" };

        unsigned char DevListBuff[sizeof (DEVICELIST) -
                      sizeof (IRDA_DEVICE_INFO) +
                      (sizeof (IRDA_DEVICE_INFO) * DEVICE_LIST_LEN)];

        int DevListLen = sizeof (DevListBuff);
        PDEVICELIST pDevList;

        pDevList = (PDEVICELIST) & DevListBuff;

        // Initialize Winsock
        iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
        if (iResult != 0) {
        printf("WSAStartup failed: %d\n", iResult);
        return 1;
        }

        Sock = socket(AF_IRDA, SOCK_STREAM, 0);
        if (Sock == INVALID_SOCKET) {
        dwError = WSAGetLastError();
        printf
            ("socket failed trying to create an AF_IRDA socket with error %d\n",
             dwError);

        if (dwError == WSAEAFNOSUPPORT) {
            printf("Check that the local computer has an infrared device\n");
            printf
            ("and a device driver is installed for the infrared device\n");
        }
        WSACleanup();
        return 1;
        }

        pDevList->numDevice = 0;

        while((pDevList->numDevice < 2)&&( tries++ < 3 ))
        {
            // Sock is not in connected state
            iResult = getsockopt(Sock, SOL_IRLMP, IRLMP_ENUMDEVICES,
                     (char *) pDevList, &DevListLen);

            if (iResult == SOCKET_ERROR) {
            printf("getsockopt failed with error %d - %s\n", WSAGetLastError(), iGetLastErrorText(WSAGetLastError()));
                iResult = closesocket(Sock);
                if(iResult == SOCKET_ERROR)
                {
                printf("closesocket failed with error %d - %s\n", WSAGetLastError(), iGetLastErrorText(WSAGetLastError()));
                WSACleanup();
                    getchar();
                return 1;
                }
            WSACleanup();
                getchar();
            return 1;
            }

            if (pDevList->numDevice == 0) {
            // no devices discovered or cached
            // not a bad idea to run a couple of times
            printf("No IRDA devices were discovered or cached\n");
            } else {
            // one per discovered device
            printf("pDevList->numDevice = %d\n", pDevList->numDevice);
                for (i = 0; i < (int) pDevList->numDevice; i++) {

                    printf( "irdaCharSet: %d\nHints1: %d\nHints2: %d\nDeviceID: %x\nDeviceName: %s\n\n", 
                             pDevList->Device[i].irdaCharSet, 
                             pDevList->Device[i].irdaDeviceHints1, 
                             pDevList->Device[i].irdaDeviceHints2, 
                             pDevList->Device[i].irdaDeviceID, 
                             pDevList->Device[i].irdaDeviceName);





                    // typedef struct _IRDA_DEVICE_INFO
                // {
                //     u_char    irdaDeviceID[4];
                //     char      irdaDeviceName[22];
                //     u_char    irdaDeviceHints1;
                //     u_char    irdaDeviceHints2;
                //     u_char    irdaCharSet;
                // } _IRDA_DEVICE_INFO;

                // pDevList->Device[i]. see _IRDA_DEVICE_INFO for fields
                // display the device names and let the user select one
            }
            }
        }

        // assume the user selected the first device [0]
        memcpy(&DestSockAddr.irdaDeviceID[0], &pDevList->Device[0].irdaDeviceID[0],4);

        iResult = connect(Sock, (const struct sockaddr *) &DestSockAddr, sizeof (SOCKADDR_IRDA));
        if (iResult == SOCKET_ERROR) 
        {
            if (iResult == SOCKET_ERROR) {
            printf("connect failed with error %d - %s\n", WSAGetLastError(), iGetLastErrorText(WSAGetLastError()));
                iResult = closesocket(Sock);
                if(iResult == SOCKET_ERROR)
                {
                printf("closesocket failed with error %d - %s\n", WSAGetLastError(), iGetLastErrorText(WSAGetLastError()));
                WSACleanup();
                    getchar();
                return 1;
                }
            WSACleanup();
                getchar();
            return 1;
            }
        } 
        else 
        {
            printf("connect to first IRDA device was successful\n");
        }

        getchar();

        WSACleanup();
        return 0;
    }       

    char* iGetLastErrorText(DWORD nErrorCode)
    {
        char* msg;
        // Ask Windows to prepare a standard message for a GetLastError() code:
        FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, nErrorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&msg, 0, NULL);
        // Return the message
        if (!msg)
        return("Unknown error");
        else
        return(msg);
    }

Answer 1

结束了这个老问题的循环：简短的回答是不，没有其他的方法。

IrDA套接字是创建的，在我的例子中，在Windows7中，是基于对任何和所有IrDA信号在活动和范围内的询问而枚举的。枚举过程为存储它找到的每个唯一的设备ID (特别是IrDA Dev id)的数据。如果它看到3个唯一的设备it，则可以存储每个it的数据，并使连接可用以完成连接。随后，对于每个连接，可以与每个设备进行单独的对话。但是，如果相同的三个设备处于活动状态，并且在范围内，具有相同的设备ID ，则Windows将只存储与该一个ID相对应的数据，并且只能进行一个连接。