G:/ScriptBasic/source/extensions/mt/interface.c

Go to the documentation of this file.

/* FILE: mt.c

This file contains code fot the multi-thread support module.

For further information read the accopaining documentation that 
I am going to write when I am ready programming this module. Right 
now I just start to write it.

Peter Verhas March 6, 2001.

--GNU LGPL
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

NTLIBS:
UXLIBS:
DWLIBS: -init __init

*/
#include <stdio.h>
#include <time.h>
#include "../../basext.h"

/* This declaraton declares the counter and the mutex protecting it that
   counts the number of threads loading this library. Note that only the
   first call to LoadLibrary/dlopen loads this library the rest is only
   returns the pointer to the already loaded library.

   This library was designed to support multithread implementations so that
   it allows different threads to access data stored in memory. However each
   thread call FreeLibrary/dlclose to release this library. If there is a point
   in time when no thread uses this library then the library is unloaded and all
   data allocated is lost.

   To keep the library in memory the function besSUB_KEEP returns zero when the
   library would be unloaded. Thus exactly one LoadLibrary/dlopen is not followed
   by FreeLibrary/dlclose and thus this library remains in memory so long as long
   the process is alive.                                                               */
SUPPORT_MULTITHREAD

static SymbolTable MtVariables,SessionTable;
static MUTEX mxMTVariables,mxSessionCounter,mxSessionTable;
static unsigned long lSessionCounter;

/* Information that maintains a session. */
typedef struct _SessionInfo {
  SHAREDLOCK lckSession;       /* lock for read when used, lock for write when being deleted */
  MUTEX mxSession;             /* lock whenever access session symbol table                  */
  void *pMemSeg;               /* memory segment for session related memory allocations      */
  SymbolTable stSession;       /* session variables symbol table                             */
  unsigned long lPingTime;     /* timestamp when the session was alive last time             */
  unsigned long lTimeout;      /* timestamp when the session times out (set by BASIC program)*/
  unsigned long lTimeStart;    /* timestamp when the session was started                     */
  char *pszId;                 /* pointer into the symbol table to the if of the session     */
  struct _SessionInfo *prev,*next;
  } SessionInfo, *pSessionInfo;

static pSessionInfo pSessionRoot;

typedef struct _MtClass {
  pSessionInfo AssignedSession;
  char *pszSessionId;
  } MtClass, *pMtClass;

typedef struct _MTVariable{
  SHAREDLOCK lckV;
  VARIABLE vV;
  }MTVariable,*pMTVariable;


#define MT_ERROR_NOSESSION 0x00080001
#define MT_ERROR_BAD_PROG  0x00080002
#define MT_ERROR_BAD_SESS  0x00080003

/* Allocate a new session information structure.
   Note that this function is NOT reentrant but is called when the MUTEX mxSessionTable is locked.
*/
static pSessionInfo AllocNewSession(pSupportTable pSt,void *p){
  pSessionInfo pS;
  pS = besPROCALLOC(sizeof(SessionInfo));
  if( ! pS )return NULL;
  pS->pszId = SymbolName(p);
  pS->lTimeStart = time(NULL);
  /* hook into the double linked list */
  pS->next = pSessionRoot;
  pS->prev = NULL;
  pSessionRoot = pS;
  return pS;
  }

static void ReleaseSession(pSupportTable pSt, pSessionInfo pS){

  besLockMutex(&mxSessionTable);

  /* unhook from the double linked list */
  if( pS->prev )pS->prev->next = pS->next; else pSessionRoot = pS->next;
  if( pS->next )pS->next->prev = pS->prev;

  besPROCFREE(pS);

  besUnlockMutex(&mxSessionTable);
  }

/*
This function is executed as a separate thread when the module is initialized the first time.
It starts the timeout scripts when their time comes.
*/
static void time_out_work_thread(void *p){
  pSupportTable pSt;
  unsigned long lSleepLen;
  pSessionInfo pS;
  pSt = p;

  if( besCONFIGEX(pSt->pEo->pConfig,"httpd.mt.sleep",NULL,NULL,&lSleepLen,NULL,NULL) )
    lSleepLen = 60;

  while(1){
    besSLEEP(lSleepLen);
    pS = pSessionRoot;
    }


  }

#define IsUndef(pVar)  ((pVar) == NULL || (pVar)->vType == VTYPE_UNDEF)


besSUB_SHUTDOWN

besEND

besSUB_START
  pMtClass pMT;

  /* This macro increments the thread counter used to help to keep this library in memory 
     even those times when the process is idle and no ScriptBasic threads are running. */
  INC_THREAD_COUNTER
  /* A process level initialization of the module should take place in this function because
     the call-back support functions are not accessible when the  function DllMain or _init is
     called. On the other hand it has to initialize only once.
  */
  INITLOCK /* lock the init mutex */
  if( iFirst ){ /* if it was not initialized yet*/

    MtVariables = pSt->NewSymbolTable(pSt->Alloc,besPROCMEMORYSEGMENT);
    if( MtVariables == NULL )return COMMAND_ERROR_MEMORY_LOW;

    besInitMutex(&mxMTVariables);

    SessionTable = pSt->NewSymbolTable(pSt->Alloc,besPROCMEMORYSEGMENT);
    if( SessionTable == NULL )return COMMAND_ERROR_MEMORY_LOW;
    besInitMutex(&mxSessionCounter);
    besInitMutex(&mxSessionTable);
    /* time is just to introduce some randomity */
    lSessionCounter = (unsigned long)time(NULL);

    pSessionRoot = NULL;

    /* create the thread that handles timeout script execution */
    /* besCreateThread(&hT,time_out_work_thread,pSt->pEo->pSTI); */

    iFirst = 0;/* successful initialization was done*/
    }
  INITUNLO /* unlock the init mutex */

  besMODULEPOINTER = besALLOC(sizeof(MtClass));
  if( besMODULEPOINTER == NULL )return 0;
  pMT = (pMtClass)besMODULEPOINTER;
  pMT->AssignedSession = NULL;
  pMT->pszSessionId = NULL;

  return COMMAND_ERROR_SUCCESS;
besEND

besFUNCTION(setsession)
  char *pszSession;
  pMtClass pMT;
  void **p;
  VARIABLE Argument;
  pSessionInfo pS;
  unsigned long i;

  pMT = besMODULEPOINTER;
  if( besARGNR < 1 )return COMMAND_ERROR_FEW_ARGS;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  if( Argument == NULL )return COMMAND_ERROR_FEW_ARGS;
  Argument = besCONVERT2STRING(Argument);
  /* check that the session ID does not contain zero character inside (for security reasons) */
  for( i = 0 ; i < STRLEN(Argument) ; i++ )
    if( ! STRINGVALUE(Argument)[i] )return MT_ERROR_BAD_SESS;

  besCONVERT2ZCHAR(Argument,pszSession);
  /* if this thread already has a session assigned to it then release the session */
  pS = pMT->AssignedSession;
  if( pMT->pszSessionId )besFREE(pMT->pszSessionId);
  if( pS )besUnlockSharedRead(&(pS->lckSession));
  pS = pMT->AssignedSession = NULL; /* pS to NULL also just for safety */

  besLockMutex(&mxSessionTable);
  p = pSt->LookupSymbol(pszSession,SessionTable,1,pSt->Alloc,pSt->Free,besPROCMEMORYSEGMENT);
  if( p == NULL ){
    besUnlockMutex(&mxSessionTable);
    besFREE(pszSession);
    return COMMAND_ERROR_MEMORY_LOW;
    }
  if( *p == NULL ){/* this is a brand new session, most probably it is */
    /* count the creation of the new session */
    besLockMutex(&mxSessionCounter);
    lSessionCounter++;
    besUnlockMutex(&mxSessionCounter);

    *p = AllocNewSession(pSt,p);
    if( *p == NULL ){
      besUnlockMutex(&mxSessionTable);
      return COMMAND_ERROR_MEMORY_LOW;
      }
    pS = pMT->AssignedSession = *p;
    besInitMutex(&(pS->mxSession));
    besInitSharedLock(&(pS->lckSession));
    besLockSharedRead(&(pS->lckSession));
    /* Create a new memory segment for the session. */
    pS->pMemSeg = besINIT_SEGMENT(pSt->pEo->pMemorySegment,NULL);
    if( pS->pMemSeg == NULL )return COMMAND_ERROR_MEMORY_LOW;
    pS->stSession = pSt->NewSymbolTable(pSt->Alloc,pS->pMemSeg);
    if( pS->stSession == NULL )return COMMAND_ERROR_MEMORY_LOW;
    besUnlockMutex(&mxSessionTable);
    }else{/* this is an already existing session */
    pS = *p;
    besLockSharedRead(&(pS->lckSession));
    besUnlockMutex(&mxSessionTable);
    }

  /* the session id string should be copied because a program may think that it is executing a session and
     another thread deletes the session in the mean time, but can not know that there is a thread using the
     session */
  pMT->pszSessionId = besALLOC(strlen(SymbolName(p))+1);
  if( pMT->pszSessionId == NULL )return COMMAND_ERROR_MEMORY_LOW;
  strcpy(pMT->pszSessionId,SymbolName(p));
  pMT->AssignedSession = pS;
  pS->lPingTime = time(NULL);
  besUnlockSharedRead(&(pS->lckSession));

besEND

besFUNCTION(chksession)
  char *pszSession;
  pMtClass pMT;
  void **p;
  VARIABLE Argument;
  pSessionInfo pS;
  unsigned long i;

  besRETURNVALUE = NULL;
  pMT = besMODULEPOINTER;
  if( besARGNR < 1 )return COMMAND_ERROR_FEW_ARGS;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  if( Argument == NULL )return COMMAND_ERROR_FEW_ARGS;
  Argument = besCONVERT2STRING(Argument);
  /* check that the session ID does not contain zero character inside (for security reasons) */
  for( i = 0 ; i < STRLEN(Argument) ; i++ )
    if( ! STRINGVALUE(Argument)[i] )return MT_ERROR_BAD_SESS;

  besCONVERT2ZCHAR(Argument,pszSession);

  pS = pMT->AssignedSession = NULL;
  besLockMutex(&mxSessionTable);
  p = pSt->LookupSymbol(pszSession,SessionTable,0,pSt->Alloc,pSt->Free,besPROCMEMORYSEGMENT);
  besUnlockMutex(&mxSessionTable);
  besFREE(pszSession);
  besALLOC_RETURN_LONG;
  LONGVALUE(besRETURNVALUE) = p == NULL ? 0 : -1 ;
  return COMMAND_ERROR_SUCCESS;
besEND

besFUNCTION(sessioncount)
  besALLOC_RETURN_LONG;
  /* count the creation of the new session */
  besLockMutex(&mxSessionCounter);
  LONGVALUE(besRETURNVALUE) = lSessionCounter;
  besUnlockMutex(&mxSessionCounter);
  return COMMAND_ERROR_SUCCESS;
besEND

besFUNCTION(newsession)
  unsigned long lThisSession;
  MD5_CTX Context;
  unsigned char digest[16];
  int i;
  pMtClass pMT;
  void **p;
  pSessionInfo pS;
  VARIABLE Argument;

  pMT = besMODULEPOINTER;
  Argument = NULL;
  if( besARGNR > 0 ){
    Argument = besARGUMENT(1);
    besDEREFERENCE(Argument);
    if( Argument){
      Argument = besCONVERT2STRING(Argument);
      }
    }

  /* count the creation of the new session */
  besLockMutex(&mxSessionCounter);
  lThisSession = lSessionCounter++;
  besUnlockMutex(&mxSessionCounter);

  /* create a new session id */
  besMD5INIT(&Context);
  besMD5UPDATE(&Context,(unsigned char *)&lThisSession,sizeof(unsigned long));
  if( Argument )besMD5UPDATE(&Context,(unsigned char *)STRINGVALUE(Argument),STRLEN(Argument));
  besMD5FINAL(digest,&Context);
  besALLOC_RETURN_STRING(33);
  STRLEN(besRETURNVALUE) = 32;
  /* convert the digest to ASCII */
  for( i = 0 ; i < 16 ; i++ ){
    STRINGVALUE(besRETURNVALUE)[2*i] = 'A' + (digest[i]&0x0F);
    digest[i] >>= 4;
    STRINGVALUE(besRETURNVALUE)[2*i+1] = 'A' + (digest[i]&0x0F);
    }
  STRINGVALUE(besRETURNVALUE)[32] = (char)0;/* terminate it to be used in the symbol table */

  pMT->AssignedSession = NULL;
  if( pMT->pszSessionId )besFREE(pMT->pszSessionId);
  besLockMutex(&mxSessionTable);
  p = pSt->LookupSymbol(STRINGVALUE(besRETURNVALUE),SessionTable,1,pSt->Alloc,pSt->Free,besPROCMEMORYSEGMENT);
  if( p == NULL ){
    besUnlockMutex(&mxSessionTable);
    return COMMAND_ERROR_MEMORY_LOW;
    }
  if( *p == NULL ){/* this is a brand new session, most probably it is */
    *p = AllocNewSession(pSt,p);
    if( *p == NULL ){
      besUnlockMutex(&mxSessionTable);
      return COMMAND_ERROR_MEMORY_LOW;
      }
    pS = pMT->AssignedSession = *p;
    pS-> lPingTime = time(NULL);
    besInitMutex(&(pS->mxSession));
    besInitSharedLock(&(pS->lckSession));
    besLockSharedRead(&(pS->lckSession));
    /* Create a new memory segment for the session. */
    pS->pMemSeg = besINIT_SEGMENT(pSt->pEo->pMemorySegment,NULL);
    if( pS->pMemSeg == NULL )return COMMAND_ERROR_MEMORY_LOW;
    pS->stSession = pSt->NewSymbolTable(pSt->Alloc,pS->pMemSeg);
    if( pS->stSession == NULL )return COMMAND_ERROR_MEMORY_LOW;
    besUnlockMutex(&mxSessionTable);
    }else{
    pS = *p;
    besLockSharedRead(&(pS->lckSession));
    besUnlockMutex(&mxSessionTable);
    }
  pMT->pszSessionId = besALLOC(strlen(SymbolName(p))+1);
  if( pMT->pszSessionId == NULL )return COMMAND_ERROR_MEMORY_LOW;
  strcpy(pMT->pszSessionId,SymbolName(p));
  pMT->AssignedSession = pS;
  pS->lPingTime = time(NULL);
  besUnlockSharedRead(&(pS->lckSession));

besEND

static void FinishSegmentCallBack(char *SymbolName, void *SymbolValue, void *f){
  pSupportTable pSt;
  pMTVariable p;

  /* we need this variable to use the bes macros */
  pSt = f;
  p = SymbolValue;
  besFinishSharedLock(&(p->lckV));
  }

besFUNCTION(delsession)
  char *pszSession;
  void **p;
  VARIABLE Argument;
  pSessionInfo pS;
  pMtClass pMT;
  int bSessDef; /* TRUE if the session was the default (actual) session 
                   This variable also shows that pszSession should be realeased */

  pMT = besMODULEPOINTER;
  pS = pMT->AssignedSession;

  besRETURNVALUE = NULL;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  bSessDef = 0;
  if( Argument == NULL ){
    /* In this case we delete the actual session. */
    bSessDef = 1;
    pszSession = pMT->pszSessionId;
    if( pszSession == NULL )return MT_ERROR_NOSESSION;
    }else{
    Argument = besCONVERT2STRING(Argument);
    besCONVERT2ZCHAR(Argument,pszSession);
    }

  /* if this is the actual session that we delete either because the user
     supplied no argument or because the user supplied the id of the actual
     session then we have to release the read lock on the session           */
  if( bSessDef || (pMT->pszSessionId && !strcmp(pszSession,pMT->pszSessionId)) ){
    besUnlockSharedRead(&(pS->lckSession));
    pMT->pszSessionId;
    pMT->AssignedSession = NULL;
    }

  besLockMutex(&mxSessionTable);
  p = pSt->LookupSymbol(pszSession,SessionTable,0,pSt->Alloc,pSt->Free,besPROCMEMORYSEGMENT);

  /* there is no such session, nothing to delete */
  if( p == NULL ){
    besUnlockMutex(&mxSessionTable);
    if( ! bSessDef )besFREE(pszSession);
    return COMMAND_ERROR_SUCCESS;
    }
  /* store the pointer to the session data */
  pS = *p;

  /* delete the symbol and the symbol tabl entry */
  pSt->DeleteSymbol(pszSession,SessionTable,pSt->Free,besPROCMEMORYSEGMENT);
  besUnlockMutex(&mxSessionTable);

  /* this should not happen. If the session id is in the table it HAS to be initialized */
  if( pS == NULL ){
    /* note that we check it here after the symbol has been deleted */
    if( ! bSessDef )besFREE(pszSession);
    return EXE_ERROR_INTERNAL;
    }

  /*  This lock waits for all executing read locks. Because we have already deleted
      the session symbol from the symbol table no new read locks may start waiting. */
  besLockSharedWrite(&(pS->lckSession));

  /* This call releases all locks using besFinishSharedLock. We should do this because some
     lock implementation in some operating system may loose some resources if we do not
     call the system function releasing a seaphore or mutex but only release the memory.
     If an operating system does not loose any resource if we just release the memory
     allocated for a mutex/semaphore then this function call may be deleted. */
  besTRAVERSESYMBOLTABLE(pS->stSession,FinishSegmentCallBack,pSt);

  /* Delete all memory that was assigned to the session. That is all session variables and their
     corresponding locks. */
  besFINISH_SEGMENT(pS->pMemSeg);
  /* Finish the mutex that has protected the symbol table. */
  besFinishMutex(&(pS->mxSession));
  /* we may unlock this shared lock (we could do it before, but who cares...) 
     there should be no one waiting for it */
  besUnlockSharedWrite(&(pS->lckSession));
  /* finish the session shard lock */
  besFinishSharedLock(&(pS->lckSession));
  /* release the session information finally */
  ReleaseSession(pSt,pS);

  /* If there was a pszSession allocated then release it. If it was the default then the variable
     pszSession already points to a memory location that was released when the session data was
     released. */
  if( ! bSessDef )besFREE(pszSession);
besEND

besFUNCTION(getsession)
  pMtClass pMT;
  char *s;

  pMT = besMODULEPOINTER;
  s = pMT->pszSessionId;
  besRETURNVALUE = NULL;
  if( pMT->AssignedSession == NULL )return COMMAND_ERROR_SUCCESS;
  besALLOC_RETURN_STRING(strlen(s));
  memcpy(STRINGVALUE(besRETURNVALUE),s,strlen(s));
  return COMMAND_ERROR_SUCCESS;
besEND

besFUNCTION(setsvariable)
  VARIABLE Argument;
  char *pszVariableName;
  pMTVariable *p;
  pMtClass pMT;
  pSessionInfo pS;

  besRETURNVALUE = NULL;
  pMT = besMODULEPOINTER;
  pS = pMT->AssignedSession;

  if( besARGNR < 2 )return COMMAND_ERROR_FEW_ARGS;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  if( Argument == NULL )return COMMAND_ERROR_FEW_ARGS;
  Argument = besCONVERT2STRING(Argument);
  besCONVERT2ZCHAR(Argument,pszVariableName);

  besLockMutex(&(pS->mxSession));
  p = (pMTVariable *)pSt->LookupSymbol(pszVariableName,pS->stSession,1,pSt->Alloc,pSt->Free,pS->pMemSeg);
  besFREE(pszVariableName);
  if( p == NULL ){
    besUnlockMutex(&(pS->mxSession));
    return COMMAND_ERROR_MEMORY_LOW;
    }
  /* if this is the first call regarding this variable then create it*/
  if( *p == NULL ){
    *p = pSt->Alloc(sizeof(MTVariable),pS->pMemSeg);
    if( *p == NULL ){
      besUnlockMutex(&(pS->mxSession));
      return COMMAND_ERROR_MEMORY_LOW;
      }
    besInitSharedLock(&((*p)->lckV));
    (*p)->vV = NULL;
    }
  besUnlockMutex(&(pS->mxSession));

  besLockSharedWrite(&((*p)->lckV));

  Argument = besARGUMENT(2);
  besDEREFERENCE(Argument);

  if( (*p)->vV && TYPE((*p)->vV) == VTYPE_STRING && STRINGVALUE((*p)->vV) ){
    pSt->Free(STRINGVALUE((*p)->vV),pS->pMemSeg);
    STRINGVALUE((*p)->vV) = NULL;
    }

  /* we do not need memory to store undef */
  if( IsUndef(Argument) ){
    if( (*p)->vV )pSt->Free((*p)->vV,pS->pMemSeg);
    (*p)->vV = NULL;
    besUnlockSharedWrite(&((*p)->lckV));
    return COMMAND_ERROR_SUCCESS;
    }

  if( (*p)->vV == NULL )(*p)->vV = pSt->Alloc(sizeof(FixSizeMemoryObject),pS->pMemSeg);
  if( (*p)->vV == NULL ){
    besUnlockSharedWrite(&((*p)->lckV));
    return COMMAND_ERROR_MEMORY_LOW;
    }

  (*p)->vV->sType = 0;             /* not used */
  (*p)->vV->State = STATE_UNKNOWN; /* not used */
  (*p)->vV->next = NULL;           /* not used */
  (*p)->vV->link.prev = NULL;           /* not used */
  (*p)->vV->ArrayHighLimit = 0;
  (*p)->vV->ArrayLowLimit  = 1;

  if( TYPE(Argument) == VTYPE_STRING ){
    (*p)->vV->Value.pValue = pSt->Alloc(STRLEN(Argument) ? STRLEN(Argument) : 1 ,pS->pMemSeg);
    if( (*p)->vV->Value.pValue == NULL ){
      pSt->Free((*p)->vV,pS->pMemSeg);
      (*p)->vV = NULL;
      besUnlockSharedWrite(&((*p)->lckV));
      return COMMAND_ERROR_MEMORY_LOW;
      }
    memcpy((*p)->vV->Value.pValue,STRINGVALUE(Argument),STRLEN(Argument));
    (*p)->vV->Size = STRLEN(Argument);
    TYPE((*p)->vV) = VTYPE_STRING;
    besUnlockSharedWrite(&((*p)->lckV));
    return COMMAND_ERROR_SUCCESS;
    }

  if( TYPE(Argument) == VTYPE_LONG || TYPE(Argument) == VTYPE_DOUBLE ){
    TYPE((*p)->vV) = TYPE(Argument);
    (*p)->vV->Size = 0;
    (*p)->vV->Value = Argument->Value;
    besUnlockSharedWrite(&((*p)->lckV));
    return COMMAND_ERROR_SUCCESS;
    }
  
  besUnlockSharedWrite(&((*p)->lckV));
  return EXE_ERROR_INTERNAL;
besEND

besFUNCTION(getsvariable)
  VARIABLE Argument;
  char *pszVariableName;
  pMTVariable *p;
  pMtClass pMT;
  pSessionInfo pS;

  besRETURNVALUE = NULL;
  pMT = besMODULEPOINTER;
  pS = pMT->AssignedSession;

  if( besARGNR < 1 )return COMMAND_ERROR_FEW_ARGS;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  if( Argument == NULL )return COMMAND_ERROR_FEW_ARGS;
  Argument = besCONVERT2STRING(Argument);
  besCONVERT2ZCHAR(Argument,pszVariableName);

  besLockMutex(&(pS->mxSession));
  p = (pMTVariable *)pSt->LookupSymbol(pszVariableName,pS->stSession,0,pSt->Alloc,pSt->Free,pS->pMemSeg);
  besFREE(pszVariableName);
  if( p == NULL ){
    besUnlockMutex(&(pS->mxSession));
    return COMMAND_ERROR_SUCCESS; /* the value is undef, cause it was not defined */
    }

  if( *p == NULL ){
    besUnlockMutex(&(pS->mxSession));
    return COMMAND_ERROR_SUCCESS; /* the value is undef, cause it was defined to be undef */
    }
  besUnlockMutex(&(pS->mxSession));

  if( (*p)->vV == NULL )return COMMAND_ERROR_SUCCESS;

  besLockSharedRead(&((*p)->lckV));

  if( TYPE((*p)->vV) == VTYPE_STRING ){
    besALLOC_RETURN_STRING(STRLEN( (*p)->vV ));
    memcpy(STRINGVALUE(besRETURNVALUE),STRINGVALUE( (*p)->vV ),STRLEN( (*p)->vV) );
    besUnlockSharedRead(&((*p)->lckV));
    return COMMAND_ERROR_SUCCESS;
    }

  if( TYPE((*p)->vV) == VTYPE_LONG ){
    besALLOC_RETURN_LONG;
    LONGVALUE(besRETURNVALUE) = LONGVALUE((*p)->vV);
    besUnlockSharedRead(&((*p)->lckV));
    return COMMAND_ERROR_SUCCESS;
    }

  if( TYPE((*p)->vV) == VTYPE_DOUBLE ){
    besALLOC_RETURN_DOUBLE;
    DOUBLEVALUE(besRETURNVALUE) = DOUBLEVALUE((*p)->vV);
    besUnlockSharedRead(&((*p)->lckV));
    return COMMAND_ERROR_SUCCESS;
    }

  return EXE_ERROR_INTERNAL;
besEND

besFUNCTION(setmtvariable)
  VARIABLE Argument;
  char *pszVariableName;
  pMTVariable *p;
  besRETURNVALUE = NULL;

  if( besARGNR < 2 )return COMMAND_ERROR_FEW_ARGS;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  if( Argument == NULL )return COMMAND_ERROR_FEW_ARGS;
  Argument = besCONVERT2STRING(Argument);
  besCONVERT2ZCHAR(Argument,pszVariableName);

  besLockMutex(&mxMTVariables);
  p = (pMTVariable *)pSt->LookupSymbol(pszVariableName,MtVariables,1,pSt->Alloc,pSt->Free,besPROCMEMORYSEGMENT);
  besFREE(pszVariableName);
  if( p == NULL ){
    besUnlockMutex(&mxMTVariables);
    return COMMAND_ERROR_MEMORY_LOW;
    }

  /* if this is the first call regarding this variable then create it*/
  if( *p == NULL ){
    *p = besPROCALLOC(sizeof(MTVariable));
    if( *p == NULL ){
      besUnlockMutex(&mxMTVariables);
      return COMMAND_ERROR_MEMORY_LOW;
      }
    besInitSharedLock(&((*p)->lckV));
    /* make the variable initially undef */
    (*p)->vV = NULL;
    }
  besUnlockMutex(&mxMTVariables);

  besLockSharedWrite(&((*p)->lckV));

  Argument = besARGUMENT(2);
  besDEREFERENCE(Argument);

  /* release the old value because we are going to replace that anyway */
  if( (*p)->vV && TYPE((*p)->vV) == VTYPE_STRING && STRINGVALUE((*p)->vV) ){
    besPROCFREE(STRINGVALUE((*p)->vV));
    STRINGVALUE((*p)->vV) = NULL;
    }

  /* we do not need memory to store undef */
  if( IsUndef(Argument) ){
    if( (*p)->vV )besPROCFREE((*p)->vV);
    (*p)->vV = NULL;
    besUnlockSharedWrite(&((*p)->lckV));
    return COMMAND_ERROR_SUCCESS;
    }

  if( (*p)->vV == NULL )(*p)->vV = besPROCALLOC(sizeof(FixSizeMemoryObject));
  if( (*p)->vV == NULL ){
    besUnlockSharedWrite(&((*p)->lckV));
    return COMMAND_ERROR_MEMORY_LOW;
    }

  (*p)->vV->sType = 0;             /* not used */
  (*p)->vV->State = STATE_UNKNOWN; /* not used */
  (*p)->vV->next = NULL;           /* not used */
  (*p)->vV->link.prev = NULL;           /* not used */
  (*p)->vV->ArrayHighLimit = 0;
  (*p)->vV->ArrayLowLimit  = 1;

  if( TYPE(Argument) == VTYPE_STRING ){
    (*p)->vV->Value.pValue = besPROCALLOC(STRLEN(Argument) ? STRLEN(Argument) : 1 );
    if( (*p)->vV->Value.pValue == NULL ){
      besUnlockSharedWrite(&((*p)->lckV));
      return COMMAND_ERROR_MEMORY_LOW;
      }
    memcpy((*p)->vV->Value.pValue,STRINGVALUE(Argument),STRLEN(Argument));
    (*p)->vV->Size = STRLEN(Argument);
    TYPE((*p)->vV) = VTYPE_STRING;
    besUnlockSharedWrite(&((*p)->lckV));
    return COMMAND_ERROR_SUCCESS;
    }

  if( TYPE(Argument) == VTYPE_LONG || TYPE(Argument) == VTYPE_DOUBLE ){
    TYPE((*p)->vV) = TYPE(Argument);
    (*p)->vV->Size = 0;
    (*p)->vV->Value = Argument->Value;
    besUnlockSharedWrite(&((*p)->lckV));
    return COMMAND_ERROR_SUCCESS;
    }
  
  besUnlockSharedWrite(&((*p)->lckV));
  return EXE_ERROR_INTERNAL;
besEND

besFUNCTION(getmtvariable)
  VARIABLE Argument;
  char *pszVariableName;
  pMTVariable *p;
  besRETURNVALUE = NULL;

  if( besARGNR < 1 )return COMMAND_ERROR_FEW_ARGS;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  if( Argument == NULL )return COMMAND_ERROR_FEW_ARGS;
  Argument = besCONVERT2STRING(Argument);
  besCONVERT2ZCHAR(Argument,pszVariableName);

  besLockMutex(&mxMTVariables);
  p = (pMTVariable *)pSt->LookupSymbol(pszVariableName,MtVariables,0,pSt->Alloc,pSt->Free,besPROCMEMORYSEGMENT);
  besFREE(pszVariableName);
  if( p == NULL ){
    besUnlockMutex(&mxMTVariables);
    return COMMAND_ERROR_SUCCESS; /* the value is undef, cause it was not defined */
    }

  if( *p == NULL ){
    besUnlockMutex(&mxMTVariables);
    return COMMAND_ERROR_SUCCESS; /* the value is undef, cause it was defined to be undef */
    }
  besUnlockMutex(&mxMTVariables);

  if( (*p)->vV == NULL )return COMMAND_ERROR_SUCCESS;

  besLockSharedRead(&((*p)->lckV));

  if( TYPE((*p)->vV) == VTYPE_STRING ){
    besALLOC_RETURN_STRING(STRLEN( (*p)->vV ));
    memcpy(STRINGVALUE(besRETURNVALUE),STRINGVALUE( (*p)->vV ),STRLEN( (*p)->vV) );
    besUnlockSharedRead(&((*p)->lckV));
    return COMMAND_ERROR_SUCCESS;
    }

  if( TYPE((*p)->vV) == VTYPE_LONG ){
    besALLOC_RETURN_LONG;
    LONGVALUE(besRETURNVALUE) = LONGVALUE((*p)->vV);
    besUnlockSharedRead(&((*p)->lckV));
    return COMMAND_ERROR_SUCCESS;
    }

  if( TYPE((*p)->vV) == VTYPE_DOUBLE ){
    besALLOC_RETURN_DOUBLE;
    DOUBLEVALUE(besRETURNVALUE) = DOUBLEVALUE((*p)->vV);
    besUnlockSharedRead(&((*p)->lckV));
    return COMMAND_ERROR_SUCCESS;
    }

  return EXE_ERROR_INTERNAL;
besEND

besFUNCTION(lockmtwrite)
  VARIABLE Argument;
  char *pszVariableName;
  pMTVariable *p;
  besRETURNVALUE = NULL;

  if( besARGNR < 1 )return COMMAND_ERROR_FEW_ARGS;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  if( Argument == NULL )return COMMAND_ERROR_FEW_ARGS;
  Argument = besCONVERT2STRING(Argument);
  besCONVERT2ZCHAR(Argument,pszVariableName);

  besLockMutex(&mxMTVariables);
  p = (pMTVariable *)pSt->LookupSymbol(pszVariableName,MtVariables,1,pSt->Alloc,pSt->Free,besPROCMEMORYSEGMENT);
  besFREE(pszVariableName);
  if( p == NULL ){
    besUnlockMutex(&mxMTVariables);
    return COMMAND_ERROR_MEMORY_LOW;
    }
  /* if this is the first call regarding this variable then create it*/
  if( *p == NULL ){
    *p = besPROCALLOC(sizeof(MTVariable));
    if( *p == NULL ){
      besUnlockMutex(&mxMTVariables);
      return COMMAND_ERROR_MEMORY_LOW;
      }
    besInitSharedLock(&((*p)->lckV));
    (*p)->vV = NULL;
    }
  besUnlockMutex(&mxMTVariables);

  besLockSharedWrite(&((*p)->lckV));

  return COMMAND_ERROR_SUCCESS;
besEND

besFUNCTION(lockmtread)
  VARIABLE Argument;
  char *pszVariableName;
  pMTVariable *p;
  besRETURNVALUE = NULL;

  if( besARGNR < 1 )return COMMAND_ERROR_FEW_ARGS;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  if( Argument == NULL )return COMMAND_ERROR_FEW_ARGS;
  Argument = besCONVERT2STRING(Argument);
  besCONVERT2ZCHAR(Argument,pszVariableName);

  besLockMutex(&mxMTVariables);
  p = (pMTVariable *)pSt->LookupSymbol(pszVariableName,MtVariables,1,pSt->Alloc,pSt->Free,besPROCMEMORYSEGMENT);
  besFREE(pszVariableName);
  if( p == NULL ){
    besUnlockMutex(&mxMTVariables);
    return COMMAND_ERROR_MEMORY_LOW;
    }
  /* if this is the first call regarding this variable then create it*/
  if( *p == NULL ){
    *p = besPROCALLOC(sizeof(MTVariable));
    if( *p == NULL ){
      besUnlockMutex(&mxMTVariables);
      return COMMAND_ERROR_MEMORY_LOW;
      }
    besInitSharedLock(&((*p)->lckV));
    (*p)->vV = NULL;
    }
  besUnlockMutex(&mxMTVariables);

  besLockSharedRead(&((*p)->lckV));

  return COMMAND_ERROR_SUCCESS;
besEND

besFUNCTION(unlockmtwrite)
  VARIABLE Argument;
  char *pszVariableName;
  pMTVariable *p;
  besRETURNVALUE = NULL;

  if( besARGNR < 1 )return COMMAND_ERROR_FEW_ARGS;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  if( Argument == NULL )return COMMAND_ERROR_FEW_ARGS;
  Argument = besCONVERT2STRING(Argument);
  besCONVERT2ZCHAR(Argument,pszVariableName);

  besLockMutex(&mxMTVariables);
  p = (pMTVariable *)pSt->LookupSymbol(pszVariableName,MtVariables,1,pSt->Alloc,pSt->Free,besPROCMEMORYSEGMENT);
  besFREE(pszVariableName);
  if( p == NULL ){
    besUnlockMutex(&mxMTVariables);
    return COMMAND_ERROR_MEMORY_LOW;
    }
  /* if this is the first call regarding this variable then create it*/
  if( *p == NULL ){
    *p = besPROCALLOC(sizeof(MTVariable));
    if( *p == NULL ){
      besUnlockMutex(&mxMTVariables);
      return COMMAND_ERROR_MEMORY_LOW;
      }
    besInitSharedLock(&((*p)->lckV));
    (*p)->vV = NULL;
    return COMMAND_ERROR_SUCCESS;
    }
  besUnlockMutex(&mxMTVariables);

  besUnlockSharedWrite(&((*p)->lckV));

  return COMMAND_ERROR_SUCCESS;
besEND

besFUNCTION(unlockmtread)
  VARIABLE Argument;
  char *pszVariableName;
  pMTVariable *p;
  besRETURNVALUE = NULL;

  if( besARGNR < 1 )return COMMAND_ERROR_FEW_ARGS;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  if( Argument == NULL )return COMMAND_ERROR_FEW_ARGS;
  Argument = besCONVERT2STRING(Argument);
  besCONVERT2ZCHAR(Argument,pszVariableName);

  besLockMutex(&mxMTVariables);
  p = (pMTVariable *)pSt->LookupSymbol(pszVariableName,MtVariables,1,pSt->Alloc,pSt->Free,besPROCMEMORYSEGMENT);
  besFREE(pszVariableName);
  if( p == NULL ){
    besUnlockMutex(&mxMTVariables);
    return COMMAND_ERROR_MEMORY_LOW;
    }
  /* if this is the first call regarding this variable then create it*/
  if( *p == NULL ){
    *p = besPROCALLOC(sizeof(MTVariable));
    if( *p == NULL ){
      besUnlockMutex(&mxMTVariables);
      return COMMAND_ERROR_MEMORY_LOW;
      }
    besInitSharedLock(&((*p)->lckV));
    (*p)->vV = NULL;
    return COMMAND_ERROR_SUCCESS;
    }
  besUnlockMutex(&mxMTVariables);

  besUnlockSharedRead(&((*p)->lckV));

  return COMMAND_ERROR_SUCCESS;
besEND

besFUNCTION(sessionto)
  VARIABLE Argument;
  pSessionInfo pS;
  pMtClass pMT;

  besRETURNVALUE = NULL;
  pMT = besMODULEPOINTER;
  pS = pMT->AssignedSession;

  /* if there is no actual session selected */
  if( pS == NULL )return MT_ERROR_NOSESSION;

  /* If there is no any argument then it means that the session
     timeout should be cancelled. */
  if( besARGNR < 1 ){
    pS->lTimeout = 0;
    return COMMAND_ERROR_SUCCESS;
    }

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  /* the timeout delay should not be undefined */
  if( Argument == NULL )return COMMAND_ERROR_FEW_ARGS;
  Argument = besCONVERT2LONG(Argument);
  /* convert the delay seconds to absolute GMT time stamp (well timestamp is GMT per def) */
  pS->lTimeout= time(NULL) + LONGVALUE(Argument);

  return COMMAND_ERROR_SUCCESS;
besEND

besFUNCTION(getsesto)
  char *pszSession;
  void **p;
  VARIABLE Argument;
  pSessionInfo pS;
  pMtClass pMT;
  int bSessDef; /* TRUE if the session was the default (actual) session 
                   This variable also shows that pszSession should be realeased */

  pMT = besMODULEPOINTER;
  pS = pMT->AssignedSession;

  besRETURNVALUE = NULL;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  if( Argument == NULL ){
    bSessDef = 1;
    pszSession = pMT->pszSessionId;
    if( pszSession == NULL )return MT_ERROR_NOSESSION;
    }else{
    bSessDef = 0;
    Argument = besCONVERT2STRING(Argument);
    besCONVERT2ZCHAR(Argument,pszSession);
    }

  besLockMutex(&mxSessionTable);
  p = pSt->LookupSymbol(pszSession,SessionTable,0,pSt->Alloc,pSt->Free,besPROCMEMORYSEGMENT);

  /* there is no such session, there is no timeout */
  if( p == NULL ){
    besUnlockMutex(&mxSessionTable);
    if( ! bSessDef )besFREE(pszSession);
    besRETURNVALUE = NULL; /* return undef */
    if( ! bSessDef )besFREE(pszSession);
    return COMMAND_ERROR_SUCCESS;
    }
  /* store the pointer to the session data */
  pS = *p;

  besUnlockMutex(&mxSessionTable);

  /* this should not happen. If the session id is in the table it HAS to be initialized */
  if( pS == NULL ){
    /* note that we check it here after the symbol has been deleted */
    if( ! bSessDef )besFREE(pszSession);
    besRETURNVALUE = NULL;
    if( ! bSessDef )besFREE(pszSession);
    return EXE_ERROR_INTERNAL;
    }

  besALLOC_RETURN_LONG;
  LONGVALUE(besRETURNVALUE) = pS->lTimeout;
  /* If there was a pszSession allocated then release it. If it was the default then the variable
     pszSession already points to a memory location that was released when the session data was
     released. */
  if( ! bSessDef )besFREE(pszSession);
besEND

besFUNCTION(getsespt)
  char *pszSession;
  void **p;
  VARIABLE Argument;
  pSessionInfo pS;
  pMtClass pMT;
  int bSessDef; /* TRUE if the session was the default (actual) session 
                   This variable also shows that pszSession should be realeased */

  pMT = besMODULEPOINTER;
  pS = pMT->AssignedSession;

  besRETURNVALUE = NULL;

  Argument = besARGUMENT(1);
  besDEREFERENCE(Argument);
  if( Argument == NULL ){
    bSessDef = 1;
    pszSession = pMT->pszSessionId;
    if( pszSession == NULL )return MT_ERROR_NOSESSION;
    }else{
    bSessDef = 0;
    Argument = besCONVERT2STRING(Argument);
    besCONVERT2ZCHAR(Argument,pszSession);
    }

  besLockMutex(&mxSessionTable);
  p = pSt->LookupSymbol(pszSession,SessionTable,0,pSt->Alloc,pSt->Free,besPROCMEMORYSEGMENT);

  /* there is no such session, there is no ping time */
  if( p == NULL ){
    besUnlockMutex(&mxSessionTable);
    if( ! bSessDef )besFREE(pszSession);
    besRETURNVALUE = NULL; /* return undef */
    if( ! bSessDef )besFREE(pszSession);
    return COMMAND_ERROR_SUCCESS;
    }
  /* store the pointer to the session data */
  pS = *p;

  besUnlockMutex(&mxSessionTable);

  /* this should not happen. If the session id is in the table it HAS to be initialized */
  if( pS == NULL ){
    /* note that we check it here after the symbol has been deleted */
    if( ! bSessDef )besFREE(pszSession);
    besRETURNVALUE = NULL;
    if( ! bSessDef )besFREE(pszSession);
    return EXE_ERROR_INTERNAL;
    }

  besALLOC_RETURN_LONG;
  LONGVALUE(besRETURNVALUE) = pS->lPingTime;
  /* If there was a pszSession allocated then release it. If it was the default then the variable
     pszSession already points to a memory location that was released when the session data was
     released. */
  if( ! bSessDef )besFREE(pszSession);
besEND

besFUNCTION(listses)
  VARIABLE Argument,*Lval;
  long cSessionList;
  pSessionInfo pS;
  /* Timeout and Ping time min and max crtiteria values */
  unsigned long lToMin,lToMax,lPtMin,lPtMax,lStMin,lStMax;
  int iError;
  long __refcount_;

  Argument = besARGUMENT(1);
  besLEFTVALUE(Argument,Lval);
  if( ! Lval )return COMMAND_ERROR_ARGUMENT_TYPE;
  besRELEASE(*Lval);
  iError = besGETARGS "*[iiiiii]" , &lStMin, &lStMax, &lPtMin, &lPtMax, &lToMin, &lToMax besGETARGE

  if( iError )return iError;

#define SESSION__CONSTRAINT \
        ( lToMin < pS->lTimeout )  && \
        ( lPtMin < pS->lPingTime)  && \
        ( lStMin < pS->lTimeStart) &&\
        ( (!lToMax) || lToMax > pS->lTimeout)  && \
        ( (!lPtMax) || lPtMax > pS->lPingTime) && \
        ( (!lStMax) || lStMax > pS->lTimeStart)

  pS = pSessionRoot;
  cSessionList = 0;
  besLockMutex(&mxSessionTable);
  while( pS ){
    if( SESSION__CONSTRAINT )cSessionList ++;
    pS = pS->next;
    }

  if( cSessionList == 0 ){
    *Lval = NULL;
    besUnlockMutex(&mxSessionTable);
    return COMMAND_ERROR_SUCCESS;
    }
  *Lval = besNEWARRAY(1,cSessionList);
  if( *Lval == NULL ){
    besUnlockMutex(&mxSessionTable);
    return COMMAND_ERROR_MEMORY_LOW;
    }

  pS = pSessionRoot;
  cSessionList = 0;
  while( pS ){
    if( SESSION__CONSTRAINT ){
      (*Lval)->Value.aValue[cSessionList] = besNEWSTRING(strlen(pS->pszId));
      if( (*Lval)->Value.aValue[cSessionList] == NULL ){
        besUnlockMutex(&mxSessionTable);
        return COMMAND_ERROR_MEMORY_LOW;
        }
      memcpy(STRINGVALUE((*Lval)->Value.aValue[cSessionList]),pS->pszId,strlen(pS->pszId));
      cSessionList ++;
      }
    pS = pS->next;
    }

  besUnlockMutex(&mxSessionTable);


besEND


besVERSION_NEGOTIATE

  return (int)INTERFACE_VERSION;

besEND


besSUB_FINISH
  pSessionInfo pS;
  pMtClass pMT;

  pMT = besMODULEPOINTER;
  pS = pMT->AssignedSession;

 /* This macro decrements the thread counter used to help to keep this library in memory 
    even those times when the process is idle and no ScriptBasic threads are running. */
  DEC_THREAD_COUNTER

  /* Release the session from the read lock (if any) */
  if( pS )besUnlockSharedRead(&(pS->lckSession));

besEND

besDLL_MAIN

/* This function is used to tell the ScriptBasic interpreter whether to call FreeLibrary/dlclose
   or not. When this function returns TRUE the interpreter unloads the library. If this function
   returns FALSE the interpreter does not call FreeLibrary/dlclose and thus the library remains
   in memory even when there is no any thread actually using it. */
besSUB_KEEP
  long lTC;

  /* get the actual value of the thread counter that counts the number of threads using the library
     currently */
  GET_THREAD_COUNTER(lTC);
  /* if this was the last thread then we will return 0 not to unload the library and therefore
     this thread finish should not be counted */
  if( lTC == 0 ){
    INC_THREAD_COUNTER
    }
  /* conver the long counter to (int) boolean */
  return lTC ? 1 : 0;
besEND

besSUB_PROCESS_START
  INIT_MULTITHREAD
  return 1;
besEND

besSUB_PROCESS_FINISH
  FINISH_MULTITHREAD
besEND

SLFST MT_SLFST[] ={

{ "keepmodu" , keepmodu },
{ "shutmodu" , shutmodu },
{ "bootmodu" , bootmodu },
{ "setsession" , setsession },
{ "chksession" , chksession },
{ "sessioncount" , sessioncount },
{ "newsession" , newsession },
{ "delsession" , delsession },
{ "getsession" , getsession },
{ "setsvariable" , setsvariable },
{ "getsvariable" , getsvariable },
{ "setmtvariable" , setmtvariable },
{ "getmtvariable" , getmtvariable },
{ "lockmtwrite" , lockmtwrite },
{ "lockmtread" , lockmtread },
{ "unlockmtwrite" , unlockmtwrite },
{ "unlockmtread" , unlockmtread },
{ "sessionto" , sessionto },
{ "getsesto" , getsesto },
{ "getsespt" , getsespt },
{ "listses" , listses },
{ "versmodu" , versmodu },
{ "finimodu" , finimodu },
{ "keepmodu" , keepmodu },
{ "_init" , _init },
{ "_fini" , _fini },
{ NULL , NULL }
  };

---