~liuyang/MiniLED_ADM.git

#include "stdafx.h"
#include "Worker_UpdateLicense.h"
 
#ifdef _DEBUG
#pragma comment(lib,"setupapi.lib")
#pragma comment(lib,"l_mega64.lib")
#else
#pragma comment(lib,"setupapi.lib")
#pragma comment(lib,"l_mega64.lib")
#endif
 
// ¸Þ°¡¶ô ¶óÀÌºê·¯¸® ¿ÜºÎ ÇÔ¼ö ¼±¾ð ½ÃÀÛ
#ifdef __cplusplus                        
extern "C" {
#endif
    extern unsigned int  lock_init_usb(unsigned int op1);        // ¸Þ°¡¶ô Å½»ö
    extern unsigned char lock_write(unsigned char op1, char op2);
    extern unsigned char lock_read(unsigned char op1);
    extern unsigned int  lock_boot_cnt(void);        // ºÎÆÃ È½¼ö ¾ò±â
    extern unsigned char lock_version(void);
    extern unsigned char lock_sn(char);                // ¸Þ°¡¶ô °íÀ¯¹øÈ£
    extern unsigned char lock_check(void);            // ¸Þ°¡¶ô Á¸Àç ¿©ºÎ¸¦ ºü¸£°í °£´ÜÈ÷ Ã¼Å©
    extern int lock_write_ex(int op1, int op2);
    extern int lock_read_ex(int op1);
    extern BOOL lock_receive(void);
 
    // ÀÌÀü ¹öÀü°ú È£È¯¼º À¯Áö¸¦ À§ÇÑ ÇÔ¼ö, ½Å±Ô¾÷Ã¼ÀÎ °æ¿ì ¾Æ·¡ÀÇ ÇÔ¼ö´Â »ç¿ëÇÏÁö ¸¶¼¼¿ä.
    extern unsigned char lock_auto(char op1);
    extern unsigned char lock_func0(unsigned char op1, unsigned char op2);
    extern unsigned char lock_func1(unsigned char op1, unsigned char op2);
    extern unsigned char lock_func2(unsigned char op1, unsigned char op2);
    extern unsigned char lock_func3(unsigned char op1, unsigned char op2);
 
#ifdef __cplusplus                        
}
#endif
//  ¸Þ°¡¶ô ¶óÀÌºê·¯¸® ¿ÜºÎ ÇÔ¼ö ¼±¾ð ³¡
 
CWorker_UpdateLicense::CWorker_UpdateLicense(int nIndex, IWorkerUpdateLicense2Parent *pIWUL2P, DWORD dwTick) 
    : m_nIndex(nIndex), m_pIWUL2P(pIWUL2P), m_dwTick(dwTick)
{
    m_sStatus.Reset();
    m_bUpdate = FALSE;
    m_hThreadDone = CreateEvent(nullptr, FALSE, FALSE, nullptr);
}
 
CWorker_UpdateLicense::~CWorker_UpdateLicense()
{
    CloseHandle(m_hThreadDone);
}
 
BOOL CWorker_UpdateLicense::StartThread()
{
    if (m_bUpdate) return FALSE;
 
    //Read ½º·¹µå »ý¼º
    m_bUpdate = TRUE;
    AfxBeginThread(CWorker_UpdateLicense::UpdateLicense,(LPVOID)(this));
 
    return TRUE;
}
 
void CWorker_UpdateLicense::StopThread()
{
    if (m_bUpdate)
    {
        m_bUpdate = FALSE;
    }
}
 
UINT CWorker_UpdateLicense::UpdateLicense(LPVOID pParam)
{
    CWorker_UpdateLicense* pThis = (CWorker_UpdateLicense*)pParam;
    const UINT uiRetval = pThis->Update_License_Func();
    if (uiRetval != 0)
    {
        SetEvent(pThis->m_hThreadDone);
    }
 
    return uiRetval;
}
 
UINT CWorker_UpdateLicense::Update_License_Func()
{
    while (m_bUpdate)
    {
        Update_License();
    
        ::Sleep(m_dwTick);
    };
 
    SetEvent(m_hThreadDone);
    return 0;
}
 
void CWorker_UpdateLicense::Update_License()
{
    ////////////////////// USB¿ë ¸Þ°¡¶ô °Ë»ç·çÆ¾ ½ÃÀÛ
    DWORD64 dwTick = GetTickCount64();
 
    m_sStatus.Reset();
 
    m_sStatus.nUsbID = 1;
    m_sStatus.strSerialNo.Format(_T("No license"));
    m_sStatus.nKeyStatus = LicenseKey_Activated;
    CTime tmpTime(2099, 12, 31, 23, 59, 59);
    m_sStatus.expTime = tmpTime;
    return;
 
    m_sStatus.nKeyStatus = LicenseKey_NotConnected; // ¿¬°á ¾ÈµÊ
    m_sStatus.nUsbID = lock_init_usb(8); // ¿¬°á Ã¼Å©
    if (0 == m_sStatus.nUsbID)
    {
        m_pIWUL2P->IWUL2P_LicenceStatus(m_nIndex, m_sStatus);
        return;
    }
 
    m_sStatus.nKeyStatus = LicenseKey_NotCertified; // ÀÎÁõ ¾ÈµÊ
    if (0 != lock_check()) // ÀÎÁõ Ã¼Å©
    {
        m_pIWUL2P->IWUL2P_LicenceStatus(m_nIndex, m_sStatus);
        return;
    }
 
    CString szTemp = L"";
    for (int i = 0; i < 4; i++)  
    {
        unsigned int rData = lock_sn(i);
        CString strCopy = szTemp;
        szTemp.Format(_T("%s%02X"), strCopy, rData);
        // szTemp.Format(_T("%s%02X"), szTemp, rData);
    }
    m_sStatus.strSerialNo = szTemp;
 
    m_sStatus.nKeyStatus = LicenseKey_NotActivated; // È°¼ºÈ ¾ÈµÊ
 
    // TIME Ã¼Å©
    int pMemData[16] = { 0 };
    CString strTemp;
    for (int i = 0; i < 16; i++)
    {
        strTemp.Format(L"%02X", lock_read(i));
        pMemData[i] = _ttoi(strTemp); // hex2dec(pChData);
    }
 
    int nYear = (pMemData[0] * 100) + pMemData[1];
    if (nYear < 2000)
    {
        m_pIWUL2P->IWUL2P_LicenceStatus(m_nIndex, m_sStatus);
        return;
    }
 
    int nMonth = pMemData[2];
    if (nMonth < 1 || nMonth > 12)
    {
        m_pIWUL2P->IWUL2P_LicenceStatus(m_nIndex, m_sStatus);
        return;
    }
 
    int nDay = pMemData[3];
    if (nDay < 1 || nDay > 31)
    {
        m_pIWUL2P->IWUL2P_LicenceStatus(m_nIndex, m_sStatus);
        return;
    }
 
    int nHour = pMemData[4];
    if (nHour < 0 || nHour > 24)
    {
        m_pIWUL2P->IWUL2P_LicenceStatus(m_nIndex, m_sStatus);
        return;
    }
 
    int nMinute = pMemData[5];
    if (nMinute < 0 || nMinute > 60)
    {
        m_pIWUL2P->IWUL2P_LicenceStatus(m_nIndex, m_sStatus);
        return;
    }
 
    int nSec = pMemData[6];
    if (nSec < 0 || nSec > 60)
    {
        m_pIWUL2P->IWUL2P_LicenceStatus(m_nIndex, m_sStatus);
        return;
    }
    
    // time check
    CTime expTime(nYear, nMonth, nDay, nHour, nMinute, nSec);
    CTime curTime = CTime::GetCurrentTime();
    CTimeSpan spanTime = expTime - curTime;
 
    m_sStatus.expTime = expTime;
 
    if (spanTime.GetTotalSeconds() > 0)
    {
        m_sStatus.nKeyStatus = LicenseKey_Activated; // È°¼ºÈµÊ
        m_pIWUL2P->IWUL2P_LicenceStatus(m_nIndex, m_sStatus);
        return;
    }
 
    dwTick = GetTickCount64() - dwTick;
    m_pIWUL2P->IWUL2P_LicenceStatus(m_nIndex, m_sStatus);
 
    return;
}