116Salm/* Simple subrs. 216Salm Copyright (C) 2019-2020 Free Software Foundation, Inc. 318471Swosch 450471Speter This file is part of libctf. 516Salm 616Salm libctf is free software; you can redistribute it and/or modify it under 716Salm the terms of the GNU General Public License as published by the Free 816Salm Software Foundation; either version 3, or (at your option) any later 916Salm version. 1016Salm 1116Salm This program is distributed in the hope that it will be useful, but 1216Salm WITHOUT ANY WARRANTY; without even the implied warranty of 131057Salm MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 141057Salm See the GNU General Public License for more details. 151057Salm 161057Salm You should have received a copy of the GNU General Public License 171057Salm along with this program; see the file COPYING. If not see 181057Salm <http://www.gnu.org/licenses/>. */ 191057Salm 201057Salm#include <ctf-impl.h> 211057Salm#ifdef HAVE_MMAP 221057Salm#include <sys/mman.h> 231057Salm#endif 241057Salm#include <sys/types.h> 251057Salm#include <stdarg.h> 261057Salm#include <string.h> 271057Salm#include <unistd.h> 281057Salm 291057Salm#ifndef ENOTSUP 301057Salm#define ENOTSUP ENOSYS 311057Salm#endif 321057Salm 331057Salmint _libctf_version = CTF_VERSION; /* Library client version. */ 341057Salmint _libctf_debug = 0; /* Debugging messages enabled. */ 351057Salm 361057Salm/* Private, read-only mmap from a file, with fallback to copying. 371057Salm 381057Salm No handling of page-offset issues at all: the caller must allow for that. */ 391057Salm 401057Salm_libctf_malloc_ void * 4116Salmctf_mmap (size_t length, size_t offset, int fd) 4216Salm{ 4316Salm void *data; 4416Salm 4516Salm#ifdef HAVE_MMAP 461057Salm data = mmap (NULL, length, PROT_READ, MAP_PRIVATE, fd, offset); 471057Salm if (data == MAP_FAILED) 481057Salm data = NULL; 491057Salm#else 501057Salm if ((data = malloc (length)) != NULL) 511057Salm { 521057Salm if (ctf_pread (fd, data, length, offset) <= 0) 531057Salm { 541057Salm free (data); 551057Salm data = NULL; 561057Salm } 571057Salm } 581057Salm#endif 591057Salm return data; 601057Salm} 611057Salm 621057Salmvoid 631057Salmctf_munmap (void *buf, size_t length _libctf_unused_) 641057Salm{ 651057Salm#ifdef HAVE_MMAP 661057Salm (void) munmap (buf, length); 671057Salm#else 681057Salm free (buf); 691057Salm#endif 701057Salm} 711057Salm 721057Salmssize_t 731057Salmctf_pread (int fd, void *buf, ssize_t count, off_t offset) 741057Salm{ 7516Salm 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. */ 131int 132ctf_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 155void 156libctf_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 166void 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 176int ctf_getdebug (void) 177{ 178 return _libctf_debug; 179} 180 181_libctf_printflike_ (1, 2) 182void 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. */ 197static 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) 203extern void 204ctf_err_warn (ctf_file_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, and if this is not a warning. 229 (Warnings may not have a meaningful error code, since the warning may not 230 lead to unwinding up to the user.) */ 231 if (!is_warning && (err != 0 || (fp && ctf_errno (fp) != 0))) 232 ctf_dprintf ("%s: %s (%s)\n", is_warning ? _("error") : _("warning"), 233 cew->cew_text, err != 0 ? ctf_errmsg (err) 234 : ctf_errmsg (ctf_errno (fp))); 235 else 236 ctf_dprintf ("%s: %s\n", is_warning ? _("error") : _("warning"), 237 cew->cew_text); 238 239 if (fp != NULL) 240 ctf_list_append (&fp->ctf_errs_warnings, cew); 241 else 242 ctf_list_append (&open_errors, cew); 243} 244 245/* Move all the errors/warnings from an fp into the open_errors. */ 246void 247ctf_err_warn_to_open (ctf_file_t *fp) 248{ 249 ctf_list_splice (&open_errors, &fp->ctf_errs_warnings); 250} 251 252/* Error-warning reporting: an 'iterator' that returns errors and warnings from 253 the error/warning list, in order of emission. Errors and warnings are popped 254 after return: the caller must free the returned error-text pointer. 255 256 An fp of NULL returns CTF-open-time errors from the open_errors variable 257 above. 258 259 The treatment of errors from this function itself is somewhat unusual: it 260 will often be called on an error path, so we don't want to overwrite the 261 ctf_errno unless we have no choice. So, like ctf_bufopen et al, this 262 function takes an errp pointer where errors are reported. The pointer is 263 optional: if not set, errors are reported via the fp (if non-NULL). Calls 264 with neither fp nor errp set are mildly problematic because there is no clear 265 way to report end-of-iteration: you just have to assume that a NULL return 266 means the end, and not an iterator error. */ 267 268char * 269ctf_errwarning_next (ctf_file_t *fp, ctf_next_t **it, int *is_warning, 270 int *errp) 271{ 272 ctf_next_t *i = *it; 273 char *ret; 274 ctf_list_t *errlist; 275 ctf_err_warning_t *cew; 276 277 if (fp) 278 errlist = &fp->ctf_errs_warnings; 279 else 280 errlist = &open_errors; 281 282 if (!i) 283 { 284 if ((i = ctf_next_create ()) == NULL) 285 { 286 if (errp) 287 *errp = ENOMEM; 288 else if (fp) 289 ctf_set_errno (fp, ENOMEM); 290 return NULL; 291 } 292 293 i->cu.ctn_fp = fp; 294 i->ctn_iter_fun = (void (*) (void)) ctf_errwarning_next; 295 *it = i; 296 } 297 298 if ((void (*) (void)) ctf_errwarning_next != i->ctn_iter_fun) 299 { 300 if (errp) 301 *errp = ECTF_NEXT_WRONGFUN; 302 else if (fp) 303 ctf_set_errno (fp, ECTF_NEXT_WRONGFUN); 304 return NULL; 305 } 306 307 if (fp != i->cu.ctn_fp) 308 { 309 if (errp) 310 *errp = ECTF_NEXT_WRONGFP; 311 else if (fp) 312 ctf_set_errno (fp, ECTF_NEXT_WRONGFP); 313 return NULL; 314 } 315 316 cew = ctf_list_next (errlist); 317 318 if (!cew) 319 { 320 ctf_next_destroy (i); 321 *it = NULL; 322 if (errp) 323 *errp = ECTF_NEXT_END; 324 else if (fp) 325 ctf_set_errno (fp, ECTF_NEXT_END); 326 return NULL; 327 } 328 329 if (is_warning) 330 *is_warning = cew->cew_is_warning; 331 ret = cew->cew_text; 332 ctf_list_delete (errlist, cew); 333 free (cew); 334 return ret; 335} 336 337void 338ctf_assert_fail_internal (ctf_file_t *fp, const char *file, size_t line, 339 const char *exprstr) 340{ 341 ctf_err_warn (fp, 0, ECTF_INTERNAL, _("%s: %lu: libctf assertion failed: %s"), 342 file, (long unsigned int) line, exprstr); 343 ctf_set_errno (fp, ECTF_INTERNAL); 344} 345