root/lang/c/AutoUpdater/trunk/recipes/Copy.c @ 38013

#ifndef _UNICODE
#error
#endif

#include <windows.h>
#include <tchar.h>
#include <commctrl.h>


/* http://msdn.microsoft.com/en-us/library/bb531404.aspx */
/* swap _M_IX86 and _M_X64 */
#if defined _M_X64
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"")
#elif defined _M_IX86
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"")
#elif defined _M_IA64
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='ia64' publicKeyToken='6595b64144ccf1df' language='*'\"")
#else
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
#endif

/* http://msdn.microsoft.com/en-us/library/1fdeehz6%28v=VS.80%29.aspx */
void *memset(void *dest_, int c, size_t count) {
    size_t i = 0;
    unsigned char* dest = (unsigned char*)dest_;
        if (!dest_) {
                return dest_;
        }
    for (i = 0; i < count; ++i) {
        dest[i] = (unsigned char)c;
    }
    return dest_;
}

HANDLE LogFile = INVALID_HANDLE_VALUE;

int AUI_Debug(const TCHAR* format, ...) {
    TCHAR output[1024]; /* http://msdn.microsoft.com/en-us/library/ms647550%28VS.85%29.aspx */
    va_list ap;
    va_start(ap, format);
    wvsprintf(output, format, ap);
    va_end(ap);
    OutputDebugString(output);
    if (LogFile != INVALID_HANDLE_VALUE) {
        DWORD written = 0;
        WriteFile(LogFile, output, lstrlen(output) * sizeof(output[0]), &written, NULL);
        FlushFileBuffers(LogFile);
    }
    return 0;
}

TCHAR* AUI_PathAppend(const TCHAR* base, const TCHAR* append) {
    TCHAR* result = NULL;
    int result_len = 0;
    
    result_len = lstrlen(base) + 1 + lstrlen(append) + 1;
    result = (TCHAR*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, result_len * sizeof(TCHAR));
    if (!result) {
        return NULL;
    }
    lstrcpy(result, base);
    
    {
        size_t base_len = lstrlen(base);
        if (base_len >= 1) {
            TCHAR last = base[base_len - 1];
            if (last != '/' && last != '\\') {
                lstrcat(result, _T("\\"));
            }
        }
    }
    
    lstrcat(result, append);
    return result;
}

BOOL CopyDirectory(const TCHAR* from, const TCHAR* to) {
    TCHAR* glob = NULL;
        WIN32_FIND_DATA find_data;
    HANDLE hFind = NULL;
    BOOL result = TRUE;

    if (!from || !to) {
        return FALSE;
    }

    glob = AUI_PathAppend(from, _T("*"));
        hFind = FindFirstFile(glob, &find_data);
        if( INVALID_HANDLE_VALUE == hFind ) {
                return FALSE;
        }

        do {
        TCHAR* from2 = NULL;
        TCHAR* to2 = NULL;

        AUI_Debug(_T("<%s>\n"), find_data.cFileName);

        if (CompareString(LOCALE_USER_DEFAULT, 0, find_data.cFileName, -1, _T("."), -1) == CSTR_EQUAL) {
            continue;
        }
        if (CompareString(LOCALE_USER_DEFAULT, 0, find_data.cFileName, -1, _T(".."), -1) == CSTR_EQUAL) {
            continue;
        }

        from2 = AUI_PathAppend(from, find_data.cFileName);
        to2 = AUI_PathAppend(to, find_data.cFileName);

        AUI_Debug(_T("%s -> %s\n"), from2, to2);

                if (FILE_ATTRIBUTE_DIRECTORY & find_data.dwFileAttributes) {
            AUI_Debug(_T("dir error\n"));
            result = result && CreateDirectory(to2, NULL) && CopyDirectory(from2, to2);
        } else if(!CopyFile(from2, to2, FALSE)) {
            AUI_Debug(_T("file error\n"));
            result = FALSE;
                }

        HeapFree(GetProcessHeap(), 0, to2);
        HeapFree(GetProcessHeap(), 0, from2);

    } while(FindNextFile(hFind, &find_data));

    AUI_Debug(_T("end\n"));
        FindClose(hFind);
    HeapFree(GetProcessHeap(), 0, glob);
        return result;
}

int main(void) {
    HANDLE hFile = NULL;
    HANDLE hProcess = NULL;
    DWORD bytes = 0;
    DWORD bytes_got = 0;
    TCHAR* data = NULL;
    TCHAR* new_program = NULL;
    TCHAR* new_program_cd = NULL;
    TCHAR* update_from = NULL;
    TCHAR* update_to = NULL;
    TCHAR* clean_after = NULL;
    TCHAR* pid_string = NULL;
    DWORD pid = 0;
    int complete = 0;
    TCHAR* clean_command = NULL;
    TCHAR* temp_path = NULL;
    TCHAR* log_full_path = NULL;
    PVOID log_name = NULL;
    TCHAR* command = NULL;

    InitCommonControls();

    {
        size_t temp_path_chars = GetTempPath(0, NULL);
        temp_path = (TCHAR*)HeapAlloc(GetProcessHeap(), 
            HEAP_ZERO_MEMORY, (temp_path_chars * sizeof(TCHAR)));
        if (!temp_path) {
            goto clean_up;
        }
        GetTempPath(temp_path_chars, temp_path);
    }

    {
        unsigned int arg = 0;
        arg = GetCurrentProcessId();
        if (FormatMessage(
                FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                _T("AutoUpdaterLog.%1!x!.txt"),
                0,
                0,
                (TCHAR*)&log_name,
                0,
                (va_list*)&arg)) {
            log_full_path = AUI_PathAppend(temp_path, (TCHAR*)log_name);
            if (log_full_path) {
                LogFile = CreateFile(log_full_path, GENERIC_WRITE, 
                    FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
            }
        }
    }

    AUI_Debug(_T("***** UpdaterProcess start: pid=0x%x *****\n"), GetCurrentProcessId());


    hFile = CreateFile(_T("AutoUpdater.txt"), GENERIC_READ, 0, NULL, 
        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

    if (hFile == INVALID_HANDLE_VALUE) {
        AUI_Debug(_T("config file not found\n"));
        goto clean_up;
    }

    bytes = GetFileSize(hFile, NULL);
    data = (TCHAR*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bytes + (/* null terminate */ sizeof(TCHAR)));
    if (!data) {
        goto clean_up;
    }

    if (ReadFile(hFile, data, bytes, &bytes_got, NULL) == 0) {
        goto clean_up;
    }

    {
        TCHAR* lines[6];
        size_t i = 0;
        size_t data_count = (bytes / sizeof(data[0]));
        unsigned line = 0;
        memset(lines, 0, sizeof(lines));
        for (i = 0; i < data_count; ++i) {
            if (data[i] == _T('\r')) {
                data[i] = 0;
            } else if (data[i] == _T('\n')) {
                data[i] = 0;
                if (i + 1 >= data_count) {
                    continue;
                }
                if (line >= sizeof(lines) / sizeof(lines[0])) {
                    break;
                }
                lines[line] = &data[i + 1];
                line++;
            }
        }
        pid_string     = lines[0];
        update_from    = lines[1];
        update_to      = lines[2];
        new_program    = lines[3];
        new_program_cd = lines[4];
        clean_after    = lines[5];
    }

    AUI_Debug(_T("pid=%s, from=%s, to=%s\nnewproc=%s, cd=%s clean=%s\n"), 
        pid_string, update_from, update_to, new_program, new_program_cd, clean_after);
    
    if (pid_string) {
        int i = 0;
        for (i = 0; pid_string[i]; ++i) {
            if (pid_string[i] < _T('0') || _T('9') < pid_string[i]) {
                AUI_Debug(_T("pid error\n"));
                goto clean_up;
            }
            pid = pid * 10;
            pid += pid_string[i] - _T('0');
        }
    }

    if (clean_after) {
        TCHAR comspec[MAX_PATH];
        TCHAR rd_command[] = _T("\"%s\" /c rd /s /q \"%s\"");
        size_t clean_command_len = 0;
        if (GetEnvironmentVariable(_T("COMSPEC"), comspec, sizeof(comspec) / sizeof(comspec[0])) == 0) {
            goto clean_up;
        }

        clean_command_len = lstrlen(comspec) + lstrlen(rd_command) + lstrlen(clean_after);
        clean_command = (TCHAR*)HeapAlloc(GetProcessHeap(), 
            HEAP_ZERO_MEMORY, clean_command_len * sizeof(TCHAR));
        if (!clean_command) {
            goto clean_up;
        }
        wsprintf(clean_command, rd_command, comspec, clean_after); 
    }

    AUI_Debug(L"waiting\n");
    hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | SYNCHRONIZE, FALSE, pid);
    if (hProcess) {
        WaitForSingleObject(hProcess, INFINITE);
    }

    AUI_Debug(L"start copy\n");

    if (CopyDirectory(update_from, update_to)) {
        complete = 1;
    }

clean_up:
    if (new_program && new_program_cd) {
        TCHAR* arg = NULL;
        TCHAR command_format[] = _T("\"%s\" %s");
        TCHAR complete_arg[] = _T("UPDATE_COMPLETE");
        TCHAR error_arg[] = _T("UPDATE_ERROR");
        int command_len = 0;
        SetLastError(0);
        if (complete) {
            arg = complete_arg;
        } else {
            arg = error_arg;
        }
        command_len = lstrlen(command_format);
        command_len += lstrlen(new_program);
        command_len += lstrlen(arg);

        command = (TCHAR*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (unsigned)command_len * sizeof(TCHAR));
        if (command) {
            wsprintf(command, command_format, new_program, arg);
        }
    }

    if (command && new_program_cd) {
        STARTUPINFO si;
        PROCESS_INFORMATION pi;
        DWORD e;
        memset(&si, 0, sizeof(si));
        si.cb = sizeof(si);
        memset(&pi, 0, sizeof(pi));

                SetLastError(0);
        CreateProcess(NULL, command, NULL, NULL, FALSE, 0, NULL, new_program_cd, &si, &pi);
        e = GetLastError();
        AUI_Debug(_T("CreateProcess(): command=%s, cd=%s, error=%d\n"), command, new_program_cd, e);

        CloseHandle(pi.hThread);
        CloseHandle(pi.hProcess);
    }

        if (hFile != INVALID_HANDLE_VALUE) {
            CloseHandle(hFile);
        }
        if (hProcess) {
                CloseHandle(hProcess);
        }

    if (log_name) {
        LocalFree(log_name);
    }

    if (clean_command) {
        STARTUPINFO si;
        PROCESS_INFORMATION pi;
        memset(&si, 0, sizeof(si));
        si.cb = sizeof(si);
        si.dwFlags = STARTF_USESHOWWINDOW; 
        si.wShowWindow = SW_HIDE; 
        memset(&pi, 0, sizeof(pi));
        AUI_Debug(_T("CreateProcess(del): command=%s, cd=%s\n"), clean_command, temp_path);
        CreateProcess(NULL, clean_command, NULL, NULL, FALSE, 0, NULL, temp_path, &si, &pi);
            CloseHandle(pi.hThread);
            CloseHandle(pi.hProcess);
    }

    if (LogFile != INVALID_HANDLE_VALUE) {
        CloseHandle(LogFile);
        if (complete) {
            //DeleteFile(log_full_path);
        }
    }

    /*

    if (log_full_path) {
        HeapFree(GetProcessHeap(), 0, log_full_path);
    }

    if (data) {
        HeapFree(GetProcessHeap(), 0, data);
    }
    if (command) {
        HeapFree(GetProcessHeap(), 0, command);
    }
    if (clean_command) {
        HeapFree(GetProcessHeap(), 0, clean_command);
    }
    if (temp_path) {
        HeapFree(GetProcessHeap(), 0, clean_cd);
    }
    */    

    return 0;
}