ARI: Add ability to raise arbitrary User Events
[asterisk/asterisk.git] / main / term.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2010, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Terminal Routines
22  *
23  * \author Mark Spencer <markster@digium.com>
24  */
25
26 /*** MODULEINFO
27         <support_level>core</support_level>
28  ***/
29
30 #include "asterisk.h"
31
32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
33
34 #include "asterisk/_private.h"
35 #include <sys/time.h>
36 #include <signal.h>
37 #include <sys/stat.h>
38 #include <fcntl.h>
39
40 #include "asterisk/term.h"
41 #include "asterisk/lock.h"
42 #include "asterisk/utils.h"
43 #include "asterisk/threadstorage.h"
44
45 static int vt100compat;
46
47 static char prepdata[80] = "";
48 static char enddata[80] = "";
49 static char quitdata[80] = "";
50
51 static const char * const termpath[] = {
52         "/usr/share/terminfo",
53         "/usr/local/share/misc/terminfo",
54         "/usr/lib/terminfo",
55         NULL
56         };
57
58 AST_THREADSTORAGE(commonbuf);
59
60 struct commonbuf {
61         short which;
62         char buffer[AST_TERM_MAX_ROTATING_BUFFERS][AST_TERM_MAX_ESCAPE_CHARS];
63 };
64
65 static int opposite(int color)
66 {
67         int lookup[] = {
68                 /* BLACK */ COLOR_BLACK,
69                 /* RED */ COLOR_MAGENTA,
70                 /* GREEN */ COLOR_GREEN,
71                 /* BROWN */ COLOR_BROWN,
72                 /* BLUE */ COLOR_CYAN,
73                 /* MAGENTA */ COLOR_RED,
74                 /* CYAN */ COLOR_BLUE,
75                 /* WHITE */ COLOR_BLACK };
76         return color ? lookup[color - 30] : 0;
77 }
78
79 /* Ripped off from Ross Ridge, but it's public domain code (libmytinfo) */
80 static short convshort(char *s)
81 {
82         register int a, b;
83
84         a = (int) s[0] & 0377;
85         b = (int) s[1] & 0377;
86
87         if (a == 0377 && b == 0377)
88                 return -1;
89         if (a == 0376 && b == 0377)
90                 return -2;
91
92         return a + b * 256;
93 }
94
95 int ast_term_init(void)
96 {
97         char *term = getenv("TERM");
98         char termfile[256] = "";
99         char buffer[512] = "";
100         int termfd = -1, parseokay = 0, i;
101
102         if (ast_opt_no_color) {
103                 return 0;
104         }
105
106         if (!ast_opt_console) {
107                 /* If any remote console is not compatible, we'll strip the color codes at that point */
108                 vt100compat = 1;
109                 goto end;
110         }
111
112         if (!term) {
113                 return 0;
114         }
115
116         for (i = 0;; i++) {
117                 if (termpath[i] == NULL) {
118                         break;
119                 }
120                 snprintf(termfile, sizeof(termfile), "%s/%c/%s", termpath[i], *term, term);
121                 termfd = open(termfile, O_RDONLY);
122                 if (termfd > -1) {
123                         break;
124                 }
125         }
126         if (termfd > -1) {
127                 int actsize = read(termfd, buffer, sizeof(buffer) - 1);
128                 short sz_names = convshort(buffer + 2);
129                 short sz_bools = convshort(buffer + 4);
130                 short n_nums   = convshort(buffer + 6);
131
132                 /* if ((sz_names + sz_bools) & 1)
133                         sz_bools++; */
134
135                 if (sz_names + sz_bools + n_nums < actsize) {
136                         /* Offset 13 is defined in /usr/include/term.h, though we do not
137                          * include it here, as it conflicts with include/asterisk/term.h */
138                         short max_colors = convshort(buffer + 12 + sz_names + sz_bools + 13 * 2);
139                         if (max_colors > 0) {
140                                 vt100compat = 1;
141                         }
142                         parseokay = 1;
143                 }
144                 close(termfd);
145         }
146
147         if (!parseokay) {
148                 /* These comparisons should not be substrings nor case-insensitive, as
149                  * terminal types are very particular about how they treat suffixes and
150                  * capitalization.  For example, terminal type 'linux-m' does NOT
151                  * support color, while 'linux' does.  Not even all vt100* terminals
152                  * support color, either (e.g. 'vt100+fnkeys'). */
153                 if (!strcmp(term, "linux")) {
154                         vt100compat = 1;
155                 } else if (!strcmp(term, "xterm")) {
156                         vt100compat = 1;
157                 } else if (!strcmp(term, "xterm-color")) {
158                         vt100compat = 1;
159                 } else if (!strcmp(term, "xterm-256color")) {
160                         vt100compat = 1;
161                 } else if (!strncmp(term, "Eterm", 5)) {
162                         /* Both entries which start with Eterm support color */
163                         vt100compat = 1;
164                 } else if (!strcmp(term, "vt100")) {
165                         vt100compat = 1;
166                 } else if (!strncmp(term, "crt", 3)) {
167                         /* Both crt terminals support color */
168                         vt100compat = 1;
169                 }
170         }
171
172 end:
173         if (vt100compat) {
174                 /* Make commands show up in nice colors */
175                 if (ast_opt_light_background) {
176                         snprintf(prepdata, sizeof(prepdata), "%c[%dm", ESC, COLOR_BROWN);
177                         snprintf(enddata, sizeof(enddata), "%c[%dm", ESC, COLOR_BLACK);
178                         snprintf(quitdata, sizeof(quitdata), "%c[0m", ESC);
179                 } else if (ast_opt_force_black_background) {
180                         snprintf(prepdata, sizeof(prepdata), "%c[%d;%d;%dm", ESC, ATTR_BRIGHT, COLOR_BROWN, COLOR_BLACK + 10);
181                         snprintf(enddata, sizeof(enddata), "%c[%d;%d;%dm", ESC, ATTR_RESET, COLOR_WHITE, COLOR_BLACK + 10);
182                         snprintf(quitdata, sizeof(quitdata), "%c[0m", ESC);
183                 } else {
184                         snprintf(prepdata, sizeof(prepdata), "%c[%d;%dm", ESC, ATTR_BRIGHT, COLOR_BROWN);
185                         snprintf(enddata, sizeof(enddata), "%c[%d;%dm", ESC, ATTR_RESET, COLOR_WHITE);
186                         snprintf(quitdata, sizeof(quitdata), "%c[0m", ESC);
187                 }
188         }
189         return 0;
190 }
191
192 char *term_color(char *outbuf, const char *inbuf, int fgcolor, int bgcolor, int maxout)
193 {
194         int attr = 0;
195
196         if (!vt100compat) {
197                 ast_copy_string(outbuf, inbuf, maxout);
198                 return outbuf;
199         }
200         if (!fgcolor) {
201                 ast_copy_string(outbuf, inbuf, maxout);
202                 return outbuf;
203         }
204
205         if (fgcolor & 128) {
206                 attr = ast_opt_light_background ? 0 : ATTR_BRIGHT;
207                 fgcolor &= ~128;
208         }
209
210         if (bgcolor) {
211                 bgcolor &= ~128;
212         }
213
214         if (ast_opt_light_background) {
215                 fgcolor = opposite(fgcolor);
216         }
217
218         if (ast_opt_force_black_background) {
219                 snprintf(outbuf, maxout, "%c[%d;%d;%dm%s%c[%d;%dm", ESC, attr, fgcolor, bgcolor + 10, inbuf, ESC, COLOR_WHITE, COLOR_BLACK + 10);
220         } else {
221                 snprintf(outbuf, maxout, "%c[%d;%dm%s%c[0m", ESC, attr, fgcolor, inbuf, ESC);
222         }
223         return outbuf;
224 }
225
226 static void check_fgcolor(int *fgcolor, int *attr)
227 {
228         *attr = ast_opt_light_background ? 0 : ATTR_BRIGHT;
229         if (*fgcolor & 128) {
230                 *fgcolor &= ~128;
231         }
232
233         if (ast_opt_light_background) {
234                 *fgcolor = opposite(*fgcolor);
235         }
236 }
237
238 static void check_bgcolor(int *bgcolor)
239 {
240         if (*bgcolor) {
241                 *bgcolor &= ~128;
242         }
243 }
244
245 static int check_colors_allowed(int fgcolor)
246 {
247         return (!vt100compat || !fgcolor) ? 0 : 1;
248 }
249
250 int ast_term_color_code(struct ast_str **str, int fgcolor, int bgcolor)
251 {
252         int attr = 0;
253
254         if (!check_colors_allowed(fgcolor)) {
255                 return -1;
256         }
257
258         check_fgcolor(&fgcolor, &attr);
259         check_bgcolor(&bgcolor);
260
261         if (ast_opt_force_black_background) {
262                 ast_str_append(str, 0, "%c[%d;%d;%dm", ESC, attr, fgcolor, COLOR_BLACK + 10);
263         } else if (bgcolor) {
264                 ast_str_append(str, 0, "%c[%d;%d;%dm", ESC, attr, fgcolor, bgcolor + 10);
265         } else {
266                 ast_str_append(str, 0, "%c[%d;%dm", ESC, attr, fgcolor);
267         }
268
269         return 0;
270 }
271
272 char *term_color_code(char *outbuf, int fgcolor, int bgcolor, int maxout)
273 {
274         int attr = 0;
275
276         if (!check_colors_allowed(fgcolor)) {
277                 *outbuf = '\0';
278                 return outbuf;
279         }
280
281         check_fgcolor(&fgcolor, &attr);
282         check_bgcolor(&bgcolor);
283
284         if (ast_opt_force_black_background) {
285                 snprintf(outbuf, maxout, "%c[%d;%d;%dm", ESC, attr, fgcolor, COLOR_BLACK + 10);
286         } else if (bgcolor) {
287                 snprintf(outbuf, maxout, "%c[%d;%d;%dm", ESC, attr, fgcolor, bgcolor + 10);
288         } else {
289                 snprintf(outbuf, maxout, "%c[%d;%dm", ESC, attr, fgcolor);
290         }
291
292         return outbuf;
293 }
294
295 const char *ast_term_color(int fgcolor, int bgcolor)
296 {
297         struct commonbuf *cb = ast_threadstorage_get(&commonbuf, sizeof(*cb));
298         char *buf;
299
300         if (!cb) {
301                 return "";
302         }
303         buf = cb->buffer[cb->which++];
304         if (cb->which == AST_TERM_MAX_ROTATING_BUFFERS) {
305                 cb->which = 0;
306         }
307
308         return term_color_code(buf, fgcolor, bgcolor, AST_TERM_MAX_ESCAPE_CHARS);
309 }
310
311 const char *ast_term_reset(void)
312 {
313         if (ast_opt_force_black_background) {
314                 static const char reset[] = { ESC, '[', COLOR_BLACK + 10, 'm', 0 };
315                 return reset;
316         } else {
317                 return quitdata;
318         }
319 }
320
321 char *term_strip(char *outbuf, const char *inbuf, int maxout)
322 {
323         char *outbuf_ptr = outbuf;
324         const char *inbuf_ptr = inbuf;
325
326         while (outbuf_ptr < outbuf + maxout) {
327                 switch (*inbuf_ptr) {
328                         case ESC:
329                                 while (*inbuf_ptr && (*inbuf_ptr != 'm'))
330                                         inbuf_ptr++;
331                                 break;
332                         default:
333                                 *outbuf_ptr = *inbuf_ptr;
334                                 outbuf_ptr++;
335                 }
336                 if (! *inbuf_ptr)
337                         break;
338                 inbuf_ptr++;
339         }
340         return outbuf;
341 }
342
343 char *term_prompt(char *outbuf, const char *inbuf, int maxout)
344 {
345         if (!vt100compat) {
346                 ast_copy_string(outbuf, inbuf, maxout);
347                 return outbuf;
348         }
349         if (ast_opt_force_black_background) {
350                 snprintf(outbuf, maxout, "%c[%d;%d;%dm%c%c[%d;%dm%s",
351                         ESC, ATTR_BRIGHT, COLOR_BLUE, COLOR_BLACK + 10,
352                         inbuf[0],
353                         ESC, COLOR_WHITE, COLOR_BLACK + 10,
354                         inbuf + 1);
355         } else if (ast_opt_light_background) {
356                 snprintf(outbuf, maxout, "%c[%d;0m%c%c[0m%s",
357                         ESC, COLOR_BLUE,
358                         inbuf[0],
359                         ESC,
360                         inbuf + 1);
361         } else {
362                 snprintf(outbuf, maxout, "%c[%d;%d;0m%c%c[0m%s",
363                         ESC, ATTR_BRIGHT, COLOR_BLUE,
364                         inbuf[0],
365                         ESC,
366                         inbuf + 1);
367         }
368         return outbuf;
369 }
370
371 /* filter escape sequences */
372 void term_filter_escapes(char *line)
373 {
374         int i;
375         int len = strlen(line);
376
377         for (i = 0; i < len; i++) {
378                 if (line[i] != ESC)
379                         continue;
380                 if ((i < (len - 2)) &&
381                     (line[i + 1] == 0x5B)) {
382                         switch (line[i + 2]) {
383                         case 0x30:
384                         case 0x31:
385                         case 0x33:
386                                 continue;
387                         }
388                 }
389                 /* replace ESC with a space */
390                 line[i] = ' ';
391         }
392 }
393
394 const char *term_prep(void)
395 {
396         return prepdata;
397 }
398
399 const char *term_end(void)
400 {
401         return enddata;
402 }
403
404 const char *term_quit(void)
405 {
406         return quitdata;
407 }