static int
init_fake_server(int ip_port)
{
struct sockaddr_in sin;
TDS_SYS_SOCKET s;
memset(&sin, 0, sizeof(sin));
sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
sin.sin_port = htons((short) ip_port);
sin.sin_family = AF_INET;
if (TDS_IS_SOCKET_INVALID(s = socket(AF_INET, SOCK_STREAM, 0))) {
perror("socket");
exit(1);
}
if (bind(s, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
perror("bind");
CLOSESOCKET(s);
return 1;
}
if (listen(s, 5) < 0) {
perror("listen");
CLOSESOCKET(s);
return 1;
}
if (tds_thread_create(&fake_thread, fake_thread_proc, int2ptr(s)) != 0) {
perror("tds_thread_create");
exit(1);
}
return 0;
}
void
tds_wakeup_close(TDSPOLLWAKEUP *wakeup)
{
if (!TDS_IS_SOCKET_INVALID(wakeup->s_signal))
CLOSESOCKET(wakeup->s_signal);
if (!TDS_IS_SOCKET_INVALID(wakeup->s_signaled))
CLOSESOCKET(wakeup->s_signaled);
}
static int jiveL_dns_gc(lua_State *L) {
struct dns_userdata *u;
u = lua_touserdata(L, 1);
CLOSESOCKET(u->fd[0]);
CLOSESOCKET(u->fd[1]);
return 0;
}
void nv_get(const char *vid) {
WS2I
const char * const us = getSession();
char * const buf = malloc(1024 * 1024);//1MB cache
char *ptr, *host, *url;
int sock = create_socket("www.nicovideo.jp", "http", 0), len;
send(sock, "HEAD /watch/", 12, 0);
send(sock, vid, strlen(vid), 0);
send(sock, " HTTP/1.0\r\nHost: www.nicovideo.jp\r\nCookie: user_session=", 56, 0);
send(sock, us, strlen(us), 0);
send(sock, "\r\n\r\n", 4, 0);
buf[recv(sock, buf, 1024 * 1024, MSG_WAITALL)] = 0;
CLOSESOCKET(sock);
ptr = strstr(buf, "nicohistory=") + 12; *strchr(ptr, ';') = 0;
strcpy(buf + 1024 * 1023, ptr);
// ---------------------------------------------------------------------------------
sock = create_socket("flapi.nicovideo.jp", "http", 0);
send(sock, "GET /api/getflv?v=", 18, 0);
send(sock, vid, strlen(vid), 0);
send(sock, " HTTP/1.0\r\nHost: flapi.nicovideo.jp\r\nCookie: user_session=", 58, 0);
send(sock, us, strlen(us), 0);
send(sock, "\r\n\r\n", 4, 0);
buf[recv(sock, buf, 1024 * 1023, MSG_WAITALL)] = 0;
CLOSESOCKET(sock);
ptr = strstr(buf, "url=") + 4; *strchr(ptr, '&') = 0;
sep_dec_url(ptr, &host, &url);
// ---------------------------------------------------------------------------------
sock = create_socket(host, ptr, 0);
send(sock, "GET ", 4, 0);
send(sock, url, strlen(url), 0);
send(sock, " HTTP/1.0\r\nHost: ", 17, 0);
send(sock, host, strlen(host), 0);
send(sock, "\r\nCookie: nicohistory=", 22, 0);
send(sock, buf + 1024 * 1023, strlen(buf + 1024 * 1023), 0);
send(sock, "; user_session=", 15, 0);
send(sock, us, strlen(us), 0);
send(sock, "\r\n\r\n", 4, 0);
memcpy(buf, CACHE_DIR, 6);
strcpy(buf + 6, vid);
FILE *f = fopen(buf, "wb");
int http = 0;
while ((len = recv(sock, buf, 1024 * 1024, MSG_WAITALL))) {
ptr = buf; url = ptr + len;
if (http >= 2) goto L2;
L1: if (*ptr == '\n') { if (++http >= 2) { ptr++; goto L2; }
} else if (*ptr != '\r') http = 0;
if (++ptr < url) goto L1;
continue;
L2: fwrite(ptr, 1, url - ptr, f);
}
CLOSESOCKET(sock);
fclose(f);
WS2U
}
void NetKeepaliveDestroy( void )
{
shutdown(ka.keepalive_fd, SHUT_RDWR);
#ifdef WIN32
if( hHandle != NULL )
{
IcmpCloseHandle(hHandle);
hHandle = NULL;
}
if( hEvent != NULL )
{
CloseHandle(hEvent);
hEvent = NULL;
}
// Free IP Helper API DLL handle, and invalidate function pointers.
if( hndliphlp != NULL )
{
IcmpCreateFile = NULL;
IcmpCloseHandle = NULL;
IcmpSendEcho2 = NULL;
IcmpParseReplies = NULL;
Icmp6CreateFile = NULL;
Icmp6SendEcho2 = NULL;
Icmp6ParseReplies = NULL;
FreeLibrary( hndliphlp );
}
#endif
CLOSESOCKET(ka.keepalive_fd);
memset(&ka, 0, sizeof(struct NetKeepAlive));
}
/**
* Close current socket
* for last socket close entire connection
* for MARS send FIN request
*/
void
tds_close_socket(TDSSOCKET * tds)
{
if (!IS_TDSDEAD(tds)) {
#if ENABLE_ODBC_MARS
TDSCONNECTION *conn = tds->conn;
unsigned n = 0, count = 0;
tds_mutex_lock(&conn->list_mtx);
for (; n < conn->num_sessions; ++n)
if (TDSSOCKET_VALID(conn->sessions[n]))
++count;
if (count > 1)
tds_append_fin(tds);
tds_mutex_unlock(&conn->list_mtx);
if (count <= 1) {
tds_disconnect(tds);
tds_connection_close(conn);
} else {
tds_set_state(tds, TDS_DEAD);
}
#else
tds_disconnect(tds);
if (CLOSESOCKET(tds_get_s(tds)) == -1)
tdserror(tds_get_ctx(tds), tds, TDSECLOS, sock_errno);
tds_set_s(tds, INVALID_SOCKET);
tds_set_state(tds, TDS_DEAD);
#endif
}
}
/* read bytes from the streaming socket and discard - used by network test to measure network throughput*/
static int stream_readtonullL(lua_State *L) {
struct stream *stream;
char buf[4094];
int n;
/*
* 1: Stream (self)
*/
stream = lua_touserdata(L, 1);
n = recv(stream->fd, buf, sizeof(buf), 0);
if (n > 0) {
fifo_lock(&streambuf_fifo);
streambuf_bytes_received += n;
fifo_unlock(&streambuf_fifo);
lua_pushinteger(L, n);
return 1;
} else if (n == -1 && errno == EAGAIN) {
lua_pushinteger(L, 0);
return 1;
} else {
CLOSESOCKET(stream->fd);
lua_pushnil(L);
lua_pushstring(L, strerror(n));
return 2;
}
}
/* read data from the stream socket into a lua string */
static int stream_readtoL(lua_State *L) {
struct stream *stream;
char buf[4094];
int n;
/*
* 1: Stream (self)
*/
stream = lua_touserdata(L, 1);
n = recv(stream->fd, buf, sizeof(buf), 0);
if (n > 0) {
lua_pushlstring(L, buf, n);
return 1;
} else if (n == -1 && errno == EAGAIN) {
lua_pushnil(L);
return 1;
} else {
CLOSESOCKET(stream->fd);
lua_pushnil(L);
lua_pushstring(L, strerror(SOCKETERROR));
return 2;
}
}
/* remove all pollfunctions and close socket */
static void udpreceive_tilde_closesocket(t_udpreceive_tilde* x)
{
sys_rmpollfn(x->x_socket);
outlet_float(x->x_outlet1, 0);
CLOSESOCKET(x->x_socket);
x->x_socket = -1;
}
static void *http_thread(void *ptr) {
slimaudio_t *audio = (slimaudio_t *) ptr;
#ifdef SLIMPROTO_DEBUG
int last_state = 0;
#endif
#ifdef BSD_THREAD_LOCKING
pthread_mutex_lock(&audio->http_mutex);
#endif
audio->http_state = STREAM_STOPPED;
while (true) {
#ifdef SLIMPROTO_DEBUG
if (last_state == audio->http_state) {
VDEBUGF("http_thread state %i\n", audio->http_state);
}
else {
DEBUGF("http_thread state %i\n", audio->http_state);
}
last_state = audio->http_state;
#endif
switch (audio->http_state) {
case STREAM_STOP:
CLOSESOCKET(audio->streamfd);
slimproto_dsco(audio->proto, DSCO_CLOSED);
slimaudio_buffer_close(audio->decoder_buffer);
audio->http_state = STREAM_STOPPED;
pthread_cond_broadcast(&audio->http_cond);
break;
case STREAM_STOPPED:
pthread_cond_wait(&audio->http_cond, &audio->http_mutex);
break;
case STREAM_PLAYING:
pthread_mutex_unlock(&audio->http_mutex);
http_recv(audio);
pthread_mutex_lock(&audio->http_mutex);
break;
case STREAM_QUIT:
return 0;
}
}
pthread_mutex_unlock(&audio->http_mutex);
}
static void
pool_destroy(TDS_POOL *pool)
{
pool_mbr_destroy(pool);
pool_user_destroy(pool);
CLOSESOCKET(pool->wakeup_fd);
CLOSESOCKET(pool->listen_fd);
CLOSESOCKET(pool->event_fd);
tds_mutex_free(&pool->events_mtx);
free(pool->user);
free(pool->password);
free(pool->server);
free(pool->database);
free(pool->name);
free(pool);
}
bool CG_NetSocket::Close()
{
if (m_socket == INVALID_SOCKET) return false;
CLOSESOCKET(m_socket);
Reset();
if (--m_nCount==0)
_NetCleanUp();
return true;
}
/*
====================
dis-connection client fd
====================
*/
void disconnectClient (struct sPacket* pClient)
{
REMOVE_FROM_LIST (g_ClientList, pClient, m_prev, m_next);
if (pClient->m_sock != INVALID_SOCKET)
CLOSESOCKET (pClient->m_sock);
free (pClient);
pClient = NULL;
}
int
tds_close_socket(TDSSOCKET * tds)
{
int rc = -1;
if (!IS_TDSDEAD(tds)) {
rc = CLOSESOCKET(tds->s);
tds->s = INVALID_SOCKET;
tds_set_state(tds, TDS_DEAD);
}
return rc;
}
/* accept a socket and read data as much as you can */
static TDS_THREAD_PROC_DECLARE(fake_thread_proc, arg)
{
TDS_SYS_SOCKET s = ptr2int(arg), sock;
socklen_t len;
char buf[128];
struct sockaddr_in sin;
struct pollfd fd;
memset(&sin, 0, sizeof(sin));
len = sizeof(sin);
fd.fd = s;
fd.events = POLLIN;
fd.revents = 0;
if (poll(&fd, 1, 30000) <= 0) {
perror("poll");
exit(1);
}
if (TDS_IS_SOCKET_INVALID(sock = tds_accept(s, (struct sockaddr *) &sin, &len))) {
perror("accept");
exit(1);
}
tds_mutex_lock(&mtx);
fake_sock = sock;
tds_mutex_unlock(&mtx);
CLOSESOCKET(s);
for (;;) {
int len;
fd.fd = sock;
fd.events = POLLIN;
fd.revents = 0;
if (poll(&fd, 1, 30000) <= 0) {
perror("poll");
exit(1);
}
/* just read and discard */
len = READSOCKET(sock, buf, sizeof(buf));
if (len == 0)
break;
if (len < 0 && sock_errno != TDSSOCK_EINPROGRESS)
break;
}
return NULL;
}
/*
====================
acppet a new client fd
====================
*/
void acceptNewClient (SOCKET listenfd)
{
SOCKET newDesc;
struct sockaddr_in peer;
#if defined (WIN32)
int peersize;
#else
socklen_t peersize;
#endif
peersize = sizeof (peer);
newDesc = accept (listenfd, (struct sockaddr*) &peer, &peersize);
if (newDesc < 0)
{
outLog ((char*)"accept new client failed!\r\n");
return;
}
setNonblock (newDesc);
struct sPacket* newClient = (struct sPacket*) malloc (sizeof (struct sPacket*));
if (!newClient)
{
CLOSESOCKET (newDesc);
return;
}
newClient->m_sock = newDesc;
(void*) strcpy (newClient->m_ip, (char*) inet_ntoa (peer.sin_addr));
*newClient->m_recvBuff = 0x00;
newClient->m_recvSize = 0x00;
newClient->m_recvPos = 0x00;
*newClient->m_sendBuff = 0x00;
newClient->m_sendSize = 0x00;
*newClient->m_name = 0x00;
newClient->m_lastRecvTime = getTime ();
newClient->m_prev = NULL;
newClient->m_next = NULL;
INSERT_TO_LIST (g_ClientList, newClient, m_prev, m_next);
g_TotalClient++;
outLog ((char*)"accept new connection: %d [%s]\r\n", newDesc, newClient->m_ip);
}
void closeallfd() {
int i;
printf("[+] Let me exit ......\r\n");
fflush(stdout);
for (i = 3; i < 256; i++) {
CLOSESOCKET(i);
}
if (fp != NULL) {
fprintf(fp, "\r\n====== Exit ======\r\n");
fclose(fp);
}
printf("[+] All Right!\r\n");
}
void
tds_connection_close(TDSCONNECTION *conn)
{
unsigned n = 0;
if (!TDS_IS_SOCKET_INVALID(conn->s)) {
/* TODO check error ?? how to return it ?? */
CLOSESOCKET(conn->s);
conn->s = INVALID_SOCKET;
}
tds_mutex_lock(&conn->list_mtx);
for (; n < conn->num_sessions; ++n)
if (TDSSOCKET_VALID(conn->sessions[n]))
tds_set_state(conn->sessions[n], TDS_DEAD);
tds_mutex_unlock(&conn->list_mtx);
}
/*
====================
initialize server socket
====================
*/
SOCKET initServerSock (int port, int backLog)
{
struct sockaddr_in sa;
SOCKET sock;
sock = socket (PF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
outLog ((char*)"InitServerSock(), socket (..) failed [PORT: %d].. \r\n", port);
return (-1);
}
int opt = 1;
if (setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, \
(char*) &opt, sizeof (opt)) < 0) {
outLog ((char*)"* Error: setsockopt REUSEADDR\r\n");
exit (1);
}
struct linger ld;
ld.l_onoff = 0;
ld.l_linger = 0;
if (setsockopt (sock, SOL_SOCKET, SO_LINGER, \
(char*) &ld, sizeof (ld)) < 0)
outLog ((char*)"* Error: setsockopt SO_LINGER ...\r\n");
(void) memset ((char*)&sa, 0x00, sizeof (sa));
sa.sin_family = PF_INET;
sa.sin_port = htons (port);
sa.sin_addr.s_addr = INADDR_ANY;
if (bind (sock, (struct sockaddr*)&sa, sizeof (sa)) < 0)
{
outLog ((char*)"InitServerSock(), bind (..) failed [PORT: %d].. \r\n", port);
CLOSESOCKET (sock);
return (-1);
}
setNonblock (sock);
listen (sock, backLog);
return (sock);
}
static int stream_writeL(lua_State *L) {
struct stream *stream;
const char *header;
ssize_t n;
size_t len;
/*
* 1: Stream (self)
* 2: Playback (self)
* 3: header
*/
stream = lua_touserdata(L, 1);
header = lua_tolstring(L, 3, &len);
while (len > 0) {
n = send(stream->fd, header, len, 0);
if (n < 0) {
CLOSESOCKET(stream->fd);
lua_pushnil(L);
lua_pushstring(L, strerror(SOCKETERROR));
return 2;
}
len -= n;
}
/*
if (shutdown(stream->fd, SHUT_WR) != 0) {
CLOSESOCKET(stream->fd);
lua_pushnil(L);
lua_pushstring(L, strerror(SOCKETERROR));
return 2;
}
*/
lua_pushboolean(L, TRUE);
return 1;
}
int makeClientSocket(const char *hostname, int port){
int sock;
struct hostent *host;
struct sockaddr_in addr;
if((host = gethostbyname(hostname)) == NULL ){
perror(hostname);
abort();
}
sock = socket(PF_INET, SOCK_STREAM, 0);
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = *(long*)(host->h_addr);
if(connect(sock, (struct sockaddr*)&addr, sizeof(addr)) != 0){
CLOSESOCKET(sock);
perror(hostname);
abort();
}
return sock;
}
static int stream_disconnectL(lua_State *L) {
struct stream *stream;
/*
* 1: self
*/
stream = lua_touserdata(L, 1);
if (stream->body) {
free(stream->body);
stream->body = NULL;
stream->body_len = 0;
}
if (stream->fd) {
CLOSESOCKET(stream->fd);
stream->fd = 0;
}
return 0;
}
static size_t
ServerNetworkLayerTCP_stop(ServerNetworkLayerTCP *layer, UA_Job **jobs) {
UA_LOG_INFO(layer->layer.logger, UA_LOGCATEGORY_NETWORK,
"Shutting down the TCP network layer with %d open connection(s)", layer->mappingsSize);
shutdown(layer->serversockfd,2);
CLOSESOCKET(layer->serversockfd);
UA_Job *items = malloc(sizeof(UA_Job) * layer->mappingsSize * 2);
if(!items)
return 0;
for(size_t i = 0; i < layer->mappingsSize; i++) {
socket_close(layer->mappings[i].connection);
items[i*2].type = UA_JOBTYPE_DETACHCONNECTION;
items[i*2].job.closeConnection = layer->mappings[i].connection;
items[(i*2)+1].type = UA_JOBTYPE_METHODCALL_DELAYED;
items[(i*2)+1].job.methodCall.method = FreeConnectionCallback;
items[(i*2)+1].job.methodCall.data = layer->mappings[i].connection;
}
#ifdef _WIN32
WSACleanup();
#endif
*jobs = items;
return layer->mappingsSize*2;
}
void slimaudio_http_disconnect(slimaudio_t *audio) {
pthread_mutex_lock(&audio->http_mutex);
if (audio->http_state == STREAM_PLAYING)
{
DEBUGF("slimaudio_http_disconnect: state=%i\n", audio->http_state);
audio->http_state = STREAM_STOP;
/* closing socket and buffer will wake the http thread */
CLOSESOCKET(audio->streamfd);
slimaudio_buffer_close(audio->decoder_buffer);
pthread_cond_broadcast(&audio->http_cond);
while (audio->http_state == STREAM_STOP)
{
pthread_cond_wait(&audio->http_cond, &audio->http_mutex);
}
}
pthread_mutex_unlock(&audio->http_mutex);
}
static void
socket_close(UA_Connection *connection) {
connection->state = UA_CONNECTION_CLOSED;
shutdown(connection->sockfd,2);
CLOSESOCKET(connection->sockfd);
}
static UA_StatusCode
ServerNetworkLayerTCP_start(UA_ServerNetworkLayer *nl) {
ServerNetworkLayerTCP *layer = nl->handle;
#ifdef _WIN32
if((layer->serversockfd = socket(PF_INET, SOCK_STREAM,0)) == (UA_Int32)INVALID_SOCKET) {
UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, "Error opening socket, code: %d",
WSAGetLastError());
return UA_STATUSCODE_BADINTERNALERROR;
}
#else
if((layer->serversockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, "Error opening socket");
return UA_STATUSCODE_BADINTERNALERROR;
}
#endif
const struct sockaddr_in serv_addr =
{.sin_family = AF_INET, .sin_addr.s_addr = INADDR_ANY,
.sin_port = htons(layer->port), .sin_zero = {0}};
int optval = 1;
if(setsockopt(layer->serversockfd, SOL_SOCKET,
SO_REUSEADDR, (const char *)&optval, sizeof(optval)) == -1) {
UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK,
"Error during setting of socket options");
CLOSESOCKET(layer->serversockfd);
return UA_STATUSCODE_BADINTERNALERROR;
}
if(bind(layer->serversockfd, (const struct sockaddr *)&serv_addr,
sizeof(serv_addr)) < 0) {
UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, "Error during socket binding");
CLOSESOCKET(layer->serversockfd);
return UA_STATUSCODE_BADINTERNALERROR;
}
socket_set_nonblocking(layer->serversockfd);
listen(layer->serversockfd, MAXBACKLOG);
UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK, "TCP network layer listening on %.*s",
nl->discoveryUrl.length, nl->discoveryUrl.data);
return UA_STATUSCODE_GOOD;
}
static size_t
ServerNetworkLayerTCP_getJobs(UA_ServerNetworkLayer *nl, UA_Job **jobs, UA_UInt16 timeout) {
ServerNetworkLayerTCP *layer = nl->handle;
fd_set fdset;
UA_Int32 highestfd = setFDSet(layer, &fdset);
struct timeval tmptv = {0, timeout};
UA_Int32 resultsize;
resultsize = select(highestfd+1, &fdset, NULL, NULL, &tmptv);
if(resultsize < 0) {
*jobs = NULL;
return 0;
}
/* accept new connections (can only be a single one) */
if(FD_ISSET(layer->serversockfd, &fdset)) {
resultsize--;
struct sockaddr_in cli_addr;
socklen_t cli_len = sizeof(cli_addr);
int newsockfd = accept(layer->serversockfd, (struct sockaddr *) &cli_addr, &cli_len);
int i = 1;
setsockopt(newsockfd, IPPROTO_TCP, TCP_NODELAY, (void *)&i, sizeof(i));
if(newsockfd >= 0) {
socket_set_nonblocking(newsockfd);
ServerNetworkLayerTCP_add(layer, newsockfd);
}
}
/* alloc enough space for a cleanup-connection and free-connection job per resulted socket */
if(resultsize == 0)
return 0;
UA_Job *js = malloc(sizeof(UA_Job) * resultsize * 2);
if(!js)
return 0;
/* read from established sockets */
size_t j = 0;
UA_ByteString buf = UA_BYTESTRING_NULL;
for(size_t i = 0; i < layer->mappingsSize && j < (size_t)resultsize; i++) {
if(!(FD_ISSET(layer->mappings[i].sockfd, &fdset)))
continue;
UA_StatusCode retval = socket_recv(layer->mappings[i].connection, &buf, 0);
if(retval == UA_STATUSCODE_GOOD) {
UA_Boolean realloced = UA_FALSE;
retval = UA_Connection_completeMessages(layer->mappings[i].connection, &buf, &realloced);
if(retval != UA_STATUSCODE_GOOD || buf.length == 0)
continue;
js[j].job.binaryMessage.connection = layer->mappings[i].connection;
js[j].job.binaryMessage.message = buf;
if(!realloced)
js[j].type = UA_JOBTYPE_BINARYMESSAGE_NETWORKLAYER;
else
js[j].type = UA_JOBTYPE_BINARYMESSAGE_ALLOCATED;
j++;
} else if (retval == UA_STATUSCODE_BADCONNECTIONCLOSED) {
UA_Connection *c = layer->mappings[i].connection;
/* the socket was closed from remote */
js[j].type = UA_JOBTYPE_DETACHCONNECTION;
js[j].job.closeConnection = layer->mappings[i].connection;
layer->mappings[i] = layer->mappings[layer->mappingsSize-1];
layer->mappingsSize--;
j++;
js[j].type = UA_JOBTYPE_METHODCALL_DELAYED;
js[j].job.methodCall.method = FreeConnectionCallback;
js[j].job.methodCall.data = c;
j++;
}
}
if(j == 0) {
free(js);
js = NULL;
}
*jobs = js;
return j;
}
BOOL CClient::Connect(const std::string& server_ip, unsigned int server_port)
{
AUTO_LOG_FUNCTION;
if (m_bConnectionEstablished)
return TRUE;
do {
struct sockaddr_in server_addr;
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.S_un.S_addr = inet_addr(server_ip.c_str());
server_addr.sin_port = htons(static_cast<u_short>(server_port));
if ((m_socket = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
JLOG(_T("socket failed\n"));
JLOG(FormatWSAError(WSAGetLastError()));
break;
}
// set the socket in non-blocking mode.
unsigned long non_blocking_mode = 1;
int result = ioctlsocket(m_socket, FIONBIO, &non_blocking_mode);
if (result != NO_ERROR) {
JLOG(_T("ioctlsocket failed : %d\n"), result);
JLOG(FormatWSAError(WSAGetLastError()));
CLOSESOCKET(m_socket);
break;
}
int ret = connect(m_socket, (struct sockaddr *) &server_addr,
sizeof(struct sockaddr));
if (ret != -1) {
JLOGA("connect to %s:%d failed\n", server_ip.c_str(), server_port);
JLOG(FormatWSAError(WSAGetLastError()));
CLOSESOCKET(m_socket);
break;
}
TIMEVAL tm;
tm.tv_sec = 3;
tm.tv_usec = 0;
fd_set fdset;
FD_ZERO(&fdset);
FD_SET(m_socket, &fdset);
if (select(m_socket + 1, nullptr, &fdset, nullptr, &tm) <= 0) {
CLOSESOCKET(m_socket);
break;
}
int error, len;
len = sizeof(int);
getsockopt(m_socket, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
if (error != NO_ERROR) {
JLOGA("connect to %s:%d failed\n", server_ip.c_str(), server_port);
JLOG(FormatWSAError(WSAGetLastError()));
CLOSESOCKET(m_socket);
break;
}
// set the socket in blocking mode.
non_blocking_mode = 0;
result = ioctlsocket(m_socket, FIONBIO, &non_blocking_mode);
if (result != NO_ERROR) {
JLOG(_T("ioctlsocket failed : %d\n"), result);
JLOG(FormatWSAError(WSAGetLastError()));
CLOSESOCKET(m_socket);
break;
}
m_bConnectionEstablished = TRUE;
m_buff.Clear();
last_recv_time_ = COleDateTime::GetTickCount();
last_send_link_test_time_ = COleDateTime::GetTickCount();
return TRUE;
} while (0);
return FALSE;
}
int callapi(char *command, char *host, short int port)
{
char buf[RECVSIZE+1];
struct hostent *ip;
struct sockaddr_in serv;
SOCKETTYPE sock;
int ret = 0;
int n, p;
SOCKETINIT;
ip = gethostbyname(host);
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock == INVSOCK) {
printf("Socket initialisation failed: %s\n", SOCKERRMSG);
return 1;
}
memset(&serv, 0, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_addr = *((struct in_addr *)ip->h_addr);
serv.sin_port = htons(port);
if (SOCKETFAIL(connect(sock, (struct sockaddr *)&serv, sizeof(struct sockaddr)))) {
printf("Socket connect failed: %s\n", SOCKERRMSG);
return 1;
}
n = send(sock, command, strlen(command), 0);
if (SOCKETFAIL(n)) {
printf("Send failed: %s\n", SOCKERRMSG);
ret = 1;
}
else {
p = 0;
buf[0] = '\0';
while (p < RECVSIZE) {
n = recv(sock, &buf[p], RECVSIZE - p , 0);
if (SOCKETFAIL(n)) {
printf("Recv failed: %s\n", SOCKERRMSG);
ret = 1;
break;
}
if (n == 0)
break;
p += n;
buf[p] = '\0';
}
if (ONLY)
printf("%s\n", buf);
else {
printf("Reply was '%s'\n", buf);
display(buf);
}
}
CLOSESOCKET(sock);
return ret;
}
/*************************************************************************************
* *
* ConnectHost:ConnectPort transmit to TransmitHost:TransmitPort *
* *
*************************************************************************************/
void conn2conn(char *host1, int port1, char *host2, int port2) {
HANDLE hThread = NULL;
SOCKET sockfd1, sockfd2;
struct transocket sock;
DWORD dwThreadID;
fd_set fds;
long l;
char buffer[MAXSIZE];
while (1) {
while (connectnum) {
if (connectnum < CONNECTNUM) {
SLEEP(1000);
break;
} else {
SLEEP(TIMEOUT * 1000);
continue;
}
}
if ((sockfd1 = create_socket()) == 0) return;
if ((sockfd2 = create_socket()) == 0) return;
printf("[+] Make a Connection to %s:%d....\r\n", host1, port1);
fflush(stdout);
if (client_connect(sockfd1, host1, port1) == 0) {
CLOSESOCKET(sockfd1);
CLOSESOCKET(sockfd2);
SLEEP(3000);
continue;
}
// fix by bkbll
// if host1:port1 recved data, than connect to host2,port2
l = 0;
memset(buffer, 0, MAXSIZE);
while (1) {
FD_ZERO(&fds);
FD_SET(sockfd1, &fds);
if (select(sockfd1 + 1, &fds, NULL, NULL, NULL) == SOCKET_ERROR) {
if (errno == WSAEINTR) {
continue;
}
break;
}
if (FD_ISSET(sockfd1, &fds)) {
l = recv(sockfd1, buffer, MAXSIZE, 0);
break;
}
SLEEP(5);
}
if (l <= 0) {
printf("[-] There is a error...Create a new connection.\r\n");
continue;
}
printf("[+] Connect OK!\r\n");
while (1) {
printf("[+] Make a Connection to %s:%d....\r\n", host2, port2);
fflush(stdout);
if (client_connect(sockfd2, host2, port2) == 0) {
CLOSESOCKET(sockfd1);
CLOSESOCKET(sockfd2);
SLEEP(3000);
continue;
}
if (send(sockfd2, buffer, l, 0) == SOCKET_ERROR) {
printf("[-] Send failed.\r\n");
continue;
}
l = 0;
memset(buffer, 0, MAXSIZE);
break;
}
printf("[+] All Connect OK!\r\n");
sock.fd1 = sockfd1;
sock.fd2 = sockfd2;
#ifdef WIN32
if (NULL == (hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID))) {
TerminateThread(hThread, 0);
return;
}
#else
if (pthread_create((pthread_t*)&hThread, NULL, &transmitdata, (void *)&sock)) {
pthread_cancel((pthread_t)hThread);
return;
}
#endif //WIN32
++connectnum;
SLEEP(1000);
printf("[+] CreateThread OK!\r\n");
}
}
/*************************************************************************************
* *
* LocalHost:ConnectPort transmit to TransmitHost:TransmitPort *
* *
*************************************************************************************/
void bind2conn(int port1, char *host, int port2) {
SOCKET sockfd, sockfd1, sockfd2;
struct sockaddr_in remote;
struct transocket sock;
socklen_t size;
DWORD dwThreadID;
HANDLE hThread = NULL;
char buffer[1024];
if (port1 > 65535 || port1 < 1) {
printf("[-] ConnectPort invalid.\r\n");
return;
}
if (port2 > 65535 || port2 < 1) {
printf("[-] TransmitPort invalid.\r\n");
return;
}
memset(buffer, 0, 1024);
if ((sockfd = create_socket()) == INVALID_SOCKET) return;
if (create_server(sockfd, port1) == 0) {
CLOSESOCKET(sockfd);
return;
}
size = sizeof(struct sockaddr);
while (1) {
printf("[+] Waiting for Client ......\r\n");
if ((sockfd1 = accept(sockfd, (struct sockaddr *)&remote, &size)) < 0) {
printf("[-] Accept error.\r\n");
continue;
}
printf("[+] Accept a Client from %s:%d ......\r\n",
inet_ntoa(remote.sin_addr), ntohs(remote.sin_port));
if ((sockfd2 = create_socket()) == 0) {
CLOSESOCKET(sockfd1);
continue;
}
printf("[+] Make a Connection to %s:%d ......\r\n", host, port2);
fflush(stdout);
if (client_connect(sockfd2, host, port2) == 0) {
CLOSESOCKET(sockfd2);
sprintf(buffer, "[SERVER]connection to %s:%d error\r\n", host, port2);
send(sockfd1, buffer, strlen(buffer), 0);
memset(buffer, 0, 1024);
CLOSESOCKET(sockfd1);
continue;
}
printf("[+] Connect OK!\r\n");
sock.fd1 = sockfd1;
sock.fd2 = sockfd2;
#ifdef WIN32
if (NULL == (hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transmitdata, (LPVOID)&sock, 0, &dwThreadID))) {
TerminateThread(hThread, 0);
return;
}
#else
if (pthread_create((pthread_t*)&hThread, NULL, &transmitdata, (void *)&sock)) {
pthread_cancel((pthread_t)hThread);
return;
}
#endif //WIN32
SLEEP(1000);
printf("[+] CreateThread OK!\r\n\n");
}
}