Line data    Source code

       1             : /* json-c wrapper
       2             :  * Copyright (C) 2015 Cumulus Networks, Inc.
       3             :  *
       4             :  * This file is part of GNU Zebra.
       5             :  *
       6             :  * GNU Zebra is free software; you can redistribute it and/or modify it
       7             :  * under the terms of the GNU General Public License as published by the
       8             :  * Free Software Foundation; either version 2, or (at your option) any
       9             :  * later version.
      10             :  *
      11             :  * GNU Zebra is distributed in the hope that it will be useful, but
      12             :  * WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             :  * General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU General Public License along
      17             :  * with this program; see the file COPYING; if not, write to the Free Software
      18             :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
      19             :  */
      20             : 
      21             : #include <zebra.h>
      22             : 
      23             : #include "command.h"
      24             : #include "lib/json.h"
      25             : 
      26             : /*
      27             :  * This function assumes that the json keyword
      28             :  * is the *last* keyword on the line no matter
      29             :  * what.
      30             :  */
      31          52 : bool use_json(const int argc, struct cmd_token *argv[])
      32             : {
      33          52 :         if (argc == 0)
      34             :                 return false;
      35             : 
      36          52 :         if (argv[argc - 1]->arg && strmatch(argv[argc - 1]->text, "json"))
      37          52 :                 return true;
      38             : 
      39             :         return false;
      40             : }
      41             : 
      42          16 : struct json_object *json_object_new_stringv(const char *fmt, va_list args)
      43             : {
      44          16 :         struct json_object *ret;
      45          16 :         char *text, buf[256];
      46             : 
      47          16 :         text = vasnprintfrr(MTYPE_TMP, buf, sizeof(buf), fmt, args);
      48          16 :         ret = json_object_new_string(text);
      49             : 
      50          16 :         if (text != buf)
      51           0 :                 XFREE(MTYPE_TMP, text);
      52          16 :         return ret;
      53             : }
      54             : 
      55           0 : void json_array_string_add(json_object *json, const char *str)
      56             : {
      57           0 :         json_object_array_add(json, json_object_new_string(str));
      58           0 : }
      59             : 
      60           0 : void json_array_string_addv(json_object *json, const char *fmt, va_list args)
      61             : {
      62           0 :         json_object_array_add(json, json_object_new_stringv(fmt, args));
      63           0 : }
      64             : 
      65          38 : void json_object_string_add(struct json_object *obj, const char *key,
      66             :                             const char *s)
      67             : {
      68          38 :         json_object_object_add(obj, key, json_object_new_string(s));
      69          38 : }
      70             : 
      71          16 : void json_object_string_addv(struct json_object *obj, const char *key,
      72             :                              const char *fmt, va_list args)
      73             : {
      74          16 :         json_object_object_add(obj, key, json_object_new_stringv(fmt, args));
      75          16 : }
      76             : 
      77           4 : void json_object_object_addv(struct json_object *parent,
      78             :                              struct json_object *child, const char *keyfmt,
      79             :                              va_list args)
      80             : {
      81           4 :         char *text, buf[256];
      82             : 
      83           4 :         text = vasnprintfrr(MTYPE_TMP, buf, sizeof(buf), keyfmt, args);
      84           4 :         json_object_object_add(parent, text, child);
      85             : 
      86           4 :         if (text != buf)
      87           0 :                 XFREE(MTYPE_TMP, text);
      88           4 : }
      89             : 
      90          21 : void json_object_int_add(struct json_object *obj, const char *key, int64_t i)
      91             : {
      92          21 :         json_object_object_add(obj, key, json_object_new_int64(i));
      93          21 : }
      94             : 
      95           0 : void json_object_double_add(struct json_object *obj, const char *key, double i)
      96             : {
      97           0 :         json_object_object_add(obj, key, json_object_new_double(i));
      98           0 : }
      99             : 
     100           0 : void json_object_boolean_false_add(struct json_object *obj, const char *key)
     101             : {
     102           0 :         json_object_object_add(obj, key, json_object_new_boolean(0));
     103           0 : }
     104             : 
     105          18 : void json_object_boolean_true_add(struct json_object *obj, const char *key)
     106             : {
     107          18 :         json_object_object_add(obj, key, json_object_new_boolean(1));
     108          18 : }
     109             : 
     110           0 : void json_object_boolean_add(struct json_object *obj, const char *key, bool val)
     111             : {
     112           0 :         json_object_object_add(obj, key, json_object_new_boolean(val));
     113           0 : }
     114             : 
     115           8 : struct json_object *json_object_lock(struct json_object *obj)
     116             : {
     117           8 :         return json_object_get(obj);
     118             : }
     119             : 
     120          54 : void json_object_free(struct json_object *obj)
     121             : {
     122          54 :         json_object_put(obj);
     123          54 : }