/builddir/build/BUILD/libutil++-1.4.0/src/sella/util/Process.cpp

/*
** libutil++
** $Id: Process.cpp 1197 2014-10-14 22:26:11Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: Process.cpp 1197 2014-10-14 22:26:11Z sella $";

#include "Process.h"
#include "CommonMacro.h"
#include "String.h"

#include <limits.h>
#include <libgen.h>
#include <unistd.h>
#include <sys/types.h>
#include <execinfo.h>
#include <stdlib.h>
#include <sys/prctl.h>

#ifdef __GNUG__
        #include <cxxabi.h>
#endif

#define BUFFER_SIZE (1024 * 32)

using namespace sella::util;

std::string Process::getBaseName(void) throw () {
        std::string path = getPath();

        if (path.empty()) {
                return path;
        }

        return path.substr(path.rfind('/') + 1);
}

std::string Process::getDirName(void) throw () {
        std::string path = getPath();

        if (path.empty()) {
                return path;
        }

        return path.substr(0, path.rfind('/'));
}

std::string Process::getPath(void) throw () {
        std::string path;
        char *buf = (char*) malloc(PATH_MAX);

        if (buf != NULL) {
                memset(buf, 0, PATH_MAX);

                if (readlink("/proc/self/exe", buf, PATH_MAX - 1) != -1) {
                        path = buf;
                }

                SAFE_FREE(buf);
        }

        return path;
}

void Process::setName(const std::string &name) throw (ProcessException) {
#ifdef PR_SET_NAME
        char buf[17]; /* Max length of 16 */

        memset(buf, 0, sizeof(buf));
        strncpy(buf, name.c_str(), sizeof(buf) - 1);

        if (prctl(PR_SET_NAME, (unsigned long) buf, 0, 0, 0) != 0) {
                THROW2(ProcessException, "prctl");
        }
#endif
}

std::string Process::getName(void) throw (ProcessException) {
        char buf[17]; /* Max length of 16 */

#ifdef PR_GET_NAME
        memset(buf, 0, sizeof(buf));

        if (prctl(PR_GET_NAME, (unsigned long) buf, 0, 0, 0) != 0) {
                THROW2(ProcessException, "prctl");
        }
#endif

        return std::string(buf);
}

void Process::setTitle(const std::string &title) throw (ProcessException) {

}

pid_t Process::getPID(void) throw () {
        return getpid();
}

pid_t Process::getParentPID(void) throw () {
        return getppid();
}

std::string Process::runCommand(const std::string &command) throw (ProcessException) {
        std::string output;
        FILE *fp;

        if ((fp = popen(command.c_str(), "r"))) {
                char buf[4096];

                while (fgets(buf, sizeof(buf) - 1, fp)) {
                        output += buf;
                }

                pclose(fp);
        } else {
                THROW2(ProcessException, "popen");
        }

        return output;
}

std::string Process::stackTrace(const std::string &executableFilename) throw () {
        size_t maxFrames = 63;
        void *frames[maxFrames + 1];
        int size = backtrace(frames, sizeof(frames) / sizeof(frames[0]));
        char **symbols = backtrace_symbols(frames, size);

        std::string stack;
        size_t funcnamesize = 256;
        char* funcname = (char*) malloc(funcnamesize);

        for (int i = 1; i < size; i++) {
                char *begin_name = 0, *begin_offset = 0, *end_offset = 0, *begin_address = 0, *end_address = 0;

                for (char *p = symbols[i]; *p; ++p) {
                        if (*p == '(') {
                                begin_name = p;
                        } else if (*p == '+') {
                                begin_offset = p;
                        } else if (*p == ')') {
                                end_offset = p;
                        } else if (*p == '[' && end_offset) {
                                begin_address = p;
                        } else if (*p == '[') {
                                begin_address = p;
                                begin_offset = p - 3;
                        } else if (*p == ']' && begin_address) {
                                end_address = p;

                                break;
                        }
                }

                if (begin_name && begin_offset && end_offset && begin_address && end_address && begin_name < begin_offset) {
                        *begin_name++ = '\0';
                        *begin_offset++ = '\0';
                        *end_offset = '\0';
                        *begin_address++ = '\0';
                        *end_address = '\0';

                        void *ptr = (void*) strtol(begin_address + 2, NULL, 16);
                        FILE *fp;
                        std::string command = String::sprintf("/usr/bin/addr2line -i -s -e %s %s 2> /dev/null", executableFilename.c_str(), begin_address);
                        std::vector<std::string> matches;

                        if ((fp = popen(command.c_str(), "r"))) { /* Use adddr2line to find file and line number */
                                char buf[1024] = { 0 };

                                while (fgets(buf, sizeof(buf) - 1, fp)) { } /* We only want the last line. */
                                String::regex_match(buf, "^([^:]+):([1-9][0-9]*).*?$", matches);

                                pclose(fp);
                        }

                        int status = -2;
#ifdef __GNUG__
                        char* ret = abi::__cxa_demangle(begin_name, funcname, &funcnamesize, &status);
#else
                        char* ret = NULL;
#endif

                        if (status == 0) {
                                funcname = ret; /* see man - use possibly realloc'd string */

                                if (matches.empty()) {
                                        stack += String::sprintf("#%-2d %012p in %s from %s\n", i, ptr, funcname, symbols[i]);
                                } else {
                                        stack += String::sprintf("#%-2d %012p in %s at %s:%s\n", i, ptr, funcname, matches[1].c_str(), matches[2].c_str());
                                }
                        } else { /* No demangle available */
                                if (matches.empty()) {
                                        stack += String::sprintf("#%-2d %012p in %s() from %s\n", i, ptr, begin_name, symbols[i]);
                                } else {
                                        stack += String::sprintf("#%-2d %012p in %s() at %s:%s\n", i, ptr, begin_name, matches[1].c_str(), matches[2].c_str());
                                }
                        }
                } else if (begin_name && begin_address && end_address) {
                        *begin_name++ = '\0';
                        *begin_address++ = '\0';
                        *end_address = '\0';

                        void *ptr = (void*) strtol(begin_address + 2, NULL, 16);

                        stack += String::sprintf("#%-2d %012p in \?\?() from %s\n", i, ptr, symbols[i]);
                } else { // couldn't parse the line? print the whole line.
                        stack += String::sprintf("#%-2d %012p in %s\n", i, 0, symbols[i]);
                }
        }

        stack.erase(stack.size() - 1);

        free(funcname);
        free(symbols);

        return stack;
}

/*
** vim: noet ts=3 sw=3
*/

---