GNUnet  0.20.0
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_FileInformationget_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_Handlecfg
 Handle to our configuration. More...
 
static struct GNUNET_FS_Handlectx
 Handle for interaction with file-sharing service. More...
 
static struct GNUNET_FS_PublishContextpc
 Handle to FS-publishing operation. More...
 
static struct GNUNET_FS_MetaDatameta
 Meta-data provided via command-line option. More...
 
static struct GNUNET_FS_UritopKeywords
 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_Uriuri
 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_DirScannerds
 Handle to the directory scanner (for recursive insertions). More...
 
static struct GNUNET_IDENTITY_Handleidentity
 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
clsNULL

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

153 {
154  struct GNUNET_FS_PublishContext *p;
155 
156  if (NULL != ds)
157  {
159  ds = NULL;
160  }
161  if (NULL != identity)
162  {
164  identity = NULL;
165  }
166  if (NULL != pc)
167  {
168  p = pc;
169  pc = NULL;
171  }
172  if (NULL != ctx)
173  {
175  ctx = NULL;
176  }
177  if (NULL != meta)
178  {
180  meta = NULL;
181  }
182  if (NULL != uri)
183  {
185  uri = NULL;
186  }
187 }
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
static struct GNUNET_FS_DirScanner * ds
Handle to the directory scanner (for recursive insertions).
static struct GNUNET_FS_MetaData * meta
Meta-data provided via command-line option.
static struct GNUNET_FS_Handle * ctx
Handle for interaction with file-sharing service.
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:677
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3310
void GNUNET_FS_publish_stop(struct GNUNET_FS_PublishContext *pc)
Stop an upload.
Definition: fs_publish.c:1571
void GNUNET_FS_directory_scan_abort(struct GNUNET_FS_DirScanner *ds)
Abort the scan.
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:757
void GNUNET_FS_meta_data_destroy(struct GNUNET_FS_MetaData *md)
Free meta data.
Definition: meta_data.c:171
Handle for controlling a publication process.
Definition: fs_api.h:1180

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
clsclosure
infodetails 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.

205 {
206  const char *s;
207  char *suri;
208 
209  switch (info->status)
210  {
212  break;
213 
215  if (verbose)
216  {
217  s = GNUNET_STRINGS_relative_time_to_string (info->value.publish.eta,
218  GNUNET_YES);
219  fprintf (stdout,
220  _ ("Publishing `%s' at %llu/%llu (%s remaining)\n"),
221  info->value.publish.filename,
222  (unsigned long long) info->value.publish.completed,
223  (unsigned long long) info->value.publish.size,
224  s);
225  }
226  break;
227 
229  if (verbose)
230  {
231  s = GNUNET_STRINGS_relative_time_to_string (info->value.publish.specifics
232  .progress_directory.eta,
233  GNUNET_YES);
234  fprintf (stdout,
235  _ ("Publishing `%s' at %llu/%llu (%s remaining)\n"),
236  info->value.publish.filename,
237  (unsigned long long)
238  info->value.publish.specifics.progress_directory.completed,
239  (unsigned long long)
240  info->value.publish.specifics.progress_directory.total,
241  s);
242  }
243  break;
244 
246  fprintf (stderr,
247  _ ("Error publishing: %s.\n"),
248  info->value.publish.specifics.error.message);
249  ret = 1;
251  break;
252 
254  fprintf (stdout,
255  _ ("Publishing `%s' done.\n"),
256  info->value.publish.filename);
257  suri =
258  GNUNET_FS_uri_to_string (info->value.publish.specifics.completed.chk_uri);
259  fprintf (stdout, _ ("URI is `%s'.\n"), suri);
260  GNUNET_free (suri);
261  if (NULL != info->value.publish.specifics.completed.sks_uri)
262  {
263  suri = GNUNET_FS_uri_to_string (
264  info->value.publish.specifics.completed.sks_uri);
265  fprintf (stdout, _ ("Namespace URI is `%s'.\n"), suri);
266  GNUNET_free (suri);
267  }
268  if (NULL == info->value.publish.pctx)
269  {
270  ret = 0;
272  }
273  break;
274 
276  GNUNET_break (NULL == pc);
277  return NULL;
278 
280  fprintf (stderr, "%s", _ ("Starting cleanup after abort\n"));
281  return NULL;
282 
284  return NULL;
285 
287  fprintf (stderr, "%s", _ ("Cleanup after abort completed.\n"));
288  GNUNET_FS_unindex_stop (info->value.unindex.uc);
289  return NULL;
290 
292  fprintf (stderr, "%s", _ ("Cleanup after abort failed.\n"));
293  GNUNET_FS_unindex_stop (info->value.unindex.uc);
294  return NULL;
295 
297  return NULL;
298 
299  default:
300  fprintf (stderr, _ ("Unexpected status: %d\n"), info->status);
301  return NULL;
302  }
303  return ""; /* non-null */
304 }
static unsigned int verbose
Command line option 'verbose' set.
static int ret
Global return value from main().
#define info
void GNUNET_FS_unindex_stop(struct GNUNET_FS_UnindexContext *uc)
Clean up after completion of an unindex operation.
Definition: fs_unindex.c:838
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:2017
@ GNUNET_FS_STATUS_UNINDEX_PROGRESS
Notification that we made progress unindexing a file.
@ GNUNET_FS_STATUS_UNINDEX_START
Notification that we started to unindex a file.
@ GNUNET_FS_STATUS_PUBLISH_STOPPED
Notification that we have stopped the process of uploading a file structure; no further events will b...
@ GNUNET_FS_STATUS_PUBLISH_ERROR
Notification that an error was encountered sharing a file structure.
@ GNUNET_FS_STATUS_UNINDEX_STOPPED
Notification that the unindexing of this file was stopped (final event for this action).
@ GNUNET_FS_STATUS_PUBLISH_PROGRESS
Notification that we are making progress sharing a file structure.
@ GNUNET_FS_STATUS_UNINDEX_COMPLETED
Notification that the unindexing of this file was completed.
@ GNUNET_FS_STATUS_UNINDEX_ERROR
Notification that we encountered an error unindexing a file.
@ GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY
Notification that we are making progress sharing a directory.
@ GNUNET_FS_STATUS_PUBLISH_START
Notification that we have started to publish a file structure.
@ GNUNET_FS_STATUS_PUBLISH_COMPLETED
Notification that we completed sharing a file structure.
@ GNUNET_YES
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:562
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:569
#define _(String)
GNU gettext support macro.
Definition: platform.h:178

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
clsclosure
plugin_namename of the plugin that generated the meta data
typetype of the meta data
formatformat of data
data_mime_typemime type of data
datavalue of the meta data
data_sizenumber of bytes in data
Returns
always 0

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

328 {
329  if ((EXTRACTOR_METAFORMAT_UTF8 != format) &&
330  (EXTRACTOR_METAFORMAT_C_STRING != format))
331  return 0;
333  return 0;
334 #if HAVE_LIBEXTRACTOR
335  fprintf (stdout, "\t%s - %s\n", EXTRACTOR_metatype_to_string (type), data);
336 #else
337  fprintf (stdout, "\t%d - %s\n", type, data);
338 #endif
339  return 0;
340 }
uint32_t data
The data value.
#define EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

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
clsclosure
keywordthe keyword
is_mandatoryis 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.

353 {
354  fprintf (stdout, "\t%s\n", keyword);
355  return GNUNET_OK;
356 }
@ 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
clsclosure
fithe entry in the publish-structure
lengthlength of the file or directory
mmetadata for the file or directory (can be modified)
uripointer to the keywords that will be used for this entry (can be modified)
boblock options
do_indexshould we index?
client_infopointer 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.

385 {
386  char *fn;
387  char *fs;
388  struct GNUNET_FS_Uri *new_uri;
389 
390  if (cls == fi)
391  return GNUNET_OK;
392  if ((disable_extractor) && (NULL != *uri))
393  {
395  *uri = NULL;
396  }
397  if (NULL != topKeywords)
398  {
399  if (NULL != *uri)
400  {
403  *uri = new_uri;
405  }
406  else
407  {
408  *uri = topKeywords;
409  }
410  topKeywords = NULL;
411  }
412  if (NULL != meta)
413  {
416  meta = NULL;
417  }
420  if (extract_only)
421  {
423  m,
426  fprintf (stdout, _ ("Meta data for file `%s' (%s)\n"), fn, fs);
428  fprintf (stdout, _ ("Keywords for file `%s' (%s)\n"), fn, fs);
429  GNUNET_free (fn);
430  GNUNET_free (fs);
431  if (NULL != *uri)
433  fprintf (stdout, "%s", "\n");
434  }
437  return GNUNET_OK;
438 }
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
static struct GNUNET_FS_Handle * fs
Handle to FS service.
Definition: gnunet-fs.c:37
static int disable_extractor
Command-line option to disable meta data extraction.
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.
static int enable_creation_time
Command-line option to disable adding creation time.
static int keyword_printer(void *cls, const char *keyword, int is_mandatory)
Iterator printing keywords.
static int extract_only
Command-line option to only perform meta data extraction, but not publish.
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).
static struct GNUNET_FS_Uri * topKeywords
Keywords provided via command-line option.
void GNUNET_FS_file_information_inspect(struct GNUNET_FS_FileInformation *dir, GNUNET_FS_FileInformationProcessor proc, void *proc_cls)
Inspect a file or directory in a publish-structure.
int GNUNET_FS_uri_ksk_get_keywords(const struct GNUNET_FS_Uri *uri, GNUNET_FS_KeywordIterator iterator, void *iterator_cls)
Iterate over all keywords in this keyword URI.
Definition: fs_uri.c:720
struct GNUNET_FS_Uri * GNUNET_FS_uri_ksk_merge(const struct GNUNET_FS_Uri *u1, const struct GNUNET_FS_Uri *u2)
Merge the sets of keywords from two KSK URIs.
Definition: fs_uri.c:931
int GNUNET_FS_meta_data_test_for_directory(const struct GNUNET_FS_MetaData *md)
Does the meta-data claim that this is a directory? Checks if the mime-type is that of a GNUnet direct...
Definition: fs_directory.c:55
int GNUNET_FS_meta_data_iterate(const struct GNUNET_FS_MetaData *md, EXTRACTOR_MetaDataProcessor iter, void *iter_cls)
Iterate over MD entries.
Definition: meta_data.c:423
void GNUNET_FS_meta_data_add_publication_date(struct GNUNET_FS_MetaData *md)
Add the current time as the publication date to the meta-data.
Definition: meta_data.c:396
void GNUNET_FS_meta_data_merge(struct GNUNET_FS_MetaData *md, const struct GNUNET_FS_MetaData *in)
Extend metadata.
Definition: meta_data.c:361
char * GNUNET_FS_meta_data_get_by_type(const struct GNUNET_FS_MetaData *md, enum EXTRACTOR_MetaType type)
Get the first MD entry of the given type.
Definition: meta_data.c:443
char * GNUNET_STRINGS_byte_size_fancy(unsigned long long size)
Convert a given filesize into a fancy human-readable format.
Definition: strings.c:106
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:167

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
clsNULL (closure)
sks_uriURI for the block that was published
emsgerror message, NULL on success

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

454 {
455  if (NULL != emsg)
456  {
457  fprintf (stderr, "%s\n", emsg);
458  ret = 1;
459  }
461 }

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
clsNULL (closure)
ksk_uriURI for the block that was published
emsgerror message, NULL on success

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

477 {
478  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
479  const struct GNUNET_IDENTITY_PrivateKey *pk;
480 
481  if (NULL != emsg)
482  {
483  fprintf (stderr, "%s\n", emsg);
484  ret = 1;
485  }
486  if (NULL == namespace)
487  {
489  return;
490  }
492  if (GNUNET_IDENTITY_TYPE_ECDSA != ntohl (pk->type))
493  return;
494  priv = &pk->ecdsa_key;
496  priv,
497  this_id,
498  next_id,
499  meta,
500  uri,
501  &bo,
504  NULL);
505 }
struct GNUNET_IDENTITY_PrivateKey pk
Private key from command line option, or NULL.
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.
static struct GNUNET_FS_BlockOptions bo
Options we set for published blocks.
static char * next_id
Command-line option for namespace publishing: identifier for updates to this publication.
static char * this_id
Command-line option for namespace publishing: identifier for this publication.
struct GNUNET_FS_PublishSksContext * GNUNET_FS_publish_sks(struct GNUNET_FS_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const char *identifier, const char *update, const struct GNUNET_FS_MetaData *meta, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_BlockOptions *bo, enum GNUNET_FS_PublishOptions options, GNUNET_FS_PublishContinuation cont, void *cont_cls)
Publish an SBlock on GNUnet.
Definition: fs_namespace.c:428
@ GNUNET_FS_PUBLISH_OPTION_NONE
No options (use defaults for everything).
const struct GNUNET_IDENTITY_PrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:560
@ GNUNET_IDENTITY_TYPE_ECDSA
The identity type.
Private ECC key encoded for transmission.
A private key for an identity as per LSD0001.
uint32_t type
Type of public key.
struct GNUNET_CRYPTO_EcdsaPrivateKey ecdsa_key
An ECDSA identity key.

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
itemroot 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.

517 {
518  struct GNUNET_FS_FileInformation *fi;
519  struct GNUNET_FS_FileInformation *fic;
521 
522  if (GNUNET_YES == item->is_directory)
523  {
524  if (NULL == item->meta)
525  item->meta = GNUNET_FS_meta_data_create ();
527  EXTRACTOR_METATYPE_MIMETYPE,
528  NULL,
529  0);
531  if (NULL == item->ksk_uri)
532  {
533  const char *mime = GNUNET_FS_DIRECTORY_MIME;
534  item->ksk_uri = GNUNET_FS_uri_ksk_create_from_args (1, &mime);
535  }
536  else
539  GNUNET_NO);
541  NULL,
542  item->ksk_uri,
543  item->meta,
544  &bo,
545  item->filename);
546  for (child = item->children_head; child; child = child->next)
547  {
548  fic = get_file_information (child);
550  }
551  }
552  else
553  {
555  NULL,
556  item->filename,
557  item->ksk_uri,
558  item->meta,
559  ! do_insert,
560  &bo);
561  }
562  return fi;
563 }
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 publishi...
static int do_insert
Command-line option for 'inserting'.
static pid_t child
void GNUNET_FS_meta_data_make_directory(struct GNUNET_FS_MetaData *md)
Set the MIMETYPE information for the given metadata to "application/gnunet-directory".
Definition: fs_directory.c:81
struct GNUNET_FS_FileInformation * GNUNET_FS_file_information_create_from_file(struct GNUNET_FS_Handle *h, void *client_info, const char *filename, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_FS_MetaData *meta, int do_index, const struct GNUNET_FS_BlockOptions *bo)
Create an entry for a file in a publish-structure.
#define GNUNET_FS_DIRECTORY_MIME
int GNUNET_FS_file_information_add(struct GNUNET_FS_FileInformation *dir, struct GNUNET_FS_FileInformation *ent)
Add an entry to a directory in a publish-structure.
struct GNUNET_FS_Uri * GNUNET_FS_uri_ksk_create_from_args(unsigned int argc, const char **argv)
Create an FS URI from a user-supplied command line of keywords.
Definition: fs_uri.c:1144
struct GNUNET_FS_FileInformation * GNUNET_FS_file_information_create_empty_directory(struct GNUNET_FS_Handle *h, void *client_info, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_FS_MetaData *meta, const struct GNUNET_FS_BlockOptions *bo, const char *filename)
Create an entry for an empty directory in a publish-structure.
void GNUNET_FS_uri_ksk_add_keyword(struct GNUNET_FS_Uri *uri, const char *keyword, int is_mandatory)
Add the given keyword to the set of keywords represented by the URI.
Definition: fs_uri.c:752
@ GNUNET_NO
struct GNUNET_FS_MetaData * GNUNET_FS_meta_data_create()
Create a fresh struct FS_MetaData token.
Definition: meta_data.c:132
int GNUNET_FS_meta_data_delete(struct GNUNET_FS_MetaData *md, enum EXTRACTOR_MetaType type, const char *data, size_t data_size)
Remove an item.
Definition: meta_data.c:369
Information for a file or directory that is about to be published.
Definition: fs_api.h:228
A node of a directory tree (produced by dirscanner)
int is_directory
GNUNET_YES if this is a directory
struct GNUNET_FS_Uri * ksk_uri
Keywords for this file or directory (derived from metadata).
struct GNUNET_FS_ShareTreeItem * children_head
This is a doubly-linked tree NULL for files and empty directories.
struct GNUNET_FS_MetaData * meta
Metadata for this file or directory.
char * filename
Name of the file/directory.

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_resultresult from the directory scan, freed in this function

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

574 {
575  struct GNUNET_FS_FileInformation *fi;
576  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
577  const struct GNUNET_IDENTITY_PrivateKey *pk;
578 
579  fi = get_file_information (directory_scan_result);
580  GNUNET_FS_share_tree_free (directory_scan_result);
581  if (NULL == fi)
582  {
583  fprintf (stderr, "%s", _ ("Could not publish\n"));
584  ret = 1;
586  return;
587  }
589  if (extract_only)
590  {
591  GNUNET_FS_file_information_destroy (fi, NULL, NULL);
593  return;
594  }
595  priv = NULL;
596  if (NULL != namespace)
597  {
600  priv = &pk->ecdsa_key;
601  }
603  fi,
604  priv,
605  this_id,
606  next_id,
607  (do_simulate)
610  if (NULL == pc)
611  {
612  fprintf (stderr, "%s", _ ("Could not start publishing.\n"));
613  ret = 1;
615  return;
616  }
617 }
static int do_simulate
Command-line option to merely simulate publishing operation.
void GNUNET_FS_share_tree_free(struct GNUNET_FS_ShareTreeItem *toplevel)
Release memory of a share item tree.
Definition: fs_sharetree.c:437
struct GNUNET_FS_PublishContext * GNUNET_FS_publish_start(struct GNUNET_FS_Handle *h, struct GNUNET_FS_FileInformation *fi, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const char *nid, const char *nuid, enum GNUNET_FS_PublishOptions options)
Publish a file or directory.
Definition: fs_publish.c:1443
void GNUNET_FS_file_information_destroy(struct GNUNET_FS_FileInformation *fi, GNUNET_FS_FileInformationProcessor cleaner, void *cleaner_cls)
Destroy publish-structure.
@ GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY
Simulate publishing.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.

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
clsclosure
filenamewhich file we are making progress on
is_directoryGNUNET_YES if this is a directory, GNUNET_NO if this is a file GNUNET_SYSERR if it is neither (or unknown)
reasonkind of progress we are making

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

636 {
637  struct GNUNET_FS_ShareTreeItem *directory_scan_result;
638 
639  switch (reason)
640  {
642  if (verbose > 1)
643  {
644  if (is_directory == GNUNET_YES)
645  fprintf (stdout, _ ("Scanning directory `%s'.\n"), filename);
646  else
647  fprintf (stdout, _ ("Scanning file `%s'.\n"), filename);
648  }
649  break;
650 
652  fprintf (stderr,
653  _ ("There was trouble processing file `%s', skipping it.\n"),
654  filename);
655  break;
656 
658  if (verbose)
659  fprintf (stdout, "%s", _ ("Preprocessing complete.\n"));
660  break;
661 
663  if (verbose > 2)
664  fprintf (stdout,
665  _ ("Extracting meta data from file `%s' complete.\n"),
666  filename);
667  break;
668 
670  if (verbose > 1)
671  fprintf (stdout, "%s", _ ("Meta data extraction has finished.\n"));
672  directory_scan_result = GNUNET_FS_directory_scan_get_result (ds);
673  ds = NULL;
674  GNUNET_FS_share_tree_trim (directory_scan_result);
675  directory_trim_complete (directory_scan_result);
676  break;
677 
679  fprintf (stdout, "%s", _ ("Error scanning directory.\n"));
680  ret = 1;
682  break;
683 
684  default:
685  GNUNET_assert (0);
686  break;
687  }
688  fflush (stdout);
689 }
static char * filename
static void directory_trim_complete(struct GNUNET_FS_ShareTreeItem *directory_scan_result)
We've finished scanning the directory and optimized the meta data.
struct GNUNET_FS_ShareTreeItem * GNUNET_FS_directory_scan_get_result(struct GNUNET_FS_DirScanner *ds)
Obtain the result of the scan after the scan has signalled completion.
void GNUNET_FS_share_tree_trim(struct GNUNET_FS_ShareTreeItem *toplevel)
Process a share item tree, moving frequent keywords up and copying frequent metadata up.
Definition: fs_sharetree.c:417
@ GNUNET_FS_DIRSCANNER_INTERNAL_ERROR
There was an internal error.
@ GNUNET_FS_DIRSCANNER_FILE_IGNORED
We're having trouble accessing a file (soft-error); it will be ignored.
@ GNUNET_FS_DIRSCANNER_FINISHED
Last call to the progress function: we have finished scanning the directory.
@ GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED
We've finished extracting meta data from a file.
@ GNUNET_FS_DIRSCANNER_ALL_COUNTED
We've found all files (in the pre-pass).
@ GNUNET_FS_DIRSCANNER_FILE_START
We've started processing a file or directory.

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
args0filename to publish

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

700 {
701  char *ex;
702  char *emsg;
703 
704  if ((NULL != pseudonym) && (NULL == namespace))
705  {
706  fprintf (stderr, _ ("Selected pseudonym `%s' unknown\n"), pseudonym);
707  ret = 1;
709  return;
710  }
711  if (NULL != uri_string)
712  {
713  emsg = NULL;
714  if (NULL == (uri = GNUNET_FS_uri_parse (uri_string, &emsg)))
715  {
716  fprintf (stderr, _ ("Failed to parse URI: %s\n"), emsg);
717  GNUNET_free (emsg);
718  ret = 1;
720  return;
721  }
723  topKeywords,
724  meta,
725  uri,
726  &bo,
729  NULL);
730  return;
731  }
732  if (GNUNET_OK !=
733  GNUNET_CONFIGURATION_get_value_string (cfg, "FS", "EXTRACTORS", &ex))
734  ex = NULL;
735  if (0 != access (args0, R_OK))
736  {
737  fprintf (stderr,
738  _ ("Failed to access `%s': %s\n"),
739  args0,
740  strerror (errno));
741  GNUNET_free (ex);
742  return;
743  }
746  ex,
748  NULL);
749  if (NULL == ds)
750  {
751  fprintf (
752  stderr,
753  "%s",
754  _ (
755  "Failed to start meta directory scanner. Is gnunet-helper-publish-fs installed?\n"));
756  GNUNET_free (ex);
757  return;
758  }
759  GNUNET_free (ex);
760 }
static char * uri_string
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
static char * pseudonym
Command-line option identifying the pseudonym to use for the publication.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Handle to our configuration.
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.
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.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
struct GNUNET_FS_Uri * GNUNET_FS_uri_parse(const char *uri, char **emsg)
Convert a UTF-8 String to a URI.
Definition: fs_uri.c:637
struct GNUNET_FS_PublishKskContext * GNUNET_FS_publish_ksk(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *ksk_uri, const struct GNUNET_FS_MetaData *meta, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_BlockOptions *bo, enum GNUNET_FS_PublishOptions options, GNUNET_FS_PublishContinuation cont, void *cont_cls)
Publish a CHK under various keywords on GNUnet.
struct GNUNET_FS_DirScanner * GNUNET_FS_directory_scan_start(const char *filename, int disable_extractor, const char *ex, GNUNET_FS_DirScannerProgressCallback cb, void *cb_cls)
Start a directory scanner thread.

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
clsclosure with 'const char *' of filename to publish
egoego handle
ctxcontext for application to store data for this ego (during the lifetime of this process, initially NULL)
namename 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.

779 {
780  const char *args0 = cls;
781 
782  if (NULL == ego)
783  {
784  identity_continuation (args0);
785  return;
786  }
787  if (NULL == name)
788  return;
789  if (0 == strcmp (name, pseudonym))
790  namespace = ego;
791 }
static void identity_continuation(const char *args0)
Continuation proceeding with initialization after identity subsystem has been initialized.
const char * name

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
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cconfiguration

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

807 {
808  /* check arguments */
809  if ((NULL != uri_string) && (extract_only))
810  {
811  printf (_ ("Cannot extract metadata from a URI!\n"));
812  ret = -1;
813  return;
814  }
815  if (((NULL == uri_string) || (extract_only)) &&
816  ((NULL == args[0]) || (NULL != args[1])))
817  {
818  printf (_ ("You must specify one and only one filename for insertion.\n"));
819  ret = -1;
820  return;
821  }
822  if ((NULL != uri_string) && (NULL != args[0]))
823  {
824  printf (_ ("You must NOT specify an URI and a filename.\n"));
825  ret = -1;
826  return;
827  }
828  if (NULL != pseudonym)
829  {
830  if (NULL == this_id)
831  {
832  fprintf (stderr,
833  _ ("Option `%s' is required when using option `%s'.\n"),
834  "-t",
835  "-P");
836  ret = -1;
837  return;
838  }
839  }
840  else
841  { /* ordinary insertion checks */
842  if (NULL != next_id)
843  {
844  fprintf (stderr,
845  _ ("Option `%s' makes no sense without option `%s'.\n"),
846  "-N",
847  "-P");
848  ret = -1;
849  return;
850  }
851  if (NULL != this_id)
852  {
853  fprintf (stderr,
854  _ ("Option `%s' makes no sense without option `%s'.\n"),
855  "-t",
856  "-P");
857  ret = -1;
858  return;
859  }
860  }
861  cfg = c;
863  "gnunet-publish",
864  &progress_cb,
865  NULL,
868  if (NULL == ctx)
869  {
870  fprintf (stderr, _ ("Could not initialize `%s' subsystem.\n"), "FS");
871  ret = 1;
872  return;
873  }
875  if (NULL != pseudonym)
877  else
879 }
static void do_stop_task(void *cls)
We are finished with the publishing operation, clean up all FS state.
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.
static void identity_cb(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
Function called by identity service with known pseudonyms.
struct GNUNET_FS_Handle * GNUNET_FS_start(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *client_name, GNUNET_FS_ProgressCallback upcb, void *upcb_cls, enum GNUNET_FS_Flags flags,...)
Setup a connection to the file-sharing service.
Definition: fs_api.c:3244
@ GNUNET_FS_FLAGS_NONE
No special flags set.
@ GNUNET_FS_OPTIONS_END
Last option in the VARARG list.
struct GNUNET_IDENTITY_Handle * GNUNET_IDENTITY_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
Connect to the identity service.
Definition: identity_api.c:531
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1334

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
argcnumber of arguments from the command line
argvcommand line arguments
Returns
0 ok, 1 on error

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

891 {
894  "anonymity",
895  "LEVEL",
896  gettext_noop (
897  "set the desired LEVEL of sender-anonymity"),
900  'D',
901  "disable-extractor",
902  gettext_noop ("do not use libextractor to add keywords or metadata"),
905  "enable-creation-time",
906  gettext_noop (
907  "enable adding the creation time to the "
908  "metadata of the uploaded file"),
911  "extract",
912  gettext_noop (
913  "print list of extracted keywords that would "
914  "be used, but do not perform upload"),
915  &extract_only),
917  'k',
918  "key",
919  "KEYWORD",
920  gettext_noop (
921  "add an additional keyword for the top-level "
922  "file or directory (this option can be specified multiple times)"),
923  &topKeywords),
925  'm',
926  "meta",
927  "TYPE:VALUE",
928  gettext_noop ("set the meta-data for the given TYPE to the given VALUE"),
929  &meta),
931  'n',
932  "noindex",
933  gettext_noop ("do not index, perform full insertion (stores "
934  "entire file in encrypted form in GNUnet database)"),
935  &do_insert),
937  'N',
938  "next",
939  "ID",
940  gettext_noop ("specify ID of an updated version to be "
941  "published in the future (for namespace insertions only)"),
942  &next_id),
944  "priority",
945  "PRIORITY",
946  gettext_noop (
947  "specify the priority of the content"),
950  "pseudonym",
951  "NAME",
952  gettext_noop (
953  "publish the files under the pseudonym "
954  "NAME (place file into namespace)"),
955  &pseudonym),
957  "replication",
958  "LEVEL",
959  gettext_noop (
960  "set the desired replication LEVEL"),
963  "simulate-only",
964  gettext_noop (
965  "only simulate the process but do not do "
966  "any actual publishing (useful to compute URIs)"),
967  &do_simulate),
969  "this",
970  "ID",
971  gettext_noop (
972  "set the ID of this version of the publication "
973  "(for namespace insertions only)"),
974  &this_id),
976  'u',
977  "uri",
978  "URI",
979  gettext_noop (
980  "URI to be published (can be used instead of passing a "
981  "file to add keywords to the file with the respective URI)"),
982  &uri_string),
983 
985 
987 
990 
991  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
992  return 2;
993  ret =
994  (GNUNET_OK ==
995  GNUNET_PROGRAM_run (argc,
996  argv,
997  "gnunet-publish [OPTIONS] FILENAME",
998  gettext_noop ("Publish a file or directory on GNUnet"),
999  options,
1000  &run,
1001  NULL))
1002  ? ret
1003  : 1;
1004  GNUNET_free_nz ((void *) argv);
1005  return ret;
1006 }
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define gettext_noop(String)
Definition: gettext.h:70
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.
struct GNUNET_GETOPT_CommandLineOption GNUNET_FS_GETOPT_METADATA(char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_FS_MetaData **meta)
Allow user to specify metadata.
Definition: fs_getopt.c:254
struct GNUNET_GETOPT_CommandLineOption GNUNET_FS_GETOPT_KEYWORDS(char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_FS_Uri **topKeywords)
Allow user to specify keywords.
Definition: fs_getopt.c:129
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_uint(char shortName, const char *name, const char *argumentHelp, const char *description, unsigned int *val)
Allow user to specify an unsigned int.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_verbose(unsigned int *level)
Define the '-V' verbosity option.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
#define GNUNET_free_nz(ptr)
Wrapper around free.
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:400
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1222
struct GNUNET_TIME_Absolute GNUNET_TIME_year_to_time(unsigned int year)
Convert a year to an expiration time of January 1st of that year.
Definition: time.c:801
unsigned int GNUNET_TIME_get_current_year(void)
Return the current year (e.g.
Definition: time.c:747
uint32_t anonymity_level
At which anonymity level should the block be shared? (0: no anonymity, 1: normal GAP,...
uint32_t content_priority
How important is it for us to store the block? If we run out of space, the highest-priority,...
uint32_t replication_level
How often should we try to migrate the block to other peers? Only used if "CONTENT_PUSHING" is set to...
struct GNUNET_TIME_Absolute expiration_time
At what time should the block expire? Data blocks (DBLOCKS and IBLOCKS) may still be used even if the...
Definition of a command line option.

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

◆ 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

◆ meta

◆ 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

◆ 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

◆ identity