int
main(int argc, char **argv)
{
int i;
int c;
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'l': /* list all flags */
printf("Performance Co-Pilot Debug Flags\n");
printf("#define Value Meaning\n");
for (i = 0; i < nfoo; i++)
printf(fmt, foo[i].name, foo[i].flag, foo[i].text);
exit(0);
case '?':
default:
opts.errors++;
break;
}
}
if (opts.errors || opts.optind >= argc) {
pmUsageMessage(&opts);
exit(1);
}
/* non-flag args are argv[opts.optind] ... argv[argc-1] */
while (opts.optind < argc) {
char *p = argv[opts.optind];
for (p = argv[opts.optind]; *p && isdigit((int)*p); p++)
;
if (*p == '\0')
sscanf(argv[opts.optind], "%d", &c);
else {
char *q;
p = argv[opts.optind];
if (*p == '0' && (p[1] == 'x' || p[1] == 'X'))
p = &p[2];
for (q = p; isxdigit((int)*q); q++)
;
if (*q != '\0' || sscanf(p, "%x", &c) != 1) {
printf("Cannot decode \"%s\" - neither decimal nor hexadecimal\n", argv[opts.optind]);
goto next;
}
}
printf("Performance Co-Pilot -- pmDebug value = %d (0x%x)\n", c, c);
printf("#define Value Meaning\n");
for (i = 0; i < nfoo; i++) {
if (c & foo[i].flag)
printf(fmt, foo[i].name, foo[i].flag, foo[i].text);
}
next:
opts.optind++;
}
return 0;
}
int
main(int argc, char **argv)
{
int c;
int sflag = 0;
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'a': /* show all, default (unmodified) list format */
case 'l':
sflag = 0;
break;
case 's': /* show all, guarded format for shell expansion */
sflag = 1;
break;
case 'L':
apiflag = 1;
break;
default:
opts.errors++;
break;
}
}
if (opts.errors) {
pmUsageMessage(&opts);
exit(1);
}
if (sflag) {
putenv("SHELL=/bin/sh");
empty = none;
}
/* the complete list of variables is to be reported */
if (opts.optind >= argc) {
if (apiflag)
__pmAPIConfig(sflag ? export_report : direct_report);
else
__pmConfig(sflag ? pcp_conf_shell_extract : pcp_conf_extract);
exit(0);
}
/* an explicit list of variables has been requested */
if (sflag) {
if (apiflag)
for (c = opts.optind; c < argc; c++)
export_report(argv[c], __pmGetAPIConfig(argv[c]));
else
for (c = opts.optind; c < argc; c++)
export_report(argv[c], pmGetConfig(argv[c]));
} else {
if (apiflag)
for (c = opts.optind; c < argc; c++)
direct_report(argv[c], __pmGetAPIConfig(argv[c]));
else
for (c = opts.optind; c < argc; c++)
direct_report(argv[c], pmGetConfig(argv[c]));
}
exit(0);
}
static int
parseargs(int argc, char *argv[])
{
int c;
int sts;
char *endnum;
char *msg;
struct timeval interval;
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'A': /* output time alignment */
Aarg = opts.optarg;
break;
case 'D': /* debug flag */
sts = __pmParseDebug(opts.optarg);
if (sts < 0) {
pmprintf("%s: unrecognized debug flag specification (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
}
else
pmDebug |= sts;
break;
case 's': /* number of samples to write out */
sarg = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0' || sarg < 0) {
pmprintf("%s: -s requires numeric argument\n",
pmProgname);
opts.errors++;
}
break;
case 'S': /* start time for reduction */
Sarg = opts.optarg;
break;
case 'T': /* end time for reduction */
Targ = opts.optarg;
break;
case 't': /* output sample interval */
if (pmParseInterval(opts.optarg, &interval, &msg) < 0) {
pmprintf("%s", msg);
free(msg);
opts.errors++;
}
else
targ = tv2double(&interval);
break;
case 'v': /* number of samples per volume */
varg = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0' || varg < 0) {
pmprintf("%s: -v requires numeric argument\n",
pmProgname);
opts.errors++;
}
break;
case 'Z': /* use timezone from command line */
if (zarg) {
pmprintf("%s: at most one of -Z and/or -z allowed\n",
pmProgname);
opts.errors++;
}
tz = opts.optarg;
break;
case 'z': /* use timezone from archive */
if (tz != NULL) {
pmprintf("%s: at most one of -Z and/or -z allowed\n",
pmProgname);
opts.errors++;
}
zarg++;
break;
case '?':
default:
opts.errors++;
break;
}
}
if (opts.errors == 0 && opts.optind > argc-2) {
pmprintf("%s: Error: insufficient arguments\n", pmProgname);
opts.errors++;
}
return -opts.errors;
}
int
main(int argc, char **argv)
{
int c;
int sts;
int sep = __pmPathSeparator();
int use_localtime = 0;
int isdaemon = 0;
char *pmnsfile = PM_NS_DEFAULT;
char *username;
char *logfile = "pmlogger.log";
/* default log (not archive) file name */
char *endnum;
int i;
task_t *tp;
optcost_t ocp;
__pmFdSet readyfds;
char *p;
char *runtime = NULL;
int ctx; /* handle corresponding to ctxp below */
__pmContext *ctxp; /* pmlogger has just this one context */
int niter;
pid_t target_pid = 0;
__pmGetUsername(&username);
/*
* Warning:
* If any of the pmlogger options change, make sure the
* corresponding changes are made to pmnewlog when pmlogger
* options are passed through from the control file
*/
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'c': /* config file */
if (access(opts.optarg, F_OK) == 0)
configfile = opts.optarg;
else {
/* does not exist as given, try the standard place */
char *sysconf = pmGetConfig("PCP_VAR_DIR");
int sz = strlen(sysconf)+strlen("/config/pmlogger/")+strlen(opts.optarg)+1;
if ((configfile = (char *)malloc(sz)) == NULL)
__pmNoMem("config file name", sz, PM_FATAL_ERR);
snprintf(configfile, sz,
"%s%c" "config%c" "pmlogger%c" "%s",
sysconf, sep, sep, sep, opts.optarg);
if (access(configfile, F_OK) != 0) {
/* still no good, error handling happens below */
free(configfile);
configfile = opts.optarg;
}
}
break;
case 'D': /* debug flag */
sts = __pmParseDebug(opts.optarg);
if (sts < 0) {
pmprintf("%s: unrecognized debug flag specification (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
}
else
pmDebug |= sts;
break;
case 'h': /* hostname for PMCD to contact */
pmcd_host_conn = opts.optarg;
break;
case 'l': /* log file name */
logfile = opts.optarg;
break;
case 'L': /* linger if not primary logger */
linger = 1;
break;
case 'm': /* note for port map file */
note = opts.optarg;
isdaemon = ((strcmp(note, "pmlogger_check") == 0) ||
(strcmp(note, "pmlogger_daily") == 0));
break;
case 'n': /* alternative name space file */
pmnsfile = opts.optarg;
break;
case 'p':
target_pid = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0') {
pmprintf("%s: invalid process identifier (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
} else if (!__pmProcessExists(target_pid)) {
pmprintf("%s: PID error - no such process (%d)\n",
pmProgname, target_pid);
opts.errors++;
}
break;
case 'P': /* this is the primary pmlogger */
primary = 1;
isdaemon = 1;
break;
case 'r': /* report sizes of pmResult records */
rflag = 1;
break;
case 's': /* exit size */
sts = ParseSize(opts.optarg, &exit_samples, &exit_bytes, &exit_time);
if (sts < 0) {
pmprintf("%s: illegal size argument '%s' for exit size\n",
pmProgname, opts.optarg);
opts.errors++;
}
else if (exit_time.tv_sec > 0) {
__pmAFregister(&exit_time, NULL, run_done_callback);
}
break;
case 'T': /* end time */
runtime = opts.optarg;
break;
case 't': /* change default logging interval */
if (pmParseInterval(opts.optarg, &delta, &p) < 0) {
pmprintf("%s: illegal -t argument\n%s", pmProgname, p);
free(p);
opts.errors++;
}
break;
case 'U': /* run as named user */
username = opts.optarg;
isdaemon = 1;
break;
case 'u': /* flush output buffers after each fetch */
/*
* all archive write I/O is unbuffered now, so maintain -u
* for backwards compatibility only
*/
break;
case 'v': /* volume switch after given size */
sts = ParseSize(opts.optarg, &vol_switch_samples, &vol_switch_bytes,
&vol_switch_time);
if (sts < 0) {
pmprintf("%s: illegal size argument '%s' for volume size\n",
pmProgname, opts.optarg);
opts.errors++;
}
else if (vol_switch_time.tv_sec > 0) {
vol_switch_afid = __pmAFregister(&vol_switch_time, NULL,
vol_switch_callback);
}
break;
case 'V':
archive_version = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0' || archive_version != PM_LOG_VERS02) {
pmprintf("%s: -V requires a version number of %d\n",
pmProgname, PM_LOG_VERS02);
opts.errors++;
}
break;
case 'x': /* recording session control fd */
rsc_fd = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0' || rsc_fd < 0) {
pmprintf("%s: -x requires a non-negative numeric argument\n", pmProgname);
opts.errors++;
}
else {
time(&rsc_start);
}
break;
case 'y':
use_localtime = 1;
break;
case '?':
default:
opts.errors++;
break;
}
}
if (primary && pmcd_host != NULL) {
pmprintf(
"%s: -P and -h are mutually exclusive; use -P only when running\n"
"%s on the same (local) host as the PMCD to which it connects.\n",
pmProgname, pmProgname);
opts.errors++;
}
if (!opts.errors && opts.optind != argc - 1) {
pmprintf("%s: insufficient arguments\n", pmProgname);
opts.errors++;
}
if (opts.errors) {
pmUsageMessage(&opts);
exit(1);
}
if (rsc_fd != -1 && note == NULL) {
/* add default note to indicate running with -x */
static char xnote[10];
snprintf(xnote, sizeof(xnote), "-x %d", rsc_fd);
note = xnote;
}
/* if we are running as a daemon, change user early */
if (isdaemon)
__pmSetProcessIdentity(username);
__pmOpenLog("pmlogger", logfile, stderr, &sts);
if (sts != 1) {
fprintf(stderr, "%s: Warning: log file (%s) creation failed\n", pmProgname, logfile);
/* continue on ... writing to stderr */
}
/* base name for archive is here ... */
archBase = argv[opts.optind];
if (pmcd_host_conn == NULL)
pmcd_host_conn = "local:";
/* initialise access control */
if (__pmAccAddOp(PM_OP_LOG_ADV) < 0 ||
__pmAccAddOp(PM_OP_LOG_MAND) < 0 ||
__pmAccAddOp(PM_OP_LOG_ENQ) < 0) {
fprintf(stderr, "%s: access control initialisation failed\n", pmProgname);
exit(1);
}
if (pmnsfile != PM_NS_DEFAULT) {
if ((sts = pmLoadASCIINameSpace(pmnsfile, 1)) < 0) {
fprintf(stderr, "%s: Cannot load namespace from \"%s\": %s\n", pmProgname, pmnsfile, pmErrStr(sts));
exit(1);
}
}
if ((ctx = pmNewContext(PM_CONTEXT_HOST, pmcd_host_conn)) < 0) {
fprintf(stderr, "%s: Cannot connect to PMCD on host \"%s\": %s\n", pmProgname, pmcd_host_conn, pmErrStr(ctx));
exit(1);
}
pmcd_host = (char *)pmGetContextHostName(ctx);
if (strlen(pmcd_host) == 0) {
fprintf(stderr, "%s: pmGetContextHostName(%d) failed\n",
pmProgname, ctx);
exit(1);
}
if (rsc_fd == -1) {
/* no -x, so register client id with pmcd */
__pmSetClientIdArgv(argc, argv);
}
/*
* discover fd for comms channel to PMCD ...
*/
if ((ctxp = __pmHandleToPtr(ctx)) == NULL) {
fprintf(stderr, "%s: botch: __pmHandleToPtr(%d) returns NULL!\n", pmProgname, ctx);
exit(1);
}
pmcdfd = ctxp->c_pmcd->pc_fd;
PM_UNLOCK(ctxp->c_lock);
if (configfile != NULL) {
if ((yyin = fopen(configfile, "r")) == NULL) {
fprintf(stderr, "%s: Cannot open config file \"%s\": %s\n",
pmProgname, configfile, osstrerror());
exit(1);
}
}
else {
/* **ANY** Lex would read from stdin automagically */
configfile = "<stdin>";
}
__pmOptFetchGetParams(&ocp);
ocp.c_scope = 1;
__pmOptFetchPutParams(&ocp);
/* prevent early timer events ... */
__pmAFblock();
if (yyparse() != 0)
exit(1);
if (configfile != NULL)
fclose(yyin);
yyend();
#ifdef PCP_DEBUG
fprintf(stderr, "Config parsed\n");
#endif
fprintf(stderr, "Starting %slogger for host \"%s\" via \"%s\"\n",
primary ? "primary " : "", pmcd_host, pmcd_host_conn);
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_LOG) {
fprintf(stderr, "optFetch Cost Parameters: pmid=%d indom=%d fetch=%d scope=%d\n",
ocp.c_pmid, ocp.c_indom, ocp.c_fetch, ocp.c_scope);
fprintf(stderr, "\nAfter loading config ...\n");
for (tp = tasklist; tp != NULL; tp = tp->t_next) {
if (tp->t_numvalid == 0)
continue;
fprintf(stderr, " state: %sin log, %savail, %s, %s",
PMLC_GET_INLOG(tp->t_state) ? "" : "not ",
PMLC_GET_AVAIL(tp->t_state) ? "" : "un",
PMLC_GET_MAND(tp->t_state) ? "mand" : "adv",
PMLC_GET_ON(tp->t_state) ? "on" : "off");
fprintf(stderr, " delta: %ld usec",
(long)1000 * tp->t_delta.tv_sec + tp->t_delta.tv_usec);
fprintf(stderr, " numpmid: %d\n", tp->t_numpmid);
for (i = 0; i < tp->t_numpmid; i++) {
fprintf(stderr, " %s (%s):\n", pmIDStr(tp->t_pmidlist[i]), tp->t_namelist[i]);
}
__pmOptFetchDump(stderr, tp->t_fetch);
}
}
#endif
if (!primary && tasklist == NULL && !linger) {
fprintf(stderr, "Nothing to log, and not the primary logger instance ... good-bye\n");
exit(1);
}
if ((sts = __pmLogCreate(pmcd_host, archBase, archive_version, &logctl)) < 0) {
fprintf(stderr, "__pmLogCreate: %s\n", pmErrStr(sts));
exit(1);
}
else {
/*
* try and establish $TZ from the remote PMCD ...
* Note the label record has been set up, but not written yet
*/
char *name = "pmcd.timezone";
pmID pmid;
pmResult *resp;
__pmtimevalNow(&epoch);
sts = pmUseContext(ctx);
if (sts >= 0)
sts = pmLookupName(1, &name, &pmid);
if (sts >= 0)
sts = pmFetch(1, &pmid, &resp);
if (sts >= 0) {
if (resp->vset[0]->numval > 0) { /* pmcd.timezone present */
strcpy(logctl.l_label.ill_tz, resp->vset[0]->vlist[0].value.pval->vbuf);
/* prefer to use remote time to avoid clock drift problems */
epoch = resp->timestamp; /* struct assignment */
if (! use_localtime)
pmNewZone(logctl.l_label.ill_tz);
}
#ifdef PCP_DEBUG
else if (pmDebug & DBG_TRACE_LOG) {
fprintf(stderr,
"main: Could not get timezone from host %s\n",
pmcd_host);
}
#endif
pmFreeResult(resp);
}
}
/* do ParseTimeWindow stuff for -T */
if (runtime) {
struct timeval res_end; /* time window end */
struct timeval start;
struct timeval end;
struct timeval last_delta;
char *err_msg; /* parsing error message */
time_t now;
struct timeval now_tv;
time(&now);
now_tv.tv_sec = now;
now_tv.tv_usec = 0;
start = now_tv;
end.tv_sec = INT_MAX;
end.tv_usec = INT_MAX;
sts = __pmParseTime(runtime, &start, &end, &res_end, &err_msg);
if (sts < 0) {
fprintf(stderr, "%s: illegal -T argument\n%s", pmProgname, err_msg);
exit(1);
}
last_delta = res_end;
tsub(&last_delta, &now_tv);
__pmAFregister(&last_delta, NULL, run_done_callback);
last_stamp = res_end;
}
fprintf(stderr, "Archive basename: %s\n", archBase);
#ifndef IS_MINGW
/* detach yourself from the launching process */
if (isdaemon)
setpgid(getpid(), 0);
#endif
/* set up control port */
init_ports();
__pmFD_ZERO(&fds);
for (i = 0; i < CFD_NUM; ++i) {
if (ctlfds[i] >= 0)
__pmFD_SET(ctlfds[i], &fds);
}
#ifndef IS_MINGW
__pmFD_SET(pmcdfd, &fds);
#endif
if (rsc_fd != -1)
__pmFD_SET(rsc_fd, &fds);
numfds = maxfd() + 1;
if ((sts = do_preamble()) < 0)
fprintf(stderr, "Warning: problem writing archive preamble: %s\n",
pmErrStr(sts));
sts = 0; /* default exit status */
parse_done = 1; /* enable callback processing */
__pmAFunblock();
for ( ; ; ) {
int nready;
#ifdef PCP_DEBUG
if ((pmDebug & DBG_TRACE_APPL2) && (pmDebug & DBG_TRACE_DESPERATE)) {
fprintf(stderr, "before __pmSelectRead(%d,...): run_done_alarm=%d vol_switch_alarm=%d log_alarm=%d\n", numfds, run_done_alarm, vol_switch_alarm, log_alarm);
}
#endif
niter = 0;
while (log_alarm && niter++ < 10) {
__pmAFblock();
log_alarm = 0;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "delayed callback: log_alarm\n");
#endif
for (tp = tasklist; tp != NULL; tp = tp->t_next) {
if (tp->t_alarm) {
tp->t_alarm = 0;
do_work(tp);
}
}
__pmAFunblock();
}
if (vol_switch_alarm) {
__pmAFblock();
vol_switch_alarm = 0;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "delayed callback: vol_switch_alarm\n");
#endif
newvolume(VOL_SW_TIME);
__pmAFunblock();
}
if (run_done_alarm) {
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "delayed callback: run_done_alarm\n");
#endif
run_done(0, NULL);
/*NOTREACHED*/
}
__pmFD_COPY(&readyfds, &fds);
nready = __pmSelectRead(numfds, &readyfds, NULL);
#ifdef PCP_DEBUG
if ((pmDebug & DBG_TRACE_APPL2) && (pmDebug & DBG_TRACE_DESPERATE)) {
fprintf(stderr, "__pmSelectRead(%d,...) done: nready=%d run_done_alarm=%d vol_switch_alarm=%d log_alarm=%d\n", numfds, nready, run_done_alarm, vol_switch_alarm, log_alarm);
}
#endif
__pmAFblock();
if (nready > 0) {
/* handle request on control port */
for (i = 0; i < CFD_NUM; ++i) {
if (ctlfds[i] >= 0 && __pmFD_ISSET(ctlfds[i], &readyfds)) {
if (control_req(ctlfds[i])) {
/* new client has connected */
__pmFD_SET(clientfd, &fds);
if (clientfd >= numfds)
numfds = clientfd + 1;
}
}
}
if (clientfd >= 0 && __pmFD_ISSET(clientfd, &readyfds)) {
/* process request from client, save clientfd in case client
* closes connection, resetting clientfd to -1
*/
int fd = clientfd;
if (client_req()) {
/* client closed connection */
__pmFD_CLR(fd, &fds);
__pmCloseSocket(clientfd);
clientfd = -1;
numfds = maxfd() + 1;
qa_case = 0;
}
}
#ifndef IS_MINGW
if (pmcdfd >= 0 && __pmFD_ISSET(pmcdfd, &readyfds)) {
/*
* do not expect this, given synchronous commumication with the
* pmcd ... either pmcd has terminated, or bogus PDU ... or its
* Win32 and we are operating under the different conditions of
* our AF.c implementation there, which has to deal with a lack
* of signal support on Windows - race condition exists between
* this check and the async event timer callback.
*/
__pmPDU *pb;
__pmPDUHdr *php;
sts = __pmGetPDU(pmcdfd, ANY_SIZE, TIMEOUT_NEVER, &pb);
if (sts <= 0) {
if (sts < 0)
fprintf(stderr, "Error: __pmGetPDU: %s\n", pmErrStr(sts));
disconnect(sts);
}
else {
php = (__pmPDUHdr *)pb;
fprintf(stderr, "Error: Unsolicited %s PDU from PMCD\n",
__pmPDUTypeStr(php->type));
disconnect(PM_ERR_IPC);
}
if (sts > 0)
__pmUnpinPDUBuf(pb);
}
#endif
if (rsc_fd >= 0 && __pmFD_ISSET(rsc_fd, &readyfds)) {
/*
* some action on the recording session control fd
* end-of-file means launcher has quit, otherwise we
* expect one of these commands
* V<number>\n - version
* F<folio>\n - folio name
* P<name>\n - launcher's name
* R\n - launcher can replay
* D\n - detach from launcher
* Q\n - quit pmlogger
*/
char rsc_buf[MAXPATHLEN];
char *rp = rsc_buf;
char myc;
int fake_x = 0;
for (rp = rsc_buf; ; rp++) {
if (read(rsc_fd, &myc, 1) <= 0) {
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "recording session control: eof\n");
#endif
if (rp != rsc_buf) {
*rp = '\0';
fprintf(stderr, "Error: incomplete recording session control message: \"%s\"\n", rsc_buf);
}
fake_x = 1;
break;
}
if (rp >= &rsc_buf[MAXPATHLEN]) {
fprintf(stderr, "Error: absurd recording session control message: \"%100.100s ...\"\n", rsc_buf);
fake_x = 1;
break;
}
if (myc == '\n') {
*rp = '\0';
break;
}
*rp = myc;
}
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2) {
if (fake_x == 0)
fprintf(stderr, "recording session control: \"%s\"\n", rsc_buf);
}
#endif
if (fake_x)
do_dialog('X');
else if (strcmp(rsc_buf, "Q") == 0 ||
strcmp(rsc_buf, "D") == 0 ||
strcmp(rsc_buf, "?") == 0)
do_dialog(rsc_buf[0]);
else if (rsc_buf[0] == 'F')
folio_name = strdup(&rsc_buf[1]);
else if (rsc_buf[0] == 'P')
rsc_prog = strdup(&rsc_buf[1]);
else if (strcmp(rsc_buf, "R") == 0)
rsc_replay = 1;
else if (rsc_buf[0] == 'V' && rsc_buf[1] == '0') {
/*
* version 0 of the recording session control ...
* this is all we grok at the moment
*/
;
}
else {
fprintf(stderr, "Error: illegal recording session control message: \"%s\"\n", rsc_buf);
do_dialog('X');
}
}
}
else if (vol_switch_flag) {
newvolume(VOL_SW_SIGHUP);
vol_switch_flag = 0;
}
else if (nready < 0 && neterror() != EINTR)
fprintf(stderr, "Error: select: %s\n", netstrerror());
__pmAFunblock();
if (target_pid && !__pmProcessExists(target_pid))
exit(EXIT_SUCCESS);
if (exit_code)
break;
}
exit(exit_code);
}
static void
ParseOptions(int argc, char *argv[], int *nports)
{
int c;
int sts;
int usage = 0;
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'A': /* disable pmproxy service advertising */
__pmServerClearFeature(PM_SERVER_FEATURE_DISCOVERY);
break;
case 'C': /* path to NSS certificate database */
certdb = opts.optarg;
break;
case 'D': /* debug flag */
if ((sts = __pmParseDebug(opts.optarg)) < 0) {
pmprintf("%s: unrecognized debug flag specification (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
} else {
pmDebug |= sts;
}
break;
case 'f': /* foreground, i.e. do _not_ run as a daemon */
run_daemon = 0;
break;
case 'i':
/* one (of possibly several) interfaces for client requests */
__pmServerAddInterface(opts.optarg);
break;
case 'l':
/* log file name */
logfile = opts.optarg;
break;
case 'L': /* Maximum size for PDUs from clients */
sts = (int)strtol(opts.optarg, NULL, 0);
if (sts <= 0) {
pmprintf("%s: -L requires a positive value\n", pmProgname);
opts.errors++;
} else {
__pmSetPDUCeiling(sts);
}
break;
case 'p':
if (__pmServerAddPorts(opts.optarg) < 0) {
pmprintf("%s: -p requires a positive numeric argument (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
} else {
*nports += 1;
}
break;
case 'P': /* password file for certificate database access */
dbpassfile = opts.optarg;
break;
case 'U': /* run as user username */
username = opts.optarg;
break;
case 'x':
fatalfile = opts.optarg;
break;
case '?':
usage = 1;
break;
default:
opts.errors++;
break;
}
}
if (usage || opts.errors || opts.optind < argc) {
pmUsageMessage(&opts);
if (usage)
exit(0);
DontStart();
}
}
int
main(int argc, char **argv)
{
int sep = __pmPathSeparator();
int sts;
int c;
char *p;
char pmnsfile[MAXPATHLEN];
char outfname[MAXPATHLEN];
struct stat sbuf;
if ((p = getenv("PMNS_DEFAULT")) != NULL) {
strncpy(pmnsfile, p, MAXPATHLEN);
pmnsfile[MAXPATHLEN-1]= '\0';
} else {
snprintf(pmnsfile, sizeof(pmnsfile), "%s%c" "pmns" "%c" "root",
pmGetConfig("PCP_VAR_DIR"), sep, sep);
}
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'd': /* duplicate PMIDs are OK */
fprintf(stderr, "%s: Warning: -d deprecated, duplicate PMNS names allowed by default\n", pmProgname);
break;
case 'D': /* debug flag */
if ((sts = __pmParseDebug(opts.optarg)) < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
} else {
pmDebug |= sts;
}
break;
case 'n': /* alternative name space file */
strncpy(pmnsfile, opts.optarg, MAXPATHLEN);
pmnsfile[MAXPATHLEN-1]= '\0';
break;
case '?':
default:
opts.errors++;
break;
}
}
if (opts.errors || opts.optind > argc - 1) {
pmUsageMessage(&opts);
exit(1);
}
if ((sts = pmLoadASCIINameSpace(pmnsfile, 1)) < 0) {
fprintf(stderr, "%s: Error: pmLoadASCIINameSpace(%s, 1): %s\n",
pmProgname, pmnsfile, pmErrStr(sts));
exit(1);
}
{
__pmnsTree *t;
t = __pmExportPMNS();
if (t == NULL) {
/* sanity check - shouldn't ever happen */
fprintf(stderr, "Exported PMNS is NULL !");
exit(1);
}
root = t->root;
}
while (opts.optind < argc) {
delpmns(root, fullname = argv[opts.optind]);
opts.optind++;
}
/*
* from here on, ignore SIGHUP, SIGINT and SIGTERM to protect
* the integrity of the new ouput file
*/
__pmSetSignalHandler(SIGHUP, SIG_IGN);
__pmSetSignalHandler(SIGINT, SIG_IGN);
__pmSetSignalHandler(SIGTERM, SIG_IGN);
snprintf(outfname, sizeof(outfname), "%s.new", pmnsfile);
if ((outf = fopen(outfname, "w")) == NULL) {
fprintf(stderr, "%s: Error: cannot open PMNS file \"%s\" for writing: %s\n",
pmProgname, outfname, osstrerror());
exit(1);
}
if (stat(pmnsfile, &sbuf) == 0) {
/*
* preserve the mode and ownership of any existing PMNS file
*/
chmod(outfname, sbuf.st_mode & ~S_IFMT);
#if defined(HAVE_CHOWN)
if (chown(outfname, sbuf.st_uid, sbuf.st_gid) < 0)
fprintf(stderr, "%s: chown(%s, ...) failed: %s\n",
pmProgname, outfname, osstrerror());
#endif
}
pmns_output(root, outf);
fclose(outf);
/* rename the PMNS */
if (rename2(outfname, pmnsfile) == -1) {
fprintf(stderr, "%s: cannot rename \"%s\" to \"%s\": %s\n",
pmProgname, outfname, pmnsfile, osstrerror());
/* remove the new PMNS */
unlink(outfname);
exit(1);
}
exit(0);
}
int
main(int argc, char **argv)
{
int c;
int sts;
char *endnum;
iflag = isatty(0);
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'D': /* debug flag */
sts = __pmParseDebug(opts.optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
}
else
pmDebug |= sts;
break;
case 'e': /* echo input */
eflag++;
break;
case 'f': /* skip .dbpmdarc processing */
fflag++;
break;
case 'i': /* be interactive */
iflag = 1;
break;
case 'n': /* alternative name space file */
pmnsfile = opts.optarg;
break;
case 'q':
sts = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0' || sts <= 0.0) {
pmprintf("%s: -q requires a positive numeric argument\n",
pmProgname);
opts.errors++;
} else {
_creds_timeout = sts;
}
break;
case 'U': /* run under alternate user account */
__pmSetProcessIdentity(opts.optarg);
break;
default:
case '?':
opts.errors++;
break;
}
}
if ((c = argc - opts.optind) > 0) {
if (c > 1)
opts.errors++;
else {
/* pid was specified */
if (primary) {
pmprintf("%s: you may not specify both -P and a pid\n",
pmProgname);
opts.errors++;
}
else {
pid = (int)strtol(argv[opts.optind], &endnum, 10);
if (*endnum != '\0') {
pmprintf("%s: pid must be a numeric process id\n",
pmProgname);
opts.errors++;
}
}
}
}
if (opts.errors) {
pmUsageMessage(&opts);
exit(1);
}
if (pmnsfile == PM_NS_DEFAULT) {
if ((sts = pmLoadNameSpace(pmnsfile)) < 0) {
fprintf(stderr, "%s: Cannot load default namespace: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
}
else {
if ((sts = pmLoadASCIINameSpace(pmnsfile, 1)) < 0) {
fprintf(stderr, "%s: Cannot load namespace from \"%s\": %s\n",
pmProgname, pmnsfile, pmErrStr(sts));
exit(1);
}
}
/* initialize the "fake context" ... */
setup_context();
setlinebuf(stdout);
setlinebuf(stderr);
#ifdef HAVE_ATEXIT
atexit(cleanup);
#endif
for ( ; ; ) {
initmetriclist();
yyparse();
if (yywrap()) {
if (iflag)
putchar('\n');
break;
}
__pmSetInternalState(PM_STATE_PMCS);
switch (stmt_type) {
case OPEN:
profile_changed = 1;
break;
case CLOSE:
switch (connmode) {
case CONN_DSO:
closedso();
break;
case CONN_DAEMON:
closepmda();
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
connmode = NO_CONN;
break;
case DESC:
switch (connmode) {
case CONN_DSO:
dodso(PDU_DESC_REQ);
break;
case CONN_DAEMON:
dopmda(PDU_DESC_REQ);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case FETCH:
switch (connmode) {
case CONN_DSO:
dodso(PDU_FETCH);
break;
case CONN_DAEMON:
dopmda(PDU_FETCH);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case INSTANCE:
switch (connmode) {
case CONN_DSO:
dodso(PDU_INSTANCE_REQ);
break;
case CONN_DAEMON:
dopmda(PDU_INSTANCE_REQ);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case STORE:
switch (connmode) {
case CONN_DSO:
dodso(PDU_RESULT);
break;
case CONN_DAEMON:
dopmda(PDU_RESULT);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case HELP:
dohelp(param.number, param.pmid);
break;
case WATCH:
break;
case DBG:
pmDebug = param.number;
break;
case QUIT:
goto done;
case STATUS:
dostatus();
break;
case INFO:
switch (connmode) {
case CONN_DSO:
dodso(PDU_TEXT_REQ);
break;
case CONN_DAEMON:
dopmda(PDU_TEXT_REQ);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case NAMESPACE:
if (cmd_namespace != NULL)
free(cmd_namespace);
cmd_namespace = strdup(param.name);
if (cmd_namespace == NULL) {
fprintf(stderr, "%s: No memory for new namespace\n",
pmProgname);
exit(1);
}
pmUnloadNameSpace();
strcpy(cmd_namespace, param.name);
if ((sts = pmLoadASCIINameSpace(cmd_namespace, 1)) < 0) {
fprintf(stderr, "%s: Cannot load namespace from \"%s\": %s\n",
pmProgname, cmd_namespace, pmErrStr(sts));
pmUnloadNameSpace();
if (pmnsfile == PM_NS_DEFAULT) {
fprintf(stderr, "%s: Reload default namespace\n",
pmProgname);
if ((sts = pmLoadNameSpace(pmnsfile)) < 0) {
fprintf(stderr,
"%s: Cannot load default namespace: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
}
else {
fprintf(stderr, "%s: Reload namespace from \"%s\"\n",
pmProgname, pmnsfile);
if ((sts = pmLoadASCIINameSpace(pmnsfile, 1)) < 0) {
fprintf(stderr,
"%s: Cannot load namespace from \"%s\""
": %s\n",
pmProgname, pmnsfile, pmErrStr(sts));
exit(1);
}
}
}
break;
case EOL:
break;
case PMNS_NAME:
switch (connmode) {
case CONN_DSO:
dodso(PDU_PMNS_IDS);
break;
case CONN_DAEMON:
dopmda(PDU_PMNS_IDS);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case PMNS_PMID:
switch (connmode) {
case CONN_DSO:
dodso(PDU_PMNS_NAMES);
break;
case CONN_DAEMON:
dopmda(PDU_PMNS_NAMES);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case PMNS_CHILDREN:
switch (connmode) {
case CONN_DSO:
dodso(PDU_PMNS_CHILD);
break;
case CONN_DAEMON:
dopmda(PDU_PMNS_CHILD);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case PMNS_TRAVERSE:
switch (connmode) {
case CONN_DSO:
dodso(PDU_PMNS_TRAVERSE);
break;
case CONN_DAEMON:
dopmda(PDU_PMNS_TRAVERSE);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case ATTR:
switch (connmode) {
case CONN_DSO:
dodso(PDU_AUTH);
break;
case CONN_DAEMON:
dopmda(PDU_AUTH);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
default:
printf("Unexpected result (%d) from parser?\n", stmt_type);
break;
}
__pmSetInternalState(PM_STATE_APPL);
}
done:
cleanup();
exit(0);
}
int
main(int argc, char *argv[])
{
register int i;
int c;
char *p;
char path[MAXPATHLEN];
pmOptions opts = {
.short_options = allflags,
.flags = PM_OPTFLAG_BOUNDARIES,
};
/*
** preserve command arguments to allow restart of other version
*/
argvp = argv;
/*
** read defaults-files /etc/atoprc en $HOME/.atoprc (if any)
*/
readrc("/etc/atoprc", 1);
if ( (p = getenv("HOME")) )
{
snprintf(path, sizeof(path), "%s/.atoprc", p);
path[sizeof(path)-1] = '\0';
readrc(path, 0);
}
/*
** check if we are supposed to behave as 'atopsar'
** i.e. system statistics only
*/
__pmSetProgname(argv[0]);
if (strcmp(pmProgname, "pcp-atopsar") == 0)
return atopsar(argc, argv);
__pmStartOptions(&opts);
if (opts.narchives > 0)
rawreadflag++;
/*
** interpret command-line arguments & flags
*/
if (argc > 1)
{
/*
** gather all flags for visualization-functions
**
** generic flags will be handled here;
** unrecognized flags are passed to the print-routines
*/
i = 0;
while (i < MAXFL-1 && (c = pmgetopt_r(argc, argv, &opts)) != EOF)
{
switch (c)
{
case '?': /* usage wanted ? */
prusage(pmProgname);
break;
case 'V': /* version wanted ? */
printf("%s\n", getstrvers());
exit(0);
case 'w': /* writing of raw data ? */
rawname = opts.optarg;
rawwriteflag++;
break;
case 'r': /* reading of raw data ? */
rawarchive(&opts, opts.optarg);
rawreadflag++;
break;
case 'S': /* midnight limit ? */
midnightflag++;
break;
case 'a': /* all processes per sample ? */
deviatonly = 0;
break;
case 'R': /* all processes per sample ? */
calcpss = 1;
break;
case 'b': /* begin time ? */
opts.start_optarg = abstime(opts.optarg);
break;
case 'e': /* end time ? */
opts.finish_optarg = abstime(opts.optarg);
break;
case 'P': /* parseable output? */
if ( !parsedef(opts.optarg) )
prusage(pmProgname);
vis.show_samp = parseout;
break;
case 'L': /* line length */
if ( !numeric(opts.optarg) )
prusage(pmProgname);
linelen = atoi(opts.optarg);
break;
default: /* gather other flags */
flaglist[i++] = c;
}
}
/*
** get optional interval-value and optional number of samples
*/
if (opts.optind < argc && opts.optind < MAXFL)
{
char *endnum, *arg;
arg = argv[opts.optind++];
if (pmParseInterval(arg, &opts.interval, &endnum) < 0)
{
pmprintf(
"%s: %s option not in pmParseInterval(3) format:\n%s\n",
pmProgname, arg, endnum);
free(endnum);
opts.errors++;
}
else
interval = opts.interval;
if (opts.optind < argc)
{
arg = argv[opts.optind];
if (!numeric(arg))
prusage(pmProgname);
if ((opts.samples = atoi(arg)) < 1)
prusage(pmProgname);
nsamples = opts.samples;
}
}
}
__pmEndOptions(&opts);
if (opts.errors)
prusage(pmProgname);
/*
** find local host details (no privileged access required)
*/
setup_globals(&opts);
/*
** check if we are in data recording mode
*/
if (rawwriteflag)
{
rawwrite(&opts, rawname, &interval, nsamples, midnightflag);
cleanstop(0);
}
/*
** catch signals for proper close-down
*/
signal(SIGHUP, cleanstop);
signal(SIGTERM, cleanstop);
/*
** switch-on the process-accounting mechanism to register the
** (remaining) resource-usage by processes which have finished
*/
acctreason = acctswon();
/*
** determine properties (like speed) of all interfaces
*/
initifprop();
/*
** open socket to the IP layer to issue getsockopt() calls later on
*/
netatop_ipopen();
/*
** start the engine now .....
*/
engine();
cleanstop(0);
return 0; /* never reached */
}
int
main(int argc, char **argv)
{
int c;
int skip_if_false = 0;
int incomment = 0;
char *ip;
currfile = &file_ctl[0];
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'D': /* define */
for (ip = opts.optarg; *ip; ip++) {
if (*ip == '=')
*ip = ' ';
}
snprintf(ibuf, sizeof(ibuf), "#define %s\n", opts.optarg);
currfile->fname = "<arg>";
currfile->lineno = opts.optind;
directive();
break;
case '?':
default:
opts.errors++;
break;
}
}
if (opts.errors || opts.optind < argc - 1) {
pmUsageMessage(&opts);
exit(1);
}
currfile->lineno = 0;
if (opts.optind == argc) {
currfile->fname = "<stdin>";
currfile->fin = stdin;
}
else {
currfile->fname = argv[opts.optind];
currfile->fin = openfile(currfile->fname);
if (currfile->fin == NULL) {
err((char *)pmErrStr(-oserror()));
/*NOTREACHED*/
}
}
printf("# %d \"%s\"\n", currfile->lineno+1, currfile->fname);
for ( ; ; ) {
if (fgets(ibuf, sizeof(ibuf), currfile->fin) == NULL) {
fclose(currfile->fin);
if (currfile == &file_ctl[0])
break;
free(currfile->fname);
currfile--;
printf("# %d \"%s\"\n", currfile->lineno+1, currfile->fname);
continue;
}
currfile->lineno++;
/* strip comments ... */
for (ip = ibuf; *ip ; ip++) {
if (incomment) {
if (*ip == '*' && ip[1] == '/') {
/* end of comment */
incomment = 0;
*ip++ = ' ';
*ip = ' ';
}
else
*ip = ' ';
}
else {
if (*ip == '/' && ip[1] == '*') {
/* start of comment */
incomment = currfile->lineno;
*ip++ = ' ';
*ip = ' ';
}
}
}
ip--;
while (ip >= ibuf && isspace((int)*ip)) ip--;
*++ip = '\n';
*++ip = '\0';
if (incomment && ibuf[0] == '\n') {
printf("\n");
continue;
}
if (ibuf[0] == '#') {
/* cpp control line */
if (strncmp(ibuf, "#include", strlen("#include")) == 0) {
char *p;
char *pend;
char c;
FILE *f;
static char tmpbuf[MAXPATHLEN];
if (skip_if_false) {
printf("\n");
continue;
}
p = &ibuf[strlen("#include")];
while (*p && isblank((int)*p)) p++;
if (*p != '"' && *p != '<') {
err("Expected \" or < after #include");
/*NOTREACHED*/
}
pend = ++p;
while (*pend && *pend != '\n' &&
((p[-1] != '"' || *pend != '"') &&
(p[-1] != '<' || *pend != '>'))) pend++;
if (p[-1] == '"' && *pend != '"') {
err("Expected \" after file name");
/*NOTREACHED*/
}
if (p[-1] == '<' && *pend != '>') {
err("Expected > after file name");
/*NOTREACHED*/
}
if (currfile == &file_ctl[MAXLEVEL-1]) {
err("#include nesting too deep");
/*NOTREACHED*/
}
if (pend[1] != '\n' && pend[1] != '\0') {
err("Unexpected extra text in #include line");
/*NOTREACHED*/
}
c = *pend;
*pend = '\0';
f = openfile(p);
if (f == NULL && file_ctl[0].fin != stdin) {
/* check in directory of file from command line */
static int sep;
static char *dir = NULL;
if (dir == NULL) {
/*
* some versions of dirname() clobber the input
* argument, some do not ... hence the obscurity
* here
*/
static char *dirbuf;
dirbuf = strdup(file_ctl[0].fname);
if (dirbuf == NULL) {
__pmNoMem("pmcpp: dir name alloc", strlen(file_ctl[0].fname)+1, PM_FATAL_ERR);
/*NOTREACHED*/
}
dir = dirname(dirbuf);
sep = __pmPathSeparator();
}
snprintf(tmpbuf, sizeof(tmpbuf), "%s%c%s", dir, sep, p);
f = openfile(tmpbuf);
if (f != NULL)
p = tmpbuf;
}
if (f == NULL) {
/* check in $PCP_VAR_DIR/pmns */
static int sep;
static char *var_dir = NULL;
if (var_dir == NULL) {
var_dir = pmGetConfig("PCP_VAR_DIR");
sep = __pmPathSeparator();
}
snprintf(tmpbuf, sizeof(tmpbuf), "%s%cpmns%c%s", var_dir, sep, sep, p);
f = openfile(tmpbuf);
if (f != NULL)
p = tmpbuf;
}
if (f == NULL) {
*pend = c;
err("Cannot open file for #include");
/*NOTREACHED*/
}
currfile++;
currfile->lineno = 0;
currfile->fin = f;
currfile->fname = strdup(p);
*pend = c;
if (currfile->fname == NULL) {
__pmNoMem("pmcpp: file name alloc", strlen(p)+1, PM_FATAL_ERR);
/*NOTREACHED*/
}
printf("# %d \"%s\"\n", currfile->lineno+1, currfile->fname);
}
else {
/* expect other cpp control ... */
skip_if_false = directive();
printf("\n");
}
continue;
}
if (skip_if_false)
printf("\n");
else {
if (nmacro > 0)
do_macro();
printf("%s", ibuf);
}
}
/* EOF for the top level file */
if (incomment) {
char msgbuf[80];
snprintf(msgbuf, sizeof(msgbuf), "Comment at line %d not terminated before end of file", incomment);
currfile->lineno = 0;
err(msgbuf);
exit(1);
}
exit(0);
}
int
main(int argc, char **argv)
{
int n;
int c;
int i;
int sts;
char *pmnsfile = PM_NS_DEFAULT;
char *fname = NULL;
char pathname[MAXPATHLEN];
FILE *inf;
char buf[MAXENTRY+MAXLINE];
char *endnum;
char *bp;
char *p;
int skip;
help_idx_t hdr;
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'D': /* debug flag */
if ((sts = __pmParseDebug(opts.optarg)) < 0) {
pmprintf("%s: unrecognized debug flag specification (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
}
else
pmDebug |= sts;
break;
case 'n': /* alternative namespace file */
pmnsfile = opts.optarg;
break;
case 'o': /* alternative output file name */
fname = opts.optarg;
break;
case 'V': /* more chit-chat */
verbose++;
break;
case 'v': /* version 2 only these days */
version = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0') {
pmprintf("%s: -v requires numeric argument\n", pmProgname);
opts.errors++;
}
if (version != 2) {
pmprintf("%s: deprecated option - only version 2 is supported\n",
pmProgname);
opts.errors++;
}
break;
case '?':
default:
opts.errors++;
break;
}
}
if (opts.errors) {
pmUsageMessage(&opts);
exit(2);
}
if ((n = pmLoadNameSpace(pmnsfile)) < 0) {
fprintf(stderr, "%s: pmLoadNameSpace: %s\n", pmProgname, pmErrStr(n));
exit(2);
}
do {
if (opts.optind < argc) {
filename = argv[opts.optind];
if ((inf = fopen(filename, "r")) == NULL) {
perror(filename);
exit(2);
}
if (fname == NULL)
fname = filename;
}
else {
if (fname == NULL) {
fprintf(stderr,
"%s: need either a -o option or a filename "
"argument to name the output file\n", pmProgname);
exit(2);
}
filename = "<stdin>";
inf = stdin;
}
if (version == 2 && f == NULL) {
sprintf(pathname, "%s.pag", fname);
if ((f = fopen(pathname, "w")) == NULL) {
fprintf(stderr, "%s: fopen(\"%s\", ...) failed: %s\n",
pmProgname, pathname, osstrerror());
exit(2);
}
/* header: 2 => pag cf 1 => dir */
fprintf(f, "PcPh2%c\n", '0' + version);
}
bp = buf;
skip = 1;
for ( ; ; ) {
if (fgets(bp, MAXLINE, inf) == NULL) {
skip = -1;
*bp = '@';
}
ln++;
if (bp[0] == '#')
continue;
if (bp[0] == '@') {
/* start of a new entry */
if (bp > buf) {
/* really have a prior entry */
p = bp - 1;
while (p > buf && *p == '\n')
p--;
*++p = '\n';
*++p = '\0';
newentry(buf);
}
if (skip == -1)
break;
skip = 0;
bp++; /* skip '@' */
while (*bp && isspace((int)*bp))
bp++;
if (bp[0] == '\0') {
if (verbose)
fprintf(stderr, "%s: [%s:%d] null entry?\n",
pmProgname, filename, ln);
skip = 1;
bp = buf;
if (!status) status = 1;
}
else {
for (p = bp; *p; p++)
;
memmove(buf, bp, p - bp + 1);
for (bp = buf; *bp; bp++)
;
}
}
if (skip)
continue;
for (p = bp; *p; p++)
;
if (bp > buf && p[-1] != '\n') {
*p++ = '\n';
*p = '\0';
fprintf(stderr, "%s: [%s:%d] long line split after ...\n%s",
pmProgname, filename, ln, buf);
ln--;
if (!status) status = 1;
}
bp = p;
if (bp > &buf[MAXENTRY]) {
bp = &buf[MAXENTRY];
bp[-1] = '\0';
bp[-2] = '\n';
fprintf(stderr, "%s: [%s:%d] entry truncated after ... %s",
pmProgname, filename, ln, &bp[-64]);
skip = 1;
if (!status) status = 1;
}
}
fclose(inf);
opts.optind++;
} while (opts.optind < argc);
if (f != NULL) {
fclose(f);
/* do the directory index ... */
sprintf(pathname, "%s.dir", fname);
if ((f = fopen(pathname, "w")) == NULL) {
fprintf(stderr, "%s: fopen(\"%s\", ...) failed: %s\n",
pmProgname, pathname, osstrerror());
exit(2);
}
/* index header */
hdr.pmid = 0x50635068; /* "PcPh" */
/* "1" => dir, next char is version */
hdr.off_oneline = 0x31000000 | (('0' + version) << 16);
hdr.off_text = thisindex + 1; /* # entries */
if (fwrite(&hdr, sizeof(hdr), 1, f) != 1 || ferror(f)) {
fprintf(stderr, "%s: fwrite index failed: %s\n",
pmProgname, osstrerror());
exit(2);
}
/* sort and write index */
qsort((void *)hindex, thisindex+1, sizeof(hindex[0]), idcomp);
for (i = 0; i <= thisindex; i++) {
if (fwrite(&hindex[i], sizeof(hindex[0]), 1, f) != 1
|| ferror(f)) {
fprintf(stderr, "%s: fwrite index failed: %s\n",
pmProgname, osstrerror());
exit(2);
}
}
}
exit(status);
}
static void
ParseOptions(int argc, char *argv[], int *nports)
{
int c;
int sts;
char *endptr;
int usage = 0;
int val;
endptr = pmGetConfig("PCP_PMCDCONF_PATH");
strncpy(configFileName, endptr, sizeof(configFileName)-1);
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'A': /* disable pmcd service advertising */
__pmServerClearFeature(PM_SERVER_FEATURE_DISCOVERY);
break;
case 'c': /* configuration file */
strncpy(configFileName, opts.optarg, sizeof(configFileName)-1);
break;
case 'C': /* path to NSS certificate database */
certdb = opts.optarg;
break;
case 'D': /* debug flag */
sts = __pmParseDebug(opts.optarg);
if (sts < 0) {
pmprintf("%s: unrecognized debug flag specification (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
}
pmDebug |= sts;
break;
case 'f':
/* foreground, i.e. do _not_ run as a daemon */
run_daemon = 0;
break;
case 'i':
/* one (of possibly several) interfaces for client requests */
__pmServerAddInterface(opts.optarg);
break;
case 'H':
/* use the given name as the pmcd.hostname for this host */
_pmcd_hostname = opts.optarg;
break;
case 'l':
/* log file name */
logfile = opts.optarg;
break;
case 'L': /* Maximum size for PDUs from clients */
val = (int)strtol(opts.optarg, NULL, 0);
if (val <= 0) {
pmprintf("%s: -L requires a positive value\n", pmProgname);
opts.errors++;
} else {
__pmSetPDUCeiling(val);
}
break;
case 'N':
dupok = 0;
/*FALLTHROUGH*/
case 'n':
/* name space file name */
pmnsfile = opts.optarg;
break;
case 'p':
if (__pmServerAddPorts(opts.optarg) < 0) {
pmprintf("%s: -p requires a positive numeric argument (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
} else {
*nports += 1;
}
break;
case 'P': /* password file for certificate database access */
dbpassfile = opts.optarg;
break;
case 'q':
val = (int)strtol(opts.optarg, &endptr, 10);
if (*endptr != '\0' || val <= 0.0) {
pmprintf("%s: -q requires a positive numeric argument\n",
pmProgname);
opts.errors++;
} else {
_creds_timeout = val;
}
break;
case 's': /* path to local unix domain socket */
snprintf(sockpath, sizeof(sockpath), "%s", opts.optarg);
break;
case 'S': /* only allow authenticated clients */
__pmServerSetFeature(PM_SERVER_FEATURE_CREDS_REQD);
break;
case 't':
val = (int)strtol(opts.optarg, &endptr, 10);
if (*endptr != '\0' || val < 0.0) {
pmprintf("%s: -t requires a positive numeric argument\n",
pmProgname);
opts.errors++;
} else {
_pmcd_timeout = val;
}
break;
case 'T':
val = (int)strtol(opts.optarg, &endptr, 10);
if (*endptr != '\0' || val < 0) {
pmprintf("%s: -T requires a positive numeric argument\n",
pmProgname);
opts.errors++;
} else {
_pmcd_trace_mask = val;
}
break;
case 'U':
username = opts.optarg;
break;
case 'x':
fatalfile = opts.optarg;
break;
case '?':
usage = 1;
break;
default:
opts.errors++;
break;
}
}
if (usage || opts.errors || opts.optind < argc) {
pmUsageMessage(&opts);
if (usage)
exit(0);
DontStart();
}
}
int
main(int argc, char **argv)
{
int sts;
int first = 1;
int c;
int j;
int force = 0;
int asis = 0;
int dupok = 0;
__pmnsNode *tmp;
umask((mode_t)022); /* anything else is pretty silly */
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'a':
asis = 1;
break;
case 'd': /* duplicate PMIDs are OK */
dupok = 1;
break;
case 'D': /* debug flag */
if ((sts = __pmParseDebug(opts.optarg)) < 0) {
pmprintf("%s: unrecognized debug flag specification (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
} else {
pmDebug |= sts;
}
break;
case 'f': /* force ... unlink file first */
force = 1;
break;
case 'v':
verbose++;
break;
case '?':
default:
opts.errors++;
break;
}
}
if (opts.errors || opts.optind > argc - 2) {
pmUsageMessage(&opts);
exit(1);
}
if (force)
unlink(argv[argc-1]);
if (access(argv[argc-1], F_OK) == 0) {
fprintf(stderr, "%s: Error: output PMNS file \"%s\" already exists!\nYou must either remove it first, or use -f\n",
pmProgname, argv[argc-1]);
exit(1);
}
/*
* from here on, ignore SIGHUP, SIGINT and SIGTERM to protect
* the integrity of the new ouput file
*/
__pmSetSignalHandler(SIGHUP, SIG_IGN);
__pmSetSignalHandler(SIGINT, SIG_IGN);
__pmSetSignalHandler(SIGTERM, SIG_IGN);
if ((outf = fopen(argv[argc-1], "w+")) == NULL) {
fprintf(stderr, "%s: Error: cannot create output PMNS file \"%s\": %s\n", pmProgname, argv[argc-1], osstrerror());
exit(1);
}
if (!asis)
sortargs(&argv[opts.optind], argc - opts.optind - 1);
j = opts.optind;
while (j < argc-1) {
if (verbose)
printf("%s:\n", argv[j]);
if ((sts = pmLoadASCIINameSpace(argv[j], dupok)) < 0) {
fprintf(stderr, "%s: Error: pmLoadNameSpace(%s): %s\n",
pmProgname, argv[j], pmErrStr(sts));
exit(1);
}
{
__pmnsTree *t;
t = __pmExportPMNS();
if (t == NULL) {
/* sanity check - shouldn't ever happen */
fprintf(stderr, "Exported PMNS is NULL !");
exit(1);
}
tmp = t->root;
}
if (first) {
root = tmp;
first = 0;
}
else {
pmns_traverse(tmp, 0, "", merge);
}
j++;
}
pmns_output(root, outf);
fclose(outf);
/*
* now load the merged PMNS to check for errors ...
*/
if ((sts = pmLoadASCIINameSpace(argv[argc-1], dupok)) < 0) {
fprintf(stderr, "%s: Error: pmLoadNameSpace(%s): %s\n",
pmProgname, argv[argc-1], pmErrStr(sts));
exit(1);
}
exit(0);
}
