|
1 /* |
|
2 * Copyright (c) 2006-2007 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 #include <es_sock.h> |
|
22 #include "natfwunsafutils.h" |
|
23 |
|
24 const TInt KBoundary = 4; |
|
25 |
|
26 // ----------------------------------------------------------------------------- |
|
27 // NATFWUNSAFUtils::WriteNetworkOrder16L |
|
28 // ----------------------------------------------------------------------------- |
|
29 // |
|
30 void NATFWUNSAFUtils::WriteNetworkOrder16L(TDes8& aDes, TInt aOffset, |
|
31 TUint16 aValue) |
|
32 { |
|
33 __ASSERT_ALWAYS( |
|
34 aDes.Length() >= aOffset + static_cast<TInt>(sizeof(aValue)), |
|
35 User::Leave(KErrArgument)); |
|
36 |
|
37 aDes[aOffset] = NATFWUNSAFUtils::HighByte(aValue); |
|
38 aDes[aOffset + 1] = NATFWUNSAFUtils::LowByte(aValue); |
|
39 } |
|
40 |
|
41 // ----------------------------------------------------------------------------- |
|
42 // NATFWUNSAFUtils::WriteNetworkOrder32L |
|
43 // ----------------------------------------------------------------------------- |
|
44 // |
|
45 void NATFWUNSAFUtils::WriteNetworkOrder32L(TDes8& aDes, TInt aOffset, |
|
46 TUint32 aValue) |
|
47 { |
|
48 __ASSERT_ALWAYS( |
|
49 aDes.Length() >= aOffset + static_cast<TInt>(sizeof(aValue)), |
|
50 User::Leave(KErrArgument)); |
|
51 |
|
52 WriteNetworkOrder16L(aDes, aOffset, NATFWUNSAFUtils::HighWord(aValue)); |
|
53 WriteNetworkOrder16L(aDes, |
|
54 aOffset + sizeof(TUint16), |
|
55 NATFWUNSAFUtils::LowWord(aValue)); |
|
56 } |
|
57 |
|
58 // ----------------------------------------------------------------------------- |
|
59 // NATFWUNSAFUtils::WriteNetworkOrder64L |
|
60 // ----------------------------------------------------------------------------- |
|
61 // |
|
62 void NATFWUNSAFUtils::WriteNetworkOrder64L(TDes8& aDes, TInt aOffset, |
|
63 TUint64 aValue) |
|
64 { |
|
65 __ASSERT_ALWAYS( |
|
66 aDes.Length() >= aOffset + static_cast<TInt>(sizeof(aValue)), |
|
67 User::Leave(KErrArgument)); |
|
68 |
|
69 WriteNetworkOrder32L(aDes, aOffset, NATFWUNSAFUtils::HighDWord(aValue)); |
|
70 WriteNetworkOrder32L(aDes, |
|
71 aOffset + sizeof(TUint32), |
|
72 NATFWUNSAFUtils::LowDWord(aValue)); |
|
73 } |
|
74 |
|
75 // ----------------------------------------------------------------------------- |
|
76 // NATFWUNSAFUtils::GetQuadWordL |
|
77 // ----------------------------------------------------------------------------- |
|
78 // |
|
79 TUint64 NATFWUNSAFUtils::GetQuadWordL(const TUint8* aPtr) |
|
80 { |
|
81 __ASSERT_ALWAYS( NULL != aPtr, User::Leave(KErrArgument)); |
|
82 return MAKE_TUINT64(BigEndian::Get32(aPtr), |
|
83 BigEndian::Get32(&aPtr[KBoundary])); |
|
84 } |
|
85 |
|
86 // ----------------------------------------------------------------------------- |
|
87 // NATFWUNSAFUtils::IsQuotedPairChar |
|
88 // ----------------------------------------------------------------------------- |
|
89 // |
|
90 TBool NATFWUNSAFUtils::IsQuotedPairChar(const TChar& aCharacter) |
|
91 { |
|
92 if (aCharacter == '\n' || aCharacter == '\r') |
|
93 { |
|
94 return EFalse; |
|
95 } |
|
96 return (TInt(aCharacter) <= 127); |
|
97 } |
|
98 |
|
99 // ----------------------------------------------------------------------------- |
|
100 // NATFWUNSAFUtils::IsQdTextChar |
|
101 // ----------------------------------------------------------------------------- |
|
102 // |
|
103 TBool NATFWUNSAFUtils::IsQdTextChar(const TChar& aCharacter) |
|
104 { |
|
105 if (aCharacter == 33 || (aCharacter >= 35 && aCharacter <= 91) || |
|
106 (aCharacter >= 93 && aCharacter <= 126)) |
|
107 { |
|
108 return ETrue; |
|
109 } |
|
110 return EFalse; |
|
111 } |
|
112 |
|
113 // ----------------------------------------------------------------------------- |
|
114 // NATFWUNSAFUtils::StartsAndEndsWithQuotes |
|
115 // ----------------------------------------------------------------------------- |
|
116 // |
|
117 TBool NATFWUNSAFUtils::StartsAndEndsWithQuotes(const TDesC8& aString) |
|
118 { |
|
119 // trim and check quotes |
|
120 TLex8 lex(aString); |
|
121 lex.SkipSpace(); |
|
122 TPtrC8 trimmedVal(lex.Remainder()); |
|
123 const TInt KTwoQuotesLength = 2; |
|
124 if (trimmedVal.Length() < KTwoQuotesLength) |
|
125 { |
|
126 return EFalse; |
|
127 } |
|
128 if (trimmedVal.Locate('"') != 0) |
|
129 { |
|
130 return EFalse; |
|
131 } |
|
132 if (trimmedVal.LocateReverse('"') != trimmedVal.Length()-1) |
|
133 { |
|
134 return EFalse; |
|
135 } |
|
136 return ETrue; |
|
137 } |
|
138 |
|
139 // ----------------------------------------------------------------------------- |
|
140 // NATFWUNSAFUtils::IsQuotedString |
|
141 // ----------------------------------------------------------------------------- |
|
142 // |
|
143 TBool NATFWUNSAFUtils::IsQuotedString(const TDesC8& aString) |
|
144 { |
|
145 // trim and check quotes |
|
146 TLex8 lex(aString); |
|
147 lex.SkipSpace(); |
|
148 TPtrC8 trimmedVal(lex.Remainder()); |
|
149 if (!StartsAndEndsWithQuotes(trimmedVal)) |
|
150 { |
|
151 return EFalse; |
|
152 } |
|
153 // remove quotes |
|
154 TPtrC8 withoutFirstQuote(trimmedVal.Mid(1)); |
|
155 TPtrC8 withoutQuotes(withoutFirstQuote.Left(withoutFirstQuote.Length()-1)); |
|
156 // check value |
|
157 return QuotedStringValue(withoutQuotes); |
|
158 } |
|
159 |
|
160 // ----------------------------------------------------------------------------- |
|
161 // NATFWUNSAFUtils::RealmValueFromQuotedStringL |
|
162 // ----------------------------------------------------------------------------- |
|
163 // |
|
164 TPtrC8 NATFWUNSAFUtils::RealmValueFromQuotedStringL(const TDesC8& aString) |
|
165 { |
|
166 // trim and check quotes |
|
167 TLex8 lex(aString); |
|
168 lex.SkipSpace(); |
|
169 TPtrC8 trimmedVal(lex.Remainder()); |
|
170 if (StartsAndEndsWithQuotes(trimmedVal)) |
|
171 { |
|
172 // remove quotes |
|
173 TPtrC8 withoutFirstQuote(trimmedVal.Mid(1)); |
|
174 TPtrC8 withoutQuotes(withoutFirstQuote.Left( |
|
175 withoutFirstQuote.Length()-1)); |
|
176 if (!QuotedStringValue(withoutQuotes)) |
|
177 { |
|
178 User::Leave(KErrArgument); |
|
179 } |
|
180 return withoutQuotes; |
|
181 } |
|
182 if (!QuotedStringValue(trimmedVal)) |
|
183 { |
|
184 User::Leave(KErrArgument); |
|
185 } |
|
186 return trimmedVal; |
|
187 } |
|
188 |
|
189 // ----------------------------------------------------------------------------- |
|
190 // NATFWUNSAFUtils::QuotedStringValue |
|
191 // ----------------------------------------------------------------------------- |
|
192 // |
|
193 TBool NATFWUNSAFUtils::QuotedStringValue(const TDesC8& aValue) |
|
194 { |
|
195 TLex8 lex(aValue); |
|
196 TChar chr = lex.Get(); |
|
197 while (chr) |
|
198 { |
|
199 TBool ok = ETrue; |
|
200 if (IsUTF8NonAsciiStartChar(chr)) |
|
201 { |
|
202 ok = SkipAndCheckNonAscii(chr,lex); |
|
203 } |
|
204 else if (chr == '\\') |
|
205 { |
|
206 chr = lex.Get(); |
|
207 ok = IsQuotedPairChar(chr); |
|
208 } |
|
209 else if (IsQdTextChar(chr) || chr == ' ' || chr == '\t') |
|
210 { |
|
211 ok = ETrue; |
|
212 } |
|
213 else |
|
214 { |
|
215 ok = EFalse; |
|
216 } |
|
217 if (!ok) |
|
218 { |
|
219 return EFalse; |
|
220 } |
|
221 chr = lex.Get(); |
|
222 } |
|
223 return ETrue; |
|
224 } |
|
225 |
|
226 // ----------------------------------------------------------------------------- |
|
227 // NATFWUNSAFUtils::SkipAndCheckNonAscii |
|
228 // ----------------------------------------------------------------------------- |
|
229 // |
|
230 TBool NATFWUNSAFUtils::SkipAndCheckNonAscii(const TChar& aChr, TLex8& aLex) |
|
231 { |
|
232 if (aChr >= 192 && aChr <= 253) |
|
233 { |
|
234 if (aChr <= 223) |
|
235 { |
|
236 return SkipAndCheckContChars(aLex,1); |
|
237 } |
|
238 else if (aChr <= 239) |
|
239 { |
|
240 return SkipAndCheckContChars(aLex,2); |
|
241 } |
|
242 else if (aChr <= 247) |
|
243 { |
|
244 return SkipAndCheckContChars(aLex,3); |
|
245 } |
|
246 else if (aChr <= 251) |
|
247 { |
|
248 return SkipAndCheckContChars(aLex,4); |
|
249 } |
|
250 else |
|
251 { |
|
252 return SkipAndCheckContChars(aLex,5); |
|
253 } |
|
254 } |
|
255 return EFalse; |
|
256 } |
|
257 |
|
258 // ----------------------------------------------------------------------------- |
|
259 // NATFWUNSAFUtils::IsUTF8NonAsciiStartChar |
|
260 // ----------------------------------------------------------------------------- |
|
261 // |
|
262 TBool NATFWUNSAFUtils::IsUTF8NonAsciiStartChar(const TChar& aChar) |
|
263 { |
|
264 if(aChar >= 192 && aChar <= 253) |
|
265 { |
|
266 return ETrue; |
|
267 } |
|
268 return EFalse; |
|
269 } |
|
270 |
|
271 // ----------------------------------------------------------------------------- |
|
272 // NATFWUNSAFUtils::SkipAndCheckContChars |
|
273 // ----------------------------------------------------------------------------- |
|
274 // |
|
275 TBool NATFWUNSAFUtils::SkipAndCheckContChars(TLex8& aLex, TInt aCount) |
|
276 { |
|
277 TInt counter = 0; |
|
278 TChar chr = 0; |
|
279 while (aCount > counter++) |
|
280 { |
|
281 chr = aLex.Get(); |
|
282 if (IsUTF8ContChar(chr)) |
|
283 { |
|
284 return EFalse; |
|
285 } |
|
286 } |
|
287 return ETrue; |
|
288 } |
|
289 |
|
290 // ----------------------------------------------------------------------------- |
|
291 // NATFWUNSAFUtils::IsUTF8ContChar |
|
292 // ----------------------------------------------------------------------------- |
|
293 // |
|
294 TBool NATFWUNSAFUtils::IsUTF8ContChar(const TChar& aChar) |
|
295 { |
|
296 return (aChar >= 128 && aChar <= 191); |
|
297 } |
|
298 |