void UDPEchoClient::onReadyRead () { { LockGuard guard (mMutex); if (mState != WAIT) return; // ignoring; timeout. // Check protocol String from; int fromPort; ByteArrayPtr data = mSocket.recvFrom(&from,&fromPort); if (!data) { Log (LogWarning) << LOGID << "Could not read any data tough readyRead() signal" << std::endl; return; // ? } String toParse (data->const_c_array(), data->size()); ArgumentList list; sf::argSplit (toParse, &list); // Format: TOKEN IP-Address Port if (list.size() != 4 || list[0] != "condataReply") { Log (LogInfo) << LOGID << "Invalid protocol in answer " << *data << ", token=" << list.size() << std::endl; return; // invalid protocol } if (list[1] != mToken){ Log (LogInfo) << LOGID << "Token mismatch in answer " << *data << std::endl; return; // invalid token } mState = READY; mAddress = list[2]; mPort = atoi (list[3].c_str()); Log (LogInfo) << LOGID << "Successfully decoded echo answer: " << mAddress << ":" << mPort << " coming from " << from << ":" << fromPort << std::endl; sf::cancelTimer(mTimeoutHandle); } mResultDelegate (NoError); }
void SocketMessage::setPayload(const ByteArrayPtr &msg) { clear(); payload_type=Variant::TYPE_BYTEARRAY; payload_size=msg.size(); payload=malloc(payload_size); if (!payload) throw OutOfMemoryException(); memcpy(payload,msg.ptr(),payload_size); }
sf::ByteArrayPtr BoshTransport::read (long maxSize) { ByteArrayPtr result = sf::createByteArrayPtr(); if (maxSize < 0 || maxSize >= (long) mInputBuffer.size()) { result->swap (mInputBuffer); } else { result->append (mInputBuffer.const_c_array(), maxSize); mInputBuffer.l_truncate(maxSize); } return result; }
/// Eat something what was written ByteArrayPtr consume (long maxSize = -1) { if (mIngoingBuffer.empty()) return ByteArrayPtr(); ByteArrayPtr result = createByteArrayPtr(); if (maxSize < 0 || maxSize >= (int64_t) mIngoingBuffer.size()){ result->swap (mIngoingBuffer); return result; } result->assign (mIngoingBuffer.begin(), mIngoingBuffer.begin() + maxSize); mIngoingBuffer.l_truncate (maxSize); notifyAsync (mChanged); return result; }
void XMPPStream::onChannelChange () { ByteArrayPtr data = mChannel->read(); if (data && data->size() > 0){ #ifndef NDEBUG Log (LogInfo) << LOGID << "recv " << *data << std::endl; #endif mXmlStreamDecoder.onWrite(*data); } // mXmlStreamDecoder can remove the channel by its own callbacks! if (mChannel && mChannel->error()) { onChannelError (mChannel->error()); } }
virtual sf::Error read (const ds::Range & range, ByteArray & dst) { LockGuard guard (mMutex); ds::Range realRange = ds::Range (range.from - mPosition, range.to - mPosition); if (realRange.from != 0) return error::NotSupported; // no seeking ByteArrayPtr data = mChannel->read (range.to); if (data) { dst.swap (*data); } if (!data || data->empty()){ mReady = false; } mPosition+=dst.size(); return mChannel->error(); }
void LocalChannel::incoming (ByteArrayPtr data){ if (mCollector) mCollector->addPendingData (data->size()); mInputBuffer.append(*data); if (mChanged) { xcall (mChanged); } }
Error LocalChannel::write (const ByteArrayPtr& data, const ResultCallback & callback) { if (!mOther) return error::NotInitialized; // no target mOther->incoming (data); if (callback) xcall (abind (callback, NoError)); if (mCollector) mCollector->addTransferred (mHostId, mOther->hostId(), data->size(), mHops); return NoError; }
sf::Error write (const ds::Range & range, const ByteArrayPtr & data) { LockGuard guard (mMutex); ds::Range realRange = ds::Range (range.from - mWritePosition, range.to - mWritePosition); if (realRange.from != 0) { // no seeking return error::NotSupported; } mWritePosition+=data->size(); return mChannel->write (data); }
ByteArrayPtr Datagram::encode () const { // simple encoding headerLength, contentLength, header, content // both with 4 bytes size_t headerLength = mHeader ? mHeader->size() : 0; if (headerLength > 2147483647) { Log (LogError) << LOGID << "Header to long!" << std::endl; assert (false); return ByteArrayPtr(); } size_t contentLength = mContent ? mContent->size() : 0; if (contentLength > 2147483647) { Log (LogError) << LOGID << "Content to long" << std::endl; assert (false); return ByteArrayPtr(); } uint32_t hln = htonl ((uint32_t)headerLength); uint32_t cln = htonl ((uint32_t)contentLength); ByteArrayPtr dest = createByteArrayPtr (); dest->reserve(8 + headerLength + contentLength); dest->append((const char*) &hln, 4); dest->append((const char*) &cln, 4); if (mHeader) dest->append(*mHeader); if (mContent) dest->append(*mContent); assert (dest->size() == 8 + headerLength + contentLength); return dest; }
void HttpConnectionManager::onChannelChange (AsyncOpId id) { PendingConnectionOp * op; getReadyAsyncOp (id, PendingConnection, &op); if (!op) return; ByteArrayPtr all = op->connection->channel->read(); if (all && !all->empty()){ Log (LogInfo) << LOGID << "Recv in pending connection: " << *all << std::endl; op->connection->inputBuffer.append(*all); } Error e = op->connection->channel->error(); if (e) { // adieu Log (LogInfo) << LOGID << "Closing channel to " << op->connection->host << " as channel reported error: " << toString (e) << std::endl; xcall (abind (&throwAway, op->connection)); removeFromPendingConnections (op); delete op; return; } // data ready? nobody knows, add it again... addAsyncOp (op); }
/*!\brief Nutzdaten des Chunks setzen * * \desc * Mit dieser Funktion werden die Nutzdaten des Chunks angegeben. Die * Daten werden dabei in einen eigenen Speicherbereich kopiert. * * \param data Eine Referenz aif ein ByteArray oder ByteArrayPtr * \exception NullPointerException Wird geworfen, wenn \p ptr auf NULL zeigt * \exception OutOfMemoryException Nicht genug Speicher */ void PFPChunk::setData(const ByteArrayPtr &data) { setData(data.ptr(),data.size()); }