extern int characterlist_destroy(void)
{
t_elem * curr;
t_character * ch;
if (characterlist_head)
{
LIST_TRAVERSE(characterlist_head,curr)
{
ch = (t_character*)elem_get_data(curr);
if (!ch) /* should not happen */
{
eventlog(eventlog_level_error,__FUNCTION__,"characterlist contains NULL item");
continue;
}
if (list_remove_elem(characterlist_head,&curr)<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not remove item from list");
xfree(ch);
}
if (list_destroy(characterlist_head)<0)
return -1;
characterlist_head = NULL;
}
static int tear_down_program(SceneData* sceneData, SceneObject* so, SoData* soData) {
tear_down_shaders ( sceneData, so, soData );
char progKey[KEYSIZE];
snprintf (progKey, KEYSIZE, "%p,%p", &so->vShader, &so->fShader);
GLuint program = (GLuint)hashmap_find(progKey, sceneData->mapShaderShader2Handle);
size_t programUsers = (size_t)hashmap_find ( progKey, sceneData->countProgramUsers );
programUsers--;
if ( 0 == programUsers ) {
glDeleteProgram ( program );
hashmap_delete ( progKey, sceneData->mapShaderShader2Handle );
hashmap_delete ( progKey, sceneData->countProgramUsers );
list_remove_elem ( (void*)program, sceneData->listPrograms );
} else {
hashmap_insert ( progKey, (void*)programUsers, sceneData->countProgramUsers );
}
return 0;
}
int topiclist_unload(void)
{
t_elem * curr;
t_topic * topic;
if (topiclist_head)
{
LIST_TRAVERSE(topiclist_head, curr)
{
if (!(topic = (t_topic*)elem_get_data(curr)))
{
eventlog(eventlog_level_error, __FUNCTION__, "found NULL entry in list");
continue;
}
if (topic->channel_name) xfree((void *)topic->channel_name);
if (topic->topic) xfree((void *)topic->topic);
xfree((void *)topic);
list_remove_elem(topiclist_head, &curr);
}
if (list_destroy(topiclist_head) < 0)
return -1;
topiclist_head = NULL;
}
return 0;
}
extern int timerlist_del_all_timers(t_connection * owner)
{
t_elem * curr;
t_timer * timer;
if (!owner)
{
eventlog(eventlog_level_error,"timerlist_del_all_timers","got NULL owner");
return -1;
}
LIST_TRAVERSE(timerlist_head,curr)
{
timer = elem_get_data(curr);
if (!timer) /* should not happen */
{
eventlog(eventlog_level_error,"timerlist_del_all_timers","timerlist contains NULL item");
return -1;
}
if (timer->owner==owner)
{
if (timer->cb)
timer->cb(timer->owner,(time_t)0,timer->data);
timer->cb = NULL;
timer->owner = NULL;
if (list_remove_elem(timerlist_head,curr)<0)
{
eventlog(eventlog_level_error,"timerlist_del_all_timers","could not remove timer");
continue;
}
free(timer);
}
}
void rr_wait(sched_queue_t *queue) {
list_elem_t *head;
thread_info_t *worker;
/* Get head of queue */
if(!pthread_mutex_lock(queue->access_mutex)) {
head = list_get_head(queue->list);
if(head) {
worker = (thread_info_t*) head->datum;
list_remove_elem(queue->list, head);
list_insert_tail(queue->list, head);
} else {
/* Queue is empty. Just leave then. */
pthread_mutex_unlock(queue->access_mutex);
return;
}
pthread_mutex_unlock(queue->access_mutex);
} else {
/* Handle queue access lock failure */
}
/* Block until worker has finished */
if(!pthread_mutex_lock(worker->yield_cpu)) {
/* Error handling */
}
}
extern int gametrans_unload(void)
{
t_elem * curr;
t_gametrans * entry;
if (gametrans_head)
{
LIST_TRAVERSE(gametrans_head,curr)
{
if (!(entry = elem_get_data(curr)))
eventlog(eventlog_level_error,"gametrans_unload","found NULL entry in list");
else
{
netaddr_destroy(entry->exclude);
addr_destroy(entry->output);
addr_destroy(entry->client);
addr_destroy(entry->viewer);
free(entry);
}
list_remove_elem(gametrans_head,curr);
}
list_destroy(gametrans_head);
gametrans_head = NULL;
}
return 0;
}
static int tear_down_index_buffer (SceneData* sceneData, SceneObject* so, SoData* soData) {
Draw* method = so->draw;
char bufferKey[KEYSIZE];
Attribute* indices = method->indices;
GLuint bufferHandle;
size_t bufferUsers;
if ( indices && 1 == indices->useBuffer ) {
snprintf (bufferKey, KEYSIZE, "%p", indices);
bufferUsers = (size_t)hashmap_find ( bufferKey, sceneData->countBufferUsers );
bufferUsers--;
if ( 0 == bufferUsers ) {
bufferHandle = (GLuint)hashmap_find ( bufferKey, sceneData->mapBuffer2Handle );
glDeleteBuffers ( 1, &bufferHandle );
hashmap_delete ( bufferKey, sceneData->mapBuffer2Handle );
hashmap_delete ( bufferKey, sceneData->countBufferUsers );
list_remove_elem ( (void*)bufferHandle, sceneData->listBuffers );
} else {
hashmap_insert ( bufferKey, (void*)bufferUsers, sceneData->countBufferUsers );
}
}
return 0;
}
static int tear_down_textures (SceneData* sceneData, SceneObject* so, SoData* soData) {
Uniform* uniform;
char uniKey[KEYSIZE];
GLuint textureHandle;
size_t textureUsers;
int i;
for ( i = 0; i < list_size ( soData->textures ); i++) {
uniform = list_get( i, soData->textures);
snprintf ( uniKey, KEYSIZE, "%p", uniform );
textureHandle = (GLuint)hashmap_find ( uniKey, sceneData->mapTexture2Handle );
textureUsers = (size_t)hashmap_find ( uniKey, sceneData->countTextureUsers );
textureUsers--;
if ( 0 == textureUsers ) {
glDeleteTextures( 1, &textureHandle );
hashmap_delete ( uniKey, sceneData->mapTexture2Handle );
hashmap_delete ( uniKey, sceneData->countTextureUsers );
list_remove_elem ( (void*)textureHandle, sceneData->listTextures );
} else {
hashmap_insert ( uniKey, (void*)textureUsers, sceneData->countTextureUsers );
}
}
return 0;
}
extern int realmlist_reload(char const * filename)
{
t_elem * new_curr;
t_elem * old_curr;
t_realm * new_realm;
t_realm * old_realm;
int match;
t_list * newlist = NULL;
t_list * oldlist = realmlist_head;
realmlist_head = NULL;
if (!(newlist = realmlist_load(filename)))
return -1;
LIST_TRAVERSE(oldlist,old_curr)
{
if (!(old_realm = elem_get_data(old_curr)))
{
eventlog(eventlog_level_error,__FUNCTION__,"found NULL elem in list");
continue;
}
match = 0;
LIST_TRAVERSE(newlist,new_curr)
{
if (!(new_realm = elem_get_data(new_curr)))
{
eventlog(eventlog_level_error,__FUNCTION__,"found NULL elem in list");
continue;
}
if (!strcmp(old_realm->name,new_realm->name))
{
match = 1;
rcm_chref(&old_realm->rcm,new_realm);
break;
}
}
if (!match)
rcm_chref(&old_realm->rcm,NULL);
realm_destroy(old_realm);
list_remove_elem(oldlist,&old_curr);
}
list_destroy(oldlist);
realmlist_head = newlist;
realm_number = 0;
return 0;
}
static int tear_down_shaders (SceneData* sceneData, SceneObject* so, SoData* soData) {
char shaderKey[KEYSIZE];
snprintf ( shaderKey, KEYSIZE, "%p", &so->vShader );
GLuint handle = (GLuint)hashmap_find ( shaderKey, sceneData->mapVShader2Handle );
size_t shaderUsers = (size_t)hashmap_find ( shaderKey, sceneData->countVShaderUsers );
shaderUsers--;
if ( 0 == shaderUsers ) {
glDeleteShader ( handle );
list_remove_elem ( (void*)handle, sceneData->listVShaders );
hashmap_delete ( shaderKey, sceneData->mapVShader2Handle );
hashmap_delete ( shaderKey, sceneData->countVShaderUsers );
} else {
hashmap_insert ( shaderKey, (void*)shaderUsers, sceneData->countVShaderUsers );
}
snprintf ( shaderKey, KEYSIZE, "%p", &so->fShader );
handle = (GLuint)hashmap_find ( shaderKey, sceneData->mapFShader2Handle );
shaderUsers = (GLuint)hashmap_find ( shaderKey, sceneData->countFShaderUsers );
shaderUsers--;
if ( 0 == shaderUsers ) {
glDeleteShader ( handle );
list_remove_elem ( (void*)handle, sceneData->listFShaders );
hashmap_delete ( shaderKey, sceneData->mapFShader2Handle );
hashmap_delete ( shaderKey, sceneData->countFShaderUsers );
} else {
hashmap_insert ( shaderKey, (void*)shaderUsers, sceneData->countFShaderUsers );
}
return 0;
}
int renderman_remove_so(Scene* scene, SceneObject* so) {
SceneData* sceneData = find_scene_data ( scene );
if ( 1 == scene->running ) {
if ( !sceneData ) return -1;
SoData* soData = find_so_data ( sceneData, so );
if ( !soData ) return -1;
list_remove_elem( so, sceneData->stageGbuffer );
list_remove_elem( so, sceneData->stageLight );
list_remove_elem( so, sceneData->stageGeometry );
list_remove_elem( so, sceneData->stageParticle );
list_remove_elem( so, sceneData->stageOverlay );
tear_down_so ( sceneData, so );
} else {
list_remove_elem ( so, scene->initialObjects );
}
return 0;
}
extern int list_remove_data(t_list * list, void const * data, t_elem ** elem)
{
if (!list)
{
eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
return -1;
}
if (!(*elem = list_get_elem_by_data(list,data)))
return -1;
return list_remove_elem(list,elem);
}
int d2ladderlist_destroy(void)
{
t_d2ladder * d2ladder;
t_elem * elem;
if (!d2ladder_list) return -1;
LIST_TRAVERSE(d2ladder_list,elem)
{
if (!(d2ladder=(t_d2ladder*)elem_get_data(elem))) continue;
xfree(d2ladder);
list_remove_elem(d2ladder_list,&elem);
}
list_destroy(d2ladder_list);
return 0;
}
INLINE LinkedList *
list_remove_elem(LinkedList* list, void* elem)
{
LinkedList *tmp;
if (list) {
if (list->head == elem) {
tmp = list->tail;
free(list);
return tmp;
}
list->tail = list_remove_elem(list->tail, elem);
return list;
}
return NULL;
}
extern int realmlist_unload(t_list * list_head)
{
t_elem * curr;
t_realm * realm;
if (list_head)
{
LIST_TRAVERSE(list_head,curr)
{
if (!(realm = elem_get_data(curr)))
eventlog(eventlog_level_error,__FUNCTION__,"found NULL realm in list");
else
realm_destroy(realm);
list_remove_elem(list_head,&curr);
}
list_destroy(list_head);
}
return 0;
}
extern int realmlist_destroy(void)
{
t_elem * curr;
t_realm * realm;
if (realmlist_head)
{
LIST_TRAVERSE(realmlist_head,curr)
{
if (!(realm = elem_get_data(curr)))
eventlog(eventlog_level_error,"realmlist_destroy","found NULL realm in list");
else
realm_destroy(realm);
list_remove_elem(realmlist_head,curr);
}
list_destroy(realmlist_head);
realmlist_head = NULL;
}
return 0;
}
extern int friendlist_close(t_list * flist)
{
t_elem * curr;
t_friend * fr;
if(flist==NULL)
return -1;
LIST_TRAVERSE(flist,curr)
{
if (!(fr = elem_get_data(curr)))
{
eventlog(eventlog_level_error,__FUNCTION__,"found NULL entry in list");
continue;
}
if (list_remove_elem(flist, &curr) < 0)
eventlog(eventlog_level_error, __FUNCTION__, "could not remove elem from flist");
xfree((void *) fr);
}
list_destroy(flist);
return 0;
}
extern int friendlist_purge(t_list * flist)
{
t_elem * curr;
t_friend * fr;
if(flist==NULL)
return -1;
LIST_TRAVERSE(flist,curr)
{
if (!(fr = elem_get_data(curr)))
{
eventlog(eventlog_level_error,__FUNCTION__,"found NULL entry in list");
continue;
}
if (fr->mutual<0)
{
if(list_remove_elem(flist, &curr)<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not remove item from list");
}
}
return 0;
}
extern int autoupdate_unload(void)
{
if (autoupdate_head) {
t_elem * curr;
t_autoupdate * entry;
LIST_TRAVERSE(autoupdate_head,curr)
{
if (!(entry = (t_autoupdate*)elem_get_data(curr)))
eventlog(eventlog_level_error,__FUNCTION__,"found NULL entry in list");
else {
xfree((void *)entry->versiontag); /* avoid warning */
xfree((void *)entry->mpqfile); /* avoid warning */
xfree(entry);
}
list_remove_elem(autoupdate_head,&curr);
}
if (list_destroy(autoupdate_head)<0) return -1;
autoupdate_head = NULL;
}
return 0;
}
extern int addrlist_destroy(t_addrlist * addrlist)
{
t_elem * curr;
t_addr * addr;
if (!addrlist)
{
eventlog(eventlog_level_error,"addrlist_destroy","got NULL addrlist");
return -1;
}
LIST_TRAVERSE(addrlist,curr)
{
if (!(addr = elem_get_data(curr)))
eventlog(eventlog_level_error,"addrlist_destroy","found NULL addr in list");
else
addr_destroy(addr);
list_remove_elem(addrlist,curr);
}
return list_destroy(addrlist);
}
extern int versioncheck_unload(void)
{
t_elem * curr;
t_versioninfo * vi;
if (versioninfo_head)
{
LIST_TRAVERSE(versioninfo_head, curr)
{
if (!(vi = (t_versioninfo*)elem_get_data(curr))) /* should not happen */
{
eventlog(eventlog_level_error, __FUNCTION__, "version list contains NULL item");
continue;
}
if (list_remove_elem(versioninfo_head, &curr) < 0)
eventlog(eventlog_level_error, __FUNCTION__, "could not remove item from list");
if (vi->parsed_exeinfo)
{
if (vi->parsed_exeinfo->exe)
xfree((void *)vi->parsed_exeinfo->exe);
xfree((void *)vi->parsed_exeinfo); /* avoid warning */
}
xfree((void *)vi->mpqfile); /* avoid warning */
xfree((void *)vi->eqn); /* avoid warning */
if (vi->versiontag)
xfree((void *)vi->versiontag); /* avoid warning */
xfree(vi);
}
if (list_destroy(versioninfo_head) < 0)
return -1;
versioninfo_head = NULL;
}
return 0;
}
extern int ipbanlist_destroy(void)
{
t_elem * curr;
t_ipban_entry * entry;
if (ipbanlist_head)
{
LIST_TRAVERSE(ipbanlist_head,curr)
{
entry = (t_ipban_entry*)elem_get_data(curr);
if (!entry) /* should not happen */
{
eventlog(eventlog_level_error,__FUNCTION__,"ipbanlist contains NULL item");
continue;
}
if (list_remove_elem(ipbanlist_head,&curr)<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not remove item from list");
ipban_unload_entry(entry);
}
if (list_destroy(ipbanlist_head)<0)
return -1;
ipbanlist_head = NULL;
}
void draw_player_cells(t_world *world, t_view *view, t_player *player)
{
t_elem *cellrunner;
t_cell *cell;
cellrunner = player->cells->begin;
while (cellrunner)
{
cell = cellrunner->cell;
clear_cell(cell, view->surface);
if (cell->area < 9)
{
list_remove_elem(player->cells, cellrunner);/*
dprintf(2, "\033[2J\033[HAlive cells: %d\n", player->cells->size);*/
}
else
{
update_cell(world, view, cell);
draw_cell(cell, view->surface);
}
cellrunner = cellrunner->next;
}
}
/* FIXME: we should save client ipaddr into c->ipaddr after accept */
static int dbs_verify_ipaddr(char const * addrlist, t_d2dbs_connection * c)
{
char * adlist;
char * s, *temp;
t_elem * elem;
t_d2dbs_connection * tempc;
unsigned int valid;
unsigned int resolveipaddr;
adlist = xstrdup(addrlist);
temp = adlist;
valid = 0;
while ((s = strsep(&temp, ","))) {
host_lookup(s, &resolveipaddr);
if (resolveipaddr == 0) continue;
if (c->ipaddr == resolveipaddr) {
valid = 1;
break;
}
}
xfree(adlist);
if (valid) {
eventlog(eventlog_level_info, __FUNCTION__, "ip address %s is valid", addr_num_to_ip_str(c->ipaddr));
LIST_TRAVERSE(dbs_server_connection_list, elem)
{
if (!(tempc = (t_d2dbs_connection*)elem_get_data(elem))) continue;
if (tempc != c && tempc->ipaddr == c->ipaddr) {
eventlog(eventlog_level_info, __FUNCTION__, "destroying previous connection %d", tempc->serverid);
dbs_server_shutdown_connection(tempc);
list_remove_elem(dbs_server_connection_list, &elem);
}
}
c->verified = 1;
return 0;
}
else {
extern int trans_unload(void)
{
t_elem *curr;
t_trans *entry;
if (trans_head) {
LIST_TRAVERSE(trans_head, curr)
{
if (!(entry = (t_trans*)elem_get_data(curr))) {
eventlog(eventlog_level_error, __FUNCTION__, "found NULL entry in list");
}
else {
netaddr_destroy(entry->network);
addr_destroy(entry->output);
addr_destroy(entry->input);
xfree(entry);
}
list_remove_elem(trans_head, &curr);
}
list_destroy(trans_head);
trans_head = NULL;
}
return 0;
}
static int tear_down_attributes (SceneData* sceneData, SceneObject* so, SoData* soData) {
Attribute* attribute;
char bufferKey[KEYSIZE];
size_t bufferUsers;
GLuint bufferHandle;
int i;
for (i = 0; i < list_size(soData->attributes); i++) {
attribute = list_get ( i, soData->attributes );
if ( 1 != attribute->useBuffer ) continue;
snprintf (bufferKey, KEYSIZE, "%p", attribute);
bufferHandle = (GLuint)hashmap_find ( bufferKey, sceneData->mapBuffer2Handle );
bufferUsers = (size_t)hashmap_find ( bufferKey, sceneData->countBufferUsers );
bufferUsers--;
if ( 0 == bufferUsers) { // free resources
glDeleteBuffers (1, &bufferHandle);
list_remove_elem ( (void*)bufferHandle, sceneData->listBuffers );
hashmap_delete ( bufferKey, sceneData->mapBuffer2Handle );
hashmap_delete ( bufferKey, sceneData->countBufferUsers );
} else {
hashmap_insert ( bufferKey, (void*)bufferUsers, sceneData->countBufferUsers );
}
}
return 0;
}
static int server_process(int sockfd)
{
t_list * serverlist_head;
t_elem * curr;
t_server * server;
struct sockaddr_in cliaddr;
t_psock_fd_set rfds;
struct timeval tv;
time_t last;
FILE * outfile;
psock_t_socklen len;
t_trackpacket packet;
if (!(serverlist_head = list_create()))
{
eventlog(eventlog_level_error,__FUNCTION__,"could not create server list");
return -1;
}
/* the main loop */
last = time(NULL) - prefs.update;
for (;;)
{
/* time to dump our list to disk and call the process command */
/* (I'm making the assumption that this won't take very long.) */
if (last+(signed)prefs.update<time(NULL))
{
last = time(NULL);
if (!(outfile = fopen(prefs.outfile,"w")))
{
eventlog(eventlog_level_error,__FUNCTION__,"unable to open file \"%s\" for writing (fopen: %s)",prefs.outfile,pstrerror(errno));
continue;
}
LIST_TRAVERSE(serverlist_head,curr)
{
server = elem_get_data(curr);
if (server->updated+(signed)prefs.expire<last)
{
list_remove_elem(serverlist_head,&curr);
xfree(server);
}
else
{
if (prefs.XML_mode == 1)
{
fprintf(outfile,"<server>\n\t<address>%s</address>\n",inet_ntoa(server->address));
fprintf(outfile,"\t<port>%hu</port>\n",bn_short_nget(server->info.port));
fprintf(outfile,"\t<location>%s</location>\n",server->info.server_location);
fprintf(outfile,"\t<software>%s</software>\n",server->info.software);
fprintf(outfile,"\t<version>%s</version>\n",server->info.version);
fprintf(outfile,"\t<users>%lu</users>\n",bn_int_nget(server->info.users));
fprintf(outfile,"\t<channels>%lu</channels>\n",bn_int_nget(server->info.channels));
fprintf(outfile,"\t<games>%lu</games>\n",bn_int_nget(server->info.games));
fprintf(outfile,"\t<description>%s</description>\n",server->info.server_desc);
fprintf(outfile,"\t<platform>%s</platform>\n",server->info.platform);
fprintf(outfile,"\t<url>%s</url>\n",server->info.server_url);
fprintf(outfile,"\t<contact_name>%s</contact_name>\n",server->info.contact_name);
fprintf(outfile,"\t<contact_email>%s</contact_email>\n",server->info.contact_email);
fprintf(outfile,"\t<uptime>%lu</uptime>\n",bn_int_nget(server->info.uptime));
fprintf(outfile,"\t<total_games>%lu</total_games>\n",bn_int_nget(server->info.total_games));
fprintf(outfile,"\t<logins>%lu</logins>\n",bn_int_nget(server->info.total_logins));
fprintf(outfile,"</server>\n");
}
else
{
fprintf(outfile,"%s\n##\n",inet_ntoa(server->address));
fprintf(outfile,"%hu\n##\n",bn_short_nget(server->info.port));
fprintf(outfile,"%s\n##\n",server->info.server_location);
fprintf(outfile,"%s\n##\n",server->info.software);
fprintf(outfile,"%s\n##\n",server->info.version);
fprintf(outfile,"%lu\n##\n",bn_int_nget(server->info.users));
fprintf(outfile,"%lu\n##\n",bn_int_nget(server->info.channels));
fprintf(outfile,"%lu\n##\n",bn_int_nget(server->info.games));
fprintf(outfile,"%s\n##\n",server->info.server_desc);
fprintf(outfile,"%s\n##\n",server->info.platform);
fprintf(outfile,"%s\n##\n",server->info.server_url);
fprintf(outfile,"%s\n##\n",server->info.contact_name);
fprintf(outfile,"%s\n##\n",server->info.contact_email);
fprintf(outfile,"%lu\n##\n",bn_int_nget(server->info.uptime));
fprintf(outfile,"%lu\n##\n",bn_int_nget(server->info.total_games));
fprintf(outfile,"%lu\n##\n",bn_int_nget(server->info.total_logins));
fprintf(outfile,"###\n");
}
}
}
if (fclose(outfile)<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not close output file \"%s\" after writing (fclose: %s)",prefs.outfile,pstrerror(errno));
if (prefs.process[0]!='\0')
system(prefs.process);
}
void dbs_server_loop(int lsocket)
{
struct sockaddr_in sinRemote;
int sd ;
fd_set ReadFDs, WriteFDs, ExceptFDs;
t_elem * elem;
t_d2dbs_connection* it;
BOOL bOK ;
const char* pcErrorType ;
struct timeval tv;
int highest_fd;
psock_t_socklen nAddrSize = sizeof(sinRemote);
while (1) {
#ifdef WIN32
if (g_ServiceStatus<0 && kbhit() && getch()=='q')
d2dbs_signal_quit_wrapper();
if (g_ServiceStatus == 0) d2dbs_signal_quit_wrapper();
while (g_ServiceStatus == 2) Sleep(1000);
#endif
if (d2dbs_handle_signal()<0) break;
dbs_handle_timed_events();
highest_fd=dbs_server_setup_fdsets(&ReadFDs, &WriteFDs, &ExceptFDs, lsocket);
tv.tv_sec = 0;
tv.tv_usec = SELECT_TIME_OUT;
switch (psock_select(highest_fd+1, &ReadFDs, &WriteFDs, &ExceptFDs, &tv) ) {
case -1:
eventlog(eventlog_level_error,__FUNCTION__,"psock_select() failed : %s",strerror(psock_errno()));
continue;
case 0:
continue;
default:
break;
}
if (PSOCK_FD_ISSET(lsocket, &ReadFDs)) {
sd = psock_accept(lsocket, (struct sockaddr*)&sinRemote, &nAddrSize);
if (sd == -1) {
eventlog(eventlog_level_error,__FUNCTION__,"psock_accept() failed : %s",strerror(psock_errno()));
return;
}
eventlog(eventlog_level_info,__FUNCTION__,"accepted connection from %s:%d , socket %d .",
inet_ntoa(sinRemote.sin_addr) , ntohs(sinRemote.sin_port), sd);
eventlog_step(prefs_get_logfile_gs(),eventlog_level_info,__FUNCTION__,"accepted connection from %s:%d , socket %d .",
inet_ntoa(sinRemote.sin_addr) , ntohs(sinRemote.sin_port), sd);
setsockopt_keepalive(sd);
dbs_server_list_add_socket(sd, ntohl(sinRemote.sin_addr.s_addr));
if (psock_ctl(sd,PSOCK_NONBLOCK)<0) {
eventlog(eventlog_level_error,__FUNCTION__,"could not set TCP socket [%d] to non-blocking mode (closing connection) (psock_ctl: %s)", sd,strerror(psock_errno()));
psock_close(sd);
}
} else if (PSOCK_FD_ISSET(lsocket, &ExceptFDs)) {
eventlog(eventlog_level_error,__FUNCTION__,"exception on listening socket");
/* FIXME: exceptions are not errors with TCP, they are out-of-band data */
return;
}
LIST_TRAVERSE(dbs_server_connection_list,elem)
{
bOK = TRUE;
pcErrorType = 0;
if (!(it=elem_get_data(elem))) continue;
if (PSOCK_FD_ISSET(it->sd, &ExceptFDs)) {
bOK = FALSE;
pcErrorType = "General socket error"; /* FIXME: no no no no no */
PSOCK_FD_CLR(it->sd, &ExceptFDs);
} else {
if (PSOCK_FD_ISSET(it->sd, &ReadFDs)) {
bOK = dbs_server_read_data(it);
pcErrorType = "Read error";
PSOCK_FD_CLR(it->sd, &ReadFDs);
}
if (PSOCK_FD_ISSET(it->sd, &WriteFDs)) {
bOK = dbs_server_write_data(it);
pcErrorType = "Write error";
PSOCK_FD_CLR(it->sd, &WriteFDs);
}
}
if (!bOK) {
int err;
psock_t_socklen errlen;
err = 0;
errlen = sizeof(err);
if (psock_getsockopt(it->sd, PSOCK_SOL_SOCKET, PSOCK_SO_ERROR, &err, &errlen)==0) {
if (errlen && err!=0) {
eventlog(eventlog_level_error,__FUNCTION__,"data socket error : %s",strerror(err));
}
}
dbs_server_shutdown_connection(it);
list_remove_elem(dbs_server_connection_list,&elem);
} else {
if (dbs_packet_handle(it)==-1) {
eventlog(eventlog_level_error,__FUNCTION__,"dbs_packet_handle() failed");
dbs_server_shutdown_connection(it);
list_remove_elem(dbs_server_connection_list,&elem);
}
}
}
}
int renderman_rendertask_repeat(RepeatInfo* info, RenderContext* ctx) {
SceneData* sceneData = find_scene_data (ctx->scene);
if ( !sceneData ) {
log_message("error: scene data is missing");
return -1;
}
SceneObject* so;
SoData* soData;
char progKey[KEYSIZE];
Attribute* attribute;
size_t numAttributes;
GLuint program;
char bufferKey[KEYSIZE];
GLuint bufferHandle;
char iboKey[KEYSIZE];
GLuint iboHandle;
Draw* method;
int i;
int k;
//////////////////////////////////////////////////
//////////////////////// STAGE Gbuffer
//////////////////////////////////////////////////
glBindFramebuffer(GL_FRAMEBUFFER, sceneData->fbos[0]);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glDisable(GL_BLEND);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
for (i = list_size(sceneData->stageGbuffer) - 1; i >= 0; i--) {
so = list_get(i, sceneData->stageGbuffer);
soData = find_so_data ( sceneData, so );
if ( !soData ) {
log_message ( "error: scene object has not been setup correctly - removing." );
tear_down_so ( sceneData, so );
list_remove_elem( so, sceneData->stageGbuffer );
continue;
}
program = (GLuint)hashmap_find( "gbuffer", staticPrograms );
glUseProgram ( program );
if ( -1 == find_and_pass_uniforms (sceneData, so, (GLuint)program)) {
tear_down_so ( sceneData, so );
list_remove_elem( so, sceneData->stageGbuffer );
continue;
}
for (k = 0; k < 2; k++) { // position and normal must be first 2 shader attributes
attribute = list_get ( k, soData->attributes );
if ( 1 == attribute->useBuffer ) {
snprintf ( bufferKey, KEYSIZE, "%p", attribute );
bufferHandle = (GLuint)hashmap_find ( bufferKey, sceneData->mapBuffer2Handle );
glBindBuffer (GL_ARRAY_BUFFER, bufferHandle);
glVertexAttribPointer (k, attribute->numComponents, attribute->dataType, GL_FALSE, 0, 0);
glEnableVertexAttribArray(k);
} else {
glVertexAttribPointer (k, attribute->numComponents, attribute->dataType, GL_FALSE, 0, attribute->data);
glEnableVertexAttribArray(k);
}
}
method = so->draw;
if ( NULL == method->indices ) {
glDrawArrays ( method->type, method->start, method->count );
} else {
snprintf( iboKey, KEYSIZE, "%p", method->indices );
iboHandle = (GLuint)hashmap_find ( iboKey, sceneData->mapBuffer2Handle );
if ( 1 == method->indices->useBuffer ) {
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, iboHandle );
}
glDrawElements ( method->type, method->count, method->indices->dataType, 1 == method->indices->useBuffer ? 0 : method->indices->data );
}
for (k = 0; k < 2; k++) {
glDisableVertexAttribArray(k);
}
glBindBuffer (GL_ARRAY_BUFFER, 0);
glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);
glBindTexture (GL_TEXTURE_2D, 0);
}
//////////////////////////////////////////////////
//////////////////////// STAGE Light
//////////////////////////////////////////////////
glBindFramebuffer(GL_FRAMEBUFFER, sceneData->fbos[1]);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glClear(GL_COLOR_BUFFER_BIT);
render_stage(sceneData->stageLight, sceneData, so, soData, progKey, attribute, numAttributes, program, bufferKey, bufferHandle, iboKey, iboHandle, method, i, k);
//////////////////////////////////////////////////
//////////////////////// STAGE Geometry
//////////////////////////////////////////////////
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glDisable(GL_BLEND);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
render_stage(sceneData->stageGeometry, sceneData, so, soData, progKey, attribute, numAttributes, program, bufferKey, bufferHandle, iboKey, iboHandle, method, i, k);
//////////////////////////////////////////////////
//////////////////////// STAGE Particle
//////////////////////////////////////////////////
//////////////////////////////////////////////////
//////////////////////// STAGE Overlay
//////////////////////////////////////////////////
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
render_stage(sceneData->stageOverlay, sceneData, so, soData, progKey, attribute, numAttributes, program, bufferKey, bufferHandle, iboKey, iboHandle, method, i, k);
//////////////////////////////////////////////////
//////////////////////// STAGE Postprocessing
//////////////////////////////////////////////////
//////////////////////////////////////////////////
//////////////////////// STAGE Update
//////////////////////////////////////////////////
eglSwapBuffers(ctx->esContext->display, ctx->esContext->surface);
if ( ctx->updateFunc ) {
ctx->updateFunc(ctx->userData, info->overruns);
}
return 0;
}
static inline void render_stage(List stage, SceneData* sceneData, SceneObject* so, SoData* soData, char* progKey, Attribute* attribute, size_t numAttributes, GLuint program, char* bufferKey, GLuint bufferHandle, char* iboKey, GLuint iboHandle, Draw* method, int i, int k) {
for (i = list_size(stage) - 1; i >= 0; i--) {
so = list_get(i, stage);
soData = find_so_data ( sceneData, so );
if ( !soData ) {
log_message ( "error: scene object has not been setup correctly - removing." );
tear_down_so ( sceneData, so );
list_remove_elem( so, stage );
continue;
}
snprintf(progKey, KEYSIZE, "%p,%p", &so->vShader, &so->fShader);
program = (GLuint)hashmap_find( progKey, sceneData->mapShaderShader2Handle );
glUseProgram ( program );
if ( -1 == find_and_pass_uniforms (sceneData, so, (GLuint)program)) {
log_message("error: scene object uniforms have not been setup correctly - removing so.");
tear_down_so ( sceneData, so );
list_remove_elem( so, stage );
continue;
}
numAttributes = list_size (soData->attributes);
for (k = 0; k < numAttributes; k++) {
attribute = list_get ( k, soData->attributes );
if ( 1 == attribute->useBuffer ) {
snprintf ( bufferKey, KEYSIZE, "%p", attribute );
bufferHandle = (GLuint)hashmap_find ( bufferKey, sceneData->mapBuffer2Handle );
glBindBuffer (GL_ARRAY_BUFFER, bufferHandle);
glVertexAttribPointer (k, attribute->numComponents, attribute->dataType, GL_FALSE, 0, 0);
glEnableVertexAttribArray(k);
} else {
glVertexAttribPointer (k, attribute->numComponents, attribute->dataType, GL_FALSE, 0, attribute->data);
glEnableVertexAttribArray(k);
}
}
method = so->draw;
if ( NULL == method->indices ) {
glDrawArrays ( method->type, method->start, method->count );
} else {
snprintf( iboKey, KEYSIZE, "%p", method->indices );
iboHandle = (GLuint)hashmap_find ( iboKey, sceneData->mapBuffer2Handle );
if ( 1 == method->indices->useBuffer ) {
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, iboHandle );
}
glDrawElements ( method->type, method->count, method->indices->dataType, 1 == method->indices->useBuffer ? 0 : method->indices->data );
}
for (k = 0; k < numAttributes; k++) {
glDisableVertexAttribArray(k);
}
glBindBuffer (GL_ARRAY_BUFFER, 0);
glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);
glBindTexture (GL_TEXTURE_2D, 0);
}
}
