microchip, Generic tcp server

I'm very new to the Microchip line and I'm currently using the Pic32 Ethernet Starter Kit 2. I've been playing and testing all aspects of this product and I'm currently working with the Generic TCPIP Servo demo from Harmony. I can load the app on the Chip and log into it with Telnet. I can also see it working if I type in say "h" it will echo back "hH" as it should. Because in this demo it runs a ToUpper line on it. What I'm looking to try is to type "hello" in telnet then have it send back "World" Just something simple to get me rolling with this. Below is the current section of code that reads the incoming data converts it to Upper and sends back out.

case APP_TCPIP_SERVING_CONNECTION:
    {
        if (!TCPIP_TCP_IsConnected(appData.socket))
        {
            appData.state = APP_TCPIP_CLOSING_CONNECTION;
            SYS_CONSOLE_MESSAGE("Connection was closed\r\n");
            break;
        }
        int16_t wMaxGet, wMaxPut, wCurrentChunk;
        uint16_t w, w2;
        uint8_t AppBuffer[32];

        //uint8_t AppBuffer2[] = "This is a Test";
        // Figure out how many bytes have been received and how many we can transmit.
        wMaxGet = TCPIP_TCP_GetIsReady(appData.socket); // Get TCP RX FIFO byte count
        wMaxPut = TCPIP_TCP_PutIsReady(appData.socket); // Get TCP TX FIFO free space

        // Make sure we don't take more bytes out of the RX FIFO than we can put into the TX FIFO
        if(wMaxPut < wMaxGet)
                wMaxGet = wMaxPut;

        // Process all bytes that we can
        // This is implemented as a loop, processing up to sizeof(AppBuffer) bytes at a time.
        // This limits memory usage while maximizing performance.  Single byte Gets and Puts are a lot slower than multibyte GetArrays and PutArrays.
        wCurrentChunk = sizeof(AppBuffer);
        for(w = 0; w < wMaxGet; w += sizeof(AppBuffer))
        {
            // Make sure the last chunk, which will likely be smaller than sizeof(AppBuffer), is treated correctly.
            if(w + sizeof(AppBuffer) > wMaxGet)
                wCurrentChunk = wMaxGet - w;

            // Transfer the data out of the TCP RX FIFO and into our local processing buffer.
            TCPIP_TCP_ArrayGet(appData.socket, AppBuffer, wCurrentChunk);

            // Perform the "ToUpper" operation on each data byte
            for(w2 = 0; w2 < wCurrentChunk; w2++)
            {
                i = AppBuffer[w2];
                if(i >= 'a' && i <= 'z')
                {
                        i -= ('a' - 'A');
                        AppBuffer[w2] = i;
                }
                else if(i == '\e')   //escape
                {
                    appData.state = APP_TCPIP_CLOSING_CONNECTION;
                    SYS_CONSOLE_MESSAGE("Connection was closed\r\n");
                }

            }

            // Transfer the data out of our local processing buffer and into the TCP TX FIFO.
            SYS_CONSOLE_PRINT("Server Sending %s\r\n", AppBuffer);
            TCPIP_TCP_ArrayPut(appData.socket, AppBuffer, wCurrentChunk);



            // No need to perform any flush.  TCP data in TX FIFO will automatically transmit itself after it accumulates for a while.  If you want to decrease latency (at the expense of wasting network bandwidth on TCP overhead), perform and explicit flush via the TCPFlush() API.
        }
    }
    break;

Thanks in advance. PBSnake

case APP_TCPIP_SERVING_CONNECTION:
{
    static uint8_t message[] = "Hello";
    static uint16_t pos = 0;

    if (!TCPIP_TCP_IsConnected(appData.socket))
    {
        pos = 0;
        appData.state = APP_TCPIP_CLOSING_CONNECTION;
        SYS_CONSOLE_MESSAGE("Connection was closed\r\n");
        break;
    }
    int16_t wMaxGet, wMaxPut, wCurrentChunk;
    uint16_t w, w2;
    uint8_t AppBuffer[32];

    //uint8_t AppBuffer2[] = "This is a Test";
    // Figure out how many bytes have been received and how many we can transmit.
    wMaxGet = TCPIP_TCP_GetIsReady(appData.socket); // Get TCP RX FIFO byte count
    wMaxPut = TCPIP_TCP_PutIsReady(appData.socket); // Get TCP TX FIFO free space

    // Make sure we don't take more bytes out of the RX FIFO than we can put into the TX FIFO
    if(wMaxPut < wMaxGet)
            wMaxGet = wMaxPut;

    // Process all bytes that we can
    // This is implemented as a loop, processing up to sizeof(AppBuffer) bytes at a time.
    // This limits memory usage while maximizing performance.  Single byte Gets and Puts are a lot slower than multibyte GetArrays and PutArrays.
    wCurrentChunk = sizeof(AppBuffer);
    for(w2 = 0; w2 < wCurrentChunk; w2++)
    {

        i = AppBuffer[w2];

        if (i == message[pos]) 
        {
            pos++;

            if (pos == strlen(message))
            {
                pos = 0;
                strcpy(AppBuffer, "World");
                SYS_CONSOLE_PRINT("Server Sending %s\r\n", AppBuffer);
                TCPPutArray(MySocket, AppBuffer, strlen(AppBuffer));
            }
        } 
        else 
        {
            pos = 0;
        }

        if(i == '\e')   //escape
        {
            TCPServerState = SM_CLOSING;
        }

    }
}

break;