int
main(int argc, char **argv)
{
int errflag = 0;
int sts;
int c;
__pmSetProgname(argv[0]);
indomp = (__pmInDom_int *)&indom;
while ((c = getopt(argc, argv, "D:")) != EOF) {
switch (c) {
#ifdef PCP_DEBUG
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
#endif
case '?':
default:
errflag++;
break;
}
}
if (errflag) {
fprintf(stderr, "Usage: %s [-D...] [a|b|c|d|...|i 1|2|3}\n", pmProgname);
exit(1);
}
while (optind < argc) {
if (strcmp(argv[optind], "a") == 0) _a(0, 1, 1);
else if (strcmp(argv[optind], "b") == 0) _b();
else if (strcmp(argv[optind], "c") == 0) _c();
else if (strcmp(argv[optind], "d") == 0) _a(1, 0, 1);
else if (strcmp(argv[optind], "e") == 0) _e(0);
else if (strcmp(argv[optind], "f") == 0) _e(3600);
else if (strcmp(argv[optind], "g") == 0) _g();
else if (strcmp(argv[optind], "h") == 0) _h();
else if (strcmp(argv[optind], "i") == 0) {
optind++;
_i(atoi(argv[optind]));
}
else if (strcmp(argv[optind], "j") == 0) _j();
else
fprintf(stderr, "torture_cache: no idea what to do with option \"%s\"\n", argv[optind]);
optind++;
}
exit(0);
}
/*
* Set up agent if running as daemon.
*/
int
main(int argc, char **argv)
{
int sep = __pmPathSeparator();
pmdaInterface dispatch;
isDSO = 0;
__pmSetProgname(argv[0]);
snprintf(helppath, sizeof(helppath), "%s%c" "papi" "%c" "help",
pmGetConfig("PCP_PMDAS_DIR"), sep, sep);
pmdaDaemon(&dispatch, PMDA_INTERFACE_6, pmProgname, PAPI, "papi.log", helppath);
pmdaGetOptions(argc, argv, &opts, &dispatch);
if (opts.errors) {
pmdaUsageMessage(&opts);
exit(1);
}
pmdaOpenLog(&dispatch);
papi_init(&dispatch);
pmdaConnect(&dispatch);
pmdaMain(&dispatch);
free(ctxtab);
free(papi_info);
free(values);
exit(0);
}
QedApp::QedApp(int &argc, char **argv) : QApplication(argc, argv)
{
// TODO: rewrite with pmOptions
__pmSetProgname(argv[0]);
my.argc = argc;
my.argv = argv;
my.pmnsfile = NULL;
my.Lflag = 0;
my.Sflag = NULL;
my.Tflag = NULL;
my.Aflag = NULL;
my.Oflag = NULL;
my.zflag = 0;
my.tz = NULL;
my.port = -1;
QCoreApplication::setOrganizationName("PCP");
QCoreApplication::setApplicationName(pmProgname);
QCoreApplication::setApplicationVersion(pmGetConfig("PCP_VERSION"));
QString confirm = pmGetConfig("PCP_BIN_DIR");
confirm.prepend("PCP_XCONFIRM_PROG=");
confirm.append("/pmquery");
putenv(strdup((const char *)confirm.toLatin1()));
if (getenv("PCP_STDERR") == NULL) // do not overwrite, for QA
putenv(strdup("PCP_STDERR=DISPLAY"));
}
int
main(int argc, char **argv)
{
int c, sep = __pmPathSeparator();
int errflag = 0;
char helppath[MAXPATHLEN];
_isDSO = 0;
__pmSetProgname(argv[0]);
__pmGetUsername(&username);
sprintf(helppath, "%s%c" "darwin" "%c" "help",
pmGetConfig("PCP_PMDAS_DIR"), sep, sep);
pmdaDaemon(&dispatch, PMDA_INTERFACE_3, pmProgname, DARWIN, "darwin.log",
helppath);
while ((c = pmdaGetOpt(argc, argv, "D:d:i:l:pu:U:6:?", &dispatch, &errflag)) != EOF) {
switch(c) {
case 'U':
username = optarg;
break;
default:
errflag++;
}
}
if (errflag)
usage();
pmdaOpenLog(&dispatch);
darwin_init(&dispatch);
pmdaConnect(&dispatch);
pmdaMain(&dispatch);
exit(0);
}
/*
* Set up the agent if running as a daemon.
*/
int
main(int argc, char **argv)
{
int err = 0;
char log_file[] = "pmda_ctdb.log";
pmdaInterface dispatch;
__pmSetProgname(argv[0]);
pmdaDaemon(&dispatch, PMDA_INTERFACE_2, pmProgname, CTDB,
log_file, helpfile());
if (pmdaGetOpt(argc, argv, "d:i:l:pu:?", &dispatch, &err) != EOF) {
err++;
}
if (err) {
usage();
}
pmdaOpenLog(&dispatch);
pmda_ctdb_init(&dispatch);
pmdaConnect(&dispatch);
pmdaMain(&dispatch);
exit(0);
}
/*
* Set up the agent if running as a daemon.
*/
int
main(int argc, char **argv)
{
int c, err = 0;
int sep = __pmPathSeparator();
pmdaInterface dispatch;
char mypath[MAXPATHLEN];
isDSO = 0;
__pmSetProgname(argv[0]);
__pmGetUsername(&username);
snprintf(mypath, sizeof(mypath), "%s%c" "openbsd" "%c" "help",
pmGetConfig("PCP_PMDAS_DIR"), sep, sep);
pmdaDaemon(&dispatch, PMDA_INTERFACE_5, pmProgname, OPENBSD,
"openbsd.log", mypath);
while ((c = pmdaGetOpt(argc, argv, "D:d:i:l:pu:U:6:?", &dispatch, &err)) != EOF) {
switch(c) {
case 'U':
username = optarg;
break;
default:
err++;
}
}
if (err)
usage();
pmdaOpenLog(&dispatch);
openbsd_init(&dispatch);
pmdaConnect(&dispatch);
pmdaMain(&dispatch);
exit(0);
}
/*
* Set up the agent if running as a daemon.
*/
int
main(int argc, char **argv)
{
int sep = __pmPathSeparator();
pmdaInterface desc;
_isDSO = 0;
__pmSetProgname(argv[0]);
__pmGetUsername(&username);
snprintf(mypath, sizeof(mypath), "%s%c" "aix" "%c" "help",
pmGetConfig("PCP_PMDAS_DIR"), sep, sep);
pmdaDaemon(&desc, PMDA_INTERFACE_3, pmProgname, AIX, "aix.log", mypath);
pmdaGetOptions(argc, argv, &opts, &desc);
if (opts.errors) {
pmdaUsageMessage(&opts);
exit(1);
}
if (opts.username)
username = opts.username;
pmdaOpenLog(&desc);
aix_init(&desc);
pmdaConnect(&desc);
pmdaMain(&desc);
exit(0);
}
int
main(int argc, char **argv)
{
int c;
int sts;
int errflag = 0;
int max, min;
static char *usage = "[-D N]";
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "D:")) != EOF) {
switch (c) {
#ifdef PCP_DEBUG
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
#endif
case '?':
default:
errflag++;
break;
}
}
if (errflag || optind != argc) {
printf("Usage: %s %s\n", pmProgname, usage);
exit(1);
}
printf("%d -> %s\n", PM_SEM_COUNTER, pmSemStr(PM_SEM_COUNTER));
printf("%d -> %s\n", PM_SEM_INSTANT, pmSemStr(PM_SEM_INSTANT));
printf("%d -> %s\n", PM_SEM_DISCRETE, pmSemStr(PM_SEM_DISCRETE));
printf("\nAnd now some error cases ...\n");
max = PM_SEM_COUNTER > PM_SEM_INSTANT ? PM_SEM_COUNTER : PM_SEM_INSTANT;
if (PM_SEM_DISCRETE > max)
max = PM_SEM_DISCRETE;
min = PM_SEM_COUNTER < PM_SEM_INSTANT ? PM_SEM_COUNTER : PM_SEM_INSTANT;
if (PM_SEM_DISCRETE < min)
min = PM_SEM_DISCRETE;
printf("out of range high -> %s\n", pmSemStr(max + 1));
printf("out of range low -> %s\n", pmSemStr(min + 1));
exit(0);
}
int
main(int argc, char **argv)
{
int err = 0;
pmdaInterface desc;
__pmSetProgname(argv[0]);
_isDSO = 0;
#if defined(BUG_5)
/*
* we don't grok PMDA_INTERFACE_77 ... 77 is arbitrary, just needs
* to be bigger than currently valid and supported
*/
pmdaDaemon(&desc, 77, pmProgname, BROKEN, _logFile,
_helpText);
#elif defined(VERSION_1)
pmdaDaemon(&desc, PMDA_PROTOCOL_2, pmProgname, BROKEN, _logFile,
_helpText);
#else
pmdaDaemon(&desc, PMDA_INTERFACE_2, pmProgname, BROKEN, _logFile,
_helpText);
#endif
if (desc.status != 0) {
fprintf(stderr, "pmdaDaemon() failed!\n");
/*
* we're going to exit() now, but first, shut down file
* descriptors to reduce chances of a race with dbpmda's first
* PDU send, e.g. in qa/274
*/
fclose(stdin);
fclose(stdout);
exit(1);
}
if (pmdaGetOpt(argc, argv, "D:d:h:i:l:pu:6:", &desc, &err) != EOF)
err++;
if (err)
usage();
pmdaOpenLog(&desc);
broken_init(&desc);
pmdaConnect(&desc);
pmdaMain(&desc);
exit(0);
}
int
main(int argc, char **argv)
{
int i;
__pmSetProgname(argv[0]);
for (i=1; i < argc; i++) {
pmiestats_t ps;
struct stat st;
int f = open(argv[i], O_RDONLY, 0);
if (f < 0) {
fprintf(stderr, "%s: cannot open %s - %s\n",
pmProgname, argv[i], osstrerror());
continue;
}
if (fstat(f, &st) < 0) {
fprintf(stderr, "%s: cannot get size of %s - %s\n",
pmProgname, argv[i], osstrerror());
goto closefile;
}
if (st.st_size != sizeof(ps)) {
fprintf(stderr, "%s: %s is not a valid pmie stats file\n",
pmProgname, argv[i]);
goto closefile;
}
if (read(f, &ps, sizeof(ps)) != sizeof(ps)) {
fprintf(stderr, "%s: cannot read %ld bytes from %s\n",
pmProgname, (long)sizeof(ps), argv[i]);
goto closefile;
}
if (ps.version != 1) {
fprintf(stderr, "%s: unsupported version %d in %s\n",
pmProgname, ps.version, argv[i]);
goto closefile;
}
printf ("%s\n%s\n%s\n", ps.config, ps.logfile, ps.defaultfqdn);
closefile:
close(f);
}
return 0;
}
int
main(int argc, char **argv)
{
struct stat sbuf;
char *file, *flags = NULL;
int c, err = 0, pid = 0;
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "f:p:")) != EOF) {
switch (c) {
case 'f':
flags = optarg;
break;
case 'p':
pid = atoi(optarg);
break;
default:
err++;
}
}
if (err || argc != optind + 1)
usage();
file = argv[optind];
c = open(file, O_RDWR, 0644);
if (c < 0) {
fprintf(stderr, "Cannot open %s for writing: %s\n",
file, strerror(errno));
exit(1);
}
fstat(c, &sbuf);
addr = __pmMemoryMap(c, sbuf.st_size, 1);
close(c);
if (flags)
write_flags(flags);
if (pid)
write_pid(pid);
__pmMemoryUnmap(addr, sbuf.st_size);
exit(0);
}
int
main(int argc, char* argv[])
{
char *endp;
long nfiles;
char *namebuf;
char *extptr;
int i, sts;
__pmSetProgname(argv[0]);
if (argc != 3)
usage();
nfiles = strtol(argv[2], &endp, 0);
if (*endp != '\0') {
fprintf(stderr, "nfiles \"%s\" is not numeric\n", argv[2]);
usage();
}
if (nfiles > LIMIT) {
fprintf(stderr, "be reasonable: nfiles limited to %d\n", LIMIT);
usage();
}
i = (int)strlen(argv[1]);
namebuf = (char *)malloc(i + 6);
if (namebuf == (char *)0) {
perror("error allocating filename buffer");
exit(1);
}
strcpy(namebuf, argv[1]);
namebuf[i++] = '.';
extptr = &namebuf[i];
for (i = 0; i < nfiles; i++) {
sprintf(extptr, "%04d", i);
if ((sts = creat(namebuf, 0777)) < 0) {
fprintf(stderr, "Error creating %s: %s\n", namebuf, strerror(errno));
exit(1);
}
else
close(sts);
}
exit(0);
}
int
main(int argc, char **argv)
{
int err = 0;
pmdaInterface desc;
__pmSetProgname(argv[0]);
_isDSO = 0;
#if defined(BUG_5)
/*
* we don't grok PMDA_INTERFACE_77 ... 77 is arbitrary, just needs
* to be bigger than currently valid and supported
*/
pmdaDaemon(&desc, 77, pmProgname, BROKEN, _logFile,
_helpText);
#elif defined(VERSION_1)
pmdaDaemon(&desc, PMDA_PROTOCOL_2, pmProgname, BROKEN, _logFile,
_helpText);
#else
pmdaDaemon(&desc, PMDA_INTERFACE_2, pmProgname, BROKEN, _logFile,
_helpText);
#endif
if (desc.status != 0) {
fprintf(stderr, "pmdaDaemon() failed!\n");
exit(1);
}
if (pmdaGetOpt(argc, argv, "D:d:h:i:l:pu:6:", &desc, &err) != EOF)
err++;
if (err)
usage();
pmdaOpenLog(&desc);
broken_init(&desc);
pmdaConnect(&desc);
pmdaMain(&desc);
exit(0);
}
int
main(int argc, char **argv)
{
int c;
int sts;
int e_sts = 0;
int errflag = 0;
int ahtype = 0;
int verbose = 0;
int quick = 0;
char *host = NULL; /* pander to gcc */
pmResult *result;
pmResult *prev = NULL;
struct timeval start = { 0,0 };
struct timeval end;
int tzh;
off_t trunc_size = 0;
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "a:D:t:qv?")) != EOF) {
switch (c) {
case 'a': /* archive name */
if (ahtype != 0) {
fprintf(stderr, "%s: at most one of -a and/or -h allowed\n", pmProgname);
errflag++;
}
ahtype = PM_CONTEXT_ARCHIVE;
host = optarg;
break;
#ifdef PCP_DEBUG
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
#endif
case 't': /* truncate */
trunc_size = atol(optarg);
break;
case 'q': /* quick */
quick = 1;
break;
case 'v': /* verbose */
verbose++;
break;
case '?':
default:
errflag++;
break;
}
}
if (errflag || optind < argc) {
fprintf(stderr,
"Usage: %s options ...\n\
\n\
Options\n\
-a archive metrics source is an archive log\n\
-t size truncate archive to size bytes\n\
-q quick (read last 3 records, not the whole archive)\n\
-v verbose\n",
pmProgname);
exit(1);
}
if (ahtype != PM_CONTEXT_ARCHIVE) {
fprintf(stderr, "%s: -a is not optional!\n", pmProgname);
exit(1);
}
/* truncate if -t specified, _before_ opening archive */
if (trunc_size != 0) {
if (access(host, W_OK) == 0) {
if (truncate(host, trunc_size) != 0) {
fprintf(stderr, "%s: file %s exists, but cannot truncate\n",
pmProgname, host);
exit(1);
}
}
else {
char path[MAXPATHLEN];
sprintf(path, "%s.0", host);
if (access(path, W_OK) == 0) {
if (truncate(path, trunc_size) != 0) {
fprintf(stderr, "%s: file %s exists, but cannot truncate\n",
pmProgname, path);
exit(1);
}
}
else {
fprintf(stderr, "%s: cannot find writeable %s or %s\n",
pmProgname, host, path);
exit(1);
}
}
}
if ((sts = pmNewContext(ahtype, host)) < 0) {
fprintf(stderr, "%s: Cannot open archive \"%s\": %s\n",
pmProgname, host, pmErrStr(sts));
exit(1);
}
/* force -z (timezone of archive */
if ((tzh = pmNewContextZone()) < 0) {
fprintf(stderr, "%s: Cannot set context timezone: %s\n",
pmProgname, pmErrStr(tzh));
exit(1);
}
sts = pmGetArchiveEnd(&end);
if (sts < 0) {
printf("pmGetArchiveEnd: %s\n", pmErrStr(sts));
}
else {
if (verbose) {
printf("pmGetArchiveEnd time: ");
printstamp(&end);
printf("\n");
}
}
sts = pmSetMode(PM_MODE_BACK, &end, 0);
if (sts < 0) {
printf("pmSetMode PM_MODE_BACK: %s\n", pmErrStr(sts));
exit(1);
}
sts = pmFetchArchive(&result);
if (sts < 0) {
printf("pmFetchArchive: %s\n", pmErrStr(sts));
e_sts = 1;
}
else {
if (verbose) {
printf("last result time (direct): ");
printstamp(&result->timestamp);
printf("\n");
}
if (result->timestamp.tv_sec != end.tv_sec ||
result->timestamp.tv_usec != end.tv_usec) {
printf("Mismatch: end=");
printstamp(&end);
printf(" direct=");
printstamp(&result->timestamp);
printf("\n");
e_sts = 1;
}
start.tv_sec = result->timestamp.tv_sec;
start.tv_usec = result->timestamp.tv_usec;
pmFreeResult(result);
}
if (quick && e_sts == 0) {
int i;
for (i = 0; i < 2; i++) {
sts = pmFetchArchive(&result);
if (sts >= 0) {
start.tv_sec = result->timestamp.tv_sec;
start.tv_usec = result->timestamp.tv_usec;
pmFreeResult(result);
}
}
}
else {
/* start from the epoch and move forward */
start.tv_sec = 0;
start.tv_usec = 0;
}
sts = pmSetMode(PM_MODE_FORW, &start, 0);
if (sts < 0) {
printf("pmSetMode PM_MODE_FORW: %s\n", pmErrStr(sts));
exit(1);
}
while ((sts = pmFetchArchive(&result)) >= 0) {
if (prev != NULL)
pmFreeResult(prev);
prev = result;
}
if (verbose) printf("pmFetchArchive: %s\n", pmErrStr(sts));
if (prev == NULL) {
printf("no results!\n");
}
else {
if (verbose) {
printf("last result time (serial): ");
printstamp(&prev->timestamp);
printf("\n");
}
if (prev->timestamp.tv_sec != end.tv_sec ||
prev->timestamp.tv_usec != end.tv_usec) {
printf("Mismatch: end=");
printstamp(&end);
printf(" serial=");
printstamp(&prev->timestamp);
printf("\n");
e_sts = 1;
}
pmFreeResult(prev);
}
exit(e_sts);
}
int
main(int argc, char *argv[])
{
int fd;
int port = 1214;
/* default port assigned to kazaa what ever that is! */
int hang = 0;
int i, sts;
int c;
int newfd;
struct sockaddr_in myAddr;
struct linger noLinger = {1, 0};
char *endnum;
int errflag = 0;
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "D:hp:?")) != EOF) {
switch (c) {
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
case 'h': /* hang after accept */
hang = 1;
break;
case 'p':
port = (int)strtol(optarg, &endnum, 10);
if (*endnum != '\0') {
fprintf(stderr, "%s: port argument must be a numeric internet port number\n", pmProgname);
exit(1);
}
break;
case '?':
default:
errflag++;
break;
}
}
if (errflag || optind != argc) {
fprintf(stderr, "Usage: %s [-D n] [-h] [-p port]\n", pmProgname);
exit(1);
}
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) {
perror("socket");
exit(1);
}
if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &i,
sizeof(i)) < 0) {
perror("setsockopt(nodelay)");
exit(1);
}
/* Don't linger on close */
if (setsockopt(fd, SOL_SOCKET, SO_LINGER, (char *) &noLinger, sizeof(noLinger)) < 0) {
perror("setsockopt(nolinger)");
exit(1);
}
memset(&myAddr, 0, sizeof(myAddr));
myAddr.sin_family = AF_INET;
myAddr.sin_addr.s_addr = htonl(INADDR_ANY);
myAddr.sin_port = htons(port);
sts = bind(fd, (struct sockaddr*)&myAddr, sizeof(myAddr));
if (sts < 0) {
fprintf(stderr, "bind(%d): %s\n", port, strerror(errno));
exit(1);
}
sts = listen(fd, 5); /* Max. of 5 pending connection requests */
if (sts == -1) {
perror("listen");
exit(1);
}
newfd = accept(fd, (struct sockaddr *)0, 0);
if (newfd < 0) {
fprintf(stderr, "%s: accept: %s\n", pmProgname, strerror(errno));
exit(1);
}
if (hang) {
/* wait for a signal ... */
pause();
exit(0);
}
/* drain input */
while ((sts = read(newfd, &c, 1)) == 1)
;
if (sts < 0) {
/*
* ECONNRESET is expected when client exits w/out closing
* socket.
*/
if (errno != ECONNRESET)
fprintf(stderr, "%s: read error: %s\n", pmProgname, pmErrStr(-errno));
}
exit(0);
}
int
main(int argc, char **argv)
{
static char helppath[MAXPATHLEN];
char *endnum;
pmdaInterface desc;
long minmem;
int c, err = 0, sep = __pmPathSeparator();
__pmSetProgname(argv[0]);
__pmGetUsername(&username);
minmem = getpagesize();
maxmem = (minmem > DEFAULT_MAXMEM) ? minmem : DEFAULT_MAXMEM;
snprintf(helppath, sizeof(helppath), "%s%c" "logger" "%c" "help",
pmGetConfig("PCP_PMDAS_DIR"), sep, sep);
pmdaDaemon(&desc, PMDA_INTERFACE_5, pmProgname, LOGGER,
"logger.log", helppath);
while ((c = pmdaGetOpt(argc, argv, "D:d:l:m:s:U:?", &desc, &err)) != EOF) {
switch (c) {
case 'm':
maxmem = strtol(optarg, &endnum, 10);
if (*endnum != '\0')
convertUnits(&endnum, &maxmem);
if (*endnum != '\0' || maxmem < minmem) {
fprintf(stderr, "%s: invalid max memory '%s' (min=%ld)\n",
pmProgname, optarg, minmem);
err++;
}
break;
case 's':
if (pmParseInterval(optarg, &interval, &endnum) < 0) {
fprintf(stderr, "%s: -s requires a time interval: %s\n",
pmProgname, endnum);
free(endnum);
err++;
}
break;
case 'U':
username = optarg;
break;
default:
err++;
break;
}
}
if (err || optind != argc -1)
usage();
pmdaOpenLog(&desc);
logger_init(&desc, argv[optind]);
pmdaConnect(&desc);
loggerMain(&desc);
event_shutdown();
exit(0);
}
int
main(int argc, char *argv[])
{
int ctx;
int sts;
int c;
int a;
int lflag = 0;
int errflag = 0;
static char *usage = "[-l] [-D debugopts]";
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "D:l")) != EOF) {
switch (c) {
#ifdef PCP_DEBUG
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
#endif
case 'l': /* linger when done */
lflag = 1;
break;
case '?':
default:
errflag++;
break;
}
}
if (errflag) {
printf("Usage: %s %s\n", pmProgname, usage);
exit(1);
}
fprintf(stderr, "Error expected ...\n");
if ((sts = __pmSetClientId("no context yet, bozo")) < 0) {
fprintf(stderr, "__pmSetClientId(...): %s\n",
pmErrStr(sts));
}
if ((ctx = pmNewContext(PM_CONTEXT_HOST, "localhost")) < 0) {
fprintf(stderr, "pmNewContext(..., \"localhost\"): %s\n",
pmErrStr(ctx));
exit(1);
}
for (a = optind; a < argc; a++) {
char *cp;
cp = (char *)malloc(strlen(argv[a])+strlen(TAG)+1);
strcpy(cp, TAG);
strcat(cp, argv[a]);
if ((sts = __pmSetClientId(cp)) < 0) {
fprintf(stderr, "__pmSetClientId(%s): %s\n",
cp, pmErrStr(sts));
}
else {
sts = system("pminfo -f pmcd.client.whoami");
if (sts != 0)
fprintf(stderr, "Warning: pminfo command: exit status %d\n", sts);
}
free(cp);
}
if (lflag)
pause();
exit(0);
}
void
getargs(int argc, char **argv)
{
#ifdef PCP_DEBUG
static char *debug = "[-D N]";
#else
static char *debug = "";
#endif
static char *usage = " [-h hostname] [-n pmnsfile] "
"[-i iterations] [-t refresh] [-v] "
"metric [metric ...]";
int errflag = 0;
char *endnum;
int c;
int i;
int sts;
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "D:h:n:i:t:v")) != EOF) {
switch (c) {
#ifdef PCP_DEBUG
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
#endif
case 'h': /* hostname for PMCD to contact */
host = optarg;
break;
case 'i': /* iterations */
iterations = (int)strtol(optarg, &endnum, 10);
if (*endnum != '\0') {
fprintf(stderr, "%s: -i requires numeric argument\n", pmProgname);
errflag++;
}
break;
case 'n': /* alternative name space file */
pmnsfile = optarg;
break;
case 't':
refresh = (int)strtol(optarg, &endnum, 10);
if (*endnum != '\0') {
fprintf(stderr, "%s: -t requires numeric argument\n", pmProgname);
errflag++;
}
break;
case 'v':
verbose = 1;
break;
case '?':
default:
errflag++;
break;
}
}
if (errflag) {
USAGE:
fprintf(stderr, "Usage: %s %s%s\n", pmProgname, debug, usage);
exit(1);
}
/* non-flag args are argv[optind] ... argv[argc-1] */
if (optind >= argc)
goto USAGE;
/* note metrics and dump them out */
for (i = 0; i < argc - optind; i++) {
metrics[i] = argv[optind+i];
if (strncmp(metrics[i], "hotproc.", 8) == 0) {
if (i > 0 && !is_hotproc) {
printf("%s: Error: all metrics should be from same agent\n",
pmProgname);
exit(1);
}
is_hotproc = 1;
}
else if (strncmp(metrics[i], "proc.", 5) == 0) {
if (i > 0 && is_hotproc) {
printf("%s: Error: all metrics should be from same agent\n",
pmProgname);
exit(1);
}
is_hotproc = 0;
}
else {
printf("%s: Error: all metrics should be from "
"proc or hotproc agent: %s\n", pmProgname, metrics[i]);
exit(1);
}
printf("metrics[%d] = <%s>\n", i, metrics[i]);
}
nmetrics = i;
if (nmetrics <= 0)
goto USAGE;
}
int
main(int argc, char **argv)
{
int sts;
int c;
int help = 0;
int oneline = 0;
char *pmnsfile = PM_NS_DEFAULT;
int errflag = 0;
int aflag = 0;
int eflag = 0;
int allpmid = 0;
int allindom = 0;
char *filename;
char *tp;
char *name;
int id;
int next_type;
char *endnum;
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "D:eHin:Opv:?")) != EOF) {
switch (c) {
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
case 'e': /* help text exists? */
eflag = 1;
break;
case 'H': /* help text */
help = 1;
break;
case 'i':
aflag++;
allindom = 1;
break;
case 'n': /* alternative namespace file */
pmnsfile = optarg;
break;
case 'O': /* oneline text */
oneline = 1;
break;
case 'p':
aflag++;
allpmid = 1;
break;
case 'v': /* version 2 only these days */
version = (int)strtol(optarg, &endnum, 10);
if (*endnum != '\0') {
fprintf(stderr, "%s: -v requires numeric argument\n", pmProgname);
errflag++;
}
if (version != 2) {
fprintf(stderr
,"%s: deprecated option - only version 2 is supported\n"
, pmProgname);
errflag++;
}
break;
case '?':
default:
errflag++;
break;
}
}
if (optind == argc) {
fprintf(stderr, "%s: missing helpfile argument\n\n", pmProgname);
errflag = 1;
}
if (aflag && optind < argc-1) {
fprintf(stderr, "%s: metricname arguments cannot be used with -i or -p\n\n",
pmProgname);
errflag = 1;
}
if (aflag == 0 && optind == argc-1 && oneline+help != 0) {
fprintf(stderr, "%s: -O or -H require metricname arguments or -i or -p\n\n",
pmProgname);
errflag = 1;
}
if (eflag && (allpmid || allindom)) {
fprintf(stderr, "%s: -e cannot be used with -i or -p\n\n",
pmProgname);
errflag = 1;
}
if (errflag || optind >= argc) {
fprintf(stderr,
"Usage: %s helpfile\n"
" %s [options] helpfile [metricname ...]\n"
"\n"
"Options:\n"
" -e exists check, only report metrics with no help text\n"
" -H display verbose help text\n"
" -i process all the instance domains\n"
" -n pmnsfile use an alternative PMNS\n"
" -O display the one line help summary\n"
" -p process all the metrics (PMIDs)\n"
" -v version deprecated (only version 2 format supported)\n"
"\n"
"No options implies silently check internal integrity of the helpfile.\n",
pmProgname, pmProgname);
exit(1);
}
filename = argv[optind++];
if ((handle = pmdaOpenHelp(filename)) < 0) {
fprintf(stderr, "pmdaOpenHelp: failed to open \"%s\": ", filename);
if (handle == -EINVAL)
fprintf(stderr, "Bad format, not version %d PCP help text\n", version);
else
fprintf(stderr, "%s\n", pmErrStr(handle));
exit(1);
}
if ((sts = pmLoadASCIINameSpace(pmnsfile, 1)) < 0) {
fprintf(stderr, "pmLoadASCIINameSpace(%s, 1): %s\n", pmnsfile, pmErrStr(sts));
exit(1);
}
if (help + oneline == 0 && (optind < argc || aflag))
/* if metric names, -p or -i => -O is default */
oneline = 1;
if (optind == argc && aflag == 0)
/* no metric names, process all entries */
aflag = 1;
if (eflag) {
if (optind == argc) {
sts = pmTraversePMNS("", dometric);
if (sts < 0) {
fprintf(stderr, "Error: pmTraversePMNS(\"\", ...): %s\n", pmErrStr(sts));
}
}
else {
for ( ; optind < argc; optind++) {
sts = pmTraversePMNS(argv[optind], dometric);
if (sts < 0)
fprintf(stderr, "Error: pmTraversePMNS(\"%s\", ...): %s\n", argv[optind], pmErrStr(sts));
}
}
exit(0);
}
while (optind < argc || aflag) {
if (aflag) {
if (next(&id, &next_type) == 0)
break;
#ifdef PCP_DEBUG
if ((pmDebug & DBG_TRACE_APPL0) && allindom+allpmid == 0)
fprintf(stderr, "next_type=%d id=0x%x\n", next_type, id);
#endif
if (next_type == 2) {
if (!allindom)
continue;
printf("\nInDom %s:", pmInDomStr((pmInDom)id));
}
else {
char **names;
if (!allpmid)
continue;
printf("\nPMID %s", pmIDStr((pmID)id));
sts = pmNameAll(id, &names);
if (sts > 0) {
printf(" ");
__pmPrintMetricNames(stdout, sts, names, " or ");
free(names);
}
putchar(':');
}
}
else {
next_type = 1;
name = argv[optind++];
if ((sts = pmLookupName(1, &name, (pmID *)&id)) < 0) {
printf("\n%s: %s\n", name, pmErrStr(sts));
continue;
}
if (id == PM_ID_NULL) {
printf("\n%s: unknown metric\n", name);
continue;
}
printf("\nPMID %s %s:", pmIDStr((pmID)id), name);
}
if (oneline) {
if (next_type == 1)
tp = pmdaGetHelp(handle, (pmID)id, PM_TEXT_ONELINE);
else
tp = pmdaGetInDomHelp(handle, (pmInDom)id, PM_TEXT_ONELINE);
if (tp != NULL)
printf(" %s", tp);
putchar('\n');
}
if (help) {
if (next_type == 1)
tp = pmdaGetHelp(handle, (pmID)id, PM_TEXT_HELP);
else
tp = pmdaGetInDomHelp(handle, (pmInDom)id, PM_TEXT_HELP);
if (tp != NULL && *tp)
printf("%s\n", tp);
}
}
return 0;
}
int
main(int argc, char *argv[])
{
time_t now;
time_t check;
int need;
char *buf;
char *p;
char *pend;
struct tm *tmp;
int sgn;
int val;
int mo_delta = 0;
int yr_delta = 0;
__pmSetProgname(argv[0]);
if (argc < 2) {
fprintf(stderr, usage);
exit(1);
}
if (strcmp(argv[1], "-?") == 0 || strcmp(argv[1], "--help") == 0) {
fprintf(stderr, usage);
exit(1);
}
time(&now);
while (argc > 2) {
p = argv[1];
if (*p == '+')
sgn = 1;
else if (*p == '-')
sgn = -1;
else {
fprintf(stderr, "%s: incorrect leading sign for offset (%s), must be \"+\" or \"-\"\n",
pmProgname, argv[1]);
exit(1);
}
p++;
val = (int)strtol(p, &pend, 10);
switch (*pend) {
case 'S':
now += sgn * val;
break;
case 'M':
now += sgn * val * 60;
break;
case 'H':
now += sgn * val * 60 * 60;
break;
case 'd':
now += sgn * val * 24 * 60 * 60;
break;
case 'm':
mo_delta += sgn*val;
break;
case 'y':
yr_delta += sgn*val;
break;
case '\0':
fprintf(stderr, "%s: missing scale after offset (%s)\n", pmProgname, argv[1]);
exit(1);
case '?':
fprintf(stderr, usage);
exit (1);
default:
fprintf(stderr, "%s: unknown scale after offset (%s)\n", pmProgname, argv[1]);
exit(1);
}
argv++;
argc--;
}
tmp = localtime(&now);
if (yr_delta) {
/*
* tm_year is years since 1900 and yr_delta is relative (not
* absolute), so this is Y2K safe
*/
tmp->tm_year += yr_delta;
/* TODO feb leap year */
}
if (mo_delta) {
/*
* tm_year is years since 1900 and the tm_year-- and
* tm_year++ is adjusting for underflow and overflow in
* tm_mon as a result of relative month delta, so this
* is Y2K safe
*/
tmp->tm_mon += mo_delta;
while (tmp->tm_mon < 0) {
tmp->tm_mon += 12;
tmp->tm_year--;
}
while (tmp->tm_mon > 12) {
tmp->tm_mon -= 12;
tmp->tm_year++;
}
}
if ((check = mktime(tmp)) == -1) {
fprintf(stderr, "%s: impossible date conversion\n", pmProgname);
exit(1);
}
/*
* Note: 256 is _more_ than enough to accommodate the longest
* value for _every_ %? lexicon that strftime() understands
*/
need = strlen(argv[1]) + 256;
if ((buf = (char *)malloc(need)) == NULL) {
fprintf(stderr, "%s: malloc failed\n", pmProgname);
exit(1);
}
if (strftime(buf, need, argv[1], tmp) == 0) {
fprintf(stderr, "%s: format too long\n", pmProgname);
exit(1);
}
else {
buf[need-1] = '\0';
printf("%s\n", buf);
exit(0);
}
}
int
main(int argc, char **argv)
{
int c;
int sts;
int errflag = 0;
static char *usage = "[-D debug] type value iunit ounit\n"
"\n"
"iunit and ounit are in the 6-integer format:\n"
"dimspace:dimtime:dimcount:scalespace:scaletime:scalecount\n";
pmUnits iu;
pmUnits ou;
int type;
int vbase;
pmAtomValue iv;
pmAtomValue ov;
char *vp;
char *q;
__pmSetProgname(argv[0]);
/* stop at type arg, so value may have leading "-" */
putenv("POSIXLY_CORRECT=yes");
while ((c = getopt(argc, argv, "D:")) != EOF) {
switch (c) {
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
case '?':
default:
errflag++;
break;
}
}
if (errflag || argc - optind != 4) {
fprintf(stderr, "Usage: %s %s\n", pmProgname, usage);
exit(1);
}
/* non-flag args are argv[optind] ... argv[argc-1] */
type = atoi(argv[optind]);
optind++;
if (strncmp(argv[optind], "0x", 2) == 0) {
vp = &argv[optind][2];
vbase = 16;
}
else {
vp = argv[optind];
vbase = 10;
}
q = vp;
switch (type) {
case PM_TYPE_32:
iv.l = strtol(vp, &q, vbase);
break;
case PM_TYPE_U32:
iv.ul = strtoul(vp, &q, vbase);
break;
case PM_TYPE_64:
iv.ll = strtoll(vp, &q, vbase);
break;
case PM_TYPE_U64:
iv.ull = strtoull(vp, &q, vbase);
break;
case PM_TYPE_FLOAT:
sts = sscanf(vp, "%f", &iv.f);
if (sts == 1) q = "";
break;
case PM_TYPE_DOUBLE:
sts = sscanf(vp, "%lf", &iv.d);
if (sts == 1) q = "";
break;
default:
case PM_TYPE_STRING:
iv.cp = vp;
q = "";
break;
case PM_TYPE_AGGREGATE:
case PM_TYPE_AGGREGATE_STATIC:
iv.vbp = (pmValueBlock *)malloc(PM_VAL_HDR_SIZE+strlen(vp));
iv.vbp->vlen = PM_VAL_HDR_SIZE+strlen(vp);
iv.vbp->vtype = type;
strncpy(iv.vbp->vbuf, vp, strlen(vp));
q = "";
break;
case PM_TYPE_EVENT: // ignore the value, force 0 event records
iv.vbp = (pmValueBlock *)malloc(sizeof(pmEventArray)-sizeof(pmEventRecord));
iv.vbp->vlen = sizeof(pmEventArray)-sizeof(pmEventRecord);
iv.vbp->vtype = type;
memset((void *)iv.vbp->vbuf, 0, sizeof(int));
q = "";
break;
case PM_TYPE_HIGHRES_EVENT: // ignore the value, force 0 event records
iv.vbp = (pmValueBlock *)malloc(sizeof(pmHighResEventArray)-sizeof(pmHighResEventRecord));
iv.vbp->vlen = sizeof(pmHighResEventArray)-sizeof(pmHighResEventRecord);
iv.vbp->vtype = type;
memset((void *)iv.vbp->vbuf, 0, sizeof(int));
q = "";
break;
}
optind++;
if (*q != '\0') {
fprintf(stderr, "Value botched @ %s\n", q);
exit(1);
}
vp = argv[optind];
iu.dimSpace = strtol(vp, &q, 10);
if (*q != ':') goto bad_in;
vp = ++q;
iu.dimTime = strtol(vp, &q, 10);
if (*q != ':') goto bad_in;
vp = ++q;
iu.dimCount = strtol(vp, &q, 10);
if (*q != ':') goto bad_in;
vp = ++q;
iu.scaleSpace = strtol(vp, &q, 10);
if (*q != ':') goto bad_in;
vp = ++q;
iu.scaleTime = strtol(vp, &q, 10);
if (*q != ':') goto bad_in;
vp = ++q;
iu.scaleCount = strtol(vp, &q, 10);
if (*q != '\0') goto bad_in;
optind++;
vp = argv[optind];
ou.dimSpace = strtol(vp, &q, 10);
if (*q != ':') goto bad_out;
vp = ++q;
ou.dimTime = strtol(vp, &q, 10);
if (*q != ':') goto bad_out;
vp = ++q;
ou.dimCount = strtol(vp, &q, 10);
if (*q != ':') goto bad_out;
vp = ++q;
ou.scaleSpace = strtol(vp, &q, 10);
if (*q != ':') goto bad_out;
vp = ++q;
ou.scaleTime = strtol(vp, &q, 10);
if (*q != ':') goto bad_out;
vp = ++q;
ou.scaleCount = strtol(vp, &q, 10);
if (*q != '\0') goto bad_out;
printf("type=%d input units=%s value=%s\n", type, pmUnitsStr(&iu), pmAtomStr(&iv, type));
if ((sts = pmConvScale(type, &iv, &iu, &ov, &ou)) < 0)
printf("pmConvScale Error: %s\n", pmErrStr(sts));
else
printf("output units=%s value=%s\n", pmUnitsStr(&ou), pmAtomStr(&ov, type));
exit(0);
bad_in:
fprintf(stderr, "Input units botch @ %s\n", q);
exit(1);
bad_out:
fprintf(stderr, "Output units botch @ %s\n", q);
exit(1);
}
/*
* Set up the agent, running as a daemon.
*/
int
main(int argc, char **argv)
{
int sep = __pmPathSeparator();
int c;
int i;
char namebuf[30];
char mypath[MAXPATHLEN];
__pmSetProgname(argv[0]);
__pmGetUsername(&username);
if (getcwd(startdir, sizeof(startdir)) == NULL) {
fprintf(stderr, "%s: getcwd() failed: %s\n",
pmProgname, pmErrStr(-oserror()));
exit(1);
}
snprintf(mypath, sizeof(mypath), "%s%c" "mailq" "%c" "help",
pmGetConfig("PCP_PMDAS_DIR"), sep, sep);
pmdaDaemon(&dispatch, PMDA_INTERFACE_2, pmProgname, MAILQ,
"mailq.log", mypath);
while ((c = pmdaGetOptions(argc, argv, &opts, &dispatch)) != EOF) {
switch (c) {
case 'b':
if (mailq_histogram(opts.optarg) < 0)
opts.errors++;
break;
case 'r':
regexstring = opts.optarg;
c = regcomp(&mq_regex, regexstring, REG_EXTENDED | REG_NOSUB);
if (c != 0) {
regerror(c, &mq_regex, mypath, sizeof(mypath));
pmprintf("%s: cannot compile regular expression: %s\n",
pmProgname, mypath);
opts.errors++;
}
break;
}
}
if (opts.optind == argc - 1)
queuedir = argv[opts.optind];
else if (opts.optind != argc)
opts.errors++;
if (opts.errors) {
pmdaUsageMessage(&opts);
exit(1);
}
if (opts.username)
username = opts.username;
if (histo == NULL) {
/* default histo bins, if not already done above ... */
numhisto = 7;
histo = (histo_t *)malloc(numhisto * sizeof(histo[0]));
if (histo == NULL) {
__pmNoMem("histo", numhisto * sizeof(histo[0]), PM_FATAL_ERR);
}
histo[0].delay = 7 * 24 * 3600;
histo[1].delay = 3 * 24 * 3600;
histo[2].delay = 24 * 3600;
histo[3].delay = 8 * 3600;
histo[4].delay = 4 * 3600;
histo[5].delay = 1 * 3600;
histo[6].delay = 0;
}
else {
/* need to add last one and sort on descending time */
numhisto++;
histo = (histo_t *)realloc(histo, numhisto * sizeof(histo[0]));
if (histo == NULL) {
__pmNoMem("histo", numhisto * sizeof(histo[0]), PM_FATAL_ERR);
}
histo[numhisto-1].delay = 0;
qsort(histo, numhisto, sizeof(histo[0]), compare_delay);
}
_delay = (pmdaInstid *)malloc(numhisto * sizeof(_delay[0]));
if (_delay == NULL)
__pmNoMem("_delay", numhisto * sizeof(_delay[0]), PM_FATAL_ERR);
for (i = 0; i < numhisto; i++) {
time_t tmp;
_delay[i].i_inst = histo[i].delay;
histo[i].count = 0;
if (histo[i].delay == 0)
sprintf(namebuf, "recent");
else if (histo[i].delay < 60)
sprintf(namebuf, "%d-secs", (int)histo[i].delay);
else if (histo[i].delay < 60 * 60) {
tmp = histo[i].delay / 60;
if (tmp <= 1)
sprintf(namebuf, "1-min");
else
sprintf(namebuf, "%d-mins", (int)tmp);
}
else if (histo[i].delay < 24 * 60 * 60) {
tmp = histo[i].delay / (60 * 60);
if (tmp <= 1)
sprintf(namebuf, "1-hour");
else
sprintf(namebuf, "%d-hours", (int)tmp);
}
else {
tmp = histo[i].delay / (24 * 60 * 60);
if (tmp <= 1)
sprintf(namebuf, "1-day");
else
sprintf(namebuf, "%d-days", (int)tmp);
}
_delay[i].i_name = strdup(namebuf);
if (_delay[i].i_name == NULL) {
__pmNoMem("_delay[i].i_name", strlen(namebuf), PM_FATAL_ERR);
}
}
indomtab[DELAY_INDOM].it_numinst = numhisto;
indomtab[DELAY_INDOM].it_set = _delay;
pmdaOpenLog(&dispatch);
mailq_init(&dispatch);
pmdaConnect(&dispatch);
pmdaMain(&dispatch);
exit(0);
}
int
main(int argc, char **argv)
{
int err = 0;
int sep = __pmPathSeparator();
char *endnum;
pmdaInterface dispatch;
int n;
int i;
int c;
char helptext[MAXPATHLEN];
__pmSetProgname(argv[0]);
__pmGetUsername(&pmdausername);
snprintf(helptext, sizeof(helptext), "%s%c" "cisco" "%c" "help",
pmGetConfig("PCP_PMDAS_DIR"), sep, sep);
pmdaDaemon(&dispatch, PMDA_INTERFACE_3, pmProgname, CISCO,
"cisco.log", helptext);
while ((c = pmdaGetOpt(argc, argv, "D:d:h:i:l:pu:6:" "CM:Nn:P:r:s:U:x:?",
&dispatch, &err)) != EOF) {
switch (c) {
case 'C': /* parser checking mode (debugging) */
pmDebug = DBG_TRACE_APPL0;
parse_only++;
break;
case 'N': /* do not perform name lookups (debugging) */
no_lookups = 1;
break;
case 'n': /* set program name, for parse (debugging) */
pmProgname = optarg;
break;
case 'P': /* passwd */
passwd = optarg;
break;
case 'r':
refreshdelay = (int)strtol(optarg, &endnum, 10);
if (*endnum != '\0') {
fprintf(stderr, "%s: -r requires numeric (number of seconds) argument\n",
pmProgname);
err++;
}
break;
case 's': /* command prompt */
prompt = optarg;
break;
case 'M': /* username (for the PMDA) */
pmdausername = optarg;
break;
case 'U': /* username (for the Cisco) */
username = optarg;
break;
case 'x':
port = (int)strtol(optarg, &endnum, 10);
if (*endnum != '\0') {
fprintf(stderr, "%s: -x requires numeric argument\n",
pmProgname);
err++;
}
break;
case '?':
err++;
}
}
n_intf = argc - optind;
if (n_intf == 0 || err) {
fprintf(stderr,
"Usage: %s [options] host:{a|B|E|e|f|h|s}N[/M[.I]] [...]\n\n",
pmProgname);
fputs("Options:\n"
" -d domain use domain (numeric) for metrics domain of PMDA\n"
" -i port expect PMCD to connect on given inet port (number or name)\n"
" -l logfile redirect diagnostics and trace output to logfile\n"
" -M username user account to run PMDA under (default \"pcp\")\n"
" -p expect PMCD to supply stdin/stdout (pipe)\n"
" -P password default user-level Cisco password\n"
" -r refresh update metrics every refresh seconds\n"
" -s prompt Cisco command prompt [default >]\n"
" -u socket expect PMCD to connect on given unix domain socket\n"
" -U username Cisco username\n"
" -x port telnet port [default 23]\n"
" -6 port expect PMCD to connect on given ipv6 port (number or name)\n",
stderr);
exit(1);
}
/* force errors from here on into the log */
if (!parse_only) {
pmdaOpenLog(&dispatch);
__pmSetProcessIdentity(pmdausername);
} else {
dispatch.version.two.text = NULL;
dispatch.version.two.ext->e_helptext = NULL;
}
/*
* build the instance domain and cisco data structures from the
* command line arguments.
*/
if ((_router = (pmdaInstid *)malloc(n_intf * sizeof(pmdaInstid))) == NULL) {
__pmNoMem("main.router", n_intf * sizeof(pmdaInstid), PM_FATAL_ERR);
}
if ((intf = (intf_t *)malloc(n_intf * sizeof(intf_t))) == NULL) {
__pmNoMem("main.intf", n_intf * sizeof(intf_t), PM_FATAL_ERR);
}
/* pre-allocated cisco[] to avoid realloc and ptr movement */
if ((cisco = (cisco_t *)malloc(n_intf * sizeof(cisco_t))) == NULL) {
__pmNoMem("main.cisco", n_intf * sizeof(cisco_t), PM_FATAL_ERR);
}
indomtab[CISCO_INDOM].it_numinst = n_intf;
indomtab[CISCO_INDOM].it_set = _router;
for (n = 0 ; optind < argc; optind++, n++) {
char *p = strdup(argv[optind]);
char *q;
char *myusername;
char *mypasswd;
char *myprompt;
myprompt = strchr(p, '!');
if (myprompt) {
/* save prompt for later */
*myprompt++ = '\0';
}
else
myprompt = NULL;
mypasswd = strchr(p, '?');
if (mypasswd) {
/* save user-level password for later */
*mypasswd++ = '\0';
}
else
mypasswd = passwd;
myusername = strchr(p, '@');
if (myusername) {
/* save username for later */
*myusername++ = '\0';
}
else
myusername = username;
_router[n].i_inst = n;
_router[n].i_name = strdup(p);
if ((q = strchr(p, ':')) == NULL)
goto badintfspec;
*q++ = '\0';
for (i = 0; i < num_intf_tab; i++) {
if (strncmp(q, intf_tab[i].type, strlen(intf_tab[i].type)) == 0)
break;
}
if (i == num_intf_tab)
goto badintfspec;
if (strcmp(intf_tab[i].type, "E") == 0) {
/*
* Cisco parser is case insensitive, so 'E' means "Ethernet"
* and 'F' means "Fddi", need to use "FastEthernet" here
*/
q++;
intf[n].interface = (char *)malloc(strlen("FastEthernet")+strlen(q)+1);
if ((intf[n].interface = (char *)malloc(strlen("FastEthernet")+strlen(q)+1)) == NULL) {
__pmNoMem("main.cisco", strlen("FastEthernet")+strlen(q)+1, PM_FATAL_ERR);
}
strcpy(intf[n].interface, "FastEthernet");
strcat(intf[n].interface, q);
}
else
intf[n].interface = q;
for (i = 0; i < n_cisco; i++) {
if (strcmp(p, cisco[i].host) == 0)
break;
}
if (i == n_cisco) {
__pmHostEnt *hostInfo = NULL;
if (!no_lookups)
hostInfo = __pmGetAddrInfo(p);
if (!hostInfo && parse_only) {
FILE *f;
/*
* for debugging, "host" may be a file ...
*/
if ((f = fopen(p, "r")) == NULL) {
fprintf(stderr, "%s: unknown hostname or filename %s: %s\n",
pmProgname, argv[optind], hoststrerror());
/* abandon this host (cisco) */
continue;
}
else {
fprintf(stderr, "%s: assuming file %s contains output from \"show int\" command\n",
pmProgname, p);
cisco[i].host = p;
cisco[i].username = myusername != NULL ? myusername : username;
cisco[i].passwd = mypasswd != NULL ? mypasswd : passwd;
cisco[i].prompt = myprompt != NULL ? myprompt : prompt;
cisco[i].fin = f;
cisco[i].fout = stdout;
n_cisco++;
}
} else if (!hostInfo) {
fprintf(stderr, "%s: unknown hostname %s: %s\n",
pmProgname, p, hoststrerror());
/* abandon this host (cisco) */
continue;
} else {
cisco[i].host = p;
cisco[i].username = myusername != NULL ? myusername : username;
cisco[i].passwd = mypasswd != NULL ? mypasswd : passwd;
cisco[i].prompt = myprompt != NULL ? myprompt : prompt;
cisco[i].fin = NULL;
cisco[i].fout = NULL;
cisco[i].hostinfo = hostInfo;
cisco[i].port = port;
n_cisco++;
fprintf(stderr, "Adding new host %s\n", p);
fflush(stderr);
}
}
else {
if (cisco[i].username == NULL) {
if (myusername != NULL)
/* username on 2nd or later interface ... applies to all */
cisco[i].username = myusername;
}
else {
if (myusername != NULL) {
if (strcmp(cisco[i].username, myusername) != 0) {
fprintf(stderr,
"%s: conflicting usernames (\"%s\" "
"and \"%s\") for cisco \"%s\"\n",
pmProgname, cisco[i].username, myusername,
cisco[i].host);
exit(1);
}
}
}
if (cisco[i].passwd == NULL) {
if (mypasswd != NULL)
/* passwd on 2nd or later interface ... applies to all */
cisco[i].passwd = mypasswd;
}
else {
if (mypasswd != NULL) {
if (strcmp(cisco[i].passwd, mypasswd) != 0) {
fprintf(stderr,
"%s: conflicting user-level passwords (\"%s\" "
"and \"%s\") for cisco \"%s\"\n",
pmProgname, cisco[i].passwd, mypasswd,
cisco[i].host);
exit(1);
}
}
}
if (cisco[i].prompt == NULL) {
if (myprompt != NULL)
/* prompt on 2nd or later interface ... applies to all */
cisco[i].prompt = myprompt;
}
else {
if (myprompt != NULL) {
if (strcmp(cisco[i].prompt, myprompt) != 0) {
fprintf(stderr,
"%s: conflicting user-level prompts (\"%s\" "
"and \"%s\") for cisco \"%s\"\n",
pmProgname, cisco[i].prompt, myprompt,
cisco[i].host);
exit(1);
}
}
}
}
intf[n].cp = cisco+i;
/*
* special one-trip initialization for Frame-Relay over serial
* lines ... see grab_cisco()
*/
intf[n].bandwidth = -2;
fprintf(stderr, "Interface %s(%d) is on host %s\n",
intf[n].interface, n, cisco[i].host);
fflush(stderr);
continue;
badintfspec:
fprintf(stderr, "%s: bad interface specification \"%s\"\n", pmProgname, argv[optind]);
fprintf(stderr, " should be like sydcisco.sydney:s1 or b9u-cisco1-81.engr.sgi.com:f2/0\n");
fprintf(stderr, " or cisco.melbourne:e0?secret\n");
exit(1);
}
if (n_cisco == 0) {
fprintf(stderr, "%s: Nothing to monitor\n", pmProgname);
exit(1);
}
if (parse_only) {
fprintf(stderr, "Sleeping while sproc does the work ... SIGINT to terminate\n");
cisco_init(&dispatch);
for (i = 0; i < n_intf; i++)
intf[i].fetched = 0;
pause();
} else {
/* set up connection to PMCD */
cisco_init(&dispatch);
pmdaConnect(&dispatch);
pmdaMain(&dispatch);
}
cisco_done();
exit(0);
}
int
main(int argc, char **argv)
{
pthread_t tid1;
pthread_t tid2;
pthread_t tid3;
int sts;
char *msg;
int errflag = 0;
int c;
int i;
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "D:")) != EOF) {
switch (c) {
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
case '?':
default:
errflag++;
break;
}
}
if (errflag || optind == argc || argc-optind > 3) {
fprintf(stderr, "Usage: %s [-D...] host1 [host2 [host3]]\n", pmProgname);
exit(1);
}
ctx1 = pmNewContext(PM_CONTEXT_HOST, argv[optind]);
if (ctx1 < 0) {
printf("Error: pmNewContext(%s) -> %s\n", argv[optind], pmErrStr(ctx1));
exit(1);
}
optind++;
if (optind < argc) {
ctx2 = pmNewContext(PM_CONTEXT_HOST, argv[optind]);
if (ctx2 < 0) {
printf("Error: pmNewContext(%s) -> %s\n", argv[optind], pmErrStr(ctx2));
exit(1);
}
optind++;
}
else
ctx2 = ctx1;
if (optind < argc) {
ctx3 = pmNewContext(PM_CONTEXT_HOST, argv[optind]);
if (ctx3 < 0) {
printf("Error: pmNewContext(%s) -> %s\n", argv[optind], pmErrStr(ctx2));
exit(1);
}
optind++;
}
else
ctx3 = ctx2;
sts = pmLookupName(NMETRIC, namelist, pmidlist);
if (sts != NMETRIC) {
if (sts < 0)
printf("Error: pmLookupName -> %s\n", pmErrStr(sts));
else
printf("Error: pmLookupName returned %d, expected %d\n", sts, (int)(NMETRIC));
for (i = 0; i < NMETRIC; i++) {
printf(" %s -> %s\n", namelist[i], pmIDStr(pmidlist[i]));
}
exit(1);
}
for (i = 0; i < NMETRIC; i++) {
if ((sts = pmLookupDesc(pmidlist[i], &desclist[i])) < 0) {
printf("Error: pmLookupDesc(%s) -> %s\n", namelist[i], pmErrStr(sts));
exit(1);
}
}
sts = pthread_barrier_init(&barrier, NULL, 3);
if (sts != 0) {
printf("pthread_barrier_init: sts=%d\n", sts);
exit(1);
}
sts = pthread_create(&tid1, NULL, func1, NULL);
if (sts != 0) {
printf("thread_create: tid1: sts=%d\n", sts);
exit(1);
}
sts = pthread_create(&tid2, NULL, func2, NULL);
if (sts != 0) {
printf("thread_create: tid2: sts=%d\n", sts);
exit(1);
}
sts = pthread_create(&tid3, NULL, func3, NULL);
if (sts != 0) {
printf("thread_create: tid3: sts=%d\n", sts);
exit(1);
}
pthread_join(tid1, (void *)&msg);
if (msg != NULL) printf("tid1: %s\n", msg);
pthread_join(tid2, (void *)&msg);
if (msg != NULL) printf("tid2: %s\n", msg);
pthread_join(tid3, (void *)&msg);
if (msg != NULL) printf("tid3: %s\n", msg);
exit(0);
}
int
main(int argc, char **argv)
{
int s, sts, op, host;
unsigned int i;
char name[4*8 + 7 + 1]; /* handles full IPv6 address, if supported */
int ipv4 = -1;
int ipv6 = -1;
int errflag = 0;
int c;
__pmSockAddr *inaddr;
/* trim cmd name of leading directory components */
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "46D:?")) != EOF) {
switch (c) {
case '4': /* ipv4 (default) */
ipv4 = 1;
break;
case '6': /* ipv6 */
ipv6 = 1;
break;
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
case '?':
default:
errflag++;
break;
}
}
if (errflag) {
fprintf(stderr,
"Usage: %s [options]\n\
\n\
Options:\n\
-4 do IPv4 (default)\n\
-6 do IPv6\n",
pmProgname);
return 1;
}
/* defaults */
if (ipv4 == -1) ipv4 = 1;
if (ipv6 == -1) ipv6 = 0;
sts = 0;
for (op = 0; op < WORD_BIT; op++)
if ((s = __pmAccAddOp(1 << op)) < 0) {
printf("Bad op %d: %s\n", op, strerror(errno));
sts = s;
}
if (sts < 0)
return 1;
for (host = 0; host < WORD_BIT; host++) {
if (ipv4) {
sprintf(name, "155.%d.%d.%d", host * 3, 17+host, host);
if ((s = __pmAccAddHost(name, ~(1 << host), ~(1 << host), host)) < 0) {
printf("cannot add inet host for op%d: %s\n", host, strerror(s));
sts = s;
}
}
if (ipv6) {
sprintf(name, "fec0::%x:%x:%x:%x:%x:%x",
host * 3, 17+host, host,
host * 3, 17+host, host);
if ((s = __pmAccAddHost(name, ~(1 << host), ~(1 << host), host)) < 0) {
printf("cannot add IPv6 host for op%d: %s\n", host, strerror(s));
sts = s;
}
}
}
if (sts < 0)
return 1;
putc('\n', stderr);
putc('\n', stderr);
__pmAccDumpHosts(stderr);
putc('\n', stderr);
if (ipv4) {
for (host = 0; host < WORD_BIT; host++) {
int j;
for (j = 0; j <= host; j++) {
char buf[20];
sprintf(buf, "%d.%d.%d.%d", 155, host * 3, 17+host, host);
if ((inaddr =__pmStringToSockAddr(buf)) == NULL) {
printf("insufficient memory\n");
continue;
}
sts = __pmAccAddClient(inaddr, &i);
__pmSockAddrFree(inaddr);
if (sts < 0) {
if (j == host && sts == PM_ERR_CONNLIMIT)
continue;
printf("add inet client from host %d (j=%d): %s\n",
j, host, pmErrStr(sts));
continue;
}
else if (i != (~(1 << host)))
printf("inet host %d: __pmAccAddClient returns denyOpsResult 0x%x (expected 0x%x)\n",
host, i, ~(1 << host));
}
}
}
if (ipv6) {
for (host = 0; host < WORD_BIT; host++) {
int j;
for (j = 0; j <= host; j++) {
char buf[4*8 + 7 + 1]; /* handles full IPv6 address */
sprintf(buf, "fec0::%x:%x:%x:%x:%x:%x",
host * 3, 17+host, host,
host * 3, 17+host, host);
if ((inaddr =__pmStringToSockAddr(buf)) == NULL) {
printf("insufficient memory\n");
continue;
}
sts = __pmAccAddClient(inaddr, &i);
__pmSockAddrFree(inaddr);
if (sts < 0) {
if (j == host && sts == PM_ERR_CONNLIMIT)
continue;
printf("add IPv6 client from host %d (j=%d): %s\n",
j, host, pmErrStr(sts));
continue;
}
else if (i != (~(1 << host)))
printf("IPv6 host %d: __pmAccAddClient returns denyOpsResult 0x%x (expected 0x%x)\n",
host, i, ~(1 << host));
}
}
}
putc('\n', stderr);
putc('\n', stderr);
__pmAccDumpHosts(stderr);
putc('\n', stderr);
return 0;
}
int
main(int argc, char **argv)
{
static char helppath[MAXPATHLEN];
char *endnum;
pmdaInterface desc;
long minmem;
int c, err = 0, sep = __pmPathSeparator();
minmem = getpagesize();
maxmem = (minmem > DEFAULT_MAXMEM) ? minmem : DEFAULT_MAXMEM;
__pmSetProgname(argv[0]);
snprintf(helppath, sizeof(helppath), "%s%c" "systemd" "%c" "help",
pmGetConfig("PCP_PMDAS_DIR"), sep, sep);
pmdaDaemon(&desc, PMDA_INTERFACE_6, pmProgname, SYSTEMD,
"systemd.log", helppath);
while ((c = pmdaGetOpt(argc, argv, "D:d:l:m:s:U:f?", &desc, &err)) != EOF) {
switch (c) {
case 'm':
maxmem = strtol(optarg, &endnum, 10);
if (*endnum != '\0')
convertUnits(&endnum, &maxmem);
if (*endnum != '\0' || maxmem < minmem) {
fprintf(stderr, "%s: invalid max memory '%s' (min=%ld)\n",
pmProgname, optarg, minmem);
err++;
}
break;
case 's':
if (pmParseInterval(optarg, &interval, &endnum) < 0) {
fprintf(stderr, "%s: -s requires a time interval: %s\n",
pmProgname, endnum);
free(endnum);
err++;
}
break;
case 'U':
username = optarg;
break;
case 'f':
uid_gid_filter_p = 0;
break;
default:
err++;
break;
}
}
if (err)
usage();
FD_ZERO (&fds);
pmdaOpenLog(&desc);
/* The systemwide journal may be accessed by the adm user (group);
root access is not necessary. */
__pmSetProcessIdentity(username);
desc.comm.flags |= PDU_FLAG_AUTH;
pmdaConnect(&desc);
// After this point, systemd_init is allowed to take some extra time.
systemd_init(&desc); // sets some fds
systemdMain(&desc); // sets some more fds
systemd_shutdown();
exit(0);
}
int
main(int argc, char **argv)
{
int sts;
int ch;
int errflag = 0;
int a, b, c;
__pmSetProgname(argv[0]);
while ((ch = getopt(argc, argv, "D:?")) != EOF) {
switch (ch) {
#ifdef PCP_DEBUG
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
#endif
case '?':
default:
errflag++;
break;
}
}
if (errflag || optind != argc-2) {
fprintf(stderr, "Usage: %s archive1 archive2\n", pmProgname);
exit(1);
}
a = pmNewContext(PM_CONTEXT_ARCHIVE, argv[optind]);
if (a < 0) {
fprintf(stderr, "%s: first pmNewContext(..., %s): %s\n", pmProgname, argv[optind], pmErrStr(a));
exit(1);
}
pmDestroyContext(a);
b = pmNewContext(PM_CONTEXT_HOST, "localhost");
if (b < 0) {
fprintf(stderr, "%s: pmNewContext(..., localhost): %s\n", pmProgname, pmErrStr(b));
exit(1);
}
c = pmNewContext(PM_CONTEXT_ARCHIVE, argv[optind+1]);
if (c < 0) {
fprintf(stderr, "%s: second pmNewContext(..., %s): %s\n", pmProgname, argv[optind+1], pmErrStr(c));
exit(1);
}
exit(0);
}
/*
* probe IRIX autofsd(1M)
*/
int
main(int argc, char **argv)
{
struct timeval tv = { 10, 0 };
CLIENT *clnt;
enum clnt_stat stat;
int c;
char *p;
char *host = "local:";
int errflag = 0;
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "h:t:?")) != EOF) {
switch (c) {
case 'h': /* contact autofsd on this hostname */
host = optarg;
break;
case 't': /* change timeout interval */
if (pmParseInterval(optarg, &tv, &p) < 0) {
fprintf(stderr, "%s: illegal -t argument\n", pmProgname);
fputs(p, stderr);
free(p);
errflag++;
}
break;
case '?':
default:
fprintf(stderr, "Usage: %s [-h host] [-t timeout]\n", pmProgname);
errflag++;
break;
}
}
if (errflag)
exit(4);
if ((clnt = clnt_create(host, AUTOFSD_PROGRAM, AUTOFSD_VERSION, "udp")) == NULL) {
clnt_pcreateerror("clnt_create");
exit(2);
}
/*
* take control of the timeout algorithm
*/
clnt_control(clnt, CLSET_TIMEOUT, (char *)&tv);
clnt_control(clnt, CLSET_RETRY_TIMEOUT, (char *)&tv);
stat = clnt_call(clnt, NULLPROC, (xdrproc_t)xdr_void, (char *)0,
(xdrproc_t)xdr_void, (char *)0, tv);
if (stat != RPC_SUCCESS) {
clnt_perror(clnt, "clnt_call");
exit(1);
}
exit(0);
}
int
main(int argc, char **argv)
{
int type = PM_CONTEXT_HOST;
int c;
int sts;
int errflag = 0;
char *host = "localhost";
static char *usage = "[-D N] [-h hostname] metric stringvalue";
int len;
int n;
char *namelist[1];
pmID pmidlist[1];
pmResult *res;
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "D:h:")) != EOF) {
switch (c) {
#ifdef PCP_DEBUG
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
#endif
case 'h': /* hostname for PMCD to contact */
host = optarg;
break;
case '?':
default:
errflag++;
break;
}
}
if (errflag || optind != argc-2) {
printf("Usage: %s %s\n", pmProgname, usage);
exit(1);
}
if ((sts = pmNewContext(type, host)) < 0) {
printf("%s: Cannot connect to PMCD on host \"%s\": %s\n",
pmProgname, host, pmErrStr(sts));
exit(1);
}
namelist[0] = argv[optind];
n = pmLookupName(1, namelist, pmidlist);
if (n < 0 || pmidlist[0] == PM_ID_NULL) {
printf("pmLookupName: %s\n", pmErrStr(n));
exit(1);
}
if ((n = pmFetch(1, pmidlist, &res)) < 0) {
printf("pmFetch: %s\n", pmErrStr(n));
exit(1);
}
/*
* expecting one value and a pmValueBlock with a type
* of PM_TYPE_AGGREGATE
*/
if (res->vset[0]->numval != 1) {
printf("Expecting numval 1, found %d\n", res->vset[0]->numval);
__pmDumpResult(stdout, res);
exit(1);
}
if (res->vset[0]->valfmt == PM_VAL_INSITU) {
printf("Not expecing PM_VAL_INSITU\n");
__pmDumpResult(stdout, res);
exit(1);
}
if (res->vset[0]->vlist[0].value.pval->vtype != PM_TYPE_AGGREGATE) {
printf("Not expecing type %s\n", pmTypeStr(res->vset[0]->vlist[0].value.pval->vtype));
__pmDumpResult(stdout, res);
exit(1);
}
printf("%s old value: ", namelist[0]);
pmPrintValue(stdout, res->vset[0]->valfmt, res->vset[0]->vlist[0].value.pval->vtype, &res->vset[0]->vlist[0], 0);
/*
* old value is probably from a pinned PDU buffer ... don't free
* and accept small mem leak here
*/
len = strlen(argv[optind+1]);
res->vset[0]->vlist[0].value.pval = (pmValueBlock *)malloc(len + PM_VAL_HDR_SIZE);
res->vset[0]->vlist[0].value.pval->vtype = PM_TYPE_AGGREGATE;
res->vset[0]->vlist[0].value.pval->vlen = len + PM_VAL_HDR_SIZE;
memcpy(res->vset[0]->vlist[0].value.pval->vbuf, argv[optind+1], len);
if ((n = pmStore(res)) < 0) {
printf("pmStore: %s\n", pmErrStr(n));
exit(1);
}
pmFreeResult(res);
if ((n = pmFetch(1, pmidlist, &res)) < 0) {
printf("pmFetch again: %s\n", pmErrStr(n));
exit(1);
}
printf(" new value: ");
pmPrintValue(stdout, res->vset[0]->valfmt, res->vset[0]->vlist[0].value.pval->vtype, &res->vset[0]->vlist[0], 0);
putchar('\n');
pmFreeResult(res);
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 */
}
