22 #endif |
22 #endif |
23 #include <tzlocalizedcityrecord.h> |
23 #include <tzlocalizedcityrecord.h> |
24 #include <tzlocalizedtimezonerecord.h> |
24 #include <tzlocalizedtimezonerecord.h> |
25 #include "timezonesession.h" |
25 #include "timezonesession.h" |
26 #include "timezoneserver.h" |
26 #include "timezoneserver.h" |
|
27 #include "OstTraceDefinitions.h" |
|
28 #ifdef OST_TRACE_COMPILER_IN_USE |
|
29 #include "timezonesessionTraces.h" |
|
30 #endif |
|
31 |
27 |
32 |
28 CTzServerSession* CTzServerSession::NewL() |
33 CTzServerSession* CTzServerSession::NewL() |
29 { |
34 { |
30 CTzServerSession* self = new (ELeave) CTzServerSession(); |
35 CTzServerSession* self = new (ELeave) CTzServerSession(); |
31 CleanupStack::PushL(self); |
36 CleanupStack::PushL(self); |
81 // |
86 // |
82 // Registers to receive notification to time and zone changes in the |
87 // Registers to receive notification to time and zone changes in the |
83 // Server |
88 // Server |
84 TInt CTzServerSession::doRegisterTzChangeNotifier(const RMessage2& aMessage) |
89 TInt CTzServerSession::doRegisterTzChangeNotifier(const RMessage2& aMessage) |
85 { |
90 { |
|
91 OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOREGISTERTZCHANGENOTIFIER_ENTRY, "CTzServerSession::doRegisterTzChangeNotifier Entry" ); |
|
92 |
|
93 |
86 if (!iPendingRequest) |
94 if (!iPendingRequest) |
87 { |
95 { |
88 iClientMessage = aMessage; |
96 iClientMessage = aMessage; |
89 iPendingRequest = ETrue; |
97 iPendingRequest = ETrue; |
90 } |
98 } |
91 else |
99 else |
92 { |
100 { |
93 // the same client already requested such notice |
101 // the same client already requested such notice |
94 // Panic the client |
102 // Panic the client |
95 iPendingRequest = EFalse; |
103 iPendingRequest = EFalse; |
|
104 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FATAL, CTZSERVERSESSION_DOREGISTERTZCHANGENOTIFIER_PANIC, "CTzServerSession::doRegisterTzChangeNotifier : The same client already requested such notice" ); |
|
105 |
96 aMessage.Panic(KTimeZoneServerName, RTz::EPanicNotificationRequestPending); |
106 aMessage.Panic(KTimeZoneServerName, RTz::EPanicNotificationRequestPending); |
|
107 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOREGISTERTZCHANGENOTIFIER_EXIT, "CTzServerSession::doRegisterTzChangeNotifier Exit;KErrCancel=%d", KErrCancel ); |
97 |
108 |
98 return (KErrCancel); |
109 return (KErrCancel); |
99 } |
110 } |
|
111 OstTraceDef1( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOREGISTERTZCHANGENOTIFIER_EXIT2, "CTzServerSession::doRegisterTzChangeNotifier Exit ;KRequestPending=%d", KRequestPending ); |
100 |
112 |
101 return KRequestPending; |
113 return KRequestPending; |
102 } |
114 } |
103 |
115 |
104 // |
116 // |
120 } |
132 } |
121 |
133 |
122 |
134 |
123 TInt CTzServerSession::doSetTimeZoneL(const RMessage2& aMessage) |
135 TInt CTzServerSession::doSetTimeZoneL(const RMessage2& aMessage) |
124 { |
136 { |
|
137 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOSETTIMEZONEL_ENTRY, "CTzServerSession::doSetTimeZoneL Entry" ); |
|
138 |
125 CBufFlat* buffer = CBufFlat::NewL(KMaxTimeZoneIdSize); |
139 CBufFlat* buffer = CBufFlat::NewL(KMaxTimeZoneIdSize); |
126 CleanupStack::PushL(buffer); |
140 CleanupStack::PushL(buffer); |
127 |
141 |
128 // Read from client message buffer |
142 // Read from client message buffer |
129 // reserve the full space |
143 // reserve the full space |
139 |
153 |
140 // Panic the client if it sent invalid data that would cause the server to panic. |
154 // Panic the client if it sent invalid data that would cause the server to panic. |
141 if (err == KErrArgument) |
155 if (err == KErrArgument) |
142 { |
156 { |
143 CleanupStack::PopAndDestroy(buffer); |
157 CleanupStack::PopAndDestroy(buffer); |
|
158 OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOSETTIMEZONEL_PANIC, "CTzServerSession::doSetTimeZoneL: Panic: EPanicInvalidArgument" ); |
|
159 |
144 aMessage.Panic(KTimeZoneServerName, RTz::EPanicInvalidArgument); |
160 aMessage.Panic(KTimeZoneServerName, RTz::EPanicInvalidArgument); |
|
161 OstTraceDef1( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOSETTIMEZONEL_EXIT, "CTzServerSession::doSetTimeZoneL Exit;KRequestPending=%d", KRequestPending ); |
|
162 |
145 return KRequestPending; |
163 return KRequestPending; |
146 } |
164 } |
147 else |
165 else |
148 { |
166 { |
|
167 |
149 User::LeaveIfError(err); |
168 User::LeaveIfError(err); |
150 } |
169 } |
151 |
170 |
152 CleanupStack::PushL(zoneId); |
171 CleanupStack::PushL(zoneId); |
153 const CTzId& KInZoneId = TzServer()->TimeZoneManager().SetTimeZoneL(*zoneId, this, ETrue); |
172 const CTzId& KInZoneId = TzServer()->TimeZoneManager().SetTimeZoneL(*zoneId, this, ETrue); |
163 |
182 |
164 // Write to client message buffer |
183 // Write to client message buffer |
165 aMessage.WriteL(1, buffer->Ptr(0)); |
184 aMessage.WriteL(1, buffer->Ptr(0)); |
166 |
185 |
167 CleanupStack::PopAndDestroy(buffer); |
186 CleanupStack::PopAndDestroy(buffer); |
168 |
187 OstTraceDef1( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOSETTIMEZONEL_EXIT2, "CTzServerSession::doSetTimeZoneL Exit;KErrNone=%d", KErrNone ); |
|
188 |
169 return (KErrNone); |
189 return (KErrNone); |
170 } |
190 } |
171 |
191 |
172 TInt CTzServerSession::doIsDaylightSavingOnL(const RMessage2& aMessage) |
192 TInt CTzServerSession::doIsDaylightSavingOnL(const RMessage2& aMessage) |
173 { |
193 { |
|
194 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOISDAYLIGHTSAVINGONL_ENTRY, "CTzServerSession::doIsDaylightSavingOnL Entry" ); |
|
195 |
174 CBufFlat* buffer = CBufFlat::NewL(KMaxTimeZoneIdSize); |
196 CBufFlat* buffer = CBufFlat::NewL(KMaxTimeZoneIdSize); |
175 CleanupStack::PushL(buffer); |
197 CleanupStack::PushL(buffer); |
176 // Read from client message buffer |
198 // Read from client message buffer |
177 // reserve the full space |
199 // reserve the full space |
178 buffer->ExpandL(0, KMaxTimeZoneIdSize); |
200 buffer->ExpandL(0, KMaxTimeZoneIdSize); |
192 |
214 |
193 // Panic the client if it sent invalid data that would cause the server to panic. |
215 // Panic the client if it sent invalid data that would cause the server to panic. |
194 if (err == KErrArgument) |
216 if (err == KErrArgument) |
195 { |
217 { |
196 CleanupStack::PopAndDestroy(buffer); |
218 CleanupStack::PopAndDestroy(buffer); |
|
219 OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FATAL, CTZSERVERSESSION_DOISDAYLIGHTSAVINGONL_PANIC, "CTzServerSession::doIsDaylightSavingOnL:Client Sent invalid data to server to panic" ); |
|
220 |
197 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
221 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
|
222 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOISDAYLIGHTSAVINGONL_EXIT, "CTzServerSession::doIsDaylightSavingOnL Exit;KRequestPending=%d", KRequestPending ); |
|
223 |
198 return KRequestPending; |
224 return KRequestPending; |
199 } |
225 } |
200 else |
226 else |
201 { |
227 { |
202 User::LeaveIfError(err); |
228 User::LeaveIfError(err); |
213 CleanupStack::PopAndDestroy(zoneId); |
239 CleanupStack::PopAndDestroy(zoneId); |
214 // Write to client message buffer |
240 // Write to client message buffer |
215 TPckg<TInt> response(isDaylightSavingOn); |
241 TPckg<TInt> response(isDaylightSavingOn); |
216 aMessage.WriteL(2, response); |
242 aMessage.WriteL(2, response); |
217 CleanupStack::PopAndDestroy(buffer); |
243 CleanupStack::PopAndDestroy(buffer); |
|
244 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOISDAYLIGHTSAVINGONL_EXIT2, "CTzServerSession::doIsDaylightSavingOnL Exit;KErrNone=%d", KErrNone ); |
|
245 |
218 return (KErrNone); |
246 return (KErrNone); |
219 } |
247 } |
220 |
248 |
221 TInt CTzServerSession::doGetLocalTimeZoneIdL(const RMessage2& aMessage) |
249 TInt CTzServerSession::doGetLocalTimeZoneIdL(const RMessage2& aMessage) |
222 { |
250 { |
|
251 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETLOCALTIMEZONEIDL_ENTRY, "CTzServerSession::doGetLocalTimeZoneIdL Entry" ); |
|
252 |
|
253 |
223 const CTzId& KZoneId = TzServer()->TimeZoneManager().GetTimeZoneIdL(); |
254 const CTzId& KZoneId = TzServer()->TimeZoneManager().GetTimeZoneIdL(); |
224 |
255 |
225 CBufFlat* buffer = CBufFlat::NewL(KMaxTimeZoneIdSize); |
256 CBufFlat* buffer = CBufFlat::NewL(KMaxTimeZoneIdSize); |
226 CleanupStack::PushL(buffer); |
257 CleanupStack::PushL(buffer); |
227 |
258 |
235 |
266 |
236 // Write to client message buffer |
267 // Write to client message buffer |
237 aMessage.WriteL(0, buffer->Ptr(0)); |
268 aMessage.WriteL(0, buffer->Ptr(0)); |
238 |
269 |
239 CleanupStack::PopAndDestroy(buffer); |
270 CleanupStack::PopAndDestroy(buffer); |
|
271 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETLOCALTIMEZONEIDL_EXIT, "CTzServerSession::doGetLocalTimeZoneIdL Exit;KErrNone=%d", KErrNone ); |
|
272 |
240 return (KErrNone); |
273 return (KErrNone); |
241 |
274 |
242 } |
275 } |
243 |
276 |
244 TInt CTzServerSession::doGetLocalEncodedTimeZoneRulesL(const RMessage2& aMessage) |
277 TInt CTzServerSession::doGetLocalEncodedTimeZoneRulesL(const RMessage2& aMessage) |
245 { |
278 { |
|
279 OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETLOCALENCODEDTIMEZONERULESL_ENTRY, "CTzServerSession::doGetLocalEncodedTimeZoneRulesL Entry" ); |
|
280 |
246 TPckgBuf<TInt> rulesSizeBuffer; |
281 TPckgBuf<TInt> rulesSizeBuffer; |
247 aMessage.ReadL(0, rulesSizeBuffer); |
282 aMessage.ReadL(0, rulesSizeBuffer); |
248 |
283 |
249 // Check if rules size buffer is valid. Panic the client if it sent |
284 // Check if rules size buffer is valid. Panic the client if it sent |
250 // invalid data that would cause the server to panic. |
285 // invalid data that would cause the server to panic. |
251 TInt size = rulesSizeBuffer(); |
286 TInt size = rulesSizeBuffer(); |
252 const TInt KMaxSize = KMaxTInt / 2; |
287 const TInt KMaxSize = KMaxTInt / 2; |
253 if (size <= 0 || size >= KMaxSize) |
288 if (size <= 0 || size >= KMaxSize) |
254 { |
289 { |
|
290 OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FATAL, CTZSERVERSESSION_DOGETLOCALENCODEDTIMEZONERULESL_PANIC, "CTzServerSession::doGetLocalEncodedTimeZoneRulesL:Invalid rules buffer size sent by client to server" ); |
|
291 |
255 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
292 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
|
293 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETLOCALENCODEDTIMEZONERULESL_EXIT, "CTzServerSession::doGetLocalEncodedTimeZoneRulesL Exit;KRequestPending=%d", KRequestPending ); |
|
294 |
256 return KRequestPending; |
295 return KRequestPending; |
257 } |
296 } |
258 |
297 |
259 CBufFlat* buffer = CBufFlat::NewL(rulesSizeBuffer()); |
298 CBufFlat* buffer = CBufFlat::NewL(rulesSizeBuffer()); |
260 CleanupStack::PushL(buffer); |
299 CleanupStack::PushL(buffer); |
269 // If the stream contains invalid data that would cause the server to panic |
308 // If the stream contains invalid data that would cause the server to panic |
270 // then panic the client. |
309 // then panic the client. |
271 if (err == KErrArgument) |
310 if (err == KErrArgument) |
272 { |
311 { |
273 CleanupStack::PopAndDestroy(buffer); |
312 CleanupStack::PopAndDestroy(buffer); |
|
313 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FATAL, CTZSERVERSESSION_DOGETLOCALENCODEDTIMEZONERULESL_PANIC2, "CTzServerSession::doGetLocalEncodedTimeZoneRulesL:Invalid data sent by client to Server" ); |
|
314 |
274 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
315 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
|
316 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETLOCALENCODEDTIMEZONERULESL_EXIT2, "CTzServerSession::doGetLocalEncodedTimeZoneRulesL Exit;KRequestPending=%d", KRequestPending ); |
|
317 |
275 return KRequestPending; |
318 return KRequestPending; |
276 } |
319 } |
277 else |
320 else |
278 { |
321 { |
279 User::LeaveIfError(err); |
322 User::LeaveIfError(err); |
284 |
327 |
285 // Write to client message buffer |
328 // Write to client message buffer |
286 aMessage.WriteL(1, buffer->Ptr(0)); |
329 aMessage.WriteL(1, buffer->Ptr(0)); |
287 |
330 |
288 CleanupStack::PopAndDestroy(buffer); |
331 CleanupStack::PopAndDestroy(buffer); |
|
332 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETLOCALENCODEDTIMEZONERULESL_EXIT3, "CTzServerSession::doGetLocalEncodedTimeZoneRulesL Exit;KErrNone=%d", KErrNone ); |
|
333 |
289 return KErrNone; |
334 return KErrNone; |
290 } |
335 } |
291 |
336 |
292 TInt CTzServerSession::doGetLocalEncodedTimeZoneRulesSizeL(const RMessage2& aMessage) |
337 TInt CTzServerSession::doGetLocalEncodedTimeZoneRulesSizeL(const RMessage2& aMessage) |
293 { |
338 { |
310 return KErrNone; |
355 return KErrNone; |
311 } |
356 } |
312 |
357 |
313 TInt CTzServerSession::doGetForeignEncodedTimeZoneRulesL(const RMessage2& aMessage) |
358 TInt CTzServerSession::doGetForeignEncodedTimeZoneRulesL(const RMessage2& aMessage) |
314 { |
359 { |
|
360 OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETFOREIGNENCODEDTIMEZONERULESL_ENTRY, "CTzServerSession::doGetForeignEncodedTimeZoneRulesL Entry" ); |
|
361 |
315 TPckgBuf<TInt> rulesSizeBuffer; |
362 TPckgBuf<TInt> rulesSizeBuffer; |
316 aMessage.ReadL(0, rulesSizeBuffer); |
363 aMessage.ReadL(0, rulesSizeBuffer); |
317 |
364 |
318 // Check if rules size buffer is invalid. Panic the client if it sent |
365 // Check if rules size buffer is invalid. Panic the client if it sent |
319 // invalid data that would cause the server to panic. |
366 // invalid data that would cause the server to panic. |
320 TInt size = rulesSizeBuffer(); |
367 TInt size = rulesSizeBuffer(); |
321 const TInt KMaxSize = KMaxTInt/2; |
368 const TInt KMaxSize = KMaxTInt/2; |
322 if (size <= 0 || size >= KMaxSize) |
369 if (size <= 0 || size >= KMaxSize) |
323 { |
370 { |
|
371 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FATAL, CTZSERVERSESSION_DOGETFOREIGNENCODEDTIMEZONERULESL_PANIC, "CTzServerSession::doGetForeignEncodedTimeZoneRulesL Panic: EPanicInvalidArgument" ); |
|
372 |
324 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
373 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
|
374 OstTraceDef1( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETFOREIGNENCODEDTIMEZONERULESL_EXIT, "CTzServerSession::doGetForeignEncodedTimeZoneRulesL Exit;KRequestPending=%d", KRequestPending ); |
|
375 |
325 return KRequestPending; |
376 return KRequestPending; |
326 } |
377 } |
327 |
378 |
328 CBufFlat* buffer = CBufFlat::NewL(rulesSizeBuffer()); |
379 CBufFlat* buffer = CBufFlat::NewL(rulesSizeBuffer()); |
329 CleanupStack::PushL(buffer); |
380 CleanupStack::PushL(buffer); |
337 // then panic the client. |
388 // then panic the client. |
338 TRAPD(err, KRules.ExternalizeL(writeStream)); |
389 TRAPD(err, KRules.ExternalizeL(writeStream)); |
339 if (err == KErrArgument) |
390 if (err == KErrArgument) |
340 { |
391 { |
341 CleanupStack::PopAndDestroy(buffer); |
392 CleanupStack::PopAndDestroy(buffer); |
|
393 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FATAL, CTZSERVERSESSION_DOGETFOREIGNENCODEDTIMEZONERULESL_PANIC2, "CTzServerSession::doGetForeignEncodedTimeZoneRulesL:Invalid data sent by client to Server" ); |
|
394 |
342 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
395 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
|
396 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETFOREIGNENCODEDTIMEZONERULESL_EXIT2, "CTzServerSession::doGetForeignEncodedTimeZoneRulesL Exit;KRequestPending=%d", KRequestPending ); |
|
397 |
343 return KRequestPending; |
398 return KRequestPending; |
344 } |
399 } |
345 else |
400 else |
346 { |
401 { |
347 User::LeaveIfError(err); |
402 User::LeaveIfError(err); |
348 } |
403 } |
349 |
404 |
|
405 |
350 writeStream.CommitL(); |
406 writeStream.CommitL(); |
351 writeStream.Close(); |
407 writeStream.Close(); |
352 |
408 |
353 // Write to client message buffer |
409 // Write to client message buffer |
354 aMessage.WriteL(1, buffer->Ptr(0)); |
410 aMessage.WriteL(1, buffer->Ptr(0)); |
355 |
411 |
356 CleanupStack::PopAndDestroy(buffer); |
412 CleanupStack::PopAndDestroy(buffer); |
|
413 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETFOREIGNENCODEDTIMEZONERULESL_EXIT3, "CTzServerSession::doGetForeignEncodedTimeZoneRulesL Exit;KErrNone=%d", KErrNone ); |
|
414 |
357 return KErrNone; |
415 return KErrNone; |
358 } |
416 } |
359 |
417 |
360 TInt CTzServerSession::doGetForeignEncodedTimeZoneRulesSizeL(const RMessage2& aMessage) |
418 TInt CTzServerSession::doGetForeignEncodedTimeZoneRulesSizeL(const RMessage2& aMessage) |
361 { |
419 { |
|
420 OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETFOREIGNENCODEDTIMEZONERULESSIZEL_ENTRY, "CTzServerSession::doGetForeignEncodedTimeZoneRulesSizeL Entry" ); |
|
421 |
362 TPckgBuf<TTime> startTimeBuffer; |
422 TPckgBuf<TTime> startTimeBuffer; |
363 aMessage.ReadL(0, startTimeBuffer); |
423 aMessage.ReadL(0, startTimeBuffer); |
364 |
424 |
365 TPckgBuf<TTime> endTimeBuffer; |
425 TPckgBuf<TTime> endTimeBuffer; |
366 aMessage.ReadL(1, endTimeBuffer); |
426 aMessage.ReadL(1, endTimeBuffer); |
382 // If the stream contains invalid data that would cause the server to panic |
442 // If the stream contains invalid data that would cause the server to panic |
383 // then panic the client. |
443 // then panic the client. |
384 if (err == KErrArgument) |
444 if (err == KErrArgument) |
385 { |
445 { |
386 CleanupStack::PopAndDestroy(buffer); |
446 CleanupStack::PopAndDestroy(buffer); |
|
447 OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FATAL, CTZSERVERSESSION_DOGETFOREIGNENCODEDTIMEZONERULESSIZEL_PANIC, "CTzServerSession::doGetForeignEncodedTimeZoneRulesSizeL Panic: Invalid data sent by client to server" ); |
|
448 |
387 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
449 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
|
450 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETFOREIGNENCODEDTIMEZONERULESSIZEL_EXIT, "CTzServerSession::doGetForeignEncodedTimeZoneRulesSizeL Exit;KRequestPending=%d", KRequestPending ); |
|
451 |
388 return KRequestPending; |
452 return KRequestPending; |
389 } |
453 } |
390 else |
454 else |
391 { |
455 { |
392 User::LeaveIfError(err); |
456 User::LeaveIfError(err); |
404 // Write to client message buffer |
468 // Write to client message buffer |
405 TPckgBuf<TInt> rulesSizeBuffer(rulesSize); |
469 TPckgBuf<TInt> rulesSizeBuffer(rulesSize); |
406 aMessage.WriteL(3, rulesSizeBuffer); |
470 aMessage.WriteL(3, rulesSizeBuffer); |
407 |
471 |
408 CleanupStack::PopAndDestroy(2,buffer); |
472 CleanupStack::PopAndDestroy(2,buffer); |
|
473 OstTraceDef1( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETFOREIGNENCODEDTIMEZONERULESSIZEL_EXIT2, "CTzServerSession::doGetForeignEncodedTimeZoneRulesSizeL Exit;KErrNone=%d", KErrNone ); |
|
474 |
409 return KErrNone; |
475 return KErrNone; |
410 } |
476 } |
411 |
477 |
412 TInt CTzServerSession::doConvertLocalZoneTimeL(const RMessage2& aMessage) |
478 TInt CTzServerSession::doConvertLocalZoneTimeL(const RMessage2& aMessage) |
413 { |
479 { |
428 } |
494 } |
429 |
495 |
430 |
496 |
431 TInt CTzServerSession::doConvertForeignZoneTimeL(const RMessage2& aMessage) |
497 TInt CTzServerSession::doConvertForeignZoneTimeL(const RMessage2& aMessage) |
432 { |
498 { |
|
499 OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOCONVERTFOREIGNZONETIMEL_ENTRY, "CTzServerSession::doConvertForeignZoneTimeL Entry" ); |
|
500 |
433 TPckgBuf<TTime> timeBuffer; |
501 TPckgBuf<TTime> timeBuffer; |
434 aMessage.ReadL(0, timeBuffer); |
502 aMessage.ReadL(0, timeBuffer); |
435 |
503 |
436 TPckgBuf<TTzTimeReference> timerRefBuffer; |
504 TPckgBuf<TTzTimeReference> timerRefBuffer; |
437 aMessage.ReadL(1, timerRefBuffer); |
505 aMessage.ReadL(1, timerRefBuffer); |
453 // If the stream contains invalid data that would cause the server to panic |
521 // If the stream contains invalid data that would cause the server to panic |
454 // then panic the client. |
522 // then panic the client. |
455 if (err == KErrArgument) |
523 if (err == KErrArgument) |
456 { |
524 { |
457 CleanupStack::PopAndDestroy(buffer); |
525 CleanupStack::PopAndDestroy(buffer); |
|
526 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FATAL, CTZSERVERSESSION_DOCONVERTFOREIGNZONETIMEL_PANIC, "CTzServerSession::doConvertForeignZoneTimeL panic: Invalid data sent by client" ); |
|
527 |
458 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
528 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
|
529 OstTraceDef1( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOCONVERTFOREIGNZONETIMEL_EXIT, "CTzServerSession::doConvertForeignZoneTimeL Exit;KRequestPending=%d", KRequestPending ); |
|
530 |
459 return KRequestPending; |
531 return KRequestPending; |
460 } |
532 } |
461 else |
533 else |
462 { |
534 { |
463 User::LeaveIfError(err); |
535 User::LeaveIfError(err); |
471 // Write to client message buffer |
543 // Write to client message buffer |
472 TPckg<TTime> timeInBuffer(time); |
544 TPckg<TTime> timeInBuffer(time); |
473 aMessage.WriteL(3, timeInBuffer); |
545 aMessage.WriteL(3, timeInBuffer); |
474 |
546 |
475 CleanupStack::PopAndDestroy(2); |
547 CleanupStack::PopAndDestroy(2); |
|
548 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOCONVERTFOREIGNZONETIMEL_EXIT2, "CTzServerSession::doConvertForeignZoneTimeL Exit;KErrNone=%d", KErrNone ); |
|
549 |
476 return (KErrNone); |
550 return (KErrNone); |
477 } |
551 } |
478 |
552 |
479 /** |
553 /** |
480 Retrieves UTC offset for a number of time zone ids |
554 Retrieves UTC offset for a number of time zone ids |
481 */ |
555 */ |
482 TInt CTzServerSession::doGetOffsetsForTimeZoneIdsL(const RMessage2& aMessage) const |
556 TInt CTzServerSession::doGetOffsetsForTimeZoneIdsL(const RMessage2& aMessage) const |
483 { |
557 { |
|
558 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETOFFSETSFORTIMEZONEIDSL_ENTRY, "CTzServerSession::doGetOffsetsForTimeZoneIdsL Entry" ); |
|
559 |
484 TInt bufferSize = aMessage.Int0(); |
560 TInt bufferSize = aMessage.Int0(); |
485 |
561 |
486 // If buffer size invalid then panic client. |
562 // If buffer size invalid then panic client. |
487 const TInt KMaxSize = KMaxTInt / 4; |
563 const TInt KMaxSize = KMaxTInt / 4; |
488 if (bufferSize <= 0 || bufferSize > KMaxSize) |
564 if (bufferSize <= 0 || bufferSize > KMaxSize) |
489 { |
565 { |
|
566 OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FATAL, CTZSERVERSESSION_DOGETOFFSETSFORTIMEZONEIDSL_PANIC, "CTzServerSession::doGetOffsetsForTimeZoneIdsL panic:Invalid buffer size sent by client" ); |
|
567 |
490 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
568 aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument ); |
|
569 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETOFFSETSFORTIMEZONEIDSL_EXIT, "CTzServerSession::doGetOffsetsForTimeZoneIdsL Exit;KRequestPending=%d", KRequestPending ); |
|
570 |
491 return KRequestPending; |
571 return KRequestPending; |
492 } |
572 } |
493 |
573 |
494 CBufFlat* idBuf = CBufFlat::NewL(bufferSize); |
574 CBufFlat* idBuf = CBufFlat::NewL(bufferSize); |
495 CleanupStack::PushL(idBuf); |
575 CleanupStack::PushL(idBuf); |
541 NTzUpdate::TTimeZoneChange change; |
622 NTzUpdate::TTimeZoneChange change; |
542 change.iNewTimeZoneId = aMessage.Int0(); |
623 change.iNewTimeZoneId = aMessage.Int0(); |
543 change.iOldTimeZoneId = aMessage.Int1(); |
624 change.iOldTimeZoneId = aMessage.Int1(); |
544 |
625 |
545 TPckgBuf<NTzUpdate::TTimeZoneChange> changeBuf(change); |
626 TPckgBuf<NTzUpdate::TTimeZoneChange> changeBuf(change); |
|
627 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,PUBLISH_UPDATE_NOTIFICATION, TTIME_ZONE_CHANGE, "CTzServerSession::doNotifyHomeTimeZoneChanged: Time zone change notification" ); |
|
628 |
546 return RProperty::Set(NTzUpdate::KPropertyCategory, NTzUpdate::EHomeTimeZoneId, changeBuf); |
629 return RProperty::Set(NTzUpdate::KPropertyCategory, NTzUpdate::EHomeTimeZoneId, changeBuf); |
547 } |
630 } |
548 |
631 |
549 TInt CTzServerSession::doSetHomeTimeL(const RMessage2& aMessage) |
632 TInt CTzServerSession::doSetHomeTimeL(const RMessage2& aMessage) |
550 { |
633 { |
571 * 1 : Input - Data Buffer contains time zone info |
654 * 1 : Input - Data Buffer contains time zone info |
572 * 2 : Output - ID of the time zone created |
655 * 2 : Output - ID of the time zone created |
573 */ |
656 */ |
574 TInt CTzServerSession::doCreateUserTimeZoneL(const RMessage2& aMessage) |
657 TInt CTzServerSession::doCreateUserTimeZoneL(const RMessage2& aMessage) |
575 { |
658 { |
|
659 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOCREATEUSERTIMEZONEL_ENTRY, "CTzServerSession::doCreateUserTimeZoneL Entry" ); |
|
660 |
|
661 |
576 const TInt buffersize = aMessage.Int0(); |
662 const TInt buffersize = aMessage.Int0(); |
577 |
663 |
578 CBufFlat* buffer = CBufFlat::NewL(buffersize); |
664 CBufFlat* buffer = CBufFlat::NewL(buffersize); |
579 CleanupStack::PushL(buffer); |
665 CleanupStack::PushL(buffer); |
580 |
666 |
591 |
677 |
592 // Panic the client if it sent invalid data that would cause the server to panic. |
678 // Panic the client if it sent invalid data that would cause the server to panic. |
593 if (err == KErrArgument) |
679 if (err == KErrArgument) |
594 { |
680 { |
595 CleanupStack::PopAndDestroy(2, buffer); |
681 CleanupStack::PopAndDestroy(2, buffer); |
|
682 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FATAL, CTZSERVERSESSION_DOCREATEUSERTIMEZONEL_FATAL, "CTzServerSession::doCreateUserTimeZoneL:Panic:EPanicInvalidArgument" ); |
|
683 |
596 aMessage.Panic(KTimeZoneServerName, RTz::EPanicInvalidArgument); |
684 aMessage.Panic(KTimeZoneServerName, RTz::EPanicInvalidArgument); |
|
685 OstTraceDef1( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOCREATEUSERTIMEZONEL_EXIT, "CTzServerSession::doCreateUserTimeZoneL Exit;KRequestPending=%d", KRequestPending ); |
|
686 |
597 return KRequestPending; |
687 return KRequestPending; |
598 } |
688 } |
599 else |
689 else |
600 { |
690 { |
601 User::LeaveIfError(err); |
691 User::LeaveIfError(err); |
607 CleanupStack::PushL(names); |
697 CleanupStack::PushL(names); |
608 TInt id = TzServer()->UserTimeZoneDb().CreateTzL(*rules, *names); |
698 TInt id = TzServer()->UserTimeZoneDb().CreateTzL(*rules, *names); |
609 CleanupStack::PopAndDestroy(4, buffer); |
699 CleanupStack::PopAndDestroy(4, buffer); |
610 TPckgBuf<TInt> idBuffer(id); |
700 TPckgBuf<TInt> idBuffer(id); |
611 aMessage.WriteL(2, idBuffer); |
701 aMessage.WriteL(2, idBuffer); |
|
702 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOCREATEUSERTIMEZONEL_EXIT2, "CTzServerSession::doCreateUserTimeZoneL Exit;KErrNone=%d", KErrNone ); |
|
703 |
612 return KErrNone; |
704 return KErrNone; |
613 } |
705 } |
614 |
706 |
615 /** |
707 /** |
616 * Update a user defined time zone |
708 * Update a user defined time zone |
618 * 1 : Input - Data buffer contained time zone info |
710 * 1 : Input - Data buffer contained time zone info |
619 * 2 : Input - ID of thetTime zone to be updated |
711 * 2 : Input - ID of thetTime zone to be updated |
620 */ |
712 */ |
621 TInt CTzServerSession::doUpdateUserTimeZoneL(const RMessage2& aMessage) |
713 TInt CTzServerSession::doUpdateUserTimeZoneL(const RMessage2& aMessage) |
622 { |
714 { |
|
715 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOUPDATEUSERTIMEZONEL_ENTRY, "CTzServerSession::doUpdateUserTimeZoneL Entry" ); |
|
716 |
623 const TInt buffersize = aMessage.Int0(); |
717 const TInt buffersize = aMessage.Int0(); |
624 |
718 |
625 CBufFlat* buffer = CBufFlat::NewL(buffersize); |
719 CBufFlat* buffer = CBufFlat::NewL(buffersize); |
626 CleanupStack::PushL(buffer); |
720 CleanupStack::PushL(buffer); |
627 |
721 |
638 |
732 |
639 // Panic the client if it sent invalid data that would cause the server to panic. |
733 // Panic the client if it sent invalid data that would cause the server to panic. |
640 if (err == KErrArgument) |
734 if (err == KErrArgument) |
641 { |
735 { |
642 CleanupStack::PopAndDestroy(2, buffer); |
736 CleanupStack::PopAndDestroy(2, buffer); |
|
737 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FATAL, CTZSERVERSESSION_DOUPDATEUSERTIMEZONEL_PANIC, "CTzServerSession::doUpdateUserTimeZoneL Panic: Invalid data sent by client to server" ); |
|
738 |
643 aMessage.Panic(KTimeZoneServerName, RTz::EPanicInvalidArgument); |
739 aMessage.Panic(KTimeZoneServerName, RTz::EPanicInvalidArgument); |
|
740 OstTraceDef1( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_DOUPDATEUSERTIMEZONEL_EXIT, "CTzServerSession::doUpdateUserTimeZoneL Exit;KRequestPending=%d", KRequestPending ); |
|
741 |
644 return KRequestPending; |
742 return KRequestPending; |
645 } |
743 } |
646 else |
744 else |
647 { |
745 { |
648 User::LeaveIfError(err); |
746 User::LeaveIfError(err); |
655 |
753 |
656 const TInt id = aMessage.Int2(); |
754 const TInt id = aMessage.Int2(); |
657 |
755 |
658 TzServer()->UserTimeZoneDb().UpdateTzL(id, *rules, *names); |
756 TzServer()->UserTimeZoneDb().UpdateTzL(id, *rules, *names); |
659 CleanupStack::PopAndDestroy(4, buffer); |
757 CleanupStack::PopAndDestroy(4, buffer); |
|
758 OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOUPDATEUSERTIMEZONEL_EXIT2, "CTzServerSession::doUpdateUserTimeZoneL Exit" ); |
|
759 |
660 return KErrNone; |
760 return KErrNone; |
661 } |
761 } |
662 |
762 |
663 /** |
763 /** |
664 * Delete a user defined time zone |
764 * Delete a user defined time zone |
695 * Gets user defined time zone names |
795 * Gets user defined time zone names |
696 * Arguments: 0 : Output - Data buffer contained time zone name |
796 * Arguments: 0 : Output - Data buffer contained time zone name |
697 */ |
797 */ |
698 TInt CTzServerSession::doGetUserTimeZoneNamesL(const RMessage2& aMessage) |
798 TInt CTzServerSession::doGetUserTimeZoneNamesL(const RMessage2& aMessage) |
699 { |
799 { |
|
800 OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETUSERTIMEZONENAMESL_ENTRY, "CTzServerSession::doGetUserTimeZoneNamesL Entry" ); |
|
801 |
700 TInt size = iTzUserDataCache->SizeOfNames(); |
802 TInt size = iTzUserDataCache->SizeOfNames(); |
701 if ( size > 0 ) |
803 if ( size > 0 ) |
702 { |
804 { |
703 CBufFlat* buffer = CBufFlat::NewL(size); |
805 CBufFlat* buffer = CBufFlat::NewL(size); |
704 CleanupStack::PushL(buffer); |
806 CleanupStack::PushL(buffer); |
710 const CTzUserNames& names = iTzUserDataCache->GetNames(); |
812 const CTzUserNames& names = iTzUserDataCache->GetNames(); |
711 writeStream << names; |
813 writeStream << names; |
712 writeStream.CommitL(); |
814 writeStream.CommitL(); |
713 aMessage.WriteL(0, buffer->Ptr(0)); |
815 aMessage.WriteL(0, buffer->Ptr(0)); |
714 CleanupStack::PopAndDestroy(2, buffer); |
816 CleanupStack::PopAndDestroy(2, buffer); |
|
817 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETUSERTIMEZONENAMESL_EXIT, "CTzServerSession::doGetUserTimeZoneNamesLExit;KErrNone=%d", KErrNone ); |
|
818 |
715 return KErrNone; |
819 return KErrNone; |
716 } |
820 } |
|
821 OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZSERVERSESSION_DOGETUSERTIMEZONENAMESL_EXIT2, "CTzServerSession::doGetUserTimeZoneNamesL Exit;KErrArgument=%d", KErrArgument ); |
|
822 |
717 return KErrArgument; |
823 return KErrArgument; |
718 } |
824 } |
719 |
825 |
720 /** |
826 /** |
721 * Gets the size of user defined time zone Ids |
827 * Gets the size of user defined time zone Ids |
722 * Arguments: 0 : Output - Size of time zone IDs |
828 * Arguments: 0 : Output - Size of time zone IDs |
723 */ |
829 */ |
724 TInt CTzServerSession::doGetUserTimeZoneIdsSizeL(const RMessage2& aMessage) |
830 TInt CTzServerSession::doGetUserTimeZoneIdsSizeL(const RMessage2& aMessage) |
725 { |
831 { |
|
832 |
726 RArray<TUint32> ids; |
833 RArray<TUint32> ids; |
727 CleanupClosePushL(ids); |
834 CleanupClosePushL(ids); |
728 TzServer()->UserTimeZoneDb().ReadTzIdsL(ids); |
835 TzServer()->UserTimeZoneDb().ReadTzIdsL(ids); |
729 iTzUserDataCache->SetIdsL(ids); |
836 iTzUserDataCache->SetIdsL(ids); |
730 CleanupStack::PopAndDestroy(&ids); |
837 CleanupStack::PopAndDestroy(&ids); |
740 * Gets the user defined time zone Ids |
847 * Gets the user defined time zone Ids |
741 * Arguments: 0 : Output - Data buffer contained time zone IDs |
848 * Arguments: 0 : Output - Data buffer contained time zone IDs |
742 */ |
849 */ |
743 TInt CTzServerSession::doGetUserTimeZoneIdsL(const RMessage2& aMessage) |
850 TInt CTzServerSession::doGetUserTimeZoneIdsL(const RMessage2& aMessage) |
744 { |
851 { |
|
852 |
745 CBufFlat* buffer = CBufFlat::NewL(iTzUserDataCache->SizeOfIds()); |
853 CBufFlat* buffer = CBufFlat::NewL(iTzUserDataCache->SizeOfIds()); |
746 CleanupStack::PushL(buffer); |
854 CleanupStack::PushL(buffer); |
747 buffer->ExpandL(0,iTzUserDataCache->SizeOfIds()); |
855 buffer->ExpandL(0,iTzUserDataCache->SizeOfIds()); |
748 |
856 |
749 RBufWriteStream writeStream; |
857 RBufWriteStream writeStream; |
762 return KErrNone; |
870 return KErrNone; |
763 } |
871 } |
764 |
872 |
765 TInt CTzServerSession::doGetHeapSizeL(const RMessage2& aMessage) |
873 TInt CTzServerSession::doGetHeapSizeL(const RMessage2& aMessage) |
766 { |
874 { |
|
875 |
767 TInt reply = User::Heap().Count(); |
876 TInt reply = User::Heap().Count(); |
768 TInt sizeInBytes; |
877 TInt sizeInBytes; |
769 reply = User::AllocSize(sizeInBytes); |
878 reply = User::AllocSize(sizeInBytes); |
770 TPckg<TInt> heapCellsBuffer(reply); |
879 TPckg<TInt> heapCellsBuffer(reply); |
771 TPckg<TInt> heapsizeBuffer(sizeInBytes); |
880 TPckg<TInt> heapsizeBuffer(sizeInBytes); |
774 return reply; |
883 return reply; |
775 } |
884 } |
776 |
885 |
777 TInt CTzServerSession::doLocalizationReadCitiesSizeL(const RMessage2& aMessage) |
886 TInt CTzServerSession::doLocalizationReadCitiesSizeL(const RMessage2& aMessage) |
778 { |
887 { |
|
888 |
779 iCitiesResultCache.ResetAndDestroy(); |
889 iCitiesResultCache.ResetAndDestroy(); |
780 TzServer()->LocalizationDb().ReadCitiesL(iCitiesResultCache); |
890 TzServer()->LocalizationDb().ReadCitiesL(iCitiesResultCache); |
781 TInt resultSize = CTzLocalizedCityRecord::ExternalizeSize(iCitiesResultCache); |
891 TInt resultSize = CTzLocalizedCityRecord::ExternalizeSize(iCitiesResultCache); |
782 |
892 |
783 // Write to client message buffer |
893 // Write to client message buffer |
787 return KErrNone; |
897 return KErrNone; |
788 } |
898 } |
789 |
899 |
790 TInt CTzServerSession::doLocalizationReadCitiesTzIdSizeL(const RMessage2& aMessage) |
900 TInt CTzServerSession::doLocalizationReadCitiesTzIdSizeL(const RMessage2& aMessage) |
791 { |
901 { |
|
902 |
792 iCitiesResultCache.ResetAndDestroy(); |
903 iCitiesResultCache.ResetAndDestroy(); |
793 TzServer()->LocalizationDb().ReadCitiesL(iCitiesResultCache, aMessage.Int1()); |
904 TzServer()->LocalizationDb().ReadCitiesL(iCitiesResultCache, aMessage.Int1()); |
794 TInt resultSize = CTzLocalizedCityRecord::ExternalizeSize(iCitiesResultCache); |
905 TInt resultSize = CTzLocalizedCityRecord::ExternalizeSize(iCitiesResultCache); |
795 |
906 |
796 // Write to client message buffer |
907 // Write to client message buffer |
800 return KErrNone; |
911 return KErrNone; |
801 } |
912 } |
802 |
913 |
803 TInt CTzServerSession::doLocalizationReadCitiesInGroupSizeL(const RMessage2& aMessage) |
914 TInt CTzServerSession::doLocalizationReadCitiesInGroupSizeL(const RMessage2& aMessage) |
804 { |
915 { |
|
916 |
805 iCitiesResultCache.ResetAndDestroy(); |
917 iCitiesResultCache.ResetAndDestroy(); |
806 TzServer()->LocalizationDb().ReadCitiesInGroupL(iCitiesResultCache, aMessage.Int1()); |
918 TzServer()->LocalizationDb().ReadCitiesInGroupL(iCitiesResultCache, aMessage.Int1()); |
807 TInt resultSize = CTzLocalizedCityRecord::ExternalizeSize(iCitiesResultCache); |
919 TInt resultSize = CTzLocalizedCityRecord::ExternalizeSize(iCitiesResultCache); |
808 |
920 |
809 // Write to client message buffer |
921 // Write to client message buffer |
813 return KErrNone; |
925 return KErrNone; |
814 } |
926 } |
815 |
927 |
816 TInt CTzServerSession::doLocalizationReadCitiesL(const RMessage2& aMessage) |
928 TInt CTzServerSession::doLocalizationReadCitiesL(const RMessage2& aMessage) |
817 { |
929 { |
|
930 |
818 TInt maxSize = aMessage.GetDesLengthL(0); |
931 TInt maxSize = aMessage.GetDesLengthL(0); |
819 CBufFlat* buffer = CBufFlat::NewL(maxSize); |
932 CBufFlat* buffer = CBufFlat::NewL(maxSize); |
820 CleanupStack::PushL(buffer); |
933 CleanupStack::PushL(buffer); |
821 |
934 |
822 RBufWriteStream writeStream; |
935 RBufWriteStream writeStream; |
1020 return KErrNone; |
1133 return KErrNone; |
1021 } |
1134 } |
1022 |
1135 |
1023 void CTzServerSession::ServiceL(const RMessage2& aMessage) |
1136 void CTzServerSession::ServiceL(const RMessage2& aMessage) |
1024 { |
1137 { |
|
1138 OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZSERVERSESSION_SERVICEL_ENTRY, "CTzServerSession::ServiceL Entry" ); |
|
1139 |
|
1140 |
1025 TInt reply = KErrNone; |
1141 TInt reply = KErrNone; |
1026 switch(aMessage.Function()) |
1142 switch(aMessage.Function()) |
1027 { |
1143 { |
1028 #if defined(_DEBUG) |
1144 #if defined(_DEBUG) |
1029 case CTzServer::ESrvOpcodeResourceCount: |
1145 case CTzServer::ESrvOpcodeResourceCount: |