|
1 /* |
|
2 * Copyright (c) 2006-2006 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 |
|
24 |
|
25 |
|
26 |
|
27 |
|
28 #include "wsstaraddressinghandler.h" |
|
29 #include "wsstarmessageutils.h" |
|
30 #include "SenXmlUtils.h" |
|
31 #include "sensaxutils.h" |
|
32 #include "senlogger.h" // private Utils\inc |
|
33 |
|
34 using namespace WSStarAddressing; |
|
35 using namespace WSStarAddressingFault; |
|
36 |
|
37 // Create instance of concrete ECOM interface implementation |
|
38 CWSStarAddressingHandler* CWSStarAddressingHandler::NewL(TAny* aHandlerCtx) |
|
39 { |
|
40 MSenHandlerContext* ctx = |
|
41 reinterpret_cast<MSenHandlerContext*>( aHandlerCtx); |
|
42 CWSStarAddressingHandler* self = new (ELeave) CWSStarAddressingHandler(*ctx); |
|
43 CleanupStack::PushL (self); |
|
44 self->ConstructL(); |
|
45 CleanupStack::Pop(self); |
|
46 return self; |
|
47 } |
|
48 |
|
49 TInt CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) |
|
50 { |
|
51 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx)"))); |
|
52 CSenSoapEnvelope* message = |
|
53 const_cast<CSenSoapEnvelope*>(aCtx.GetSenSoapEnvelopeL( |
|
54 SenContext::KSenCurrentSoapMessageCtxKey) |
|
55 ); |
|
56 TPtrC8 txtMessage = aCtx.GetMessageL(); |
|
57 InitVersionL(aCtx.GetDesC8L(WSStarContextKeys::KAddressingVersion)); |
|
58 if (message) |
|
59 { |
|
60 const CSenNamespace* nmSpace = message->Namespace(KAddressingPrefix); |
|
61 if (nmSpace) |
|
62 { |
|
63 InitVersionL(&nmSpace->URI()); |
|
64 } |
|
65 if (aCtx.Direction() == SenContext::EOutgoing) |
|
66 { |
|
67 return HandleOutboundL(aCtx, message); |
|
68 } |
|
69 else if (aCtx.Direction()==SenContext::EIncoming) |
|
70 { |
|
71 return HandleInboundL(aCtx, message); |
|
72 } |
|
73 else |
|
74 { |
|
75 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \ |
|
76 strange direction"))); |
|
77 return KErrNotFound; |
|
78 } |
|
79 } |
|
80 else if (txtMessage.Length()) |
|
81 { |
|
82 //---------------idea based on method |
|
83 /* |
|
84 TInt CSenWebServiceSession::HandleBodyWithoutParsingL(CSenSoapMessage& aMessage, |
|
85 const TDesC8& aResponse) |
|
86 */ |
|
87 TInt ret(KErrNone); |
|
88 TInt endTagStart; |
|
89 TInt endTagEnd; |
|
90 TInt startTagStart; |
|
91 TInt startTagEnd; |
|
92 TPtrC8 prefix; |
|
93 |
|
94 ret = SenSaxUtils::SearchEndTagL(txtMessage,KSenSoapEnvelopeBodyName, |
|
95 endTagStart, endTagEnd, prefix); |
|
96 if ( ret != KErrNotFound ) |
|
97 { |
|
98 ret = SenSaxUtils::SearchStartTagL(txtMessage,prefix,KSenSoapEnvelopeBodyName, |
|
99 startTagStart, startTagEnd); |
|
100 if ( ret != KErrNotFound ) |
|
101 { |
|
102 TPtrC8 startPart(txtMessage.Ptr(),startTagEnd+1); |
|
103 TPtrC8 endPart(txtMessage.Ptr()+endTagStart,txtMessage.Size()-endTagStart); |
|
104 HBufC8* pXmlWithoutBody = HBufC8::NewLC(startPart.Length()+endPart.Length()); |
|
105 pXmlWithoutBody->Des().Append(startPart); |
|
106 pXmlWithoutBody->Des().Append(endPart); |
|
107 |
|
108 CWSStarAddressingHeaderInbound* inbound = |
|
109 CWSStarAddressingHeaderInbound::NewLC(iVersion); |
|
110 inbound->SetMessageContext(aCtx); |
|
111 CSenXmlReader& reader = const_cast<CSenXmlReader&>(*aCtx.GetParser()); |
|
112 inbound->SetReader(reader); |
|
113 inbound->BuildFrom(*pXmlWithoutBody); |
|
114 CleanupStack::PopAndDestroy(inbound); |
|
115 |
|
116 |
|
117 CleanupStack::PopAndDestroy(pXmlWithoutBody); |
|
118 |
|
119 } |
|
120 } |
|
121 else//case with empty body - <S:Body/>, so we can parse all |
|
122 { |
|
123 CWSStarAddressingHeaderInbound* inbound = |
|
124 CWSStarAddressingHeaderInbound::NewLC(iVersion); |
|
125 inbound->SetMessageContext(aCtx); |
|
126 CSenXmlReader& reader = const_cast<CSenXmlReader&>(*aCtx.GetParser()); |
|
127 inbound->SetReader(reader); |
|
128 inbound->BuildFrom(txtMessage); |
|
129 CleanupStack::PopAndDestroy(inbound); |
|
130 } |
|
131 |
|
132 return ret; |
|
133 } |
|
134 else |
|
135 { |
|
136 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \ |
|
137 Soap message in message context not exists"))); |
|
138 return KErrNotFound; |
|
139 } |
|
140 } |
|
141 TInt CWSStarAddressingHandler::HandleInboundL(MSenMessageContext& aCtx, CSenSoapEnvelope* aMessage) |
|
142 { |
|
143 /* |
|
144 CWSStarAddressingHeaderInbound* inbound = CWSStarAddressingHeaderInbound::NewLC(iVersion); |
|
145 inbound->SetMessageContext(aCtx); |
|
146 CSenXmlReader& reader = const_cast<CSenXmlReader&>(*aCtx.GetParser()); |
|
147 inbound->SetReader(reader); |
|
148 HBufC8* buf = aMessage->AsXmlL(); |
|
149 CleanupStack::PushL(buf); |
|
150 inbound->BuildFrom(*buf); |
|
151 */ |
|
152 CSenElement& header = aMessage->HeaderL(); |
|
153 |
|
154 CSenElement* elem = NULL; |
|
155 CSenElement* addressElem = NULL; |
|
156 |
|
157 elem = CWSStarMessageUtils::FindElementL(KToName, header); |
|
158 if (elem) |
|
159 { |
|
160 const TDesC8& nsUri = elem->NamespaceURI(); |
|
161 if (!iVersion && (nsUri == KAddressingXmlns200408 || |
|
162 nsUri == KAddressingXmlns200403 || |
|
163 nsUri == KAddressingXmlns200412 || |
|
164 nsUri == KAddressingXmlns200502 || |
|
165 nsUri == KAddressingXmlns200503 || |
|
166 nsUri == KAddressingXmlns200508)) |
|
167 { |
|
168 iVersion = nsUri.AllocL(); |
|
169 } |
|
170 ((MSenContext&)aCtx).Update(WSStarContextKeys::KTo, elem->Content()); |
|
171 } |
|
172 elem = CWSStarMessageUtils::FindElementL(KRelatesToName, header); |
|
173 if (elem) |
|
174 { |
|
175 ((MSenContext&)aCtx).Update(WSStarContextKeys::KRelatesTo, elem->Content()); |
|
176 } |
|
177 elem = CWSStarMessageUtils::FindElementL(KMessageIDName, header); |
|
178 if (elem) |
|
179 { |
|
180 ((MSenContext&)aCtx).Update(WSStarContextKeys::KMessageID, elem->Content()); |
|
181 } |
|
182 elem = CWSStarMessageUtils::FindElementL(KActionName, header); |
|
183 if (elem) |
|
184 { |
|
185 ((MSenContext&)aCtx).Update(WSStarContextKeys::KAction, elem->Content()); |
|
186 } |
|
187 elem = CWSStarMessageUtils::FindElementL(WSStarAddressingEPR::KDeviceAddressName, header); |
|
188 if (elem) |
|
189 { |
|
190 ((MSenContext&)aCtx).Update(WSStarContextKeys::KReplyToDeviceAddress, elem->Content()); |
|
191 } |
|
192 |
|
193 elem = CWSStarMessageUtils::FindElementL(KReplyToName, header); |
|
194 if (elem) |
|
195 { |
|
196 addressElem = CWSStarMessageUtils::FindElementL(KAddressName, *elem); |
|
197 if (addressElem) |
|
198 { |
|
199 ((MSenContext&)aCtx).Update(WSStarContextKeys::KReplyTo, addressElem->Content()); |
|
200 } |
|
201 } |
|
202 elem = CWSStarMessageUtils::FindElementL(KFaultToName, header); |
|
203 if (elem) |
|
204 { |
|
205 addressElem = CWSStarMessageUtils::FindElementL(KAddressName, *elem); |
|
206 if (addressElem) |
|
207 { |
|
208 ((MSenContext&)aCtx).Update(WSStarContextKeys::KFaultTo, addressElem->Content()); |
|
209 } |
|
210 } |
|
211 elem = CWSStarMessageUtils::FindElementL(KFromName, header); |
|
212 if (elem) |
|
213 { |
|
214 addressElem = CWSStarMessageUtils::FindElementL(KAddressName, *elem); |
|
215 if (addressElem) |
|
216 { |
|
217 ((MSenContext&)aCtx).Update(WSStarContextKeys::KFrom, addressElem->Content()); |
|
218 } |
|
219 } |
|
220 _LIT8(Kpp, "pp"); |
|
221 _LIT8(KCredProperties, "credProperties"); |
|
222 _LIT8(KCredProperty, "credProperty"); |
|
223 _LIT8(KName, "Name"); |
|
224 CWSStarMessageUtils::RArraySenElements credPropertiesElements; |
|
225 CSenElement* ppElem = CWSStarMessageUtils::FindElementL(Kpp, header); |
|
226 if(ppElem) |
|
227 { |
|
228 CSenElement* credPropertiesElem = CWSStarMessageUtils::FindElementL(KCredProperties, *ppElem);//Naga |
|
229 if(credPropertiesElem) |
|
230 { |
|
231 CWSStarMessageUtils::FindElementL(KCredProperty, *credPropertiesElem, credPropertiesElements); |
|
232 TInt count = credPropertiesElements.Count(); |
|
233 for(TInt i=0; i<count; i++) |
|
234 { |
|
235 elem = credPropertiesElements[i]; |
|
236 const TDesC8* ptr = elem->AttrValue(WSStarContextKeys::KName); |
|
237 if ( *ptr == WSStarContextKeys::KMainBrandID ) |
|
238 { |
|
239 ((MSenContext&)aCtx).Update(WSStarContextKeys::KMainBrandID, elem->Content()); |
|
240 } |
|
241 if (*ptr == WSStarContextKeys::KBrandIDList) |
|
242 { |
|
243 ((MSenContext&)aCtx).Update(WSStarContextKeys::KBrandIDList, elem->Content()); |
|
244 } |
|
245 } |
|
246 } |
|
247 } |
|
248 |
|
249 /* |
|
250 if (!iVersion && inbound->Version()) |
|
251 { |
|
252 iVersion = inbound->Version()->AllocL(); |
|
253 } |
|
254 */ |
|
255 if (!aCtx.GetDesC8L(WSStarContextKeys::KRelatesTo)) |
|
256 { |
|
257 TLSLOG_FORMAT((KSenFaultsLogChannel, KSenFaultsLogLevel, |
|
258 WSStarAddressingFault::KInvalidHeaderFormatString8, |
|
259 &KRelatesToQName(),&WSStarAddressingFault::KMissingTag())); |
|
260 |
|
261 } |
|
262 if (!aCtx.GetDesC8L(WSStarContextKeys::KTo)) |
|
263 { |
|
264 TLSLOG_FORMAT((KSenFaultsLogChannel, KSenFaultsLogLevel, KRequiredHeaderFormatString8, |
|
265 &KToQName())); |
|
266 |
|
267 } |
|
268 if (!aCtx.GetDesC8L(WSStarContextKeys::KAction)) |
|
269 { |
|
270 TLSLOG_FORMAT((KSenFaultsLogChannel, KSenFaultsLogLevel, KRequiredHeaderFormatString8, |
|
271 &KActionQName())); |
|
272 |
|
273 } |
|
274 if (aCtx.GetDesC8L(WSStarContextKeys::KReplyTo) || aCtx.GetDesC8L(WSStarContextKeys::KFaultTo)) |
|
275 { |
|
276 if (!aCtx.GetDesC8L(WSStarContextKeys::KMessageID)) |
|
277 { |
|
278 TLSLOG_FORMAT((KSenFaultsLogChannel, KSenFaultsLogLevel, KRequiredHeaderFormatString8, |
|
279 &KMessageIDQName())); |
|
280 |
|
281 } |
|
282 } |
|
283 |
|
284 // CleanupStack::PopAndDestroy(buf); |
|
285 // CleanupStack::PopAndDestroy(inbound); |
|
286 CSenElement& body = aMessage->BodyL(); |
|
287 ShareMyLiterals(aCtx); |
|
288 if (aMessage->IsFault()) |
|
289 { |
|
290 TPtrC8 errorCode(KNullDesC8); |
|
291 CSenSoapFault* faultElement = aMessage->FaultL(); |
|
292 if (faultElement) |
|
293 { |
|
294 TPtrC8 code; |
|
295 if (aMessage->NsUri() == KSenSoapEnvelopeXmlns) |
|
296 { |
|
297 TPtrC8 code = faultElement->FaultCode(); |
|
298 const CSenNamespace* nmSpace = faultElement->Namespace(SenXmlUtils::NsPrefix(code), |
|
299 ETrue); |
|
300 code.Set(SenXmlUtils::LocalName(code)); |
|
301 if (nmSpace) |
|
302 { |
|
303 if (!iVersion) |
|
304 { |
|
305 InitVersionL(&nmSpace->URI()); |
|
306 } |
|
307 if (iVersion && |
|
308 nmSpace->URI() == *iVersion) |
|
309 { |
|
310 errorCode.Set(code); |
|
311 } |
|
312 } |
|
313 } |
|
314 else if (aMessage->NsUri() == KSenSoap12EnvelopeXmlns) |
|
315 { |
|
316 code.Set(faultElement->FaultCode()); |
|
317 const CSenNamespace* nmSpaceCode = |
|
318 faultElement->Namespace(SenXmlUtils::NsPrefix(code), ETrue); |
|
319 code.Set(SenXmlUtils::LocalName(code)); |
|
320 if ((nmSpaceCode && |
|
321 nmSpaceCode->URI() == KSenSoap12EnvelopeXmlns) && |
|
322 (code == KSender || code == KReceiver)) |
|
323 { |
|
324 TPtrC8 subcode = faultElement->FaultSubcode(); |
|
325 const CSenNamespace* nmSpace = |
|
326 faultElement->Namespace(SenXmlUtils::NsPrefix(subcode), ETrue); |
|
327 subcode.Set(SenXmlUtils::LocalName(subcode)); |
|
328 if (nmSpace) |
|
329 { |
|
330 if (!iVersion) |
|
331 { |
|
332 InitVersionL(&nmSpace->URI()); |
|
333 } |
|
334 if (iVersion && |
|
335 nmSpace->URI() == *iVersion) |
|
336 { |
|
337 errorCode.Set(subcode); |
|
338 } |
|
339 } |
|
340 } |
|
341 } |
|
342 if (errorCode.Length()>0) |
|
343 { |
|
344 if (errorCode == WSStarAddressingFault::KInvalidHeader || |
|
345 errorCode == WSStarAddressingFault::KRequiredHeader || |
|
346 errorCode == WSStarAddressingFault::KDestinationUnreachable || |
|
347 errorCode == WSStarAddressingFault::KActionNotSupported ) |
|
348 { |
|
349 ((MSenContext&)aCtx).Update(WSStarSession::KErrorLayer, |
|
350 WSStarSession::EAddressing); |
|
351 } |
|
352 if ((errorCode == WSStarAddressingFault::KEndpointUnavailable) |
|
353 && (code == KReceiver)) |
|
354 { |
|
355 ((MSenContext&)aCtx).Update(WSStarSession::KErrorLayer, |
|
356 WSStarSession::EAddressing); |
|
357 CSenElement* detailElement = faultElement->Element(KFault12DetailLocalname); |
|
358 if (detailElement) |
|
359 { |
|
360 CSenElement* retryElement = detailElement->Element(*iVersion, |
|
361 KRetryAfterName); |
|
362 if (retryElement) |
|
363 { |
|
364 TPtrC8 retryAfter = retryElement->Content(); |
|
365 TLex8 num; |
|
366 TInt retryInt; |
|
367 num.Assign(retryAfter); |
|
368 TInt ret = num.Val(retryInt); |
|
369 if (ret == KErrNone) |
|
370 ((MSenContext&)aCtx).Update(WSStarContextKeys::KRetryAfter, |
|
371 retryInt); |
|
372 } |
|
373 } |
|
374 } |
|
375 } |
|
376 } |
|
377 else |
|
378 { |
|
379 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \ |
|
380 Fault element not exists"))); |
|
381 return KErrNotFound; |
|
382 } |
|
383 } |
|
384 return KErrNone; |
|
385 } |
|
386 TInt CWSStarAddressingHandler::HandleOutboundL(MSenMessageContext& aCtx, |
|
387 CSenSoapEnvelope* aMessage) |
|
388 { |
|
389 if (!iVersion) |
|
390 { |
|
391 iVersion = KAddressingXmlns200508().AllocL(); |
|
392 } |
|
393 TPtrC8 anonymous(KNullDesC8); |
|
394 if (!iVersion->Compare(KAddressingXmlns200403())) |
|
395 { |
|
396 anonymous.Set(KReplyToAnonymous200403()); |
|
397 } |
|
398 else if(!iVersion->Compare(KAddressingXmlns200408())) |
|
399 { |
|
400 anonymous.Set(KReplyToAnonymous200408()); |
|
401 } |
|
402 else if(!iVersion->Compare(KAddressingXmlns200412())) |
|
403 { |
|
404 anonymous.Set(KReplyToAnonymous200412()); |
|
405 } |
|
406 else if(!iVersion->Compare(KAddressingXmlns200502())) |
|
407 { |
|
408 anonymous.Set(KReplyToAnonymous200502()); |
|
409 } |
|
410 else if(!iVersion->Compare(KAddressingXmlns200503())) |
|
411 { |
|
412 anonymous.Set(KReplyToAnonymous200503()); |
|
413 } |
|
414 else if(!iVersion->Compare(KAddressingXmlns200508())) |
|
415 { |
|
416 anonymous.Set(KReplyToAnonymous200508()); |
|
417 } |
|
418 CSenElement& element = aMessage->AsElement(); |
|
419 element.AddNamespaceL(KAddressingPrefix, *iVersion); |
|
420 ((MSenContext&)aCtx).Update(WSStarContextKeys::KAddressingNsHolder, *iVersion); |
|
421 /////////////// |
|
422 const TDesC8* value = NULL; |
|
423 const TInt* isPassportEnabled = aCtx.GetIntL(WSStarContextKeys::KPassportEnabled); |
|
424 value = aCtx.GetDesC8L(WSStarContextKeys::KMessageID); |
|
425 if (!value) |
|
426 { |
|
427 SetMessageIDL(aCtx); |
|
428 } |
|
429 |
|
430 if (!isPassportEnabled || (isPassportEnabled && *isPassportEnabled == FALSE)) |
|
431 { |
|
432 CSenElement& header = aMessage->HeaderL(); |
|
433 value = aCtx.GetDesC8L(WSStarContextKeys::KMessageID); |
|
434 if (value) |
|
435 { |
|
436 CreateElementAddressingL(header, KMessageIDName, *value, EFalse); |
|
437 } |
|
438 else |
|
439 { |
|
440 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \ |
|
441 MessageId in message context not exists"))); |
|
442 return KErrNotFound; |
|
443 } |
|
444 value = aCtx.GetDesC8L(WSStarContextKeys::KTo); |
|
445 if (value) |
|
446 { |
|
447 CreateElementAddressingL(header, KToName, *value, EFalse); |
|
448 } |
|
449 else |
|
450 { |
|
451 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \ |
|
452 Endpoint in message context not exists"))); |
|
453 return KErrNotFound; |
|
454 } |
|
455 value = aCtx.GetDesC8L(WSStarContextKeys::KAction); |
|
456 if (value) |
|
457 { |
|
458 CreateElementAddressingL(header, KActionName, *value, EFalse); |
|
459 } |
|
460 else |
|
461 { |
|
462 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \ |
|
463 Action in message context not exists"))); |
|
464 return KErrNotFound; |
|
465 } |
|
466 value = aCtx.GetDesC8L(WSStarContextKeys::KRelatesTo); |
|
467 if (value) |
|
468 { |
|
469 CreateElementAddressingL(header, KRelatesToName, *value, EFalse); |
|
470 } |
|
471 value = aCtx.GetDesC8L(WSStarContextKeys::KFrom); |
|
472 if (value) |
|
473 { |
|
474 CreateElementAddressingL(header, KFromName, *value, ETrue); |
|
475 } |
|
476 value = aCtx.GetDesC8L(WSStarContextKeys::KReplyTo); |
|
477 if (value) |
|
478 { |
|
479 CSenElement* element = CreateElementAddressingL(header, KReplyToName, *value, ETrue); |
|
480 const TDesC8* mwsNs = NULL; |
|
481 mwsNs = aCtx.GetDesC8L(WSStarContextKeys::KMwsNamespace); |
|
482 if (mwsNs) |
|
483 { |
|
484 const TDesC8* deviceId = NULL; |
|
485 deviceId = aCtx.GetDesC8L(WSStarContextKeys::KReplyToDeviceAddress); |
|
486 if (deviceId && element) |
|
487 { |
|
488 ((CWSStarAddressingEPR*)element)->AddDeviceAddressL(*mwsNs,*deviceId); |
|
489 } |
|
490 } |
|
491 } |
|
492 else |
|
493 { |
|
494 CSenElement* element = CreateElementAddressingL(header, KReplyToName, |
|
495 anonymous, ETrue); |
|
496 ((MSenContext&)aCtx).Update(WSStarContextKeys::KReplyTo, anonymous); |
|
497 const TDesC8* mwsNs = NULL; |
|
498 mwsNs = aCtx.GetDesC8L(WSStarContextKeys::KMwsNamespace); |
|
499 if (mwsNs) |
|
500 { |
|
501 const TDesC8* deviceId = NULL; |
|
502 deviceId = aCtx.GetDesC8L(WSStarContextKeys::KReplyToDeviceAddress); |
|
503 if (deviceId && element) |
|
504 { |
|
505 ((CWSStarAddressingEPR*)element)->AddDeviceAddressL(*mwsNs,*deviceId); |
|
506 } |
|
507 } |
|
508 } |
|
509 |
|
510 value = aCtx.GetDesC8L(WSStarContextKeys::KFaultTo); |
|
511 if (value) |
|
512 { |
|
513 CreateElementAddressingL(header, KFaultToName, *value, ETrue); |
|
514 } |
|
515 if(aCtx.GetIntL(WSStarContextKeys::KAppInfoPresent)) |
|
516 { |
|
517 AddAppInfoHeaderL(aCtx,header); |
|
518 } |
|
519 } |
|
520 |
|
521 CSenElement& body = aMessage->BodyL(); |
|
522 CSenElement* addressHolderEl = NULL; |
|
523 do |
|
524 { |
|
525 addressHolderEl = |
|
526 CWSStarMessageUtils::GetMarkedElementL(body, WSStarContextKeys::KAddressAttrMark); |
|
527 if (addressHolderEl) |
|
528 { |
|
529 value = addressHolderEl->AttrValue(WSStarContextKeys::KAddressAttrMark); |
|
530 CreateElementAddressingL(*addressHolderEl, KEndpointReferenceName, |
|
531 *value, ETrue); |
|
532 //removing marker |
|
533 CSenBaseAttribute* marker = |
|
534 SenXmlUtils::RemoveAttributeL(*addressHolderEl, WSStarContextKeys::KAddressAttrMark); |
|
535 delete marker; |
|
536 marker = NULL; |
|
537 } |
|
538 |
|
539 }while(addressHolderEl); |
|
540 HBufC8* bodyString = body.AsXmlL(); |
|
541 ((MSenContext&)aCtx).Update(WSStarContextKeys::KBody, *bodyString); |
|
542 ((MSenContext&)aCtx).Remove(WSStarContextKeys::KBodyElement); |
|
543 delete bodyString; |
|
544 bodyString = NULL; |
|
545 return KErrNone; |
|
546 } |
|
547 void CWSStarAddressingHandler::AddAppInfoHeaderL(MSenMessageContext& aCtx, |
|
548 CSenElement& aHeader) |
|
549 { |
|
550 const TDesC8* value = NULL; |
|
551 |
|
552 const TDesC8* mwsNs = NULL; |
|
553 mwsNs = aCtx.GetDesC8L(WSStarContextKeys::KMwsNamespace); |
|
554 if (mwsNs) |
|
555 { |
|
556 //CreateElementAddressingL(header, WSStarContextKeys::KApplication, *value,EFalse); |
|
557 CSenElement& aaplication = aHeader.AddElementL(*mwsNs, |
|
558 WSStarContextKeys::KApplication, |
|
559 WSStarContextKeys::KNsPApplication); |
|
560 |
|
561 value = aCtx.GetDesC8L(WSStarContextKeys::KApplicationName); |
|
562 if(value) |
|
563 { |
|
564 CSenElement& name = aaplication.AddElementL(*mwsNs, |
|
565 WSStarContextKeys::KName, |
|
566 WSStarContextKeys::KNsPName); |
|
567 name.SetContentL(*value); |
|
568 } |
|
569 |
|
570 value = aCtx.GetDesC8L(WSStarContextKeys::KApplicationVendor); |
|
571 if(value) |
|
572 { |
|
573 CSenElement& vendor = aaplication.AddElementL(*mwsNs, |
|
574 WSStarContextKeys::KVendor, |
|
575 WSStarContextKeys::KNsPVendor); |
|
576 vendor.SetContentL(*value); |
|
577 } |
|
578 value = aCtx.GetDesC8L(WSStarContextKeys::KApplicationVersion); |
|
579 if(value) |
|
580 { |
|
581 CSenElement& version = aaplication.AddElementL(*mwsNs, |
|
582 WSStarContextKeys::KVersion, |
|
583 WSStarContextKeys::KNsPVersion); |
|
584 version.SetContentL(*value); |
|
585 } |
|
586 |
|
587 CSenElement& deviceoption = aHeader.AddElementL(*mwsNs, |
|
588 WSStarContextKeys::KDeviceOptions, |
|
589 WSStarContextKeys::KNsPDeviceOptions); |
|
590 |
|
591 value = aCtx.GetDesC8L(WSStarContextKeys::KLocale); |
|
592 if(value) |
|
593 { |
|
594 CSenElement& local = deviceoption.AddElementL(*mwsNs, |
|
595 WSStarContextKeys::KLocale, |
|
596 WSStarContextKeys::KNsPLocale); |
|
597 local.SetContentL(*value); |
|
598 } |
|
599 |
|
600 CSenElement& useragent = deviceoption.AddElementL(*mwsNs, |
|
601 WSStarContextKeys::KUserAgent, |
|
602 WSStarContextKeys::KNsPUserAgent); |
|
603 |
|
604 value = aCtx.GetDesC8L(WSStarContextKeys::KManufacturer); |
|
605 if(value) |
|
606 { |
|
607 CSenElement& manufacturer = useragent.AddElementL(*mwsNs, |
|
608 WSStarContextKeys::KManufacturer, |
|
609 WSStarContextKeys::KNsPManufacturer); |
|
610 manufacturer.SetContentL(*value); |
|
611 } |
|
612 value = aCtx.GetDesC8L(WSStarContextKeys::KModel); |
|
613 if(value) |
|
614 { |
|
615 CSenElement& model = useragent.AddElementL(*mwsNs, |
|
616 WSStarContextKeys::KModel, |
|
617 WSStarContextKeys::KNsPModel); |
|
618 model.SetContentL(*value); |
|
619 } |
|
620 |
|
621 CSenElement& os = useragent.AddElementL(*mwsNs, |
|
622 WSStarContextKeys::KOS, |
|
623 WSStarContextKeys::KNsPOS); |
|
624 |
|
625 value = aCtx.GetDesC8L(WSStarContextKeys::KDeviceName); |
|
626 if(value) |
|
627 { |
|
628 CSenElement& name = os.AddElementL(*mwsNs, |
|
629 WSStarContextKeys::KName, |
|
630 WSStarContextKeys::KNsPName); |
|
631 name.SetContentL(*value); |
|
632 } |
|
633 value = aCtx.GetDesC8L(WSStarContextKeys::KDeviceVersion); |
|
634 if(value) |
|
635 { |
|
636 CSenElement& version = os.AddElementL(*mwsNs, |
|
637 WSStarContextKeys::KVersion, |
|
638 WSStarContextKeys::KNsPVersion); |
|
639 version.SetContentL(*value); |
|
640 } |
|
641 |
|
642 |
|
643 value = aCtx.GetDesC8L(WSStarContextKeys::KIMSI); |
|
644 if(value) |
|
645 { |
|
646 CSenElement& imsi = useragent.AddElementL(*mwsNs, |
|
647 WSStarContextKeys::KIMSI, |
|
648 WSStarContextKeys::KNsPIMSI); |
|
649 imsi.SetContentL(*value); |
|
650 } |
|
651 } |
|
652 return; |
|
653 } |
|
654 |
|
655 SenHandler::THandlerDirection CWSStarAddressingHandler::Direction() const |
|
656 { |
|
657 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::Direction()"))); |
|
658 return SenHandler::EBoth; |
|
659 } |
|
660 SenHandler::THandlerPhase CWSStarAddressingHandler::Phase() |
|
661 { |
|
662 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::Phase()"))); |
|
663 return SenHandler::EMessage; |
|
664 } |
|
665 |
|
666 // Constructor |
|
667 CWSStarAddressingHandler::CWSStarAddressingHandler(MSenHandlerContext& aCtx) |
|
668 :CSenMessageHandler(aCtx) |
|
669 { |
|
670 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::\ |
|
671 CWSStarAddressingHandler(MSenHandlerContext& aCtx)"))); |
|
672 } |
|
673 |
|
674 // Destructor |
|
675 CWSStarAddressingHandler::~CWSStarAddressingHandler() |
|
676 { |
|
677 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::~CWSStarAddressingHandler()"))); |
|
678 delete iVersion; |
|
679 } |
|
680 |
|
681 // Second phase construction. |
|
682 void CWSStarAddressingHandler::ConstructL() |
|
683 { |
|
684 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::ConstructL()"))); |
|
685 |
|
686 InitVersionL(NULL); |
|
687 } |
|
688 void CWSStarAddressingHandler::InitVersionL(const TDesC8* aVersion) |
|
689 { |
|
690 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InitVersion()"))); |
|
691 const TDesC8* version = iHandlerContext.GetDesC8L(HandlerContextKey::KVersion); |
|
692 if (aVersion && |
|
693 (*aVersion == KAddressingXmlns200408 || |
|
694 *aVersion == KAddressingXmlns200403 || |
|
695 *aVersion == KAddressingXmlns200412 || |
|
696 *aVersion == KAddressingXmlns200502 || |
|
697 *aVersion == KAddressingXmlns200503 || |
|
698 *aVersion == KAddressingXmlns200508)) |
|
699 { |
|
700 delete iVersion; |
|
701 iVersion = NULL; |
|
702 iVersion = aVersion->AllocL(); |
|
703 } |
|
704 else if(version && |
|
705 (*version == KAddressingXmlns200408 || |
|
706 *version == KAddressingXmlns200403 || |
|
707 *version == KAddressingXmlns200412 || |
|
708 *version == KAddressingXmlns200502 || |
|
709 *version == KAddressingXmlns200503 || |
|
710 *version == KAddressingXmlns200508)) |
|
711 { |
|
712 delete iVersion; |
|
713 iVersion = NULL; |
|
714 iVersion = version->AllocL(); |
|
715 } |
|
716 else |
|
717 {//no version from handler config |
|
718 //no version from user |
|
719 //so it means some default behavior (new addressing), |
|
720 //only allocate if differen (to safe time) |
|
721 if ((!iVersion) || (*iVersion != KAddressingXmlns200508())) |
|
722 { |
|
723 delete iVersion; |
|
724 iVersion = NULL; |
|
725 //iVersion = KAddressingXmlns200508().AllocL(); |
|
726 } |
|
727 //else - just leave ai it is |
|
728 } |
|
729 } |
|
730 CSenElement* CWSStarAddressingHandler::CreateElementAddressingL(CSenElement& aParentElement, const TDesC8& aLocalName, |
|
731 const TDesC8& aContent, TBool aUseAddress) |
|
732 { |
|
733 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::CreateElementAddressing(CSenElement& aParentElement,\ |
|
734 const TDesC8& aLocalName, const TDesC8& aContent, TBool aUseAddress)"))); |
|
735 |
|
736 CSenElement* newelement = NULL; |
|
737 if (!aUseAddress) |
|
738 { |
|
739 newelement = aParentElement.CreateElementL(KAddressingPrefix(), |
|
740 aLocalName); |
|
741 CleanupStack::PushL(newelement); |
|
742 newelement->SetContentL(aContent); |
|
743 } |
|
744 else |
|
745 { |
|
746 newelement = CWSStarAddressingEPR::NewL(aParentElement, aLocalName, aContent, *iVersion); |
|
747 CleanupStack::PushL(newelement); |
|
748 } |
|
749 if (newelement) |
|
750 { |
|
751 aParentElement.AddElementL(*newelement); |
|
752 CleanupStack::Pop(newelement); |
|
753 } |
|
754 /* |
|
755 if (aUseAddress) |
|
756 { |
|
757 CSenElement& element = *newelement; |
|
758 CreateElementAddressingL(element,KAddressName,aContent,EFalse); |
|
759 } |
|
760 else |
|
761 { |
|
762 newelement->SetContentL(aContent); |
|
763 }*/ |
|
764 return newelement; |
|
765 } |
|
766 |
|
767 void CWSStarAddressingHandler::SetMessageIDL(MSenMessageContext& aCtx) |
|
768 { |
|
769 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::SetMessageID(MSenMessageContext& aCtx)"))); |
|
770 CSenGuidGen* pGuidGenerator = CSenGuidGen::NewLC(); |
|
771 HBufC8* messageId = pGuidGenerator->GetRandomGuid8LC(); |
|
772 TPtr8 messageIdDes = messageId->Des(); |
|
773 messageIdDes.LowerCase(); |
|
774 ((MSenContext&)aCtx).Update(WSStarContextKeys::KMessageID,*messageId); |
|
775 CleanupStack::PopAndDestroy(messageId); |
|
776 CleanupStack::PopAndDestroy(pGuidGenerator); |
|
777 } |
|
778 void CWSStarAddressingHandler::ShareMyLiterals(MSenMessageContext& aCtx) |
|
779 { |
|
780 if (iVersion) |
|
781 { |
|
782 ((MSenContext&)aCtx).Update(WSStarContextKeys::KAddressingNsHolder, |
|
783 *iVersion); |
|
784 ((MSenContext&)aCtx).Update(WSStarContextKeys::KAddressingEndpointTagHolder, KAddressName); |
|
785 } |
|
786 } |
|
787 TInt CWSStarAddressingHandler::InitL(MSenHandlerContext& aCtx) |
|
788 { |
|
789 TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InitL(MSenHandlerContext& aCtx)"))); |
|
790 iHandlerContext = aCtx; |
|
791 return KErrNone; |
|
792 } |
|
793 |
|
794 RFileLogger* CWSStarAddressingHandler::Log() const |
|
795 { |
|
796 RFileLogger* pLog = NULL; |
|
797 TRAP_IGNORE( pLog = (RFileLogger*)iHandlerContext.GetAnyL(HandlerContextKey::KLogger); ) |
|
798 return pLog; |
|
799 } |
|
800 |
|
801 // END OF FILE |
|
802 |