f3d61de532
This change does the following:
* enables building lldb-gdbserver on linux_x86-64 platforms.
Note - it builds but it has several run-time issues where many gdb
remote protocol features are not properly implemented yet. I'm
working on these one at a time.
* lldb-gdbserver: does not enable the eLaunchFlagDebug launch flag on
Linux. Currently the POSIX launch routine will assert if that flag
is passed in, presumably because that launch mode is not yet
available. This prevents lldb-gdbserver from asserting the moment
it launches the debuggee process.
* Adds ConstString& Host::GetDistributionId ()
This method is defined to return an empty result on all platforms
except for Linux. On Linux, it makes one attempt to execute
'lsb_release -i' (both /usr/bin/lsb_release, where it appears
on ubuntu, and /bin/lsb_release, where it appears on fedora
if the redhat-lsb package is installed). If lsb_release is not
found in either of those locations, or if 'lsb_release -i' does
not return the first line starting with "Distributor ID:\t",
then the distribution id is empty. The method will lower-case
the id and replace whitespace with underscores.
* Modify Host::GetArchitecture () so that linux replaces an unknown
vendor portion with the results of GetDistributionId () if that
is non-empty. This shows up now in qHostInfo remote packet
responses and on the lldb host side. Tested with ubuntu and
fedora (the latter both with the default of not having lsb_release
installed, and with having lsb_release installed via the redhat-lsb
package).
Examples of triples on Linux after this change:
# x86_64 Unbuntu 12.04 LTS:
x86_64-ubuntu-linux-gnu
# x86_64 Fedora 20 Desktop with redhat-lsb package installed
x86_64-fedora-linux-gnu
# x86_64 Fedora 20 Desktop without redhat-lsb-core installed
# (i.e. no /bin/lsb_release available)
# same as before the change
x86_64--linux-gnu
Note I intend to have Android respond with:
{arch}-android-linux
when I get to implementing Android lldb-gdbserver support.
llvm-svn: 199510
609 lines
19 KiB
C++
609 lines
19 KiB
C++
//===-- source/Host/linux/Host.cpp ------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// C Includes
|
|
#include <stdio.h>
|
|
#include <sys/utsname.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <dirent.h>
|
|
#include <fcntl.h>
|
|
#include <execinfo.h>
|
|
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/Core/Error.h"
|
|
#include "lldb/Core/Log.h"
|
|
#include "lldb/Target/Process.h"
|
|
|
|
#include "lldb/Host/Host.h"
|
|
#include "lldb/Core/DataBufferHeap.h"
|
|
#include "lldb/Core/DataExtractor.h"
|
|
|
|
#include "lldb/Core/ModuleSpec.h"
|
|
#include "lldb/Symbol/ObjectFile.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
typedef enum ProcessStateFlags
|
|
{
|
|
eProcessStateRunning = (1u << 0), // Running
|
|
eProcessStateSleeping = (1u << 1), // Sleeping in an interruptible wait
|
|
eProcessStateWaiting = (1u << 2), // Waiting in an uninterruptible disk sleep
|
|
eProcessStateZombie = (1u << 3), // Zombie
|
|
eProcessStateTracedOrStopped = (1u << 4), // Traced or stopped (on a signal)
|
|
eProcessStatePaging = (1u << 5) // Paging
|
|
} ProcessStateFlags;
|
|
|
|
typedef struct ProcessStatInfo
|
|
{
|
|
lldb::pid_t ppid; // Parent Process ID
|
|
uint32_t fProcessState; // ProcessStateFlags
|
|
} ProcessStatInfo;
|
|
|
|
// Get the process info with additional information from /proc/$PID/stat (like process state, and tracer pid).
|
|
static bool GetProcessAndStatInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info, ProcessStatInfo &stat_info, lldb::pid_t &tracerpid);
|
|
|
|
|
|
namespace
|
|
{
|
|
|
|
lldb::DataBufferSP
|
|
ReadProcPseudoFile (lldb::pid_t pid, const char *name)
|
|
{
|
|
int fd;
|
|
char path[PATH_MAX];
|
|
|
|
// Make sure we've got a nil terminated buffer for all the folks calling
|
|
// GetBytes() directly off our returned DataBufferSP if we hit an error.
|
|
lldb::DataBufferSP buf_sp (new DataBufferHeap(1, 0));
|
|
|
|
// Ideally, we would simply create a FileSpec and call ReadFileContents.
|
|
// However, files in procfs have zero size (since they are, in general,
|
|
// dynamically generated by the kernel) which is incompatible with the
|
|
// current ReadFileContents implementation. Therefore we simply stream the
|
|
// data into a DataBuffer ourselves.
|
|
if (snprintf (path, PATH_MAX, "/proc/%" PRIu64 "/%s", pid, name) > 0)
|
|
{
|
|
if ((fd = open (path, O_RDONLY, 0)) >= 0)
|
|
{
|
|
size_t bytes_read = 0;
|
|
std::unique_ptr<DataBufferHeap> buf_ap(new DataBufferHeap(1024, 0));
|
|
|
|
for (;;)
|
|
{
|
|
size_t avail = buf_ap->GetByteSize() - bytes_read;
|
|
ssize_t status = read (fd, buf_ap->GetBytes() + bytes_read, avail);
|
|
|
|
if (status < 0)
|
|
break;
|
|
|
|
if (status == 0)
|
|
{
|
|
buf_ap->SetByteSize (bytes_read);
|
|
buf_sp.reset (buf_ap.release());
|
|
break;
|
|
}
|
|
|
|
bytes_read += status;
|
|
|
|
if (avail - status == 0)
|
|
buf_ap->SetByteSize (2 * buf_ap->GetByteSize());
|
|
}
|
|
|
|
close (fd);
|
|
}
|
|
}
|
|
|
|
return buf_sp;
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
static bool
|
|
ReadProcPseudoFileStat (lldb::pid_t pid, ProcessStatInfo& stat_info)
|
|
{
|
|
// Read the /proc/$PID/stat file.
|
|
lldb::DataBufferSP buf_sp = ReadProcPseudoFile (pid, "stat");
|
|
|
|
// The filename of the executable is stored in parenthesis right after the pid. We look for the closing
|
|
// parenthesis for the filename and work from there in case the name has something funky like ')' in it.
|
|
const char *filename_end = strrchr ((const char *)buf_sp->GetBytes(), ')');
|
|
if (filename_end)
|
|
{
|
|
char state = '\0';
|
|
int ppid = LLDB_INVALID_PROCESS_ID;
|
|
|
|
// Read state and ppid.
|
|
sscanf (filename_end + 1, " %c %d", &state, &ppid);
|
|
|
|
stat_info.ppid = ppid;
|
|
|
|
switch (state)
|
|
{
|
|
case 'R':
|
|
stat_info.fProcessState |= eProcessStateRunning;
|
|
break;
|
|
case 'S':
|
|
stat_info.fProcessState |= eProcessStateSleeping;
|
|
break;
|
|
case 'D':
|
|
stat_info.fProcessState |= eProcessStateWaiting;
|
|
break;
|
|
case 'Z':
|
|
stat_info.fProcessState |= eProcessStateZombie;
|
|
break;
|
|
case 'T':
|
|
stat_info.fProcessState |= eProcessStateTracedOrStopped;
|
|
break;
|
|
case 'W':
|
|
stat_info.fProcessState |= eProcessStatePaging;
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static void
|
|
GetLinuxProcessUserAndGroup (lldb::pid_t pid, ProcessInstanceInfo &process_info, lldb::pid_t &tracerpid)
|
|
{
|
|
tracerpid = 0;
|
|
uint32_t rUid = UINT32_MAX; // Real User ID
|
|
uint32_t eUid = UINT32_MAX; // Effective User ID
|
|
uint32_t rGid = UINT32_MAX; // Real Group ID
|
|
uint32_t eGid = UINT32_MAX; // Effective Group ID
|
|
|
|
// Read the /proc/$PID/status file and parse the Uid:, Gid:, and TracerPid: fields.
|
|
lldb::DataBufferSP buf_sp = ReadProcPseudoFile (pid, "status");
|
|
|
|
static const char uid_token[] = "Uid:";
|
|
char *buf_uid = strstr ((char *)buf_sp->GetBytes(), uid_token);
|
|
if (buf_uid)
|
|
{
|
|
// Real, effective, saved set, and file system UIDs. Read the first two.
|
|
buf_uid += sizeof(uid_token);
|
|
rUid = strtol (buf_uid, &buf_uid, 10);
|
|
eUid = strtol (buf_uid, &buf_uid, 10);
|
|
}
|
|
|
|
static const char gid_token[] = "Gid:";
|
|
char *buf_gid = strstr ((char *)buf_sp->GetBytes(), gid_token);
|
|
if (buf_gid)
|
|
{
|
|
// Real, effective, saved set, and file system GIDs. Read the first two.
|
|
buf_gid += sizeof(gid_token);
|
|
rGid = strtol (buf_gid, &buf_gid, 10);
|
|
eGid = strtol (buf_gid, &buf_gid, 10);
|
|
}
|
|
|
|
static const char tracerpid_token[] = "TracerPid:";
|
|
char *buf_tracerpid = strstr((char *)buf_sp->GetBytes(), tracerpid_token);
|
|
if (buf_tracerpid)
|
|
{
|
|
// Tracer PID. 0 if we're not being debugged.
|
|
buf_tracerpid += sizeof(tracerpid_token);
|
|
tracerpid = strtol (buf_tracerpid, &buf_tracerpid, 10);
|
|
}
|
|
|
|
process_info.SetUserID (rUid);
|
|
process_info.SetEffectiveUserID (eUid);
|
|
process_info.SetGroupID (rGid);
|
|
process_info.SetEffectiveGroupID (eGid);
|
|
}
|
|
|
|
bool
|
|
Host::GetOSVersion(uint32_t &major,
|
|
uint32_t &minor,
|
|
uint32_t &update)
|
|
{
|
|
struct utsname un;
|
|
int status;
|
|
|
|
if (uname(&un))
|
|
return false;
|
|
|
|
status = sscanf(un.release, "%u.%u.%u", &major, &minor, &update);
|
|
if (status == 3)
|
|
return true;
|
|
|
|
// Some kernels omit the update version, so try looking for just "X.Y" and
|
|
// set update to 0.
|
|
update = 0;
|
|
status = sscanf(un.release, "%u.%u", &major, &minor);
|
|
return status == 2;
|
|
}
|
|
|
|
lldb::DataBufferSP
|
|
Host::GetAuxvData(lldb_private::Process *process)
|
|
{
|
|
return ReadProcPseudoFile(process->GetID(), "auxv");
|
|
}
|
|
|
|
static bool
|
|
IsDirNumeric(const char *dname)
|
|
{
|
|
for (; *dname; dname++)
|
|
{
|
|
if (!isdigit (*dname))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
uint32_t
|
|
Host::FindProcesses (const ProcessInstanceInfoMatch &match_info, ProcessInstanceInfoList &process_infos)
|
|
{
|
|
static const char procdir[] = "/proc/";
|
|
|
|
DIR *dirproc = opendir (procdir);
|
|
if (dirproc)
|
|
{
|
|
struct dirent *direntry = NULL;
|
|
const uid_t our_uid = getuid();
|
|
const lldb::pid_t our_pid = getpid();
|
|
bool all_users = match_info.GetMatchAllUsers();
|
|
|
|
while ((direntry = readdir (dirproc)) != NULL)
|
|
{
|
|
if (direntry->d_type != DT_DIR || !IsDirNumeric (direntry->d_name))
|
|
continue;
|
|
|
|
lldb::pid_t pid = atoi (direntry->d_name);
|
|
|
|
// Skip this process.
|
|
if (pid == our_pid)
|
|
continue;
|
|
|
|
lldb::pid_t tracerpid;
|
|
ProcessStatInfo stat_info;
|
|
ProcessInstanceInfo process_info;
|
|
|
|
if (!GetProcessAndStatInfo (pid, process_info, stat_info, tracerpid))
|
|
continue;
|
|
|
|
// Skip if process is being debugged.
|
|
if (tracerpid != 0)
|
|
continue;
|
|
|
|
// Skip zombies.
|
|
if (stat_info.fProcessState & eProcessStateZombie)
|
|
continue;
|
|
|
|
// Check for user match if we're not matching all users and not running as root.
|
|
if (!all_users && (our_uid != 0) && (process_info.GetUserID() != our_uid))
|
|
continue;
|
|
|
|
if (match_info.Matches (process_info))
|
|
{
|
|
process_infos.Append (process_info);
|
|
}
|
|
}
|
|
|
|
closedir (dirproc);
|
|
}
|
|
|
|
return process_infos.GetSize();
|
|
}
|
|
|
|
bool
|
|
Host::FindProcessThreads (const lldb::pid_t pid, TidMap &tids_to_attach)
|
|
{
|
|
bool tids_changed = false;
|
|
static const char procdir[] = "/proc/";
|
|
static const char taskdir[] = "/task/";
|
|
std::string process_task_dir = procdir + std::to_string(pid) + taskdir;
|
|
DIR *dirproc = opendir (process_task_dir.c_str());
|
|
|
|
if (dirproc)
|
|
{
|
|
struct dirent *direntry = NULL;
|
|
while ((direntry = readdir (dirproc)) != NULL)
|
|
{
|
|
if (direntry->d_type != DT_DIR || !IsDirNumeric (direntry->d_name))
|
|
continue;
|
|
|
|
lldb::tid_t tid = atoi(direntry->d_name);
|
|
TidMap::iterator it = tids_to_attach.find(tid);
|
|
if (it == tids_to_attach.end())
|
|
{
|
|
tids_to_attach.insert(TidPair(tid, false));
|
|
tids_changed = true;
|
|
}
|
|
}
|
|
closedir (dirproc);
|
|
}
|
|
|
|
return tids_changed;
|
|
}
|
|
|
|
static bool
|
|
GetELFProcessCPUType (const char *exe_path, ProcessInstanceInfo &process_info)
|
|
{
|
|
// Clear the architecture.
|
|
process_info.GetArchitecture().Clear();
|
|
|
|
ModuleSpecList specs;
|
|
FileSpec filespec (exe_path, false);
|
|
const size_t num_specs = ObjectFile::GetModuleSpecifications (filespec, 0, 0, specs);
|
|
// GetModuleSpecifications() could fail if the executable has been deleted or is locked.
|
|
// But it shouldn't return more than 1 architecture.
|
|
assert(num_specs <= 1 && "Linux plugin supports only a single architecture");
|
|
if (num_specs == 1)
|
|
{
|
|
ModuleSpec module_spec;
|
|
if (specs.GetModuleSpecAtIndex (0, module_spec) && module_spec.GetArchitecture().IsValid())
|
|
{
|
|
process_info.GetArchitecture () = module_spec.GetArchitecture();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool
|
|
GetProcessAndStatInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info, ProcessStatInfo &stat_info, lldb::pid_t &tracerpid)
|
|
{
|
|
tracerpid = 0;
|
|
process_info.Clear();
|
|
::memset (&stat_info, 0, sizeof(stat_info));
|
|
stat_info.ppid = LLDB_INVALID_PROCESS_ID;
|
|
|
|
// Use special code here because proc/[pid]/exe is a symbolic link.
|
|
char link_path[PATH_MAX];
|
|
char exe_path[PATH_MAX] = "";
|
|
if (snprintf (link_path, PATH_MAX, "/proc/%" PRIu64 "/exe", pid) <= 0)
|
|
return false;
|
|
|
|
ssize_t len = readlink (link_path, exe_path, sizeof(exe_path) - 1);
|
|
if (len <= 0)
|
|
return false;
|
|
|
|
// readlink does not append a null byte.
|
|
exe_path[len] = 0;
|
|
|
|
// If the binary has been deleted, the link name has " (deleted)" appended.
|
|
// Remove if there.
|
|
static const ssize_t deleted_len = strlen(" (deleted)");
|
|
if (len > deleted_len &&
|
|
!strcmp(exe_path + len - deleted_len, " (deleted)"))
|
|
{
|
|
exe_path[len - deleted_len] = 0;
|
|
}
|
|
else
|
|
{
|
|
GetELFProcessCPUType (exe_path, process_info);
|
|
}
|
|
|
|
process_info.SetProcessID(pid);
|
|
process_info.GetExecutableFile().SetFile(exe_path, false);
|
|
|
|
lldb::DataBufferSP buf_sp;
|
|
|
|
// Get the process environment.
|
|
buf_sp = ReadProcPseudoFile(pid, "environ");
|
|
Args &info_env = process_info.GetEnvironmentEntries();
|
|
char *next_var = (char *)buf_sp->GetBytes();
|
|
char *end_buf = next_var + buf_sp->GetByteSize();
|
|
while (next_var < end_buf && 0 != *next_var)
|
|
{
|
|
info_env.AppendArgument(next_var);
|
|
next_var += strlen(next_var) + 1;
|
|
}
|
|
|
|
// Get the commond line used to start the process.
|
|
buf_sp = ReadProcPseudoFile(pid, "cmdline");
|
|
|
|
// Grab Arg0 first, if there is one.
|
|
char *cmd = (char *)buf_sp->GetBytes();
|
|
if (cmd)
|
|
{
|
|
process_info.SetArg0(cmd);
|
|
|
|
// Now process any remaining arguments.
|
|
Args &info_args = process_info.GetArguments();
|
|
char *next_arg = cmd + strlen(cmd) + 1;
|
|
end_buf = cmd + buf_sp->GetByteSize();
|
|
while (next_arg < end_buf && 0 != *next_arg)
|
|
{
|
|
info_args.AppendArgument(next_arg);
|
|
next_arg += strlen(next_arg) + 1;
|
|
}
|
|
}
|
|
|
|
// Read /proc/$PID/stat to get our parent pid.
|
|
if (ReadProcPseudoFileStat (pid, stat_info))
|
|
{
|
|
process_info.SetParentProcessID (stat_info.ppid);
|
|
}
|
|
|
|
// Get User and Group IDs and get tracer pid.
|
|
GetLinuxProcessUserAndGroup (pid, process_info, tracerpid);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
Host::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info)
|
|
{
|
|
lldb::pid_t tracerpid;
|
|
ProcessStatInfo stat_info;
|
|
|
|
return GetProcessAndStatInfo (pid, process_info, stat_info, tracerpid);
|
|
}
|
|
|
|
void
|
|
Host::ThreadCreated (const char *thread_name)
|
|
{
|
|
if (!Host::SetThreadName (LLDB_INVALID_PROCESS_ID, LLDB_INVALID_THREAD_ID, thread_name))
|
|
{
|
|
Host::SetShortThreadName (LLDB_INVALID_PROCESS_ID, LLDB_INVALID_THREAD_ID, thread_name, 16);
|
|
}
|
|
}
|
|
|
|
std::string
|
|
Host::GetThreadName (lldb::pid_t pid, lldb::tid_t tid)
|
|
{
|
|
assert(pid != LLDB_INVALID_PROCESS_ID);
|
|
assert(tid != LLDB_INVALID_THREAD_ID);
|
|
|
|
// Read /proc/$TID/comm file.
|
|
lldb::DataBufferSP buf_sp = ReadProcPseudoFile (tid, "comm");
|
|
const char *comm_str = (const char *)buf_sp->GetBytes();
|
|
const char *cr_str = ::strchr(comm_str, '\n');
|
|
size_t length = cr_str ? (cr_str - comm_str) : strlen(comm_str);
|
|
|
|
std::string thread_name(comm_str, length);
|
|
return thread_name;
|
|
}
|
|
|
|
void
|
|
Host::Backtrace (Stream &strm, uint32_t max_frames)
|
|
{
|
|
if (max_frames > 0)
|
|
{
|
|
std::vector<void *> frame_buffer (max_frames, NULL);
|
|
int num_frames = ::backtrace (&frame_buffer[0], frame_buffer.size());
|
|
char** strs = ::backtrace_symbols (&frame_buffer[0], num_frames);
|
|
if (strs)
|
|
{
|
|
// Start at 1 to skip the "Host::Backtrace" frame
|
|
for (int i = 1; i < num_frames; ++i)
|
|
strm.Printf("%s\n", strs[i]);
|
|
::free (strs);
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t
|
|
Host::GetEnvironment (StringList &env)
|
|
{
|
|
char **host_env = environ;
|
|
char *env_entry;
|
|
size_t i;
|
|
for (i=0; (env_entry = host_env[i]) != NULL; ++i)
|
|
env.AppendString(env_entry);
|
|
return i;
|
|
}
|
|
|
|
const ConstString &
|
|
Host::GetDistributionId ()
|
|
{
|
|
// Try to run 'lbs_release -i', and use that response
|
|
// for the distribution id.
|
|
|
|
static bool s_evaluated;
|
|
static ConstString s_distribution_id;
|
|
|
|
if (!s_evaluated)
|
|
{
|
|
s_evaluated = true;
|
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_HOST));
|
|
if (log)
|
|
log->Printf ("attempting to determine Linux distribution...");
|
|
|
|
// check if the lsb_release command exists at one of the
|
|
// following paths
|
|
const char *const exe_paths[] = {
|
|
"/bin/lsb_release",
|
|
"/usr/bin/lsb_release"
|
|
};
|
|
|
|
for (int exe_index = 0;
|
|
exe_index < sizeof (exe_paths) / sizeof (exe_paths[0]);
|
|
++exe_index)
|
|
{
|
|
const char *const get_distribution_info_exe = exe_paths[exe_index];
|
|
if (access (get_distribution_info_exe, F_OK))
|
|
{
|
|
// this exe doesn't exist, move on to next exe
|
|
if (log)
|
|
log->Printf ("executable doesn't exist: %s",
|
|
get_distribution_info_exe);
|
|
continue;
|
|
}
|
|
|
|
// execute the distribution-retrieval command, read output
|
|
std::string get_distribution_id_command (get_distribution_info_exe);
|
|
get_distribution_id_command += " -i";
|
|
|
|
FILE *file = popen (get_distribution_id_command.c_str (), "r");
|
|
if (!file)
|
|
{
|
|
if (log)
|
|
log->Printf (
|
|
"failed to run command: \"%s\", cannot retrieve "
|
|
"platform information",
|
|
get_distribution_id_command.c_str ());
|
|
return s_distribution_id;
|
|
}
|
|
|
|
// retrieve the distribution id string.
|
|
char distribution_id[256] = { '\0' };
|
|
if (fgets (distribution_id, sizeof (distribution_id) - 1, file)
|
|
!= NULL)
|
|
{
|
|
if (log)
|
|
log->Printf ("distribution id command returned \"%s\"",
|
|
distribution_id);
|
|
|
|
const char *const distributor_id_key = "Distributor ID:\t";
|
|
if (strstr (distribution_id, distributor_id_key))
|
|
{
|
|
// strip newlines
|
|
std::string id_string (distribution_id +
|
|
strlen (distributor_id_key));
|
|
id_string.erase(
|
|
std::remove (
|
|
id_string.begin (),
|
|
id_string.end (),
|
|
'\n'),
|
|
id_string.end ());
|
|
|
|
// lower case it and convert whitespace to underscores
|
|
std::transform (
|
|
id_string.begin(),
|
|
id_string.end (),
|
|
id_string.begin (),
|
|
[] (char ch)
|
|
{ return tolower ( isspace (ch) ? '_' : ch ); });
|
|
|
|
s_distribution_id.SetCString (id_string.c_str ());
|
|
if (log)
|
|
log->Printf ("distribion id set to \"%s\"",
|
|
s_distribution_id.GetCString ());
|
|
}
|
|
else
|
|
{
|
|
if (log)
|
|
log->Printf ("failed to find \"%s\" field in \"%s\"",
|
|
distributor_id_key, distribution_id);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (log)
|
|
log->Printf (
|
|
"failed to retrieve distribution id, \"%s\" returned no"
|
|
" lines", get_distribution_id_command.c_str ());
|
|
}
|
|
|
|
// clean up the file
|
|
pclose(file);
|
|
}
|
|
}
|
|
|
|
return s_distribution_id;
|
|
}
|