/* It opens a connection to the host name rhost that is listening
on the specified port. It returns the socket descriptor, or -1
in case of failure.
*/
static int clientsocket(const char *rhost, unsigned short port)
{
struct hostent *ptrh; /* pointer to a host table entry */
struct sockaddr_in sad;/* structure to hold server's address*/
int fd; /* socket descriptor */
memset((char *)&sad, 0, sizeof(sad)); /* clear sockaddr structure */
sad.sin_family = AF_INET; /* set family to Internet */
sad.sin_port = htons((u_short)port);
/* Convert host name to equivalent IP address and copy sad */
ptrh = net_gethostbyname(rhost);
if (((char *)ptrh) == NULL) {
fprintf(stderr, "invalid host: %s\n", rhost);
return (-1);
}
memcpy(&sad.sin_addr, ptrh->h_addr, ptrh->h_length);
/* Create a socket */
fd = net_socket(PF_INET, SOCK_STREAM, 0);
if (fd < 0) {
fprintf(stderr, "socket creation failed\n");
return (-1);;
}
/* Connect the socket to the specified server */
if (net_connect(fd, (struct sockaddr *)&sad, sizeof(sad)) < 0) {
fprintf(stderr, "connect failed\n");
return (-1);
}
return fd;
}
static s32 tcp_socket(void)
{
s32 s, res;
s = net_socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
if (s < 0)
return s;
if(split_res == 2){
return s;
}
res = net_fcntl(s, F_GETFL, 0);
if (res < 0)
{
net_close(s);
return res;
}
res = net_fcntl(s, F_SETFL, res | IOS_O_NONBLOCK);
if (res < 0)
{
net_close(s);
return res;
}
return s;
}
s32 create_server(u16 port) {
s32 server = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if (server < 0)
return -1;
set_blocking(server, false);
struct sockaddr_in bindAddress;
memset(&bindAddress, 0, sizeof(bindAddress));
bindAddress.sin_family = AF_INET;
bindAddress.sin_port = htons(port);
bindAddress.sin_addr.s_addr = htonl(INADDR_ANY);
s32 ret;
if ((ret = net_bind(server, (struct sockaddr *)&bindAddress, sizeof(bindAddress))) < 0) {
net_close(server);
gxprintf("Error binding socket: [%i] %s\n", -ret, strerror(-ret));
return ret;
}
if ((ret = net_listen(server, 3)) < 0) {
net_close(server);
gxprintf("Error listening on socket: [%i] %s\n", -ret, strerror(-ret));
return ret;
}
return server;
}
int32_t SocketInit(int &sockDesc)
{
#ifdef __GNUWIN32__
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0)
{
return 0;
}
#endif
#ifdef __NDS__
if ( !Wifi_InitDefault(WFC_CONNECT) )
{
return 0;
}
if ( (sockDesc = socket(AF_INET, SOCK_STREAM, 0)) < 0 )
{
return 0;
}
#elif defined (__GAMECUBE__) || defined (__WII__)
if ( (sockDesc = net_socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0 )
{
return 0;
}
#else
if ( (sockDesc = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0 )
{
return 0;
}
#endif
return 1;
}
NSAPI_PUBLIC SYS_NETFD INTnet_create_listener_alt(const char *ipstr, int port, PRBool internal)
{
SYS_NETFD sd;
struct sockaddr_in sa_server;
if (PR_TRUE == internal)
{
// internal listen sockets are always created without SSL
sd = INTnet_socket_alt(AF_INET,SOCK_STREAM,IPPROTO_TCP);
}
else
{
// otherwise the socket may be SSL
sd = net_socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
};
if (sd == SYS_NET_ERRORFD)
{
return SYS_NET_ERRORFD;
};
ZERO((char *) &sa_server, sizeof(sa_server));
sa_server.sin_family=AF_INET;
sa_server.sin_addr.s_addr = (ipstr ? inet_addr(ipstr) : htonl(INADDR_ANY));
sa_server.sin_port=htons(port);
if(net_bind(sd, (struct sockaddr *) &sa_server,sizeof(sa_server)) < 0) {
return SYS_NET_ERRORFD;
}
net_listen(sd, net_listenqsize);
return sd;
}
s32 tcp_socket (void) {
s32 s, res;
s = net_socket (PF_INET, SOCK_STREAM, 0);
if (s < 0) {
printDebugMsg(NORMAL_DEBUG_MESSAGE,"net_socket failed: %d\n", s);
return s;
}
res = net_fcntl (s, F_GETFL, 0);
if (res < 0) {
printDebugMsg(NORMAL_DEBUG_MESSAGE,"F_GETFL failed: %d\n", res);
net_close (s);
return res;
}
res = net_fcntl (s, F_SETFL, res | 4);
if (res < 0) {
printDebugMsg(NORMAL_DEBUG_MESSAGE,"F_SETFL failed: %d\n", res);
net_close (s);
return res;
}
return s;
}
s32 tcp_socket (void) {
s32 s, res;
s = net_socket (PF_INET, SOCK_STREAM, 0);
if (s < 0) {
printf ("net_socket failed: %d\n", s);
return s;
}
res = net_fcntl (s, F_GETFL, 0);
if (res < 0) {
printf ("F_GETFL failed: %d\n", res);
net_close (s);
return res;
}
res = net_fcntl (s, F_SETFL, res | 4);
if (res < 0) {
printf ("F_SETFL failed: %d\n", res);
net_close (s);
return res;
}
return s;
}
s32 ConnectSocket(const char *hostname, u32 port)
{
s32 socket = 0;
struct sockaddr_in connect_addr;
if ( (socket = net_socket(AF_INET,SOCK_STREAM,IPPROTO_IP)) < 0)
{
return -1;
}
else
{
//resolving hostname
struct hostent *host = 0;
host = net_gethostbyname(hostname);
if ( host == NULL )
{
//resolving failed
return -2;
}
else
{
connect_addr.sin_family = AF_INET;
connect_addr.sin_port = port;
memcpy(&connect_addr.sin_addr, host->h_addr_list[0], host->h_length);
}
}
if (net_connect(socket, (struct sockaddr*)&connect_addr , sizeof(connect_addr)) == -1 )
{
net_close(socket);
return -3;
}
return socket;
}
static s32 tcp_socket(void)
{
s32 s, res;
s = net_socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
if (s < 0)
return s;
// Switch off Nagle with TCP_NODELAY
u32 nodelay = 1;
net_setsockopt(s,IPPROTO_TCP,TCP_NODELAY,&nodelay,sizeof(nodelay));
res = net_fcntl(s, F_GETFL, 0);
if (res < 0)
{
net_close(s);
return res;
}
res = net_fcntl(s, F_SETFL, res | IOS_O_NONBLOCK);
if (res < 0)
{
net_close(s);
return res;
}
return s;
}
int WifiGecko_Connect()
{
return -1;
if(connection >= 0)
return connection;
net_init();
connection = net_socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
if (connection < 0)
return connection;
struct sockaddr_in connect_addr;
memset(&connect_addr, 0, sizeof(connect_addr));
connect_addr.sin_family = AF_INET;
connect_addr.sin_port = htons(portnumber);
inet_aton(ipaddress, &connect_addr.sin_addr);
if(net_connect(connection, (struct sockaddr*)&connect_addr, sizeof(connect_addr)) < 0)
{
WifiGecko_Close();
return -1;
}
return connection;
}
static Socket new_listening_TCP_socket(int family, uint16_t port)
{
Socket sock = net_socket(family, TOX_SOCK_STREAM, TOX_PROTO_TCP);
if (!sock_valid(sock)) {
return ~0;
}
int ok = set_socket_nonblock(sock);
if (ok && family == AF_INET6) {
ok = set_socket_dualstack(sock);
}
if (ok) {
ok = set_socket_reuseaddr(sock);
}
ok = ok && bind_to_port(sock, family, port) && (listen(sock, TCP_MAX_BACKLOG) == 0);
if (!ok) {
kill_sock(sock);
return ~0;
}
return sock;
}
void network_init()
{
struct sockaddr_in my_name;
my_name.sin_family = AF_INET;
my_name.sin_port = htons(SERVER_PORT);
my_name.sin_addr.s_addr = htonl(INADDR_ANY);
net_init();
server_socket = net_socket(AF_INET, SOCK_STREAM, 0);
int yes = 1;
net_setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
while(net_bind(server_socket, (struct sockaddr*)&my_name, sizeof(my_name)) < 0)
{
}
net_listen(server_socket, 0);
struct sockaddr_in client_info;
socklen_t ssize = sizeof(client_info);
client_socket = net_accept(server_socket, (struct sockaddr*)&client_info, &ssize);
network_printf("Hello world!\n");
}
s32 Network_Connect(void) {
struct hostent *he;
struct sockaddr_in sa;
s32 ret;
/* Close socket if it is already open */
if (sockfd >= 0) net_close(sockfd);
/* Create socket */
sockfd = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if (sockfd < 0) return sockfd;
/* Get host by name */
he = net_gethostbyname(NusHostname);
if (!he) return -1;
/* Setup socket */
memcpy(&sa.sin_addr, he->h_addr_list[0], he->h_length);
sa.sin_family = AF_INET;
sa.sin_port = htons(NusPort);
ret = net_connect(sockfd, (struct sockaddr *) &sa, sizeof(sa));
if (ret < 0) return ret;
return 0;
}
/****************************************************************************
* NetworkWait
***************************************************************************/
int NetworkWait() {
if (!checkincomming)
return -3;
struct sockaddr_in sin;
struct sockaddr_in client_address;
socklen_t addrlen = sizeof(client_address);
//Open socket
socket = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if (socket == INVALID_SOCKET) {
return socket;
}
sin.sin_family = AF_INET;
sin.sin_port = htons(PORT);
sin.sin_addr.s_addr = htonl(INADDR_ANY);
if (net_bind(socket, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
net_close(socket);
return -1;
}
if (net_listen(socket, 3) < 0) {
net_close(socket);
return -1;
}
connection = net_accept(socket, (struct sockaddr*)&client_address, &addrlen);
sprintf(incommingIP, "%s", inet_ntoa(client_address.sin_addr));
if (connection < 0) {
net_close(connection);
net_close(socket);
return -4;
} else {
unsigned char haxx[9];
//skip haxx
net_read(connection, &haxx, 8);
wiiloadVersion[0] = haxx[4];
wiiloadVersion[1] = haxx[5];
net_read(connection, &infilesize, 4);
if (haxx[4] > 0 || haxx[5] > 4) {
net_read(connection, &uncfilesize, 4); // Compressed protocol, read another 4 bytes
}
waitforanswer = true;
checkincomming = false;
networkHalt = true;
}
return 1;
}
int net_bind(
const char name[],
const char addr[],
const char port[],
const char ifce[],
int protocol, int af
) {
char addrbuf[FULL_ADDSTRLEN+1];
const int opt_on = 1;
int sock;
socklen_t addrlen;
IP sockaddr;
if( af == AF_INET ) {
addrlen = sizeof(IP4);
} else if( af == AF_INET6 ) {
addrlen = sizeof(IP6);
} else {
log_err( "%s: Unknown address family value.", name );
return -1;
}
if( addr_parse( &sockaddr, addr, port, af ) != 0 ) {
log_err( "%s: Failed to parse IP address '%s' and port '%s'.", name, addr, port );
return -1;
}
if( (sock = net_socket( name, ifce, protocol, af )) < 0 ) {
return -1;
}
if( af == AF_INET6 ) {
if( setsockopt( sock, IPPROTO_IPV6, IPV6_V6ONLY, &opt_on, sizeof(opt_on) ) < 0 ) {
close( sock );
log_err( "%s: Failed to set socket option IPV6_V6ONLY: %s", name, strerror( errno ));
return -1;
}
}
if( bind( sock, (struct sockaddr*) &sockaddr, addrlen ) < 0 ) {
close( sock );
log_err( "%s: Failed to bind socket to address: '%s'", name, strerror( errno ) );
return -1;
}
if( protocol == IPPROTO_TCP && listen( sock, 5 ) < 0 ) {
close( sock );
log_err( "%s: Failed to listen on socket: '%s'", name, strerror( errno ) );
return -1;
}
log_info( ifce ? "%s: Bind to %s, interface %s" : "%s: Bind to %s",
name, str_addr( &sockaddr, addrbuf ), ifce
);
return sock;
}
/****************************************************************************
* Test if connection to the address is available (PING)
***************************************************************************/
bool CheckConnection(const char *url, float timeout)
{
//Check if the url starts with "http://", if not it is not considered a valid url
if (strncmp(url, "http://", strlen("http://")) != 0)
return false;
//Locate the path part of the url by searching for '/' past "http://"
char *path = strchr(url + strlen("http://"), '/');
//At the very least the url has to end with '/', ending with just a domain is invalid
if (path == NULL)
return false;
//Extract the domain part out of the url
int domainlength = path - url - strlen("http://");
if (domainlength == 0)
return false;
char domain[domainlength + 1];
strlcpy(domain, url + strlen("http://"), domainlength + 1);
//Parsing of the URL is done, start making an actual connection
u32 ipaddress = getipbynamecached(domain);
if (ipaddress == 0)
return false;
//Initialize socket
s32 connection = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if (connection < 0) return connection;
s32 flags = net_fcntl(connection, F_GETFL, 0);
if (flags >= 0) flags = net_fcntl(connection, F_SETFL, flags | 4);
struct sockaddr_in connect_addr;
memset(&connect_addr, 0, sizeof(connect_addr));
connect_addr.sin_family = AF_INET;
connect_addr.sin_port = 80;
connect_addr.sin_addr.s_addr = getipbynamecached(domain);
Timer netTime;
int res = -1;
while(res < 0 && res != -127 && netTime.elapsed() < timeout)
{
res = net_connect(connection, (struct sockaddr*) &connect_addr, sizeof(connect_addr));
usleep(1000);
}
net_close(connection);
return !(res < 0 && res != -127);
}
int WaitForConnection(int& server_socket)
{
int addrlen;
struct sockaddr_in my_name, peer_name;
int status;
server_socket = net_socket(AF_INET, SOCK_STREAM, 0);
if (server_socket == -1)
{
printf("Failed to create server socket\n");
}
int yes = 1;
net_setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
memset(&my_name, 0, sizeof(my_name));
my_name.sin_family = AF_INET;
my_name.sin_port = htons(DFF_CONN_PORT);
my_name.sin_addr.s_addr = htonl(INADDR_ANY);
status = net_bind(server_socket, (struct sockaddr*)&my_name, sizeof(my_name));
if (status == -1)
{
printf("Failed to bind server socket\n");
}
status = net_listen(server_socket, 5); // TODO: Change second parameter..
if (status == -1)
{
printf("Failed to listen on server socket\n");
}
printf("Listening now!\n");
int client_socket = -1;
struct sockaddr_in client_info;
socklen_t ssize = sizeof(client_info);
int new_socket = net_accept(server_socket, (struct sockaddr*)&client_info, &ssize);
if (new_socket < 0)
{
printf("accept failed!\n");
}
else
{
client_socket = new_socket;
printf("accept succeeded and returned %d\n", client_socket);
}
return client_socket;
}
static int32_t init_http_socket( struct CSession_t *pThis, const CSessionParam *pSessionParam )
{
int32_t iRetCode = -1;
CSocket *pTCPSocket = NULL;
if ( pThis->pSocket )
{
iRetCode = 0;
return iRetCode;
}
pTCPSocket = net_socket( SOCKET_TYPE_STREAM, 0 );
if ( pTCPSocket )
{
CNetAddr addr;
char tempBuf[1024] = { 0x00, };
int32_t iLen = 0;
memset( &addr, 0x00, sizeof(addr) );
memcpy( addr.pIP, pSessionParam->pIP, strlen(pSessionParam->pIP) );
addr.iPort = pSessionParam->iPort;
if ( net_connect( pTCPSocket, &addr ) >= 0 )
{
if ( add_reactor_socket( pThis->pOwnerReactor, pTCPSocket, pThis ) >= 0 )
{
if ( net_set_socket( pTCPSocket, SOCKET_OPTION_NONE_BLOCK, NULL, 0 ) >= 0 )
{
pThis->pSocket = pTCPSocket;
iRetCode = 0;
}
else
log_print( "set none blocking socket failed???????????????" );
}
else
log_print( "add reactor socket failed???????????????????" );
}
else
log_print( "connect failed????????????????" );
}
else
log_print( "create tcp socket failed???????????????????????" );
return iRetCode;
}
/**
* Connect to a remote server via TCP on a specified port
*
* @param u32 ip address of the server to connect to
* @param u32 the port to connect to on the server
* @return s32 The connection to the server (negative number if connection could not be established)
*/
static s32 server_connect(u32 ipaddress, u32 socket_port) {
//Initialize socket
s32 connection = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if (connection < 0) return connection;
struct sockaddr_in connect_addr;
memset(&connect_addr, 0, sizeof(connect_addr));
connect_addr.sin_family = AF_INET;
connect_addr.sin_port = socket_port;
connect_addr.sin_addr.s_addr= ipaddress;
//Attemt to open the socket
if (net_connect(connection, (struct sockaddr*)&connect_addr, sizeof(connect_addr)) == -1) {
net_close(connection);
return -1;
}
return connection;
}
void
NetworkConsole::Init()
{
printf("Initializing Network\n");
int Connect = net_init();
if(Connect != 0)
{
printf("Net_Init() failed.\n");
}
else
{
printf("Net_Init() successful.\n\n");
printf("Net_Socket Initializing.\n");
Data->netSocket = net_socket(AF_INET, SOCK_DGRAM, 0);
if(Data->netSocket == INVALID_SOCKET)
{
printf("Net_Socket Initialization failed.\n");
}
else
{
printf("Net_Socket Initialized.\n\n");
printf("Establishing server on port %d.\n",MULTICAST_PORT);
Data->sin.sin_port=htons(MULTICAST_PORT);
Data->sin.sin_addr.s_addr=inet_addr(MULTICAST_GROUP);//replace with multicast destination
Data->sin.sin_family=AF_INET;
if(net_bind(Data->netSocket,(sockaddr*)&(Data->sin), sizeof(Data->sin)) == SOCKET_ERROR)
{
printf("Failed to bind.\n");
}
else
{
printf("Server established!\n");
if(net_connect(Data->netSocket,(sockaddr*)&(Data->sin), sizeof(Data->sin))==-1)
{
printf("net_connect Error\n");
}
}
}
}
}
static s32 helper_setup_socket( u16 port)
{
s32 sock;
int ret;
//u32 clientlen;
struct sockaddr_in server;
struct sockaddr_in client;
//clientlen = sizeof(client);
sock = net_socket (AF_INET, SOCK_STREAM, IPPROTO_IP);
if (sock == INVALID_SOCKET) {
printf( "setup():INVALID_SOCKET\n");
return -1;
}
memset (&server, 0, sizeof (server));
memset (&client, 0, sizeof (client));
server.sin_family = AF_INET;
server.sin_port = htons (port);
server.sin_addr.s_addr = INADDR_ANY;
ret = net_bind (sock, (struct sockaddr *) &server, sizeof (server));
if ( ret ) {
printf( "net_bind():INVALID_SOCKET\n");
net_close( sock);
return -1;
}
if ( (ret = net_listen( sock, 1)) ) {
printf( "net_listen():INVALID_SOCKET\n");
net_close( sock);
return -1;
}
#if 0
ret = setNonblocking(sock);
printf( "setNonblocking(%d) returns=%d.\n", sock, ret);
#endif
return sock;
}
/*
* The function net_connect() create the socket and connects it to the
* address specified by node:service pair. If node is NULL, then the network
* address will be set to the loopback interface address.
*
* If the node/servise name resolution, socket creation and connection
* succeeds, socket is returned. On error, negative error code is returned.
*/
int net_connect (int type, const char *node, const char *service)
{
struct addrinfo *res;
int s, saved_errno;
/* using first resource record element... */
if ((s = net_socket (type, node, service, &res, 0)) < 0)
return s;
if (connect (s, res->ai_addr, res->ai_addrlen) == -1) {
saved_errno = errno;
freeaddrinfo (res);
close (s);
return -saved_errno;
}
freeaddrinfo (res);
return s;
}
bool ClientSocket::Connect(const std::string& serverName, int port)
{
AMJU_CALL_STACK;
struct sockaddr_in sa;
struct hostent *hp;
#ifdef GEKKO
hp = net_gethostbyname(serverName.c_str());
#else
hp = gethostbyname(serverName.c_str());
#endif
if (!hp)
{
return false;
}
memset(&sa,0,sizeof(sa));
memcpy((char *)&sa.sin_addr,hp->h_addr,hp->h_length);
sa.sin_family= hp->h_addrtype;
sa.sin_port= htons((u_short)port);
#ifdef GEKKO
if ((m_socket = net_socket(hp->h_addrtype,SOCK_STREAM,0)) < 0)
#else
if ((m_socket = socket(hp->h_addrtype,SOCK_STREAM,0)) < 0)
#endif
{
return false;
}
#ifdef GEKKO
if (net_connect(m_socket,(struct sockaddr *)&sa,sizeof sa) < 0)
#else
if (connect(m_socket,(struct sockaddr *)&sa,sizeof sa) < 0)
#endif
{
return false;
}
return true;
}
int create_send_socket( void ) {
int sock_send;
sock_send = net_socket( "LPD", gconf->dht_ifce, IPPROTO_UDP, gconf->af );
if( multicast_set_ttl( sock_send, gconf->af, 1 ) < 0 ) {
log_err( "LPD: Failed to set IP_MULTICAST_TTL for sending socket: %s", strerror( errno ));
goto fail;
}
if( multicast_set_loop( sock_send, gconf->af, 0 ) < 0 ) {
log_warn( "LPD: Failed to set IP_MULTICAST_LOOP: %s", strerror( errno ) );
goto fail;
}
return sock_send;
fail:
close( sock_send );
return -1;
}
/**
* Connect to a remote server via TCP on a specified port
*
* @param u32 ip address of the server to connect to
* @param u32 the port to connect to on the server
* @return s32 The connection to the server (negative number if connection could not be established)
*/
static s32 tcp_connect(u32 ipaddress, u16 socket_port)
{
//Initialize socket
s32 connection = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if (connection < 0) return connection;
struct sockaddr_in connect_addr;
memset(&connect_addr, 0, sizeof(connect_addr));
connect_addr.sin_family = AF_INET;
connect_addr.sin_port = htons(socket_port);
connect_addr.sin_addr.s_addr = ipaddress;
sprintf(incommingIP, "%s", inet_ntoa(connect_addr.sin_addr));
//Attempt to open the socket
if (net_connect(connection, (struct sockaddr*) &connect_addr, sizeof(connect_addr)) == -1)
{
net_close(connection);
return -1;
}
return connection;
}
s32 tcp_socket (void) {
s32 s, res;
s = net_socket (PF_INET, SOCK_STREAM, 0);
if (s < 0) {
return s;
}
res = net_fcntl (s, F_GETFL, 0);
if (res < 0) {
net_close (s);
return res;
}
res = net_fcntl (s, F_SETFL, res | 4);
if (res < 0) {
net_close (s);
return res;
}
return s;
}
int WifiGecko_Connect()
{
if(connection >= 0)
return connection;
connection = net_socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
if (connection < 0)
return connection;
struct sockaddr_in connect_addr;
memset(&connect_addr, 0, sizeof(connect_addr));
connect_addr.sin_family = AF_INET;
connect_addr.sin_port = htons(DESTINATION_PORT);
inet_aton(DESTINATION_IP, &connect_addr.sin_addr);
if(net_connect(connection, (struct sockaddr*)&connect_addr, sizeof(connect_addr)) < 0)
{
WifiGecko_Close();
return -1;
}
return connection;
}
s32 tcp_socket (void) {
s32 s, res;
s = net_socket (PF_INET, SOCK_STREAM, 0);
if (s < 0) return s;
if(http_port == 80)
{
res = net_fcntl (s, F_GETFL, 0);
if (res < 0) {
net_close (s);
return res;
}
//set non-blocking
res = net_fcntl (s, F_SETFL, res | 4);
if (res < 0) {
net_close (s);
return res;
}
}
return s;
}
int InitNetwork(NET_STATE* ref)
{
int ret, result;
ret = if_config(ref->localip, ref->netmask, ref->gateway, TRUE);
if (ret < 0) {
return -1;
}
ref->socket = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if (ref->socket == INVALID_SOCKET) {
return -1;
}
memset(&ref->sockAddr, 0, sizeof(ref->sockAddr));
ref->sockAddr.sin_family = AF_INET;
ref->sockAddr.sin_port = htons(NETWORK_PORT_A);
ref->sockAddr.sin_addr.s_addr = inet_addr(HOST_IP);
/*
getaddrinfo(HOST_NAME, STR(HOST_IP), NULL, &addrinfo);
*/
result = net_connect(ref->socket, (struct sockaddr *)&ref->sockAddr, sizeof(ref->sockAddr));
if (result == -1) {
net_close(ref->socket);
return -1;
}
if (LWP_CreateThread(&ref->thread_handle, NetworkThread, (void*)ref, NULL, 256*1024, 60) < 0)
{
ref->threadTerminated = 1;
return -1;
}
return 0;
}
int main( int argc, char **argv )
{
int32_t iRetCode = -1;
CReactor *iUDPReactorId = NULL;
int8_t pLocalIP[32] = "225.0.0.37";
CThread *acceptTid = NULL;
enable_log( 1 );
set_log( LOG_TYPE_CONSOLE, NULL, 0 );
if ( strlen( pLocalIP ) <= 0 )
if ( net_get_local_ip( pLocalIP, sizeof( pLocalIP ) ) < 0 )
return iRetCode;
log_print( "%s %s:%d local ip-->%s\r\n", __FILE__, __FUNCTION__, __LINE__, pLocalIP );
if ( init_pine_system( ) < 0 )
return iRetCode;
iUDPReactorId = net_reactor( );
if ( iUDPReactorId )
{
if ( register_reactor_callback( iUDPReactorId, udp_reactor_callback, NULL ) < 0 )
{
log_print( "%s %s:%d register reactor callback failed???????????\r\n", __FILE__, __FUNCTION__, __LINE__ );
return iRetCode;
}
iUDPClientSocketId = net_socket( SOCKET_TYPE_DGRAM, 0 );
if ( iUDPClientSocketId )
{
CNetAddr addr, stLocalAddr;
char tempBuf[1024] = { 0x00, };
int32_t iLen = 0;
memset( &addr, 0x00, sizeof(addr) );
memset( &stLocalAddr, 0x00, sizeof(stLocalAddr) );
memcpy( addr.pIP, pLocalIP, strlen(pLocalIP) );
addr.iPort = LOCAL_PORT;
memcpy( stLocalAddr.pIP, pLocalIP, strlen(pLocalIP) );
stLocalAddr.iPort = LOCAL_PORT + 1;
if ( net_bind( iUDPClientSocketId, &stLocalAddr ) < 0 )
{
log_print( "%s %s:%d socket bind failed???????????\r\n", __FILE__, __FUNCTION__, __LINE__ );
return iRetCode;
}
else
log_print( "bind ok.............." );
if ( net_connect( iUDPClientSocketId, &addr ) < 0 )
{
log_print( "%s %s:%d socket connect failed???????????\r\n", __FILE__, __FUNCTION__, __LINE__ );
return iRetCode;
}
else
log_print( "connect ok.............." );
if ( add_reactor_socket( iUDPReactorId, iUDPClientSocketId, NULL ) < 0 )
{
log_print( "%s %s:%d set add reactor socket failed???????????\r\n", __FILE__, __FUNCTION__, __LINE__ );
return iRetCode;
}
else
log_print( "add reactor socket ok................." );
if ( net_set_socket( iUDPClientSocketId, SOCKET_OPTION_NONE_BLOCK, NULL, 0 ) < 0 )
{
log_print( "%s %s:%d set socket none block failed???????????\r\n", __FILE__, __FUNCTION__, __LINE__ );
return iRetCode;
}
else
log_print( "set socket none blocking ok....................." );
log_print( "multicast client is running.............." );
while ( fgets(tempBuf, sizeof(tempBuf), stdin) )
{
int32_t iOpRet = net_sendto( iUDPClientSocketId, tempBuf, strlen(tempBuf) + 1, &addr );
log_print( "udp client: iOpRet->%d", iOpRet );
}
}
}
while ( 1 )
os_sleep( 1000 );
net_close_reactor( iUDPReactorId );
return 0;
}
