firmware.c File Reference

IAX Firmware Support. More...

#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"

Include dependency graph for firmware.c:

Go to the source code of this file.

Data Structures
struct	firmwares
struct	iax_firmware

Macros
#define	IAX_FIRMWARE_SUBDIR   "/firmware/iax"

Functions
static void	destroy_firmware (struct iax_firmware *cur)
int	iax_firmware_append (struct iax_ie_data *ied, const char *dev, unsigned int desc)
int	iax_firmware_get_version (const char *dev, uint16_t *version)
void	iax_firmware_reload (void)
void	iax_firmware_traverse (const char *filter, int(*callback)(struct ast_iax2_firmware_header *header, void *data), void *data)
void	iax_firmware_unload (void)
static int	try_firmware (char *s)

Variables
static struct firmwares	firmwares = AST_LIST_HEAD_INIT_VALUE

Detailed Description

IAX Firmware Support.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Definition in file firmware.c.

Macro Definition Documentation

IAX_FIRMWARE_SUBDIR

#define IAX_FIRMWARE_SUBDIR   "/firmware/iax"

Definition at line 47 of file firmware.c.

Function Documentation

destroy_firmware()

static void destroy_firmware ( struct iax_firmware *  cur )

static

Definition at line 196 of file firmware.c.

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

References ast_free, ast_iax2_firmware_header::datalen, iax_firmware::fd, and iax_firmware::fwh.

Referenced by iax_firmware_reload(), and iax_firmware_unload().

iax_firmware_append()

int iax_firmware_append	(	struct iax_ie_data *	ied,
		const char *	dev,
		unsigned int	desc
	)

Definition at line 283 of file firmware.c.

{
    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;
}

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), bs, ast_iax2_firmware_header::data, ast_iax2_firmware_header::datalen, desc, ast_iax2_firmware_header::devname, iax_firmware::fwh, iax_ie_append(), iax_ie_append_int(), iax_ie_append_raw(), IAX_IE_FWBLOCKDATA, IAX_IE_FWBLOCKDESC, and iax_firmware::list.

Referenced by socket_process_helper().

iax_firmware_get_version()

int iax_firmware_get_version	(	const char *	dev,
		uint16_t *	version
	)

Definition at line 263 of file firmware.c.

{
    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;
}

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), ast_iax2_firmware_header::devname, iax_firmware::fwh, iax_firmware::list, NULL, version, and ast_iax2_firmware_header::version.

Referenced by update_registry().

iax_firmware_reload()

void iax_firmware_reload

(

void

)

Definition at line 206 of file firmware.c.

{
    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);
}

References ast_config_AST_DATA_DIR, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_log, ast_verb, iax_firmware::dead, destroy_firmware(), errno, IAX_FIRMWARE_SUBDIR, LOG_WARNING, NULL, PATH_MAX, and try_firmware().

Referenced by load_module(), and reload_config().

iax_firmware_traverse()

void iax_firmware_traverse	(	const char *	filter,
		int(*)(struct ast_iax2_firmware_header *header, void *data)	callback,
		void *	data
	)

Definition at line 321 of file firmware.c.

{
    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);
}

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, callback(), ast_iax2_firmware_header::devname, filter(), iax_firmware::fwh, iax_firmware::list, and NULL.

Referenced by handle_cli_iax2_show_firmware().

iax_firmware_unload()

void iax_firmware_unload

(

void

)

Definition at line 250 of file firmware.c.

{
    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);
}

References AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, destroy_firmware(), iax_firmware::list, and NULL.

Referenced by __unload_module().

try_firmware()

static int try_firmware ( char *  s )

static

Definition at line 60 of file firmware.c.

{
    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;
}

References ast_alloca, ast_calloc, AST_FILE_MODE, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log, ast_random(), ast_strlen_zero(), buf, ast_iax2_firmware_header::chksum, ast_iax2_firmware_header::data, ast_iax2_firmware_header::datalen, iax_firmware::dead, ast_iax2_firmware_header::devname, errno, iax_firmware::fd, iax_firmware::fwh, IAX_FIRMWARE_MAGIC, last, len(), LOG_WARNING, ast_iax2_firmware_header::magic, md5(), MD5Final(), MD5Init(), MD5Update(), iax_firmware::mmaplen, NULL, and ast_iax2_firmware_header::version.

Referenced by iax_firmware_reload().

Variable Documentation

firmwares

struct firmwares firmwares = AST_LIST_HEAD_INIT_VALUE

static