File content as of revision 19:3a2282277ad0:

/*
/* Copyright (C) 2013 gsfan, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge, publish, distribute,
 * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/* Copyright (C) 2014 Wiznet, MIT License
 *  port to the Wiznet Module WizFi250
 */

#include "WizFi250.h"

#ifdef CFG_ENABLE_RTOS
#undef WIZ_DBG
#define WIZ_DBG(x, ...)
#endif

// This function is operating in ISR. So you can't use debug message.
void WizFi250::recvData ( char c )
{
	static int cid, sub, len, count;

	switch(_state.mode)
	{
		case MODE_COMMAND:
			switch(c)
			{
				case 0:
				case 0x0a:  // LF
				case 0x0d:  // CR
				break;

				case '{':
				_state.buf->flush();
				_state.mode = MODE_DATA_RX;
				sub = 0;
				break;

				default:
				_state.buf->flush();
				_state.buf->queue(c);
				_state.mode = MODE_CMDRESP;
				break;
			}
			break;

		case MODE_CMDRESP:
			switch(c)
			{
				case 0:
					break;
				case 0x0a: // LF
					break;
				case 0x0d: // CR
					if (_flow == 2) setRts(false);      // block
					_state.mode = MODE_COMMAND;
					parseMessage();
					if (_flow == 2) setRts(true);       // release
					break;
				default:
					_state.buf->queue(c);
					break;
			}
			break;

		case MODE_DATA_RX:
			switch(sub)
			{
				case 0:
				// cid
				if( (c >= '0') && (c <= '9') )
				{
					cid = x2i(c);
				}
				else if ( c == ',' )
				{
					sub++;
					count = 0;
					len = 0;
				}
				else
				{
					_state.mode = MODE_COMMAND;
				}
				break;

			case 1:
				// ip
				if ((c >= '0' && c <= '9') || c == '.')
				{
					_con[cid].ip[count] = c;
					count++;
				}
				else if( c == ',' )
				{
					_con[cid].ip[count] = '\0';
					_con[cid].port = 0;
					sub++;
				}
				else
				{
					_state.mode = MODE_COMMAND;
				}
				break;

			case 2:
				// port
				if ( c >= '0' && c <= '9' )
				{
					_con[cid].port = (_con[cid].port * 10) + ( c - '0' );
				}
				else if( c == ',')
				{
					sub++;
					count = 0;
				}
				else
				{
					_state.mode = MODE_COMMAND;
				}
				break;

			case 3:
				// data length
				if ( c >= '0' && c <= '9' )
				{
					//_con[cid].recv_length = (_con[cid].recv_length * 10) + (c - '0');
					len = (len * 10) + (c - '0');
				}
				else if( c == '}' )
				{
					sub++;
					count = 0;
					_con[cid].recv_length = len;
				}
				else
				{
					_state.mode = MODE_COMMAND;
				}
				break;

			default:
				if(_con[cid].buf != NULL)
				{
					_con[cid].buf->queue(c);
					if(_con[cid].buf->available() > CFG_DATA_SIZE - 16 )
					{
						setRts(false);     // blcok
						_con[cid].received = true;
						WIZ_WARN("buf full");
					}
				}
				_con[cid].recv_length--;
				if(_con[cid].recv_length == 0)
				{
					 //WIZ_DBG("recv cid: %d, count : %d, len : %d",cid, count, len);
					_con[cid].received = true;
					_state.mode = MODE_COMMAND;
				}
				break;
			}
			break;
	}
}


#define MSG_TABLE_NUM 6
#define RES_TABLE_NUM 7
int WizFi250::parseMessage () {
	int i;
	char buf[128];

	static const struct MSG_TABLE {
		const char msg[24];
		void (WizFi250::*func)(const char *);
	} msg_table[MSG_TABLE_NUM] = {
		{"[OK]",                    &WizFi250::msgOk},
		{"[ERROR]",                 &WizFi250::msgError},
		{"[ERROR:INVALIDINPUT]",    &WizFi250::msgError},
		{"[CONNECT ",               &WizFi250::msgConnect},
		{"[DISCONNECT ",            &WizFi250::msgDisconnect},
		{"[LISTEN ",                &WizFi250::msgListen},
    };
	static const struct RES_TABLE{
		const Response res;
		void (WizFi250::*func)(const char *);
	}res_table[RES_TABLE_NUM]={
		{RES_NULL,          NULL},
		{RES_MACADDRESS,    &WizFi250::resMacAddress},
//		{RES_WJOIN,         &WizFi250::resWJOIN},
		{RES_CONNECT,       &WizFi250::resConnect},
		{RES_SSEND,         &WizFi250::resSSEND},
		{RES_FDNS,          &WizFi250::resFDNS},
		{RES_SMGMT,         &WizFi250::resSMGMT},
		{RES_WSTATUS,       &WizFi250::resWSTATUS},
	};


	for( i=0; i<sizeof(buf); i++ )
	{
		if( _state.buf->dequeue(&buf[i]) == false ) break;
	}

	buf[i] = '\0';
	//strncpy(_state.dbgRespBuf, buf, sizeof(buf) );
	//WIZ_DBG("%s\r\n",_state.dbgRespBuf);

	if(_state.res != RES_NULL)
	{
		for( i=0; i<RES_TABLE_NUM; i++)
		{
			if(res_table[i].res == _state.res)
			{
				//WIZ_DBG("parse res %d '%s'\r\n", i, buf);
				if(res_table[i].func != NULL)
				{
					(this->*(res_table[i].func))(buf);
				}

				if(res_table[i].res == RES_CONNECT && _state.n < 2)
					return -1;
			}
		}
	}

	for( i=0; i<MSG_TABLE_NUM; i++)
	{
		if( strncmp(buf, msg_table[i].msg, strlen(msg_table[i].msg)) == 0 )
		{
			//WIZ_DBG("parse msg '%s'\r\n", buf);
			if(msg_table[i].func != NULL)
			{
				(this->*(msg_table[i].func))(buf);
			}
			return 0;
		}
	}

	return -1;
}


void WizFi250::msgOk (const char *buf)
{
	_state.ok = true;
}

void WizFi250::msgError (const char *buf)
{
	_state.failure = true;
}

void WizFi250::msgConnect (const char *buf)
{
	int cid;

	if (buf[9] < '0' || buf[9] > '8' || buf[10] != ']') return;

	cid = x2i(buf[9]);

	initCon(cid, true);
	_state.cid = cid;
	_con[cid].accept = true;
	_con[cid].parent = cid;
}

void WizFi250::msgDisconnect (const char *buf)
{
	int cid;

	if(buf[12] < '0' || buf[12] > '8' || buf[13] != ']')    return;

	cid = x2i(buf[12]);
	_con[cid].connected = false;
}

void WizFi250::msgListen (const char *buf)
{
	int cid;

	if(buf[8] < '0' || buf[8] > '8' || buf[9] != ']')   return;

	cid = x2i(buf[8]);
	_state.cid = cid;
}

void WizFi250::resMacAddress (const char *buf)
{
	if( buf[2] == ':' && buf[5] == ':')
	{
		strncpy(_state.mac, buf, sizeof(_state.mac));
		_state.mac[17] = 0;
		_state.res = RES_NULL;

		if(strncmp(_state.mac,CFG_DEFAULT_MAC,sizeof(CFG_DEFAULT_MAC)) == 0)
			_state.ok = false;
		_state.ok = true;
	}
}

void WizFi250::resConnect (const char *buf)
{
	int cid;

	if (buf[0] == '[' && buf[1] == 'O' && buf[2] == 'K' && buf[3] == ']')
	{
		_state.n++;
	}
	else if( buf[0] == '[' && buf[1] == 'C' && buf[2] == 'O' && buf[3] == 'N' &&
			  buf[4] == 'N' && buf[5] == 'E' && buf[6] == 'C' && buf[7] == 'T')
	{
		cid = x2i(buf[9]);
		_state.cid = cid;
		_state.n++;
	}

	if(_state.n >= 2)
	{
		_state.res = RES_NULL;
		_state.ok = true;
	}
}

void WizFi250::resSSEND (const char *buf)
{
	if(_state.cid != -1)
	{
		_state.res = RES_NULL;
		_state.ok = true;
	}
}

void WizFi250::resFDNS (const char *buf)
{
	int i;

	for(i=0; i<strlen(buf); i++)
	{
		if( (buf[i] < '0' || buf[i] > '9') && buf[i] != '.' )
		{
			return;
		}
	}

	strncpy(_state.resolv, buf, sizeof(_state.resolv));
	_state.res = RES_NULL;
}

void WizFi250::resSMGMT (const char *buf)
{
	int cid, i;
	char *c;

	if( (buf[0] < '0' || buf[0] > '8') )    return;

	cid = x2i(buf[0]);
	if( cid != _state.cid )                 return;

	// IP
	c = (char*)(buf+6);
	for( i=0; i<16; i++ )
	{
		if( *(c+i) == ':')
		{
			_con[cid].ip[i] = '\0';
			i++;
			break;
		}
		if( ( *(c+i) < '0' || *(c+i) > '9') && *(c+i) != '.' )  return;
		_con[cid].ip[i] = *(c+i);
	}

	// Port
	c = (c+i);
	_con[cid].port = 0;
	for( i=0; i<5; i++ )
	{
		if( *(c+i) == '/')                  break;
		if( *(c+i) < '0' || *(c+i) > '9' )  return;

		_con[cid].port = (_con[cid].port * 10) + ( *(c+i) - '0' );
	}

	_state.res = RES_NULL;
}

void WizFi250::resWSTATUS (const char *buf)
{
    int idx=0,sep_cnt=0;
    int ip_idx=0,gw_idx=0;

    if(_state.n == 0)
    {
    	_state.n++;
    }
    else if(_state.n == 1)
    {
    	for(idx=0;buf[idx]!='\r';idx++)
    	{
    		if(buf[idx] =='/')
    		{
    			sep_cnt++;
    			continue;
    		}

    		if( sep_cnt == 2)    // IP Address
    		{
    			_state.ip[ip_idx++] = buf[idx];
    		}
    		else if(sep_cnt == 3)
    		{
    			_state.gateway[gw_idx++] = buf[idx];
    		}
    	}
    	_state.ip[ip_idx] = '\0';
    	_state.gateway[gw_idx] = '\0';
    	_state.res = RES_NULL;
    }
}