GSList*
g_slist_insert_sorted (GSList *list,
gpointer data,
GCompareFunc func)
{
GSList *tmp_list = list;
GSList *prev_list = NULL;
GSList *new_list;
gint cmp;
g_return_val_if_fail (func != NULL, list);
if (!list)
{
new_list = g_slist_alloc();
new_list->data = data;
return new_list;
}
cmp = (*func) (data, tmp_list->data);
while ((tmp_list->next) && (cmp > 0))
{
prev_list = tmp_list;
tmp_list = tmp_list->next;
cmp = (*func) (data, tmp_list->data);
}
new_list = g_slist_alloc();
new_list->data = data;
if ((!tmp_list->next) && (cmp > 0))
{
tmp_list->next = new_list;
return list;
}
if (prev_list)
{
prev_list->next = new_list;
new_list->next = tmp_list;
return list;
}
else
{
new_list->next = list;
return new_list;
}
}
Evas_Object* viewer_list_create(Evas_Object *win)
{
__COMMON_FUNC_ENTER__;
assertm_if(NULL == win, "NULL!!");
assertm_if(NULL != viewer_list, "Err!!");
viewer_list = elm_genlist_add(win);
elm_object_style_set(viewer_list, "dialogue");
assertm_if(NULL == viewer_list, "NULL!!");
elm_genlist_mode_set(viewer_list, ELM_LIST_LIMIT);
evas_object_size_hint_weight_set(viewer_list, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(viewer_list, EVAS_HINT_FILL, EVAS_HINT_FILL);
container = NULL;
container = g_slist_alloc();
assertm_if(NULL == container, "NULL!!");
itc.item_style = "dialogue/2text.2icon.3.tb";
itc.func.text_get = _gl_listview_text_get;
itc.func.content_get = _gl_listview_content_get;
itc.func.state_get = NULL;
itc.func.del = _gl_listview_del;
__COMMON_FUNC_EXIT__;
return viewer_list;
}
void read_by_uuid_cb(guint8 status, const guint8 *pdu, guint16 plen,
gpointer user_data)
{
struct att_data_list *list;
GSList *bl_value_list = NULL;
cb_ctx_t *cb_ctx = user_data;
printf_dbg("[CB] IN read_by_uuid_cb\n");
if (status) {
cb_ctx->cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ctx->cb_ret_msg, "Read by uuid callback: Failure: %s\n",
att_ecode2str(status));
goto error;
}
list = dec_read_by_type_resp(pdu, plen);
if (list == NULL) {
strcpy(cb_ctx->cb_ret_msg, "Read by uuid callback: Nothing found\n");
cb_ctx->cb_ret_val = BL_NO_ERROR;
goto error;
}
for (int i = 0; i < list->num; i++) {
bl_value_t *bl_value = bl_value_new(NULL, att_get_u16(list->data[i]),
list->len - 2, list->data[i] + 2);
if (bl_value == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Read by uuid callback: Malloc error\n");
goto error;
}
// Add it to the value list
if (bl_value_list == NULL) {
bl_value_list = g_slist_alloc();
if (bl_value_list == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Read by uuid callback: Malloc error\n");
goto error;
}
bl_value_list->data = bl_value;
} else {
bl_value_list = g_slist_append(bl_value_list, bl_value);
}
}
att_data_list_free(list);
cb_ctx->cb_ret_pointer = bl_value_list;
cb_ctx->cb_ret_val = BL_NO_ERROR;
goto exit;
error:
if (bl_value_list)
bl_value_list_free(bl_value_list);
exit:
g_mutex_unlock(&cb_ctx->pending_cb_mtx);
printf_dbg("[CB] OUT read_by_uuid_cb\n");
}
void
gdm_error_trap_push (void)
{
GSList *node;
GdmErrorTrap *trap;
if (gdm_error_trap_free_list) {
node = gdm_error_trap_free_list;
gdm_error_trap_free_list = gdm_error_trap_free_list->next;
} else {
node = g_slist_alloc ();
node->data = g_new (GdmErrorTrap, 1);
}
node->next = gdm_error_traps;
gdm_error_traps = node;
trap = node->data;
trap->old_handler = XSetErrorHandler (gdm_x_error);
trap->error_code = _gdm_error_code;
trap->error_warnings = _gdm_error_warnings;
_gdm_error_code = 0;
_gdm_error_warnings = 0;
}
void char_by_uuid_cb(GSList *characteristics, guint8 status,
gpointer user_data)
{
GSList *l = NULL;
GSList *bl_char_list = NULL;
cb_ctx_t *cb_ctx = user_data;
printf_dbg(" IN char_by_uuid\n");
if (status) {
cb_ctx->cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ctx->cb_ret_msg,
"Characteristic by UUID callback: Failure: %s\n",
att_ecode2str(status));
goto error;
}
for (l = characteristics; l; l = l->next) {
// Extract data
struct gatt_char *chars = l->data;
bl_char_t *bl_char = bl_char_new(chars->uuid, chars->handle,
chars->properties,
chars->value_handle);
// Add it to the characteristic
if (bl_char == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Characteristic by UUID callback: Malloc error\n");
goto error;
}
// Append it to the list
if (bl_char_list == NULL) {
bl_char_list = g_slist_alloc();
if (bl_char_list == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Characteristic by UUID callback: Malloc error\n");
goto error;
}
bl_char_list->data = bl_char;
} else {
bl_char_list = g_slist_append(bl_char_list, bl_char);
}
}
cb_ctx->cb_ret_val = BL_NO_ERROR;
cb_ctx->cb_ret_pointer = bl_char_list;
goto exit;
error:
if (bl_char_list)
bl_char_list_free(bl_char_list);
exit:
if (l)
g_slist_free(l);
g_mutex_unlock(&cb_ctx->pending_cb_mtx);
printf_dbg("OUT char_by_uuid\n");
}
static void
add_new_waiting_for (SymbolDBViewLocals *dbvl, gint parent_symbol_id,
const gchar* symbol_name,
gint symbol_id, const GdkPixbuf *pixbuf)
{
SymbolDBViewLocalsPriv *priv;
gpointer node;
g_return_if_fail (dbvl != NULL);
priv = dbvl->priv;
/* we don't want a negative parent_symbol_id */
if (parent_symbol_id < 0)
return;
/* check if we already have some children waiting for a
* specific father to be inserted, then add this symbol_id to the list
* (or create a new one)
*/
WaitingForSymbol *wfs;
wfs = g_new0 (WaitingForSymbol, 1);
wfs->child_symbol_id = symbol_id;
wfs->child_symbol_name = g_strdup (symbol_name);
wfs->pixbuf = pixbuf;
/* DEBUG_PRINT ("add_new_waiting_for (): looking up waiting_for %d",
parent_symbol_id);*/
node = g_tree_lookup (priv->waiting_for, GINT_TO_POINTER (parent_symbol_id));
if (node == NULL)
{
/* no lists already set. Create one. */
GSList *slist;
slist = g_slist_alloc ();
slist = g_slist_prepend (slist, wfs);
/*DEBUG_PRINT ("add_new_waiting_for (): NEW adding to "
"waiting_for [%d]", parent_symbol_id);*/
/* add it to the binary tree. */
g_tree_insert (priv->waiting_for, GINT_TO_POINTER (parent_symbol_id),
slist);
}
else
{
/* found a list */
GSList *slist;
slist = (GSList*)node;
/*DEBUG_PRINT ("prepare_for_adding (): NEW adding to "
"parent_waiting_for_list [%d] %s",
parent_symbol_id, symbol_name);*/
slist = g_slist_prepend (slist, wfs);
g_tree_replace (priv->waiting_for, GINT_TO_POINTER (parent_symbol_id),
slist);
}
}
void primary_all_cb(GSList *services, guint8 status,
gpointer user_data)
{
GSList *l = NULL;
GSList *bl_primary_list = NULL;
printf_dbg("[CB] IN Primary_all_cb\n");
if (status) {
cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ret_msg, "Primary callback: Failure: %s\n",
att_ecode2str(status));
goto error;
}
if (services == NULL) {
cb_ret_val = BL_NO_ERROR;
strcpy(cb_ret_msg, "Primary callback: Nothing found\n");
goto exit;
}
for (l = services; l; l = l->next) {
struct gatt_primary *prim = l->data;
bl_primary_t *bl_primary = bl_primary_new(prim->uuid, prim->changed,
prim->range.start, prim->range.end);
g_free(prim);
if (bl_primary == NULL) {
cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ret_msg, "Primary callback: Malloc error\n");
goto error;
}
if (bl_primary_list == NULL) {
bl_primary_list = g_slist_alloc();
if (bl_primary_list == NULL) {
cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ret_msg, "Primary callback: Malloc error\n");
goto error;
}
bl_primary_list->data = bl_primary;
} else {
bl_primary_list = g_slist_append(bl_primary_list, bl_primary);
}
}
cb_ret_val = BL_NO_ERROR;
cb_ret_pointer = bl_primary_list;
strcpy(cb_ret_msg, "Primary callback: Sucess\n");
goto exit;
error:
if (bl_primary_list)
bl_primary_list_free(bl_primary_list);
exit:
if (l)
g_slist_free(l);
g_mutex_unlock(pending_callback);
printf_dbg("[CB] OUT primary_all_cb\n");
}
void primary_by_uuid_cb(GSList *ranges, guint8 status,
gpointer user_data)
{
GSList *l;
GSList *bl_primary_list = NULL;
cb_ctx_t *cb_ctx = user_data;
printf_dbg("IN primary_by_uuid_cb\n");
if (status) {
cb_ctx->cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ctx->cb_ret_msg, "Primary by UUID callback: Failure: %s\n",
att_ecode2str(status));
goto error;
}
if (ranges == NULL) {
cb_ctx->cb_ret_val = BL_NO_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Primary by UUID callback: Nothing found\n");
goto exit;
}
for (l = ranges; l; l = l->next) {
struct att_range *range = l->data;
bl_primary_t *bl_primary = bl_primary_new(NULL, 0, range->start,
range->end);
free(range);
if (bl_primary == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Primary by UUID callback: Malloc error\n");
goto error;
}
if (bl_primary_list == NULL) {
bl_primary_list = g_slist_alloc();
if (bl_primary_list == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Primary by UUID callback: Malloc error\n");
goto error;
}
bl_primary_list->data = bl_primary;
} else {
bl_primary_list = g_slist_append(bl_primary_list, bl_primary);
}
}
cb_ctx->cb_ret_val = BL_NO_ERROR;
cb_ctx->cb_ret_pointer = bl_primary_list;
goto exit;
error:
if (bl_primary_list)
bl_primary_list_free(bl_primary_list);
exit:
g_mutex_unlock(&cb_ctx->pending_cb_mtx);
printf_dbg("OUT primary_by_uuid_cb\n");
}
/* This is also a list node constructor. */
GSList*
g_slist_prepend (GSList *list, gpointer data)
{
GSList *head = g_slist_alloc ();
head->data = data;
head->next = list;
return head;
}
void included_cb(GSList *includes, guint8 status, gpointer user_data)
{
GSList *l = NULL;
GSList *bl_included_list = NULL;
cb_ctx_t *cb_ctx = user_data;
printf_dbg("IN included_cb\n");
if (status) {
cb_ctx->cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ctx->cb_ret_msg, "Included callback: Failure: %s\n",
att_ecode2str(status));
goto error;
}
if (includes == NULL) {
cb_ctx->cb_ret_val = BL_NO_ERROR;
strcpy(cb_ctx->cb_ret_msg, "Included callback: Nothing found\n");
goto exit;
}
for (l = includes; l; l = l->next) {
struct gatt_included *incl = l->data;
bl_included_t *bl_included = bl_included_new(incl->uuid, incl->handle,
incl->range.start,
incl->range.end);
if (bl_included == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg, "Included callback: Malloc error\n");
goto error;
}
if (bl_included_list == NULL) {
bl_included_list = g_slist_alloc();
if (bl_included_list == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Included callback: Malloc error\n");
goto error;
}
bl_included_list->data = bl_included;
} else {
bl_included_list = g_slist_append(bl_included_list, bl_included);
}
}
cb_ctx->cb_ret_val = BL_NO_ERROR;
cb_ctx->cb_ret_pointer = bl_included_list;
goto exit;
error:
if (bl_included_list)
bl_included_list_free(bl_included_list);
exit:
if (l)
g_slist_free(l);
g_mutex_unlock(&cb_ctx->pending_cb_mtx);
printf_dbg("OUT included_cb\n");
}
GSList *local_interfaces_to_list(void)
{
GSList *interfaces = NULL;
#ifdef HAVE_GETIFADDRS
struct ifaddrs *ifap;
struct ifaddrs *ifa;
int family;
char ip[INET6_ADDRSTRLEN];
if (getifaddrs(&ifap)) {
goto end;
}
interfaces = g_slist_alloc();
for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
if (ifa->ifa_addr == NULL)
continue;
family = ifa->ifa_addr->sa_family;
memset(ip, 0x0, INET6_ADDRSTRLEN);
switch (family) {
case AF_INET:
{
struct sockaddr_in *addr4 = (struct sockaddr_in *)ifa->ifa_addr;
ws_inet_ntop4(&addr4->sin_addr, ip, sizeof(ip));
break;
}
case AF_INET6:
{
struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)ifa->ifa_addr;
ws_inet_ntop6(&addr6->sin6_addr, ip, sizeof(ip));
break;
}
default:
break;
}
/* skip loopback addresses */
if (!g_strcmp0(ip, "127.0.0.1") || !g_strcmp0(ip, "::1"))
continue;
if (*ip) {
interfaces = g_slist_prepend(interfaces, g_strdup(ip));
}
}
freeifaddrs(ifap);
end:
#endif /* HAVE_GETIFADDRS */
return interfaces;
}
GSList *
g_slist_prepend (GSList * list, gpointer data)
{
GSList *new_list;
new_list = g_slist_alloc ();
new_list->data = data;
new_list->next = list;
return new_list;
}
void init_cmd_system()
{
if( cmd_system_is_init() ) return;
_cmd_list = g_slist_alloc();
if( !_cmd_list )
{
Log( FATAL, "Command System Could not be Initialized" );
exit( -1 );
}
_cmd_list->data = NULL;
}
GSList*
g_slist_insert_before (GSList *slist,
GSList *sibling,
gpointer data)
{
if (!slist)
{
slist = g_slist_alloc ();
slist->data = data;
g_return_val_if_fail (sibling == NULL, slist);
return slist;
}
else
{
GSList *node, *last = NULL;
for (node = slist; node; last = node, node = last->next)
if (node == sibling)
break;
if (!last)
{
node = g_slist_alloc ();
node->data = data;
node->next = slist;
return node;
}
else
{
node = g_slist_alloc ();
node->data = data;
node->next = last->next;
last->next = node;
return slist;
}
}
}
GSList*
g_slist_copy (GSList *list)
{
GSList *new_list = NULL;
if (list)
{
GSList *last;
new_list = g_slist_alloc ();
new_list->data = list->data;
last = new_list;
list = list->next;
while (list)
{
last->next = g_slist_alloc ();
last = last->next;
last->data = list->data;
list = list->next;
}
}
return new_list;
}
GSList *
g_slist_append (GSList * list, gpointer data)
{
GSList *new_list;
GSList *last;
new_list = g_slist_alloc ();
new_list->data = data;
if (list)
{
last = g_slist_last (list);
last->next = new_list;
return list;
} else
return new_list;
}
GSList*
g_slist_insert (GSList *list,
gpointer data,
gint position)
{
GSList *prev_list;
GSList *tmp_list;
GSList *new_list;
if (position < 0)
return g_slist_append (list, data);
else if (position == 0)
return g_slist_prepend (list, data);
new_list = g_slist_alloc ();
new_list->data = data;
if (!list)
return new_list;
prev_list = NULL;
tmp_list = list;
while ((position-- > 0) && tmp_list)
{
prev_list = tmp_list;
tmp_list = tmp_list->next;
}
if (prev_list)
{
new_list->next = prev_list->next;
prev_list->next = new_list;
}
else
{
new_list->next = list;
list = new_list;
}
return list;
}
bool service_list_upgradable_packages_cb(LSHandle *handle, LSMessage *message, void *user_data)
{
struct package_list_info plistinfo;
GSList *iter;
jvalue_ref reply_obj = NULL;
jvalue_ref pkglist_obj = NULL;
jvalue_ref pkgname_obj = NULL;
if (opkg_new()) {
luna_service_message_reply_error_internal(handle, message);
return true;
}
plistinfo.pkgs = g_slist_alloc();
opkg_list_upgradable_packages(upgradable_package_list_cb, &plistinfo);
reply_obj = jobject_create();
jobject_put(reply_obj, J_CSTR_TO_JVAL("returnValue"), jboolean_create(true));
pkglist_obj = jarray_create(NULL);
for (iter = plistinfo.pkgs; iter != NULL; iter = g_slist_next(iter)) {
if (iter->data != NULL) {
gchar *pkgname = iter->data;
pkgname_obj = jstring_create(pkgname);
jarray_append(pkglist_obj, pkgname_obj);
}
}
jobject_put(reply_obj, J_CSTR_TO_JVAL("upgradablePackages"), pkglist_obj);
if(!luna_service_message_validate_and_send(handle, message, reply_obj))
luna_service_message_reply_error_internal(handle, message);
j_release(&reply_obj);
g_slist_free_full(plistinfo.pkgs, g_free);
opkg_free();
return true;
}
static void
rejilla_async_task_manager_insert_task (RejillaAsyncTaskManager *self,
RejillaAsyncTaskCtx *ctx)
{
GSList *iter;
GSList *node;
RejillaAsyncTaskCtx *tmp;
node = g_slist_alloc ();
node->data = ctx;
if (!self->priv->waiting_tasks) {
self->priv->waiting_tasks = node;
return;
}
tmp = self->priv->waiting_tasks->data;
if (tmp->priority < ctx->priority) {
node->next = self->priv->waiting_tasks;
self->priv->waiting_tasks = node;
return;
}
for (iter = self->priv->waiting_tasks; iter->next; iter = iter->next) {
tmp = iter->next->data;
if (tmp->priority < ctx->priority) {
node->next = iter->next;
iter->next = node;
return;
}
}
iter->next = node;
}
bool service_check_for_update_cb(LSHandle *handle, LSMessage *message, void *user_data)
{
int err = 0;
struct package_list_info plistinfo;
GSList *iter;
jvalue_ref reply_obj = NULL;
if (opkg_new()) {
luna_service_message_reply_error_internal(handle, message);
return true;
}
err = opkg_update_package_lists(NULL, NULL);
if (err != 0) {
luna_service_message_reply_custom_error(handle, message, "Failed to update package list from configured feeds");
return true;
}
plistinfo.pkgs = g_slist_alloc();
opkg_list_upgradable_packages(upgradable_package_list_cb, &plistinfo);
reply_obj = jobject_create();
jobject_put(reply_obj, J_CSTR_TO_JVAL("returnValue"), jboolean_create(true));
jobject_put(reply_obj, J_CSTR_TO_JVAL("updatesAvailable"),
jboolean_create(g_slist_length(plistinfo.pkgs) > 0));
if(!luna_service_message_validate_and_send(handle, message, reply_obj))
luna_service_message_reply_error_internal(handle, message);
j_release(&reply_obj);
g_slist_free_full(plistinfo.pkgs, g_free);
opkg_free();
return true;
}
int main(int argc, char **argv)
{
SaHpiInt32T ComputerNumber; //0..n-1
SaHpiInt32T SelectedSystem; //0..n-1
SaHpiHsPowerStateT Action;
COMPUTER_DATA *ComputerPtr;
SaHpiBoolT BladeSelected;
SaHpiBoolT MultipleBlades;
SaHpiBoolT ActionSelected;
SaHpiBoolT PrintUsage;
SaHpiBoolT DebugPrints;
GSList* Computer;
GSList* ComputerListHead;
int option;
SaHpiSessionIdT SessionId;
SaErrorT Status, Clean_Up_Status;
SaHpiEntryIdT RptEntry, RptNextEntry;
SaHpiRptEntryT Report;
SaHpiInt32T Index, EntityElement;
SaHpiHsPowerStateT PowerState;
char PowerStateString[3][7]={"off\0","on\0","cycled\0"};
SaHpiVersionT HpiVersion;
/*
// Print out the Program name and Version
*/
PROGRAM_HEADER;
/* Set Program Defaults */
ComputerNumber = 0;
SelectedSystem = 0;
Action = 255; //set it out of range to stand for status
BladeSelected = FALSE;
MultipleBlades = FALSE;
ActionSelected = FALSE;
PrintUsage = FALSE;
DebugPrints = FALSE;
RptEntry = SAHPI_FIRST_ENTRY;
/* Parse out option instructions */
while (1)
{
option = getopt(argc, argv, "dpruxb:");
if ((option == EOF) || (PrintUsage == TRUE))
{
break; //break out of the while loop
}
switch (option)
{
case 'd':
Action = SAHPI_HS_POWER_OFF;
ActionSelected = TRUE;
break;
case 'p':
Action = SAHPI_HS_POWER_ON;
ActionSelected = TRUE;
break;
case 'r':
Action = SAHPI_HS_POWER_CYCLE;
ActionSelected = TRUE;
break;
case 'u':
BladeSelected = TRUE;
ActionSelected = TRUE;
break;
case 'x':
DebugPrints = TRUE;
break;
case 'b':
if (*optarg == 0)
{
PrintUsage = TRUE;
break; //no argument
}
SelectedSystem = atoi(optarg) - 1; //Normalizing to 0...n-1
if ((SelectedSystem > MAX_MANAGED_SYSTEMS) ||
(SelectedSystem < 0))
{
//Argument is out of Range
PrintUsage = TRUE;
}
BladeSelected = TRUE;
break;
default:
PrintUsage = TRUE;
break;
} //end of switch statement
} //end of argument parsing while loop
if (PrintUsage == TRUE)
{
UsageMessage(PrgName);
/*BUG: what is the exit code for bad argument?*/
exit(0); //When we exit here, there is nothing to clean up
}
/* Initialize the first of a list of computers */
HPI_POWER_DEBUG_PRINT("1.0 Initializing the List Structure for the computers\n");
Computer = g_slist_alloc();
ComputerListHead = Computer;
HPI_POWER_DEBUG_PRINT("1.1 Allocating space for the information on each computer\n");
ComputerPtr = (COMPUTER_DATA*)malloc(sizeof(COMPUTER_DATA));
Computer->data = (gpointer)ComputerPtr;
/* Initialize HPI domain and session */
HPI_POWER_DEBUG_PRINT("2.0 Initalizing HPI\n");
Status = saHpiInitialize(&HpiVersion);
if (Status == SA_OK)
{
HPI_POWER_DEBUG_PRINT("2.1 Initalizing HPI Session\n");
Status = saHpiSessionOpen(SAHPI_DEFAULT_DOMAIN_ID,
&SessionId,
NULL);
}
if (Status == SA_OK)
{
/* Find all of the individual systems */
// regenerate the Resource Presence Table(RPT)
HPI_POWER_DEBUG_PRINT("2.2 Hpi Discovery\n");
Status = saHpiResourcesDiscover(SessionId);
}
HPI_POWER_DEBUG_PRINT("3.0 Walking through all of the Report Tables\n");
while ((Status == SA_OK) && (RptEntry != SAHPI_LAST_ENTRY))
{
HPI_POWER_DEBUG_PRINT("@");
Status = saHpiRptEntryGet(SessionId,
RptEntry,
&RptNextEntry,
&Report);
RptEntry = RptNextEntry;
// Blades will have the first Element of the Entity Path set to SBC_BLADE
EntityElement = 0;
HPI_POWER_DEBUG_PRINT(".");
if (Report.ResourceEntity.Entry[EntityElement].EntityType ==
SAHPI_ENT_SBC_BLADE)
{
HPI_POWER_DEBUG_PRINT("#");
// We have found a Blade
ComputerPtr->ResID = Report.ResourceId;
/* enumerate this list as created */
ComputerPtr->number = ComputerNumber;
ComputerNumber++;
ComputerPtr->Instance =
Report.ResourceEntity.Entry[EntityElement].EntityLocation;
// find a Name string for this blade
sprintf(ComputerPtr->NameStr,
"%s %d",
(char*)Report.ResourceTag.Data,
(int) ComputerPtr->Instance);
// Create a new allocation for another system
ComputerPtr = (COMPUTER_DATA*)malloc(sizeof(COMPUTER_DATA));
// Add another member to the list
Computer = g_slist_append(Computer,(gpointer)ComputerPtr);
// set a flag that we are working with blades
MultipleBlades = TRUE;
}
}
HPI_POWER_DEBUG_PRINT("\n4.0 Generating Listing of options to choose from:\n");
/* If parsed option does not select blade and
more than one is found */
if ((MultipleBlades == TRUE) && (BladeSelected == FALSE) && (Status == SA_OK))
{
HPI_POWER_DEBUG_PRINT("4.1 Printing out a listing of all the blades\n");
for (Index = 0; Index < ComputerNumber; Index++)
{
HPI_POWER_DEBUG_PRINT("$");
// obtain the information for this computer
ComputerPtr = g_slist_nth_data(ComputerListHead, Index);
if (ComputerPtr == NULL)
{
printf("Call returned a NULL\n");
break;
}
// retrieve the power status for this computer
HPI_POWER_DEBUG_PRINT("%%");
PowerState = 0;
Status = saHpiResourcePowerStateGet(SessionId,
ComputerPtr->ResID,
&PowerState);
if (Status != SA_OK)
{
printf("%s does not support PowerStateGet",
ComputerPtr->NameStr);
}
/* Print out all of the systems */
printf("%2d) %20s - %s \n\r", (Index + 1),
ComputerPtr->NameStr,
PowerStateString[PowerState]);
}
/* Prompt user to select one */
while ((Index >= ComputerNumber) || (Index < 0))
{
printf("\nEnter the number for the desired blade: ");
scanf("%d",&Index);
Index--; //normalize to 0..n-1
printf("\n");
}
BladeSelected = TRUE;
SelectedSystem = Index;
}
HPI_POWER_DEBUG_PRINT("4.2 Generating Listing of Actions to choose from\n");
/* If action is not selected */
if ((ActionSelected == FALSE) && (Status == SA_OK))
{
/* prompt user to select an action */
printf("\nSelect Action: 0 - Off; 1 - On; 2 - Reset; 3 - Status \n\r");
printf("Enter a number 0 to 3: ");
scanf("%d", &Index);
switch (Index)
{
case 0:
Action = SAHPI_HS_POWER_OFF;
break;
case 1:
Action = SAHPI_HS_POWER_ON;
break;
case 2:
Action = SAHPI_HS_POWER_CYCLE;
break;
default:
Action = 255; //Out of Range for "Status"
break;
}
}
/* execute the command */
if (Status == SA_OK)
{
HPI_POWER_DEBUG_PRINT("5.0 Executing the command\n\r");
// obtain the information for this computer
ComputerPtr = g_slist_nth_data(ComputerListHead, SelectedSystem);
if (Action <= SAHPI_HS_POWER_CYCLE)
{
HPI_POWER_DEBUG_PRINT("5.1 Setting a New Power State\n\r");
// Set the new power status for this computer
Status = saHpiResourcePowerStateSet(SessionId,
ComputerPtr->ResID,
Action);
/* return status */
if (Status == SA_OK)
{
printf("\n%s -- %20s has been successfully powered %s\n",
PrgName,
ComputerPtr->NameStr,
PowerStateString[Action]);
}
}
else // Report Power status for the system
{
HPI_POWER_DEBUG_PRINT("5.2 Getting the Power Status\n\r");
// retrieve the power status for this computer
PowerState = 0;
Status = saHpiResourcePowerStateGet(SessionId,
ComputerPtr->ResID,
&PowerState);
if (Status != SA_OK)
{
printf("%s does not support PowerStateGet",
ComputerPtr->NameStr);
}
/* Print out Status for this system */
printf("%2d) %20s - %s \n\r", (ComputerPtr->number + 1),
ComputerPtr->NameStr,
PowerStateString[PowerState]);
}
}
HPI_POWER_DEBUG_PRINT("6.0 Clean up");
/* clean up */
Clean_Up_Status = saHpiSessionClose(SessionId);
Clean_Up_Status = saHpiFinalize();
//Free all of the Allocations for the Computer data
Computer = ComputerListHead;
while (Computer != NULL)
{
free(Computer->data);
Computer = g_slist_next(Computer);
}
//Free the whole List
g_slist_free(ComputerListHead);
/* return status code and exit */
if (Status != SA_OK)
{
HPI_POWER_DEBUG_PRINT("7.0 Reporting Bad Status");
AppHpiPrintError(Status, PrgName);
}
return(Status);
}
int main(int argc, char **argv)
{
SaHpiInt32T ComputerNumber = 0; //0..n-1
SaHpiInt32T SelectedSystem = 0; //0..n-1
SaHpiPowerStateT Action = 255; //set it out of range to stand for status;
COMPUTER_DATA *ComputerPtr;
SaHpiBoolT BladeSelected = FALSE;
SaHpiBoolT MultipleBlades = FALSE;
SaHpiBoolT ActionSelected = FALSE;
GSList* Computer;
GSList* ComputerListHead;
SaHpiSessionIdT SessionId;
SaErrorT Status;
SaHpiEntryIdT RptEntry = SAHPI_FIRST_ENTRY;
SaHpiEntryIdT RptNextEntry;
SaHpiRptEntryT Report;
SaHpiInt32T Index, EntityElement;
SaHpiPowerStateT PowerState;
char PowerStateString[3][7]= {"off\0","on\0","cycled\0"};
GOptionContext *context;
/* Print version strings */
oh_prog_version(argv[0]);
/* Parsing options */
static char usetext[]="- Exercise HPI Power Management APIs\n "
OH_SVN_REV;
OHC_PREPARE_REVISION(usetext);
context = g_option_context_new (usetext);
g_option_context_add_main_entries (context, my_options, NULL);
if (!ohc_option_parse(&argc, argv,
context, &copt,
OHC_ALL_OPTIONS
- OHC_ENTITY_PATH_OPTION //TODO: Feature 880127
- OHC_VERBOSE_OPTION )) { // no verbose mode implemented
g_option_context_free (context);
return 1;
}
g_option_context_free (context);
if (f_down) {
Action = SAHPI_POWER_OFF;
ActionSelected = TRUE;
}
if (f_up) {
Action = SAHPI_POWER_ON;
ActionSelected = TRUE;
}
if (f_reset) {
Action = SAHPI_POWER_CYCLE;
ActionSelected = TRUE;
}
if (f_unattended) {
BladeSelected = TRUE;
ActionSelected = TRUE;
}
if (f_blade > 0) {
BladeSelected = TRUE;
SelectedSystem = f_blade - 1; //Normalizing to 0...n-1
if ((SelectedSystem > MAX_MANAGED_SYSTEMS) ||
(SelectedSystem < 0)) {
CRIT("hpipower: blade number out of range");
return 1; //When we exit here, there is nothing to clean up
}
}
/* Initialize the first of a list of computers */
HPI_POWER_DEBUG_PRINT("Initializing the List Structure for the computers");
Computer = g_slist_alloc();
ComputerListHead = Computer;
HPI_POWER_DEBUG_PRINT("Allocating space for the information on each computer");
ComputerPtr = (COMPUTER_DATA*)malloc(sizeof(COMPUTER_DATA));
Computer->data = (gpointer)ComputerPtr;
/* Initialize HPI domain and session */
HPI_POWER_DEBUG_PRINT("Initalizing HPI Session");
Status = ohc_session_open_by_option ( &copt, &SessionId);
if (Status == SA_OK)
{
/* Find all of the individual systems */
// regenerate the Resource Presence Table(RPT)
HPI_POWER_DEBUG_PRINT("Hpi Discovery");
Status = saHpiDiscover(SessionId);
} else {
CRIT("Initalizing HPI Session FAILED, code %s", oh_lookup_error(Status));
return -1;
}
HPI_POWER_DEBUG_PRINT("Walking through all of the Report Tables");
while ((Status == SA_OK) && (RptEntry != SAHPI_LAST_ENTRY))
{
HPI_POWER_DEBUG_PRINT1("@");
Status = saHpiRptEntryGet(SessionId,
RptEntry,
&RptNextEntry,
&Report);
RptEntry = RptNextEntry;
// Blades will have the first Element of the Entity Path set to SBC_BLADE
EntityElement = 0;
HPI_POWER_DEBUG_PRINT1(".");
if (Report.ResourceCapabilities & SAHPI_CAPABILITY_POWER)
{
char tagbuf[SAHPI_MAX_TEXT_BUFFER_LENGTH + 1];
HPI_POWER_DEBUG_PRINT1("#");
// We have found a Blade
ComputerPtr->ResID = Report.ResourceId;
/* enumerate this list as created */
ComputerPtr->number = ComputerNumber;
ComputerNumber++;
ComputerPtr->Instance =
Report.ResourceEntity.Entry[EntityElement].EntityLocation;
// find a Name string for this blade
HpiTextBuffer2CString( &Report.ResourceTag, tagbuf );
snprintf(ComputerPtr->NameStr, sizeof(ComputerPtr->NameStr),
"%s %d",
tagbuf,
(int) ComputerPtr->Instance);
// Create a new allocation for another system
ComputerPtr = (COMPUTER_DATA*)malloc(sizeof(COMPUTER_DATA));
// Add another member to the list
Computer = g_slist_append(Computer,(gpointer)ComputerPtr);
// set a flag that we are working with blades
MultipleBlades = TRUE;
}
}
HPI_POWER_DEBUG_PRINT("Generating Listing of options to choose from:");
/* If parsed option does not select blade and
more than one is found */
if ((MultipleBlades == TRUE) && (BladeSelected == FALSE) && (Status == SA_OK))
{
HPI_POWER_DEBUG_PRINT("Printing out a listing of all the blades");
for (Index = 0; Index < ComputerNumber; Index++)
{
HPI_POWER_DEBUG_PRINT1("$");
// obtain the information for this computer
ComputerPtr = g_slist_nth_data(ComputerListHead, Index);
if (ComputerPtr == NULL)
{
printf("Call returned a NULL\n");
break;
}
// retrieve the power status for this computer
HPI_POWER_DEBUG_PRINT1("%%");
PowerState = 0;
Status = saHpiResourcePowerStateGet(SessionId,
ComputerPtr->ResID,
&PowerState);
if (Status != SA_OK)
{
printf("%s does not support PowerStateGet",
ComputerPtr->NameStr);
}
/* Print out all of the systems */
printf("%2d) %20s - %s \n\r", (Index + 1),
ComputerPtr->NameStr,
PowerStateString[PowerState]);
}
/* Prompt user to select one */
while ((Index >= ComputerNumber) || (Index < 0))
{
printf("\nEnter the number for the desired blade: ");
if (scanf("%d",&Index) == 0) {
printf("Incorrect number\n");
}
Index--; //normalize to 0..n-1
printf("\n");
}
BladeSelected = TRUE;
SelectedSystem = Index;
}
HPI_POWER_DEBUG_PRINT("Generating Listing of Actions to choose from");
/* If action is not selected */
if ((ActionSelected == FALSE) && (Status == SA_OK))
{
/* prompt user to select an action */
printf("\nSelect Action: 0 - Off; 1 - On; 2 - Reset; 3 - Status \n\r");
printf("Enter a number 0 to 3: ");
if (scanf("%d", &Index) == 0) {
Index = -1;
}
switch (Index)
{
case 0:
Action = SAHPI_POWER_OFF;
break;
case 1:
Action = SAHPI_POWER_ON;
break;
case 2:
Action = SAHPI_POWER_CYCLE;
break;
default:
Action = 255; //Out of Range for "Status"
break;
}
}
/* execute the command */
if (Status == SA_OK)
{
HPI_POWER_DEBUG_PRINT("Executing the command");
// obtain the information for this computer
ComputerPtr = g_slist_nth_data(ComputerListHead, SelectedSystem);
if (ComputerPtr == NULL)
{
printf("Error: Selected system %d was not found.\n", SelectedSystem);
return -1;
}
if (Action <= SAHPI_POWER_CYCLE)
{
HPI_POWER_DEBUG_PRINT("Setting a New Power State");
// Set the new power status for this computer
Status = saHpiResourcePowerStateSet(SessionId,
ComputerPtr->ResID,
Action);
/* return status */
if (Status == SA_OK)
{
printf("\n%s -- %20s has been successfully powered %s\n",
argv[0],
ComputerPtr->NameStr,
PowerStateString[Action]);
}
}
else // Report Power status for the system
{
HPI_POWER_DEBUG_PRINT("Getting the Power Status\r");
// retrieve the power status for this computer
PowerState = 0;
Status = saHpiResourcePowerStateGet(SessionId,
ComputerPtr->ResID,
&PowerState);
if (Status != SA_OK)
{
printf("%s does not support PowerStateGet",
ComputerPtr->NameStr);
}
/* Print out Status for this system */
printf("%2d) %20s - %s \n\r", (ComputerPtr->number + 1),
ComputerPtr->NameStr,
PowerStateString[PowerState]);
}
}
HPI_POWER_DEBUG_PRINT("Clean up");
/* clean up */
saHpiSessionClose(SessionId);
//Free all of the Allocations for the Computer data
Computer = ComputerListHead;
while (Computer != NULL)
{
free(Computer->data);
Computer = g_slist_next(Computer);
}
//Free the whole List
g_slist_free(ComputerListHead);
/* return status code and exit */
if (Status != SA_OK)
{
HPI_POWER_DEBUG_PRINT("Reporting Bad Status");
CRIT("Error: %s", oh_lookup_error(Status));
}
return(Status);
}
void char_desc_cb(guint8 status, const guint8 *pdu, guint16 plen,
gpointer user_data) {
struct att_data_list *list = NULL;
guint8 format;
uint16_t handle = 0xffff;
int i;
char uuid_str[MAX_LEN_UUID_STR];
uint8_t *value;
printf_dbg("[CB] IN char_desc_cb\n");
if (status) {
cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ret_msg, "Characteristic descriptor "
"callback: Failure: %s\n", att_ecode2str(status));
goto exit;
}
list = dec_find_info_resp(pdu, plen, &format);
if (list == NULL) {
cb_ret_val = BL_NO_ERROR;
strcpy(cb_ret_msg, "Characteristic descriptor callback: Nothing found\n");
goto exit;
}
for (i = 0; i < list->num; i++) {
bt_uuid_t uuid;
value = list->data[i];
handle = att_get_u16(value);
if (format == 0x01)
uuid = att_get_uuid16(&value[2]);
else
uuid = att_get_uuid128(&value[2]);
bt_uuid_to_string(&uuid, uuid_str, MAX_LEN_UUID_STR);
if (strcmp(uuid_str, GATT_PRIM_SVC_UUID_STR) &&
strcmp(uuid_str, GATT_SND_SVC_UUID_STR) &&
strcmp(uuid_str, GATT_INCLUDE_UUID_STR) &&
strcmp(uuid_str, GATT_CHARAC_UUID_STR)) {
bl_desc_t *bl_desc = bl_desc_new(uuid_str, handle);
if (bl_desc == NULL) {
cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ret_msg, "Characteristic descriptor callback: Malloc "
"error\n");
goto exit;
}
if (bl_desc_list == NULL) {
bl_desc_list = g_slist_alloc();
if (bl_desc_list == NULL) {
cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ret_msg, "Characteristic descriptor callback: Malloc "
"error\n");
goto exit;
}
bl_desc_list->data = bl_desc;
} else {
bl_desc_list = g_slist_append(bl_desc_list, bl_desc);
}
} else {
printf_dbg("Reach end of descriptor list\n");
goto exit;
}
}
if ((handle != 0xffff) && (handle < end_handle_cb)) {
printf_dbg("[CB] OUT with asking for a new request\n");
if (gatt_discover_char_desc(attrib, handle + 1, end_handle_cb,
char_desc_cb, NULL)) {
goto next;
}
cb_ret_val = BL_SEND_REQUEST_ERROR;
strcpy(cb_ret_msg, "Unable to send request\n");
}
exit:
if (bl_desc_list) {
// Return what we got if we add something
cb_ret_val = BL_NO_ERROR;
cb_ret_pointer = bl_desc_list;
}
bl_desc_list = NULL;
g_mutex_unlock(pending_callback);
next:
if (list)
att_data_list_free(list);
printf_dbg("[CB] OUT char_desc_cb\n");
}
/******************************************************************
Display the mail
*******************************************************************/
static int read_window_display_mail(struct Read_Data *data, struct mail *m)
{
char path[512];
if (!data->folder_path) return 0;
data->ref_mail = m;
getcwd(path,sizeof(path));
if (chdir(data->folder_path)==-1) return 0;
if ((data->mail = mail_create_from_file(m->filename)))
{
int dont_show = 0; /* attachments */
chdir(path); /* should be a absolute path */
mail_read_contents(data->folder_path,data->mail);
mail_create_html_header(data->mail, 0);
if (!data->mail->num_multiparts || (data->mail->num_multiparts == 1 && !data->mail->multipart_array[0]->num_multiparts))
{
/* mail has only one part */
dont_show = 1;
} else
{
}
if (data->mail_list) g_slist_free(data->mail_list);
data->mail_list = g_slist_alloc();
insert_mail(data,data->mail);
show_mail(data,mail_find_initial(data->mail));
} else chdir(path);
return 1;
#if 0
if ((lock = Lock(data->folder_path,ACCESS_READ))) /* maybe it's better to use an absoulte path here */
{
BPTR old_dir = CurrentDir(lock);
if ((data->mail = mail_create_from_file(mail->filename)))
{
int dont_show = 0;
mail_read_contents(data->folder_path,data->mail);
mail_create_html_header(data->mail);
if (!data->mail->num_multiparts || (data->mail->num_multiparts == 1 && !data->mail->multipart_array[0]->num_multiparts))
{
/* mail has only one part */
set(data->attachments_group, MUIA_ShowMe, FALSE);
dont_show = 1;
} else
{
DoMethod((Object*)xget(data->attachments_group,MUIA_Parent), MUIM_Group_InitChange);
}
DoMethod(data->attachments_group, MUIM_Group_InitChange);
DisposeAllChilds(data->attachments_group);
data->attachments_last_selected = NULL;
insert_mail(data,data->mail);
DoMethod(data->attachments_group, OM_ADDMEMBER, HSpace(0));
DoMethod(data->attachments_group, MUIM_Group_ExitChange);
if (!dont_show)
{
set(data->attachments_group, MUIA_ShowMe, TRUE);
DoMethod((Object*)xget(data->attachments_group,MUIA_Parent), MUIM_Group_ExitChange);
}
show_mail(data,mail_find_initial(data->mail));
CurrentDir(old_dir);
set(App, MUIA_Application_Sleep, FALSE);
return 1;
}
CurrentDir(old_dir);
}
DoMethod(data->attachments_group, MUIM_Group_InitChange);
DisposeAllChilds(data->attachments_group);
data->attachments_last_selected = NULL;
DoMethod(data->attachments_group, OM_ADDMEMBER, HSpace(0));
DoMethod(data->attachments_group, MUIM_Group_ExitChange);
set(App, MUIA_Application_Sleep, FALSE);
return 0;
#endif
}
static void parseScores(char *buf, int len)
{ /* read string buffer and make adequate 'currentScores' structure */
char *ptr = buf;
char *end = buf+len;
#define isWhitespace(c) (c==' '||c=='\t')
currentScores = g_slist_alloc();
while (ptr<end)
{
switch(*ptr) {
case ' ':
case '\t':
case '\n':
ptr++;
break;
case '#':
{
while(*ptr!='\n') { ++ptr; }
ptr++;
break;
}
default:
{
int l;
char *n, *s, *p = ptr;
while(!(isWhitespace(*p)) && *p!='\n') { p++; }
l = p-ptr;
n = (char*)g_malloc(sizeof(char)*l);
strncpy(n,ptr,l);
n[l]='\0';
while(isWhitespace(*p)) { p++; }
ptr = p;
while(!(isWhitespace(*p)) && *p!='\n') { p++; }
l = p-ptr;
s = (char*)g_malloc(sizeof(char)*l);
strncpy(s,ptr,l);
s[l]='\0';
ptr = p;
DEBUG(("\t '%s'-->'%s'\n",n,s));
{
ScoreRecord *record;
record = (ScoreRecord*)g_malloc(sizeof(ScoreRecord));
record->name = n;
record->score = s;
currentScores = g_slist_append(currentScores,record);
}
}
}
}
DONE:
}
void readScores(char *scorefile)
{
if(scorefile!=(char*)NULL)
{
char *buf;
struct stat sb;
FILE *file = fopen(scorefile,"r");
currentScoresFile = scorefile;
{
/*if(stat(scorefile,&sb)==0) /* could use fstat(fileno(file),&sb) instead */
if(fstat(fileno(file),&sb)!=0)
{
printf("can't stat file '%s'!\n",scorefile);
exit(EXIT_FAILURE);
}
}
{
buf = (char*)g_malloc(sizeof(char)*(sb.st_size+1));
if(buf==NULL)
{
printf("can't malloc memory!\n");
exit(EXIT_FAILURE);
}
(void)fread(buf,sb.st_size,1,file);
parseScores(buf,sb.st_size);
}
fclose(file);
}
}
void saveScores(GSList *rec, char *filename)
{
FILE *file;
if(filename==(char*)NULL)
filename = currentScoresFile;
if(filename==(char*)NULL)
filename = "~/.gms-scores";
if(strcasecmp(filename,"stdout"))
file = stdout;
else
file = fopen(filename,"w"); /* replace the contents of this file ! */
if(file==(FILE*)NULL)
{
char *msg;
msg = (char*)g_malloc(sizeof(char)*(strlen(filename)+20));
sprintf(msg,"Can't open file '%s'",filename);
ModalInfoBox(msg,"Error!");
g_free(msg);
return;
}
fprintf(file,"# File generated by "NAME", do not edit!\n");
{
#if 0
ScoreRecord *r = rec;
while(r!=(ScoreRecord*)NULL)
{
fprintf(file,"%s\t%s\n",r->name,r->score);
r++;
}
#else
GSList *lst = rec;
while(lst = g_slist_next(lst))
{
ScoreRecord *record = (ScoreRecord*)lst->data;
fprintf(file,"%s\t%s\n",record->name,record->score);
}
#endif
}
fclose(file);
}
/*
* Create quit dialog
*/
gboolean av_dialog_quit_new(const GPtrArray *list, guint list_len)
{
GSList *chkbtn_list = NULL, *filelist = NULL;
GtkWidget *content_area = NULL;
gboolean quit_status = TRUE;
gint result = 0;
/* Create quit dialog */
main_widget.dialog_quit = gtk_dialog_new();
/* Set window title */
gtk_window_set_title(GTK_WINDOW(main_widget.dialog_quit), AV_WIDGET_QUIT_DIALOG_TITLE);
/* Set window position */
gtk_window_set_position(GTK_WINDOW(main_widget.dialog_quit), GTK_WIN_POS_CENTER);
/* Set as resizable window */
gtk_window_set_resizable(GTK_WINDOW(main_widget.dialog_quit), FALSE);
/* Get content area in dialog */
content_area = gtk_dialog_get_content_area(GTK_DIALOG(main_widget.dialog_quit));
/* Create check-button widgets list */
chkbtn_list = dialog_chkbtn_list_new(content_area, list, list_len);
/* Create buttons in dialog */
if (NULL == chkbtn_list)
{
gtk_dialog_add_buttons(GTK_DIALOG(main_widget.dialog_quit),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
}
else
{
gtk_dialog_add_buttons(GTK_DIALOG(main_widget.dialog_quit),
AV_WIDGET_BUTTONS_CLOSE_WITHOUT_SAVING, AV_RESPONSE_CLOSE_WITHOUT_SAVING,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, AV_RESPONSE_SAVE,
NULL);
}
result = gtk_dialog_run(GTK_DIALOG(main_widget.dialog_quit));
switch (result)
{
case GTK_RESPONSE_CANCEL:
AV_DBG("%s: canceled\n", __func__);
gtk_widget_destroy(main_widget.dialog_quit);
return FALSE;
case GTK_RESPONSE_OK:
AV_DBG("%s: closed only\n", __func__);
break;
case AV_RESPONSE_CLOSE_WITHOUT_SAVING:
AV_DBG("%s: closed without saving\n", __func__);
break;
case AV_RESPONSE_SAVE:
AV_DBG("%s: closed and saved\n", __func__);
filelist = g_slist_alloc();
g_slist_foreach(chkbtn_list, (GFunc)dialog_chkbtn_list_active_new, &filelist);
av_doc_save_filelist(filelist);
break;
default:
quit_status = FALSE;
break;
}
/* Free file selected list in check-button list */
dialog_chkbtn_list_active_del(filelist);
/* Free check-button widgets list */
dialog_chkbtn_list_del(chkbtn_list);
/* All widgets will be destroyed by 'main_quit' */
av_main_quit();
return quit_status;
}
static GSList *insert_new_accelcand(GSList * list, float power, float sigma,
int numharm, double rr, double zz, int *added)
/* Checks the current list to see if there is already */
/* a candidate within ACCEL_CLOSEST_R bins. If not, */
/* it adds it to the list in increasing freq order. */
{
GSList *tmp_list = list, *prev_list = NULL, *new_list;
double prev_diff_r = ACCEL_CLOSEST_R + 1.0, next_diff_r;
*added = 0;
if (!list) {
new_list = g_slist_alloc();
new_list->data = (gpointer *) create_accelcand(power, sigma, numharm, rr, zz);
*added = 1;
return new_list;
}
/* Find the correct position in the list for the candidate */
while ((tmp_list->next) && (((accelcand *) (tmp_list->data))->r < rr)) {
prev_list = tmp_list;
tmp_list = tmp_list->next;
}
next_diff_r = fabs(rr - ((accelcand *) (tmp_list->data))->r);
if (prev_list)
prev_diff_r = fabs(rr - ((accelcand *) (prev_list->data))->r);
/* Similar candidate(s) is(are) present */
if (prev_diff_r < ACCEL_CLOSEST_R) {
/* Overwrite the prev cand */
if (((accelcand *) (prev_list->data))->sigma < sigma) {
free_accelcand(prev_list->data, NULL);
prev_list->data = (gpointer *) create_accelcand(power, sigma,
numharm, rr, zz);
*added = 1;
}
if (next_diff_r < ACCEL_CLOSEST_R) {
if (((accelcand *) (tmp_list->data))->sigma < sigma) {
free_accelcand(tmp_list->data, NULL);
if (*added) {
/* Remove the next cand */
list = g_slist_remove_link(list, tmp_list);
g_slist_free_1(tmp_list);
} else {
/* Overwrite the next cand */
tmp_list->data = (gpointer *) create_accelcand(power, sigma,
numharm, rr, zz);
*added = 1;
}
}
}
} else if (next_diff_r < ACCEL_CLOSEST_R) {
/* Overwrite the next cand */
if (((accelcand *) (tmp_list->data))->sigma < sigma) {
free_accelcand(tmp_list->data, NULL);
tmp_list->data = (gpointer *) create_accelcand(power, sigma,
numharm, rr, zz);
*added = 1;
}
} else { /* This is a new candidate */
new_list = g_slist_alloc();
new_list->data = (gpointer *) create_accelcand(power, sigma, numharm, rr, zz);
*added = 1;
if (!tmp_list->next &&
(((accelcand *) (tmp_list->data))->r < (rr - ACCEL_CLOSEST_R))) {
tmp_list->next = new_list;
return list;
}
if (prev_list) {
prev_list->next = new_list;
new_list->next = tmp_list;
} else {
new_list->next = list;
return new_list;
}
}
return list;
}
struct audio_service* audio_service_create()
{
struct audio_service *service;
LSError error;
pa_mainloop_api *mainloop_api;
char name[100];
service = g_try_new0(struct audio_service, 1);
if (!service)
return NULL;
LSErrorInit(&error);
if (!LSRegisterPubPriv("org.webosports.audio", &service->handle, false, &error)) {
g_warning("Failed to register the luna service: %s", error.message);
LSErrorFree(&error);
goto error;
}
if (!LSRegisterCategory(service->handle, "/", audio_service_methods,
NULL, NULL, &error)) {
g_warning("Could not register service category: %s", error.message);
LSErrorFree(&error);
goto error;
}
if (!LSCategorySetData(service->handle, "/", service, &error)) {
g_warning("Could not set daa for service category: %s", error.message);
LSErrorFree(&error);
goto error;
}
if (!LSGmainAttach(service->handle, event_loop, &error)) {
g_warning("Could not attach service handle to mainloop: %s", error.message);
LSErrorFree(&error);
goto error;
}
service->pa_mainloop = pa_glib_mainloop_new(g_main_context_default());
mainloop_api = pa_glib_mainloop_get_api(service->pa_mainloop);
snprintf(name, 100, "AudioServiceContext:%i", getpid());
service->context = pa_context_new(mainloop_api, name);
service->context_initialized = false;
pa_context_set_state_callback(service->context, context_state_cb, service);
if (pa_context_connect(service->context, NULL, 0, NULL) < 0) {
g_warning("Failed to connect to PulseAudio");
pa_context_unref(service->context);
pa_glib_mainloop_free(service->pa_mainloop);
goto error;
}
sample_list = g_slist_alloc();
return service;
error:
if (service->handle != NULL) {
LSUnregister(service->handle, &error);
LSErrorFree(&error);
}
g_free(service);
return NULL;
}
