void draw ( void ) { if ( use_cairo ) fl_push_use_cairo(true); fl_rectf( x(), y(), w(), h(), FL_BLACK ); unsigned long long then = get_ts(); fl_push_clip( x(), y(), w(), h() ); int count = 400; /* draw stuff */ int i = 0; for ( ; i < count; ++i ) fl_draw_box( boxtype, x(), y(), w(), h(), fl_lighter( FL_BLACK ) ); fl_pop_clip(); unsigned long long now = get_ts(); double elapsedms = (now - then) / 1000.0; static char text[256]; sprintf( text, "Drew %i boxes in in %fms", i, elapsedms ); fl_color( FL_RED ); fl_draw( text, x(), y(), w(), h(), FL_ALIGN_CENTER | FL_ALIGN_INSIDE ); draw_label(); if ( use_cairo ) fl_pop_use_cairo(); }
Context *getContext(void) { #if APITRACE_TLS return get_ts()->current_context.get(); #else return get_ts()->current_context; #endif }
/* void response_client_open_ex(response_client_t *uclient, char *conn_str, char *(*id_f)(), char *(*pph_f)()) { uclient->id_f = id_f; uclient->passphrase_f = pph_f; response_client_open_int(uclient, conn_str); } */ int response_client_send(response_client_t *uclient, response_request_t *request) { int ret; long nbytes; char buff[UCLIENT_BUFSIZE]; #if defined(USERVER_ENCRYPTED) char cipher[UCLIENT_BUFSIZE]; char message[UCLIENT_BUFSIZE]; uint32_t timestamp; char sts[32]; char *passphrase = uclient->passphrase_f(); char otp[100]; char *id = uclient->id_f(); char challenge[32]; int len = 32; int len1 = 32; lvc_t lvc; timestamp = get_ts(); len1 = ts2str(timestamp, sts); generate_otp(otp, passphrase, sts); do_encrypt(challenge, &len, sts, len1, otp); lvc_init(&lvc, message, UCLIENT_BUFSIZE); fprintf(stdout, "lvc_pack id:%s\n", id); lvc_pack( &lvc, strlen(id), id ); fprintf(stdout, "lvc_pack ts:%u\n", timestamp); lvc_pack( &lvc, sizeof(uint32_t), (char *)×tamp ); fprintf(stdout, "lvc_pack challenge:%d\n", len); lvc_pack( &lvc, len, challenge ); #endif response_build_request(buff, sizeof(buff), request); nbytes = strlen(buff); #if defined(USERVER_ENCRYPTED) fprintf(stdout, "Message to send:%.*s\n", nbytes, buff); len = sizeof(cipher); do_encrypt(cipher, &len, buff, nbytes, otp); lvc_pack( &lvc, len, cipher ); lvc_pack_finish(&lvc); nbytes = lvc.len; ret = pj_sock_sendto(uclient->fd, lvc.data, &nbytes, 0, (const pj_sockaddr_t *)uclient->connect_data, sizeof(pj_sockaddr_in)); #else ret = pj_sock_sendto(uclient->fd, buff, &nbytes, 0, (const pj_sockaddr_t *)uclient->connect_data, sizeof(pj_sockaddr_in)); #endif if(ret != 0) { PERROR_IF_TRUE(1, "Error in sending data\n"); return -1; } return nbytes; }
void SimpleSwitch::enqueue(int egress_port, std::unique_ptr<Packet> &&packet) { packet->set_egress_port(egress_port); PHV *phv = packet->get_phv(); if (with_queueing_metadata) { phv->get_field("queueing_metadata.enq_timestamp").set(get_ts().count()); phv->get_field("queueing_metadata.enq_qdepth") .set(egress_buffers.size(egress_port)); } #ifdef SSWITCH_PRIORITY_QUEUEING_ON size_t priority = phv->get_field(SSWITCH_PRIORITY_QUEUEING_SRC).get<size_t>(); if (priority >= SSWITCH_PRIORITY_QUEUEING_NB_QUEUES) { bm::Logger::get()->error("Priority out of range, dropping packet"); return; } egress_buffers.push_front( egress_port, SSWITCH_PRIORITY_QUEUEING_NB_QUEUES - 1 - priority, std::move(packet)); #else egress_buffers.push_front(egress_port, std::move(packet)); #endif }
std::string generate_logging_table(statistics_global *ps, std::string username) { std::vector<history_logins> log = ps -> get_login_history(); std::string content = "<table class=\"table2 tablemargins fullwidth\">\n"; content += "<tr class=\"lighttable\"><td class=\"timestamp\">event ts</td><td>event type</td><td>user</td><td>host</td><td>type</td></tr>\n"; content += "<tr class=\"lighttable\"><td>connected since</td><td>duration</td><td colspan=\"3\">notes</td></tr>\n"; double now_ts = get_ts(); for(int index=log.size()-1; index >= 0; index--) { if (username.size() > 0 && log.at(index).user != username) continue; content += "<tr>"; content += "<td>" + time_to_str((time_t)log.at(index).event_ts) + "</td>"; content += "<td>"; switch(log.at(index).hl) { case HL_LOGIN_OK: content += "login ok"; break; case HL_LOGOUT_OK: content += "logout ok"; break; case HL_LOGIN_USER_FAIL: content += "unknown user"; break; case HL_LOGIN_PW_FAIL: content += "password fail"; break; case HL_LOGIN_OTHER: content += "other error"; break; default: content += "INTERNAL ERROR"; } content += "</td><td>" + log.at(index).user + "</td>"; content += "<td>" + log.at(index).host + "</td>"; content += "<td>" + log.at(index).type + "</td>"; content += "</tr>"; content += "<tr class=\"lighttable2\">"; content += "<td>" + time_to_str((time_t)log.at(index).time_logged_in) + "</td>"; if (log.at(index).hl == HL_LOGOUT_OK) content += format("<td>%f</td>", log.at(index).duration); else if (log.at(index).hl == HL_LOGIN_OK) content += format("<td>[%f]</td>", now_ts - log.at(index).time_logged_in); else content += "<td></td>"; content += "<td colspan=\"3\">" + log.at(index).details + "</td>"; content += "</tr>\n"; } content += "</table>\n"; return content; }
static void add_new_tcp(struct tcphdr * this_tcphdr, struct ip * this_iphdr) { struct tcp_stream *tolink; struct tcp_stream *a_tcp; int hash_index; struct tuple4 addr; addr.source = ntohs(this_tcphdr->th_sport); addr.dest = ntohs(this_tcphdr->th_dport); addr.saddr = this_iphdr->ip_src.s_addr; addr.daddr = this_iphdr->ip_dst.s_addr; hash_index = mk_hash_index(addr); if (tcp_num > max_stream) { struct lurker_node *i; tcp_oldest->nids_state = NIDS_TIMED_OUT; for (i = tcp_oldest->listeners; i; i = i->next) (i->item) (tcp_oldest, &i->data); free_tcp(tcp_oldest); nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_TOOMUCH, ugly_iphdr, this_tcphdr); } a_tcp = free_streams; if (!a_tcp) { fprintf(stderr, "gdb me ...\n"); #ifdef WIN32 /* Exit here, I do not know of a function similar to pause() in WIN32 -- Mike */ exit(-1); #else pause(); #endif } free_streams = a_tcp->next_free; tcp_num++; tolink = tcp_stream_table[hash_index]; memset(a_tcp, 0, sizeof(struct tcp_stream)); a_tcp->hash_index = hash_index; a_tcp->addr = addr; a_tcp->client.state = TCP_SYN_SENT; a_tcp->client.seq = ntohl(this_tcphdr->th_seq) + 1; a_tcp->client.first_data_seq = a_tcp->client.seq; a_tcp->client.window = ntohs(this_tcphdr->th_win); a_tcp->client.ts_on = get_ts(this_tcphdr, &a_tcp->client.curr_ts); a_tcp->server.state = TCP_CLOSE; a_tcp->next_node = tolink; a_tcp->prev_node = 0; if (tolink) tolink->prev_node = a_tcp; tcp_stream_table[hash_index] = a_tcp; a_tcp->next_time = tcp_latest; a_tcp->prev_time = 0; if (!tcp_oldest) tcp_oldest = a_tcp; if (tcp_latest) tcp_latest->prev_time = a_tcp; tcp_latest = a_tcp; }
debug_console::debug_console() { nc = false; win_term = win_regs = win_logs = NULL; max_x = max_y = -1; n_ticks = 0; start_ts = get_ts(); had_logging = false; refresh_limit = refresh_counter = 0; refresh_limit_valid = false; }
int connect_ssl(int fd, SSL_CTX *client_ctx, SSL **ssl_h, BIO **s_bio, double timeout, double *ssl_handshake) { int dummy = -1; double dstart = get_ts(); struct timeval tv; tv.tv_sec = (long)(timeout / 1000.0); tv.tv_usec = (long)(timeout * 1000.0) % 1000000; *ssl_handshake = -1.0; if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv) == -1) { set_error(gettext("problem setting receive timeout (%s)"), strerror(errno)); return -1; } if (setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof tv) == -1) { set_error(gettext("problem setting transmit timeout (%s)"), strerror(errno)); return -1; } *ssl_h = SSL_new(client_ctx); *s_bio = BIO_new_socket(fd, BIO_NOCLOSE); SSL_set_bio(*ssl_h, *s_bio, *s_bio); dummy = SSL_connect(*ssl_h); if (dummy <= 0) { set_error(gettext("problem starting SSL connection: %d"), SSL_get_error(*ssl_h, dummy)); return -1; } *ssl_handshake = get_ts() - dstart; return 0; }
void setContext(uintptr_t context_id) { ThreadState *ts = get_ts(); context_ptr_t ctx; context_map_mutex.lock(); assert(context_map.find(context_id) != context_map.end()); ctx = context_map[context_id]; context_map_mutex.unlock(); ts->current_context = ctx; if (!ctx->bound) { ctx->profile = glfeatures::getCurrentContextProfile(); ctx->extensions.getCurrentContextExtensions(ctx->profile); ctx->features.load(ctx->profile, ctx->extensions); ctx->bound = true; } if (!ctx->boundDrawable) { /* * The default viewport and scissor state is set when a context is * first made current, with values matching the bound drawable. Many * applications never thouch the default state ever again. * * Since we currently don't trace window sizes, and rely on viewport * calls to deduct, emit fake calls here so that viewport/scissor state * can be deducated. * * FIXME: don't call the real functions here -- just emit the fake * calls. */ GLint viewport[4] = {0, 0, 0, 0}; GLint scissor[4] = {0, 0, 0, 0}; _glGetIntegerv(GL_VIEWPORT, viewport); _glGetIntegerv(GL_SCISSOR_BOX, scissor); /* * On MacOSX the current context and surface are set independently, and * we might be called before both are set, so ignore empty boxes. */ if (viewport[2] && viewport[3] && scissor[2] && scissor[3]) { glViewport(viewport[0], viewport[1], viewport[2], viewport[3]); glScissor(scissor[0], scissor[1], scissor[2], scissor[3]); ctx->boundDrawable = true; } } }
void Packet::print() { uint32_t tsval, tsecr; char sip_str[INET_ADDRSTRLEN]; char dip_str[INET_ADDRSTRLEN]; inet_ntop(AF_INET, &ip_hdr->ip_src.s_addr, sip_str, INET_ADDRSTRLEN); inet_ntop(AF_INET, &ip_hdr->ip_dst.s_addr, dip_str, INET_ADDRSTRLEN); get_tcp_ts(&tsval,&tsecr); switch(get_ip_protocol()) { case IPPROTO_TCP: std::cout << "TCP packet: " << "[" << get_ts().tv_sec << "." << std::setw(9) << std::setfill('0') << get_ts().tv_nsec << "] [" << sip_str << ":" << get_tcp_sport() << "->" << dip_str << ":" << get_tcp_dport() << "] " << "[S:" << get_tcp_seq() << "] " << "[A:" << get_tcp_ack() << "] " << "[L:" << get_tcp_payload_len() << "] " << "[M:" << get_tcp_mss() << "] " << "[TV:" << tsval << "] " << "[TE:" << tsecr << "]" << std::endl << std::flush; break; case IPPROTO_ICMP: std::cout << "ICMP packet: [" << sip_str << "->" << dip_str << "] " << "[TTL:" << get_ip_ttl() << "]" << std::endl << std::flush; break; default: std::cout << "Unknown packet!" << std::endl << std::flush; break; } }
static void * timedcond_routine (void *arg) { int ret; struct timespec ts; gl_lock_lock (lockcond); while (!cond_value) { get_ts (&ts); ret = glthread_cond_timedwait (&condtest, &lockcond, &ts); if (ret == ETIMEDOUT) cond_timeout = 1; } gl_lock_unlock (lockcond); return NULL; }
int SimpleSwitch::receive(int port_num, const char *buffer, int len) { static int pkt_id = 0; // this is a good place to call this, because blocking this thread will not // block the processing of existing packet instances, which is a requirement if (do_swap() == 0) { check_queueing_metadata(); } // we limit the packet buffer to original size + 512 bytes, which means we // cannot add more than 512 bytes of header data to the packet, which should // be more than enough auto packet = new_packet_ptr(port_num, pkt_id++, len, bm::PacketBuffer(len + 512, buffer, len)); BMELOG(packet_in, *packet); PHV *phv = packet->get_phv(); // many current P4 programs assume this // it is also part of the original P4 spec phv->reset_metadata(); // setting standard metadata phv->get_field("standard_metadata.ingress_port").set(port_num); // using packet register 0 to store length, this register will be updated for // each add_header / remove_header primitive call packet->set_register(PACKET_LENGTH_REG_IDX, len); phv->get_field("standard_metadata.packet_length").set(len); Field &f_instance_type = phv->get_field("standard_metadata.instance_type"); f_instance_type.set(PKT_INSTANCE_TYPE_NORMAL); if (phv->has_field("intrinsic_metadata.ingress_global_timestamp")) { phv->get_field("intrinsic_metadata.ingress_global_timestamp") .set(get_ts().count()); } input_buffer.push_front(std::move(packet)); return 0; }
void SimpleSwitch::egress_thread(size_t worker_id) { PHV *phv; while (1) { std::unique_ptr<Packet> packet; size_t port; egress_buffers.pop_back(worker_id, &port, &packet); Deparser *deparser = this->get_deparser("deparser"); Pipeline *egress_mau = this->get_pipeline("egress"); phv = packet->get_phv(); if (with_queueing_metadata) { auto enq_timestamp = phv->get_field("queueing_metadata.enq_timestamp").get<ts_res::rep>(); phv->get_field("queueing_metadata.deq_timedelta").set( get_ts().count() - enq_timestamp); phv->get_field("queueing_metadata.deq_qdepth").set( egress_buffers.size(port)); } phv->get_field("standard_metadata.egress_port").set(port); Field &f_egress_spec = phv->get_field("standard_metadata.egress_spec"); f_egress_spec.set(0); phv->get_field("standard_metadata.packet_length").set( packet->get_register(PACKET_LENGTH_REG_IDX)); egress_mau->apply(packet.get()); Field &f_clone_spec = phv->get_field("standard_metadata.clone_spec"); unsigned int clone_spec = f_clone_spec.get_uint(); // EGRESS CLONING if (clone_spec) { BMLOG_DEBUG_PKT(*packet, "Cloning packet at egress"); int egress_port = get_mirroring_mapping(clone_spec & 0xFFFF); if (egress_port >= 0) { f_clone_spec.set(0); p4object_id_t field_list_id = clone_spec >> 16; std::unique_ptr<Packet> packet_copy = packet->clone_with_phv_reset_metadata_ptr(); PHV *phv_copy = packet_copy->get_phv(); FieldList *field_list = this->get_field_list(field_list_id); for (const auto &p : *field_list) { phv_copy->get_field(p.header, p.offset) .set(phv->get_field(p.header, p.offset)); } phv_copy->get_field("standard_metadata.instance_type") .set(PKT_INSTANCE_TYPE_EGRESS_CLONE); enqueue(egress_port, std::move(packet_copy)); } } // TODO(antonin): should not be done like this in egress pipeline int egress_spec = f_egress_spec.get_int(); if (egress_spec == 511) { // drop packet BMLOG_DEBUG_PKT(*packet, "Dropping packet at the end of egress"); continue; } deparser->deparse(packet.get()); // RECIRCULATE if (phv->has_field("intrinsic_metadata.recirculate_flag")) { Field &f_recirc = phv->get_field("intrinsic_metadata.recirculate_flag"); if (f_recirc.get_int()) { BMLOG_DEBUG_PKT(*packet, "Recirculating packet"); p4object_id_t field_list_id = f_recirc.get_int(); f_recirc.set(0); FieldList *field_list = this->get_field_list(field_list_id); // TODO(antonin): just like for resubmit, there is no need for a copy // here, but it is more convenient for this first prototype std::unique_ptr<Packet> packet_copy = packet->clone_no_phv_ptr(); PHV *phv_copy = packet_copy->get_phv(); phv_copy->reset_metadata(); for (const auto &p : *field_list) { phv_copy->get_field(p.header, p.offset) .set(phv->get_field(p.header, p.offset)); } phv_copy->get_field("standard_metadata.instance_type") .set(PKT_INSTANCE_TYPE_RECIRC); size_t packet_size = packet_copy->get_data_size(); packet_copy->set_register(PACKET_LENGTH_REG_IDX, packet_size); phv_copy->get_field("standard_metadata.packet_length").set(packet_size); input_buffer.push_front(std::move(packet_copy)); continue; } } output_buffer.push_front(std::move(packet)); }
static void tcp_queue(struct tcp_stream * a_tcp, struct tcphdr * this_tcphdr, struct half_stream * snd, struct half_stream * rcv, char *data, int datalen, int skblen ) { a_tcp->lasttime = time((time_t *)0); u_int this_seq = ntohl(this_tcphdr->th_seq); struct skbuff *pakiet; /* * Did we get anything new to ack? */ if (!after(this_seq, EXP_SEQ)) { if (after(this_seq + datalen + (this_tcphdr->th_flags & TH_FIN), EXP_SEQ)) { // the packet straddles our window end get_ts(this_tcphdr, &snd->curr_ts); add_from_skb(a_tcp, rcv, snd, data, datalen, this_seq, (this_tcphdr->th_flags & TH_FIN), (this_tcphdr->th_flags & TH_URG), ntohs(this_tcphdr->th_urp) + this_seq - 1); // Do we have any old packets to ack that the above // made visible? (Go forward from skb) pakiet = rcv->list; while (pakiet) { if (after(pakiet->seq, EXP_SEQ)) break; if (after(pakiet->seq + pakiet->len + pakiet->fin, EXP_SEQ)) { struct skbuff *tmp; add_from_skb(a_tcp, rcv, snd, pakiet->data, pakiet->len, pakiet->seq, pakiet->fin, pakiet->urg, pakiet->urg_ptr + pakiet->seq - 1); rcv->rmem_alloc -= pakiet->truesize; if (pakiet->prev) pakiet->prev->next = pakiet->next; else rcv->list = pakiet->next; if (pakiet->next) pakiet->next->prev = pakiet->prev; else rcv->listtail = pakiet->prev; tmp = pakiet->next; free(pakiet->data); free(pakiet); pakiet = tmp; } else pakiet = pakiet->next; } } } else if(this_tcphdr->th_flags & TH_FIN || this_tcphdr->th_flags & TH_RST ) { pakiet = rcv->list; while (pakiet) { struct skbuff *tmp; add_from_skb(a_tcp, rcv, snd, pakiet->data, pakiet->len, pakiet->seq, pakiet->fin, pakiet->urg, pakiet->urg_ptr + pakiet->seq - 1); rcv->rmem_alloc -= pakiet->truesize; if (pakiet->prev) pakiet->prev->next = pakiet->next; else rcv->list = pakiet->next; if (pakiet->next) pakiet->next->prev = pakiet->prev; else rcv->listtail = pakiet->prev; tmp = pakiet->next; free(pakiet->data); free(pakiet); pakiet = tmp; } //free_tcp(a_tcp); } else { struct skbuff *p = rcv->listtail; pakiet = mknew(struct skbuff); pakiet->truesize = skblen; rcv->rmem_alloc += pakiet->truesize; pakiet->len = datalen; pakiet->data = malloc(datalen); if (!pakiet->data) nids_params.no_mem("tcp_queue"); memcpy(pakiet->data, data, datalen); pakiet->fin = (this_tcphdr->th_flags & TH_FIN); pakiet->seq = this_seq; pakiet->urg = (this_tcphdr->th_flags & TH_URG); pakiet->urg_ptr = ntohs(this_tcphdr->th_urp); for (;;) { /* if (!p || !after(p->seq, this_seq)) break; */ if( !p ) break; if ( !after(p->seq, this_seq)) { if( p->seq != this_seq){ break; } else { if(p->len > datalen) break; }//if_else }//if p = p->prev; }//for if (!p) { pakiet->prev = 0; pakiet->next = rcv->list; if (rcv->list) rcv->list->prev = pakiet; rcv->list = pakiet; if (!rcv->listtail) rcv->listtail = pakiet; } else { pakiet->next = p->next; p->next = pakiet; pakiet->prev = p; if (pakiet->next) pakiet->next->prev = pakiet; else rcv->listtail = pakiet; } } }
void process_tcp(u_char * data, int skblen) { // printf("into process_tcp\n"); struct ip *this_iphdr = (struct ip *)data; struct tcphdr *this_tcphdr = (struct tcphdr *)(data + 4 * this_iphdr->ip_hl); int datalen, iplen; int from_client = 1; unsigned int tmp_ts; struct tcp_stream *a_tcp; struct half_stream *snd, *rcv; ugly_iphdr = this_iphdr; iplen = ntohs(this_iphdr->ip_len); if ((unsigned)iplen < 4 * this_iphdr->ip_hl + sizeof(struct tcphdr)) { nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr, this_tcphdr); return; } // ktos sie bawi datalen = iplen - 4 * this_iphdr->ip_hl - 4 * this_tcphdr->th_off; if (datalen < 0) { nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr, this_tcphdr); return; } // ktos sie bawi if ((this_iphdr->ip_src.s_addr | this_iphdr->ip_dst.s_addr) == 0) { nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr, this_tcphdr); return; } /* if (!(this_tcphdr->th_flags & TH_ACK)) detect_scan(this_iphdr); */ if (!nids_params.n_tcp_streams) return; if (my_tcp_check(this_tcphdr, iplen - 4 * this_iphdr->ip_hl, this_iphdr->ip_src.s_addr, this_iphdr->ip_dst.s_addr)) { nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr, this_tcphdr); //return; } #if 0 check_flags(this_iphdr, this_tcphdr); //ECN #endif if (!(a_tcp = find_stream(this_tcphdr, this_iphdr, &from_client))) { if ((this_tcphdr->th_flags & TH_SYN) && !(this_tcphdr->th_flags & TH_ACK) && !(this_tcphdr->th_flags & TH_RST)) add_new_tcp(this_tcphdr, this_iphdr); // printf("add new\n"); return; } // printf("tcp exist\n"); if (from_client) { snd = &a_tcp->client; rcv = &a_tcp->server; } else { rcv = &a_tcp->client; snd = &a_tcp->server; } if ((this_tcphdr->th_flags & TH_SYN)) { if (from_client || a_tcp->client.state != TCP_SYN_SENT || a_tcp->server.state != TCP_CLOSE || !(this_tcphdr->th_flags & TH_ACK)) return; if (a_tcp->client.seq != ntohl(this_tcphdr->th_ack)) return; a_tcp->server.state = TCP_SYN_RECV; a_tcp->server.seq = ntohl(this_tcphdr->th_seq) + 1; a_tcp->server.first_data_seq = a_tcp->server.seq; a_tcp->server.ack_seq = ntohl(this_tcphdr->th_ack); a_tcp->server.window = ntohs(this_tcphdr->th_win); if (a_tcp->client.ts_on) { a_tcp->server.ts_on = get_ts(this_tcphdr, &a_tcp->server.curr_ts); if (!a_tcp->server.ts_on) a_tcp->client.ts_on = 0; } else a_tcp->server.ts_on = 0; if (a_tcp->client.wscale_on) { a_tcp->server.wscale_on = get_wscale(this_tcphdr, &a_tcp->server.wscale); if (!a_tcp->server.wscale_on) { a_tcp->client.wscale_on = 0; a_tcp->client.wscale = 1; a_tcp->server.wscale = 1; } } else { a_tcp->server.wscale_on = 0; a_tcp->server.wscale = 1; } return; } if ( ! ( !datalen && ntohl(this_tcphdr->th_seq) == rcv->ack_seq ) && ( !before(ntohl(this_tcphdr->th_seq), rcv->ack_seq + rcv->window*rcv->wscale) || before(ntohl(this_tcphdr->th_seq) + datalen, rcv->ack_seq) ) ) return; if ((this_tcphdr->th_flags & TH_RST)) { if (a_tcp->nids_state == NIDS_DATA) { struct lurker_node *i; a_tcp->nids_state = NIDS_RESET; for (i = a_tcp->listeners; i; i = i->next) (i->item) (a_tcp, &i->data); } free_tcp(a_tcp); return; } /* PAWS check */ if (rcv->ts_on && get_ts(this_tcphdr, &tmp_ts) && before(tmp_ts, snd->curr_ts)) return; if ((this_tcphdr->th_flags & TH_ACK)) { if (from_client && a_tcp->client.state == TCP_SYN_SENT && a_tcp->server.state == TCP_SYN_RECV) { if (ntohl(this_tcphdr->th_ack) == a_tcp->server.seq) { a_tcp->client.state = TCP_ESTABLISHED; a_tcp->client.ack_seq = ntohl(this_tcphdr->th_ack); { struct proc_node *i; struct lurker_node *j; void *data; a_tcp->server.state = TCP_ESTABLISHED; a_tcp->nids_state = NIDS_JUST_EST; for (i = tcp_procs; i; i = i->next) { char whatto = 0; char cc = a_tcp->client.collect; char sc = a_tcp->server.collect; char ccu = a_tcp->client.collect_urg; char scu = a_tcp->server.collect_urg; (i->item) (a_tcp, &data); if (cc < a_tcp->client.collect) whatto |= COLLECT_cc; if (ccu < a_tcp->client.collect_urg) whatto |= COLLECT_ccu; if (sc < a_tcp->server.collect) whatto |= COLLECT_sc; if (scu < a_tcp->server.collect_urg) whatto |= COLLECT_scu; if (nids_params.one_loop_less) { if (a_tcp->client.collect >=2) { a_tcp->client.collect=cc; whatto&=~COLLECT_cc; } if (a_tcp->server.collect >=2 ) { a_tcp->server.collect=sc; whatto&=~COLLECT_sc; } } if (whatto) { j = mknew(struct lurker_node); j->item = i->item; j->data = data; j->whatto = whatto; j->next = a_tcp->listeners; a_tcp->listeners = j; } } if (!a_tcp->listeners) { free_tcp(a_tcp); return; } a_tcp->nids_state = NIDS_DATA; } } // return; } }
void statistics_menu(void) { NEWWIN *mywin = create_popup(23, 65); int offset = 0, cur_line = 0; for(;;) { int c; int vmsize = get_vmsize(getpid()); time_t now = time(NULL); struct tm *tmnow = localtime(&now); proginfo **plist = NULL; char *issub = NULL; int *winnr = NULL; int loop, nwin = 0; /* create list of (sub-)windows */ for(loop=0; loop<nfd; loop++) { proginfo *cur = &pi[loop]; while(cur) { plist = (proginfo **)myrealloc(plist, (nwin + 1) * sizeof(proginfo *)); issub = (char *) myrealloc(issub, (nwin + 1) * sizeof(char) ); winnr = (int *) myrealloc(winnr, (nwin + 1) * sizeof(int) ); plist[nwin] = cur; issub[nwin] = (cur != &pi[loop]); winnr[nwin] = loop; nwin++; cur = cur -> next; } } werase(mywin -> win); win_header(mywin, "Statistics"); for(loop=0; loop<18; loop++) { int cur_index = loop + offset; int is_sub_indent; if (cur_index >= nwin) break; is_sub_indent = issub[cur_index]; if (loop == cur_line) ui_inverse_on(mywin); if (is_sub_indent) mvwprintw(mywin -> win, 2 + loop, 7, "%s", shorten_filename(plist[cur_index] -> filename, 54)); else mvwprintw(mywin -> win, 2 + loop, 2, "[%02d] %s", winnr[cur_index], shorten_filename(plist[cur_index] -> filename, 56)); if (loop == cur_line) ui_inverse_off(mywin); } mvwprintw(mywin -> win, 20, 2, "Run-time: %.2f hours %02d:%02d", (get_ts() - mt_started) / 3600.0, tmnow -> tm_hour, tmnow -> tm_min); if (vmsize != -1) { char *vmsize_str = amount_to_str(vmsize); mvwprintw(mywin -> win, 20, 35, "Memory usage: %s", vmsize_str); myfree(vmsize_str); } escape_print(mywin, 21, 2, "Press ^r^ to reset counters, ^q^ to exit"); draw_border(mywin); mydoupdate(); c = toupper(wait_for_keypress(HELP_STATISTICS, popup_refresh_interval, mywin, 1)); if (c == 'R') { for(loop=0; loop<nfd; loop++) { proginfo *cur = &pi[loop]; while(cur) { reset_counters(&cur -> statistics); cur = cur -> next; } } } else if (c == KEY_UP) { if (cur_line) cur_line--; else if (offset) offset--; else wrong_key(); } else if (c == KEY_DOWN) { if ((cur_line + offset) < (nwin - 1)) { if (cur_line < (18 - 1)) cur_line++; else offset++; } else wrong_key(); } else if (c == 13 || c == ' ') { statistics_popup(winnr[cur_line + offset], plist[cur_line + offset]); } else if (c == 'Q' || c == abort_key) { myfree(plist); myfree(issub); myfree(winnr); break; } else if (c != -1) { wrong_key(); } myfree(plist); myfree(issub); myfree(winnr); } delete_popup(mywin); }
void debug_console::tick(processor *p) { n_ticks++; if (!refresh_limit_valid) { double now_ts = get_ts(); double t_diff = now_ts - start_ts; // first second: ignore as the cpu might need to come out of // reduced clock frequency (linux: "ondemand" scaling governor) if (t_diff >= 1.0) refresh_limit++; if (t_diff >= 1.0 + 1.0 / double(SCREEN_REFRESHES_PER_SECOND)) { dc_log("Refresh screen every %d instructions", refresh_limit); refresh_limit_valid = true; } } uint64_t PC = p -> is_delay_slot() ? p -> get_delay_slot_PC() : p -> get_PC(); uint32_t instruction = -1; bool r_ok = true; try { p -> get_mem_32b(PC, &instruction); } catch(processor_exception & pe) { dc_log("EXCEPTION %d at/for %016llx, PC: %016llx (3), sr: %08x", pe.get_cause(), pe.get_BadVAddr(), pe.get_EPC(), pe.get_status()); r_ok = false; } std::string logline = p -> da_logline(instruction); dolog(logline.c_str()); std::string decoded = p -> decode_to_text(instruction); #ifdef _DEBUG unsigned int space = decoded.find(' '); if (space == std::string::npos) space = decoded.length(); std::string instruction_name = decoded.substr(0, space); std::map<std::string, long int>::iterator found = instruction_counts.find(instruction_name); if (found != instruction_counts.end()) found -> second++; else instruction_counts.insert(std::pair<std::string, long int>(instruction_name, 1)); #endif if ((++refresh_counter >= refresh_limit && refresh_limit_valid == true) || single_step) { double now_ts = get_ts(); if (term_change) recreate_terminal(); int x = -1, y = -1; for(int registers=0; registers<32; registers++) { if (registers < 16) { x = 0; y = registers; } else { x = 22; y = registers - 16; } mvwprintw(win_regs, y, x, "%s %016llx", registers == 0 ? "0 " : processor::reg_to_name(registers), p -> get_register_64b_unsigned(registers)); } mvwprintw(win_regs, 0, 44, "PC: %016llx %c", PC, p -> is_delay_slot() ? 'D' : '.'); mvwprintw(win_regs, 1, 44, "LO: %016llx", p -> get_LO()); mvwprintw(win_regs, 2, 44, "HI: %016llx", p -> get_HI()); mvwprintw(win_regs, 3, 44, "SR: %016llx", p -> get_SR()); mvwprintw(win_regs, 4, 44, "mem: %d/%08x", r_ok, instruction); int opcode = (instruction >> 26) & MASK_6B; int function = instruction & MASK_6B; int sa = processor::get_SA(instruction); int rd = processor::get_RD(instruction); int rt = processor::get_RT(instruction); int rs = processor::get_RS(instruction); int immediate = processor::get_immediate(instruction); int b18_signed_offset = processor::get_SB18(instruction); mvwprintw(win_regs, 5, 44, "op: %02x rs: %02x", opcode, rs); mvwprintw(win_regs, 6, 44, "rt: %02x rd: %02x", rt, rd); mvwprintw(win_regs, 7, 44, "sa: %02x fu: %02d", sa, function); mvwprintw(win_regs, 8, 44, "im: %04x of: %d", immediate, b18_signed_offset); mvwprintw(win_regs, 9, 44, "> "); mvwprintw(win_regs, 9, 44, "> %s", decoded.c_str()); double t_diff = now_ts - start_ts; if (t_diff) { double i_per_s = double(n_ticks) / t_diff; if (i_per_s >= 1000000000.0) mvwprintw(win_regs, 10, 44, "I/S: %6.2fG", i_per_s / 1000000000.0); else if (i_per_s >= 1000000.0) mvwprintw(win_regs, 10, 44, "I/S: %6.2fM", i_per_s / 1000000.0); else if (i_per_s >= 1000.0) mvwprintw(win_regs, 10, 44, "I/S: %6.2fk", i_per_s / 1000.0); else mvwprintw(win_regs, 10, 44, "I/S: %6.2f", i_per_s); } if (n_ticks >= 1000000000) mvwprintw(win_regs, 11, 44, "cnt: %7.2fG", double(n_ticks) / 1000000000.0); else if (n_ticks >= 1000000) mvwprintw(win_regs, 11, 44, "cnt: %7.2fM", double(n_ticks) / 1000000.0); else if (n_ticks >= 1000) mvwprintw(win_regs, 11, 44, "cnt: %7.2fk", double(n_ticks) / 1000.0); else mvwprintw(win_regs, 11, 44, "cnt: %lld", n_ticks); mvwprintw(win_regs, 11, 44, "cnt: %lld", n_ticks); const memory_bus *pmb = p -> get_memory_bus(); mvwprintw(win_regs, 12, 44, "I_S: %016x", pmb -> get_cur_segment_i()); mvwprintw(win_regs, 13, 44, "D_S: %016x", pmb -> get_cur_segment()); if (had_logging) { wnoutrefresh(win_logs); had_logging = false; } wnoutrefresh(win_regs); doupdate(); if (refresh_limit_valid) refresh_counter = 0; }
void round_one() { std::cout << "Creating new file test.hdf5r\n"; // Open the HDF5 file hdf5r::HDF5R f("test.hdf5r", hdf5r::TRUNCATE); // Show the number of channels - it will be zero for a new file std::cout << "Number of channels in the file: " << f.channels().size() << '\n'; // Add a couple of channels of varying type std::cout << "Adding channel 'integers' to log\n"; hdf5r::ChannelID int_chan = f.add_channel("integers", "int", "thin_air", H5T_NATIVE_INT, H5T_STD_I64LE); std::cout << "Adding channel 'floats' to log\n"; hdf5r::ChannelID float_chan = f.add_channel("floats", "float", "thinner_air", H5T_NATIVE_FLOAT, H5T_IEEE_F32LE); std::cout << "Number of channels in the file: " << f.channels().size() << '\n'; // Put some data into the channels std::cout << "Writing some data\n"; int int_data[] = {1, 2, 3, 5, 8, 13, 21, 34, 55, 89}; float float_data[] = {2.7182818284590451, 7.3890560989306495, 20.085536923187664, 54.598150033144229, 148.41315910257657, 403.428793492735, 1096.6331584284583, 2980.9579870417269, 8103.0839275753797, 22026.465794806703}; f.add_entry(int_chan, get_ts(), &int_data[0]); f.add_entry(int_chan, get_ts(), &int_data[1]); f.add_entry(float_chan, get_ts(), &float_data[0]); f.add_entry(int_chan, get_ts(), &int_data[2]); f.add_entry(float_chan, get_ts(), &float_data[1]); f.add_entry(float_chan, get_ts(), &float_data[2]); f.add_entry(float_chan, get_ts(), &float_data[3]); f.add_entry(float_chan, get_ts(), &float_data[4]); f.add_entry(int_chan, get_ts(), &int_data[3]); f.add_entry(float_chan, get_ts(), &float_data[5]); f.add_entry(int_chan, get_ts(), &int_data[4]); f.add_entry(float_chan, get_ts(), &float_data[6]); f.add_entry(int_chan, get_ts(), &int_data[5]); f.add_entry(int_chan, get_ts(), &int_data[6]); f.add_entry(int_chan, get_ts(), &int_data[7]); f.add_entry(float_chan, get_ts(), &float_data[7]); f.add_entry(int_chan, get_ts(), &int_data[8]); f.add_entry(float_chan, get_ts(), &float_data[8]); f.add_entry(int_chan, get_ts(), &int_data[9]); f.add_entry(float_chan, get_ts(), &float_data[9]); // Add a couple of tags std::cout << "Setting tags\n"; f.set_text_tag("TITLE", "Sample HDF5R log"); f.set_text_tag("LIB_NAME", "hdf5r 1.0"); std::cout << "Closing file\n\n"; }
void info(void) { NEWWIN *mywin = create_popup(19, 60); int line = 7; struct utsname uinfo; int proc_u_line; char *term = getenv("TERM"); mvwprintw(mywin -> win, 1, 2, "-=* MultiTail " VERSION " *=-"); mvwprintw(mywin -> win, 3, 2, "Written by [email protected]"); mvwprintw(mywin -> win, 4, 2, "Website: http://www.vanheusden.com/multitail/"); if (!use_colors) mvwprintw(mywin -> win, line++, 2, "Your terminal doesn't support colors"); if (uname(&uinfo) == -1) error_popup("Retrieving system information", -1, "uname() failed\n"); else { line++; mvwprintw(mywin -> win, line++, 2, "Running on:"); #ifdef _GNU_SOURCE mvwprintw(mywin -> win, line++, 2, "%s/%s %s %s", uinfo.nodename, uinfo.sysname, uinfo.machine, uinfo.domainname); #else mvwprintw(mywin -> win, line++, 2, "%s/%s %s", uinfo.nodename, uinfo.sysname, uinfo.machine); #endif mvwprintw(mywin -> win, line++, 2, "%s %s", uinfo.release, uinfo.version); line++; } if (has_colors()) mvwprintw(mywin -> win, line++, 2, "colors: %d, colorpairs: %d (%d), change colors: %s", COLORS, COLOR_PAIRS, cp.n_def, can_change_color()?"yes":"no"); else mvwprintw(mywin -> win, line++, 2, "Terminal does not support colors."); if (term) mvwprintw(mywin -> win, line++, 2, "Terminal size: %dx%d, terminal: %s", max_x, max_y, term); else mvwprintw(mywin -> win, line++, 2, "Terminal size: %dx%d", max_x, max_y); if (beep_interval > 0) mvwprintw(mywin -> win, line++, 2, "Did %d beeps.", did_n_beeps); proc_u_line = line++; escape_print(mywin, 16, 2, "_Press any key to exit this screen_"); #if defined(__FreeBSD__) || defined(linux) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__) || defined(sun) || defined(__sun) || defined(__GNU__) || defined(__CYGWIN__) for(;;) { dtime_t run_time = get_ts() - mt_started; #ifndef __CYGWIN__ double v1, v2, v3; get_load_values(&v1, &v2, &v3); mvwprintw(mywin -> win, 6, 2, "Current load of system: %f %f %f", v1, v2, v3); #endif if (run_time) { struct rusage usage; if (getrusage(RUSAGE_SELF, &usage) == -1) error_exit(TRUE, FALSE, "getrusage() failed\n"); mvwprintw(mywin -> win, proc_u_line, 2, "Runtime: %02d:%02d:%02d, avg.proc.usage: %.2f%% ints/s: %.1f", (int)(run_time / 3600), ((int)run_time / 60) % 60, (int)run_time % 60, ((double)usage.ru_utime.tv_sec + (double)usage.ru_utime.tv_usec / 1000000.0 + (double)usage.ru_stime.tv_sec + (double)usage.ru_stime.tv_usec / 1000000.0) * 100.0 / run_time, (double)total_wakeups / run_time); } mydoupdate(); if (wait_for_keypress(-1, popup_refresh_interval, mywin, 0) != -1) break; } #else mydoupdate(); wait_for_keypress(-1, 0, mywin, 0); #endif delete_popup(mywin); }
// Main int main (int argc, char **argv) { // Do some initial sanity checking assert (TIME_BITLEN + MACHINE_BITLEN + SEQ_BITLEN == 64); // Parse command-line arguments int opt; int has_port_opt = 0; int has_machine_opt = 0; int has_config_file_opt = 0; int has_daemonize_opt = 0; int machine_specified = 0; const char *config_file_path; int port = DEFAULT_PORT; uint64_t machine; while ((opt = getopt (argc, argv, "hp:m:f:d")) != -1) { switch (opt) { case 'h': print_help (); exit (EXIT_SUCCESS); case 'p': has_port_opt = 1; port = atoi (optarg); break; case 'm': has_machine_opt = 1; machine = atoll (optarg); machine_specified = 1; break; case 'f': has_config_file_opt = 1; config_file_path = optarg; break; case 'd': has_daemonize_opt = 1; break; } } // Read the config file if (has_config_file_opt) { config_t cfg; config_init (&cfg); if (!config_read_file (&cfg, config_file_path)) { config_destroy (&cfg); fprintf (stderr, "Invalid config file\n"); exit (EXIT_FAILURE); } long unsigned int machine_from_file; if (config_lookup_int (&cfg, "machine", &machine_from_file) && !has_machine_opt) { machine_specified = 1; machine = (uint64_t) machine_from_file; } long unsigned int port_from_file; if (config_lookup_int (&cfg, "port", &port_from_file) && !has_port_opt) port = (int) port_from_file; } // Sanity check the machine number if (!machine_specified) { fprintf (stderr, "No machine number specified.\n"); exit (EXIT_FAILURE); } else if (machine > MACHINE_MAX) { fprintf (stderr, "Machine number too large. Cannot be greater than %llu\n", MACHINE_MAX); exit (EXIT_FAILURE); } // Daemonize static char *pid_file_path = "/var/run/znowflaked.pid"; int pid_file; if (has_daemonize_opt) { pid_t pid, sid; pid = fork (); if (pid < 0) { exit (EXIT_FAILURE); } if (pid > 0) { exit (EXIT_SUCCESS); } umask (0); sid = setsid (); if (sid < 0) { exit (EXIT_FAILURE); } if ((chdir ("/")) < 0) { exit (EXIT_FAILURE); } // Create and lock the pid file pid_file = open (pid_file_path, O_CREAT | O_RDWR, 0666); if (pid_file > 0) { int rc = lockf (pid_file, F_TLOCK, 0); if (rc) { switch (errno) { case EACCES: case EAGAIN: fprintf (stderr, "PID file already locked\n"); break; case EBADF: fprintf (stderr, "Bad pid file\n"); break; default: fprintf (stderr, "Could not lock pid file\n"); } exit (EXIT_FAILURE); } char *pid_string = NULL; int pid_string_len = asprintf (&pid_string, "%ld", (long) getpid ()); write (pid_file, pid_string, pid_string_len); } close (STDIN_FILENO); close (STDOUT_FILENO); close (STDERR_FILENO); } // Sleep for 1ms to prevent collisions struct timespec ms; ms.tv_sec = 0; ms.tv_nsec = 1000000; nanosleep (&ms, NULL); // Initialize ZeroMQ zctx_t *context = zctx_new (); assert (context); void *socket = zsocket_new (context, ZMQ_REP); assert (socket); assert (streq (zsocket_type_str (socket), "REP")); int rc = zsocket_bind (socket, "tcp://*:%d", port); if (rc != port) { printf ("E: bind failed: %s\n", strerror (errno)); exit (EXIT_FAILURE); } // Start remembering the last timer tick uint64_t ts = 0; uint64_t last_ts = 0; uint64_t seq = 0; // Main loop s_catch_signals (); while (1) { // Wait for the next request zmsg_t *request_msg = zmsg_new (); assert (request_msg); request_msg = zmsg_recv (socket); assert (request_msg); zmsg_destroy (&request_msg); // Grab a time click last_ts = ts; ts = get_ts (); // Make sure the system clock wasn't reversed on us if (ts < last_ts) { // Wait until it catches up while (ts <= last_ts) { nanosleep (&ms, NULL); ts = get_ts (); } } // Increment the sequence number if (ts != last_ts) { // We're in a new time click, so reset the sequence seq = 0; } else if (seq == SEQ_MAX) { // Wrapped sequence, so wait for the next time tick seq = 0; nanosleep (&ms, NULL); } else { // Still in the same time click seq++; } // Build the ID and put it in network byte order uint64_t id = build_id (ts, machine, seq); uint64_t id_be64 = htobe64 (id); // Reply zmsg_t *reply_msg = zmsg_new (); assert (reply_msg); zframe_t *frame = zframe_new (&id_be64, 8); assert (frame); zmsg_push (reply_msg, frame); assert (zmsg_size (reply_msg) == 1); assert (zmsg_content_size (reply_msg) == 8); zmsg_send (&reply_msg, socket); assert (reply_msg == NULL); // Exit program if (s_interrupted) { printf ("interrupt received, killing server…\n"); break; } } zctx_destroy (&context); if (has_daemonize_opt) { if (pid_file > 0) { unlink (pid_file_path); close (pid_file); } } exit (EXIT_SUCCESS); }
int main(int argc, char *argv[]) { if(argc < 2) printf("usage: %s matroska_filename\n", argv[0]); char* filename = argv[1]; uint8_t* in_frame = calloc(800*600,1); FILE *fp; if ((fp = fopen(filename,"rb"))!=NULL) { // (rb) read in binary mode printf("opening %s\n", filename); } else { printf("couldn't open %s for read\n",filename); free(in_frame); return (-1); } int i = 0; uint64_t timecode_scale = 0; uint64_t cluster_file_pos = 0; uint64_t end_cluster_file_pos = 0; uint64_t cluster_ts = 0; uint64_t block_ts = 0; uint32_t ID = 0x00000000; int next_byte = 0; uint64_t uisize = 0; uint64_t frame_n = 0; uint64_t seg_inf_size = 0; uint64_t seg_inf_pos = 0; uint64_t tracks_size = 0; uint64_t tracks_pos = 0; uint64_t tmp_size = 0; uint64_t tmp_pos = 0; int video_track = 1; //EBML HEADER ID do { next_byte = fgetc(fp); if(next_byte != EOF) { next_byte &= 0x000000ff; ID <<= 8; ID &= 0xffffff00; ID += next_byte; } else { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } } while(ID != EBML_ID_HEADER); tmp_size = get_size(fp); printf("ebml header size:%llu - skipping\n", tmp_size); //skip ebml header fseeko(fp, tmp_size, SEEK_CUR); //search for timecode scale in segment info //SEGMENT ID do { next_byte = fgetc(fp); if(next_byte != EOF) { next_byte &= 0x000000ff; ID <<= 8; ID &= 0xffffff00; ID += next_byte; } else { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } } while(ID != MATROSKA_ID_SEGMENT); //SEGMENT INFO ID do { next_byte = fgetc(fp); if(next_byte != EOF) { next_byte &= 0x000000ff; ID <<= 8; ID &= 0xffffff00; ID += next_byte; } else { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } } while(ID != MATROSKA_ID_INFO); seg_inf_size = get_size(fp); seg_inf_pos = ftello(fp); //TIMECODE SCALE ID do { next_byte = fgetc(fp); if(next_byte != EOF) { next_byte &= 0x000000ff; ID <<= 8; ID &= 0x00ffff00; ID += next_byte; } else { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } } while((ID != MATROSKA_ID_TIMECODESCALE) && (ftello(fp) < (seg_inf_pos + seg_inf_size))); //get timecode scale int ts_size = get_size(fp); for(i=0; i< ts_size; i++) { next_byte = fgetc(fp); if(next_byte != EOF) { next_byte &= 0x000000ff; timecode_scale <<= 8; timecode_scale &= 0xffffffffffffff00; timecode_scale += next_byte; } else { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } } printf("timecode scale is %llu\n", timecode_scale); //SEGMENT TRACKS do { next_byte = fgetc(fp); if(next_byte != EOF) { next_byte &= 0x000000ff; ID <<= 8; ID &= 0xffffff00; ID += next_byte; } else { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } } while(ID != MATROSKA_ID_TRACKS); tracks_size = get_size(fp); tracks_pos = ftello(fp); //printf("tracks info size: %llu - skip to pos %llu\n", tmp_size, tmp_pos+tmp_size); //skip segment tracks header //fseeko(fp, tmp_size, SEEK_CUR); int track_n = 1; int is_video = 0; do { next_byte = fgetc(fp); if(next_byte != EOF) { next_byte &= 0x000000ff; if(next_byte == MATROSKA_ID_TRACKENTRY) { //check track number and type //if its a video track register number and skip rest of tracks header tmp_size = get_size(fp); tmp_pos = ftello(fp); track_n = 0; int skip = 0; do { next_byte = fgetc(fp); if(next_byte != EOF) { next_byte &= 0x000000ff; if(next_byte == MATROSKA_ID_TRACKNUMBER) { int nsize = get_size(fp); track_n = get_ts(fp, nsize); } else if(next_byte == MATROSKA_ID_TRACKTYPE) { int nsize = get_size(fp); if(get_ts(fp, nsize) == 1) is_video = 1; else skip = 1; //skip track - not a video track } else if (next_byte == 0x73) //0x73c5 UID { next_byte = fgetc(fp); if(next_byte != EOF) { next_byte &=0x000000ff; if(next_byte == 0xc5) //track uid { int uid_size = get_size(fp); fseeko(fp, uid_size, SEEK_CUR); //skip uid } } else { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } } } else { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } if(is_video && track_n) { video_track = track_n; printf("video track at index %d\n", video_track); break; } } while((ftello(fp) < (tmp_pos + tmp_size)) && !skip); fseeko(fp, tmp_pos + tmp_size, SEEK_SET); } } else { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } } while((ftello(fp) < (tracks_pos + tracks_size)) && !is_video); //search for clusters while(1) { do { next_byte = fgetc(fp); if(next_byte != EOF) { next_byte &= 0x000000ff; //if(ftello(fp) == 5553) // printf("ID is 0x%08X next is 0x%08X\n", ID, next_byte); ID <<= 8; ID &= 0xffffff00; ID += next_byte; } else { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } } while(ID != MATROSKA_ID_CLUSTER); cluster_file_pos = ftello(fp); printf("cluster found at position 0x%016X\n", cluster_file_pos-4); //get size end_cluster_file_pos = get_size(fp); end_cluster_file_pos += cluster_file_pos; next_byte = fgetc(fp); if(next_byte != EOF) { next_byte &= 0x000000ff; } else { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } if(next_byte == MATROSKA_ID_CLUSTERTIMECODE) { //printf("cluster time code found at position 0x%016X\n", ftello(fp)); uisize = get_size(fp); cluster_ts = get_ts(fp, uisize); //printf("cluster timestamp is %llu ms\n", cluster_ts); } else { printf("found 0x%02X instead of 0xE7 - We must have arrived to the Seek Head block - finish\n", next_byte); printf("extracted %llu frames\n", frame_n); fclose(fp); free(in_frame); return (1); } uint64_t bgsize = 0; uint64_t bsize = 0; uint64_t fstart = 0; uint64_t fend = 0; uint64_t f_ts = 0; uint64_t block_start_pos = 0; //get frame time stamp and frame data do { next_byte = fgetc(fp); if(next_byte != EOF) { next_byte &= 0x000000ff; if(next_byte == MATROSKA_ID_BLOCKGROUP) { //printf("found block group at %llu \n", ftello(fp)); bgsize = get_size(fp); next_byte = fgetc(fp); if(next_byte != EOF) { next_byte &= 0x000000ff; if(next_byte == MATROSKA_ID_BLOCK) { block_start_pos = ftello(fp); //printf("found block at %llu \n", block_start_pos); bsize = get_size(fp); //only 1 uint8_t (1-video 2-audio) //video or audio ? if(get_size(fp) == video_track) { printf("found video frame\n"); //timestamp - allways 2 bytes f_ts = cluster_ts; f_ts += get_frame_delta(fp); //empty byte before frame next_byte = fgetc(fp); if(next_byte == EOF) { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } if(next_byte != 0) printf("frame flags set to 0x%02X\n", next_byte); //frame if( (bsize-4) > 0) { fread(in_frame, 1, bsize-4, fp); char image_file[80]; sprintf( image_file, "frame_%016llu_ts-%016llu.jpg", frame_n, f_ts ); frame_n++; printf("saving %s\n", image_file); saveJPG(image_file, bsize-4, in_frame); } else printf("frame is empty - skip it\n"); } else { printf("found non video frame - skip it\n"); fseeko(fp, bsize-1, SEEK_CUR); } } } else { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } } else if(next_byte == MATROSKA_ID_SIMPLEBLOCK) { block_start_pos = ftello(fp); printf("found simple block at %llu\n", block_start_pos); bsize = get_size(fp); //video or audio if(get_size(fp) == video_track) { printf("found video frame\n"); //timestamp - allways 2 bytes f_ts = cluster_ts; f_ts += get_frame_delta(fp); //empty byte before frame next_byte = fgetc(fp); if(next_byte == EOF) { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } if(next_byte != 0) printf("frame flags set to 0x%02X \n", next_byte); //frame if( (bsize-4) > 0) { fread(in_frame, 1, bsize-4, fp); char image_file[80]; sprintf( image_file, "frame_%016llu_ts-%016llu.jpg", frame_n, f_ts ); frame_n++; printf("saving %s\n", image_file); saveJPG(image_file, bsize-4, in_frame); } else printf("frame is empty - skip it\n"); } else printf("not a video frame - skip it\n"); } } else { if(ferror(fp)) printf("An error ocurred when reading the file\n"); fclose(fp); free(in_frame); return(-2); } } while( ftello(fp) < end_cluster_file_pos); } printf("extracted %llu frames\n", frame_n); fclose(fp); free(in_frame); return 0; }
static void add_new_tcp(struct tcphdr * this_tcphdr, struct ip * this_iphdr) { struct tcp_stream *tolink; struct tcp_stream *a_tcp; int hash_index; struct tuple4 addr; addr.source = ntohs(this_tcphdr->th_sport); addr.dest = ntohs(this_tcphdr->th_dport); addr.saddr = this_iphdr->ip_src.s_addr; addr.daddr = this_iphdr->ip_dst.s_addr; hash_index = mk_hash_index(addr); if (tcp_num > max_stream) { struct lurker_node *i; int orig_client_state=tcp_oldest->client.state; tcp_oldest->nids_state = NIDS_TIMED_OUT; for (i = tcp_oldest->listeners; i; i = i->next) (i->item) (tcp_oldest, &i->data); nids_free_tcp_stream(tcp_oldest); if (orig_client_state!=TCP_SYN_SENT) nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_TOOMUCH, ugly_iphdr, this_tcphdr); } a_tcp = free_streams; if (!a_tcp) { fprintf(stderr, "gdb me ...\n"); pause(); } free_streams = a_tcp->next_free; tcp_num++; tolink = tcp_stream_table[hash_index]; memset(a_tcp, 0, sizeof(struct tcp_stream)); #ifdef OSPLIT struct ipfrag *frag_tag=this_fragments; struct ipfrag *ip_frag_next; if(this_fragments) ip_frag_next=this_fragments->next; a_tcp->fp=split_file[(TCP_file_idx++)%SPLIT_FILE_NUM]; /*write all fragment(s) to fp trace file*/ if(is_frag==0) { write_pcap_hdr(a_tcp->fp,(char*)nids_last_pcap_header,sizeof(struct pcap_sf_pkthdr)); write_ip(a_tcp->fp,(char*)this_iphdr,ntohs(this_iphdr->ip_len),(char*)nids_last_pcap_header); } else { /*fragments*/ while(frag_tag!=NULL) { write_pcap_hdr(a_tcp->fp,(char*)(&(frag_tag->pcap_header)),sizeof(struct pcap_sf_pkthdr)); write_ip(a_tcp->fp,(char*)frag_tag->skb->data,frag_tag->wtrace_len,(char*)(&(frag_tag->pcap_header))); free(frag_tag); frag_tag=ip_frag_next; if(ip_frag_next!=NULL) ip_frag_next=ip_frag_next->next; } is_frag=0; } /*set statistic info*/ store_flag=1; #endif a_tcp->hash_index = hash_index; a_tcp->addr = addr; a_tcp->client.state = TCP_SYN_SENT; a_tcp->client.seq = ntohl(this_tcphdr->th_seq) + 1; a_tcp->client.first_data_seq = a_tcp->client.seq; a_tcp->client.window = ntohs(this_tcphdr->th_win); a_tcp->client.ts_on = get_ts(this_tcphdr, &a_tcp->client.curr_ts); a_tcp->client.wscale_on = get_wscale(this_tcphdr, &a_tcp->client.wscale); a_tcp->server.state = TCP_CLOSE; a_tcp->next_node = tolink; a_tcp->prev_node = 0; if (tolink) tolink->prev_node = a_tcp; tcp_stream_table[hash_index] = a_tcp; a_tcp->next_time = tcp_latest; a_tcp->prev_time = 0; if (!tcp_oldest) tcp_oldest = a_tcp; if (tcp_latest) tcp_latest->prev_time = a_tcp; tcp_latest = a_tcp; }
void get_now_ts(char *format_str, char *dest, int dest_size) { double_ts_to_str(get_ts(), format_str, dest, dest_size); }
debug_console_simple::~debug_console_simple() { printf("cycles/sec: %f\n", double(n_ticks) / (get_ts() - start_ts)); }
static void tcp_queue(struct tcp_stream * a_tcp, struct tcphdr * this_tcphdr, struct half_stream * snd, struct half_stream * rcv, char *data, int datalen, int skblen ) { u_int this_seq = ntohl(this_tcphdr->th_seq); struct skbuff *pakiet, *tmp; /* * Did we get anything new to ack? */ if (!after(this_seq, EXP_SEQ)) { if (after(this_seq + datalen + (this_tcphdr->th_flags & TH_FIN), EXP_SEQ)) { /* the packet straddles our window end */ get_ts(this_tcphdr, &snd->curr_ts); add_from_skb(a_tcp, rcv, snd, (u_char *)data, datalen, this_seq, (this_tcphdr->th_flags & TH_FIN), (this_tcphdr->th_flags & TH_URG), ntohs(this_tcphdr->th_urp) + this_seq - 1); /* * Do we have any old packets to ack that the above * made visible? (Go forward from skb) */ pakiet = rcv->list; while (pakiet) { if (after(pakiet->seq, EXP_SEQ)) break; if (after(pakiet->seq + pakiet->len + pakiet->fin, EXP_SEQ)) { add_from_skb(a_tcp, rcv, snd, pakiet->data, pakiet->len, pakiet->seq, pakiet->fin, pakiet->urg, pakiet->urg_ptr + pakiet->seq - 1); } rcv->rmem_alloc -= pakiet->truesize; if (pakiet->prev) pakiet->prev->next = pakiet->next; else rcv->list = pakiet->next; if (pakiet->next) pakiet->next->prev = pakiet->prev; else rcv->listtail = pakiet->prev; tmp = pakiet->next; free(pakiet->data); free(pakiet); pakiet = tmp; } } else return; } else { struct skbuff *p = rcv->listtail; pakiet = mknew(struct skbuff); pakiet->truesize = skblen; rcv->rmem_alloc += pakiet->truesize; pakiet->len = datalen; pakiet->data = malloc(datalen); if (!pakiet->data) nids_params.no_mem("tcp_queue"); memcpy(pakiet->data, data, datalen); pakiet->fin = (this_tcphdr->th_flags & TH_FIN); /* Some Cisco - at least - hardware accept to close a TCP connection * even though packets were lost before the first TCP FIN packet and * never retransmitted; this violates RFC 793, but since it really * happens, it has to be dealt with... The idea is to introduce a 10s * timeout after TCP FIN packets were sent by both sides so that * corresponding libnids resources can be released instead of waiting * for retransmissions which will never happen. -- Sebastien Raveau */ if (pakiet->fin) { snd->state = TCP_CLOSING; if (rcv->state == FIN_SENT || rcv->state == FIN_CONFIRMED) add_tcp_closing_timeout(a_tcp); } pakiet->seq = this_seq; pakiet->urg = (this_tcphdr->th_flags & TH_URG); pakiet->urg_ptr = ntohs(this_tcphdr->th_urp); for (;;) { if (!p || !after(p->seq, this_seq)) break; p = p->prev; } if (!p) { pakiet->prev = 0; pakiet->next = rcv->list; if (rcv->list) rcv->list->prev = pakiet; rcv->list = pakiet; if (!rcv->listtail) rcv->listtail = pakiet; } else { pakiet->next = p->next; p->next = pakiet; pakiet->prev = p; if (pakiet->next) pakiet->next->prev = pakiet; else rcv->listtail = pakiet; } } }
static void httplive_mediaproc(void *pArg) { HTTPLIVE_CLIENT_T *pClient = (HTTPLIVE_CLIENT_T *) pArg; int rc = 0; const char *p; const char *puri = NULL; char path[VSX_MAX_PATH_LEN]; pClient->running = 0; LOG(X_DEBUG("Starting HTTPLive client media thread")); path[sizeof(path) - 1] = '\0'; while(rc >= 0 && pClient->pCfg->running == 0 && pClient->insession) { path[0] = '\0'; pthread_mutex_lock(&pClient->mtx); if(pClient->nextidx > pClient->curidx) { LOG(X_WARNING("HTTPLive skipping playlist media chunk index %d - %d"), pClient->curidx, pClient->nextidx - 1); pClient->curidx = pClient->nextidx; //pClient->nextidx++; } if((p = find_path(&pClient->pl, pClient->curidx))) { strncpy(path, p, sizeof(path) - 1); } else { } pthread_mutex_unlock(&pClient->mtx); if(!(puri = get_uri_from_path(pClient, path))) { rc = -1; break; } if(puri && puri[0] != '\0') { // TODO: create httplive retrieval flag forcing new socket... lame if(NETIOSOCK_FD(pClient->netsock) != INVALID_SOCKET && net_issockremotelyclosed(NETIOSOCK_FD(pClient->netsock), 1)) { LOG(X_DEBUG("HTTPLive media socket has been closed")); netio_closesocket(&pClient->netsock); } if(NETIOSOCK_FD(pClient->netsock) == INVALID_SOCKET) { //fprintf(stderr, "----MEDIA GET for '%s' '%s'\n", path, puri); if((rc = httpcli_connect(&pClient->netsock, &pClient->sa, "HTTPLive media thread")) < 0) { break; } } //fprintf(stderr, "may call get_ts puri:'%s', idx:%d, next:%d\n", puri, pClient->curidx, pClient->nextidx); if((rc = get_ts(pClient, puri)) >= 0) { //fprintf(stderr, "HTTPLive ts retrieval '%s' returned %d\n", puri, rc); pthread_mutex_lock(&pClient->mtx); pClient->nextidx++; pClient->curidx = pClient->nextidx; pthread_mutex_unlock(&pClient->mtx); } } // end of if(puri && puri[0] != '\0' ... sleep(1); } netio_closesocket(&pClient->netsock); pClient->insession = 0; pClient->running = -1; LOG(X_DEBUG("HTTPLive media download thread exiting with code %d"), rc); }
void clearContext(void) { ThreadState *ts = get_ts(); ts->current_context = ts->dummy_context; }
void statistics_popup(int f_index, proginfo *cur) { NEWWIN *popup = create_popup(16, 68); const char *title = "Statistics for "; char *abbr_fname = shorten_filename(cur -> filename, 54 - strlen(title)); char buffer[54 + 1]; snprintf(buffer, sizeof(buffer), "%s%s", title, abbr_fname); for(;;) { dtime_t time_running = get_ts() - cur -> statistics.start_ts; time_t start_ts = (time_t)cur -> statistics.start_ts; char *start_ts_str = mystrdup(ctime(&start_ts)); time_t lastevent = (time_t)cur -> statistics.lastevent; char *last_ts_str = mystrdup(ctime(&lastevent)); char *dummy; char *vmsize_str = NULL; char *fsize_str = NULL; char *total_data_processed_str = amount_to_str(cur -> statistics.bytes_processed); char *buffer_kb; off64_t fsize = -1; int c; int total_re = 0; int loop; if (cur -> wt == WT_COMMAND) { vmsize_str = amount_to_str(get_vmsize(cur -> pid)); } else if (cur -> wt == WT_FILE) { (void)file_info(cur -> filename, &fsize, 0, NULL, NULL); fsize_str = amount_to_str(fsize); } dummy = strchr(start_ts_str, '\n'); if (dummy) *dummy = 0x00; dummy = strchr(last_ts_str, '\n'); if (dummy) *dummy = 0x00; werase(popup -> win); win_header(popup, buffer); ui_inverse_on(popup); mvwprintw(popup -> win, 3, 2, "# lines :"); mvwprintw(popup -> win, 3, 27, "#l/s :"); mvwprintw(popup -> win, 3, 44, "Avg len:"); mvwprintw(popup -> win, 4, 2, "Data interval :"); if (cur -> wt == WT_COMMAND) mvwprintw(popup -> win, 5, 2, "VM size :"); else if (cur -> wt == WT_FILE) mvwprintw(popup -> win, 5, 2, "File size :"); mvwprintw(popup -> win, 9, 2, "Data processed:"); mvwprintw(popup -> win, 9, 27, "Bps :"); mvwprintw(popup -> win, 6, 2, "Started at :"); mvwprintw(popup -> win, 7, 2, "Last event :"); mvwprintw(popup -> win, 8, 2, "Next expected@:"); mvwprintw(popup -> win, 10, 2, "# matched r.e.:"); mvwprintw(popup -> win, 11, 2, "Buffered lines:"); mvwprintw(popup -> win, 11, 27, "Bytes:"); mvwprintw(popup -> win, 11, 44, "Limit :"); mvwprintw(popup -> win, 12, 2, "# of beeps: "); if (cur -> wt == WT_COMMAND) { mvwprintw(popup -> win, 13, 2, "Number of runs:"); mvwprintw(popup -> win, 13, 27, "Last rc:"); } ui_inverse_off(popup); mvwprintw(popup -> win, 3, 18, "%d", cur -> statistics.n_events); mvwprintw(popup -> win, 6, 18, "%s", start_ts_str); if (cur -> statistics.lastevent != (dtime_t)0.0) mvwprintw(popup -> win, 7, 18, "%s", last_ts_str); else mvwprintw(popup -> win, 7, 18, "---"); if (cur -> statistics.n_events == 0) { mvwprintw(popup -> win, 4, 18, "Not yet available"); } else { double avg = cur -> statistics.med / (double)cur -> statistics.n_events; double dev = sqrt((cur -> statistics.dev / (double)cur -> statistics.n_events) - pow(avg, 2.0)); /* serial correlation coefficient */ double scct1 = cur -> statistics.scct1 + cur -> statistics.scclast * cur -> statistics.sccu0; double med = cur -> statistics.med * cur -> statistics.med; double scc = (double)cur -> statistics.n_events * cur -> statistics.dev - med; if (scc != 0.0) { scc = ((double)cur -> statistics.n_events * scct1 - med) / scc; mvwprintw(popup -> win, 4, 18, "average: %.2f, std.dev.: %.2f, SCC: %1.6f", avg, dev, scc); } else mvwprintw(popup -> win, 4, 18, "average: %.2f, std.dev.: %.2f, not correlated", avg, dev); if (avg) { double dummy_d = (double)(time(NULL) - cur -> statistics.lastevent) / avg; time_t next_event = cur -> statistics.lastevent + (ceil(dummy_d) * avg); char *ne_str = mystrdup(ctime(&next_event)); char *dummy_str = strchr(ne_str, '\n'); if (dummy_str) *dummy_str = 0x00; mvwprintw(popup -> win, 8, 18, "%s", ne_str); myfree(ne_str); } mvwprintw(popup -> win, 3, 53, "%.1f", (double)cur -> statistics.bytes_processed / (double)cur -> statistics.n_events); } if (cur -> wt == WT_COMMAND) mvwprintw(popup -> win, 5, 18, "%s", vmsize_str); else if (cur -> wt == WT_STDIN || cur -> wt == WT_SOCKET) mvwprintw(popup -> win, 5, 18, "n.a."); else if (cur -> wt == WT_FILE) mvwprintw(popup -> win, 5, 18, "%s", fsize_str); myfree(vmsize_str); myfree(fsize_str); mvwprintw(popup -> win, 9, 18, "%s", total_data_processed_str); myfree(total_data_processed_str); if (time_running > 0) { char *bps_str = amount_to_str((double)cur -> statistics.bytes_processed / (double)time_running); mvwprintw(popup -> win, 9, 34, "%s", bps_str); myfree(bps_str); mvwprintw(popup -> win, 3, 34, "%.4f", (double)cur -> statistics.n_events / (double)time_running); } buffer_kb = amount_to_str(lb[f_index].curbytes); mvwprintw(popup -> win, 11, 18, "%d", lb[f_index].curpos); mvwprintw(popup -> win, 11, 34, "%s", buffer_kb); myfree(buffer_kb); mvwprintw(popup -> win, 12, 18, "%d", cur -> beep.did_n_beeps); escape_print(popup, 14, 2, "Press ^r^ to reset counters, ^q^ to exit"); myfree(start_ts_str); myfree(last_ts_str); for(loop=0; loop<cur -> n_re; loop++) total_re += (cur -> pre)[loop].match_count; if (cur -> statistics.n_events) mvwprintw(popup -> win, 10, 18, "%d (%.2f%%)", total_re, (total_re * 100.0) / (double)cur -> statistics.n_events); else mvwprintw(popup -> win, 10, 18, "%d", total_re); if (cur -> wt == WT_COMMAND) { mvwprintw(popup -> win, 13, 18, "%d", cur -> n_runs); mvwprintw(popup -> win, 13, 36, "%d", cur -> last_exit_rc); } if (lb[f_index].maxnlines > 0) { mvwprintw(popup -> win, 11, 53, "%d lines", lb[f_index].maxnlines); } else if (lb[f_index].maxbytes > 0) { char *str = amount_to_str(lb[f_index].maxbytes); mvwprintw(popup -> win, 11, 53, "%s", str); myfree(str); } draw_border(popup); mydoupdate(); c = toupper(wait_for_keypress(HELP_STATISTICS_POPUP, popup_refresh_interval, popup, 0)); if (c == 'Q' || c == abort_key) { break; } else if (c == 'R') { reset_counters(&cur -> statistics); } else if (c != -1) { wrong_key(); } } delete_popup(popup); }
Context *getContext(void) { return get_ts()->current_context.get(); }
void process_tcp(u_char * data, int skblen) { struct ip *this_iphdr = (struct ip *)data; struct tcphdr *this_tcphdr = (struct tcphdr *)(data + 4 * this_iphdr->ip_hl); int datalen, iplen; int from_client = 1; unsigned int tmp_ts; struct tcp_stream *a_tcp; struct half_stream *snd, *rcv; ugly_iphdr = this_iphdr; iplen = ntohs(this_iphdr->ip_len); if ((unsigned)iplen < 4 * this_iphdr->ip_hl + sizeof(struct tcphdr)) { nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr, this_tcphdr); return; } // ktos sie bawi datalen = iplen - 4 * this_iphdr->ip_hl - 4 * this_tcphdr->th_off; if (datalen < 0) { nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr, this_tcphdr); return; } // ktos sie bawi if ((this_iphdr->ip_src.s_addr | this_iphdr->ip_dst.s_addr) == 0) { nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr, this_tcphdr); return; } if (!(this_tcphdr->th_flags & TH_ACK)) detect_scan(this_iphdr); if (!nids_params.n_tcp_streams) return; /*FIXME: remove the tcp header check function tempor..*/ #ifdef OSPLIT #ifdef CHECK_TCPHDR_DISABLED #if 0 if (my_tcp_check(this_tcphdr, iplen - 4 * this_iphdr->ip_hl, this_iphdr->ip_src.s_addr, this_iphdr->ip_dst.s_addr)) { nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr, this_tcphdr); return; } #endif #else if (my_tcp_check(this_tcphdr, iplen - 4 * this_iphdr->ip_hl, this_iphdr->ip_src.s_addr, this_iphdr->ip_dst.s_addr)) { nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr, this_tcphdr); return; } #endif #endif #if 0 check_flags(this_iphdr, this_tcphdr); //ECN #endif if (!(a_tcp = find_stream(this_tcphdr, this_iphdr, &from_client))) { if ((this_tcphdr->th_flags & TH_SYN) && !(this_tcphdr->th_flags & TH_ACK) && !(this_tcphdr->th_flags & TH_RST)) add_new_tcp(this_tcphdr, this_iphdr); return; } #ifdef OSPLIT struct ipfrag *frag_tag=this_fragments; struct ipfrag *ip_frag_next; if(this_fragments) ip_frag_next=this_fragments->next; /*write all fragment(s) to fp trace file*/ if(is_frag==0) { write_pcap_hdr(a_tcp->fp,(char*)nids_last_pcap_header,sizeof(struct pcap_sf_pkthdr)); write_ip(a_tcp->fp,(char*)this_iphdr,ntohs(this_iphdr->ip_len),(char*)nids_last_pcap_header); } else { /*fragments*/ while(frag_tag!=NULL) { write_pcap_hdr(a_tcp->fp,(char*)(&(frag_tag->pcap_header)),sizeof(struct pcap_sf_pkthdr)); write_ip(a_tcp->fp,(char*)frag_tag->skb->data,frag_tag->wtrace_len,(char*)(&(frag_tag->pcap_header))); free(frag_tag); frag_tag=ip_frag_next; if(ip_frag_next!=NULL) ip_frag_next=ip_frag_next->next; } is_frag=0; } /*set statistic info*/ store_flag=1; #endif if (from_client) { snd = &a_tcp->client; rcv = &a_tcp->server; } else { rcv = &a_tcp->client; snd = &a_tcp->server; } if ((this_tcphdr->th_flags & TH_SYN)) { if (from_client || a_tcp->client.state != TCP_SYN_SENT || a_tcp->server.state != TCP_CLOSE || !(this_tcphdr->th_flags & TH_ACK)) return; if (a_tcp->client.seq != ntohl(this_tcphdr->th_ack)) return; a_tcp->server.state = TCP_SYN_RECV; a_tcp->server.seq = ntohl(this_tcphdr->th_seq) + 1; a_tcp->server.first_data_seq = a_tcp->server.seq; a_tcp->server.ack_seq = ntohl(this_tcphdr->th_ack); a_tcp->server.window = ntohs(this_tcphdr->th_win); if (a_tcp->client.ts_on) { a_tcp->server.ts_on = get_ts(this_tcphdr, &a_tcp->server.curr_ts); if (!a_tcp->server.ts_on) a_tcp->client.ts_on = 0; } else a_tcp->server.ts_on = 0; if (a_tcp->client.wscale_on) { a_tcp->server.wscale_on = get_wscale(this_tcphdr, &a_tcp->server.wscale); if (!a_tcp->server.wscale_on) { a_tcp->client.wscale_on = 0; a_tcp->client.wscale = 1; a_tcp->server.wscale = 1; } } else { a_tcp->server.wscale_on = 0; a_tcp->server.wscale = 1; } return; } if ( ! ( !datalen && ntohl(this_tcphdr->th_seq) == rcv->ack_seq ) && ( !before(ntohl(this_tcphdr->th_seq), rcv->ack_seq + rcv->window*rcv->wscale) || before(ntohl(this_tcphdr->th_seq) + datalen, rcv->ack_seq) ) ) return; if ((this_tcphdr->th_flags & TH_RST)) { if (a_tcp->nids_state == NIDS_DATA) { struct lurker_node *i; a_tcp->nids_state = NIDS_RESET; for (i = a_tcp->listeners; i; i = i->next) (i->item) (a_tcp, &i->data); } nids_free_tcp_stream(a_tcp); return; } /* PAWS check */ if (rcv->ts_on && get_ts(this_tcphdr, &tmp_ts) && before(tmp_ts, snd->curr_ts)) return; if ((this_tcphdr->th_flags & TH_ACK)) { if (from_client && a_tcp->client.state == TCP_SYN_SENT && a_tcp->server.state == TCP_SYN_RECV) { if (ntohl(this_tcphdr->th_ack) == a_tcp->server.seq) { a_tcp->client.state = TCP_ESTABLISHED; a_tcp->client.ack_seq = ntohl(this_tcphdr->th_ack); { struct proc_node *i; struct lurker_node *j; void *data; a_tcp->server.state = TCP_ESTABLISHED; a_tcp->nids_state = NIDS_JUST_EST; for (i = tcp_procs; i; i = i->next) { char whatto = 0; char cc = a_tcp->client.collect; char sc = a_tcp->server.collect; char ccu = a_tcp->client.collect_urg; char scu = a_tcp->server.collect_urg; (i->item) (a_tcp, &data); if (cc < a_tcp->client.collect) whatto |= COLLECT_cc; if (ccu < a_tcp->client.collect_urg) whatto |= COLLECT_ccu; if (sc < a_tcp->server.collect) whatto |= COLLECT_sc; if (scu < a_tcp->server.collect_urg) whatto |= COLLECT_scu; if (nids_params.one_loop_less) { if (a_tcp->client.collect >=2) { a_tcp->client.collect=cc; whatto&=~COLLECT_cc; } if (a_tcp->server.collect >=2 ) { a_tcp->server.collect=sc; whatto&=~COLLECT_sc; } } if (whatto) { j = mknew(struct lurker_node); j->item = i->item; j->data = data; j->whatto = whatto; j->next = a_tcp->listeners; a_tcp->listeners = j; } } #ifdef OSPLIT #if 0 if (!a_tcp->listeners) { nids_free_tcp_stream(a_tcp); return; } #endif #endif a_tcp->nids_state = NIDS_DATA; } } // return; } }