From 1fe0d00fae6cdec10b475a3d761651de04b25ee5 Mon Sep 17 00:00:00 2001 From: "Rich O." Date: Thu, 5 Nov 2026 15:02:22 -0500 Subject: [PATCH] palm-client: Trace Path (Go menu, or a contact's More > Trace / Route): a trace through the repeaters typed as hop codes or picked with Add, out and back the same way, listing the SNR each hop heard it at and the time it took. For a contact it starts from its route, and Set Route makes the hops its route (ADD_UPDATE_CONTACT from its own record, so nothing else changes). Ping: a trace to a repeater one hop away and back --- palm-client/src/trace_form.c | 406 +++++++++++++++++++++++++++++++++++ palm-client/src/trace_form.h | 18 ++ 2 files changed, 424 insertions(+) create mode 100644 palm-client/src/trace_form.c create mode 100644 palm-client/src/trace_form.h diff --git a/palm-client/src/trace_form.c b/palm-client/src/trace_form.c new file mode 100644 index 0000000..2af2284 --- /dev/null +++ b/palm-client/src/trace_form.c @@ -0,0 +1,406 @@ +/* + * Trace Path: sends a trace through the repeaters typed as hop codes (or + * picked with Add), out and, with Round trip, back the same way, and lists + * the SNR each hop heard it at and the time it took. Opened for a contact + * (More > Trace / Route), it starts from the contact's route, and Set Route + * makes the hops (out only) the contact's route. Ping is a trace to a + * repeater one hop away and back. + */ +#include +#include "resources.h" +#include "session.h" +#include "contacts.h" +#include "contact_form.h" +#include "protocol2.h" +#include "info_fmt.h" +#include "app.h" +#include "ui/draw.h" +#include "ui/text.h" +#include "ui/rowlist.h" +#include "ui/glyphs.h" +#include "ui/title.h" +#include "trace_form.h" + +static void *GetObject(FormType *form, UInt16 id) VM_SECT5; +static void Note(const Char *msg) VM_SECT5; +static UInt8 TraceSize(void) VM_SECT5; +static void FillFromRoute(FormType *form) VM_SECT5; +static void DrawRow(UInt16 row, const RectangleType *b, void *ctx) VM_SECT5; +static Int16 ReadHops(FormType *form, UInt8 *hops, UInt8 *size) VM_SECT5; +static void Run(FormType *form) VM_SECT5; +static void AddHop(FormType *form) VM_SECT5; +static void SetRoute(FormType *form) VM_SECT5; +static Boolean IsSelf(const UInt8 *hash, UInt8 size) VM_SECT5; + +#define MAX_REPEATERS 40 +#define LABEL_MAX 32 + +static VmContact gContact; +static Boolean gForContact; +static Char gLabel[64]; /* cut to LABEL_MAX for the form's label */ +static VmTrace gTrace; +static UInt32 gTripMs; +static Err gErr; +static UInt8 gSent[VM_TRACE_MAX]; /* the path traced, for naming the hops */ +static RowList gList; + +void TraceFormOpen(const VmContact *c) +{ + gForContact = c != NULL; + if (c) + gContact = *c; + FrmGotoForm(TraceForm); +} + +static void *GetObject(FormType *form, UInt16 id) +{ + return FrmGetObjectPtr(form, FrmGetObjectIndex(form, id)); +} + +static void Note(const Char *msg) +{ + FrmCustomAlert(SettingsErrorAlert, msg, "", ""); +} + +/* Hop codes as long as the radio's path hashes (a 3-byte one is traced as 4: keys match either way). */ +static UInt8 TraceSize(void) +{ + UInt8 mode = SessionDevice()->hasPathHashMode ? SessionDevice()->pathHashMode : 0; + + return mode == 0 ? 1 : mode == 1 ? 2 : 4; +} + +/* The contact's route from the radio as hop codes; a repeater's own code goes last, as the trace's far end. */ +static void FillFromRoute(FormType *form) +{ + UInt8 frame[VM_HEADER_LEN + 1 + VM_PUB_KEY_SIZE], reply[VM_CONTACT_FRAME_LEN], pathLen, path[VM_MAX_PATH_SIZE]; + FieldType *f = GetObject(form, TraceField); + Char text[64], hex[10]; + UInt16 len, got, i, hops = 0, size = 0; + + text[0] = 0; + StrPrintF(gLabel, "%s: ", gContact.name); + len = VmBuildGetContactByKey(frame, sizeof(frame), gContact.pubKey); + if (SessionQuery(frame, len, VM_RESP_CONTACT, reply, sizeof(reply), &got) == errNone && + VmContactPath(reply, got, &pathLen, path)) { + if (pathLen == VM_PATH_UNKNOWN) { + StrCat(gLabel, "no route (flood)"); + } else { + hops = VM_PATH_HOPS(pathLen); + size = VM_PATH_HASH_BYTES(pathLen); + if (hops == 0) + StrCat(gLabel, "direct, no repeaters"); + else + StrPrintF(gLabel + StrLen(gLabel), "route of %u hop%s", hops, hops == 1 ? "" : "s"); + for (i = 0; i < hops && (i + 1) * size <= VM_MAX_PATH_SIZE && StrLen(text) + 10 < sizeof(text); i++) { + TxtHex(path + i * size, size, hex); + if (i) + StrCat(text, " "); + StrCat(text, hex); + } + } + } else { + StrCat(gLabel, "route unknown"); + } + if (gContact.type == VM_ADV_TYPE_REPEATER && StrLen(text) + 10 < sizeof(text)) { + TxtHex(gContact.pubKey, size ? size : TraceSize(), hex); + if (text[0]) + StrCat(text, " "); + StrCat(text, hex); + } + FldDelete(f, 0, FldGetTextLength(f)); + FldInsert(f, text, StrLen(text)); +} + +/* + * Row 0: the outcome; then one per hop: who heard it and at what SNR, the + * last being us. + */ +static void DrawRow(UInt16 row, const RectangleType *b, void *ctx) +{ + FontID old = FntSetFont(vmSmallFont); + Coord x = b->topLeft.x + 1, y = b->topLeft.y, right = b->topLeft.x + b->extent.x - 1; + Char line[48], snr[8], msg[48]; + + if (row == 0) { + if (gErr == vmErrNoReply) + StrCopy(line, "No answer: a hop didn't hear it."); + else if (gErr != errNone) { + AppErrorText(gErr, msg); + StrCopy(line, msg); + } else + StrPrintF(line, "Back in %lu.%lu s, %u hop%s", gTripMs / 1000, gTripMs % 1000 / 100, + gTrace.hops, gTrace.hops == 1 ? "" : "s"); + WinDrawChars(line, StrLen(line), x, y); + } else { + line[0] = GLYPH_FORWARD; + line[1] = ' '; + line[2] = 0; + if (row - 1 < gTrace.hops) + InfoHop(line, sizeof(line), gSent + (row - 1) * gTrace.hashSize, gTrace.hashSize); + else + StrCat(line, "you"); + DrawCut(line, x, y, right - 30 - x); + TxtFormatSnr(snr, gTrace.snrQ[row - 1]); + DrawRight(snr, right, y); + } + FntSetFont(old); +} + +/* The typed hops; -1 (after saying why) if they don't parse. */ +static Int16 ReadHops(FormType *form, UInt8 *hops, UInt8 *size) +{ + const Char *t = FldGetTextPtr(GetObject(form, TraceField)); + Int16 n = VmParseHopCodes(t ? t : "", hops, VM_TRACE_MAX, size); + + if (n < 0) + Note("Hops are hex codes of 2, 4 or 8 digits, all the same length, separated by spaces."); + return n; +} + +static void Run(FormType *form) +{ + UInt8 hops[VM_TRACE_MAX], size; + Int16 n = ReadHops(form, hops, &size), i, total; + + if (n < 0) + return; + if (n == 0) { + Note("Add a hop first: the repeaters to trace through."); + return; + } + if (!SessionIsConnected()) { + Note("Connect to the radio first (Node)."); + return; + } + total = n; + if (CtlGetValue(GetObject(form, TraceRoundCheck))) { + /* back the same way: A B C -> A B C B A */ + for (i = n - 2; i >= 0 && (total + 1) * size <= VM_TRACE_MAX; i--, total++) + MemMove(hops + total * size, hops + i * size, size); + if (i >= 0) { + Note("That's too many hops for a round trip."); + return; + } + } + MemMove(gSent, hops, total * size); + TitleStatus("tracing..."); + gErr = SessionTrace(hops, total * size, size, &gTrace, &gTripMs); + TitleStatus(""); + if (gErr != errNone) + gTrace.hops = 0; + RowListSetCount(&gList, gErr == errNone ? 2 + gTrace.hops : 1); + RowListScrollTo(&gList, 0); + RowListDraw(&gList); +} + +/* Appends a repeater's code, picked from the contacts by name. */ +static void AddHop(FormType *form) +{ + ListType *list = GetObject(form, TraceHopList); + FieldType *f = GetObject(form, TraceField); + Char **names; + UInt8 (*keys)[4]; + UInt16 i, n = 0, count = ContactsCount(); + UInt8 size = TraceSize(); + VmContact c; + Char hex[10]; + Int16 pick; + + names = MemPtrNew(MAX_REPEATERS * (sizeof(Char *) + VM_NAME_SIZE)); + keys = MemPtrNew(MAX_REPEATERS * 4); + if (!names || !keys) { + if (names) + MemPtrFree(names); + if (keys) + MemPtrFree(keys); + return; + } + for (i = 0; i < count && n < MAX_REPEATERS; i++) { + if (!ContactsGet(i, &c) || c.type != VM_ADV_TYPE_REPEATER) + continue; + names[n] = (Char *)(names + MAX_REPEATERS) + n * VM_NAME_SIZE; + StrCopy(names[n], c.name); + MemMove(keys[n], c.pubKey, 4); + n++; + } + if (n == 0) { + Note("No repeaters in the contacts yet. Type a hop's code instead."); + } else { + LstSetListChoices(list, names, n); + LstSetHeight(list, n < 10 ? n : 10); + pick = LstPopupList(list); + if (pick >= 0) { + /* the size of the codes already typed, if any */ + const Char *t = FldGetTextPtr(f); + UInt8 typed[VM_TRACE_MAX], tsize; + + if (t && *t && VmParseHopCodes(t, typed, sizeof(typed), &tsize) > 0) + size = tsize; + TxtHex(keys[pick], size, hex); + FldSetInsertionPoint(f, FldGetTextLength(f)); + if (FldGetTextLength(f) && t[FldGetTextLength(f) - 1] != ' ') + FldInsert(f, " ", 1); + FldInsert(f, hex, StrLen(hex)); + } + } + LstSetListChoices(list, NULL, 0); + MemPtrFree(keys); + MemPtrFree(names); +} + +static Boolean IsSelf(const UInt8 *hash, UInt8 size) +{ + return MemCmp(hash, gContact.pubKey, size) == 0; +} + +/* The typed hops (out only; a repeater's own code at the end dropped) become the contact's route. */ +static void SetRoute(FormType *form) +{ + UInt8 hops[VM_TRACE_MAX], frame[VM_HEADER_LEN + VM_CONTACT_FRAME_LEN], reply[VM_CONTACT_FRAME_LEN]; + UInt8 size, pathSize = SessionDevice()->hasPathHashMode ? SessionDevice()->pathHashMode + 1 : 1, i; + Int16 n = ReadHops(form, hops, &size); + Char how[80], hex[10]; + UInt16 len, got; + Err err; + + if (n < 0) + return; + if (!SessionIsConnected()) { + Note("Connect to the radio first (Node)."); + return; + } + if (n > 0 && IsSelf(hops + (n - 1) * size, size)) + n--; + if (n > 0 && size < pathSize) { + StrPrintF(how, "Routes use %u-byte codes (%u hex digits) on this radio.", pathSize, pathSize * 2); + Note(how); + return; + } + /* stored at the radio's path hash size: longer codes are cut */ + for (i = 1; i < n && size > pathSize; i++) + MemMove(hops + i * pathSize, hops + i * size, pathSize); + if (n == 0) { + StrCopy(how, "directly, with no repeaters"); + } else { + StrCopy(how, "through"); + for (i = 0; i < n && StrLen(how) + 10 < sizeof(how); i++) { + TxtHex(hops + i * pathSize, pathSize, hex); + StrCat(how, " "); + StrCat(how, hex); + } + } + if (FrmCustomAlert(TraceRouteAlert, gContact.name, how, "") != 0) + return; + len = VmBuildGetContactByKey(frame, sizeof(frame), gContact.pubKey); + err = SessionQuery(frame, len, VM_RESP_CONTACT, reply, sizeof(reply), &got); + if (err == errNone) { + len = VmBuildContactRoute(frame, sizeof(frame), reply, got, pathSize, hops, (UInt8)n); + err = len ? SessionCommand(frame, len) : vmErrBadReply; + } + if (err == errNone) + err = ContactsUpdate(); + if (err != errNone) { + AppErrorText(err, how); + Note(how); + return; + } + ContactsFindByPrefixN(gContact.pubKey, VM_PUB_KEY_SIZE, &gContact); + FillFromRoute(form); + gLabel[LABEL_MAX] = 0; + FrmCopyLabel(form, TraceForLabel, gLabel); +} + +void TracePing(const VmContact *c) +{ + UInt8 size = TraceSize(); + VmTrace t; + UInt32 ms; + Char text[120], there[8], back[8], msg[48]; + Err err; + + if (!SessionIsConnected()) { + Note("Connect to the radio first (Node)."); + return; + } + if (c->type != VM_ADV_TYPE_REPEATER) { + Note("Only repeaters answer a ping (they pass traces on)."); + return; + } + err = SessionTrace(c->pubKey, size, size, &t, &ms); + if (err == errNone && t.hops >= 1) { + TxtFormatSnr(there, t.snrQ[0]); + TxtFormatSnr(back, t.snrQ[t.hops]); + StrPrintF(text, "%s answered in %lu.%lu s.\nIt heard us at %s, we heard it at %s.", c->name, + ms / 1000, ms % 1000 / 100, there, back); + } else if (err == vmErrNoReply) { + StrPrintF(text, "No answer from %s: it may be out of direct range. Trace Path reaches it through other repeaters.", c->name); + } else { + AppErrorText(err, msg); + StrCopy(text, msg); + } + FrmCustomAlert(PingAlert, text, "", ""); +} + +Boolean TraceFormHandleEvent(EventType *event) +{ + FormType *form = FrmGetActiveForm(); + Int16 tapped = -1; + + switch (event->eType) { + case frmOpenEvent: + gErr = errNone; + TitleStatusReset(); + RowListInit(&gList, TraceGadget, TraceScroll, VM_ROW_H, DrawRow, NULL, NULL); + CtlSetValue(GetObject(form, TraceRoundCheck), 1); + gLabel[0] = 0; + if (gForContact && SessionIsConnected()) + FillFromRoute(form); + else if (gForContact) + StrPrintF(gLabel, "%s: connect to read its route", gContact.name); + else + StrCopy(gLabel, "Repeaters to trace through:"); + gLabel[LABEL_MAX] = 0; + FrmCopyLabel(form, TraceForLabel, gLabel); + if (!gForContact) + FrmHideObject(form, FrmGetObjectIndex(form, TraceRouteButton)); + FrmDrawForm(form); + RowListDraw(&gList); + FrmSetFocus(form, FrmGetObjectIndex(form, TraceField)); + return true; + case frmUpdateEvent: + if (event->data.frmUpdate.updateCode == frmRedrawUpdateCode) { + FrmDrawForm(form); + RowListDraw(&gList); + } + return true; + case keyDownEvent: + if (event->data.keyDown.chr == linefeedChr) { + Run(form); + return true; + } + break; + case ctlSelectEvent: + switch (event->data.ctlSelect.controlID) { + case TraceGoButton: + Run(form); + return true; + case TraceAddButton: + AddHop(form); + return true; + case TraceRouteButton: + SetRoute(form); + return true; + case TraceDoneButton: + if (gForContact) + ContactFormOpen(&gContact); + else + FrmGotoForm(HomeForm); + return true; + } + break; + default: + break; + } + return RowListHandleEvent(&gList, event, &tapped); +} diff --git a/palm-client/src/trace_form.h b/palm-client/src/trace_form.h new file mode 100644 index 0000000..e1454d7 --- /dev/null +++ b/palm-client/src/trace_form.h @@ -0,0 +1,18 @@ +/* + * Trace Path (Go menu, or a contact's More > Trace / Route) and Ping (a + * repeater's More). Both send a trace, so both transmit. + */ +#ifndef VM_TRACE_FORM_H +#define VM_TRACE_FORM_H + +#include +#include "sections.h" /* this module is in the fifth code segment */ +#include "protocol.h" + +/* c NULL: any path; a contact: start from its route, and Set Route changes it. */ +void TraceFormOpen(const VmContact *c) VM_SECT5; +Boolean TraceFormHandleEvent(EventType *event) VM_SECT5; +/* A zero-hop trace to a repeater and back: the time and SNR both ways, in an alert. */ +void TracePing(const VmContact *c) VM_SECT5; + +#endif