/* Add an email to the list -- always to the beginning */
void OS_AddMailtoList(MailMsg *ml)
{
MailNode *tmp_node = n_node;
if (tmp_node) {
MailNode *new_node;
new_node = (MailNode *)calloc(1, sizeof(MailNode));
if (new_node == NULL) {
ErrorExit(MEM_ERROR, ARGV0, errno, strerror(errno));
}
/* Always add to the beginning of the list
* The new node will become the first node and
* new_node->next will be the previous first node
*/
new_node->next = tmp_node;
new_node->prev = NULL;
tmp_node->prev = new_node;
n_node = new_node;
/* Add the event to the node */
new_node->mail = ml;
_memoryused++;
/* Need to remove the last node */
if (_memoryused > _memorymaxsize) {
MailNode *oldlast;
oldlast = lastnode;
lastnode = lastnode->prev;
/* Free last node */
FreeMail(oldlast);
_memoryused--;
}
}
else {
/* Add first node */
n_node = (MailNode *)calloc(1, sizeof(MailNode));
if (n_node == NULL) {
ErrorExit(MEM_ERROR, ARGV0, errno, strerror(errno));
}
n_node->prev = NULL;
n_node->next = NULL;
n_node->mail = ml;
lastnode = n_node;
}
return;
}
/* OS_Run: Read the queue and send the appropriate alerts.
* not supposed to return..
*/
static void OS_Run(MailConfig *mail)
{
MailMsg *msg;
MailMsg *s_msg = NULL;
MailMsg *msg_sms = NULL;
time_t tm;
struct tm *p;
int i = 0;
int mailtosend = 0;
int childcount = 0;
int thishour = 0;
int n_errs = 0;
file_queue *fileq;
/* Getting currently time before starting */
tm = time(NULL);
p = localtime(&tm);
thishour = p->tm_hour;
/* Init file queue */
i = 0;
i |= CRALERT_MAIL_SET;
os_calloc(1, sizeof(file_queue), fileq);
Init_FileQueue(fileq, p, i);
/* Creating the list */
OS_CreateMailList(MAIL_LIST_SIZE);
/* Setting default timeout */
mail_timeout = DEFAULT_TIMEOUT;
/* Clearing global vars */
_g_subject_level = 0;
memset(_g_subject, '\0', SUBJECT_SIZE +2);
while(1)
{
tm = time(NULL);
p = localtime(&tm);
/* SMS messages are sent without delay */
if(msg_sms)
{
pid_t pid;
pid = fork();
if(pid < 0)
{
merror("%s: Fork failed. cause: %d - %s", ARGV0, errno, strerror(errno));
merror(FORK_ERROR, ARGV0);
sleep(30);
continue;
}
else if (pid == 0)
{
if(OS_Sendsms(mail, p, msg_sms) < 0)
merror(SNDMAIL_ERROR, ARGV0, mail->smtpserver);
exit(0);
}
/* Freeing sms structure */
FreeMailMsg(msg_sms);
msg_sms = NULL;
/* Increasing child count */
childcount++;
}
/* If mail_timeout == NEXTMAIL_TIMEOUT, we will try to get
* more messages, before sending anything
*/
if((mail_timeout == NEXTMAIL_TIMEOUT) && (p->tm_hour == thishour))
{
/* getting more messages */
}
/* Hour changed. Send all supressed mails */
else if(((mailtosend < mail->maxperhour) && (mailtosend != 0))||
((p->tm_hour != thishour) && (childcount < MAXCHILDPROCESS)))
{
MailNode *mailmsg;
pid_t pid;
/* Checking if we have anything to sent */
mailmsg = OS_CheckLastMail();
if(mailmsg == NULL)
{
/* dont fork in here */
goto snd_check_hour;
}
pid = fork();
if(pid < 0)
{
merror("%s: Fork failed. cause: %d - %s", ARGV0, errno, strerror(errno));
merror(FORK_ERROR, ARGV0);
sleep(30);
continue;
}
else if (pid == 0)
{
if(OS_Sendmail(mail, p) < 0)
merror(SNDMAIL_ERROR,ARGV0,mail->smtpserver);
exit(0);
}
/* Cleaning the memory */
mailmsg = OS_PopLastMail();
do
{
FreeMail(mailmsg);
mailmsg = OS_PopLastMail();
}while(mailmsg);
/* Increasing child count */
childcount++;
/* Clearing global vars */
_g_subject[0] = '\0';
_g_subject[SUBJECT_SIZE -1] = '\0';
_g_subject_level = 0;
/* Cleaning up set values */
if(mail->gran_to)
{
i = 0;
while(mail->gran_to[i] != NULL)
{
if(s_msg && mail->gran_set[i] == DONOTGROUP)
{
mail->gran_set[i] = FULL_FORMAT;
}
else
{
mail->gran_set[i] = 0;
}
i++;
}
}
snd_check_hour:
/* If we sent everything */
if(p->tm_hour != thishour)
{
thishour = p->tm_hour;
mailtosend = 0;
}
}
/* Saved message for the do_not_group option.
*/
if(s_msg)
{
/* We need to set the remaining do no group to
* full format.
*/
if(mail->gran_to)
{
i = 0;
while(mail->gran_to[i] != NULL)
{
if(mail->gran_set[i] == DONOTGROUP)
{
mail->gran_set[i] = FULL_FORMAT;
}
i++;
}
}
OS_AddMailtoList(s_msg);
s_msg = NULL;
mailtosend++;
continue;
}
/* Receive message from queue */
if((msg = OS_RecvMailQ(fileq, p, mail, &msg_sms)) != NULL)
{
/* If the e-mail priority is do_not_group, we first will
* flush all previous entries and then send it.
* We use s_msg to hold the pointer to the message
* while we flush it.
*/
if(mail->priority == DONOTGROUP)
{
s_msg = msg;
}
else
{
OS_AddMailtoList(msg);
}
/* Change timeout to see if any new message is coming shortly */
if(mail->groupping)
{
/* If priority is set, send email now */
if(mail->priority)
{
mail_timeout = DEFAULT_TIMEOUT;
/* If do_not_group is set, we do not increase the
* list count in here.
*/
if(mail->priority != DONOTGROUP)
{
mailtosend++;
}
}
else
{
/* 5 seconds only */
mail_timeout = NEXTMAIL_TIMEOUT;
}
}
else
{
/* Send message by itself */
mailtosend++;
}
}
else
{
if(mail_timeout == NEXTMAIL_TIMEOUT)
{
mailtosend++;
/* Default timeout */
mail_timeout = DEFAULT_TIMEOUT;
}
}
/* Waiting for the childs .. */
while (childcount)
{
int wp;
int p_status;
wp = waitpid((pid_t) -1, &p_status, WNOHANG);
if (wp < 0)
{
merror(WAITPID_ERROR, ARGV0);
n_errs++;
}
/* if = 0, we still need to wait for the child process */
else if (wp == 0)
break;
else
{
if(p_status != 0)
{
merror(CHLDWAIT_ERROR,ARGV0,p_status);
merror(SNDMAIL_ERROR,ARGV0,mail->smtpserver);
n_errs++;
}
childcount--;
}
/* Too many errors */
if(n_errs > 6)
{
merror(TOOMANY_WAIT_ERROR,ARGV0);
merror(SNDMAIL_ERROR,ARGV0,mail->smtpserver);
exit(1);
}
}
}
}
