Google Git
Sign in
apache / nuttx-apps / aed0e2873ef7cd45023c8a63c7fc2a565b999950 / . / system / cfgdata / cfgdata_main.c
blob: 83776a555c0866ddff143799f0e81e98326df7ca [file] [log] [blame]
/****************************************************************************
* apps/system/cfgdata/cfgdata_main.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <nuttx/mtd/mtd.h>
#include <nuttx/mtd/configdata.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <inttypes.h>
/****************************************************************************
* Private data
****************************************************************************/
static const char *g_config_dev = "/dev/config";
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Print usage information
****************************************************************************/
static void cfgdatacmd_help(void)
{
printf("\nUsage: cfgdata <cmd> [arguments]\n");
printf("Where <cmd> is one of:\n\n");
printf(" all: show all config entries\n");
printf(" print: display a specific config entry\n");
printf(" set: set or change a config entry\n");
printf(" unset: delete a config entry\n");
printf(" format: delete all config entries\n\n");
printf("Syntax for 'set' cmd:\n");
#ifdef CONFIG_MTD_CONFIG_NAMED
printf(" set name [hex_byte,hex_byte,etc.]\n");
printf(" set name \"string\"\n\n");
#else
printf(" set id,instance [bytes]\n");
printf(" set id,instance \"string\"\n\n");
#endif
printf("Syntax for 'print' cmd:\n");
#ifdef CONFIG_MTD_CONFIG_NAMED
printf(" print name\n");
#else
printf(" print id,instance\n");
#endif
printf("Syntax for 'unset' cmd:\n");
#ifdef CONFIG_MTD_CONFIG_NAMED
printf(" unset name\n");
#else
printf(" unset id,instance\n");
#endif
}
/****************************************************************************
* Parse out the id,inst,name tokens
****************************************************************************/
#ifndef CONFIG_MTD_CONFIG_NAMED
static int cfgdatacmd_idtok(int startpos, char *token)
{
while (token[startpos] != ',' && token[startpos] != '\0')
{
startpos++;
}
if (token[startpos] != ',')
{
/* Error in format */
printf("Expected config identifier in 'id,instance' format\n");
return 0;
}
/* return, skipping the ',' */
return startpos + 1;
}
#endif
/****************************************************************************
* Set a config item value
*
* config set 1,0,wr_width_cs0 [0x3]
* config set 1,1,wr_width_cs1 [0x2]
*
****************************************************************************/
static void cfgdatacmd_parse_byte_array(struct config_data_s *cfg,
int argc, char *argv[])
{
int x;
int c;
int count;
int val;
/* Start with arg3 */
x = 3;
c = 1;
count = 0;
/* Loop for all remaining arguments until ']' found */
while (x < argc && argv[x][c] != ']' && argv[x][c] != '\0')
{
/* Count this item */
count++;
/* Skip to next item */
while (argv[x][c] != ',' && argv[x][c] != ']' && argv[x][c] != 0)
{
c++;
}
/* Test for comma separator */
if (argv[x][c] == ',')
{
c++;
}
/* Test for space separated items */
if (argv[x][c] == 0)
{
x++;
c = 0;
}
}
/* Test if static stack space allocation is big enough for data */
if (count > cfg->len)
{
/* Perform dynamic memory allocation */
cfg->configdata = (FAR uint8_t *)malloc(count);
cfg->len = count;
}
/* Count determined. Start with arg3 again and parse the bytes */
x = 3;
c = 1;
count = 0;
/* Loop for all remaining arguments until ']' found */
while (x < argc && argv[x][c] != ']' && argv[x][c] != '\0')
{
/* Parse this item */
if (strncmp(&argv[x][c], "0x", 2) == 0)
{
/* Hex byte */
sscanf(&argv[x][c + 2], "%x", &val);
cfg->configdata[count] = (uint8_t)val;
}
else
{
/* Decimal value */
cfg->configdata[count] = (uint8_t)atoi(&argv[x][c]);
}
/* Increment the count */
count++;
/* Skip to next item */
while (argv[x][c] != ',' && argv[x][c] != ']' && argv[x][c] != 0)
{
c++;
}
/* Test for comma separator */
if (argv[x][c] == ',')
{
c++;
}
/* Test for space separated items */
if (argv[x][c] == 0)
{
x++;
c = 0;
}
}
cfg->len = count;
}
/****************************************************************************
* Set a config item value
*
* config set 1,0,wr_width_cs0 [0x3]
* config set 1,1,wr_width_cs1 [0x2]
*
****************************************************************************/
static void cfgdatacmd_set(int argc, char *argv[])
{
int ret;
int fd;
int x;
struct config_data_s cfg;
uint8_t data[32];
#ifdef CONFIG_MTD_CONFIG_NAMED
/* Copy the name to the cfg struct */
strlcpy(cfg.name, argv[2], CONFIG_MTD_CONFIG_NAME_LEN);
#else
/* Parse the id and instance */
cfg.id = atoi(argv[2]);
/* Advance past ',' to instance number */
x = cfgdatacmd_idtok(0, argv[2]);
if (x == 0)
{
return;
}
/* Convert instance to integer */
cfg.instance = atoi(&argv[2][x]);
#endif
/* Test if data is an array of bytes or simple string */
if (argv[3][0] == '[')
{
/* It is an array of bytes. Count the number of bytes */
cfg.configdata = data;
cfg.len = sizeof(data);
cfgdatacmd_parse_byte_array(&cfg, argc, argv);
}
else
{
bool isnumber = true;
/* It is a simple string. Test if it looks like a number */
cfg.configdata = data;
if (strncmp(argv[3], "0x", 2) == 0)
{
/* Test for all hex digit values */
for (x = 2; x < strlen(argv[3]); x++)
{
if (!isxdigit(argv[3][x]))
{
isnumber = false;
break;
}
}
if (isnumber)
{
sscanf(&argv[3][2], "%" SCNx32, (int32_t *)&cfg.configdata);
cfg.len = 4;
}
}
else
{
/* Test for all hex digit values */
for (x = 0; x < strlen(argv[3]); x++)
{
if (!isdigit(argv[3][x]))
{
isnumber = false;
break;
}
}
if (isnumber)
{
int32_t temp = atoi(argv[3]);
*((int32_t *)cfg.configdata) = temp;
cfg.len = 4;
}
}
if (!isnumber)
{
/* Point to the string and calculate the length */
cfg.configdata = (FAR uint8_t *)argv[3];
cfg.len = strlen(argv[3]) + 1;
}
}
/* Now open the /dev/config file and set the config item */
if ((fd = open(g_config_dev, 0)) < 2)
{
/* Display error */
printf("error: unable to open %s\n", g_config_dev);
return;
}
ret = ioctl(fd, CFGDIOC_SETCONFIG, (unsigned long)(uintptr_t)&cfg);
/* Close the file and report error if any */
close(fd);
if (ret != OK)
{
printf("Error %d setting config entry\n", errno);
}
/* Free the cfg.configdata if needed */
if (cfg.configdata != (FAR uint8_t *)argv[3] &&
cfg.configdata != data)
{
free(cfg.configdata);
}
}
/****************************************************************************
* Unset a config item value
****************************************************************************/
static void cfgdatacmd_unset(int argc, char *argv[])
{
int ret;
int fd;
struct config_data_s cfg;
#ifdef CONFIG_MTD_CONFIG_NAMED
/* Copy the name to the cfg struct */
strlcpy(cfg.name, argv[2], CONFIG_MTD_CONFIG_NAME_LEN);
#else
int x;
/* Parse the id and instance */
cfg.id = atoi(argv[2]);
/* Advance past ',' to instance number */
x = cfgdatacmd_idtok(0, argv[2]);
if (x == 0)
{
return;
}
/* Convert instance to integer */
cfg.instance = atoi(&argv[2][x]);
#endif
cfg.configdata = NULL;
cfg.len = 0;
/* Try to open the /dev/config file */
if ((fd = open(g_config_dev, 0)) < 2)
{
/* Display error */
printf("error: unable to open %s\n", g_config_dev);
return;
}
/* Delete the config item */
ret = ioctl(fd, CFGDIOC_DELCONFIG, (unsigned long)(uintptr_t)&cfg);
close(fd);
if (ret != OK)
{
printf("Error deletign config entry '%s'\n", argv[2]);
}
}
/****************************************************************************
* Print a config item value
*
* config print 1,1
* config print wr_width_cs0
*
****************************************************************************/
static void cfgdatacmd_print(int argc, char *argv[])
{
int ret;
int fd;
int x;
struct config_data_s cfg;
bool isstring;
#ifdef CONFIG_MTD_CONFIG_NAMED
/* Copy the name to the cfg struct */
strlcpy(cfg.name, argv[2], CONFIG_MTD_CONFIG_NAME_LEN);
#else
/* Parse the id and instance */
cfg.id = atoi(argv[2]);
/* Advance past ',' to instance number */
x = cfgdatacmd_idtok(0, argv[2]);
if (x == 0)
{
return;
}
/* Convert instance to integer */
cfg.instance = atoi(&argv[2][x]);
#endif
/* Try to open the /dev/config file */
if ((fd = open(g_config_dev, O_RDONLY)) < 2)
{
/* Display error */
printf("error: unable to open %s\n", g_config_dev);
return;
}
cfg.configdata = (FAR uint8_t *)malloc(256);
cfg.len = 256;
if (cfg.configdata == NULL)
{
printf("Error allocating buffer\n");
return;
}
/* Get the config item */
ret = ioctl(fd, CFGDIOC_GETCONFIG, (unsigned long)(uintptr_t)&cfg);
close(fd);
if (ret != OK)
{
printf("Error reading config entry '%s'\n", argv[2]);
free(cfg.configdata);
return;
}
/* Display the data */
isstring = cfg.configdata[cfg.len - 1] == 0;
for (x = 0; x < cfg.len - 1; x++)
{
/* Test for all ascii characters */
if (cfg.configdata[x] < ' ' || cfg.configdata[x] > '~')
{
isstring = false;
break;
}
}
/* Display the data */
if (isstring)
{
printf("%s\n", cfg.configdata);
}
else
{
/* Loop though all bytes and display them */
for (x = 0; x < cfg.len; x++)
{
/* Print the next byte */
printf("0x%02X ", cfg.configdata[x]);
if (((x + 1) & 7) == 0 && x + 1 != cfg.len)
{
printf("\n");
}
}
printf("\n");
}
free(cfg.configdata);
}
/****************************************************************************
* Enumerate and display all config items
****************************************************************************/
static void cfgdatacmd_show_all_config_items(void)
{
int ret;
int fd;
int x;
struct config_data_s cfg;
char fmtstr[24];
bool isstring;
/* Try to open the /dev/config file */
if ((fd = open(g_config_dev, 0)) < 2)
{
/* Display error */
printf("error: unable to open %s\n", g_config_dev);
return;
}
/* Print header */
#ifdef CONFIG_MTD_CONFIG_NAMED
snprintf(fmtstr, sizeof(fmtstr),
"%%-%ds%%-6sData\n", CONFIG_MTD_CONFIG_NAME_LEN);
printf(fmtstr, "Name", "Len");
snprintf(fmtstr, sizeof(fmtstr),
"%%-%ds%%-6d", CONFIG_MTD_CONFIG_NAME_LEN);
#else
strlcpy(fmtstr, "%-6s%-6s%-6sData\n", sizeof(fmtstr));
printf(fmtstr, "ID", "Inst", "Len");
strlcpy(fmtstr, "%-6d%-6d%-6d", sizeof(fmtstr));
#endif
/* Get the first config item */
cfg.configdata = (FAR uint8_t *)malloc(256);
cfg.len = 256;
if (cfg.configdata == NULL)
{
printf("Error allocating buffer\n");
return;
}
ret = ioctl(fd, CFGDIOC_FIRSTCONFIG, (unsigned long)(uintptr_t)&cfg);
while (ret != -1)
{
/* Print this entry */
#ifdef CONFIG_MTD_CONFIG_NAMED
printf(fmtstr, cfg.name, cfg.len);
#else
printf(fmtstr, cfg.id, cfg.instance, cfg.len);
#endif
/* Test if data is a string */
isstring = cfg.configdata[cfg.len - 1] == 0;
for (x = 0; x < cfg.len - 1; x++)
{
/* Test for all ascii characters */
if (cfg.configdata[x] < ' ' || cfg.configdata[x] > '~')
{
isstring = false;
break;
}
}
/* Display the data */
if (isstring)
{
printf("%s\n", cfg.configdata);
}
else
{
char fmtstr2[10];
#ifdef CONFIG_MTD_CONFIG_NAMED
snprintf(fmtstr2, sizeof(fmtstr2),
"\n%ds", CONFIG_MTD_CONFIG_NAME_LEN + 6);
#else
strlcpy(fmtstr2, "\n%18s", sizeof(fmtstr2));
#endif
/* Loop though all bytes and display them */
for (x = 0; x < cfg.len; x++)
{
/* Print the next byte */
printf("0x%02X ", cfg.configdata[x]);
if (((x + 1) & 7) == 0 && x + 1 != cfg.len)
{
printf(fmtstr2, " ");
}
}
printf("\n");
}
/* Get the next config item */
cfg.len = 256;
ret = ioctl(fd, CFGDIOC_NEXTCONFIG, (unsigned long)(uintptr_t)&cfg);
}
close(fd);
free(cfg.configdata);
}
/****************************************************************************
* Erase all config items
****************************************************************************/
static void cfgdatacmd_format(void)
{
int fd;
int ret;
/* Try to open the /dev/config file */
if ((fd = open(g_config_dev, 0)) < 2)
{
/* Display error */
printf("error: unable to open %s\n", g_config_dev);
return;
}
ret = ioctl(fd, MTDIOC_BULKERASE, 0);
close(fd);
if (ret != OK)
{
printf("Error %d config format\n", errno);
}
}
/****************************************************************************
* Public Functions
****************************************************************************/
int main(int argc, FAR char *argv[])
{
/* Argument given? */
if (argc == 1)
{
/* Show usage info and exit */
cfgdatacmd_help();
return 0;
}
/* Test for "all" cmd */
if (strcmp(argv[1], "all") == 0)
{
/* Print the existing config items */
cfgdatacmd_show_all_config_items();
return 0;
}
/* Test for "set" cmd */
if (strcmp(argv[1], "set") == 0)
{
if (argc < 4)
{
printf("At least 2 arguments needed for 'set' command\n");
return 0;
}
/* Call the routine to set a config item */
cfgdatacmd_set(argc, argv);
return 0;
}
/* Test for "print" cmd */
if (strcmp(argv[1], "print") == 0)
{
/* Test for print all */
if (strcmp(argv[2], "all") == 0)
{
cfgdatacmd_show_all_config_items();
}
else
{
/* Call the routine to print a config item */
cfgdatacmd_print(argc, argv);
}
return 0;
}
/* Test for "unset" cmd */
if (strcmp(argv[1], "unset") == 0)
{
if (argc < 3)
{
printf("Need 1 argument for 'unset' command\n");
return 0;
}
/* Call the routine to set a config item */
cfgdatacmd_unset(argc, argv);
return 0;
}
/* Test for "format" cmd */
if (strcmp(argv[1], "format") == 0)
{
/* Call the routine to erase all config items */
cfgdatacmd_format();
return 0;
}
/* Unknown cmd */
printf("Unknown config command: %s\n", argv[1]);
return 0;
}