From: Art Cancro Date: Mon, 28 Aug 2023 15:13:42 +0000 (-0400) Subject: FreeBSD compatibility (first of several commits) X-Git-Tag: v989~32 X-Git-Url: https://code.citadel.org/?a=commitdiff_plain;h=e9b2bc64bf79a961b294f4961d7ce8f0378aca0e;p=citadel.git FreeBSD compatibility (first of several commits) --- diff --git a/citadel/server/citadel_defs.h b/citadel/server/citadel_defs.h index 48fe0760a..04ab4e7cb 100644 --- a/citadel/server/citadel_defs.h +++ b/citadel/server/citadel_defs.h @@ -11,8 +11,8 @@ // Suppress these compiler warnings #pragma GCC diagnostic ignored "-Wcast-qual" -#pragma GCC diagnostic ignored "-Wdiscarded-qualifiers" -#pragma GCC diagnostic ignored "-Wformat-truncation" +// #pragma GCC diagnostic ignored "-Wdiscarded-qualifiers" // this doesn't work on FreeBSD +// #pragma GCC diagnostic ignored "-Wformat-truncation" // nor does this #pragma GCC diagnostic ignored "-Wdeprecated-declarations" #include "sysdep.h" diff --git a/citadel/server/config.c b/citadel/server/config.c index 0f1432618..de80290bb 100644 --- a/citadel/server/config.c +++ b/citadel/server/config.c @@ -10,7 +10,7 @@ #include #include #include -#include +//#include #include #include #include diff --git a/citadel/server/context.c b/citadel/server/context.c index cb7cf9334..280c4f283 100644 --- a/citadel/server/context.c +++ b/citadel/server/context.c @@ -15,17 +15,17 @@ #include "control.h" #include "config.h" -pthread_key_t MyConKey; /* TSD key for MyContext() */ +pthread_key_t MyConKey; // TSD key for MyContext() CitContext masterCC; CitContext *ContextList = NULL; -time_t last_purge = 0; /* Last dead session purge */ -int num_sessions = 0; /* Current number of sessions */ +time_t last_purge = 0; // Last dead session purge +int num_sessions = 0; // Current number of sessions int next_pid = 0; -/* Flag for single user mode */ +// Flag for single user mode static int want_single_user = 0; -/* Try to go single user */ +// Try to go single user int CtdlTrySingleUser(void) { int can_do = 0; @@ -65,12 +65,10 @@ int CtdlIsSingleUser(void) { } -/* - * Locate a context by its session number and terminate it if the user is able. - * User can NOT terminate their current session. - * User CAN terminate any other session that has them logged in. - * Aide CAN terminate any session except the current one. - */ +// Locate a context by its session number and terminate it if the user is able. +// User can NOT terminate their current session. +// User CAN terminate any other session that has them logged in. +// Aide CAN terminate any session except the current one. int CtdlTerminateOtherSession (int session_num) { int ret = 0; CitContext *ccptr; @@ -127,12 +125,10 @@ void CtdlBumpNewMailCounter(long which_user) { } -/* - * Check to see if a user is currently logged in - * Take care with what you do as a result of this test. - * The user may not have been logged in when this function was called BUT - * because of threading the user might be logged in before you test the result. - */ +// Check to see if a user is currently logged in +// Take care with what you do as a result of this test. +// The user may not have been logged in when this function was called BUT +// because of threading the user might be logged in before you test the result. int CtdlIsUserLoggedIn(char *user_name) { CitContext *cptr; int ret = 0; @@ -149,13 +145,11 @@ int CtdlIsUserLoggedIn(char *user_name) { } -/* - * Check to see if a user is currently logged in. - * Basically same as CtdlIsUserLoggedIn() but uses the user number instead. - * Take care with what you do as a result of this test. - * The user may not have been logged in when this function was called BUT - * because of threading the user might be logged in before you test the result. - */ +// Check to see if a user is currently logged in. +// Basically same as CtdlIsUserLoggedIn() but uses the user number instead. +// Take care with what you do as a result of this test. +// The user may not have been logged in when this function was called BUT +// because of threading the user might be logged in before you test the result. int CtdlIsUserLoggedInByNum (long usernum) { CitContext *cptr; int ret = 0; @@ -171,25 +165,21 @@ int CtdlIsUserLoggedInByNum (long usernum) { } -/* - * Return a pointer to the CitContext structure bound to the thread which - * called this function. If there's no such binding (for example, if it's - * called by the housekeeper thread) then a generic 'master' CC is returned. - * - * This function is used *VERY* frequently and must be kept small. - */ +// Return a pointer to the CitContext structure bound to the thread which +// called this function. If there's no such binding (for example, if it's +// called by the housekeeper thread) then a generic 'master' CC is returned. +// +// This function is used *VERY* frequently and must be kept small. CitContext *MyContext(void) { register CitContext *c; return ((c = (CitContext *) pthread_getspecific(MyConKey), c == NULL) ? &masterCC : c); } -/* - * Terminate idle sessions. This function pounds through the session table - * comparing the current time to each session's time-of-last-command. If an - * idle session is found it is terminated, then the search restarts at the - * beginning because the pointer to our place in the list becomes invalid. - */ +// Terminate idle sessions. This function pounds through the session table +// comparing the current time to each session's time-of-last-command. If an +// idle session is found it is terminated, then the search restarts at the +// beginning because the pointer to our place in the list becomes invalid. void terminate_idle_sessions(void) { CitContext *ccptr; time_t now; @@ -223,9 +213,7 @@ void terminate_idle_sessions(void) { } -/* - * During shutdown, close the sockets of any sessions still connected. - */ +// During shutdown, close the sockets of any sessions still connected. void terminate_all_sessions(void) { CitContext *ccptr; int killed = 0; @@ -285,12 +273,10 @@ void RemoveContext(CitContext *con) { } -/* - * Initialize a new context and place it in the list. The session number - * used to be the PID (which is why it's called cs_pid), but that was when we - * had one process per session. Now we just assign them sequentially, starting - * at 1 (don't change it to 0 because masterCC uses 0). - */ +// Initialize a new context and place it in the list. The session number +// used to be the PID (which is why it's called cs_pid), but that was when we +// had one process per session. Now we just assign them sequentially, starting +// at 1 (don't change it to 0 because masterCC uses 0). CitContext *CreateNewContext(void) { CitContext *me; @@ -301,24 +287,13 @@ CitContext *CreateNewContext(void) { } memset(me, 0, sizeof(CitContext)); - /* Give the context a name. Hopefully makes it easier to track */ + // Give the context a name. Hopefully makes it easier to track strcpy (me->user.fullname, "SYS_notauth"); - /* The new context will be created already in the CON_EXECUTING state - * in order to prevent another thread from grabbing it while it's - * being set up. - */ - me->state = CON_EXECUTING; - /* - * Generate a unique session number and insert this context into - * the list. - */ - me->MigrateBuf = NewStrBuf(); - + me->state = CON_EXECUTING; // Create new context already in CON_EXECUTING so another thread doesn't grab it. + me->MigrateBuf = NewStrBuf(); // Generate a unique session number me->RecvBuf.Buf = NewStrBuf(); - - me->lastcmd = time(NULL); /* set lastcmd to now to prevent idle timer infanticide TODO: if we have a valid IO, use that to set the timer. */ - + me->lastcmd = time(NULL); // set lastcmd to now to prevent idle timer infanticide begin_critical_section(S_SESSION_TABLE); me->cs_pid = ++next_pid; @@ -334,12 +309,10 @@ CitContext *CreateNewContext(void) { } -/* - * Initialize a new context and place it in the list. The session number - * used to be the PID (which is why it's called cs_pid), but that was when we - * had one process per session. Now we just assign them sequentially, starting - * at 1 (don't change it to 0 because masterCC uses 0). - */ +// Initialize a new context and place it in the list. The session number +// used to be the PID (which is why it's called cs_pid), but that was when we +// had one process per session. Now we just assign them sequentially, starting +// at 1 (don't change it to 0 because masterCC uses 0). CitContext *CloneContext(CitContext *CloneMe) { CitContext *me; @@ -362,7 +335,6 @@ CitContext *CloneContext(CitContext *CloneMe) { me->download_fp = NULL; me->upload_fp = NULL; - /// TODO: what about the room/user? me->ma = NULL; me->ldap_dn = NULL; me->session_specific_data = NULL; @@ -378,27 +350,25 @@ CitContext *CloneContext(CitContext *CloneMe) { me->RecvBuf.Buf = NewStrBuf(); begin_critical_section(S_SESSION_TABLE); - { - me->cs_pid = ++next_pid; - me->prev = NULL; - me->next = ContextList; - me->lastcmd = time(NULL); /* set lastcmd to now to prevent idle timer infanticide */ - ContextList = me; - if (me->next != NULL) { - me->next->prev = me; - } - ++num_sessions; + + me->cs_pid = ++next_pid; + me->prev = NULL; + me->next = ContextList; + me->lastcmd = time(NULL); // set lastcmd to now to prevent idle timer infanticide + ContextList = me; + if (me->next != NULL) { + me->next->prev = me; } + ++num_sessions; + end_critical_section(S_SESSION_TABLE); return (me); } -/* - * Return an array containing a copy of the context list. - * This allows worker threads to perform "for each context" operations without - * having to lock and traverse the live list. - */ +// Return an array containing a copy of the context list. +// This allows worker threads to perform "for each context" operations without +// having to lock and traverse the live list. CitContext *CtdlGetContextArray(int *count) { int nContexts, i; CitContext *nptr, *cptr; @@ -420,13 +390,10 @@ CitContext *CtdlGetContextArray(int *count) { } -/* - * Back-end function for starting a session - */ +// Back-end function for starting a session void begin_session(CitContext *con) { - /* - * Initialize some variables specific to our context. - */ + + // Initialize some variables specific to our context. con->logged_in = 0; con->internal_pgm = 0; con->download_fp = NULL; @@ -453,43 +420,10 @@ void begin_session(CitContext *con) { else { con->cs_host[0] = 0; con->cs_addr[0] = 0; -#ifdef HAVE_STRUCT_UCRED - { - /* as http://www.wsinnovations.com/softeng/articles/uds.html told us... */ - struct ucred credentials; - socklen_t ucred_length = sizeof(struct ucred); - - /*fill in the user data structure */ - if(getsockopt(con->client_socket, SOL_SOCKET, SO_PEERCRED, &credentials, &ucred_length)) { - syslog(LOG_ERR, "context: could obtain credentials from unix domain socket"); - - } - else { - /* the process ID of the process on the other side of the socket */ - /* credentials.pid; */ - - /* the effective UID of the process on the other side of the socket */ - con->cs_UDSclientUID = credentials.uid; - - /* the effective primary GID of the process on the other side of the socket */ - /* credentials.gid; */ - - /* To get supplemental groups, we will have to look them up in our account - database, after a reverse lookup on the UID to get the account name. - We can take this opportunity to check to see if this is a legit account. - */ - snprintf(con->cs_clientinfo, sizeof(con->cs_clientinfo), - "PID: "F_PID_T"; UID: "F_UID_T"; GID: "F_XPID_T" ", - credentials.pid, - credentials.uid, - credentials.gid); - } - } -#endif } con->cs_flags = 0; - con->nologin = 0; + if (((CtdlGetConfigInt("c_maxsessions") > 0)&&(num_sessions > CtdlGetConfigInt("c_maxsessions"))) || CtdlWantSingleUser()) { con->nologin = 1; } @@ -503,10 +437,8 @@ void begin_session(CitContext *con) { } -/* - * This function fills in a context and its user field correctly - * Then creates/loads that user - */ +// This function fills in a context and its user field correctly +// Then creates/loads that user void CtdlFillSystemContext(CitContext *context, char *name) { char sysname[SIZ]; long len; @@ -522,44 +454,36 @@ void CtdlFillSystemContext(CitContext *context, char *name) { context->state = CON_SYS; context->ServiceName = name; - /* internal_create_user has the side effect of loading the user regardless of whether they - * already existed or needed to be created - */ + // internal_create_user has the side effect of loading the user regardless of whether they + // already existed or needed to be created internal_create_user(sysname, &(context->user), -1) ; - /* Check to see if the system user needs upgrading */ - if (context->user.usernum == 0) { /* old system user with number 0, upgrade it */ + // Check to see if the system user needs upgrading + if (context->user.usernum == 0) { // old system user with number 0, upgrade it context->user.usernum = get_new_user_number(); syslog(LOG_INFO, "context: upgrading system user \"%s\" from user number 0 to user number %ld", context->user.fullname, context->user.usernum); - /* add user to the database */ + // add user to the database CtdlPutUser(&(context->user)); cdb_store(CDB_USERSBYNUMBER, &(context->user.usernum), sizeof(long), context->user.fullname, strlen(context->user.fullname)+1); } } -/* - * Cleanup any contexts that are left lying around - */ +// Cleanup any contexts that are left lying around void context_cleanup(void) { CitContext *ptr = NULL; CitContext *rem = NULL; - /* - * Clean up the contexts. - * There are no threads so no critical_section stuff is needed. - */ + // Clean up the contexts. + // There are no threads so no critical_section stuff is needed. ptr = ContextList; - /* We need to update the ContextList because some modules may want to itterate it - * Question is should we NULL it before iterating here or should we just keep updating it - * as we remove items? - * - * Answer is to NULL it first to prevent modules from doing any actions on the list at all - */ + // We need to update the ContextList because some modules may want to iterate it + // Question is should we NULL it before iterating here or should we just keep updating it as we remove items? + // Answer is to NULL it first to prevent modules from doing any actions on the list at all. ContextList=NULL; while (ptr != NULL){ - /* Remove the session from the active list */ + // Remove the session from the active list rem = ptr->next; --num_sessions; @@ -571,20 +495,18 @@ void context_cleanup(void) { } -/* - * Purge all sessions which have the 'kill_me' flag set. - * This function has code to prevent it from running more than once every - * few seconds, because running it after every single unbind would waste a lot - * of CPU time and keep the context list locked too much. To force it to run - * anyway, set "force" to nonzero. - */ +// Purge all sessions which have the 'kill_me' flag set. +// This function has code to prevent it from running more than once every +// few seconds, because running it after every single unbind would waste a lot +// of CPU time and keep the context list locked too much. To force it to run +// anyway, set "force" to nonzero. void dead_session_purge(int force) { - CitContext *ptr, *ptr2; /* general-purpose utility pointer */ - CitContext *rem = NULL; /* list of sessions to be destroyed */ + CitContext *ptr, *ptr2; // general-purpose utility pointer + CitContext *rem = NULL; // list of sessions to be destroyed if (force == 0) { if ( (time(NULL) - last_purge) < 5 ) { - return; /* Too soon, go away */ + return; // Too soon, go away } } time(&last_purge); @@ -598,7 +520,7 @@ void dead_session_purge(int force) { ptr = ptr->next; if ( (ptr2->state == CON_IDLE) && (ptr2->kill_me) ) { - /* Remove the session from the active list */ + // Remove the session from the active list if (ptr2->prev) { ptr2->prev->next = ptr2->next; } @@ -620,10 +542,9 @@ void dead_session_purge(int force) { } end_critical_section(S_SESSION_TABLE); - /* Now that we no longer have the session list locked, we can take - * our time and destroy any sessions on the to-be-killed list, which - * is allocated privately on this thread's stack. - */ + // Now that we no longer have the session list locked, we can take + // our time and destroy any sessions on the to-be-killed list, which + // is allocated privately on this thread's stack. while (rem != NULL) { syslog(LOG_DEBUG, "context: dead_session_purge() purging session %d, reason=%d", rem->cs_pid, rem->kill_me); RemoveContext(rem); @@ -634,10 +555,7 @@ void dead_session_purge(int force) { } -/* - * masterCC is the context we use when not attached to a session. This - * function initializes it. - */ +// masterCC is the context we use when not attached to a session. This function initializes it. void InitializeMasterCC(void) { memset(&masterCC, 0, sizeof(struct CitContext)); masterCC.internal_pgm = 1; @@ -645,9 +563,7 @@ void InitializeMasterCC(void) { } -/* - * Set the "async waiting" flag for a session, if applicable - */ +// Set the "async waiting" flag for a session, if applicable void set_async_waiting(struct CitContext *ccptr) { syslog(LOG_DEBUG, "context: setting async_waiting flag for session %d", ccptr->cs_pid); if (ccptr->is_async) { @@ -659,8 +575,7 @@ void set_async_waiting(struct CitContext *ccptr) { } -CTDL_MODULE_INIT(session) -{ +CTDL_MODULE_INIT(session) { if (!threading) { } return "session"; diff --git a/citadel/server/netconfig.c b/citadel/server/netconfig.c index 5be018371..cfb8cc273 100644 --- a/citadel/server/netconfig.c +++ b/citadel/server/netconfig.c @@ -1,6 +1,6 @@ // This module handles loading, saving, and parsing of room network configurations. // -// Copyright (c) 2000-2022 by the citadel.org team +// Copyright (c) 2000-2023 by the citadel.org team // // This program is open source software; you can redistribute it and/or modify // it under the terms of the GNU General Public License, version 3. @@ -9,15 +9,6 @@ #include #include #include - -#ifdef HAVE_SYSCALL_H -# include -#else -# if HAVE_SYS_SYSCALL_H -# include -# endif -#endif -#include #include #include #include "ctdl_module.h"