helpers.c

winNT技术操作系统,国外开放的原代码和LIUX一样

        AFD_DbgPrint(MIN_TRACE, ("Error reading transport list registry\n"));
        return WSAEINVAL;
    }

    /* Allocate Memory for the Transport List */
    *TransportList = HeapAlloc(GlobalHeap, 0, TransportListSize);

    /* Check for error */
    if (*TransportList == NULL) {
        AFD_DbgPrint(MIN_TRACE, ("Buffer allocation failed\n"));
        return WSAEINVAL;
    }

    /* Get the Transports */
    Status = RegQueryValueExW (KeyHandle, 
                               L"Transports", 
                               NULL, 
                               NULL, 
                               (LPBYTE)*TransportList, 
                               &TransportListSize);

    /* Check for error */
    if (Status) {
        AFD_DbgPrint(MIN_TRACE, ("Error reading transport list registry\n"));
        HeapFree(GlobalHeap, 0, *TransportList);
        return WSAEINVAL;
    }

    /* Close key and return */
    RegCloseKey(KeyHandle);
    return 0;
}

INT
SockLoadHelperDll(
    PWSTR TransportName, 
    PWINSOCK_MAPPING Mapping, 
    PHELPER_DATA *HelperDllData)
{
    PHELPER_DATA	HelperData;
    PWSTR               HelperDllName;
    PWSTR               FullHelperDllName;
    ULONG               HelperDllNameSize;
    PWSTR               HelperKey;
    HKEY                KeyHandle;
    ULONG               DataSize;
    LONG                Status;
    
    /* Allocate space for the Helper Structure and TransportName */
    HelperData = HeapAlloc(GlobalHeap, 0, sizeof(*HelperData) + (wcslen(TransportName) + 1) * sizeof(WCHAR));

    /* Check for error */
    if (HelperData == NULL) {
        AFD_DbgPrint(MIN_TRACE, ("Buffer allocation failed\n"));
        return WSAEINVAL;
    }
    
    /* Allocate Space for the Helper DLL Key */
    HelperKey = HeapAlloc(GlobalHeap, 0, (54 + wcslen(TransportName)) * sizeof(WCHAR));
	
    /* Check for error */
    if (HelperKey == NULL) {
        AFD_DbgPrint(MIN_TRACE, ("Buffer allocation failed\n"));
        HeapFree(GlobalHeap, 0, HelperData);
        return WSAEINVAL;
    }

    /* Generate the right key name */
    wcscpy(HelperKey, L"System\\CurrentControlSet\\Services\\");
    wcscat(HelperKey, TransportName);
    wcscat(HelperKey, L"\\Parameters\\Winsock");

    /* Open the Key */
    Status = RegOpenKeyExW(HKEY_LOCAL_MACHINE, HelperKey, 0, KEY_READ, &KeyHandle);

    HeapFree(GlobalHeap, 0, HelperKey);

    /* Check for error */
    if (Status) {
        AFD_DbgPrint(MIN_TRACE, ("Error reading helper DLL parameters\n"));
        HeapFree(GlobalHeap, 0, HelperData);
        return WSAEINVAL;
    }
    
    /* Read Size of SockAddr Structures */
    DataSize = sizeof(HelperData->MinWSAddressLength);
    HelperData->MinWSAddressLength = 16;
    RegQueryValueExW (KeyHandle, 
                      L"MinSockaddrLength", 
                      NULL, 
                      NULL, 
                      (LPBYTE)&HelperData->MinWSAddressLength, 
                      &DataSize);
    DataSize = sizeof(HelperData->MinWSAddressLength);
    HelperData->MaxWSAddressLength = 16;
    RegQueryValueExW (KeyHandle, 
                      L"MaxSockaddrLength", 
                      NULL, 
                      NULL, 
                      (LPBYTE)&HelperData->MaxWSAddressLength, 
                      &DataSize);

    /* Size of TDI Structures */
    HelperData->MinTDIAddressLength = HelperData->MinWSAddressLength + 6;
    HelperData->MaxTDIAddressLength = HelperData->MaxWSAddressLength + 6;
    
    /* Read Delayed Acceptance Setting */
    DataSize = sizeof(DWORD);
    HelperData->UseDelayedAcceptance = FALSE;
    RegQueryValueExW (KeyHandle, 
                      L"UseDelayedAcceptance", 
                      NULL, 
                      NULL, 
                      (LPBYTE)&HelperData->UseDelayedAcceptance, 
                      &DataSize);

    /* Allocate Space for the Helper DLL Names */
    HelperDllName = HeapAlloc(GlobalHeap, 0, 512);

    /* Check for error */
    if (HelperDllName == NULL) {
        AFD_DbgPrint(MIN_TRACE, ("Buffer allocation failed\n"));
        HeapFree(GlobalHeap, 0, HelperData);
        return WSAEINVAL;
    }

    FullHelperDllName = HeapAlloc(GlobalHeap, 0, 512);
	
    /* Check for error */
    if (FullHelperDllName == NULL) {
        AFD_DbgPrint(MIN_TRACE, ("Buffer allocation failed\n"));
        HeapFree(GlobalHeap, 0, HelperDllName);
        HeapFree(GlobalHeap, 0, HelperData);
        return WSAEINVAL;
    }

    /* Get the name of the Helper DLL*/
    DataSize = 512;
    Status = RegQueryValueExW (KeyHandle, 
                               L"HelperDllName", 
                               NULL, 
                               NULL, 
                               (LPBYTE)HelperDllName, 
                               &DataSize);

    /* Check for error */
    if (Status) {
        AFD_DbgPrint(MIN_TRACE, ("Error reading helper DLL parameters\n"));
        HeapFree(GlobalHeap, 0, FullHelperDllName);
        HeapFree(GlobalHeap, 0, HelperDllName);
        HeapFree(GlobalHeap, 0, HelperData);
        return WSAEINVAL;
    }

    /* Get the Full name, expanding Environment Strings */
    HelperDllNameSize = ExpandEnvironmentStringsW (HelperDllName,
                                                   FullHelperDllName, 
                                                   256);

    /* Load the DLL */
    HelperData->hInstance = LoadLibraryW(FullHelperDllName);

    HeapFree(GlobalHeap, 0, HelperDllName);
    HeapFree(GlobalHeap, 0, FullHelperDllName);

    if (HelperData->hInstance == NULL) {
        AFD_DbgPrint(MIN_TRACE, ("Error loading helper DLL\n"));
        HeapFree(GlobalHeap, 0, HelperData);
        return WSAEINVAL;
    }

    /* Close Key */
    RegCloseKey(KeyHandle);

    /* Get the Pointers to the Helper Routines */
    HelperData->WSHOpenSocket =	(PWSH_OPEN_SOCKET)
									GetProcAddress(HelperData->hInstance,
									"WSHOpenSocket");
    HelperData->WSHOpenSocket2 = (PWSH_OPEN_SOCKET2)
									GetProcAddress(HelperData->hInstance,
									"WSHOpenSocket2");
    HelperData->WSHJoinLeaf = (PWSH_JOIN_LEAF)
								GetProcAddress(HelperData->hInstance,
								"WSHJoinLeaf");
    HelperData->WSHNotify = (PWSH_NOTIFY)
								GetProcAddress(HelperData->hInstance, "WSHNotify");
    HelperData->WSHGetSocketInformation = (PWSH_GET_SOCKET_INFORMATION)
											GetProcAddress(HelperData->hInstance, 
											"WSHGetSocketInformation");
    HelperData->WSHSetSocketInformation = (PWSH_SET_SOCKET_INFORMATION)
											GetProcAddress(HelperData->hInstance,
											"WSHSetSocketInformation");
    HelperData->WSHGetSockaddrType = (PWSH_GET_SOCKADDR_TYPE)
										GetProcAddress(HelperData->hInstance,
										"WSHGetSockaddrType");
    HelperData->WSHGetWildcardSockaddr = (PWSH_GET_WILDCARD_SOCKEADDR)
											GetProcAddress(HelperData->hInstance,
											"WSHGetWildcardSockaddr");
    HelperData->WSHGetBroadcastSockaddr = (PWSH_GET_BROADCAST_SOCKADDR)
											GetProcAddress(HelperData->hInstance,
											"WSHGetBroadcastSockaddr");
    HelperData->WSHAddressToString = (PWSH_ADDRESS_TO_STRING)
										GetProcAddress(HelperData->hInstance,
										"WSHAddressToString");
    HelperData->WSHStringToAddress = (PWSH_STRING_TO_ADDRESS)
										GetProcAddress(HelperData->hInstance,
										"WSHStringToAddress");
    HelperData->WSHIoctl = (PWSH_IOCTL)
							GetProcAddress(HelperData->hInstance,
							"WSHIoctl");

    /* Save the Mapping Structure and transport name */
    HelperData->Mapping = Mapping;
    wcscpy(HelperData->TransportName, TransportName);

    /* Increment Reference Count */
    HelperData->RefCount = 1;

    /* Add it to our list */
    InsertHeadList(&SockHelpersListHead, &HelperData->Helpers);

    /* Return Pointers */
    *HelperDllData = HelperData;
    return 0;
}

BOOL
SockIsTripleInMapping(
    PWINSOCK_MAPPING Mapping, 
    INT AddressFamily, 
    INT SocketType, 
    INT Protocol)
{
    /* The Windows version returns more detailed information on which of the 3 parameters failed...we should do this later */
    ULONG    Row;
    
    AFD_DbgPrint(MID_TRACE,("Called, Mapping rows = %d\n", Mapping->Rows));

    /* Loop through Mapping to Find a matching one */
    for (Row = 0; Row < Mapping->Rows; Row++) {
	AFD_DbgPrint(MID_TRACE,("Examining: row %d: AF %d type %d proto %d\n",
				Row,
				(INT)Mapping->Mapping[Row].AddressFamily,
				(INT)Mapping->Mapping[Row].SocketType,
				(INT)Mapping->Mapping[Row].Protocol));

        /* Check of all three values Match */
        if (((INT)Mapping->Mapping[Row].AddressFamily == AddressFamily) && 
            ((INT)Mapping->Mapping[Row].SocketType == SocketType) && 
            ((INT)Mapping->Mapping[Row].Protocol == Protocol)) {
	    AFD_DbgPrint(MID_TRACE,("Found\n"));
            return TRUE;
        }
    }
    AFD_DbgPrint(MID_TRACE,("Not found\n"));
    return FALSE;
}

/* EOF */