new student with C++

Discussion in 'C++' started by statquos, Jun 12, 2008.

  1. statquos

    statquos New Member

    Joined:
    Jun 12, 2008
    Messages:
    1
    Likes Received:
    0
    Trophy Points:
    0
    I need a program which run as service (in the background).

    The program read a txt file where are informations: date/time and message.
    example txt file:
    2008/06/13
    20:00:00
    Go to cinema

    The program check if time (date/time) is equal of system time (date/time).
    If is equal, the program put a message on screen)- ex. Go to cinema.

    have ex.program, not comare system time and date... how make this?

    Code:
    #include <process.h>
    #include <iostream>
    #include <time.h>
    #include <fstream>
    #include <string>
    #include <tchar.h>
    #include <stdio.h>
    #include <windows.h>
    #include <winbase.h>
    #include <winsvc.h>
    
    //  Service.cpp : Defines the entry point for the console application.
    //
    
    #include "stdafx.h"
    
    #define        MAX_NUM_OF_PROCESS        4
    /** Window Service **/
    VOID ServiceMainProc();
    VOID Install(char* pPath, char* pName);
    VOID UnInstall(char* pName);
    VOID WriteLog(char* pFile, char* pMsg);
    BOOL KillService(char* pName);
    BOOL RunService(char* pName);
    VOID ExecuteSubProcess();
    VOID ProcMonitorThread(VOID *);
    
    VOID WINAPI ServiceMain(DWORD dwArgc, LPTSTR *lpszArgv);
    VOID WINAPI ServiceHandler(DWORD fdwControl);
    
    
    /** Window Service **/
    const int nBufferSize = 500;
    CHAR pServiceName[nBufferSize+1];
    CHAR pExeFile[nBufferSize+1];
    CHAR lpCmdLineData[nBufferSize+1];
    CHAR pLogFile[nBufferSize+1];
    BOOL ProcessStarted = TRUE;
    
    CRITICAL_SECTION        myCS;
    SERVICE_TABLE_ENTRY        lpServiceStartTable[] = 
    {
        {pServiceName, ServiceMain},
        {NULL, NULL}
    };
    
    LPTSTR ProcessNames[MAX_NUM_OF_PROCESS];
    
    SERVICE_STATUS_HANDLE   hServiceStatusHandle; 
    SERVICE_STATUS          ServiceStatus; 
    PROCESS_INFORMATION    pProcInfo[MAX_NUM_OF_PROCESS];
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        if(argc >= 2)
            strcpy(lpCmdLineData, argv[1]);
        ServiceMainProc();
        return 0;
    }
    
    VOID ServiceMainProc()
    {
        ::InitializeCriticalSection(&myCS);
        // initialize variables for .exe and .log file names
        char pModuleFile[nBufferSize+1];
        DWORD dwSize = GetModuleFileName(NULL, pModuleFile, nBufferSize);
        pModuleFile[dwSize] = 0;
        if(dwSize>4 && pModuleFile[dwSize-4] == '.')
        {
            sprintf(pExeFile,"%s",pModuleFile);
            pModuleFile[dwSize-4] = 0;
            sprintf(pLogFile,"%s.log",pModuleFile);
        }
        //name of process
        strcpy(pServiceName,"SkyDiver");
    
        if(_stricmp("-i",lpCmdLineData) == 0 || _stricmp("-I",lpCmdLineData) == 0)
            Install(pExeFile, pServiceName);
        else if(_stricmp("-k",lpCmdLineData) == 0 || _stricmp("-K",lpCmdLineData) == 0)
            KillService(pServiceName);
        else if(_stricmp("-u",lpCmdLineData) == 0 || _stricmp("-U",lpCmdLineData) == 0)
            UnInstall(pServiceName);
        else if(_stricmp("-s",lpCmdLineData) == 0 || _stricmp("-S",lpCmdLineData) == 0)
            RunService(pServiceName);
        else
            ExecuteSubProcess();
    }
    
    VOID Install(char* pPath, char* pName)
    {  
        SC_HANDLE schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_CREATE_SERVICE); 
        if (schSCManager==0) 
        {
            long nError = GetLastError();
            char pTemp[121];
            sprintf(pTemp, "OpenSCManager failed, error code = %d\n", nError);
            WriteLog(pLogFile, pTemp);
        }
        else
        {
            SC_HANDLE schService = CreateService
            ( 
                schSCManager,    /* SCManager database      */ 
                pName,            /* name of service         */ 
                pName,            /* service name to display */ 
                SERVICE_ALL_ACCESS,        /* desired access          */ 
                SERVICE_WIN32_OWN_PROCESS|SERVICE_INTERACTIVE_PROCESS , /* service type            */ 
                SERVICE_AUTO_START,      /* start type              */ 
                SERVICE_ERROR_NORMAL,      /* error control type      */ 
                pPath,            /* service's binary        */ 
                NULL,                      /* no load ordering group  */ 
                NULL,                      /* no tag identifier       */ 
                NULL,                      /* no dependencies         */ 
                NULL,                      /* LocalSystem account     */ 
                NULL
            );                     /* no password             */ 
            if (schService==0) 
            {
                long nError =  GetLastError();
                char pTemp[121];
                sprintf(pTemp, "Failed to create service %s, error code = %d\n", pName, nError);
                WriteLog(pLogFile, pTemp);
            }
            else
            {
                char pTemp[121];
                sprintf(pTemp, "Service %s installed\n", pName);
                WriteLog(pLogFile, pTemp);
                CloseServiceHandle(schService); 
            }
            CloseServiceHandle(schSCManager);
        }    
    }
    
    VOID UnInstall(char* pName)
    {
        SC_HANDLE schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS); 
        if (schSCManager==0) 
        {
            long nError = GetLastError();
            char pTemp[121];
            sprintf(pTemp, "OpenSCManager failed, error code = %d\n", nError);
            WriteLog(pLogFile, pTemp);
        }
        else
        {
            SC_HANDLE schService = OpenService( schSCManager, pName, SERVICE_ALL_ACCESS);
            if (schService==0) 
            {
                long nError = GetLastError();
                char pTemp[121];
                sprintf(pTemp, "OpenService failed, error code = %d\n", nError);
                WriteLog(pLogFile, pTemp);
            }
            else
            {
                if(!DeleteService(schService)) 
                {
                    char pTemp[121];
                    sprintf(pTemp, "Failed to delete service %s\n", pName);
                    WriteLog(pLogFile, pTemp);
                }
                else 
                {
                    char pTemp[121];
                    sprintf(pTemp, "Service %s removed\n",pName);
                    WriteLog(pLogFile, pTemp);
                }
                CloseServiceHandle(schService); 
            }
            CloseServiceHandle(schSCManager);    
        }
        DeleteFile(pLogFile);
    }
    
    
    VOID WriteLog(char* pFile, char* pMsg)
    {
        // write error or other information into log file
        ::EnterCriticalSection(&myCS);
        try
        {
            SYSTEMTIME oT;
            ::GetLocalTime(&oT);
            FILE* pLog = fopen(pFile,"a");
            fprintf(pLog,"%02d/%02d/%04d, %02d:%02d:%02d\n    %s",oT.wMonth,oT.wDay,oT.wYear,oT.wHour,oT.wMinute,oT.wSecond,pMsg); 
            fclose(pLog);
        } catch(...) {}
        ::LeaveCriticalSection(&myCS);
    }
    
    BOOL KillService(char* pName) 
    { 
        // kill service with given name
        SC_HANDLE schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS); 
        if (schSCManager==0) 
        {
            long nError = GetLastError();
            char pTemp[121];
            sprintf(pTemp, "OpenSCManager failed, error code = %d\n", nError);
            WriteLog(pLogFile, pTemp);
        }
        else
        {
            // open the service
            SC_HANDLE schService = OpenService( schSCManager, pName, SERVICE_ALL_ACCESS);
            if (schService==0) 
            {
                long nError = GetLastError();
                char pTemp[121];
                sprintf(pTemp, "OpenService failed, error code = %d\n", nError);
                WriteLog(pLogFile, pTemp);
            }
            else
            {
                // call ControlService to kill the given service
                SERVICE_STATUS status;
                if(ControlService(schService,SERVICE_CONTROL_STOP,&status))
                {
                    CloseServiceHandle(schService); 
                    CloseServiceHandle(schSCManager); 
                    return TRUE;
                }
                else
                {
                    long nError = GetLastError();
                    char pTemp[121];
                    sprintf(pTemp, "ControlService failed, error code = %d\n", nError);
                    WriteLog(pLogFile, pTemp);
                }
                CloseServiceHandle(schService); 
            }
            CloseServiceHandle(schSCManager); 
        }
        return FALSE;
    }
    
    BOOL RunService(char* pName) 
    { 
        // run service with given name
        SC_HANDLE schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS); 
        if (schSCManager==0) 
        {
            long nError = GetLastError();
            char pTemp[121];
            sprintf(pTemp, "OpenSCManager failed, error code = %d\n", nError);
            WriteLog(pLogFile, pTemp);
        }
        else
        {
            // open the service
            SC_HANDLE schService = OpenService( schSCManager, pName, SERVICE_ALL_ACCESS);
            if (schService==0) 
            {
                long nError = GetLastError();
                char pTemp[121];
                sprintf(pTemp, "OpenService failed, error code = %d\n", nError);
                WriteLog(pLogFile, pTemp);
            }
            else
            {
                // call StartService to run the service
                if(StartService(schService, 0, (const char**)NULL))
                {
                    CloseServiceHandle(schService); 
                    CloseServiceHandle(schSCManager); 
                    return TRUE;
                }
                else
                {
                    long nError = GetLastError();
                    char pTemp[121];
                    sprintf(pTemp, "StartService failed, error code = %d\n", nError);
                    WriteLog(pLogFile, pTemp);
                }
                CloseServiceHandle(schService); 
            }
            CloseServiceHandle(schSCManager); 
        }
        return FALSE;
    }
    
    
    VOID ExecuteSubProcess()
    {
        if(_beginthread(ProcMonitorThread, 0, NULL) == -1)
        {
            long nError = GetLastError();
            char pTemp[121];
            sprintf(pTemp, "StartService failed, error code = %d\n", nError);
            WriteLog(pLogFile, pTemp);
        }
        if(!StartServiceCtrlDispatcher(lpServiceStartTable))
        {
            long nError = GetLastError();
            char pTemp[121];
            sprintf(pTemp, "StartServiceCtrlDispatcher failed, error code = %d\n", nError);
            WriteLog(pLogFile, pTemp);
        }
        ::DeleteCriticalSection(&myCS);
    }
    
    VOID WINAPI ServiceMain(DWORD dwArgc, LPTSTR *lpszArgv)
    {
        DWORD   status = 0; 
        DWORD   specificError = 0xfffffff; 
     
        ServiceStatus.dwServiceType        = SERVICE_WIN32; 
        ServiceStatus.dwCurrentState       = SERVICE_START_PENDING; 
        ServiceStatus.dwControlsAccepted   = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_PAUSE_CONTINUE; 
        ServiceStatus.dwWin32ExitCode      = 0; 
        ServiceStatus.dwServiceSpecificExitCode = 0; 
        ServiceStatus.dwCheckPoint         = 0; 
        ServiceStatus.dwWaitHint           = 0; 
     
        hServiceStatusHandle = RegisterServiceCtrlHandler(pServiceName, ServiceHandler); 
        if (hServiceStatusHandle==0) 
        {
            long nError = GetLastError();
            char pTemp[121];
            sprintf(pTemp, "RegisterServiceCtrlHandler failed, error code = %d\n", nError);
            WriteLog(pLogFile, pTemp);
            return; 
        } 
     
        // Initialization complete - report running status 
        ServiceStatus.dwCurrentState       = SERVICE_RUNNING; 
        ServiceStatus.dwCheckPoint         = 0; 
        ServiceStatus.dwWaitHint           = 0;  
        if(!SetServiceStatus(hServiceStatusHandle, &ServiceStatus)) 
        { 
            long nError = GetLastError();
            char pTemp[121];
            sprintf(pTemp, "SetServiceStatus failed, error code = %d\n", nError);
            WriteLog(pLogFile, pTemp);
        } 
    }
    
    VOID WINAPI ServiceHandler(DWORD fdwControl)
    {
        switch(fdwControl) 
        {
            case SERVICE_CONTROL_STOP:
            case SERVICE_CONTROL_SHUTDOWN:
                ProcessStarted = FALSE;
                ServiceStatus.dwWin32ExitCode = 0; 
                ServiceStatus.dwCurrentState  = SERVICE_STOPPED; 
                ServiceStatus.dwCheckPoint    = 0; 
                ServiceStatus.dwWaitHint      = 0;
                break; 
            case SERVICE_CONTROL_PAUSE:
                ServiceStatus.dwCurrentState = SERVICE_PAUSED; 
                break;
            case SERVICE_CONTROL_CONTINUE:
                ServiceStatus.dwCurrentState = SERVICE_RUNNING; 
                break;
            case SERVICE_CONTROL_INTERROGATE:
                break;
    
        };
        if (!SetServiceStatus(hServiceStatusHandle,  &ServiceStatus)) 
        { 
            long nError = GetLastError();
            char pTemp[121];
            sprintf(pTemp, "SetServiceStatus failed, error code = %d\n", nError);
            WriteLog(pLogFile, pTemp);
        } 
    }
    
    VOID ProcMonitorThread(VOID *)
    {
        while(ProcessStarted == TRUE)
        {
            //WriteLog(pLogFile, "Write service!!!");		
    		FILE *f;
    		int tmp;
    		char c,time[10],date[10],msg[100];
    
    		for(tmp=0;tmp<10;++tmp)
    			time[tmp]='\0';
    		for(tmp=0;tmp<10;++tmp)
    			date[tmp]='\0';
    		for(tmp=0;tmp<10;++tmp)
    			 msg[tmp]='\0';
        
    		tmp=0;
    
    		f=fopen("Scheduler.txt","r");
        
    		while(1)
    		{
    			c=getc(f);
    			if(c==' ')break;
    			time[tmp]=c;
    			++tmp;
    		}
    		tmp=0;
        
    		while(1)
    		{
    			c=getc(f);
    			if(c==' ')break;
    			date[tmp]=c;
    			++tmp;
    		 }
    		tmp=0;
        
    		while(1)
    		{
    			c=getc(f);
    			if(c==EOF)break;
    			msg[tmp]=c;
    			++tmp;
    		}
    		fclose(f);
    
    		MessageBox(NULL,("Time: %s   Date: %s   Message: %s",time,date,msg),"Message window",0);
    	}
    }
    
     

Share This Page

  1. This site uses cookies to help personalise content, tailor your experience and to keep you logged in if you register.
    By continuing to use this site, you are consenting to our use of cookies.
    Dismiss Notice