* move policy.c into modules/expire/expire_policy.c, since it just controls this.
[citadel.git] / citadel / modules / extnotify / extnotify_main.c
1 /*
2  * extnotify_main.c
3  * Mathew McBride
4  *
5  * This module implements an external pager hook for when notifcation
6  * of a new email is wanted.
7  *
8  * Based on bits of serv_funambol
9  * Contact: <matt@mcbridematt.dhs.org> / <matt@comalies>
10  *
11  * Copyright (c) 2008-2009
12  *
13  *  This program is free software; you can redistribute it and/or modify
14  *  it under the terms of the GNU General Public License as published by
15  *  the Free Software Foundation; either version 3 of the License, or
16  *  (at your option) any later version.
17  *
18  *  This program is distributed in the hope that it will be useful,
19  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
20  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  *  GNU General Public License for more details.
22  *
23  *  You should have received a copy of the GNU General Public License
24  *  along with this program; if not, write to the Free Software
25  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26  */
27
28 #include "sysdep.h"
29 #include <stdlib.h>
30 #include <unistd.h>
31 #include <stdio.h>
32 #include <fcntl.h>
33 #include <signal.h>
34 #include <pwd.h>
35 #include <errno.h>
36 #include <sys/types.h>
37
38 #if TIME_WITH_SYS_TIME
39 # include <sys/time.h>
40 # include <time.h>
41 #else
42 # if HAVE_SYS_TIME_H
43 #  include <sys/time.h>
44 # else
45 #  include <time.h>
46 # endif
47 #endif
48
49 #include <sys/wait.h>
50 #include <string.h>
51 #include <limits.h>
52 #include <sys/socket.h>
53 #include <libcitadel.h>
54 #include "citadel.h"
55 #include "server.h"
56 #include "citserver.h"
57 #include "support.h"
58 #include "config.h"
59 #include "control.h"
60 #include "user_ops.h"
61 #include "database.h"
62 #include "msgbase.h"
63 #include "internet_addressing.h"
64 #include "domain.h"
65 #include "clientsocket.h"
66 #include "extnotify.h"
67
68 #include "ctdl_module.h"
69
70
71
72 void ExtNotify_PutErrorMessage(NotifyContext *Ctx, StrBuf *ErrMsg)
73 {
74         int nNext;
75         if (Ctx->NotifyErrors == NULL)
76                 Ctx->NotifyErrors = NewHash(1, Flathash);
77
78         nNext = GetCount(Ctx->NotifyErrors) + 1;
79         Put(Ctx->NotifyErrors, 
80             (char*)&nNext, 
81             sizeof(int), 
82             ErrMsg, 
83             HFreeStrBuf);
84 }
85
86
87
88
89 StrBuf* GetNHBuf(int i, int allocit, StrBuf **NotifyHostList)
90 {
91         if ((NotifyHostList[i] == NULL) && (allocit != 0))
92                 NotifyHostList[i] = NewStrBuf();
93         return NotifyHostList[i];
94 }
95
96
97 StrBuf** GetNotifyHosts(void)
98 {
99         char NotifyHostsBuf[SIZ];
100         StrBuf *Host;
101         StrBuf *File;
102         StrBuf *NotifyBuf;
103         int notify;
104         const char *pchs, *pche;
105         const char *NextHost = NULL;
106         StrBuf **NotifyHostList;
107         int num_notify;
108
109         /* See if we have any Notification Hosts configured */
110         num_notify = get_hosts(NotifyHostsBuf, "notify");
111         if (num_notify < 1)
112                 return(NULL);
113
114         NotifyHostList = malloc(sizeof(StrBuf*) * 2 * (num_notify + 1));
115         memset(NotifyHostList, 0, sizeof(StrBuf*) * 2 * (num_notify + 1));
116         
117         NotifyBuf = NewStrBufPlain(NotifyHostsBuf, -1);
118         /* get all configured notifiers's */
119         for (notify=0; notify<num_notify; notify++) {
120                 
121                 Host = GetNHBuf(notify * 2, 1, NotifyHostList);
122                 StrBufExtract_NextToken(Host, NotifyBuf, &NextHost, '|');
123                 pchs = ChrPtr(Host);
124                 pche = strchr(pchs, ':');
125                 if (pche == NULL) {
126                         CtdlLogPrintf(CTDL_ERR, 
127                                       __FILE__": filename not found in %s.\n", 
128                                       pchs);
129                         continue;
130                 }
131                 File = GetNHBuf(notify * 2 + 1, 1, NotifyHostList);
132                 StrBufPlain(File, pchs, pche - pchs);
133                 StrBufCutLeft(Host, pche - pchs + 1);
134         }
135         return NotifyHostList;
136 }
137
138
139 /*! \brief Create the notify message queue. We use the exact same room
140  *                      as the Funambol module.
141  *
142  *      Run at server startup, creates FNBL_QUEUE_ROOM if it doesn't exist
143  *      and sets as system room.
144  */
145 void create_extnotify_queue(void) {
146         struct ctdlroom qrbuf;
147     
148         CtdlCreateRoom(FNBL_QUEUE_ROOM, 3, "", 0, 1, 0, VIEW_MAILBOX);
149     
150         /*
151          * Make sure it's set to be a "system room" so it doesn't show up
152          * in the <K>nown rooms list for Aides.
153          */
154         if (CtdlGetRoomLock(&qrbuf, FNBL_QUEUE_ROOM) == 0) {
155                 qrbuf.QRflags2 |= QR2_SYSTEM;
156                 CtdlPutRoomLock(&qrbuf);
157         }
158 }
159 /*!
160  * \brief Run through the pager room queue
161  */
162 void do_extnotify_queue(void) 
163 {
164         NotifyContext Ctx;
165         static int doing_queue = 0;
166         int i = 0;
167     
168         /*
169          * This is a simple concurrency check to make sure only one queue run
170          * is done at a time.  We could do this with a mutex, but since we
171          * don't really require extremely fine granularity here, we'll do it
172          * with a static variable instead.
173          */
174         if (doing_queue) return;
175         doing_queue = 1;
176     
177         /*
178          * Go ahead and run the queue
179          */
180         CtdlLogPrintf(CTDL_DEBUG, "serv_extnotify: processing notify queue\n");
181     
182         memset(&Ctx, 0, sizeof(NotifyContext));
183         Ctx.NotifyHostList = GetNotifyHosts();
184         if (CtdlGetRoom(&CC->room, FNBL_QUEUE_ROOM) != 0) {
185                 CtdlLogPrintf(CTDL_ERR, "Cannot find room <%s>\n", FNBL_QUEUE_ROOM);
186                 return;
187         }
188         CtdlForEachMessage(MSGS_ALL, 0L, NULL,
189                            SPOOLMIME, NULL, process_notify, &Ctx);
190
191         while ((Ctx.NotifyHostList != NULL) && (Ctx.NotifyHostList[i] != NULL))
192                 FreeStrBuf(&Ctx.NotifyHostList[i]);
193
194         if (Ctx.NotifyErrors != NULL)
195         {
196                 long len;
197                 const char *Key;
198                 HashPos *It;
199                 void *vErr;
200                 StrBuf *ErrMsg;
201
202                 It = GetNewHashPos(Ctx.NotifyErrors, 0);
203                 while (GetNextHashPos(Ctx.NotifyErrors, It, &len, &Key, &vErr) && 
204                        (vErr != NULL)) {
205                         ErrMsg = (StrBuf*) vErr;
206                         quickie_message("Citadel", NULL, NULL, AIDEROOM, ChrPtr(ErrMsg), FMT_FIXED, 
207                                         "Failed to notify external service about inbound mail");
208                 }
209
210                 DeleteHashPos(&It);
211                 DeleteHash(&Ctx.NotifyErrors);
212         }
213
214         CtdlLogPrintf(CTDL_DEBUG, "serv_extnotify: queue run completed\n");
215         doing_queue = 0;
216 }
217 /*!
218  * \brief Process messages in the external notification queue
219  */
220 void process_notify(long NotifyMsgnum, void *usrdata) 
221 {
222         NotifyContext *Ctx;
223         long msgnum = 0;
224         long todelete[1];
225         int fnblAllowed;
226         int extPagerAllowedHttp;
227         int extPagerAllowedSystem;
228         char *pch;
229         long configMsgNum;
230         char configMsg[SIZ];
231         struct CtdlMessage *msg;
232
233         Ctx = (NotifyContext*) usrdata;
234
235         msg = CtdlFetchMessage(NotifyMsgnum, 1);
236         if ( msg->cm_fields['W'] == NULL) {
237                 goto nuke;
238         }
239     
240         configMsgNum = extNotify_getConfigMessage(msg->cm_fields['W']);
241     
242         extNotify_getPrefs(configMsgNum, &configMsg[0]);
243         
244         /* Check to see if:
245          * 1. The user has configured paging / They have and disabled it
246          * AND 2. There is an external pager program
247          * 3. A Funambol server has been entered
248          *
249          */
250         if ((configMsgNum == -1) || 
251             ((strncasecmp(configMsg, "none", 4) == 0) &&
252              IsEmptyStr(config.c_pager_program) && 
253              IsEmptyStr(config.c_funambol_host))) {
254                 CtdlLogPrintf(CTDL_DEBUG, "No external notifiers configured on system/user");
255                 goto nuke;
256         }
257
258         // Can Funambol take the message?
259         pch = strchr(configMsg, '\n');
260         if (*pch == '\n')
261             *pch = '\0';
262         fnblAllowed = strncasecmp(configMsg, HKEY(FUNAMBOL_CONFIG_TEXT));
263         extPagerAllowedHttp = strncasecmp(configMsg, HKEY(PAGER_CONFIG_HTTP)); 
264         extPagerAllowedSystem = strncasecmp(configMsg, HKEY(PAGER_CONFIG_SYSTEM));
265         pch = strstr(msg->cm_fields['M'], "msgid|");
266         if (pch != NULL) 
267                 msgnum = atol(pch + sizeof("msgid"));
268         if (fnblAllowed == 0) {
269                 char remoteurl[SIZ];
270                 snprintf(remoteurl, SIZ, "http://%s@%s:%d/%s",
271                          config.c_funambol_auth,
272                          config.c_funambol_host,
273                          config.c_funambol_port,
274                          FUNAMBOL_WS);
275                 notify_http_server(remoteurl, 
276                                    file_funambol_msg,
277                                    strlen(file_funambol_msg),/*GNA*/
278                                    msg->cm_fields['W'], 
279                                    msg->cm_fields['I'],
280                                    msgnum, 
281                                    Ctx);
282         } else if (extPagerAllowedHttp == 0) {
283                 int i = 0;
284                 StrBuf *URL;
285                 char URLBuf[SIZ];
286                 StrBuf *File;
287                 StrBuf *FileBuf = NewStrBuf();
288                 
289                 while(1)
290                 {
291
292                         URL = GetNHBuf(i*2, 0, Ctx->NotifyHostList);
293                         if (URL==NULL) break;
294                         File = GetNHBuf(i*2 + 1, 0, Ctx->NotifyHostList);
295                         if (File==NULL) break;
296
297                         if (StrLength(File)>0)
298                                 StrBufPrintf(FileBuf, "%s/%s", 
299                                              ctdl_shared_dir, 
300                                              ChrPtr(File));
301                         else
302                                 FlushStrBuf(FileBuf);
303                         memcpy(URLBuf, ChrPtr(URL), StrLength(URL) + 1);
304
305                         notify_http_server(URLBuf, 
306                                            ChrPtr(FileBuf),
307                                            StrLength(FileBuf),
308                                            msg->cm_fields['W'], 
309                                            msg->cm_fields['I'],
310                                            msgnum, 
311                                            Ctx);
312                         i++;
313                 }
314                 FreeStrBuf(&FileBuf);
315         } 
316         else if (extPagerAllowedSystem == 0) {
317                 char *number;
318                 int commandSiz;
319                 char *command;
320
321                 number = strtok(configMsg, "textmessage\n");
322                 commandSiz = sizeof(config.c_pager_program) + strlen(number) + strlen(msg->cm_fields['W']) + 5;
323                 command = malloc(commandSiz);
324                 snprintf(command, commandSiz, "%s %s -u %s", config.c_pager_program, number, msg->cm_fields['W']);
325                 system(command);
326                 free(command);
327         }
328 nuke:
329         CtdlFreeMessage(msg);
330         memset(configMsg, 0, sizeof(configMsg));
331         todelete[0] = NotifyMsgnum;
332         CtdlDeleteMessages(FNBL_QUEUE_ROOM, todelete, 1, "");
333 }
334
335 /*! \brief Checks to see what notification option the user has set
336  *
337  */
338 void extNotify_getPrefs(long configMsgNum, char *configMsg) 
339 {
340         struct CtdlMessage *prefMsg;
341         // Do a simple string search to see if 'funambol' is selected as the
342         // type. This string would be at the very top of the message contents.
343         if (configMsgNum == -1) {
344                 CtdlLogPrintf(CTDL_ERR, "extNotify_isAllowedByPrefs was passed a non-existant config message id\n");
345                 return;
346         }
347         prefMsg = CtdlFetchMessage(configMsgNum, 1);
348         strncpy(configMsg, prefMsg->cm_fields['M'], strlen(prefMsg->cm_fields['M']));
349         CtdlFreeMessage(prefMsg);
350 }
351
352 /*! \brief Get configuration message for pager/funambol system from the
353  *                      users "My Citadel Config" room
354  */
355 long extNotify_getConfigMessage(char *username) {
356         struct ctdlroom qrbuf; // scratch for room
357         struct ctdluser user; // ctdl user instance
358         char configRoomName[ROOMNAMELEN];
359         struct CtdlMessage *msg;
360         struct cdbdata *cdbfr;
361         long *msglist = NULL;
362         int num_msgs = 0;
363         long confMsgNum = -1;
364         int a;
365
366         // Get the user
367         CtdlGetUser(&user, username);
368     
369         CtdlMailboxName(configRoomName, sizeof configRoomName, &user, USERCONFIGROOM);
370         // Fill qrbuf
371         CtdlGetRoom(&qrbuf, configRoomName);
372         /* Do something really, really stoopid here. Raid the room on ourselves,
373          * loop through the messages manually and find it. I don't want
374          * to use a CtdlForEachMessage callback here, as we would be
375          * already in one */
376         cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long));
377         if (cdbfr != NULL) {
378                 msglist = (long *) cdbfr->ptr;
379                 cdbfr->ptr = NULL;      /* CtdlForEachMessage() now owns this memory */
380                 num_msgs = cdbfr->len / sizeof(long);
381                 cdb_free(cdbfr);
382         } else {
383                 CtdlLogPrintf(CTDL_DEBUG, "extNotify_getConfigMessage: No config messages found\n");
384                 return -1;      /* No messages at all?  No further action. */
385         }
386         for (a = 0; a < num_msgs; ++a) {
387                 msg = CtdlFetchMessage(msglist[a], 1);
388                 if (msg != NULL) {
389                         if ((msg->cm_fields['U'] != NULL) && 
390                             (strncasecmp(msg->cm_fields['U'], PAGER_CONFIG_MESSAGE,
391                                          strlen(PAGER_CONFIG_MESSAGE)) == 0)) {
392                                 confMsgNum = msglist[a];
393                         }
394                         CtdlFreeMessage(msg);
395                 }
396         }
397         return confMsgNum;
398     
399 }
400
401 CTDL_MODULE_INIT(extnotify)
402 {
403         if (!threading)
404         {
405                 create_extnotify_queue();
406                 CtdlRegisterSessionHook(do_extnotify_queue, EVT_TIMER);
407         }
408         /* return our Subversion id for the Log */
409         return "$Id$";
410 }