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.

44 {
46  ctx = NULL;
47 }
static struct GNUNET_FS_Handle * ctx
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3338

References ctx, and GNUNET_FS_stop().

Referenced by progress_cb().

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.

52 {
53  struct GNUNET_FS_UnindexContext *u;
54 
55  if (uc != NULL)
56  {
57  u = uc;
58  uc = NULL;
60  }
61 }
static struct GNUNET_FS_UnindexContext * uc
void GNUNET_FS_unindex_stop(struct GNUNET_FS_UnindexContext *uc)
Clean up after completion of an unindex operation.
Definition: fs_unindex.c:837
Handle for controlling an unindexing operation.
Definition: fs_api.h:1350

References GNUNET_FS_unindex_stop(), and uc.

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 78 of file gnunet-unindex.c.

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 }
static unsigned int verbose
static void cleanup_task(void *cls)
@ GNUNET_YES
Definition: gnunet_common.h:97
@ 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_UNINDEX_STOPPED
Notification that the unindexing of this file was stopped (final event for this action).
@ 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.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
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:1296
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:557
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
union GNUNET_FS_ProgressInfo::@25 value
Values that depend on the event type.
enum GNUNET_FS_Status status
Specific status code (determines the event type).
struct GNUNET_FS_ProgressInfo::@25::GNUNET_FS_UnindexEvent unindex

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().

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.

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 const struct GNUNET_CONFIGURATION_Handle * cfg
static void shutdown_task(void *cls)
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_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:3263
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
@ GNUNET_FS_FLAGS_NONE
No special flags set.
@ GNUNET_FS_OPTIONS_END
Last option in the VARARG list.
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:1331

References _, consensus-simulation::args, cfg, ctx, 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, shutdown_task(), and uc.

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

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_nz ((void *) argv);
201  return ret;
202 }
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:69
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.
@ GNUNET_OK
Definition: gnunet_common.h:95
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_verbose(unsigned int *level)
Define the '-V' verbosity option.
#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:364
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:1209
Definition of a command line option.

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

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.

Referenced by run().

◆ ctx

struct GNUNET_FS_Handle* ctx
static

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

Referenced by cleanup_task(), and run().

◆ uc

struct GNUNET_FS_UnindexContext* uc
static