Back to index

webcit  8.12-dfsg
Defines | Functions | Variables
sysdep.c File Reference
#include "sysdep.h"
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <ctype.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <syslog.h>
#include <sys/syslog.h>
#include <time.h>
#include <limits.h>
#include <sys/resource.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/un.h>
#include <string.h>
#include <pwd.h>
#include <errno.h>
#include <stdarg.h>
#include <grp.h>
#include "webcit.h"
#include "snprintf.h"
#include "webserver.h"
#include "modules_init.h"

Go to the source code of this file.

Defines

#define COMPUTE_DIRECTORY(SUBDIR)

Functions

void * context_loop (ParsedHttpHdrs *Hdr)
void * housekeeping_loop (void)
void do_housekeeping (void)
void InitialiseSemaphores (void)
void begin_critical_section (int which_one)
void end_critical_section (int which_one)
void ShutDownWebcit (void)
void worker_entry (void)
void graceful_shutdown_watcher (int signum)
void graceful_shutdown (int signum)
void start_daemon (char *pid_file)
void spawn_another_worker_thread ()
void webcit_calc_dirs_n_files (int relh, const char *basedir, int home, char *webcitdir, char *relhome)
void drop_root (uid_t UID)
void wc_backtrace (void)

Variables

pthread_mutex_t Critters [MAX_SEMAPHORES]
pthread_key_t MyConKey
pthread_key_t MyReq
int msock
int time_to_die = 0
char ctdl_key_dir [PATH_MAX] = SSL_DIR
char file_crpt_file_key [PATH_MAX] = ""
char file_crpt_file_csr [PATH_MAX] = ""
char file_crpt_file_cer [PATH_MAX] = ""
const char editor_absolut_dir [PATH_MAX] = EDITORDIR
char static_dir [PATH_MAX]
char static_local_dir [PATH_MAX]
char static_icon_dir [PATH_MAX]
char * static_dirs []
 Web representation.
int ExitPipe [2]
pid_t current_child

Define Documentation

#define COMPUTE_DIRECTORY (   SUBDIR)
Value:
memcpy(dirbuffer,SUBDIR, sizeof dirbuffer);\
       snprintf(SUBDIR,sizeof SUBDIR,  "%s%s%s%s%s%s%s", \
                      (home&!relh)?webcitdir:basedir, \
             ((basedir!=webcitdir)&(home&!relh))?basedir:"/", \
             ((basedir!=webcitdir)&(home&!relh))?"/":"", \
                      relhome, \
             (relhome[0]!='\0')?"/":"",\
                      dirbuffer,\
                      (dirbuffer[0]!='\0')?"/":"");

Function Documentation

void begin_critical_section ( int  which_one)

Definition at line 121 of file sysdep.c.

{
       pthread_mutex_lock(&Critters[which_one]);
}

Here is the caller graph for this function:

void* context_loop ( ParsedHttpHdrs Hdr)

Definition at line 484 of file context_loop.c.

{
       int isbogus = 0;
       wcsession *TheSession;
       struct timeval tx_start;
       struct timeval tx_finish;
       int session_may_be_reused = 1;
       
       gettimeofday(&tx_start, NULL);            /* start a stopwatch for performance timing */

       /*
        * Find out what it is that the web browser is asking for
        */
       isbogus = ReadHTTPRequest(Hdr);

       Hdr->HR.dav_depth = 32767; /* TODO: find a general way to have non-0 defaults */

       if (!isbogus) {
              isbogus = AnalyseHeaders(Hdr);
       }

       if (   (isbogus)
              || ((Hdr->HR.Handler != NULL)
              && ((Hdr->HR.Handler->Flags & BOGUS) != 0))
       ) {
              wcsession *Bogus;
              Bogus = CreateSession(0, 1, NULL, Hdr, NULL);
              do_404();
              syslog(9, "HTTP: 404 [%ld.%06ld] %s %s",
                     ((tx_finish.tv_sec*1000000 + tx_finish.tv_usec) - (tx_start.tv_sec*1000000 + tx_start.tv_usec)) / 1000000,
                     ((tx_finish.tv_sec*1000000 + tx_finish.tv_usec) - (tx_start.tv_sec*1000000 + tx_start.tv_usec)) % 1000000,
                     ReqStrs[Hdr->HR.eReqType],
                     ChrPtr(Hdr->this_page)
                     );
              session_detach_modules(Bogus);
              session_destroy_modules(&Bogus);
              return;
       }

       if ((Hdr->HR.Handler != NULL) && ((Hdr->HR.Handler->Flags & ISSTATIC) != 0))
       {
              wcsession *Static;
              Static = CreateSession(0, 1, NULL, Hdr, NULL);
              
              Hdr->HR.Handler->F();

              /* How long did this transaction take? */
              gettimeofday(&tx_finish, NULL);
              
              syslog(9, "HTTP: 200 [%ld.%06ld] %s %s",
                     ((tx_finish.tv_sec*1000000 + tx_finish.tv_usec) - (tx_start.tv_sec*1000000 + tx_start.tv_usec)) / 1000000,
                     ((tx_finish.tv_sec*1000000 + tx_finish.tv_usec) - (tx_start.tv_sec*1000000 + tx_start.tv_usec)) % 1000000,
                     ReqStrs[Hdr->HR.eReqType],
                     ChrPtr(Hdr->this_page)
              );
              session_detach_modules(Static);
              session_destroy_modules(&Static);
              return;
       }

       if (Hdr->HR.got_auth == AUTH_BASIC) {
              CheckAuthBasic(Hdr);
       }

       if (Hdr->HR.got_auth) {
              session_may_be_reused = 0;
       }

       /*
        * See if there's an existing session open with any of:
        * - The desired Session ID
        * - A matching http-auth username and password
        * - An unbound session flagged as reusable
        */
       TheSession = FindSession(&SessionList, Hdr, &SessionListMutex);

       /*
        * If there were no qualifying sessions, then create a new one.
        */
       if (TheSession == NULL) {
              TheSession = CreateSession(1, 0, &SessionList, Hdr, &SessionListMutex);
       }

       /*
        * Reject transactions which require http-auth, if http-auth was not provided
        */
       if (   (StrLength(Hdr->c_username) == 0)
              && (!Hdr->HR.DontNeedAuth)
              && (Hdr->HR.Handler != NULL)
              && ((XHTTP_COMMANDS & Hdr->HR.Handler->Flags) == XHTTP_COMMANDS)
       ) {
              syslog(LOG_DEBUG, "http-auth required but not provided");
              OverrideRequest(Hdr, HKEY("GET /401 HTTP/1.0"));
              Hdr->HR.prohibit_caching = 1;                           
       }

       /*
        * A future improvement might be to check the session integrity
        * at this point before continuing.
        */

       /*
        * Bind to the session and perform the transaction
        */
       CtdlLogResult(pthread_mutex_lock(&TheSession->SessionMutex));
       pthread_setspecific(MyConKey, (void *)TheSession);
       
       TheSession->inuse = 1;                                  /* mark the session as bound */
       TheSession->lastreq = time(NULL);                /* log */
       TheSession->Hdr = Hdr;

       /*
        * If a language was requested via a cookie, select that language now.
        */
       if (StrLength(Hdr->c_language) > 0) {
              syslog(LOG_DEBUG, "Session cookie requests language '%s'", ChrPtr(Hdr->c_language));
              set_selected_language(ChrPtr(Hdr->c_language));
              go_selected_language();
       }

       /*
        * do the transaction
        */
       session_attach_modules(TheSession);
       session_loop();

       /* How long did this transaction take? */
       gettimeofday(&tx_finish, NULL);

       syslog(9, "HTTP: 200 [%ld.%06ld] %s %s",
              ((tx_finish.tv_sec*1000000 + tx_finish.tv_usec) - (tx_start.tv_sec*1000000 + tx_start.tv_usec)) / 1000000,
              ((tx_finish.tv_sec*1000000 + tx_finish.tv_usec) - (tx_start.tv_sec*1000000 + tx_start.tv_usec)) % 1000000,
              ReqStrs[Hdr->HR.eReqType],
              ChrPtr(Hdr->this_page)
       );

       session_detach_modules(TheSession);

       /* If *this* very transaction did not explicitly specify a session cookie,
        * and it did not log in, we want to flag the session as a candidate for
        * re-use by the next unbound client that comes along.  This keeps our session
        * table from getting bombarded with new sessions when, for example, a web
        * spider crawls the site without using cookies.
        */
       if ((session_may_be_reused) && (!WC->logged_in)) {
              WC->wc_session = 0;                /* flag as available for re-use */
              TheSession->selected_language = 0; /* clear any non-default language setting */
       }

       TheSession->Hdr = NULL;
       TheSession->inuse = 0;                                  /* mark the session as unbound */
       CtdlLogResult(pthread_mutex_unlock(&TheSession->SessionMutex));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void do_housekeeping ( void  )

Definition at line 57 of file context_loop.c.

{
       wcsession *sptr, *ss;
       wcsession *sessions_to_kill = NULL;

       /*
        * Lock the session list, moving any candidates for euthanasia into
        * a separate list.
        */
       CtdlLogResult(pthread_mutex_lock(&SessionListMutex));
       for (sptr = SessionList; sptr != NULL; sptr = sptr->next) {

              /* Kill idle sessions */
              if ((time(NULL) - (sptr->lastreq)) > (time_t) WEBCIT_TIMEOUT) {
                     syslog(3, "Timeout session %d", sptr->wc_session);
                     sptr->killthis = 1;
              }

              /* Remove sessions flagged for kill */
              if (sptr->killthis) {

                     /* remove session from linked list */
                     if (sptr == SessionList) {
                            SessionList = SessionList->next;
                     }
                     else for (ss=SessionList;ss!=NULL;ss=ss->next) {
                            if (ss->next == sptr) {
                                   ss->next = ss->next->next;
                            }
                     }

                     sptr->next = sessions_to_kill;
                     sessions_to_kill = sptr;
              }
       }
       CtdlLogResult(pthread_mutex_unlock(&SessionListMutex));

       /*
        * Now free up and destroy the culled sessions.
        */
       while (sessions_to_kill != NULL) {
              syslog(3, "Destroying session %d", sessions_to_kill->wc_session);
              sptr = sessions_to_kill->next;
              session_destroy_modules(&sessions_to_kill);
              sessions_to_kill = sptr;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void drop_root ( uid_t  UID)

Definition at line 499 of file sysdep.c.

{
       struct passwd pw, *pwp = NULL;

       /*
        * Now that we've bound the sockets, change to the Citadel user id and its
        * corresponding group ids
        */
       if (UID != -1) {
              
#ifdef HAVE_GETPWUID_R
#ifdef SOLARIS_GETPWUID
              pwp = getpwuid_r(UID, &pw, pwbuf, sizeof(pwbuf));
#else /* SOLARIS_GETPWUID */
              getpwuid_r(UID, &pw, pwbuf, sizeof(pwbuf), &pwp);
#endif /* SOLARIS_GETPWUID */
#else /* HAVE_GETPWUID_R */
              pwp = NULL;
#endif /* HAVE_GETPWUID_R */

              if (pwp == NULL)
                     syslog(LOG_CRIT, "WARNING: getpwuid(%d): %s\n"
                            "Group IDs will be incorrect.\n", UID,
                            strerror(errno));
              else {
                     initgroups(pw.pw_name, pw.pw_gid);
                     if (setgid(pw.pw_gid))
                            syslog(LOG_CRIT, "setgid(%ld): %s\n", (long)pw.pw_gid,
                                   strerror(errno));
              }
              syslog(LOG_INFO, "Changing uid to %ld\n", (long)UID);
              if (setuid(UID) != 0) {
                     syslog(LOG_CRIT, "setuid() failed: %s\n", strerror(errno));
              }
#if defined (HAVE_SYS_PRCTL_H) && defined (PR_SET_DUMPABLE)
              prctl(PR_SET_DUMPABLE, 1);
#endif
       }
}

Here is the caller graph for this function:

void end_critical_section ( int  which_one)

Definition at line 129 of file sysdep.c.

{
       pthread_mutex_unlock(&Critters[which_one]);
}

Here is the caller graph for this function:

void graceful_shutdown ( int  signum)

Definition at line 303 of file sysdep.c.

                                   {
       FILE *FD;
       int fd;

       syslog(1, "WebCit is being shut down on signal %d.\n", signum);
       fd = msock;
       msock = -1;
       time_to_die = 1;
       FD=fdopen(fd, "a+");
       fflush (FD);
       fclose (FD);
       close(fd);
       write(ExitPipe[0], HKEY("                              "));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void graceful_shutdown_watcher ( int  signum)

Definition at line 289 of file sysdep.c.

                                           {
       syslog(1, "Watcher thread exiting.\n");
       write(ExitPipe[0], HKEY("                              "));
       kill(current_child, signum);
       if (signum != SIGHUP)
              exit(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* housekeeping_loop ( void  )

Definition at line 130 of file context_loop.c.

void InitialiseSemaphores ( void  )

Definition at line 99 of file sysdep.c.

{
       int i;

       /* Set up a bunch of semaphores to be used for critical sections */
       for (i=0; i<MAX_SEMAPHORES; ++i) {
              pthread_mutex_init(&Critters[i], NULL);
       }

       if (pipe(ExitPipe))
       {
              syslog(2, "Failed to open exit pipe: %d [%s]\n", 
                     errno, 
                     strerror(errno));
              
              exit(-1);
       }
}

Here is the caller graph for this function:

void ShutDownWebcit ( void  )

Definition at line 135 of file sysdep.c.

{
       free_zone_directory ();
       icaltimezone_release_zone_tab ();
       icalmemory_free_ring ();
       ShutDownLibCitadel ();
       shutdown_modules ();
#ifdef HAVE_OPENSSL
       if (is_https) {
              shutdown_ssl();
       }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void spawn_another_worker_thread ( void  )

Definition at line 419 of file sysdep.c.

{
       pthread_t SessThread;       /* Thread descriptor */
       pthread_attr_t attr; /* Thread attributes */
       int ret;

       ++num_threads_existing;
       ++num_threads_executing;

       /* set attributes for the new thread */
       pthread_attr_init(&attr);
       pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

       /*
        * Our per-thread stacks need to be bigger than the default size,
        * otherwise the MIME parser crashes on FreeBSD.
        */
       if ((ret = pthread_attr_setstacksize(&attr, 1024 * 1024))) {
              syslog(1, "pthread_attr_setstacksize: %s\n", strerror(ret));
              pthread_attr_destroy(&attr);
       }

       /* now create the thread */
       if (pthread_create(&SessThread, &attr, (void *(*)(void *)) worker_entry, NULL) != 0) {
              syslog(1, "Can't create thread: %s\n", strerror(errno));
       }

       /* free up the attributes */
       pthread_attr_destroy(&attr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void start_daemon ( char *  pid_file)

Definition at line 322 of file sysdep.c.

{
       int status = 0;
       pid_t child = 0;
       FILE *fp;
       int do_restart = 0;

       current_child = 0;

       /* Close stdin/stdout/stderr and replace them with /dev/null.
        * We don't just call close() because we don't want these fd's
        * to be reused for other files.
        */
       chdir("/");

       signal(SIGHUP, SIG_IGN);
       signal(SIGINT, SIG_IGN);
       signal(SIGQUIT, SIG_IGN);

       child = fork();
       if (child != 0) {
              exit(0);
       }

       setsid();
       umask(0);
       freopen("/dev/null", "r", stdin);
       freopen("/dev/null", "w", stdout);
       freopen("/dev/null", "w", stderr);
       signal(SIGTERM, graceful_shutdown_watcher);
       signal(SIGHUP, graceful_shutdown_watcher);

       do {
              current_child = fork();

       
              if (current_child < 0) {
                     perror("fork");
                     ShutDownLibCitadel ();
                     exit(errno);
              }
       
              else if (current_child == 0) {     /* child process */
                     signal(SIGHUP, graceful_shutdown);

                     return; /* continue starting webcit. */
              }
              else { /* watcher process */
                     if (pid_file) {
                            fp = fopen(pid_file, "w");
                            if (fp != NULL) {
                                   fprintf(fp, "%d\n", getpid());
                                   fclose(fp);
                            }
                     }
                     waitpid(current_child, &status, 0);
              }

              do_restart = 0;

              /* Did the main process exit with an actual exit code? */
              if (WIFEXITED(status)) {

                     /* Exit code 0 means the watcher should exit */
                     if (WEXITSTATUS(status) == 0) {
                            do_restart = 0;
                     }

                     /* Exit code 101-109 means the watcher should exit */
                     else if ( (WEXITSTATUS(status) >= 101) && (WEXITSTATUS(status) <= 109) ) {
                            do_restart = 0;
                     }

                     /* Any other exit code means we should restart. */
                     else {
                            do_restart = 1;
                     }
              }

              /* Any other type of termination (signals, etc.) should also restart. */
              else {
                     do_restart = 1;
              }

       } while (do_restart);

       if (pid_file) {
              unlink(pid_file);
       }
       ShutDownLibCitadel ();
       exit(WEXITSTATUS(status));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void wc_backtrace ( void  )

Definition at line 543 of file sysdep.c.

{
#ifdef HAVE_BACKTRACE
       void *stack_frames[50];
       size_t size, i;
       char **strings;


       size = backtrace(stack_frames, sizeof(stack_frames) / sizeof(void*));
       strings = backtrace_symbols(stack_frames, size);
       for (i = 0; i < size; i++) {
              if (strings != NULL)
                     syslog(1, "%s\n", strings[i]);
              else
                     syslog(1, "%p\n", stack_frames[i]);
       }
       free(strings);
#endif
}

Here is the caller graph for this function:

void webcit_calc_dirs_n_files ( int  relh,
const char *  basedir,
int  home,
char *  webcitdir,
char *  relhome 
)

Definition at line 452 of file sysdep.c.

{
       char dirbuffer[PATH_MAX]="";
       /* calculate all our path on a central place */
    /* where to keep our config */
       
#define COMPUTE_DIRECTORY(SUBDIR) memcpy(dirbuffer,SUBDIR, sizeof dirbuffer);\
       snprintf(SUBDIR,sizeof SUBDIR,  "%s%s%s%s%s%s%s", \
                      (home&!relh)?webcitdir:basedir, \
             ((basedir!=webcitdir)&(home&!relh))?basedir:"/", \
             ((basedir!=webcitdir)&(home&!relh))?"/":"", \
                      relhome, \
             (relhome[0]!='\0')?"/":"",\
                      dirbuffer,\
                      (dirbuffer[0]!='\0')?"/":"");
       basedir=RUNDIR;
       COMPUTE_DIRECTORY(socket_dir);
       basedir=WWWDIR "/static";
       COMPUTE_DIRECTORY(static_dir);
       basedir=WWWDIR "/static/icons";
       COMPUTE_DIRECTORY(static_icon_dir);
       basedir=WWWDIR "/static.local";
       COMPUTE_DIRECTORY(static_local_dir);
       StripSlashes(static_dir, 1);
       StripSlashes(static_icon_dir, 1);
       StripSlashes(static_local_dir, 1);

       snprintf(file_crpt_file_key,
               sizeof file_crpt_file_key, 
               "%s/citadel.key",
               ctdl_key_dir);
       snprintf(file_crpt_file_csr,
               sizeof file_crpt_file_csr, 
               "%s/citadel.csr",
               ctdl_key_dir);
       snprintf(file_crpt_file_cer,
               sizeof file_crpt_file_cer, 
               "%s/citadel.cer",
               ctdl_key_dir);

       /* we should go somewhere we can leave our coredump, if enabled... */
       syslog(9, "Changing directory to %s\n", socket_dir);
       if (chdir(webcitdir) != 0) {
              perror("chdir");
       }
}

Here is the caller graph for this function:

void worker_entry ( void  )

Definition at line 152 of file sysdep.c.

{
       int ssock;
       int i = 0;
       int fail_this_transaction = 0;
       ParsedHttpHdrs Hdr;

       memset(&Hdr, 0, sizeof(ParsedHttpHdrs));
       Hdr.HR.eReqType = eGET;
       http_new_modules(&Hdr);     

       do {
              /* Each worker thread blocks on accept() while waiting for something to do. */
              fail_this_transaction = 0;
              ssock = -1; 
              errno = EAGAIN;
              do {
                     fd_set wset;
                     --num_threads_executing;
                        FD_ZERO(&wset);
                        FD_SET(msock, &wset);
                        FD_SET(ExitPipe[1], &wset);

                        select(msock + 1, NULL, &wset, NULL, NULL);
                     if (time_to_die)
                            break;

                     ssock = accept(msock, NULL, 0);
                     ++num_threads_executing;
                     if (ssock < 0) fail_this_transaction = 1;
              } while ((msock > 0) && (ssock < 0)  && (time_to_die == 0));

              if ((msock == -1)||(time_to_die))
              {/* ok, we're going down. */
                     int shutdown = 0;

                     /* The first thread to get here will have to do the cleanup.
                      * Make sure it's really just one.
                      */
                     begin_critical_section(S_SHUTDOWN);
                     if (msock == -1)
                     {
                            msock = -2;
                            shutdown = 1;
                     }
                     end_critical_section(S_SHUTDOWN);
                     if (shutdown == 1)
                     {/* we're the one to cleanup the mess. */
                            http_destroy_modules(&Hdr);
                            syslog(2, "I'm master shutdown: tagging sessions to be killed.\n");
                            shutdown_sessions();
                            syslog(2, "master shutdown: waiting for others\n");
                            sleeeeeeeeeep(1); /* wait so some others might finish... */
                            syslog(2, "master shutdown: cleaning up sessions\n");
                            do_housekeeping();
                            syslog(2, "master shutdown: cleaning up libical\n");

                            ShutDownWebcit();

                            syslog(2, "master shutdown exiting.\n");                       
                            exit(0);
                     }
                     break;
              }
              if (ssock < 0 ) continue;

              check_thread_pool_size();

              /* Now do something. */
              if (msock < 0) {
                     if (ssock > 0) close (ssock);
                     syslog(2, "in between.");
                     pthread_exit(NULL);
              } else {
                     /* Got it? do some real work! */
                     /* Set the SO_REUSEADDR socket option */
                     i = 1;
                     setsockopt(ssock, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));

                     /* If we are an HTTPS server, go crypto now. */
#ifdef HAVE_OPENSSL
                     if (is_https) {
                            if (starttls(ssock) != 0) {
                                   fail_this_transaction = 1;
                                   close(ssock);
                            }
                     }
                     else 
#endif
                     {
                            int fdflags; 
                            fdflags = fcntl(ssock, F_GETFL);
                            if (fdflags < 0)
                                   syslog(1, "unable to get server socket flags! %s \n",
                                          strerror(errno));
                            fdflags = fdflags | O_NONBLOCK;
                            if (fcntl(ssock, F_SETFL, fdflags) < 0)
                                   syslog(1, "unable to set server socket nonblocking flags! %s \n",
                                          strerror(errno));
                     }

                     if (fail_this_transaction == 0) {
                            Hdr.http_sock = ssock;

                            /* Perform an HTTP transaction... */
                            context_loop(&Hdr);

                            /* Shut down SSL/TLS if required... */
#ifdef HAVE_OPENSSL
                            if (is_https) {
                                   endtls();
                            }
#endif

                            /* ...and close the socket. */
                            if (Hdr.http_sock > 0) {
                                   lingering_close(ssock);
                            }
                            http_detach_modules(&Hdr);

                     }

              }

       } while (!time_to_die);

       http_destroy_modules(&Hdr);
       syslog(1, "Thread exiting.\n");
       pthread_exit(NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

pthread_mutex_t Critters[MAX_SEMAPHORES]

Definition at line 71 of file sysdep.c.

char ctdl_key_dir[PATH_MAX] = SSL_DIR

Definition at line 81 of file sysdep.c.

Definition at line 288 of file sysdep.c.

const char editor_absolut_dir[PATH_MAX] = EDITORDIR

Definition at line 86 of file sysdep.c.

int ExitPipe[2]

Definition at line 97 of file sysdep.c.

char file_crpt_file_cer[PATH_MAX] = ""

Definition at line 84 of file sysdep.c.

char file_crpt_file_csr[PATH_MAX] = ""

Definition at line 83 of file sysdep.c.

char file_crpt_file_key[PATH_MAX] = ""

Definition at line 82 of file sysdep.c.

int msock

Definition at line 74 of file sysdep.c.

pthread_key_t MyConKey

Definition at line 72 of file sysdep.c.

pthread_key_t MyReq

Definition at line 73 of file sysdep.c.

char static_dir[PATH_MAX]

Definition at line 87 of file sysdep.c.

char* static_dirs[]
Initial value:

Web representation.

Definition at line 90 of file sysdep.c.

char static_icon_dir[PATH_MAX]

Definition at line 89 of file sysdep.c.

char static_local_dir[PATH_MAX]

Definition at line 88 of file sysdep.c.

int time_to_die = 0

Definition at line 75 of file sysdep.c.