cli.c

   1 /*
   2  * Copyright (C) 2008 Felix Fietkau <nbd@openwrt.org>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2
   6  * as published by the Free Software Foundation
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13 #include <strings.h>
  14 #include <stdlib.h>
  15 #include "uci.h"
  16
  17 static struct uci_context *ctx;
  18
  19 static void uci_usage(int argc, char **argv)
  20 {
  21         fprintf(stderr,
  22                 "Usage: %s [<options>] <command> [<arguments>]\n\n"
  23                 "Commands:\n"
  24                 "\texport   [<config>]\n"
  25                 "\tshow     [<config>[.<section>[.<option>]]]\n"
  26                 "\tget      <config>.<section>[.<option>]\n"
  27                 "\tset      <config>.<section>[.<option>]=<value>\n"
  28                 "\n",
  29                 argv[0]
  30         );
  31         exit(255);
  32 }
  33
  34 static void uci_show_section(struct uci_section *p)
  35 {
  36         struct uci_element *e;
  37         const char *cname, *sname;
  38
  39         cname = p->package->e.name;
  40         sname = p->e.name;
  41         printf("%s.%s=%s\n", cname, sname, p->type);
  42         uci_foreach_element(&p->options, e) {
  43                 printf("%s.%s.%s=%s\n", cname, sname, e->name, uci_to_option(e)->value);
  44         }
  45 }
  46
  47 static void uci_show_package(struct uci_package *p, char *section)
  48 {
  49         struct uci_element *e;
  50
  51         uci_foreach_element( &p->sections, e) {
  52                 if (!section || !strcmp(e->name, section))
  53                         uci_show_section(uci_to_section(e));
  54         }
  55 }
  56
  57 static int uci_show(int argc, char **argv)
  58 {
  59         char *section = (argc > 2 ? argv[2] : NULL);
  60         struct uci_package *package;
  61         char **configs;
  62         char **p;
  63
  64         configs = uci_list_configs(ctx);
  65         if (!configs)
  66                 return 0;
  67
  68         if (argc >= 2) {
  69                 if (uci_load(ctx, argv[1], &package) != UCI_OK) {
  70                         uci_perror(ctx, NULL);
  71                         return 1;
  72                 }
  73                 uci_show_package(package, section);
  74                 uci_unload(ctx, package);
  75                 return 0;
  76         }
  77
  78         for (p = configs; *p; p++) {
  79                 if ((argc < 2) || !strcmp(argv[1], *p)) {
  80                         if (uci_load(ctx, *p, &package) != UCI_OK) {
  81                                 uci_perror(ctx, NULL);
  82                                 return 1;
  83                         }
  84                         uci_show_package(package, section);
  85                         uci_unload(ctx, package);
  86                 }
  87         }
  88
  89         return 0;
  90 }
  91
  92 static int uci_do_export(int argc, char **argv)
  93 {
  94         char **configs = uci_list_configs(ctx);
  95         char **p;
  96
  97         if (!configs)
  98                 return 0;
  99
 100         for (p = configs; *p; p++) {
 101                 if ((argc < 2) || !strcmp(argv[1], *p)) {
 102                         struct uci_package *package = NULL;
 103                         int ret;
 104
 105                         ret = uci_load(ctx, *p, &package);
 106                         if (ret)
 107                                 continue;
 108                         uci_export(ctx, stdout, package, true);
 109                         uci_unload(ctx, package);
 110                 }
 111         }
 112         return 0;
 113 }
 114
 115 static int uci_do_get(int argc, char **argv)
 116 {
 117         char *package = NULL;
 118         char *section = NULL;
 119         char *option = NULL;
 120         struct uci_package *p = NULL;
 121         struct uci_element *e = NULL;
 122         char *value = NULL;
 123
 124         if (argc != 2)
 125                 return 255;
 126
 127         if (uci_parse_tuple(ctx, argv[1], &package, &section, &option, NULL) != UCI_OK)
 128                 return 1;
 129
 130         if (uci_load(ctx, package, &p) != UCI_OK) {
 131                 uci_perror(ctx, "uci");
 132                 return 1;
 133         }
 134
 135         if (uci_lookup(ctx, &e, p, section, option) != UCI_OK)
 136                 return 1;
 137
 138         switch(e->type) {
 139         case UCI_TYPE_SECTION:
 140                 value = uci_to_section(e)->type;
 141                 break;
 142         case UCI_TYPE_OPTION:
 143                 value = uci_to_option(e)->value;
 144                 break;
 145         default:
 146                 /* should not happen */
 147                 return 1;
 148         }
 149
 150         /* throw the value to stdout */
 151         printf("%s\n", value);
 152
 153         return 0;
 154 }
 155
 156 static int uci_do_set(int argc, char **argv)
 157 {
 158         struct uci_package *p;
 159         char *package = NULL;
 160         char *section = NULL;
 161         char *option = NULL;
 162         char *value = NULL;
 163
 164         if (argc != 2)
 165                 return 255;
 166
 167         if (uci_parse_tuple(ctx, argv[1], &package, &section, &option, &value) != UCI_OK)
 168                 return 1;
 169
 170         if (uci_load(ctx, package, &p) != UCI_OK) {
 171                 uci_perror(ctx, "uci");
 172                 return 1;
 173         }
 174
 175         if (uci_set(ctx, package, section, option, value) != UCI_OK) {
 176                 uci_perror(ctx, "uci");
 177                 return 1;
 178         }
 179         uci_commit(ctx, p);
 180         return 0;
 181 }
 182
 183 static int uci_cmd(int argc, char **argv)
 184 {
 185         if (!strcasecmp(argv[0], "show"))
 186                 return uci_show(argc, argv);
 187         if (!strcasecmp(argv[0], "export"))
 188                 return uci_do_export(argc, argv);
 189         if (!strcasecmp(argv[0], "get"))
 190                 return uci_do_get(argc, argv);
 191         if (!strcasecmp(argv[0], "set"))
 192                 return uci_do_set(argc, argv);
 193         return 255;
 194 }
 195
 196 int main(int argc, char **argv)
 197 {
 198         int ret;
 199
 200         ctx = uci_alloc_context();
 201         if (argc < 2)
 202                 uci_usage(argc, argv);
 203         ret = uci_cmd(argc - 1, argv + 1);
 204         if (ret == 255)
 205                 uci_usage(argc, argv);
 206         uci_free_context(ctx);
 207
 208         return ret;
 209 }