static void XMMS_Set_ToggleFn(char *name, void *togglefunc, void *getfunc) {
int ret, set;
gboolean (*xmms_togglefunc)(gint) = togglefunc;
gboolean (*xmms_getfunc)(gint) = getfunc;
if (!MP3_IsPlayerRunning()) {
Com_Printf("%s\n", mp3_notrunning_msg);
return;
}
if (Cmd_Argc() >= 3) {
Com_Printf("Usage: %s [on|off|toggle]\n", Cmd_Argv(0));
return;
}
ret = xmms_getfunc(XMMS_SESSION);
if (Cmd_Argc() == 1) {
Com_Printf("%s is %s\n", name, (ret == 1) ? "on" : "off");
return;
}
if (!Q_stricmp(Cmd_Argv(1), "on")) {
set = 1;
} else if (!Q_stricmp(Cmd_Argv(1), "off")) {
set = 0;
} else if (!Q_stricmp(Cmd_Argv(1), "toggle")) {
set = ret ? 0 : 1;
} else {
Com_Printf("Usage: %s [on|off|toggle]\n", Cmd_Argv(0));
return;
}
if (set && !ret)
xmms_togglefunc(XMMS_SESSION);
else if (!set && ret)
xmms_togglefunc(XMMS_SESSION);
Com_Printf("%s set to %s\n", name, set ? "on" : "off");
}
/**
* gpa_printer_list_load_from_module:
* @path:
*
* Load printers from a module
**/
static gboolean
gpa_printer_list_load_from_module (GPAList *printers, const gchar *path)
{
GpaModuleInfo info;
GModule *handle;
gboolean (*init) (GpaModuleInfo *info);
gint retval = FALSE;
handle = g_module_open (path, G_MODULE_BIND_LAZY);
if (!handle) {
g_warning ("Can't g_module_open %s\n", path);
return retval;
}
if (!g_module_symbol (handle, "gpa_module_init", (gpointer*) &init)) {
g_warning ("Error. Module %s does not contains an init function\n", path);
goto module_error;
}
if (!(init) (&info)) {
g_warning ("Could not initialize module %s\n", path);
goto module_error;
}
(info.printer_list_append) (printers, path);
retval = TRUE;
module_error:
g_module_close (handle);
return retval;
}
static void
gpa_printer_load_data (GPAPrinter *printer)
{
GpaModuleInfo info;
GModule *handle = NULL;
gboolean (*init) (GpaModuleInfo *info);
void (*load_data) (GPAPrinter *printer);
if (printer->is_complete)
return;
g_return_if_fail (printer->module_path != NULL);
if ((handle = printer->module_handle) != NULL &&
g_module_symbol (handle, "gpa_module_init",
(gpointer*) &init) &&
g_module_symbol (handle, "gpa_module_load_data",
(gpointer*) &load_data)) {
if (init (&info))
load_data (printer);
printer->module_handle = handle;
} else
g_warning ("gpa_module_load_data cannot be retrieved from "
"module %s", printer->module_path);
return;
}
gboolean
plugin_load_module(const gchar *module_name, GlobalConfig *cfg, CfgArgs *args)
{
GModule *mod;
static GModule *main_module_handle;
gboolean (*init_func)(GlobalConfig *cfg, CfgArgs *args);
gchar *module_init_func;
const gchar *mp;
gchar *p;
if (!main_module_handle)
main_module_handle = g_module_open(NULL, 0);
module_init_func = g_strdup_printf("%s_module_init", module_name);
for (p = module_init_func; *p; p++)
{
if ((*p) == '-')
*p = '_';
}
if (g_module_symbol(main_module_handle, module_init_func, (gpointer *) &init_func))
{
/* already linked in, no need to load explicitly */
goto call_init;
}
if (cfg->lexer)
mp = cfg_args_get(cfg->lexer->globals, "module-path");
else
mp = NULL;
if (!mp)
mp = module_path;
mod = plugin_dlopen_module(module_name, mp);
if (!mod)
{
g_free(module_init_func);
return FALSE;
}
g_module_make_resident(mod);
if (!g_module_symbol(mod, module_init_func, (gpointer *) &init_func))
{
msg_error("Error finding init function in module",
evt_tag_str("module", module_name),
evt_tag_str("symbol", module_init_func),
evt_tag_str("error", g_module_error()),
NULL);
g_free(module_init_func);
return FALSE;
}
call_init:
g_free(module_init_func);
return (*init_func)(cfg, args);
}
void
next_test()
{
printf("\n");
current_test++;
if(app.timeout) g_source_remove (app.timeout);
if(current_test < __n_tests){
test_finished = false;
gboolean (*test)() = tests[current_test];
dbg(2, "test %i of %i.", current_test + 1, __n_tests);
g_timeout_add(300, run_test, test);
app.timeout = g_timeout_add(20000, on_test_timeout, NULL);
}
else{ printf("finished all. passed=%s%i%s failed=%s%i%s\n", green, app.n_passed, wf_white, (n_failed ? red : wf_white), n_failed, wf_white); g_timeout_add(1000, __exit, NULL); }
}
gboolean
plugin_load_module(const gchar *module_name, GlobalConfig *cfg, CfgArgs *args)
{
GModule *mod;
static GModule *main_module_handle;
gboolean (*init_func)(GlobalConfig *cfg, CfgArgs *args);
gchar *module_init_func;
const gchar *mp;
gboolean result;
ModuleInfo *module_info;
/* lookup in the main executable */
if (!main_module_handle)
main_module_handle = g_module_open(NULL, 0);
module_init_func = plugin_get_module_init_name(module_name);
if (g_module_symbol(main_module_handle, module_init_func, (gpointer *) &init_func))
{
/* already linked in, no need to load explicitly */
goto call_init;
}
/* try to load it from external .so */
if (cfg->lexer)
mp = cfg_args_get(cfg->lexer->globals, "module-path");
else
mp = NULL;
if (!mp)
mp = resolvedConfigurablePaths.initial_module_path;
mod = plugin_dlopen_module(module_name, mp);
if (!mod)
{
g_free(module_init_func);
return FALSE;
}
g_module_make_resident(mod);
module_info = plugin_get_module_info(mod);
if (module_info->canonical_name)
{
g_free(module_init_func);
module_init_func = plugin_get_module_init_name(module_info->canonical_name ? : module_name);
}
void
MySIPEndPoint::OnRegistrationStatus(const RegistrationStatus & status)
{
SIPEndPoint::OnRegistrationStatus(status);
if (status.m_reason < 200 || (status.m_reRegistering && status.m_reason < 300))
return;
SIPURL aor = status.m_addressofRecord;
aor.Sanitise(SIPURL::ExternalURI);
PString aor_str = aor.AsString ();
char *address_of_record = g_strdup (aor_str);
g_signal_emit_by_name (m_sipep, "registration-status",
address_of_record,
gboolean (status.m_wasRegistering),
GopalStatusCodes (status.m_reason));
}
static size_t curlapi_http_write_cb(char *ptr,
size_t size,
size_t nmemb,
void *userdata)
{
gsize length = 0;
GString *buffer = NULL;
GSList *args = NULL;
GSList *threadargs = NULL;
gboolean (*write_cb)(GSList *args) = NULL;
gchar *string = NULL;
gchar *fullstring = NULL;
length = size * nmemb;
args = (GSList *) userdata;
buffer = g_slist_nth_data(args, 0);
write_cb = g_slist_nth_data(args, 1);
string = g_strndup(ptr, length);
if(g_strcmp0("\r\n", &string[length - 2]) == 0)
{
string[length - 2] = '\0';
g_string_append(buffer, string);
g_free(string);
fullstring = g_strdup(buffer->str);
g_string_set_size(buffer, 0);
threadargs = g_slist_copy(g_slist_nth(args, 2));
threadargs = g_slist_append(threadargs, fullstring);
//Make sure write_cb returns true, else die.
if(write_cb(threadargs) == FALSE)
length = 0;
}
else
{
g_string_append(buffer, string);
g_free(string);
}
return(length);
}
/* g_main_iterate () runs a single iteration of the mainloop, or,
* if !dispatch checks to see if any sources need dispatching.
* basic algorithm for dispatch=TRUE:
*
* 1) while the list of currently pending sources is non-empty,
* we call (*dispatch) on those that are !IN_CALL or can_recurse,
* removing sources from the list after each returns.
* the return value of (*dispatch) determines whether the source
* itself is kept alive.
*
* 2) call (*prepare) for sources that are not yet SOURCE_READY and
* are !IN_CALL or can_recurse. a return value of TRUE determines
* that the source would like to be dispatched immediatedly, it
* is then flagged as SOURCE_READY.
*
* 3) poll with the pollfds from all sources at the priority of the
* first source flagged as SOURCE_READY. if there are any sources
* flagged as SOURCE_READY, we use a timeout of 0 or the minimum
* of all timouts otherwise.
*
* 4) for each source !IN_CALL or can_recurse, if SOURCE_READY or
* (*check) returns true, add the source to the pending list.
* once one source returns true, stop after checking all sources
* at that priority.
*
* 5) while the list of currently pending sources is non-empty,
* call (*dispatch) on each source, removing the source
* after the call.
*
*/
static gboolean
g_main_iterate (gboolean block,
gboolean dispatch)
{
GHook *hook;
GTimeVal current_time = { 0, 0 };
gint n_ready = 0;
gint current_priority = 0;
gint timeout;
gboolean retval = FALSE;
g_return_val_if_fail (!block || dispatch, FALSE);
g_get_current_time (¤t_time);
G_LOCK (main_loop);
#ifdef G_THREADS_ENABLED
if (poll_waiting)
{
g_warning("g_main_iterate(): main loop already active in another thread");
G_UNLOCK (main_loop);
return FALSE;
}
#endif
/* If recursing, finish up current dispatch, before starting over */
if (pending_dispatches)
{
if (dispatch)
g_main_dispatch (¤t_time);
G_UNLOCK (main_loop);
return TRUE;
}
/* Prepare all sources */
timeout = block ? -1 : 0;
hook = g_hook_first_valid (&source_list, TRUE);
while (hook)
{
GSource *source = (GSource*) hook;
gint source_timeout = -1;
if ((n_ready > 0) && (source->priority > current_priority))
{
g_hook_unref (&source_list, hook);
break;
}
if (G_HOOK_IN_CALL (hook) && !(hook->flags & G_SOURCE_CAN_RECURSE))
{
hook = g_hook_next_valid (&source_list, hook, TRUE);
continue;
}
if (!(hook->flags & G_SOURCE_READY))
{
gboolean (*prepare) (gpointer source_data,
GTimeVal *current_time,
gint *timeout,
gpointer user_data);
prepare = ((GSourceFuncs *) hook->func)->prepare;
in_check_or_prepare++;
G_UNLOCK (main_loop);
if ((*prepare) (source->source_data, ¤t_time, &source_timeout, source->hook.data))
hook->flags |= G_SOURCE_READY;
G_LOCK (main_loop);
in_check_or_prepare--;
}
if (hook->flags & G_SOURCE_READY)
{
if (!dispatch)
{
g_hook_unref (&source_list, hook);
G_UNLOCK (main_loop);
return TRUE;
}
else
{
n_ready++;
current_priority = source->priority;
timeout = 0;
}
}
if (source_timeout >= 0)
{
if (timeout < 0)
timeout = source_timeout;
else
timeout = MIN (timeout, source_timeout);
}
hook = g_hook_next_valid (&source_list, hook, TRUE);
}
/* poll(), if necessary */
g_main_poll (timeout, n_ready > 0, current_priority);
if (timeout != 0)
g_get_current_time (¤t_time);
/* Check to see what sources need to be dispatched */
n_ready = 0;
hook = g_hook_first_valid (&source_list, TRUE);
while (hook)
{
GSource *source = (GSource *)hook;
if ((n_ready > 0) && (source->priority > current_priority))
{
g_hook_unref (&source_list, hook);
break;
}
if (G_HOOK_IN_CALL (hook) && !(hook->flags & G_SOURCE_CAN_RECURSE))
{
hook = g_hook_next_valid (&source_list, hook, TRUE);
continue;
}
if (!(hook->flags & G_SOURCE_READY))
{
gboolean (*check) (gpointer source_data,
GTimeVal *current_time,
gpointer user_data);
check = ((GSourceFuncs *) hook->func)->check;
in_check_or_prepare++;
G_UNLOCK (main_loop);
if ((*check) (source->source_data, ¤t_time, source->hook.data))
hook->flags |= G_SOURCE_READY;
G_LOCK (main_loop);
in_check_or_prepare--;
}
if (hook->flags & G_SOURCE_READY)
{
if (dispatch)
{
hook->flags &= ~G_SOURCE_READY;
g_hook_ref (&source_list, hook);
pending_dispatches = g_slist_prepend (pending_dispatches, source);
current_priority = source->priority;
n_ready++;
}
else
{
g_hook_unref (&source_list, hook);
G_UNLOCK (main_loop);
return TRUE;
}
}
hook = g_hook_next_valid (&source_list, hook, TRUE);
}
/* Now invoke the callbacks */
if (pending_dispatches)
{
pending_dispatches = g_slist_reverse (pending_dispatches);
g_main_dispatch (¤t_time);
retval = TRUE;
}
G_UNLOCK (main_loop);
return retval;
}
gboolean
subsystem_msg_dispatch(IPC_Channel *sender, void *user_data)
{
int lpc = 0;
xmlNode *msg = NULL;
xmlNode *data = NULL;
gboolean all_is_well = TRUE;
const char *sys_to;
const char *task;
gboolean (*process_function)
(xmlNode *msg, xmlNode *data, IPC_Channel *sender) = NULL;
while(IPC_ISRCONN(sender)) {
gboolean process = FALSE;
if(sender->ops->is_message_pending(sender) == 0) {
break;
}
msg = xmlfromIPC(sender, MAX_IPC_DELAY);
if (msg == NULL) {
break;
}
lpc++;
crm_log_xml(LOG_MSG, __FUNCTION__, msg);
sys_to = crm_element_value(msg, F_CRM_SYS_TO);
task = crm_element_value(msg, F_CRM_TASK);
if(safe_str_eq(task, CRM_OP_HELLO)) {
process = TRUE;
} else if(sys_to == NULL) {
crm_err("Value of %s was NULL!!", F_CRM_SYS_TO);
} else if(task == NULL) {
crm_err("Value of %s was NULL!!", F_CRM_TASK);
} else {
process = TRUE;
}
if(process == FALSE) {
free_xml(msg); msg = NULL;
continue;
}
data = get_message_xml(msg, F_CRM_DATA);
process_function = user_data;
if(FALSE == process_function(msg, data, sender)) {
crm_warn("Received a message destined for %s"
" by mistake", sys_to);
}
free_xml(msg); msg = NULL;
if(sender->ch_status == IPC_CONNECT) {
break;
}
}
crm_debug_2("Processed %d messages", lpc);
if (sender->ch_status != IPC_CONNECT) {
crm_err("The server %d has left us: Shutting down...NOW",
sender->farside_pid);
exit(1); /* shutdown properly later */
return !all_is_well;
}
return all_is_well;
}
gboolean get_xmmsctrl_info(struct TrackInfo *ti, void *handle, int session)
{
gchar *(*xmms_remote_get_playlist_title)(gint session, gint pos);
gint (*xmms_remote_get_playlist_time)(gint session, gint pos);
gboolean (*xmms_remote_is_playing)(gint session);
gboolean (*xmms_remote_is_paused)(gint session);
gint (*xmms_remote_get_playlist_pos)(gint session);
gint (*xmms_remote_get_output_time)(gint session);
if (!handle)
{
return FALSE;
}
get_func(xmms_remote_get_playlist_title);
get_func(xmms_remote_get_playlist_time);
get_func(xmms_remote_is_playing);
get_func(xmms_remote_is_paused);
get_func(xmms_remote_get_playlist_pos);
get_func(xmms_remote_get_output_time);
if (!(xmms_remote_get_playlist_title && xmms_remote_get_playlist_time &&
xmms_remote_is_playing && xmms_remote_is_paused &&
xmms_remote_get_playlist_pos && xmms_remote_get_output_time)) {
trace("xmmsctrl not initialized properly");
return FALSE;
}
if ((*xmms_remote_is_playing)(session)) {
if ((*xmms_remote_is_paused)(session))
ti->status = PLAYER_STATUS_PAUSED;
else
ti->status = PLAYER_STATUS_PLAYING;
} else
ti->status = PLAYER_STATUS_STOPPED;
trace("Got state %d", ti->status);
if (ti->status != PLAYER_STATUS_STOPPED) {
int pos = (*xmms_remote_get_playlist_pos)(session);
trace("Got position %d", pos);
char *title = (*xmms_remote_get_playlist_title)(session, pos);
if (title) {
trace("Got title %s", title);
const char *sep = purple_prefs_get_string(PREF_XMMS_SEP);
if (strlen(sep) != 1) {
trace("Delimiter size should be 1. Cant parse status.");
return FALSE;
}
char regexp[STRLEN];
sprintf(regexp, "^(.*)\\%s(.*)\\%s(.*)$", sep, sep);
pcre *re = regex(regexp, 0);
capture(re, title, strlen(title), ti->artist, ti->album, ti->track);
pcre_free(re);
g_free(title);
}
ti->totalSecs = (*xmms_remote_get_playlist_time)(session, pos)/1000;
ti->currentSecs = (*xmms_remote_get_output_time)(session)/1000;
}
return TRUE;
}
