Question

我是将Windows CE 5.0设备的HTTPD Web服务器耦合到在同一Windows CE设备上运行的.NET应用程序的最实用的方法是什么？

我的第一个想法是构建一个ISAPI扩展，将传入的http请求转发到.NET应用程序。不知道怎么做！可能是共享内存，COM，TCP / IP套接字？

另一种方法是，在.NET应用程序本身内实现独立的HTTP服务器，避免使用HTTPD。

任何经验或想法？

由于克里斯

Answer 1

在CE Web服务器中运行.NET代码的关键是将服务器dll加载到.NET进程中。几年前我做了一个概念验证来证明这一点。

设计看起来有点复杂，但有几个优点：

.NET代码和非托管ISAPI扩展可以在Web服务器中并行运行
加密和身份验证等Web服务器功能仍然有效
资源继续由Web服务器管理，包括线程池
性能方面可能胜过任何基于单独流程和IPC的解决方案

首先，我们需要阻止Windows CE自动启动Web服务器。将其添加到注册表中：

[HKEY_LOCAL_MACHINE\Services\HTTPD]
    "Flags"=dword:4  ; DEVFLAGS_NOLOAD

在我们处理此问题时，请添加另一个密钥以映射＆＃39; / dotnet＆＃39;到我们的自定义ISAPI处理程序：

[HKEY_LOCAL_MACHINE\Comm\HTTPD\VROOTS\/dotnet]
    @="\\Windows\\HttpdHostUnmanaged.dll"

现在从以下源代码创建名为HttpdHostProc.exe的.NET exe：

using System;
using System.Runtime.InteropServices;
using System.Text;

class HttpdHostProc
{
    static void Main(string[] args)
    {
        GetExtensionVersionDelegate pInit =
            new GetExtensionVersionDelegate(GetExtensionVersion);
        TerminateExtensionDelegate pDeinit
            = new TerminateExtensionDelegate(TerminateExtension);
        HttpExtensionProcDelegate pProc =
            new HttpExtensionProcDelegate(HttpExtensionProc);

        Init(pInit, pDeinit, pProc);

        int state = SERVICE_INIT_STOPPED | SERVICE_NET_ADDR_CHANGE_THREAD;
        int context = HTP_Init(state);

        HTP_IOControl(context, IOCTL_SERVICE_REGISTER_SOCKADDR,
             IntPtr.Zero, 0, IntPtr.Zero, 0, IntPtr.Zero);

        HTP_IOControl(context, IOCTL_SERVICE_STARTED,
             IntPtr.Zero, 0, IntPtr.Zero, 0, IntPtr.Zero);

        RunHttpd(context, 80);
    }

    static int GetExtensionVersion(IntPtr pVer)
    {
        OutputDebugString("GetExtensionVersion from .NET\r\n");
        return 1;
    }

    static int TerminateExtension(int dwFlags)
    {
        OutputDebugString("TerminateExtension from .NET\r\n");
        return 1;
    }

    static int HttpExtensionProc(IntPtr pECB)
    {
        OutputDebugString("HttpExtensionProc from .NET\r\n");

        var response = "<html><head></head><body><p>Hello .NET!</p></body></html>";
        var bytes = Encoding.UTF8.GetBytes(response);
        var length = bytes.Length;

        var unmanagedbuffer = Marshal.AllocHGlobal(length);
        Marshal.Copy(bytes, 0, unmanagedbuffer, length);

        var retval = WriteClient(pECB, unmanagedbuffer, ref length);

        Marshal.FreeHGlobal(unmanagedbuffer);

        return retval;
    }

    delegate int GetExtensionVersionDelegate(IntPtr pVer);
    delegate int TerminateExtensionDelegate(int dwFlags);
    delegate int HttpExtensionProcDelegate(IntPtr pECB);

    [DllImport("HttpdHostUnmanaged.dll", SetLastError = true)]
    extern static void Init(
        GetExtensionVersionDelegate pInit,
        TerminateExtensionDelegate pDeinit,
        HttpExtensionProcDelegate pProc
    );

    [DllImport("HttpdHostUnmanaged.dll", SetLastError = true)]
    extern static int RunHttpd(int context, int port);

    [DllImport("HttpdHostUnmanaged.dll", SetLastError = true)]
    extern static int WriteClient(IntPtr pECB, IntPtr Buffer, ref int lpdwBytes);

    [DllImport("coredll.dll")]
    extern static void OutputDebugString(string msg);

    [DllImport("httpd.dll", SetLastError = true)]
    extern static int HTP_Init(int dwData);

    [DllImport("httpd.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    extern static bool HTP_IOControl(int dwData, int dwCode, IntPtr pBufIn,
        int dwLenIn, IntPtr pBufOut, int dwLenOut, IntPtr pdwActualOut);

    const int IOCTL_SERVICE_STARTED = 0x01040038;
    const int IOCTL_SERVICE_REGISTER_SOCKADDR = 0x0104002c;

    const int SERVICE_INIT_STOPPED = 0x00000001;
    const int SERVICE_NET_ADDR_CHANGE_THREAD = 0x00000008;
}

一些评论：

Main函数加载并初始化我们的非托管dll，它将作为托管代码和非托管代码之间的垫脚石
然后通过调用HTP_Init函数初始化并启动Web服务器，然后调用几个ioctls
最后，它在我们的非托管dll中调用RunHttpd，它将接受传入的请求并将它们转发到Web服务器。

如果你曾经做过任何ISAPI编程，那么下面的三个函数 - GetExtensionVersion，TerminateExtension，HttpExtensionProc - 应该看起来很熟悉。如果没有，您真正需要知道的是传入请求由HttpExtensionProc处理。

转到非托管dll，HttpdHostUnmanaged.dll：

#include <winsock2.h>
#include <httpext.h>

typedef BOOL (* pfHTP_IOControl)(DWORD dwData, DWORD dwCode, PBYTE pBufIn,
    DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut, PDWORD pdwActualOut);

typedef BOOL (* PFN_WRITE_CLIENT)(HCONN ConnID, LPVOID Buffer,
    LPDWORD lpdwBytes, DWORD dwReserved);

static PFN_GETEXTENSIONVERSION g_pInit;
static PFN_TERMINATEEXTENSION g_pDeinit;
static PFN_HTTPEXTENSIONPROC g_pProc;

BOOL APIENTRY DllMain(HANDLE, DWORD, LPVOID)
{
    return TRUE;
}

extern "C" void Init(
    PFN_GETEXTENSIONVERSION pInit,
    PFN_TERMINATEEXTENSION pDeinit,
    PFN_HTTPEXTENSIONPROC pProc)
{
    // Store pointers to .NET delegates
    g_pInit = pInit;
    g_pDeinit = pDeinit;
    g_pProc = pProc;
}

extern "C" BOOL WINAPI GetExtensionVersion(HSE_VERSION_INFO *pVer)
{
    pVer->dwExtensionVersion = HSE_VERSION;
    strncpy(pVer->lpszExtensionDesc, "HttpdHostUnmanaged",
        HSE_MAX_EXT_DLL_NAME_LEN);

    // Call .NET GetExtensionVersion
    return g_pInit(pVer);
}

extern "C" BOOL WINAPI TerminateExtension(DWORD dwFlags)
{
    // Call .NET TerminateExtension
    return g_pDeinit(dwFlags);
}

extern "C" DWORD WINAPI HttpExtensionProc(EXTENSION_CONTROL_BLOCK *pECB)
{
    // Call .NET HttpExtensionProc
    return g_pProc(pECB);
}

extern "C" DWORD WINAPI WriteClient(EXTENSION_CONTROL_BLOCK *pECB,
    LPVOID Buffer, LPDWORD lpdwBytes)
{
    return pECB->WriteClient(pECB->ConnID, Buffer, lpdwBytes, 0);
}

extern "C" int WINAPI RunHttpd(DWORD context, int port)
{
    // Load web server and start accepting connections.
    // When a connection comes in,
    // pass it to httpd using IOCTL_SERVICE_CONNECTION.

    HMODULE hDll = LoadLibrary(L"httpd.dll");
    if(!hDll)
    {
        return -1;
    }

    pfHTP_IOControl Ioctl =
        (pfHTP_IOControl)GetProcAddress(hDll, L"HTP_IOControl");
    if(!Ioctl)
    {
        FreeLibrary(hDll);
        return -2;
    }

    WSADATA Data;
    int status = WSAStartup(MAKEWORD(1, 1), &Data);
    if(status != 0)
    {
        FreeLibrary(hDll);
        return status;
    }

    SOCKET s = socket(PF_INET, SOCK_STREAM, 0);
    if(s == INVALID_SOCKET)
    {
        status = WSAGetLastError();
        goto exit;
    }

    SOCKADDR_IN sAddr;
    memset(&sAddr, 0, sizeof(sAddr));
    sAddr.sin_port = htons(port);
    sAddr.sin_family = AF_INET;
    sAddr.sin_addr.s_addr = htonl(INADDR_ANY);

    if(bind(s, (LPSOCKADDR)&sAddr, sizeof(sAddr)) == SOCKET_ERROR)
    {
        status = WSAGetLastError();
        goto exit;
    }

    if(listen(s, SOMAXCONN) == SOCKET_ERROR)
    {
        status = WSAGetLastError();
        goto exit;
    }

    for(;;)
    {
        SOCKADDR_IN addr;
        int cbAddr = sizeof(addr);

        SOCKET conn = accept(s, (LPSOCKADDR)&addr, &cbAddr);

        if(conn == INVALID_SOCKET)
        {
            status = WSAGetLastError();
            goto exit;
        }

        DWORD IOCTL_SERVICE_CONNECTION = 0x01040034;
        Ioctl(context, IOCTL_SERVICE_CONNECTION,
            (PBYTE)&conn, sizeof(conn), NULL, 0, NULL);
    }

exit:
    FreeLibrary(hDll);

    if(s != INVALID_SOCKET)
    {
        closesocket(s);
    }

    WSACleanup();
    return status;
}

有许多非常有趣的函数可以转发.NET和来自.NET。

如上所述，RunHttpd函数只接受传入连接并将它们传递给Web服务器，以便通过另一个ioctl进行处理。

要全部测试，请在设备上启动HttpdHostProc.exe，然后在浏览器中打开http://<ipaddr>/dotnet。 CE设备应该回复一些HTML，其中包含消息＆＃34; Hello .NET！＆＃34;。

此代码在带有.NET Compact Framework 3.5的Windows Embedded Compact 7.0上运行，但也可能适用于其他版本。

我在Pocket PC 2003 SDK上构建了非托管dll，因为那是我碰巧安装的内容。可能任何Windows CE SDK都可以，但您可能需要调整编译器设置，例如我必须使用/ GS-（禁用缓冲区安全检查）为PPC2003构建。

在.NET中实现RunHttpd函数也很诱人，但要注意它有几个潜在的问题：

在我的测试中，.NET CF套接字上的Handle属性返回了一种伪句柄，它不适用于本机套接字API
套接字的生命周期将由.NET运行时管理，这使得将套接字的所有权传递给Web服务器变得特别困难

如果您不介意使用/ unsafe进行编译，可以通过将固定缓冲区传递给WriteClient来略微提高性能，而不是将所有响应数据复制到HttpExtensionProc中的非托管缓冲区。

EXTENSION_CONTROL_BLOCK结构包含许多有用的字段和函数，显然需要包含在完整的实现中。

修改

只是澄清请求的处理方式：

RunHttpd接受传入请求，使用ioctl将其转发到Web服务器

根据我们之前设置的注册表中的vroot条目，Web服务器调用HttpdHostUnmanaged.dll来处理/ dotnet的请求

如果这是/ dotnet的第一个请求，则Web服务器通过在HttpdHostUnmanaged.dll中调用非托管版本的GetExtensionVersion来启动。非托管的GetExtensionVersion回调到GetExtensionVersion的.NET版本。 GetExtensionVersion是一个可以初始化所需资源的常用位置，因为它只调用一次（相应的清理函数是TerminateExtension，当web服务器决定卸载HttpdHostUnmanaged.dll时调用它）

接下来，Web服务器调用非托管HttpExtensionProc

非托管HttpExtensionProc回调到HttpExtensionProc的.NET版本

托管的HttpExtensionProc生成响应，并调用非托管WriteClient将其传递给客户端

Answer 2

在我看来，基于过去尝试使用内置的HTTPD服务器，内置服务器绝对很难尝试做任何有用的事情。调试任何东西都很头疼，与任何设备硬件/系统互操作都很痛苦。

由于CF中没有EE Hosting支持，因此Web服务器无法加载托管程序集（来自ISAPI或其他任何内容）。这意味着您的托管代码必须在一个单独的进程中进行通信，您必须使用IPC - 类似P2PMessageQueue，MemoryMappedFile，套接字等。

编写自己的HTTPD服务器也是一种选择，但这不是一项简单的任务。这听起来很简单，但是一旦你深入了解它就会涉及很多。我知道，因为几年前我们在一个项目上做出了这个决定，我们最终创建的服务器支持ASP.NET的一个子集，我们实际上把它变成了commercial product因为a）它真的很有用而且b因为实际写作花了很多工作。但是，它确实提供了托管托管代码的好处，并且能够在托管开发人员期望的Studio中调试而不是printf。

Windows CE 5.0 HTTPD＆lt; - ＆gt; .NET应用程序

2 个答案: