ticksrv.cpp

《Windows CE 6.0开发者参考》（《Programming Windows Embedded CE 6.0 Developer Reference》）第四版书中的源代码

        } 
        __except (EXCEPTION_EXECUTE_HANDLER) {
            ;
        }
        break;

// IOCTL_SERVICE_QUERY_CAN_DEINIT was depricated for CE 6. To
// prevent unload, use DEVFLAGS_NOUNLOAD in Flags val in registry
#if (_WIN32_WCE < 0x600)
    // Query for unload.  
    case IOCTL_SERVICE_QUERY_CAN_DEINIT:
        DEBUGMSG (ZONE_IOCTLS, 
                  (DTAG TEXT("IOCTL_SERVICE_QUERY_CAN_DEINIT\r\n")));
        if (!pOut || (dwOut < sizeof (DWORD)))
            break;
        __try {
            *(DWORD *)pOut = 1; // non-zero == Yes, can be unloaded.
            if (pdwBytesWritten)
                *pdwBytesWritten = sizeof (DWORD);
            err = 0;
        } 
        __except (EXCEPTION_EXECUTE_HANDLER) {
            ;
        }
        break;
#endif 
    // Query to see if sock address okay for monitoring
    case IOCTL_SERVICE_REGISTER_SOCKADDR:
        DEBUGMSG (ZONE_IOCTLS, 
                  (DTAG TEXT("IOCTL_SERVICE_REGISTER_SOCKADDR\r\n")));
        // Calling to see if service can accept super service help
        if (!pIn || (dwIn < sizeof (DWORD))) {

            if ((pSrv->servState == SERVICE_STATE_OFF) |
                (pSrv->servState == SERVICE_STATE_UNKNOWN)) 
                    pSrv->servState = SERVICE_STATE_STARTING_UP;
            err = 0;
            break;
        }
        // Confirming a specific sock address 
        DEBUGMSG (ZONE_IOCTLS, (DTAG TEXT("Socket:%x\r\n"), *pIn));
        err = 0;
        break;

    // -------------
    // Notifications
    // -------------

    // Notify that sock address going away
    case IOCTL_SERVICE_DEREGISTER_SOCKADDR:
        DEBUGMSG (ZONE_IOCTLS, 
                  (DTAG TEXT("IOCTL_SERVICE_DEREGISTER_SOCKADDR\r\n")));
        EnterCriticalSection (&pSrv->csData);
        if (pSrv->servState == SERVICE_STATE_SHUTTING_DOWN) 
            pSrv->servState = SERVICE_STATE_OFF;
        
        LeaveCriticalSection (&pSrv->csData);
        err = 0;
        break;

    // All super service ports open
    case IOCTL_SERVICE_STARTED:
        DEBUGMSG (ZONE_IOCTLS, (DTAG TEXT("IOCTL_SERVICE_STARTED\r\n")));
        EnterCriticalSection (&pSrv->csData);
        if ((pSrv->servState == SERVICE_STATE_STARTING_UP) |
            (pSrv->servState == SERVICE_STATE_UNKNOWN)) 
            pSrv->servState = SERVICE_STATE_ON;
        
        LeaveCriticalSection (&pSrv->csData);
        err = 0;
        break;

    // Notification that connect has occurred
    case IOCTL_SERVICE_CONNECTION:
        DEBUGMSG (ZONE_IOCTLS, 
                  (DTAG TEXT("IOCTL_SERVICE_CONNECTION\r\n")));
        if (!pIn || (dwIn < sizeof (DWORD)))
            break;

        // Create thread to handle the socket
        hThrd = CreateThread (NULL, 0, AcceptThread, (PVOID)*(DWORD*)pIn, 0, 
                              NULL);
        if (hThrd) {
            CloseHandle (hThrd);
            err = 0;
        } 
        else 
            err = GetLastError();
        break;

    default:
        DEBUGMSG (ZONE_ERROR | ZONE_IOCTLS, 
                  (DTAG TEXT("Unsupported IOCTL code %x (%d)\r\n"), 
                  dwCode, (dwCode & 0x00ff) / 4));
            return FALSE;
    }
    SetLastError (err);
    DEBUGMSG (ZONE_FUNC, (DTAG TEXT("TCK_IOControl-- %d\r\n"), err));
    return (err == 0) ? TRUE : FALSE;
}
//======================================================================
// External entry point to make it easy to init the registry
//======================================================================
int ExternRegisterServer () {

    return RegisterService();
}
//----------------------------------------------------------------------
// AddRegString - Helper routine
//
int AddRegString (HKEY hKey, LPTSTR lpName, LPTSTR lpStr) {

    return RegSetValueEx (hKey, lpName, 0, REG_SZ, (PBYTE)lpStr,
                          (lstrlen (lpStr) + 1) * sizeof (TCHAR));
}
//----------------------------------------------------------------------
// AddRegDW - Helper routine
//
int AddRegDW (HKEY hKey, LPTSTR lpName, DWORD dw) {
    return RegSetValueEx (hKey, lpName, 0, REG_DWORD, (PBYTE)&dw, 4);
}
//----------------------------------------------------------------------
// AddRegSuperServ - Helper routine
//
int AddRegSuperServ (HKEY hKey, WORD wPort) {
    SOCKADDR_IN sa;
    HKEY hSubKey;
    TCHAR szKeyName[128];
    DWORD dw;
    int rc;

    DEBUGMSG (ZONE_FUNC, (DTAG TEXT("AddRegSuperServ++ %d\r\n"), wPort));

    memset (&sa, 0, sizeof (sa));
    sa.sin_family = AF_INET;
    sa.sin_port = htons(wPort);
    sa.sin_addr.s_addr = INADDR_ANY;

    // Create key for this service
    wsprintf (szKeyName, TEXT("Accept\\TCP-%d"), wPort);
    rc = RegCreateKeyEx (hKey, szKeyName, 0, NULL, 0, NULL, 
                         NULL, &hSubKey, &dw);
    DEBUGMSG (1, (TEXT("RegCreateKeyEx %d %d\r\n"), rc, GetLastError()));
    if (rc == ERROR_SUCCESS) 
        rc = RegSetValueEx (hSubKey, TEXT("SockAddr"), 0, REG_BINARY, 
                       (PBYTE)&sa, sizeof (sa));

    DEBUGMSG (ZONE_FUNC, (DTAG TEXT("AddRegSuperServ-- %d\r\n"),rc));
    return rc;
}
//----------------------------------------------------------------------
// RegisterService - Add registry settings for auto load
//
int RegisterService () {
    HKEY hKey, hSubKey;
    TCHAR szModName[MAX_PATH], *pName;
    DWORD dw;
    int rc;

    // Open the Services key
    rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE,TEXT("Services"),0, 0, &hKey);
    if (rc == ERROR_SUCCESS) {
        // Create key for this service
        rc = RegCreateKeyEx (hKey, REGNAME, 0, NULL, 0, NULL, 
                             NULL, &hSubKey, &dw);
        if (rc == ERROR_SUCCESS) {

            GetModuleFileName (hInst, szModName, dim (szModName));
            // Scan to filename
            pName = szModName + lstrlen (szModName);
            while ((pName > szModName) && (*pName != TEXT('\\')))
                pName--;
            if (*pName == TEXT('\\')) pName++;
            AddRegString (hSubKey, TEXT ("DLL"),  pName);

            AddRegString (hSubKey, TEXT ("Prefix"),  TEXT("TCK"));

            AddRegDW (hSubKey, TEXT("Index"), 0);
#if (_WIN32_WCE >= 0x600)
            AddRegDW (hSubKey, TEXT("ServiceContext"), SERVICE_INIT_STOPPED);
#else
            AddRegDW (hSubKey, TEXT("Context"), SERVICE_INIT_STOPPED);
#endif
            AddRegString (hSubKey, TEXT("DisplayName"), 
                          TEXT("Tick Service"));

            AddRegString (hSubKey, TEXT("Description"), 
                          TEXT("Returns system tick cnt on Port 1000"));

            AddRegSuperServ (hSubKey, PORTNUM);

        } else
            DEBUGMSG (ZONE_ERROR, (TEXT("Error creating key\r\n")));

        RegCloseKey(hKey);
    } else
        DEBUGMSG (ZONE_ERROR, (TEXT("Error opening key\r\n")));

    return (rc == ERROR_SUCCESS) ? 0 : -1;
}
//----------------------------------------------------------------------
// DeregisterService - Remove auto load settings from registry
//
int DeregisterService () {
    HKEY hKey;
    int rc;

    // Open the Services key
    rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE,TEXT("Services"),0, 0, &hKey);
    if (rc == ERROR_SUCCESS) {
        // Delete key for this service
        rc = RegDeleteKey (hKey, REGNAME);
        if (rc != ERROR_SUCCESS) 
            DEBUGMSG(ZONE_ERROR, (DTAG TEXT("Error deleting key %d\r\n"),
                     GetLastError()));
        RegCloseKey(hKey);
    } else
        DEBUGMSG (ZONE_ERROR, (TEXT("Error opening key\r\n")));
    return (rc == ERROR_SUCCESS) ? 0 : -1;
}
//======================================================================
// AcceptThread - Thread for managing connected sockets
//
DWORD WINAPI AcceptThread (PVOID pArg) {
    SOCKET sock;
    int rc;
    DWORD dwCmd, dwTicks;

    sock = (SOCKET)pArg;

    DEBUGMSG (ZONE_THREAD, (TEXT("AcceptThread++ %x\r\n"), pArg));

    // Simple task, for any nonzero received byte, sent tick count back
    rc = recv (sock, (char *)&dwCmd, sizeof (DWORD), 0);
    while ((rc != SOCKET_ERROR) && (dwCmd != 0)) {
        DEBUGMSG (ZONE_THREAD, (TEXT("Recv cmd %x\r\n"), dwCmd));

        dwTicks = GetTickCount ();
        DEBUGMSG (ZONE_THREAD, (TEXT("sending %d\r\n"), dwTicks));
        rc = send (sock, (char *)&dwTicks, 4, 0);

        // Read next cmd
        rc = recv (sock, (char *)&dwCmd, sizeof (DWORD), 0);
    }
    closesocket (sock);
    DEBUGMSG (ZONE_THREAD, (TEXT("AcceptThread-- %d %d\r\n"),rc, GetLastError()));
    return 0;
}