[](https://github.com/la5nta/pat/actions)
[](https://goreportcard.com/report/github.com/la5nta/pat)
[](https://liberapay.com/la5nta)
## Overview
Pat is a cross platform Winlink client with basic messaging capabilities.
It is the primary sandbox/prototype application for the [wl2k-go](https://github.com/la5nta/wl2k-go) project, and provides both a command line interface and a responsive (mobile-friendly) web interface.
It is mainly developed for Linux, but is also known to run on OS X, Windows and Android.
#### Features
* Message composer/reader (basic mailbox functionality).
* Auto-shrink image attachments.
* Post position reports with location from local GPS, browser location or manual entry.
* Rig control (using hamlib).
* CRON-like syntax for execution of scheduled commands (e.g. QSY or connect).
* Built in http-server with web interface (mobile friendly).
* Git style command line interface.
* Listen for P2P connections using multiple modes concurrently.
* AX.25, telnet, PACTOR and ARDOP support.
* Experimental gzip message compression (See "Gzip experiment" below).
##### Example
```
martinhpedersen@duo:~$ pat interactive
> listen winmor,telnet-p2p,ax25
2015/02/03 10:33:10 Listening for incoming traffic (winmor,telnet-p2p,ax25)...
> connect winmor:///LA3F
2015/02/03 10:34:28 Connecting to winmor:LA3F...
2015/02/03 10:34:33 Connected to WINMOR:LA3F
RMS Trimode 1.3.3.0 Follo.SE Oslo. Pactor & Winmor Hybrid Gateway
LA5NTA has 117 minutes remaining with LA3F
[WL2K-2.8.4.8-B2FWIHJM$]
Wien CMS via LA3F >
>FF
FC EM FOYNU8AKXX59 260 221 0
F> 68
1 proposal(s) received
Accepting FOYNU8AKXX59
Receiving [//WL2K test til linux] [offset 0]
>FF
FQ
Waiting for remote node to close the connection...
> _
```
### Gzip experiment
Gzip message compression has been added as an experimental B2F extension. The extension is implemented as a backwards compatible alternative to the ancient LZHUF compression.
This experiment is enabled by default and sessions between two Pat nodes (or other software supporting this B2F extension) will use gzip compression when transferring messages.
For more information, see ") scanner := bufio.NewScanner(buf) var blockquote int for scanner.Scan() { line := scanner.Text() if len(line) == 0 { _, _ = fmt.Fprint(&out, "
") continue } depth := blockquoteDepth(line) for depth != blockquote { if depth > blockquote { _, _ = fmt.Fprintf(&out, "
") blockquote++ } else { _, _ = fmt.Fprintf(&out, "
") blockquote-- } } line = line[depth:] line = htmlEncode(line) line = linkify(line) _, _ = fmt.Fprint(&out, line+"\n") } for ; blockquote > 0; blockquote-- { _, _ = fmt.Fprintf(&out, "
") } _, _ = fmt.Fprint(&out, "") return out.Bytes() } // blcokquoteDepth counts the number of '>' at the beginning of the string. func blockquoteDepth(str string) (n int) { for _, c := range str { if c != '>' { break } n++ } return } // htmlEncode encodes html characters func htmlEncode(str string) string { str = strings.ReplaceAll(str, ">", ">") str = strings.ReplaceAll(str, "<", "<") return str } // linkify detects url's in the given string and adds %s%s`, str[:start], link, str[start:end], linkify(str[end:])) } pat-0.15.1/interactive.go 0000664 0000000 0000000 00000006664 14534256521 0015251 0 ustar 00root root 0000000 0000000 // Copyright 2016 Martin Hebnes Pedersen (LA5NTA). All rights reserved. // Use of this source code is governed by the MIT-license that can be // found in the LICENSE file. package main import ( "bytes" "context" "fmt" "log" "os" "runtime" "strings" "time" "github.com/la5nta/wl2k-go/transport/ax25" "github.com/peterh/liner" ) func Interactive(ctx context.Context) { line := liner.NewLiner() defer line.Close() done := make(chan struct{}) go func() { defer close(done) for { str, _ := line.Prompt(getPrompt()) if str == "" { continue } line.AppendHistory(str) if str[0] == '#' { continue } if quit := execCmd(str); quit { break } } }() select { case <-ctx.Done(): case <-done: } } func execCmd(line string) (quit bool) { cmd, param := parseCommand(line) switch cmd { case "connect": if param == "" { printInteractiveUsage() return } Connect(param) case "listen": Listen(param) case "unlisten": Unlisten(param) case "heard": PrintHeard() case "freq": freq(param) case "qtc": PrintQTC() case "debug": os.Setenv("ardop_debug", "1") fmt.Println("Number of goroutines:", runtime.NumGoroutine()) case "q", "quit": return true case "": return default: printInteractiveUsage() } return } func printInteractiveUsage() { fmt.Println("Uri examples: 'LA3F@5350', 'LA1B-10 v LA5NTA-1', 'LA5NTA:secret@192.168.1.1:54321'") methods := []string{ MethodArdop, MethodAX25, MethodAX25AGWPE, MethodAX25Linux, MethodAX25SerialTNC, MethodPactor, MethodTelnet, MethodVaraHF, MethodVaraFM, } fmt.Println("Methods:", strings.Join(methods, ", ")) cmds := []string{ "connect METHOD:[URI] or alias Connect to a remote station.", "listen METHOD Listen for incoming connections.", "unlisten METHOD Unregister listener for incoming connections.", "freq METHOD:FREQ Change rig frequency.", "heard Display all stations heard over the air.", "qtc Print pending outbound messages.", } fmt.Println("Commands: ") for _, cmd := range cmds { fmt.Printf(" %s\n", cmd) } } func getPrompt() string { var buf bytes.Buffer status := getStatus() if len(status.ActiveListeners) > 0 { fmt.Fprintf(&buf, "L%v", status.ActiveListeners) } fmt.Fprint(&buf, "> ") return buf.String() } func PrintHeard() { pf := func(call string, t time.Time) { fmt.Printf(" %-10s (%s)\n", call, t.Format(time.RFC1123)) } fmt.Println("ardop:") if adTNC == nil { fmt.Println(" (not initialized)") } else if heard := adTNC.Heard(); len(heard) == 0 { fmt.Println(" (none)") } else { for call, t := range heard { pf(call, t) } } fmt.Println("ax25+linux:") if heard, err := ax25.Heard(config.AX25Linux.Port); err != nil { fmt.Printf(" (%s)\n", err) } else if len(heard) == 0 { fmt.Println(" (none)") } else { for call, t := range heard { pf(call, t) } } } func PrintQTC() { msgs, err := mbox.Outbox() if err != nil { log.Println(err) return } fmt.Printf("QTC: %d.\n", len(msgs)) for _, msg := range msgs { fmt.Printf(`%-12.12s (%s): %s`, msg.MID(), msg.Subject(), fmt.Sprint(msg.To())) if msg.Header.Get("X-P2POnly") == "true" { fmt.Printf(" (P2P only)") } fmt.Println("") } } func parseCommand(str string) (mode, param string) { parts := strings.SplitN(str, " ", 2) if len(parts) == 1 { return parts[0], "" } return parts[0], parts[1] } pat-0.15.1/internal/ 0000775 0000000 0000000 00000000000 14534256521 0014205 5 ustar 00root root 0000000 0000000 pat-0.15.1/internal/buildinfo/ 0000775 0000000 0000000 00000000000 14534256521 0016160 5 ustar 00root root 0000000 0000000 pat-0.15.1/internal/buildinfo/VERSION.go 0000664 0000000 0000000 00000001052 14534256521 0017632 0 ustar 00root root 0000000 0000000 // Copyright 2017 Martin Hebnes Pedersen (LA5NTA). All rights reserved. // Use of this source code is governed by the MIT-license that can be // found in the LICENSE file. package buildinfo const ( // AppName is the friendly name of the app. // // Forks should consider using a different name. AppName = "Pat" // Version is the app's SemVer. // // Forks should NOT bump this unless they use a unique AppName. The Winlink // system uses this to derive the "these users should upgrade" wall of shame // from CMS connects. Version = "0.15.1" ) pat-0.15.1/internal/buildinfo/gitrev.go 0000664 0000000 0000000 00000000607 14534256521 0020012 0 ustar 00root root 0000000 0000000 //go:build go1.18 // +build go1.18 package buildinfo import "runtime/debug" // GitRev is the git commit hash that the binary was built at. var GitRev = func() string { if info, ok := debug.ReadBuildInfo(); ok { for _, setting := range info.Settings { if setting.Key == "vcs.revision" && len(setting.Value) > 7 { return setting.Value[:7] } } } return "unknown origin" }() pat-0.15.1/internal/buildinfo/gitrev_legacy.go 0000664 0000000 0000000 00000000252 14534256521 0021332 0 ustar 00root root 0000000 0000000 //go:build !go1.18 // +build !go1.18 package buildinfo // GitRev is the git commit hash that the binary was built at. var GitRev = "unknown origin" // Set by make.bash pat-0.15.1/internal/buildinfo/strings.go 0000664 0000000 0000000 00000001375 14534256521 0020206 0 ustar 00root root 0000000 0000000 package buildinfo import ( "fmt" "runtime" ) // VersionString returns a very descriptive version including the app SemVer, git rev plus the // Golang OS, architecture and version. func VersionString() string { return fmt.Sprintf("%s %s/%s - %s", VersionStringShort(), runtime.GOOS, runtime.GOARCH, runtime.Version()) } // VersionStringShort returns the app SemVer and git rev. func VersionStringShort() string { return fmt.Sprintf("v%s (%s)", Version, GitRev) } // UserAgent returns a suitable HTTP user agent string containing app name, SemVer, git rev, plus // the Golang OS, architecture and version. func UserAgent() string { return fmt.Sprintf("%v/%v (%v) %v (%v; %v)", AppName, Version, GitRev, runtime.Version(), runtime.GOOS, runtime.GOARCH) } pat-0.15.1/internal/cmsapi/ 0000775 0000000 0000000 00000000000 14534256521 0015461 5 ustar 00root root 0000000 0000000 pat-0.15.1/internal/cmsapi/api.go 0000664 0000000 0000000 00000011053 14534256521 0016561 0 ustar 00root root 0000000 0000000 // Copyright 2016 Martin Hebnes Pedersen (LA5NTA). All rights reserved. // Use of this source code is governed by the MIT-license that can be // found in the LICENSE file. package cmsapi import ( "bytes" "context" "encoding/json" "fmt" "io" "log" "net/http" "net/url" "os" "strings" "time" ) const ( RootURL = "https://api.winlink.org" PathVersionAdd = "/version/add" PathGatewayStatus = "/gateway/status.json" PathAccountExists = "/account/exists" // AccessKey issued December 2017 by the WDT for use with Pat AccessKey = "1880278F11684B358F36845615BD039A" ) type VersionAdd struct { Callsign string `json:"callsign"` Program string `json:"program"` Version string `json:"version"` Comments string `json:"comments,omitempty"` } func (v VersionAdd) Post() error { b, _ := json.Marshal(v) buf := bytes.NewBuffer(b) versionURL := RootURL + PathVersionAdd + "?key=" + AccessKey req, _ := http.NewRequest("POST", versionURL, buf) req.Header.Set("content-type", "application/json") req.Header.Set("accept", "application/json") resp, err := http.DefaultClient.Do(req) if err != nil { return err } defer resp.Body.Close() var response map[string]interface{} if err := json.NewDecoder(resp.Body).Decode(&response); err != nil { return err } if errMsg, ok := response["ErrorMessage"]; ok { return fmt.Errorf("Winlink CMS Web Services: %s", errMsg) } return nil } func AccountExists(callsign string) (bool, error) { accountURL := RootURL + PathAccountExists + "?key=" + AccessKey + "&callsign=" + url.QueryEscape(callsign) req, _ := http.NewRequest("GET", accountURL, nil) req.Header.Set("Accept", "application/json") resp, err := http.DefaultClient.Do(req) if err != nil { return false, err } defer resp.Body.Close() var obj struct{ CallsignExists bool } return obj.CallsignExists, json.NewDecoder(resp.Body).Decode(&obj) } type GatewayStatus struct { ServerName string `json:"ServerName"` ErrorCode int `json:"ErrorCode"` Gateways []Gateway `json:"Gateways"` } type Gateway struct { Callsign string BaseCallsign string RequestedMode string Comments string LastStatus RFC1123Time Latitude float64 Longitude float64 Channels []GatewayChannel `json:"GatewayChannels"` } type GatewayChannel struct { OperatingHours string SupportedModes string Frequency float64 ServiceCode string Baud string RadioRange string Mode int Gridsquare string Antenna string } type RFC1123Time struct{ time.Time } // GetGatewayStatus fetches the gateway status list returned by GatewayStatusUrl // // mode can be any of [packet, pactor, robustpacket, allhf or anyall]. Empty is AnyAll. // historyHours is the number of hours of history to include (maximum: 48). If < 1, then API default is used. // serviceCodes defaults to "PUBLIC". func GetGatewayStatus(ctx context.Context, mode string, historyHours int, serviceCodes ...string) (io.ReadCloser, error) { switch { case mode == "": mode = "AnyAll" case historyHours > 48: historyHours = 48 case len(serviceCodes) == 0: serviceCodes = []string{"PUBLIC"} } params := url.Values{"Mode": {mode}} params.Set("key", AccessKey) if historyHours >= 0 { params.Add("HistoryHours", fmt.Sprintf("%d", historyHours)) } for _, str := range serviceCodes { params.Add("ServiceCodes", str) } req, err := http.NewRequestWithContext(ctx, "POST", RootURL+PathGatewayStatus, strings.NewReader(params.Encode())) if err != nil { return nil, err } req.Header.Set("Content-Type", "application/x-www-form-urlencoded") resp, err := http.DefaultClient.Do(req) switch { case err != nil: return nil, err case resp.StatusCode != http.StatusOK: return nil, fmt.Errorf("unexpected http status '%v'", resp.Status) } return resp.Body, err } func GetGatewayStatusCached(ctx context.Context, cacheFile string, forceDownload bool, serviceCodes ...string) (io.ReadCloser, error) { if !forceDownload { file, err := os.Open(cacheFile) if err == nil { return file, nil } } log.Println("Downloading latest gateway status information...") fresh, err := GetGatewayStatus(ctx, "", 48, serviceCodes...) if err != nil { return nil, err } file, err := os.Create(cacheFile) if err != nil { return nil, err } _, err = io.Copy(file, fresh) file.Seek(0, 0) if err == nil { log.Println("download succeeded.") } return file, err } func (t *RFC1123Time) UnmarshalJSON(b []byte) (err error) { var str string if err = json.Unmarshal(b, &str); err != nil { return err } t.Time, err = time.Parse(time.RFC1123, str) return err } pat-0.15.1/internal/debug/ 0000775 0000000 0000000 00000000000 14534256521 0015273 5 ustar 00root root 0000000 0000000 pat-0.15.1/internal/debug/debug.go 0000664 0000000 0000000 00000000454 14534256521 0016713 0 ustar 00root root 0000000 0000000 package debug import ( "log" "os" "strconv" ) const ( EnvVar = "PAT_DEBUG" Prefix = "[DEBUG] " ) var enabled bool func init() { enabled, _ = strconv.ParseBool(os.Getenv(EnvVar)) } func Printf(format string, v ...interface{}) { if !enabled { return } log.Printf(Prefix+format, v...) } pat-0.15.1/internal/directories/ 0000775 0000000 0000000 00000000000 14534256521 0016521 5 ustar 00root root 0000000 0000000 pat-0.15.1/internal/directories/directories.go 0000664 0000000 0000000 00000006725 14534256521 0021376 0 ustar 00root root 0000000 0000000 package directories import ( "errors" "log" "os" "path/filepath" "strings" "sync" "github.com/la5nta/pat/internal/buildinfo" "github.com/la5nta/pat/internal/debug" "github.com/adrg/xdg" ) var ( lock = &sync.Mutex{} dataPath string configPath string statePath string ) func DataDir() string { return getDir(&dataPath, xdg.DataHome, "DataDir") } func ConfigDir() string { return getDir(&configPath, xdg.ConfigHome, "ConfigDir") } func StateDir() string { return getDir(&statePath, xdg.StateHome, "StateDir") } func getDir(dir *string, basePath string, methodName string) string { lock.Lock() defer lock.Unlock() if *dir == "" { initDir(dir, basePath, methodName) } return *dir } func initDir(dir *string, basePath string, methodName string) { *dir = filepath.Join(basePath, strings.ToLower(buildinfo.AppName)) if _, err := os.Stat(*dir); os.IsNotExist(err) { err := os.MkdirAll(*dir, os.ModeDir|0o755) if err != nil { log.Fatalf("unable to create or open %s %s: %v", methodName, *dir, err) } } } func MigrateLegacyDataDir() { if f, err := os.Stat(ConfigDir()); err != nil && f.IsDir() { debug.Printf("new config directory %s already exists, we have already migrated", ConfigDir()) return } homeDir, err := os.UserHomeDir() if err != nil { log.Fatal(err) } legacyDataDir := filepath.Join(homeDir, ".wl2k") switch f, err := os.Stat(legacyDataDir); { case os.IsNotExist(err): debug.Printf("tried to migrate from %s but it doesn't exist; nothing to do", legacyDataDir) return case err != nil: log.Fatal(err) case !f.IsDir(): log.Printf("tried to migrate from %s but it's not a directory, that's weird; ignoring", legacyDataDir) return } log.Printf("Migrating your Pat files from %s to new locations", legacyDataDir) if err = migrateFile("config.json", legacyDataDir, ConfigDir()); err != nil { log.Fatal(err) } if err = migrateFile("mailbox", legacyDataDir, DataDir()); err != nil { log.Fatal(err) } if err = migrateFile("Standard_Forms", legacyDataDir, DataDir()); err != nil { log.Fatal(err) } matches, err := filepath.Glob(filepath.Join(legacyDataDir, "rmslist*.json")) if err != nil { log.Fatal(err) } for _, match := range matches { _, f := filepath.Split(match) if err = migrateFile(f, legacyDataDir, DataDir()); err != nil { log.Fatal(err) } } debug.Printf("migration from %s finished, renaming it", legacyDataDir) err = os.Rename(legacyDataDir, legacyDataDir+"-old") if err != nil { log.Fatal(err) } } func migrateFile(fileName string, fromDir string, toDir string) error { // make sure the old file is there fromFile := filepath.Join(fromDir, fileName) if _, err := os.Stat(fromFile); errors.Is(err, os.ErrNotExist) { // no legacy file, nothing to do debug.Printf("File %s doesn't exist, not migrating it", fromFile) return nil } else if err != nil { return err } // touch the new file to make sure it's not there, and we can write to it toFile := filepath.Join(toDir, fileName) switch f, err := os.OpenFile(toFile, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0o666); { case errors.Is(err, os.ErrExist): // new file already exists, don't clobber it debug.Printf("new file %s already exists; ignoring %s", toFile, fromFile) return nil case err != nil: return err default: if err := f.Close(); err != nil { return err } if err := os.Remove(toFile); err != nil { return err } } debug.Printf("Migrating %s from %s to %s", fileName, fromDir, toDir) return os.Rename(fromFile, toFile) } pat-0.15.1/internal/forms/ 0000775 0000000 0000000 00000000000 14534256521 0015333 5 ustar 00root root 0000000 0000000 pat-0.15.1/internal/forms/date.go 0000664 0000000 0000000 00000001235 14534256521 0016600 0 ustar 00root root 0000000 0000000 package forms import ( "strings" "time" ) func formatDateTime(t time.Time) string { return t.Format("2006-01-02 15:04:05") } func formatDateTimeUTC(t time.Time) string { return t.UTC().Format("2006-01-02 15:04:05Z07:00") } func formatDate(t time.Time) string { return t.Format("2006-01-02") } func formatTime(t time.Time) string { return t.Format("15:04:05") } func formatDateUTC(t time.Time) string { return t.UTC().Format("2006-01-02Z07:00") } func formatTimeUTC(t time.Time) string { return t.UTC().Format("15:04:05Z07:00") } func formatUDTG(t time.Time) string { return strings.ToUpper(t.UTC().Format("021504Z07:00 Jan 2006")) } pat-0.15.1/internal/forms/date_test.go 0000664 0000000 0000000 00000001167 14534256521 0017643 0 ustar 00root root 0000000 0000000 package forms import ( "testing" "time" ) func TestDateFormat(t *testing.T) { now := time.Date(2023, 12, 31, 23, 59, 59, 0, time.FixedZone("UTC-4", -4*60*60)) tests := []struct { fn func(t time.Time) string expect string }{ {formatDateTime, "2023-12-31 23:59:59"}, {formatDateTimeUTC, "2024-01-01 03:59:59Z"}, {formatDate, "2023-12-31"}, {formatTime, "23:59:59"}, {formatDateUTC, "2024-01-01Z"}, {formatTimeUTC, "03:59:59Z"}, {formatUDTG, "010359Z JAN 2024"}, } for i, tt := range tests { if got := tt.fn(now); got != tt.expect { t.Errorf("%d: got %q expected %q", i, got, tt.expect) } } } pat-0.15.1/internal/forms/forms.go 0000664 0000000 0000000 00000102425 14534256521 0017014 0 ustar 00root root 0000000 0000000 // Copyright 2020 Rainer Grosskopf (KI7RMJ). All rights reserved. // Use of this source code is governed by the MIT-license that can be // found in the LICENSE file. // Processes Winlink-compatible message template (aka Winlink forms) package forms import ( "archive/zip" "bufio" "bytes" "context" "encoding/json" "encoding/xml" "errors" "fmt" "io" "io/ioutil" "log" "math" "net/http" "os" "path" "path/filepath" "regexp" "sort" "strconv" "strings" "sync" "time" "unicode/utf8" "github.com/dimchansky/utfbom" "github.com/la5nta/pat/cfg" "github.com/la5nta/pat/internal/debug" "github.com/la5nta/pat/internal/gpsd" "github.com/pd0mz/go-maidenhead" ) const ( fieldValueFalseInXML = "False" htmlFileExt = ".html" txtFileExt = ".txt" formsVersionInfoURL = "https://api.getpat.io/v1/forms/standard-templates/latest" ) // Manager manages the forms subsystem // When the web frontend POSTs the form template data, this map holds the POST'ed data. // Each form composer instance renders into another browser tab, and has a unique instance cookie. // This instance cookie is the key into the map, so that we can keep the values // from different form authoring sessions separate from each other. type Manager struct { config Config postedFormData struct { sync.RWMutex internalFormDataMap map[string]FormData } } // Config passes config options to the forms package type Config struct { FormsPath string MyCall string Locator string AppVersion string LineReader func() string UserAgent string GPSd cfg.GPSdConfig } // Form holds information about a Winlink form template type Form struct { Name string `json:"name"` TxtFileURI string `json:"txt_file_uri"` InitialURI string `json:"initial_uri"` ViewerURI string `json:"viewer_uri"` ReplyTxtFileURI string `json:"reply_txt_file_uri"` ReplyInitialURI string `json:"reply_initial_uri"` ReplyViewerURI string `json:"reply_viewer_uri"` } // FormFolder is a folder with forms. A tree structure with Form leaves and sub-Folder branches type FormFolder struct { Name string `json:"name"` Path string `json:"path"` Version string `json:"version"` FormCount int `json:"form_count"` Forms []Form `json:"forms"` Folders []FormFolder `json:"folders"` } // FormData holds the instance data that define a filled-in form type FormData struct { TargetForm Form `json:"target_form"` Fields map[string]string `json:"fields"` MsgTo string `json:"msg_to"` MsgCc string `json:"msg_cc"` MsgSubject string `json:"msg_subject"` MsgBody string `json:"msg_body"` MsgXML string `json:"msg_xml"` IsReply bool `json:"is_reply"` Submitted time.Time `json:"submitted"` } // MessageForm represents a concrete form-based message type MessageForm struct { To string Cc string Subject string Body string AttachmentXML string AttachmentName string } // UpdateResponse is the API response format for the upgrade forms endpoint type UpdateResponse struct { NewestVersion string `json:"newestVersion"` Action string `json:"action"` } var client = httpClient{http.Client{Timeout: 10 * time.Second}} // NewManager instantiates the forms manager func NewManager(conf Config) *Manager { _ = os.MkdirAll(conf.FormsPath, 0o755) retval := &Manager{ config: conf, } retval.postedFormData.internalFormDataMap = make(map[string]FormData) return retval } // GetFormsCatalogHandler reads all forms from config.FormsPath and writes them in the http response as a JSON object graph // This lets the frontend present a tree-like GUI for the user to select a form for composing a message func (m *Manager) GetFormsCatalogHandler(w http.ResponseWriter, r *http.Request) { formFolder, err := m.buildFormFolder() if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) log.Printf("%s %s: %s", r.Method, r.URL.Path, err) return } _ = json.NewEncoder(w).Encode(formFolder) } // PostFormDataHandler - When the user is done filling a form, the frontend posts the input fields to this handler, // which stores them in a map, so that other browser tabs can read the values back with GetFormDataHandler func (m *Manager) PostFormDataHandler(w http.ResponseWriter, r *http.Request) { if err := r.ParseMultipartForm(10e6); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } formPath := r.URL.Query().Get("formPath") if formPath == "" { http.Error(w, "formPath query param missing", http.StatusBadRequest) log.Printf("formPath query param missing %s %s", r.Method, r.URL.Path) return } composeReply, _ := strconv.ParseBool(r.URL.Query().Get("composereply")) formFolder, err := m.buildFormFolder() if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) log.Printf("%s %s: %s", r.Method, r.URL.Path, err) return } form, err := findFormFromURI(formPath, formFolder) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) log.Printf("can't find form to match posted form data %s %s", formPath, r.URL) return } formInstanceKey, err := r.Cookie("forminstance") if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) log.Printf("missing cookie %s %s", formPath, r.URL) return } formData := FormData{ IsReply: composeReply, TargetForm: form, Fields: make(map[string]string), } for key, values := range r.PostForm { formData.Fields[strings.TrimSpace(strings.ToLower(key))] = values[0] } formMsg, err := formMessageBuilder{ Template: form, FormValues: formData.Fields, Interactive: false, IsReply: composeReply, FormsMgr: m, }.build() if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) log.Printf("%s %s: %s", r.Method, r.URL.Path, err) } formData.MsgTo = formMsg.To formData.MsgCc = formMsg.Cc formData.MsgSubject = formMsg.Subject formData.MsgBody = formMsg.Body formData.MsgXML = formMsg.AttachmentXML formData.Submitted = time.Now() m.postedFormData.Lock() m.postedFormData.internalFormDataMap[formInstanceKey.Value] = formData m.postedFormData.Unlock() m.cleanupOldFormData() _, _ = io.WriteString(w, "") } // GetFormDataHandler is the counterpart to PostFormDataHandler. Returns the form field values to the frontend func (m *Manager) GetFormDataHandler(w http.ResponseWriter, r *http.Request) { formInstanceKey, err := r.Cookie("forminstance") if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) log.Printf("missing cookie %s %s", formInstanceKey, r.URL) return } _ = json.NewEncoder(w).Encode(m.GetPostedFormData(formInstanceKey.Value)) } // GetPostedFormData is similar to GetFormDataHandler, but used when posting the form-based message to the outbox func (m *Manager) GetPostedFormData(key string) FormData { m.postedFormData.RLock() defer m.postedFormData.RUnlock() return m.postedFormData.internalFormDataMap[key] } // GetFormTemplateHandler handles the request for viewing a form filled-in with instance values func (m *Manager) GetFormTemplateHandler(w http.ResponseWriter, r *http.Request) { formPath := r.URL.Query().Get("formPath") if formPath == "" { http.Error(w, "formPath query param missing", http.StatusBadRequest) log.Printf("formPath query param missing %s %s", r.Method, r.URL.Path) return } absPathTemplate, err := m.findAbsPathForTemplatePath(formPath) if err != nil { http.Error(w, "find the full path for requested template "+formPath, http.StatusBadRequest) log.Printf("find the full path for requested template %s %s: %s", r.Method, r.URL.Path, "can't open template "+formPath) return } responseText, err := m.fillFormTemplate(absPathTemplate, "/api/form?"+r.URL.Query().Encode(), nil, make(map[string]string)) if err != nil { http.Error(w, "can't open template "+formPath, http.StatusBadRequest) log.Printf("problem filling form template file %s %s: can't open template %s. Err: %s", r.Method, r.URL.Path, formPath, err) return } _, err = io.WriteString(w, responseText) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) log.Printf("can't write form into response %s %s: %s", r.Method, r.URL.Path, err) return } } // UpdateFormTemplatesHandler handles API calls to update form templates. func (m *Manager) UpdateFormTemplatesHandler(w http.ResponseWriter, r *http.Request) { response, err := m.UpdateFormTemplates(r.Context()) if err != nil { http.Error(w, fmt.Sprint(err), http.StatusInternalServerError) return } jsn, _ := json.Marshal(response) _, _ = w.Write(jsn) } // UpdateFormTemplates handles searching for and installing the latest version of the form templates. func (m *Manager) UpdateFormTemplates(ctx context.Context) (UpdateResponse, error) { if err := os.MkdirAll(m.config.FormsPath, 0o755); err != nil { return UpdateResponse{}, fmt.Errorf("can't write to forms dir [%w]", err) } log.Printf("Updating form templates; current version is %v", m.getFormsVersion()) latest, err := m.getLatestFormsInfo(ctx) if err != nil { return UpdateResponse{}, err } if !m.isNewerVersion(latest.Version) { log.Printf("Latest forms version is %v; nothing to do", latest.Version) return UpdateResponse{ NewestVersion: latest.Version, Action: "none", }, nil } if err = m.downloadAndUnzipForms(ctx, latest.ArchiveURL); err != nil { return UpdateResponse{}, err } log.Printf("Finished forms update to %v", latest.Version) // TODO: re-init forms manager return UpdateResponse{ NewestVersion: latest.Version, Action: "update", }, nil } type formsInfo struct { Version string `json:"version"` ArchiveURL string `json:"archive_url"` } func (m *Manager) getLatestFormsInfo(ctx context.Context) (*formsInfo, error) { resp, err := client.Get(ctx, m.config.UserAgent, formsVersionInfoURL) if err != nil || resp.StatusCode != http.StatusOK { return nil, fmt.Errorf("can't fetch winlink forms version page: %w", err) } defer resp.Body.Close() var v formsInfo if err := json.NewDecoder(resp.Body).Decode(&v); err != nil { return nil, err } return &v, nil } func (m *Manager) downloadAndUnzipForms(ctx context.Context, downloadLink string) error { log.Printf("Updating forms via %v", downloadLink) resp, err := client.Get(ctx, m.config.UserAgent, downloadLink) if err != nil { return fmt.Errorf("can't download update ZIP: %w", err) } defer resp.Body.Close() f, err := ioutil.TempFile(os.TempDir(), "pat") if err != nil { return fmt.Errorf("can't create temp file for download: %w", err) } defer f.Close() defer os.Remove(f.Name()) if _, err := io.Copy(f, resp.Body); err != nil { return fmt.Errorf("can't write update ZIP: %w", err) } if err := unzip(f.Name(), m.config.FormsPath); err != nil { return fmt.Errorf("can't unzip forms update: %w", err) } return nil } func unzip(srcArchivePath, dstRoot string) error { // Closure to address file descriptors issue with all the deferred .Close() methods extractAndWriteFile := func(zf *zip.File) error { if zf.FileInfo().IsDir() { return nil } destPath := filepath.Join(dstRoot, zf.Name) // Check for ZipSlip (Directory traversal) if !strings.HasPrefix(destPath, filepath.Clean(dstRoot)+string(os.PathSeparator)) { return fmt.Errorf("illegal file path: %s", destPath) } // Ensure target directory exists if err := os.MkdirAll(filepath.Dir(destPath), 0o755); err != nil { return fmt.Errorf("can't create target directory: %w", err) } // Write file src, err := zf.Open() if err != nil { return err } defer src.Close() dst, err := os.OpenFile(destPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, zf.Mode()) if err != nil { return err } defer dst.Close() _, err = io.Copy(dst, src) return err } r, err := zip.OpenReader(srcArchivePath) if err != nil { return err } defer r.Close() for _, f := range r.File { err := extractAndWriteFile(f) if err != nil { return err } } return nil } // GetXMLAttachmentNameForForm returns the user-visible filename for the message attachment that holds the form instance values func (m *Manager) GetXMLAttachmentNameForForm(f Form, isReply bool) string { attachmentName := filepath.Base(f.ViewerURI) if isReply { attachmentName = filepath.Base(f.ReplyViewerURI) } attachmentName = strings.TrimSuffix(attachmentName, filepath.Ext(attachmentName)) attachmentName = "RMS_Express_Form_" + attachmentName + ".xml" if len(attachmentName) > 255 { attachmentName = strings.TrimPrefix(attachmentName, "RMS_Express_Form_") } return attachmentName } // RenderForm finds the associated form and returns the filled-in form in HTML given the contents of a form attachment func (m *Manager) RenderForm(contentUnsanitized []byte, composeReply bool) (string, error) { type Node struct { XMLName xml.Name Content []byte `xml:",innerxml"` Nodes []Node `xml:",any"` } sr := utfbom.SkipOnly(bytes.NewReader(contentUnsanitized)) contentData, err := io.ReadAll(sr) if err != nil { return "", fmt.Errorf("error reading sanitized form xml: %w", err) } if !utf8.Valid(contentData) { log.Println("Warning: unsupported string encoding in form XML, expected utf-8") } var n1 Node formParams := make(map[string]string) formVars := make(map[string]string) if err := xml.Unmarshal(contentData, &n1); err != nil { return "", err } if n1.XMLName.Local != "RMS_Express_Form" { return "", errors.New("missing RMS_Express_Form tag in form XML") } for _, n2 := range n1.Nodes { switch n2.XMLName.Local { case "form_parameters": for _, n3 := range n2.Nodes { formParams[n3.XMLName.Local] = string(n3.Content) } case "variables": for _, n3 := range n2.Nodes { formVars[n3.XMLName.Local] = string(n3.Content) } } } switch { case formParams["display_form"] == "": return "", errors.New("missing display_form tag in form XML") case composeReply && formParams["reply_template"] == "": return "", errors.New("missing reply_template tag in form XML for a reply message") } formFolder, err := m.buildFormFolder() if err != nil { return "", err } formToLoad := formParams["display_form"] if composeReply { // we're authoring a reply formToLoad = formParams["reply_template"] } form, err := findFormFromURI(formToLoad, formFolder) if err != nil { return "", err } var formRelPath string switch { case composeReply: // authoring a form reply formRelPath = form.ReplyInitialURI case strings.HasSuffix(form.ReplyViewerURI, formParams["display_form"]): // viewing a form reply formRelPath = form.ReplyViewerURI default: // viewing a form formRelPath = form.ViewerURI } absPathTemplate, err := m.findAbsPathForTemplatePath(formRelPath) if err != nil { return "", err } return m.fillFormTemplate(absPathTemplate, "/api/form?composereply=true&formPath="+formRelPath, regexp.MustCompile(`{[vV][aA][rR]\s+(\w+)\s*}`), formVars) } // ComposeForm combines all data needed for the whole form-based message: subject, body, and attachment func (m *Manager) ComposeForm(tmplPath string, subject string) (MessageForm, error) { formFolder, err := m.buildFormFolder() if err != nil { return MessageForm{}, fmt.Errorf("failed to build form folder tree: %v", err) } tmplPath = filepath.Clean(tmplPath) form, err := findFormFromURI(tmplPath, formFolder) if err != nil { return MessageForm{}, fmt.Errorf("failed to find '%s': %v", tmplPath, err) } formValues := map[string]string{ "subjectline": subject, "templateversion": m.getFormsVersion(), "msgsender": m.config.MyCall, } fmt.Printf("Form '%s', version: %s", form.TxtFileURI, formValues["templateversion"]) formMsg, err := formMessageBuilder{ Template: form, FormValues: formValues, Interactive: true, IsReply: false, FormsMgr: m, }.build() if err != nil { return MessageForm{}, err } return formMsg, nil } func (f Form) matchesName(nameToMatch string) bool { return f.InitialURI == nameToMatch || strings.EqualFold(f.InitialURI, nameToMatch+htmlFileExt) || f.ViewerURI == nameToMatch || strings.EqualFold(f.ViewerURI, nameToMatch+htmlFileExt) || f.ReplyInitialURI == nameToMatch || f.ReplyInitialURI == nameToMatch+".0" || f.ReplyViewerURI == nameToMatch || f.ReplyViewerURI == nameToMatch+".0" || f.TxtFileURI == nameToMatch || strings.EqualFold(f.TxtFileURI, nameToMatch+txtFileExt) } func (f Form) containsName(partialName string) bool { return strings.Contains(f.InitialURI, partialName) || strings.Contains(f.ViewerURI, partialName) || strings.Contains(f.ReplyInitialURI, partialName) || strings.Contains(f.ReplyViewerURI, partialName) || strings.Contains(f.ReplyTxtFileURI, partialName) || strings.Contains(f.TxtFileURI, partialName) } func (m *Manager) buildFormFolder() (FormFolder, error) { formFolder, err := m.innerRecursiveBuildFormFolder(m.config.FormsPath) formFolder.Version = m.getFormsVersion() return formFolder, err } func (m *Manager) innerRecursiveBuildFormFolder(rootPath string) (FormFolder, error) { rootFile, err := os.Open(rootPath) if err != nil { return FormFolder{}, err } defer rootFile.Close() rootFileInfo, _ := os.Stat(rootPath) if !rootFileInfo.IsDir() { return FormFolder{}, errors.New(rootPath + " is not a directory") } folder := FormFolder{ Name: rootFileInfo.Name(), Path: rootFile.Name(), Forms: []Form{}, Folders: []FormFolder{}, } infos, err := rootFile.Readdir(0) if err != nil { return folder, err } _ = rootFile.Close() formCnt := 0 for _, info := range infos { if info.IsDir() { subfolder, err := m.innerRecursiveBuildFormFolder(path.Join(rootPath, info.Name())) if err != nil { return folder, err } folder.Folders = append(folder.Folders, subfolder) folder.FormCount += subfolder.FormCount continue } if !strings.EqualFold(filepath.Ext(info.Name()), txtFileExt) { continue } frm, err := m.buildFormFromTxt(path.Join(rootPath, info.Name())) if err != nil { continue } if frm.InitialURI != "" || frm.ViewerURI != "" { formCnt++ folder.Forms = append(folder.Forms, frm) folder.FormCount++ } } sort.Slice(folder.Folders, func(i, j int) bool { return folder.Folders[i].Name < folder.Folders[j].Name }) sort.Slice(folder.Forms, func(i, j int) bool { return folder.Forms[i].Name < folder.Forms[j].Name }) return folder, nil } func (m *Manager) buildFormFromTxt(txtPath string) (Form, error) { f, err := os.Open(txtPath) if err != nil { return Form{}, err } defer f.Close() formsPathWithSlash := m.config.FormsPath + "/" form := Form{ Name: strings.TrimSuffix(path.Base(txtPath), path.Ext(txtPath)), TxtFileURI: strings.TrimPrefix(txtPath, formsPathWithSlash), } scanner := bufio.NewScanner(f) baseURI := path.Dir(form.TxtFileURI) for scanner.Scan() { l := scanner.Text() switch { case strings.HasPrefix(l, "Form:"): // Form: