/*
* 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;
}
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
}
