1 /* $OpenBSD: format.c,v 1.122 2017/02/09 15:04:53 nicm Exp $ */ 2 3 /* 4 * Copyright (c) 2011 Nicholas Marriott <nicholas.marriott@gmail.com> 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 #include <sys/wait.h> 21 22 #include <ctype.h> 23 #include <errno.h> 24 #include <libgen.h> 25 #include <netdb.h> 26 #include <stdarg.h> 27 #include <stdlib.h> 28 #include <string.h> 29 #include <time.h> 30 #include <unistd.h> 31 32 #include "tmux.h" 33 34 /* 35 * Build a list of key-value pairs and use them to expand #{key} entries in a 36 * string. 37 */ 38 39 struct format_entry; 40 typedef void (*format_cb)(struct format_tree *, struct format_entry *); 41 42 static void format_job_callback(struct job *); 43 static char *format_job_get(struct format_tree *, const char *); 44 static void format_job_timer(int, short, void *); 45 46 static void format_cb_host(struct format_tree *, struct format_entry *); 47 static void format_cb_host_short(struct format_tree *, 48 struct format_entry *); 49 static void format_cb_pid(struct format_tree *, struct format_entry *); 50 static void format_cb_session_alerts(struct format_tree *, 51 struct format_entry *); 52 static void format_cb_window_layout(struct format_tree *, 53 struct format_entry *); 54 static void format_cb_window_visible_layout(struct format_tree *, 55 struct format_entry *); 56 static void format_cb_start_command(struct format_tree *, 57 struct format_entry *); 58 static void format_cb_current_command(struct format_tree *, 59 struct format_entry *); 60 static void format_cb_history_bytes(struct format_tree *, 61 struct format_entry *); 62 static void format_cb_pane_tabs(struct format_tree *, 63 struct format_entry *); 64 65 static char *format_find(struct format_tree *, const char *, int); 66 static void format_add_cb(struct format_tree *, const char *, format_cb); 67 static void format_add_tv(struct format_tree *, const char *, 68 struct timeval *); 69 static int format_replace(struct format_tree *, const char *, size_t, 70 char **, size_t *, size_t *); 71 72 static void format_defaults_session(struct format_tree *, 73 struct session *); 74 static void format_defaults_client(struct format_tree *, struct client *); 75 static void format_defaults_winlink(struct format_tree *, struct session *, 76 struct winlink *); 77 78 /* Entry in format job tree. */ 79 struct format_job { 80 u_int tag; 81 const char *cmd; 82 const char *expanded; 83 84 time_t last; 85 char *out; 86 87 struct job *job; 88 int status; 89 90 RB_ENTRY(format_job) entry; 91 }; 92 93 /* Format job tree. */ 94 static struct event format_job_event; 95 static int format_job_cmp(struct format_job *, struct format_job *); 96 static RB_HEAD(format_job_tree, format_job) format_jobs = RB_INITIALIZER(); 97 RB_GENERATE_STATIC(format_job_tree, format_job, entry, format_job_cmp); 98 99 /* Format job tree comparison function. */ 100 static int 101 format_job_cmp(struct format_job *fj1, struct format_job *fj2) 102 { 103 if (fj1->tag < fj2->tag) 104 return (-1); 105 if (fj1->tag > fj2->tag) 106 return (1); 107 return (strcmp(fj1->cmd, fj2->cmd)); 108 } 109 110 /* Format modifiers. */ 111 #define FORMAT_TIMESTRING 0x1 112 #define FORMAT_BASENAME 0x2 113 #define FORMAT_DIRNAME 0x4 114 #define FORMAT_SUBSTITUTE 0x8 115 116 /* Entry in format tree. */ 117 struct format_entry { 118 char *key; 119 char *value; 120 time_t t; 121 format_cb cb; 122 RB_ENTRY(format_entry) entry; 123 }; 124 125 /* Format entry tree. */ 126 struct format_tree { 127 struct window *w; 128 struct session *s; 129 struct window_pane *wp; 130 131 u_int tag; 132 int flags; 133 134 RB_HEAD(format_entry_tree, format_entry) tree; 135 }; 136 static int format_entry_cmp(struct format_entry *, struct format_entry *); 137 RB_GENERATE_STATIC(format_entry_tree, format_entry, entry, format_entry_cmp); 138 139 /* Format entry tree comparison function. */ 140 static int 141 format_entry_cmp(struct format_entry *fe1, struct format_entry *fe2) 142 { 143 return (strcmp(fe1->key, fe2->key)); 144 } 145 146 /* Single-character uppercase aliases. */ 147 static const char *format_upper[] = { 148 NULL, /* A */ 149 NULL, /* B */ 150 NULL, /* C */ 151 "pane_id", /* D */ 152 NULL, /* E */ 153 "window_flags", /* F */ 154 NULL, /* G */ 155 "host", /* H */ 156 "window_index", /* I */ 157 NULL, /* J */ 158 NULL, /* K */ 159 NULL, /* L */ 160 NULL, /* M */ 161 NULL, /* N */ 162 NULL, /* O */ 163 "pane_index", /* P */ 164 NULL, /* Q */ 165 NULL, /* R */ 166 "session_name", /* S */ 167 "pane_title", /* T */ 168 NULL, /* U */ 169 NULL, /* V */ 170 "window_name", /* W */ 171 NULL, /* X */ 172 NULL, /* Y */ 173 NULL /* Z */ 174 }; 175 176 /* Single-character lowercase aliases. */ 177 static const char *format_lower[] = { 178 NULL, /* a */ 179 NULL, /* b */ 180 NULL, /* c */ 181 NULL, /* d */ 182 NULL, /* e */ 183 NULL, /* f */ 184 NULL, /* g */ 185 "host_short", /* h */ 186 NULL, /* i */ 187 NULL, /* j */ 188 NULL, /* k */ 189 NULL, /* l */ 190 NULL, /* m */ 191 NULL, /* n */ 192 NULL, /* o */ 193 NULL, /* p */ 194 NULL, /* q */ 195 NULL, /* r */ 196 NULL, /* s */ 197 NULL, /* t */ 198 NULL, /* u */ 199 NULL, /* v */ 200 NULL, /* w */ 201 NULL, /* x */ 202 NULL, /* y */ 203 NULL /* z */ 204 }; 205 206 /* Format job callback. */ 207 static void 208 format_job_callback(struct job *job) 209 { 210 struct format_job *fj = job->data; 211 char *line, *buf; 212 size_t len; 213 struct client *c; 214 215 fj->job = NULL; 216 free(fj->out); 217 218 buf = NULL; 219 if ((line = evbuffer_readline(job->event->input)) == NULL) { 220 len = EVBUFFER_LENGTH(job->event->input); 221 buf = xmalloc(len + 1); 222 if (len != 0) 223 memcpy(buf, EVBUFFER_DATA(job->event->input), len); 224 buf[len] = '\0'; 225 } else 226 buf = line; 227 fj->out = buf; 228 229 if (fj->status) { 230 TAILQ_FOREACH(c, &clients, entry) 231 server_status_client(c); 232 fj->status = 0; 233 } 234 235 log_debug("%s: %s: %s", __func__, fj->cmd, fj->out); 236 } 237 238 /* Find a job. */ 239 static char * 240 format_job_get(struct format_tree *ft, const char *cmd) 241 { 242 struct format_job fj0, *fj; 243 time_t t; 244 char *expanded; 245 int force; 246 247 fj0.tag = ft->tag; 248 fj0.cmd = cmd; 249 if ((fj = RB_FIND(format_job_tree, &format_jobs, &fj0)) == NULL) { 250 fj = xcalloc(1, sizeof *fj); 251 fj->tag = ft->tag; 252 fj->cmd = xstrdup(cmd); 253 fj->expanded = NULL; 254 255 xasprintf(&fj->out, "<'%s' not ready>", fj->cmd); 256 257 RB_INSERT(format_job_tree, &format_jobs, fj); 258 } 259 260 expanded = format_expand(ft, cmd); 261 if (fj->expanded == NULL || strcmp(expanded, fj->expanded) != 0) { 262 free((void *)fj->expanded); 263 fj->expanded = xstrdup(expanded); 264 force = 1; 265 } else 266 force = (ft->flags & FORMAT_FORCE); 267 268 t = time(NULL); 269 if (fj->job == NULL && (force || fj->last != t)) { 270 fj->job = job_run(expanded, NULL, NULL, format_job_callback, 271 NULL, fj); 272 if (fj->job == NULL) { 273 free(fj->out); 274 xasprintf(&fj->out, "<'%s' didn't start>", fj->cmd); 275 } 276 fj->last = t; 277 } 278 279 if (ft->flags & FORMAT_STATUS) 280 fj->status = 1; 281 282 free(expanded); 283 return (format_expand(ft, fj->out)); 284 } 285 286 /* Remove old jobs. */ 287 static void 288 format_job_timer(__unused int fd, __unused short events, __unused void *arg) 289 { 290 struct format_job *fj, *fj1; 291 time_t now; 292 struct timeval tv = { .tv_sec = 60 }; 293 294 now = time(NULL); 295 RB_FOREACH_SAFE(fj, format_job_tree, &format_jobs, fj1) { 296 if (fj->last > now || now - fj->last < 3600) 297 continue; 298 RB_REMOVE(format_job_tree, &format_jobs, fj); 299 300 log_debug("%s: %s", __func__, fj->cmd); 301 302 if (fj->job != NULL) 303 job_free(fj->job); 304 305 free((void *)fj->expanded); 306 free((void *)fj->cmd); 307 free(fj->out); 308 309 free(fj); 310 } 311 312 evtimer_del(&format_job_event); 313 evtimer_add(&format_job_event, &tv); 314 } 315 316 /* Callback for host. */ 317 static void 318 format_cb_host(__unused struct format_tree *ft, struct format_entry *fe) 319 { 320 char host[HOST_NAME_MAX + 1]; 321 322 if (gethostname(host, sizeof host) != 0) 323 fe->value = xstrdup(""); 324 else 325 fe->value = xstrdup(host); 326 } 327 328 /* Callback for host_short. */ 329 static void 330 format_cb_host_short(__unused struct format_tree *ft, struct format_entry *fe) 331 { 332 char host[HOST_NAME_MAX + 1], *cp; 333 334 if (gethostname(host, sizeof host) != 0) 335 fe->value = xstrdup(""); 336 else { 337 if ((cp = strchr(host, '.')) != NULL) 338 *cp = '\0'; 339 fe->value = xstrdup(host); 340 } 341 } 342 343 /* Callback for pid. */ 344 static void 345 format_cb_pid(__unused struct format_tree *ft, struct format_entry *fe) 346 { 347 xasprintf(&fe->value, "%ld", (long)getpid()); 348 } 349 350 /* Callback for session_alerts. */ 351 static void 352 format_cb_session_alerts(struct format_tree *ft, struct format_entry *fe) 353 { 354 struct session *s = ft->s; 355 struct winlink *wl; 356 char alerts[256], tmp[16]; 357 358 if (s == NULL) 359 return; 360 361 *alerts = '\0'; 362 RB_FOREACH(wl, winlinks, &s->windows) { 363 if ((wl->flags & WINLINK_ALERTFLAGS) == 0) 364 continue; 365 xsnprintf(tmp, sizeof tmp, "%u", wl->idx); 366 367 if (*alerts != '\0') 368 strlcat(alerts, ",", sizeof alerts); 369 strlcat(alerts, tmp, sizeof alerts); 370 if (wl->flags & WINLINK_ACTIVITY) 371 strlcat(alerts, "#", sizeof alerts); 372 if (wl->flags & WINLINK_BELL) 373 strlcat(alerts, "!", sizeof alerts); 374 if (wl->flags & WINLINK_SILENCE) 375 strlcat(alerts, "~", sizeof alerts); 376 } 377 fe->value = xstrdup(alerts); 378 } 379 380 /* Callback for window_layout. */ 381 static void 382 format_cb_window_layout(struct format_tree *ft, struct format_entry *fe) 383 { 384 struct window *w = ft->w; 385 386 if (w == NULL) 387 return; 388 389 if (w->saved_layout_root != NULL) 390 fe->value = layout_dump(w->saved_layout_root); 391 else 392 fe->value = layout_dump(w->layout_root); 393 } 394 395 /* Callback for window_visible_layout. */ 396 static void 397 format_cb_window_visible_layout(struct format_tree *ft, struct format_entry *fe) 398 { 399 struct window *w = ft->w; 400 401 if (w == NULL) 402 return; 403 404 fe->value = layout_dump(w->layout_root); 405 } 406 407 /* Callback for pane_start_command. */ 408 static void 409 format_cb_start_command(struct format_tree *ft, struct format_entry *fe) 410 { 411 struct window_pane *wp = ft->wp; 412 413 if (wp == NULL) 414 return; 415 416 fe->value = cmd_stringify_argv(wp->argc, wp->argv); 417 } 418 419 /* Callback for pane_current_command. */ 420 static void 421 format_cb_current_command(struct format_tree *ft, struct format_entry *fe) 422 { 423 struct window_pane *wp = ft->wp; 424 char *cmd; 425 426 if (wp == NULL) 427 return; 428 429 cmd = get_proc_name(wp->fd, wp->tty); 430 if (cmd == NULL || *cmd == '\0') { 431 free(cmd); 432 cmd = cmd_stringify_argv(wp->argc, wp->argv); 433 if (cmd == NULL || *cmd == '\0') { 434 free(cmd); 435 cmd = xstrdup(wp->shell); 436 } 437 } 438 fe->value = parse_window_name(cmd); 439 free(cmd); 440 } 441 442 /* Callback for history_bytes. */ 443 static void 444 format_cb_history_bytes(struct format_tree *ft, struct format_entry *fe) 445 { 446 struct window_pane *wp = ft->wp; 447 struct grid *gd; 448 struct grid_line *gl; 449 unsigned long long size; 450 u_int i; 451 452 if (wp == NULL) 453 return; 454 gd = wp->base.grid; 455 456 size = 0; 457 for (i = 0; i < gd->hsize; i++) { 458 gl = &gd->linedata[i]; 459 size += gl->cellsize * sizeof *gl->celldata; 460 size += gl->extdsize * sizeof *gl->extddata; 461 } 462 size += gd->hsize * sizeof *gd->linedata; 463 464 xasprintf(&fe->value, "%llu", size); 465 } 466 467 /* Callback for pane_tabs. */ 468 static void 469 format_cb_pane_tabs(struct format_tree *ft, struct format_entry *fe) 470 { 471 struct window_pane *wp = ft->wp; 472 struct evbuffer *buffer; 473 u_int i; 474 int size; 475 476 if (wp == NULL) 477 return; 478 479 buffer = evbuffer_new(); 480 for (i = 0; i < wp->base.grid->sx; i++) { 481 if (!bit_test(wp->base.tabs, i)) 482 continue; 483 484 if (EVBUFFER_LENGTH(buffer) > 0) 485 evbuffer_add(buffer, ",", 1); 486 evbuffer_add_printf(buffer, "%u", i); 487 } 488 size = EVBUFFER_LENGTH(buffer); 489 xasprintf(&fe->value, "%.*s", size, EVBUFFER_DATA(buffer)); 490 evbuffer_free(buffer); 491 } 492 493 /* Merge a format tree. */ 494 static void 495 format_merge(struct format_tree *ft, struct format_tree *from) 496 { 497 struct format_entry *fe; 498 499 RB_FOREACH(fe, format_entry_tree, &from->tree) { 500 if (fe->value != NULL) 501 format_add(ft, fe->key, "%s", fe->value); 502 } 503 504 } 505 506 /* Create a new tree. */ 507 struct format_tree * 508 format_create(struct cmdq_item *item, int tag, int flags) 509 { 510 struct format_tree *ft; 511 512 if (!event_initialized(&format_job_event)) { 513 evtimer_set(&format_job_event, format_job_timer, NULL); 514 format_job_timer(-1, 0, NULL); 515 } 516 517 ft = xcalloc(1, sizeof *ft); 518 RB_INIT(&ft->tree); 519 520 ft->tag = tag; 521 ft->flags = flags; 522 523 format_add_cb(ft, "host", format_cb_host); 524 format_add_cb(ft, "host_short", format_cb_host_short); 525 format_add_cb(ft, "pid", format_cb_pid); 526 format_add(ft, "socket_path", "%s", socket_path); 527 format_add_tv(ft, "start_time", &start_time); 528 529 if (item != NULL && item->cmd != NULL) 530 format_add(ft, "command", "%s", item->cmd->entry->name); 531 if (item != NULL && item->formats != NULL) 532 format_merge(ft, item->formats); 533 534 return (ft); 535 } 536 537 /* Free a tree. */ 538 void 539 format_free(struct format_tree *ft) 540 { 541 struct format_entry *fe, *fe1; 542 543 RB_FOREACH_SAFE(fe, format_entry_tree, &ft->tree, fe1) { 544 RB_REMOVE(format_entry_tree, &ft->tree, fe); 545 free(fe->value); 546 free(fe->key); 547 free(fe); 548 } 549 550 free(ft); 551 } 552 553 /* Add a key-value pair. */ 554 void 555 format_add(struct format_tree *ft, const char *key, const char *fmt, ...) 556 { 557 struct format_entry *fe; 558 struct format_entry *fe_now; 559 va_list ap; 560 561 fe = xmalloc(sizeof *fe); 562 fe->key = xstrdup(key); 563 564 fe_now = RB_INSERT(format_entry_tree, &ft->tree, fe); 565 if (fe_now != NULL) { 566 free(fe->key); 567 free(fe); 568 free(fe_now->value); 569 fe = fe_now; 570 } 571 572 fe->cb = NULL; 573 fe->t = 0; 574 575 va_start(ap, fmt); 576 xvasprintf(&fe->value, fmt, ap); 577 va_end(ap); 578 } 579 580 /* Add a key and time. */ 581 static void 582 format_add_tv(struct format_tree *ft, const char *key, struct timeval *tv) 583 { 584 struct format_entry *fe; 585 struct format_entry *fe_now; 586 587 fe = xmalloc(sizeof *fe); 588 fe->key = xstrdup(key); 589 590 fe_now = RB_INSERT(format_entry_tree, &ft->tree, fe); 591 if (fe_now != NULL) { 592 free(fe->key); 593 free(fe); 594 free(fe_now->value); 595 fe = fe_now; 596 } 597 598 fe->cb = NULL; 599 fe->t = tv->tv_sec; 600 601 fe->value = NULL; 602 } 603 604 /* Add a key and function. */ 605 static void 606 format_add_cb(struct format_tree *ft, const char *key, format_cb cb) 607 { 608 struct format_entry *fe; 609 struct format_entry *fe_now; 610 611 fe = xmalloc(sizeof *fe); 612 fe->key = xstrdup(key); 613 614 fe_now = RB_INSERT(format_entry_tree, &ft->tree, fe); 615 if (fe_now != NULL) { 616 free(fe->key); 617 free(fe); 618 free(fe_now->value); 619 fe = fe_now; 620 } 621 622 fe->cb = cb; 623 fe->t = 0; 624 625 fe->value = NULL; 626 } 627 628 /* Find a format entry. */ 629 static char * 630 format_find(struct format_tree *ft, const char *key, int modifiers) 631 { 632 struct format_entry *fe, fe_find; 633 struct environ_entry *envent; 634 static char s[64]; 635 struct options_entry *o; 636 const char *found; 637 int idx; 638 char *copy, *saved; 639 640 if (~modifiers & FORMAT_TIMESTRING) { 641 o = options_parse_get(global_options, key, &idx, 0); 642 if (o == NULL && ft->w != NULL) 643 o = options_parse_get(ft->w->options, key, &idx, 0); 644 if (o == NULL) 645 o = options_parse_get(global_w_options, key, &idx, 0); 646 if (o == NULL && ft->s != NULL) 647 o = options_parse_get(ft->s->options, key, &idx, 0); 648 if (o == NULL) 649 o = options_parse_get(global_s_options, key, &idx, 0); 650 if (o != NULL) { 651 found = options_tostring(o, idx, 1); 652 goto found; 653 } 654 } 655 found = NULL; 656 657 fe_find.key = (char *) key; 658 fe = RB_FIND(format_entry_tree, &ft->tree, &fe_find); 659 if (fe != NULL) { 660 if (modifiers & FORMAT_TIMESTRING) { 661 if (fe->t == 0) 662 return (NULL); 663 ctime_r(&fe->t, s); 664 s[strcspn(s, "\n")] = '\0'; 665 found = s; 666 goto found; 667 } 668 if (fe->t != 0) { 669 xsnprintf(s, sizeof s, "%lld", (long long)fe->t); 670 found = s; 671 goto found; 672 } 673 if (fe->value == NULL && fe->cb != NULL) 674 fe->cb(ft, fe); 675 found = fe->value; 676 goto found; 677 } 678 679 if (~modifiers & FORMAT_TIMESTRING) { 680 envent = NULL; 681 if (ft->s != NULL) 682 envent = environ_find(ft->s->environ, key); 683 if (envent == NULL) 684 envent = environ_find(global_environ, key); 685 if (envent != NULL) { 686 found = envent->value; 687 goto found; 688 } 689 } 690 691 return (NULL); 692 693 found: 694 if (found == NULL) 695 return (NULL); 696 copy = xstrdup(found); 697 if (modifiers & FORMAT_BASENAME) { 698 saved = copy; 699 copy = xstrdup(basename(saved)); 700 free(saved); 701 } 702 if (modifiers & FORMAT_DIRNAME) { 703 saved = copy; 704 copy = xstrdup(dirname(saved)); 705 free(saved); 706 } 707 return (copy); 708 } 709 710 /* Skip until comma. */ 711 static char * 712 format_skip(char *s) 713 { 714 int brackets = 0; 715 716 for (; *s != '\0'; s++) { 717 if (*s == '{') 718 brackets++; 719 if (*s == '}') 720 brackets--; 721 if (*s == ',' && brackets == 0) 722 break; 723 } 724 if (*s == '\0') 725 return (NULL); 726 return (s); 727 } 728 729 /* Return left and right alternatives separated by commas. */ 730 static int 731 format_choose(char *s, char **left, char **right) 732 { 733 char *cp; 734 735 cp = format_skip(s); 736 if (cp == NULL) 737 return (-1); 738 *cp = '\0'; 739 740 *left = s; 741 *right = cp + 1; 742 return (0); 743 } 744 745 /* Is this true? */ 746 static int 747 format_true(const char *s) 748 { 749 if (s != NULL && *s != '\0' && (s[0] != '0' || s[1] != '\0')) 750 return (1); 751 return (0); 752 } 753 754 /* 755 * Replace a key/value pair in buffer. #{blah} is expanded directly, 756 * #{?blah,a,b} is replace with a if blah exists and is nonzero else b. 757 */ 758 static int 759 format_replace(struct format_tree *ft, const char *key, size_t keylen, 760 char **buf, size_t *len, size_t *off) 761 { 762 char *copy, *copy0, *endptr, *ptr, *found, *new, *value; 763 char *from = NULL, *to = NULL, *left, *right; 764 size_t valuelen, newlen, fromlen, tolen, used; 765 long limit = 0; 766 int modifiers = 0, compare = 0; 767 768 /* Make a copy of the key. */ 769 copy0 = copy = xmalloc(keylen + 1); 770 memcpy(copy, key, keylen); 771 copy[keylen] = '\0'; 772 773 /* Is there a length limit or whatnot? */ 774 switch (copy[0]) { 775 case '!': 776 if (copy[1] == '=' && copy[2] == ':') { 777 compare = -1; 778 copy += 3; 779 break; 780 } 781 break; 782 case '=': 783 if (copy[1] == '=' && copy[2] == ':') { 784 compare = 1; 785 copy += 3; 786 break; 787 } 788 errno = 0; 789 limit = strtol(copy + 1, &endptr, 10); 790 if (errno == ERANGE && (limit == LONG_MIN || limit == LONG_MAX)) 791 break; 792 if (*endptr != ':') 793 break; 794 copy = endptr + 1; 795 break; 796 case 'b': 797 if (copy[1] != ':') 798 break; 799 modifiers |= FORMAT_BASENAME; 800 copy += 2; 801 break; 802 case 'd': 803 if (copy[1] != ':') 804 break; 805 modifiers |= FORMAT_DIRNAME; 806 copy += 2; 807 break; 808 case 't': 809 if (copy[1] != ':') 810 break; 811 modifiers |= FORMAT_TIMESTRING; 812 copy += 2; 813 break; 814 case 's': 815 if (copy[1] != '/') 816 break; 817 from = copy + 2; 818 for (copy = from; *copy != '\0' && *copy != '/'; copy++) 819 /* nothing */; 820 if (copy[0] != '/' || copy == from) { 821 copy = copy0; 822 break; 823 } 824 copy[0] = '\0'; 825 to = copy + 1; 826 for (copy = to; *copy != '\0' && *copy != '/'; copy++) 827 /* nothing */; 828 if (copy[0] != '/' || copy[1] != ':') { 829 copy = copy0; 830 break; 831 } 832 copy[0] = '\0'; 833 834 modifiers |= FORMAT_SUBSTITUTE; 835 copy += 2; 836 break; 837 } 838 839 /* Is this a comparison or a conditional? */ 840 if (compare != 0) { 841 /* Comparison: compare comma-separated left and right. */ 842 if (format_choose(copy, &left, &right) != 0) 843 goto fail; 844 left = format_expand(ft, left); 845 right = format_expand(ft, right); 846 if (compare == 1 && strcmp(left, right) == 0) 847 value = xstrdup("1"); 848 else if (compare == -1 && strcmp(left, right) != 0) 849 value = xstrdup("1"); 850 else 851 value = xstrdup("0"); 852 free(right); 853 free(left); 854 } else if (*copy == '?') { 855 /* Conditional: check first and choose second or third. */ 856 ptr = format_skip(copy); 857 if (ptr == NULL) 858 goto fail; 859 *ptr = '\0'; 860 861 found = format_find(ft, copy + 1, modifiers); 862 if (found == NULL) 863 found = format_expand(ft, copy + 1); 864 if (format_choose(ptr + 1, &left, &right) != 0) 865 goto fail; 866 867 if (format_true(found)) 868 value = format_expand(ft, left); 869 else 870 value = format_expand(ft, right); 871 free(found); 872 } else { 873 /* Neither: look up directly. */ 874 value = format_find(ft, copy, modifiers); 875 if (value == NULL) 876 value = xstrdup(""); 877 } 878 879 /* Perform substitution if any. */ 880 if (modifiers & FORMAT_SUBSTITUTE) { 881 fromlen = strlen(from); 882 tolen = strlen(to); 883 884 newlen = strlen(value) + 1; 885 copy = new = xmalloc(newlen); 886 for (ptr = value; *ptr != '\0'; /* nothing */) { 887 if (strncmp(ptr, from, fromlen) != 0) { 888 *new++ = *ptr++; 889 continue; 890 } 891 used = new - copy; 892 893 newlen += tolen; 894 copy = xrealloc(copy, newlen); 895 896 new = copy + used; 897 memcpy(new, to, tolen); 898 899 new += tolen; 900 ptr += fromlen; 901 } 902 *new = '\0'; 903 free(value); 904 value = copy; 905 } 906 907 /* Truncate the value if needed. */ 908 if (limit > 0) { 909 new = utf8_trimcstr(value, limit); 910 free(value); 911 value = new; 912 } else if (limit < 0) { 913 new = utf8_rtrimcstr(value, -limit); 914 free(value); 915 value = new; 916 } 917 918 /* Expand the buffer and copy in the value. */ 919 valuelen = strlen(value); 920 while (*len - *off < valuelen + 1) { 921 *buf = xreallocarray(*buf, 2, *len); 922 *len *= 2; 923 } 924 memcpy(*buf + *off, value, valuelen); 925 *off += valuelen; 926 927 free(value); 928 free(copy0); 929 return (0); 930 931 fail: 932 free(copy0); 933 return (-1); 934 } 935 936 /* Expand keys in a template, passing through strftime first. */ 937 char * 938 format_expand_time(struct format_tree *ft, const char *fmt, time_t t) 939 { 940 struct tm *tm; 941 char s[2048]; 942 943 if (fmt == NULL || *fmt == '\0') 944 return (xstrdup("")); 945 946 tm = localtime(&t); 947 948 if (strftime(s, sizeof s, fmt, tm) == 0) 949 return (xstrdup("")); 950 951 return (format_expand(ft, s)); 952 } 953 954 /* Expand keys in a template. */ 955 char * 956 format_expand(struct format_tree *ft, const char *fmt) 957 { 958 char *buf, *out; 959 const char *ptr, *s, *saved = fmt; 960 size_t off, len, n, outlen; 961 int ch, brackets; 962 963 if (fmt == NULL) 964 return (xstrdup("")); 965 966 len = 64; 967 buf = xmalloc(len); 968 off = 0; 969 970 while (*fmt != '\0') { 971 if (*fmt != '#') { 972 while (len - off < 2) { 973 buf = xreallocarray(buf, 2, len); 974 len *= 2; 975 } 976 buf[off++] = *fmt++; 977 continue; 978 } 979 fmt++; 980 981 ch = (u_char) *fmt++; 982 switch (ch) { 983 case '(': 984 brackets = 1; 985 for (ptr = fmt; *ptr != '\0'; ptr++) { 986 if (*ptr == '(') 987 brackets++; 988 if (*ptr == ')' && --brackets == 0) 989 break; 990 } 991 if (*ptr != ')' || brackets != 0) 992 break; 993 n = ptr - fmt; 994 995 if (ft->flags & FORMAT_NOJOBS) 996 out = xstrdup(""); 997 else 998 out = format_job_get(ft, xstrndup(fmt, n)); 999 outlen = strlen(out); 1000 1001 while (len - off < outlen + 1) { 1002 buf = xreallocarray(buf, 2, len); 1003 len *= 2; 1004 } 1005 memcpy(buf + off, out, outlen); 1006 off += outlen; 1007 1008 free(out); 1009 1010 fmt += n + 1; 1011 continue; 1012 case '{': 1013 brackets = 1; 1014 for (ptr = fmt; *ptr != '\0'; ptr++) { 1015 if (*ptr == '{') 1016 brackets++; 1017 if (*ptr == '}' && --brackets == 0) 1018 break; 1019 } 1020 if (*ptr != '}' || brackets != 0) 1021 break; 1022 n = ptr - fmt; 1023 1024 if (format_replace(ft, fmt, n, &buf, &len, &off) != 0) 1025 break; 1026 fmt += n + 1; 1027 continue; 1028 case '#': 1029 while (len - off < 2) { 1030 buf = xreallocarray(buf, 2, len); 1031 len *= 2; 1032 } 1033 buf[off++] = '#'; 1034 continue; 1035 default: 1036 s = NULL; 1037 if (ch >= 'A' && ch <= 'Z') 1038 s = format_upper[ch - 'A']; 1039 else if (ch >= 'a' && ch <= 'z') 1040 s = format_lower[ch - 'a']; 1041 if (s == NULL) { 1042 while (len - off < 3) { 1043 buf = xreallocarray(buf, 2, len); 1044 len *= 2; 1045 } 1046 buf[off++] = '#'; 1047 buf[off++] = ch; 1048 continue; 1049 } 1050 n = strlen(s); 1051 if (format_replace(ft, s, n, &buf, &len, &off) != 0) 1052 break; 1053 continue; 1054 } 1055 1056 break; 1057 } 1058 buf[off] = '\0'; 1059 1060 log_debug("format '%s' -> '%s'", saved, buf); 1061 return (buf); 1062 } 1063 1064 /* Set defaults for any of arguments that are not NULL. */ 1065 void 1066 format_defaults(struct format_tree *ft, struct client *c, struct session *s, 1067 struct winlink *wl, struct window_pane *wp) 1068 { 1069 if (s == NULL && c != NULL) 1070 s = c->session; 1071 if (wl == NULL && s != NULL) 1072 wl = s->curw; 1073 if (wp == NULL && wl != NULL) 1074 wp = wl->window->active; 1075 1076 if (c != NULL) 1077 format_defaults_client(ft, c); 1078 if (s != NULL) 1079 format_defaults_session(ft, s); 1080 if (s != NULL && wl != NULL) 1081 format_defaults_winlink(ft, s, wl); 1082 if (wp != NULL) 1083 format_defaults_pane(ft, wp); 1084 } 1085 1086 /* Set default format keys for a session. */ 1087 static void 1088 format_defaults_session(struct format_tree *ft, struct session *s) 1089 { 1090 struct session_group *sg; 1091 1092 ft->s = s; 1093 1094 format_add(ft, "session_name", "%s", s->name); 1095 format_add(ft, "session_windows", "%u", winlink_count(&s->windows)); 1096 format_add(ft, "session_width", "%u", s->sx); 1097 format_add(ft, "session_height", "%u", s->sy); 1098 format_add(ft, "session_id", "$%u", s->id); 1099 1100 sg = session_group_contains(s); 1101 format_add(ft, "session_grouped", "%d", sg != NULL); 1102 if (sg != NULL) 1103 format_add(ft, "session_group", "%s", sg->name); 1104 1105 format_add_tv(ft, "session_created", &s->creation_time); 1106 format_add_tv(ft, "session_last_attached", &s->last_attached_time); 1107 format_add_tv(ft, "session_activity", &s->activity_time); 1108 1109 format_add(ft, "session_attached", "%u", s->attached); 1110 format_add(ft, "session_many_attached", "%d", s->attached > 1); 1111 1112 format_add_cb(ft, "session_alerts", format_cb_session_alerts); 1113 } 1114 1115 /* Set default format keys for a client. */ 1116 static void 1117 format_defaults_client(struct format_tree *ft, struct client *c) 1118 { 1119 struct session *s; 1120 const char *name; 1121 struct tty *tty = &c->tty; 1122 const char *types[] = TTY_TYPES; 1123 1124 if (ft->s == NULL) 1125 ft->s = c->session; 1126 1127 format_add(ft, "client_pid", "%ld", (long) c->pid); 1128 format_add(ft, "client_height", "%u", tty->sy); 1129 format_add(ft, "client_width", "%u", tty->sx); 1130 if (tty->path != NULL) 1131 format_add(ft, "client_tty", "%s", tty->path); 1132 format_add(ft, "client_control_mode", "%d", 1133 !!(c->flags & CLIENT_CONTROL)); 1134 1135 if (tty->term_name != NULL) 1136 format_add(ft, "client_termname", "%s", tty->term_name); 1137 if (tty->term_name != NULL) 1138 format_add(ft, "client_termtype", "%s", types[tty->term_type]); 1139 1140 format_add_tv(ft, "client_created", &c->creation_time); 1141 format_add_tv(ft, "client_activity", &c->activity_time); 1142 1143 name = server_client_get_key_table(c); 1144 if (strcmp(c->keytable->name, name) == 0) 1145 format_add(ft, "client_prefix", "%d", 0); 1146 else 1147 format_add(ft, "client_prefix", "%d", 1); 1148 format_add(ft, "client_key_table", "%s", c->keytable->name); 1149 1150 if (tty->flags & TTY_UTF8) 1151 format_add(ft, "client_utf8", "%d", 1); 1152 else 1153 format_add(ft, "client_utf8", "%d", 0); 1154 1155 if (c->flags & CLIENT_READONLY) 1156 format_add(ft, "client_readonly", "%d", 1); 1157 else 1158 format_add(ft, "client_readonly", "%d", 0); 1159 1160 s = c->session; 1161 if (s != NULL) 1162 format_add(ft, "client_session", "%s", s->name); 1163 s = c->last_session; 1164 if (s != NULL && session_alive(s)) 1165 format_add(ft, "client_last_session", "%s", s->name); 1166 } 1167 1168 /* Set default format keys for a window. */ 1169 void 1170 format_defaults_window(struct format_tree *ft, struct window *w) 1171 { 1172 ft->w = w; 1173 1174 format_add_tv(ft, "window_activity", &w->activity_time); 1175 format_add(ft, "window_id", "@%u", w->id); 1176 format_add(ft, "window_name", "%s", w->name); 1177 format_add(ft, "window_width", "%u", w->sx); 1178 format_add(ft, "window_height", "%u", w->sy); 1179 format_add_cb(ft, "window_layout", format_cb_window_layout); 1180 format_add_cb(ft, "window_visible_layout", 1181 format_cb_window_visible_layout); 1182 format_add(ft, "window_panes", "%u", window_count_panes(w)); 1183 format_add(ft, "window_zoomed_flag", "%d", 1184 !!(w->flags & WINDOW_ZOOMED)); 1185 } 1186 1187 /* Set default format keys for a winlink. */ 1188 static void 1189 format_defaults_winlink(struct format_tree *ft, struct session *s, 1190 struct winlink *wl) 1191 { 1192 struct window *w = wl->window; 1193 char *flags; 1194 1195 if (ft->w == NULL) 1196 ft->w = wl->window; 1197 1198 flags = window_printable_flags(s, wl); 1199 1200 format_defaults_window(ft, w); 1201 1202 format_add(ft, "window_index", "%d", wl->idx); 1203 format_add(ft, "window_flags", "%s", flags); 1204 format_add(ft, "window_active", "%d", wl == s->curw); 1205 1206 format_add(ft, "window_bell_flag", "%d", 1207 !!(wl->flags & WINLINK_BELL)); 1208 format_add(ft, "window_activity_flag", "%d", 1209 !!(wl->flags & WINLINK_ACTIVITY)); 1210 format_add(ft, "window_silence_flag", "%d", 1211 !!(wl->flags & WINLINK_SILENCE)); 1212 format_add(ft, "window_last_flag", "%d", 1213 !!(wl == TAILQ_FIRST(&s->lastw))); 1214 format_add(ft, "window_linked", "%d", session_is_linked(s, wl->window)); 1215 1216 free(flags); 1217 } 1218 1219 /* Set default format keys for a window pane. */ 1220 void 1221 format_defaults_pane(struct format_tree *ft, struct window_pane *wp) 1222 { 1223 struct grid *gd = wp->base.grid; 1224 u_int idx; 1225 int status, scroll_position; 1226 1227 if (ft->w == NULL) 1228 ft->w = wp->window; 1229 ft->wp = wp; 1230 1231 format_add(ft, "history_size", "%u", gd->hsize); 1232 format_add(ft, "history_limit", "%u", gd->hlimit); 1233 format_add_cb(ft, "history_bytes", format_cb_history_bytes); 1234 1235 if (window_pane_index(wp, &idx) != 0) 1236 fatalx("index not found"); 1237 format_add(ft, "pane_index", "%u", idx); 1238 1239 format_add(ft, "pane_width", "%u", wp->sx); 1240 format_add(ft, "pane_height", "%u", wp->sy); 1241 format_add(ft, "pane_title", "%s", wp->base.title); 1242 format_add(ft, "pane_id", "%%%u", wp->id); 1243 format_add(ft, "pane_active", "%d", wp == wp->window->active); 1244 format_add(ft, "pane_input_off", "%d", !!(wp->flags & PANE_INPUTOFF)); 1245 1246 status = wp->status; 1247 if (wp->fd == -1 && WIFEXITED(status)) 1248 format_add(ft, "pane_dead_status", "%d", WEXITSTATUS(status)); 1249 format_add(ft, "pane_dead", "%d", wp->fd == -1); 1250 1251 if (window_pane_visible(wp)) { 1252 format_add(ft, "pane_left", "%u", wp->xoff); 1253 format_add(ft, "pane_top", "%u", wp->yoff); 1254 format_add(ft, "pane_right", "%u", wp->xoff + wp->sx - 1); 1255 format_add(ft, "pane_bottom", "%u", wp->yoff + wp->sy - 1); 1256 } 1257 1258 format_add(ft, "pane_in_mode", "%d", wp->screen != &wp->base); 1259 format_add(ft, "pane_synchronized", "%d", 1260 !!options_get_number(wp->window->options, "synchronize-panes")); 1261 1262 format_add(ft, "pane_tty", "%s", wp->tty); 1263 format_add(ft, "pane_pid", "%ld", (long) wp->pid); 1264 format_add_cb(ft, "pane_start_command", format_cb_start_command); 1265 format_add_cb(ft, "pane_current_command", format_cb_current_command); 1266 1267 format_add(ft, "cursor_x", "%u", wp->base.cx); 1268 format_add(ft, "cursor_y", "%u", wp->base.cy); 1269 format_add(ft, "scroll_region_upper", "%u", wp->base.rupper); 1270 format_add(ft, "scroll_region_lower", "%u", wp->base.rlower); 1271 1272 scroll_position = window_copy_scroll_position(wp); 1273 if (scroll_position != -1) 1274 format_add(ft, "scroll_position", "%d", scroll_position); 1275 1276 format_add(ft, "alternate_on", "%d", wp->saved_grid ? 1 : 0); 1277 format_add(ft, "alternate_saved_x", "%u", wp->saved_cx); 1278 format_add(ft, "alternate_saved_y", "%u", wp->saved_cy); 1279 1280 format_add(ft, "cursor_flag", "%d", 1281 !!(wp->base.mode & MODE_CURSOR)); 1282 format_add(ft, "insert_flag", "%d", 1283 !!(wp->base.mode & MODE_INSERT)); 1284 format_add(ft, "keypad_cursor_flag", "%d", 1285 !!(wp->base.mode & MODE_KCURSOR)); 1286 format_add(ft, "keypad_flag", "%d", 1287 !!(wp->base.mode & MODE_KKEYPAD)); 1288 format_add(ft, "wrap_flag", "%d", 1289 !!(wp->base.mode & MODE_WRAP)); 1290 1291 format_add(ft, "mouse_any_flag", "%d", 1292 !!(wp->base.mode & ALL_MOUSE_MODES)); 1293 format_add(ft, "mouse_standard_flag", "%d", 1294 !!(wp->base.mode & MODE_MOUSE_STANDARD)); 1295 format_add(ft, "mouse_button_flag", "%d", 1296 !!(wp->base.mode & MODE_MOUSE_BUTTON)); 1297 format_add(ft, "mouse_all_flag", "%d", 1298 !!(wp->base.mode & MODE_MOUSE_ALL)); 1299 1300 format_add_cb(ft, "pane_tabs", format_cb_pane_tabs); 1301 } 1302 1303 /* Set default format keys for paste buffer. */ 1304 void 1305 format_defaults_paste_buffer(struct format_tree *ft, struct paste_buffer *pb) 1306 { 1307 size_t bufsize; 1308 char *s; 1309 1310 paste_buffer_data(pb, &bufsize); 1311 format_add(ft, "buffer_size", "%zu", bufsize); 1312 format_add(ft, "buffer_name", "%s", paste_buffer_name(pb)); 1313 1314 s = paste_make_sample(pb); 1315 format_add(ft, "buffer_sample", "%s", s); 1316 free(s); 1317 } 1318