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 29 void 30 ctf_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 48 void 49 ctf_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 67 void 68 ctf_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 85 int 86 ctf_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 93 Elf64_Sym * 94 ctf_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 108 char * 109 ctf_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 132 char * 133 ctf_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. */ 144 void * 145 ctf_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 159 void * 160 ctf_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 170 unsigned long 171 ctf_set_errno (ctf_file_t * fp, int err) 172 { 173 fp->ctf_errno = err; 174 return CTF_ERR; 175 } 176