tor-commits September 2012

tor-commits@lists.torproject.org

18 participants
792 discussions

[tor/master] Merge remote-tracking branch 'public/bug6853'
by nickm＠torproject.org 17 Sep '12

17 Sep '12

commit 32d9cea2892f79d8f16adcc5ae417980af33f082 Merge: 5511d21 414adb2 Author: Nick Mathewson <nickm(a)torproject.org> Date: Mon Sep 17 10:50:48 2012 -0400 Merge remote-tracking branch 'public/bug6853' changes/bug6853 | 3 +++ src/or/routerparse.c | 2 +- 2 files changed, 4 insertions(+), 1 deletions(-)

1 0

[tor/master] Avoid sign-extending when computing rend auth type.
by nickm＠torproject.org 17 Sep '12

17 Sep '12

commit 96d2a21683cdfe25b549e13fa450d4b12fb945b2 Author: Nick Mathewson <nickm(a)torproject.org> Date: Mon Sep 17 09:52:43 2012 -0400 Avoid sign-extending when computing rend auth type. Right-shifting negative values has implementation-defined behavior. On all the platforms we work on right now, the behavior is to sign-extend the input. That isn't what we wanted in auth_type_val = (descriptor_cookie_tmp[16] >> 4) + 1; Fix for 6861; bugfix on 0.2.1.5-alpha; reported pseudonymously. The broken behavior didn't actually hurt anything, I think, since the only way to get sign-extension to happen would be to have the top bit of descriptor_cookie_tmp[16] set, which would make the value of descriptor_cookie_tmp[16] >> 4 somewhere between 0b11111111 and 0b11111000 (that is, between -1 and -8). So auth_type_val would be between -7 and 0. And the immediate next line does: if (auth_type_val < 1 || auth_type_val > 2) { So the incorrectly computed auth_type_val would be rejected as invalid, just as a correctly computed auth_type_val would be. Still, this stuff shouldn't sit around the codebase. --- changes/bug6861 | 3 +++ src/or/rendclient.c | 2 +- 2 files changed, 4 insertions(+), 1 deletions(-) diff --git a/changes/bug6861 b/changes/bug6861 new file mode 100644 index 0000000..1040bd7 --- /dev/null +++ b/changes/bug6861 @@ -0,0 +1,3 @@ + o Minor bugfixes: + - Fix handling of rendezvous client authorization types over 8. + Fixes bug 6841; bugfix on 0.2.1.5-alpha. diff --git a/src/or/rendclient.c b/src/or/rendclient.c index 73e1c41..2104a5b 100644 --- a/src/or/rendclient.c +++ b/src/or/rendclient.c @@ -1250,7 +1250,7 @@ rend_parse_service_authorization(const or_options_t *options, descriptor_cookie); goto err; } - auth_type_val = (descriptor_cookie_tmp[16] >> 4) + 1; + auth_type_val = (((uint8_t)descriptor_cookie_tmp[16]) >> 4) + 1; if (auth_type_val < 1 || auth_type_val > 2) { log_warn(LD_CONFIG, "Authorization cookie has unknown authorization " "type encoded.");

1 0

[tor/master] Merge branch 'bug6861_typofix'
by nickm＠torproject.org 17 Sep '12

17 Sep '12

commit 5511d21d2b99fb686f3ad57be1a16d383f77adc9 Merge: c3f526e 96d2a21 Author: Nick Mathewson <nickm(a)torproject.org> Date: Mon Sep 17 10:28:35 2012 -0400 Merge branch 'bug6861_typofix' changes/bug6861 | 3 +++ src/or/rendclient.c | 2 +- 2 files changed, 4 insertions(+), 1 deletions(-)

1 0

[tor/master] Handle FIFOs in read_file_to_str
by nickm＠torproject.org 17 Sep '12

17 Sep '12

commit d64bf286a175f590fc07f51f49584cf246eac9b2 Author: meejah <meejah(a)meejah.ca> Date: Wed Sep 12 13:26:34 2012 -0600 Handle FIFOs in read_file_to_str add read_file_to_str_until_eof which is used by read_file_to_str if the file happens to be a FIFO. change file_status() to return FN_FILE if st_mode matches S_IFIFO (on not-windows) so that init_key_from_file() will read from a FIFO. --- src/common/util.c | 60 ++++++++++++++++++++++++++ src/common/util.h | 3 + src/test/test_util.c | 114 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 177 insertions(+), 0 deletions(-) diff --git a/src/common/util.c b/src/common/util.c index 3efc253..feeaf74 100644 --- a/src/common/util.c +++ b/src/common/util.c @@ -1807,6 +1807,10 @@ file_status(const char *fname) return FN_DIR; else if (st.st_mode & S_IFREG) return FN_FILE; +#ifndef _WIN32 + else if (st.st_mode & S_IFIFO) + return FN_FILE; +#endif else return FN_ERROR; } @@ -2237,6 +2241,46 @@ write_bytes_to_new_file(const char *fname, const char *str, size_t len, (bin?O_BINARY:O_TEXT)); } +/** + * Read the contents of the open file fd presuming it is a FIFO + * (or similar) file descriptor for which the size of the file isn't + * known ahead of time. Return NULL on failure, and a NUL-terminated + * string on success. On success, set sz_out to the number of + * bytes read. + */ +char * +read_file_to_str_until_eof(int fd, size_t max_bytes_to_read, size_t *sz_out) +{ + ssize_t r; + size_t pos = 0; + char *string = NULL; + size_t string_max = 0; + + if (max_bytes_to_read+1 >= SIZE_T_CEILING) + return NULL; + + do { + /* XXXX This "add 1K" approach is a little goofy; if we care about + * performance here, we should be doubling. But in practice we shouldn't + * be using this function on big files anyway. */ + string_max = pos + 1024; + if (string_max > max_bytes_to_read) + string_max = max_bytes_to_read + 1; + string = tor_realloc(string, string_max); + r = read(fd, string + pos, string_max - pos - 1); + if (r < 0) { + tor_free(string); + return NULL; + } + + pos += r; + } while (r > 0 && pos < max_bytes_to_read); + + *sz_out = pos; + string[pos] = '\0'; + return string; +} + /** Read the contents of filename into a newly allocated * string; return the string on success or NULL on failure. * @@ -2285,6 +2329,22 @@ read_file_to_str(const char *filename, int flags, struct stat *stat_out) return NULL; } +#ifndef _WIN32 +/** When we detect that we're reading from a FIFO, don't read more than + * this many bytes. It's insane overkill for most uses. */ +#define FIFO_READ_MAX (1024*1024) + if (S_ISFIFO(statbuf.st_mode)) { + size_t sz = 0; + string = read_file_to_str_until_eof(fd, FIFO_READ_MAX, &sz); + if (string && stat_out) { + statbuf.st_size = sz; + memcpy(stat_out, &statbuf, sizeof(struct stat)); + } + close(fd); + return string; + } +#endif + if ((uint64_t)(statbuf.st_size)+1 >= SIZE_T_CEILING) return NULL; diff --git a/src/common/util.h b/src/common/util.h index a6944ac..0cfc1b9 100644 --- a/src/common/util.h +++ b/src/common/util.h @@ -360,6 +360,9 @@ struct stat; #endif char *read_file_to_str(const char *filename, int flags, struct stat *stat_out) ATTR_MALLOC; +char *read_file_to_str_until_eof(int fd, size_t max_bytes_to_read, + size_t *sz_out) + ATTR_MALLOC; const char *parse_config_line_from_str(const char *line, char **key_out, char **value_out); char *expand_filename(const char *filename); diff --git a/src/test/test_util.c b/src/test/test_util.c index 64976f3..cc3a03f 100644 --- a/src/test/test_util.c +++ b/src/test/test_util.c @@ -19,6 +19,117 @@ #endif static void +test_util_read_file_fifo_tiny_limit(void *arg) +{ +#ifndef _WIN32 + char *fifo_name = NULL; + char *str = NULL; + int fd = -1; + int read_fd = -1; + size_t sz; + (void)arg; + + fifo_name = tor_strdup(get_fname("tor_test_fifo_tiny")); + fd = open(fifo_name, O_WRONLY | O_CREAT, 0600); + test_neq(fd, -1); + test_eq(write(fd, "short", 6), 6); + close(fd); + + // purposely set limit shorter than what we wrote to the FIFO to + // test the maximum, and that it puts the NUL in the right spot + + read_fd = open(fifo_name, O_RDONLY); + str = read_file_to_str_until_eof(read_fd, 4, &sz); + close(read_fd); + + test_eq(str[0], 's'); + test_eq(str[1], 'h'); + test_eq(str[2], 'o'); + test_eq(str[3], 'r'); + test_eq(str[4], '\0'); + + done: + unlink(fifo_name); + tor_free(fifo_name); + tor_free(str); +#endif +} + +static void +test_util_read_file_fifo_two_loops(void *arg) +{ +#ifndef _WIN32 + char *fifo_name = NULL; + char *str = NULL; + char data[2048]; + int i = 0; + int fd = -1; + int read_fd = -1; + size_t sz; + (void)arg; + + while (i < 2048) { + data[i] = (char)(i & 0xff); + ++i; + } + + // write more than 1024 bytes to the FIFO to test two passes through + // the loop in the method; if the re-alloc size is changed this + // should be updated as well. + + fifo_name = tor_strdup(get_fname("tor_fifo_test_2k")); + fd = open(fifo_name, O_WRONLY | O_CREAT, 0600); + test_neq(fd, -1); + test_eq(write(fd, data, 2048), 2048); + close(fd); + + read_fd = open(fifo_name, O_RDONLY); + str = read_file_to_str_until_eof(read_fd, 1024*1024, &sz); + close(read_fd); + + for (i = 0; i < 2048; ++i) { + test_eq(str[i], (char)(i & 0xff)); + } + + done: + unlink(fifo_name); + tor_free(fifo_name); + tor_free(str); +#endif +} + +static void +test_util_read_file_fifo_zero_bytes(void *arg) +{ +#ifndef _WIN32 + char *fifo_name = NULL; + char *str = NULL; + int fd = -1; + int read_fd = -1; + size_t sz; + (void)arg; + + fifo_name = tor_strdup(get_fname("tor_fifo_test_zero_bytes")); + // zero-byte fifo + fd = open(fifo_name, O_WRONLY | O_CREAT, 0600); + test_neq(fd, -1); + close(fd); + + read_fd = open(fifo_name, O_RDONLY); + str = read_file_to_str_until_eof(read_fd, 1024, &sz); + close(read_fd); + + test_neq(str, NULL); + test_eq(str[0], '\0'); + + done: + unlink(fifo_name); + tor_free(fifo_name); + tor_free(str); +#endif +} + +static void test_util_time(void) { struct timeval start, end; @@ -3191,6 +3302,9 @@ struct testcase_t util_tests[] = { UTIL_TEST(envnames, 0), UTIL_TEST(make_environment, 0), UTIL_TEST(set_env_var_in_sl, 0), + UTIL_TEST(read_file_fifo_tiny_limit, 0), + UTIL_TEST(read_file_fifo_two_loops, 0), + UTIL_TEST(read_file_fifo_zero_bytes, 0), END_OF_TESTCASES };

1 0

[tor/master] Merge branch '6044_nm_squashed'
by nickm＠torproject.org 17 Sep '12

17 Sep '12

commit c3f526ed64012f64589b926082ff5e542ec7d18d Merge: 2939cc3 faab788 Author: Nick Mathewson <nickm(a)torproject.org> Date: Mon Sep 17 10:03:11 2012 -0400 Merge branch '6044_nm_squashed' changes/6044 | 5 +++ src/common/util.c | 60 ++++++++++++++++++++++++++++++++++++++++++ src/common/util.h | 3 ++ src/test/test_util.c | 71 ++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 139 insertions(+), 0 deletions(-) diff --cc src/test/test_util.c index 2c65903,1734108..f615ead --- a/src/test/test_util.c +++ b/src/test/test_util.c @@@ -18,20 -18,75 +18,88 @@@ #include <tchar.h> #endif +/* XXXX this is a minimal wrapper to make the unit tests compile with the + * changed tor_timegm interface. */ +static time_t +tor_timegm_wrapper(const struct tm *tm) +{ + time_t t; + if (tor_timegm(tm, &t) < 0) + return -1; + return t; +} + +#define tor_timegm tor_timegm_wrapper + static void + test_util_read_until_eof_impl(const char *fname, size_t file_len, + size_t read_limit) + { + char *fifo_name = NULL; + char *test_str = NULL; + char *str = NULL; + size_t sz = 9999999; + int fd = -1; + int r; + + fifo_name = tor_strdup(get_fname(fname)); + test_str = tor_malloc(file_len); + crypto_rand(test_str, file_len); + + r = write_bytes_to_file(fifo_name, test_str, file_len, 1); + tt_int_op(r, ==, 0); + + fd = open(fifo_name, O_RDONLY|O_BINARY); + tt_int_op(fd, >=, 0); + str = read_file_to_str_until_eof(fd, read_limit, &sz); + close(fd); + tt_assert(str != NULL); + + if (read_limit < file_len) + tt_int_op(sz, ==, read_limit); + else + tt_int_op(sz, ==, file_len); + + test_mem_op(test_str, ==, str, sz); + test_assert(str[sz] == '\0'); + + done: + unlink(fifo_name); + tor_free(fifo_name); + tor_free(test_str); + tor_free(str); + } + + static void + test_util_read_file_eof_tiny_limit(void *arg) + { + (void)arg; + // purposely set limit shorter than what we wrote to the FIFO to + // test the maximum, and that it puts the NUL in the right spot + + test_util_read_until_eof_impl("tor_test_fifo_tiny", 5, 4); + } + + static void + test_util_read_file_eof_two_loops(void *arg) + { + (void)arg; + // write more than 1024 bytes to the FIFO to test two passes through + // the loop in the method; if the re-alloc size is changed this + // should be updated as well. + + test_util_read_until_eof_impl("tor_test_fifo_2k", 2048, 10000); + } + + static void + test_util_read_file_eof_zero_bytes(void *arg) + { + (void)arg; + // zero-byte fifo + test_util_read_until_eof_impl("tor_test_fifo_empty", 0, 10000); + } + + static void test_util_time(void) { struct timeval start, end;

1 0

[tor/master] changes file for 6044
by nickm＠torproject.org 17 Sep '12

17 Sep '12

commit faab7881894e55e71c0a19654f3c733c8b0d2920 Author: Nick Mathewson <nickm(a)torproject.org> Date: Fri Sep 14 14:10:08 2012 -0400 changes file for 6044 --- changes/6044 | 5 +++++ 1 files changed, 5 insertions(+), 0 deletions(-) diff --git a/changes/6044 b/changes/6044 new file mode 100644 index 0000000..6f932a3 --- /dev/null +++ b/changes/6044 @@ -0,0 +1,5 @@ + o Minor features: + - Enable Tor to read configuration, state, and key information from + a FIFO. Previously Tor would only read from files with a positive + stat.st_size. Code from meejah; fixes bug 6044. +

1 0

[tor/master] Turn the read_file_until_eof tests into a single implementation
by nickm＠torproject.org 17 Sep '12

17 Sep '12

commit 4b362d002ccd2008ebfa4b44e3ca61e8efa96cac Author: Nick Mathewson <nickm(a)torproject.org> Date: Fri Sep 14 12:23:31 2012 -0400 Turn the read_file_until_eof tests into a single implementation --- src/test/test_util.c | 119 ++++++++++++++++---------------------------------- 1 files changed, 38 insertions(+), 81 deletions(-) diff --git a/src/test/test_util.c b/src/test/test_util.c index cc3a03f..1734108 100644 --- a/src/test/test_util.c +++ b/src/test/test_util.c @@ -19,114 +19,71 @@ #endif static void -test_util_read_file_fifo_tiny_limit(void *arg) +test_util_read_until_eof_impl(const char *fname, size_t file_len, + size_t read_limit) { -#ifndef _WIN32 char *fifo_name = NULL; + char *test_str = NULL; char *str = NULL; + size_t sz = 9999999; int fd = -1; - int read_fd = -1; - size_t sz; - (void)arg; + int r; - fifo_name = tor_strdup(get_fname("tor_test_fifo_tiny")); - fd = open(fifo_name, O_WRONLY | O_CREAT, 0600); - test_neq(fd, -1); - test_eq(write(fd, "short", 6), 6); - close(fd); + fifo_name = tor_strdup(get_fname(fname)); + test_str = tor_malloc(file_len); + crypto_rand(test_str, file_len); - // purposely set limit shorter than what we wrote to the FIFO to - // test the maximum, and that it puts the NUL in the right spot + r = write_bytes_to_file(fifo_name, test_str, file_len, 1); + tt_int_op(r, ==, 0); + + fd = open(fifo_name, O_RDONLY|O_BINARY); + tt_int_op(fd, >=, 0); + str = read_file_to_str_until_eof(fd, read_limit, &sz); + close(fd); + tt_assert(str != NULL); - read_fd = open(fifo_name, O_RDONLY); - str = read_file_to_str_until_eof(read_fd, 4, &sz); - close(read_fd); + if (read_limit < file_len) + tt_int_op(sz, ==, read_limit); + else + tt_int_op(sz, ==, file_len); - test_eq(str[0], 's'); - test_eq(str[1], 'h'); - test_eq(str[2], 'o'); - test_eq(str[3], 'r'); - test_eq(str[4], '\0'); + test_mem_op(test_str, ==, str, sz); + test_assert(str[sz] == '\0'); done: unlink(fifo_name); tor_free(fifo_name); + tor_free(test_str); tor_free(str); -#endif } static void -test_util_read_file_fifo_two_loops(void *arg) +test_util_read_file_eof_tiny_limit(void *arg) { -#ifndef _WIN32 - char *fifo_name = NULL; - char *str = NULL; - char data[2048]; - int i = 0; - int fd = -1; - int read_fd = -1; - size_t sz; (void)arg; + // purposely set limit shorter than what we wrote to the FIFO to + // test the maximum, and that it puts the NUL in the right spot - while (i < 2048) { - data[i] = (char)(i & 0xff); - ++i; - } + test_util_read_until_eof_impl("tor_test_fifo_tiny", 5, 4); +} +static void +test_util_read_file_eof_two_loops(void *arg) +{ + (void)arg; // write more than 1024 bytes to the FIFO to test two passes through // the loop in the method; if the re-alloc size is changed this // should be updated as well. - fifo_name = tor_strdup(get_fname("tor_fifo_test_2k")); - fd = open(fifo_name, O_WRONLY | O_CREAT, 0600); - test_neq(fd, -1); - test_eq(write(fd, data, 2048), 2048); - close(fd); - - read_fd = open(fifo_name, O_RDONLY); - str = read_file_to_str_until_eof(read_fd, 1024*1024, &sz); - close(read_fd); - - for (i = 0; i < 2048; ++i) { - test_eq(str[i], (char)(i & 0xff)); - } - - done: - unlink(fifo_name); - tor_free(fifo_name); - tor_free(str); -#endif + test_util_read_until_eof_impl("tor_test_fifo_2k", 2048, 10000); } static void -test_util_read_file_fifo_zero_bytes(void *arg) +test_util_read_file_eof_zero_bytes(void *arg) { -#ifndef _WIN32 - char *fifo_name = NULL; - char *str = NULL; - int fd = -1; - int read_fd = -1; - size_t sz; (void)arg; - - fifo_name = tor_strdup(get_fname("tor_fifo_test_zero_bytes")); // zero-byte fifo - fd = open(fifo_name, O_WRONLY | O_CREAT, 0600); - test_neq(fd, -1); - close(fd); - - read_fd = open(fifo_name, O_RDONLY); - str = read_file_to_str_until_eof(read_fd, 1024, &sz); - close(read_fd); - - test_neq(str, NULL); - test_eq(str[0], '\0'); - - done: - unlink(fifo_name); - tor_free(fifo_name); - tor_free(str); -#endif + test_util_read_until_eof_impl("tor_test_fifo_empty", 0, 10000); } static void @@ -3302,9 +3259,9 @@ struct testcase_t util_tests[] = { UTIL_TEST(envnames, 0), UTIL_TEST(make_environment, 0), UTIL_TEST(set_env_var_in_sl, 0), - UTIL_TEST(read_file_fifo_tiny_limit, 0), - UTIL_TEST(read_file_fifo_two_loops, 0), - UTIL_TEST(read_file_fifo_zero_bytes, 0), + UTIL_TEST(read_file_eof_tiny_limit, 0), + UTIL_TEST(read_file_eof_two_loops, 0), + UTIL_TEST(read_file_eof_zero_bytes, 0), END_OF_TESTCASES };

1 0

[tor/master] Note which compiler caused bug 6842
by nickm＠torproject.org 17 Sep '12

17 Sep '12

commit 2939cc3ba3afe5ef2c6a273eef18577274e6867b Author: Nick Mathewson <nickm(a)torproject.org> Date: Mon Sep 17 09:38:48 2012 -0400 Note which compiler caused bug 6842 --- ChangeLog | 6 +++--- 1 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ChangeLog b/ChangeLog index c517207..3ba1286 100644 --- a/ChangeLog +++ b/ChangeLog @@ -36,9 +36,9 @@ Changes in version 0.2.4.3-alpha - 2012-09-?? Previously, Tor would have confused (as-yet-unused) protocol version numbers greater than 32 with lower ones on many platforms. Fixes bug 6827; bugfix on 0.2.0.10-alpha. Found by George Kadianakis. - - Fix building with older versions of GCC that don't like preprocessor - directives inside macro arguments. Found by grarpamp. Fixes bug - 6842; bugfix on 0.2.4.2-alpha. + - Fix building with older versions of GCC (2.95, for one) that don't + like preprocessor directives inside macro arguments. Found by + grarpamp. Fixes bug 6842; bugfix on 0.2.4.2-alpha. - Switch weighted node selection rule from using a list of doubles to using a list of int64_t. This change should make the process slightly easier to debug and maintain. Needed to finish ticket 6538.

1 0

[translation/https_everywhere] Update translations for https_everywhere
by translation＠torproject.org 17 Sep '12

17 Sep '12

commit a47bffead1711e718568032e152273ba6355522d Author: Translation commit bot <translation(a)torproject.org> Date: Mon Sep 17 12:45:30 2012 +0000 Update translations for https_everywhere --- ja/https-everywhere.dtd | 37 +++++++++++++++++++++++++++++++++++++ 1 files changed, 37 insertions(+), 0 deletions(-) diff --git a/ja/https-everywhere.dtd b/ja/https-everywhere.dtd new file mode 100644 index 0000000..b0dfb95 --- /dev/null +++ b/ja/https-everywhere.dtd @@ -0,0 +1,37 @@ +<!ENTITY https-everywhere.about.title ""> +<!ENTITY https-everywhere.about.ext_name ""> +<!ENTITY https-everywhere.about.ext_description ""> +<!ENTITY https-everywhere.about.version ""> +<!ENTITY https-everywhere.about.created_by ""> +<!ENTITY https-everywhere.about.librarians ""> +<!ENTITY https-everywhere.about.thanks ""> +<!ENTITY https-everywhere.about.contribute ""> +<!ENTITY https-everywhere.about.donate_tor ""> +<!ENTITY https-everywhere.about.tor_lang_code ""> +<!ENTITY https-everywhere.about.donate_eff ""> + +<!ENTITY https-everywhere.menu.about ""> +<!ENTITY https-everywhere.menu.observatory ""> +<!ENTITY https-everywhere.menu.globalEnable ""> +<!ENTITY https-everywhere.menu.globalDisable ""> + +<!ENTITY https-everywhere.prefs.title ""> +<!ENTITY https-everywhere.prefs.enable_all ""> +<!ENTITY https-everywhere.prefs.disable_all ""> +<!ENTITY https-everywhere.prefs.reset_defaults ""> +<!ENTITY https-everywhere.prefs.search ""> +<!ENTITY https-everywhere.prefs.site ""> +<!ENTITY https-everywhere.prefs.notes ""> +<!ENTITY https-everywhere.prefs.list_caption ""> +<!ENTITY https-everywhere.prefs.enabled ""> +<!ENTITY https-everywhere.prefs.ruleset_howto ""> +<!ENTITY https-everywhere.prefs.here_link ""> +<!ENTITY https-everywhere.prefs.toggle ""> +<!ENTITY https-everywhere.prefs.reset_default ""> +<!ENTITY https-everywhere.prefs.view_xml_source ""> + +<!ENTITY https-everywhere.source.downloading ""> +<!ENTITY https-everywhere.source.filename ""> +<!ENTITY https-everywhere.source.unable_to_download ""> + +

1 0

[arm/master] Failing over when proc fails to get the uptime
by atagar＠torproject.org 17 Sep '12

17 Sep '12

commit 74567bb166c68584e3d1459f98e1ea08d09927c3 Author: Damian Johnson <atagar(a)torproject.org> Date: Sun Sep 16 17:13:07 2012 -0700 Failing over when proc fails to get the uptime The header panel caches tor's start time which is great... unless the following happens. 1. We try to fetch the start time via proc contents and fail. 2. The header panel caches the None result. 3. Arm later discovers that proc is unusable and turns it off, but it's too late since the header panel has cached the result. Accounting for this by failing over to 'ps' whenever the proc query fails. Issue caught by drforbin on... https://trac.torproject.org/6862 Only testing done was a basic sanity test that arm runs against a relay. --- src/util/torTools.py | 12 ++++++++---- 1 files changed, 8 insertions(+), 4 deletions(-) diff --git a/src/util/torTools.py b/src/util/torTools.py index 5b70c6a..a4d49c7 100644 --- a/src/util/torTools.py +++ b/src/util/torTools.py @@ -2370,16 +2370,20 @@ class Controller(TorCtl.PostEventListener): myPid = self.getMyPid() if myPid: - try: - if procTools.isProcAvailable(): + if procTools.isProcAvailable(): + try: result = float(procTools.getStats(myPid, procTools.Stat.START_TIME)[0]) - else: + except: pass + + if not result: + # if we're either not using proc or it fails then try using ps + try: psCall = sysTools.call("ps -p %s -o etime" % myPid) if psCall and len(psCall) >= 2: etimeEntry = psCall[1].strip() result = time.time() - uiTools.parseShortTimeLabel(etimeEntry) - except: pass + except: pass elif key == "authorities": # There's two configuration options that can overwrite the default # authorities: DirServer and AlternateDirAuthority.

1 0

← Newer
1
...
28
29
30
31
32
33
34
...
80
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

tor-commits September 2012