/** * ido_location_menu_item_set_timezone: * @timezone: timezone identifier (eg: "America/Chicago") * * Set this location's timezone. This will be used to show the location's * current time in menuitem's right-justified secondary label. */ void ido_location_menu_item_set_timezone (IdoLocationMenuItem * self, const char * timezone) { priv_t * p; g_return_if_fail (IDO_IS_LOCATION_MENU_ITEM (self)); p = self->priv; g_free (p->timezone); p->timezone = g_strdup (timezone); update_timestamp (self); }
/** * gst_adapter_flush: * @adapter: a #GstAdapter * @flush: the number of bytes to flush * * Flushes the first @flush bytes in the @adapter. The caller must ensure that * at least this many bytes are available. * * See also: gst_adapter_peek(). */ static void gst_adapter_flush_unchecked (GstAdapter * adapter, guint flush) { GstBuffer *cur; guint size; GstAdapterPrivate *priv; GSList *g; GST_LOG_OBJECT (adapter, "flushing %u bytes", flush); priv = adapter->priv; /* clear state */ adapter->size -= flush; adapter->assembled_len = 0; /* take skip into account */ flush += adapter->skip; /* distance is always at least the amount of skipped bytes */ priv->distance -= adapter->skip; g = adapter->buflist; cur = g->data; size = GST_BUFFER_SIZE (cur); while (flush >= size) { /* can skip whole buffer */ GST_LOG_OBJECT (adapter, "flushing out head buffer"); priv->distance += size; flush -= size; gst_buffer_unref (cur); g = g_slist_delete_link (g, g); if (G_UNLIKELY (g == NULL)) { GST_LOG_OBJECT (adapter, "adapter empty now"); adapter->buflist_end = NULL; break; } /* there is a new head buffer, update the timestamp */ cur = g->data; update_timestamp (adapter, cur); size = GST_BUFFER_SIZE (cur); } adapter->buflist = g; /* account for the remaining bytes */ adapter->skip = flush; adapter->priv->distance += flush; /* invalidate scan position */ priv->scan_offset = 0; priv->scan_entry = NULL; }
void recoder::add_enc_packet(const uint8_t *data, const uint16_t len) { size_t tmp_rank; guard g(m_lock); /* don't add packets when we have enough, and try to stop encoder * from sending more packets */ if (this->is_complete()) { send_ack_packet(); return; } if (curr_state() == STATE_DONE) return; CHECK_EQ(len, this->payload_size()) << "Recoder " << m_coder << ": Encoded data is too short:" << len << " < " << this->payload_size(); /* keep track of changes in rank */ tmp_rank = this->rank(); this->decode(const_cast<uint8_t *>(data)); /* check if rank improved */ if (this->rank() == tmp_rank) inc("non-innovative recoded packets"); update_timestamp(); if (this->last_symbol_is_systematic()) { inc("systematic packets added"); send_systematic_packet(data, len); m_budget--; } else { inc("encoded packets added"); } /* signal state machine if generation is complete */ if (this->is_complete()) { send_ack_packet(); dispatch_event(EVENT_COMPLETE); } else { dispatch_event(EVENT_RX); } VLOG(LOG_PKT) << "Recoder " << m_coder << ": Added encoded packet"; }
static void revoke_eviction(UINT32 const page_idx) { ASSERT(cached_pmt_timestamps[page_idx] == EVICTED_TIMESTAMP); ASSERT(merge_buf_size > 0); // find the evicted page in merge buf UINT8 sp_i; for (sp_i = 0; sp_i < merge_buf_size; sp_i++) if (merged_page_idxes[sp_i] == page_idx) break; ASSERT(sp_i != merge_buf_size); // remove the evicted page from merge buf merge_buf_size--; merged_page_idxes[sp_i] = merged_page_idxes[merge_buf_size]; // change timestamp to normal update_timestamp(page_idx); }
/* execute rundll32 on the wine.inf file if necessary */ static void update_wineprefix( int force ) { const char *config_dir = wine_get_config_dir(); char *inf_path = get_wine_inf_path(); int fd; struct stat st; if (!inf_path) { WINE_MESSAGE( "wine: failed to update %s, wine.inf not found\n", config_dir ); return; } if ((fd = open( inf_path, O_RDONLY )) == -1) { WINE_MESSAGE( "wine: failed to update %s with %s: %s\n", config_dir, inf_path, strerror(errno) ); goto done; } fstat( fd, &st ); close( fd ); if (update_timestamp( config_dir, st.st_mtime ) || force) { HANDLE process; DWORD count = 0; if ((process = start_rundll32( inf_path, FALSE ))) { HWND hwnd = show_wait_window(); for (;;) { MSG msg; DWORD res = MsgWaitForMultipleObjects( 1, &process, FALSE, INFINITE, QS_ALLINPUT ); if (res == WAIT_OBJECT_0) { CloseHandle( process ); if (count++ || !(process = start_rundll32( inf_path, TRUE ))) break; } else while (PeekMessageW( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageW( &msg ); } DestroyWindow( hwnd ); } WINE_MESSAGE( "wine: configuration in '%s' has been updated.\n", config_dir ); } done: HeapFree( GetProcessHeap(), 0, inf_path ); }
/* * Returns true if the user successfully authenticates, false if not * or -1 on error. */ static int check_user_interactive(int validated, int mode, struct passwd *auth_pw) { int status, rval = true; debug_decl(check_user_interactive, SUDO_DEBUG_AUTH) /* Always need a password when -k was specified with the command. */ if (ISSET(mode, MODE_IGNORE_TICKET)) SET(validated, FLAG_CHECK_USER); if (build_timestamp(auth_pw) == -1) { rval = -1; goto done; } status = timestamp_status(auth_pw); if (status != TS_CURRENT || ISSET(validated, FLAG_CHECK_USER)) { char *prompt; bool lectured; /* Bail out if we are non-interactive and a password is required */ if (ISSET(mode, MODE_NONINTERACTIVE)) { validated |= FLAG_NON_INTERACTIVE; log_auth_failure(validated, 0); rval = -1; goto done; } /* XXX - should not lecture if askpass helper is being used. */ lectured = display_lecture(status); /* Expand any escapes in the prompt. */ prompt = expand_prompt(user_prompt ? user_prompt : def_passprompt, auth_pw->pw_name); rval = verify_user(auth_pw, prompt, validated); if (rval == true && lectured) set_lectured(); efree(prompt); } /* Only update timestamp if user was validated. */ if (rval == true && ISSET(validated, VALIDATE_OK) && !ISSET(mode, MODE_IGNORE_TICKET) && status != TS_ERROR) update_timestamp(auth_pw); done: debug_return_bool(rval); }
static UINT32 get_page(UINT32 const pmt_idx) { ASSERT(pmt_idx < PMT_SUB_PAGES); /* shortcuts for consecutive access of the same pmt_idx */ if (last_pmt_idx == pmt_idx) return last_page_idx; UINT32 page_idx = mem_search_equ_sram(cached_pmt_idxes, sizeof(UINT32), NUM_PC_SUB_PAGES, pmt_idx); if (page_idx >= NUM_PC_SUB_PAGES) return NULL_PAGE_IDX; last_pmt_idx = pmt_idx; last_page_idx = page_idx; UINT32 timestamp = cached_pmt_timestamps[page_idx]; if (timestamp == EVICTED_TIMESTAMP) revoke_eviction(page_idx); else if (timestamp < NULL_TIMESTAMP) update_timestamp(page_idx); return page_idx; }
/** * gst_adapter_push: * @adapter: a #GstAdapter * @buf: a #GstBuffer to add to queue in the adapter * * Adds the data from @buf to the data stored inside @adapter and takes * ownership of the buffer. */ void gst_adapter_push (GstAdapter * adapter, GstBuffer * buf) { guint size; g_return_if_fail (GST_IS_ADAPTER (adapter)); g_return_if_fail (GST_IS_BUFFER (buf)); size = GST_BUFFER_SIZE (buf); adapter->size += size; /* Note: merging buffers at this point is premature. */ if (G_UNLIKELY (adapter->buflist == NULL)) { GST_LOG_OBJECT (adapter, "pushing first %u bytes", size); adapter->buflist = adapter->buflist_end = g_slist_append (NULL, buf); update_timestamp (adapter, buf); } else { /* Otherwise append to the end, and advance our end pointer */ GST_LOG_OBJECT (adapter, "pushing %u bytes at end, size now %u", size, adapter->size); adapter->buflist_end = g_slist_append (adapter->buflist_end, buf); adapter->buflist_end = g_slist_next (adapter->buflist_end); } }
void encoder::add_plain_packet(const uint8_t *data, const uint16_t len) { uint8_t *buf; size_t size = this->symbol_size(); CHECK_LE(len, size - LEN_SIZE) << "Encoder " << m_coder << ": Plain packet is too long: " << len << " > " << size - LEN_SIZE; guard g(m_lock); /* make sure encoder is in a state to accept plain packets */ if (curr_state() != STATE_WAIT) return; buf = get_symbol_buffer(m_plain_pkt_count); *reinterpret_cast<uint16_t *>(buf) = len; memcpy(buf + LEN_SIZE, data, len); /* Copy data into encoder storage */ sak::mutable_storage symbol(buf, this->symbol_size()); this->set_symbol(m_plain_pkt_count++, symbol); update_timestamp(); inc("plain packets added"); VLOG(LOG_PKT) << "Encoder " << m_coder << ": Added plain packet"; if (is_full()) { inc("generations"); dispatch_event(EVENT_FULL); } else if (this->rank() > FLAGS_encoder_threshold*this->symbols() && semaphore_count() > 0) { m_budget += recoder_credit(m_e1, m_e2, m_e3); send_encoded_credit(); } }
/* * Returns true if the user successfully authenticates, false if not * or -1 on error. */ int check_user(int validated, int mode) { struct passwd *auth_pw; char *timestampdir = NULL; char *timestampfile = NULL; char *prompt; struct stat sb; int status, rval = true; debug_decl(check_user, SUDO_DEBUG_AUTH) /* * Init authentication system regardless of whether we need a password. * Required for proper PAM session support. */ auth_pw = get_authpw(); if (sudo_auth_init(auth_pw) == -1) { rval = -1; goto done; } /* * Don't prompt for the root passwd or if the user is exempt. * If the user is not changing uid/gid, no need for a password. */ if (!def_authenticate || user_uid == 0 || user_is_exempt()) goto done; if (user_uid == runas_pw->pw_uid && (!runas_gr || user_in_group(sudo_user.pw, runas_gr->gr_name))) { #ifdef HAVE_SELINUX if (user_role == NULL && user_type == NULL) #endif #ifdef HAVE_PRIV_SET if (runas_privs == NULL && runas_limitprivs == NULL) #endif goto done; } /* Always need a password when -k was specified with the command. */ if (ISSET(mode, MODE_IGNORE_TICKET)) SET(validated, FLAG_CHECK_USER); /* Stash the tty's ctime for tty ticket comparison. */ if (def_tty_tickets && user_ttypath && stat(user_ttypath, &sb) == 0) { tty_info.dev = sb.st_dev; tty_info.ino = sb.st_ino; tty_info.rdev = sb.st_rdev; if (tty_is_devpts(user_ttypath)) ctim_get(&sb, &tty_info.ctime); } if (build_timestamp(×tampdir, ×tampfile) == -1) { rval = -1; goto done; } status = timestamp_status(timestampdir, timestampfile, user_name, TS_MAKE_DIRS); if (status != TS_CURRENT || ISSET(validated, FLAG_CHECK_USER)) { /* Bail out if we are non-interactive and a password is required */ if (ISSET(mode, MODE_NONINTERACTIVE)) { validated |= FLAG_NON_INTERACTIVE; log_auth_failure(validated, 0); rval = -1; goto done; } /* XXX - should not lecture if askpass helper is being used. */ lecture(status); /* Expand any escapes in the prompt. */ prompt = expand_prompt(user_prompt ? user_prompt : def_passprompt, user_name, user_shost); rval = verify_user(auth_pw, prompt, validated); } /* Only update timestamp if user was validated. */ if (rval == true && ISSET(validated, VALIDATE_OK) && !ISSET(mode, MODE_IGNORE_TICKET) && status != TS_ERROR) update_timestamp(timestampdir, timestampfile); efree(timestampdir); efree(timestampfile); done: sudo_auth_cleanup(auth_pw); sudo_pw_delref(auth_pw); debug_return_bool(rval); }
int main(int argc, char *argv[]) { unsigned long sleep_time; double read_interval; start_time = time(0); memset(&rtiming, 0, sizeof(rtiming)); rtiming.rt_variance.v_min = FLT_MAX; /* * Early initialization before reading config */ conf_init_pre(); parse_args_pre(argc, argv); /* * Reading the configuration file */ configfile_read(); /* * Late initialization after reading config */ if (parse_args_post(argc, argv)) return 1; conf_init_post(); module_init(); read_interval = cfg_read_interval; sleep_time = cfg_getint(cfg, "sleep_time"); if (((double) sleep_time / 1000000.0f) > read_interval) sleep_time = (unsigned long) (read_interval * 1000000.0f); DBG("Entering mainloop..."); do { /* * E := Elapsed time * NR := Next Read * LR := Last Read * RI := Read Interval * ST := Sleep Time * C := Correction */ timestamp_t e, ri, tmp; unsigned long st; float_to_timestamp(&ri, read_interval); /* * NR := NOW */ update_timestamp(&rtiming.rt_next_read); for (;;) { output_pre(); /* * E := NOW */ update_timestamp(&e); /* * IF NR <= E THEN */ if (timestamp_le(&rtiming.rt_next_read, &e)) { timestamp_t c; /* * C := (NR - E) */ timestamp_sub(&c, &rtiming.rt_next_read, &e); //calc_variance(&c, &ri); /* * LR := E */ copy_timestamp(&rtiming.rt_last_read, &e); /* * NR := E + RI + C */ timestamp_add(&rtiming.rt_next_read, &e, &ri); timestamp_add(&rtiming.rt_next_read, &rtiming.rt_next_read, &c); reset_update_flags(); input_read(); free_unused_elements(); output_draw(); output_post(); } if (do_quit) exit(0); /* * ST := Configured ST */ st = sleep_time; /* * IF (NR - E) < ST THEN */ timestamp_sub(&tmp, &rtiming.rt_next_read, &e); if (tmp.tv_sec < 0) continue; if (tmp.tv_sec == 0 && tmp.tv_usec < st) { if (tmp.tv_usec < 0) continue; /* * ST := (NR - E) */ st = tmp.tv_usec; } /* * SLEEP(ST) */ usleep(st); } } while (0); return 0; /* buddha says i'll never be reached */ }
static bool process_packet(tc_user_t *u, unsigned char *frame) { bool result; uint16_t size_ip, size_tcp, tot_len, cont_len; uint32_t h_ack, h_last_ack; tc_ip_header_t *ip_header; tc_tcp_header_t *tcp_header; ip_port_pair_mapping_t *test; ip_header = (tc_ip_header_t *) (frame + ETHERNET_HDR_LEN); size_ip = ip_header->ihl << 2; tcp_header = (tc_tcp_header_t *) ((char *) ip_header + size_ip); size_tcp = tcp_header->doff << 2; tot_len = ntohs(ip_header->tot_len); cont_len = tot_len - size_tcp - size_ip; if (u->dst_port == 0) { test = get_test_pair(&(clt_settings.transfer), ip_header->daddr, tcp_header->dest); if (test == NULL) { tc_log_info(LOG_NOTICE, 0, " test null:%u", ntohs(tcp_header->dest)); tc_log_trace(LOG_WARN, 0, TO_BAKEND_FLAG, ip_header, tcp_header); return false; } u->dst_addr = test->target_ip; u->dst_port = test->target_port; #if (GRYPHON_PCAP_SEND) u->src_mac = test->src_mac; u->dst_mac = test->dst_mac; #endif } if (u->state.last_ack_recorded) { if (u->state.status < SEND_REQ && (u->state.status & SYN_CONFIRM)) { h_ack = ntohl(tcp_header->ack_seq); h_last_ack = ntohl(u->history_last_ack_seq); if (after(h_ack, h_last_ack)) { tc_log_debug1(LOG_DEBUG, 0, "server resp first, wait, p:%u", ntohs(u->src_port)); u->state.resp_waiting = 1; return false; } } } ip_header->saddr = u->src_addr; tcp_header->source = u->src_port; u->history_last_ack_seq = tcp_header->ack_seq; u->state.last_ack_recorded = 1; tcp_header->ack_seq = u->exp_ack_seq; ip_header->daddr = u->dst_addr; tcp_header->dest = u->dst_port; tc_log_debug2(LOG_DEBUG, 0, "set ack seq:%u, p:%u", ntohl(u->exp_ack_seq), ntohs(u->src_port)); packs_sent_cnt++; if (tcp_header->syn) { syn_sent_cnt++; #if (!GRYPHON_SINGLE) if (!send_router_info(u, CLIENT_ADD)) { return false; } #endif u->state.last_ack_recorded = 0; u->state.status |= SYN_SENT; } else if (tcp_header->fin) { fin_sent_cnt++; u->state.status |= CLIENT_FIN; } else if (tcp_header->rst) { rst_sent_cnt++; u->state.status |= CLIENT_FIN; tc_log_debug1(LOG_DEBUG, 0, "a reset packet to back:%u", ntohs(u->src_port)); } if (cont_len > 0) { cont_sent_cnt++; u->state.status |= SEND_REQ; } if (u->state.timestamped) { update_timestamp(u, tcp_header); } tcp_header->check = 0; tcp_header->check = tcpcsum((unsigned char *) ip_header, (unsigned short *) tcp_header, (int) (tot_len - size_ip)); #if (GRYPHON_PCAP_SEND) ip_header->check = 0; ip_header->check = csum((unsigned short *) ip_header,size_ip); #endif tc_log_debug_trace(LOG_DEBUG, 0, TO_BAKEND_FLAG, ip_header, tcp_header); #if (!GRYPHON_PCAP_SEND) result = tc_raw_socket_send(tc_raw_socket_out, ip_header, tot_len, ip_header->daddr); #else fill_frame((struct ethernet_hdr *) frame, u->src_mac, u->dst_mac); result = tc_pcap_send(frame, tot_len + ETHERNET_HDR_LEN); #endif if (result == TC_OK) { u->last_sent_time = tc_time(); return true; } else { tc_log_info(LOG_ERR, 0, "send to back error,tot_len is:%d,cont_len:%d", tot_len,cont_len); #if (!TCPCOPY_PCAP_SEND) tc_raw_socket_out = TC_INVALID_SOCKET; #endif tc_over = SIGRTMAX; return false; } }
timer::timer(std::string name, time_callback callback, int interval, bool repeat, unsigned long timestamp):name_(name), callback_(callback), repeat_(repeat), update_(false) { set_interval(interval); set_timestamp(timestamp); update_timestamp(); }
int main(int argc, char *argv[]) { unsigned long sleep_time; double read_interval; start_time = time(0); parse_args_pre(argc, argv); configfile_read(); parse_args_post(argc, argv); conf_init(); module_init(); read_interval = cfg_read_interval; sleep_time = cfg_getint(cfg, "sleep_time"); if (((double) sleep_time / 1000000.0f) > read_interval) sleep_time = (unsigned long) (read_interval * 1000000.0f); // pipe_start(); if (cfg_getbool(cfg, "daemon")) { init_syslog(); daemonize(); write_pidfile(); } drop_privs(); do { /* * E := Elapsed time * NR := Next Read * LR := Last Read * RI := Read Interval * ST := Sleep Time * C := Correction */ timestamp_t e, ri, tmp; unsigned long st; float_to_timestamp(&ri, read_interval); /* * NR := NOW */ update_timestamp(&rtiming.rt_next_read); for (;;) { output_pre(); /* * read the chucka chucka pipe */ // pipe_handle(); /* * E := NOW */ update_timestamp(&e); /* * IF NR <= E THEN */ if (timestamp_le(&rtiming.rt_next_read, &e)) { timestamp_t c; /* * C := (NR - E) */ timestamp_sub(&c, &rtiming.rt_next_read, &e); //calc_variance(&c, &ri); /* * LR := E */ copy_timestamp(&rtiming.rt_last_read, &e); /* * NR := E + RI + C */ timestamp_add(&rtiming.rt_next_read, &e, &ri); timestamp_add(&rtiming.rt_next_read, &rtiming.rt_next_read, &c); reset_update_flags(); input_read(); free_unused_elements(); output_draw(); output_post(); } if (do_quit) exit(0); /* * ST := Configured ST */ st = sleep_time; /* * IF (NR - E) < ST THEN */ timestamp_sub(&tmp, &rtiming.rt_next_read, &e); if (tmp.tv_sec < 0) continue; if (tmp.tv_sec == 0 && tmp.tv_usec < st) { if (tmp.tv_usec < 0) continue; /* * ST := (NR - E) */ st = tmp.tv_usec; } /* * SLEEP(ST) */ usleep(st); } } while (0); return 0; /* buddha says i'll never be reached */ }
/* * serve - handle one HTTP request/response transaction */ void serve(int to_client_fd) { char buf[MAXLINE], method[MAXLINE], uri[MAXLINE], version[MAXLINE]; char filename[MAXLINE], hostname[MAXLINE]; char port[10]; rio_t rio_to_client; rio_t rio_to_server; int to_server_fd; /* Read request line and headers */ Rio_readinitb(&rio_to_client, to_client_fd); Rio_readlineb(&rio_to_client, buf, MAXLINE); sscanf(buf, "%s %s %s", method, uri, version); /* if not GET method, ignore it */ if (strcasecmp(method, "GET")) { return; } /* Parse URI from GET request */ parse_uri(uri, hostname, port, filename); // strange display error in csapp page if (strcasecmp(hostname, "csapp.cs.cmu.edu") == 0) { return; } sprintf(buf, "%s %s %s\r\n", "GET", filename, "HTTP/1.0"); /* search content in cache list */ struct cache_block* ptr = search_cache(head, uri); /* cache found, directly send to client */ if (ptr) { // add the number of existing threads reading add_reading_cnt(ptr); // send cache to client Rio_writen(to_client_fd, ptr->file, ptr->size); // subtract the number of existing threads reading sub_reading_cnt(ptr); // update timestamp and reorder LRU list update_timestamp(head, ptr); return; } /* cache not found, connect with server */ to_server_fd = Open_clientfd(hostname, port); Rio_readinitb(&rio_to_server, to_server_fd); // send request line: GET HTTP/1.0 Rio_writen(to_server_fd, buf, strlen(buf)); // send host to server sprintf(buf, "Host: %s\r\n", hostname); Rio_writen(to_server_fd, buf, strlen(buf)); /* read http headers from client and write to server */ Rio_readlineb(&rio_to_client, buf, MAXLINE); while (strncmp(buf, "\r\n", MAXLINE) != 0) { if (strstr(buf, "User-Agent")) strncpy(buf, user_agent_hdr, MAXLINE); else if (strstr(buf, "Connection")) strncpy(buf, "Connection: close\r\n", MAXLINE); else if (strstr(buf, "Proxy-Connection")) strncpy(buf, "Proxy-Connection: close\r\n", MAXLINE); else if (strstr(buf, "Host")) { // ignore, because we already sent one Rio_readlineb(&rio_to_client, buf, MAXLINE); continue; } Rio_writen(to_server_fd, buf, strlen(buf)); Rio_readlineb(&rio_to_client, buf, MAXLINE); } /* terminates request headers */ Rio_writen(to_server_fd, "\r\n", 2); /* read http response from server and write to client */ memset(buf, 0, MAXLINE); Rio_readlineb(&rio_to_server, buf, MAXLINE); int content_len = 0; while (strncmp(buf, "\r\n", MAXLINE) != 0) { char* ptr = strstr(buf, "Content-length"); if (ptr) { content_len = atoi(ptr + 16); } //printf("write2: %s\n", uri); //printf("fd: %d\n", to_client_fd); //printf("%d: %s\n", strlen(buf), buf); Rio_writen(to_client_fd, buf, strlen(buf)); memset(buf, 0, MAXLINE); Rio_readlineb(&rio_to_server, buf, MAXLINE); } /* terminates response headers */ Rio_writen(to_client_fd, "\r\n", 2); int size = 0; int need_cache = 0; /* shall we cache it? */ if (content_len < MAX_OBJECT_SIZE) need_cache = 1; /* init a new cache block */ struct cache_block* blk = (struct cache_block*) malloc(sizeof(struct cache_block)); init_cache(blk); strncpy(blk->uri, uri, MAXLINE); if (content_len > 0) blk->file = (char*) malloc(sizeof(char) * content_len); else blk->file = (char*) malloc(sizeof(char) * MAX_OBJECT_SIZE); memset(buf, 0, MAXLINE); int total_size = 0; char* headptr = blk->file; /* read response contents and write to client */ while ((size = Rio_readnb(&rio_to_server, buf, MAXLINE)) > 0) { total_size += size; if (total_size > MAX_OBJECT_SIZE) need_cache = 0; if (need_cache) { memcpy(headptr, buf, size); headptr += size; } //printf("write3: %s\n", uri); Rio_writen(to_client_fd, buf, size); memset(buf, 0, MAXLINE); } /* add cache block */ if (need_cache) { blk->size = total_size; // resize block blk->file = (char*) realloc(blk->file, blk->size); // size overflow, need to evict using LRU if (blk->size + cache_size > MAX_CACHE_SIZE) evict_cache(head, blk->size); // add it add_cache(head, blk); } /* prevent memory leakage */ else { free_cache_node(blk); } Close(to_server_fd); return; }
void countdown_clock::update_team(int new_timestamp) { int time_passed = update_timestamp(new_timestamp); team_.set_countdown_time(std::max<int>(0, team_.countdown_time() - time_passed)); }
static uint32_t flv_merge_stream(FILE * in, FILE * out,uint64_t timestamp,uint32_t lastsize) { static char buf[65536000]; struct flvbodytag flvbodytag; int pos; flv_skip_header(in);//skip the header // skip to video content and start reading do{ fread(&flvbodytag,sizeof flvbodytag,1,in); fseek(in,UI24(flvbodytag.tag_data_size),SEEK_CUR); }while(flvbodytag.tag_type != 18); if( lastsize ){ fread(&flvbodytag,sizeof flvbodytag,1,in); fseek(in,UI24(flvbodytag.tag_data_size),SEEK_CUR); fread(&flvbodytag,sizeof flvbodytag,1,in); fseek(in,UI24(flvbodytag.tag_data_size),SEEK_CUR); pos = ftell(in); } //开始读咯 //还要步步更新 timestamp if( fread(&flvbodytag,sizeof flvbodytag,1,in) ==1 ) { flvbodytag.prv_tag_size = htonl(lastsize); // update timestamp update_timestamp(&flvbodytag,timestamp); // write tag fwrite(&flvbodytag,sizeof flvbodytag,1,out); // write tag data fread(buf, 1, UI24(flvbodytag.tag_data_size), in); fwrite(buf, 1, UI24(flvbodytag.tag_data_size), out); }else return 0; //开始读咯 //还要步步更新 timestamp while( fread(&flvbodytag,sizeof flvbodytag,1,in) ==1 ) { // update timestamp update_timestamp(&flvbodytag,timestamp); // write tag fwrite(&flvbodytag,sizeof flvbodytag,1,out); // write tag data fread(buf, 1, UI24(flvbodytag.tag_data_size), in); fwrite(buf, 1, UI24(flvbodytag.tag_data_size), out); } return ntohl(flvbodytag.prv_tag_size); }
void shuffle(peer_t *peers, uint16_t numpeers, char *coop) { peer_timestamp_t *list; int i; #ifdef DEBUG fprintf(stderr, "shuffle:coop %s\n", coop); #endif if ((list = (peer_timestamp_t *)malloc( numpeers * sizeof(peer_timestamp_t))) == NULL) { /* * if this fails, just do a random shuffle */ random_shuffle(peers, numpeers); /* * need to touch all the timestamps in the download timestamps * table */ return; } for (i = 0 ; i < numpeers ; ++i) { memcpy(&list[i].peer, &peers[i], sizeof(list[i].peer)); list[i].timestamp = lookup_timestamp(list[i].peer.ip, &list[i].coop); } if (numpeers > 1) { #ifdef DEBUG fprintf(stderr, "shuffle:before sort\n"); for (i = 0 ; i < numpeers ; ++i) { struct in_addr in; in.s_addr = list[i].peer.ip; fprintf(stderr, "\thost %s : state %c : timestamp %lld : coop %s\n", inet_ntoa(in), (list[i].peer.state == DOWNLOADING ? 'd' : 'r'), list[i].timestamp, list[i].coop); } #endif mycoop = coop; /* * sort the list by timestamps */ qsort(list, numpeers, sizeof(peer_timestamp_t), timestamp_compare); #ifdef DEBUG fprintf(stderr, "shuffle:after sort\n"); for (i = 0 ; i < numpeers ; ++i) { struct in_addr in; in.s_addr = list[i].peer.ip; fprintf(stderr, "\thost %s : state %c : timestamp %lld : coop %s\n", inet_ntoa(in), (list[i].peer.state == DOWNLOADING ? 'd' : 'r'), list[i].timestamp, list[i].coop); } #endif /* * now copy the sorted list back into peers */ for (i = 0 ; i < numpeers ; ++i) { memcpy(&peers[i], &list[i].peer, sizeof(peers[i])); } /* * update the timestamp on only the first entry in the new list */ update_timestamp(peers[0].ip); } free(list); return; }