1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 1997 Brian Somers <brian@Awfulhak.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 * $FreeBSD: stable/11/usr.sbin/ppp/log.c 330449 2018-03-05 07:26:05Z eadler $
29 */
30
31#include <sys/types.h>
32
33#include <ctype.h>
34#include <stdarg.h>
35#include <stdio.h>
36#include <string.h>
37#include <syslog.h>
38#include <termios.h>
39
40#include "defs.h"
41#include "command.h"
42#include "mbuf.h"
43#include "log.h"
44#include "descriptor.h"
45#include "prompt.h"
46
47static const char *const LogNames[] = {
48  "Async",
49  "CBCP",
50  "CCP",
51  "Chat",
52  "Command",
53  "Connect",
54  "Debug",
55  "DNS",
56  "Filter",			/* Log discarded packets */
57  "HDLC",
58  "ID0",
59  "IPCP",
60  "IPV6CP",
61  "LCP",
62  "LQM",
63  "Phase",
64  "Physical",
65  "Radius",
66  "Sync",
67  "TCP/IP",
68  "Timer",
69  "Tun",
70  "Warning",
71  "Error",
72  "Alert"
73};
74
75#define MSK(n) (1<<((n)-1))
76
77static u_long LogMask = MSK(LogPHASE);
78static u_long LogMaskLocal = MSK(LogERROR) | MSK(LogALERT) | MSK(LogWARN);
79static int LogTunno = -1;
80static const char *LogIfaceName;
81static struct prompt *promptlist;	/* Where to log local stuff */
82struct prompt *log_PromptContext;
83int log_PromptListChanged;
84
85struct prompt *
86log_PromptList()
87{
88  return promptlist;
89}
90
91void
92log_RegisterPrompt(struct prompt *prompt)
93{
94  prompt->next = promptlist;
95  promptlist = prompt;
96  prompt->active = 1;
97  log_DiscardAllLocal(&prompt->logmask);
98}
99
100void
101log_ActivatePrompt(struct prompt *prompt)
102{
103  prompt->active = 1;
104  LogMaskLocal |= prompt->logmask;
105}
106
107static void
108LogSetMaskLocal(void)
109{
110  struct prompt *p;
111
112  LogMaskLocal = MSK(LogERROR) | MSK(LogALERT) | MSK(LogWARN);
113  for (p = promptlist; p; p = p->next)
114    LogMaskLocal |= p->logmask;
115}
116
117void
118log_DeactivatePrompt(struct prompt *prompt)
119{
120  if (prompt->active) {
121    prompt->active = 0;
122    LogSetMaskLocal();
123  }
124}
125
126void
127log_UnRegisterPrompt(struct prompt *prompt)
128{
129  if (prompt) {
130    struct prompt **p;
131
132    for (p = &promptlist; *p; p = &(*p)->next)
133      if (*p == prompt) {
134        *p = prompt->next;
135        prompt->next = NULL;
136        break;
137      }
138    LogSetMaskLocal();
139    log_PromptListChanged++;
140  }
141}
142
143void
144log_DestroyPrompts(struct server *s)
145{
146  struct prompt *p, *pn, *pl;
147
148  p = promptlist;
149  pl = NULL;
150  while (p) {
151    pn = p->next;
152    if (s && p->owner == s) {
153      if (pl)
154        pl->next = p->next;
155      else
156        promptlist = p->next;
157      p->next = NULL;
158      prompt_Destroy(p, 1);
159    } else
160      pl = p;
161    p = pn;
162  }
163}
164
165void
166log_DisplayPrompts()
167{
168  struct prompt *p;
169
170  for (p = promptlist; p; p = p->next)
171    prompt_Required(p);
172}
173
174void
175log_WritePrompts(struct datalink *dl, const char *fmt,...)
176{
177  va_list ap;
178  struct prompt *p;
179
180  va_start(ap, fmt);
181  for (p = promptlist; p; p = p->next)
182    if (prompt_IsTermMode(p, dl))
183      prompt_vPrintf(p, fmt, ap);
184  va_end(ap);
185}
186
187void
188log_SetTtyCommandMode(struct datalink *dl)
189{
190  struct prompt *p;
191
192  for (p = promptlist; p; p = p->next)
193    if (prompt_IsTermMode(p, dl))
194      prompt_TtyCommandMode(p);
195}
196
197static int
198syslogLevel(int lev)
199{
200  switch (lev) {
201  case LogLOG:
202    return LOG_INFO;
203  case LogDEBUG:
204  case LogTIMER:
205    return LOG_DEBUG;
206  case LogWARN:
207    return LOG_WARNING;
208  case LogERROR:
209    return LOG_ERR;
210  case LogALERT:
211    return LOG_ALERT;
212  }
213  return lev >= LogMIN && lev <= LogMAX ? LOG_INFO : 0;
214}
215
216const char *
217log_Name(int id)
218{
219  if (id == LogLOG)
220    return "LOG";
221  return id < LogMIN || id > LogMAX ? "Unknown" : LogNames[id - 1];
222}
223
224void
225log_Keep(int id)
226{
227  if (id >= LogMIN && id <= LogMAXCONF)
228    LogMask |= MSK(id);
229}
230
231void
232log_KeepLocal(int id, u_long *mask)
233{
234  if (id >= LogMIN && id <= LogMAXCONF) {
235    LogMaskLocal |= MSK(id);
236    *mask |= MSK(id);
237  }
238}
239
240void
241log_Discard(int id)
242{
243  if (id >= LogMIN && id <= LogMAXCONF)
244    LogMask &= ~MSK(id);
245}
246
247void
248log_DiscardLocal(int id, u_long *mask)
249{
250  if (id >= LogMIN && id <= LogMAXCONF) {
251    *mask &= ~MSK(id);
252    LogSetMaskLocal();
253  }
254}
255
256void
257log_DiscardAll()
258{
259  LogMask = 0;
260}
261
262void
263log_DiscardAllLocal(u_long *mask)
264{
265  *mask = MSK(LogERROR) | MSK(LogALERT) | MSK(LogWARN);
266  LogSetMaskLocal();
267}
268
269int
270log_IsKept(int id)
271{
272  if (id == LogLOG)
273    return LOG_KEPT_SYSLOG;
274  if (id < LogMIN || id > LogMAX)
275    return 0;
276  if (id > LogMAXCONF)
277    return LOG_KEPT_LOCAL | LOG_KEPT_SYSLOG;
278
279  return ((LogMaskLocal & MSK(id)) ? LOG_KEPT_LOCAL : 0) |
280    ((LogMask & MSK(id)) ? LOG_KEPT_SYSLOG : 0);
281}
282
283int
284log_IsKeptLocal(int id, u_long mask)
285{
286  if (id < LogMIN || id > LogMAX)
287    return 0;
288  if (id > LogMAXCONF)
289    return LOG_KEPT_LOCAL | LOG_KEPT_SYSLOG;
290
291  return ((mask & MSK(id)) ? LOG_KEPT_LOCAL : 0) |
292    ((LogMask & MSK(id)) ? LOG_KEPT_SYSLOG : 0);
293}
294
295void
296log_Open(const char *Name)
297{
298  openlog(Name, LOG_PID, LOG_DAEMON);
299}
300
301void
302log_SetTun(int tunno, const char *ifaceName)
303{
304  LogTunno = tunno;
305  LogIfaceName = ifaceName;
306}
307
308void
309log_Close()
310{
311  closelog();
312  LogTunno = -1;
313  LogIfaceName = NULL;
314}
315
316void
317log_Printf(int lev, const char *fmt,...)
318{
319  va_list ap;
320  struct prompt *prompt;
321
322  if (log_IsKept(lev)) {
323    char nfmt[200];
324
325    va_start(ap, fmt);
326    if (promptlist && (log_IsKept(lev) & LOG_KEPT_LOCAL)) {
327      if ((log_IsKept(LogTUN) & LOG_KEPT_LOCAL) && LogTunno != -1) {
328        if (LogIfaceName)
329          snprintf(nfmt, sizeof nfmt, "%s%d(%s): %s: %s", TUN_NAME,
330	         LogTunno, LogIfaceName, log_Name(lev), fmt);
331        else
332          snprintf(nfmt, sizeof nfmt, "%s%d: %s: %s", TUN_NAME,
333	         LogTunno, log_Name(lev), fmt);
334      } else
335        snprintf(nfmt, sizeof nfmt, "%s: %s", log_Name(lev), fmt);
336
337      if (log_PromptContext && lev == LogWARN)
338        /* Warnings just go to the current prompt */
339        prompt_vPrintf(log_PromptContext, nfmt, ap);
340      else for (prompt = promptlist; prompt; prompt = prompt->next)
341        if (lev > LogMAXCONF || (prompt->logmask & MSK(lev)))
342          prompt_vPrintf(prompt, nfmt, ap);
343    }
344    va_end(ap);
345
346    va_start(ap, fmt);
347    if ((log_IsKept(lev) & LOG_KEPT_SYSLOG) &&
348        (lev != LogWARN || !log_PromptContext)) {
349      if ((log_IsKept(LogTUN) & LOG_KEPT_SYSLOG) && LogTunno != -1) {
350        if (LogIfaceName)
351          snprintf(nfmt, sizeof nfmt, "%s%d(%s): %s: %s", TUN_NAME,
352	         LogTunno, LogIfaceName, log_Name(lev), fmt);
353        else
354          snprintf(nfmt, sizeof nfmt, "%s%d: %s: %s", TUN_NAME,
355	         LogTunno, log_Name(lev), fmt);
356      } else
357        snprintf(nfmt, sizeof nfmt, "%s: %s", log_Name(lev), fmt);
358      vsyslog(syslogLevel(lev), nfmt, ap);
359    }
360    va_end(ap);
361  }
362}
363
364void
365log_DumpBp(int lev, const char *hdr, const struct mbuf *bp)
366{
367  if (log_IsKept(lev)) {
368    char buf[68];
369    char *b, *c;
370    const u_char *ptr;
371    int f;
372
373    if (hdr && *hdr)
374      log_Printf(lev, "%s\n", hdr);
375
376    b = buf;
377    c = b + 50;
378    do {
379      f = bp->m_len;
380      ptr = CONST_MBUF_CTOP(bp);
381      while (f--) {
382	sprintf(b, " %02x", (int) *ptr);
383        *c++ = isprint(*ptr) ? *ptr : '.';
384        ptr++;
385        b += 3;
386        if (b == buf + 48) {
387          memset(b, ' ', 2);
388          *c = '\0';
389          log_Printf(lev, "%s\n", buf);
390          b = buf;
391          c = b + 50;
392        }
393      }
394    } while ((bp = bp->m_next) != NULL);
395
396    if (b > buf) {
397      memset(b, ' ', 50 - (b - buf));
398      *c = '\0';
399      log_Printf(lev, "%s\n", buf);
400    }
401  }
402}
403
404void
405log_DumpBuff(int lev, const char *hdr, const u_char *ptr, int n)
406{
407  if (log_IsKept(lev)) {
408    char buf[68];
409    char *b, *c;
410
411    if (hdr && *hdr)
412      log_Printf(lev, "%s\n", hdr);
413    while (n > 0) {
414      b = buf;
415      c = b + 50;
416      for (b = buf; b != buf + 48 && n--; b += 3, ptr++) {
417	sprintf(b, " %02x", (int) *ptr);
418        *c++ = isprint(*ptr) ? *ptr : '.';
419      }
420      memset(b, ' ', 50 - (b - buf));
421      *c = '\0';
422      log_Printf(lev, "%s\n", buf);
423    }
424  }
425}
426
427int
428log_ShowLevel(struct cmdargs const *arg)
429{
430  int i;
431
432  prompt_Printf(arg->prompt, "Log:  ");
433  for (i = LogMIN; i <= LogMAX; i++)
434    if (log_IsKept(i) & LOG_KEPT_SYSLOG)
435      prompt_Printf(arg->prompt, " %s", log_Name(i));
436
437  prompt_Printf(arg->prompt, "\nLocal:");
438  for (i = LogMIN; i <= LogMAX; i++)
439    if (log_IsKeptLocal(i, arg->prompt->logmask) & LOG_KEPT_LOCAL)
440      prompt_Printf(arg->prompt, " %s", log_Name(i));
441
442  prompt_Printf(arg->prompt, "\n");
443
444  return 0;
445}
446
447int
448log_SetLevel(struct cmdargs const *arg)
449{
450  int i, res, argc, local;
451  char const *const *argv, *argp;
452
453  argc = arg->argc - arg->argn;
454  argv = arg->argv + arg->argn;
455  res = 0;
456
457  if (argc == 0 || strcasecmp(argv[0], "local"))
458    local = 0;
459  else {
460    if (arg->prompt == NULL) {
461      log_Printf(LogWARN, "set log local: Only available on the"
462                 " command line\n");
463      return 1;
464    }
465    argc--;
466    argv++;
467    local = 1;
468  }
469
470  if (argc == 0 || (argv[0][0] != '+' && argv[0][0] != '-')) {
471    if (local)
472      log_DiscardAllLocal(&arg->prompt->logmask);
473    else
474      log_DiscardAll();
475  }
476
477  while (argc--) {
478    argp = **argv == '+' || **argv == '-' ? *argv + 1 : *argv;
479    /* Special case 'all' */
480    if (strcasecmp(argp, "all") == 0) {
481        if (**argv == '-') {
482          if (local)
483            for (i = LogMIN; i <= LogMAX; i++)
484              log_DiscardLocal(i, &arg->prompt->logmask);
485          else
486            for (i = LogMIN; i <= LogMAX; i++)
487              log_Discard(i);
488        } else if (local)
489          for (i = LogMIN; i <= LogMAX; i++)
490            log_KeepLocal(i, &arg->prompt->logmask);
491        else
492          for (i = LogMIN; i <= LogMAX; i++)
493            log_Keep(i);
494        argv++;
495        continue;
496    }
497    for (i = LogMIN; i <= LogMAX; i++)
498      if (strcasecmp(argp, log_Name(i)) == 0) {
499	if (**argv == '-') {
500          if (local)
501            log_DiscardLocal(i, &arg->prompt->logmask);
502          else
503	    log_Discard(i);
504	} else if (local)
505          log_KeepLocal(i, &arg->prompt->logmask);
506        else
507          log_Keep(i);
508	break;
509      }
510    if (i > LogMAX) {
511      log_Printf(LogWARN, "%s: Invalid log value\n", argp);
512      res = -1;
513    }
514    argv++;
515  }
516  return res;
517}
518
519int
520log_ShowWho(struct cmdargs const *arg)
521{
522  struct prompt *p;
523
524  for (p = promptlist; p; p = p->next) {
525    prompt_Printf(arg->prompt, "%s (%s)", p->src.type, p->src.from);
526    if (p == arg->prompt)
527      prompt_Printf(arg->prompt, " *");
528    if (!p->active)
529      prompt_Printf(arg->prompt, " ^Z");
530    prompt_Printf(arg->prompt, "\n");
531  }
532
533  return 0;
534}
535