sigmaker.cpp

自己动手

// SigMaker.cpp: implementation of the CSigMaker class.
//
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
//Sig处理类
//功能：处理生成sig文件相关的操作
//作者：hup(timeout)
//QQ:22740132
//Email:[e-mail]
//欢迎联系！
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MySigMaker.h"
#include "SigMaker.h"
#include <process.h>

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Global Function
//////////////////////////////////////////////////////////////////////
//判断文件或目录是否存在
BOOL IsFileExist(PCHAR pszFileName)
{
    return (int)GetFileAttributes(pszFileName) >= 0;
}

BOOL DeleteDir(PCHAR pszDirName)
{
    if (NULL == pszDirName)
    {
        return FALSE;
    }
    if (pszDirName[_tcslen(pszDirName)-1] == _T('\\'))
    {
        pszDirName[_tcslen(pszDirName)-1] = 0;
    }
    SHFILEOPSTRUCT ss;
    ss.hwnd = NULL;
    ss.wFunc = FO_DELETE;
    ss.pFrom = pszDirName;
    ss.pTo = NULL;
    ss.fFlags = FOF_NOCONFIRMATION | FOF_NOERRORUI;
    ss.fAnyOperationsAborted = TRUE;
    ss.hNameMappings = NULL;
    ss.lpszProgressTitle = NULL;
    int nRet = SHFileOperation(&ss);
    if (0 == nRet)
    {
        return TRUE;
    }
    return FALSE;
}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CSigMaker::CSigMaker()
:m_bDelTmpFile(FALSE), m_hThread(NULL)
{
    memset(m_szSigBat1AllFileName, 0, sizeof(m_szSigBat1AllFileName));
    memset(m_szSigBat2AllFileName, 0, sizeof(m_szSigBat2AllFileName));
    memset(m_szCurrModulePathWithBackslash, 0, sizeof(m_szCurrModulePathWithBackslash));
    memset(m_szSigName, 0, sizeof(m_szSigName));  
    memset(m_szSigPath, 0, sizeof(m_szSigPath));
    memset(m_szSigDesc, 0, sizeof(m_szSigDesc));
    memset(m_szExcName, 0, sizeof(m_szExcName));
    memset(m_szExcNameBK, 0, sizeof(m_szExcNameBK));
    memset(m_szLibName, 0, sizeof(m_szLibName));
    memset(m_szLibNameNoExt, 0, sizeof(m_szLibNameNoExt));  
    memset(m_szLibAllName, 0, sizeof(m_szLibAllName));   
    memset(m_szWorkPath, 0, sizeof(m_szWorkPath)); 
    memset(m_szSigFullName, 0, sizeof(m_szSigFullName));
    memset(m_szSigNameNoExt, 0, sizeof(m_szSigNameNoExt));
}

CSigMaker::~CSigMaker()
{
    if (m_hThread)
    {
        TerminateThread(m_hThread, -1);
        CloseHandle(m_hThread);
    }
}

BOOL CSigMaker::CreateSigBatFile(void)
{
    //生成Sig批处理文件
    memset(m_szSigBat1AllFileName, 0, sizeof(m_szSigBat1AllFileName));
    memset(m_szSigBat2AllFileName, 0, sizeof(m_szSigBat1AllFileName));
    _stprintf(m_szSigBat1AllFileName, _T("%s%s"), m_szWorkPath, DEFAULT_SIGBAT1_FILENAME);
    _stprintf(m_szSigBat2AllFileName, _T("%s%s"), m_szWorkPath, DEFAULT_SIGBAT2_FILENAME);
    
    //创建批处理文件一
    FILE *pFile = fopen(m_szSigBat1AllFileName, _T("w+"));
    if (!pFile)
    {
        return FALSE;
    }
    fputs(_T("for /F %%i in ('link -lib /list %1.lib') do link -lib /extract:%%i %1.lib\n"), pFile);
    fputs(_T("for %%i in (*.obj) do pcf -g0 %%i\n"), pFile);
    TCHAR szTmp[256] = {0};
    _stprintf(szTmp, _T("sigmake -n\"%s\" *.pat %s\n"), m_szSigDesc, m_szSigName);
    fputs(szTmp, pFile);
    fclose(pFile);
    pFile = NULL;

    //创建批处理文件二（用于生成sig出错后处理完毕之后再执行）
    pFile = fopen(m_szSigBat2AllFileName, _T("w+"));
    if (!pFile)
    {
        return FALSE;
    }
    memset(szTmp, 0, sizeof(szTmp));
    _stprintf(szTmp, _T("sigmake -n\"%s\" *.pat %s\n"), m_szSigDesc, m_szSigName);
    fputs(szTmp, pFile);
    fclose(pFile);
    pFile = NULL;

    return TRUE;
}

//设置当前模块路径
BOOL CSigMaker::SetModulePath(PCHAR pszModulePath)
{
    if (NULL == pszModulePath)
    {
        return FALSE;
    }
    
    int nLen = _tcslen(pszModulePath);
    if (sizeof(m_szCurrModulePathWithBackslash) < nLen)
    {
        return FALSE;
    }
    if ((sizeof(m_szCurrModulePathWithBackslash) == nLen)
        && ('\\' == pszModulePath[nLen-1]))
    {
        return FALSE;
    }

    _tcsncpy(m_szCurrModulePathWithBackslash, pszModulePath, sizeof(m_szCurrModulePathWithBackslash));

    if ('\\' != pszModulePath[nLen-1])
    {
        _tcscat(m_szCurrModulePathWithBackslash, "\\");
    }
    return TRUE;
}

BOOL CSigMaker::SetEnv(PCHAR pszName, PCHAR pszValue)
{
    if (NULL == pszName || NULL == pszValue)
    {
        return FALSE;
    }

    PCHAR pOldValue = _tgetenv(pszName);
    int nLen = _tcslen(pOldValue) + _tcslen(pszValue) + _tcslen(pszName);
    PCHAR pData = new TCHAR[nLen + 16];
    memset(pData, 0, (nLen + 16)*sizeof(TCHAR));
    _stprintf(pData, _T("%s=%s;%s"), pszName, pOldValue, pszValue);

    if(_tputenv(pData))
    {
        return FALSE;
    }
    delete [] pData;

    return TRUE;
}

BOOL CSigMaker::DoSig()
{
    //删除原有的exc文件
    TCHAR szExcAllName[MAX_PATH]={0};
    _stprintf(szExcAllName, _T("%s%s"), m_szWorkPath, m_szExcName);
    if (IsFileExist(szExcAllName) && !DeleteFile(szExcAllName))
    {
        return FALSE;
    }
    
    TCHAR szExcAllNameBK[MAX_PATH]={0};
    _stprintf(szExcAllNameBK, _T("%s%s"), m_szWorkPath, m_szExcNameBK);
    if (IsFileExist(szExcAllName) && !DeleteFile(szExcAllNameBK))
    {
        return FALSE;
    }
    
    //删除原有的sig文件
    TCHAR szSigAllName[MAX_PATH]={0};
    _stprintf(szSigAllName, _T("%s%s"), m_szWorkPath, m_szSigName);
    if (IsFileExist(szExcAllName) && !DeleteFile(szSigAllName))
    {
        return FALSE;
    }

    TCHAR szParam[MAX_PATH]={0};
    _stprintf(szParam, _T(" /c %s %s "), DEFAULT_SIGBAT1_FILENAME, m_szLibNameNoExt);
    //执行批处理文件一，若出错则生成.exc文件，否则生成Sig文件
    HINSTANCE hInst = ShellExecute(NULL, SHELLEXECUTE_VERB_NAME, SHELLEXECUTE_FILE_NAME, szParam, 
        m_szWorkPath, SW_HIDE);

    //若exc文件存在，则说明sigmaker程序已经执行过，可以开始处理exc文件了
    //若sig文件存在，则说明sigmake没有报错，已经生成sig文件了
    BOOL bOK = FALSE;
    while (TRUE)
    {
        if (IsFileExist(szSigAllName))
        {
            bOK = TRUE;
            break;
        }
        if (IsFileExist(szExcAllName))
        {
            break;
        }
    }

    if (!bOK)
    {
        memset(szParam, 0, sizeof(szParam));
        _stprintf(szParam, _T(" /c copy %s %s "), m_szExcName, m_szExcNameBK);
        ShellExecute(NULL, SHELLEXECUTE_VERB_NAME,SHELLEXECUTE_FILE_NAME , szParam, 
            m_szWorkPath, SW_HIDE);
        Sleep(2000);
        
        memset(szParam, 0, sizeof(szParam));
        _stprintf(szParam, _T("%s\\%s"), m_szWorkPath, m_szExcNameBK);
        FILE *pFilebk = fopen(szParam, _T("r"));
        if (!pFilebk)
        {   
            return FALSE;
        }
        
        memset(szParam, 0, sizeof(szParam));
        _stprintf(szParam, _T("%s\\%s"), m_szWorkPath, m_szExcName);
        FILE *pFile = fopen(szParam, _T("w+"));
        if (!pFile)
        {
            return FALSE;
        }
        
        TCHAR szBuff[1024]={0};
        while (TRUE)
        {
            if (feof(pFilebk))
            {
                break;
            }
            fgets(szBuff, sizeof(szBuff), pFilebk);
            if (szBuff[0] == _T(';'))
            {
                continue;
            }
            fputs(szBuff, pFile);
        }
        fclose(pFile);
        fclose(pFilebk);
        
        memset(szParam, 0, sizeof(szParam));
        _stprintf(szParam, _T(" /c %s %s "), DEFAULT_SIGBAT2_FILENAME, m_szLibNameNoExt);
        hInst = ShellExecute(NULL, SHELLEXECUTE_VERB_NAME, SHELLEXECUTE_FILE_NAME, szParam,
            m_szWorkPath, SW_HIDE); 
        
        while (!IsFileExist(szSigAllName))
        {
            Sleep(200);
            continue;
        }
    }
    //把生成的Sig文件复制到指定的目录
    BOOL bCopy = CopyFile(szSigAllName, m_szSigFullName, FALSE);
    if (!bCopy)
    {
        return FALSE;
    }

    return TRUE;
}

PCHAR CSigMaker::GetExcName()
{
    return m_szExcName;
}

PCHAR CSigMaker::GetExcNameBK()
{
    return m_szExcNameBK;
}

PCHAR CSigMaker::GetCurrModulePathWithBackslash()
{
    return m_szCurrModulePathWithBackslash;
}

PCHAR CSigMaker::GetLibNameNoExt()
{
    return m_szLibNameNoExt;
}

PCHAR CSigMaker::GetSigBat1AllFileName()
{
    return m_szSigBat1AllFileName;
}

PCHAR CSigMaker::GetSigBat2AllFileName()
{
    return m_szSigBat2AllFileName;
}

PCHAR CSigMaker::SetLibName(PCHAR pszLibName)
{
    _tcscpy(m_szLibName, pszLibName);
    _tcscpy(m_szLibNameNoExt, m_szLibName);
    if (_tcsrchr(m_szLibNameNoExt, _T('.')))
    {
        (_tcsrchr(m_szLibNameNoExt, _T('.')))[0] = 0;
    }
    return m_szLibName;
}

PCHAR CSigMaker::SetLibAllName(PCHAR pszLibAllName)
{
    _tcscpy(m_szLibAllName, pszLibAllName);
    int nLen = _tcslen(m_szLibAllName);
    for (int i=nLen-1; i>=0; --i)
    {
        if (_T('\\') == m_szLibAllName[i])
        {
            PCHAR pCurr=&m_szLibAllName[i+1];
            SetLibName(pCurr);
            break;
        }
    }
    return m_szLibAllName;
}

BOOL CSigMaker::MakeSig(PCHAR pszModulePath, PCHAR pszLibAllName, PCHAR pszSigPath, 
                        PCHAR pszSigName, PCHAR pszSigDesc, BOOL bDelTmpFile)
{
    if (NULL == pszModulePath || NULL == pszLibAllName || NULL == pszSigPath
        || NULL == pszSigName || NULL == pszSigDesc)
    {
        return FALSE;
    }
    m_bDelTmpFile = bDelTmpFile;
    SetModulePath(pszModulePath);
    SetLibAllName(pszLibAllName);
    SetSigAllName(pszSigPath, pszSigName, pszSigDesc);
    SetEnv(_T("PATH"), m_szCurrModulePathWithBackslash);
    SetWorkPath();//创建各种目录
    if (!IsFileExist(m_szWorkPath))
    {
        if (0 == CreateDirectory(m_szWorkPath, NULL))
        {
            return FALSE;
        }
    }
    CreateSigBatFile();
    
    BOOL bRet = DoSig();
    if (m_bDelTmpFile)
    {
        if (!DeleteDir(m_szWorkPath))
        {
            MessageBox(NULL, _T("临时文件未能删除成功，请手动删除！"), _T("提示"), MB_OK);
        }
    }
    return bRet;
}

PCHAR CSigMaker::SetExcName()
{
    _stprintf(m_szExcName, _T("%s.exc"), m_szSigNameNoExt);
    _stprintf(m_szExcNameBK, _T("%s.bk"), m_szExcName);
    return m_szExcName;
}

PCHAR CSigMaker::SetWorkPath()
{
    _stprintf(m_szWorkPath, _T("%s%s_sig\\"), m_szCurrModulePathWithBackslash, m_szLibNameNoExt);
    return m_szWorkPath;
}

PCHAR CSigMaker::GetWorkPath()
{
    return m_szWorkPath;
}

HANDLE CSigMaker::GetThreadHandle()
{
    return m_hThread;
}

PCHAR CSigMaker::GetSigName()
{
    return m_szSigName;
}

PCHAR CSigMaker::SetSigAllName(PCHAR pszSigPath, PCHAR pszSigName, PCHAR pszSigDesc)
{
    _tcscpy(m_szSigPath, pszSigPath);
    _tcscpy(m_szSigName, pszSigName);
    _tcscpy(m_szSigDesc, pszSigDesc);
    _tcscpy(m_szSigFullName, m_szSigPath);
    if (_tcsrchr(m_szSigFullName, _T('\\')) == 0)
    {
        _tcscat(m_szSigFullName, _T("\\"));
    }
    _tcscat(m_szSigFullName, m_szSigName);
    _tcscpy(m_szSigNameNoExt, m_szSigName);
    if (_tcsrchr(m_szSigNameNoExt, _T('.')))
    {
        (_tcsrchr(m_szSigNameNoExt, _T('.')))[0] = 0;
    }
    SetExcName();
    return m_szSigFullName;
}

PCHAR CSigMaker::GetSigFullName()
{
    return m_szSigFullName;
}