static void fam_dir_entry_free(void *data) {
fam_dir_entry *fam_dir = data;
if (!fam_dir) return;
FAMCancelMonitor(fam_dir->fc, fam_dir->req);
buffer_free(fam_dir->name);
free(fam_dir->req);
free(fam_dir);
}
static gboolean
g_fam_file_monitor_cancel (GFileMonitor *monitor)
{
GFamFileMonitor *gffm = G_FAM_FILE_MONITOR (monitor);
g_mutex_lock (&fam_lock);
g_assert (fam_initialised);
FAMCancelMonitor (&fam_connection, &gffm->request);
g_mutex_unlock (&fam_lock);
return TRUE;
}
static void fhs_event_remove_resource(struct fe_handler *feh, FAMEvent *fe)
{
struct sim_rdr_id *rdr_id;
int index;
#if 0
insert resource event and rdr event to event queue
#endif
index = 0;
rdr_id = sim_util_get_rdr_id(feh->ids, fe->filename, index);
while (rdr_id) {
FAMRequest fr;
fr.reqnum = rdr_id->reqnum;
FAMCancelMonitor(fe->fc, &fr);
index++;
rdr_id = sim_util_get_rdr_id(feh->ids, fe->filename, index);
}
sim_util_free_res_id(feh->ids, fe->filename);
printf("remove resource and sensor:%s, code:%d\n", fe->filename, fe->code);
return;
}
void vfs_file_monitor_remove( VFSFileMonitor * fm,
VFSFileMonitorCallback cb,
gpointer user_data )
{
int i;
VFSFileMonitorCallbackEntry* callbacks;
//printf( "vfs_file_monitor_remove\n" );
if ( !fm )
printf( " fm == NULL\n");
if ( cb && fm && fm->callbacks )
{
callbacks = ( VFSFileMonitorCallbackEntry* ) fm->callbacks->data;
for ( i = 0; i < fm->callbacks->len; ++i )
{
if ( callbacks[ i ].callback == cb && callbacks[ i ].user_data == user_data )
{
fm->callbacks = g_array_remove_index_fast ( fm->callbacks, i );
break;
}
}
}
if ( fm && g_atomic_int_dec_and_test( &fm->n_ref ) ) //MOD added "fm &&"
{
#ifdef USE_INOTIFY /* Linux inotify */
inotify_rm_watch ( inotify_fd, fm->wd );
#else /* Use FAM|gamin */
FAMCancelMonitor( &fam, &fm->request );
#endif
g_hash_table_remove( monitor_hash, fm->path );
g_free( fm->path );
g_array_free( fm->callbacks, TRUE );
g_slice_free( VFSFileMonitor, fm );
}
//printf( "vfs_file_monitor_remove DONE\n" );
}
static int
processCommand(char *line, int no)
{
int ret, args;
char *command = NULL;
char *arg = NULL;
char *arg2 = NULL;
if (line == NULL)
return (-1);
if (line[0] == '#')
return (0);
args = scanCommand(line, &command, &arg, &arg2);
if (args < 0)
return (-1);
if (args == 0)
return (0);
if (!strcmp(command, "connect")) {
if (testState.connected) {
fprintf(stderr, "connect line %d: already connected\n", no);
return (-1);
}
if (arg != NULL) {
#ifdef HAVE_SETENV
setenv("GAM_CLIENT_ID", arg, 1);
#elif HAVE_PUTENV
char *client_id = malloc (strlen (arg) + sizeof "GAM_CLIENT_ID=");
if (client_id)
{
strcpy (client_id, "GAM_CLIENT_ID=");
strcat (client_id, arg);
putenv (client_id);
}
#endif /* HAVE_SETENV */
}
ret = FAMOpen(&(testState.fc));
if (ret < 0) {
fprintf(stderr, "connect line %d: failed to connect\n", no);
return (-1);
}
testState.connected = 1;
if (arg != NULL)
printf("connected to %s\n", arg);
else
printf("connected\n");
} else if (!strcmp(command, "kill")) {
/*
* okay, it's heavy but that's the simplest way since we do not have
* the pid(s) of the servers running.
*/
ret = system("killall gam_server");
if (ret < 0) {
fprintf(stderr, "kill line %d: failed to killall gam_server\n",
no);
return (-1);
}
printf("killall gam_server\n");
} else if (!strcmp(command, "disconnect")) {
if (testState.connected == 0) {
fprintf(stderr, "disconnect line %d: not connected\n", no);
return (-1);
}
ret = FAMClose(&(testState.fc));
if (ret < 0) {
fprintf(stderr, "connect line %d: failed to disconnect\n", no);
return (-1);
}
testState.connected = 0;
printf("disconnected\n");
} else if (!strcmp(command, "mondir")) {
if (args >= 2) {
if (arg[0] != '/')
snprintf(filename, sizeof(filename), "%s/%s", pwd, arg);
else
snprintf(filename, sizeof(filename), "%s", arg);
}
if (args == 2) {
ret = FAMMonitorDirectory(&(testState.fc), filename,
&(testState.
fr[testState.nb_requests]), NULL);
} else if (args == 3) {
int index;
if (sscanf(arg2, "%d", &index) <= 0) {
fprintf(stderr, "mondir line %d: invalid index value %s\n",
no, arg2);
return (-1);
}
testState.fr[testState.nb_requests].reqnum = index;
ret = FAMMonitorDirectory2(&(testState.fc), filename,
&(testState.
fr[testState.nb_requests]));
} else {
fprintf(stderr, "mondir line %d: invalid format\n", no);
return (-1);
}
if (ret < 0) {
fprintf(stderr, "mondir line %d: failed to monitor %s\n", no,
arg);
return (-1);
}
printf("mondir %s %d\n", arg, testState.nb_requests);
testState.nb_requests++;
} else if (!strcmp(command, "monfile")) {
if (args != 2) {
fprintf(stderr, "monfile line %d: lacks name\n", no);
return (-1);
}
if (arg[0] != '/')
snprintf(filename, sizeof(filename), "%s/%s", pwd, arg);
else
snprintf(filename, sizeof(filename), "%s", arg);
ret = FAMMonitorFile(&(testState.fc), filename,
&(testState.fr[testState.nb_requests]), NULL);
if (ret < 0) {
fprintf(stderr, "monfile line %d: failed to monitor %s\n", no,
arg);
return (-1);
}
printf("monfile %s %d\n", arg, testState.nb_requests);
testState.nb_requests++;
} else if (!strcmp(command, "pending")) {
if (args != 1) {
fprintf(stderr, "pending line %d: extra argument %s\n", no,
arg);
return (-1);
}
ret = FAMPending(&(testState.fc));
if (ret < 0) {
fprintf(stderr, "pending line %d: failed\n", no);
return (-1);
}
printf("pending %d\n", ret);
} else if (!strcmp(command, "mkdir")) {
if (args != 2) {
fprintf(stderr, "mkdir line %d: lacks name\n", no);
return (-1);
}
ret = mkdir(arg, 0755);
if (ret < 0) {
fprintf(stderr, "mkdir line %d: failed to create %s\n", no,
arg);
return (-1);
}
printf("mkdir %s\n", arg);
} else if (!strcmp(command, "chmod")) {
if (args != 3) {
fprintf(stderr, "chmod line %d: lacks path and mode\n", no);
return (-1);
}
ret = chmod(arg, strtol (arg2, NULL, 8));
if (ret < 0) {
fprintf(stderr, "chmod line %d: failed to chmod %s to %s\n", no,
arg, arg2);
return (-1);
}
printf("chmod %s to %s\n", arg, arg2);
} else if (!strcmp(command, "chown")) {
if (args != 3) {
fprintf(stderr, "chown line %d: lacks path and owner\n", no);
return (-1);
}
struct stat sb;
if (!lstat (arg, &sb)) {
ret = (S_ISLNK (sb.st_mode)) ?
lchown(arg, strtol(arg2, NULL, 10), -1) :
chown(arg, strtol(arg2, NULL, 10), -1);
} else
ret=-1;
if (ret < 0) {
fprintf(stderr, "chown line %d: failed to chown %s to %s\n", no,
arg, arg2);
return (-1);
}
printf("chown %s to %s\n", arg, arg2);
} else if (!strcmp(command, "mkfile")) {
if (args != 2) {
fprintf(stderr, "mkfile line %d: lacks name\n", no);
return (-1);
}
ret = open(arg, O_CREAT | O_WRONLY, 0666);
if (ret < 0) {
fprintf(stderr, "mkfile line %d: failed to open %s\n", no,
arg);
return (-1);
}
close(ret);
printf("mkfile %s\n", arg);
} else if (!strcmp(command, "append")) {
if (args != 2) {
fprintf(stderr, "mkfile line %d: lacks name\n", no);
return (-1);
}
ret = open(arg, O_RDWR | O_APPEND);
if (ret < 0) {
fprintf(stderr, "append line %d: failed to open %s\n", no,
arg);
return (-1);
}
write(ret, "a", 1);
close(ret);
printf("append %s\n", arg);
} else if (!strcmp(command, "rmdir")) {
if (args != 2) {
fprintf(stderr, "rmdir line %d: lacks name\n", no);
return (-1);
}
ret = rmdir(arg);
if (ret < 0) {
fprintf(stderr, "rmdir line %d: failed to remove %s\n", no,
arg);
return (-1);
}
printf("rmdir %s\n", arg);
} else if (!strcmp(command, "rmfile")) {
if (args != 2) {
fprintf(stderr, "rmfile line %d: lacks name\n", no);
return (-1);
}
ret = unlink(arg);
if (ret < 0) {
fprintf(stderr, "rmfile line %d: failed to unlink %s\n", no,
arg);
return (-1);
}
printf("rmfile %s\n", arg);
} else if (!strcmp(command, "move")) {
if (args != 3)
{
fprintf(stderr, "move line %d: lacks something\n", no);
return (-1);
}
ret = rename(arg, arg2);
if (ret < 0) {
fprintf(stderr, "move line %d: failed to move %s\n", no, arg);
return (-1);
}
printf("move %s %s\n", arg, arg2);
} else if (!strcmp(command, "link")) {
if (args != 3) {
fprintf(stderr, "link line %d: lacks target and name\n", no); return (-1);
}
ret = symlink(arg, arg2);
if (ret < 0) {
fprintf(stderr, "link line %d: failed to link to %s\n", no, arg);
return (-1);
}
printf("link %s to %s\n", arg2, arg);
} else if (!strcmp(command, "event")) {
printEvent(no);
} else if (!strcmp(command, "events")) {
printEvents(no);
} else if (!strcmp(command, "expect")) {
int count;
int delay = 0;
int nb_events = testState.nb_events;
if (args != 2) {
fprintf(stderr, "expect line %d: lacks number\n", no);
return (-1);
}
if (sscanf(arg, "%d", &count) <= 0) {
fprintf(stderr, "expect line %d: invalid number value %s\n",
no, arg);
return (-1);
}
/*
* wait at most 3 secs before declaring failure
*/
while ((delay < 30) && (testState.nb_events < nb_events + count)) {
debugLoop(100);
/* printf("+"); fflush(stdout); */
delay++;
}
if (testState.nb_events < nb_events + count) {
printf("expect line %d: got %d of %d expected events\n",
no, testState.nb_events - nb_events, count);
return (-1);
}
} else if (!strcmp(command, "sleep")) {
int i;
for (i = 0; (i < 30) && (FAMPending(&(testState.fc)) == 0); i++)
usleep(50000);
} else if (!strcmp(command, "wait")) {
sleep(1);
} else if (!strcmp(command, "cancel")) {
if (args == 2) {
int req_index = 0;
if (sscanf(arg, "%d", &req_index) <= 0
|| req_index >= testState.nb_requests) {
fprintf(stderr,
"cancel line %d: invalid req_index value %s\n", no,
arg);
return (-1);
}
ret = FAMCancelMonitor(&(testState.fc),
&(testState.fr[req_index]));
} else {
fprintf(stderr, "cancel line %d: invalid format\n", no);
return (-1);
}
if (ret < 0) {
fprintf(stderr,
"cancel line %d: failed to cancel req_index %s\n", no,
arg);
return (-1);
}
printf("cancel %s %d\n", arg, testState.nb_requests);
} else {
fprintf(stderr, "Unable to parse line %d: %s\n", no, line);
return (-1);
}
return (0);
}
static void viewer_fam_cancel(viewer_t *viewer)
{
if ( viewer->fc_req_ok )
FAMCancelMonitor(&(viewer->fc), &(viewer->fc_req));
viewer->fc_req_ok = 0;
}
static int do_index(const char * filename,
DIC * dic) {
int i;
int j;
int k;
struct stat sbuf;
if (0 == strncmp(filename,
dic->ename,
strlen(dic->ename)))
return 0; /* database (and database-temp file) is always pruned! */
if (isPruned(filename))
return 0;
for (i=dic->deferredCount-1;i>=0;i--) {
if (0 == strcmp(filename,
dic->deferredTruncations[i])) {
free(dic->deferredTruncations[i]);
dic->deferredTruncations[i]
= dic->deferredTruncations[dic->deferredCount-1];
GROW(dic->deferredTruncations,
dic->deferredCount,
dic->deferredCount-1);
}
}
j = -1;
for (i=DOODLE_getFileCount(dic->tree)-1;i>=0;i--) {
if (0 == strcmp(filename,
DOODLE_getFileAt(dic->tree,i)->filename)) {
j = i;
break;
}
}
k = -1;
for (i=0;i<dic->frPos;i++) {
if (0 == strcmp(filename,
dic->frNames[i])) {
k=i;
break;
}
}
if (0 != lstat(filename,
&sbuf)) {
dic->log(dic->logContext,
DOODLE_LOG_VERY_VERBOSE,
_("Call to '%s' for file '%s' failed: %s\n"),
"stat",
filename,
strerror(errno));
if (j != -1) {
/* remove old keywords, file no longer there? */
GROW(dic->deferredTruncations,
dic->deferredCount,
dic->deferredCount + 1);
dic->deferredTruncations[dic->deferredCount-1]
= strdup(filename);
}
if (k != -1) {
if (-1 == FAMCancelMonitor(&dic->fc,
&dic->fr[k])) {
dic->log(dic->logContext,
DOODLE_LOG_CRITICAL,
_("Call to '%s' for file '%s' failed: %s\n"),
"FAMCancelMonitor",
filename,
FamErrlist[FAMErrno]);
}
free(dic->frNames[k]);
dic->fr[k] = dic->fr[dic->frPos-1];
dic->frNames[k] = dic->frNames[dic->frPos-1];
dic->frNames[dic->frPos-1] = NULL;
dic->frPos--;
}
return 0;
}
if ( (S_ISDIR(sbuf.st_mode)) &&
#ifdef S_ISLNK
(! S_ISLNK(sbuf.st_mode)) &&
#endif
#ifdef S_ISSOCK
(! S_ISSOCK(sbuf.st_mode)) &&
#endif
(k == -1) ) {
char * fn;
if (dic->frPos == dic->frSize) {
unsigned int s = dic->frSize;
GROW(dic->fr,
dic->frSize,
dic->frSize * 2);
GROW(dic->frNames,
s,
s * 2);
}
dic->log(dic->logContext,
DOODLE_LOG_VERY_VERBOSE,
_("Will monitor directory '%s' for changes.\n"),
filename);
fn = STRDUP(filename);
if (0 == FAMMonitorDirectory(&dic->fc,
filename,
&dic->fr[dic->frPos],
fn)) {
dic->frNames[dic->frPos] = fn;
dic->frPos++;
} else {
dic->log(dic->logContext,
DOODLE_LOG_CRITICAL,
_("Call to '%s' for file '%s' failed: %s\n"),
"FAMMonitorDirectory",
filename,
FamErrlist[FAMErrno]);
free(fn);
}
}
if (j != -1) {
if (DOODLE_getFileAt(dic->tree,j)->mod_time == (unsigned int) sbuf.st_mtime) {
return 0; /* already processed! */
} else {
/* remove old keywords, file changed! */
/* we must do the new truncation now, so
we also do all of those that were
deferred */
GROW(dic->deferredTruncations,
dic->deferredCount,
dic->deferredCount + 2);
dic->deferredTruncations[dic->deferredCount-2]
= strdup(filename);
DOODLE_tree_truncate_multiple(dic->tree,
(const char**)dic->deferredTruncations);
for (i=dic->deferredCount-2;i>=0;i--)
free(dic->deferredTruncations[i]);
GROW(dic->deferredTruncations,
dic->deferredCount,
0);
}
}
if (S_ISREG(sbuf.st_mode)) {
dic->log(dic->logContext,
DOODLE_LOG_VERY_VERBOSE,
_("Processing file '%s'.\n"),
filename);
return buildIndex(dic->elist,
NULL,
filename,
dic->tree,
do_filenames);
}
return 0;
}
