init.c

WinCE5.0部分核心源码

            RegSetValueEx(hKey, L"Prefix", 0, REG_SZ, 
                (BYTE *) DHCPV6_DEV_PREFIX, 8);
            Index = DHCPV6_DEV_INDEX;
            RegSetValueEx(hKey, L"Index", 0, REG_DWORD, (BYTE *) &Index, 
                sizeof(DWORD));
            RegCloseKey(hKey);
        }

        if (! ActivateDevice(DHCPV6DevPath, 0)) {
            DEBUGMSG(ZONE_ERROR, (TEXT("DhcpV6L: ActivateDevice call failed!\r\n")));
        }
    	
        // Timer Q support
        WCE_Initialize();

		return fStatus;

	case DHCP_PROBE:
		return TRUE;
		break;

	default:
		fStatus = FALSE;
		break;
	}
	
	if (Status != DHCP_SUCCESS) {
		SetLastError(Status);
		fStatus = FALSE;
	}

	return fStatus;
}	// DhcpV6L()

void ReadyToGo() {
    HANDLE  hThread;
    DWORD   dwThreadId;
	
	DEBUGMSG(ZONE_INIT, (TEXT("*DhcpV6L:ReadyToGo\r\n")));

	if (hThread = CreateThread(NULL, 0, 
		(LPTHREAD_START_ROUTINE)DhcpV6Startup, NULL, 0, &dwThreadId)) {

        CloseHandle(hThread);
   }

}



// Return Non-Zero for success, will be passed to Deinit and Open

DWORD
DP6_Init(
	DWORD dwContext) // Specifies a pointer to a string containing the registry path to the active key for the installable device driver.
{
   DEBUGMSG(1, (TEXT("+DP6_Init(%x)\n"), dwContext));

   return 1;
}


//	@func PVOID | DP6_Deinit | Device deinitialization routine
//  @parm DWORD | dwData | value returned from IP6_Init call
//  @rdesc	Returns TRUE for success, FALSE for failure.
//	@remark	Routine exported by a device driver.  "NDT" is the string
//			passed in as lpszType in RegisterDevice

BOOL
DP6_Deinit(DWORD dwData)
{
	return TRUE;
}

//	@func PVOID | IP6_Open		| Device open routine
//  @parm DWORD | dwData		| value returned from IP6_Init call
//  @parm DWORD | dwAccess		| requested access (combination of GENERIC_READ
//								  and GENERIC_WRITE)
//  @parm DWORD | dwShareMode	| requested share mode (combination of
//								  FILE_SHARE_READ and FILE_SHARE_WRITE)
//  @rdesc	Returns a DWORD which will be passed to Read, Write, etc or NULL if
//			unable to open device.
//	@remark	Routine exported by a device driver.  "NDT" is the string passed
//			in as lpszType in RegisterDevice
DWORD
DP6_Open (DWORD dwData, DWORD dwAccess, DWORD dwShareMode)
{
	// Return Non-Null for success, other will be passed to Read etc.
	return 2;
}


BOOL
DP6_Close (DWORD dwData) 
{
	//DEBUGMSG (ZONE_TRACE, (TEXT("IP6_Close(0x%X)\r\n"), dwData));
	return TRUE;
}



//  @rdesc	Returns 0 for end of file, -1 for error, otherwise the number of
//			bytes read.  The length returned is guaranteed to be the length
//			requested unless end of file or an error condition occurs.

DWORD
DP6_Read (DWORD dwData, LPVOID pBuf, DWORD Len)
{
	// Return length read
	return 0;
}


//  @rdesc	Returns -1 for error, otherwise the number of bytes written.  The
//			length returned is guaranteed to be the length requested unless an
//			error condition occurs.

DWORD
DP6_Write (DWORD dwData, LPCVOID pBuf, DWORD Len)
{
	// return number of bytes written (or -1 for error)
	return 0;
}


//  @rdesc	Returns current position relative to start of file, or -1 on error
//	@remark	Routine exported by a device driver.  "NDT" is the string passed
//		 in as lpszType in RegisterDevice

DWORD
DP6_Seek (DWORD dwData, long pos, DWORD type)
{
	// return an error
	return (DWORD)-1;
}

//	@func void | IP6_PowerUp | Device powerup routine
//	@comm	Called to restore device from suspend mode.  You cannot call any
//			routines aside from those in your dll in this call.

void
DP6_PowerUp(void)
{
}
//	@func void | IP6_PowerDown | Device powerdown routine
//	@comm	Called to suspend device.  You cannot call any routines aside from
//			those in your dll in this call.
void
DP6_PowerDown(void)
{
}


BOOL IoctlEnumDhcpV6Interfaces(PBYTE pBufIn, DWORD dwLenIn, void * pBufOut, 
    DWORD dwLenOut, PDWORD pdwActualOut) {
    
    DHCPV6_IOCTL_ENUM_PARAMS    *pParams = pBufOut;

    if (dwLenOut >= sizeof(*pParams)) {    
        pParams->Status = EnumDhcpV6Interfaces(NULL, pParams->dwVersion, NULL,
            pParams->dwPreferredNumEntries, 
            (void *)&(pParams->pDhcpV6Interfaces),
            &pParams->dwNumInterfaces, &pParams->dwTotalNumInterfaces,
            &pParams->dwResumeHandle, &pParams->pvReserved);

        pParams->CallType = IOCTL_DHCPV6L_ENUMERATE_INTERFACES;
    } else {
        pParams->Status = ERROR_OUTOFMEMORY;
    }

    return (ERROR_SUCCESS == pParams->Status);

}   // IoctlEnumDhcpV6Interfaces()

BOOL IoctlOpenDhcpV6InterfaceHandle(PBYTE pBufIn, DWORD dwLenIn, 
    void * pBufOut, DWORD dwLenOut, PDWORD pdwActualOut) {
    
    DHCPV6_IOCTL_INTERFACE_PARAMS   *pParams = pBufOut;

    if (dwLenOut >= sizeof(*pParams)) {    
        pParams->Status = OpenDhcpV6InterfaceHandle(NULL, pParams->dwVersion,
            (void *)&pParams->DhcpV6Interface, &pParams->pvReserved,
            &pParams->hInterface);
        pParams->CallType = IOCTL_DHCPV6L_OPEN_HANDLE;
    } else {
        pParams->Status = ERROR_OUTOFMEMORY;
    }

    return (ERROR_SUCCESS == pParams->Status);

}   // IoctlOpenDhcpV6InterfaceHandle()


BOOL IoctlCloseDhcpV6InterfaceHandle(PBYTE pBufIn, DWORD dwLenIn, 
    void * pBufOut, DWORD dwLenOut, PDWORD pdwActualOut) {
    
    DHCPV6_IOCTL_INTERFACE_PARAMS   *pParams = pBufOut;

    if (dwLenOut >= sizeof(*pParams)) {    
        pParams->Status = CloseDhcpV6InterfaceHandle(pParams->hInterface);
        pParams->CallType = IOCTL_DHCPV6L_CLOSE_HANDLE;
    } else {
        pParams->Status = ERROR_OUTOFMEMORY;
    }

    return (ERROR_SUCCESS == pParams->Status);

}   // IoctlCloseDhcpV6InterfaceHandle()


BOOL IoctlPerformDhcpV6Refresh(PBYTE pBufIn, DWORD dwLenIn, 
    void * pBufOut, DWORD dwLenOut, PDWORD pdwActualOut) {
    
    DHCPV6_IOCTL_INTERFACE_PARAMS   *pParams = pBufOut;

    if (dwLenOut >= sizeof(*pParams)) {    
        pParams->Status = PerformDhcpV6Refresh(pParams->hInterface, 
            pParams->dwVersion, &pParams->pvReserved);
        pParams->CallType = IOCTL_DHCPV6L_REFRESH;
    } else {
        pParams->Status = ERROR_OUTOFMEMORY;
    }

    return (ERROR_SUCCESS == pParams->Status);

}   // IoctlPerformDhcpV6Refresh()


BOOL IoctlGetDhcpV6DNSList(PBYTE pBufIn, DWORD dwLenIn, 
    void * pBufOut, DWORD dwLenOut, PDWORD pdwActualOut) {
    
    DHCPV6_IOCTL_INTERFACE_PARAMS   *pParams = pBufOut;

    if (dwLenOut >= sizeof(*pParams)) {    
        pParams->Status = GetDhcpV6DNSList(pParams->hInterface, 
            pParams->dwVersion, (void *)&pParams->pDhcpV6DNSList, 
            &pParams->pvReserved);
        pParams->CallType = IOCTL_DHCPV6L_GET_DNS_LIST;
    } else {
        pParams->Status = ERROR_OUTOFMEMORY;
    }

    return (ERROR_SUCCESS == pParams->Status);

}   // IoctlGetDhcpV6DNSList()

BOOL IoctlGetDhcpV6PDList(PBYTE pBufIn, DWORD dwLenIn, 
    void * pBufOut, DWORD dwLenOut, PDWORD pdwActualOut) {
    
    DHCPV6_IOCTL_INTERFACE_PARAMS   *pParams = pBufOut;

    if (dwLenOut >= sizeof(*pParams)) {    
        pParams->Status = GetDhcpV6PDList(pParams->hInterface, 
            pParams->dwVersion, (void *)&pParams->pPrefixD, 
            &pParams->pvReserved);
        pParams->CallType = IOCTL_DHCPV6L_GET_PD_LIST;
    } else {
        pParams->Status = ERROR_OUTOFMEMORY;
    }

    return (ERROR_SUCCESS == pParams->Status);

}   // IoctlGetDhcpV6PDList()


BOOL IoctlGetDhcpV6DomainList(PBYTE pBufIn, DWORD dwLenIn, 
    void * pBufOut, DWORD dwLenOut, PDWORD pdwActualOut) {
    
    DHCPV6_IOCTL_INTERFACE_PARAMS   *pParams = pBufOut;

    if (dwLenOut >= sizeof(*pParams)) {    
        pParams->Status = GetDhcpV6DomainList(pParams->hInterface, 
            pParams->dwVersion, (void *)&pParams->pDomainList, 
            &pParams->pvReserved);
        pParams->CallType = IOCTL_DHCPV6L_GET_DOMAIN_LIST;
    } else {
        pParams->Status = ERROR_OUTOFMEMORY;
    }

    return (ERROR_SUCCESS == pParams->Status);

}   // IoctlGetDhcpV6DomainList()


BOOL IoctlDhcpV6FreeMem(PBYTE pBufIn, DWORD dwLenIn, 
    void * pBufOut, DWORD dwLenOut, PDWORD pdwActualOut) {

    DHCPV6_IOCTL_HDR *pHdr = (DHCPV6_IOCTL_HDR *)pBufIn;
    DWORD   i;
    DHCPV6_IOCTL_ENUM_PARAMS *pEnum;
    DHCPV6_IOCTL_INTERFACE_PARAMS   *pParams = 
        (DHCPV6_IOCTL_INTERFACE_PARAMS *)pBufIn;

    if (dwLenIn < sizeof(*pHdr)) {
        pHdr->Status = ERROR_INSUFFICIENT_BUFFER;
        goto Exit;
    }

    pHdr->Status = ERROR_SUCCESS;

    switch (pHdr->CallType) {
    case IOCTL_DHCPV6L_OPEN_HANDLE:
    case IOCTL_DHCPV6L_CLOSE_HANDLE:
    case IOCTL_DHCPV6L_REFRESH:

        // nothing to free in these cases!

        break;

        
    case IOCTL_DHCPV6L_ENUMERATE_INTERFACES:
        pEnum = (DHCPV6_IOCTL_ENUM_PARAMS *)pBufIn;
        if (dwLenIn < sizeof(*pEnum)) {
            pHdr->Status = ERROR_INSUFFICIENT_BUFFER;
            goto Exit;
        }

        if (pEnum->pDhcpV6Interfaces) {
            for (i = 0; i < pEnum->dwNumInterfaces; i++) {
                // DHCPv6FreeBuffer currently checks for NULL, if this
                // changes we'll need to check for NULL here!
                DHCPv6FreeBuffer(pEnum->pDhcpV6Interfaces[i].pszDescription);
            }
            DHCPv6FreeBuffer(pEnum->pDhcpV6Interfaces);
            pEnum->pDhcpV6Interfaces = NULL;
        }
        break;

    case IOCTL_DHCPV6L_GET_DNS_LIST:
        if (dwLenIn < sizeof(*pParams)) {
            pHdr->Status = ERROR_INSUFFICIENT_BUFFER;
            goto Exit;
        }

        if (pParams->pDhcpV6DNSList) {
            DHCPv6FreeBuffer(pParams->pDhcpV6DNSList->pDhcpV6DNS);
            DHCPv6FreeBuffer(pParams->pDhcpV6DNSList);
            pParams->pDhcpV6DNSList = NULL;
        }        
        break;

    case IOCTL_DHCPV6L_GET_PD_LIST:
        if (dwLenIn < sizeof(*pParams)) {
            pHdr->Status = ERROR_INSUFFICIENT_BUFFER;
            goto Exit;
        }

        if (pParams->pPrefixD) {
            DHCPv6FreeBuffer(pParams->pPrefixD);
            pParams->pPrefixD = NULL;
        }
        break;

    case IOCTL_DHCPV6L_GET_DOMAIN_LIST:
        if (dwLenIn < sizeof(*pParams)) {
            pHdr->Status = ERROR_INSUFFICIENT_BUFFER;
            goto Exit;
        }

        if (pParams->pDomainList) {
            DHCPv6FreeBuffer(pParams->pDomainList);
            pParams->pDomainList = NULL;
        }
        break;

    default:
        pHdr->Status = ERROR_INVALID_DATA;
        break;
    }

Exit:
    return (ERROR_SUCCESS == pHdr->Status);

}   // IoctlGetDhcpV6DomainList()


//	@func BOOL | DP6_IOControl | Device IO control routine
//  @parm DWORD | dwOpenData | value returned from DP6_Open call
//  @parm DWORD | dwCode | io control code to be performed
//  @parm PBYTE | pBufIn | input data to the device
//  @parm DWORD | dwLenIn | number of bytes being passed in
//  @parm PBYTE | pBufOut | output data from the device
//  @parm DWORD | dwLenOut |maximum number of bytes to receive from device
//  @parm PDWORD | pdwActualOut | actual number of bytes received from device
//  @rdesc	Returns TRUE for success, FALSE for failure
//	@remark	Routine exported by a device driver.  "NDT" is the string passed
//		in as lpszType in RegisterDevice


BOOL
DP6_IOControl(
	IN		DWORD dwOpenData, 
	IN		DWORD dwCode, 
	IN		PBYTE pBufIn,
	IN		DWORD dwLenIn,
	IN	OUT	PBYTE pBufOut,
	IN		DWORD dwLenOut,
	IN	OUT	PDWORD pdwActualOut)
{
    BOOL Status;

    if ((dwLenIn < sizeof(DHCPV6_IOCTL_HDR)) || 
        (dwLenOut < sizeof(DHCPV6_IOCTL_HDR))) {
        Status = FALSE;
        goto Exit;
    }

    switch (dwCode) {
    case IOCTL_DHCPV6L_ENUMERATE_INTERFACES:
        Status = IoctlEnumDhcpV6Interfaces(pBufIn, dwLenIn, pBufOut, 
            dwLenOut, pdwActualOut);
        break;
    case IOCTL_DHCPV6L_OPEN_HANDLE:
        Status = IoctlOpenDhcpV6InterfaceHandle(pBufIn, dwLenIn, pBufOut, 
            dwLenOut, pdwActualOut);
        break;
    case IOCTL_DHCPV6L_CLOSE_HANDLE:
        Status = IoctlCloseDhcpV6InterfaceHandle(pBufIn, dwLenIn, pBufOut, 
            dwLenOut, pdwActualOut);
        break;
    case IOCTL_DHCPV6L_REFRESH:
        Status = IoctlPerformDhcpV6Refresh(pBufIn, dwLenIn, pBufOut, 
            dwLenOut, pdwActualOut);
        break;
    case IOCTL_DHCPV6L_GET_DNS_LIST:
        Status = IoctlGetDhcpV6DNSList(pBufIn, dwLenIn, pBufOut, dwLenOut, 
            pdwActualOut);
        break;
    case IOCTL_DHCPV6L_GET_PD_LIST:
        Status = IoctlGetDhcpV6PDList(pBufIn, dwLenIn, pBufOut, 
            dwLenOut, pdwActualOut);
        break;
    case IOCTL_DHCPV6L_GET_DOMAIN_LIST:
        Status = IoctlGetDhcpV6DomainList(pBufIn, dwLenIn, pBufOut, 
            dwLenOut, pdwActualOut);
        break;
    case IOCTL_DHCPV6L_FREE_MEMORY:
        Status = IoctlDhcpV6FreeMem(pBufIn, dwLenIn, pBufOut, 
            dwLenOut, pdwActualOut);
        break;
    default:
        Status = FALSE;
    }

    if (Status) {
        DHCPV6_IOCTL_HDR *pHdr = (DHCPV6_IOCTL_HDR *)pBufOut;
        pHdr->CallType = dwCode;
    }
        

Exit:
    return Status;

}