#include "common.h"

#define NO_CACHEID -1

static unsigned int cacheHead = 0; // our marker for last allocated cache, used to find next free one

static unsigned int* cacheIndex = 0; // data ring of the caches + timestamp/volley info

char* cacheBase = 0; // start of contiguous cache block of caches

static int currentCache = NO_CACHEID; // the current user file buffer

unsigned int userCacheCount = 1; // holds 1 user by default

unsigned int userCacheSize = DEFAULT_USER_CACHE; // size of user file buffer (our largest buffers)

int volleyLimit = -1; // default save user records to file every n volley (use default 0 if this value is unchanged by user)

char* userDataBase = NULL; // current write user record base

unsigned int userTopicStoreSize,userTableSize; // memory used which we will display

void InitCache()

}

void CloseCache()

}

static void WriteCache(unsigned int which,size_t size)

}

void FlushCache() // writes out the cache but does not invalidate it

}

char* GetFreeCache() // allocate backwards from current, so in use is always NEXT from current

{

if (!userCacheCount) return NULL;

unsigned int duration = (clock() / CLOCKS_PER_SEC) - startSystem; // how many seconds since start of program launch

// need to find a cache that's free else flush oldest one

unsigned int last = cacheIndex[PRIOR(cacheHead)]; // PRIOR ptr of list start

char* ptr = GetCacheBuffer(last);

if (*ptr) // this is in use

{

WriteCache(last,0);

*ptr = 0; // clear cache so it can be reused

}

cacheIndex[TIMESTAMP(last)] = duration; // includes 0 volley count and when this was allocated

currentCache = cacheHead = last; // just rotate the ring - has more than one block

return ptr;

}

void FreeUserCache()

}

void FreeAllUserCaches()

}

char* FindUserCache(char* word)

{

// already in cache?

unsigned int start = cacheHead;

while (userCacheCount)

{

char* ptr = GetCacheBuffer(start);

size_t len = strlen(word);

if (!strnicmp(ptr,word,len) && ptr[len+1] == '\r') // this is the user

{

if (start != cacheHead) // make him FIRST on the list

{

unsigned int prior = cacheIndex[PRIOR(start)];

unsigned int next = cacheIndex[NEXT(start)];

// decouple from where it is

cacheIndex[NEXT(prior)] = next;

cacheIndex[PRIOR(next)] = prior;

// now insert in front

prior = cacheIndex[PRIOR(cacheHead)];

cacheIndex[PRIOR(cacheHead)] = start;

cacheIndex[NEXT(prior)] = start;

cacheIndex[PRIOR(start)] = prior;

cacheIndex[NEXT(start)] = cacheHead;

}

currentCache = cacheHead = start;

return ptr;

}

start = cacheIndex[NEXT(start)];

if (start == cacheHead) break; // end of loop

}

return NULL;

}

void CopyUserTopicFile(char* newname)

}

char* GetFileRead(char* user,char* computer)

{

char word[MAX_WORD_SIZE];

sprintf(word,(char*)"%s/%stopic_%s_%s.txt",users,GetUserPath(loginID),user,computer);

if (stricmp(language,"english")) sprintf(word, (char*)"%s/%stopic_%s_%s_%s.txt", users, GetUserPath(loginID), user, computer,language);

char* buffer;

if ( filesystemOverride == NORMALFILES) // local files

{

char name[MAX_WORD_SIZE];

strcpy(name,word);

strcat(name,"\r\n");

buffer = FindUserCache(name); // sets currentCache and makes it first if non-zero return - will either find but not assign if not found

if (buffer) return buffer;

}

clock_t start_time = ElapsedMilliseconds();

// have to go read it

buffer = GetFreeCache(); // get cache buffer

FILE* in = (!buffer) ? NULL : userFileSystem.userOpen(word); // user topic file

#ifdef LOCKUSERFILE

#ifdef LINUX

if (server && in && filesystemOverride == NORMALFILES)

{

int fd = fileno(in);

if (fd < 0)

{

userFileSystem.userClose(in);

in = 0;

}

else

{

struct flock fl;

fl.l_type = F_RDLCK; /* F_RDLCK, F_WRLCK, F_UNLCK */

fl.l_whence = SEEK_SET; /* SEEK_SET, SEEK_CUR, SEEK_END */

fl.l_start = 0; /* Offset from l_whence */

fl.l_len = 0; /* length, 0 = to EOF */

fl.l_pid = getpid(); /* our PID */

if (fcntl(fd, F_SETLKW, &fl) < 0)

{

userFileSystem.userClose(in);

in = 0;

}

}

}

#endif

#endif

if (in) // read in data if file exists

{

size_t readit;

readit = DecryptableFileRead(buffer,1,userCacheSize,in,userEncrypt,"USER"); // reading topic file of user

buffer[readit] = 0;

buffer[readit+1] = 0; // insure nothing can overrun

userFileSystem.userClose(in);

if (trace & TRACE_USERCACHE) Log((server) ? SERVERLOG : STDTRACELOG,(char*)"read in %s cache (%d)\r\n",word,currentCache);

if (timing & TIME_USERCACHE) {

int diff = ElapsedMilliseconds() - start_time;

if (timing & TIME_ALWAYS || diff > 0) Log((server) ? SERVERLOG : STDTIMELOG, (char*)"Read user cache %d in file %s time: %d ms\r\n", currentCache, word, diff);

}

}

return buffer;

}

char* GetCacheBuffer(int which)

{

return (which < 0) ? GetFreeCache() : (cacheBase+(which * userCacheSize)); // NOT from cache system, get a cache buffer

}

char* GetUserFileBuffer() // when we need a really big buffer (several megabytes)

{

return GetFreeCache();

}

void Cache(char* buffer, size_t size) // save into cache

}