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