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
149
150
151
152
153
154
155
156
157
158
159

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"os/exec"
	"strings"
)

const toolsEnvVar = "QR_CODE_TOOLS"

type tools struct {
	qrencode  string
	gtkdialog string
	zbarcam   string
}

func readTools() (tools, error) {
	val, ok := os.LookupEnv(toolsEnvVar)
	if !ok {
		return tools{}, fmt.Errorf("please set %s to a JSON object mapping tool names to paths", toolsEnvVar)
	}
	var m map[string]string
	if err := json.Unmarshal([]byte(val), &m); err != nil {
		return tools{}, fmt.Errorf("cannot parse %s as JSON object: %w", toolsEnvVar, err)
	}
	get := func(name string) (string, error) {
		p, ok := m[name]
		if !ok {
			return "", fmt.Errorf("tool %q not found in %s", name, toolsEnvVar)
		}
		return p, nil
	}
	qrencode, err := get("qrencode")
	if err != nil {
		return tools{}, err
	}
	gtkdialog, err := get("gtkdialog")
	if err != nil {
		return tools{}, err
	}
	zbarcam, err := get("zbarcam")
	if err != nil {
		return tools{}, err
	}
	return tools{qrencode: qrencode, gtkdialog: gtkdialog, zbarcam: zbarcam}, nil
}

func cmdShow(t tools, qrText string) error {
	tmp, err := os.CreateTemp("", "qrencode-*.png")
	if err != nil {
		return fmt.Errorf("cannot create temp file: %w", err)
	}
	tmpPath := tmp.Name()
	tmp.Close()
	defer os.Remove(tmpPath)

	if err := exec.Command(t.qrencode, "-s", "8", "-o", tmpPath, "-t", "PNG", "--", qrText).Run(); err != nil {
		return fmt.Errorf("qrencode failed: %w", err)
	}

	fmt.Fprintf(os.Stderr, "showing file %s\n", tmpPath)

	dialog := fmt.Sprintf("<vbox>\n  <pixmap>\n    <input file>%s</input>\n  </pixmap>\n</vbox>\n", tmpPath)
	cmd := exec.Command(t.gtkdialog, "--stdin")
	cmd.Stdin = strings.NewReader(dialog)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if err := cmd.Run(); err != nil {
		return fmt.Errorf("gtkdialog failed: %w", err)
	}
	return nil
}

func cmdRead(t tools, device string) error {
	out, err := exec.Command(t.zbarcam, "-Sbinary", "--oneshot", "--raw", device).Output()
	if err != nil {
		return fmt.Errorf("zbarcam failed: %w", err)
	}
	fmt.Println(strings.TrimSpace(string(out)))
	return nil
}

func cmdGenerate(t tools, qrText, outputFile string) error {
	if err := exec.Command(t.qrencode, "-s", "8", "-o", outputFile, "-t", "PNG", "--", qrText).Run(); err != nil {
		return fmt.Errorf("qrencode failed: %w", err)
	}
	fmt.Println(outputFile)
	return nil
}

func usage() {
	fmt.Fprintf(os.Stderr, `Usage: qr-code <command> [args]

Commands:
  show <QR_TEXT>                   Show a QR code in a window
  read [--device /dev/video1]      Read a QR code from camera
  generate <QR_TEXT> <OUTPUT_FILE> Generate a QR code PNG file
`)
}

func die(format string, args ...any) {
	fmt.Fprintf(os.Stderr, "qr-code: "+format+"\n", args...)
	os.Exit(1)
}

func main() {
	args := os.Args[1:]
	if len(args) == 0 {
		usage()
		os.Exit(1)
	}

	t, err := readTools()
	if err != nil {
		die("%v", err)
	}

	switch args[0] {
	case "show":
		if len(args) != 2 {
			die("show: expected QR_TEXT argument")
		}
		if err := cmdShow(t, args[1]); err != nil {
			die("show: %v", err)
		}

	case "read":
		device := "/dev/video1"
		rest := args[1:]
		for len(rest) > 0 {
			switch rest[0] {
			case "--device":
				if len(rest) < 2 {
					die("read: --device requires an argument")
				}
				device = rest[1]
				rest = rest[2:]
			default:
				die("read: unknown argument %q", rest[0])
			}
		}
		if err := cmdRead(t, device); err != nil {
			die("read: %v", err)
		}

	case "generate":
		if len(args) != 3 {
			die("generate: expected QR_TEXT and OUTPUT_FILE arguments")
		}
		if err := cmdGenerate(t, args[1], args[2]); err != nil {
			die("generate: %v", err)
		}

	default:
		die("unknown command %q", args[0])
	}
}