1/* Simple subrs.
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#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
33int _libctf_version = CTF_VERSION;	      /* Library client version.  */
34int _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 *
41ctf_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
62void
63ctf_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
72ssize_t
73ctf_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.  */
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