1 /*
2 * $Id: json_util.c,v 1.4 2006/01/30 23:07:57 mclark Exp $
3 *
4 * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd.
5 * Michael Clark <michael@metaparadigm.com>
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the MIT license. See COPYING for details.
9 *
10 */
11
12 #include "config.h"
13 #undef realloc
14
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <stddef.h>
18 #include <limits.h>
19 #include <string.h>
20 #include <errno.h>
21 #include <ctype.h>
22
23 #ifdef HAVE_SYS_TYPES_H
24 #include <sys/types.h>
25 #endif /* HAVE_SYS_TYPES_H */
26
27 #ifdef HAVE_SYS_STAT_H
28 #include <sys/stat.h>
29 #endif /* HAVE_SYS_STAT_H */
30
31 #ifdef HAVE_FCNTL_H
32 #include <fcntl.h>
33 #endif /* HAVE_FCNTL_H */
34
35 #ifdef HAVE_UNISTD_H
36 # include <unistd.h>
37 #endif /* HAVE_UNISTD_H */
38
39 #ifdef WIN32
40 # define WIN32_LEAN_AND_MEAN
41 # include <windows.h>
42 # include <io.h>
43 #endif /* defined(WIN32) */
44
45 #if !defined(HAVE_OPEN) && defined(WIN32)
46 # define open _open
47 #endif
48
49 #if !defined(HAVE_SNPRINTF) && defined(_MSC_VER)
50 /* MSC has the version as _snprintf */
51 # define snprintf _snprintf
52 #elif !defined(HAVE_SNPRINTF)
53 # error You do not have snprintf on your system.
54 #endif /* HAVE_SNPRINTF */
55
56 #include "debug.h"
57 #include "printbuf.h"
58 #include "json_inttypes.h"
59 #include "json_object.h"
60 #include "json_tokener.h"
61 #include "json_util.h"
62
63 static int sscanf_is_broken = 0;
64 static int sscanf_is_broken_testdone = 0;
65 static void sscanf_is_broken_test(void);
66
json_object_from_file(const char * filename)67 struct json_object* json_object_from_file(const char *filename)
68 {
69 struct printbuf *pb;
70 struct json_object *obj;
71 char buf[JSON_FILE_BUF_SIZE];
72 int fd, ret;
73
74 if((fd = open(filename, O_RDONLY)) < 0) {
75 MC_ERROR("json_object_from_file: error opening file %s: %s\n",
76 filename, strerror(errno));
77 return NULL;
78 }
79 if(!(pb = printbuf_new())) {
80 close(fd);
81 MC_ERROR("json_object_from_file: printbuf_new failed\n");
82 return NULL;
83 }
84 while((ret = read(fd, buf, JSON_FILE_BUF_SIZE)) > 0) {
85 printbuf_memappend(pb, buf, ret);
86 }
87 close(fd);
88 if(ret < 0) {
89 MC_ERROR("json_object_from_file: error reading file %s: %s\n",
90 filename, strerror(errno));
91 printbuf_free(pb);
92 return NULL;
93 }
94 obj = json_tokener_parse(pb->buf);
95 printbuf_free(pb);
96 return obj;
97 }
98
99 /* extended "format and write to file" function */
100
json_object_to_file_ext(const char * filename,struct json_object * obj,int flags)101 int json_object_to_file_ext(const char *filename, struct json_object *obj, int flags)
102 {
103 const char *json_str;
104 int fd, ret;
105 unsigned int wpos, wsize;
106
107 if(!obj) {
108 MC_ERROR("json_object_to_file: object is null\n");
109 return -1;
110 }
111
112 if((fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT, 0644)) < 0) {
113 MC_ERROR("json_object_to_file: error opening file %s: %s\n",
114 filename, strerror(errno));
115 return -1;
116 }
117
118 if(!(json_str = json_object_to_json_string_ext(obj,flags))) {
119 close(fd);
120 return -1;
121 }
122
123 wsize = (unsigned int)(strlen(json_str) & UINT_MAX); /* CAW: probably unnecessary, but the most 64bit safe */
124 wpos = 0;
125 while(wpos < wsize) {
126 if((ret = write(fd, json_str + wpos, wsize-wpos)) < 0) {
127 close(fd);
128 MC_ERROR("json_object_to_file: error writing file %s: %s\n",
129 filename, strerror(errno));
130 return -1;
131 }
132
133 /* because of the above check for ret < 0, we can safely cast and add */
134 wpos += (unsigned int)ret;
135 }
136
137 close(fd);
138 return 0;
139 }
140
141 // backwards compatible "format and write to file" function
142
json_object_to_file(const char * filename,struct json_object * obj)143 int json_object_to_file(const char *filename, struct json_object *obj)
144 {
145 return json_object_to_file_ext(filename, obj, JSON_C_TO_STRING_PLAIN);
146 }
147
json_parse_double(const char * buf,double * retval)148 int json_parse_double(const char *buf, double *retval)
149 {
150 return (sscanf(buf, "%lf", retval)==1 ? 0 : 1);
151 }
152
153 /*
154 * Not all implementations of sscanf actually work properly.
155 * Check whether the one we're currently using does, and if
156 * it's broken, enable the workaround code.
157 */
sscanf_is_broken_test()158 static void sscanf_is_broken_test()
159 {
160 int64_t num64;
161 int ret_errno, is_int64_min, ret_errno2, is_int64_max;
162
163 (void)sscanf(" -01234567890123456789012345", "%" SCNd64, &num64);
164 ret_errno = errno;
165 is_int64_min = (num64 == INT64_MIN);
166
167 (void)sscanf(" 01234567890123456789012345", "%" SCNd64, &num64);
168 ret_errno2 = errno;
169 is_int64_max = (num64 == INT64_MAX);
170
171 if (ret_errno != ERANGE || !is_int64_min ||
172 ret_errno2 != ERANGE || !is_int64_max)
173 {
174 MC_DEBUG("sscanf_is_broken_test failed, enabling workaround code\n");
175 sscanf_is_broken = 1;
176 }
177 }
178
json_parse_int64(const char * buf,int64_t * retval)179 int json_parse_int64(const char *buf, int64_t *retval)
180 {
181 int64_t num64;
182 const char *buf_sig_digits;
183 int orig_has_neg;
184 int saved_errno;
185
186 if (!sscanf_is_broken_testdone)
187 {
188 sscanf_is_broken_test();
189 sscanf_is_broken_testdone = 1;
190 }
191
192 // Skip leading spaces
193 while (isspace((int)*buf) && *buf)
194 buf++;
195
196 errno = 0; // sscanf won't always set errno, so initialize
197 if (sscanf(buf, "%" SCNd64, &num64) != 1)
198 {
199 MC_DEBUG("Failed to parse, sscanf != 1\n");
200 return 1;
201 }
202
203 saved_errno = errno;
204 buf_sig_digits = buf;
205 orig_has_neg = 0;
206 if (*buf_sig_digits == '-')
207 {
208 buf_sig_digits++;
209 orig_has_neg = 1;
210 }
211
212 // Not all sscanf implementations actually work
213 if (sscanf_is_broken && saved_errno != ERANGE)
214 {
215 char buf_cmp[100];
216 char *buf_cmp_start = buf_cmp;
217 int recheck_has_neg = 0;
218 int buf_cmp_len;
219
220 // Skip leading zeros, but keep at least one digit
221 while (buf_sig_digits[0] == '0' && buf_sig_digits[1] != '\0')
222 buf_sig_digits++;
223 if (num64 == 0) // assume all sscanf impl's will parse -0 to 0
224 orig_has_neg = 0; // "-0" is the same as just plain "0"
225
226 snprintf(buf_cmp_start, sizeof(buf_cmp), "%" PRId64, num64);
227 if (*buf_cmp_start == '-')
228 {
229 recheck_has_neg = 1;
230 buf_cmp_start++;
231 }
232 // No need to skip leading spaces or zeros here.
233
234 buf_cmp_len = strlen(buf_cmp_start);
235 /**
236 * If the sign is different, or
237 * some of the digits are different, or
238 * there is another digit present in the original string
239 * then we have NOT successfully parsed the value.
240 */
241 if (orig_has_neg != recheck_has_neg ||
242 strncmp(buf_sig_digits, buf_cmp_start, strlen(buf_cmp_start)) != 0 ||
243 ((int)strlen(buf_sig_digits) != buf_cmp_len &&
244 isdigit((int)buf_sig_digits[buf_cmp_len])
245 )
246 )
247 {
248 saved_errno = ERANGE;
249 }
250 }
251
252 // Not all sscanf impl's set the value properly when out of range.
253 // Always do this, even for properly functioning implementations,
254 // since it shouldn't slow things down much.
255 if (saved_errno == ERANGE)
256 {
257 if (orig_has_neg)
258 num64 = INT64_MIN;
259 else
260 num64 = INT64_MAX;
261 }
262 *retval = num64;
263 return 0;
264 }
265
266 #ifndef HAVE_REALLOC
rpl_realloc(void * p,size_t n)267 void* rpl_realloc(void* p, size_t n)
268 {
269 if (n == 0)
270 n = 1;
271 if (p == 0)
272 return malloc(n);
273 return realloc(p, n);
274 }
275 #endif
276
277 #define NELEM(a) (sizeof(a) / sizeof(a[0]))
278 static const char* json_type_name[] = {
279 /* If you change this, be sure to update the enum json_type definition too */
280 "null",
281 "boolean",
282 "double",
283 "int",
284 "object",
285 "array",
286 "string",
287 };
288
json_type_to_name(enum json_type o_type)289 const char *json_type_to_name(enum json_type o_type)
290 {
291 int o_type_int = (int)o_type;
292 if (o_type_int < 0 || o_type_int >= (int)NELEM(json_type_name))
293 {
294 MC_ERROR("json_type_to_name: type %d is out of range [0,%d]\n", o_type, NELEM(json_type_name));
295 return NULL;
296 }
297 return json_type_name[o_type];
298 }
299
300