enhanced module loader to not rely on PATH_MAX
[rsyslog.git] / runtime / modules.c
1 /* modules.c
2  * This is the implementation of syslogd modules object.
3  * This object handles plug-ins and build-in modules of all kind.
4  *
5  * Modules are reference-counted. Anyone who access a module must call
6  * Use() before any function is accessed and Release() when he is done.
7  * When the reference count reaches 0, rsyslog unloads the module (that
8  * may be changed in the future to cache modules). Rsyslog does NOT
9  * unload modules with a reference count > 0, even if the unload
10  * method is called!
11  *
12  * File begun on 2007-07-22 by RGerhards
13  *
14  * Copyright 2007, 2009 Rainer Gerhards and Adiscon GmbH.
15  *
16  * This file is part of the rsyslog runtime library.
17  *
18  * The rsyslog runtime library is free software: you can redistribute it and/or modify
19  * it under the terms of the GNU Lesser General Public License as published by
20  * the Free Software Foundation, either version 3 of the License, or
21  * (at your option) any later version.
22  *
23  * The rsyslog runtime library is distributed in the hope that it will be useful,
24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26  * GNU Lesser General Public License for more details.
27  *
28  * You should have received a copy of the GNU Lesser General Public License
29  * along with the rsyslog runtime library.  If not, see <http://www.gnu.org/licenses/>.
30  *
31  * A copy of the GPL can be found in the file "COPYING" in this distribution.
32  * A copy of the LGPL can be found in the file "COPYING.LESSER" in this distribution.
33  */
34 #include "config.h"
35 #include "rsyslog.h"
36 #include <stdio.h>
37 #include <stdarg.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <time.h>
41 #include <assert.h>
42 #include <errno.h>
43 #include <pthread.h>
44 #ifdef  OS_BSD
45 #       include "libgen.h"
46 #endif
47
48 #include <dlfcn.h> /* TODO: replace this with the libtools equivalent! */
49
50 #include <unistd.h>
51 #include <sys/file.h>
52
53 #ifdef OS_SOLARIS
54 #       define PATH_MAX MAXPATHLEN
55 #endif
56
57 #include "cfsysline.h"
58 #include "modules.h"
59 #include "errmsg.h"
60 #include "parser.h"
61 #include "strgen.h"
62
63 /* static data */
64 DEFobjStaticHelpers
65 DEFobjCurrIf(errmsg)
66 DEFobjCurrIf(parser)
67 DEFobjCurrIf(strgen)
68
69 /* we must ensure that only one thread at one time tries to load or unload
70  * modules, otherwise we may see race conditions. This first came up with
71  * imdiag/imtcp, which both use the same stream drivers. Below is the mutex
72  * for that handling.
73  * rgerhards, 2009-05-25
74  */
75 static pthread_mutex_t mutLoadUnload;
76
77 static modInfo_t *pLoadedModules = NULL;        /* list of currently-loaded modules */
78 static modInfo_t *pLoadedModulesLast = NULL;    /* tail-pointer */
79
80 /* already dlopen()-ed libs */
81 static struct dlhandle_s *pHandles = NULL;
82
83 /* config settings */
84 uchar   *pModDir = NULL; /* read-only after startup */
85
86
87 /* we provide a set of dummy functions for modules that do not support the
88  * some interfaces.
89  * On the commit feature: As the modules do not support it, they commit each message they
90  * receive, and as such the dummies can always return RS_RET_OK without causing
91  * harm. This simplifies things as in action processing we do not need to check
92  * if the transactional entry points exist.
93  */
94 static rsRetVal dummyBeginTransaction() 
95 {
96         return RS_RET_OK;
97 }
98 static rsRetVal dummyEndTransaction() 
99 {
100         return RS_RET_OK;
101 }
102 static rsRetVal dummyIsCompatibleWithFeature() 
103 {
104         return RS_RET_INCOMPATIBLE;
105 }
106
107 #ifdef DEBUG
108 /* we add some home-grown support to track our users (and detect who does not free us). In
109  * the long term, this should probably be migrated into debug.c (TODO). -- rgerhards, 2008-03-11
110  */
111
112 /* add a user to the current list of users (always at the root) */
113 static void
114 modUsrAdd(modInfo_t *pThis, char *pszUsr)
115 {
116         modUsr_t *pUsr;
117
118         BEGINfunc
119         if((pUsr = calloc(1, sizeof(modUsr_t))) == NULL)
120                 goto finalize_it;
121
122         if((pUsr->pszFile = strdup(pszUsr)) == NULL) {
123                 free(pUsr);
124                 goto finalize_it;
125         }
126
127         if(pThis->pModUsrRoot != NULL) {
128                 pUsr->pNext = pThis->pModUsrRoot;
129         }
130         pThis->pModUsrRoot = pUsr;
131
132 finalize_it:
133         ENDfunc;
134 }
135
136
137 /* remove a user from the current user list
138  * rgerhards, 2008-03-11
139  */
140 static void
141 modUsrDel(modInfo_t *pThis, char *pszUsr)
142 {
143         modUsr_t *pUsr;
144         modUsr_t *pPrev = NULL;
145
146         for(pUsr = pThis->pModUsrRoot ; pUsr != NULL ; pUsr = pUsr->pNext) {
147                 if(!strcmp(pUsr->pszFile, pszUsr))
148                         break;
149                 else
150                         pPrev = pUsr;
151         }
152
153         if(pUsr == NULL) {
154                 dbgprintf("oops - tried to delete user %s from module %s and it wasn't registered as one...\n",
155                           pszUsr, pThis->pszName);
156         } else {
157                 if(pPrev == NULL) {
158                         /* This was at the root! */
159                         pThis->pModUsrRoot = pUsr->pNext;
160                 } else {
161                         pPrev->pNext = pUsr->pNext;
162                 }
163                 /* free ressources */
164                 free(pUsr->pszFile);
165                 free(pUsr);
166                 pUsr = NULL; /* just to make sure... */
167         }
168 }
169
170
171 /* print a short list all all source files using the module in question
172  * rgerhards, 2008-03-11
173  */
174 static void
175 modUsrPrint(modInfo_t *pThis)
176 {
177         modUsr_t *pUsr;
178
179         for(pUsr = pThis->pModUsrRoot ; pUsr != NULL ; pUsr = pUsr->pNext) {
180                 dbgprintf("\tmodule %s is currently in use by file %s\n",
181                           pThis->pszName, pUsr->pszFile);
182         }
183 }
184
185
186 /* print all loaded modules and who is accessing them. This is primarily intended
187  * to be called at end of run to detect "module leaks" and who is causing them.
188  * rgerhards, 2008-03-11
189  */
190 //static void
191 void
192 modUsrPrintAll(void)
193 {
194         modInfo_t *pMod;
195
196         BEGINfunc
197         for(pMod = pLoadedModules ; pMod != NULL ; pMod = pMod->pNext) {
198                 dbgprintf("printing users of loadable module %s, refcount %u, ptr %p, type %d\n", pMod->pszName, pMod->uRefCnt, pMod, pMod->eType);
199                 modUsrPrint(pMod);
200         }
201         ENDfunc
202 }
203
204 #endif /* #ifdef DEBUG */
205
206
207 /* Construct a new module object
208  */
209 static rsRetVal moduleConstruct(modInfo_t **pThis)
210 {
211         modInfo_t *pNew;
212
213         if((pNew = calloc(1, sizeof(modInfo_t))) == NULL)
214                 return RS_RET_OUT_OF_MEMORY;
215
216         /* OK, we got the element, now initialize members that should
217          * not be zero-filled.
218          */
219
220         *pThis = pNew;
221         return RS_RET_OK;
222 }
223
224
225 /* Destructs a module object. The object must not be linked to the
226  * linked list of modules. Please note that all other dependencies on this
227  * modules must have been removed before (e.g. CfSysLineHandlers!)
228  */
229 static void moduleDestruct(modInfo_t *pThis)
230 {
231         assert(pThis != NULL);
232         if(pThis->pszName != NULL)
233                 free(pThis->pszName);
234         if(pThis->pModHdlr != NULL) {
235 #       ifdef   VALGRIND
236 #               warning "dlclose disabled for valgrind"
237 #       else
238                 if (pThis->eKeepType == eMOD_NOKEEP) {
239                         dlclose(pThis->pModHdlr);
240                 }
241 #       endif
242         }
243
244         free(pThis);
245 }
246
247
248 /* This enables a module to query the core for specific features.
249  * rgerhards, 2009-04-22
250  */
251 static rsRetVal queryCoreFeatureSupport(int *pBool, unsigned uFeat)
252 {
253         DEFiRet;
254
255         if((pBool == NULL))
256                 ABORT_FINALIZE(RS_RET_PARAM_ERROR);
257
258         *pBool = (uFeat & CORE_FEATURE_BATCHING) ? 1 : 0;
259
260 finalize_it:
261         RETiRet;
262 }
263
264
265 /* The following function is the queryEntryPoint for host-based entry points.
266  * Modules may call it to get access to core interface functions. Please note
267  * that utility functions can be accessed via shared libraries - at least this
268  * is my current shool of thinking.
269  * Please note that the implementation as a query interface allows to take
270  * care of plug-in interface version differences. -- rgerhards, 2007-07-31
271  * ... but often it better not to use a new interface. So we now add core
272  * functions here that a plugin may request. -- rgerhards, 2009-04-22
273  */
274 static rsRetVal queryHostEtryPt(uchar *name, rsRetVal (**pEtryPoint)())
275 {
276         DEFiRet;
277
278         if((name == NULL) || (pEtryPoint == NULL))
279                 ABORT_FINALIZE(RS_RET_PARAM_ERROR);
280
281         if(!strcmp((char*) name, "regCfSysLineHdlr")) {
282                 *pEtryPoint = regCfSysLineHdlr;
283         } else if(!strcmp((char*) name, "objGetObjInterface")) {
284                 *pEtryPoint = objGetObjInterface;
285         } else if(!strcmp((char*) name, "OMSRgetSupportedTplOpts")) {
286                 *pEtryPoint = OMSRgetSupportedTplOpts;
287         } else if(!strcmp((char*) name, "queryCoreFeatureSupport")) {
288                 *pEtryPoint = queryCoreFeatureSupport;
289         } else {
290                 *pEtryPoint = NULL; /* to  be on the safe side */
291                 ABORT_FINALIZE(RS_RET_ENTRY_POINT_NOT_FOUND);
292         }
293
294 finalize_it:
295         RETiRet;
296 }
297
298
299 /* get the name of a module
300  */
301 static uchar *modGetName(modInfo_t *pThis)
302 {
303         return((pThis->pszName == NULL) ? (uchar*) "" : pThis->pszName);
304 }
305
306
307 /* get the state-name of a module. The state name is its name
308  * together with a short description of the module state (which
309  * is pulled from the module itself.
310  * rgerhards, 2007-07-24
311  * TODO: the actual state name is not yet pulled
312  */
313 static uchar *modGetStateName(modInfo_t *pThis)
314 {
315         return(modGetName(pThis));
316 }
317
318
319 /* Add a module to the loaded module linked list
320  */
321 static inline void
322 addModToList(modInfo_t *pThis)
323 {
324         assert(pThis != NULL);
325
326         if(pLoadedModules == NULL) {
327                 pLoadedModules = pLoadedModulesLast = pThis;
328         } else {
329                 /* there already exist entries */
330                 pThis->pPrev = pLoadedModulesLast;
331                 pLoadedModulesLast->pNext = pThis;
332                 pLoadedModulesLast = pThis;
333         }
334 }
335
336
337 /* Get the next module pointer - this is used to traverse the list.
338  * The function returns the next pointer or NULL, if there is no next one.
339  * The last object must be provided to the function. If NULL is provided,
340  * it starts at the root of the list. Even in this case, NULL may be 
341  * returned - then, the list is empty.
342  * rgerhards, 2007-07-23
343  */
344 static modInfo_t *GetNxt(modInfo_t *pThis)
345 {
346         modInfo_t *pNew;
347
348         if(pThis == NULL)
349                 pNew = pLoadedModules;
350         else
351                 pNew = pThis->pNext;
352
353         return(pNew);
354 }
355
356
357 /* this function is like GetNxt(), but it returns pointers to
358  * modules of specific type only. As we currently deal just with output modules,
359  * it is a dummy, to be filled with real code later.
360  * rgerhards, 2007-07-24
361  */
362 static modInfo_t *GetNxtType(modInfo_t *pThis, eModType_t rqtdType)
363 {
364         modInfo_t *pMod = pThis;
365
366         do {
367                 pMod = GetNxt(pMod);
368         } while(!(pMod == NULL || pMod->eType == rqtdType)); /* warning: do ... while() */
369
370         return pMod;
371 }
372
373
374 /* Prepare a module for unloading.
375  * This is currently a dummy, to be filled when we have a plug-in
376  * interface - rgerhards, 2007-08-09
377  * rgerhards, 2007-11-21:
378  * When this function is called, all instance-data must already have
379  * been destroyed. In the case of output modules, this happens when the
380  * rule set is being destroyed. When we implement other module types, we
381  * need to think how we handle it there (and if we have any instance data).
382  * rgerhards, 2008-03-10: reject unload request if the module has a reference
383  * count > 0.
384  */
385 static rsRetVal
386 modPrepareUnload(modInfo_t *pThis)
387 {
388         DEFiRet;
389         void *pModCookie;
390
391         assert(pThis != NULL);
392
393         if(pThis->uRefCnt > 0) {
394                 dbgprintf("rejecting unload of module '%s' because it has a refcount of %d\n",
395                           pThis->pszName, pThis->uRefCnt);
396                 ABORT_FINALIZE(RS_RET_MODULE_STILL_REFERENCED);
397         }
398
399         CHKiRet(pThis->modGetID(&pModCookie));
400         pThis->modExit(); /* tell the module to get ready for unload */
401         CHKiRet(unregCfSysLineHdlrs4Owner(pModCookie));
402
403 finalize_it:
404         RETiRet;
405 }
406
407
408 /* Add an already-loaded module to the module linked list. This function does
409  * everything needed to fully initialize the module.
410  */
411 static rsRetVal
412 doModInit(rsRetVal (*modInit)(int, int*, rsRetVal(**)(), rsRetVal(*)(), modInfo_t*), uchar *name, void *pModHdlr)
413 {
414         rsRetVal localRet;
415         modInfo_t *pNew = NULL;
416         uchar *pName;
417         parser_t *pParser; /* used for parser modules */
418         strgen_t *pStrgen; /* used for strgen modules */
419         rsRetVal (*GetName)(uchar**);
420         rsRetVal (*modGetType)(eModType_t *pType);
421         rsRetVal (*modGetKeepType)(eModKeepType_t *pKeepType);
422         struct dlhandle_s *pHandle = NULL;
423         DEFiRet;
424
425         assert(modInit != NULL);
426
427         if((iRet = moduleConstruct(&pNew)) != RS_RET_OK) {
428                 pNew = NULL;
429                 ABORT_FINALIZE(iRet);
430         }
431
432         CHKiRet((*modInit)(CURR_MOD_IF_VERSION, &pNew->iIFVers, &pNew->modQueryEtryPt, queryHostEtryPt, pNew));
433
434         if(pNew->iIFVers != CURR_MOD_IF_VERSION) {
435                 ABORT_FINALIZE(RS_RET_MISSING_INTERFACE);
436         }
437
438         /* We now poll the module to see what type it is. We do this only once as this
439          * can never change in the lifetime of an module. -- rgerhards, 2007-12-14
440          */
441         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"getType", &modGetType));
442         CHKiRet((*modGetType)(&pNew->eType));
443         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"getKeepType", &modGetKeepType));
444         CHKiRet((*modGetKeepType)(&pNew->eKeepType));
445         dbgprintf("module of type %d being loaded.\n", pNew->eType);
446         
447         /* OK, we know we can successfully work with the module. So we now fill the
448          * rest of the data elements. First we load the interfaces common to all
449          * module types.
450          */
451         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"modGetID", &pNew->modGetID));
452         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"modExit", &pNew->modExit));
453         localRet = (*pNew->modQueryEtryPt)((uchar*)"isCompatibleWithFeature", &pNew->isCompatibleWithFeature);
454         if(localRet == RS_RET_MODULE_ENTRY_POINT_NOT_FOUND)
455                 pNew->isCompatibleWithFeature = dummyIsCompatibleWithFeature;
456         else if(localRet != RS_RET_OK)
457                 ABORT_FINALIZE(localRet);
458
459         /* ... and now the module-specific interfaces */
460         switch(pNew->eType) {
461                 case eMOD_IN:
462                         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"runInput", &pNew->mod.im.runInput));
463                         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"willRun", &pNew->mod.im.willRun));
464                         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"afterRun", &pNew->mod.im.afterRun));
465                         pNew->mod.im.bCanRun = 0;
466                         break;
467                 case eMOD_OUT:
468                         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"freeInstance", &pNew->freeInstance));
469                         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"dbgPrintInstInfo", &pNew->dbgPrintInstInfo));
470                         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"doAction", &pNew->mod.om.doAction));
471                         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"parseSelectorAct", &pNew->mod.om.parseSelectorAct));
472                         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"tryResume", &pNew->tryResume));
473                         /* try load optional interfaces */
474                         localRet = (*pNew->modQueryEtryPt)((uchar*)"doHUP", &pNew->doHUP);
475                         if(localRet != RS_RET_OK && localRet != RS_RET_MODULE_ENTRY_POINT_NOT_FOUND)
476                                 ABORT_FINALIZE(localRet);
477
478                         localRet = (*pNew->modQueryEtryPt)((uchar*)"beginTransaction", &pNew->mod.om.beginTransaction);
479                         if(localRet == RS_RET_MODULE_ENTRY_POINT_NOT_FOUND)
480                                 pNew->mod.om.beginTransaction = dummyBeginTransaction;
481                         else if(localRet != RS_RET_OK)
482                                 ABORT_FINALIZE(localRet);
483
484                         localRet = (*pNew->modQueryEtryPt)((uchar*)"endTransaction", &pNew->mod.om.endTransaction);
485                         if(localRet == RS_RET_MODULE_ENTRY_POINT_NOT_FOUND) {
486                                 pNew->mod.om.endTransaction = dummyEndTransaction;
487                         } else if(localRet != RS_RET_OK) {
488                                 ABORT_FINALIZE(localRet);
489                         }
490                         break;
491                 case eMOD_LIB:
492                         break;
493                 case eMOD_PARSER:
494                         /* first, we need to obtain the parser object. We could not do that during
495                          * init as that would have caused class bootstrap issues which are not
496                          * absolutely necessary. Note that we can call objUse() multiple times, it
497                          * handles that.
498                          */
499                         CHKiRet(objUse(parser, CORE_COMPONENT));
500                         /* here, we create a new parser object */
501                         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"parse", &pNew->mod.pm.parse));
502                         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"GetParserName", &GetName));
503                         CHKiRet(GetName(&pName));
504                         CHKiRet(parser.Construct(&pParser));
505
506                         /* check some features */
507                         localRet = pNew->isCompatibleWithFeature(sFEATUREAutomaticSanitazion);
508                         if(localRet == RS_RET_OK){
509                                 CHKiRet(parser.SetDoSanitazion(pParser, TRUE));
510                         }
511                         localRet = pNew->isCompatibleWithFeature(sFEATUREAutomaticPRIParsing);
512                         if(localRet == RS_RET_OK){
513                                 CHKiRet(parser.SetDoPRIParsing(pParser, TRUE));
514                         }
515
516                         CHKiRet(parser.SetName(pParser, pName));
517                         CHKiRet(parser.SetModPtr(pParser, pNew));
518                         CHKiRet(parser.ConstructFinalize(pParser));
519                         break;
520                 case eMOD_STRGEN:
521                         /* first, we need to obtain the strgen object. We could not do that during
522                          * init as that would have caused class bootstrap issues which are not
523                          * absolutely necessary. Note that we can call objUse() multiple times, it
524                          * handles that.
525                          */
526                         CHKiRet(objUse(strgen, CORE_COMPONENT));
527                         /* here, we create a new parser object */
528                         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"strgen", &pNew->mod.sm.strgen));
529                         CHKiRet((*pNew->modQueryEtryPt)((uchar*)"GetName", &GetName));
530                         CHKiRet(GetName(&pName));
531                         CHKiRet(strgen.Construct(&pStrgen));
532                         CHKiRet(strgen.SetName(pStrgen, pName));
533                         CHKiRet(strgen.SetModPtr(pStrgen, pNew));
534                         CHKiRet(strgen.ConstructFinalize(pStrgen));
535                         break;
536         }
537
538         pNew->pszName = (uchar*) strdup((char*)name); /* we do not care if strdup() fails, we can accept that */
539         pNew->pModHdlr = pModHdlr;
540         /* TODO: take this from module */
541         if(pModHdlr == NULL) {
542                 pNew->eLinkType = eMOD_LINK_STATIC;
543         } else {
544                 pNew->eLinkType = eMOD_LINK_DYNAMIC_LOADED;
545
546                 /* if we need to keep the linked module, save it */
547                 if (pNew->eKeepType == eMOD_KEEP) {
548                         /* see if we have this one already */
549                         for (pHandle = pHandles; pHandle; pHandle = pHandle->next) {
550                                 if (!strcmp((char *)name, (char *)pHandle->pszName))
551                                         break;
552                         }
553
554                         /* not found, create it */
555                         if (!pHandle) {
556                                 if((pHandle = malloc(sizeof (*pHandle))) == NULL) {
557                                         ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
558                                 }
559                                 if((pHandle->pszName = (uchar*) strdup((char*)name)) == NULL) {
560                                         free(pHandle);
561                                         ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
562                                 }
563                                 pHandle->pModHdlr = pModHdlr;
564                                 pHandle->next = pHandles;
565
566                                 pHandles = pHandle;
567                         }
568                 }
569         }
570
571         /* we initialized the structure, now let's add it to the linked list of modules */
572         addModToList(pNew);
573
574 finalize_it:
575         if(iRet != RS_RET_OK) {
576                 if(pNew != NULL)
577                         moduleDestruct(pNew);
578         }
579
580         RETiRet;
581 }
582
583 /* Print loaded modules. This is more or less a 
584  * debug or test aid, but anyhow I think it's worth it...
585  * This only works if the dbgprintf() subsystem is initialized.
586  * TODO: update for new input modules!
587  */
588 static void modPrintList(void)
589 {
590         modInfo_t *pMod;
591
592         pMod = GetNxt(NULL);
593         while(pMod != NULL) {
594                 dbgprintf("Loaded Module: Name='%s', IFVersion=%d, ",
595                         (char*) modGetName(pMod), pMod->iIFVers);
596                 dbgprintf("type=");
597                 switch(pMod->eType) {
598                 case eMOD_OUT:
599                         dbgprintf("output");
600                         break;
601                 case eMOD_IN:
602                         dbgprintf("input");
603                         break;
604                 case eMOD_LIB:
605                         dbgprintf("library");
606                         break;
607                 case eMOD_PARSER:
608                         dbgprintf("parser");
609                         break;
610                 case eMOD_STRGEN:
611                         dbgprintf("strgen");
612                         break;
613                 }
614                 dbgprintf(" module.\n");
615                 dbgprintf("Entry points:\n");
616                 dbgprintf("\tqueryEtryPt:        0x%lx\n", (unsigned long) pMod->modQueryEtryPt);
617                 dbgprintf("\tdbgPrintInstInfo:   0x%lx\n", (unsigned long) pMod->dbgPrintInstInfo);
618                 dbgprintf("\tfreeInstance:       0x%lx\n", (unsigned long) pMod->freeInstance);
619                 switch(pMod->eType) {
620                 case eMOD_OUT:
621                         dbgprintf("Output Module Entry Points:\n");
622                         dbgprintf("\tdoAction:           0x%lx\n", (unsigned long) pMod->mod.om.doAction);
623                         dbgprintf("\tparseSelectorAct:   0x%lx\n", (unsigned long) pMod->mod.om.parseSelectorAct);
624                         dbgprintf("\ttryResume:          0x%lx\n", (unsigned long) pMod->tryResume);
625                         dbgprintf("\tdoHUP:              0x%lx\n", (unsigned long) pMod->doHUP);
626                         dbgprintf("\tBeginTransaction:   0x%lx\n", (unsigned long)
627                                                                    ((pMod->mod.om.beginTransaction == dummyBeginTransaction) ?
628                                                                     0 :  pMod->mod.om.beginTransaction));
629                         dbgprintf("\tEndTransaction:     0x%lx\n", (unsigned long)
630                                                                    ((pMod->mod.om.endTransaction == dummyEndTransaction) ?
631                                                                     0 :  pMod->mod.om.endTransaction));
632                         break;
633                 case eMOD_IN:
634                         dbgprintf("Input Module Entry Points\n");
635                         dbgprintf("\trunInput:           0x%lx\n", (unsigned long) pMod->mod.im.runInput);
636                         dbgprintf("\twillRun:            0x%lx\n", (unsigned long) pMod->mod.im.willRun);
637                         dbgprintf("\tafterRun:           0x%lx\n", (unsigned long) pMod->mod.im.afterRun);
638                         break;
639                 case eMOD_LIB:
640                         break;
641                 case eMOD_PARSER:
642                         dbgprintf("Parser Module Entry Points\n");
643                         dbgprintf("\tparse:              0x%lx\n", (unsigned long) pMod->mod.pm.parse);
644                         break;
645                 case eMOD_STRGEN:
646                         dbgprintf("Strgen Module Entry Points\n");
647                         dbgprintf("\tstrgen:            0x%lx\n", (unsigned long) pMod->mod.sm.strgen);
648                         break;
649                 }
650                 dbgprintf("\n");
651                 pMod = GetNxt(pMod); /* done, go next */
652         }
653 }
654
655
656 /* unlink and destroy a module. The caller must provide a pointer to the module
657  * itself as well as one to its immediate predecessor.
658  * rgerhards, 2008-02-26
659  */
660 static rsRetVal
661 modUnlinkAndDestroy(modInfo_t **ppThis)
662 {
663         DEFiRet;
664         modInfo_t *pThis;
665
666         assert(ppThis != NULL);
667         pThis = *ppThis;
668         assert(pThis != NULL);
669
670         pthread_mutex_lock(&mutLoadUnload);
671
672         /* first check if we are permitted to unload */
673         if(pThis->eType == eMOD_LIB) {
674                 if(pThis->uRefCnt > 0) {
675                         dbgprintf("module %s NOT unloaded because it still has a refcount of %u\n",
676                                   pThis->pszName, pThis->uRefCnt);
677 #                       ifdef DEBUG
678                         //modUsrPrintAll();
679 #                       endif
680                         ABORT_FINALIZE(RS_RET_MODULE_STILL_REFERENCED);
681                 }
682         }
683
684         /* we need to unlink the module before we can destruct it -- rgerhards, 2008-02-26 */
685         if(pThis->pPrev == NULL) {
686                 /* module is root, so we need to set a new root */
687                 pLoadedModules = pThis->pNext;
688         } else {
689                 pThis->pPrev->pNext = pThis->pNext;
690         }
691
692         if(pThis->pNext == NULL) {
693                 pLoadedModulesLast = pThis->pPrev;
694         } else {
695                 pThis->pNext->pPrev = pThis->pPrev;
696         }
697
698         /* finally, we are ready for the module to go away... */
699         dbgprintf("Unloading module %s\n", modGetName(pThis));
700         CHKiRet(modPrepareUnload(pThis));
701         *ppThis = pThis->pNext;
702
703         moduleDestruct(pThis);
704
705 finalize_it:
706         pthread_mutex_unlock(&mutLoadUnload);
707         RETiRet;
708 }
709
710
711 /* unload all loaded modules of a specific type (use eMOD_ALL if you want to
712  * unload all module types). The unload happens only if the module is no longer
713  * referenced. So some modules may survive this call.
714  * rgerhards, 2008-03-11
715  */
716 static rsRetVal
717 modUnloadAndDestructAll(eModLinkType_t modLinkTypesToUnload)
718 {
719         DEFiRet;
720         modInfo_t *pModCurr; /* module currently being processed */
721
722         pModCurr = GetNxt(NULL);
723         while(pModCurr != NULL) {
724                 if(modLinkTypesToUnload == eMOD_LINK_ALL || pModCurr->eLinkType == modLinkTypesToUnload) {
725                         if(modUnlinkAndDestroy(&pModCurr) == RS_RET_MODULE_STILL_REFERENCED) {
726                                 pModCurr = GetNxt(pModCurr);
727                         } else {
728                                 /* Note: if the module was successfully unloaded, it has updated the
729                                  * pModCurr pointer to the next module. However, the unload process may
730                                  * still have indirectly referenced the pointer list in a way that the
731                                  * unloaded module is not aware of. So we restart the unload process
732                                  * to make sure we do not fall into a trap (what we did ;)). The
733                                  * performance toll is minimal. -- rgerhards, 2008-04-28
734                                  */
735                                 pModCurr = GetNxt(NULL);
736                         }
737                 } else {
738                         pModCurr = GetNxt(pModCurr);
739                 }
740         }
741
742 #       ifdef DEBUG
743         /* DEV DEBUG only!
744                 if(pLoadedModules != NULL) {
745                         dbgprintf("modules still loaded after module.UnloadAndDestructAll:\n");
746                         modUsrPrintAll();
747                 }
748         */
749 #       endif
750
751         RETiRet;
752 }
753
754
755 /* load a module and initialize it, based on doModLoad() from conf.c
756  * rgerhards, 2008-03-05
757  * varmojfekoj added support for dynamically loadable modules on 2007-08-13
758  * rgerhards, 2007-09-25: please note that the non-threadsafe function dlerror() is
759  * called below. This is ok because modules are currently only loaded during
760  * configuration file processing, which is executed on a single thread. Should we
761  * change that design at any stage (what is unlikely), we need to find a
762  * replacement.
763  */
764 static rsRetVal
765 Load(uchar *pModName)
766 {
767         DEFiRet;
768         
769         size_t iPathLen, iModNameLen;
770         uchar *pModNameCmp;
771         int bHasExtension;
772         void *pModHdlr, *pModInit;
773         modInfo_t *pModInfo;
774         uchar *pModDirCurr, *pModDirNext;
775         int iLoadCnt;
776         struct dlhandle_s *pHandle = NULL;
777 #       ifdef PATH_MAX
778         uchar pathBuf[PATH_MAX+1];
779 #       else
780         uchar pathBuf[4096];
781 #       endif
782         uchar *pPathBuf = pathBuf;
783         size_t lenPathBuf = sizeof(pathBuf);
784
785         assert(pModName != NULL);
786         dbgprintf("Requested to load module '%s'\n", pModName);
787
788         iModNameLen = strlen((char*)pModName);
789         /* overhead for a full path is potentially 1 byte for a slash,
790          * three bytes for ".so" and one byte for '\0'.
791          */
792 #       define PATHBUF_OVERHEAD 1 + iModNameLen + 3 + 1
793
794         pthread_mutex_lock(&mutLoadUnload);
795
796         if(iModNameLen > 3 && !strcmp((char *) pModName + iModNameLen - 3, ".so")) {
797                 iModNameLen -= 3;
798                 bHasExtension = TRUE;
799         } else
800                 bHasExtension = FALSE;
801
802         pModInfo = GetNxt(NULL);
803         while(pModInfo != NULL) {
804                 if(!strncmp((char *) pModName, (char *) (pModNameCmp = modGetName(pModInfo)), iModNameLen) &&
805                    (!*(pModNameCmp + iModNameLen) || !strcmp((char *) pModNameCmp + iModNameLen, ".so"))) {
806                         dbgprintf("Module '%s' already loaded\n", pModName);
807                         ABORT_FINALIZE(RS_RET_OK);
808                 }
809                 pModInfo = GetNxt(pModInfo);
810         }
811
812         pModDirCurr = (uchar *)((pModDir == NULL) ? _PATH_MODDIR : (char *)pModDir);
813         pModDirNext = NULL;
814         pModHdlr    = NULL;
815         iLoadCnt    = 0;
816         do {    /* now build our load module name */
817                 if(*pModName == '/' || *pModName == '.') {
818                         if(lenPathBuf < PATHBUF_OVERHEAD) {
819                                 if(pPathBuf != pathBuf) /* already malloc()ed memory? */
820                                         free(pPathBuf);
821                                 /* we always alloc enough memory for everything we potentiall need to add */
822                                 lenPathBuf = PATHBUF_OVERHEAD;
823                                 CHKmalloc(pPathBuf = malloc(sizeof(char)*lenPathBuf));
824                         }
825                         *pPathBuf = '\0';       /* we do not need to append the path - its already in the module name */
826                         iPathLen = 0;
827                 } else {
828                         *pPathBuf = '\0';
829
830                         iPathLen = strlen((char *)pModDirCurr);
831                         pModDirNext = (uchar *)strchr((char *)pModDirCurr, ':');
832                         if(pModDirNext)
833                                 iPathLen = (size_t)(pModDirNext - pModDirCurr);
834
835                         if(iPathLen == 0) {
836                                 if(pModDirNext) {
837                                         pModDirCurr = pModDirNext + 1;
838                                         continue;
839                                 }
840                                 break;
841                         } else if(iPathLen > lenPathBuf - PATHBUF_OVERHEAD) {
842                                 if(pPathBuf != pathBuf) /* already malloc()ed memory? */
843                                         free(pPathBuf);
844                                 /* we always alloc enough memory for everything we potentiall need to add */
845                                 lenPathBuf = iPathLen + PATHBUF_OVERHEAD;
846                                 CHKmalloc(pPathBuf = malloc(sizeof(char)*lenPathBuf));
847                         }
848
849                         memcpy((char *) pPathBuf, (char *)pModDirCurr, iPathLen);
850                         if((pPathBuf[iPathLen - 1] != '/')) {
851                                 /* we have space, made sure in previous check */
852                                 pPathBuf[iPathLen++] = '/';
853                         }
854                         pPathBuf[iPathLen] = '\0';
855
856                         if(pModDirNext)
857                                 pModDirCurr = pModDirNext + 1;
858                 }
859
860                 /* ... add actual name ... */
861                 strncat((char *) pPathBuf, (char *) pModName, lenPathBuf - iPathLen - 1);
862
863                 /* now see if we have an extension and, if not, append ".so" */
864                 if(!bHasExtension) {
865                         /* we do not have an extension and so need to add ".so"
866                          * TODO: I guess this is highly importable, so we should change the
867                          * algo over time... -- rgerhards, 2008-03-05
868                          */
869                         /* ... so now add the extension */
870                         strncat((char *) pPathBuf, ".so", lenPathBuf - strlen((char*) pPathBuf) - 1);
871                         iPathLen += 3;
872                 }
873
874                 /* complete load path constructed, so ... GO! */
875                 dbgprintf("loading module '%s'\n", pPathBuf);
876
877                 /* see if we have this one already */
878                 for (pHandle = pHandles; pHandle; pHandle = pHandle->next) {
879                         if (!strcmp((char *)pModName, (char *)pHandle->pszName)) {
880                                 pModHdlr = pHandle->pModHdlr;
881                                 break;
882                         }
883                 }
884
885                 /* not found, try to dynamically link it */
886                 if (!pModHdlr) {
887                         pModHdlr = dlopen((char *) pPathBuf, RTLD_NOW);
888                 }
889
890                 iLoadCnt++;
891         
892         } while(pModHdlr == NULL && *pModName != '/' && pModDirNext);
893
894         if(!pModHdlr) {
895                 if(iLoadCnt) {
896                         errmsg.LogError(0, RS_RET_MODULE_LOAD_ERR_DLOPEN, "could not load module '%s', dlopen: %s\n",
897                                         pPathBuf, dlerror());
898                 } else {
899                         errmsg.LogError(0, NO_ERRCODE, "could not load module '%s', ModDir was '%s'\n", pPathBuf,
900                                                        ((pModDir == NULL) ? _PATH_MODDIR : (char *)pModDir));
901                 }
902                 ABORT_FINALIZE(RS_RET_MODULE_LOAD_ERR_DLOPEN);
903         }
904         if(!(pModInit = dlsym(pModHdlr, "modInit"))) {
905                 errmsg.LogError(0, RS_RET_MODULE_LOAD_ERR_NO_INIT, "could not load module '%s', dlsym: %s\n", pPathBuf, dlerror());
906                 dlclose(pModHdlr);
907                 ABORT_FINALIZE(RS_RET_MODULE_LOAD_ERR_NO_INIT);
908         }
909         if((iRet = doModInit(pModInit, (uchar*) pModName, pModHdlr)) != RS_RET_OK) {
910                 errmsg.LogError(0, RS_RET_MODULE_LOAD_ERR_INIT_FAILED, "could not load module '%s', rsyslog error %d\n", pPathBuf, iRet);
911                 dlclose(pModHdlr);
912                 ABORT_FINALIZE(RS_RET_MODULE_LOAD_ERR_INIT_FAILED);
913         }
914
915 finalize_it:
916         if(pPathBuf != pathBuf) /* used malloc()ed memory? */
917                 free(pPathBuf);
918         pthread_mutex_unlock(&mutLoadUnload);
919         RETiRet;
920 }
921
922
923 /* set the default module load directory. A NULL value may be provided, in
924  * which case any previous value is deleted but no new one set. The caller-provided
925  * string is duplicated. If it needs to be freed, that's the caller's duty.
926  * rgerhards, 2008-03-07
927  */
928 static rsRetVal
929 SetModDir(uchar *pszModDir)
930 {
931         DEFiRet;
932
933         dbgprintf("setting default module load directory '%s'\n", pszModDir);
934         if(pModDir != NULL) {
935                 free(pModDir);
936         }
937
938         pModDir = (uchar*) strdup((char*)pszModDir);
939
940         RETiRet;
941 }
942
943
944 /* Reference-Counting object access: add 1 to the current reference count. Must be
945  * called by anyone interested in using a module. -- rgerhards, 20080-03-10
946  */
947 static rsRetVal
948 Use(char *srcFile, modInfo_t *pThis)
949 {
950         DEFiRet;
951
952         assert(pThis != NULL);
953         pThis->uRefCnt++;
954         dbgprintf("source file %s requested reference for module '%s', reference count now %u\n",
955                   srcFile, pThis->pszName, pThis->uRefCnt);
956
957 #       ifdef DEBUG
958         modUsrAdd(pThis, srcFile);
959 #       endif
960
961         RETiRet;
962
963 }
964
965
966 /* Reference-Counting object access: subract one from the current refcount. Must
967  * by called by anyone who no longer needs a module. If count reaches 0, the 
968  * module is unloaded. -- rgerhards, 20080-03-10
969  */
970 static rsRetVal
971 Release(char *srcFile, modInfo_t **ppThis)
972 {
973         DEFiRet;
974         modInfo_t *pThis;
975
976         assert(ppThis != NULL);
977         pThis = *ppThis;
978         assert(pThis != NULL);
979         if(pThis->uRefCnt == 0) {
980                 /* oops, we are already at 0? */
981                 dbgprintf("internal error: module '%s' already has a refcount of 0 (released by %s)!\n",
982                           pThis->pszName, srcFile);
983         } else {
984                 --pThis->uRefCnt;
985                 dbgprintf("file %s released module '%s', reference count now %u\n",
986                           srcFile, pThis->pszName, pThis->uRefCnt);
987 #               ifdef DEBUG
988                 modUsrDel(pThis, srcFile);
989                 modUsrPrint(pThis);
990 #               endif
991         }
992
993         if(pThis->uRefCnt == 0) {
994                 /* we have a zero refcount, so we must unload the module */
995                 dbgprintf("module '%s' has zero reference count, unloading...\n", pThis->pszName);
996                 modUnlinkAndDestroy(&pThis);
997                 /* we must NOT do a *ppThis = NULL, because ppThis now points into freed memory!
998                  * If in doubt, see obj.c::ReleaseObj() for how we are called.
999                  */
1000         }
1001
1002         RETiRet;
1003
1004 }
1005
1006
1007 /* exit our class
1008  * rgerhards, 2008-03-11
1009  */
1010 BEGINObjClassExit(module, OBJ_IS_LOADABLE_MODULE) /* CHANGE class also in END MACRO! */
1011 CODESTARTObjClassExit(module)
1012         /* release objects we no longer need */
1013         objRelease(errmsg, CORE_COMPONENT);
1014         objRelease(parser, CORE_COMPONENT);
1015         /* We have a problem in our reference counting, which leads to this function
1016          * being called too early. This usually is no problem, but if we destroy
1017          * the mutex object, we get into trouble. So rather than finding the root cause,
1018          * we do not release the mutex right now and have a very, very slight leak.
1019          * We know that otherwise no bad effects happen, so this acceptable for the 
1020          * time being. -- rgerhards, 2009-05-25
1021          *
1022          * TODO: add again: pthread_mutex_destroy(&mutLoadUnload);
1023          */
1024
1025 #       ifdef DEBUG
1026         modUsrPrintAll(); /* debug aid - TODO: integrate with debug.c, at least the settings! */
1027 #       endif
1028 ENDObjClassExit(module)
1029
1030
1031 /* queryInterface function
1032  * rgerhards, 2008-03-05
1033  */
1034 BEGINobjQueryInterface(module)
1035 CODESTARTobjQueryInterface(module)
1036         if(pIf->ifVersion != moduleCURR_IF_VERSION) { /* check for current version, increment on each change */
1037                 ABORT_FINALIZE(RS_RET_INTERFACE_NOT_SUPPORTED);
1038         }
1039
1040         /* ok, we have the right interface, so let's fill it
1041          * Please note that we may also do some backwards-compatibility
1042          * work here (if we can support an older interface version - that,
1043          * of course, also affects the "if" above).
1044          */
1045         pIf->GetNxt = GetNxt;
1046         pIf->GetNxtType = GetNxtType;
1047         pIf->GetName = modGetName;
1048         pIf->GetStateName = modGetStateName;
1049         pIf->PrintList = modPrintList;
1050         pIf->UnloadAndDestructAll = modUnloadAndDestructAll;
1051         pIf->doModInit = doModInit;
1052         pIf->SetModDir = SetModDir;
1053         pIf->Load = Load;
1054         pIf->Use = Use;
1055         pIf->Release = Release;
1056 finalize_it:
1057 ENDobjQueryInterface(module)
1058
1059
1060 /* Initialize our class. Must be called as the very first method
1061  * before anything else is called inside this class.
1062  * rgerhards, 2008-03-05
1063  */
1064 BEGINAbstractObjClassInit(module, 1, OBJ_IS_CORE_MODULE) /* class, version - CHANGE class also in END MACRO! */
1065         uchar *pModPath;
1066         pthread_mutexattr_t mutAttr;
1067
1068         /* use any module load path specified in the environment */
1069         if((pModPath = (uchar*) getenv("RSYSLOG_MODDIR")) != NULL) {
1070                 SetModDir(pModPath);
1071         }
1072
1073         /* now check if another module path was set via the command line (-M)
1074          * if so, that overrides the environment. Please note that we must use
1075          * a global setting here because the command line parser can NOT call
1076          * into the module object, because it is not initialized at that point. So
1077          * instead a global setting is changed and we pick it up as soon as we
1078          * initialize -- rgerhards, 2008-04-04
1079          */
1080         if(glblModPath != NULL) {
1081                 SetModDir(glblModPath);
1082         }
1083
1084         pthread_mutexattr_init(&mutAttr);
1085         pthread_mutexattr_settype(&mutAttr, PTHREAD_MUTEX_RECURSIVE);
1086         pthread_mutex_init(&mutLoadUnload, &mutAttr);
1087
1088         /* request objects we use */
1089         CHKiRet(objUse(errmsg, CORE_COMPONENT));
1090 ENDObjClassInit(module)
1091
1092 /* vi:set ai:
1093  */