static GSM_Error DCT4_ReplyTuneRadio(GSM_Protocol_Message *msg, GSM_StateMachine *sm)
{
int length;
unsigned char name[100];
switch (msg->Buffer[3]) {
case 0x09:
N6510_DecodeFMFrequency(&RadioFreq, msg->Buffer+16);
length = msg->Buffer[8];
memcpy(name,msg->Buffer+18,length*2);
name[length*2] = 0x00;
name[length*2+1] = 0x00;
CopyUnicodeString(RadioName,name);
smprintf(sm,"Station name: \"%s\"\n",DecodeUnicodeString(RadioName));
return ERR_NONE;
case 0x15:
case 0x16:
smprintf(sm,"Response for enabling radio/headset status received\n");
if (msg->Buffer[5] == 0) {
smprintf(sm,"Connected\n");
return ERR_NONE;
}
smprintf(sm,"Probably not connected\n");
return ERR_PERMISSION;
}
return ERR_UNKNOWNRESPONSE;
}
unsigned char *VCALGetTextPart(unsigned char *Buff, int *pos)
{
static unsigned char tmp[1000];
unsigned char *start;
start = Buff + *pos;
while (Buff[*pos] != 0 || Buff[*pos + 1] != 0) {
if (Buff[*pos] == 0 && Buff[*pos + 1] == ';') {
Buff[*pos + 1] = 0;
CopyUnicodeString(tmp, start);
Buff[*pos + 1] = ';';
*pos += 2;
return tmp;
}
*pos += 2;
}
if (start == Buff || (start[0] == 0 && start[1] == 0)) return NULL;
CopyUnicodeString(tmp, start);
return tmp;
}
GSM_Error DUMMY_GetSMSFolders(GSM_StateMachine *s, GSM_SMSFolders *folders)
{
PHONE_GetSMSFolders(s,folders);
folders->Number = 5;
CopyUnicodeString(folders->Folder[2].Name,folders->Folder[0].Name);
folders->Folder[2].InboxFolder = folders->Folder[0].InboxFolder;
folders->Folder[2].OutboxFolder = folders->Folder[0].OutboxFolder;
folders->Folder[2].Memory = MEM_ME;
CopyUnicodeString(folders->Folder[3].Name,folders->Folder[1].Name);
folders->Folder[3].InboxFolder = folders->Folder[1].InboxFolder;
folders->Folder[3].OutboxFolder = folders->Folder[1].OutboxFolder;
folders->Folder[3].Memory = MEM_ME;
EncodeUnicode(folders->Folder[4].Name,_("Templates"),strlen(_("Templates")));
folders->Folder[4].InboxFolder = FALSE;
folders->Folder[4].OutboxFolder = FALSE;
folders->Folder[4].Memory = MEM_ME;
return ERR_NONE;
}
GSM_Error DUMMY_GetAlarm(GSM_StateMachine *s, GSM_Alarm *entry)
{
GSM_Backup Backup;
char *filename=NULL;
GSM_Error error;
int i;
filename = DUMMY_AlarmPath(s, entry);
error = GSM_ReadBackupFile(filename, &Backup, GSM_Backup_VCalendar);
free(filename);
filename=NULL;
if (error != ERR_NONE) {
if (error == ERR_CANTOPENFILE) return ERR_EMPTY;
return error;
}
if (Backup.Calendar[0] == NULL) return ERR_EMPTY;
entry->Repeating = FALSE;
entry->Text[0] = 0;
entry->Text[1] = 0;
GSM_GetCurrentDateTime(&entry->DateTime);
for (i = 0; i < Backup.Calendar[0]->EntriesNum; i++) {
switch (Backup.Calendar[0]->Entries[i].EntryType) {
case CAL_TONE_ALARM_DATETIME:
entry->DateTime = Backup.Calendar[0]->Entries[i].Date;
break;
case CAL_TEXT:
CopyUnicodeString(entry->Text, Backup.Calendar[0]->Entries[i].Text);
break;
case CAL_REPEAT_FREQUENCY:
if (Backup.Calendar[0]->Entries[i].Number) {
entry->Repeating = TRUE;
}
break;
default:
break;
}
}
GSM_FreeBackup(&Backup);
return ERR_NONE;
}
GSM_Error DUMMY_AddFilePart(GSM_StateMachine *s, GSM_File *File, int *Pos, int *Handle)
{
char *path;
FILE *file;
size_t pos;
GSM_Error error;
*Handle = 0;
pos = UnicodeLength(File->ID_FullName);
if (pos > 0 && (File->ID_FullName[2*pos - 2] != 0 || File->ID_FullName[2*pos - 1] != '/')) {
File->ID_FullName[2*pos + 1] = '/';
File->ID_FullName[2*pos + 0] = 0;
pos++;
}
CopyUnicodeString(File->ID_FullName + 2 * pos, File->Name);
path = DUMMY_GetFSFilePath(s, File->ID_FullName);
file = fopen(path, "w");
if (file == NULL) {
free(path);
error = DUMMY_Error(s, "fopen(w) failed");
if (error == ERR_EMPTY) return ERR_PERMISSION;
return error;
}
if (fwrite(File->Buffer, 1, File->Used, file) != File->Used) {
free(path);
error = DUMMY_Error(s, "fwrite failed");
fclose(file);
if (error == ERR_EMPTY) return ERR_PERMISSION;
return error;
}
if (fclose(file) != 0) {
free(path);
error = DUMMY_Error(s, "fclose failed");
if (error == ERR_EMPTY) return ERR_PERMISSION;
return error;
}
free(path);
path=NULL;
*Pos = File->Used;
return ERR_EMPTY;
}
int CopyStringFromDict(PyObject * dict, const char *key, size_t len,
unsigned char *dest)
{
unsigned char *s;
s = GetStringFromDict(dict, key);
if (s == NULL)
return 0;
if (UnicodeLength(s) > len) {
pyg_warning("Truncating text %s to %ld chars!\n", key,
(long)len);
s[2 * len] = 0;
s[(2 * len) + 1] = 0;
}
CopyUnicodeString(dest, s);
free(s);
return 1;
}
GSM_Error DUMMY_SetAlarm(GSM_StateMachine *s, GSM_Alarm *entry)
{
char *filename=NULL;
GSM_Error error;
GSM_Backup backup;
GSM_CalendarEntry cal;
GSM_ClearBackup(&backup);
error = DUMMY_DeleteAlarm(s, entry);
if (error != ERR_EMPTY && error != ERR_NONE) return error;
filename = DUMMY_AlarmPath(s, entry);
cal.EntriesNum = 3;
cal.Type = GSM_CAL_ALARM;
cal.Location = entry->Location;
cal.Entries[0].EntryType = CAL_TONE_ALARM_DATETIME;
cal.Entries[0].Date = entry->DateTime;
cal.Entries[0].Date.Year = 1970;
cal.Entries[0].Date.Month = 1;
cal.Entries[0].Date.Day = 1;
cal.Entries[0].Date.Timezone = 0;
cal.Entries[1].EntryType = CAL_START_DATETIME;
cal.Entries[1].Date = entry->DateTime;
cal.Entries[1].Date.Year = 1970;
cal.Entries[1].Date.Month = 1;
cal.Entries[1].Date.Day = 1;
cal.Entries[1].Date.Timezone = 0;
cal.Entries[2].EntryType = CAL_TEXT;
CopyUnicodeString(cal.Entries[2].Text, entry->Text);
if (entry->Repeating) {
cal.Entries[3].EntryType = CAL_REPEAT_FREQUENCY;
cal.Entries[3].Number = 1;
}
backup.Calendar[0] = &cal;
backup.Calendar[1] = NULL;
error = GSM_SaveBackupFile(filename, &backup, GSM_Backup_VCalendar);
free(filename);
filename=NULL;
return error;
}
GSM_Error DUMMY_AddFolder(GSM_StateMachine *s, GSM_File *File)
{
char *path;
size_t pos;
pos = UnicodeLength(File->ID_FullName);
if (pos > 0 && (File->ID_FullName[2*pos - 2] != 0 || File->ID_FullName[2*pos - 1] != '/')) {
File->ID_FullName[2*pos + 1] = '/';
File->ID_FullName[2*pos + 0] = 0;
pos++;
}
CopyUnicodeString(File->ID_FullName + 2 * pos, File->Name);
path = DUMMY_GetFSFilePath(s, File->ID_FullName);
if (MKDIR(path) != 0) {
free(path);
path=NULL;
return DUMMY_Error(s, "mkdir failed");
}
free(path);
path=NULL;
return ERR_NONE;
}
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);
}
//
// TDS 4.1.4
//
EFI_STATUS
BBTestStrUprFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_UNICODE_COLLATION_PROTOCOL *UnicodeCollation;
UINTN Index;
EFI_TEST_ASSERTION AssertionType;
//
// Test Data
//
CHAR16 *TestData[] ={
L"\x21\x22\x31\x32\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5Ax61\x62\x7D\x7E",
L"\x30\x50[abcdzyxw!)(@#*]\x40\x20\x30\x50\ab\x40\x20",
L"\x30\x50[A-D]\x40\x20\x30\x50f\x40\x20",
L""
};
CHAR16 TestDataSav[MAX_SIZE_OF_STRING + 1];
//
// Verify whether it is one of IHV interfaces
//
if (! IsIhvInterface (ClientInterface, SupportHandle)) {
return EFI_UNSUPPORTED;
}
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
UnicodeCollation = (EFI_UNICODE_COLLATION_PROTOCOL *)ClientInterface;
for (Index = 0; Index < sizeof (TestData) / sizeof (CHAR16*); Index++) {
//
// Backup current test data
//
CopyUnicodeString (TestDataSav, TestData[Index]);
//
// For each test data, test the StrUpr functionality.
//
UnicodeCollation->StrUpr (UnicodeCollation, TestData[Index]);
if (CheckStrUpr (TestDataSav, TestData[Index])) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid005,
L"EFI_UNICODE_COLLATION_PROTOCOL.StrUpr - Verification of StrUpr interface",
L"%a:%d: Original=%s-- ToUpper=%s",
__FILE__,
__LINE__,
TestDataSav,
TestData[Index]
);
CopyUnicodeString (TestDataSav, TestData[Index]);
UnicodeCollation->StrLwr (UnicodeCollation, TestData[Index]);
UnicodeCollation->StrUpr (UnicodeCollation, TestData[Index]);
if (CheckStrEql (TestDataSav, TestData[Index])) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gUnicodeCollationFunctionTestAssertionGuid006,
L"EFI_UNICODE_COLLATION_PROTOCOL.StrUpr - Verification of StrUpr interface",
L"%a:%d: Original=%s -- ToUpper=%s",
__FILE__,
__LINE__,
TestDataSav,
TestData[Index]
);
};
return EFI_SUCCESS;
}
static GSM_Error GSM_DecodeLDIFEntry(char *Buffer, size_t *Pos, GSM_MemoryEntry *Pbk)
{
unsigned char Line[2000],Buff[2000],Buff2[2000];
int Level = 0;
GSM_Error error;
Buff[0] = 0;
Pbk->EntriesNum = 0;
while (1) {
error = MyGetLine(Buffer, Pos, Line, strlen(Buffer), sizeof(Line), FALSE);
if (error != ERR_NONE) return error;
if (strlen(Line) == 0) break;
Pbk->Entries[Pbk->EntriesNum].AddError = ERR_NONE;
Pbk->Entries[Pbk->EntriesNum].SMSList[0] = 0;
Pbk->Entries[Pbk->EntriesNum].VoiceTag = 0;
switch (Level) {
case 0:
if (ReadLDIFText(Line, "objectclass", Buff)) {
sprintf(Buff2,"%s",DecodeUnicodeString(Buff));
if (!strcmp("mozillaAbPersonObsolete",Buff2)) {
dbgprintf(NULL, "level1\n");
Level = 1;
}
}
break;
case 1:
if (ReadLDIFText(Line, "dn", Buff)) {
dbgprintf(NULL, "entries num is %i\n",Pbk->EntriesNum);
if (Pbk->EntriesNum == 0) return ERR_EMPTY;
return ERR_NONE;
}
if (ReadLDIFText(Line, "givenName", Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Text_Name;
Pbk->EntriesNum++;
}
if (ReadLDIFText(Line, "telephoneNumber", Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Number_General;
Pbk->EntriesNum++;
}
if (ReadLDIFText(Line, "mobile", Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Number_Mobile;
Pbk->EntriesNum++;
}
if (ReadLDIFText(Line, "pager", Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Number_Pager;
Pbk->EntriesNum++;
}
if (ReadLDIFText(Line, "messaging", Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Number_Messaging;
Pbk->EntriesNum++;
}
if (ReadLDIFText(Line, "workPhone", Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Number_Work;
Pbk->EntriesNum++;
}
if (ReadLDIFText(Line, "fax", Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Number_Fax;
Pbk->EntriesNum++;
}
if (ReadLDIFText(Line, "homePhone",Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Number_Home;
Pbk->EntriesNum++;
}
if (ReadLDIFText(Line, "Description", Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Text_Note;
Pbk->EntriesNum++;
}
if (ReadLDIFText(Line, "HomePostalAddress", Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Text_Postal;
Pbk->EntriesNum++;
}
if (ReadLDIFText(Line, "womePostalAddress", Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Text_WorkPostal;
Pbk->EntriesNum++;
}
if (ReadLDIFText(Line, "mail", Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Text_Email;
Pbk->EntriesNum++;
}
if (ReadLDIFText(Line, "homeurl", Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Text_URL;
Pbk->EntriesNum++;
}
if (ReadLDIFText(Line, "luid", Buff)) {
CopyUnicodeString(Pbk->Entries[Pbk->EntriesNum].Text,Buff);
Pbk->Entries[Pbk->EntriesNum].EntryType = PBK_Text_LUID;
Pbk->EntriesNum++;
}
/* FIXME: add rest */
break;
}
}
dbgprintf(NULL, "entries num is %i\n",Pbk->EntriesNum);
if (Pbk->EntriesNum == 0) return ERR_EMPTY;
return ERR_NONE;
}
// Get the list of Address Books for the currently logged in user profile
STDMETHODIMP CPalmSyncImp::nsGetABList(BOOL aIsUnicode, short * aABListCount,
lpnsMozABDesc * aABList, long ** aABCatIndexList, BOOL ** aDirFlagsList)
{
if (!aABListCount || !aABList || !aABCatIndexList ||!aDirFlagsList)
return E_FAIL;
*aABListCount = 0;
nsresult rv;
nsCOMPtr<nsIAbManager> abManager(do_GetService(NS_ABMANAGER_CONTRACTID, &rv));
if (NS_FAILED(rv))
return E_FAIL;
nsCOMPtr<nsISimpleEnumerator> subDirectories;
if (NS_SUCCEEDED(abManager->GetDirectories(getter_AddRefs(subDirectories))) &&
subDirectories)
{
// Get the total number of addrbook.
PRInt16 count=0;
nsCOMPtr<nsISupports> item;
PRBool hasMore;
while (NS_SUCCEEDED(rv = subDirectories->HasMoreElements(&hasMore)) && hasMore)
{
if (NS_SUCCEEDED(subDirectories->GetNext(getter_AddRefs(item))))
{
nsCOMPtr<nsIAbDirectory> directory(do_QueryInterface(item, &rv));
if (NS_SUCCEEDED(rv))
{
nsCAutoString fileName;
rv = directory->GetFileName(fileName);
if(NS_FAILED(rv))
continue;
PRInt32 dirType;
rv = directory->GetDirType(&dirType);
if(NS_FAILED(rv))
continue;
PRBool disableThisAB;
rv = directory->GetBoolValue("disablePalmSync",
PR_FALSE, &disableThisAB);
if (NS_FAILED(rv))
continue;
// Skip/Ignore 4.X addrbooks (ie, with ".na2" extension), and non personal AB's
if (disableThisAB || ((fileName.Length() > kABFileName_PreviousSuffixLen) &&
strcmp(fileName.get() + fileName.Length() - kABFileName_PreviousSuffixLen, kABFileName_PreviousSuffix) == 0) ||
(dirType != kPABDirectory && dirType != kMAPIDirectory))
continue;
}
}
count++;
}
if (!count)
return E_FAIL; // should not happen but just in case.
lpnsMozABDesc serverDescList = (lpnsMozABDesc) CoTaskMemAlloc(sizeof(nsMozABDesc) * count);
BOOL *dirFlagsList = (BOOL *) CoTaskMemAlloc(sizeof(BOOL) * count);
long *catIndexList = (long *) CoTaskMemAlloc(sizeof(long) * count);
*aABListCount = count;
*aABList = serverDescList;
*aDirFlagsList = dirFlagsList;
*aABCatIndexList = catIndexList;
// reset enumerator
if (NS_FAILED(abManager->GetDirectories(getter_AddRefs(subDirectories))))
return E_FAIL;
// For each valid addrbook collect info.
while (NS_SUCCEEDED(rv = subDirectories->HasMoreElements(&hasMore)) && hasMore)
{
if (NS_SUCCEEDED(subDirectories->GetNext(getter_AddRefs(item))))
{
nsCOMPtr<nsIAbDirectory> directory(do_QueryInterface(item, &rv));
if (NS_SUCCEEDED(rv))
{
// We don't have to skip mailing list since there's no mailing lists at the top level.
nsCAutoString fileName;
nsCAutoString uri;
nsString description;
PRUint32 palmSyncTimeStamp;
PRInt32 dirType, palmCategoryIndex;
rv = directory->GetDescription(description);
if(NS_FAILED(rv)) return E_FAIL;
rv = directory->GetFileName(fileName);
if(NS_FAILED(rv)) return E_FAIL;
rv = directory->GetURI(uri);
if(NS_FAILED(rv)) return E_FAIL;
rv = directory->GetDirType(&dirType);
if(NS_FAILED(rv)) return E_FAIL;
rv = directory->GetIntValue("PalmCategoryId", -1, &palmCategoryIndex);
if (NS_FAILED(rv)) return E_FAIL;
rv = directory->GetIntValue("PalmSyncTimeStamp", 0,
(PRInt32*)&palmSyncTimeStamp);
if (NS_FAILED(rv)) return E_FAIL;
PRBool disableThisAB;
rv = directory->GetBoolValue("disablePalmSync", PR_FALSE, &disableThisAB);
if (NS_FAILED(rv)) return E_FAIL;
// Skip/Ignore 4.X addrbooks (ie, with ".na2" extension), and non personal AB's
if (disableThisAB || ((fileName.Length() > kABFileName_PreviousSuffixLen) &&
strcmp(fileName.get() + fileName.Length() - kABFileName_PreviousSuffixLen, kABFileName_PreviousSuffix) == 0) ||
(dirType != kPABDirectory && dirType != kMAPIDirectory))
{
continue;
}
if(aIsUnicode)
{
// convert uri to Unicode
nsAutoString abUrl;
rv = ConvertToUnicode("UTF-8", uri, abUrl);
if (NS_FAILED(rv))
break;
// add to the list
CopyUnicodeString(&(serverDescList->lpszABName), description);
CopyUnicodeString(&(serverDescList->lpszABUrl), abUrl);
}
else {
// we need to convert uri to Unicode and then to ASCII
nsAutoString abUUrl;
rv = ConvertToUnicode("UTF-8", uri, abUUrl);
if (NS_FAILED(rv))
break;
CopyCString(&(serverDescList->lpszABName),
NS_ConvertUTF16toUTF8(description));
CopyCString(&(serverDescList->lpszABUrl),
NS_ConvertUTF16toUTF8(abUUrl));
}
serverDescList++;
PRUint32 dirFlag = 0;
if (palmSyncTimeStamp <= 0)
dirFlag |= kFirstTimeSyncDirFlag;
// was this the pab?
nsCAutoString prefName;
rv = directory->GetDirPrefId(prefName);
if (NS_FAILED(rv))
break;
if (prefName.Equals("ldap_2.servers.pab"))
dirFlag |= kIsPabDirFlag;
*dirFlagsList = (BOOL) dirFlag;
dirFlagsList++;
*catIndexList = palmCategoryIndex;
catIndexList++;
}
}
}
// assign member variables to the beginning of the list
serverDescList = *aABList;
dirFlagsList = *aDirFlagsList;
catIndexList = *aABCatIndexList;
if(NS_FAILED(rv))
return E_FAIL;
}
return S_OK;
}
void DCT4TuneRadio(int argc, char *argv[])
{
double Freq, diff;
GSM_Error error;
GSM_FMStation FMStation[50],FMStat;
int i, j, num;
gboolean found;
unsigned char Enable[] = {N6110_FRAME_HEADER, 0x00, 0x00, 0x00};
unsigned char Disable[] = {N6110_FRAME_HEADER, 0x01, 0x0E, 0x00};
// unsigned char SetVolume[] = {N6110_FRAME_HEADER, 0x14,
// 0x00, /* Volume level */
// 0x00};
// unsigned char MuteUnMute[] = {N6110_FRAME_HEADER, 0x0F,
// 0x0C, /* 0x0B = mute, 0x0C = unmute */
// 0x00};
unsigned char SetFreq[] = {N6110_FRAME_HEADER, 0x08,
0x08, 0x14, 0x00, 0x01,
0x9A, 0x28}; /* Frequency */
// unsigned char Find1[] = {N6110_FRAME_HEADER, 0x08,
// 0x04, 0x14, 0x00, 0x00, 0x00, 0x00};
unsigned char Find2[] = {N6110_FRAME_HEADER, 0x08,
0x05, 0x14, 0x00, 0x00, 0x00, 0x00};
// unsigned char SetStereo[] = {N6110_FRAME_HEADER, 0x19,
// 0x0A, 0x00, 0x15};
// unsigned char SetMono[] = {N6110_FRAME_HEADER, 0x19,
// 0x09, 0x00, 0x96};
GSM_Init(TRUE);
CheckDCT4();
gsm->User.UserReplyFunctions=UserReplyFunctions4;
FMStat.Location = 1;
error = GSM_GetFMStation(gsm,&FMStat);
if (error != ERR_NONE && error != ERR_EMPTY) {
printf("%s\n", _("Phone seems not to support radio"));
GSM_Terminate();
Terminate(3);
}
error=GSM_WaitFor (gsm, Enable, 6, 0x3E, 4, ID_User3);
if (error == ERR_PERMISSION) {
printf("%s\n", _("Please connect headset. Required as antenna"));
GSM_Terminate();
Terminate(3);
}
Print_Error(error);
num=0;
for (i=88;i<108;i++) {
fprintf(stderr,"%cSearching: %i percent",13,(i-88)*100/(108-88));
Freq = i;
N6510_EncodeFMFrequency(Freq, SetFreq+8);
error=GSM_WaitFor (gsm, SetFreq, 10, 0x3E, 4, ID_User3);
Print_Error(error);
error=GSM_WaitFor (gsm, Find2, 10, 0x3E, 4, ID_User3);
Print_Error(error);
found = FALSE;
for (j=0;j<num;j++) {
if (FMStation[j].Frequency > RadioFreq) {
diff = FMStation[j].Frequency - RadioFreq;
} else {
diff = RadioFreq - FMStation[j].Frequency;
}
if (diff <= 0.2) {
smprintf(gsm, "diff is %f\n",diff);
found = TRUE;
break;
}
}
if (!found) {
smprintf(gsm, "Adding %f, num %i\n",RadioFreq,num);
FMStation[num].Frequency = RadioFreq;
CopyUnicodeString(FMStation[num].StationName,RadioName);
num++;
}
}
fprintf(stderr,"%cSearching: %i percent",13,100);
fprintf(stderr,"\n\n");
i=0;
while(1) {
if (i==num || i==num-1) break;
if (FMStation[i].Frequency > FMStation[i+1].Frequency) {
memcpy(&FMStat,&FMStation[i],sizeof(GSM_FMStation));
memcpy(&FMStation[i],&FMStation[i+1],sizeof(GSM_FMStation));
memcpy(&FMStation[i+1],&FMStat,sizeof(GSM_FMStation));
i = 0;
continue;
}
i++;
}
for (i=0;i<num;i++) {
fprintf(stderr,"%02i.",i+1);
if (FMStation[i].Frequency < 100) fprintf(stderr," ");
fprintf(stderr,"%.1f MHz - \"%s\" \n",
FMStation[i].Frequency,
DecodeUnicodeString(FMStation[i].StationName));
}
if (answer_yes2("Do you want to save found stations")) {
fprintf(stderr,"Deleting old FM stations: ");
error=GSM_ClearFMStations(gsm);
Print_Error(error);
fprintf(stderr,"Done\n");
for (i=0;i<num;i++) {
FMStation[i].Location = i+1;
error=GSM_SetFMStation(gsm,&FMStation[i]);
Print_Error(error);
fprintf(stderr,"%cWriting: %i percent",13,(i+1)*100/num);
}
fprintf(stderr,"\n");
}
error=GSM_WaitFor (gsm, Disable, 6, 0x3E, 4, ID_User3);
Print_Error(error);
GSM_Terminate();
}
UINTN
_IPrint (
IN EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput,
IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *Sto,
IN UINTN X,
IN UINTN Y,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Foreground,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Background,
IN CHAR16 *fmt
)
{
VOID *Buffer;
EFI_STATUS Status;
UINT16 GlyphWidth;
UINT32 GlyphStatus;
UINT16 StringIndex;
UINTN Index;
CHAR16 *UnicodeWeight;
EFI_NARROW_GLYPH *Glyph;
UINTN Size;
EFI_HII_PROTOCOL *Hii;
EFI_HANDLE Handle;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *LineBuffer;
UINTN HorizontalResolution;
UINTN VerticalResolution;
GlyphStatus = 0;
//
// For now, allocate an arbitrarily long buffer
//
Status = gtBS->AllocatePool (EfiBootServicesData,
0x10000,
&Buffer);
CopyUnicodeString ((CHAR16*) Buffer, fmt);
HorizontalResolution = GraphicsOutput->Mode->Info->HorizontalResolution;
VerticalResolution = GraphicsOutput->Mode->Info->VerticalResolution;
Status = gtBS->AllocatePool (
EfiBootServicesData,
sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) * HorizontalResolution * GLYPH_HEIGHT,
&LineBuffer
);
if (EFI_ERROR (Status)) {
gtBS->FreePool (Buffer);
return Status;
}
Size = sizeof (EFI_HANDLE);
Status = gtBS->LocateHandle (
ByProtocol,
&gEfiHiiProtocolGuid,
NULL,
&Size,
&Handle
);
if (EFI_ERROR (Status)) {
goto Error;
}
Status = gtBS->HandleProtocol (
Handle,
&gEfiHiiProtocolGuid,
&Hii
);
if (EFI_ERROR (Status)) {
goto Error;
}
UnicodeWeight = (CHAR16 *)Buffer;
for (Index = 0; UnicodeWeight[Index] != 0; Index++) {
if (UnicodeWeight[Index] == CHAR_BACKSPACE ||
UnicodeWeight[Index] == CHAR_LINEFEED ||
UnicodeWeight[Index] == CHAR_CARRIAGE_RETURN) {
UnicodeWeight[Index] = 0;
}
}
for (Index = 0; Index < EfiStrLen (Buffer); Index++) {
StringIndex = (UINT16)Index;
Status = Hii->GetGlyph (Hii, UnicodeWeight, &StringIndex, (UINT8 **)&Glyph, &GlyphWidth, &GlyphStatus);
if (EFI_ERROR (Status)) {
goto Error;
}
if (Foreground == NULL || Background == NULL) {
Status = Hii->GlyphToBlt (Hii, (UINT8 *)Glyph, mEfiColors[Sto->Mode->Attribute & 0x0f], mEfiColors[Sto->Mode->Attribute >> 4], EfiStrLen (Buffer), GlyphWidth, GLYPH_HEIGHT, &LineBuffer[Index * GLYPH_WIDTH]);
} else {
/**
* @name action_send_messages:
*/
int action_send_messages(gammu_state_t **sp,
int argc, char *argv[]) {
int rv = 0;
char **argp = &argv[1];
if (argc <= 2) {
print_usage_error(U_ERR_ARGS_MISSING);
return 1;
}
if (argc % 2 != 1) {
print_usage_error(U_ERR_ARGS_ODD);
return 2;
}
/* Lazy initialization of libgammu */
gammu_state_t *s = gammu_create_if_necessary(sp);
if (!s) {
print_operation_error(OP_ERR_INIT);
rv = 3; goto cleanup;
}
/* Allocate */
smsc_t *smsc = allocate(sizeof(*smsc));
multimessage_t *sms = allocate(sizeof(*sms));
multimessage_info_t *info = allocate(sizeof(*info));
/* Find SMSC number */
smsc->Location = 1;
if ((s->err = GSM_GetSMSC(s->sm, smsc)) != ERR_NONE) {
print_operation_error(OP_ERR_SMSC);
rv = 4; goto cleanup_sms;
}
transmit_status_t status;
initialize_transmit_status(&status);
GSM_SetSendSMSStatusCallback(
s->sm, _message_transmit_callback, &status
);
boolean_t is_start = TRUE;
unsigned int message_index = 0;
printf("[");
/* For each message... */
while (*argp != NULL) {
GSM_ClearMultiPartSMSInfo(info);
GSM_Debug_Info *debug = GSM_GetGlobalDebug();
/* Copy/convert destination phone number */
char *sms_destination_number = convert_utf8_utf16be(*argp++, FALSE);
if (!sms_destination_number) {
status.err = "Invalid UTF-8 sequence in destination number";
goto cleanup_end;
}
string_info_t nsi;
utf16be_string_info(sms_destination_number, &nsi);
/* Check size of phone number:
We'll be decoding this in to a fixed-sized buffer. */
if (nsi.units >= GSM_MAX_NUMBER_LENGTH) {
status.err = "Phone number is too long";
goto cleanup_transmit_status;
}
/* Missing message text:
This shouldn't happen since we check `argc` above,
but I'm leaving this here in case we refactor later. */
if (*argp == NULL) {
status.err = "No message body provided";
goto cleanup_transmit_status;
}
/* UTF-8 message content */
char *sms_message = *argp++;
/* Convert message from UTF-8 to UTF-16-BE:
Every symbol is two bytes long; the string is then
terminated by a single 2-byte UTF-16 null character. */
char *sms_message_utf16be = convert_utf8_utf16be(sms_message, FALSE);
if (!sms_message_utf16be) {
status.err = "Invalid UTF-8 sequence";
goto cleanup_transmit_status;
}
/* Prepare message info structure:
This information is used to encode the possibly-multipart SMS. */
info->Class = 1;
info->EntriesNum = 1;
info->Entries[0].ID = SMS_ConcatenatedTextLong;
info->Entries[0].Buffer = (uint8_t *) sms_message_utf16be;
info->UnicodeCoding = !utf16be_is_gsm_string(sms_message_utf16be);
if ((s->err = GSM_EncodeMultiPartSMS(debug, info, sms)) != ERR_NONE) {
status.err = "Failed to encode message";
goto cleanup_sms_text;
}
status.parts_sent = 0;
status.parts_total = sms->Number;
/* For each SMS part... */
for (unsigned int i = 0; i < sms->Number; i++) {
status.finished = FALSE;
status.message_part_index = i;
sms->SMS[i].PDU = SMS_Submit;
/* Copy destination phone number:
This is a fixed-size buffer; size was already checked above. */
CopyUnicodeString(sms->SMS[i].SMSC.Number, smsc->Number);
CopyUnicodeString(
sms->SMS[i].Number, (unsigned char *) sms_destination_number
);
/* Transmit a single message part */
if ((s->err = GSM_SendSMS(s->sm, &sms->SMS[i])) != ERR_NONE) {
status.parts[i].err = "Message transmission failed";
continue;
}
for (;;) {
/* Wait for reply */
GSM_ReadDevice(s->sm, TRUE);
if (status.finished) {
break;
}
}
if (!status.parts[i].transmitted) {
status.parts[i].err = "Message delivery failed";
continue;
}
status.parts_sent++;
}
cleanup_sms_text:
status.message_index = ++message_index;
free(sms_message_utf16be);
cleanup_transmit_status:
print_json_transmit_status(s, sms, &status, is_start);
free(sms_destination_number);
cleanup_end:
is_start = FALSE;
}
cleanup_sms:
free(sms);
free(smsc);
free(info);
printf("]\n");
cleanup:
return rv;
}
/* Find one multi SMS to sending and return it (or return ERR_EMPTY)
* There is also set ID for SMS
*/
static GSM_Error SMSDSQL_FindOutboxSMS(GSM_MultiSMSMessage * sms, GSM_SMSDConfig * Config, char *ID)
{
SQL_result res;
struct GSM_SMSDdbobj *db = Config->db;
int i;
time_t timestamp;
const char *coding;
const char *text;
size_t text_len;
const char *text_decoded;
const char *destination;
const char *udh;
const char *q;
size_t udh_len;
SQL_Var vars[3];
vars[0].type = SQL_TYPE_INT;
vars[0].v.i = 1;
vars[1].type = SQL_TYPE_NONE;
while (TRUE) {
if (SMSDSQL_NamedQuery(Config, Config->SMSDSQL_queries[SQL_QUERY_FIND_OUTBOX_SMS_ID], NULL, vars, &res) != SQL_OK) {
SMSD_Log(DEBUG_INFO, Config, "Error reading from database (%s)", __FUNCTION__);
return ERR_UNKNOWN;
}
if (db->NextRow(Config, &res) != 1) {
db->FreeResult(Config, &res);
return ERR_EMPTY;
}
sprintf(ID, "%ld", (long)db->GetNumber(Config, &res, 0));
timestamp = db->GetDate(Config, &res, 1);
db->FreeResult(Config, &res);
if (timestamp == -1) {
SMSD_Log(DEBUG_INFO, Config, "Invalid date for InsertIntoDB.");
return ERR_UNKNOWN;
}
SMSDSQL_Time2String(Config, timestamp, Config->DT, sizeof(Config->DT));
if (SMSDSQL_RefreshSendStatus(Config, ID) == ERR_NONE) {
break;
}
}
sms->Number = 0;
for (i = 0; i < GSM_MAX_MULTI_SMS; i++) {
GSM_SetDefaultSMSData(&sms->SMS[i]);
sms->SMS[i].SMSC.Number[0] = 0;
sms->SMS[i].SMSC.Number[1] = 0;
}
for (i = 1; i < GSM_MAX_MULTI_SMS + 1; i++) {
vars[0].type = SQL_TYPE_STRING;
vars[0].v.s = ID;
vars[1].type = SQL_TYPE_INT;
vars[1].v.i = i;
vars[2].type = SQL_TYPE_NONE;
if (i == 1) {
q = Config->SMSDSQL_queries[SQL_QUERY_FIND_OUTBOX_BODY];
} else {
q = Config->SMSDSQL_queries[SQL_QUERY_FIND_OUTBOX_MULTIPART];
}
if (SMSDSQL_NamedQuery(Config, q, NULL, vars, &res) != SQL_OK) {
SMSD_Log(DEBUG_ERROR, Config, "Error reading from database (%s)", __FUNCTION__);
return ERR_UNKNOWN;
}
if (db->NextRow(Config, &res) != 1) {
db->FreeResult(Config, &res);
return ERR_NONE;
}
coding = db->GetString(Config, &res, 1);
text = db->GetString(Config, &res, 0);
if (text == NULL) {
text_len = 0;
} else {
text_len = strlen(text);
}
text_decoded = db->GetString(Config, &res, 4);
udh = db->GetString(Config, &res, 2);
if (udh == NULL) {
udh_len = 0;
} else {
udh_len = strlen(udh);
}
sms->SMS[sms->Number].Coding = GSM_StringToSMSCoding(coding);
if (sms->SMS[sms->Number].Coding == 0) {
if (text == NULL || text_len == 0) {
SMSD_Log(DEBUG_NOTICE, Config, "Assuming default coding for text message");
sms->SMS[sms->Number].Coding = SMS_Coding_Default_No_Compression;
} else {
SMSD_Log(DEBUG_NOTICE, Config, "Assuming 8bit coding for binary message");
sms->SMS[sms->Number].Coding = SMS_Coding_8bit;
}
}
if (text == NULL || text_len == 0) {
if (text_decoded == NULL) {
SMSD_Log(DEBUG_ERROR, Config, "Message without text!");
return ERR_UNKNOWN;
} else {
SMSD_Log(DEBUG_NOTICE, Config, "Message: %s", text_decoded);
DecodeUTF8(sms->SMS[sms->Number].Text, text_decoded, strlen(text_decoded));
}
} else {
switch (sms->SMS[sms->Number].Coding) {
case SMS_Coding_Unicode_No_Compression:
case SMS_Coding_Default_No_Compression:
DecodeHexUnicode(sms->SMS[sms->Number].Text, text, text_len);
break;
case SMS_Coding_8bit:
DecodeHexBin(sms->SMS[sms->Number].Text, text, text_len);
sms->SMS[sms->Number].Length = text_len / 2;
break;
default:
break;
}
}
if (i == 1) {
destination = db->GetString(Config, &res, 6);
if (destination == NULL) {
SMSD_Log(DEBUG_ERROR, Config, "Message without recipient!");
return ERR_UNKNOWN;
}
DecodeUTF8(sms->SMS[sms->Number].Number, destination, strlen(destination));
} else {
CopyUnicodeString(sms->SMS[sms->Number].Number, sms->SMS[0].Number);
}
sms->SMS[sms->Number].UDH.Type = UDH_NoUDH;
if (udh != NULL && udh_len != 0) {
sms->SMS[sms->Number].UDH.Type = UDH_UserUDH;
sms->SMS[sms->Number].UDH.Length = udh_len / 2;
DecodeHexBin(sms->SMS[sms->Number].UDH.Text, udh, udh_len);
}
sms->SMS[sms->Number].Class = db->GetNumber(Config, &res, 3);
sms->SMS[sms->Number].PDU = SMS_Submit;
sms->Number++;
if (i == 1) {
strcpy(Config->CreatorID, db->GetString(Config, &res, 10));
Config->relativevalidity = db->GetNumber(Config, &res, 8);
Config->currdeliveryreport = db->GetBool(Config, &res, 9);
/* Is this a multipart message? */
if (!db->GetBool(Config, &res, 7)) {
db->FreeResult(Config, &res);
break;
}
}
db->FreeResult(Config, &res);
}
return ERR_NONE;
}
static void cgi_process_each(GSM_StateMachine *s, GSM_SMSMessage*sms) {
int child_in[2];
int child_out[2];
int pid;
int ret;
int offset;
int status;
child_in[0] = child_in[1] = child_out[0] = child_out[1] = -1; /* invalid fd */
DecodeUnicode(sms->Text, buffer);
smprintf(s, CGI_ENGINE "<< [%s]\n", buffer);
/* ----------------------------------------------------- now open the pipes */
if (pipe(child_in)) {
smprintf(s, CGI_ENGINE "Unable to open to pipe: %s\n", strerror(errno));
goto error;
}
if (pipe(child_out)) {
smprintf(s, CGI_ENGINE "Unable to open from pipe: %s\n", strerror(errno));
goto error;
}
/* ------------------------- Block SIGHUP during the fork - prevents a race */
//sigfillset(&signal_set);
//pthread_sigmask(SIG_BLOCK, &signal_set, &old_set);
//signal(SIGCHLD, cgi_child_end);
/* ----------------------------------------------------------- fork the cgi */
pid = fork();
if(pid < 0) {
smprintf(s, CGI_ENGINE "Could not fork: %s\n", strerror(errno));
// pthread_sigmask(SIG_SETMASK, &old_set, NULL);
goto error;
}
if(!pid) {
/* -------------------------------------------------- child process */
/* ------------------------------------ move stdout to child_out[1] */
close(STDOUT_FILENO);
dup2(child_out[1], STDOUT_FILENO);
close(child_out[1]);
close(child_out[0]); /* close unused read end */
/* -------------------------------------- move stdin to child_in[0] */
close(STDIN_FILENO);
dup2(child_in[0], STDIN_FILENO);
close(child_in[0]);
close(child_in[1]); /* close unused write end */
cgi_child(s);
}
/* --------------------------------------------------------- parent process */
close(child_out[1]); /* close unused write end */
close(child_in[0]); /* close unused read end */
smprintf(s, CGI_ENGINE "Launched CGI script\n");
/* ----------------------------------------------------------- send headers */
DecodeUnicode(sms->Number, buffer2);
cgi_write_header(s, child_in[1], "SMS_FROM", buffer2);
DecodeUnicode(sms->Name, buffer2);
cgi_write_header(s, child_in[1], "SMS_NAME", buffer2);
cgi_write_header(s, child_in[1], "SMS_TIME", OSDate(sms->DateTime));
/* -------------------------------------------- End headers with empty line */
cgi_write_helper(s, child_in[1], "\r\n", sizeof("\r\n") - 1);
/* ----------------------------------------------- now we write the command */
cgi_write_helper(s, child_in[1], buffer, strlen(buffer));
close(child_in[1]); /* send EOF */
/* ------------------------------------------------------------ now we read */
smprintf(s, CGI_ENGINE ">>======== CGI Response ==========\n");
buffer[0] = '\0';
offset = 0;
while((ret = read(child_out[0], buffer + offset, 1)) > 0) {
offset += ret;
*(buffer+offset) = '\0';
}
smprintf(s, CGI_ENGINE "%s", buffer);
smprintf(s, "\n>>================================\n");
do {
/* ------------------------------------------------- wait for child to exit */
if((ret = waitpid(pid, &status, WNOHANG)) == -1) {
smprintf(s, CGI_ENGINE " waitpid failed :(\n");
goto error;
}
if(!ret) {
smprintf(s, CGI_ENGINE " Child is not dead yet ..\n");
}
if(!WIFEXITED(status)) {
if(WIFSIGNALED(status)) {
smprintf(s, CGI_ENGINE "killed by signal %d\n", WTERMSIG(status));
} else if (WIFSTOPPED(status)) {
smprintf(s, CGI_ENGINE "stopped by signal %d\n", WSTOPSIG(status));
} else if (WIFCONTINUED(status)) {
smprintf(s, CGI_ENGINE "continued\n");
}
}
} while(!WIFEXITED(status) && !WIFSIGNALED(status));
smprintf(s, CGI_ENGINE " Child process exited\n");
if(buffer[0] != '\0') {
/* ----------------------------------------------- prepare response */
memset(&smsSendBuffer, 0, sizeof(smsSendBuffer)); /* reset memory */
GSM_SetDefaultSMSData(&smsSendBuffer);
smsSendBuffer.Location = 1;
smsSendBuffer.Class = 1;
smsSendBuffer.PDU = SMS_Submit;
smsSendBuffer.Coding = SMS_Coding_Default_No_Compression;
CopyUnicodeString(smsSendBuffer.Number, sms->Number);
EncodeUnicode(smsSendBuffer.Text, buffer, strlen(buffer));
/* -------------------------------------------------- send response */
error = GSM_SendSMS(s, &smsSendBuffer);
}
error:
close(child_in[0]);
close(child_in[1]);
close(child_out[0]);
close(child_out[1]);
GSM_DeleteSMS(s, sms);
return;
}
