/*
* Connect to the pmdaroot socket as a client, perform version exchange
*/
int
pmdaRootConnect(const char *path)
{
__pmSockAddr *addr;
char *tmpdir;
char socketpath[MAXPATHLEN];
char errmsg[PM_MAXERRMSGLEN];
int fd, sts, version, features;
/* Initialize the socket address. */
if ((addr = __pmSockAddrAlloc()) == NULL)
return -ENOMEM;
if (path == NULL) {
if ((tmpdir = pmGetOptionalConfig("PCP_TMP_DIR")) == NULL) {
__pmSockAddrFree(addr);
return PM_ERR_GENERIC;
}
snprintf(socketpath, sizeof(socketpath), "%s/pmcd/root.socket", tmpdir);
} else
strncpy(socketpath, path, sizeof(socketpath));
socketpath[sizeof(socketpath)-1] = '\0';
__pmSockAddrSetFamily(addr, AF_UNIX);
__pmSockAddrSetPath(addr, socketpath);
/* Create client socket connection */
if ((fd = __pmCreateUnixSocket()) < 0) {
__pmNotifyErr(LOG_ERR, "pmdaRootConnect: cannot create socket %s: %s\n",
socketpath, osstrerror_r(errmsg, sizeof(errmsg)));
__pmSockAddrFree(addr);
return fd;
}
sts = __pmConnect(fd, addr, -1);
__pmSockAddrFree(addr);
if (sts < 0) {
if (sts != -EPERM || (pmDebug & DBG_TRACE_LIBPMDA))
__pmNotifyErr(LOG_INFO,
"pmdaRootConnect: cannot connect to %s: %s\n",
socketpath, osstrerror_r(errmsg, sizeof(errmsg)));
__pmCloseSocket(fd);
return sts;
}
/* Check server connection information */
if ((sts = __pmdaRecvRootPDUInfo(fd, &version, &features)) < 0) {
__pmNotifyErr(LOG_ERR,
"pmdaRootConnect: cannot verify %s server: %s\n",
socketpath, pmErrStr_r(sts, errmsg, sizeof(errmsg)));
__pmCloseSocket(fd);
return sts;
}
if (pmDebug & DBG_TRACE_LIBPMDA)
__pmNotifyErr(LOG_INFO,
"pmdaRootConnect: %s server fd=%d version=%d features=0x%x\n",
socketpath, fd, version, features);
return fd;
}
int
__pmGetUsername(char **username)
{
char *user = pmGetOptionalConfig("PCP_USER");
if (user && user[0] != '\0') {
*username = user;
return 1;
}
*username = "******";
return 0;
}
http_client *
pmhttpNewClient(void)
{
http_client *cp;
if ((cp = calloc(1, sizeof(http_client))) == NULL)
return NULL;
cp->timeout.tv_sec = DEFAULT_READ_TIMEOUT;
cp->max_redirect = DEFAULT_MAX_REDIRECT;
cp->http_version = PV_HTTP_1_1;
cp->user_agent = pmProgname;
cp->agent_vers = pmGetOptionalConfig("PCP_VERSION");
cp->fd = -1;
return cp;
}
/*
** Extract active PCP archive file from latest archive folio,
** use pmcd.hostname by default, unless directed elsewhere.
*/
void
rawfolio(pmOptions *opts)
{
int sep = __pmPathSeparator();
char path[MAXPATHLEN];
char *logdir;
if ((logdir = pmGetOptionalConfig("PCP_LOG_DIR")) == NULL)
{
fprintf(stderr, "%s: cannot find PCP_LOG_DIR\n", pmProgname);
cleanstop(1);
}
snprintf(path, sizeof(path), "%s%c%s%c%s%c",
logdir, sep, "pmlogger", sep, rawlocalhost(opts), sep);
if (chdir(path) < 0)
{
fprintf(stderr, "%s: cannot change to %s: %s\n",
pmProgname, path, pmErrStr(-oserror()));
cleanstop(1);
}
__pmAddOptArchiveFolio(opts, "Latest");
}
/* Return (in result) a list of active pmlogger ports on the local machine.
* The return value of the function is the number of elements in the array.
* The caller must NOT free any part of the result stucture, it's storage is
* managed here. Subsequent calls will overwrite the data so the caller should
* copy it if persistence is required.
*/
int
__pmLogFindLocalPorts(int pid, __pmLogPort **result)
{
char dir[MAXPATHLEN];
int lendir;
int i, j, n;
int nf; /* number of port files found */
struct dirent **files = NULL; /* array of port file dirents */
char *p;
int len;
char namebuf[MAXPATHLEN];
int (*scanfn)(const_dirent *dep);
FILE *pfile;
char buf[MAXPATHLEN];
if (PM_MULTIPLE_THREADS(PM_SCOPE_LOGPORT))
return PM_ERR_THREAD;
if (result == NULL)
return -EINVAL;
if ((p = pmGetOptionalConfig("PCP_TMP_DIR")) == NULL)
return PM_ERR_GENERIC;
lendir = snprintf(dir, sizeof(dir), "%s%cpmlogger", p, __pmPathSeparator());
/* Set up the appropriate function to select files from the control port
* directory. Anticipate that this will usually be an exact match for
* the primary logger control port.
*/
scanfn = is_match;
switch (pid) {
case PM_LOG_PRIMARY_PID: /* primary logger control (single) */
strcpy(match, "primary");
break;
case PM_LOG_ALL_PIDS: /* find all ports */
scanfn = is_portfile;
break;
default: /* a specific pid (single) */
if (!__pmProcessExists((pid_t)pid)) {
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_LOG) {
fprintf(stderr, "__pmLogFindLocalPorts() -> 0, "
"pid(%d) doesn't exist\n", pid);
}
#endif
*result = NULL;
return 0;
}
snprintf(match, sizeof(match), "%d", pid);
break;
}
nf = scandir(dir, &files, scanfn, alphasort);
#ifdef PCP_DEBUG
if (nf < 1 && (pmDebug & DBG_TRACE_LOG)) {
fprintf(stderr, "__pmLogFindLocalPorts: scandir() -> %d %s\n",
nf, pmErrStr(oserror()));
}
#endif
if (nf == -1 && oserror() == ENOENT)
nf = 0;
else if (nf == -1) {
char errmsg[PM_MAXERRMSGLEN];
pmprintf("__pmLogFindLocalPorts: scandir: %s\n", osstrerror_r(errmsg, sizeof(errmsg)));
pmflush();
return -oserror();
}
if (resize_logports(nf) < 0) {
for (i=0; i < nf; i++)
free(files[i]);
free(files);
return -oserror();
}
if (nf == 0) {
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_LOG) {
fprintf(stderr, "__pmLogFindLocalPorts() -> 0, "
"num files = 0\n");
}
#endif
*result = NULL;
free(files);
return 0;
}
/* make a buffer for the longest complete pathname found */
len = (int)strlen(files[0]->d_name);
for (i = 1; i < nf; i++)
if ((j = (int)strlen(files[i]->d_name)) > len)
len = j;
/* +1 for trailing path separator, +1 for null termination */
len += lendir + 2;
/* namebuf is the complete pathname, p points to the trailing filename
* within namebuf.
*/
strcpy(namebuf, dir);
p = namebuf + lendir;
*p++ = __pmPathSeparator();
/* open the file, try to read the port number and add the port to the
* logport array if successful.
*/
for (i = 0; i < nf; i++) {
char *fname = files[i]->d_name;
int err = 0;
__pmLogPort *lpp = &logport[nlogports];
strcpy(p, fname);
if ((pfile = fopen(namebuf, "r")) == NULL) {
char errmsg[PM_MAXERRMSGLEN];
pmprintf("__pmLogFindLocalPorts: pmlogger port file %s: %s\n",
namebuf, osstrerror_r(errmsg, sizeof(errmsg)));
free(files[i]);
pmflush();
continue;
}
if (!err && fgets(buf, MAXPATHLEN, pfile) == NULL) {
if (feof(pfile)) {
clearerr(pfile);
pmprintf("__pmLogFindLocalPorts: pmlogger port file %s empty!\n",
namebuf);
}
else {
char errmsg[PM_MAXERRMSGLEN];
pmprintf("__pmLogFindLocalPorts: pmlogger port file %s: %s\n",
namebuf, osstrerror_r(errmsg, sizeof(errmsg)));
}
err = 1;
}
else {
char *endp;
lpp->port = (int)strtol(buf, &endp, 10);
if (*endp != '\n') {
pmprintf("__pmLogFindLocalPorts: pmlogger port file %s: no port number\n",
namebuf);
err = 1;
}
else {
lpp->pid = (int)strtol(fname, &endp, 10);
if (*endp != '\0') {
if (strcmp(fname, "primary") == 0)
lpp->pid = PM_LOG_PRIMARY_PORT;
else {
pmprintf("__pmLogFindLocalPorts: unrecognised pmlogger port file %s\n",
namebuf);
err = 1;
}
}
}
}
if (err) {
pmflush();
fclose(pfile);
}
else {
if (fgets(buf, MAXPATHLEN, pfile) == NULL) {
pmprintf("__pmLogFindLocalPorts: pmlogger port file %s: no PMCD host name\n",
namebuf);
pmflush();
}
else {
char *q = strchr(buf, '\n');
if (q != NULL)
*q = '\0';
lpp->pmcd_host = strdup(buf);
if (fgets(buf, MAXPATHLEN, pfile) == NULL) {
pmprintf("__pmLogFindLocalPorts: pmlogger port file %s: no archive base pathname\n",
namebuf);
pmflush();
}
else {
char *q = strchr(buf, '\n');
if (q != NULL)
*q = '\0';
lpp->archive = strdup(buf);
}
}
fclose(pfile);
if ((lpp->name = strdup(fname)) != NULL)
nlogports++;
else {
if (lpp->pmcd_host != NULL) {
free(lpp->pmcd_host);
lpp->pmcd_host = NULL;
}
if (lpp->archive != NULL) {
free(lpp->archive);
lpp->archive = NULL;
}
break;
}
}
free(files[i]);
}
if (i == nf) { /* all went well */
n = nlogports;
*result = logport;
}
else { /* strdup error on fname, clean up */
*result = NULL;
for (j = i; j < nf; j++)
free(files[j]);
n = -oserror();
}
free(files);
return n;
}
void
rawarchive(pmOptions *opts, const char *name)
{
struct tm *tp;
time_t timenow;
char tmp[MAXPATHLEN];
char path[MAXPATHLEN];
char *logdir, *py, *host;
int sep = __pmPathSeparator();
int sts, len = (name? strlen(name) : 0);
if (len == 0)
return rawfolio(opts);
/* see if a valid archive exists as specified */
if ((sts = pmNewContext(PM_CONTEXT_ARCHIVE, name)) >= 0)
{
pmDestroyContext(sts);
__pmAddOptArchive(opts, (char * )name);
return;
}
/* see if a valid folio exists as specified */
strncpy(tmp, name, sizeof(tmp));
tmp[sizeof(tmp)-1] = '\0';
if (access(tmp, R_OK) == 0)
{
__pmAddOptArchiveFolio(opts, tmp);
return;
}
snprintf(path, sizeof(path), "%s/%s.folio", name, basename(tmp));
path[sizeof(path)-1] = '\0';
if (access(path, R_OK) == 0)
{
__pmAddOptArchiveFolio(opts, path);
return;
}
/* else go hunting in the system locations... */
if ((logdir = pmGetOptionalConfig("PCP_LOG_DIR")) == NULL)
{
fprintf(stderr, "%s: cannot find PCP_LOG_DIR\n", pmProgname);
cleanstop(1);
}
host = rawlocalhost(opts);
/*
** Use original rawread() algorithms for specifying dates
*/
if (len == 8 && lookslikedatetome(name))
{
snprintf(path, sizeof(path), "%s%c%s%c%s%c%s",
logdir, sep, "pmlogger", sep, host, sep, name);
__pmAddOptArchive(opts, (char * )path);
}
/*
** if one or more 'y' (yesterday) characters are used and that
** string is not known as an existing file, the standard logfile
** is shown from N days ago (N is determined by the number
** of y's).
*/
else
{
/*
** make a string existing of y's to compare with
*/
py = malloc(len+1);
ptrverify(py, "Malloc failed for 'yes' sequence\n");
memset(py, 'y', len);
*(py+len) = '\0';
if ( strcmp(name, py) == 0 )
{
timenow = time(0);
timenow -= len*3600*24;
tp = localtime(&timenow);
snprintf(path, sizeof(path), "%s%c%s%c%s%c%04u%02u%02u",
logdir, sep, "pmlogger", sep, host, sep,
tp->tm_year+1900, tp->tm_mon+1, tp->tm_mday);
__pmAddOptArchive(opts, (char * )path);
}
else
{
fprintf(stderr, "%s: cannot find archive from \"%s\"\n",
pmProgname, name);
cleanstop(1);
}
free(py);
}
}
