c-ares / c-ares / #53

Committed 27 Sep 2023 12:43PM UTC coverage: 88.055% (+0.02%) from 88.04%

Build # #53

Build Type

push

travis-ci

Committed by

bradh352

Commit Message

fix #206 by allowing NULL to be passed to socket function callbacks to use defaults

Run Details

21 of 21 new or added lines in 1 file covered. (100.0%)

5057 of 5743 relevant lines covered (88.06%)

11801.46 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.9

/src/lib/ares__htable_asvp.c

/* Copyright (C) 2023 by Brad House
 *
 * Permission to use, copy, modify, and distribute this
 * software and its documentation for any purpose and without
 * fee is hereby granted, provided that the above copyright
 * notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting
 * documentation, and that the name of M.I.T. not be used in
 * advertising or publicity pertaining to distribution of the
 * software without specific, written prior permission.
 * M.I.T. makes no representations about the suitability of
 * this software for any purpose.  It is provided "as is"
 * without express or implied warranty.
 *
 * SPDX-License-Identifier: MIT
 */
#include "ares_setup.h"
#include "ares.h"
#include "ares_private.h"
#include "ares__htable.h"
#include "ares__htable_asvp.h"


struct ares__htable_asvp {
  ares__htable_asvp_val_free_t free_val;
  ares__htable_t              *hash;
};


typedef struct {
  ares_socket_t        key;
  void                *val;
  ares__htable_asvp_t *parent;
} ares__htable_asvp_bucket_t;


void ares__htable_asvp_destroy(ares__htable_asvp_t *htable)
{
  if (htable == NULL)
    return;

  ares__htable_destroy(htable->hash);
  ares_free(htable);
}


static unsigned int hash_func(const void *key, unsigned int seed)
{
  const ares_socket_t *arg = key;
  return ares__htable_hash_FNV1a((const unsigned char *)arg, sizeof(*arg),
                                 seed);
}


static const void *bucket_key(const void *bucket)
{
  const ares__htable_asvp_bucket_t *arg = bucket;
  return &arg->key;
}


static void bucket_free(void *bucket)
{
  ares__htable_asvp_bucket_t *arg = bucket;

  if (arg->parent->free_val)
    arg->parent->free_val(arg->val);

  ares_free(arg);
}


static unsigned int key_eq(const void *key1, const void *key2)
{
  const ares_socket_t *k1 = key1;
  const ares_socket_t *k2 = key2;

  if (*k1 == *k2)
    return 1;

  return 0;
}


ares__htable_asvp_t *ares__htable_asvp_create(
    ares__htable_asvp_val_free_t val_free)
{
  ares__htable_asvp_t *htable = ares_malloc(sizeof(*htable));
  if (htable == NULL)
    goto fail;

  htable->hash = ares__htable_create(hash_func,
                                     bucket_key,
                                     bucket_free,
                                     key_eq);
  if (htable->hash == NULL)
    goto fail;

  htable->free_val = val_free;

  return htable;

fail:
  if (htable) {
    ares__htable_destroy(htable->hash);
    ares_free(htable);
  }
  return NULL;
}


unsigned int ares__htable_asvp_insert(ares__htable_asvp_t *htable,
                                      ares_socket_t key, void *val)
{
  ares__htable_asvp_bucket_t *bucket = NULL;

  if (htable == NULL)
    goto fail;

  bucket = ares_malloc(sizeof(*bucket));
  if (bucket == NULL)
    goto fail;

  bucket->parent = htable;
  bucket->key    = key;
  bucket->val    = val;

  if (!ares__htable_insert(htable->hash, bucket))
    goto fail;

  return 1;

fail:
  if (bucket) {
    ares_free(bucket);
  }
  return 0;
}


unsigned int ares__htable_asvp_get(ares__htable_asvp_t *htable,
                                   ares_socket_t key, void **val)
{
  ares__htable_asvp_bucket_t *bucket = NULL;

  if (val)
    *val = NULL;

  if (htable == NULL)
    return 0;

  bucket = ares__htable_get(htable->hash, &key);
  if (bucket == NULL)
    return 0;

  if (val)
    *val = bucket->val;
  return 1;
}


void *ares__htable_asvp_get_direct(ares__htable_asvp_t *htable,
                                   ares_socket_t key)
{
  void *val = NULL;
  ares__htable_asvp_get(htable, key, &val);
  return val;
}


unsigned int ares__htable_asvp_remove(ares__htable_asvp_t *htable,
                                      ares_socket_t key)
{
  if (htable == NULL)
    return 0;

  return ares__htable_remove(htable->hash, &key);
}


size_t ares__htable_asvp_num_keys(ares__htable_asvp_t *htable)
{
  if (htable == NULL)
    return 0;
  return ares__htable_num_keys(htable->hash);
}

1	/* Copyright (C) 2023 by Brad House
2	*
3	* Permission to use, copy, modify, and distribute this
4	* software and its documentation for any purpose and without
5	* fee is hereby granted, provided that the above copyright
6	* notice appear in all copies and that both that copyright
7	* notice and this permission notice appear in supporting
8	* documentation, and that the name of M.I.T. not be used in
9	* advertising or publicity pertaining to distribution of the
10	* software without specific, written prior permission.
11	* M.I.T. makes no representations about the suitability of
12	* this software for any purpose. It is provided "as is"
13	* without express or implied warranty.
14	*
15	* SPDX-License-Identifier: MIT
16	*/
17	#include "ares_setup.h"
18	#include "ares.h"
19	#include "ares_private.h"
20	#include "ares__htable.h"
21	#include "ares__htable_asvp.h"
22
23
24	struct ares__htable_asvp {
25	ares__htable_asvp_val_free_t free_val;
26	ares__htable_t *hash;
27	};
28
29
30	typedef struct {
31	ares_socket_t key;
32	void *val;
33	ares__htable_asvp_t *parent;
34	} ares__htable_asvp_bucket_t;
35
36
37	void ares__htable_asvp_destroy(ares__htable_asvp_t *htable)	333✔
38	{
39	if (htable == NULL)	333✔
40	return;	35✔
41
42	ares__htable_destroy(htable->hash);	298✔
43	ares_free(htable);	298✔
44	}
45
46
47	static unsigned int hash_func(const void *key, unsigned int seed)	2,697✔
48	{
49	const ares_socket_t *arg = key;	2,697✔
50	return ares__htable_hash_FNV1a((const unsigned char )arg, sizeof(arg),	2,697✔
51	seed);
52	}
53
54
55	static const void bucket_key(const void bucket)	2,538✔
56	{
57	const ares__htable_asvp_bucket_t *arg = bucket;	2,538✔
58	return &arg->key;	2,538✔
59	}
60
61
62	static void bucket_free(void *bucket)	264✔
63	{
64	ares__htable_asvp_bucket_t *arg = bucket;	264✔
65
66	if (arg->parent->free_val)	264✔
67	arg->parent->free_val(arg->val);	×
68
69	ares_free(arg);	264✔
70	}	264✔
71
72
73	static unsigned int key_eq(const void key1, const void key2)	2,262✔
74	{
75	const ares_socket_t *k1 = key1;	2,262✔
76	const ares_socket_t *k2 = key2;	2,262✔
77
78	if (k1 == k2)	2,262✔
79	return 1;	2,262✔
80
81	return 0;	×
82	}
83
84
85	ares__htable_asvp_t *ares__htable_asvp_create(	306✔
86	ares__htable_asvp_val_free_t val_free)
87	{
88	ares__htable_asvp_t htable = ares_malloc(sizeof(htable));	306✔
89	if (htable == NULL)	306✔
90	goto fail;	3✔
91
92	htable->hash = ares__htable_create(hash_func,	303✔
93	bucket_key,
94	bucket_free,
95	key_eq);
96	if (htable->hash == NULL)	303✔
97	goto fail;	4✔
98
99	htable->free_val = val_free;	299✔
100
101	return htable;	299✔
102
103	fail:	7✔
104	if (htable) {	7✔
105	ares__htable_destroy(htable->hash);	4✔
106	ares_free(htable);	4✔
107	}
108	return NULL;	7✔
109	}
110
111
112	unsigned int ares__htable_asvp_insert(ares__htable_asvp_t *htable,	266✔
113	ares_socket_t key, void *val)
114	{
115	ares__htable_asvp_bucket_t *bucket = NULL;	266✔
116
117	if (htable == NULL)	266✔
118	goto fail;	×
119
120	bucket = ares_malloc(sizeof(*bucket));	266✔
121	if (bucket == NULL)	266✔
122	goto fail;	2✔
123
124	bucket->parent = htable;	264✔
125	bucket->key = key;	264✔
126	bucket->val = val;	264✔
127
128	if (!ares__htable_insert(htable->hash, bucket))	264✔
129	goto fail;	×
130
131	return 1;	264✔
132
133	fail:	2✔
134	if (bucket) {	2✔
135	ares_free(bucket);	×
136	}
137	return 0;	2✔
138	}
139
140
141	unsigned int ares__htable_asvp_get(ares__htable_asvp_t *htable,	2,156✔
142	ares_socket_t key, void **val)
143	{
144	ares__htable_asvp_bucket_t *bucket = NULL;	2,156✔
145
146	if (val)	2,156✔
147	*val = NULL;	2,156✔
148
149	if (htable == NULL)	2,156✔
150	return 0;	×
151
152	bucket = ares__htable_get(htable->hash, &key);	2,156✔
153	if (bucket == NULL)	2,156✔
154	return 0;	158✔
155
156	if (val)	1,998✔
157	*val = bucket->val;	1,998✔
158	return 1;	1,998✔
159	}
160
161
162	void ares__htable_asvp_get_direct(ares__htable_asvp_t htable,	2,156✔
163	ares_socket_t key)
164	{
165	void *val = NULL;	2,156✔
166	ares__htable_asvp_get(htable, key, &val);	2,156✔
167	return val;	2,156✔
168	}
169
170
171	unsigned int ares__htable_asvp_remove(ares__htable_asvp_t *htable,	264✔
172	ares_socket_t key)
173	{
174	if (htable == NULL)	264✔
175	return 0;	×
176
177	return ares__htable_remove(htable->hash, &key);	264✔
178	}
179
180
181	size_t ares__htable_asvp_num_keys(ares__htable_asvp_t *htable)	×
182	{
183	if (htable == NULL)	×
184	return 0;	×
185	return ares__htable_num_keys(htable->hash);	×
186	}

c-ares / c-ares / #53

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous