// Save persists a Siegfried struct to disk (path) func (s *Siegfried) Save(path string) error { ls := persist.NewLoadSaver(nil) ls.SaveTime(s.C) namematcher.Save(s.nm, ls) mimematcher.Save(s.mm, ls) containermatcher.Save(s.cm, ls) xmlmatcher.Save(s.xm, ls) riffmatcher.Save(s.rm, ls) bytematcher.Save(s.bm, ls) textmatcher.Save(s.tm, ls) ls.SaveTinyUInt(len(s.ids)) for _, i := range s.ids { i.Save(ls) } if ls.Err != nil { return ls.Err } f, err := os.Create(path) if err != nil { return err } defer f.Close() _, err = f.Write(append(config.Magic(), byte(config.Version()[0]), byte(config.Version()[1]))) if err != nil { return err } z, err := flate.NewWriter(f, 1) if err != nil { return err } _, err = z.Write(ls.Bytes()) z.Close() return err }
// YAML representation of a Siegfried struct. // This is the provenace block at the beginning of sf results and includes descriptions for each identifier. func (s *Siegfried) YAML() string { version := config.Version() str := fmt.Sprintf( "---\nsiegfried : %d.%d.%d\nscandate : %v\nsignature : %s\ncreated : %v\nidentifiers : \n", version[0], version[1], version[2], time.Now().Format(time.RFC3339), s.path, s.C.Format(time.RFC3339)) for _, id := range s.ids { str += fmt.Sprintf(" - name : '%v'\n details : '%v'\n", id.Name(), id.Details()) } return str }
func updateSigs() (string, error) { url, _, _ := config.UpdateOptions() if url == "" { return "Update is not available for this distribution of siegfried", nil } response, err := getHttp(url) if err != nil { return "", err } var u Update if err := json.Unmarshal(response, &u); err != nil { return "", err } version := config.Version() if version[0] < u.Version[0] || (version[0] == u.Version[0] && version[1] < u.Version[1]) || // if the version is out of date u.Version == [3]int{0, 0, 0} || u.Created == "" || u.Size == 0 || u.Path == "" { // or if the unmarshalling hasn't worked and we have blank values return "Your version of siegfried is out of date; please install latest from http://www.itforarchivists.com/siegfried before continuing.", nil } s, err := siegfried.Load(config.Signature()) if err == nil { if !s.Update(u.Created) { return "You are already up to date!", nil } } else { // this hairy bit of golang exception handling is thanks to Ross! :) if _, err = os.Stat(config.Home()); err != nil { if os.IsNotExist(err) { err = os.MkdirAll(config.Home(), os.ModePerm) if err != nil { return "", fmt.Errorf("Siegfried: cannot create home directory %s, %v", config.Home(), err) } } else { return "", fmt.Errorf("Siegfried: error opening directory %s, %v", config.Home(), err) } } } fmt.Println("... downloading latest signature file ...") response, err = getHttp(u.Path) if err != nil { return "", fmt.Errorf("Siegfried: error retrieving %s.\nThis may be a network or firewall issue. See https://github.com/richardlehane/siegfried/wiki/Getting-started for manual instructions.\nSystem error: %v", config.SignatureBase(), err) } if len(response) != u.Size { return "", fmt.Errorf("Siegfried: error retrieving %s; expecting %d bytes, got %d bytes", config.SignatureBase(), u.Size, len(response)) } err = ioutil.WriteFile(config.Signature(), response, os.ModePerm) if err != nil { return "", fmt.Errorf("Siegfried: error writing to directory, %v", err) } fmt.Printf("... writing %s ...\n", config.Signature()) return "Your signature file has been updated", nil }
// JSON representation of a Siegfried struct. // This is the provenace block at the beginning of sf results and includes descriptions for each identifier. func (s *Siegfried) JSON() string { version := config.Version() str := fmt.Sprintf( "{\"siegfried\":\"%d.%d.%d\",\"scandate\":\"%v\",\"signature\":\"%s\",\"created\":\"%v\",\"identifiers\":[", version[0], version[1], version[2], time.Now().Format(time.RFC3339), s.path, s.C.Format(time.RFC3339)) for i, id := range s.ids { if i > 0 { str += "," } str += fmt.Sprintf("{\"name\":\"%s\",\"details\":\"%s\"}", id.Name(), id.Details()) } str += "]," return str }
func main() { flag.Parse() /*//UNCOMMENT TO RUN PROFILER go func() { log.Println(http.ListenAndServe("localhost:6060", nil)) }()*/ // configure home and signature if not default if *home != config.Home() { config.SetHome(*home) } if *sig != config.SignatureBase() { config.SetSignature(*sig) } // handle -update if *update { msg, err := updateSigs() if err != nil { log.Fatalf("[FATAL] failed to update signature file, %v", err) } fmt.Println(msg) return } // handle -hash error hashT := getHash(*hashf) if *hashf != "" && hashT < 0 { log.Fatalf("[FATAL] invalid hash type; choose from %s", hashChoices) } // load and handle signature errors s, err := siegfried.Load(config.Signature()) if err != nil { log.Fatalf("[FATAL] error loading signature file, got: %v", err) } // handle -version if *version { version := config.Version() fmt.Printf("siegfried %d.%d.%d\n%s", version[0], version[1], version[2], s) return } // handle -fpr if *fprflag { log.Printf("FPR server started at %s. Use CTRL-C to quit.\n", config.Fpr()) serveFpr(config.Fpr(), s) return } // check -multi if *multi > maxMulti || *multi < 1 || (*archive && *multi > 1) { log.Println("[WARN] -multi must be > 0 and =< 1024. If -z, -multi must be 1. Resetting -multi to 1") *multi = 1 } // start logger lg, err := newLogger(*logf) if err != nil { log.Fatalln(err) } if config.Slow() || config.Debug() { if *serve != "" || *fprflag { log.Fatalln("[FATAL] debug and slow logging cannot be run in server mode") } } // start throttle if *throttlef != 0 { throttle = time.NewTicker(*throttlef) defer throttle.Stop() } // start the printer lenCtxts := *multi if lenCtxts == 1 { lenCtxts = 8 } ctxts := make(chan *context, lenCtxts) go printer(ctxts, lg) // set default writer var w writer switch { case *csvo: w = newCSV(os.Stdout) case *jsono: w = newJSON(os.Stdout) case *droido: w = newDroid(os.Stdout) if len(s.Fields()) != 1 || len(s.Fields()[0]) != 7 { close(ctxts) log.Fatalln("[FATAL] DROID output is limited to signature files with a single PRONOM identifier") } default: w = newYAML(os.Stdout) } // overrite writer with nil writer if logging is to stdout if lg != nil && lg.w == os.Stdout { w = logWriter{} } // setup default waitgroup wg := &sync.WaitGroup{} // setup context pool setCtxPool(s, w, wg, hashT, *archive) // handle -serve if *serve != "" { log.Printf("Starting server at %s. Use CTRL-C to quit.\n", *serve) listen(*serve, s, ctxts) return } // handle no file/directory argument if flag.NArg() != 1 { close(ctxts) log.Fatalln("[FATAL] expecting a single file or directory argument") } w.writeHead(s, hashT) // support reading list files from stdin if flag.Arg(0) == "-" { scanner := bufio.NewScanner(os.Stdin) for scanner.Scan() { info, err := os.Stat(scanner.Text()) if err != nil { info, err = retryStat(scanner.Text(), err) } if err != nil || info.IsDir() { ctx := getCtx(scanner.Text(), "", "", 0) ctx.res <- results{fmt.Errorf("failed to identify %s (in scanning mode, inputs must all be files and not directories), got: %v", scanner.Text(), err), nil, nil} ctx.wg.Add(1) ctxts <- ctx } else { identifyFile(getCtx(scanner.Text(), "", info.ModTime().Format(time.RFC3339), info.Size()), ctxts, getCtx) } } } else { err = identify(ctxts, flag.Arg(0), "", *nr, getCtx) } wg.Wait() close(ctxts) w.writeTail() // log time elapsed if !lg.start.IsZero() { fmt.Fprintf(lg.w, "%s %v\n", timeString, time.Since(lg.start)) } if err != nil { log.Fatal(err) } os.Exit(0) }
// Load creates a Siegfried struct and loads content from path func Load(path string) (*Siegfried, error) { errOpening := "siegfried: error opening signature file, got %v; try running `sf -update`" errNotSig := "siegfried: not a siegfried signature file; try running `sf -update`" errUpdateSig := "siegfried: signature file is incompatible with this version of sf; try running `sf -update`" fbuf, err := ioutil.ReadFile(path) if err != nil { return nil, fmt.Errorf(errOpening, err) } if len(fbuf) < len(config.Magic())+2 { return nil, fmt.Errorf(errNotSig) } if string(fbuf[:len(config.Magic())]) != string(config.Magic()) { return nil, fmt.Errorf(errNotSig) } if major, minor := fbuf[len(config.Magic())], fbuf[len(config.Magic())+1]; major < byte(config.Version()[0]) || (major == byte(config.Version()[0]) && minor < byte(config.Version()[1])) { return nil, fmt.Errorf(errUpdateSig) } r := bytes.NewBuffer(fbuf[len(config.Magic())+2:]) rc := flate.NewReader(r) defer rc.Close() buf, err := ioutil.ReadAll(rc) if err != nil { return nil, fmt.Errorf(errOpening, err) } ls := persist.NewLoadSaver(buf) return &Siegfried{ path: filepath.Base(path), C: ls.LoadTime(), nm: namematcher.Load(ls), mm: mimematcher.Load(ls), cm: containermatcher.Load(ls), xm: xmlmatcher.Load(ls), rm: riffmatcher.Load(ls), bm: bytematcher.Load(ls), tm: textmatcher.Load(ls), ids: func() []core.Identifier { ids := make([]core.Identifier, ls.LoadTinyUInt()) for i := range ids { ids[i] = core.LoadIdentifier(ls) } return ids }(), buffers: siegreader.New(), }, ls.Err }