QString AddressManager::pathForPositionAndOrientation(const glm::vec3& position, bool hasOrientation, const glm::quat& orientation) { QString pathString = "/" + createByteArray(position); if (hasOrientation) { QString orientationString = createByteArray(orientation); pathString += "/" + orientationString; } return pathString; }
CapsInfo CapsInfoGenerator::generateCapsInfo(const DiscoInfo& discoInfo) const { std::string serializedCaps; std::vector<DiscoInfo::Identity> identities(discoInfo.getIdentities()); std::sort(identities.begin(), identities.end()); for (const auto& identity : identities) { serializedCaps += identity.getCategory() + "/" + identity.getType() + "/" + identity.getLanguage() + "/" + identity.getName() + "<"; } std::vector<std::string> features(discoInfo.getFeatures()); std::sort(features.begin(), features.end()); for (const auto& feature : features) { serializedCaps += feature + "<"; } for (const auto& extension : discoInfo.getExtensions()) { serializedCaps += extension->getFormType() + "<"; std::vector<FormField::ref> fields(extension->getFields()); std::sort(fields.begin(), fields.end(), &compareFields); for (const auto& field : fields) { if (field->getName() == "FORM_TYPE") { continue; } serializedCaps += field->getName() + "<"; std::vector<std::string> values(field->getValues()); std::sort(values.begin(), values.end()); for (const auto& value : values) { serializedCaps += value + "<"; } } } std::string version(Base64::encode(crypto_->getSHA1Hash(createByteArray(serializedCaps)))); return CapsInfo(node_, version, "sha-1"); }
void Profile::updatePosition(const glm::vec3 position) { if (_lastPosition != position) { static timeval lastPositionSend = {}; const quint64 DATA_SERVER_POSITION_UPDATE_INTERVAL_USECS = 5 * 1000 * 1000; const float DATA_SERVER_POSITION_CHANGE_THRESHOLD_METERS = 1; if (usecTimestampNow() - usecTimestamp(&lastPositionSend) >= DATA_SERVER_POSITION_UPDATE_INTERVAL_USECS && (fabsf(_lastPosition.x - position.x) >= DATA_SERVER_POSITION_CHANGE_THRESHOLD_METERS || fabsf(_lastPosition.y - position.y) >= DATA_SERVER_POSITION_CHANGE_THRESHOLD_METERS || fabsf(_lastPosition.z - position.z) >= DATA_SERVER_POSITION_CHANGE_THRESHOLD_METERS)) { // if it has been 5 seconds since the last position change and the user has moved >= the threshold // in at least one of the axis then send the position update to the data-server _lastPosition = position; // update the lastPositionSend to now gettimeofday(&lastPositionSend, NULL); // send the changed position to the data-server DataServerClient::putValueForKeyAndUserString(DataServerKey::Position, QString(createByteArray(position)), getUserString()); } } }
ByteArray DIGESTMD5Properties::serialize() const { ByteArray result; for(DIGESTMD5PropertiesMap::const_iterator i = properties.begin(); i != properties.end(); ++i) { if (i != properties.begin()) { result.push_back(','); } append(result, createByteArray(i->first)); result.push_back('='); if (isQuoted(i->first)) { append(result, createByteArray("\"")); append(result, i->second); append(result, createByteArray("\"")); } else { append(result, i->second); } } return result; }
void SOCKS5BytestreamClientSession::handleDataRead(boost::shared_ptr<SafeByteArray> data) { SWIFT_LOG(debug) << "state: " << state << " data.size() = " << data->size() << std::endl; if (state != Reading) { append(unprocessedData, *data); process(); } else { writeBytestream->write(createByteArray(vecptr(*data), data->size())); //onBytesReceived(data->size()); } }
void SOCKS5BytestreamClientSession::authenticate() { SWIFT_LOG(debug) << std::endl; SafeByteArray header = createSafeByteArray("\x05\x01\x00\x03", 4); SafeByteArray message = header; append(message, createSafeByteArray(boost::numeric_cast<char>(destination.size()))); authenticateAddress = createByteArray(destination); append(message, authenticateAddress); append(message, createSafeByteArray("\x00\x00", 2)); // 2 byte for port connection->write(message); state = Authenticating; }
const QString AddressManager::currentPath(bool withOrientation) const { if (_positionGetter) { QString pathString = "/" + createByteArray(_positionGetter()); if (withOrientation) { if (_orientationGetter) { QString orientationString = createByteArray(_orientationGetter()); pathString += "/" + orientationString; } else { qCDebug(networking) << "Cannot add orientation to path without a getter for position." << "Call AddressManager::setOrientationGetter to pass a function that will return a glm::quat"; } } return pathString; } else { qCDebug(networking) << "Cannot create address path without a getter for position." << "Call AddressManager::setPositionGetter to pass a function that will return a const glm::vec3&"; return QString(); } }
RefPtr<TTObject> TTLiteral::createByteArray(const std::vector<uint8_t> &bytes) { RefPtr<TTObject> obj = createByteArray(bytes.size()); uint8_t *dataBytes = obj->getLiteral()->data; for(auto &byt : bytes) { *dataBytes = byt; dataBytes++; } return obj; }
static std::string getCertUri(PCCERT_CONTEXT cert, const char * cert_store_name) { DWORD cbHash = SHA1_HASH_LENGTH; BYTE aHash[SHA1_HASH_LENGTH]; std::string result("certstore:"); result += cert_store_name; result += ":sha1:"; if (CertGetCertificateContextProperty(cert, CERT_HASH_PROP_ID, aHash, &cbHash) == FALSE ) { return ""; } ByteArray byteArray = createByteArray((char *)(&aHash[0]), cbHash); result += Hexify::hexify(byteArray); return result; }
void BOSHConnection::handleDataRead(std::shared_ptr<SafeByteArray> data) { onBOSHDataRead(*data); buffer_ = concat(buffer_, *data); std::string response = safeByteArrayToString(buffer_); if (response.find("\r\n\r\n") == std::string::npos) { onBOSHDataRead(createSafeByteArray("[[Previous read incomplete, pending]]")); return; } std::string httpCode = response.substr(response.find(" ") + 1, 3); if (httpCode != "200") { onHTTPError(httpCode); return; } BOSHBodyExtractor parser(parserFactory_, createByteArray(response.substr(response.find("\r\n\r\n") + 4))); if (parser.getBody()) { if (parser.getBody()->attributes.getAttribute("type") == "terminate") { BOSHError::Type errorType = parseTerminationCondition(parser.getBody()->attributes.getAttribute("condition")); onSessionTerminated(errorType == BOSHError::NoError ? std::shared_ptr<BOSHError>() : std::make_shared<BOSHError>(errorType)); } buffer_.clear(); if (waitingForStartResponse_) { waitingForStartResponse_ = false; sid_ = parser.getBody()->attributes.getAttribute("sid"); std::string requestsString = parser.getBody()->attributes.getAttribute("requests"); size_t requests = 2; if (!requestsString.empty()) { try { requests = boost::lexical_cast<size_t>(requestsString); } catch (const boost::bad_lexical_cast&) { } } onSessionStarted(sid_, requests); } SafeByteArray payload = createSafeByteArray(parser.getBody()->content); /* Say we're good to go again, so don't add anything after here in the method */ pending_ = false; onXMPPDataRead(payload); } }
void SOCKS5BytestreamClientSession::process() { SWIFT_LOG(debug) << "unprocessedData.size(): " << unprocessedData.size() << std::endl; ByteArray bndAddress; switch(state) { case Initial: hello(); break; case Hello: if (unprocessedData.size() > 1) { unsigned char version = unprocessedData[0]; unsigned char authMethod = unprocessedData[1]; if (version != 5 || authMethod != 0) { // signal failure to upper level finish(true); return; } unprocessedData.clear(); authenticate(); } break; case Authenticating: if (unprocessedData.size() < 5) { // need more data to start progressing break; } if (unprocessedData[0] != '\x05') { // wrong version // disconnect & signal failure finish(true); break; } if (unprocessedData[1] != '\x00') { // no success // disconnect & signal failure finish(true); break; } if (unprocessedData[3] != '\x03') { // we expect x'03' = DOMAINNAME here // discconect & signal failure finish(true); break; } if (static_cast<size_t>(unprocessedData[4]) + 1 > unprocessedData.size() + 5) { // complete domainname and port not available yet break; } bndAddress = createByteArray(&vecptr(unprocessedData)[5], unprocessedData[4]); if (unprocessedData[unprocessedData[4] + 5] != 0 && bndAddress == createByteArray(destination)) { // we expect a 0 as port // disconnect and fail finish(true); } unprocessedData.clear(); state = Ready; SWIFT_LOG(debug) << "session ready" << std::endl; // issue ready signal so the bytestream can be used for reading or writing weFailedTimeout->stop(); onSessionReady(false); break; case Ready: SWIFT_LOG(debug) << "Received further data in Ready state." << std::endl; break; case Reading: case Writing: case Finished: SWIFT_LOG(debug) << "Unexpected receive of data. Current state: " << state << std::endl; SWIFT_LOG(debug) << "Data: " << Hexify::hexify(unprocessedData) << std::endl; unprocessedData.clear(); //assert(false); } }
void DIGESTMD5Properties::setValue(const std::string& key, const std::string& value) { properties.insert(DIGESTMD5PropertiesMap::value_type(key, createByteArray(value))); }
std::string SOCKS5BytestreamServer::getSOCKSDestinationAddress(const std::string& id, const JID& from, const JID& to) { return Hexify::hexify(SHA1::getHash(createByteArray(id + from.toString() + to.toString()))); }
void Profile::updateOrientation(const glm::quat& orientation) { glm::vec3 eulerAngles = safeEulerAngles(orientation); if (_lastOrientation == eulerAngles) { return; } const quint64 DATA_SERVER_ORIENTATION_UPDATE_INTERVAL_USECS = 5 * 1000 * 1000; const float DATA_SERVER_ORIENTATION_CHANGE_THRESHOLD_DEGREES = 5.0f; quint64 now = usecTimestampNow(); if (now - _lastOrientationSend >= DATA_SERVER_ORIENTATION_UPDATE_INTERVAL_USECS && glm::distance(_lastOrientation, eulerAngles) >= DATA_SERVER_ORIENTATION_CHANGE_THRESHOLD_DEGREES) { DataServerClient::putValueForKeyAndUserString(DataServerKey::Orientation, QString(createByteArray(eulerAngles)), getUserString()); _lastOrientation = eulerAngles; _lastOrientationSend = now; } }