bool luna_service_message_validate_and_send(LSHandle *handle, LSMessage *message, jvalue_ref reply_obj)
{
jschema_ref response_schema = NULL;
LSError lserror;
bool success = true;
LSErrorInit(&lserror);
response_schema = jschema_parse (j_cstr_to_buffer("{}"), DOMOPT_NOOPT, NULL);
if(!response_schema) {
luna_service_message_reply_error_internal(handle, message);
return false;
}
if (!LSMessageReply(handle, message,
jvalue_tostring(reply_obj, response_schema), &lserror)) {
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
success = false;
}
jschema_release(&response_schema);
return success;
}
void TestSchema::initTestCase()
{
m_schemaDOM = jschema_parse(m_schema,
DOMOPT_INPUT_NOCHANGE | DOMOPT_INPUT_OUTLIVES_DOM, NULL);
QVERIFY(m_schemaDOM != NULL);
QCOMPARE(m_fileNames.size(), m_inputs.size());
}
static bool handle_get_info_command(LSHandle *sh, LSMessage *message, void* context)
{
jvalue_ref reply = jobject_create();
LSError lserror;
LSErrorInit(&lserror);
char wifi_mac_address[32]={0}, wired_mac_address[32]={0};
jobject_put(reply, J_CSTR_TO_JVAL("returnValue"), jboolean_create(true));
if(get_wifi_mac_address(CONNMAN_WIFI_INTERFACE_NAME, wifi_mac_address) == 0)
{
jvalue_ref wifi_info = jobject_create();
jobject_put(wifi_info, J_CSTR_TO_JVAL("macAddress"),jstring_create(wifi_mac_address));
jobject_put(reply, J_CSTR_TO_JVAL("wifiInfo"), wifi_info);
}
else
WCA_LOG_ERROR("Error in fetching mac address for wifi interface");
if(get_wifi_mac_address(CONNMAN_WIRED_INTERFACE_NAME, wired_mac_address) == 0)
{
jvalue_ref wired_info = jobject_create();
jobject_put(wired_info, J_CSTR_TO_JVAL("macAddress"),jstring_create(wired_mac_address));
jobject_put(reply, J_CSTR_TO_JVAL("wiredInfo"), wired_info);
}
else
WCA_LOG_ERROR("Error in fetching mac address for wired interface");
jschema_ref response_schema = jschema_parse (j_cstr_to_buffer("{}"), DOMOPT_NOOPT, NULL);
if(!response_schema)
{
LSMessageReplyErrorUnknown(sh,message);
goto cleanup;
}
if (!LSMessageReply(sh, message, jvalue_tostring(reply, response_schema), &lserror))
{
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
}
jschema_release(&response_schema);
cleanup:
if (LSErrorIsSet(&lserror))
{
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
}
j_release(&reply);
return true;
}
JSchema::Resource *JSchemaFragment::createResource(const std::string &fragment)
{
raw_buffer schemaStr;
schemaStr.m_str = fragment.c_str();
schemaStr.m_len = fragment.length();
// XXX: This is not optimal on purpose on the assumption that this class
// disappears anyways
jschema_ref parsed = jschema_parse(schemaStr, JSCHEMA_DOM_NOOPT, NULL);
if (parsed == NULL)
return NULL;
return new JSchema::Resource(parsed, JSchema::Resource::TakeSchema);
}
JSchema::Resource* JSchemaFile::createSchemaMap(int fd)
{
Map map;
if (!initSchemaMap(fd, map))
return NULL;
raw_buffer schemaContents;
schemaContents.m_str = (char *)map.data;
schemaContents.m_len = map.size;
jschema_ref parsed = jschema_parse(schemaContents, JSCHEMA_INPUT_OUTLIVES_DOM | JSCHEMA_DOM_INPUT_NOCHANGE, NULL);
return new MMapResource(map, parsed);
}
jvalue_ref luna_service_message_parse_and_validate(const char *payload)
{
jschema_ref input_schema = NULL;
jvalue_ref parsed_obj = NULL;
JSchemaInfo schema_info;
input_schema = jschema_parse(j_cstr_to_buffer("{}"), DOMOPT_NOOPT, NULL);
jschema_info_init(&schema_info, input_schema, NULL, NULL);
parsed_obj = jdom_parse(j_cstr_to_buffer(payload), DOMOPT_NOOPT, &schema_info);
jschema_release(&input_schema);
if (jis_null(parsed_obj))
return NULL;
return parsed_obj;
}
static bool handle_get_status_command(LSHandle* sh, LSMessage *message, void* context)
{
jvalue_ref reply = jobject_create();
LSError lserror;
LSErrorInit(&lserror);
bool subscribed = false;
if (LSMessageIsSubscription(message))
{
if (!LSSubscriptionProcess(sh, message, &subscribed, &lserror))
{
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
}
jobject_put(reply, J_CSTR_TO_JVAL("subscribed"), jboolean_create(subscribed));
if(!connman_manager_is_manager_available(manager))
goto response;
}
if(!connman_status_check(manager, sh, message))
goto cleanup;
send_connection_status(&reply);
response:
{
jschema_ref response_schema = jschema_parse (j_cstr_to_buffer("{}"), DOMOPT_NOOPT, NULL);
if(!response_schema)
{
LSMessageReplyErrorUnknown(sh,message);
goto cleanup;
}
if (!LSMessageReply(sh, message, jvalue_tostring(reply, response_schema), &lserror)) {
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
}
jschema_release(&response_schema);
}
cleanup:
j_release(&reply);
return true;
}
void luna_service_post_subscription(LSHandle *handle, const char *path, const char *method, jvalue_ref reply_obj)
{
jschema_ref response_schema = NULL;
LSError lserror;
LSErrorInit(&lserror);
response_schema = jschema_parse (j_cstr_to_buffer("{}"), DOMOPT_NOOPT, NULL);
if(!response_schema)
goto cleanup;
if (!LSSubscriptionPost(handle, path, method,
jvalue_tostring(reply_obj, response_schema), &lserror)) {
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
}
cleanup:
if (response_schema)
jschema_release(&response_schema);
}
static JSchemaResolutionResult simpleResolver(JSchemaResolverRef resolver, jschema_ref *resolved)
{
QString resourceName = QString::fromUtf8(resolver->m_resourceToResolve.m_str, resolver->m_resourceToResolve.m_len);
QFileInfo lookupPath(resolutionDir, resourceName + ".schema");
if (!lookupPath.isFile() || !lookupPath.isReadable()) {
qWarning() << "Failed to resolve" << resourceName << ". Resolved path" << lookupPath.absoluteFilePath() << " isn't a file";
return SCHEMA_NOT_FOUND;
}
QFile resourceData(lookupPath.absoluteFilePath());
if (!resourceData.open(QIODevice::ReadOnly)) {
qWarning() << "Failed to open" << resourceName << "(" << lookupPath.absoluteFilePath() << ")";
return SCHEMA_IO_ERROR;
}
raw_buffer readSchema;
if (resourceData.size() > std::numeric_limits<typeof(readSchema.m_len)>::max()) {
qWarning() << "Schema" << lookupPath.absoluteFilePath() << "is too big";
return SCHEMA_GENERIC_ERROR;
}
readSchema.m_len = resourceData.size();
readSchema.m_str = new char[readSchema.m_len];
QDataStream schemaReader(&resourceData);
if (!readSchema.m_len == schemaReader.readRawData((char *)readSchema.m_str, readSchema.m_len)) {
qWarning() << "Failed to read schema" << resourceName << "fully";
delete [] readSchema.m_str;
return SCHEMA_IO_ERROR;
}
*resolved = jschema_parse(readSchema, DOMOPT_NOOPT, NULL);
delete [] readSchema.m_str;
if (*resolved == NULL)
return SCHEMA_INVALID;
qDebug() << "Resolved reference for" << resourceName;
return SCHEMA_RESOLVED;
}
void connectionmanager_send_status(void)
{
jvalue_ref reply = jobject_create();
jobject_put(reply, J_CSTR_TO_JVAL("returnValue"), jboolean_create(true));
send_connection_status(&reply);
jschema_ref response_schema = jschema_parse (j_cstr_to_buffer("{}"), DOMOPT_NOOPT, NULL);
if(response_schema)
{
const char *payload = jvalue_tostring(reply, response_schema);
LSError lserror;
LSErrorInit(&lserror);
WCA_LOG_INFO("Sending payload %s",payload);
if (!LSSubscriptionPost(pLsHandle, "/", "getstatus", payload, &lserror))
{
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
}
jschema_release(&response_schema);
}
j_release(&reply);
}
static bool handle_set_state_command(LSHandle *sh, LSMessage *message, void* context)
{
if(!connman_status_check(manager, sh, message))
return true;
jvalue_ref parsedObj = {0};
jschema_ref input_schema = jschema_parse (j_cstr_to_buffer("{}"), DOMOPT_NOOPT, NULL);
if(!input_schema)
return false;
JSchemaInfo schemaInfo;
jschema_info_init(&schemaInfo, input_schema, NULL, NULL); // no external refs & no error handlers
parsedObj = jdom_parse(j_cstr_to_buffer(LSMessageGetPayload(message)), DOMOPT_NOOPT, &schemaInfo);
jschema_release(&input_schema);
if (jis_null(parsedObj))
{
LSMessageReplyErrorBadJSON(sh, message);
return true;
}
jvalue_ref wifiObj = {0}, wiredObj = {0};
gboolean enable_wifi = FALSE, enable_wired = FALSE;
gboolean invalidArg = TRUE;
if(jobject_get_exists(parsedObj, J_CSTR_TO_BUF("wifi"), &wifiObj))
{
if (jstring_equal2(wifiObj, J_CSTR_TO_BUF("enabled")))
{
enable_wifi = TRUE;
}
else if (jstring_equal2(wifiObj, J_CSTR_TO_BUF("disabled")))
{
enable_wifi = FALSE;
}
else
{
goto invalid_params;
}
/*
* Check if we are enabling an already enabled service,
* or disabling an already disabled service
*/
if((enable_wifi && is_wifi_powered()) || (!enable_wifi && !is_wifi_powered()))
{
WCA_LOG_DEBUG("Wifi technology already enabled/disabled");
}
else
{
set_wifi_state(enable_wifi);
}
invalidArg = FALSE;
}
if(jobject_get_exists(parsedObj, J_CSTR_TO_BUF("wired"), &wiredObj))
{
if (jstring_equal2(wiredObj, J_CSTR_TO_BUF("enabled")))
{
enable_wired = TRUE;
}
else if (jstring_equal2(wiredObj, J_CSTR_TO_BUF("disabled")))
{
enable_wired = FALSE;
}
else
{
goto invalid_params;
}
/*
* Check if we are enabling an already enabled service,
* or disabling an already disabled service
*/
if((enable_wired && is_ethernet_powered()) || (!enable_wired && !is_ethernet_powered()))
{
WCA_LOG_DEBUG("Wired technology already enabled/disabled");
}
else
{
set_ethernet_state(enable_wired);
}
invalidArg = FALSE;
}
if(invalidArg == TRUE)
{
goto invalid_params;
}
LSMessageReplySuccess(sh,message);
goto cleanup;
invalid_params:
LSMessageReplyErrorInvalidParams(sh, message);
cleanup:
j_release(&parsedObj);
return true;
}
static bool handle_set_dns_command(LSHandle *sh, LSMessage *message, void* context)
{
if(!connman_status_check(manager, sh, message))
return true;
jvalue_ref parsedObj = {0};
jschema_ref input_schema = jschema_parse (j_cstr_to_buffer("{}"), DOMOPT_NOOPT, NULL);
if(!input_schema)
return false;
JSchemaInfo schemaInfo;
jschema_info_init(&schemaInfo, input_schema, NULL, NULL); // no external refs & no error handlers
parsedObj = jdom_parse(j_cstr_to_buffer(LSMessageGetPayload(message)), DOMOPT_NOOPT, &schemaInfo);
jschema_release(&input_schema);
if (jis_null(parsedObj))
{
LSMessageReplyErrorBadJSON(sh, message);
return true;
}
jvalue_ref ssidObj = {0}, dnsObj = {0};
GStrv dns = NULL;
gchar *ssid = NULL;
if(jobject_get_exists(parsedObj, J_CSTR_TO_BUF("dns"), &dnsObj))
{
int i, dns_arrsize = jarray_size(dnsObj);
dns = (GStrv) g_new0(GStrv, 1);
for(i = 0; i < dns_arrsize; i++)
{
raw_buffer dns_buf = jstring_get(jarray_get(dnsObj, i));
dns[i] = g_strdup(dns_buf.m_str);
jstring_free_buffer(dns_buf);
}
}
else
{
LSMessageReplyErrorInvalidParams(sh, message);
goto Exit;
}
if(jobject_get_exists(parsedObj, J_CSTR_TO_BUF("ssid"), &ssidObj))
{
raw_buffer ssid_buf = jstring_get(ssidObj);
ssid = g_strdup(ssid_buf.m_str);
jstring_free_buffer(ssid_buf);
}
connman_service_t *service = get_connman_service(ssid);
if(NULL != service)
{
if(connman_service_set_nameservers(service, dns))
LSMessageReplySuccess(sh, message);
else
LSMessageReplyErrorUnknown(sh, message);
goto Exit;
}
else
LSMessageReplyCustomError(sh, message, "No connected network");
Exit:
g_strfreev(dns);
g_free(ssid);
j_release(&parsedObj);
return true;
}
static bool handle_set_ipv4_command(LSHandle *sh, LSMessage *message, void* context)
{
if(!connman_status_check(manager, sh, message))
return true;
jvalue_ref parsedObj = {0};
jschema_ref input_schema = jschema_parse (j_cstr_to_buffer("{}"), DOMOPT_NOOPT, NULL);
if(!input_schema)
return false;
JSchemaInfo schemaInfo;
jschema_info_init(&schemaInfo, input_schema, NULL, NULL); // no external refs & no error handlers
parsedObj = jdom_parse(j_cstr_to_buffer(LSMessageGetPayload(message)), DOMOPT_NOOPT, &schemaInfo);
jschema_release(&input_schema);
if (jis_null(parsedObj))
{
LSMessageReplyErrorBadJSON(sh, message);
return true;
}
jvalue_ref ssidObj = {0}, methodObj = {0}, addressObj = {0}, netmaskObj = {0}, gatewayObj = {0};
ipv4info_t ipv4 = {0};
gchar *ssid = NULL;
gboolean invalidArg = TRUE;
if(jobject_get_exists(parsedObj, J_CSTR_TO_BUF("method"), &methodObj))
{
raw_buffer method_buf = jstring_get(methodObj);
ipv4.method = g_strdup(method_buf.m_str);
jstring_free_buffer(method_buf);
invalidArg = FALSE;
}
if(jobject_get_exists(parsedObj, J_CSTR_TO_BUF("address"), &addressObj))
{
raw_buffer address_buf = jstring_get(addressObj);
ipv4.address = g_strdup(address_buf.m_str);
jstring_free_buffer(address_buf);
invalidArg = FALSE;
}
if(jobject_get_exists(parsedObj, J_CSTR_TO_BUF("netmask"), &netmaskObj))
{
raw_buffer netmask_buf = jstring_get(netmaskObj);
ipv4.netmask = g_strdup(netmask_buf.m_str);
jstring_free_buffer(netmask_buf);
invalidArg = FALSE;
}
if(jobject_get_exists(parsedObj, J_CSTR_TO_BUF("gateway"), &gatewayObj))
{
raw_buffer gateway_buf = jstring_get(gatewayObj);
ipv4.gateway = g_strdup(gateway_buf.m_str);
jstring_free_buffer(gateway_buf);
invalidArg = FALSE;
}
if(jobject_get_exists(parsedObj, J_CSTR_TO_BUF("ssid"), &ssidObj))
{
raw_buffer ssid_buf = jstring_get(ssidObj);
ssid = g_strdup(ssid_buf.m_str);
jstring_free_buffer(ssid_buf);
invalidArg = FALSE;
}
if(invalidArg == TRUE)
{
LSMessageReplyErrorInvalidParams(sh, message);
goto Exit;
}
connman_service_t *service = get_connman_service(ssid);
if(NULL != service)
{
if(connman_service_set_ipv4(service, &ipv4))
LSMessageReplySuccess(sh, message);
else
LSMessageReplyErrorUnknown(sh, message);
goto Exit;
}
else
{
LSMessageReplyCustomError(sh, message, "Network not found");
}
Exit:
g_free(ipv4.method);
g_free(ipv4.address);
g_free(ipv4.netmask);
g_free(ipv4.gateway);
g_free(ssid);
j_release(&parsedObj);
return true;
}
