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); } }