|
0
|
1 /*
|
|
|
2 client.go : client-program.
|
|
12
|
3 Version : 1.3
|
|
|
4 Last Change: 2018-11-13 火 12:03:00.
|
|
0
|
5
|
|
|
6 install to: rsearcher_root/
|
|
|
7
|
|
|
8 rsearcher_root/client.exe
|
|
|
9 + grsearcher.exe
|
|
|
10 + app.conf
|
|
12
|
11 + upgrade.bat
|
|
0
|
12 + auth.db ( temporary )
|
|
|
13 + hhs.db ( temporary )
|
|
12
|
14 + index.db ( 14 days )
|
|
3
|
15 + image/*.png, *.jpg
|
|
0
|
16 + doc/
|
|
4
|
17 + .cache/* ( temporary )
|
|
0
|
18
|
|
8
|
19 $ client.exe -r 192.168.0.1:3910 # get new release
|
|
|
20 $ client.exe -u 192.168.0.1:3910 # get new dbs
|
|
0
|
21 $ client.exe 192.168.0.1:3910 0800012345 20171231 # get images
|
|
12
|
22 $ client.exe -a 192.168.0.1:3910 upfile.txt # upload file to /upload
|
|
|
23 $ client.exe -m 192.168.0.1:3910 hhs.db # upload file to /db
|
|
0
|
24 */
|
|
|
25 package main
|
|
|
26
|
|
|
27 import (
|
|
|
28 "archive/tar"
|
|
|
29 "bytes"
|
|
|
30 "compress/gzip"
|
|
|
31 "flag"
|
|
|
32 "fmt"
|
|
|
33 "io"
|
|
|
34 "io/ioutil"
|
|
|
35 "log"
|
|
|
36 "net/http"
|
|
|
37 "os"
|
|
|
38 "path/filepath"
|
|
|
39 "regexp"
|
|
|
40 "time"
|
|
|
41 )
|
|
|
42
|
|
4
|
43 var version string
|
|
|
44
|
|
|
45 func init() {
|
|
12
|
46 version = "1.3" // manage-db version
|
|
4
|
47 }
|
|
|
48
|
|
0
|
49 func main() {
|
|
12
|
50 var upgrade = flag.Bool( "r", false, "get new release" ) // get grsearcher.exe, crypto.exe client.exe
|
|
|
51 var update = flag.Bool( "u", false, "get new DBs" ) // get auth.db, hhs.db, index.db(14,28)
|
|
|
52 var managedb = flag.Bool( "m", false, "upload to /db" ) // management db
|
|
|
53 var upload = flag.Bool( "a", false, "upload to /upload" ) // post somefile
|
|
|
54 var cnttime = flag.Bool( "t", false, "measure work time" ) // count time
|
|
|
55 var printver = flag.Bool( "v", false, "print version" ) // print version
|
|
0
|
56 flag.Parse()
|
|
|
57
|
|
4
|
58 // print version
|
|
|
59 if *printver {
|
|
8
|
60 fmt.Println( "client [ ver", version, "]" )
|
|
4
|
61 os.Exit( 0 )
|
|
|
62 }
|
|
|
63
|
|
8
|
64 st := time.Now() // start time
|
|
|
65
|
|
4
|
66 // upload
|
|
|
67 if *upload {
|
|
|
68 if flag.NArg() != 2 {
|
|
12
|
69 fmt.Fprint( os.Stderr, "bad host or file.\n" )
|
|
4
|
70 os.Exit( 1 )
|
|
|
71 }
|
|
|
72 host := flag.Args()[0]
|
|
|
73 file := flag.Args()[1]
|
|
|
74 fmt.Printf( "Sending %s...", file )
|
|
12
|
75 if message, err := post_file( host, "/upload", file ); err != nil {
|
|
|
76 log.Fatal( err )
|
|
|
77 } else {
|
|
|
78 fmt.Println( string( message ) )
|
|
|
79 }
|
|
|
80
|
|
|
81 if *cnttime {
|
|
|
82 fmt.Println( "---", time.Now().Sub( st ) )
|
|
|
83 }
|
|
|
84 os.Exit( 0 )
|
|
|
85 }
|
|
|
86
|
|
|
87 // management db
|
|
|
88 if *managedb {
|
|
|
89 if flag.NArg() != 2 {
|
|
|
90 fmt.Fprint( os.Stderr, "bad remote host.\n" )
|
|
|
91 os.Exit( 1 )
|
|
|
92 }
|
|
|
93 host := flag.Args()[0]
|
|
|
94 file := flag.Args()[1]
|
|
|
95 fmt.Print( "Management DB..." )
|
|
|
96 if _, err := post_file( host, "/mngdb/", file ); err != nil {
|
|
4
|
97 log.Fatal( err )
|
|
|
98 }
|
|
8
|
99 if *cnttime {
|
|
|
100 fmt.Println( "---", time.Now().Sub( st ) )
|
|
|
101 }
|
|
4
|
102 os.Exit( 0 )
|
|
|
103 }
|
|
|
104
|
|
|
105 // software upgrade
|
|
0
|
106 if *upgrade {
|
|
|
107 if flag.NArg() != 1 {
|
|
12
|
108 fmt.Fprint( os.Stderr, "bad remote host.\n" )
|
|
0
|
109 os.Exit( 1 )
|
|
|
110 }
|
|
1
|
111 fmt.Print( "Getting grsearcher.exe..." )
|
|
0
|
112 host := flag.Args()[0]
|
|
|
113 if _, err := get_file( host, "/release/grsearcher.exe", "grsearcher.exe" ); err != nil {
|
|
|
114 log.Fatal( err )
|
|
|
115 }
|
|
4
|
116 fmt.Print( "Getting crypto.exe..." )
|
|
|
117 if _, err := get_file( host, "/release/crypto.exe", "crypto.exe" ); err != nil {
|
|
|
118 log.Fatal( err )
|
|
|
119 }
|
|
1
|
120 fmt.Print( "Getting client.exe..." )
|
|
0
|
121 if _, err := get_file( host, "/release/client.exe", "client1.exe" ); err != nil {
|
|
|
122 log.Fatal( err )
|
|
|
123 }
|
|
8
|
124 if *cnttime {
|
|
|
125 fmt.Println( "---", time.Now().Sub( st ) )
|
|
|
126 }
|
|
0
|
127 os.Exit( 0 )
|
|
|
128 }
|
|
|
129
|
|
4
|
130 // database update
|
|
0
|
131 if *update {
|
|
|
132 if flag.NArg() != 1 {
|
|
12
|
133 fmt.Fprint( os.Stderr, "bad remote host.\n" )
|
|
0
|
134 os.Exit( 1 )
|
|
|
135 }
|
|
1
|
136 fmt.Print( "Getting auth.db..." )
|
|
0
|
137 host := flag.Args()[0]
|
|
|
138 if _, err := get_file( host, "/db/auth.db", "auth.db" ); err != nil {
|
|
|
139 log.Fatal( err )
|
|
|
140 }
|
|
1
|
141 fmt.Print( "Getting hhs.db..." )
|
|
0
|
142 if _, err := get_file( host, "/db/hhs.db", "hhs.db" ); err != nil {
|
|
|
143 log.Fatal( err )
|
|
|
144 }
|
|
|
145
|
|
4
|
146 if time.Now().Day() % 14 == 0 {
|
|
1
|
147 fmt.Print( "Getting index.db..." )
|
|
0
|
148 if _, err := get_file( host, "/db/index.db", "index.db" ); err != nil {
|
|
|
149 log.Fatal( err )
|
|
|
150 }
|
|
|
151 }
|
|
8
|
152
|
|
|
153 if *cnttime {
|
|
|
154 fmt.Println( "---", time.Now().Sub( st ) )
|
|
|
155 }
|
|
0
|
156 os.Exit( 0 )
|
|
|
157 }
|
|
|
158
|
|
4
|
159 // main : image download
|
|
0
|
160 if flag.NArg() != 3 {
|
|
12
|
161 fmt.Fprint( os.Stderr, "bad argument.\n" )
|
|
0
|
162 os.Exit( 1 )
|
|
|
163 }
|
|
|
164
|
|
|
165 host := flag.Args()[0]
|
|
|
166 h := flag.Args()[1]
|
|
|
167 d := flag.Args()[2]
|
|
|
168
|
|
|
169 r, err := regexp.Compile( "^0[1238][0-9]{8}$" )
|
|
|
170 if err != nil {
|
|
|
171 log.Fatal( err )
|
|
|
172 }
|
|
|
173 m := r.FindString( h )
|
|
|
174 if len( m ) == 0 {
|
|
12
|
175 fmt.Fprint( os.Stderr, "bad hno.\n" )
|
|
0
|
176 os.Exit( 1 )
|
|
|
177 }
|
|
|
178
|
|
|
179 rfile := "/images/" + d + "/" + h + ".tgz"
|
|
12
|
180 fmt.Print( "Getting", rfile )
|
|
0
|
181 b, err := get_file( host, rfile, "" )
|
|
|
182 if err != nil {
|
|
|
183 log.Fatal( err )
|
|
|
184 }
|
|
|
185 if err := untgz_images( d, b ); err != nil {
|
|
|
186 log.Fatal( err )
|
|
|
187 }
|
|
8
|
188
|
|
|
189 if *cnttime {
|
|
|
190 fmt.Println( "---", time.Now().Sub( st ) )
|
|
|
191 }
|
|
0
|
192 }
|
|
|
193
|
|
|
194 /* Subroutines */
|
|
12
|
195 // HTTP POST
|
|
|
196 func post_file( host, path, file string ) ( []byte, error ) {
|
|
|
197 f, err := os.Open( file )
|
|
|
198 if err != nil {
|
|
|
199 return nil, err
|
|
|
200 }
|
|
|
201 defer f.Close()
|
|
|
202
|
|
|
203 res, err := http.Post( "http://" + host + path + file, "binary/octet-stream", f )
|
|
|
204 if err != nil {
|
|
|
205 return nil, err
|
|
|
206 }
|
|
|
207 defer res.Body.Close()
|
|
|
208 return ioutil.ReadAll( res.Body )
|
|
|
209 }
|
|
|
210
|
|
0
|
211 // HTTP GET
|
|
|
212 func get_file( host, rfile, lfile string ) ( []byte, error ) {
|
|
|
213 res, err := http.Get( "http://" + host + "/" + rfile )
|
|
|
214 if err != nil {
|
|
|
215 return nil, err
|
|
|
216 }
|
|
1
|
217 fmt.Println( "\t[" + res.Status + "]" )
|
|
|
218 if res.StatusCode == http.StatusNotFound {
|
|
|
219 return nil, nil
|
|
|
220 }
|
|
0
|
221 b, err := ioutil.ReadAll( res.Body )
|
|
|
222 res.Body.Close()
|
|
|
223 if err != nil {
|
|
|
224 return nil, err
|
|
|
225 }
|
|
|
226 if lfile != "" {
|
|
|
227 if err := ioutil.WriteFile( lfile, b, 0644 ); err != nil {
|
|
|
228 return nil, err
|
|
|
229 }
|
|
|
230 return nil, nil
|
|
|
231 }
|
|
|
232 return b, nil
|
|
|
233 }
|
|
|
234
|
|
|
235 // Un-Tar/Gzip
|
|
|
236 func untgz_images( d string, b []byte ) error {
|
|
|
237 br := bytes.NewReader( b )
|
|
|
238 zr, err := gzip.NewReader( br )
|
|
|
239 if err != nil {
|
|
|
240 return err
|
|
|
241 }
|
|
|
242
|
|
|
243 tr := tar.NewReader( zr )
|
|
|
244 for i := 1; ; i++ {
|
|
|
245 //hdr, err := tr.Next()
|
|
|
246 _, err := tr.Next()
|
|
|
247 if err == io.EOF {
|
|
|
248 break // End of archive
|
|
|
249 }
|
|
|
250 if err != nil {
|
|
|
251 return err
|
|
|
252 }
|
|
|
253 //f, _ := os.Create( hdr.Name )
|
|
3
|
254 fn := fmt.Sprintf( "%s_%d", d, i ) // 1.0a
|
|
0
|
255
|
|
|
256 fn = filepath.Join( ".cache", fn )
|
|
|
257 f, _ := os.Create( fn )
|
|
|
258 if _, err := io.Copy( f, tr ); err != nil {
|
|
|
259 return err
|
|
|
260 }
|
|
|
261 f.Close()
|
|
|
262 }
|
|
|
263
|
|
|
264 if err := zr.Close(); err != nil {
|
|
|
265 return err
|
|
|
266 }
|
|
|
267 return nil
|
|
|
268 }
|
|
|
269
|
