стоит небольшая задача нужно написать програмку в виде службы чтобы она опрделяла пользователя и если это пользователь который нужен то он можте работать на данной машине 2 часа!
с чего начать лучше?

на netcode.ru  есть огромный фак по с++.
Определить имя пользователя, посмотреть на время, если закончилось, то просто залочить комп.
прогу можно запускать как сервис и стандартно.

DateTimeToStr(Now()); чтоб время узнать, а вот пример сервиса, надеюсь разберёшься

#include "stdafx.h"
//--------------------------------------------------------------------
-------
extern "C" typedef BOOL (__stdcall* ChangeServiceConfigPtr)
(
  SC_HANDLE hService,         // handle to service
  DWORD dwServiceType,        // type of service
  DWORD dwStartType,          // when to start service
  DWORD dwErrorControl,       // severity if service fails to start
  LPCTSTR lpBinaryPathName,   // pointer to service binary file name
  LPCTSTR lpLoadOrderGroup,   // pointer to load ordering group name
  LPDWORD lpdwTagId,          // pointer to variable to get tag
identifier
  LPCTSTR lpDependencies,     // pointer to array of dependency names
  LPCTSTR lpServiceStartName, // pointer to account name of service
  LPCTSTR lpPassword,         // pointer to password for service
account
  LPCTSTR lpDisplayName       // pointer to display name
);
//--------------------------------------------------------------------
-------
VOID WINAPI SNTPMain     (DWORD dwArgc, LPTSTR* lpszArgv);
VOID WINAPI SNTPHandler  (DWORD fdwControl);
int  WINAPI RunAsApplication (void);
void WINAPI InstallService   (void);
void WINAPI UnInstallService (void);
bool WINAPI CheckVersion     (void);
//--------------------------------------------------------------------
-------
SERVICE_STATUS_HANDLE hSS     = 0;
CRITICAL_SECTION      SNTPCS;
SERVICE_STATUS        SS;
//--------------------------------------------------------------------
-------

void WINAPI LockServiceStatus (void)
{
    EnterCriticalSection(&SNTPCS);
}
//--------------------------------------------------------------------
-------

void WINAPI UnlockSNTPObject (void)
{
    LeaveCriticalSection(&SNTPCS);
}
//--------------------------------------------------------------------
-------
#define UnlockServiceStatus() UnlockSNTPObject()
//--------------------------------------------------------------------
-------

char* WINAPI FindOneOf (char* p1, char* p2)
{
    while (p1!=0 && *p1!=0)
    {
        char* p = p2;
        while (p!=0 && *p!=0)
        {
            if (*p1==*p)
                return CharNext(p1);
            p = CharNext(p);
        }
        p1 = CharNext(p1);
    }
    return 0;
}
//--------------------------------------------------------------------
-------

SERVICE_TABLE_ENTRY ServiceTable[] = {
    {"SNTP Time Service", SNTPMain},
    {0, 0}
};
//--------------------------------------------------------------------
-------

int APIENTRY CRTWinMain (HINSTANCE, HINSTANCE, LPSTR, int)
{
    char* cmdline = GetCommandLine();
    char tokens[] = "-/";
    char* token = FindOneOf(cmdline, tokens);

    if (token!=0)
    {
        if (lstrcmpi(token, "install")==0)
        {
            InstallService();
            return 0;
        }
        else if (lstrcmpi(token, "remove")==0)
        {
            UnInstallService();
            return 0;
        }
        else if (lstrcmpi(token, "service")==0)
        {
            InitializeCriticalSection(&SNTPCS);
            if (CheckVersion())
            {
                if (StartServiceCtrlDispatcher(ServiceTable)==0)
                WriteLog("Failed to start service dispatcher");
            }
            DeleteCriticalSection(&SNTPCS);
        }
        else if (lstrcmpi(token, "application")==0)
            return RunAsApplication();
    }
    else
        MessageBox(0, "sntp.exe [/install | /remove | /service |
/application]", "Parameters", MB_OK);

    return 0;
}
//--------------------------------------------------------------------
-------

VOID WINAPI SNTPHandler (DWORD fdwControl)
{
    switch (fdwControl)
    {
        case SERVICE_CONTROL_SHUTDOWN:
        case SERVICE_CONTROL_STOP:
        {
            LockServiceStatus();
            if (SS.dwCurrentState==SERVICE_RUNNING)
            {
                SS.dwCheckPoint = 1;
                SS.dwCurrentState = SERVICE_STOP_PENDING;
            }
            else if (SS.dwCurrentState!=SERVICE_STOPPED)
                SS.dwCheckPoint++;
            SS.dwWaitHint   = 5000;
            SetServiceStatus(hSS, &SS);
            UnlockServiceStatus();
            break;
        }
        case SERVICE_CONTROL_INTERROGATE:
        {
            LockServiceStatus();
            if (SS.dwCurrentState!=SERVICE_RUNNING &&
SS.dwCurrentState!=SERVICE_STOPPED)
                SS.dwCheckPoint++;
            SS.dwWaitHint = 5000;
            SetServiceStatus(hSS, &SS);
            UnlockServiceStatus();
            break;
        }
    }
}
//--------------------------------------------------------------------
-------

VOID WINAPI SNTPMain (DWORD dwArgc, LPTSTR* lpszArgv)
{
    LockServiceStatus();
    if ((hSS=RegisterServiceCtrlHandler(ServiceTable[0].lpServiceName,
SNTPHandler))==0)
    {
        UnlockServiceStatus();
        return;
    }

    SS.dwServiceType      = SERVICE_WIN32_OWN_PROCESS;
    SS.dwCurrentState     = SERVICE_START_PENDING;

    // устанавливаем что может сервис (стоп/пауза итд)
    SS.dwControlsAccepted = SERVICE_ACCEPT_STOP |
SERVICE_ACCEPT_SHUTDOWN;
    SS.dwWin32ExitCode    = NO_ERROR;
    SS.dwServiceSpecificExitCode = 0;
    SS.dwCheckPoint       = 1;
    SS.dwWaitHint         = 5000;
    SetServiceStatus(hSS, &SS);
    UnlockServiceStatus();

    // ...
    // инициализируем все необходимые для работы объекты
    // ...

    LockServiceStatus();
    SS.dwCurrentState = SERVICE_RUNNING;
    SS.dwWaitHint     = 30000;
    SS.dwCheckPoint   = 0;
    UnlockServiceStatus();

    while (true)
    {
        LockServiceStatus();
        if (SS.dwCurrentState!=SERVICE_RUNNING)
        {
            SS.dwWaitHint = 10000;
            SS.dwCheckPoint++;
        }
        SetServiceStatus(hSS, &SS);
        UnlockServiceStatus();

        // ...
        // выполняем что-то (собственно рабочий цикл сервиса)
        // ...

        LockServiceStatus();
        if (SS.dwCurrentState==SERVICE_RUNNING)
        SS.dwWaitHint = 30000;
        SetServiceStatus(hSS, &SS);
        UnlockServiceStatus();

        Sleep(0);

    }

    LockServiceStatus();
    SS.dwCurrentState  = SERVICE_STOPPED;
    SS.dwCheckPoint    = 0;
    SS.dwWin32ExitCode = NO_ERROR;
    SetServiceStatus(hSS, &SS);
    UnlockServiceStatus();
    return;
}
//--------------------------------------------------------------------
-------

int WINAPI RunAsApplication (void)
{
    // запускаем как приложение
    return 0;
}
//--------------------------------------------------------------------
-------

void WINAPI InstallService (void)
{
    if (!CheckVersion())
        return;
    SC_HANDLE hSCM = OpenSCManager(0, 0, SC_MANAGER_CREATE_SERVICE);
    if (hSCM==0)
    {
        MessageBox(0, "Failed to open SCM", "Error", MB_OK |
MB_ICONERROR);
        return;
    }
    char MN[MAX_PATH+20];
    ZeroMemory(MN, MAX_PATH+20);
    MN[0] = '"';
    GetModuleFileName(0, &MN[1], MAX_PATH);
    lstrcat(MN, "\" /service");
    SC_HANDLE hSrv = CreateService(hSCM, "SNTP Server",
ServiceTable[0].lpServiceName, SERVICE_CHANGE_CONFIG,
SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL,
MN, 0, 0, 0, 0, 0);
    if (hSrv==0)
    {
        MessageBox(0, "Service already installed", "Information",
MB_OK | MB_ICONINFORMATION);
        CloseServiceHandle(hSCM);
        return;
    }

    HINSTANCE H = LoadLibrary("advapi32.dll");
    if (H!=0)
    {
        ChangeServiceConfigPtr ChangeServiceConfigEx =
(ChangeServiceConfigPtr)GetProcAddress(H, "ChangeServiceConfigA");
        if (ChangeServiceConfigEx!=0)
        {
            if ((*ChangeServiceConfigEx)(hSrv,
SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL,
MN, 0, 0, 0, 0, 0, "SNTP Server")==0)
                MessageBox(0, "Failed to change server config",
"Error", MB_OK | MB_ICONERROR);
        }
        else
            MessageBox(0, "ChangeServiceConfigA not found", "Error",
MB_OK | MB_ICONERROR);
        FreeLibrary(H);
    }

    CloseServiceHandle(hSrv);
    CloseServiceHandle(hSCM);
    MessageBox(0, "Service installed successful", "Success", MB_OK |
MB_ICONINFORMATION);
}
//--------------------------------------------------------------------
-------

void WINAPI UnInstallService (void)
{
    if (!CheckVersion())
        return;
    SC_HANDLE hSCM = OpenSCManager(0, 0, SC_MANAGER_CONNECT);
    if (hSCM==0)
    {
        MessageBox(0, "Failed to open SCM", "Error", MB_OK |
MB_ICONERROR);
        return;
    }
    SC_HANDLE hSrv = OpenService(hSCM, "SNTP Server", DELETE);
    if (hSrv==0)
    {
        MessageBox(0, "Service already removed", "Information", MB_OK
| MB_ICONINFORMATION);
        CloseServiceHandle(hSCM);
        return;
    }
    if (DeleteService(hSrv)==0)
    {
        MessageBox(0, "Failed to delete service", "Error", MB_OK |
MB_ICONERROR);
        CloseServiceHandle(hSrv);
        CloseServiceHandle(hSCM);
        return;
    }

    CloseServiceHandle(hSrv);
    CloseServiceHandle(hSCM);
    MessageBox(0, "Service removed successful", "Success", MB_OK |
MB_ICONINFORMATION);
}
//--------------------------------------------------------------------
-------

bool WINAPI CheckVersion (void)
{
    OSVERSIONINFO OVI;
    OVI.dwOSVersionInfoSize = sizeof(OVI);
    if (GetVersionEx(&OVI)==0)
    {
        MessageBox(0, "Unknown error", "Error", MB_OK | MB_ICONERROR);
        return false;
    }
    if (OVI.dwPlatformId!=VER_PLATFORM_WIN32_NT)
    {
        MessageBox(0, "Windows NT 4.0 or higher required", "Error",
MB_OK | MB_ICONERROR);
        return false;
    }
    return true;
}
//--------------------------------------------------------------------
-------

Спасибо огромное!
конечно разберусь!