json_value* GetApplicationSettings() {
static json_value* ret = new json_value();
static bool settings_fetched = false;
if (settings_fetched)
return ret;
settings_fetched = true;
LOG_DEBUG << "Fetching settings from settings.json file";
std::string settingsFile = GetExecutableDirectory() + "\\settings.json";
std::string contents = GetFileContents(settingsFile);
if (contents.empty()) {
LOG_WARNING << "Error opening settings.json file";
return ret;
}
json_settings settings;
memset(&settings, 0, sizeof(json_settings));
char error[256];
json_value* json_parsed = json_parse_ex(&settings, contents.c_str(),
&error[0]);
if (json_parsed == 0) {
LOG_WARNING << "Error while parsing settings.json file: " << error;
return ret;
}
ret = json_parsed;
return ret;
}
int
main()
{
char* cfgtext = slurp("silo.cfg");
char* err = calloc(2048, sizeof(char));
json_settings settings = { 0 };
json_value* js = json_parse_ex(&settings, cfgtext, strlen(cfgtext), err);
free(cfgtext);
if(js == NULL) {
ERR(silo, "Parse error: %s", err);
free(err);
return 1;
}
TRACE(silo, "type: %d", js->type);
TRACE(silo, "none (%d), obj (%d), array (%d), integer (%d), double (%d), "
"string (%d), bool (%d), null (%d)", json_none, json_object,
json_array, json_integer, json_double, json_string, json_boolean,
json_null);
size_t ndims;
size_t* dimens = js_dimensions(js, &ndims);
printf("dtype: %d\n", (int)js_datatype(js));
double** mycoords = js_coord_arrays(js, dimens, ndims);
assert(mycoords);
for(size_t i=0; i < ndims; ++i) { free(mycoords[i]); }
free(mycoords);
free(dimens);
free(err);
json_value_free(js);
return 0;
}
bool MJsonValue::ParseJson(const wchar_t* buffer)
{
if (mp_data)
{
FreeData();
}
json_settings setting = {};
setting.settings = json_enable_comments;
char errMsg[json_error_max] = "";
json_value* p = json_parse_ex(&setting, buffer, wcslen(buffer), errMsg);
if (p == NULL)
{
SafeFree(ms_Error);
size_t eLen = strlen(errMsg);
if (eLen)
{
ms_Error = (wchar_t*)malloc((eLen+1)*sizeof(*ms_Error));
if (ms_Error)
MultiByteToWideChar(CP_ACP, 0, errMsg, -1, ms_Error, eLen+1);
}
return false;
}
mb_Root = true;
mp_data = p;
return true;
}
TESTCASE(allow_trailing_comma, object_one_element) {
const char payload[] = "{\"foo\" : true, }";
struct json_value_s* value = json_parse_ex(payload, strlen(payload), json_parse_flags_allow_trailing_comma, 0, 0, 0);
struct json_object_s* object = 0;
ASSERT_TRUE(value);
ASSERT_EQ(json_type_object, value->type);
object = (struct json_object_s* )value->payload;
ASSERT_TRUE(object->start);
ASSERT_EQ(1, object->length);
ASSERT_TRUE(object->start->name->string);
ASSERT_STREQ("foo", (char* )object->start->name->string);
ASSERT_EQ(strlen("foo"), object->start->name->string_size);
ASSERT_EQ(strlen((char* )object->start->name->string), object->start->name->string_size);
ASSERT_TRUE(object->start->value);
ASSERT_FALSE(object->start->value->payload);
ASSERT_EQ(json_type_true, object->start->value->type);
ASSERT_FALSE(object->start->next);
free(value);
}
TESTCASE(allow_trailing_comma, array_two_elements) {
const char payload[] = "[ true, false, ]";
struct json_value_s* value = json_parse_ex(payload, strlen(payload), json_parse_flags_allow_trailing_comma, 0, 0, 0);
struct json_array_s* object = 0;
struct json_array_element_s* element = 0;
ASSERT_TRUE(value);
ASSERT_EQ(json_type_array, value->type);
object = (struct json_array_s* )value->payload;
ASSERT_TRUE(object->start);
ASSERT_EQ(2, object->length);
element = object->start;
ASSERT_TRUE(element->value);
ASSERT_FALSE(element->value->payload);
ASSERT_EQ(json_type_true, element->value->type);
element = element->next;
ASSERT_TRUE(element->value);
ASSERT_FALSE(element->value->payload);
ASSERT_EQ(json_type_false, element->value->type);
ASSERT_FALSE(element->next);
free(value);
}
static int parse_traffic(char *buf, int len, char *port, uint64_t *traffic)
{
char *data = get_data(buf, len);
char error_buf[512];
json_settings settings = { 0 };
if (data == NULL) {
LOGE("No data found");
return -1;
}
json_value *obj = json_parse_ex(&settings, data, strlen(data), error_buf);
if (obj == NULL) {
LOGE("%s", error_buf);
return -1;
}
if (obj->type == json_object) {
int i = 0;
for (i = 0; i < obj->u.object.length; i++) {
char *name = obj->u.object.values[i].name;
json_value *value = obj->u.object.values[i].value;
if (value->type == json_integer) {
strncpy(port, name, 8);
*traffic = value->u.integer;
}
}
}
json_value_free(obj);
return 0;
}
TESTCASE(allow_string_simplification, solidus) {
const char payload[] = "[ \"\\/\" ]";
struct json_value_s* value = json_parse_ex(payload, strlen(payload), json_parse_flags_allow_string_simplification, 0, 0, 0);
struct json_array_s* array = 0;
struct json_value_s* value2 = 0;
struct json_string_s* string = 0;
ASSERT_TRUE(value);
ASSERT_TRUE(value->payload);
ASSERT_EQ(json_type_array, value->type);
array = (struct json_array_s* )value->payload;
ASSERT_TRUE(array->start);
ASSERT_EQ(1, array->length);
ASSERT_TRUE(array->start->value);
ASSERT_FALSE(array->start->next); // we have only one element
value2 = array->start->value;
ASSERT_TRUE(value2->payload);
ASSERT_EQ(json_type_string, value2->type);
string = (struct json_string_s* )value2->payload;
ASSERT_TRUE(string->string);
ASSERT_STREQ("/", string->string);
ASSERT_EQ(strlen("/"), string->string_size);
ASSERT_EQ(strlen(string->string), string->string_size);
free(value);
}
cx_json_tree cx_json_tree_create (const char *data, cxu32 size)
{
CX_ASSERT (data);
cx_json_tree_internal *tree = NULL;
json_settings settings;
memset (&settings, 0, sizeof(settings));
char errorBuffer [512];
json_value *root = json_parse_ex (&settings, data, size, errorBuffer, 512);
if (root)
{
tree = cx_malloc (sizeof (cx_json_tree_internal));
tree->root = root;
}
CX_LOG_CONSOLE (CX_JSON_DEBUG_LOG_ENABLED && (root == NULL), errorBuffer);
return tree;
}
json_value * sut_json_load (const char * filename)
{
char * json;
if (!sut_load_file (filename, &json, 0))
{
fprintf (stderr, "Error loading JSON file: %s\n", filename);
return 0;
}
json_settings settings = {};
char json_error [128];
json_value * value;
if (! (value = json_parse_ex (&settings, json, json_error)))
{
fprintf (stderr, "Error parsing JSON: %s\n", json_error);
free (json);
return 0;
}
free (json);
return value;
}
static bool ParseJson( vlc_object_t *p_obj, char *psz_buffer, acoustid_results_t *p_results )
{
json_settings settings;
char psz_error[128];
memset (&settings, 0, sizeof (json_settings));
json_value *root = json_parse_ex( &settings, psz_buffer, psz_error );
if ( root == NULL )
{
msg_Warn( p_obj, "Can't parse json data: %s", psz_error );
goto error;
}
if ( root->type != json_object )
{
msg_Warn( p_obj, "wrong json root node" );
goto error;
}
json_value *node = jsongetbyname( root, "status" );
if ( !node || node->type != json_string )
{
msg_Warn( p_obj, "status node not found or invalid" );
goto error;
}
if ( strcmp( node->u.string.ptr, "ok" ) != 0 )
{
msg_Warn( p_obj, "Bad request status" );
goto error;
}
node = jsongetbyname( root, "results" );
if ( !node || node->type != json_array )
{
msg_Warn( p_obj, "Bad results array or no results" );
goto error;
}
p_results->p_results = calloc( node->u.array.length, sizeof(acoustid_result_t) );
if ( ! p_results->p_results ) goto error;
p_results->count = node->u.array.length;
for( unsigned int i=0; i<node->u.array.length; i++ )
{
json_value *resultnode = node->u.array.values[i];
if ( resultnode && resultnode->type == json_object )
{
acoustid_result_t *p_result = & p_results->p_results[i];
json_value *value = jsongetbyname( resultnode, "score" );
if ( value && value->type == json_double )
p_result->d_score = value->u.dbl;
value = jsongetbyname( resultnode, "id" );
if ( value && value->type == json_string )
p_result->psz_id = strdup( value->u.string.ptr );
parse_recordings( p_obj, jsongetbyname( resultnode, "recordings" ), p_result );
}
}
json_value_free( root );
return true;
error:
if ( root ) json_value_free( root );
return false;
}
json_value &readFileToJSON(string filename) {
char *raw_text = readFileToCString(filename);
json_settings settings;
memset (&settings, 0, sizeof (json_settings));
char err[512];
json_value *json = json_parse_ex(&settings, raw_text, err);
if (json == NULL) {
error("Error parsing JSON in file %s.\n%s", filename.c_str(), err);
}
delete raw_text;
return *json;
}
TESTCASE(allow_trailing_comma, object_no_element) {
const char payload[] = "{,}";
struct json_parse_result_s result;
struct json_value_s* value = json_parse_ex(payload, strlen(payload), json_parse_flags_allow_trailing_comma, 0, 0, &result);
ASSERT_FALSE(value);
ASSERT_EQ(json_parse_error_invalid_string, result.error);
ASSERT_EQ(1, result.error_offset);
ASSERT_EQ(1, result.error_line_no);
ASSERT_EQ(1, result.error_row_no);
}
bool CLocalizationDatabase::Load(const char *pFilename, IStorage *pStorage, IConsole *pConsole)
{
// empty string means unload
if(pFilename[0] == 0)
{
m_Strings.clear();
m_CurrentVersion = 0;
return true;
}
// read file data into buffer
IOHANDLE File = pStorage->OpenFile(pFilename, IOFLAG_READ, IStorage::TYPE_ALL);
if(!File)
return false;
int FileSize = (int)io_length(File);
char *pFileData = (char *)mem_alloc(FileSize+1, 1);
io_read(File, pFileData, FileSize);
pFileData[FileSize] = 0;
io_close(File);
// init
char aBuf[64];
str_format(aBuf, sizeof(aBuf), "loaded '%s'", pFilename);
pConsole->Print(IConsole::OUTPUT_LEVEL_ADDINFO, "localization", aBuf);
m_Strings.clear();
// parse json data
json_settings JsonSettings;
mem_zero(&JsonSettings, sizeof(JsonSettings));
char aError[256];
json_value *pJsonData = json_parse_ex(&JsonSettings, pFileData, aError);
if(pJsonData == 0)
{
pConsole->Print(IConsole::OUTPUT_LEVEL_ADDINFO, pFilename, aError);
mem_free(pFileData);
return false;
}
// extract data
const json_value &rStart = (*pJsonData)["translated strings"];
if(rStart.type == json_array)
{
for(unsigned i = 0; i < rStart.u.array.length; ++i)
AddString((const char *)rStart[i]["or"], (const char *)rStart[i]["tr"]);
}
// clean up
json_value_free(pJsonData);
mem_free(pFileData);
m_CurrentVersion = ++m_VersionCounter;
return true;
}
bool Parse(const std::string& json, uint16_t& msgid, uint16_t& type) {
json_settings settings;
memset(&settings, 0, sizeof(json_settings));
char error_buf[512];
json_value* object = json_parse_ex(&settings, json.c_str(), error_buf);
if(object == NULL) {
std::cerr << error_buf << std::endl;
return false;
}
// check if its a valid object
if(object->type != json_object) {
json_value_free(object);
return false;
}
// get packet array
json_value packet = (*object)["packet"];
// set msgid (if available)
json_value id = (*object)["msgid"];
if(id.type != json_none) {
msgid = (long)id;
}
// set type (if available)
json_value t = (*object)["type"];
if(t.type != json_none) {
type = (long)t;
}
// iterate through array
for(int i = 0; ; i++) {
json_value o = packet[i];
if(o.type != json_object) {
break;
}
OnPacketData(o);
}
json_value_free(object);
return true;
}
static struct server *get_server(char *buf, int len)
{
char *data = get_data(buf, len);
char error_buf[512];
struct server *server = (struct server *)malloc(sizeof(struct server));
if (data == NULL) {
LOGE("No data found");
return NULL;
}
memset(server, 0, sizeof(struct server));
json_settings settings = { 0 };
json_value *obj = json_parse_ex(&settings, data, strlen(data), error_buf);
if (obj == NULL) {
LOGE("%s", error_buf);
return NULL;
}
if (obj->type == json_object) {
int i = 0;
for (i = 0; i < obj->u.object.length; i++) {
char *name = obj->u.object.values[i].name;
json_value *value = obj->u.object.values[i].value;
if (strcmp(name, "server_port") == 0) {
if (value->type == json_string) {
strncpy(server->port, value->u.string.ptr, 8);
} else if (value->type == json_integer) {
snprintf(server->port, 8, "%" PRIu64 "", value->u.integer);
}
} else if (strcmp(name, "password") == 0) {
if (value->type == json_string) {
strncpy(server->password, value->u.string.ptr, 128);
}
} else {
LOGE("invalid data: %s", data);
json_value_free(obj);
return NULL;
}
}
}
json_value_free(obj);
return server;
}
/**
* Creates a new #json_value from JSON data. The returned #json_value
* should be freed with #json_value_free() when no longer needed.
*
* @param data The JSON data.
* @param length The length of the JSON data.
* @param err The return location for a GError or NULL.
*
* @return The #json_value or NULL on error.
**/
json_value *steam_json_new(const gchar *data, gsize length, GError **err)
{
json_value *json;
json_settings js;
gchar *estr;
memset(&js, 0, sizeof js);
estr = g_new0(gchar, json_error_max);
json = json_parse_ex(&js, data, length, estr);
if ((json != NULL) && (strlen(estr) < 1)) {
g_free(estr);
return json;
}
g_set_error(err, STEAM_JSON_ERROR, STEAM_JSON_ERROR_PARSER,
"Parser: %s", estr);
g_free(estr);
return NULL;
}
TESTCASE(allow_equals_in_object, number) {
const char payload[] = "{\"foo\" = -0.123e-42}";
struct json_value_s* value = json_parse_ex(payload, strlen(payload), json_parse_flags_allow_equals_in_object, 0);
struct json_object_s* object = 0;
struct json_value_s* value2 = 0;
struct json_number_s* number = 0;
ASSERT_TRUE(value);
ASSERT_TRUE(value->payload);
ASSERT_EQ(json_type_object, value->type);
object = (struct json_object_s* )value->payload;
ASSERT_TRUE(object->start);
ASSERT_EQ(1, object->length);
ASSERT_TRUE(object->start->name);
ASSERT_TRUE(object->start->value);
ASSERT_FALSE(object->start->next); // we have only one element
ASSERT_TRUE(object->start->name->string);
ASSERT_STREQ("foo", object->start->name->string);
ASSERT_EQ(strlen("foo"), object->start->name->string_size);
ASSERT_EQ(strlen(object->start->name->string), object->start->name->string_size);
value2 = object->start->value;
ASSERT_TRUE(value2->payload);
ASSERT_EQ(json_type_number, value2->type);
number = (struct json_number_s* )value2->payload;
ASSERT_TRUE(number->number);
ASSERT_STREQ("-0.123e-42", number->number);
ASSERT_EQ(strlen("-0.123e-42"), number->number_size);
ASSERT_EQ(strlen(number->number), number->number_size);
free(value);
}
TESTCASE(allow_equals_in_object, string) {
const char payload[] = "{\"foo\" = \"Heyo, gaia?\"}";
struct json_value_s* value = json_parse_ex(payload, strlen(payload), json_parse_flags_allow_equals_in_object, 0);
struct json_object_s* object = 0;
struct json_value_s* value2 = 0;
struct json_string_s* string = 0;
ASSERT_TRUE(value);
ASSERT_TRUE(value->payload);
ASSERT_EQ(json_type_object, value->type);
object = (struct json_object_s* )value->payload;
ASSERT_TRUE(object->start);
ASSERT_EQ(1, object->length);
ASSERT_TRUE(object->start->name);
ASSERT_TRUE(object->start->value);
ASSERT_FALSE(object->start->next); // we have only one element
ASSERT_TRUE(object->start->name->string);
ASSERT_STREQ("foo", object->start->name->string);
ASSERT_EQ(strlen("foo"), object->start->name->string_size);
ASSERT_EQ(strlen(object->start->name->string), object->start->name->string_size);
value2 = object->start->value;
ASSERT_TRUE(value2->payload);
ASSERT_EQ(json_type_string, value2->type);
string = (struct json_string_s* )value2->payload;
ASSERT_TRUE(string->string);
ASSERT_STREQ("Heyo, gaia?", string->string);
ASSERT_EQ(strlen("Heyo, gaia?"), string->string_size);
ASSERT_EQ(strlen(string->string), string->string_size);
free(value);
}
void testcheckIfErrorOccured()
{
int errorCode = 0;
char *jsonFullPath = getFullFileName("tests/jsons/googleOauth2Access_invalidGrand.json");
char *fileContent = getFileContent(jsonFullPath, &errorCode);
CU_ASSERT_EQUAL_FATAL(errorCode, 0);
CU_ASSERT_PTR_NOT_NULL_FATAL(fileContent);
json_settings settings;
memset(&settings, 0, sizeof (json_settings));
char error[256];
json_value *value = json_parse_ex(&settings, fileContent, error);
CU_ASSERT_PTR_NOT_NULL_FATAL(value);
int return_value = checkIfErrorOccured(value);
CU_ASSERT_NOT_EQUAL(return_value, 0);
CU_ASSERT_EQUAL(return_value, INVALID_GRAND);
json_value_free(value);
}
bool load_config (strat_ctx ctx)
{
char * config_json;
if (!sut_load_file ("config.json", &config_json, 0))
{
fprintf (stderr, "Error loading configuration file\n");
return false;
}
json_settings settings = {};
char json_error [128];
if (! (ctx->config = json_parse_ex (&settings, config_json, json_error)))
{
fprintf (stderr, "Error parsing configuration file: %s\n", json_error);
free (config_json);
return false;
}
return true;
}
void testProcessIncomingAccessTokenResponse()
{
int errorCode = 0;
char *jsonFullPath = getFullFileName("tests/jsons/googleOauth2AccessTokenResponse_valid.json");
char *fileContent = getFileContent(jsonFullPath, &errorCode);
CU_ASSERT_EQUAL_FATAL(errorCode, 0);
CU_ASSERT_PTR_NOT_NULL_FATAL(fileContent);
json_settings settings;
memset(&settings, 0, sizeof (json_settings));
char error[256];
json_value *value = json_parse_ex(&settings, fileContent, error);
TokenResponse* result = processIncomingAccessTokenResponse(value);
CU_ASSERT_PTR_NOT_NULL_FATAL(result);
CU_ASSERT_STRING_EQUAL(result->access_token, "access_token_string");
CU_ASSERT_STRING_EQUAL(result->error_code, NO_ERROR);
CU_ASSERT_STRING_EQUAL(result->refresh_token, "refresh_token_string");
CU_ASSERT_STRING_EQUAL(result->token_type, "Bearer");
CU_ASSERT_EQUAL(result->expires_in, 3920);
json_value_free(value);
}
bstring get_signer_pubkey(bstring url)
{
CURL *curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_URL, url->data);
bstring result = bfromcstr("");
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, save_incoming_data);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, result);
bstring error = bfromcstralloc(CURL_ERROR_SIZE, "");
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, bdata(error));
CURLcode rc = curl_easy_perform(curl);
if (rc != CURLE_OK)
{
fprintf(stderr, "Error obtaining token: %s\n", bdata(error));
exit(1);
}
long response_code;
rc = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
if (rc != CURLE_OK)
{
fprintf(stderr, "Error obtaining response code\n");
return 0;
}
if (response_code == 403)
{
fprintf(stderr, "Permission denied.\n");
return 0;
}
if (response_code >= 300)
{
fprintf(stderr, "Invalid response code %ld from server\n", response_code);
return 0;
}
// printf("rc=%d '%s'\n", rc, result->data);
curl_easy_cleanup(curl);
curl = 0;
bdestroy(error);
json_settings settings = { 0 } ;
char json_error[json_error_max + 1];
json_value *ret = json_parse_ex(&settings, bdata(result), blength(result), json_error);
if (ret->type != json_object)
return 0;
int i;
bstring pubkey = 0;
for (i = 0; i < ret->u.object.length; i++)
{
if (strcmp(ret->u.object.values[i].name, "pubkey") == 0)
{
json_value *t = ret->u.object.values[i].value;
pubkey = bfromcstr(t->u.string.ptr);
}
}
json_value_free(ret);
bdestroy(result);
return pubkey;
}
int CMain::ReadConfig()
{
// read and parse config
IOHANDLE File = io_open(m_Config.m_aConfigFile, IOFLAG_READ);
if(!File)
{
dbg_msg("main", "Couldn't open %s", m_Config.m_aConfigFile);
return 1;
}
int FileSize = (int)io_length(File);
char *pFileData = (char *)mem_alloc(FileSize + 1, 1);
io_read(File, pFileData, FileSize);
pFileData[FileSize] = 0;
io_close(File);
// parse json data
json_settings JsonSettings;
mem_zero(&JsonSettings, sizeof(JsonSettings));
char aError[256];
json_value *pJsonData = json_parse_ex(&JsonSettings, pFileData, strlen(pFileData), aError);
if(!pJsonData)
{
dbg_msg("main", "JSON Error in file %s: %s", m_Config.m_aConfigFile, aError);
mem_free(pFileData);
return 1;
}
// reset clients
for(int i = 0; i < NET_MAX_CLIENTS; i++)
{
if(!Client(i)->m_Active || !Client(i)->m_Connected)
continue;
m_Server.Network()->Drop(Client(i)->m_ClientNetID, "Server reloading...");
}
mem_zero(m_aClients, sizeof(m_aClients));
for(int i = 0; i < NET_MAX_CLIENTS; i++)
m_aClients[i].m_ClientNetID = -1;
// extract data
int ID = 0;
const json_value &rStart = (*pJsonData)["servers"];
if(rStart.type == json_array)
{
for(unsigned i = 0; i < rStart.u.array.length; i++)
{
if(ID < 0 || ID >= NET_MAX_CLIENTS)
continue;
Client(ID)->m_Active = true;
Client(ID)->m_Disabled = rStart[i]["disabled"].u.boolean;
str_copy(Client(ID)->m_aName, rStart[i]["name"].u.string.ptr, sizeof(Client(ID)->m_aName));
str_copy(Client(ID)->m_aUsername, rStart[i]["username"].u.string.ptr, sizeof(Client(ID)->m_aUsername));
str_copy(Client(ID)->m_aType, rStart[i]["type"].u.string.ptr, sizeof(Client(ID)->m_aType));
str_copy(Client(ID)->m_aHost, rStart[i]["host"].u.string.ptr, sizeof(Client(ID)->m_aHost));
str_copy(Client(ID)->m_aLocation, rStart[i]["location"].u.string.ptr, sizeof(Client(ID)->m_aLocation));
str_copy(Client(ID)->m_aPassword, rStart[i]["password"].u.string.ptr, sizeof(Client(ID)->m_aPassword));
if(m_Config.m_Verbose)
{
if(Client(ID)->m_Disabled)
dbg_msg("main", "[#%d: Name: \"%s\", Username: \"%s\", Type: \"%s\", Host: \"%s\", Location: \"%s\", Password: \"%s\"]",
ID, Client(ID)->m_aName, Client(ID)->m_aUsername, Client(ID)->m_aType, Client(ID)->m_aHost, Client(ID)->m_aLocation, Client(ID)->m_aPassword);
else
dbg_msg("main", "#%d: Name: \"%s\", Username: \"%s\", Type: \"%s\", Host: \"%s\", Location: \"%s\", Password: \"%s\"",
ID, Client(ID)->m_aName, Client(ID)->m_aUsername, Client(ID)->m_aType, Client(ID)->m_aHost, Client(ID)->m_aLocation, Client(ID)->m_aPassword);
}
ID++;
}
}
// clean up
json_value_free(pJsonData);
mem_free(pFileData);
// tell clients to reload the page
m_JSONUpdateThreadData.m_ReloadRequired = 2;
return 0;
}
struct json_value_s *json_parse(const void *src, size_t src_size) {
return json_parse_ex(src, src_size, json_parse_flags_default, NULL);
}
jconf_t *read_jconf(const char * file)
{
static jconf_t conf;
memset(&conf, 0, sizeof(conf));
char *buf;
json_value *obj;
FILE *f = fopen(file, "rb");
if (f == NULL) {
FATAL("Invalid config path.");
}
fseek(f, 0, SEEK_END);
long pos = ftell(f);
fseek(f, 0, SEEK_SET);
if (pos >= MAX_CONF_SIZE) {
FATAL("Too large config file.");
}
buf = malloc(pos + 1);
if (buf == NULL) {
FATAL("No enough memory.");
}
int nread = fread(buf, pos, 1, f);
if (!nread) {
FATAL("Failed to read the config file.");
}
fclose(f);
buf[pos] = '\0'; // end of string
json_settings settings = { 0 };
char error_buf[512];
obj = json_parse_ex(&settings, buf, pos, error_buf);
if (obj == NULL) {
FATAL(error_buf);
}
if (obj->type == json_object) {
int i, j;
for (i = 0; i < obj->u.object.length; i++) {
char *name = obj->u.object.values[i].name;
json_value *value = obj->u.object.values[i].value;
if (strcmp(name, "server") == 0) {
if (value->type == json_array) {
for (j = 0; j < value->u.array.length; j++) {
if (j >= MAX_REMOTE_NUM) {
break;
}
json_value *v = value->u.array.values[j];
parse_addr(to_string(v), conf.remote_addr + j);
conf.remote_num = j + 1;
}
} else if (value->type == json_string) {
conf.remote_addr[0].host = to_string(value);
conf.remote_addr[0].port = NULL;
conf.remote_num = 1;
}
} else if (strcmp(name, "server_port") == 0) {
conf.remote_port = to_string(value);
} else if (strcmp(name, "local_address") == 0) {
conf.local_addr = to_string(value);
} else if (strcmp(name, "local_port") == 0) {
conf.local_port = to_string(value);
} else if (strcmp(name, "password") == 0) {
conf.password = to_string(value);
} else if (strcmp(name, "method") == 0) {
conf.method = to_string(value);
} else if (strcmp(name, "timeout") == 0) {
conf.timeout = to_string(value);
} else if (strcmp(name, "fast_open") == 0) {
conf.fast_open = value->u.boolean;
} else if (strcmp(name, "nofile") == 0) {
conf.nofile = value->u.integer;
} else if (strcmp(name, "nameserver") == 0) {
conf.nameserver = to_string(value);
#ifdef USE_CRYPTO_OPENSSL
} else if (strcmp(name, "bitcoin_address") == 0) {
conf.bitcoin_address = to_string(value);
} else if (strcmp(name, "bitcoin_privkey") == 0) {
conf.bitcoin_privkey = to_string(value);
} else if (strcmp(name, "bitcoin_list") == 0) {
conf.bitcoin_list = to_string(value);
#endif
}
}
} else {
FATAL("Invalid config file");
}
free(buf);
json_value_free(obj);
return &conf;
}
jconf_t *read_jconf(const char* file)
{
static jconf_t conf;
char *buf;
json_value *obj;
FILE *f = fopen(file, "r");
if (f == NULL) FATAL("Invalid config path.");
fseek(f, 0, SEEK_END);
long pos = ftell(f);
fseek(f, 0, SEEK_SET);
if (pos >= MAX_CONF_SIZE) FATAL("Too large config file.");
buf = malloc(pos + 1);
if (buf == NULL) FATAL("No enough memory.");
fread(buf, pos, 1, f);
fclose(f);
buf[pos] = '\0'; // end of string
json_settings settings = { 0 };
char error_buf[512];
obj = json_parse_ex(&settings, buf, pos, error_buf);
if (obj == NULL)
{
FATAL(error_buf);
}
if (obj->type == json_object)
{
int i;
for (i = 0; i < obj->u.object.length; i++)
{
char *name = obj->u.object.values[i].name;
json_value *value = obj->u.object.values[i].value;
if (strcmp(name, "whitelist") == 0)
{
conf.whitelist = to_string(value);
}
else if (strcmp(name, "TwitterID") == 0)
{
conf.TwitterID = to_string(value);
}
else if (strcmp(name, "CONSUMER_KEY") == 0)
{
conf.CONSUMER_KEY = to_string(value);
}
else if (strcmp(name, "CONSUMER_SECRET") == 0)
{
conf.CONSUMER_SECRET = to_string(value);
}
else if (strcmp(name, "OAUTH_TOKEN") == 0)
{
conf.OAUTH_TOKEN = to_string(value);
}
else if (strcmp(name, "OAUTH_TOKEN_SECRET") == 0)
{
conf.OAUTH_TOKEN_SECRET = to_string(value);
}
}
}
else
{
FATAL("Invalid config file");
}
free(buf);
json_value_free(obj);
return &conf;
}
void CUpdater::CheckUpdates(CMenus *pMenus)
{
dbg_msg("autoupdate", "Checking for updates...");
if (!CHttpDownloader::GetToFile("http://" UPDATES_HOST UPDATES_BASE_PATH UPDATES_MANIFEST_FILE, UPDATES_MANIFEST_FILE))
{
dbg_msg("autoupdate", "Error downloading updates manifest :/");
return;
}
Reset();
IOHANDLE fileAutoUpdate = io_open(UPDATES_MANIFEST_FILE, IOFLAG_READ);
io_seek(fileAutoUpdate, 0, IOSEEK_END);
std::streamsize size = io_tell(fileAutoUpdate);
io_seek(fileAutoUpdate, 0, IOSEEK_START);
std::vector<char> buffer(size);
if (io_read(fileAutoUpdate, buffer.data(), size))
{
bool needUpdate = false;
json_settings JsonSettings;
mem_zero(&JsonSettings, sizeof(JsonSettings));
char aError[256];
json_value *pJsonNodeMain = json_parse_ex(&JsonSettings, buffer.data(), size, aError);
if (pJsonNodeMain == 0)
{
dbg_msg("autoupdate", "Error: %s", aError);
return;
}
int verCode = -1;
for(int j=pJsonNodeMain->u.object.length-1; j>=0; j--) // Ascendent Search: Manifest has descendant order
{
sscanf((const char *)pJsonNodeMain->u.object.values[j].name, "%d", &verCode);
json_value *pNodeCode = pJsonNodeMain->u.object.values[j].value;
if (verCode <= HCLIENT_VERSION_CODE)
continue;
needUpdate = true;
const json_value &rVersion = (*pNodeCode)["version"];
str_copy(m_NewVersion, (const char *)rVersion, sizeof(m_NewVersion));
// Need update client?
const json_value &rClient = (*pNodeCode)["client"];
m_NeedUpdateClient = (rClient.u.boolean);
// Need update server?
const json_value &rServer = (*pNodeCode)["server"];
m_NeedUpdateServer = (rServer.u.boolean);
// Get files to download
const json_value &rDownload = (*pNodeCode)["download"];
for(unsigned k = 0; k < rDownload.u.array.length; k++)
AddFileToDownload((const char *)rDownload[k]);
// Get files to remove
const json_value &rRemove = (*pNodeCode)["remove"];
for(unsigned k = 0; k < rRemove.u.array.length; k++)
AddFileToRemove((const char *)rRemove[k]);
}
if (needUpdate) pMenus->SetPopup(CMenus::POPUP_UPDATER);
else m_Updated = true;
}
io_close(fileAutoUpdate);
fs_remove(UPDATES_MANIFEST_FILE);
}
IGeoIP::GeoInfo CGeoIP::GetInfo(std::string ip)
{
dbg_msg("GeoIP", "Searching geolocation of '%s'...", ip.c_str());
NETADDR bindAddr;
mem_zero(&bindAddr, sizeof(bindAddr));
char aNetBuff[1024];
std::string jsonData;
IGeoIP::GeoInfo rInfo;
//Connect
bindAddr.type = NETTYPE_IPV4;
m_Socket = net_tcp_create(bindAddr);
net_set_non_blocking(m_Socket);
if(net_tcp_connect(m_Socket, &m_HostAddress) < 0)
{
if (net_errno() != EINPROGRESS)
{
dbg_msg("GeoIP","ERROR: Can't connect.");
net_tcp_close(m_Socket);
return rInfo;
}
}
net_socket_read_wait(m_Socket, 1);
net_set_blocking(m_Socket);
//Send request
str_format(aNetBuff, sizeof(aNetBuff), "GET /geoip/%s HTTP/1.0\r\nHost: www.telize.com\r\n\r\n", ip.c_str());
net_tcp_send(m_Socket, aNetBuff, strlen(aNetBuff));
//read data
bool errors = true;
std::string NetData;
int TotalRecv = 0;
int TotalBytes = 0;
int CurrentRecv = 0;
bool isHead = true;
int enterCtrl = 0;
while ((CurrentRecv = net_tcp_recv(m_Socket, aNetBuff, sizeof(aNetBuff))) > 0)
{
for (int i=0; i<CurrentRecv ; i++)
{
if (isHead)
{
if (aNetBuff[i]=='\n')
{
enterCtrl++;
if (enterCtrl == 2)
{
isHead = false;
NetData.clear();
continue;
}
std::transform(NetData.begin(), NetData.end(), NetData.begin(), ::tolower);
if (NetData.find("content-length:") != std::string::npos)
{
sscanf(NetData.c_str(), "content-length:%d", &TotalBytes);
if (TotalBytes == 0)
sscanf(NetData.c_str(), "content-length: %d", &TotalBytes);
}
NetData.clear();
continue;
}
else if (aNetBuff[i]!='\r')
enterCtrl=0;
NetData+=aNetBuff[i];
}
else
{
if (TotalBytes == 0)
{
net_tcp_close(m_Socket);
dbg_msg("GeoIP","ERROR: Error with size received data.");
break;
}
jsonData += aNetBuff[i];
TotalRecv++;
if (TotalRecv == TotalBytes)
{
errors = false;
break;
}
}
}
}
//Finish
net_tcp_close(m_Socket);
if (!errors)
{
// parse json data
json_settings JsonSettings;
mem_zero(&JsonSettings, sizeof(JsonSettings));
char aError[256];
json_value *pJsonData = json_parse_ex(&JsonSettings, jsonData.c_str(), jsonData.length(), aError);
if (pJsonData == 0)
{
dbg_msg("GeoIP", "Error: %s", aError);
return rInfo;
}
// generate configurations
const json_value &countryCode = (*pJsonData)["country_code"];
if (countryCode.type == json_string) str_copy(rInfo.m_aCountryCode, (const char *)countryCode, sizeof(rInfo.m_aCountryCode));
const json_value &countryName = (*pJsonData)["country"];
if (countryName.type == json_string) str_copy(rInfo.m_aCountryName, (const char *)countryName, sizeof(rInfo.m_aCountryName));
//const json_value &isp = (*pJsonData)["isp"];
//if (isp.type == json_string) geoInfo->m_Isp = (const char *)isp;
}
return rInfo;
}
int CSkins::SkinScan(const char *pName, int IsDir, int DirType, void *pUser)
{
int l = str_length(pName);
if(l < 5 || IsDir || str_comp(pName+l-5, ".json") != 0)
return 0;
CSkins *pSelf = (CSkins *)pUser;
// read file data into buffer
char aBuf[512];
str_format(aBuf, sizeof(aBuf), "skins/%s", pName);
IOHANDLE File = pSelf->Storage()->OpenFile(aBuf, IOFLAG_READ, IStorage::TYPE_ALL);
if(!File)
return 0;
int FileSize = (int)io_length(File);
char *pFileData = (char *)mem_alloc(FileSize, 1);
io_read(File, pFileData, FileSize);
io_close(File);
// init
CSkin Skin = pSelf->m_DummySkin;
str_copy(Skin.m_aName, pName, min((int)sizeof(Skin.m_aName),l-4));
if(pSelf->Find(Skin.m_aName, true) != -1)
return 0;
bool SpecialSkin = pName[0] == 'x' && pName[1] == '_';
// parse json data
json_settings JsonSettings;
mem_zero(&JsonSettings, sizeof(JsonSettings));
char aError[256];
json_value *pJsonData = json_parse_ex(&JsonSettings, pFileData, FileSize, aError);
mem_free(pFileData);
if(pJsonData == 0)
{
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_ADDINFO, aBuf, aError);
return 0;
}
// extract data
const json_value &rStart = (*pJsonData)["skin"];
if(rStart.type == json_object)
{
for(int PartIndex = 0; PartIndex < NUM_SKINPARTS; ++PartIndex)
{
const json_value &rPart = rStart[(const char *)ms_apSkinPartNames[PartIndex]];
if(rPart.type != json_object)
continue;
// filename
const json_value &rFilename = rPart["filename"];
if(rFilename.type == json_string)
{
int SkinPart = pSelf->FindSkinPart(PartIndex, (const char *)rFilename, SpecialSkin);
if(SkinPart > -1)
Skin.m_apParts[PartIndex] = pSelf->GetSkinPart(PartIndex, SkinPart);
}
// use custom colors
bool UseCustomColors = false;
const json_value &rColour = rPart["custom_colors"];
if(rColour.type == json_string)
{
UseCustomColors = str_comp((const char *)rColour, "true") == 0;
}
Skin.m_aUseCustomColors[PartIndex] = UseCustomColors;
// color components
if(!UseCustomColors)
continue;
for(int i = 0; i < NUM_COLOR_COMPONENTS; i++)
{
if(PartIndex != SKINPART_MARKING && i == 3)
continue;
const json_value &rComponent = rPart[(const char *)ms_apColorComponents[i]];
if(rComponent.type == json_integer)
{
switch(i)
{
case 0: Skin.m_aPartColors[PartIndex] = (Skin.m_aPartColors[PartIndex]&0xFF00FFFF) | (rComponent.u.integer << 16); break;
case 1: Skin.m_aPartColors[PartIndex] = (Skin.m_aPartColors[PartIndex]&0xFFFF00FF) | (rComponent.u.integer << 8); break;
case 2: Skin.m_aPartColors[PartIndex] = (Skin.m_aPartColors[PartIndex]&0xFFFFFF00) | rComponent.u.integer; break;
case 3: Skin.m_aPartColors[PartIndex] = (Skin.m_aPartColors[PartIndex]&0x00FFFFFF) | (rComponent.u.integer << 24); break;
}
}
}
}
}
// clean up
json_value_free(pJsonData);
// set skin data
Skin.m_Flags = SpecialSkin ? SKINFLAG_SPECIAL : 0;
if(DirType != IStorage::TYPE_SAVE)
Skin.m_Flags |= SKINFLAG_STANDARD;
if(g_Config.m_Debug)
{
str_format(aBuf, sizeof(aBuf), "load skin %s", Skin.m_aName);
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_ADDINFO, "skins", aBuf);
}
pSelf->m_aSkins.add(Skin);
return 0;
}
value2 = object->start->value;
ASSERT_TRUE(value2->payload);
ASSERT_EQ(json_type_array, value2->type);
array = (struct json_array_s* )value2->payload;
ASSERT_FALSE(array->start);
ASSERT_EQ(0, array->length);
free(value);
}
TESTCASE(allow_equals_in_object, true) {
const char payload[] = "{\"foo\" = true}";
struct json_value_s* value = json_parse_ex(payload, strlen(payload), json_parse_flags_allow_equals_in_object, 0);
struct json_object_s* object = 0;
struct json_value_s* value2 = 0;
ASSERT_TRUE(value);
ASSERT_TRUE(value->payload);
ASSERT_EQ(json_type_object, value->type);
object = (struct json_object_s* )value->payload;
ASSERT_TRUE(object->start);
ASSERT_EQ(1, object->length);
ASSERT_TRUE(object->start->name);
ASSERT_TRUE(object->start->value);
ASSERT_FALSE(object->start->next); // we have only one element