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