static void DumpNumber(lua_Number x, DumpState* D)
{
const int srcSize = sizeof(x);
const int dstSize = D->config->sizeof_lua_Number;
const int endianSwap = EndianSwapRequired(D->config->endianness);
lua_assert((dstSize == 4) || (dstSize == 8));
lua_assert(dstSize >= srcSize);
if (dstSize > srcSize)
{
const double x64 = x;
double out = x64;
if (endianSwap)
EndianSwapScalar(&out, &x64, sizeof(out));
DumpMem(&out, 1, sizeof(out), D);
}
else
{
lua_Number out = x;
if (endianSwap)
EndianSwapScalar(&out, &x, sizeof(out));
DumpMem(&out, 1, sizeof(out), D);
}
// Original Lua implmenetation:
// DumpVar(x, D);
}
static void DumpInt(int x, DumpState* D)
{
const int srcSize = sizeof(x);
const int dstSize = D->config->sizeof_int;
const int endianSwap = EndianSwapRequired(D->config->endianness);
lua_assert((dstSize == 4) || (dstSize == 8));
lua_assert(dstSize >= srcSize);
if (dstSize > srcSize)
{
const int64_t x64 = x;
int64_t out = x64;
if (endianSwap)
EndianSwapScalar(&out, &x64, sizeof(out));
DumpMem(&out, 1, sizeof(out), D);
}
else
{
int out = x;
if (endianSwap)
EndianSwapScalar(&out, &x, sizeof(out));
DumpMem(&out, 1, sizeof(out), D);
}
// Original Lua implementation:
// DumpVar(x, D);
}
static void DumpSizeT(size_t x, DumpState* D)
{
const int srcSize = sizeof(size_t);
const int dstSize = D->config->sizeof_size_t;
const int endianSwap = EndianSwapRequired(D->config->endianness);
lua_assert((dstSize == 4) || (dstSize == 8));
lua_assert(dstSize >= srcSize);
if (dstSize > srcSize)
{
const uint64_t x64 = x;
uint64_t out = x64;
if (endianSwap)
EndianSwapScalar(&out, &x64, sizeof(out));
DumpMem(&out, 1, sizeof(out), D);
}
else
{
size_t out = x;
if (endianSwap)
EndianSwapScalar(&out, &x, sizeof(out));
DumpMem(&out, 1, sizeof(out), D);
}
}
static void DumpNumber(lua_Number x, DumpState* D)
{
/*
http://stackoverflow.com/questions/14954088/how-do-i-handle-byte-order-differences-when-reading-writing-floating-point-types/14955046#14955046
10-byte little-endian serialized format for double:
- normalized mantissa stored as 64-bit (8-byte) signed integer:
negative range: (-2^53, -2^52]
zero: 0
positive range: [+2^52, +2^53)
- 16-bit (2-byte) signed exponent:
range: [-0x7FFE, +0x7FFE]
Represented value = mantissa * 2^(exponent - 53)
Special cases:
- +infinity: mantissa = 0x7FFFFFFFFFFFFFFF, exp = 0x7FFF
- -infinity: mantissa = 0x8000000000000000, exp = 0x7FFF
- NaN: mantissa = 0x0000000000000000, exp = 0x7FFF
- +/-0: only one zero supported
*/
double y=(double)x,m;
unsigned char z[8];
long long im;
int ie;
if (luai_numisnan(NULL,x)) { DumpChar(0,D); /* NaN */ return; }
else if (x == LUA_INFINITY) { DumpChar(1,D); /* +inf */ return; }
else if (x == -LUA_INFINITY) { DumpChar(2,D); /* -inf */ return; }
else if (x == 0) { DumpChar(3,D); /* 0 */ return; }
/* Split double into normalized mantissa (range: (-1, -0.5], 0, [+0.5, +1)) and base-2 exponent */
m = frexp(y, &ie); /* y = m * 2^ie exactly for FLT_RADIX=2, frexp() can't fail */
/* Extract most significant 53 bits of mantissa as integer */
m = ldexp(m, 53); /* can't overflow because DBL_MAX_10_EXP >= 37 equivalent to DBL_MAX_2_EXP >= 122 */
im = (long long)trunc(m); /* exact unless DBL_MANT_DIG > 53 */
/* If the exponent is too small or too big, reduce the number to 0 or +/- infinity */
if (ie>0x7FFE)
{
if (im<0) DumpChar(2,D); /* -inf */ else DumpChar(1,D); /* +inf */
return;
}
else if (ie<-0x7FFE) { DumpChar(3,D); /* 0 */ return; }
DumpChar(4,D); /* encoded */
/* Store im as signed 64-bit little-endian integer */
z[0]=(unsigned char)(im&0xFF);
z[1]=(unsigned char)((im>>8)&0xFF);
z[2]=(unsigned char)((im>>16)&0xFF);
z[3]=(unsigned char)((im>>24)&0xFF);
z[4]=(unsigned char)((im>>32)&0xFF);
z[5]=(unsigned char)((im>>40)&0xFF);
z[6]=(unsigned char)((im>>48)&0xFF);
z[7]=(unsigned char)((im>>56)&0xFF);
DumpMem(z,1,8,D);
/* Store ie as signed 16-bit little-endian integer */
z[0]=(unsigned char)(ie&0xFF);
z[1]=(unsigned char)((ie>>8)&0xFF);
DumpMem(z,1,2,D);
}
int SendBytesAndWaitForResponse(SOCKET destination,char *source, int nBytes, char *destinationBuffer, int MaxReadSize,int timeout)
{
int i=-1;
#ifdef WIN32
u_long tmp=1;
#else
int tmp=1;
#endif
fd_set fds;
struct timeval tv;
if (debug) {
printf("Sending..\n");
DumpMem(source,nBytes);
}
// if (send(destination, source, nBytes,0) >0) {
if (timeout>0)
{
#ifdef WIN32
ioctlsocket(destination, FIONBIO, &tmp);
#else
ioctl(destination, FIONBIO, (char *)&tmp);
#endif
send(destination, source, nBytes,0);
tv.tv_sec = timeout;
tv.tv_usec = 0;
FD_ZERO(&fds);
FD_SET(destination, &fds);
//printf("Esperando Timeout: %i\n",timeout);
i=select((int)destination+1,&fds,0,0,&tv);
//printf("saliendo select: %i\n",i);
if (i<=0) return(-1);
} else {
send(destination, source, nBytes,0);
}
i=recv(destination, (char *)destinationBuffer, MaxReadSize, 0);
if (timeout>0)
{
tmp=0;
#ifdef WIN32
ioctlsocket(destination, FIONBIO, &tmp);
#else
ioctl(destination, FIONBIO, (char *)&tmp);
#endif
}
if (debug)
{
printf("[*] received: %i bytes\n",i);
DumpMem(destinationBuffer,i);
}
// }
//printf("salimos...: %i\n",i);
return(i);
}
void CHttpStateMachine::process_state(t_sm_state state, bool entry)
{
(this->*m_process_state[state])(entry);
#ifdef __DEBUG__
int n = 0;
switch (state) {
case HTTP_STATE_START:
case HTTP_STATE_END:
case HTTP_STATE_RECEIVE_COMMAND_REPLY:
default:
n = 0;
break;
case HTTP_STATE_SEND_COMMAND_REQUEST:
n = m_packetLenght;
break;
case HTTP_STATE_PROCESS_COMMAND_REPLY:
n = m_lastRead;
break;
}
if (entry) {
DumpMem(m_buffer, n, m_state_name[state], m_ok);
} else {
AddDebugLogLineN(logProxy,
wxString(wxT("wait state -- ")) << m_state_name[state]);
}
#endif // __DEBUG__
}
static void DumpUInt(lu_int32 x, DumpState* D)
{
unsigned char y[4];
y[0]=(unsigned char)(x&0xFF);
y[1]=(unsigned char)((x>>8)&0xFF);
y[2]=(unsigned char)((x>>16)&0xFF);
y[3]=(unsigned char)((x>>24)&0xFF);
DumpMem(y,1,4,D);
}
void SendData( const void *buf, size_t bytesToWrite )
{
if ( gDebug )
{
DumpMem( "Send", 0, buf, bytesToWrite );
}
gSerialPort.Write( buf, bytesToWrite );
} // SendData
static void DumpInt(int x, DumpState* D)
{
unsigned char y[4];
if(x<0)
error(D,"negative int value");
y[0]=(unsigned char)(x&0xFF);
y[1]=(unsigned char)((x>>8)&0xFF);
y[2]=(unsigned char)((x>>16)&0xFF);
y[3]=(unsigned char)((x>>24)&0xFF);
DumpMem(y,1,4,D);
}
void BioloidBus::WriteBuffer()
{
if ( m_showPackets )
{
DumpMem( "W", 0, m_data, m_dataBytes );
}
WriteBufferedData( m_data, m_dataBytes );
m_dataBytes = 0;
}
smheader *BuildSmbPacket1(void)
{
char buf2[4096];
smheader *SmbPacket1;
memset((char*)buf2,'\0',sizeof(buf2));
BuildAuthRequest((tSmbNtlmAuthRequest*)buf2,0,NULL,NULL);
#ifdef _DBG_
DumpMem((char*)buf2,SmbLength((tSmbNtlmAuthRequest*)buf2));
#endif
SmbPacket1=BuildSmbPacket((smheader*)NULL,SESSIONSETUPANDX,0,buf2,40);
return(SmbPacket1);
}
static void DumpVector(const void* b, int n, size_t size, DumpState* D)
{
const int endianSwap = EndianSwapRequired(D->config->endianness);
DumpInt(n, D);
if (endianSwap)
{
void* out = malloc(n * size);
EndianSwapArray(out, b, n, size);
DumpMem(out, n, size, D);
free(out);
}
else
DumpMem(b, n, size, D);
// Original Lua implementation
// DumpInt(n, D);
// DumpMem(b, n, size, D);
}
void CSocks5StateMachine::process_state(t_sm_state state, bool entry)
{
/* Ok, the syntax is terrible, but this is correct. This is a
* pointer to a member function. No C equivalent for that. */
(this->*m_process_state[state])(entry);
#ifdef __DEBUG__
int n = 0;
switch (state) {
case SOCKS5_STATE_START:
case SOCKS5_STATE_END:
case SOCKS5_STATE_RECEIVE_AUTHENTICATION_METHOD:
case SOCKS5_STATE_RECEIVE_AUTHENTICATION_GSSAPI:
case SOCKS5_STATE_RECEIVE_AUTHENTICATION_USERNAME_PASSWORD:
case SOCKS5_STATE_RECEIVE_COMMAND_REPLY:
default:
n = 0;
break;
case SOCKS5_STATE_SEND_QUERY_AUTHENTICATION_METHOD:
case SOCKS5_STATE_SEND_AUTHENTICATION_GSSAPI:
case SOCKS5_STATE_SEND_AUTHENTICATION_USERNAME_PASSWORD:
case SOCKS5_STATE_SEND_COMMAND_REQUEST:
n = m_packetLenght;
break;
case SOCKS5_STATE_PROCESS_AUTHENTICATION_METHOD:
case SOCKS5_STATE_PROCESS_AUTHENTICATION_GSSAPI:
case SOCKS5_STATE_PROCESS_AUTHENTICATION_USERNAME_PASSWORD:
case SOCKS5_STATE_PROCESS_COMMAND_REPLY:
n = m_lastRead;
break;
}
if (entry) {
DumpMem(m_buffer, n, m_state_name[state], m_ok);
} else {
AddDebugLogLineN(logProxy,
wxString(wxT("wait state -- ")) << m_state_name[state]);
}
#endif // __DEBUG__
}
bool BioloidBus::ReadStatusPacket( BioloidPacket *pkt )
{
Bioloid::Error err;
m_dataBytes = 0;
do
{
uint8_t ch;
if ( !ReadByte( &ch ))
{
//LogError( "BioloidBus::ReadStatusPacket: ReadByte returned false\n");
return false;
}
if ( m_dataBytes < sizeof( m_data ))
{
m_data[ m_dataBytes++ ] = ch;
}
err = pkt->ProcessChar( ch );
} while ( err == Bioloid::ERROR_NOT_DONE );
if ( err == Bioloid::ERROR_NONE )
{
if ( m_showPackets )
{
if ( m_dataBytes > 0 )
{
DumpMem( "R", 0, m_data, m_dataBytes );
}
}
}
else
{
Log( "BioloidBus::ReadStatusPacket err = %d\n", err );
}
return err == Bioloid::ERROR_NONE;
}
static void DumpVector(const void* b, int n, size_t size, DumpState* D)
{
DumpInt(n,D);
DumpMem(b,n,size,D);
}
void I2C_SerialDongle::PacketReceived( PKT_Packet *packet )
{
uint8_t *pd = &packet->data[ 0 ];
PacketType packetType = (PacketType)*pd++;
uint8_t crc = 0;
uint8_t len = 0;
if ( m_debugDongleData )
{
DumpMem( "PktRcvd", 0, packet->data, packet->len );
}
if ( packetType == ErrorPacket )
{
m_response.m_errorCode = *pd;
LogError( "Rcvd Error packet, error code:%d '%s'\n", m_response.m_errorCode, ErrorStr( m_response.m_errorCode ));
}
else
if ( packetType == m_response.m_responseType )
{
// This is the type of packet that the caller is waiting for.
crc = m_response.m_partialCrc;
if ( packet->len > 1 )
{
// Check the CRC to see if it's valid
len = *pd; crc = Crc8( crc, *pd ); pd++;
// Sanity check the length. The packet length should equal the i2c len
// plus 3 (1 for packet type, 1 for len, 1 for CRC)
if (( len + 3 ) != packet->len )
{
LogError( "I2C_SerialDongle::PacketReceived Inconsistent packet length. Serial packetLen = %d, i2c packetLen = %d (expecting %d)\n",
packet->len, len, packet->len - 3 );
m_response.m_errorCode = I2C_ERROR_BAD_LEN;
packetType = ErrorPacket;
}
else
{
for ( int i = 0; i < len; i++ )
{
crc = Crc8( crc, pd[ i ]);
}
if ( crc != pd[ len ] )
{
LogError( "I2C_SerialDongle::PacketReceived CRC failure. Found 0x%02x, expecting 0x%02x\n", pd[ len ], crc );
m_response.m_errorCode = I2C_ERROR_BAD_CRC;
packetType = ErrorPacket;
}
}
// We've received a good packet, and we're waiting for this type
// of packet. Wakeup the reader
if ( len < 1 )
{
LogError( "I2C_SerialDongle::PacketReceived packet len too small (%d). Needs to be at least 1 to store address of sender\n", len );
len = 1;
}
if ( len > m_response.m_buf->dataLen )
{
LogError( "I2C_SerialDongle::PacketReceived packet buffer too small. bufferSize = %d, received %d\n", m_response.m_buf->dataLen, len );
len = m_response.m_buf->dataLen;
}
m_response.m_buf->dataLen = len;
if (( len > 0 ) && ( m_response.m_buf != NULL ))
{
memcpy( &m_response.m_buf->data[ 0 ], &pd[ 0 ], len );
}
}
}
if (( packetType == m_response.m_responseType ) || ( packetType == ErrorPacket ))
{
// Setting m_responseType to NoPacket signals that we're no longer
// waiting for a packet.
m_response.m_responseType = NoPacket;
sem_post( &m_response.m_semaphore );
return;
}
// Call the registered callback to report the received packet
if ( m_callback != NULL )
{
m_callback->PacketReceived( m_response.m_buf );
}
else
{
LogError( "m_callback == NULL\n" );
LogError( "packetType:%d m_response.m_responseType:%d\n", packetType, m_response.m_responseType );
LogError( "packet len: %d\n", packet->len );
DumpMem( " pkt", 0, packet->data, packet->len );
}
} // PacketReceived
/**
* Sends a packet and waits for a respomse. We need to do things in the
* correct order to prevent a race condition.
*/
bool I2C_SerialDongle::SendPacketWaitForResponse
(
const PKT_Packet *pkt,
PacketType responseType,
uint8_t partialCrc,
Buffer *buf
)
{
// Currently we only handle one outstanding "wait" at a time.
if ( m_response.m_responseType != NoPacket )
{
LogError( "m_response.m_responseType:%d\n", m_response.m_responseType );
}
assert( m_response.m_responseType == NoPacket );
// Setup the response before sending the packet. Since we have a different
// thread processing the received packets, we could receive the packet
// really quickly
m_response.m_responseType = responseType;
m_response.m_partialCrc = partialCrc;
m_response.m_buf = buf;
m_response.m_errorCode = I2C_ERROR_NONE;
// Send the packet
if ( m_debugDongleData )
{
DumpMem( "SendPkt", 0, pkt->data, pkt->len );
}
PKT_SendPacket( pkt, this );
// Wait for the response
struct timespec waitTime;
waitTime.tv_sec = time( NULL ) + 3; // We shouldn't have to wait this long for a response
waitTime.tv_nsec = 0;
if ( sem_timedwait( &m_response.m_semaphore, &waitTime ) != 0 )
{
if ( errno == ETIMEDOUT )
{
LogError( "I2C_Dongle::WaitForResponse timeout waiting for response\n" );
}
else
{
LogError( "I2C_Dongle::WaitForResponse: error waiting for semaphore: %s (%d)\n", strerror( errno ), errno );
}
m_response.m_responseType = NoPacket;
return false;
}
if ( m_response.m_errorCode != I2C_ERROR_NONE )
{
LogError( "I2C_Dongle::WaitForResponse error %d detected\n", m_response.m_errorCode );
return false;
}
return true;
} // WaitForResponse
static void DumpChar(int y, DumpState* D)
{
char x=(char)y;
DumpMem(&x, 1, sizeof(x), D);
}
int WriteRemoteFile(RELAY relay, smheader *buffer, char *lpFileName)
{
char path[256];
char buf[64000];
smheader *packet;
int i;
int filesize;
char *filedata;
uint16 FID;
uint16 TreeID;
sprintf(path,"\\\\%s\\admin$",inet_ntoa(relay.destinationaddr.sin_addr));
memset(buf,0,sizeof(buf));
i=BuildTreeConnectAndXStub(buf,"",path,"?????");
packet=BuildSmbPacket((smheader*)buffer,TREECONNETANDX,0,buf,i);//,(int)strlen(path));
printf("[+] Trying to connect to admin$\r");
if (debug)
{
CleanLine(verbose);
DumpMem((char*)packet,SmbPacketLen(packet));
}
i=SendBytesAndWaitForResponse(relay.destination,(char*)packet, SmbPacketLen(packet),(char*)buf,sizeof(buf),SMBWAITTIMEOUT);
if ((i<=0) || (((smheader*)buf)->NtStatus!=0x00000000) ){
CleanLine(verbose);
printf("[-] Error. Unable to connect to admin$\n");
return(0);
}
TreeID=((smheader*)buf)->TreeId;
sprintf(path,"\\%s",lpFileName);
filedata =ReadFileToSend(&filesize,lpFileName);
if(!filedata)
{
CleanLine(verbose);
printf("[-] Error. Unable to open %s\n",lpFileName);
return(0);
}
packet=BuildSmbPacket((smheader*)buf,NTCREATEANDX,0,path,filesize);
CleanLine(verbose);
printf("[+] Creating Remote File %s under admin$\r",lpFileName);
if (debug)
{
CleanLine(verbose);
DumpMem((char*)packet,SmbPacketLen(packet));
}
i=SendBytesAndWaitForResponse(relay.destination,(char*)packet, SmbPacketLen(packet),(char*)buf,sizeof(buf),SMBWAITTIMEOUT);
if ((i<=0) || (((smheader*)buf)->NtStatus!=0x00000000) ){
CleanLine(verbose);
if ( ((smheader*)buf)->NtStatus == STATUS_SHARING_VIOLATION) {
printf("[-] Remote File already in use (try to connect to the remote Shell).\n");
return(1);
}
printf("[-] Error. Unable to create file under admin$ (Error 0x%x)\n",((smheader*)buf)->NtStatus);
return(0);
}
memcpy((char*)&FID,((smheader*)buf)->buffer+6,2);
CleanLine(verbose);
printf("[+] Writing File %s into admin$ (%i bytes)\r",lpFileName,filesize);
packet=BuildSmbPacket((smheader*)buf,WRITEANDX,0,filedata,filesize);
free(filedata);
if (debug)
{
CleanLine(verbose);
DumpMem((char*)packet,SmbPacketLen(packet));
}
i=SendBytesAndWaitForResponse(relay.destination,(char*)packet, SmbPacketLen(packet),(char*)buf,sizeof(buf),SMBWAITTIMEOUT);
if ((i<=0) || (((smheader*)buf)->NtStatus!=0x00000000) ){
CleanLine(verbose);
printf("[-] Error. Unable to Write File.\n");
return(0);
}
packet=BuildSmbPacket((smheader*)buf,SMBCLOSE,0,&FID,2);
packet->TreeId=TreeID;
if (verbose)
{
CleanLine(verbose);
printf("[*] Closing File handle - FID: %2.2x\r",FID);
if (debug) DumpMem((char*)packet,SmbPacketLen(packet));
}
i=SendBytesAndWaitForResponse(relay.destination,(char*)packet, SmbPacketLen(packet),(char*)buf,sizeof(buf),SMBWAITTIMEOUT);
if ((i<=0) || (((smheader*)buf)->NtStatus!=0x00000000) ){
CleanLine(verbose);
printf("[-] Error Closing File Handle\n");
return(0);
}
return(1);
}
bool BioloidCommandLine::ProcessLine( char *lineStr )
{
char *devTypeStr;
BLD_DevType_t *devType;
char token[ 20 ];
StrTokenizer line( lineStr, token, sizeof( token ));
unsigned devTypeIdx;
if ( m_bus == NULL )
{
LogError( "SetBus not called\n" );
return false;
}
// Pull out the device type
if (( devTypeStr = line.NextToken( gDelim )) == NULL )
{
// Empty line - ignore
return true;
}
// Check for special non-device type commands
if ( strcmp( devTypeStr, "action" ) == 0 )
{
m_bus->SendAction();
// The action command is sent as a broadcast, so no response
// is expected.
return true;
}
if ( strcmp( devTypeStr, "scan" ) == 0 )
{
uint8_t numIds;
if ( !line.NextNum( &numIds ))
{
numIds = 32;
}
if ( numIds < 100 )
{
bool servoIdFound = m_bus->Scan( DevFound, 0, numIds );
bool sensorIdFound = m_bus->Scan( DevFound, 100, numIds );
if ( !servoIdFound && !sensorIdFound )
{
Log( "No devices found\n" );
}
}
else
{
if ( !m_bus->Scan( DevFound, 0 , numIds ))
{
Log( "No devices found\n" );
}
}
return true;
}
if ( strcmp( devTypeStr, "dev-types" ) == 0 )
{
for ( devTypeIdx = 0; devTypeIdx < m_numDevTypes; devTypeIdx++ )
{
devType = m_devType[devTypeIdx];
Log( "%-10s Model: %5u %2d registers\n",
devType->devTypeStr, devType->model, devType->numRegs );
}
return true;
}
if ( strcmp( devTypeStr, "quit" ) == 0 )
{
return false;
}
// Since it's not one of those - assume it's a device type
devType = NULL;
for ( devTypeIdx = 0; devTypeIdx < m_numDevTypes; devTypeIdx++ )
{
if ( strcmp( m_devType[ devTypeIdx ]->devTypeStr, devTypeStr ) == 0 )
{
devType = m_devType[ devTypeIdx ];
break;
}
}
if ( devTypeIdx >= m_numDevTypes )
{
LogError( "Unrecognized device type: '%s'\n", devTypeStr );
return true;
}
Bioloid::ID_t id;
if ( !line.NextNum( &id ))
{
if ( strcmp( line.PrevToken(), "reg" ) == 0 )
{
DumpRegInfo( devType );
return true;
}
LogError( "Invalid ID: '%s'\n", line.PrevToken() );
return true;
}
if ( id >= Bioloid::INVALID_ID )
{
LogError( "IDs must be 254 (0xFE) or less\n" );
return true;
}
m_device.SetBusAndID( m_bus, id );
char *cmdStr;
if (( cmdStr = line.NextToken()) == NULL )
{
LogError( "No command specified for %s %u\n", devType->devTypeStr, id );
return true;
}
LogVerbose( "DevType: %s ID: %d Cmd: %s\n", devType->devTypeStr, id, cmdStr );
if ( strcmp( cmdStr, "ping" ) == 0 )
{
Bioloid::Error err;
if ( id == Bioloid::BROADCAST_ID )
{
LogError( "Broadcast ID not valid with ping command\n" );
return true;
}
if (( err = m_device.Ping()) == Bioloid::ERROR_NONE )
{
Log( "%s %d Response Received\n", devType->devTypeStr, id );
}
else
{
Log( "%s %d ", devType->devTypeStr, id );
PrintError( err );
}
}
else
if (( strcmp( cmdStr, "read-data" ) == 0 )
|| ( strcmp( cmdStr, "rd" ) == 0 ))
{
uint8_t offset;
uint8_t numBytes;
if ( id == Bioloid::BROADCAST_ID )
{
LogError( "Broadcast ID not valid with read-data command\n" );
return true;
}
if ( !line.NextNum( &offset ))
{
LogError( "Invalid offset specified: '%s'\n", line.PrevToken() );
return true;
}
if ( !line.NextNum( &numBytes ))
{
LogError( "Invalid numBytes specified: '%s'\n", line.PrevToken() );
return true;
}
if ( numBytes > sizeof( gReadBuf ))
{
LogError( "Only able to a maximum of %d bytes\n", sizeof( gReadBuf ));
return true;
}
if ( PrintError( m_device.Read( offset, gReadBuf, numBytes )))
{
return true;
}
DumpMem( "Read", offset, gReadBuf, numBytes );
}
else
if (( strcmp( cmdStr, "write-data" ) == 0 )
|| ( strcmp( cmdStr, "wd" ) == 0 ))
{
uint8_t offset;
uint8_t numBytes;
uint8_t data[ 20 ];
if ( !ParseOffsetAndData( line, &offset, &numBytes, data, sizeof( data )))
{
return true;
}
PrintError( m_device.Write( offset, data, numBytes ));
}
else
if (( strcmp( cmdStr, "reg-write" ) == 0 )
|| ( strcmp( cmdStr, "rw" ) == 0 ))
{
uint8_t offset;
uint8_t numBytes;
uint8_t data[ 20 ];
if ( !ParseOffsetAndData( line, &offset, &numBytes, data, sizeof( data )))
{
return true;
}
m_device.SendDeferredWrite( offset, data, numBytes );
}
else
if ( strcmp( cmdStr, "get" ) == 0 )
{
ProcessDeviceGetCommand( devType, id, line, false );
}
else
if ( strcmp( cmdStr, "get-raw" ) == 0 )
{
ProcessDeviceGetCommand( devType, id, line, true );
}
else
if ( strcmp( cmdStr, "set" ) == 0 )
{
ProcessDeviceSetCommand( devType, id, line, false );
}
else
if ( strcmp( cmdStr, "set-raw" ) == 0 )
{
ProcessDeviceSetCommand( devType, id, line, true );
}
else
if ( strcmp( cmdStr, "reset" ) == 0 )
{
m_device.Reset();
}
else
{
LogError( "Unrecognized command: '%s'\n", cmdStr );
}
return true;
}
