mirror
/
SP8EBC-ParaTNC
kopia lustrzana https://github.com/SP8EBC/ParaTNC
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
SP8EBC-ParaTNC/system/src/aprs/message.c

571 wiersze
19 KiB
C
Czysty Bezpośredni odnośnik Wina Historia

/*
* message.c
*
* Created on: Apr 20, 2024
* Author: mateusz
*/
#include "message.h"
#include "variant.h"
#include "string.h"
#include "stdio.h"
#ifdef UNIT_TEST
#define STATIC
#else
#define STATIC static
#endif
#define MESSAGE_RECIPIENT_FIELD_SIZE 9
#define MESSAGE_SSID_CHARS_LN 2
#define MESSAGE_SENDER_CALL_SSID_MAXLEN 9
#define MESSAGE_COUNTER_MAXLEN 4
#define MESSAGE_MINIMUM_SENSEFUL_LN (MESSAGE_SENDER_CALL_SSID_MAXLEN + MESSAGE_RECIPIENT_FIELD_SIZE + MESSAGE_COUNTER_MAXLEN)
#define MESSAGE_CURRENT_CHAR *(message + content_position + i)
#define MESSAGE_CURRENT_SENDER_CHAR *(message + i)
#define MESSAGE_IS_HEX_DIGIT(c) ((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
#define MESSAGE_IS_DIGIT(c) ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
#define MESSAGE_IS_DIGIT_OR_LETTER(c) ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
#define MESSAGE_ACK_REMAINING_BUF (out_buffer_ln - current_pos)
#define MESSAGE_ACK_CURRENT_POS (char*)(out_buffer + current_pos)
static uint8_t message_tx_msg_couter = 0;
/**
* Lookup table used to string-to-int conversion for HEX strings. Value of 0x30 should be
* subtracted from ASCII scancode and this value should be used to intex this table
*/
static const int8_t message_atoi_lookup[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
-1, -1, -1, -1, -1, -1, -1,
10, 11, 12, 13, 14, 15,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
10, 11, 12, 13, 14, 15};
/**
* Convert string with message number to integer, with automatic detection of decimal or hex base. It operates
* only on positive integers up to 32 bit wide.
* @param string
* @param string_ln
* @param output optional pointer to message structure when output will be also put
* @return unsigned integer with decoded number
*/
STATIC uint32_t message_atoi_message_counter(const uint8_t const * string, uint8_t string_ln, message_t * output)
{
// sum to be returned
uint32_t sum = 0u;
// temporary buffer
int8_t conversion_table[6];
// set to non zero if any digit from A fo F was found in input string
int8_t is_hex = 0;
// checck if input string is located in legit RAM memory
if (variant_validate_is_within_ram(string) == 1 && string_ln <= 6) {
// clear intermediate convertion buffer
memset(conversion_table, 0x00, 6);
// iterator over conversion_table array
int8_t conversion_it = string_ln;
// iterate from the end of a string
for (int8_t string_it = string_ln; string_it >= 0; string_it--) {
// currently processed character
const uint8_t current_char = *(string + string_it - 1);
// check if current character is hex or dec base digit
if (MESSAGE_IS_DIGIT(current_char)) {
// calculate index to lookup table basing on current character
const uint8_t index = current_char - 0x30u;
// check lookup table for converting character with a digit to a number
conversion_table[string_ln - conversion_it] = message_atoi_lookup[index];
// decrement an interator
conversion_it--;
if (MESSAGE_IS_HEX_DIGIT(current_char)) {
is_hex = 1;
}
}
}
if (is_hex == 1) {
sum = (conversion_table[0]);
sum += (conversion_table[1] * 0x10);
sum += (conversion_table[2] * 0x100);
sum += (conversion_table[3] * 0x1000);
sum += (conversion_table[4] * 0x10000);
sum += (conversion_table[5] * 0x100000);
}
else {
sum = (conversion_table[0]);
sum += (conversion_table[1] * 10);
sum += (conversion_table[2] * 100);
sum += (conversion_table[3] * 1000);
sum += (conversion_table[4] * 10000);
sum += (conversion_table[5] * 100000);
}
}
if (variant_validate_is_within_ram(output) == 1) {
output->number = sum & 0xFFu;
if (is_hex == 1) {
if (output->source == MESSAGE_SOURCE_APRSIS) {
output->source = MESSAGE_SOURCE_APRSIS_HEXCNTR;
}
else if (output->source == MESSAGE_SOURCE_RADIO) {
output->source = MESSAGE_SOURCE_RADIO_HEXCNTR;
}
}
}
return sum;
}
/**
* Decode received data to look for an APRS message and put it into a structure
* @param message pointer to data received from APRS-IS
* @param message_ln lenght of a buffer content
* @param content_position optional position of an APRS message content (recipient callsign). if set to zero function will look for it
* @param output parsed APRS message content
* @return zero if message has been found and decoded, non zero if parsing failed
*/
uint8_t message_decode(const uint8_t * const message, const uint16_t message_ln, uint16_t content_position, message_source_t src, message_t * output) {
// example message:: SP8EBC>APX216,TCPIP*,qAC,NINTH::SR9WXZ :tedt{0s}\r\n
// result returned by the function, although shamesly it is also used as local aux variable
// in few places of this function :( this is what You sometimes do to save some stack.
uint8_t result = 0xFF;
uint16_t i = 0;
if (output == 0x00) {
return result;
}
if (message_ln < (MESSAGE_SENDER_CALL_SSID_MAXLEN + MESSAGE_RECIPIENT_FIELD_SIZE)) {
return result;
}
memset(output->number_str, 0x00, MESSAGE_NUMBER_STRING_BUFFER);
// if start position of APRS message (position of recipient callsign) has not been provided
if ((src == MESSAGE_SOURCE_APRSIS) && (content_position == 0)) {
// look for it
for (i = 0; i < message_ln; i++) {
const uint8_t * this_character = message + i;
const uint8_t * next_character = message + i + 1;
// break on an end of input string
if (*this_character == 0x00) {
break;
}
// check if double semicolon has been found
if ((*this_character == ':') && (*next_character == ':')) {
// APRS message starts after second semicolong
content_position = i + 2;
break;
}
}
}
// clear the iterator, it will be used across this function
i = 0;
// check content position one more time to verify
// if input data contains APRS message at all
if (
((src == MESSAGE_SOURCE_APRSIS) && (content_position != 0)) ||
(src == MESSAGE_SOURCE_RADIO)
) {
// set this variable to zero as now it will be used as a local
result = 0;
// clear output structure to make room for new data
memset(output, 0x00, sizeof(message_t));
//extract sender call and SSID only if this message has been received from APRS-IS in pure text form
if (src == MESSAGE_SOURCE_APRSIS) {
// fast forward any potential whitespace at the begining
while (MESSAGE_CURRENT_SENDER_CHAR == ' ') {
i++;
if (i >= message_ln) {
break;
}
}
// extract sender callsign
for (; i < MESSAGE_SENDER_CALL_SSID_MAXLEN; i++) {
// if SSID separator or sender end character ('>') has been reached
if (MESSAGE_CURRENT_SENDER_CHAR == '-' || MESSAGE_CURRENT_SENDER_CHAR == '>') {
break;
}
output->from.call[result++] = MESSAGE_CURRENT_SENDER_CHAR;
}
// check if sender has SSID
if (MESSAGE_CURRENT_SENDER_CHAR == '-') {
// jumps to next character. otherwise separating '-'
// will be interpreted as a minus/negitive sign
i++;
result = 0; // here used as a local iterator
// extract SSID
for (; i < MESSAGE_RECIPIENT_FIELD_SIZE; i++) {
// copy characters to aux buffer
output->number_str[result++] = MESSAGE_CURRENT_SENDER_CHAR;
// check if there isn't enough characters
if (result == MESSAGE_NUMBER_STRING_BUFFER) {
break;
}
}
// convert SSID to int
output->from.ssid = atoi(output->number_str);
}
// clear the iterator, it will be used across this function
i = 0;
}
else {
// clear content_position iterator
content_position = 0;
// find a begining of the message in data from radio channel
while (MESSAGE_CURRENT_CHAR != ':') {
content_position++;
if (content_position >= message_ln) {
break;
}
}
// jump over ':'
content_position++;
}
// extract recipient
for (; i < MESSAGE_RECIPIENT_FIELD_SIZE; i++) {
// look if end of callsign or separating '-' has been found
if (MESSAGE_CURRENT_CHAR == ' ' || MESSAGE_CURRENT_CHAR == '-') {
break; // and go for SSID reading
}
// copy recipient callsign character per character
output->to.call[i] = MESSAGE_CURRENT_CHAR;
}
// check if callsign has SSID set
if (MESSAGE_CURRENT_CHAR == '-') {
// jumps to next character. otherwise separating '-'
// will be interpreted as a minus/negitive sign
i++;
result = 0; // here used as a local iterator
// extract SSID
for (; i < MESSAGE_RECIPIENT_FIELD_SIZE; i++) {
// copy characters to aux buffer
output->number_str[result++] = MESSAGE_CURRENT_CHAR;
// check if there isn't enough characters
if (result == MESSAGE_NUMBER_STRING_BUFFER) {
break;
}
}
// convert SSID to int
output->to.ssid = atoi(output->number_str);
}
if (result != MESSAGE_NUMBER_STRING_BUFFER && /* if SSID extraction was OK and end of a buffer hasn't been reached */
(
(i < MESSAGE_RECIPIENT_FIELD_SIZE) || /* if recipient and callsign has been read before ':' separating from message content */
((i == MESSAGE_RECIPIENT_FIELD_SIZE) && (MESSAGE_CURRENT_CHAR == ':')) /* if a position of separating ':' was reached and ':' is there */
)
) {
// reinitialize buffer before next usage
memset(output->number_str, 0x00, MESSAGE_NUMBER_STRING_BUFFER);
// check if the iterator is set now to position of ':' separating
// recipient an the message itself
while(MESSAGE_CURRENT_CHAR != ':' && i <= MESSAGE_RECIPIENT_FIELD_SIZE) {
i++;
}
// one more incrementation to jump over ':' and land on the first character of the message
i++;
result = 0;
output->content_ln = 0;
// then copy message, which ends on a counter, something like '{1'
while(MESSAGE_CURRENT_CHAR != ':' && i + content_position < message_ln) {
output->content[result++] = MESSAGE_CURRENT_CHAR;
output->content_ln++;
i++;
// break on message counter separator
if (MESSAGE_CURRENT_CHAR == '{') {
i++; // move to first digit of a counter
break;
}
}
// check which condition has ended previous 'while' loop and if an end of the buffer has been reached
if (i + content_position < message_ln) {
result = 0;
// now iterator is set (should be set) on a first digit of message counter
// copy everything until first non digit character is found
while (MESSAGE_IS_DIGIT_OR_LETTER(MESSAGE_CURRENT_CHAR)) {
output->number_str[result++] = MESSAGE_CURRENT_CHAR;
i++;
// check if there isn't enough characters
if (result == MESSAGE_NUMBER_STRING_BUFFER) {
break;
}
}
output->source = src;
// convert message counter from string to int
message_atoi_message_counter(output->number_str, result, output);
if (result < MESSAGE_NUMBER_STRING_BUFFER) {
// new we are done (??)
result = 0;
}
}
else {
result = 0xFF;
}
}
else {
result = 0xFF;
}
}
return result;
}
/**
*
* @param input
* @param output
* @param output_ln
* @param encode_for
* @return
*/
uint16_t message_encode(message_t * input, uint8_t * output, uint16_t output_ln, message_source_t encode_for)
{
uint16_t current_pos = 0;
uint8_t recipient_pos = 0;
if( variant_validate_is_within_ram(input) &&
variant_validate_is_within_ram(output) &&
output_ln > (MESSAGE_MINIMUM_SENSEFUL_LN + input->content_ln)) {
// check the lenght of sender (from) callsign
const uint8_t from_call_ln = (input->from.call[5] != 0x00) ? 6 : strlen(input->from.call);
// check the lenght of recipient (to) callsign
const uint8_t to_call_ln = (input->to.call[5] != 0x00) ? 6 : strlen(input->from.call);
if (encode_for == MESSAGE_SOURCE_APRSIS) {
// put my callsign
memcpy(output, input->from.call, from_call_ln);
current_pos += from_call_ln;
// check if SSID is set
if (input->from.ssid > 0 && input->from.ssid < 16) {
current_pos += sprintf(output + current_pos, "-%d>AKLPRZ:", input->from.ssid);
}
else {
current_pos += sprintf(output + current_pos, ">AKLPRZ:");
}
}
*(output + current_pos) = ':';
current_pos++;
// put recipient callsign
memcpy(output + current_pos, input->to.call, to_call_ln);
recipient_pos = to_call_ln;
// and optional SSID
if (input->to.ssid > 0 && input->to.ssid < 16) {
recipient_pos += sprintf(output + current_pos + recipient_pos, "-%d", input->to.ssid);
}
else {
;
}
current_pos += recipient_pos;
// check how many characters were put and if padding needs to be applied
while (recipient_pos < MESSAGE_RECIPIENT_FIELD_SIZE) {
*(output + current_pos) = ' ';
current_pos++;
recipient_pos++;
}
if (current_pos + input->content_ln < output_ln) {
// put message content itself
current_pos += sprintf(output + current_pos, ":%s", input->content);
// put message counter
if (current_pos + MESSAGE_COUNTER_MAXLEN < output_ln) {
current_pos += sprintf(output + current_pos, "{%x}", message_tx_msg_couter);
message_tx_msg_couter++;
*(output + current_pos) = 0x00;
}
else {
current_pos = 0;
}
}
else {
current_pos = 0;
}
}
return current_pos;
}
/**
*
* @param config_data
* @param message
* @return zero if this is a message to us, non zero otherwise
*/
uint8_t message_is_for_me(const char * const callsign, const uint8_t ssid, const message_t * const message)
{
const int _callsign = strncmp(callsign, message->to.call, 6);
if (_callsign == 0 && (ssid == message->to.ssid)) {
return 0;
}
else {
return 1;
}
}
/**
*
* @param out_buffer
* @param out_buffer_ln
* @param message
* @param src how this message has been received
*/
int message_create_ack_for(uint8_t * out_buffer, const uint16_t out_buffer_ln, const message_t * const message)
{
int current_pos = 0;
uint8_t call_position = 0;
const message_source_t src = message->source;
// clear output buffer
memset(out_buffer, 0x00, out_buffer_ln);
if (src == MESSAGE_SOURCE_APRSIS || src == MESSAGE_SOURCE_APRSIS_HEXCNTR) {
// put my callsign
for (; call_position < 6; call_position++) {
// break on null character
if (message->to.call[call_position] == 0x00) {
break;
}
// copy callsign data
out_buffer[current_pos + call_position] = message->to.call[call_position];
}
current_pos += call_position;
call_position = 0;
// check if I have a SSID
if (message->to.ssid != 0) {
current_pos += snprintf(MESSAGE_ACK_CURRENT_POS, MESSAGE_ACK_REMAINING_BUF, "-%d", message->to.ssid);
}
// constant part
current_pos += snprintf(MESSAGE_ACK_CURRENT_POS, MESSAGE_ACK_REMAINING_BUF, ">AKLPRZ::");
// put sender callsign, station I received this message from
for (; call_position < 6; call_position++) {
// break on null character
if (message->from.call[call_position] == 0x00) {
break;
}
// copy callsign data
out_buffer[current_pos + call_position] = message->from.call[call_position];
}
// put sender SSID, station I received this message from
if (message->from.ssid != 0) {
call_position += snprintf(MESSAGE_ACK_CURRENT_POS + call_position, MESSAGE_ACK_REMAINING_BUF, "-%d", message->from.ssid);
}
// check if callsign was shorter than 6 characters
while (call_position < 9) {
// copy callsign data
out_buffer[current_pos + call_position] = ' ';
call_position++;
}
// callsign + ssid + padding must be exactly 9 characters long
current_pos += 9;
// then put 'ackXX' where X is message number
current_pos += snprintf(MESSAGE_ACK_CURRENT_POS, MESSAGE_ACK_REMAINING_BUF, ":ack%s\r\n", message->number_str);
}
else {
}
return current_pos;
}
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik