Back to index

citadel  8.12
Functions | Variables
modules_init.h File Reference
#include "ctdl_module.h"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

void initialise_modules (int threading)
void upgrade_modules (void)
 CTDL_MODULE_INIT (citserver)
 CTDL_MODULE_INIT (control)
 CTDL_MODULE_INIT (euidindex)
 CTDL_MODULE_INIT (file_ops)
 CTDL_MODULE_INIT (msgbase)
 CTDL_MODULE_INIT (room_ops)
 CTDL_MODULE_INIT (user_ops)
 CTDL_MODULE_INIT (modules)
 CTDL_MODULE_INIT (autocompletion)
 CTDL_MODULE_INIT (bio)
 CTDL_MODULE_INIT (blog)
 CTDL_MODULE_INIT (c_ares_client)
 CTDL_MODULE_INIT (calendar)
 CTDL_MODULE_INIT (checkpoint)
 CTDL_MODULE_INIT (virus)
 CTDL_MODULE_INIT (dspam)
 CTDL_MODULE_INIT (event_client)
 CTDL_MODULE_INIT (expire)
 CTDL_MODULE_INIT (extnotify)
 CTDL_MODULE_INIT (fulltext)
 CTDL_MODULE_INIT (imap)
 CTDL_MODULE_INIT (inetcfg)
 CTDL_MODULE_INIT (instmsg)
 CTDL_MODULE_INIT (listsub)
 CTDL_MODULE_INIT (managesieve)
 CTDL_MODULE_INIT (migrate)
 CTDL_MODULE_INIT (mrtg)
 CTDL_MODULE_INIT (netconfig)
 CTDL_MODULE_INIT (netfilter)
 CTDL_MODULE_INIT (network_spool)
 CTDL_MODULE_INIT (network)
 CTDL_MODULE_INIT (network_client)
 CTDL_MODULE_INIT (newuser)
 CTDL_MODULE_INIT (notes)
 CTDL_MODULE_INIT (openid_rp)
 CTDL_MODULE_INIT (pop3)
 CTDL_MODULE_INIT (pop3client)
 CTDL_MODULE_INIT (roomchat)
 CTDL_MODULE_INIT (rssparser)
 CTDL_MODULE_INIT (rssclient)
 CTDL_MODULE_INIT (rwho)
 CTDL_MODULE_INIT (sieve)
 CTDL_MODULE_INIT (smtp)
 CTDL_MODULE_INIT (smtp_eventclient)
 CTDL_MODULE_INIT (smtp_queu)
 CTDL_MODULE_INIT (spam)
 CTDL_MODULE_INIT (test)
 CTDL_MODULE_UPGRADE (upgrade)
 CTDL_MODULE_INIT (urldeshortener)
 CTDL_MODULE_INIT (vcard)
 CTDL_MODULE_INIT (wiki)
 CTDL_MODULE_INIT (xmpp)

Variables

size_t nSizErrmsg

Function Documentation

CTDL_MODULE_INIT ( citserver  )

Definition at line 1070 of file citserver.c.

{
       if (!threading) {
              CtdlRegisterProtoHook(cmd_noop, "NOOP", "no operation");
              CtdlRegisterProtoHook(cmd_qnop, "QNOP", "no operation with no response");
              CtdlRegisterProtoHook(cmd_quit, "QUIT", "log out and disconnect from server");
              CtdlRegisterProtoHook(cmd_lout, "LOUT", "log out but do not disconnect from server");
              CtdlRegisterProtoHook(cmd_asyn, "ASYN", "enable asynchronous server responses");
              CtdlRegisterProtoHook(cmd_info, "INFO", "fetch server capabilities and configuration");
              CtdlRegisterProtoHook(cmd_mesg, "MESG", "fetch system banners");
              CtdlRegisterProtoHook(cmd_emsg, "EMSG", "submit system banners");
              CtdlRegisterProtoHook(cmd_echo, "ECHO", "echo text back to the client");
              CtdlRegisterProtoHook(cmd_more, "MORE", "fetch the paginator prompt");
              CtdlRegisterProtoHook(cmd_iden, "IDEN", "identify the client software and location");
              CtdlRegisterProtoHook(cmd_term, "TERM", "terminate another running session");
              CtdlRegisterProtoHook(cmd_down, "DOWN", "perform a server shutdown");
              CtdlRegisterProtoHook(cmd_halt, "HALT", "halt the server without exiting the server process");
              CtdlRegisterProtoHook(cmd_scdn, "SCDN", "schedule or cancel a server shutdown");
              CtdlRegisterProtoHook(cmd_time, "TIME", "fetch the date and time from the server");
       }
        /* return our id for the Log */
       return "citserver";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( control  )

Definition at line 753 of file control.c.

{
       if (!threading) {
              CtdlRegisterProtoHook(cmd_conf, "CONF", "get/set system configuration");
       }
       /* return our id for the Log */
       return "control";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( euidindex  )

Definition at line 258 of file euidindex.c.

{
       if (!threading) {
              CtdlRegisterProtoHook(cmd_euid, "EUID", "Perform operations on Extended IDs for messages");
       }
       /* return our Subversion id for the Log */
       return "euidindex";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( file_ops  )

Definition at line 776 of file file_ops.c.

{
       if (!threading) {

              CtdlRegisterProtoHook(cmd_delf, "DELF", "Delete a file");
              CtdlRegisterProtoHook(cmd_movf, "MOVF", "Move a file");
              CtdlRegisterProtoHook(cmd_open, "OPEN", "Open a download file transfer");
              CtdlRegisterProtoHook(cmd_clos, "CLOS", "Close a download file transfer");
              CtdlRegisterProtoHook(cmd_uopn, "UOPN", "Open an upload file transfer");
              CtdlRegisterProtoHook(cmd_ucls, "UCLS", "Close an upload file transfer");
              CtdlRegisterProtoHook(cmd_read, "READ", "File transfer read operation");
              CtdlRegisterProtoHook(cmd_writ, "WRIT", "File transfer write operation");
              CtdlRegisterProtoHook(cmd_ndop, "NDOP", "Open a network spool file for download");
              CtdlRegisterProtoHook(cmd_nuop, "NUOP", "Open a network spool file for upload");
              CtdlRegisterProtoHook(cmd_oimg, "OIMG", "Open an image file for download");
              CtdlRegisterProtoHook(cmd_uimg, "UIMG", "Upload an image file");
       }
        /* return our Subversion id for the Log */
       return "file_ops";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( msgbase  )

Definition at line 5435 of file msgbase.c.

{
       if (!threading) {
              CtdlRegisterDebugFlagHook(HKEY("messages"), SetMessageDebugEnabled, &MessageDebugEnabled);

              CtdlRegisterProtoHook(cmd_msgs, "MSGS", "Output a list of messages in the current room");
              CtdlRegisterProtoHook(cmd_msg0, "MSG0", "Output a message in plain text format");
              CtdlRegisterProtoHook(cmd_msg2, "MSG2", "Output a message in RFC822 format");
              CtdlRegisterProtoHook(cmd_msg3, "MSG3", "Output a message in raw format (deprecated)");
              CtdlRegisterProtoHook(cmd_msg4, "MSG4", "Output a message in the client's preferred format");
              CtdlRegisterProtoHook(cmd_msgp, "MSGP", "Select preferred format for MSG4 output");
              CtdlRegisterProtoHook(cmd_opna, "OPNA", "Open an attachment for download");
              CtdlRegisterProtoHook(cmd_dlat, "DLAT", "Download an attachment");
              CtdlRegisterProtoHook(cmd_ent0, "ENT0", "Enter a message");
              CtdlRegisterProtoHook(cmd_dele, "DELE", "Delete a message");
              CtdlRegisterProtoHook(cmd_move, "MOVE", "Move or copy a message to another room");
              CtdlRegisterProtoHook(cmd_isme, "ISME", "Determine whether an email address belongs to a user");
       }

        /* return our Subversion id for the Log */
       return "msgbase";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( room_ops  )

Definition at line 2299 of file room_ops.c.

{
       if (!threading) {
              CtdlRegisterProtoHook(cmd_lrms, "LRMS", "List rooms");
              CtdlRegisterProtoHook(cmd_lkra, "LKRA", "List all known rooms");
              CtdlRegisterProtoHook(cmd_lkrn, "LKRN", "List known rooms with new messages");
              CtdlRegisterProtoHook(cmd_lkro, "LKRO", "List known rooms without new messages");
              CtdlRegisterProtoHook(cmd_lzrm, "LZRM", "List zapped rooms");
              CtdlRegisterProtoHook(cmd_lprm, "LPRM", "List public rooms");
              CtdlRegisterProtoHook(cmd_goto, "GOTO", "Goto a named room");
              CtdlRegisterProtoHook(cmd_whok, "WHOK", "List users who know this room");
              CtdlRegisterProtoHook(cmd_rdir, "RDIR", "List files in room directory");
              CtdlRegisterProtoHook(cmd_getr, "GETR", "Get room parameters");
              CtdlRegisterProtoHook(cmd_setr, "SETR", "Set room parameters");
              CtdlRegisterProtoHook(cmd_geta, "GETA", "Get the room aide name");
              CtdlRegisterProtoHook(cmd_seta, "SETA", "Set the room aide for this room");
              CtdlRegisterProtoHook(cmd_rinf, "RINF", "Fetch room info file");
              CtdlRegisterProtoHook(cmd_kill, "KILL", "Kill (delete) the current room");
              CtdlRegisterProtoHook(cmd_cre8, "CRE8", "Create a new room");
              CtdlRegisterProtoHook(cmd_einf, "EINF", "Enter info file for the current room");
              CtdlRegisterProtoHook(cmd_lflr, "LFLR", "List all known floors");
              CtdlRegisterProtoHook(cmd_cflr, "CFLR", "Create a new floor");
              CtdlRegisterProtoHook(cmd_kflr, "KFLR", "Kill a floor");
              CtdlRegisterProtoHook(cmd_eflr, "EFLR", "Edit a floor");
       }
        /* return our Subversion id for the Log */
       return "room_ops";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( user_ops  )

Definition at line 2099 of file user_ops.c.

{
       if (!threading) {
              CtdlRegisterProtoHook(cmd_user, "USER", "Submit username for login");
              CtdlRegisterProtoHook(cmd_pass, "PASS", "Complete login by submitting a password");
              CtdlRegisterProtoHook(cmd_creu, "CREU", "Create User");
              CtdlRegisterProtoHook(cmd_setp, "SETP", "Set the password for an account");
              CtdlRegisterProtoHook(cmd_getu, "GETU", "Get User parameters");
              CtdlRegisterProtoHook(cmd_setu, "SETU", "Set User parameters");
              CtdlRegisterProtoHook(cmd_slrp, "SLRP", "Set Last Read Pointer");
              CtdlRegisterProtoHook(cmd_invt, "INVT", "Invite a user to a room");
              CtdlRegisterProtoHook(cmd_kick, "KICK", "Kick a user out of a room");
              CtdlRegisterProtoHook(cmd_forg, "FORG", "Forget a room");
              CtdlRegisterProtoHook(cmd_gnur, "GNUR", "Get Next Unregistered User");
              CtdlRegisterProtoHook(cmd_vali, "VALI", "Validate new users");
              CtdlRegisterProtoHook(cmd_list, "LIST", "List users");
              CtdlRegisterProtoHook(cmd_chek, "CHEK", "assorted info we need to check at login");
              CtdlRegisterProtoHook(cmd_qusr, "QUSR", "check to see if a user exists");
              CtdlRegisterProtoHook(cmd_agup, "AGUP", "Administratively Get User Parameters");
              CtdlRegisterProtoHook(cmd_asup, "ASUP", "Administratively Set User Parameters");
              CtdlRegisterProtoHook(cmd_seen, "SEEN", "Manipulate seen/unread message flags");
              CtdlRegisterProtoHook(cmd_gtsn, "GTSN", "Fetch seen/unread message flags");
              CtdlRegisterProtoHook(cmd_view, "VIEW", "Set preferred view for user/room combination");
              CtdlRegisterProtoHook(cmd_renu, "RENU", "Rename a user");
              CtdlRegisterProtoHook(cmd_newu, "NEWU", "Log in as a new user");
       }
       /* return our Subversion id for the Log */
       return "user_ops";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( modules  )

Definition at line 1473 of file serv_extensions.c.

{
       if (!threading) {
              CtdlRegisterDebugFlagHook(HKEY("modules"), DebugModulesEnable, &DebugModules);

              CtdlRegisterProtoHook(cmd_log_get, "LOGP", "Print Log-parameters");
              CtdlRegisterProtoHook(cmd_log_set, "LOGS", "Set Log-parameters");
       }
       return "modules";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( autocompletion  )

Definition at line 219 of file serv_autocompletion.c.

                                 {
       if (!threading)
       {
              CtdlRegisterProtoHook(cmd_auto, "AUTO", "Do recipient autocompletion");
       }
       /* return our module name for the log */
       return "autocompletion";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( bio  )

Definition at line 138 of file serv_bio.c.

{
       if (!threading)
       {
               CtdlRegisterProtoHook(cmd_ebio, "EBIO", "Enter your bio");
              CtdlRegisterProtoHook(cmd_rbio, "RBIO", "Read a user's bio");
               CtdlRegisterProtoHook(cmd_lbio, "LBIO", "List users with bios");
       }
       /* return our module name for the log */
        return "bio";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( blog  )

Definition at line 94 of file serv_blog.c.

{
       if (!threading)
       {
              CtdlRegisterMessageHook(blog_upload_beforesave, EVT_BEFORESAVE);
       }
       
       /* return our module id for the Log */
       return "blog";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( c_ares_client  )

Definition at line 607 of file serv_c-ares-dns.c.

{
       if (!threading)
       {
              CtdlRegisterDebugFlagHook(HKEY("cares"), EnableDebugCAres, &DebugCAres);
              int r = ares_library_init(ARES_LIB_INIT_ALL);
              if (0 != r) {
                     
              }
       }
       return "c-ares";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( calendar  )

Definition at line 2589 of file serv_calendar.c.

{
       if (!threading)
       {

              /* Tell libical to return errors instead of aborting if it gets bad data */
              icalerror_errors_are_fatal = 0;

              /* Use our own application prefix in tzid's generated from system tzdata */
              icaltimezone_set_tzid_prefix("/citadel.org/");

              /* Initialize our hook functions */
              CtdlRegisterMessageHook(ical_obj_beforesave, EVT_BEFORESAVE);
              CtdlRegisterMessageHook(ical_obj_aftersave, EVT_AFTERSAVE);
              CtdlRegisterSessionHook(ical_CtdlCreateRoom, EVT_LOGIN, PRIO_LOGIN + 1);
              CtdlRegisterProtoHook(cmd_ical, "ICAL", "Citadel iCal commands");
              CtdlRegisterSessionHook(ical_session_startup, EVT_START, PRIO_START + 1);
              CtdlRegisterSessionHook(ical_session_shutdown, EVT_STOP, PRIO_STOP + 80);
              CtdlRegisterFixedOutputHook("text/calendar", ical_fixed_output);
              CtdlRegisterFixedOutputHook("application/ics", ical_fixed_output);
              CtdlRegisterCleanupHook(serv_calendar_destroy);
       }
       
       /* return our module name for the log */
       return "calendar";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( checkpoint  )

Definition at line 61 of file serv_checkpoint.c.

                             {
       if (threading)
       {
              CtdlRegisterSessionHook(cdb_checkpoint, EVT_TIMER, PRIO_CLEANUP + 10);
       }
       /* return our module name for the log */
       return "checkpoint";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( virus  )

Definition at line 197 of file serv_virus.c.

{
       if (!threading)
       {
              CtdlRegisterMessageHook(clamd, EVT_SMTPSCAN);
       }
       
       /* return our module name for the log */
        return "virus";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( dspam  )

Definition at line 239 of file serv_dspam.c.

{
       return "disabled.";
       if (!threading)
       {
#ifdef HAVE_LIBDSPAM

              ctdl_dspam_init();
              CtdlRegisterCleanupHook(serv_dspam_shutdown);
              CtdlRegisterProtoHook(cmd_tspam, "SPAM", "Tag Message as Spam/Ham to learn DSPAM");

               CtdlRegisterRoomHook(serv_dspam_room);


#else  /* HAVE_LIBDSPAM */

              syslog(LOG_INFO, "This server is missing libdspam Spam filtering will be disabled.\n");

#endif /* HAVE_LIBDSPAM */
       }
       
        /* return our module name for the log */
       return "dspam";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( event_client  )

Definition at line 865 of file serv_eventclient.c.

Here is the call graph for this function:

CTDL_MODULE_INIT ( expire  )

Definition at line 947 of file serv_expire.c.

{
       if (!threading)
       {
              CtdlRegisterProtoHook(cmd_tdap, "TDAP", "Manually initiate auto-purger");
              CtdlRegisterProtoHook(cmd_gpex, "GPEX", "Get expire policy");
              CtdlRegisterProtoHook(cmd_spex, "SPEX", "Set expire policy");
              CtdlRegisterSessionHook(purge_databases, EVT_TIMER, PRIO_CLEANUP + 20);
       }

       /* return our module name for the log */
       return "expire";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( extnotify  )

Definition at line 469 of file extnotify_main.c.

{
       if (!threading)
       {
              create_extnotify_queue();
              CtdlRegisterSessionHook(do_extnotify_queue, EVT_TIMER, PRIO_SEND + 10);
       }
       /* return our module name for the log */
       return "extnotify";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( fulltext  )

Definition at line 500 of file serv_fulltext.c.

Here is the call graph for this function:

CTDL_MODULE_INIT ( imap  )

Definition at line 1665 of file serv_imap.c.

{
       if (ImapCmds == NULL)
              ImapCmds = NewHash(1, NULL);

       RegisterImapCMD("NOOP", "", imap_noop, I_FLAG_NONE);
       RegisterImapCMD("CHECK", "", imap_noop, I_FLAG_NONE);
       RegisterImapCMD("ID", "", imap_id, I_FLAG_NONE);
       RegisterImapCMD("LOGOUT", "", imap_logout, I_FLAG_NONE);
       RegisterImapCMD("LOGIN", "", imap_login, I_FLAG_NONE);
       RegisterImapCMD("AUTHENTICATE", "", imap_authenticate, I_FLAG_NONE);
       RegisterImapCMD("CAPABILITY", "", imap_capability, I_FLAG_NONE);
#ifdef HAVE_OPENSSL
       RegisterImapCMD("STARTTLS", "", imap_starttls, I_FLAG_NONE);
#endif

       /* The commans below require a logged-in state */
       RegisterImapCMD("SELECT", "", imap_select, I_FLAG_LOGGED_IN);
       RegisterImapCMD("EXAMINE", "", imap_select, I_FLAG_LOGGED_IN);
       RegisterImapCMD("LSUB", "", imap_list, I_FLAG_LOGGED_IN);
       RegisterImapCMD("LIST", "", imap_list, I_FLAG_LOGGED_IN);
       RegisterImapCMD("CREATE", "", imap_create, I_FLAG_LOGGED_IN);
       RegisterImapCMD("DELETE", "", imap_delete, I_FLAG_LOGGED_IN);
       RegisterImapCMD("RENAME", "", imap_rename, I_FLAG_LOGGED_IN);
       RegisterImapCMD("STATUS", "", imap_status, I_FLAG_LOGGED_IN);
       RegisterImapCMD("SUBSCRIBE", "", imap_subscribe, I_FLAG_LOGGED_IN);
       RegisterImapCMD("UNSUBSCRIBE", "", imap_unsubscribe, I_FLAG_LOGGED_IN);
       RegisterImapCMD("APPEND", "", imap_append, I_FLAG_LOGGED_IN);
       RegisterImapCMD("NAMESPACE", "", imap_namespace, I_FLAG_LOGGED_IN);
       RegisterImapCMD("SETACL", "", imap_setacl, I_FLAG_LOGGED_IN);
       RegisterImapCMD("DELETEACL", "", imap_deleteacl, I_FLAG_LOGGED_IN);
       RegisterImapCMD("GETACL", "", imap_getacl, I_FLAG_LOGGED_IN);
       RegisterImapCMD("LISTRIGHTS", "", imap_listrights, I_FLAG_LOGGED_IN);
       RegisterImapCMD("MYRIGHTS", "", imap_myrights, I_FLAG_LOGGED_IN);
       RegisterImapCMD("GETMETADATA", "", imap_getmetadata, I_FLAG_LOGGED_IN);
       RegisterImapCMD("SETMETADATA", "", imap_setmetadata, I_FLAG_LOGGED_IN);

       /* The commands below require the SELECT state on a mailbox */
       RegisterImapCMD("FETCH", "", imap_fetch, I_FLAG_LOGGED_IN | I_FLAG_SELECT | I_FLAG_UNTAGGED);
       RegisterImapCMD("UID", "FETCH", imap_uidfetch, I_FLAG_LOGGED_IN | I_FLAG_SELECT);
       RegisterImapCMD("SEARCH", "", imap_search, I_FLAG_LOGGED_IN | I_FLAG_SELECT | I_FLAG_UNTAGGED);
       RegisterImapCMD("UID", "SEARCH", imap_uidsearch, I_FLAG_LOGGED_IN | I_FLAG_SELECT);
       RegisterImapCMD("STORE", "", imap_store, I_FLAG_LOGGED_IN | I_FLAG_SELECT | I_FLAG_UNTAGGED);
       RegisterImapCMD("UID", "STORE", imap_uidstore, I_FLAG_LOGGED_IN | I_FLAG_SELECT);
       RegisterImapCMD("COPY", "", imap_copy, I_FLAG_LOGGED_IN | I_FLAG_SELECT);
       RegisterImapCMD("UID", "COPY", imap_uidcopy, I_FLAG_LOGGED_IN | I_FLAG_SELECT);
       RegisterImapCMD("EXPUNGE", "", imap_expunge, I_FLAG_LOGGED_IN | I_FLAG_SELECT);
       RegisterImapCMD("UID", "EXPUNGE", imap_expunge, I_FLAG_LOGGED_IN | I_FLAG_SELECT);
       RegisterImapCMD("CLOSE", "", imap_close, I_FLAG_LOGGED_IN | I_FLAG_SELECT);

       if (!threading)
       {
              CtdlRegisterDebugFlagHook(HKEY("imapsrv"), SetIMAPDebugEnabled, &IMAPDebugEnabled);
              CtdlRegisterServiceHook(config.c_imap_port,
                                   NULL, imap_greeting, imap_command_loop, NULL, CitadelServiceIMAP);
#ifdef HAVE_OPENSSL
              CtdlRegisterServiceHook(config.c_imaps_port,
                                   NULL, imaps_greeting, imap_command_loop, NULL, CitadelServiceIMAPS);
#endif
              CtdlRegisterSessionHook(imap_cleanup_function, EVT_STOP, PRIO_STOP + 30);
              CtdlRegisterCleanupHook(imap_cleanup);
       }
       
       /* return our module name for the log */
       return "imap";
}

Definition at line 152 of file serv_inetcfg.c.

{
       if (!threading)
       {
              CtdlRegisterMessageHook(inetcfg_aftersave, EVT_AFTERSAVE);
              inetcfg_init();
              CtdlRegisterCleanupHook(clenaup_inetcfg);
       }
       
       /* return our module name for the log */
       return "inetcfg";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( instmsg  )

Definition at line 594 of file serv_instmsg.c.

{
       if (!threading)
       {
              CtdlRegisterProtoHook(cmd_gexp, "GEXP", "Get instant messages");
              CtdlRegisterProtoHook(cmd_sexp, "SEXP", "Send an instant message");
              CtdlRegisterProtoHook(cmd_dexp, "DEXP", "Disable instant messages");
              CtdlRegisterProtoHook(cmd_reqt, "REQT", "Request client termination");
              CtdlRegisterSessionHook(cmd_gexp_async, EVT_ASYNC, PRIO_ASYNC + 1);
              CtdlRegisterSessionHook(delete_instant_messages, EVT_STOP, PRIO_STOP + 1);
              CtdlRegisterXmsgHook(send_instant_message, XMSG_PRI_LOCAL);
              CtdlRegisterSessionHook(instmsg_timer, EVT_TIMER, PRIO_CLEANUP + 400);
              CtdlRegisterSessionHook(instmsg_shutdown, EVT_SHUTDOWN, PRIO_SHUTDOWN + 10);
       }
       
       /* return our module name for the log */
       return "instmsg";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( listsub  )

Definition at line 578 of file serv_listsub.c.

{
       if (!threading)
       {
              CtdlRegisterProtoHook(cmd_subs, "SUBS", "List subscribe/unsubscribe");
       }
       
       /* return our module name for the log */
       return "listsub";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( managesieve  )

Definition at line 659 of file serv_managesieve.c.

{
       if (!threading)
       {
              CtdlRegisterServiceHook(config.c_managesieve_port,
                                   NULL,
                                   managesieve_greeting,
                                   managesieve_command_loop,
                                   NULL, 
                                   CitadelServiceManageSieve);
              CtdlRegisterSessionHook(managesieve_cleanup_function, EVT_STOP, PRIO_STOP + 30);
       }
       
       /* return our module name for the log */
       return "managesieve";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( migrate  )

Definition at line 994 of file serv_migrate.c.

{
       if (!threading)
       {
              CtdlRegisterProtoHook(cmd_migr, "MIGR", "Across-the-wire migration");
              CtdlRegisterProtoHook(cmd_migr, "ARTV", "Across-the-wire migration (legacy syntax)");
       }
       
       /* return our module name for the log */
       return "migrate";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( mrtg  )

Definition at line 177 of file serv_mrtg.c.

{
       if (!threading)
       {
               CtdlRegisterProtoHook(cmd_mrtg, "MRTG", "Supply stats to MRTG");
       }
       
       /* return our module name for the log */
        return "mrtg";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( netconfig  )

Definition at line 570 of file serv_netconfig.c.

{
       if (!threading)
       {
              CtdlRegisterProtoHook(cmd_gnet, "GNET", "Get network config");
              CtdlRegisterProtoHook(cmd_snet, "SNET", "Set network config");
              CtdlRegisterProtoHook(cmd_netp, "NETP", "Identify as network poller");
       }
       return "netconfig";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( netfilter  )

Definition at line 188 of file serv_netfilter.c.

{
       if (!threading)
       {
              CtdlRegisterNetprocHook(filter_the_idiots);
       }
       
       /* return our module name for the log */
       return "netfilter";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( network_spool  )

Definition at line 1010 of file serv_netspool.c.

{
       if (!threading)
       {
              create_spool_dirs();
       }
       return "network_spool";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( network  )
CTDL_MODULE_INIT ( network_client  )

Definition at line 1040 of file serv_networkclient.c.

{
       if (!threading)
       {
              CtdlFillSystemContext(&networker_client_CC, "CitNetworker");
              
              CtdlRegisterSessionHook(network_do_clientqueue, EVT_TIMER, PRIO_SEND + 10);
              CtdlRegisterDebugFlagHook(HKEY("networkclient"), LogDebugEnableNetworkClient, &NetworkClientDebugEnabled);

       }
       return "networkclient";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( newuser  )

Definition at line 109 of file serv_newuser.c.

{
       if (!threading)
       {
              CtdlRegisterSessionHook(CopyNewUserGreetings, EVT_LOGIN, PRIO_LOGIN + 1);
       }
       
       /* return our module name for the log */
       return "newuser";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( notes  )

Definition at line 178 of file serv_notes.c.

{
       if (!threading)
       {
              CtdlRegisterMessageHook(serv_notes_beforesave, EVT_BEFORESAVE);
       }
       
       /* return our module name for the log */
       return "notes";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( openid_rp  )

Definition at line 1129 of file serv_openid_rp.c.

{
       if (!threading) {
// evcurl call this for us. curl_global_init(CURL_GLOBAL_ALL);

              /* Only enable the OpenID command set when native mode authentication is in use. */
              if (config.c_auth_mode == AUTHMODE_NATIVE) {
                     CtdlRegisterProtoHook(cmd_oids, "OIDS", "Setup OpenID authentication");
                     CtdlRegisterProtoHook(cmd_oidf, "OIDF", "Finalize OpenID authentication");
                     CtdlRegisterProtoHook(cmd_oidl, "OIDL", "List OpenIDs associated with an account");
                     CtdlRegisterProtoHook(cmd_oidd, "OIDD", "Detach an OpenID from an account");
                     CtdlRegisterProtoHook(cmd_oidc, "OIDC", "Create new user after validating OpenID");
                     CtdlRegisterProtoHook(cmd_oida, "OIDA", "List all OpenIDs in the database");
              }
              CtdlRegisterSessionHook(openid_cleanup_function, EVT_LOGOUT, PRIO_LOGOUT + 10);
              CtdlRegisterUserHook(openid_purge, EVT_PURGEUSER);
              openid_level_supported = 1; /* This module supports OpenID 1.0 only */
       }

       /* return our module name for the log */
       return "openid_rp";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( pop3  )

Definition at line 664 of file serv_pop3.c.

{
       if(!threading)
       {
              CtdlRegisterServiceHook(config.c_pop3_port,
                                   NULL,
                                   pop3_greeting,
                                   pop3_command_loop,
                                   NULL,
                                   CitadelServicePop3);
#ifdef HAVE_OPENSSL
              CtdlRegisterServiceHook(config.c_pop3s_port,
                                   NULL,
                                   pop3s_greeting,
                                   pop3_command_loop,
                                   NULL,
                                   CitadelServicePop3S);
#endif
              CtdlRegisterSessionHook(pop3_cleanup_function, EVT_STOP, PRIO_STOP + 30);
       }
       
       /* return our module name for the log */
       return "pop3";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( pop3client  )

Definition at line 1255 of file serv_pop3client.c.

{
       if (!threading)
       {
              CtdlFillSystemContext(&pop3_client_CC, "POP3aggr");
              pthread_mutex_init(&POP3QueueMutex, NULL);
              POP3QueueRooms = NewHash(1, lFlathash);
              POP3FetchUrls = NewHash(1, NULL);
              CtdlRegisterSessionHook(pop3client_scan, EVT_TIMER, PRIO_AGGR + 50);
              CtdlRegisterEVCleanupHook(pop3_cleanup);
              CtdlRegisterDebugFlagHook(HKEY("pop3client"), LogDebugEnablePOP3Client, &POP3ClientDebugEnabled);
       }

       /* return our module id for the log */
       return "pop3client";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( roomchat  )

Definition at line 265 of file serv_roomchat.c.

{
       if (!threading)
       {
              CtdlRegisterProtoHook(cmd_rcht, "RCHT", "Participate in real time chat in a room");
              CtdlRegisterSessionHook(roomchat_timer, EVT_TIMER, PRIO_CLEANUP + 400);
              CtdlRegisterSessionHook(roomchat_shutdown, EVT_SHUTDOWN, PRIO_SHUTDOWN + 55);
       }
       
       /* return our module name for the log */
       return "roomchat";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( rssparser  )

Definition at line 1094 of file rss_atom_parser.c.

{
       if (!threading)
       {
              StartHandlers = NewHash(1, NULL);
              EndHandlers = NewHash(1, NULL);

              AddRSSStartHandler(RSS_item_rss_start,     RSS_UNSET, HKEY("rss"));
              AddRSSStartHandler(RSS_item_rdf_start,     RSS_UNSET, HKEY("rdf"));
              AddRSSStartHandler(ATOM_item_feed_start,   RSS_UNSET, HKEY("feed"));
              AddRSSStartHandler(RSS_item_item_start,    RSS_RSS, HKEY("item"));
              AddRSSStartHandler(ATOM_item_entry_start,  RSS_ATOM, HKEY("entry"));
              AddRSSStartHandler(ATOM_item_link_start,   RSS_ATOM, HKEY("link"));

              AddRSSEndHandler(ATOMRSS_item_title_end,   RSS_ATOM|RSS_RSS|RSS_REQUIRE_BUF, HKEY("title"));
              AddRSSEndHandler(RSS_item_guid_end,        RSS_RSS|RSS_REQUIRE_BUF, HKEY("guid"));
              AddRSSEndHandler(ATOM_item_id_end,         RSS_ATOM|RSS_REQUIRE_BUF, HKEY("id"));
              AddRSSEndHandler(RSS_item_link_end,        RSS_RSS|RSS_REQUIRE_BUF, HKEY("link"));
#if 0
// hm, rss to the comments of that blog, might be interesting in future, but...
              AddRSSEndHandler(RSS_item_relink_end,      RSS_RSS|RSS_REQUIRE_BUF, HKEY("commentrss"));
// comment count...
              AddRSSEndHandler(RSS_item_relink_end,      RSS_RSS|RSS_REQUIRE_BUF, HKEY("comments"));
#endif
              AddRSSEndHandler(RSSATOM_item_title_end,   RSS_ATOM|RSS_RSS|RSS_REQUIRE_BUF, HKEY("title"));
              AddRSSEndHandler(ATOM_item_content_end,    RSS_ATOM|RSS_REQUIRE_BUF, HKEY("content"));
              AddRSSEndHandler(RSS_item_description_end, RSS_RSS|RSS_ATOM|RSS_REQUIRE_BUF, HKEY("encoded"));
              AddRSSEndHandler(ATOM_item_summary_end,    RSS_ATOM|RSS_REQUIRE_BUF, HKEY("summary"));
              AddRSSEndHandler(RSS_item_description_end, RSS_RSS|RSS_REQUIRE_BUF, HKEY("description"));
              AddRSSEndHandler(ATOM_item_published_end,  RSS_ATOM|RSS_REQUIRE_BUF, HKEY("published"));
              AddRSSEndHandler(ATOM_item_updated_end,    RSS_ATOM|RSS_REQUIRE_BUF, HKEY("updated"));
              AddRSSEndHandler(RSS_item_pubdate_end,     RSS_RSS|RSS_REQUIRE_BUF, HKEY("pubdate"));
              AddRSSEndHandler(RSS_item_date_end,        RSS_RSS|RSS_REQUIRE_BUF, HKEY("date"));
              AddRSSEndHandler(RSS_item_author_end,      RSS_RSS|RSS_REQUIRE_BUF, HKEY("author"));
              AddRSSEndHandler(RSS_item_creator_end,     RSS_RSS|RSS_REQUIRE_BUF, HKEY("creator"));
/* <author> */
              AddRSSEndHandler(ATOM_item_email_end,      RSS_ATOM|RSS_REQUIRE_BUF, HKEY("email"));
              AddRSSEndHandler(ATOM_item_name_end,       RSS_ATOM|RSS_REQUIRE_BUF, HKEY("name"));
              AddRSSEndHandler(ATOM_item_uri_end,        RSS_ATOM|RSS_REQUIRE_BUF, HKEY("uri"));
/* </author> */
              AddRSSEndHandler(RSS_item_item_end,        RSS_RSS, HKEY("item"));
              AddRSSEndHandler(RSS_item_rss_end,         RSS_RSS, HKEY("rss"));
              AddRSSEndHandler(RSS_item_rdf_end,         RSS_RSS, HKEY("rdf"));
              AddRSSEndHandler(ATOM_item_entry_end,      RSS_ATOM, HKEY("entry"));


/* at the start of atoms: <seq> <li>link to resource</li></seq> ignore them. */
              AddRSSStartHandler(RSSATOM_item_ignore,      RSS_RSS|RSS_ATOM, HKEY("seq"));
              AddRSSEndHandler  (RSSATOM_item_ignore,      RSS_RSS|RSS_ATOM, HKEY("seq"));
              AddRSSStartHandler(RSSATOM_item_ignore,      RSS_RSS|RSS_ATOM, HKEY("li"));
              AddRSSEndHandler  (RSSATOM_item_ignore,      RSS_RSS|RSS_ATOM, HKEY("li"));

/* links to other feed generators... */
              AddRSSStartHandler(RSSATOM_item_ignore,      RSS_RSS|RSS_ATOM, HKEY("feedflare"));
              AddRSSEndHandler  (RSSATOM_item_ignore,      RSS_RSS|RSS_ATOM, HKEY("feedflare"));
              AddRSSStartHandler(RSSATOM_item_ignore,      RSS_RSS|RSS_ATOM, HKEY("browserfriendly"));
              AddRSSEndHandler  (RSSATOM_item_ignore,      RSS_RSS|RSS_ATOM, HKEY("browserfriendly"));

              KnownNameSpaces = NewHash(1, NULL);
              Put(KnownNameSpaces, HKEY("http://a9.com/-/spec/opensearch/1.1/"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://a9.com/-/spec/opensearchrss/1.0/"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://backend.userland.com/creativeCommonsRssModule"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://purl.org/atom/ns#"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://purl.org/dc/elements/1.1/"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://purl.org/rss/1.0/"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://purl.org/rss/1.0/modules/content/"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://purl.org/rss/1.0/modules/slash/"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://purl.org/rss/1.0/modules/syndication/"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://purl.org/rss/1.0/"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://purl.org/syndication/thread/1.0"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://rssnamespace.org/feedburner/ext/1.0"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://schemas.google.com/g/2005"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://webns.net/mvcb/"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://web.resource.org/cc/"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://wellformedweb.org/CommentAPI/"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://www.georss.org/georss"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://www.w3.org/1999/xhtml"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://www.w3.org/1999/02/22-rdf-syntax-ns#"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://www.w3.org/1999/02/22-rdf-syntax-ns#"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://www.w3.org/2003/01/geo/wgs84_pos#"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("http://www.w3.org/2005/Atom"), NULL, reference_free_handler);
              Put(KnownNameSpaces, HKEY("urn:flickr:"), NULL, reference_free_handler);
#if 0
              /* we don't like these namespaces because of they shadow our usefull parameters. */
              Put(KnownNameSpaces, HKEY("http://search.yahoo.com/mrss/"), NULL, reference_free_handler);
#endif
              CtdlRegisterDebugFlagHook(HKEY("RSSAtomParser"), LogDebugEnableRSSATOMParser, &RSSAtomParserDebugEnabled);
              CtdlRegisterCleanupHook(rss_parser_cleanup);
       }
       return "rssparser";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( rssclient  )

Definition at line 586 of file serv_rssclient.c.

{
       if (threading)
       {
              CtdlFillSystemContext(&rss_CC, "rssclient");
              pthread_mutex_init(&RSSQueueMutex, NULL);
              RSSQueueRooms = NewHash(1, lFlathash);
              RSSFetchUrls = NewHash(1, NULL);
              syslog(LOG_INFO, "%s\n", curl_version());
              CtdlRegisterSessionHook(rssclient_scan, EVT_TIMER, PRIO_AGGR + 300);
              CtdlRegisterEVCleanupHook(rss_cleanup);
              CtdlRegisterDebugFlagHook(HKEY("rssclient"), LogDebugEnableRSSClient, &RSSClientDebugEnabled);
       }
       return "rssclient";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( rwho  )

Definition at line 281 of file serv_rwho.c.

{
       if(!threading)
       {
               CtdlRegisterProtoHook(cmd_rwho, "RWHO", "Display who is online");
              CtdlRegisterProtoHook(cmd_hchg, "HCHG", "Masquerade hostname");
               CtdlRegisterProtoHook(cmd_rchg, "RCHG", "Masquerade roomname");
              CtdlRegisterProtoHook(cmd_uchg, "UCHG", "Masquerade username");
               CtdlRegisterProtoHook(cmd_stel, "STEL", "Enter/exit stealth mode");
       }
       
       /* return our module name for the log */
        return "rwho";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( sieve  )

Definition at line 1349 of file serv_sieve.c.

{
       if (!threading)
       {
              CtdlRegisterDebugFlagHook(HKEY("sieve"), LogSieveDebugEnable, &SieveDebugEnable);
              ctdl_sieve_init();
              CtdlRegisterProtoHook(cmd_msiv, "MSIV", "Manage Sieve scripts");
               CtdlRegisterRoomHook(serv_sieve_room);
              CtdlRegisterSessionHook(perform_sieve_processing, EVT_HOUSE, PRIO_HOUSE + 10);
              CtdlRegisterCleanupHook(cleanup_sieve);
       }
       
        /* return our module name for the log */
       return "sieve";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( smtp  )
CTDL_MODULE_INIT ( smtp_eventclient  )

Definition at line 791 of file serv_smtpeventclient.c.

{
       if (!threading)
              CtdlRegisterDebugFlagHook(HKEY("smtpeventclient"), LogDebugEnableSMTPClient, &SMTPClientDebugEnabled);
       return "smtpeventclient";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( smtp_queu  )

Definition at line 1099 of file serv_smtpqueue.c.

{
       char *pstr;

       if (!threading)
       {
              pstr = getenv("CITSERVER_n_session_max");
              if ((pstr != NULL) && (*pstr != '\0'))
                     max_sessions_for_outbound_smtp = atol(pstr); /* how many sessions might be active till we stop adding more smtp jobs */

              pstr = getenv("CITSERVER_smtp_n_delay_count");
              if ((pstr != NULL) && (*pstr != '\0'))
                     ndelay_count = atol(pstr); /* every n queued messages we will sleep... */

              pstr = getenv("CITSERVER_smtp_delay");
              if ((pstr != NULL) && (*pstr != '\0'))
                     delay_msec = atol(pstr) * 1000; /* this many seconds. */




              CtdlFillSystemContext(&smtp_queue_CC, "SMTP_Send");
              ActiveQItems = NewHash(1, lFlathash);
              pthread_mutex_init(&ActiveQItemsLock, NULL);

              QItemHandlers = NewHash(0, NULL);

              RegisterQItemHandler(HKEY("msgid"),              QItem_Handle_MsgID);
              RegisterQItemHandler(HKEY("envelope_from"),      QItem_Handle_EnvelopeFrom);
              RegisterQItemHandler(HKEY("retry"),              QItem_Handle_retry);
              RegisterQItemHandler(HKEY("attempted"),          QItem_Handle_Attempted);
              RegisterQItemHandler(HKEY("remote"),             QItem_Handle_Recipient);
              RegisterQItemHandler(HKEY("bounceto"),           QItem_Handle_BounceTo);
              RegisterQItemHandler(HKEY("source_room"), QItem_Handle_SenderRoom);
              RegisterQItemHandler(HKEY("submitted"),          QItem_Handle_Submitted);

              smtp_init_spoolout();

              CtdlRegisterEVCleanupHook(smtp_evq_cleanup);

              CtdlRegisterProtoHook(cmd_smtp, "SMTP", "SMTP utility commands");
              CtdlRegisterSessionHook(smtp_do_queue, EVT_TIMER, PRIO_SEND + 10);
       }

       /* return our Subversion id for the Log */
       return "smtpeventclient";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( spam  )

Definition at line 198 of file serv_spam.c.

{
       if (!threading)
       {
              CtdlRegisterMessageHook(spam_assassin, EVT_SMTPSCAN);
       }
       
       /* return our module name for the log */
        return "spam";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( test  )

Definition at line 71 of file serv_test.c.

Here is the call graph for this function:

CTDL_MODULE_INIT ( urldeshortener  )

Definition at line 337 of file serv_expand_shorter_urls.c.

{
       if (threading)
       {
              syslog(LOG_INFO, "%s\n", curl_version());
       }
       else 
       {
              LoadUrlShorteners ();
                CtdlRegisterCleanupHook(shorter_url_cleanup);
       }
       return "UrlShortener";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( vcard  )

Definition at line 1446 of file serv_vcard.c.

{
       struct ctdlroom qr;
       char filename[256];
       FILE *fp;
       int rv = 0;

       if (!threading)
       {
              CtdlRegisterSessionHook(vcard_session_login_hook, EVT_LOGIN, PRIO_LOGIN + 70);
              CtdlRegisterMessageHook(vcard_upload_beforesave, EVT_BEFORESAVE);
              CtdlRegisterMessageHook(vcard_upload_aftersave, EVT_AFTERSAVE);
              CtdlRegisterDeleteHook(vcard_delete_remove);
              CtdlRegisterProtoHook(cmd_regi, "REGI", "Enter registration info");
              CtdlRegisterProtoHook(cmd_greg, "GREG", "Get registration info");
              CtdlRegisterProtoHook(cmd_igab, "IGAB", "Initialize Global Address Book");
              CtdlRegisterProtoHook(cmd_qdir, "QDIR", "Query Directory");
              CtdlRegisterProtoHook(cmd_gvsn, "GVSN", "Get Valid Screen Names");
              CtdlRegisterProtoHook(cmd_gvea, "GVEA", "Get Valid Email Addresses");
              CtdlRegisterProtoHook(cmd_dvca, "DVCA", "Dump VCard Addresses");
              CtdlRegisterUserHook(vcard_newuser, EVT_NEWUSER);
              CtdlRegisterUserHook(vcard_purge, EVT_PURGEUSER);
              CtdlRegisterNetprocHook(vcard_extract_from_network);
              CtdlRegisterSessionHook(store_harvested_addresses, EVT_TIMER, PRIO_CLEANUP + 470);
              CtdlRegisterFixedOutputHook("text/x-vcard", vcard_fixed_output);
              CtdlRegisterFixedOutputHook("text/vcard", vcard_fixed_output);

              /* Create the Global ADdress Book room if necessary */
              CtdlCreateRoom(ADDRESS_BOOK_ROOM, 3, "", 0, 1, 0, VIEW_ADDRESSBOOK);

              /* Set expiration policy to manual; otherwise objects will be lost! */
              if (!CtdlGetRoomLock(&qr, ADDRESS_BOOK_ROOM)) {
                     qr.QRep.expire_mode = EXPIRE_MANUAL;
                     qr.QRdefaultview = VIEW_ADDRESSBOOK;      /* 2 = address book view */
                     CtdlPutRoomLock(&qr);

                     /*
                      * Also make sure it has a netconfig file, so the networker runs
                      * on this room even if we don't share it with any other nodes.
                      * This allows the CANCEL messages (i.e. "Purge this vCard") to be
                      * purged.
                      */
                     assoc_file_name(filename, sizeof filename, &qr, ctdl_netcfg_dir);
                     fp = fopen(filename, "a");
                     if (fp != NULL) fclose(fp);
                     rv = chown(filename, CTDLUID, (-1));
                     if (rv == -1)
                            syslog(LOG_EMERG, "Failed to adjust ownership of: %s [%s]", 
                                   filename, strerror(errno));
              }

              /* for postfix tcpdict */
              CtdlRegisterServiceHook(config.c_pftcpdict_port, /* Postfix */
                                   NULL,
                                   check_get_greeting,
                                   check_get,
                                   NULL,
                                   CitadelServiceDICT_TCP);
       }
       
       /* return our module name for the log */
       return "vcard";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( wiki  )

Definition at line 687 of file serv_wiki.c.

{
       if (!threading)
       {
              CtdlRegisterMessageHook(wiki_upload_beforesave, EVT_BEFORESAVE);
              CtdlRegisterProtoHook(cmd_wiki, "WIKI", "Commands related to Wiki management");
       }

       /* return our module name for the log */
       return "wiki";
}

Here is the call graph for this function:

CTDL_MODULE_INIT ( xmpp  )
CTDL_MODULE_UPGRADE ( upgrade  )

Definition at line 386 of file serv_upgrade.c.

{
       check_server_upgrades();
       
       /* return our module id for the Log */
       return "upgrade";
}

Here is the call graph for this function:

void initialise_modules ( int  threading)

Definition at line 25 of file modules_init.c.

{
    long filter;
    const char *pMod;

    if (threading) {
        MODM_syslog(LOG_DEBUG, "Initializing, CtdlThreads enabled.\n");
    }
    else {
        MODM_syslog(LOG_INFO, "Initializing. CtdlThreads not yet enabled.\n");
    }
/* static server initialization: */
        pMod = CTDL_INIT_CALL(citserver);
        MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);

        pMod = CTDL_INIT_CALL(control);
        MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);

        pMod = CTDL_INIT_CALL(euidindex);
        MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);

        pMod = CTDL_INIT_CALL(file_ops);
        MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);

        pMod = CTDL_INIT_CALL(msgbase);
        MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);

        pMod = CTDL_INIT_CALL(room_ops);
        MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);

        pMod = CTDL_INIT_CALL(user_ops);
        MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
/* dynamic modules: */

       pMod = CTDL_INIT_CALL(modules);
        MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);

       pMod = CTDL_INIT_CALL(autocompletion);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(bio);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(blog);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(c_ares_client);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(calendar);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(checkpoint);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(virus);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(dspam);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(event_client);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(expire);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(extnotify);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(fulltext);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(imap);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(inetcfg);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(instmsg);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(listsub);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(managesieve);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(migrate);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(mrtg);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(netconfig);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(netfilter);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(network_spool);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(network);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(network_client);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(newuser);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(notes);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(openid_rp);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(pop3);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(pop3client);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(roomchat);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(rssparser);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(rssclient);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(rwho);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(sieve);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(smtp);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(smtp_eventclient);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(smtp_queu);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(spam);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(test);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(urldeshortener);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(vcard);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(wiki);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);
       pMod = CTDL_INIT_CALL(xmpp);
       MOD_syslog(LOG_DEBUG, "Loaded module: %s\n", pMod);


       for (filter = 1; filter != 0; filter = filter << 1)
              if ((filter & DetailErrorFlags) != 0)
                     LogPrintMessages(filter);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void upgrade_modules ( void  )

Definition at line 24 of file modules_upgrade.c.

{
    const char *pMod;

    MODM_syslog(LOG_INFO, "Upgrade modules.\n");

       pMod = CTDL_UPGRADE_CALL(upgrade);
       MOD_syslog(LOG_INFO, "%s\n", pMod);
}

Here is the caller graph for this function:


Variable Documentation

size_t nSizErrmsg