/*-------------------------------------------------------------------------------------*/
Socket tcp_wait_for_connection( Socket socket )
/*-------------------------------------------------------------------------------------*/
{
// parameter check
check_socket_ptr("tcp_wait_for_connection() failed", socket);
MySocket *serv = (MySocket *)socket;
MySocket *clie = (MySocket *)malloc( sizeof(MySocket) );
if ( clie == NULL )
die("tcp_wait_for_connection() failed: mem alloc error");
struct sockaddr_in addr;
unsigned int length = sizeof(struct sockaddr_in);
char *p;
check_sd("tcp_wait_for_connection() failed", serv->sd);
clie->sd = accept(serv->sd, (struct sockaddr*) &addr, &length);
check_sd("tcp_wait_for_connection() failed: accept() error", clie->sd);
p = inet_ntoa(addr.sin_addr); //returns addr to statically allocated buffer
clie->ip_addr = (char *)malloc( sizeof(char)*CHAR_IP_ADDR_LENGTH);
if ( clie->ip_addr == NULL )
die("tcp_wait_for_connection failed(): mem alloc error");
clie->ip_addr = strcpy( clie->ip_addr, p );
clie->port = ntohs(addr.sin_port);
return (Socket)clie;
}
/*-------------------------------------------------------------------------------------*/
Socket tcp_passive_open(int port)
/*-------------------------------------------------------------------------------------*/
{
// parameter check
check_port("tcp_open_server() failed", port);
MySocket *s = (MySocket *)malloc( sizeof(MySocket) );
if ( s == NULL )
die("tcp_open__socket() failed: mem alloc error");
struct sockaddr_in addr;
s->sd = socket(PROTOCOLFAMILY, TYPE, PROTOCOL);
check_sd("tcp_open_server failed(): socket creation error", s->sd);
/* Construct the server address structure */
memset(&addr, 0, sizeof(struct sockaddr_in));
addr.sin_family = PROTOCOLFAMILY;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(port);
if ( bind(s->sd, (struct sockaddr *)&addr, sizeof(addr)) != 0 ) {
die("tcp_open_server failed(): bind() failed"); //will fail if e.g; port is in use
}
if( listen(s->sd, MAX_PENDING) != 0 )
die("tcp_open_server failed(): listen() failed");
s->port = port;
s->ip_addr = NULL; //INADDR_ANY ...
return (Socket)s;
}
/*-------------------------------------------------------------------------------------*/
void tcp_send(Socket socket, void *buffer, int bufsize )
/*-------------------------------------------------------------------------------------*/
{
// parameter check
check_socket_ptr("tcp_send() failed", socket);
if ( buffer == NULL )
die("tcp_send failed(): buffer param is NULL");
MySocket *s = (MySocket *)socket;
int result;
int sen = 0;
int to_sen = bufsize;
check_sd("tcp_send() failed", s->sd);
do {
result = send(s->sd, (const void*) (buffer+sen), to_sen, 0);
if (result < 0)
die("tcp_send() failed: not able to send");
sen += result;
to_sen -= result;
} while ( to_sen > 0 );
}
/*-------------------------------------------------------------------------------------*/
int get_socket_descriptor( Socket socket )
/*-------------------------------------------------------------------------------------*/
{
// parameter check
check_socket_ptr("get_socket_descriptor() failed", socket);
MySocket *s = (MySocket *)socket;
check_sd("get_socket_descriptor() failed", s->sd);
return s->sd;
}
/*-------------------------------------------------------------------------------------*/
Socket tcp_active_open( int remote_port, char *remote_ip )
/*-------------------------------------------------------------------------------------*/
{
// parameter check
check_port("tcp_open_client() failed", remote_port);
check_ip_addr("tcp_open_client() failed", remote_ip);
MySocket *client = (MySocket *)malloc( sizeof(MySocket) );
if ( client == NULL )
die("tcp_open_client() failed: mem alloc error");
struct sockaddr_in addr;
int length;
char *p;
client->sd = socket(PROTOCOLFAMILY, TYPE, PROTOCOL);
check_sd("tcp_open_client() failed: socket creation error", client->sd);
/* Construct the server address structure */
memset(&addr, 0, sizeof(struct sockaddr_in));
addr.sin_family = PROTOCOLFAMILY;
if ( inet_aton(remote_ip, (struct in_addr *) &addr.sin_addr.s_addr) == 0 )
die("tcp_open_client failed(): invalid ip address");
addr.sin_port = htons(remote_port);
if ( connect(client->sd, (struct sockaddr *) &addr, sizeof(addr) ) < 0 )
die("tcp_open_client failed(): connect () failed");
memset(&addr, 0, sizeof(struct sockaddr_in));
length = sizeof(addr);
if ( getsockname(client->sd, (struct sockaddr *)&addr, (socklen_t *)&length) != 0 )
die("tcp_open_client failed(): getsockname() failed");
p = inet_ntoa(addr.sin_addr); //returns addr to statically allocated buffer
client->ip_addr = (char *)malloc( sizeof(char)*CHAR_IP_ADDR_LENGTH);
if ( client->ip_addr == NULL )
die("tcp_open_client failed(): mem alloc error");
client->ip_addr = strcpy( client->ip_addr, p );
client->port = ntohs(addr.sin_port);
return (Socket)client;
}
/*-------------------------------------------------------------------------------------*/
int tcp_receive (Socket socket, void* buffer, int bufsize)
/*-------------------------------------------------------------------------------------*/
{
// parameter check
check_socket_ptr("tcp_receive() failed", socket);
if ( buffer == NULL )
die("tcp_receive() failed: buffer param is NULL");
if ( bufsize == 0 )
die("tcp_receive() failed: bufsize is zero");
MySocket *s = (MySocket *)socket;
check_sd("tcp_receive() failed", s->sd);
int rec = recv(s->sd, buffer, bufsize, 0);
return rec;
}
/*-------------------------------------------------------------------------------------*/
void tcp_close( Socket *socket )
/*-------------------------------------------------------------------------------------*/
{
// parameter check
check_socket_ptr("tcp_close() failed", socket);
check_socket_ptr("tcp_close() failed", *socket);
MySocket *s = (MySocket *)*socket;
check_sd("tcp_close() failed", s->sd);
close( s->sd );
if (s->ip_addr != NULL) {
free(s->ip_addr);
}
free(s);
*socket = NULL;
}
int main() {
state = new LaosStatus();
state->setState(BOOTING);
if (! check_sd()) mbed_reset();
if (SDcheckFirmware()) mbed_reset();
cfg = new GlobalConfig("config.txt");
mot = new LaosMotion();
// wait until cover is closed
state->setState(WAITFORCOVER);
while (! mot->isStart() );
// home
state->setState(HOMING);
mot->home(cfg->xhome,cfg->yhome, cfg->zhome);
// clean sd card?
if (cfg->cleandir) cleandir();
// configure network
eth_speed = 0;
eth = EthConfig();
eth_speed = 1;
// set up TFTP server thread
osThreadCreate(osThread(tftp_thread), NULL);
// set up Queue (planner-filler) thread
osThreadCreate(osThread(queue_thread), NULL);
while (1) {
if (mot->qstate == IDLE) {
mot->filename = getLaosFile();
if (mot->filename) mot->qstate = NEW;
}
if (mot->qstate == DONE) {
removefile(mot->filename);
delete(mot->filename);
}
osDelay(500);
}
}
boolean SDClass::begin(uint8_t csPin){
// cspin is ignored on x86 as it is not needed
return check_sd();
}
static void *
UpdateGUI (void *arg)
{
int i;
while(1)
{
if(guiHalt)
{
LWP_SuspendThread(guithread);
}
else
{
UpdatePads();
mainWindow->Draw();
#ifdef HW_RVL
// for(i=3; i >= 0; i--) // so that player 1's cursor appears on top!
// {
if(userInput[0].wpad->ir.valid)
Menu_DrawImg(userInput[0].wpad->ir.x-48, userInput[0].wpad->ir.y-48,
96, 96, pointer->GetImage(), userInput[0].wpad->ir.angle, 1, 1, 255);
// }
#endif
Menu_Render();
// for(i=0; i < 4; i++)
mainWindow->Update(&userInput[0]);
if(ExitRequested)
{
for(i = 0; i < 255; i += 15)
{
mainWindow->Draw();
GXColor Color = (GXColor) {0, 0, 0, i};
Menu_DrawRectangle(0,0,screenwidth,screenheight,&Color,false,true);
Menu_Render();
}
if (boothomebrew)
{
LoadHomebrew(Settings.forwarder_path.c_str());
string startingAppName = Settings.forwarder_path;
if((signed)startingAppName.rfind("/") != -1)
startingAppName.erase(startingAppName.rfind("/"));
startingAppName.erase(0, startingAppName.rfind("/") +1);
if(IOS_GetVersion() != GetAppIOS(startingAppName))
addAppIos(Settings.startingAppName, SelectedIOS());
}
if (!goneek2o)
ExitApp();
}
// sd check
if(Settings.device == "sd1")
check_sd();
// usb check
else if(Settings.device == "usb1")
check_usb();
// sd und usb check
else if(Settings.device == "sd_usb")
{
check_sd();
check_usb();
}
else if(Settings.device == "dvd")
check_dvd();
#ifndef VWII
else if(Settings.device == "gca")
check_gca();
else if(Settings.device == "gcb")
check_gcb();
#endif
else if(Settings.device == "all")
{
check_sd();
check_usb();
check_dvd();
#ifndef VWII
check_gca();
check_gcb();
#endif
}
// screenshoot
if(WPAD_ButtonsDown(0) & WPAD_BUTTON_1 && WPAD_ButtonsDown(0) & WPAD_BUTTON_2)
Screenshot();
}
}
return NULL;
}
