1 /* Simple subrs. 2 Copyright (C) 2019-2024 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 #ifdef HAVE_MMAP 22 #include <sys/mman.h> 23 #endif 24 #include <sys/types.h> 25 #include <stdarg.h> 26 #include <string.h> 27 #include <unistd.h> 28 29 #ifndef ENOTSUP 30 #define ENOTSUP ENOSYS 31 #endif 32 33 int _libctf_version = CTF_VERSION; /* Library client version. */ 34 int _libctf_debug = 0; /* Debugging messages enabled. */ 35 36 /* Private, read-only mmap from a file, with fallback to copying. 37 38 No handling of page-offset issues at all: the caller must allow for that. */ 39 40 _libctf_malloc_ void * 41 ctf_mmap (size_t length, size_t offset, int fd) 42 { 43 void *data; 44 45 #ifdef HAVE_MMAP 46 data = mmap (NULL, length, PROT_READ, MAP_PRIVATE, fd, offset); 47 if (data == MAP_FAILED) 48 data = NULL; 49 #else 50 if ((data = malloc (length)) != NULL) 51 { 52 if (ctf_pread (fd, data, length, offset) <= 0) 53 { 54 free (data); 55 data = NULL; 56 } 57 } 58 #endif 59 return data; 60 } 61 62 void 63 ctf_munmap (void *buf, size_t length _libctf_unused_) 64 { 65 #ifdef HAVE_MMAP 66 (void) munmap (buf, length); 67 #else 68 free (buf); 69 #endif 70 } 71 72 ssize_t 73 ctf_pread (int fd, void *buf, ssize_t count, off_t offset) 74 { 75 ssize_t len; 76 size_t acc = 0; 77 char *data = (char *) buf; 78 79 #ifdef HAVE_PREAD 80 while (count > 0) 81 { 82 errno = 0; 83 if (((len = pread (fd, data, count, offset)) < 0) && 84 errno != EINTR) 85 return len; 86 if (errno == EINTR) 87 continue; 88 89 acc += len; 90 if (len == 0) /* EOF. */ 91 return acc; 92 93 count -= len; 94 offset += len; 95 data += len; 96 } 97 return acc; 98 #else 99 off_t orig_off; 100 101 if ((orig_off = lseek (fd, 0, SEEK_CUR)) < 0) 102 return -1; 103 if ((lseek (fd, offset, SEEK_SET)) < 0) 104 return -1; 105 106 while (count > 0) 107 { 108 errno = 0; 109 if (((len = read (fd, data, count)) < 0) && 110 errno != EINTR) 111 return len; 112 if (errno == EINTR) 113 continue; 114 115 acc += len; 116 if (len == 0) /* EOF. */ 117 break; 118 119 count -= len; 120 data += len; 121 } 122 if ((lseek (fd, orig_off, SEEK_SET)) < 0) 123 return -1; /* offset is smashed. */ 124 #endif 125 126 return acc; 127 } 128 129 /* Set the CTF library client version to the specified version. If version is 130 zero, we just return the default library version number. */ 131 int 132 ctf_version (int version) 133 { 134 if (version < 0) 135 { 136 errno = EINVAL; 137 return -1; 138 } 139 140 if (version > 0) 141 { 142 /* Dynamic version switching is not presently supported. */ 143 if (version != CTF_VERSION) 144 { 145 errno = ENOTSUP; 146 return -1; 147 } 148 ctf_dprintf ("ctf_version: client using version %d\n", version); 149 _libctf_version = version; 150 } 151 152 return _libctf_version; 153 } 154 155 void 156 libctf_init_debug (void) 157 { 158 static int inited; 159 if (!inited) 160 { 161 _libctf_debug = getenv ("LIBCTF_DEBUG") != NULL; 162 inited = 1; 163 } 164 } 165 166 void ctf_setdebug (int debug) 167 { 168 /* Ensure that libctf_init_debug() has been called, so that we don't get our 169 debugging-on-or-off smashed by the next call. */ 170 171 libctf_init_debug(); 172 _libctf_debug = debug; 173 ctf_dprintf ("CTF debugging set to %i\n", debug); 174 } 175 176 int ctf_getdebug (void) 177 { 178 return _libctf_debug; 179 } 180 181 _libctf_printflike_ (1, 2) 182 void ctf_dprintf (const char *format, ...) 183 { 184 if (_libctf_unlikely_ (_libctf_debug)) 185 { 186 va_list alist; 187 188 va_start (alist, format); 189 fflush (stdout); 190 (void) fputs ("libctf DEBUG: ", stderr); 191 (void) vfprintf (stderr, format, alist); 192 va_end (alist); 193 } 194 } 195 196 /* This needs more attention to thread-safety later on. */ 197 static ctf_list_t open_errors; 198 199 /* Errors and warnings. Report the warning or error to the list in FP (or the 200 open errors list if NULL): if ERR is nonzero it is the errno to report to the 201 debug stream instead of that recorded on fp. */ 202 _libctf_printflike_ (4, 5) 203 extern void 204 ctf_err_warn (ctf_dict_t *fp, int is_warning, int err, 205 const char *format, ...) 206 { 207 va_list alist; 208 ctf_err_warning_t *cew; 209 210 /* Don't bother reporting errors here: we can't do much about them if they 211 happen. If we're so short of memory that a tiny malloc doesn't work, a 212 vfprintf isn't going to work either and the caller will have to rely on the 213 ENOMEM return they'll be getting in short order anyway. */ 214 215 if ((cew = malloc (sizeof (ctf_err_warning_t))) == NULL) 216 return; 217 218 cew->cew_is_warning = is_warning; 219 va_start (alist, format); 220 if (vasprintf (&cew->cew_text, format, alist) < 0) 221 { 222 free (cew); 223 va_end (alist); 224 return; 225 } 226 va_end (alist); 227 228 /* Include the error code only if there is one; if this is a warning, 229 only use the error code if it was explicitly passed and is nonzero. 230 (Warnings may not have a meaningful error code, since the warning may not 231 lead to unwinding up to the user.) */ 232 if ((!is_warning && (err != 0 || (fp && ctf_errno (fp) != 0))) 233 || (is_warning && err != 0)) 234 ctf_dprintf ("%s: %s (%s)\n", is_warning ? _("error") : _("warning"), 235 cew->cew_text, err != 0 ? ctf_errmsg (err) 236 : ctf_errmsg (ctf_errno (fp))); 237 else 238 ctf_dprintf ("%s: %s\n", is_warning ? _("error") : _("warning"), 239 cew->cew_text); 240 241 if (fp != NULL) 242 ctf_list_append (&fp->ctf_errs_warnings, cew); 243 else 244 ctf_list_append (&open_errors, cew); 245 } 246 247 /* Move all the errors/warnings from an fp into the open_errors. */ 248 void 249 ctf_err_warn_to_open (ctf_dict_t *fp) 250 { 251 ctf_list_splice (&open_errors, &fp->ctf_errs_warnings); 252 } 253 254 /* Error-warning reporting: an 'iterator' that returns errors and warnings from 255 the error/warning list, in order of emission. Errors and warnings are popped 256 after return: the caller must free the returned error-text pointer. 257 258 An fp of NULL returns CTF-open-time errors from the open_errors variable 259 above. 260 261 The treatment of errors from this function itself is somewhat unusual: it 262 will often be called on an error path, so we don't want to overwrite the 263 ctf_errno unless we have no choice. So, like ctf_bufopen et al, this 264 function takes an errp pointer where errors are reported. The pointer is 265 optional: if not set, errors are reported via the fp (if non-NULL). Calls 266 with neither fp nor errp set are mildly problematic because there is no clear 267 way to report end-of-iteration: you just have to assume that a NULL return 268 means the end, and not an iterator error. */ 269 270 char * 271 ctf_errwarning_next (ctf_dict_t *fp, ctf_next_t **it, int *is_warning, 272 int *errp) 273 { 274 ctf_next_t *i = *it; 275 char *ret; 276 ctf_list_t *errlist; 277 ctf_err_warning_t *cew; 278 279 if (fp) 280 errlist = &fp->ctf_errs_warnings; 281 else 282 errlist = &open_errors; 283 284 if (!i) 285 { 286 if ((i = ctf_next_create ()) == NULL) 287 { 288 if (errp) 289 *errp = ENOMEM; 290 else if (fp) 291 ctf_set_errno (fp, ENOMEM); 292 return NULL; 293 } 294 295 i->cu.ctn_fp = fp; 296 i->ctn_iter_fun = (void (*) (void)) ctf_errwarning_next; 297 *it = i; 298 } 299 300 if ((void (*) (void)) ctf_errwarning_next != i->ctn_iter_fun) 301 { 302 if (errp) 303 *errp = ECTF_NEXT_WRONGFUN; 304 else if (fp) 305 ctf_set_errno (fp, ECTF_NEXT_WRONGFUN); 306 return NULL; 307 } 308 309 if (fp != i->cu.ctn_fp) 310 { 311 if (errp) 312 *errp = ECTF_NEXT_WRONGFP; 313 else if (fp) 314 ctf_set_errno (fp, ECTF_NEXT_WRONGFP); 315 return NULL; 316 } 317 318 cew = ctf_list_next (errlist); 319 320 if (!cew) 321 { 322 ctf_next_destroy (i); 323 *it = NULL; 324 if (errp) 325 *errp = ECTF_NEXT_END; 326 else if (fp) 327 ctf_set_errno (fp, ECTF_NEXT_END); 328 return NULL; 329 } 330 331 if (is_warning) 332 *is_warning = cew->cew_is_warning; 333 ret = cew->cew_text; 334 ctf_list_delete (errlist, cew); 335 free (cew); 336 return ret; 337 } 338 339 void 340 ctf_assert_fail_internal (ctf_dict_t *fp, const char *file, size_t line, 341 const char *exprstr) 342 { 343 ctf_set_errno (fp, ECTF_INTERNAL); 344 ctf_err_warn (fp, 0, 0, _("%s: %lu: libctf assertion failed: %s"), 345 file, (long unsigned int) line, exprstr); 346 } 347