popufare/busunit/common/common_defs.c

/*
* Copyright (c) 2019 Clementine Computing LLC.
*
* This file is part of PopuFare.
*
* PopuFare is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* PopuFare is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with PopuFare.  If not, see <https:// www.gnu.org/licenses/>.
*
*/

#include <sys/termios.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <poll.h>
#include <syslog.h>
#include <sysexits.h>
#include <stdarg.h>

#include <dirent.h>
#include <fnmatch.h>

#include "common_defs.h"

#ifndef DEFAULT_BAUD
  #define DEFAULT_BAUD   (B115200)
#endif


// ------------------------------------------- This horrible blob of code goes and hunts for package install records and gathers
// ------------------------------------------- them into a sane data structure for display to the user in status/diagnostic screens.
#define PKG_SEARCH_DIR  CONFIG_FILE_PATH
#define PATTERN_SUFFIX  ".tgz.version"
#define CHECKSUM_SUFFIX ".tgz.checksum"
#define PATTTERN        ("*" PATTERN_SUFFIX)



static int package_filter(const struct dirent *file) {
  int match = fnmatch(PATTTERN, file->d_name, 0);
  return !match;
}


int find_packages(package_signature *pkgs, int n) {
  int i = 0;
  int scandir_ret;
  struct dirent **matchlist;

  int j;
  int match_len;
  int suffix_len = strlen(PATTERN_SUFFIX);
  FILE *f;

  struct stat st;

  char pathbuffer[1024];

  // Look for any file that matches the pattern PATTERN (see package_filter above) and return into matchlist a pointer
  // to and array of pointers to dirent structures for each directory entry that made the cut, sorted alphabetically
  //
  scandir_ret = scandir(PKG_SEARCH_DIR, &matchlist, package_filter, alphasort);

  // If that seemed to work....
  //
  if( (scandir_ret >= 0) && (matchlist != NULL) ) {

    // Walk the resultant list
    //
    for(i=0; i < scandir_ret; i++) {

      // if we've filled our caller's buffer, break out now
      //
      if(i >= n) {
        break;
      }

      // Go figure out how long the module name part is (it'll be the length of the filename minus the length of the suffix)
      //
      match_len = strlen(matchlist[i]->d_name) - suffix_len;

      // If that would cause an overflow, truncate it...
      //
      if (match_len > (PKG_STRING_SIZE - 1)) {
        match_len = PKG_STRING_SIZE - 1;
      }

      // Copy our package name
      //
      strncpy(pkgs[i].pkgname, matchlist[i]->d_name, match_len);
      pkgs[i].pkgname[match_len] = '\0';


      // (if fscanf fails, we want an empty string rather than random crap from memory...)
      //
      pkgs[i].pkgver[0] = '\0';

      // generate the file name of the package version string...
      //
      snprintf(pathbuffer, sizeof(pathbuffer), "%s%s%s", PKG_SEARCH_DIR, pkgs[i].pkgname, PATTERN_SUFFIX);

      // Go and read the contents of that into the pkgver part of our structure...
      //
      f = fopen(pathbuffer, "rb");
      if (f) {
        fscanf(f, PKG_STRING_FORMAT, pkgs[i].pkgver);
        fclose(f);
      }


      pkgs[i].checksum[0] = '\0';

      // generate the file name of the file containing the package checksum
      //
      snprintf(pathbuffer, sizeof(pathbuffer), "%s%s%s", PKG_SEARCH_DIR, pkgs[i].pkgname, CHECKSUM_SUFFIX);

      // Go and read the contents of that into the checkdum part of our structure...
      //
      f = fopen(pathbuffer, "rb");
      if (f) {
        fscanf(f, PKG_STRING_FORMAT, pkgs[i].checksum);
        fclose(f);
      }


      pkgs[i].installed = 0;

      // Go and grab the mtime of the package install file
      //
      if (!stat(pathbuffer, &st)) {
        pkgs[i].installed = st.st_mtime;
      }

      // Free this dirent
      //
      free(matchlist[i]);
    }

    // Clean up any leftovers
    //
    for (j = i; j < scandir_ret; j++) {
      free(matchlist[i]);
    }

    // free the array of pointers
    //
    free(matchlist);
  }

  // return the number actually filled
  //
  return i;
}

// --------------------------------------------------------------------------------------------------

// This function checks the dropfile to see if the tunnel is up...
//
int tunnel_is_up() {
  struct stat st;
  int retval;

  retval = stat(TUNNEL_DROPFILE, &st);

  if (retval) {
    return 0;
  }
  else {
    return 1;
  }
}

// This function checks the dropfile to see if the GPRS modem is up...
//
int gprs_is_up() {
  struct stat st;
  int retval;

  retval = stat(GPRS_DROPFILE, &st);

  if(retval) {
    return 0;
  }
  else {
    return 1;
  }
}

// This function gets the equipment number from the appropriate config file
// If it cannot be gotten, it returns -1
//
int get_equip_num() {
  FILE *f;
  int num = -1;

  f = fopen(EQUIPNUM_FILE, "rb");

  if (f) {
    fscanf(f,"%d",&num);
    fclose(f);
  }
  else {
    num = -1;
  }

  return num;
}

// This function sets the euipment number in the config file.
// if this operation fails, -1 is returned.
//
int set_equip_num(int num) {
  FILE *f;

  if ( (num < 1) || (num > MAX_EQUIPNUM) ) {
    return -1;
  }

  f = fopen(EQUIPNUM_TEMPFILE, "wb");

  if (f) {
    fprintf(f,"%d\n", num);
    fclose(f);
    rename(EQUIPNUM_TEMPFILE, EQUIPNUM_FILE);
    sync();
    return 0;
  }

  return -1;
}

//

int get_server_desc(char *desc, int len) {
  char svrname[LINE_BUFFER_SIZE];
  FILE *f;

  if (!desc) {
    return -1;
  }

  if (len <= 0) {
    return -1;
  }

  f = fopen(SERVER_DESC_FILE, "rb");

  if (f) {
    fgets(svrname, LINE_BUFFER_SIZE, f);
    svrname[LINE_BUFFER_SIZE - 1] = '\0';
    strip_crlf(svrname);

    strncpy(desc, svrname, len);
    desc[len - 1] = '\0';
    return 0;
  }

  return -1;
}

int get_field(char *dest, char *src, int dest_len, int *eol_flag) {
  int i,j;
  int done = 0;
  int eol = 0;

  i = j = 0;

  while ( ! done ) {
    switch(src[i]) {
      case '\0':    // If we've hit the end of the input line
      case '\n':
      case '\r':

        //  cap off our destination string if there is room
        //
        if (j < dest_len)  {
          dest[j++] = '\0';
        }

        //  set our internal End Of Line flag
        //
        eol = 1;

        //  set the done flag so we break out of the while
        //
        done = 1;

        break;

      //  If we have hit a record boundary
      //
      case '\t':
        //  cap off our input line
        //
        if (j < dest_len)  {
          dest[j++] = '\0';
        }

        //  Advance past this input character
        //
        i++;

        //  flag us as done
        //
        done = 1;

        break;

      //  otherwise (for normal characters) just copy them if there is space
      //
      default:

        if (j < dest_len) {
          dest[j++] = src[i];
        }

        //  and advance past them
        //
        i++;
        break;
    }
  }

  //  If we have filled our line to capacity
  //
  if ( j == dest_len )    {

    //  Truncate it by 1 character to fit the terminating NUL
    //
    dest[dest_len - 1] = '\0';
  }

  //  If the user has passed us a place to store our EOL flag,
  //
  if( eol_flag != NULL )  {

    //  store it there
    //
    *eol_flag = eol;

  }

  //  Return the index of the next character to be consumed.
  //
  return i;
}


// magic hash function hashes english strings well enough for our needs
//
unsigned long long stringhash(char *string) {
  unsigned long long hash = 5381;
  int c;

  while ((c = *string++)) {

    /* hash * 33 + c */
    hash = ((hash << 5) + hash) + c;

  }

  return hash;
}

int strip_crlf(char *buffer) {
  char *src,*dst;
  int count=0;

  // Set both our source and destination pointers to the buffer in question
  //
  src=dst=buffer;

  // While we still have unprocessed buffer bytes
  //
  while(*src) {

    // If we encounter a CR or LF character
    //
    if((*src == '\r') || (*src == '\n')) {

      // If the NEXT character is not another EOL character or a terminating nul
      //
      if( (src[1] != '\0') && (src[1] != '\r') && (src[1] != '\n') ) {
        src++;

        //  replace the CR or LF with a space.
        //
        *dst++ = ' ';

        count++;
        continue;
      }

      //  On the other hand, if what comes next is EOL or end of string,
      //
      else  {

        //  just trim this character
        //
        src++;
        continue;
      }
    }

    // If this character isn't one of the special ones, just copy it.
    //
    *dst++ = *src++;
    count++;
  }

  // Copy the terminating NUL
  //
  *dst++ = *src++;

  return count;
}

int open_rs232_device(char *devname, int custom_baud, int linemode) {
  struct termios tty={0};
  int retval;
  int fd;

  // Open the specified character device READ/WRITE and not as a Controlling TTY
  //
  fd = open(devname, O_RDWR | O_NOCTTY);

  if (fd < 0) {
#ifdef COMMON_PRINT_WARNING
    fprintf(stderr, "Warning:  Cannot open TTY %s\n", devname);
#endif
    return -1;
  }

  // Try and fetch the TTY properties of the device
  //
  retval = ioctl(fd, TCGETS, &tty);

  if (retval) {
#ifdef COMMON_PRINT_WARNING
    fprintf(stderr, "Warning:  Cannot get TTY attributes on %s.  Not a TTY?\n", devname);
#endif
    close(fd);
    return -1;
  }


  if (custom_baud > 0) {
    tty.c_cflag = custom_baud | CS8 | CREAD | CLOCAL;
  }

  else {
    tty.c_cflag = DEFAULT_BAUD | CS8 | CREAD | CLOCAL;
  }


  if (linemode) {
    tty.c_iflag = IGNBRK;
    tty.c_oflag = 0;
    tty.c_lflag = ICANON;
    tty.c_line = 0;
    tty.c_cc[VMIN] = 1;      // minimum one character read

    tty.c_cc[VTIME] = ACCUM_SECONDS * 10;  // wait ACCUM_SECONDS without any further chars
                                            // before giving up on the arrival of a newline.
                                            // (VTIME is specified in deciseconds (who knows why...))

    tty.c_cc[VEOL] = '\n';      // allow a newline to release the buffer
  }

  else {
    tty.c_iflag = IGNBRK;
    tty.c_oflag = 0;
    tty.c_lflag = 0;
    tty.c_line = 0;
    tty.c_cc[VMIN] = 1;
    tty.c_cc[VTIME] = 5;
  }

  // try and plunk our desired settings down on the device
  //
  retval = ioctl(fd, TCSETS, &tty);

  if (retval) {
#ifdef COMMON_PRINT_WARNING
    fprintf(stderr, "Warning:  Cannot set TTY attributes on %s. Unsupported mode?\n", devname);
#endif
    close(fd);
    return -1;
  }

  // flush the serial port buffers to clean up any detritus that has accumulated before we got here
  //
  tcflush(fd, TCIOFLUSH);

  return fd;
}


static int read_with_timeout(int fd, void *buffer, int n, int timeout) {
  int retval;
  struct pollfd fds[1];

  fds[0].fd = fd;
  fds[0].events = POLLIN;

  retval = poll(fds, 1, timeout);

  if (retval > 0) {
    return read(fd, buffer, n);
  }

  else {
    return retval;
  }
}

static int init_device(int fd, device_test_vector *vec, char *diag) {
  char buffer[1024] = {0};

  int i;
  int retval;
  int len;
  char *trav;

  int timeout = DEVICE_TEST_TIMEOUT;

  if (vec->init_timeout > 0) {
    timeout = vec->init_timeout;
  }

  //  If we were given an init string
  //
  if (vec->init_string != NULL)  {
    //  calculate how long it is
    //
    len = strlen(vec->init_string);

    //  send it on its way
    //
    retval = write(fd, vec->init_string, len);

    //  if that didn't work
    //
    if (retval != len)  {
      //  complain and fail
      //
      if (diag)  {
        snprintf(diag, DIAG_BUFFER_SIZE, "Cannot write init string to device.");
      }

      return -1;
    }
  }

  i = 0;

  while (i < vec->n_reply_lines) {

    //  Ask the kernel for a line from the TTY
    //
    retval = read_with_timeout(fd, buffer, sizeof(buffer), timeout);

    //  If we DID read something from the device, make sure it is correct
    //
    if(retval > 0)  {

      buffer[retval] = '\0';
      strip_crlf(buffer);

      trav = buffer;

      // Skip any garbage before the start character
      //
      while (*trav && (*trav != '/')) {
        trav++;
      }

      if (*trav == '\0') {
        continue;  // ignore blank lines
      }

      if ( (trav[0] == '/') && (trav[1] == '?') && (trav[2] == ':') ) {

        //  ignore device ID lines
        //
        continue;
      }

      // The order of these tests in importand.  Short circuit keeps us from
      // dereferencing expected_reply_lines if the first test fails
      //
      //  If we have a pattern to test against
      //
      if ( (vec->reply_strings != NULL) && (vec->reply_strings[i] != NULL) )  {

        if (strcmp(trav, vec->reply_strings[i])) {

          if (diag) {
            snprintf(diag, DIAG_BUFFER_SIZE, "Read init reply line %d from device, expected \"%s\" but got \"%s\"", i, vec->reply_strings[i], trav);
          }

          return -1;
        }
      }

    }

    //  If we DIDN'T read anything from the device...
    //
    else  {

      //  Complain
      //
      if (diag)  {
        snprintf(diag, DIAG_BUFFER_SIZE, "Reading init reply from device timed out waiting for line %d", i);
      }

      //  And fail
      //
      return -1;
    }

    i++;
  }

  return 0;
}

int test_and_init_device(int fd, device_test_vector *vec, char *diag) {
  char buffer[DEV_INIT_BUFFER_SIZE] = {0};
  char module_id[DEV_INIT_BUFFER_SIZE] = {0};

  int tries = DEVICE_TEST_TRIES;
  int timeout = DEVICE_TEST_TIMEOUT;

  int retval;
  char *trav;

  if (vec == NULL) {
    return -1;
  }

  if (vec->dev_id == NULL) {
    return -1;
  }

  if (vec->init_tries > 0) {
    tries = vec->init_tries;
  }

  if (vec->init_timeout > 0) {
    timeout = vec->init_timeout;
  }

  //  We want to iterate through DEVICE_TEST_TRIES tries at getting a valid line from the device
  //
  do {

    //  Send a CR to stimulate the device to spit out its help message
    //
    write(fd,"\r", 1);

    //  Ask the kernel for a line from the TTY
    //
    retval = read_with_timeout(fd, buffer, sizeof(buffer), timeout);

    // If we actually got a line of data
    //
    if (retval > 0) {
      buffer[retval] = '\0';
      strip_crlf(buffer);

      // Start examining our buffer
      //
      trav = buffer;

      // Skip any garbage before the start character
      //
      while (*trav && (*trav != '/')) {
        trav++;
      }

      // See if it is our Device ID / help line...
      //
      if ( (trav[0] == '/') && (trav[1] == '?') && (trav[2] == ':') ) {

        //  Skip the header and go to the body
        //
        trav += 3;

        //  Look for our module ID string
        //
        retval = sscanf(trav, " ?=%s", module_id);

        if (retval < 1) {

          //  Look for our module ID string without leading space
          //
          retval = sscanf(trav, "?=%s", module_id);
        }

        //  If we have found id
        //
        if (retval == 1)    {

          //  See if it is the correct one
          //
          if (!strcmp(module_id, vec->dev_id))  {

            //  If so, pass on our diagnostic message if we have a place to
            //
            if (diag)  {
              snprintf(diag, DIAG_BUFFER_SIZE, "Device connected OK");
            }

            return init_device(fd, vec, diag);   // Perform initialization and return the status of that operation
          }

          //  Otherwise, if it is NOT the one we are expecting
          //
          else {

            //  Complain if we have a place to
            //
            if (diag)  {
              snprintf(diag, DIAG_BUFFER_SIZE, "Device present:  Expecting: \"%s\" Got: \"%s\"", vec->dev_id, module_id);
            }

            return -2;  // Return a distinct failure code
          }
        }
      }

      //  If we DIDN'T get the line we were looking for, pretend it was blank so we'll try again...
      //
      else  {

        //  This pretends the received line was black.
        //
        retval = 0;
      }

    //  if we got 0 bytes or EINTR from the alarm firing
    //
    }

  //  While we still have tries and a previous try didn't work
  //
  } while ( (retval <= 0) && ( --tries > 0) );

  if (diag) {
    snprintf(diag, DIAG_BUFFER_SIZE, "Could not get reply from device");
  }
  return -1;
}

// ========================================================================================================
// ------------------------------- WATCHDOG TIMER and other SIGNAL HANDLERS -------------------------------
// ========================================================================================================

// volatile int hup_request_status = 0;
//
volatile sig_atomic_t hup_request_status = 0;

void request_hup(char *fmt, ...) {
  va_list ap;

  hup_request_status = 1;

  va_start(ap, fmt);
  vprintf(fmt, ap);
  va_end(ap);
}

// Our signal handlers and standard message handlers will OR these bits into exit_request_status
//

volatile int exit_request_status = 0;
static int exit_signal_counter = 0;

void request_polite_exit(int reason, char *fmt, ...) {
  va_list ap;

  exit_request_status |= reason;

  if (reason) {
    exit_signal_counter++;
  }

  if (exit_request_status & EXIT_REQUEST_CRASH) {
    va_start(ap, fmt);
      vsyslog(LOG_ERR, fmt, ap);
    va_end(ap);

    exit(EX_SOFTWARE);
  }

  if (exit_signal_counter >= MAX_POLITE_EXIT_REQUESTS) {
    va_start(ap, fmt);
      vsyslog(LOG_NOTICE, fmt, ap);
    va_end(ap);

    exit(SIGTERM);
  }
}

static void watchdog_handler(int signum, siginfo_t *info, void *data) {
  request_polite_exit(EXIT_REQUEST_CRASH, "Watchdog timer has expired!");
}

static void term_int_handler(int signum, siginfo_t *info, void *data) {
  request_polite_exit(EXIT_REQUEST_INT_TERM, "Received signal %d", signum);
}

static void hard_crash_handler(int signum, siginfo_t *info, void *data) {
  switch(signum) {
    case SIGSEGV:
      request_polite_exit(EXIT_REQUEST_CRASH, "Segmentation fault at virtual address %p", info->si_addr);
      break;

    case SIGILL:
      request_polite_exit(EXIT_REQUEST_CRASH, "Illegal instruction at virtual address %p", info->si_addr);
      break;

    case SIGFPE:
      request_polite_exit(EXIT_REQUEST_CRASH, "Floating point exception at virtual address %p", info->si_addr);
      break;

    case SIGBUS:
      request_polite_exit(EXIT_REQUEST_CRASH, "SIGBUS (hardware error!) at address %p", info->si_addr);
      break;

    default:
      request_polite_exit(EXIT_REQUEST_CRASH, "Caught Signal %d", signum);
      break;
  }
}

void configure_signal_handlers(char *procname) {
  struct sigaction sa = {{0}};

  openlog(procname, LOG_CONS | LOG_PERROR, LOG_USER);

  #ifdef USE_WATCHDOG_ALARM
    sa.sa_sigaction = watchdog_handler;
    sa.sa_flags =  SA_SIGINFO;
    sigfillset(&sa.sa_mask);

    sigaction(SIGALRM, &sa, NULL);

    RESET_WATCHDOG();
  #endif

  // Install our "boy did we ever fuck up this time" signal handler
  // to trap segmentation faults, illegal instructions, divides by zero,
  // and things like RAM chips popping off a running board (SIGBUS).
  //
  sa.sa_sigaction = hard_crash_handler;
  sa.sa_flags =  SA_SIGINFO;
  sigaction(SIGSEGV, &sa, NULL);
  sigaction(SIGILL, &sa, NULL);
  sigaction(SIGFPE, &sa, NULL);
  sigaction(SIGBUS, &sa, NULL);

  // Install our polite exit handler...
  //
  sa.sa_sigaction = term_int_handler;
  sa.sa_flags =  SA_SIGINFO | SA_RESTART;  // Allow interrupted I/O calls to finish to facilitate clean exit
  sigaction(SIGTERM, &sa,  NULL);
  sigaction(SIGINT, &sa,  NULL);
}

// ------------------