In the event the realloc fails, argout would be clobbered, losing our only pointer to all of the allocated memory. So, realloc into a new temporary variable, and then if that is valid, set argout to it. Also fixes an incorrect sizeof(int**)
455 lines
11 KiB
C
455 lines
11 KiB
C
/*
|
|
* Copyright (c) 2017 Nuand LLC.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#include "parse.h"
|
|
#include "conversions.h"
|
|
#include "log.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
static char **add_arg(
|
|
char **argv, int argc, const char *buf, int start, int end, int quote_count)
|
|
{
|
|
char **rv;
|
|
char *d_ptr;
|
|
int i;
|
|
int len;
|
|
|
|
char c;
|
|
char quote_char;
|
|
|
|
quote_char = 0;
|
|
|
|
rv = (char **)realloc(argv, sizeof(char *) * (argc + 1));
|
|
if (rv == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
rv[argc] = NULL;
|
|
|
|
len = end - start + 1;
|
|
|
|
d_ptr = (char *)malloc(len + 1 - quote_count * 2);
|
|
if (d_ptr == NULL) {
|
|
free(rv);
|
|
return NULL;
|
|
}
|
|
|
|
rv[argc - 1] = d_ptr;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
c = buf[start + i];
|
|
|
|
if (!quote_char) {
|
|
/* We are not in a quote, copy everything but quote chars */
|
|
if (c == '"' || c == '\'') {
|
|
quote_char = c;
|
|
} else {
|
|
*d_ptr++ = c;
|
|
}
|
|
} else {
|
|
/* We are in a quote, copy everything but the current quote char */
|
|
if (c == quote_char) {
|
|
quote_char = 0;
|
|
} else {
|
|
*d_ptr++ = c;
|
|
}
|
|
}
|
|
}
|
|
*d_ptr = '\0';
|
|
|
|
return rv;
|
|
}
|
|
|
|
int str2args(const char *line, char comment_char, char ***argv)
|
|
{
|
|
char **rv;
|
|
int argc;
|
|
|
|
unsigned i;
|
|
size_t len;
|
|
|
|
bool in_arg;
|
|
char c;
|
|
char quote_char;
|
|
|
|
int arg_start;
|
|
int quote_count;
|
|
|
|
rv = NULL;
|
|
argc = 0;
|
|
|
|
quote_char = 0;
|
|
|
|
arg_start = 0;
|
|
quote_count = 0;
|
|
|
|
len = strlen(line);
|
|
|
|
in_arg = false;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
c = line[i];
|
|
|
|
if (in_arg) {
|
|
/* Found the end of a quote! */
|
|
if (quote_char) {
|
|
if (quote_char == c) {
|
|
quote_char = 0;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
/* Found the beginning of a quote! */
|
|
if (c == '\'' || c == '"') {
|
|
quote_count++;
|
|
quote_char = c;
|
|
continue;
|
|
}
|
|
|
|
/* Found whitespace outside of quote */
|
|
if (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
|
|
in_arg = false;
|
|
argc++;
|
|
rv = add_arg(rv, argc, line, arg_start, i - 1, quote_count);
|
|
if (rv == NULL)
|
|
return -1;
|
|
}
|
|
} else {
|
|
if (c == comment_char) {
|
|
break;
|
|
}
|
|
/* Enter a new argument */
|
|
if (c != ' ' && c != '\t' && c != '\r' && c != '\n') {
|
|
/* If first argument is a tick it means we're in a quote */
|
|
if (c == '\'' || c == '"') {
|
|
quote_char = c;
|
|
} else {
|
|
quote_char = 0;
|
|
}
|
|
quote_count = 0;
|
|
arg_start = i;
|
|
in_arg = true;
|
|
}
|
|
/* else this is still whitespace */
|
|
}
|
|
}
|
|
|
|
/* reached the end of the line, check to see if current arg needs to
|
|
* be closed */
|
|
if (in_arg) {
|
|
if (quote_char) {
|
|
free_args(argc, rv);
|
|
return -2;
|
|
} else {
|
|
argc++;
|
|
rv = add_arg(rv, argc, line, arg_start, i - 1, quote_count);
|
|
if (rv == NULL) {
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
*argv = rv;
|
|
|
|
return argc;
|
|
}
|
|
|
|
void free_args(int argc, char **argv)
|
|
{
|
|
int i;
|
|
for (i = 0; i < argc; i++) {
|
|
free(argv[i]);
|
|
}
|
|
free(argv);
|
|
}
|
|
|
|
static struct config_options *add_opt(
|
|
struct config_options *optv, int optc, char *key, char *val, int lineno)
|
|
{
|
|
struct config_options *rv;
|
|
char *ptr1, *ptr2;
|
|
rv = (struct config_options *)realloc(optv,
|
|
sizeof(struct config_options) * optc);
|
|
if (rv == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
ptr1 = (char *)malloc(strlen(key) + 1);
|
|
if (ptr1 == NULL) {
|
|
free(rv);
|
|
return NULL;
|
|
}
|
|
strcpy(ptr1, key);
|
|
rv[optc - 1].key = ptr1;
|
|
|
|
ptr2 = (char *)malloc(strlen(val) + 1);
|
|
if (ptr2 == NULL) {
|
|
free(ptr1);
|
|
free(rv);
|
|
return NULL;
|
|
}
|
|
strcpy(ptr2, val);
|
|
rv[optc - 1].value = ptr2;
|
|
|
|
rv[optc - 1].lineno = lineno;
|
|
|
|
return rv;
|
|
}
|
|
|
|
bool update_match(struct bladerf *dev, char *str)
|
|
{
|
|
size_t len;
|
|
int status;
|
|
struct bladerf_devinfo info;
|
|
bladerf_fpga_size fpga_size;
|
|
|
|
status = bladerf_get_devinfo(dev, &info);
|
|
if (status < 0)
|
|
return false;
|
|
|
|
bladerf_get_fpga_size(dev, &fpga_size);
|
|
if (status < 0)
|
|
return false;
|
|
|
|
str++;
|
|
len = strlen(str);
|
|
if (str[len - 1] == ']')
|
|
str[len - 1] = '\0';
|
|
|
|
if (!strcmp(str, "x40")) {
|
|
return fpga_size == BLADERF_FPGA_40KLE;
|
|
} else if (!strcmp(str, "x115")) {
|
|
return fpga_size == BLADERF_FPGA_115KLE;
|
|
}
|
|
|
|
status = bladerf_devstr_matches(str, &info);
|
|
|
|
return status == 1;
|
|
}
|
|
|
|
int str2options(struct bladerf *dev,
|
|
const char *buf,
|
|
size_t buf_sz,
|
|
struct config_options **opts)
|
|
{
|
|
char *line;
|
|
char *d_ptr;
|
|
int line_num;
|
|
char c;
|
|
unsigned i;
|
|
|
|
struct config_options *optv;
|
|
int optc;
|
|
|
|
char **line_argv;
|
|
int line_argc;
|
|
|
|
bool match;
|
|
|
|
match = true;
|
|
|
|
optv = NULL;
|
|
optc = 0;
|
|
|
|
line_num = 1;
|
|
|
|
line = malloc(buf_sz + 1);
|
|
if (!line)
|
|
return BLADERF_ERR_MEM;
|
|
|
|
d_ptr = line;
|
|
|
|
for (i = 0; i < buf_sz; i++) {
|
|
c = buf[i];
|
|
if (c == '\n') {
|
|
/* deal with the old line */
|
|
*d_ptr = 0;
|
|
line_argc = str2args(line, '#', &line_argv);
|
|
if (line_argc < 0)
|
|
goto out;
|
|
|
|
/* handle line */
|
|
if (line_argc > 3) {
|
|
log_error("Too many arguments in bladeRF.conf on line %d\n",
|
|
line_num);
|
|
goto out;
|
|
} else if (match && line_argc == 2) {
|
|
optc++;
|
|
optv =
|
|
add_opt(optv, optc, line_argv[0], line_argv[1], line_num);
|
|
if (!optv) {
|
|
optc = -1;
|
|
goto out;
|
|
}
|
|
} else if (line_argc == 1) {
|
|
if (*line_argv[0] != '[') {
|
|
log_error("Expecting scoping line (requires [ and ]) on "
|
|
"line %d\n",
|
|
line_num);
|
|
}
|
|
match = update_match(dev, line_argv[0]);
|
|
}
|
|
|
|
/* free line */
|
|
free_args(line_argc, line_argv);
|
|
|
|
/* setup to capture the next line */
|
|
line_num++;
|
|
d_ptr = line;
|
|
} else {
|
|
*d_ptr++ = c;
|
|
}
|
|
}
|
|
|
|
if (opts)
|
|
*opts = optv;
|
|
|
|
out:
|
|
free(line);
|
|
return optc;
|
|
}
|
|
|
|
void free_opts(struct config_options *optv, int optc)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < optc; i++) {
|
|
free(optv[i].key);
|
|
free(optv[i].value);
|
|
}
|
|
free(optv);
|
|
}
|
|
|
|
int csv2int(const char *line, int ***args)
|
|
{
|
|
const char delim[] = " \r\n\t,.:"; /* supported delimiters */
|
|
const size_t MAXLEN = 128; /* max line length (with newline and null) */
|
|
static size_t arglen = 2; /* tunable: initial expected column count */
|
|
char *myline = NULL; /* local copy of 'line' */
|
|
char *parsestr = NULL; /* ptr to 'myline' on first strtok_r */
|
|
char *saveptr = NULL; /* strtok_r state pointer */
|
|
int **argout = NULL; /* array of output values */
|
|
size_t count = 0; /* count of tokens extracted */
|
|
size_t i;
|
|
|
|
// Validity check
|
|
if (NULL == line) {
|
|
log_debug("line is null\n");
|
|
return 0;
|
|
}
|
|
|
|
if (NULL == args) {
|
|
log_error("args is null\n");
|
|
goto fail;
|
|
}
|
|
|
|
// strtok_r doesn't respect const, so make a copy of 'line'
|
|
myline = calloc(MAXLEN, 1);
|
|
if (NULL == myline) {
|
|
log_error("could not calloc myline\n");
|
|
goto fail;
|
|
}
|
|
|
|
myline = strncpy(myline, line, MAXLEN - 1);
|
|
|
|
// Initial allocation of argout
|
|
argout = malloc(arglen * sizeof(int *));
|
|
if (NULL == argout) {
|
|
log_error("could not malloc argout\n");
|
|
goto fail;
|
|
}
|
|
|
|
// Loop over input until strtok_r returns a NULL
|
|
for (i = 0, parsestr = myline; true; ++i, parsestr = NULL) {
|
|
char *token = NULL; /* return token from strtok_r */
|
|
bool ok;
|
|
|
|
token = strtok_r(parsestr, delim, &saveptr);
|
|
if (NULL == token) {
|
|
break;
|
|
}
|
|
|
|
// Expand argout if necessary
|
|
if (i >= arglen) {
|
|
arglen *= 2;
|
|
log_verbose("expanding allocation to %zu column(s)\n", arglen);
|
|
int **newargout = realloc(argout, arglen * sizeof(int *));
|
|
if (NULL == newargout) {
|
|
log_error("could not realloc(argout,%zu)\n", arglen);
|
|
goto fail;
|
|
}
|
|
argout = newargout;
|
|
}
|
|
|
|
// Allocate memory for this value
|
|
argout[i] = malloc(sizeof(int));
|
|
if (NULL == argout[i]) {
|
|
log_error("could not malloc argout[%zu]\n", i);
|
|
goto fail;
|
|
}
|
|
|
|
// Update the count now, in case str2int fails and we need to dealloc
|
|
++count;
|
|
|
|
// Parse token into an integer value
|
|
*argout[i] = str2int(token, INT32_MIN, INT32_MAX, &ok);
|
|
if (!ok) {
|
|
log_error("str2int failed on '%s'\n", token);
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
// Success!
|
|
*args = argout;
|
|
free(myline);
|
|
|
|
// If arglen is too big, cut it in half next time...
|
|
if (count <= (arglen / 2)) {
|
|
arglen /= 2;
|
|
log_verbose("decreasing future arglen to %zu\n", arglen);
|
|
}
|
|
|
|
return (int)count;
|
|
|
|
fail:
|
|
// Deallocate everything...
|
|
free(myline);
|
|
free_csv2int((int)count, argout);
|
|
return -1;
|
|
}
|
|
|
|
void free_csv2int(int argc, int **args)
|
|
{
|
|
int i;
|
|
|
|
if (NULL == args) {
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < argc; ++i) {
|
|
free(args[i]);
|
|
}
|
|
|
|
free(args);
|
|
}
|