GNUnet  0.10.x
gnunet_fs_service.h
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2004--2013 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
33 #ifndef GNUNET_FS_LIB_H
34 #define GNUNET_FS_LIB_H
35 
36 #include "gnunet_util_lib.h"
37 
38 #ifdef __cplusplus
39 extern "C"
40 {
41 #if 0 /* keep Emacsens' auto-indent happy */
42 }
43 #endif
44 #endif
45 
67 #define GNUNET_FS_VERSION 0x00090300
68 
69 
70 /* ******************** URI API *********************** */
71 
72 #define GNUNET_FS_URI_PREFIX "gnunet://fs/"
73 #define GNUNET_FS_URI_KSK_INFIX "ksk/"
74 #define GNUNET_FS_URI_SKS_INFIX "sks/"
75 #define GNUNET_FS_URI_CHK_INFIX "chk/"
76 #define GNUNET_FS_URI_LOC_INFIX "loc/"
77 
78 
83 #define GNUNET_FS_PROBE_UPDATE_FREQUENCY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 250)
84 
88 struct GNUNET_FS_Uri;
89 
90 
99 typedef int
101  const char *keyword,
102  int is_mandatory);
103 
104 
105 
114 int
116  struct GNUNET_HashCode *key);
117 
118 
125 char *
127 
128 
136 char *
138 
139 
148 void
150  const char *keyword,
151  int is_mandatory);
152 
153 
161 void
163  const char *keyword);
164 
165 
173 struct GNUNET_FS_Uri *
174 GNUNET_FS_uri_parse(const char *uri,
175  char **emsg);
176 
177 
183 void
185 
186 
193 unsigned int
195 
196 
206 int
209  void *iterator_cls);
210 
211 
219 int
221  struct GNUNET_PeerIdentity *peer);
222 
223 
230 struct GNUNET_FS_Uri *
232 
233 
242 
243 
256 struct GNUNET_FS_Uri *
257 GNUNET_FS_uri_loc_create(const struct GNUNET_FS_Uri *base_uri,
258  const struct GNUNET_CRYPTO_EddsaPrivateKey *sign_key,
259  struct GNUNET_TIME_Absolute expiration_time);
260 
261 
269 struct GNUNET_FS_Uri *
270 GNUNET_FS_uri_ksk_merge(const struct GNUNET_FS_Uri *u1,
271  const struct GNUNET_FS_Uri *u2);
272 
273 
280 struct GNUNET_FS_Uri *
281 GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri);
282 
283 
301 struct GNUNET_FS_Uri *
303  char **emsg);
304 
305 
323 struct GNUNET_FS_Uri *
324 GNUNET_FS_uri_ksk_create_from_args(unsigned int argc,
325  const char **argv);
326 
327 
335 int
336 GNUNET_FS_uri_test_equal(const struct GNUNET_FS_Uri *u1,
337  const struct GNUNET_FS_Uri *u2);
338 
339 
346 int
348 
349 
357 struct GNUNET_FS_Uri *
359  const char *id);
360 
361 
370 int
373 
374 
381 char *
383 
384 
391 int
393 
394 
401 int
403 
404 
412 uint64_t
414 
415 
422 int
424 
425 
434 struct GNUNET_FS_Uri *
436  *md);
437 
438 
439 /* ******************** command-line option parsing API *********************** */
440 
452  const char *name,
453  const char *argumentHelp,
454  const char *description,
455  struct GNUNET_FS_Uri **topKeywords);
456 
468  const char *name,
469  const char *argumentHelp,
470  const char *description,
472 
485 int
487  void *scls,
488  const char *option,
489  const char *value);
490 
491 
492 
493 /* ************************* sharing API ***************** */
494 
495 
512 
517 
522 
527 
534 
541 
548 
553 
558 
563 
568 
573 
580 
586 
592 
598 
606 
613 
620 
626 
633 
638 
643 
649 
654 
659 
664 
670 
676 
683 
688 
693 
698 
703 
709 
715 
721 
726 };
727 
728 
733 
734 
739 
740 
745 
746 
753 
754 
759 
760 
767 
768 
777  union {
781  struct {
786 
791 
796  void *cctx;
797 
802  void *pctx;
803 
807  const char *filename;
808 
815  uint64_t size;
816 
823 
829 
833  uint64_t completed;
834 
838  uint32_t anonymity;
839 
843  union {
848  struct {
852  const void *data;
853 
857  uint64_t offset;
858 
862  uint64_t data_len;
863 
868  unsigned int depth;
869  } progress;
870 
875  struct {
879  uint64_t completed;
880 
884  uint64_t total;
885 
892  struct GNUNET_TIME_Relative eta;
894 
899  struct {
903  const char *message;
904 
908  const struct GNUNET_FS_Uri *chk_uri;
909 
913  const struct GNUNET_FS_Uri *sks_uri;
914  } resume;
915 
920  struct {
924  const struct GNUNET_FS_Uri *chk_uri;
925 
929  const struct GNUNET_FS_Uri *sks_uri;
930  } completed;
931 
936  struct {
940  const char *message;
941  } error;
942  } specifics;
943  } publish;
944 
945 
949  struct {
954 
960  void *cctx;
961 
966  void *pctx;
967 
974  void *sctx;
975 
979  const struct GNUNET_FS_Uri *uri;
980 
984  const char *filename;
985 
991  uint64_t size;
992 
998  struct GNUNET_TIME_Relative eta;
999 
1004 
1008  uint64_t completed;
1009 
1013  uint32_t anonymity;
1014 
1019 
1023  union {
1028  struct {
1035  const void *data;
1036 
1040  uint64_t offset;
1041 
1045  uint64_t data_len;
1046 
1052 
1057  unsigned int depth;
1058 
1066 
1074  } progress;
1075 
1080  struct {
1085  } start;
1086 
1091  struct {
1095  const struct GNUNET_CONTAINER_MetaData *meta;
1096 
1100  const char *message;
1101  } resume;
1102 
1107  struct {
1111  const char *message;
1112  } error;
1113  } specifics;
1114  } download;
1115 
1119  struct {
1127 
1135  void *cctx;
1136 
1144  void *pctx;
1145 
1150  const struct GNUNET_FS_Uri *query;
1151 
1158 
1162  uint32_t anonymity;
1163 
1167  union {
1172  struct {
1176  const struct GNUNET_CONTAINER_MetaData *meta;
1177 
1181  const struct GNUNET_FS_Uri *uri;
1182 
1187 
1193  } result;
1194 
1199  struct {
1203  const struct GNUNET_CONTAINER_MetaData *meta;
1204 
1208  const struct GNUNET_FS_Uri *uri;
1209 
1214 
1220 
1226 
1232  uint32_t applicability_rank;
1233  } resume_result;
1234 
1239  struct {
1244  void *cctx;
1245 
1249  const struct GNUNET_CONTAINER_MetaData *meta;
1250 
1254  const struct GNUNET_FS_Uri *uri;
1255 
1260  int32_t availability_rank;
1261 
1266  uint32_t availability_certainty;
1267 
1273  uint32_t applicability_rank;
1274 
1279  } update;
1280 
1290  struct {
1295  void *cctx;
1296 
1300  const struct GNUNET_CONTAINER_MetaData *meta;
1301 
1305  const struct GNUNET_FS_Uri *uri;
1306  } result_suspend;
1307 
1317  struct {
1322  void *cctx;
1323 
1327  const struct GNUNET_CONTAINER_MetaData *meta;
1328 
1332  const struct GNUNET_FS_Uri *uri;
1333  } result_stopped;
1334 
1339  struct {
1343  const char *message;
1344 
1349  } resume;
1350 
1355  struct {
1359  const char *message;
1360  } error;
1361 
1365  struct {
1369  const char *name;
1370 
1374  const char *root;
1375 
1379  const struct GNUNET_CONTAINER_MetaData *meta;
1380 
1385  } ns;
1386  } specifics;
1387  } search;
1388 
1392  struct {
1397 
1403  void *cctx;
1404 
1408  const char *filename;
1409 
1413  uint64_t size;
1414 
1420  struct GNUNET_TIME_Relative eta;
1421 
1427 
1431  uint64_t completed;
1432 
1436  union {
1441  struct {
1445  const void *data;
1446 
1450  uint64_t offset;
1451 
1455  uint64_t data_len;
1456 
1461  unsigned int depth;
1462  } progress;
1463 
1468  struct {
1472  const char *message;
1473  } resume;
1474 
1479  struct {
1483  const char *message;
1484  } error;
1485  } specifics;
1486  } unindex;
1487  } value;
1488 
1493 
1498 };
1499 
1500 
1516 typedef void *
1517 (*GNUNET_FS_ProgressCallback) (void *cls,
1518  const struct GNUNET_FS_ProgressInfo *info);
1519 
1520 
1529 
1535 
1542 };
1543 
1544 
1553 
1560 
1568 };
1569 
1570 
1583  struct GNUNET_TIME_Absolute expiration_time;
1584 
1590 
1597 
1610 };
1611 
1612 
1616 struct GNUNET_FS_Handle;
1617 
1618 
1630 struct GNUNET_FS_Handle *
1632  const char *client_name,
1634  void *upcb_cls,
1635  enum GNUNET_FS_Flags flags,
1636  ...);
1637 
1638 
1648 void
1650 
1651 
1667 typedef int
1669  struct GNUNET_FS_FileInformation *fi,
1670  uint64_t length,
1672  struct GNUNET_FS_Uri ** uri,
1673  struct GNUNET_FS_BlockOptions *bo,
1674  int *do_index,
1675  void **client_info);
1676 
1677 
1687 const char *
1689 
1690 
1697 const char *
1699 
1700 
1709 void
1711  const char *filename);
1712 
1713 
1730  void *client_info,
1731  const char *filename,
1732  const struct GNUNET_FS_Uri *keywords,
1733  const struct GNUNET_CONTAINER_MetaData *meta,
1734  int do_index,
1735  const struct GNUNET_FS_BlockOptions *bo);
1736 
1737 
1756  void *client_info,
1757  uint64_t length,
1758  void *data,
1759  const struct GNUNET_FS_Uri *keywords,
1760  const struct GNUNET_CONTAINER_MetaData *meta,
1761  int do_index,
1762  const struct GNUNET_FS_BlockOptions *bo);
1763 
1764 
1785 typedef size_t
1786 (*GNUNET_FS_DataReader) (void *cls,
1787  uint64_t offset,
1788  size_t max,
1789  void *buf,
1790  char **emsg);
1791 
1792 
1811  void *client_info,
1812  uint64_t length,
1814  void *reader_cls,
1815  const struct GNUNET_FS_Uri
1816  *keywords,
1817  const struct
1819  int do_index,
1820  const struct
1822 
1823 
1838  void *client_info,
1839  const struct GNUNET_FS_Uri
1840  *keywords,
1841  const struct
1843  *meta,
1844  const struct
1846  const char *filename);
1847 
1848 
1855 int
1857  *ent);
1858 
1859 
1871 int
1873  struct GNUNET_FS_FileInformation *ent);
1874 
1875 
1890 void
1893  void *proc_cls);
1894 
1895 
1906 void
1909  void *cleaner_cls);
1910 
1911 
1921 
1927 };
1928 
1929 
1943 struct GNUNET_FS_PublishContext *
1945  struct GNUNET_FS_FileInformation *fi,
1946  const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
1947  const char *nid,
1948  const char *nuid,
1950 
1951 
1960 void
1962 
1963 
1972 typedef void
1974  const struct GNUNET_FS_Uri *uri,
1975  const char *emsg);
1976 
1977 
1982 
1983 
1999  const struct GNUNET_FS_Uri *ksk_uri,
2000  const struct GNUNET_CONTAINER_MetaData *meta,
2001  const struct GNUNET_FS_Uri *uri,
2002  const struct GNUNET_FS_BlockOptions *bo,
2005 
2006 
2012 void
2014 
2015 
2020 
2021 
2039  const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
2040  const char *identifier,
2041  const char *update,
2042  const struct GNUNET_CONTAINER_MetaData *meta,
2043  const struct GNUNET_FS_Uri *uri,
2044  const struct GNUNET_FS_BlockOptions *bo,
2047 
2048 
2054 void
2056 
2057 
2066 typedef int
2068  const char *filename,
2069  const struct GNUNET_HashCode *file_id);
2070 
2071 
2076 
2077 
2089  void *iterator_cls);
2090 
2091 
2097 void
2099 
2100 
2109 struct GNUNET_FS_UnindexContext *
2111  const char *filename,
2112  void *cctx);
2113 
2114 
2120 void
2122 
2123 
2133 typedef void (*GNUNET_FS_IdentifierProcessor) (void *cls,
2134  const char *last_id,
2135  const struct GNUNET_FS_Uri *last_uri,
2136  const struct GNUNET_CONTAINER_MetaData *last_meta,
2137  const char *next_id);
2138 
2139 
2161 void
2163  const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
2164  const char *next_id,
2166  void *ip_cls);
2167 
2168 
2178 
2183 };
2184 
2185 
2197 struct GNUNET_FS_SearchContext *
2199  const struct GNUNET_FS_Uri *uri, uint32_t anonymity,
2200  enum GNUNET_FS_SearchOptions options, void *cctx);
2201 
2202 
2208 void
2210 
2211 
2217 void
2219 
2220 
2226 void
2228 
2229 
2240 struct GNUNET_FS_SearchResult *
2242  const struct GNUNET_FS_Uri *uri,
2243  const struct GNUNET_CONTAINER_MetaData *meta,
2244  void *client_info,
2245  uint32_t anonymity);
2246 
2247 
2255 void *
2257 
2258 
2268 
2273 
2279 
2285 
2294 };
2295 
2296 
2297 
2330  const struct GNUNET_FS_Uri *uri,
2331  const struct GNUNET_CONTAINER_MetaData *meta,
2332  const char *filename, const char *tempname,
2333  uint64_t offset, uint64_t length, uint32_t anonymity,
2336 
2337 
2374  struct GNUNET_FS_SearchResult *sr,
2375  const char *filename,
2376  const char *tempname, uint64_t offset,
2377  uint64_t length, uint32_t anonymity,
2379  void *cctx);
2380 
2381 
2388 void
2389 GNUNET_FS_download_stop(struct GNUNET_FS_DownloadContext *dc, int do_delete);
2390 
2391 
2397 void
2399 
2400 
2406 void
2408 
2409 
2410 
2411 /* ******************** Directory API *********************** */
2412 
2413 
2414 #define GNUNET_FS_DIRECTORY_MIME "application/gnunet-directory"
2415 #define GNUNET_FS_DIRECTORY_MAGIC "\211GND\r\n\032\n"
2416 #define GNUNET_FS_DIRECTORY_EXT ".gnd"
2417 
2425 int
2427  *md);
2428 
2429 
2436 void
2438 
2439 
2446 char *
2448 
2449 
2465 typedef void (*GNUNET_FS_DirectoryEntryProcessor) (void *cls,
2466  const char *filename,
2467  const struct GNUNET_FS_Uri *
2468  uri,
2469  const struct
2471  meta, size_t length,
2472  const void *data);
2473 
2474 
2494 int
2495 GNUNET_FS_directory_list_contents(size_t size, const void *data,
2496  uint64_t offset,
2498  void *dep_cls);
2499 
2500 
2505 
2506 
2514  *mdir);
2515 
2516 
2527 void
2529  const struct GNUNET_FS_Uri *uri,
2530  const struct GNUNET_CONTAINER_MetaData *md,
2531  const void *data);
2532 
2533 
2544 int
2546  size_t * rsize, void **rdata);
2547 
2548 
2549 /* ******************** DirScanner API *********************** */
2550 
2559 
2565 
2570 
2575 
2581 
2586 };
2587 
2588 
2600 typedef void (*GNUNET_FS_DirScannerProgressCallback) (void *cls,
2601  const char *filename,
2602  int is_directory,
2604 
2605 
2614 
2619 
2625 
2631 
2637 
2642 
2647 
2651  char *filename;
2652 
2657 
2662 };
2663 
2664 
2668 struct GNUNET_FS_DirScanner;
2669 
2670 
2682 struct GNUNET_FS_DirScanner *
2683 GNUNET_FS_directory_scan_start(const char *filename,
2684  int disable_extractor,
2685  const char *ex,
2687  void *cb_cls);
2688 
2689 
2696 void
2698 
2699 
2708 struct GNUNET_FS_ShareTreeItem *
2710 
2711 
2718 void
2720 
2721 
2727 void
2729 
2730 
2731 #if 0 /* keep Emacsens' auto-indent happy */
2732 {
2733 #endif
2734 #ifdef __cplusplus
2735 }
2736 #endif
2737 
2738 #endif
2739  /* end of group */
int GNUNET_FS_uri_loc_get_peer_identity(const struct GNUNET_FS_Uri *uri, struct GNUNET_PeerIdentity *peer)
Obtain the identity of the peer offering the data.
Definition: fs_uri.c:819
static int iterator(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Iterator over hash map entries.
void * client_info
Client info for this search result.
Definition: fs_api.h:519
unsigned int depth
Depth of the given block in the tree; 0 would be the lowest level (DBLOCKs).
General context for command line processors.
void * reader_cls
Closure for reader.
Definition: fs_api.h:311
struct GNUNET_FS_ProgressInfo::@28::@31::@44::@47 update
These values are only valid for GNUNET_FS_STATUS_SEARCH_UPDATE events.
char * nid
ID of the content in the namespace, NULL if we have no namespace.
Definition: fs_api.h:1189
Notification that we have started this download.
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1332
char * GNUNET_FS_meta_data_suggest_filename(const struct GNUNET_CONTAINER_MetaData *md)
Suggest a filename based on given metadata.
Definition: fs_misc.c:38
struct GNUNET_FS_ProgressInfo::@28::@29::@33::@35 progress_directory
These values are only valid for GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY events.
const char * name
Short, human-readable name of the namespace.
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:403
int GNUNET_FS_directory_builder_finish(struct GNUNET_FS_DirectoryBuilder *bld, size_t *rsize, void **rdata)
Finish building the directory.
Definition: fs_directory.c:570
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:84
GNUNET_FS_PublishContinuation cont
Function to call once we&#39;re done.
Definition: fs_namespace.c:362
No options (use defaults for everything).
int32_t availability_rank
Current availability rank (negative: unavailable, positive: available)
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_CONTAINER_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_publish_stop(struct GNUNET_FS_PublishContext *pc)
Stop a publication.
Definition: fs_publish.c:1555
void GNUNET_FS_unindex_stop(struct GNUNET_FS_UnindexContext *uc)
Clean up after completion of an unindex operation.
Definition: fs_unindex.c:835
int(* GNUNET_FS_FileInformationProcessor)(void *cls, struct GNUNET_FS_FileInformation *fi, uint64_t length, struct GNUNET_CONTAINER_MetaData *meta, struct GNUNET_FS_Uri **uri, struct GNUNET_FS_BlockOptions *bo, int *do_index, void **client_info)
Function called on entries in a struct GNUNET_FS_FileInformation iteration.
struct GNUNET_FS_ProgressInfo::@28::@31 search
Values for all "GNUNET_FS_STATUS_SEARCH_*" events.
Context for controlling a download.
Definition: fs_api.h:1722
void * iterator_cls
Closure for iterator.
struct GNUNET_FS_UnindexContext * uc
Context for controlling the unindexing.
const char * argumentHelp
Name of the argument for the user in help text.
struct GNUNET_TIME_Absolute GNUNET_FS_uri_loc_get_expiration(const struct GNUNET_FS_Uri *uri)
Obtain the expiration of the LOC URI.
Definition: fs_uri.c:836
void(* GNUNET_FS_DirScannerProgressCallback)(void *cls, const char *filename, int is_directory, enum GNUNET_FS_DirScannerProgressUpdateReason reason)
Function called over time as the directory scanner makes progress on the job at hand.
GNUNET_FS_Flags
General (global) option flags for file-sharing.
This search has yielded a result.
Notification that we started to unindex a file.
Last message from a search; this signals that there will be no further events associated with this se...
uint64_t total
How big do we estimate the entire directory to be?
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:1152
struct GNUNET_FS_Uri * GNUNET_FS_uri_loc_create(const struct GNUNET_FS_Uri *base_uri, const struct GNUNET_CRYPTO_EddsaPrivateKey *sign_key, struct GNUNET_TIME_Absolute expiration_time)
Construct a location URI (this peer will be used for the location).
Definition: fs_uri.c:876
void GNUNET_FS_meta_data_make_directory(struct GNUNET_CONTAINER_MetaData *md)
Set the MIMETYPE information for the given metadata to "application/gnunet-directory".
Definition: fs_directory.c:77
Notification that we are making progress sharing a file 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:759
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:1428
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
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.
Context for the SKS publication.
Definition: fs_namespace.c:332
Notification that this download was suspended.
void * client_info
Pointer kept for the client.
Definition: fs_api.h:239
const struct GNUNET_CONTAINER_MetaData * meta
Known metadata for the download.
Event generated for each search result when the respective search is stopped.
union GNUNET_FS_ProgressInfo::@28::@29::@33 specifics
Additional values for specific events.
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:641
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:288
Notification that we made progress unindexing a file.
void GNUNET_FS_search_continue(struct GNUNET_FS_SearchContext *sc)
Continue paused search.
Definition: fs_search.c:1662
const char * description
Help text for the option (description)
Master context for most FS operations.
Definition: fs_api.h:1056
struct GNUNET_FS_ShareTreeItem * prev
This is a doubly-linked list.
GNUNET_FS_DataReader reader
Function that can be used to read the data for the file.
Definition: fs_api.h:306
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.
void GNUNET_FS_get_indexed_files_cancel(struct GNUNET_FS_GetIndexedContext *gic)
Cancel iteration over all indexed files.
void GNUNET_FS_publish_ksk_cancel(struct GNUNET_FS_PublishKskContext *pkc)
Abort the KSK publishing operation.
void * pctx
Client context pointer for the parent operation (if this is a file in a directory or a subdirectory)...
struct GNUNET_TIME_Relative duration
How long has this upload been actively running (excludes times where the upload was suspended)...
int(* GNUNET_FS_KeywordIterator)(void *cls, const char *keyword, int is_mandatory)
Iterator over keywords.
struct GNUNET_FS_SearchResult * result
Handle to the result (for starting downloads).
struct GNUNET_FS_ShareTreeItem * parent
This is a doubly-linked tree NULL for top-level entries.
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_CONTAINER_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:430
struct GNUNET_FS_FileInformation * GNUNET_FS_file_information_create_from_data(struct GNUNET_FS_Handle *h, void *client_info, uint64_t length, void *data, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_CONTAINER_MetaData *meta, int do_index, const struct GNUNET_FS_BlockOptions *bo)
Create an entry for a file in a publish-structure.
struct GNUNET_FS_ShareTreeItem * children_tail
This is a doubly-linked tree NULL for files and empty directories.
struct GNUNET_FS_ProgressInfo::@28::@30 download
Values for all "GNUNET_FS_STATUS_DOWNLOAD_*" events.
struct GNUNET_FS_SearchResult * GNUNET_FS_probe(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta, void *client_info, uint32_t anonymity)
Start download probes for the given search result.
Definition: fs_search.c:491
struct GNUNET_FS_DownloadContext * parent
Parent download (used when downloading files in directories).
Definition: fs_api.h:1742
GNUNET_FS_SearchOptions
Options for searching.
Last option in the VARARG list.
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_CONTAINER_MetaData *meta, int do_index, const struct GNUNET_FS_BlockOptions *bo)
Create an entry for a file in a publish-structure.
const char * message
Error message, NULL if no error was encountered so far.
struct GNUNET_FS_Uri * ksk_uri
Keywords for this file or directory (derived from metadata).
struct GNUNET_TIME_Relative block_download_duration
How much time passed between us asking for this block and actually getting it? GNUNET_TIME_UNIT_FOREV...
struct GNUNET_TIME_Relative eta
At what time do we expect to finish the upload? (will be a value in the past for completed uploads)...
First event generated when a client requests a search to begin or when a namespace result automatical...
Internal state of a directory builder.
Definition: fs_directory.c:334
uint32_t availability_certainty
On how many total queries is the given availability_rank based?
An opaque structure a pointer to which is returned to the caller to be used to control the scanner...
int is_active
Is the download currently active.
char * GNUNET_FS_uri_ksk_to_string_fancy(const struct GNUNET_FS_Uri *uri)
Convert keyword URI to a human readable format (i.e.
Definition: fs_uri.c:155
int GNUNET_FS_uri_test_equal(const struct GNUNET_FS_Uri *u1, const struct GNUNET_FS_Uri *u2)
Test if two URIs are equal.
Definition: fs_uri.c:1209
Definition of a command line option.
Private ECC key encoded for transmission.
uint64_t offset
At what offset in the file is "data"?
Information for a file or directory that is about to be published.
Definition: fs_api.h:219
int GNUNET_FS_uri_test_sks(const struct GNUNET_FS_Uri *uri)
Is this a namespace URI?
Definition: fs_uri.c:1279
Notification that we suspended unindexing a file.
We have discovered a new namespace.
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3215
void GNUNET_FS_namespace_list_updateable(struct GNUNET_FS_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const char *next_id, GNUNET_FS_IdentifierProcessor ip, void *ip_cls)
List all of the identifiers in the namespace for which we could produce an update.
Definition: fs_namespace.c:667
int GNUNET_FS_uri_sks_get_namespace(const struct GNUNET_FS_Uri *uri, struct GNUNET_CRYPTO_EcdsaPublicKey *pseudonym)
Get the public key of a namespace from the given namespace URI.
Definition: fs_uri.c:1294
const char shortName
Short name of the option.
struct GNUNET_GETOPT_CommandLineOption GNUNET_FS_GETOPT_METADATA(char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_CONTAINER_MetaData **meta)
Allow user to specify metadata.
Definition: fs_getopt.c:252
Handle for controlling an unindexing operation.
Definition: fs_api.h:1334
We&#39;ve found all files (in the pre-pass).
struct GNUNET_FS_Uri * GNUNET_FS_uri_sks_create(const struct GNUNET_CRYPTO_EcdsaPublicKey *ns, const char *id)
Create an SKS URI from a namespace ID and an identifier.
Definition: fs_uri.c:916
struct GNUNET_FS_DownloadContext * GNUNET_FS_download_start(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta, const char *filename, const char *tempname, uint64_t offset, uint64_t length, uint32_t anonymity, enum GNUNET_FS_DownloadOptions options, void *cctx, struct GNUNET_FS_DownloadContext *parent)
Download parts of a file.
Definition: fs_download.c:2145
const struct GNUNET_FS_FileInformation * fi
Information about the file that is being publishd.
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:995
GNUNET_FS_PublishContinuation cont
Function to call once we&#39;re done.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
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.
int GNUNET_FS_uri_to_key(const struct GNUNET_FS_Uri *uri, struct GNUNET_HashCode *key)
Get a unique key from a URI.
Definition: fs_uri.c:103
Notification that we have stopped the process of uploading a file structure; no futher events will be...
int GNUNET_FS_uri_test_loc(const struct GNUNET_FS_Uri *uri)
Is this a location URI?
Definition: fs_uri.c:1392
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:2024
struct GNUNET_TIME_Relative current_probe_time
How long has the current probe been active?
uint32_t anonymity
What anonymity level is used for this upload?
struct GNUNET_FS_SearchContext * sc
Context for controlling the search, NULL for searches that were not explicitly triggered by the clien...
Do not append temporary data to the target file (for the IBlocks).
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
uint32_t anonymity_level
At which anonymity level should the block be shared? (0: no anonymity, 1: normal GAP, >1: with cover traffic).
struct GNUNET_FS_PublishKskContext * GNUNET_FS_publish_ksk(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *ksk_uri, const struct GNUNET_CONTAINER_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.
void GNUNET_FS_file_information_set_filename(struct GNUNET_FS_FileInformation *s, const char *filename)
Set the filename in the file information structure.
struct GNUNET_FS_ProgressInfo::@28::@29::@33::@36 resume
These values are only valid for GNUNET_FS_STATUS_PUBLISH_RESUME events.
const char * root
Root identifier for the namespace, can be NULL.
struct GNUNET_FS_ShareTreeItem * next
This is a doubly-linked list.
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:727
Notification that we have started to publish a file structure.
struct GNUNET_FS_ProgressInfo::@28::@30::@39::@41 start
These values are only valid for GNUNET_FS_STATUS_DOWNLOAD_START events.
Meta data to associate with a file, directory or namespace.
Notification that this download completed.
void GNUNET_FS_directory_builder_add(struct GNUNET_FS_DirectoryBuilder *bld, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *md, const void *data)
Add an entry to a directory.
Definition: fs_directory.c:384
int(* GNUNET_FS_IndexedFileProcessor)(void *cls, const char *filename, const struct GNUNET_HashCode *file_id)
Type of a function called by GNUNET_FS_get_indexed_files.
char ** keywords
Keywords start with a &#39;+&#39; if they are mandatory (in which case the &#39;+&#39; is NOT part of the keyword) an...
Definition: fs_api.h:179
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
static struct GNUNET_FS_Uri * topKeywords
Keywords provided via command-line option.
A node of a directory tree (produced by dirscanner)
void * GNUNET_FS_probe_stop(struct GNUNET_FS_SearchResult *sr)
Stop probe activity.
Definition: fs_search.c:542
Notification that we are making progress sharing a directory.
static char * value
Value of the record to add/remove.
struct GNUNET_FS_ShareTreeItem * children_head
This is a doubly-linked tree NULL for files and empty directories.
uint64_t size
How large is the file overall? For directories, this is only the size of the directory itself...
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
Information we store for each search result.
Definition: fs_api.h:484
Should we automatically trigger probes for search results to determine availability? (will create GNUNET_FS_STATUS_SEARCH_UPDATE events).
Only download from the local host, do not access remote systems (no P2P)
void *(* GNUNET_FS_ProgressCallback)(void *cls, const struct GNUNET_FS_ProgressInfo *info)
Notification of FS to a client about the progress of an operation.
struct GNUNET_FS_GetIndexedContext * GNUNET_FS_get_indexed_files(struct GNUNET_FS_Handle *h, GNUNET_FS_IndexedFileProcessor iterator, void *iterator_cls)
Iterate over all indexed files.
char * nuid
ID for future updates, NULL if we have no namespace or no updates.
Definition: fs_api.h:1194
enum GNUNET_FS_Status status
Specific status code (determines the event type).
Internal option used to flag this download as a &#39;probe&#39; for a search result.
void(* GNUNET_FS_IdentifierProcessor)(void *cls, const char *last_id, const struct GNUNET_FS_Uri *last_uri, const struct GNUNET_CONTAINER_MetaData *last_meta, const char *next_id)
Function called on updateable identifiers.
struct GNUNET_FS_SearchContext * GNUNET_FS_search_start(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, uint32_t anonymity, enum GNUNET_FS_SearchOptions options, void *cctx)
Start search for content.
Definition: fs_search.c:1611
void GNUNET_FS_publish_sks_cancel(struct GNUNET_FS_PublishSksContext *psc)
Abort the SKS publishing operation.
Definition: fs_namespace.c:493
const struct GNUNET_FS_Uri * uri
URI used for this download.
void(* GNUNET_FS_PublishContinuation)(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
Signature of a function called as the continuation of a KBlock or SBlock publication.
Last event when a search is being resumed; note that "GNUNET_FS_SEARCH_START" will not be generated i...
void GNUNET_FS_download_stop(struct GNUNET_FS_DownloadContext *dc, int do_delete)
Stop a download (aborts if download is incomplete).
Definition: fs_download.c:2332
struct GNUNET_FS_ProgressInfo::@28::@29 publish
Values for all "GNUNET_FS_STATUS_PUBLISH_*" events.
static int disable_extractor
Disable extractor option to use for publishing.
static char * option
Name of the option.
Definition: gnunet-config.c:38
static char buf[2048]
No options (use defaults for everything).
char * client_name
Name of our client.
Definition: fs_api.h:1065
uint32_t applicability_rank
Applicability rank (the larger, the better the result fits the search criteria).
GNUNET_FS_PublishOptions
Options for publishing.
Context for the KSK publication.
GNUNET_FS_OPTIONS
Options specified in the VARARGs portion of GNUNET_FS_start.
void(* GNUNET_FS_DirectoryEntryProcessor)(void *cls, const char *filename, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta, size_t length, const void *data)
Function used to process entries in a directory.
void GNUNET_FS_directory_scan_abort(struct GNUNET_FS_DirScanner *ds)
Abort the scan.
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:675
There was an internal error.
Handle for controlling a publication process.
Definition: fs_api.h:1165
Signals that this search was continued (unpaused).
A 512-bit hashcode.
const char * GNUNET_FS_file_information_get_filename(struct GNUNET_FS_FileInformation *s)
Obtain the filename from the file information structure.
int GNUNET_FS_uri_test_chk(const struct GNUNET_FS_Uri *uri)
Is this a file (or directory) URI?
Definition: fs_uri.c:1354
GNUNET_FS_DirScannerProgressUpdateReason
Progress reasons of the directory scanner.
const void * data
Data block we just published.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
uint64_t completed
How many bytes have we completed?
Notification that this download is no longer actively being pursued (back in the queue).
char * short_filename
Base name of the file/directory.
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
Last event when a search is being suspended; note that "GNUNET_FS_SEARCH_STOPPED" will not be generat...
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_HashCode key
The key used in the DHT.
Notification that the unindexing of this file was stopped (final event for this action).
Notification about progress with this download.
struct GNUNET_FS_ProgressInfo::@28::@29::@33::@38 error
These values are only valid for GNUNET_FS_STATUS_PUBLISH_ERROR events.
struct GNUNET_FS_ProgressInfo::@28::@31::@44::@52 ns
Values for GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE events.
GNUNET_FS_DownloadOptions
Options for downloading.
Select the desired amount of parallelism (this option should be followed by an "unsigned int" giving ...
const char * name
Notification that this download is now actively being pursued (as opposed to waiting in the queue)...
Last call to the progress function: we have finished scanning the directory.
uint32_t respect_offered
How much respect did we offer for downloading this block? (estimate, because we might have the same r...
Settings for publishing a block (which may of course also apply to an entire directory or file)...
Notification that the unindexing of this file was completed.
Notification that we completed sharing a file structure.
int is_directory
GNUNET_YES if this is a directory
char * filename
Name of the file/directory.
Maximum number of requests that should be pending at a given point in time (invidivual downloads may ...
Notification that this download is being resumed.
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
int GNUNET_FS_meta_data_test_for_directory(const struct GNUNET_CONTAINER_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:54
int GNUNET_FS_directory_list_contents(size_t size, const void *data, uint64_t offset, GNUNET_FS_DirectoryEntryProcessor dep, void *dep_cls)
Iterate over all entries in a directory.
Definition: fs_directory.c:177
struct GNUNET_CONTAINER_MetaData * meta
Metadata for this file or directory.
struct GNUNET_FS_Uri * GNUNET_FS_uri_ksk_create(const char *keywords, char **emsg)
Create an FS URI from a single user-supplied string of keywords.
Definition: fs_uri.c:1057
int GNUNET_FS_file_information_is_directory(const struct GNUNET_FS_FileInformation *ent)
Test if a given entry represents a directory.
struct GNUNET_FS_Handle * fsh
File-sharing handle that generated the event.
We&#39;ve started processing a file or directory.
void * sctx
Client context pointer for the associated search operation (specifically, context pointer for the spe...
Notification that this download is no longer part of a recursive download or search but now a &#39;stand-...
uint32_t replication_level
How often should we try to migrate the block to other peers? Only used if "CONTENT_PUSHING" is set to...
Event generated for each search result when the respective search is resumed.
Notification that we have resumed sharing a file structure.
struct GNUNET_FS_Uri * GNUNET_FS_uri_ksk_create_from_meta_data(const struct GNUNET_CONTAINER_MetaData *md)
Construct a keyword-URI from meta-data (take all entries in the meta-data and construct one large key...
Definition: fs_uri.c:1778
Private ECC key encoded for transmission.
size_t(* GNUNET_FS_DataReader)(void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
Function that provides data.
The identity of the host (wraps the signing key of the peer).
Event generated for each search result when the respective search is suspended.
Notification that an error was encountered sharing a file structure.
GNUNET_FS_ProgressCallback upcb
Function to call with updates on our progress.
Definition: fs_api.h:1070
Notification that we have suspended sharing a file structure.
struct GNUNET_FS_ProgressInfo::@28::@29::@33::@34 progress
These values are only valid for GNUNET_FS_STATUS_PUBLISH_PROGRESS events.
static char * next_id
Command-line option for namespace publishing: identifier for updates to this publication.
Do a recursive download (that is, automatically trigger the download of files in directories).
const struct GNUNET_FS_Uri * query
What query is used for this search (list of keywords or SKS identifier).
uint64_t GNUNET_FS_uri_chk_get_file_size(const struct GNUNET_FS_Uri *uri)
What is the size of the file that this URI refers to?
Definition: fs_uri.c:1368
configuration data
Definition: configuration.c:83
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.
void GNUNET_FS_share_tree_free(struct GNUNET_FS_ShareTreeItem *toplevel)
Release memory of a share item tree.
Definition: fs_sharetree.c:423
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:162
Handle for controlling a search.
Definition: fs_api.h:1492
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
void * upcb_cls
Closure for upcb.
Definition: fs_api.h:1075
struct GNUNET_FS_Uri * keywords
Keywords to use for KBlocks.
Definition: fs_api.h:249
We&#39;ve finished extracting meta data from a file.
void GNUNET_FS_file_information_destroy(struct GNUNET_FS_FileInformation *fi, GNUNET_FS_FileInformationProcessor cleaner, void *cleaner_cls)
Destroy publish-structure.
int GNUNET_FS_getopt_set_metadata(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx, void *scls, const char *option, const char *value)
Command-line option parser function that allows the user to specify one or more &#39;-m&#39; options with met...
struct GNUNET_FS_Uri * GNUNET_FS_uri_loc_get_uri(const struct GNUNET_FS_Uri *uri)
Obtain the URI of the content itself.
Definition: fs_uri.c:850
uint32_t content_priority
How important is it for us to store the block? If we run out of space, the highest-priority, non-expired blocks will be kept.
Only search the local host, do not search remote systems (no P2P)
unsigned int GNUNET_FS_uri_ksk_get_keyword_count(const struct GNUNET_FS_Uri *uri)
How many keywords are ANDed in this keyword URI?
Definition: fs_uri.c:709
Signals a problem with this search.
void * cont_cls
Closure for cont.
Definition: fs_namespace.c:367
struct GNUNET_FS_ProgressInfo::@28::@31::@44::@46 resume_result
These values are only valid for GNUNET_FS_STATUS_SEARCH_RESUME_RESULT events.
Context for GNUNET_FS_get_indexed_files().
struct GNUNET_FS_FileInformation * GNUNET_FS_file_information_create_from_reader(struct GNUNET_FS_Handle *h, void *client_info, uint64_t length, GNUNET_FS_DataReader reader, void *reader_cls, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_CONTAINER_MetaData *meta, int do_index, const struct GNUNET_FS_BlockOptions *bo)
Create an entry for a file in a publish-structure.
void GNUNET_FS_download_suspend(struct GNUNET_FS_DownloadContext *dc)
Suspend a download.
Definition: fs_download.c:2293
GNUNET_FS_Status
Possible status codes used in the callback for the various file-sharing operations.
We have additional data about the quality or availability of a search result.
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:939
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_search_pause(struct GNUNET_FS_SearchContext *sc)
Pause search.
Definition: fs_search.c:1631
Time for absolute times used by GNUnet, in microseconds.
struct GNUNET_CRYPTO_EcdsaPublicKey pseudonym
Public key of the namespace.
static struct GNUNET_FS_DirScanner * ds
Handle to the directory scanner (for recursive insertions).
char * GNUNET_FS_uri_sks_get_content_id(const struct GNUNET_FS_Uri *uri)
Get the content identifier of an SKS URI.
Definition: fs_uri.c:1314
struct GNUNET_FS_DownloadContext * GNUNET_FS_download_start_from_search(struct GNUNET_FS_Handle *h, struct GNUNET_FS_SearchResult *sr, const char *filename, const char *tempname, uint64_t offset, uint64_t length, uint32_t anonymity, enum GNUNET_FS_DownloadOptions options, void *cctx)
Download parts of a file based on a search result.
Definition: fs_download.c:2216
const char * filename
Name of the file being published; can be NULL.
struct GNUNET_FS_PublishContext * pc
Context for controlling the upload.
void GNUNET_FS_uri_ksk_remove_keyword(struct GNUNET_FS_Uri *uri, const char *keyword)
Remove the given keyword from the set of keywords represented by the URI.
Definition: fs_uri.c:787
Notification that we resumed unindexing of a file.
void GNUNET_FS_download_resume(struct GNUNET_FS_DownloadContext *dc)
Resume a suspended download.
Definition: fs_download.c:2305
uint64_t data_len
Length of the data block.
No options (use defaults for everything).
Notification that this download was stopped (final event with respect to this action).
Signals that this search was paused.
struct GNUNET_FS_ProgressInfo::@28::@32 unindex
Values for all "GNUNET_FS_STATUS_UNINDEX_*" events.
struct GNUNET_FS_DirectoryBuilder * GNUNET_FS_directory_builder_create(const struct GNUNET_CONTAINER_MetaData *mdir)
Create a directory builder.
Definition: fs_directory.c:358
Notification that we encountered an error unindexing a file.
int is_paused
Is this search currently paused?
struct GNUNET_FS_ProgressInfo::@28::@31::@44::@49 result_stopped
These values are only valid for GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED events.
uint32_t num_transmissions
How often did we transmit the request? (estimate, because we might have the same request pending for ...
struct GNUNET_FS_Uri * ksk_uri
Keywords to use.
void GNUNET_FS_search_stop(struct GNUNET_FS_SearchContext *sc)
Stop search for content.
Definition: fs_search.c:1770
Notification that this download encountered an error.
const char * GNUNET_FS_file_information_get_id(struct GNUNET_FS_FileInformation *s)
Obtain the name under which this file information structure is stored on disk.
static struct GNUNET_FS_BlockOptions bo
Options we set for published blocks.
static char * pseudonym
Command-line option identifying the pseudonym to use for the publication.
Argument given to the progress callback with information about what is going on.
Time for relative time used by GNUnet, in microseconds.
Is persistence of operations desired? (will create SUSPEND/RESUME events).
void * cctx
Client context pointer (set the last time by the client for this operation; initially NULL on START/R...
We&#39;re having trouble accessing a file (soft-error); it will be ignored.
const struct GNUNET_FS_Uri * chk_uri
URI of the file (if the download had been completed)
struct GNUNET_FS_ProgressInfo::@28::@31::@44::@48 result_suspend
These values are only valid for GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND events.
enum GNUNET_FS_Flags flags
General flags.
Definition: fs_api.h:1148
const struct GNUNET_FS_Uri * sks_uri
SKS URI of the file (if the download had been completed)
struct GNUNET_FS_DownloadContext * dc
Context for controlling the download.
void * cont_cls
Closure for cont.