void restore_databases(struct configuration *conf, MYSQL *conn) {
GError *error= NULL;
GDir* dir= g_dir_open(directory, 0, &error);
if (error) {
g_critical("cannot open directory %s, %s\n", directory, error->message);
errors++;
return;
}
const gchar* filename= NULL;
while((filename= g_dir_read_name(dir))) {
if (g_strrstr(filename, "-schema.sql")) {
add_schema(filename, conn);
}
}
g_dir_rewind(dir);
while((filename= g_dir_read_name(dir))) {
if (!g_strrstr(filename, "-schema.sql") && g_strrstr(filename, ".sql")) {
add_table(filename, conf);
}
}
g_dir_close(dir);
}
static void
test_streams (GDir *dir, const char *datadir, const char *filename)
{
char inpath[256], outpath[256], *p, *q, *o;
const char *dent, *d;
gint64 start, end;
size_t n;
guint i;
p = g_stpcpy (inpath, datadir);
*p++ = G_DIR_SEPARATOR;
p = g_stpcpy (p, "input");
*p++ = G_DIR_SEPARATOR;
strcpy (p, filename);
q = g_stpcpy (outpath, datadir);
*q++ = G_DIR_SEPARATOR;
q = g_stpcpy (q, "output");
*q++ = G_DIR_SEPARATOR;
*q = '\0';
n = strlen (filename);
while ((dent = g_dir_read_name (dir))) {
if (strncmp (dent, filename, n) != 0 || dent[n] != '_')
continue;
d = dent + n + 1;
if ((start = strtol (d, &o, 10)) < 0 || *o != ',')
continue;
d = o + 1;
if ((((end = strtol (d, &o, 10)) < start) && end != -1) || *o != '\0')
continue;
strcpy (q, dent);
for (i = 0; i < G_N_ELEMENTS (checks); i++) {
testsuite_check ("%s on `%s'", checks[i].what, dent);
try {
if (!checks[i].check (inpath, outpath, dent, start, end)) {
testsuite_check_warn ("%s could not open `%s'",
checks[i].what, dent);
} else {
testsuite_check_passed ();
}
} catch (ex) {
testsuite_check_failed ("%s on `%s' failed: %s", checks[i].what,
dent, ex->message);
} finally;
}
}
g_dir_rewind (dir);
}
pointer foreign_dirrewind(scheme *sc, pointer args)
{
pointer first_arg;
GDir *dir;
if (args == sc->NIL)
return sc->F;
first_arg = sc->vptr->pair_car(args);
if (!sc->vptr->is_integer(first_arg))
return sc->F;
dir = (GDir *) sc->vptr->ivalue(first_arg);
if (dir == NULL)
return sc->F;
g_dir_rewind(dir);
return sc->T;
}
void restore_databases(struct configuration *conf, MYSQL *conn) {
GError *error= NULL;
GDir* dir= g_dir_open(directory, 0, &error);
if (error) {
g_critical("cannot open directory %s, %s\n", directory, error->message);
errors++;
return;
}
const gchar* filename= NULL;
while((filename= g_dir_read_name(dir))) {
if (!source_db || g_str_has_prefix(filename, g_strdup_printf("%s.", source_db))){
if (g_strrstr(filename, "-schema.sql")) {
add_schema(filename, conn);
}
}
}
g_dir_rewind(dir);
while((filename= g_dir_read_name(dir))) {
if (!source_db || g_str_has_prefix(filename, g_strdup_printf("%s.", source_db))){
if (!g_strrstr(filename, "-schema.sql")
&& !g_strrstr(filename, "-schema-view.sql")
&& !g_strrstr(filename, "-schema-triggers.sql")
&& !g_strrstr(filename, "-schema-post.sql")
&& !g_strrstr(filename, "-schema-create.sql")
&& g_strrstr(filename, ".sql")) {
add_table(filename, conf);
}
}
}
g_dir_close(dir);
}
int main (int argc, char **argv)
{
const char *datadir = "data/streams";
gboolean gen_data = TRUE;
char *stream_name = NULL;
char path[256], *p;
GDir *dir, *outdir;
const char *dent;
int i;
g_mime_init (0);
testsuite_init (argc, argv);
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
datadir = argv[i];
break;
}
}
testsuite_start ("Stream tests");
p = g_stpcpy (path, datadir);
*p++ = G_DIR_SEPARATOR;
strcpy (p, "output");
if (!(outdir = g_dir_open (path, 0, NULL))) {
if (gen_test_data (datadir, &stream_name) == -1 ||
!(outdir = g_dir_open (path, 0, NULL)))
goto exit;
gen_data = FALSE;
}
p = g_stpcpy (p, "input");
if (!(dir = g_dir_open (path, 0, NULL))) {
if (!gen_data || gen_test_data (datadir, &stream_name) == -1 ||
!(dir = g_dir_open (path, 0, NULL))) {
g_dir_close (outdir);
goto exit;
}
gen_data = FALSE;
}
if (gen_data) {
while ((dent = g_dir_read_name (dir))) {
if (dent[0] == '.' || !strcmp (dent, "README"))
continue;
gen_data = FALSE;
break;
}
g_dir_rewind (dir);
if (gen_data && gen_test_data (datadir, &stream_name) == -1)
goto exit;
}
*p++ = G_DIR_SEPARATOR;
*p = '\0';
while ((dent = g_dir_read_name (dir))) {
if (dent[0] == '.' || !strcmp (dent, "README"))
continue;
test_streams (outdir, datadir, dent);
strcpy (p, dent);
test_stream_buffer_gets (path);
}
if (gen_data && stream_name && testsuite_total_errors () == 0) {
/* since all tests were successful, unlink the generated test data */
strcpy (p, stream_name);
unlink (path);
p = g_stpcpy (path, datadir);
*p++ = G_DIR_SEPARATOR;
p = g_stpcpy (p, "output");
*p++ = G_DIR_SEPARATOR;
g_dir_rewind (outdir);
while ((dent = g_dir_read_name (outdir))) {
if (!strncmp (dent, stream_name, strlen (stream_name))) {
strcpy (p, dent);
unlink (path);
}
}
g_free (stream_name);
}
g_dir_close (outdir);
g_dir_close (dir);
exit:
testsuite_end ();
g_mime_shutdown ();
return testsuite_exit ();
}
void dt_film_import1(dt_job_t *job, dt_film_t *film)
{
gboolean recursive = dt_conf_get_bool("ui_last/import_recursive");
/* first of all gather all images to import */
GList *images = NULL;
images = _film_recursive_get_files(film->dirname, recursive, &images);
if(g_list_length(images) == 0)
{
dt_control_log(_("no supported images were found to be imported"));
return;
}
#ifdef USE_LUA
/* pre-sort image list for easier handling in Lua code */
images = g_list_sort(images, (GCompareFunc)_film_filename_cmp);
dt_lua_lock();
lua_State *L = darktable.lua_state.state;
{
GList *elt = images;
lua_newtable(L);
while(elt)
{
lua_pushstring(L, elt->data);
luaL_ref(L, -2);
elt = g_list_next(elt);
}
}
lua_pushvalue(L, -1);
dt_lua_event_trigger(L, "pre-import", 1);
{
g_list_free_full(images, g_free);
// recreate list of images
images = NULL;
lua_pushnil(L); /* first key */
while(lua_next(L, -2) != 0)
{
/* uses 'key' (at index -2) and 'value' (at index -1) */
void *filename = strdup(luaL_checkstring(L, -1));
lua_pop(L, 1);
images = g_list_prepend(images, filename);
}
}
lua_pop(L, 1); // remove the table again from the stack
dt_lua_unlock();
#endif
if(g_list_length(images) == 0)
{
// no error message, lua probably emptied the list on purpose
return;
}
/* we got ourself a list of images, lets sort and start import */
images = g_list_sort(images, (GCompareFunc)_film_filename_cmp);
/* let's start import of images */
gchar message[512] = { 0 };
double fraction = 0;
guint total = g_list_length(images);
g_snprintf(message, sizeof(message) - 1, ngettext("importing %d image", "importing %d images", total), total);
dt_control_job_set_progress_message(job, message);
/* loop thru the images and import to current film roll */
dt_film_t *cfr = film;
GList *image = g_list_first(images);
do
{
gchar *cdn = g_path_get_dirname((const gchar *)image->data);
/* check if we need to initialize a new filmroll */
if(!cfr || g_strcmp0(cfr->dirname, cdn) != 0)
{
// FIXME: maybe refactor into function and call it?
if(cfr && cfr->dir)
{
/* check if we can find a gpx data file to be auto applied
to images in the jsut imported filmroll */
g_dir_rewind(cfr->dir);
const gchar *dfn = NULL;
while((dfn = g_dir_read_name(cfr->dir)) != NULL)
{
/* check if we have a gpx to be auto applied to filmroll */
size_t len = strlen(dfn);
if(strcmp(dfn + len - 4, ".gpx") == 0 || strcmp(dfn + len - 4, ".GPX") == 0)
{
gchar *gpx_file = g_build_path(G_DIR_SEPARATOR_S, cfr->dirname, dfn, NULL);
gchar *tz = dt_conf_get_string("plugins/lighttable/geotagging/tz");
dt_control_gpx_apply(gpx_file, cfr->id, tz);
g_free(gpx_file);
g_free(tz);
}
}
}
/* cleanup previously imported filmroll*/
if(cfr && cfr != film)
{
if(dt_film_is_empty(cfr->id))
{
dt_film_remove(cfr->id);
}
dt_film_cleanup(cfr);
free(cfr);
cfr = NULL;
}
/* initialize and create a new film to import to */
cfr = malloc(sizeof(dt_film_t));
dt_film_init(cfr);
dt_film_new(cfr, cdn);
}
g_free(cdn);
/* import image */
dt_image_import(cfr->id, (const gchar *)image->data, FALSE);
fraction += 1.0 / total;
dt_control_job_set_progress(job, fraction);
} while((image = g_list_next(image)) != NULL);
g_list_free_full(images, g_free);
// only redraw at the end, to not spam the cpu with exposure events
dt_control_queue_redraw_center();
dt_control_signal_raise(darktable.signals, DT_SIGNAL_TAG_CHANGED);
dt_control_signal_raise(darktable.signals, DT_SIGNAL_FILMROLLS_IMPORTED, film->id);
// FIXME: maybe refactor into function and call it?
if(cfr && cfr->dir)
{
/* check if we can find a gpx data file to be auto applied
to images in the just imported filmroll */
g_dir_rewind(cfr->dir);
const gchar *dfn = NULL;
while((dfn = g_dir_read_name(cfr->dir)) != NULL)
{
/* check if we have a gpx to be auto applied to filmroll */
size_t len = strlen(dfn);
if(strcmp(dfn + len - 4, ".gpx") == 0 || strcmp(dfn + len - 4, ".GPX") == 0)
{
gchar *gpx_file = g_build_path(G_DIR_SEPARATOR_S, cfr->dirname, dfn, NULL);
gchar *tz = dt_conf_get_string("plugins/lighttable/geotagging/tz");
dt_control_gpx_apply(gpx_file, cfr->id, tz);
g_free(gpx_file);
g_free(tz);
}
}
}
/* cleanup previously imported filmroll*/
if(cfr && cfr != film)
{
dt_film_cleanup(cfr);
free(cfr);
}
}
void dt_film_import1(dt_film_t *film)
{
gboolean recursive = dt_conf_get_bool("ui_last/import_recursive");
/* first of all gather all images to import */
GList *images = NULL;
images = _film_recursive_get_files(film->dirname, recursive, &images);
if(g_list_length(images) == 0)
{
dt_control_log(_("no supported images were found to be imported"));
return;
}
/* we got ourself a list of images, lets sort and start import */
images = g_list_sort(images,(GCompareFunc)_film_filename_cmp);
/* let's start import of images */
gchar message[512] = {0};
double fraction = 0;
uint32_t total = g_list_length(images);
g_snprintf(message, sizeof(message) - 1,
ngettext("importing %d image","importing %d images", total), total);
const guint *jid = dt_control_backgroundjobs_create(darktable.control, 0, message);
/* loop thru the images and import to current film roll */
dt_film_t *cfr = film;
GList *image = g_list_first(images);
do
{
gchar *cdn = g_path_get_dirname((const gchar *)image->data);
/* check if we need to initialize a new filmroll */
if(!cfr || g_strcmp0(cfr->dirname, cdn) != 0)
{
#if GLIB_CHECK_VERSION (2, 26, 0)
if(cfr && cfr->dir)
{
/* check if we can find a gpx data file to be auto applied
to images in the jsut imported filmroll */
g_dir_rewind(cfr->dir);
const gchar *dfn = NULL;
while ((dfn = g_dir_read_name(cfr->dir)) != NULL)
{
/* check if we have a gpx to be auto applied to filmroll */
if(strcmp(dfn+strlen(dfn)-4,".gpx") == 0 ||
strcmp(dfn+strlen(dfn)-4,".GPX") == 0)
{
gchar *gpx_file = g_build_path (G_DIR_SEPARATOR_S, cfr->dirname, dfn, NULL);
dt_control_gpx_apply(gpx_file, cfr->id, dt_conf_get_string("plugins/lighttable/geotagging/tz"));
g_free(gpx_file);
}
}
}
#endif
/* cleanup previously imported filmroll*/
if(cfr && cfr!=film)
{
if(dt_film_is_empty(cfr->id))
{
dt_film_remove(cfr->id);
}
dt_film_cleanup(cfr);
g_free(cfr);
cfr = NULL;
}
/* initialize and create a new film to import to */
cfr = g_malloc(sizeof(dt_film_t));
dt_film_init(cfr);
dt_film_new(cfr, cdn);
}
/* import image */
dt_image_import(cfr->id, (const gchar *)image->data, FALSE);
fraction+=1.0/total;
dt_control_backgroundjobs_progress(darktable.control, jid, fraction);
}
while( (image = g_list_next(image)) != NULL);
// only redraw at the end, to not spam the cpu with exposure events
dt_control_queue_redraw_center();
dt_control_signal_raise(darktable.signals,DT_SIGNAL_TAG_CHANGED);
dt_control_backgroundjobs_destroy(darktable.control, jid);
dt_control_signal_raise(darktable.signals , DT_SIGNAL_FILMROLLS_IMPORTED,film->id);
#if GLIB_CHECK_VERSION (2, 26, 0)
if(cfr && cfr->dir)
{
/* check if we can find a gpx data file to be auto applied
to images in the just imported filmroll */
g_dir_rewind(cfr->dir);
const gchar *dfn = NULL;
while ((dfn = g_dir_read_name(cfr->dir)) != NULL)
{
/* check if we have a gpx to be auto applied to filmroll */
if(strcmp(dfn+strlen(dfn)-4,".gpx") == 0 ||
strcmp(dfn+strlen(dfn)-4,".GPX") == 0)
{
gchar *gpx_file = g_build_path (G_DIR_SEPARATOR_S, cfr->dirname, dfn, NULL);
dt_control_gpx_apply(gpx_file, cfr->id, dt_conf_get_string("plugins/lighttable/geotagging/tz"));
g_free(gpx_file);
}
}
}
#endif
}
/** \brief Update TLE files from local files.
* \param dir Directory where files are located.
* \param filter File filter, e.g. *.txt (not used at the moment!)
* \param silent TRUE if function should execute without graphical status indicator.
* \param label1 Activity label (can be NULL)
* \param label2 Statistics label (can be NULL)
* \param progress Pointer to progress indicator.
* \param init_prgs Initial value of progress indicator, e.g 0.5 if we are updating
* from network.
*
* This function is used to update the TLE data from local files.
*
* Functional description: TBD
*
*/
void tle_update_from_files (const gchar *dir, const gchar *filter,
gboolean silent, GtkWidget *progress,
GtkWidget *label1, GtkWidget *label2)
{
static GMutex tle_file_in_progress;
GHashTable *data; /* hash table with fresh TLE data */
GDir *cache_dir; /* directory to scan fresh TLE */
GDir *loc_dir; /* directory for gpredict TLE files */
GError *err = NULL;
gchar *text;
gchar *ldname;
gchar *userconfdir;
const gchar *fnam;
guint num = 0;
guint updated,updated_tmp;
guint skipped,skipped_tmp;
guint nodata,nodata_tmp;
guint newsats = 0;
guint total,total_tmp;
gdouble fraction = 0.0;
gdouble start = 0.0;
(void) filter; /* avoid unused parameter compiler warning */
if (g_mutex_trylock(&tle_file_in_progress) == FALSE)
{
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: A TLE update process is already running. Aborting."),
__FUNCTION__);
return;
}
/* create hash table */
data = g_hash_table_new_full (g_int_hash, g_int_equal, g_free, free_new_tle);
/* open directory and read files one by one */
cache_dir = g_dir_open (dir, 0, &err);
if (err != NULL) {
/* send an error message */
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: Error opening directory %s (%s)"),
__FUNCTION__, dir, err->message);
/* insert error message into the status string, too */
if (!silent && (label1 != NULL)) {
text = g_strdup_printf (_("<b>ERROR</b> opening directory %s\n%s"),
dir, err->message);
gtk_label_set_markup (GTK_LABEL (label1), text);
g_free (text);
}
g_clear_error (&err);
err = NULL;
}
else {
/* scan directory for tle files */
while ((fnam = g_dir_read_name (cache_dir)) != NULL) {
/* check that we got a TLE file */
if (is_tle_file(dir, fnam)) {
/* status message */
if (!silent && (label1 != NULL)) {
text = g_strdup_printf (_("Reading data from %s"), fnam);
gtk_label_set_text (GTK_LABEL (label1), text);
g_free (text);
/* Force the drawing queue to be processed otherwise there will
not be any visual feedback, ie. frozen GUI
- see Gtk+ FAQ http://www.gtk.org/faq/#AEN602
*/
while (g_main_context_iteration (NULL, FALSE));
/* give user a chance to follow progress */
g_usleep (G_USEC_PER_SEC / 100);
}
/* now, do read the fresh data */
num = read_fresh_tle (dir, fnam, data);
} else {
num = 0;
}
if (num < 1) {
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: No valid TLE data found in %s"),
__FUNCTION__, fnam);
}
else {
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s: Read %d sats from %s into memory"),
__FUNCTION__, num, fnam);
}
}
/* close directory since we don't need it anymore */
g_dir_close (cache_dir);
/* now we load each .sat file and update if we have new data */
userconfdir = get_user_conf_dir ();
ldname = g_strconcat (userconfdir, G_DIR_SEPARATOR_S, "satdata", NULL);
g_free (userconfdir);
/* open directory and read files one by one */
loc_dir = g_dir_open (ldname, 0, &err);
if (err != NULL) {
/* send an error message */
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: Error opening directory %s (%s)"),
__FUNCTION__, dir, err->message);
/* insert error message into the status string, too */
if (!silent && (label1 != NULL)) {
text = g_strdup_printf (_("<b>ERROR</b> opening directory %s\n%s"),
dir, err->message);
gtk_label_set_markup (GTK_LABEL (label1), text);
g_free (text);
}
g_clear_error (&err);
err = NULL;
}
else {
/* clear statistics */
updated = 0;
skipped = 0;
nodata = 0;
total = 0;
/* get initial value of progress indicator */
if (progress != NULL)
start = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (progress));
/* This is insane but I don't know how else to count the number of sats */
num = 0;
while ((fnam = g_dir_read_name (loc_dir)) != NULL) {
/* only consider .sat files */
if (g_str_has_suffix (fnam, ".sat")) {
num++;
}
}
g_dir_rewind (loc_dir);
/* update TLE files one by one */
while ((fnam = g_dir_read_name (loc_dir)) != NULL) {
/* only consider .sat files */
if (g_str_has_suffix (fnam, ".sat")) {
/* clear stat bufs */
updated_tmp = 0;
skipped_tmp = 0;
nodata_tmp = 0;
total_tmp = 0;
/* update TLE data in this file */
update_tle_in_file (ldname, fnam, data,
&updated_tmp,
&skipped_tmp,
&nodata_tmp,
&total_tmp);
/* update statistics */
updated += updated_tmp;
skipped += skipped_tmp;
nodata += nodata_tmp;
total = updated+skipped+nodata;
if (!silent) {
if (label1 != NULL) {
gtk_label_set_text (GTK_LABEL (label1),
_("Updating data..."));
}
if (label2 != NULL) {
text = g_strdup_printf (_("Satellites updated:\t %d\n"\
"Satellites skipped:\t %d\n"\
"Missing Satellites:\t %d\n"),
updated, skipped, nodata);
gtk_label_set_text (GTK_LABEL (label2), text);
g_free (text);
}
if (progress != NULL) {
/* two different calculations for completeness depending on whether
we are adding new satellites or not. */
if (sat_cfg_get_bool (SAT_CFG_BOOL_TLE_ADD_NEW)) {
/* In this case we are possibly processing more than num satellites
How many more? We do not know yet. Worst case is g_hash_table_size more.
As we update skipped and updated we can reduce the denominator count
as those are in both pools (files and hash table). When we have processed
all the files, updated and skipped are completely correct and the progress
is correct. It may be correct sooner if the missed satellites are the
last files to process.
Until then, if we eliminate the ones that are updated and skipped from being
double counted, our progress will shown will always be less or equal to our
true progress since the denominator will be larger than is correct.
Advantages to this are that the progress bar does not stall close to
finished when there are a large number of new satellites.
*/
fraction = start + (1.0-start) * ((gdouble) total) /
((gdouble) num + g_hash_table_size(data) - updated - skipped);
} else {
/* here we only process satellites we have have files for so divide by num */
fraction = start + (1.0-start) * ((gdouble) total) / ((gdouble) num);
}
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress),
fraction);
}
/* update the gui only every so often to speed up the process */
/* 47 was selected empirically to balance the update looking smooth but not take too much time. */
/* it also tumbles all digits in the numbers so that there is no obvious pattern. */
/* on a developer machine this improved an update from 5 minutes to under 20 seconds. */
if (total%47 == 0) {
/* Force the drawing queue to be processed otherwise there will
not be any visual feedback, ie. frozen GUI
- see Gtk+ FAQ http://www.gtk.org/faq/#AEN602
*/
while (g_main_context_iteration (NULL, FALSE));
/* give user a chance to follow progress */
g_usleep (G_USEC_PER_SEC / 1000);
}
}
}
}
/* force gui update */
while (g_main_context_iteration (NULL, FALSE));
/* close directory handle */
g_dir_close (loc_dir);
/* see if we have any new sats that need to be added */
if (sat_cfg_get_bool (SAT_CFG_BOOL_TLE_ADD_NEW)) {
newsats = add_new_sats (data);
if (!silent && (label2 != NULL)) {
text = g_strdup_printf (_("Satellites updated:\t %d\n"\
"Satellites skipped:\t %d\n"\
"Missing Satellites:\t %d\n"\
"New Satellites:\t\t %d"),
updated, skipped, nodata, newsats);
gtk_label_set_text (GTK_LABEL (label2), text);
g_free (text);
}
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s: Added %d new satellites to local database"),
__FUNCTION__, newsats);
}
/* store time of update if we have updated something */
if ((updated > 0) || (newsats > 0)) {
GTimeVal tval;
g_get_current_time (&tval);
sat_cfg_set_int (SAT_CFG_INT_TLE_LAST_UPDATE, tval.tv_sec);
}
}
g_free (ldname);
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s: TLE elements updated."),
__FUNCTION__);
}
/* destroy hash tables */
g_hash_table_destroy (data);
g_mutex_unlock(&tle_file_in_progress);
}
bool _vmnetfs_ll_modified_upload(struct vmnetfs_image *img, GError **err) {
GDir *root_dir, *chunk_dir;
char *name, *chunk_dir_path, *file;
char *endptr;
uint64_t chunk;
FILE *chunk_file;
char *chunk_path;
bool ret;
struct timespec start, end;
struct timespec temp;
root_dir = g_dir_open(img->modified_base, 0, err);
if (root_dir == NULL) {
goto out;
}
/* Read the chunk directories 0, 4096, ... */
while (true) {
while ((name = g_dir_read_name(root_dir)) != NULL) {
chunk_dir_path = g_strdup_printf("%s/%s", img->modified_base, name);
/* Iterate through chunk directories */
if (g_file_test(chunk_dir_path, G_FILE_TEST_IS_DIR)) {
chunk_dir = g_dir_open(chunk_dir_path, 0, err);
while ((file = g_dir_read_name(chunk_dir)) != NULL) {
clock_gettime(CLOCK_MONOTONIC, &temp);
/* Check if chunk is already uploaded */
chunk = g_ascii_strtoull(file, &endptr, 10);
if (is_uploaded(img, chunk)) {
continue;
}
chunk_path = g_strdup_printf("%s/%s", chunk_dir_path, file);
/* Read chunk and upload */
chunk_file = fopen(chunk_path, "r");
/* Mark the file as uploaded before so that if any
* modifications are made before upload finished, they are
* still marked dirty */
set_uploaded_file(chunk_path, true);
clock_gettime(CLOCK_MONOTONIC, &start);
clock_t start2 = clock();
_vmnetfs_io_put_data(img, img->cpool, chunk, chunk_file, err);
if (!img->checkin) {
// usleep(1000*100);
}
clock_t stop = clock();
double elapsed = (double)(stop - start2) * 1000.0 / CLOCKS_PER_SEC;
clock_gettime(CLOCK_MONOTONIC, &end);
if (*err != NULL) {
}
fclose(chunk_file);
/* Update stats and streams */
_vmnetfs_u64_stat_decrement(img->chunks_modified_not_uploaded, 1);
_vmnetfs_bit_notify_plus_minus(img->uploaded_map, chunk, 1);
/* Cleanup */
g_free(chunk_path);
// TEMP THROTTLE FOR NON CHECKIN
if (!img->checkin) {
// usleep in microseconds (millionth)
unsigned int wait_us;
uint64_t diff = 1000000000L * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec;
diff = diff / 1000;
wait_us = (unsigned int) ((double) diff / img->rate) - diff;
// fputs(g_strdup_printf("transfer took %u, %u %f %f waiting %u microseconds\n", diff,
// diff/1000, img->rate, (double)diff / img->rate, (unsigned int)wait_us), f);
// usleep((unsigned int)wait_us);
}
}
g_dir_close(chunk_dir);
}
g_free(chunk_dir_path);
}
g_dir_rewind(root_dir);
sleep(1);
}
out:
g_dir_close(root_dir);
return true;
}
static gboolean enable_i8042_debugging(GError **error) {
GDir *devices_dir = NULL;
GSList *connected_ports = NULL;
struct sigaction sigaction_struct;
devices_dir = g_dir_open(I8042_DEV_DIR, 0, error);
if (!devices_dir) {
g_prefix_error(error, "While opening " I8042_DEV_DIR ": ");
goto error;
}
/* Detach the devices before we do anything, this prevents potential race
* conditions */
for (gchar const *dir_name = g_dir_read_name(devices_dir);
dir_name != NULL && *error == NULL;
dir_name = g_dir_read_name(devices_dir)) {
gchar *file_name;
gchar *input_dev_path;
if (!g_str_has_prefix(dir_name, "serio"))
continue;
/* Check if the port's connected */
input_dev_path = g_build_filename(I8042_DEV_DIR, dir_name, "input",
NULL);
if (!g_file_test(input_dev_path, G_FILE_TEST_EXISTS)) {
g_free(input_dev_path);
continue;
}
g_free(input_dev_path);
connected_ports = g_slist_prepend(connected_ports, strdup(dir_name));
file_name = g_build_filename(I8042_DEV_DIR, dir_name, "drvctl", NULL);
if (!write_to_char_dev(file_name, error, "none")) {
g_free(file_name);
goto error;
}
g_free(file_name);
}
if (*error)
goto error;
/* We mark when the recording starts, so that we can separate this recording
* from other recordings ran during this session */
start_time = g_get_monotonic_time();
if (!write_to_char_dev("/dev/kmsg", error, "ps2emu: Start recording %ld\n",
start_time))
goto error;
/* Enable the debugging output for i8042 */
if (!write_to_char_dev("/sys/module/i8042/parameters/debug", error, "1\n"))
goto error;
/* As of Linux 4.3+, data coming out of the KBD port is masked by default */
if (recording_target == PS2_PORT_KBD &&
g_file_test("/sys/module/i8042/parameters/unmask_kbd_data",
G_FILE_TEST_EXISTS)) {
if (!write_to_char_dev("/sys/module/i8042/parameters/unmask_kbd_data",
error, "1\n"))
goto error;
}
/* Reattach the devices */
g_dir_rewind(devices_dir);
for (gchar const *dir_name = g_dir_read_name(devices_dir);
dir_name != NULL && *error == NULL;
dir_name = g_dir_read_name(devices_dir)) {
gchar *file_name;
gboolean was_connected = FALSE;
/* Check if the directory was a previously connected port */
for (GSList *l = connected_ports; l != NULL; l = l->next) {
if (strcmp(l->data, dir_name) != 0)
continue;
was_connected = TRUE;
break;
}
if (!was_connected)
continue;
file_name = g_build_filename(I8042_DEV_DIR, dir_name, "drvctl", NULL);
if (!write_to_char_dev(file_name, error, "rescan")) {
g_free(file_name);
goto error;
}
g_free(file_name);
}
if (*error)
goto error;
g_dir_close(devices_dir);
g_slist_free_full(connected_ports, g_free);
/* Disable debugging when this application quits */
memset(&sigaction_struct, 0, sizeof(sigaction_struct));
sigaction_struct.sa_handler = exit_on_interrupt;
g_warn_if_fail(sigaction(SIGINT, &sigaction_struct, NULL) == 0);
g_warn_if_fail(sigaction(SIGTERM, &sigaction_struct, NULL) == 0);
g_warn_if_fail(sigaction(SIGHUP, &sigaction_struct, NULL) == 0);
return TRUE;
error:
if (devices_dir)
g_dir_close(devices_dir);
if (connected_ports)
g_slist_free_full(connected_ports, g_free);
return FALSE;
}
static gchar * fileinfo_recursive_get_image (const gchar * path, const gchar *
file_name, gint depth)
{
GDir *d;
if (get_bool (NULL, "recurse_for_cover") && depth > get_int (NULL, "recurse_for_cover_depth"))
return NULL;
d = g_dir_open(path, 0, NULL);
if (d) {
const gchar *f;
if (get_bool (NULL, "use_file_cover") && file_name)
{
/* Look for images matching file name */
while((f = g_dir_read_name(d))) {
gchar *newpath = g_strconcat(path, "/", f, NULL);
if (!g_file_test(newpath, G_FILE_TEST_IS_DIR) &&
has_front_cover_extension(f) &&
is_file_image(f, file_name)) {
g_dir_close(d);
return newpath;
}
g_free(newpath);
}
g_dir_rewind(d);
}
/* Search for files using filter */
while ((f = g_dir_read_name(d))) {
gchar *newpath = g_strconcat(path, "/", f, NULL);
if (!g_file_test(newpath, G_FILE_TEST_IS_DIR) &&
has_front_cover_extension(f) &&
is_front_cover_image(f)) {
g_dir_close(d);
return newpath;
}
g_free(newpath);
}
g_dir_rewind(d);
/* checks whether recursive or not. */
if (! get_bool (NULL, "recurse_for_cover"))
{
g_dir_close(d);
return NULL;
}
/* Descend into directories recursively. */
while ((f = g_dir_read_name(d))) {
gchar *newpath = g_strconcat(path, "/", f, NULL);
if(g_file_test(newpath, G_FILE_TEST_IS_DIR)) {
gchar *tmp = fileinfo_recursive_get_image(newpath,
NULL, depth + 1);
if(tmp) {
g_free(newpath);
g_dir_close(d);
return tmp;
}
}
g_free(newpath);
}
g_dir_close(d);
}
return NULL;
}
/* scandir using glib */
gint _wapi_io_scandir (const gchar *dirname, const gchar *pattern,
gchar ***namelist)
{
GError *error = NULL;
GDir *dir;
GPtrArray *names;
gint result;
wapi_glob_t glob_buf;
int flags = 0, i;
dir = _wapi_g_dir_open (dirname, 0, &error);
if (dir == NULL) {
/* g_dir_open returns ENOENT on directories on which we don't
* have read/x permission */
gint errnum = get_errno_from_g_file_error (error->code);
g_error_free (error);
if (errnum == ENOENT &&
!_wapi_access (dirname, F_OK) &&
_wapi_access (dirname, R_OK|X_OK)) {
errnum = EACCES;
}
errno = errnum;
return -1;
}
if (IS_PORTABILITY_CASE) {
flags = WAPI_GLOB_IGNORECASE;
}
result = _wapi_glob (dir, pattern, flags, &glob_buf);
if (g_str_has_suffix (pattern, ".*")) {
/* Special-case the patterns ending in '.*', as
* windows also matches entries with no extension with
* this pattern.
*
* TODO: should this be a MONO_IOMAP option?
*/
gchar *pattern2 = g_strndup (pattern, strlen (pattern) - 2);
gint result2;
g_dir_rewind (dir);
result2 = _wapi_glob (dir, pattern2, flags | WAPI_GLOB_APPEND | WAPI_GLOB_UNIQUE, &glob_buf);
g_free (pattern2);
if (result != 0) {
result = result2;
}
}
g_dir_close (dir);
if (glob_buf.gl_pathc == 0) {
return(0);
} else if (result != 0) {
return(-1);
}
names = g_ptr_array_new ();
for (i = 0; i < glob_buf.gl_pathc; i++) {
g_ptr_array_add (names, g_strdup (glob_buf.gl_pathv[i]));
}
_wapi_globfree (&glob_buf);
result = names->len;
if (result > 0) {
g_ptr_array_sort (names, file_compare);
g_ptr_array_set_size (names, result + 1);
*namelist = (gchar **) g_ptr_array_free (names, FALSE);
} else {
g_ptr_array_free (names, TRUE);
}
return result;
}