// Get the PID from the selection list in CLIENT_DATA
static int get_pid(Widget, XtPointer client_data, XtPointer)
{
IntArray pids;
Widget processes = Widget(client_data);
if (processes != 0)
getPIDs(processes, pids);
if (pids.size() == 1)
return pids[0];
else
return 0;
}
// kill previous procnannies
void killOldProcNannies() {
int numberOfProcNanniePIDs = getNumberOfPIDsForProcess("procnanny.cli");
debugPrint("found %d old procnanny clients\n", numberOfProcNanniePIDs);
while (getNumberOfPIDsForProcess("procnanny.cli") == 0) {
debugPrint("found %d old procnanny clients\n", numberOfProcNanniePIDs);
sleep(2);
}
if (numberOfProcNanniePIDs > 1) {
char * inputBuffer = malloc(150);
FILE * fp;
//printf("found %d processes of procnanny running. Commencing deletion... \n", numberOfProcNanniePIDs);
int * procNanniePIDs = malloc(numberOfProcNanniePIDs + 50);
getPIDs("procnanny.cli", procNanniePIDs, numberOfProcNanniePIDs);
// remove current pid
int currentProcPID = getpid();
int tmpCounter = 0;
for (tmpCounter = 0; tmpCounter < numberOfProcNanniePIDs; tmpCounter = tmpCounter + 1) {
if (currentProcPID != procNanniePIDs[tmpCounter]) {
snprintf(inputBuffer, 140, "kill -9 %d", procNanniePIDs[tmpCounter]);
//printf("%s \n", inputBuffer);
if ((fp = popen(inputBuffer, "r")) != NULL) {
snprintf(inputBuffer, 120, "An old procnanny.client (%d) was killed \n", procNanniePIDs[tmpCounter]);
writeToLogs("Warning", inputBuffer);
}
}
}
free(inputBuffer);
free(procNanniePIDs);
}
}
// Create list of processes
static void update_processes(Widget processes, bool keep_selection)
{
StatusDelay delay("Getting list of processes");
string cmd = sh_command(app_data.ps_command) + " 2>&1";
FILE *fp = popen(cmd.chars(), "r");
if (fp == 0)
{
delay.outcome = strerror(errno);
return;
}
StringArray all_process_list;
int c;
string line = "";
bool first_line = true;
while ((c = getc(fp)) != EOF)
{
if (c == '\n')
{
if (first_line || valid_ps_line(line, app_data.ps_command))
all_process_list += line;
#if 0
else
std::clog << "Excluded: " << line << "\n";
#endif
if (first_line)
{
// Find first occurrence of `PID' title
ps_pid_index = line.index(" PID ");
if (ps_pid_index < 0)
ps_pid_index = 0;
}
line = "";
first_line = false;
}
else
{
line += c;
}
}
pclose(fp);
sortProcesses(all_process_list);
DynIntArray pids(all_process_list.size());
// If GDB cannot send a signal to the process, we cannot debug it.
// Try a `kill -0' (via GDB, as it may be setuid) and filter out
// all processes in the `kill' diagnostic -- that is, all
// processes that `kill' could not send a signal.
string kill = "kill -0";
if (gdb->has_handler_command())
kill = "/usr/bin/kill -0"; // Bypass built-in SUN DBX command
int i;
for (i = 0; i < all_process_list.size(); i++)
{
pids[i] = ps_pid(all_process_list[i]);
if (pids[i])
kill += string(" ") + itostring(pids[i]);
}
#if defined(__sun)
// bypass underlying debugger
// Fix for Sun: use /usr/bin/kill
string kill_result;
{
std::ostringstream os;
kill += " 2>&1";
FILE *fp = popen(kill.chars(), "r");
if (fp != 0)
{
int c;
while ((c = getc(fp)) != EOF)
{
os << (char)c;
}
pclose(fp);
}
kill_result = os;
}
#else
string kill_result = gdb_question(gdb->shell_command(kill));
#endif
i = 0;
while (i >= 0)
{
i = kill_result.index(rxint, i);
if (i >= 0)
{
int bad_pid = atoi(kill_result.chars() + i);
for (int k = 0; k < all_process_list.size(); k++)
{
if (pids[k] != 0 && pids[k] == bad_pid)
{
#if 0
std::clog << "Excluded: " << all_process_list[k] << "\n";
#endif
all_process_list[k] = NO_GDB_ANSWER;
}
}
i++;
}
}
StringArray process_list;
for (i = 0; i < all_process_list.size(); i++)
if (all_process_list[i] != NO_GDB_ANSWER)
process_list += all_process_list[i];
// Now set the selection.
bool *selected = new bool[process_list.size()];
for (i = 0; i < process_list.size(); i++)
selected[i] = false;
int pos = -1;
if (keep_selection)
{
// Preserve old selection: each PID selected before will also be
// selected after.
IntArray selection;
getPIDs(processes, selection);
for (i = 0; i < selection.size(); i++)
{
for (int j = 0; j < process_list.size(); j++)
if (selection[i] == ps_pid(process_list[j]))
{
if (pos < 0)
pos = j;
selected[j] = true;
}
}
}
if (pos < 0)
{
// Create new selection from current file and current pid.
ProgramInfo info;
// Check for current pid; if found, highlight it.
for (i = 0; pos < 0 && i < process_list.size(); i++)
{
if (info.pid != 0 && ps_pid(process_list[i]) == info.pid)
pos = i;
}
if (pos < 0)
{
// Not found? Try leftmost occurrence of process base name.
string current_base = basename(info.file.chars());
int leftmost = INT_MAX;
for (i = 0; i < process_list.size(); i++)
{
int occurrence = process_list[i].index(current_base);
if (occurrence >= 0 && occurrence < leftmost
&& ps_pid(process_list[i]) > 0)
{
leftmost = occurrence;
pos = i;
}
}
}
}
if (pos >= 0)
selected[pos] = true;
setLabelList(processes, process_list.values(),
selected, process_list.size(), true, false);
if (pos >= 0)
ListSetAndSelectPos(processes, pos + 1);
delete[] selected;
}
void monitorProcess(char * processName, int processLifeSpan) {
// takes processName and lifeSpan
// converts processName to PIDs
// and monitors each PID by either
// spawning a child for that process or
// or reusing a "unbusy" child depending
// on the global freeChildren variable.
debugPrint("startin monitor Process for %s \n", processName);
char * message;
int * PIDs;
int counter = 0;
int pid = 0;
int parentPID = getpid();
int numberOfPIDs = 0;
// check to make sure process "processName" is still active
if ((numberOfPIDs = getNumberOfPIDsForProcess(processName)) < 1) {
debugPrint("no processes %s found \n", processName);
message = malloc(200);
snprintf(message, 190, "No '%s' processes found ", processName);
writeToLogs("Info", message);
free(message);
return;
}
debugPrint("we are parent: %d \n", getpid());
debugPrint("for %d %s we have the number of PIDs is equal to %d \n", getpid(), processName, numberOfPIDs);
PIDs = malloc(numberOfPIDs + 100);
message = malloc(200);
getPIDs(processName, PIDs, numberOfPIDs);
// print out messages to logs regarding which
// processes are being monitored
for (counter = 0; counter < numberOfPIDs; counter = counter + 1) {
if (monitoredPIDs != NULL && searchNodes(monitoredPIDs, processName, PIDs[counter]) != -1) {
// only call monitor process if
// process has more than 0 pids active
// and it is not in monitoredPIDs linked list
// ie it is not being monitored already
debugPrint("process %s with pid %d is already being monitored \n", processName, PIDs[counter]);
continue;
}
snprintf(message, 200, "Initializing monitoring of process '%s' (PID %d)", processName, PIDs[counter]);
writeToLogs("Info", message);
debugPrint("adding pid %d to list \n", PIDs[counter]);
if (monitoredPIDs) {
debugPrint("ADDDING pid %d to list! \n", PIDs[counter]);
addNode(monitoredPIDs, processName, PIDs[counter]);
}
else {
debugPrint("initialzing pid %d to list!\n", PIDs[counter]);
monitoredPIDs = init(processName, PIDs[counter]);
}
if (freeChildren > 0) {
// write to pipe newProcessToChild
debugPrint("freeChildren is %d, preparing to reuse child for %s pid %d\n", freeChildren, processName, PIDs[counter]);
// debugPrint("from parent: printing before writing to pipe \n");
/* write message start */
// close(newProcessToChild[0]);
char tmpStr[63];
snprintf(tmpStr, 63, "%-20s#%20d!%20d", processName, PIDs[counter], processLifeSpan);
write(newProcessToChild[1], tmpStr, 63);
debugPrint("using children\n");
freeChildren = freeChildren - 1;
}
else {
pid = fork();
if (pid == 0) {
// child portion
debugPrint("Spawned A child %d for process: %s, pid %d \n",getpid(), processName, PIDs[counter]);
dispatch(parentPID, processName, PIDs[counter], processLifeSpan);
while(keepLooping == 1) {
debugPrint("%d child : starting dispatch \n", getpid());
dispatch(parentPID, processName, -1, processLifeSpan);
}
free(PIDs);
free(message);
debugPrint("child dying....\n");
exit(0);
}
else if (pid < 0) {
fprintf(stderr,"error in forking. \n");
exit(0);
}
else {
numberOfChildren++;
if (childPIDs){
addNode(childPIDs, " ", pid);
}
else {
childPIDs = init(" ", pid);
}
//printf("parent process pid=%d \n", getpid());
}
} // spawning child end bracket
} // for loop end bracket
free(PIDs);
free(message);
}