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; }