GNUnet  0.10.x
Functions | Variables
gnunet-unindex.c File Reference

unindex files published on GNUnet More...

#include "platform.h"
#include "gnunet_fs_service.h"
Include dependency graph for gnunet-unindex.c:

Go to the source code of this file.

Functions

static void cleanup_task (void *cls)
 
static void shutdown_task (void *cls)
 
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 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 unindex content. More...
 

Variables

static int ret
 
static unsigned int verbose
 
static const struct GNUNET_CONFIGURATION_Handlecfg
 
static struct GNUNET_FS_Handlectx
 
static struct GNUNET_FS_UnindexContextuc
 

Detailed Description

unindex files published on GNUnet

Author
Christian Grothoff
Krista Bennett
James Blackwell
Igor Wronsky

Definition in file gnunet-unindex.c.

Function Documentation

◆ cleanup_task()

static void cleanup_task ( void *  cls)
static

Definition at line 43 of file gnunet-unindex.c.

References GNUNET_FS_stop().

Referenced by progress_cb().

44 {
46  ctx = NULL;
47 }
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3215
static struct GNUNET_FS_Handle * ctx
Here is the call graph for this function:
Here is the caller graph for this function:

◆ shutdown_task()

static void shutdown_task ( void *  cls)
static

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

References GNUNET_FS_unindex_stop(), and uc.

Referenced by run().

52 {
53  struct GNUNET_FS_UnindexContext *u;
54 
55  if (uc != NULL)
56  {
57  u = uc;
58  uc = NULL;
60  }
61 }
void GNUNET_FS_unindex_stop(struct GNUNET_FS_UnindexContext *uc)
Clean up after completion of an unindex operation.
Definition: fs_unindex.c:835
static struct GNUNET_FS_UnindexContext * uc
Handle for controlling an unindexing operation.
Definition: fs_api.h:1334
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 77 of file gnunet-unindex.c.

References _, cleanup_task(), 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_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, GNUNET_FS_ProgressInfo::status, GNUNET_FS_ProgressInfo::unindex, GNUNET_FS_ProgressInfo::value, and verbose.

Referenced by run().

78 {
79  const char *s;
80 
81  switch (info->status)
82  {
84  break;
85 
87  if (verbose)
88  {
90  GNUNET_YES);
91  fprintf(stdout,
92  _("Unindexing at %llu/%llu (%s remaining)\n"),
93  (unsigned long long)info->value.unindex.completed,
94  (unsigned long long)info->value.unindex.size,
95  s);
96  }
97  break;
98 
100  fprintf(stderr,
101  _("Error unindexing: %s.\n"),
102  info->value.unindex.specifics.error.message);
104  break;
105 
107  fprintf(stdout, "%s", _("Unindexing done.\n"));
109  break;
110 
113  break;
114 
115  default:
116  fprintf(stderr, _("Unexpected status: %d\n"), info->status);
117  break;
118  }
119  return NULL;
120 }
Notification that we started to unindex a file.
Notification that we made progress unindexing a file.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:517
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
static unsigned int verbose
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
enum GNUNET_FS_Status status
Specific status code (determines the event type).
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:686
Notification that the unindexing of this file was stopped (final event for this action).
Notification that the unindexing of this file was completed.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_FS_ProgressInfo::@28::@32 unindex
Values for all "GNUNET_FS_STATUS_UNINDEX_*" events.
Notification that we encountered an error unindexing a file.
static void cleanup_task(void *cls)
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 132 of file gnunet-unindex.c.

References _, GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END, GNUNET_FS_start(), GNUNET_FS_stop(), GNUNET_FS_unindex_start(), GNUNET_SCHEDULER_add_shutdown(), progress_cb(), ret, and shutdown_task().

Referenced by main().

136 {
137  /* check arguments */
138  if ((args[0] == NULL) || (args[1] != NULL))
139  {
140  printf(_("You must specify one and only one filename for unindexing.\n"));
141  ret = -1;
142  return;
143  }
144  cfg = c;
146  "gnunet-unindex",
147  &progress_cb,
148  NULL,
151  if (NULL == ctx)
152  {
153  fprintf(stderr, _("Could not initialize `%s' subsystem.\n"), "FS");
154  ret = 1;
155  return;
156  }
157  uc = GNUNET_FS_unindex_start(ctx, args[0], NULL);
158  if (NULL == uc)
159  {
160  fprintf(stderr, "%s", _("Could not start unindex operation.\n"));
162  return;
163  }
165 }
static int ret
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.
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, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1284
static struct GNUNET_FS_UnindexContext * uc
Last option in the VARARG list.
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3215
static void shutdown_task(void *cls)
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:3140
No special flags set.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
struct GNUNET_FS_UnindexContext * GNUNET_FS_unindex_start(struct GNUNET_FS_Handle *h, const char *filename, void *cctx)
Unindex a file.
Definition: fs_unindex.c:793
static struct GNUNET_FS_Handle * ctx
static const struct GNUNET_CONFIGURATION_Handle * cfg
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 unindex content.

Parameters
argcnumber of arguments from the command line
argvcommand line arguments
Returns
0 ok, 1 on error

Definition at line 176 of file gnunet-unindex.c.

References gettext_noop, GNUNET_free, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_verbose(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), ret, run(), and verbose.

177 {
180 
182  };
183 
184  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
185  return 2;
186 
187  ret = (GNUNET_OK ==
189  argc,
190  argv,
191  "gnunet-unindex [OPTIONS] FILENAME",
192  gettext_noop(
193  "Unindex a file that was previously indexed with gnunet-publish."),
194  options,
195  &run,
196  NULL))
197  ? ret
198  : 1;
199  GNUNET_free((void *)argv);
200  return ret;
201 }
static int ret
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_verbose(unsigned int *level)
Define the '-V' verbosity option.
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1439
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Definition of a command line option.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
static unsigned int verbose
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.
int 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, parse options).
Definition: program.c:367
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:

Variable Documentation

◆ ret

int ret
static

Definition at line 31 of file gnunet-unindex.c.

Referenced by main(), and run().

◆ verbose

unsigned int verbose
static

Definition at line 33 of file gnunet-unindex.c.

Referenced by main(), and progress_cb().

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

Definition at line 35 of file gnunet-unindex.c.

◆ ctx

struct GNUNET_FS_Handle* ctx
static

Definition at line 37 of file gnunet-unindex.c.

◆ uc

struct GNUNET_FS_UnindexContext* uc
static