lib_util.c File Reference

#include <string.h>
#include <stdint.h>
#include <stdio.h>
#include <errno.h>
#include <limits.h>
#include "yubihsm.h"
#include "internal.h"
#include "debug_lib.h"

Include dependency graph for lib_util.c:

Go to the source code of this file.

Macros
#define	STATUS_STR   "status="
#define	VERSION_STR   "version="
#define	PID_STR   "pid="
#define	ADDRESS_STR   "address="
#define	PORT_STR   "port="

Functions
void	dump_hex (FILE *file, const uint8_t *ptr, uint16_t len)
void	dump_msg (FILE *file, const Msg *msg)
void	dump_response (FILE *file, const Msg *msg)
void	parse_status_data (char *data, yh_connector *connector)
bool	parse_usb_url (const char *url, unsigned long *serial)

Macro Definition Documentation

ADDRESS_STR

#define ADDRESS_STR   "address="

Definition at line 30 of file lib_util.c.

PID_STR

#define PID_STR   "pid="

Definition at line 29 of file lib_util.c.

PORT_STR

#define PORT_STR   "port="

Definition at line 31 of file lib_util.c.

STATUS_STR

#define STATUS_STR   "status="

Definition at line 27 of file lib_util.c.

VERSION_STR

#define VERSION_STR   "version="

Definition at line 28 of file lib_util.c.

Function Documentation

dump_hex()

void dump_hex	(	FILE *	file,
		const uint8_t *	ptr,
		uint16_t	len )

Definition at line 33 of file lib_util.c.

                                                            {
 
  uint32_t i;
 
  for (i = 0; i < len; i++) {
    if (i && !(i % 8)) {
      fprintf(file, " ");
    }
    fprintf(file, "%02x", ptr[i]);
  }
}

Here is the caller graph for this function:

dump_msg()

void dump_msg	(	FILE *	file,
		const Msg *	msg )

Definition at line 45 of file lib_util.c.

                                          {
 
  fprintf(file, "SEND >> (03 + %04d) %02x %04x ", msg->st.len, msg->st.cmd,
          msg->st.len);
 
  dump_hex(file, msg->st.data, msg->st.len);
 
  fprintf(file, "\n");
}

Here is the call graph for this function:

dump_response()

void dump_response	(	FILE *	file,
		const Msg *	msg )

Definition at line 55 of file lib_util.c.

                                               {
 
  fprintf(file, "RECV << (03 + %04d) %02x %04x ", msg->st.len, msg->st.cmd,
          msg->st.len);
 
  dump_hex(file, msg->st.data, msg->st.len);
 
  fprintf(file, " \n");
}

Here is the call graph for this function:

parse_status_data()

void parse_status_data	(	char *	data,
		yh_connector *	connector )

Definition at line 65 of file lib_util.c.

                                                            {
 
  char *saveptr = NULL;
  char *str = NULL;
 
  while ((str = strtok_r(str ? NULL : data, "\n", &saveptr))) {
    if (strncmp(str, STATUS_STR, strlen(STATUS_STR)) == 0) {
      if (strcmp(str + strlen(STATUS_STR), "OK") == 0) {
        connector->has_device = true;
      } else {
        connector->has_device = false;
      }
    } else if (strncmp(str, VERSION_STR, strlen(VERSION_STR)) == 0) {
      unsigned long v_maj = 0;
      unsigned long v_min = 0;
      unsigned long v_pat = 0;
 
      str = str + strlen(VERSION_STR);
      if (sscanf(str, "%lu.%lu.%lu", &v_maj, &v_min, &v_pat) == 0) {
        DBG_ERR("Unable to parse version string");
        continue;
      }
 
      connector->version_major = v_maj;
      connector->version_minor = v_min;
      connector->version_patch = v_pat;
    } else if (strncmp(str, PID_STR, strlen(PID_STR)) == 0) {
      char *endptr;
      unsigned long pid;
 
      str = str + strlen(PID_STR);
      errno = 0;
      pid = strtoul(str, &endptr, 0);
      if ((errno == ERANGE && pid == ULONG_MAX) || (errno != 0 && pid == 0)) {
        continue;
      }
 
      if (endptr == str || pid == 0) {
        continue;
      }
 
      connector->pid = pid;
    } else if (strncmp(str, ADDRESS_STR, strlen(ADDRESS_STR)) == 0) {
      strncpy((char *) connector->address, str + strlen(ADDRESS_STR),
              sizeof(connector->address) - 1);
    } else if (strncmp(str, PORT_STR, strlen(PORT_STR)) == 0) {
      char *endptr;
      unsigned long port;
 
      str = str + strlen(PORT_STR);
      errno = 0;
      port = strtoul(str, &endptr, 0);
      if ((errno == ERANGE && port == ULONG_MAX) || (errno != 0 && port == 0)) {
        continue;
      }
 
      if (endptr == str || port == 0) {
        continue;
      }
 
      connector->port = port;
    }
  }
 
  DBG_INFO("response from connector");
  DBG_INFO("has device: %s", connector->has_device == true ? "yes" : "no");
  DBG_INFO("version: %d.%d.%d", connector->version_major,
           connector->version_minor, connector->version_patch);
  DBG_INFO("pid: %u", connector->pid);
  DBG_INFO("address: %s", connector->address);
  DBG_INFO("port: %u", connector->port);
 
  return;
}

parse_usb_url()

bool parse_usb_url	(	const char *	url,
		unsigned long *	serial )

Definition at line 140 of file lib_util.c.

                                                           {
  if (strncmp(url, YH_USB_URL_SCHEME, strlen(YH_USB_URL_SCHEME)) == 0) {
    url += strlen(YH_USB_URL_SCHEME);
    char *copy = strdup(url);
    char *str = NULL;
    char *saveptr = NULL;
 
    // if we don't find a serial we still want to return serial 0
    *serial = 0;
 
    while ((str = strtok_r(str ? NULL : copy, "&", &saveptr))) {
      if (strncmp(str, "serial=", strlen("serial=")) == 0) {
        char *endptr;
        str += strlen("serial=");
 
        errno = 0;
        *serial = strtoul(str, &endptr, 0);
        if ((errno == ERANGE && *serial == ULONG_MAX) || endptr == str ||
            (errno != 0 && *serial == 0)) {
          *serial = 0;
          DBG_INFO("Failed to parse serial argument: '%s'.", str);
        }
      } else {
        DBG_INFO("Unknown USB option '%s'.", str);
      }
    }
    DBG_INFO("USB url parsed with serial %lu.", *serial);
    free(copy);
    return true;
  }
  return false;
}