1 /* $OpenBSD: format.c,v 1.40 2013/11/24 11:29:09 nicm Exp $ */ 2 3 /* 4 * Copyright (c) 2011 Nicholas Marriott <nicm@users.sourceforge.net> 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER 15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING 16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <sys/types.h> 20 21 #include <ctype.h> 22 #include <errno.h> 23 #include <netdb.h> 24 #include <stdarg.h> 25 #include <stdlib.h> 26 #include <string.h> 27 #include <time.h> 28 #include <unistd.h> 29 30 #include "tmux.h" 31 32 /* 33 * Build a list of key-value pairs and use them to expand #{key} entries in a 34 * string. 35 */ 36 37 int format_replace(struct format_tree *, const char *, size_t, char **, 38 size_t *, size_t *); 39 char *format_get_command(struct window_pane *); 40 void format_window_pane_tabs(struct format_tree *, struct window_pane *); 41 42 /* Format key-value replacement entry. */ 43 RB_GENERATE(format_tree, format_entry, entry, format_cmp); 44 45 /* Format tree comparison function. */ 46 int 47 format_cmp(struct format_entry *fe1, struct format_entry *fe2) 48 { 49 return (strcmp(fe1->key, fe2->key)); 50 } 51 52 /* Single-character uppercase aliases. */ 53 const char *format_upper[] = { 54 NULL, /* A */ 55 NULL, /* B */ 56 NULL, /* C */ 57 "pane_id", /* D */ 58 NULL, /* E */ 59 "window_flags", /* F */ 60 NULL, /* G */ 61 "host", /* H */ 62 "window_index", /* I */ 63 NULL, /* J */ 64 NULL, /* K */ 65 NULL, /* L */ 66 NULL, /* M */ 67 NULL, /* N */ 68 NULL, /* O */ 69 "pane_index", /* P */ 70 NULL, /* Q */ 71 NULL, /* R */ 72 "session_name", /* S */ 73 "pane_title", /* T */ 74 NULL, /* U */ 75 NULL, /* V */ 76 "window_name", /* W */ 77 NULL, /* X */ 78 NULL, /* Y */ 79 NULL /* Z */ 80 }; 81 82 /* Single-character lowercase aliases. */ 83 const char *format_lower[] = { 84 NULL, /* a */ 85 NULL, /* b */ 86 NULL, /* c */ 87 NULL, /* d */ 88 NULL, /* e */ 89 NULL, /* f */ 90 NULL, /* g */ 91 "host_short", /* h */ 92 NULL, /* i */ 93 NULL, /* j */ 94 NULL, /* k */ 95 NULL, /* l */ 96 NULL, /* m */ 97 NULL, /* n */ 98 NULL, /* o */ 99 NULL, /* p */ 100 NULL, /* q */ 101 NULL, /* r */ 102 NULL, /* s */ 103 NULL, /* t */ 104 NULL, /* u */ 105 NULL, /* v */ 106 NULL, /* w */ 107 NULL, /* x */ 108 NULL, /* y */ 109 NULL /* z */ 110 }; 111 112 /* Create a new tree. */ 113 struct format_tree * 114 format_create(void) 115 { 116 struct format_tree *ft; 117 char host[MAXHOSTNAMELEN], *ptr; 118 119 ft = xmalloc(sizeof *ft); 120 RB_INIT(ft); 121 122 if (gethostname(host, sizeof host) == 0) { 123 format_add(ft, "host", "%s", host); 124 if ((ptr = strchr(host, '.')) != NULL) 125 *ptr = '\0'; 126 format_add(ft, "host_short", "%s", host); 127 } 128 129 return (ft); 130 } 131 132 /* Free a tree. */ 133 void 134 format_free(struct format_tree *ft) 135 { 136 struct format_entry *fe, *fe_next; 137 138 fe_next = RB_MIN(format_tree, ft); 139 while (fe_next != NULL) { 140 fe = fe_next; 141 fe_next = RB_NEXT(format_tree, ft, fe); 142 143 RB_REMOVE(format_tree, ft, fe); 144 free(fe->value); 145 free(fe->key); 146 free(fe); 147 } 148 149 free(ft); 150 } 151 152 /* Add a key-value pair. */ 153 void 154 format_add(struct format_tree *ft, const char *key, const char *fmt, ...) 155 { 156 struct format_entry *fe; 157 struct format_entry *fe_now; 158 va_list ap; 159 160 fe = xmalloc(sizeof *fe); 161 fe->key = xstrdup(key); 162 163 va_start(ap, fmt); 164 xvasprintf(&fe->value, fmt, ap); 165 va_end(ap); 166 167 fe_now = RB_INSERT(format_tree, ft, fe); 168 if (fe_now != NULL) { 169 free(fe_now->value); 170 fe_now->value = fe->value; 171 free(fe->key); 172 free(fe); 173 } 174 } 175 176 /* Find a format entry. */ 177 const char * 178 format_find(struct format_tree *ft, const char *key) 179 { 180 struct format_entry *fe, fe_find; 181 182 fe_find.key = (char *) key; 183 fe = RB_FIND(format_tree, ft, &fe_find); 184 if (fe == NULL) 185 return (NULL); 186 return (fe->value); 187 } 188 189 /* 190 * Replace a key/value pair in buffer. #{blah} is expanded directly, 191 * #{?blah,a,b} is replace with a if blah exists and is nonzero else b. 192 */ 193 int 194 format_replace(struct format_tree *ft, const char *key, size_t keylen, 195 char **buf, size_t *len, size_t *off) 196 { 197 char *copy, *copy0, *endptr, *ptr, *saved; 198 const char *value; 199 size_t valuelen; 200 u_long limit = ULONG_MAX; 201 202 /* Make a copy of the key. */ 203 copy0 = copy = xmalloc(keylen + 1); 204 memcpy(copy, key, keylen); 205 copy[keylen] = '\0'; 206 207 /* Is there a length limit or whatnot? */ 208 if (!islower((u_char) *copy) && *copy != '?') { 209 while (*copy != ':' && *copy != '\0') { 210 switch (*copy) { 211 case '=': 212 errno = 0; 213 limit = strtoul(copy + 1, &endptr, 10); 214 if (errno == ERANGE && limit == ULONG_MAX) 215 goto fail; 216 copy = endptr; 217 break; 218 default: 219 copy++; 220 break; 221 } 222 } 223 if (*copy != ':') 224 goto fail; 225 copy++; 226 } 227 228 /* 229 * Is this a conditional? If so, check it exists and extract either the 230 * first or second element. If not, look up the key directly. 231 */ 232 if (*copy == '?') { 233 ptr = strchr(copy, ','); 234 if (ptr == NULL) 235 goto fail; 236 *ptr = '\0'; 237 238 value = format_find(ft, copy + 1); 239 if (value != NULL && (value[0] != '0' || value[1] != '\0')) { 240 value = ptr + 1; 241 ptr = strchr(value, ','); 242 if (ptr == NULL) 243 goto fail; 244 *ptr = '\0'; 245 } else { 246 ptr = strchr(ptr + 1, ','); 247 if (ptr == NULL) 248 goto fail; 249 value = ptr + 1; 250 } 251 saved = format_expand(ft, value); 252 value = saved; 253 } else { 254 value = format_find(ft, copy); 255 if (value == NULL) 256 value = ""; 257 saved = NULL; 258 } 259 valuelen = strlen(value); 260 261 /* Truncate the value if needed. */ 262 if (valuelen > limit) 263 valuelen = limit; 264 265 /* Expand the buffer and copy in the value. */ 266 while (*len - *off < valuelen + 1) { 267 *buf = xrealloc(*buf, 2, *len); 268 *len *= 2; 269 } 270 memcpy(*buf + *off, value, valuelen); 271 *off += valuelen; 272 273 free(saved); 274 free(copy0); 275 return (0); 276 277 fail: 278 free(copy0); 279 return (-1); 280 } 281 282 /* Expand keys in a template. */ 283 char * 284 format_expand(struct format_tree *ft, const char *fmt) 285 { 286 char *buf; 287 const char *ptr, *s; 288 size_t off, len, n; 289 int ch, brackets; 290 291 len = 64; 292 buf = xmalloc(len); 293 off = 0; 294 295 while (*fmt != '\0') { 296 if (*fmt != '#') { 297 while (len - off < 2) { 298 buf = xrealloc(buf, 2, len); 299 len *= 2; 300 } 301 buf[off++] = *fmt++; 302 continue; 303 } 304 fmt++; 305 306 ch = (u_char) *fmt++; 307 switch (ch) { 308 case '{': 309 brackets = 1; 310 for (ptr = fmt; *ptr != '\0'; ptr++) { 311 if (*ptr == '{') 312 brackets++; 313 if (*ptr == '}' && --brackets == 0) 314 break; 315 } 316 if (*ptr != '}' || brackets != 0) 317 break; 318 n = ptr - fmt; 319 320 if (format_replace(ft, fmt, n, &buf, &len, &off) != 0) 321 break; 322 fmt += n + 1; 323 continue; 324 case '#': 325 while (len - off < 2) { 326 buf = xrealloc(buf, 2, len); 327 len *= 2; 328 } 329 buf[off++] = '#'; 330 continue; 331 default: 332 s = NULL; 333 if (ch >= 'A' && ch <= 'Z') 334 s = format_upper[ch - 'A']; 335 else if (ch >= 'a' && ch <= 'z') 336 s = format_lower[ch - 'a']; 337 if (s == NULL) { 338 while (len - off < 3) { 339 buf = xrealloc(buf, 2, len); 340 len *= 2; 341 } 342 buf[off++] = '#'; 343 buf[off++] = ch; 344 continue; 345 } 346 n = strlen(s); 347 if (format_replace(ft, s, n, &buf, &len, &off) != 0) 348 break; 349 continue; 350 } 351 352 break; 353 } 354 buf[off] = '\0'; 355 356 return (buf); 357 } 358 359 /* Get command name for format. */ 360 char * 361 format_get_command(struct window_pane *wp) 362 { 363 char *cmd, *out; 364 365 cmd = get_proc_name(wp->fd, wp->tty); 366 if (cmd == NULL || *cmd == '\0') { 367 free(cmd); 368 cmd = xstrdup(wp->cmd); 369 if (cmd == NULL || *cmd == '\0') { 370 free(cmd); 371 cmd = xstrdup(wp->shell); 372 } 373 } 374 out = parse_window_name(cmd); 375 free(cmd); 376 return (out); 377 } 378 379 /* Set default format keys for a session. */ 380 void 381 format_session(struct format_tree *ft, struct session *s) 382 { 383 struct session_group *sg; 384 char *tim; 385 time_t t; 386 387 format_add(ft, "session_name", "%s", s->name); 388 format_add(ft, "session_windows", "%u", winlink_count(&s->windows)); 389 format_add(ft, "session_width", "%u", s->sx); 390 format_add(ft, "session_height", "%u", s->sy); 391 format_add(ft, "session_id", "$%u", s->id); 392 393 sg = session_group_find(s); 394 format_add(ft, "session_grouped", "%d", sg != NULL); 395 if (sg != NULL) 396 format_add(ft, "session_group", "%u", session_group_index(sg)); 397 398 t = s->creation_time.tv_sec; 399 format_add(ft, "session_created", "%lld", (long long) t); 400 tim = ctime(&t); 401 *strchr(tim, '\n') = '\0'; 402 format_add(ft, "session_created_string", "%s", tim); 403 404 if (s->flags & SESSION_UNATTACHED) 405 format_add(ft, "session_attached", "%d", 0); 406 else 407 format_add(ft, "session_attached", "%d", 1); 408 } 409 410 /* Set default format keys for a client. */ 411 void 412 format_client(struct format_tree *ft, struct client *c) 413 { 414 char *tim; 415 time_t t; 416 struct session *s; 417 418 format_add(ft, "client_height", "%u", c->tty.sy); 419 format_add(ft, "client_width", "%u", c->tty.sx); 420 if (c->tty.path != NULL) 421 format_add(ft, "client_tty", "%s", c->tty.path); 422 if (c->tty.termname != NULL) 423 format_add(ft, "client_termname", "%s", c->tty.termname); 424 425 t = c->creation_time.tv_sec; 426 format_add(ft, "client_created", "%lld", (long long) t); 427 tim = ctime(&t); 428 *strchr(tim, '\n') = '\0'; 429 format_add(ft, "client_created_string", "%s", tim); 430 431 t = c->activity_time.tv_sec; 432 format_add(ft, "client_activity", "%lld", (long long) t); 433 tim = ctime(&t); 434 *strchr(tim, '\n') = '\0'; 435 format_add(ft, "client_activity_string", "%s", tim); 436 437 format_add(ft, "client_prefix", "%d", !!(c->flags & CLIENT_PREFIX)); 438 439 if (c->tty.flags & TTY_UTF8) 440 format_add(ft, "client_utf8", "%d", 1); 441 else 442 format_add(ft, "client_utf8", "%d", 0); 443 444 if (c->flags & CLIENT_READONLY) 445 format_add(ft, "client_readonly", "%d", 1); 446 else 447 format_add(ft, "client_readonly", "%d", 0); 448 449 s = c->session; 450 if (s != NULL) 451 format_add(ft, "client_session", "%s", s->name); 452 s = c->last_session; 453 if (s != NULL && session_alive(s)) 454 format_add(ft, "client_last_session", "%s", s->name); 455 } 456 457 /* Set default format keys for a window. */ 458 void 459 format_window(struct format_tree *ft, struct window *w) 460 { 461 char *layout; 462 463 layout = layout_dump(w); 464 465 format_add(ft, "window_id", "@%u", w->id); 466 format_add(ft, "window_name", "%s", w->name); 467 format_add(ft, "window_width", "%u", w->sx); 468 format_add(ft, "window_height", "%u", w->sy); 469 format_add(ft, "window_layout", "%s", layout); 470 format_add(ft, "window_panes", "%u", window_count_panes(w)); 471 472 free(layout); 473 } 474 475 /* Set default format keys for a winlink. */ 476 void 477 format_winlink(struct format_tree *ft, struct session *s, struct winlink *wl) 478 { 479 struct window *w = wl->window; 480 char *flags; 481 482 flags = window_printable_flags(s, wl); 483 484 format_window(ft, w); 485 486 format_add(ft, "window_index", "%d", wl->idx); 487 format_add(ft, "window_flags", "%s", flags); 488 format_add(ft, "window_active", "%d", wl == s->curw); 489 490 format_add(ft, "window_bell_flag", "%u", 491 !!(wl->flags & WINLINK_BELL)); 492 format_add(ft, "window_content_flag", "%u", 493 !!(wl->flags & WINLINK_CONTENT)); 494 format_add(ft, "window_activity_flag", "%u", 495 !!(wl->flags & WINLINK_ACTIVITY)); 496 format_add(ft, "window_silence_flag", "%u", 497 !!(wl->flags & WINLINK_SILENCE)); 498 499 500 free(flags); 501 } 502 503 /* Add window pane tabs. */ 504 void 505 format_window_pane_tabs(struct format_tree *ft, struct window_pane *wp) 506 { 507 struct evbuffer *buffer; 508 u_int i; 509 510 buffer = evbuffer_new(); 511 for (i = 0; i < wp->base.grid->sx; i++) { 512 if (!bit_test(wp->base.tabs, i)) 513 continue; 514 515 if (EVBUFFER_LENGTH(buffer) > 0) 516 evbuffer_add(buffer, ",", 1); 517 evbuffer_add_printf(buffer, "%d", i); 518 } 519 520 format_add(ft, "pane_tabs", "%.*s", (int) EVBUFFER_LENGTH(buffer), 521 EVBUFFER_DATA(buffer)); 522 evbuffer_free(buffer); 523 } 524 525 /* Set default format keys for a window pane. */ 526 void 527 format_window_pane(struct format_tree *ft, struct window_pane *wp) 528 { 529 struct grid *gd = wp->base.grid; 530 struct grid_line *gl; 531 unsigned long long size; 532 u_int i, idx; 533 char *cmd; 534 535 size = 0; 536 for (i = 0; i < gd->hsize; i++) { 537 gl = &gd->linedata[i]; 538 size += gl->cellsize * sizeof *gl->celldata; 539 } 540 size += gd->hsize * sizeof *gd->linedata; 541 format_add(ft, "history_size", "%u", gd->hsize); 542 format_add(ft, "history_limit", "%u", gd->hlimit); 543 format_add(ft, "history_bytes", "%llu", size); 544 545 if (window_pane_index(wp, &idx) != 0) 546 fatalx("index not found"); 547 format_add(ft, "pane_index", "%u", idx); 548 549 format_add(ft, "pane_width", "%u", wp->sx); 550 format_add(ft, "pane_height", "%u", wp->sy); 551 format_add(ft, "pane_title", "%s", wp->base.title); 552 format_add(ft, "pane_id", "%%%u", wp->id); 553 format_add(ft, "pane_active", "%d", wp == wp->window->active); 554 format_add(ft, "pane_dead", "%d", wp->fd == -1); 555 556 format_add(ft, "pane_in_mode", "%d", wp->screen != &wp->base); 557 format_add(ft, "pane_synchronized", "%d", 558 !!options_get_number(&wp->window->options, "synchronize-panes")); 559 560 if (wp->tty != NULL) 561 format_add(ft, "pane_tty", "%s", wp->tty); 562 format_add(ft, "pane_pid", "%ld", (long) wp->pid); 563 if (wp->cmd != NULL) 564 format_add(ft, "pane_start_command", "%s", wp->cmd); 565 if ((cmd = format_get_command(wp)) != NULL) { 566 format_add(ft, "pane_current_command", "%s", cmd); 567 free(cmd); 568 } 569 570 format_add(ft, "cursor_x", "%d", wp->base.cx); 571 format_add(ft, "cursor_y", "%d", wp->base.cy); 572 format_add(ft, "scroll_region_upper", "%d", wp->base.rupper); 573 format_add(ft, "scroll_region_lower", "%d", wp->base.rlower); 574 format_add(ft, "saved_cursor_x", "%d", wp->ictx.old_cx); 575 format_add(ft, "saved_cursor_y", "%d", wp->ictx.old_cy); 576 577 format_add(ft, "alternate_on", "%d", wp->saved_grid ? 1 : 0); 578 format_add(ft, "alternate_saved_x", "%d", wp->saved_cx); 579 format_add(ft, "alternate_saved_y", "%d", wp->saved_cy); 580 581 format_add(ft, "cursor_flag", "%d", 582 !!(wp->base.mode & MODE_CURSOR)); 583 format_add(ft, "insert_flag", "%d", 584 !!(wp->base.mode & MODE_INSERT)); 585 format_add(ft, "keypad_cursor_flag", "%d", 586 !!(wp->base.mode & MODE_KCURSOR)); 587 format_add(ft, "keypad_flag", "%d", 588 !!(wp->base.mode & MODE_KKEYPAD)); 589 format_add(ft, "wrap_flag", "%d", 590 !!(wp->base.mode & MODE_WRAP)); 591 592 format_add(ft, "mouse_standard_flag", "%d", 593 !!(wp->base.mode & MODE_MOUSE_STANDARD)); 594 format_add(ft, "mouse_button_flag", "%d", 595 !!(wp->base.mode & MODE_MOUSE_BUTTON)); 596 format_add(ft, "mouse_any_flag", "%d", 597 !!(wp->base.mode & MODE_MOUSE_ANY)); 598 format_add(ft, "mouse_utf8_flag", "%d", 599 !!(wp->base.mode & MODE_MOUSE_UTF8)); 600 601 format_window_pane_tabs(ft, wp); 602 } 603 604 /* Set default format keys for paste buffer. */ 605 void 606 format_paste_buffer(struct format_tree *ft, struct paste_buffer *pb) 607 { 608 char *pb_print = paste_print(pb, 50); 609 610 format_add(ft, "buffer_size", "%zu", pb->size); 611 format_add(ft, "buffer_sample", "%s", pb_print); 612 613 free(pb_print); 614 } 615