• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/json-c/json_util.c

  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 "bits.h"
 57 #include "debug.h"
 58 #include "printbuf.h"
 59 #include "json_inttypes.h"
 60 #include "json_object.h"
 61 #include "json_tokener.h"
 62 #include "json_util.h"
 63 
 64 static int sscanf_is_broken = 0;
 65 static int sscanf_is_broken_testdone = 0;
 66 static void sscanf_is_broken_test(void);
 67 
 68 struct json_object* json_object_from_file(const char *filename)
 69 {
 70   struct printbuf *pb;
 71   struct json_object *obj;
 72   char buf[JSON_FILE_BUF_SIZE];
 73   int fd, ret;
 74 
 75   if((fd = open(filename, O_RDONLY)) < 0) {
 76     MC_ERROR("json_object_from_file: error reading file %s: %s\n",
 77              filename, strerror(errno));
 78     return NULL;
 79   }
 80   if(!(pb = printbuf_new())) {
 81     close(fd);
 82     MC_ERROR("json_object_from_file: printbuf_new failed\n");
 83     return NULL;
 84   }
 85   while((ret = read(fd, buf, JSON_FILE_BUF_SIZE)) > 0) {
 86     printbuf_memappend(pb, buf, ret);
 87   }
 88   close(fd);
 89   if(ret < 0) {
 90     MC_ABORT("json_object_from_file: error reading file %s: %s\n",
 91              filename, strerror(errno));
 92     printbuf_free(pb);
 93     return NULL;
 94   }
 95   obj = json_tokener_parse(pb->buf);
 96   printbuf_free(pb);
 97   return obj;
 98 }
 99 
100 /* extended "format and write to file" function */
101 
102 int json_object_to_file_ext(char *filename, struct json_object *obj, int flags)
103 {
104   const char *json_str;
105   int fd, ret;
106   unsigned int wpos, wsize;
107 
108   if(!obj) {
109     MC_ERROR("json_object_to_file: object is null\n");
110     return -1;
111   }
112 
113   if((fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT, 0644)) < 0) {
114     MC_ERROR("json_object_to_file: error opening file %s: %s\n",
115              filename, strerror(errno));
116     return -1;
117   }
118 
119   if(!(json_str = json_object_to_json_string_ext(obj,flags))) {
120     close(fd);
121     return -1;
122   }
123 
124   wsize = (unsigned int)(strlen(json_str) & UINT_MAX); /* CAW: probably unnecessary, but the most 64bit safe */
125   wpos = 0;
126   while(wpos < wsize) {
127     if((ret = write(fd, json_str + wpos, wsize-wpos)) < 0) {
128       close(fd);
129       MC_ERROR("json_object_to_file: error writing file %s: %s\n",
130              filename, strerror(errno));
131       return -1;
132     }
133 
134         /* because of the above check for ret < 0, we can safely cast and add */
135     wpos += (unsigned int)ret;
136   }
137 
138   close(fd);
139   return 0;
140 }
141 
142 // backwards compatible "format and write to file" function
143 
144 int json_object_to_file(char *filename, struct json_object *obj)
145 {
146   return json_object_to_file_ext(filename, obj, JSON_C_TO_STRING_PLAIN);
147 }
148 
149 int json_parse_double(const char *buf, double *retval)
150 {
151   return (sscanf(buf, "%lf", retval)==1 ? 0 : 1);
152 }
153 
154 /*
155  * Not all implementations of sscanf actually work properly.
156  * Check whether the one we're currently using does, and if
157  * it's broken, enable the workaround code.
158  */
159 static void sscanf_is_broken_test()
160 {
161         int64_t num64;
162 
163         (void)sscanf(" -01234567890123456789012345", "%" SCNd64, &num64);
164         int ret_errno = errno;
165         int is_int64_min = (num64 == INT64_MIN);
166 
167         (void)sscanf(" 01234567890123456789012345", "%" SCNd64, &num64);
168         int ret_errno2 = errno;
169         int 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 
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] == '' && 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 ""
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
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 
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 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt