static int start_child_process_with_core(const char* cmd) {
struct rlimit r;
errno = 0;
if(getrlimit(RLIMIT_CORE, &r) == -1) {
E_WARNING(E_STRLOC ": gerlimit() failed with '%s'\n", strerror(errno));
return -1;
}
rlim_t old = r.rlim_cur;
r.rlim_cur = RLIM_INFINITY;
if(setrlimit(RLIMIT_CORE, &r) == -1) {
E_WARNING(E_STRLOC ": setrlimit() failed with '%s'\n", strerror(errno));
return -1;
}
int ret = start_child_process(cmd);
r.rlim_cur = old;
if(setrlimit(RLIMIT_CORE, &r) == -1) {
E_WARNING(E_STRLOC ": setrlimit() failed with '%s'\n", strerror(errno));
return -1;
}
return ret;
}
bool EdbusConnection::send_with_reply_and_block(const EdbusMessage& content, int timeout_ms, EdbusMessage& ret) {
if(!dc || !dc->conn)
return false;
DBusMessage* reply, *msg;
DBusError err;
dbus_error_init(&err);
msg = content.to_dbus_message();
if(!msg) {
E_WARNING(E_STRLOC ": Can't convert to DBusMessage\n");
return false;
}
reply = dbus_connection_send_with_reply_and_block(dc->conn, msg, timeout_ms, &err);
if(dbus_error_is_set(&err)) {
E_WARNING(E_STRLOC ": Sending error: %s, %s\n", err.name, err.message);
dbus_error_free(&err);
return false;
}
ret.from_dbus_message(reply);
return true;
}
int PtyProcess::enable_local_echo(bool enable) {
int slave = open(m_TTY, O_RDWR);
if (slave < 0) {
E_WARNING(E_STRLOC ": could not open slave tty\n");
return -1;
}
struct termios tio;
errno = 0;
if(tcgetattr(slave, &tio) < 0) {
E_WARNING(E_STRLOC ": tcgetattr() failed with '%s'\n", strerror(errno));
close(slave);
return -1;
}
if(enable)
tio.c_lflag |= ECHO;
else
tio.c_lflag &= ~ECHO;
if(tcsetattr(slave, TCSANOW, &tio) < 0) {
E_WARNING(E_STRLOC ": tcsetattr() failed with '%s'\n", strerror(errno));
close(slave);
return -1;
}
close(slave);
return 0;
}
scheme *edelib_scheme_init(void) {
scheme *s;
pointer sym;
s = scheme_init_new();
scheme_set_input_port_file(s, stdin);
scheme_set_output_port_file(s, stdout);
sym = edelib_scheme_mk_symbol(s, "*edelib-dir-separator*");
edelib_scheme_define(s, EDELIB_SCHEME_GLOBAL_ENV(s), sym, edelib_scheme_mk_string(s, E_DIR_SEPARATOR_STR));
sym = edelib_scheme_mk_symbol(s, "*edelib-version*");
edelib_scheme_define(s, EDELIB_SCHEME_GLOBAL_ENV(s), sym, edelib_scheme_mk_string(s, EDELIB_VERSION));
EDELIB_SCHEME_DEFINE(s, edelib_scheme_clock, "edelib-clock");
EDELIB_SCHEME_DEFINE(s, edelib_scheme_clock_diff, "edelib-clock-diff");
/* load init files; it is a list of files separated with ':' */
char *paths = getenv("EDELIB_SCHEME_INIT");
if(paths) {
char *tmp = edelib_strndup(paths, 256);
FILE *fd = NULL;
for(char *p = strtok(tmp, ":"); p; p = strtok(NULL, ":")) {
fd = fopen(p, "r");
if(!fd) {
E_WARNING(E_STRLOC ": unable to open '%s'. Skipping...\n", p);
continue;
}
edelib_scheme_load_file(s, fd);
fclose(fd);
fd = NULL;
}
free(tmp);
} else {
FILE *fd;
char path[PATH_MAX];
const char *init_files[] = {"init.ss", "init-2.ss", 0};
bool found_files = false;
for(int i = 0; init_files[i]; i++) {
snprintf(path, sizeof(path), "%s/%s", EDELIB_SCHEME_DEFAULT_LIB_PATH, init_files[i]);
fd = fopen(path, "r");
if(fd) {
found_files = true;
edelib_scheme_load_file(s, fd);
fclose(fd);
}
}
if(!found_files)
E_WARNING(E_STRLOC ": EDELIB_SCHEME_INIT wasn't set. Interpreter will be loaded without init files\n");
}
return s;
}
BugzillaData *bugzilla_new(const char *url, BugzillaErrorCallback cb, void *cb_data) {
BugzillaData *data = new BugzillaData;
bugzilla_set_error_callback(data, cb, cb_data);
xmlrpc_env_init(&data->xenv);
xmlrpc_client_setup_global_const(&data->xenv);
data->url = url;
/*
* to allow https connections; curl by default refuse connections without valid certificate
* (at least docs says that ;))
*/
gparms_curl.no_ssl_verifypeer = 1;
gparms_curl.no_ssl_verifyhost = 1;
/* only curl transport is supported */
gparms.transport = "curl";
gparms.transportparmsP = &gparms_curl;
xmlrpc_client_create(&data->xenv, XMLRPC_CLIENT_NO_FLAGS, "ede-bug-report", "0.1", &gparms, sizeof(gparms), &data->xcli);
if(data->xenv.fault_occurred) {
E_WARNING(E_STRLOC ": Unable to init xmlrpc client data (%s)\n", data->xenv.fault_string);
if(cb) cb(data->xenv.fault_string, cb_data);
delete data;
data = NULL;
}
return data;
}
static void apply_changes_on_x(const char *current, const String *previous) {
if(repeat_press_value)
XAutoRepeatOn(fl_display);
else
XAutoRepeatOff(fl_display);
/* do not do anything if selected layout is the same as previous */
if(!previous || *previous != current) {
/*
* believe me, it is easier to call this command than to reimplmement a mess for
* uploading keyboard layout on X server!
*/
String setxkbmap = file_path("setxkbmap");
if(setxkbmap.empty()) {
alert(_("Unable to find 'setxkbmap' tool.\n\nThis tool is used as helper tool for "
"easier keyboard setup and is standard tool shipped with every X package. "
"Please install it first and run this program again."));
} else {
int ret = run_sync("%s %s", setxkbmap.c_str(), current);
/* do not show dialog since we can fail if config has bad entry when called from apply_chages_from_config() */
if(ret != 0)
E_WARNING(E_STRLOC ": 'setxkbmap %s' failed with %i\n", current, ret);
}
}
/* force panel applet to re-read config file to see if flag should be displayed or not */
foreign_callback_call(PANEL_APPLET_ID);
}
int PtyProcess::init() {
delete m_pPTY;
m_pPTY = new PTY();
m_Fd = m_pPTY->getpt();
if(m_Fd < 0)
return -1;
if((m_pPTY->grantpt() < 0) || (m_pPTY->unlockpt() < 0)) {
E_WARNING(E_STRLOC ": master setup failed.\n");
m_Fd = -1;
return -1;
}
if(m_TTY)
free(m_TTY);
m_TTY = strdup(m_pPTY->ptsname());
if(m_Inbuf)
free(m_Inbuf);
m_Inbuf = 0;
return 0;
}
static void read_watch_cb(int fd, void* d) {
/* E_DEBUG(E_STRLOC ": read_watch_cb()\n"); */
EdbusConnImpl* dc = (EdbusConnImpl*)d;
E_ASSERT(dc != NULL);
E_ASSERT(dc->watch_list != NULL);
WatchListIter it = dc->watch_list->begin(), it_end = dc->watch_list->end();
while(it != it_end) {
if(dbus_watch_get_fd(*it) == fd && dbus_watch_get_enabled(*it)) {
if(!dbus_watch_handle(*it, DBUS_WATCH_READABLE))
E_WARNING(E_STRLOC ": Out of memory\n");
break;
}
++it;
}
/*
* Check if there are more incomming data and process them. Note that
* dbus_connection_dispatch() call will also remove data from queue.
* This means that (here) timer will not be installed if only one unprocessed
* message is in queue; opposite, after installment it will process the rest
* of the messages without interrupting read_watch_cb() flow.
*
* If this is not set (e.g. all data are processed here), we can miss initial
* (or later) messages that are sent to us. Also, timer will be triggered faster
* as it can (seems that 0.5 as timer value misses some data...).
*/
if(dbus_connection_dispatch(dc->conn) == DBUS_DISPATCH_DATA_REMAINS)
Fl::add_timeout(0.2, dispatch_cb, dc);
}
// NB: do not do anything if we're not actually connected to the given source
void SinkBase::disconnect(SourceBase& source) {
if (_source != &source) {
E_WARNING("Cannot disconnect " << this->fullName() << " from " << source.fullName() << " as they are not connected");
return;
}
E_DEBUG(EConnectors, " SinkBase::disconnect: " << fullName() << "::_source = 0");
setSource(0);
}
/*
* Copy output to stdout until the child process exists, or a line of output
* matches `m_Exit'.
* We have to use waitpid() to test for exit. Merely waiting for EOF on the
* pty does not work, because the target process may have children still
* attached to the terminal.
*/
int PtyProcess::wait_for_child(void) {
int retval = 1;
fd_set fds;
FD_ZERO(&fds);
errno = 0;
while(1) {
FD_SET(m_Fd, &fds);
int ret = select(m_Fd+1, &fds, 0L, 0L, 0L);
if (ret == -1) {
if (errno != EINTR) {
E_WARNING(E_STRLOC ": select() failed with '%s'\n", strerror(errno));
return -1;
}
ret = 0;
}
if(ret) {
int len;
for(char* line = read_line(false); line && strlen(line) > 0; line = read_line(false)) {
if(m_Exit) {
len = strlen(m_Exit);
if(len > 0 && !strncasecmp(line, m_Exit, len))
kill(m_Pid, SIGTERM);
}
if(m_bTerminal) {
fputs(line, stdout);
fputc('\n', stdout);
}
}
}
ret = check_pid_exited(m_Pid);
if(ret == Error) {
if (errno == ECHILD)
retval = 0;
else
retval = 1;
break;
} else if(ret == Killed || ret == Crashed) {
retval = 0;
break;
} else if (ret == NotExited) {
// keep checking
} else {
retval = ret;
break;
}
}
return retval;
}
bool Theme::load(const char *f) {
E_RETURN_VAL_IF_FAIL(f != NULL, false);
/* do not allow loading if clear() wasn't called before */
E_RETURN_VAL_IF_FAIL(priv->sc == NULL, false);
priv->is_loaded = false;
init_interpreter();
scheme *ss = priv->sc;
/*
* Determine from which directory we loads file, and set that file as base directory
* where '(include)' statement can search additional files. Include uses 'private::theme.search-path'.
*/
char *path = edelib_strndup(f, PATH_MAX);
if(!path)
E_FATAL(E_STRLOC ": No memory\n");
char *dir = local_dirname(path);
/* If returned name is the same as file, dirname wasn't found directory name in given path. */
if(strcmp(dir, f) != 0) {
pointer sym = mk_symbol(ss, "private:theme.search-path");
edelib_scheme_define(ss, ss->global_env, sym, mk_string(ss, dir));
ss->vptr->setimmutable(sym);
}
/* scheme copies path, so we do not need it any more */
free(path);
FILE *fd = fopen(f, "r");
if(!fd) {
edelib_scheme_deinit(ss);
free(ss);
priv->sc = 0;
return false;
}
edelib_scheme_load_named_file(ss, fd, f);
fclose(fd);
if(ss->no_memory) {
E_WARNING(E_STRLOC ": No memory to load theme source in interpreter\n");
return false;
}
if(ss->retcode != 0)
return false;
/* fetch common variables */
priv->name = get_string_var(ss, "private:theme.name");
priv->author = get_string_var(ss, "private:theme.author");
priv->sample = get_string_var(ss, "private:theme.sample");
priv->is_loaded = true;
return true;
}
void XSettingsClient::read_settings(void) {
E_ASSERT(client_data != NULL);
Atom type;
int format;
unsigned long n_items, bytes_after;
unsigned char *data;
int result;
int (*old_handler)(Display*, XErrorEvent*);
XSettingsList* old_settings = client_data->settings;
client_data->settings = NULL;
if(client_data->manager_win) {
old_handler = XSetErrorHandler(ignore_xerrors);
result = XGetWindowProperty(client_data->display, client_data->manager_win, client_data->xsettings_atom,
0, LONG_MAX, False, client_data->xsettings_atom,
&type, &format, &n_items, &bytes_after, (unsigned char**)&data);
XSetErrorHandler(old_handler);
if(result == Success && type != None) {
if(type != client_data->xsettings_atom)
E_WARNING(E_STRLOC ": Invalid type for XSETTINGS property\n");
else if(format != 8)
E_WARNING(E_STRLOC ": Invalid format for XSETTINGS property %d\n", format);
else {
// parse settings
client_data->settings = xsettings_decode(data, n_items, &client_data->serial);
}
XFree(data);
}
}
notify_changes(client_data, old_settings, settings_cb, settings_cb_data);
xsettings_list_free(old_settings);
}
/*
* Fork and execute the command. This returns in the parent.
*/
int PtyProcess::exec(const char *command, const char **args) {
E_DEBUG(E_STRLOC ": running '%s'\n", command);
if(init() < 0)
return -1;
// Open the pty slave before forking. See SetupTTY()
E_DEBUG(E_STRLOC ": pty: %s\n", m_TTY);
int slave = open(m_TTY, O_RDWR);
if(slave < 0) {
E_WARNING(E_STRLOC ": could not open slave pty.\n");
return -1;
}
errno = 0;
if((m_Pid = fork()) == -1) {
E_WARNING(E_STRLOC ": fork failed with '%s'\n", strerror(errno));
return -1;
}
// Parent
if(m_Pid) {
close(slave);
return 0;
}
// Child
if(setup_tty(slave) < 0)
_exit(1);
if (d->env) {
for(int i = 0; d->env[i]; i++)
putenv(d->env[i]);
}
execv(command, (char**)args);
_exit(1);
return -1; /* never reached */
}
bool EdbusConnection::send(const EdbusMessage& content) {
if(!dc || !dc->conn)
return false;
bool ret;
dbus_uint32_t serial;
DBusMessage* msg = content.to_dbus_message();
if(!msg) {
E_WARNING(E_STRLOC ": Can't convert to DBusMessage\n");
return false;
}
if(!dbus_connection_send(dc->conn, msg, &serial)) {
E_WARNING(E_STRLOC ": Message sending failed\n");
ret = false;
} else
ret = true;
dbus_connection_flush(dc->conn);
return ret;
}
void SinkBase::detachProxy(SinkProxyBase* sproxy) {
// TODO: verify me
if (sproxy != _sproxy) {
E_WARNING("Cannot detach " << fullName() << " from SinkProxy " << sproxy->fullName() << " as they are not attached");
return;
}
E_DEBUG(EConnectors, " SinkBase::detachProxy: " << fullName() << "::_sproxy = 0");
_sproxy = 0;
E_DEBUG(EConnectors, " SinkBase::detachProxy: " << fullName() << "::_source = 0");
setSource(0); // also set source to 0 because the proxy set it for us when we attached, but now we're all alone
}
void EdbusConnection::setup_filter(void) {
E_ASSERT(dc != NULL);
E_ASSERT(dc->conn != NULL);
DBusError err;
dbus_error_init(&err);
/* if we didn't registered any signal match, match everything */
if(dc->signal_matches == 0) {
dbus_bus_add_match(dc->conn, "type='signal'", &err);
if(dbus_error_is_set(&err)) {
E_WARNING(E_STRLOC ": Signal match failed: %s, %s\n", err.name, err.message);
dbus_error_free(&err);
return;
}
}
/* if we didn't registered any method match, match everything */
if(dc->method_matches == 0) {
const char* name = unique_name();
if(name) {
char buff[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
snprintf(buff, sizeof(buff), "destination='%s'", name);
dbus_bus_add_match(dc->conn, buff, &err);
if(dbus_error_is_set(&err)) {
E_WARNING(E_STRLOC ": Destination match failed: %s, %s\n", err.name, err.message);
dbus_error_free(&err);
return;
}
} else
E_WARNING(E_STRLOC ": Unable to get unique name\n");
}
dbus_connection_add_filter(dc->conn, edbus_signal_filter, dc, 0);
}
AlgorithmStatus AudioLoader::process() {
if (!parameter("filename").isConfigured()) {
throw EssentiaException("AudioLoader: Trying to call process() on an AudioLoader algo which hasn't been correctly configured.");
}
// read frames until we get a good one
do {
int result = av_read_frame(_demuxCtx, &_packet);
//E_DEBUG(EAlgorithm, "AudioLoader: called av_read_frame(), got result = " << result);
if (result != 0) {
// 0 = OK, < 0 = error or EOF
if (result != AVERROR_EOF) {
char errstring[1204];
av_strerror(result, errstring, sizeof(errstring));
ostringstream msg;
msg << "AudioLoader: Error reading frame: " << errstring;
E_WARNING(msg.str());
}
// TODO: should try reading again on EAGAIN error?
// https://github.com/FFmpeg/FFmpeg/blob/master/ffmpeg.c
shouldStop(true);
flushPacket();
closeAudioFile();
if (_computeMD5) {
av_md5_final(_md5Encoded, _checksum);
_md5.push(uint8_t_to_hex(_checksum, 16));
}
else {
string md5 = "";
_md5.push(md5);
}
return FINISHED;
}
} while (_packet.stream_index != _streamIdx);
// compute md5 first
if (_computeMD5) {
av_md5_update(_md5Encoded, _packet.data, _packet.size);
}
// decode frames in packet
while(_packet.size > 0) {
if (!decodePacket()) break;
copyFFmpegOutput();
}
// neds to be freed !!
av_free_packet(&_packet);
return OK;
}
void bugzilla_logout(BugzillaData *data) {
E_ASSERT(data != NULL);
xmlrpc_value *result;
xmlrpc_client_call2f(&data->xenv, data->xcli, data->url.c_str(), "User.logout", &result, "()");
if(data->xenv.fault_occurred) {
E_WARNING(E_STRLOC ": Unable to call xmlrpc function (%s)\n", data->xenv.fault_string);
if(data->cb) (data->cb)(data->xenv.fault_string, data->cb_data);
return;
}
xmlrpc_DECREF(result);
}
bool EdbusConnection::connect(EdbusConnectionType ctype) {
if(dc == NULL) {
dc = new EdbusConnImpl;
dc->conn = NULL;
dc->signal_cb = NULL;
dc->signal_cb_data = NULL;
dc->method_call_cb = NULL;
dc->method_call_cb_data = NULL;
dc->watch_list = NULL;
dc->timeout = NULL;
dc->signal_table = NULL;
dc->signal_table_sz = 0;
dc->method_table = NULL;
dc->method_table_sz = 0;
dc->signal_matches = dc->method_matches = 0;
}
DBusBusType type;
DBusError err;
dbus_error_init(&err);
switch(ctype) {
case EDBUS_SYSTEM:
type = DBUS_BUS_SYSTEM;
break;
case EDBUS_SESSION:
default:
type = DBUS_BUS_SESSION;
break;
}
dc->conn = dbus_bus_get(type, &err);
if(dbus_error_is_set(&err)) {
E_WARNING(E_STRLOC ": Connection error: %s\n", err.message);
dbus_error_free(&err);
}
if(dc->conn == NULL)
return false;
return true;
}
/*
* Wait until the terminal is set into no echo mode. At least one su
* (RH6 w/ Linux-PAM patches) sets noecho mode AFTER writing the Password:
* prompt, using TCSAFLUSH. This flushes the terminal I/O queues, possibly
* taking the password with it. So we wait until no echo mode is set
* before writing the password.
* Note that this is done on the slave fd. While Linux allows tcgetattr() on
* the master side, Solaris doesn't.
*/
int PtyProcess::wait_slave() {
int slave = open(m_TTY, O_RDWR);
if (slave < 0) {
E_WARNING(E_STRLOC ": could not open slave tty\n");
return -1;
}
// kdDebug(900) << k_lineinfo << "Child pid " << m_Pid << endl;
struct termios tio;
errno = 0;
while (1) {
if (!check_pid(m_Pid)) {
close(slave);
return -1;
}
if(tcgetattr(slave, &tio) < 0) {
E_WARNING(E_STRLOC ": tcgetattr() failed with '%s'\n", strerror(errno));
close(slave);
return -1;
}
if(tio.c_lflag & ECHO) {
E_DEBUG(E_STRLOC ": echo mode still on\n");
wait_ms(slave,100);
continue;
}
break;
}
close(slave);
return 0;
}
void Theme::init_interpreter(void) {
if(priv->sc) return;
scheme *ss = edelib_scheme_init_raw();
if(!ss) {
E_WARNING(E_STRLOC ": Unable to init interpreter\n");
return;
}
priv->sc = ss;
/* must be called */
scheme_set_input_port_file(ss, stdin);
scheme_set_output_port_file(ss, stdout);
/* install user supplied error handler first, if given */
if(priv->err_func) {
ss->vptr->scheme_define(ss,
ss->global_env,
ss->vptr->mk_symbol(ss, "private:theme.error_hook"),
ss->vptr->mk_foreign_func(ss, theme_error_hook));
/* make sure interpreter does not use this function at all */
scheme_set_external_data(ss, (void*)priv);
}
/* load init stuff */
scheme_load_string(ss, init_ss_content);
/* load theme stuff */
scheme_load_string(ss, theme_ss_content);
/*
* Set (or override) common variables before actual script was loaded.
* Variables are static and can't be changed.
*/
pointer sym;
sym = mk_symbol(ss, "*edelib-dir-separator*");
scheme_define(ss, ss->global_env, sym, mk_string(ss, E_DIR_SEPARATOR_STR));
ss->vptr->setimmutable(sym);
sym = mk_symbol(ss, "*edelib-version*");
scheme_define(ss, ss->global_env, sym, mk_string(ss, EDELIB_VERSION));
ss->vptr->setimmutable(sym);
}
static void write_watch_cb(int fd, void* d) {
/* E_DEBUG(E_STRLOC ": write_watch_cb()\n"); */
EdbusConnImpl* dc = (EdbusConnImpl*)d;
E_ASSERT(dc != NULL);
E_ASSERT(dc->watch_list != NULL);
WatchListIter it = dc->watch_list->begin(), it_end = dc->watch_list->end();
while(it != it_end) {
if(dbus_watch_get_fd(*it) == fd && dbus_watch_get_enabled(*it)) {
if(!dbus_watch_handle(*it, DBUS_WATCH_WRITABLE))
E_WARNING(E_STRLOC ": Out of memory\n");
break;
}
++it;
}
}
EDELIB_NS_BEGIN
void EdbusDict::append(const EdbusData& key, const EdbusData& value) {
if(!EdbusData::basic_type(key))
return;
/*
* Assure all keys are the same type. The same applies with the values.
* This is done by checking first added entry, if exists.
* We can accept keys (or values) with different types, but D-Bus does not
* like it.
*/
if(size() > 0) {
if(key.type() != key_type() || value.type() != value_type()) {
E_WARNING("Key or value is different type than I already have. Ignoring...");
return;
}
}
unhook();
/*
* If entry with the same key already exists, just replace value. Opposite
* add as new entry.
*
* Not efficient at all, but this will assure dict contains unique keys.
* Dbus specs tolerates duplicate keys in dict, but it can mark data parts
* with them as invalid.
*/
EdbusDict::iterator it = impl->lst.begin(), it_end = impl->lst.end();
while(it != it_end) {
if((*it).key == key) {
(*it).value = value;
return;
}
++it;
}
EdbusDictEntry n;
n.key = key;
n.value = value;
impl->lst.push_back(n);
}
bool Config::save(const char* fname) {
E_ASSERT(fname != NULL);
TempFile t;
if(!t.create(".etmp.XXXXXX")) {
errcode = CONF_ERR_FILE;
return false;
}
/* so we could explicitly handle our options */
t.set_no_close(true);
t.set_auto_delete(false);
FILE *f = t.fstream();
SectionListIter sit = section_list.begin(), sit_end = section_list.end();
unsigned int sz = section_list.size();
EntryListIter eit;
for (; sit != sit_end; ++sit, --sz) {
fprintf(f, "[%s]\n", (*sit)->sname);
for (eit = (*sit)->entry_list.begin(); eit != (*sit)->entry_list.end(); ++eit)
fprintf(f, "%s=%s\n", (*eit)->key, (*eit)->value);
/* prevent unneeded newline at the end of file */
if(sz != 1)
fprintf(f, "\n");
}
/* explicitly flush */
fflush(f);
t.close();
E_ASSERT(t.name() && "Temporary name NULL. Report this as bug");
if(rename(t.name(), fname) != 0) {
E_WARNING("Unable to save to '%s'\n", fname);
return false;
}
chmod(fname, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
return true;
}
char *bugzilla_get_version(BugzillaData *data) {
E_ASSERT(data != NULL);
xmlrpc_value *result;
xmlrpc_client_call2f(&data->xenv, data->xcli, data->url.c_str(), "Bugzilla.version", &result, "()");
if(data->xenv.fault_occurred) {
E_WARNING(E_STRLOC ": Unable to call xmlrpc function (%s)\n", data->xenv.fault_string);
if(data->cb) (data->cb)(data->xenv.fault_string, data->cb_data);
return (char*)"";
}
/* this value will be malloc()-ated by xmlrpc_decompose_value() and should be freeed by user */
char *ret;
xmlrpc_decompose_value(&data->xenv, result, "{s:s,*}", "version", &ret);
xmlrpc_DECREF(result);
return ret;
}
void EdbusConnection::add_signal_match(const char* path, const char* interface, const char* name) {
if(!dc || !dc->conn)
return;
DBusError err;
dbus_error_init(&err);
char buff[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
snprintf(buff, sizeof(buff), "type='signal',path='%s',interface='%s',member='%s'", path, interface, name);
dbus_bus_add_match(dc->conn, buff, &err);
if(dbus_error_is_set(&err)) {
E_WARNING(E_STRLOC ": Adding signal match failed: %s, %s\n", err.name, err.message);
dbus_error_free(&err);
return;
}
dc->signal_matches++;
}
void AudioLoader::flushPacket() {
AVPacket empty;
av_init_packet(&empty);
do {
_dataSize = FFMPEG_BUFFER_SIZE;
empty.data = NULL;
empty.size = 0;
int len = decode_audio_frame(_audioCtx, _buffer, &_dataSize, &empty);
if (len < 0) {
char errstring[1204];
av_strerror(len, errstring, sizeof(errstring));
ostringstream msg;
msg << "AudioLoader: decoding error while flushing a packet:" << errstring;
E_WARNING(msg.str());
}
copyFFmpegOutput();
} while (_dataSize > 0);
}
static XkbRF_RulesPtr fetch_all_layouts(const String ¤t) {
char buf[256];
XkbRF_RulesPtr xkb_rules = NULL;
XkbRF_DescribeVarsPtr layouts = NULL;
/* try to locate rules file */
for(int i = 0; x11_dirs[i]; i++) {
for(int j = 0; x11_rules[j]; j++) {
snprintf(buf, sizeof(buf), "%s%s", x11_dirs[i], x11_rules[j]);
xkb_rules = XkbRF_Load(buf, (char*)"", True, True);
if(xkb_rules)
goto done;
}
}
if(!xkb_rules) {
E_WARNING(E_STRLOC ": Unable to load keyboard rules file\n");
return NULL;
}
done:
layouts = &xkb_rules->layouts;
/* sort them */
qsort(layouts->desc, layouts->num_desc, sizeof(XkbRF_VarDescRec), sort_cmp);
for(int i = 0; i < layouts->num_desc; i++) {
snprintf(buf, sizeof(buf), "%s\t%s", layouts->desc[i].name, layouts->desc[i].desc);
layout_browser->add(buf);
if(current == layouts->desc[i].name) {
/* Fl_Browser counts items from 1 */
layout_browser->select(i + 1);
}
}
return xkb_rules;
}
bool EdbusConnection::request_name(const char* name, int mode) {
if(!dc || !dc->conn)
return false;
E_ASSERT(mode >= 0 && "Invalid 'mode' value");
int flags = 0;
bool ret = false;
/* mixing them have no much sense */
if(mode & EDBUS_NAME_NO_REPLACE)
flags = 0;
else {
if(mode & EDBUS_NAME_ALLOW_REPLACE)
flags |= DBUS_NAME_FLAG_ALLOW_REPLACEMENT;
if(mode & EDBUS_NAME_REPLACE_EXISTING)
flags |= DBUS_NAME_FLAG_REPLACE_EXISTING;
}
DBusError err;
dbus_error_init(&err);
/* see if we got the name */
if(dbus_bus_request_name(dc->conn, name, flags, &err) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
ret = true;
else
ret = false;
if(dbus_error_is_set(&err)) {
E_WARNING(E_STRLOC ": Name request error: %s, %s\n", err.name, err.message);
dbus_error_free(&err);
ret = false;
}
return ret;
}
int bugzilla_login(BugzillaData *data, const char *user, const char *passwd) {
E_ASSERT(data != NULL);
xmlrpc_value *result;
int remember = 0; /* remember login data */
int id = -1; /* bugzilla user id */
xmlrpc_client_call2f(&data->xenv, data->xcli, data->url.c_str(), "User.login", &result,
"({s:s,s:s,s:b})",
"login", user,
"password", passwd,
"remember", remember);
if(data->xenv.fault_occurred) {
E_WARNING(E_STRLOC ": Unable to perform login function (%s)\n", data->xenv.fault_string);
if(data->cb) (data->cb)(data->xenv.fault_string, data->cb_data);
return id;
}
xmlrpc_decompose_value(&data->xenv, result, "{s:i,*}", "id", &id);
xmlrpc_DECREF(result);
return id;
}
