gonpack/main.go at master · dmpas/gonpack · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
package main

import "fmt"
import "os"
import "io"
import "path"
import "compress/flate"

const exeVersion = "3.0.36"
const exeCopyright = "\n\t2008 Denis Demidov 2008-03-30\n\t2014-2016 Sergey Batanov"

type Extractor struct {
	dirname string
}

type Parser struct {
	dirname string
}

// ProcessData просто выводит данные без обработки
func (un Extractor) ProcessData(f *os.File, filename string) error {
	targetFilePath := path.Join(un.dirname, filename)
	fileOut, err := os.Create(targetFilePath)
	if err != nil {
		return err
	}
	defer fileOut.Close()

	blockReader := GetBlockReader(f)
	_, err = io.Copy(fileOut, blockReader)

	return err
}

func (pr Parser) ProcessData(f *os.File, filename string) error {

	blockReader := GetBlockReader(f)
	inflater := flate.NewReader(blockReader)

	targetFilePath := path.Join(pr.dirname, filename)
	fileOut, err := os.Create(targetFilePath)
	if err != nil {
		return err
	}
	defer fileOut.Close()

	_, err = io.Copy(fileOut, inflater)
	return err
}

func unpack(filename, dirname string, withParse bool) {
	fstat, err := os.Stat(filename)
	if err != nil {
		panic(err)
	}

	FileDataSize := fstat.Size()

	fileIn, err := os.Open(filename)
	if err != nil {
		panic(err)
	}
	defer fileIn.Close()

	supplyDirectory(dirname)

	var processor DataProcessor

	if withParse {
		var p Parser
		p.dirname = dirname
		processor = p
	} else {
		var p Extractor
		p.dirname = dirname
		processor = p
	}

	UnpackToDirectoryNoLoad(dirname, fileIn, FileDataSize, processor)
}

func inflate(packedFileName, unpackedFileName string) {

	fi, err := os.Open(packedFileName)
	if err != nil {
		panic(err)
	}
	defer fi.Close()

	fo, err := os.Create(unpackedFileName)
	if err != nil {
		panic(err)
	}
	defer fo.Close()

	inflater := flate.NewReader(fi)
	io.Copy(fo, inflater)
}

func run(args []string) {

	if len(args) < 2 {
		usage()
		return
	}

	if args[1] == "-parse" || args[1] == "-p" {

		unpack(args[2], args[3], true)

	} else if args[1] == "-unpack" || args[1] == "-u" {

		unpack(args[2], args[3], false)

	} else if args[1] == "-inflate" || args[1] == "-i" {

		inflate(args[2], args[3])

	} else {
		usage()
	}
}

func usage() {
	fmt.Println()
	fmt.Printf("V8Upack Version %s Copyright (c) %s\n", exeVersion, exeCopyright)
	fmt.Println()
	fmt.Println("Unpack, pack, deflate and inflate 1C v8 file (*.cf)")
	fmt.Println()
	fmt.Println("V8UNPACK")
	fmt.Println("  -U[NPACK]     in_filename.cf     out_dirname")
	fmt.Println("  -PA[CK]       in_dirname         out_filename.cf")
	fmt.Println("  -I[NFLATE]    in_filename.data   out_filename")
	fmt.Println("  -D[EFLATE]    in_filename        filename.data")
	fmt.Println("  -E[XAMPLE]")
	fmt.Println("  -BAT")
	fmt.Println("  -P[ARSE]      in_filename        out_dirname")
	fmt.Println("  -B[UILD]      in_dirname         out_filename")
	fmt.Println("  -V[ERSION]")
}

func version() {
	fmt.Println(exeVersion)
}

func main() {
	run(os.Args)
}