/*
* Connect PF_INET socket.
*/
LTTNG_HIDDEN
int lttcomm_connect_inet_sock(struct lttcomm_sock *sock)
{
int ret, closeret;
if (lttcomm_get_network_timeout()) {
ret = connect_with_timeout(sock);
} else {
ret = connect_no_timeout(sock);
}
if (ret < 0) {
PERROR("connect");
goto error_connect;
}
return ret;
error_connect:
closeret = close(sock->fd);
if (closeret) {
PERROR("close inet");
}
return ret;
}
int bluez_connect(struct addrinfo hints,
const char *remote_address, const char *remote_service,
set_sockopt_handler_t set_sockopt_handler, void *hdata,
time_t timeout, int *rt_socktype)
{
int err, fd = -1;
struct sockaddr_storage ss;
socklen_t salen = 0;
char name_buf[BA_STR_SIZE];
/* make sure arguments are valid and preconditions are respected */
assert(remote_address != NULL && strlen(remote_address) > 0);
/* this function only supports a specific protocol family */
assert(hints.ai_family == PF_BLUETOOTH);
memset(&ss, 0, sizeof(ss));
/* get the sockaddr */
if (getbluezaddr(remote_address, remote_service, &hints,
(struct sockaddr *)&ss, &salen))
{
return -1;
}
/* setup name_buf if we're in verbose mode */
if (verbose_mode())
getbluezname((struct sockaddr *)&ss, hints.ai_protocol,
name_buf, sizeof(name_buf));
fd = socket(hints.ai_family, hints.ai_socktype, hints.ai_protocol);
if (fd < 0) {
warning("cannot create the bluez socket: %s", strerror(errno));
return -1;
}
if (set_sockopt_handler != NULL)
set_sockopt_handler(fd, hdata);
err = connect_with_timeout(fd, (struct sockaddr *)&ss, salen, timeout);
if (err != 0) {
if (verbose_mode()) {
if (errno == ETIMEDOUT) {
/* connection timed out */
warning(_("timeout while connecting to %s"),
name_buf);
}
else {
/* connection failed */
warning(_("cannot connect to %s: %s"),
name_buf, strerror(errno));
}
}
return err;
}
*rt_socktype = hints.ai_socktype;
return fd;
}
int connect_to_server(const char *server, const char *port, int timeout)
{
if(server == NULL || port == NULL)
{
return -1 ;
}
struct addrinfo *result = NULL ;
struct addrinfo hints ;
hints.ai_family = AF_UNSPEC ;
hints.ai_protocol = 0 ;
hints.ai_socktype = SOCK_STREAM ;
hints.ai_addr = NULL ;
hints.ai_addrlen = 0 ;
hints.ai_next = NULL ;
hints.ai_flags = 0 ;
int ret = getaddrinfo(server, port, &hints, &result) ;
struct addrinfo *tmp = result ;
int cfd = -1 ;
for(tmp = result; tmp != NULL ;tmp = tmp ->ai_next)
{
char ip[256] = {0} ;
inet_ntop(tmp ->ai_family, &(((struct sockaddr_in *)tmp ->ai_addr) ->sin_addr), ip, sizeof(ip) -1) ;
printf("ip = %s port = %d\n", ip, ntohs(((struct sockaddr_in *)tmp ->ai_addr) ->sin_port)) ;
cfd = socket(tmp ->ai_family, tmp ->ai_socktype, tmp ->ai_protocol) ;
if(cfd == -1)
continue ;
if(connect_with_timeout(cfd, tmp ->ai_addr, tmp ->ai_addrlen, timeout) == 0)
break ;
close(cfd) ;
cfd = -1 ;
}
freeaddrinfo(result) ;
return cfd ;
}
int connect_to_server()
{
/*
* 1. Connect to server, timeout is 5s connect
* If server down -> reconnect after 5s
* 2. Succeess, wait until receive request from Android client
*/
int ret;
// Connect to server
while(1)
{
ret = connect_with_timeout(SERVER, SERVER_PORT, 5, 0, "rpi001$6789");
if (ret == -2 || ret == -3 || ret == -4)//timeout
{
printf("Connect failed - Cause by server's network state!, ret =%d\n", ret);
sleep(5);
}
else if (ret == -5)
{
printf("Connect failed - Cause by wrong username or password!, ret =%d\n", ret);
sleep(5);
}
else //sucess
{
global_socket = ret;
printf ("Connect to server: ret = %d\n", global_socket);
printf("Connect successful!\n");
break;
}
}
}
int ClientConn::Connect(const string& server_ip, uint16_t server_port, uint32_t timeout)
{
server_ip_ = server_ip;
server_port_ = server_port;
timeout_ = timeout;
conn_handle_ = connect_with_timeout(server_ip.c_str(), server_port, timeout);
if (conn_handle_ == NETLIB_INVALID_HANDLE) {
return 1;
} else {
block_set_timeout(conn_handle_, timeout);
return 0;
}
}
int ClientConn::Reconnect()
{
if (conn_handle_ != NETLIB_INVALID_HANDLE) {
Close();
}
conn_handle_ = connect_with_timeout(server_ip_.c_str(), server_port_, timeout_);
if (conn_handle_ == NETLIB_INVALID_HANDLE) {
return 1;
} else {
block_set_timeout(conn_handle_, timeout_);
return 0;
}
}
static Variant new_socket_connect(const HostURL &hosturl, double timeout,
Variant &errnum, Variant &errstr) {
int domain = AF_UNSPEC;
int type = SOCK_STREAM;
auto const& scheme = hosturl.getScheme();
SmartPtr<Socket> sock;
SmartPtr<SSLSocket> sslsock;
std::string sockerr;
int error;
if (scheme == "udp" || scheme == "udg") {
type = SOCK_DGRAM;
} else if (scheme == "unix") {
domain = AF_UNIX;
}
int fd = -1;
if (domain == AF_UNIX) {
sockaddr_storage sa_storage;
struct sockaddr *sa_ptr;
size_t sa_size;
fd = socket(domain, type, 0);
sock = makeSmartPtr<Socket>(
fd, domain, hosturl.getHost().c_str(), hosturl.getPort());
if (!set_sockaddr(sa_storage, sock, hosturl.getHost().c_str(),
hosturl.getPort(), sa_ptr, sa_size)) {
// set_sockaddr raises its own warning on failure
return false;
}
if (connect_with_timeout(fd, sa_ptr, sa_size, timeout,
hosturl, sockerr, error) != 0) {
SOCKET_ERROR(sock, sockerr.c_str(), error);
errnum = sock->getLastError();
errstr = HHVM_FN(socket_strerror)(sock->getLastError());
return false;
}
} else {
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = domain;
hints.ai_socktype = type;
auto port = folly::to<std::string>(hosturl.getPort());
auto host = hosturl.getHost();
struct addrinfo *aiHead;
int errcode = getaddrinfo(host.c_str(), port.c_str(), &hints, &aiHead);
if (errcode != 0) {
errstr = String(gai_strerror(errcode), CopyString);
return false;
}
SCOPE_EXIT { freeaddrinfo(aiHead); };
for (struct addrinfo *ai = aiHead; ai != nullptr; ai = ai->ai_next) {
domain = ai->ai_family;
fd = socket(domain, ai->ai_socktype, ai->ai_protocol);
if (fd == -1) {
continue;
}
if (connect_with_timeout(fd, ai->ai_addr, ai->ai_addrlen, timeout,
hosturl, sockerr, error) == 0) {
break;
}
close(fd);
fd = -1;
}
sslsock = SSLSocket::Create(fd, domain, hosturl, timeout);
if (sslsock) {
sock = sslsock;
} else {
sock = makeSmartPtr<Socket>(fd,
domain,
hosturl.getHost().c_str(),
hosturl.getPort());
}
}
if (!sock->valid()) {
SOCKET_ERROR(sock,
sockerr.empty() ? "unable to create socket" : sockerr.c_str(), error);
errnum = sock->getLastError();
errstr = HHVM_FN(socket_strerror)(sock->getLastError());
return false;
}
if (sslsock && !sslsock->onConnect()) {
raise_warning("Failed to enable crypto");
return false;
}
return Variant(std::move(sock));
}
int neo4j_connect_tcp_socket(const char *hostname, const char *servname,
const neo4j_config_t *config, neo4j_logger_t *logger)
{
REQUIRE(hostname != NULL, -1);
struct addrinfo hints;
struct addrinfo *candidate_addresses = NULL;
int err = 0;
init_getaddrinfo_hints(&hints);
err = getaddrinfo(hostname, servname, &hints, &candidate_addresses);
if (err)
{
errno = NEO4J_UNKNOWN_HOST;
return -1;
}
int fd = -1;
struct addrinfo *addr;
for (addr = candidate_addresses; addr != NULL; addr = addr->ai_next)
{
fd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
if (fd < 0)
{
if (!unsupported_sock_error(errno))
continue;
neo4j_log_error_errno(logger, "socket");
freeaddrinfo(candidate_addresses);
return -1;
}
set_socket_options(fd, config, logger);
char hostnum[NI_MAXHOST];
char servnum[NI_MAXSERV];
err = getnameinfo(addr->ai_addr, addr->ai_addrlen,
hostnum, sizeof(hostnum), servnum, sizeof(servnum),
NI_NUMERICHOST | NI_NUMERICSERV);
if (err)
{
neo4j_log_error(logger, "getnameinfo: %s", gai_strerror(err));
freeaddrinfo(candidate_addresses);
errno = NEO4J_UNEXPECTED_ERROR;
return -1;
}
neo4j_log_debug(logger, "attempting connection to %s [%s]",
hostnum, servnum);
err = connect_with_timeout(fd, addr->ai_addr, addr->ai_addrlen,
config->connect_timeout, logger);
if (err == 0)
{
break;
}
else if (err < 0)
{
return -1;
}
char ebuf[256];
neo4j_log_info(logger, "connection to %s [%s] failed: %s",
hostnum, servnum, neo4j_strerror(errno, ebuf, sizeof(ebuf)));
close(fd);
fd = -1;
}
freeaddrinfo(candidate_addresses);
return fd;
}
