firmware.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2013, Digium, Inc.
 *
 * Mark Spencer <[email protected]>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief IAX Firmware Support
 *
 * \author Mark Spencer <[email protected]>
 */

/*** MODULEINFO
   <support_level>core</support_level>
 ***/

#include "asterisk.h"

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <dirent.h>
#include <sys/mman.h>
#include <arpa/inet.h>

#include "asterisk/linkedlists.h"
#include "asterisk/md5.h"
#include "asterisk/paths.h"
#include "asterisk/utils.h"

#include "include/firmware.h"

#define IAX_FIRMWARE_SUBDIR "/firmware/iax"

struct iax_firmware {
   AST_LIST_ENTRY(iax_firmware) list;
   int fd;
   int mmaplen;
   int dead;
   struct ast_iax2_firmware_header *fwh;
   unsigned char *buf;
};

static AST_LIST_HEAD_STATIC(firmwares, iax_firmware);

static int try_firmware(char *s)
{
   struct stat stbuf;
   struct iax_firmware *cur = NULL;
   int ifd, fd, res, len, chunk;
   struct ast_iax2_firmware_header *fwh, fwh2;
   struct MD5Context md5;
   unsigned char sum[16], buf[1024];
   char *s2, *last;

   s2 = ast_alloca(strlen(s) + 100);

   last = strrchr(s, '/');
   if (last)
      last++;
   else
      last = s;

   snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, ast_random());

   if (stat(s, &stbuf) < 0) {
      ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
      return -1;
   }

   /* Make sure it's not a directory */
   if (S_ISDIR(stbuf.st_mode))
      return -1;
   ifd = open(s, O_RDONLY);
   if (ifd < 0) {
      ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
      return -1;
   }
   fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
   if (fd < 0) {
      ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
      close(ifd);
      return -1;
   }
   /* Unlink our newly created file */
   unlink(s2);

   /* Now copy the firmware into it */
   len = stbuf.st_size;
   while(len) {
      chunk = len;
      if (chunk > sizeof(buf))
         chunk = sizeof(buf);
      res = read(ifd, buf, chunk);
      if (res != chunk) {
         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
         close(ifd);
         close(fd);
         return -1;
      }
      res = write(fd, buf, chunk);
      if (res != chunk) {
         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
         close(ifd);
         close(fd);
         return -1;
      }
      len -= chunk;
   }
   close(ifd);
   /* Return to the beginning */
   lseek(fd, 0, SEEK_SET);
   if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
      ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
      close(fd);
      return -1;
   }
   if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
      ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
      close(fd);
      return -1;
   }
   if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
      ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
      close(fd);
      return -1;
   }
   if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
      ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
      close(fd);
      return -1;
   }
   fwh = (struct ast_iax2_firmware_header*)mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
   if (fwh == MAP_FAILED) {
      ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
      close(fd);
      return -1;
   }
   MD5Init(&md5);
   MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
   MD5Final(sum, &md5);
   if (memcmp(sum, fwh->chksum, sizeof(sum))) {
      ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
      munmap((void*)fwh, stbuf.st_size);
      close(fd);
      return -1;
   }

   AST_LIST_TRAVERSE(&firmwares, cur, list) {
      if (!strcmp((const char *) cur->fwh->devname, (const char *) fwh->devname)) {
         /* Found a candidate */
         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
            /* The version we have on loaded is older, load this one instead */
            break;
         /* This version is no newer than what we have.  Don't worry about it.
            We'll consider it a proper load anyhow though */
         munmap((void*)fwh, stbuf.st_size);
         close(fd);
         return 0;
      }
   }

   if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
      cur->fd = -1;
      AST_LIST_INSERT_TAIL(&firmwares, cur, list);
   }

   if (cur) {
      if (cur->fwh)
         munmap((void*)cur->fwh, cur->mmaplen);
      if (cur->fd > -1)
         close(cur->fd);
      cur->fwh = fwh;
      cur->fd = fd;
      cur->mmaplen = stbuf.st_size;
      cur->dead = 0;
   }

   return 0;
}

static void destroy_firmware(struct iax_firmware *cur)
{
   /* Close firmware */
   if (cur->fwh) {
      munmap((void*)cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
   }
   close(cur->fd);
   ast_free(cur);
}

void iax_firmware_reload(void)
{
   struct iax_firmware *cur = NULL;
   DIR *fwd;
   struct dirent *de;
   char fn[PATH_MAX + sizeof(IAX_FIRMWARE_SUBDIR) + sizeof(de->d_name)];

   AST_LIST_LOCK(&firmwares);

   /* Mark all as dead */
   AST_LIST_TRAVERSE(&firmwares, cur, list) {
      cur->dead = 1;
   }

   /* Now that we have marked them dead... load new ones */
   snprintf(fn, sizeof(fn), "%s%s", ast_config_AST_DATA_DIR, IAX_FIRMWARE_SUBDIR);
   fwd = opendir(fn);
   if (fwd) {
      while((de = readdir(fwd))) {
         if (de->d_name[0] != '.') {
            snprintf(fn, sizeof(fn), "%s%s/%s",
               ast_config_AST_DATA_DIR, IAX_FIRMWARE_SUBDIR, de->d_name);
            if (!try_firmware(fn)) {
               ast_verb(2, "Loaded firmware '%s'\n", de->d_name);
            }
         }
      }
      closedir(fwd);
   } else {
      ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", fn, strerror(errno));
   }

   /* Clean up leftovers */
   AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
      if (!cur->dead)
         continue;
      AST_LIST_REMOVE_CURRENT(list);
      destroy_firmware(cur);
   }
   AST_LIST_TRAVERSE_SAFE_END;

   AST_LIST_UNLOCK(&firmwares);
}

void iax_firmware_unload(void)
{
   struct iax_firmware *cur = NULL;

   AST_LIST_LOCK(&firmwares);
   AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
      AST_LIST_REMOVE_CURRENT(list);
      destroy_firmware(cur);
   }
   AST_LIST_TRAVERSE_SAFE_END;
   AST_LIST_UNLOCK(&firmwares);
}

int iax_firmware_get_version(const char *dev, uint16_t *version)
{
   struct iax_firmware *cur = NULL;

   if (ast_strlen_zero(dev))
      return 0;

   AST_LIST_LOCK(&firmwares);
   AST_LIST_TRAVERSE(&firmwares, cur, list) {
      if (!strcmp(dev, (const char *) cur->fwh->devname)) {
         *version = ntohs(cur->fwh->version);
         AST_LIST_UNLOCK(&firmwares);
         return 1;
      }
   }
   AST_LIST_UNLOCK(&firmwares);

   return 0;
}

int iax_firmware_append(struct iax_ie_data *ied, const char *dev, unsigned int desc)
{
   int res = -1;
   unsigned int bs = desc & 0xff;
   unsigned int start = (desc >> 8) & 0xffffff;
   unsigned int bytes;
   struct iax_firmware *cur;

   if (ast_strlen_zero((char *)dev) || !bs)
      return -1;

   start *= bs;

   AST_LIST_LOCK(&firmwares);
   AST_LIST_TRAVERSE(&firmwares, cur, list) {
      if (strcmp(dev, (const char *) cur->fwh->devname))
         continue;
      iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
      if (start < ntohl(cur->fwh->datalen)) {
         bytes = ntohl(cur->fwh->datalen) - start;
         if (bytes > bs)
            bytes = bs;
         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
      } else {
         bytes = 0;
         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
      }
      if (bytes == bs)
         res = 0;
      else
         res = 1;
      break;
   }
   AST_LIST_UNLOCK(&firmwares);

   return res;
}

void iax_firmware_traverse(
   const char *filter,
   int (*callback)(struct ast_iax2_firmware_header *header, void *data),
   void *data)
{
   struct iax_firmware *cur = NULL;

   if (!callback) {
      return;
   }

   AST_LIST_LOCK(&firmwares);
   AST_LIST_TRAVERSE(&firmwares, cur, list) {
      if (!filter || !strcasecmp(filter, (const char *) cur->fwh->devname)) {
         if (callback(cur->fwh, data)) {
            break;
         }
      }
   }
   AST_LIST_UNLOCK(&firmwares);
}