void DH_Pool_SavePostToLocalFile(ILibThreadPool pool, void *var)
{
struct DH_Data *data = (struct DH_Data*)var;
struct packetheader *resp;
struct ILibWebServer_Session *session = data->session;
int paused=0;
lock_wait(&(data->TransferStatus->syncLock));
if(data->TransferStatus->Reserved1!=0)
{
data->TransferStatus->Reserved2 = 1;
data->TransferStatus->Reserved3 = data;
paused=1;
}
lock_post(&(data->TransferStatus->syncLock));
if(paused)
{
ILibWebServer_Release(session);
return;
}
if(data->session->bufferLength!=0)
{
fwrite(data->session->buffer,sizeof(char),data->session->bufferLength,data->f);
}
lock_wait(&(data->TransferStatus->syncLock));
data->TransferStatus->ActualBytesReceived += data->session->bufferLength;
lock_post(&(data->TransferStatus->syncLock));
if(data->session->done!=0)
{
fclose(data->f);
data->f = NULL;
//
// Finished Saving file
//
resp = ILibCreateEmptyPacket();
ILibSetVersion(resp,"1.1",3);
ILibSetStatusCode(resp,200,"OK",2);
ILibWebServer_Send(data->session,resp);
data->session->User3 = NULL;
data->session->Reserved7 = NULL;
data->session->OnReceive = data->OriginalReceivePtr;
if(data->callback_response!=NULL)
{
data->callback_response(data->session,data->TransferStatus,DHS_ERRORS_NONE,data->user_object);
}
DH_DestroyTransferStatus(data->TransferStatus);
free(data);
}
ILibWebServer_Resume(session);
ILibWebServer_Release(session);
}
void DHC_Pool(ILibThreadPool sender, void *var)
{
struct DHC_Data *data = (struct DHC_Data*)var;
int bytesRead = -1;
long currentPosition;
if(data->TransferStatus->TotalBytesToBeSent==-1)
{
lock_wait(&(data->TransferStatus->syncLock));
currentPosition = ftell(data->f);
fseek(data->f,0,SEEK_END);
data->TransferStatus->TotalBytesToBeSent = ftell(data->f) - currentPosition;
fseek(data->f,currentPosition,SEEK_SET);
lock_post(&(data->TransferStatus->syncLock));
}
if(data->f!=NULL && feof(data->f))
{
fclose(data->f);
data->f = NULL;
printf("C");
ILibWebClient_StreamRequestBody(data->token,NULL,0,ILibAsyncSocket_MemoryOwnership_STATIC,1);
}
else
{
bytesRead = (int)fread(data->buffer,sizeof(char),data->bufferLength,data->f);
if(bytesRead>0)
{
ILibWebClient_StreamRequestBody(data->token,data->buffer,bytesRead,ILibAsyncSocket_MemoryOwnership_USER,0);
lock_wait(&(data->TransferStatus->syncLock));
data->TransferStatus->ActualBytesSent += (long)bytesRead;
lock_post(&(data->TransferStatus->syncLock));
}
else
{
//
// Read Error
//
if(feof(data->f))
{
fclose(data->f);
data->f = NULL;
ILibWebClient_StreamRequestBody(data->token,NULL,0,ILibAsyncSocket_MemoryOwnership_STATIC,1);
}
}
}
}
void worker_thread(void *user)
{
JOBPOOL *pool = (JOBPOOL *)user;
while(1)
{
JOB *job = 0;
/* fetch job from queue */
lock_wait(pool->lock);
if(pool->first_job)
{
job = pool->first_job;
pool->first_job = pool->first_job->next;
if(pool->first_job)
pool->first_job->prev = 0;
else
pool->last_job = 0;
}
lock_release(pool->lock);
/* do the job if we have one */
if(job)
{
job->status = JOBSTATUS_RUNNING;
job->result = job->func(job->func_data);
job->status = JOBSTATUS_DONE;
}
else
thread_sleep(10);
}
}
void snd_stop(int vid)
{
/* TODO: a nice fade out */
lock_wait(sound_lock);
voices[vid].snd = 0;
lock_release(sound_lock);
}
static int play(int cid, int sid, int flags, float x, float y)
{
int vid = -1;
int i;
lock_wait(sound_lock);
/* search for voice */
for(i = 0; i < NUM_VOICES; i++)
{
int id = (next_voice + i) % NUM_VOICES;
if(!voices[id].snd)
{
vid = id;
next_voice = id+1;
break;
}
}
/* voice found, use it */
if(vid != -1)
{
voices[vid].snd = &samples[sid];
voices[vid].channel = &channels[cid];
voices[vid].tick = 0;
voices[vid].vol = 255;
voices[vid].flags = flags;
voices[vid].x = (int)x;
voices[vid].y = (int)y;
}
lock_release(sound_lock);
return vid;
}
static void CurlLock(CURL *pHandle, curl_lock_data Data, curl_lock_access Access, void *pUser)
{
(void)pHandle;
(void)Access;
(void)pUser;
lock_wait(gs_aLocks[GetLockIndex(Data)]);
}
int CSound::Play(int ChannelId, int SampleId, int Flags, float x, float y)
{
int VoiceId = -1;
int i;
lock_wait(m_SoundLock);
// search for voice
for(i = 0; i < NUM_VOICES; i++)
{
int id = (m_NextVoice + i) % NUM_VOICES;
if(!m_aVoices[id].m_pSample)
{
VoiceId = id;
m_NextVoice = id+1;
break;
}
}
// voice found, use it
if(VoiceId != -1)
{
m_aVoices[VoiceId].m_pSample = &m_aSamples[SampleId];
m_aVoices[VoiceId].m_pChannel = &m_aChannels[ChannelId];
m_aVoices[VoiceId].m_Tick = 0;
m_aVoices[VoiceId].m_Vol = 255;
m_aVoices[VoiceId].m_Flags = Flags;
m_aVoices[VoiceId].m_X = (int)x;
m_aVoices[VoiceId].m_Y = (int)y;
}
lock_release(m_SoundLock);
return VoiceId;
}
void write_log(char * log_content) {
lock_wait(LOG_LOCK);
FILE * log_file = fopen(LOG_FILE, "a");
fputs(log_content, log_file);
fclose(log_file);
lock_release(LOG_LOCK);
}
void CJobPool::WorkerThread(void *pUser)
{
CJobPool *pPool = (CJobPool *)pUser;
while(1)
{
CJob *pJob = 0;
// fetch job from queue
lock_wait(pPool->m_Lock);
if(pPool->m_pFirstJob)
{
pJob = pPool->m_pFirstJob;
pPool->m_pFirstJob = pPool->m_pFirstJob->m_pNext;
if(pPool->m_pFirstJob)
pPool->m_pFirstJob->m_pPrev = 0;
else
pPool->m_pLastJob = 0;
}
lock_unlock(pPool->m_Lock);
// do the job if we have one
if(pJob)
{
pJob->m_Status = CJob::STATE_RUNNING;
pJob->m_Result = pJob->m_pfnFunc(pJob->m_pFuncData);
pJob->m_Status = CJob::STATE_DONE;
}
else
thread_sleep(10);
}
}
void CStream::Add(const char *pData, int Size)
{
if (Size == 0)
{
return;
}
lock_wait(m_Lock);
CStreamBlock *pNew = new CStreamBlock();
pNew->m_pNext = 0;
pNew->m_Start = 0;
pNew->m_Size = Size;
pNew->m_pData = new char[Size];
mem_copy(pNew->m_pData, pData, Size);
if (m_pFirst == 0)
{
m_pFirst = pNew;
}
else
{
CStreamBlock *pLast = m_pFirst;
while(pLast->m_pNext)
{
pLast = pLast->m_pNext;
}
pLast->m_pNext = pNew;
}
m_Size += Size;
lock_release(m_Lock);
}
void IndexBlocks_Destroy(IndexBlocks blocks)
{
struct _IndexBlocks* instance = (struct _IndexBlocks*)blocks;
struct _IndexBlockNode* node = NULL;
if(blocks == NULL ||
#if defined(_POSIX)
instance->_sem_ret == -1
#else
instance->_sync == NULL
#endif
)
{
return;
}
lock_wait(&instance->_sync);
lock_destroy(&instance->_sync);
#if defined(_POSIX)
instance->_sem_ret = -1;
#else
instance->_sync = NULL;
#endif
node = instance->_firstNode;
while(node != NULL)
{
struct _IndexBlockNode* next = node->Next;
free(node);
node = next;
}
free(instance);
}
void DH_Disconnect(struct ILibWebServer_Session *session)
{
struct DH_Data *data = (struct DH_Data*)session->User3;
int SendStatus = 0;
if(data!=NULL)
{
lock_wait(&(data->SendStatusLock));
SendStatus = data->SendStatus;
lock_post(&(data->SendStatusLock));
if(SendStatus>0 || SendStatus<0)
{
if(data->f!=NULL)
{
if(data->callback_response!=NULL)
{
data->callback_response(data->session, data->TransferStatus, DHS_ERRORS_PEER_ABORTED_CONNECTION,data->user_object);
}
fclose(data->f);
data->f = NULL;
}
DH_DestroyTransferStatus(data->TransferStatus);
lock_destroy(&(data->SendStatusLock));
free(data);
}
else
{
data->Disconnect=1;
}
}
}
void CFetcher::QueueAdd(CFetchTask *pTask, const char *pUrl, const char *pDest, int StorageType, void *pUser, COMPFUNC pfnCompCb, PROGFUNC pfnProgCb)
{
str_copy(pTask->m_aUrl, pUrl, sizeof(pTask->m_aUrl));
str_copy(pTask->m_aDest, pDest, sizeof(pTask->m_aDest));
pTask->m_StorageType = StorageType;
pTask->m_pfnProgressCallback = pfnProgCb;
pTask->m_pfnCompCallback = pfnCompCb;
pTask->m_pUser = pUser;
pTask->m_Size = pTask->m_Progress = 0;
pTask->m_Abort = false;
lock_wait(m_Lock);
if(!m_pThHandle)
{
m_pThHandle = thread_init(&FetcherThread, this);
thread_detach(m_pThHandle);
}
if(!m_pFirst)
{
m_pFirst = pTask;
m_pLast = m_pFirst;
}
else
{
m_pLast->m_pNext = pTask;
m_pLast = pTask;
}
pTask->m_State = CFetchTask::STATE_QUEUED;
lock_unlock(m_Lock);
}
void CFileScore::SaveScoreThread(void *pUser)
{
CFileScore *pSelf = (CFileScore *)pUser;
lock_wait(gs_ScoreLock);
std::fstream f;
f.open(SaveFile().c_str(), std::ios::out);
if(!f.fail())
{
int t = 0;
for(sorted_array<CPlayerScore>::range r = pSelf->m_Top.all(); !r.empty(); r.pop_front())
{
f << r.front().m_aName << std::endl << r.front().m_Score << std::endl;
if(g_Config.m_SvCheckpointSave)
{
for(int c = 0; c < NUM_CHECKPOINTS; c++)
f << r.front().m_aCpTime[c] << " ";
f << std::endl;
}
t++;
if(t%50 == 0)
thread_sleep(1);
}
}
f.close();
lock_release(gs_ScoreLock);
}
void CSound::Stop(int VoiceId)
{
// TODO: a nice fade out
lock_wait(m_SoundLock);
m_aVoices[VoiceId].m_pSample = 0;
lock_release(m_SoundLock);
}
void DHC_OnSendOK(ILibWebClient_StateObject sender, void *user1, void *user2)
{
struct DHC_Data *data = (struct DHC_Data*)user2;
int ok = 0;
void *Abort = NULL;
lock_wait(&(data->TransferStatus->syncLock));
if(data->TransferStatus->Reserved1!=0)
{
data->TransferStatus->Reserved2 = 1;
data->TransferStatus->Reserved3 = data;
}
else if(data->TransferStatus->Reserved4==0)
{
ok = 1;
}
if(data->TransferStatus->Reserved4!=0 && data->TransferStatus->RequestToken!=NULL)
{
//
// Abort
//
Abort = data->TransferStatus->RequestToken;
data->TransferStatus->RequestToken = NULL;
}
lock_post(&(data->TransferStatus->syncLock));
if(Abort==NULL && ok && data->f!=NULL && data->GotContinue!=0)
{
ILibThreadPool_QueueUserWorkItem(data->pool,data,&DHC_Pool);
}
else if(Abort!=NULL)
{
ILibWebClient_CancelRequest(Abort);
}
}
int IndexBlocks_GetTrackCount(IndexBlocks blocks)
{
int result = -1;
struct _IndexBlocks* instance = (struct _IndexBlocks*)blocks;
if(instance != NULL)
{
if(
#if defined(_POSIX)
instance->_sem_ret == -1
#else
instance->_sync == NULL
#endif
)
{
return result;
}
lock_wait(&instance->_sync);
if(instance->_firstNode == NULL)
{
result = 0;
}
else
{
struct _IndexBlockNode* lastNode = _GetLastNode(instance->_firstNode);
result = (int)lastNode->FirstTrackNumber + (int)lastNode->TrackCount;
}
lock_post(&instance->_sync);
}
return result;
}
void ThreadUpdates(void *params)
{
InfoUpdatesThread *pInfoThread = static_cast<InfoUpdatesThread*>(params);
lock_wait(m_UpdatesLock);
pInfoThread->m_pUpdater->DoUpdates(pInfoThread->m_pMenus);
lock_unlock(m_UpdatesLock);
}
/* ARGSUSED */
void
mraccessf(mrlock_t *mrp, int flags)
{
MRLOCK(mrp);
if(mrp->mr_writes_waiting > 0) {
mrp->mr_reads_waiting++;
lock_wait(&mrp->mr_readerq, &mrp->mr_lock, 0);
mrp->mr_reads_waiting--;
}
while (mrp->mr_count < 0) {
mrp->mr_reads_waiting++;
lock_wait(&mrp->mr_readerq, &mrp->mr_lock, 0);
mrp->mr_reads_waiting--;
}
mrp->mr_count++;
MRUNLOCK(mrp);
}
void DH_Pool_RequestResponse(ILibThreadPool sender, void *obj)
{
struct DHC_Data *data = (struct DHC_Data*)obj;
int okToFree = 0;
if(data->bufferLength>0)
{
fwrite(data->buffer,sizeof(char),data->bufferLength,data->f);
}
lock_wait(&(data->TransferStatus->syncLock));
data->TransferStatus->ActualBytesReceived += data->bufferLength;
lock_post(&(data->TransferStatus->syncLock));
if(data->GotContinue)
{
fclose(data->f);
if(data->Callback!=NULL)
{
data->Callback(data->TransferStatus, DHC_ERRORS_NONE, 200, "OK",data->user);
}
okToFree = 1;
}
if(!okToFree)
{
lock_wait(&(data->TransferStatus->syncLock));
if(data->TransferStatus->Reserved1!=0)
{
data->TransferStatus->Reserved2 = 1;
}
else
{
ILibWebClient_Resume(data->webState);
}
lock_post(&(data->TransferStatus->syncLock));
}
else
{
ILibWebClient_Resume(data->webState);
DH_DestroyTransferStatus(data->TransferStatus);
free(data);
}
}
CFileScore::~CFileScore()
{
lock_wait(gs_ScoreLock);
// clear list
m_Top.clear();
lock_release(gs_ScoreLock);
}
// update stuff
void CSqlScore::LoadScoreThread(void *pUser)
{
lock_wait(gs_SqlLock);
CSqlScoreData *pData = (CSqlScoreData *)pUser;
// Connect to database
if(pData->m_pSqlData->Connect())
{
try
{
// check strings
pData->m_pSqlData->ClearString(pData->m_aName);
char aBuf[512];
str_format(aBuf, sizeof(aBuf), "SELECT * FROM %s_%s_race WHERE Name='%s' ORDER BY time ASC LIMIT 1;", pData->m_pSqlData->m_pPrefix, pData->m_pSqlData->m_aMap, pData->m_aName);
pData->m_pSqlData->m_pResults = pData->m_pSqlData->m_pStatement->executeQuery(aBuf);
if(pData->m_pSqlData->m_pResults->next())
{
// get the best time
pData->m_pSqlData->PlayerData(pData->m_ClientID)->m_BestTime = (float)pData->m_pSqlData->m_pResults->getDouble("Time");
char aColumn[8];
if(g_Config.m_SvCheckpointSave)
{
for(int i = 0; i < NUM_CHECKPOINTS; i++)
{
str_format(aColumn, sizeof(aColumn), "cp%d", i+1);
pData->m_pSqlData->PlayerData(pData->m_ClientID)->m_aBestCpTime[i] = (float)pData->m_pSqlData->m_pResults->getDouble(aColumn);
}
}
}
dbg_msg("SQL", "Getting best time done");
// delete statement and results
delete pData->m_pSqlData->m_pStatement;
delete pData->m_pSqlData->m_pResults;
}
catch (sql::SQLException &e)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "MySQL Error: %s", e.what());
dbg_msg("SQL", aBuf);
dbg_msg("SQL", "ERROR: Could not update account");
}
// disconnect from database
pData->m_pSqlData->Disconnect();
}
delete pData;
lock_release(gs_SqlLock);
}
FifoConsole::~FifoConsole()
{
if(m_pFifoFile[0] == '\0')
return;
lock_wait(gs_FifoLock);
gs_stopFifoThread = true;
lock_unlock(gs_FifoLock);
gs_FifoLock = 0;
}
void CSound::StopAll()
{
// TODO: a nice fade out
lock_wait(m_SoundLock);
for(int i = 0; i < NUM_VOICES; i++)
{
m_aVoices[i].m_pSample = 0;
}
lock_release(m_SoundLock);
}
Long oz_knl_user_increfc (OZ_User *user, Long inc)
{
Long refc;
OZ_KNL_CHKOBJTYPE (user, OZ_OBJTYPE_USER);
lock_wait (); /* keep others from mucking with list */
refc = user_increfc (user, inc); /* make modifications */
lock_clr (); /* allow others to modify list */
return (refc); /* return new reference count */
}
void CSqlScore::ShowTop5Thread(void *pUser)
{
lock_wait(gs_SqlLock);
CSqlScoreData *pData = (CSqlScoreData *)pUser;
// Connect to database
if(pData->m_pSqlData->Connect())
{
try
{
// check sort methode
char aBuf[512];
str_format(aBuf, sizeof(aBuf), "SELECT Name, min(Time) as Time FROM %s_%s_race Group By Name ORDER BY `Time` ASC LIMIT %d, 5;", pData->m_pSqlData->m_pPrefix, pData->m_pSqlData->m_aMap, pData->m_Num-1);
pData->m_pSqlData->m_pResults = pData->m_pSqlData->m_pStatement->executeQuery(aBuf);
// show top5
pData->m_pSqlData->GameServer()->SendChatTarget(pData->m_ClientID, "----------- Top 5 -----------");
int Rank = pData->m_Num;
float Time = 0;
while(pData->m_pSqlData->m_pResults->next())
{
Time = (float)pData->m_pSqlData->m_pResults->getDouble("Time");
str_format(aBuf, sizeof(aBuf), "%d. %s Time: %d minute(s) %.2f second(s)", Rank, pData->m_pSqlData->m_pResults->getString("Name").c_str(), (int)(Time/60), Time-((int)Time/60*60));
pData->m_pSqlData->GameServer()->SendChatTarget(pData->m_ClientID, aBuf);
Rank++;
}
pData->m_pSqlData->GameServer()->SendChatTarget(pData->m_ClientID, "-------------------------------");
dbg_msg("SQL", "Showing top5 done");
// delete results and statement
delete pData->m_pSqlData->m_pResults;
delete pData->m_pSqlData->m_pStatement;
}
catch (sql::SQLException &e)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "MySQL Error: %s", e.what());
dbg_msg("SQL", aBuf);
dbg_msg("SQL", "ERROR: Could not show top5");
}
// disconnect from database
pData->m_pSqlData->Disconnect();
}
delete pData;
lock_release(gs_SqlLock);
}
OZ_User *oz_knl_user_getnext (OZ_User *lastuser)
{
OZ_User *user;
lock_wait ();
if (lastuser == NULL) user = users;
else user = lastuser -> next;
if (user != NULL) user_increfc (user, 1);
lock_clr ();
return (user);
}
/* ARGSUSED */
void
mrupdatef(mrlock_t *mrp, int flags)
{
MRLOCK(mrp);
while(mrp->mr_count) {
mrp->mr_writes_waiting++;
lock_wait(&mrp->mr_writerq, &mrp->mr_lock, 1);
mrp->mr_writes_waiting--;
}
mrp->mr_count = -1; /* writer on it */
MRUNLOCK(mrp);
}
CLuaFile::~CLuaFile()
{
m_MySQLThread.m_Running = false;
lock_wait(m_MySQLThread.m_MySSQLLock);
lock_release(m_MySQLThread.m_MySSQLLock);
lock_destroy(m_MySQLThread.m_MySSQLLock);
#ifndef CONF_PLATFORM_MACOSX
End();
if (m_pLua)
lua_close(m_pLua);
m_pLua = 0;
#endif
}
OZ_Job *oz_knl_job_getnext (OZ_Job *lastjob, OZ_User *user)
{
OZ_Job *job;
lock_wait ();
if (lastjob == NULL) job = user -> jobs;
else job = lastjob -> next;
if (job != NULL) oz_knl_job_increfc (job, 1);
lock_clr ();
return (job);
}
