int cpClient_connect(cpClient *cli, char *host, int port, double timeout)
{
int ret;
cli->serv_addr.sin_family = AF_INET;
cli->serv_addr.sin_port = htons(port);
if (swClient_inet_addr(&cli->serv_addr, host) < 0)
{
return SUCCESS;
}
cli->timeout = timeout;
cpSetTimeout(cli->sock, timeout);
// int count = 0;
while (1)
{
ret = connect(cli->sock, (struct sockaddr *) (&cli->serv_addr), sizeof (cli->serv_addr));
if (ret < 0)
{
if (errno == EINTR)
{
continue;
}
// if (++count <= 15) {//防止重启代理导致的con refused
// usleep(100000);
// continue;
// }
}
break;
}
return ret;
}
static int swClient_udp_connect(swClient *cli, char *host, int port, double timeout, int udp_connect)
{
if (swClient_inet_addr(cli, host, port) < 0)
{
return SW_ERR;
}
cli->socket->active = 1;
cli->timeout = timeout;
int bufsize = SwooleG.socket_buffer_size;
if (timeout > 0)
{
swSocket_set_timeout(cli->socket->fd, timeout);
}
if (cli->type == SW_SOCK_UNIX_DGRAM)
{
struct sockaddr_un* client_addr = &cli->socket->info.addr.un;
sprintf(client_addr->sun_path, "/tmp/swoole-client.%d.%d.sock", getpid(), cli->socket->fd);
client_addr->sun_family = AF_UNIX;
unlink(client_addr->sun_path);
if (bind(cli->socket->fd, (struct sockaddr *) client_addr, sizeof(cli->socket->info.addr.un)) < 0)
{
swSysError("bind(%s) failed.", client_addr->sun_path);
return SW_ERR;
}
}
else if (udp_connect != 1)
{
goto connect_ok;
}
if (connect(cli->socket->fd, (struct sockaddr *) (&cli->server_addr), cli->server_addr.len) == 0)
{
swSocket_clean(cli->socket->fd);
connect_ok:
setsockopt(cli->socket->fd, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
setsockopt(cli->socket->fd, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));
if (cli->async && cli->onConnect)
{
if (SwooleG.main_reactor->add(SwooleG.main_reactor, cli->socket->fd, cli->reactor_fdtype | SW_EVENT_READ) < 0)
{
return SW_ERR;
}
cli->onConnect(cli);
}
return SW_OK;
}
else
{
swSysError("connect() failed.");
cli->socket->active = 0;
return SW_ERR;
}
}
static int swClient_tcp_connect_sync(swClient *cli, char *host, int port, double timeout, int nonblock)
{
int ret;
cli->timeout = timeout;
if (swClient_inet_addr(cli, host, port) < 0)
{
return SW_ERR;
}
if (nonblock == 1)
{
swSetNonBlock(cli->socket->fd);
}
else
{
if (cli->timeout > 0)
{
swSocket_set_timeout(cli->socket->fd, timeout);
}
swSetBlock(cli->socket->fd);
}
while (1)
{
ret = connect(cli->socket->fd, (struct sockaddr *) &cli->server_addr.addr, cli->server_addr.len);
if (ret < 0)
{
if (errno == EINTR)
{
continue;
}
}
break;
}
if (ret >= 0)
{
cli->socket->active = 1;
#ifdef SW_USE_OPENSSL
if (cli->open_ssl)
{
if (swClient_enable_ssl_encrypt(cli) < 0)
{
return SW_ERR;
}
if (swClient_ssl_handshake(cli) < 0)
{
return SW_ERR;
}
}
#endif
}
return ret;
}
static int swClient_udp_connect(swClient *cli, char *host, int port, double timeout, int udp_connect)
{
char buf[1024];
if (swClient_inet_addr(cli, host, port) < 0)
{
return SW_ERR;
}
cli->timeout = timeout;
if (timeout > 0)
{
swSetTimeout(cli->connection.fd, timeout);
}
cli->connection.active = 1;
if (cli->type == SW_SOCK_UNIX_DGRAM)
{
struct sockaddr_un* client_addr = &cli->client_addr.addr.un;
sprintf(client_addr->sun_path, "/tmp/swoole-client.%d.%d.sock", getpid(), cli->connection.fd);
client_addr->sun_family = AF_UNIX;
unlink(client_addr->sun_path);
if (bind(cli->connection.fd, (struct sockaddr *) client_addr, sizeof(cli->client_addr.addr.un)) < 0)
{
swSysError("bind(%s) failed.", client_addr->sun_path);
return SW_ERR;
}
}
else if (udp_connect != 1)
{
return SW_OK;
}
int bufsize = cli->udp_sock_buffer_size;
setsockopt(cli->connection.fd, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
setsockopt(cli->connection.fd, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));
if (connect(cli->connection.fd, (struct sockaddr *) (&cli->server_addr), cli->server_addr.len) == 0)
{
//清理connect前的buffer数据遗留
while (recv(cli->connection.fd, buf, 1024, MSG_DONTWAIT) > 0);
return SW_OK;
}
else
{
swSysError("connect() failed.");
cli->connection.active = 0;
return SW_ERR;
}
}
static int swClient_tcp_connect_async(swClient *cli, char *host, int port, double timeout, int nonblock)
{
int ret;
cli->timeout = timeout;
//alloc input memory buffer
cli->buffer = swString_new(cli->buffer_input_size);
if (!cli->buffer)
{
return SW_ERR;
}
if (!(cli->onConnect && cli->onError && cli->onClose))
{
swWarn("onConnect/onError/onClose callback have not set.");
return SW_ERR;
}
if (swClient_inet_addr(cli, host, port) < 0)
{
return SW_ERR;
}
while (1)
{
ret = connect(cli->socket->fd, (struct sockaddr *) &cli->server_addr.addr, cli->server_addr.len);
if (ret < 0)
{
if (errno == EINTR)
{
continue;
}
SwooleG.error = errno;
}
break;
}
if ((ret < 0 && errno == EINPROGRESS) || ret == 0)
{
if (SwooleG.main_reactor->add(SwooleG.main_reactor, cli->socket->fd, cli->reactor_fdtype | SW_EVENT_WRITE) < 0)
{
return SW_ERR;
}
return SW_OK;
}
return ret;
}
int swClient_tcp_connect(swClient *cli, char *host, int port, double timeout, int nonblock)
{
int ret;
cli->serv_addr.sin_family = cli->sock_domain;
cli->serv_addr.sin_port = htons(port);
if (swClient_inet_addr(cli, host) < 0)
{
return SW_ERR;
}
cli->timeout = timeout;
if (nonblock == 1)
{
swSetNonBlock(cli->sock);
}
else
{
swSetTimeout(cli->sock, timeout);
//block default
//swSetBlock(cli->sock);
}
while (1)
{
ret = connect(cli->sock, (struct sockaddr *) (&cli->serv_addr), sizeof(cli->serv_addr));
if (ret < 0)
{
if (errno == EINTR)
{
continue;
}
}
break;
}
if (ret >= 0)
{
cli->connected = 1;
}
return ret;
}
static int swClient_tcp_connect(swClient *cli, char *host, int port, double timeout, int nonblock)
{
int ret;
cli->timeout = timeout;
if (swClient_inet_addr(cli, host, port) < 0)
{
return SW_ERR;
}
if (nonblock == 1)
{
swSetNonBlock(cli->connection.fd);
}
else
{
if (cli->timeout > 0)
{
swSetTimeout(cli->connection.fd, timeout);
}
swSetBlock(cli->connection.fd);
}
while (1)
{
ret = connect(cli->connection.fd, (struct sockaddr *) &cli->server_addr.addr, cli->server_addr.len);
if (ret < 0)
{
if (errno == EINTR)
{
continue;
}
}
break;
}
if (ret >= 0)
{
cli->connection.active = 1;
}
return ret;
}
int swClient_udp_connect(swClient *cli, char *host, int port, double timeout, int udp_connect)
{
int ret;
char buf[1024];
cli->timeout = timeout;
ret = swSetTimeout(cli->sock, timeout);
if(ret < 0)
{
swWarn("setTimeout fail.errno=%d\n", errno);
return SW_ERR;
}
cli->serv_addr.sin_family = cli->sock_domain;
cli->serv_addr.sin_port = htons(port);
cli->connected = 1;
if (swClient_inet_addr(cli, host) < 0)
{
return SW_ERR;
}
if(udp_connect != 1)
{
return SW_OK;
}
if(connect(cli->sock, (struct sockaddr *) (&cli->serv_addr), sizeof(cli->serv_addr)) == 0)
{
//清理connect前的buffer数据遗留
while(recv(cli->sock, buf, 1024 , MSG_DONTWAIT) > 0);
return SW_OK;
}
else
{
return SW_ERR;
}
}
static int swClient_tcp_connect_sync(swClient *cli, char *host, int port, double timeout, int nonblock)
{
int ret, n;
char buf[1024];
cli->timeout = timeout;
if (swClient_inet_addr(cli, host, port) < 0)
{
return SW_ERR;
}
if (nonblock == 1)
{
swSetNonBlock(cli->socket->fd);
}
else
{
if (cli->timeout > 0)
{
swSocket_set_timeout(cli->socket->fd, timeout);
}
swSetBlock(cli->socket->fd);
}
while (1)
{
ret = connect(cli->socket->fd, (struct sockaddr *) &cli->server_addr.addr, cli->server_addr.len);
if (ret < 0)
{
if (errno == EINTR)
{
continue;
}
}
break;
}
if (ret >= 0)
{
cli->socket->active = 1;
//socks5 proxy
if (cli->socks5_proxy)
{
swSocks5_pack(buf, cli->socks5_proxy->username == NULL ? 0x00 : 0x02);
if (cli->send(cli, buf, 3, 0) < 0)
{
return SW_ERR;
}
cli->socks5_proxy->state = SW_SOCKS5_STATE_HANDSHAKE;
while (1)
{
n = cli->recv(cli, buf, sizeof(buf), 0);
if (n > 0)
{
if (swSocks5_connect(cli, buf, n) < 0)
{
return SW_ERR;
}
else
{
if (cli->socks5_proxy->state == SW_SOCKS5_STATE_READY)
{
break;
}
else
{
continue;
}
}
}
return SW_ERR;
}
}
#ifdef SW_USE_OPENSSL
if (cli->open_ssl)
{
if (swClient_enable_ssl_encrypt(cli) < 0)
{
return SW_ERR;
}
if (swClient_ssl_handshake(cli) < 0)
{
return SW_ERR;
}
}
#endif
}
return ret;
}
static int swClient_tcp_connect_async(swClient *cli, char *host, int port, double timeout, int nonblock)
{
int ret;
cli->timeout = timeout;
if (!cli->buffer)
{
//alloc input memory buffer
cli->buffer = swString_new(cli->buffer_input_size);
if (!cli->buffer)
{
return SW_ERR;
}
}
if (!(cli->onConnect && cli->onError && cli->onClose))
{
swWarn("onConnect/onError/onClose callback have not set.");
return SW_ERR;
}
if (cli->onBufferFull && cli->buffer_high_watermark == 0)
{
cli->buffer_high_watermark = cli->socket->buffer_size * 0.8;
}
if (swClient_inet_addr(cli, host, port) < 0)
{
return SW_ERR;
}
if (cli->wait_dns)
{
swAio_event ev;
bzero(&ev, sizeof(swAio_event));
int len = strlen(cli->server_host);
if (strlen(cli->server_host) < SW_IP_MAX_LENGTH)
{
ev.nbytes = SW_IP_MAX_LENGTH;
}
else
{
ev.nbytes = len + 1;
}
ev.buf = sw_malloc(ev.nbytes);
if (!ev.buf)
{
swWarn("malloc failed.");
return SW_ERR;
}
memcpy(ev.buf, cli->server_host, len);
((char *) ev.buf)[len] = 0;
ev.flags = cli->_sock_domain;
ev.type = SW_AIO_DNS_LOOKUP;
ev.object = cli;
ev.callback = swClient_onResolveCompleted;
return swAio_dispatch(&ev);
}
while (1)
{
ret = connect(cli->socket->fd, (struct sockaddr *) &cli->server_addr.addr, cli->server_addr.len);
if (ret < 0)
{
if (errno == EINTR)
{
continue;
}
SwooleG.error = errno;
}
break;
}
if ((ret < 0 && errno == EINPROGRESS) || ret == 0)
{
if (SwooleG.main_reactor->add(SwooleG.main_reactor, cli->socket->fd, cli->reactor_fdtype | SW_EVENT_WRITE) < 0)
{
return SW_ERR;
}
if (timeout > 0)
{
if (SwooleG.timer.fd == 0)
{
swTimer_init((int) (timeout * 1000));
}
cli->timer = SwooleG.timer.add(&SwooleG.timer, (int) (timeout * 1000), 0, cli, swClient_onTimeout);
}
return SW_OK;
}
return ret;
}
