sse_int
SseUtilNetInfo_GetHwAddress(const SSEString *in_ifname,
SSEString **out_hwaddr)
{
sse_int err;
sse_char hwaddr[18];
sse_char *ifname;
ifname = sse_strndup(sse_string_get_cstr((SSEString *)in_ifname),
sse_string_get_length((SSEString *)in_ifname));
if (ifname == NULL) {
LOG_ERROR("sse_strndup() ... failed.");
return SSE_E_NOMEM;
}
err = SseUtilNetInfo_GetHwAddressCstr(ifname, hwaddr, sizeof(hwaddr));
if (err != SSE_E_OK) {
sse_free(ifname);
return err;
}
*out_hwaddr = sse_string_new(hwaddr);
if (*out_hwaddr == NULL) {
LOG_ERROR("sse_string_new() ... failed.");
sse_free(ifname);
return SSE_E_NOMEM;
}
sse_free(ifname);
return SSE_E_OK;
}
sse_int
SseUtilNetInfo_GetIPv4Netmask(const SSEString *in_ifname,
SSEString **out_netmask)
{
sse_int err;
sse_char netmask[NI_MAXHOST];
sse_char *ifname;
if (in_ifname == NULL || out_netmask == NULL) {
LOG_ERROR("Invalid argument.");
return SSE_E_INVAL;
}
ifname = sse_strndup(sse_string_get_cstr((SSEString *)in_ifname),
sse_string_get_length((SSEString *)in_ifname));
if (ifname == NULL) {
LOG_ERROR("sse_strndup() ... failed.");
return SSE_E_NOMEM;
}
err = SseUtilNetInfo_GetIPv4NetmaskCstr(ifname, netmask, sizeof(netmask));
if (err != SSE_E_OK) {
sse_free(ifname);
return err;
}
*out_netmask = sse_string_new(netmask);
if (*out_netmask == NULL) {
LOG_ERROR("sse_string_new() ... failed.");
sse_free(ifname);
return SSE_E_NOMEM;
}
sse_free(ifname);
return SSE_E_OK;
}
sse_int
SseUtilNetInfo_GetIPv4Address(const SSEString *in_ifname,
SSEString **out_ipaddr)
{
sse_int err;
sse_char *ifname;
sse_char ipaddr[NI_MAXHOST];
if (in_ifname == NULL || out_ipaddr == NULL) {
LOG_ERROR("Invalid argument.");
return SSE_E_INVAL;
}
ifname = sse_strndup(sse_string_get_cstr((SSEString *)in_ifname),
sse_string_get_length((SSEString *)in_ifname));
if (ifname == NULL) {
LOG_ERROR("sse_strndup() ... failed.");
return SSE_E_NOMEM;
}
err = SseUtilNetInfo_GetIPv4AddressCstr(ifname, ipaddr, sizeof(ipaddr));
if (err != SSE_E_OK) {
sse_free(ifname);
return err;
}
*out_ipaddr = sse_string_new(ipaddr);
if (*out_ipaddr == NULL) {
LOG_ERROR("sse_string_new() ... failed.");
sse_free(ifname);
return SSE_E_NOMEM;
}
sse_free(ifname);
return SSE_E_OK;
}
static void
__SseUtilMoatObjectDump(MoatObject* in_object, sse_int in_indent)
{
sse_char* key;
MoatValue* value;
moat_value_type type;
MoatObjectIterator* it = moat_object_create_iterator(in_object);
sse_char* indent = sse_zeroalloc((in_indent * 4) + 1);
sse_memset(indent, ' ', in_indent * 4);
while (moat_object_iterator_has_next(it)) {
key = moat_object_iterator_get_next_key(it);
value = moat_object_get_value(in_object, key);
type = moat_value_get_type(value);
switch (type) {
case MOAT_VALUE_TYPE_OBJECT:
{
MoatObject* object;
moat_value_get_object(value, &object);
LOG_DEBUG("%sKey=[%s], Type=OBJECT", indent, key);
__SseUtilMoatObjectDump(object, in_indent + 1);
}
break;
case MOAT_VALUE_TYPE_INT16:
{
sse_int16 val;
moat_value_get_int16(value, &val);
LOG_DEBUG("%sKey=[%s], Type=INT16, Value=[%d]", indent, key, val);
}
break;
case MOAT_VALUE_TYPE_INT32:
{
sse_int32 val;
moat_value_get_int32(value, &val);
LOG_DEBUG("%sKey=[%s], Type=INT32, Value=[%d]", indent, key, val);
}
break;
case MOAT_VALUE_TYPE_INT64:
{
sse_int64 val;
moat_value_get_int64(value, &val);
LOG_DEBUG("%sKey=[%s], Type=INT64, Value=[%lld]", indent, key, val);
}
break;
case MOAT_VALUE_TYPE_STRING:
{
sse_char* val;
sse_uint len;
moat_value_get_string(value, &val, &len);
LOG_DEBUG("%sKey=[%s], Type=STRING, Value=[%s], Len=[%d]", indent, key, val, len);
}
break;
default:
LOG_DEBUG("%sKey=[%s]", indent, key);
LOG_WARN("%sSorry, unsupported vaule type=[%d]", indent, type);
}
}
moat_object_iterator_free(it);
sse_free(indent);
}
void
sse_queue_free(SSEQueue *q)
{
sse_free(q);
}
static void
FILEContentInfo_OnCompleteCallback(MoatValue *in_err_code,
MoatValue *in_err_msg,
const sse_char *in_uid,
const sse_char *in_key,
const sse_char *operation,
sse_pointer in_user_data)
{
TFILEContentInfo *self = (TFILEContentInfo*)in_user_data;
sse_char *job_service_id = NULL;
MoatObject *collection = NULL;
sse_int err;
sse_char *str;
sse_uint len;
sse_bool success;
sse_int request_id;
ASSERT(self);
ASSERT(in_err_code);
ASSERT(in_err_msg);
job_service_id = moat_create_notification_id_with_moat(self->fMoat, (sse_char*)operation, "1.0.0");
ASSERT(job_service_id);
LOG_DEBUG("URI=[%s]", job_service_id);
collection = moat_object_new();
ASSERT(collection);
err = moat_value_get_string(in_err_code, &str, &len);
ASSERT(err == SSE_E_OK);
if ((sse_strlen(FILE_ERROR_OK) == len) && (sse_strncmp(FILE_ERROR_OK, str, len) == 0)) {
success = sse_true;
} else {
success = sse_false;
}
err = moat_object_add_boolean_value(collection, "success", success, sse_true);
ASSERT(err == SSE_E_OK);
err = moat_object_add_value(collection, "message", in_err_msg, sse_true, sse_true);
ASSERT(err == SSE_E_OK);
err = moat_object_add_value(collection, "code", in_err_code, sse_true, sse_true);
ASSERT(err == SSE_E_OK);
if (in_uid) {
err = moat_object_add_string_value(collection, "uid", (sse_char*)in_uid, 0, sse_true, sse_true);
ASSERT(err == SSE_E_OK);
}
/* Send a notification. */
request_id = moat_send_notification(self->fMoat,
job_service_id,
(sse_char*)in_key,
FILE_MODELNAME_FILERESULT,
collection,
NULL, //FIXME
NULL); //FIXME
if (request_id < 0) {
LOG_ERROR("moat_send_notification() ... failed with [%s].", request_id);
}
LOG_INFO("moat_send_notification(job_service_id=[%s], key=[%s]) ... in progress.", job_service_id, in_key);
MOAT_OBJECT_DUMP_INFO(TAG, collection);
moat_object_free(collection);
sse_free(job_service_id);
return;
}
void
sse_list_free(SSEList *list)
{
sse_free(list);
}
void
sse_slist_free(SSESList *list)
{
sse_free(list);
}
void
moat_object_free(MoatObject *self)
{
sse_free(self);
}
sse_int
TDEVINFOCollector_GetHardwareSim(TDEVINFOCollector* self,
DEVINFOCollector_OnGetCallback in_callback,
sse_pointer in_user_data)
{
sse_int err;
MoatObject *object = NULL;
MoatValue *value = NULL;
FILE *fd;
sse_char buff[128];
sse_char *iccid = NULL;
sse_char *imsi = NULL;
sse_char *msisdn = NULL;
sse_int i;
ASSERT(self);
self->fOnGetCallback = in_callback;
self->fUserData = in_user_data;
self->fStatus = DEVINFO_COLLECTOR_STATUS_COLLECTING;
/* Get SIM Info */
fd = fopen("/tmp/.flags/.sim_exist", "r");
if (fd == NULL) {
LOG_INFO("No SIM info.");
if (self->fOnGetCallback) {
self->fOnGetCallback(NULL, self->fUserData, SSE_E_NOENT);
}
self->fStatus = DEVINFO_COLLECTOR_STATUS_COMPLETED;
return SSE_E_OK;
}
while (fgets(buff, sizeof(buff), fd) != NULL) {
LOG_DEBUG("SIM: %s", buff);
if ((imsi == NULL) && (sse_strlen(buff) > 15)) {
for (i = 0; i < 15; i++) {
if (!isdigit(buff[i])) {
break;
}
}
imsi = sse_strndup(buff, 15);
ASSERT(imsi);
LOG_INFO("IMSI=%[%s].", imsi);
} else if ((iccid == NULL) && (sse_strlen(buff) > 6) && (sse_strncmp(buff, "+CCID:", 6) == 0)) {
iccid = sse_strndup(buff + 7, 19);
ASSERT(iccid);
LOG_INFO("ICCID=[%s].", iccid);
} else if ((msisdn == NULL) && (sse_strlen(buff) > 6) && (sse_strncmp(buff, "+CNUM:", 6) == 0)) {
msisdn = sse_strndup(buff + 11, 11);
ASSERT(msisdn);
LOG_INFO("MSISDN=[%s].", msisdn);
}
}
fclose(fd);
/* Create MoatObject */
object = moat_object_new();
ASSERT(object);
if (iccid) {
err = moat_object_add_string_value(object, DEVINFO_KEY_SIM_ICCID, iccid, sse_strlen(iccid), sse_true, sse_false);
if (err != SSE_E_OK) {
LOG_ERROR("moat_object_set_string_value() ... failed with [%s].", sse_get_error_string(err));
if(self->fOnGetCallback) {
self->fOnGetCallback(NULL, self->fUserData, err);
}
goto error_exit;
}
}
if (imsi) {
err = moat_object_add_string_value(object, DEVINFO_KEY_SIM_IMSI, imsi, sse_strlen(imsi), sse_true, sse_false);
if (err != SSE_E_OK) {
LOG_ERROR("moat_object_set_string_value() ... failed with [%s].", sse_get_error_string(err));
if(self->fOnGetCallback) {
self->fOnGetCallback(NULL, self->fUserData, err);
}
goto error_exit;
}
}
if (msisdn) {
err = moat_object_add_string_value(object, DEVINFO_KEY_SIM_MSISDN, msisdn, sse_strlen(msisdn), sse_true, sse_false);
if (err != SSE_E_OK) {
LOG_ERROR("moat_object_set_string_value() ... failed with [%s].", sse_get_error_string(err));
if(self->fOnGetCallback) {
self->fOnGetCallback(NULL, self->fUserData, err);
}
goto error_exit;
}
}
/* Call callback */
if(self->fOnGetCallback) {
value = moat_value_new_object(object, sse_true);
ASSERT(value);
self->fOnGetCallback(value, self->fUserData, err);
moat_value_free(value);
}
/* Cleanup */
moat_object_free(object);
if (imsi) sse_free(imsi);
if (iccid) sse_free(iccid);
if (msisdn) sse_free(msisdn);
self->fStatus = DEVINFO_COLLECTOR_STATUS_COMPLETED;
return SSE_E_OK;
/* Abnormal end */
error_exit:
self->fStatus = DEVINFO_COLLECTOR_STATUS_ABEND;
if (object) moat_object_free(object);
if (imsi) sse_free(imsi);
if (iccid) sse_free(iccid);
if (msisdn) sse_free(msisdn);
return err;
}
static void
DeviceInfo_CollectOnComplete(sse_int in_err,
sse_pointer in_user_data)
{
sse_int err;
TDEVINFOModelCommand *context;
TDEVINFOManager *mgr;
SSEString *devinfo = NULL;
MoatObject *object = NULL;
sse_char *job_service_id = NULL;
sse_int request_id;
#ifdef DEVINFO_ENABLE_BASE64_ENCODE
sse_size encoded_len;
sse_char *encoded;
#endif /* DEVINFO_ENABLE_BASE64_ENCODE */
context = (TDEVINFOModelCommand *)in_user_data;
ASSERT(context);
mgr = context->fMgr;
ASSERT(mgr);
object = moat_object_new();
ASSERT(object);
job_service_id = moat_create_notification_id_with_moat(context->fMoat, "inquire-result", "1.0.0");
ASSERT(job_service_id);
LOG_DEBUG("URI=[%s]", job_service_id);
/* Check the result of collecting devinfo. */
if (in_err != SSE_E_OK) {
LOG_ERROR("DeviceInfo_collect_async() ... failed with [%s].", sse_get_error_string(in_err));
goto error_exit;
}
/* Get devinfo from the repository. */
err = TDEVINFOManager_GetDevinfo(mgr, &devinfo);
if (err != SSE_E_OK) {
LOG_ERROR("TDEVINFOManager_GetDevinfo() ... failed with [%s].", sse_get_error_string(err));
goto error_exit;
}
/* Base64 encode */
#ifdef DEVINFO_ENABLE_BASE64_ENCODE
encoded_len = sse_base64_get_encoded_length(sse_string_get_length(devinfo));
encoded = sse_zeroalloc(encoded_len);
ASSERT(encoded);
sse_base64_encode((sse_byte*)sse_string_get_cstr(devinfo), sse_string_get_length(devinfo), encoded);
{ /* for DEBUG */
sse_char *buff;
buff = sse_strndup(encoded, encoded_len);
if (buff) {
LOG_INFO("Encoded=[%s]", buff);
sse_free(buff);
}
}
#endif /* DEVINFO_ENABLE_BASE64_ENCODE */
/* Create a model object */
#ifdef DEVINFO_ENABLE_BASE64_ENCODE
err = moat_object_add_string_value(object, "deviceInfo", encoded, encoded_len, sse_true, sse_false);
#else
err = moat_object_add_string_value(object, "deviceInfo", sse_string_get_cstr(devinfo), sse_string_get_length(devinfo), sse_true, sse_false);
#endif /* DEVINFO_ENABLE_BASE64_ENCODE */
if (err != SSE_E_OK) {
LOG_ERROR("moat_object_add_string_value() ... failed with [%s].", err);
goto error_exit;
}
/* Send a notification. */
request_id = moat_send_notification(context->fMoat,
job_service_id,
context->fKey,
DEVINFO_MODEL_NAME,
object,
NULL, //FIXME
NULL); //FIXME
if (request_id < 0) {
LOG_ERROR("moat_send_notification() ... failed with [%s].", request_id);
}
LOG_INFO("moat_send_notification(job_service_id=[%s], key=[%s]) ... in progress.", job_service_id, context->fKey);
sse_string_free(devinfo, sse_true);
moat_object_free(object);
sse_free(job_service_id);
return;
error_exit:
/* No way to reply error after responding SSE_E_INPROGRESS, so reply empty object as error.
*/
request_id = moat_send_notification(context->fMoat,
job_service_id,
context->fKey,
DEVINFO_MODEL_NAME,
object,
NULL, //FIXME
NULL); //FIXME
if (request_id < 0) {
LOG_ERROR("moat_send_notification() ... failed with [%s].", request_id);
}
if (devinfo) {
sse_string_free(devinfo, sse_true);
}
if (object) {
moat_object_free(object);
}
if (job_service_id) {
sse_free(job_service_id);
}
sse_free(context);
return;
}
