int procauth_isauthoritative(int service_code, pid_t pid) { procpid *pp; list_iterator_start(&proclist); while (list_iterator_hasnext(&proclist)) { pp = (procpid *)list_iterator_next(&proclist); if (pp->service_code == service_code) { /* wanted service found, compare pids... */ list_iterator_stop(&proclist); if (pp->current_pid == pid) /* authoritative */ return 1; else { pp->current_pid = procauth_getprocpid(pp->filename); if (pp->current_pid == -1) { /* error accessing pidfile */ return 0; } else { if (pp->current_pid != pid) { /* check if this is a child of the parent pid */ return procauth_ischildof(pid, pp->current_pid); } /* pid correctly updated and matching */ return 1; } } } } list_iterator_stop(&proclist); /* service_code was unknown */ return 0; }
void free_policy(bool runtime, policy_t* policy) { if (runtime) return; if (policy->name != NULL) bdestroy(policy->name); if (policy->instructions != NULL) { list_iterator_start(policy->instructions); while (list_iterator_hasnext(policy->instructions)) free_policy_instruction(runtime, list_iterator_next(policy->instructions)); list_iterator_stop(policy->instructions); list_destroy(policy->instructions); free(policy->instructions); } if (policy->settings != NULL) { list_iterator_start(policy->settings); while (list_iterator_hasnext(policy->settings)) free_policy_setting(runtime, list_iterator_next(policy->settings)); list_iterator_stop(policy->settings); list_destroy(policy->settings); free(policy->settings); } free(policy); }
/** * This function will search the list of cached pattern IDs for a pattern ID according to the given filename. * If it finds one, the found ID will be returned. * If not, -1 will be returned. */ int getPatternIDFromList(const char *filename) { int id = -1; #ifdef DEBUG_LOGGING __android_log_write(ANDROID_LOG_INFO,"AR native","trying to retrieve pattern from list"); #endif if (patternIDs == NULL) { #ifdef DEBUG_LOGGING __android_log_write(ANDROID_LOG_INFO,"AR native","list of patterns is null!!"); #endif return -1; } list_iterator_start(patternIDs); while (list_iterator_hasnext(patternIDs)) { patternID * currPatt = (patternID *) list_iterator_next(patternIDs); #ifdef DEBUG_LOGGING __android_log_print(ANDROID_LOG_INFO,"AR native","current pattern fiel: %s",currPatt->filename); #endif if (strcmp(filename, currPatt->filename) == 0) { #ifdef DEBUG_LOGGING __android_log_write(ANDROID_LOG_INFO,"AR native","found pattern in list"); #endif id = currPatt->id; break; } } list_iterator_stop(patternIDs); #ifdef DEBUG_LOGGING if(id==-1) __android_log_print(ANDROID_LOG_INFO,"AR native","found no pattern in the list for file %s",filename); #endif return id; }
static void load_reader_driver_options(sc_context_t *ctx) { struct sc_reader_driver *driver = ctx->reader_driver; scconf_block *conf_block = NULL; sc_reader_t *reader; int max_send_size; int max_recv_size; conf_block = sc_get_conf_block(ctx, "reader_driver", driver->short_name, 1); if (conf_block != NULL) { max_send_size = scconf_get_int(conf_block, "max_send_size", -1); max_recv_size = scconf_get_int(conf_block, "max_recv_size", -1); if (max_send_size >= 0 || max_recv_size >= 0) { if (list_iterator_start(&ctx->readers)) { reader = list_iterator_next(&ctx->readers); while (reader) { if (max_send_size >= 0) reader->max_send_size = max_send_size; if (max_recv_size >= 0) reader->max_recv_size = max_recv_size; reader = list_iterator_next(&ctx->readers); } list_iterator_stop(&ctx->readers); } } } }
struct lprov_entry* list_revert(list_t* list) { struct lprov_entry* first = NULL; struct lprov_entry* previous = NULL; struct lprov_entry* current = NULL; struct lconv_entry* entry = NULL; if (list == NULL) return NULL; list_iterator_start(list); while (list_iterator_hasnext(list)) { entry = list_iterator_next(list); current = malloc(sizeof(struct lprov_entry)); current->address = entry->address; current->label = bstr2cstr(entry->label, '0'); current->next = NULL; if (previous != NULL) previous->next = current; if (first == NULL) first = current; previous = current; } list_iterator_stop(list); return first; }
int dbg_lua_handle_lines(lua_State* L) { struct dbg_state* state = dbg_lua_extract_state(L, 1); void* ud = dbg_lua_extract_state_ud(L, 1); list_t* symbols = state->dbg_lua_get_symbols(); struct dbg_sym* current = NULL; struct dbg_sym_payload_line* payload = NULL; int tbl; lua_newtable(L); if (symbols == NULL) return 1; tbl = lua_gettop(L); list_iterator_start(symbols); while (list_iterator_hasnext(symbols)) { current = (struct dbg_sym*)list_iterator_next(symbols); if (current->type != DBGFMT_SYMBOL_LINE) continue; payload = (struct dbg_sym_payload_line*)current->payload; if (payload->path == NULL) continue; lua_newtable(L); lua_pushstring(L, payload->path->data); lua_setfield(L, -2, "file"); lua_pushnumber(L, payload->lineno); lua_setfield(L, -2, "line"); lua_pushnumber(L, payload->address); lua_setfield(L, -2, "address"); lua_rawseti(L, tbl, lua_objlen(L, tbl) + 1); } list_iterator_stop(symbols); return 1; }
void free_policy_value(bool runtime, policy_value_t* value) { if ((runtime && !value->runtime) || (!runtime && value->runtime)) return; switch (value->type) { case NUMBER: case TABLE: case FIELD: break; case WORD: case VARIABLE: bdestroy(value->string); break; case FUNCTION: free_policy_function_call(runtime, value->function); break; case LIST: list_iterator_start(value->list); while (list_iterator_hasnext(value->list)) free_policy_value(runtime, list_iterator_next(value->list)); list_iterator_stop(value->list); list_destroy(value->list); free(value->list); break; default: break; } free(value); }
/// /// Pops a scope from the stack. /// void ppimpl_pop_scope(state_t* state) { scope_t* scope; match_t* match; match_t* old; bstring name; size_t a, i; if (list_size(&state->scopes) == 0) return; scope = list_extract_at(&state->scopes, list_size(&state->scopes) - 1); // Delete text if this scope was silenced. if (!scope->active) { list_delete_range(&state->cached_output, scope->start_index, list_size(&state->cached_output) - 1); } // Delete handlers that were defined this scope. list_iterator_start(&scope->new_handlers); while (list_iterator_hasnext(&scope->new_handlers)) { name = list_iterator_next(&scope->new_handlers); for (i = 0; i < list_size(&state->handlers); i++) { old = list_get_at(&state->handlers, i); if (biseq(name, old->text.ref)) { // We need remove the old handler. // FIXME: Free the old handler. list_delete_at(&state->handlers, i); i--; } } bdestroy(name); } list_iterator_stop(&scope->new_handlers); list_destroy(&scope->new_handlers); // Restore handlers. for (a = 0; a < list_size(&scope->old_handlers); a++) { match = list_get_at(&scope->old_handlers, a); // Restore the old handler. list_append(&state->handlers, match); list_extract_at(&scope->old_handlers, a); a--; } list_destroy(&scope->old_handlers); // Free memory. free(scope); }
void free_policy_state(bool runtime, policy_state_t* state) { if (runtime) return; list_iterator_start(&state->variables); while (list_iterator_hasnext(&state->variables)) free_policy_instruction(runtime, list_iterator_next(&state->variables)); list_iterator_stop(&state->variables); list_destroy(&state->variables); free(state); }
void wr_rtp_packet_destroy(wr_rtp_packet_t * rtp_packet) { list_iterator_start(&rtp_packet->data_frames); while(list_iterator_hasnext(&rtp_packet->data_frames)){ wr_data_frame_t * frame = (wr_data_frame_t * ) list_iterator_next(&rtp_packet->data_frames); free(frame->data); free(frame); } list_iterator_stop(&rtp_packet->data_frames); list_destroy(&rtp_packet->data_frames); }
int wr_rtp_packet_copy_with_data(wr_rtp_packet_t * new_packet, wr_rtp_packet_t * old_packet) { wr_rtp_packet_copy(new_packet, old_packet); list_init(&new_packet->data_frames); list_iterator_start(&old_packet->data_frames); while(list_iterator_hasnext(&old_packet->data_frames)){ wr_data_frame_t * frame = (wr_data_frame_t * ) list_iterator_next(&old_packet->data_frames); wr_rtp_packet_add_frame(new_packet, frame->data, frame->size, frame->length_in_ms); } list_iterator_stop(&old_packet->data_frames); return 0; }
list_t* list_clone(list_t* original) { list_t* list = malloc(sizeof(list_t)); list_init(list); list_attributes_copy(list, &lconv_entry_meter, 1); list_attributes_comparator(list, &lconv_entry_comparator); list_attributes_seeker(list, &lconv_entry_seeker); list_iterator_start(original); while (list_iterator_hasnext(original)) list_append(list, list_iterator_next(original)); list_iterator_stop(original); return list; }
void free_policies(bool runtime, policies_t* policies) { if (runtime) return; list_iterator_start(&policies->policies); while (list_iterator_hasnext(&policies->policies)) free_policy(runtime, list_iterator_next(&policies->policies)); list_iterator_stop(&policies->policies); list_destroy(&policies->policies); if (policies->settings != NULL) free_policy(runtime, policies->settings); free(policies); }
void handle_LIST(char **params, int socket){ printf("at the top of handle_list, plenty of time to fill the printf buffer and send a message\n"); char msgbuf[512]; char* nick; char *chanName = params[1]; channel* chan; struct ClientData * ourCli = (struct ClientData *)list_seek(&clientList, &socket); nick = ourCli->nick; //printf("Ahfksadkfhkwelkheiowhrihfksadnfnkahseihiofhiohdsfaskdnfkneifhihdisjfkalsdklfjksdjfij\n"); //printf("chan null is :%d\n", chanName == NULL); //printf("shfksadkfhkwelkheiowhrihfksadnfnkahseihiofhiohdsfaskdnfkneifhihdisjfkalsdklfjksdjfij\n"); if(chanName != NULL){ chan = (channel *) findChannel(chanName); //if channel doesn't exist if(chan == NULL){ return; } sprintf(msgbuf, ":%s 322 %s %s %d :%s\r\n", host, nick, chanName, chan->nusers, chan->topic); //add stuff sendMessage(msgbuf, socket); sprintf(msgbuf, ":%s 323 %s :End of LIST\r\n", host, nick); sendMessage(msgbuf, socket); } else { pthread_mutex_lock(&chanListLock); if(list_iterator_start(&channelList) == 0){ printf("could not iterate list\n"); return; } printf("starting channel iterator\n"); while(list_iterator_hasnext(&channelList)){ chan = (channel *) list_iterator_next(&channelList); printf("sending channel info\n"); sprintf(msgbuf, ":%s 322 %s %s %d :%s\r\n", host, nick, chan->name, chan->nusers, chan->topic); //add stuff sendMessage(msgbuf, socket); } list_iterator_stop(&channelList); pthread_mutex_unlock(&chanListLock); sprintf(msgbuf, ":%s 323 %s :End of LIST\r\n", host, nick); sendMessage(msgbuf, socket); } return; }
/* Function to return a list of users connected/in a channel */ void handle_LUSERS(char** params, int socket) { char msgbuf[512]; int numUsers = 0; int numUnregUsers = 0; pthread_mutex_lock(&listLock); struct ClientData *cur; struct ClientData *cli; char user[500]; //iterate through the list of users, get the number that are registered and unregistered if(list_iterator_start(&clientList) ==0) { printf("Error iterating the list.\n"); return; } while(list_iterator_hasnext(&clientList)) { cur = (struct ClientData *)list_iterator_next(&clientList); if(cur->registered){ numUsers++; } else { numUnregUsers++; } } if(list_iterator_stop(&clientList) == 0) { printf("Error iterating the list.\n"); return; } pthread_mutex_unlock(&listLock); //get the client we are sending this to cli = (struct ClientData *)list_seek(&clientList, &socket); strcpy(user, cli->user); //send the message sprintf(msgbuf, ":%s 251 %s :There are %d users and 0 services on 1 servers\r\n", host, user, numUsers); sendMessage(msgbuf, socket); sprintf(msgbuf,":%s 252 %s 0 :operator(s) online\r\n", host, user); sendMessage(msgbuf, socket); sprintf(msgbuf, ":%s 253 %s %d :unknown connection(s)\r\n",host, user, numUnregUsers); sendMessage(msgbuf, socket); sprintf(msgbuf,":%s 254 %s 0 :channels formed\r\n",host, user); sendMessage(msgbuf, socket); sprintf(msgbuf,":%s 255 %s :I have %d clients and 1 servers\r\n",host, user, numUsers+numUnregUsers); sendMessage(msgbuf, socket); return; }
void procauth_fin() { procpid *pp; /* free filenames */ list_iterator_start(&proclist); while (list_iterator_hasnext(&proclist)) { pp = (procpid *)list_iterator_next(&proclist); free(pp->filename); } list_iterator_stop(&proclist); /* destroy the list itself */ list_destroy(&proclist); }
void free_policy_function_call(bool runtime, policy_function_call_t* call) { if (runtime) return; if (call->parameters != NULL) { list_iterator_start(call->parameters); while (list_iterator_hasnext(call->parameters)) free_policy_value(runtime, list_iterator_next(call->parameters)); list_iterator_stop(call->parameters); list_destroy(call->parameters); free(call->parameters); } free(call); }
void* get_thread(int id, bzz_t *lock) { bzz_thread_t *found = 0; list_t *threads = lock->threads; list_iterator_start(threads); while(list_iterator_hasnext(threads)) { bzz_thread_t *current = list_iterator_next(threads); if(current->id == id) { found = current; } } list_iterator_stop(threads); return found; }
unsigned int num_old_gold_waiting(bzz_t *lock) { unsigned int num_old_gold_waiting = 0; list_t *waiting_gold_threads = lock->waiting_gold_threads; list_iterator_start(waiting_gold_threads); // Iterate through waiting gold threads checking for old threads while(list_iterator_hasnext(waiting_gold_threads)) { bzz_thread_t *current = list_iterator_next(waiting_gold_threads); if(is_old(current, lock)) { num_old_gold_waiting++; } } list_iterator_stop(waiting_gold_threads); return num_old_gold_waiting; }
int procauth_refreshpids() { procpid *pp; pid_t newpid; int changed = 0; /* update each process in list with the current pid */ list_iterator_start(&proclist); while (list_iterator_hasnext(&proclist)) { pp = (procpid *)list_iterator_next(&proclist); newpid = procauth_getprocpid(pp->filename); if (newpid != pp->current_pid) changed++; pp->current_pid = newpid; } list_iterator_stop(&proclist); sshguard_log(LOG_DEBUG,"refreshing the list of pids from pidfiles... %d pids changed", changed); return changed; }
//TODO release globalref JNIEXPORT void JNICALL Java_edu_dhbw_andar_ARToolkit_removeObject (JNIEnv *env, jobject artoolkit, jint objectID) { if(list_delete(&objects,&objectID) != 0) { //failed to delete -> throw error jclass exc = (*env)->FindClass( env, "edu/dhbw/andar/exceptions/AndARException" ); if ( exc != NULL ) (*env)->ThrowNew( env, exc, "could not delete object from native array" ); } #ifdef DEBUG_LOGGING __android_log_write(ANDROID_LOG_INFO,"AR native","array of objects still containing the following elements:"); list_iterator_start(&objects); /* starting an iteration "session" */ while (list_iterator_hasnext(&objects)) { /* tell whether more values available */ Object* curObject = (Object *)list_iterator_next(&objects); /* get the next value */ __android_log_print(ANDROID_LOG_INFO,"AR native","name: %s", curObject->name); __android_log_print(ANDROID_LOG_INFO,"AR native","id: %s", curObject->id); } list_iterator_stop(&objects); #endif }
/** * Sends an asynchronous event to any waiting client */ LONG EHSignalEventToClients(void) { LONG rv = SCARD_S_SUCCESS; int32_t filedes; (void)pthread_mutex_lock(&ClientsWaitingForEvent_lock); (void)list_iterator_start(&ClientsWaitingForEvent); while (list_iterator_hasnext(&ClientsWaitingForEvent)) { filedes = *(int32_t *)list_iterator_next(&ClientsWaitingForEvent); rv = MSGSignalClient(filedes, SCARD_S_SUCCESS); } (void)list_iterator_stop(&ClientsWaitingForEvent); (void)list_clear(&ClientsWaitingForEvent); (void)pthread_mutex_unlock(&ClientsWaitingForEvent_lock); return rv; } /* EHSignalEventToClients */
/// /// Saves the bin with the specified name to the specified path. /// /// @param name The name of the bin to save. /// @param path The path to save the bin to. /// void bins_save(freed_bstring name, freed_bstring path) { FILE* out; struct ldbin* bin = list_seek(&ldbins.bins, name.ref); assert(bin != NULL); // Open the output file. out = fopen(path.ref->data, "wb"); // Write each byte from the bin. list_iterator_start(&bin->words); while (list_iterator_hasnext(&bin->words)) fwrite(list_iterator_next(&bin->words), sizeof(uint16_t), 1, out); list_iterator_stop(&bin->words); // Close the output file. fclose(out); // Free strings. bautodestroy(name); bautodestroy(path); }
void list_prov_destroy(list_t* list) { struct lconv_entry* entry = NULL; if (list == NULL) return; list_iterator_start(list); while (list_iterator_hasnext(list)) { entry = list_iterator_next(list); bdestroy(entry->label); // No need to free entries as list_attributes_copy // has the copy_data option set to 1. We also don't // free the bin name, as we don't own that. } list_iterator_stop(list); list_clear(list); list_destroy(list); free(list); }
void free_policy_instruction(bool runtime, policy_instruction_t* instruction) { if (runtime) return; if (instruction->value != NULL) free_policy_value(runtime, instruction->value); if (instruction->for_variable != NULL) bdestroy(instruction->for_variable); if (instruction->for_start != NULL) free_policy_value(runtime, instruction->for_start); if (instruction->for_end != NULL) free_policy_value(runtime, instruction->for_end); if (instruction->for_instructions != NULL) { list_iterator_start(instruction->for_instructions); while (list_iterator_hasnext(instruction->for_instructions)) free_policy_instruction(runtime, list_iterator_next(instruction->for_instructions)); list_iterator_stop(instruction->for_instructions); list_destroy(instruction->for_instructions); free(instruction->for_instructions); } free(instruction); }
void dbgfmt_free(list_t* symbols) { struct dbg_sym* symbol; if (symbols == NULL) return; list_iterator_start(symbols); while (list_iterator_hasnext(symbols)) { symbol = list_iterator_next(symbols); // Free payload. dbgfmt_free_symbol(symbol); // No need to free the symbol, it will be // free'd by simclist when we clear / destroy // the list. } list_iterator_stop(symbols); list_clear(symbols); list_destroy(symbols); free(symbols); }
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Write all new alarms to the diskloop. */ void alarm_archive( alarm_context_t* alarm_list, buffer_t* url_str, st_info_t* st_info ) { time_t start_time = 0; time_t end_time = 0; uint8_t buf_byte = 0; uint16_t buf_word = 0; uint32_t buf_dword = 0L; //uint64_t buf_qword = 0LL; uint16_t version_type = 0x8000 | FALCON_VERSION; uint16_t alarm_count = 0; char* retmsg = NULL; buffer_t* alarm_data = NULL; alarm_line_t* alarm = NULL; alarm_data = buffer_init(); if (!alarm_data) { if (gDebug) fprintf(stderr, "falcon: unable to allocate space for alarm data\n"); else syslog(LOG_ERR, "falcon: unable to allocate space for alarm data\n"); return; } // Print each line in the filtered list list_iterator_stop(alarm_list); list_iterator_start(alarm_list); while (list_iterator_hasnext(alarm_list)) { alarm = (alarm_line_t*)list_iterator_next(alarm_list); if (alarm->sent) continue; if (!start_time) start_time = alarm->timestamp; if (!end_time) end_time = alarm->timestamp; if (gDebug) fprintf(stdout, "DEBUG %s, line %d, date %s: %s\n", __FILE__, __LINE__, __DATE__, alarm->text); if ((retmsg = q330LogMsg(alarm->text, st_info->station, st_info->network, "LOG", st_info->location)) != NULL) { // error trying to log the message if (gDebug) fprintf(stderr, "falcon: failed to write alarms to log: %s\n", retmsg); else syslog(LOG_ERR, "falcon: failed to write alarms to log: %s\n", retmsg); exit(1); } if (gDebug) { fprintf(stdout, "Alarm '%s':\n", alarm->description); fprintf(stdout, " Channel : %02x\n", (alarm->channel)); fprintf(stdout, " Timestamp : %li\n", (long)(alarm->timestamp)); fprintf(stdout, " Event Code : 0x%02x\n", (alarm->event)); fprintf(stdout, " Sent : %s\n", alarm->sent ? "Yes" : "No"); fprintf(stdout, " Hash : 0x%08lx\n", (unsigned long)(alarm->hash)); fprintf(stdout, " Text : %s\n", alarm->text); } if (start_time > alarm->timestamp) start_time = alarm->timestamp; if (end_time < alarm->timestamp) end_time = alarm->timestamp; if (!alarm->description[0]) { if (gDebug) fprintf(stderr, "falcon: description code not found\n"); else syslog(LOG_ERR, "falcon: description code not found\n"); continue; } // There must be at least enough space for one more alarm. // If there isn't, queue this buffer's contents, and reset it. // This should prevent us from ever fragmenting alarm data // across opaque blockettes. if (alarm_count && (alarm_data->length > 400)) { buffer_seek(alarm_data, 2); buf_dword = htonl(start_time); buffer_write(alarm_data, (uint8_t*)(&buf_dword), sizeof(buf_dword)); buf_dword = htonl(end_time); buffer_write(alarm_data, (uint8_t*)(&buf_dword), sizeof(buf_dword)); buf_word = htons(alarm_count); buffer_write(alarm_data, (uint8_t*)(&buf_word), sizeof(buf_word)); if (gDebug) { fprintf(stdout, "falcon: [MID] alarms were found\n"); fprintf(stdout, "[MID] raw buffer:\n"); format_data(alarm_data->content, alarm_data->length, 0, 0); } QueueOpaque(alarm_data->content, (int)alarm_data->length, st_info->station, st_info->network, st_info->alarm_chan, st_info->location, FALCON_IDSTRING); alarm_data = buffer_destroy(alarm_data); alarm_count = 0; start_time = alarm->timestamp; end_time = alarm->timestamp; alarm_data = buffer_init(); if (!alarm_data) { if (gDebug) fprintf(stderr, "falcon: unable to allocate space for alarm data\n"); else syslog(LOG_ERR, "falcon: unable to allocate space for alarm data\n"); return; } } // If we've built up a records worth of alarm data if (!alarm_count) { // Write alarm header info if (gDebug) { fprintf(stderr, "falcon: Writing alarm header info.\n"); } buf_word = htons(version_type); buffer_write(alarm_data, (uint8_t*)(&buf_word), sizeof(buf_word)); // Reserve space for elements that will be assigned just // prior to queueing data buf_dword = htonl(start_time); buffer_write(alarm_data, (uint8_t*)(&buf_dword), sizeof(buf_dword)); buf_dword = htonl(end_time); buffer_write(alarm_data, (uint8_t*)(&buf_dword), sizeof(buf_dword)); buf_word = htons(alarm_count); buffer_write(alarm_data, (uint8_t*)(&buf_word), sizeof(buf_word)); } // Add an alarm buf_word = htons(alarm->channel); buffer_write(alarm_data, (uint8_t*)(&buf_word), sizeof(buf_word)); buf_dword = htonl(alarm->timestamp); buffer_write(alarm_data, (uint8_t*)(&buf_dword), sizeof(buf_dword)); buffer_write(alarm_data, &(alarm->event), sizeof(alarm->event)); buf_byte = (uint8_t)strlen(alarm->description); buffer_write(alarm_data, &buf_byte, sizeof(buf_byte)); buffer_write(alarm_data, (uint8_t*)(alarm->description), (size_t)buf_byte); buffer_terminate(alarm_data); alarm_count++; alarm->sent = 1; } list_iterator_stop(alarm_list); if (alarm_count && alarm_data && alarm_data->content && alarm_data->length) { buffer_seek(alarm_data, 2); buf_dword = htonl(start_time); buffer_write(alarm_data, (uint8_t*)(&buf_dword), sizeof(buf_dword)); buf_dword = htonl(end_time); buffer_write(alarm_data, (uint8_t*)(&buf_dword), sizeof(buf_dword)); buf_word = htons(alarm_count); buffer_write(alarm_data, (uint8_t*)(&buf_word), sizeof(buf_word)); if (gDebug) { fprintf(stderr, "falcon: [END] alarms were found\n"); fprintf(stderr, "[END] raw buffer:\n"); format_data(alarm_data->content, alarm_data->length, 0, 0); } QueueOpaque(alarm_data->content, (int)alarm_data->length, st_info->station, st_info->network, st_info->alarm_chan, st_info->location, FALCON_IDSTRING); } alarm_data = buffer_destroy(alarm_data); // Make sure we limit the accumulation of alarm messages while (list_size(alarm_list) > MAX_CONTEXT_ALARMS) { alarm = list_fetch(alarm_list); alarm = alarm_line_destroy(alarm); } }
wr_errorcode_t wr_wavfile_filter_start(wr_rtp_filter_t * filter) { SNDFILE * file; SF_INFO file_info; wr_encoder_t * codec; wr_rtp_packet_t rtp_packet; int sequence_number = 0; int rtp_timestamp = 0; struct timeval packet_start_timestamp; struct timeval packet_end_timestamp; gettimeofday(&packet_start_timestamp, NULL); timeval_copy(&packet_end_timestamp, &packet_start_timestamp); int rtp_in_frame = iniparser_getpositiveint(wr_options.output_options, "global:rtp_in_frame", 1); int frames_count = 0; /* open WAV file */ file = sf_open(wr_options.filename, SFM_READ, &file_info); if (!file){ wr_set_error("cannot open or render sound file"); return WR_FATAL; } if (file_info.samplerate != 8000){ wr_set_error("this tool works only with .wav files in 8kHz, rerecord your signal or resample it (with sox for example)\n"); return WR_FATAL; } list_iterator_start(wr_options.codec_list); if (list_iterator_hasnext(wr_options.codec_list)){ codec = (wr_encoder_t*)list_iterator_next(wr_options.codec_list); wr_rtp_packet_init(&rtp_packet, codec->payload_type, sequence_number, 1, rtp_timestamp, packet_start_timestamp); }else{ wr_set_error("no codec is found"); return WR_FATAL; } wr_rtp_filter_notify_observers(filter, TRANSMISSION_START, NULL); /* One cycle iteration encode one data frame */ while(codec){ int input_buffer_size = (*codec->get_input_buffer_size)(codec->state); int output_buffer_size = (*codec->get_output_buffer_size)(codec->state); short input_buffer[input_buffer_size]; char output_buffer[output_buffer_size]; bzero(input_buffer, input_buffer_size); bzero(output_buffer, output_buffer_size); input_buffer_size = sf_read_short(file, input_buffer, input_buffer_size); if (!input_buffer_size){ /*EOF*/ if (frames_count){ wr_rtp_filter_notify_observers(filter, NEW_PACKET, &rtp_packet); wr_rtp_packet_destroy(&rtp_packet); frames_count = 0; sequence_number++; timeval_copy(&packet_start_timestamp, &packet_end_timestamp); wr_rtp_packet_init(&rtp_packet, codec->payload_type, sequence_number, 0, rtp_timestamp, packet_start_timestamp); } sf_seek(file, 0, SEEK_SET); if (list_iterator_hasnext(wr_options.codec_list)){ codec = (wr_encoder_t*)list_iterator_next(wr_options.codec_list); }else{ codec = NULL; list_iterator_stop(wr_options.codec_list); } continue; } output_buffer_size = (*codec->encode)(codec->state, input_buffer, output_buffer); wr_rtp_packet_add_frame(&rtp_packet, output_buffer, output_buffer_size, 1000 * input_buffer_size / file_info.samplerate); timeval_increment(&packet_end_timestamp, 1e6 * input_buffer_size / file_info.samplerate); rtp_timestamp += input_buffer_size; frames_count++; if (frames_count == rtp_in_frame){ wr_rtp_filter_notify_observers(filter, NEW_PACKET, &rtp_packet); wr_rtp_packet_destroy(&rtp_packet); frames_count = 0; sequence_number++; timeval_copy(&packet_start_timestamp, &packet_end_timestamp); wr_rtp_packet_init(&rtp_packet, codec->payload_type, sequence_number, 0, rtp_timestamp, packet_start_timestamp); } } wr_rtp_filter_notify_observers(filter, TRANSMISSION_END, NULL); sf_close(file); }
/* control_loop() is the main STCP loop; it repeatedly waits for one of the * following to happen: * - incoming data from the peer * - new data from the application (via mywrite()) * - the socket to be closed (via myclose()) * - a timeout */ static void control_loop(mysocket_t sd, context_t *ctx) { assert(ctx); int tcplen; char payload[MAXLEN]; STCPHeader *in_header; void *packtosend; char *indicpt; char tempbuff[WINLEN]; stcp_event_type_t eventflag; while (!ctx->done) { unsigned int event; eventflag = ANY_EVENT; /* set timeout if there is any unack'd data; if not, just make it NULL */ struct timespec timestart; struct timespec *timeout; if (ctx->send_unack < ctx->send_next) { timestart = ((packet_t *)list_get_at(ctx->unackd_packets, 0))->start_time; timeout = ×tart; /* constructs the timeout with absolute time by adding the RTO */ timeout->tv_sec += ctx->rto.tv_sec; timeout->tv_nsec += ctx->rto.tv_nsec; /* ensures no nanosecond overflow */ if (timeout->tv_nsec >= 1000000000) { timeout->tv_sec += timeout->tv_nsec / 1000000000; timeout->tv_nsec = timeout->tv_nsec % 1000000000; } if (timeout->tv_sec <= time(NULL)) /*earliest unacked packet has timed out, unless it's currently sitting in buffer */ eventflag = NETWORK_DATA|TIMEOUT; } else { timeout = NULL; DEBUG("No timeout set\n"); } /* see stcp_api.h or stcp_api.c for details of this function */ /* XXX: you will need to change some of these arguments! */ event = stcp_wait_for_event(sd, eventflag, timeout); /* check whether it was the network, app, or a close request */ if (event & APP_DATA) { DEBUG("Application Data\n"); /* the application has requested that data be sent */ /* we should send as long as send_wind > 0 */ int open_window = ctx->send_wind - (ctx->send_next - ctx->send_unack); if(open_window > 0) { int send_size; /* only read in as much from app as we can send */ if(open_window > MAXLEN) send_size = MAXLEN; else send_size = open_window; void* buffer = (char *) calloc(1, send_size); tcplen = stcp_app_recv(sd, buffer, send_size); if( tcplen > 0 ) { DEBUG("Application data size: %d\n", tcplen); /*create and send packet*/ packtosend = (void *)make_stcp_packet(TH_ACK, ctx->send_next, ctx->recv_next, tcplen); memcpy(packtosend + sizeof(STCPHeader), buffer, tcplen); stcp_network_send(sd, packtosend, sizeof(STCPHeader) + tcplen, NULL); DEBUG("Packet of payload size %d, ack number %d, seq number %d sent to network\n", tcplen, ctx->recv_next, ctx->send_next); packet_t_create(ctx, packtosend, sizeof(STCPHeader) + tcplen); /* now a packet has been pushed onto the unacked queue */ /* update window length and send_next */ ctx->send_next += tcplen; } free(buffer); buffer = NULL; free(packtosend); packtosend = NULL; } else DEBUG("Could not get application data\n"); } if (event & NETWORK_DATA) { DEBUG("Network Data\n"); in_header = malloc(sizeof(STCPHeader)); /* network data transmission */ int data_size = recv_packet(sd, ctx, payload, MAXLEN, in_header); DEBUG("Received net data size is %d\n", data_size); /* send ACK as long as it's not past our window, and actually contained data */ if(data_size > 0 || data_size == -2) { /* -2 indicates it received old data, which we should not send to the application */ packtosend = (void *)make_stcp_packet(TH_ACK, ctx->send_next, ctx->recv_next, 0); stcp_network_send(sd, packtosend, sizeof(STCPHeader), NULL); free(packtosend); packtosend = NULL; } /* send payload to application, if it's valid */ if(data_size > 0) { DEBUG("Sent data of size %d to application\n", data_size); stcp_app_send(sd, ctx->recv_buffer, data_size); /* slide the window over */ indicpt = strchr(ctx->recv_indicator, '\0'); data_size = indicpt - ctx->recv_indicator; memcpy(tempbuff, ctx->recv_buffer + data_size, WINLEN - data_size); memset(ctx->recv_buffer, '\0', WINLEN); memcpy(ctx->recv_buffer, tempbuff, WINLEN - data_size); /* slide window indicator over */ memcpy(tempbuff, indicpt, WINLEN - data_size); memset(ctx->recv_indicator, '\0', WINLEN); memcpy(ctx->recv_indicator, tempbuff, WINLEN - data_size); } /* deal with connection teardown, if need be */ if (in_header->th_flags & TH_ACK) { /* go from FIN-WAIT1 --> FIN-WAIT2 */ if(ctx->connection_state == CSTATE_FIN_WAIT1) { DEBUG("State: FIN-WAIT2\n"); ctx->connection_state = CSTATE_FIN_WAIT2; } /* go from LAST-ACK --> CLOSED */ if(ctx->connection_state == CSTATE_LAST_ACK) { DEBUG("State: CLOSED\n"); ctx->connection_state = CSTATE_CLOSED; free(in_header); in_header = NULL; break; } /* go from CLOSING --> CLOSED */ if(ctx->connection_state == CSTATE_CLOSING) { DEBUG("State: CLOSED\n"); ctx->connection_state = CSTATE_CLOSED; free(in_header); in_header = NULL; break; } } /* branching for the receipt of a FIN packet */ if (in_header->th_flags & TH_FIN) { DEBUG("Received FIN packet\n"); /* Acknowledge FIN, which counts as a byte */ ctx->recv_next++; packtosend = (void *)make_stcp_packet(TH_ACK, ctx->send_next, ctx->recv_next, 0); stcp_network_send(sd, packtosend, sizeof(STCPHeader), NULL); /* go into CLOSE-WAIT */ if (ctx->connection_state == CSTATE_ESTABLISHED) { DEBUG("State: CLOSE_WAIT\n"); /* inform app of FIN */ stcp_fin_received(sd); ctx->connection_state = CSTATE_CLOSE_WAIT; } /* go from FIN-WAIT2 --> CLOSED */ if (ctx->connection_state == CSTATE_FIN_WAIT2) { DEBUG("State: CLOSED\n"); ctx->connection_state = CSTATE_CLOSED; free(in_header); in_header = NULL; break; } /* go from FIN-WAIT1 --> CLOSING */ if (ctx->connection_state == CSTATE_FIN_WAIT1) { DEBUG("State: CLOSING\n"); /* inform app of FIN */ stcp_fin_received(sd); ctx->connection_state = CSTATE_CLOSING; } free(in_header); in_header = NULL; } } if (event & APP_CLOSE_REQUESTED) { DEBUG("Application close requested\n"); if(ctx->connection_state == CSTATE_ESTABLISHED) { /* need to send all outstanding data first */ DEBUG("Sending FIN packet with seq %d, ack %d\n", ctx->send_next, ctx->recv_next); STCPHeader *header = make_stcp_packet(TH_FIN, ctx->send_next, ctx->recv_next, 0); stcp_network_send(sd, header, sizeof(STCPHeader), NULL); ctx->send_unack += 1; packet_t_create(ctx, header, sizeof(STCPHeader)); free(header); header = NULL; /* go into FIN-WAIT1 */ ctx->connection_state = CSTATE_FIN_WAIT1; DEBUG("State: FIN-WAIT1\n"); } if(ctx->connection_state == CSTATE_CLOSE_WAIT) { DEBUG("Sending FIN packet with seq %d, ack %d\n", ctx->send_next, ctx->recv_next); STCPHeader *header = make_stcp_packet(TH_FIN, ctx->send_next, ctx->recv_next, 0); stcp_network_send(sd, header, sizeof(STCPHeader), NULL); packet_t_create(ctx, header, sizeof(STCPHeader)); ctx->send_next += 1; free(header); header = NULL; /* go from CLOSE-WAIT --> LAST-ACK */ ctx->connection_state = CSTATE_LAST_ACK; DEBUG("State: LAST-ACK\n"); } } if (event == TIMEOUT) { int giveup = 0; /* TIMEOUT--resend all packets in ctx->unackd_packets */ packet_t *resendpack; list_iterator_start(ctx->unackd_packets); while (list_iterator_hasnext(ctx->unackd_packets)) { resendpack = (packet_t *)list_iterator_next(ctx->unackd_packets); if (resendpack->retry_count > 6) { /*close the connection*/ DEBUG("Too many retries"); errno = ECONNABORTED; giveup = 1; } /* increment retries */ resendpack->retry_count++; clock_gettime(CLOCK_REALTIME, &(resendpack->start_time)); ((STCPHeader *)(resendpack->packet))->th_ack = htonl(ctx->recv_next); stcp_network_send(sd, resendpack->packet, resendpack->packet_size, NULL); DEBUG("Resent packet with sequence number %d\n", ntohl(((STCPHeader *)(resendpack->packet))->th_seq)); } list_iterator_stop(ctx->unackd_packets); if (giveup) break; } } }
void ddbg_precycle_hook(vm_t* vm, uint16_t pos, void* ud) { unsigned int i = 0; struct breakpoint* bk; uint16_t op, a, b; // Handle any symbols that are at this cycle. list_t* symbols = ddbg_get_symbols(vm->pc); list_iterator_start(symbols); while (list_iterator_hasnext(symbols)) dbg_lua_handle_hook_symbol(&lstate, NULL, bautofree((bstring)list_iterator_next(symbols))); list_iterator_stop(symbols); list_empty(symbols); free(symbols); // Handle custom Lua commands. dbg_lua_handle_hook(&lstate, NULL, bautofree(bfromcstr("precycle")), pos); // Check to see if Lua halted the VM and return if it did. if (vm->halted) return; // Handle breakpoints. if (!ignore_next_breakpoint) { for (i = 0; i < list_size(&breakpoints); i++) { bk = (struct breakpoint*)list_get_at(&breakpoints, i); if (vm->pc == bk->addr) { vm->halted = true; ignore_next_breakpoint = true; vm_hook_break(vm); // Required for UI to update correctly. if (bk->temporary) list_delete_at(&breakpoints, i--); if (!bk->silent) ddbg_disassemble(max_int32((int32_t)vm->pc - 10, 0x0), min_int32((int32_t)vm->pc + 10, 0x10000) - vm->pc); printd(LEVEL_DEFAULT, "Breakpoint hit at 0x%04X.\n", bk->addr); return; } } } ignore_next_breakpoint = false; // Handle backtrace. op = INSTRUCTION_GET_OP(vm->ram[vm->pc]); a = INSTRUCTION_GET_A(vm->ram[vm->pc]); b = INSTRUCTION_GET_B(vm->ram[vm->pc]); if ((op == OP_SET && b == PC) || (op == OP_NONBASIC && b == NBOP_JSR)) { // FIXME: This doesn't handle every valid value correctly.. if (a == PUSH_POP) list_delete_at(&backtrace, list_size(&backtrace) - 1); else if (a == NXT_LIT) { printd(LEVEL_DEBUG, "jumping literally from 0x%04X to 0x%04X (0x%04X).\n", vm->pc, vm->ram[vm->pc + 1], vm->pc + 1); list_append(&backtrace, backtrace_entry_create(vm->pc, vm->ram[vm->pc + 1])); } else if (a == NXT) { //list_append(&backtrace, backtrace_entry_create(vm->pc, vm->ram[vm->ram[vm->pc+1]])); } else { // Unhandled. printd(LEVEL_DEBUG, "warning: unhandled backtrace jump occurred.\n"); } } }