package completer import ( "bufio" "errors" "fmt" "io" "mime" "net/mail" "os/exec" "regexp" "strings" "syscall" "git.sr.ht/~rjarry/aerc/log" "github.com/google/shlex" ) // A Completer is used to autocomplete text inputs based on the configured // completion commands. type Completer struct { // AddressBookCmd is the command to run for completing email addresses. This // command must output one completion on each line with fields separated by a // tab character. The first field must be the address, and the second field, // if present, the contact name. Only the email address field is required. // The name field is optional. Additional fields are ignored. AddressBookCmd string errHandler func(error) } // A CompleteFunc accepts a string to be completed and returns a slice of // completions candidates with a prefix to prepend to the chosen candidate type CompleteFunc func(string) ([]string, string) // New creates a new Completer with the specified address book command. func New(addressBookCmd string, errHandler func(error)) *Completer { return &Completer{ AddressBookCmd: addressBookCmd, errHandler: errHandler, } } // ForHeader returns a CompleteFunc appropriate for the specified mail header. In // the case of To, From, etc., the completer will get completions from the // configured address book command. For other headers, a noop completer will be // returned. If errors arise during completion, the errHandler will be called. func (c *Completer) ForHeader(h string) CompleteFunc { if isAddressHeader(h) { if c.AddressBookCmd == "" { return nil } // wrap completeAddress in an error handler return func(s string) ([]string, string) { completions, prefix, err := c.completeAddress(s) if err != nil { c.handleErr(err) return []string{}, "" } return completions, prefix } } return nil } // isAddressHeader determines whether the address completer should be used for // header h. func isAddressHeader(h string) bool { switch strings.ToLower(h) { case "to", "from", "cc", "bcc": return true } return false } const maxCompletionLines = 100 var tooManyLines = fmt.Errorf("returned more than %d lines", maxCompletionLines) // completeAddress uses the configured address book completion command to fetch // completions for the specified string, returning a slice of completions and // a prefix to be prepended to the selected completion, or an error. func (c *Completer) completeAddress(s string) ([]string, string, error) { prefix, candidate := c.parseAddress(s) cmd, err := c.getAddressCmd(candidate) if err != nil { return nil, "", err } stdout, err := cmd.StdoutPipe() if err != nil { return nil, "", fmt.Errorf("stdout: %w", err) } stderr, err := cmd.StderrPipe() if err != nil { return nil, "", fmt.Errorf("stderr: %w", err) } // reset the process group id to allow killing all its children cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if err := cmd.Start(); err != nil { return nil, "", fmt.Errorf("cmd start: %w", err) } // Wait returns an error if the exit status != 0, which some completion // programs will do to signal no matches. We don't want to spam the user with // spurious error messages, so we'll ignore any errors that arise at this // point. defer cmd.Wait() //nolint:errcheck // see above completions, err := readCompletions(stdout) if err != nil { // make sure to kill the process *and* all its children //nolint:errcheck // who cares? syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL) log.Warnf("command %s killed: %s", cmd, err) } if err != nil && !errors.Is(err, tooManyLines) { buf, _ := io.ReadAll(stderr) msg := strings.TrimSpace(string(buf)) if msg != "" { msg = ": " + msg } return nil, "", fmt.Errorf("read completions%s: %w", msg, err) } return completions, prefix, nil } // parseAddress will break an address header into a prefix (containing // the already valid addresses) and an input for completion func (c *Completer) parseAddress(s string) (string, string) { pattern := regexp.MustCompile(`^(.*),\s+([^,]*)$`) matches := pattern.FindStringSubmatch(s) if matches == nil { return "", s } return matches[1] + ", ", matches[2] } // getAddressCmd constructs an exec.Cmd based on the configured command and // specified query. func (c *Completer) getAddressCmd(s string) (*exec.Cmd, error) { if strings.TrimSpace(c.AddressBookCmd) == "" { return nil, fmt.Errorf("no command configured") } queryCmd := strings.ReplaceAll(c.AddressBookCmd, "%s", s) parts, err := shlex.Split(queryCmd) if err != nil { return nil, fmt.Errorf("could not lex command") } if len(parts) < 1 { return nil, fmt.Errorf("empty command") } if len(parts) > 1 { return exec.Command(parts[0], parts[1:]...), nil } return exec.Command(parts[0]), nil } // readCompletions reads a slice of completions from r line by line. Each line // must consist of tab-delimited fields. Only the first field (the email // address field) is required, the second field (the contact name) is optional, // and subsequent fields are ignored. func readCompletions(r io.Reader) ([]string, error) { buf := bufio.NewReader(r) completions := []string{} for i := 0; i < maxCompletionLines; i++ { line, err := buf.ReadString('\n') if errors.Is(err, io.EOF) { return completions, nil } else if err != nil { return nil, err } if strings.TrimSpace(line) == "" { // skip empty lines continue } parts := strings.SplitN(line, "\t", 3) addr, err := mail.ParseAddress(strings.TrimSpace(parts[0])) if err != nil { log.Warnf("line %d: %#v: could not parse address: %v", line, err) continue } if len(parts) > 1 { addr.Name = strings.TrimSpace(parts[1]) } decoded, err := decodeMIME(addr.String()) if err != nil { log.Warnf("line %d: %#v: could not decode MIME string: %v", i+1, line, err) continue } completions = append(completions, decoded) } return completions, tooManyLines } func decodeMIME(s string) (string, error) { var d mime.WordDecoder return d.DecodeHeader(s) } func (c *Completer) handleErr(err error) { if c.errHandler != nil { c.errHandler(err) } }