|
1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // Name : CSIPURI.cpp |
|
15 // Part of : SIP Codec |
|
16 // Version : SIP/4.0 |
|
17 // |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 #include "sipuri.h" |
|
23 #include "CSIPURIParams.h" |
|
24 #include "CSIPURIHeaders.h" |
|
25 #include "sipcodecerr.h" |
|
26 #include "SIPSyntaxCheck.h" |
|
27 #include "sipstrings.h" |
|
28 #include "sipstrconsts.h" |
|
29 #include <uricommon.h> |
|
30 #include "_sipcodecdefs.h" |
|
31 |
|
32 _LIT8(KSIP, "sip"); |
|
33 _LIT8(KSIPS, "sips"); |
|
34 _LIT8(KColon, ":"); |
|
35 _LIT8(KSemiColon, ";"); |
|
36 _LIT8(KAt, "@"); |
|
37 _LIT8(KQuestionMark, "?"); |
|
38 |
|
39 // ----------------------------------------------------------------------------- |
|
40 // CSIPURI::DecodeL |
|
41 // ----------------------------------------------------------------------------- |
|
42 // |
|
43 EXPORT_C CSIPURI* CSIPURI::DecodeL (const TDesC8& aValue) |
|
44 { |
|
45 __ASSERT_ALWAYS (aValue.Length() > 0, User::Leave(KErrSipCodecURI)); |
|
46 |
|
47 CSIPURI* sipUri = CSIPURI::NewLC(); |
|
48 |
|
49 sipUri->ParseL(sipUri->ParseSipSchemeL(aValue)); |
|
50 |
|
51 CleanupStack::Pop(sipUri); |
|
52 return sipUri; |
|
53 } |
|
54 |
|
55 // ----------------------------------------------------------------------------- |
|
56 // CSIPURI::NewL |
|
57 // ----------------------------------------------------------------------------- |
|
58 // |
|
59 CSIPURI* CSIPURI::NewL (const CSIPURI& aSIPURI) |
|
60 { |
|
61 CSIPURI* self = CSIPURI::NewLC(aSIPURI); |
|
62 CleanupStack::Pop(self); |
|
63 return self; |
|
64 } |
|
65 |
|
66 // ----------------------------------------------------------------------------- |
|
67 // CSIPURI::NewLC |
|
68 // ----------------------------------------------------------------------------- |
|
69 // |
|
70 CSIPURI* CSIPURI::NewLC (const CSIPURI& aSIPURI) |
|
71 { |
|
72 CSIPURI* self = new(ELeave)CSIPURI(aSIPURI.IsSIPSURI()); |
|
73 CleanupStack::PushL(self); |
|
74 self->ConstructL(aSIPURI); |
|
75 return self; |
|
76 } |
|
77 |
|
78 // ----------------------------------------------------------------------------- |
|
79 // CSIPURI::NewL |
|
80 // ----------------------------------------------------------------------------- |
|
81 // |
|
82 CSIPURI* CSIPURI::NewL () |
|
83 { |
|
84 CSIPURI* self = CSIPURI::NewLC(); |
|
85 CleanupStack::Pop(self); |
|
86 return self; |
|
87 } |
|
88 |
|
89 // ----------------------------------------------------------------------------- |
|
90 // CSIPURI::NewLC |
|
91 // ----------------------------------------------------------------------------- |
|
92 // |
|
93 CSIPURI* CSIPURI::NewLC () |
|
94 { |
|
95 CSIPURI* self = new(ELeave)CSIPURI; |
|
96 CleanupStack::PushL(self); |
|
97 self->ConstructL (); |
|
98 return self; |
|
99 } |
|
100 |
|
101 // ----------------------------------------------------------------------------- |
|
102 // CSIPURI::CSIPURI |
|
103 // ----------------------------------------------------------------------------- |
|
104 // |
|
105 CSIPURI::CSIPURI(TBool aIsSIPSUri) |
|
106 : iIsSIPSURI(aIsSIPSUri) |
|
107 { |
|
108 } |
|
109 |
|
110 // ----------------------------------------------------------------------------- |
|
111 // CSIPURI::ConstructL |
|
112 // ----------------------------------------------------------------------------- |
|
113 // |
|
114 void CSIPURI::ConstructL () |
|
115 { |
|
116 iURIParams = new(ELeave)CSIPURIParams(iIsSIPSURI); |
|
117 iURIHeaders = new(ELeave)CSIPURIHeaders; |
|
118 } |
|
119 |
|
120 // ----------------------------------------------------------------------------- |
|
121 // CSIPURI::ConstructL |
|
122 // ----------------------------------------------------------------------------- |
|
123 // |
|
124 void CSIPURI::ConstructL (const CSIPURI& aSIPURI) |
|
125 { |
|
126 ConstructL(); |
|
127 iHostPort = CSIPHostPort::NewL(*aSIPURI.iHostPort); |
|
128 if (aSIPURI.User().Compare(KNullDesC8) != 0) |
|
129 { |
|
130 SetUserL(aSIPURI.User()); |
|
131 } |
|
132 if (aSIPURI.Password().Compare(KNullDesC8) != 0) |
|
133 { |
|
134 SetPasswordL(aSIPURI.Password()); |
|
135 } |
|
136 SetURIParams(CSIPURIParams::NewL(*aSIPURI.iURIParams,aSIPURI.IsSIPSURI())); |
|
137 SetURIHeaders(CSIPURIHeaders::NewL(*aSIPURI.iURIHeaders)); |
|
138 } |
|
139 |
|
140 // ----------------------------------------------------------------------------- |
|
141 // CSIPURI::~CSIPURI |
|
142 // ----------------------------------------------------------------------------- |
|
143 // |
|
144 EXPORT_C CSIPURI::~CSIPURI () |
|
145 { |
|
146 delete iHostPort; |
|
147 delete iURIHeaders; |
|
148 delete iURIParams; |
|
149 delete iPassword; |
|
150 delete iUser; |
|
151 } |
|
152 |
|
153 // ----------------------------------------------------------------------------- |
|
154 // CSIPURI::IsSIPSURI |
|
155 // ----------------------------------------------------------------------------- |
|
156 // |
|
157 EXPORT_C TBool CSIPURI::IsSIPSURI () const |
|
158 { |
|
159 return iIsSIPSURI; |
|
160 } |
|
161 |
|
162 // ----------------------------------------------------------------------------- |
|
163 // CSIPURI::SetSIPS |
|
164 // ----------------------------------------------------------------------------- |
|
165 // |
|
166 EXPORT_C void CSIPURI::SetSIPS(TBool aSIPS) |
|
167 { |
|
168 iIsSIPSURI = aSIPS; |
|
169 } |
|
170 |
|
171 // ----------------------------------------------------------------------------- |
|
172 // CSIPURI::SetHostPortL |
|
173 // ----------------------------------------------------------------------------- |
|
174 // |
|
175 EXPORT_C void CSIPURI::SetHostPortL (CSIPHostPort* aHostPort) |
|
176 { |
|
177 __ASSERT_ALWAYS (aHostPort != 0, User::Leave(KErrSipCodecHost)); |
|
178 |
|
179 delete iHostPort; |
|
180 iHostPort = aHostPort; |
|
181 } |
|
182 |
|
183 // ----------------------------------------------------------------------------- |
|
184 // CSIPURI::HostPort |
|
185 // ----------------------------------------------------------------------------- |
|
186 // |
|
187 EXPORT_C const CSIPHostPort& CSIPURI::HostPort () const |
|
188 { |
|
189 return *iHostPort; |
|
190 } |
|
191 |
|
192 // ----------------------------------------------------------------------------- |
|
193 // CSIPURI::HostPort |
|
194 // ----------------------------------------------------------------------------- |
|
195 // |
|
196 EXPORT_C CSIPHostPort& CSIPURI::HostPort () |
|
197 { |
|
198 return *iHostPort; |
|
199 } |
|
200 |
|
201 // ----------------------------------------------------------------------------- |
|
202 // CSIPURI::User |
|
203 // ----------------------------------------------------------------------------- |
|
204 // |
|
205 EXPORT_C const TDesC8& CSIPURI::User () const |
|
206 { |
|
207 if (iUser) |
|
208 { |
|
209 return *iUser; |
|
210 } |
|
211 return KNullDesC8; |
|
212 } |
|
213 |
|
214 // ----------------------------------------------------------------------------- |
|
215 // CSIPURI::SetUserL |
|
216 // ----------------------------------------------------------------------------- |
|
217 // |
|
218 EXPORT_C void CSIPURI::SetUserL (const TDesC8& aUser) |
|
219 { |
|
220 __ASSERT_ALWAYS (SIPSyntaxCheck::User(aUser), |
|
221 User::Leave(KErrSipCodecURI)); |
|
222 |
|
223 HBufC8* tmp = aUser.AllocL(); |
|
224 delete iUser; |
|
225 iUser = tmp; |
|
226 } |
|
227 |
|
228 // ----------------------------------------------------------------------------- |
|
229 // CSIPURI::DeleteUserInfo |
|
230 // ----------------------------------------------------------------------------- |
|
231 // |
|
232 EXPORT_C void CSIPURI::DeleteUserInfo () |
|
233 { |
|
234 delete iUser; iUser = 0; |
|
235 DeletePassword(); |
|
236 } |
|
237 |
|
238 // ----------------------------------------------------------------------------- |
|
239 // CSIPURI::Password |
|
240 // ----------------------------------------------------------------------------- |
|
241 // |
|
242 EXPORT_C const TDesC8& CSIPURI::Password () const |
|
243 { |
|
244 if (iPassword) |
|
245 { |
|
246 return *iPassword; |
|
247 } |
|
248 return KNullDesC8; |
|
249 } |
|
250 |
|
251 // ----------------------------------------------------------------------------- |
|
252 // CSIPURI::SetPasswordL |
|
253 // ----------------------------------------------------------------------------- |
|
254 // |
|
255 EXPORT_C void CSIPURI::SetPasswordL (const TDesC8& aPassword) |
|
256 { |
|
257 __ASSERT_ALWAYS (SIPSyntaxCheck::Password(aPassword), |
|
258 User::Leave(KErrSipCodecURI)); |
|
259 __ASSERT_ALWAYS (iUser, User::Leave(KErrArgument)); |
|
260 |
|
261 HBufC8* tmp = aPassword.AllocL(); |
|
262 delete iPassword; |
|
263 iPassword = tmp; |
|
264 } |
|
265 |
|
266 // ----------------------------------------------------------------------------- |
|
267 // CSIPURI::DeletePassword |
|
268 // ----------------------------------------------------------------------------- |
|
269 // |
|
270 EXPORT_C void CSIPURI::DeletePassword () |
|
271 { |
|
272 delete iPassword; iPassword = 0; |
|
273 } |
|
274 |
|
275 // ----------------------------------------------------------------------------- |
|
276 // CSIPURI::HasParams |
|
277 // ----------------------------------------------------------------------------- |
|
278 // |
|
279 EXPORT_C TBool CSIPURI::HasParams () const |
|
280 { |
|
281 return (iURIParams->ParamCount() > 0); |
|
282 } |
|
283 |
|
284 // ----------------------------------------------------------------------------- |
|
285 // CSIPURI::TtlParam |
|
286 // ----------------------------------------------------------------------------- |
|
287 // |
|
288 EXPORT_C TInt CSIPURI::TtlParam () const |
|
289 { |
|
290 RStringF ttl = SIPStrings::StringF(SipStrConsts::ETtl); |
|
291 return iURIParams->IntParamValue(ttl); |
|
292 } |
|
293 |
|
294 // ----------------------------------------------------------------------------- |
|
295 // CSIPURI::SetTtlParamL |
|
296 // ----------------------------------------------------------------------------- |
|
297 // |
|
298 EXPORT_C void CSIPURI::SetTtlParamL (TInt aValue) |
|
299 { |
|
300 RStringF ttl = SIPStrings::StringF(SipStrConsts::ETtl); |
|
301 iURIParams->SetParamL(ttl,aValue); |
|
302 } |
|
303 |
|
304 // ----------------------------------------------------------------------------- |
|
305 // CSIPURI::HasParam |
|
306 // ----------------------------------------------------------------------------- |
|
307 // |
|
308 EXPORT_C TBool CSIPURI::HasParam(RStringF aName) const |
|
309 { |
|
310 return iURIParams->HasParam(aName); |
|
311 } |
|
312 |
|
313 // ----------------------------------------------------------------------------- |
|
314 // CSIPURI::ParamValue |
|
315 // ----------------------------------------------------------------------------- |
|
316 // |
|
317 EXPORT_C RStringF CSIPURI::ParamValue(RStringF aName) const |
|
318 { |
|
319 return iURIParams->ParamValue(aName); |
|
320 } |
|
321 |
|
322 // ----------------------------------------------------------------------------- |
|
323 // CSIPURI::SetParamL |
|
324 // ----------------------------------------------------------------------------- |
|
325 // |
|
326 EXPORT_C void CSIPURI::SetParamL(RStringF aName) |
|
327 { |
|
328 iURIParams->SetParamL(aName); |
|
329 } |
|
330 |
|
331 // ----------------------------------------------------------------------------- |
|
332 // CSIPURI::SetParamL |
|
333 // ----------------------------------------------------------------------------- |
|
334 // |
|
335 EXPORT_C void CSIPURI::SetParamL(RStringF aName, RStringF aValue) |
|
336 { |
|
337 iURIParams->SetParamL(aName,aValue); |
|
338 } |
|
339 |
|
340 // ----------------------------------------------------------------------------- |
|
341 // CSIPURI::DeleteParam |
|
342 // ----------------------------------------------------------------------------- |
|
343 // |
|
344 EXPORT_C void CSIPURI::DeleteParam(RStringF aName) |
|
345 { |
|
346 iURIParams->DeleteParam (aName); |
|
347 } |
|
348 |
|
349 // ----------------------------------------------------------------------------- |
|
350 // CSIPURI::HasURIHeaders |
|
351 // ----------------------------------------------------------------------------- |
|
352 // |
|
353 EXPORT_C TBool CSIPURI::HasURIHeaders (const TDesC8& aName) const |
|
354 { |
|
355 return iURIHeaders->HasHeaders(aName); |
|
356 } |
|
357 |
|
358 // ----------------------------------------------------------------------------- |
|
359 // CSIPURI::URIHeaderValuesL |
|
360 // ----------------------------------------------------------------------------- |
|
361 // |
|
362 EXPORT_C CPtrC8Array* CSIPURI::URIHeaderValuesL (const TDesC8& aName) const |
|
363 { |
|
364 return iURIHeaders->HeaderValuesL(aName); |
|
365 } |
|
366 |
|
367 // ----------------------------------------------------------------------------- |
|
368 // CSIPURI::AddURIHeaderL |
|
369 // ----------------------------------------------------------------------------- |
|
370 // |
|
371 EXPORT_C void CSIPURI::AddURIHeaderL (const TDesC8& aName, |
|
372 const TDesC8& aValue) |
|
373 { |
|
374 iURIHeaders->AddHeaderL(aName,aValue); |
|
375 } |
|
376 |
|
377 // ----------------------------------------------------------------------------- |
|
378 // CSIPURI::DeleteAllURIHeaders |
|
379 // ----------------------------------------------------------------------------- |
|
380 // |
|
381 void CSIPURI::DeleteAllURIHeaders () |
|
382 { |
|
383 iURIHeaders->DeleteAll(); |
|
384 } |
|
385 |
|
386 // ----------------------------------------------------------------------------- |
|
387 // CSIPURI::operator== |
|
388 // ----------------------------------------------------------------------------- |
|
389 // |
|
390 EXPORT_C TBool CSIPURI::operator==(const CSIPURI& aURI) const |
|
391 { |
|
392 if (aURI.iIsSIPSURI != iIsSIPSURI) |
|
393 { |
|
394 return EFalse; |
|
395 } |
|
396 TBool hasuserparam((aURI.User().Compare(KNullDesC8) != 0)); |
|
397 TBool hasuser((User().Compare(KNullDesC8) != 0)); |
|
398 if (hasuserparam != hasuser) |
|
399 { |
|
400 return EFalse; |
|
401 } |
|
402 if (hasuserparam && aURI.User() != User()) |
|
403 { |
|
404 return EFalse; |
|
405 } |
|
406 TBool haspasswordparam((aURI.Password().Compare(KNullDesC8) != 0)); |
|
407 TBool haspassword((Password().Compare(KNullDesC8) != 0)); |
|
408 if (haspasswordparam != haspassword) |
|
409 { |
|
410 return EFalse; |
|
411 } |
|
412 if (haspasswordparam && |
|
413 aURI.Password() != Password()) |
|
414 { |
|
415 return EFalse; |
|
416 } |
|
417 if (!(*iHostPort == *(aURI.iHostPort))) |
|
418 { |
|
419 return EFalse; |
|
420 } |
|
421 if (!(*aURI.iURIParams == *iURIParams)) |
|
422 { |
|
423 return EFalse; |
|
424 } |
|
425 return (*aURI.iURIHeaders == *iURIHeaders); |
|
426 } |
|
427 |
|
428 // ----------------------------------------------------------------------------- |
|
429 // CSIPURI::ToTextL |
|
430 // ----------------------------------------------------------------------------- |
|
431 // |
|
432 EXPORT_C HBufC8* CSIPURI::ToTextL () const |
|
433 { |
|
434 TPtrC8 scheme(KSIP); |
|
435 if (iIsSIPSURI) |
|
436 { |
|
437 scheme.Set(KSIPS); |
|
438 } |
|
439 TUint encodedLength = scheme.Length() + KColon().Length(); |
|
440 |
|
441 if (iUser) |
|
442 { |
|
443 encodedLength += iUser->Length(); |
|
444 if (iPassword) encodedLength+=KColon().Length()+iPassword->Length(); |
|
445 encodedLength += KAt().Length(); |
|
446 } |
|
447 |
|
448 HBufC8* hostPort = iHostPort->ToTextLC(); |
|
449 encodedLength += hostPort->Length(); |
|
450 |
|
451 HBufC8* uriParams = iURIParams->ToTextLC(); |
|
452 if (uriParams->Length() > 0) encodedLength += (1+uriParams->Length()); |
|
453 |
|
454 HBufC8* uriHeaders = iURIHeaders->ToTextLC(); |
|
455 if (uriHeaders->Length() > 0) encodedLength += (1+uriHeaders->Length()); |
|
456 |
|
457 // Create and fill the encoded SIP URI |
|
458 HBufC8* encodedSIPURI = HBufC8::NewL (encodedLength); |
|
459 TPtr8 encodedSIPURIPtr = encodedSIPURI->Des(); |
|
460 |
|
461 encodedSIPURIPtr.Append(scheme); |
|
462 encodedSIPURIPtr.Append(KColon); |
|
463 |
|
464 if (iUser) |
|
465 { |
|
466 encodedSIPURIPtr.Append(*iUser); |
|
467 if (iPassword) |
|
468 { |
|
469 encodedSIPURIPtr.Append(KColon); |
|
470 encodedSIPURIPtr.Append(*iPassword); |
|
471 } |
|
472 encodedSIPURIPtr.Append(KAt); |
|
473 } |
|
474 |
|
475 encodedSIPURIPtr.Append(*hostPort); |
|
476 |
|
477 if (uriParams->Length() > 0) |
|
478 { |
|
479 encodedSIPURIPtr.Append(KSemiColon); |
|
480 encodedSIPURIPtr.Append (*uriParams); |
|
481 } |
|
482 |
|
483 if (uriHeaders->Length() > 0) |
|
484 { |
|
485 encodedSIPURIPtr.Append(KQuestionMark); |
|
486 encodedSIPURIPtr.Append (*uriHeaders); |
|
487 } |
|
488 |
|
489 CleanupStack::PopAndDestroy(uriHeaders); |
|
490 CleanupStack::PopAndDestroy(uriParams); |
|
491 CleanupStack::PopAndDestroy(hostPort); |
|
492 return encodedSIPURI; |
|
493 } |
|
494 |
|
495 // ----------------------------------------------------------------------------- |
|
496 // CSIPURI::ParseSipSchemeL |
|
497 // ----------------------------------------------------------------------------- |
|
498 // |
|
499 TPtrC8 CSIPURI::ParseSipSchemeL (const TDesC8& aValue) |
|
500 { |
|
501 __ASSERT_ALWAYS (aValue.Length() > 0, User::Leave(KErrSipCodecURIScheme)); |
|
502 |
|
503 _LIT8(KSIPAndColon, "sip:"); |
|
504 _LIT8(KSIPSAndColon, "sips:"); |
|
505 |
|
506 TPtrC8 schemeAndColon; |
|
507 TInt sipSchemePos = aValue.FindF(KSIPAndColon); |
|
508 if (sipSchemePos < 0) |
|
509 { |
|
510 TInt sipsSchemePos = aValue.FindF(KSIPSAndColon); |
|
511 if (sipsSchemePos != 0) |
|
512 { |
|
513 User::Leave (KErrSipCodecURIScheme); |
|
514 } |
|
515 schemeAndColon.Set(KSIPSAndColon); |
|
516 iIsSIPSURI = ETrue; |
|
517 } |
|
518 else |
|
519 { |
|
520 if (sipSchemePos != 0) |
|
521 { |
|
522 User::Leave (KErrSipCodecURIScheme); |
|
523 } |
|
524 schemeAndColon.Set(KSIPAndColon); |
|
525 iIsSIPSURI = EFalse; |
|
526 } |
|
527 TPtrC8 remainder(aValue.Mid(schemeAndColon.Length())); |
|
528 return remainder; |
|
529 } |
|
530 |
|
531 // ----------------------------------------------------------------------------- |
|
532 // CSIPURI::ParseL |
|
533 // ----------------------------------------------------------------------------- |
|
534 // |
|
535 void CSIPURI::ParseL (const TDesC8& aValue) |
|
536 { |
|
537 TPtrC8 remainder(aValue); |
|
538 TInt atPos = 0; |
|
539 LocateSeparatorL(aValue, '@', atPos); |
|
540 if (atPos > 0) // has userinfo |
|
541 { |
|
542 ParseUserInfoL(aValue.Left(atPos)); |
|
543 remainder.Set(aValue.Mid(atPos+1)); |
|
544 } |
|
545 |
|
546 TInt semiColonPos = 0; |
|
547 LocateSeparatorL(remainder, ';', semiColonPos); |
|
548 if (semiColonPos > 0) // has uri-parameters |
|
549 { |
|
550 iHostPort = CSIPHostPort::DecodeL (remainder.Left(semiColonPos)); |
|
551 remainder.Set(remainder.Mid(semiColonPos+1)); |
|
552 TInt questionMarkPos = 0; |
|
553 LocateSeparatorL(remainder, '?', questionMarkPos); |
|
554 TPtrC8 uriParams; |
|
555 if (questionMarkPos > 0) // has uri-headers |
|
556 { |
|
557 uriParams.Set(remainder.Left(questionMarkPos)); |
|
558 TPtrC8 uriHeaders(remainder.Mid(questionMarkPos+1)); |
|
559 SetURIHeaders (CSIPURIHeaders::DecodeL(uriHeaders)); |
|
560 } |
|
561 else // does not have uri-headers |
|
562 { |
|
563 uriParams.Set(remainder); |
|
564 } |
|
565 SetURIParams(CSIPURIParams::DecodeL(uriParams,iIsSIPSURI)); |
|
566 } |
|
567 else // does not have uri-parameters |
|
568 { |
|
569 TInt questionMarkPos = 0; |
|
570 LocateSeparatorL(remainder, '?', questionMarkPos); |
|
571 if (questionMarkPos > 0) // has uri-headers |
|
572 { |
|
573 iHostPort = CSIPHostPort::DecodeL (remainder.Left(questionMarkPos)); |
|
574 TPtrC8 uriHeaders(remainder.Mid(questionMarkPos+1)); |
|
575 SetURIHeaders (CSIPURIHeaders::DecodeL(uriHeaders)); |
|
576 } |
|
577 else |
|
578 { |
|
579 iHostPort = CSIPHostPort::DecodeL (remainder); |
|
580 } |
|
581 } |
|
582 } |
|
583 |
|
584 // ----------------------------------------------------------------------------- |
|
585 // CSIPURI::ParseUserInfoL |
|
586 // ----------------------------------------------------------------------------- |
|
587 // |
|
588 void CSIPURI::ParseUserInfoL (const TDesC8& aValue) |
|
589 { |
|
590 __ASSERT_ALWAYS (aValue.Length() > 0, User::Leave(KErrSipCodecURI)); |
|
591 |
|
592 TInt colonPos = 0; |
|
593 LocateSeparatorL(aValue, ':', colonPos); |
|
594 if (colonPos > 0) // has both user and password part |
|
595 { |
|
596 SetUserL (aValue.Left(colonPos)); |
|
597 SetPasswordL (aValue.Mid(colonPos+1)); |
|
598 } |
|
599 else // has only user part |
|
600 { |
|
601 SetUserL (aValue); |
|
602 } |
|
603 } |
|
604 |
|
605 // ----------------------------------------------------------------------------- |
|
606 // CSIPURI::LocateSeparatorL |
|
607 // ----------------------------------------------------------------------------- |
|
608 // |
|
609 void CSIPURI::LocateSeparatorL( |
|
610 const TDesC8& aValue, |
|
611 TChar aSeparator, |
|
612 TInt& aPosition) const |
|
613 { |
|
614 __ASSERT_ALWAYS (aValue.Length() > 0, User::Leave (KErrSipCodecURI)); |
|
615 |
|
616 TInt position = aValue.Locate(aSeparator); |
|
617 if (position == 0 || position == aValue.Length()-1) |
|
618 { |
|
619 User::Leave (KErrSipCodecURI); |
|
620 } |
|
621 aPosition = position; |
|
622 } |
|
623 |
|
624 // ----------------------------------------------------------------------------- |
|
625 // CSIPURI::SetURIParams |
|
626 // ----------------------------------------------------------------------------- |
|
627 // |
|
628 void CSIPURI::SetURIParams (CSIPURIParams* aURIParams) |
|
629 { |
|
630 delete iURIParams; |
|
631 iURIParams = aURIParams; |
|
632 } |
|
633 |
|
634 // ----------------------------------------------------------------------------- |
|
635 // CSIPURI::SetURIHeaders |
|
636 // ----------------------------------------------------------------------------- |
|
637 // |
|
638 void CSIPURI::SetURIHeaders (CSIPURIHeaders* aURIHeaders) |
|
639 { |
|
640 delete iURIHeaders; |
|
641 iURIHeaders = aURIHeaders; |
|
642 } |
|
643 |
|
644 |