예제 #1
0
파일: dp_js.c 프로젝트: dplatform/dupin
static JSValueRef
js_emit (JSContextRef ctx, JSObjectRef object, JSObjectRef thisObject,
	 size_t argumentCount, const JSValueRef arguments[],
	 JSValueRef * exception)
{
  JsonObject *obj;
  JsonNode *node;
  gchar *buffer;
  if (argumentCount != 1)
    {
      *exception = JSValueMakeNumber (ctx, 1);
      return NULL;
    }
  if (JSValueIsObject (ctx, arguments[0]) == false)
    {
      *exception = JSValueMakeNumber (ctx, 1);
      return NULL;
    }

  obj = json_object_new();

  js_value (ctx, (JSObjectRef) arguments[0], &node);
  json_object_set_member (obj, "emit", node);

  JsonNode *node1 = json_node_new (JSON_NODE_OBJECT);

  if (node1 == NULL)
    {
      json_object_unref (obj);
      return NULL;
    }

  json_node_set_object (node1, obj);

  JsonGenerator *gen = json_generator_new();

  if (gen == NULL)
    {
      json_node_free (node1);
      return NULL;
    }

  json_generator_set_root (gen, node1 );
  buffer = json_generator_to_data (gen,NULL);

  if (buffer == NULL)
    {
      json_node_free (node1);
      g_object_unref (gen);
      return NULL;
    }

  json_node_free (node1);
  g_object_unref (gen);

  puts (buffer);
  g_free (buffer);

  return NULL; /* shouldn't be an object ? */
}
예제 #2
0
/**
 * json_builder_add_value:
 * @builder: a #JsonBuilder
 * @node: (transfer full): the value of the member or element
 *
 * If called after json_builder_set_member_name(), sets @node as member of the
 * most recent opened object, otherwise @node is added as element of the most
 * recent opened array.
 *
 * The builder will take ownership of the #JsonNode.
 *
 * Return value: (transfer none): the #JsonBuilder, or %NULL if the call was inconsistent
 */
JsonBuilder *
json_builder_add_value (JsonBuilder *builder,
                        JsonNode    *node)
{
  JsonBuilderState *state;

  g_return_val_if_fail (JSON_IS_BUILDER (builder), NULL);
  g_return_val_if_fail (node != NULL, NULL);
  g_return_val_if_fail (!g_queue_is_empty (builder->priv->stack), NULL);
  g_return_val_if_fail (json_builder_is_valid_add_mode (builder), NULL);

  state = g_queue_peek_head (builder->priv->stack);
  switch (state->mode)
    {
    case JSON_BUILDER_MODE_MEMBER:
      json_object_set_member (state->data.object, state->member_name, node);
      g_free (state->member_name);
      state->member_name = NULL;
      state->mode = JSON_BUILDER_MODE_OBJECT;
      break;

    case JSON_BUILDER_MODE_ARRAY:
      json_array_add_element (state->data.array, node);
      break;

    default:
      g_assert_not_reached ();
    }

  return builder;
}
예제 #3
0
JsonNode*
cometd_new_publish_message(const cometd* h,
                           const char* channel,
                           JsonNode* data)
{
  gint64 seed = ++(h->conn->msg_id_seed);

  JsonNode*   root = json_node_new(JSON_NODE_OBJECT);
  JsonObject* obj  = json_object_new();

  json_object_set_int_member(obj, COMETD_MSG_ID_FIELD, seed);

  json_object_set_string_member(obj,
                                COMETD_MSG_CHANNEL_FIELD,
                                channel);

  json_object_set_string_member(obj,
                                COMETD_MSG_CLIENT_ID_FIELD,
                                cometd_conn_client_id(h->conn));

  json_object_set_member(obj,
                         COMETD_MSG_DATA_FIELD,
                         json_node_copy(data));

  json_node_take_object(root, obj);

  return root;
}
예제 #4
0
JsonNode*   cometd_ping_ls(cometd* h, char *target)
{
  JsonObject	*adviceObject = json_object_new();
  JsonNode	*adviceNode = json_node_new(JSON_NODE_OBJECT);
  JsonNode	*adviceRoot = json_node_init_object(adviceNode, adviceObject);

  adviceObject = json_node_get_object(adviceRoot);

  json_object_set_string_member(adviceObject, "folder", "/");

  
  JsonNode*	root = json_node_new(JSON_NODE_OBJECT);
  JsonObject*	obj  = json_object_new();
  gint64	seed = ++(h->conn->msg_id_seed);

  char*  connection_type = cometd_current_transport(h)->name;
  
  json_object_set_int_member   (obj, COMETD_MSG_ID_FIELD,      seed);
  json_object_set_string_member(obj, COMETD_MSG_CHANNEL_FIELD, target);
  json_object_set_string_member(obj, "connectionType",         connection_type);
  json_object_set_member(obj, "data", adviceRoot);
  json_object_set_string_member(obj, "clientId",               cometd_conn_client_id(h->conn));
 
  json_node_take_object(root, obj);

  return(root);
}
예제 #5
0
파일: snra-json.c 프로젝트: gkiagia/aurena
static gboolean
snra_add_struct_object (GQuark field_id, const GValue * value, JsonObject * o)
{
  JsonNode *n = snra_json_value_to_node (value);
  if (n)
    json_object_set_member (o, g_quark_to_string (field_id), n);
  return TRUE;
}
예제 #6
0
static void
glide_document_json_obj_set_name (GlideDocument *document, JsonObject *obj)
{
  JsonNode *node = json_node_new (JSON_NODE_VALUE);
  json_node_set_string (node, document->priv->name);
  
  json_object_set_member (obj, "name", node);
}
예제 #7
0
static JsonObject *
json_gobject_dump (GObject *gobject)
{
  JsonSerializableIface *iface = NULL;
  JsonSerializable *serializable = NULL;
  gboolean serialize_property = FALSE;
  JsonObject *object;
  GParamSpec **pspecs;
  guint n_pspecs, i;

  if (JSON_IS_SERIALIZABLE (gobject))
    {
      serializable = JSON_SERIALIZABLE (gobject);
      iface = JSON_SERIALIZABLE_GET_IFACE (gobject);
      serialize_property = (iface->serialize_property != NULL);
    }

  object = json_object_new ();

  pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (gobject), &n_pspecs);
  for (i = 0; i < n_pspecs; i++)
    {
      GParamSpec *pspec = pspecs[i];
      GValue value = { 0, };
      JsonNode *node = NULL;

      /* read only what we can */
      if (!(pspec->flags & G_PARAM_READABLE))
        continue;

      g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
      g_object_get_property (gobject, pspec->name, &value);

      /* if there is a serialization vfunc, then it is completely responsible
       * for serializing the property, possibly by calling the implementation
       * of the default JsonSerializable interface through chaining up
       */
      if (serialize_property)
        {
          node = iface->serialize_property (serializable, pspec->name,
                                            &value,
                                            pspec);
        }
      else
        node = json_serialize_pspec (&value, pspec);

      if (node)
        json_object_set_member (object, pspec->name, node);

      g_value_unset (&value);
    }

  g_free (pspecs);

  return object;
}
예제 #8
0
void
searpc_set_object_to_ret_object (JsonObject *object, GObject *ret)
{
    if (ret == NULL)
        json_object_set_null_member (object, "ret");
    else {
        json_object_set_member (object, "ret", json_gobject_serialize(ret));
        g_object_unref (ret);
    }
}
예제 #9
0
static void
gvariant_to_json_object_foreach (GVariant *variant_child, gpointer  user_data)
{
  gchar *member_name;
  JsonNode *json_child;
  JsonObject *object = (JsonObject *) user_data;

  json_child = gvariant_dict_entry_to_json (variant_child, &member_name);
  json_object_set_member (object, member_name, json_child);
  g_free (member_name);
}
예제 #10
0
파일: glide-image.c 프로젝트: racarr/Glide
static void
glide_json_object_add_image_properties (JsonObject *obj, GlideImage *image)
{
  JsonNode *n = json_node_new (JSON_NODE_OBJECT);
  JsonObject *img_obj = json_object_new ();
  
  json_node_set_object (n, img_obj);
  
  glide_json_object_set_string (img_obj, "filename", image->priv->filename);
  
  json_object_set_member (obj, "image-properties", n);
}
예제 #11
0
파일: alert.c 프로젝트: j-o-h-n-g/yaarf
void
snarf_alert_add_double_field(snarf_alert_t *alert,
                             const char    *name,
                             double         value)
{
JsonObject * rootobj = json_node_get_object (alert->msg);
JsonObject * bodyobj = json_object_get_object_member(rootobj,"body");
JsonNode * doublenode = json_node_alloc();
doublenode=json_node_init_double(doublenode,value);
json_object_set_member(bodyobj,name,doublenode);

}
예제 #12
0
파일: alert.c 프로젝트: j-o-h-n-g/yaarf
void
snarf_alert_add_int_field(snarf_alert_t *alert,
                          const char    *name,
                          int64_t        value)
{

JsonObject * rootobj = json_node_get_object (alert->msg);
JsonObject * bodyobj = json_object_get_object_member(rootobj,"body");
JsonNode * intnode = json_node_alloc();
intnode=json_node_init_int(intnode,value);
json_object_set_member(bodyobj,name,intnode);

}
예제 #13
0
static gboolean
process_open_dynamic_peer (CockpitRouter *self,
                           const gchar *channel,
                           JsonObject *options,
                           GBytes *data,
                           gpointer user_data)
{
  CockpitPeer *peer = NULL;
  DynamicKey key = { NULL, NULL };
  DynamicPeer *dp = user_data;
  JsonObject *config = NULL;
  GList *l, *names = NULL;

  if (dp->spawn)
    add_dynamic_args_to_array (&key.argv, dp->spawn, options);

  if (dp->env)
    add_dynamic_args_to_array (&key.environ, dp->env, options);

  peer = g_hash_table_lookup (dp->peers, &key);
  if (!peer)
    {
      config = json_object_new ();
      names = json_object_get_members (dp->config);
      for (l = names; l != NULL; l = g_list_next (l))
        {
          if (!g_str_equal (l->data, "spawn") && !g_str_equal (l->data, "environ"))
            json_object_set_member (config, l->data, json_object_dup_member (dp->config, l->data));
        }

      if (key.argv)
        json_object_set_array_member (config, "spawn", strv_to_json_array (key.argv));

      if (key.environ)
        json_object_set_array_member (config, "environ", strv_to_json_array (key.environ));

      peer = cockpit_peer_new (self->transport, config);
      g_hash_table_insert (dp->peers, g_memdup (&key, sizeof (DynamicKey)), peer);
    }
  else
    {
      g_strfreev (key.argv);
      g_strfreev (key.environ);
    }

  if (config)
    json_object_unref (config);

  g_list_free (names);
  return cockpit_peer_handle (peer, channel, options, data);
}
예제 #14
0
파일: alert.c 프로젝트: j-o-h-n-g/yaarf
void
snarf_alert_add_text_field(snarf_alert_t *alert,
                           const char    *name,
                           const char    *value)
{

// Add text field to body
JsonNode *node;

JsonObject * rootobj = json_node_get_object (alert->msg);
JsonObject * bodyobj = json_object_get_object_member(rootobj,"body");

JsonNode * stringnode = json_node_alloc();
stringnode=json_node_init_string(stringnode,value);
json_object_set_member(bodyobj,name,stringnode);

}
예제 #15
0
파일: alert.c 프로젝트: j-o-h-n-g/yaarf
void
snarf_alert_add_ip_field_v4(snarf_alert_t *alert,
                            const char    *name,
                            uint32_t       value)
{
// Add IP field to body
JsonNode *node;

JsonObject * rootobj = json_node_get_object (alert->msg);
JsonObject * bodyobj = json_object_get_object_member(rootobj,"body");

JsonNode * stringnode = json_node_alloc();

struct in_addr ip;
ip.s_addr=htonl(value);
stringnode=json_node_init_string(stringnode,inet_ntoa(ip));
json_object_set_member(bodyobj,name,stringnode);

}
static JsonNode *trg_prefs_get_value_inner(JsonObject * obj,
                                           const gchar * key, int type,
                                           int flags)
{
    if (json_object_has_member(obj, key)) {
        if ((flags & TRG_PREFS_REPLACENODE))
            json_object_remove_member(obj, key);
        else
            return json_object_get_member(obj, key);
    }

    if ((flags & TRG_PREFS_NEWNODE) || (flags & TRG_PREFS_REPLACENODE)) {
        JsonNode *newNode = json_node_new(type);
        json_object_set_member(obj, key, newNode);
        return newNode;
    }

    return NULL;
}
예제 #17
0
static void
glide_document_json_obj_set_slides (GlideDocument *document, JsonObject *obj)
{
  JsonNode *node = json_node_new (JSON_NODE_ARRAY);
  JsonArray *array = json_array_new ();
  GList *s;
  
  for (s = document->priv->slides; s; s = s->next)
    {
      JsonNode *n;
      GlideSlide *slide = (GlideSlide *)(s->data);
      
      n = glide_actor_serialize (GLIDE_ACTOR (slide));
      json_array_add_element (array, n);
    }
  json_node_take_array (node, array);

  json_object_set_member (obj, "slides", node);
  
}
예제 #18
0
파일: dp_js.c 프로젝트: dplatform/dupin
static void
js_obj (JSContextRef ctx, JSObjectRef object, JsonObject * obj)
{
  JSPropertyNameArrayRef props;
  gsize nprops, i;

  props = JSObjectCopyPropertyNames (ctx, object);
  nprops = JSPropertyNameArrayGetCount (props);

  for (i = 0; i < nprops; i++)
    {
      JSStringRef prop = JSPropertyNameArrayGetNameAtIndex (props, i);

      JSValueRef value;
      JsonNode *node;
      gchar *p;

      p = js_string (prop);
g_message("Getting obj property %s\n",p);

      value = JSObjectGetProperty (ctx, object, prop, NULL);
      js_value (ctx, value, &node);

g_message("Got obj property %s\n",p);

debug_print_json_node ( "js_obj(): ", node );

g_message("obj=%p\n",obj);

      json_object_set_member (obj, p, node);

      g_free (p);
      JSStringRelease (prop);
    }
g_message("Done get properties\n");

  JSPropertyNameArrayRelease (props);
}
예제 #19
0
파일: alert.c 프로젝트: j-o-h-n-g/yaarf
void
snarf_alert_add_flow_v4(snarf_alert_t *alert,
                        uint64_t stime, uint32_t elapsed,
                        uint32_t sip, uint32_t dip,
                        uint16_t sport, uint16_t dport,
                        uint8_t proto,
                        uint32_t packets, uint32_t bytes,
                        uint8_t flags, uint8_t flags_initial,
                        uint16_t application_id,
                        char *sensor_name,
                        char *flow_class, char *flow_type)
{

JsonBuilder *builder;

// Populate the envelope
builder=json_builder_new();
json_builder_begin_array(builder);
json_builder_begin_object(builder);

json_builder_set_member_name(builder,"stime");
char jsontime[32];
time_t sectime = stime / (1000*1000);
struct tm gmt;
gmtime_r(&sectime,&gmt);
strftime(jsontime,21,"%Y-%m-%dT%H:%M:%SZ",&gmt);
json_builder_add_string_value(builder,jsontime);

json_builder_set_member_name(builder,"elapsed");
json_builder_add_int_value(builder,elapsed);

struct in_addr ip;

ip.s_addr=htonl(sip);
json_builder_set_member_name(builder,"sip");
json_builder_add_string_value(builder,inet_ntoa(ip));

ip.s_addr=htonl(dip);
json_builder_set_member_name(builder,"dip");
json_builder_add_string_value(builder,inet_ntoa(ip));

json_builder_set_member_name(builder,"sport");
json_builder_add_int_value(builder,sport);

json_builder_set_member_name(builder,"dport");
json_builder_add_int_value(builder,dport);

json_builder_set_member_name(builder,"proto");
json_builder_add_int_value(builder,proto);

json_builder_set_member_name(builder,"packets");
json_builder_add_int_value(builder,packets);

json_builder_set_member_name(builder,"bytes");
json_builder_add_int_value(builder,bytes);

// flags
json_builder_set_member_name(builder,"flags");
GString *flag_string = snarf_alert_flags_to_string(flags);
json_builder_add_string_value(builder,flag_string->str);
g_string_free(flag_string,TRUE);


// flags initial
json_builder_set_member_name(builder,"flags_initial");
GString *flag_initial_string = snarf_alert_flags_to_string(flags_initial);
json_builder_add_string_value(builder,flag_initial_string->str);
//g_print(flag_initial_string);
g_string_free(flag_initial_string,TRUE);

// application id
json_builder_set_member_name(builder,"application_id");
json_builder_add_int_value(builder,application_id);

// sensor
json_builder_set_member_name(builder,"sensor_name");
json_builder_add_string_value(builder,sensor_name);

// flow class
json_builder_set_member_name(builder,"flow_class");
json_builder_add_string_value(builder,flow_class);

// flow type
json_builder_set_member_name(builder,"flow_type");
json_builder_add_string_value(builder,flow_type);

json_builder_end_object(builder);
json_builder_end_array(builder);
//json_builder_end_object(builder);

JsonNode *root = json_builder_get_root(builder);

JsonObject * rootobj = json_node_get_object (alert->msg);
JsonObject * bodyobj = json_object_get_object_member(rootobj,"body");
json_object_set_member(bodyobj,"flow",root);

}
예제 #20
0
static guint
json_parse_object (JsonParser   *parser,
                   JsonScanner  *scanner,
                   JsonNode    **node)
{
  JsonParserPrivate *priv = parser->priv;
  JsonObject *object;
  JsonNode *old_current;
  guint token;

  old_current = priv->current_node;
  priv->current_node = json_node_new (JSON_NODE_OBJECT);

  object = json_object_new ();

  token = json_scanner_get_next_token (scanner);
  g_assert (token == G_TOKEN_LEFT_CURLY);

  g_signal_emit (parser, parser_signals[OBJECT_START], 0);

  while (token != G_TOKEN_RIGHT_CURLY)
    {
      guint next_token = json_scanner_peek_next_token (scanner);
      JsonNode *member = NULL;
      gchar *name;

      /* we need to abort here because empty objects do not
       * have member names
       */
      if (next_token == G_TOKEN_RIGHT_CURLY)
        break;

      /* parse the member's name */
      if (next_token != G_TOKEN_STRING)
        {
          json_object_unref (object);
          json_node_free (priv->current_node);
          priv->current_node = old_current;

          return G_TOKEN_STRING;
        }

      /* member name */
      token = json_scanner_get_next_token (scanner);
      name = g_strdup (scanner->value.v_string);

      /* a colon separates names from values */
      next_token = json_scanner_peek_next_token (scanner);
      if (next_token != ':')
        {
          g_free (name);
          json_object_unref (object);
          json_node_free (priv->current_node);
          priv->current_node = old_current;

          return ':';
        }

      /* we swallow the ':' */
      token = json_scanner_get_next_token (scanner);
      g_assert (token == ':');
      next_token = json_scanner_peek_next_token (scanner);

      /* parse the member's value */
      switch (next_token)
        {
        case G_TOKEN_LEFT_BRACE:
          token = json_parse_array (parser, scanner, &member);
          break;

        case G_TOKEN_LEFT_CURLY:
          token = json_parse_object (parser, scanner, &member);
          break;

        case G_TOKEN_INT:
        case G_TOKEN_FLOAT:
        case G_TOKEN_STRING:
        case '-':
        case JSON_TOKEN_TRUE:
        case JSON_TOKEN_FALSE:
        case JSON_TOKEN_NULL:
          token = json_scanner_get_next_token (scanner);
          token = json_parse_value (parser, scanner, token, &member);
          break;

        default:
          /* once a member name is defined we need a value */
          token = G_TOKEN_SYMBOL;
          break;
        }

      if (token != G_TOKEN_NONE || member == NULL)
        {
          /* the json_parse_* functions will have set the error code */
          g_free (name);
          json_object_unref (object);
          json_node_free (priv->current_node);
          priv->current_node = old_current;

          return token;
        }

      next_token = json_scanner_peek_next_token (scanner);
      if (next_token == G_TOKEN_COMMA)
        {
          token = json_scanner_get_next_token (scanner);
          next_token = json_scanner_peek_next_token (scanner);

          /* look for trailing commas */
          if (next_token == G_TOKEN_RIGHT_CURLY)
            {
              json_object_unref (object);
              json_node_free (member);
              json_node_free (priv->current_node);
              priv->current_node = old_current;

              return G_TOKEN_RIGHT_BRACE;
            }
        }
      else if (next_token == G_TOKEN_STRING)
        {
          json_object_unref (object);
          json_node_free (member);
          json_node_free (priv->current_node);
          priv->current_node = old_current;

          return G_TOKEN_COMMA;
        }

      json_node_set_parent (member, priv->current_node);
      json_object_set_member (object, name, member);

      g_signal_emit (parser, parser_signals[OBJECT_MEMBER], 0,
                     object,
                     name);

      g_free (name);

      token = next_token;
    }

  json_scanner_get_next_token (scanner);

  json_node_take_object (priv->current_node, object);
  json_node_set_parent (priv->current_node, old_current);

  g_signal_emit (parser, parser_signals[OBJECT_END], 0, object);

  if (node != NULL && *node == NULL)
    *node = priv->current_node;

  priv->current_node = old_current;

  return G_TOKEN_NONE;
}
예제 #21
0
JsonNode*
cometd_new_handshake_message(const cometd* h)
{
                                                                                                                                                                                      
  gint64 seed = ++(h->conn->msg_id_seed);
  

  /////////////////Data Concatenation/////////////                                                                                                                                                                                               

  JsonObject* dataObject = json_object_new();
  JsonNode*   dataNode = json_node_new(JSON_NODE_OBJECT);
  JsonNode*   dataRoot = json_node_init_object(dataNode, dataObject);

  dataObject = json_node_get_object(dataRoot);

  json_object_set_string_member(dataObject, "login", "test2");
  json_object_set_string_member(dataObject, "password", "password");

  ////////////////Data Concatenation////////////                                                                                                                                                                                                 

  /////////////////Auth/////////////////                                                                                                                                                                                                         

  // I begin from the most inner JsonObject of my Json File                                                                                                                                                                                      

  //here i initialize my Root JsonNode with an object in it and a JsonObject to be able to get the object from the JsonNode                                                                                                                      

  JsonObject* authObject = json_object_new();
  JsonNode*   authNode = json_node_new(JSON_NODE_OBJECT);
  JsonNode*   authRoot = json_node_init_object(authNode, authObject);

  // Here i retrieve the initialized JsonObject that is inside my JsonNode                                                                                                                                                                       
  authObject = json_node_get_object(authRoot);

  // And here some few insertion of strings in the object                                                                                                                                                                                        
  json_object_set_string_member(authObject, "action", "authenticate");
  json_object_set_string_member(authObject, "type", "GmY-HuzW.KZyH.simple");
  json_object_set_string_member(authObject, "resource", "zetapushTuto");
  json_object_set_member(authObject, "data", dataRoot);

  ///////////////Auth/////////////////                                                                                                                                                                                                           



  //////////////First Concatenation : Authentication///////////////                                                                                                                                                                              
  //Here i make the authentication of my first JsonObject with a upper membrane.                                                                                                                                                                 

  JsonObject *extMembrane = json_object_new();
  JsonNode   *contactMembrane = json_node_new(JSON_NODE_OBJECT);
  JsonNode   *secondRootMembrane = json_node_init_object(contactMembrane, extMembrane);

  extMembrane = json_node_get_object(secondRootMembrane);

  json_object_set_member(extMembrane, "authentication", authRoot);
  /////////////First Concatenation////////////////                                                                                                                                                                                               

  ////////////Second Concatenation : Ext///////////////                                                                                                                                                                                          
  // Here i finnaly concatenante my last JsonObject and encapsulate the overall file inside the root JsonNode                                                                                                                                    
  JsonObject *rootObjectMembrane = json_object_new();
  JsonNode   *initRootMembrane = json_node_new(JSON_NODE_OBJECT);
  JsonNode   *rootMembrane = json_node_init_object(initRootMembrane, rootObjectMembrane);

   rootObjectMembrane = json_node_get_object(rootMembrane);

   json_object_set_member(rootObjectMembrane, "ext", secondRootMembrane);


  // I still needs to create a object under Ext JsonNode, then an JsonArray to supportedConnectionTypes                                                                                                                                          
  //Then add the advice object with "timeout" and "interval"                                                                                                                                                                                     

  json_object_set_int_member(rootObjectMembrane, "id", seed);
  json_object_set_string_member(rootObjectMembrane, "version", "1.0");
  json_object_set_string_member(rootObjectMembrane, "minimumVersion", "1.0");
  json_object_set_string_member(rootObjectMembrane, "channel", "/meta/handshake");

  JsonArray* json_transports = json_array_new();
  GList* entry = h->config->transports;
  while (entry){
    cometd_transport* t = entry->data;
    json_array_add_string_element(json_transports, t->name);
    entry = g_list_next(entry);
}

  //json_array_add_string_element(json_transports, "long-polling");
  json_object_set_array_member(rootObjectMembrane, "supportedConnectionTypes", json_transports);

  //////////Advice////////                                                                                                                                                                                                                       
  JsonObject *adviceMembrane = json_object_new();
  JsonNode   *adviceNodeMembrane = json_node_new(JSON_NODE_OBJECT);
  JsonNode   *adviceRootMembrane = json_node_init_object(adviceNodeMembrane, adviceMembrane);
  gint64 interval = 0;
  gint64 timeout = 60000;
  adviceMembrane = json_node_get_object(adviceRootMembrane);
  json_object_set_int_member(adviceMembrane, "timeout", timeout);
  json_object_set_int_member(adviceMembrane, "interval", interval);
  json_object_set_member(rootObjectMembrane, "advice", adviceRootMembrane);

  /////////Advice////////                                                                                                                                                                                                                        



   ////////////Second Concatenation//////////////
  
  // call extensions with message - TODO: implement extensions first
  //json_node_take_object(root, obj);
  return rootMembrane;
}
예제 #22
0
파일: util.c 프로젝트: hean01/castio
JsonNode *
js_util_tojsonnode(js_State *state, int idx)
{
  const char *s;
  JsonNode *node;
  JsonNode *tmp;
  JsonObject *object;
  JsonArray *array;
  unsigned int i, length;

  node = json_node_alloc();

  if (js_isstring(state, idx))
  {
    json_node_init_string(node, js_tostring(state, idx));
  }

  else if (js_isnumber(state, idx))
  {
    json_node_init_int(node, js_tointeger(state, idx));
  }

  else if (js_isboolean(state, idx))
  {
    json_node_init_boolean(node, js_toboolean(state, idx));
  }

  else if (js_isarray(state, idx))
  {
    length = js_getlength(state, idx);

    array = json_array_new();
    json_node_init_array(node, array);

    for (i = 0; i < length; i++)
    {
      js_getindex(state, idx, i);
      tmp = js_util_tojsonnode(state, -1);

      if (tmp)
	json_array_add_element(array, tmp);

      js_pop(state, 1);
    }

    json_array_unref(array);
  }

  else if (js_isobject(state, idx))
  {
    object = json_object_new();
    json_node_init_object(node, object);

    js_pushiterator(state, idx, 1);
    while((s = js_nextiterator(state, -1)) != NULL)
    {
      if (idx > 0) js_getproperty(state, idx, s);
      else js_getproperty(state, idx - 1, s);

      tmp = js_util_tojsonnode(state, -1);
      if (tmp)
	json_object_set_member(object, s, tmp);

      js_pop(state, 1);
    }

    js_pop(state, 1);

    json_object_unref(object);
  }

  else
  {
    json_node_free(node);
    return NULL;
  }

  return node;
}
예제 #23
0
파일: dp_js.c 프로젝트: dplatform/dupin
gint
main (gint argc, gchar ** argv)
{
  JSGlobalContextRef ctx;

  JSStringRef str;
  JSObjectRef func;
  JSValueRef result;
  JSValueRef exception = NULL;

  JsonObject *obj;
  JsonNode *node;

  g_type_init();

  gchar *buffer;

  if (argc != 2)
    {
      printf ("Usage: %s <script>\n", argv[0]);
      return 1;
    }

  ctx = JSGlobalContextCreate (NULL);

  str = JSStringCreateWithUTF8CString ("emitIntermediate");
  func = JSObjectMakeFunctionWithCallback (ctx, str, js_emitIntermediate);
  JSObjectSetProperty (ctx, JSContextGetGlobalObject (ctx), str, func,
		       kJSPropertyAttributeNone, NULL);
  JSStringRelease (str);

  str = JSStringCreateWithUTF8CString ("emit");
  func = JSObjectMakeFunctionWithCallback (ctx, str, js_emit);
  JSObjectSetProperty (ctx, JSContextGetGlobalObject (ctx), str, func,
		       kJSPropertyAttributeNone, NULL);
  JSStringRelease (str);

  str = JSStringCreateWithUTF8CString (argv[1]);
  result = JSEvaluateScript (ctx, str, NULL, NULL, 0, &exception);
  JSStringRelease (str);

  obj = json_object_new ();

  if (!result || exception)
    {
      js_value (ctx, exception, &node);

      json_object_set_member (obj, "error", node);

      json_object_set_boolean_member (obj, "status", FALSE);

      JSGlobalContextRelease (ctx);
    }
  else
    {
      json_object_set_boolean_member (obj, "status", TRUE);
    }

  JsonNode *node1 = json_node_new (JSON_NODE_OBJECT);

  if (node1 == NULL)
    {
      json_object_unref (obj);
      JSGlobalContextRelease (ctx);
      return 1;
    }

  json_node_set_object (node1, obj);

  JsonGenerator *gen = json_generator_new();

  if (gen == NULL)
    {
      json_node_free (node1);
      JSGlobalContextRelease (ctx);
      return 1;
    }

  json_generator_set_root (gen, node1 );
  buffer = json_generator_to_data (gen,NULL);

  if (buffer == NULL)
    {
      json_node_free (node1);
      JSGlobalContextRelease (ctx);
      return 1;
    }

  json_node_free (node1);

  puts (buffer);
  g_free (buffer);

  JSGlobalContextRelease (ctx);
  return 0;
}
static gboolean
process_includes (RpmOstreeTreeComposeContext  *self,
                  GFile             *treefile_path,
                  guint              depth,
                  JsonObject        *root,
                  GCancellable      *cancellable,
                  GError           **error)
{
  gboolean ret = FALSE;
  const char *include_path;
  const guint maxdepth = 50;

  if (depth > maxdepth)
    {
      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
                   "Exceeded maximum include depth of %u", maxdepth);
      goto out;
    }

  {
    g_autoptr(GFile) parent = g_file_get_parent (treefile_path);
    gboolean existed = FALSE;
    if (self->treefile_context_dirs->len > 0)
      {
        GFile *prev = self->treefile_context_dirs->pdata[self->treefile_context_dirs->len-1];
        if (g_file_equal (parent, prev))
          existed = TRUE;
      }
    if (!existed)
      {
        g_ptr_array_add (self->treefile_context_dirs, parent);
        parent = NULL; /* Transfer ownership */
      }
  }

  if (!_rpmostree_jsonutil_object_get_optional_string_member (root, "include", &include_path, error))
    goto out;
                                          
  if (include_path)
    {
      g_autoptr(GFile) treefile_dirpath = g_file_get_parent (treefile_path);
      g_autoptr(GFile) parent_path = g_file_resolve_relative_path (treefile_dirpath, include_path);
      glnx_unref_object JsonParser *parent_parser = json_parser_new ();
      JsonNode *parent_rootval;
      JsonObject *parent_root;
      GList *members;
      GList *iter;

      if (!json_parser_load_from_file (parent_parser,
                                       gs_file_get_path_cached (parent_path),
                                       error))
        goto out;

      parent_rootval = json_parser_get_root (parent_parser);
      if (!JSON_NODE_HOLDS_OBJECT (parent_rootval))
        {
          g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
                       "Treefile root is not an object");
          goto out;
        }
      parent_root = json_node_get_object (parent_rootval);
      
      if (!process_includes (self, parent_path, depth + 1, parent_root,
                             cancellable, error))
        goto out;
                             
      members = json_object_get_members (parent_root);
      for (iter = members; iter; iter = iter->next)
        {
          const char *name = iter->data;
          JsonNode *parent_val = json_object_get_member (parent_root, name);
          JsonNode *val = json_object_get_member (root, name);

          g_assert (parent_val);

          if (!val)
            json_object_set_member (root, name, json_node_copy (parent_val));
          else
            {
              JsonNodeType parent_type =
                json_node_get_node_type (parent_val);
              JsonNodeType child_type =
                json_node_get_node_type (val);
              if (parent_type != child_type)
                {
                  g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
                               "Conflicting element type of '%s'",
                               name);
                  goto out;
                }
              if (child_type == JSON_NODE_ARRAY)
                {
                  JsonArray *parent_array = json_node_get_array (parent_val);
                  JsonArray *child_array = json_node_get_array (val);
                  JsonArray *new_child = json_array_new ();
                  guint i, len;

                  len = json_array_get_length (parent_array);
                  for (i = 0; i < len; i++)
                    json_array_add_element (new_child, json_node_copy (json_array_get_element (parent_array, i)));
                  len = json_array_get_length (child_array);
                  for (i = 0; i < len; i++)
                    json_array_add_element (new_child, json_node_copy (json_array_get_element (child_array, i)));
                  
                  json_object_set_array_member (root, name, new_child);
                }
            }
        }

      json_object_remove_member (root, "include");
    }

  ret = TRUE;
 out:
  return ret;
}
예제 #25
0
static JsonNode *
builder_options_serialize_property (JsonSerializable *serializable,
                                    const gchar      *property_name,
                                    const GValue     *value,
                                    GParamSpec       *pspec)
{
  if (strcmp (property_name, "arch") == 0)
    {
      BuilderOptions *self = BUILDER_OPTIONS (serializable);
      JsonNode *retval = NULL;

      if (self->arch && g_hash_table_size (self->arch) > 0)
        {
          JsonObject *object;
          GHashTableIter iter;
          gpointer key, value;

          object = json_object_new ();

          g_hash_table_iter_init (&iter, self->arch);
          while (g_hash_table_iter_next (&iter, &key, &value))
            {
              JsonNode *child = json_gobject_serialize (value);
              json_object_set_member (object, (char *)key, child);
            }

          retval = json_node_init_object (json_node_alloc (), object);
          json_object_unref (object);
        }

      return retval;
    }
  else if (strcmp (property_name, "env") == 0)
    {
      BuilderOptions *self = BUILDER_OPTIONS (serializable);
      JsonNode *retval = NULL;

      if (self->env && g_strv_length (self->env) > 0)
        {
          JsonObject *object;
          int i;

          object = json_object_new ();

          for (i = 0; self->env[i] != NULL; i++)
            {
              JsonNode *str = json_node_new (JSON_NODE_VALUE);
              const char *equal;
              g_autofree char *member = NULL;

              equal = strchr (self->env[i], '=');
              if (equal)
                {
                  json_node_set_string (str, equal + 1);
                  member = g_strndup (self->env[i], equal - self->env[i]);
                }
              else
                {
                  json_node_set_string (str, "");
                  member = g_strdup (self->env[i]);
                }

              json_object_set_member (object, member, str);
            }

          retval = json_node_init_object (json_node_alloc (), object);
          json_object_unref (object);
        }

      return retval;
    }
  else
    return json_serializable_default_serialize_property (serializable,
                                                         property_name,
                                                         value,
                                                         pspec);
}
예제 #26
0
static guint
json_parse_object (JsonParser   *parser,
                   JsonScanner  *scanner,
                   JsonNode    **node)
{
  JsonParserPrivate *priv = parser->priv;
  JsonObject *object;
  JsonNode *old_current;
  guint token;

  old_current = priv->current_node;
  priv->current_node = json_node_init_object (json_node_alloc (), NULL);

  object = json_object_new ();

  token = json_scanner_get_next_token (scanner);
  g_assert (token == G_TOKEN_LEFT_CURLY);

  g_signal_emit (parser, parser_signals[OBJECT_START], 0);

  while (token != G_TOKEN_RIGHT_CURLY)
    {
      guint next_token = json_scanner_peek_next_token (scanner);
      JsonNode *member = NULL;
      gchar *name;

      /* we need to abort here because empty objects do not
       * have member names
       */
      if (next_token == G_TOKEN_RIGHT_CURLY)
        break;

      /* parse the member's name */
      if (next_token != G_TOKEN_STRING)
        {
          JSON_NOTE (PARSER, "Missing object member name");

          priv->error_code = JSON_PARSER_ERROR_INVALID_BAREWORD;

          json_object_unref (object);
          json_node_free (priv->current_node);
          priv->current_node = old_current;

          return G_TOKEN_STRING;
        }

      /* member name */
      token = json_scanner_get_next_token (scanner);
      name = g_strdup (scanner->value.v_string);
      if (name == NULL || *name == '\0')
        {
          JSON_NOTE (PARSER, "Empty object member name");

          priv->error_code = JSON_PARSER_ERROR_EMPTY_MEMBER_NAME;

          json_object_unref (object);
          json_node_free (priv->current_node);
          priv->current_node = old_current;

          return G_TOKEN_STRING;
        }

      JSON_NOTE (PARSER, "Object member '%s'", name);

      /* a colon separates names from values */
      next_token = json_scanner_peek_next_token (scanner);
      if (next_token != ':')
        {
          JSON_NOTE (PARSER, "Missing object member name separator");

          priv->error_code = JSON_PARSER_ERROR_MISSING_COLON;

          g_free (name);
          json_object_unref (object);
          json_node_free (priv->current_node);
          priv->current_node = old_current;

          return ':';
        }

      /* we swallow the ':' */
      token = json_scanner_get_next_token (scanner);
      g_assert (token == ':');
      next_token = json_scanner_peek_next_token (scanner);

      /* parse the member's value */
      switch (next_token)
        {
        case G_TOKEN_LEFT_BRACE:
          JSON_NOTE (PARSER, "Nested array at member %s", name);
          token = json_parse_array (parser, scanner, &member);
          break;

        case G_TOKEN_LEFT_CURLY:
          JSON_NOTE (PARSER, "Nested object at member %s", name);
          token = json_parse_object (parser, scanner, &member);
          break;

        default:
          /* once a member name is defined we need a value */
          token = json_scanner_get_next_token (scanner);
          token = json_parse_value (parser, scanner, token, &member);
          break;
        }

      if (token != G_TOKEN_NONE || member == NULL)
        {
          /* the json_parse_* functions will have set the error code */
          g_free (name);
          json_object_unref (object);
          json_node_free (priv->current_node);
          priv->current_node = old_current;

          return token;
        }

      next_token = json_scanner_peek_next_token (scanner);
      if (next_token == G_TOKEN_COMMA)
        {
          token = json_scanner_get_next_token (scanner);
          next_token = json_scanner_peek_next_token (scanner);

          /* look for trailing commas */
          if (next_token == G_TOKEN_RIGHT_CURLY)
            {
              priv->error_code = JSON_PARSER_ERROR_TRAILING_COMMA;

              json_object_unref (object);
              json_node_free (member);
              json_node_free (priv->current_node);
              priv->current_node = old_current;

              return G_TOKEN_RIGHT_BRACE;
            }
        }
      else if (next_token == G_TOKEN_STRING)
        {
          priv->error_code = JSON_PARSER_ERROR_MISSING_COMMA;

          json_object_unref (object);
          json_node_free (member);
          json_node_free (priv->current_node);
          priv->current_node = old_current;

          return G_TOKEN_COMMA;
        }

      JSON_NOTE (PARSER, "Object member '%s' completed", name);
      json_node_set_parent (member, priv->current_node);
      json_object_set_member (object, name, member);

      g_signal_emit (parser, parser_signals[OBJECT_MEMBER], 0,
                     object,
                     name);

      g_free (name);

      token = next_token;
    }

  json_scanner_get_next_token (scanner);

  json_node_take_object (priv->current_node, object);
  json_node_set_parent (priv->current_node, old_current);

  g_signal_emit (parser, parser_signals[OBJECT_END], 0, object);

  if (node != NULL && *node == NULL)
    *node = priv->current_node;

  priv->current_node = old_current;

  return G_TOKEN_NONE;
}