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; }