tprintf.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * Copyright 2009, 2010 Daniel Borkmann.
   4  * Copyright 2013 Tobias Klauser.
   5  * Subject to the GPL, version 2.
   6  */
   7
   8 #define _BSD_SOURCE
   9 #include <ctype.h>
  10 #include <stdio.h>
  11 #include <stdarg.h>
  12 #include <sys/ioctl.h>
  13
  14 #include "xutils.h"
  15 #include "tprintf.h"
  16 #include "die.h"
  17 #include "locking.h"
  18 #include "built_in.h"
  19
  20 #define term_trailing_size      5
  21 #define term_starting_size      3
  22
  23 #define term_curr_size          (get_tty_size() - term_trailing_size)
  24
  25 static char buffer[1024];
  26
  27 static volatile size_t buffer_use = 0;
  28
  29 static struct spinlock buffer_lock;
  30
  31 static int get_tty_size(void)
  32 {
  33 #ifdef TIOCGSIZE
  34         struct ttysize ts = {0};
  35
  36         return (ioctl(0, TIOCGSIZE, &ts) == 0 ? ts.ts_cols : DEFAULT_TTY_SIZE);
  37 #elif defined(TIOCGWINSZ)
  38         struct winsize ts;
  39
  40         return (ioctl(0, TIOCGWINSZ, &ts) == 0 ? ts.ws_col : DEFAULT_TTY_SIZE);
  41 #else
  42         return DEFAULT_TTY_SIZE;
  43 #endif
  44 }
  45
  46 static inline void __tprintf_flush_newline(void)
  47 {
  48         int i;
  49
  50         fputc('\n', stdout);
  51         for (i = 0; i < term_starting_size; ++i)
  52                 fputc(' ', stdout);
  53 }
  54
  55 static inline int __tprintf_flush_skip(char *buffer, int i, size_t max)
  56 {
  57         int val = buffer[i];
  58
  59         if (val == ' ' || val == ',')
  60                 return 1;
  61
  62         return 0;
  63 }
  64
  65 static void __tprintf_flush(void)
  66 {
  67         int i;
  68         static ssize_t line_count = 0;
  69         size_t term_len = term_curr_size;
  70
  71         for (i = 0; i < buffer_use; ++i) {
  72                 if (buffer[i] == '\n') {
  73                         term_len = term_curr_size;
  74                         line_count = -1;
  75                 }
  76
  77                 if (line_count == term_len) {
  78                         __tprintf_flush_newline();
  79                         line_count = term_starting_size;
  80
  81                         while (i < buffer_use &&
  82                                __tprintf_flush_skip(buffer, i, buffer_use))
  83                                 i++;
  84                 }
  85
  86                 fputc(buffer[i], stdout);
  87                 line_count++;
  88         }
  89
  90         fflush(stdout);
  91         buffer_use = 0;
  92 }
  93
  94 void tprintf_flush(void)
  95 {
  96         spinlock_lock(&buffer_lock);
  97         __tprintf_flush();
  98         spinlock_unlock(&buffer_lock);
  99 }
 100
 101 void tprintf_init(void)
 102 {
 103         spinlock_init(&buffer_lock);
 104
 105         setvbuf(stdout, NULL, _IONBF, 0);
 106         setvbuf(stderr, NULL, _IONBF, 0);
 107 }
 108
 109 void tprintf_cleanup(void)
 110 {
 111         tprintf_flush();
 112         spinlock_destroy(&buffer_lock);
 113 }
 114
 115 void tprintf(char *msg, ...)
 116 {
 117         ssize_t ret;
 118         ssize_t avail;
 119         va_list vl;
 120
 121         spinlock_lock(&buffer_lock);
 122
 123         avail = sizeof(buffer) - buffer_use;
 124         bug_on(avail < 0);
 125
 126         va_start(vl, msg);
 127         ret = vsnprintf(buffer + buffer_use, avail, msg, vl);
 128         va_end(vl);
 129
 130         if (ret < 0)
 131                 panic("vsnprintf screwed up in tprintf!\n");
 132         if (ret > sizeof(buffer))
 133                 panic("No mem in tprintf left!\n");
 134         if (ret >= avail) {
 135                 __tprintf_flush();
 136
 137                 avail = sizeof(buffer) - buffer_use;
 138                 bug_on(avail < 0);
 139
 140                 va_start(vl, msg);
 141                 ret = vsnprintf(buffer + buffer_use, avail, msg, vl);
 142                 va_end(vl);
 143
 144                 if (ret < 0)
 145                         panic("vsnprintf screwed up in tprintf!\n");
 146         }
 147
 148         buffer_use += ret;
 149
 150         spinlock_unlock(&buffer_lock);
 151 }
 152
 153 void tputchar_safe(int c)
 154 {
 155         unsigned char ch = (unsigned char)(c & 0xff);
 156
 157         if (isprint(ch))
 158                 tprintf("%c", ch);
 159         else
 160                 tprintf("\\0x%02x", ch);
 161 }
 162
 163 void tputs_safe(const char *str, size_t len)
 164 {
 165         while (len--) {
 166                 tputchar_safe(*str);
 167                 str++;
 168         }
 169 }