ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid-7.2/src/irc_res.c
(Generate patch)

Comparing ircd-hybrid-7.2/src/irc_res.c (file contents):
Revision 986 by michael, Sat Aug 15 21:12:34 2009 UTC vs.
Revision 992 by michael, Mon Aug 17 19:19:16 2009 UTC

# Line 88 | Line 88 | struct reslist
88    time_t timeout;
89    struct irc_ssaddr addr;
90    char *name;
91 <  struct DNSQuery *query;  /* query callback for this request */
91 >  dns_callback_fnc callback;
92 >  void *callback_ctx;
93   };
94  
95   static fde_t ResolverFileDescriptor;
96   static dlink_list request_list = { NULL, NULL, 0 };
97  
98   static void rem_request(struct reslist *request);
99 < static struct reslist *make_request(struct DNSQuery *query);
100 < static void do_query_name(struct DNSQuery *query,
101 <                          const char* name, struct reslist *request, int);
102 < static void do_query_number(struct DNSQuery *query,
99 > static struct reslist *make_request(dns_callback_fnc callback, void *);
100 > static void do_query_name(dns_callback_fnc callback, void *,
101 >                          const char *, struct reslist *, int);
102 > static void do_query_number(dns_callback_fnc callback, void *ctx,
103                              const struct irc_ssaddr *,
104                              struct reslist *request);
105   static void query_name(const char *name, int query_class, int query_type,
# Line 129 | Line 130 | static int
130   res_ourserver(const struct irc_ssaddr *inp)
131   {
132   #ifdef IPV6
133 <  struct sockaddr_in6 *v6;
134 <  struct sockaddr_in6 *v6in = (struct sockaddr_in6 *)inp;
133 >  const struct sockaddr_in6 *v6;
134 >  const struct sockaddr_in6 *v6in = (const struct sockaddr_in6 *)inp;
135   #endif
136 <  struct sockaddr_in *v4;
137 <  struct sockaddr_in *v4in = (struct sockaddr_in *)inp;
136 >  const struct sockaddr_in *v4;
137 >  const struct sockaddr_in *v4in = (const struct sockaddr_in *)inp;
138    int ns;
139  
140    for (ns = 0; ns < irc_nscount; ns++)
141    {
142      const struct irc_ssaddr *srv = &irc_nsaddr_list[ns];
143   #ifdef IPV6
144 <    v6 = (struct sockaddr_in6 *)srv;
144 >    v6 = (const struct sockaddr_in6 *)srv;
145   #endif
146 <    v4 = (struct sockaddr_in *)srv;
146 >    v4 = (const struct sockaddr_in *)srv;
147  
148      /* could probably just memcmp(srv, inp, srv.ss_len) here
149       * but we'll air on the side of caution - stu
# Line 198 | Line 199 | timeout_query_list(time_t now)
199      {
200        if (--request->retries <= 0)
201        {
202 <        (*request->query->callback)(request->query->ptr, NULL);
202 >        (*request->callback)(request->callback_ctx, NULL, NULL);
203          rem_request(request);
204          continue;
205        }
# Line 312 | Line 313 | rem_request(struct reslist *request)
313   * make_request - Create a DNS request record for the server.
314   */
315   static struct reslist *
316 < make_request(struct DNSQuery* query)
316 > make_request(dns_callback_fnc callback, void *ctx)
317   {
318    struct reslist *request;
319  
320    request = (struct reslist *)MyMalloc(sizeof(struct reslist));
321  
322 <  request->sentat  = CurrentTime;
323 <  request->retries = 3;
324 <  request->resend  = 1;
325 <  request->timeout = 4;    /* start at 4 and exponential inc. */
326 <  request->query   = query;
327 <  request->state   = REQ_IDLE;
322 >  request->sentat       = CurrentTime;
323 >  request->retries      = 3;
324 >  request->resend       = 1;
325 >  request->timeout      = 4;    /* start at 4 and exponential inc. */
326 >  request->state        = REQ_IDLE;
327 >  request->callback     = callback;
328 >  request->callback_ctx = ctx;
329  
330    dlinkAdd(request, &request->node, &request_list);
331    return(request);
# Line 334 | Line 336 | make_request(struct DNSQuery* query)
336   * for which there no longer exist clients or conf lines.
337   */
338   void
339 < delete_resolver_queries(const struct DNSQuery *query)
339 > delete_resolver_queries(const void *vptr)
340   {
341    dlink_node *ptr;
342    dlink_node *next_ptr;
# Line 344 | Line 346 | delete_resolver_queries(const struct DNS
346    {
347      if ((request = ptr->data) != NULL)
348      {
349 <      if (query == request->query)
349 >      if (request->callback_ctx == vptr)
350          rem_request(request);
351      }
352    }
# Line 406 | Line 408 | find_id(int id)
408   *
409   */
410   void
411 < gethost_byname_type(const char *name, struct DNSQuery *query, int type)
411 > gethost_byname_type(dns_callback_fnc callback, void *ctx, const char *name, int type)
412   {
413    assert(name != 0);
414 <  do_query_name(query, name, NULL, type);
414 >  do_query_name(callback, ctx, name, NULL, type);
415   }
416  
417   /*
418   * gethost_byname - wrapper for _type - send T_AAAA first if IPV6 supported
419   */
420   void
421 < gethost_byname(const char *name, struct DNSQuery *query)
421 > gethost_byname(dns_callback_fnc callback, void *ctx, const char *name)
422   {
423   #ifdef IPV6
424 <  gethost_byname_type(name, query, T_AAAA);
424 >  gethost_byname_type(callback, ctx, name, T_AAAA);
425   #else
426 <  gethost_byname_type(name, query, T_A);
426 >  gethost_byname_type(callback, ctx, name, T_A);
427   #endif
428   }
429  
# Line 429 | Line 431 | gethost_byname(const char *name, struct
431   * gethost_byaddr - get host name from address
432   */
433   void
434 < gethost_byaddr(const struct irc_ssaddr *addr, struct DNSQuery *query)
434 > gethost_byaddr(dns_callback_fnc callback, void *ctx, const struct irc_ssaddr *addr)
435   {
436 <  do_query_number(query, addr, NULL);
436 >  do_query_number(callback, ctx, addr, NULL);
437   }
438  
439   /*
440   * do_query_name - nameserver lookup name
441   */
442   static void
443 < do_query_name(struct DNSQuery *query, const char *name,
443 > do_query_name(dns_callback_fnc callback, void *ctx, const char *name,
444                struct reslist *request, int type)
445   {
446    char host_name[HOSTLEN + 1];
# Line 448 | Line 450 | do_query_name(struct DNSQuery *query, co
450  
451    if (request == NULL)
452    {
453 <    request       = make_request(query);
453 >    request       = make_request(callback, ctx);
454      request->name = MyMalloc(strlen(host_name) + 1);
455      request->type = type;
456      strcpy(request->name, host_name);
# Line 468 | Line 470 | do_query_name(struct DNSQuery *query, co
470   * do_query_number - Use this to do reverse IP# lookups.
471   */
472   static void
473 < do_query_number(struct DNSQuery *query, const struct irc_ssaddr *addr,
473 > do_query_number(dns_callback_fnc callback, void *ctx,
474 >                const struct irc_ssaddr *addr,
475                  struct reslist *request)
476   {
477    char ipbuf[128];
# Line 476 | Line 479 | do_query_number(struct DNSQuery *query,
479  
480    if (addr->ss.ss_family == AF_INET)
481    {
482 <    struct sockaddr_in *v4 = (struct sockaddr_in *)addr;
482 >    const struct sockaddr_in *v4 = (const struct sockaddr_in *)addr;
483      cp = (const unsigned char*)&v4->sin_addr.s_addr;
484  
485      ircsprintf(ipbuf, "%u.%u.%u.%u.in-addr.arpa.",
# Line 486 | Line 489 | do_query_number(struct DNSQuery *query,
489   #ifdef IPV6
490    else if (addr->ss.ss_family == AF_INET6)
491    {
492 <    struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)addr;
492 >    const struct sockaddr_in6 *v6 = (const struct sockaddr_in6 *)addr;
493      cp = (const unsigned char *)&v6->sin6_addr.s6_addr;
494  
495      sprintf(ipbuf, "%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x."
# Line 511 | Line 514 | do_query_number(struct DNSQuery *query,
514   #endif
515    if (request == NULL)
516    {
517 <    request       = make_request(query);
517 >    request       = make_request(callback, ctx);
518      request->type = T_PTR;
519      memcpy(&request->addr, addr, sizeof(struct irc_ssaddr));
520      request->name = MyMalloc(HOSTLEN + 1);
# Line 563 | Line 566 | resend_query(struct reslist *request)
566    switch (request->type)
567    {
568      case T_PTR:
569 <      do_query_number(NULL, &request->addr, request);
569 >      do_query_number(NULL, NULL, &request->addr, request);
570        break;
571      case T_A:
572 <      do_query_name(NULL, request->name, request, request->type);
572 >      do_query_name(NULL, NULL, request->name, request, request->type);
573        break;
574   #ifdef IPV6
575      case T_AAAA:
576        /* didnt work, try A */
577        if (request->state == REQ_AAAA)
578 <        do_query_name(NULL, request->name, request, T_A);
578 >        do_query_name(NULL, NULL, request->name, request, T_A);
579   #endif
580      default:
581        break;
# Line 749 | Line 752 | res_readreply(fde_t *fd, void *data)
752            ;
753    HEADER *header;
754    struct reslist *request = NULL;
752  struct DNSReply *reply  = NULL;
755    int rc;
756    int answer_count;
757    socklen_t len = sizeof(struct irc_ssaddr);
# Line 796 | Line 798 | res_readreply(fde_t *fd, void *data)
798         * If a bad error was returned, stop here and don't
799         * send any more (no retries granted).
800         */
801 <      (*request->query->callback)(request->query->ptr, NULL);
801 >      (*request->callback)(request->callback_ctx, NULL, NULL);
802        rem_request(request);
803      }
804   #ifdef IPV6
# Line 833 | Line 835 | res_readreply(fde_t *fd, void *data)
835           * got a PTR response with no name, something bogus is happening
836           * don't bother trying again, the client address doesn't resolve
837           */
838 <        (*request->query->callback)(request->query->ptr, reply);
838 >        (*request->callback)(request->callback_ctx, NULL, NULL);
839          rem_request(request);
840          return;
841        }
# Line 845 | Line 847 | res_readreply(fde_t *fd, void *data)
847         */
848   #ifdef IPV6
849        if (request->addr.ss.ss_family == AF_INET6)
850 <        gethost_byname_type(request->name, request->query, T_AAAA);
850 >        gethost_byname_type(request->callback, request->callback_ctx, request->name, T_AAAA);
851        else
852   #endif
853 <      gethost_byname_type(request->name, request->query, T_A);
853 >      gethost_byname_type(request->callback, request->callback_ctx, request->name, T_A);
854        rem_request(request);
855      }
856      else
# Line 856 | Line 858 | res_readreply(fde_t *fd, void *data)
858        /*
859         * got a name and address response, client resolved
860         */
861 <      reply = make_dnsreply(request);
860 <      (*request->query->callback)(request->query->ptr, reply);
861 <      MyFree(reply);
861 >      (*request->callback)(request->callback_ctx, &request->addr, request->name);
862        rem_request(request);
863      }
864    }
# Line 874 | Line 874 | res_readreply(fde_t *fd, void *data)
874    }
875   }
876  
877 static struct DNSReply *
878 make_dnsreply(struct reslist *request)
879 {
880  struct DNSReply *cp;
881  assert(request != 0);
882
883  cp = (struct DNSReply *)MyMalloc(sizeof(struct DNSReply));
884
885  cp->h_name = request->name;
886  memcpy(&cp->addr, &request->addr, sizeof(cp->addr));
887  return(cp);
888 }
889
877   void
878   report_dns_servers(struct Client *source_p)
879   {
880    int i;
881 <  char ipaddr[HOSTIPLEN];
881 >  char ipaddr[HOSTIPLEN + 1];
882  
883    for (i = 0; i < irc_nscount; i++)
884    {
885      irc_getnameinfo((struct sockaddr *)&(irc_nsaddr_list[i]),
886 <                    irc_nsaddr_list[i].ss_len, ipaddr, HOSTIPLEN, NULL, 0,
887 <                    NI_NUMERICHOST);
886 >                    irc_nsaddr_list[i].ss_len, ipaddr,
887 >                    sizeof(ipaddr), NULL, 0, NI_NUMERICHOST);
888      sendto_one(source_p, form_str(RPL_STATSALINE),
889                 me.name, source_p->name, ipaddr);
890    }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines