|
16
|
1 /*
|
|
24
|
2 UT : Unix like utility Tool.
|
|
16
|
3
|
|
|
4 TODO:
|
|
|
5 password
|
|
|
6 delete file on server
|
|
|
7 */
|
|
|
8 package main
|
|
|
9
|
|
|
10 import (
|
|
|
11 "bufio"
|
|
|
12 "bytes"
|
|
|
13 "flag"
|
|
|
14 "fmt"
|
|
|
15 "io"
|
|
|
16 "io/ioutil"
|
|
|
17 "log"
|
|
|
18 "mime/multipart"
|
|
|
19 "net/http"
|
|
|
20 "os"
|
|
|
21 "runtime"
|
|
|
22 "strconv"
|
|
|
23 "strings"
|
|
|
24 "time"
|
|
|
25
|
|
|
26 "./lu"
|
|
20
|
27 "./nw"
|
|
16
|
28 )
|
|
|
29
|
|
21
|
30 var version = "1.06"
|
|
16
|
31
|
|
|
32 func main() {
|
|
|
33
|
|
|
34 var getfile = flag.Bool( "g", false, "get a file from site." ) // ok
|
|
|
35 var putfile = flag.Bool( "G", false, "put a file to site." ) // ok
|
|
17
|
36 var compress = flag.Bool( "z", false, "compress files. (.tgz)" ) // ok
|
|
16
|
37 var uncmprss = flag.Bool( "x", false, "uncompress files. (.tgz )" ) // ok
|
|
|
38 var noprefix = flag.Bool( "n", false, "not add prefix(YYYYMMDDhhmm_) to filename." ) // ok
|
|
|
39
|
|
|
40 var wget = flag.Bool( "w", false, "little wget tool." ) // ok
|
|
|
41 var wc_l = flag.Bool( "l", false, "little wc -l tool." ) // ok
|
|
|
42 var catn = flag.Bool( "C", false, "little cat -n tool." ) // ok
|
|
20
|
43 var reverse = flag.Bool( "R", false, "little tac tool. ( reverse file )" ) // ok
|
|
16
|
44 var uniq = flag.Bool( "u", false, "little uniq tool." ) // ok
|
|
|
45 var uniqc = flag.Bool( "uc", false, "little uniq tool.( count )" ) // ok
|
|
|
46 var uniqd = flag.Bool( "ud", false, "little uniq tool.( only dup )" ) // ok
|
|
|
47 var uniqdc = flag.Bool( "udc", false, "little uniq tool.( count dup )" ) // ok
|
|
|
48 var md5 = flag.Bool( "md5", false, "md5." ) // ok
|
|
|
49 var sha256 = flag.Bool( "sha256", false, "sha256." ) // ok
|
|
18
|
50 var grep = flag.String( "a", "", "little grep tool." ) // ok
|
|
|
51 var grepv = flag.String( "b", "", "little grep -v tool." ) // ok
|
|
|
52 var orgrep = flag.String( "A", "", "little grep tool. ( from list file )" ) // ok
|
|
|
53 var orgrepv = flag.String( "B", "", "little grep -v tool. ( from list file )" ) // ok
|
|
19
|
54 var tee = flag.String( "e", "", "little tee tool." ) // ok
|
|
21
|
55 var replace = flag.Bool( "r", false, "replace strings. ( s/arg1/arg2/g )" ) // ok
|
|
20
|
56 var nc = flag.Bool( "nc", false, "netcat." ) // ok
|
|
|
57 var ncl = flag.Bool( "ncl", false, "netcat listen-mode." ) // ok
|
|
26
|
58 var fserver = flag.Int( "fs", 0, "file server." ) // ok
|
|
|
59 var wserver = flag.Int( "ws", 0, "web server." ) // ok
|
|
16
|
60
|
|
|
61 var msleep = flag.Bool( "M", false, "sleep." )
|
|
|
62 //var swatch = flag.Bool( "W", false, "stop watch." )
|
|
|
63 //var bccalc = flag.Bool( "j", false, "calculator." )
|
|
|
64 //var bhole = flag.Bool( "k", false, "black hole. ( /dev/null )" )
|
|
|
65 var cmdtime = flag.Bool( "T", false, "measure program running time." )
|
|
|
66 var touch = flag.Bool( "t", false, "little touch tool." )
|
|
|
67 var sort = flag.Bool( "s", false, "little sort tool." )
|
|
|
68 var nsort = flag.Bool( "ns", false, "little number sort tool." )
|
|
|
69 var tree = flag.Bool( "f", false, "little tree tool." )
|
|
|
70 var head = flag.Int( "d", 0, "little head/tail tool.( head:n, tail:-n )" )
|
|
|
71 //var cut = flag.String( "c", "", "little cut tool ( only csv )." )
|
|
|
72 var migemo = flag.Bool( "m", false, "migemo tool." )
|
|
|
73 //var split = flag.Int( "s", 100, "split file ( default 100 MB )." )
|
|
|
74 var ipscan = flag.Bool( "p", false, "ping." )
|
|
26
|
75 var ptscan = flag.Int( "P", 0, "port scan." )
|
|
16
|
76 var minfo = flag.Bool( "i", false, "print machine infomation." ) // half-ok
|
|
|
77
|
|
|
78 //var imgsz = flag.String( "is", "", "resize image" )
|
|
|
79 //var imgconv = flag.String( "ic", "", "convert image type" )
|
|
|
80
|
|
|
81 var pversion = flag.Bool( "v", false, "print version." ) // ok
|
|
|
82 var help = flag.Bool( "h", false, "help." ) // ok
|
|
|
83 flag.Parse()
|
|
|
84
|
|
|
85 if *pversion {
|
|
|
86 fmt.Fprintf( os.Stderr, "%s [ ver %s ]\n", os.Args[0], version )
|
|
|
87 os.Exit( 0 )
|
|
|
88 }
|
|
|
89
|
|
|
90 if *help {
|
|
|
91 print_help()
|
|
|
92 os.Exit( 0 )
|
|
|
93 }
|
|
|
94
|
|
|
95 if *minfo {
|
|
|
96 // IP, mask, gw, dns
|
|
|
97 host, _ := os.Hostname()
|
|
|
98 fmt.Fprintf( os.Stderr, "OS = %s\n", runtime.GOOS )
|
|
|
99 fmt.Fprintf( os.Stderr, "ARCH = %s\n", runtime.GOARCH )
|
|
|
100 fmt.Fprintf( os.Stderr, "HOSTNAME = %s", host )
|
|
20
|
101 fmt.Fprintf( os.Stderr, " [%s]\n", nw.GetLocalIP() )
|
|
16
|
102 os.Exit( 0 )
|
|
|
103 }
|
|
|
104
|
|
23
|
105 /* Here Servers */
|
|
|
106 if *fserver != 0 {
|
|
|
107 addr := nw.GetLocalIP() + ":" + fmt.Sprintf( "%d", *fserver )
|
|
|
108 log.Fatal( http.ListenAndServe( addr, http.FileServer( http.Dir( ".") ) ) )
|
|
|
109 }
|
|
|
110
|
|
|
111 if *wserver != 0 {
|
|
|
112 addr := nw.GetLocalIP() + ":" + fmt.Sprintf( "%d", *wserver )
|
|
|
113 http.HandleFunc( "/", func( w http.ResponseWriter, r *http.Request ) {
|
|
|
114 if flag.NArg() == 0 {
|
|
|
115 fmt.Fprintf( w, "WebServer\n" )
|
|
|
116 return
|
|
|
117 }
|
|
|
118 file := flag.Args()[0]
|
|
|
119 f, err := os.Open( file )
|
|
|
120 if err != nil {
|
|
|
121 fmt.Fprintf( w, "WebServer\n" )
|
|
|
122 }
|
|
|
123 if _, err = io.Copy( w, f ); err != nil {
|
|
|
124 log.Fatal( err )
|
|
|
125 }
|
|
|
126 f.Close()
|
|
|
127 } )
|
|
|
128 log.Fatal( http.ListenAndServe( addr, nil ) )
|
|
|
129 }
|
|
|
130
|
|
16
|
131 /* Here Utility Function ( unix tool like tools ) */
|
|
|
132 if *msleep {
|
|
|
133 fmt.Fprintln( os.Stderr, "not implement" )
|
|
|
134 os.Exit( 3 )
|
|
|
135 }
|
|
|
136
|
|
|
137 if *cmdtime {
|
|
|
138 fmt.Fprintln( os.Stderr, "not implement" )
|
|
|
139 os.Exit( 3 )
|
|
|
140 }
|
|
|
141
|
|
|
142 if *wget { // done.
|
|
|
143 if flag.NArg() == 0 {
|
|
|
144 fmt.Fprintln( os.Stderr, "no url" )
|
|
|
145 os.Exit( 1 )
|
|
|
146 }
|
|
|
147 url := flag.Args()[0]
|
|
|
148 if !strings.Contains( url, "://" ) {
|
|
|
149 url = "http://" + url
|
|
|
150 }
|
|
|
151
|
|
|
152 fmt.Printf( "%s", url_get( url ) )
|
|
|
153 os.Exit( 0 )
|
|
|
154 }
|
|
|
155
|
|
|
156 /*
|
|
|
157 if *cut {
|
|
|
158 fmt.Fprintln( os.Stderr, "not implement" )
|
|
|
159 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
160 log.Fatal( err )
|
|
|
161 }
|
|
|
162 lu.CutCsv( flag.Args() )
|
|
|
163 os.Exit( 3 )
|
|
|
164 }
|
|
|
165 */
|
|
|
166
|
|
19
|
167 if *tee != "" { // done.
|
|
|
168 lu.Tee( *tee )
|
|
|
169 os.Exit( 0 )
|
|
17
|
170 }
|
|
|
171
|
|
16
|
172 if *sort {
|
|
|
173 fmt.Fprintln( os.Stderr, "not implement" )
|
|
|
174 os.Exit( 3 )
|
|
|
175 }
|
|
|
176
|
|
|
177 if *nsort {
|
|
|
178 fmt.Fprintln( os.Stderr, "not implement" )
|
|
|
179 os.Exit( 3 )
|
|
|
180 }
|
|
|
181
|
|
|
182 if *tree {
|
|
|
183 fmt.Fprintln( os.Stderr, "not implement" )
|
|
|
184 os.Exit( 3 )
|
|
|
185 }
|
|
|
186
|
|
|
187 if *catn { // done.
|
|
|
188 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
189 log.Fatal( err )
|
|
|
190 }
|
|
|
191 lu.Cat_n( flag.Args() )
|
|
|
192 os.Exit( 0 )
|
|
|
193 }
|
|
|
194
|
|
|
195 if *wc_l { // done.
|
|
|
196 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
197 log.Fatal( err )
|
|
|
198 }
|
|
|
199 lu.Wc_l( flag.Args() )
|
|
|
200 os.Exit( 0 )
|
|
|
201 }
|
|
|
202
|
|
|
203 if *uniq || *uniqc || *uniqd || *uniqdc { // done.
|
|
|
204 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
205 log.Fatal( err )
|
|
|
206 }
|
|
|
207 if *uniqdc {
|
|
|
208 *uniqc, *uniqd = true, true
|
|
|
209 }
|
|
|
210 lu.Uniq( *uniqc, *uniqd, flag.Args() )
|
|
|
211 os.Exit( 0 )
|
|
|
212 }
|
|
|
213
|
|
|
214 if *head != 0 {
|
|
|
215 fmt.Fprintln( os.Stderr, "not implement" )
|
|
|
216 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
217 log.Fatal( err )
|
|
|
218 }
|
|
|
219 lu.Head( *head, flag.Args() )
|
|
|
220 os.Exit( 0 )
|
|
|
221 }
|
|
|
222
|
|
|
223 if *reverse { // done.
|
|
|
224 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
225 log.Fatal( err )
|
|
|
226 }
|
|
|
227 lu.Reverse( flag.Args() )
|
|
|
228 os.Exit( 0 )
|
|
|
229 }
|
|
|
230
|
|
18
|
231 if *grep != "" { // done.
|
|
|
232 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
233 log.Fatal( err )
|
|
16
|
234 }
|
|
18
|
235 lu.Grep( *grep, false, flag.Args() )
|
|
|
236 os.Exit( 0 )
|
|
|
237 }
|
|
|
238
|
|
|
239 if *grepv != "" { // done.
|
|
|
240 if err := is_exist_files( flag.Args() ); err != nil {
|
|
16
|
241 log.Fatal( err )
|
|
|
242 }
|
|
18
|
243 lu.Grep( *grepv, true, flag.Args() )
|
|
|
244 os.Exit( 0 )
|
|
|
245 }
|
|
|
246
|
|
|
247 if *orgrep != "" {
|
|
|
248 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
249 log.Fatal( err )
|
|
|
250 }
|
|
|
251 lu.OrGrep( *orgrep, false, flag.Args() )
|
|
|
252 os.Exit( 0 )
|
|
|
253 }
|
|
|
254
|
|
|
255 if *orgrepv != "" {
|
|
|
256 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
257 log.Fatal( err )
|
|
|
258 }
|
|
|
259 lu.OrGrep( *orgrepv, true, flag.Args() )
|
|
16
|
260 os.Exit( 0 )
|
|
|
261 }
|
|
|
262
|
|
|
263 if *migemo {
|
|
|
264 fmt.Fprintln( os.Stderr, "not implement" )
|
|
|
265 os.Exit( 3 )
|
|
|
266 }
|
|
|
267
|
|
21
|
268 if *replace { // done.
|
|
|
269 if flag.NArg() < 2 {
|
|
|
270 fmt.Fprintf( os.Stderr, "too few argument.\n" )
|
|
|
271 os.Exit( 1 )
|
|
|
272 }
|
|
16
|
273 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
274 log.Fatal( err )
|
|
|
275 }
|
|
21
|
276 lu.Replace( flag.Args()[0], flag.Args()[1], flag.Args()[2:] )
|
|
16
|
277 os.Exit( 0 )
|
|
|
278 }
|
|
|
279
|
|
|
280 if *touch {
|
|
|
281 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
282 log.Fatal( err )
|
|
|
283 }
|
|
|
284 lu.Touch( flag.Args() )
|
|
|
285 os.Exit( 0 )
|
|
|
286 }
|
|
|
287
|
|
|
288 if *md5 { // done.
|
|
|
289 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
290 log.Fatal( err )
|
|
|
291 }
|
|
|
292 lu.Md5( flag.Args() )
|
|
|
293 os.Exit( 0 )
|
|
|
294 }
|
|
|
295
|
|
|
296 if *sha256 { // done.
|
|
|
297 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
298 log.Fatal( err )
|
|
|
299 }
|
|
|
300 lu.Sha256( flag.Args() )
|
|
|
301 os.Exit( 0 )
|
|
|
302 }
|
|
|
303
|
|
20
|
304 if *nc { // done.
|
|
|
305 if flag.NArg() != 2 {
|
|
|
306 fmt.Fprintf( os.Stderr, "$ ut -nc 192.168.0.55 8080\n" )
|
|
|
307 os.Exit( 1 )
|
|
|
308 }
|
|
|
309 nw.Netcat( flag.Args()[0], flag.Args()[1] )
|
|
|
310 os.Exit( 0 )
|
|
|
311 }
|
|
|
312
|
|
|
313 if *ncl { // done.
|
|
|
314 if flag.NArg() == 0 {
|
|
|
315 fmt.Fprintf( os.Stderr, "$ ut -ncl 8080\n" )
|
|
|
316 os.Exit( 1 )
|
|
|
317 }
|
|
|
318 nw.Netcat_l( flag.Args()[0] )
|
|
|
319 os.Exit( 0 )
|
|
|
320 }
|
|
|
321
|
|
16
|
322 if *ipscan {
|
|
|
323 fmt.Fprintln( os.Stderr, "not implement" )
|
|
|
324 os.Exit( 2 )
|
|
|
325 }
|
|
|
326
|
|
26
|
327 if *ptscan != 0 {
|
|
|
328 fmt.Fprintln( os.Stderr, "not implement" )
|
|
|
329 fmt.Fprintln( os.Stderr, "$ ut -P 1 192.168.0.101 3000 # vanilla scan\n" )
|
|
|
330 fmt.Fprintln( os.Stderr, "$ ut -P 2 192.168.0.101 3000 # syn scan\n" )
|
|
|
331 fmt.Fprintln( os.Stderr, "$ ut -P 3 192.168.0.101 3000 # fin scan\n" )
|
|
|
332 fmt.Fprintln( os.Stderr, "$ ut -P 4 192.168.0.101 3000 # Xmas scan\n" )
|
|
|
333 fmt.Fprintln( os.Stderr, "$ ut -P 9 192.168.0.101 3000 # null scan\n" )
|
|
|
334 os.Exit( 2 )
|
|
|
335 }
|
|
|
336
|
|
17
|
337 if *compress && !*putfile { // done.
|
|
|
338 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
339 log.Fatal( err )
|
|
|
340 }
|
|
|
341 tgz := time.Now().Format( "200601021504.tgz" )
|
|
|
342 lu.Tgz( tgz, flag.Args() )
|
|
|
343 os.Exit( 0 )
|
|
|
344 }
|
|
|
345
|
|
16
|
346 if *uncmprss { // done.
|
|
|
347 if err := is_exist_files( flag.Args() ); err != nil {
|
|
|
348 log.Fatal( err )
|
|
|
349 }
|
|
|
350 lu.UnTgz( flag.Args() )
|
|
|
351 os.Exit( 0 )
|
|
|
352 }
|
|
|
353
|
|
|
354 /* Here My Uplaad / Download Function */
|
|
|
355 host := "http://777.nazo.cc"
|
|
17
|
356
|
|
16
|
357 if *putfile {
|
|
|
358 if flag.NArg() > 0 {
|
|
|
359
|
|
|
360 // アップロードには，このプログラムで認証が必要:未実装
|
|
|
361 if !is_valid_user() {
|
|
|
362 fmt.Println( "wrong password." )
|
|
|
363 os.Exit( 0 )
|
|
|
364 }
|
|
|
365
|
|
|
366 for _, file := range flag.Args() {
|
|
|
367 if _, err := os.Stat( file ); os.IsNotExist( err ) {
|
|
|
368 fmt.Fprintf( os.Stderr, "%s: not exist\n", file )
|
|
|
369 }
|
|
|
370 }
|
|
|
371
|
|
|
372 url := host + "/uploader/index.cgi/goup/post"
|
|
|
373 //url = "http://localhost:3000/gofile"
|
|
|
374
|
|
|
375 var prefix string
|
|
|
376 if !*noprefix {
|
|
|
377 prefix = time.Now().Format( "200601021504_" )
|
|
|
378 }
|
|
|
379
|
|
|
380 // 圧縮
|
|
17
|
381 if *compress {
|
|
16
|
382 tmpfile, err := ioutil.TempFile( ".", "muxx" )
|
|
|
383 if err != nil {
|
|
|
384 log.Fatal( err )
|
|
|
385 }
|
|
|
386
|
|
|
387 tgz := prefix + tmpfile.Name() + ".tgz"
|
|
|
388 os.Rename( tmpfile.Name(), tgz )
|
|
17
|
389 defer os.Remove( tgz )
|
|
|
390 lu.Tgz( tgz, flag.Args() )
|
|
16
|
391 fmt.Printf( "archive & compress ...done [%s].\n", tgz )
|
|
|
392
|
|
17
|
393 if err := post_file( url, tgz ); err != nil {
|
|
|
394 log.Fatal( err )
|
|
16
|
395 }
|
|
17
|
396 fmt.Println( "upload ...done." )
|
|
|
397 // 非圧縮
|
|
16
|
398 } else {
|
|
|
399 for _, file := range flag.Args() {
|
|
|
400 if !*noprefix {
|
|
|
401 c, err := ioutil.ReadFile( file )
|
|
|
402 if err != nil {
|
|
|
403 log.Fatal( err )
|
|
|
404 }
|
|
|
405 if err := ioutil.WriteFile( prefix + file, c, 0644 ); err != nil {
|
|
|
406 log.Fatal( err )
|
|
|
407 }
|
|
|
408 }
|
|
|
409 if err := post_file( url, prefix + file ); err != nil {
|
|
|
410 log.Fatal( err )
|
|
|
411 }
|
|
|
412 fmt.Println( file + "\tupload ...done." )
|
|
|
413 }
|
|
|
414 }
|
|
|
415 }
|
|
17
|
416 os.Exit( 0 )
|
|
16
|
417 }
|
|
|
418
|
|
|
419 // ファイル一覧を取得
|
|
|
420 if *getfile {
|
|
|
421 url := host + "/uploader/index.cgi/goup/"
|
|
|
422 list := url_get( url )
|
|
|
423 files := strings.Split( string( list ), "\n" )
|
|
|
424
|
|
|
425 var filename [100]string
|
|
|
426 for i, file := range files {
|
|
|
427 info := strings.Split( file, "#" )
|
|
|
428 fmt.Printf( "[%3d] %-28s %10s %s\n", i + 1, info[0], info[1], info[2] )
|
|
|
429 filename[i] = info[0]
|
|
|
430 }
|
|
|
431
|
|
|
432 fmt.Print( "> " )
|
|
|
433 scanner := bufio.NewScanner( os.Stdin )
|
|
|
434 scanner.Scan()
|
|
|
435 input := scanner.Text()
|
|
|
436
|
|
|
437 if strings.Compare( input, "q" ) == 0 || strings.Compare( input, "bye" ) == 0 {
|
|
|
438 fmt.Println( "bye." )
|
|
|
439 os.Exit( 0 )
|
|
|
440 }
|
|
|
441
|
|
|
442 no, err := strconv.Atoi( input )
|
|
|
443 if err != nil || no < 1 || no > len( files ) {
|
|
|
444 fmt.Fprint( os.Stderr, "bad input\n" )
|
|
|
445 os.Exit( 0 )
|
|
|
446 }
|
|
|
447
|
|
|
448 url = host + "/uploader/files/goup/" + filename[ no - 1 ]
|
|
|
449 fmt.Printf( "downloading %s...\n", filename[ no - 1 ] )
|
|
|
450 bytes := url_get( url )
|
|
|
451 if err := ioutil.WriteFile( filename[ no - 1 ], bytes, 0644 ); err != nil {
|
|
|
452 log.Fatal( err )
|
|
|
453 }
|
|
|
454 os.Exit( 0 )
|
|
|
455 }
|
|
|
456
|
|
|
457 print_help()
|
|
|
458 }
|
|
|
459
|
|
|
460 // Subroutines
|
|
|
461 func url_get( url string ) []byte {
|
|
|
462 res, err := http.Get( url )
|
|
|
463 if err != nil {
|
|
|
464 log.Fatal( err )
|
|
|
465 }
|
|
|
466 b, err := ioutil.ReadAll( res.Body )
|
|
|
467 res.Body.Close()
|
|
|
468 if err != nil {
|
|
|
469 log.Fatal( err )
|
|
|
470 }
|
|
|
471 return b
|
|
|
472 }
|
|
|
473
|
|
|
474 func post_file( url, file string ) error {
|
|
|
475
|
|
|
476 f, err := os.Open( file )
|
|
|
477 if err != nil {
|
|
|
478 return err
|
|
|
479 }
|
|
|
480 defer f.Close()
|
|
|
481
|
|
|
482 buf := &bytes.Buffer{}
|
|
|
483 writer := multipart.NewWriter( buf )
|
|
|
484 fw, err := writer.CreateFormFile( "filename", file )
|
|
|
485 if err != nil {
|
|
|
486 return err
|
|
|
487 }
|
|
|
488
|
|
|
489 if _, err = io.Copy( fw, f ); err != nil {
|
|
|
490 return err
|
|
|
491 }
|
|
|
492
|
|
|
493 ct := writer.FormDataContentType()
|
|
|
494 writer.Close()
|
|
|
495
|
|
|
496 resp, err := http.Post( url, ct, buf )
|
|
|
497 if err != nil {
|
|
|
498 fmt.Fprintf( os.Stderr, "%s", resp.Status )
|
|
|
499 return err
|
|
|
500 }
|
|
|
501
|
|
|
502 return nil
|
|
|
503 }
|
|
|
504
|
|
|
505 func is_valid_user() bool {
|
|
|
506 return true
|
|
|
507 return false
|
|
|
508 }
|
|
|
509
|
|
|
510 func is_exist_files( files []string ) error {
|
|
|
511 for _, file := range files {
|
|
|
512 if _, err := os.Stat( file ); os.IsNotExist( err ) {
|
|
|
513 return fmt.Errorf( "%s: not exist\n", file )
|
|
|
514 }
|
|
|
515 }
|
|
|
516 return nil
|
|
|
517 }
|
|
|
518
|
|
|
519 func print_help() {
|
|
|
520 fmt.Fprintf( os.Stderr, "Usage of %s [%s]:\n", os.Args[0], version )
|
|
|
521 flag.PrintDefaults()
|
|
|
522 }
|
|
17
|
523
|
