all: updated FSF address in GPL text
[sip-router] / modules / cpl-c / cpl_nonsig.c
1 /*
2  * $Id$
3  *
4  * Copyright (C) 2001-2003 FhG Fokus
5  *
6  * This file is part of Kamailio, a free SIP server.
7  *
8  * Kamailio is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version
12  *
13  * Kamailio is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License 
19  * along with this program; if not, write to the Free Software 
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
21  *
22  * History:
23  * -------
24  * 2003-06-27: file created (bogdan)
25  */
26
27 #include <unistd.h>
28 #include <errno.h>
29 #include <string.h>
30 #include <sys/types.h>
31 #include <sys/stat.h>
32 #include <fcntl.h>
33 #include <time.h>
34 #include <sys/uio.h>
35 #include <signal.h>
36
37 #include "../../mem/shm_mem.h"
38 #include "../../mem/mem.h"
39 #include "../../dprint.h"
40 #include "cpl_nonsig.h"
41 #include "CPL_tree.h"
42
43
44 #define MAX_LOG_FILE_NAME      32
45
46 #define FILE_NAME_SUFIX        ".log"
47 #define FILE_NAME_SUFIX_LEN    (sizeof(FILE_NAME_SUFIX)-1)
48
49 #define LOG_SEPARATOR          ": "
50 #define LOG_SEPARATOR_LEN      (sizeof(LOG_SEPARATOR)-1)
51
52 #define DEFAULT_LOG_NAME       "default_log"
53 #define DEFAULT_LOG_NAME_LEN   (sizeof(DEFAULT_LOG_NAME)-1)
54
55 #define LOG_TERMINATOR          "\n"
56 #define LOG_TERMINATOR_LEN      (sizeof(LOG_TERMINATOR)-1)
57
58
59 static char file[MAX_LOG_DIR_SIZE+1+MAX_LOG_FILE_NAME+FILE_NAME_SUFIX_LEN+1];
60 static char *file_ptr;
61
62
63 static inline void write_log( struct cpl_cmd *cmd)
64 {
65         struct iovec  wr_vec[5];
66         time_t now;
67         char *time_ptr;
68         int fd;
69         int ret;
70
71         /* build file name (cmd->s1 is the user name)*/
72         if (cmd->s1.len>MAX_LOG_FILE_NAME)
73                 cmd->s1.len = MAX_LOG_FILE_NAME;
74         memcpy(file_ptr, cmd->s1.s, cmd->s1.len );
75         memcpy(file_ptr+cmd->s1.len,FILE_NAME_SUFIX,FILE_NAME_SUFIX_LEN);
76         file_ptr[cmd->s1.len+FILE_NAME_SUFIX_LEN] = 0;
77
78         /* get current date+time -> wr_vec[0] */
79         time( &now );
80         time_ptr = ctime( &now );
81         wr_vec[0].iov_base = time_ptr;
82         wr_vec[0].iov_len = strlen( time_ptr );
83         /* ctime_r adds a \n at the end -> overwrite it with space */
84         time_ptr[ wr_vec[0].iov_len-1 ] = ' ';
85
86         /* log name (cmd->s2) ->  wr_vec[1] */
87         if (cmd->s2.s==0 || cmd->s2.len==0) {
88                 wr_vec[1].iov_base = DEFAULT_LOG_NAME;
89                 wr_vec[1].iov_len = DEFAULT_LOG_NAME_LEN;
90         } else {
91                 wr_vec[1].iov_base = cmd->s2.s;
92                 wr_vec[1].iov_len = cmd->s2.len;
93         }
94
95         /* log separator ->  wr_vec[2] */
96         wr_vec[2].iov_base = LOG_SEPARATOR;
97         wr_vec[2].iov_len = LOG_SEPARATOR_LEN;
98
99         /* log comment (cmd->s3) ->  wr_vec[3] */
100         wr_vec[3].iov_base = cmd->s3.s;
101         wr_vec[3].iov_len = cmd->s3.len;
102
103         /* log terminator ->  wr_vec[2] */
104         wr_vec[4].iov_base = LOG_TERMINATOR;
105         wr_vec[4].iov_len = LOG_TERMINATOR_LEN;
106
107         /* [create+]open the file */
108         fd = open( file, O_CREAT|O_APPEND|O_WRONLY, 0664);
109         if (fd==-1) {
110                 LM_ERR("cannot open file [%s] : %s\n",
111                         file, strerror(errno) );
112                 return;
113         }
114         /* get the log */
115         LM_DBG("logging into [%s]... \n",file);
116         /* I'm really not interested in the return code for write ;-) */
117         while ( (ret=writev( fd, wr_vec, 5))==-1 ) {
118                 if (errno==EINTR)
119                         continue;
120                 LM_ERR("writing to log file [%s] : %s\n",
121                         file, strerror(errno) );
122         }
123         close (fd);
124
125         shm_free( cmd->s1.s );
126 }
127
128
129
130 static inline void send_mail( struct cpl_cmd *cmd)
131 {
132         char *argv[5];
133         int pfd[2];
134         pid_t  pid;
135         int i;
136
137         if (pipe(pfd) < 0) {
138                 LM_ERR("pipe failed: %s\n",strerror(errno));
139                 return;
140         }
141
142         /* even if I haven't fork yet, I push the date on the pipe just to get
143          * rid of one more malloc + copy */
144         if (cmd->s3.len && cmd->s3.s) {
145                 if ( (i=write( pfd[1], cmd->s3.s, cmd->s3.len ))!=cmd->s3.len ) {
146                         LM_ERR("write returned error %s\n",
147                                 strerror(errno));
148                         goto error;
149                 }
150         }
151
152         if ( (pid = fork()) < 0) {
153                 LM_ERR("fork failed: %s\n",strerror(errno));
154                 goto error;
155         } else if (pid==0) {
156                 /* child -> close all descriptors excepting pfd[0] */
157                 /* 32 is the maximum number of inherited open file descriptors */
158                 for (i=3; i < 32; i++)
159                         if (i!=pfd[0])
160                                 close(i);
161                 if (pfd[0] != STDIN_FILENO) {
162                         dup2(pfd[0], STDIN_FILENO);
163                         close(pfd[0]);
164                 }
165
166                 /* set the argument vector*/
167                 argv[0] = "mail";
168                 argv[1] = "-s";
169                 if (cmd->s2.s && cmd->s2.len) {
170                         /* put the subject in this format : <"$subject"\0> */
171                         if ( (argv[2]=(char*)pkg_malloc(1+cmd->s2.len+1+1))==0) {
172                                 LM_ERR("cannot get pkg memory\n");
173                                 goto child_exit;
174                         }
175                         argv[2][0] = '\"';
176                         memcpy(argv[2]+1,cmd->s2.s,cmd->s2.len);
177                         argv[2][cmd->s2.len+1] = '\"';
178                         argv[2][cmd->s2.len+2] = 0;
179                 } else {
180                         argv[2] = "\"[CPL notification]\"";
181                 }
182                 /* put the TO in <$to\0> format*/
183                 if ( (argv[3]=(char*)pkg_malloc(cmd->s1.len+1))==0) {
184                         LM_ERR("cannot get pkg memory\n");
185                         goto child_exit;
186                 }
187                 memcpy(argv[3],cmd->s1.s,cmd->s1.len);
188                 argv[3][cmd->s1.len] = 0;
189                 /* last element in vector mist be a null pointer */
190                 argv[4] = (char*)0;
191                 /* just debug */
192                 for(i=0;i<sizeof(argv)/sizeof(char*);i++)
193                         LM_DBG("argv[%d] = %s\n",i,argv[i]);
194                 /* once I copy localy all the data from shm mem -> free the shm */
195                 shm_free( cmd->s1.s );
196
197                 /* set an alarm -> sending the email shouldn't take more than 10 sec */
198                 alarm(10);
199                 /* run the external mailer */
200                 LM_DBG("new forked process created -> "
201                         "doing execv..\n");
202                 execv("/usr/bin/mail",argv);
203                 /* if we got here means execv exit with error :-( */
204                 LM_ERR("execv failed! (%s)\n",strerror(errno));
205 child_exit:
206                 _exit(127);
207         }
208
209         /* parent -> close both ends of pipe */
210         close(pfd[0]);
211         close(pfd[1]);
212         return;
213 error:
214         shm_free( cmd->s1.s );
215         close(pfd[0]);
216         close(pfd[1]);
217         return;
218 }
219
220
221
222
223 void cpl_aux_process( int cmd_out, char *log_dir)
224 {
225         struct cpl_cmd cmd;
226         int len;
227
228         /* this process will ignore SIGCHLD signal */
229         if (signal( SIGCHLD, SIG_IGN)==SIG_ERR) {
230                 LM_ERR("cannot set to IGNORE SIGCHLD signal\n");
231         }
232
233         /* set the path for logging */
234         if (log_dir) {
235                 strcpy( file, log_dir);
236                 file_ptr = file + strlen(log_dir);
237                 *(file_ptr++) = '/';
238         }
239
240         while(1) {
241                 /* let's read a command from pipe */
242                 len = read( cmd_out, &cmd, sizeof(struct cpl_cmd));
243                 if (len!=sizeof(struct cpl_cmd)) {
244                         if (len>=0) {
245                                 LM_ERR("truncated message"
246                                         " read from pipe! -> discarded\n");
247                         } else if (errno!=EAGAIN) {
248                                 LM_ERR("pipe reading failed: "
249                                         " : %s\n",strerror(errno));
250                         }
251                         sleep(1);
252                         continue;
253                 }
254
255                 /* process the command*/
256                 switch (cmd.code) {
257                         case CPL_LOG_CMD:
258                                 write_log( &cmd );
259                                 break;
260                         case CPL_MAIL_CMD:
261                                 send_mail( &cmd );
262                                 break;
263                         default:
264                                 LM_ERR("unknown command (%d) "
265                                         "received! -> ignoring\n",cmd.code);
266                 } /* end switch*/
267
268         }
269 }
270