int ast_jb_get_when_to_wakeup(struct ast_channel *c0, struct ast_channel *c1, int time_left) { struct ast_jb *jb0 = ast_channel_jb(c0); struct ast_jb *jb1 = ast_channel_jb(c1); int c0_use_jb = ast_test_flag(jb0, JB_USE); int c0_jb_is_created = ast_test_flag(jb0, JB_CREATED); int c1_use_jb = ast_test_flag(jb1, JB_USE); int c1_jb_is_created = ast_test_flag(jb1, JB_CREATED); int wait, wait0, wait1; struct timeval tv_now; if (time_left == 0) { /* No time left - the bridge will be retried */ /* TODO: Test disable this */ /*return 0;*/ } if (time_left < 0) { time_left = INT_MAX; } gettimeofday(&tv_now, NULL); wait0 = (c0_use_jb && c0_jb_is_created) ? jb0->next - get_now(jb0, &tv_now) : time_left; wait1 = (c1_use_jb && c1_jb_is_created) ? jb1->next - get_now(jb1, &tv_now) : time_left; wait = wait0 < wait1 ? wait0 : wait1; wait = wait < time_left ? wait : time_left; if (wait == INT_MAX) { wait = -1; } else if (wait < 1) { /* don't let wait=0, because this can cause the pbx thread to loop without any sleeping at all */ wait = 1; } return wait; }
MoonAppRecord * MoonAppDatabase::CreateAppRecord (const Uri *origin) { char *install_dir, *uid; MoonAppRecord *app; const char *domain; if (origin == NULL || !(domain = origin->GetHost ())) domain = "localhost"; int seed = (int)(get_now () >> 32); #if !HAVE_RAND_R srand (seed); #endif do { #if HAVE_RAND_R int r = rand_r (&seed); #else int r = rand (); #endif uid = g_strdup_printf ("%u.%s", r, domain); install_dir = g_build_filename (base_dir, uid, NULL); if (g_mkdir_with_parents (install_dir, 0777) == 0) break; g_free (install_dir); g_free (uid); if (errno != EEXIST) { // EEXIST is the only error we can recover from... return NULL; } } while (true); app = new MoonAppRecord (); app->origin = g_strdup (origin->GetOriginalString ()); app->mtime = time (NULL); app->uid = uid; if (!AddAppRecord (app)) { RemoveDir (install_dir); delete app; return NULL; } g_free (install_dir); return app; }
/* * Check whether we need to rotate. * Possible reasons are: * - No log file open (ROTATE_NEW) * - User forces us to rotate (ROTATE_FORCE) * - Our log file size is already bigger than the * allowed maximum (ROTATE_SIZE) * - The next log time interval expired (ROTATE_TIME) * * When size and time constraints are both given, * it suffices that one of them is fulfilled. */ static void checkRotate(rotate_config_t *config, rotate_status_t *status) { if (status->current.fd == NULL) { status->rotateReason = ROTATE_NEW; } else if (config->sRotation) { apr_finfo_t finfo; apr_off_t current_size = -1; if (apr_file_info_get(&finfo, APR_FINFO_SIZE, status->current.fd) == APR_SUCCESS) { current_size = finfo.size; } if (current_size > config->sRotation) { status->rotateReason = ROTATE_SIZE; } else if (config->tRotation) { if (get_now(config) >= status->tLogEnd) { status->rotateReason = ROTATE_TIME; } } } else if (config->tRotation) { if (get_now(config) >= status->tLogEnd) { status->rotateReason = ROTATE_TIME; } } else { fprintf(stderr, "No rotation time or size specified\n"); exit(2); } if (status->rotateReason != ROTATE_NONE && config->verbose) { fprintf(stderr, "File rotation needed, reason: %s\n", ROTATE_REASONS[status->rotateReason]); } }
void TournamentSR::spawn_player(Player *p) { if (!server) { TimesOfPlayer *top = get_times_of_player(p); if (top) { if (!top->running) { top->running = true; } else { if (top->finished) { top->finished = false; gametime_t now; get_now(now); ms_t d_ms = diff_ms(top->start_time, now); GTransportTime *race = new GTransportTime; race->id = p->state.id; race->ms = static_cast<sr_milliseconds_t>(d_ms); race->to_net(); add_state_response(GPSRoundFinished, GTransportTimeLen, race); } } get_now(top->start_time); } } Tournament::spawn_player(p); }
char*ndpi_find_lru_cache_str(struct ndpi_LruCache *cache, char *key) { if(cache->hash_size == 0) return(0); else { u_int32_t hash_val = lru_hash_string(key); u_int32_t hash_id = hash_val % cache->hash_size; struct ndpi_LruCacheEntry *head, *prev = NULL; char *ret_val = NULL; time_t now = get_now(); if(unlikely(traceLRU)) printf("%s(%s)", __FUNCTION__, key); // validate_unit_len(cache, hash_id); cache->num_cache_find++; head = cache->hash[hash_id]; while(head != NULL) { if(strcmp(head->u.str.key, key) == 0) { if(head->u.str.expire_time < now) { /* The node has expired */ if(prev == NULL) cache->hash[hash_id] = head->next; else prev->next = head->next; free_lru_cache_entry(cache, head); ndpi_free(head); #ifdef FULL_STATS cache->mem_size -= sizeof(struct ndpi_LruCacheEntry); #endif ret_val = NULL; cache->current_hash_size[hash_id]--; } else ret_val = head->u.str.value; break; } else { prev = head; head = head->next; } } if(ret_val == NULL) cache->num_cache_misses++; // validate_unit_len(cache, hash_id); return(ret_val); } }
void handle_request_stats(struct evhttp_request *req, void *arg){ global_data * global = (global_data *) arg; struct evbuffer *evb; evb = evbuffer_new(); evbuffer_add_printf(evb, "Uptime: %u<br />\n", (get_now() - global->stats.starttime)); evbuffer_add_printf(evb, "Requests: %u<br />\n", global->stats.requests); // evbuffer_add_printf(evb, "Games: %u<br />\n", global->stats.games); evbuffer_add_printf(evb, "Moves: %u<br />\n", global->stats.moves); evbuffer_add_printf(evb, "Cpu Time: %u s<br />\n", global->stats.cputime/1000); evhttp_send_reply(req, HTTP_OK, "OK", evb); evbuffer_free(evb); }
void main_loop(void) { int n; struct timer *timer; int delay; while (num_pollfds > 1 || heap_len(timers) > 1 || pollfds[0].events & POLLOUT) { if (heap_empty(timers)) { timer = NULL; delay = -1; } else { timer = heap_peek(timers); delay = (timer->time - get_now()) * 1000; } if (timer && delay <= 0) n = 0; else n = poll(pollfds, num_pollfds, delay); if (!n) { timer = heap_extract_min(timers); timer->func(timer->data); free(timer); goto cont; } for (int i = 0; i < num_pollfds && n; i++) { if (pollfds[i].revents) { event_handlers[i]->func(event_handlers[i]->data); n--; /* We may have just deleted this id. * Try it again in case it's a new * one. */ i--; } } cont: maybe_dequeue(); } }
struct ndpi_LruCacheEntry* lru_allocCacheStringNode(struct ndpi_LruCache *cache, char *key, char *value, u_int32_t timeout) { struct ndpi_LruCacheEntry *node = (struct ndpi_LruCacheEntry*)ndpi_calloc(1, sizeof(struct ndpi_LruCacheEntry)); if(unlikely(traceLRU)) printf("%s(key=%s, value=%s)", __FUNCTION__, key, value); if(node == NULL) printf("ERROR: Not enough memory?"); else { node->numeric_node = 0; node->u.str.key = ndpi_strdup(key), node->u.str.value = ndpi_strdup(value); node->u.str.expire_time = (timeout == 0) ? 0 : (compute_timeout(timeout) + get_now()); #ifdef FULL_STATS cache->mem_size += sizeof(struct ndpi_LruCacheEntry) + strlen(key) + strlen(value); //printf("%s(key=%s, value=%s) [memory: %u]", __FUNCTION__, key, value, cache->mem_size); #endif } return(node); }
void init(void) { struct timespec timespec; queue = queue_new(); if (0 > clock_getres(CLOCK_MONOTONIC, ×pec)) die(); /* 5 ms resolution should be _plenty_ */ if (timespec.tv_sec || timespec.tv_nsec > 5000000) die(); start_time = 0; start_time = get_now(); if (timers) die(); timers = heap_new(timer_cmp, offsetof(struct timer, heap_loc)); max_pollfds = 128; num_pollfds = 0; myallocn(pollfds, max_pollfds); myallocn(event_handlers, max_pollfds); }
void TournamentSR::draw_score() { Player *me = get_me(); if (!(me->state.server_state.flags & PlayerServerFlagSpectating)) { TimesOfPlayer *top = get_times_of_player(me); if (top) { subsystem.set_color(0.75f, 0.75f, 1.0f, 0.75f); if (!game_over) { get_now(now_for_drawing); } ms_t d_ms = diff_ms(top->start_time, now_for_drawing); float diff = round(d_ms / 10.0f) / 100.0f; char *pb; int len; int x; int view_width = subsystem.get_view_width(); Tileset *ts = resources.get_tileset("numbers"); int tile_width = ts->get_tile(0)->get_tilegraphic()->get_width(); int number_width = tile_width - 13; int i = static_cast<int>(floor(diff)); int m = static_cast<int>((diff - i) * 100); /* first part */ sprintf(buffer, "%d", i); len = strlen(buffer); x = view_width / 2 - (len * number_width) - number_width / 2; pb = buffer; while (*pb) { subsystem.draw_tile(ts->get_tile(*pb - '0'), x, 5); x += number_width; pb++; } /* draw dot */ subsystem.draw_tile(ts->get_tile(11), x, 5); x += number_width; /* second part */ sprintf(buffer, "%02d", m); pb = buffer; while (*pb) { subsystem.draw_tile(ts->get_tile(*pb - '0'), x, 5); x += number_width; pb++; } /* reset */ subsystem.reset_color(); /* draw best & last lap */ size_t sz = top->times.size(); Font *f = resources.get_font("big"); const TimesOfPlayer& lead = times_of_players[0]; if (lead.times.size()) { subsystem.set_color(0.25f, 1.0f, 0.25f, 1.0f); subsystem.draw_text(f, 5, 5, "lead:"); sprintf(buffer, "%.2f (%s)", lead.best, lead.player->get_player_name().c_str()); subsystem.draw_text(f, 45, 5, buffer); subsystem.reset_color(); } subsystem.draw_text(f, 5, 20, "lap:"); sprintf(buffer, "%d", static_cast<int>(sz + 1)); subsystem.draw_text(f, 45, 20, buffer); if (sz) { subsystem.draw_text(f, 5, 35, "best:"); sprintf(buffer, "%.2f", top->best); subsystem.draw_text(f, 45, 35, buffer); subsystem.draw_text(f, 5, 50, "last:"); sprintf(buffer, "%.2f", top->last); subsystem.draw_text(f, 45, 50, buffer); } } } }
/** * Updates the time stamp, setting it to the current clock. */ void update() { last = get_now(); }
void TimeManager::SourceTick () { #if PUT_TIME_MANAGER_TO_SLEEP // we need to do this because we might have had a shorter timeout due to putting the time manager to sleep source->SetTimerFrequency (current_timeout); #endif TimeManagerOp current_flags = flags; #if PUT_TIME_MANAGER_TO_SLEEP flags = (TimeManagerOp)0; #endif if (current_flags & TIME_MANAGER_TICK_CALL) { STARTTICKTIMER (tm_tick_call, "TimeManager::Tick - Call"); InvokeTickCalls (); ENDTICKTIMER (tm_tick_call, "TimeManager::Tick - Call"); } if (current_flags & TIME_MANAGER_UPDATE_CLOCKS) { STARTTICKTIMER (tick_update_clocks, "TimeManager::Tick - UpdateClocks"); current_global_time = source->GetNow(); current_global_time_usec = current_global_time / 10; bool need_another_tick = root_clock->UpdateFromParentTime (GetCurrentTime()); if (need_another_tick) NeedClockTick (); // ... then cause all clocks to raise the events they've queued up root_clock->RaiseAccumulatedEvents (); applier->Apply (); applier->Flush (); root_clock->RaiseAccumulatedCompleted (); #if CLOCK_DEBUG if (need_another_tick) ListClocks (); #endif ENDTICKTIMER (tick_update_clocks, "TimeManager::Tick - UpdateClocks"); } if (current_flags & TIME_MANAGER_UPDATE_INPUT) { STARTTICKTIMER (tick_input, "TimeManager::Tick - Input"); Emit (UpdateInputEvent); ENDTICKTIMER (tick_input, "TimeManager::Tick - Input"); } if (current_flags & TIME_MANAGER_RENDER) { // fprintf (stderr, "rendering\n"); fflush (stderr); STARTTICKTIMER (tick_render, "TimeManager::Tick - Render"); rendering_args->SetRenderingTime (get_now()); rendering_args->ref (); // to keep Emit from destroying the object Emit (RenderEvent, rendering_args); ENDTICKTIMER (tick_render, "TimeManager::Tick - Render"); } last_global_time = current_global_time; #if PUT_TIME_MANAGER_TO_SLEEP if (flags == 0 && source_tick_pending) { Stop (); } #endif }
int main (int argc, const char * const argv[]) { char buf[BUFSIZE]; apr_size_t nRead, nWrite; apr_file_t *f_stdin; apr_file_t *f_stdout; apr_getopt_t *opt; apr_status_t rv; char c; const char *opt_arg; const char *err = NULL; #if APR_FILES_AS_SOCKETS apr_pollfd_t pollfd = { 0 }; apr_status_t pollret = APR_SUCCESS; int polltimeout; #endif apr_app_initialize(&argc, &argv, NULL); atexit(apr_terminate); memset(&config, 0, sizeof config); memset(&status, 0, sizeof status); status.rotateReason = ROTATE_NONE; apr_pool_create(&status.pool, NULL); apr_getopt_init(&opt, status.pool, argc, argv); #if APR_FILES_AS_SOCKETS while ((rv = apr_getopt(opt, "lL:p:ftvecn:", &c, &opt_arg)) == APR_SUCCESS) { #else while ((rv = apr_getopt(opt, "lL:p:ftven:", &c, &opt_arg)) == APR_SUCCESS) { #endif switch (c) { case 'l': config.use_localtime = 1; break; case 'L': config.linkfile = opt_arg; break; case 'p': config.postrotate_prog = opt_arg; break; case 'f': config.force_open = 1; break; case 't': config.truncate = 1; break; case 'v': config.verbose = 1; break; case 'e': config.echo = 1; break; #if APR_FILES_AS_SOCKETS case 'c': config.create_empty = 1; break; #endif case 'n': config.num_files = atoi(opt_arg); status.fileNum = -1; break; } } if (rv != APR_EOF) { usage(argv[0], NULL /* specific error message already issued */ ); } /* * After the initial flags we need 2 to 4 arguments, * the file name, either the rotation interval time or size * or both of them, and optionally the UTC offset. */ if ((argc - opt->ind < 2) || (argc - opt->ind > 4) ) { usage(argv[0], "Incorrect number of arguments"); } config.szLogRoot = argv[opt->ind++]; /* Read in the remaining flags, namely time, size and UTC offset. */ for(; opt->ind < argc; opt->ind++) { if ((err = get_time_or_size(&config, argv[opt->ind], opt->ind < argc - 1 ? 0 : 1)) != NULL) { usage(argv[0], err); } } config.use_strftime = (strchr(config.szLogRoot, '%') != NULL); if (config.use_strftime && config.num_files > 0) { fprintf(stderr, "Cannot use -n with %% in filename\n"); exit(1); } if (status.fileNum == -1 && config.num_files < 1) { fprintf(stderr, "Invalid -n argument\n"); exit(1); } if (apr_file_open_stdin(&f_stdin, status.pool) != APR_SUCCESS) { fprintf(stderr, "Unable to open stdin\n"); exit(1); } if (apr_file_open_stdout(&f_stdout, status.pool) != APR_SUCCESS) { fprintf(stderr, "Unable to open stdout\n"); exit(1); } /* * Write out result of config parsing if verbose is set. */ if (config.verbose) { dumpConfig(&config); } #if APR_FILES_AS_SOCKETS if (config.create_empty && config.tRotation) { pollfd.p = status.pool; pollfd.desc_type = APR_POLL_FILE; pollfd.reqevents = APR_POLLIN; pollfd.desc.f = f_stdin; } #endif /* * Immediately open the logfile as we start, if we were forced * to do so via '-f'. */ if (config.force_open) { doRotate(&config, &status); } for (;;) { nRead = sizeof(buf); #if APR_FILES_AS_SOCKETS if (config.create_empty && config.tRotation) { polltimeout = status.tLogEnd ? status.tLogEnd - get_now(&config) : config.tRotation; if (polltimeout <= 0) { pollret = APR_TIMEUP; } else { pollret = apr_poll(&pollfd, 1, &pollret, apr_time_from_sec(polltimeout)); } } if (pollret == APR_SUCCESS) { rv = apr_file_read(f_stdin, buf, &nRead); if (APR_STATUS_IS_EOF(rv)) { break; } else if (rv != APR_SUCCESS) { exit(3); } } else if (pollret == APR_TIMEUP) { *buf = 0; nRead = 0; } else { fprintf(stderr, "Unable to poll stdin\n"); exit(5); } #else /* APR_FILES_AS_SOCKETS */ rv = apr_file_read(f_stdin, buf, &nRead); if (APR_STATUS_IS_EOF(rv)) { break; } else if (rv != APR_SUCCESS) { exit(3); } #endif /* APR_FILES_AS_SOCKETS */ checkRotate(&config, &status); if (status.rotateReason != ROTATE_NONE) { doRotate(&config, &status); } nWrite = nRead; rv = apr_file_write_full(status.current.fd, buf, nWrite, &nWrite); if (nWrite != nRead) { apr_off_t cur_offset; cur_offset = 0; if (apr_file_seek(status.current.fd, APR_CUR, &cur_offset) != APR_SUCCESS) { cur_offset = -1; } status.nMessCount++; apr_snprintf(status.errbuf, sizeof status.errbuf, "Error %d writing to log file at offset %" APR_OFF_T_FMT ". " "%10d messages lost (%pm)\n", rv, cur_offset, status.nMessCount, &rv); truncate_and_write_error(&status); } else { status.nMessCount++; } if (config.echo) { if (apr_file_write_full(f_stdout, buf, nRead, &nWrite)) { fprintf(stderr, "Unable to write to stdout\n"); exit(4); } } } return 0; /* reached only at stdin EOF. */ }
/* * Open a new log file, and if successful * also close the old one. * * The timestamp for the calculation of the file * name of the new log file will be the actual millisecond * timestamp, except when a regular rotation based on a time * interval is configured and the previous interval * is over. Then the timestamp is the starting time * of the actual interval. */ static void doRotate(rotate_config_t *config, rotate_status_t *status) { int now = get_now(config); int tLogStart; apr_status_t rv; struct logfile newlog; int thisLogNum = -1; status->rotateReason = ROTATE_NONE; if (config->tRotation) { int tLogEnd; tLogStart = (now / config->tRotation) * config->tRotation; tLogEnd = tLogStart + config->tRotation; /* * Check if rotation was forced and the last rotation * interval is not yet over. Use the value of now instead * of the time interval boundary for the file name then. */ if (tLogStart < status->tLogEnd) { tLogStart = now; } status->tLogEnd = tLogEnd; } else { tLogStart = now; } if (config->use_strftime) { apr_time_t tNow = apr_time_from_sec(tLogStart); apr_time_exp_t e; apr_size_t rs; apr_time_exp_gmt(&e, tNow); apr_strftime(newlog.name, &rs, sizeof(newlog.name), config->szLogRoot, &e); } else { if (config->truncate) { apr_snprintf(newlog.name, sizeof(newlog.name), "%s", config->szLogRoot); } else if (config->num_files > 0) { if (status->fileNum == -1 || status->fileNum == (config->num_files - 1)) { thisLogNum = 0; apr_snprintf(newlog.name, sizeof(newlog.name), "%s", config->szLogRoot); } else { thisLogNum = status->fileNum + 1; apr_snprintf(newlog.name, sizeof(newlog.name), "%s.%d", config->szLogRoot, thisLogNum); } } else { apr_snprintf(newlog.name, sizeof(newlog.name), "%s.%010d", config->szLogRoot, tLogStart); } } apr_pool_create(&newlog.pool, status->pool); if (config->verbose) { fprintf(stderr, "Opening file %s\n", newlog.name); } rv = apr_file_open(&newlog.fd, newlog.name, APR_WRITE | APR_CREATE | APR_APPEND | (config->truncate || (config->num_files > 0 && status->current.fd) ? APR_TRUNCATE : 0), APR_OS_DEFAULT, newlog.pool); if (rv == APR_SUCCESS) { /* Handle post-rotate processing. */ post_rotate(newlog.pool, &newlog, config, status); status->fileNum = thisLogNum; /* Close out old (previously 'current') logfile, if any. */ if (status->current.fd) { close_logfile(config, &status->current); } /* New log file is now 'current'. */ status->current = newlog; } else { char error[120]; apr_strerror(rv, error, sizeof error); /* Uh-oh. Failed to open the new log file. Try to clear * the previous log file, note the lost log entries, * and keep on truckin'. */ if (status->current.fd == NULL) { fprintf(stderr, "Could not open log file '%s' (%s)\n", newlog.name, error); exit(2); } /* Throw away new state; it isn't going to be used. */ apr_pool_destroy(newlog.pool); /* Try to keep this error message constant length * in case it occurs several times. */ apr_snprintf(status->errbuf, sizeof status->errbuf, "Resetting log file due to error opening " "new log file, %10d messages lost: %-25.25s\n", status->nMessCount, error); truncate_and_write_error(status); } status->nMessCount = 0; }
int main(int argc, char**argv) { //Iterator int i; //Port number int port; //Host file string hostfile; //count of messages to be sent int count; //Delivery queue map<Key,DM*> delivery_queue; //Delivered Messages vector<Key> delivered_queue; //Map to store Hostname to IP address map<string,string> host_to_id; //Map to store Hostname to id map<string,int> hostname_to_id; //Map to maintain retransmission info map<string,bool> host_retransmit_info; //buffer to hold a recieved message char *mesg = (char *)malloc(sizeof(AckMessage)); if(argc < 7) { kprintf("Usage: "); kprintf("proj2 -p port -h hostfile -c count"); exit(EXIT_FAILURE); } for(i=0;i<argc;i++) { string arg = argv[i]; if(arg == "-p") { if(argv[i+1]) { string temp = argv[i+1]; port = atoi(temp.c_str()); if(port == 0 || port <=1024) { kprintf("Invalid port. Please specify a port greater than 1024"); exit(EXIT_FAILURE); } i = i + 1; } else { kprintf("Please specify port number"); exit(EXIT_FAILURE); } } if(arg == "-h") { if(argv[i+1]) { hostfile = argv[i+1]; i = i + 1; } else { kprintf("Please specify host file"); exit(EXIT_FAILURE); } } if(arg == "-c") { if(argv[i+1]) { string temp = argv[i+1]; count = atoi(temp.c_str()); i = i + 1; if(count < 0) { kprintf("Number of messages to be multicast must be greater than zero"); exit(EXIT_FAILURE); } } else { kprintf("Please specify number of messages to be multicast"); exit(EXIT_FAILURE); } } } kprintf("Port: ",port); kprintf("Hostfile: ",hostfile); kprintf("Count: ",count); ifstream hostfile_stream(hostfile.c_str()); string hostname; int host_id = 0; if(hostfile_stream.is_open()) { while(hostfile_stream.good()) { getline(hostfile_stream,hostname); if(!hostname.empty()) { hostname_to_id[hostname] = host_id++; //Get IP address struct hostent *hp; hp = gethostbyname(hostname.c_str()); if(!hp) { kprintf(" not found ",hostname); exit(EXIT_FAILURE); } if((inet_ntoa(*(struct in_addr *)hp->h_addr_list[0]))) { string s_local(inet_ntoa(*(struct in_addr *)hp->h_addr_list[0])); kprintf(s_local.c_str()); if(s_local.find("127") != 0) { host_to_id[hostname] = s_local; host_retransmit_info[s_local] = false; } else { host_to_id[hostname] = string(inet_ntoa(*(struct in_addr *)hp->h_addr_list[1])); host_retransmit_info[string(inet_ntoa(*(struct in_addr *)hp->h_addr_list[1]))] = false; } } else { host_to_id[hostname] = string(inet_ntoa(*(struct in_addr *)hp->h_addr_list[1])); host_retransmit_info[string(inet_ntoa(*(struct in_addr *)hp->h_addr_list[1]))] = false; } kprintf(hostname.c_str()); } } hostfile_stream.close(); } else { kprintf("Unable to read host file"); exit(EXIT_FAILURE); } kprintf("Size is: ",host_to_id.at("xinu01.cs.purdue.edu")); //get my hostname char myhostname[HOSTNAME_LEN]; gethostname(myhostname,HOSTNAME_LEN); string myhostname_str(myhostname); host_retransmit_info[host_to_id[myhostname_str]] = true; //Iterator for sending messages int iter=0; //Seq numbers to be maintained throughout int max_last_proposed_seq_num=0; int last_proposed_seq_num = 0; //Socket variables int sockfd,n; struct sockaddr_in servaddr,cliaddr; socklen_t lensock; sockfd = socket(AF_INET,SOCK_DGRAM,0); if(sockfd == -1) { kprintf("Could not create socket"); exit(EXIT_FAILURE); } bzero(&servaddr,sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr=htonl(INADDR_ANY); servaddr.sin_port=htons(port); int bval = bind(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr)); if(bval==-1) { kprintf("Bind failed\n"); exit(EXIT_FAILURE); } //Multiset to maintain all the sequence numbers recieved in Acks multiset<int> ackmultiset; //infinite loop for the protocol while(1) { //Send message to all other hosts/processes only if iter<count if(iter<count) { DataMessage *init_dm = (DataMessage *)malloc(sizeof(DataMessage)); init_dm->type = TYPE_DM; init_dm->sender = hostname_to_id[myhostname_str]; //Get sender ID kprintf("Sender ID: ",init_dm->sender); init_dm->msg_id = iter; init_dm->data = iter; host_network(init_dm); for(map<string,string>::iterator it = host_to_id.begin();it != host_to_id.end();++it) { if(host_retransmit_info[it->second.c_str()] == false) { cliaddr.sin_family = AF_INET; cliaddr.sin_addr.s_addr = inet_addr(it->second.c_str()); cliaddr.sin_port = htons(port); int rval = sendto(sockfd,init_dm,sizeof(DataMessage),0,(struct sockaddr *)&cliaddr,sizeof(cliaddr)); kprintf("Sent message ",it->second.c_str()); } } network_host(init_dm); Key current_srch_key (last_proposed_seq_num,hostname_to_id[myhostname_str]); //Add the sent message to your queue if it does not already exist if(delivery_queue.find(current_srch_key) == delivery_queue.end()) { DM* sent_msg = (DM*)malloc(sizeof(DM)); sent_msg->deliverable = false; sent_msg->seq_num = ++max_last_proposed_seq_num; sent_msg->data_msg = init_dm; Key current_key (sent_msg->seq_num,hostname_to_id[myhostname_str]); last_proposed_seq_num = max_last_proposed_seq_num; //Add the sent message to your queue delivery_queue[current_key] = sent_msg; kprintf("Inserted in delivery queue",current_key.seq); } } //Start Recieving messages here //start ack timer struct timeval time_ack,time_curr_ack; get_now(&time_ack); while(time_to_seconds(&time_ack,get_now(&time_curr_ack)) <= UDP_RETRANSMIT_TIMER) { socklen_t lensock = sizeof(cliaddr); if((n = recvfrom(sockfd,mesg,sizeof(AckMessage),MSG_DONTWAIT,(struct sockaddr *)&cliaddr,&lensock)) > 0) { //Get the type by converting from network to host uint32_t* recv_type = (uint32_t*)malloc(sizeof(uint32_t)); memcpy(recv_type,mesg,sizeof(uint32_t)); int type = *recv_type; type = ntohl(type); kprintf("Recieved Type",type); if(type == TYPE_ACK) { AckMessage* ack_mesg = (AckMessage*)mesg; network_host(ack_mesg); int sender = hostname_to_id[myhostname_str]; if(ack_mesg->receiver == sender && iter == ack_mesg->msg_id) { //Mark Ack recieved string ip = string(inet_ntoa(cliaddr.sin_addr)); if(host_retransmit_info.find(ip) != host_retransmit_info.end()) { host_retransmit_info[ip] = true; kprintf("Marked true for ip ",ip.c_str()); } } ackmultiset.insert(ack_mesg->proposed_seq); } else if(type == TYPE_DM) { //Check if it is delivered DataMessage* dm_mesg = (DataMessage*) mesg; network_host(dm_mesg); int msg_id = dm_mesg->msg_id; int sender = dm_mesg->sender; bool delivered = false; for(vector<Key>:: iterator it=delivered_queue.begin();it!=delivered_queue.end();++it) { if((*it).seq == msg_id && (*it).pid == sender) { delivered = true; } } //Check if in ready queue bool inreadyqueue = false; for(map<Key,DM*>:: iterator it=delivery_queue.begin();it!=delivery_queue.end();it++) { if((it->second)->data_msg->msg_id == msg_id && (it->second)->data_msg->sender == sender) inreadyqueue = true; } //if not in ready queue or delivered if(delivered == false && inreadyqueue == false) { //Send Ack AckMessage* ack_mesg = (AckMessage*)malloc(sizeof(AckMessage)); ack_mesg->type = TYPE_ACK; ack_mesg->sender = hostname_to_id[myhostname_str]; ack_mesg->msg_id = msg_id; ack_mesg->proposed_seq = ++max_last_proposed_seq_num; ack_mesg->receiver = sender; host_network(ack_mesg); //Send ack to the sender string ip = string(inet_ntoa(cliaddr.sin_addr)); cliaddr.sin_family = AF_INET; cliaddr.sin_addr.s_addr = inet_addr(ip.c_str()); cliaddr.sin_port = htons(port); int rval = sendto(sockfd,ack_mesg,sizeof(AckMessage),0,(struct sockaddr *)&cliaddr,sizeof(cliaddr)); kprintf("Sent Ack to ",ip.c_str()); //Store in Queue ******************** string current_hostname; for(map<string,string>:: iterator it=host_to_id.begin(); it!=host_to_id.end(); it++) { if((it->second).compare(ip) == 0) current_hostname = it->first; } DataMessage *init_dm = (DataMessage *)malloc(sizeof(DataMessage)); init_dm->type = TYPE_DM; init_dm->sender = hostname_to_id[current_hostname]; init_dm->msg_id = msg_id; init_dm->data = dm_mesg->data; DM* sent_msg = (DM*)malloc(sizeof(DM)); sent_msg->deliverable = false; sent_msg->seq_num = max_last_proposed_seq_num; sent_msg->data_msg = init_dm; Key current_key (sent_msg->seq_num,hostname_to_id[current_hostname]); last_proposed_seq_num = max_last_proposed_seq_num; //Add the sent message to your queue delivery_queue[current_key] = sent_msg; kprintf("Inserted in delivery queue",current_key.seq); } } else if(type == TYPE_SEQ_MSG) { SeqMessage* seq_mesg = (SeqMessage*)mesg; network_host(seq_mesg); int msg_id = seq_mesg->msg_id; int sender = seq_mesg->sender; //Search in delivery queue for the corresponding message for(map<Key,DM*>:: iterator it=delivery_queue.begin();it!=delivery_queue.end();it++) { if((it->second)->data_msg->msg_id == msg_id && (it->second)->data_msg->sender == sender) { (it->second)->deliverable = true; (it->second)->seq_num = seq_mesg->final_seq; } } max_last_proposed_seq_num = seq_mesg->final_seq; deliver_messages(&delivery_queue,&delivered_queue,hostname_to_id[myhostname_str]); kprintf("Got final seq message", seq_mesg->msg_id); } } } //go for next message if(check(host_retransmit_info)) { kprintf("After check"); //Get the maximum sequence number recieved int max = *(ackmultiset.rbegin()); kprintf("Max is",max); //Update the max proposed seq num for next message if(max_last_proposed_seq_num < max) max_last_proposed_seq_num = max; //Build the final seq message SeqMessage* final_seq_msg = (SeqMessage *)malloc(sizeof(SeqMessage)); final_seq_msg->type = TYPE_SEQ_MSG; final_seq_msg->sender = hostname_to_id[myhostname_str]; final_seq_msg->msg_id = iter; final_seq_msg->final_seq = max; host_network(final_seq_msg); //send it to everyone for(map<string,string>::iterator it = host_to_id.begin();it != host_to_id.end();++it) { if(myhostname_str.compare(it->first) !=0) { cliaddr.sin_family = AF_INET; cliaddr.sin_addr.s_addr = inet_addr(it->second.c_str()); cliaddr.sin_port = htons(port); int rval = sendto(sockfd,final_seq_msg,sizeof(SeqMessage),0,(struct sockaddr *)&cliaddr,sizeof(cliaddr)); kprintf("Sent final sequence message ",it->second.c_str()); } } int msg_id_srch = iter; int sender = hostname_to_id[myhostname_str]; //update the message in delivery queue with the final sequence number for(map<Key,DM*>:: iterator it = delivery_queue.begin();it != delivery_queue.end();++it) { if(it->second->data_msg->sender == sender && it->second->data_msg->msg_id == msg_id_srch) { //Prepare new message DM* updatedDM = (DM*)malloc(sizeof(DM)); updatedDM->data_msg = it->second->data_msg; updatedDM->deliverable = true; updatedDM->seq_num = max; //erase the old msg delivery_queue.erase(it); //Prepare new key Key updated_key(max,sender); //Update queue delivery_queue[updated_key] = updatedDM; kprintf("Found the message and marked deliverable and updated sequence number too",updatedDM->seq_num); } } //deliver messages deliver_messages(&delivery_queue,&delivered_queue,hostname_to_id[myhostname_str]); iter++; //Reinitialize for new message host_retransmit_info = reinit(host_retransmit_info,host_to_id[myhostname_str]); //Reinitialize ack multiset ackmultiset = reinit_set(ackmultiset); } } }
void* capture_multiple_images (void* data) { capture_multiple_images_data_t* cmid = (capture_multiple_images_data_t *) data; std::list<Magick::Image> image_list; pid_t pid = getpid (); gint64 start, previous, current, elapsed, next; const gint64 ticks_in_ms = 10000; const gchar *tmp_dir = g_get_tmp_dir (); gchar *pid_dir = g_strdup_printf ("%i", pid); gchar *image_dir = g_build_filename (tmp_dir, "moonlight-test-harness", pid_dir, NULL); gchar **image_paths = (gchar **) g_malloc0 (sizeof (gchar *) * (cmid->count + 1)); gchar **image_files = (gchar **) g_malloc0 (sizeof (gchar *) * (cmid->count + 1)); LOG_CAPTURE ("Moonlight harness: Capture %i screenshots, initial delay: %i ms, interval: %i ms, width: %i, height: %i\n", cmid->count, cmid->initial_delay, cmid->interval, cmid->width, cmid->height); usleep (cmid->initial_delay * 1000); g_mkdir_with_parents (image_dir, 0700); ScreenCaptureData sc (cmid->x, cmid->y, cmid->width, cmid->height); start = get_now () / ticks_in_ms; for (int i = 0; i < cmid->count; i++) { image_files [i] = g_strdup_printf ("multilayered-image-%03i.png", i); image_paths [i] = g_build_filename (image_dir, image_files [i], NULL); // printf (" Capturing screenshot #%2i into %s", i + 1, image_paths [i]); previous = get_now () / ticks_in_ms; sc.Capture (image_paths [i]); current = get_now () / ticks_in_ms; elapsed = current - start; next = (start + cmid->interval * (i + 1)) - current; if (next <= 0) { next = cmid->interval; if (current - previous > cmid->interval) printf ("\nMoonlight harness: Screen capture can't capture fast enough. Interval %" G_GINT64_FORMAT " ms, time spent taking screenshot: %" G_GINT64_FORMAT " ms\n", (gint64) cmid->interval, (gint64) current - previous); } LOG_CAPTURE (" Done in %4" G_GINT64_FORMAT " ms, elapsed: %4" G_GINT64_FORMAT " ms, sleeping %4" G_GINT64_FORMAT " ms\n", current - previous, elapsed, next); usleep (next * 1000); } try { for (int i = 0; i < cmid->count; i++) { Magick::Image image; image.read (image_paths [i]); image_list.push_front (image); } Magick::writeImages (image_list.begin (), image_list.end (), cmid->image_path); } catch (Magick::Exception & error) { // Don't crash if imagemagick freaks out printf ("Moonlight harness: ImageMagick threw an exception: %s\n", error.what ()); } // Cleanup after us for (int i = 0; i < cmid->count; i++) { unlink (image_paths [i]); } rmdir (image_dir); g_strfreev (image_paths); g_strfreev (image_files); g_free (pid_dir); g_free (image_dir); capture_multiple_images_data_free (cmid); shutdown_manager_wait_decrement (); LOG_CAPTURE ("Moonlight harness: Capture %i screenshots [Done]\n", cmid->count); return NULL; }
int ast_jb_put(struct ast_channel *chan, struct ast_frame *f) { struct ast_jb *jb = ast_channel_jb(chan); const struct ast_jb_impl *jbimpl = jb->impl; void *jbobj = jb->jbobj; struct ast_frame *frr; long now = 0; if (!ast_test_flag(jb, JB_USE)) return -1; if (f->frametype != AST_FRAME_VOICE) { if (f->frametype == AST_FRAME_DTMF && ast_test_flag(jb, JB_CREATED)) { jb_framelog("JB_PUT {now=%ld}: Received DTMF frame. Force resynching jb...\n", now); jbimpl->force_resync(jbobj); } return -1; } /* We consider an enabled jitterbuffer should receive frames with valid timing info. */ if (!ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO) || f->len < 2 || f->ts < 0) { ast_log(LOG_WARNING, "%s received frame with invalid timing info: " "has_timing_info=%d, len=%ld, ts=%ld, src=%s\n", ast_channel_name(chan), ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO), f->len, f->ts, f->src); return -1; } frr = ast_frdup(f); if (!frr) { ast_log(LOG_ERROR, "Failed to isolate frame for the jitterbuffer on channel '%s'\n", ast_channel_name(chan)); return -1; } if (!ast_test_flag(jb, JB_CREATED)) { if (create_jb(chan, frr)) { ast_frfree(frr); /* Disable the jitterbuffer */ ast_clear_flag(jb, JB_USE); return -1; } ast_set_flag(jb, JB_CREATED); return 0; } else { now = get_now(jb, NULL); if (jbimpl->put(jbobj, frr, now) != AST_JB_IMPL_OK) { jb_framelog("JB_PUT {now=%ld}: Dropped frame with ts=%ld and len=%ld\n", now, frr->ts, frr->len); ast_frfree(frr); /*return -1;*/ /* TODO: Check this fix - should return 0 here, because the dropped frame shouldn't be delivered at all */ return 0; } jb->next = jbimpl->next(jbobj); jb_framelog("JB_PUT {now=%ld}: Queued frame with ts=%ld and len=%ld\n", now, frr->ts, frr->len); return 0; } }
void Client::idle() throw (Exception) { /* process net io */ bool queue_empty = true; do { ServerEvent evt; { Scope<Mutex> lock(mtx); if (server_events.empty()) { break; } evt = server_events.front(); server_events.pop(); queue_empty = server_events.empty(); } switch (evt.event) { case EventTypeStatus: { std::string msg(evt.data, evt.sz); subsystem << msg << std::endl; break; } case EventTypeAccessDenied: { stop_thread(); exception_msg.assign(evt.data, evt.sz); throw_exception = true; break; } case EventTypeLogin: { sevt_login(evt); break; } case EventTypeLogout: { stop_thread(); logged_in = false; conn = 0; exception_msg.assign(evt.data, evt.sz); throw_exception = true; break; } case EventTypeData: sevt_data(evt); break; } if (evt.data) { delete[] evt.data; } } while (!queue_empty && !throw_exception); /* have to throw an exception? */ if (throw_exception) { throw ClientException(exception_msg); } /* interpolate movements */ get_now(now); ns_t diff = diff_ns(last, now); last = now; if (tournament) { tournament->update_states(diff); if (conn) { tournament->set_ping_time(conn->ping_time); Tournament::StateResponses& responses = tournament->get_state_responses(); size_t sz = responses.size(); { Scope<Mutex> lock(mtx); for (size_t i = 0; i < sz; i++) { StateResponse *resp = responses[i]; if (resp->action == GPCTextMessage) { std::string msg(reinterpret_cast<const char *>(resp->data), resp->len); add_text_msg(msg); } else { stacked_send_data(conn, factory.get_tournament_id(), resp->action, 0, resp->len, resp->data); } } flush_stacked_send_data(conn, 0); } } tournament->delete_responses(); /* send player position (unreliable) */ updatecnt += diff; bool player_force = false; if (me && me->force_broadcast) { player_force = true; me->force_broadcast = false; me->state.client_server_state.flags |= PlayerClientServerFlagForceBroadcast; } if (updatecnt >= UpdatePeriod || force_send || player_force) { updatecnt = 0; if (conn && me && tournament->is_ready()) { GPlayerClientServerState state; state = me->state.client_server_state; state.to_net(); { Scope<Mutex> lock(mtx); send_data(conn, factory.get_tournament_id(), GPSUpdatePlayerClientServerState, 0, GPlayerClientServerStateLen, &state); } me->state.client_server_state.flags &= ~PlayerClientServerFlagForceBroadcast; } } } /* interpolate messages */ for (TextMessages::iterator it = text_messages.begin(); it != text_messages.end(); it++) { TextMessage *cmsg = *it; cmsg->duration += (diff / 1000000.0f); if (cmsg->duration > text_message_duration) { cmsg->delete_me = true; } } text_messages.erase(std::remove_if(text_messages.begin(), text_messages.end(), erase_element<TextMessage>), text_messages.end()); /* player in options or in chatbox? */ if (me) { if (get_stack_count()) { me->state.client_server_state.flags |= PlayerClientServerFlagWriting; } else { me->state.client_server_state.flags &= ~PlayerClientServerFlagWriting; } } /* draw map */ if (tournament) { tournament->draw(); } /* draw messages */ Font *font = resources.get_font("normal"); int view_height = subsystem.get_view_height(); int font_height = font->get_font_height(); int y = view_height - font_height - 5; for (TextMessages::reverse_iterator it = text_messages.rbegin(); it != text_messages.rend(); it++) { TextMessage *cmsg = *it; float alpha = 1.0f; if (cmsg->duration > text_message_fade_out_at) { alpha = static_cast<float>((text_message_duration - cmsg->duration) / (text_message_duration - text_message_fade_out_at)); } subsystem.set_color(0.75f, 0.75f, 1.0f, alpha); subsystem.draw_text(font, 5, y, cmsg->text); alpha *= 0.9f; y -= font_height; } subsystem.reset_color(); /* draw file transfer status */ if (fhnd) { Font *big = resources.get_font("big"); int percent = 100 - static_cast<int>(100.0f / static_cast<float>(total_xfer_sz) * remaining_xfer_sz); sprintf(buffer, "transferring %s (%d%%)", xfer_filename.c_str(), percent); int tw = big->get_text_width(buffer); subsystem.draw_text(big, subsystem.get_view_width() / 2 - tw / 2, view_height - 30, buffer); } }
static int create_jb(struct ast_channel *chan, struct ast_frame *frr) { struct ast_jb *jb = ast_channel_jb(chan); struct ast_jb_conf *jbconf = &jb->conf; const struct ast_jb_impl *jbimpl = jb->impl; void *jbobj; struct ast_channel *bridged; long now; char logfile_pathname[20 + AST_JB_IMPL_NAME_SIZE + 2*AST_CHANNEL_NAME + 1]; char name1[AST_CHANNEL_NAME], name2[AST_CHANNEL_NAME], *tmp; int res; jbobj = jb->jbobj = jbimpl->create(jbconf, jbconf->resync_threshold); if (!jbobj) { ast_log(LOG_WARNING, "Failed to create jitterbuffer on channel '%s'\n", ast_channel_name(chan)); return -1; } now = get_now(jb, NULL); res = jbimpl->put_first(jbobj, frr, now); /* The result of putting the first frame should not differ from OK. However, its possible some implementations (i.e. adaptive's when resynch_threshold is specified) to drop it. */ if (res != AST_JB_IMPL_OK) { ast_log(LOG_WARNING, "Failed to put first frame in the jitterbuffer on channel '%s'\n", ast_channel_name(chan)); /* jbimpl->destroy(jbobj); return -1; */ } /* Init next */ jb->next = jbimpl->next(jbobj); /* Init last format for a first time. */ ast_format_copy(&jb->last_format, &frr->subclass.format); /* Create a frame log file */ if (ast_test_flag(jbconf, AST_JB_LOG)) { char safe_logfile[30] = "/tmp/logfile-XXXXXX"; int safe_fd; snprintf(name2, sizeof(name2), "%s", ast_channel_name(chan)); if ((tmp = strchr(name2, '/'))) { *tmp = '#'; } bridged = ast_bridged_channel(chan); /* We should always have bridged chan if a jitterbuffer is in use */ ast_assert(bridged != NULL); snprintf(name1, sizeof(name1), "%s", ast_channel_name(bridged)); if ((tmp = strchr(name1, '/'))) { *tmp = '#'; } snprintf(logfile_pathname, sizeof(logfile_pathname), "/tmp/ast_%s_jb_%s--%s.log", jbimpl->name, name1, name2); unlink(logfile_pathname); safe_fd = mkstemp(safe_logfile); if (safe_fd < 0 || link(safe_logfile, logfile_pathname) || unlink(safe_logfile) || !(jb->logfile = fdopen(safe_fd, "w+b"))) { ast_log(LOG_ERROR, "Failed to create frame log file with pathname '%s': %s\n", logfile_pathname, strerror(errno)); jb->logfile = NULL; if (safe_fd > -1) { close(safe_fd); } } if (res == AST_JB_IMPL_OK) { jb_framelog("JB_PUT_FIRST {now=%ld}: Queued frame with ts=%ld and len=%ld\n", now, frr->ts, frr->len); } else { jb_framelog("JB_PUT_FIRST {now=%ld}: Dropped frame with ts=%ld and len=%ld\n", now, frr->ts, frr->len); } } ast_verb(3, "%s jitterbuffer created on channel %s\n", jbimpl->name, ast_channel_name(chan)); /* Free the frame if it has not been queued in the jb */ if (res != AST_JB_IMPL_OK) { ast_frfree(frr); } return 0; }
// <@$M_{t1}$@> module void acq () { uint myt = FAI_ticket(); while(get_now()!=myt){}; hold_lock(); }
void benchcore(const char *host,const int port,const char *req) { int rlen; char buf[1500], readflag; int s,i, success; struct sigaction sa; ull start, end; long recv_byte; FILE* f; /* setup alarm signal handler */ sa.sa_handler=alarm_handler; sa.sa_flags=0; if(sigaction(SIGALRM,&sa,NULL)) exit(3); alarm(benchtime); rlen=strlen(req); f=fdopen(mypipe[1],"w"); /* open pipe to write data*/ while(1) { if(timerexpired) { if(failed>0) { failed--; } break; } start = get_now(); recv_byte = 0; success = 0; readflag = 0; s=Socket(host,port); if(s<0) { failed++; goto writelog; } if(rlen!=write(s,req,rlen)) { failed++; close(s); goto writelog; } if(http10==0) if(shutdown(s,1)) { failed++; close(s); goto writelog; } if(force==0) { /* read all available data from socket */ do { if(timerexpired) break; i = read(s,buf,1500); /* fprintf(stderr,"%s\n", buf); */ if(i < 0) { failed++; close(s); goto writelog; } else { if(i==0) break; else { if (!readflag) { readflag = 1; buf[8] = 0; if(!strcmp(buf, HTTP_HEADER)) { if(buf[9] < '4') { success = 1; } } } bytes+=i; recv_byte += i; } } } while(1); } if(close(s)) { failed++; goto writelog; } speed++; writelog: { end = get_now(); /* Ignore error caused by signal. */ if (!timerexpired) fprintf(f, "%d %ld %d\n", success, recv_byte, (int)(end - start)); } } fprintf(f, "-1 0 0\n"); fclose(f); }
void callback(const HttpRequest* req, HttpResponse* res) { Buffer content; ServerInfo svr_info; StatementsInfo smt_info; if (req->path() == "/") { res->setStatusCode(HttpResponse::HTTP_OK); res->setContentType(CONTEXT_TYPE_HTML); res->addHeader("Server", JOINTCOM_FLAG); char date[128] = {0}; get_now(date); res->setBody("<html><head><title>JOINTCOM</title></head>" "<body><h1>Welcom to JOINTCOM</h1>Now is " + std::string(date) + "</body></html>"); } else if (readUrlConfig(req->method(), req->path(), svr_info, smt_info) != -1) { if (req->method() == HTTP_GET || req->method() == HTTP_DELETE) { if(smt_info.param_count > 0) { //固定参数 //固定参数需匹配参数数量,不匹配时返回404 if(smt_info.param_count != req->query_param().size()) { res->setHttp404Status("Query-Param error!"); return; } auto it = req->query_param().begin(); for (int i = 0; i < smt_info.param_count; i++) { auto n = smt_info.sql.find_first_of('?'); if (n != std::string::npos) { smt_info.sql.replace(n, 1, it->first); it++; } } } else if (smt_info.param_count == 0 && req->query_param().size() > 0) { //自由参数 auto it = req->query_param().begin(); std::string temp = " where "; for (int i = 0; i < req->query_param().size(); i++) { temp += "["; temp += it->first; temp += "] = '"; temp += it->second; temp += "'"; if (i != req->query_param().size() - 1) { temp += " and "; it++; } } smt_info.sql += temp; } else if(smt_info.param_count == 0 && req->query_param().size() == 0 && req->method() == HTTP_DELETE) { //删除方法的参数不允许参数为0, 返回404 res->setHttp404Status("Delete-Param error!"); return; } } else if(req->method() == HTTP_POST) { std::string body = req->body(); std::string sql = ""; std::vector<std::string> vec = split_string(body, "\n"); for(auto it = vec.begin(); it != vec.end(); it++) { std::string val = *it; if(val == "") continue; std::string temp = smt_info.sql; auto n = temp.find_first_of('?'); if (n != std::string::npos) temp.replace(n, 1, val.c_str()); else { res->setHttp404Status("Config-Sql error!"); return; } sql += temp + "\n"; } smt_info.sql = sql; } std::string content_type(CONTEXT_TYPE_PLAIN); int ret = db_odbc_exec(svr_info, smt_info, &content, content_type); if (ret == -1) { res->setHttp404Status(content.buffer()); return; } res->setStatusCode(HttpResponse::HTTP_OK); res->setContentType(content_type); res->addHeader("Server", JOINTCOM_FLAG); res->setBody(content.buffer()); } else { res->setHttp404Status(); } }
void log_event_now(const char *log_name, const char *event) { log_event(log_name, get_now(), event); }
TimeSpan SystemTimeSource::GetNow () { return get_now (); }
int ndpi_add_to_lru_cache_str_timeout(struct ndpi_LruCache *cache, char *key, char *value, u_int32_t timeout) { if(cache->hash_size == 0) return(0); else { u_int32_t hash_val = lru_hash_string(key); u_int32_t hash_id = hash_val % cache->hash_size; struct ndpi_LruCacheEntry *node; u_int8_t node_already_existing = 0; int rc = 0; if(unlikely(traceLRU)) printf("%s(key=%s, value=%s)", __FUNCTION__, key, value); // validate_unit_len(cache, hash_id); cache->num_cache_add++; /* [1] Add to hash */ if(cache->hash[hash_id] == NULL) { if((node = lru_allocCacheStringNode(cache, key, value, timeout)) == NULL) { rc = -1; goto ret_add_to_lru_cache; } cache->hash[hash_id] = node; cache->current_hash_size[hash_id]++; } else { /* Check if the element exists */ struct ndpi_LruCacheEntry *head = cache->hash[hash_id]; while(head != NULL) { if(strcmp(head->u.str.key, key) == 0) { /* Duplicated key found */ node = head; if(node->u.str.value) { #ifdef FULL_STATS cache->mem_size -= strlen(node->u.str.value); #endif ndpi_free(node->u.str.value); } node->u.str.value = ndpi_strdup(value); /* Overwrite old value */ #ifdef FULL_STATS cache->mem_size += strlen(value); #endif node->u.str.expire_time = (timeout == 0) ? 0 : (compute_timeout(timeout) + get_now()); node_already_existing = 1; break; } else head = head->next; } if(!node_already_existing) { if((node = lru_allocCacheStringNode(cache, key, value, timeout)) == NULL) { rc = -2; goto ret_add_to_lru_cache; } node->next = cache->hash[hash_id]; cache->hash[hash_id] = node; cache->current_hash_size[hash_id]++; } } trim_subhash(cache, hash_id); // validate_unit_len(cache, hash_id); ret_add_to_lru_cache: return(rc); } }
/*! \brief Handle connection coming data and timeout of timers. * */ static void _cons_supp_event_loop(mb_rt_t *rt) { struct _cons_supp_runtime *cmb_rt = (struct _cons_supp_runtime *)rt; struct _cons_supp_IO_man *io_man = (struct _cons_supp_IO_man *)cmb_rt->io_man; mb_timer_man_t *timer_man = (mb_timer_man_t *)cmb_rt->timer_man; redraw_man_t *rdman; mb_tman_t *tman = tman_timer_man_get_tman(timer_man); mb_timeval_t now, tmo; struct timeval tv; fd_set rfds, wfds; int nfds = 0; int r, r1,i; rdman = mb_runtime_rdman(rt); rdman_redraw_all(rdman); _cons_supp_handle_cons_event(cmb_rt); while(1) { FD_ZERO(&rfds); FD_ZERO(&wfds); for(i = 0; i < io_man->n_monitor; i++) { if(io_man->monitors[i].type == MB_IO_R || io_man->monitors[i].type == MB_IO_RW) { FD_SET(io_man->monitors[i].fd, &rfds); nfds = MB_MAX(nfds, io_man->monitors[i].fd + 1); } if(io_man->monitors[i].type == MB_IO_W || io_man->monitors[i].type == MB_IO_RW) { FD_SET(io_man->monitors[i].fd, &wfds); nfds = MB_MAX(nfds, io_man->monitors[i].fd + 1); } } get_now(&now); r = mb_tman_next_timeout(tman, &now, &tmo); if(r == 0) { tv.tv_sec = MB_TIMEVAL_SEC(&tmo); tv.tv_usec = MB_TIMEVAL_USEC(&tmo); r1 = select(nfds, &rfds, NULL, NULL, &tv); } else r1 = select(nfds, &rfds, NULL, NULL, NULL); if(r1 == -1) { perror("select"); break; } if(r1 == 0) { get_now(&now); mb_tman_handle_timeout(tman, &now); rdman_redraw_changed(rdman); } else { for(i = 0; i < io_man->n_monitor; i++) { if(io_man->monitors[i].type == MB_IO_R || io_man->monitors[i].type == MB_IO_RW) { if(FD_ISSET(io_man->monitors[i].fd, &rfds)) io_man->monitors[i].cb(i, io_man->monitors[i].fd, MB_IO_R, io_man->monitors[i].data); } if(io_man->monitors[i].type == MB_IO_W || io_man->monitors[i].type == MB_IO_RW) { if(FD_ISSET(io_man->monitors[i].fd, &wfds)) io_man->monitors[i].cb(i, io_man->monitors[i].fd, MB_IO_W, io_man->monitors[i].data); } } } } }
int main(int argc, char **argv) { char *username = NULL; int rc; char buf[BUFSIZE]; int nRead, nWrite; time_t now; pthread_attr_t *tha = NULL; pthread_t tid; char *m_cmd = strrchr(argv[0], '/'); if(m_cmd == NULL) { m_cmd = argv[0]; } else { m_cmd++; } while(argc >= 1) { if(strcmp(*argv,"-o") == 0) { if (--argc >= 1) { m_file_name = *(++argv); } } else if(strcmp(*argv,"-u") == 0) { if (--argc >= 1) { username = *(++argv); } } else if(strcmp(*argv,"-s") == 0) { if (--argc >= 1) { m_tRotation = atoi(*(++argv)); } } else if(strcmp(*argv,"-t") == 0) { if (--argc >= 1) { m_offset = atoi(*(++argv)); m_offset = m_offset * 3600; m_offset_enabled = 1; } } else if(strcmp(*argv,"-g") == 0) { if (--argc >= 1) { m_generations = atoi(*(++argv)); } } else if(strcmp(*argv,"-b") == 0) { if (--argc >= 1) { m_limit = atoi(*(++argv)); } } else if(strcmp(*argv,"-z") == 0) { m_compress = 1; } else if(strcmp(*argv,"-p") == 0) { m_stdout = 1; } else if(strcmp(*argv,"-f") == 0) { m_force_rotation = 1; } else if(strcmp(*argv,"-h") == 0) { usage(m_cmd, 0); } else if(strcmp(*argv,"--help") == 0) { usage(m_cmd, 0); } else if(strcmp(*argv,"-?") == 0) { usage(m_cmd, 0); } else if(strcmp(*argv,"--man") == 0) { usage(m_cmd, 1); } argc--; argv++; } if(m_file_name == NULL) usage(m_cmd, 0); if(m_limit < (1024 * 1024)) usage(m_cmd, 0); if(username && getuid() == 0) { struct passwd *pwd = getpwnam(username); uid_t uid, gid; if(pwd == NULL) { fprintf(stderr,"[%s]: ERROR, unknown user id %s\n", m_cmd, username); exit(1); } uid = pwd->pw_uid; gid = pwd->pw_gid; setgid(gid); setuid(uid); if(getuid() != uid) { fprintf(stderr,"[%s]: ERROR, setuid failed (%s,%d)\n", m_cmd, username, uid); exit(1); } if(getgid() != gid) { fprintf(stderr,"[%s]: ERROR, setgid failed (%d)\n", m_cmd, gid); exit(1); } } /* set next rotation time */ now = get_now(); m_tLogEnd = ((now / m_tRotation) * m_tRotation) + m_tRotation; /* open file */ m_nLogFD = openFile(m_cmd, m_file_name); if(m_nLogFD < 0) { /* startup did not success */ exit(2); } if(m_force_rotation) { qs_csInitLock(); pthread_create(&tid, tha, forcedRotationThread, NULL); } for(;;) { nRead = read(0, buf, sizeof buf); if(nRead == 0) exit(3); if(nRead < 0) if(errno != EINTR) exit(4); if(m_force_rotation) { qs_csLock(); } m_counter += nRead; now = get_now(); /* write data if we have a file handle (else continue but drop log data, re-try to open the file at next rotation time) */ if(m_nLogFD >= 0) { do { nWrite = write(m_nLogFD, buf, nRead); if(m_stdout) { printf("%.*s", nRead, buf); } } while (nWrite < 0 && errno == EINTR); } if(nWrite != nRead) { m_messages++; if(m_nLogFD >= 0) { char msg[HUGE_STR]; snprintf(msg, sizeof(msg), "ERROR while writing to file, %ld messages lost\n", m_messages); /* error while writing data, try to delete the old file and continue ... */ rc = ftruncate(m_nLogFD, 0); rc = write(m_nLogFD, msg, strlen(msg)); } } else { m_messages++; } if((now > m_tLogEnd) || (m_counter > m_limit)) { /* rotate! */ rotate(m_cmd, now, m_file_name, &m_messages); } if(m_force_rotation) { qs_csUnLock(); } } return 0; }
int main(int argc, char **argv){ unsigned int i; char * ptr; unsigned int numthreads; global_data * global = new global_data; global->stats.starttime = get_now(); //2 queues global->request = new tqueue<request_t>(); global->response = new tqueue<request_t>(); //thread stuff pthread_t thread[MAX_THREADS]; thread_data_t threaddata[MAX_THREADS]; //http server stuff struct evhttp *http; struct event updateEvent; //notification fds int fds[2]; srand(time(NULL)); //defaults char port_def[] = "80"; char hostname_def[] = "0.0.0.0"; char threads_def[] = "3"; char static_source_def[] = "pentagoo/"; //Argument Pointers char *port_arg = port_def; char *hostname_arg = hostname_def; char *threads_arg = threads_def; char *static_source = static_source_def; //Parse command line options for (i = 1; i < (unsigned int)argc; i++) { ptr = argv[i]; if(strcmp(ptr, "--help") == 0){ printf("Usage:\n" "\t--help Show this help\n" "\t-l Location for the web frontend [%s]\n" "\t-p Port Number [%s]\n" "\t-h Hostname [%s]\n" "\t-t Number of threads [%s]\n\n", static_source_def, port_def, hostname_def, threads_def); exit(255); }else if (strcmp(ptr, "-p") == 0) port_arg = ptr = argv[++i]; else if (strcmp(ptr, "-h") == 0) hostname_arg = ptr = argv[++i]; else if (strcmp(ptr, "-t") == 0) threads_arg = ptr = argv[++i]; else if (strcmp(ptr, "-l") == 0) static_source = ptr = argv[++i]; } global->static_source = static_source; numthreads = atoi(threads_arg); if(numthreads < 1) numthreads = 1; if(numthreads > MAX_THREADS){ printf("Invalid number of threads '%s', setting to max threads %i\n", threads_arg, MAX_THREADS); numthreads = MAX_THREADS; } //initialize update notification pipe socketpair(AF_UNIX, SOCK_STREAM, 0, fds); global->pushfd = fds[0]; global->popfd = fds[1]; printf("Starting %u computation threads\n", numthreads); for(i = 0; i < numthreads; i++){ threaddata[i].threadid = i; threaddata[i].state = 1; threaddata[i].global = global; pthread_create(&thread[i], NULL, (void* (*)(void*)) requestRunner, (void*) &threaddata[i]); } //init the event lib event_init(); printf("Listening on %s:%s\n", hostname_arg, port_arg); //start the http server http = evhttp_start(hostname_arg, atoi(port_arg)); if(http == NULL) { printf("Couldn't start server on %s:%s\n", hostname_arg, port_arg); return 1; } //Register a callback for requests evhttp_set_gencb(http, handle_http_static, global); //the generic catch all callback, used to serve static files evhttp_set_cb(http, "/ai", handle_request_ai, global); //my nice url evhttp_set_cb(http, "/pentagoo_ai.php", handle_request_ai, global); //hijack the pentagoo url evhttp_set_cb(http, "/stats", handle_request_stats, global); event_set(& updateEvent, global->popfd, EV_READ|EV_PERSIST, handle_queue_response, global); event_add(& updateEvent, 0); printf("Starting event loop\n"); event_dispatch(); printf("Exiting\n"); global->request->nonblock(); for(i = 0; i < numthreads; i++) pthread_join(thread[i], NULL); return 0; }
#include <unistd.h> #include <assert.h> #include <sys/time.h> volatile unsigned int AmSession::session_num = 0; AmMutex AmSession::session_num_mut; volatile unsigned int AmSession::max_session_num = 0; volatile unsigned long long AmSession::avg_session_num = 0; struct timeval get_now() { struct timeval res; gettimeofday(&res, NULL); return res; } struct timeval avg_last_timestamp = get_now(); struct timeval avg_first_timestamp = avg_last_timestamp; // AmSession methods AmSession::AmSession(AmSipDialog* p_dlg) : AmEventQueue(this), dlg(p_dlg), input(NULL), output(NULL), sess_stopped(false), m_dtmfDetector(this), m_dtmfEventQueue(&m_dtmfDetector), m_dtmfDetectionEnabled(true), accept_early_session(false), rtp_interface(-1), refresh_method(REFRESH_UPDATE_FB_REINV), processing_status(SESSION_PROCESSING_EVENTS) #ifdef WITH_ZRTP
int main( int argc, char *argv[] ) { PGconn *conn; const char *value; bool integer_datetimes; PGresult *res; uint64_t tmp; uint64_t param1; const char *values[1] = { (const char *)¶m1 }; int lengths[1] = { sizeof( param1 ) }; int binary[1] = { 1 }; struct timespec now; if( argc != 2 ) { fprintf( stderr, "usage: testpgsql <Pg conn info>\n" ); return 1; } conn = PQconnectdb( argv[1] ); if( PQstatus( conn ) != CONNECTION_OK ) { fprintf( stderr, "Connection to database failed: %s", PQerrorMessage( conn ) ); PQfinish( conn ); return 1; } value = PQparameterStatus( conn, "integer_datetimes" ); if( value == NULL ) { fprintf( stderr, "PQ param integer_datetimes empty?\n" ); PQfinish( conn ); return 1; } integer_datetimes = strcmp( value, "on" ) == 0 ? true : false; printf( "integer_datetimes: %s\n", integer_datetimes ? "true" : "false" ); now = get_now( ); tmp = ( (uint64_t)now.tv_sec - POSTGRES_EPOCH_DATE ) * 1000000; tmp += now.tv_nsec / 1000; param1 = htobe64( tmp ); res = PQexecParams( conn, "SELECT now(),$1::timestamp", 1, NULL, values, lengths, binary, 1 ); if( PQresultStatus( res ) != PGRES_TUPLES_OK ) { fprintf( stderr, "select error: %s\n", PQerrorMessage( conn ) ); PQclear( res ); PQfinish( conn ); return 1; } if( PQntuples( res ) == 0 ) { PQclear( res ); PQfinish( conn ); return 1; } if( PQntuples( res ) > 1 ) { fprintf( stderr, "Expecting exactly one tuple as result." ); PQclear( res ); PQfinish( conn ); return 1; } /* Since PostgreSQL 8.4 int64 representation should be the default * unless changed at compilation time */ if( integer_datetimes ) { char *data_db; char *data_select; struct timespec time_db; struct timespec time_select; uint64_t t_db; uint64_t t_select; data_db = PQgetvalue( res, 0, 0 ); t_db = be64toh( *( (uint64_t *)data_db ) ); time_db.tv_sec = POSTGRES_EPOCH_DATE + t_db / 1000000; time_db.tv_nsec = ( t_db % 1000000 ) * 1000; data_select = PQgetvalue( res, 0, 1 ); t_select = be64toh( *( (uint64_t *)data_select ) ); time_select.tv_sec = POSTGRES_EPOCH_DATE + t_select / 1000000; time_select.tv_nsec = ( t_select % 1000000 ) * 1000; now = get_now( ); printf( "now passed as param: %lu.%lu, now from database: %lu.%lu, now computed: %lu.%lu\n", time_select.tv_sec, time_select.tv_nsec, time_db.tv_sec, time_db.tv_nsec, now.tv_sec, now.tv_nsec ); } else { /* doubles have no standard network representation! */ fprintf( stderr, "Not supporting dates as doubles!\n" ); PQclear( res ); PQfinish( conn ); return 1; } value = PQparameterStatus( conn, "client_encoding" ); if( value == NULL ) { fprintf( stderr, "PQ param client_encoding empty?\n" ); PQfinish( conn ); return 1; } printf( "integer_datetimes: %s\n", value ); PQfinish( conn ); return 0; }