1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
/*
This file is part of GNUnet.
Copyright (C) 2012, 2017 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License,
or (at your option) any later version.
GNUnet is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
*/
/**
* @file fs/gnunet-service-fs_cadet.h
* @brief non-anonymous file-transfer
* @author Christian Grothoff
*/
#ifndef GNUNET_SERVICE_FS_CADET_H
#define GNUNET_SERVICE_FS_CADET_H
/**
* Handle for a request that is going out via cadet API.
*/
struct GSF_CadetRequest;
/**
* Function called with a reply from the cadet.
*
* @param cls closure
* @param type type of the block, ANY on error
* @param expiration expiration time for the block
* @param data_size number of bytes in @a data, 0 on error
* @param data reply block data, NULL on error
*/
typedef void
(*GSF_CadetReplyProcessor)(void *cls,
enum GNUNET_BLOCK_Type type,
struct GNUNET_TIME_Absolute expiration,
size_t data_size,
const void *data);
/**
* Look for a block by directly contacting a particular peer.
*
* @param target peer that should have the block
* @param query hash to query for the block
* @param type desired type for the block
* @param proc function to call with result
* @param proc_cls closure for @a proc
* @return handle to cancel the operation
*/
struct GSF_CadetRequest *
GSF_cadet_query (const struct GNUNET_PeerIdentity *target,
const struct GNUNET_HashCode *query,
enum GNUNET_BLOCK_Type type,
GSF_CadetReplyProcessor proc,
void *proc_cls);
/**
* Function called on each active cadets to shut them down.
*
* @param cls NULL
* @param key target peer, unused
* @param value the `struct CadetHandle` to destroy
* @return #GNUNET_YES (continue to iterate)
*/
int
GSF_cadet_release_clients (void *cls,
const struct GNUNET_PeerIdentity *key,
void *value);
/**
* Cancel an active request; must not be called after 'proc'
* was calld.
*
* @param sr request to cancel
*/
void
GSF_cadet_query_cancel (struct GSF_CadetRequest *sr);
/**
* Initialize subsystem for non-anonymous file-sharing.
*/
void
GSF_cadet_start_server (void);
/**
* Shutdown subsystem for non-anonymous file-sharing.
*/
void
GSF_cadet_stop_server (void);
/**
* Cadet channel for creating outbound channels.
*/
extern struct GNUNET_CADET_Handle *cadet_handle;
/**
* Map from peer identities to 'struct CadetHandles' with cadet
* channels to those peers.
*/
extern struct GNUNET_CONTAINER_MultiPeerMap *cadet_map;
GNUNET_NETWORK_STRUCT_BEGIN
/**
* Query from one peer, asking the other for CHK-data.
*/
struct CadetQueryMessage
{
/**
* Type is GNUNET_MESSAGE_TYPE_FS_CADET_QUERY.
*/
struct GNUNET_MessageHeader header;
/**
* Block type must be DBLOCK or IBLOCK.
*/
uint32_t type GNUNET_PACKED;
/**
* Query hash from CHK (hash of encrypted block).
*/
struct GNUNET_HashCode query;
};
/**
* Reply to a CadetQueryMessage.
*/
struct CadetReplyMessage
{
/**
* Type is GNUNET_MESSAGE_TYPE_FS_CADET_REPLY.
*/
struct GNUNET_MessageHeader header;
/**
* Block type must be DBLOCK or IBLOCK.
*/
uint32_t type GNUNET_PACKED;
/**
* Expiration time for the block.
*/
struct GNUNET_TIME_AbsoluteNBO expiration;
/* followed by the encrypted block */
};
GNUNET_NETWORK_STRUCT_END
#endif
|
