int pkg_src_download_signature(pkg_src_t * src)
{
int err = 0;
char *url;
char *sigfile;
const char *sigext;
if (strcmp(opkg_config->signature_type, "gpg-asc") == 0)
sigext = "asc";
else
sigext = "sig";
sprintf_alloc(&sigfile, "%s/%s.%s", opkg_config->lists_dir, src->name,
sigext);
/* get the url for the sig file */
if (src->extra_data) /* debian style? */
sprintf_alloc(&url, "%s/%s/Packages.%s", src->value, src->extra_data,
sigext);
else
sprintf_alloc(&url, "%s/Packages.%s", src->value, sigext);
err = opkg_download(url, sigfile, NULL, NULL);
if (err) {
opkg_msg(ERROR, "Failed to download signature for %s.\n", src->name);
goto cleanup;
}
opkg_msg(DEBUG, "Downloaded signature for %s.\n", src->name);
cleanup:
free(sigfile);
free(url);
return err;
}
int pkg_dest_init(pkg_dest_t * dest, const char *name, const char *root_dir)
{
char *status_file_dir;
dest->name = xstrdup(name);
/* Guarantee that dest->root_dir ends with a '/' */
if (root_dir[strlen(root_dir) - 1] == '/') {
dest->root_dir = xstrdup(root_dir);
} else {
sprintf_alloc(&dest->root_dir, "%s/", root_dir);
}
file_mkdir_hier(dest->root_dir, 0755);
sprintf_alloc(&dest->info_dir, "%s/%s", dest->root_dir,
opkg_config->info_dir);
file_mkdir_hier(dest->info_dir, 0755);
sprintf_alloc(&dest->status_file_name, "%s/%s", dest->root_dir,
opkg_config->status_file);
/* Ensure that the directory in which we will create the status file exists.
*/
status_file_dir = xdirname(dest->status_file_name);
file_mkdir_hier(status_file_dir, 0755);
free(status_file_dir);
return 0;
}
/*! Write a buffer completely into a file.
*
* If the file already exists, it will be overwritten.
*
* \return
* 0 on success, -1 on failure
*
* \param error
* On failure, \c error will be set to a newly allocated string
* that contains the error message.
* On success, or when out of memory,
* \c error will be set to \c NULL.
*
* \param path
* path of the file to write to
*
* \param source
* buffer to write
*
* \param source_size
* size of \c source
*/
static int write_file(char **error, const char *path, const char *source, size_t source_size)
{
FILE *file;
size_t written_size;
*error = NULL;
file = fopen(path, "wb");
if (file == NULL) {
*error = sprintf_alloc("Unable to open file \"%s\" for writing: %s.",
path, strerror(errno));
goto error_cleanup;
}
written_size = fwrite(source, 1, source_size, file);
if (ferror(file)) {
*error = sprintf_alloc("Unable to write %lu bytes to file \"%s\": %s.",
(unsigned long)source_size, path, strerror(errno));
goto error_cleanup;
}
if (written_size != source_size) {
*error = sprintf_alloc("Unable to write %lu bytes to file \"%s\": Only %lu bytes were written.",
(unsigned long)source_size, path, (unsigned long)written_size);
goto error_cleanup;
}
if (fclose(file) != 0) {
*error = sprintf_alloc("Unable to close file \"%s\" after writing: %s.",
path, strerror(errno));
file = NULL;
goto error_cleanup;
}
return 0;
error_cleanup:
if (file != NULL) {
fclose(file);
}
return -1;
}
static int
opkg_download_cache(const char *src, const char *dest_file_name,
curl_progress_func cb, void *data)
{
char *cache_name = xstrdup(src);
char *cache_location, *p;
int err = 0;
if (!conf->cache || str_starts_with(src, "file:")) {
err = opkg_download(src, dest_file_name, cb, data, 0);
goto out1;
}
if(!file_is_dir(conf->cache)){
opkg_msg(ERROR, "%s is not a directory.\n",
conf->cache);
err = 1;
goto out1;
}
for (p = cache_name; *p; p++)
if (*p == '/')
*p = ','; /* looks nicer than | or # */
sprintf_alloc(&cache_location, "%s/%s", conf->cache, cache_name);
if (file_exists(cache_location))
opkg_msg(NOTICE, "Copying %s.\n", cache_location);
else {
/* cache file with funky name not found, try simple name */
free(cache_name);
char *filename = strrchr(dest_file_name,'/');
if (filename)
cache_name = xstrdup(filename+1); // strip leading '/'
else
cache_name = xstrdup(dest_file_name);
free(cache_location);
sprintf_alloc(&cache_location, "%s/%s", conf->cache, cache_name);
if (file_exists(cache_location))
opkg_msg(NOTICE, "Copying %s.\n", cache_location);
else {
err = opkg_download(src, cache_location, cb, data, 0);
if (err) {
(void) unlink(cache_location);
goto out2;
}
}
}
err = file_copy(cache_location, dest_file_name);
out2:
free(cache_location);
out1:
free(cache_name);
return err;
}
static int set_and_load_pkg_dest_list(ipkg_conf_t *conf, nv_pair_list_t *nv_pair_list, char *lists_dir )
{
nv_pair_list_elt_t *iter;
nv_pair_t *nv_pair;
pkg_dest_t *dest;
char *root_dir;
for (iter = nv_pair_list->head; iter; iter = iter->next) {
nv_pair = iter->data;
if (conf->offline_root) {
sprintf_alloc(&root_dir, "%s%s", conf->offline_root, nv_pair->value);
} else {
root_dir = strdup(nv_pair->value);
}
dest = pkg_dest_list_append(&conf->pkg_dest_list, nv_pair->name, root_dir, lists_dir, conf);
free(root_dir);
if (dest == NULL) {
continue;
}
if (conf->default_dest == NULL) {
conf->default_dest = dest;
}
if (file_exists(dest->status_file_name)) {
pkg_hash_add_from_file(conf, dest->status_file_name,
NULL, dest, 1);
}
}
return 0;
}
static int expect_element_end (
xmlTextReaderPtr reader,
char *exp_name)
{
xmlChar *name;
/* maybe we are already on the end element ... lets see */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT){
xmlChar *temp;
xmlChar *temp2;
temp = xmlTextReaderName(reader);
temp2 = (xmlChar*)sprintf_alloc("/%s", temp);
name = xmlStrdup(temp2);
xmlFree(temp);
free(temp2);
} else {
name = get_xml_element(reader);
}
if (name == NULL)
return -1;
if (xmlStrcasecmp(name+1,(xmlChar *)exp_name) != 0 || name[0] != '/'){
rrd_set_error("line %d: expected </%s> end element but found <%s>",
xmlTextReaderGetParserLineNumber(reader),exp_name,name);
xmlFree(name);
return -1;
}
xmlFree(name);
return 0;
} /* expect_element_end */
void * render_loop(void * data)
{
tinfo_t * tinfo = data;
state_t * state = tinfo->state;
char * buffer_name = sprintf_alloc("rot%d", tinfo->id);
float color[4] = {1.0f, 1.0 - .1f*tinfo->id, .1f*tinfo->id, 1.0f};
while(state->running) {
double rad = (tinfo->id*M_PI/5) + (vx_util_mtime() % 2000) * 2* M_PI / 1e3;
vx_object_t * vo = vxo_chain(vxo_mat_rotate_z(rad),
vxo_mat_translate2(0,10),
vxo_box(vxo_mesh_style(color)));
vx_buffer_add_back(vx_world_get_buffer(state->world, buffer_name), vo);
vx_buffer_swap(vx_world_get_buffer(state->world, buffer_name));
usleep(500);
}
printf("Exiting render thread %s\n", buffer_name);
free(buffer_name);
return NULL;
}
int pkg_extract_control_files_to_dir_with_prefix(pkg_t * pkg, const char *dir,
const char *prefix)
{
int r = -1;
char *dir_with_prefix;
struct opkg_ar *ar;
sprintf_alloc(&dir_with_prefix, "%s/%s", dir, prefix);
ar = ar_open_pkg_control_archive(pkg->local_filename);
if (!ar) {
opkg_msg(ERROR, "Failed to extract control.tar.gz from package '%s'.\n",
pkg->local_filename);
goto cleanup;
}
r = ar_extract_all(ar, dir_with_prefix);
if (r < 0)
opkg_msg(ERROR,
"Failed to extract all control files from package '%s'.\n",
pkg->local_filename);
cleanup:
free(dir_with_prefix);
if (ar)
ar_close(ar);
return r;
}
int pkg_src_download(pkg_src_t * src)
{
int err = 0;
char *url;
char *feed;
const char *url_filename;
sprintf_alloc(&feed, "%s/%s", opkg_config->lists_dir, src->name);
url_filename = src->gzip ? "Packages.gz" : "Packages";
if (src->extra_data) /* debian style? */
sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
url_filename);
else
sprintf_alloc(&url, "%s/%s", src->value, url_filename);
if (src->gzip) {
char *cache_location;
cache_location = opkg_download_cache(url, NULL, NULL);
if (!cache_location) {
err = -1;
goto cleanup;
}
err = file_decompress(cache_location, feed);
free(cache_location);
if (err) {
opkg_msg(ERROR, "Couldn't decompress feed for source %s.",
src->name);
goto cleanup;
}
} else {
err = opkg_download(url, feed, NULL, NULL);
if (err)
goto cleanup;
}
opkg_msg(DEBUG, "Downloaded package list for %s.\n", src->name);
cleanup:
free(feed);
free(url);
return err;
}
struct sockaddr_storage conf_addr(
conf_val_t *val,
const char *sock_base_dir)
{
assert(val != NULL && val->item != NULL);
assert(val->item->type == YP_TADDR ||
(val->item->type == YP_TREF &&
val->item->var.r.ref->var.g.id->type == YP_TADDR));
struct sockaddr_storage out = { AF_UNSPEC };
if (val->code == KNOT_EOK) {
bool no_port;
conf_val(val);
out = yp_addr(val->data, &no_port);
if (out.ss_family == AF_UNIX) {
// val->data[0] is socket type identifier!
if (val->data[1] != '/' && sock_base_dir != NULL) {
char *tmp = sprintf_alloc("%s/%s", sock_base_dir,
val->data + 1);
val->code = sockaddr_set(&out, AF_UNIX, tmp, 0);
free(tmp);
}
} else if (no_port) {
sockaddr_port_set(&out, val->item->var.a.dflt_port);
}
} else {
const char *dflt_socket = val->item->var.a.dflt_socket;
if (dflt_socket != NULL) {
if (dflt_socket[0] == '/' || sock_base_dir == NULL) {
val->code = sockaddr_set(&out, AF_UNIX,
dflt_socket, 0);
} else {
char *tmp = sprintf_alloc("%s/%s", sock_base_dir,
dflt_socket);
val->code = sockaddr_set(&out, AF_UNIX, tmp, 0);
free(tmp);
}
}
}
return out;
}
int pkg_src_verify(pkg_src_t * src)
{
int err = 0;
char *feed;
char *sigfile;
const char *sigext;
if (strcmp(opkg_config->signature_type, "gpg-asc") == 0)
sigext = "asc";
else
sigext = "sig";
sprintf_alloc(&feed, "%s/%s", opkg_config->lists_dir, src->name);
sprintf_alloc(&sigfile, "%s.%s", feed, sigext);
if (!file_exists(sigfile)) {
opkg_msg(ERROR,
"Signature file is missing for %s. "
"Perhaps you need to run 'opkg update'?\n", src->name);
err = -1;
goto cleanup;
}
err = opkg_verify_signature(feed, sigfile);
if (err) {
opkg_msg(ERROR, "Signature verification failed for %s.\n", src->name);
goto cleanup;
}
opkg_msg(DEBUG, "Signature verification passed for %s.\n", src->name);
cleanup:
if (err) {
/* Remove incorrect files. */
unlink(feed);
unlink(sigfile);
}
free(sigfile);
free(feed);
return err;
}
/*
* Downloads file from url, installs in package database, return package name.
*/
int
opkg_prepare_url_for_install(const char *url, char **namep)
{
int err = 0;
pkg_t *pkg;
pkg = pkg_new();
if (str_starts_with(url, "http://")
|| str_starts_with(url, "ftp://")) {
char *tmp_file;
char *file_basec = xstrdup(url);
char *file_base = basename(file_basec);
sprintf_alloc(&tmp_file, "%s/%s", conf->tmp_dir, file_base);
err = opkg_download(url, tmp_file, NULL, NULL, 0);
if (err)
return err;
err = pkg_init_from_file(pkg, tmp_file);
if (err)
return err;
free(tmp_file);
free(file_basec);
} else if (strcmp(&url[strlen(url) - 4], OPKG_PKG_EXTENSION) == 0
|| strcmp(&url[strlen(url) - 4], IPKG_PKG_EXTENSION) == 0
|| strcmp(&url[strlen(url) - 4], DPKG_PKG_EXTENSION) == 0) {
err = pkg_init_from_file(pkg, url);
if (err)
return err;
opkg_msg(DEBUG2, "Package %s provided by hand (%s).\n",
pkg->name, pkg->local_filename);
pkg->provided_by_hand = 1;
} else {
pkg_deinit(pkg);
free(pkg);
return 0;
}
pkg->dest = conf->default_dest;
pkg->state_want = SW_INSTALL;
pkg->state_flag |= SF_PREFER;
hash_insert_pkg(pkg, 1);
if (namep) {
*namep = pkg->name;
}
return 0;
}
char* conf_abs_path(
conf_val_t *val,
const char *base_dir)
{
const char *path = conf_str(val);
if (path == NULL) {
return NULL;
} else if (path[0] == '/') {
return strdup(path);
} else {
char *abs_path;
if (base_dir == NULL) {
char *cwd = realpath("./", NULL);
abs_path = sprintf_alloc("%s/%s", cwd, path);
free(cwd);
} else {
abs_path = sprintf_alloc("%s/%s", base_dir, path);
}
return abs_path;
}
}
// 実行ファイルのディレクトリに、config.ini(デフォルト)を付加した物になります
// 動的にバッファを格納して返却するので、解放必須です
LPTSTR GetConfigPath(LPTSTR fileName)
{
LPTSTR lpExecDirectory = (LPTSTR)::GlobalAlloc(GMEM_FIXED, MAX_PATH * sizeof(TCHAR));
if( ::GetExecuteDirectory(lpExecDirectory, MAX_PATH) ) {
LPTSTR lpConfigPath = sprintf_alloc(L"%s%s", lpExecDirectory, fileName);
::GlobalFree(lpExecDirectory);
return lpConfigPath;
} else {
::GlobalFree(lpExecDirectory);
::ShowLastError();
return NULL;
}
}
int
opkg_download_pkg(pkg_t *pkg, const char *dir)
{
int err;
char *url;
char *stripped_filename;
if (pkg->src == NULL) {
opkg_msg(ERROR, "Package %s is not available from any configured src.\n",
pkg->name);
return -1;
}
if (pkg->filename == NULL) {
opkg_msg(ERROR, "Package %s does not have a valid filename field.\n",
pkg->name);
return -1;
}
sprintf_alloc(&url, "%s/%s", pkg->src->value, pkg->filename);
/* The pkg->filename might be something like
"../../foo.opk". While this is correct, and exactly what we
want to use to construct url above, here we actually need to
use just the filename part, without any directory. */
stripped_filename = strrchr(pkg->filename, '/');
if ( ! stripped_filename )
stripped_filename = pkg->filename;
sprintf_alloc(&pkg->local_filename, "%s/%s", dir, stripped_filename);
err = opkg_download_cache(url, pkg->local_filename, NULL, NULL);
free(url);
return err;
}
static void movie(state_t * state, vx_code_input_stream_t * cins, int record)
{
if (record) {
if (state->movie_file != NULL) {
printf("WRN: Only one movie can be recorded at a time\n");
return;
}
uint64_t mtime = vx_mtime();
time_t now = time(NULL);
struct tm * now2 = localtime(&now);
pthread_mutex_lock(&state->movie_mutex);
if (vx_code_input_stream_available(cins) > 0) {
const char * f2 = cins->read_str(cins);
state->movie_file = strdup(f2);
} else { // generate a unique ID
state->movie_file = sprintf_alloc("m%4d%02d%02d_%02d%02d%02d_%03d.ppms.gz",
now2->tm_year + 1900,
now2->tm_mon + 1,
now2->tm_mday,
now2->tm_hour,
now2->tm_min,
now2->tm_sec,
(int)(mtime%1000));
}
pthread_cond_signal(&state->movie_cond);
pthread_mutex_unlock(&state->movie_mutex);
} else { // finish recording
if (state->movie_file == NULL) {
printf("WRN: Can't stop recording a movie: none in progress\n");
return;
}
pthread_mutex_lock(&state->movie_mutex);
{
state->movie_file = NULL;
pthread_cond_signal(&state->movie_cond);
}
pthread_mutex_unlock(&state->movie_mutex);
}
}
char *harmony_setcfg(hdesc_t *hdesc, const char *key, const char *val)
{
char *buf;
int retval;
if (hdesc->state < HARMONY_STATE_CONNECTED) {
/* User must be preparing for a new session since we're not
* connected yet. Store the key/value pair in a local cache.
*/
buf = stralloc( hcfg_get(hdesc->sess.cfg, key) );
hcfg_set(hdesc->sess.cfg, key, val);
return buf;
}
if (!key) {
hdesc->errstr = "Invalid key string.";
errno = EINVAL;
return NULL;
}
buf = sprintf_alloc("%s=%s", key, val ? val : "");
if (!buf) {
hdesc->errstr = "Internal memory allocation error.";
return NULL;
}
/* Prepare a Harmony message. */
hmesg_scrub(&hdesc->mesg);
hdesc->mesg.data.string = buf;
retval = send_request(hdesc, HMESG_SETCFG);
free(buf);
if (retval < 0)
return NULL;
if (hdesc->mesg.status != HMESG_STATUS_OK) {
hdesc->errstr = "Invalid message received from server.";
errno = EINVAL;
return NULL;
}
/* It is the user's responsibility to free this memory. */
return stralloc(hdesc->mesg.data.string);
}
int pkg_dest_init(pkg_dest_t *dest, const char *name, const char *root_dir,const char * lists_dir, ipkg_conf_t *conf)
{
dest->name = strdup(name);
/* Guarantee that dest->root_dir ends with a '/' */
if (str_ends_with(root_dir, "/")) {
dest->root_dir = strdup(root_dir);
} else {
sprintf_alloc(&dest->root_dir, "%s/", root_dir);
}
file_mkdir_hier(dest->root_dir, 0755);
if (!conf->ipkg_libdir) {
sprintf_alloc(&dest->ipkg_dir, "%s%s",
dest->root_dir, IPKG_STATE_DIR_PREFIX);
}else{
sprintf_alloc(&dest->ipkg_dir, "%s%s",
dest->root_dir, conf->ipkg_libdir);
}
file_mkdir_hier(dest->ipkg_dir, 0755);
if (str_starts_with (lists_dir, "/"))
sprintf_alloc(&dest->lists_dir, "%s", lists_dir);
else
sprintf_alloc(&dest->lists_dir, "/%s", lists_dir);
file_mkdir_hier(dest->lists_dir, 0755);
sprintf_alloc(&dest->info_dir, "%s/%s",
dest->ipkg_dir, IPKG_INFO_DIR_SUFFIX);
file_mkdir_hier(dest->info_dir, 0755);
sprintf_alloc(&dest->status_file_name, "%s/%s",
dest->ipkg_dir, IPKG_STATUS_FILE_SUFFIX);
sprintf_alloc(&dest->status_file_tmp_name, "%s/%s.tmp",
dest->ipkg_dir, IPKG_STATUS_FILE_SUFFIX);
dest->status_file = NULL;
return 0;
}
/*! Remove a directory recursively like <tt>rm -r</tt>.
*
* \return
* 0 on success, -1 on failure
*
* \param error
* On failure, \c error will be set to a newly allocated string
* that contains the error message.
* On success, or when out of memory,
* \c error will be set to \c NULL.
*
* \param dirname
* the directory to remove
*/
static int remove_directory_recursively(char **error, const char *dirname)
{
DIR *dir;
struct dirent *entry;
/* continue on errors and report only the first error that occured */
*error = NULL;
dir = opendir(dirname);
if (dir == NULL && *error == NULL) {
*error = sprintf_alloc("Unable to read directory entries of \"%s\": %s.",
dirname, strerror(errno));
} else {
for (entry = readdir(dir); entry != NULL; entry = readdir(dir)) {
char *name;
if ( strcmp(entry->d_name, ".") == 0
|| strcmp(entry->d_name, "..") == 0) {
continue;
}
name = sprintf_alloc("%s/%s", dirname, entry->d_name);
if (name == NULL && *error == NULL) {
*error = sprintf_alloc("Out of memory.");
continue;
}
if (entry->d_type == DT_DIR) {
char *sub_error;
if (remove_directory_recursively(&sub_error, name) != 0 && *error == NULL) {
*error = sub_error;
}
} else {
if (unlink(name) != 0 && *error == NULL) {
*error = sprintf_alloc("Unable to remove file \"%s\": %s.",
name, strerror(errno));
}
}
free(name);
}
if (closedir(dir) != 0 && *error == NULL) {
*error = sprintf_alloc("Unable to close directory \"%s\": %s.",
dirname, strerror(errno));
}
}
if (rmdir(dirname) != 0) {
if (*error == NULL) {
*error = sprintf_alloc("Unable to remove directory \"%s\": %s.",
dirname, strerror(errno));
}
return -1;
}
/* all previous errors are irrelevant because rmdir() was successful */
*error = NULL;
return 0;
}
static int parse_rdata(struct entry *entry, const char *owner, const char *rrtype, const char *rdata,
int ttl, knot_mm_t *mm)
{
knot_rdataset_init(&entry->data.rrs);
int ret = knot_rrtype_from_string(rrtype, &entry->data.type);
if (ret != KNOT_EOK) {
return ret;
}
/* Synthetize RR line */
char *rr_line = sprintf_alloc("%s %u IN %s %s\n", owner, ttl, rrtype, rdata);
if (zs_set_input_string(g_scanner, rr_line, strlen(rr_line)) != 0 ||
zs_parse_all(g_scanner) != 0) {
free(rr_line);
return KNOT_EPARSEFAIL;
}
free(rr_line);
/* Write parsed RDATA. */
knot_rdata_t rr[knot_rdata_array_size(g_scanner->r_data_length)];
knot_rdata_init(rr, g_scanner->r_data_length, g_scanner->r_data, ttl);
return knot_rdataset_add(&entry->data.rrs, rr, mm);
}
void remove_maintainer_scripts(pkg_t * pkg)
{
unsigned int i;
int err;
char *globpattern;
glob_t globbuf;
if (opkg_config->noaction)
return;
sprintf_alloc(&globpattern, "%s/%s.*", pkg->dest->info_dir, pkg->name);
err = glob(globpattern, 0, NULL, &globbuf);
free(globpattern);
if (err)
return;
for (i = 0; i < globbuf.gl_pathc; i++) {
opkg_msg(INFO, "Deleting %s.\n", globbuf.gl_pathv[i]);
unlink(globbuf.gl_pathv[i]);
}
globfree(&globbuf);
}
static int parse_rdata(struct entry *entry, const char *owner, const char *rrtype, const char *rdata,
int ttl, mm_ctx_t *mm)
{
knot_rdataset_init(&entry->data.rrs);
int ret = knot_rrtype_from_string(rrtype, &entry->data.type);
if (ret != KNOT_EOK) {
return ret;
}
/* Synthetize RR line */
char *rr_line = sprintf_alloc("%s %u IN %s %s\n", owner, ttl, rrtype, rdata);
ret = zs_scanner_parse(g_scanner, rr_line, rr_line + strlen(rr_line), true);
free(rr_line);
/* Write parsed RDATA. */
if (ret == KNOT_EOK) {
knot_rdata_t rr[knot_rdata_array_size(g_scanner->r_data_length)];
knot_rdata_init(rr, g_scanner->r_data_length, g_scanner->r_data, ttl);
ret = knot_rdataset_add(&entry->data.rrs, rr, mm);
}
return ret;
}
static void screen_shot(state_t * state, vx_code_input_stream_t * cins)
{
char * filename = NULL;
if (vx_code_input_stream_available(cins) > 0) {
const char * f2 = cins->read_str(cins);
filename = strdup(f2);
} else { // generate a unique ID
uint64_t mtime = vx_mtime();
time_t now = time(NULL);
struct tm * now2 = localtime(&now);
filename=sprintf_alloc("p%4d%02d%02d_%02d%02d%02d_%03d.png",
now2->tm_year + 1900,
now2->tm_mon + 1,
now2->tm_mday,
now2->tm_hour,
now2->tm_min,
now2->tm_sec,
(int)(mtime % 1000));
}
int last_idx = (state->cur_pb_idx + 1) % 2;
GdkPixbuf * pb = state->pixbufs[last_idx];
if (pb == NULL)
return;
GError * err = NULL;
gdk_pixbuf_save(pb,filename, "png", & err, NULL);
printf("Saved screenshot to %s\n", filename);
free(filename);
}
/* Join left and right path components without intervening '/' as left may end
* with a prefix to be applied to the names of extracted files.
*
* The right path component is stripped of leading '/' or './' components. If
* the right path component is simply '.' after stripping, it should not be
* created.
*
* Returns the joined path, or NULL if the resulting path should not be created.
*/
static char *join_paths(const char *left, const char *right)
{
char *path;
/* Skip leading '/' or './' in right-hand path if present. */
while (right[0] == '.' && right[1] == '/')
right += 2;
while (right[0] == '/')
right++;
/* Don't create '.' directory. */
if (right[0] == '.' && right[1] == '\0')
return NULL;
/* Don't extract empty paths. */
if (right[0] == '\0')
return NULL;
if (!left)
return xstrdup(right);
sprintf_alloc(&path, "%s%s", left, right);
return path;
}
static int set_and_load_pkg_src_list(ipkg_conf_t *conf, pkg_src_list_t *pkg_src_list)
{
pkg_src_list_elt_t *iter;
pkg_src_t *src;
char *list_file;
for (iter = pkg_src_list->head; iter; iter = iter->next) {
src = iter->data;
if (src == NULL) {
continue;
}
sprintf_alloc(&list_file, "%s/%s",
conf->restrict_to_default_dest ? conf->default_dest->lists_dir : conf->lists_dir,
src->name);
if (file_exists(list_file)) {
pkg_hash_add_from_file(conf, list_file, src, NULL, 0);
}
free(list_file);
}
return 0;
}
/* dept -1 causes depth to be ignored */
static xmlChar* get_xml_element (
xmlTextReaderPtr reader
)
{
int rc;
while((rc = xmlTextReaderRead(reader)) == 1){
int type;
xmlChar *name;
type = xmlTextReaderNodeType(reader);
if (type == XML_READER_TYPE_TEXT){
xmlChar *value;
value = xmlTextReaderValue(reader);
rrd_set_error("line %d: expected element but found text '%s'",
xmlTextReaderGetParserLineNumber(reader),value);
xmlFree(value);
return NULL;
}
/* skip all other non-elements */
if (type != XML_READER_TYPE_ELEMENT && type != XML_READER_TYPE_END_ELEMENT)
continue;
name = xmlTextReaderName(reader);
if (type == XML_READER_TYPE_END_ELEMENT){
xmlChar *temp;
xmlChar *temp2;
temp = (xmlChar*)sprintf_alloc("/%s",name);
temp2 = xmlStrdup(temp);
free(temp);
xmlFree(name);
return temp2;
}
/* all seems well, return the happy news */
return name;
}
if (rc == 0) {
rrd_set_error("the xml ended while we were looking for an element");
} else {
xmlErrorPtr err = xmlGetLastError();
/* argh: err->message often contains \n at the end. This is not
what we want: Bite the bullet by copying the message, replacing any
\n, constructing the rrd error message and freeing the temp. buffer.
*/
char *msgcpy = NULL, *c;
if (err != NULL && err->message != NULL) {
msgcpy = strdup(err->message);
if (msgcpy != NULL) {
for (c = msgcpy ; *c ; c++) {
if (*c == '\n') *c = ' ';
}
/* strip whitespace from end of message */
for (c-- ; c != msgcpy ; c--) {
if (!isprint(*c)) {
*c = 0;
}
}
} else {
/* out of memory during error handling, hmmmm */
}
}
rrd_set_error("error reading/parsing XML: %s",
msgcpy != NULL ? msgcpy : "?");
if (msgcpy) free(msgcpy);
}
return NULL;
} /* get_xml_element */
/*! Convert a TeX or LaTeX source to DVI or PDF.
*/
void texcaller_convert(char **result, size_t *result_size, char **info, const char *source, size_t source_size, const char *source_format, const char *result_format, int max_runs)
{
char *error;
const char *cmd;
const char *tmpdir;
char *dir = NULL;
char *dir_template = NULL;
char *source_filename = NULL;
char *aux_filename = NULL;
char *log_filename = NULL;
char *result_filename = NULL;
char *aux = NULL;
size_t aux_size = 0;
char *aux_old = NULL;
size_t aux_old_size = 0;
int runs;
*result = NULL;
*result_size = 0;
*info = NULL;
/* check arguments */
if (strcmp(source_format, "TeX") == 0 && strcmp(result_format, "DVI") == 0) {
cmd = "tex";
} else if (strcmp(source_format, "TeX") == 0 && strcmp(result_format, "PDF") == 0) {
cmd = "pdftex";
} else if (strcmp(source_format, "LaTeX") == 0 && strcmp(result_format, "DVI") == 0) {
cmd = "latex";
} else if (strcmp(source_format, "LaTeX") == 0 && strcmp(result_format, "PDF") == 0) {
cmd = "pdflatex";
} else {
*info = sprintf_alloc("Unable to convert from \"%s\" to \"%s\".",
source_format, result_format);
goto cleanup;
}
if (max_runs < 2) {
*info = sprintf_alloc("Argument max_runs is %i, but must be >= 2.",
max_runs);
goto cleanup;
}
/* create temporary directory */
tmpdir = getenv("TMPDIR");
if (tmpdir == NULL || strcmp(tmpdir, "") == 0) {
tmpdir = "/tmp";
}
dir_template = sprintf_alloc("%s/texcaller-temp-XXXXXX", tmpdir);
if (dir_template == NULL) {
goto cleanup;
}
dir = mkdtemp(dir_template);
if (dir == NULL) {
*info = sprintf_alloc("Unable to create temporary directory from template \"%s\": %s.",
dir_template, strerror(errno));
goto cleanup;
}
source_filename = sprintf_alloc("%s/texput.tex", dir);
if (source_filename == NULL) {
goto cleanup;
}
aux_filename = sprintf_alloc("%s/texput.aux", dir);
if (aux_filename == NULL) {
goto cleanup;
}
log_filename = sprintf_alloc("%s/texput.log", dir);
if (log_filename == NULL) {
goto cleanup;
}
if (strcmp(result_format, "DVI") == 0) {
result_filename = sprintf_alloc("%s/texput.dvi", dir);
} else {
result_filename = sprintf_alloc("%s/texput.pdf", dir);
}
if (result_filename == NULL) {
goto cleanup;
}
/* create source file */
if (write_file(&error, source_filename, source, source_size) != 0) {
*info = error;
goto cleanup;
}
/* run command as often as necessary */
for (runs = 1; runs <= max_runs; runs++) {
pid_t pid;
pid = fork();
if (pid == -1) {
*info = sprintf_alloc("Unable to fork child process: %s.",
strerror(errno));
goto cleanup;
}
/* child process */
if (pid == 0) {
/* run command within the temporary directory */
if (chdir(dir) != 0) {
exit(1);
}
/* prevent access to stdin, stdout and stderr */
fclose(stdin);
fclose(stdout);
fclose(stderr);
/* execute command */
execlp(cmd,
cmd,
"-interaction=batchmode",
"-halt-on-error",
"-file-line-error",
"-no-shell-escape",
"texput.tex",
NULL);
}
/* wait for child process */
for (;;) {
int status;
pid_t wpid = waitpid(pid, &status, 0);
if (wpid == -1) {
*info = sprintf_alloc("Unable to wait for child process: %s.",
strerror(errno));
goto cleanup;
}
if (WIFSIGNALED(status)) {
*info = sprintf_alloc("Command \"%s\" was terminated by signal %i.",
cmd, (int)WTERMSIG(status));
goto cleanup;
}
if (WIFEXITED(status) && WEXITSTATUS(status) != 0) {
*info = sprintf_alloc("Command \"%s\" terminated with exit status %i.",
cmd, (int)WEXITSTATUS(status));
goto cleanup;
}
if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
break;
}
}
/* read new aux file, saving old one */
free(aux_old);
aux_old = aux;
aux_old_size = aux_size;
read_file(&aux, &aux_size, &error, aux_filename);
/* tolerate missing aux file */
free(error);
/* check whether aux file stabilized,
which is also true if there isn't and wasn't any aux file */
if (aux_size == aux_old_size && memcmp(aux, aux_old, aux_size) == 0) {
read_file(result, result_size, &error, result_filename);
if (*result == NULL) {
*info = error;
goto cleanup;
}
*info = sprintf_alloc("Generated %s (%lu bytes)"
" from %s (%lu bytes) after %i runs.",
result_format, (unsigned long)*result_size,
source_format, (unsigned long)source_size, runs);
goto cleanup;
}
}
/* aux file didn't stabilize */
*info = sprintf_alloc("Output didn't stabilize after %i runs.",
max_runs);
goto cleanup;
/* cleanup all used resources */
cleanup:
if (log_filename != NULL) {
char *log;
size_t log_size;
read_file(&log, &log_size, &error, log_filename);
free(error);
if (log != NULL) {
if (*info == NULL) {
*info = log;
} else {
char *info_old = *info;
*info = sprintf_alloc("%s\n\n%s", info_old, log);
free(info_old);
free(log);
}
}
}
if (dir != NULL && remove_directory_recursively(&error, dir) != 0) {
free(*result);
*result = NULL;
*result_size = 0;
free(*info);
*info = error;
}
free(dir_template);
free(source_filename);
free(aux_filename);
free(log_filename);
free(result_filename);
free(aux);
free(aux_old);
}
/*! Read a file completely into a buffer that can be used as a string.
*
* \param result
* will be set to a newly allocated buffer that contains
* the complete content of the file,
* with a \c '\\0' added to the end.
* If an error occured,
* \c result will be set to \c NULL.
*
* \param result_size
* will be set to the size of \c result,
* not counting the added \c '\\0'.
* If an error occured,
* \c result_size will be set to \c 0.
*
* \param error
* On failure, \c error will be set to a newly allocated string
* that contains the error message.
* On success, or when out of memory,
* \c error will be set to \c NULL.
*
* \param path
* path of the file to read
*/
static void read_file(char **result, size_t *result_size, char **error, const char *path)
{
FILE *file;
long file_size;
size_t read_size;
*result = NULL;
*error = NULL;
file = fopen(path, "rb");
if (file == NULL) {
*error = sprintf_alloc("Unable to open file \"%s\" for reading: %s.",
path, strerror(errno));
goto error_cleanup;
}
if (fseek(file, 0, SEEK_END) != 0) {
*error = sprintf_alloc("Unable to seek to end of file \"%s\": %s.",
path, strerror(errno));
goto error_cleanup;
}
file_size = ftell(file);
if (file_size == -1) {
*error = sprintf_alloc("Unable to obtain size of file \"%s\": %s.",
path, strerror(errno));
goto error_cleanup;
}
*result_size = file_size;
if (fseek(file, 0, SEEK_SET) != 0) {
*error = sprintf_alloc("Unable to seek back to start of file \"%s\": %s.",
path, strerror(errno));
goto error_cleanup;
}
*result = (char *)malloc(*result_size + 1);
if (*result == NULL) {
*error = sprintf_alloc("Unable to allocate buffer for reading file \"%s\": %s.",
path, strerror(errno));
goto error_cleanup;
}
(*result)[*result_size] = '\0';
read_size = fread(*result, 1, *result_size, file);
if (ferror(file)) {
*error = sprintf_alloc("Unable to read %lu bytes from file \"%s\": %s.",
(unsigned long)*result_size, path, strerror(errno));
goto error_cleanup;
}
if (read_size != *result_size) {
*error = sprintf_alloc("Unable to read %lu bytes from file \"%s\": Got only %lu bytes.",
(unsigned long)*result_size, path, (unsigned long)read_size);
goto error_cleanup;
}
if (fclose(file) != 0) {
*error = sprintf_alloc("Unable to close file \"%s\" after reading: %s.",
path, strerror(errno));
file = NULL;
goto error_cleanup;
}
return;
error_cleanup:
free(*result);
*result = NULL;
*result_size = 0;
if (file != NULL) {
fclose(file);
}
}
int rrd_graph_xport(image_desc_t *im) {
/* prepare the data for processing */
unsigned long col_cnt=0;
time_t start=im->start;
time_t end=im->end;
unsigned long step=im->step;
char **legend_v=NULL;
rrd_value_t *data=NULL;
/* initialize buffer */
stringbuffer_t buffer={0,0,NULL,NULL};
/* check if we have a supported ggraph format */
switch (im->graph_type) {
/* allow the following to pass */
case GTYPE_TIME:
case GTYPE_XY:
break;
default:
rrd_set_error("Not supported graph type");
return -1;
}
/* if we write a file, then open it */
if (im->graphfile) {
buffer.file=fopen(im->graphfile,"w");
}
/* do the data processing */
if (rrd_xport_fn(im,&start,&end,&step,&col_cnt,&legend_v,&data,1)) { return -1;}
/* fill in some data */
rrd_infoval_t info;
info.u_cnt = start;
grinfo_push(im, sprintf_alloc("graph_start"), RD_I_CNT, info);
info.u_cnt = end;
grinfo_push(im, sprintf_alloc("graph_end"), RD_I_CNT, info);
info.u_cnt = step;
grinfo_push(im, sprintf_alloc("graph_step"), RD_I_CNT, info);
/* set locale */
/* format it for output */
int r=0;
switch(im->imgformat) {
case IF_XML:
r=rrd_xport_format_xmljson(2,&buffer,im, start, end, step, col_cnt, legend_v, data);
break;
case IF_XMLENUM:
r=rrd_xport_format_xmljson(6,&buffer,im, start, end, step, col_cnt, legend_v, data);
break;
case IF_JSON:
r=rrd_xport_format_xmljson(1,&buffer,im, start, end, step, col_cnt, legend_v, data);
break;
case IF_JSONTIME:
r=rrd_xport_format_xmljson(3,&buffer,im, start, end, step, col_cnt, legend_v, data);
break;
case IF_CSV:
r=rrd_xport_format_sv(',',&buffer,im, start, end, step, col_cnt, legend_v, data);
break;
case IF_TSV:
r=rrd_xport_format_sv('\t',&buffer,im, start, end, step, col_cnt, legend_v, data);
break;
case IF_SSV:
r=rrd_xport_format_sv(';',&buffer,im, start, end, step, col_cnt, legend_v, data);
break;
default:
break;
}
/* handle errors */
if (r) {
/* free legend */
for (unsigned long j = 0; j < col_cnt; j++) {
free(legend_v[j]);
}
free(legend_v);
/* free data */
free(data);
/* free the buffer */
if (buffer.data) {free(buffer.data);}
/* close the file */
if (buffer.file) {fclose(buffer.file);}
/* and return with error */
return r;
}
/* now do the cleanup */
if (buffer.file) {
fclose(buffer.file); buffer.file=NULL;
im->rendered_image_size=0;
im->rendered_image=NULL;
} else {
im->rendered_image_size=buffer.len;
im->rendered_image=buffer.data;
}
/* and print stuff */
return print_calc(im);
}
int
opkg_download(const char *src, const char *dest_file_name,
curl_progress_func cb, void *data, const short hide_error)
{
int err = 0;
char *src_basec = xstrdup(src);
char *src_base = basename(src_basec);
char *tmp_file_location;
opkg_msg(NOTICE,"Downloading %s.\n", src);
if (str_starts_with(src, "file:")) {
const char *file_src = src + 5;
opkg_msg(INFO, "Copying %s to %s...", file_src, dest_file_name);
err = file_copy(file_src, dest_file_name);
opkg_msg(INFO, "Done.\n");
free(src_basec);
return err;
}
sprintf_alloc(&tmp_file_location, "%s/%s", conf->tmp_dir, src_base);
free(src_basec);
err = unlink(tmp_file_location);
if (err && errno != ENOENT) {
opkg_perror(ERROR, "Failed to unlink %s", tmp_file_location);
free(tmp_file_location);
return -1;
}
if (conf->http_proxy) {
opkg_msg(DEBUG, "Setting environment variable: http_proxy = %s.\n",
conf->http_proxy);
setenv("http_proxy", conf->http_proxy, 1);
}
if (conf->ftp_proxy) {
opkg_msg(DEBUG, "Setting environment variable: ftp_proxy = %s.\n",
conf->ftp_proxy);
setenv("ftp_proxy", conf->ftp_proxy, 1);
}
if (conf->no_proxy) {
opkg_msg(DEBUG,"Setting environment variable: no_proxy = %s.\n",
conf->no_proxy);
setenv("no_proxy", conf->no_proxy, 1);
}
#ifdef HAVE_CURL
CURLcode res;
FILE * file = fopen (tmp_file_location, "w");
curl = opkg_curl_init (cb, data);
if (curl)
{
curl_easy_setopt (curl, CURLOPT_URL, src);
curl_easy_setopt (curl, CURLOPT_WRITEDATA, file);
res = curl_easy_perform (curl);
fclose (file);
if (res)
{
long error_code;
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &error_code);
opkg_msg(hide_error?DEBUG2:ERROR, "Failed to download %s: %s.\n",
src, curl_easy_strerror(res));
free(tmp_file_location);
return -1;
}
}
else
{
free(tmp_file_location);
return -1;
}
#else
{
int res;
const char *argv[8];
int i = 0;
argv[i++] = "wget";
argv[i++] = "-q";
if (conf->http_proxy || conf->ftp_proxy) {
argv[i++] = "-Y";
argv[i++] = "on";
}
argv[i++] = "-O";
argv[i++] = tmp_file_location;
argv[i++] = src;
argv[i++] = NULL;
res = xsystem(argv);
if (res) {
opkg_msg(ERROR, "Failed to download %s, wget returned %d.\n", src, res);
free(tmp_file_location);
return -1;
}
}
#endif
err = file_move(tmp_file_location, dest_file_name);
free(tmp_file_location);
return err;
}
