1/* Miscellaneous utilities. 2 Copyright (C) 2019-2020 Free Software Foundation, Inc. 3 4 This file is part of libctf. 5 6 libctf is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 This program is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 14 See the GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; see the file COPYING. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20#include <ctf-impl.h> 21#include <string.h> 22 23/* Simple doubly-linked list append routine. This implementation assumes that 24 each list element contains an embedded ctf_list_t as the first member. 25 An additional ctf_list_t is used to store the head (l_next) and tail 26 (l_prev) pointers. The current head and tail list elements have their 27 previous and next pointers set to NULL, respectively. */ 28 29void 30ctf_list_append (ctf_list_t *lp, void *newp) 31{ 32 ctf_list_t *p = lp->l_prev; /* p = tail list element. */ 33 ctf_list_t *q = newp; /* q = new list element. */ 34 35 lp->l_prev = q; 36 q->l_prev = p; 37 q->l_next = NULL; 38 39 if (p != NULL) 40 p->l_next = q; 41 else 42 lp->l_next = q; 43} 44 45/* Prepend the specified existing element to the given ctf_list_t. The 46 existing pointer should be pointing at a struct with embedded ctf_list_t. */ 47 48void 49ctf_list_prepend (ctf_list_t * lp, void *newp) 50{ 51 ctf_list_t *p = newp; /* p = new list element. */ 52 ctf_list_t *q = lp->l_next; /* q = head list element. */ 53 54 lp->l_next = p; 55 p->l_prev = NULL; 56 p->l_next = q; 57 58 if (q != NULL) 59 q->l_prev = p; 60 else 61 lp->l_prev = p; 62} 63 64/* Delete the specified existing element from the given ctf_list_t. The 65 existing pointer should be pointing at a struct with embedded ctf_list_t. */ 66 67void 68ctf_list_delete (ctf_list_t *lp, void *existing) 69{ 70 ctf_list_t *p = existing; 71 72 if (p->l_prev != NULL) 73 p->l_prev->l_next = p->l_next; 74 else 75 lp->l_next = p->l_next; 76 77 if (p->l_next != NULL) 78 p->l_next->l_prev = p->l_prev; 79 else 80 lp->l_prev = p->l_prev; 81} 82 83/* Return 1 if the list is empty. */ 84 85int 86ctf_list_empty_p (ctf_list_t *lp) 87{ 88 return (lp->l_next == NULL && lp->l_prev == NULL); 89} 90 91/* Convert a 32-bit ELF symbol into Elf64 and return a pointer to it. */ 92 93Elf64_Sym * 94ctf_sym_to_elf64 (const Elf32_Sym *src, Elf64_Sym *dst) 95{ 96 dst->st_name = src->st_name; 97 dst->st_value = src->st_value; 98 dst->st_size = src->st_size; 99 dst->st_info = src->st_info; 100 dst->st_other = src->st_other; 101 dst->st_shndx = src->st_shndx; 102 103 return dst; 104} 105 106/* A string appender working on dynamic strings. Returns NULL on OOM. */ 107 108char * 109ctf_str_append (char *s, const char *append) 110{ 111 size_t s_len = 0; 112 113 if (append == NULL) 114 return s; 115 116 if (s != NULL) 117 s_len = strlen (s); 118 119 size_t append_len = strlen (append); 120 121 if ((s = realloc (s, s_len + append_len + 1)) == NULL) 122 return NULL; 123 124 memcpy (s + s_len, append, append_len); 125 s[s_len + append_len] = '\0'; 126 127 return s; 128} 129 130/* A version of ctf_str_append that returns the old string on OOM. */ 131 132char * 133ctf_str_append_noerr (char *s, const char *append) 134{ 135 char *new_s; 136 137 new_s = ctf_str_append (s, append); 138 if (!new_s) 139 return s; 140 return new_s; 141} 142 143/* A realloc() that fails noisily if called with any ctf_str_num_users. */ 144void * 145ctf_realloc (ctf_file_t *fp, void *ptr, size_t size) 146{ 147 if (fp->ctf_str_num_refs > 0) 148 { 149 ctf_dprintf ("%p: attempt to realloc() string table with %lu active refs\n", 150 (void *) fp, (unsigned long) fp->ctf_str_num_refs); 151 return NULL; 152 } 153 return realloc (ptr, size); 154} 155 156/* Store the specified error code into errp if it is non-NULL, and then 157 return NULL for the benefit of the caller. */ 158 159void * 160ctf_set_open_errno (int *errp, int error) 161{ 162 if (errp != NULL) 163 *errp = error; 164 return NULL; 165} 166 167/* Store the specified error code into the CTF container, and then return 168 CTF_ERR / -1 for the benefit of the caller. */ 169 170unsigned long 171ctf_set_errno (ctf_file_t * fp, int err) 172{ 173 fp->ctf_errno = err; 174 return CTF_ERR; 175} 176