/* * Copyright (c) 2008-2024 OARC, Inc. * Copyright (c) 2007-2008, Internet Systems Consortium, Inc. * Copyright (c) 2003-2007, The Measurement Factory, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * 3. Neither the name of the copyright holder nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include "config.h" #include "edns_cookie_index.h" #include "xmalloc.h" #include "hashtbl.h" #include // edns_cookie int edns_cookie_indexer(const dns_message* m) { if (m->malformed) return -1; return m->edns.option.cookie; } static int next_iter; int edns_cookie_iterator(const char** label) { if (NULL == label) { next_iter = 0; return 2; } if (next_iter > 1) return -1; if (next_iter) *label = "yes"; else *label = "no"; return next_iter++; } // edns_cookie_len static int len_largest = 0; int edns_cookie_len_indexer(const dns_message* m) { if (m->malformed) return -1; size_t len = m->edns.cookie.server_len; if (m->edns.cookie.client) len += 8; if (len > len_largest) len_largest = len; return len; } static int len_next_iter; int edns_cookie_len_iterator(const char** label) { static char label_buf[20]; if (NULL == label) { len_next_iter = 0; return len_largest + 1; } if (len_next_iter > len_largest) return -1; if (len_next_iter == 0) snprintf(label_buf, sizeof(label_buf), "none"); else snprintf(label_buf, sizeof(label_buf), "%d", len_next_iter); *label = label_buf; return len_next_iter++; } void edns_cookie_len_reset() { len_largest = 0; } // cookie hash #define MAX_ARRAY_SZ 65536 typedef struct { char* cookie; int index; } cookieobj; static unsigned int cookie_hashfunc(const void* key) { return hashendian(key, strlen(key), 0); } static int cookie_cmpfunc(const void* a, const void* b) { return strcasecmp(a, b); } // edns_cookie_client static hashtbl* clientHash = NULL; static int client_next_idx = 0; int edns_cookie_client_indexer(const dns_message* m) { cookieobj* obj; if (m->malformed || !m->edns.cookie.client) return -1; char cookie[64]; strtohex(cookie, (char*)m->edns.cookie.client, 8); cookie[16] = 0; if (NULL == clientHash) { clientHash = hash_create(MAX_ARRAY_SZ, cookie_hashfunc, cookie_cmpfunc, 1, afree, afree); if (NULL == clientHash) return -1; } if ((obj = hash_find(cookie, clientHash))) return obj->index; obj = acalloc(1, sizeof(*obj)); if (NULL == obj) return -1; obj->cookie = astrdup(cookie); if (NULL == obj->cookie) { afree(obj); return -1; } obj->index = client_next_idx; if (0 != hash_add(obj->cookie, obj, clientHash)) { afree(obj->cookie); afree(obj); return -1; } client_next_idx++; return obj->index; } int edns_cookie_client_iterator(const char** label) { cookieobj* obj; if (0 == client_next_idx) return -1; if (NULL == label) { /* initialize and tell caller how big the array is */ hash_iter_init(clientHash); return client_next_idx; } if ((obj = hash_iterate(clientHash)) == NULL) return -1; *label = obj->cookie; return obj->index; } void edns_cookie_client_reset() { clientHash = NULL; client_next_idx = 0; } // edns_cookie_server static hashtbl* serverHash = NULL; static int server_next_idx = 0; int edns_cookie_server_indexer(const dns_message* m) { cookieobj* obj; if (m->malformed || !m->edns.cookie.server) return -1; char cookie[128]; strtohex(cookie, (char*)m->edns.cookie.server, m->edns.cookie.server_len); cookie[m->edns.cookie.server_len * 2] = 0; if (NULL == serverHash) { serverHash = hash_create(MAX_ARRAY_SZ, cookie_hashfunc, cookie_cmpfunc, 1, afree, afree); if (NULL == serverHash) return -1; } if ((obj = hash_find(cookie, serverHash))) return obj->index; obj = acalloc(1, sizeof(*obj)); if (NULL == obj) return -1; obj->cookie = astrdup(cookie); if (NULL == obj->cookie) { afree(obj); return -1; } obj->index = server_next_idx; if (0 != hash_add(obj->cookie, obj, serverHash)) { afree(obj->cookie); afree(obj); return -1; } server_next_idx++; return obj->index; } int edns_cookie_server_iterator(const char** label) { cookieobj* obj; if (0 == server_next_idx) return -1; if (NULL == label) { /* initialize and tell caller how big the array is */ hash_iter_init(serverHash); return server_next_idx; } if ((obj = hash_iterate(serverHash)) == NULL) return -1; *label = obj->cookie; return obj->index; } void edns_cookie_server_reset() { serverHash = NULL; server_next_idx = 0; }