1 /* 2 * services/outside_network.h - listen to answers from the network 3 * 4 * Copyright (c) 2007, NLnet Labs. All rights reserved. 5 * 6 * This software is open source. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * Redistributions of source code must retain the above copyright notice, 13 * this list of conditions and the following disclaimer. 14 * 15 * Redistributions in binary form must reproduce the above copyright notice, 16 * this list of conditions and the following disclaimer in the documentation 17 * and/or other materials provided with the distribution. 18 * 19 * Neither the name of the NLNET LABS nor the names of its contributors may 20 * be used to endorse or promote products derived from this software without 21 * specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 27 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 29 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 30 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 */ 35 36 /** 37 * \file 38 * 39 * This file has functions to send queries to authoritative servers, 40 * and wait for the pending answer, with timeouts. 41 */ 42 43 #ifndef OUTSIDE_NETWORK_H 44 #define OUTSIDE_NETWORK_H 45 46 #include "util/rbtree.h" 47 #include "util/netevent.h" 48 #include "dnstap/dnstap_config.h" 49 struct pending; 50 struct pending_timeout; 51 struct ub_randstate; 52 struct pending_tcp; 53 struct waiting_tcp; 54 struct waiting_udp; 55 struct infra_cache; 56 struct port_comm; 57 struct port_if; 58 struct sldns_buffer; 59 struct serviced_query; 60 struct dt_env; 61 struct edns_option; 62 struct module_env; 63 struct module_qstate; 64 struct query_info; 65 66 /** 67 * Send queries to outside servers and wait for answers from servers. 68 * Contains answer-listen sockets. 69 */ 70 struct outside_network { 71 /** Base for select calls */ 72 struct comm_base* base; 73 /** pointer to time in seconds */ 74 time_t* now_secs; 75 /** pointer to time in microseconds */ 76 struct timeval* now_tv; 77 78 /** buffer shared by UDP connections, since there is only one 79 datagram at any time. */ 80 struct sldns_buffer* udp_buff; 81 /** serviced_callbacks malloc overhead when processing multiple 82 * identical serviced queries to the same server. */ 83 size_t svcd_overhead; 84 /** use x20 bits to encode additional ID random bits */ 85 int use_caps_for_id; 86 /** outside network wants to quit. Stop queued msgs from sent. */ 87 int want_to_quit; 88 89 /** number of unwanted replies received (for statistics) */ 90 size_t unwanted_replies; 91 /** cumulative total of unwanted replies (for defense) */ 92 size_t unwanted_total; 93 /** threshold when to take defensive action. If 0 then never. */ 94 size_t unwanted_threshold; 95 /** what action to take, called when defensive action is needed */ 96 void (*unwanted_action)(void*); 97 /** user param for action */ 98 void* unwanted_param; 99 100 /** linked list of available commpoints, unused file descriptors, 101 * for use as outgoing UDP ports. cp.fd=-1 in them. */ 102 struct port_comm* unused_fds; 103 /** if udp is done */ 104 int do_udp; 105 /** if udp is delay-closed (delayed answers do not meet closed port)*/ 106 int delayclose; 107 /** timeout for delayclose */ 108 struct timeval delay_tv; 109 110 /** array of outgoing IP4 interfaces */ 111 struct port_if* ip4_ifs; 112 /** number of outgoing IP4 interfaces */ 113 int num_ip4; 114 115 /** array of outgoing IP6 interfaces */ 116 struct port_if* ip6_ifs; 117 /** number of outgoing IP6 interfaces */ 118 int num_ip6; 119 120 /** pending udp queries waiting to be sent out, waiting for fd */ 121 struct pending* udp_wait_first; 122 /** last pending udp query in list */ 123 struct pending* udp_wait_last; 124 125 /** pending udp answers. sorted by id, addr */ 126 rbtree_type* pending; 127 /** serviced queries, sorted by qbuf, addr, dnssec */ 128 rbtree_type* serviced; 129 /** host cache, pointer but not owned by outnet. */ 130 struct infra_cache* infra; 131 /** where to get random numbers */ 132 struct ub_randstate* rnd; 133 /** ssl context to create ssl wrapped TCP with DNS connections */ 134 void* sslctx; 135 /** if SNI will be used for TLS connections */ 136 int tls_use_sni; 137 #ifdef USE_DNSTAP 138 /** dnstap environment */ 139 struct dt_env* dtenv; 140 #endif 141 /** maximum segment size of tcp socket */ 142 int tcp_mss; 143 /** IP_TOS socket option requested on the sockets */ 144 int ip_dscp; 145 146 /** 147 * Array of tcp pending used for outgoing TCP connections. 148 * Each can be used to establish a TCP connection with a server. 149 * The file descriptors are -1 if they are free, and need to be 150 * opened for the tcp connection. Can be used for ip4 and ip6. 151 */ 152 struct pending_tcp **tcp_conns; 153 /** number of tcp communication points. */ 154 size_t num_tcp; 155 /** number of tcp communication points in use. */ 156 size_t num_tcp_outgoing; 157 /** list of tcp comm points that are free for use */ 158 struct pending_tcp* tcp_free; 159 /** list of tcp queries waiting for a buffer */ 160 struct waiting_tcp* tcp_wait_first; 161 /** last of waiting query list */ 162 struct waiting_tcp* tcp_wait_last; 163 }; 164 165 /** 166 * Outgoing interface. Ports available and currently used are tracked 167 * per interface 168 */ 169 struct port_if { 170 /** address ready to allocate new socket (except port no). */ 171 struct sockaddr_storage addr; 172 /** length of addr field */ 173 socklen_t addrlen; 174 175 /** prefix length of network address (in bits), for randomisation. 176 * if 0, no randomisation. */ 177 int pfxlen; 178 179 #ifndef DISABLE_EXPLICIT_PORT_RANDOMISATION 180 /** the available ports array. These are unused. 181 * Only the first total-inuse part is filled. */ 182 int* avail_ports; 183 /** the total number of available ports (size of the array) */ 184 int avail_total; 185 #endif 186 187 /** array of the commpoints currently in use. 188 * allocated for max number of fds, first part in use. */ 189 struct port_comm** out; 190 /** max number of fds, size of out array */ 191 int maxout; 192 /** number of commpoints (and thus also ports) in use */ 193 int inuse; 194 }; 195 196 /** 197 * Outgoing commpoint for UDP port. 198 */ 199 struct port_comm { 200 /** next in free list */ 201 struct port_comm* next; 202 /** which port number (when in use) */ 203 int number; 204 /** interface it is used in */ 205 struct port_if* pif; 206 /** index in the out array of the interface */ 207 int index; 208 /** number of outstanding queries on this port */ 209 int num_outstanding; 210 /** UDP commpoint, fd=-1 if not in use */ 211 struct comm_point* cp; 212 }; 213 214 /** 215 * A query that has an answer pending for it. 216 */ 217 struct pending { 218 /** redblacktree entry, key is the pending struct(id, addr). */ 219 rbnode_type node; 220 /** the ID for the query. int so that a value out of range can 221 * be used to signify a pending that is for certain not present in 222 * the rbtree. (and for which deletion is safe). */ 223 unsigned int id; 224 /** remote address. */ 225 struct sockaddr_storage addr; 226 /** length of addr field in use. */ 227 socklen_t addrlen; 228 /** comm point it was sent on (and reply must come back on). */ 229 struct port_comm* pc; 230 /** timeout event */ 231 struct comm_timer* timer; 232 /** callback for the timeout, error or reply to the message */ 233 comm_point_callback_type* cb; 234 /** callback user argument */ 235 void* cb_arg; 236 /** the outside network it is part of */ 237 struct outside_network* outnet; 238 /** the corresponding serviced_query */ 239 struct serviced_query* sq; 240 241 /*---- filled if udp pending is waiting -----*/ 242 /** next in waiting list. */ 243 struct pending* next_waiting; 244 /** timeout in msec */ 245 int timeout; 246 /** The query itself, the query packet to send. */ 247 uint8_t* pkt; 248 /** length of query packet. */ 249 size_t pkt_len; 250 }; 251 252 /** 253 * Pending TCP query to server. 254 */ 255 struct pending_tcp { 256 /** next in list of free tcp comm points, or NULL. */ 257 struct pending_tcp* next_free; 258 /** the ID for the query; checked in reply */ 259 uint16_t id; 260 /** tcp comm point it was sent on (and reply must come back on). */ 261 struct comm_point* c; 262 /** the query being serviced, NULL if the pending_tcp is unused. */ 263 struct waiting_tcp* query; 264 }; 265 266 /** 267 * Query waiting for TCP buffer. 268 */ 269 struct waiting_tcp { 270 /** 271 * next in waiting list. 272 * if pkt==0, this points to the pending_tcp structure. 273 */ 274 struct waiting_tcp* next_waiting; 275 /** timeout event; timer keeps running whether the query is 276 * waiting for a buffer or the tcp reply is pending */ 277 struct comm_timer* timer; 278 /** the outside network it is part of */ 279 struct outside_network* outnet; 280 /** remote address. */ 281 struct sockaddr_storage addr; 282 /** length of addr field in use. */ 283 socklen_t addrlen; 284 /** 285 * The query itself, the query packet to send. 286 * allocated after the waiting_tcp structure. 287 * set to NULL when the query is serviced and it part of pending_tcp. 288 * if this is NULL, the next_waiting points to the pending_tcp. 289 */ 290 uint8_t* pkt; 291 /** length of query packet. */ 292 size_t pkt_len; 293 /** callback for the timeout, error or reply to the message */ 294 comm_point_callback_type* cb; 295 /** callback user argument */ 296 void* cb_arg; 297 /** if it uses ssl upstream */ 298 int ssl_upstream; 299 /** ref to the tls_auth_name from the serviced_query */ 300 char* tls_auth_name; 301 }; 302 303 /** 304 * Callback to party interested in serviced query results. 305 */ 306 struct service_callback { 307 /** next in callback list */ 308 struct service_callback* next; 309 /** callback function */ 310 comm_point_callback_type* cb; 311 /** user argument for callback function */ 312 void* cb_arg; 313 }; 314 315 /** fallback size for fragmentation for EDNS in IPv4 */ 316 #define EDNS_FRAG_SIZE_IP4 1472 317 /** fallback size for EDNS in IPv6, fits one fragment with ip6-tunnel-ids */ 318 #define EDNS_FRAG_SIZE_IP6 1232 319 320 /** 321 * Query service record. 322 * Contains query and destination. UDP, TCP, EDNS are all tried. 323 * complete with retries and timeouts. A number of interested parties can 324 * receive a callback. 325 */ 326 struct serviced_query { 327 /** The rbtree node, key is this record */ 328 rbnode_type node; 329 /** The query that needs to be answered. Starts with flags u16, 330 * then qdcount, ..., including qname, qtype, qclass. Does not include 331 * EDNS record. */ 332 uint8_t* qbuf; 333 /** length of qbuf. */ 334 size_t qbuflen; 335 /** If an EDNS section is included, the DO/CD bit will be turned on. */ 336 int dnssec; 337 /** We want signatures, or else the answer is likely useless */ 338 int want_dnssec; 339 /** ignore capsforid */ 340 int nocaps; 341 /** tcp upstream used, use tcp, or ssl_upstream for SSL */ 342 int tcp_upstream, ssl_upstream; 343 /** the name of the tls authentication name, eg. 'ns.example.com' 344 * or NULL */ 345 char* tls_auth_name; 346 /** where to send it */ 347 struct sockaddr_storage addr; 348 /** length of addr field in use. */ 349 socklen_t addrlen; 350 /** zone name, uncompressed domain name in wireformat */ 351 uint8_t* zone; 352 /** length of zone name */ 353 size_t zonelen; 354 /** qtype */ 355 int qtype; 356 /** current status */ 357 enum serviced_query_status { 358 /** initial status */ 359 serviced_initial, 360 /** UDP with EDNS sent */ 361 serviced_query_UDP_EDNS, 362 /** UDP without EDNS sent */ 363 serviced_query_UDP, 364 /** TCP with EDNS sent */ 365 serviced_query_TCP_EDNS, 366 /** TCP without EDNS sent */ 367 serviced_query_TCP, 368 /** probe to test noEDNS0 (EDNS gives FORMERRorNOTIMP) */ 369 serviced_query_UDP_EDNS_fallback, 370 /** probe to test TCP noEDNS0 (EDNS gives FORMERRorNOTIMP) */ 371 serviced_query_TCP_EDNS_fallback, 372 /** send UDP query with EDNS1480 (or 1280) */ 373 serviced_query_UDP_EDNS_FRAG 374 } 375 /** variable with current status */ 376 status; 377 /** true if serviced_query is scheduled for deletion already */ 378 int to_be_deleted; 379 /** number of UDP retries */ 380 int retry; 381 /** time last UDP was sent */ 382 struct timeval last_sent_time; 383 /** rtt of last message */ 384 int last_rtt; 385 /** do we know edns probe status already, for UDP_EDNS queries */ 386 int edns_lame_known; 387 /** edns options to use for sending upstream packet */ 388 struct edns_option* opt_list; 389 /** outside network this is part of */ 390 struct outside_network* outnet; 391 /** list of interested parties that need callback on results. */ 392 struct service_callback* cblist; 393 /** the UDP or TCP query that is pending, see status which */ 394 void* pending; 395 }; 396 397 /** 398 * Create outside_network structure with N udp ports. 399 * @param base: the communication base to use for event handling. 400 * @param bufsize: size for network buffers. 401 * @param num_ports: number of udp ports to open per interface. 402 * @param ifs: interface names (or NULL for default interface). 403 * These interfaces must be able to access all authoritative servers. 404 * @param num_ifs: number of names in array ifs. 405 * @param do_ip4: service IP4. 406 * @param do_ip6: service IP6. 407 * @param num_tcp: number of outgoing tcp buffers to preallocate. 408 * @param dscp: DSCP to use. 409 * @param infra: pointer to infra cached used for serviced queries. 410 * @param rnd: stored to create random numbers for serviced queries. 411 * @param use_caps_for_id: enable to use 0x20 bits to encode id randomness. 412 * @param availports: array of available ports. 413 * @param numavailports: number of available ports in array. 414 * @param unwanted_threshold: when to take defensive action. 415 * @param unwanted_action: the action to take. 416 * @param unwanted_param: user parameter to action. 417 * @param tcp_mss: maximum segment size of tcp socket. 418 * @param do_udp: if udp is done. 419 * @param sslctx: context to create outgoing connections with (if enabled). 420 * @param delayclose: if not 0, udp sockets are delayed before timeout closure. 421 * msec to wait on timeouted udp sockets. 422 * @param tls_use_sni: if SNI is used for TLS connections. 423 * @param dtenv: environment to send dnstap events with (if enabled). 424 * @return: the new structure (with no pending answers) or NULL on error. 425 */ 426 struct outside_network* outside_network_create(struct comm_base* base, 427 size_t bufsize, size_t num_ports, char** ifs, int num_ifs, 428 int do_ip4, int do_ip6, size_t num_tcp, int dscp, struct infra_cache* infra, 429 struct ub_randstate* rnd, int use_caps_for_id, int* availports, 430 int numavailports, size_t unwanted_threshold, int tcp_mss, 431 void (*unwanted_action)(void*), void* unwanted_param, int do_udp, 432 void* sslctx, int delayclose, int tls_use_sni, struct dt_env *dtenv); 433 434 /** 435 * Delete outside_network structure. 436 * @param outnet: object to delete. 437 */ 438 void outside_network_delete(struct outside_network* outnet); 439 440 /** 441 * Prepare for quit. Sends no more queries, even if queued up. 442 * @param outnet: object to prepare for removal 443 */ 444 void outside_network_quit_prepare(struct outside_network* outnet); 445 446 /** 447 * Send UDP query, create pending answer. 448 * Changes the ID for the query to be random and unique for that destination. 449 * @param sq: serviced query. 450 * @param packet: wireformat query to send to destination. 451 * @param timeout: in milliseconds from now. 452 * @param callback: function to call on error, timeout or reply. 453 * @param callback_arg: user argument for callback function. 454 * @return: NULL on error for malloc or socket. Else the pending query object. 455 */ 456 struct pending* pending_udp_query(struct serviced_query* sq, 457 struct sldns_buffer* packet, int timeout, comm_point_callback_type* callback, 458 void* callback_arg); 459 460 /** 461 * Send TCP query. May wait for TCP buffer. Selects ID to be random, and 462 * checks id. 463 * @param sq: serviced query. 464 * @param packet: wireformat query to send to destination. copied from. 465 * @param timeout: in milliseconds from now. 466 * Timer starts running now. Timer may expire if all buffers are used, 467 * without any query been sent to the server yet. 468 * @param callback: function to call on error, timeout or reply. 469 * @param callback_arg: user argument for callback function. 470 * @return: false on error for malloc or socket. Else the pending TCP object. 471 */ 472 struct waiting_tcp* pending_tcp_query(struct serviced_query* sq, 473 struct sldns_buffer* packet, int timeout, comm_point_callback_type* callback, 474 void* callback_arg); 475 476 /** 477 * Delete pending answer. 478 * @param outnet: outside network the pending query is part of. 479 * Internal feature: if outnet is NULL, p is not unlinked from rbtree. 480 * @param p: deleted 481 */ 482 void pending_delete(struct outside_network* outnet, struct pending* p); 483 484 /** 485 * Perform a serviced query to the authoritative servers. 486 * Duplicate efforts are detected, and EDNS, TCP and UDP retry is performed. 487 * @param outnet: outside network, with rbtree of serviced queries. 488 * @param qinfo: query info. 489 * @param flags: flags u16 (host format), includes opcode, CD bit. 490 * @param dnssec: if set, DO bit is set in EDNS queries. 491 * If the value includes BIT_CD, CD bit is set when in EDNS queries. 492 * If the value includes BIT_DO, DO bit is set when in EDNS queries. 493 * @param want_dnssec: signatures are needed, without EDNS the answer is 494 * likely to be useless. 495 * @param nocaps: ignore use_caps_for_id and use unperturbed qname. 496 * @param tcp_upstream: use TCP for upstream queries. 497 * @param ssl_upstream: use SSL for upstream queries. 498 * @param tls_auth_name: when ssl_upstream is true, use this name to check 499 * the server's peer certificate. 500 * @param addr: to which server to send the query. 501 * @param addrlen: length of addr. 502 * @param zone: name of the zone of the delegation point. wireformat dname. 503 This is the delegation point name for which the server is deemed 504 authoritative. 505 * @param zonelen: length of zone. 506 * @param qstate: module qstate. Mainly for inspecting the available 507 * edns_opts_lists. 508 * @param callback: callback function. 509 * @param callback_arg: user argument to callback function. 510 * @param buff: scratch buffer to create query contents in. Empty on exit. 511 * @param env: the module environment. 512 * @return 0 on error, or pointer to serviced query that is used to answer 513 * this serviced query may be shared with other callbacks as well. 514 */ 515 struct serviced_query* outnet_serviced_query(struct outside_network* outnet, 516 struct query_info* qinfo, uint16_t flags, int dnssec, int want_dnssec, 517 int nocaps, int tcp_upstream, int ssl_upstream, char* tls_auth_name, 518 struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone, 519 size_t zonelen, struct module_qstate* qstate, 520 comm_point_callback_type* callback, void* callback_arg, 521 struct sldns_buffer* buff, struct module_env* env); 522 523 /** 524 * Remove service query callback. 525 * If that leads to zero callbacks, the query is completely cancelled. 526 * @param sq: serviced query to adjust. 527 * @param cb_arg: callback argument of callback that needs removal. 528 * same as the callback_arg to outnet_serviced_query(). 529 */ 530 void outnet_serviced_query_stop(struct serviced_query* sq, void* cb_arg); 531 532 /** 533 * Get memory size in use by outside network. 534 * Counts buffers and outstanding query (serviced queries) malloced data. 535 * @param outnet: outside network structure. 536 * @return size in bytes. 537 */ 538 size_t outnet_get_mem(struct outside_network* outnet); 539 540 /** 541 * Get memory size in use by serviced query while it is servicing callbacks. 542 * This takes into account the pre-deleted status of it; it will be deleted 543 * when the callbacks are done. 544 * @param sq: serviced query. 545 * @return size in bytes. 546 */ 547 size_t serviced_get_mem(struct serviced_query* sq); 548 549 /** get TCP file descriptor for address, returns -1 on failure, 550 * tcp_mss is 0 or maxseg size to set for TCP packets. */ 551 int outnet_get_tcp_fd(struct sockaddr_storage* addr, socklen_t addrlen, int tcp_mss, int dscp); 552 553 /** 554 * Create udp commpoint suitable for sending packets to the destination. 555 * @param outnet: outside_network with the comm_base it is attached to, 556 * with the outgoing interfaces chosen from, and rnd gen for random. 557 * @param cb: callback function for the commpoint. 558 * @param cb_arg: callback argument for cb. 559 * @param to_addr: intended destination. 560 * @param to_addrlen: length of to_addr. 561 * @return commpoint that you can comm_point_send_udp_msg with, or NULL. 562 */ 563 struct comm_point* outnet_comm_point_for_udp(struct outside_network* outnet, 564 comm_point_callback_type* cb, void* cb_arg, 565 struct sockaddr_storage* to_addr, socklen_t to_addrlen); 566 567 /** 568 * Create tcp commpoint suitable for communication to the destination. 569 * It also performs connect() to the to_addr. 570 * @param outnet: outside_network with the comm_base it is attached to, 571 * and the tcp_mss. 572 * @param cb: callback function for the commpoint. 573 * @param cb_arg: callback argument for cb. 574 * @param to_addr: intended destination. 575 * @param to_addrlen: length of to_addr. 576 * @param query: initial packet to send writing, in buffer. It is copied 577 * to the commpoint buffer that is created. 578 * @param timeout: timeout for the TCP connection. 579 * timeout in milliseconds, or -1 for no (change to the) timeout. 580 * So seconds*1000. 581 * @param ssl: set to true for TLS. 582 * @param host: hostname for host name verification of TLS (or NULL if no TLS). 583 * @return tcp_out commpoint, or NULL. 584 */ 585 struct comm_point* outnet_comm_point_for_tcp(struct outside_network* outnet, 586 comm_point_callback_type* cb, void* cb_arg, 587 struct sockaddr_storage* to_addr, socklen_t to_addrlen, 588 struct sldns_buffer* query, int timeout, int ssl, char* host); 589 590 /** 591 * Create http commpoint suitable for communication to the destination. 592 * Creates the http request buffer. It also performs connect() to the to_addr. 593 * @param outnet: outside_network with the comm_base it is attached to, 594 * and the tcp_mss. 595 * @param cb: callback function for the commpoint. 596 * @param cb_arg: callback argument for cb. 597 * @param to_addr: intended destination. 598 * @param to_addrlen: length of to_addr. 599 * @param timeout: timeout for the TCP connection. 600 * timeout in milliseconds, or -1 for no (change to the) timeout. 601 * So seconds*1000. 602 * @param ssl: set to true for https. 603 * @param host: hostname to use for the destination. part of http request. 604 * @param path: pathname to lookup, eg. name of the file on the destination. 605 * @return http_out commpoint, or NULL. 606 */ 607 struct comm_point* outnet_comm_point_for_http(struct outside_network* outnet, 608 comm_point_callback_type* cb, void* cb_arg, 609 struct sockaddr_storage* to_addr, socklen_t to_addrlen, int timeout, 610 int ssl, char* host, char* path); 611 612 /** connect tcp connection to addr, 0 on failure */ 613 int outnet_tcp_connect(int s, struct sockaddr_storage* addr, socklen_t addrlen); 614 615 /** callback for incoming udp answers from the network */ 616 int outnet_udp_cb(struct comm_point* c, void* arg, int error, 617 struct comm_reply *reply_info); 618 619 /** callback for pending tcp connections */ 620 int outnet_tcp_cb(struct comm_point* c, void* arg, int error, 621 struct comm_reply *reply_info); 622 623 /** callback for udp timeout */ 624 void pending_udp_timer_cb(void *arg); 625 626 /** callback for udp delay for timeout */ 627 void pending_udp_timer_delay_cb(void *arg); 628 629 /** callback for outgoing TCP timer event */ 630 void outnet_tcptimer(void* arg); 631 632 /** callback for serviced query UDP answers */ 633 int serviced_udp_callback(struct comm_point* c, void* arg, int error, 634 struct comm_reply* rep); 635 636 /** TCP reply or error callback for serviced queries */ 637 int serviced_tcp_callback(struct comm_point* c, void* arg, int error, 638 struct comm_reply* rep); 639 640 /** compare function of pending rbtree */ 641 int pending_cmp(const void* key1, const void* key2); 642 643 /** compare function of serviced query rbtree */ 644 int serviced_cmp(const void* key1, const void* key2); 645 646 #endif /* OUTSIDE_NETWORK_H */ 647