File: | src/usr.sbin/npppd/npppd/../common/debugutil.c |
Warning: | line 283, column 4 Value stored to 'o' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: debugutil.c,v 1.6 2017/05/30 17:22:00 yasuoka Exp $ */ |
2 | /*- |
3 | * Copyright (c) 2009 Internet Initiative Japan Inc. |
4 | * All rights reserved. |
5 | * |
6 | * Redistribution and use in source and binary forms, with or without |
7 | * modification, are permitted provided that the following conditions |
8 | * are met: |
9 | * 1. Redistributions of source code must retain the above copyright |
10 | * notice, this list of conditions and the following disclaimer. |
11 | * 2. Redistributions in binary form must reproduce the above copyright |
12 | * notice, this list of conditions and the following disclaimer in the |
13 | * documentation and/or other materials provided with the distribution. |
14 | * |
15 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND |
16 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
17 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
18 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
19 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
20 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
21 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
22 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
23 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
24 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
25 | * SUCH DAMAGE. |
26 | */ |
27 | #include <sys/types.h> |
28 | #include <stdio.h> |
29 | #include <errno(*__errno()).h> |
30 | #include <string.h> |
31 | #include <syslog.h> |
32 | #include <stdarg.h> |
33 | #include <stdlib.h> |
34 | #include <time.h> |
35 | |
36 | #include "debugutil.h" |
37 | |
38 | #define MINIMUM(a, b)(((a) < (b)) ? (a) : (b)) (((a) < (b)) ? (a) : (b)) |
39 | #define MAXIMUM(a, b)(((a) > (b)) ? (a) : (b)) (((a) > (b)) ? (a) : (b)) |
40 | |
41 | int debuglevel = 0; |
42 | FILE *debugfp = NULL((void *)0); |
43 | static int prio_idx_inititialized = 0; |
44 | |
45 | static void set_prio_idx_init(void); |
46 | |
47 | #ifndef countof |
48 | #define countof(x)(sizeof((x)) / sizeof((x)[0])) (sizeof((x)) / sizeof((x)[0])) |
49 | #endif |
50 | #define VAL_NAME(x){ (x), "x"} { (x), #x} |
51 | |
52 | #ifndef LOG_PRI |
53 | #define LOG_PRI(p)((p) & 0x07) ((p) & LOG_PRIMASK0x07) |
54 | #endif |
55 | |
56 | static int use_syslog = 1; |
57 | static int no_debuglog = 0; |
58 | static int syslog_level_adjust = 0; |
59 | |
60 | static struct { |
61 | int prio; |
62 | const char *name; |
63 | } prio_name[] = { |
64 | VAL_NAME(LOG_EMERG){ (0), "LOG_EMERG"}, |
65 | VAL_NAME(LOG_ALERT){ (1), "LOG_ALERT"}, |
66 | VAL_NAME(LOG_CRIT){ (2), "LOG_CRIT"}, |
67 | VAL_NAME(LOG_ERR){ (3), "LOG_ERR"}, |
68 | VAL_NAME(LOG_WARNING){ (4), "LOG_WARNING"}, |
69 | VAL_NAME(LOG_NOTICE){ (5), "LOG_NOTICE"}, |
70 | VAL_NAME(LOG_INFO){ (6), "LOG_INFO"}, |
71 | VAL_NAME(LOG_DEBUG){ (7), "LOG_DEBUG"} |
72 | }; |
73 | |
74 | static const char *prio_name_idx[16]; |
75 | |
76 | static void |
77 | set_prio_idx_init() |
78 | { |
79 | int i; |
80 | |
81 | if (prio_idx_inititialized) |
82 | return; |
83 | for (i = 0; i < (int)countof(prio_name)(sizeof((prio_name)) / sizeof((prio_name)[0])); i++) { |
84 | ASSERT(prio_name[i].prio < countof(prio_name_idx))((void)0);; |
85 | if (prio_name[i].prio >= (int)countof(prio_name_idx)(sizeof((prio_name_idx)) / sizeof((prio_name_idx)[0]))) |
86 | continue; |
87 | prio_name_idx[prio_name[i].prio] = &prio_name[i].name[4]; |
88 | } |
89 | prio_idx_inititialized = 1; |
90 | } |
91 | |
92 | void |
93 | debug_set_debugfp(fp) |
94 | FILE *fp; |
95 | { |
96 | debugfp = fp; |
97 | } |
98 | |
99 | void |
100 | debug_use_syslog(b) |
101 | int b; |
102 | { |
103 | if (b) |
104 | use_syslog = 1; |
105 | else |
106 | use_syslog = 0; |
107 | } |
108 | |
109 | void |
110 | debug_set_no_debuglog(int no_debuglog0) |
111 | { |
112 | if (no_debuglog0) |
113 | no_debuglog = 1; |
114 | else |
115 | no_debuglog = 0; |
116 | } |
117 | |
118 | FILE * |
119 | debug_get_debugfp() |
120 | { |
121 | return debugfp; |
122 | } |
123 | |
124 | #define DL(p)((p) >> 24 & 0xff) ((p) >> 24 & 0xff) |
125 | int |
126 | vlog_printf(uint32_t prio, const char *format, va_list ap) |
127 | { |
128 | int status = 0, i, fmtoff = 0, state = 0, fmtlen, saved_errno, level; |
129 | char fmt[8192]; |
130 | struct tm *lt; |
131 | time_t now; |
132 | |
133 | ASSERT(format != NULL)((void)0);; |
134 | ASSERT(format[0] != '\0')((void)0);; |
135 | if (DL(prio)((prio) >> 24 & 0xff) > 0 && debuglevel < (int)DL(prio)((prio) >> 24 & 0xff)) |
136 | return -1; |
137 | if (no_debuglog && LOG_PRI(prio)((prio) & 0x07) >= LOG_DEBUG7) |
138 | return -1; |
139 | |
140 | if (!prio_idx_inititialized) |
141 | set_prio_idx_init(); |
142 | if (use_syslog && DL(prio)((prio) >> 24 & 0xff) == 0) { |
143 | level = LOG_PRI(prio)((prio) & 0x07) + syslog_level_adjust; |
144 | if (!no_debuglog || level < LOG_DEBUG7) { |
145 | level = MINIMUM(LOG_DEBUG, level)(((7) < (level)) ? (7) : (level)); |
146 | level = MAXIMUM(LOG_EMERG, level)(((0) > (level)) ? (0) : (level)); |
147 | level |= (prio & LOG_FACMASK0x03f8); |
148 | vsyslog(level, format, ap); |
149 | } |
150 | } |
151 | |
152 | if (debugfp == NULL((void *)0)) |
153 | return -1; |
154 | |
155 | time(&now); |
156 | lt = localtime(&now); |
157 | |
158 | fmtlen = strlen(format); |
159 | for (i = 0; i < fmtlen; i++) { |
160 | /* 2 chars in this block and 2 chars after this block */ |
161 | if (sizeof(fmt) - fmtoff < 4) |
162 | break; |
163 | switch(state) { |
164 | case 0: |
165 | switch(format[i]) { |
166 | case '%': |
167 | state = 1; |
168 | goto copy_loop; |
169 | case '\n': |
170 | fmt[fmtoff++] = '\n'; |
171 | fmt[fmtoff++] = '\t'; |
172 | goto copy_loop; |
173 | } |
174 | break; |
175 | case 1: |
176 | switch(format[i]) { |
177 | default: |
178 | case '%': |
179 | fmt[fmtoff++] = '%'; |
180 | state = 0; |
181 | break; |
182 | case 'm': |
183 | fmt[fmtoff] = '\0'; |
184 | saved_errno = errno(*__errno()); |
185 | /* -1 is to reserve for '\n' */ |
186 | strlcat(fmt, strerror(errno(*__errno())), sizeof(fmt) - 1); |
187 | errno(*__errno()) = saved_errno; |
188 | fmtoff = strlen(fmt); |
189 | state = 0; |
190 | goto copy_loop; |
191 | } |
192 | } |
193 | fmt[fmtoff++] = format[i]; |
194 | copy_loop: |
195 | continue; |
196 | } |
197 | /* remove trailing TAB */ |
198 | if (fmtoff > 0 && fmt[fmtoff - 1] == '\t') |
199 | fmtoff--; |
200 | /* append new line char */ |
201 | if (fmtoff == 0 || fmt[fmtoff-1] != '\n') |
202 | fmt[fmtoff++] = '\n'; |
203 | |
204 | fmt[fmtoff] = '\0'; |
205 | |
206 | ASSERT(0 <= LOG_PRI(prio)((void)0); |
207 | && LOG_PRI(prio) < countof(prio_name_idx)((void)0); |
208 | && prio_name_idx[LOG_PRI(prio)] != NULL)((void)0);; |
209 | ftell(debugfp); |
210 | fprintf(debugfp, |
211 | "%04d-%02d-%02d %02d:%02d:%02d:%s: " |
212 | , lt->tm_year + 1900 |
213 | , lt->tm_mon + 1 |
214 | , lt->tm_mday |
215 | , lt->tm_hour |
216 | , lt->tm_min |
217 | , lt->tm_sec |
218 | , (prio & 0xff000000) ? "DEBUG" : prio_name_idx[LOG_PRI(prio)((prio) & 0x07)] |
219 | ); |
220 | status = vfprintf(debugfp, fmt, ap); |
221 | fflush(debugfp); |
222 | |
223 | return status; |
224 | } |
225 | |
226 | int |
227 | log_printf(int prio, const char *fmt, ...) |
228 | { |
229 | int status; |
230 | va_list ap; |
231 | |
232 | va_start(ap, fmt)__builtin_va_start(ap, fmt); |
233 | status = vlog_printf((uint32_t)prio, fmt, ap); |
234 | va_end(ap)__builtin_va_end(ap); |
235 | |
236 | return status; |
237 | } |
238 | |
239 | void |
240 | debug_set_syslog_level_adjust(int adjust) |
241 | { |
242 | syslog_level_adjust = adjust; |
243 | } |
244 | |
245 | int |
246 | debug_get_syslog_level_adjust(void) |
247 | { |
248 | return syslog_level_adjust; |
249 | } |
250 | |
251 | |
252 | /* |
253 | * show_hd - |
254 | * print hexadecimal/ascii dump for debug |
255 | * |
256 | * usage: |
257 | * show_hd(stderr, buf, sizeof(buf)); |
258 | */ |
259 | void |
260 | show_hd(FILE *file, const u_char *buf, int len) |
261 | { |
262 | int i, o = 0; |
263 | int hd_cnt = 0; |
264 | char linebuf[80]; |
265 | char asciibuf[17]; |
266 | |
267 | memset(asciibuf, ' ', sizeof(asciibuf)); |
268 | asciibuf[sizeof(asciibuf)-1] = '\0'; |
269 | |
270 | for (i = 0; i < len; i++) { |
271 | if (0x20 <= *(buf+i) && *(buf+i) <= 0x7e) |
272 | asciibuf[hd_cnt % 16] = *(buf+i); |
273 | else |
274 | asciibuf[hd_cnt % 16] = '.'; |
275 | |
276 | switch (hd_cnt % 16) { |
277 | case 0: |
278 | o += snprintf(linebuf + o, sizeof(linebuf) - o, |
279 | "%04x %02x", hd_cnt, |
280 | (unsigned char)*(buf+i)); |
281 | break; |
282 | case 15: |
283 | o += snprintf(linebuf + o, sizeof(linebuf) - o, |
Value stored to 'o' is never read | |
284 | "%02x", (unsigned char)*(buf+i)); |
285 | if (file) |
286 | fprintf(file, "\t%-47s |%s|\n", linebuf, |
287 | asciibuf); |
288 | else |
289 | syslog(LOG_ERR3, "%-47s |%s|\n", linebuf, |
290 | asciibuf); |
291 | memset(asciibuf, ' ', sizeof(asciibuf)); |
292 | asciibuf[sizeof(asciibuf)-1] = '\0'; |
293 | o = 0; |
294 | break; |
295 | case 8: |
296 | o += snprintf(linebuf + o, sizeof(linebuf) - o, |
297 | "- %02x", (unsigned char)*(buf+i)); |
298 | break; |
299 | default: |
300 | if (hd_cnt % 2 == 1) |
301 | o += snprintf(linebuf + o, sizeof(linebuf) - o, |
302 | "%02x ", (unsigned char)*(buf+i)); |
303 | else |
304 | o += snprintf(linebuf + o, sizeof(linebuf) - o, |
305 | "%02x", (unsigned char)*(buf+i)); |
306 | break; |
307 | } |
308 | hd_cnt++; |
309 | } |
310 | if (hd_cnt > 0 && (hd_cnt % 16) != 0) { |
311 | if (file) |
312 | fprintf(file, "\t%-47s |%s|\n", linebuf, asciibuf); |
313 | else |
314 | syslog(LOG_ERR3, "%-47s |%s|\n", linebuf, asciibuf); |
315 | } |
316 | if (file) |
317 | fflush(file); |
318 | } |