extern "C" unsigned long WINAPI EXPORT vscp_readStringValue( const char * pStrValue )
{
wxString strVal;
strVal.FromAscii( pStrValue );
return readStringValue( strVal );
}
int vscp_server_parse_send( char *pArg, vscpEvent *pEvent )
{
// Get VSCP head
char *p = strtok( pArg, "," );
if ( NULL == p ) return VSCP_SRV_ERROR_ARGUMENT;
pEvent->head = readStringValue( p );
// Get VSCP class
p = strtok( NULL, "," );
if ( NULL == p ) return VSCP_SRV_ERROR_ARGUMENT;
pEvent->vscp_class = readStringValue( p );
// Get VSCP type
p = strtok( NULL, "," );
if ( NULL == p ) return VSCP_SRV_ERROR_ARGUMENT;
pEvent->vscp_type = readStringValue( p );
// Get VSCP obid
p = strtok( NULL, "," );
if ( NULL == p ) return VSCP_SRV_ERROR_ARGUMENT;
uint32_t pvscp_obid = readStringValue( p );
// Get VSCP timestamp
p = strtok( NULL, "," );
if ( NULL == p ) return VSCP_SRV_ERROR_ARGUMENT;
uint32_t pvscp_timestamp = readStringValue( p );
// Get VSCP GUID
p = strtok( NULL, "," );
if ( NULL == p ) return VSCP_SRV_ERROR_ARGUMENT;
vscp_server_ParseGUID( p, pEvent->GUID );
// Get VSCP data if any
p = strtok( NULL, "," );
if ( NULL != p ) {
vscp_server_ParseData( p, pEvent->data, &pEvent->sizeData );
}
return VSCP_SRV_ERROR_SUCCESS;
}
void vscp_server_ParseGUID( char *pArg, uint8_t *pGUID )
{
uint8_t i;
char *p;
memset( pGUID, 0x00, 16 );
if ( NULL == pArg ) return;
p = strtok( pArg, ":" );
for ( i=0; i<16; i++ ) {
if ( NULL == p ) break;
pGUID[ 15-i ] = readStringValue( p );
p = strtok( NULL, ":" );
}
}
uint16_t vscp_server_ParseData( char *pArg, uint8_t *pData, uint16_t *pcntData )
{
char *p;
if ( NULL == pArg ) return VSCP_SRV_ERROR_ARGUMENT;
*pcntData = 0;
p = strtok( pArg, ":" );
#ifdef VSCP_LEVEL2_LIMITED_DEVICE
uint16_t datasize = VSCP_LEVEL2_LIMITED_BUFFER_SIZE;
#else
uint16_t datasize = 512-25;
#endif
for ( *pcntData=0; *pcntData < datasize; *pcntData++ ) {
if ( NULL == p ) break;
pData[ *pcntData ] = readStringValue( p );
p = strtok( NULL, ":" );
}
return *pcntData;
}
int vscpServerParser( char *pCommand )
{
int rv = 0;
uint16_t i;
// Convert string to uppercase
i = 0;
while ( pCommand[ i ] ) {
pCommand[ i ] = toupper( pCommand[ i ] );
i++;
}
// ********************************************************************
// QUIT
// *********************************************************************
if ( NULL != strstr( pCommand, "QUIT" ) ) {
vscp_server_sendReply( MSG_GOODBY );
vscp_server_command_quit();
}
//*********************************************************************
// No Operation
//*********************************************************************
else if ( NULL != strstr( pCommand, "NOOP" ) ) {
vscp_server_sendReply( MSG_OK );
}
//*********************************************************************
// Send event
//
// "send head,class,type,obid,timestamp,GUID,data1,data2,data3...."
//*********************************************************************
else if ( NULL != strstr( pCommand, "SEND" ) ) {
// parse the send argument
vscpEvent event;
if ( VSCP_SRV_ERROR_SUCCESS == vscp_server_parse_send( pCommand + 4,
&event ) ) {
// Handle the command
vscp_server_command_send( &event );
}
else {
vscp_server_sendReply( MSG_PARAMETER_ERROR );
}
}
//*********************************************************************
// Read event
// "RETR n" the argument can be omitted meaning "1"
//*********************************************************************
else if ( NULL != strstr( pCommand, "RETR" ) ) {
char *p = pCommand + 4;
vscpEvent event;
#ifdef VSCP_LEVEL2_LIMITED_DEVICE
char buf[ 31 + 64 + 3 * ( 512 - 25 + 1 ) ];
#else
char buf[ 31 + 64 + 3 * ( LIMITED_DEVICE_DATASIZE + 1 ) ];
#endif
// Get read count
uint16_t count = readStringValue( p );
// Default to read one event
if ( 0 == count ) count = 1;
char wrkbuf[ 32 ];
while ( count-- ) {
// Get event
if ( !vscp_server_command_retr( &event ) ) break;
// Empty reply string
buf[ 0 ] = 0x00;
// Event available. We should output a dataline.
// Format is
// head,class,type,obid,timestamp,GUID,data0,data1,data2,...........<cr><lf>
// head
itoa( event.head, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
// class
itoa( event.vscp_class, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
// type
itoa( event.vscp_type, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
// obid
strcat( buf, "0," );
// timestamp
itoa( vscp_server_getTicks(), wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
// GUID
vscp_server_GUID2String( event.GUID, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
// Data
vscp_server_Data2String( event.data, event.sizeData, buf + strlen( buf ) );
strcat( buf, "\r\n" );
vscp_server_sendReply( buf );
}
vscp_server_sendReply( MSG_OK );
}
//*********************************************************************
// Check if data is available
//*********************************************************************
else if ( NULL != strstr( pCommand, "CDTA" ) ) {
uint32_t cnt = vscp_server_command_cdta();
char buf[ 32 ];
atoi( cnt, buf );
strcat( buf, "\r\n" );
vscp_server_sendReply( buf );
vscp_server_sendReply( MSG_OK );
}
//*********************************************************************
// Clear input queue
//*********************************************************************
else if ( NULL != strstr( pCommand, "CLRA" ) ) {
vscp_server_command_clra();
vscp_server_sendReply( MSG_OK );
}
//*********************************************************************
// Get Statistics
//*********************************************************************
else if ( NULL != strstr( pCommand, "STAT" ) ) {
vscp_statistics stat;
char buf[ 80 ];
char wrkbuf[ 10 ];
vscp_server_command_stat( &stat );
// Null string
*buf = 0x00;
// Bus off's
itoa( stat.cntBusOff, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
// Bus warnings
itoa( stat.cntBusWarnings, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
// Overruns
itoa( stat.cntOverruns, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
// Received data
itoa( stat.cntReceiveData, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
// Received frames
itoa( stat.cntReceiveFrames, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
// Transmitted data
itoa( stat.cntTransmitData, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
// Transmitted frames
itoa( stat.cntTransmitFrames, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "\r\n" );
vscp_server_sendReply( buf );
vscp_server_sendReply( MSG_OK );
}
//*********************************************************************
// Get Status
//*********************************************************************
else if ( NULL != strstr( pCommand, "INFO" ) ) {
vscp_interface_info info;
char buf[ 80 ];
char wrkbuf[ 10 ];
// Null string
*buf = 0x00;
vscp_server_command_info( &info );
// Channel status flags/code
itoa( info.channel_status, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
// Last error code
itoa( info.lasterrorcode, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
// Last error sub code
itoa( info.lasterrorsubcode, wrkbuf );
strcat( buf, wrkbuf );
strcat( buf, "," );
strcat( buf, info.lasterrorstr );
strcat( buf, "\r\n" );
vscp_server_sendReply( buf );
vscp_server_sendReply( MSG_OK );
}
//*********************************************************************
// Get Channel ID
//*********************************************************************
else if ( NULL != strstr( pCommand, "CHID" ) ) {
char buf[ 10 ];
// Null string
*buf = 0x00;
uint32_t chid = vscp_server_command_chid();
itoa( chid, buf );
strcat( buf, "\r\n" );
vscp_server_sendReply( buf );
vscp_server_sendReply( MSG_OK );
}
//*********************************************************************
// Set Channel GUID
//*********************************************************************
else if ( NULL != strstr( pCommand, "SGID" ) ) {
char *p = pCommand + 4;
uint8_t GUID[ 16 ];
vscp_server_ParseGUID( p, GUID );
vscp_server_command_sgid( GUID );
vscp_server_sendReply( MSG_OK );
}
//*********************************************************************
// Get Channel GUID
//*********************************************************************
else if ( NULL != strstr( pCommand, "GGID" ) ) {
uint8_t GUID[ 16 ];
char buf[ 32 ];
// Fetch the interface GUID
vscp_server_command_ggid( GUID );
vscp_server_GUID2String( GUID, buf );
strcat( buf, "\r\n" );
vscp_server_sendReply( buf );
vscp_server_sendReply( MSG_OK );
}
//*********************************************************************
// Get Version
//*********************************************************************
else if ( NULL != strstr( pCommand, "VERS" ) ) {
uint8_t major;
uint8_t minor;
uint8_t sub;
char wrk[ 5 ];
char buf[ 32 ];
// Get version
vscp_server_command_ver( &major, &minor, &sub );
buf[ 0 ] = 0x00; // Empty string
// Major version
itoa( major, wrk );
strcat( buf, wrk );
strcat( buf, "," );
// Minor version
itoa( minor, wrk );
strcat( buf, wrk );
strcat( buf, "," );
// Sub minor version
itoa( sub, wrk );
strcat( buf, wrk );
strcat( buf, "\r\n" );
vscp_server_sendReply( buf );
vscp_server_sendReply( MSG_OK );
}
//*********************************************************************
// Set Filter
//*********************************************************************
else if ( NULL != strstr( pCommand, "SFLT" ) ) {
uint8_t filter_priority = 0;
uint16_t filter_class = 0;
uint8_t filter_type = 0;
char *p;
uint8_t filter_GUID[ 16 ];
// Nill GUID
memset( filter_GUID, 0x00, 16 );
p = strtok( pCommand + 4, "," );
if ( NULL != p ) filter_priority = readStringValue( p );
p = strtok( NULL, "," );
if ( NULL != p ) filter_class = readStringValue( p );
p = strtok( NULL, "," );
if ( NULL != p ) filter_type = readStringValue( p );
p = strtok( NULL, "," );
if ( NULL != p ) vscp_server_ParseGUID( p, filter_GUID );
// Set the filter
vscp_server_command_sflt( filter_priority,
filter_class,
filter_type,
filter_GUID );
vscp_server_sendReply( MSG_OK );
}
//*********************************************************************
// Set Mask
//*********************************************************************
else if ( NULL != strstr( pCommand, "SMSK" ) ) {
uint8_t mask_priority = 0;
uint16_t mask_class = 0;
uint8_t mask_type = 0;
char *p;
uint8_t mask_GUID[ 16 ];
// Nill GUID
memset( mask_GUID, 0x00, 16 );
p = strtok( pCommand + 4, "," );
if ( NULL != p ) mask_priority = readStringValue( p );
p = strtok( NULL, "," );
if ( NULL != p ) mask_class = readStringValue( p );
p = strtok( NULL, "," );
if ( NULL != p ) mask_type = readStringValue( p );
p = strtok( NULL, "," );
if ( NULL != p ) vscp_server_ParseGUID( p, mask_GUID );
// Set the filter
vscp_server_command_smsk( mask_priority,
mask_class,
mask_type,
mask_GUID );
vscp_server_sendReply( MSG_OK );
}
//*********************************************************************
// Username
//*********************************************************************
else if ( NULL != strstr( pCommand, "USER" ) ) {
vscp_server_command_user( pCommand + 4 );
vscp_server_sendReply( MSG_USENAME_OK ); // YES!!! Always OK
}
//*********************************************************************
// Password
//*********************************************************************
else if ( NULL != strstr( pCommand, "PASS" ) ) {
if ( vscp_server_command_password( pCommand + 4 ) ) {
vscp_server_sendReply( MSG_PASSWORD_ERROR );
}
else {
vscp_server_sendReply( MSG_PASSWORD_OK );
}
}
//*********************************************************************
// Enter Binary Mode
//*********************************************************************
else if ( NULL != strstr( pCommand, "FAST" ) ) {
vscp_server_sendReply( MSG_NOT_IMPLEMENTED );
}
//*********************************************************************
// + (repeat last command)
//*********************************************************************
else if ( NULL != strstr( pCommand, "+" ) ) {
vscp_server_sendReply( MSG_NOT_IMPLEMENTED );
}
//*********************************************************************
// Rcvloop
//*********************************************************************
else if ( NULL != strstr( pCommand, "RCVLOOP" ) ) {
vscp_server_sendReply( MSG_NOT_IMPLEMENTED );
}
//*********************************************************************
// Help
//*********************************************************************
else if ( NULL != strstr( pCommand, "HELP" ) ) {
vscp_server_sendReply( MSG_NOT_IMPLEMENTED );
}
//*********************************************************************
// Restart
//*********************************************************************
else if ( NULL != strstr( pCommand, "RESTART" ) ) {
vscp_server_sendReply( MSG_NOT_IMPLEMENTED );
}
//*********************************************************************
// Client/interface
//*********************************************************************
else if ( NULL != strstr( pCommand, "INTERFACE" ) ) {
vscp_server_sendReply( MSG_NOT_IMPLEMENTED );
}
//*********************************************************************
// Test
//*********************************************************************
else if ( NULL != strstr( pCommand, "TEST" ) ) {
vscp_server_sendReply( MSG_NOT_IMPLEMENTED );
}
//*********************************************************************
// Shutdown
//*********************************************************************
else if ( NULL != strstr( pCommand, "SHUTDOWN" ) ) {
vscp_server_sendReply( MSG_NOT_IMPLEMENTED );
}
//*********************************************************************
// canmode
//*********************************************************************
else if ( NULL != strstr( pCommand, "CANMODE" ) ) {
vscp_server_sendReply( MSG_NOT_IMPLEMENTED );
}
//*********************************************************************
// Que?
//*********************************************************************
else {
// Unknown command
vscp_server_sendReply( MSG_UNKNOWN_COMMAND );
}
return rv;
}
bool
ClParserParser::
parse()
{
ClParserOperatorType op = CL_PARSER_OP_NONE;
error_code_ = 0;
bool expression = false;
parse_.skipSpace();
while (! parse_.eof()) {
/* <expression> := <inline_operator> <expression>
<expression> := <expression> <inline_operator> */
if (parse_.isString("++") || parse_.isString("--")) {
if (parse_.isChar('+'))
ClParserStackMgrInst->push(CL_PARSER_OP_INCREMENT);
else
ClParserStackMgrInst->push(CL_PARSER_OP_DECREMENT);
ClParserStackMgrInst->toNext();
parse_.skipChars(2);
if (! expression) {
ClParserParser parser(this);
if (! parser.parse()) {
error_code_ = parser.getErrorCode();
goto fail;
}
if (parser.isAssign()) {
error_code_ = int(ClErr::INVALID_LVALUE_FOR_ASSIGNMENT);
goto fail;
}
}
expression = true;
}
/* <expression> := <unary_operator> <expression> */
else if (! expression && parse_.isOneOf(parser_unary_operator_chars)) {
if (! readUnaryOperator(&op)) {
error_code_ = int(ClErr::INVALID_CHARACTER);
goto fail;
}
ClParserStackMgrInst->push(op);
ClParserStackMgrInst->toNext();
ClParserParser parser(this);
if (! parser.parse()) {
error_code_ = parser.getErrorCode();
goto fail;
}
if (parser.isAssign()) {
error_code_ = int(ClErr::INVALID_LVALUE_FOR_ASSIGNMENT);
goto fail;
}
expression = true;
}
/* <expression> := '(' <expression> ')' */
else if (! expression && parse_.isChar('(')) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_R_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
ClParserParser parser(this);
/* TODO: set end char */
if (! parser.parse() &&
parser.getErrorCode() != int(ClErr::INVALID_CHARACTER)) {
error_code_ = parser.getErrorCode();
goto fail;
}
parse_.skipSpace();
if (! parse_.isChar(')')) {
error_code_ = int(ClErr::MISSING_CLOSE_ROUND_BRACKET);
goto fail;
}
ClParserStackMgrInst->push(CL_PARSER_OP_CLOSE_R_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
expression = true;
}
/* <expression> := <numeric_value> */
else if (! expression && (parse_.isDigit() || parse_.isChar('.'))) {
ClParserValuePtr value;
if (! readNumericValue(value))
goto fail;
ClParserStackMgrInst->push(value);
ClParserStackMgrInst->toNext();
expression = true;
}
/* <expression> := <string_value> */
else if (! expression && parse_.isOneOf(parser_string_chars)) {
ClParserValuePtr value;
if (! readStringValue(value))
goto fail;
ClParserStackMgrInst->push(value);
ClParserStackMgrInst->toNext();
expression = true;
}
/* <expression> := <array_value> */
else if (! expression && parse_.isChar('[')) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_S_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
if (! readArray())
goto fail;
expression = true;
}
/* <expression> := <dict_value> */
else if (! expression && parse_.isString("{{")) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_DICT);
ClParserStackMgrInst->toNext();
parse_.skipChars(2);
if (! readDictionary())
goto fail;
expression = true;
}
/* <expression> := <list_value> */
else if (! expression && parse_.isChar('{')) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_BRACE);
ClParserStackMgrInst->toNext();
parse_.skipChar();
if (! readList())
goto fail;
expression = true;
}
/* <expression> := <expression> <binary_operator> <expression> */
else if (expression && parse_.isOneOf(parser_binary_operator_chars)) {
if (! readBinaryOperator(&op))
goto fail;
ClParserStackMgrInst->push(op);
ClParserStackMgrInst->toNext();
ClParserParser parser(this);
if (! parser.parse()) {
error_code_ = parser.getErrorCode();
goto fail;
}
ClParserOperatorPtr op1 = ClParserOperatorMgrInst->getOperator(op);
if (! op1->isAssignment() && parser.isAssign()) {
error_code_ = int(ClErr::INVALID_LVALUE_FOR_ASSIGNMENT);
goto fail;
}
if (op1->isAssignment())
assign_ = true;
expression = true;
}
/* <expression> := <expression> '?' <expression> ':' <expression> */
else if (expression && parse_.isChar('?')) {
ClParserStackMgrInst->push(CL_PARSER_OP_QUESTION_MARK);
ClParserStackMgrInst->toNext();
parse_.skipChar();
ClParserParser parser1(this);
if (! parser1.parse() &&
parser1.getErrorCode() != int(ClErr::INVALID_CHARACTER)) {
error_code_ = parser1.getErrorCode();
goto fail;
}
parse_.skipSpace();
if (! parse_.isChar(':')) {
error_code_ = int(ClErr::MISSING_COLON_OPERATOR);
goto fail;
}
ClParserStackMgrInst->push(CL_PARSER_OP_COLON);
ClParserStackMgrInst->toNext();
parse_.skipChar();
ClParserParser parser2(this);
if (! parser2.parse() &&
parser2.getErrorCode() != int(ClErr::INVALID_CHARACTER)) {
error_code_ = parser2.getErrorCode();
goto fail;
}
assign_ = parser1.isAssign() | parser2.isAssign();
expression = true;
}
/* <expression> := <expression> '[' <expression> ',' .... ']' */
else if (expression && parse_.isChar('[')) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_S_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
if (! readArray())
goto fail;
expression = true;
}
/* <expression> := <expression> ',' <expression> */
else if (expression && parse_.isChar(',')) {
ClParserStackMgrInst->push(CL_PARSER_OP_COMMA);
ClParserStackMgrInst->toNext();
parse_.skipChar();
ClParserParser parser(this);
if (! parser.parse()) {
error_code_ = parser.getErrorCode();
goto fail;
}
expression = true;
}
/* <expression> := <variable> */
/* <expression> := <variable> '.' <variable> '.' <...> */
/* <expression> := <variable> '[' <expression> ',' .... ']' */
/* <expression> := <function> '(' <expression> ',' .... ')' */
/* <expression> := <type> '(' <expression> ',' .... ')' */
else if (! expression &&
((! ClParserInst->getDollarPrefix() && parse_.isIdentifier()) ||
( ClParserInst->getDollarPrefix() &&
parse_.isChar('$') && parse_.isIdentifier(1)))) {
if (ClParserInst->getDollarPrefix() && parse_.isChar('$'))
parse_.skipChar();
ClParserIdentifierPtr identifier;
if (! readIdentifier(identifier))
goto fail;
const std::string &name = identifier->getName();
ClParserScopePtr scope = identifier->getScope();
parse_.skipSpace();
if (parse_.isChar('(')) {
ClParserInternFnPtr internfn;
if (scope.isValid())
internfn = scope->getInternFn(name);
else
internfn = ClParserInst->getInternFn(name);
if (internfn.isValid()) {
ClParserStackMgrInst->push(internfn);
ClParserStackMgrInst->toNext();
}
else {
ClParserUserFnPtr userfn;
if (scope.isValid())
userfn = scope->getUserFn(name);
else
userfn = ClParserInst->getUserFn(name);
if (userfn.isValid()) {
ClParserStackMgrInst->push(userfn);
ClParserStackMgrInst->toNext();
}
else {
ClParserTypePtr type = ClParserInst->getType(name);
if (type.isValid()) {
ClParserStackMgrInst->push(type);
ClParserStackMgrInst->toNext();
}
else {
identifier->setFunction();
ClParserStackMgrInst->push(identifier);
ClParserStackMgrInst->toNext();
}
}
}
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_R_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
if (! readArgList())
goto fail;
expression = true;
}
else {
identifier->setVariable();
ClParserStackMgrInst->push(identifier);
ClParserStackMgrInst->toNext();
if (parse_.isChar('[')) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_S_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
if (! readArray())
goto fail;
parse_.skipSpace();
}
while (parse_.isChar('.')) {
identifier->setStructPart();
ClParserStackMgrInst->push(CL_PARSER_OP_DOT);
ClParserStackMgrInst->toNext();
parse_.skipChar();
parse_.skipSpace();
if (! readIdentifier(identifier)) {
error_code_ = int(ClErr::INVALID_CHARACTER);
goto fail;
}
identifier->setVariable();
ClParserStackMgrInst->push(identifier);
ClParserStackMgrInst->toNext();
if (parse_.isChar('[')) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_S_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
if (! readArray())
goto fail;
parse_.skipSpace();
}
}
expression = true;
}
}
/* <expression> := <string_value> */
else if (! expression && ClParserInst->getDollarPrefix()) {
std::string str;
parse_.readNonSpace(str);
ClParserValuePtr value = ClParserValueMgrInst->createValue(str);
ClParserStackMgrInst->push(value);
ClParserStackMgrInst->toNext();
parse_.skipSpace();
expression = true;
}
else {
error_code_ = int(ClErr::INVALID_CHARACTER);
goto fail;
}
parse_.skipSpace();
}
if (error_code_ == 0 && ! expression) {
error_code_ = int(ClErr::NULL_EXPRESSION);
goto fail;
}
if (parent_)
parent_->parse_.setPos(parent_->parse_.getPos() + parse_.getPos());
return true;
fail:
if (parent_)
parent_->parse_.setPos(parent_->parse_.getPos() + parse_.getPos());
return false;
}
void *CudpdrvTxTread::Entry()
{
pcap_t *fp;
char errbuf[ PCAP_ERRBUF_SIZE ];
//uint8_t packet[ 512 ];
// First log on to the host and get configuration
// variables
if ( m_srv.doCmdOpen( m_pobj->m_host,
m_pobj->m_port,
m_pobj->m_username,
m_pobj->m_password ) <= 0 ) {
return NULL;
}
// Find the channel id
m_srv.doCmdGetChannelID( &m_pobj->m_ChannelIDtx );
// It is possible that there is configuration data the server holds
// that we need to read in.
// We look for
// prefix_interface Communication interface to work on
// prefix_localmac MAC address to use for outgoing packets
// prefix_filter to find a filter. A string is expected.
// prefix_mask to find a mask. A string is expected.
// Interface
wxString varInterface;
if ( m_srv.getVariableString( m_pobj->m_prefix + _T("_interface"), &varInterface ) ) {
m_pobj->m_interface = varInterface;
}
wxString varLocalMac;
if ( m_srv.getVariableString( m_pobj->m_prefix + _T("_localmac"), &varLocalMac ) ) {
varLocalMac.MakeUpper();
wxStringTokenizer tkz( varLocalMac, ":\n" );
for ( int i = 0; i < 6; i++ ) {
if ( tkz.HasMoreTokens() ) break;
wxString str = _("0X") + tkz.GetNextToken();
m_pobj->m_localMac[ i ] = readStringValue( str );
m_pobj->m_localGUIDtx.setAt( ( 9 + i ), m_pobj->m_localMac[ i ] );
m_pobj->m_localGUIDrx.setAt( ( 9 + i ), m_pobj->m_localMac[ i ] );
}
}
// We want to use our own Ethernet based GUID for this interface
wxString strGUID;
m_pobj->m_localGUIDtx.toString( strGUID );
m_srv.doCmdSetGUID( (char *)strGUID.ToAscii() );
// Open the adapter
if ( (fp = pcap_open_live( m_pobj->m_interface.ToAscii(), // name of the device
65536, // portion of the packet to capture. It doesn't matter in this case
1, // promiscuous mode (nonzero means promiscuous)
1000, // read timeout
errbuf // error buffer
) ) == NULL ) {
//fprintf(stderr,"\nUnable to open the adapter. %s is not supported by WinPcap\n", argv[1]);
return NULL;
}
int rv;
struct pcap_pkthdr *header;
const u_char *pkt_data;
while ( !TestDestroy() &&
!m_pobj->m_bQuit &&
( rv = pcap_next_ex( fp, &header, &pkt_data ) ) >= 0 ) {
// Check for timeout
if ( 0 == rv ) continue;
// Check if this is VSCP
if ( ( 0x25 == pkt_data[ 12 ] ) &&
( 0x7e == pkt_data[ 13 ] ) ) {
// We have a packet - send it as a VSCP event
vscpEventEx event;
event.head = pkt_data[ 15 ] & 0xe0; // Priority
event.GUID[ 0 ] = 0xff; // Ethernet predefined GUID
event.GUID[ 1 ] = 0xff;
event.GUID[ 2 ] = 0xff;
event.GUID[ 3 ] = 0xff;
event.GUID[ 4 ] = 0xff;
event.GUID[ 5 ] = 0xff;
event.GUID[ 6 ] = 0xff;
event.GUID[ 7 ] = 0xfe;
event.GUID[ 8 ] = pkt_data[ 6 ]; // Source MAC address
event.GUID[ 9 ] = pkt_data[ 7 ];
event.GUID[ 10 ] = pkt_data[ 8 ];
event.GUID[ 11 ] = pkt_data[ 9 ];
event.GUID[ 12 ] = pkt_data[ 10 ];
event.GUID[ 13 ] = pkt_data[ 11 ];
event.GUID[ 14 ] = pkt_data[ 19 ]; // Device sub address
event.GUID[ 15 ] = pkt_data[ 20 ];
event.timestamp = ( pkt_data[ 21 ] << 24 ) +
( pkt_data[ 22 ] << 16 ) +
( pkt_data[ 23 ] << 8 ) +
pkt_data[ 24 ] ;
event.obid = ( pkt_data[ 25 ] << 24 ) +
( pkt_data[ 26 ] << 16 ) +
( pkt_data[ 27 ] << 8 ) +
pkt_data[ 28 ];
event.vscp_class = ( pkt_data[ 29 ] << 8 ) +
pkt_data[ 30 ];
event.vscp_type = ( pkt_data[ 31 ] << 8 ) +
pkt_data[ 32 ];
event.sizeData = ( pkt_data[ 33 ] << 8 ) +
pkt_data[ 34 ];
// If the packet is smaller then the set datasize just
// disregard it
if ( ( event.sizeData + 35 ) > (uint16_t)header->len ) continue;
for ( int i=0; i<event.sizeData; i++ ) {
event.data[ i ] = pkt_data[ 35 + i ];
}
m_srv.doCmdSendEx( &event ); // Send the event
}
} // work loop
// Close listner
pcap_close( fp );
// Close the channel
m_srv.doCmdClose();
return NULL;
}
bool Cudpdrv::open( const char *pUsername,
const char *pPassword,
const char *pHost,
short port,
const char *pPrefix,
const char *pConfig,
unsigned long flags )
{
bool rv = true;
m_flags = flags;
wxString wxstr = pConfig;
m_username = pUsername;
m_password = pPassword;
m_host = pHost;
m_port = port;
m_prefix = pPrefix;
// Parse the configuration string. It should
// have the following form
// username;password;host;prefix;port;filename
wxStringTokenizer tkz( pConfig, ";\n" );
// Interface
if ( tkz.HasMoreTokens() ) {
m_interface = tkz.GetNextToken();
}
// Local Mac
wxString localMac;
if ( tkz.HasMoreTokens() ) {
localMac = tkz.GetNextToken();
localMac.MakeUpper();
wxStringTokenizer tkzmac( localMac, ":\n" );
for ( int i = 0; i < 6; i++ ) {
if ( !tkzmac.HasMoreTokens() ) break;
wxString str = _("0X") + tkzmac.GetNextToken();
m_localMac[ i ] = readStringValue( str );
m_localGUIDtx.setAt( ( 9 + i ), m_localMac[ i ] );
m_localGUIDrx.setAt( ( 9 + i ), m_localMac[ i ] );
}
}
// start the workerthreads
m_pthreadWorkTx = new CudpdrvTxTread();
if ( NULL != m_pthreadWorkTx ) {
m_pthreadWorkTx->m_pobj = this;
m_pthreadWorkTx->Create();
m_pthreadWorkTx->Run();
}
else {
rv = false;
}
wxSleep( 1 );
m_pthreadWorkRx = new CudpdrvRxTread();
if ( NULL != m_pthreadWorkRx ) {
m_pthreadWorkRx->m_pobj = this;
m_pthreadWorkRx->Create();
m_pthreadWorkRx->Run();
}
else {
rv = false;
}
return rv;
}
bool CVSCPVariable::setValueFromString( int type, const wxString& strValue )
{
// Convert to uppercase
wxString strUpper;
switch ( type ) {
case VSCP_DAEMON_VARIABLE_CODE_STRING:
m_strValue = strValue;
break;
case VSCP_DAEMON_VARIABLE_CODE_BOOLEAN:
{
strUpper = strValue.Upper();
if ( wxNOT_FOUND != strUpper.Find( _("TRUE") ) ) {
m_boolValue = true;
}
else {
m_boolValue = false;
}
}
break;
case VSCP_DAEMON_VARIABLE_CODE_INTEGER:
m_longValue = readStringValue( strValue );
break;
case VSCP_DAEMON_VARIABLE_CODE_LONG:
m_longValue = readStringValue( strValue );
break;
case VSCP_DAEMON_VARIABLE_CODE_DOUBLE:
strValue.ToDouble( &m_floatValue );
break;
case VSCP_DAEMON_VARIABLE_CODE_VSCP_MEASUREMENT:
{
uint8_t data[ VSCP_MAX_DATA ];
uint16_t sizeData = 0;
getVscpDataArrayFromString( data, &sizeData, strValue );
if ( sizeData > 8 ) sizeData = 8;
if (sizeData) memcpy( m_normInteger, data, sizeData );
m_normIntSize = sizeData;
}
break;
case VSCP_DAEMON_VARIABLE_CODE_VSCP_EVENT:
getVscpEventFromString( &m_event, strValue );
break;
case VSCP_DAEMON_VARIABLE_CODE_VSCP_EVENT_GUID:
getGuidFromString( &m_event, strValue );
break;
case VSCP_DAEMON_VARIABLE_CODE_VSCP_EVENT_DATA:
getVscpDataFromString( &m_event, strValue );
break;
case VSCP_DAEMON_VARIABLE_CODE_VSCP_EVENT_CLASS:
m_event.vscp_class = readStringValue( strValue );
break;
case VSCP_DAEMON_VARIABLE_CODE_VSCP_EVENT_TYPE:
m_event.vscp_type = readStringValue( strValue );
break;
case VSCP_DAEMON_VARIABLE_CODE_VSCP_EVENT_TIMESTAMP:
m_event.timestamp = readStringValue( strValue );
break;
case VSCP_DAEMON_VARIABLE_CODE_DATETIME:
m_timestamp.ParseDateTime( strValue );
break;
case VSCP_DAEMON_VARIABLE_CODE_UNASSIGNED:
// Fall through - Not allowed here
default:
return false;
}
return true;
}
