void OpenSSLContext::sendPendingDataToApplication() {
ByteArray data;
data.resize(SSL_READ_BUFFERSIZE);
int ret = SSL_read(handle_, data.getData(), data.getSize());
while (ret > 0) {
data.resize(ret);
onDataForApplication(data);
data.resize(SSL_READ_BUFFERSIZE);
ret = SSL_read(handle_, data.getData(), data.getSize());
}
if (ret < 0 && SSL_get_error(handle_, ret) != SSL_ERROR_WANT_READ) {
state_ = Error;
onError();
}
}
ByteArray OpenSSLContext::getFinishMessage() const {
ByteArray data;
data.resize(MAX_FINISHED_SIZE);
size_t size = SSL_get_finished(handle_, data.getData(), data.getSize());
data.resize(size);
return data;
}
void dataReceived(ASocket* socket, ByteArray& data, uint32 totalSize) {
uint32 code;
bool ok = T::getHeaderInfos(data, code);
if (ok)
_delegate->packetInProgress(code, (float32)data.getSize() / totalSize);
}
void SDKControl::onSDKConfigGet(long long clientID, SDKConfigMessage* data)
{
auto client(GameServer::getInstance()->getLogicServer()->getClient(clientID));
if (!client)
{
Log::w("client is disconnect before sql execute");
return;
}
SDKConfigMessage* replyData = data;
if (!data)
{
replyData = new SDKConfigMessage;
}
ByteArray packet;
MessageHead head;
head.command = CMD_S2C_SDK_CONFIG;
head.pack(packet);
replyData->pack(packet);
// rewrite packet size
head.packSize = (unsigned short)packet.getSize();
packet.position = 0;
head.pack(packet);
client->send(packet);
client->flush();
if (!data)
{
delete replyData;
}
}
void OpenSSLContext::handleDataFromApplication(const ByteArray& data) {
if (SSL_write(handle_, data.getData(), data.getSize()) >= 0) {
sendPendingDataToNetwork();
}
else {
state_ = Error;
onError();
}
}
//------------------------------------------------------------------------------
void Usb::interruptHandler(ByteArray& byteArray)
{
int size = byteArray.getSize();
for (int i = 0; i < size; i++)
{
myRxBuffer.write(byteArray[i]);
}
}
void ByteArray::append(ByteArray const& cpy) {
uint64 bufsize = cpy.getSize();
uint64 pos = getSize();
std::vector<char> buf = cpy.getBuffer();
_buffer->resize(getSize() + bufsize);
for (uint32 i = 0; i < bufsize; ++i)
(*_buffer)[pos++] = buf[i];
}
bool Bullet::init(IGame* game, ByteArray const& params, float32 xStart) {
if ((_game = game) == NULL) {
return (false);
}
std::stringstream data(std::stringstream::binary | std::stringstream::in | std::stringstream::out);
data.write(params.getData(), params.getSize());
Vec2 size;
Vec3 from;
Vec2 to;
char *spriteName;
uint32 spriteSize;
char frameIndex;
_xStart = xStart;
data.read(reinterpret_cast<char*>(&spriteSize), sizeof(spriteSize));
spriteName = new char[spriteSize];
data.read(spriteName, spriteSize*sizeof(*spriteName));
std::string name = std::string(spriteName, spriteSize);
delete []spriteName;
data.read(reinterpret_cast<char*>(&frameIndex), sizeof(frameIndex));
data.read(reinterpret_cast<char*>(&size), sizeof(size));
data.read(reinterpret_cast<char*>(&from), sizeof(from));
data.read(reinterpret_cast<char*>(&_direction), sizeof(_direction));
_direction.normalize();
data.read(reinterpret_cast<char*>(&_speed), sizeof(_speed));
ISprite *sprite = _game->getLevelSprite(name);
if (sprite == NULL)
return false;
if ((_graphicElement = game->createGraphicElement()) == NULL)
return false;
if ((_physicElement = game->createPhysicElement()) == NULL)
return false;
_graphicElement->setPosition(from);
_graphicElement->setSize(size);
_graphicElement->setRotation(0);
_graphicElement->setSprite(sprite);
_graphicElement->setSpriteFrameIndex(frameIndex);
_graphicElement->setType(IGraphicElement::Static);
game->addGraphicElement(_graphicElement);
_physicElement->setPosition(from);
_physicElement->setSize(size);
_physicElement->setRotation(0);
_physicElement->setType(IPhysicElement::Static);
game->addPhysicElement(_physicElement);
return true;
}
bool ByteArray::operator!=(ByteArray const& cmp) {
uint64 bufsize = cmp.getSize();
uint64 currentSize = getSize();
if (bufsize != currentSize)
return true;
std::vector<char> buf = cmp.getBuffer();
for (uint32 i = 0; i < bufsize; ++i)
if (buf[i] != _buffer->at(i))
return true;
return false;
}
OpenSSLCertificate::OpenSSLCertificate(const ByteArray& der) {
#if OPENSSL_VERSION_NUMBER <= 0x009070cfL
unsigned char* p = const_cast<unsigned char*>(der.getData());
#else
const unsigned char* p = der.getData();
#endif
cert = boost::shared_ptr<X509>(d2i_X509(NULL, &p, der.getSize()), X509_free);
if (!cert) {
SWIFT_LOG(warning) << "Error creating certificate from DER data" << std::endl;
}
parse();
}
ByteArray* AUdpSocketIO::getData(void) {
SCOPELOCK(this);
if (!(this->_input.first.empty())) {
ByteArray* datagram = this->_input.first.front();
this->_input.first.pop();
this->_input.second -= datagram->getSize();
return datagram;
} else {
return nullptr;
}
}
//------------------------------------------------------------------------------
bool ImuSetConfigResponseBinaryMessage::parseMessageData(const ByteArray& data)
{
if (data.getSize() < 1)
{
return false;
}
ByteArrayParser byteArrayParser(data,
ENDIAN_BIG,
ByteArrayParser::PARSE_DIRECTION_FORWARD);
return (byteArrayParser.parse(myMessage.error));
}
void OpenSSLContext::handleDataFromNetwork(const ByteArray& data) {
BIO_write(readBIO_, data.getData(), data.getSize());
switch (state_) {
case Connecting:
doConnect();
break;
case Connected:
sendPendingDataToApplication();
break;
case Start: assert(false); break;
case Error: /*assert(false);*/ break;
}
}
void Graphic::Image::loadFromData(ByteArray const& data) {
sf::Image image;
if (!image.loadFromMemory((void*)data.getData(), data.getSize())) {
throw new Graphic::Exception("Cannot load image from data");
}
_width = image.getSize().x;
_height = image.getSize().y;
uint32 dataSize = _width * _height * 4;
if (_pixels)
delete[] _pixels;
_pixels = new uint8[dataSize];
memcpy((void*)_pixels, image.getPixelsPtr(), dataSize);
}
//------------------------------------------------------------------------------
SerialPort::Error SerialPortWindows::driverTx(const ByteArray& byteArray)
{
DWORD bytesWritten = 0;
if (!WriteFile(mySerialHandle,
byteArray.getDataConst(),
byteArray.getSize(),
&bytesWritten,
NULL))
{
return Error(ERROR_CODE_TX_FAILED);
}
return Error(ERROR_CODE_NONE);
}
//------------------------------------------------------------------------------
SerialPort::Error SerialPortWindows::driverGetRxBytes(ByteArray& byteArray,
const unsigned int nBytes)
{
DWORD bytesReceived = 0;
// TODO Fix this so it's non-blocking (overlapped I/O?)...
if (!SetCommMask(mySerialHandle, EV_RXCHAR))
{
// Error?
}
// DWORD dwCommEvent;
//
// if (!WaitCommEvent(mySerialHandle, &dwCommEvent, NULL))
// {
// return Error(ERROR_CODE_RX_FAILED);
// }
if (nBytes == 0)
{
// byteArray.setSize(driverRxBytesAvailable());
if (!ReadFile(mySerialHandle,
byteArray.getData(),
byteArray.getSize(),
&bytesReceived,
NULL))
{
return Error(ERROR_CODE_RX_FAILED);
}
}
else
{
if (!ReadFile(mySerialHandle,
byteArray.getData(),
nBytes,
&bytesReceived,
NULL))
{
return Error(ERROR_CODE_RX_FAILED);
}
}
byteArray.setSize(bytesReceived);
return Error(ERROR_CODE_NONE);
}
boost::optional<ByteArray> SCRAMSHA1ClientAuthenticator::getResponse() const {
if (step == Initial) {
return getGS2Header() + getInitialBareClientMessage();
}
else if (step == Proof) {
ByteArray clientKey = HMACSHA1::getResult(saltedPassword, "Client Key");
ByteArray storedKey = SHA1::getHash(clientKey);
ByteArray clientSignature = HMACSHA1::getResult(storedKey, authMessage);
ByteArray clientProof = clientKey;
for (unsigned int i = 0; i < clientProof.getSize(); ++i) {
clientProof[i] ^= clientSignature[i];
}
ByteArray result = getFinalMessageWithoutProof() + ",p=" + Base64::encode(clientProof);
return result;
}
else {
return boost::optional<ByteArray>();
}
}
void ConsoleProfiler::onTimer1000()
{
ServerSocket* logicServer = GameServer::getInstance()->getLogicServer();
ServerSocket* consoleServer = GameServer::getInstance()->getConsoleServer();
DBQueue* dbQueue = GameServer::getInstance()->getDBQueue();
ByteArray packet;
MessageHead head;
head.command = CMD_CONSOLE_SUBSCRIBE;
head.pack(packet);
ConsoleSubscribeMessage msg;
msg.memoryPeak = Profiler::getPeakRSS();
msg.memoryUsed = Profiler::getCurrentRSS();
msg.numDBRequests = dbQueue->getQueueLength();
msg.numOnline = logicServer->numOnlines();
#ifdef _WIN32
msg.ioDataPoolSize = logicServer->getIODataPoolSize();
msg.ioDataPostedSize = logicServer->getIODataPostedSize();
#endif
msg.pack(packet);
head.packSize = packet.getSize();
packet.position = 0;
head.pack(packet);
auto iter = allSubscribe.begin();
while (iter != allSubscribe.end())
{
long long clientID = *iter;
auto client = consoleServer->getClient(clientID);
if (!client)
{
iter = allSubscribe.erase(iter);
}
else
{
client->send(packet);
client->flush();
++iter;
}
}
}
//------------------------------------------------------------------------------
bool ImuGetConfigResponseBinaryMessage::parseMessageData(const ByteArray& data)
{
if (data.getSize() < 26)
{
return false;
}
ByteArrayParser byteArrayParser(data,
ENDIAN_BIG,
ByteArrayParser::PARSE_DIRECTION_FORWARD);
return (byteArrayParser.parse(myMessage.index) &&
byteArrayParser.parse(myMessage.measurementMode) &&
byteArrayParser.parse(myMessage.accelMeasurementRange) &&
byteArrayParser.parse(myMessage.accelMeasurementRateHz) &&
byteArrayParser.parse(myMessage.gyroMeasurementRange) &&
byteArrayParser.parse(myMessage.gyroMeasurementRateHz) &&
byteArrayParser.parse(myMessage.magMeasurementRange) &&
byteArrayParser.parse(myMessage.magMeasurementRateHz));
}
LinkLocalServiceInfo LinkLocalServiceInfo::createFromTXTRecord(const ByteArray& record) {
LinkLocalServiceInfo info;
size_t i = 0;
while (i < record.getSize()) {
std::pair<std::string,std::string> entry = readEntry(record, &i);
if (entry.first.empty()) {
break;
}
else if (entry.first == "1st") {
info.setFirstName(entry.second);
}
else if (entry.first == "last") {
info.setLastName(entry.second);
}
else if (entry.first == "email") {
info.setEMail(entry.second);
}
else if (entry.first == "jid") {
info.setJID(JID(entry.second));
}
else if (entry.first == "msg") {
info.setMessage(entry.second);
}
else if (entry.first == "nick") {
info.setNick(entry.second);
}
else if (entry.first == "port.p2pj") {
info.setPort(boost::lexical_cast<int>(entry.second));
}
else if (entry.first == "status") {
if (entry.second == "away") {
info.setStatus(Away);
}
else if (entry.second == "dnd") {
info.setStatus(DND);
}
}
}
return info;
}
std::pair<std::string,std::string> LinkLocalServiceInfo::readEntry(const ByteArray& record, size_t* index) {
size_t& i = *index;
std::string key;
std::string value;
size_t entryEnd = i + 1 + record[i];
++i;
bool inKey = true;
while (i < entryEnd && i < record.getSize()) {
if (inKey) {
if (record[i] == '=') {
inKey = false;
}
else {
key += record[i];
}
}
else {
value += record[i];
}
++i;
}
return std::make_pair(key, value);
}
void OpenSSLCertificate::parse() {
if (!cert) {
return;
}
// Subject name
X509_NAME* subjectName = X509_get_subject_name(cert.get());
if (subjectName) {
// Subject name
ByteArray subjectNameData;
subjectNameData.resize(256);
X509_NAME_oneline(X509_get_subject_name(cert.get()), reinterpret_cast<char*>(subjectNameData.getData()), subjectNameData.getSize());
this->subjectName = std::string(reinterpret_cast<const char*>(subjectNameData.getData()));
// Common name
int cnLoc = X509_NAME_get_index_by_NID(subjectName, NID_commonName, -1);
while (cnLoc != -1) {
X509_NAME_ENTRY* cnEntry = X509_NAME_get_entry(subjectName, cnLoc);
ASN1_STRING* cnData = X509_NAME_ENTRY_get_data(cnEntry);
commonNames.push_back(ByteArray(cnData->data, cnData->length).toString());
cnLoc = X509_NAME_get_index_by_NID(subjectName, NID_commonName, cnLoc);
}
}
// subjectAltNames
int subjectAltNameLoc = X509_get_ext_by_NID(cert.get(), NID_subject_alt_name, -1);
if(subjectAltNameLoc != -1) {
X509_EXTENSION* extension = X509_get_ext(cert.get(), subjectAltNameLoc);
boost::shared_ptr<GENERAL_NAMES> generalNames(reinterpret_cast<GENERAL_NAMES*>(X509V3_EXT_d2i(extension)), GENERAL_NAMES_free);
boost::shared_ptr<ASN1_OBJECT> xmppAddrObject(OBJ_txt2obj(ID_ON_XMPPADDR_OID, 1), ASN1_OBJECT_free);
boost::shared_ptr<ASN1_OBJECT> dnsSRVObject(OBJ_txt2obj(ID_ON_DNSSRV_OID, 1), ASN1_OBJECT_free);
for (int i = 0; i < sk_GENERAL_NAME_num(generalNames.get()); ++i) {
GENERAL_NAME* generalName = sk_GENERAL_NAME_value(generalNames.get(), i);
if (generalName->type == GEN_OTHERNAME) {
OTHERNAME* otherName = generalName->d.otherName;
if (OBJ_cmp(otherName->type_id, xmppAddrObject.get()) == 0) {
// XmppAddr
if (otherName->value->type != V_ASN1_UTF8STRING) {
continue;
}
ASN1_UTF8STRING* xmppAddrValue = otherName->value->value.utf8string;
addXMPPAddress(ByteArray(ASN1_STRING_data(xmppAddrValue), ASN1_STRING_length(xmppAddrValue)).toString());
}
else if (OBJ_cmp(otherName->type_id, dnsSRVObject.get()) == 0) {
// SRVName
if (otherName->value->type != V_ASN1_IA5STRING) {
continue;
}
ASN1_IA5STRING* srvNameValue = otherName->value->value.ia5string;
addSRVName(ByteArray(ASN1_STRING_data(srvNameValue), ASN1_STRING_length(srvNameValue)).toString());
}
}
else if (generalName->type == GEN_DNS) {
// DNSName
addDNSName(ByteArray(ASN1_STRING_data(generalName->d.dNSName), ASN1_STRING_length(generalName->d.dNSName)).toString());
}
}
}
}
//------------------------------------------------------------------------------
ComProtocol::ParseStatus ComProtocolNmea::driverParseData(
const ByteArray& rxByteArray,
ByteArray& txByteArray,
unsigned int& bytesConsumed)
{
int startIndex = 0;
int i;
int nRxBytes = rxByteArray.getSize();
ParseStatus parseStatus = PARSE_STATUS_MID_MESSAGE;
bytesConsumed = 0;
if (nRxBytes < startFlagSize)
{
return PARSE_STATUS_MID_MESSAGE;
}
// Look through all incoming bytes for start flag
while (startIndex < nRxBytes)
{
// Look for start flag
for (i = startIndex; i < nRxBytes; i++)
{
if (memcmp(&(rxByteArray[i]), startFlag, startFlagSize) == 0)
{
break;
}
}
// If true, we've searched beyond the end of the message
if (i == nRxBytes)
{
bytesConsumed = rxByteArray.getSize();
return PARSE_STATUS_NOT_A_MESSAGE;
}
startIndex = i + startFlagSize;
// Look for end flag
for (i = startIndex; i < nRxBytes; i++)
{
if (memcmp(&(rxByteArray[i]), endFlag, endFlagSize) == 0)
{
break;
}
}
// If true, we've searched beyond the end of the message
if (i == nRxBytes)
{
return PARSE_STATUS_MID_MESSAGE;
}
int endIndex = i;
Message message;
// Look for message string
for (i = 0; i < ARRAY_SIZE(messageStringMap); i++)
{
if (memcmp(&(rxByteArray[startIndex]),
messageStringMap[i],
strlen(messageStringMap[i])) == 0)
{
break;
}
}
// Verify message string was found
if (i == ARRAY_SIZE(messageStringMap))
{
parseStatus = PARSE_STATUS_INVALID_MESSAGE;
bytesConsumed += endIndex - startIndex + endFlagSize + 1;
}
else
{
message = (Message) i;
// Bytes are consumed whether message is supported or not
bytesConsumed += endIndex - startIndex + 1;
switch (message)
{
case MESSAGE_GSA:
{
ByteArray messageByteArray =
rxByteArray.subArray(startIndex + 6,
endIndex - startIndex - 6 + 1);
parseStatus = parseGsaMessage(messageByteArray);
break;
}
case MESSAGE_RMC:
{
ByteArray messageByteArray =
rxByteArray.subArray(startIndex + 6,
endIndex - startIndex - 6 + 1);
parseStatus = parseRmcMessage(messageByteArray);
break;
}
default:
{
parseStatus = PARSE_STATUS_UNSUPPORTED_MESSAGE;
break;
}
}
}
startIndex = endIndex + endFlagSize + 1;
}
return parseStatus;
}
//------------------------------------------------------------------------------
Usb::Error UsbStm32f4xx::driverTx(const ByteArray& byteArray)
{
VCP_DataTx(byteArray.getItems(), byteArray.getSize());
return ERROR_NONE;
}
