/*
* Create socket for incoming connections and bind to it an address for
* clients to use. Returns -1 on failure.
*
* If '*family' is AF_UNIX and unix domain sockets are supported:
* 'port' is ignored and 'address' is the path to the socket file in the filesystem.
*
* Otherwise:
* address is a string representing the Inet/IPv6 address that the port
* is advertised for. To allow connections to all this host's internet
* addresses from clients use address == "INADDR_ANY", or for localhost
* access only use address == "INADDR_LOOPBACK".
* On input, 'family' is a pointer to the address family to use (AF_INET,
* AF_INET6) if the address specified is empty. If the spec is not
* empty then family is ignored and is set to the actual address family
* used. 'family' must be initialized to AF_UNSPEC, in this case.
*/
static int
OpenRequestSocket(int port, const char *address, int *family,
int backlog, __pmFdSet *fdset, int *maximum)
{
int fd = -1;
int one, sts;
__pmSockAddr *myAddr;
int isUnix = 0;
/*
* Using this flag will eliminate the need for more conditional
* compilation below, hopefully making the code easier to read and maintain.
*/
#if defined(HAVE_STRUCT_SOCKADDR_UN)
if (*family == AF_UNIX)
isUnix = 1;
#endif
if (isUnix) {
if ((myAddr = __pmSockAddrAlloc()) == NULL) {
__pmNoMem("OpenRequestSocket: can't allocate socket address",
sizeof(*myAddr), PM_FATAL_ERR);
}
/* Initialize the address. */
__pmSockAddrSetFamily(myAddr, *family);
__pmSockAddrSetPath(myAddr, address);
/* Create the socket. */
fd = __pmCreateUnixSocket();
}
else {
/*
* If the address is unspecified, then use the address family we
* have been given, otherwise the family will be determined by
* __pmStringToSockAddr.
*/
if (address == NULL || strcmp(address, "INADDR_ANY") == 0) {
if ((myAddr = __pmSockAddrAlloc()) == NULL) {
__pmNoMem("OpenRequestSocket: can't allocate socket address",
sizeof(*myAddr), PM_FATAL_ERR);
}
__pmSockAddrInit(myAddr, *family, INADDR_ANY, 0);
}
else if (strcmp(address, "INADDR_LOOPBACK") == 0) {
if ((myAddr = __pmSockAddrAlloc()) == NULL) {
__pmNoMem("OpenRequestSocket: can't allocate socket address",
sizeof(*myAddr), PM_FATAL_ERR);
}
__pmSockAddrInit(myAddr, *family, INADDR_LOOPBACK, 0);
}
else {
if ((myAddr = __pmStringToSockAddr(address)) == NULL) {
__pmNotifyErr(LOG_ERR, "OpenRequestSocket(%d, %s) invalid address\n",
port, address);
goto fail;
}
*family = __pmSockAddrGetFamily(myAddr);
}
__pmSockAddrSetPort(myAddr, port);
/* Create the socket. */
if (*family == AF_INET)
fd = __pmCreateSocket();
else if (*family == AF_INET6)
fd = __pmCreateIPv6Socket();
else {
__pmNotifyErr(LOG_ERR, "OpenRequestSocket(%d, %s) invalid address family: %d\n",
port, address, *family);
goto fail;
}
}
if (fd < 0) {
__pmNotifyErr(LOG_ERR, "OpenRequestSocket(%d, %s, %s) __pmCreateSocket: %s\n",
port, address, AddressFamily(*family), netstrerror());
goto fail;
}
/* Ignore dead client connections. */
one = 1;
#ifndef IS_MINGW
if (__pmSetSockOpt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&one,
(__pmSockLen)sizeof(one)) < 0) {
__pmNotifyErr(LOG_ERR,
"OpenRequestSocket(%d, %s, %s) __pmSetSockOpt(SO_REUSEADDR): %s\n",
port, address, AddressFamily(*family), netstrerror());
goto fail;
}
#else
if (__pmSetSockOpt(fd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char *)&one,
(__pmSockLen)sizeof(one)) < 0) {
__pmNotifyErr(LOG_ERR,
"OpenRequestSocket(%d, %s, %s) __pmSetSockOpt(EXCLUSIVEADDRUSE): %s\n",
port, address, AddressFamily(*family), netstrerror());
goto fail;
}
#endif
/* and keep alive please - bad networks eat fds */
if (__pmSetSockOpt(fd, SOL_SOCKET, SO_KEEPALIVE, (char *)&one,
(__pmSockLen)sizeof(one)) < 0) {
__pmNotifyErr(LOG_ERR,
"OpenRequestSocket(%d, %s, %s) __pmSetSockOpt(SO_KEEPALIVE): %s\n",
port, address, AddressFamily(*family), netstrerror());
goto fail;
}
sts = __pmBind(fd, (void *)myAddr, __pmSockAddrSize());
__pmSockAddrFree(myAddr);
myAddr = NULL;
if (sts < 0) {
sts = neterror();
__pmNotifyErr(LOG_ERR, "OpenRequestSocket(%d, %s, %s) __pmBind: %s\n",
port, address, AddressFamily(*family), netstrerror());
if (sts == EADDRINUSE)
__pmNotifyErr(LOG_ERR, "%s may already be running\n", pmProgname);
goto fail;
}
if (isUnix) {
/*
* For unix domain sockets, grant rw access to the socket for all,
* otherwise, on linux platforms, connection will not be possible.
* This must be done AFTER binding the address. See Unix(7) for details.
*/
sts = chmod(address, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
if (sts != 0) {
__pmNotifyErr(LOG_ERR,
"OpenRequestSocket(%d, %s, %s) chmod(%s): %s\n",
port, address, AddressFamily(*family), address, strerror(errno));
goto fail;
}
}
sts = __pmListen(fd, backlog); /* Max. pending connection requests */
if (sts < 0) {
__pmNotifyErr(LOG_ERR, "OpenRequestSocket(%d, %s, %s) __pmListen: %s\n",
port, address, AddressFamily(*family), netstrerror());
goto fail;
}
if (fd > *maximum)
*maximum = fd;
__pmFD_SET(fd, fdset);
return fd;
fail:
if (fd != -1) {
__pmCloseSocket(fd);
/* We must unlink the socket file. */
if (isUnix)
unlink(address);
}
if (myAddr)
__pmSockAddrFree(myAddr);
return -1;
}
/*
* 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;
}
void
DeleteClient(ClientInfo *cp)
{
int i;
for (i = 0; i < nClients; i++)
if (cp == &client[i])
break;
if (i == nClients) {
fprintf(stderr, "DeleteClient: Botch: tried to delete non-existent client @" PRINTF_P_PFX "%p\n", cp);
return;
}
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_CONTEXT)
fprintf(stderr, "DeleteClient [%d]\n", i);
#endif
if (cp->fd >= 0) {
__pmFD_CLR(cp->fd, &sockFds);
__pmCloseSocket(cp->fd);
}
if (cp->pmcd_fd >= 0) {
__pmFD_CLR(cp->pmcd_fd, &sockFds);
__pmCloseSocket(cp->pmcd_fd);
}
if (i == nClients-1) {
i--;
while (i >= 0 && !client[i].status.connected)
i--;
nClients = (i >= 0) ? i + 1 : 0;
}
if (cp->fd == maxSockFd || cp->pmcd_fd == maxSockFd) {
maxSockFd = maxReqPortFd;
for (i = 0; i < nClients; i++) {
if (cp->status.connected == 0)
continue;
if (client[i].fd > maxSockFd)
maxSockFd = client[i].fd;
if (client[i].pmcd_fd > maxSockFd)
maxSockFd = client[i].pmcd_fd;
}
}
__pmSockAddrFree(cp->addr);
cp->addr = NULL;
cp->status.connected = 0;
cp->fd = -1;
cp->pmcd_fd = -1;
if (cp->pmcd_hostname != NULL) {
free(cp->pmcd_hostname);
cp->pmcd_hostname = NULL;
}
}
void
DeleteClient(ClientInfo *cp)
{
int i;
for (i = 0; i < nClients; i++)
if (cp == &client[i])
break;
if (i == nClients) {
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL0) {
__pmNotifyErr(LOG_ERR, "DeleteClient: tried to delete non-existent client\n");
Shutdown();
exit(1);
}
#endif
return;
}
if (cp->fd != -1) {
__pmFD_CLR(cp->fd, &clientFds);
__pmCloseSocket(cp->fd);
}
if (i == nClients-1) {
i--;
while (i >= 0 && !client[i].status.connected)
i--;
nClients = (i >= 0) ? i + 1 : 0;
}
if (cp->fd == maxClientFd) {
maxClientFd = -1;
for (i = 0; i < nClients; i++) {
if (client[i].fd > maxClientFd)
maxClientFd = client[i].fd;
}
}
for (i = 0; i < cp->szProfile; i++) {
if (cp->profile[i] != NULL) {
__pmFreeProfile(cp->profile[i]);
cp->profile[i] = NULL;
}
}
__pmFreeAttrsSpec(&cp->attrs);
__pmHashClear(&cp->attrs);
__pmSockAddrFree(cp->addr);
cp->addr = NULL;
cp->status.connected = 0;
cp->fd = -1;
NotifyEndContext(cp-client);
}
/*
* Opens a TCP socket and returns the descriptor
* Returns:
* socket descriptor, or
* -1 on error
*/
int makeSocket(const char *host)
{
int sock; /* Socket descriptor */
int ret;
int port;
char *p;
__pmFdSet wfds;
struct timeval tv;
struct timeval *ptv;
__pmSockAddr *myaddr;
__pmHostEnt *servInfo;
void *enumIx;
int flags = 0;
/* Check for port number specified in URL */
p = strchr(host, ':');
if(p)
{
port = atoi(p + 1);
*p = '\0';
}
else
port = PORT_NUMBER;
servInfo = __pmGetAddrInfo(host);
if(servInfo == NULL) { errorSource = H_ERRNO; return -1; }
sock = -1;
enumIx = NULL;
for (myaddr = __pmHostEntGetSockAddr(servInfo, &enumIx);
myaddr != NULL;
myaddr = __pmHostEntGetSockAddr(servInfo, &enumIx)) {
/* Create a socket */
if (__pmSockAddrIsInet(myaddr))
sock = __pmCreateSocket();
else if (__pmSockAddrIsIPv6(myaddr))
sock = __pmCreateIPv6Socket();
else
sock = -1;
if (sock < 0) {
__pmSockAddrFree(myaddr);
continue; /* Try the next address */
}
/* Attempt to connect */
flags = __pmConnectTo(sock, myaddr, port);
__pmSockAddrFree(myaddr);
if (flags < 0) {
/*
* Mark failure in case we fall out the end of the loop
* and try next address. sock has been closed in __pmConnectTo().
*/
sock = -1;
continue;
}
/* FNDELAY and we're in progress - wait on select */
tv.tv_sec = timeout;
tv.tv_usec = 0;
ptv = (tv.tv_sec || tv.tv_usec) ? &tv : NULL;
__pmFD_ZERO(&wfds);
__pmFD_SET(sock, &wfds);
ret = __pmSelectWrite(sock+1, &wfds, ptv);
/* Was the connection successful? */
if (ret < 0) {
if (oserror() == EINTR)
return _makeSocketErr(sock, FETCHER_ERROR, HF_CONNECTTIMEOUT);
return _makeSocketErr(sock, ERRNO, 0);
}
ret = __pmConnectCheckError(sock);
if (ret == 0)
break;
/* Unsuccessful connection. */
__pmCloseSocket(sock);
sock = -1;
} /* loop over addresses */
__pmHostEntFree(servInfo);
if(sock == -1) { errorSource = ERRNO; return -1; }
sock = __pmConnectRestoreFlags(sock, flags);
if(sock < 0) { errorSource = ERRNO; return -1; }
return sock;
}
static int
http_client_connectunix(const char *path, struct timeval *timeout)
{
#if defined(HAVE_STRUCT_SOCKADDR_UN)
__pmFdSet wfds;
__pmSockAddr *myAddr;
struct timeval stv, *ptv;
int fdFlags = 0;
int fd = -1;
int sts;
int rc;
/* Initialize the socket address. */
if ((myAddr = __pmSockAddrAlloc()) == NULL) {
if (pmDebug & DBG_TRACE_HTTP)
fprintf(stderr, "HTTP connect unix(%s): out of memory\n", path);
return -ENOMEM;
}
__pmSockAddrSetFamily(myAddr, AF_UNIX);
__pmSockAddrSetPath(myAddr, path);
if ((fd = __pmCreateUnixSocket()) < 0) {
if (pmDebug & DBG_TRACE_HTTP) {
char errmsg[PM_MAXERRMSGLEN];
fprintf(stderr, "HTTP connect unix(%s) unable to create socket: %s\n",
path, osstrerror_r(errmsg, sizeof(errmsg)));
}
__pmSockAddrFree(myAddr);
return fd;
}
/* Attempt to connect */
fdFlags = __pmConnectTo(fd, myAddr, -1);
__pmSockAddrFree(myAddr);
if (fdFlags < 0) {
__pmCloseSocket(fd);
return -ECONNREFUSED;
}
/* FNDELAY and we're in progress - wait on select */
stv = *timeout;
ptv = (stv.tv_sec || stv.tv_usec) ? &stv : NULL;
__pmFD_ZERO(&wfds);
__pmFD_SET(fd, &wfds);
sts = 0;
if ((rc = __pmSelectWrite(fd+1, &wfds, ptv)) == 1)
sts = __pmConnectCheckError(fd);
else if (rc == 0)
sts = ETIMEDOUT;
else
sts = (rc < 0) ? neterror() : EINVAL;
if (sts != 0) {
/* Unsuccessful connection. */
if (sts == ENOENT)
sts = ECONNREFUSED;
__pmCloseSocket(fd);
fd = -sts;
}
if (fd < 0)
return fd;
/*
* If we're here, it means we have a valid connection; restore the
* flags and make sure this file descriptor is closed if exec() is
* called
*/
return __pmConnectRestoreFlags(fd, fdFlags);
#else
if (pmDebug & DBG_TRACE_HTTP)
__pmNotifyErr(LOG_ERR, "HTTP connect unix(%s) not supported\n", path);
return -EOPNOTSUPP;
#endif
}
static int
http_client_connectto(const char *host, int port, struct timeval *timeout)
{
struct timeval stv, *ptv;
__pmHostEnt *servInfo;
__pmSockAddr *myAddr;
__pmFdSet readyFds, allFds;
void *enumIx;
int fdFlags[FD_SETSIZE];
int i, fd, sts, maxFd;
if ((servInfo = __pmGetAddrInfo(host)) == NULL) {
if (pmDebug & DBG_TRACE_HTTP)
fprintf(stderr, "HTTP connect(%s, %d): hosterror=%d, ``%s''\n",
host, port, hosterror(), hoststrerror());
return -EHOSTUNREACH;
}
/*
* We want to respect the connect timeout that has been configured, but we
* may have more than one address to try. Do this by creating a socket for
* each address and then using __pmSelectWrite() to wait for one of them to
* respond. That way, the timeout is applied to all of the addresses
* simultaneously. First, create the sockets, add them to the fd set and
* try to establish connectections.
*/
__pmFD_ZERO(&allFds);
maxFd = -1;
enumIx = NULL;
for (myAddr = __pmHostEntGetSockAddr(servInfo, &enumIx);
myAddr != NULL;
myAddr = __pmHostEntGetSockAddr(servInfo, &enumIx)) {
/* Create a socket */
if (__pmSockAddrIsInet(myAddr))
fd = __pmCreateSocket();
else if (__pmSockAddrIsIPv6(myAddr))
fd = __pmCreateIPv6Socket();
else {
if (pmDebug & DBG_TRACE_HTTP)
fprintf(stderr, "HTTP connect(%s, %d): bad address family %d\n",
host, port, __pmSockAddrGetFamily(myAddr));
fd = -EINVAL;
}
if (fd < 0) {
__pmSockAddrFree(myAddr);
continue; /* Try the next address */
}
/* Attempt to connect */
fdFlags[fd] = __pmConnectTo(fd, myAddr, port);
__pmSockAddrFree(myAddr);
if (fdFlags[fd] < 0) {
/*
* Mark failure in case we fall out the end of the loop
* and try next address
*/
__pmCloseSocket(fd);
continue;
}
/* Add it to the fd set. */
__pmFD_SET(fd, &allFds);
if (fd > maxFd)
maxFd = fd;
}
__pmHostEntFree(servInfo);
/* If we were unable to open any sockets, then give up. */
if (maxFd == -1)
return -ECONNREFUSED;
/* FNDELAY and we're in progress - wait on select */
__pmFD_COPY(&readyFds, &allFds);
stv = *timeout;
ptv = (stv.tv_sec || stv.tv_usec) ? &stv : NULL;
sts = __pmSelectWrite(maxFd+1, &readyFds, ptv);
/* Figure out what happened. */
if (sts == 0)
fd = -ETIMEDOUT;
else if (sts < 0)
fd = -neterror();
else {
/* Scan fd set, find first successfully connected socket (if any). */
fd = -EINVAL;
for (i = 0; i <= maxFd; ++i) {
if (__pmFD_ISSET(i, &readyFds)) {
/* Successful connection? */
sts = __pmConnectCheckError(i);
if (sts == 0) {
fd = i;
break;
}
fd = -sts;
}
}
}
/* Clean up the unused fds. */
for (i = 0; i <= maxFd; ++i) {
if (i != fd && __pmFD_ISSET(i, &allFds))
__pmCloseSocket(i);
}
if (fd < 0)
return fd;
/*
* If we're here, it means we have a valid connection; restore the
* flags and make sure this file descriptor is closed if exec() is
* called
*/
return __pmConnectRestoreFlags(fd, fdFlags[fd]);
}
static int stomp_connect(const char *hostname, int port)
{
__pmSockAddr *myaddr;
__pmHostEnt *servinfo;
void *enumIx;
struct timeval tv;
struct timeval *ptv;
__pmFdSet wfds;
int ret;
int flags = 0;
if ((servinfo = __pmGetAddrInfo(hostname)) == NULL)
return -1;
fd = -1;
enumIx = NULL;
for (myaddr = __pmHostEntGetSockAddr(servinfo, &enumIx);
myaddr != NULL;
myaddr = __pmHostEntGetSockAddr(servinfo, &enumIx)) {
/* Create a socket */
if (__pmSockAddrIsInet(myaddr))
fd = __pmCreateSocket();
else if (__pmSockAddrIsIPv6(myaddr))
fd = __pmCreateIPv6Socket();
else
fd = -1;
if (fd < 0) {
__pmSockAddrFree(myaddr);
continue; /* Try the next address */
}
/* Attempt to connect */
flags = __pmConnectTo(fd, myaddr, port);
__pmSockAddrFree(myaddr);
if (flags < 0) {
/*
* Mark failure in case we fall out the end of the loop
* and try next address. fd has been closed in __pmConnectTo().
*/
fd = -1;
continue;
}
/* FNDELAY and we're in progress - wait on select */
tv.tv_sec = timeout;
tv.tv_usec = 0;
ptv = (tv.tv_sec || tv.tv_usec) ? &tv : NULL;
__pmFD_ZERO(&wfds);
__pmFD_SET(fd, &wfds);
ret = __pmSelectWrite(fd+1, &wfds, ptv);
/* Was the connection successful? */
if (ret <= 0) {
if (oserror() == EINTR)
return -2;
continue;
}
ret = __pmConnectCheckError(fd);
if (ret == 0)
break;
/* Unsuccessful connection. */
__pmCloseSocket(fd);
fd = -1;
} /* loop over addresses */
__pmHostEntFree(servinfo);
if(fd == -1)
return -4;
fd = __pmConnectRestoreFlags(fd, flags);
if(fd < 0)
return -5;
return fd;
}
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
conn_cisco(cisco_t * cp)
{
__pmFdSet wfds;
__pmSockAddr *myaddr;
void *enumIx;
int flags = 0;
int fd;
int ret;
fd = -1;
enumIx = NULL;
for (myaddr = __pmHostEntGetSockAddr(cp->hostinfo, &enumIx);
myaddr != NULL;
myaddr = __pmHostEntGetSockAddr(cp->hostinfo, &enumIx)) {
/* Create a socket */
if (__pmSockAddrIsInet(myaddr))
fd = __pmCreateSocket();
else if (__pmSockAddrIsIPv6(myaddr))
fd = __pmCreateIPv6Socket();
else
fd = -1;
if (fd < 0) {
__pmSockAddrFree(myaddr);
continue; /* Try the next address */
}
/* Attempt to connect */
flags = __pmConnectTo(fd, myaddr, cp->port);
__pmSockAddrFree(myaddr);
if (flags < 0) {
/*
* Mark failure in case we fall out the end of the loop
* and try next address. fd has been closed in __pmConnectTo().
*/
setoserror(ECONNREFUSED);
fd = -1;
continue;
}
/* FNDELAY and we're in progress - wait on select */
__pmFD_ZERO(&wfds);
__pmFD_SET(fd, &wfds);
ret = __pmSelectWrite(fd+1, &wfds, NULL);
/* Was the connection successful? */
if (ret == 0)
setoserror(ETIMEDOUT);
else if (ret > 0) {
ret = __pmConnectCheckError(fd);
if (ret == 0)
break;
setoserror(ret);
}
/* Unsuccessful connection. */
__pmCloseSocket(fd);
fd = -1;
} /* loop over addresses */
if (fd == -1) {
fprintf(stderr, "conn_cisco(%s): connect: %s\n",
cp->host, netstrerror());
return -1;
}
fd = __pmConnectRestoreFlags(fd, flags);
if (fd < 0) {
fprintf(stderr, "conn_cisco(%s): setsockopt: %s\n",
cp->host, netstrerror());
return -1;
}
return fd;
}
static int
_pmauxtraceconnect(void)
{
int port = TRACE_PORT;
char hostname[MAXHOSTNAMELEN];
struct timeval timeout = { 3, 0 }; /* default 3 secs */
__pmSockAddr *myaddr;
__pmHostEnt *servinfo;
void *enumIx;
#ifndef IS_MINGW
struct itimerval _pmolditimer;
void (*old_handler)(int foo);
#endif
int rc, sts;
int flags = 0;
char *sptr, *endptr, *endnum;
struct timeval canwait = { 5, 000000 };
struct timeval stv;
struct timeval *pstv;
__pmFdSet wfds;
#ifdef PMTRACE_DEBUG
if (__pmstate & PMTRACE_STATE_NOAGENT) {
fprintf(stderr, "_pmtraceconnect: connecting to PMDA (skipped)\n");
return 0;
}
else if (__pmstate & PMTRACE_STATE_COMMS)
fprintf(stderr, "_pmtraceconnect: connecting to PMDA ...\n");
#endif
/*
* get optional stuff from environment ...
* PCP_TRACE_HOST, PCP_TRACE_PORT, PCP_TRACE_TIMEOUT, and
* PCP_TRACE_NOAGENT
*/
if ((sptr = getenv(TRACE_ENV_HOST)) != NULL)
strcpy(hostname, sptr);
else {
(void)gethostname(hostname, MAXHOSTNAMELEN);
hostname[MAXHOSTNAMELEN-1] = '\0';
}
if ((sptr = getenv(TRACE_ENV_PORT)) != NULL) {
port = (int)strtol(sptr, &endnum, 0);
if (*endnum != '\0' || port < 0) {
fprintf(stderr, "trace warning: bad PCP_TRACE_PORT ignored.");
port = TRACE_PORT;
}
}
if ((sptr = getenv(TRACE_ENV_TIMEOUT)) != NULL) {
double timesec = strtod(sptr, &endptr);
if (*endptr != '\0' || timesec < 0.0)
fprintf(stderr, "trace warning: bogus PCP_TRACE_TIMEOUT.");
else {
timeout.tv_sec = (time_t)timesec;
timeout.tv_usec = (int)((timesec - (double)timeout.tv_sec)*1000000);
}
}
if (getenv(TRACE_ENV_NOAGENT) != NULL)
__pmstate |= PMTRACE_STATE_NOAGENT;
if ((servinfo = __pmGetAddrInfo(hostname)) == NULL) {
#ifdef PMTRACE_DEBUG
if (__pmstate & PMTRACE_STATE_COMMS)
fprintf(stderr, "_pmtraceconnect(__pmGetAddrInfo(hostname=%s): "
"hosterror=%d, ``%s''\n", hostname, hosterror(),
hoststrerror());
#endif
return -EHOSTUNREACH;
}
/* Try each address in turn until one connects. */
sts = EHOSTUNREACH;
__pmfd = -1;
enumIx = NULL;
for (myaddr = __pmHostEntGetSockAddr(servinfo, &enumIx);
myaddr != NULL;
myaddr = __pmHostEntGetSockAddr(servinfo, &enumIx)) {
/* Create a socket */
if (__pmSockAddrIsInet(myaddr))
__pmfd = __pmCreateSocket();
else if (__pmSockAddrIsIPv6(myaddr))
__pmfd = __pmCreateIPv6Socket();
else {
fprintf(stderr, "_pmtraceconnect(invalid address family): %d\n",
__pmSockAddrGetFamily(myaddr));
}
if (__pmfd < 0) {
sts = neterror();
__pmSockAddrFree(myaddr);
continue; /* Try the next address */
}
/* Set the port. */
__pmSockAddrSetPort(myaddr, port);
#ifndef IS_MINGW
/* arm interval timer */
_pmmyitimer.it_value.tv_sec = timeout.tv_sec;
_pmmyitimer.it_value.tv_usec = timeout.tv_usec;
_pmmyitimer.it_interval.tv_sec = 0;
_pmmyitimer.it_interval.tv_usec = 0;
old_handler = signal(SIGALRM, _pmtracealarm);
setitimer(ITIMER_REAL, &_pmmyitimer, &_pmolditimer);
#endif
#ifdef PMTRACE_DEBUG
if (__pmstate & PMTRACE_STATE_COMMS) {
char *name = __pmHostEntGetName (servinfo);
fprintf(stderr, "_pmtraceconnect: PMDA host=%s port=%d timeout=%d"
"secs\n", name == NULL ? "unknown" : name, port, (int)timeout.tv_sec);
if (name != NULL)
free(name);
}
#endif
/* Attempt to connect */
flags = __pmConnectTo(__pmfd, myaddr, port);
__pmSockAddrFree(myaddr);
if (flags < 0) {
/*
* Mark failure in case we fall out the end of the loop
* and try next address. __pmfd has been closed in __pmConnectTo().
*/
sts = -flags;
__pmfd = -1;
continue;
}
/* FNDELAY and we're in progress - wait on select */
stv = canwait;
pstv = (stv.tv_sec || stv.tv_usec) ? &stv : NULL;
__pmFD_ZERO(&wfds);
__pmFD_SET(__pmfd, &wfds);
if ((rc = __pmSelectWrite(__pmfd+1, &wfds, pstv)) == 1) {
sts = __pmConnectCheckError(__pmfd);
}
else if (rc == 0) {
sts = ETIMEDOUT;
}
else {
sts = (rc < 0) ? neterror() : EINVAL;
}
#ifndef IS_MINGW
/* re-arm interval timer */
setitimer(ITIMER_REAL, &off_itimer, &_pmmyitimer);
signal(SIGALRM, old_handler);
if (_pmolditimer.it_value.tv_sec != 0 && _pmolditimer.it_value.tv_usec != 0) {
_pmolditimer.it_value.tv_usec -= timeout.tv_usec - _pmmyitimer.it_value.tv_usec;
while (_pmolditimer.it_value.tv_usec < 0) {
_pmolditimer.it_value.tv_usec += 1000000;
_pmolditimer.it_value.tv_sec--;
}
while (_pmolditimer.it_value.tv_usec > 1000000) {
_pmolditimer.it_value.tv_usec -= 1000000;
_pmolditimer.it_value.tv_sec++;
}
_pmolditimer.it_value.tv_sec -= timeout.tv_sec - _pmmyitimer.it_value.tv_sec;
if (_pmolditimer.it_value.tv_sec < 0) {
/* missed the user's itimer, pretend there is 1 msec to go! */
_pmolditimer.it_value.tv_sec = 0;
_pmolditimer.it_value.tv_usec = 1000;
}
setitimer(ITIMER_REAL, &_pmolditimer, &_pmmyitimer);
}
#endif
/* Was the connection successful? */
if (sts == 0)
break;
/* Unsuccessful connection. */
__pmCloseSocket(__pmfd);
__pmfd = -1;
} /* loop over addresses */
__pmHostEntFree(servinfo);
/* Was the connection successful? */
if (__pmfd < 0) {
#ifdef PMTRACE_DEBUG
if (__pmstate & PMTRACE_STATE_COMMS)
fprintf(stderr, "_pmtraceconnect(socket failed): %s\n",
netstrerror());
#endif
return -sts;
}
_pmtimedout = 0;
/* Restore the original file status flags. */
if (__pmSetFileStatusFlags(__pmfd, flags) < 0) {
#ifdef PMTRACE_DEBUG
if (__pmstate & PMTRACE_STATE_COMMS)
fprintf(stderr, ":_pmtraceconnect: cannot restore file status flags\n");
#endif
return -oserror();
}
/* make sure this file descriptor is closed if exec() is called */
if ((flags = __pmGetFileDescriptorFlags(__pmfd)) != -1)
sts = __pmSetFileDescriptorFlags(__pmfd, flags | FD_CLOEXEC);
else
sts = -1;
if (sts == -1)
return -oserror();
if (__pmtraceprotocol(TRACE_PROTOCOL_QUERY) == TRACE_PROTOCOL_ASYNC) {
/* in the asynchronoous protocol - ensure no delay after close */
if ((flags = __pmGetFileStatusFlags(__pmfd)) != -1)
sts = __pmSetFileStatusFlags(__pmfd, flags | FNDELAY);
else
sts = -1;
if (sts == -1)
return -oserror();
#ifdef PMTRACE_DEBUG
if (__pmstate & PMTRACE_STATE_COMMS)
fprintf(stderr, "_pmtraceconnect: async protocol setup complete\n");
#endif
}
else
#ifdef PMTRACE_DEBUG
if (__pmstate & PMTRACE_STATE_COMMS)
fprintf(stderr, "_pmtraceconnect: sync protocol setup complete\n");
#endif
/* trace PMDA sends an ACK on successful connect */
sts = _pmtracegetack(sts, 0);
return sts;
}
