Line data Source code
1 : #include "fd_http_resolver.h"
2 : #include "fd_ssresolve.h"
3 :
4 : #include "../../../util/log/fd_log.h"
5 : #include "../../../util/fd_util.h"
6 :
7 : #include <poll.h>
8 : #include <errno.h>
9 : #include <unistd.h>
10 : #include <sys/socket.h>
11 : #include <netinet/in.h>
12 : #include <netinet/tcp.h>
13 :
14 0 : #define PEER_STATE_UNRESOLVED (0)
15 0 : #define PEER_STATE_REFRESHING (1)
16 0 : #define PEER_STATE_VALID (2)
17 0 : #define PEER_STATE_INVALID (3)
18 :
19 0 : #define PEER_DEADLINE_NANOS_VALID (5L*1000L*1000L*1000L) /* 5 seconds */
20 0 : #define PEER_DEADLINE_NANOS_RESOLVE (1L*1000L*1000L*1000L) /* 1 second */
21 0 : #define PEER_DEADLINE_NANOS_INVALID (5L*1000L*1000L*1000L) /* 5 seconds */
22 :
23 : struct fd_ssresolve_peer {
24 : fd_ip4_port_t addr;
25 : fd_ssinfo_t ssinfo;
26 :
27 : fd_ssresolve_t * full_ssresolve;
28 : fd_ssresolve_t * inc_ssresolve;
29 :
30 : struct {
31 : ulong next;
32 : } pool;
33 :
34 : struct {
35 : ulong next;
36 : ulong prev;
37 : } deadline;
38 :
39 : struct {
40 : ulong idx;
41 : } fd;
42 :
43 : int state;
44 : long deadline_nanos;
45 : };
46 : typedef struct fd_ssresolve_peer fd_ssresolve_peer_t;
47 :
48 : #define POOL_NAME peer_pool
49 0 : #define POOL_T fd_ssresolve_peer_t
50 : #define POOL_IDX_T ulong
51 0 : #define POOL_NEXT pool.next
52 : #include "../../../util/tmpl/fd_pool.c"
53 :
54 : #define DLIST_NAME deadline_list
55 : #define DLIST_ELE_T fd_ssresolve_peer_t
56 0 : #define DLIST_PREV deadline.prev
57 0 : #define DLIST_NEXT deadline.next
58 : #include "../../../util/tmpl/fd_dlist.c"
59 :
60 : struct fd_http_resolver_private {
61 : fd_ssresolve_peer_t * pool;
62 : deadline_list_t * unresolved;
63 : deadline_list_t * resolving;
64 : deadline_list_t * valid;
65 : deadline_list_t * invalid;
66 :
67 : ulong fds_len;
68 : struct pollfd * fds;
69 : ulong * fds_idx;
70 :
71 : int incremental_snapshot_fetch;
72 :
73 : void * cb_arg;
74 : fd_http_resolver_on_resolve_fn_t on_resolve_cb;
75 :
76 : ulong magic; /* ==FD_HTTP_RESOLVER_MAGIC */
77 : };
78 :
79 : FD_FN_CONST ulong
80 0 : fd_http_resolver_align( void ) {
81 0 : return fd_ulong_max( alignof(fd_http_resolver_t), fd_ulong_max( peer_pool_align(), fd_ulong_max( deadline_list_align(), fd_ulong_max( alignof(struct pollfd), alignof(ulong) ) ) ) );
82 0 : }
83 :
84 : FD_FN_CONST ulong
85 0 : fd_http_resolver_footprint( ulong peers_cnt ) {
86 0 : ulong l;
87 0 : l = FD_LAYOUT_INIT;
88 0 : l = FD_LAYOUT_APPEND( l, alignof(fd_http_resolver_t), sizeof(fd_http_resolver_t) );
89 0 : l = FD_LAYOUT_APPEND( l, peer_pool_align(), peer_pool_footprint( peers_cnt ) );
90 0 : l = FD_LAYOUT_APPEND( l, deadline_list_align(), deadline_list_footprint() );
91 0 : l = FD_LAYOUT_APPEND( l, deadline_list_align(), deadline_list_footprint() );
92 0 : l = FD_LAYOUT_APPEND( l, deadline_list_align(), deadline_list_footprint() );
93 0 : l = FD_LAYOUT_APPEND( l, deadline_list_align(), deadline_list_footprint() );
94 0 : l = FD_LAYOUT_APPEND( l, alignof(struct pollfd), 2UL*peers_cnt*sizeof(struct pollfd) );
95 0 : l = FD_LAYOUT_APPEND( l, alignof(ulong), 2UL*peers_cnt*sizeof(ulong) );
96 :
97 0 : for( ulong i=0UL; i<peers_cnt*2UL; i++ ) {
98 0 : l = FD_LAYOUT_APPEND( l, fd_ssresolve_align(), fd_ssresolve_footprint() );
99 0 : }
100 0 : return FD_LAYOUT_FINI( l, fd_http_resolver_align() );
101 0 : }
102 :
103 : void *
104 : fd_http_resolver_new( void * shmem,
105 : ulong peers_cnt,
106 : int incremental_snapshot_fetch,
107 : fd_http_resolver_on_resolve_fn_t on_resolve_cb,
108 0 : void * cb_arg ) {
109 0 : if( FD_UNLIKELY( !shmem ) ) {
110 0 : FD_LOG_WARNING(( "NULL shmem" ));
111 0 : return NULL;
112 0 : }
113 :
114 0 : if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)shmem, fd_http_resolver_align() ) ) ) {
115 0 : FD_LOG_WARNING(( "unaligned shmem" ));
116 0 : return NULL;
117 0 : }
118 :
119 0 : if( FD_UNLIKELY( peers_cnt<1UL ) ) {
120 0 : FD_LOG_WARNING(( "max_peers must be at least 1" ));
121 0 : return NULL;
122 0 : }
123 :
124 0 : FD_SCRATCH_ALLOC_INIT( l, shmem );
125 0 : fd_http_resolver_t * resolver = FD_SCRATCH_ALLOC_APPEND( l, fd_http_resolver_align(), sizeof(fd_http_resolver_t) );
126 0 : void * _pool = FD_SCRATCH_ALLOC_APPEND( l, peer_pool_align(), peer_pool_footprint( peers_cnt ) );
127 0 : void * _unresolved = FD_SCRATCH_ALLOC_APPEND( l, deadline_list_align(), deadline_list_footprint() );
128 0 : void * _resolving = FD_SCRATCH_ALLOC_APPEND( l, deadline_list_align(), deadline_list_footprint() );
129 0 : void * _invalid = FD_SCRATCH_ALLOC_APPEND( l, deadline_list_align(), deadline_list_footprint() );
130 0 : void * _valid = FD_SCRATCH_ALLOC_APPEND( l, deadline_list_align(), deadline_list_footprint() );
131 0 : struct pollfd * fds = FD_SCRATCH_ALLOC_APPEND( l, alignof(struct pollfd), 2UL*peers_cnt*sizeof(struct pollfd) );
132 0 : ulong * fds_idx = FD_SCRATCH_ALLOC_APPEND( l, alignof(ulong), 2UL*peers_cnt*sizeof(ulong) );
133 :
134 0 : resolver->pool = peer_pool_join( peer_pool_new( _pool, peers_cnt ) );
135 0 : resolver->unresolved = deadline_list_join( deadline_list_new( _unresolved ) );
136 0 : resolver->resolving = deadline_list_join( deadline_list_new( _resolving ) );
137 0 : resolver->invalid = deadline_list_join( deadline_list_new( _invalid ) );
138 0 : resolver->valid = deadline_list_join( deadline_list_new( _valid ) );
139 :
140 0 : resolver->fds_len = 0UL;
141 0 : resolver->fds = fds;
142 0 : resolver->fds_idx = fds_idx;
143 :
144 0 : for( ulong i=0UL; i<peer_pool_max( resolver->pool ); i++ ) {
145 0 : void * _full_ssresolve = FD_SCRATCH_ALLOC_APPEND( l, fd_ssresolve_align(), fd_ssresolve_footprint() );
146 0 : void * _inc_ssresolve = FD_SCRATCH_ALLOC_APPEND( l, fd_ssresolve_align(), fd_ssresolve_footprint() );
147 0 : resolver->pool[ i ].full_ssresolve = fd_ssresolve_join( fd_ssresolve_new( _full_ssresolve ) );
148 0 : resolver->pool[ i ].inc_ssresolve = fd_ssresolve_join( fd_ssresolve_new( _inc_ssresolve ) );
149 0 : }
150 :
151 0 : resolver->incremental_snapshot_fetch = incremental_snapshot_fetch;
152 0 : resolver->cb_arg = cb_arg;
153 0 : resolver->on_resolve_cb = on_resolve_cb;
154 :
155 0 : FD_COMPILER_MFENCE();
156 0 : FD_VOLATILE( resolver->magic ) = FD_HTTP_RESOLVER_MAGIC;
157 0 : FD_COMPILER_MFENCE();
158 :
159 0 : return (void *)resolver;
160 0 : }
161 :
162 : fd_http_resolver_t *
163 0 : fd_http_resolver_join( void * shresolver ) {
164 0 : if( FD_UNLIKELY( !shresolver ) ) {
165 0 : FD_LOG_WARNING(( "NULL shresolver" ));
166 0 : return NULL;
167 0 : }
168 :
169 0 : if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)shresolver, fd_http_resolver_align() ) ) ) {
170 0 : FD_LOG_WARNING(( "misaligned shresolver" ));
171 0 : return NULL;
172 0 : }
173 :
174 0 : fd_http_resolver_t * resolver = (fd_http_resolver_t *)shresolver;
175 :
176 0 : if( FD_UNLIKELY( resolver->magic!=FD_HTTP_RESOLVER_MAGIC ) ) {
177 0 : FD_LOG_WARNING(( "bad magic" ));
178 0 : return NULL;
179 0 : }
180 :
181 0 : return resolver;
182 0 : }
183 :
184 : void
185 : fd_http_resolver_add( fd_http_resolver_t * resolver,
186 0 : fd_ip4_port_t addr ) {
187 0 : if( !peer_pool_free( resolver->pool ) ) {
188 0 : FD_LOG_ERR(( "peer pool exhausted" ));
189 0 : }
190 0 : fd_ssresolve_peer_t * peer = peer_pool_ele_acquire( resolver->pool );
191 0 : peer->state = PEER_STATE_UNRESOLVED;
192 0 : peer->addr = addr;
193 0 : peer->fd.idx = ULONG_MAX;
194 0 : peer->ssinfo.full.slot = ULONG_MAX;
195 0 : peer->ssinfo.incremental.base_slot = ULONG_MAX;
196 0 : peer->ssinfo.incremental.slot = ULONG_MAX;
197 0 : deadline_list_ele_push_tail( resolver->unresolved, peer, resolver->pool );
198 0 : }
199 :
200 : static int
201 : create_socket( fd_http_resolver_t * resolver,
202 0 : fd_ssresolve_peer_t * peer ) {
203 0 : int sockfd = socket( AF_INET, SOCK_STREAM|SOCK_NONBLOCK, 0 );
204 0 : if( FD_UNLIKELY( -1==sockfd ) ) FD_LOG_ERR(( "socket failed (%i-%s)", errno, strerror( errno ) ));
205 :
206 0 : int optval = 1;
207 0 : if( FD_UNLIKELY( -1==setsockopt( sockfd, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(int) ) ) ) {
208 0 : FD_LOG_ERR(( "setsockopt() failed (%d-%s)", errno, fd_io_strerror( errno ) ));
209 0 : }
210 :
211 0 : struct sockaddr_in addr = {
212 0 : .sin_family = AF_INET,
213 0 : .sin_port = fd_ushort_bswap( peer->addr.port ),
214 0 : .sin_addr = { .s_addr = peer->addr.addr }
215 0 : };
216 :
217 0 : if( FD_UNLIKELY( -1==connect( sockfd, fd_type_pun( &addr ), sizeof(addr) ) && errno!=EINPROGRESS ) ) {
218 0 : if( FD_UNLIKELY( -1==close( sockfd ) ) ) FD_LOG_ERR(( "close() failed (%i-%s)", errno, fd_io_strerror( errno ) ));
219 0 : return -1;
220 0 : }
221 :
222 0 : resolver->fds[ resolver->fds_len ] = (struct pollfd){
223 0 : .fd = sockfd,
224 0 : .events = POLLIN|POLLOUT,
225 0 : .revents = 0
226 0 : };
227 :
228 0 : return 0;
229 0 : }
230 :
231 : static int
232 : peer_connect( fd_http_resolver_t * resolver,
233 0 : fd_ssresolve_peer_t * peer ) {
234 0 : int err;
235 0 : err = create_socket( resolver, peer ); /* full */
236 0 : if( FD_UNLIKELY( err ) ) return err;
237 0 : resolver->fds_idx[ resolver->fds_len ] = peer_pool_idx( resolver->pool, peer );
238 0 : peer->fd.idx = resolver->fds_len;
239 0 : resolver->fds_len++;
240 0 : fd_ssresolve_init( peer->full_ssresolve, peer->addr, resolver->fds[ peer->fd.idx ].fd, 1 );
241 :
242 0 : if( FD_LIKELY( resolver->incremental_snapshot_fetch ) ) {
243 0 : err = create_socket( resolver, peer ); /* incremental */
244 0 : if( FD_UNLIKELY( err ) ) return err;
245 0 : resolver->fds_idx[ resolver->fds_len ] = peer_pool_idx( resolver->pool, peer );
246 0 : resolver->fds_len++;
247 0 : fd_ssresolve_init( peer->inc_ssresolve, peer->addr, resolver->fds[ peer->fd.idx+1UL ].fd, 0 );
248 0 : } else {
249 0 : resolver->fds[ resolver->fds_len ] = (struct pollfd) {
250 0 : .fd = -1,
251 0 : .events = 0,
252 0 : .revents = 0
253 0 : };
254 0 : resolver->fds_idx[ resolver->fds_len ] = ULONG_MAX;
255 0 : resolver->fds_len++;
256 0 : }
257 :
258 0 : return 0;
259 0 : }
260 :
261 : static inline void
262 : remove_peer( fd_http_resolver_t * resolver,
263 0 : ulong idx ) {
264 0 : FD_TEST( idx<resolver->fds_len );
265 :
266 : /* FIXME... */
267 0 : close( resolver->fds[ idx ].fd );
268 0 : close( resolver->fds[ idx+1UL ].fd );
269 :
270 0 : if( FD_UNLIKELY( resolver->fds_len==2UL ) ) {
271 0 : resolver->fds_len = 0UL;
272 0 : return;
273 0 : }
274 :
275 0 : resolver->fds[ idx ] = resolver->fds[ resolver->fds_len-2UL ];
276 0 : resolver->fds_idx[ idx ] = resolver->fds_idx[ resolver->fds_len-2UL ];
277 :
278 0 : resolver->fds[ idx+1UL ] = resolver->fds[ resolver->fds_len-1UL ];
279 0 : resolver->fds_idx[ idx+1UL ] = resolver->fds_idx[ resolver->fds_len-1UL ];
280 :
281 0 : fd_ssresolve_peer_t * peer = peer_pool_ele( resolver->pool, resolver->fds_idx[ idx ] );
282 0 : peer->fd.idx = idx;
283 :
284 0 : resolver->fds_len -= 2UL;
285 0 : }
286 :
287 : static inline void
288 : unresolve_peer( fd_http_resolver_t * resolver,
289 : fd_ssresolve_peer_t * peer,
290 0 : long now ) {
291 0 : FD_TEST( peer->state==PEER_STATE_UNRESOLVED || peer->state==PEER_STATE_REFRESHING );
292 0 : remove_peer( resolver, peer->fd.idx );
293 0 : deadline_list_ele_remove( resolver->resolving, peer, resolver->pool );
294 0 : peer->state = PEER_STATE_INVALID;
295 0 : peer->deadline_nanos = now + PEER_DEADLINE_NANOS_INVALID;
296 0 : deadline_list_ele_push_tail( resolver->invalid, peer, resolver->pool );
297 0 : }
298 :
299 : static inline int
300 : poll_resolve( fd_http_resolver_t * resolver,
301 : struct pollfd * pfd,
302 : fd_ssresolve_peer_t * peer,
303 : fd_ssresolve_t * ssresolve,
304 : ulong idx,
305 0 : long now ) {
306 0 : if( FD_LIKELY( pfd->revents & POLLOUT ) ) {
307 0 : int res = fd_ssresolve_advance_poll_out( ssresolve );
308 :
309 0 : if( FD_UNLIKELY( res==FD_SSRESOLVE_ADVANCE_ERROR ) ) {
310 0 : unresolve_peer( resolver, peer_pool_ele( resolver->pool, resolver->fds_idx[ idx ] ), now );
311 0 : return -1;
312 0 : }
313 0 : }
314 :
315 0 : if( FD_LIKELY( pfd->revents & POLLIN ) ) {
316 0 : fd_ssresolve_result_t resolve_result;
317 0 : int res = fd_ssresolve_advance_poll_in( ssresolve, &resolve_result );
318 :
319 0 : if( FD_UNLIKELY( res==FD_SSRESOLVE_ADVANCE_ERROR ) ) {
320 0 : unresolve_peer( resolver, peer_pool_ele( resolver->pool, resolver->fds_idx[ idx ] ), now );
321 0 : return -1;
322 0 : } else if( FD_UNLIKELY( res==FD_SSRESOLVE_ADVANCE_AGAIN ) ) {
323 0 : return -1;
324 0 : } else { /* FD_SSRESOLVE_ADVANCE_SUCCESS */
325 0 : FD_TEST( peer->deadline_nanos>now );
326 :
327 0 : if( resolve_result.base_slot==ULONG_MAX ) {
328 0 : peer->ssinfo.full.slot = resolve_result.slot;
329 0 : } else {
330 0 : peer->ssinfo.incremental.base_slot = resolve_result.base_slot;
331 0 : peer->ssinfo.incremental.slot = resolve_result.slot;
332 0 : }
333 0 : }
334 0 : }
335 :
336 0 : return 0;
337 0 : }
338 :
339 : static inline void
340 : poll_advance( fd_http_resolver_t * resolver,
341 0 : long now ) {
342 0 : if( FD_LIKELY( !resolver->fds_len ) ) return;
343 :
344 0 : int nfds = fd_syscall_poll( resolver->fds, (uint)resolver->fds_len, 0 );
345 0 : if( FD_LIKELY( !nfds ) ) return;
346 0 : else if( FD_UNLIKELY( -1==nfds && errno==EINTR ) ) return;
347 0 : else if( FD_UNLIKELY( -1==nfds ) ) FD_LOG_ERR(( "poll failed (%i-%s)", errno, strerror( errno ) ));
348 :
349 0 : for( ulong i=0UL; i<resolver->fds_len; i++) {
350 :
351 0 : struct pollfd * pfd = &resolver->fds[ i ];
352 0 : if( FD_UNLIKELY( pfd->fd==-1 ) ) continue;
353 0 : if( FD_UNLIKELY( pfd->revents & (POLLERR|POLLHUP) ) ) {
354 0 : unresolve_peer( resolver, peer_pool_ele( resolver->pool, resolver->fds_idx[ i ] ), now );
355 0 : continue;
356 0 : }
357 :
358 0 : fd_ssresolve_peer_t * peer = peer_pool_ele( resolver->pool, resolver->fds_idx[ i ] );
359 0 : int full = i&1UL ? 0 : 1; /* even indices are full, odd indices are incremental */
360 0 : fd_ssresolve_t * ssresolve = full ? peer->full_ssresolve : peer->inc_ssresolve;
361 :
362 0 : if( FD_LIKELY( !fd_ssresolve_is_done( ssresolve ) ) ) {
363 0 : int res = poll_resolve( resolver, pfd, peer, ssresolve, i, now );
364 0 : if( FD_UNLIKELY( res ) ) continue;
365 0 : }
366 :
367 : /* Once both the full and incremental snapshots are resolved, we can
368 : mark the peer valid and remove the peer from the list of peers to
369 : ping. */
370 0 : if( FD_LIKELY( fd_ssresolve_is_done( peer->full_ssresolve ) &&
371 0 : (!resolver->incremental_snapshot_fetch || fd_ssresolve_is_done( peer->inc_ssresolve ) ) ) ) {
372 0 : peer->state = PEER_STATE_VALID;
373 0 : peer->deadline_nanos = now + PEER_DEADLINE_NANOS_VALID;
374 :
375 0 : deadline_list_ele_remove( resolver->resolving, peer, resolver->pool );
376 0 : deadline_list_ele_push_tail( resolver->valid, peer, resolver->pool );
377 0 : remove_peer( resolver, peer->fd.idx );
378 :
379 0 : resolver->on_resolve_cb( resolver->cb_arg, peer->addr, &peer->ssinfo );
380 0 : }
381 0 : }
382 0 : }
383 :
384 : void
385 : fd_http_resolver_advance( fd_http_resolver_t * resolver,
386 : long now,
387 0 : fd_sspeer_selector_t * selector ) {
388 0 : while( !deadline_list_is_empty( resolver->unresolved, resolver->pool ) ) {
389 0 : fd_ssresolve_peer_t * peer = deadline_list_ele_pop_head( resolver->unresolved, resolver->pool );
390 :
391 0 : FD_LOG_INFO(( "resolving " FD_IP4_ADDR_FMT ":%hu", FD_IP4_ADDR_FMT_ARGS( peer->addr.addr ), peer->addr.port ));
392 0 : int result = peer_connect( resolver, peer );
393 0 : if( FD_UNLIKELY( -1==result ) ) {
394 0 : peer->state = PEER_STATE_INVALID;
395 0 : peer->deadline_nanos = now + PEER_DEADLINE_NANOS_INVALID;
396 0 : deadline_list_ele_push_tail( resolver->invalid, peer, resolver->pool );
397 0 : } else {
398 0 : peer->state = PEER_STATE_REFRESHING;
399 0 : peer->deadline_nanos = now + PEER_DEADLINE_NANOS_RESOLVE;
400 0 : deadline_list_ele_push_tail( resolver->resolving, peer, resolver->pool );
401 0 : }
402 0 : }
403 :
404 0 : while( !deadline_list_is_empty( resolver->resolving, resolver->pool ) ) {
405 0 : fd_ssresolve_peer_t * peer = deadline_list_ele_peek_head( resolver->resolving, resolver->pool );
406 0 : if( FD_LIKELY( peer->deadline_nanos>now ) ) break;
407 :
408 0 : deadline_list_ele_pop_head( resolver->resolving, resolver->pool );
409 0 : peer->state = PEER_STATE_INVALID;
410 0 : peer->deadline_nanos = now + PEER_DEADLINE_NANOS_INVALID;
411 0 : deadline_list_ele_push_tail( resolver->invalid, peer, resolver->pool );
412 0 : remove_peer( resolver, peer->fd.idx );
413 :
414 0 : fd_sspeer_selector_remove( selector, peer->addr );
415 0 : }
416 :
417 0 : while( !deadline_list_is_empty( resolver->invalid, resolver->pool ) ) {
418 0 : fd_ssresolve_peer_t * peer = deadline_list_ele_peek_head( resolver->invalid, resolver->pool );
419 0 : if( FD_LIKELY( peer->deadline_nanos>now ) ) break;
420 :
421 0 : deadline_list_ele_pop_head( resolver->invalid, resolver->pool );
422 :
423 0 : peer->state = PEER_STATE_UNRESOLVED;
424 0 : peer->deadline_nanos = 0L;
425 0 : deadline_list_ele_push_tail( resolver->unresolved, peer, resolver->pool );
426 0 : }
427 :
428 0 : while( !deadline_list_is_empty( resolver->valid, resolver->pool ) ) {
429 0 : fd_ssresolve_peer_t * peer = deadline_list_ele_peek_head( resolver->valid, resolver->pool );
430 0 : if( FD_LIKELY( peer->deadline_nanos>now ) ) break;
431 :
432 0 : deadline_list_ele_pop_head( resolver->valid, resolver->pool );
433 :
434 0 : int result = peer_connect( resolver, peer );
435 0 : if( FD_UNLIKELY( -1==result ) ) {
436 0 : peer->state = PEER_STATE_INVALID;
437 0 : peer->deadline_nanos = now + PEER_DEADLINE_NANOS_INVALID;
438 0 : deadline_list_ele_push_tail( resolver->invalid, peer, resolver->pool );
439 0 : fd_sspeer_selector_remove( selector, peer->addr );
440 0 : } else {
441 0 : peer->state = PEER_STATE_REFRESHING;
442 0 : peer->deadline_nanos = now + PEER_DEADLINE_NANOS_RESOLVE;
443 0 : deadline_list_ele_push_tail( resolver->resolving, peer, resolver->pool );
444 0 : }
445 0 : }
446 :
447 0 : poll_advance( resolver, now );
448 0 : }
|
