GNUnet 0.21.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{
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 a publication.
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:732
void GNUNET_FS_meta_data_destroy(struct GNUNET_FS_MetaData *md)
Free meta data.
Definition: meta_data.c:166
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 {
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:570
#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}
static char * data
The data to insert into the dht.
static uint32_t type
Type string converted to DNS type value.
#define EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME

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
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
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_iterate(const struct GNUNET_FS_MetaData *md, EXTRACTOR_MetaDataProcessor iter, void *iter_cls)
Iterate over MD entries.
Definition: meta_data.c:418
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:438
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:391
void GNUNET_FS_meta_data_merge(struct GNUNET_FS_MetaData *md, const struct GNUNET_FS_MetaData *in)
Extend metadata.
Definition: meta_data.c:356
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(), publish_inspector(), topKeywords, and uri.

Referenced by directory_trim_complete(), and publish_inspector().

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_CRYPTO_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_PUBLIC_KEY_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_CRYPTO_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_CRYPTO_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:517
@ GNUNET_PUBLIC_KEY_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_CRYPTO_PrivateKey::ecdsa_key, GNUNET_FS_PUBLISH_OPTION_NONE, GNUNET_FS_publish_sks(), GNUNET_IDENTITY_ego_get_private_key(), GNUNET_PUBLIC_KEY_TYPE_ECDSA, GNUNET_SCHEDULER_shutdown(), meta, next_id, pk, ret, this_id, GNUNET_CRYPTO_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)
527 EXTRACTOR_METATYPE_MIMETYPE,
528 NULL,
529 0);
531 if (NULL == item->ksk_uri)
532 {
533 const char *mime = GNUNET_FS_DIRECTORY_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 {
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 int do_insert
Command-line option for 'inserting'.
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 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
#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_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.
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_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.
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(void)
Create a fresh meta data container.
Definition: meta_data.c:127
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:364
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, get_file_information(), 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(), and get_file_information().

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_CRYPTO_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,
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_CRYPTO_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_PUBLIC_KEY_TYPE_ECDSA, GNUNET_SCHEDULER_shutdown(), next_id, pc, pk, publish_inspector(), ret, this_id, and GNUNET_CRYPTO_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 {
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 }
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_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 KBlock 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.
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

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 char * name
Name (label) of the records to list.
static void identity_continuation(const char *args0)
Continuation proceeding with initialization after identity subsystem has been initialized.

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",
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 * 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 do_stop_task(void *cls)
We are finished with the publishing operation, clean up all FS state.
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:487
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",
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",
907 "enable adding the creation time to the "
908 "metadata of the uploaded file"),
911 "extract",
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",
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",
947 "specify the priority of the content"),
950 "pseudonym",
951 "NAME",
953 "publish the files under the pseudonym "
954 "NAME (place file into namespace)"),
955 &pseudonym),
957 "replication",
958 "LEVEL",
960 "set the desired replication LEVEL"),
963 "simulate-only",
965 "only simulate the process but do not do "
966 "any actual publishing (useful to compute URIs)"),
967 &do_simulate),
969 "this",
970 "ID",
972 "set the ID of this version of the publication "
973 "(for namespace insertions only)"),
974 &this_id),
976 'u',
977 "uri",
978 "URI",
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:1230
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 GNUNET_FS_GETOPT_KEYWORDS(), 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 add_to_builder(), check_advertisement(), create_download_context(), dns_string_to_value(), dns_value_to_string(), do_stop_task(), fip_signal_start(), gather_uri_data(), GDS_try_connect(), getopt_set_keywords(), GNUNET_DNSPARSER_builder_add_uri(), GNUNET_DNSPARSER_free_uri(), GNUNET_DNSPARSER_parse_uri(), GNUNET_FS_directory_builder_add(), GNUNET_FS_directory_list_contents(), GNUNET_FS_download_start(), GNUNET_FS_probe(), GNUNET_FS_publish_ksk(), GNUNET_FS_publish_sks(), GNUNET_FS_publish_ublock_(), GNUNET_FS_search_start(), 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_peer_identity(), 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_FS_uri_to_string(), GNUNET_HELLO_builder_from_url(), GNUNET_STRINGS_path_is_absolute(), handle_advertisement(), handle_gns_resolution_result(), handle_uri(), handler_advertisement(), hello_for_client_cb(), hello_for_incoming_cb(), identity_continuation(), linked_list_contains(), load_hostlist_file(), print_entry(), 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(), save_member_session(), 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