1 /* printf implementation for the dynamic loader.
2 Copyright (C) 1997-2023 Free Software Foundation, Inc.
3 Copyright The GNU Toolchain Authors.
4 This file is part of the GNU C Library.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <https://www.gnu.org/licenses/>. */
19
20 #include <_itoa.h>
21 #include <assert.h>
22 #include <dl-writev.h>
23 #include <ldsodefs.h>
24 #include <limits.h>
25 #include <stdarg.h>
26 #include <stdint.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <sys/uio.h>
30 #include <unistd.h>
31 #include <intprops.h>
32
33 /* Bare-bones printf implementation. This function only knows about
34 the formats and flags needed and can handle only up to 64 stripes in
35 the output. */
36 static void
37 _dl_debug_vdprintf (int fd, int tag_p, const char *fmt, va_list arg)
38 {
39 # define NIOVMAX 64
40 struct iovec iov[NIOVMAX];
41 /* Maximum size for 'd', 'u', and 'x' including padding. */
42 enum { IFMTSIZE = INT_STRLEN_BOUND(void *) };
43 char ifmtbuf[NIOVMAX][IFMTSIZE];
44 int niov = 0;
45 pid_t pid = 0;
46 char pidbuf[12];
47
48 while (*fmt != '\0')
49 {
50 const char *startp = fmt;
51
52 if (tag_p > 0)
53 {
54 /* Generate the tag line once. It consists of the PID and a
55 colon followed by a tab. */
56 if (pid == 0)
57 {
58 char *p;
59 pid = __getpid ();
60 assert (pid >= 0 && sizeof (pid_t) <= 4);
61 p = _itoa (pid, &pidbuf[10], 10, 0);
62 while (p > pidbuf)
63 *--p = ' ';
64 pidbuf[10] = ':';
65 pidbuf[11] = '\t';
66 }
67
68 /* Append to the output. */
69 assert (niov < NIOVMAX);
70 iov[niov].iov_len = 12;
71 iov[niov++].iov_base = pidbuf;
72
73 /* No more tags until we see the next newline. */
74 tag_p = -1;
75 }
76
77 /* Skip everything except % and \n (if tags are needed). */
78 while (*fmt != '\0' && *fmt != '%' && (! tag_p || *fmt != '\n'))
79 ++fmt;
80
81 /* Append constant string. */
82 assert (niov < NIOVMAX);
83 if ((iov[niov].iov_len = fmt - startp) != 0)
84 iov[niov++].iov_base = (char *) startp;
85
86 if (*fmt == '%')
87 {
88 /* It is a format specifier. */
89 char fill = ' ';
90 int width = -1;
91 int prec = -1;
92 #if LONG_MAX != INT_MAX
93 int long_mod = 0;
94 #endif
95
96 /* Recognize zero-digit fill flag. */
97 if (*++fmt == '0')
98 {
99 fill = '0';
100 ++fmt;
101 }
102
103 /* See whether with comes from a parameter. Note that no other
104 way to specify the width is implemented. */
105 if (*fmt == '*')
106 {
107 width = va_arg (arg, int);
108 /* The maximum padding accepted is up to pointer size. */
109 assert (width < IFMTSIZE);
110 ++fmt;
111 }
112
113 /* Handle precision. */
114 if (*fmt == '.' && fmt[1] == '*')
115 {
116 prec = va_arg (arg, int);
117 fmt += 2;
118 }
119
120 /* Recognize the l modifier. It is only important on some
121 platforms where long and int have a different size. We
122 can use the same code for size_t. */
123 if (*fmt == 'l' || *fmt == 'z')
124 {
125 #if LONG_MAX != INT_MAX
126 long_mod = 1;
127 #endif
128 ++fmt;
129 }
130
131 switch (*fmt)
132 {
133 /* Integer formatting. */
134 case 'd':
135 case 'u':
136 case 'x':
137 {
138 /* We have to make a difference if long and int have a
139 different size. */
140 #if LONG_MAX != INT_MAX
141 unsigned long int num = (long_mod
142 ? va_arg (arg, unsigned long int)
143 : va_arg (arg, unsigned int));
144 #else
145 unsigned long int num = va_arg (arg, unsigned int);
146 #endif
147 bool negative = false;
148 if (*fmt == 'd')
149 {
150 #if LONG_MAX != INT_MAX
151 if (long_mod)
152 {
153 if ((long int) num < 0)
154 {
155 num = -num;
156 negative = true;
157 }
158 }
159 else
160 {
161 if ((int) num < 0)
162 {
163 num = -(unsigned int) num;
164 negative = true;
165 }
166 }
167 #else
168 if ((int) num < 0)
169 {
170 num = -num;
171 negative = true;
172 }
173 #endif
174 }
175
176 char *endp = &ifmtbuf[niov][IFMTSIZE];
177 char *cp = _itoa (num, endp, *fmt == 'x' ? 16 : 10, 0);
178
179 /* Pad to the width the user specified. */
180 if (width != -1)
181 while (endp - cp < width)
182 *--cp = fill;
183
184 if (negative)
185 *--cp = '-';
186
187 iov[niov].iov_base = cp;
188 iov[niov].iov_len = endp - cp;
189 ++niov;
190 }
191 break;
192
193 case 's':
194 /* Get the string argument. */
195 iov[niov].iov_base = va_arg (arg, char *);
196 iov[niov].iov_len = strlen (iov[niov].iov_base);
197 if (prec != -1)
198 iov[niov].iov_len = MIN ((size_t) prec, iov[niov].iov_len);
199 ++niov;
200 break;
201
202 case '%':
203 iov[niov].iov_base = (void *) fmt;
204 iov[niov].iov_len = 1;
205 ++niov;
206 break;
207
208 default:
209 assert (! "invalid format specifier");
210 }
211 ++fmt;
212 }
213 else if (*fmt == '\n')
214 {
215 /* See whether we have to print a single newline character. */
216 if (fmt == startp)
217 {
218 iov[niov].iov_base = (char *) startp;
219 iov[niov++].iov_len = 1;
220 }
221 else
222 /* No, just add it to the rest of the string. */
223 ++iov[niov - 1].iov_len;
224
225 /* Next line, print a tag again. */
226 tag_p = 1;
227 ++fmt;
228 }
229 }
230
231 /* Finally write the result. */
232 _dl_writev (fd, iov, niov);
233 }
234
235
236 /* Write to debug file. */
237 void
238 _dl_debug_printf (const char *fmt, ...)
239 {
240 va_list arg;
241
242 va_start (arg, fmt);
243 _dl_debug_vdprintf (GLRO(dl_debug_fd), 1, fmt, arg);
244 va_end (arg);
245 }
246
247
248 /* Write to debug file but don't start with a tag. */
249 void
250 _dl_debug_printf_c (const char *fmt, ...)
251 {
252 va_list arg;
253
254 va_start (arg, fmt);
255 _dl_debug_vdprintf (GLRO(dl_debug_fd), -1, fmt, arg);
256 va_end (arg);
257 }
258
259
260 /* Write the given file descriptor. */
261 void
262 _dl_dprintf (int fd, const char *fmt, ...)
263 {
264 va_list arg;
265
266 va_start (arg, fmt);
267 _dl_debug_vdprintf (fd, 0, fmt, arg);
268 va_end (arg);
269 }
270
271 void
272 _dl_printf (const char *fmt, ...)
273 {
274 va_list arg;
275
276 va_start (arg, fmt);
277 _dl_debug_vdprintf (STDOUT_FILENO, 0, fmt, arg);
278 va_end (arg);
279 }
280
281 void
282 _dl_error_printf (const char *fmt, ...)
283 {
284 va_list arg;
285
286 va_start (arg, fmt);
287 _dl_debug_vdprintf (STDERR_FILENO, 0, fmt, arg);
288 va_end (arg);
289 }
290
291 void
292 _dl_fatal_printf (const char *fmt, ...)
293 {
294 va_list arg;
295
296 va_start (arg, fmt);
297 _dl_debug_vdprintf (STDERR_FILENO, 0, fmt, arg);
298 va_end (arg);
299 _exit (127);
300 }
301 rtld_hidden_def (_dl_fatal_printf)