GNUnet  0.11.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:3216
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:837
static struct GNUNET_FS_UnindexContext * uc
Handle for controlling an unindexing operation.
Definition: fs_api.h:1349
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 78 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().

79 {
80  const char *s;
81 
82  switch (info->status)
83  {
85  break;
86 
88  if (verbose)
89  {
91  GNUNET_YES);
92  fprintf (stdout,
93  _ ("Unindexing at %llu/%llu (%s remaining)\n"),
94  (unsigned long long) info->value.unindex.completed,
95  (unsigned long long) info->value.unindex.size,
96  s);
97  }
98  break;
99 
101  fprintf (stderr,
102  _ ("Error unindexing: %s.\n"),
103  info->value.unindex.specifics.error.message);
105  break;
106 
108  fprintf (stdout, "%s", _ ("Unindexing done.\n"));
110  break;
111 
114  break;
115 
116  default:
117  fprintf (stderr, _ ("Unexpected status: %d\n"), info->status);
118  break;
119  }
120  return NULL;
121 }
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:526
struct GNUNET_FS_ProgressInfo::@25::@29 unindex
Values for all "GNUNET_FS_STATUS_UNINDEX_*" events.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
union GNUNET_FS_ProgressInfo::@25 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:1280
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:687
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
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 133 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().

137 {
138  /* check arguments */
139  if ((args[0] == NULL) || (args[1] != NULL))
140  {
141  printf (_ ("You must specify one and only one filename for unindexing.\n"));
142  ret = -1;
143  return;
144  }
145  cfg = c;
147  "gnunet-unindex",
148  &progress_cb,
149  NULL,
152  if (NULL == ctx)
153  {
154  fprintf (stderr, _ ("Could not initialize `%s' subsystem.\n"), "FS");
155  ret = 1;
156  return;
157  }
158  uc = GNUNET_FS_unindex_start (ctx, args[0], NULL);
159  if (NULL == uc)
160  {
161  fprintf (stderr, "%s", _ ("Could not start unindex operation.\n"));
163  return;
164  }
166 }
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:1300
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:3216
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:3141
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:795
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 177 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.

178 {
181 
183  };
184 
185  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
186  return 2;
187 
188  ret = (GNUNET_OK ==
190  argc,
191  argv,
192  "gnunet-unindex [OPTIONS] FILENAME",
193  gettext_noop (
194  "Unindex a file that was previously indexed with gnunet-publish."),
195  options,
196  &run,
197  NULL))
198  ? ret
199  : 1;
200  GNUNET_free ((void *) argv);
201  return ret;
202 }
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:1438
#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