hackedteam/core-winmobile

#include "Event.h"
#include "Common.h"
#include "Conf.h"
#include "Date.h"
#include "Log.h"

HANDLE eventHandle;

DWORD WINAPI repeatThread(LPVOID lpParam) {
    int *delay = (int *)lpParam;

    for (;;) {
        Sleep(*delay);
        SetEvent(eventHandle);
    }
}

DWORD WINAPI OnTimer(LPVOID lpParam) {
    Event *me = (Event *)lpParam;
    Configuration *conf;
    wstring subType;
    int timeStart, timeEnd, delay, iterations;
    
    eventHandle = me->getEvent();

    me->setStatus(EVENT_RUNNING);
    conf = me->getConf();

    try {
        subType = conf->getString(L"subtype");
    } catch (...) {
        subType = L"";
    }

    try {
        timeStart = conf->getInt(L"start");
    } catch (...) {
        timeStart = CONF_ACTION_NULL;
    }

    try {
        timeEnd = conf->getInt(L"end");
    } catch (...) {
        timeEnd = CONF_ACTION_NULL;
    }

    try {
        delay = conf->getInt(L"delay") * 1000;
    } catch (...) {
        delay = INFINITE;
    }

    try {
        iterations = conf->getInt(L"iter");
    } catch (...) {
        iterations = MAXINT;
    }

    // Defensive
    if (subType.compare(L"startup") == 0) {
        subType = L"loop";
    }

    DBG_TRACE(L"Debug - Timer.cpp - Timer Event is Alive\n", 1, FALSE);

#ifdef _DEBUG
    wstring desc;

    try {
        desc = conf->getString(L"desc");
    } catch (...) {
        desc = L"";
    }

    wprintf(L"Debug - Timer.cpp - Desc: %s, iter: %d, delay: %d\n", desc.c_str(), iterations, delay / 1000);
#endif

    if (subType.compare(L"loop") == 0) {
        int curIterations = 0;

        me->triggerStart();

        // Caso di loop con solo start, senza repeat ne' end
        if (iterations == MAXINT && delay == INFINITE) {
            me->requestStop();
            me->setStatus(EVENT_STOPPED);

            return 0;
        }

        LOOP {
            WaitForSingleObject(eventHandle, delay);

            if (me->shouldStop()) {
                DBG_TRACE(L"Debug - Timer.cpp - Timer Event is Closing\n", 1, FALSE);
                me->setStatus(EVENT_STOPPED);

                return 0;
            }

            if (curIterations > iterations) {
                me->requestStop();
                continue;
            }

            me->triggerRepeat();
            curIterations++;
        }
    }

    if (subType.compare(L"daily") == 0) {
        unsigned __int64 ts, te, current;
        int curIterations = 0, sleepTime;
        Date date;
        HANDLE hRepeat;
        DWORD repeatThreadId;

        hRepeat = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)repeatThread, (void*)&delay, 0, &repeatThreadId);

        if (hRepeat == NULL) {
            me->setStatus(EVENT_STOPPED);
            return 0;
        }

        try {
            const wstring startTime = conf->getString(L"ts");
            const wstring endTime = conf->getString(L"te");

            date.setDate(startTime);
            ts = date.stringToAbsoluteMs();

            date.setDate(endTime);
            te = date.stringToAbsoluteMs();
        } catch (...) {
            DBG_TRACE(L"Debug - Timer.cpp - Timer Event is Closing, missing parameters\n", 1, FALSE);
            me->setStatus(EVENT_STOPPED);

            return 0;
        }

        current = date.getCurAbsoluteMs();

        if (current >= ts && current <= te) { // We are in range
            me->triggerStart();
        } else {
            DWORD dwWait;

            if (current < ts) { // We are just before the start time
                dwWait = WaitForSingleObject(eventHandle, (DWORD)(ts - current));
            } else { // Start time is tomorrow
                dwWait = WaitForSingleObject(eventHandle, (DWORD)(ts + date.getMsDay() - current));
            }

            // Handle signaled, we have to stop
            if (dwWait == WAIT_OBJECT_0) {
                DBG_TRACE(L"Debug - Timer.cpp - Timer Event is Closing\n", 1, FALSE);
                me->setStatus(EVENT_STOPPED);

                TerminateThread(hRepeat, 0);
                CloseHandle(hRepeat);
                return 0;
            }

            me->triggerStart();
        }

        // We need to update it! We could arrive here after 24 hours
        te = date.stringToAbsoluteMs();

        // From now on we are in range
        LOOP {
            current = date.getCurAbsoluteMs();

            // Siamo attivi
            if (current + delay > te)
                sleepTime = (int)(te - current); // Just sleep
            else
                sleepTime = delay; // Sleep and exec
            
            WaitForSingleObject(eventHandle, sleepTime);

            if (me->shouldStop()) {
                DBG_TRACE(L"Debug - Timer.cpp - Timer Event is Closing\n", 1, FALSE);
                me->setStatus(EVENT_STOPPED);

                TerminateThread(hRepeat, 0);
                CloseHandle(hRepeat);
                return 0;
            }

            if (curIterations > iterations) {
                me->requestStop();
                continue;
            }

            me->triggerRepeat();
            curIterations++;
        }
    }

    DBG_TRACE(L"Debug - Timer.cpp - *** We shouldn't be here!!!\n", 1, FALSE);
    me->requestStop();
    me->setStatus(EVENT_STOPPED);

    return 0;
}

DWORD WINAPI OnAfterInst(LPVOID lpParam) {
    HANDLE evHandle;
    Event *me = (Event *)lpParam;
    Configuration *conf;
    Date date;
    int days, installedDays, delay, iterations, curIterations = 0;
    __int64 inst, now;
    Log log;

    evHandle = me->getEvent();

    me->setStatus(EVENT_RUNNING);
    conf = me->getConf();

    if (log.IsMarkup(EVENT_AFTERINST) == FALSE) {
        me->setStatus(EVENT_STOPPED);
        return 0;
    }

    try {
        days = conf->getInt(L"days");
    } catch (...) {
        days = MAXINT;
    }

    try {
        delay = conf->getInt(L"delay") * 1000;
    } catch (...) {
        delay = INFINITE;
    }

    try {
        iterations = conf->getInt(L"iter");
    } catch (...) {
        iterations = MAXINT;
    }

    DBG_TRACE(L"Debug - Timer.cpp - AfterInst Event is Alive\n", 1, FALSE);

    UINT instSize;
    BYTE* instTime;

    instTime = log.ReadMarkup(EVENT_AFTERINST, &instSize);

    if (instTime == NULL) {
        me->setStatus(EVENT_STOPPED);
        return 0;
    }

    memcpy(&inst, instTime, sizeof(inst));

    now = date.getCurAbsoluteMs();

    // How many days from installation?
    now -= inst;
    installedDays = (int)(now / date.getMsDay());

    if (installedDays < days) {
        WaitForSingleObject(evHandle, (days - installedDays) * date.getMsDay());

        if (me->shouldStop()) {
            DBG_TRACE(L"Debug - Timer.cpp - Timer Event is Closing\n", 1, FALSE);
            me->setStatus(EVENT_STOPPED);

            return 0;
        }
    }

    me->triggerStart();

    LOOP {
        WaitForSingleObject(evHandle, delay);

        if (me->shouldStop()) {
            DBG_TRACE(L"Debug - Timer.cpp - Timer Event is Closing\n", 1, FALSE);
            me->setStatus(EVENT_STOPPED);

            return 0;
        }

        if (curIterations > iterations) {
            me->requestStop();
            continue;
        }

        me->triggerRepeat();
        curIterations++;
    }
}

DWORD WINAPI OnDate(LPVOID lpParam) {
    HANDLE evHandle;
    Event *me = (Event *)lpParam;
    Configuration *conf;
    Date date;
    int delay, iterations, curIterations = 0, curDelay = 0;
    unsigned __int64 startDate, now, endDate;
    wstring dateFrom, dateTo;

    evHandle = me->getEvent();

    me->setStatus(EVENT_RUNNING);
    conf = me->getConf();

    try {
        dateFrom = conf->getString(L"datefrom");
    } catch (...) {
        dateFrom = L"1999-01-01 00:00:00";
    }

    try {
        dateTo = conf->getString(L"dateto");
    } catch (...) {
        dateTo = L"2999-01-01 00:00:00";
    }

    try {
        delay = conf->getInt(L"delay") * 1000;
    } catch (...) {
        delay = INFINITE;
    }

    try {
        iterations = conf->getInt(L"iter");
    } catch (...) {
        iterations = MAXINT;
    }

    DBG_TRACE(L"Debug - Timer.cpp - OnDate Event is Alive\n", 1, FALSE);

    date.setDate(dateFrom);
    startDate = date.stringDateToMs();

    now = date.getCurAbsoluteMs();

    if (now < startDate) {
        curDelay = (UINT)(startDate - now);
        WaitForSingleObject(evHandle, curDelay);
        
        if (me->shouldStop()) {
            DBG_TRACE(L"Debug - Timer.cpp - Date Event is Closing\n", 1, FALSE);
            me->setStatus(EVENT_STOPPED);

            return 0;
        }
    }

    me->triggerStart();
    curDelay = delay;

    date.setDate(dateTo);
    endDate = date.stringDateToMs();

    LOOP {
        WaitForSingleObject(evHandle, curDelay);

        if (me->shouldStop()) {
            DBG_TRACE(L"Debug - Timer.cpp - Date Event is Closing\n", 1, FALSE);
            me->setStatus(EVENT_STOPPED);

            return 0;
        }

        if (curIterations > iterations) {
            me->requestStop();
            continue;
        }

        if (date.getCurAbsoluteMs() > endDate) {
            me->requestStop();
            continue;
        }

        me->triggerRepeat();
        curIterations++;
    }
}