int single_test(const char *string, const char *expected)
{
const char *ret;
ret = GSM_GetNetworkName(string);
if (strcmp(DecodeUnicodeConsole(ret), expected) != 0) {
printf("Result %s did not match %s\n", DecodeUnicodeConsole(ret), expected);
return 1;
}
return 0;
}
void RestoreSMS(int argc, char *argv[])
{
GSM_Error error;
GSM_MultiSMSMessage *SMS;
GSM_SMS_Backup *Backup;
GSM_SMSFolders folders;
int smsnum = 0;
gboolean restore8bit;
SMS = malloc(sizeof(GSM_MultiSMSMessage));
if (SMS == NULL) {
return;
}
Backup = malloc(sizeof(GSM_SMS_Backup));
if (Backup == NULL) {
free(SMS);
return;
}
if (argc == 4 && strcasecmp(argv[3],"-yes") == 0) always_answer_yes = TRUE;
error = GSM_ReadSMSBackupFile(argv[2], Backup);
Print_Error(error);
restore8bit = answer_yes("%s", _("Do you want to restore binary SMS?"));
GSM_Init(TRUE);
error = GSM_GetSMSFolders(gsm, &folders);
Print_Error(error);
while (Backup->SMS[smsnum] != NULL) {
if (restore8bit || Backup->SMS[smsnum]->Coding != SMS_Coding_8bit) {
SMS->Number = 1;
memcpy(&(SMS->SMS[0]), Backup->SMS[smsnum], sizeof(GSM_SMSMessage));
DisplayMultiSMSInfo(SMS, FALSE, FALSE, NULL, gsm);
if (answer_yes(_("Restore %03i sms to folder \"%s\"%s?"),
smsnum + 1,
DecodeUnicodeConsole(folders.Folder[Backup->SMS[smsnum]->Folder - 1].Name),
folders.Folder[Backup->SMS[smsnum]->Folder - 1].Memory == MEM_SM ? _(" (SIM)") : "")) {
smprintf(gsm, _("saving %i SMS\n"),smsnum);
error = GSM_AddSMS(gsm, Backup->SMS[smsnum]);
Print_Error(error);
}
}
smsnum++;
}
/* We don't need this anymore */
GSM_FreeSMSBackup(Backup);
free(Backup);
free(SMS);
GSM_Terminate();
}
void NokiaComposer(int argc UNUSED, char *argv[])
{
GSM_Error error;
GSM_Ringtone ringtone;
gboolean started;
int i,j;
GSM_RingNote *Note;
GSM_RingNoteDuration Duration;
GSM_RingNoteDuration DefNoteDuration = 32; /* 32 = Duration_1_4 */
unsigned int DefNoteScale = Scale_880;
ringtone.Format = 0;
error=GSM_ReadRingtoneFile(argv[2],&ringtone);
Print_Error(error);
if (ringtone.Format != RING_NOTETONE) {
printf("%s\n", _("It can be RTTL ringtone only used with this option"));
Terminate(2);
}
started = FALSE;
j = 0;
for (i=0;i<ringtone.NoteTone.NrCommands;i++) {
if (ringtone.NoteTone.Commands[i].Type == RING_Note) {
Note = &ringtone.NoteTone.Commands[i].Note;
if (!started) {
if (Note->Note != Note_Pause) {
printf(_("Ringtone \"%s\" (tempo = %i Beats Per Minute)"),DecodeUnicodeConsole(ringtone.Name),GSM_RTTLGetTempo(Note->Tempo));
printf("\n\n");
started = TRUE;
}
}
if (started) j++;
}
}
if (j>50) {
printf_warn(_("length=%i notes, but you will enter only first 50 tones."), j);
}
printf("\n\n%s ", _("This ringtone in Nokia Composer in phone should look:"));
started = FALSE;
for (i=0;i<ringtone.NoteTone.NrCommands;i++) {
if (ringtone.NoteTone.Commands[i].Type == RING_Note) {
Note = &ringtone.NoteTone.Commands[i].Note;
if (!started) {
if (Note->Note != Note_Pause) started = TRUE;
}
if (started) {
switch (Note->Duration) {
case Duration_Full: printf("1"); break;
case Duration_1_2 : printf("2"); break;
case Duration_1_4 : printf("4"); break;
case Duration_1_8 : printf("8"); break;
case Duration_1_16: printf("16");break;
case Duration_1_32: printf("32");break;
}
if (Note->DurationSpec == DottedNote) printf(".");
switch (Note->Note) {
case Note_C : printf("c"); break;
case Note_Cis : printf("#c"); break;
case Note_D :printf("d"); break;
case Note_Dis : printf("#d"); break;
case Note_E : printf("e"); break;
case Note_F : printf("f"); break;
case Note_Fis : printf("#f"); break;
case Note_G : printf("g"); break;
case Note_Gis : printf("#g"); break;
case Note_A : printf("a"); break;
case Note_Ais : printf("#a"); break;
case Note_H : printf("h"); break;
case Note_Pause : printf("-"); break;
}
if (Note->Note != Note_Pause) printf("%i",Note->Scale - 4);
printf(" ");
}
}
}
printf("\n\n%s ", _("To enter it please press:"));
started = FALSE;
for (i=0;i<ringtone.NoteTone.NrCommands;i++) {
if (ringtone.NoteTone.Commands[i].Type == RING_Note) {
Note = &ringtone.NoteTone.Commands[i].Note;
if (!started) {
if (Note->Note != Note_Pause) started = TRUE;
}
if (started) {
switch (Note->Note) {
case Note_C : case Note_Cis: printf("1");break;
case Note_D : case Note_Dis: printf("2");break;
case Note_E : printf("3");break;
case Note_F : case Note_Fis: printf("4");break;
case Note_G : case Note_Gis: printf("5");break;
case Note_A : case Note_Ais: printf("6");break;
case Note_H : printf("7");break;
default : printf("0");break;
}
if (Note->DurationSpec == DottedNote) printf("%s", _("(longer)"));
switch (Note->Note) {
case Note_Cis: case Note_Dis:
case Note_Fis: case Note_Gis:
case Note_Ais:
printf("#");
break;
default :
break;
}
if (Note->Note != Note_Pause) {
if ((unsigned int)Note->Scale != DefNoteScale) {
while (DefNoteScale != (unsigned int)Note->Scale) {
printf("*");
DefNoteScale++;
if (DefNoteScale==Scale_7040) DefNoteScale = Scale_880;
}
}
}
Duration = 0;
switch (Note->Duration) {
case Duration_Full : Duration = 128; break;
case Duration_1_2 : Duration = 64; break;
case Duration_1_4 : Duration = 32; break;
case Duration_1_8 : Duration = 16; break;
case Duration_1_16 : Duration = 8; break;
case Duration_1_32 : Duration = 4; break;
default : fprintf(stderr, "error\n");break;
}
if (Duration > DefNoteDuration) {
while (DefNoteDuration != Duration) {
printf("9");
DefNoteDuration = DefNoteDuration * 2;
}
}
if (Duration < DefNoteDuration) {
while (DefNoteDuration != Duration) {
printf("8");
DefNoteDuration = DefNoteDuration / 2;
}
}
printf(" ");
}
}
}
printf("\n");
fflush(stdout);
}
void NokiaAddPlayLists2(unsigned char *ID,unsigned char *Name,unsigned char *IDFolder)
{
GSM_Error error;
gboolean Start = TRUE, Available = FALSE;
GSM_File Files,Files2,Files3;
int j,NamesPos2=0;
size_t i, NamesPos = 0;
unsigned char Buffer[20],Buffer2[500];
unsigned char *Names,*Names2,*Pointer;
PlayListEntry *First,*Entry=NULL,*Prev;
First = NULL; Names=NULL; Names2=NULL;
CopyUnicodeString(Files.ID_FullName,ID);
printf(_("Checking %s\n"),DecodeUnicodeString(Name));
/* looking into folder content (searching for mp3 and similiar) */
while (1) {
error = GSM_GetFolderListing(gsm,&Files,Start);
if (error == ERR_FOLDERPART) {
printf("%s\n", _(" Only part handled!"));
break;
}
if (error == ERR_EMPTY) break;
if (error == ERR_FILENOTEXIST) return;
Print_Error(error);
if (!Files.Folder) {
if (strcasestr(DecodeUnicodeConsole(Files.Name),".mp3")!=NULL ||
strcasestr(DecodeUnicodeConsole(Files.Name),".aac")!=NULL) {
if (First==NULL) {
First = malloc(sizeof(PlayListEntry));
Entry = First;
} else {
Entry->Next = malloc(sizeof(PlayListEntry));
Entry = Entry->Next;
}
Entry->Next = NULL;
Entry->Name = malloc(strlen(DecodeUnicodeString(Files.ID_FullName))+1);
sprintf(Entry->Name,"%s",DecodeUnicodeString(Files.ID_FullName));
/* converting Gammu drives to phone drives */
if (Entry->Name[0]=='a' || Entry->Name[0]=='A') {
Entry->Name[0]='b';
} else if (Entry->Name[0]=='d' || Entry->Name[0]=='D') {
Entry->Name[0]='a';
}
Entry->NameUP = malloc(strlen(DecodeUnicodeString(Files.ID_FullName))+1);
for (i = 0; i < strlen(DecodeUnicodeString(Files.ID_FullName)) + 1; i++) {
Entry->NameUP[i] = tolower(Entry->Name[i]);
}
}
} else {
Names = (unsigned char *)realloc(Names,NamesPos+UnicodeLength(Files.ID_FullName)*2+2);
CopyUnicodeString(Names+NamesPos,Files.ID_FullName);
NamesPos+=UnicodeLength(Files.ID_FullName)*2+2;
Names2 = (unsigned char *)realloc(Names2,NamesPos2+UnicodeLength(Files.Name)*2+2);
CopyUnicodeString(Names2+NamesPos2,Files.Name);
NamesPos2+=UnicodeLength(Files.Name)*2+2;
}
Start = FALSE;
}
if (First!=NULL) {
/* sorting songs names */
Entry=First;
while (Entry->Next!=NULL) {
if (strcmp(Entry->NameUP,Entry->Next->NameUP)>0) {
Pointer=Entry->Next->Name;
Entry->Next->Name = Entry->Name;
Entry->Name = Pointer;
Pointer=Entry->Next->NameUP;
Entry->Next->NameUP = Entry->NameUP;
Entry->NameUP = Pointer;
Entry=First;
continue;
}
Entry=Entry->Next;
}
/* we checking, if file already exist.if yes, we look for another... */
i = 0;
Files3.Buffer = NULL;
while (1) {
CopyUnicodeString(Files3.ID_FullName,IDFolder);
CopyUnicodeString(Buffer2,Name);
if (i!=0) {
sprintf(Buffer, "%ld", (long)i);
EncodeUnicode(Buffer2+UnicodeLength(Buffer2)*2,Buffer,strlen(Buffer));
}
EncodeUnicode(Buffer2+UnicodeLength(Buffer2)*2,".m3u",4);
Start = TRUE;
Available = FALSE;
while (1) {
error = GSM_GetFolderListing(gsm,&Files3,Start);
if (error == ERR_FOLDERPART) {
printf("%s\n", _(" Problem with adding playlist"));
break;
}
if (error == ERR_EMPTY) break;
Print_Error(error);
if (!Files3.Folder) {
if (mywstrncasecmp(Buffer2,Files3.Name,-1)) {
Available = TRUE;
break;
}
}
Start = FALSE;
}
if (!Available) break;
i++;
}
/* preparing new playlist file date */
Files2.System = FALSE;
Files2.Folder = FALSE;
Files2.ReadOnly = FALSE;
Files2.Hidden = FALSE;
Files2.Protected = FALSE;
Files2.ModifiedEmpty = FALSE;
GSM_GetCurrentDateTime (&Files2.Modified);
CopyUnicodeString(Files2.ID_FullName,IDFolder);
CopyUnicodeString(Files2.Name,Buffer2);
/* preparing new playlist file content */
Files2.Buffer=NULL;
Files2.Buffer = (unsigned char *)realloc(Files2.Buffer,10);
sprintf(Files2.Buffer,"#EXTM3U%c%c",13,10);
Files2.Used = 9;
Entry=First;
while (Entry!=NULL) {
Files2.Buffer = (unsigned char *)realloc(Files2.Buffer,Files2.Used+strlen(Entry->Name)+2+1);
sprintf(Files2.Buffer+Files2.Used,"%s%c%c",Entry->Name,13,10);
Files2.Used+=strlen(Entry->Name)+2;
Entry=Entry->Next;
}
Files2.Used -= 2;
for (i=0;i<Files2.Used;i++) {
if (Files2.Buffer[i]=='/') Files2.Buffer[i]='\\';
}
/* adding new playlist file */
sprintf(Buffer2, _("Writing file %s:"), DecodeUnicodeString(Files2.Name));
AddOneFile(&Files2, Buffer2, FALSE);
/* cleaning buffers */
free(Files2.Buffer);
Files2.Buffer=NULL;
while (Entry!=NULL) {
Entry=First;
Prev=NULL;
while (Entry->Next!=NULL) {
Prev=Entry;
Entry=Entry->Next;
}
free(Entry->Name);
free(Entry->NameUP);
free(Entry);
Entry=NULL;
if (Prev!=NULL) Prev->Next = NULL;
}
}
/* going into subfolders */
if (NamesPos != 0) {
i = 0; j = 0;
while (i != NamesPos) {
NokiaAddPlayLists2(Names+i,Names2+j,IDFolder);
i+=UnicodeLength(Names+i)*2+2;
j+=UnicodeLength(Names2+j)*2+2;
}
}
free(Names);
free(Names2);
}
/**
* We separate matching text (Start) to tokens and then try to find all
* tokens in Buffer. We also accept tokens like PREF, CHARSET or ENCODING.
*
* Also it parses TYPE=* tokens, matching it to text types passed in Start
* parameter. For example Start "TEL;FAX;VOICE" matches "TEL;TYPE=FAX,VOICE"
* or "TEL;FAX;TYPE=VOICE" or "TEL;TYPE=FAX;TYPE=VOICE" and of course
* "TEL;FAX;VOICE".
*
* When all tokens are matched we found matching line.
*/
gboolean ReadVCALText(char *Buffer, const char *Start, unsigned char *Value, const gboolean UTF8, GSM_EntryLocation *location)
{
char *line = NULL;
char **tokens = NULL;
char *charset = NULL;
char *begin, *pos, *end, *end2;
gboolean quoted_printable = FALSE;
size_t numtokens, token;
size_t i, j, len;
gboolean found;
gboolean ret = FALSE;
/* Initialize output */
Value[0] = 0x00;
Value[1] = 0x00;
/* Count number of tokens */
len = strlen(Start);
numtokens = 1;
for (i = 0; i < len; i++) {
if (Start[i] == ';') {
numtokens++;
}
}
/* Allocate memory */
line = strdup(Start);
if (line == NULL) {
dbgprintf(NULL, "Could not alloc!\n");
goto fail;
}
tokens = (char **)malloc(sizeof(char *) * numtokens);
if (tokens == NULL) {
dbgprintf(NULL, "Could not alloc!\n");
goto fail;
}
/* Parse Start to vCard tokens (separated by ;) */
token = 0;
begin = line;
for (i = 0; i < len; i++) {
if (line[i] == ';') {
tokens[token++] = begin;
begin = line + i + 1;
line[i] = 0;
}
}
/* Store last token */
tokens[token] = begin;
/* Compare first token, it must be in place */
pos = Buffer;
len = strlen(tokens[0]);
if (strncasecmp(pos, tokens[0], len) != 0) {
goto fail;
}
/* Advance position */
pos += len;
/* No need to check this token anymore */
tokens[0][0] = 0;
/* Initialize location */
if (location != NULL) {
*location = PBK_Location_Unknown;
}
/* Check remaining tokens */
while (*pos != ':') {
if (*pos == ';') {
pos++;
} else {
dbgprintf(NULL, "Could not parse! (stopped at string: %s)\n", pos);
goto fail;
}
found = FALSE;
for (token = 0; token < numtokens; token++) {
len = strlen(tokens[token]);
/* Skip already matched tokens */
if (len == 0) {
continue;
}
if (strncasecmp(pos, tokens[token], len) == 0) {
dbgprintf(NULL, "Found %s\n", tokens[token]);
/* Advance position */
pos += len;
/* We need to check one token less */
tokens[token][0] = 0;
found = TRUE;
break;
}
}
if (!found) {
if (strncasecmp(pos, "ENCODING=QUOTED-PRINTABLE", 25) == 0) {
quoted_printable = TRUE;
/* Advance position */
pos += 25;
found = TRUE;
} else if (strncasecmp(pos, "CHARSET=", 8) == 0) {
/* Advance position */
pos += 8;
/* Grab charset */
end = strchr(pos, ':');
end2 = strchr(pos, ';');
if (end == NULL && end2 == NULL) {
dbgprintf(NULL, "Could not read charset!\n");
goto fail;
} else if (end == NULL) {
end = end2;
} else if (end2 != NULL && end2 < end) {
end = end2;
}
/* We basically want strndup, but it is not portable */
charset = strdup(pos);
if (charset == NULL) {
dbgprintf(NULL, "Could not alloc!\n");
goto fail;
}
charset[end - pos] = 0;
pos = end;
found = TRUE;
} else if (strncasecmp(pos, "TZID=", 5) == 0) {
/* @todo: We ignore time zone for now */
/* Advance position */
pos += 5;
/* Go behind value */
end = strchr(pos, ':');
end2 = strchr(pos, ';');
if (end == NULL && end2 == NULL) {
dbgprintf(NULL, "Could not read timezone!\n");
goto fail;
} else if (end == NULL) {
end = end2;
} else if (end2 != NULL && end2 < end) {
end = end2;
}
pos = end;
found = TRUE;
} else if (strncasecmp(pos, "TYPE=", 5) == 0) {
/* We ignore TYPE= prefix */
pos += 5;
/* Now process types, which should be comma separated */
while (*pos != ':' && *pos != ';') {
found = FALSE;
/* Go through tokens to match */
for (token = 0; token < numtokens; token++) {
len = strlen(tokens[token]);
/* Skip already matched tokens */
if (len == 0) {
continue;
}
if (strncasecmp(pos, tokens[token], len) == 0) {
dbgprintf(NULL, "Found %s\n", tokens[token]);
/* Advance position */
pos += len;
/* We need to check one token less */
tokens[token][0] = 0;
found = TRUE;
break;
}
}
if (!found) {
if (strncasecmp(pos, "PREF", 4) == 0) {
/* We ignore pref token */
pos += 4;
found = TRUE;
} else if (strncasecmp(pos, "WORK", 4) == 0) {
/* We ignore work token */
pos += 4;
found = TRUE;
if (location != NULL) {
*location = PBK_Location_Work;
}
} else if (strncasecmp(pos, "HOME", 4) == 0) {
/* We ignore home token */
pos += 4;
found = TRUE;
if (location != NULL) {
*location = PBK_Location_Home;
}
} else {
dbgprintf(NULL, "%s not found! (%s)\n", Start, pos);
goto fail;
}
}
if (*pos == ';' || *pos == ':') {
dbgprintf(NULL, "End of TYPE= string\n");
break;
} else if (*pos == ',') {
/* Advance past separator */
pos++;
} else {
dbgprintf(NULL, "Could not parse TYPE=! (stopped at string: %s)\n", pos);
goto fail;
}
}
} else if (strncasecmp(pos, "PREF", 4) == 0) {
/* We ignore pref token */
pos += 4;
found = TRUE;
} else if (location && strncasecmp(pos, "WORK", 4) == 0) {
/* We ignore pref token */
pos += 4;
found = TRUE;
*location = PBK_Location_Work;
} else if (location && strncasecmp(pos, "HOME", 4) == 0) {
/* We ignore pref token */
pos += 4;
found = TRUE;
*location = PBK_Location_Home;
}
if (!found) {
dbgprintf(NULL, "%s not found!\n", Start);
goto fail;
}
}
}
/* Skip : */
pos++;
/* Length of rest */
len = strlen(pos);
/* Did we match all our tokens? */
for (token = 0; token < numtokens; token++) {
if (strlen(tokens[token]) > 0) {
dbgprintf(NULL, "All tokens did not match!\n");
goto fail;
}
}
/* Decode the text */
if (charset == NULL) {
if (quoted_printable) {
if (UTF8) {
DecodeUTF8QuotedPrintable(Value, pos, len);
} else {
DecodeISO88591QuotedPrintable(Value, pos, len);
}
} else {
if (UTF8) {
DecodeUTF8(Value, pos, len);
} else {
DecodeISO88591(Value, pos, len);
}
}
} else {
if (strcasecmp(charset, "UTF-8") == 0||
strcasecmp(charset, "\"UTF-8\"") == 0
) {
if (quoted_printable) {
DecodeUTF8QuotedPrintable(Value, pos, len);
} else {
DecodeUTF8(Value, pos, len);
}
} else if (strcasecmp(charset, "UTF-7") == 0||
strcasecmp(charset, "\"UTF-7\"") == 0
) {
if (quoted_printable) {
dbgprintf(NULL, "Unsupported charset: %s\n", charset);
goto fail;
} else {
DecodeUTF7(Value, pos, len);
}
} else {
dbgprintf(NULL, "Unsupported charset: %s\n", charset);
goto fail;
}
}
/* Postprocess escaped chars */
len = UnicodeLength(Value);
for (i = 0; i < len; i++) {
if (Value[(2 * i)] == 0 && Value[(2 * i) + 1] == '\\') {
j = i + 1;
if (Value[(2 * j)] == 0 && (
Value[(2 * j) + 1] == 'n' ||
Value[(2 * j) + 1] == 'N')
) {
Value[(2 * i) + 1] = '\n';
} else if (Value[(2 * j)] == 0 && (
Value[(2 * j) + 1] == 'r' ||
Value[(2 * j) + 1] == 'R')
) {
Value[(2 * i) + 1] = '\r';
} else if (Value[(2 * j)] == 0 && Value[(2 * j) + 1] == '\\') {
Value[(2 * i) + 1] = '\\';
} else if (Value[(2 * j)] == 0 && Value[(2 * j) + 1] == ';') {
Value[(2 * i) + 1] = ';';
} else if (Value[(2 * j)] == 0 && Value[(2 * j) + 1] == ',') {
Value[(2 * i) + 1] = ',';
} else {
/* We ignore unknown for now */
continue;
}
/* Shift the string */
memmove(Value + (2 * j), Value + (2 * j) + 2, 2 * (len + 1 - j));
len--;
}
}
ret = TRUE;
dbgprintf(NULL, "ReadVCalText(%s) is \"%s\"\n", Start, DecodeUnicodeConsole(Value));
fail:
free(line);
line=NULL;
free(tokens);
tokens=NULL;
free(charset);
charset=NULL;
return ret;
}
void BackupSMS(int argc UNUSED, char *argv[])
{
GSM_Error error;
GSM_SMS_Backup *Backup;
GSM_MultiSMSMessage *sms;
GSM_SMSFolders folders;
gboolean BackupFromFolder[GSM_MAX_SMS_FOLDERS];
gboolean start = TRUE;
gboolean DeleteAfter = FALSE, askdelete = TRUE;
int j, smsnum = 0;
sms = malloc(sizeof(GSM_MultiSMSMessage));
if (sms == NULL) {
return;
}
Backup = malloc(sizeof(GSM_SMS_Backup));
if (Backup == NULL) {
free(sms);
return;
}
if (argc == 4) {
if (strcasecmp(argv[3],"-yes") == 0) {
always_answer_yes = TRUE;
}
if (strcasecmp(argv[3],"-all") == 0) {
always_answer_yes = TRUE;
askdelete = FALSE;
DeleteAfter = FALSE;
}
}
GSM_Init(TRUE);
Backup->SMS[0] = NULL;
sms->SMS[0].Location = 0;
sms->Number = 0;
error=GSM_GetSMSFolders(gsm, &folders);
Print_Error(error);
if (askdelete) {
DeleteAfter = answer_yes("%s", _("Delete each sms after backup?"));
}
for (j=0;j<folders.Number;j++) {
BackupFromFolder[j] = FALSE;
if (answer_yes(_("Backup sms from folder \"%s\"%s?"),
DecodeUnicodeConsole(folders.Folder[j].Name),
folders.Folder[j].Memory == MEM_SM ? _(" (SIM)") : ""
))
BackupFromFolder[j] = TRUE;
}
while (error == ERR_NONE) {
sms->SMS[0].Folder=0x00;
error=GSM_GetNextSMS(gsm, sms, start);
switch (error) {
case ERR_EMPTY:
break;
default:
Print_Error(error);
for (j=0;j<sms->Number;j++) {
if (BackupFromFolder[sms->SMS[j].Folder-1]) {
switch (sms->SMS[j].PDU) {
case SMS_Status_Report:
break;
case SMS_Submit:
case SMS_Deliver:
if (sms->SMS[j].Length == 0) break;
if (smsnum < GSM_BACKUP_MAX_SMS) {
Backup->SMS[smsnum] = malloc(sizeof(GSM_SMSMessage));
if (Backup->SMS[smsnum] == NULL) Print_Error(ERR_MOREMEMORY);
Backup->SMS[smsnum + 1] = NULL;
} else {
printf(_(" Increase %s\n") , "GSM_BACKUP_MAX_SMS");
GSM_Terminate();
Terminate(1);
}
*(Backup->SMS[smsnum]) = sms->SMS[j];
smsnum++;
break;
}
}
}
}
start=FALSE;
}
error = GSM_AddSMSBackupFile(argv[2], Backup);
Print_Error(error);
if (DeleteAfter) {
for (j=0;j<smsnum;j++) {
Backup->SMS[j]->Folder = 0;
error=GSM_DeleteSMS(gsm, Backup->SMS[j]);
Print_Error(error);
fprintf(stderr, "\r");
fprintf(stderr, "%s ", _("Deleting:"));
fprintf(stderr, _("%i percent"),
(j + 1) * 100 / smsnum);
}
}
GSM_FreeSMSBackup(Backup);
free(Backup);
free(sms);
GSM_Terminate();
}
static SQL_Error SMSDSQL_NamedQuery(GSM_SMSDConfig * Config, const char *sql_query, GSM_SMSMessage *sms,
const SQL_Var *params, SQL_result * res)
{
char buff[65536], *ptr, c, static_buff[8192];
char *buffer2, *end;
const char *to_print, *q = sql_query;
int int_to_print;
int numeric;
int n, argc = 0;
struct GSM_SMSDdbobj *db = Config->db;
GSM_NetworkInfo NetInfo;
char empty[1] = "";
char *NetCode, *NetName;
NetCode = empty;
NetName = empty;
/* Query network status only if we need it */
if (
(strstr(sql_query, "%O") != NULL || strstr(sql_query, "%M") != NULL)
&& GSM_GetNetworkInfo(Config->gsm, &NetInfo) == ERR_NONE
) {
NetCode = NetInfo.NetworkCode;
if (NetInfo.NetworkName[0] != 0x00 || NetInfo.NetworkName[1] != 0x00) {
NetName = DecodeUnicodeConsole(NetInfo.NetworkName);
}
}
if (params != NULL) {
while (params[argc].type != SQL_TYPE_NONE) argc++;
}
ptr = buff;
do {
if (*q != '%') {
*ptr++ = *q;
continue;
}
c = *(++q);
if( c >= '0' && c <= '9'){
n = strtoul(q, &end, 10) - 1;
if (n < argc && n >= 0) {
switch(params[n].type){
case SQL_TYPE_INT:
ptr += sprintf(ptr, "%i", params[n].v.i);
break;
case SQL_TYPE_STRING:
buffer2 = db->QuoteString(Config, params[n].v.s);
memcpy(ptr, buffer2, strlen(buffer2));
ptr += strlen(buffer2);
free(buffer2);
break;
default:
SMSD_Log(DEBUG_ERROR, Config, "SQL: unknown type: %i (application bug) in query: `%s`", params[n].type, sql_query);
return SQL_BUG;
break;
}
} else {
SMSD_Log(DEBUG_ERROR, Config, "SQL: wrong number of parameter: %i (max %i) in query: `%s`", n+1, argc, sql_query);
return SQL_BUG;
}
q = end - 1;
continue;
}
numeric = 0;
to_print = NULL;
switch (c) {
case 'I':
to_print = Config->Status->IMEI;
break;
case 'P':
to_print = Config->PhoneID;
break;
case 'O':
to_print = NetCode;
break;
case 'M':
to_print = NetName;
break;
case 'N':
snprintf(static_buff, sizeof(static_buff), "Gammu %s, %s, %s", GAMMU_VERSION, GetOS(), GetCompiler());
to_print = static_buff;
break;
case 'A':
to_print = Config->CreatorID;
break;
default:
if (sms != NULL) {
switch (c) {
case 'R':
EncodeUTF8(static_buff, sms->Number);
to_print = static_buff;
break;
case 'F':
EncodeUTF8(static_buff, sms->SMSC.Number);
to_print = static_buff;
break;
case 'u':
if (sms->UDH.Type != UDH_NoUDH) {
EncodeHexBin(static_buff, sms->UDH.Text, sms->UDH.Length);
to_print = static_buff;
}else{
to_print = "";
}
break;
case 'x':
int_to_print = sms->Class;
numeric = 1;
break;
case 'c':
to_print = GSM_SMSCodingToString(sms->Coding);
break;
case 't':
int_to_print = sms->MessageReference;
numeric = 1;
break;
case 'E':
switch (sms->Coding) {
case SMS_Coding_Unicode_No_Compression:
case SMS_Coding_Default_No_Compression:
EncodeHexUnicode(static_buff, sms->Text, UnicodeLength(sms->Text));
break;
case SMS_Coding_8bit:
EncodeHexBin(static_buff, sms->Text, sms->Length);
break;
default:
*static_buff = '\0';
break;
}
to_print = static_buff;
break;
case 'T':
switch (sms->Coding) {
case SMS_Coding_Unicode_No_Compression:
case SMS_Coding_Default_No_Compression:
EncodeUTF8(static_buff, sms->Text);
to_print = static_buff;
break;
default:
to_print = "";
break;
}
break;
case 'V':
if (sms->SMSC.Validity.Format == SMS_Validity_RelativeFormat) {
int_to_print = sms->SMSC.Validity.Relative;
} else {
int_to_print = -1;
}
numeric = 1;
break;
case 'C':
SMSDSQL_Time2String(Config, Fill_Time_T(sms->SMSCTime), static_buff, sizeof(static_buff));
to_print = static_buff;
break;
case 'd':
SMSDSQL_Time2String(Config, Fill_Time_T(sms->DateTime), static_buff, sizeof(static_buff));
to_print = static_buff;
break;
case 'e':
int_to_print = sms->DeliveryStatus;
numeric = 1;
break;
default:
SMSD_Log(DEBUG_ERROR, Config, "SQL: uexpected char '%c' in query: %s", c, sql_query);
return SQL_BUG;
} /* end of switch */
} else {
SMSD_Log(DEBUG_ERROR, Config, "Syntax error in query.. uexpected char '%c' in query: %s", c, sql_query);
return SQL_BUG;
}
break;
} /* end of switch */
if (numeric) {
ptr += sprintf(ptr, "%i", int_to_print);
} else if (to_print != NULL) {
buffer2 = db->QuoteString(Config, to_print);
memcpy(ptr, buffer2, strlen(buffer2));
ptr += strlen(buffer2);
free(buffer2);
} else {
memcpy(ptr, "NULL", 4);
ptr += 4;
}
} while (*(++q) != '\0');
*ptr = '\0';
return SMSDSQL_Query(Config, buff, res);
}
* messages.
*/
GSM_ClearMultiPartSMSInfo(&SMSInfo);
/* Class 1 message (normal) */
SMSInfo.Class = 1;
/* Message will be consist of one part */
SMSInfo.EntriesNum = 1;
/* No unicode */
SMSInfo.UnicodeCoding = FALSE;
/* The part has type long text */
SMSInfo.Entries[0].ID = SMS_ConcatenatedTextLong;
/* Encode message text */
EncodeUnicode(message_unicode, message_text, strlen(message_text));
SMSInfo.Entries[0].Buffer = message_unicode;
printf("%s\n", DecodeUnicodeConsole(SMSInfo.Entries[0].Buffer));
/* Encode message into PDU parts */
error = GSM_EncodeMultiPartSMS(debug_info, &SMSInfo, &SMS);
error_handler();
/* Allocates state machine */
s = GSM_AllocStateMachine();
if (s == NULL)
return 3;
/*
* Enable state machine debugging to stderr
* Same could be achieved by just using global debug config.
*/
debug_info = GSM_GetDebug(s);
