1 #include <string.h>
2
3 #include <gammu.h>
4 #include "gsmstate.h"
5 #include "gsmcomon.h"
6 #include "debug.h"
7
8 #ifdef __FUNCTION__WORKING
9 #define PRINT_FUNCTION_START smprintf(s, "Entering %s\n", __FUNCTION__);
10 #define PRINT_FUNCTION_END smprintf(s, "Leaving %s\n", __FUNCTION__);
11 #else
12 #define PRINT_FUNCTION_START smprintf(s, "Entering %s:%d\n", __FILE__, __LINE__);
13 #define PRINT_FUNCTION_END smprintf(s, "Leaving %s:%d\n", __FILE__, __LINE__);
14 #endif
15 #define PRINT_MEMORY_INFO() smprintf(s, "Location = %d, Memory type = %s\n", entry->Location, GSM_MemoryTypeToString(entry->MemoryType));
16 #define PRINT_TODO_INFO() smprintf(s, "Location = %d\n", ToDo->Location);
17 #define PRINT_CALENDAR_INFO() smprintf(s, "Location = %d\n", Note->Location);
18 #define PRINT_NOTE_INFO() smprintf(s, "Location = %d\n", Note->Location);
19 #define PRINT_MSMS_INFO() smprintf(s, "Number = %d, Location = %d, Folder = %d\n", sms->Number, sms->SMS[0].Location, sms->SMS[0].Folder);
20 #define PRINT_SMS_INFO() smprintf(s, "Location = %d, Folder = %d\n", sms->Location, sms->Folder);
21 #define PRINT_START() if (start) smprintf(s, "Starting reading!\n");
22
23 /**
24 * Prints error message (if any) to debug log.
25 *
26 * \param err Error code to check.
27 */
28 #define PRINT_LOG_ERROR(err) \
29 { \
30 GSM_LogError(s, __FUNCTION__, err); \
31 PRINT_FUNCTION_END \
32 }
33
34 /**
35 * Checks whether we are connected to phone, fails with error
36 * otherwise.
37 */
38 #define CHECK_PHONE_CONNECTION() \
39 { \
40 PRINT_FUNCTION_START \
41 if (!GSM_IsConnected(s)) { \
42 return ERR_NOTCONNECTED; \
43 } \
44 if (s->Phone.Functions->PreAPICall != NONEFUNCTION) { \
45 err = s->Phone.Functions->PreAPICall(s); \
46 if (err != ERR_NONE) { \
47 return err; \
48 } \
49 } \
50 }
51
52 /**
53 * Tries the command a couple of times to see if it can complete
54 * without an ERR_BUSY return.
55 */
56 #define RUN_RESTARTABLE(return_value, function_call) \
57 { \
58 int restarts; \
59 for (restarts = 0; restarts < 10; ++restarts) { \
60 unsigned useconds = 10000 << restarts; \
61 return_value = (function_call); \
62 if (return_value != ERR_BUSY) \
63 break; \
64 smprintf(s, "Sleeping %d ms before retrying the last command\n", useconds / 1000); \
65 usleep(useconds); \
66 } \
67 }
68
69 /**
70 * Reads manufacturer from phone.
71 */
GSM_GetManufacturer(GSM_StateMachine * s,char * value)72 GSM_Error GSM_GetManufacturer(GSM_StateMachine *s, char *value)
73 {
74 GSM_Error err;
75
76 CHECK_PHONE_CONNECTION();
77
78 s->Phone.Data.Manufacturer[0] = '\0';
79 err = s->Phone.Functions->GetManufacturer(s);
80 if (value != NULL) {
81 strcpy(value, s->Phone.Data.Manufacturer);
82 }
83
84 PRINT_LOG_ERROR(err);
85 return err;
86 }
87 /**
88 * Reads model from phone.
89 */
GSM_GetModel(GSM_StateMachine * s,char * value)90 GSM_Error GSM_GetModel(GSM_StateMachine *s, char *value)
91 {
92 GSM_Error err;
93
94 CHECK_PHONE_CONNECTION();
95
96 s->Phone.Data.Model[0] = '\0';
97 err = s->Phone.Functions->GetModel(s);
98 if (value != NULL) {
99 strcpy(value, s->Phone.Data.Model);
100 }
101
102 PRINT_LOG_ERROR(err);
103 return err;
104 }
105 /**
106 * Reads firmware information from phone.
107 */
GSM_GetFirmware(GSM_StateMachine * s,char * value,char * date,double * num)108 GSM_Error GSM_GetFirmware(GSM_StateMachine *s, char *value, char *date, double *num)
109 {
110 GSM_Error err;
111
112 CHECK_PHONE_CONNECTION();
113
114 s->Phone.Data.Version[0] = '\0';
115 err = s->Phone.Functions->GetFirmware(s);
116 if (value != NULL) {
117 strcpy(value, s->Phone.Data.Version);
118 }
119 if (date != NULL) {
120 strcpy(date, s->Phone.Data.VerDate);
121 }
122 if (num != NULL) {
123 *num = s->Phone.Data.VerNum;
124 }
125
126 PRINT_LOG_ERROR(err);
127 return err;
128 }
129 /**
130 * Reads IMEI/serial number from phone.
131 */
GSM_GetIMEI(GSM_StateMachine * s,char * value)132 GSM_Error GSM_GetIMEI(GSM_StateMachine *s, char *value)
133 {
134 GSM_Error err;
135
136 CHECK_PHONE_CONNECTION();
137
138 s->Phone.Data.IMEI[0] = '\0';
139 err = s->Phone.Functions->GetIMEI(s);
140 if (value != NULL) {
141 strcpy(value, s->Phone.Data.IMEI);
142 }
143
144 PRINT_LOG_ERROR(err);
145 return err;
146 }
147 /**
148 * Gets date and time from phone.
149 */
GSM_GetOriginalIMEI(GSM_StateMachine * s,char * value)150 GSM_Error GSM_GetOriginalIMEI(GSM_StateMachine *s, char *value)
151 {
152 GSM_Error err;
153
154 CHECK_PHONE_CONNECTION();
155
156 err = s->Phone.Functions->GetOriginalIMEI(s, value);
157 PRINT_LOG_ERROR(err);
158 return err;
159 }
160 /**
161 * Gets month when device was manufactured.
162 */
GSM_GetManufactureMonth(GSM_StateMachine * s,char * value)163 GSM_Error GSM_GetManufactureMonth(GSM_StateMachine *s, char *value)
164 {
165 GSM_Error err;
166
167 CHECK_PHONE_CONNECTION();
168
169 err = s->Phone.Functions->GetManufactureMonth(s, value);
170 PRINT_LOG_ERROR(err);
171 return err;
172 }
173 /**
174 * Gets product code of device.
175 */
GSM_GetProductCode(GSM_StateMachine * s,char * value)176 GSM_Error GSM_GetProductCode(GSM_StateMachine *s, char *value)
177 {
178 GSM_Error err;
179
180 CHECK_PHONE_CONNECTION();
181
182 err = s->Phone.Functions->GetProductCode(s, value);
183 PRINT_LOG_ERROR(err);
184 return err;
185 }
186 /**
187 * Gets hardware information about device.
188 */
GSM_GetHardware(GSM_StateMachine * s,char * value)189 GSM_Error GSM_GetHardware(GSM_StateMachine *s, char *value)
190 {
191 GSM_Error err;
192
193 CHECK_PHONE_CONNECTION();
194
195 err = s->Phone.Functions->GetHardware(s, value);
196 PRINT_LOG_ERROR(err);
197 return err;
198 }
199 /**
200 * Gets PPM (Post Programmable Memory) info from phone
201 * (in other words for Nokia get, which language pack is in phone)
202 */
GSM_GetPPM(GSM_StateMachine * s,char * value)203 GSM_Error GSM_GetPPM(GSM_StateMachine *s, char *value)
204 {
205 GSM_Error err;
206
207 CHECK_PHONE_CONNECTION();
208
209 err = s->Phone.Functions->GetPPM(s, value);
210 PRINT_LOG_ERROR(err);
211 return err;
212 }
213 /**
214 * Gets SIM IMSI from phone.
215 */
GSM_GetSIMIMSI(GSM_StateMachine * s,char * IMSI)216 GSM_Error GSM_GetSIMIMSI(GSM_StateMachine *s, char *IMSI)
217 {
218 GSM_Error err;
219
220 CHECK_PHONE_CONNECTION();
221
222 err = s->Phone.Functions->GetSIMIMSI(s, IMSI);
223 PRINT_LOG_ERROR(err);
224 return err;
225 }
226 /**
227 * Reads date and time from phone.
228 */
GSM_GetDateTime(GSM_StateMachine * s,GSM_DateTime * date_time)229 GSM_Error GSM_GetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time)
230 {
231 GSM_Error err;
232
233 CHECK_PHONE_CONNECTION();
234
235 err = s->Phone.Functions->GetDateTime(s, date_time);
236 PRINT_LOG_ERROR(err);
237 return err;
238 }
239 /**
240 * Sets date and time in phone.
241 */
GSM_SetDateTime(GSM_StateMachine * s,GSM_DateTime * date_time)242 GSM_Error GSM_SetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time)
243 {
244 GSM_Error err;
245
246 CHECK_PHONE_CONNECTION();
247
248 err = s->Phone.Functions->SetDateTime(s, date_time);
249 PRINT_LOG_ERROR(err);
250 return err;
251 }
252 /**
253 * Reads alarm set in phone.
254 */
GSM_GetAlarm(GSM_StateMachine * s,GSM_Alarm * Alarm)255 GSM_Error GSM_GetAlarm(GSM_StateMachine *s, GSM_Alarm *Alarm)
256 {
257 GSM_Error err;
258
259 CHECK_PHONE_CONNECTION();
260
261 err = s->Phone.Functions->GetAlarm(s, Alarm);
262 PRINT_LOG_ERROR(err);
263 return err;
264 }
265 /**
266 * Sets alarm in phone.
267 */
GSM_SetAlarm(GSM_StateMachine * s,GSM_Alarm * Alarm)268 GSM_Error GSM_SetAlarm(GSM_StateMachine *s, GSM_Alarm *Alarm)
269 {
270 GSM_Error err;
271
272 CHECK_PHONE_CONNECTION();
273
274 err = s->Phone.Functions->SetAlarm(s, Alarm);
275 PRINT_LOG_ERROR(err);
276 return err;
277 }
278 /**
279 * Gets locale from phone.
280 */
GSM_GetLocale(GSM_StateMachine * s,GSM_Locale * locale)281 GSM_Error GSM_GetLocale(GSM_StateMachine *s, GSM_Locale *locale)
282 {
283 GSM_Error err;
284
285 CHECK_PHONE_CONNECTION();
286
287 err = s->Phone.Functions->GetLocale(s, locale);
288 PRINT_LOG_ERROR(err);
289 return err;
290 }
291 /**
292 * Sets locale of phone.
293 */
GSM_SetLocale(GSM_StateMachine * s,GSM_Locale * locale)294 GSM_Error GSM_SetLocale(GSM_StateMachine *s, GSM_Locale *locale)
295 {
296 GSM_Error err;
297
298 CHECK_PHONE_CONNECTION();
299
300 err = s->Phone.Functions->SetLocale(s, locale);
301 PRINT_LOG_ERROR(err);
302 return err;
303 }
304 /**
305 * Power on/off the phone.
306 */
GSM_SetPower(GSM_StateMachine * s,gboolean on)307 GSM_Error GSM_SetPower(GSM_StateMachine *s, gboolean on)
308 {
309 GSM_Error err;
310
311 CHECK_PHONE_CONNECTION();
312
313 err = s->Phone.Functions->SetPower(s, on);
314 PRINT_LOG_ERROR(err);
315 return err;
316 }
317 /**
318 * Emulates key press or key release.
319 */
GSM_PressKey(GSM_StateMachine * s,GSM_KeyCode Key,gboolean Press)320 GSM_Error GSM_PressKey(GSM_StateMachine *s, GSM_KeyCode Key, gboolean Press)
321 {
322 GSM_Error err;
323
324 CHECK_PHONE_CONNECTION();
325
326 err = s->Phone.Functions->PressKey(s, Key, Press);
327 PRINT_LOG_ERROR(err);
328 return err;
329 }
330 /**
331 * Performs phone reset.
332 */
GSM_Reset(GSM_StateMachine * s,gboolean hard)333 GSM_Error GSM_Reset(GSM_StateMachine *s, gboolean hard)
334 {
335 GSM_Error err;
336
337 CHECK_PHONE_CONNECTION();
338
339 err = s->Phone.Functions->Reset(s, hard);
340 PRINT_LOG_ERROR(err);
341 return err;
342 }
343 /**
344 * Resets phone settings.
345 */
GSM_ResetPhoneSettings(GSM_StateMachine * s,GSM_ResetSettingsType Type)346 GSM_Error GSM_ResetPhoneSettings(GSM_StateMachine *s, GSM_ResetSettingsType Type)
347 {
348 GSM_Error err;
349
350 CHECK_PHONE_CONNECTION();
351
352 err = s->Phone.Functions->ResetPhoneSettings(s, Type);
353 PRINT_LOG_ERROR(err);
354 return err;
355 }
356 /**
357 * Enters security code (PIN, PUK,...) .
358 */
GSM_EnterSecurityCode(GSM_StateMachine * s,GSM_SecurityCode * Code)359 GSM_Error GSM_EnterSecurityCode(GSM_StateMachine *s, GSM_SecurityCode *Code)
360 {
361 GSM_Error err;
362
363 CHECK_PHONE_CONNECTION();
364
365 err = s->Phone.Functions->EnterSecurityCode(s, Code);
366 PRINT_LOG_ERROR(err);
367 return err;
368 }
369 /**
370 * Queries whether some security code needs to be entered./
371 */
GSM_GetSecurityStatus(GSM_StateMachine * s,GSM_SecurityCodeType * Status)372 GSM_Error GSM_GetSecurityStatus(GSM_StateMachine *s, GSM_SecurityCodeType *Status)
373 {
374 GSM_Error err;
375
376 CHECK_PHONE_CONNECTION();
377
378 err = s->Phone.Functions->GetSecurityStatus(s, Status);
379 PRINT_LOG_ERROR(err);
380 return err;
381 }
382 /**
383 * Acquired display status.
384 */
GSM_GetDisplayStatus(GSM_StateMachine * s,GSM_DisplayFeatures * features)385 GSM_Error GSM_GetDisplayStatus(GSM_StateMachine *s, GSM_DisplayFeatures *features)
386 {
387 GSM_Error err;
388
389 CHECK_PHONE_CONNECTION();
390
391 err = s->Phone.Functions->GetDisplayStatus(s, features);
392 PRINT_LOG_ERROR(err);
393 return err;
394 }
395 /**
396 * Enables network auto login.
397 */
GSM_SetAutoNetworkLogin(GSM_StateMachine * s)398 GSM_Error GSM_SetAutoNetworkLogin(GSM_StateMachine *s)
399 {
400 GSM_Error err;
401
402 CHECK_PHONE_CONNECTION();
403
404 err = s->Phone.Functions->SetAutoNetworkLogin(s);
405 PRINT_LOG_ERROR(err);
406 return err;
407 }
408 /**
409 * Gets information about batery charge and phone charging state.
410 */
GSM_GetBatteryCharge(GSM_StateMachine * s,GSM_BatteryCharge * bat)411 GSM_Error GSM_GetBatteryCharge(GSM_StateMachine *s, GSM_BatteryCharge *bat)
412 {
413 GSM_Error err;
414
415 CHECK_PHONE_CONNECTION();
416
417 memset(bat, 0, sizeof(GSM_BatteryCharge));
418
419 err = s->Phone.Functions->GetBatteryCharge(s, bat);
420 PRINT_LOG_ERROR(err);
421 return err;
422 }
423 /**
424 * Reads signal quality (strength and error rate).
425 */
GSM_GetSignalQuality(GSM_StateMachine * s,GSM_SignalQuality * sig)426 GSM_Error GSM_GetSignalQuality(GSM_StateMachine *s, GSM_SignalQuality *sig)
427 {
428 GSM_Error err;
429
430 CHECK_PHONE_CONNECTION();
431
432 err = s->Phone.Functions->GetSignalQuality(s, sig);
433 PRINT_LOG_ERROR(err);
434 return err;
435 }
436 /**
437 * Gets network information.
438 */
GSM_GetNetworkInfo(GSM_StateMachine * s,GSM_NetworkInfo * netinfo)439 GSM_Error GSM_GetNetworkInfo(GSM_StateMachine *s, GSM_NetworkInfo *netinfo)
440 {
441 GSM_Error err;
442
443 CHECK_PHONE_CONNECTION();
444
445 netinfo->CID[0] = 0;
446 netinfo->LAC[0] = 0;
447 netinfo->PacketCID[0] = 0;
448 netinfo->PacketLAC[0] = 0;
449 netinfo->State = GSM_NetworkStatusUnknown;
450 netinfo->PacketState = GSM_NetworkStatusUnknown;
451 netinfo->NetworkName[0] = 0;
452 netinfo->NetworkName[1] = 0;
453 netinfo->NetworkCode[0] = 0;
454 netinfo->GPRS = 0;
455
456 err = s->Phone.Functions->GetNetworkInfo(s, netinfo);
457 PRINT_LOG_ERROR(err);
458 return err;
459 }
460 /**
461 * Reads category from phone.
462 */
GSM_GetCategory(GSM_StateMachine * s,GSM_Category * Category)463 GSM_Error GSM_GetCategory(GSM_StateMachine *s, GSM_Category *Category)
464 {
465 GSM_Error err;
466
467 CHECK_PHONE_CONNECTION();
468
469 err = s->Phone.Functions->GetCategory(s, Category);
470 PRINT_LOG_ERROR(err);
471 return err;
472 }
473 /**
474 * Adds category to phone.
475 */
GSM_AddCategory(GSM_StateMachine * s,GSM_Category * Category)476 GSM_Error GSM_AddCategory(GSM_StateMachine *s, GSM_Category *Category)
477 {
478 GSM_Error err;
479
480 CHECK_PHONE_CONNECTION();
481
482 err = s->Phone.Functions->AddCategory(s, Category);
483 PRINT_LOG_ERROR(err);
484 return err;
485 }
486 /**
487 * Reads category status (number of used entries) from phone.
488 */
GSM_GetCategoryStatus(GSM_StateMachine * s,GSM_CategoryStatus * Status)489 GSM_Error GSM_GetCategoryStatus(GSM_StateMachine *s, GSM_CategoryStatus *Status)
490 {
491 GSM_Error err;
492
493 CHECK_PHONE_CONNECTION();
494
495 err = s->Phone.Functions->GetCategoryStatus(s, Status);
496 PRINT_LOG_ERROR(err);
497 return err;
498 }
499 /**
500 * Gets memory (phonebooks or calls) status (eg. number of used and
501 * free entries).
502 */
GSM_GetMemoryStatus(GSM_StateMachine * s,GSM_MemoryStatus * status)503 GSM_Error GSM_GetMemoryStatus(GSM_StateMachine *s, GSM_MemoryStatus *status)
504 {
505 GSM_Error err;
506
507 CHECK_PHONE_CONNECTION();
508
509 err = s->Phone.Functions->GetMemoryStatus(s, status);
510 PRINT_LOG_ERROR(err);
511 return err;
512 }
513 /**
514 * Reads entry from memory (phonebooks or calls). Which entry should
515 * be read is defined in entry.
516 */
GSM_GetMemory(GSM_StateMachine * s,GSM_MemoryEntry * entry)517 GSM_Error GSM_GetMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
518 {
519 GSM_Error err;
520
521 CHECK_PHONE_CONNECTION();
522 PRINT_MEMORY_INFO();
523
524 err = s->Phone.Functions->GetMemory(s, entry);
525 PRINT_LOG_ERROR(err);
526 return err;
527 }
528 /**
529 * Reads entry from memory (phonebooks or calls). Which entry should
530 * be read is defined in entry. This can be easily used for reading all entries.
531 */
GSM_GetNextMemory(GSM_StateMachine * s,GSM_MemoryEntry * entry,gboolean start)532 GSM_Error GSM_GetNextMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry, gboolean start)
533 {
534 GSM_Error err;
535
536 CHECK_PHONE_CONNECTION();
537 PRINT_START();
538 PRINT_MEMORY_INFO();
539
540 err = s->Phone.Functions->GetNextMemory(s, entry, start);
541 PRINT_LOG_ERROR(err);
542 return err;
543 }
544 /**
545 * Sets memory (phonebooks or calls) entry.
546 */
GSM_SetMemory(GSM_StateMachine * s,GSM_MemoryEntry * entry)547 GSM_Error GSM_SetMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
548 {
549 GSM_Error err;
550
551 CHECK_PHONE_CONNECTION();
552 PRINT_MEMORY_INFO();
553
554 RUN_RESTARTABLE(err, s->Phone.Functions->SetMemory(s, entry));
555 PRINT_LOG_ERROR(err);
556 return err;
557 }
558 /**
559 * Deletes memory (phonebooks or calls) entry.
560 */
GSM_AddMemory(GSM_StateMachine * s,GSM_MemoryEntry * entry)561 GSM_Error GSM_AddMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
562 {
563 GSM_Error err;
564
565 CHECK_PHONE_CONNECTION();
566 PRINT_MEMORY_INFO();
567
568 err = s->Phone.Functions->AddMemory(s, entry);
569 PRINT_LOG_ERROR(err);
570 return err;
571 }
572 /**
573 * Deletes memory (phonebooks or calls) entry.
574 */
GSM_DeleteMemory(GSM_StateMachine * s,GSM_MemoryEntry * entry)575 GSM_Error GSM_DeleteMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
576 {
577 GSM_Error err;
578
579 CHECK_PHONE_CONNECTION();
580 PRINT_MEMORY_INFO();
581
582 RUN_RESTARTABLE(err, s->Phone.Functions->DeleteMemory(s, entry));
583 PRINT_LOG_ERROR(err);
584 return err;
585 }
586 /**
587 * Deletes all memory (phonebooks or calls) entries of specified type.
588 */
GSM_DeleteAllMemory(GSM_StateMachine * s,GSM_MemoryType MemoryType)589 GSM_Error GSM_DeleteAllMemory(GSM_StateMachine *s, GSM_MemoryType MemoryType)
590 {
591 GSM_Error err;
592
593 CHECK_PHONE_CONNECTION();
594
595 err = s->Phone.Functions->DeleteAllMemory(s, MemoryType);
596 PRINT_LOG_ERROR(err);
597 return err;
598 }
599 /**
600 * Gets speed dial.
601 */
GSM_GetSpeedDial(GSM_StateMachine * s,GSM_SpeedDial * Speed)602 GSM_Error GSM_GetSpeedDial(GSM_StateMachine *s, GSM_SpeedDial *Speed)
603 {
604 GSM_Error err;
605
606 CHECK_PHONE_CONNECTION();
607
608 err = s->Phone.Functions->GetSpeedDial(s, Speed);
609 PRINT_LOG_ERROR(err);
610 return err;
611 }
612 /**
613 * Sets speed dial.
614 */
GSM_SetSpeedDial(GSM_StateMachine * s,GSM_SpeedDial * Speed)615 GSM_Error GSM_SetSpeedDial(GSM_StateMachine *s, GSM_SpeedDial *Speed)
616 {
617 GSM_Error err;
618
619 CHECK_PHONE_CONNECTION();
620
621 err = s->Phone.Functions->SetSpeedDial(s, Speed);
622 PRINT_LOG_ERROR(err);
623 return err;
624 }
625 /**
626 * Gets SMS Service Center number and SMS settings.
627 */
GSM_GetSMSC(GSM_StateMachine * s,GSM_SMSC * smsc)628 GSM_Error GSM_GetSMSC(GSM_StateMachine *s, GSM_SMSC *smsc)
629 {
630 GSM_Error err;
631
632 CHECK_PHONE_CONNECTION();
633
634 err = s->Phone.Functions->GetSMSC(s, smsc);
635 PRINT_LOG_ERROR(err);
636 return err;
637 }
638 /**
639 * Sets SMS Service Center number and SMS settings.
640 */
GSM_SetSMSC(GSM_StateMachine * s,GSM_SMSC * smsc)641 GSM_Error GSM_SetSMSC(GSM_StateMachine *s, GSM_SMSC *smsc)
642 {
643 GSM_Error err;
644
645 CHECK_PHONE_CONNECTION();
646
647 err = s->Phone.Functions->SetSMSC(s, smsc);
648 PRINT_LOG_ERROR(err);
649 return err;
650 }
651 /**
652 * Gets information about SMS memory (read/unread/size of memory for
653 * both SIM and phone).
654 */
GSM_GetSMSStatus(GSM_StateMachine * s,GSM_SMSMemoryStatus * status)655 GSM_Error GSM_GetSMSStatus(GSM_StateMachine *s, GSM_SMSMemoryStatus *status)
656 {
657 GSM_Error err;
658
659 CHECK_PHONE_CONNECTION();
660
661 err = s->Phone.Functions->GetSMSStatus(s, status);
662 PRINT_LOG_ERROR(err);
663 return err;
664 }
665 /**
666 * Reads SMS message.
667 */
GSM_GetSMS(GSM_StateMachine * s,GSM_MultiSMSMessage * sms)668 GSM_Error GSM_GetSMS(GSM_StateMachine *s, GSM_MultiSMSMessage *sms)
669 {
670 GSM_Error err;
671
672 CHECK_PHONE_CONNECTION();
673 PRINT_MSMS_INFO();
674
675 err = s->Phone.Functions->GetSMS(s, sms);
676 PRINT_LOG_ERROR(err);
677 return err;
678 }
679 /**
680 * Reads next (or first if start set) SMS message. This might be
681 * faster for some phones than using @ref GSM_GetSMS for each message.
682 */
GSM_GetNextSMS(GSM_StateMachine * s,GSM_MultiSMSMessage * sms,gboolean start)683 GSM_Error GSM_GetNextSMS(GSM_StateMachine *s, GSM_MultiSMSMessage *sms, gboolean start)
684 {
685 GSM_Error err;
686
687 CHECK_PHONE_CONNECTION();
688 PRINT_START();
689 PRINT_MSMS_INFO();
690
691 err = s->Phone.Functions->GetNextSMS(s, sms, start);
692 PRINT_LOG_ERROR(err);
693 return err;
694 }
695 /**
696 * Sets SMS.
697 */
GSM_SetSMS(GSM_StateMachine * s,GSM_SMSMessage * sms)698 GSM_Error GSM_SetSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
699 {
700 GSM_Error err;
701
702 CHECK_PHONE_CONNECTION();
703 PRINT_SMS_INFO();
704
705 err = s->Phone.Functions->SetSMS(s, sms);
706 PRINT_LOG_ERROR(err);
707 return err;
708 }
709 /**
710 * Adds SMS to specified folder.
711 */
GSM_AddSMS(GSM_StateMachine * s,GSM_SMSMessage * sms)712 GSM_Error GSM_AddSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
713 {
714 GSM_Error err;
715
716 CHECK_PHONE_CONNECTION();
717 PRINT_SMS_INFO();
718
719 err = s->Phone.Functions->AddSMS(s, sms);
720 PRINT_LOG_ERROR(err);
721 return err;
722 }
723 /**
724 * Deletes SMS.
725 */
GSM_DeleteSMS(GSM_StateMachine * s,GSM_SMSMessage * sms)726 GSM_Error GSM_DeleteSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
727 {
728 GSM_Error err;
729
730 CHECK_PHONE_CONNECTION();
731 PRINT_SMS_INFO();
732
733 err = s->Phone.Functions->DeleteSMS(s, sms);
734 PRINT_LOG_ERROR(err);
735 return err;
736 }
737 /**
738 * Sends SMS.
739 */
GSM_SendSMS(GSM_StateMachine * s,GSM_SMSMessage * sms)740 GSM_Error GSM_SendSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
741 {
742 GSM_Error err;
743
744 CHECK_PHONE_CONNECTION();
745
746 err = s->Phone.Functions->SendSMS(s, sms);
747 PRINT_LOG_ERROR(err);
748 return err;
749 }
750 /**
751 * Sends SMS already saved in phone.
752 */
GSM_SendSavedSMS(GSM_StateMachine * s,int Folder,int Location)753 GSM_Error GSM_SendSavedSMS(GSM_StateMachine *s, int Folder, int Location)
754 {
755 GSM_Error err;
756
757 CHECK_PHONE_CONNECTION();
758 smprintf(s, "Location = %d, Folder = %d\n", Location, Folder);
759
760 err = s->Phone.Functions->SendSavedSMS(s, Folder, Location);
761 PRINT_LOG_ERROR(err);
762 return err;
763 }
764 /**
765 * Configures fast SMS sending.
766 */
GSM_SetFastSMSSending(GSM_StateMachine * s,gboolean enable)767 GSM_Error GSM_SetFastSMSSending(GSM_StateMachine *s, gboolean enable)
768 {
769 GSM_Error err;
770
771 CHECK_PHONE_CONNECTION();
772
773 err = s->Phone.Functions->SetFastSMSSending(s, enable);
774 PRINT_LOG_ERROR(err);
775 return err;
776 }
777 /**
778 * Enable/disable notification on incoming SMS.
779 */
GSM_SetIncomingSMS(GSM_StateMachine * s,gboolean enable)780 GSM_Error GSM_SetIncomingSMS(GSM_StateMachine *s, gboolean enable)
781 {
782 GSM_Error err;
783
784 CHECK_PHONE_CONNECTION();
785
786 err = s->Phone.Functions->SetIncomingSMS(s, enable);
787 PRINT_LOG_ERROR(err);
788 return err;
789 }
790 /**
791 * Gets network information from phone.
792 */
GSM_SetIncomingCB(GSM_StateMachine * s,gboolean enable)793 GSM_Error GSM_SetIncomingCB(GSM_StateMachine *s, gboolean enable)
794 {
795 GSM_Error err;
796
797 CHECK_PHONE_CONNECTION();
798
799 err = s->Phone.Functions->SetIncomingCB(s, enable);
800 PRINT_LOG_ERROR(err);
801 return err;
802 }
803 /**
804 * Returns SMS folders information.
805 */
GSM_GetSMSFolders(GSM_StateMachine * s,GSM_SMSFolders * folders)806 GSM_Error GSM_GetSMSFolders(GSM_StateMachine *s, GSM_SMSFolders *folders)
807 {
808 GSM_Error err;
809
810 CHECK_PHONE_CONNECTION();
811
812 err = s->Phone.Functions->GetSMSFolders(s, folders);
813 PRINT_LOG_ERROR(err);
814 return err;
815 }
816 /**
817 * Creates SMS folder.
818 */
GSM_AddSMSFolder(GSM_StateMachine * s,unsigned char * name)819 GSM_Error GSM_AddSMSFolder(GSM_StateMachine *s, unsigned char *name)
820 {
821 GSM_Error err;
822
823 CHECK_PHONE_CONNECTION();
824
825 err = s->Phone.Functions->AddSMSFolder(s, name);
826 PRINT_LOG_ERROR(err);
827 return err;
828 }
829 /**
830 * Deletes SMS folder.
831 */
GSM_DeleteSMSFolder(GSM_StateMachine * s,int ID)832 GSM_Error GSM_DeleteSMSFolder(GSM_StateMachine *s, int ID)
833 {
834 GSM_Error err;
835
836 CHECK_PHONE_CONNECTION();
837
838 err = s->Phone.Functions->DeleteSMSFolder(s, ID);
839 PRINT_LOG_ERROR(err);
840 return err;
841 }
842 /**
843 * Dials number and starts voice call.
844 */
GSM_DialVoice(GSM_StateMachine * s,char * Number,GSM_CallShowNumber ShowNumber)845 GSM_Error GSM_DialVoice(GSM_StateMachine *s, char *Number, GSM_CallShowNumber ShowNumber)
846 {
847 GSM_Error err;
848
849 CHECK_PHONE_CONNECTION();
850
851 err = s->Phone.Functions->DialVoice(s, Number, ShowNumber);
852 PRINT_LOG_ERROR(err);
853 return err;
854 }
855 /**
856 * Dials service number (usually for USSD).
857 */
GSM_DialService(GSM_StateMachine * s,char * Number)858 GSM_Error GSM_DialService(GSM_StateMachine *s, char *Number)
859 {
860 GSM_Error err;
861
862 CHECK_PHONE_CONNECTION();
863
864 err = s->Phone.Functions->DialService(s, Number);
865 PRINT_LOG_ERROR(err);
866 return err;
867 }
868 /**
869 * Accept current incoming call.
870 */
GSM_AnswerCall(GSM_StateMachine * s,int ID,gboolean all)871 GSM_Error GSM_AnswerCall(GSM_StateMachine *s, int ID, gboolean all)
872 {
873 GSM_Error err;
874
875 CHECK_PHONE_CONNECTION();
876
877 err = s->Phone.Functions->AnswerCall(s, ID, all);
878 PRINT_LOG_ERROR(err);
879 return err;
880 }
881 /**
882 * Deny current incoming call.
883 */
GSM_CancelCall(GSM_StateMachine * s,int ID,gboolean all)884 GSM_Error GSM_CancelCall(GSM_StateMachine *s, int ID, gboolean all)
885 {
886 GSM_Error err;
887
888 CHECK_PHONE_CONNECTION();
889
890 err = s->Phone.Functions->CancelCall(s, ID, all);
891 PRINT_LOG_ERROR(err);
892 return err;
893 }
894 /**
895 * Holds call.
896 */
GSM_HoldCall(GSM_StateMachine * s,int ID)897 GSM_Error GSM_HoldCall(GSM_StateMachine *s, int ID)
898 {
899 GSM_Error err;
900
901 CHECK_PHONE_CONNECTION();
902
903 err = s->Phone.Functions->HoldCall(s, ID);
904 PRINT_LOG_ERROR(err);
905 return err;
906 }
907 /**
908 * Unholds call.
909 */
GSM_UnholdCall(GSM_StateMachine * s,int ID)910 GSM_Error GSM_UnholdCall(GSM_StateMachine *s, int ID)
911 {
912 GSM_Error err;
913
914 CHECK_PHONE_CONNECTION();
915
916 err = s->Phone.Functions->UnholdCall(s, ID);
917 PRINT_LOG_ERROR(err);
918 return err;
919 }
920 /**
921 * Initiates a conference call.
922 */
GSM_ConferenceCall(GSM_StateMachine * s,int ID)923 GSM_Error GSM_ConferenceCall(GSM_StateMachine *s, int ID)
924 {
925 GSM_Error err;
926
927 CHECK_PHONE_CONNECTION();
928
929 err = s->Phone.Functions->ConferenceCall(s, ID);
930 PRINT_LOG_ERROR(err);
931 return err;
932 }
933 /**
934 * Splits call.
935 */
GSM_SplitCall(GSM_StateMachine * s,int ID)936 GSM_Error GSM_SplitCall(GSM_StateMachine *s, int ID)
937 {
938 GSM_Error err;
939
940 CHECK_PHONE_CONNECTION();
941
942 err = s->Phone.Functions->SplitCall(s, ID);
943 PRINT_LOG_ERROR(err);
944 return err;
945 }
946 /**
947 * Transfers call.
948 */
GSM_TransferCall(GSM_StateMachine * s,int ID,gboolean next)949 GSM_Error GSM_TransferCall(GSM_StateMachine *s, int ID, gboolean next)
950 {
951 GSM_Error err;
952
953 CHECK_PHONE_CONNECTION();
954
955 err = s->Phone.Functions->TransferCall(s, ID, next);
956 PRINT_LOG_ERROR(err);
957 return err;
958 }
959 /**
960 * Switches call.
961 */
GSM_SwitchCall(GSM_StateMachine * s,int ID,gboolean next)962 GSM_Error GSM_SwitchCall(GSM_StateMachine *s, int ID, gboolean next)
963 {
964 GSM_Error err;
965
966 CHECK_PHONE_CONNECTION();
967
968 err = s->Phone.Functions->SwitchCall(s, ID, next);
969 PRINT_LOG_ERROR(err);
970 return err;
971 }
972 /**
973 * Gets call diverts.
974 */
GSM_GetCallDivert(GSM_StateMachine * s,GSM_CallDivert * request,GSM_MultiCallDivert * result)975 GSM_Error GSM_GetCallDivert(GSM_StateMachine *s, GSM_CallDivert *request, GSM_MultiCallDivert *result)
976 {
977 GSM_Error err;
978
979 CHECK_PHONE_CONNECTION();
980
981 err = s->Phone.Functions->GetCallDivert(s, request, result);
982 PRINT_LOG_ERROR(err);
983 return err;
984 }
985 /**
986 * Sets call diverts.
987 */
GSM_SetCallDivert(GSM_StateMachine * s,GSM_CallDivert * divert)988 GSM_Error GSM_SetCallDivert(GSM_StateMachine *s, GSM_CallDivert *divert)
989 {
990 GSM_Error err;
991
992 CHECK_PHONE_CONNECTION();
993
994 err = s->Phone.Functions->SetCallDivert(s, divert);
995 PRINT_LOG_ERROR(err);
996 return err;
997 }
998 /**
999 * Cancels all diverts.
1000 */
GSM_CancelAllDiverts(GSM_StateMachine * s)1001 GSM_Error GSM_CancelAllDiverts(GSM_StateMachine *s)
1002 {
1003 GSM_Error err;
1004
1005 CHECK_PHONE_CONNECTION();
1006
1007 err = s->Phone.Functions->CancelAllDiverts(s);
1008 PRINT_LOG_ERROR(err);
1009 return err;
1010 }
1011 /**
1012 * Activates/deactivates noticing about incoming calls.
1013 */
GSM_SetIncomingCall(GSM_StateMachine * s,gboolean enable)1014 GSM_Error GSM_SetIncomingCall(GSM_StateMachine *s, gboolean enable)
1015 {
1016 GSM_Error err;
1017
1018 CHECK_PHONE_CONNECTION();
1019
1020 err = s->Phone.Functions->SetIncomingCall(s, enable);
1021 PRINT_LOG_ERROR(err);
1022 return err;
1023 }
1024 /**
1025 * Activates/deactivates noticing about incoming USSDs (UnStructured Supplementary Services).
1026 */
GSM_SetIncomingUSSD(GSM_StateMachine * s,gboolean enable)1027 GSM_Error GSM_SetIncomingUSSD(GSM_StateMachine *s, gboolean enable)
1028 {
1029 GSM_Error err;
1030
1031 CHECK_PHONE_CONNECTION();
1032
1033 err = s->Phone.Functions->SetIncomingUSSD(s, enable);
1034 PRINT_LOG_ERROR(err);
1035 return err;
1036 }
1037 /**
1038 * Sends DTMF (Dual Tone Multi Frequency) tone.
1039 */
GSM_SendDTMF(GSM_StateMachine * s,char * sequence)1040 GSM_Error GSM_SendDTMF(GSM_StateMachine *s, char *sequence)
1041 {
1042 GSM_Error err;
1043
1044 CHECK_PHONE_CONNECTION();
1045
1046 err = s->Phone.Functions->SendDTMF(s, sequence);
1047 PRINT_LOG_ERROR(err);
1048 return err;
1049 }
1050 /**
1051 * Gets ringtone from phone.
1052 */
GSM_GetRingtone(GSM_StateMachine * s,GSM_Ringtone * Ringtone,gboolean PhoneRingtone)1053 GSM_Error GSM_GetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, gboolean PhoneRingtone)
1054 {
1055 GSM_Error err;
1056
1057 CHECK_PHONE_CONNECTION();
1058
1059 err = s->Phone.Functions->GetRingtone(s, Ringtone, PhoneRingtone);
1060 PRINT_LOG_ERROR(err);
1061 return err;
1062 }
1063 /**
1064 * Sets ringtone in phone.
1065 */
GSM_SetRingtone(GSM_StateMachine * s,GSM_Ringtone * Ringtone,int * maxlength)1066 GSM_Error GSM_SetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, int *maxlength)
1067 {
1068 GSM_Error err;
1069
1070 CHECK_PHONE_CONNECTION();
1071
1072 err = s->Phone.Functions->SetRingtone(s, Ringtone, maxlength);
1073 PRINT_LOG_ERROR(err);
1074 return err;
1075 }
1076 /**
1077 * Acquires ringtone informaiton.
1078 */
GSM_GetRingtonesInfo(GSM_StateMachine * s,GSM_AllRingtonesInfo * Info)1079 GSM_Error GSM_GetRingtonesInfo(GSM_StateMachine *s, GSM_AllRingtonesInfo *Info)
1080 {
1081 GSM_Error err;
1082
1083 CHECK_PHONE_CONNECTION();
1084
1085 err = s->Phone.Functions->GetRingtonesInfo(s, Info);
1086 PRINT_LOG_ERROR(err);
1087 return err;
1088 }
1089 /**
1090 * Deletes user defined ringtones from phone.
1091 */
GSM_DeleteUserRingtones(GSM_StateMachine * s)1092 GSM_Error GSM_DeleteUserRingtones(GSM_StateMachine *s)
1093 {
1094 GSM_Error err;
1095
1096 CHECK_PHONE_CONNECTION();
1097
1098 err = s->Phone.Functions->DeleteUserRingtones(s);
1099 PRINT_LOG_ERROR(err);
1100 return err;
1101 }
1102 /**
1103 * Plays tone.
1104 */
GSM_PlayTone(GSM_StateMachine * s,int Herz,unsigned char Volume,gboolean start)1105 GSM_Error GSM_PlayTone(GSM_StateMachine *s, int Herz, unsigned char Volume, gboolean start)
1106 {
1107 GSM_Error err;
1108
1109 CHECK_PHONE_CONNECTION();
1110
1111 err = s->Phone.Functions->PlayTone(s, Herz, Volume, start);
1112 PRINT_LOG_ERROR(err);
1113 return err;
1114 }
1115 /**
1116 * Reads WAP bookmark.
1117 */
GSM_GetWAPBookmark(GSM_StateMachine * s,GSM_WAPBookmark * bookmark)1118 GSM_Error GSM_GetWAPBookmark(GSM_StateMachine *s, GSM_WAPBookmark *bookmark)
1119 {
1120 GSM_Error err;
1121
1122 CHECK_PHONE_CONNECTION();
1123
1124 err = s->Phone.Functions->GetWAPBookmark(s, bookmark);
1125 PRINT_LOG_ERROR(err);
1126 return err;
1127 }
1128 /**
1129 * Sets WAP bookmark.
1130 */
GSM_SetWAPBookmark(GSM_StateMachine * s,GSM_WAPBookmark * bookmark)1131 GSM_Error GSM_SetWAPBookmark(GSM_StateMachine *s, GSM_WAPBookmark *bookmark)
1132 {
1133 GSM_Error err;
1134
1135 CHECK_PHONE_CONNECTION();
1136
1137 err = s->Phone.Functions->SetWAPBookmark(s, bookmark);
1138 PRINT_LOG_ERROR(err);
1139 return err;
1140 }
1141 /**
1142 * Deletes WAP bookmark.
1143 */
GSM_DeleteWAPBookmark(GSM_StateMachine * s,GSM_WAPBookmark * bookmark)1144 GSM_Error GSM_DeleteWAPBookmark(GSM_StateMachine *s, GSM_WAPBookmark *bookmark)
1145 {
1146 GSM_Error err;
1147
1148 CHECK_PHONE_CONNECTION();
1149
1150 err = s->Phone.Functions->DeleteWAPBookmark(s, bookmark);
1151 PRINT_LOG_ERROR(err);
1152 return err;
1153 }
1154 /**
1155 * Acquires WAP settings.
1156 */
GSM_GetWAPSettings(GSM_StateMachine * s,GSM_MultiWAPSettings * settings)1157 GSM_Error GSM_GetWAPSettings(GSM_StateMachine *s, GSM_MultiWAPSettings *settings)
1158 {
1159 GSM_Error err;
1160
1161 CHECK_PHONE_CONNECTION();
1162
1163 err = s->Phone.Functions->GetWAPSettings(s, settings);
1164 PRINT_LOG_ERROR(err);
1165 return err;
1166 }
1167 /**
1168 * Changes WAP settings.
1169 */
GSM_SetWAPSettings(GSM_StateMachine * s,GSM_MultiWAPSettings * settings)1170 GSM_Error GSM_SetWAPSettings(GSM_StateMachine *s, GSM_MultiWAPSettings *settings)
1171 {
1172 GSM_Error err;
1173
1174 CHECK_PHONE_CONNECTION();
1175
1176 err = s->Phone.Functions->SetWAPSettings(s, settings);
1177 PRINT_LOG_ERROR(err);
1178 return err;
1179 }
1180 /**
1181 * Acquires SyncML settings.
1182 */
GSM_GetSyncMLSettings(GSM_StateMachine * s,GSM_SyncMLSettings * settings)1183 GSM_Error GSM_GetSyncMLSettings(GSM_StateMachine *s, GSM_SyncMLSettings *settings)
1184 {
1185 GSM_Error err;
1186
1187 CHECK_PHONE_CONNECTION();
1188
1189 err = s->Phone.Functions->GetSyncMLSettings(s, settings);
1190 PRINT_LOG_ERROR(err);
1191 return err;
1192 }
1193 /**
1194 * Changes SyncML settings.
1195 */
GSM_SetSyncMLSettings(GSM_StateMachine * s,GSM_SyncMLSettings * settings)1196 GSM_Error GSM_SetSyncMLSettings(GSM_StateMachine *s, GSM_SyncMLSettings *settings)
1197 {
1198 GSM_Error err;
1199
1200 CHECK_PHONE_CONNECTION();
1201
1202 err = s->Phone.Functions->SetSyncMLSettings(s, settings);
1203 PRINT_LOG_ERROR(err);
1204 return err;
1205 }
1206 /**
1207 * Acquires chat/presence settings.
1208 */
GSM_GetChatSettings(GSM_StateMachine * s,GSM_ChatSettings * settings)1209 GSM_Error GSM_GetChatSettings(GSM_StateMachine *s, GSM_ChatSettings *settings)
1210 {
1211 GSM_Error err;
1212
1213 CHECK_PHONE_CONNECTION();
1214
1215 err = s->Phone.Functions->GetChatSettings(s, settings);
1216 PRINT_LOG_ERROR(err);
1217 return err;
1218 }
1219 /**
1220 * Changes chat/presence settings.
1221 */
GSM_SetChatSettings(GSM_StateMachine * s,GSM_ChatSettings * settings)1222 GSM_Error GSM_SetChatSettings(GSM_StateMachine *s, GSM_ChatSettings *settings)
1223 {
1224 GSM_Error err;
1225
1226 CHECK_PHONE_CONNECTION();
1227
1228 err = s->Phone.Functions->SetChatSettings(s, settings);
1229 PRINT_LOG_ERROR(err);
1230 return err;
1231 }
1232 /**
1233 * Acquires MMS settings.
1234 */
GSM_GetMMSSettings(GSM_StateMachine * s,GSM_MultiWAPSettings * settings)1235 GSM_Error GSM_GetMMSSettings(GSM_StateMachine *s, GSM_MultiWAPSettings *settings)
1236 {
1237 GSM_Error err;
1238
1239 CHECK_PHONE_CONNECTION();
1240
1241 err = s->Phone.Functions->GetMMSSettings(s, settings);
1242 PRINT_LOG_ERROR(err);
1243 return err;
1244 }
1245 /**
1246 * Changes MMS settings.
1247 */
GSM_SetMMSSettings(GSM_StateMachine * s,GSM_MultiWAPSettings * settings)1248 GSM_Error GSM_SetMMSSettings(GSM_StateMachine *s, GSM_MultiWAPSettings *settings)
1249 {
1250 GSM_Error err;
1251
1252 CHECK_PHONE_CONNECTION();
1253
1254 err = s->Phone.Functions->SetMMSSettings(s, settings);
1255 PRINT_LOG_ERROR(err);
1256 return err;
1257 }
1258 /**
1259 * Lists MMS folders.
1260 */
GSM_GetMMSFolders(GSM_StateMachine * s,GSM_MMSFolders * folders)1261 GSM_Error GSM_GetMMSFolders(GSM_StateMachine *s, GSM_MMSFolders *folders)
1262 {
1263 GSM_Error err;
1264
1265 CHECK_PHONE_CONNECTION();
1266
1267 err = s->Phone.Functions->GetMMSFolders(s, folders);
1268 PRINT_LOG_ERROR(err);
1269 return err;
1270 }
1271 /**
1272 * Retrieves next part of MMS file information.
1273 */
GSM_GetNextMMSFileInfo(GSM_StateMachine * s,unsigned char * FileID,int * MMSFolder,gboolean start)1274 GSM_Error GSM_GetNextMMSFileInfo(GSM_StateMachine *s, unsigned char *FileID, int *MMSFolder, gboolean start)
1275 {
1276 GSM_Error err;
1277
1278 CHECK_PHONE_CONNECTION();
1279 PRINT_START();
1280
1281 err = s->Phone.Functions->GetNextMMSFileInfo(s, FileID, MMSFolder, start);
1282 PRINT_LOG_ERROR(err);
1283 return err;
1284 }
1285 /**
1286 * Gets bitmap.
1287 */
GSM_GetBitmap(GSM_StateMachine * s,GSM_Bitmap * Bitmap)1288 GSM_Error GSM_GetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
1289 {
1290 GSM_Error err;
1291
1292 CHECK_PHONE_CONNECTION();
1293
1294 err = s->Phone.Functions->GetBitmap(s, Bitmap);
1295 PRINT_LOG_ERROR(err);
1296 return err;
1297 }
1298 /**
1299 * Sets bitmap.
1300 */
GSM_SetBitmap(GSM_StateMachine * s,GSM_Bitmap * Bitmap)1301 GSM_Error GSM_SetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
1302 {
1303 GSM_Error err;
1304
1305 CHECK_PHONE_CONNECTION();
1306
1307 err = s->Phone.Functions->SetBitmap(s, Bitmap);
1308 PRINT_LOG_ERROR(err);
1309 return err;
1310 }
1311 /**
1312 * Gets status of ToDos (count of used entries).
1313 */
GSM_GetToDoStatus(GSM_StateMachine * s,GSM_ToDoStatus * status)1314 GSM_Error GSM_GetToDoStatus(GSM_StateMachine *s, GSM_ToDoStatus *status)
1315 {
1316 GSM_Error err;
1317
1318 CHECK_PHONE_CONNECTION();
1319
1320 err = s->Phone.Functions->GetToDoStatus(s, status);
1321 PRINT_LOG_ERROR(err);
1322 return err;
1323 }
1324 /**
1325 * Reads ToDo from phone.
1326 */
GSM_GetToDo(GSM_StateMachine * s,GSM_ToDoEntry * ToDo)1327 GSM_Error GSM_GetToDo(GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
1328 {
1329 GSM_Error err;
1330
1331 CHECK_PHONE_CONNECTION();
1332 PRINT_TODO_INFO();
1333
1334 err = s->Phone.Functions->GetToDo(s, ToDo);
1335 PRINT_LOG_ERROR(err);
1336 return err;
1337 }
1338 /**
1339 * Reads ToDo from phone.
1340 */
GSM_GetNextToDo(GSM_StateMachine * s,GSM_ToDoEntry * ToDo,gboolean start)1341 GSM_Error GSM_GetNextToDo(GSM_StateMachine *s, GSM_ToDoEntry *ToDo, gboolean start)
1342 {
1343 GSM_Error err;
1344
1345 CHECK_PHONE_CONNECTION();
1346 PRINT_START();
1347 PRINT_TODO_INFO();
1348
1349 err = s->Phone.Functions->GetNextToDo(s, ToDo, start);
1350 PRINT_LOG_ERROR(err);
1351 return err;
1352 }
1353 /**
1354 * Sets ToDo in phone.
1355 */
GSM_SetToDo(GSM_StateMachine * s,GSM_ToDoEntry * ToDo)1356 GSM_Error GSM_SetToDo(GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
1357 {
1358 GSM_Error err;
1359
1360 CHECK_PHONE_CONNECTION();
1361 PRINT_TODO_INFO();
1362
1363 err = s->Phone.Functions->SetToDo(s, ToDo);
1364 PRINT_LOG_ERROR(err);
1365 return err;
1366 }
1367 /**
1368 * Adds ToDo in phone.
1369 */
GSM_AddToDo(GSM_StateMachine * s,GSM_ToDoEntry * ToDo)1370 GSM_Error GSM_AddToDo(GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
1371 {
1372 GSM_Error err;
1373
1374 CHECK_PHONE_CONNECTION();
1375 PRINT_TODO_INFO();
1376
1377 err = s->Phone.Functions->AddToDo(s, ToDo);
1378 PRINT_LOG_ERROR(err);
1379 return err;
1380 }
1381 /**
1382 * Deletes ToDo entry in phone.
1383 */
GSM_DeleteToDo(GSM_StateMachine * s,GSM_ToDoEntry * ToDo)1384 GSM_Error GSM_DeleteToDo(GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
1385 {
1386 GSM_Error err;
1387
1388 CHECK_PHONE_CONNECTION();
1389 PRINT_TODO_INFO();
1390
1391 err = s->Phone.Functions->DeleteToDo(s, ToDo);
1392 PRINT_LOG_ERROR(err);
1393 return err;
1394 }
1395 /**
1396 * Deletes all todo entries in phone.
1397 */
GSM_DeleteAllToDo(GSM_StateMachine * s)1398 GSM_Error GSM_DeleteAllToDo(GSM_StateMachine *s)
1399 {
1400 GSM_Error err;
1401
1402 CHECK_PHONE_CONNECTION();
1403
1404 err = s->Phone.Functions->DeleteAllToDo(s);
1405 PRINT_LOG_ERROR(err);
1406 return err;
1407 }
1408 /**
1409 * Retrieves calendar status (number of used entries).
1410 */
GSM_GetCalendarStatus(GSM_StateMachine * s,GSM_CalendarStatus * Status)1411 GSM_Error GSM_GetCalendarStatus(GSM_StateMachine *s, GSM_CalendarStatus *Status)
1412 {
1413 GSM_Error err;
1414
1415 CHECK_PHONE_CONNECTION();
1416
1417 err = s->Phone.Functions->GetCalendarStatus(s, Status);
1418 PRINT_LOG_ERROR(err);
1419 return err;
1420 }
1421 /**
1422 * Retrieves calendar entry.
1423 */
GSM_GetCalendar(GSM_StateMachine * s,GSM_CalendarEntry * Note)1424 GSM_Error GSM_GetCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
1425 {
1426 GSM_Error err;
1427
1428 CHECK_PHONE_CONNECTION();
1429 PRINT_CALENDAR_INFO();
1430
1431 err = s->Phone.Functions->GetCalendar(s, Note);
1432 PRINT_LOG_ERROR(err);
1433 return err;
1434 }
1435 /**
1436 * Retrieves calendar entry. This is useful for continuous reading of all
1437 * calendar entries.
1438 */
GSM_GetNextCalendar(GSM_StateMachine * s,GSM_CalendarEntry * Note,gboolean start)1439 GSM_Error GSM_GetNextCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note, gboolean start)
1440 {
1441 GSM_Error err;
1442
1443 CHECK_PHONE_CONNECTION();
1444 PRINT_START();
1445 PRINT_CALENDAR_INFO();
1446
1447 err = s->Phone.Functions->GetNextCalendar(s, Note, start);
1448 PRINT_LOG_ERROR(err);
1449 return err;
1450 }
1451 /**
1452 * Sets calendar entry
1453 */
GSM_SetCalendar(GSM_StateMachine * s,GSM_CalendarEntry * Note)1454 GSM_Error GSM_SetCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
1455 {
1456 GSM_Error err;
1457
1458 CHECK_PHONE_CONNECTION();
1459 PRINT_CALENDAR_INFO();
1460
1461 err = s->Phone.Functions->SetCalendar(s, Note);
1462 PRINT_LOG_ERROR(err);
1463 return err;
1464 }
1465 /**
1466 * Adds calendar entry.
1467 */
GSM_AddCalendar(GSM_StateMachine * s,GSM_CalendarEntry * Note)1468 GSM_Error GSM_AddCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
1469 {
1470 GSM_Error err;
1471
1472 CHECK_PHONE_CONNECTION();
1473 PRINT_CALENDAR_INFO();
1474
1475 err = s->Phone.Functions->AddCalendar(s, Note);
1476 PRINT_LOG_ERROR(err);
1477 return err;
1478 }
1479 /**
1480 * Deletes calendar entry.
1481 */
GSM_DeleteCalendar(GSM_StateMachine * s,GSM_CalendarEntry * Note)1482 GSM_Error GSM_DeleteCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
1483 {
1484 GSM_Error err;
1485
1486 CHECK_PHONE_CONNECTION();
1487 PRINT_CALENDAR_INFO();
1488
1489 err = s->Phone.Functions->DeleteCalendar(s, Note);
1490 PRINT_LOG_ERROR(err);
1491 return err;
1492 }
1493 /**
1494 * Deletes all calendar entries.
1495 */
GSM_DeleteAllCalendar(GSM_StateMachine * s)1496 GSM_Error GSM_DeleteAllCalendar(GSM_StateMachine *s)
1497 {
1498 GSM_Error err;
1499
1500 CHECK_PHONE_CONNECTION();
1501
1502 err = s->Phone.Functions->DeleteAllCalendar(s);
1503 PRINT_LOG_ERROR(err);
1504 return err;
1505 }
1506 /**
1507 * Reads calendar settings.
1508 */
GSM_GetCalendarSettings(GSM_StateMachine * s,GSM_CalendarSettings * settings)1509 GSM_Error GSM_GetCalendarSettings(GSM_StateMachine *s, GSM_CalendarSettings *settings)
1510 {
1511 GSM_Error err;
1512
1513 CHECK_PHONE_CONNECTION();
1514
1515 err = s->Phone.Functions->GetCalendarSettings(s, settings);
1516 PRINT_LOG_ERROR(err);
1517 return err;
1518 }
1519 /**
1520 * Sets calendar settings.
1521 */
GSM_SetCalendarSettings(GSM_StateMachine * s,GSM_CalendarSettings * settings)1522 GSM_Error GSM_SetCalendarSettings(GSM_StateMachine *s, GSM_CalendarSettings *settings)
1523 {
1524 GSM_Error err;
1525
1526 CHECK_PHONE_CONNECTION();
1527
1528 err = s->Phone.Functions->SetCalendarSettings(s, settings);
1529 PRINT_LOG_ERROR(err);
1530 return err;
1531 }
1532 /**
1533 * Retrieves notes status (number of used entries).
1534 */
GSM_GetNotesStatus(GSM_StateMachine * s,GSM_ToDoStatus * status)1535 GSM_Error GSM_GetNotesStatus(GSM_StateMachine *s, GSM_ToDoStatus *status)
1536 {
1537 GSM_Error err;
1538
1539 CHECK_PHONE_CONNECTION();
1540
1541 err = s->Phone.Functions->GetNotesStatus(s, status);
1542 PRINT_LOG_ERROR(err);
1543 return err;
1544 }
1545 /**
1546 * Retrieves notes entry.
1547 */
GSM_GetNote(GSM_StateMachine * s,GSM_NoteEntry * Note)1548 GSM_Error GSM_GetNote(GSM_StateMachine *s, GSM_NoteEntry *Note)
1549 {
1550 GSM_Error err;
1551
1552 CHECK_PHONE_CONNECTION();
1553 PRINT_NOTE_INFO();
1554
1555 err = s->Phone.Functions->GetNote(s, Note);
1556 PRINT_LOG_ERROR(err);
1557 return err;
1558 }
1559 /**
1560 * Retrieves note entry. This is useful for continuous reading of all
1561 * notes entries.
1562 */
GSM_GetNextNote(GSM_StateMachine * s,GSM_NoteEntry * Note,gboolean start)1563 GSM_Error GSM_GetNextNote(GSM_StateMachine *s, GSM_NoteEntry *Note, gboolean start)
1564 {
1565 GSM_Error err;
1566
1567 CHECK_PHONE_CONNECTION();
1568 PRINT_START();
1569 PRINT_NOTE_INFO();
1570
1571 err = s->Phone.Functions->GetNextNote(s, Note, start);
1572 PRINT_LOG_ERROR(err);
1573 return err;
1574 }
1575 /**
1576 * Sets note entry
1577 */
GSM_SetNote(GSM_StateMachine * s,GSM_NoteEntry * Note)1578 GSM_Error GSM_SetNote(GSM_StateMachine *s, GSM_NoteEntry *Note)
1579 {
1580 GSM_Error err;
1581
1582 CHECK_PHONE_CONNECTION();
1583 PRINT_NOTE_INFO();
1584
1585 err = s->Phone.Functions->SetNote(s, Note);
1586 PRINT_LOG_ERROR(err);
1587 return err;
1588 }
1589 /**
1590 * Adds note entry.
1591 */
GSM_AddNote(GSM_StateMachine * s,GSM_NoteEntry * Note)1592 GSM_Error GSM_AddNote(GSM_StateMachine *s, GSM_NoteEntry *Note)
1593 {
1594 GSM_Error err;
1595
1596 CHECK_PHONE_CONNECTION();
1597 PRINT_NOTE_INFO();
1598
1599 err = s->Phone.Functions->AddNote(s, Note);
1600 PRINT_LOG_ERROR(err);
1601 return err;
1602 }
1603 /**
1604 * Deletes note entry.
1605 */
GSM_DeleteNote(GSM_StateMachine * s,GSM_NoteEntry * Note)1606 GSM_Error GSM_DeleteNote(GSM_StateMachine *s, GSM_NoteEntry *Note)
1607 {
1608 GSM_Error err;
1609
1610 CHECK_PHONE_CONNECTION();
1611 PRINT_NOTE_INFO();
1612
1613 err = s->Phone.Functions->DeleteNote(s, Note);
1614 PRINT_LOG_ERROR(err);
1615 return err;
1616 }
1617 /**
1618 * Deletes all notes entries.
1619 */
GSM_DeleteAllNotes(GSM_StateMachine * s)1620 GSM_Error GSM_DeleteAllNotes(GSM_StateMachine *s)
1621 {
1622 GSM_Error err;
1623
1624 CHECK_PHONE_CONNECTION();
1625
1626 err = s->Phone.Functions->DeleteAllNotes(s);
1627 PRINT_LOG_ERROR(err);
1628 return err;
1629 }
1630 /**
1631 * Reads profile.
1632 */
GSM_GetProfile(GSM_StateMachine * s,GSM_Profile * Profile)1633 GSM_Error GSM_GetProfile(GSM_StateMachine *s, GSM_Profile *Profile)
1634 {
1635 GSM_Error err;
1636
1637 CHECK_PHONE_CONNECTION();
1638
1639 err = s->Phone.Functions->GetProfile(s, Profile);
1640 PRINT_LOG_ERROR(err);
1641 return err;
1642 }
1643 /**
1644 * Updates profile.
1645 */
GSM_SetProfile(GSM_StateMachine * s,GSM_Profile * Profile)1646 GSM_Error GSM_SetProfile(GSM_StateMachine *s, GSM_Profile *Profile)
1647 {
1648 GSM_Error err;
1649
1650 CHECK_PHONE_CONNECTION();
1651
1652 err = s->Phone.Functions->SetProfile(s, Profile);
1653 PRINT_LOG_ERROR(err);
1654 return err;
1655 }
1656 /**
1657 * Reads FM station.
1658 */
GSM_GetFMStation(GSM_StateMachine * s,GSM_FMStation * FMStation)1659 GSM_Error GSM_GetFMStation(GSM_StateMachine *s, GSM_FMStation *FMStation)
1660 {
1661 GSM_Error err;
1662
1663 CHECK_PHONE_CONNECTION();
1664
1665 err = s->Phone.Functions->GetFMStation(s, FMStation);
1666 PRINT_LOG_ERROR(err);
1667 return err;
1668 }
1669 /**
1670 * Sets FM station.
1671 */
GSM_SetFMStation(GSM_StateMachine * s,GSM_FMStation * FMStation)1672 GSM_Error GSM_SetFMStation(GSM_StateMachine *s, GSM_FMStation *FMStation)
1673 {
1674 GSM_Error err;
1675
1676 CHECK_PHONE_CONNECTION();
1677
1678 err = s->Phone.Functions->SetFMStation(s, FMStation);
1679 PRINT_LOG_ERROR(err);
1680 return err;
1681 }
1682 /**
1683 * Clears defined FM stations.
1684 */
GSM_ClearFMStations(GSM_StateMachine * s)1685 GSM_Error GSM_ClearFMStations(GSM_StateMachine *s)
1686 {
1687 GSM_Error err;
1688
1689 CHECK_PHONE_CONNECTION();
1690
1691 err = s->Phone.Functions->ClearFMStations(s);
1692 PRINT_LOG_ERROR(err);
1693 return err;
1694 }
1695 /**
1696 * Gets next filename from filesystem.
1697 */
GSM_GetNextFileFolder(GSM_StateMachine * s,GSM_File * File,gboolean start)1698 GSM_Error GSM_GetNextFileFolder(GSM_StateMachine *s, GSM_File *File, gboolean start)
1699 {
1700 GSM_Error err;
1701
1702 CHECK_PHONE_CONNECTION();
1703 PRINT_START();
1704
1705 err = s->Phone.Functions->GetNextFileFolder(s, File, start);
1706 PRINT_LOG_ERROR(err);
1707 return err;
1708 }
1709 /**
1710 * Gets file part from filesystem.
1711 */
GSM_GetFolderListing(GSM_StateMachine * s,GSM_File * File,gboolean start)1712 GSM_Error GSM_GetFolderListing(GSM_StateMachine *s, GSM_File *File, gboolean start)
1713 {
1714 GSM_Error err;
1715
1716 CHECK_PHONE_CONNECTION();
1717 PRINT_START();
1718
1719 err = s->Phone.Functions->GetFolderListing(s, File, start);
1720 PRINT_LOG_ERROR(err);
1721 return err;
1722 }
1723 /**
1724 * Gets next root folder.
1725 */
GSM_GetNextRootFolder(GSM_StateMachine * s,GSM_File * File)1726 GSM_Error GSM_GetNextRootFolder(GSM_StateMachine *s, GSM_File *File)
1727 {
1728 GSM_Error err;
1729
1730 CHECK_PHONE_CONNECTION();
1731
1732 err = s->Phone.Functions->GetNextRootFolder(s, File);
1733 PRINT_LOG_ERROR(err);
1734 return err;
1735 }
1736 /**
1737 * Sets file system attributes.
1738 */
GSM_SetFileAttributes(GSM_StateMachine * s,GSM_File * File)1739 GSM_Error GSM_SetFileAttributes(GSM_StateMachine *s, GSM_File *File)
1740 {
1741 GSM_Error err;
1742
1743 CHECK_PHONE_CONNECTION();
1744
1745 err = s->Phone.Functions->SetFileAttributes(s, File);
1746 PRINT_LOG_ERROR(err);
1747 return err;
1748 }
1749 /**
1750 * Retrieves file part.
1751 */
GSM_GetFilePart(GSM_StateMachine * s,GSM_File * File,int * Handle,size_t * Size)1752 GSM_Error GSM_GetFilePart(GSM_StateMachine *s, GSM_File *File, int *Handle, size_t *Size)
1753 {
1754 GSM_Error err;
1755
1756 CHECK_PHONE_CONNECTION();
1757
1758 err = s->Phone.Functions->GetFilePart(s, File, Handle, Size);
1759 PRINT_LOG_ERROR(err);
1760 return err;
1761 }
1762 /**
1763 * Adds file part to filesystem.
1764 */
GSM_AddFilePart(GSM_StateMachine * s,GSM_File * File,size_t * Pos,int * Handle)1765 GSM_Error GSM_AddFilePart(GSM_StateMachine *s, GSM_File *File, size_t *Pos, int *Handle)
1766 {
1767 GSM_Error err;
1768
1769 CHECK_PHONE_CONNECTION();
1770
1771 err = s->Phone.Functions->AddFilePart(s, File, Pos, Handle);
1772 PRINT_LOG_ERROR(err);
1773 return err;
1774 }
1775 /**
1776 * Sends file to phone, it's up to phone to decide what to do with it.
1777 */
GSM_SendFilePart(GSM_StateMachine * s,GSM_File * File,size_t * Pos,int * Handle)1778 GSM_Error GSM_SendFilePart(GSM_StateMachine *s, GSM_File *File, size_t *Pos, int *Handle)
1779 {
1780 GSM_Error err;
1781
1782 CHECK_PHONE_CONNECTION();
1783
1784 err = s->Phone.Functions->SendFilePart(s, File, Pos, Handle);
1785 PRINT_LOG_ERROR(err);
1786 return err;
1787 }
1788 /**
1789 * Acquires filesystem status.
1790 */
GSM_GetFileSystemStatus(GSM_StateMachine * s,GSM_FileSystemStatus * Status)1791 GSM_Error GSM_GetFileSystemStatus(GSM_StateMachine *s, GSM_FileSystemStatus *Status)
1792 {
1793 GSM_Error err;
1794
1795 CHECK_PHONE_CONNECTION();
1796
1797 err = s->Phone.Functions->GetFileSystemStatus(s, Status);
1798 PRINT_LOG_ERROR(err);
1799 return err;
1800 }
1801 /**
1802 * Deletes file from filessytem.
1803 */
GSM_DeleteFile(GSM_StateMachine * s,unsigned char * ID)1804 GSM_Error GSM_DeleteFile(GSM_StateMachine *s, unsigned char *ID)
1805 {
1806 GSM_Error err;
1807
1808 CHECK_PHONE_CONNECTION();
1809
1810 err = s->Phone.Functions->DeleteFile(s, ID);
1811 PRINT_LOG_ERROR(err);
1812 return err;
1813 }
1814 /**
1815 * Adds folder to filesystem.
1816 */
GSM_AddFolder(GSM_StateMachine * s,GSM_File * File)1817 GSM_Error GSM_AddFolder(GSM_StateMachine *s, GSM_File *File)
1818 {
1819 GSM_Error err;
1820
1821 CHECK_PHONE_CONNECTION();
1822
1823 err = s->Phone.Functions->AddFolder(s, File);
1824 PRINT_LOG_ERROR(err);
1825 return err;
1826 }
1827 /**
1828 * Deletes folder from filesystem.
1829 */
GSM_DeleteFolder(GSM_StateMachine * s,unsigned char * ID)1830 GSM_Error GSM_DeleteFolder(GSM_StateMachine *s, unsigned char *ID)
1831 {
1832 GSM_Error err;
1833
1834 CHECK_PHONE_CONNECTION();
1835
1836 err = s->Phone.Functions->DeleteFolder(s, ID);
1837 PRINT_LOG_ERROR(err);
1838 return err;
1839 }
1840 /**
1841 * Gets GPRS access point.
1842 */
GSM_GetGPRSAccessPoint(GSM_StateMachine * s,GSM_GPRSAccessPoint * point)1843 GSM_Error GSM_GetGPRSAccessPoint(GSM_StateMachine *s, GSM_GPRSAccessPoint *point)
1844 {
1845 GSM_Error err;
1846
1847 CHECK_PHONE_CONNECTION();
1848
1849 err = s->Phone.Functions->GetGPRSAccessPoint(s, point);
1850 PRINT_LOG_ERROR(err);
1851 return err;
1852 }
1853 /**
1854 * Sets GPRS access point.
1855 */
GSM_SetGPRSAccessPoint(GSM_StateMachine * s,GSM_GPRSAccessPoint * point)1856 GSM_Error GSM_SetGPRSAccessPoint(GSM_StateMachine *s, GSM_GPRSAccessPoint *point)
1857 {
1858 GSM_Error err;
1859
1860 CHECK_PHONE_CONNECTION();
1861
1862 err = s->Phone.Functions->SetGPRSAccessPoint(s, point);
1863 PRINT_LOG_ERROR(err);
1864 return err;
1865 }
1866
1867 /**
1868 * Gets phone screenshot
1869 */
GSM_GetScreenshot(GSM_StateMachine * s,GSM_BinaryPicture * picture)1870 GSM_Error GSM_GetScreenshot(GSM_StateMachine *s, GSM_BinaryPicture *picture)
1871 {
1872 GSM_Error err;
1873
1874 CHECK_PHONE_CONNECTION();
1875
1876 picture->Length = 0;
1877 picture->Buffer = NULL;
1878 picture->Type = 0;
1879
1880 err = s->Phone.Functions->GetScreenshot(s, picture);
1881 PRINT_LOG_ERROR(err);
1882 return err;
1883 }
1884
1885 /**
1886 * Gets phone screenshot
1887 */
GSM_Install(GSM_StateMachine * s,const char * ExtraPath,gboolean Minimal)1888 GSM_Error GSM_Install(GSM_StateMachine *s, const char *ExtraPath, gboolean Minimal)
1889 {
1890 GSM_Error err;
1891
1892 err = s->Phone.Functions->Install(s, ExtraPath, Minimal);
1893 PRINT_LOG_ERROR(err);
1894 return err;
1895 }
1896
1897 /* How should editor hadle tabs in this file? Add editor commands here.
1898 * vim: noexpandtab sw=8 ts=8 sts=8:
1899 */
1900