PuTTy: Diff

Differences From Artifact [116018d6b1]:

File unix/uxpty.c — part of check-in [a2c0243430] at 2011-07-14 13:52:21 on branch trunk — Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. (user: simon size: 26697)

To Artifact [fa5104a1f5]:

File unix/uxpty.c — part of check-in [acb21a748a] at 2011-09-19 11:38:23 on branch trunk — We shouldn't fork off a utmp helper subprocess when we aren't setuid, because (a) under that circumstance we won't be writing to utmp anyway, and (b) if we aren't setuid, then we won't have created the pty at the point we fork, so even if our subprocess _could_ have written to utmp it wouldn't have done it right! Spotted by valgrind (triggering on the access beyond the end of the ttyname string in setup_utmp, clueing me in to it having been empty). (user: simon size: 27773)

︙
163 164 165 166 167 168 169 ~~170 171~~ 172 173 174 175 176 177 178	163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178	- - + +	* Likewise, since utmp is only used via pty_pre_init, it too must * be single-instance, so we can declare utmp-related variables * here. / static Pty single_pty = NULL; #ifndef OMIT_UTMP ~~static pid_t pty_utmp_helper_pid; static int pty_utmp_helper_pipe;~~ static pid_t pty_utmp_helper_pid = -1; static int pty_utmp_helper_pipe = -1; static int pty_stamped_utmp; static struct utmpx utmp_entry; #endif / * pty_argv is a grievous hack to allow a proper argv to be passed * through from the Unix command line. Again, it doesn't really
︙
404 405 406 407 408 409 410 ~~411~~ 412 413 ~~414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429~~ 430 ~~431 432 433 434 435 436~~ 437 ~~438 439~~ 440 ~~441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473~~ 474 ~~475~~ 476 477 ~~478~~ 479 480 ~~481~~ 482 483 ~~484~~ 485 486 ~~487~~ 488 489 ~~490~~ 491 492 ~~493~~ 494 495 ~~496~~ 497 498 ~~499~~ 500 ~~501 502 503 504 505 506 507 508 509~~ 510 511 512 513 514 515 516 517	404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517	- - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - - - - - + + + + + + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + - + - + - + - + - - - - - - - - - + + + + + + + + + +	pty->master_fd = pty->slave_fd = -1; #ifndef OMIT_UTMP pty_stamped_utmp = FALSE; #endif if (geteuid() != getuid() \|\| getegid() != getgid()) { pty_open_master(pty); } #ifndef OMIT_UTMP /* * Fork off the utmp helper. / if (pipe(pipefd) < 0) { perror("pterm: pipe"); exit(1); } cloexec(pipefd[0]); cloexec(pipefd[1]); pid = fork(); if (pid < 0) { perror("pterm: fork"); exit(1); } else if (pid == 0) { char display[128], buffer[128]; int dlen, ret; / * Fork off the utmp helper. / if (pipe(pipefd) < 0) { perror("pterm: pipe"); exit(1); } cloexec(pipefd[0]); cloexec(pipefd[1]); pid = fork(); if (pid < 0) { perror("pterm: fork"); exit(1); } else if (pid == 0) { char display[128], buffer[128]; int dlen, ret; ~~close(pipefd[1]); / * Now sit here until we receive a display name from the * other end of the pipe, and then stamp utmp. Unstamp utmp * again, and exit, when the pipe closes. /~~ close(pipefd[1]); / * Now sit here until we receive a display name from the * other end of the pipe, and then stamp utmp. Unstamp utmp * again, and exit, when the pipe closes. / ~~dlen = 0; while (1) {~~ dlen = 0; while (1) { ret = read(pipefd[0], buffer, lenof(buffer)); if (ret <= 0) { cleanup_utmp(); _exit(0); } else if (!pty_stamped_utmp) { if (dlen < lenof(display)) memcpy(display+dlen, buffer, min(ret, lenof(display)-dlen)); if (buffer[ret-1] == '\0') { / * Now we have a display name. NUL-terminate * it, and stamp utmp. / display[lenof(display)-1] = '\0'; / * Trap as many fatal signals as we can in the * hope of having the best possible chance to * clean up utmp before termination. We are * unfortunately unprotected against SIGKILL, * but that's life. / putty_signal(SIGHUP, fatal_sig_handler); putty_signal(SIGINT, fatal_sig_handler); putty_signal(SIGQUIT, fatal_sig_handler); putty_signal(SIGILL, fatal_sig_handler); putty_signal(SIGABRT, fatal_sig_handler); putty_signal(SIGFPE, fatal_sig_handler); putty_signal(SIGPIPE, fatal_sig_handler); putty_signal(SIGALRM, fatal_sig_handler); putty_signal(SIGTERM, fatal_sig_handler); putty_signal(SIGSEGV, fatal_sig_handler); putty_signal(SIGUSR1, fatal_sig_handler); putty_signal(SIGUSR2, fatal_sig_handler); ret = read(pipefd[0], buffer, lenof(buffer)); if (ret <= 0) { cleanup_utmp(); _exit(0); } else if (!pty_stamped_utmp) { if (dlen < lenof(display)) memcpy(display+dlen, buffer, min(ret, lenof(display)-dlen)); if (buffer[ret-1] == '\0') { / * Now we have a display name. NUL-terminate * it, and stamp utmp. / display[lenof(display)-1] = '\0'; / * Trap as many fatal signals as we can in the * hope of having the best possible chance to * clean up utmp before termination. We are * unfortunately unprotected against SIGKILL, * but that's life. / putty_signal(SIGHUP, fatal_sig_handler); putty_signal(SIGINT, fatal_sig_handler); putty_signal(SIGQUIT, fatal_sig_handler); putty_signal(SIGILL, fatal_sig_handler); putty_signal(SIGABRT, fatal_sig_handler); putty_signal(SIGFPE, fatal_sig_handler); putty_signal(SIGPIPE, fatal_sig_handler); putty_signal(SIGALRM, fatal_sig_handler); putty_signal(SIGTERM, fatal_sig_handler); putty_signal(SIGSEGV, fatal_sig_handler); putty_signal(SIGUSR1, fatal_sig_handler); putty_signal(SIGUSR2, fatal_sig_handler); #ifdef SIGBUS ~~putty_signal(SIGBUS, fatal_sig_handler);~~ putty_signal(SIGBUS, fatal_sig_handler); #endif #ifdef SIGPOLL ~~putty_signal(SIGPOLL, fatal_sig_handler);~~ putty_signal(SIGPOLL, fatal_sig_handler); #endif #ifdef SIGPROF ~~putty_signal(SIGPROF, fatal_sig_handler);~~ putty_signal(SIGPROF, fatal_sig_handler); #endif #ifdef SIGSYS ~~putty_signal(SIGSYS, fatal_sig_handler);~~ putty_signal(SIGSYS, fatal_sig_handler); #endif #ifdef SIGTRAP ~~putty_signal(SIGTRAP, fatal_sig_handler);~~ putty_signal(SIGTRAP, fatal_sig_handler); #endif #ifdef SIGVTALRM ~~putty_signal(SIGVTALRM, fatal_sig_handler);~~ putty_signal(SIGVTALRM, fatal_sig_handler); #endif #ifdef SIGXCPU ~~putty_signal(SIGXCPU, fatal_sig_handler);~~ putty_signal(SIGXCPU, fatal_sig_handler); #endif #ifdef SIGXFSZ ~~putty_signal(SIGXFSZ, fatal_sig_handler);~~ putty_signal(SIGXFSZ, fatal_sig_handler); #endif #ifdef SIGIO ~~putty_signal(SIGIO, fatal_sig_handler);~~ putty_signal(SIGIO, fatal_sig_handler); #endif ~~setup_utmp(pty->name, display); } } } } else { close(pipefd[0]); pty_utmp_helper_pid = pid; pty_utmp_helper_pipe = pipefd[1]; }~~ setup_utmp(pty->name, display); } } } } else { close(pipefd[0]); pty_utmp_helper_pid = pid; pty_utmp_helper_pipe = pipefd[1]; } #endif } / Drop privs. */ { #ifndef HAVE_NO_SETRESUID int gid = getgid(), uid = getuid(); int setresgid(gid_t, gid_t, gid_t); int setresuid(uid_t, uid_t, uid_t);
︙
731 732 733 734 735 736 737 ~~738~~ 739 740 741 742 743 744 745	731 732 733 734 735 736 737 738 739 740 741 742 743 744 745	- +	/* * Stamp utmp (that is, tell the utmp helper process to do so), * or not. / if (!conf_get_int(conf, CONF_stamp_utmp)) { close(pty_utmp_helper_pipe); / just let the child process die / pty_utmp_helper_pipe = -1; ~~} else {~~ } else if (pty_utmp_helper_pipe >= 0) { char location = get_x_display(pty->frontend); int len = strlen(location)+1, pos = 0; /* +1 to include NUL / while (pos < len) { int ret = write(pty_utmp_helper_pipe, location+pos, len - pos); if (ret < 0) { perror("pterm: writing to utmp helper process"); close(pty_utmp_helper_pipe); / arrgh, just give up */
︙