Use external utilities for hash calculation

[meta4ra.git] / cmd / meta4-create / main.go

diff --git a/cmd/meta4-create/main.go b/cmd/meta4-create/main.go
index 772714f38044247d38a8907144213839b4e6b43e..b5d9abac4175411f8079f19ecf5cb37754825cae 100644 (file)
--- a/cmd/meta4-create/main.go
+++ b/cmd/meta4-create/main.go
@@ -1,6 +1,6 @@
 /*
 meta4a -- Metalink 4.0 creator
-Copyright (C) 2021-2022 Sergey Matveev <stargrave@stargrave.org>
+Copyright (C) 2021-2023 Sergey Matveev <stargrave@stargrave.org>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -20,58 +20,126 @@ package main
 
 import (
        "bufio"
-       "crypto/sha256"
-       "crypto/sha512"
-       "encoding/hex"
+       "bytes"
        "encoding/xml"
        "flag"
        "io"
        "log"
        "os"
-       "path/filepath"
+       "os/exec"
+       "path"
+       "strings"
+       "sync"
        "time"
 
        "go.stargrave.org/meta4ra"
 )
 
+type Hasher struct {
+       names []string
+       cmds  []*exec.Cmd
+       ins   []io.WriteCloser
+       outs  []io.ReadCloser
+       wg    sync.WaitGroup
+}
+
+func NewHasher(hashes string) *Hasher {
+       h := Hasher{}
+       for _, hc := range strings.Split(hashes, ",") {
+               cols := strings.SplitN(hc, ":", 2)
+               name, cmdline := cols[0], cols[1]
+               cmd := exec.Command(cmdline)
+               in, err := cmd.StdinPipe()
+               if err != nil {
+                       log.Fatalln(err)
+               }
+               out, err := cmd.StdoutPipe()
+               if err != nil {
+                       log.Fatalln(err)
+               }
+               if err = cmd.Start(); err != nil {
+                       log.Fatalln(err)
+               }
+               h.names = append(h.names, name)
+               h.ins = append(h.ins, in)
+               h.outs = append(h.outs, out)
+               h.cmds = append(h.cmds, cmd)
+       }
+       return &h
+}
+
+func (h *Hasher) Write(p []byte) (n int, err error) {
+       h.wg.Add(len(h.names))
+       for _, in := range h.ins {
+               go func(in io.WriteCloser) {
+                       if _, err := io.Copy(in, bytes.NewReader(p)); err != nil {
+                               log.Fatalln(err)
+                       }
+                       h.wg.Done()
+               }(in)
+       }
+       h.wg.Wait()
+       return len(p), nil
+}
+
+func (h *Hasher) Sums() []meta4ra.Hash {
+       sums := make([]meta4ra.Hash, 0, len(h.names))
+       for i, name := range h.names {
+               if err := h.ins[i].Close(); err != nil {
+                       log.Fatalln(err)
+               }
+               dgst, err := io.ReadAll(h.outs[i])
+               if err != nil {
+                       log.Fatalln(err)
+               }
+               sums = append(sums, meta4ra.Hash{Type: name, Hash: string(dgst[:len(dgst)-1])})
+               if err = h.cmds[i].Wait(); err != nil {
+                       log.Fatalln(err)
+               }
+       }
+       return sums
+}
+
 func main() {
-       file := flag.String("file", "", "Path to file")
+       fn := flag.String("fn", "", "Filename")
        mtime := flag.String("mtime", "", "Take that file's mtime as a Published date")
        desc := flag.String("desc", "", "Description")
        sig := flag.String("sig", "", "Path to signature file")
+       hashesDef := []string{
+               "sha-256:sha256",
+               "sha-512:sha512",
+               "shake128:shake128sum",
+               "shake256:shake256sum",
+               "streebog-256:streebog256sum",
+               "streebog-512:streebog512sum",
+               "skein-256:skein256",
+               "skein-512:skein512",
+               "blake3-256:b3sum",
+       }
+       hashes := flag.String("hashes", strings.Join(hashesDef, ","), "hash-name:command-s")
        torrent := flag.String("torrent", "", "Torrent URL")
        log.SetFlags(log.Lshortfile)
        flag.Parse()
+       if *fn == "" {
+               log.Fatalln("empty -fn")
+       }
        urls := make([]meta4ra.URL, 0, len(flag.Args()))
        for _, u := range flag.Args() {
                urls = append(urls, meta4ra.URL{URL: u})
        }
-       fd, err := os.Open(*file)
-       if err != nil {
-               log.Fatalln(err)
-       }
-       fi, err := fd.Stat()
-       if err != nil {
-               log.Fatalln(err)
-       }
-       sha256Hasher := sha256.New()
-       sha512Hasher := sha512.New()
-       _, err = io.Copy(
-               io.MultiWriter(sha256Hasher, sha512Hasher),
-               bufio.NewReader(fd),
-       )
+       h := NewHasher(*hashes)
+       br := bufio.NewReaderSize(os.Stdin, 1<<20)
+       buf := make([]byte, 1<<20)
+       size, err := io.CopyBuffer(h, br, buf)
        if err != nil {
                log.Fatalln(err)
        }
        f := meta4ra.File{
-               Name:        filepath.Base(*file),
+               Name:        path.Base(*fn),
                Description: *desc,
-               Size:        uint64(fi.Size()),
+               Size:        uint64(size),
                URLs:        urls,
-               Hashes: []meta4ra.Hash{
-                       {Type: meta4ra.HashSHA256, Hash: hex.EncodeToString(sha256Hasher.Sum(nil))},
-                       {Type: meta4ra.HashSHA512, Hash: hex.EncodeToString(sha512Hasher.Sum(nil))},
-               },
+               Hashes:      h.Sums(),
        }
        if *sig != "" {
                sigData, err := os.ReadFile(*sig)