From: Michael Jeanson Date: Fri, 2 Apr 2021 19:19:51 +0000 (-0400) Subject: Add an internal 'libcommon' for utils X-Git-Tag: v2.13.0-rc1~145 X-Git-Url: https://git.lttng.org./?a=commitdiff_plain;h=d8621b3ea82b7fc1937b0eefb2b1316b2ce361a5;p=lttng-ust.git Add an internal 'libcommon' for utils Replicate the setup in tools and create a convenience library for internal utils. Move the 'snprintf' component to this internal lib. This is part of an effort to standardize our autotools setup across projects to simplify maintenance. Change-Id: I4e8ad48eda64a093b7e169474ad454b74a237e09 Signed-off-by: Michael Jeanson Signed-off-by: Mathieu Desnoyers --- diff --git a/.gitignore b/.gitignore index 37d46f9f..0e4a2464 100644 --- a/.gitignore +++ b/.gitignore @@ -15,6 +15,7 @@ Makefile.in *.info *.class cscope.* +.dirstamp /configure /aclocal.m4 @@ -148,7 +149,6 @@ cscope.* /src/libmsgpack/Makefile /src/libringbuffer/Makefile /src/python-lttngust/Makefile -/src/snprintf/Makefile /src/Makefile /tests/Makefile /tests/benchmark/Makefile diff --git a/configure.ac b/configure.ac index 00b70f2a..4c6eac89 100644 --- a/configure.ac +++ b/configure.ac @@ -548,7 +548,6 @@ AC_CONFIG_FILES([ src/python-lttngust/lttngust/version.py src/python-lttngust/Makefile src/python-lttngust/setup.py - src/snprintf/Makefile tests/benchmark/Makefile tests/compile/ctf-types/Makefile tests/compile/hello.cxx/Makefile diff --git a/src/Makefile.am b/src/Makefile.am index d9253053..28a32ba5 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -2,7 +2,6 @@ SUBDIRS = \ common \ - snprintf \ libringbuffer \ liblttng-ust-comm \ libcounter \ diff --git a/src/common/Makefile.am b/src/common/Makefile.am index 276c06a5..e73cc1fa 100644 --- a/src/common/Makefile.am +++ b/src/common/Makefile.am @@ -1,5 +1,7 @@ # SPDX-License-Identifier: LGPL-2.1-only +AUTOMAKE_OPTIONS = subdir-objects + ### ### ### Global private headers ### ### ### @@ -30,3 +32,37 @@ noinst_HEADERS += \ # Used by liblttng-ust-fd noinst_HEADERS += \ ust-fd.h + +### ### +## Convenience libraries ## +### ### + +noinst_LTLIBRARIES = \ + snprintf/libsnprintf.la \ + libcommon.la + +# snprintf +snprintf_libsnprintf_la_SOURCES = \ + snprintf/fflush.c \ + snprintf/fileext.h \ + snprintf/floatio.h \ + snprintf/fvwrite.c \ + snprintf/fvwrite.h \ + snprintf/local.h \ + snprintf/mbrtowc_sb.c \ + snprintf/snprintf.c \ + snprintf/various.h \ + snprintf/vfprintf.c \ + snprintf/wcio.h \ + snprintf/wsetup.c + +# Common library +libcommon_la_SOURCES = \ + logging.c \ + logging.h \ + patient.c + +libcommon_la_LIBADD = \ + snprintf/libsnprintf.la + +EXTRA_DIST = snprintf/README diff --git a/src/common/logging.c b/src/common/logging.c new file mode 100644 index 00000000..9841c68d --- /dev/null +++ b/src/common/logging.c @@ -0,0 +1,27 @@ +/* + * SPDX-License-Identifier: LGPL-2.1-only + * + * Copyright (C) 2011 Mathieu Desnoyers + */ + +#include "common/logging.h" + +volatile enum ust_err_loglevel ust_err_loglevel; + +void ust_err_init(void) +{ + char *ust_debug; + + if (ust_err_loglevel == UST_ERR_LOGLEVEL_UNKNOWN) { + /* + * This getenv is not part of lttng_ust_getenv() because it + * is required to print ERR() performed during getenv + * initialization. + */ + ust_debug = getenv("LTTNG_UST_DEBUG"); + if (ust_debug) + ust_err_loglevel = UST_ERR_LOGLEVEL_DEBUG; + else + ust_err_loglevel = UST_ERR_LOGLEVEL_NORMAL; + } +} diff --git a/src/common/patient.c b/src/common/patient.c new file mode 100644 index 00000000..517a16ad --- /dev/null +++ b/src/common/patient.c @@ -0,0 +1,120 @@ +/* + * SPDX-License-Identifier: LGPL-2.1-or-later + * + * Copyright (C) 2009 Pierre-Marc Fournier + * Copyright (C) 2011 Mathieu Desnoyers + */ + +#include + +/* write() */ +#include + +/* writev() */ +#include + +/* send() */ +#include +#include + +#include + +#include "common/patient.h" + +/* + * This write is patient because it restarts if it was incomplete. + */ + +ssize_t ust_patient_write(int fd, const void *buf, size_t count) +{ + const char *bufc = (const char *) buf; + int result; + + for(;;) { + result = write(fd, bufc, count); + if (result == -1 && errno == EINTR) { + continue; + } + if (result <= 0) { + return result; + } + count -= result; + bufc += result; + + if (count == 0) { + break; + } + } + + return bufc-(const char *)buf; +} + +/* + * The `struct iovec *iov` is not `const` because we modify it to support + * partial writes. + */ +ssize_t ust_patient_writev(int fd, struct iovec *iov, int iovcnt) +{ + ssize_t written, total_written = 0; + int curr_element_idx = 0; + + for(;;) { + written = writev(fd, iov + curr_element_idx, + iovcnt - curr_element_idx); + if (written == -1 && errno == EINTR) { + continue; + } + if (written <= 0) { + return written; + } + + total_written += written; + + /* + * If it's not the last element in the vector and we have + * written more than the current element size, then increment + * the current element index until we reach the element that + * was partially written. + */ + while (curr_element_idx < iovcnt && + written >= iov[curr_element_idx].iov_len) { + written -= iov[curr_element_idx].iov_len; + curr_element_idx++; + } + + /* Maybe we are done. */ + if (curr_element_idx >= iovcnt) { + break; + } + + /* Update the current element base and size. */ + iov[curr_element_idx].iov_base += written; + iov[curr_element_idx].iov_len -= written; + } + + return total_written; +} + +ssize_t ust_patient_send(int fd, const void *buf, size_t count, int flags) +{ + const char *bufc = (const char *) buf; + int result; + + for(;;) { + result = send(fd, bufc, count, flags); + if (result == -1 && errno == EINTR) { + continue; + } + if (result <= 0) { + return result; + } + count -= result; + bufc += result; + + if (count == 0) { + break; + } + } + + return bufc - (const char *) buf; +} diff --git a/src/common/snprintf/README b/src/common/snprintf/README new file mode 100644 index 00000000..73cb573e --- /dev/null +++ b/src/common/snprintf/README @@ -0,0 +1,2 @@ +This is a signal safe version of snprintf/vsnprintf. The code is +originally from the OpenBSD libc. diff --git a/src/common/snprintf/fflush.c b/src/common/snprintf/fflush.c new file mode 100644 index 00000000..26450efe --- /dev/null +++ b/src/common/snprintf/fflush.c @@ -0,0 +1,60 @@ +/* $OpenBSD: fflush.c,v 1.7 2009/10/22 01:23:16 guenther Exp $ */ +/* + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (C) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + */ + +#include +#include +#include "local.h" + +/* Flush a single file, or (if fp is NULL) all files. */ +int ust_safe_fflush(LTTNG_UST_LFILE *fp) +{ + + if (fp == NULL) + return 0; +// return (_fwalk(__sflush)); + if ((fp->_flags & (__SWR | __SRW)) == 0) { + errno = EBADF; + return (EOF); + } + return (__sflush(fp)); +} + +int +__sflush(LTTNG_UST_LFILE *fp) +{ + unsigned char *p; + int n, t; + + t = fp->_flags; + if ((t & __SWR) == 0) + return (0); + + if ((p = fp->_bf._base) == NULL) + return (0); + + n = fp->_p - p; /* write this much */ + + /* + * Set these immediately to avoid problems with longjmp and to allow + * exchange buffering (via setvbuf) in user write function. + */ + fp->_p = p; + fp->_w = t & (__SLBF|__SNBF) ? 0 : fp->_bf._size; + + for (; n > 0; n -= t, p += t) { + t = (*fp->_write)(fp->_cookie, (char *)p, n); + if (t <= 0) { + fp->_flags |= __SERR; + return (EOF); + } + } + return (0); +} diff --git a/src/common/snprintf/fileext.h b/src/common/snprintf/fileext.h new file mode 100644 index 00000000..d215c860 --- /dev/null +++ b/src/common/snprintf/fileext.h @@ -0,0 +1,35 @@ +/* $OpenBSD: fileext.h,v 1.2 2005/06/17 20:40:32 espie Exp $ */ +/* $NetBSD: fileext.h,v 1.5 2003/07/18 21:46:41 nathanw Exp $ */ + +/* + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (C)2001 Citrus Project, + * All rights reserved. + * + * $Citrus$ + */ + +/* + * file extension + */ +struct __lttng_ust_sfileext { + struct __lttng_ust_sbuf _ub; /* ungetc buffer */ + struct wchar_io_data _wcio; /* wide char io status */ +}; + +#define _EXT(fp) ((struct __lttng_ust_sfileext *)((fp)->_ext._base)) +#define _UB(fp) _EXT(fp)->_ub + +#define _FILEEXT_INIT(fp) \ +do { \ + _UB(fp)._base = NULL; \ + _UB(fp)._size = 0; \ + WCIO_INIT(fp); \ +} while (0) + +#define _FILEEXT_SETUP(f, fext) \ +do { \ + (f)->_ext._base = (unsigned char *)(fext); \ + _FILEEXT_INIT(f); \ +} while (0) diff --git a/src/common/snprintf/floatio.h b/src/common/snprintf/floatio.h new file mode 100644 index 00000000..deaa1934 --- /dev/null +++ b/src/common/snprintf/floatio.h @@ -0,0 +1,41 @@ +/* $OpenBSD: floatio.h,v 1.4 2008/09/07 20:36:08 martynas Exp $ */ + +/* + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (C) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + */ + +/* + * Floating point scanf/printf (input/output) definitions. + */ + +/* 11-bit exponent (VAX G floating point) is 308 decimal digits */ +#define MAXEXP 308 +/* 128 bit fraction takes up 39 decimal digits; max reasonable precision */ +#define MAXFRACT 39 + +/* + * MAXEXPDIG is the maximum number of decimal digits needed to store a + * floating point exponent in the largest supported format. It should + * be ceil(log10(LDBL_MAX_10_EXP)) or, if hexadecimal floating point + * conversions are supported, ceil(log10(LDBL_MAX_EXP)). But since it + * is presently never greater than 5 in practice, we fudge it. + */ +#define MAXEXPDIG 6 +#if LDBL_MAX_EXP > 999999 +#error "floating point buffers too small" +#endif + +char *__hdtoa(double, const char *, int, int *, int *, char **) + __attribute__((visibility("hidden"))); + +char *__hldtoa(long double, const char *, int, int *, int *, char **) + __attribute__((visibility("hidden"))); + +char *__ldtoa(long double *, int, int, int *, int *, char **) + __attribute__((visibility("hidden"))); diff --git a/src/common/snprintf/fvwrite.c b/src/common/snprintf/fvwrite.c new file mode 100644 index 00000000..c58e5786 --- /dev/null +++ b/src/common/snprintf/fvwrite.c @@ -0,0 +1,183 @@ +/* $OpenBSD: fvwrite.c,v 1.16 2009/10/22 01:23:16 guenther Exp $ */ +/* + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (C) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + */ + +#include +#include +#include +#include +#include "local.h" +#include "fvwrite.h" +#include "various.h" + +/* + * Write some memory regions. Return zero on success, EOF on error. + * + * This routine is large and unsightly, but most of the ugliness due + * to the three different kinds of output buffering is handled here. + */ +int +__sfvwrite(LTTNG_UST_LFILE *fp, struct __lttng_ust_suio *uio) +{ + size_t len; + char *p; + struct __lttng_ust_siov *iov; + int w, s; + char *nl; + int nlknown, nldist; + + if ((len = uio->uio_resid) == 0) + return (0); + /* make sure we can write */ + if (cantwrite(fp)) { + errno = EBADF; + return (EOF); + } + +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#define COPY(n) (void)memcpy((void *)fp->_p, (void *)p, (size_t)(n)) + + iov = uio->uio_iov; + p = iov->iov_base; + len = iov->iov_len; + iov++; +#define GETIOV(extra_work) \ + while (len == 0) { \ + extra_work; \ + p = iov->iov_base; \ + len = iov->iov_len; \ + iov++; \ + } + if (fp->_flags & __SNBF) { + /* + * Unbuffered: write up to BUFSIZ bytes at a time. + */ + do { + GETIOV(;); + w = (*fp->_write)(fp->_cookie, p, MIN(len, BUFSIZ)); + if (w <= 0) + goto err; + p += w; + len -= w; + } while ((uio->uio_resid -= w) != 0); + } else if ((fp->_flags & __SLBF) == 0) { + /* + * Fully buffered: fill partially full buffer, if any, + * and then flush. If there is no partial buffer, write + * one _bf._size byte chunk directly (without copying). + * + * String output is a special case: write as many bytes + * as fit, but pretend we wrote everything. This makes + * snprintf() return the number of bytes needed, rather + * than the number used, and avoids its write function + * (so that the write function can be invalid). + */ + do { + GETIOV(;); + if ((fp->_flags & (__SALC | __SSTR)) == + (__SALC | __SSTR) && fp->_w < len) { + size_t blen = fp->_p - fp->_bf._base; + unsigned char *_base; + int _size; + + /* Allocate space exponentially. */ + _size = fp->_bf._size; + do { + _size = (_size << 1) + 1; + } while (_size < blen + len); + _base = realloc(fp->_bf._base, _size + 1); + if (_base == NULL) + goto err; + fp->_w += _size - fp->_bf._size; + fp->_bf._base = _base; + fp->_bf._size = _size; + fp->_p = _base + blen; + } + w = fp->_w; + if (fp->_flags & __SSTR) { + if (len < w) + w = len; + COPY(w); /* copy MIN(fp->_w,len), */ + fp->_w -= w; + fp->_p += w; + w = len; /* but pretend copied all */ + } else if (fp->_p > fp->_bf._base && len > w) { + /* fill and flush */ + COPY(w); + /* fp->_w -= w; */ /* unneeded */ + fp->_p += w; + if (ust_safe_fflush(fp)) + goto err; + } else if (len >= (w = fp->_bf._size)) { + /* write directly */ + w = (*fp->_write)(fp->_cookie, p, w); + if (w <= 0) + goto err; + } else { + /* fill and done */ + w = len; + COPY(w); + fp->_w -= w; + fp->_p += w; + } + p += w; + len -= w; + } while ((uio->uio_resid -= w) != 0); + } else { + /* + * Line buffered: like fully buffered, but we + * must check for newlines. Compute the distance + * to the first newline (including the newline), + * or `infinity' if there is none, then pretend + * that the amount to write is MIN(len,nldist). + */ + nlknown = 0; + nldist = 0; /* XXX just to keep gcc happy */ + do { + GETIOV(nlknown = 0); + if (!nlknown) { + nl = memchr((void *)p, '\n', len); + nldist = nl ? nl + 1 - p : len + 1; + nlknown = 1; + } + s = MIN(len, nldist); + w = fp->_w + fp->_bf._size; + if (fp->_p > fp->_bf._base && s > w) { + COPY(w); + /* fp->_w -= w; */ + fp->_p += w; + if (ust_safe_fflush(fp)) + goto err; + } else if (s >= (w = fp->_bf._size)) { + w = (*fp->_write)(fp->_cookie, p, w); + if (w <= 0) + goto err; + } else { + w = s; + COPY(w); + fp->_w -= w; + fp->_p += w; + } + if ((nldist -= w) == 0) { + /* copied the newline: flush and forget */ + if (ust_safe_fflush(fp)) + goto err; + nlknown = 0; + } + p += w; + len -= w; + } while ((uio->uio_resid -= w) != 0); + } + return (0); + +err: + fp->_flags |= __SERR; + return (EOF); +} diff --git a/src/common/snprintf/fvwrite.h b/src/common/snprintf/fvwrite.h new file mode 100644 index 00000000..3fabf5f5 --- /dev/null +++ b/src/common/snprintf/fvwrite.h @@ -0,0 +1,29 @@ +/* $OpenBSD: fvwrite.h,v 1.5 2003/06/02 20:18:37 millert Exp $ */ + +/* + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (C) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + */ + +/* + * I/O descriptors for __sfvwrite(). + */ +#include + +struct __lttng_ust_siov { + void *iov_base; + size_t iov_len; +}; +struct __lttng_ust_suio { + struct __lttng_ust_siov *uio_iov; + int uio_iovcnt; + int uio_resid; +}; + +extern int __sfvwrite(LTTNG_UST_LFILE *, struct __lttng_ust_suio *) + __attribute__((visibility("hidden"))); diff --git a/src/common/snprintf/local.h b/src/common/snprintf/local.h new file mode 100644 index 00000000..6d71cf53 --- /dev/null +++ b/src/common/snprintf/local.h @@ -0,0 +1,100 @@ +/* $OpenBSD: local.h,v 1.14 2009/10/22 01:23:16 guenther Exp $ */ + +/* + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (C) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + */ + +/* + * Information local to this implementation of stdio, + * in particular, macros and private variables. + */ + +#include +#include +#include "various.h" +#include "wcio.h" +#include "fileext.h" + +int __sflush(LTTNG_UST_LFILE *) + __attribute__((visibility("hidden"))); + +LTTNG_UST_LFILE *__sfp(void) + __attribute__((visibility("hidden"))); + +int __srefill(LTTNG_UST_LFILE *) + __attribute__((visibility("hidden"))); + +int __sread(void *, char *, int) + __attribute__((visibility("hidden"))); + +int __swrite(void *, const char *, int) + __attribute__((visibility("hidden"))); + +fpos_t __sseek(void *, fpos_t, int) + __attribute__((visibility("hidden"))); + +int __sclose(void *) + __attribute__((visibility("hidden"))); + +void __sinit(void) + __attribute__((visibility("hidden"))); + +void _cleanup(void) + __attribute__((visibility("hidden"))); + +void __smakebuf(LTTNG_UST_LFILE *) + __attribute__((visibility("hidden"))); + +int __swhatbuf(LTTNG_UST_LFILE *, size_t *, int *) + __attribute__((visibility("hidden"))); + +int _fwalk(int (*)(LTTNG_UST_LFILE *)) + __attribute__((visibility("hidden"))); + +int __swsetup(LTTNG_UST_LFILE *) + __attribute__((visibility("hidden"))); + +int __sflags(const char *, int *) + __attribute__((visibility("hidden"))); + +wint_t __fgetwc_unlock(LTTNG_UST_LFILE *) + __attribute__((visibility("hidden"))); + +extern void __atexit_register_cleanup(void (*)(void)) + __attribute__((visibility("hidden"))); + +extern int __sdidinit + __attribute__((visibility("hidden"))); + +/* + * Return true if the given LTTNG_UST_LFILE cannot be written now. + */ +#define cantwrite(fp) \ + ((((fp)->_flags & __SWR) == 0 || (fp)->_bf._base == NULL) && \ + __swsetup(fp)) + +/* + * Test whether the given stdio file has an active ungetc buffer; + * release such a buffer, without restoring ordinary unread data. + */ +#define HASUB(fp) (_UB(fp)._base != NULL) +#define FREEUB(fp) { \ + if (_UB(fp)._base != (fp)->_ubuf) \ + free(_UB(fp)._base); \ + _UB(fp)._base = NULL; \ +} + +/* + * test for an fgetln() buffer. + */ +#define HASLB(fp) ((fp)->_lb._base != NULL) +#define FREELB(fp) { \ + free((char *)(fp)->_lb._base); \ + (fp)->_lb._base = NULL; \ +} diff --git a/src/common/snprintf/mbrtowc_sb.c b/src/common/snprintf/mbrtowc_sb.c new file mode 100644 index 00000000..6fcf93e8 --- /dev/null +++ b/src/common/snprintf/mbrtowc_sb.c @@ -0,0 +1,34 @@ +/* $OpenBSD: mbrtowc_sb.c,v 1.4 2005/11/27 20:03:06 cloder Exp $ */ +/* $NetBSD: multibyte_sb.c,v 1.4 2003/08/07 16:43:04 agc Exp $ */ + +/* + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (C) 1991 The Regents of the University of California. + * All rights reserved. + */ + +#include +#include +#include + +#include "various.h" + +/*ARGSUSED*/ +size_t +ust_safe_mbrtowc(wchar_t *pwc, const char *s, size_t n, + mbstate_t *ps __attribute__((unused))) +{ + + /* pwc may be NULL */ + /* s may be NULL */ + /* ps appears to be unused */ + + if (s == NULL) + return 0; + if (n == 0) + return (size_t)-1; + if (pwc) + *pwc = (wchar_t)(unsigned char)*s; + return (*s != '\0'); +} diff --git a/src/common/snprintf/snprintf.c b/src/common/snprintf/snprintf.c new file mode 100644 index 00000000..c297cb70 --- /dev/null +++ b/src/common/snprintf/snprintf.c @@ -0,0 +1,57 @@ +/* $OpenBSD: snprintf.c,v 1.16 2009/10/22 01:23:16 guenther Exp $ */ +/* + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (C) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + */ + +#include +#include +#include +#include +#include +#include "local.h" +#include "common/safe-snprintf.h" + +#define DUMMY_LEN 1 + +int ust_safe_vsnprintf(char *str, size_t n, const char *fmt, va_list ap) +{ + int ret; + char dummy[DUMMY_LEN]; + LTTNG_UST_LFILE f; + struct __lttng_ust_sfileext fext; + + /* While snprintf(3) specifies size_t stdio uses an int internally */ + if (n > INT_MAX) + n = INT_MAX; + /* Stdio internals do not deal correctly with zero length buffer */ + if (n == 0) { + str = dummy; + n = DUMMY_LEN; + } + _FILEEXT_SETUP(&f, &fext); + f._file = -1; + f._flags = __SWR | __SSTR; + f._bf._base = f._p = (unsigned char *)str; + f._bf._size = f._w = n - 1; + ret = ust_safe_vfprintf(&f, fmt, ap); + *f._p = '\0'; + return (ret); +} + +int ust_safe_snprintf(char *str, size_t n, const char *fmt, ...) +{ + va_list ap; + int ret; + + va_start(ap, fmt); + ret = ust_safe_vsnprintf(str, n, fmt, ap); + va_end(ap); + + return ret; +} diff --git a/src/common/snprintf/various.h b/src/common/snprintf/various.h new file mode 100644 index 00000000..067b1add --- /dev/null +++ b/src/common/snprintf/various.h @@ -0,0 +1,110 @@ +/* + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (C) 1990 The Regents of the University of California. + * All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + */ + +#ifndef UST_SNPRINTF_VARIOUS_H +#define UST_SNPRINTF_VARIOUS_H + +#include +#include +#include +#include + +struct __lttng_ust_sbuf { + unsigned char *_base; + int _size; +}; + +/* + * stdio state variables. + * + * The following always hold: + * + * if (_flags&(__SLBF|__SWR)) == (__SLBF|__SWR), + * _lbfsize is -_bf._size, else _lbfsize is 0 + * if _flags&__SRD, _w is 0 + * if _flags&__SWR, _r is 0 + * + * This ensures that the getc and putc macros (or inline functions) never + * try to write or read from a file that is in `read' or `write' mode. + * (Moreover, they can, and do, automatically switch from read mode to + * write mode, and back, on "r+" and "w+" files.) + * + * _lbfsize is used only to make the inline line-buffered output stream + * code as compact as possible. + * + * _ub, _up, and _ur are used when ungetc() pushes back more characters + * than fit in the current _bf, or when ungetc() pushes back a character + * that does not match the previous one in _bf. When this happens, + * _ub._base becomes non-nil (i.e., a stream has ungetc() data iff + * _ub._base!=NULL) and _up and _ur save the current values of _p and _r. + */ +typedef struct __lttng_ust_sFILE { + unsigned char *_p; /* current position in (some) buffer */ + int _r; /* read space left for getc() */ + int _w; /* write space left for putc() */ + short _flags; /* flags, below; this FILE is free if 0 */ + short _file; /* fileno, if Unix descriptor, else -1 */ + struct __lttng_ust_sbuf _bf; /* the buffer (at least 1 byte, if !NULL) */ + int _lbfsize; /* 0 or -_bf._size, for inline putc */ + + /* operations */ + void *_cookie; /* cookie passed to io functions */ + int (*_close)(void *); + int (*_read)(void *, char *, int); + fpos_t (*_seek)(void *, fpos_t, int); + int (*_write)(void *, const char *, int); + + /* extension data, to avoid further ABI breakage */ + struct __lttng_ust_sbuf _ext; + /* data for long sequences of ungetc() */ + unsigned char *_up; /* saved _p when _p is doing ungetc data */ + int _ur; /* saved _r when _r is counting ungetc data */ + + /* tricks to meet minimum requirements even when malloc() fails */ + unsigned char _ubuf[3]; /* guarantee an ungetc() buffer */ + unsigned char _nbuf[1]; /* guarantee a getc() buffer */ + + /* separate buffer for fgetln() when line crosses buffer boundary */ + struct __lttng_ust_sbuf _lb; /* buffer for fgetln() */ + + /* Unix stdio files get aligned to block boundaries on fseek() */ + int _blksize; /* stat.st_blksize (may be != _bf._size) */ + fpos_t _offset; /* current lseek offset */ +} LTTNG_UST_LFILE; + +#define __SLBF 0x0001 /* line buffered */ +#define __SNBF 0x0002 /* unbuffered */ +#define __SRD 0x0004 /* OK to read */ +#define __SWR 0x0008 /* OK to write */ + /* RD and WR are never simultaneously asserted */ +#define __SRW 0x0010 /* open for reading & writing */ +#define __SEOF 0x0020 /* found EOF */ +#define __SERR 0x0040 /* found error */ +#define __SMBF 0x0080 /* _buf is from malloc */ +#define __SAPP 0x0100 /* fdopen()ed in append mode */ +#define __SSTR 0x0200 /* this is an sprintf/snprintf string */ +#define __SOPT 0x0400 /* do fseek() optimisation */ +#define __SNPT 0x0800 /* do not do fseek() optimisation */ +#define __SOFF 0x1000 /* set iff _offset is in fact correct */ +#define __SMOD 0x2000 /* true => fgetln modified _p text */ +#define __SALC 0x4000 /* allocate string space dynamically */ + +#define __sferror(p) (((p)->_flags & __SERR) != 0) + +extern int ust_safe_fflush(LTTNG_UST_LFILE *fp) + __attribute__((visibility("hidden"))); + +extern int ust_safe_vfprintf(LTTNG_UST_LFILE *fp, const char *fmt0, va_list ap) + __attribute__((visibility("hidden"))); + +extern size_t ust_safe_mbrtowc(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps) + __attribute__((visibility("hidden"))); + +#endif /* UST_SNPRINTF_VARIOUS_H */ diff --git a/src/common/snprintf/vfprintf.c b/src/common/snprintf/vfprintf.c new file mode 100644 index 00000000..c2b07eb0 --- /dev/null +++ b/src/common/snprintf/vfprintf.c @@ -0,0 +1,1372 @@ +/* $OpenBSD: vfprintf.c,v 1.57 2009/10/28 21:15:02 naddy Exp $ */ +/* + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (C) 1990 The Regents of the University of California. + * All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + */ + +/* + * Actual printf innards. + * + * This code is large and complicated... + */ + +//#define FLOATING_POINT + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "local.h" +#include "fvwrite.h" +#include "various.h" + +static char null_str[] = "(null)"; +static char bad_base_str[] = "bug in ust_safe_vfprintf: bad base"; + +union arg { + int intarg; + unsigned int uintarg; + long longarg; + unsigned long ulongarg; + long long longlongarg; + unsigned long long ulonglongarg; + ptrdiff_t ptrdiffarg; + size_t sizearg; + size_t ssizearg; + intmax_t intmaxarg; + uintmax_t uintmaxarg; + void *pvoidarg; + char *pchararg; + signed char *pschararg; + short *pshortarg; + int *pintarg; + long *plongarg; + long long *plonglongarg; + ptrdiff_t *pptrdiffarg; + ssize_t *pssizearg; + intmax_t *pintmaxarg; +#ifdef FLOATING_POINT + double doublearg; + long double longdoublearg; +#endif +}; + +static int __find_arguments(const char *fmt0, va_list ap, union arg **argtable, + size_t *argtablesiz); +static int __grow_type_table(unsigned char **typetable, int *tablesize); + +/* + * Flush out all the vectors defined by the given uio, + * then reset it so that it can be reused. + */ +static int +__sprint(LTTNG_UST_LFILE *fp, struct __lttng_ust_suio *uio) +{ + int err; + + if (uio->uio_resid == 0) { + uio->uio_iovcnt = 0; + return (0); + } + err = __sfvwrite(fp, uio); + uio->uio_resid = 0; + uio->uio_iovcnt = 0; + return (err); +} + +/* + * Helper function for `fprintf to unbuffered unix file': creates a + * temporary buffer. We only work on write-only files; this avoids + * worries about ungetc buffers and so forth. + */ +//static int +//__sbprintf(LTTNG_UST_LFILE *fp, const char *fmt, va_list ap) +//{ +// int ret; +// LTTNG_UST_LFILE fake; +// struct __sfileext fakeext; +// unsigned char buf[BUFSIZ]; +// +// _FILEEXT_SETUP(&fake, &fakeext); +// /* copy the important variables */ +// fake._flags = fp->_flags & ~__SNBF; +// fake._file = fp->_file; +// fake._cookie = fp->_cookie; +// fake._write = fp->_write; +// +// /* set up the buffer */ +// fake._bf._base = fake._p = buf; +// fake._bf._size = fake._w = sizeof(buf); +// fake._lbfsize = 0; /* not actually used, but Just In Case */ +// +// /* do the work, then copy any error status */ +// ret = ust_safe_vfprintf(&fake, fmt, ap); +// if (ret >= 0 && fflush(&fake)) +// ret = EOF; +// if (fake._flags & __SERR) +// fp->_flags |= __SERR; +// return (ret); +//} + + +#ifdef FLOATING_POINT +#include +#include +#include +#include "floatio.h" + +#define DEFPREC 6 + +extern char *__dtoa(double, int, int, int *, int *, char **); +extern void __freedtoa(char *); +static int exponent(char *, int, int); +#endif /* FLOATING_POINT */ + +/* + * The size of the buffer we use as scratch space for integer + * conversions, among other things. Technically, we would need the + * most space for base 10 conversions with thousands' grouping + * characters between each pair of digits. 100 bytes is a + * conservative overestimate even for a 128-bit uintmax_t. + */ +#define BUF 100 + +#define STATIC_ARG_TBL_SIZE 8 /* Size of static argument table. */ + + +/* + * Macros for converting digits to letters and vice versa + */ +#define to_digit(c) ((c) - '0') +#define is_digit(c) ((unsigned)to_digit(c) <= 9) +#define to_char(n) ((n) + '0') + +/* + * Flags used during conversion. + */ +#define ALT 0x0001 /* alternate form */ +#define LADJUST 0x0004 /* left adjustment */ +#define LONGDBL 0x0008 /* long double; unimplemented */ +#define LONGINT 0x0010 /* long integer */ +#define LLONGINT 0x0020 /* long long integer */ +#define SHORTINT 0x0040 /* short integer */ +#define ZEROPAD 0x0080 /* zero (as opposed to blank) pad */ +#define FPT 0x0100 /* Floating point number */ +#define PTRINT 0x0200 /* (unsigned) ptrdiff_t */ +#define SIZEINT 0x0400 /* (signed) size_t */ +#define CHARINT 0x0800 /* 8 bit integer */ +#define MAXINT 0x1000 /* largest integer size (intmax_t) */ + +int ust_safe_vfprintf(LTTNG_UST_LFILE *fp, const char *fmt0, va_list ap) +{ + char *fmt; /* format string */ + int ch; /* character from fmt */ + int n, n2; /* handy integers (short term usage) */ + char *cp; /* handy char pointer (short term usage) */ + struct __lttng_ust_siov *iovp; /* for PRINT macro */ + int flags; /* flags as above */ + int ret; /* return value accumulator */ + int width; /* width from format (%8d), or 0 */ + int prec; /* precision from format; <0 for N/A */ + char sign; /* sign prefix (' ', '+', '-', or \0) */ + wchar_t wc; + mbstate_t ps; +#ifdef FLOATING_POINT + /* + * We can decompose the printed representation of floating + * point numbers into several parts, some of which may be empty: + * + * [+|-| ] [0x|0X] MMM . NNN [e|E|p|P] [+|-] ZZ + * A B ---C--- D E F + * + * A: 'sign' holds this value if present; '\0' otherwise + * B: ox[1] holds the 'x' or 'X'; '\0' if not hexadecimal + * C: cp points to the string MMMNNN. Leading and trailing + * zeros are not in the string and must be added. + * D: expchar holds this character; '\0' if no exponent, e.g. %f + * F: at least two digits for decimal, at least one digit for hex + */ + char *decimal_point = localeconv()->decimal_point; + int signflag; /* true if float is negative */ + union { /* floating point arguments %[aAeEfFgG] */ + double dbl; + long double ldbl; + } fparg; + int expt; /* integer value of exponent */ + char expchar; /* exponent character: [eEpP\0] */ + char *dtoaend; /* pointer to end of converted digits */ + int expsize; /* character count for expstr */ + int lead; /* sig figs before decimal or group sep */ + int ndig; /* actual number of digits returned by dtoa */ + char expstr[MAXEXPDIG+2]; /* buffer for exponent string: e+ZZZ */ + char *dtoaresult = NULL; +#endif + + uintmax_t _umax; /* integer arguments %[diouxX] */ + enum { OCT, DEC, HEX } base; /* base for %[diouxX] conversion */ + int dprec; /* a copy of prec if %[diouxX], 0 otherwise */ + int realsz; /* field size expanded by dprec */ + int size; /* size of converted field or string */ + const char *xdigs = NULL; /* digits for %[xX] conversion */ +#define NIOV 8 + struct __lttng_ust_suio uio; /* output information: summary */ + struct __lttng_ust_siov iov[NIOV];/* ... and individual io vectors */ + char buf[BUF]; /* buffer with space for digits of uintmax_t */ + char ox[2]; /* space for 0x; ox[1] is either x, X, or \0 */ + union arg *argtable; /* args, built due to positional arg */ + union arg statargtable[STATIC_ARG_TBL_SIZE]; + size_t argtablesiz; + int nextarg; /* 1-based argument index */ + va_list orgap; /* original argument pointer */ + + /* + * Choose PADSIZE to trade efficiency vs. size. If larger printf + * fields occur frequently, increase PADSIZE and make the initialisers + * below longer. + */ +#define PADSIZE 16 /* pad chunk size */ + static char blanks[PADSIZE] = + {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '}; + static char zeroes[PADSIZE] = + {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'}; + + static const char xdigs_lower[16] = "0123456789abcdef"; + static const char xdigs_upper[16] = "0123456789ABCDEF"; + + /* + * BEWARE, these `goto error' on error, and PAD uses `n'. + */ +#define PRINT(ptr, len) do { \ + iovp->iov_base = (ptr); \ + iovp->iov_len = (len); \ + uio.uio_resid += (len); \ + iovp++; \ + if (++uio.uio_iovcnt >= NIOV) { \ + if (__sprint(fp, &uio)) \ + goto error; \ + iovp = iov; \ + } \ +} while (0) +#define PAD(howmany, with) do { \ + if ((n = (howmany)) > 0) { \ + while (n > PADSIZE) { \ + PRINT(with, PADSIZE); \ + n -= PADSIZE; \ + } \ + PRINT(with, n); \ + } \ +} while (0) +#define PRINTANDPAD(p, ep, len, with) do { \ + n2 = (ep) - (p); \ + if (n2 > (len)) \ + n2 = (len); \ + if (n2 > 0) \ + PRINT((p), n2); \ + PAD((len) - (n2 > 0 ? n2 : 0), (with)); \ +} while(0) +#define FLUSH() do { \ + if (uio.uio_resid && __sprint(fp, &uio)) \ + goto error; \ + uio.uio_iovcnt = 0; \ + iovp = iov; \ +} while (0) + + /* + * To extend shorts properly, we need both signed and unsigned + * argument extraction methods. + */ +#define SARG() \ + ((intmax_t)(flags&MAXINT ? GETARG(intmax_t) : \ + flags&LLONGINT ? GETARG(long long) : \ + flags&LONGINT ? GETARG(long) : \ + flags&PTRINT ? GETARG(ptrdiff_t) : \ + flags&SIZEINT ? GETARG(ssize_t) : \ + flags&SHORTINT ? (short)GETARG(int) : \ + flags&CHARINT ? (__signed char)GETARG(int) : \ + GETARG(int))) +#define UARG() \ + ((uintmax_t)(flags&MAXINT ? GETARG(uintmax_t) : \ + flags&LLONGINT ? GETARG(unsigned long long) : \ + flags&LONGINT ? GETARG(unsigned long) : \ + flags&PTRINT ? (uintptr_t)GETARG(ptrdiff_t) : /* XXX */ \ + flags&SIZEINT ? GETARG(size_t) : \ + flags&SHORTINT ? (unsigned short)GETARG(int) : \ + flags&CHARINT ? (unsigned char)GETARG(int) : \ + GETARG(unsigned int))) + + /* + * Append a digit to a value and check for overflow. + */ +#define APPEND_DIGIT(val, dig) do { \ + if ((val) > INT_MAX / 10) \ + goto overflow; \ + (val) *= 10; \ + if ((val) > INT_MAX - to_digit((dig))) \ + goto overflow; \ + (val) += to_digit((dig)); \ +} while (0) + + /* + * Get * arguments, including the form *nn$. Preserve the nextarg + * that the argument can be gotten once the type is determined. + */ +#define GETASTER(val) \ + n2 = 0; \ + cp = fmt; \ + while (is_digit(*cp)) { \ + APPEND_DIGIT(n2, *cp); \ + cp++; \ + } \ + if (*cp == '$') { \ + int hold = nextarg; \ + if (argtable == NULL) { \ + argtable = statargtable; \ + __find_arguments(fmt0, orgap, &argtable, &argtablesiz); \ + } \ + nextarg = n2; \ + val = GETARG(int); \ + nextarg = hold; \ + fmt = ++cp; \ + } else { \ + val = GETARG(int); \ + } + +/* +* Get the argument indexed by nextarg. If the argument table is +* built, use it to get the argument. If its not, get the next +* argument (and arguments must be gotten sequentially). +*/ +#define GETARG(type) \ + ((argtable != NULL) ? *((type*)(&argtable[nextarg++])) : \ + (nextarg++, va_arg(ap, type))) + + _SET_ORIENTATION(fp, -1); + /* sorry, fprintf(read_only_file, "") returns EOF, not 0 */ + if (cantwrite(fp)) { + errno = EBADF; + return (EOF); + } + + /* optimise fprintf(stderr) (and other unbuffered Unix files) */ +// if ((fp->_flags & (__SNBF|__SWR|__SRW)) == (__SNBF|__SWR) && +// fp->_file >= 0) +// return (__sbprintf(fp, fmt0, ap)); + + fmt = (char *)fmt0; + argtable = NULL; + nextarg = 1; + va_copy(orgap, ap); + uio.uio_iov = iovp = iov; + uio.uio_resid = 0; + uio.uio_iovcnt = 0; + ret = 0; + + memset(&ps, 0, sizeof(ps)); + /* + * Scan the format for conversions (`%' character). + */ + for (;;) { + cp = fmt; + while ((n = ust_safe_mbrtowc(&wc, fmt, MB_CUR_MAX, &ps)) > 0) { + fmt += n; + if (wc == '%') { + fmt--; + break; + } + } + if (fmt != cp) { + ptrdiff_t m = fmt - cp; + if (m < 0 || m > INT_MAX - ret) + goto overflow; + PRINT(cp, m); + ret += m; + } + if (n <= 0) + goto done; + fmt++; /* skip over '%' */ + + flags = 0; + dprec = 0; + width = 0; + prec = -1; + sign = '\0'; + ox[1] = '\0'; + +rflag: ch = *fmt++; +reswitch: switch (ch) { + case ' ': + /* + * ``If the space and + flags both appear, the space + * flag will be ignored.'' + * -- ANSI X3J11 + */ + if (!sign) + sign = ' '; + goto rflag; + case '#': + flags |= ALT; + goto rflag; + case '\'': + /* grouping not implemented */ + goto rflag; + case '*': + /* + * ``A negative field width argument is taken as a + * - flag followed by a positive field width.'' + * -- ANSI X3J11 + * They don't exclude field widths read from args. + */ + GETASTER(width); + if (width >= 0) + goto rflag; + if (width == INT_MIN) + goto overflow; + width = -width; + /* FALLTHROUGH */ + case '-': + flags |= LADJUST; + goto rflag; + case '+': + sign = '+'; + goto rflag; + case '.': + if ((ch = *fmt++) == '*') { + GETASTER(n); + prec = n < 0 ? -1 : n; + goto rflag; + } + n = 0; + while (is_digit(ch)) { + APPEND_DIGIT(n, ch); + ch = *fmt++; + } + if (ch == '$') { + nextarg = n; + if (argtable == NULL) { + argtable = statargtable; + __find_arguments(fmt0, orgap, + &argtable, &argtablesiz); + } + goto rflag; + } + prec = n; + goto reswitch; + case '0': + /* + * ``Note that 0 is taken as a flag, not as the + * beginning of a field width.'' + * -- ANSI X3J11 + */ + flags |= ZEROPAD; + goto rflag; + case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + n = 0; + do { + APPEND_DIGIT(n, ch); + ch = *fmt++; + } while (is_digit(ch)); + if (ch == '$') { + nextarg = n; + if (argtable == NULL) { + argtable = statargtable; + __find_arguments(fmt0, orgap, + &argtable, &argtablesiz); + } + goto rflag; + } + width = n; + goto reswitch; +#ifdef FLOATING_POINT + case 'L': + flags |= LONGDBL; + goto rflag; +#endif + case 'h': + if (*fmt == 'h') { + fmt++; + flags |= CHARINT; + } else { + flags |= SHORTINT; + } + goto rflag; + case 'j': + flags |= MAXINT; + goto rflag; + case 'l': + if (*fmt == 'l') { + fmt++; + flags |= LLONGINT; + } else { + flags |= LONGINT; + } + goto rflag; + case 'q': + flags |= LLONGINT; + goto rflag; + case 't': + flags |= PTRINT; + goto rflag; + case 'z': + flags |= SIZEINT; + goto rflag; + case 'c': + *(cp = buf) = GETARG(int); + size = 1; + sign = '\0'; + break; + case 'D': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'd': + case 'i': + _umax = SARG(); + if ((intmax_t)_umax < 0) { + _umax = -_umax; + sign = '-'; + } + base = DEC; + goto number; +#ifdef FLOATING_POINT + case 'a': + case 'A': + if (ch == 'a') { + ox[1] = 'x'; + xdigs = xdigs_lower; + expchar = 'p'; + } else { + ox[1] = 'X'; + xdigs = xdigs_upper; + expchar = 'P'; + } + if (prec >= 0) + prec++; + if (dtoaresult) + __freedtoa(dtoaresult); + if (flags & LONGDBL) { + fparg.ldbl = GETARG(long double); + dtoaresult = cp = + __hldtoa(fparg.ldbl, xdigs, prec, + &expt, &signflag, &dtoaend); + if (dtoaresult == NULL) { + errno = ENOMEM; + goto error; + } + } else { + fparg.dbl = GETARG(double); + dtoaresult = cp = + __hdtoa(fparg.dbl, xdigs, prec, + &expt, &signflag, &dtoaend); + if (dtoaresult == NULL) { + errno = ENOMEM; + goto error; + } + } + if (prec < 0) + prec = dtoaend - cp; + if (expt == INT_MAX) + ox[1] = '\0'; + goto fp_common; + case 'e': + case 'E': + expchar = ch; + if (prec < 0) /* account for digit before decpt */ + prec = DEFPREC + 1; + else + prec++; + goto fp_begin; + case 'f': + case 'F': + expchar = '\0'; + goto fp_begin; + case 'g': + case 'G': + expchar = ch - ('g' - 'e'); + if (prec == 0) + prec = 1; +fp_begin: + if (prec < 0) + prec = DEFPREC; + if (dtoaresult) + __freedtoa(dtoaresult); + if (flags & LONGDBL) { + fparg.ldbl = GETARG(long double); + dtoaresult = cp = + __ldtoa(&fparg.ldbl, expchar ? 2 : 3, prec, + &expt, &signflag, &dtoaend); + if (dtoaresult == NULL) { + errno = ENOMEM; + goto error; + } + } else { + fparg.dbl = GETARG(double); + dtoaresult = cp = + __dtoa(fparg.dbl, expchar ? 2 : 3, prec, + &expt, &signflag, &dtoaend); + if (dtoaresult == NULL) { + errno = ENOMEM; + goto error; + } + if (expt == 9999) + expt = INT_MAX; + } +fp_common: + if (signflag) + sign = '-'; + if (expt == INT_MAX) { /* inf or nan */ + if (*cp == 'N') { + cp = (ch >= 'a') ? "nan" : "NAN"; + sign = '\0'; + } else + cp = (ch >= 'a') ? "inf" : "INF"; + size = 3; + flags &= ~ZEROPAD; + break; + } + flags |= FPT; + ndig = dtoaend - cp; + if (ch == 'g' || ch == 'G') { + if (expt > -4 && expt <= prec) { + /* Make %[gG] smell like %[fF] */ + expchar = '\0'; + if (flags & ALT) + prec -= expt; + else + prec = ndig - expt; + if (prec < 0) + prec = 0; + } else { + /* + * Make %[gG] smell like %[eE], but + * trim trailing zeroes if no # flag. + */ + if (!(flags & ALT)) + prec = ndig; + } + } + if (expchar) { + expsize = exponent(expstr, expt - 1, expchar); + size = expsize + prec; + if (prec > 1 || flags & ALT) + ++size; + } else { + /* space for digits before decimal point */ + if (expt > 0) + size = expt; + else /* "0" */ + size = 1; + /* space for decimal pt and following digits */ + if (prec || flags & ALT) + size += prec + 1; + lead = expt; + } + break; +#endif /* FLOATING_POINT */ + case 'n': + if (flags & LLONGINT) + *GETARG(long long *) = ret; + else if (flags & LONGINT) + *GETARG(long *) = ret; + else if (flags & SHORTINT) + *GETARG(short *) = ret; + else if (flags & CHARINT) + *GETARG(__signed char *) = ret; + else if (flags & PTRINT) + *GETARG(ptrdiff_t *) = ret; + else if (flags & SIZEINT) + *GETARG(ssize_t *) = ret; + else if (flags & MAXINT) + *GETARG(intmax_t *) = ret; + else + *GETARG(int *) = ret; + continue; /* no output */ + case 'O': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'o': + _umax = UARG(); + base = OCT; + goto nosign; + case 'p': + /* + * ``The argument shall be a pointer to void. The + * value of the pointer is converted to a sequence + * of printable characters, in an implementation- + * defined manner.'' + * -- ANSI X3J11 + */ + /* NOSTRICT */ + _umax = (u_long)GETARG(void *); + base = HEX; + xdigs = xdigs_lower; + ox[1] = 'x'; + goto nosign; + case 's': + if ((cp = GETARG(char *)) == NULL) + cp = null_str; + if (prec >= 0) { + /* + * can't use strlen; can only look for the + * NUL in the first `prec' characters, and + * strlen() will go further. + */ + char *p = memchr(cp, 0, prec); + + size = p ? (p - cp) : prec; + } else { + size_t len; + + if ((len = strlen(cp)) > INT_MAX) + goto overflow; + size = (int)len; + } + sign = '\0'; + break; + case 'U': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'u': + _umax = UARG(); + base = DEC; + goto nosign; + case 'X': + xdigs = xdigs_upper; + goto hex; + case 'x': + xdigs = xdigs_lower; +hex: _umax = UARG(); + base = HEX; + /* leading 0x/X only if non-zero */ + if (flags & ALT && _umax != 0) + ox[1] = ch; + + /* unsigned conversions */ +nosign: sign = '\0'; + /* + * ``... diouXx conversions ... if a precision is + * specified, the 0 flag will be ignored.'' + * -- ANSI X3J11 + */ +number: if ((dprec = prec) >= 0) + flags &= ~ZEROPAD; + + /* + * ``The result of converting a zero value with an + * explicit precision of zero is no characters.'' + * -- ANSI X3J11 + */ + cp = buf + BUF; + if (_umax != 0 || prec != 0) { + /* + * Unsigned mod is hard, and unsigned mod + * by a constant is easier than that by + * a variable; hence this switch. + */ + switch (base) { + case OCT: + do { + *--cp = to_char(_umax & 7); + _umax >>= 3; + } while (_umax); + /* handle octal leading 0 */ + if (flags & ALT && *cp != '0') + *--cp = '0'; + break; + + case DEC: + /* many numbers are 1 digit */ + while (_umax >= 10) { + *--cp = to_char(_umax % 10); + _umax /= 10; + } + *--cp = to_char(_umax); + break; + + case HEX: + do { + *--cp = xdigs[_umax & 15]; + _umax >>= 4; + } while (_umax); + break; + + default: + cp = bad_base_str; + size = strlen(cp); + goto skipsize; + } + } + size = buf + BUF - cp; + if (size > BUF) /* should never happen */ + abort(); + skipsize: + break; + default: /* "%?" prints ?, unless ? is NUL */ + if (ch == '\0') + goto done; + /* pretend it was %c with argument ch */ + cp = buf; + *cp = ch; + size = 1; + sign = '\0'; + break; + } + + /* + * All reasonable formats wind up here. At this point, `cp' + * points to a string which (if not flags&LADJUST) should be + * padded out to `width' places. If flags&ZEROPAD, it should + * first be prefixed by any sign or other prefix; otherwise, + * it should be blank padded before the prefix is emitted. + * After any left-hand padding and prefixing, emit zeroes + * required by a decimal %[diouxX] precision, then print the + * string proper, then emit zeroes required by any leftover + * floating precision; finally, if LADJUST, pad with blanks. + * + * Compute actual size, so we know how much to pad. + * size excludes decimal prec; realsz includes it. + */ + realsz = dprec > size ? dprec : size; + if (sign) + realsz++; + if (ox[1]) + realsz+= 2; + + /* right-adjusting blank padding */ + if ((flags & (LADJUST|ZEROPAD)) == 0) + PAD(width - realsz, blanks); + + /* prefix */ + if (sign) + PRINT(&sign, 1); + if (ox[1]) { /* ox[1] is either x, X, or \0 */ + ox[0] = '0'; + PRINT(ox, 2); + } + + /* right-adjusting zero padding */ + if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD) + PAD(width - realsz, zeroes); + + /* leading zeroes from decimal precision */ + PAD(dprec - size, zeroes); + + /* the string or number proper */ +#ifdef FLOATING_POINT + if ((flags & FPT) == 0) { + PRINT(cp, size); + } else { /* glue together f_p fragments */ + if (!expchar) { /* %[fF] or sufficiently short %[gG] */ + if (expt <= 0) { + PRINT(zeroes, 1); + if (prec || flags & ALT) + PRINT(decimal_point, 1); + PAD(-expt, zeroes); + /* already handled initial 0's */ + prec += expt; + } else { + PRINTANDPAD(cp, dtoaend, lead, zeroes); + cp += lead; + if (prec || flags & ALT) + PRINT(decimal_point, 1); + } + PRINTANDPAD(cp, dtoaend, prec, zeroes); + } else { /* %[eE] or sufficiently long %[gG] */ + if (prec > 1 || flags & ALT) { + buf[0] = *cp++; + buf[1] = *decimal_point; + PRINT(buf, 2); + PRINT(cp, ndig-1); + PAD(prec - ndig, zeroes); + } else { /* XeYYY */ + PRINT(cp, 1); + } + PRINT(expstr, expsize); + } + } +#else + PRINT(cp, size); +#endif + /* left-adjusting padding (always blank) */ + if (flags & LADJUST) + PAD(width - realsz, blanks); + + /* finally, adjust ret */ + if (width < realsz) + width = realsz; + if (width > INT_MAX - ret) + goto overflow; + ret += width; + + FLUSH(); /* copy out the I/O vectors */ + } +done: + FLUSH(); +error: + if (__sferror(fp)) + ret = -1; + goto finish; + +overflow: + errno = ENOMEM; + ret = -1; + +finish: + va_end(orgap); +#ifdef FLOATING_POINT + if (dtoaresult) + __freedtoa(dtoaresult); +#endif + if (argtable != NULL && argtable != statargtable) { + munmap(argtable, argtablesiz); + argtable = NULL; + } + return (ret); +} + +/* + * Type ids for argument type table. + */ +#define T_UNUSED 0 +#define T_SHORT 1 +#define T_U_SHORT 2 +#define TP_SHORT 3 +#define T_INT 4 +#define T_U_INT 5 +#define TP_INT 6 +#define T_LONG 7 +#define T_U_LONG 8 +#define TP_LONG 9 +#define T_LLONG 10 +#define T_U_LLONG 11 +#define TP_LLONG 12 +#define T_DOUBLE 13 +#define T_LONG_DOUBLE 14 +#define TP_CHAR 15 +#define TP_VOID 16 +#define T_PTRINT 17 +#define TP_PTRINT 18 +#define T_SIZEINT 19 +#define T_SSIZEINT 20 +#define TP_SSIZEINT 21 +#define T_MAXINT 22 +#define T_MAXUINT 23 +#define TP_MAXINT 24 +#define T_CHAR 25 +#define T_U_CHAR 26 + +/* + * Find all arguments when a positional parameter is encountered. Returns a + * table, indexed by argument number, of pointers to each arguments. The + * initial argument table should be an array of STATIC_ARG_TBL_SIZE entries. + * It will be replaced with a mmap-ed one if it overflows (malloc cannot be + * used since we are attempting to make snprintf thread safe, and alloca is + * problematic since we have nested functions..) + */ +static int +__find_arguments(const char *fmt0, va_list ap, union arg **argtable, + size_t *argtablesiz) +{ + char *fmt; /* format string */ + int ch; /* character from fmt */ + int n, n2; /* handy integer (short term usage) */ + char *cp; /* handy char pointer (short term usage) */ + int flags; /* flags as above */ + unsigned char *typetable; /* table of types */ + unsigned char stattypetable[STATIC_ARG_TBL_SIZE]; + int tablesize; /* current size of type table */ + int tablemax; /* largest used index in table */ + int nextarg; /* 1-based argument index */ + int ret = 0; /* return value */ + wchar_t wc; + mbstate_t ps; + + /* + * Add an argument type to the table, expanding if necessary. + */ +#define ADDTYPE(type) \ + ((nextarg >= tablesize) ? \ + __grow_type_table(&typetable, &tablesize) : 0, \ + (nextarg > tablemax) ? tablemax = nextarg : 0, \ + typetable[nextarg++] = type) + +#define ADDSARG() \ + ((flags&MAXINT) ? ADDTYPE(T_MAXINT) : \ + ((flags&PTRINT) ? ADDTYPE(T_PTRINT) : \ + ((flags&SIZEINT) ? ADDTYPE(T_SSIZEINT) : \ + ((flags&LLONGINT) ? ADDTYPE(T_LLONG) : \ + ((flags&LONGINT) ? ADDTYPE(T_LONG) : \ + ((flags&SHORTINT) ? ADDTYPE(T_SHORT) : \ + ((flags&CHARINT) ? ADDTYPE(T_CHAR) : ADDTYPE(T_INT)))))))) + +#define ADDUARG() \ + ((flags&MAXINT) ? ADDTYPE(T_MAXUINT) : \ + ((flags&PTRINT) ? ADDTYPE(T_PTRINT) : \ + ((flags&SIZEINT) ? ADDTYPE(T_SIZEINT) : \ + ((flags&LLONGINT) ? ADDTYPE(T_U_LLONG) : \ + ((flags&LONGINT) ? ADDTYPE(T_U_LONG) : \ + ((flags&SHORTINT) ? ADDTYPE(T_U_SHORT) : \ + ((flags&CHARINT) ? ADDTYPE(T_U_CHAR) : ADDTYPE(T_U_INT)))))))) + + /* + * Add * arguments to the type array. + */ +#define ADDASTER() \ + n2 = 0; \ + cp = fmt; \ + while (is_digit(*cp)) { \ + APPEND_DIGIT(n2, *cp); \ + cp++; \ + } \ + if (*cp == '$') { \ + int hold = nextarg; \ + nextarg = n2; \ + ADDTYPE(T_INT); \ + nextarg = hold; \ + fmt = ++cp; \ + } else { \ + ADDTYPE(T_INT); \ + } + fmt = (char *)fmt0; + typetable = stattypetable; + tablesize = STATIC_ARG_TBL_SIZE; + tablemax = 0; + nextarg = 1; + memset(typetable, T_UNUSED, STATIC_ARG_TBL_SIZE); + memset(&ps, 0, sizeof(ps)); + + /* + * Scan the format for conversions (`%' character). + */ + for (;;) { + cp = fmt; + while ((n = ust_safe_mbrtowc(&wc, fmt, MB_CUR_MAX, &ps)) > 0) { + fmt += n; + if (wc == '%') { + fmt--; + break; + } + } + if (n <= 0) + goto done; + fmt++; /* skip over '%' */ + + flags = 0; + +rflag: ch = *fmt++; +reswitch: switch (ch) { + case ' ': + case '#': + case '\'': + goto rflag; + case '*': + ADDASTER(); + goto rflag; + case '-': + case '+': + goto rflag; + case '.': + if ((ch = *fmt++) == '*') { + ADDASTER(); + goto rflag; + } + while (is_digit(ch)) { + ch = *fmt++; + } + goto reswitch; + case '0': + goto rflag; + case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + n = 0; + do { + APPEND_DIGIT(n ,ch); + ch = *fmt++; + } while (is_digit(ch)); + if (ch == '$') { + nextarg = n; + goto rflag; + } + goto reswitch; +#ifdef FLOATING_POINT + case 'L': + flags |= LONGDBL; + goto rflag; +#endif + case 'h': + if (*fmt == 'h') { + fmt++; + flags |= CHARINT; + } else { + flags |= SHORTINT; + } + goto rflag; + case 'l': + if (*fmt == 'l') { + fmt++; + flags |= LLONGINT; + } else { + flags |= LONGINT; + } + goto rflag; + case 'q': + flags |= LLONGINT; + goto rflag; + case 't': + flags |= PTRINT; + goto rflag; + case 'z': + flags |= SIZEINT; + goto rflag; + case 'c': + ADDTYPE(T_INT); + break; + case 'D': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'd': + case 'i': + ADDSARG(); + break; +#ifdef FLOATING_POINT + case 'a': + case 'A': + case 'e': + case 'E': + case 'f': + case 'F': + case 'g': + case 'G': + if (flags & LONGDBL) + ADDTYPE(T_LONG_DOUBLE); + else + ADDTYPE(T_DOUBLE); + break; +#endif /* FLOATING_POINT */ + case 'n': + if (flags & LLONGINT) + ADDTYPE(TP_LLONG); + else if (flags & LONGINT) + ADDTYPE(TP_LONG); + else if (flags & SHORTINT) + ADDTYPE(TP_SHORT); + else if (flags & PTRINT) + ADDTYPE(TP_PTRINT); + else if (flags & SIZEINT) + ADDTYPE(TP_SSIZEINT); + else if (flags & MAXINT) + ADDTYPE(TP_MAXINT); + else + ADDTYPE(TP_INT); + continue; /* no output */ + case 'O': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'o': + ADDUARG(); + break; + case 'p': + ADDTYPE(TP_VOID); + break; + case 's': + ADDTYPE(TP_CHAR); + break; + case 'U': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'u': + case 'X': + case 'x': + ADDUARG(); + break; + default: /* "%?" prints ?, unless ? is NUL */ + if (ch == '\0') + goto done; + break; + } + } +done: + /* + * Build the argument table. + */ + if (tablemax >= STATIC_ARG_TBL_SIZE) { + *argtablesiz = sizeof(union arg) * (tablemax + 1); + *argtable = mmap(NULL, *argtablesiz, + PROT_WRITE|PROT_READ, MAP_ANON|MAP_PRIVATE, -1, 0); + if (*argtable == MAP_FAILED) + return (-1); + } + +#if 0 + /* XXX is this required? */ + (*argtable)[0].intarg = 0; +#endif + for (n = 1; n <= tablemax; n++) { + switch (typetable[n]) { + case T_UNUSED: + case T_CHAR: + case T_U_CHAR: + case T_SHORT: + case T_U_SHORT: + case T_INT: + (*argtable)[n].intarg = va_arg(ap, int); + break; + case TP_SHORT: + (*argtable)[n].pshortarg = va_arg(ap, short *); + break; + case T_U_INT: + (*argtable)[n].uintarg = va_arg(ap, unsigned int); + break; + case TP_INT: + (*argtable)[n].pintarg = va_arg(ap, int *); + break; + case T_LONG: + (*argtable)[n].longarg = va_arg(ap, long); + break; + case T_U_LONG: + (*argtable)[n].ulongarg = va_arg(ap, unsigned long); + break; + case TP_LONG: + (*argtable)[n].plongarg = va_arg(ap, long *); + break; + case T_LLONG: + (*argtable)[n].longlongarg = va_arg(ap, long long); + break; + case T_U_LLONG: + (*argtable)[n].ulonglongarg = va_arg(ap, unsigned long long); + break; + case TP_LLONG: + (*argtable)[n].plonglongarg = va_arg(ap, long long *); + break; +#ifdef FLOATING_POINT + case T_DOUBLE: + (*argtable)[n].doublearg = va_arg(ap, double); + break; + case T_LONG_DOUBLE: + (*argtable)[n].longdoublearg = va_arg(ap, long double); + break; +#endif + case TP_CHAR: + (*argtable)[n].pchararg = va_arg(ap, char *); + break; + case TP_VOID: + (*argtable)[n].pvoidarg = va_arg(ap, void *); + break; + case T_PTRINT: + (*argtable)[n].ptrdiffarg = va_arg(ap, ptrdiff_t); + break; + case TP_PTRINT: + (*argtable)[n].pptrdiffarg = va_arg(ap, ptrdiff_t *); + break; + case T_SIZEINT: + (*argtable)[n].sizearg = va_arg(ap, size_t); + break; + case T_SSIZEINT: + (*argtable)[n].ssizearg = va_arg(ap, ssize_t); + break; + case TP_SSIZEINT: + (*argtable)[n].pssizearg = va_arg(ap, ssize_t *); + break; + case TP_MAXINT: + (*argtable)[n].intmaxarg = va_arg(ap, intmax_t); + break; + } + } + goto finish; + +overflow: + errno = ENOMEM; + ret = -1; + +finish: + if (typetable != NULL && typetable != stattypetable) { + munmap(typetable, *argtablesiz); + typetable = NULL; + } + return (ret); +} + +/* + * Increase the size of the type table. + */ +static int +__grow_type_table(unsigned char **typetable, int *tablesize) +{ + unsigned char *oldtable = *typetable; + int newsize = *tablesize * 2; + + if (newsize < getpagesize()) + newsize = getpagesize(); + + if (*tablesize == STATIC_ARG_TBL_SIZE) { + *typetable = mmap(NULL, newsize, PROT_WRITE|PROT_READ, + MAP_ANON|MAP_PRIVATE, -1, 0); + if (*typetable == MAP_FAILED) + return (-1); + bcopy(oldtable, *typetable, *tablesize); + } else { + unsigned char *new = mmap(NULL, newsize, PROT_WRITE|PROT_READ, + MAP_ANON|MAP_PRIVATE, -1, 0); + if (new == MAP_FAILED) + return (-1); + memmove(new, *typetable, *tablesize); + munmap(*typetable, *tablesize); + *typetable = new; + } + memset(*typetable + *tablesize, T_UNUSED, (newsize - *tablesize)); + + *tablesize = newsize; + return (0); +} + + +#ifdef FLOATING_POINT +static int +exponent(char *p0, int exp, int fmtch) +{ + char *p, *t; + char expbuf[MAXEXPDIG]; + + p = p0; + *p++ = fmtch; + if (exp < 0) { + exp = -exp; + *p++ = '-'; + } else + *p++ = '+'; + t = expbuf + MAXEXPDIG; + if (exp > 9) { + do { + *--t = to_char(exp % 10); + } while ((exp /= 10) > 9); + *--t = to_char(exp); + for (; t < expbuf + MAXEXPDIG; *p++ = *t++) + /* nothing */; + } else { + /* + * Exponents for decimal floating point conversions + * (%[eEgG]) must be at least two characters long, + * whereas exponents for hexadecimal conversions can + * be only one character long. + */ + if (fmtch == 'e' || fmtch == 'E') + *p++ = '0'; + *p++ = to_char(exp); + } + return (p - p0); +} +#endif /* FLOATING_POINT */ diff --git a/src/common/snprintf/wcio.h b/src/common/snprintf/wcio.h new file mode 100644 index 00000000..ec2c52e3 --- /dev/null +++ b/src/common/snprintf/wcio.h @@ -0,0 +1,68 @@ +/* $OpenBSD: wcio.h,v 1.1 2005/06/17 20:40:32 espie Exp $ */ +/* $NetBSD: wcio.h,v 1.3 2003/01/18 11:30:00 thorpej Exp $ */ + +/* + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (C)2001 Citrus Project, + * All rights reserved. + * + * $Citrus$ + */ + +#ifndef _WCIO_H_ +#define _WCIO_H_ + +#include +#include + +/* minimal requirement of SUSv2 */ +#define WCIO_UNGETWC_BUFSIZE 1 + +struct wchar_io_data { + mbstate_t wcio_mbstate_in; + mbstate_t wcio_mbstate_out; + + wchar_t wcio_ungetwc_buf[WCIO_UNGETWC_BUFSIZE]; + size_t wcio_ungetwc_inbuf; + + int wcio_mode; /* orientation */ +}; + +#define WCIO_GET(fp) \ + (_EXT(fp) ? &(_EXT(fp)->_wcio) : (struct wchar_io_data *)0) + +#define WCIO_GET_NONULL(fp) \ + (&(_EXT(fp)->_wcio)) + +#define _SET_ORIENTATION(fp, mode) \ +do {\ + struct wchar_io_data *_wcio = WCIO_GET(fp); \ + if (_wcio && _wcio->wcio_mode == 0) \ + _wcio->wcio_mode = (mode);\ +} while (0) + +/* + * WCIO_FREE should be called by fclose + */ +#define WCIO_FREE(fp) \ +do {\ + struct wchar_io_data *_wcio = WCIO_GET(fp); \ + if (_wcio) { \ + _wcio->wcio_mode = 0;\ + _wcio->wcio_ungetwc_inbuf = 0;\ + } \ +} while (0) + +#define WCIO_FREEUB(fp) \ +do {\ + struct wchar_io_data *_wcio = WCIO_GET(fp); \ + if (_wcio) { \ + _wcio->wcio_ungetwc_inbuf = 0;\ + } \ +} while (0) + +#define WCIO_INIT(fp) \ + memset(WCIO_GET_NONULL(fp), 0, sizeof(struct wchar_io_data)) + +#endif /*_WCIO_H_*/ diff --git a/src/common/snprintf/wsetup.c b/src/common/snprintf/wsetup.c new file mode 100644 index 00000000..3d2526b8 --- /dev/null +++ b/src/common/snprintf/wsetup.c @@ -0,0 +1,66 @@ +/* $OpenBSD: wsetup.c,v 1.7 2005/08/08 08:05:36 espie Exp $ */ +/* + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (C) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + */ + +#include +#include +#include +#include "local.h" + +/* + * Various output routines call wsetup to be sure it is safe to write, + * because either _flags does not include __SWR, or _buf is NULL. + * _wsetup returns 0 if OK to write, nonzero otherwise. + */ +int +__swsetup(LTTNG_UST_LFILE *fp) +{ + /* make sure stdio is set up */ +// if (!__sdidinit) +// __sinit(); + + /* + * If we are not writing, we had better be reading and writing. + */ + if ((fp->_flags & __SWR) == 0) { + if ((fp->_flags & __SRW) == 0) + return (EOF); + if (fp->_flags & __SRD) { + /* clobber any ungetc data */ + if (HASUB(fp)) + FREEUB(fp); + fp->_flags &= ~(__SRD|__SEOF); + fp->_r = 0; + fp->_p = fp->_bf._base; + } + fp->_flags |= __SWR; + } + + /* + * Make a buffer if necessary, then set _w. + */ + if (fp->_bf._base == NULL) { +// if ((fp->_flags & (__SSTR | __SALC)) == __SSTR) +// return (EOF); +// __smakebuf(fp); + assert(0); + } + if (fp->_flags & __SLBF) { + /* + * It is line buffered, so make _lbfsize be -_bufsize + * for the putc() macro. We will change _lbfsize back + * to 0 whenever we turn off __SWR. + */ + fp->_w = 0; + fp->_lbfsize = -fp->_bf._size; + } else + fp->_w = fp->_flags & __SNBF ? 0 : fp->_bf._size; + return (0); +} diff --git a/src/liblttng-ust-ctl/Makefile.am b/src/liblttng-ust-ctl/Makefile.am index 30c3879a..43a88566 100644 --- a/src/liblttng-ust-ctl/Makefile.am +++ b/src/liblttng-ust-ctl/Makefile.am @@ -12,5 +12,5 @@ liblttng_ust_ctl_la_LDFLAGS = \ liblttng_ust_ctl_la_LIBADD = \ $(top_builddir)/src/liblttng-ust-comm/liblttng-ust-comm.la \ $(top_builddir)/src/liblttng-ust/liblttng-ust-support.la \ - $(top_builddir)/src/snprintf/libustsnprintf.la \ + $(top_builddir)/src/common/libcommon.la \ $(DL_LIBS) diff --git a/src/liblttng-ust-dl/Makefile.am b/src/liblttng-ust-dl/Makefile.am index 3e919f7d..75149ea4 100644 --- a/src/liblttng-ust-dl/Makefile.am +++ b/src/liblttng-ust-dl/Makefile.am @@ -10,7 +10,7 @@ liblttng_ust_dl_la_SOURCES = \ liblttng_ust_dl_la_LIBADD = \ $(top_builddir)/src/liblttng-ust/liblttng-ust.la \ - $(top_builddir)/src/snprintf/libustsnprintf.la \ + $(top_builddir)/src/common/libcommon.la \ $(DL_LIBS) liblttng_ust_dl_la_CFLAGS = -DUST_COMPONENT=liblttng-ust-dl $(AM_CFLAGS) diff --git a/src/liblttng-ust/Makefile.am b/src/liblttng-ust/Makefile.am index 5d94be61..8892ff32 100644 --- a/src/liblttng-ust/Makefile.am +++ b/src/liblttng-ust/Makefile.am @@ -22,7 +22,7 @@ liblttng_ust_tracepoint_la_SOURCES = \ liblttng_ust_tracepoint_la_LIBADD = \ liblttng-ust-common.la \ - $(top_builddir)/src/snprintf/libustsnprintf.la \ + $(top_builddir)/src/common/libcommon.la \ $(DL_LIBS) liblttng_ust_tracepoint_la_LDFLAGS = -no-undefined -version-info $(LTTNG_UST_LIBRARY_VERSION) @@ -135,7 +135,7 @@ liblttng_ust_support_la_LIBADD = \ liblttng_ust_la_LIBADD = \ -lrt \ liblttng-ust-common.la \ - $(top_builddir)/src/snprintf/libustsnprintf.la \ + $(top_builddir)/src/common/libcommon.la \ $(top_builddir)/src/liblttng-ust-comm/liblttng-ust-comm.la \ liblttng-ust-tracepoint.la \ liblttng-ust-runtime.la liblttng-ust-support.la \ diff --git a/src/snprintf/Makefile.am b/src/snprintf/Makefile.am deleted file mode 100644 index 7d9e2b64..00000000 --- a/src/snprintf/Makefile.am +++ /dev/null @@ -1,26 +0,0 @@ -# SPDX-License-Identifier: LGPL-2.1-only - -AM_CPPFLAGS += -I$(top_srcdir)/libustcomm -AM_CFLAGS += -fno-strict-aliasing - -noinst_LTLIBRARIES = libustsnprintf.la -libustsnprintf_la_SOURCES = \ - fflush.c \ - fileext.h \ - floatio.h \ - fvwrite.c \ - fvwrite.h \ - local.h \ - mbrtowc_sb.c \ - snprintf.c \ - various.h \ - vfprintf.c \ - wcio.h \ - wsetup.c \ - core.c \ - patient_write.c - -libustsnprintf_la_LDFLAGS = -no-undefined -static -libustsnprintf_la_CFLAGS = -DUST_COMPONENT="lttng_ust_snprintf" -fPIC $(AM_CFLAGS) - -EXTRA_DIST = README diff --git a/src/snprintf/README b/src/snprintf/README deleted file mode 100644 index 73cb573e..00000000 --- a/src/snprintf/README +++ /dev/null @@ -1,2 +0,0 @@ -This is a signal safe version of snprintf/vsnprintf. The code is -originally from the OpenBSD libc. diff --git a/src/snprintf/core.c b/src/snprintf/core.c deleted file mode 100644 index 9841c68d..00000000 --- a/src/snprintf/core.c +++ /dev/null @@ -1,27 +0,0 @@ -/* - * SPDX-License-Identifier: LGPL-2.1-only - * - * Copyright (C) 2011 Mathieu Desnoyers - */ - -#include "common/logging.h" - -volatile enum ust_err_loglevel ust_err_loglevel; - -void ust_err_init(void) -{ - char *ust_debug; - - if (ust_err_loglevel == UST_ERR_LOGLEVEL_UNKNOWN) { - /* - * This getenv is not part of lttng_ust_getenv() because it - * is required to print ERR() performed during getenv - * initialization. - */ - ust_debug = getenv("LTTNG_UST_DEBUG"); - if (ust_debug) - ust_err_loglevel = UST_ERR_LOGLEVEL_DEBUG; - else - ust_err_loglevel = UST_ERR_LOGLEVEL_NORMAL; - } -} diff --git a/src/snprintf/fflush.c b/src/snprintf/fflush.c deleted file mode 100644 index 26450efe..00000000 --- a/src/snprintf/fflush.c +++ /dev/null @@ -1,60 +0,0 @@ -/* $OpenBSD: fflush.c,v 1.7 2009/10/22 01:23:16 guenther Exp $ */ -/* - * SPDX-License-Identifier: BSD-3-Clause - * - * Copyright (C) 1990, 1993 - * The Regents of the University of California. All rights reserved. - * - * This code is derived from software contributed to Berkeley by - * Chris Torek. - */ - -#include -#include -#include "local.h" - -/* Flush a single file, or (if fp is NULL) all files. */ -int ust_safe_fflush(LTTNG_UST_LFILE *fp) -{ - - if (fp == NULL) - return 0; -// return (_fwalk(__sflush)); - if ((fp->_flags & (__SWR | __SRW)) == 0) { - errno = EBADF; - return (EOF); - } - return (__sflush(fp)); -} - -int -__sflush(LTTNG_UST_LFILE *fp) -{ - unsigned char *p; - int n, t; - - t = fp->_flags; - if ((t & __SWR) == 0) - return (0); - - if ((p = fp->_bf._base) == NULL) - return (0); - - n = fp->_p - p; /* write this much */ - - /* - * Set these immediately to avoid problems with longjmp and to allow - * exchange buffering (via setvbuf) in user write function. - */ - fp->_p = p; - fp->_w = t & (__SLBF|__SNBF) ? 0 : fp->_bf._size; - - for (; n > 0; n -= t, p += t) { - t = (*fp->_write)(fp->_cookie, (char *)p, n); - if (t <= 0) { - fp->_flags |= __SERR; - return (EOF); - } - } - return (0); -} diff --git a/src/snprintf/fileext.h b/src/snprintf/fileext.h deleted file mode 100644 index d215c860..00000000 --- a/src/snprintf/fileext.h +++ /dev/null @@ -1,35 +0,0 @@ -/* $OpenBSD: fileext.h,v 1.2 2005/06/17 20:40:32 espie Exp $ */ -/* $NetBSD: fileext.h,v 1.5 2003/07/18 21:46:41 nathanw Exp $ */ - -/* - * SPDX-License-Identifier: BSD-2-Clause - * - * Copyright (C)2001 Citrus Project, - * All rights reserved. - * - * $Citrus$ - */ - -/* - * file extension - */ -struct __lttng_ust_sfileext { - struct __lttng_ust_sbuf _ub; /* ungetc buffer */ - struct wchar_io_data _wcio; /* wide char io status */ -}; - -#define _EXT(fp) ((struct __lttng_ust_sfileext *)((fp)->_ext._base)) -#define _UB(fp) _EXT(fp)->_ub - -#define _FILEEXT_INIT(fp) \ -do { \ - _UB(fp)._base = NULL; \ - _UB(fp)._size = 0; \ - WCIO_INIT(fp); \ -} while (0) - -#define _FILEEXT_SETUP(f, fext) \ -do { \ - (f)->_ext._base = (unsigned char *)(fext); \ - _FILEEXT_INIT(f); \ -} while (0) diff --git a/src/snprintf/floatio.h b/src/snprintf/floatio.h deleted file mode 100644 index deaa1934..00000000 --- a/src/snprintf/floatio.h +++ /dev/null @@ -1,41 +0,0 @@ -/* $OpenBSD: floatio.h,v 1.4 2008/09/07 20:36:08 martynas Exp $ */ - -/* - * SPDX-License-Identifier: BSD-3-Clause - * - * Copyright (C) 1990, 1993 - * The Regents of the University of California. All rights reserved. - * - * This code is derived from software contributed to Berkeley by - * Chris Torek. - */ - -/* - * Floating point scanf/printf (input/output) definitions. - */ - -/* 11-bit exponent (VAX G floating point) is 308 decimal digits */ -#define MAXEXP 308 -/* 128 bit fraction takes up 39 decimal digits; max reasonable precision */ -#define MAXFRACT 39 - -/* - * MAXEXPDIG is the maximum number of decimal digits needed to store a - * floating point exponent in the largest supported format. It should - * be ceil(log10(LDBL_MAX_10_EXP)) or, if hexadecimal floating point - * conversions are supported, ceil(log10(LDBL_MAX_EXP)). But since it - * is presently never greater than 5 in practice, we fudge it. - */ -#define MAXEXPDIG 6 -#if LDBL_MAX_EXP > 999999 -#error "floating point buffers too small" -#endif - -char *__hdtoa(double, const char *, int, int *, int *, char **) - __attribute__((visibility("hidden"))); - -char *__hldtoa(long double, const char *, int, int *, int *, char **) - __attribute__((visibility("hidden"))); - -char *__ldtoa(long double *, int, int, int *, int *, char **) - __attribute__((visibility("hidden"))); diff --git a/src/snprintf/fvwrite.c b/src/snprintf/fvwrite.c deleted file mode 100644 index c58e5786..00000000 --- a/src/snprintf/fvwrite.c +++ /dev/null @@ -1,183 +0,0 @@ -/* $OpenBSD: fvwrite.c,v 1.16 2009/10/22 01:23:16 guenther Exp $ */ -/* - * SPDX-License-Identifier: BSD-3-Clause - * - * Copyright (C) 1990, 1993 - * The Regents of the University of California. All rights reserved. - * - * This code is derived from software contributed to Berkeley by - * Chris Torek. - */ - -#include -#include -#include -#include -#include "local.h" -#include "fvwrite.h" -#include "various.h" - -/* - * Write some memory regions. Return zero on success, EOF on error. - * - * This routine is large and unsightly, but most of the ugliness due - * to the three different kinds of output buffering is handled here. - */ -int -__sfvwrite(LTTNG_UST_LFILE *fp, struct __lttng_ust_suio *uio) -{ - size_t len; - char *p; - struct __lttng_ust_siov *iov; - int w, s; - char *nl; - int nlknown, nldist; - - if ((len = uio->uio_resid) == 0) - return (0); - /* make sure we can write */ - if (cantwrite(fp)) { - errno = EBADF; - return (EOF); - } - -#define MIN(a, b) ((a) < (b) ? (a) : (b)) -#define COPY(n) (void)memcpy((void *)fp->_p, (void *)p, (size_t)(n)) - - iov = uio->uio_iov; - p = iov->iov_base; - len = iov->iov_len; - iov++; -#define GETIOV(extra_work) \ - while (len == 0) { \ - extra_work; \ - p = iov->iov_base; \ - len = iov->iov_len; \ - iov++; \ - } - if (fp->_flags & __SNBF) { - /* - * Unbuffered: write up to BUFSIZ bytes at a time. - */ - do { - GETIOV(;); - w = (*fp->_write)(fp->_cookie, p, MIN(len, BUFSIZ)); - if (w <= 0) - goto err; - p += w; - len -= w; - } while ((uio->uio_resid -= w) != 0); - } else if ((fp->_flags & __SLBF) == 0) { - /* - * Fully buffered: fill partially full buffer, if any, - * and then flush. If there is no partial buffer, write - * one _bf._size byte chunk directly (without copying). - * - * String output is a special case: write as many bytes - * as fit, but pretend we wrote everything. This makes - * snprintf() return the number of bytes needed, rather - * than the number used, and avoids its write function - * (so that the write function can be invalid). - */ - do { - GETIOV(;); - if ((fp->_flags & (__SALC | __SSTR)) == - (__SALC | __SSTR) && fp->_w < len) { - size_t blen = fp->_p - fp->_bf._base; - unsigned char *_base; - int _size; - - /* Allocate space exponentially. */ - _size = fp->_bf._size; - do { - _size = (_size << 1) + 1; - } while (_size < blen + len); - _base = realloc(fp->_bf._base, _size + 1); - if (_base == NULL) - goto err; - fp->_w += _size - fp->_bf._size; - fp->_bf._base = _base; - fp->_bf._size = _size; - fp->_p = _base + blen; - } - w = fp->_w; - if (fp->_flags & __SSTR) { - if (len < w) - w = len; - COPY(w); /* copy MIN(fp->_w,len), */ - fp->_w -= w; - fp->_p += w; - w = len; /* but pretend copied all */ - } else if (fp->_p > fp->_bf._base && len > w) { - /* fill and flush */ - COPY(w); - /* fp->_w -= w; */ /* unneeded */ - fp->_p += w; - if (ust_safe_fflush(fp)) - goto err; - } else if (len >= (w = fp->_bf._size)) { - /* write directly */ - w = (*fp->_write)(fp->_cookie, p, w); - if (w <= 0) - goto err; - } else { - /* fill and done */ - w = len; - COPY(w); - fp->_w -= w; - fp->_p += w; - } - p += w; - len -= w; - } while ((uio->uio_resid -= w) != 0); - } else { - /* - * Line buffered: like fully buffered, but we - * must check for newlines. Compute the distance - * to the first newline (including the newline), - * or `infinity' if there is none, then pretend - * that the amount to write is MIN(len,nldist). - */ - nlknown = 0; - nldist = 0; /* XXX just to keep gcc happy */ - do { - GETIOV(nlknown = 0); - if (!nlknown) { - nl = memchr((void *)p, '\n', len); - nldist = nl ? nl + 1 - p : len + 1; - nlknown = 1; - } - s = MIN(len, nldist); - w = fp->_w + fp->_bf._size; - if (fp->_p > fp->_bf._base && s > w) { - COPY(w); - /* fp->_w -= w; */ - fp->_p += w; - if (ust_safe_fflush(fp)) - goto err; - } else if (s >= (w = fp->_bf._size)) { - w = (*fp->_write)(fp->_cookie, p, w); - if (w <= 0) - goto err; - } else { - w = s; - COPY(w); - fp->_w -= w; - fp->_p += w; - } - if ((nldist -= w) == 0) { - /* copied the newline: flush and forget */ - if (ust_safe_fflush(fp)) - goto err; - nlknown = 0; - } - p += w; - len -= w; - } while ((uio->uio_resid -= w) != 0); - } - return (0); - -err: - fp->_flags |= __SERR; - return (EOF); -} diff --git a/src/snprintf/fvwrite.h b/src/snprintf/fvwrite.h deleted file mode 100644 index 3fabf5f5..00000000 --- a/src/snprintf/fvwrite.h +++ /dev/null @@ -1,29 +0,0 @@ -/* $OpenBSD: fvwrite.h,v 1.5 2003/06/02 20:18:37 millert Exp $ */ - -/* - * SPDX-License-Identifier: BSD-3-Clause - * - * Copyright (C) 1990, 1993 - * The Regents of the University of California. All rights reserved. - * - * This code is derived from software contributed to Berkeley by - * Chris Torek. - */ - -/* - * I/O descriptors for __sfvwrite(). - */ -#include - -struct __lttng_ust_siov { - void *iov_base; - size_t iov_len; -}; -struct __lttng_ust_suio { - struct __lttng_ust_siov *uio_iov; - int uio_iovcnt; - int uio_resid; -}; - -extern int __sfvwrite(LTTNG_UST_LFILE *, struct __lttng_ust_suio *) - __attribute__((visibility("hidden"))); diff --git a/src/snprintf/local.h b/src/snprintf/local.h deleted file mode 100644 index 6d71cf53..00000000 --- a/src/snprintf/local.h +++ /dev/null @@ -1,100 +0,0 @@ -/* $OpenBSD: local.h,v 1.14 2009/10/22 01:23:16 guenther Exp $ */ - -/* - * SPDX-License-Identifier: BSD-3-Clause - * - * Copyright (C) 1990, 1993 - * The Regents of the University of California. All rights reserved. - * - * This code is derived from software contributed to Berkeley by - * Chris Torek. - */ - -/* - * Information local to this implementation of stdio, - * in particular, macros and private variables. - */ - -#include -#include -#include "various.h" -#include "wcio.h" -#include "fileext.h" - -int __sflush(LTTNG_UST_LFILE *) - __attribute__((visibility("hidden"))); - -LTTNG_UST_LFILE *__sfp(void) - __attribute__((visibility("hidden"))); - -int __srefill(LTTNG_UST_LFILE *) - __attribute__((visibility("hidden"))); - -int __sread(void *, char *, int) - __attribute__((visibility("hidden"))); - -int __swrite(void *, const char *, int) - __attribute__((visibility("hidden"))); - -fpos_t __sseek(void *, fpos_t, int) - __attribute__((visibility("hidden"))); - -int __sclose(void *) - __attribute__((visibility("hidden"))); - -void __sinit(void) - __attribute__((visibility("hidden"))); - -void _cleanup(void) - __attribute__((visibility("hidden"))); - -void __smakebuf(LTTNG_UST_LFILE *) - __attribute__((visibility("hidden"))); - -int __swhatbuf(LTTNG_UST_LFILE *, size_t *, int *) - __attribute__((visibility("hidden"))); - -int _fwalk(int (*)(LTTNG_UST_LFILE *)) - __attribute__((visibility("hidden"))); - -int __swsetup(LTTNG_UST_LFILE *) - __attribute__((visibility("hidden"))); - -int __sflags(const char *, int *) - __attribute__((visibility("hidden"))); - -wint_t __fgetwc_unlock(LTTNG_UST_LFILE *) - __attribute__((visibility("hidden"))); - -extern void __atexit_register_cleanup(void (*)(void)) - __attribute__((visibility("hidden"))); - -extern int __sdidinit - __attribute__((visibility("hidden"))); - -/* - * Return true if the given LTTNG_UST_LFILE cannot be written now. - */ -#define cantwrite(fp) \ - ((((fp)->_flags & __SWR) == 0 || (fp)->_bf._base == NULL) && \ - __swsetup(fp)) - -/* - * Test whether the given stdio file has an active ungetc buffer; - * release such a buffer, without restoring ordinary unread data. - */ -#define HASUB(fp) (_UB(fp)._base != NULL) -#define FREEUB(fp) { \ - if (_UB(fp)._base != (fp)->_ubuf) \ - free(_UB(fp)._base); \ - _UB(fp)._base = NULL; \ -} - -/* - * test for an fgetln() buffer. - */ -#define HASLB(fp) ((fp)->_lb._base != NULL) -#define FREELB(fp) { \ - free((char *)(fp)->_lb._base); \ - (fp)->_lb._base = NULL; \ -} diff --git a/src/snprintf/mbrtowc_sb.c b/src/snprintf/mbrtowc_sb.c deleted file mode 100644 index 6fcf93e8..00000000 --- a/src/snprintf/mbrtowc_sb.c +++ /dev/null @@ -1,34 +0,0 @@ -/* $OpenBSD: mbrtowc_sb.c,v 1.4 2005/11/27 20:03:06 cloder Exp $ */ -/* $NetBSD: multibyte_sb.c,v 1.4 2003/08/07 16:43:04 agc Exp $ */ - -/* - * SPDX-License-Identifier: BSD-3-Clause - * - * Copyright (C) 1991 The Regents of the University of California. - * All rights reserved. - */ - -#include -#include -#include - -#include "various.h" - -/*ARGSUSED*/ -size_t -ust_safe_mbrtowc(wchar_t *pwc, const char *s, size_t n, - mbstate_t *ps __attribute__((unused))) -{ - - /* pwc may be NULL */ - /* s may be NULL */ - /* ps appears to be unused */ - - if (s == NULL) - return 0; - if (n == 0) - return (size_t)-1; - if (pwc) - *pwc = (wchar_t)(unsigned char)*s; - return (*s != '\0'); -} diff --git a/src/snprintf/patient_write.c b/src/snprintf/patient_write.c deleted file mode 100644 index 517a16ad..00000000 --- a/src/snprintf/patient_write.c +++ /dev/null @@ -1,120 +0,0 @@ -/* - * SPDX-License-Identifier: LGPL-2.1-or-later - * - * Copyright (C) 2009 Pierre-Marc Fournier - * Copyright (C) 2011 Mathieu Desnoyers - */ - -#include - -/* write() */ -#include - -/* writev() */ -#include - -/* send() */ -#include -#include - -#include - -#include "common/patient.h" - -/* - * This write is patient because it restarts if it was incomplete. - */ - -ssize_t ust_patient_write(int fd, const void *buf, size_t count) -{ - const char *bufc = (const char *) buf; - int result; - - for(;;) { - result = write(fd, bufc, count); - if (result == -1 && errno == EINTR) { - continue; - } - if (result <= 0) { - return result; - } - count -= result; - bufc += result; - - if (count == 0) { - break; - } - } - - return bufc-(const char *)buf; -} - -/* - * The `struct iovec *iov` is not `const` because we modify it to support - * partial writes. - */ -ssize_t ust_patient_writev(int fd, struct iovec *iov, int iovcnt) -{ - ssize_t written, total_written = 0; - int curr_element_idx = 0; - - for(;;) { - written = writev(fd, iov + curr_element_idx, - iovcnt - curr_element_idx); - if (written == -1 && errno == EINTR) { - continue; - } - if (written <= 0) { - return written; - } - - total_written += written; - - /* - * If it's not the last element in the vector and we have - * written more than the current element size, then increment - * the current element index until we reach the element that - * was partially written. - */ - while (curr_element_idx < iovcnt && - written >= iov[curr_element_idx].iov_len) { - written -= iov[curr_element_idx].iov_len; - curr_element_idx++; - } - - /* Maybe we are done. */ - if (curr_element_idx >= iovcnt) { - break; - } - - /* Update the current element base and size. */ - iov[curr_element_idx].iov_base += written; - iov[curr_element_idx].iov_len -= written; - } - - return total_written; -} - -ssize_t ust_patient_send(int fd, const void *buf, size_t count, int flags) -{ - const char *bufc = (const char *) buf; - int result; - - for(;;) { - result = send(fd, bufc, count, flags); - if (result == -1 && errno == EINTR) { - continue; - } - if (result <= 0) { - return result; - } - count -= result; - bufc += result; - - if (count == 0) { - break; - } - } - - return bufc - (const char *) buf; -} diff --git a/src/snprintf/snprintf.c b/src/snprintf/snprintf.c deleted file mode 100644 index c297cb70..00000000 --- a/src/snprintf/snprintf.c +++ /dev/null @@ -1,57 +0,0 @@ -/* $OpenBSD: snprintf.c,v 1.16 2009/10/22 01:23:16 guenther Exp $ */ -/* - * SPDX-License-Identifier: BSD-3-Clause - * - * Copyright (C) 1990, 1993 - * The Regents of the University of California. All rights reserved. - * - * This code is derived from software contributed to Berkeley by - * Chris Torek. - */ - -#include -#include -#include -#include -#include -#include "local.h" -#include "common/safe-snprintf.h" - -#define DUMMY_LEN 1 - -int ust_safe_vsnprintf(char *str, size_t n, const char *fmt, va_list ap) -{ - int ret; - char dummy[DUMMY_LEN]; - LTTNG_UST_LFILE f; - struct __lttng_ust_sfileext fext; - - /* While snprintf(3) specifies size_t stdio uses an int internally */ - if (n > INT_MAX) - n = INT_MAX; - /* Stdio internals do not deal correctly with zero length buffer */ - if (n == 0) { - str = dummy; - n = DUMMY_LEN; - } - _FILEEXT_SETUP(&f, &fext); - f._file = -1; - f._flags = __SWR | __SSTR; - f._bf._base = f._p = (unsigned char *)str; - f._bf._size = f._w = n - 1; - ret = ust_safe_vfprintf(&f, fmt, ap); - *f._p = '\0'; - return (ret); -} - -int ust_safe_snprintf(char *str, size_t n, const char *fmt, ...) -{ - va_list ap; - int ret; - - va_start(ap, fmt); - ret = ust_safe_vsnprintf(str, n, fmt, ap); - va_end(ap); - - return ret; -} diff --git a/src/snprintf/various.h b/src/snprintf/various.h deleted file mode 100644 index 067b1add..00000000 --- a/src/snprintf/various.h +++ /dev/null @@ -1,110 +0,0 @@ -/* - * SPDX-License-Identifier: BSD-3-Clause - * - * Copyright (C) 1990 The Regents of the University of California. - * All rights reserved. - * - * This code is derived from software contributed to Berkeley by - * Chris Torek. - */ - -#ifndef UST_SNPRINTF_VARIOUS_H -#define UST_SNPRINTF_VARIOUS_H - -#include -#include -#include -#include - -struct __lttng_ust_sbuf { - unsigned char *_base; - int _size; -}; - -/* - * stdio state variables. - * - * The following always hold: - * - * if (_flags&(__SLBF|__SWR)) == (__SLBF|__SWR), - * _lbfsize is -_bf._size, else _lbfsize is 0 - * if _flags&__SRD, _w is 0 - * if _flags&__SWR, _r is 0 - * - * This ensures that the getc and putc macros (or inline functions) never - * try to write or read from a file that is in `read' or `write' mode. - * (Moreover, they can, and do, automatically switch from read mode to - * write mode, and back, on "r+" and "w+" files.) - * - * _lbfsize is used only to make the inline line-buffered output stream - * code as compact as possible. - * - * _ub, _up, and _ur are used when ungetc() pushes back more characters - * than fit in the current _bf, or when ungetc() pushes back a character - * that does not match the previous one in _bf. When this happens, - * _ub._base becomes non-nil (i.e., a stream has ungetc() data iff - * _ub._base!=NULL) and _up and _ur save the current values of _p and _r. - */ -typedef struct __lttng_ust_sFILE { - unsigned char *_p; /* current position in (some) buffer */ - int _r; /* read space left for getc() */ - int _w; /* write space left for putc() */ - short _flags; /* flags, below; this FILE is free if 0 */ - short _file; /* fileno, if Unix descriptor, else -1 */ - struct __lttng_ust_sbuf _bf; /* the buffer (at least 1 byte, if !NULL) */ - int _lbfsize; /* 0 or -_bf._size, for inline putc */ - - /* operations */ - void *_cookie; /* cookie passed to io functions */ - int (*_close)(void *); - int (*_read)(void *, char *, int); - fpos_t (*_seek)(void *, fpos_t, int); - int (*_write)(void *, const char *, int); - - /* extension data, to avoid further ABI breakage */ - struct __lttng_ust_sbuf _ext; - /* data for long sequences of ungetc() */ - unsigned char *_up; /* saved _p when _p is doing ungetc data */ - int _ur; /* saved _r when _r is counting ungetc data */ - - /* tricks to meet minimum requirements even when malloc() fails */ - unsigned char _ubuf[3]; /* guarantee an ungetc() buffer */ - unsigned char _nbuf[1]; /* guarantee a getc() buffer */ - - /* separate buffer for fgetln() when line crosses buffer boundary */ - struct __lttng_ust_sbuf _lb; /* buffer for fgetln() */ - - /* Unix stdio files get aligned to block boundaries on fseek() */ - int _blksize; /* stat.st_blksize (may be != _bf._size) */ - fpos_t _offset; /* current lseek offset */ -} LTTNG_UST_LFILE; - -#define __SLBF 0x0001 /* line buffered */ -#define __SNBF 0x0002 /* unbuffered */ -#define __SRD 0x0004 /* OK to read */ -#define __SWR 0x0008 /* OK to write */ - /* RD and WR are never simultaneously asserted */ -#define __SRW 0x0010 /* open for reading & writing */ -#define __SEOF 0x0020 /* found EOF */ -#define __SERR 0x0040 /* found error */ -#define __SMBF 0x0080 /* _buf is from malloc */ -#define __SAPP 0x0100 /* fdopen()ed in append mode */ -#define __SSTR 0x0200 /* this is an sprintf/snprintf string */ -#define __SOPT 0x0400 /* do fseek() optimisation */ -#define __SNPT 0x0800 /* do not do fseek() optimisation */ -#define __SOFF 0x1000 /* set iff _offset is in fact correct */ -#define __SMOD 0x2000 /* true => fgetln modified _p text */ -#define __SALC 0x4000 /* allocate string space dynamically */ - -#define __sferror(p) (((p)->_flags & __SERR) != 0) - -extern int ust_safe_fflush(LTTNG_UST_LFILE *fp) - __attribute__((visibility("hidden"))); - -extern int ust_safe_vfprintf(LTTNG_UST_LFILE *fp, const char *fmt0, va_list ap) - __attribute__((visibility("hidden"))); - -extern size_t ust_safe_mbrtowc(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps) - __attribute__((visibility("hidden"))); - -#endif /* UST_SNPRINTF_VARIOUS_H */ diff --git a/src/snprintf/vfprintf.c b/src/snprintf/vfprintf.c deleted file mode 100644 index c2b07eb0..00000000 --- a/src/snprintf/vfprintf.c +++ /dev/null @@ -1,1372 +0,0 @@ -/* $OpenBSD: vfprintf.c,v 1.57 2009/10/28 21:15:02 naddy Exp $ */ -/* - * SPDX-License-Identifier: BSD-3-Clause - * - * Copyright (C) 1990 The Regents of the University of California. - * All rights reserved. - * - * This code is derived from software contributed to Berkeley by - * Chris Torek. - */ - -/* - * Actual printf innards. - * - * This code is large and complicated... - */ - -//#define FLOATING_POINT - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "local.h" -#include "fvwrite.h" -#include "various.h" - -static char null_str[] = "(null)"; -static char bad_base_str[] = "bug in ust_safe_vfprintf: bad base"; - -union arg { - int intarg; - unsigned int uintarg; - long longarg; - unsigned long ulongarg; - long long longlongarg; - unsigned long long ulonglongarg; - ptrdiff_t ptrdiffarg; - size_t sizearg; - size_t ssizearg; - intmax_t intmaxarg; - uintmax_t uintmaxarg; - void *pvoidarg; - char *pchararg; - signed char *pschararg; - short *pshortarg; - int *pintarg; - long *plongarg; - long long *plonglongarg; - ptrdiff_t *pptrdiffarg; - ssize_t *pssizearg; - intmax_t *pintmaxarg; -#ifdef FLOATING_POINT - double doublearg; - long double longdoublearg; -#endif -}; - -static int __find_arguments(const char *fmt0, va_list ap, union arg **argtable, - size_t *argtablesiz); -static int __grow_type_table(unsigned char **typetable, int *tablesize); - -/* - * Flush out all the vectors defined by the given uio, - * then reset it so that it can be reused. - */ -static int -__sprint(LTTNG_UST_LFILE *fp, struct __lttng_ust_suio *uio) -{ - int err; - - if (uio->uio_resid == 0) { - uio->uio_iovcnt = 0; - return (0); - } - err = __sfvwrite(fp, uio); - uio->uio_resid = 0; - uio->uio_iovcnt = 0; - return (err); -} - -/* - * Helper function for `fprintf to unbuffered unix file': creates a - * temporary buffer. We only work on write-only files; this avoids - * worries about ungetc buffers and so forth. - */ -//static int -//__sbprintf(LTTNG_UST_LFILE *fp, const char *fmt, va_list ap) -//{ -// int ret; -// LTTNG_UST_LFILE fake; -// struct __sfileext fakeext; -// unsigned char buf[BUFSIZ]; -// -// _FILEEXT_SETUP(&fake, &fakeext); -// /* copy the important variables */ -// fake._flags = fp->_flags & ~__SNBF; -// fake._file = fp->_file; -// fake._cookie = fp->_cookie; -// fake._write = fp->_write; -// -// /* set up the buffer */ -// fake._bf._base = fake._p = buf; -// fake._bf._size = fake._w = sizeof(buf); -// fake._lbfsize = 0; /* not actually used, but Just In Case */ -// -// /* do the work, then copy any error status */ -// ret = ust_safe_vfprintf(&fake, fmt, ap); -// if (ret >= 0 && fflush(&fake)) -// ret = EOF; -// if (fake._flags & __SERR) -// fp->_flags |= __SERR; -// return (ret); -//} - - -#ifdef FLOATING_POINT -#include -#include -#include -#include "floatio.h" - -#define DEFPREC 6 - -extern char *__dtoa(double, int, int, int *, int *, char **); -extern void __freedtoa(char *); -static int exponent(char *, int, int); -#endif /* FLOATING_POINT */ - -/* - * The size of the buffer we use as scratch space for integer - * conversions, among other things. Technically, we would need the - * most space for base 10 conversions with thousands' grouping - * characters between each pair of digits. 100 bytes is a - * conservative overestimate even for a 128-bit uintmax_t. - */ -#define BUF 100 - -#define STATIC_ARG_TBL_SIZE 8 /* Size of static argument table. */ - - -/* - * Macros for converting digits to letters and vice versa - */ -#define to_digit(c) ((c) - '0') -#define is_digit(c) ((unsigned)to_digit(c) <= 9) -#define to_char(n) ((n) + '0') - -/* - * Flags used during conversion. - */ -#define ALT 0x0001 /* alternate form */ -#define LADJUST 0x0004 /* left adjustment */ -#define LONGDBL 0x0008 /* long double; unimplemented */ -#define LONGINT 0x0010 /* long integer */ -#define LLONGINT 0x0020 /* long long integer */ -#define SHORTINT 0x0040 /* short integer */ -#define ZEROPAD 0x0080 /* zero (as opposed to blank) pad */ -#define FPT 0x0100 /* Floating point number */ -#define PTRINT 0x0200 /* (unsigned) ptrdiff_t */ -#define SIZEINT 0x0400 /* (signed) size_t */ -#define CHARINT 0x0800 /* 8 bit integer */ -#define MAXINT 0x1000 /* largest integer size (intmax_t) */ - -int ust_safe_vfprintf(LTTNG_UST_LFILE *fp, const char *fmt0, va_list ap) -{ - char *fmt; /* format string */ - int ch; /* character from fmt */ - int n, n2; /* handy integers (short term usage) */ - char *cp; /* handy char pointer (short term usage) */ - struct __lttng_ust_siov *iovp; /* for PRINT macro */ - int flags; /* flags as above */ - int ret; /* return value accumulator */ - int width; /* width from format (%8d), or 0 */ - int prec; /* precision from format; <0 for N/A */ - char sign; /* sign prefix (' ', '+', '-', or \0) */ - wchar_t wc; - mbstate_t ps; -#ifdef FLOATING_POINT - /* - * We can decompose the printed representation of floating - * point numbers into several parts, some of which may be empty: - * - * [+|-| ] [0x|0X] MMM . NNN [e|E|p|P] [+|-] ZZ - * A B ---C--- D E F - * - * A: 'sign' holds this value if present; '\0' otherwise - * B: ox[1] holds the 'x' or 'X'; '\0' if not hexadecimal - * C: cp points to the string MMMNNN. Leading and trailing - * zeros are not in the string and must be added. - * D: expchar holds this character; '\0' if no exponent, e.g. %f - * F: at least two digits for decimal, at least one digit for hex - */ - char *decimal_point = localeconv()->decimal_point; - int signflag; /* true if float is negative */ - union { /* floating point arguments %[aAeEfFgG] */ - double dbl; - long double ldbl; - } fparg; - int expt; /* integer value of exponent */ - char expchar; /* exponent character: [eEpP\0] */ - char *dtoaend; /* pointer to end of converted digits */ - int expsize; /* character count for expstr */ - int lead; /* sig figs before decimal or group sep */ - int ndig; /* actual number of digits returned by dtoa */ - char expstr[MAXEXPDIG+2]; /* buffer for exponent string: e+ZZZ */ - char *dtoaresult = NULL; -#endif - - uintmax_t _umax; /* integer arguments %[diouxX] */ - enum { OCT, DEC, HEX } base; /* base for %[diouxX] conversion */ - int dprec; /* a copy of prec if %[diouxX], 0 otherwise */ - int realsz; /* field size expanded by dprec */ - int size; /* size of converted field or string */ - const char *xdigs = NULL; /* digits for %[xX] conversion */ -#define NIOV 8 - struct __lttng_ust_suio uio; /* output information: summary */ - struct __lttng_ust_siov iov[NIOV];/* ... and individual io vectors */ - char buf[BUF]; /* buffer with space for digits of uintmax_t */ - char ox[2]; /* space for 0x; ox[1] is either x, X, or \0 */ - union arg *argtable; /* args, built due to positional arg */ - union arg statargtable[STATIC_ARG_TBL_SIZE]; - size_t argtablesiz; - int nextarg; /* 1-based argument index */ - va_list orgap; /* original argument pointer */ - - /* - * Choose PADSIZE to trade efficiency vs. size. If larger printf - * fields occur frequently, increase PADSIZE and make the initialisers - * below longer. - */ -#define PADSIZE 16 /* pad chunk size */ - static char blanks[PADSIZE] = - {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '}; - static char zeroes[PADSIZE] = - {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'}; - - static const char xdigs_lower[16] = "0123456789abcdef"; - static const char xdigs_upper[16] = "0123456789ABCDEF"; - - /* - * BEWARE, these `goto error' on error, and PAD uses `n'. - */ -#define PRINT(ptr, len) do { \ - iovp->iov_base = (ptr); \ - iovp->iov_len = (len); \ - uio.uio_resid += (len); \ - iovp++; \ - if (++uio.uio_iovcnt >= NIOV) { \ - if (__sprint(fp, &uio)) \ - goto error; \ - iovp = iov; \ - } \ -} while (0) -#define PAD(howmany, with) do { \ - if ((n = (howmany)) > 0) { \ - while (n > PADSIZE) { \ - PRINT(with, PADSIZE); \ - n -= PADSIZE; \ - } \ - PRINT(with, n); \ - } \ -} while (0) -#define PRINTANDPAD(p, ep, len, with) do { \ - n2 = (ep) - (p); \ - if (n2 > (len)) \ - n2 = (len); \ - if (n2 > 0) \ - PRINT((p), n2); \ - PAD((len) - (n2 > 0 ? n2 : 0), (with)); \ -} while(0) -#define FLUSH() do { \ - if (uio.uio_resid && __sprint(fp, &uio)) \ - goto error; \ - uio.uio_iovcnt = 0; \ - iovp = iov; \ -} while (0) - - /* - * To extend shorts properly, we need both signed and unsigned - * argument extraction methods. - */ -#define SARG() \ - ((intmax_t)(flags&MAXINT ? GETARG(intmax_t) : \ - flags&LLONGINT ? GETARG(long long) : \ - flags&LONGINT ? GETARG(long) : \ - flags&PTRINT ? GETARG(ptrdiff_t) : \ - flags&SIZEINT ? GETARG(ssize_t) : \ - flags&SHORTINT ? (short)GETARG(int) : \ - flags&CHARINT ? (__signed char)GETARG(int) : \ - GETARG(int))) -#define UARG() \ - ((uintmax_t)(flags&MAXINT ? GETARG(uintmax_t) : \ - flags&LLONGINT ? GETARG(unsigned long long) : \ - flags&LONGINT ? GETARG(unsigned long) : \ - flags&PTRINT ? (uintptr_t)GETARG(ptrdiff_t) : /* XXX */ \ - flags&SIZEINT ? GETARG(size_t) : \ - flags&SHORTINT ? (unsigned short)GETARG(int) : \ - flags&CHARINT ? (unsigned char)GETARG(int) : \ - GETARG(unsigned int))) - - /* - * Append a digit to a value and check for overflow. - */ -#define APPEND_DIGIT(val, dig) do { \ - if ((val) > INT_MAX / 10) \ - goto overflow; \ - (val) *= 10; \ - if ((val) > INT_MAX - to_digit((dig))) \ - goto overflow; \ - (val) += to_digit((dig)); \ -} while (0) - - /* - * Get * arguments, including the form *nn$. Preserve the nextarg - * that the argument can be gotten once the type is determined. - */ -#define GETASTER(val) \ - n2 = 0; \ - cp = fmt; \ - while (is_digit(*cp)) { \ - APPEND_DIGIT(n2, *cp); \ - cp++; \ - } \ - if (*cp == '$') { \ - int hold = nextarg; \ - if (argtable == NULL) { \ - argtable = statargtable; \ - __find_arguments(fmt0, orgap, &argtable, &argtablesiz); \ - } \ - nextarg = n2; \ - val = GETARG(int); \ - nextarg = hold; \ - fmt = ++cp; \ - } else { \ - val = GETARG(int); \ - } - -/* -* Get the argument indexed by nextarg. If the argument table is -* built, use it to get the argument. If its not, get the next -* argument (and arguments must be gotten sequentially). -*/ -#define GETARG(type) \ - ((argtable != NULL) ? *((type*)(&argtable[nextarg++])) : \ - (nextarg++, va_arg(ap, type))) - - _SET_ORIENTATION(fp, -1); - /* sorry, fprintf(read_only_file, "") returns EOF, not 0 */ - if (cantwrite(fp)) { - errno = EBADF; - return (EOF); - } - - /* optimise fprintf(stderr) (and other unbuffered Unix files) */ -// if ((fp->_flags & (__SNBF|__SWR|__SRW)) == (__SNBF|__SWR) && -// fp->_file >= 0) -// return (__sbprintf(fp, fmt0, ap)); - - fmt = (char *)fmt0; - argtable = NULL; - nextarg = 1; - va_copy(orgap, ap); - uio.uio_iov = iovp = iov; - uio.uio_resid = 0; - uio.uio_iovcnt = 0; - ret = 0; - - memset(&ps, 0, sizeof(ps)); - /* - * Scan the format for conversions (`%' character). - */ - for (;;) { - cp = fmt; - while ((n = ust_safe_mbrtowc(&wc, fmt, MB_CUR_MAX, &ps)) > 0) { - fmt += n; - if (wc == '%') { - fmt--; - break; - } - } - if (fmt != cp) { - ptrdiff_t m = fmt - cp; - if (m < 0 || m > INT_MAX - ret) - goto overflow; - PRINT(cp, m); - ret += m; - } - if (n <= 0) - goto done; - fmt++; /* skip over '%' */ - - flags = 0; - dprec = 0; - width = 0; - prec = -1; - sign = '\0'; - ox[1] = '\0'; - -rflag: ch = *fmt++; -reswitch: switch (ch) { - case ' ': - /* - * ``If the space and + flags both appear, the space - * flag will be ignored.'' - * -- ANSI X3J11 - */ - if (!sign) - sign = ' '; - goto rflag; - case '#': - flags |= ALT; - goto rflag; - case '\'': - /* grouping not implemented */ - goto rflag; - case '*': - /* - * ``A negative field width argument is taken as a - * - flag followed by a positive field width.'' - * -- ANSI X3J11 - * They don't exclude field widths read from args. - */ - GETASTER(width); - if (width >= 0) - goto rflag; - if (width == INT_MIN) - goto overflow; - width = -width; - /* FALLTHROUGH */ - case '-': - flags |= LADJUST; - goto rflag; - case '+': - sign = '+'; - goto rflag; - case '.': - if ((ch = *fmt++) == '*') { - GETASTER(n); - prec = n < 0 ? -1 : n; - goto rflag; - } - n = 0; - while (is_digit(ch)) { - APPEND_DIGIT(n, ch); - ch = *fmt++; - } - if (ch == '$') { - nextarg = n; - if (argtable == NULL) { - argtable = statargtable; - __find_arguments(fmt0, orgap, - &argtable, &argtablesiz); - } - goto rflag; - } - prec = n; - goto reswitch; - case '0': - /* - * ``Note that 0 is taken as a flag, not as the - * beginning of a field width.'' - * -- ANSI X3J11 - */ - flags |= ZEROPAD; - goto rflag; - case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - n = 0; - do { - APPEND_DIGIT(n, ch); - ch = *fmt++; - } while (is_digit(ch)); - if (ch == '$') { - nextarg = n; - if (argtable == NULL) { - argtable = statargtable; - __find_arguments(fmt0, orgap, - &argtable, &argtablesiz); - } - goto rflag; - } - width = n; - goto reswitch; -#ifdef FLOATING_POINT - case 'L': - flags |= LONGDBL; - goto rflag; -#endif - case 'h': - if (*fmt == 'h') { - fmt++; - flags |= CHARINT; - } else { - flags |= SHORTINT; - } - goto rflag; - case 'j': - flags |= MAXINT; - goto rflag; - case 'l': - if (*fmt == 'l') { - fmt++; - flags |= LLONGINT; - } else { - flags |= LONGINT; - } - goto rflag; - case 'q': - flags |= LLONGINT; - goto rflag; - case 't': - flags |= PTRINT; - goto rflag; - case 'z': - flags |= SIZEINT; - goto rflag; - case 'c': - *(cp = buf) = GETARG(int); - size = 1; - sign = '\0'; - break; - case 'D': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'd': - case 'i': - _umax = SARG(); - if ((intmax_t)_umax < 0) { - _umax = -_umax; - sign = '-'; - } - base = DEC; - goto number; -#ifdef FLOATING_POINT - case 'a': - case 'A': - if (ch == 'a') { - ox[1] = 'x'; - xdigs = xdigs_lower; - expchar = 'p'; - } else { - ox[1] = 'X'; - xdigs = xdigs_upper; - expchar = 'P'; - } - if (prec >= 0) - prec++; - if (dtoaresult) - __freedtoa(dtoaresult); - if (flags & LONGDBL) { - fparg.ldbl = GETARG(long double); - dtoaresult = cp = - __hldtoa(fparg.ldbl, xdigs, prec, - &expt, &signflag, &dtoaend); - if (dtoaresult == NULL) { - errno = ENOMEM; - goto error; - } - } else { - fparg.dbl = GETARG(double); - dtoaresult = cp = - __hdtoa(fparg.dbl, xdigs, prec, - &expt, &signflag, &dtoaend); - if (dtoaresult == NULL) { - errno = ENOMEM; - goto error; - } - } - if (prec < 0) - prec = dtoaend - cp; - if (expt == INT_MAX) - ox[1] = '\0'; - goto fp_common; - case 'e': - case 'E': - expchar = ch; - if (prec < 0) /* account for digit before decpt */ - prec = DEFPREC + 1; - else - prec++; - goto fp_begin; - case 'f': - case 'F': - expchar = '\0'; - goto fp_begin; - case 'g': - case 'G': - expchar = ch - ('g' - 'e'); - if (prec == 0) - prec = 1; -fp_begin: - if (prec < 0) - prec = DEFPREC; - if (dtoaresult) - __freedtoa(dtoaresult); - if (flags & LONGDBL) { - fparg.ldbl = GETARG(long double); - dtoaresult = cp = - __ldtoa(&fparg.ldbl, expchar ? 2 : 3, prec, - &expt, &signflag, &dtoaend); - if (dtoaresult == NULL) { - errno = ENOMEM; - goto error; - } - } else { - fparg.dbl = GETARG(double); - dtoaresult = cp = - __dtoa(fparg.dbl, expchar ? 2 : 3, prec, - &expt, &signflag, &dtoaend); - if (dtoaresult == NULL) { - errno = ENOMEM; - goto error; - } - if (expt == 9999) - expt = INT_MAX; - } -fp_common: - if (signflag) - sign = '-'; - if (expt == INT_MAX) { /* inf or nan */ - if (*cp == 'N') { - cp = (ch >= 'a') ? "nan" : "NAN"; - sign = '\0'; - } else - cp = (ch >= 'a') ? "inf" : "INF"; - size = 3; - flags &= ~ZEROPAD; - break; - } - flags |= FPT; - ndig = dtoaend - cp; - if (ch == 'g' || ch == 'G') { - if (expt > -4 && expt <= prec) { - /* Make %[gG] smell like %[fF] */ - expchar = '\0'; - if (flags & ALT) - prec -= expt; - else - prec = ndig - expt; - if (prec < 0) - prec = 0; - } else { - /* - * Make %[gG] smell like %[eE], but - * trim trailing zeroes if no # flag. - */ - if (!(flags & ALT)) - prec = ndig; - } - } - if (expchar) { - expsize = exponent(expstr, expt - 1, expchar); - size = expsize + prec; - if (prec > 1 || flags & ALT) - ++size; - } else { - /* space for digits before decimal point */ - if (expt > 0) - size = expt; - else /* "0" */ - size = 1; - /* space for decimal pt and following digits */ - if (prec || flags & ALT) - size += prec + 1; - lead = expt; - } - break; -#endif /* FLOATING_POINT */ - case 'n': - if (flags & LLONGINT) - *GETARG(long long *) = ret; - else if (flags & LONGINT) - *GETARG(long *) = ret; - else if (flags & SHORTINT) - *GETARG(short *) = ret; - else if (flags & CHARINT) - *GETARG(__signed char *) = ret; - else if (flags & PTRINT) - *GETARG(ptrdiff_t *) = ret; - else if (flags & SIZEINT) - *GETARG(ssize_t *) = ret; - else if (flags & MAXINT) - *GETARG(intmax_t *) = ret; - else - *GETARG(int *) = ret; - continue; /* no output */ - case 'O': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'o': - _umax = UARG(); - base = OCT; - goto nosign; - case 'p': - /* - * ``The argument shall be a pointer to void. The - * value of the pointer is converted to a sequence - * of printable characters, in an implementation- - * defined manner.'' - * -- ANSI X3J11 - */ - /* NOSTRICT */ - _umax = (u_long)GETARG(void *); - base = HEX; - xdigs = xdigs_lower; - ox[1] = 'x'; - goto nosign; - case 's': - if ((cp = GETARG(char *)) == NULL) - cp = null_str; - if (prec >= 0) { - /* - * can't use strlen; can only look for the - * NUL in the first `prec' characters, and - * strlen() will go further. - */ - char *p = memchr(cp, 0, prec); - - size = p ? (p - cp) : prec; - } else { - size_t len; - - if ((len = strlen(cp)) > INT_MAX) - goto overflow; - size = (int)len; - } - sign = '\0'; - break; - case 'U': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'u': - _umax = UARG(); - base = DEC; - goto nosign; - case 'X': - xdigs = xdigs_upper; - goto hex; - case 'x': - xdigs = xdigs_lower; -hex: _umax = UARG(); - base = HEX; - /* leading 0x/X only if non-zero */ - if (flags & ALT && _umax != 0) - ox[1] = ch; - - /* unsigned conversions */ -nosign: sign = '\0'; - /* - * ``... diouXx conversions ... if a precision is - * specified, the 0 flag will be ignored.'' - * -- ANSI X3J11 - */ -number: if ((dprec = prec) >= 0) - flags &= ~ZEROPAD; - - /* - * ``The result of converting a zero value with an - * explicit precision of zero is no characters.'' - * -- ANSI X3J11 - */ - cp = buf + BUF; - if (_umax != 0 || prec != 0) { - /* - * Unsigned mod is hard, and unsigned mod - * by a constant is easier than that by - * a variable; hence this switch. - */ - switch (base) { - case OCT: - do { - *--cp = to_char(_umax & 7); - _umax >>= 3; - } while (_umax); - /* handle octal leading 0 */ - if (flags & ALT && *cp != '0') - *--cp = '0'; - break; - - case DEC: - /* many numbers are 1 digit */ - while (_umax >= 10) { - *--cp = to_char(_umax % 10); - _umax /= 10; - } - *--cp = to_char(_umax); - break; - - case HEX: - do { - *--cp = xdigs[_umax & 15]; - _umax >>= 4; - } while (_umax); - break; - - default: - cp = bad_base_str; - size = strlen(cp); - goto skipsize; - } - } - size = buf + BUF - cp; - if (size > BUF) /* should never happen */ - abort(); - skipsize: - break; - default: /* "%?" prints ?, unless ? is NUL */ - if (ch == '\0') - goto done; - /* pretend it was %c with argument ch */ - cp = buf; - *cp = ch; - size = 1; - sign = '\0'; - break; - } - - /* - * All reasonable formats wind up here. At this point, `cp' - * points to a string which (if not flags&LADJUST) should be - * padded out to `width' places. If flags&ZEROPAD, it should - * first be prefixed by any sign or other prefix; otherwise, - * it should be blank padded before the prefix is emitted. - * After any left-hand padding and prefixing, emit zeroes - * required by a decimal %[diouxX] precision, then print the - * string proper, then emit zeroes required by any leftover - * floating precision; finally, if LADJUST, pad with blanks. - * - * Compute actual size, so we know how much to pad. - * size excludes decimal prec; realsz includes it. - */ - realsz = dprec > size ? dprec : size; - if (sign) - realsz++; - if (ox[1]) - realsz+= 2; - - /* right-adjusting blank padding */ - if ((flags & (LADJUST|ZEROPAD)) == 0) - PAD(width - realsz, blanks); - - /* prefix */ - if (sign) - PRINT(&sign, 1); - if (ox[1]) { /* ox[1] is either x, X, or \0 */ - ox[0] = '0'; - PRINT(ox, 2); - } - - /* right-adjusting zero padding */ - if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD) - PAD(width - realsz, zeroes); - - /* leading zeroes from decimal precision */ - PAD(dprec - size, zeroes); - - /* the string or number proper */ -#ifdef FLOATING_POINT - if ((flags & FPT) == 0) { - PRINT(cp, size); - } else { /* glue together f_p fragments */ - if (!expchar) { /* %[fF] or sufficiently short %[gG] */ - if (expt <= 0) { - PRINT(zeroes, 1); - if (prec || flags & ALT) - PRINT(decimal_point, 1); - PAD(-expt, zeroes); - /* already handled initial 0's */ - prec += expt; - } else { - PRINTANDPAD(cp, dtoaend, lead, zeroes); - cp += lead; - if (prec || flags & ALT) - PRINT(decimal_point, 1); - } - PRINTANDPAD(cp, dtoaend, prec, zeroes); - } else { /* %[eE] or sufficiently long %[gG] */ - if (prec > 1 || flags & ALT) { - buf[0] = *cp++; - buf[1] = *decimal_point; - PRINT(buf, 2); - PRINT(cp, ndig-1); - PAD(prec - ndig, zeroes); - } else { /* XeYYY */ - PRINT(cp, 1); - } - PRINT(expstr, expsize); - } - } -#else - PRINT(cp, size); -#endif - /* left-adjusting padding (always blank) */ - if (flags & LADJUST) - PAD(width - realsz, blanks); - - /* finally, adjust ret */ - if (width < realsz) - width = realsz; - if (width > INT_MAX - ret) - goto overflow; - ret += width; - - FLUSH(); /* copy out the I/O vectors */ - } -done: - FLUSH(); -error: - if (__sferror(fp)) - ret = -1; - goto finish; - -overflow: - errno = ENOMEM; - ret = -1; - -finish: - va_end(orgap); -#ifdef FLOATING_POINT - if (dtoaresult) - __freedtoa(dtoaresult); -#endif - if (argtable != NULL && argtable != statargtable) { - munmap(argtable, argtablesiz); - argtable = NULL; - } - return (ret); -} - -/* - * Type ids for argument type table. - */ -#define T_UNUSED 0 -#define T_SHORT 1 -#define T_U_SHORT 2 -#define TP_SHORT 3 -#define T_INT 4 -#define T_U_INT 5 -#define TP_INT 6 -#define T_LONG 7 -#define T_U_LONG 8 -#define TP_LONG 9 -#define T_LLONG 10 -#define T_U_LLONG 11 -#define TP_LLONG 12 -#define T_DOUBLE 13 -#define T_LONG_DOUBLE 14 -#define TP_CHAR 15 -#define TP_VOID 16 -#define T_PTRINT 17 -#define TP_PTRINT 18 -#define T_SIZEINT 19 -#define T_SSIZEINT 20 -#define TP_SSIZEINT 21 -#define T_MAXINT 22 -#define T_MAXUINT 23 -#define TP_MAXINT 24 -#define T_CHAR 25 -#define T_U_CHAR 26 - -/* - * Find all arguments when a positional parameter is encountered. Returns a - * table, indexed by argument number, of pointers to each arguments. The - * initial argument table should be an array of STATIC_ARG_TBL_SIZE entries. - * It will be replaced with a mmap-ed one if it overflows (malloc cannot be - * used since we are attempting to make snprintf thread safe, and alloca is - * problematic since we have nested functions..) - */ -static int -__find_arguments(const char *fmt0, va_list ap, union arg **argtable, - size_t *argtablesiz) -{ - char *fmt; /* format string */ - int ch; /* character from fmt */ - int n, n2; /* handy integer (short term usage) */ - char *cp; /* handy char pointer (short term usage) */ - int flags; /* flags as above */ - unsigned char *typetable; /* table of types */ - unsigned char stattypetable[STATIC_ARG_TBL_SIZE]; - int tablesize; /* current size of type table */ - int tablemax; /* largest used index in table */ - int nextarg; /* 1-based argument index */ - int ret = 0; /* return value */ - wchar_t wc; - mbstate_t ps; - - /* - * Add an argument type to the table, expanding if necessary. - */ -#define ADDTYPE(type) \ - ((nextarg >= tablesize) ? \ - __grow_type_table(&typetable, &tablesize) : 0, \ - (nextarg > tablemax) ? tablemax = nextarg : 0, \ - typetable[nextarg++] = type) - -#define ADDSARG() \ - ((flags&MAXINT) ? ADDTYPE(T_MAXINT) : \ - ((flags&PTRINT) ? ADDTYPE(T_PTRINT) : \ - ((flags&SIZEINT) ? ADDTYPE(T_SSIZEINT) : \ - ((flags&LLONGINT) ? ADDTYPE(T_LLONG) : \ - ((flags&LONGINT) ? ADDTYPE(T_LONG) : \ - ((flags&SHORTINT) ? ADDTYPE(T_SHORT) : \ - ((flags&CHARINT) ? ADDTYPE(T_CHAR) : ADDTYPE(T_INT)))))))) - -#define ADDUARG() \ - ((flags&MAXINT) ? ADDTYPE(T_MAXUINT) : \ - ((flags&PTRINT) ? ADDTYPE(T_PTRINT) : \ - ((flags&SIZEINT) ? ADDTYPE(T_SIZEINT) : \ - ((flags&LLONGINT) ? ADDTYPE(T_U_LLONG) : \ - ((flags&LONGINT) ? ADDTYPE(T_U_LONG) : \ - ((flags&SHORTINT) ? ADDTYPE(T_U_SHORT) : \ - ((flags&CHARINT) ? ADDTYPE(T_U_CHAR) : ADDTYPE(T_U_INT)))))))) - - /* - * Add * arguments to the type array. - */ -#define ADDASTER() \ - n2 = 0; \ - cp = fmt; \ - while (is_digit(*cp)) { \ - APPEND_DIGIT(n2, *cp); \ - cp++; \ - } \ - if (*cp == '$') { \ - int hold = nextarg; \ - nextarg = n2; \ - ADDTYPE(T_INT); \ - nextarg = hold; \ - fmt = ++cp; \ - } else { \ - ADDTYPE(T_INT); \ - } - fmt = (char *)fmt0; - typetable = stattypetable; - tablesize = STATIC_ARG_TBL_SIZE; - tablemax = 0; - nextarg = 1; - memset(typetable, T_UNUSED, STATIC_ARG_TBL_SIZE); - memset(&ps, 0, sizeof(ps)); - - /* - * Scan the format for conversions (`%' character). - */ - for (;;) { - cp = fmt; - while ((n = ust_safe_mbrtowc(&wc, fmt, MB_CUR_MAX, &ps)) > 0) { - fmt += n; - if (wc == '%') { - fmt--; - break; - } - } - if (n <= 0) - goto done; - fmt++; /* skip over '%' */ - - flags = 0; - -rflag: ch = *fmt++; -reswitch: switch (ch) { - case ' ': - case '#': - case '\'': - goto rflag; - case '*': - ADDASTER(); - goto rflag; - case '-': - case '+': - goto rflag; - case '.': - if ((ch = *fmt++) == '*') { - ADDASTER(); - goto rflag; - } - while (is_digit(ch)) { - ch = *fmt++; - } - goto reswitch; - case '0': - goto rflag; - case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - n = 0; - do { - APPEND_DIGIT(n ,ch); - ch = *fmt++; - } while (is_digit(ch)); - if (ch == '$') { - nextarg = n; - goto rflag; - } - goto reswitch; -#ifdef FLOATING_POINT - case 'L': - flags |= LONGDBL; - goto rflag; -#endif - case 'h': - if (*fmt == 'h') { - fmt++; - flags |= CHARINT; - } else { - flags |= SHORTINT; - } - goto rflag; - case 'l': - if (*fmt == 'l') { - fmt++; - flags |= LLONGINT; - } else { - flags |= LONGINT; - } - goto rflag; - case 'q': - flags |= LLONGINT; - goto rflag; - case 't': - flags |= PTRINT; - goto rflag; - case 'z': - flags |= SIZEINT; - goto rflag; - case 'c': - ADDTYPE(T_INT); - break; - case 'D': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'd': - case 'i': - ADDSARG(); - break; -#ifdef FLOATING_POINT - case 'a': - case 'A': - case 'e': - case 'E': - case 'f': - case 'F': - case 'g': - case 'G': - if (flags & LONGDBL) - ADDTYPE(T_LONG_DOUBLE); - else - ADDTYPE(T_DOUBLE); - break; -#endif /* FLOATING_POINT */ - case 'n': - if (flags & LLONGINT) - ADDTYPE(TP_LLONG); - else if (flags & LONGINT) - ADDTYPE(TP_LONG); - else if (flags & SHORTINT) - ADDTYPE(TP_SHORT); - else if (flags & PTRINT) - ADDTYPE(TP_PTRINT); - else if (flags & SIZEINT) - ADDTYPE(TP_SSIZEINT); - else if (flags & MAXINT) - ADDTYPE(TP_MAXINT); - else - ADDTYPE(TP_INT); - continue; /* no output */ - case 'O': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'o': - ADDUARG(); - break; - case 'p': - ADDTYPE(TP_VOID); - break; - case 's': - ADDTYPE(TP_CHAR); - break; - case 'U': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'u': - case 'X': - case 'x': - ADDUARG(); - break; - default: /* "%?" prints ?, unless ? is NUL */ - if (ch == '\0') - goto done; - break; - } - } -done: - /* - * Build the argument table. - */ - if (tablemax >= STATIC_ARG_TBL_SIZE) { - *argtablesiz = sizeof(union arg) * (tablemax + 1); - *argtable = mmap(NULL, *argtablesiz, - PROT_WRITE|PROT_READ, MAP_ANON|MAP_PRIVATE, -1, 0); - if (*argtable == MAP_FAILED) - return (-1); - } - -#if 0 - /* XXX is this required? */ - (*argtable)[0].intarg = 0; -#endif - for (n = 1; n <= tablemax; n++) { - switch (typetable[n]) { - case T_UNUSED: - case T_CHAR: - case T_U_CHAR: - case T_SHORT: - case T_U_SHORT: - case T_INT: - (*argtable)[n].intarg = va_arg(ap, int); - break; - case TP_SHORT: - (*argtable)[n].pshortarg = va_arg(ap, short *); - break; - case T_U_INT: - (*argtable)[n].uintarg = va_arg(ap, unsigned int); - break; - case TP_INT: - (*argtable)[n].pintarg = va_arg(ap, int *); - break; - case T_LONG: - (*argtable)[n].longarg = va_arg(ap, long); - break; - case T_U_LONG: - (*argtable)[n].ulongarg = va_arg(ap, unsigned long); - break; - case TP_LONG: - (*argtable)[n].plongarg = va_arg(ap, long *); - break; - case T_LLONG: - (*argtable)[n].longlongarg = va_arg(ap, long long); - break; - case T_U_LLONG: - (*argtable)[n].ulonglongarg = va_arg(ap, unsigned long long); - break; - case TP_LLONG: - (*argtable)[n].plonglongarg = va_arg(ap, long long *); - break; -#ifdef FLOATING_POINT - case T_DOUBLE: - (*argtable)[n].doublearg = va_arg(ap, double); - break; - case T_LONG_DOUBLE: - (*argtable)[n].longdoublearg = va_arg(ap, long double); - break; -#endif - case TP_CHAR: - (*argtable)[n].pchararg = va_arg(ap, char *); - break; - case TP_VOID: - (*argtable)[n].pvoidarg = va_arg(ap, void *); - break; - case T_PTRINT: - (*argtable)[n].ptrdiffarg = va_arg(ap, ptrdiff_t); - break; - case TP_PTRINT: - (*argtable)[n].pptrdiffarg = va_arg(ap, ptrdiff_t *); - break; - case T_SIZEINT: - (*argtable)[n].sizearg = va_arg(ap, size_t); - break; - case T_SSIZEINT: - (*argtable)[n].ssizearg = va_arg(ap, ssize_t); - break; - case TP_SSIZEINT: - (*argtable)[n].pssizearg = va_arg(ap, ssize_t *); - break; - case TP_MAXINT: - (*argtable)[n].intmaxarg = va_arg(ap, intmax_t); - break; - } - } - goto finish; - -overflow: - errno = ENOMEM; - ret = -1; - -finish: - if (typetable != NULL && typetable != stattypetable) { - munmap(typetable, *argtablesiz); - typetable = NULL; - } - return (ret); -} - -/* - * Increase the size of the type table. - */ -static int -__grow_type_table(unsigned char **typetable, int *tablesize) -{ - unsigned char *oldtable = *typetable; - int newsize = *tablesize * 2; - - if (newsize < getpagesize()) - newsize = getpagesize(); - - if (*tablesize == STATIC_ARG_TBL_SIZE) { - *typetable = mmap(NULL, newsize, PROT_WRITE|PROT_READ, - MAP_ANON|MAP_PRIVATE, -1, 0); - if (*typetable == MAP_FAILED) - return (-1); - bcopy(oldtable, *typetable, *tablesize); - } else { - unsigned char *new = mmap(NULL, newsize, PROT_WRITE|PROT_READ, - MAP_ANON|MAP_PRIVATE, -1, 0); - if (new == MAP_FAILED) - return (-1); - memmove(new, *typetable, *tablesize); - munmap(*typetable, *tablesize); - *typetable = new; - } - memset(*typetable + *tablesize, T_UNUSED, (newsize - *tablesize)); - - *tablesize = newsize; - return (0); -} - - -#ifdef FLOATING_POINT -static int -exponent(char *p0, int exp, int fmtch) -{ - char *p, *t; - char expbuf[MAXEXPDIG]; - - p = p0; - *p++ = fmtch; - if (exp < 0) { - exp = -exp; - *p++ = '-'; - } else - *p++ = '+'; - t = expbuf + MAXEXPDIG; - if (exp > 9) { - do { - *--t = to_char(exp % 10); - } while ((exp /= 10) > 9); - *--t = to_char(exp); - for (; t < expbuf + MAXEXPDIG; *p++ = *t++) - /* nothing */; - } else { - /* - * Exponents for decimal floating point conversions - * (%[eEgG]) must be at least two characters long, - * whereas exponents for hexadecimal conversions can - * be only one character long. - */ - if (fmtch == 'e' || fmtch == 'E') - *p++ = '0'; - *p++ = to_char(exp); - } - return (p - p0); -} -#endif /* FLOATING_POINT */ diff --git a/src/snprintf/wcio.h b/src/snprintf/wcio.h deleted file mode 100644 index ec2c52e3..00000000 --- a/src/snprintf/wcio.h +++ /dev/null @@ -1,68 +0,0 @@ -/* $OpenBSD: wcio.h,v 1.1 2005/06/17 20:40:32 espie Exp $ */ -/* $NetBSD: wcio.h,v 1.3 2003/01/18 11:30:00 thorpej Exp $ */ - -/* - * SPDX-License-Identifier: BSD-2-Clause - * - * Copyright (C)2001 Citrus Project, - * All rights reserved. - * - * $Citrus$ - */ - -#ifndef _WCIO_H_ -#define _WCIO_H_ - -#include -#include - -/* minimal requirement of SUSv2 */ -#define WCIO_UNGETWC_BUFSIZE 1 - -struct wchar_io_data { - mbstate_t wcio_mbstate_in; - mbstate_t wcio_mbstate_out; - - wchar_t wcio_ungetwc_buf[WCIO_UNGETWC_BUFSIZE]; - size_t wcio_ungetwc_inbuf; - - int wcio_mode; /* orientation */ -}; - -#define WCIO_GET(fp) \ - (_EXT(fp) ? &(_EXT(fp)->_wcio) : (struct wchar_io_data *)0) - -#define WCIO_GET_NONULL(fp) \ - (&(_EXT(fp)->_wcio)) - -#define _SET_ORIENTATION(fp, mode) \ -do {\ - struct wchar_io_data *_wcio = WCIO_GET(fp); \ - if (_wcio && _wcio->wcio_mode == 0) \ - _wcio->wcio_mode = (mode);\ -} while (0) - -/* - * WCIO_FREE should be called by fclose - */ -#define WCIO_FREE(fp) \ -do {\ - struct wchar_io_data *_wcio = WCIO_GET(fp); \ - if (_wcio) { \ - _wcio->wcio_mode = 0;\ - _wcio->wcio_ungetwc_inbuf = 0;\ - } \ -} while (0) - -#define WCIO_FREEUB(fp) \ -do {\ - struct wchar_io_data *_wcio = WCIO_GET(fp); \ - if (_wcio) { \ - _wcio->wcio_ungetwc_inbuf = 0;\ - } \ -} while (0) - -#define WCIO_INIT(fp) \ - memset(WCIO_GET_NONULL(fp), 0, sizeof(struct wchar_io_data)) - -#endif /*_WCIO_H_*/ diff --git a/src/snprintf/wsetup.c b/src/snprintf/wsetup.c deleted file mode 100644 index 3d2526b8..00000000 --- a/src/snprintf/wsetup.c +++ /dev/null @@ -1,66 +0,0 @@ -/* $OpenBSD: wsetup.c,v 1.7 2005/08/08 08:05:36 espie Exp $ */ -/* - * SPDX-License-Identifier: BSD-3-Clause - * - * Copyright (C) 1990, 1993 - * The Regents of the University of California. All rights reserved. - * - * This code is derived from software contributed to Berkeley by - * Chris Torek. - */ - -#include -#include -#include -#include "local.h" - -/* - * Various output routines call wsetup to be sure it is safe to write, - * because either _flags does not include __SWR, or _buf is NULL. - * _wsetup returns 0 if OK to write, nonzero otherwise. - */ -int -__swsetup(LTTNG_UST_LFILE *fp) -{ - /* make sure stdio is set up */ -// if (!__sdidinit) -// __sinit(); - - /* - * If we are not writing, we had better be reading and writing. - */ - if ((fp->_flags & __SWR) == 0) { - if ((fp->_flags & __SRW) == 0) - return (EOF); - if (fp->_flags & __SRD) { - /* clobber any ungetc data */ - if (HASUB(fp)) - FREEUB(fp); - fp->_flags &= ~(__SRD|__SEOF); - fp->_r = 0; - fp->_p = fp->_bf._base; - } - fp->_flags |= __SWR; - } - - /* - * Make a buffer if necessary, then set _w. - */ - if (fp->_bf._base == NULL) { -// if ((fp->_flags & (__SSTR | __SALC)) == __SSTR) -// return (EOF); -// __smakebuf(fp); - assert(0); - } - if (fp->_flags & __SLBF) { - /* - * It is line buffered, so make _lbfsize be -_bufsize - * for the putc() macro. We will change _lbfsize back - * to 0 whenever we turn off __SWR. - */ - fp->_w = 0; - fp->_lbfsize = -fp->_bf._size; - } else - fp->_w = fp->_flags & __SNBF ? 0 : fp->_bf._size; - return (0); -} diff --git a/tests/unit/libringbuffer/Makefile.am b/tests/unit/libringbuffer/Makefile.am index 134bcb1c..1954e454 100644 --- a/tests/unit/libringbuffer/Makefile.am +++ b/tests/unit/libringbuffer/Makefile.am @@ -7,5 +7,5 @@ test_shm_SOURCES = shm.c test_shm_LDADD = \ $(top_builddir)/src/libringbuffer/libringbuffer.la \ $(top_builddir)/src/liblttng-ust-comm/liblttng-ust-comm.la \ - $(top_builddir)/src/snprintf/libustsnprintf.la \ + $(top_builddir)/src/common/libcommon.la \ $(top_builddir)/tests/utils/libtap.a diff --git a/tests/unit/snprintf/Makefile.am b/tests/unit/snprintf/Makefile.am index e4af591a..cfc232a6 100644 --- a/tests/unit/snprintf/Makefile.am +++ b/tests/unit/snprintf/Makefile.am @@ -5,7 +5,7 @@ AM_CPPFLAGS += -I$(top_srcdir)/tests/utils noinst_PROGRAMS = test_snprintf test_snprintf_SOURCES = snprintf.c test_snprintf_LDADD = \ - $(top_builddir)/src/snprintf/libustsnprintf.la \ + $(top_builddir)/src/common/snprintf/libsnprintf.la \ $(top_builddir)/tests/utils/libtap.a EXTRA_DIST = README