/*
* Receive function from WIFISerial with timeout.
* It waits until first byte is available on WIFISerial, or time out.
* Then it starts to receive answer stream, until trailer or fixed time out.
*/
int MWiFi::receiveMessWait(unsigned long ms)
{
setTimer(ms);
rxcode=0xFD;
while(WIFISerial.available()==0)
{delay(10);if(getTimeout()) {return rxcode;}}
return receiveMess();
}
/*
* Setup MCW1001A (first function to issue).
* Hardware reset (pin 7).
* Read startup message at 115200 from MCW and then change serial speed to WIFISPEED define.
* Then switch on led 0.
*/
void MWiFi::begin()
{
#if WIFIDEBUG
Serial.begin(9600);Serial.println("Debug on!");
#endif
wdt_disable();
WIFISerial.begin(115200);
pinMode(7,OUTPUT);digitalWrite(7,HIGH);delay(1);digitalWrite(7,LOW);
receiveMessWait(10000);
WIFISerial.begin(WIFISPEED);
setLed(0,1);
receiveMess(); // just to clean buffer
delay(100);
setSockSize();
setARP(0);
errorHandle=NULL;
}
/*
* It decodes possible asynchronous message.
* It returns event code or 0 (if no async.).
*/
uint8_t MWiFi::getAsync()
{
uint8_t cd=receiveMess();
if (cd!=1) return 0;
return decodeAsync();
}
/**************************************************
** Function: Main
** Description: Server style socket configurations based off example at: http://www.linuxhowtos.org/C_C++/socket.htm
** and http://beej.us/guide/bgnet/output/html/singlepage/bgnet.html
** Parameters: command line argument port number to listen on.
** Returns: 1
**************************************************/
int main(int argc, char *argv[]) {
int sockfd; // Socket file descriptor.
int newsockfd; // Socket file descriptor for use once socket it bound to a port.
int portno; // Port we are accepting connections on.
int pid; // PID of child processes.
socklen_t clilen; // Size of clients address, required by 'accept()'.
char buffer[1000]; // Data buffer to read incoming messages into.
char username[] = "localhost";
struct sockaddr_in serv_addr; // Address of the server (here).
struct sockaddr_in cli_addr; // Address of the client (who connects).
int n; // Integer to hold number of characters read or write returns.
int status; // Status variable to communicate child process status.
int portCounter = 0; // Integer to increment port number by as clients connect.
// Begin socket setup.
// Check user passed in a port to set socket up on.
if(argc < 2) {
fprintf(stderr, "ERROR, no port provided\n");
fflush(stderr);
exit(1);
}
// Create new socket.
sockfd = socket(AF_INET, SOCK_STREAM, 0); // Socket uses unix domain, stream type socket, with TCP protocol.
if(sockfd < 0) // -1 means socket created errored out.
error("ERROR opening socket", 1);
bzero((char *) &serv_addr, sizeof(serv_addr)); // Set serv_addr struct to all 0's.
portno = atoi(argv[1]); // Convert user entered port number to integer.
// Set up server address struct.
serv_addr.sin_family = AF_INET; // Set to unix domain.
serv_addr.sin_port = htons(portno); // Set port number to network byte order.
serv_addr.sin_addr.s_addr = INADDR_ANY; // Set server address to it's own IP address. (INADDR_ANY returns current machines IP).
// Bind socket to server address.
if(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
error("ERROR binding", 1);
listen(sockfd, 5); // Listen on socket for connections.
int quit = 0;
while(1) { // Loop forever waiting for connections.
newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen); // Accept connection, make new socket for connection.
portCounter = portCounter + 1; // Increment port increase variable, so they can communicate on new port #.
if(newsockfd < 0) // If newsockfd is less than 0, the accept call failed.
error("ERROR on accept", 1);
// Connection was successful so fork a new process.
pid = fork();
if(pid < 0)
error("ERROR forking process", 1);
if(pid == 0) { // CHILD
close(sockfd); // Close the old socket.
char childPort[50]; // Character array to hold port number child should talk on.
int childsockfd; // New socket.
int newchildsockfd; // New communication between child process and client. Sock bound to new port.
childsockfd = socket(AF_INET, SOCK_STREAM, 0); // Socket uses unix domain, stream type socket, with TCP protocol.
sprintf(childPort, "%d", (portno + portCounter)); // Convert port integer to string and store it in childPort.
// Set up new port to talk on, port is 5 characters.
write(newsockfd, childPort, 5);
// Copy old serv address to new one.
struct sockaddr_in child_serv_addr; // Address of the server (here).
// Copy over master server address information to child.
memcpy(&child_serv_addr, &serv_addr, sizeof(serv_addr));
// Set port number of child.
child_serv_addr.sin_port = htons((portno + portCounter)); // Set new port number.
// Bind socket to child server address.
if(bind(childsockfd, (struct sockaddr *) &child_serv_addr, sizeof(child_serv_addr)) < 0)
error("ERROR binding", 1);
listen(childsockfd, 5); // Listen on socket for connections.
newchildsockfd = accept(childsockfd, (struct sockaddr *) &cli_addr, &clilen); // Accept connection, make new socket for connection.
if(newchildsockfd < 0) {
error("ERROR accepting connection from client", 1);
}
int messLen = 0;
int contConn = 1; // Be default we want to continue receiving message.
while(1) {
// Receive message.
contConn = receiveMess(newchildsockfd, buffer);
if(contConn == 0) { // Client decided to close connection.
break;
}
// Send message.
contConn = sendMess(newchildsockfd, buffer, username);
if(quit == 1) { // \quit was entered.
close(newchildsockfd);
close(newsockfd);
kill(pid, SIGKILL);
return 0;
}
}
exit(0);
} else { // PARENT
waitpid(0, &status, WNOHANG);
close(newsockfd);
}
} /* End of while loop */
close(sockfd);
return 0;
}
