popufare/busunit/DIUv2/driver.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 "driver.h"

// This function searches the driver file and checks a driver, pin pair returning 0 on success
// or -1 on failure.
//
int driver_login(int drivernum, char *pinnum) {
  FILE *f;
  char name[DRIVER_NAME_LEN]={0};
  char pin[64];
  char line[LINE_BUFFER_SIZE]={0};
  char *inc_line;
  struct message_record outgoing_msg;


  int drv;
  int retval;

  if (!drivernum || !pinnum) { return -1; }

  // open the driver file
  //
  f=fopen(DRIVERS_FILE,"rb");

  if (!f) {
    format_log_message(&outgoing_msg, LOGLEVEL_ERROR, "Cannot open %s\n", DRIVERS_FILE);
    send_message(hub_fd,&outgoing_msg);

    // fail if we can't read it
    //
    return -1;
  }

  // while we haven't hit EOF
  //
  while (!feof(f)) {

    // read it line by line
    //
    if (!fgets(line,sizeof(line)-1,f)) {
      break;
    }

    // terminating each line safely
    //
    line[sizeof(line)-1] = '\0';

    inc_line = line;

    // and ignoring any leading whitespace
    //
    while (1) {
      char c = *inc_line;

      if ( (c == ' ') ||(c == '\t') ||(c == '\r') ||(c == '\n') ) {
        inc_line++;
        continue;
      }

      break;
    }

    // and ignoring blank/comment lines
    //
    if ( (inc_line[0] == '#') || (inc_line[0] == '\0')) {
      continue;
    }

    name[0]='\0';
    pin[0]='\0';

    // parse the line format (drivernum pin_num drivername)
    //
    retval=sscanf(inc_line,"%d %63[0123456789] %63[^\r\n]",&drv,pin,name);

    // if we get at least a driver number and pin number
    //
    if (retval >= 2) {
      // check to see if we've found a match
      //
      if (drv != drivernum) {
        continue;
      }

      // if the PIN matches
      //
      if (!strcmp(pinnum, pin)) {
        my_driver_status.logged_in_driver = drivernum;
        strncpy(my_driver_status.driver_name, name, DRIVER_NAME_LEN);
        my_driver_status.driver_name[DRIVER_NAME_LEN - 1] = '\0';
        my_driver_status.equip_num = get_equip_num();

        format_log_message(&outgoing_msg, LOGLEVEL_DEBUG, "Successful login for driver %d\n", drivernum);
        send_message(hub_fd,&outgoing_msg);

        update_driver_status |= 1;
        fclose(f);
        return 0;
      }
      else {
        format_log_message(&outgoing_msg, LOGLEVEL_DEBUG, "Failed login for driver %d\n", drivernum);
        send_message(hub_fd,&outgoing_msg);
        fclose(f);
        return -1;
      }
    }
  }

  format_log_message(&outgoing_msg, LOGLEVEL_DEBUG, "Failed login for unknown driver %d\n", drivernum);
  send_message(hub_fd,&outgoing_msg);
  fclose(f);
  return -1;
}

// Log a driver out and cancel any pending set paddle request
//
int driver_logout() {
  struct message_record outgoing_msg;

  if (my_driver_status.logged_in_driver) {
    format_log_message(&outgoing_msg, LOGLEVEL_DEBUG, "Driver logout for driver %d\n", my_driver_status.logged_in_driver);
    send_message(hub_fd,&outgoing_msg);
  }

  my_driver_status.logged_in_driver = 0;
  my_driver_status.driver_name[0] = '\0';
  paddle_req_timeout = 0;
  update_driver_status |= 1;
  return 0;
}

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

int make_paddle_request(int paddle) {
  struct message_record outgoing_msg;

  paddle_req.result = 0;
  paddle_req.request = paddle;
  paddle_req_timeout = time(NULL) + PADDLE_REQ_TIMEOUT;

  prepare_message(&outgoing_msg, MAILBOX_SET_PADDLE, &paddle_req, sizeof(paddle_req));
  return send_message(hub_fd, &outgoing_msg);
}

int check_paddle_request() {
  char buf[LINE_BUFFER_SIZE];
  struct message_record outgoing_msg;

  if (paddle_req_timeout != 0) {

    if (paddle_req.request == paddle_req.result) {
      format_log_message(&outgoing_msg, LOGLEVEL_DEBUG, "Set Paddle %d\n", paddle_req.request);
      send_message(hub_fd, &outgoing_msg);
      paddle_req_timeout = 0;

      snprintf(buf, LINE_BUFFER_SIZE, "paddle ok %i", paddle_req.result);
      ws_send(&g_mgr, buf);

      return 1;
    }
    else if ( (paddle_req.result < 0) || (paddle_req_timeout < time(NULL)) ) {
      format_log_message(&outgoing_msg, LOGLEVEL_DEBUG, "Failed to set Paddle %d\n", paddle_req.request);
      send_message(hub_fd, &outgoing_msg);
      paddle_req.result = 0;
      paddle_req.request = 0;
      paddle_req_timeout = 0;

      ws_send(&g_mgr, "paddle fail");

      return 1;
    }
  }

  return 0;
}

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

void action_nextstop() {
  struct message_record outgoing_msg;
  prepare_message(&outgoing_msg, MAILBOX_NEXT_STOP, "", 0);
  send_message(hub_fd, &outgoing_msg);
}

void action_prevstop() {
  struct message_record outgoing_msg;
  prepare_message(&outgoing_msg, MAILBOX_PREV_STOP, "", 0);
  send_message(hub_fd, &outgoing_msg);
}