gnunet-publish.c File Reference

publishing files on GNUnet More...

#include "platform.h"
#include "gnunet_fs_service.h"
#include "gnunet_identity_service.h"

Include dependency graph for gnunet-publish.c:

Go to the source code of this file.

Functions
static void	do_stop_task (void *cls)
	We are finished with the publishing operation, clean up all FS state. More...
static void *	progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
	Called by FS client to give information about the progress of an operation. More...
static int	meta_printer (void *cls, const char *plugin_name, enum EXTRACTOR_MetaType type, enum EXTRACTOR_MetaFormat format, const char *data_mime_type, const char *data, size_t data_size)
	Print metadata entries (except binary metadata and the filename). More...
static int	keyword_printer (void *cls, const char *keyword, int is_mandatory)
	Iterator printing keywords. More...
static int	publish_inspector (void *cls, struct GNUNET_FS_FileInformation *fi, uint64_t length, struct GNUNET_FS_MetaData *m, struct GNUNET_FS_Uri **uri, struct GNUNET_FS_BlockOptions *bo, int *do_index, void **client_info)
	Function called on all entries before the publication. More...
static void	uri_sks_continuation (void *cls, const struct GNUNET_FS_Uri *sks_uri, const char *emsg)
	Function called upon completion of the publishing of the UBLOCK for the SKS URI. More...
static void	uri_ksk_continuation (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
	Function called upon completion of the publishing of the UBLOCK for the KSK URI. More...
static struct GNUNET_FS_FileInformation *	get_file_information (struct GNUNET_FS_ShareTreeItem *item)
	Iterate over the results from the directory scan and extract the desired information for the publishing operation. More...
static void	directory_trim_complete (struct GNUNET_FS_ShareTreeItem *directory_scan_result)
	We've finished scanning the directory and optimized the meta data. More...
static void	directory_scan_cb (void *cls, const char *filename, int is_directory, enum GNUNET_FS_DirScannerProgressUpdateReason reason)
	Function called by the directory scanner as we build the tree that we will need to publish later. More...
static void	identity_continuation (const char *args0)
	Continuation proceeding with initialization after identity subsystem has been initialized. More...
static void	identity_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
	Function called by identity service with known pseudonyms. 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...
int	main (int argc, char *const *argv)
	The main function to publish content to GNUnet. More...

Variables
static int	ret
	Global return value from main(). More...
static unsigned int	verbose
	Command line option 'verbose' set. More...
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Handle to our configuration. More...
static struct GNUNET_FS_Handle *	ctx
	Handle for interaction with file-sharing service. More...
static struct GNUNET_FS_PublishContext *	pc
	Handle to FS-publishing operation. More...
static struct GNUNET_FS_MetaData *	meta
	Meta-data provided via command-line option. More...
static struct GNUNET_FS_Uri *	topKeywords
	Keywords provided via command-line option. More...
static struct GNUNET_FS_BlockOptions	bo = { { 0LL }, 1, 365, 1 }
	Options we set for published blocks. More...
static char *	uri_string
	Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer to an existing URI). More...
static struct GNUNET_FS_Uri *	uri
	Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer to an existing URI); parsed version of 'uri_string'. More...
static char *	next_id
	Command-line option for namespace publishing: identifier for updates to this publication. More...
static char *	this_id
	Command-line option for namespace publishing: identifier for this publication. More...
static char *	pseudonym
	Command-line option identifying the pseudonym to use for the publication. More...
static int	do_insert
	Command-line option for 'inserting'. More...
static int	disable_extractor
	Command-line option to disable meta data extraction. More...
static int	do_simulate
	Command-line option to merely simulate publishing operation. More...
static int	extract_only
	Command-line option to only perform meta data extraction, but not publish. More...
static int	enable_creation_time
	Command-line option to disable adding creation time. More...
static struct GNUNET_FS_DirScanner *	ds
	Handle to the directory scanner (for recursive insertions). More...
static struct GNUNET_IDENTITY_Handle *	identity
	Which namespace do we publish to? NULL if we do not publish to a namespace. More...

Detailed Description

publishing files on GNUnet

Author

Christian Grothoff

Krista Bennett

James Blackwell

Igor Wronsky

Definition in file gnunet-publish.c.

Function Documentation

do_stop_task()

static void do_stop_task ( void *  cls )

static

We are finished with the publishing operation, clean up all FS state.

Parameters

cls

NULL

Definition at line 152 of file gnunet-publish.c.

{
  struct GNUNET_FS_PublishContext *p;
 
  if (NULL != ds)
  {
    GNUNET_FS_directory_scan_abort (ds);
    ds = NULL;
  }
  if (NULL != identity)
  {
    GNUNET_IDENTITY_disconnect (identity);
    identity = NULL;
  }
  if (NULL != pc)
  {
    p = pc;
    pc = NULL;
    GNUNET_FS_publish_stop (p);
  }
  if (NULL != ctx)
  {
    GNUNET_FS_stop (ctx);
    ctx = NULL;
  }
  if (NULL != meta)
  {
    GNUNET_FS_meta_data_destroy (meta);
    meta = NULL;
  }
  if (NULL != uri)
  {
    GNUNET_FS_uri_destroy (uri);
    uri = NULL;
  }
}

References ctx, ds, GNUNET_FS_directory_scan_abort(), GNUNET_FS_meta_data_destroy(), GNUNET_FS_publish_stop(), GNUNET_FS_stop(), GNUNET_FS_uri_destroy(), GNUNET_IDENTITY_disconnect(), identity, meta, p, pc, and uri.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

progress_cb()

static void* progress_cb ( void *  cls, const struct GNUNET_FS_ProgressInfo *  info  )

static

Called by FS client to give information about the progress of an operation.

Parameters

cls	closure
info	details about the event, specifying the event type and various bits about the event

Returns

client-context (for the next progress call for this operation; should be set to NULL for SUSPEND and STOPPED events). The value returned will be passed to future callbacks in the respective field in the GNUNET_FS_ProgressInfo struct.

Definition at line 204 of file gnunet-publish.c.

{
  const char *s;
  char *suri;
 
  switch (info->status)
  {
  case GNUNET_FS_STATUS_PUBLISH_START:
    break;
 
  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
    if (verbose)
    {
      s = GNUNET_STRINGS_relative_time_to_string (info->value.publish.eta,
                                                  GNUNET_YES);
      fprintf (stdout,
               _ ("Publishing `%s' at %llu/%llu (%s remaining)\n"),
               info->value.publish.filename,
               (unsigned long long) info->value.publish.completed,
               (unsigned long long) info->value.publish.size,
               s);
    }
    break;
 
  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
    if (verbose)
    {
      s = GNUNET_STRINGS_relative_time_to_string (info->value.publish.specifics
                                                  .progress_directory.eta,
                                                  GNUNET_YES);
      fprintf (stdout,
               _ ("Publishing `%s' at %llu/%llu (%s remaining)\n"),
               info->value.publish.filename,
               (unsigned long long)
               info->value.publish.specifics.progress_directory.completed,
               (unsigned long long)
               info->value.publish.specifics.progress_directory.total,
               s);
    }
    break;
 
  case GNUNET_FS_STATUS_PUBLISH_ERROR:
    fprintf (stderr,
             _ ("Error publishing: %s.\n"),
             info->value.publish.specifics.error.message);
    ret = 1;
    GNUNET_SCHEDULER_shutdown ();
    break;
 
  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
    fprintf (stdout,
             _ ("Publishing `%s' done.\n"),
             info->value.publish.filename);
    suri =
      GNUNET_FS_uri_to_string (info->value.publish.specifics.completed.chk_uri);
    fprintf (stdout, _ ("URI is `%s'.\n"), suri);
    GNUNET_free (suri);
    if (NULL != info->value.publish.specifics.completed.sks_uri)
    {
      suri = GNUNET_FS_uri_to_string (
        info->value.publish.specifics.completed.sks_uri);
      fprintf (stdout, _ ("Namespace URI is `%s'.\n"), suri);
      GNUNET_free (suri);
    }
    if (NULL == info->value.publish.pctx)
    {
      ret = 0;
      GNUNET_SCHEDULER_shutdown ();
    }
    break;
 
  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
    GNUNET_break (NULL == pc);
    return NULL;
 
  case GNUNET_FS_STATUS_UNINDEX_START:
    fprintf (stderr, "%s", _ ("Starting cleanup after abort\n"));
    return NULL;
 
  case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
    return NULL;
 
  case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
    fprintf (stderr, "%s", _ ("Cleanup after abort completed.\n"));
    GNUNET_FS_unindex_stop (info->value.unindex.uc);
    return NULL;
 
  case GNUNET_FS_STATUS_UNINDEX_ERROR:
    fprintf (stderr, "%s", _ ("Cleanup after abort failed.\n"));
    GNUNET_FS_unindex_stop (info->value.unindex.uc);
    return NULL;
 
  case GNUNET_FS_STATUS_UNINDEX_STOPPED:
    return NULL;
 
  default:
    fprintf (stderr, _ ("Unexpected status: %d\n"), info->status);
    return NULL;
  }
  return ""; /* non-null */
}

References _, GNUNET_break, GNUNET_free, GNUNET_FS_STATUS_PUBLISH_COMPLETED, GNUNET_FS_STATUS_PUBLISH_ERROR, GNUNET_FS_STATUS_PUBLISH_PROGRESS, GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY, GNUNET_FS_STATUS_PUBLISH_START, GNUNET_FS_STATUS_PUBLISH_STOPPED, GNUNET_FS_STATUS_UNINDEX_COMPLETED, GNUNET_FS_STATUS_UNINDEX_ERROR, GNUNET_FS_STATUS_UNINDEX_PROGRESS, GNUNET_FS_STATUS_UNINDEX_START, GNUNET_FS_STATUS_UNINDEX_STOPPED, GNUNET_FS_unindex_stop(), GNUNET_FS_uri_to_string(), GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, info, pc, ret, and verbose.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

meta_printer()

static int meta_printer ( void *  cls, const char *  plugin_name, enum EXTRACTOR_MetaType  type, enum EXTRACTOR_MetaFormat  format, const char *  data_mime_type, const char *  data, size_t  data_size  )

static

Print metadata entries (except binary metadata and the filename).

Parameters

cls	closure
plugin_name	name of the plugin that generated the meta data
type	type of the meta data
format	format of data
data_mime_type	mime type of data
data	value of the meta data
data_size	number of bytes in data

Returns

always 0

Definition at line 321 of file gnunet-publish.c.

{
  if ((EXTRACTOR_METAFORMAT_UTF8 != format) &&
      (EXTRACTOR_METAFORMAT_C_STRING != format))
    return 0;
  if (EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME == type)
    return 0;
#if HAVE_LIBEXTRACTOR
  fprintf (stdout, "\t%s - %s\n", EXTRACTOR_metatype_to_string (type), data);
#else
  fprintf (stdout, "\t%d - %s\n", type, data);
#endif
  return 0;
}

References data, EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME, and type.

Referenced by publish_inspector().

Here is the caller graph for this function:

keyword_printer()

static int keyword_printer ( void *  cls, const char *  keyword, int  is_mandatory  )

static

Iterator printing keywords.

Parameters

cls	closure
keyword	the keyword
is_mandatory	is the keyword mandatory (in a search)

Returns

GNUNET_OK to continue to iterate, GNUNET_SYSERR to abort

Definition at line 352 of file gnunet-publish.c.

{
  fprintf (stdout, "\t%s\n", keyword);
  return GNUNET_OK;
}

References GNUNET_OK.

Referenced by publish_inspector().

Here is the caller graph for this function:

publish_inspector()

static int publish_inspector ( void *  cls, struct GNUNET_FS_FileInformation *  fi, uint64_t  length, struct GNUNET_FS_MetaData *  m, struct GNUNET_FS_Uri **  uri, struct GNUNET_FS_BlockOptions *  bo, int *  do_index, void **  client_info  )

static

Function called on all entries before the publication.

This is where we perform modifications to the default based on command-line options.

Parameters

cls	closure
fi	the entry in the publish-structure
length	length of the file or directory
m	metadata for the file or directory (can be modified)
uri	pointer to the keywords that will be used for this entry (can be modified)
bo	block options
do_index	should we index?
client_info	pointer to client context set upon creation (can be modified)

Returns

GNUNET_OK to continue, GNUNET_NO to remove this entry from the directory, GNUNET_SYSERR to abort the iteration

Definition at line 377 of file gnunet-publish.c.

{
  char *fn;
  char *fs;
  struct GNUNET_FS_Uri *new_uri;
 
  if (cls == fi)
    return GNUNET_OK;
  if ((disable_extractor) && (NULL != *uri))
  {
    GNUNET_FS_uri_destroy (*uri);
    *uri = NULL;
  }
  if (NULL != topKeywords)
  {
    if (NULL != *uri)
    {
      new_uri = GNUNET_FS_uri_ksk_merge (topKeywords, *uri);
      GNUNET_FS_uri_destroy (*uri);
      *uri = new_uri;
      GNUNET_FS_uri_destroy (topKeywords);
    }
    else
    {
      *uri = topKeywords;
    }
    topKeywords = NULL;
  }
  if (NULL != meta)
  {
    GNUNET_FS_meta_data_merge (m, meta);
    GNUNET_FS_meta_data_destroy (meta);
    meta = NULL;
  }
  if (enable_creation_time)
    GNUNET_FS_meta_data_add_publication_date (m);
  if (extract_only)
  {
    fn = GNUNET_FS_meta_data_get_by_type (
      m,
      EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
    fs = GNUNET_STRINGS_byte_size_fancy (length);
    fprintf (stdout, _ ("Meta data for file `%s' (%s)\n"), fn, fs);
    GNUNET_FS_meta_data_iterate (m, &meta_printer, NULL);
    fprintf (stdout, _ ("Keywords for file `%s' (%s)\n"), fn, fs);
    GNUNET_free (fn);
    GNUNET_free (fs);
    if (NULL != *uri)
      GNUNET_FS_uri_ksk_get_keywords (*uri, &keyword_printer, NULL);
    fprintf (stdout, "%s", "\n");
  }
  if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (m))
    GNUNET_FS_file_information_inspect (fi, &publish_inspector, fi);
  return GNUNET_OK;
}

References _, disable_extractor, enable_creation_time, extract_only, EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME, fs, GNUNET_free, GNUNET_FS_file_information_inspect(), GNUNET_FS_meta_data_add_publication_date(), GNUNET_FS_meta_data_destroy(), GNUNET_FS_meta_data_get_by_type(), GNUNET_FS_meta_data_iterate(), GNUNET_FS_meta_data_merge(), GNUNET_FS_meta_data_test_for_directory(), GNUNET_FS_uri_destroy(), GNUNET_FS_uri_ksk_get_keywords(), GNUNET_FS_uri_ksk_merge(), GNUNET_OK, GNUNET_STRINGS_byte_size_fancy(), GNUNET_YES, keyword_printer(), m, meta, meta_printer(), topKeywords, and uri.

Referenced by directory_trim_complete().

Here is the call graph for this function:

Here is the caller graph for this function:

uri_sks_continuation()

static void uri_sks_continuation ( void *  cls, const struct GNUNET_FS_Uri *  sks_uri, const char *  emsg  )

static

Function called upon completion of the publishing of the UBLOCK for the SKS URI.

As this is the last step, stop our interaction with FS (clean up).

Parameters

cls	NULL (closure)
sks_uri	URI for the block that was published
emsg	error message, NULL on success

Definition at line 451 of file gnunet-publish.c.

{
  if (NULL != emsg)
  {
    fprintf (stderr, "%s\n", emsg);
    ret = 1;
  }
  GNUNET_SCHEDULER_shutdown ();
}

References GNUNET_SCHEDULER_shutdown(), and ret.

Referenced by uri_ksk_continuation().

Here is the call graph for this function:

Here is the caller graph for this function:

uri_ksk_continuation()

static void uri_ksk_continuation ( void *  cls, const struct GNUNET_FS_Uri *  ksk_uri, const char *  emsg  )

static

Function called upon completion of the publishing of the UBLOCK for the KSK URI.

Continue with publishing the SKS URI (if applicable) or clean up.

Parameters

cls	NULL (closure)
ksk_uri	URI for the block that was published
emsg	error message, NULL on success

Definition at line 474 of file gnunet-publish.c.

{
  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
  const struct GNUNET_IDENTITY_PrivateKey *pk;
 
  if (NULL != emsg)
  {
    fprintf (stderr, "%s\n", emsg);
    ret = 1;
  }
  if (NULL == namespace)
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  pk = GNUNET_IDENTITY_ego_get_private_key (namespace);
  if (GNUNET_IDENTITY_TYPE_ECDSA != ntohl (pk->type))
    return;
  priv = &pk->ecdsa_key;
  GNUNET_FS_publish_sks (ctx,
                         priv,
                         this_id,
                         next_id,
                         meta,
                         uri,
                         &bo,
                         GNUNET_FS_PUBLISH_OPTION_NONE,
                         &uri_sks_continuation,
                         NULL);
}

References bo, ctx, GNUNET_IDENTITY_PrivateKey::ecdsa_key, GNUNET_FS_PUBLISH_OPTION_NONE, GNUNET_FS_publish_sks(), GNUNET_IDENTITY_ego_get_private_key(), GNUNET_IDENTITY_TYPE_ECDSA, GNUNET_SCHEDULER_shutdown(), meta, next_id, pk, ret, this_id, GNUNET_IDENTITY_PrivateKey::type, uri, and uri_sks_continuation().

Referenced by identity_continuation().

Here is the call graph for this function:

Here is the caller graph for this function:

get_file_information()

static struct GNUNET_FS_FileInformation* get_file_information ( struct GNUNET_FS_ShareTreeItem *  item )

static

Iterate over the results from the directory scan and extract the desired information for the publishing operation.

Parameters

item	root with the data from the directory scan

Returns

handle with the information for the publishing operation

Definition at line 516 of file gnunet-publish.c.

{
  struct GNUNET_FS_FileInformation *fi;
  struct GNUNET_FS_FileInformation *fic;
  struct GNUNET_FS_ShareTreeItem *child;
 
  if (GNUNET_YES == item->is_directory)
  {
    if (NULL == item->meta)
      item->meta = GNUNET_FS_meta_data_create ();
    GNUNET_FS_meta_data_delete (item->meta,
                                EXTRACTOR_METATYPE_MIMETYPE,
                                NULL,
                                0);
    GNUNET_FS_meta_data_make_directory (item->meta);
    if (NULL == item->ksk_uri)
    {
      const char *mime = GNUNET_FS_DIRECTORY_MIME;
      item->ksk_uri = GNUNET_FS_uri_ksk_create_from_args (1, &mime);
    }
    else
      GNUNET_FS_uri_ksk_add_keyword (item->ksk_uri,
                                     GNUNET_FS_DIRECTORY_MIME,
                                     GNUNET_NO);
    fi = GNUNET_FS_file_information_create_empty_directory (ctx,
                                                            NULL,
                                                            item->ksk_uri,
                                                            item->meta,
                                                            &bo,
                                                            item->filename);
    for (child = item->children_head; child; child = child->next)
    {
      fic = get_file_information (child);
      GNUNET_break (GNUNET_OK == GNUNET_FS_file_information_add (fi, fic));
    }
  }
  else
  {
    fi = GNUNET_FS_file_information_create_from_file (ctx,
                                                      NULL,
                                                      item->filename,
                                                      item->ksk_uri,
                                                      item->meta,
                                                      ! do_insert,
                                                      &bo);
  }
  return fi;
}

References bo, child, GNUNET_FS_ShareTreeItem::children_head, ctx, do_insert, GNUNET_FS_ShareTreeItem::filename, GNUNET_break, GNUNET_FS_DIRECTORY_MIME, GNUNET_FS_file_information_add(), GNUNET_FS_file_information_create_empty_directory(), GNUNET_FS_file_information_create_from_file(), GNUNET_FS_meta_data_create(), GNUNET_FS_meta_data_delete(), GNUNET_FS_meta_data_make_directory(), GNUNET_FS_uri_ksk_add_keyword(), GNUNET_FS_uri_ksk_create_from_args(), GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_FS_ShareTreeItem::is_directory, GNUNET_FS_ShareTreeItem::ksk_uri, and GNUNET_FS_ShareTreeItem::meta.

Referenced by directory_trim_complete().

Here is the call graph for this function:

Here is the caller graph for this function:

directory_trim_complete()

static void directory_trim_complete ( struct GNUNET_FS_ShareTreeItem *  directory_scan_result )

static

We've finished scanning the directory and optimized the meta data.

Begin the publication process.

Parameters

directory_scan_result

result from the directory scan, freed in this function

Definition at line 573 of file gnunet-publish.c.

{
  struct GNUNET_FS_FileInformation *fi;
  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
  const struct GNUNET_IDENTITY_PrivateKey *pk;
 
  fi = get_file_information (directory_scan_result);
  GNUNET_FS_share_tree_free (directory_scan_result);
  if (NULL == fi)
  {
    fprintf (stderr, "%s", _ ("Could not publish\n"));
    ret = 1;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_FS_file_information_inspect (fi, &publish_inspector, NULL);
  if (extract_only)
  {
    GNUNET_FS_file_information_destroy (fi, NULL, NULL);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  priv = NULL;
  if (NULL != namespace)
  {
    pk = GNUNET_IDENTITY_ego_get_private_key (namespace);
    GNUNET_assert (GNUNET_IDENTITY_TYPE_ECDSA == ntohl (pk->type));
    priv = &pk->ecdsa_key;
  }
  pc = GNUNET_FS_publish_start (ctx,
                                fi,
                                priv,
                                this_id,
                                next_id,
                                (do_simulate)
                                ? GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY
                                : GNUNET_FS_PUBLISH_OPTION_NONE);
  if (NULL == pc)
  {
    fprintf (stderr, "%s", _ ("Could not start publishing.\n"));
    ret = 1;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}

References _, ctx, do_simulate, GNUNET_IDENTITY_PrivateKey::ecdsa_key, extract_only, get_file_information(), GNUNET_assert, GNUNET_FS_file_information_destroy(), GNUNET_FS_file_information_inspect(), GNUNET_FS_PUBLISH_OPTION_NONE, GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY, GNUNET_FS_publish_start(), GNUNET_FS_share_tree_free(), GNUNET_IDENTITY_ego_get_private_key(), GNUNET_IDENTITY_TYPE_ECDSA, GNUNET_SCHEDULER_shutdown(), next_id, pc, pk, publish_inspector(), ret, this_id, and GNUNET_IDENTITY_PrivateKey::type.

Referenced by directory_scan_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

directory_scan_cb()

static void directory_scan_cb ( void *  cls, const char *  filename, int  is_directory, enum GNUNET_FS_DirScannerProgressUpdateReason  reason  )

static

Function called by the directory scanner as we build the tree that we will need to publish later.

Parameters

cls	closure
filename	which file we are making progress on
is_directory	GNUNET_YES if this is a directory, GNUNET_NO if this is a file GNUNET_SYSERR if it is neither (or unknown)
reason	kind of progress we are making

Definition at line 632 of file gnunet-publish.c.

{
  struct GNUNET_FS_ShareTreeItem *directory_scan_result;
 
  switch (reason)
  {
  case GNUNET_FS_DIRSCANNER_FILE_START:
    if (verbose > 1)
    {
      if (is_directory == GNUNET_YES)
        fprintf (stdout, _ ("Scanning directory `%s'.\n"), filename);
      else
        fprintf (stdout, _ ("Scanning file `%s'.\n"), filename);
    }
    break;
 
  case GNUNET_FS_DIRSCANNER_FILE_IGNORED:
    fprintf (stderr,
             _ ("There was trouble processing file `%s', skipping it.\n"),
             filename);
    break;
 
  case GNUNET_FS_DIRSCANNER_ALL_COUNTED:
    if (verbose)
      fprintf (stdout, "%s", _ ("Preprocessing complete.\n"));
    break;
 
  case GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED:
    if (verbose > 2)
      fprintf (stdout,
               _ ("Extracting meta data from file `%s' complete.\n"),
               filename);
    break;
 
  case GNUNET_FS_DIRSCANNER_FINISHED:
    if (verbose > 1)
      fprintf (stdout, "%s", _ ("Meta data extraction has finished.\n"));
    directory_scan_result = GNUNET_FS_directory_scan_get_result (ds);
    ds = NULL;
    GNUNET_FS_share_tree_trim (directory_scan_result);
    directory_trim_complete (directory_scan_result);
    break;
 
  case GNUNET_FS_DIRSCANNER_INTERNAL_ERROR:
    fprintf (stdout, "%s", _ ("Error scanning directory.\n"));
    ret = 1;
    GNUNET_SCHEDULER_shutdown ();
    break;
 
  default:
    GNUNET_assert (0);
    break;
  }
  fflush (stdout);
}

References _, directory_trim_complete(), ds, filename, GNUNET_assert, GNUNET_FS_directory_scan_get_result(), GNUNET_FS_DIRSCANNER_ALL_COUNTED, GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED, GNUNET_FS_DIRSCANNER_FILE_IGNORED, GNUNET_FS_DIRSCANNER_FILE_START, GNUNET_FS_DIRSCANNER_FINISHED, GNUNET_FS_DIRSCANNER_INTERNAL_ERROR, GNUNET_FS_share_tree_trim(), GNUNET_SCHEDULER_shutdown(), GNUNET_YES, GNUNET_FS_ShareTreeItem::is_directory, ret, and verbose.

Referenced by identity_continuation().

Here is the call graph for this function:

Here is the caller graph for this function:

identity_continuation()

static void identity_continuation ( const char *  args0 )

static

Continuation proceeding with initialization after identity subsystem has been initialized.

Parameters

args0

filename to publish

Definition at line 699 of file gnunet-publish.c.

{
  char *ex;
  char *emsg;
 
  if ((NULL != pseudonym) && (NULL == namespace))
  {
    fprintf (stderr, _ ("Selected pseudonym `%s' unknown\n"), pseudonym);
    ret = 1;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (NULL != uri_string)
  {
    emsg = NULL;
    if (NULL == (uri = GNUNET_FS_uri_parse (uri_string, &emsg)))
    {
      fprintf (stderr, _ ("Failed to parse URI: %s\n"), emsg);
      GNUNET_free (emsg);
      ret = 1;
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    GNUNET_FS_publish_ksk (ctx,
                           topKeywords,
                           meta,
                           uri,
                           &bo,
                           GNUNET_FS_PUBLISH_OPTION_NONE,
                           &uri_ksk_continuation,
                           NULL);
    return;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg, "FS", "EXTRACTORS", &ex))
    ex = NULL;
  if (0 != access (args0, R_OK))
  {
    fprintf (stderr,
             _ ("Failed to access `%s': %s\n"),
             args0,
             strerror (errno));
    GNUNET_free (ex);
    return;
  }
  ds = GNUNET_FS_directory_scan_start (args0,
                                       disable_extractor,
                                       ex,
                                       &directory_scan_cb,
                                       NULL);
  if (NULL == ds)
  {
    fprintf (
      stderr,
      "%s",
      _ (
        "Failed to start meta directory scanner.  Is gnunet-helper-publish-fs installed?\n"));
    GNUNET_free (ex);
    return;
  }
  GNUNET_free (ex);
}

References _, bo, cfg, ctx, directory_scan_cb(), disable_extractor, ds, GNUNET_CONFIGURATION_get_value_string(), GNUNET_free, GNUNET_FS_directory_scan_start(), GNUNET_FS_publish_ksk(), GNUNET_FS_PUBLISH_OPTION_NONE, GNUNET_FS_uri_parse(), GNUNET_OK, GNUNET_SCHEDULER_shutdown(), meta, pseudonym, ret, topKeywords, uri, uri_ksk_continuation(), and uri_string.

Referenced by identity_cb(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

identity_cb()

static void identity_cb ( void *  cls, struct GNUNET_IDENTITY_Ego *  ego, void **  ctx, const char *  name  )

static

Function called by identity service with known pseudonyms.

Parameters

cls	closure with 'const char *' of filename to publish
ego	ego handle
ctx	context for application to store data for this ego (during the lifetime of this process, initially NULL)
name	name assigned by the user for this ego, NULL if the user just deleted the ego and it must thus no longer be used

Definition at line 775 of file gnunet-publish.c.

{
  const char *args0 = cls;
 
  if (NULL == ego)
  {
    identity_continuation (args0);
    return;
  }
  if (NULL == name)
    return;
  if (0 == strcmp (name, pseudonym))
    namespace = ego;
}

References identity_continuation(), name, and pseudonym.

Referenced by run().

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 803 of file gnunet-publish.c.

{
  /* check arguments */
  if ((NULL != uri_string) && (extract_only))
  {
    printf (_ ("Cannot extract metadata from a URI!\n"));
    ret = -1;
    return;
  }
  if (((NULL == uri_string) || (extract_only)) &&
      ((NULL == args[0]) || (NULL != args[1])))
  {
    printf (_ ("You must specify one and only one filename for insertion.\n"));
    ret = -1;
    return;
  }
  if ((NULL != uri_string) && (NULL != args[0]))
  {
    printf (_ ("You must NOT specify an URI and a filename.\n"));
    ret = -1;
    return;
  }
  if (NULL != pseudonym)
  {
    if (NULL == this_id)
    {
      fprintf (stderr,
               _ ("Option `%s' is required when using option `%s'.\n"),
               "-t",
               "-P");
      ret = -1;
      return;
    }
  }
  else
  {   /* ordinary insertion checks */
    if (NULL != next_id)
    {
      fprintf (stderr,
               _ ("Option `%s' makes no sense without option `%s'.\n"),
               "-N",
               "-P");
      ret = -1;
      return;
    }
    if (NULL != this_id)
    {
      fprintf (stderr,
               _ ("Option `%s' makes no sense without option `%s'.\n"),
               "-t",
               "-P");
      ret = -1;
      return;
    }
  }
  cfg = c;
  ctx = GNUNET_FS_start (cfg,
                         "gnunet-publish",
                         &progress_cb,
                         NULL,
                         GNUNET_FS_FLAGS_NONE,
                         GNUNET_FS_OPTIONS_END);
  if (NULL == ctx)
  {
    fprintf (stderr, _ ("Could not initialize `%s' subsystem.\n"), "FS");
    ret = 1;
    return;
  }
  GNUNET_SCHEDULER_add_shutdown (&do_stop_task, NULL);
  if (NULL != pseudonym)
    identity = GNUNET_IDENTITY_connect (cfg, &identity_cb, args[0]);
  else
    identity_continuation (args[0]);
}

References _, consensus-simulation::args, cfg, ctx, do_stop_task(), extract_only, GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END, GNUNET_FS_start(), GNUNET_IDENTITY_connect(), GNUNET_SCHEDULER_add_shutdown(), identity, identity_cb(), identity_continuation(), next_id, progress_cb(), pseudonym, ret, this_id, and uri_string.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

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

The main function to 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 890 of file gnunet-publish.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_uint ('a',
                               "anonymity",
                               "LEVEL",
                               gettext_noop (
                                 "set the desired LEVEL of sender-anonymity"),
                               &bo.anonymity_level),
    GNUNET_GETOPT_option_flag (
      'D',
      "disable-extractor",
      gettext_noop ("do not use libextractor to add keywords or metadata"),
      &disable_extractor),
    GNUNET_GETOPT_option_flag ('E',
                               "enable-creation-time",
                               gettext_noop (
                                 "enable adding the creation time to the "
                                 "metadata of the uploaded file"),
                               &enable_creation_time),
    GNUNET_GETOPT_option_flag ('e',
                               "extract",
                               gettext_noop (
                                 "print list of extracted keywords that would "
                                 "be used, but do not perform upload"),
                               &extract_only),
    GNUNET_FS_GETOPT_KEYWORDS (
      'k',
      "key",
      "KEYWORD",
      gettext_noop (
        "add an additional keyword for the top-level "
        "file or directory (this option can be specified multiple times)"),
      &topKeywords),
    GNUNET_FS_GETOPT_METADATA (
      'm',
      "meta",
      "TYPE:VALUE",
      gettext_noop ("set the meta-data for the given TYPE to the given VALUE"),
      &meta),
    GNUNET_GETOPT_option_flag (
      'n',
      "noindex",
      gettext_noop ("do not index, perform full insertion (stores "
                    "entire file in encrypted form in GNUnet database)"),
      &do_insert),
    GNUNET_GETOPT_option_string (
      'N',
      "next",
      "ID",
      gettext_noop ("specify ID of an updated version to be "
                    "published in the future (for namespace insertions only)"),
      &next_id),
    GNUNET_GETOPT_option_uint ('p',
                               "priority",
                               "PRIORITY",
                               gettext_noop (
                                 "specify the priority of the content"),
                               &bo.content_priority),
    GNUNET_GETOPT_option_string ('P',
                                 "pseudonym",
                                 "NAME",
                                 gettext_noop (
                                   "publish the files under the pseudonym "
                                   "NAME (place file into namespace)"),
                                 &pseudonym),
    GNUNET_GETOPT_option_uint ('r',
                               "replication",
                               "LEVEL",
                               gettext_noop (
                                 "set the desired replication LEVEL"),
                               &bo.replication_level),
    GNUNET_GETOPT_option_flag ('s',
                               "simulate-only",
                               gettext_noop (
                                 "only simulate the process but do not do "
                                 "any actual publishing (useful to compute URIs)"),
                               &do_simulate),
    GNUNET_GETOPT_option_string ('t',
                                 "this",
                                 "ID",
                                 gettext_noop (
                                   "set the ID of this version of the publication "
                                   "(for namespace insertions only)"),
                                 &this_id),
    GNUNET_GETOPT_option_string (
      'u',
      "uri",
      "URI",
      gettext_noop (
        "URI to be published (can be used instead of passing a "
        "file to add keywords to the file with the respective URI)"),
      &uri_string),
 
    GNUNET_GETOPT_option_verbose (&verbose),
 
    GNUNET_GETOPT_OPTION_END };
 
  bo.expiration_time =
    GNUNET_TIME_year_to_time (GNUNET_TIME_get_current_year () + 2);
 
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
  ret =
    (GNUNET_OK ==
     GNUNET_PROGRAM_run (argc,
                         argv,
                         "gnunet-publish [OPTIONS] FILENAME",
                         gettext_noop ("Publish a file or directory on GNUnet"),
                         options,
                         &run,
                         NULL))
    ? ret
    : 1;
  GNUNET_free_nz ((void *) argv);
  return ret;
}

References GNUNET_FS_BlockOptions::anonymity_level, bo, GNUNET_FS_BlockOptions::content_priority, disable_extractor, do_insert, do_simulate, enable_creation_time, GNUNET_FS_BlockOptions::expiration_time, extract_only, gettext_noop, GNUNET_free_nz, GNUNET_FS_GETOPT_KEYWORDS(), GNUNET_FS_GETOPT_METADATA(), GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_GETOPT_option_uint(), GNUNET_GETOPT_option_verbose(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), GNUNET_TIME_get_current_year(), GNUNET_TIME_year_to_time(), meta, next_id, options, pseudonym, GNUNET_FS_BlockOptions::replication_level, ret, run(), this_id, topKeywords, uri_string, and verbose.

Here is the call graph for this function:

Variable Documentation

ret

int ret

static

Global return value from main().

Definition at line 36 of file gnunet-publish.c.

Referenced by directory_scan_cb(), directory_trim_complete(), identity_continuation(), main(), progress_cb(), run(), uri_ksk_continuation(), and uri_sks_continuation().

verbose

unsigned int verbose

static

Command line option 'verbose' set.

Definition at line 41 of file gnunet-publish.c.

Referenced by directory_scan_cb(), main(), and progress_cb().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Handle to our configuration.

Definition at line 46 of file gnunet-publish.c.

Referenced by identity_continuation(), and run().

ctx

struct GNUNET_FS_Handle* ctx

static

Handle for interaction with file-sharing service.

Definition at line 51 of file gnunet-publish.c.

Referenced by directory_trim_complete(), do_stop_task(), get_file_information(), identity_continuation(), run(), and uri_ksk_continuation().

pc

struct GNUNET_FS_PublishContext* pc

static

Handle to FS-publishing operation.

Definition at line 56 of file gnunet-publish.c.

Referenced by block_proc(), block_reader(), count_address(), create_loc_uri(), deserialize_publish_file(), directory_trim_complete(), do_stop_task(), ds_put_cont(), dump_pc(), encode_cont(), finish_release_reserve(), finish_reserve(), fip_signal_resume(), fip_signal_start(), fip_signal_stop(), fip_signal_suspend(), free_preference(), GAS_preference_done(), GDS_ROUTING_process(), GNUNET_FS_namespace_list_updateable(), GNUNET_FS_publish_main_(), GNUNET_FS_publish_make_status_(), GNUNET_FS_publish_signal_suspend_(), GNUNET_FS_publish_stop(), GNUNET_FS_publish_sync_(), GNUNET_REVOCATION_pow_start(), GNUNET_REVOCATION_pow_stop(), handle_client_monitor_peers(), handle_index_start_failed(), handle_index_start_ok(), handle_signature_response(), hash_for_index_cb(), index_mq_error_handler(), loc_mq_error_handler(), lookup_records(), peerinfo_list_iteration(), print_address(), print_peer_info(), process_resolved_address(), process_update_node(), progress_cb(), progress_proc(), publish_cleanup(), publish_content(), publish_kblocks(), publish_kblocks_cont(), publish_sblock(), publish_sblocks_cont(), send_peer_information(), set_mutation_done(), shutdown_task(), signal_publish_completion(), signal_publish_error(), and suspend_operation().

meta

struct GNUNET_FS_MetaData* meta

static

Meta-data provided via command-line option.

Definition at line 61 of file gnunet-publish.c.

Referenced by create_download_context(), do_stop_task(), extract_files(), fip_signal_resume(), fip_signal_stop(), fip_signal_suspend(), GNUNET_FS_directory_builder_add(), GNUNET_FS_download_start(), GNUNET_FS_file_information_create_empty_directory(), GNUNET_FS_file_information_create_from_data(), GNUNET_FS_file_information_create_from_file(), GNUNET_FS_file_information_create_from_reader(), GNUNET_FS_GETOPT_METADATA(), GNUNET_FS_probe(), GNUNET_FS_publish_ksk(), GNUNET_FS_publish_sks(), GNUNET_FS_publish_ublock_(), GNUNET_FS_read_meta_data(), identity_continuation(), main(), print_entry(), process_kblock(), process_ksk_result(), process_sblock(), process_sks_result(), publish_inspector(), trigger_recursive_download(), and uri_ksk_continuation().

topKeywords

struct GNUNET_FS_Uri* topKeywords

static

Keywords provided via command-line option.

Definition at line 66 of file gnunet-publish.c.

Referenced by identity_continuation(), main(), and publish_inspector().

bo

struct GNUNET_FS_BlockOptions bo = { { 0LL }, 1, 365, 1 }

static

Options we set for published blocks.

Definition at line 66 of file gnunet-publish.c.

Referenced by get_file_information(), GNUNET_FS_file_information_create_empty_directory(), GNUNET_FS_file_information_create_from_data(), GNUNET_FS_file_information_create_from_file(), GNUNET_FS_file_information_create_from_reader(), GNUNET_FS_publish_ksk(), GNUNET_FS_publish_sks(), GNUNET_FS_publish_ublock_(), identity_continuation(), main(), make_file(), publish_fs_connect_complete_cb(), and uri_ksk_continuation().

uri_string

char* uri_string

static

Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer to an existing URI).

Definition at line 77 of file gnunet-publish.c.

Referenced by identity_continuation(), main(), and run().

uri

struct GNUNET_FS_Uri* uri

static

Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer to an existing URI); parsed version of 'uri_string'.

Definition at line 84 of file gnunet-publish.c.

Referenced by check_advertisement(), create_download_context(), do_stop_task(), fip_signal_start(), gather_uri_data(), GDS_try_connect(), GNUNET_FS_directory_builder_add(), GNUNET_FS_directory_list_contents(), GNUNET_FS_download_start(), GNUNET_FS_GETOPT_KEYWORDS(), GNUNET_FS_probe(), GNUNET_FS_publish_ksk(), GNUNET_FS_publish_sks(), GNUNET_FS_publish_ublock_(), GNUNET_FS_search_start(), GNUNET_FS_TEST_download(), GNUNET_FS_uri_chk_get_file_size(), GNUNET_FS_uri_destroy(), GNUNET_FS_uri_dup(), GNUNET_FS_uri_ksk_add_keyword(), GNUNET_FS_uri_ksk_create(), GNUNET_FS_uri_ksk_create_from_args(), GNUNET_FS_uri_ksk_get_keyword_count(), GNUNET_FS_uri_ksk_get_keywords(), GNUNET_FS_uri_ksk_remove_keyword(), GNUNET_FS_uri_ksk_to_string_fancy(), GNUNET_FS_uri_loc_create(), GNUNET_FS_uri_loc_get_expiration(), GNUNET_FS_uri_loc_get_uri(), GNUNET_FS_uri_parse(), GNUNET_FS_uri_sks_get_content_id(), GNUNET_FS_uri_sks_get_namespace(), GNUNET_FS_uri_test_chk(), GNUNET_FS_uri_test_ksk(), GNUNET_FS_uri_test_loc(), GNUNET_FS_uri_test_sks(), GNUNET_FS_uri_to_key(), GNUNET_HELLO_builder_from_url(), GNUNET_HELLO_parse_uri(), handle_advertisement(), handle_uri(), handler_advertisement(), identity_continuation(), linked_list_contains(), load_hostlist_file(), print_entry(), print_my_uri(), print_search_result(), process_kblock(), process_ksk_result(), process_sblock(), process_sks_result(), progress_cb(), publish_inspector(), publish_sblocks_cont(), run(), search_start(), test_result_present(), trigger_recursive_download(), uri_chk_to_string(), uri_ksk_continuation(), uri_ksk_to_string(), uri_loc_parse(), uri_loc_to_string(), uri_sks_to_string(), and wait_child().

next_id

char* next_id

static

Command-line option for namespace publishing: identifier for updates to this publication.

Definition at line 90 of file gnunet-publish.c.

Referenced by directory_trim_complete(), GNUNET_FS_namespace_list_updateable(), load_member_session_next(), main(), run(), and uri_ksk_continuation().

this_id

char* this_id

static

Command-line option for namespace publishing: identifier for this publication.

Definition at line 96 of file gnunet-publish.c.

Referenced by directory_trim_complete(), main(), run(), and uri_ksk_continuation().

pseudonym

char* pseudonym

static

Command-line option identifying the pseudonym to use for the publication.

Definition at line 101 of file gnunet-publish.c.

Referenced by GNUNET_FS_uri_sks_get_namespace(), identity_cb(), identity_continuation(), main(), and run().

do_insert

int do_insert

static

Command-line option for 'inserting'.

Definition at line 106 of file gnunet-publish.c.

Referenced by get_file_information(), and main().

disable_extractor

int disable_extractor

static

Command-line option to disable meta data extraction.

Definition at line 111 of file gnunet-publish.c.

Referenced by identity_continuation(), main(), and publish_inspector().

do_simulate

int do_simulate

static

Command-line option to merely simulate publishing operation.

Definition at line 116 of file gnunet-publish.c.

Referenced by directory_trim_complete(), and main().

extract_only

int extract_only

static

Command-line option to only perform meta data extraction, but not publish.

Definition at line 121 of file gnunet-publish.c.

Referenced by directory_trim_complete(), main(), publish_inspector(), and run().

enable_creation_time

int enable_creation_time

static

Command-line option to disable adding creation time.

Definition at line 126 of file gnunet-publish.c.

Referenced by main(), and publish_inspector().

ds

struct GNUNET_FS_DirScanner* ds

static

Handle to the directory scanner (for recursive insertions).

Definition at line 131 of file gnunet-publish.c.

Referenced by decrypt_conclude(), decrypt_session_destroy(), directory_scan_cb(), do_dns_read(), do_stop_task(), finish_scan(), get_decrypt_peer_info(), GNUNET_DNSSTUB_add_dns_ip(), GNUNET_DNSSTUB_add_dns_sa(), GNUNET_DNSSTUB_stop(), GNUNET_FS_directory_scan_abort(), GNUNET_FS_directory_scan_get_result(), GNUNET_FS_directory_scan_start(), handle_client_decrypt(), helper_died_cb(), identity_continuation(), insert_decrypt_element(), process_helper_msgs(), run(), and transmit_query().

identity

struct GNUNET_IDENTITY_Handle* identity

static

Which namespace do we publish to? NULL if we do not publish to a namespace.

Handle to identity service.

Definition at line 142 of file gnunet-publish.c.

Referenced by add_attribute_cont(), add_credential_cont(), add_host_to_known_hosts(), attr_iter_cb(), callback_room_disconnect(), check_credential_iteration_start(), consume_cont(), consume_result_cb(), consume_ticket(), core_init(), delete_attribute_cont(), delete_credential_cont(), derive_iv(), derive_pong_iv(), do_stop_task(), GNUNET_RECLAIM_get_attributes_start(), GNUNET_RECLAIM_get_credentials_start(), GNUNET_RECLAIM_ticket_consume(), GNUNET_RECLAIM_ticket_iteration_start(), GNUNET_RECLAIM_ticket_revoke(), handle_attribute_delete_message(), handle_attribute_result(), handle_attribute_store_message(), handle_cadet_ring_message(), handle_consume_ticket_message(), handle_consume_ticket_result(), handle_credential_delete_message(), handle_credential_iteration_start(), handle_credential_result(), handle_credential_store_message(), handle_issue_ticket_message(), handle_iteration_start(), handle_revoke_ticket_message(), handle_ticket_iteration_start(), hosts_directory_scan_callback(), list_attribute_cont(), list_credential_cont(), list_tickets_cont(), login_cont(), process_attrs(), RECLAIM_TICKETS_issue(), RECLAIM_TICKETS_iteration_start(), RECLAIM_TICKETS_revoke(), and run().