574 lines
17 KiB
Go
574 lines
17 KiB
Go
package main
|
|
|
|
import (
|
|
"archive/zip"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync/atomic"
|
|
"time"
|
|
)
|
|
|
|
// ── 상수 및 변수 ─────────────────────────────────────────────
|
|
|
|
const maxDownloadSize = 2 << 30 // 2 GB
|
|
const maxExtractFileSize = 4 << 30 // 개별 파일 최대 4 GB
|
|
const tmpZipName = "a301_game.zip" // 임시 다운로드 파일명
|
|
|
|
var downloadCancelled atomic.Bool
|
|
|
|
// ── HTTP 클라이언트 ──────────────────────────────────────────
|
|
|
|
// checkRedirect 허용되지 않는 스킴이나 과도한 리다이렉트를 차단한다.
|
|
var checkRedirect = func(req *http.Request, via []*http.Request) error {
|
|
if req.URL.Scheme != "https" && req.URL.Scheme != "http" {
|
|
return fmt.Errorf("허용되지 않는 리다이렉트 스킴: %s", req.URL.Scheme)
|
|
}
|
|
if len(via) >= 10 {
|
|
return fmt.Errorf("리다이렉트 횟수 초과")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// apiClient 서버 정보 조회 등 짧은 요청용 (전체 120초 타임아웃).
|
|
var apiClient = &http.Client{
|
|
Timeout: 120 * time.Second,
|
|
CheckRedirect: checkRedirect,
|
|
}
|
|
|
|
// downloadClient 대용량 파일 다운로드용 (전체 타임아웃 없음).
|
|
var downloadClient = &http.Client{
|
|
Transport: &http.Transport{
|
|
TLSHandshakeTimeout: 30 * time.Second,
|
|
ResponseHeaderTimeout: 30 * time.Second,
|
|
IdleConnTimeout: 60 * time.Second,
|
|
},
|
|
CheckRedirect: checkRedirect,
|
|
}
|
|
|
|
// ── 파일 다운로드 ────────────────────────────────────────────
|
|
|
|
// doDownloadRequest Range 헤더로 이어받기를 시도한다.
|
|
// 서버가 416(범위 불일치)을 반환하면 임시 파일을 삭제하고 처음부터 다시 요청한다.
|
|
func doDownloadRequest(downloadURL, tmpPath string) (resp *http.Response, resumeOffset int64, err error) {
|
|
for attempt := 0; attempt < 2; attempt++ {
|
|
resumeOffset = 0
|
|
if fi, statErr := os.Stat(tmpPath); statErr == nil {
|
|
resumeOffset = fi.Size()
|
|
}
|
|
|
|
req, err := http.NewRequest("GET", downloadURL, nil)
|
|
if err != nil {
|
|
return nil, 0, fmt.Errorf("다운로드 요청 생성 실패: %w", err)
|
|
}
|
|
if resumeOffset > 0 {
|
|
req.Header.Set("Range", fmt.Sprintf("bytes=%d-", resumeOffset))
|
|
}
|
|
|
|
resp, err := downloadClient.Do(req)
|
|
if err != nil {
|
|
return nil, 0, fmt.Errorf("다운로드 연결 실패: %w", err)
|
|
}
|
|
|
|
if resp.StatusCode == http.StatusRequestedRangeNotSatisfiable {
|
|
resp.Body.Close()
|
|
os.Remove(tmpPath)
|
|
continue
|
|
}
|
|
return resp, resumeOffset, nil
|
|
}
|
|
return nil, 0, fmt.Errorf("다운로드 실패: 재시도 횟수 초과")
|
|
}
|
|
|
|
// openTmpFile 응답 상태에 따라 임시 파일을 이어쓰기 또는 새로 생성한다.
|
|
func openTmpFile(resp *http.Response, tmpPath string, resumeOffset int64) (tmpFile *os.File, downloaded, total int64, err error) {
|
|
switch resp.StatusCode {
|
|
case http.StatusPartialContent:
|
|
downloaded = resumeOffset
|
|
if resp.ContentLength > 0 {
|
|
total = resumeOffset + resp.ContentLength
|
|
}
|
|
tmpFile, err = os.OpenFile(tmpPath, os.O_WRONLY|os.O_APPEND, 0644)
|
|
case http.StatusOK:
|
|
if resp.ContentLength > 0 {
|
|
total = resp.ContentLength
|
|
}
|
|
tmpFile, err = os.Create(tmpPath)
|
|
default:
|
|
return nil, 0, 0, fmt.Errorf("다운로드 실패 (HTTP %d)", resp.StatusCode)
|
|
}
|
|
if err != nil {
|
|
return nil, 0, 0, fmt.Errorf("임시 파일 열기 실패: %w", err)
|
|
}
|
|
if total > maxDownloadSize {
|
|
tmpFile.Close()
|
|
os.Remove(tmpPath)
|
|
return nil, 0, 0, fmt.Errorf("파일이 너무 큽니다 (%d bytes)", total)
|
|
}
|
|
return tmpFile, downloaded, total, nil
|
|
}
|
|
|
|
// formatProgress 다운로드 진행률 텍스트를 생성한다.
|
|
func formatProgress(pct int, speedBytesPerSec float64, remaining float64) string {
|
|
if speedBytesPerSec <= 0 {
|
|
return fmt.Sprintf("다운로드 중... %d%%", pct)
|
|
}
|
|
speedMB := speedBytesPerSec / 1024 / 1024
|
|
if remaining < 60 {
|
|
return fmt.Sprintf("다운로드 중... %d%% (%.1f MB/s, %d초 남음)", pct, speedMB, int(remaining))
|
|
}
|
|
return fmt.Sprintf("다운로드 중... %d%% (%.1f MB/s, %d분 남음)", pct, speedMB, int(remaining/60))
|
|
}
|
|
|
|
// downloadBody 응답 본문을 tmpFile에 쓰고 진행률을 갱신한다.
|
|
// downloaded는 이어받기 시작 오프셋, total은 전체 크기(미확정이면 0).
|
|
// tmpPath는 크기 초과 시 파일 삭제에만 사용된다.
|
|
// 완료 또는 오류 시 tmpFile을 닫는다.
|
|
func downloadBody(resp *http.Response, tmpFile *os.File, tmpPath string, downloaded, total int64) error {
|
|
buf := make([]byte, 32*1024)
|
|
var lastSpeedUpdate time.Time
|
|
var lastBytes int64
|
|
var speedBytesPerSec float64
|
|
|
|
for {
|
|
if downloadCancelled.Load() {
|
|
tmpFile.Close()
|
|
return fmt.Errorf("다운로드가 취소되었습니다")
|
|
}
|
|
|
|
n, readErr := resp.Body.Read(buf)
|
|
if n > 0 {
|
|
if _, werr := tmpFile.Write(buf[:n]); werr != nil {
|
|
tmpFile.Close()
|
|
return fmt.Errorf("파일 쓰기 실패: %w", werr)
|
|
}
|
|
downloaded += int64(n)
|
|
if downloaded > maxDownloadSize {
|
|
tmpFile.Close()
|
|
os.Remove(tmpPath)
|
|
return fmt.Errorf("다운로드 크기가 제한을 초과했습니다")
|
|
}
|
|
|
|
// 500ms마다 속도 계산 및 진행률 갱신
|
|
now := time.Now()
|
|
if now.Sub(lastSpeedUpdate) >= 500*time.Millisecond {
|
|
elapsed := now.Sub(lastSpeedUpdate).Seconds()
|
|
if elapsed > 0 {
|
|
speedBytesPerSec = float64(downloaded-lastBytes) / elapsed
|
|
}
|
|
lastBytes = downloaded
|
|
lastSpeedUpdate = now
|
|
}
|
|
|
|
if total > 0 {
|
|
pct := int(downloaded * 100 / total)
|
|
if pct > 100 {
|
|
pct = 100
|
|
}
|
|
remaining := float64(total-downloaded) / speedBytesPerSec
|
|
setProgress(formatProgress(pct, speedBytesPerSec, remaining), pct)
|
|
}
|
|
}
|
|
if readErr == io.EOF {
|
|
break
|
|
}
|
|
if readErr != nil {
|
|
tmpFile.Close()
|
|
return fmt.Errorf("다운로드 중 오류: %w", readErr)
|
|
}
|
|
}
|
|
return tmpFile.Close()
|
|
}
|
|
|
|
// doDownload 파일을 다운로드하고 zip을 추출하여 destDir에 배치한다.
|
|
// 다운로드 완료 후 zip 파일은 tmpZipName 경로에 남겨둔다 (ensureGame에서 해시 검증 후 삭제).
|
|
func doDownload(downloadURL, destDir string) error {
|
|
tmpPath := filepath.Join(os.TempDir(), tmpZipName)
|
|
|
|
resp, resumeOffset, err := doDownloadRequest(downloadURL, tmpPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
tmpFile, downloaded, total, err := openTmpFile(resp, tmpPath, resumeOffset)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := downloadBody(resp, tmpFile, tmpPath, downloaded, total); err != nil {
|
|
return err
|
|
}
|
|
|
|
setProgress("압축을 해제하는 중...", -1)
|
|
|
|
tmpExtractDir, err := os.MkdirTemp("", "a301_extract_")
|
|
if err != nil {
|
|
return fmt.Errorf("임시 추출 디렉토리 생성 실패: %w", err)
|
|
}
|
|
defer os.RemoveAll(tmpExtractDir)
|
|
|
|
if err := extractZip(tmpPath, tmpExtractDir); err != nil {
|
|
return err
|
|
}
|
|
if err := moveContents(tmpExtractDir, destDir); err != nil {
|
|
return fmt.Errorf("파일 이동 실패: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ── zip 추출 ─────────────────────────────────────────────────
|
|
|
|
// extractZip zip 파일을 destDir에 추출한다.
|
|
// zip에 단일 최상위 래퍼 디렉토리가 있으면 1단계 제거하고, launcher.exe 자신은 덮어쓰기 방지.
|
|
func extractZip(zipPath, destDir string) error {
|
|
r, err := zip.OpenReader(zipPath)
|
|
if err != nil {
|
|
return fmt.Errorf("zip 열기 실패: %w", err)
|
|
}
|
|
defer r.Close()
|
|
|
|
strip := hasWrapperDir(r.File)
|
|
selfName := strings.ToLower(filepath.Base(os.Args[0]))
|
|
|
|
for _, f := range r.File {
|
|
rel := resolveZipEntry(f.Name, strip)
|
|
if rel == "" {
|
|
continue
|
|
}
|
|
|
|
// 보안 검증: 절대 경로, ADS, 경로 탈출(zip slip) 차단
|
|
if filepath.IsAbs(rel) {
|
|
return fmt.Errorf("잘못된 zip 경로 (절대 경로): %s", rel)
|
|
}
|
|
if strings.Contains(rel, ":") {
|
|
return fmt.Errorf("잘못된 zip 경로 (ADS): %s", rel)
|
|
}
|
|
dest := filepath.Join(destDir, filepath.FromSlash(rel))
|
|
if !strings.HasPrefix(filepath.Clean(dest), filepath.Clean(destDir)+string(os.PathSeparator)) &&
|
|
filepath.Clean(dest) != filepath.Clean(destDir) {
|
|
return fmt.Errorf("잘못된 zip 경로: %s", rel)
|
|
}
|
|
|
|
// 자기 자신(launcher.exe)은 덮어쓰지 않음
|
|
if strings.ToLower(filepath.Base(rel)) == selfName {
|
|
continue
|
|
}
|
|
// 심볼릭 링크는 건너뜀
|
|
if f.FileInfo().Mode()&os.ModeSymlink != 0 {
|
|
continue
|
|
}
|
|
|
|
if f.FileInfo().IsDir() {
|
|
os.MkdirAll(dest, 0755)
|
|
continue
|
|
}
|
|
|
|
if err := extractFile(f, dest); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// hasWrapperDir zip의 모든 엔트리가 동일한 단일 최상위 디렉토리 아래에 있는지 확인한다.
|
|
// 예: "game/A301.exe", "game/Data/" → true ("game"이 래퍼)
|
|
// "A301.exe", "A301_Data/" → false (래퍼 없음)
|
|
func hasWrapperDir(files []*zip.File) bool {
|
|
if len(files) == 0 {
|
|
return false
|
|
}
|
|
var wrapper string
|
|
for _, f := range files {
|
|
clean := filepath.ToSlash(f.Name)
|
|
parts := strings.SplitN(clean, "/", 2)
|
|
top := parts[0]
|
|
if len(parts) == 1 && !f.FileInfo().IsDir() {
|
|
// 루트 레벨에 파일이 있으면 래퍼 디렉토리 아님
|
|
return false
|
|
}
|
|
if wrapper == "" {
|
|
wrapper = top
|
|
} else if top != wrapper {
|
|
// 최상위에 여러 폴더/파일 → 래퍼 아님
|
|
return false
|
|
}
|
|
}
|
|
return wrapper != ""
|
|
}
|
|
|
|
// resolveZipEntry zip 엔트리의 경로를 반환한다.
|
|
// strip=true이면 최상위 디렉토리를 제거한다.
|
|
func resolveZipEntry(name string, strip bool) string {
|
|
clean := filepath.ToSlash(name)
|
|
if !strip {
|
|
// 래퍼 없음: 디렉토리 엔트리("/")만 빈 문자열로 반환
|
|
clean = strings.TrimSuffix(clean, "/")
|
|
if clean == "" {
|
|
return ""
|
|
}
|
|
return clean
|
|
}
|
|
// 래퍼 제거
|
|
parts := strings.SplitN(clean, "/", 2)
|
|
if len(parts) < 2 || parts[1] == "" {
|
|
return "" // 래퍼 디렉토리 자체
|
|
}
|
|
return parts[1]
|
|
}
|
|
|
|
// extractFile 단일 zip 엔트리를 dest 경로에 추출한다.
|
|
func extractFile(f *zip.File, dest string) error {
|
|
if err := os.MkdirAll(filepath.Dir(dest), 0755); err != nil {
|
|
return err
|
|
}
|
|
rc, err := f.Open()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer rc.Close()
|
|
|
|
out, err := os.Create(dest)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, copyErr := io.Copy(out, io.LimitReader(rc, maxExtractFileSize))
|
|
closeErr := out.Close()
|
|
if copyErr != nil {
|
|
return copyErr
|
|
}
|
|
if closeErr != nil {
|
|
return fmt.Errorf("파일 닫기 실패: %w", closeErr)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ── 파일 유틸리티 ────────────────────────────────────────────
|
|
|
|
// moveContents srcDir의 모든 파일/폴더를 dstDir로 이동한다.
|
|
// Rename 실패 시 복사 후 원본 삭제로 대체한다.
|
|
func moveContents(srcDir, dstDir string) error {
|
|
entries, err := os.ReadDir(srcDir)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, e := range entries {
|
|
src := filepath.Join(srcDir, e.Name())
|
|
dst := filepath.Join(dstDir, e.Name())
|
|
if e.IsDir() {
|
|
if err := os.MkdirAll(dst, 0755); err != nil {
|
|
return err
|
|
}
|
|
if err := moveContents(src, dst); err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
// 기존 파일 삭제 후 이동. 삭제 실패 시(파일 잠금 등) 에러 반환.
|
|
if err := os.Remove(dst); err != nil && !os.IsNotExist(err) {
|
|
return fmt.Errorf("기존 파일 삭제 실패 (%s): %w", e.Name(), err)
|
|
}
|
|
if err := os.Rename(src, dst); err != nil {
|
|
if err := copyFile(src, dst); err != nil {
|
|
os.Remove(dst)
|
|
return err
|
|
}
|
|
os.Remove(src)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// copyFile src를 dst로 복사한다.
|
|
func copyFile(src, dst string) error {
|
|
in, err := os.Open(src)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer in.Close()
|
|
out, err := os.Create(dst)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err = io.Copy(out, in); err != nil {
|
|
out.Close()
|
|
return err
|
|
}
|
|
return out.Close()
|
|
}
|
|
|
|
// hashFile 파일의 SHA-256 해시를 계산한다.
|
|
func hashFile(path string) (string, error) {
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer f.Close()
|
|
h := sha256.New()
|
|
if _, err := io.Copy(h, f); err != nil {
|
|
return "", err
|
|
}
|
|
return hex.EncodeToString(h.Sum(nil)), nil
|
|
}
|
|
|
|
// ── 게임/런처 업데이트 ──────────────────────────────────────
|
|
|
|
const hashFileName = ".filehash" // 마지막 설치된 zip 해시를 저장하는 파일
|
|
|
|
// readLocalHash 로컬에 저장된 마지막 zip 해시를 읽는다.
|
|
func readLocalHash(gameDir string) string {
|
|
data, err := os.ReadFile(filepath.Join(gameDir, hashFileName))
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return strings.TrimSpace(string(data))
|
|
}
|
|
|
|
// writeLocalHash zip 해시를 로컬에 저장한다.
|
|
func writeLocalHash(gameDir, hash string) {
|
|
os.WriteFile(filepath.Join(gameDir, hashFileName), []byte(hash), 0644)
|
|
}
|
|
|
|
// ensureGame 게임 파일이 최신인지 확인하고 필요 시 다운로드한다.
|
|
// 서버의 fileHash는 zip 파일 전체의 해시이므로, 로컬에 저장된 해시와 비교한다.
|
|
func ensureGame(gameDir, gamePath string, serverInfo *downloadInfo) error {
|
|
if serverInfo.FileHash == "" {
|
|
return fmt.Errorf("서버에서 유효한 파일 정보를 받지 못했습니다")
|
|
}
|
|
|
|
// 게임 파일이 없거나 로컬 해시가 서버와 다르면 다운로드 필요
|
|
localHash := readLocalHash(gameDir)
|
|
if _, err := os.Stat(gamePath); err == nil && strings.EqualFold(localHash, serverInfo.FileHash) {
|
|
return nil // 게임 파일 존재 + 해시 일치 → 최신 상태
|
|
}
|
|
|
|
// URL 검증 후 다운로드
|
|
if serverInfo.URL == "" {
|
|
return fmt.Errorf("다운로드 URL이 없습니다")
|
|
}
|
|
u, err := url.Parse(serverInfo.URL)
|
|
if err != nil || (u.Scheme != "https" && u.Scheme != "http") {
|
|
return fmt.Errorf("유효하지 않은 다운로드 URL")
|
|
}
|
|
if err := downloadWithProgress(serverInfo.URL, gameDir); err != nil {
|
|
return fmt.Errorf("게임 설치 실패: %w", err)
|
|
}
|
|
|
|
// 다운로드된 zip의 해시를 검증 후 삭제
|
|
tmpPath := filepath.Join(os.TempDir(), tmpZipName)
|
|
defer os.Remove(tmpPath)
|
|
|
|
zipHash, err := hashFile(tmpPath)
|
|
if err != nil {
|
|
return fmt.Errorf("다운로드 후 파일 검증 실패: %w", err)
|
|
}
|
|
if !strings.EqualFold(zipHash, serverInfo.FileHash) {
|
|
return fmt.Errorf("다운로드된 파일의 해시가 일치하지 않습니다 (파일이 손상되었을 수 있습니다)")
|
|
}
|
|
|
|
writeLocalHash(gameDir, serverInfo.FileHash)
|
|
return nil
|
|
}
|
|
|
|
// downloadFile url에서 destPath로 파일을 다운로드한다.
|
|
func downloadFile(dlURL, destPath string) error {
|
|
resp, err := apiClient.Get(dlURL)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != http.StatusOK {
|
|
return fmt.Errorf("HTTP %d", resp.StatusCode)
|
|
}
|
|
f, err := os.Create(destPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = io.Copy(f, io.LimitReader(resp.Body, maxDownloadSize))
|
|
if closeErr := f.Close(); closeErr != nil && err == nil {
|
|
err = closeErr
|
|
}
|
|
return err
|
|
}
|
|
|
|
// ensureLauncher 설치된 런처가 최신인지 확인하고 필요 시 교체한다.
|
|
// 항상 설치 경로(%LOCALAPPDATA%\A301\launcher.exe)를 대상으로 한다.
|
|
func ensureLauncher(serverInfo *downloadInfo) (updated bool, err error) {
|
|
if serverInfo.LauncherHash == "" {
|
|
return false, nil
|
|
}
|
|
|
|
dir, err := installDir()
|
|
if err != nil {
|
|
return false, nil
|
|
}
|
|
installedPath := filepath.Join(dir, "launcher.exe")
|
|
|
|
localHash, err := hashFile(installedPath)
|
|
if err != nil {
|
|
return false, nil
|
|
}
|
|
if strings.EqualFold(localHash, serverInfo.LauncherHash) {
|
|
return false, nil
|
|
}
|
|
|
|
dlURL := serverInfo.LauncherURL
|
|
if dlURL == "" {
|
|
return false, nil
|
|
}
|
|
|
|
// 새 런처를 .new로 다운로드 → 해시 검증 → 기존 파일과 교체
|
|
newPath := installedPath + ".new"
|
|
if err := downloadFile(dlURL, newPath); err != nil {
|
|
os.Remove(newPath)
|
|
return false, fmt.Errorf("런처 업데이트 다운로드 실패: %w", err)
|
|
}
|
|
|
|
newHash, err := hashFile(newPath)
|
|
if err != nil {
|
|
os.Remove(newPath)
|
|
return false, fmt.Errorf("런처 검증 실패: %w", err)
|
|
}
|
|
if !strings.EqualFold(newHash, serverInfo.LauncherHash) {
|
|
os.Remove(newPath)
|
|
return false, fmt.Errorf("런처 해시 불일치")
|
|
}
|
|
|
|
// 원자적 교체: 기존→.old, .new→기존
|
|
oldPath := installedPath + ".old"
|
|
os.Remove(oldPath)
|
|
if err := os.Rename(installedPath, oldPath); err != nil {
|
|
os.Remove(newPath)
|
|
return false, fmt.Errorf("런처 교체 실패: %w", err)
|
|
}
|
|
if err := os.Rename(newPath, installedPath); err != nil {
|
|
// 교체 실패 시 복원 시도
|
|
if restoreErr := os.Rename(oldPath, installedPath); restoreErr != nil {
|
|
return false, fmt.Errorf("런처 교체 실패 및 복원 불가: %w (원인: %v)", restoreErr, err)
|
|
}
|
|
return false, fmt.Errorf("런처 교체 실패: %w", err)
|
|
}
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// cleanupOldFiles 이전 런처 업데이트에서 남은 .old/.new 파일을 제거한다.
|
|
func cleanupOldFiles(dir string) {
|
|
entries, err := os.ReadDir(dir)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for _, e := range entries {
|
|
name := e.Name()
|
|
if strings.HasSuffix(name, ".old") || strings.HasSuffix(name, ".new") {
|
|
os.Remove(filepath.Join(dir, name))
|
|
}
|
|
}
|
|
}
|