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