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;
}
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;
}
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;
}
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;
}
static s32 setNonblocking(s32 fd)
{
s32 flags;
/* Fixme: O_NONBLOCK is defined but broken on SunOS 4.1.x and AIX 3.2.5. */
if (-1 == (flags = net_fcntl(fd, F_GETFL, 0)))
flags = 0;
return net_fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}
/****************************************************************************
* 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);
}
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;
}
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;
}
s32 set_blocking(s32 s, bool blocking) {
s32 flags;
flags = net_fcntl(s, F_GETFL, 0);
if (flags >= 0) flags = net_fcntl(s, F_SETFL, blocking ? (flags&~4) : (flags|4));
return flags;
}
bool NetReceiver::CheckIncomming()
{
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 false;
}
sin.sin_family = AF_INET;
sin.sin_port = htons(PORT);
sin.sin_addr.s_addr = htonl(INADDR_ANY);
int flags = net_fcntl(socket, F_GETFL, 0);
flags = net_fcntl(socket, F_SETFL, flags | 4);
if (net_bind(socket, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
net_close(socket);
return false;
}
if (net_listen(socket, 10) < 0) {
net_close(socket);
return false;
}
Timer CTimer;
do
{
connection = net_accept(socket, (struct sockaddr*)&client_address, &addrlen);
if(connection >= 0)
break;
}
while(CTimer.elapsed() < 1.0f);
sprintf(incommingIP, "%s", inet_ntoa(client_address.sin_addr));
if (connection < 0)
{
net_close(socket);
return false;
}
else
{
unsigned char haxx[9];
//skip haxx
net_read(connection, &haxx, 8);
if (memcmp(haxx, "HAXX", 4) != 0) // unsupported protocol
{
net_close(connection);
net_close(socket);
return false;
}
wiiloadVersion[0] = haxx[4];
wiiloadVersion[1] = haxx[5];
net_read(connection, &filesize, 4);
if (haxx[4] > 0 || haxx[5] > 4)
net_read(connection, &uncfilesize, 4); // Compressed protocol, read another 4 bytes
}
return true;
}
static bool StartWiiLoadServer (void)
{
struct sockaddr_in sin;
struct sockaddr_in client_address;
s32 connection;
int err;
if ( wiiload.status == WIILOAD_HBREADY || wiiload.status == WIILOAD_HBZREADY)
{
// This isn't an error, simply we have received valid data. Host process should set hbready mode to IDLE or stop/restart the thread
return true;
}
// Clean old data, if any
if (wiiload.args) free (wiiload.args);
wiiload.args = NULL;
wiiload.argl = 0;
printopt ("StartWiiLoadServer begin");
socklen_t addrlen = sizeof(client_address);
//Open socket
socket = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if (socket == INVALID_SOCKET)
{
printopt ("net_socket INVALID_SOCKET");
return false;
}
int one = 1;
err = net_setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (const char *)&one, sizeof(one));
if (err < 0)
{
printopt ("net_setsockopt %d");
return false;
}
sin.sin_family = AF_INET;
sin.sin_port = htons(PORT);
sin.sin_addr.s_addr = htonl(INADDR_ANY);
int flags = net_fcntl(socket, F_GETFL, 0);
flags = net_fcntl(socket, F_SETFL, flags|4); // Set non blocking
err = net_bind(socket, (struct sockaddr*)&sin, sizeof(sin));
if (err < 0)
{
printopt ("net_bind error %d", err);
net_close(socket);
return false;
}
if (net_listen(socket, 10) < 0)
{
printopt ("net_listen error");
net_close(socket);
return false;
}
printopt ("net_accept");
// WIILOAD_IDLE is set once. This because if an hb is executed it make no sense....
// Maybe it can be usefull for an app is an hb is rejected. Hosting appl. can set it by itsel
wiiload.status = WIILOAD_IDLE;
do
{
int i;
for (i = 0; i < 10; i++)
{
usleep (50000);
if (pauseWiiload) break;
}
if (pauseWiiload)
{
Debug ("WiiLoad thread paused");
pauseWiiload = 2;
do
{
usleep (250*1000);
}
while (pauseWiiload && !stopNetworkThread);
Debug ("WiiLoad thread resumed");
pauseWiiload = 0;
}
connection = net_accept(socket, (struct sockaddr*)&client_address, &addrlen);
if (connection >= 0)
{
sprintf(wiiload.op, "%s", inet_ntoa(client_address.sin_addr));
if (!WiiLoad (connection))
{
wiiload.status = WIILOAD_IDLE;
}
net_close(connection);
}
usleep (100);
}
while (!stopNetworkThread);
net_close(socket);
return true;
}
