[](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-1.0.0/api/types/ 0000775 0000000 0000000 00000000000 15203222376 0014213 5 ustar 00root root 0000000 0000000 pat-1.0.0/api/types/prompt.go 0000664 0000000 0000000 00000001465 15203222376 0016071 0 ustar 00root root 0000000 0000000 package types type PromptKind string const ( PromptKindPassword PromptKind = "password" PromptKindMultiSelect PromptKind = "multi-select" PromptKindBusyChannel PromptKind = "busy-channel" PromptKindPreAccountActivation PromptKind = "pre-account-activation" PromptKindAccountActivation PromptKind = "account-activation" ) type Prompt struct { ID string `json:"id"` Kind PromptKind `json:"kind"` Message string `json:"message"` Options []PromptOption `json:"options,omitempty"` // For multi-select } type PromptOption struct { Value string `json:"value"` Desc string `json:"desc,omitempty"` Checked bool `json:"checked"` } type PromptResponse struct { ID string `json:"id"` Value string `json:"value"` Err error `json:"error"` } pat-1.0.0/api/types/types.go 0000664 0000000 0000000 00000001645 15203222376 0015714 0 ustar 00root root 0000000 0000000 package types // Status represents a status report as sent to the Web GUI type Status struct { ActiveListeners []string `json:"active_listeners"` Connected bool `json:"connected"` Dialing bool `json:"dialing"` RemoteAddr string `json:"remote_addr"` HTTPClients []string `json:"http_clients"` ConfigHash string `json:"config_hash"` } // Progress represents a progress report as sent to the Web GUI type Progress struct { BytesTransferred int `json:"bytes_transferred"` BytesTotal int `json:"bytes_total"` MID string `json:"mid"` Subject string `json:"subject"` Receiving bool `json:"receiving"` Sending bool `json:"sending"` Done bool `json:"done"` } // Notification represents a desktop notification as sent to the Web GUI type Notification struct { Title string `json:"title"` Body string `json:"body"` } pat-1.0.0/api/winlink_account.go 0000664 0000000 0000000 00000005144 15203222376 0016571 0 ustar 00root root 0000000 0000000 package api import ( "encoding/json" "net/http" "github.com/la5nta/pat/internal/cmsapi" ) func (h Handler) winlinkAccountRegistrationHandler(w http.ResponseWriter, r *http.Request) { switch r.Method { case http.MethodGet: callsign := h.Options().MyCall if v := r.URL.Query().Get("callsign"); v != "" { callsign = v } if callsign == "" { http.Error(w, "Empty callsign", http.StatusBadRequest) return } exists, err := cmsapi.AccountExists(r.Context(), callsign) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } json.NewEncoder(w).Encode(struct { Callsign string `json:"callsign"` Exists bool `json:"exists"` }{callsign, exists}) case http.MethodPost: type body struct { Callsign string `json:"callsign"` Password string `json:"password"` RecoveryEmail string `json:"recovery_email"` // optional } var v body if err := json.NewDecoder(r.Body).Decode(&v); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } switch { case v.Callsign == "": http.Error(w, "Empty callsign", http.StatusBadRequest) return case len(v.Password) < 6 || len(v.Password) > 12: http.Error(w, "Password must be 6-12 characters", http.StatusBadRequest) return } if err := cmsapi.AccountAdd(r.Context(), v.Callsign, v.Password, v.RecoveryEmail); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } json.NewEncoder(w).Encode(v) } } func (h Handler) winlinkPasswordRecoveryEmailHandler(w http.ResponseWriter, r *http.Request) { type body struct { RecoveryEmail string `json:"recovery_email"` } var ( ctx = r.Context() callsign = h.Options().MyCall password = h.Config().SecureLoginPassword ) if callsign == "" || password == "" { http.Error(w, "Missing callsign or password in config", http.StatusBadRequest) return } switch r.Method { case http.MethodGet: email, err := cmsapi.PasswordRecoveryEmailGet(ctx, callsign, password) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(body{RecoveryEmail: email}) case http.MethodPut: var v body if err := json.NewDecoder(r.Body).Decode(&v); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } if err := cmsapi.PasswordRecoveryEmailSet(ctx, callsign, password, v.RecoveryEmail); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(v) } } pat-1.0.0/api/wshub.go 0000664 0000000 0000000 00000016547 15203222376 0014543 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 api import ( "bufio" "context" "encoding/json" "errors" "io" "log" "os" "path" "runtime" "sync" "time" "github.com/fsnotify/fsnotify" "github.com/gorilla/websocket" "github.com/la5nta/pat/api/types" "github.com/la5nta/pat/app" "github.com/la5nta/pat/internal/debug" "github.com/la5nta/pat/internal/osutil" "github.com/la5nta/wl2k-go/mailbox" ) const KeepaliveInterval = 4 * time.Minute // WSConn represent one connection in the WSHub pool type WSConn struct { conn *websocket.Conn out chan interface{} } // WSHub is a hub for broadcasting data to several websocket connections type WSHub struct { *app.App mu sync.Mutex pool map[*WSConn]struct{} } func NewWSHub(app *app.App) *WSHub { return &WSHub{App: app, pool: map[*WSConn]struct{}{}} } func (w *WSHub) UpdateStatus() { w.WriteJSON(struct{ Status types.Status }{w.GetStatus()}) } func (w *WSHub) WriteProgress(p types.Progress) { w.WriteJSON(struct{ Progress types.Progress }{p}) } func (w *WSHub) WriteNotification(n types.Notification) { w.WriteJSON(struct{ Notification types.Notification }{n}) } func (w *WSHub) Prompt(p app.Prompt) { w.WriteJSON(struct{ Prompt types.Prompt }{p.Prompt}) go func() { <-p.Done(); w.WriteJSON(struct{ PromptAbort types.Prompt }{p.Prompt}) }() } func (w *WSHub) WriteJSON(v interface{}) { w.mu.Lock() defer w.mu.Unlock() for c := range w.pool { select { case c.out <- v: case <-time.After(3 * time.Second): debug.Printf("Closing one unresponsive web socket") c.conn.Close() delete(w.pool, c) } } } // Close closes all active WebSocket connections in the hub. // // The hub should not be used after calling Close. func (w *WSHub) Close() error { w.mu.Lock() defer w.mu.Unlock() if w.pool == nil { return nil } for conn, _ := range w.pool { // Closing the connection should trigger the deferred cleanup in the Handle method for that client, // which includes removing it from the pool. err := conn.conn.Close() if err != nil { debug.Printf("Error closing WebSocket connection %s: %v", conn.conn.RemoteAddr(), err) } } w.pool = nil return nil } func (w *WSHub) NumClients() int { return len(w.ClientAddrs()) } func (w *WSHub) ClientAddrs() []string { w.mu.Lock() defer w.mu.Unlock() addrs := make([]string, 0, len(w.pool)) for c := range w.pool { addrs = append(addrs, c.conn.RemoteAddr().String()) } return addrs } func (w *WSHub) WatchMBox(ctx context.Context, mbox *mailbox.DirHandler) { // Maximise ulimit -n: // fsnotify opens a file descriptor for every file in the directories it watches, which // may more files than the current soft limit. The is especially a problem on macOS which // has a default soft limit of only 256 files. Windows does not have a such a limit. if runtime.GOOS != "windows" { if err := osutil.RaiseOpenFileLimit(4096); err != nil { log.Printf("Unable to raise open file limit: %v", err) } } fsWatcher, err := fsnotify.NewWatcher() if err != nil { log.Println("Unable to start fs watcher: ", err) return } defer fsWatcher.Close() // Add all directories in the mailbox to the watcher for _, dir := range []string{mailbox.DIR_INBOX, mailbox.DIR_OUTBOX, mailbox.DIR_SENT, mailbox.DIR_ARCHIVE} { p := path.Join(mbox.MBoxPath, dir) debug.Printf("Adding '%s' to fs watcher", p) if err := fsWatcher.Add(p); err != nil { log.Printf("Unable to add path '%s' to fs watcher: %v", p, err) } } // Listen for filesystem events and broadcast updates to all clients for { select { case <-ctx.Done(): return case e := <-fsWatcher.Events: if e.Op == fsnotify.Chmod { continue } // Make sure we don't send many of these events over a short period. drainUntilSilence(fsWatcher, 100*time.Millisecond) w.WriteJSON(struct { UpdateMailbox bool }{true}) case err := <-fsWatcher.Errors: log.Println(err) } } } // Handle adds a new websocket to the hub // // It will block until the client either stops responding or closes the connection. func (w *WSHub) Handle(conn *websocket.Conn) { debug.Printf("ws[%s] subscribed", conn.RemoteAddr()) c := &WSConn{ conn: conn, out: make(chan interface{}, 1), } w.mu.Lock() w.pool[c] = struct{}{} w.mu.Unlock() // Initial status update // (broadcasted as it includes info to other clients about this new one) w.UpdateStatus() quit := w.wsReadLoop(conn) // Disconnect and remove client when this handler returns. defer func() { debug.Printf("ws[%s] unsubscribing...", conn.RemoteAddr()) c.conn.Close() w.mu.Lock() delete(w.pool, c) w.mu.Unlock() w.UpdateStatus() debug.Printf("ws[%s] unsubscribed", conn.RemoteAddr()) }() lines, done, err := tailFile(w.Options().LogPath) if err != nil { log.Println(err) return } defer close(done) ticker := time.NewTicker(KeepaliveInterval) defer ticker.Stop() for { var err error c.conn.SetWriteDeadline(time.Time{}) select { case <-ticker.C: debug.Printf("ws[%s] ping", conn.RemoteAddr()) c.conn.SetWriteDeadline(time.Now().Add(5 * time.Second)) err = c.conn.WriteJSON(struct { Ping bool }{true}) case line := <-lines: c.conn.SetWriteDeadline(time.Now().Add(5 * time.Second)) err = c.conn.WriteJSON(struct { LogLine string }{string(line)}) case v := <-c.out: c.conn.SetWriteDeadline(time.Now().Add(5 * time.Second)) err = c.conn.WriteJSON(v) case <-quit: // The read loop failed/disconnected. Abort. return } if err != nil { debug.Printf("ws[%s] write error: %v", conn.RemoteAddr(), err) return } } } // drainEvents reads from w.Events and blocks until the channel has been silent for at least 50 ms. func drainUntilSilence(w *fsnotify.Watcher, silenceDur time.Duration) { timer := time.NewTimer(silenceDur) defer timer.Stop() for { select { case <-w.Events: if !timer.Stop() { <-timer.C } timer.Reset(silenceDur) case <-timer.C: return } } } // Expects the file to never get renamed/truncated or deleted func tailFile(path string) (<-chan []byte, chan<- struct{}, error) { lines := make(chan []byte) done := make(chan struct{}) file, err := os.Open(path) if err != nil { return nil, nil, err } go func() { rd := bufio.NewReader(file) for { data, _, err := rd.ReadLine() if errors.Is(err, io.EOF) { time.Sleep(time.Millisecond * 100) continue } select { case <-done: file.Close() return case lines <- data: } } }() return lines, done, nil } func (w *WSHub) handleWSMessage(v map[string]json.RawMessage) { raw, ok := v["prompt_response"] if !ok { return } var resp app.PromptResponse json.Unmarshal(raw, &resp) w.PromptHub().Respond(resp.ID, resp.Value, resp.Err) } func (w *WSHub) wsReadLoop(c *websocket.Conn) <-chan struct{} { quit := make(chan struct{}) go func() { for { v := map[string]json.RawMessage{} // We should at least get a ping response once per KeepaliveInterval. c.SetReadDeadline(time.Now().Add(KeepaliveInterval + 10*time.Second)) err := c.ReadJSON(&v) if err != nil { debug.Printf("ws[%s] read error: %v", c.RemoteAddr(), err) close(quit) return } if _, ok := v["Pong"]; ok { // That's the Ping response. debug.Printf("ws[%s] pong", c.RemoteAddr()) continue } go w.handleWSMessage(v) } }() return quit } pat-1.0.0/app/ 0000775 0000000 0000000 00000000000 15203222376 0013056 5 ustar 00root root 0000000 0000000 pat-1.0.0/app/account_activation.go 0000664 0000000 0000000 00000007366 15203222376 0017276 0 ustar 00root root 0000000 0000000 package app import ( "context" "errors" "regexp" "strings" "time" "github.com/la5nta/pat/internal/cmsapi" "github.com/la5nta/pat/internal/debug" "github.com/la5nta/wl2k-go/fbb" ) func (a *App) promptUnconfirmedAccount() (confirmed bool) { accountConfirmed := func() bool { ctx, cancel := context.WithTimeout(context.TODO(), 10*time.Second) defer cancel() exists, err := cmsapi.AccountExists(ctx, a.options.MyCall) switch { case err != nil: // API is unavailable. Use heuristic method based on message count. debug.Printf("Using heuristic method. API call failed: %v", err) if a.Mailbox().InboxCount() != 0 || a.Mailbox().SentCount() != 0 || a.Mailbox().ArchiveCount() != 0 { return true } case exists: // API confirmed active account. debug.Printf("API confirmed active account") return true } debug.Printf("Unable to confirm active account. Prompting user...") resp := <-a.promptHub.Prompt( context.Background(), 2*time.Minute, PromptKindPreAccountActivation, "Winlink Account activation", ) return resp.Value == "confirmed" } debug.Printf("Checking for active Winlink account...") err := DoIfElapsed(a.options.MyCall, "account-confirmed", 100*24*time.Hour, func() error { if accountConfirmed() { return nil // Account is confirmed. Persist state with TTL. } return errors.New("account not confirmed") }) debug.Printf("Account confirmation error: %v", err) return err == nil || err == ErrRateLimited } func isServiceMessage(m *fbb.Message) bool { return m.From().EqualString("SERVICE") } func isAccountActivation(from fbb.Address, subject string) bool { return from.EqualString("SERVICE") && strings.EqualFold(strings.TrimSpace(subject), "Your New Winlink Account") } var ( reSentenceSplit = regexp.MustCompile(`[.!?]`) rePassword = regexp.MustCompile("['\"`]([a-zA-Z0-9]{6,12})['\"`]") ) func isAccountActivationMessage(m *fbb.Message) (t bool, password string) { if !isAccountActivation(m.From(), m.Subject()) { return false, "" } body, _ := m.Body() // Search the message for a sentence that includes the word "password" and // contains a quoted string of 6-12 alphanumeric characters that is not the // users callsign. sentences := reSentenceSplit.Split(body, -1) for _, sentence := range sentences { if !strings.Contains(strings.ToLower(sentence), "password") { continue } matches := rePassword.FindStringSubmatch(sentence) if len(matches) > 1 && matches[1] != m.To()[0].String() { return true, matches[1] } } return true, "" // Is activation message, but no password was identified. } func mockNewAccountMsg() *fbb.Message { m := fbb.NewMessage(fbb.Private, "SERVICE") m.AddTo("LA5NTA") m.SetSubject("Your New Winlink Account") m.SetBody(`A new Winlink account for 'LA5NTA' has been activated. The next time you connect to a Winlink server or gateway you will be required to use 'K1CHN7' as your account password (no quotes). In Winlink Express you'll find the option for configuring your password under "Winlink Express Setup" in the "Files" menu. In Airmail it is called the "Radio Password" and is on the "Tools | Options | Settings" Tab. For other programs, consult the appropriate documentation or help file. You can manage your Winlink account (to include changing your password) by logging on to the Winlink web site at https://www.winlink.org. It is important that you establish a password recovery address as well! This address is used to send you your password if you happen to forget it. You can manage your password recovery address either at the Winlink web site or by sending an OPTIONS message to SYSTEM. See WL2K_Help category, item USER_OPTIONS for details. Please print and save this message in case you forget your password. Thanks for using Winlink.`) return m } pat-1.0.0/app/account_activation_test.go 0000664 0000000 0000000 00000001023 15203222376 0020315 0 ustar 00root root 0000000 0000000 // Copyright 2021 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 app import "testing" func TestIsAccountActivationMessage(t *testing.T) { msg := mockNewAccountMsg() isActivation, password := isAccountActivationMessage(msg) if !isActivation { t.Errorf("Expected isActivation to be true, but was false") } if password != "K1CHN7" { t.Errorf("Expected password to be 'K1CHN7', but was '%s'", password) } } pat-1.0.0/app/app.go 0000664 0000000 0000000 00000033307 15203222376 0014173 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 app implements the core functionality shared by cli and api. package app import ( "context" "crypto/sha1" "encoding/json" "fmt" "io" "log" "net" "os" "path/filepath" "sort" "strings" "time" "github.com/harenber/ptc-go/v2/pactor" "github.com/la5nta/pat/api/types" "github.com/la5nta/pat/cfg" "github.com/la5nta/pat/internal/buildinfo" "github.com/la5nta/pat/internal/debug" "github.com/la5nta/pat/internal/directories" "github.com/la5nta/pat/internal/forms" "github.com/la5nta/pat/internal/propagation" "github.com/la5nta/wl2k-go/fbb" "github.com/la5nta/wl2k-go/mailbox" "github.com/la5nta/wl2k-go/rigcontrol/hamlib" "github.com/la5nta/wl2k-go/transport" "github.com/la5nta/wl2k-go/transport/ardop" "github.com/la5nta/wl2k-go/transport/ax25" "github.com/la5nta/wl2k-go/transport/ax25/agwpe" "github.com/n8jja/Pat-Vara/vara" ) const ( MethodArdop = "ardop" MethodTelnet = "telnet" MethodPactor = "pactor" MethodVaraHF = "varahf" MethodVaraFM = "varafm" MethodAX25 = "ax25" MethodAX25AGWPE = MethodAX25 + "+agwpe" MethodAX25Linux = MethodAX25 + "+linux" MethodAX25SerialTNC = MethodAX25 + "+serial-tnc" // TODO: Remove after some release cycles (2023-05-21) MethodSerialTNCDeprecated = "serial-tnc" ) type Options struct { IgnoreBusy bool // Move to connect? SendOnly bool // Move to connect? RadioOnly bool Robust bool MyCall string Listen string MailboxPath string ConfigPath string PrehooksPath string LogPath string EventLogPath string FormsPath string } type App struct { options Options config cfg.Config OnReload func() error mbox *mailbox.DirHandler formsMgr *forms.Manager exchangeChan chan ex // The channel that the exchange loop is listening on exchangeConn net.Conn // Pointer to the active session connection (exchange) dialing *transport.URL // The connect URL currently being dialed (if any) dialCancelFunc func() // Context cancellation function for aborting while dialing. listenHub *ListenerHub promptHub *PromptHub websocketHub WSHub // Persistent modem connections ardop *ardop.TNC agwpe *agwpe.TNCPort pactor *pactor.Modem varaHF *vara.Modem varaFM *vara.Modem rigs map[string]rig predictor propagation.Predictor eventLog *EventLogger termWriter io.WriteCloser // termWriter writes to both stdout and the log file (web gui echoes log file) } // A rig holds a VFO and a closer for the underlying rig connection. type rig struct { hamlib.VFO io.Closer } func New(opts Options) *App { opts.MailboxPath = filepath.Clean(opts.MailboxPath) opts.FormsPath = filepath.Clean(opts.FormsPath) opts.ConfigPath = filepath.Clean(opts.ConfigPath) opts.LogPath = filepath.Clean(opts.LogPath) opts.EventLogPath = filepath.Clean(opts.EventLogPath) return &App{options: opts, websocketHub: noopWSSocket{}} } func (a *App) Mailbox() *mailbox.DirHandler { return a.mbox } func (a *App) FormsManager() *forms.Manager { return a.formsMgr } func (a *App) Config() cfg.Config { return a.config } func (a *App) Options() Options { return a.options } func (a *App) PromptHub() *PromptHub { return a.promptHub } func (a *App) Reload() error { return a.OnReload() } func (a *App) VFOForRig(rig string) (hamlib.VFO, bool) { r, ok := a.rigs[rig]; return r, ok } // Locator implements forms.LocatorProvider func (a *App) Locator() string { return a.config.Locator } func (a *App) VFOForTransport(transport string) (vfo hamlib.VFO, rigName string, ok bool, err error) { var rig string switch { case transport == MethodArdop: rig = a.config.Ardop.Rig case transport == MethodAX25, strings.HasPrefix(transport, MethodAX25+"+"): rig = a.config.AX25.Rig case transport == MethodPactor: rig = a.config.Pactor.Rig case transport == MethodVaraHF: rig = a.config.VaraHF.Rig case transport == MethodVaraFM: rig = a.config.VaraFM.Rig default: return vfo, "", false, fmt.Errorf("not supported with transport '%s'", transport) } if rig == "" { return vfo, "", false, fmt.Errorf("missing rig reference in config section for %s", transport) } vfo, ok = a.VFOForRig(rig) return vfo, rig, ok, nil } func (a *App) EnableWebSocket(ctx context.Context, wsHub WSHub) error { a.websocketHub = wsHub a.promptHub.AddPrompter(wsHub) return nil } func (a *App) Run(ctx context.Context, cmd Command, args []string) { debug.Printf("Version: %s", buildinfo.VersionString()) debug.Printf("Command: %s %v", cmd.Str, args) debug.Printf("Mailbox dir is\t'%s'", a.options.MailboxPath) debug.Printf("Forms dir is\t'%s'", a.options.FormsPath) debug.Printf("Config file is\t'%s'", a.options.ConfigPath) debug.Printf("Log file is \t'%s'", a.options.LogPath) debug.Printf("Event log file is\t'%s'", a.options.EventLogPath) directories.MigrateLegacyDataDir() a.listenHub = NewListenerHub(a) a.listenHub.websocketHub = a.websocketHub a.promptHub = NewPromptHub() // Skip initialization for some commands switch cmd.Str { case "configure", "version": cmd.HandleFunc(ctx, a, args) return } // Enable the GZIP extension experiment by default if _, ok := os.LookupEnv("GZIP_EXPERIMENT"); !ok { os.Setenv("GZIP_EXPERIMENT", "1") } os.Setenv("PATH", fmt.Sprintf(`%s%c%s`, a.options.PrehooksPath, os.PathListSeparator, os.Getenv("PATH"))) // Parse configuration file var err error a.config, err = LoadConfig(a.options.ConfigPath, cfg.DefaultConfig) if err != nil { log.Fatalf("Unable to load/write config: %s", err) } // Initialize logger f, err := os.Create(a.options.LogPath) if err != nil { log.Fatalf("Unable to create log file at %s: %v", a.options.LogPath, err) } a.termWriter = struct { io.Writer io.Closer }{io.MultiWriter(f, os.Stdout), f} log.SetOutput(io.MultiWriter(f, os.Stderr)) // web gui echoes the log file a.eventLog, err = NewEventLogger(a.options.EventLogPath) if err != nil { log.Fatal("Unable to open event log file:", err) } // Read command line options from config if unset if a.options.MyCall == "" && a.config.MyCall == "" { fmt.Fprint(os.Stderr, "Missing mycall\n") if cmd.Str != "http" { os.Exit(1) } } else if a.options.MyCall == "" { a.options.MyCall = a.config.MyCall } // Ensure mycall is all upper case. a.options.MyCall = strings.ToUpper(a.options.MyCall) // Don't use config password if we don't use config mycall if !strings.EqualFold(a.options.MyCall, a.config.MyCall) { a.config.SecureLoginPassword = "" } if a.options.Listen == "" && len(a.config.Listen) > 0 { a.options.Listen = strings.Join(a.config.Listen, ",") } // Initialize HF prediction engine (VOACAP) switch p := a.config.Prediction; p.Engine { case cfg.PredictionEngineVOACAP, cfg.PredictionEngineAuto: voacap, err := propagation.NewVOACAPPredictor(p.VOACAP.Executable, p.VOACAP.DataDir) if err != nil { // Only log error if engine is set explicitly if p.Engine == cfg.PredictionEngineVOACAP { log.Println("Failed to initialize VOACAP:", err) } else { debug.Printf("Failed to initialize VOACAP: %v", err) } break } debug.Printf("Prediction engine: %s (%q)", p.Engine, voacap.Version()) a.predictor = propagation.WithCaching(voacap) case cfg.PredictionEngineVOACAPAPI: voacap := propagation.NewVOACAPAPIPredictor(p.VOACAPAPI.BaseURL) debug.Printf("Prediction engine: %s (%q)", p.Engine, voacap.Version()) a.predictor = propagation.WithCaching(voacap) } // init forms subsystem a.formsMgr = forms.NewManager(forms.Config{ FormsPath: a.options.FormsPath, SequencePath: filepath.Join(directories.StateDir(), "template-sequence-number.json"), SequenceFormat: "%03d", MyCall: a.options.MyCall, AppVersion: buildinfo.AppName + " " + buildinfo.VersionStringShort(), UserAgent: buildinfo.UserAgent(), GPSd: a.config.GPSd, LocatorProvider: a, }) // Load the mailbox handler a.mbox = mailbox.NewDirHandler( filepath.Join(a.options.MailboxPath, a.options.MyCall), a.options.SendOnly, ) // Ensure the mailbox handler is ready if err := a.mbox.Prepare(); err != nil { log.Fatal(err) } if cmd.MayConnect { a.loadHamlibRigs(a.config.HamlibRigs) a.exchangeChan = a.exchangeLoop(ctx) go func() { if a.config.VersionReportingDisabled { return } for { a.postVersionUpdate() // 24 hour hold on success a.checkPasswordRecoveryEmailIsSet(ctx) // 14 day hold on success select { case <-time.After(6 * time.Hour): // Retry every 6 hours case <-ctx.Done(): return } } }() } if cmd.LongLived { if a.options.Listen != "" { a.Listen(a.options.Listen) } if a.config.GPSd.UpdateLocator { go a.gpsdLocatorUpdater(ctx) } } // Start command execution cmd.HandleFunc(ctx, a, args) } type Heard struct { Callsign string `json:"callsign"` Time time.Time `json:"time"` } func (a *App) ActiveListeners() []string { slice := []string{} for _, tl := range a.listenHub.Active() { slice = append(slice, tl.Name()) } sort.Strings(slice) return slice } func (a *App) Heard() map[string][]Heard { heard := make(map[string][]Heard) if a.ardop != nil { for callsign, time := range a.ardop.Heard() { heard[MethodArdop] = append(heard[MethodArdop], Heard{ Callsign: callsign, Time: time, }) } } if ax25, err := ax25.Heard(a.Config().AX25Linux.Port); err == nil { for callsign, time := range ax25 { heard[MethodAX25Linux] = append(heard[MethodAX25Linux], Heard{ Callsign: callsign, Time: time, }) } } return heard } func (a *App) GetStatus() types.Status { configHash := func(c cfg.Config) string { h := sha1.New() if err := json.NewEncoder(h).Encode(c); err != nil { panic(err) } return fmt.Sprintf("%x", h.Sum(nil)) } status := types.Status{ ActiveListeners: a.ActiveListeners(), Dialing: a.dialing != nil, Connected: a.exchangeConn != nil, HTTPClients: a.websocketHub.ClientAddrs(), ConfigHash: configHash(a.config), } if a.exchangeConn != nil { addr := a.exchangeConn.RemoteAddr() status.RemoteAddr = fmt.Sprintf("%s:%s", addr.Network(), addr) } return status } func (a *App) Close() { debug.Printf("Starting cleanup") defer func() { debug.Printf("Cleanup done") if a.termWriter != nil { a.termWriter.Close() } }() debug.Printf("Closing active connection and/or listeners") a.AbortActiveConnection(false) a.listenHub.Close() debug.Printf("Closing modems") if a.ardop != nil { if err := a.ardop.Close(); err != nil { log.Printf("Failure to close ardop TNC: %s", err) } } if a.pactor != nil { if err := a.pactor.Close(); err != nil { log.Printf("Failure to close pactor modem: %s", err) } } if a.varaFM != nil { if err := a.varaFM.Close(); err != nil { log.Printf("Failure to close varafm modem: %s", err) } } if a.varaHF != nil { if err := a.varaHF.Close(); err != nil { log.Printf("Failure to close varahf modem: %s", err) } } if a.agwpe != nil { if err := a.agwpe.Close(); err != nil { log.Printf("Failure to close AGWPE TNC: %s", err) } } // Close rigs debug.Printf("Closing rigs") for name, r := range a.rigs { if err := r.Close(); err != nil { log.Printf("Failure to close rig %s: %s", name, err) } } a.promptHub.Close() a.websocketHub.Close() a.eventLog.Close() a.formsMgr.Close() } func (a *App) onServiceMessageReceived(msg *fbb.Message) { // Recover any panic here, as we really REALLY don't want the user to lose system messages due to panics. defer func() { if r := recover(); r != nil { log.Println(r) } }() // Write all service messages to the log body, _ := msg.Body() subject := msg.Subject() fmt.Fprintln(a.termWriter) fmt.Fprintln(a.termWriter, strings.Repeat("=", (60-len(subject))/2), subject, strings.Repeat("=", (60-len(subject))/2)) fmt.Fprintln(a.termWriter, strings.TrimSpace(body)) fmt.Fprintln(a.termWriter, strings.Repeat("=", 62)) fmt.Fprintln(a.termWriter) // Handle account activation email if isActivation, password := isAccountActivationMessage(msg); isActivation && password != "" { fmt.Fprintln(a.termWriter, "DO NOT LOSE YOUR PASSWORD:", password) fmt.Fprintln(a.termWriter) } } func (a *App) loadHamlibRigs(rigsConfig map[string]cfg.HamlibConfig) { a.rigs = make(map[string]rig, len(rigsConfig)) for name, conf := range rigsConfig { if conf.Address == "" { log.Printf("Missing address-field for rig '%s', skipping.", name) continue } if conf.Network == "" { conf.Network = "tcp" } r, err := hamlib.Open(conf.Network, conf.Address) if err != nil { log.Printf("Initialization hamlib rig %s failed: %s.", name, err) continue } var vfo hamlib.VFO switch strings.ToUpper(conf.VFO) { case "A", "VFOA": vfo, err = r.VFOA() case "B", "VFOB": vfo, err = r.VFOB() case "": vfo = r.CurrentVFO() default: log.Printf("Cannot load rig '%s': Unrecognized VFO identifier '%s'", name, conf.VFO) r.Close() // Close rig if we can't use it continue } if err != nil { log.Printf("Cannot load rig '%s': Unable to select VFO: %s", name, err) r.Close() // Close rig if we can't use it continue } f, err := vfo.GetFreq() if err != nil { log.Printf("Unable to get frequency from rig %s: %s.", name, err) } else { log.Printf("%s ready. Dial frequency is %s.", name, Frequency(f)) } a.rigs[name] = rig{VFO: vfo, Closer: r} } } func (a *App) SetConnectAliases(aliases map[string]string) error { onDisk, err := LoadConfig(a.options.ConfigPath, cfg.DefaultConfig) if err != nil { return err } onDisk.ConnectAliases = aliases if err := WriteConfig(onDisk, a.options.ConfigPath); err != nil { return err } a.config.ConnectAliases = aliases return nil } pat-1.0.0/app/attachment.go 0000664 0000000 0000000 00000003261 15203222376 0015537 0 ustar 00root root 0000000 0000000 package app import ( "bytes" "image" "image/jpeg" "io" "log" "mime" "path" "path/filepath" "strings" "github.com/la5nta/wl2k-go/fbb" "github.com/nfnt/resize" ) func AddAttachment(msg *fbb.Message, filename string, contentType string, r io.Reader) error { p, err := io.ReadAll(r) if err != nil { return err } if ok, mediaType := isConvertableImageMediaType(filename, contentType); ok { log.Printf("Auto converting '%s' [%s]...", filename, mediaType) if converted, err := convertImage(p); err != nil { log.Printf("Error converting image: %s", err) } else { log.Printf("Done converting '%s'.", filename) ext := filepath.Ext(filename) filename = filename[:len(filename)-len(ext)] + ".jpg" p = converted } } msg.AddFile(fbb.NewFile(filename, p)) return nil } func isConvertableImageMediaType(filename, contentType string) (convertable bool, mediaType string) { if contentType != "" { mediaType, _, _ = mime.ParseMediaType(contentType) } if mediaType == "" { mediaType = mime.TypeByExtension(path.Ext(filename)) } switch mediaType { case "image/svg+xml": // This is a text file return false, mediaType default: return strings.HasPrefix(mediaType, "image/"), mediaType } } func convertImage(orig []byte) ([]byte, error) { img, _, err := image.Decode(bytes.NewReader(orig)) if err != nil { return nil, err } // Scale down if img.Bounds().Dx() > 600 { img = resize.Resize(600, 0, img, resize.NearestNeighbor) } // Re-encode as low quality jpeg var buf bytes.Buffer if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: 40}); err != nil { return orig, err } if buf.Len() >= len(orig) { return orig, nil } return buf.Bytes(), nil } pat-1.0.0/app/command.go 0000664 0000000 0000000 00000001750 15203222376 0015026 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 app import ( "context" "fmt" "os" "strings" ) var ErrNoCmd = fmt.Errorf("no cmd") type Command struct { Str string Aliases []string Desc string HandleFunc func(ctx context.Context, app *App, args []string) Usage string Options map[string]string Example string LongLived bool MayConnect bool } func (cmd Command) PrintUsage() { fmt.Fprintf(os.Stderr, "%s - %s\n", cmd.Str, cmd.Desc) fmt.Fprintf(os.Stderr, "\nUsage:\n %s %s\n", cmd.Str, strings.TrimSpace(cmd.Usage)) if len(cmd.Options) > 0 { fmt.Fprint(os.Stderr, "\nOptions:\n") for f, desc := range cmd.Options { fmt.Fprintf(os.Stderr, " %-17s %s\n", f, desc) } } if cmd.Example != "" { fmt.Fprintf(os.Stderr, "\nExample:\n %s\n", strings.TrimSpace(cmd.Example)) } fmt.Fprint(os.Stderr, "\n") } pat-1.0.0/app/config.go 0000664 0000000 0000000 00000012767 15203222376 0014667 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 app import ( "encoding/json" "fmt" "log" "os" "path" "strings" "github.com/kelseyhightower/envconfig" "github.com/la5nta/pat/cfg" "github.com/la5nta/pat/internal/buildinfo" ) func LoadConfig(cfgPath string, fallback cfg.Config) (config cfg.Config, err error) { config, err = ReadConfig(cfgPath) switch { case os.IsNotExist(err): config = fallback if err := WriteConfig(config, cfgPath); err != nil { return config, err } case err != nil: return config, err } // Environment variables overrides values from the config file if err := envconfig.Process(buildinfo.AppName, &config); err != nil { return config, err } // Environment variables for hamlib rigs (custom syntax not handled by envconfig) if err := readRigsFromEnv(&config.HamlibRigs); err != nil { return config, err } // Ensure the alias "telnet" exists if config.ConnectAliases == nil { config.ConnectAliases = make(map[string]string) } if _, exists := config.ConnectAliases["telnet"]; !exists { config.ConnectAliases["telnet"] = cfg.DefaultConfig.ConnectAliases["telnet"] } // TODO: Remove after some release cycles (2023-05-21) // Rewrite deprecated serial-tnc:// aliases to ax25-serial-tnc:// var deprecatedAliases []string for k, v := range config.ConnectAliases { if !strings.HasPrefix(v, MethodSerialTNCDeprecated+"://") { continue } deprecatedAliases = append(deprecatedAliases, k) config.ConnectAliases[k] = strings.Replace(v, MethodSerialTNCDeprecated, MethodAX25SerialTNC, 1) } if len(deprecatedAliases) > 0 { log.Printf("Alias(es) %s uses deprecated transport scheme %s://. Please use %s:// instead.", strings.Join(deprecatedAliases, ", "), MethodSerialTNCDeprecated, MethodAX25SerialTNC) } // Ensure ServiceCodes has a default value if len(config.ServiceCodes) == 0 { config.ServiceCodes = cfg.DefaultConfig.ServiceCodes } // Ensure we have a default AX.25 engine if config.AX25.Engine == "" { config.AX25.Engine = cfg.DefaultAX25Engine() } // Ensure we have a default AGWPE config if config.AGWPE == (cfg.AGWPEConfig{}) { config.AGWPE = cfg.DefaultConfig.AGWPE } // Enforce minimum beacon intervals if config.Ardop.BeaconInterval > 0 && config.Ardop.BeaconInterval < 10 { config.Ardop.BeaconInterval = 10 } if config.AX25.Beacon.Every > 0 && config.AX25.Beacon.Every < 10 { config.AX25.Beacon.Every = 10 } // Ensure we have a default AX.25 Linux config if config.AX25Linux == (cfg.AX25LinuxConfig{}) { config.AX25Linux = cfg.DefaultConfig.AX25Linux } // TODO: Remove after some release cycles (2023-04-30) if v := config.AX25.AXPort; v != "" && v != config.AX25Linux.Port { log.Println("Using deprecated configuration option ax25.port. Please set ax25_linux.port instead.") config.AX25Linux.Port = v } // Ensure Pactor has a default value if config.Pactor == (cfg.PactorConfig{}) { config.Pactor = cfg.DefaultConfig.Pactor } // Ensure VARA FM and VARA HF has default values if config.VaraHF.IsZero() { config.VaraHF = cfg.DefaultConfig.VaraHF } if config.VaraFM.IsZero() { config.VaraFM = cfg.DefaultConfig.VaraFM } // Ensure GPSd has a default value if config.GPSd == (cfg.GPSdConfig{}) { config.GPSd = cfg.DefaultConfig.GPSd } // Ensure SerialTNC has a default hbaud and serialbaud if config.SerialTNC.HBaud == 0 { config.SerialTNC.HBaud = cfg.DefaultConfig.SerialTNC.HBaud } if config.SerialTNC.SerialBaud == 0 { config.SerialTNC.SerialBaud = cfg.DefaultConfig.SerialTNC.SerialBaud } // Compatibility for old type default 'Kenwood' (should be 'kenwood') if v := config.SerialTNC.Type; v == "Kenwood" { config.SerialTNC.Type = strings.ToLower(v) } // Ensure ARDOP.ConnectRequests has a default value if config.Ardop.ConnectRequests == 0 { config.Ardop.ConnectRequests = cfg.DefaultConfig.Ardop.ConnectRequests } return config, nil } // readRigsFromEnv reads hamlib rigs config from environment. // Syntax: PAT_HAMLIB_RIGS_{rig name}_{ATTRIBUTE} // _{ATTRIBUTE} is optional (defaults to _ADDRESS). // Examples: // - PAT_HAMLIB_RIGS_rig1_NETWORK=tcp // - PAT_HAMLIB_RIGS_rig1_ADDRESS=localhost:8080 // - PAT_HAMLIB_RIGS_rig1_VFO=A // - PAT_HAMLIB_RIGS_rig2=localhost:8080 func readRigsFromEnv(rigs *map[string]cfg.HamlibConfig) error { prefix := strings.ToUpper(buildinfo.AppName) + "_HAMLIB_RIGS_" for _, env := range os.Environ() { attribute, value, _ := strings.Cut(env, "=") if !strings.HasPrefix(attribute, prefix) { continue } attribute = strings.TrimPrefix(attribute, prefix) name, attribute, _ := strings.Cut(attribute, "_") if *rigs == nil { *rigs = make(map[string]cfg.HamlibConfig) } rig := (*rigs)[name] switch attribute { case "ADDRESS", "": rig.Address = value case "NETWORK": rig.Network = value case "VFO": rig.VFO = value default: return fmt.Errorf("invalid attribute '%s' for rig '%s'", attribute, name) } (*rigs)[name] = rig } return nil } func ReadConfig(path string) (config cfg.Config, err error) { data, err := os.ReadFile(path) if err != nil { return } err = json.Unmarshal(data, &config) return } func WriteConfig(config cfg.Config, filePath string) error { b, err := json.MarshalIndent(config, "", " ") if err != nil { return err } // Add trailing new-line b = append(b, '\n') // Ensure path dir is available os.Mkdir(path.Dir(filePath), os.ModePerm|os.ModeDir) return os.WriteFile(filePath, b, 0o600) } pat-1.0.0/app/config_test.go 0000664 0000000 0000000 00000003007 15203222376 0015711 0 ustar 00root root 0000000 0000000 package app import ( "os" "strings" "testing" "github.com/la5nta/pat/cfg" ) func TestReadRigsFromEnv(t *testing.T) { const prefix = "PAT_HAMLIB_RIGS" unset := func() { for _, env := range os.Environ() { key, _, _ := strings.Cut(env, "=") if strings.HasPrefix(key, prefix) { os.Unsetenv(key) } } } t.Run("simple", func(t *testing.T) { defer unset() var rigs map[string]cfg.HamlibConfig os.Setenv(prefix+"_rig", "localhost:4532") if err := readRigsFromEnv(&rigs); err != nil { t.Fatal(err) } if got := rigs["rig"]; (got != cfg.HamlibConfig{Address: "localhost:4532"}) { t.Fatalf("Got unexpected config: %#v", got) } }) t.Run("with VFO", func(t *testing.T) { defer unset() var rigs map[string]cfg.HamlibConfig os.Setenv(prefix+"_rig", "localhost:4532") os.Setenv(prefix+"_rig_VFO", "A") if err := readRigsFromEnv(&rigs); err != nil { t.Fatal(err) } if got := rigs["rig"]; (got != cfg.HamlibConfig{Address: "localhost:4532", VFO: "A"}) { t.Fatalf("Got unexpected config: %#v", got) } }) t.Run("full", func(t *testing.T) { defer unset() var rigs map[string]cfg.HamlibConfig os.Setenv(prefix+"_rig_ADDRESS", "/dev/ttyS0") os.Setenv(prefix+"_rig_NETWORK", "serial") os.Setenv(prefix+"_rig_VFO", "B") if err := readRigsFromEnv(&rigs); err != nil { t.Fatal(err) } expect := cfg.HamlibConfig{ Address: "/dev/ttyS0", Network: "serial", VFO: "B", } if got := rigs["rig"]; got != expect { t.Fatalf("Got unexpected config: %#v", got) } }) } pat-1.0.0/app/connect.go 0000664 0000000 0000000 00000026336 15203222376 0015050 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 app import ( "context" "errors" "fmt" "log" "os" "strconv" "strings" "time" "github.com/la5nta/pat/cfg" "github.com/la5nta/pat/internal/buildinfo" "github.com/la5nta/pat/internal/debug" "github.com/la5nta/pat/internal/prehook" "github.com/harenber/ptc-go/v2/pactor" "github.com/la5nta/wl2k-go/transport" "github.com/la5nta/wl2k-go/transport/ardop" "github.com/la5nta/wl2k-go/transport/ax25/agwpe" "github.com/n8jja/Pat-Vara/vara" // Register stateless dialers _ "github.com/la5nta/wl2k-go/transport/ax25" _ "github.com/la5nta/wl2k-go/transport/telnet" ) func hasSSID(str string) bool { return strings.Contains(str, "-") } func (a *App) Connect(connectStr string) (success bool) { if connectStr == "" { return false } else if aliased, ok := a.config.ConnectAliases[connectStr]; ok { return a.Connect(aliased) } // Replace placeholders connectStr = strings.ReplaceAll(connectStr, cfg.PlaceholderMycall, a.options.MyCall) // Prompt if Winlink account is unconfirmed if confirmed := a.promptUnconfirmedAccount(); !confirmed { return false } // Hack around bug in frontend which may occur if the status updates too quickly. if a.websocketHub.NumClients() > 0 { defer func() { time.Sleep(time.Second); a.websocketHub.UpdateStatus() }() } debug.Printf("connectStr: %s", connectStr) url, err := transport.ParseURL(connectStr) if err != nil { log.Println(err) return false } // TODO: Remove after some release cycles (2023-05-21) // Rewrite legacy serial-tnc scheme. if url.Scheme == MethodSerialTNCDeprecated { log.Printf("Transport scheme %s:// is deprecated, use %s:// instead.", MethodSerialTNCDeprecated, MethodAX25SerialTNC) url.Scheme = MethodAX25SerialTNC } // Rewrite the generic ax25:// scheme to use a specified AX.25 engine. if url.Scheme == MethodAX25 { url.Scheme = a.defaultAX25Method() } // Init TNCs switch url.Scheme { case MethodAX25AGWPE: if err := a.initAGWPE(); err != nil { log.Println(err) return } case MethodArdop: if err := a.initARDOP(); err != nil { log.Println(err) return } case MethodPactor: ptCmdInit := "" if val, ok := url.Params["init"]; ok { ptCmdInit = strings.Join(val, "\n") } if err := a.initPACTOR(ptCmdInit); err != nil { log.Println(err) return } case MethodVaraHF: if err := a.initVARAHF(); err != nil { log.Println(err) return } case MethodVaraFM: if err := a.initVARAFM(); err != nil { log.Println(err) return } } // Set default userinfo (mycall) if url.User == nil { url.SetUser(a.options.MyCall) } // Set default host interface address if url.Host == "" { switch url.Scheme { case MethodAX25Linux: url.Host = a.config.AX25Linux.Port case MethodAX25SerialTNC: url.Host = a.config.SerialTNC.Path if hbaud := a.config.SerialTNC.HBaud; hbaud > 0 { url.Params.Set("hbaud", fmt.Sprint(hbaud)) } if sbaud := a.config.SerialTNC.SerialBaud; sbaud > 0 { url.Params.Set("serial_baud", fmt.Sprint(sbaud)) } } } // Radio Only? radioOnly := a.options.RadioOnly if v := url.Params.Get("radio_only"); v != "" { radioOnly, _ = strconv.ParseBool(v) } if radioOnly { if hasSSID(a.options.MyCall) { log.Println("Radio Only does not support callsign with SSID") return } if strings.HasPrefix(url.Scheme, MethodAX25) { log.Printf("Radio-Only is not available for %s", url.Scheme) return } url.SetUser(url.User.Username() + "-T") } // QSY var revertFreq func() if freq := url.Params.Get("freq"); freq != "" { revertFreq, err = a.qsy(url.Scheme, freq) if err != nil { log.Printf("Unable to QSY: %s", err) return } defer revertFreq() } var currFreq Frequency if vfo, _, ok, _ := a.VFOForTransport(url.Scheme); ok { f, _ := vfo.GetFreq() currFreq = Frequency(f) } ctx, cancel := context.WithCancel(context.Background()) a.dialCancelFunc = func() { a.dialing = nil; cancel() } defer a.dialCancelFunc() // Signal web gui that we are dialing a connection a.dialing = url a.websocketHub.UpdateStatus() prehookScript := prehook.Script{ Dir: a.options.PrehooksPath, File: url.Params.Get("prehook"), Args: url.Params["prehook-arg"], } if prehookScript.File != "" { if err := prehookScript.VerifyFile(); err != nil { log.Printf("invalid prehook: %s", err) return } } log.Printf("Connecting to %s (%s)...", url.Target, url.Scheme) conn, err := transport.DialURLContext(ctx, url) // Signal web gui that we are no longer dialing a.dialing = nil a.websocketHub.UpdateStatus() a.eventLog.LogConn("connect "+connectStr, currFreq, conn, err) switch { case errors.Is(err, context.Canceled): log.Printf("Connect cancelled") return case err != nil: log.Printf("Unable to establish connection to remote: %s", err) return } if prehookScript.File != "" { log.Println("Running prehook...") prehookScript.Env = append([]string{ buildinfo.AppName + "_DIAL_URL=" + connectStr, buildinfo.AppName + "_REMOTE_ADDR=" + conn.RemoteAddr().String(), buildinfo.AppName + "_LOCAL_ADDR=" + conn.LocalAddr().String(), }, append(os.Environ(), a.Env()...)...) conn = prehook.Wrap(conn) if err := prehookScript.Execute(ctx, conn); err != nil { conn.Close() log.Printf("Prehook script failed: %s", err) return } log.Println("Prehook succeeded") } err = a.exchange(conn, url.Target, false) if err != nil { log.Printf("Exchange failed: %s", err) } else { log.Println("Disconnected.") success = true } return } func (a *App) qsy(method, addr string) (revert func(), err error) { noop := func() {} rig, rigName, ok, err := a.VFOForTransport(method) if err != nil { return noop, err } else if !ok { return noop, fmt.Errorf("hamlib rig '%s' not loaded", rigName) } log.Printf("QSY %s: %s", method, addr) _, oldFreq, err := SetFreq(rig, addr) if err != nil { return noop, err } time.Sleep(3 * time.Second) return func() { time.Sleep(time.Second) log.Printf("QSX %s: %.3f", method, float64(oldFreq)/1e3) rig.SetFreq(oldFreq) }, nil } func (a *App) onBusyChannel(ctx context.Context) (abort bool) { if a.options.IgnoreBusy { log.Println("Ignoring busy channel!") return false } log.Println("Waiting for clear channel...") select { case <-ctx.Done(): // The channel is no longer busy. log.Println("Channel clear") return false case resp := <-a.promptHub.Prompt(ctx, 5*time.Minute, PromptKindBusyChannel, "Waiting for clear channel..."): return resp.Value == "abort" || resp.Err == context.DeadlineExceeded } } // ARDOP returns the initialized ARDOP modem, initializing it if necessary. func (a *App) ARDOP() (*ardop.TNC, error) { if err := a.initARDOP(); err != nil { return nil, err } return a.ardop, nil } func (a *App) initARDOP() error { if a.ardop != nil && a.ardop.Ping() == nil { return nil } if a.ardop != nil { a.ardop.Close() } var err error a.ardop, err = ardop.OpenTCP(a.config.Ardop.Addr, a.options.MyCall, a.config.Locator) if err != nil { return fmt.Errorf("ARDOP TNC initialization failed: %w", err) } a.ardop.SetBusyFunc(a.onBusyChannel) if !a.config.Ardop.ARQBandwidth.IsZero() { if err := a.ardop.SetARQBandwidth(a.config.Ardop.ARQBandwidth); err != nil { return fmt.Errorf("unable to set ARQ bandwidth for ardop TNC: %w", err) } } if err := a.ardop.SetCWID(a.config.Ardop.CWID); err != nil { return fmt.Errorf("unable to configure CWID for ardop TNC: %w", err) } if v, err := a.ardop.Version(); err != nil { return fmt.Errorf("ARDOP TNC initialization failed: %s", err) } else { log.Printf("ARDOP TNC (%s) initialized", v) } transport.RegisterDialer(MethodArdop, a.ardop) if !a.config.Ardop.PTTControl { return nil } rig, ok := a.rigs[a.config.Ardop.Rig] if !ok { return fmt.Errorf("unable to set PTT rig '%s': Not defined or not loaded", a.config.Ardop.Rig) } a.ardop.SetPTT(rig) return nil } func (a *App) initPACTOR(cmdlineinit string) error { if a.pactor != nil { a.pactor.Close() } var err error a.pactor, err = pactor.OpenModem(a.config.Pactor.Path, a.config.Pactor.Baudrate, a.options.MyCall, a.config.Pactor.InitScript, cmdlineinit) if err != nil || a.pactor == nil { return fmt.Errorf("pactor initialization failed: %w", err) } transport.RegisterDialer(MethodPactor, a.pactor) return nil } // VARAHF returns the initialized VARA HF modem, initializing it if necessary. func (a *App) VARAHF() (*vara.Modem, error) { if err := a.initVARAHF(); err != nil { return nil, err } return a.varaHF, nil } func (a *App) initVARAHF() error { if a.varaHF != nil && a.varaHF.Ping() { return nil } if a.varaHF != nil { a.varaHF.Close() } m, err := a.initVARA(MethodVaraHF, a.config.VaraHF) if err != nil { return err } if bw := a.config.VaraHF.Bandwidth; bw != 0 { if err := m.SetBandwidth(fmt.Sprint(bw)); err != nil { m.Close() return err } } a.varaHF = m return nil } // VARAFM returns the initialized VARA FM modem, initializing it if necessary. func (a *App) VARAFM() (*vara.Modem, error) { if err := a.initVARAFM(); err != nil { return nil, err } return a.varaFM, nil } func (a *App) initVARAFM() error { if a.varaFM != nil && a.varaFM.Ping() { return nil } if a.varaFM != nil { a.varaFM.Close() } m, err := a.initVARA(MethodVaraFM, a.config.VaraFM) if err != nil { return err } a.varaFM = m return nil } func (a *App) initVARA(scheme string, conf cfg.VaraConfig) (*vara.Modem, error) { vConf := vara.ModemConfig{ Host: conf.Host(), CmdPort: conf.CmdPort(), DataPort: conf.DataPort(), } m, err := vara.NewModem(scheme, a.options.MyCall, vConf) if err != nil { return nil, fmt.Errorf("vara initialization failed: %w", err) } transport.RegisterDialer(scheme, m) m.SetBusyFunc(a.onBusyChannel) if conf.PTTControl { rig, ok := a.rigs[conf.Rig] if !ok { m.Close() return nil, fmt.Errorf("unable to set PTT rig '%s': not defined or not loaded", conf.Rig) } m.SetPTT(rig) } v, _ := m.Version() log.Printf("VARA modem (%s) initialized", v) return m, nil } // AGWPE returns the initialized AGWPE TNC, initializing it if necessary. func (a *App) AGWPE() (*agwpe.TNCPort, error) { if err := a.initAGWPE(); err != nil { return nil, err } return a.agwpe, nil } func (a *App) initAGWPE() error { if a.agwpe != nil && a.agwpe.Ping() == nil { return nil } if a.agwpe != nil { a.agwpe.Close() } var err error a.agwpe, err = agwpe.OpenPortTCP(a.config.AGWPE.Addr, a.config.AGWPE.RadioPort, a.options.MyCall) if err != nil { return fmt.Errorf("AGWPE TNC initialization failed: %w", err) } if v, err := a.agwpe.Version(); err != nil { return fmt.Errorf("AGWPE TNC initialization failed: %w", err) } else { log.Printf("AGWPE TNC (%s) initialized", v) } transport.RegisterContextDialer(MethodAX25AGWPE, a.agwpe) return nil } // defaultAX25Method resolves the generic ax25:// scheme to a implementation specific scheme. func (a *App) defaultAX25Method() string { switch a.config.AX25.Engine { case cfg.AX25EngineAGWPE: return MethodAX25AGWPE case cfg.AX25EngineSerialTNC: return MethodAX25SerialTNC case cfg.AX25EngineLinux: return MethodAX25Linux default: panic(fmt.Sprintf("invalid ax25 engine: %s", a.config.AX25.Engine)) } } pat-1.0.0/app/env.go 0000664 0000000 0000000 00000002047 15203222376 0014200 0 ustar 00root root 0000000 0000000 package app import ( "os" "runtime" "github.com/la5nta/pat/internal/buildinfo" ) func (a *App) Env() []string { return []string{ `PAT_MYCALL="` + a.options.MyCall + `"`, `PAT_LOCATOR="` + a.config.Locator + `"`, `PAT_VERSION="` + buildinfo.Version + `"`, `PAT_ARCH="` + runtime.GOARCH + `"`, `PAT_OS="` + runtime.GOOS + `"`, `PAT_MAILBOX_PATH="` + a.options.MailboxPath + `"`, `PAT_CONFIG_PATH="` + a.options.ConfigPath + `"`, `PAT_LOG_PATH="` + a.options.LogPath + `"`, `PAT_EVENTLOG_PATH="` + a.options.EventLogPath + `"`, `PAT_FORMS_PATH="` + a.options.FormsPath + `"`, `PAT_DEBUG="` + os.Getenv("PAT_DEBUG") + `"`, `PAT_WEB_DEV_ADDR="` + os.Getenv("PAT_WEB_DEV_ADDR") + `"`, `ARDOP_DEBUG="` + os.Getenv("ARDOP_DEBUG") + `"`, `PACTOR_DEBUG="` + os.Getenv("PACTOR_DEBUG") + `"`, `AGWPE_DEBUG="` + os.Getenv("AGWPE_DEBUG") + `"`, `VARA_DEBUG="` + os.Getenv("VARA_DEBUG") + `"`, `GZIP_EXPERIMENT="` + os.Getenv("GZIP_EXPERIMENT") + `"`, `ARDOP_FSKONLY_EXPERIMENT="` + os.Getenv("ARDOP_FSKONLY_EXPERIMENT") + `"`, } } pat-1.0.0/app/event_log.go 0000664 0000000 0000000 00000002417 15203222376 0015373 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 app import ( "encoding/json" "net" "os" "time" ) type EventLogger struct { file *os.File enc *json.Encoder } func NewEventLogger(path string) (*EventLogger, error) { file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_RDWR, 0o666) return &EventLogger{file, json.NewEncoder(file)}, err } func (l *EventLogger) Close() error { if l == nil || l.file == nil { return nil } return l.file.Close() } func (l *EventLogger) Log(what string, event map[string]interface{}) { event["log_time"] = time.Now() event["what"] = what if err := l.enc.Encode(event); err != nil { panic(err) } } func (l *EventLogger) LogConn(op string, freq Frequency, conn net.Conn, err error) { e := map[string]interface{}{"success": err == nil} if err != nil { e["error"] = err.Error() } else { if remote := conn.RemoteAddr(); remote != nil { e["remote_addr"] = remote.String() e["network"] = conn.RemoteAddr().Network() } if local := conn.LocalAddr(); local != nil { e["local_addr"] = local.String() } } if freq > 0 { e["freq"] = freq } e["operation"] = op l.Log("connect", e) } pat-1.0.0/app/exchange.go 0000664 0000000 0000000 00000022771 15203222376 0015200 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 app import ( "context" "fmt" "log" "net" "os" "strconv" "strings" "time" "github.com/la5nta/pat/api/types" "github.com/la5nta/pat/internal/buildinfo" "github.com/la5nta/wl2k-go/fbb" ) type ex struct { conn net.Conn target string master bool errors chan error } func (a *App) exchangeLoop(ctx context.Context) chan ex { ce := make(chan ex) go func() { for { select { case ex := <-ce: ex.errors <- a.sessionExchange(ex.conn, ex.target, ex.master) close(ex.errors) case <-ctx.Done(): return } } }() return ce } func (a *App) exchange(conn net.Conn, targetCall string, master bool) error { e := ex{ conn: conn, target: targetCall, master: master, errors: make(chan error), } a.exchangeChan <- e return <-e.errors } type NotifyMBox struct { fbb.MBoxHandler *App } func (m NotifyMBox) ProcessInbound(msgs ...*fbb.Message) error { if err := m.MBoxHandler.ProcessInbound(msgs...); err != nil { return err } for _, msg := range msgs { m.websocketHub.WriteNotification(types.Notification{ Title: fmt.Sprintf("New message from %s", msg.From().Addr), Body: msg.Subject(), }) if isServiceMessage(msg) { m.onServiceMessageReceived(msg) } } return nil } func (m NotifyMBox) GetInboundAnswers(p []fbb.Proposal) []fbb.ProposalAnswer { answers := make([]fbb.ProposalAnswer, len(p)) var outsideLimit bool var hasAccountActivation bool for idx, p := range p { answers[idx] = m.GetInboundAnswer(p) outsideLimit = outsideLimit || p.CompressedSize() >= m.config.AutoDownloadSizeLimit if pm := p.PendingMessage(); pm != nil { hasAccountActivation = hasAccountActivation || isAccountActivation(pm.From, pm.Subject) } } if hasAccountActivation { res := <-m.promptHub.Prompt( context.Background(), time.Minute, types.PromptKindAccountActivation, "Important: Your New Account Password", ) if declined := res.Value != "accept"; declined { // Defer all proposals for idx := range answers { answers[idx] = fbb.Defer } return answers } } if !outsideLimit || m.config.AutoDownloadSizeLimit < 0 { // All proposals are within the prompt limit. Go ahead. return answers } // Build multi-select build options for those accepted by the mailbox handler. var options []PromptOption for idx, p := range p { if answers[idx] != fbb.Accept { continue } answers[idx] = fbb.Defer // Defer unless user explicitly accepts through prompt answer. sender, subject := "Unkown sender", "Unknown subject" if pm := p.PendingMessage(); pm != nil { sender, subject = pm.From.String(), pm.Subject } desc := fmt.Sprintf("%s (%d bytes): %s", sender, p.CompressedSize(), subject) options = append(options, PromptOption{Value: p.MID(), Desc: desc, Checked: p.CompressedSize() < m.config.AutoDownloadSizeLimit}) } // Prompt the user ans := <-m.promptHub.Prompt(context.Background(), time.Minute, PromptKindMultiSelect, "Select messages for download", options...) // If timeout was reached, use our default values to fill in for the user if ans.Err == context.DeadlineExceeded { var checked []string for _, opt := range options { if opt.Checked { checked = append(checked, opt.Value) } } ans.Value = strings.Join(checked, ",") } // For each mid in answer, search the proposals and update answer to Accept. for _, val := range strings.Split(ans.Value, ",") { for idx, p := range p { if p.MID() != val { continue } answers[idx] = fbb.Accept } } return answers } func (a *App) sessionExchange(conn net.Conn, targetCall string, master bool) error { a.exchangeConn = conn a.websocketHub.UpdateStatus() defer func() { a.exchangeConn = nil; a.websocketHub.UpdateStatus() }() // New wl2k Session targetCall = strings.Split(targetCall, ` `)[0] session := fbb.NewSession( a.options.MyCall, targetCall, a.config.Locator, NotifyMBox{a.mbox, a}, ) session.SetUserAgent(fbb.UserAgent{ Name: buildinfo.AppName, Version: buildinfo.Version, }) if len(a.config.MOTD) > 0 { session.SetMOTD(a.config.MOTD...) } // Handle secure login session.SetSecureLoginHandleFunc(func(addr fbb.Address) (string, error) { if addr.Addr == a.options.MyCall && a.config.SecureLoginPassword != "" { return a.config.SecureLoginPassword, nil } for _, aux := range a.config.AuxAddrs { if !addr.EqualString(aux.Address) { continue } switch { case aux.Password != nil: return *aux.Password, nil case a.config.SecureLoginPassword != "": return a.config.SecureLoginPassword, nil } } resp := <-a.promptHub.Prompt(context.Background(), time.Minute, PromptKindPassword, "Enter secure login password for "+addr.String()) return resp.Value, resp.Err }) for _, addr := range a.config.AuxAddrs { session.AddAuxiliaryAddress(fbb.AddressFromString(addr.Address)) } session.IsMaster(master) session.SetLogger(log.New(a.termWriter, "", 0)) session.SetStatusUpdater(StatusUpdate{a.websocketHub}) if a.options.Robust { session.SetRobustMode(fbb.RobustForced) } log.Printf("Connected to %s (%s)", conn.RemoteAddr(), conn.RemoteAddr().Network()) start := time.Now() stats, err := session.Exchange(conn) if fbb.IsLoginFailure(err) { fmt.Println("NOTE: A new password scheme for Winlink is being implemented as of 2018-01-31.") fmt.Println(" Users with passwords created/changed prior to January 31, 2018 should be") fmt.Println(" aware that their password MUST be entered in ALL-UPPERCASE letters. Only") fmt.Println(" passwords created/changed/issued after January 31, 2018 should/may contain") fmt.Println(" lowercase letters. - https://github.com/la5nta/pat/issues/113") } if t, _ := strconv.ParseBool(os.Getenv("PAT_MOCK_NEW_ACCOUNT_MSG")); t { log.Println("Mocking new account msg...") NotifyMBox{a.mbox, a}.ProcessInbound(mockNewAccountMsg()) } event := map[string]interface{}{ "mycall": session.Mycall(), "targetcall": session.Targetcall(), "remote_fw": session.RemoteForwarders(), "remote_sid": session.RemoteSID(), "master": master, "local_locator": a.config.Locator, "auxiliary_addresses": a.config.AuxAddrs, "network": conn.RemoteAddr().Network(), "remote_addr": conn.RemoteAddr().String(), "local_addr": conn.LocalAddr().String(), "sent": stats.Sent, "received": stats.Received, "start": start.Unix(), "end": time.Now().Unix(), "success": err == nil, } if err != nil { event["error"] = err.Error() } a.eventLog.Log("exchange", event) return err } func (a *App) AbortActiveConnection(dirty bool) (ok bool) { switch { case dirty: // This mean we've already tried to abort, but the connection is still active. // Fallback to the below cases to try to identify the busy modem and abort hard. case a.dialing != nil: // If we're currently dialing a transport, attempt to abort by cancelling the associated context. log.Printf("Got abort signal while dialing %s, cancelling...", a.dialing.Scheme) go a.dialCancelFunc() return true case a.exchangeConn != nil: // If we have an active connection, close it gracefully. log.Println("Got abort signal, disconnecting...") go a.exchangeConn.Close() return true } // Any connection and/or dial operation has been cancelled at this point. // User is attempting to abort something, so try to identify any non-idling transports and abort. // It might be a "dirty disconnect" of an already cancelled connection or dial operation which is in the // process of gracefully terminating. It might also be an attempt to close an inbound P2P connection. switch { case a.ardop != nil && !a.ardop.Idle(): if dirty { log.Println("Dirty disconnecting ardop...") a.ardop.Abort() return true } log.Println("Disconnecting ardop...") go func() { if err := a.ardop.Disconnect(); err != nil { log.Println(err) } }() return true case a.varaFM != nil && !a.varaFM.Idle(): if dirty { log.Println("Dirty disconnecting varafm...") a.varaFM.Abort() return true } log.Println("Disconnecting varafm...") go func() { if err := a.varaFM.Close(); err != nil { log.Println(err) } }() return true case a.varaHF != nil && !a.varaHF.Idle(): if dirty { log.Println("Dirty disconnecting varahf...") a.varaHF.Abort() return true } log.Println("Disconnecting varahf...") go func() { if err := a.varaHF.Close(); err != nil { log.Println(err) } }() return true case a.pactor != nil: log.Println("Disconnecting pactor...") err := a.pactor.Close() if err != nil { log.Println(err) } return err == nil default: return false } } type StatusUpdate struct{ WSHub } func (s StatusUpdate) UpdateStatus(stat fbb.Status) { var prop fbb.Proposal switch { case stat.Receiving != nil: prop = *stat.Receiving case stat.Sending != nil: prop = *stat.Sending } s.WriteProgress(types.Progress{ MID: prop.MID(), BytesTotal: stat.BytesTotal, BytesTransferred: stat.BytesTransferred, Subject: prop.Title(), Receiving: stat.Receiving != nil, Sending: stat.Sending != nil, Done: stat.Done, }) percent := float64(stat.BytesTransferred) / float64(stat.BytesTotal) * 100 fmt.Printf("\r%s: %3.0f%%", prop.Title(), percent) if stat.Done { fmt.Println("") } os.Stdout.Sync() } pat-1.0.0/app/freq.go 0000664 0000000 0000000 00000004467 15203222376 0014355 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 app import ( "encoding/json" "fmt" "strconv" "strings" "github.com/la5nta/wl2k-go/rigcontrol/hamlib" ) var bands = map[string]Band{ "160m": {1.8e6, 2.0e6}, "80m": {3.5e6, 4.0e6}, "60m": {5.2e6, 5.5e6}, "40m": {7.0e6, 7.3e6}, "30m": {10.1e6, 10.2e6}, "20m": {14.0e6, 14.4e6}, "17m": {18.0e6, 18.2e6}, "15m": {21.0e6, 21.5e6}, "12m": {24.8e6, 25.0e6}, "10m": {28.0e6, 30.0e6}, "6m": {50.0e6, 54.0e6}, "4m": {70.0e6, 70.5e6}, "2m": {144.0e6, 148.0e6}, "1.25m": {219.0e6, 225.0e6}, // 220, 222 (MHz) "70cm": {420.0e6, 450.0e6}, } type Band struct{ lower, upper Frequency } func (b Band) Contains(f Frequency) bool { if b.lower == 0 && b.upper == 0 { return true } return f >= b.lower && f <= b.upper } type Frequency int // Hz func (f Frequency) String() string { m := f / 1e6 k := (float64(f) - float64(m)*1e6) / 1e3 return fmt.Sprintf("%d.%06.2f MHz", m, k) } func (f Frequency) MarshalJSON() ([]byte, error) { type obj struct { Hz json.Number `json:"hz"` KHz json.Number `json:"khz"` Desc string `json:"desc"` } return json.Marshal(obj{ Hz: json.Number(fmt.Sprint(int(f))), KHz: json.Number(fmt.Sprint(f.KHz())), Desc: f.String(), }) } func (f Frequency) KHz() float64 { return float64(f) / 1e3 } func (f Frequency) MHz() float64 { return float64(f) / 1e6 } func (f Frequency) Dial(mode string) Frequency { mode = strings.ToLower(mode) // Try to detect FM modes, e.g. `ARDOP 2000 FM` and `VARA FM WIDE` if strings.Contains(mode, "fm") { return f } offsets := map[string]Frequency{ MethodPactor: 1500, MethodArdop: 1500, // varahf doesn't appear in RMS list from WDT "vara": 1500, } var shift Frequency for m, offset := range offsets { if strings.Contains(mode, m) { shift = -offset break } } return f + shift } func SetFreq(rig hamlib.VFO, freq string) (newFreq, oldFreq int, err error) { oldFreq, err = rig.GetFreq() if err != nil { return 0, 0, fmt.Errorf("unable to get rig frequency: %w", err) } f, err := strconv.ParseFloat(freq, 64) if err != nil { return 0, 0, err } newFreq = int(f * 1e3) err = rig.SetFreq(newFreq) return } pat-1.0.0/app/gpsd_locator.go 0000664 0000000 0000000 00000002661 15203222376 0016072 0 ustar 00root root 0000000 0000000 package app import ( "context" "fmt" "log" "time" "github.com/la5nta/pat/internal/debug" "github.com/la5nta/pat/internal/gpsd" "github.com/pd0mz/go-maidenhead" ) // gpsdLocatorUpdater polls GPSd every hour and updates the in-memory locator field func (a *App) gpsdLocatorUpdater(ctx context.Context) { // Logs first error to standard logger and the rest to the debug logger for logger := log.Printf; ; logger = debug.Printf { if err := a.updateLocatorFromGPSd(); err != nil && ctx.Err() == nil { logger("Failed to update locator from GPSd: %v", err) } select { case <-time.After(time.Hour): continue case <-ctx.Done(): return } } } // updateLocatorFromGPSd connects to GPSd, gets position, and updates the config locator func (a *App) updateLocatorFromGPSd() error { conn, err := gpsd.Dial(a.config.GPSd.Addr) if err != nil { return fmt.Errorf("connection failed: %w", err) } defer conn.Close() conn.Watch(true) pos, err := conn.NextPosTimeout(time.Minute) if err != nil { return fmt.Errorf("failed to provide position: %w", err) } point := maidenhead.NewPoint(pos.Lat, pos.Lon) locator, err := point.GridSquare() switch { case err != nil: return fmt.Errorf("failed to convert coordinates to locator: %w", err) case a.config.Locator == locator: return nil // Locator is up to date } log.Printf("Locator changed from %s to %s", a.config.Locator, locator) a.config.Locator = locator return nil } pat-1.0.0/app/listen.go 0000664 0000000 0000000 00000014472 15203222376 0014713 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 app import ( "context" "log" "net" "strings" "time" "github.com/la5nta/pat/cfg" "github.com/la5nta/wl2k-go/rigcontrol/hamlib" "github.com/la5nta/wl2k-go/transport/ardop" "github.com/la5nta/wl2k-go/transport/ax25" "github.com/la5nta/wl2k-go/transport/ax25/agwpe" "github.com/la5nta/wl2k-go/transport/telnet" "github.com/n8jja/Pat-Vara/vara" ) func (a *App) Unlisten(param string) { methods := strings.FieldsFunc(param, SplitFunc) for _, method := range methods { ok, err := a.listenHub.Disable(method) if err != nil { log.Printf("Unable to close %s listener: %s", method, err) } else if !ok { log.Printf("No active %s listener, ignoring.\n", method) } } } func (a *App) Listen(listenStr string) { methods := strings.FieldsFunc(listenStr, SplitFunc) for _, method := range methods { // Rewrite the generic ax25:// scheme to use a specified AX.25 engine. if method == MethodAX25 { method = a.defaultAX25Method() } switch strings.ToLower(method) { case MethodArdop: a.listenHub.Enable(&ARDOPListener{a, nil}) case MethodTelnet: a.listenHub.Enable(TelnetListener{a}) case MethodAX25AGWPE: a.listenHub.Enable(&AX25AGWPEListener{a, nil}) case MethodAX25Linux: a.listenHub.Enable(&AX25LinuxListener{a, nil}) case MethodVaraFM: a.listenHub.Enable(VaraFMListener{a}) case MethodVaraHF: a.listenHub.Enable(VaraHFListener{a}) case MethodAX25SerialTNC, MethodSerialTNCDeprecated: log.Printf("%s listen not implemented, ignoring.", method) default: log.Printf("'%s' is not a valid listen method", method) return } } log.Printf("Listening for incoming traffic on %s...", listenStr) } type AX25LinuxListener struct { a interface { Options() Options Config() cfg.Config } stopBeacon func() } func (l *AX25LinuxListener) Init() (net.Listener, error) { return ax25.ListenAX25(l.a.Config().AX25Linux.Port, l.a.Options().MyCall) } func (l *AX25LinuxListener) BeaconStart() error { interval := time.Duration(l.a.Config().AX25.Beacon.Every) * time.Second if interval <= 0 { return nil } b, err := ax25.NewAX25Beacon(l.a.Config().AX25Linux.Port, l.a.Options().MyCall, l.a.Config().AX25.Beacon.Destination, l.a.Config().AX25.Beacon.Message) if err != nil { return err } l.stopBeacon = doEvery(interval, func() { if err := b.Now(); err != nil { log.Printf("%s beacon failed: %s", l.Name(), err) l.stopBeacon() } }) return nil } func (l *AX25LinuxListener) BeaconStop() { if l.stopBeacon != nil { l.stopBeacon() } } func (l *AX25LinuxListener) CurrentFreq() (Frequency, bool) { return 0, false } func (l *AX25LinuxListener) Name() string { return MethodAX25Linux } type ARDOPListener struct { a interface { ARDOP() (*ardop.TNC, error) VFOForRig(string) (hamlib.VFO, bool) Config() cfg.Config } stopBeacon func() } func (l ARDOPListener) Name() string { return MethodArdop } func (l ARDOPListener) Init() (net.Listener, error) { m, err := l.a.ARDOP() if err != nil { return nil, err } return m.Listen() } func (l ARDOPListener) CurrentFreq() (Frequency, bool) { if rig, ok := l.a.VFOForRig(l.a.Config().Ardop.Rig); ok { f, _ := rig.GetFreq() return Frequency(f), ok } return 0, false } func (l *ARDOPListener) BeaconStart() error { interval := time.Duration(l.a.Config().Ardop.BeaconInterval) * time.Second if interval <= 0 { return nil } m, err := l.a.ARDOP() if err != nil { return err } l.stopBeacon = func() { m.BeaconEvery(0) } return m.BeaconEvery(interval) } func (l ARDOPListener) BeaconStop() { if l.stopBeacon != nil { l.stopBeacon() } } type VaraFMListener struct { a interface { Config() cfg.Config VFOForRig(string) (hamlib.VFO, bool) VARAFM() (*vara.Modem, error) } } func (l VaraFMListener) Name() string { return MethodVaraFM } func (l VaraFMListener) Init() (net.Listener, error) { m, err := l.a.VARAFM() if err != nil { return nil, err } return m.Listen() } func (l VaraFMListener) CurrentFreq() (Frequency, bool) { if rig, ok := l.a.VFOForRig(l.a.Config().VaraFM.Rig); ok { f, _ := rig.GetFreq() return Frequency(f), ok } return 0, false } type VaraHFListener struct { a interface { Config() cfg.Config VFOForRig(string) (hamlib.VFO, bool) VARAHF() (*vara.Modem, error) } } func (l VaraHFListener) Name() string { return MethodVaraHF } func (l VaraHFListener) Init() (net.Listener, error) { m, err := l.a.VARAHF() if err != nil { return nil, err } return m.Listen() } func (l VaraHFListener) CurrentFreq() (Frequency, bool) { if rig, ok := l.a.VFOForRig(l.a.Config().VaraHF.Rig); ok { f, _ := rig.GetFreq() return Frequency(f), ok } return 0, false } type AX25AGWPEListener struct { a interface { Config() cfg.Config AGWPE() (*agwpe.TNCPort, error) } stopBeacon func() } func (l *AX25AGWPEListener) Name() string { return MethodAX25AGWPE } func (l *AX25AGWPEListener) Init() (net.Listener, error) { m, err := l.a.AGWPE() if err != nil { return nil, err } return m.Listen() } func (l *AX25AGWPEListener) CurrentFreq() (Frequency, bool) { return 0, false } func (l *AX25AGWPEListener) BeaconStart() error { b := l.a.Config().AX25.Beacon interval := time.Duration(b.Every) * time.Second if interval <= 0 { return nil } m, err := l.a.AGWPE() if err != nil { return err } l.stopBeacon = doEvery(interval, func() { if err := m.SendUI([]byte(b.Message), b.Destination); err != nil { log.Printf("%s beacon failed: %s", l.Name(), err) l.stopBeacon() } }) return nil } func (l AX25AGWPEListener) BeaconStop() { if l.stopBeacon != nil { l.stopBeacon() } } type TelnetListener struct { a interface { Config() cfg.Config } } func (l TelnetListener) Name() string { return MethodTelnet } func (l TelnetListener) Init() (net.Listener, error) { return telnet.Listen(l.a.Config().Telnet.ListenAddr) } func (l TelnetListener) CurrentFreq() (Frequency, bool) { return 0, false } func doEvery(interval time.Duration, fn func()) (cancel func()) { if interval == 0 { return } ctx, cancel := context.WithCancel(context.Background()) go func() { t := time.NewTicker(interval) defer t.Stop() for { select { case <-ctx.Done(): return case <-t.C: fn() } } }() return cancel } pat-1.0.0/app/listener_hub.go 0000664 0000000 0000000 00000007342 15203222376 0016076 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 app import ( "log" "net" "sync" "time" ) type TransportListener interface { Init() (net.Listener, error) Name() string CurrentFreq() (Frequency, bool) } type Beaconer interface { BeaconStop() BeaconStart() error } type Listener struct { *App t TransportListener done chan struct{} mu sync.Mutex err error ln net.Listener } func (h *ListenerHub) NewListener(t TransportListener) *Listener { return &Listener{ App: h.App, t: t, done: make(chan struct{}), } } func (l *Listener) Err() error { l.mu.Lock() defer l.mu.Unlock() return l.err } func (l *Listener) Close() error { l.mu.Lock() defer l.mu.Unlock() select { case <-l.done: return l.err default: close(l.done) if l.ln != nil { return l.ln.Close() } return l.err } } func (l *Listener) listenLoop(h *ListenerHub) { var silenceErr bool for { select { case <-l.done: return default: ln, err := l.t.Init() l.mu.Lock() l.ln, l.err = ln, err l.mu.Unlock() if err != nil { if !silenceErr { log.Printf("Listener %s failed: %s", l.t.Name(), err) log.Printf("Will try to re-establish listener in the background...") silenceErr = true h.websocketHub.UpdateStatus() } time.Sleep(time.Second) continue } if silenceErr { log.Printf("Listener %s re-established", l.t.Name()) silenceErr = false h.websocketHub.UpdateStatus() } if b, ok := l.t.(Beaconer); ok { b.BeaconStart() } // Run the accept loop until an error occurs if err := l.acceptLoop(); err != nil { select { case <-l.done: // Ignore errors during shutdown default: log.Printf("Accept %s failed: %s", l.t.Name(), err) } } if b, ok := l.t.(Beaconer); ok { b.BeaconStop() } } } } type RemoteCaller interface { RemoteCall() string } func (l *Listener) acceptLoop() error { for { conn, err := l.ln.Accept() if err != nil { return err } remoteCall := conn.RemoteAddr().String() if c, ok := conn.(RemoteCaller); ok { remoteCall = c.RemoteCall() } freq, _ := l.t.CurrentFreq() l.eventLog.LogConn("accept", freq, conn, nil) log.Printf("Got connect (%s:%s)", l.t.Name(), remoteCall) err = l.exchange(conn, remoteCall, true) if err != nil { log.Printf("Exchange failed: %s", err) } else { log.Println("Disconnected.") } } } type ListenerHub struct { *App mu sync.Mutex listeners map[string]*Listener } func NewListenerHub(a *App) *ListenerHub { return &ListenerHub{ App: a, listeners: map[string]*Listener{}, } } func (h *ListenerHub) Active() []TransportListener { h.mu.Lock() defer h.mu.Unlock() slice := make([]TransportListener, 0, len(h.listeners)) for _, l := range h.listeners { if l.Err() != nil { continue } slice = append(slice, l.t) } return slice } func (h *ListenerHub) Enable(t TransportListener) { h.mu.Lock() defer func() { h.mu.Unlock() h.websocketHub.UpdateStatus() }() l := h.NewListener(t) if _, ok := h.listeners[t.Name()]; ok { return } h.listeners[t.Name()] = l go l.listenLoop(h) } func (h *ListenerHub) Disable(name string) (bool, error) { if name == MethodAX25 { name = h.defaultAX25Method() } h.mu.Lock() defer func() { h.mu.Unlock() h.websocketHub.UpdateStatus() }() l, ok := h.listeners[name] if !ok { return false, nil } delete(h.listeners, name) return true, l.Close() } func (h *ListenerHub) Close() error { h.mu.Lock() defer func() { h.mu.Unlock() h.websocketHub.UpdateStatus() }() for k, l := range h.listeners { l.Close() delete(h.listeners, k) } return nil } pat-1.0.0/app/listener_hub_test.go 0000664 0000000 0000000 00000004073 15203222376 0017133 0 ustar 00root root 0000000 0000000 package app import ( "net" "testing" "time" ) type mockListener struct { closed bool acceptErr error } func (m *mockListener) Accept() (net.Conn, error) { if m.acceptErr != nil { return nil, m.acceptErr } select {} // Block forever to simulate working listener } func (m *mockListener) Close() error { m.closed = true; m.acceptErr = net.ErrClosed; return nil } func (m *mockListener) Addr() net.Addr { return nil } type mockTransportListener struct { name string initErr error initCallCount int } func (m *mockTransportListener) Init() (net.Listener, error) { m.initCallCount++ if m.initErr != nil { return nil, m.initErr } return &mockListener{}, nil } func (m *mockTransportListener) Name() string { return m.name } func (m *mockTransportListener) CurrentFreq() (Frequency, bool) { return 0, false } func createTestApp() *App { return &App{ websocketHub: noopWSSocket{}, eventLog: &EventLogger{}, } } func TestListenerHub_EnableDisable(t *testing.T) { hub := NewListenerHub(createTestApp()) defer hub.Close() t.Run("Enable", func(t *testing.T) { hub.Enable(&mockTransportListener{name: "test"}) active := hub.Active() if len(active) != 1 { t.Errorf("Expected 1 active listener, got %d", len(active)) } }) t.Run("Disable", func(t *testing.T) { removed, err := hub.Disable("test") if err != nil { t.Fatalf("Disable should not return error: %v", err) } if !removed { t.Error("Disable should return true when listener was removed") } active := hub.Active() if len(active) != 0 { t.Errorf("Expected 0 active listeners after removal, got %d", len(active)) } }) } func TestListener_RetriesOnFailure(t *testing.T) { hub := NewListenerHub(createTestApp()) defer hub.Close() transport := &mockTransportListener{ name: "test", initErr: net.ErrClosed, } hub.Enable(transport) // Wait for multiple retry attempts time.Sleep(2500 * time.Millisecond) if transport.initCallCount < 2 { t.Errorf("Expected at least 2 Init calls due to retries, got %d", transport.initCallCount) } } pat-1.0.0/app/prompt_hub.go 0000664 0000000 0000000 00000005367 15203222376 0015577 0 ustar 00root root 0000000 0000000 package app import ( "context" "fmt" "sync" "time" "github.com/la5nta/pat/api/types" "github.com/la5nta/pat/internal/debug" ) const ( PromptKindBusyChannel = types.PromptKindBusyChannel PromptKindMultiSelect = types.PromptKindMultiSelect PromptKindPassword = types.PromptKindPassword PromptKindPreAccountActivation = types.PromptKindPreAccountActivation PromptKindAccountActivation = types.PromptKindAccountActivation ) type ( PromptResponse = types.PromptResponse PromptKind = types.PromptKind PromptOption = types.PromptOption ) type Prompt struct { types.Prompt hub *PromptHub resp chan PromptResponse ctx context.Context cancel context.CancelFunc } type Prompter interface{ Prompt(Prompt) } func (p Prompt) Done() <-chan struct{} { return p.ctx.Done() } func (p Prompt) Err() error { return p.ctx.Err() } func (p Prompt) Respond(val string, err error) { p.hub.Respond(p.ID, val, err) } type PromptHub struct { c chan *Prompt rc chan PromptResponse closeOnce sync.Once prompters map[Prompter]struct{} } func NewPromptHub() *PromptHub { p := &PromptHub{ c: make(chan *Prompt), rc: make(chan PromptResponse, 1), } go p.loop() return p } func (p *PromptHub) Close() error { if p == nil { return nil } p.closeOnce.Do(func() { close(p.c) }) return nil } func (p *PromptHub) AddPrompter(prompters ...Prompter) { if p.prompters == nil { p.prompters = make(map[Prompter]struct{}, len(prompters)) } for _, prompter := range prompters { p.prompters[prompter] = struct{}{} } } func (p *PromptHub) loop() { defer close(p.rc) defer debug.Printf("PromptHub run loop stopped") for prompt := range p.c { debug.Printf("New prompt: %#v", prompt) select { case <-prompt.ctx.Done(): debug.Printf("Prompt cancelled: %v", prompt.ctx.Err()) prompt.resp <- PromptResponse{ID: prompt.ID, Err: prompt.ctx.Err()} case resp := <-p.rc: debug.Printf("Prompt resp: %#v", resp) if resp.ID != prompt.ID { continue } prompt.resp <- resp prompt.cancel() } } } func (p *PromptHub) Respond(id, value string, err error) { select { case p.rc <- PromptResponse{ID: id, Value: value, Err: err}: default: } } func (p *PromptHub) Prompt(ctx context.Context, timeout time.Duration, kind PromptKind, message string, options ...PromptOption) <-chan PromptResponse { ctx, cancel := context.WithTimeout(ctx, timeout) prompt := &Prompt{ Prompt: types.Prompt{ ID: fmt.Sprint(time.Now().UnixNano()), Kind: kind, Message: message, Options: options, }, hub: p, resp: make(chan PromptResponse, 1), ctx: ctx, cancel: cancel, } p.c <- prompt for prompter := range p.prompters { go prompter.Prompt(*prompt) } return prompt.resp } pat-1.0.0/app/rmslist.go 0000664 0000000 0000000 00000020272 15203222376 0015105 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 app import ( "context" "encoding/json" "errors" "fmt" "log" "math" "net/url" "path/filepath" "sort" "strings" "time" "github.com/la5nta/pat/internal/cmsapi" "github.com/la5nta/pat/internal/debug" "github.com/la5nta/pat/internal/directories" "github.com/la5nta/pat/internal/propagation" "github.com/la5nta/pat/internal/propagation/silso" "github.com/pd0mz/go-maidenhead" ) type JSONURL struct{ url.URL } func (url JSONURL) MarshalJSON() ([]byte, error) { return json.Marshal(url.String()) } // JSONFloat64 is a float64 which serializes NaN and Inf(+-) as JSON value null type JSONFloat64 float64 func (f JSONFloat64) MarshalJSON() ([]byte, error) { if math.IsNaN(float64(f)) || math.IsInf(float64(f), 0) { return json.Marshal(nil) } return json.Marshal(float64(f)) } type Prediction struct { LinkQuality int `json:"link_quality"` OutputRaw string `json:"output_raw"` OutputValues any `json:"output_values"` } type RMS struct { Callsign string `json:"callsign"` Gridsquare string `json:"gridsquare"` Distance JSONFloat64 `json:"distance"` Azimuth JSONFloat64 `json:"azimuth"` Modes string `json:"modes"` Freq Frequency `json:"freq"` Dial Frequency `json:"dial"` URL *JSONURL `json:"url"` Prediction *Prediction `json:"prediction"` } func (r RMS) IsMode(mode string) bool { if mode == MethodVaraFM { return strings.HasPrefix(r.Modes, "VARA FM") } if mode == MethodVaraHF { return strings.HasPrefix(r.Modes, "VARA") && !strings.HasPrefix(r.Modes, "VARA FM") } return strings.Contains(strings.ToLower(r.Modes), mode) } func (r RMS) IsBand(band string) bool { return bands[band].Contains(r.Freq) } type ByLinkQuality []RMS func (r ByLinkQuality) Len() int { return len(r) } func (r ByLinkQuality) Swap(i, j int) { r[i], r[j] = r[j], r[i] } func (r ByLinkQuality) Less(i, j int) bool { quality := func(idx int) int { if r[idx].Prediction == nil { return -1 } return r[idx].Prediction.LinkQuality } if iq, jq := quality(i), quality(j); iq != jq { return iq < jq } // Fallback to distance sort (reversed since smaller value is better, as oppose to link quality) return sort.Reverse(ByDist(r)).Less(i, j) } type ByDist []RMS func (r ByDist) Len() int { return len(r) } func (r ByDist) Swap(i, j int) { r[i], r[j] = r[j], r[i] } func (r ByDist) Less(i, j int) bool { if r[i].Distance != r[j].Distance { return r[i].Distance < r[j].Distance } if r[i].Callsign != r[j].Callsign { return r[i].Callsign < r[j].Callsign } return r[i].Freq < r[j].Freq } func (a *App) ReadRMSList(ctx context.Context, forceDownload bool, filterFn func(rms RMS) (keep bool)) ([]RMS, error) { me, err := maidenhead.ParseLocator(a.config.Locator) if err != nil { log.Print("Missing or Invalid Locator, will not compute distance and Azimuth") } fileName := "rmslist" isDefaultServiceCode := len(a.config.ServiceCodes) == 1 && a.config.ServiceCodes[0] == "PUBLIC" if !isDefaultServiceCode { fileName += "-" + strings.Join(a.config.ServiceCodes, "-") } filePath := filepath.Join(directories.DataDir(), fileName+".json") debug.Printf("RMS list file is %s", filePath) f, err := cmsapi.GetGatewayStatusCached(ctx, filePath, forceDownload, a.config.ServiceCodes...) if err != nil { return nil, err } defer f.Close() var status cmsapi.GatewayStatus if err = json.NewDecoder(f).Decode(&status); err != nil { return nil, err } slice := []RMS{} for _, gw := range status.Gateways { for _, channel := range gw.Channels { r := RMS{ Callsign: gw.Callsign, Gridsquare: channel.Gridsquare, Modes: channel.SupportedModes, Freq: Frequency(channel.Frequency), Dial: Frequency(channel.Frequency).Dial(channel.SupportedModes), } if chURL := toURL(channel, gw.Callsign); chURL != nil { r.URL = &JSONURL{*chURL} } hasLocator := me != maidenhead.Point{} if them, err := maidenhead.ParseLocator(channel.Gridsquare); err == nil && hasLocator { r.Distance = JSONFloat64(me.Distance(them)) r.Azimuth = JSONFloat64(me.Bearing(them)) } if keep := filterFn(r); !keep { continue } slice = append(slice, r) } } if a.predictor == nil { return slice, nil } // Grab the forecasted SSN for today ssn, err := getSSN(ctx, time.Now()) if err != nil { log.Println(err) } // In case this takes a while, add a log statement if it's not within 5 seconds ctx, cancel := context.WithCancel(ctx) defer cancel() go func() { select { case <-time.After(5 * time.Second): log.Println("Hang tight - calculating propagation predictions...") case <-ctx.Done(): } }() // Run prediction (in parallel) params := make([]propagation.PredictionParams, len(slice)) for i, r := range slice { params[i] = propagation.PredictionParams{ From: propagation.Maidenhead(a.Config().Locator), To: propagation.Maidenhead(r.Gridsquare), Frequency: int(r.Freq), SSN: ssn, TransmitPower: 50, // TODO: Consider making this configurable Time: time.Now(), } } propagation.PredictParallel(ctx, a.predictor, params, func(i int, p *propagation.Prediction, err error) { switch { case errors.Is(err, propagation.ErrFrequencyOutOfBounds), ctx.Err() != nil: case err != nil: debug.Printf("Could not predict propagation for %s: %s", slice[i].Callsign, err) default: slice[i].Prediction = &Prediction{LinkQuality: p.LinkQuality, OutputRaw: p.OutputRaw, OutputValues: p.OutputValues} } }) return slice, nil } func getSSN(ctx context.Context, now time.Time) (int, error) { ctx, cancel := context.WithTimeout(ctx, time.Minute) defer cancel() debug.Printf("Fetching SIDC SSN prediction...") // In case this takes a while, add a log statement if it's not ready after one second go func() { select { case <-time.After(time.Second): log.Println("Updating SIDC SSN prediction...") case <-ctx.Done(): } }() cachePath := filepath.Join(directories.DataDir(), ".predicted-ssn-silso.json") predictions, err := silso.GetPredictedSSNCached(ctx, cachePath) if err != nil || len(predictions) == 0 { return 50, fmt.Errorf("failed to get SSN prediction data: %v", err) } targetMonth := now.Format("2006-01") for _, p := range predictions { if p.TimeTag == targetMonth { debug.Printf("SSN: %v", p.PredictedSSN) return int(p.PredictedSSN), nil } } p := predictions[len(predictions)-1] return int(p.PredictedSSN), fmt.Errorf("failed to find SSN prediction for current month. Using %.0f (%s)", p.PredictedSSN, p.TimeTag) } func toURL(gc cmsapi.GatewayChannel, targetCall string) *url.URL { freq := Frequency(gc.Frequency).Dial(gc.SupportedModes) chURL, _ := url.Parse(fmt.Sprintf("%s:///%s?freq=%v", toTransport(gc), targetCall, freq.KHz())) addBandwidth(gc, chURL) return chURL } func addBandwidth(gc cmsapi.GatewayChannel, chURL *url.URL) { bw := "" modeF := strings.Fields(gc.SupportedModes) switch modeF[0] { case "ARDOP": if len(modeF) > 1 { bw = modeF[1] + "MAX" } case "VARA": if len(modeF) > 1 && modeF[1] == "FM" { // VARA FM should not set bandwidth in connect URL or sent over the command port, // it's set in the VARA Setup dialog bw = "" } else { // VARA HF may be 500, 2750, or none which is implicitly 2300 if len(modeF) > 1 { if len(modeF) > 1 { bw = modeF[1] } } else { bw = "2300" } } } if bw != "" { v := chURL.Query() v.Set("bw", bw) chURL.RawQuery = v.Encode() } } var transports = []string{MethodAX25, MethodPactor, MethodArdop, MethodVaraFM, MethodVaraHF} func toTransport(gc cmsapi.GatewayChannel) string { modes := strings.ToLower(gc.SupportedModes) for _, transport := range transports { if strings.Contains(modes, "packet") { // bug(maritnhpedersen): We really don't know which transport to use here. It could be serial-tnc or ax25, but ax25 is most likely. return MethodAX25 } if strings.HasPrefix(modes, "vara fm") { return MethodVaraFM } if strings.HasPrefix(modes, "vara") { return MethodVaraHF } if strings.Contains(modes, transport) { return transport } } return "" } pat-1.0.0/app/rmslist_test.go 0000664 0000000 0000000 00000007612 15203222376 0016147 0 ustar 00root root 0000000 0000000 package app import ( "net/url" "reflect" "testing" "github.com/la5nta/pat/internal/cmsapi" ) func Test_toURL(t *testing.T) { type args struct { channel cmsapi.GatewayChannel targetCall string } tests := []struct { name string args args want *url.URL }{ { name: "ax25 1200", args: args{ channel: cmsapi.GatewayChannel{ Frequency: 145050000, SupportedModes: "Packet 1200", }, targetCall: "K0NTS-10", }, want: parseURL("ax25:///K0NTS-10?freq=145050"), }, { name: "ax25 9600", args: args{ channel: cmsapi.GatewayChannel{ Frequency: 438075000, SupportedModes: "Packet 9600", }, targetCall: "HB9AK-14", }, want: parseURL("ax25:///HB9AK-14?freq=438075"), }, { name: "adrop 2000", args: args{ channel: cmsapi.GatewayChannel{ Frequency: 3586500, SupportedModes: "ARDOP 2000", }, targetCall: "K0SI", }, want: parseURL("ardop:///K0SI?bw=2000MAX&freq=3585"), }, { name: "adrop 500", args: args{ channel: cmsapi.GatewayChannel{ Frequency: 3584000, SupportedModes: "ARDOP 500", }, targetCall: "F1ZWL", }, want: parseURL("ardop:///F1ZWL?bw=500MAX&freq=3582.5"), }, { // These are quite rare but are seen in the wild name: "adrop 1000", args: args{ channel: cmsapi.GatewayChannel{ Frequency: 3588000, SupportedModes: "ARDOP 1000", }, targetCall: "N3HYM-10", }, want: parseURL("ardop:///N3HYM-10?bw=1000MAX&freq=3586.5"), }, { // This is a notional ARDOP station that doesn't specify bandwidth in supportedModes. // None appear today in the RMS list, but maybe they could. name: "adrop unspec", args: args{ channel: cmsapi.GatewayChannel{ Frequency: 7584000, SupportedModes: "ARDOP", }, targetCall: "T3ST", }, want: parseURL("ardop:///T3ST?freq=7582.5"), }, { name: "pactor", args: args{ channel: cmsapi.GatewayChannel{ Frequency: 1850000, SupportedModes: "Pactor 1,2", }, targetCall: "K1EHZ", }, want: parseURL("pactor:///K1EHZ?freq=1848.5"), }, { name: "robust packet", args: args{ channel: cmsapi.GatewayChannel{ Frequency: 7099400, SupportedModes: "Robust Packet", }, targetCall: "N3HYM-10", }, want: parseURL("ax25:///N3HYM-10?freq=7099.4"), }, { name: "vara hf 500", args: args{ channel: cmsapi.GatewayChannel{ Frequency: 7064000, SupportedModes: "VARA 500", }, targetCall: "W0VG", }, want: parseURL("varahf:///W0VG?bw=500&freq=7062.5"), }, { name: "vara hf unspec", args: args{ channel: cmsapi.GatewayChannel{ Frequency: 7103000, SupportedModes: "VARA", }, targetCall: "W0VG", }, want: parseURL("varahf:///W0VG?bw=2300&freq=7101.5"), }, { name: "vara hf 2750", args: args{ channel: cmsapi.GatewayChannel{ Frequency: 3597900, SupportedModes: "VARA 2750", }, targetCall: "W1EO", }, want: parseURL("varahf:///W1EO?bw=2750&freq=3596.4"), }, { name: "vara fm narrow", args: args{ channel: cmsapi.GatewayChannel{ Frequency: 145070000, SupportedModes: "VARA FM", }, targetCall: "W0TQ", }, // vara transport adapter will default to narrow want: parseURL("varafm:///W0TQ?freq=145070"), }, { name: "vara fm wide", args: args{ channel: cmsapi.GatewayChannel{ Frequency: 145510000, SupportedModes: "VARA FM WIDE", }, targetCall: "W1AW-10", }, want: parseURL("varafm:///W1AW-10?freq=145510"), }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { if got := toURL(tt.args.channel, tt.args.targetCall); !reflect.DeepEqual(got, tt.want) { t.Errorf("toURL() = %v, want %v", got, tt.want) } }) } } func parseURL(str string) *url.URL { parse, _ := url.Parse(str) return parse } pat-1.0.0/app/utils.go 0000664 0000000 0000000 00000000444 15203222376 0014547 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 app import ( "unicode" ) func SplitFunc(c rune) bool { return unicode.IsSpace(c) || c == ',' || c == ';' } pat-1.0.0/app/winlink_api.go 0000664 0000000 0000000 00000010340 15203222376 0015707 0 ustar 00root root 0000000 0000000 package app import ( "context" "encoding/json" "errors" "fmt" "os" "path/filepath" "runtime" "time" "github.com/la5nta/pat/internal/buildinfo" "github.com/la5nta/pat/internal/cmsapi" "github.com/la5nta/pat/internal/debug" "github.com/la5nta/pat/internal/directories" ) var ErrRateLimited error = errors.New("call was rate-limited") // DoIfElapsed implements a per-callsign rate limited function. func DoIfElapsed(callsign, name string, t time.Duration, fn func() error) error { filePath := filepath.Join(directories.StateDir(), "."+name+"_"+callsign+".json") file, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE, 0o600) if err != nil { return err } defer file.Close() var lastUpdated time.Time json.NewDecoder(file).Decode(&lastUpdated) if since := time.Since(lastUpdated); since < t { debug.Printf("Skipping %q (last run: %s ago)", name, since.Truncate(time.Minute)) return ErrRateLimited } if err := fn(); err != nil { return err } file.Truncate(0) file.Seek(0, 0) return json.NewEncoder(file).Encode(time.Now()) } func (a *App) postVersionUpdate() { const interval = 24 * time.Hour err := DoIfElapsed(a.Options().MyCall, "version_report", interval, func() error { debug.Printf("Posting version update...") // WDT do not want us to post version reports for callsigns without a registered account if exists, err := accountExists(a.Options().MyCall); err != nil { return err } else if !exists { return fmt.Errorf("account does not exist") } return cmsapi.VersionAdd{ Callsign: a.Options().MyCall, Program: buildinfo.AppName, Version: buildinfo.Version, Comments: fmt.Sprintf("%s - %s/%s", buildinfo.GitRev, runtime.GOOS, runtime.GOARCH), }.Post() }) if err != nil && !errors.Is(err, ErrRateLimited) { debug.Printf("Failed to post version update: %v", err) } } func (a *App) checkPasswordRecoveryEmailIsSet(ctx context.Context) { const interval = 14 * 24 * time.Hour err := DoIfElapsed(a.Options().MyCall, "pw_recovery_email_check", interval, func() error { debug.Printf("Checking if winlink.org password recovery email is set...") set, err := passwordRecoveryEmailSet(ctx, a.Options().MyCall, a.Config().SecureLoginPassword) if err != nil { return err } debug.Printf("Password recovery email set: %t", set) if set { return nil } fmt.Println("") fmt.Println("WINLINK NOTICE: Password recovery email is not set for your Winlink account. It is highly recommended to do so.") fmt.Println("Run `" + os.Args[0] + " account --help` for help setting your recovery address. You can also manage your account settings at https://winlink.org/.") fmt.Println("") return nil }) if err != nil && !errors.Is(err, ErrRateLimited) { debug.Printf("Failed to check if password recovery email is set: %v", err) } } func passwordRecoveryEmailSet(ctx context.Context, callsign, password string) (bool, error) { if password == "" { return false, fmt.Errorf("missing password") } switch exists, err := accountExists(callsign); { case err != nil: return false, fmt.Errorf("error checking if account exist: %w", err) case !exists: return false, fmt.Errorf("account does not exist") } email, err := cmsapi.PasswordRecoveryEmailGet(ctx, callsign, password) return email != "", err } func accountExists(callsign string) (bool, error) { var cache struct { Expires time.Time AccountExists bool } fileName := fmt.Sprintf(".cached_account_check_%s.json", callsign) filePath := filepath.Join(directories.StateDir(), fileName) f, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE, 0o600) if err != nil { return false, err } json.NewDecoder(f).Decode(&cache) if time.Since(cache.Expires) < 0 { return cache.AccountExists, nil } defer func() { f.Truncate(0) f.Seek(0, 0) json.NewEncoder(f).Encode(cache) }() debug.Printf("Checking if account exists...") exists, err := cmsapi.AccountExists(context.Background(), callsign) debug.Printf("Account exists: %t (%v)", exists, err) if !exists || err != nil { // Let's try again in 48 hours cache.Expires = time.Now().Add(48 * time.Hour) return false, err } // Keep this response for a month. It will probably not change. cache.Expires = time.Now().Add(30 * 24 * time.Hour) cache.AccountExists = exists return exists, err } pat-1.0.0/app/wshub.go 0000664 0000000 0000000 00000001340 15203222376 0014533 0 ustar 00root root 0000000 0000000 package app import "github.com/la5nta/pat/api/types" type WSHub interface { UpdateStatus() WriteProgress(types.Progress) WriteNotification(types.Notification) Prompt(Prompt) NumClients() int ClientAddrs() []string Close() error } type noopWSSocket struct{} func (noopWSSocket) UpdateStatus() {} func (noopWSSocket) WriteProgress(types.Progress) {} func (noopWSSocket) WriteNotification(types.Notification) {} func (noopWSSocket) Prompt(Prompt) {} func (noopWSSocket) NumClients() int { return 0 } func (noopWSSocket) ClientAddrs() []string { return []string{} } func (noopWSSocket) Close() error { return nil } pat-1.0.0/cfg/ 0000775 0000000 0000000 00000000000 15203222376 0013035 5 ustar 00root root 0000000 0000000 pat-1.0.0/cfg/ax25_engine.go 0000664 0000000 0000000 00000001025 15203222376 0015466 0 ustar 00root root 0000000 0000000 package cfg import ( "encoding/json" "fmt" ) const ( AX25EngineAGWPE AX25Engine = "agwpe" AX25EngineLinux = "linux" AX25EngineSerialTNC = "serial-tnc" ) type AX25Engine string func (a *AX25Engine) UnmarshalJSON(p []byte) error { var str string if err := json.Unmarshal(p, &str); err != nil { return err } switch v := AX25Engine(str); v { case AX25EngineLinux, AX25EngineAGWPE, AX25EngineSerialTNC: *a = v return nil default: return fmt.Errorf("invalid AX.25 engine '%s'", v) } } pat-1.0.0/cfg/ax25_engine_libax25.go 0000664 0000000 0000000 00000000140 15203222376 0017011 0 ustar 00root root 0000000 0000000 //go:build libax25 package cfg func DefaultAX25Engine() AX25Engine { return AX25EngineLinux } pat-1.0.0/cfg/ax25_engine_other.go 0000664 0000000 0000000 00000000141 15203222376 0016665 0 ustar 00root root 0000000 0000000 //go:build !libax25 package cfg func DefaultAX25Engine() AX25Engine { return AX25EngineAGWPE } pat-1.0.0/cfg/config.go 0000664 0000000 0000000 00000032036 15203222376 0014635 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 cfg import ( "encoding/json" "fmt" "net" "strconv" "strings" "github.com/la5nta/wl2k-go/transport/ardop" ) const ( PlaceholderMycall = "{mycall}" ) type AuxAddr struct { Address string Password *string } func (a AuxAddr) MarshalJSON() ([]byte, error) { if a.Password == nil { return json.Marshal(a.Address) } return json.Marshal(a.Address + ":" + *a.Password) } func (a *AuxAddr) UnmarshalJSON(p []byte) error { var str string if err := json.Unmarshal(p, &str); err != nil { return err } parts := strings.SplitN(str, ":", 2) a.Address = parts[0] if len(parts) > 1 { a.Password = &parts[1] } return nil } type Config struct { // This station's callsign. MyCall string `json:"mycall"` // Secure login password used when a secure login challenge is received. // // The user is prompted if this is undefined. SecureLoginPassword string `json:"secure_login_password"` // Auxiliary callsigns to fetch email on behalf of. // // Passwords can optionally be specified by appending :MYPASS (e.g. EMCOMM-1:MyPassw0rd). // If no password is specified, the SecureLoginPassword is used. AuxAddrs []AuxAddr `json:"auxiliary_addresses"` // Maidenhead grid square (e.g. JP20qe). Locator string `json:"locator"` // Message size limit (in bytes) for automatic download of pending messages. // // When receiving messages larger than this limit, the user will be prompted // with the option to defer the download to a later session. // // Negative value means no limit. AutoDownloadSizeLimit int `json:"auto_download_size_limit"` // List of service codes for rmslist (defaults to PUBLIC) ServiceCodes []string `json:"service_codes"` // Default HTTP listen address (for web UI). // // Use ":8080" to listen on any device, port 8080. HTTPAddr string `json:"http_addr"` // Handshake comment lines sent to remote node on incoming connections. // // Example: ["QTH: Hagavik, Norway. Operator: Martin", "Rig: FT-897 with Signalink USB"] MOTD []string `json:"motd"` // Connect aliases // // Example: {"LA1B-10": "ax25:///LD5GU/LA1B-10", "LA1B": "ardop://LA3F?freq=5350"} // Any occurrence of the substring "{mycall}" will be replaced with user's callsign. ConnectAliases map[string]string `json:"connect_aliases"` // Methods to listen for incoming P2P connections by default. // // Example: ["ax25", "telnet", "ardop"] Listen []string `json:"listen"` // Hamlib rigs available (with reference name) for ptt and frequency control. HamlibRigs map[string]HamlibConfig `json:"hamlib_rigs"` AX25 AX25Config `json:"ax25"` // See AX25Config. AX25Linux AX25LinuxConfig `json:"ax25_linux"` // See AX25LinuxConfig. AGWPE AGWPEConfig `json:"agwpe"` // See AGWPEConfig. SerialTNC SerialTNCConfig `json:"serial-tnc"` // See SerialTNCConfig. Ardop ArdopConfig `json:"ardop"` // See ArdopConfig. Pactor PactorConfig `json:"pactor"` // See PactorConfig. Telnet TelnetConfig `json:"telnet"` // See TelnetConfig. VaraHF VaraConfig `json:"varahf"` // See VaraConfig. VaraFM VaraConfig `json:"varafm"` // See VaraConfig. // See GPSdConfig. GPSd GPSdConfig `json:"gpsd"` // See PredictionConfig. Prediction PredictionConfig `json:"prediction,omitzero"` // Command schedule (cron-like syntax). // // Examples: // # Connect to telnet once every hour // "@hourly": "connect telnet" // // # Change ardop listen frequency based on hour of day // "00 10 * * *": "freq ardop:7350.000", # 40m from 10:00 // "00 18 * * *": "freq ardop:5347.000", # 60m from 18:00 // "00 22 * * *": "freq ardop:3602.000" # 80m from 22:00 Schedule map[string]string `json:"schedule"` // By default, Pat posts your callsign and running version to the Winlink CMS Web Services // // Set to true if you don't want your information sent. VersionReportingDisabled bool `json:"version_reporting_disabled"` } func (c *Config) UnmarshalJSON(b []byte) error { type aliased Config tmp := struct { aliased // Default to -1 if omitted (legacy configs) AutoDownloadSizeLimit *int `json:"auto_download_size_limit"` }{} if err := json.Unmarshal(b, &tmp); err != nil { return err } if ptr := tmp.AutoDownloadSizeLimit; ptr == nil { tmp.aliased.AutoDownloadSizeLimit = -1 } else { tmp.aliased.AutoDownloadSizeLimit = *tmp.AutoDownloadSizeLimit } *c = Config(tmp.aliased) return nil } type PredictionConfig struct { // engine sets the HF propagation prediction engine to be used. // Valid options are: // - empty string (autodetect) // - voacap // - voacap-api // - disabled // If empty, autodetection is attempted. Engine PredictionEngine `json:"engine"` // See VOACAPConfig. VOACAP VOACAPConfig `json:"voacap,omitzero"` // See VOACAPAPIConfig. VOACAPAPI VOACAPAPIConfig `json:"voacap_api,omitzero"` } func (p PredictionConfig) IsZero() bool { return p == (PredictionConfig{}) } type VOACAPConfig struct { // Executable overrides the default executable for VOACAP. // Default is c:\itshfbc\bin_win\voacapw.exe on Windows and voacapl for other platforms. Executable string `json:"executable"` // DataDir overrides the default data directory for VOACAP. // Default is c:\itshfbc on Windows and $HOME/itshfbc for other platforms. DataDir string `json:"data_dir"` } func (v VOACAPConfig) IsZero() bool { return v == (VOACAPConfig{}) } type VOACAPAPIConfig struct { // BaseURL is the base URL for the VOACAP API. // E.g. http://localhost:3000 BaseURL string `json:"base_url"` } func (v VOACAPAPIConfig) IsZero() bool { return v == (VOACAPAPIConfig{}) } type HamlibConfig struct { // The network type ("serial" or "tcp"). Use 'tcp' for rigctld (default). // // (For serial support: build with "-tags libhamlib".) Network string `json:"network,omitempty"` // The rig address. // // For tcp (rigctld): "address:port" (e.g. localhost:4532). // For serial: "/path/to/tty?model=&baudrate=" (e.g. /dev/ttyS0?model=123&baudrate=4800). Address string `json:"address,omitempty"` // The rig's VFO to control ("A" or "B"). If empty, the current active VFO is used. VFO string `json:"VFO"` } type ArdopConfig struct { // Network address of the Ardop TNC (e.g. localhost:8515). Addr string `json:"addr"` // Default/listen ARQ bandwidth (200/500/1000/2000 MAX/FORCED). ARQBandwidth ardop.Bandwidth `json:"arq_bandwidth"` // Number of connect frames to transmit when dialing. // // Some stations may require mutliple attempts before responding. ConnectRequests int `json:"connect_requests"` // (optional) Reference name to the Hamlib rig to control frequency and ptt. Rig string `json:"rig"` // Set to true if hamlib should control PTT (SignaLink=false, most rigexpert=true). PTTControl bool `json:"ptt_ctrl"` // (optional) Send ID frame at a regular interval when the listener is active (unit is seconds) BeaconInterval int `json:"beacon_interval"` // Send FSK CW ID after an ID frame. CWID bool `json:"cwid_enabled"` } type VaraConfig struct { // Network host of the VARA modem (defaults to localhost:8300). Addr string `json:"addr"` // Default/listen bandwidth (HF: 500/2300/2750 Hz). Bandwidth int `json:"bandwidth,omitempty"` // (optional) Reference name to the Hamlib rig to control frequency and ptt. Rig string `json:"rig"` // Set to true if hamlib should control PTT (SignaLink=false, most rigexpert=true). PTTControl bool `json:"ptt_ctrl"` } // UnmarshalJSON implements VaraConfig JSON unmarshalling with support for legacy format. func (v *VaraConfig) UnmarshalJSON(b []byte) error { type newFormat VaraConfig legacy := struct { newFormat Host string `json:"host"` CmdPort int `json:"cmdPort"` DataPort int `json:"dataPort"` }{} if err := json.Unmarshal(b, &legacy); err != nil { return err } if legacy.newFormat.Addr == "" && legacy.Host != "" { legacy.newFormat.Addr = fmt.Sprintf("%s:%d", legacy.Host, legacy.CmdPort) } *v = VaraConfig(legacy.newFormat) if !v.IsZero() && v.CmdPort() <= 0 { return fmt.Errorf("invalid addr format") } return nil } func (v VaraConfig) IsZero() bool { return v == (VaraConfig{}) } func (v VaraConfig) Host() string { host, _, _ := net.SplitHostPort(v.Addr) return host } func (v VaraConfig) CmdPort() int { _, portStr, _ := net.SplitHostPort(v.Addr) port, _ := strconv.Atoi(portStr) return port } func (v VaraConfig) DataPort() int { return v.CmdPort() + 1 } type PactorConfig struct { // Path/port to TNC device (e.g. /dev/ttyUSB0 or COM1). Path string `json:"path"` // Baudrate for the serial port (e.g. 57600). Baudrate int `json:"baudrate"` // (optional) Reference name to the Hamlib rig for frequency control. Rig string `json:"rig"` // (optional) Path to custom TNC initialization script. InitScript string `json:"custom_init_script"` } type TelnetConfig struct { // Network address (and port) to listen for telnet-p2p connections (e.g. :8774). ListenAddr string `json:"listen_addr"` // Telnet-p2p password. Password string `json:"password"` } type SerialTNCConfig struct { // Serial port (e.g. /dev/ttyUSB0 or COM1). Path string `json:"path"` // SerialBaud is the serial port's baudrate (e.g. 57600). SerialBaud int `json:"serial_baud"` // HBaud is the the packet connection's baudrate (1200 or 9600). HBaud int `json:"hbaud"` // Type of TNC (currently only 'kenwood'). Type string `json:"type"` } type AGWPEConfig struct { // The TCP address of the TNC. Addr string `json:"addr"` // The AGWPE "radio port" (0-3). RadioPort int `json:"radio_port"` } type AX25Config struct { // The AX.25 engine to be used. // // Valid options are: // - linux // - agwpe // - serial-tnc Engine AX25Engine `json:"engine"` // (optional) Reference name to the Hamlib rig for frequency control. Rig string `json:"rig"` // DEPRECATED: See AX25Linux.Port. AXPort string `json:"port,omitempty"` // Optional beacon when listening for incoming packet-p2p connections. Beacon BeaconConfig `json:"beacon"` } type AX25LinuxConfig struct { // axport to use (as defined in /etc/ax25/axports). Only applicable to ax25 engine 'linux'. Port string `json:"port"` } type BeaconConfig struct { // Beacon interval in seconds (e.g. 3600 for once every 1 hour) Every int `json:"every"` // (seconds) // Beacon data/message Message string `json:"message"` // Beacon destination (e.g. IDENT) Destination string `json:"destination"` } type GPSdConfig struct { // Enable GPSd proxy for HTTP (web GUI) // // Caution: Your GPS position will be accessible to any network device able to access Pat's HTTP interface. EnableHTTP bool `json:"enable_http"` // Allow Winlink forms to use GPSd for aquiring your position. // // Caution: Your current GPS position will be automatically injected, without your explicit consent, into forms requesting such information. AllowForms bool `json:"allow_forms"` // Use server time instead of timestamp provided by GPSd (e.g for older GPS device with week roll-over issue). UseServerTime bool `json:"use_server_time"` // Automatically update the locator field in-memory by polling GPSd every hour. // // Note: This only updates the locator in-memory. The config file is not modified. // On startup, the config's locator value will be used until the first position is received from GPSd. UpdateLocator bool `json:"update_locator"` // Address and port of GPSd server (e.g. localhost:2947). Addr string `json:"addr"` } var DefaultConfig = Config{ MOTD: []string{"Open source Winlink client - getpat.io"}, AuxAddrs: []AuxAddr{}, ServiceCodes: []string{"PUBLIC"}, AutoDownloadSizeLimit: -1, ConnectAliases: map[string]string{ "telnet": "telnet://{mycall}:CMSTelnet@cms.winlink.org:8772/wl2k", }, Listen: []string{}, HTTPAddr: "localhost:8080", AX25: AX25Config{ Engine: DefaultAX25Engine(), Beacon: BeaconConfig{ Every: 3600, Message: "Winlink P2P", Destination: "IDENT", }, }, AX25Linux: AX25LinuxConfig{ Port: "wl2k", }, SerialTNC: SerialTNCConfig{ Path: "/dev/ttyUSB0", SerialBaud: 9600, HBaud: 1200, Type: "kenwood", }, AGWPE: AGWPEConfig{ Addr: "localhost:8000", RadioPort: 0, }, Ardop: ArdopConfig{ Addr: "localhost:8515", ARQBandwidth: ardop.Bandwidth500Max, ConnectRequests: ardop.DefaultConnectRequests, CWID: true, }, Pactor: PactorConfig{ Path: "/dev/ttyUSB0", Baudrate: 57600, }, Telnet: TelnetConfig{ ListenAddr: ":8774", Password: "", }, VaraHF: VaraConfig{ Addr: "localhost:8300", Bandwidth: 2300, }, VaraFM: VaraConfig{ Addr: "localhost:8300", }, GPSd: GPSdConfig{ EnableHTTP: false, // Default to false to help protect privacy of unknowing users (see github.com//issues/146) AllowForms: false, // Default to false to help protect location privacy of unknowing users UseServerTime: false, UpdateLocator: false, Addr: "localhost:2947", // Default listen address for GPSd }, Schedule: map[string]string{}, HamlibRigs: map[string]HamlibConfig{}, } pat-1.0.0/cfg/prediction_engine.go 0000664 0000000 0000000 00000001340 15203222376 0017047 0 ustar 00root root 0000000 0000000 package cfg import ( "encoding/json" "fmt" "strings" ) type PredictionEngine string const ( PredictionEngineAuto PredictionEngine = "" PredictionEngineDisabled PredictionEngine = "disabled" PredictionEngineVOACAP PredictionEngine = "voacap" PredictionEngineVOACAPAPI PredictionEngine = "voacap-api" ) func (p *PredictionEngine) UnmarshalJSON(b []byte) error { var str string if err := json.Unmarshal(b, &str); err != nil { return err } switch v := PredictionEngine(strings.ToLower(strings.TrimSpace(str))); v { case PredictionEngineVOACAP, PredictionEngineVOACAPAPI, PredictionEngineDisabled, PredictionEngineAuto: *p = v return nil default: return fmt.Errorf("invalid prediction engine '%s'", v) } } pat-1.0.0/cli/ 0000775 0000000 0000000 00000000000 15203222376 0013045 5 ustar 00root root 0000000 0000000 pat-1.0.0/cli/account.go 0000664 0000000 0000000 00000003770 15203222376 0015037 0 ustar 00root root 0000000 0000000 package cli import ( "context" "fmt" "log" "os" "strings" "time" "github.com/la5nta/pat/app" "github.com/la5nta/pat/internal/cmsapi" ) const ( AccountUsage = `property [value] properties: password.recovery.email ` AccountExample = ` account password.recovery.email Get your current password recovery email for winlink.org. account password.recovery.email me@example.com Set your password recovery email to for winlink.org to "me@example.com". ` ) func AccountHandle(ctx context.Context, app *app.App, args []string) { switch cmd, args := shiftArgs(args); cmd { case "password.recovery.email": if err := passwordRecoveryEmailHandle(ctx, app, args); err != nil { fmt.Println("ERROR:", err) os.Exit(1) } default: fmt.Println("Missing argument, try 'account help'.") } } // getPasswordForCallsign gets the password for the specified callsign // It tries the configured SecureLoginPassword first, then prompts if not available func getPasswordForCallsign(ctx context.Context, a *app.App, callsign string) string { password := a.Config().SecureLoginPassword if password != "" { return password } select { case <-ctx.Done(): return "" case resp := <-a.PromptHub().Prompt(ctx, time.Minute, app.PromptKindPassword, "Enter account password for "+callsign): if resp.Err != nil { log.Printf("Password prompt error: %v", resp.Err) return "" } return resp.Value } } func passwordRecoveryEmailHandle(ctx context.Context, a *app.App, args []string) error { mycall := a.Options().MyCall password := getPasswordForCallsign(ctx, a, mycall) arg, _ := shiftArgs(args) if arg != "" { if err := cmsapi.PasswordRecoveryEmailSet(ctx, mycall, password, arg); err != nil { return fmt.Errorf("failed to set value: %w", err) } } email, err := cmsapi.PasswordRecoveryEmailGet(ctx, mycall, password) switch { case err != nil: return fmt.Errorf("failed to get value: %w", err) case strings.TrimSpace(email) == "": email = "[not set]" } fmt.Println(email) return nil } pat-1.0.0/cli/commands.go 0000664 0000000 0000000 00000012760 15203222376 0015203 0 ustar 00root root 0000000 0000000 package cli import ( "context" "log" "github.com/la5nta/pat/app" ) var Commands = []app.Command{ { Str: "init", Desc: "Initial configuration setup.", HandleFunc: InitHandle, Usage: "Interactive basic setup with Winlink account verification.", }, { Str: "configure", Desc: "Open configuration file for editing.", HandleFunc: ConfigureHandle, }, { Str: "connect", Desc: "Connect to a remote station.", HandleFunc: ConnectHandle, Usage: UsageConnect, Example: ExampleConnect, MayConnect: true, }, { Str: "interactive", Desc: "Run interactive mode.", Usage: "[options]", Options: map[string]string{ "--http, -h": "Start http server for web UI in the background.", }, HandleFunc: InteractiveHandle, MayConnect: true, LongLived: true, }, { Str: "http", Desc: "Run http server for web UI.", Usage: "[options]", Options: map[string]string{ "--addr, -a": "Listen address. Default is :8080.", }, HandleFunc: HTTPHandle, MayConnect: true, LongLived: true, }, { Str: "compose", Desc: "Compose a new message.", Usage: "[options]\n" + "\tIf no options are passed, composes interactively.\n" + "\tIf options are passed, reads message from stdin similar to mail(1).", Options: map[string]string{ "--from, -r": "Address to send from. Default is your call from config or --mycall, but can be specified to use tactical addresses.", "--forward": "Forward given message (full path or mid)", "--in-reply-to": "Compose in reply to given message (full path or mid)", "--reply-all": "Reply to all (only applicable in combination with --in-reply-to)", "--template": "Compose using template file. Uses the --forms directory as root for relative paths.", "--subject, -s": "Subject", "--attachment , -a": "Attachment path (may be repeated)", "--cc, -c": "CC Address(es) (may be repeated)", "--p2p-only": "Send over peer to peer links only (avoid CMS)", "": "Recipient address (may be repeated)", }, HandleFunc: ComposeMessage, }, { Str: "read", Desc: "Read messages.", HandleFunc: ReadHandle, }, { Str: "composeform", Aliases: []string{"formPath"}, Desc: "Post form-based report. (DEPRECATED)", Usage: "[options]", Options: map[string]string{ "--template": "path to the form template file. Uses the --forms directory as root. Defaults to 'ICS USA Forms/ICS213.txt'", }, HandleFunc: func(ctx context.Context, app *app.App, args []string) { log.Println("DEPRECATED: Use `compose --template` instead") if len(args) == 0 || args[0] == "" { args = []string{"ICS USA Forms/ICS213.txt"} } ComposeMessage(ctx, app, append([]string{"--template"}, args...)) }, }, { Str: "position", Aliases: []string{"pos"}, Desc: "Post a position report (GPSd or manual entry).", Usage: "[options]", Options: map[string]string{ "--latlon": "latitude,longitude in decimal degrees for manual entry. Will use GPSd if this is empty.", "--comment, -c": "Comment to be included in the position report.", }, Example: ExamplePosition, HandleFunc: PositionHandle, }, { Str: "extract", Desc: "Extract attachments from a message file.", Usage: "[full path or mid]", HandleFunc: ExtractMessageHandle, }, { Str: "rmslist", Desc: "Print/search in list of RMS nodes.", Usage: "[options] [search term]", Options: map[string]string{ "--mode, -m": "Mode filter.", "--band, -b": "Band filter (e.g. '80m').", "--force-download, -d": "Force download of latest list from winlink.org.", "--sort-distance, -s": "Sort by distance", "--sort-link-quality, -q": "Sort by predicted link quality (requires VOACAP)", }, HandleFunc: RMSListHandle, }, { Str: "updateforms", Desc: "Download the latest form templates. (DEPRECATED)", HandleFunc: func(ctx context.Context, a *app.App, args []string) { log.Println("DEPRECATED: Use `templates update` instead") TemplatesHandle(ctx, a, []string{"update"}) }, }, { Str: "templates", Desc: "Manage message templates and HTML forms.", Usage: TemplatesUsage, Example: TemplatesExample, HandleFunc: TemplatesHandle, }, { Str: "account", Desc: "Get and set Winlink.org account settings.", Usage: AccountUsage, Example: AccountExample, HandleFunc: AccountHandle, }, { Str: "mps", Desc: "Manage message pickup stations.", Usage: MPSUsage, Example: MPSExample, HandleFunc: MPSHandle, }, { Str: "version", Desc: "Print the application version.", Usage: "[options]", Options: map[string]string{ "--check, -c": "Check if a new version is available", "--verbose, -v": "Show detailed build information", }, HandleFunc: VersionHandle, }, { Str: "env", Desc: "List environment variables.", HandleFunc: EnvHandle, }, { Str: "help", Desc: "Print detailed help for a given command.", // Avoid initialization loop by invoking helpHandler in main }, } func FindCommand(args []string) (cmd app.Command, pre, post []string, err error) { cmdMap := make(map[string]app.Command, len(Commands)) for _, c := range Commands { cmdMap[c.Str] = c for _, alias := range c.Aliases { cmdMap[alias] = c } } for i, arg := range args { if cmd, ok := cmdMap[arg]; ok { return cmd, args[1:i], args[i+1:], nil } } err = app.ErrNoCmd return } pat-1.0.0/cli/composer.go 0000664 0000000 0000000 00000021745 15203222376 0015234 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 cli import ( "bufio" "bytes" "context" "fmt" "io" "log" "os" "path/filepath" "strings" "github.com/la5nta/pat/app" "github.com/la5nta/pat/internal/editor" "github.com/la5nta/wl2k-go/fbb" "github.com/spf13/pflag" ) type composerFlags struct { // Headers from string to []string cc []string subject string p2pOnly bool body string attachmentPaths []string attachments []*fbb.File // forwarded attachments and/or attachments generated from template template string // path to template/form forward string // path/mid inReplyTo string // path/mid replyAll bool } func ComposeMessage(ctx context.Context, app *app.App, args []string) { exitOnContextCancellation(ctx) var flags composerFlags set := pflag.NewFlagSet("compose", pflag.ExitOnError) set.StringVarP(&flags.from, "from", "r", app.Options().MyCall, "") set.StringVarP(&flags.subject, "subject", "s", "", "") set.StringArrayVarP(&flags.attachmentPaths, "attachment", "a", nil, "") set.StringArrayVarP(&flags.cc, "cc", "c", nil, "") set.BoolVarP(&flags.p2pOnly, "p2p-only", "", false, "") set.StringVarP(&flags.template, "template", "", "", "") set.StringVarP(&flags.inReplyTo, "in-reply-to", "", "", "") set.StringVarP(&flags.forward, "forward", "", "", "") set.BoolVarP(&flags.replyAll, "reply-all", "", false, "") set.Parse(args) // Remaining args are recipients for _, r := range set.Args() { if strings.TrimSpace(r) == "" { // Filter out empty args (this actually happens) continue } flags.to = append(flags.to, r) } composeMessage(app, flags, isTerminal(os.Stdin)) } func composeMessage(app *app.App, flags composerFlags, interactive bool) { switch { case flags.inReplyTo != "" && flags.forward != "": log.Fatal("reply and forward are mutually exclusive operations") case flags.inReplyTo != "": if err := prepareReply(app, &flags); err != nil { log.Fatal(err) } case flags.forward != "": if err := prepareForward(app, &flags); err != nil { log.Fatal(err) } } if interactive { promptHeader(&flags) } if err := buildBody(app, &flags, interactive); err != nil { log.Fatal(err) } if interactive { promptAttachments(&flags.attachmentPaths) if !previewAndPromptConfirmation(&flags) { return } } msg := buildMessage(app.Options().MyCall, flags) postMessage(app, msg) } func prepareReply(app *app.App, flags *composerFlags) error { originalMsg, err := openMessage(app, flags.inReplyTo) if err != nil { return err } if flags.subject == "" { flags.subject = "Re: " + strings.TrimSpace(strings.TrimPrefix(originalMsg.Subject(), "Re:")) } flags.to = append(flags.to, originalMsg.From().String()) if flags.replyAll { for _, addr := range append(originalMsg.To(), originalMsg.Cc()...) { if !addr.EqualString(app.Options().MyCall) { flags.cc = append(flags.cc, addr.String()) } } } var buf bytes.Buffer writeMessageCitation(&buf, originalMsg) flags.body = buf.String() return nil } func prepareForward(app *app.App, flags *composerFlags) error { originalMsg, err := openMessage(app, flags.forward) if err != nil { return err } if flags.subject == "" { flags.subject = "Fwd: " + strings.TrimSpace(strings.TrimPrefix(originalMsg.Subject(), "Fwd:")) } flags.attachments = append(flags.attachments, originalMsg.Files()...) var buf bytes.Buffer writeMessageCitation(&buf, originalMsg) flags.body = buf.String() return nil } func buildBody(app *app.App, flags *composerFlags, interactive bool) error { switch { case flags.template != "": inReplyTo, err := openMessage(app, flags.inReplyTo) if err != nil && flags.inReplyTo != "" { return err } formMsg, err := app.FormsManager().ComposeTemplate(flags.template, flags.subject, inReplyTo, readLine) if err != nil { return fmt.Errorf("failed to compose message for template: %w", err) } flags.subject = formMsg.Subject flags.body = formMsg.Body flags.attachments = append(flags.attachments, formMsg.Attachments...) case interactive: promptBody(&flags.body) default: // Read body from stdin body, _ := io.ReadAll(os.Stdin) if len(body) == 0 { fmt.Fprint(os.Stderr, "Null message body; hope that's ok\n") } flags.body = string(body) } return nil } func postMessage(a *app.App, msg *fbb.Message) { if err := msg.Validate(); err != nil { fmt.Printf("WARNING - Message does not validate: %s\n", err) } if err := a.Mailbox().AddOut(msg); err != nil { log.Fatal(err) } fmt.Println("Message posted") } func promptHeader(flags *composerFlags) { flags.from = prompt("From", flags.from) flags.to = strings.FieldsFunc(prompt("To", strings.Join(flags.to, ",")), SplitFunc) flags.cc = strings.FieldsFunc(prompt("Cc", strings.Join(flags.cc, ",")), SplitFunc) switch len(flags.to) + len(flags.cc) { case 1: if flags.p2pOnly { flags.p2pOnly = strings.EqualFold(prompt("P2P only", "Y", "n"), "y") } else { flags.p2pOnly = strings.EqualFold(prompt("P2P only", "N", "y"), "y") } case 0: fmt.Println("Message must have at least one recipient") os.Exit(1) } flags.subject = prompt("Subject", flags.subject) // A message without subject is not valid, so let's use a sane default if flags.subject == "" { flags.subject = "6Ҍ3=z ;DXn57+a ]6Ǿo\X|~ĭn,e˕!
J_>NɎCpФTYJ~D3Z 5nņB,\CDpyqH7 p{`M-$6+͌;HNlXߩ
ϗQn! 9
ӂIg;p &T ⠊3
rkWsZr*F#kC])-fЅv8Fpcl1bYWGڏ( vo^׳\YUFr
TAvKi$An5O0.][:peblB:H/g`OH^Ti#*qjDb,EN1Ylf[u(
XYFLZ#>v,9].D3hhVǺ>f0 Dm9領L[mq- %),LkX[eن2Q$ፔ6$RL' .DIVy1tP+\Q.~юlcpfyĭs7K*5Bm1 Εa:aH>Ip|iy=u~̮F&IB]jdwN
]IQI-Z([w8|*{lӜ8s:R㋤B'{f)y%Ƌt]ʐ-D[8xm0^'*m Q ;)&@kD]ʺ vyӉ+jY T
heɗb`d[me35Ív[22 q
7pa+{ore|gr$3. L_@͟ ]丱LvX]~%c3YSc{x_q\eݯD9,?LcIPS8yȫCqhtэ'- + 0t$eӘXVƱ+j)ʗyDViM Hbb
їVV>u
*JVJb吂=r~~\OS bX3$nQѢԉ[@Z(VMڪ
?@,iUaָN.h%*,p\&7pLK'-tØR-Y)apfx ZTG[!=}>>[IJcF8笿0Мaax` UFbxk00?sVӧɻA>Nlǟ7tr^
]h,c]ef7<JcMm0"vbgv-xڭ(
FiN
S`K;ZȟUt'Wj ;}QKXӻBsߔ KPlu! {dPݳOOJo~pr_x#v=ߐ ùl K6* *'iPYM{N^K
Z;\O%sPgd6ݓ eJP3l~ ԼpGuЙ>?j;YeA9E~]*>#k. `75ꨝ
ۦ9ֶ3`^
O1ShKHanxzXlpY| CQjUxO۠G\ ˚gY
C/l_=lL6Ӣ6]l4m FayU$@lQR8#;|WF w֭a-v_J菗e0SUjJ~@D oe* }r70( lppmoT