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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
#ifndef GNS_RESOLVER_H
#define GNS_RESOLVER_H
#include "gns.h"
#define DHT_OPERATION_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3)
#define DHT_LOOKUP_TIMEOUT DHT_OPERATION_TIMEOUT
#define DHT_GNS_REPLICATION_LEVEL 5
#define MAX_DNS_LABEL_LENGTH 63
/*
* DLL to hold the authority chain
* we had to pass in the resolution process
*/
struct AuthorityChain
{
struct AuthorityChain *prev;
struct AuthorityChain *next;
/* the zone hash of the authority */
GNUNET_HashCode zone;
/* (local) name of the authority */
char* name;
/* was the ns entry fresh */
int fresh;
};
/* handle to a resolution process */
struct ResolverHandle;
/**
* processor for a resultion result
*
* @param cls the closure
* @param rh the resolution handle
* @param rd_count number of results
* @pram rd resukt data
*/
typedef void (*RecordLookupProcessor) (void *cls,
uint32_t rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd);
/**
* processor for a shorten result
*
* @param cls the closure
* @param name shortened name
*/
typedef void (*ShortenResultProcessor) (void *cls, const char* name);
/**
* processor for an authority result
*
* @param cls the closure
* @param name name
*/
typedef void (*GetAuthorityResultProcessor) (void *cls, const char* name);
/**
* processor for a resultion result
*
* @param cls the closure
* @param rh the resolution handle
* @param rd_count number of results
* @param rd result data
*/
typedef void (*ResolutionResultProcessor) (void *cls,
struct ResolverHandle *rh,
uint32_t rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd);
/**
* Resoltion status indicator
* EXISTS: the name to lookup exists
* EXPIRED: the name in the record expired
*/
enum ResolutionStatus
{
EXISTS = 1,
EXPIRED = 2
};
/**
* Handle to a currenty pending resolution
*/
struct ResolverHandle
{
/* The name to resolve */
char *name;
/* has this query been answered? how many matches */
int answered;
/* the authoritative zone to query */
GNUNET_HashCode authority;
/* the name of the authoritative zone to query */
char *authority_name;
/**
* we have an authority in namestore that
* may be able to resolve
*/
int authority_found;
/* a handle for dht lookups. should be NULL if no lookups are in progress */
struct GNUNET_DHT_GetHandle *get_handle;
/* timeout task for dht lookups */
GNUNET_SCHEDULER_TaskIdentifier dht_timeout_task;
/* called when resolution phase finishes */
ResolutionResultProcessor proc;
/* closure passed to proc */
void* proc_cls;
/* DLL to store the authority chain */
struct AuthorityChain *authority_chain_head;
/* DLL to store the authority chain */
struct AuthorityChain *authority_chain_tail;
/* status of the resolution result */
enum ResolutionStatus status;
};
/**
* Handle to a record lookup
*/
struct RecordLookupHandle
{
/* the record type to look up */
enum GNUNET_GNS_RecordType record_type;
/* the name to look up */
char *name;
/* Method to call on record resolution result */
RecordLookupProcessor proc;
/* closure to pass to proc */
void* proc_cls;
};
/**
* Handle to a shorten context
*/
struct NameShortenHandle
{
/* Method to call on shorten result */
ShortenResultProcessor proc;
/* closure to pass to proc */
void* proc_cls;
};
/**
* Handle to a get authority context
*/
struct GetNameAuthorityHandle
{
/* the name to look up authority for */
char* name;
/* Method to call on result */
GetAuthorityResultProcessor proc;
/* closure to pass to proc */
void* proc_cls;
};
/**
* Lookup of a record in a specific zone
* calls lookup result processor on result
*
* @param zone the root zone
* @param record_type the record type to look up
* @param proc the processor to call
* @param cls the closure to pass to proc
*/
void
gns_resolver_lookup_record(GNUNET_HashCode zone,
uint32_t record_type,
const char* name,
RecordLookupProcessor proc,
void* cls);
void
gns_resolver_shorten_name(GNUNET_HashCode zone,
const char* name,
ShortenResultProcessor proc,
void* cls);
/**
* Tries to resolve the authority for name
* in our namestore
*
* @param zone the root zone to look up for
* @param name the name to lookup up
* @param proc the processor to call when finished
* @param cls the closure to pass to the processor
*/
void
gns_resolver_get_authority(GNUNET_HashCode zone,
const char* name,
GetAuthorityResultProcessor proc,
void* cls);
#endif
|
