ares_data.c

   1
   2 /* Copyright (C) 2009-2010 by Daniel Stenberg
   3  *
   4  * Permission to use, copy, modify, and distribute this
   5  * software and its documentation for any purpose and without
   6  * fee is hereby granted, provided that the above copyright
   7  * notice appear in all copies and that both that copyright
   8  * notice and this permission notice appear in supporting
   9  * documentation, and that the name of M.I.T. not be used in
  10  * advertising or publicity pertaining to distribution of the
  11  * software without specific, written prior permission.
  12  * M.I.T. makes no representations about the suitability of
  13  * this software for any purpose.  It is provided "as is"
  14  * without express or implied warranty.
  15  */
  16
  17
  18 #include "ares_setup.h"
  19
  20 #include <stddef.h>
  21
  22 #include "ares.h"
  23 #include "ares_data.h"
  24 #include "ares_private.h"
  25
  26
  27 /*
  28 ** ares_free_data() - c-ares external API function.
  29 **
  30 ** This function must be used by the application to free data memory that
  31 ** has been internally allocated by some c-ares function and for which a
  32 ** pointer has already been returned to the calling application. The list
  33 ** of c-ares functions returning pointers that must be free'ed using this
  34 ** function is:
  35 **
  36 **   ares_get_servers()
  37 **   ares_parse_srv_reply()
  38 **   ares_parse_txt_reply()
  39 */
  40
  41 void ares_free_data(void *dataptr)
  42 {
  43   struct ares_data *ptr;
  44
  45   if (!dataptr)
  46     return;
  47
  48 #ifdef __INTEL_COMPILER
  49 #  pragma warning(push)
  50 #  pragma warning(disable:1684)
  51    /* 1684: conversion from pointer to same-sized integral type */
  52 #endif
  53
  54   ptr = (void *)((char *)dataptr - offsetof(struct ares_data, data));
  55
  56 #ifdef __INTEL_COMPILER
  57 #  pragma warning(pop)
  58 #endif
  59
  60   if (ptr->mark != ARES_DATATYPE_MARK)
  61     return;
  62
  63   switch (ptr->type)
  64     {
  65       case ARES_DATATYPE_SRV_REPLY:
  66
  67         if (ptr->data.srv_reply.next)
  68           ares_free_data(ptr->data.srv_reply.next);
  69         if (ptr->data.srv_reply.host)
  70           free(ptr->data.srv_reply.host);
  71         break;
  72
  73       case ARES_DATATYPE_TXT_REPLY:
  74
  75         if (ptr->data.txt_reply.next)
  76           ares_free_data(ptr->data.txt_reply.next);
  77         if (ptr->data.txt_reply.txt)
  78           free(ptr->data.txt_reply.txt);
  79         break;
  80
  81       case ARES_DATATYPE_ADDR_NODE:
  82
  83         if (ptr->data.addr_node.next)
  84           ares_free_data(ptr->data.addr_node.next);
  85         break;
  86
  87       default:
  88         return;
  89     }
  90
  91   free(ptr);
  92 }
  93
  94
  95 /*
  96 ** ares_malloc_data() - c-ares internal helper function.
  97 **
  98 ** This function allocates memory for a c-ares private ares_data struct
  99 ** for the specified ares_datatype, initializes c-ares private fields
 100 ** and zero initializes those which later might be used from the public
 101 ** API. It returns an interior pointer which can be passed by c-ares
 102 ** functions to the calling application, and that must be free'ed using
 103 ** c-ares external API function ares_free_data().
 104 */
 105
 106 void *ares_malloc_data(ares_datatype type)
 107 {
 108   struct ares_data *ptr;
 109
 110   ptr = malloc(sizeof(struct ares_data));
 111   if (!ptr)
 112     return NULL;
 113
 114   switch (type)
 115     {
 116       case ARES_DATATYPE_SRV_REPLY:
 117         ptr->data.srv_reply.next = NULL;
 118         ptr->data.srv_reply.host = NULL;
 119         ptr->data.srv_reply.priority = 0;
 120         ptr->data.srv_reply.weight = 0;
 121         ptr->data.srv_reply.port = 0;
 122         break;
 123
 124       case ARES_DATATYPE_TXT_REPLY:
 125         ptr->data.txt_reply.next = NULL;
 126         ptr->data.txt_reply.txt = NULL;
 127         ptr->data.txt_reply.length  = 0;
 128         break;
 129
 130       case ARES_DATATYPE_ADDR_NODE:
 131         ptr->data.addr_node.next = NULL;
 132         ptr->data.addr_node.family = 0;
 133         memset(&ptr->data.addr_node.addrV6, 0,
 134           sizeof(ptr->data.addr_node.addrV6));
 135
 136       default:
 137         free(ptr);
 138         return NULL;
 139     }
 140
 141   ptr->mark = ARES_DATATYPE_MARK;
 142   ptr->type = type;
 143
 144   return &ptr->data;
 145 }
 146
 147
 148 /*
 149 ** ares_get_datatype() - c-ares internal helper function.
 150 **
 151 ** This function returns the ares_datatype of the data stored in a
 152 ** private ares_data struct when given the public API pointer.
 153 */
 154
 155 ares_datatype ares_get_datatype(void * dataptr)
 156 {
 157   struct ares_data *ptr;
 158
 159 #ifdef __INTEL_COMPILER
 160 #  pragma warning(push)
 161 #  pragma warning(disable:1684)
 162    /* 1684: conversion from pointer to same-sized integral type */
 163 #endif
 164
 165   ptr = (void *)((char *)dataptr - offsetof(struct ares_data, data));
 166
 167 #ifdef __INTEL_COMPILER
 168 #  pragma warning(pop)
 169 #endif
 170
 171   if (ptr->mark == ARES_DATATYPE_MARK)
 172     return ptr->type;
 173
 174   return ARES_DATATYPE_UNKNOWN;
 175 }