openwrt shell使用json

openwrt中在shell中对json数据进行了处理，通过设置一些环境变量的值，来索引一个json数据。

jshc.sh是一个脚本，提供了一些设置json数据的环境变量
jshc是一个c写的获取环境变量，并解析出来json数据的函数，比如使用方法json -w。

gcc -o jshn jshn.c -ljson-c -I/usr/local/include/json-c        //可以使用的编译方式。

export K_J_V="hello world"


export J_V_hello=karl
export T_J_V_hello=string
export N_J_V_hello=kim


export J_V_world=liu
export T_J_V_world=object
export N_J_V_world=ssss


export K_liu="li dongwu"
export liu_li=my
export T_liu_li=string
export N_liu_li=yang


export liu_dongwu="mao"
export T_liu_dongwu=string
export N_liu_dongwu="cat"
./jshn -w


J_V为一个object，这个object包含了一系列的子object。所以必须有K_J_V表示每一个子object.


对于其中的一个子object,比如hello.
必须有如下资料
J_V_hello表示对象的值
T_J_V_hello 表示对象的类型
N_J_V_hello 表示对象的名字


比如字符串
J_V_hello="string value"
比如对象
J_V_hello="envsubobject"
envsubobject包含的对象如何去找到，则需要继续找
K_envsubobject="subobj1 subobj2"
这样后面的子对象
envsubobject_subobj1="value1"
T_envsuboject_subobj1=string
N_envsubobject_subobject1="subobj1"

附jshc.c源码：

点击(此处)折叠或打开

1. /*
   
2.  * Copyright (C) 2011-2013 Felix Fietkau <[e-mail]>
   
3.  *
   
4.  * Permission to use, copy, modify, and/or distribute this software for any
   
5.  * purpose with or without fee is hereby granted, provided that the above
   
6.  * copyright notice and this permission notice appear in all copies.
   
7.  *
   
8.  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   
9.  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   
10.  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    
11.  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    
12.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
    
13.  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    
14.  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
    
15.  */
    
16.         #include <json.h>
    
17. 
    
18. #include <string.h>
    
19. #include <stdlib.h>
    
20. #include <stdio.h>
    
21. #include <stdbool.h>
    
22. #include <ctype.h>
    
23. #include <getopt.h>
    
24. 
    
25. #define MAX_VARLEN    256
    
26. 
    
27. 
    
28. static const char *var_prefix = "";
    
29. static int var_prefix_len = 0;
    
30. 
    
31. static int add_json_element(const char *key, json_object *obj);
    
32. 
    
33. static int add_json_object(json_object *obj)
    
34. {
    
35.     int ret = 0;
    
36. 
    
37.     json_object_object_foreach(obj, key, val) {
    
38.         ret = add_json_element(key, val);
    
39.         if (ret)
    
40.             break;
    
41.     }
    
42.     return ret;
    
43. }
    
44. 
    
45. static int add_json_array(struct array_list *a)
    
46. {
    
47.     char seq[12];
    
48.     int i, len;
    
49.     int ret;
    
50. 
    
51.     for (i = 0, len = array_list_length(a); i < len; i++) {
    
52.         sprintf(seq, "%d", i);
    
53.         ret = add_json_element(seq, array_list_get_idx(a, i));
    
54.         if (ret)
    
55.             return ret;
    
56.     }
    
57. 
    
58.     return 0;
    
59. }
    
60. 
    
61. static void add_json_string(const char *str)
    
62. {
    
63.     char *ptr = (char *) str;
    
64.     int len;
    
65.     char *c;
    
66. 
    
67.     while ((c = strchr(ptr, '\'')) != NULL) {
    
68.         len = c - ptr;
    
69.         if (len > 0)
    
70.             fwrite(ptr, len, 1, stdout);
    
71.         ptr = c + 1;
    
72.         c = "'\\''";
    
73.         fwrite(c, strlen(c), 1, stdout);
    
74.     }
    
75.     len = strlen(ptr);
    
76.     if (len > 0)
    
77.         fwrite(ptr, len, 1, stdout);
    
78. }
    
79. 
    
80. static void write_key_string(const char *key)
    
81. {
    
82.     while (*key) {
    
83.         putc(isalnum(*key) ? *key : '_', stdout);
    
84.         key++;
    
85.     }
    
86. }
    
87. 
    
88. static int add_json_element(const char *key, json_object *obj)
    
89. {
    
90.     char *type;
    
91. 
    
92.     if (!obj)
    
93.         return -1;
    
94. 
    
95.     switch (json_object_get_type(obj)) {
    
96.     case json_type_object:
    
97.         type = "object";
    
98.         break;
    
99.     case json_type_array:
    
100.         type = "array";
     
101.         break;
     
102.     case json_type_string:
     
103.         type = "string";
     
104.         break;
     
105.     case json_type_boolean:
     
106.         type = "boolean";
     
107.         break;
     
108.     case json_type_int:
     
109.         type = "int";
     
110.         break;
     
111.     case json_type_double:
     
112.         type = "double";
     
113.         break;
     
114.     default:
     
115.         return -1;
     
116.     }
     
117. 
     
118.     fprintf(stdout, "json_add_%s '", type);
     
119.     write_key_string(key);
     
120. 
     
121.     switch (json_object_get_type(obj)) {
     
122.     case json_type_object:
     
123.         fprintf(stdout, "';\n");
     
124.         add_json_object(obj);
     
125.         fprintf(stdout, "json_close_object;\n");
     
126.         break;
     
127.     case json_type_array:
     
128.         fprintf(stdout, "';\n");
     
129.         add_json_array(json_object_get_array(obj));
     
130.         fprintf(stdout, "json_close_array;\n");
     
131.         break;
     
132.     case json_type_string:
     
133.         fprintf(stdout, "' '");
     
134.         add_json_string(json_object_get_string(obj));
     
135.         fprintf(stdout, "';\n");
     
136.         break;
     
137.     case json_type_boolean:
     
138.         fprintf(stdout, "' %d;\n", json_object_get_boolean(obj));
     
139.         break;
     
140.     case json_type_int:
     
141.         fprintf(stdout, "' %d;\n", json_object_get_int(obj));
     
142.         break;
     
143.     case json_type_double:
     
144.         fprintf(stdout, "' %lf;\n", json_object_get_double(obj));
     
145.         break;
     
146.     default:
     
147.         return -1;
     
148.     }
     
149. 
     
150.     return 0;
     
151. }
     
152. 
     
153. static int jshn_parse(const char *str)
     
154. {
     
155.     json_object *obj;
     
156. 
     
157.     obj = json_tokener_parse(str);
     
158.     if (!obj || json_object_get_type(obj) != json_type_object) {
     
159.         fprintf(stderr, "Failed to parse message data\n");
     
160.         return 1;
     
161.     }
     
162.     fprintf(stdout, "json_init;\n");
     
163.     add_json_object(obj);
     
164.     fflush(stdout);
     
165. 
     
166.     return 0;
     
167. }
     
168. 
     
169. static char *get_keys(const char *prefix)
     
170. {
     
171.     char *keys;
     
172. 
     
173.     keys = alloca(var_prefix_len + strlen(prefix) + sizeof("K_") + 1);
     
174.     sprintf(keys, "%sK_%s", var_prefix, prefix);
     
175.     printf("getenv %s\n", keys);
     
176.     return getenv(keys);
     
177. }
     
178. 
     
179. static void get_var(const char *prefix, const char **name, char **var, char **type)
     
180. {
     
181.     char *tmpname, *varname;
     
182. 
     
183.     tmpname = alloca(var_prefix_len + strlen(prefix) + 1 + strlen(*name) + 1 + sizeof("T_"));
     
184. 
     
185.     sprintf(tmpname, "%s%s_%s", var_prefix, prefix, *name);
     
186.     *var = getenv(tmpname);
     
187.     printf("getenv %s=%s\n", tmpname, *var);
     
188. 
     
189.     sprintf(tmpname, "%sT_%s_%s", var_prefix, prefix, *name);
     
190.     *type = getenv(tmpname);
     
191.     printf("getenv %s=%s\n", tmpname, *type);
     
192. 
     
193.     sprintf(tmpname, "%sN_%s_%s", var_prefix, prefix, *name);
     
194.     varname = getenv(tmpname);
     
195.     printf("getenv %s=%s\n", tmpname, varname);
     
196.     if (varname)
     
197.         *name = varname;
     
198. }
     
199. 
     
200. static json_object *jshn_add_objects(json_object *obj, const char *prefix, bool array);
     
201. 
     
202. static void jshn_add_object_var(json_object *obj, bool array, const char *prefix, const char *name)
     
203. {
     
204.     json_object *new;
     
205.     char *var, *type;
     
206. 
     
207.     get_var(prefix, &name, &var, &type);
     
208.     if (!var || !type)
     
209.         return;
     
210. 
     
211.     if (!strcmp(type, "array")) {
     
212.         new = json_object_new_array();
     
213.         jshn_add_objects(new, var, true);
     
214.     } else if (!strcmp(type, "object")) {
     
215.         new = json_object_new_object();
     
216.         jshn_add_objects(new, var, false);
     
217.     } else if (!strcmp(type, "string")) {
     
218.         new = json_object_new_string(var);
     
219.     } else if (!strcmp(type, "int")) {
     
220.         new = json_object_new_int(atoi(var));
     
221.     } else if (!strcmp(type, "double")) {
     
222.         new = json_object_new_double(strtod(var, NULL));
     
223.     } else if (!strcmp(type, "boolean")) {
     
224.         new = json_object_new_boolean(!!atoi(var));
     
225.     } else {
     
226.         return;
     
227.     }
     
228. 
     
229.     if (array)
     
230.         json_object_array_add(obj, new);
     
231.     else
     
232.         json_object_object_add(obj, name, new);
     
233. }
     
234. 
     
235. static json_object *jshn_add_objects(json_object *obj, const char *prefix, bool array)
     
236. {
     
237.     char *keys, *key, *brk;
     
238. 
     
239.     keys = get_keys(prefix);
     
240.     printf("prefix=%s, keys=%s\n", prefix, keys);
     
241.     if (!keys || !obj)
     
242.         goto out;
     
243. 
     
244.     for (key = strtok_r(keys, " ", &brk); key;
     
245.      key = strtok_r(NULL, " ", &brk)) {
     
246.         jshn_add_object_var(obj, array, prefix, key);
     
247.     }
     
248. 
     
249. out:
     
250.     return obj;
     
251. }
     
252. 
     
253. static int jshn_format(bool no_newline, bool indent)
     
254. {
     
255.     json_object *obj;
     
256.     const char *output;
     
257.     int ret = -1;
     
258. 
     
259.     if (!(obj = json_object_new_object()))
     
260.         return -1;
     
261. 
     
262.     jshn_add_objects(obj, "J_V", false);
     
263.     if (!(output = json_object_to_json_string(obj)))
     
264.         goto out;
     
265. 
     
266.     if (indent) {
     
267.     }
     
268.     fprintf(stdout, "%s%s", output, no_newline ? "" : "\n");
     
269.     ret = 0;
     
270. 
     
271. out:
     
272.     json_object_put(obj);
     
273.     return ret;
     
274. }
     
275. 
     
276. static int usage(const char *progname)
     
277. {
     
278.     fprintf(stderr, "Usage: %s [-n] [-i] -r |-w\n", progname);
     
279.     return 2;
     
280. }
     
281. 
     
282. int main(int argc, char **argv)
     
283. {
     
284.     bool no_newline = false;
     
285.     bool indent = false;
     
286.     int ch;
     
287. 
     
288.     while ((ch = getopt(argc, argv, "p:nir:w")) != -1) {
     
289.         switch(ch) {
     
290.         case 'p':
     
291.             var_prefix = optarg;
     
292.             var_prefix_len = strlen(var_prefix);
     
293.             break;
     
294.         case 'r':
     
295.             return jshn_parse(optarg);
     
296.         case 'w':
     
297.             return jshn_format(no_newline, indent);
     
298.         case 'n':
     
299.             no_newline = true;
     
300.             break;
     
301.         case 'i