libgammu/api.c

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