time_t Fill_Time_T(GSM_DateTime DT)
{
struct tm timestruct;
struct tm *now;
time_t t;
dbgprintf(NULL, "StartTime: %s\n", OSDate(DT));
memset(×truct, 0, sizeof(timestruct));
timestruct.tm_year = DT.Year - 1900;
timestruct.tm_mon = DT.Month - 1;
timestruct.tm_mday = DT.Day;
timestruct.tm_hour = DT.Hour;
timestruct.tm_min = DT.Minute;
timestruct.tm_sec = DT.Second;
time(&t);
now = localtime(&t);
#ifdef HAVE_DAYLIGHT
timestruct.tm_isdst = now->tm_isdst;
#else
timestruct.tm_isdst = -1;
#endif
#ifdef HAVE_STRUCT_TM_TM_ZONE
/* No time zone information */
timestruct.tm_gmtoff = now->tm_gmtoff;
timestruct.tm_zone = now->tm_zone;
#endif
return mktime(×truct);
}
time_t Fill_Time_T(GSM_DateTime DT)
{
struct tm tm_starttime;
dbgprintf(NULL, "StartTime: %s\n", OSDate(DT));
memset(&tm_starttime, 0, sizeof(tm_starttime));
tm_starttime.tm_year = DT.Year - 1900;
tm_starttime.tm_mon = DT.Month - 1;
tm_starttime.tm_mday = DT.Day;
tm_starttime.tm_hour = DT.Hour;
tm_starttime.tm_min = DT.Minute;
tm_starttime.tm_sec = DT.Second;
tm_starttime.tm_isdst = -1;
return mktime(&tm_starttime);
}
GSM_Error GSM_ReadFile(const char *FileName, GSM_File *File)
{
int i = 1000;
FILE *file;
struct stat fileinfo;
if (FileName[0] == 0x00) return ERR_UNKNOWN;
file = fopen(FileName,"rb");
if (file == NULL) return ERR_CANTOPENFILE;
free(File->Buffer);
File->Buffer = NULL;
File->Used = 0;
while (i == 1000) {
File->Buffer = (unsigned char *)realloc(File->Buffer,File->Used + 1000);
i = fread(File->Buffer+File->Used,1,1000,file);
File->Used = File->Used + i;
}
File->Buffer = (unsigned char *)realloc(File->Buffer,File->Used + 1);
/* Make it 0 terminated, in case it is needed somewhere (we don't count this to length) */
File->Buffer[File->Used] = 0;
fclose(file);
File->Level = 0;
GSM_IdentifyFileFormat(File);
File->Protected = FALSE;
File->Hidden = FALSE;
File->System = FALSE;
File->ReadOnly = FALSE; /* @todo TODO get this from permissions? */
File->Folder = FALSE;
File->ModifiedEmpty = TRUE;
if (stat(FileName,&fileinfo) == 0) {
File->ModifiedEmpty = FALSE;
dbgprintf(NULL, "File info read correctly\n");
/* st_mtime is time of last modification of file */
Fill_GSM_DateTime(&File->Modified, fileinfo.st_mtime);
dbgprintf(NULL, "FillTime: %s\n", OSDate(File->Modified));
}
return ERR_NONE;
}
gboolean ReadVCALDate(char *Buffer, const char *Start, GSM_DateTime *Date, gboolean *is_date_only)
{
char fullstart[200];
unsigned char datestring[200];
if (!ReadVCALText(Buffer, Start, datestring, FALSE, NULL)) {
fullstart[0] = 0;
strcat(fullstart, Start);
strcat(fullstart, ";VALUE=DATE");
if (!ReadVCALText(Buffer, fullstart, datestring, FALSE, NULL)) {
return FALSE;
}
*is_date_only = TRUE;
}
if (ReadVCALDateTime(DecodeUnicodeString(datestring), Date)) {
dbgprintf(NULL, "ReadVCALDateTime is %s\n", OSDate(*Date));
*is_date_only = FALSE;
return TRUE;
}
return FALSE;
}
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;
}
