#ifdef DEBUG

DebugPrintF(f_wic); // "\nWiServer init called"

#endif // DEBUG

// Store the callback function for serving pages

callbackFunc = function;

// Store the pin numbers

txPin = tx;

rxPin = rx;

// Set pin modes as needed

if (tx != -1) pinMode(tx, OUTPUT);

if (rx != -1) pinMode(rx, OUTPUT);

while (len-- > 0) {

this->write(pgm_read_byte(data++));

}

return len;

char c = pgm_read_byte(s);

size_t count = 0;

while (c) {

this->print(c);

c = pgm_read_byte(++s);

count++;

}

return count;

size_t count = 0;

count += this->print_P(c);

count += this->println();

return count;

size_t count = 0;

long secs = t / 1000;

int mins = (int)(secs / 60);

int hours = mins / 60;

hours %= 24;

count += this->print(hours / 10);

count += this->print(hours % 10);

count += this->print(':');

mins %= 60;

count += this->print(mins / 10);

count += this->print(mins % 10);

count += this->print(':');

secs %= 60;

count += this->print(secs / 10);

count += this->print(secs % 10);

return count;

// Make sure there's a current connection

if (uip_conn) {

// Check if the cursor is within the range that maps to the uip_appdata buffer

// (and we'll increment the cursor while we're at it)

int offset = (int)(uip_conn->appstate.cursor++) - uip_conn->appstate.ackedCount;

if ((offset >= 0) && (offset < (int)uip_conn->mss)) {

// Write the byte to the corresponding location in the buffer

*((char*)uip_appdata + offset) = b;

return 1;

}

}

return 0;

uip_tcp_appstate_t *app = &(uip_conn->appstate);

// Find the intersection of the virtual buffer and the real uip buffer

int len = (int)app->cursor - app->ackedCount;

len = len < 0 ? 0 : len;

len = len > (int)uip_conn->mss ? (int)uip_conn->mss : len;

#ifdef DEBUG

DebugPrintFO(f_tx); // Serial.print("-->TX ");

Serial.print(len);

DebugPrintF (f_bytes); // Serial.print (" bytes");

Serial.print(app->ackedCount);

DebugPrintFO(f_hyphen); // Serial.print(" - ");

Serial.print(app->ackedCount + len - 1);

DebugPrintFO(f_of); // Serial.print(" of ");

Serial.print((int)app->cursor);

DebugPrint((char *)"");

#endif // DEBUG

// Send the real bytes from the virtual buffer and record how many were sent

uip_send(uip_appdata, len);

app->sentCount = len;

setTXPin(HIGH);

// Check for a valid GET line

if ((uip_conn->appstate.request == NULL) && (strncmp_P(data, httpGET, 4) == 0)) {

// URL starts at the '/'

char* start = data + 4;

// Find trailing space after the URL

data = start;

char* end = data + len;

while (++data < end) {

if (' ' == *data) {

// Replace the space with a NULL to terminate it

*(data++) = '\0';

// copy the URL to the static storage

uip_conn->appstate.request = get_string_global;

strncpy(get_string_global, start, WISERVER_GET_STRING_MAX - 1);

// The following set is implicit. get_string_global is allocated in

// the BSS so it starts with a NULL last char and it stays there

// as long as we never overwrite it

// get_string_global[WISERVER_GET_STRING_MAX - 1] = '\0';

return false;

}

}

// No space, not valid

}

return (len == 0);

// Address after the last byte of data

char* end = data + len;

// Start of current line

char* start = data;

// Scan through the bytes in the packet looking for a Line Feed character

while (data < end) {

if (*data == LF) {

// Determine the length of the line excluding the Line Feed

int lineLength = data - start;

if (*(data - 1) == CR) {

lineLength--;

}

*(start + lineLength) = 0;

// Process the line

if (processLine(start, lineLength)) {

return true;

}

// Set up for the start of the next line

start = ++data;

} else {

// Go to the next byte

data++;

}

}

return false;

// Reset the virtual buffer cursor

uip_conn->appstate.cursor = 0;

// Start off with an HTTP OK response header and a blank line

WiServer.println_P(httpOK);

WiServer.println();

// Call the application's 'sendPage' function and ask it to

// generate the requested page content.

if (!callbackFunc((char*)uip_conn->appstate.request)) {

// The URL is not recognized by the sketch

// Reset the cursor and overwrite the HTTP OK header with a 404 message

uip_conn->appstate.cursor = 0;

WiServer.println_P(httpNotFound);

WiServer.println();

#ifdef DEBUG

DebugPrintF(f_unf); // "URL Not Found";

#endif // DEBUG

}

// Send the 'real' bytes in the buffer

send();

// Check if there is a current connection

if (uip_conn != NULL) {

// Check if the remote host is local to the server

uip_ipaddr_t hostaddr, mask;

// Get the server's address

uip_gethostaddr(&hostaddr);

// Get the subnet mask

uip_getnetmask(&mask);

// Compare with the client's address

return uip_ipaddr_maskcmp(&hostaddr, uip_conn->ripaddr, &mask);

}

return false;

// Get the connection's app state

uip_tcp_appstate_t *app = &(uip_conn->appstate);

if (uip_connected()) {

#ifdef DEBUG

DebugPrintF(f_sc); // JM "Server connected";

#endif

// Initialize the server request data

app->ackedCount = 0;

app->request = NULL;

}

if (uip_newdata()) {

setRXPin(HIGH);

// Process the received packet and check if a valid GET request had been received

if (processPacket((char*)uip_appdata, uip_datalen()) && app->request) {

#ifdef DEBUG

DebugPrintFO(f_prf); // JM "Processing request for ";

DebugPrint((char*)app->request);

#endif

sendPage();

}

}

// Did we get an ack for the last packet?

if (uip_acked()) {

// Record the bytes that were successfully sent

app->ackedCount += app->sentCount;

app->sentCount = 0;

// Check if we're done or need to send more content for this

// request

if (app->ackedCount == (int)app->cursor) {

// Done with the current request and connection

uip_close();

} else {

// Generate the content again to send the next packet of data

sendPage();

}

}

// Check if we need to retransmit

if (uip_rexmit()) {

// Send the same data again (same ackedCount value)

sendPage();

}

if (uip_aborted() || uip_closed() || uip_timedout()) {

// Check if a URL was stored for this connection

if (app->request != NULL) {

#ifdef DEBUG

DebugPrintF(f_scc); // "Server connection closed"

#endif

// Free RAM and clear the pointer

// GregEigsti - jrwifi submitted WiServer stability fix

// free(app->request);

app->request = NULL;

}

}

// Check for an empty queue

if (queue == NULL) {

// Point to the new request

queue = req;

#ifdef DEBUG

DebugPrintF(f_ngr); // JM - new GET/POSTrequest

#endif

} else {

// Find the tail of the queue

GETrequest* r = queue;

while (r->next != NULL) {

r = r->next;

}

// Append the new request

r->next = req;

#ifdef DEBUG

DebugPrintF(f_qgr); // JM - queue GETrequest

#endif

}

// Set the request as being active

req->active = true;

uip_tcp_appstate_t *app = &(uip_conn->appstate);

GETrequest *req = (GETrequest*)app->request;

// Reset the virtual buffer

app->cursor = 0;

// Indicates if this is a POST request (instead of a GET)

// Main difference is that POST requests have a body and a

// callback function to generate said body

bool isPost = req->body != NULL;

// Write out the request header

WiServer.print_P(isPost ? post : get);

WiServer.print(req->URL);

WiServer.println_P(http10);

// Host name

WiServer.print_P(host);

WiServer.println(req->hostName);

// Auth data (if applicable)

if (req->auth) {

WiServer.print_P(authBasic);

WiServer.println(req->auth);

}

// User agent (WiServer, of course!)

WiServer.println_P(userAgent);

if (isPost) {

// Since a post has a body after the blank header line, it has to include

// an accurate content length so that the server knows when it has received

// all of the body data.

char* lengthFieldPos; // Cursor position where the content length place holder starts

char* contentStart; // Start of the body

char* contentEnd; // End of the body

// Just form data for now

WiServer.println_P(contentTypeForm);

// Content length line (with 4-space placeholder for the value)

WiServer.println_P(contentLength);

// Make a note of where the place holder is so we can fill it in later

lengthFieldPos = app->cursor - 6; // 6 bytes for CR, LF, and 4 spaces

// Blank line to indicate end of header

WiServer.println();

// Body starts here

contentStart = app->cursor;

// Print the body preamble if the request has one

if (req->bodyPreamble) {

WiServer.print(req->bodyPreamble);

}

// Have the sketch provide the body for the POST

req->body();

// Body ends here

contentEnd = app->cursor;

// Move the cursor back to the content length value and write in the real length

app->cursor = lengthFieldPos;

WiServer.print((int)(contentEnd - contentStart));

// Put the cursor back at the end of the body so that all of the data gets sent

app->cursor = contentEnd;

} else {

// Blank line to indicate end of GET header

WiServer.println();

}

// Send the 'real' bytes in the buffer

send();

uip_tcp_appstate_t *app = &(uip_conn->appstate);

GETrequest *req = (GETrequest*)app->request;

if (uip_connected()) {

TCP_client_connected = 1; // JM - indicate that an end point client connection is in progress

TCP_new_connection = 1; // JM - indicate a new connection was made - cleared by application

#ifdef DEBUG

DebugPrintFO(f_ct); // Serial.print("-->Connected to ");

DebugPrint((char *)(req->hostName));

#endif

app->ackedCount = 0;

sendRequest();

}

// Did we get an ack for the last packet?

if (uip_acked()) {

// Record the bytes that were successfully sent

app->ackedCount += app->sentCount;

app->sentCount = 0;

// Check if we're done or need to send more content for this

// request

if (app->ackedCount != (int)app->cursor) {

// Generate the post again to send the next packet of data

sendRequest();

}

}

if (uip_rexmit()) {

sendRequest();

}

if (uip_newdata()) {

setRXPin(HIGH);

#ifdef DEBUG

DebugPrintFO(f_rx); // Serial.print("\n<--RX ");

Serial.print(uip_datalen());

DebugPrintFO(f_bf); // Serial.print(" bytes from ");

DebugPrint((char *)req->hostName);

#endif

// Check if the sketch cares about the returned data

if ((req->returnFunc) && (uip_datalen() > 0)){

// Call the sketch's callback function

req->returnFunc((char*)uip_appdata, uip_datalen());

}

}

if (uip_aborted() || uip_timedout() || uip_closed()) {

if (req != NULL) {

TCP_client_connected = 0; // JM end point connection no longer in progress

TCP_connection_terminated = 1; // JM indicate a connection attempt or connection terminated

#ifdef DEBUG

DebugPrintFO(f_ec);

DebugPrint((char *)req->hostName);

#endif

if (req->returnFunc) {

// Call the sketch's callback function with 0 bytes to indicate End Of Data

req->returnFunc((char*)uip_appdata, 0);

}

// Remove the request from the connection

app->request = NULL;

// Request is no longer active

req->active = false;

}

}

dest[0] = getChar(src[0] >> 2);

dest[1] = getChar(((src[0] & 0x03) << 4) | ((src[1] & 0xf0) >> 4));

dest[2] = len > 1 ? getChar(((src[1] & 0x0f) << 2) | ((src[2] & 0xc0) >> 6)) : '=';

dest[3] = len > 2 ? getChar(src[2] & 0x3f ) : '=';

// Clear the activity pins

setTXPin(LOW);

setRXPin(LOW);

// Check for an active connection

if (uip_conn) {

// Is the connection for local port 80?

if (uip_conn->lport == HTONS(80)) {

// Server mode

server_task_impl();

} else {

#ifdef ENABLE_CLIENT_MODE

// Client mode

client_task_impl();

#endif // ENABLE_CLIENT_MODE

}

}

long endTime = millis() + (seconds * 1000);

while (!this->server_task() & ((seconds == -1) || (millis() < endTime)));

return state == CONNECTED;

// Run the driver

zg_drv_process();

if (state == CONNECTED) {

if (isConnected()) {

// Run the stack state machine

stack_process();

#ifdef ENABLE_CLIENT_MODE

// Check if there is a pending client request

if (queue) {

// Attempt to connect to the server

struct uip_conn *conn = uip_connect(&(queue->ipAddr), queue->port);

if (conn != NULL) {

#ifdef DEBUG

DebugPrintFO(f_gcf);

Serial.println(queue->hostName);

#endif // DEBUG

// Attach the request object to its connection

conn->appstate.request = queue;

// Move the head of the queue to the next request in the queue

queue = queue->next;

// Clear the next pointer of the connected request

((GETrequest*)conn->appstate.request)->next = NULL;

}

}

#endif // ENABLE_CLIENT_MODE

} else {

state = DISCONNECTED;

#ifdef DEBUG

DebugPrintF(f_cla);

#endif

uip_abort();

stack_process();

}

}

// Check if we need to initiate a connection

if (state == DISCONNECTED) {

#ifdef DEBUG

DebugPrintF(f_reinit);

#endif

// WiShield init

zg_init();

#ifdef USE_DIG0_INTR

attachInterrupt(0, zg_isr, LOW);

#endif

#ifdef USE_DIG8_INTR

// set digital pin 8 on Arduino

// as ZG interrupt pin

PCICR |= (1<<PCIE0);

PCMSK0 |= (1<<PCINT0);

#endif

state = CONNECTING;

connectTime = millis();

#ifdef DEBUG

DebugPrintF(f_co);

#endif

}

// Check if we're waiting for the connection to be established

if (state == CONNECTING) {

// Move things along

zg_drv_process();

// Check if we got a connection

if (isConnected()) {

state = CONNECTED;

#ifdef DEBUG

DebugPrintF(f_cd);

#endif

// Start the stack

stack_init();

// Listen for server requests on port 80 if appropriate

if (callbackFunc) {

uip_listen(HTONS(80));

}

} else if (millis() - connectTime > CONNECTION_TIMEOUT * 1000) {

// No success, try restarting the WiShield

state = DISCONNECTED;

#ifdef DEBUG

DebugPrintF(f_reinit_fail);

#endif

}

}

return (state == CONNECTED);