gnunet-auto-share.c File Reference

automatically publish files on GNUnet More...

#include "platform.h"
#include "gnunet_util_lib.h"

Include dependency graph for gnunet-auto-share.c:

Go to the source code of this file.

Data Structures
struct	WorkItem
	Item in our work queue (or in the set of files/directories we have successfully published). More...

Macros
#define	MAX_DELAY   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
#define	MIN_DELAY   GNUNET_TIME_UNIT_MINUTES

Functions
static char *	get_state_file ()
	Compute the name of the state database file we will use. More...
static void	load_state ()
	Load the set of work_finished items from disk. More...
static int	write_item (void *cls, const struct GNUNET_HashCode *key, void *value)
	Write work item from the work_finished map to the given write handle. More...
static void	save_state ()
	Save the set of work_finished items on disk. More...
static void	do_stop_task (void *cls)
	Task run on shutdown. More...
static void	schedule_next_task (void)
	Decide what the next task is (working or scanning) and schedule it. More...
static void	maint_child_death (void *cls)
	Task triggered whenever we receive a SIGCHLD (child process died). More...
static void	sighandler_child_death ()
	Signal handler called for SIGCHLD. More...
static void	work (void *cls)
	Function called to process work items. More...
static int	determine_id (void *cls, const char *filename)
	Recursively scan the given file/directory structure to determine a unique ID that represents the current state of the hierarchy. More...
static int	add_file (void *cls, const char *filename)
	Function called with a filename (or directory name) to publish (if it has changed since the last time we published it). More...
static void	scan (void *cls)
	Periodically run task to update our view of the directory to share. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Main function that will be run by the scheduler. More...
static int	free_item (void *cls, const struct GNUNET_HashCode *key, void *value)
	Free memory associated with the work item from the work_finished map. More...
int	main (int argc, char *const *argv)
	The main function to automatically publish content to GNUnet. More...

Variables
static int	ret
	Global return value from 'main'. More...
static unsigned int	verbose
	Are we running 'verbosely'? More...
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Configuration to use. More...
static char *	cfg_filename
	Name of the configuration file. More...
static int	disable_extractor
	Disable extractor option to use for publishing. More...
static int	do_disable_creation_time
	Disable creation time option to use for publishing. More...
static struct GNUNET_SCHEDULER_Task *	run_task
	Handle for the main task that does scanning and working. More...
static unsigned int	anonymity_level = 1
	Anonymity level option to use for publishing. More...
static unsigned int	content_priority = 365
	Content priority option to use for publishing. More...
static unsigned int	replication_level = 1
	Replication level option to use for publishing. More...
static const char *	dir_name
	Top-level directory we monitor to auto-publish. More...
static struct WorkItem *	work_head
	Head of linked list of files still to publish. More...
static struct WorkItem *	work_tail
	Tail of linked list of files still to publish. More...
static struct GNUNET_CONTAINER_MultiHashMap *	work_finished
	Map from the hash of the filename (!) to a struct WorkItem that was finished. More...
static int	do_shutdown
	Set to GNUNET_YES if we are shutting down. More...
static struct GNUNET_TIME_Absolute	start_time
	Start time of the current round; used to determine how long one iteration takes (which influences how fast we schedule the next one). More...
static struct GNUNET_DISK_PipeHandle *	sigpipe
	Pipe used to communicate 'gnunet-publish' completion (SIGCHLD) via signal. More...
static struct GNUNET_OS_Process *	publish_proc
	Handle to the 'gnunet-publish' process that we executed. More...

Detailed Description

automatically publish files on GNUnet

Author

Christian Grothoff

TODO:

• support loading meta data / keywords from resource file
• add stability timer (a la buildbot)

Definition in file gnunet-auto-share.c.

Macro Definition Documentation

MAX_DELAY

#define MAX_DELAY   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)

Definition at line 32 of file gnunet-auto-share.c.

MIN_DELAY

#define MIN_DELAY   GNUNET_TIME_UNIT_MINUTES

Definition at line 34 of file gnunet-auto-share.c.

Function Documentation

get_state_file()

static char* get_state_file ( )

static

Compute the name of the state database file we will use.

Definition at line 164 of file gnunet-auto-share.c.

{
  char *ret;
 
  GNUNET_asprintf (&ret,
                   "%s%s.auto-share",
                   dir_name,
                   (DIR_SEPARATOR == dir_name[strlen (dir_name) - 1])
                   ? ""
                   : DIR_SEPARATOR_STR);
  return ret;
}

References dir_name, DIR_SEPARATOR, DIR_SEPARATOR_STR, GNUNET_asprintf(), and ret.

Referenced by load_state(), and save_state().

Here is the call graph for this function:

Here is the caller graph for this function:

load_state()

static void load_state ( )

static

Load the set of work_finished items from disk.

Definition at line 182 of file gnunet-auto-share.c.

{
  char *fn;
  struct GNUNET_BIO_ReadHandle *rh;
  uint32_t n;
  struct GNUNET_HashCode id;
  struct WorkItem *wi;
  char *emsg;
 
  emsg = NULL;
  fn = get_state_file ();
  rh = GNUNET_BIO_read_open_file (fn);
  GNUNET_free (fn);
  if (NULL == rh)
    return;
  fn = NULL;
  if (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "number of files",
                                          (int32_t *) &n))
    goto error;
  while (n-- > 0)
  {
    struct GNUNET_BIO_ReadSpec rs[] = {
      GNUNET_BIO_read_spec_string ("filename", &fn, 1024),
      GNUNET_BIO_read_spec_object ("id", &id, sizeof(struct GNUNET_HashCode)),
      GNUNET_BIO_read_spec_end (),
    };
    if (GNUNET_OK != GNUNET_BIO_read_spec_commit (rh, rs))
      goto error;
    wi = GNUNET_new (struct WorkItem);
    wi->id = id;
    wi->filename = fn;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Loaded serialization ID for `%s' is `%s'\n",
                wi->filename,
                GNUNET_h2s (&id));
    fn = NULL;
    GNUNET_CRYPTO_hash (wi->filename, strlen (wi->filename), &id);
    GNUNET_break (GNUNET_OK ==
                  GNUNET_CONTAINER_multihashmap_put (
                    work_finished,
                    &id,
                    wi,
                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  }
  if (GNUNET_OK == GNUNET_BIO_read_close (rh, &emsg))
    return;
  rh = NULL;
error:
  GNUNET_free (fn);
  if (NULL != rh)
    (void) GNUNET_BIO_read_close (rh, &emsg);
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              _ ("Failed to load state: %s\n"),
              emsg);
  GNUNET_free (emsg);
}

References _, WorkItem::filename, get_state_file(), GNUNET_BIO_read_close(), GNUNET_BIO_read_int32(), GNUNET_BIO_read_open_file(), GNUNET_BIO_read_spec_commit(), GNUNET_BIO_read_spec_end, GNUNET_BIO_read_spec_object(), GNUNET_BIO_read_spec_string(), GNUNET_break, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_new, GNUNET_OK, id, WorkItem::id, GNUNET_BIO_ReadSpec::rh, and work_finished.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

write_item()

static int write_item ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Write work item from the work_finished map to the given write handle.

Parameters

cls	the struct GNUNET_BIO_WriteHandle *
key	key of the item in the map (unused)
value	the struct WorkItem to write

Returns

GNUNET_OK to continue to iterate (if write worked)

Definition at line 249 of file gnunet-auto-share.c.

{
  struct GNUNET_BIO_WriteHandle *wh = cls;
  struct WorkItem *wi = value;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Saving serialization ID of file `%s' with value `%s'\n",
              wi->filename,
              GNUNET_h2s (&wi->id));
  struct GNUNET_BIO_WriteSpec ws[] = {
    GNUNET_BIO_write_spec_string ("auto-share-write-item-filename",
                                  wi->filename),
    GNUNET_BIO_write_spec_object ("id", &wi->id, sizeof(struct
                                                        GNUNET_HashCode)),
    GNUNET_BIO_write_spec_end (),
  };
  if (GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws))
    return GNUNET_SYSERR; /* write error, abort iteration */
  return GNUNET_OK;
}

References WorkItem::filename, GNUNET_BIO_write_spec_commit(), GNUNET_BIO_write_spec_end, GNUNET_BIO_write_spec_object(), GNUNET_BIO_write_spec_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_OK, GNUNET_SYSERR, WorkItem::id, value, and wh.

Referenced by save_state().

Here is the call graph for this function:

Here is the caller graph for this function:

save_state()

static void save_state ( )

static

Save the set of work_finished items on disk.

Definition at line 275 of file gnunet-auto-share.c.

{
  uint32_t n;
  struct GNUNET_BIO_WriteHandle *wh;
  char *fn;
 
  n = GNUNET_CONTAINER_multihashmap_size (work_finished);
  fn = get_state_file ();
  wh = GNUNET_BIO_write_open_file (fn);
  if (NULL == wh)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to save state to file %s\n"),
                fn);
    GNUNET_free (fn);
    return;
  }
  if (GNUNET_OK != GNUNET_BIO_write_int32 (wh, "size of state", n))
  {
    (void) GNUNET_BIO_write_close (wh, NULL);
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to save state to file %s\n"),
                fn);
    GNUNET_free (fn);
    return;
  }
  (void) GNUNET_CONTAINER_multihashmap_iterate (work_finished, &write_item, wh);
  if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to save state to file %s\n"),
                fn);
  GNUNET_free (fn);
}

References _, get_state_file(), GNUNET_BIO_write_close(), GNUNET_BIO_write_int32(), GNUNET_BIO_write_open_file(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_OK, wh, work_finished, and write_item().

Referenced by maint_child_death().

Here is the call graph for this function:

Here is the caller graph for this function:

do_stop_task()

static void do_stop_task ( void *  cls )

static

Task run on shutdown.

Serializes our current state to disk.

Parameters

cls	closure, unused

Definition at line 316 of file gnunet-auto-share.c.

{
  do_shutdown = GNUNET_YES;
  if (NULL != publish_proc)
  {
    GNUNET_OS_process_kill (publish_proc, SIGKILL);
    return;
  }
  if (NULL != run_task)
  {
    GNUNET_SCHEDULER_cancel (run_task);
    run_task = NULL;
  }
}

References do_shutdown, GNUNET_OS_process_kill(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, publish_proc, and run_task.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

schedule_next_task()

static void schedule_next_task ( void  )

static

Decide what the next task is (working or scanning) and schedule it.

Definition at line 618 of file gnunet-auto-share.c.

{
  struct GNUNET_TIME_Relative delay;
 
  if (GNUNET_YES == do_shutdown)
    return;
  GNUNET_assert (NULL == run_task);
  if (NULL == work_head)
  {
    /* delay by at most 4h, at least 1s, and otherwise in between depending
       on how long it took to scan */
    delay = GNUNET_TIME_absolute_get_duration (start_time);
    delay = GNUNET_TIME_relative_saturating_multiply (delay, 100);
    delay = GNUNET_TIME_relative_min (delay, MAX_DELAY);
    delay = GNUNET_TIME_relative_max (delay, MIN_DELAY);
    run_task = GNUNET_SCHEDULER_add_delayed (delay, &scan, NULL);
  }
  else
  {
    run_task = GNUNET_SCHEDULER_add_now (&work, NULL);
  }
}

References delay, do_shutdown, GNUNET_assert, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_max(), GNUNET_TIME_relative_min(), GNUNET_TIME_relative_saturating_multiply(), GNUNET_YES, MAX_DELAY, MIN_DELAY, run_task, scan(), start_time, work(), and work_head.

Referenced by maint_child_death(), and scan().

Here is the call graph for this function:

Here is the caller graph for this function:

maint_child_death()

static void maint_child_death ( void *  cls )

static

Task triggered whenever we receive a SIGCHLD (child process died).

Parameters

cls	the struct WorkItem we were working on

Definition at line 346 of file gnunet-auto-share.c.

{
  struct WorkItem *wi = cls;
  struct GNUNET_HashCode key;
  enum GNUNET_OS_ProcessStatusType type;
  unsigned long code;
  int ret;
  char c;
  const struct GNUNET_DISK_FileHandle *pr;
  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
  run_task = NULL;
  pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
  tc = GNUNET_SCHEDULER_get_task_context ();
  if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
  {
    /* shutdown scheduled us, someone else will kill child,
       we should just try again */
    run_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                               pr,
                                               &maint_child_death,
                                               wi);
    return;
  }
  /* consume the signal */
  GNUNET_break (0 < GNUNET_DISK_file_read (pr, &c, sizeof(c)));
 
  ret = GNUNET_OS_process_status (publish_proc, &type, &code);
  GNUNET_assert (GNUNET_SYSERR != ret);
  if (GNUNET_NO == ret)
  {
    /* process still running? Then where did the SIGCHLD come from?
       Well, let's declare it spurious (kernel bug?) and keep rolling.
     */
    GNUNET_break (0);
    run_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                               pr,
                                               &maint_child_death,
                                               wi);
    return;
  }
  GNUNET_assert (GNUNET_OK == ret);
 
  GNUNET_OS_process_destroy (publish_proc);
  publish_proc = NULL;
 
  if (GNUNET_YES == do_shutdown)
  {
    GNUNET_free (wi->filename);
    GNUNET_free (wi);
    return;
  }
  if ((GNUNET_OS_PROCESS_EXITED == type) && (0 == code))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("Publication of `%s' done\n"),
                wi->filename);
    GNUNET_CRYPTO_hash (wi->filename, strlen (wi->filename), &key);
    GNUNET_break (GNUNET_OK ==
                  GNUNET_CONTAINER_multihashmap_put (
                    work_finished,
                    &key,
                    wi,
                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  }
  else
  {
    GNUNET_CONTAINER_DLL_insert_tail (work_head, work_tail, wi);
  }
  save_state ();
  schedule_next_task ();
}

References _, do_shutdown, WorkItem::filename, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_DISK_file_read(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_pipe_handle(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_OS_process_destroy(), GNUNET_OS_PROCESS_EXITED, GNUNET_OS_process_status(), GNUNET_SCHEDULER_add_read_file(), GNUNET_SCHEDULER_get_task_context(), GNUNET_SCHEDULER_REASON_READ_READY, GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, key, publish_proc, GNUNET_SCHEDULER_TaskContext::reason, ret, run_task, save_state(), schedule_next_task(), sigpipe, tc, type, work_finished, work_head, and work_tail.

Referenced by work().

Here is the call graph for this function:

Here is the caller graph for this function:

sighandler_child_death()

static void sighandler_child_death ( void  )

static

Signal handler called for SIGCHLD.

Triggers the respective handler by writing to the trigger pipe.

Definition at line 425 of file gnunet-auto-share.c.

{
  static char c;
  int old_errno = errno; /* back-up errno */
 
  GNUNET_break (
    1 ==
    GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle (sigpipe,
                                                     GNUNET_DISK_PIPE_END_WRITE),
                            &c,
                            sizeof(c)));
  errno = old_errno; /* restore errno */
}

References GNUNET_break, GNUNET_DISK_file_write(), GNUNET_DISK_PIPE_END_WRITE, GNUNET_DISK_pipe_handle(), and sigpipe.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

work()

static void work ( void *  cls )

static

Function called to process work items.

Parameters

cls	closure, NULL

Definition at line 446 of file gnunet-auto-share.c.

{
  static char *argv[14];
  static char anon_level[20];
  static char content_prio[20];
  static char repl_level[20];
  struct WorkItem *wi;
  const struct GNUNET_DISK_FileHandle *pr;
  int argc;
 
  run_task = NULL;
  wi = work_head;
  GNUNET_CONTAINER_DLL_remove (work_head, work_tail, wi);
  argc = 0;
  argv[argc++] = "gnunet-publish";
  if (verbose)
    argv[argc++] = "-V";
  if (disable_extractor)
    argv[argc++] = "-D";
  if (do_disable_creation_time)
    argv[argc++] = "-d";
  argv[argc++] = "-c";
  argv[argc++] = cfg_filename;
  GNUNET_snprintf (anon_level, sizeof(anon_level), "%u", anonymity_level);
  argv[argc++] = "-a";
  argv[argc++] = anon_level;
  GNUNET_snprintf (content_prio, sizeof(content_prio), "%u", content_priority);
  argv[argc++] = "-p";
  argv[argc++] = content_prio;
  GNUNET_snprintf (repl_level, sizeof(repl_level), "%u", replication_level);
  argv[argc++] = "-r";
  argv[argc++] = repl_level;
  argv[argc++] = wi->filename;
  argv[argc] = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Publishing `%s'\n"), wi->filename);
  GNUNET_assert (NULL == publish_proc);
  publish_proc = GNUNET_OS_start_process_vap (GNUNET_OS_USE_PIPE_CONTROL,
                                              NULL,
                                              NULL,
                                              NULL,
                                              "gnunet-publish",
                                              argv);
  if (NULL == publish_proc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to run `%s'\n"),
                "gnunet-publish");
    GNUNET_CONTAINER_DLL_insert (work_head, work_tail, wi);
    run_task =
      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &work, NULL);
    return;
  }
  pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
  run_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                             pr,
                                             &maint_child_death,
                                             wi);
}

References _, anonymity_level, cfg_filename, content_priority, disable_extractor, do_disable_creation_time, WorkItem::filename, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_pipe_handle(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_OS_start_process_vap(), GNUNET_OS_USE_PIPE_CONTROL, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_read_file(), GNUNET_snprintf(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_MINUTES, maint_child_death(), publish_proc, replication_level, run_task, sigpipe, verbose, work_head, and work_tail.

Referenced by dns_post_request_handler(), and schedule_next_task().

Here is the call graph for this function:

Here is the caller graph for this function:

determine_id()

static int determine_id ( void *  cls, const char *  filename  )

static

Recursively scan the given file/directory structure to determine a unique ID that represents the current state of the hierarchy.

Parameters

cls	where to store the unique ID we are computing
filename	file to scan

Returns

GNUNET_OK (always)

Definition at line 515 of file gnunet-auto-share.c.

{
  struct GNUNET_HashCode *id = cls;
  struct stat sbuf;
  struct GNUNET_HashCode fx[2];
  struct GNUNET_HashCode ft;
 
  if (0 != stat (filename, &sbuf))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
    return GNUNET_OK;
  }
  GNUNET_CRYPTO_hash (filename, strlen (filename), &fx[0]);
  if (! S_ISDIR (sbuf.st_mode))
  {
    uint64_t fattr[2];
 
    fattr[0] = GNUNET_htonll (sbuf.st_size);
    fattr[0] = GNUNET_htonll (sbuf.st_mtime);
 
    GNUNET_CRYPTO_hash (fattr, sizeof(fattr), &fx[1]);
  }
  else
  {
    memset (&fx[1], 1, sizeof(struct GNUNET_HashCode));
    GNUNET_DISK_directory_scan (filename, &determine_id, &fx[1]);
  }
  /* use hash here to make hierarchical structure distinct from
     all files on the same level */
  GNUNET_CRYPTO_hash (fx, sizeof(fx), &ft);
  /* use XOR here so that order of the files in the directory
     does not matter! */
  GNUNET_CRYPTO_hash_xor (&ft, id, id);
  return GNUNET_OK;
}

References filename, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hash_xor(), GNUNET_DISK_directory_scan(), GNUNET_ERROR_TYPE_WARNING, GNUNET_htonll(), GNUNET_log_strerror_file, and GNUNET_OK.

Referenced by add_file().

Here is the call graph for this function:

Here is the caller graph for this function:

add_file()

static int add_file ( void *  cls, const char *  filename  )

static

Function called with a filename (or directory name) to publish (if it has changed since the last time we published it).

This function is called for the top-level files only.

Parameters

cls	closure, NULL
filename	complete filename (absolute path)

Returns

GNUNET_OK to continue to iterate, GNUNET_SYSERR during shutdown

Definition at line 562 of file gnunet-auto-share.c.

{
  struct WorkItem *wi;
  struct GNUNET_HashCode key;
  struct GNUNET_HashCode id;
 
  if (GNUNET_YES == do_shutdown)
    return GNUNET_SYSERR;
  if ((NULL != strstr (filename, "/.auto-share")) ||
      (NULL != strstr (filename, "\\.auto-share")))
    return GNUNET_OK; /* skip internal file */
  GNUNET_CRYPTO_hash (filename, strlen (filename), &key);
  wi = GNUNET_CONTAINER_multihashmap_get (work_finished, &key);
  memset (&id, 0, sizeof(struct GNUNET_HashCode));
  determine_id (&id, filename);
  if (NULL != wi)
  {
    if (0 == memcmp (&id, &wi->id, sizeof(struct GNUNET_HashCode)))
      return GNUNET_OK;   /* skip: we did this one already */
    /* contents changed, need to re-do the directory... */
    GNUNET_assert (
      GNUNET_YES ==
      GNUNET_CONTAINER_multihashmap_remove (work_finished, &key, wi));
  }
  else
  {
    wi = GNUNET_new (struct WorkItem);
    wi->filename = GNUNET_strdup (filename);
  }
  wi->id = id;
  GNUNET_CONTAINER_DLL_insert (work_head, work_tail, wi);
  if (GNUNET_YES == do_shutdown)
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

References determine_id(), do_shutdown, WorkItem::filename, filename, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CRYPTO_hash(), GNUNET_new, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, GNUNET_YES, id, WorkItem::id, key, work_finished, work_head, and work_tail.

Referenced by scan().

Here is the call graph for this function:

Here is the caller graph for this function:

scan()

static void scan ( void *  cls )

static

Periodically run task to update our view of the directory to share.

Parameters

cls

NULL

Definition at line 605 of file gnunet-auto-share.c.

{
  run_task = NULL;
  start_time = GNUNET_TIME_absolute_get ();
  (void) GNUNET_DISK_directory_scan (dir_name, &add_file, NULL);
  schedule_next_task ();
}

References add_file(), dir_name, GNUNET_DISK_directory_scan(), GNUNET_TIME_absolute_get(), run_task, schedule_next_task(), and start_time.

Referenced by run(), and schedule_next_task().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  c  )

static

Main function that will be run by the scheduler.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
c	configuration

Definition at line 651 of file gnunet-auto-share.c.

{
  /* check arguments */
  if ((NULL == args[0]) || (NULL != args[1]) ||
      (GNUNET_YES != GNUNET_DISK_directory_test (args[0], GNUNET_YES)))
  {
    printf (_ (
              "You must specify one and only one directory name for automatic publication.\n"));
    ret = -1;
    return;
  }
  cfg_filename = GNUNET_strdup (cfgfile);
  cfg = c;
  dir_name = args[0];
  work_finished = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
  load_state ();
  run_task = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
                                                 &scan,
                                                 NULL);
  GNUNET_SCHEDULER_add_shutdown (&do_stop_task, NULL);
}

References _, consensus-simulation::args, cfg, cfg_filename, dir_name, do_stop_task(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_DISK_directory_test(), GNUNET_NO, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_add_with_priority(), GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_strdup, GNUNET_YES, load_state(), ret, run_task, scan(), and work_finished.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

free_item()

static int free_item ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Free memory associated with the work item from the work_finished map.

Parameters

cls	NULL (unused)
key	key of the item in the map (unused)
value	the struct WorkItem to free

Returns

GNUNET_OK to continue to iterate

Definition at line 686 of file gnunet-auto-share.c.

{
  struct WorkItem *wi = value;
 
  GNUNET_free (wi->filename);
  GNUNET_free (wi);
  return GNUNET_OK;
}

References WorkItem::filename, GNUNET_free, GNUNET_OK, and value.

Referenced by main().

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

The main function to automatically publish content to GNUnet.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns

0 ok, 1 on error

Definition at line 704 of file gnunet-auto-share.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_uint ('a',
                               "anonymity",
                               "LEVEL",
                               gettext_noop (
                                 "set the desired LEVEL of sender-anonymity"),
                               &anonymity_level),
 
    GNUNET_GETOPT_option_flag (
      'd',
      "disable-creation-time",
      gettext_noop (
        "disable adding the creation time to the metadata of the uploaded file"),
      &do_disable_creation_time),
 
    GNUNET_GETOPT_option_flag (
      'D',
      "disable-extractor",
      gettext_noop ("do not use libextractor to add keywords or metadata"),
      &disable_extractor),
 
    GNUNET_GETOPT_option_uint ('p',
                               "priority",
                               "PRIORITY",
                               gettext_noop (
                                 "specify the priority of the content"),
                               &content_priority),
 
    GNUNET_GETOPT_option_uint ('r',
                               "replication",
                               "LEVEL",
                               gettext_noop (
                                 "set the desired replication LEVEL"),
                               &replication_level),
 
    GNUNET_GETOPT_option_verbose (&verbose),
 
    GNUNET_GETOPT_OPTION_END
  };
  struct WorkItem *wi;
  int ok;
  struct GNUNET_SIGNAL_Context *shc_chld;
 
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
  sigpipe = GNUNET_DISK_pipe (GNUNET_DISK_PF_NONE);
  GNUNET_assert (NULL != sigpipe);
  shc_chld =
    GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD, &sighandler_child_death);
  ok =
    (GNUNET_OK ==
     GNUNET_PROGRAM_run (
       argc,
       argv,
       "gnunet-auto-share [OPTIONS] FILENAME",
       gettext_noop ("Automatically publish files from a directory on GNUnet"),
       options,
       &run,
       NULL))
    ? ret
    : 1;
  if (NULL != work_finished)
  {
    (void) GNUNET_CONTAINER_multihashmap_iterate (work_finished,
                                                  &free_item,
                                                  NULL);
    GNUNET_CONTAINER_multihashmap_destroy (work_finished);
  }
  while (NULL != (wi = work_head))
  {
    GNUNET_CONTAINER_DLL_remove (work_head, work_tail, wi);
    GNUNET_free (wi->filename);
    GNUNET_free (wi);
  }
  GNUNET_SIGNAL_handler_uninstall (shc_chld);
  shc_chld = NULL;
  GNUNET_DISK_pipe_close (sigpipe);
  sigpipe = NULL;
  GNUNET_free (cfg_filename);
  cfg_filename = NULL;
  GNUNET_free_nz ((void *) argv);
  return ok;
}

References anonymity_level, cfg_filename, content_priority, disable_extractor, do_disable_creation_time, WorkItem::filename, free_item(), gettext_noop, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_DISK_PF_NONE, GNUNET_DISK_pipe(), GNUNET_DISK_pipe_close(), GNUNET_free, GNUNET_free_nz, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_uint(), GNUNET_GETOPT_option_verbose(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_SIGCHLD, GNUNET_SIGNAL_handler_install(), GNUNET_SIGNAL_handler_uninstall(), GNUNET_STRINGS_get_utf8_args(), ok, options, replication_level, ret, run(), shc_chld, sighandler_child_death(), sigpipe, verbose, work_finished, work_head, and work_tail.

Here is the call graph for this function:

Variable Documentation

ret

int ret

static

Global return value from 'main'.

Definition at line 69 of file gnunet-auto-share.c.

Referenced by get_state_file(), main(), maint_child_death(), and run().

verbose

unsigned int verbose

static

Are we running 'verbosely'?

Definition at line 74 of file gnunet-auto-share.c.

Referenced by main(), and work().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Configuration to use.

Definition at line 79 of file gnunet-auto-share.c.

Referenced by run().

cfg_filename

char* cfg_filename

static

Name of the configuration file.

Definition at line 84 of file gnunet-auto-share.c.

Referenced by GNUNET_DISK_purge_cfg_dir(), GNUNET_SERVICE_run_(), GNUNET_TESTBED_barrier_wait(), GNUNET_TESTBED_test_run(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), main(), run(), and work().

disable_extractor

int disable_extractor

static

Disable extractor option to use for publishing.

Definition at line 89 of file gnunet-auto-share.c.

Referenced by GNUNET_FS_directory_scan_start(), main(), and work().

do_disable_creation_time

int do_disable_creation_time

static

Disable creation time option to use for publishing.

Definition at line 94 of file gnunet-auto-share.c.

Referenced by main(), and work().

run_task

struct GNUNET_SCHEDULER_Task* run_task

static

Handle for the main task that does scanning and working.

Definition at line 99 of file gnunet-auto-share.c.

Referenced by do_stop_task(), maint_child_death(), run(), scan(), schedule_next_task(), and work().

anonymity_level

unsigned int anonymity_level = 1

static

Anonymity level option to use for publishing.

Definition at line 104 of file gnunet-auto-share.c.

Referenced by GSF_pending_request_create_(), main(), and work().

content_priority

unsigned int content_priority = 365

static

Content priority option to use for publishing.

Definition at line 109 of file gnunet-auto-share.c.

Referenced by main(), and work().

replication_level

unsigned int replication_level = 1

static

Replication level option to use for publishing.

Definition at line 114 of file gnunet-auto-share.c.

Referenced by handle_dht_local_put(), main(), and work().

dir_name

const char* dir_name

static

Top-level directory we monitor to auto-publish.

Definition at line 119 of file gnunet-auto-share.c.

Referenced by get_state_file(), GNUNET_DISK_directory_scan(), run(), and scan().

work_head

struct WorkItem* work_head

static

Head of linked list of files still to publish.

Definition at line 124 of file gnunet-auto-share.c.

Referenced by add_file(), main(), maint_child_death(), schedule_next_task(), and work().

work_tail

struct WorkItem* work_tail

static

Tail of linked list of files still to publish.

Definition at line 129 of file gnunet-auto-share.c.

Referenced by add_file(), main(), maint_child_death(), and work().

work_finished

struct GNUNET_CONTAINER_MultiHashMap* work_finished

static

Map from the hash of the filename (!) to a struct WorkItem that was finished.

Definition at line 135 of file gnunet-auto-share.c.

Referenced by add_file(), load_state(), main(), maint_child_death(), run(), and save_state().

do_shutdown

int do_shutdown

static

Set to GNUNET_YES if we are shutting down.

Definition at line 140 of file gnunet-auto-share.c.

Referenced by add_file(), do_stop_task(), maint_child_death(), and schedule_next_task().

start_time

struct GNUNET_TIME_Absolute start_time

static

Start time of the current round; used to determine how long one iteration takes (which influences how fast we schedule the next one).

Definition at line 140 of file gnunet-auto-share.c.

Referenced by do_directory_scan(), run(), scan(), schedule_next_task(), and shutdown_task().

sigpipe

struct GNUNET_DISK_PipeHandle* sigpipe

static

Pipe used to communicate 'gnunet-publish' completion (SIGCHLD) via signal.

Definition at line 152 of file gnunet-auto-share.c.

Referenced by main(), maint_child_death(), sighandler_child_death(), and work().

publish_proc

struct GNUNET_OS_Process* publish_proc

static

Handle to the 'gnunet-publish' process that we executed.

Definition at line 157 of file gnunet-auto-share.c.

Referenced by do_stop_task(), maint_child_death(), and work().