/* 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; }
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; }
/** * 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; }
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; }
/** * 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); }
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()); } }
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; }
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; }
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); }
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; }
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; }
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; }
/* 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; }
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; }
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; }
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; }