static json_t* decode_text(const char *text)
{
json_t *root = NULL;
json_error_t err;
if (!text)
goto exit;
root = json_loads(text, 0, &err);
if (!root) {
printf("json_loads() failed: %s\n", err.text);
goto exit;
}
if (!json_is_array(root)) {
printf("json_is_array() failed\n");
json_decref(root);
root = NULL;
}
exit:
return root;
}
static size_t
write_compact_objects(json_t* objects, json_t* header, stream_t* stream)
{
size_t bytes = 0;
size_t obj_bytes = 1;
size_t objs_bytes = 0;
int i;
assert(json_is_array(objects));
size_t array_length = json_array_size(objects);
for (i = 0; i < array_length && obj_bytes > 0; ++i) {
json_t* obj = json_array_get(objects, i);
obj_bytes = write_compact_object(obj, header, stream);
objs_bytes += obj_bytes;
}
if (i == array_length) {
bytes = objs_bytes;
}
return bytes;
}
static void parse_memcached(const json_t *obj)
{
json_t *servers;
if (!json_is_object(obj)) {
/* No memcached config so don't use it. */
memcached_free(srv.mc);
srv.mc = NULL;
return;
}
servers = json_object_get(obj, "servers");
if (json_is_array(servers)) {
unsigned int i, size = json_array_size(servers);
for (i = 0; i < size; i++) {
json_t *server_obj;
server_obj = json_array_get(servers, i);
parse_memcached_server(server_obj);
}
}
}
static w_query_expr *parse_list(w_query *query, json_t *term, bool allof)
{
struct w_expr_list *list;
size_t i;
/* don't allow "allof" on its own */
if (!json_is_array(term) || json_array_size(term) < 2) {
query->errmsg = strdup("must use [\"allof\", expr...]");
return NULL;
}
list = calloc(1, sizeof(*list));
if (!list) {
query->errmsg = strdup("out of memory");
return NULL;
}
list->allof = allof;
list->num = json_array_size(term) - 1;
list->exprs = calloc(list->num, sizeof(list->exprs[0]));
for (i = 0; i < list->num; i++) {
w_query_expr *parsed;
json_t *exp = json_array_get(term, i + 1);
parsed = w_query_expr_parse(query, exp);
if (!parsed) {
// other expression parser sets errmsg
dispose_list(list);
return NULL;
}
list->exprs[i] = parsed;
}
return w_query_expr_new(eval_list, dispose_list, list);
}
int load_cfg_svr(json_t *root, const char *key, nw_svr_cfg *cfg)
{
json_t *node = json_object_get(root, key);
if (!node || !json_is_object(node))
return -__LINE__;
json_t *bind = json_object_get(node, "bind");
if (!bind)
return -__LINE__;
if (json_is_string(bind)) {
cfg->bind_count = 1;
cfg->bind_arr = malloc(sizeof(nw_svr_bind));
if (nw_sock_cfg_parse(json_string_value(bind), &cfg->bind_arr[0].addr, &cfg->bind_arr[0].sock_type) < 0)
return -__LINE__;
} else if (json_is_array(bind)) {
cfg->bind_count = json_array_size(bind);
if (cfg->bind_count == 0)
return -__LINE__;
cfg->bind_arr = malloc(sizeof(nw_svr_bind) * cfg->bind_count);
for (uint32_t i = 0; i < cfg->bind_count; ++i) {
json_t *row = json_array_get(bind, i);
if (!json_is_string(row))
return -__LINE__;
if (nw_sock_cfg_parse(json_string_value(row), &cfg->bind_arr[i].addr, &cfg->bind_arr[i].sock_type) < 0)
return -__LINE__;
}
} else {
return -__LINE__;
}
ERR_RET(read_cfg_uint32(node, "max_pkg_size", &cfg->max_pkg_size, true, 0));
ERR_RET(read_cfg_uint32(node, "buf_limit", &cfg->buf_limit, false, 0));
ERR_RET(read_cfg_uint32(node, "read_mem", &cfg->read_mem, false, 0));
ERR_RET(read_cfg_uint32(node, "write_mem", &cfg->write_mem, false, 0));
return 0;
}
Frame* CreateFramesFromJSON(json_t* root)
{
if (!json_is_array(root))
{
SDL_LogError(
SDL_LOG_CATEGORY_APPLICATION,
"Frames is not JSON array"
);
return NULL;
}
Frame* frames = NULL;
Frame** frameIter = &frames;
uint32_t i = 0;
for (i = 0; i < json_array_size(root); i++)
{
json_t* frameNode;
frameNode = json_array_get(root, i);
if (!json_is_object(frameNode))
{
SDL_LogWarn(
SDL_LOG_CATEGORY_APPLICATION,
"Frame is invalid JSON type. Expected object.\n"
);
continue;
}
while (*frameIter != NULL)
frameIter = &((*frameIter)->next);
*frameIter = CreateFrameFromJSON(frameNode);
}
return frames;
}
int broker_msg_handle_subscribe(RemoteDSLink *link, json_t *req) {
broker_utils_send_closed_resp(link, req, NULL);
json_t *paths = json_object_get(req, "paths");
if (!json_is_array(paths)) {
return 1;
}
json_t *maxPermitJson = json_object_get(req, "permit");
PermissionLevel maxPermit = PERMISSION_CONFIG;
if (json_is_string(maxPermitJson)) {
maxPermit = permission_str_level(json_string_value(maxPermitJson));
}
if (maxPermit < PERMISSION_READ) {
return 0;
}
size_t index;
json_t *obj;
json_array_foreach(paths, index, obj) {
handle_subscribe(link, obj);
}
static TR_RP_REALM *tr_cfg_parse_comm_rps (TR_CFG *trc, json_t *jrps, TR_CFG_RC *rc)
{
TR_RP_REALM *rp = NULL;
TR_RP_REALM *temp_rp = NULL;
int i = 0;
if ((!trc) ||
(!jrps) ||
(!json_is_array(jrps))) {
if (rc)
*rc = TR_CFG_BAD_PARAMS;
return NULL;
}
for (i = (json_array_size(jrps)-1); i >= 0; i--) {
if (NULL == (temp_rp = talloc(trc, TR_RP_REALM))) {
tr_debug("tr_cfg_parse_comm_rps: Can't allocate memory for RP Realm.");
if (rc)
*rc = TR_CFG_NOMEM;
return NULL;
}
memset (temp_rp, 0, sizeof(TR_RP_REALM));
if (NULL == (temp_rp->realm_name = tr_new_name((char *)json_string_value(json_array_get(jrps, i))))) {
tr_debug("tr_cfg_parse_comm_rps: No memory for RP Realm Name.");
if (rc)
*rc = TR_CFG_NOMEM;
return NULL;
}
temp_rp->next = rp;
rp = temp_rp;
}
return rp;
}
// QUESTION: Should -3 be returned for !array, etc. ?
int_t portal_parse_sections(json_t *array, uint32_t *sections) {
uint64_t count;
chr_t *current;
int_t result = 1;
if (!array || !json_is_array(array) || !sections) {
return -1;
}
// Clear the output just in case something goes wrong.
*sections = 0;
if (!(count = json_array_size_d(array))) {
return 0;
}
for (uint64_t i = 0; i < count && result == 1; i++) {
if (!json_is_string(json_array_get_d(array, i)) || !(current = (chr_t *)json_string_value_d(json_array_get_d(array, i)))) {
return -1;
}
if (!st_cmp_ci_eq(NULLER(current), PLACER("meta", 4))) *sections |= PORTAL_ENDPOINT_MESSAGE_META;
else if (!st_cmp_ci_eq(NULLER(current), PLACER("source", 6))) *sections |= PORTAL_ENDPOINT_MESSAGE_SOURCE;
else if (!st_cmp_ci_eq(NULLER(current), PLACER("security", 8))) *sections |= PORTAL_ENDPOINT_MESSAGE_SECURITY;
else if (!st_cmp_ci_eq(NULLER(current), PLACER("server", 6))) *sections |= PORTAL_ENDPOINT_MESSAGE_SERVER;
else if (!st_cmp_ci_eq(NULLER(current), PLACER("header", 6))) *sections |= PORTAL_ENDPOINT_MESSAGE_HEADER;
else if (!st_cmp_ci_eq(NULLER(current), PLACER("body", 4))) *sections |= PORTAL_ENDPOINT_MESSAGE_BODY;
else if (!st_cmp_ci_eq(NULLER(current), PLACER("attachments", 11))) *sections |= PORTAL_ENDPOINT_MESSAGE_ATTACHMENTS;
else if (!st_cmp_ci_eq(NULLER(current), PLACER("info",4))) *sections |= PORTAL_ENDPOINT_MESSAGE_INFO;
else if (result == 1) result = -2;
}
return result;
}
int json_array_append_new(json_t *json, json_t *value)
{
json_array_t *array;
if(!value)
return -1;
if(!json_is_array(json) || json == value)
{
json_decref(value);
return -1;
}
array = json_to_array(json);
if(!json_array_grow(array, 1, 1)) {
json_decref(value);
return -1;
}
array->table[array->entries] = value;
array->entries++;
return 0;
}
static int
avro_schema_from_json_t(json_t *json, avro_schema_t *schema,
st_table *named_schemas)
{
#ifdef _WIN32
#pragma message("#warning: Bug: '0' is not of type avro_type_t.")
#else
#warning "Bug: '0' is not of type avro_type_t."
#endif
/* We should really have an "AVRO_INVALID" type in
* avro_type_t. Suppress warning below in which we set type to 0.
*/
avro_type_t type = (avro_type_t) 0;
unsigned int i;
avro_schema_t named_type = NULL;
if (avro_type_from_json_t(json, &type, named_schemas, &named_type)) {
return EINVAL;
}
switch (type) {
case AVRO_LINK:
*schema = avro_schema_link(named_type);
break;
case AVRO_STRING:
*schema = avro_schema_string();
break;
case AVRO_BYTES:
*schema = avro_schema_bytes();
break;
case AVRO_INT32:
*schema = avro_schema_int();
break;
case AVRO_INT64:
*schema = avro_schema_long();
break;
case AVRO_FLOAT:
*schema = avro_schema_float();
break;
case AVRO_DOUBLE:
*schema = avro_schema_double();
break;
case AVRO_BOOLEAN:
*schema = avro_schema_boolean();
break;
case AVRO_NULL:
*schema = avro_schema_null();
break;
case AVRO_RECORD:
{
json_t *json_name = json_object_get(json, "name");
json_t *json_namespace =
json_object_get(json, "namespace");
json_t *json_fields = json_object_get(json, "fields");
unsigned int num_fields;
const char *record_name;
const char *record_namespace;
if (!json_is_string(json_name)) {
avro_set_error("Record type must have a \"name\"");
return EINVAL;
}
if (!json_is_array(json_fields)) {
avro_set_error("Record type must have \"fields\"");
return EINVAL;
}
num_fields = json_array_size(json_fields);
if (num_fields == 0) {
avro_set_error("Record type must have at least one field");
return EINVAL;
}
record_name = json_string_value(json_name);
if (!record_name) {
avro_set_error("Record type must have a \"name\"");
return EINVAL;
}
if (json_is_string(json_namespace)) {
record_namespace =
json_string_value(json_namespace);
} else {
record_namespace = NULL;
}
*schema =
avro_schema_record(record_name, record_namespace);
if (save_named_schemas(record_name, *schema, named_schemas)) {
avro_set_error("Cannot save record schema");
return ENOMEM;
}
for (i = 0; i < num_fields; i++) {
json_t *json_field =
json_array_get(json_fields, i);
json_t *json_field_name;
json_t *json_field_type;
json_t *json_default_value;
avro_schema_t json_field_type_schema;
int field_rval;
if (!json_is_object(json_field)) {
avro_set_error("Record field %d must be an array", i);
avro_schema_decref(*schema);
return EINVAL;
}
json_field_name =
json_object_get(json_field, "name");
if (!json_field_name) {
avro_set_error("Record field %d must have a \"name\"", i);
avro_schema_decref(*schema);
return EINVAL;
}
json_field_type =
json_object_get(json_field, "type");
if (!json_field_type) {
avro_set_error("Record field %d must have a \"type\"", i);
avro_schema_decref(*schema);
return EINVAL;
}
field_rval =
avro_schema_from_json_t(json_field_type,
&json_field_type_schema,
named_schemas);
if (field_rval) {
avro_schema_decref(*schema);
return field_rval;
}
json_default_value =
json_object_get(json_field, "default");
avro_datum_t default_value = NULL;
if (json_default_value) {
avro_schema_t default_schema = json_field_type_schema;
if (json_field_type_schema->type == AVRO_UNION) {
// From the spec: "Default values for union fields correspond
// to the first schema in the union."
default_schema =
avro_schema_union_branch(json_field_type_schema, 0);
}
default_value =
json_t_to_avro_value(default_schema, json_default_value);
if (default_value == NULL) {
avro_schema_decref(*schema);
return EINVAL;
}
}
field_rval =
avro_schema_record_field_append(*schema,
json_string_value
(json_field_name),
json_field_type_schema,
default_value);
avro_schema_decref(json_field_type_schema);
if (field_rval != 0) {
avro_schema_decref(*schema);
return field_rval;
}
}
}
break;
case AVRO_ENUM:
{
json_t *json_name = json_object_get(json, "name");
json_t *json_symbols = json_object_get(json, "symbols");
const char *name;
unsigned int num_symbols;
if (!json_is_string(json_name)) {
avro_set_error("Enum type must have a \"name\"");
return EINVAL;
}
if (!json_is_array(json_symbols)) {
avro_set_error("Enum type must have \"symbols\"");
return EINVAL;
}
name = json_string_value(json_name);
if (!name) {
avro_set_error("Enum type must have a \"name\"");
return EINVAL;
}
num_symbols = json_array_size(json_symbols);
if (num_symbols == 0) {
avro_set_error("Enum type must have at least one symbol");
return EINVAL;
}
*schema = avro_schema_enum(name);
if (save_named_schemas(name, *schema, named_schemas)) {
avro_set_error("Cannot save enum schema");
return ENOMEM;
}
for (i = 0; i < num_symbols; i++) {
int enum_rval;
json_t *json_symbol =
json_array_get(json_symbols, i);
const char *symbol;
if (!json_is_string(json_symbol)) {
avro_set_error("Enum symbol %d must be a string", i);
avro_schema_decref(*schema);
return EINVAL;
}
symbol = json_string_value(json_symbol);
enum_rval =
avro_schema_enum_symbol_append(*schema,
symbol);
if (enum_rval != 0) {
avro_schema_decref(*schema);
return enum_rval;
}
}
}
break;
case AVRO_ARRAY:
{
int items_rval;
json_t *json_items = json_object_get(json, "items");
avro_schema_t items_schema;
if (!json_items) {
avro_set_error("Array type must have \"items\"");
return EINVAL;
}
items_rval =
avro_schema_from_json_t(json_items, &items_schema,
named_schemas);
if (items_rval) {
return items_rval;
}
*schema = avro_schema_array(items_schema);
avro_schema_decref(items_schema);
}
break;
case AVRO_MAP:
{
int values_rval;
json_t *json_values = json_object_get(json, "values");
avro_schema_t values_schema;
if (!json_values) {
avro_set_error("Map type must have \"values\"");
return EINVAL;
}
values_rval =
avro_schema_from_json_t(json_values, &values_schema,
named_schemas);
if (values_rval) {
return values_rval;
}
*schema = avro_schema_map(values_schema);
avro_schema_decref(values_schema);
}
break;
case AVRO_UNION:
{
unsigned int num_schemas = json_array_size(json);
avro_schema_t s;
if (num_schemas == 0) {
avro_set_error("Union type must have at least one branch");
return EINVAL;
}
*schema = avro_schema_union();
for (i = 0; i < num_schemas; i++) {
int schema_rval;
json_t *schema_json = json_array_get(json, i);
if (!schema_json) {
avro_set_error("Cannot retrieve branch JSON");
return EINVAL;
}
schema_rval =
avro_schema_from_json_t(schema_json, &s,
named_schemas);
if (schema_rval != 0) {
avro_schema_decref(*schema);
return schema_rval;
}
schema_rval =
avro_schema_union_append(*schema, s);
avro_schema_decref(s);
if (schema_rval != 0) {
avro_schema_decref(*schema);
return schema_rval;
}
}
}
break;
case AVRO_FIXED:
{
json_t *json_size = json_object_get(json, "size");
json_t *json_name = json_object_get(json, "name");
json_int_t size;
const char *name;
if (!json_is_integer(json_size)) {
avro_set_error("Fixed type must have a \"size\"");
return EINVAL;
}
if (!json_is_string(json_name)) {
avro_set_error("Fixed type must have a \"name\"");
return EINVAL;
}
size = json_integer_value(json_size);
name = json_string_value(json_name);
*schema = avro_schema_fixed(name, (int64_t) size);
if (save_named_schemas(name, *schema, named_schemas)) {
avro_set_error("Cannot save fixed schema");
return ENOMEM;
}
}
break;
default:
avro_set_error("Unknown schema type");
return EINVAL;
}
return 0;
}
static int
avro_type_from_json_t(json_t *json, avro_type_t *type,
st_table *named_schemas, avro_schema_t *named_type)
{
json_t *json_type;
const char *type_str;
if (json_is_array(json)) {
*type = AVRO_UNION;
return 0;
} else if (json_is_object(json)) {
json_type = json_object_get(json, "type");
} else {
json_type = json;
}
if (!json_is_string(json_type)) {
avro_set_error("\"type\" field must be a string");
return EINVAL;
}
type_str = json_string_value(json_type);
if (!type_str) {
avro_set_error("\"type\" field must be a string");
return EINVAL;
}
/*
* TODO: gperf/re2c this
*/
if (strcmp(type_str, "string") == 0) {
*type = AVRO_STRING;
} else if (strcmp(type_str, "bytes") == 0) {
*type = AVRO_BYTES;
} else if (strcmp(type_str, "int") == 0) {
*type = AVRO_INT32;
} else if (strcmp(type_str, "long") == 0) {
*type = AVRO_INT64;
} else if (strcmp(type_str, "float") == 0) {
*type = AVRO_FLOAT;
} else if (strcmp(type_str, "double") == 0) {
*type = AVRO_DOUBLE;
} else if (strcmp(type_str, "boolean") == 0) {
*type = AVRO_BOOLEAN;
} else if (strcmp(type_str, "null") == 0) {
*type = AVRO_NULL;
} else if (strcmp(type_str, "record") == 0) {
*type = AVRO_RECORD;
} else if (strcmp(type_str, "enum") == 0) {
*type = AVRO_ENUM;
} else if (strcmp(type_str, "array") == 0) {
*type = AVRO_ARRAY;
} else if (strcmp(type_str, "map") == 0) {
*type = AVRO_MAP;
} else if (strcmp(type_str, "fixed") == 0) {
*type = AVRO_FIXED;
} else if ((*named_type = find_named_schemas(type_str, named_schemas))) {
*type = AVRO_LINK;
} else {
avro_set_error("Unknown Avro \"type\": %s", type_str);
return EINVAL;
}
return 0;
}
void pilot::JSONFileHandler::endArrayWrite() {
Assertion(json_is_array(_currentEl), "Array ended while not in an array!");
_elementStack.pop_back();
_currentEl = _elementStack.back();
}
/*====================================================================
* 函数名 : vGenCONNSRVCONNMsg
* 功能 : 终端与某服务器连上时上报消息
* 算法实现 :
* 参数说明 : vpd 要上报的设备
* 返回值说明: 成功 生成的消息
* 失败 NULL
* ----------------------------------------------------------------------
* 修改记录:
* 日 期 版本 修改人 走读人 修改记录
* 2015/1/26 v1.0 YLI 创建
* ====================================================================*/
json_t * vGenCONNSRVCONNMsg(VPD vpd)
{
json_t *root;
json_t *conn_srv_state_info;
json_t *jt;
json_t *jp;
char saCfgPath[L_PATH_MAX_LEN];
int n,m;
root = json_object();
memset(saCfgPath,0x00,sizeof saCfgPath);
//eventid
if (json_object_set(root,"eventid",
json_string("EV_CONNSRV_CONN_MSG")) == FAILUER)
{
json_decref(root);
vLogErr("eventid set error!!!");
return NULL;
}
conn_srv_state_info = json_array();
if(getenv("APP_PROFILE_PATH") == NULL)
{
json_decref(root);
vLogErr("devtypes config file path error,please check evn value!!!");
return NULL;
}
strcpy(saCfgPath,getenv("APP_PROFILE_PATH"));
strcat(saCfgPath,"/devtypes.json");
/*conn_srv_state_info*/
jt = tPflGetJsonObj(saCfgPath,K_LOGICTYPE_KEY);
if(jt == NULL)
{
json_decref(root);
return NULL;
}
srand((unsigned)time(NULL));
if (json_is_array(jt))
{
int it;
m = json_array_size(jt);
n = rand()%m;
jp = json_pack("{s:s,s:s}",
"type",json_string_value(json_array_get(jt,n)),
"ip",_gstrpShm->rc.nSrvIP);
if ((jp ==NULL) || (json_array_insert(conn_srv_state_info,0,
jp)) == FAILUER)
{
json_decref(root);
vLogErr("devtype set error!!!");
return NULL;
}
it = rand()%m;
while(it == n) it = rand()%m;
n = it;
jp = json_pack("{s:s,s:s}",
"type",json_string_value(json_array_get(jt,n)),
"ip",_gstrpShm->rc.nSrvIP);
if (json_array_insert(conn_srv_state_info,1,
json_array_get(jt,n)) == FAILUER)
{
json_decref(root);
vLogErr("devtype set error!!!");
return NULL;
}
}
json_decref(jt);
json_decref(jp);
json_decref(conn_srv_state_info);
json_object_set(root,"conn_srv_state_info",conn_srv_state_info);
return root;
}
// Parse pools array in json config
bool parse_pool_array(json_t *obj)
{
size_t idx;
json_t *p, *val;
if (!json_is_array(obj))
return false;
// array of objects [ {}, {} ]
json_array_foreach(obj, idx, p)
{
if (!json_is_object(p))
continue;
for (int i = 0; i < ARRAY_SIZE(cfg_array_keys); i++)
{
int opt = -1;
char *s = NULL;
if (cfg_array_keys[i].cat != CFG_POOL)
continue;
val = json_object_get(p, cfg_array_keys[i].name);
if (!val)
continue;
for (int k = 0; k < options_count(); k++)
{
const char *alias = cfg_array_keys[i].longname;
if (alias && !strcasecmp(options[k].name, alias)) {
opt = k;
break;
}
if (!alias && !strcasecmp(options[k].name, cfg_array_keys[i].name)) {
opt = k;
break;
}
}
if (opt == -1)
continue;
if (json_is_string(val)) {
s = strdup(json_string_value(val));
if (!s)
continue;
// applog(LOG_DEBUG, "pool key %s '%s'", options[opt].name, s);
parse_arg(options[opt].val, s);
free(s);
} else {
// numeric or bool
char buf[32] = { 0 };
double d = 0.;
if (json_is_true(val)) d = 1.;
else if (json_is_integer(val))
d = 1.0 * json_integer_value(val);
else if (json_is_real(val))
d = json_real_value(val);
snprintf(buf, sizeof(buf)-1, "%f", d);
// applog(LOG_DEBUG, "pool key %s '%f'", options[opt].name, d);
parse_arg(options[opt].val, buf);
}
}
}
return true;
}
// ["dirname", "foo"] -> ["dirname", "foo", ["depth", "ge", 0]]
static w_query_expr *dirname_parser_inner(w_query *query, json_t *term,
bool caseless)
{
const char *which = caseless ? "idirname" : "dirname";
struct dirname_data *data;
json_t *name;
struct w_query_int_compare depth_comp;
if (!json_is_array(term)) {
ignore_result(asprintf(&query->errmsg, "Expected array for '%s' term",
which));
return NULL;
}
if (json_array_size(term) < 2) {
ignore_result(asprintf(&query->errmsg,
"Invalid number of arguments for '%s' term",
which));
return NULL;
}
if (json_array_size(term) > 3) {
ignore_result(asprintf(&query->errmsg,
"Invalid number of arguments for '%s' term",
which));
return NULL;
}
name = json_array_get(term, 1);
if (!json_is_string(name)) {
ignore_result(asprintf(&query->errmsg,
"Argument 2 to '%s' must be a string", which));
return NULL;
}
if (json_array_size(term) == 3) {
json_t *depth;
depth = json_array_get(term, 2);
if (!json_is_array(depth)) {
ignore_result(asprintf(&query->errmsg,
"Invalid number of arguments for '%s' term",
which));
return NULL;
}
if (!parse_int_compare(depth, &depth_comp, &query->errmsg)) {
return NULL;
}
if (strcmp("depth", json_string_value(json_array_get(depth, 0)))) {
ignore_result(asprintf(&query->errmsg,
"Third parameter to '%s' should be a relational depth term",
which));
return NULL;
}
} else {
depth_comp.operand = 0;
depth_comp.op = W_QUERY_ICMP_GE;
}
data = calloc(1, sizeof(*data));
if (!data) {
ignore_result(asprintf(&query->errmsg, "out of memory"));
return NULL;
}
data->dirname = w_string_new(json_string_value(name));
data->startswith =
caseless ? w_string_startswith_caseless : w_string_startswith;
data->depth = depth_comp;
return w_query_expr_new(eval_dirname, dispose_dirname, data);
}
/*
* validate the "aud" and "azp" claims in the id_token payload
*/
static apr_byte_t oidc_proto_validate_aud_and_azp(request_rec *r, oidc_cfg *cfg,
oidc_provider_t *provider, apr_jwt_payload_t *id_token_payload) {
char *azp = NULL;
apr_jwt_get_string(r->pool, &id_token_payload->value, "azp", &azp);
/*
* the "azp" claim is only needed when the id_token has a single audience value and that audience
* is different than the authorized party; it MAY be included even when the authorized party is
* the same as the sole audience.
*/
if ((azp != NULL) && (apr_strnatcmp(azp, provider->client_id) != 0)) {
oidc_error(r,
"the \"azp\" claim (%s) is present in the id_token, but is not equal to the configured client_id (%s)",
azp, provider->client_id);
return FALSE;
}
/* get the "aud" value from the JSON payload */
json_t *aud = json_object_get(id_token_payload->value.json, "aud");
if (aud != NULL) {
/* check if it is a single-value */
if (json_is_string(aud)) {
/* a single-valued audience must be equal to our client_id */
if (apr_strnatcmp(json_string_value(aud), provider->client_id)
!= 0) {
oidc_error(r,
"the configured client_id (%s) did not match the \"aud\" claim value (%s) in the id_token",
provider->client_id, json_string_value(aud));
return FALSE;
}
/* check if this is a multi-valued audience */
} else if (json_is_array(aud)) {
if ((json_array_size(aud) > 1) && (azp == NULL)) {
oidc_debug(r,
"the \"aud\" claim value in the id_token is an array with more than 1 element, but \"azp\" claim is not present (a SHOULD in the spec...)");
}
if (oidc_util_json_array_has_value(r, aud,
provider->client_id) == FALSE) {
oidc_error(r,
"our configured client_id (%s) could not be found in the array of values for \"aud\" claim",
provider->client_id);
return FALSE;
}
} else {
oidc_error(r,
"id_token JSON payload \"aud\" claim is not a string nor an array");
return FALSE;
}
} else {
oidc_error(r, "id_token JSON payload did not contain an \"aud\" claim");
return FALSE;
}
return TRUE;
}
void read_ff_json(const char *json_file, struct atomgrp *ag)
{
json_error_t json_file_error;
json_t *base = json_load_file(json_file, 0, &json_file_error);
if (!base) {
fprintf(stderr,
"error reading json file %s on line %d column %d: %s\n",
json_file, json_file_error.line, json_file_error.column,
json_file_error.text);
}
if (!json_is_object(base)) {
fprintf(stderr, "json file not an object %s\n", json_file);
}
json_t *atoms, *bonds, *angles, *torsions, *impropers;
atoms = json_object_get(base, "atoms");
if (!json_is_array(atoms)) {
fprintf(stderr, "json atoms are not an array %s\n", json_file);
}
size_t natoms = json_array_size(atoms);
if (natoms != (size_t) ag->natoms) {
fprintf(stderr,
"json file has a different number of atoms %zd vs. %d : %s\n",
natoms, ag->natoms, json_file);
}
ag->num_atom_types = 0;
for (size_t i = 0; i < natoms; i++) {
json_t *atom = json_array_get(atoms, i);
if (!json_is_object(atom)) {
fprintf(stderr,
"Atom %zd not an object in json file %s\n", i,
json_file);
}
json_t *ace_volume, *ftype_index, *ftype_name, *eps03;
json_t *name, *radius03, *eps;
json_t *charge, *radius, *element;
ace_volume = json_object_get(atom, "ace_volume");
if (!json_is_real(ace_volume)) {
fprintf(stderr,
"json ace volume is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].acevolume = json_real_value(ace_volume);
ftype_index = json_object_get(atom, "ftype_index");
if (!json_is_integer(ftype_index)) {
fprintf(stderr,
"json ftype index is not integer for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].atom_ftypen = json_integer_value(ftype_index);
if (ag->atoms[i].atom_ftypen > ag->num_atom_types) {
ag->num_atom_types = ag->atoms[i].atom_ftypen;
}
ftype_name = json_object_get(atom, "ftype_name");
if (!json_is_string(ftype_name)) {
fprintf(stderr,
"json ftype name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].ftype_name = strdup(json_string_value(ftype_name));
element = json_object_get(atom, "element");
if (!json_is_string(element)) {
fprintf(stderr,
"json element name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].element = strdup(json_string_value(element));
eps = json_object_get(atom, "eps");
if (!json_is_real(eps)) {
fprintf(stderr,
"json eps is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].eps = sqrt(-json_real_value(eps));
eps03 = json_object_get(atom, "eps03");
if (!json_is_real(eps03)) {
fprintf(stderr,
"json eps03 is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].eps03 = sqrt(-json_real_value(eps03));
radius = json_object_get(atom, "radius");
if (!json_is_real(radius)) {
fprintf(stderr,
"json radius is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].rminh = json_real_value(radius);
radius03 = json_object_get(atom, "radius03");
if (!json_is_real(radius03)) {
fprintf(stderr,
"json radius03 is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].rminh03 = json_real_value(radius03);
charge = json_object_get(atom, "charge");
if (!json_is_real(radius03)) {
fprintf(stderr,
"json charge is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].chrg = json_real_value(charge);
name = json_object_get(atom, "name");
if (!json_is_string(name)) {
fprintf(stderr,
"json name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].name = strdup(json_string_value(name));
ag->atoms[i].nbonds = 0;
ag->atoms[i].nangs = 0;
ag->atoms[i].ntors = 0;
ag->atoms[i].nimps = 0;
ag->atoms[i].fixed = 0;
}
bonds = json_object_get(base, "bonds");
if (!json_is_array(bonds)) {
fprintf(stderr, "json bonds are not an array %s\n", json_file);
}
size_t nbonds = json_array_size(bonds);
ag->nbonds = nbonds;
ag->bonds = _mol_calloc(nbonds, sizeof(struct atombond));
for (size_t i = 0; i < nbonds; i++) {
json_t *bond = json_array_get(bonds, i);
if (!json_is_object(bond)) {
fprintf(stderr,
"Bond %zd not an object in json file %s\n", i,
json_file);
}
json_t *length, *atom1, *atom2, *spring_constant, *sdf_type;
atom1 = json_object_get(bond, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for bond %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->bonds[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].nbonds)++;
atom2 = json_object_get(bond, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for bond %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->bonds[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].nbonds)++;
length = json_object_get(bond, "length");
if (!json_is_real(length)) {
fprintf(stderr,
"json length is not floating point for bond %zd in json_file %s\n",
i, json_file);
}
ag->bonds[i].l0 = json_real_value(length);
spring_constant = json_object_get(bond, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for bond %zd in json_file %s\n",
i, json_file);
}
ag->bonds[i].k = json_real_value(spring_constant);
sdf_type = json_object_get(bond, "sdf_type");
if (!json_is_integer(sdf_type)) {
fprintf(stderr,
"json sdf_type is not integer for bond %zd in json_file %s\n",
i, json_file);
}
ag->bonds[i].sdf_type = json_integer_value(sdf_type);
}
angles = json_object_get(base, "angles");
if (!json_is_array(angles)) {
fprintf(stderr, "json angles are not an array %s\n", json_file);
}
size_t nangles = json_array_size(angles);
ag->nangs = nangles;
ag->angs = _mol_calloc(nangles, sizeof(struct atomangle));
for (size_t i = 0; i < nangles; i++) {
json_t *angle = json_array_get(angles, i);
if (!json_is_object(angle)) {
fprintf(stderr,
"Angle %zd not an object in json file %s\n", i,
json_file);
}
json_t *theta, *atom1, *atom2, *atom3, *spring_constant;
atom1 = json_object_get(angle, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for angle %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->angs[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].nangs)++;
atom2 = json_object_get(angle, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for angle %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->angs[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].nangs)++;
atom3 = json_object_get(angle, "atom3");
if (!json_is_integer(atom3)) {
fprintf(stderr,
"json atom3 is not integer for angle %zd in json_file %s\n",
i, json_file);
}
int i3 = json_integer_value(atom3) - 1;
ag->angs[i].a2 = &(ag->atoms[i3]);
(ag->atoms[i3].nangs)++;
theta = json_object_get(angle, "theta");
if (!json_is_real(theta)) {
fprintf(stderr,
"json theta is not floating point for angle %zd in json_file %s\n",
i, json_file);
}
ag->angs[i].th0 = json_real_value(theta);
spring_constant = json_object_get(angle, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for angle %zd in json_file %s\n",
i, json_file);
}
ag->angs[i].k = json_real_value(spring_constant);
}
torsions = json_object_get(base, "torsions");
if (!json_is_array(torsions)) {
fprintf(stderr, "json torsions are not an array %s\n",
json_file);
}
size_t ntorsions = json_array_size(torsions);
ag->ntors = ntorsions;
ag->tors = _mol_calloc(ntorsions, sizeof(struct atomtorsion));
for (size_t i = 0; i < ntorsions; i++) {
json_t *torsion = json_array_get(torsions, i);
if (!json_is_object(torsion)) {
fprintf(stderr,
"Torsion %zd not an object in json file %s\n",
i, json_file);
}
json_t *atom1, *atom2, *atom3, *atom4, *minima, *delta_constant,
*spring_constant;
atom1 = json_object_get(torsion, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->tors[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].ntors)++;
atom2 = json_object_get(torsion, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->tors[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].ntors)++;
atom3 = json_object_get(torsion, "atom3");
if (!json_is_integer(atom3)) {
fprintf(stderr,
"json atom3 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i3 = json_integer_value(atom3) - 1;
ag->tors[i].a2 = &(ag->atoms[i3]);
(ag->atoms[i3].ntors)++;
atom4 = json_object_get(torsion, "atom4");
if (!json_is_integer(atom4)) {
fprintf(stderr,
"json atom4 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i4 = json_integer_value(atom4) - 1;
ag->tors[i].a3 = &(ag->atoms[i4]);
(ag->atoms[i4].ntors)++;
minima = json_object_get(torsion, "minima");
if (!json_is_integer(minima)) {
fprintf(stderr,
"json minima is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
ag->tors[i].n = json_integer_value(minima);
delta_constant = json_object_get(torsion, "delta_constant");
if (!json_is_real(delta_constant)) {
fprintf(stderr,
"json delta_constant is not floating point for torsion %zd in json_file %s\n",
i, json_file);
}
ag->tors[i].d = json_real_value(delta_constant);
spring_constant = json_object_get(torsion, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for torsion %zd in json_file %s\n",
i, json_file);
}
ag->tors[i].k = json_real_value(spring_constant);
}
impropers = json_object_get(base, "impropers");
if (!json_is_array(impropers)) {
fprintf(stderr, "json impropers are not an array %s\n",
json_file);
}
size_t nimpropers = json_array_size(impropers);
ag->nimps = nimpropers;
ag->imps = _mol_calloc(nimpropers, sizeof(struct atomimproper));
for (size_t i = 0; i < nimpropers; i++) {
json_t *improper = json_array_get(impropers, i);
if (!json_is_object(improper)) {
fprintf(stderr,
"Improper %zd not an object in json file %s\n",
i, json_file);
}
json_t *atom1, *atom2, *atom3, *atom4, *phi, *spring_constant;
atom1 = json_object_get(improper, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->imps[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].nimps)++;
atom2 = json_object_get(improper, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->imps[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].nimps)++;
atom3 = json_object_get(improper, "atom3");
if (!json_is_integer(atom3)) {
fprintf(stderr,
"json atom3 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i3 = json_integer_value(atom3) - 1;
ag->imps[i].a2 = &(ag->atoms[i3]);
(ag->atoms[i3].nimps)++;
atom4 = json_object_get(improper, "atom4");
if (!json_is_integer(atom4)) {
fprintf(stderr,
"json atom4 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i4 = json_integer_value(atom4) - 1;
ag->imps[i].a3 = &(ag->atoms[i4]);
(ag->atoms[i4].nimps)++;
phi = json_object_get(improper, "phi");
if (!json_is_real(phi)) {
fprintf(stderr,
"json phi is not floating point for improper %zd in json_file %s\n",
i, json_file);
}
ag->imps[i].psi0 = json_real_value(phi);
spring_constant = json_object_get(improper, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for improper %zd in json_file %s\n",
i, json_file);
}
ag->imps[i].k = json_real_value(spring_constant);
}
json_decref(base);
//allocate atom arrays of pointers to parameters
for (size_t i = 0; i < natoms; i++) {
int i1 = ag->atoms[i].nbonds;
ag->atoms[i].bonds = _mol_calloc(i1, sizeof(struct atombond *));
ag->atoms[i].nbonds = 0;
i1 = ag->atoms[i].nangs;
ag->atoms[i].angs = _mol_calloc(i1, sizeof(struct atomangle *));
ag->atoms[i].nangs = 0;
i1 = ag->atoms[i].ntors;
ag->atoms[i].tors =
_mol_calloc(i1, sizeof(struct atomtorsion *));
ag->atoms[i].ntors = 0;
i1 = ag->atoms[i].nimps;
ag->atoms[i].imps =
_mol_calloc(i1, sizeof(struct atomimproper *));
ag->atoms[i].nimps = 0;
}
struct atom *atm;
//fill bonds
for (int i = 0; i < ag->nbonds; i++) {
atm = ag->bonds[i].a0;
atm->bonds[(atm->nbonds)++] = &(ag->bonds[i]);
atm = ag->bonds[i].a1;
atm->bonds[(atm->nbonds)++] = &(ag->bonds[i]);
}
//fill angles
for (int i = 0; i < ag->nangs; i++) {
atm = ag->angs[i].a0;
atm->angs[(atm->nangs)++] = &(ag->angs[i]);
atm = ag->angs[i].a1;
atm->angs[(atm->nangs)++] = &(ag->angs[i]);
atm = ag->angs[i].a2;
atm->angs[(atm->nangs)++] = &(ag->angs[i]);
}
//fill torsions
for (int i = 0; i < ag->ntors; i++) {
atm = ag->tors[i].a0;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
atm = ag->tors[i].a1;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
atm = ag->tors[i].a2;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
atm = ag->tors[i].a3;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
}
//fill impropers
for (int i = 0; i < ag->nimps; i++) {
atm = ag->imps[i].a0;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
atm = ag->imps[i].a1;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
atm = ag->imps[i].a2;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
atm = ag->imps[i].a3;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
}
//atom indices in the group
fill_ingrp(ag);
ag->is_psf_read = true;
// copy vals from deprecated to new data structures
int atomsi;
for (atomsi = 0; atomsi < ag->natoms; atomsi++) {
_mol_atom_create_bond_indices(&ag->atoms[atomsi],
ag->atoms[atomsi].nbonds);
}
_mol_atom_group_copy_from_deprecated(ag);
}
static void task_populate_titledb_thread(void* arg) {
populate_titledb_data* data = (populate_titledb_data*) arg;
Result res = 0;
linked_list titles;
linked_list_init(&titles);
json_t* root = NULL;
if(R_SUCCEEDED(res = http_download_json("https://api.titledb.com/v1/entry?nested=true"
"&only=id&only=name&only=author&only=headline&only=category"
"&only=cia.id&only=cia.mtime&only=cia.version&only=cia.size&only=cia.titleid"
"&only=tdsx.id&only=tdsx.mtime&only=tdsx.version&only=tdsx.size&only=tdsx.smdh.id",
&root, 1024 * 1024))) {
if(json_is_array(root)) {
for(u32 i = 0; i < json_array_size(root) && R_SUCCEEDED(res); i++) {
svcWaitSynchronization(task_get_pause_event(), U64_MAX);
if(task_is_quit_all() || svcWaitSynchronization(data->cancelEvent, 0) == 0) {
break;
}
json_t* entry = json_array_get(root, i);
if(json_is_object(entry)) {
list_item* item = (list_item*) calloc(1, sizeof(list_item));
if(item != NULL) {
titledb_info* titledbInfo = (titledb_info*) calloc(1, sizeof(titledb_info));
if(titledbInfo != NULL) {
titledbInfo->id = (u32) json_object_get_integer(entry, "id", 0);
string_copy(titledbInfo->category, json_object_get_string(entry, "category", "Unknown"), sizeof(titledbInfo->category));
string_copy(titledbInfo->meta.shortDescription, json_object_get_string(entry, "name", ""), sizeof(titledbInfo->meta.shortDescription));
string_copy(titledbInfo->meta.publisher, json_object_get_string(entry, "author", ""), sizeof(titledbInfo->meta.publisher));
json_t* headline = json_object_get(entry, "headline");
if(json_is_string(headline)) {
const char* val = json_string_value(headline);
if(json_string_length(headline) > sizeof(titledbInfo->headline) - 1) {
snprintf(titledbInfo->headline, sizeof(titledbInfo->headline), "%.508s...", val);
} else {
string_copy(titledbInfo->headline, val, sizeof(titledbInfo->headline));
}
} else {
titledbInfo->headline[0] = '\0';
}
json_t* cias = json_object_get(entry, "cia");
if(json_is_array(cias)) {
for(u32 j = 0; j < json_array_size(cias); j++) {
json_t* cia = json_array_get(cias, j);
if(json_is_object(cia)) {
const char* mtime = json_object_get_string(cia, "mtime", "Unknown");
if(!titledbInfo->cia.exists || task_populate_titledb_compare_dates(mtime, titledbInfo->cia.mtime, sizeof(titledbInfo->cia.mtime)) >= 0) {
titledbInfo->cia.exists = true;
titledbInfo->cia.id = (u32) json_object_get_integer(cia, "id", 0);
string_copy(titledbInfo->cia.mtime, mtime, sizeof(titledbInfo->cia.mtime));
string_copy(titledbInfo->cia.version, json_object_get_string(cia, "version", "Unknown"), sizeof(titledbInfo->cia.version));
titledbInfo->cia.size = (u32) json_object_get_integer(cia, "size", 0);
titledbInfo->cia.titleId = strtoull(json_object_get_string(cia, "titleid", "0"), NULL, 16);
}
}
}
}
json_t* tdsxs = json_object_get(entry, "tdsx");
if(json_is_array(tdsxs)) {
for(u32 j = 0; j < json_array_size(tdsxs); j++) {
json_t* tdsx = json_array_get(tdsxs, j);
if(json_is_object(tdsx)) {
const char* mtime = json_object_get_string(tdsx, "mtime", "Unknown");
if(!titledbInfo->tdsx.exists || task_populate_titledb_compare_dates(mtime, titledbInfo->tdsx.mtime, sizeof(titledbInfo->tdsx.mtime)) >= 0) {
titledbInfo->tdsx.exists = true;
titledbInfo->tdsx.id = (u32) json_object_get_integer(tdsx, "id", 0);
string_copy(titledbInfo->tdsx.mtime, mtime, sizeof(titledbInfo->tdsx.mtime));
string_copy(titledbInfo->tdsx.version, json_object_get_string(tdsx, "version", "Unknown"), sizeof(titledbInfo->tdsx.version));
titledbInfo->tdsx.size = (u32) json_object_get_integer(tdsx, "size", 0);
json_t* smdh = json_object_get(tdsx, "smdh");
if(json_is_object(smdh)) {
titledbInfo->tdsx.smdh.exists = true;
titledbInfo->tdsx.smdh.id = (u32) json_object_get_integer(smdh, "id", 0);
}
}
}
}
}
char* latestTime = "Unknown";
if(titledbInfo->cia.exists && titledbInfo->tdsx.exists) {
if(task_populate_titledb_compare_dates(titledbInfo->cia.mtime, titledbInfo->tdsx.mtime, sizeof(titledbInfo->cia.mtime)) >= 0) {
latestTime = titledbInfo->cia.mtime;
} else {
latestTime = titledbInfo->tdsx.mtime;
}
} else if(titledbInfo->cia.exists) {
latestTime = titledbInfo->cia.mtime;
} else if(titledbInfo->tdsx.exists) {
latestTime = titledbInfo->tdsx.mtime;
}
string_copy(titledbInfo->mtime, latestTime, sizeof(titledbInfo->mtime));
if((titledbInfo->cia.exists || titledbInfo->tdsx.exists) && (data->filter == NULL || data->filter(data->userData, titledbInfo))) {
string_copy(item->name, titledbInfo->meta.shortDescription, LIST_ITEM_NAME_MAX);
item->data = titledbInfo;
task_populate_titledb_update_status(item);
linked_list_add_sorted(&titles, item, data->userData, data->compare);
} else {
free(titledbInfo);
free(item);
}
} else {
free(item);
res = R_APP_OUT_OF_MEMORY;
}
} else {
res = R_APP_OUT_OF_MEMORY;
}
}
}
linked_list_iter iter;
linked_list_iterate(&titles, &iter);
while(linked_list_iter_has_next(&iter)) {
list_item* item = linked_list_iter_next(&iter);
if(R_SUCCEEDED(res)) {
linked_list_add(data->items, item);
} else {
task_free_titledb(item);
linked_list_iter_remove(&iter);
}
}
} else {
res = R_APP_BAD_DATA;
}
json_decref(root);
}
data->itemsListed = true;
if(R_SUCCEEDED(res)) {
linked_list_iter iter;
linked_list_iterate(&titles, &iter);
while(linked_list_iter_has_next(&iter)) {
svcWaitSynchronization(task_get_pause_event(), U64_MAX);
Handle events[2] = {data->resumeEvent, data->cancelEvent};
s32 index = 0;
svcWaitSynchronizationN(&index, events, 2, false, U64_MAX);
if(task_is_quit_all() || svcWaitSynchronization(data->cancelEvent, 0) == 0) {
break;
}
list_item* item = (list_item*) linked_list_iter_next(&iter);
titledb_info* titledbInfo = (titledb_info*) item->data;
char url[128];
if(titledbInfo->cia.exists) {
snprintf(url, sizeof(url), "https://3ds.titledb.com/v1/cia/%lu/icon_l.bin", titledbInfo->cia.id);
} else if(titledbInfo->tdsx.exists && titledbInfo->tdsx.smdh.exists) {
snprintf(url, sizeof(url), "https://3ds.titledb.com/v1/smdh/%lu/icon_l.bin", titledbInfo->tdsx.smdh.id);
} else {
continue;
}
u8 icon[0x1200];
u32 iconSize = 0;
if(R_SUCCEEDED(http_download(url, &iconSize, &icon, sizeof(icon))) && iconSize == sizeof(icon)) {
titledbInfo->meta.texture = screen_allocate_free_texture();
screen_load_texture_tiled(titledbInfo->meta.texture, icon, sizeof(icon), 48, 48, GPU_RGB565, false);
}
}
}
linked_list_destroy(&titles);
svcCloseHandle(data->resumeEvent);
svcCloseHandle(data->cancelEvent);
data->result = res;
data->finished = true;
}
struct atomgrp *read_json_ag(const char *json_file)
{
struct atomgrp *ag =
(struct atomgrp *)_mol_calloc(1, sizeof(struct atomgrp));
json_error_t json_file_error;
json_t *base = json_load_file(json_file, 0, &json_file_error);
if (!base) {
fprintf(stderr,
"error reading json file %s on line %d column %d: %s\n",
json_file, json_file_error.line, json_file_error.column,
json_file_error.text);
}
if (!json_is_object(base)) {
fprintf(stderr, "json file not an object %s\n", json_file);
}
json_t *atoms, *bonds, *angles, *torsions, *impropers;
atoms = json_object_get(base, "atoms");
if (!json_is_array(atoms)) {
fprintf(stderr, "json atoms are not an array %s\n", json_file);
}
size_t natoms = json_array_size(atoms);
ag->natoms = natoms;
ag->atoms = (struct atom *)_mol_calloc(ag->natoms, sizeof(struct atom));
ag->num_atom_types = 0;
char *prev_segment = _mol_calloc(1, sizeof(char));
char *prev_residue = _mol_calloc(1, sizeof(char));
int prev_residue_seq = -107;
ag->nres = 0;
int alloc_res = 250;
ag->iares = _mol_malloc(alloc_res*sizeof(int));
for (size_t i = 0; i < natoms; i++) {
json_t *atom = json_array_get(atoms, i);
if (!json_is_object(atom)) {
fprintf(stderr,
"Atom %zd not an object in json file %s\n", i,
json_file);
}
json_t *ace_volume, *ftype_index, *ftype_name, *eps03;
json_t *name, *radius03, *eps, *acp_type, *residue_name;
json_t *charge, *radius, *element;
json_t *x, *y, *z;
json_t *yeti_type, *sybyl_type;
json_t *backbone, *hb_acceptor, *hb_donor, *hb_weight;
json_t *segment, *residue;
segment = json_object_get(atom, "segment");
residue = json_object_get(atom, "residue");
if ((segment != NULL) && (residue != NULL)) {
if (!json_is_string(segment)) {
fprintf(stderr,
"json segment is not string for atom %zd in json_file %s\n",
i, json_file);
}
if (!json_is_string(residue)) {
fprintf(stderr,
"json residue is not string for atom %zd in json_file %s\n",
i, json_file);
}
const char *cur_segment = json_string_value(segment);
const char *cur_residue = json_string_value(residue);
if (strcmp(cur_segment, prev_segment) != 0) {
prev_residue_seq += 100;
free(prev_segment);
prev_segment = strdup(cur_segment);
}
if (strcmp(cur_residue, prev_residue) != 0) {
int cur_residue_int = atoi(cur_residue);
int prev_residue_int = atoi(prev_residue);
if ((cur_residue_int - prev_residue_int) > 1) {
prev_residue_seq +=
(cur_residue_int -
prev_residue_int);
} else {
prev_residue_seq += 1;
}
free(prev_residue);
prev_residue = strdup(cur_residue);
if (ag->nres +1 == alloc_res) {
alloc_res *= 2;
ag->iares = _mol_realloc(ag->iares, alloc_res * i);
}
ag->iares[ag->nres] = i;
ag->nres++;
}
ag->atoms[i].comb_res_seq = prev_residue_seq;
} else {
ag->atoms[i].comb_res_seq = prev_residue_seq;
}
ace_volume = json_object_get(atom, "ace_volume");
if (!json_is_real(ace_volume)) {
fprintf(stderr,
"json ace volume is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].acevolume = json_real_value(ace_volume);
ftype_index = json_object_get(atom, "ftype_index");
if (!json_is_integer(ftype_index)) {
fprintf(stderr,
"json ftype index is not integer for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].atom_ftypen = json_integer_value(ftype_index);
if (ag->atoms[i].atom_ftypen > ag->num_atom_types) {
ag->num_atom_types = ag->atoms[i].atom_ftypen;
}
ftype_name = json_object_get(atom, "ftype_name");
if (!json_is_string(ftype_name)) {
fprintf(stderr,
"json ftype name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].ftype_name = strdup(json_string_value(ftype_name));
element = json_object_get(atom, "element");
if (!json_is_string(element)) {
fprintf(stderr,
"json element name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].element = strdup(json_string_value(element));
eps = json_object_get(atom, "eps");
if (!json_is_real(eps)) {
fprintf(stderr,
"json eps is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].eps = sqrt(-json_real_value(eps));
eps03 = json_object_get(atom, "eps03");
if (!json_is_real(eps03)) {
fprintf(stderr,
"json eps03 is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].eps03 = sqrt(-json_real_value(eps03));
radius = json_object_get(atom, "radius");
if (!json_is_real(radius)) {
fprintf(stderr,
"json radius is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].rminh = json_real_value(radius);
radius03 = json_object_get(atom, "radius03");
if (!json_is_real(radius03)) {
fprintf(stderr,
"json radius03 is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].rminh03 = json_real_value(radius03);
charge = json_object_get(atom, "charge");
if (!json_is_real(radius03)) {
fprintf(stderr,
"json charge is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].chrg = json_real_value(charge);
name = json_object_get(atom, "name");
if (!json_is_string(name)) {
fprintf(stderr,
"json name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].name = strdup(json_string_value(name));
residue_name = json_object_get(atom, "residue_name");
if (residue_name != NULL) {
if (!json_is_string(residue_name)) {
fprintf(stderr,
"json residue_name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].residue_name =
strdup(json_string_value(residue_name));
} else {
ag->atoms[i].residue_name = NULL;
}
x = json_object_get(atom, "x");
if (!json_is_real(x)) {
fprintf(stderr,
"json coordinate x is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].X = json_real_value(x);
y = json_object_get(atom, "y");
if (!json_is_real(y)) {
fprintf(stderr,
"json coordinate y is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].Y = json_real_value(y);
z = json_object_get(atom, "z");
if (!json_is_real(z)) {
fprintf(stderr,
"json coordinate z is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].Z = json_real_value(z);
acp_type = json_object_get(atom, "acp_type");
if (acp_type != NULL) {
if (!json_is_integer(acp_type)) {
fprintf(stderr,
"json acp_type index is not integer for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].acp_type = json_integer_value(acp_type);
} else {
ag->atoms[i].acp_type = -1;
}
yeti_type = json_object_get(atom, "yeti_type");
if (yeti_type != NULL) {
const char *yeti_type_string;
if (!json_is_string(yeti_type)) {
fprintf(stderr,
"json yeti_type is not string for atom %zd in json_file %s\n",
i, json_file);
}
yeti_type_string = json_string_value(yeti_type);
if (strcmp("carbonyl", yeti_type_string) == 0) {
ag->atoms[i].yeti_type = MOL_YETI_CARBONYL;
} else if (strcmp("hydroxyl", yeti_type_string) == 0) {
ag->atoms[i].yeti_type = MOL_YETI_HYDROXYL;
} else if (strcmp("sulfonamide", yeti_type_string) == 0) {
ag->atoms[i].yeti_type = MOL_YETI_SULFONAMIDE;
} else if (strcmp("N5_aromatic", yeti_type_string) == 0) {
ag->atoms[i].yeti_type = MOL_YETI_N5_AROMATIC;
} else if (strcmp("N6_aromatic", yeti_type_string) == 0) {
ag->atoms[i].yeti_type = MOL_YETI_N6_AROMATIC;
} else {
fprintf(stderr,
"unknown json yeti_type %s for atom %zd in json_file %s\n",
yeti_type_string, i, json_file);
ag->atoms[i].yeti_type = MOL_YETI_NONE;
}
} else {
ag->atoms[i].yeti_type = MOL_YETI_NONE;
}
sybyl_type = json_object_get(atom, "sybyl_type");
if (sybyl_type != NULL) {
const char *sybyl_type_string;
if (!json_is_string(sybyl_type)) {
fprintf(stderr,
"json sybyl_type is not string for atom %zd in json_file %s\n",
i, json_file);
}
sybyl_type_string = json_string_value(sybyl_type);
ag->atoms[i].hybridization =
mol_hydridization_from_sybyl(sybyl_type_string);
} else {
ag->atoms[i].hybridization = UNKNOWN_HYBRID;
}
backbone = json_object_get(atom, "backbone");
if (backbone != NULL) {
if (!json_is_boolean(backbone)) {
fprintf(stderr,
"json backbone is not boolean for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].backbone = json_is_true(backbone);
} else {
ag->atoms[i].backbone = false;
}
ag->atoms[i].hprop = 0;
hb_acceptor = json_object_get(atom, "hb_acceptor");
if (hb_acceptor != NULL) {
if (!json_is_boolean(hb_acceptor)) {
fprintf(stderr,
"json hb_acceptor is not boolean for atom %zd in json_file %s\n",
i, json_file);
}
if (json_is_true(hb_acceptor)) {
ag->atoms[i].hprop |= HBOND_ACCEPTOR;
}
}
hb_donor = json_object_get(atom, "hb_donor");
if (hb_donor != NULL) {
if (!json_is_boolean(hb_donor)) {
fprintf(stderr,
"json hb_donor is not boolean for atom %zd in json_file %s\n",
i, json_file);
}
if (json_is_true(hb_donor)) {
ag->atoms[i].hprop |= DONATABLE_HYDROGEN;
}
}
ag->atoms[i].hbond_weight = 1.0;
hb_weight = json_object_get(atom, "hb_weight");
if (hb_weight != NULL) {
if (!json_is_real(hb_weight)) {
fprintf(stderr,
"json hb_weight is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].hbond_weight = json_real_value(hb_weight);
}
ag->atoms[i].nbonds = 0;
ag->atoms[i].nangs = 0;
ag->atoms[i].ntors = 0;
ag->atoms[i].nimps = 0;
ag->atoms[i].fixed = 0;
ag->atoms[i].sa = -1;
ag->atoms[i].base = -1;
ag->atoms[i].base2 = -1;
}
ag->iares[ag->nres] = ag->natoms;
ag->iares = _mol_realloc(ag->iares, (ag->nres+1) * sizeof(int));
free(prev_segment);
free(prev_residue);
bonds = json_object_get(base, "bonds");
if (!json_is_array(bonds)) {
fprintf(stderr, "json bonds are not an array %s\n", json_file);
}
size_t nbonds = json_array_size(bonds);
ag->nbonds = nbonds;
ag->bonds = _mol_calloc(nbonds, sizeof(struct atombond));
for (size_t i = 0; i < nbonds; i++) {
json_t *bond = json_array_get(bonds, i);
if (!json_is_object(bond)) {
fprintf(stderr,
"Bond %zd not an object in json file %s\n", i,
json_file);
}
json_t *length, *atom1, *atom2, *spring_constant, *sdf_type;
atom1 = json_object_get(bond, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for bond %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->bonds[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].nbonds)++;
atom2 = json_object_get(bond, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for bond %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->bonds[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].nbonds)++;
length = json_object_get(bond, "length");
if (!json_is_real(length)) {
fprintf(stderr,
"json length is not floating point for bond %zd in json_file %s\n",
i, json_file);
}
ag->bonds[i].l0 = json_real_value(length);
spring_constant = json_object_get(bond, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for bond %zd in json_file %s\n",
i, json_file);
}
ag->bonds[i].k = json_real_value(spring_constant);
sdf_type = json_object_get(bond, "sdf_type");
if (sdf_type != NULL) {
if (!json_is_integer(sdf_type)) {
fprintf(stderr,
"json sdf_type is not integer for bond %zd in json_file %s\n",
i, json_file);
}
ag->bonds[i].sdf_type = json_integer_value(sdf_type);
} else {
ag->bonds[i].sdf_type = 0;
}
}
angles = json_object_get(base, "angles");
if (!json_is_array(angles)) {
fprintf(stderr, "json angles are not an array %s\n", json_file);
}
size_t nangles = json_array_size(angles);
ag->nangs = nangles;
ag->angs = _mol_calloc(nangles, sizeof(struct atomangle));
for (size_t i = 0; i < nangles; i++) {
json_t *angle = json_array_get(angles, i);
if (!json_is_object(angle)) {
fprintf(stderr,
"Angle %zd not an object in json file %s\n", i,
json_file);
}
json_t *theta, *atom1, *atom2, *atom3, *spring_constant;
atom1 = json_object_get(angle, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for angle %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->angs[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].nangs)++;
atom2 = json_object_get(angle, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for angle %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->angs[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].nangs)++;
atom3 = json_object_get(angle, "atom3");
if (!json_is_integer(atom3)) {
fprintf(stderr,
"json atom3 is not integer for angle %zd in json_file %s\n",
i, json_file);
}
int i3 = json_integer_value(atom3) - 1;
ag->angs[i].a2 = &(ag->atoms[i3]);
(ag->atoms[i3].nangs)++;
theta = json_object_get(angle, "theta");
if (!json_is_real(theta)) {
fprintf(stderr,
"json theta is not floating point for angle %zd in json_file %s\n",
i, json_file);
}
ag->angs[i].th0 = json_real_value(theta);
spring_constant = json_object_get(angle, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for angle %zd in json_file %s\n",
i, json_file);
}
ag->angs[i].k = json_real_value(spring_constant);
}
torsions = json_object_get(base, "torsions");
if (!json_is_array(torsions)) {
fprintf(stderr, "json torsions are not an array %s\n",
json_file);
}
size_t ntorsions = json_array_size(torsions);
ag->ntors = ntorsions;
ag->tors = _mol_calloc(ntorsions, sizeof(struct atomtorsion));
for (size_t i = 0; i < ntorsions; i++) {
json_t *torsion = json_array_get(torsions, i);
if (!json_is_object(torsion)) {
fprintf(stderr,
"Torsion %zd not an object in json file %s\n",
i, json_file);
}
json_t *atom1, *atom2, *atom3, *atom4, *minima, *delta_constant,
*spring_constant;
atom1 = json_object_get(torsion, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->tors[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].ntors)++;
atom2 = json_object_get(torsion, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->tors[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].ntors)++;
atom3 = json_object_get(torsion, "atom3");
if (!json_is_integer(atom3)) {
fprintf(stderr,
"json atom3 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i3 = json_integer_value(atom3) - 1;
ag->tors[i].a2 = &(ag->atoms[i3]);
(ag->atoms[i3].ntors)++;
atom4 = json_object_get(torsion, "atom4");
if (!json_is_integer(atom4)) {
fprintf(stderr,
"json atom4 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i4 = json_integer_value(atom4) - 1;
ag->tors[i].a3 = &(ag->atoms[i4]);
(ag->atoms[i4].ntors)++;
minima = json_object_get(torsion, "minima");
if (!json_is_integer(minima)) {
fprintf(stderr,
"json minima is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
ag->tors[i].n = json_integer_value(minima);
delta_constant = json_object_get(torsion, "delta_constant");
if (!json_is_real(delta_constant)) {
fprintf(stderr,
"json delta_constant is not floating point for torsion %zd in json_file %s\n",
i, json_file);
}
ag->tors[i].d = json_real_value(delta_constant);
spring_constant = json_object_get(torsion, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for torsion %zd in json_file %s\n",
i, json_file);
}
ag->tors[i].k = json_real_value(spring_constant);
}
impropers = json_object_get(base, "impropers");
if (!json_is_array(impropers)) {
fprintf(stderr, "json impropers are not an array %s\n",
json_file);
}
size_t nimpropers = json_array_size(impropers);
ag->nimps = nimpropers;
ag->imps = _mol_calloc(nimpropers, sizeof(struct atomimproper));
for (size_t i = 0; i < nimpropers; i++) {
json_t *improper = json_array_get(impropers, i);
if (!json_is_object(improper)) {
fprintf(stderr,
"Improper %zd not an object in json file %s\n",
i, json_file);
}
json_t *atom1, *atom2, *atom3, *atom4, *phi, *spring_constant;
atom1 = json_object_get(improper, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->imps[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].nimps)++;
atom2 = json_object_get(improper, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->imps[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].nimps)++;
atom3 = json_object_get(improper, "atom3");
if (!json_is_integer(atom3)) {
fprintf(stderr,
"json atom3 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i3 = json_integer_value(atom3) - 1;
ag->imps[i].a2 = &(ag->atoms[i3]);
(ag->atoms[i3].nimps)++;
atom4 = json_object_get(improper, "atom4");
if (!json_is_integer(atom4)) {
fprintf(stderr,
"json atom4 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i4 = json_integer_value(atom4) - 1;
ag->imps[i].a3 = &(ag->atoms[i4]);
(ag->atoms[i4].nimps)++;
phi = json_object_get(improper, "phi");
if (!json_is_real(phi)) {
fprintf(stderr,
"json phi is not floating point for improper %zd in json_file %s\n",
i, json_file);
}
ag->imps[i].psi0 = json_real_value(phi);
spring_constant = json_object_get(improper, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for improper %zd in json_file %s\n",
i, json_file);
}
ag->imps[i].k = json_real_value(spring_constant);
}
json_decref(base);
//allocate atom arrays of pointers to parameters
for (size_t i = 0; i < natoms; i++) {
int i1 = ag->atoms[i].nbonds;
ag->atoms[i].bonds = _mol_calloc(i1, sizeof(struct atombond *));
ag->atoms[i].nbonds = 0;
i1 = ag->atoms[i].nangs;
ag->atoms[i].angs = _mol_calloc(i1, sizeof(struct atomangle *));
ag->atoms[i].nangs = 0;
i1 = ag->atoms[i].ntors;
ag->atoms[i].tors =
_mol_calloc(i1, sizeof(struct atomtorsion *));
ag->atoms[i].ntors = 0;
i1 = ag->atoms[i].nimps;
ag->atoms[i].imps =
_mol_calloc(i1, sizeof(struct atomimproper *));
ag->atoms[i].nimps = 0;
}
struct atom *atm;
//fill bonds
for (int i = 0; i < ag->nbonds; i++) {
atm = ag->bonds[i].a0;
atm->bonds[(atm->nbonds)++] = &(ag->bonds[i]);
atm = ag->bonds[i].a1;
atm->bonds[(atm->nbonds)++] = &(ag->bonds[i]);
}
//fill angles
for (int i = 0; i < ag->nangs; i++) {
atm = ag->angs[i].a0;
atm->angs[(atm->nangs)++] = &(ag->angs[i]);
atm = ag->angs[i].a1;
atm->angs[(atm->nangs)++] = &(ag->angs[i]);
atm = ag->angs[i].a2;
atm->angs[(atm->nangs)++] = &(ag->angs[i]);
}
//fill torsions
for (int i = 0; i < ag->ntors; i++) {
atm = ag->tors[i].a0;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
atm = ag->tors[i].a1;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
atm = ag->tors[i].a2;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
atm = ag->tors[i].a3;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
}
//fill impropers
for (int i = 0; i < ag->nimps; i++) {
atm = ag->imps[i].a0;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
atm = ag->imps[i].a1;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
atm = ag->imps[i].a2;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
atm = ag->imps[i].a3;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
}
//atom indices in the group
fill_ingrp(ag);
ag->is_psf_read = true;
// copy vals from deprecated to new data structures
int atomsi;
for (atomsi = 0; atomsi < ag->natoms; atomsi++) {
_mol_atom_create_bond_indices(&ag->atoms[atomsi],
ag->atoms[atomsi].nbonds);
}
_mol_atom_group_copy_from_deprecated(ag);
return ag;
}
int VtFile_clusters(struct VtFile *file_scan, const char *cluster_date,
void (*cb)(json_t *cluster_json, void *data), void *user_data) {
CURL *curl;
CURLcode res;
int ret = 0;
json_t *resp_json = NULL;
long http_response_code = 0;
char url[1024];
if (!cluster_date || !cluster_date[0]) {
VT_ERROR("search cluster_date can not be empty\n");
return -1;
}
VtApiPage_resetBuffer((struct VtApiPage *) file_scan);
curl = curl_easy_init();
if (!curl) {
VT_ERROR("init curl\n");
goto cleanup;
}
snprintf(url, sizeof(url) - 1 , VT_API_BASE_URL "file/clusters?apikey=%s&date=%s",
file_scan->api_key, cluster_date);
// DBG(1, "URL=%s \n", url);
curl_easy_setopt(curl, CURLOPT_URL, url);
set_std_curl_data(file_scan, curl);
/* Perform the request, res will get the return code */
res = curl_easy_perform(curl);
DBG(1, "Perform done\n");
/* Check for errors */
if(res != CURLE_OK) {
VT_ERROR("curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
ret = res;
goto cleanup;
} else {
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_response_code);
if (http_response_code != 200) {
VT_ERROR("HTTP Response code: %ld\n", http_response_code);
ret = http_response_code;
goto cleanup;
}
}
DBG(1, "Page:\n%s\n",file_scan->buffer);
if (file_scan->response)
VtResponse_put(&file_scan->response);
file_scan->response = VtResponse_new();
ret = VtResponse_fromJSONstr(file_scan->response, file_scan->buffer);
if (ret) {
VT_ERROR("Parsing JSON\n");
goto cleanup;
}
resp_json = VtResponse_getJanssonObj(file_scan->response);
if (resp_json) {
json_t *offset_json = json_object_get(resp_json, "offset");
if (json_is_string(offset_json)) {
VtFile_setOffset(file_scan, json_string_value(offset_json));
}
}
if (cb && resp_json) {
json_t *clusters_json = json_object_get(resp_json, "clusters");
unsigned int index;
json_t *cl_json = NULL;
if (!clusters_json || !json_is_array(clusters_json)) {
goto cleanup;
}
json_array_foreach(clusters_json, index, cl_json) {
if (!json_is_object(cl_json)) {
VT_ERROR("not valid object\n");
continue;
}
cb(cl_json, user_data);
}
}
int VtFile_search(struct VtFile *file_scan, const char *query,
void (*cb)(const char *resource, void *data),
void *user_data) {
CURL *curl;
CURLcode res;
int ret = 0;
json_t *resp_json = NULL;
struct curl_httppost *formpost=NULL;
struct curl_httppost *lastptr=NULL;
struct curl_slist *headerlist=NULL;
static const char header_buf[] = "Expect:";
long http_response_code = 0;
if (!query || !query[0]) {
VT_ERROR("search query can not be empty\n");
return -1;
}
VtApiPage_resetBuffer((struct VtApiPage *) file_scan);
curl = curl_easy_init();
if (!curl) {
VT_ERROR("init curl\n");
goto cleanup;
}
// initialize custom header list (stating that Expect: 100-continue is not wanted
headerlist = curl_slist_append(headerlist, header_buf);
DBG(1, "Api Key = '%s'\n", file_scan->api_key);
ret = curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, "query",
CURLFORM_COPYCONTENTS, query,
CURLFORM_END);
if (ret)
VT_ERROR("Adding qury %s\n", query);
ret = curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, "apikey",
CURLFORM_COPYCONTENTS, file_scan->api_key,
CURLFORM_END);
if (ret)
VT_ERROR("Adding key\n");
if (file_scan->offset) {
ret = curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, "offset",
CURLFORM_COPYCONTENTS, file_scan->offset,
CURLFORM_END);
if (ret)
VT_ERROR("Adding offset\n");
}
// DBG(1, "URL=%s \n", url);
curl_easy_setopt(curl, CURLOPT_URL, VT_API_BASE_URL "file/search");
set_std_curl_data(file_scan, curl);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost); // set form
/* Perform the request, res will get the return code */
res = curl_easy_perform(curl);
DBG(1, "Perform done\n");
/* Check for errors */
if(res != CURLE_OK) {
VT_ERROR("curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
ret = res;
goto cleanup;
} else {
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_response_code);
if (http_response_code != 200) {
VT_ERROR("HTTP Response code: %ld\n", http_response_code);
ret = http_response_code;
goto cleanup;
}
}
DBG(1, "Page:\n%s\n",file_scan->buffer);
if (file_scan->response)
VtResponse_put(&file_scan->response);
file_scan->response = VtResponse_new();
ret = VtResponse_fromJSONstr(file_scan->response, file_scan->buffer);
if (ret) {
VT_ERROR("Parsing JSON\n");
goto cleanup;
}
resp_json = VtResponse_getJanssonObj(file_scan->response);
if (resp_json) {
json_t *offset_json = json_object_get(resp_json, "offset");
if (json_is_string(offset_json)) {
VtFile_setOffset(file_scan, json_string_value(offset_json));
}
}
if (cb && resp_json) {
json_t *hashes_json = json_object_get(resp_json, "hashes");
unsigned int index;
json_t *hash_obj;
json_t *offset_json = json_object_get(resp_json, "offset");
if (offset_json && json_is_string(offset_json)
&& json_string_value(offset_json) && json_string_value(offset_json)[0]) {
VtFile_setOffset(file_scan, json_string_value(offset_json));
}
if (!hashes_json || !json_is_array(hashes_json)) {
VT_ERROR("Parse error: hashes\n");
goto cleanup;
}
json_array_foreach(hashes_json, index, hash_obj) {
if (!json_is_string(hash_obj)) {
VT_ERROR("hash is not string\n");
continue;
}
cb(json_string_value(hash_obj), user_data);
}
}
/*====================================================================
* 函数名 : vGenRegSrvMsg
* 功能 : 生成服务器注册消息
* 算法实现 :
* 参数说明 : nFlag 标志物理或逻辑服务器
* nIdx base索引
* 返回值说明:
* 成功 生成的注册消息
* 失败 NULL
* ----------------------------------------------------------------------
* 修改记录:
* 日 期 版本 修改人 走读人 修改记录
* 2015/1/14 v1.0 YLI 创建
* ====================================================================*/
json_t *vGenRegSrvMsg(int nFlag,int nIdx)
{
json_t *root;
json_t *jt;
json_t *srv_info;
char saBuf[100];
char saCfgPath[L_PATH_MAX_LEN];
int n,m;
memset(saBuf,0x00,sizeof saBuf);
memset(saCfgPath,0x00,sizeof saCfgPath);
srand((unsigned)time(NULL));
root = json_object();
//devid
if (nFlag == F_PHY_FLAG) //phy srv
{
sprintf(saBuf,"11%d",_gstrpPid[nIdx].nPhyCount);
}
else if (nFlag == F_LOGIC_FLAG) //logic srv
{
memset(saBuf,0x00,sizeof saBuf);
//vLogNM(EL_DEBUG,"phy.log","phy count [%d] [%d]",_gstrpShm->rc.nPhyNum,_gstrpPid[nIdx].nPhyCount);
vLogNM(EL_ERR,"phy.log","phy count [%d] [%d]",_gstrpShm->rc.nPhyNum,_gstrpPid[nIdx].nPhyCount);
if (_gstrpPid[nIdx].nPhyCount == 0)
{
json_decref(root);
vLogErr("phy server is not exist !!!!");
return NULL;
}
n = rand() % _gstrpPid[nIdx].nPhyCount;
//m = rand() % (_gstrpPid[nIdx].nLogicCount + 1);
sprintf(saBuf,"11%d%d",n,_gstrpPid[nIdx].nLogicCount);
}
else
{
json_decref(root);
vLogErr("devid generate error!!!");
return NULL;
}
if (json_object_set(root,"devid",
json_string(saBuf)) == FAILUER)
{
json_decref(root);
vLogErr("devid set error!!!");
return NULL;
}
//devtype
if(getenv("APP_PROFILE_PATH") == NULL)
{
json_decref(root);
vLogErr("devtypes config file path error,please check evn value!!!");
return NULL;
}
strcpy(saCfgPath,getenv("APP_PROFILE_PATH"));
strcat(saCfgPath,"/devtypes.json");
if (nFlag == F_PHY_FLAG)
{
jt = tPflGetJsonObj(saCfgPath,K_PHYTYPE_KEY);
}
else
{
jt = tPflGetJsonObj(saCfgPath,K_LOGICTYPE_KEY);
}
if (jt == NULL)
{
json_decref(root);
vLogErr("devtypes file open error,please check devtypes.json is exist!!!");
return NULL;
}
if (json_is_array(jt))
{
m = json_array_size(jt);
n = rand()%m;
if (json_object_set(root,"devtype",
json_array_get(jt,n)) == FAILUER)
{
json_decref(root);
vLogErr("devtype set error!!!");
return NULL;
}
}
json_decref(jt);
//eventid
if (json_object_set(root,"eventid",
json_string("EV_REG_REQ")) == FAILUER)
{
json_decref(root);
vLogErr("eventid set error!!!");
return NULL;
}
/*srv_info*/
srv_info = json_object();
//devip
json_object_set(srv_info,"devip",
json_string(_gstrpShm->rc.nSrvIP));
//devver
if (json_object_set(srv_info,"devver",
json_string("123")) == FAILUER)
{
json_decref(root);
vLogErr("devadpver set error!!!");
return NULL;
}
//devadpver
json_object_set(srv_info,"devadpver",json_string("123"));
//devname
json_object_set(srv_info,"devname",json_string("truelink"));
json_object_set(root,"srv_info",srv_info);
json_decref(srv_info);
return root;
}
/*
* get the key from the JWKs that corresponds with the key specified in the header
*/
static apr_byte_t oidc_proto_get_key_from_jwks(request_rec *r,
apr_jwt_header_t *jwt_hdr, json_t *j_jwks, const char *type,
apr_jwk_t **result) {
char *x5t = NULL;
apr_jwt_get_string(r->pool, &jwt_hdr->value, "x5t", &x5t);
oidc_debug(r, "search for kid \"%s\" or thumbprint x5t \"%s\"",
jwt_hdr->kid, x5t);
/* get the "keys" JSON array from the JWKs object */
json_t *keys = json_object_get(j_jwks, "keys");
if ((keys == NULL) || !(json_is_array(keys))) {
oidc_error(r, "\"keys\" array element is not a JSON array");
return FALSE;
}
int i;
for (i = 0; i < json_array_size(keys); i++) {
/* get the next element in the array */
json_t *elem = json_array_get(keys, i);
/* check that it is a JSON object */
if (!json_is_object(elem)) {
oidc_warn(r,
"\"keys\" array element is not a JSON object, skipping");
continue;
}
/* get the key type and see if it is the RSA type that we are looking for */
json_t *kty = json_object_get(elem, "kty");
if ((!json_is_string(kty))
|| (strcmp(json_string_value(kty), type) != 0))
continue;
/* see if we were looking for a specific kid, if not we'll return the first one found */
if ((jwt_hdr->kid == NULL) && (x5t == NULL)) {
oidc_debug(r, "no kid/x5t to match, return first key found");
apr_jwk_parse_json(r->pool, elem, NULL, result);
break;
}
/* we are looking for a specific kid, get the kid from the current element */
json_t *ekid = json_object_get(elem, "kid");
if ((ekid != NULL) && json_is_string(ekid) && (jwt_hdr->kid != NULL)) {
/* compare the requested kid against the current element */
if (apr_strnatcmp(jwt_hdr->kid, json_string_value(ekid)) == 0) {
oidc_debug(r, "found matching kid: \"%s\"", jwt_hdr->kid);
apr_jwk_parse_json(r->pool, elem, NULL, result);
break;
}
}
/* we are looking for a specific x5t, get the x5t from the current element */
json_t *ex5t = json_object_get(elem, "kid");
if ((ex5t != NULL) && json_is_string(ex5t) && (x5t != NULL)) {
/* compare the requested kid against the current element */
if (apr_strnatcmp(x5t, json_string_value(ex5t)) == 0) {
oidc_debug(r, "found matching x5t: \"%s\"", x5t);
apr_jwk_parse_json(r->pool, elem, NULL, result);
break;
}
}
}
return TRUE;
}
/* Call the simple functions not covered by other tests of the public API */
int main()
{
json_t *value;
value = json_integer(1);
if(json_typeof(value) != JSON_INTEGER)
fail("json_typeof failed");
if(json_is_object(value))
fail("json_is_object failed");
if(json_is_array(value))
fail("json_is_array failed");
if(json_is_string(value))
fail("json_is_string failed");
if(!json_is_integer(value))
fail("json_is_integer failed");
if(json_is_real(value))
fail("json_is_real failed");
if(!json_is_number(value))
fail("json_is_number failed");
if(json_is_true(value))
fail("json_is_true failed");
if(json_is_false(value))
fail("json_is_false failed");
if(json_is_boolean(value))
fail("json_is_boolean failed");
if(json_is_null(value))
fail("json_is_null failed");
json_decref(value);
value = json_string("foo");
if(!value)
fail("json_string failed");
if(strcmp(json_string_value(value), "foo"))
fail("invalid string value");
if(json_string_set(value, "bar"))
fail("json_string_set failed");
if(strcmp(json_string_value(value), "bar"))
fail("invalid string value");
json_decref(value);
value = json_string(NULL);
if(value)
fail("json_string(NULL) failed");
/* invalid UTF-8 */
value = json_string("a\xefz");
if(value)
fail("json_string(<invalid utf-8>) failed");
value = json_string_nocheck("foo");
if(!value)
fail("json_string_nocheck failed");
if(strcmp(json_string_value(value), "foo"))
fail("invalid string value");
if(json_string_set_nocheck(value, "bar"))
fail("json_string_set_nocheck failed");
if(strcmp(json_string_value(value), "bar"))
fail("invalid string value");
json_decref(value);
/* invalid UTF-8 */
value = json_string_nocheck("qu\xff");
if(!value)
fail("json_string_nocheck failed");
if(strcmp(json_string_value(value), "qu\xff"))
fail("invalid string value");
if(json_string_set_nocheck(value, "\xfd\xfe\xff"))
fail("json_string_set_nocheck failed");
if(strcmp(json_string_value(value), "\xfd\xfe\xff"))
fail("invalid string value");
json_decref(value);
value = json_integer(123);
if(!value)
fail("json_integer failed");
if(json_integer_value(value) != 123)
fail("invalid integer value");
if(json_number_value(value) != 123.0)
fail("invalid number value");
if(json_integer_set(value, 321))
fail("json_integer_set failed");
if(json_integer_value(value) != 321)
fail("invalid integer value");
if(json_number_value(value) != 321.0)
fail("invalid number value");
json_decref(value);
value = json_real(123.123);
if(!value)
fail("json_real failed");
if(json_real_value(value) != 123.123)
fail("invalid integer value");
if(json_number_value(value) != 123.123)
fail("invalid number value");
if(json_real_set(value, 321.321))
fail("json_real_set failed");
if(json_real_value(value) != 321.321)
fail("invalid real value");
if(json_number_value(value) != 321.321)
fail("invalid number value");
json_decref(value);
value = json_true();
if(!value)
fail("json_true failed");
json_decref(value);
value = json_false();
if(!value)
fail("json_false failed");
json_decref(value);
value = json_null();
if(!value)
fail("json_null failed");
json_decref(value);
/* Test reference counting on singletons (true, false, null) */
value = json_true();
if(value->refcount != (size_t)-1)
fail("refcounting true works incorrectly");
json_decref(value);
if(value->refcount != (size_t)-1)
fail("refcounting true works incorrectly");
json_incref(value);
if(value->refcount != (size_t)-1)
fail("refcounting true works incorrectly");
value = json_false();
if(value->refcount != (size_t)-1)
fail("refcounting false works incorrectly");
json_decref(value);
if(value->refcount != (size_t)-1)
fail("refcounting false works incorrectly");
json_incref(value);
if(value->refcount != (size_t)-1)
fail("refcounting false works incorrectly");
value = json_null();
if(value->refcount != (size_t)-1)
fail("refcounting null works incorrectly");
json_decref(value);
if(value->refcount != (size_t)-1)
fail("refcounting null works incorrectly");
json_incref(value);
if(value->refcount != (size_t)-1)
fail("refcounting null works incorrectly");
return 0;
}
/*
* based on an account name, perform OpenID Connect Provider Issuer Discovery to find out the issuer and obtain and store its metadata
*/
apr_byte_t oidc_proto_account_based_discovery(request_rec *r, oidc_cfg *cfg,
const char *acct, char **issuer) {
// TODO: maybe show intermediate/progress screen "discovering..."
oidc_debug(r, "enter, acct=%s", acct);
const char *resource = apr_psprintf(r->pool, "acct:%s", acct);
const char *domain = strrchr(acct, '@');
if (domain == NULL) {
oidc_error(r, "invalid account name");
return FALSE;
}
domain++;
const char *url = apr_psprintf(r->pool, "https://%s/.well-known/webfinger",
domain);
apr_table_t *params = apr_table_make(r->pool, 1);
apr_table_addn(params, "resource", resource);
apr_table_addn(params, "rel", "http://openid.net/specs/connect/1.0/issuer");
const char *response = NULL;
if (oidc_util_http_get(r, url, params, NULL, NULL,
cfg->provider.ssl_validate_server, &response,
cfg->http_timeout_short, cfg->outgoing_proxy) == FALSE) {
/* errors will have been logged by now */
return FALSE;
}
/* decode and see if it is not an error response somehow */
json_t *j_response = NULL;
if (oidc_util_decode_json_and_check_error(r, response, &j_response) == FALSE)
return FALSE;
/* get the links parameter */
json_t *j_links = json_object_get(j_response, "links");
if ((j_links == NULL) || (!json_is_array(j_links))) {
oidc_error(r, "response JSON object did not contain a \"links\" array");
json_decref(j_response);
return FALSE;
}
/* get the one-and-only object in the "links" array */
json_t *j_object = json_array_get(j_links, 0);
if ((j_object == NULL) || (!json_is_object(j_object))) {
oidc_error(r,
"response JSON object did not contain a JSON object as the first element in the \"links\" array");
json_decref(j_response);
return FALSE;
}
/* get the href from that object, which is the issuer value */
json_t *j_href = json_object_get(j_object, "href");
if ((j_href == NULL) || (!json_is_string(j_href))) {
oidc_error(r,
"response JSON object did not contain a \"href\" element in the first \"links\" array object");
json_decref(j_response);
return FALSE;
}
*issuer = apr_pstrdup(r->pool, json_string_value(j_href));
oidc_debug(r,
"returning issuer \"%s\" for account \"%s\" after doing successful webfinger-based discovery",
*issuer, acct);
json_decref(j_response);
return TRUE;
}
/*
* check to see if JSON provider metadata is valid
*/
static apr_byte_t oidc_metadata_provider_is_valid(request_rec *r,
json_t *j_provider, const char *issuer) {
/* get the "issuer" from the provider metadata and double-check that it matches what we looked for */
json_t *j_issuer = json_object_get(j_provider, "issuer");
if ((j_issuer == NULL) || (!json_is_string(j_issuer))) {
oidc_error(r,
"provider (%s) JSON metadata did not contain an \"issuer\" string",
issuer);
return FALSE;
}
/* check that the issuer matches */
if (issuer != NULL) {
if (oidc_util_issuer_match(issuer, json_string_value(j_issuer)) == FALSE) {
oidc_warn(r,
"requested issuer (%s) does not match the \"issuer\" value in the provider metadata file: %s",
issuer, json_string_value(j_issuer));
//return FALSE;
}
}
/* verify that the provider supports the a flow that we implement */
json_t *j_response_types_supported = json_object_get(j_provider,
"response_types_supported");
if ((j_response_types_supported != NULL)
&& (json_is_array(j_response_types_supported))) {
int i = 0;
for (i = 0; i < json_array_size(j_response_types_supported); i++) {
json_t *elem = json_array_get(j_response_types_supported, i);
if (!json_is_string(elem)) {
oidc_error(r,
"unhandled in-array JSON non-string object type [%d]",
elem->type);
continue;
}
if (oidc_proto_flow_is_supported(r->pool, json_string_value(elem)))
break;
}
if (i == json_array_size(j_response_types_supported)) {
oidc_warn(r,
"could not find a supported response type in provider metadata (%s) for entry \"response_types_supported\"; assuming that \"code\" flow is supported...",
issuer);
//return FALSE;
}
} else {
oidc_warn(r,
"provider (%s) JSON metadata did not contain a \"response_types_supported\" array; assuming that \"code\" flow is supported...",
issuer);
// TODO: hey, this is required-by-spec stuff right?
}
/* verify that the provider supports a response_mode that we implement */
json_t *response_modes_supported = json_object_get(j_provider,
"response_modes_supported");
if ((response_modes_supported != NULL)
&& (json_is_array(response_modes_supported))) {
int i = 0;
for (i = 0; i < json_array_size(response_modes_supported); i++) {
json_t *elem = json_array_get(response_modes_supported, i);
if (!json_is_string(elem)) {
oidc_error(r,
"unhandled in-array JSON non-string object type [%d]",
elem->type);
continue;
}
if ((apr_strnatcmp(json_string_value(elem), "fragment") == 0)
|| (apr_strnatcmp(json_string_value(elem), "query") == 0)
|| (apr_strnatcmp(json_string_value(elem), "form_post") == 0))
break;
}
if (i == json_array_size(response_modes_supported)) {
oidc_warn(r,
"could not find a supported response mode in provider metadata (%s) for entry \"response_modes_supported\"",
issuer);
return FALSE;
}
} else {
oidc_debug(r,
"provider (%s) JSON metadata did not contain a \"response_modes_supported\" array; assuming that \"fragment\" and \"query\" are supported",
issuer);
}
/* check the required authorization endpoint */
if (oidc_metadata_is_valid_uri(r, "provider", issuer, j_provider,
"authorization_endpoint", TRUE) == FALSE)
return FALSE;
/* check the optional token endpoint */
if (oidc_metadata_is_valid_uri(r, "provider", issuer, j_provider,
"token_endpoint", FALSE) == FALSE)
return FALSE;
/* check the optional user info endpoint */
if (oidc_metadata_is_valid_uri(r, "provider", issuer, j_provider,
"userinfo_endpoint", FALSE) == FALSE)
return FALSE;
/* check the optional JWKs URI */
if (oidc_metadata_is_valid_uri(r, "provider", issuer, j_provider,
"jwks_uri", FALSE) == FALSE)
return FALSE;
/* find out what type of authentication the token endpoint supports (we only support post or basic) */
json_t *j_token_endpoint_auth_methods_supported = json_object_get(
j_provider, "token_endpoint_auth_methods_supported");
if ((j_token_endpoint_auth_methods_supported == NULL)
|| (!json_is_array(j_token_endpoint_auth_methods_supported))) {
oidc_debug(r,
"provider (%s) JSON metadata did not contain a \"token_endpoint_auth_methods_supported\" array, assuming \"client_secret_basic\" is supported",
issuer);
} else {
int i;
for (i = 0;
i < json_array_size(j_token_endpoint_auth_methods_supported);
i++) {
json_t *elem = json_array_get(
j_token_endpoint_auth_methods_supported, i);
if (!json_is_string(elem)) {
oidc_warn(r,
"unhandled in-array JSON object type [%d] in provider (%s) metadata for entry \"token_endpoint_auth_methods_supported\"",
elem->type, issuer);
continue;
}
if (strcmp(json_string_value(elem), "client_secret_post") == 0) {
break;
}
if (strcmp(json_string_value(elem), "client_secret_basic") == 0) {
break;
}
}
if (i == json_array_size(j_token_endpoint_auth_methods_supported)) {
oidc_error(r,
"could not find a supported value [client_secret_post|client_secret_basic] in provider (%s) metadata for entry \"token_endpoint_auth_methods_supported\"",
issuer);
return FALSE;
}
}
return TRUE;
}
bool Json::isArray() const {
return json_is_array(m_json) > 0;
}
static void
ccmd_set_option(json_t * params)
{
const char *optname, *optstr, *pattern;
json_t *jmsg, *joval, *jopt;
int isstr, i, ret;
const struct nh_option_desc *gameopt, *birthopt, *option;
union nh_optvalue value;
struct nh_autopickup_rules ar = { NULL, 0 };
struct nh_autopickup_rule *r;
if (json_unpack
(params, "{ss,so,si*}", "name", &optname, "value", &joval, "isstr",
&isstr) == -1)
exit_client("Bad parameters for set_option");
/* find the option_desc for the options that should be set; the option type
is required in order to decode the option value. */
gameopt = nh_get_options(GAME_OPTIONS);
birthopt =
nh_get_options(gameid ? ACTIVE_BIRTH_OPTIONS : CURRENT_BIRTH_OPTIONS);
option = find_option(optname, gameopt, birthopt);
if (!option) {
jmsg = json_pack("{si,so}", "return", FALSE, "option", json_object());
client_msg("set_option", jmsg);
return;
}
/* decode the option value depending on the option type */
if (isstr || option->type == OPTTYPE_STRING) {
if (!json_is_string(joval))
exit_client("could not decode option string");
value.s = (char *)json_string_value(joval);
} else if (option->type == OPTTYPE_INT || option->type == OPTTYPE_ENUM ||
option->type == OPTTYPE_BOOL) {
if (!json_is_integer(joval))
exit_client("could not decode option value");
value.i = json_integer_value(joval);
} else if (option->type == OPTTYPE_AUTOPICKUP_RULES) {
if (!json_is_array(joval))
exit_client("could not decode option");
ar.num_rules = json_array_size(joval);
ar.rules = malloc(sizeof (struct nh_autopickup_rule) * ar.num_rules);
if (ar.num_rules) {
value.ar = &ar;
for (i = 0; i < ar.num_rules; i++) {
r = &ar.rules[i];
if (json_unpack
(json_array_get(joval, i), "{ss,si,si,si}", "pattern",
&pattern, "oclass", &r->oclass, "buc", &r->buc, "action",
&r->action) == -1)
exit_client("Error unpacking autopickup rule");
strncpy(r->pattern, pattern, sizeof (r->pattern) - 1);
}
} else
value.ar = NULL;
}
ret = nh_set_option(optname, value, isstr);
if (option->type == OPTTYPE_AUTOPICKUP_RULES)
free(ar.rules);
gameopt = nh_get_options(GAME_OPTIONS);
birthopt =
nh_get_options(gameid ? ACTIVE_BIRTH_OPTIONS : CURRENT_BIRTH_OPTIONS);
option = find_option(optname, gameopt, birthopt);
jopt = json_option(option);
optstr = nh_get_option_string(option);
if (ret == TRUE)
db_set_option(user_info.uid, optname, option->type, optstr);
/* return the altered option struct and the string representation to the
client. The intent is to save some network round trips and make a
separate get_option_string message unneccessary */
jmsg = json_pack("{si,so}", "return", ret, "option", jopt);
client_msg("set_option", jmsg);
}
/*====================================================================
* 函数名 : vGenRegTermMsg
* 功能 : 生成终端注册消息
* 算法实现 :
* 参数说明 :
* nIdx 标识是哪个的base
* 返回值说明: 成功 生成的json字符串
* 失败 NULL
* ----------------------------------------------------------------------
* 修改记录:
* 日 期 版本 修改人 走读人 修改记录
* 2015/1/13 v1.0 YLI 创建
* ====================================================================*/
json_t *vGenRegTermMsg(int nIdx)
{
json_t *root;
json_t *mt_info;
json_t *netinfo;
json_t *aps_addr;
json_t *jt;
const char *key;
json_t *value;
int n,size;
char saCfgPath[L_PATH_MAX_LEN];
char tmp[100];
root = json_object();
memset(tmp,0x00,sizeof tmp);
memset(saCfgPath,0x00,sizeof saCfgPath);
srand((unsigned)time(NULL));
//set eventid
if (json_object_set(root,"eventid",
json_string("EV_REG_REQ")) == FAILUER)
{
json_decref(root);
vLogErr("eventid set error!!!");
return NULL;
}
//devid
n = rand() % (S_RAND_RANG + _gstrpPid[nIdx].nTermCount);
sprintf(tmp,"1.2.%02d",n);
if (json_object_set(root,"devid",
json_string(tmp)) == FAILUER)
{
json_decref(root);
vLogErr("devid set error!!!");
return NULL;
}
//devtype
if(getenv("APP_PROFILE_PATH") == NULL)
{
json_decref(root);
vLogErr("devtypes config file path error,please check evn value!!!");
return NULL;
}
strcpy(saCfgPath,getenv("APP_PROFILE_PATH"));
strcat(saCfgPath,"/devtypes.json");
jt = tPflGetJsonObj(saCfgPath,K_DEVTYPE_KEY);
if (jt == NULL)
{
json_decref(root);
vLogErr("devtypes file open error,please check devtypes.json is exist!!!");
return NULL;
}
if (json_is_array(jt))
{
size = json_array_size(jt);
n = rand()%size;
if (json_object_set(root,"devtype",
json_array_get(jt,n)) == FAILUER)
{
json_decref(root);
vLogErr("devtype set error!!!");
return NULL;
}
}
/*mt_info*/
mt_info = json_object();
//devver
if (json_object_set(mt_info,"devver",
json_string("123")) == FAILUER)
{
json_decref(root);
vLogErr("devver set error!!!");
return NULL;
}
//devname
json_object_set(mt_info,"devname",json_string("truelink"));
//netinfo
netinfo = json_object();
json_object_set(netinfo,"ip",
json_string(_gstrpShm->rc.nSrvIP));
json_object_set(netinfo,"dns",
json_string("172.16.0.65"));
json_object_set(mt_info,"netinfo",netinfo);
//aps_addr
aps_addr = json_object();
json_object_set(aps_addr,"domain",
json_string("fdaf"));
json_object_set(aps_addr,"ip",
json_string(_gstrpShm->rc.nSrvIP));
json_object_set(mt_info,"aps_addr",aps_addr);
//oem
json_object_set(mt_info,"oem",json_string("dfd"));
//os
json_object_set(mt_info,"os",json_string("Centos 6.4"));
//cpu_num
json_object_set(mt_info,"cpu_num",json_integer(4));
//cpu_type
//cpu_freq
json_decref(jt);
jt = GetCpuInfo();
json_object_foreach(jt,key,value)
{
if(strncmp(key,"cpuMHz",6) == 0)
{
json_object_set(mt_info,"cpu_freq",value);
}
if (strncmp(key,"modelname",9) == 0)
{
json_object_set(mt_info,"cpu_type",value);
}
}
json_decref(jt);
jt = GetMemInfo();
//memory
json_object_foreach(jt,key,value)
{
if(strncmp(key,"MemTotal",8) == 0)
{
json_object_set(mt_info,"memory",value);
}
}
json_object_set(root,"mt_info",mt_info);
json_decref(mt_info);
return root;
}
