bool IsProcessNameRunning(char *procNameRegex)
{
char *colHeaders[CF_PROCCOLS];
int start[CF_PROCCOLS] = { 0 };
int end[CF_PROCCOLS] = { 0 };
bool matched = false;
int i;
memset(colHeaders, 0, sizeof(colHeaders));
if (PROCESSTABLE == NULL)
{
Log(LOG_LEVEL_ERR, "IsProcessNameRunning: PROCESSTABLE is empty");
return false;
}
/* TODO: use actual time of ps-run, not time(NULL), which may be later. */
time_t pstime = time(NULL);
GetProcessColumnNames(PROCESSTABLE->name, colHeaders, start, end);
for (const Item *ip = PROCESSTABLE->next; !matched && ip != NULL; ip = ip->next) // iterate over ps lines
{
char *lineSplit[CF_PROCCOLS];
memset(lineSplit, 0, sizeof(lineSplit));
if (NULL_OR_EMPTY(ip->name))
{
continue;
}
if (!SplitProcLine(ip->name, pstime, colHeaders, start, end,
PS_COLUMN_ALGORITHM[VPSHARDCLASS], lineSplit))
{
Log(LOG_LEVEL_ERR, "IsProcessNameRunning: Could not split process line '%s'", ip->name);
goto loop_cleanup;
}
ApplyPlatformExtraTable(colHeaders, lineSplit);
if (SelectProcRegexMatch("CMD", "COMMAND", procNameRegex, true, colHeaders, lineSplit))
{
matched = true;
}
loop_cleanup:
for (i = 0; lineSplit[i] != NULL; i++)
{
free(lineSplit[i]);
}
}
for (i = 0; colHeaders[i] != NULL; i++)
{
free(colHeaders[i]);
}
return matched;
}
bool IsProcessNameRunning(EvalContext *ctx, char *procNameRegex)
{
char *colHeaders[CF_PROCCOLS];
Item *ip;
int start[CF_PROCCOLS] = { 0 };
int end[CF_PROCCOLS] = { 0 };
bool matched = false;
int i;
if (PROCESSTABLE == NULL)
{
Log(LOG_LEVEL_ERR, "IsProcessNameRunning: PROCESSTABLE is empty");
return false;
}
GetProcessColumnNames(PROCESSTABLE->name, (char **) colHeaders, start, end);
for (ip = PROCESSTABLE->next; ip != NULL; ip = ip->next) // iterate over ps lines
{
char *lineSplit[CF_PROCCOLS];
if (NULL_OR_EMPTY(ip->name))
{
continue;
}
if (!SplitProcLine(ip->name, colHeaders, start, end, lineSplit))
{
Log(LOG_LEVEL_ERR, "IsProcessNameRunning: Could not split process line '%s'", ip->name);
continue;
}
if (SelectProcRegexMatch(ctx, "CMD", "COMMAND", procNameRegex, colHeaders, lineSplit))
{
matched = true;
break;
}
i = 0;
while (lineSplit[i] != NULL)
{
free(lineSplit[i]);
i++;
}
}
i = 0;
while (colHeaders[i] != NULL)
{
free(colHeaders[i]);
i++;
}
return matched;
}
bool IsProcessNameRunning(char *procNameRegex)
{
char *colHeaders[CF_PROCCOLS];
Item *ip;
int start[CF_PROCCOLS] = { 0 };
int end[CF_PROCCOLS] = { 0 };
bool matched = false;
if (PROCESSTABLE == NULL)
{
CfOut(cf_error, "", "!! IsProcessNameRunning: PROCESSTABLE is empty");
return false;
}
GetProcessColumnNames(PROCESSTABLE->name, (char **) colHeaders, start, end);
for (ip = PROCESSTABLE->next; ip != NULL; ip = ip->next) // iterate over ps lines
{
char *lineSplit[CF_PROCCOLS];
if (NULL_OR_EMPTY(ip->name))
{
continue;
}
if (!SplitProcLine(ip->name, colHeaders, start, end, lineSplit))
{
CfOut(cf_error, "", "!! IsProcessNameRunning: Could not split process line \"%s\"", ip->name);
continue;
}
if (SelectProcRegexMatch("CMD", "COMMAND", procNameRegex, colHeaders, lineSplit))
{
matched = true;
break;
}
}
return matched;
}
static int SelectProcess(EvalContext *ctx, char *procentry, char **names, int *start, int *end, ProcessSelect a)
{
int result = true, i;
char *column[CF_PROCCOLS];
Rlist *rp;
StringSet *process_select_attributes = StringSetNew();
if (!SplitProcLine(procentry, names, start, end, column))
{
return false;
}
for (i = 0; names[i] != NULL; i++)
{
Log(LOG_LEVEL_DEBUG, "In SelectProcess, COL[%s] = '%s'", names[i], column[i]);
}
for (rp = a.owner; rp != NULL; rp = rp->next)
{
if (SelectProcRegexMatch(ctx, "USER", "UID", RlistScalarValue(rp), names, column))
{
StringSetAdd(process_select_attributes, xstrdup("process_owner"));
break;
}
}
if (SelectProcRangeMatch("PID", "PID", a.min_pid, a.max_pid, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("pid"));
}
if (SelectProcRangeMatch("PPID", "PPID", a.min_ppid, a.max_ppid, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("ppid"));
}
if (SelectProcRangeMatch("PGID", "PGID", a.min_pgid, a.max_pgid, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("pgid"));
}
if (SelectProcRangeMatch("VSZ", "SZ", a.min_vsize, a.max_vsize, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("vsize"));
}
if (SelectProcRangeMatch("RSS", "RSS", a.min_rsize, a.max_rsize, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("rsize"));
}
if (SelectProcTimeCounterRangeMatch("TIME", "TIME", a.min_ttime, a.max_ttime, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("ttime"));
}
if (SelectProcTimeAbsRangeMatch
("STIME", "START", a.min_stime, a.max_stime, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("stime"));
}
if (SelectProcRangeMatch("NI", "PRI", a.min_pri, a.max_pri, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("priority"));
}
if (SelectProcRangeMatch("NLWP", "NLWP", a.min_thread, a.max_thread, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("threads"));
}
if (SelectProcRegexMatch(ctx, "S", "STAT", a.status, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("status"));
}
if (SelectProcRegexMatch(ctx, "CMD", "COMMAND", a.command, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("command"));
}
if (SelectProcRegexMatch(ctx, "TTY", "TTY", a.tty, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("tty"));
}
if (!a.process_result)
{
if (StringSetSize(process_select_attributes) == 0)
{
result = EvalProcessResult("", process_select_attributes);
}
else
{
Writer *w = StringWriter();
StringSetIterator iter = StringSetIteratorInit(process_select_attributes);
char *attr = StringSetIteratorNext(&iter);
WriterWrite(w, attr);
while ((attr = StringSetIteratorNext(&iter)))
{
WriterWriteChar(w, '.');
WriterWrite(w, attr);
}
result = EvalProcessResult(StringWriterData(w), process_select_attributes);
WriterClose(w);
}
}
else
{
result = EvalProcessResult(a.process_result, process_select_attributes);
}
StringSetDestroy(process_select_attributes);
for (i = 0; column[i] != NULL; i++)
{
free(column[i]);
}
return result;
}
static bool SelectProcess(const char *procentry,
time_t pstime,
char **names,
int *start,
int *end,
const char *process_regex,
ProcessSelect a,
bool attrselect)
{
bool result = true;
char *column[CF_PROCCOLS];
Rlist *rp;
assert(process_regex);
StringSet *process_select_attributes = StringSetNew();
memset(column, 0, sizeof(column));
if (!SplitProcLine(procentry, pstime, names, start, end,
PS_COLUMN_ALGORITHM[VPSHARDCLASS], column))
{
result = false;
goto cleanup;
}
ApplyPlatformExtraTable(names, column);
for (int i = 0; names[i] != NULL; i++)
{
Log(LOG_LEVEL_DEBUG, "In SelectProcess, COL[%s] = '%s'", names[i], column[i]);
}
if (!SelectProcRegexMatch("CMD", "COMMAND", process_regex, false, names, column))
{
result = false;
goto cleanup;
}
if (!attrselect)
{
// If we are not considering attributes, then the matching is done.
goto cleanup;
}
for (rp = a.owner; rp != NULL; rp = rp->next)
{
if (SelectProcRegexMatch("USER", "UID", RlistScalarValue(rp), true, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("process_owner"));
break;
}
}
if (SelectProcRangeMatch("PID", "PID", a.min_pid, a.max_pid, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("pid"));
}
if (SelectProcRangeMatch("PPID", "PPID", a.min_ppid, a.max_ppid, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("ppid"));
}
if (SelectProcRangeMatch("PGID", "PGID", a.min_pgid, a.max_pgid, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("pgid"));
}
if (SelectProcRangeMatch("VSZ", "SZ", a.min_vsize, a.max_vsize, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("vsize"));
}
if (SelectProcRangeMatch("RSS", "RSS", a.min_rsize, a.max_rsize, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("rsize"));
}
if (SelectProcTimeCounterRangeMatch("TIME", "TIME", a.min_ttime, a.max_ttime, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("ttime"));
}
if (SelectProcTimeAbsRangeMatch
("STIME", "START", a.min_stime, a.max_stime, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("stime"));
}
if (SelectProcRangeMatch("NI", "PRI", a.min_pri, a.max_pri, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("priority"));
}
if (SelectProcRangeMatch("NLWP", "NLWP", a.min_thread, a.max_thread, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("threads"));
}
if (SelectProcRegexMatch("S", "STAT", a.status, true, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("status"));
}
if (SelectProcRegexMatch("CMD", "COMMAND", a.command, true, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("command"));
}
if (SelectProcRegexMatch("TTY", "TTY", a.tty, true, names, column))
{
StringSetAdd(process_select_attributes, xstrdup("tty"));
}
if (!a.process_result)
{
if (StringSetSize(process_select_attributes) == 0)
{
result = EvalProcessResult("", process_select_attributes);
}
else
{
Writer *w = StringWriter();
StringSetIterator iter = StringSetIteratorInit(process_select_attributes);
char *attr = StringSetIteratorNext(&iter);
WriterWrite(w, attr);
while ((attr = StringSetIteratorNext(&iter)))
{
WriterWriteChar(w, '.');
WriterWrite(w, attr);
}
result = EvalProcessResult(StringWriterData(w), process_select_attributes);
WriterClose(w);
}
}
else
{
result = EvalProcessResult(a.process_result, process_select_attributes);
}
cleanup:
StringSetDestroy(process_select_attributes);
for (int i = 0; column[i] != NULL; i++)
{
free(column[i]);
}
return result;
}
static void ReadFromUcbPsPipe(FILE *cmd)
{
char *names[CF_PROCCOLS];
memset(names, 0, sizeof(names));
int start[CF_PROCCOLS];
int end[CF_PROCCOLS];
char *line = NULL;
size_t linesize = 0;
bool header = true;
time_t pstime = time(NULL);
int pidcol = -1;
int cmdcol = -1;
while (CfReadLine(&line, &linesize, cmd) > 0)
{
if (header)
{
GetProcessColumnNames(line, names, start, end);
for (int i = 0; names[i]; i++)
{
if (strcmp(names[i], "PID") == 0)
{
pidcol = i;
}
else if (strcmp(names[i], "COMMAND") == 0
|| strcmp(names[i], "CMD") == 0)
{
cmdcol = i;
}
}
if (pidcol < 0 || cmdcol < 0)
{
Log(LOG_LEVEL_ERR,
"Could not find PID and/or CMD/COMMAND column in "
"ps output: \"%s\"", line);
break;
}
header = false;
continue;
}
char *columns[CF_PROCCOLS];
memset(columns, 0, sizeof(columns));
if (!SplitProcLine(line, pstime, names, start, end,
UCB_STYLE_PS_COLUMN_ALGORITHM, columns))
{
Log(LOG_LEVEL_WARNING,
"Not able to parse ps output: \"%s\"", line);
}
StringMapInsert(UCB_PS_MAP, columns[pidcol], columns[cmdcol]);
// We avoid strdup'ing these strings by claiming ownership here.
columns[pidcol] = NULL;
columns[cmdcol] = NULL;
for (int i = 0; i < CF_PROCCOLS; i++)
{
// There may be some null entries here, but since we "steal"
// strings in the section above, we may have set some of them to
// NULL and there may be following non-NULL fields.
free(columns[i]);
}
}
if (!feof(cmd) && ferror(cmd))
{
Log(LOG_LEVEL_ERR, "Error while reading output from ps: %s",
GetErrorStr());
}
for (int i = 0; names[i] && i < CF_PROCCOLS; i++)
{
free(names[i]);
}
free(line);
}
static int SelectProcess(char *procentry, char **names, int *start, int *end, ProcessSelect a)
{
int result = true, i;
char *column[CF_PROCCOLS];
Rlist *rp;
StringSet *proc_attr = StringSetNew();
if (!SplitProcLine(procentry, names, start, end, column))
{
return false;
}
for (i = 0; names[i] != NULL; i++)
{
Log(LOG_LEVEL_DEBUG, "In SelectProcess, COL[%s] = '%s'", names[i], column[i]);
}
for (rp = a.owner; rp != NULL; rp = rp->next)
{
if (SelectProcRegexMatch("USER", "UID", (char *) rp->item, names, column))
{
StringSetAdd(proc_attr, xstrdup("process_owner"));
break;
}
}
if (SelectProcRangeMatch("PID", "PID", a.min_pid, a.max_pid, names, column))
{
StringSetAdd(proc_attr, xstrdup("pid"));
}
if (SelectProcRangeMatch("PPID", "PPID", a.min_ppid, a.max_ppid, names, column))
{
StringSetAdd(proc_attr, xstrdup("ppid"));
}
if (SelectProcRangeMatch("PGID", "PGID", a.min_pgid, a.max_pgid, names, column))
{
StringSetAdd(proc_attr, xstrdup("pgid"));
}
if (SelectProcRangeMatch("VSZ", "SZ", a.min_vsize, a.max_vsize, names, column))
{
StringSetAdd(proc_attr, xstrdup("vsize"));
}
if (SelectProcRangeMatch("RSS", "RSS", a.min_rsize, a.max_rsize, names, column))
{
StringSetAdd(proc_attr, xstrdup("rsize"));
}
if (SelectProcTimeCounterRangeMatch("TIME", "TIME", a.min_ttime, a.max_ttime, names, column))
{
StringSetAdd(proc_attr, xstrdup("ttime"));
}
if (SelectProcTimeAbsRangeMatch
("STIME", "START", a.min_stime, a.max_stime, names, column))
{
StringSetAdd(proc_attr, xstrdup("stime"));
}
if (SelectProcRangeMatch("NI", "PRI", a.min_pri, a.max_pri, names, column))
{
StringSetAdd(proc_attr, xstrdup("priority"));
}
if (SelectProcRangeMatch("NLWP", "NLWP", a.min_thread, a.max_thread, names, column))
{
StringSetAdd(proc_attr, xstrdup("threads"));
}
if (SelectProcRegexMatch("S", "STAT", a.status, names, column))
{
StringSetAdd(proc_attr, xstrdup("status"));
}
if (SelectProcRegexMatch("CMD", "COMMAND", a.command, names, column))
{
StringSetAdd(proc_attr, xstrdup("command"));
}
if (SelectProcRegexMatch("TTY", "TTY", a.tty, names, column))
{
StringSetAdd(proc_attr, xstrdup("tty"));
}
result = EvalProcessResult(a.process_result, proc_attr);
StringSetDestroy(proc_attr);
for (i = 0; column[i] != NULL; i++)
{
free(column[i]);
}
return result;
}
int SelectProcess(char *procentry, char **names, int *start, int *end, Attributes a, Promise *pp)
{
AlphaList proc_attr;
int result = true, i;
char *column[CF_PROCCOLS];
Rlist *rp;
CfDebug("SelectProcess(%s)\n", procentry);
InitAlphaList(&proc_attr);
if (!a.haveselect)
{
return true;
}
if (!SplitProcLine(procentry, names, start, end, column))
{
return false;
}
if (DEBUG)
{
for (i = 0; names[i] != NULL; i++)
{
printf("COL[%s] = \"%s\"\n", names[i], column[i]);
}
}
for (rp = a.process_select.owner; rp != NULL; rp = rp->next)
{
if (SelectProcRegexMatch("USER", "UID", (char *) rp->item, names, column))
{
PrependAlphaList(&proc_attr, "process_owner");
break;
}
}
if (SelectProcRangeMatch("PID", "PID", a.process_select.min_pid, a.process_select.max_pid, names, column))
{
PrependAlphaList(&proc_attr, "pid");
}
if (SelectProcRangeMatch("PPID", "PPID", a.process_select.min_ppid, a.process_select.max_ppid, names, column))
{
PrependAlphaList(&proc_attr, "ppid");
}
if (SelectProcRangeMatch("PGID", "PGID", a.process_select.min_pgid, a.process_select.max_pgid, names, column))
{
PrependAlphaList(&proc_attr, "pgid");
}
if (SelectProcRangeMatch("VSZ", "SZ", a.process_select.min_vsize, a.process_select.max_vsize, names, column))
{
PrependAlphaList(&proc_attr, "vsize");
}
if (SelectProcRangeMatch("RSS", "RSS", a.process_select.min_rsize, a.process_select.max_rsize, names, column))
{
PrependAlphaList(&proc_attr, "rsize");
}
if (SelectProcTimeCounterRangeMatch
("TIME", "TIME", a.process_select.min_ttime, a.process_select.max_ttime, names, column))
{
PrependAlphaList(&proc_attr, "ttime");
}
if (SelectProcTimeAbsRangeMatch
("STIME", "START", a.process_select.min_stime, a.process_select.max_stime, names, column))
{
PrependAlphaList(&proc_attr, "stime");
}
if (SelectProcRangeMatch("NI", "PRI", a.process_select.min_pri, a.process_select.max_pri, names, column))
{
PrependAlphaList(&proc_attr, "priority");
}
if (SelectProcRangeMatch("NLWP", "NLWP", a.process_select.min_thread, a.process_select.max_thread, names, column))
{
PrependAlphaList(&proc_attr, "threads");
}
if (SelectProcRegexMatch("S", "STAT", a.process_select.status, names, column))
{
PrependAlphaList(&proc_attr, "status");
}
if (SelectProcRegexMatch("CMD", "COMMAND", a.process_select.command, names, column))
{
PrependAlphaList(&proc_attr, "command");
}
if (SelectProcRegexMatch("TTY", "TTY", a.process_select.tty, names, column))
{
PrependAlphaList(&proc_attr, "tty");
}
if ((result = EvalProcessResult(a.process_select.process_result, &proc_attr)))
{
//ClassesFromString(fp->defines);
}
DeleteAlphaList(&proc_attr);
if (result)
{
if (a.transaction.action == cfa_warn)
{
CfOut(cf_error, "", " !! Matched: %s\n", procentry);
}
else
{
CfOut(cf_inform, "", " !! Matched: %s\n", procentry);
}
}
for (i = 0; column[i] != NULL; i++)
{
free(column[i]);
}
return result;
}
