コード例 #1
0
ファイル: mod.c プロジェクト: AirspeedTelecom/freeradius
/* map free radius attribute to user defined json element name */
int mod_attribute_to_element(const char *name, json_object *map, void *buf) {
	json_object *jval;  /* json object values */

	/* clear buffer */
	memset((char *) buf, 0, MAX_KEY_SIZE);

	/* attempt to map attribute */
	if (json_object_object_get_ex(map, name, &jval)) {
		int length;     /* json value length */
		/* get value length */
		length = json_object_get_string_len(jval);
		/* check buffer size */
		if (length > MAX_KEY_SIZE -1) {
			/* oops ... this value is bigger than our buffer ... error out */
			ERROR("rlm_couchbase: json map value larger than MAX_KEY_SIZE - %d", MAX_KEY_SIZE);
			/* return fail */
			return -1;
		} else {
			/* copy string value to buffer */
			strncpy(buf, json_object_get_string(jval), length);
			/* return good */
			return 0;
		}
	}

	/* debugging */
	DEBUG("rlm_couchbase: skipping attribute with no map entry - %s", name);

	/* default return */
	return -1;
}
コード例 #2
0
ファイル: server.c プロジェクト: nejstastnejsistene/DotBot
static void set_grid(struct per_session_data *data, const char *buf) {
    int row, col;
    json_object *json_grid = json_tokener_parse(buf);
    if (json_object_get_type(json_grid) != json_type_array) {
        return;
    }
    if (json_object_array_length(json_grid) != NUM_ROWS) {
        return;
    }
    for (row = 0; row < NUM_ROWS; row++) {
        json_object *json_row = json_object_array_get_idx(json_grid, row);
        const char *row_buf;
        if (json_object_get_string_len(json_row) != NUM_COLS) {
            return;
        }
        row_buf = json_object_get_string(json_row);
        for (col = 0; col < NUM_COLS; col++) {
            color_t color;
            switch (row_buf[col]) {
                case 'R': color = RED;    break;
                case 'Y': color = YELLOW; break;
                case 'G': color = GREEN;  break;
                case 'B': color = BLUE;   break;
                case 'V': color = VIOLET; break;
                default: return;
            }
            data->grid[col] = SET_COLUMN_COLOR(data->grid[col], row, color);
        }
    }
    data->new_game = 0;
}
コード例 #3
0
/**
 * Retrieve the authentication token and service catalog from a now-complete Keystone JSON response,
 * and store them in the Keystone context structure for later use.
 */
static enum keystone_error
process_keystone_json(keystone_context_t *context, struct json_object *response)
{
	struct json_object *access, *token, *id;

	if (context->pvt.debug) {
		json_object_to_file_ext("/dev/stderr", response, JSON_C_TO_STRING_PRETTY);
	}
	if (!json_object_is_type(response, json_type_object)) {
		context->keystone_error("response is not an object", KSERR_PARSE);
		return KSERR_PARSE; /* Not the expected JSON object */
	}
	/* Everything is in an "access" sub-object */
	if (!json_object_object_get_ex(response, "access", &access)) {
		context->keystone_error("response lacks 'access' key", KSERR_PARSE);
		return KSERR_PARSE; /* Lacking the expected key */
	}
	if (!json_object_is_type(access, json_type_object)) {
		context->keystone_error("response.access is not an object", KSERR_PARSE);
		return KSERR_PARSE; /* Not the expected JSON object */
	}
	/* Service catalog */
	if (!json_object_object_get_ex(access, "serviceCatalog", &context->pvt.services)) {
		context->keystone_error("response.access lacks 'serviceCatalog' key", KSERR_PARSE);
		return KSERR_PARSE;
	}
	if (!json_object_is_type(context->pvt.services, json_type_array)) {
		context->keystone_error("response.access.serviceCatalog not an array", KSERR_PARSE);
		return KSERR_PARSE;
	}
	/* Authentication token */
	if (!json_object_object_get_ex(access, "token", &token)) {
		context->keystone_error("reponse.access lacks 'token' key", KSERR_PARSE);
		return KSERR_PARSE; /* Lacking the expected key */
	}
	if (!json_object_is_type(token, json_type_object)) {
		context->keystone_error("response.access.token is not an object", KSERR_PARSE);
		return KSERR_PARSE; /* Not the expected JSON object */
	}
	if (!json_object_object_get_ex(token, "id", &id)) {
		context->keystone_error("response.access.token lacks 'id' key", KSERR_PARSE);
		return KSERR_PARSE; /* Lacking the expected key */
	}
	if (!json_object_is_type(id, json_type_string)) {
		context->keystone_error("response.access.token.id is not a string", KSERR_PARSE);
		return KSERR_PARSE; /* Not the expected JSON string */
	}
	context->pvt.auth_token = context->allocator(
		context->pvt.auth_token,
		json_object_get_string_len(id)
		+ 1 /* '\0' */
	);
	if (NULL == context->pvt.auth_token) {
		return KSERR_PARSE; /* Allocation failed */
	}
	strcpy(context->pvt.auth_token, json_object_get_string(id));

	return KSERR_SUCCESS;
}
コード例 #4
0
ファイル: json.c プロジェクト: ZRouter/ZRouter
int pv_get_json (struct sip_msg* msg,  pv_param_t* pvp, pv_value_t* val)
{

	pv_json_t * var ;
	json_t * obj;
	json_name * id = (json_name *) pvp->pvn.u.dname;
	UNUSED(id);


	if( expand_tag_list( msg, ((json_name *)pvp->pvn.u.dname)->tags ) < 0)
	{
		LM_ERR("Cannot expand variables in path\n");
		return pv_get_null( msg, pvp, val);
	}


	var = get_pv_json(pvp);

	if( var == NULL )
	{
		/* this is not an error - we simply came across a json spec
		 * pointing a json var which was never set/init */
		LM_DBG("Variable named:%.*s not found\n",id->name.len,id->name.s);
		return pv_get_null( msg, pvp, val);
	}

	obj = get_object(var, pvp, NULL, 0);
	memset(val, 0, sizeof(pv_value_t));

	if( obj == NULL )
		return pv_get_null( msg, pvp, val);

	if( json_object_is_type(obj, json_type_int) )
	{
		val->rs.s = sint2str(json_object_get_int(obj), &val->rs.len);
		val->ri = json_object_get_int(obj);;
		val->flags |= PV_VAL_INT|PV_TYPE_INT|PV_VAL_STR;

	}
	else if( json_object_is_type(obj, json_type_string))
	{
		val->flags = PV_VAL_STR;
		val->rs.s = (char*)json_object_get_string( obj );
#if JSON_LIB_VERSION >= 10
		val->rs.len = json_object_get_string_len( obj );
#else
		val->rs.len = strlen(val->rs.s);
#endif
	} else {
		val->flags = PV_VAL_STR;
		val->rs.s = (char*)json_object_to_json_string( obj );
		val->rs.len = strlen(val->rs.s);
	}

	return 0;
}
コード例 #5
0
/**
 *  Get the string length at a certain index
 *  @param  index
 *  @return string
 */
size_t Array::strlen(int index) const
{
    // get the value at this location
    json_object *value = json_object_array_get_idx(_json, index);

    // in case our type isn't string we return an empty string
    if (json_object_get_type(value) != json_type_string) return 0;

    // get the string length
    return json_object_get_string_len(value);
}
コード例 #6
0
ファイル: jsonc_parser.cpp プロジェクト: Debug-Orz/hhvm
Variant json_object_to_variant(json_object *new_obj, const bool assoc,
                               const bool stable_maps, const bool collections) {
    json_type type;
    int64_t i64;

    if (!new_obj) {
        return Variant(Variant::NullInit());
    }

    type = json_object_get_type(new_obj);
    switch (type) {
    case json_type_double:
        return Variant(json_object_get_double(new_obj));

    case json_type_string:
        return Variant(String(json_object_get_string(new_obj),
                              json_object_get_string_len(new_obj),
                              CopyString));

    case json_type_int:
        i64 = json_object_get_int64(new_obj);
        if (i64==INT64_MAX || i64==INT64_MIN) {
            // php notice: integer overflow detected
        }
        return Variant(i64);

    case json_type_boolean:
        if (json_object_get_boolean(new_obj)) {
            return Variant(true);
        } else {
            return Variant(false);
        }

    case json_type_null:
        return Variant(Variant::NullInit());

    case json_type_array:
        return json_type_array_to_variant(new_obj, assoc, stable_maps,
                                          collections);

    case json_type_object:
        return json_type_object_to_variant(new_obj, assoc, stable_maps,
                                           collections);

    default:
        // warning type <type> not yet implemented
        return Variant(Variant::NullInit());
    }
}
コード例 #7
0
static void GenStat(Stat* s, json_object* v) {
    switch (json_object_get_type(v)) {
    case json_type_object:
        {
            json_object_object_foreach(v, key, val) {
                GenStat(s, val);
                s->stringCount++;
                s->stringLength += strlen(key);
                s->memberCount++;
            }
            s->objectCount++;
        }
        break;

    case json_type_array:
        for (int i = 0; i < json_object_array_length(v); i++)
            GenStat(s, json_object_array_get_idx(v, i));
        s->elementCount += json_object_array_length(v);
        s->arrayCount++;
        break;

    case json_type_string:
        s->stringCount++;
        s->stringLength += json_object_get_string_len(v);
        break;

    case json_type_int:
    case json_type_double:
        s->numberCount++;
        break;

    case json_type_boolean:
        if (json_object_get_boolean(v))
            s->trueCount++;
        else
            s->falseCount++;
        break;

        break;

    case json_type_null:
        s->nullCount++;
        break;
    }
コード例 #8
0
ファイル: bbproxy-proxy.c プロジェクト: BwRy/rcs-anonymizer
int command_forward(json_object *json, BIO *bio_src)
{
   int r = -1, len = 0;
   json_object *params = NULL, *body = NULL;
   char *address = NULL, *cookie = NULL, *data = NULL, buf[100 * 1024];
   BIO *bio_conn = NULL;

   do {
      if(!(params = json_object_object_get(json, "params"))) break;
      if(!(address = (char *)json_object_get_string(json_object_object_get(params, "address")))) break;
      logme(LOGMSG_DEBUG, "FORWARD -> address: %s", address);
      if(!(cookie = (char *)json_object_get_string(json_object_object_get(params, "cookie")))) break;
      logme(LOGMSG_DEBUG, "FORWARD -> cookie: %s", cookie);

      if(!(body = json_object_object_get(json, "body"))) break;
      if(!(data = (char *)json_object_get_string(body))) break;
      if(!(len = json_object_get_string_len(body))) break;
      logme(LOGMSG_DEBUG, "FORWARD -> data: %d bytes", len);

      if(!(bio_conn = BIO_new_connect(address))) break;
      if(BIO_do_connect(bio_conn) <= 0) { logme(LOGMSG_ERROR, "Unable to connect to %s", address); break; }
      if(BIO_printf(bio_conn, "POST / HTTP/1.0\r\n" \
                              "Host: %s\r\n" \
                              "Accept: */" "*\r\n" \
                              "Cookie: %s\r\n" \
                              "Content-Length: %d\r\n" \
                              "Content-Type: application/octet-stream\r\n" \
                              "Connection: close\r\n" \
                              "\r\n",
                              address, cookie, len) <= 0) break;
      if(BIO_write(bio_conn, data, len) != len) break;
      (void)BIO_flush(bio_conn);

      while((len = BIO_read(bio_conn, buf, sizeof(buf))) > 0) if(BIO_write(bio_src, buf, len) != len) break;
      if(len != 0) break;

      r = 0;
   } while(0);
   if(bio_conn) BIO_free(bio_conn);

   return r;
}
コード例 #9
0
ファイル: CommonObj.cpp プロジェクト: imace/nnt
void LoginOutputData::parse(json_object* obj) {
    if (obj == NULL)
        return;

    json_object* node;

    node = json_object_object_get(obj, "accountid");
    this->accountid = json_object_get_int(node);
    node = json_object_object_get(obj, "nickname");
    this->nickname.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "gender");
    this->gender = json_object_get_int(node);
    node = json_object_object_get(obj, "birthday");
    this->birthday.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "rank");
    this->rank.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "introduction");
    this->introduction.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "points");
    this->points = json_object_get_int(node);
    node = json_object_object_get(obj, "impactpower");
    this->impactpower = json_object_get_int(node);
    node = json_object_object_get(obj, "listenpower");
    this->listenpower = json_object_get_int(node);
    node = json_object_object_get(obj, "avatar");
    this->avatar.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "voice");
    this->voice.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "voicetime");
    this->voicetime = json_object_get_int(node);
    node = json_object_object_get(obj, "viptypeid");
    this->viptypeid = json_object_get_int(node);
    node = json_object_object_get(obj, "vipstarttime");
    this->vipstarttime.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "vipexpiretime");
    this->vipexpiretime.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "created");
    this->created.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "status");
    this->status = json_object_get_int(node);
    node = json_object_object_get(obj, "kind");
    this->kind = json_object_get_int(node);
    node = json_object_object_get(obj, "gold");
    this->gold = json_object_get_int(node);
    node = json_object_object_get(obj, "nativeplace");
    this->nativeplace.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "occupation");
    this->occupation.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "dialect");
    this->dialect.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "devicetoken");
    this->devicetoken.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "ipowerlevel");
    this->ipowerlevel = json_object_get_int(node);
    node = json_object_object_get(obj, "lpowerlevel");
    this->lpowerlevel = json_object_get_int(node);
    node = json_object_object_get(obj, "isaskpermit");
    this->isaskpermit = json_object_get_int(node);
    node = json_object_object_get(obj, "isagainstpermit");
    this->isagainstpermit = json_object_get_int(node);
    node = json_object_object_get(obj, "giftcount");
    this->giftcount = json_object_get_int(node);
    node = json_object_object_get(obj, "pickuppoints");
    this->pickuppoints = json_object_get_int(node);
    node = json_object_object_get(obj, "levelconfig");
    node = json_object_object_get(obj, "isquickuser");
    this->isquickuser = json_object_get_int(node);
    node = json_object_object_get(obj, "isplisttester");
    this->isplisttester = json_object_get_int(node);
    node = json_object_object_get(obj, "clientversion");
    this->clientversion.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "updateurl");
    this->updateurl.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "updatedesc");
    this->updatedesc.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "restoredefaultplist");
    this->restoredefaultplist = json_object_get_int(node);
    node = json_object_object_get(obj, "bindplatformlist");
    array_list* array =  json_object_get_array(obj);
    if (array) {
        int len = array_list_length(array);
        for (int i = 0; i < len; i++) {
            json_object *obj = (json_object*)array_list_get_idx(array, i);
            if (!obj)
                continue;

            json_type type = json_object_get_type(obj);
            if (type == json_type_object) {
                //* tmp = new ();
                //tmp.parse(obj);
                //bindplatformlist.push_back(tmp);
            } else if (type == json_type_int) {
                //bindplatformlist.push_back(itoa(json_object_get_int(obj)));
            } else if (type == json_type_double) {
                //bindplatformlist.push_back(json_object_get_double(obj));
            } else if (type == json_type_string) {
                string str;
                bindplatformlist.push_back(str.assign(json_object_get_string(obj), json_object_get_string_len(obj)));
            }
        }
    }
    node = json_object_object_get(obj, "username");
    this->username.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "platform");
    this->platform.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "askpoints1");
    this->askpoints1 = json_object_get_int(node);
    node = json_object_object_get(obj, "askpoints2");
    this->askpoints2 = json_object_get_int(node);
    node = json_object_object_get(obj, "background");
    this->background.assign(json_object_get_string(node), json_object_get_string_len(node));
    node = json_object_object_get(obj, "pushmessage");
    this->pushmessage = json_object_get_int(node);
    node = json_object_object_get(obj, "lbs");
    this->lbs = json_object_get_int(node);
    node = json_object_object_get(obj, "weixinur");
    this->weixinur = json_object_get_int(node);
    node = json_object_object_get(obj, "activitystatus");
    this->activitystatus = json_object_get_int(node);
    node = json_object_object_get(obj, "shareversions");
    this->shareversions = json_object_get_int(node);
    node = json_object_object_get(obj, "isnewdialect");
    this->isnewdialect = json_object_get_int(node);
    node = json_object_object_get(obj, "vcolor");
    this->vcolor = json_object_get_int(node);
    node = json_object_object_get(obj, "isready");
    this->isready = json_object_get_int(node);
    node = json_object_object_get(obj, "tabidx");
    this->tabidx = json_object_get_int(node);


}
コード例 #10
0
ファイル: json.c プロジェクト: OpenSIPS/opensips
int pv_get_json_ext(struct sip_msg* msg,  pv_param_t* pvp, pv_value_t* val, int flags)
{

	pv_json_t * var ;
	json_t * obj;
	json_name * id = (json_name *) pvp->pvn.u.dname;
	UNUSED(id);

	if( expand_tag_list( msg, ((json_name *)pvp->pvn.u.dname)->tags ) < 0)
	{
		LM_ERR("Cannot expand variables in path\n");
		return pv_get_null( msg, pvp, val);
	}


	var = get_pv_json(pvp);

	if( var == NULL )
	{
		/* this is not an error - we simply came across a json spec
		 * pointing a json var which was never set/init */
		LM_DBG("Variable named:%.*s not found\n",id->name.len,id->name.s);
		return pv_get_null( msg, pvp, val);
	}

	obj = get_object(var, pvp, NULL, 0, 0);

	memset(val, 0, sizeof(pv_value_t));

	if( obj == NULL )
		return pv_get_null( msg, pvp, val);

	if (pvp->pvi.type == PV_IDX_INT) {
		if (pv_json_iterate(&obj, pvp, id, val) < 0) {
			LM_DBG("Failed to iterate\n");
			return pv_get_null(msg, pvp, val);
		}

		if (val->flags == PV_VAL_STR || val->flags == PV_VAL_NULL)
			/* val is set */
			return 0;
		/* else we got an object */
	} else if (pvp->pvi.type == PV_IDX_ALL) {
		LM_ERR("\"[*]\" index only supported in for each statement\n");
		return pv_get_null(msg, pvp, val);
	}

	if( json_object_is_type(obj, json_type_int) )
	{
		val->rs.s = sint2str(json_object_get_int(obj), &val->rs.len);
		val->ri = json_object_get_int(obj);;
		val->flags |= PV_VAL_INT|PV_TYPE_INT|PV_VAL_STR;

	}
	else if( json_object_is_type(obj, json_type_string))
	{
		val->flags = PV_VAL_STR;
		val->rs.s = (char*)json_object_get_string( obj );
#if JSON_C_VERSION_NUM >= JSON_C_VERSION_010
		val->rs.len = json_object_get_string_len( obj );
#else
		val->rs.len = strlen(val->rs.s);
#endif
	} else {
		val->flags = PV_VAL_STR;
		val->rs.s = (char*)json_object_to_json_string_ext( obj, flags);
		val->rs.len = strlen(val->rs.s);
	}

	return 0;
}
コード例 #11
0
ファイル: tokeniser2.c プロジェクト: Achal-Aggarwal/hibbub
int main(int argc, char **argv)
{
	struct json_object *json;
	struct array_list *tests;
	struct lh_entry *entry;
	char *key;
	struct json_object *val;
	int i;
	context ctx;

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

	json = json_object_from_file(argv[1]);
	assert(!is_error(json));

	assert(strcmp((char *) ((json_object_get_object(json)->head)->k),
			"tests") == 0);

	/* Get array of tests */
	tests = json_object_get_array((struct json_object *)
			(json_object_get_object(json)->head)->v);

	for (i = 0; i < array_list_length(tests); i++) {
		/* Get test */
		struct json_object *test =
			(struct json_object *) array_list_get_idx(tests, i);

		ctx.last_start_tag = NULL;
		ctx.content_model = NULL;
		ctx.process_cdata = false;

		/* Extract settings */
		for (entry = json_object_get_object(test)->head; entry;
				entry = entry->next) {
			key = (char *) entry->k;
			val = (struct json_object *) entry->v;

			if (strcmp(key, "description") == 0) {
				printf("Test: %s\n",
					json_object_get_string(val));
			} else if (strcmp(key, "input") == 0) {
				ctx.input = (const uint8_t *)
					json_object_get_string(val);
				ctx.input_len =	json_object_get_string_len(val);
			} else if (strcmp(key, "output") == 0) {
				ctx.output = json_object_get_array(val);
				ctx.output_index = 0;
				ctx.char_off = 0;
			} else if (strcmp(key, "lastStartTag") == 0) {
				ctx.last_start_tag = (const char *)
						json_object_get_string(val);
			} else if (strcmp(key, "contentModelFlags") == 0) {
				ctx.content_model =
						json_object_get_array(val);
			} else if (strcmp(key, "processCDATA") == 0) {
				ctx.process_cdata =
					json_object_get_boolean(val);
			}
		}

		/* And run the test */
		run_test(&ctx);
	}

	json_object_put(json);

	printf("PASS\n");

	return 0;
}
コード例 #12
0
ファイル: tokeniser2.c プロジェクト: Achal-Aggarwal/hibbub
hubbub_error token_handler(const hubbub_token *token, void *pw)
{
	static const char *token_names[] = {
		"DOCTYPE", "StartTag", "EndTag",
		"Comment", "Character", "EOF"
	};
	size_t i;
	context *ctx = (context *) pw;
	struct json_object *obj = NULL;
	struct array_list *items;

	for (; ctx->output_index < array_list_length(ctx->output);
			ctx->output_index++) {
		/* Get object for index */
		obj = (struct json_object *)
				array_list_get_idx(ctx->output,
						ctx->output_index);

		/* If it's not a string, we've found the expected output */
		if (json_object_get_type(obj) != json_type_string)
			break;

		/* Otherwise, it must be a parse error */
		assert(strcmp(json_object_get_string(obj),
				 "ParseError") == 0);
	}

	/* If we've run off the end, this is an error -- the tokeniser has
	 * produced more tokens than expected. We allow for the generation
	 * of a terminating EOF token, however. */
	assert("too many tokens" &&
			(ctx->output_index < array_list_length(ctx->output) ||
			token->type == HUBBUB_TOKEN_EOF));

	/* Got a terminating EOF -- no error */
	if (ctx->output_index >= array_list_length(ctx->output))
		return HUBBUB_OK;

	/* Now increment the output index so we don't re-expect this token */
	ctx->output_index++;

	/* Expected output must be an array */
	assert(json_object_get_type(obj) == json_type_array);

	items = json_object_get_array(obj);

	printf("got %s: expected %s\n", token_names[token->type],
			json_object_get_string((struct json_object *)
				array_list_get_idx(items, 0)));

	/* Make sure we got the token we expected */
	assert(strcmp(token_names[token->type],
			json_object_get_string((struct json_object *)
				array_list_get_idx(items, 0))) == 0);

	switch (token->type) {
	case HUBBUB_TOKEN_DOCTYPE:
	{
		const char *expname = json_object_get_string(
				array_list_get_idx(items, 1));
		const char *exppub = json_object_get_string(
				array_list_get_idx(items, 2));
		const char *expsys = json_object_get_string(
				array_list_get_idx(items, 3));
		bool expquirks = !json_object_get_boolean(
				array_list_get_idx(items, 4));
		const char *gotname = (const char *)token->data.doctype.name.ptr;
		const char *gotpub, *gotsys;

		printf("'%.*s' %sids:\n",
				(int) token->data.doctype.name.len,
				gotname,
				token->data.doctype.force_quirks ?
						"(force-quirks) " : "");

		if (token->data.doctype.public_missing) {
			gotpub = NULL;
			printf("\tpublic: missing\n");
		} else {
			gotpub = (const char *) token->data.doctype.public_id.ptr;
			printf("\tpublic: '%.*s' (%d)\n",
				(int) token->data.doctype.public_id.len,
				gotpub,
				(int) token->data.doctype.public_id.len);
		}

		if (token->data.doctype.system_missing) {
			gotsys = NULL;
			printf("\tsystem: missing\n");
		} else {
			gotsys = (const char *) token->data.doctype.system_id.ptr;
			printf("\tsystem: '%.*s' (%d)\n",
				(int) token->data.doctype.system_id.len,
				gotsys,
				(int) token->data.doctype.system_id.len);
		}

		assert(token->data.doctype.name.len == strlen(expname));
		assert(strncmp(gotname, expname, strlen(expname)) == 0);

		assert((exppub == NULL) ==
				(token->data.doctype.public_missing == true));
		if (exppub) {
			assert(token->data.doctype.public_id.len == strlen(exppub));
			assert(strncmp(gotpub, exppub, strlen(exppub)) == 0);
		}

		assert((expsys == NULL) ==
				(token->data.doctype.system_missing == true));
		if (gotsys) {
			assert(token->data.doctype.system_id.len == strlen(expsys));
			assert(strncmp(gotsys, expsys, strlen(expsys)) == 0);
		}

		assert(expquirks == token->data.doctype.force_quirks);
	}
		break;
	case HUBBUB_TOKEN_START_TAG:
	{
		const char *expname = json_object_get_string(
				array_list_get_idx(items, 1));
		struct lh_entry *expattrs = json_object_get_object(
				array_list_get_idx(items, 2))->head;
		bool self_closing = json_object_get_boolean(
				array_list_get_idx(items, 3));

		const char *tagname = (const char *)
				token->data.tag.name.ptr;

		printf("expected: '%s' %s\n",
				expname,
				(self_closing) ? "(self-closing) " : "");

		printf("     got: '%.*s' %s\n",
				(int) token->data.tag.name.len,
				tagname,
				(token->data.tag.self_closing) ?
						"(self-closing) " : "");

		if (token->data.tag.n_attributes > 0) {
			printf("attributes:\n");
		}

		assert(token->data.tag.name.len == strlen(expname));
		assert(strncmp(tagname, expname, strlen(expname)) == 0);

		assert((token->data.tag.n_attributes == 0) ==
				(expattrs == NULL));

		assert(self_closing == token->data.tag.self_closing);

		for (i = 0; i < token->data.tag.n_attributes; i++) {
			char *expname = (char *) expattrs->k;
			const char *expval = json_object_get_string(
					(struct json_object *) expattrs->v);
			const char *gotname = (const char *)
				token->data.tag.attributes[i].name.ptr;
			size_t namelen =
				token->data.tag.attributes[i].name.len;
			const char *gotval = (const char *)
				token->data.tag.attributes[i].value.ptr;
			size_t vallen =
				token->data.tag.attributes[i].value.len;

			printf("\t'%.*s' = '%.*s'\n",
					(int) namelen, gotname,
					(int) vallen, gotval);

			assert(namelen == strlen(expname));
			assert(strncmp(gotname, expname,
						strlen(expname)) == 0);
			assert(vallen == strlen(expval));
			assert(strncmp(gotval, expval, strlen(expval)) == 0);

			expattrs = expattrs->next;
		}

		assert(expattrs == NULL);
	}
		break;
	case HUBBUB_TOKEN_END_TAG:
	{
		const char *expname = json_object_get_string(
				array_list_get_idx(items, 1));
		const char *tagname = (const char *)
				token->data.tag.name.ptr;

		printf("'%.*s' %s\n",
				(int) token->data.tag.name.len,
				tagname,
				(token->data.tag.n_attributes > 0) ?
						"attributes:" : "");

		assert(token->data.tag.name.len == strlen(expname));
		assert(strncmp(tagname, expname, strlen(expname)) == 0);
	}
		break;
	case HUBBUB_TOKEN_COMMENT:
	{
		const char *expstr = json_object_get_string(
				array_list_get_idx(items, 1));
		const char *gotstr = (const char *)
				token->data.comment.ptr;

		printf("expected: '%s'\n", expstr);
		printf("     got: '%.*s'\n",
				(int) token->data.comment.len, gotstr);

		assert(token->data.comment.len == strlen(expstr));
		assert(strncmp(gotstr, expstr, strlen(expstr)) == 0);
	}
		break;
	case HUBBUB_TOKEN_CHARACTER:
	{
		int expstrlen = json_object_get_string_len(
				array_list_get_idx(items, 1));
		const char *expstr =json_object_get_string( 
				array_list_get_idx(items, 1));
		const char *gotstr = (const char *)
				token->data.character.ptr;
		size_t len = min(token->data.character.len,
				expstrlen - ctx->char_off);

		printf("expected: '%.*s'\n", (int) len, expstr + ctx->char_off);
		printf("     got: '%.*s'\n", 
				(int) token->data.character.len, gotstr);

		assert(memcmp(gotstr, expstr + ctx->char_off, len) == 0);

		if (len < token->data.character.len) {
			/* Expected token only contained part of the data
			 * Calculate how much is left, then try again with
			 * the next expected token */
			hubbub_token t;

			t.type = HUBBUB_TOKEN_CHARACTER;
			t.data.character.ptr += len;
			t.data.character.len -= len;

			ctx->char_off = 0;

			token_handler(&t, pw);
		} else if (strlen(expstr + ctx->char_off) >
				token->data.character.len) {
			/* Tokeniser output only contained part of the data
			 * in the expected token; calculate the offset into
			 * the token and process the remainder next time */
			ctx->char_off += len;
			ctx->output_index--;
		} else {
			/* Exact match - clear offset */
			ctx->char_off = 0;
		}
	}
		break;
	case HUBBUB_TOKEN_EOF:
		printf("\n");
		break;
	}

	return HUBBUB_OK;
}
コード例 #13
0
/* write accounting data to couchbase */
static rlm_rcode_t CC_HINT(nonnull) mod_accounting(void *instance, REQUEST *request) {
	rlm_couchbase_t *inst = instance;   /* our module instance */
	void *handle = NULL;                /* connection pool handle */
	VALUE_PAIR *vp;                     /* radius value pair linked list */
	char dockey[MAX_KEY_SIZE];          /* our document key */
	char document[MAX_VALUE_SIZE];      /* our document body */
	char element[MAX_KEY_SIZE];         /* mapped radius attribute to element name */
	int status = 0;                     /* account status type */
	int docfound = 0;                   /* document found toggle */
	lcb_error_t cb_error = LCB_SUCCESS; /* couchbase error holder */

	/* assert packet as not null */
	rad_assert(request->packet != NULL);

	/* sanity check */
	if ((vp = pairfind(request->packet->vps, PW_ACCT_STATUS_TYPE, 0, TAG_ANY)) == NULL) {
		/* log debug */
		RDEBUG("could not find status type in packet");
		/* return */
		return RLM_MODULE_NOOP;
	}

	/* set status */
	status = vp->vp_integer;

	/* acknowledge the request but take no action */
	if (status == PW_STATUS_ACCOUNTING_ON || status == PW_STATUS_ACCOUNTING_OFF) {
		/* log debug */
		RDEBUG("handling accounting on/off request without action");
		/* return */
		return RLM_MODULE_OK;
	}

	/* get handle */
	handle = fr_connection_get(inst->pool);

	/* check handle */
	if (!handle) return RLM_MODULE_FAIL;

	/* set handle pointer */
	rlm_couchbase_handle_t *handle_t = handle;

	/* set couchbase instance */
	lcb_t cb_inst = handle_t->handle;

	/* set cookie */
	cookie_t *cookie = handle_t->cookie;

	/* check cookie */
	if (cookie) {
		/* clear cookie */
		memset(cookie, 0, sizeof(cookie_t));
	} else {
		/* log error */
		RERROR("cookie not usable - possibly not allocated");
		/* free connection */
		if (handle) {
			fr_connection_release(inst->pool, handle);
		}
		/* return */
		return RLM_MODULE_FAIL;
	}

	/* attempt to build document key */
	if (radius_xlat(dockey, sizeof(dockey), request, inst->acct_key, NULL, NULL) < 0) {
		/* log error */
		RERROR("could not find accounting key attribute (%s) in packet", inst->acct_key);
		/* release handle */
		if (handle) {
			fr_connection_release(inst->pool, handle);
		}
		/* return */
		return RLM_MODULE_NOOP;
	}

	/* init cookie error status */
	cookie->jerr = json_tokener_success;

	/* attempt to fetch document */
	cb_error = couchbase_get_key(cb_inst, cookie, dockey);

	/* check error */
	if (cb_error != LCB_SUCCESS || cookie->jerr != json_tokener_success) {
		/* log error */
		RERROR("failed to execute get request or parse returned json object");
		/* free json object */
		if (cookie->jobj) {
			json_object_put(cookie->jobj);
		}
	} else {
		/* check cookie json object */
		if (cookie->jobj != NULL) {
			/* set doc found */
			docfound = 1;
			/* debugging */
			RDEBUG("parsed json body from couchbase: %s", json_object_to_json_string(cookie->jobj));
		}
	}

	/* start json document if needed */
	if (docfound != 1) {
		/* debugging */
		RDEBUG("document not found - creating new json document");
		/* create new json object */
		cookie->jobj = json_object_new_object();
		/* set 'docType' element for new document */
		json_object_object_add(cookie->jobj, "docType", json_object_new_string(inst->doctype));
		/* set start and stop times ... ensure we always have these elements */
		json_object_object_add(cookie->jobj, "startTimestamp", json_object_new_string("null"));
		json_object_object_add(cookie->jobj, "stopTimestamp", json_object_new_string("null"));
	}

	/* status specific replacements for start/stop time */
	switch (status) {
		case PW_STATUS_START:
			/* add start time */
			if ((vp = pairfind(request->packet->vps, PW_EVENT_TIMESTAMP, 0, TAG_ANY)) != NULL) {
				/* add to json object */
				json_object_object_add(cookie->jobj, "startTimestamp", mod_value_pair_to_json_object(request, vp));
			}
		break;
		case PW_STATUS_STOP:
			/* add stop time */
			if ((vp = pairfind(request->packet->vps, PW_EVENT_TIMESTAMP, 0, TAG_ANY)) != NULL) {
				/* add to json object */
				json_object_object_add(cookie->jobj, "stopTimestamp", mod_value_pair_to_json_object(request, vp));
			}
			/* check start timestamp and adjust if needed */
			mod_ensure_start_timestamp(cookie->jobj, request->packet->vps);
		break;
		case PW_STATUS_ALIVE:
			/* check start timestamp and adjust if needed */
			mod_ensure_start_timestamp(cookie->jobj, request->packet->vps);
		break;
		default:
			/* we shouldn't get here - free json object */
			if (cookie->jobj) {
				json_object_put(cookie->jobj);
			}
			/* release our connection handle */
			if (handle) {
				fr_connection_release(inst->pool, handle);
			}
			/* return without doing anything */
			return RLM_MODULE_NOOP;
	}

	/* loop through pairs and add to json document */
	for (vp = request->packet->vps; vp; vp = vp->next) {
		/* map attribute to element */
		if (mod_attribute_to_element(vp->da->name, inst->map, &element) == 0) {
			/* debug */
			RDEBUG("mapped attribute %s => %s", vp->da->name, element);
			/* add to json object with mapped name */
			json_object_object_add(cookie->jobj, element, mod_value_pair_to_json_object(request, vp));
		}
	}

	/* make sure we have enough room in our document buffer */
	if ((unsigned int) json_object_get_string_len(cookie->jobj) > sizeof(document) - 1) {
		/* this isn't good */
		RERROR("could not write json document - insufficient buffer space");
		/* free json output */
		if (cookie->jobj) {
			json_object_put(cookie->jobj);
		}
		/* release handle */
		if (handle) {
			fr_connection_release(inst->pool, handle);
		}
		/* return */
		return RLM_MODULE_FAIL;
	} else {
		/* copy json string to document */
		strlcpy(document, json_object_to_json_string(cookie->jobj), sizeof(document));
		/* free json output */
		if (cookie->jobj) {
			json_object_put(cookie->jobj);
		}
	}

	/* debugging */
	RDEBUG("setting '%s' => '%s'", dockey, document);

	/* store document/key in couchbase */
	cb_error = couchbase_set_key(cb_inst, dockey, document, inst->expire);

	/* check return */
	if (cb_error != LCB_SUCCESS) {
		RERROR("failed to store document (%s): %s (0x%x)", dockey, lcb_strerror(NULL, cb_error), cb_error);
	}

	/* release handle */
	if (handle) {
		fr_connection_release(inst->pool, handle);
	}

	/* return */
	return RLM_MODULE_OK;
}
コード例 #14
0
int
read_handler(int fd)
{
    char rbuf[MAXPKTSIZE] = "";
    int readbytes;
    json_object *jobj;
    int ctype;
    int is_reg_pkt = 0;
    int numtoread;

#ifdef WWDEBUG
    fprintf(stderr, "About to read on FD - %d, type - %d\n", fd, sock_data[fd].ctype);
#endif

    // First check if there is any remaining payload from previous
    // transmission for this socket and decide the # of bytes to read.
    if ((sock_data[fd].r_payloadlen > 0) && (sock_data[fd].r_payloadlen < MAXPKTSIZE - 1)) {
        numtoread = sock_data[fd].r_payloadlen;
    } else {
        numtoread = MAXPKTSIZE - 1;
    }

    if ((readbytes = recv(fd, rbuf, numtoread, 0)) == -1) {
        perror("recv");
        FD_CLR(fd, &rfds);
        close(fd);
        return 0;
    }
    rbuf[readbytes] = '\0';
    //fprintf(stderr, "Rx a string of size %d - %s\n",readbytes,rbuf);
    //fprintf(stderr, "Rx a string of size %d \n",readbytes);

    // Is this required ?
    if (strlen(rbuf) == 0) {
#ifdef WWDEBUG
        fprintf(stderr, "\nSeems like the remote client connected\n");
        fprintf(stderr, "to this socket has closed its connection\n");
        fprintf(stderr, "So I'm closing the socket\n");
#endif
        FD_CLR(fd, &rfds);
        close(fd);
        return 0;
    }
    // If the read buffer is from pending transmission append to accrualbuf
    // Or else treat it as a new packet.
    if (sock_data[fd].r_payloadlen > 0) {
        strcat(sock_data[fd].accrual_buf, rbuf);
        sock_data[fd].r_payloadlen = sock_data[fd].r_payloadlen - readbytes;
    } else {
        apphdr *app_h = (apphdr *) rbuf;
        appdata *app_d = (appdata *) (rbuf + sizeof(apphdr));

        //printf("Len of the payload - %d, %s\n", app_h->len,app_d->payload);

        // plus 1 to store the NULL char
        sock_data[fd].accrual_buf = (char *) malloc(app_h->len + 1);
        strcpy(sock_data[fd].accrual_buf, app_d->payload);
        sock_data[fd].r_payloadlen = app_h->len - strlen(sock_data[fd].accrual_buf);
        //printf("strlen(sock_data[%d].accrual_buf) = %d\n", fd, strlen(sock_data[fd].accrual_buf));
    }

    if (sock_data[fd].r_payloadlen > 0) {
        //Still has more reading to do
        //printf("r_payloadlen = %d\n", sock_data[fd].r_payloadlen);
        return (0);
    }
#ifdef WWDEBUG
    printf("Done reading totally, now processing the received data packet\n");
#endif

/*
  if(sock_data[fd].ctype == UNKNOWN) {
	int ctype;
	ctype = get_int_from_json(json_tokener_parse(sock_data[fd].accrual_buf),"CONN_TYPE");
	if(ctype == -1) {
	  printf("Not able to determine type\n");
	} else {
	  sock_data[fd].ctype = ctype;
	  //printf("Conn type - %d on sock - %d\n",ctype, fd);
	}
   } else if(sock_data[fd].ctype == COLLECTOR) {
*/

    jobj = json_tokener_parse(sock_data[fd].accrual_buf);
    ctype = get_int_from_json(jobj, "CONN_TYPE");
    if (ctype == -1) {
#ifdef WWDEBUG
        printf("Either not able to determine type or not a registration packet\n");
#endif
    } else {
        sock_data[fd].ctype = ctype;
        is_reg_pkt = 1;
        //printf("Conn type - %d on sock - %d\n",ctype, fd);
    }

    if (is_reg_pkt != 1) {
        if (sock_data[fd].ctype == COLLECTOR) {
            apphdr *app_h = (apphdr *) rbuf;

            //printf("%s\n",sock_data[fd].accrual_buf);
            update_dbase(app_h->timestamp, app_h->nodename, jobj);
        } else if (sock_data[fd].ctype == APPLICATION) {
            const char *sqlite_cmd;
            size_t cmd_len = 0;
            json_object *json_sqlite_cmd;

            json_sqlite_cmd = json_object_object_get(jobj, "sqlite_cmd");
            if (json_sqlite_cmd) {
                sqlite_cmd = json_object_get_string(json_sqlite_cmd);
                cmd_len = json_object_get_string_len(json_sqlite_cmd);
            }

            sock_data[fd].sqlite_cmd = malloc(MAX_SQL_SIZE);
            if (cmd_len) {
                char sql_stmt[] = "SELECT nodename,jsonblob FROM " SQLITE_DB_TB1NAME " LEFT JOIN " SQLITE_DB_TB2NAME " ON "
                    SQLITE_DB_TB1NAME ".rowid = " SQLITE_DB_TB2NAME ".blobid WHERE ";

                /* FIXME */
                strcpy(sock_data[fd].sqlite_cmd, sql_stmt);
                strcat(sock_data[fd].sqlite_cmd, sqlite_cmd);
            } else {
                // App sent an empty SQL command so we need to return all JSONs we have
                strcpy(sock_data[fd].sqlite_cmd, "SELECT nodename,jsonblob FROM " SQLITE_DB_TB1NAME);
            }
        }
    }
    json_object_put(jobj);

    if (sock_data[fd].accrual_buf != NULL) {
        free(sock_data[fd].accrual_buf);
        sock_data[fd].accrual_buf = NULL;
    }
    FD_CLR(fd, &rfds);
    FD_SET(fd, &wfds);
    return 0;
}
コード例 #15
0
ファイル: properties.c プロジェクト: liquanqing/RGBLED_Text
OSStatus _property_write_create_response(struct mico_service_t *service_table, 
                                    char *key, json_object *val,
                                    json_object *out_write_obj, json_object *out_err_prop_obj)
{
  OSStatus err = kUnknownErr;
  int iid = 0;
  int service_index = 0;
  int property_index = 0;
  int ret = 0;
  
  int int_value = 0;
  float float_value = 0;
  bool boolean_value = false;
  const char *set_string = NULL;
  int set_string_len = 0;
  
  require_action(service_table, exit, err = kParamErr);
  require_action(key, exit, err = kParamErr);
  require_action(val, exit, err = kParamErr);
  require_action(out_write_obj, exit, err = kParamErr);
  require_action(out_err_prop_obj, exit, err = kParamErr);
  
  Str2Int((uint8_t*)key, &iid);
  //properties_log("properties write iid=%d.", iid);
  
  err = FindPropertyByIID(service_table, iid, &service_index, &property_index);
  require_noerr(err, exit);
  
  if( MICO_PROP_PERMS_WRITABLE (service_table[service_index].properties[property_index].perms) ){
    switch(service_table[service_index].properties[property_index].format){
    case MICO_PROP_TYPE_INT:{
      //properties_log("prop got: %s, iid=%d, value=%d", 
      //               service_table[service_index].properties[property_index].type, iid, 
      //               *((int*)service_table[service_index].properties[property_index].value));
      // property set (hardware operation)
      if(NULL != service_table[service_index].properties[property_index].set){
        int_value = json_object_get_int(val);
        ret = service_table[service_index].properties[property_index].set(&service_table[service_index].properties[property_index],
                                                                          service_table[service_index].properties[property_index].arg,
                                                                          (void*)&int_value, sizeof(int));
        if (0 == ret){  // set ok, update property value
          *((int*)service_table[service_index].properties[property_index].value) =  int_value;
          json_object_object_add(out_write_obj, key, json_object_new_int(int_value));
          err = kNoErr;
        }
        else{  // return write err status
          json_object_object_add(out_err_prop_obj, key, json_object_new_int(MICO_PROP_CODE_WRITE_FAILED));
          err = kWriteErr;
        }
      }
      else{ // no set func err
        json_object_object_add(out_err_prop_obj, key, json_object_new_int(MICO_PROP_CODE_NO_SET_FUNC));
        err = kWriteErr;
      }
      break;
    }
    case MICO_PROP_TYPE_FLOAT:{
      //properties_log("prop got: %s, iid=%d, value=%f", 
      //               service_table[service_index].properties[property_index].type, iid, 
      //               *((float*)service_table[service_index].properties[property_index].value));
      // property set(hardware operation)
      if(NULL != service_table[service_index].properties[property_index].set){
        float_value = json_object_get_double(val);
        ret = service_table[service_index].properties[property_index].set(&service_table[service_index].properties[property_index], 
                                                                          service_table[service_index].properties[property_index].arg,
                                                                          (void*)&float_value, sizeof(float));
        if (0 == ret){  // set ok, update property value
          *((float*)service_table[service_index].properties[property_index].value) = float_value;
          json_object_object_add(out_write_obj, key, json_object_new_double(float_value));
          err = kNoErr;
        }
        else{  // return write err status
          json_object_object_add(out_err_prop_obj, key, json_object_new_int(MICO_PROP_CODE_WRITE_FAILED));
          err = kWriteErr;
        }
      }
      else{ // no set func err
        json_object_object_add(out_err_prop_obj, key, json_object_new_int(MICO_PROP_CODE_NO_SET_FUNC));
        err = kWriteErr;
      }
      break;
    }
    case MICO_PROP_TYPE_STRING:{
      //properties_log("prop got: %s, iid=%d, value=%s", 
      //               service_table[service_index].properties[property_index].type, iid, 
      //               (char*)service_table[service_index].properties[property_index].value);
      
      // property set(hardware operation)
      if(NULL != service_table[service_index].properties[property_index].set){
        set_string = json_object_get_string(val);
        set_string_len = json_object_get_string_len(val);
        ret = service_table[service_index].properties[property_index].set(&service_table[service_index].properties[property_index], 
                                                                          service_table[service_index].properties[property_index].arg,
                                                                          (void*)set_string, set_string_len);
        if (0 == ret){  // set ok, update property value
          memset((char*)(service_table[service_index].properties[property_index].value), '\0', service_table[service_index].properties[property_index].maxStringLen);
          strncpy((char*)(service_table[service_index].properties[property_index].value), set_string, set_string_len);
          *(service_table[service_index].properties[property_index].value_len) = set_string_len;
          json_object_object_add(out_write_obj, key, json_object_new_string(set_string));
          err = kNoErr;
        }
        else{  // return write err status
          json_object_object_add(out_err_prop_obj, key, json_object_new_int(MICO_PROP_CODE_WRITE_FAILED));
          err = kWriteErr;
        }
      }
      else{ // no set func err
        json_object_object_add(out_err_prop_obj, key, json_object_new_int(MICO_PROP_CODE_NO_SET_FUNC));
        err = kWriteErr;
      }
      break;
    }
    case MICO_PROP_TYPE_BOOL:{
      //properties_log("prop got: %s, iid=%d, value=%d", 
      //               service_table[service_index].properties[property_index].type, iid, 
      //               *((bool*)service_table[service_index].properties[property_index].value));
      // property set(hardware operation)
      if(NULL != service_table[service_index].properties[property_index].set){
        boolean_value = json_object_get_boolean(val);
        ret = service_table[service_index].properties[property_index].set(&service_table[service_index].properties[property_index], 
                                                                          service_table[service_index].properties[property_index].arg,
                                                                          (void*)&boolean_value, sizeof(bool));
        if (0 == ret){  // set ok, update property value
          *((bool*)service_table[service_index].properties[property_index].value) = boolean_value;
          json_object_object_add(out_write_obj, key, json_object_new_boolean(boolean_value));
          err = kNoErr;
        }
        else{  // return write err status
          json_object_object_add(out_err_prop_obj, key, json_object_new_int(MICO_PROP_CODE_WRITE_FAILED));
          err = kWriteErr;
        }
      }
      else{ // no set func err
        json_object_object_add(out_err_prop_obj, key, json_object_new_int(MICO_PROP_CODE_NO_SET_FUNC));
        err = kWriteErr;
      }
      break;
    }
    default:
      properties_log("ERROR: Unsupported format!");
      json_object_object_add(out_err_prop_obj, key, json_object_new_int(MICO_PROP_CODE_DATA_FORMAT_ERR));
      err = kWriteErr;
      break;
    }
  }
  else{
    properties_log("ERROR: property is read only!");
    json_object_object_add(out_err_prop_obj, key, json_object_new_int(MICO_PROP_CODE_NOT_WRITABLE));
    err = kNotWritableErr;
  }
  
exit:
  if(kNotFoundErr == err){   // property not found
    properties_log("ERROR: property not found!");
    json_object_object_add(out_err_prop_obj, key, json_object_new_int(MICO_PROP_CODE_NOT_FOUND));
  }
  if(kRequestErr == err){   // service can not be set
    properties_log("ERROR: service can not be set!");
    json_object_object_add(out_err_prop_obj, key, json_object_new_int(MICO_PROP_CODE_NOT_SUPPORTED));
  }
  return err;
}
コード例 #16
0
ファイル: json_msg.c プロジェクト: Scribery/tlog
tlog_grc
tlog_json_msg_init(struct tlog_json_msg *msg, struct json_object *obj)
{
    struct json_object *o;
    int rc;
    const char *str;
    int end;
    int64_t session;
    int64_t id;
    int64_t pos;

    assert(msg != NULL);

    memset(msg, 0, sizeof(*msg));

    if (obj == NULL) {
        assert(tlog_json_msg_is_valid(msg));
        return true;
    }

#define GET_FIELD(_name_token, _type_token) \
    do {                                                            \
        if (!json_object_object_get_ex(obj, #_name_token, &o)) {    \
            return TLOG_RC_JSON_MSG_FIELD_MISSING;                  \
        }                                                           \
        if (json_object_get_type(o) != json_type_##_type_token) {   \
            return TLOG_RC_JSON_MSG_FIELD_INVALID_TYPE;             \
        }                                                           \
    } while (0)

#define GET_FIELD_ALT_TYPE2(_name_token, _type_token1, _type_token2) \
    do {                                                                \
        if (!json_object_object_get_ex(obj, #_name_token, &o)) {        \
            return TLOG_RC_JSON_MSG_FIELD_MISSING;                      \
        }                                                               \
        if (json_object_get_type(o) != json_type_##_type_token1 &&      \
            json_object_get_type(o) != json_type_##_type_token2) {      \
            return TLOG_RC_JSON_MSG_FIELD_INVALID_TYPE;                 \
        }                                                               \
    } while (0)

#define GET_OPTIONAL_FIELD(_name_token, _type_token) \
    do {                                                            \
        if (json_object_object_get_ex(obj, #_name_token, &o) &&     \
            json_object_get_type(o) != json_type_##_type_token) {   \
            return TLOG_RC_JSON_MSG_FIELD_INVALID_TYPE;             \
        }                                                           \
    } while (0)

    GET_FIELD_ALT_TYPE2(ver, string, int);
    /* NOTE: Converting number to string can fail */
    str = json_object_get_string(o);
    if (str == NULL) {
        return TLOG_GRC_ERRNO;
    }
    end = 0;
    rc = sscanf(str, "%u%n.%u%n",
                &msg->ver_major, &end, &msg->ver_minor, &end);
    if (rc < 1 || str[end] != '\0' || msg->ver_major > 2) {
        return TLOG_RC_JSON_MSG_FIELD_INVALID_VALUE_VER;
    }

    GET_FIELD(host, string);
    msg->host = json_object_get_string(o);

    GET_OPTIONAL_FIELD(rec, string);
    msg->rec = json_object_get_string(o);

    GET_FIELD(user, string);
    msg->user = json_object_get_string(o);

    GET_FIELD(term, string);
    msg->term = json_object_get_string(o);

    GET_FIELD(session, int);
    session = json_object_get_int64(o);
    if (session < 1 || session > UINT_MAX) {
        return TLOG_RC_JSON_MSG_FIELD_INVALID_VALUE_SESSION;
    }
    msg->session = (unsigned int)session;

    GET_FIELD(id, int);
    id = json_object_get_int64(o);
    if (id < 0
#if INT64_MAX > SIZE_MAX
        || id > (int64_t)SIZE_MAX
#endif
    ) {
        return TLOG_RC_JSON_MSG_FIELD_INVALID_VALUE_ID;
    }
    msg->id = (size_t)id;

    GET_FIELD(pos, int);
    pos = json_object_get_int64(o);
    if (pos < 0 || pos > TLOG_DELAY_MAX_MS_NUM) {
        return TLOG_RC_JSON_MSG_FIELD_INVALID_VALUE_POS;
    }
    msg->pos.tv_sec = pos / 1000;
    msg->pos.tv_nsec = pos % 1000 * 1000000;

    GET_FIELD(timing, string);
    msg->timing_ptr = json_object_get_string(o);

    GET_FIELD(in_txt, string);
    msg->in_txt_ptr = json_object_get_string(o);
    msg->in_txt_len = (size_t)json_object_get_string_len(o);

    GET_FIELD(in_bin, array);
    msg->in_bin_obj = o;
    msg->in_bin_pos = 0;

    GET_FIELD(out_txt, string);
    msg->out_txt_ptr = json_object_get_string(o);
    msg->out_txt_len = (size_t)json_object_get_string_len(o);

    GET_FIELD(out_bin, array);
    msg->out_bin_obj = o;
    msg->out_bin_pos = 0;

#undef GET_OPTIONAL_FIELD
#undef GET_FIELD_ALT_TYPE2
#undef GET_FIELD

    msg->obj = json_object_get(obj);
    assert(tlog_json_msg_is_valid(msg));
    return TLOG_RC_OK;
}