{

if (init)

{

if (fullInputLimit == 0) fullInputLimit = maxBufferSize * 2;

readBuffer = (char*)malloc(fullInputLimit);

*readBuffer = 0;

lastInputSubstitution = (char*)malloc(maxBufferSize);

rawSentenceCopy = (char*)malloc(maxBufferSize);

revertBuffer = (char*)malloc(maxBufferSize);

inputCopy = (char*)malloc(fullInputLimit);

ourMainInputBuffer = (char*)malloc(fullInputLimit); // precaution for overflow

currentOutputLimit = outputsize;

currentRuleOutputBase = currentOutputBase = ourMainOutputBuffer = (char*)malloc(outputsize);

// need allocatable buffers for things that run ahead like servers and such.

maxBufferSize = (maxBufferSize + 63);

maxBufferSize &= 0xffffffc0; // force 64 bit align on size

unsigned int total = maxBufferLimit * maxBufferSize;

buffers = (char*)malloc(total); // have it around already for messages

if (!buffers)

{

(*printer)((char*)"%s", (char*)"cannot allocate buffer space");

myexit((char*)"FATAL: cannot allocate buffer space");

}

bufferIndex = 0;

baseBufferIndex = bufferIndex;

}

else

{

free(readBuffer);

free(lastInputSubstitution);

free(inputCopy);

free(rawSentenceCopy);

free(revertBuffer);

free(ourMainInputBuffer);

free(ourMainOutputBuffer);

// free(buffers); see CloseBuffers()

}

{

startSystem = clock() / CLOCKS_PER_SEC;

*currentFilename = 0; // no files are open (if logging bugs)

tokenControl = 0;

outputlevel = 0;

*computerID = 0; // default bot

{

char* eq = strchr(word, '=');

if (eq)

{

*eq = 0;

ReturnToAfterLayer(currentBeforeLayer-1, true);

*word = USERVAR_PREFIX;

SetUserVariable(word, eq + 1);

if (server && debugLevel > 0) Log(SERVERLOG,"botvariable: %s = %s\r\n", word, eq + 1);

else if(debugLevel > 0) (*printer )((char*)"botvariable: %s = %s\r\n", word, eq + 1);

NoteBotVariables(); // these go into level 1

LockLayer(false);

// need to restore the initial markers so that a restart can process them

*eq = '=';

*word = 'V';

}

{

// move dead/transient facts to end

FACT* tailArea = lastFactUsed + 1; // last fact

FACT* G = NULL;

while (++F <= lastFactUsed)

{

if (!(F->flags & (FACTTRANSIENT | FACTDEAD)))

{

F->flags |= FACTBUILD1;

continue;

}

else if (!F->subject) continue; // already moved this one

UnweaveFact(F);

bool dead = true;

if (!G) G = F;

while (++G < tailArea)

{

if ((G->flags & (FACTTRANSIENT | FACTDEAD))) continue;

if (!G->subject) break; // already dead

UnweaveFact(G); // cut from from dictionary referencing

memcpy(F, G, sizeof(FACT)); // replicate fact lower

WeaveFact(F); // rebind fact to dictionary

F->flags |= FACTBUILD1;

G->flags |= FACTDEAD;

dead = false;

break;

}

if (dead)

{

// kill this completely in case we cant overwrite it with valid fact

F->subject = F->verb = F->object = 0;

F->flags |= FACTDEAD;

}

}

while (!lastFactUsed->subject) --lastFactUsed; // reclaim

{

if (!boot || noboot)

{// noboot is command line paramenter to block use of boot

rebooting = false;

return;

}

// boot== ^csboot on startup (reboot==false) vs ^cs_reboot per volley (reboot==true)

if (volleyboot) rebooting = true; // global awareness we are rebooting vs system startup

else // system startup boot

{

}

// run script on startup of system. data it generates will also be layer 1 data

int oldtrace = trace;

int oldtiming = timing;

if (traceboot) trace = (unsigned int) -1;

if (*bootcmd) DoCommand(bootcmd, NULL, false); // run this command before CSBOOT is run. eg to trace boot process

if (!volleyboot) UnlockLayer(LAYER_BOOT); // unlock it to add stuff

else currentBeforeLayer = LAYER_BOOT; // be in user layer (before is boot layer)

FACT* F = lastFactUsed; // note facts allocated before running boot

Callback(boot, (char*)"()", true, true); // do before world is locked

*ourMainOutputBuffer = 0; // remove any boot message

myBot = 0; // restore fact owner to generic all

// cs_reboot may call boot to reload layer, this flag

// rebooting might be wrong...

if (!volleyboot)

{

RelocateDeadBootFacts(F);

NoteBotVariables(); // convert user variables read into bot variables in boot layer

LockLayer(false); // rewrite level 2 start data with augmented from script data

}

else

{

ReturnToAfterLayer(LAYER_BOOT, false); // dict/fact/strings reverted and any extra topic loaded info (but CSBoot process NOT lost)

}

trace = (modifiedTrace) ? modifiedTraceVal : oldtrace;

timing = (modifiedTiming) ? modifiedTimingVal : oldtiming;

stackFree = stackStart; // drop any possible stack used

rebooting = false;

{

memset(depthcount, 0, sizeof(int)*limit);

unused = 0;

int words = 0;

for (unsigned long i = 0; i <= maxHashBuckets; ++i)

{

int n = 0;

if (!hashbuckets[i]) ++unused;

else

{

WORDP D = Index2Word(hashbuckets[i]);

while (D != dictionaryBase)

{

++n;

D = Index2Word(GETNEXTNODE(D));

}

}

words += n; // n is number of words in this bucket

if (n && n < limit)

depthcount[n] += n; // this many words have a bucket access of n

}

return words;

{

char buffer[5000];

char word[MAX_WORD_SIZE];

FILE* in = FopenReadOnly(file);

if (in)

{

while (ReadALine(buffer, in, MAX_WORD_SIZE) >= 0)

{

ReadCompiledWord(buffer, word);

if (*word == 'V') SetBotVariable(word); // these are level 1 values

}

fclose(in);

}

{

uint64 starttime = ElapsedMilliseconds();

tableinput = NULL;

overrideAuthorization = false; // always start safe

loading = true;

char* os;

mystart("createsystem");

#ifdef WIN32

os = "Windows";

#elif IOS

os = "IOS";

#elif __MACH__

os = "MACH";

#elif FREEBSD

os = "FreeBSD";

#else

os = "LINUX";

#endif

if (!buffers) // restart asking for new memory allocations

{

maxBufferSize = (maxBufferSize + 63);

maxBufferSize &= 0xffffffC0; // force 64 bit align

unsigned int total = maxBufferLimit * maxBufferSize;

buffers = (char*) malloc(total); // have it around already for messages

if (!buffers)

{

(*printer)((char*)"%s",(char*)"cannot allocate buffer space");

myexit((char*)"FATAL: cannot allocate buffer space");

}

bufferIndex = 0;

baseBufferIndex = bufferIndex;

}

char data[MAX_WORD_SIZE];

char* kind;

int pid = 0;

#ifdef EVSERVER

kind = "EVSERVER";

pid = getpid();

#elif DEBUG

kind = "Debug";

#else

kind = "Release";

#endif

sprintf(data,(char*)"ChatScript %s Version %s pid: %d %ld bit %s compiled %s",kind,version,pid,(long int)(sizeof(char*) * 8),os,compileDate);

strcat(data,(char*)" host=");

strcat(data,hostname);

if (server) Log(SERVERLOG,"Server %s\r\n",data);

strcat(data,(char*)"\r\n");

(*printer)((char*)"%s",data);

int oldtrace = trace; // in case trace turned on by default

trace = 0;

*oktest = 0;

sprintf(data,(char*)"Params: dict:%lu fact:%lu text:%lukb hash:%lu \r\n",(unsigned long )maxDictEntries,(unsigned long)maxFacts,(unsigned long)(maxHeapBytes/1000),(unsigned long)maxHashBuckets);

if (server) Log(SERVERLOG,"%s",data);

else (*printer)((char*)"%s",data);

sprintf(data,(char*)" buffer:%ux%ukb cache:%ux%ukb userfacts:%u outputlimit:%u loglimit:%u\r\n",(unsigned int)maxBufferLimit,(unsigned int)(maxBufferSize/1000),(unsigned int)userCacheCount,(unsigned int)(userCacheSize/1000),(unsigned int)userFactCount,

outputsize,logsize);

if (server) Log(SERVERLOG,"%s",data);

else (*printer)((char*)"%s",data);

// in case

MakeDirectory(topicfolder);

char name[MAX_WORD_SIZE];

sprintf(name, "%s/BUILD0", topicfolder);

MakeDirectory(name);

sprintf(name, "%s/BUILD1", topicfolder);

MakeDirectory(name);

LoadSystem(); // builds base facts and dictionary (from wordnet)

*currentFilename = 0;

*debugEntry = 0;

char word[MAX_WORD_SIZE];

for (int i = 1; i < argc; ++i)

{

strcpy(word,argv[i]);

if (*word == '"' && word[1] == 'V')

{

memmove(word,word+1,strlen(word));

size_t len = strlen(word);

if (word[len-1] == '"') word[len-1] = 0;

}

if (*word == 'V') SetBotVariable(word); // predefined bot variable in level 1

}

for (int i=0;i<configLinesLength;i++)

{

char* line = configLines[i];

if (*line == 'V') SetBotVariable(line); // these are level 1 values

}

kernelVariableThreadList = botVariableThreadList;

botVariableThreadList = NULL;

UnlockLayer(LAYER_BOOT); // unlock it to add stuff

trace = oldtrace; // allow boot tracing

HandleReBoot(FindWord((char*)"^csboot"),false);// run script on startup of system. data it generates will also be layer 1 data

LockLayer(true);

currentBeforeLayer = LAYER_BOOT;

InitSpellCheck(); // after boot vocabulary added

unsigned int factUsedMemKB = ( lastFactUsed-factBase) * sizeof(FACT) / 1000;

unsigned int lastFactUsedMemKB = ( factEnd-lastFactUsed) * sizeof(FACT) / 1000;

unsigned int dictUsedMemKB = ( dictionaryFree-dictionaryBase) * sizeof(WORDENTRY) / 1000;

// dictfree shares text space

unsigned int textUsedMemKB = ( heapBase-heapFree) / 1000;

unsigned int textFreeMemKB = ( heapFree- heapEnd) / 1000;

unsigned int bufferMemKB = (maxBufferLimit * maxBufferSize) / 1000;

unsigned int used = factUsedMemKB + dictUsedMemKB + textUsedMemKB + bufferMemKB;

used += (userTopicStoreSize + userTableSize) /1000;

unsigned int free = lastFactUsedMemKB + textFreeMemKB;

unsigned int bytes = (tagRuleCount * MAX_TAG_FIELDS * sizeof(uint64)) / 1000;

used += bytes;

char buf2[MAX_WORD_SIZE];

char buf1[MAX_WORD_SIZE];

char buf[MAX_WORD_SIZE];

strcpy(buf,StdIntOutput(lastFactUsed-factBase));

strcpy(buf2,StdIntOutput(textFreeMemKB));

unsigned int depthcount[100];

unsigned int unused;

unsigned int words = CountWordsInBuckets(unused, depthcount,100);

char depthmsg[1000];

int x = 100;

while (!depthcount[--x]); // find last used slot

char* at = depthmsg;

*at = 0;

for (int i = 1; i <= x; ++i)

{

sprintf(at, "%u.", depthcount[i]);

at += strlen(at);

}

sprintf(data, (char*)"Used %uMB: dict %s (%ukb) hashdepths %s words %u unusedbuckets %u fact %s (%ukb) heap %ukb\r\n",

used / 1000,

StdIntOutput(dictionaryFree - dictionaryBase - 1),

dictUsedMemKB, depthmsg,words,unused,

buf,

factUsedMemKB,

textUsedMemKB);

if (server) Log(SERVERLOG,"%s",data);

else (*printer)((char*)"%s",data);

sprintf(data,(char*)" buffer (%ukb) cache (%uWkb)\r\n",

bufferMemKB,

(userTopicStoreSize + userTableSize)/1000);

if(server) Log(SERVERLOG,"%s",data);

else (*printer)((char*)"%s",data);

strcpy(buf,StdIntOutput(factEnd-lastFactUsed)); // unused facts

strcpy(buf1,StdIntOutput(textFreeMemKB)); // unused text

strcpy(buf2,StdIntOutput(free/1000));

sprintf(data,(char*)"Free %sMB: dict %s fact %s stack/heap %sKB \r\n\r\n",

buf2,StdIntOutput(((unsigned int)maxDictEntries)-(dictionaryFree-dictionaryBase)),buf,buf1);

if (server) Log(SERVERLOG,"%s",data);

else (*printer)((char*)"%s",data);

trace = oldtrace;

#ifdef DISCARDSERVER

(*printer)((char*)" Server disabled.\r\n");

#endif

#ifdef DISCARDSCRIPTCOMPILER

if(server) Log(SERVERLOG," Script compiler disabled.\r\n");

else (*printer)((char*)" Script compiler disabled.\r\n");

#endif

#ifdef DISCARDTESTING

if(server) Log(SERVERLOG," Testing disabled.\r\n");

else (*printer)((char*)" Testing disabled.\r\n");

#else

*callerIP = 0;

if (server && VerifyAuthorization(FopenReadOnly((char*)"authorizedIP.txt"))) // authorizedIP

{

Log(SERVERLOG," *** Server WIDE OPEN to :command use.\r\n");

}

#endif

char route[100];

*route = 0;

#ifdef DISCARDJSONOPEN

sprintf(route, (char*)"%s", (char*)" JSONOpen access disabled.\r\n");

if (server) Log(SERVERLOG, route);

else (*printer)(route);

#endif

#ifdef TREETAGGER

sprintf(route, (char*)" TreeTagger access enabled: %s\r\n",language);

if (server) Log(SERVERLOG, route);

else (*printer)(route);

#endif

#ifndef DISCARDMICROSOFTSQL

if (gzip)

{

sprintf(route, (char*)" Text Compression enabled\r\n");

if (server) Log(SERVERLOG, route);

else (*printer)(route);

}

#endif

(*printer)((char*)"%s",(char*)"\r\n");

loading = false;

printf("System created in %u ms\r\n", (unsigned int)(ElapsedMilliseconds() - starttime));

{// reset the basic system

myBot = 0; // facts loaded here are universal

originalUserInput = NULL;

InitFacts(); // malloc space

InitStackHeap(); // malloc space

InitTextUtilities(); // also part of basic system before a build

InitDictionary(); // malloc space

LoadDictionary(heapFree);

InitTextUtilities1(); // also part of basic system before a build

InitUserCache(); // malloc space

InitFunctionSystem(); // modify dictionary entries

InitScriptSystem();

InitVariableSystem();

InitSystemVariables();

ReadLiveData(); // below layer 0

#ifdef TREETAGGER

// We will be reserving some working space for treetagger on the heap

// so make sure it is tucked away where it cannot be touched

// NOT IN DEBUGGER WILL FORCE reloads of layers

InitTreeTagger(treetaggerParams);

#endif

WordnetLockDictionary();

InitTopicSystem(); // dictionary reverts to wordnet zone

ReadBotVariable(configFile);

ReadBotVariable(configFile2);

{

if (!argumentsSeen)

{

char path[MAX_WORD_SIZE];

*path = 0;

GetCurrentDir(path, MAX_WORD_SIZE);

(*printer)("CommandLine: %s\r\n",path);

argumentsSeen = true;

}

#ifndef NOARGTRACE

(*printer)(" %s\r\n",arg);

#endif

if (!strnicmp(arg, (char*)"trace", 5))

{

if (arg[5] == '=') trace = atoi(arg + 6);

else trace = (unsigned int)-1;

}

else if (!strnicmp(arg, (char*)"language=", 9))

{

strcpy(language, arg + 9);

MakeUpperCase(language);

}

else if (!strnicmp(arg, (char*)"buildflags=", 11)) CopyParam(buildflags, arg + 11, 100);

else if (!strnicmp(arg, (char*)"buffer=", 7)) // number of large buffers available 8x80000

{

maxBufferLimit = atoi(arg + 7);

char* size = strchr(arg + 7, 'x');

if (size) maxBufferSize = atoi(size + 1) * 1000;

if (maxBufferSize < OUTPUT_BUFFER_SIZE)

{

(*printer)((char*)"Buffer cannot be less than OUTPUT_BUFFER_SIZE of %d\r\n", OUTPUT_BUFFER_SIZE);

myexit((char*)"FATAL buffer size less than output buffer size");

}

}

else if (!strnicmp(arg, (char*)"timer=", 6))

{

char* x = strchr(arg + 6, 'x'); // 15000x10

if (x)

{

*x = 0;

timerCheckRate = atoi(x + 1);

}

timerLimit = atoi(arg + 6);

}

else if (!stricmp(arg, (char*)"trustpos")) trustpos = true;

else if (!strnicmp(arg, (char*)"inputlimit=", 11)) inputLimit = atoi(arg + 11);

else if (!strnicmp(arg, (char*)"fullInputlimit=", 15)) fullInputLimit = atoi(arg + 15);

else if (!strnicmp(arg, (char*)"debug=", 6)) CopyParam(debugEntry, arg + 6, 1000);

else if (!strnicmp(arg, "erasename=", 10)) CopyParam(erasename, arg + 10, 100);

else if (!strnicmp(arg, "cs_new_user=", 12)) CopyParam(newusername, arg + 12, 100);

else if (!stricmp(arg, "userencrypt")) userEncrypt = true;

else if (!stricmp(arg, "ltmencrypt")) ltmEncrypt = true;

else if (!strnicmp(arg, "defaultbot=", 11)) CopyParam(defaultbot, arg + 11, 100);

else if (!strnicmp(arg, "traceuser=", 10)) CopyParam(traceuser, arg + 10);

else if (!stricmp(arg, (char*)"noboot")) noboot = true;

else if (!stricmp(arg, (char*)"noretrybackup")) noretrybackup = true;

else if (!stricmp(arg, (char*)"traceboot")) traceboot = true;

else if (!stricmp(arg, (char*)"trace")) trace = (unsigned int)-1; // make trace work on login

else if (!stricmp(arg, (char*)"time")) timing = (unsigned int)-1 ^ TIME_ALWAYS; // make timing work on login

else if (!stricmp(arg, (char*)"recordboot")) recordBoot = true;

else if (!stricmp(arg, (char*)"servertrace")) servertrace = true;

else if (!strnicmp(arg, (char*)"repeatlimit=", 12)) repeatLimit = atoi(arg + 12);

else if (!strnicmp(arg, (char*)"apikey=", 7)) CopyParam(apikey, arg + 7);

else if (!strnicmp(arg, (char*)"logsize=", 8)) logsize = atoi(arg + 8); // bytes avail for log buffer

else if (!strnicmp(arg, (char*)"loglimit=", 9)) loglimit = atoi(arg + 9); // max mb of log file before change files

else if (!strnicmp(arg, (char*)"outputsize=", 11)) outputsize = atoi(arg + 11); // bytes avail for output buffer

else if (!stricmp(arg, (char*)"time")) timing = (unsigned int)-1 ^ TIME_ALWAYS;

else if (!strnicmp(arg, (char*)"bootcmd=", 8)) CopyParam(bootcmd, arg + 8);

#ifdef WIN32

else if (!strnicmp(arg, (char*)"windowsbuglog=", 14)) CopyParam(externalBugLog, arg + 14);

#else

else if (!strnicmp(arg, (char*)"linuxbuglog=", 12)) CopyParam(externalBugLog, arg + 12);

#endif

else if (!strnicmp(arg, (char*)"dir=", 4))

{

#ifdef WIN32

if (!SetCurrentDirectory(arg + 4)) (*printer)((char*)"unable to change to %s\r\n", arg + 4);

#else

chdir(arg + 5);

#endif

}

else if (!strnicmp(arg, (char*)"source=", 7)) CopyParam(sourceInput, arg + 7);

else if (!strnicmp(arg,(char*)"login=",6)) CopyParam(loginID,arg+6);

else if (!strnicmp(arg,(char*)"output=",7)) outputLength = atoi(arg+7);

else if (!strnicmp(arg,(char*)"save=",5))

{

volleyLimit = atoi(arg+5);

if (volleyLimit > 255) volleyLimit = 255; // cant store higher

}

// memory sizings

else if (!strnicmp(arg,(char*)"hash=",5))

{

maxHashBuckets = atoi(arg+5); // size of hash

setMaxHashBuckets = true;

}

else if (!strnicmp(arg,(char*)"dict=",5)) maxDictEntries = atoi(arg+5); // how many dict words allowed

else if (!strnicmp(arg,(char*)"fact=",5)) maxFacts = atoi(arg+5); // fact entries

else if (!strnicmp(arg,(char*)"text=",5)) maxHeapBytes = atoi(arg+5) * 1000; // stack and heap bytes in pages

else if (!strnicmp(arg,(char*)"debuglevel=",11)) debugLevel = atoi(arg+11); // log level entries

else if (!strnicmp(arg,(char*)"cache=",6)) // value of 10x0 means never save user data

{

userCacheSize = atoi(arg+6) * 1000;

char* number = strchr(arg+6,'x');

if (number) userCacheCount = atoi(number+1);

}

else if (!strnicmp(arg, (char*)"nofastload", 10)) fastload = false; // how many user facts allowed

else if (!strnicmp(arg,(char*)"userfacts=",10)) userFactCount = atoi(arg+10); // how many user facts allowed

else if (!stricmp(arg,(char*)"redo")) redo = true; // enable redo

else if (!strnicmp(arg,(char*)"authorize=",10)) CopyParam(authorizations,arg+10); // whitelist debug commands

else if (!stricmp(arg,(char*)"nodebug")) *authorizations = '1';

else if (!strnicmp(arg,(char*)"users=",6 )) CopyParam(usersfolder,arg+6);

else if (!strnicmp(arg,(char*)"logs=",5 )) CopyParam(logsfolder,arg+5);

else if (!strnicmp(arg,(char*)"topic=",6 )) CopyParam(topicfolder,arg+6);

else if (!strnicmp(arg,(char*)"tmp=",4 )) CopyParam(tmpfolder,arg+4);

else if (!strnicmp(arg, (char*)"buildfiles=", 11)) CopyParam(buildfiles, arg + 11);

else if (!strnicmp(arg,(char*)"private=",8)) privateParams = arg+8;

else if (!strnicmp(arg, (char*)"treetagger", 10))

{

if (arg[10] == '=') CopyParam(treetaggerParams, arg + 11);

else CopyParam(treetaggerParams, "1");

}

else if (!strnicmp(arg,(char*)"encrypt=",8)) CopyParam(encryptParams,arg+8);

else if (!strnicmp(arg,(char*)"decrypt=",8)) CopyParam(decryptParams,arg+8);

else if (!stricmp(arg, (char*)"noautoreload")) autoreload = false;

else if (!strnicmp(arg,(char*)"livedata=",9) )

{

CopyParam(livedataFolder,arg+9);

sprintf(systemFolder,(char*)"%s/SYSTEM",arg+9);

sprintf(languageFolder,(char*)"%s/%s",arg+9,language);

}

else if (!strnicmp(arg,(char*)"nosuchbotrestart=",17) )

{

if (!stricmp(arg+17,"true")) nosuchbotrestart = true;

else nosuchbotrestart = false;

}

else if (!strnicmp(arg,(char*)"system=",7) ) CopyParam(systemFolder,arg+7);

else if (!strnicmp(arg,(char*)"english=",8) ) CopyParam(languageFolder,arg+8);

else if (!strnicmp(arg, (char*)"db=", 3)) db = atoi(arg + 3);

else if (!strnicmp(arg, (char*)"gzip=", 5)) gzip = atoi(arg + 5);

else if (!strnicmp(arg, (char*)"syslogstr=", 10)) CopyParam(syslogstr, arg + 10);

#ifndef DISCARDMYSQL

else if (!strnicmp(arg, (char*)"mysql=", 6))

{

CopyParam(mysqlparams, arg + 6, 300);

strcpy(dbparams, mysqlparams);

}

#endif

#ifndef DISCARDMICROSOFTSQL

else if (!strnicmp(arg, (char*)"mssql=", 6))

{

CopyParam(mssqlparams, arg + 6, 300);

strcpy(dbparams, mssqlparams);

}

#endif

#ifndef DISCARDPOSTGRES

else if (!strnicmp(arg, (char*)"pguser=", 7))

{

CopyParam(postgresparams, arg + 7, 300);

strcpy(dbparams, postgresparams);

}

// Postgres Override SQL

else if (!strnicmp(arg,(char*)"pguserread=",11) )

{

CopyParam(postgresuserread, arg+11);

pguserread = postgresuserread;

}

else if (!strnicmp(arg,(char*)"pguserinsert=",13) )

{

CopyParam(postgresuserinsert, arg+13);

pguserinsert = postgresuserinsert;

}

else if (!strnicmp(arg,(char*)"pguserupdate=",13) )

{

CopyParam(postgresuserupdate, arg+13);

pguserupdate = postgresuserupdate;

}

#endif

#ifndef DISCARDWEBSOCKET

else if (!strnicmp(arg, (char*)"websocket=", 10))

{

CopyParam(websocketparams, arg + 10,300);

server = true;

}

else if (!strnicmp(arg, (char*)"websocketmessage=", 17)) CopyParam(websocketmessage, arg + 17,300);

#endif

#ifndef DISCARDMONGO

else if (!strnicmp(arg, (char*)"mongo=", 6))

{

CopyParam(mongodbparams, arg + 6, 300);

strcpy(dbparams, mongodbparams);

}

#endif

#ifndef DISCARDCLIENT

else if (!strnicmp(arg,(char*)"client=",7)) // client=1.2.3.4:1024 or client=localhost:1024

{

server = false;

client = true;

char buffer[MAX_WORD_SIZE];

CopyParam(serverIP,arg+7);

char* portVal = strchr(serverIP,':');

if ( portVal)

{

*portVal = 0;

port = atoi(portVal+1);

}

if (!*loginID)

{

(*printer)((char*)"%s",(char*)"\r\nEnter client user name: ");

ReadALine(buffer,stdin);

(*printer)((char*)"%s",(char*)"\r\n");

Client(buffer);

}

else Client(loginID);

exit(0);

}

#endif

else if (!stricmp(arg, (char*)"nouserlog")) userLog = 0;

else if (!strnicmp(arg, "userlogging=", 12))

{

userLog = NO_LOG;

if (strstr(arg, "none")) userLog = NO_LOG;

if (strstr(arg, "file")) userLog |= FILE_LOG;

if (strstr(arg, "stdout")) userLog |= STDOUT_LOG;

if (strstr(arg, "stderr")) userLog |= STDERR_LOG;

if (strstr(arg, "prelog")) userLog |=PRE_LOG;

}

else if (!strnicmp(arg, "userlog",7))

{

userLog = FILE_LOG;

if (arg[7] == '=')

{

if (IsDigit(arg[8])) userLog = atoi(arg + 8);

else userLog = NO_LOG;

}

}

else if (!strnicmp(arg, "autorestartdelay=", 17)) autorestartdelay = atoi( arg + 17);

else if (!strnicmp(arg, "jmeter=", 7)) CopyParam(jmeter, arg + 7);

else if (!stricmp(arg, (char*)"dieonwritefail")) dieonwritefail = true;

else if (strstr(arg, (char*)"crnl_safe")) crnl_safe = true;

else if (!strnicmp(arg, (char*)"blockapitrace=",14)) blockapitrace = atoi(arg+14);

else if (!strnicmp(arg, (char*)"hidefromlog=", 12)) CopyParam(hide, arg+12);

#ifndef DISCARDSERVER

else if (!stricmp(arg,"serverretry")) serverRetryOK = true;

else if (!stricmp(arg,"local")) server = false; // local standalone

else if (!strnicmp(arg, "serverlogauthcode=", 18)) CopyParam(serverlogauthcode,arg + 18);

else if (!stricmp(arg, "noserverlog")) serverLog = NO_LOG;

else if (!strnicmp(arg, "serverlogging=", 14))

{

serverLog = NO_LOG;

if (strstr(arg, "none")) serverLog = NO_LOG;

if (strstr(arg, "file")) serverLog |= FILE_LOG;

if (strstr(arg, "stdout")) serverLog |= STDOUT_LOG;

if (strstr(arg, "stderr")) serverLog |= STDERR_LOG;

if (strstr(arg, "prelog")) serverLog |= PRE_LOG;

}

else if (!strnicmp(arg, "serverlog", 9))

{

if (arg[9] == '=' && IsDigit(arg[10])) serverLog = atoi(arg + 10) | PRE_LOG;

else serverLog = FILE_LOG| PRE_LOG;

}

else if (!stricmp(arg, "nobuglog")) bugLog = NO_LOG;

else if (!strnicmp(arg, "buglogging=", 11))

{

bugLog = NO_LOG;

if (strstr(arg, "none")) bugLog = NO_LOG;

if (strstr(arg, "file")) bugLog |= FILE_LOG;

if (strstr(arg, "stdout")) bugLog |= STDOUT_LOG;

if (strstr(arg, "stderr")) bugLog |= STDERR_LOG;

}

else if (!strnicmp(arg, "buglog",6))

{

bugLog = FILE_LOG;

if (arg[6] == '=')

{

if (IsDigit(arg[7])) bugLog |= atoi(arg + 7);

else bugLog = NO_LOG;

}

}

else if (!strnicmp(arg, (char*)"timelog=",8)) timeLog = atoi(arg+8);

else if (!stricmp(arg, (char*)"noserverprelog")) serverPreLog = false;

else if (!stricmp(arg,(char*)"serverctrlz")) serverctrlz = 1;

else if (!strnicmp(arg, (char*)"stdlogging=", 11)) stdlogging = (atoi(arg + 11) != 0) ? true : false; // means server logging should go to std out (enabled server logging)

else if (!strnicmp(arg,(char*)"port=",5)) // be a server

{

port = atoi(arg+5); // accept a port=

server = true;

#ifdef LINUX

if (forkcount > 1) {

sprintf(serverLogfileName, (char*)"%s/serverlog%d-%d.txt", logsfolder, port,getpid());

sprintf(dbTimeLogfileName, (char*)"%s/dbtimelog%d-%d.txt", logsfolder, port, getpid());

}

else {

sprintf(serverLogfileName, (char*)"%s/serverlog%d.txt", logsfolder, port);

sprintf(dbTimeLogfileName, (char*)"%s/dbtimelog%d.txt", logsfolder, port);

}

#else

sprintf(serverLogfileName,(char*)"%s/serverlog%u.txt", logsfolder,port); // DEFAULT LOG

sprintf(dbTimeLogfileName, (char*)"%s/dbtimelog%u.txt", logsfolder, port);

#endif

}

#ifdef EVSERVER

else if (!strnicmp(arg, "fork=", 5))

{

forkcount = atoi(arg + 5);

sprintf(forkCount,(char*)"evsrv:fork=%d", forkcount);

evsrv_arg = forkCount;

#ifdef LINUX

if (forkcount > 1) {

sprintf(serverLogfileName, (char*)"%s/serverlog%d-%d.txt", logsfolder, port, getpid());

sprintf(dbTimeLogfileName, (char*)"%s/dbtimelog%d-%d.txt", logsfolder, port, getpid());

}

else {

sprintf(serverLogfileName, (char*)"%s/serverlog%d.txt", logsfolder, port);

sprintf(dbTimeLogfileName, (char*)"%s/dbtimelog%d.txt", logsfolder, port);

}

#else

sprintf(serverLogfileName, (char*)"%s/serverlog%d.txt", logsfolder, port); // DEFAULT LOG

sprintf(dbTimeLogfileName, (char*)"%s/dbtimelog%d.txt", logsfolder, port);

#endif

}

#endif

else if (!strnicmp(arg,(char*)"interface=",10)) interfaceKind = string(arg+10); // specify interface

#endif

for (int i=0; i< configLinesLength; i++){

ProcessArgument(TrimSpaces(configLines[i],true));

}