-- vda diff -x '*.po' -d -urpN abrt.0/inc/abrtlib.h abrt.1/inc/abrtlib.h --- abrt.0/inc/abrtlib.h 2011-01-06 13:10:44.000000000 +0100 +++ abrt.1/inc/abrtlib.h 2011-01-06 13:15:57.000000000 +0100 @@ -218,6 +218,17 @@ char* xmalloc_sockaddr2dotted_noport(con /* Random utility functions */ +#ifdef __cplusplus +extern "C" { +#endif +/* Emit a string of hex representation of bytes */ +char* bin2hex(char *dst, const char *str, int count); +/* Convert "xxxxxxxx" hex string to binary, no more than COUNT bytes */ +char* hex2bin(char *dst, const char *str, int count); +#ifdef __cplusplus +} +#endif + /* Returns command line of running program. * Caller is responsible to free() the returned value. * If the pid is not valid or command line can not be obtained, diff -x '*.po' -d -urpN abrt.0/lib/Plugins/CCpp.cpp abrt.1/lib/Plugins/CCpp.cpp --- abrt.0/lib/Plugins/CCpp.cpp 2010-11-22 14:49:46.000000000 +0100 +++ abrt.1/lib/Plugins/CCpp.cpp 2011-01-06 15:20:04.803436707 +0100 @@ -39,15 +39,27 @@ using namespace std; #define CORE_PATTERN_IFACE "/proc/sys/kernel/core_pattern" -#define CORE_PATTERN "|"CCPP_HOOK_PATH" "DEBUG_DUMPS_DIR" %p %s %u %c" +/* + * %s - signal number + * %c - ulimit -c value + * %p - pid + * %u - uid + * %g - gid + * %t - UNIX time of dump + * %h - hostname + * %e - executable filename + * %% - output one "%" + */ +#define CORE_PATTERN "|"CCPP_HOOK_PATH" "DEBUG_DUMPS_DIR" %s %c %p %u %g %t %h %e" + #define CORE_PIPE_LIMIT_IFACE "/proc/sys/kernel/core_pipe_limit" /* core_pipe_limit specifies how many dump_helpers might run at the same time -0 - means unlimited, but the it's not guaranteed that /proc/<pid> of crashing -process might not be available for dump_helper -4 - means that 4 dump_helpers can run at the same time, which should be enough -for ABRT, we can miss some crashes, but what are the odds that more processes -crash at the same time? This value has been recommended by nhorman -*/ + * 0 - means unlimited, but the it's not guaranteed that /proc/<pid> + * of crashing process will be available for dump_helper + * 4 - means that 4 dump_helpers can run at the same time, which should be enough + * for ABRT, we can miss some crashes, but what are the odds that more processes + * crash at the same time? This value has been recommended by nhorman + */ #define CORE_PIPE_LIMIT "4" #define DEBUGINFO_CACHE_DIR LOCALSTATEDIR"/cache/abrt-di" @@ -796,7 +808,7 @@ void CAnalyzerCCpp::Init() } if (m_sOldCorePattern[0] == '|') { - if (m_sOldCorePattern == CORE_PATTERN) + if (strncmp(m_sOldCorePattern.c_str(), CORE_PATTERN, strlen(CORE_PATTERN)) == 0) { log("warning: %s already contains %s, " "did abrt daemon crash recently?", @@ -820,14 +832,35 @@ void CAnalyzerCCpp::Init() fp = fopen(CORE_PATTERN_IFACE, "w"); if (fp) { - fputs(CORE_PATTERN, fp); + if (m_sOldCorePattern[0] != '|') + { + const char *old = m_sOldCorePattern.c_str(); + unsigned len = strchrnul(old, '\n') - old; + char *hex_old = (char*)xmalloc(len * 2 + 1); + bin2hex(hex_old, old, len)[0] = '\0'; + /* Trailing 00 is a sentinel. Decoder in the hook will check it. + * If it won't see it, then kernel has truncated the argument: + */ + char *pattern = xasprintf("%s %s00", CORE_PATTERN, hex_old); + //log("old:'%s'->'%s'", old, hex_old); + //log("pattern:'%s'", pattern); + + fputs(pattern, fp); + + free(pattern); + free(hex_old); + } + else + { + fputs(CORE_PATTERN, fp); + } fclose(fp); } /* read the core_pipe_limit and change it if it's == 0 - otherwise the abrt-hook-ccpp won't be able to read /proc/<pid> - of the crashing process - */ + * otherwise the abrt-hook-ccpp won't be able to read /proc/<pid> + * of the crashing process + */ fp = fopen(CORE_PIPE_LIMIT_IFACE, "r"); if (fp) { diff -x '*.po' -d -urpN abrt.0/lib/Utils/binhex.cpp abrt.1/lib/Utils/binhex.cpp --- abrt.0/lib/Utils/binhex.cpp 1970-01-01 01:00:00.000000000 +0100 +++ abrt.1/lib/Utils/binhex.cpp 2011-01-06 13:11:53.000000000 +0100 @@ -0,0 +1,74 @@ +/* + Copyright (C) 2010 ABRT team + Copyright (C) 2010 RedHat Inc + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License version 2 + as published by the Free Software Foundation. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ +#include "abrtlib.h" + +static const char hexdigits_locase[] = "0123456789abcdef"; + +/* Emit a string of hex representation of bytes */ +char *bin2hex(char *dst, const char *str, int count) +{ + while (count) { + unsigned char c = *str++; + /* put lowercase hex digits */ + *dst++ = hexdigits_locase[c >> 4]; + *dst++ = hexdigits_locase[c & 0xf]; + count--; + } + return dst; +} + +/* Convert "xxxxxxxx" hex string to binary, no more than COUNT bytes */ +char *hex2bin(char *dst, const char *str, int count) +{ + /* Parts commented out with // allow parsing + * of strings like "xx:x:x:xx:xx:xx:xxxxxx" + * (IPv6, ethernet addresses and the like). + */ + errno = EINVAL; + while (*str && count) { + uint8_t val; + uint8_t c; + + c = *str++; + if (isdigit(c)) + val = c - '0'; + else if ((c|0x20) >= 'a' && (c|0x20) <= 'f') + val = (c|0x20) - ('a' - 10); + else + return NULL; + val <<= 4; + c = *str; + if (isdigit(c)) + val |= c - '0'; + else if ((c|0x20) >= 'a' && (c|0x20) <= 'f') + val |= (c|0x20) - ('a' - 10); + //else if (c == ':' || c == '\0') + // val >>= 4; + else + return NULL; + + *dst++ = val; + //if (c != '\0') + str++; + //if (*str == ':') + // str++; + count--; + } + errno = (*str ? ERANGE : 0); + return dst; +} diff -x '*.po' -d -urpN abrt.0/lib/Utils/Makefile.am abrt.1/lib/Utils/Makefile.am --- abrt.0/lib/Utils/Makefile.am 2011-01-06 13:10:44.000000000 +0100 +++ abrt.1/lib/Utils/Makefile.am 2011-01-06 13:19:29.000000000 +0100 @@ -12,6 +12,7 @@ AM_YFLAGS = --verbose libABRTUtils_la_SOURCES = \ xfuncs.cpp \ encbase64.cpp \ + binhex.cpp \ stdio_helpers.cpp \ read_write.cpp \ logging.cpp \ diff -x '*.po' -d -urpN abrt.0/src/Hooks/abrt-hook-ccpp.cpp abrt.1/src/Hooks/abrt-hook-ccpp.cpp --- abrt.0/src/Hooks/abrt-hook-ccpp.cpp 2010-11-22 14:49:46.000000000 +0100 +++ abrt.1/src/Hooks/abrt-hook-ccpp.cpp 2011-01-06 15:24:14.421186221 +0100 @@ -166,9 +166,22 @@ static char* get_cwd(pid_t pid) return malloc_readlink(buf); } -static char core_basename[sizeof("core.%lu") + sizeof(long)*3] = "core"; +/* + * %s - signal number + * %c - ulimit -c value + * %p - pid + * %u - uid + * %g - gid + * %t - UNIX time of dump + * %h - hostname + * %e - executable filename + * %% - output one "%" + */ +/* Must match CORE_PATTERN order in daemon! */ +static const char percent_specifiers[] = "%scpugthe"; +static char *core_basename = "core"; -static int open_user_core(const char *user_pwd, uid_t uid, pid_t pid) +static int open_user_core(const char *user_pwd, uid_t uid, pid_t pid, char **percent_values) { struct passwd* pw = getpwuid(uid); gid_t gid = pw ? pw->pw_gid : uid; @@ -183,20 +196,63 @@ static int open_user_core(const char *us return -1; } - /* Mimic "core.PID" if requested */ - char buf[] = "0\n"; - int fd = open("/proc/sys/kernel/core_uses_pid", O_RDONLY); - if (fd >= 0) + if (strcmp(core_basename, "core") == 0) { - read(fd, buf, sizeof(buf)); - close(fd); + /* Mimic "core.PID" if requested */ + char buf[] = "0\n"; + int fd = open("/proc/sys/kernel/core_uses_pid", O_RDONLY); + if (fd >= 0) + { + read(fd, buf, sizeof(buf)); + close(fd); + } + if (strcmp(buf, "1\n") == 0) + { + core_basename = xasprintf("%s.%lu", core_basename, (long)pid); + } } - if (strcmp(buf, "1\n") == 0) + else { - sprintf(core_basename, "core.%lu", (long)pid); + /* Expand old core pattern, put expanded name in core_basename */ + core_basename = xstrdup(core_basename); + unsigned idx = 0; + while (1) + { + char c = core_basename[idx]; + if (!c) + break; + idx++; + if (c != '%') + continue; + + /* We just copied %, look at following char and expand %c */ + c = core_basename[idx]; + unsigned specifier_num = strchrnul(percent_specifiers, c) - percent_specifiers; + if (percent_specifiers[specifier_num] != '\0') /* valid %c (might be %% too) */ + { + const char *val = "%"; + if (specifier_num > 0) /* not %% */ + val = percent_values[specifier_num - 1]; + //log("c:'%c'", c); + //log("val:'%s'", val); + + /* Replace %c at core_basename[idx] by its value */ + idx--; + char *old = core_basename; + core_basename = xasprintf("%.*s%s%s", idx, core_basename, val, core_basename + idx + 2); + //log("pos:'%*s|'", idx, ""); + //log("new:'%s'", core_basename); + //log("old:'%s'", old); + free(old); + idx += strlen(val); + } + /* else: invalid %c, % is already copied verbatim, + * next loop iteration will copy c */ + } } - /* man core: + /* Open (create) compat core file. + * man core: * There are various circumstances in which a core dump file * is not produced: * @@ -214,8 +270,7 @@ static int open_user_core(const char *us * * The RLIMIT_CORE or RLIMIT_FSIZE resource limits for the process * are set to zero. - * [shouldn't it be checked by kernel? 2.6.30.9-96 doesn't, still - * calls us even if "ulimit -c 0"] + * [we check RLIMIT_CORE, but how can we check RLIMIT_FSIZE?] * * The binary being executed by the process does not have * read permission enabled. [how we can check it here?] @@ -226,7 +281,6 @@ static int open_user_core(const char *us * (However, see the description of the prctl(2) PR_SET_DUMPABLE operation, * and the description of the /proc/sys/fs/suid_dumpable file in proc(5).) */ - /* Do not O_TRUNC: if later checks fail, we do not want to have file already modified here */ struct stat sb; errno = 0; @@ -245,6 +299,7 @@ static int open_user_core(const char *us if (ftruncate(user_core_fd, 0) != 0) { /* perror first, otherwise unlink may trash errno */ perror_msg("truncate %s/%s", user_pwd, core_basename); + unlink(core_basename); return -1; } @@ -253,23 +308,28 @@ static int open_user_core(const char *us int main(int argc, char** argv) { - int i; struct stat sb; - if (argc < 5) + if (argc < 10) /* no argv[9]? */ { - error_msg_and_die("Usage: %s: DUMPDIR PID SIGNO UID CORE_SIZE_LIMIT", argv[0]); + /* percent specifier: %s %c %p %u %g %t %h %e */ + /* argv: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] */ + error_msg_and_die("Usage: %s DUMPDIR SIGNO CORE_SIZE_LIMIT PID UID GID TIME HOSTNAME BINARY_NAME [OLD_PATTERN]", argv[0]); } /* Not needed on 2.6.30. * At least 2.6.18 has a bug where - * argv[1] = "DUMPDIR PID SIGNO UID CORE_SIZE_LIMIT" - * argv[2] = "PID SIGNO UID CORE_SIZE_LIMIT" + * argv[1] = "DUMPDIR SIGNO CORE_SIZE_LIMIT ..." + * argv[2] = "SIGNO CORE_SIZE_LIMIT ..." * and so on. Fixing it: */ - for (i = 1; argv[i]; i++) + if (strchr(argv[1], ' ')) { - strchrnul(argv[i], ' ')[0] = '\0'; + int i; + for (i = 1; argv[i]; i++) + { + strchrnul(argv[i], ' ')[0] = '\0'; + } } openlog("abrt", LOG_PID, LOG_DAEMON); @@ -277,19 +337,38 @@ int main(int argc, char** argv) errno = 0; const char* dddir = argv[1]; - pid_t pid = xatoi_u(argv[2]); - const char* signal_str = argv[3]; - int signal_no = xatoi_u(argv[3]); - uid_t uid = xatoi_u(argv[4]); - off_t ulimit_c = strtoull(argv[5], NULL, 10); + const char* signal_str = argv[2]; + int signal_no = xatoi_u(signal_str); + off_t ulimit_c = strtoull(argv[3], NULL, 10); if (ulimit_c < 0) /* unlimited? */ { /* set to max possible >0 value */ ulimit_c = ~((off_t)1 << (sizeof(off_t)*8-1)); } + pid_t pid = xatoi_u(argv[4]); + uid_t uid = xatoi_u(argv[5]); if (errno || pid <= 0) { - error_msg_and_die("pid '%s' or limit '%s' is bogus", argv[2], argv[5]); + perror_msg_and_die("pid '%s' or limit '%s' is bogus", argv[4], argv[3]); + } + if (argv[10]) /* OLD_PATTERN */ + { + char *buf = (char*) xzalloc(strlen(argv[10]) / 2 + 2); + char *end = hex2bin(buf, argv[10], strlen(argv[10])); + if (end && end > buf && end[-1] == '\0') + { + core_basename = buf; + //log("core_basename:'%s'", core_basename); + } + else + { + /* Until recently, kernels were truncating expanded core pattern. + * In this case, we end up here... + */ + error_msg("bad old pattern '%s', ignoring and using 'core'", argv[10]); + /* core_basename = "core"; - already is */ + free(buf); + } } int src_fd_binary; @@ -316,8 +395,8 @@ int main(int argc, char** argv) /* Open a fd to compat coredump, if requested and is possible */ int user_core_fd = -1; if (setting_MakeCompatCore && ulimit_c != 0) - /* note: checks "user_pwd == NULL" inside */ - user_core_fd = open_user_core(user_pwd, uid, pid); + /* note: checks "user_pwd == NULL" inside, updates core_basename */ + user_core_fd = open_user_core(user_pwd, uid, pid, &argv[2]); if (executable == NULL) {