const std::string toString() const {
std::ostringstream oss;
oss << "<RunInstancesResponse>\n"
<< " <requestId>" << requestId() << "</requestId>\n"
<< " <reservationId>" << reservationId() << "</reservationId>\n"
<< " <ownerId>" << ownerId() << "</ownerId>\n"
;
oss << " <groupSet>\n";
for ( std::vector<groupSet_t>::const_iterator item (_groupSet.begin())
; item != _groupSet.end()
; ++item
) {
oss<< " <item>\n " << *item << " </item>\n";
}
oss << " </groupSet>\n"
<< " <instancesSet>\n";
for ( std::vector<instancesSet_t>::const_iterator item (_instancesSet.begin())
; item != _instancesSet.end()
; ++item
) {
oss<< " <item>\n " << *item << " </item>\n";
}
oss << " </instancesSet>\n"
<< "</RunInstancesResponse>\n"
;
return oss.str();
}
const std::string toString() const {
std::ostringstream oss;
oss << "<Response>\n";
oss << " <Errors>\n" << error() << "</Errors>\n";
oss << " <RequestId>" << requestId() << "</RequestId>\n"
<< "</Response>\n"
;
return oss.str();
}
// -----------------------------------------------------------------------------
// CRegBindingImplementation::DoRegisterL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CRegBindingImplementation::DoRegisterL(CSIPMessageElements* aElements)
{
__TEST_INVARIANT;
CheckConnectionL();
CSIPClientTransaction* ta = CreateClientTransactionL();
CleanupStack::PushL(ta);
CSIPMessageElements* elem = aElements;
if (!aElements)
{
elem = CSIPMessageElements::NewLC();
}
//Put contact temporarily to elem. Once REGISTER is sent, clear it from elem
CleanupStack::PushL(TCleanupItem(DetachContactHeader, elem));
elem->AddHeaderL(iContact);
CSIPFromHeader* from = iFrom;
if (!iFrom)
{
from = CSIPFromHeader::NewLC(*iAor);
}
TUint32 requestId(0);
iConnection->Implementation().ClientConnectionL().SendRegisterL(requestId,
*iAor,
*from,
*elem,
iRemoteUri,
iOutboundProxy,
(iRefresh != NULL),
iSendWithExpires,
iCacheOutboundProxyIP);
if (!iFrom)
{
CleanupStack::PopAndDestroy(from);
}
CleanupStack::PopAndDestroy(); //TCleanupItem
if (aElements)
{
delete aElements;
}
else
{
CleanupStack::PopAndDestroy(elem);
}
CleanupStack::Pop(ta);
ta->SetRequestId(requestId);
__TEST_INVARIANT;
return ta;
}
void CSuplProxyPrivacySession::CompleteRequest(const RMessage2& aMessage)
{
LBSLOG(ELogP1, "CSuplProxyPrivacySession::CompleteRequest() Begin\n");
TUint32 requestId(aMessage.Int0());
TInt reason(aMessage.Int1());
iPrivacyProtocol.CompletePrivacyRequest(requestId, reason);
aMessage.Complete(KErrNone);
LBSLOG(ELogP1, "CSuplProxyPrivacySession::CompleteRequest() End\n");
}
QNearFieldTarget::RequestId NearFieldTarget::readNdefMessages()
{
// Making sure that target has NDEF messages
if (!hasNdefMessage())
return QNearFieldTarget::RequestId();
// Making sure that target is still in range
QNearFieldTarget::RequestId requestId(new QNearFieldTarget::RequestIdPrivate);
if (!m_intent.isValid()) {
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QNearFieldTarget::Error, QNearFieldTarget::TargetOutOfRangeError),
Q_ARG(const QNearFieldTarget::RequestId&, requestId));
return requestId;
}
// -----------------------------------------------------------------------------
// CNATTraversalNotIntegrated::ResolvePublicAddrL
// -----------------------------------------------------------------------------
//
TUint32 CNATTraversalNotIntegrated::ResolvePublicAddrL(
TUint32 aIapId,
RConnection& /*aConnection*/,
const TInetAddr& /*aLocalAddr*/,
const TDesC8& /*aDomain*/,
RSocket& /*aUdpSocket*/,
const TInetAddr& /*aNextHopAddr*/,
MSIPNATBindingObserver* /*aBindingObserver*/,
MSIPNATTraversalRequestObserver& aRequestObserver )
{
TUint32 requestId( NextRequestId() );
AddAsyncRequestL( aIapId, aRequestObserver, requestId );
return requestId;
}
// -----------------------------------------------------------------------------
// CRegBindingImplementation::DoUpdateL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CRegBindingImplementation::DoUpdateL(CSIPMessageElements* aElements,
TUint* aExpirationValue)
{
__TEST_INVARIANT;
CheckConnectionL();
CSIPClientTransaction* ta = CSIPClientTransaction::NewLC(
SIPStrings::StringF(SipStrConsts::ERegister),
*this);
CSIPMessageElements* elem = aElements;
if (!aElements)
{
elem = CSIPMessageElements::NewLC();
}
if (aExpirationValue)
{
iContact->SetExpiresParameterL(*aExpirationValue);
}
//Put contact temporarily to elem. Once REGISTER is sent, clear it from elem
CleanupStack::PushL(TCleanupItem(DetachContactHeader, elem));
elem->AddHeaderL(iContact);
TUint32 requestId(0);
iConnection->Implementation().ClientConnectionL().UpdateRegistrationL(
iRegistrationId,
requestId,
elem);
CleanupStack::PopAndDestroy(); //TCleanupItem
if (aElements)
{
delete aElements;
}
else
{
CleanupStack::PopAndDestroy(elem);
}
CleanupStack::Pop(ta);
ta->SetRequestId(requestId);
__TEST_INVARIANT;
return ta;
}
// -----------------------------------------------------------------------------
// CRegBindingImplementation::DoDeregisterL
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CRegBindingImplementation::DoDeregisterL(CSIPMessageElements* aElements)
{
__TEST_INVARIANT;
CheckConnectionL();
CSIPClientTransaction* ta = CSIPClientTransaction::NewLC(
SIPStrings::StringF(SipStrConsts::ERegister), *this);
TUint32 requestId(0);
iConnection->Implementation().ClientConnectionL().UnregisterL(
iRegistrationId,
requestId,
aElements);
CleanupStack::Pop(ta);
ta->SetRequestId(requestId);
delete aElements;
__TEST_INVARIANT;
return ta;
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::DoSendUnsubscribeL
// Sending (un)SUBSCRIBE does not terminate the dialog. (un)SUBSCRIBE is not a
// dialog creating request.
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CSIPSubscribeDialogAssoc::DoSendUnsubscribeL(CSIPMessageElements* aElements)
{
CSIPMessageElements* elem = aElements;
if (!aElements)
{
elem = CSIPMessageElements::NewLC();
}
TMessageHeaderCleanup headerCleanup(*elem);
TCleanupItem cleanupItem(TMessageHeaderCleanup::Cleanup, &headerCleanup);
if (aElements)
{
CleanupStack::PushL(cleanupItem);
}
CSIPDialogAssocImplementation::CopyHeaderL(*iEvent, *elem, headerCleanup);
RPointerArray<CSIPHeaderBase> expireHeaders = elem->UserHeadersL(
SIPStrings::StringF(SipStrConsts::EExpiresHeader));
CleanupClosePushL(expireHeaders);
TBool hasExpiresZero = EFalse;
TInt expiresHeaderCount = expireHeaders.Count();
__ASSERT_ALWAYS(expiresHeaderCount <= 1, User::Leave(KErrArgument));
if (expiresHeaderCount == 1)
{
CSIPExpiresHeader* expires =
static_cast<CSIPExpiresHeader*>(expireHeaders[0]);
__ASSERT_ALWAYS(expires->Value() == 0, User::Leave(KErrArgument));
hasExpiresZero = ETrue;
}
CleanupStack::PopAndDestroy(); //expireHeaders
if (!hasExpiresZero)
{
CSIPExpiresHeader* expires = new (ELeave) CSIPExpiresHeader(0);
CleanupStack::PushL(expires);
CSIPDialogAssocImplementation::CopyHeaderL(*expires,
*elem,
headerCleanup);
CleanupStack::PopAndDestroy(expires);
}
CSIPClientTransaction* ta =
CSIPClientTransaction::NewLC(Type(), Implementation(), iRefresh);
TUint32 requestId(0);
if (iRefresh)
{
//Terminates an existing refreshed subscription
Implementation().ClientConnectionL().SendRequestWithinDialogL(
Dialog().Implementation().DialogId(),
iRefresh->RefreshId(),
requestId,
elem);
}
else
{
TUint32 refreshId(0);
Implementation().ClientConnectionL().SendRequestWithinDialogL(
Dialog().Implementation().DialogId(),
requestId,
refreshId,
Type(),
elem,
CSIPTransactionBase::IsTargetRefresh(Type()));
}
CleanupStack::Pop(ta);
ta->SetRequestId(requestId);
//Take ownership of aElements when leave can't occur
delete elem;
CleanupStack::Pop(); //TCleanupItem or elem
return ta;
}
// -----------------------------------------------------------------------------
// CSIPSubscribeDialogAssoc::DoSendSubscribeL
// If subscription is already being refreshed, leaves with KErrAlreadyExists
// -----------------------------------------------------------------------------
//
CSIPClientTransaction*
CSIPSubscribeDialogAssoc::DoSendSubscribeL(CSIPMessageElements* aElements,
CSIPRefresh* aRefresh,
TBool aWithinDialog)
{
__ASSERT_ALWAYS(!(aRefresh && iRefresh), User::Leave(KErrAlreadyExists));
CSIPMessageElements* elem = aElements;
if (!aElements)
{
elem = CSIPMessageElements::NewLC();
}
TMessageHeaderCleanup headerCleanup(*elem);
TCleanupItem cleanupItem(TMessageHeaderCleanup::Cleanup, &headerCleanup);
if (aElements)
{
CleanupStack::PushL(cleanupItem);
}
CSIPDialogAssocImplementation::CopyHeaderL(*iEvent, *elem, headerCleanup);
CSIPClientTransaction* ta = NULL;
if (aWithinDialog)
{
ta = CSIPClientTransaction::NewLC(Type(),
Implementation(),
aRefresh ? aRefresh : iRefresh);
TUint32 requestId(0);
TUint32 refreshId(0);
if (iRefresh)
{
//Updates an existing refreshed subscription
Implementation().ClientConnectionL().SendRequestWithinDialogL(
Dialog().Implementation().DialogId(),
iRefresh->RefreshId(),
requestId,
elem);
}
else
{
Implementation().ClientConnectionL().SendRequestWithinDialogL(
Dialog().Implementation().DialogId(),
requestId,
refreshId,
Type(),
elem,
CSIPTransactionBase::IsTargetRefresh(Type()),
(aRefresh != NULL));
}
if (aRefresh)
{
aRefresh->SetRefreshIdIfEmpty(refreshId);
}
CleanupStack::Pop(ta);
ta->SetRequestId(requestId);
//Take ownership of aElements when leave can't occur
delete elem;
}
else
{
const CSIPContactHeader* contact =
Dialog().Implementation().ContactHeader();
if (contact)
{
CSIPDialogAssocImplementation::CopyHeaderL(*contact,
*elem,
headerCleanup);
}
ta = Dialog().Implementation().SendDialogCreatingRequestL(
Implementation(), elem, aRefresh);
}
CleanupStack::Pop(); //TCleanupItem or elem
if (aRefresh)
{
aRefresh->SetRequestType(Type());
iRefresh = aRefresh;
iRefresh->SetRefreshOwner(Implementation());
}
return ta;
}
std::vector<Message::Shared> ENetServer::poll()
{
std::vector<Message::Shared> msgs;
ENetEvent event;
while (true) {
// poll with a zero timeout
int32_t res = enet_host_service(host_, &event, 0);
if (res > 0) {
// event occured
if (event.type == ENET_EVENT_TYPE_RECEIVE) {
// received a packet
// LOG_DEBUG("A packet of length "
// << event.packet->dataLength
// << " containing `"
// << event.packet->data
// << "` was received from client_"
// << event.peer->incomingPeerID);
auto stream = StreamBuffer::alloc(
event.packet->data,
event.packet->dataLength);
// deserialize message
auto msg = Message::alloc(event.peer->incomingPeerID);
msg->deserialize(stream);
msgs.push_back(msg);
// handle requests
if (msg->type() == MessageType::DATA_REQUEST) {
handleRequest(
event.peer->incomingPeerID,
msg->requestId(),
msg->stream());
}
// destroy packet payload
enet_packet_destroy(event.packet);
} else if (event.type == ENET_EVENT_TYPE_CONNECT) {
// client connected
LOG_DEBUG("Client has connected from "
<< addressToString(&event.peer->address)
<< ", "
<< numClients()
<< " connected clients");
// add msg
auto msg = Message::alloc(
event.peer->incomingPeerID,
MessageType::CONNECT);
msgs.push_back(msg);
clients_[event.peer->incomingPeerID] = event.peer;
} else if (event.type == ENET_EVENT_TYPE_DISCONNECT) {
// client disconnected
LOG_DEBUG("Client has disconnected from "
<< addressToString(&event.peer->address)
<< ", "
<< numClients()
<< " clients remaining");
// add msg
auto msg = Message::alloc(
event.peer->incomingPeerID,
MessageType::DISCONNECT);
msgs.push_back(msg);
clients_.erase(event.peer->incomingPeerID);
}
} else if (res < 0) {
// error occured
LOG_ERROR("Encountered error while polling");
break;
} else {
// no event
break;
}
}
return msgs;
}
