Mirror/zeek
1
0
Fork 0
mirror of https://github.com/zeek/zeek.git synced 2025-10-02 14:48:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Deprecate the internal int/uint types in favor of the cstdint types they were based on

Browse source
This commit is contained in:
Tim Wojtulewicz 2019-07-30 11:38:42 -07:00
parent 18e4976c6c
commit 54752ef9a1
218 changed files with 1331 additions and 1323 deletions
Download patch file Download diff file Expand all files Collapse all files

88
src/analyzer/protocol/tcp/TCP.cc
View file

@ -232,7 +232,7 @@ const struct tcphdr* TCP_Analyzer::ExtractTCP_Header(const u_char*& data,
int& len, int& caplen)
{
const struct tcphdr* tp = (const struct tcphdr*) data;
uint32 tcp_hdr_len = tp->th_off * 4;
uint32_t tcp_hdr_len = tp->th_off * 4;
if ( tcp_hdr_len < sizeof(struct tcphdr) )
{
@ -240,8 +240,8 @@ const struct tcphdr* TCP_Analyzer::ExtractTCP_Header(const u_char*& data,
return 0;
}
if ( tcp_hdr_len > uint32(len) ||
tcp_hdr_len > uint32(caplen) )
if ( tcp_hdr_len > uint32_t(len) ||
tcp_hdr_len > uint32_t(caplen) )
{
// This can happen even with the above test, due to TCP
// options.
@ -285,7 +285,7 @@ void TCP_Analyzer::SetPartialStatus(TCP_Flags flags, bool is_orig)
}
static void update_history(TCP_Flags flags, TCP_Endpoint* endpoint,
uint64 rel_seq, int len)
uint64_t rel_seq, int len)
{
int bits_set = (flags.SYN() ? 1 : 0) + (flags.FIN() ? 1 : 0) +
(flags.RST() ? 1 : 0);
@ -343,8 +343,8 @@ static void update_history(TCP_Flags flags, TCP_Endpoint* endpoint,
}
static void init_window(TCP_Endpoint* endpoint, TCP_Endpoint* peer,
TCP_Flags flags, bro_int_t scale, uint32 base_seq,
uint32 ack_seq)
TCP_Flags flags, bro_int_t scale, uint32_t base_seq,
uint32_t ack_seq)
{
// ### In the following, we could be fooled by an
// inconsistent SYN retransmission. Where's a normalizer
@ -381,7 +381,7 @@ static void init_window(TCP_Endpoint* endpoint, TCP_Endpoint* peer,
}
static void update_window(TCP_Endpoint* endpoint, unsigned int window,
uint32 base_seq, uint32 ack_seq, TCP_Flags flags)
uint32_t base_seq, uint32_t ack_seq, TCP_Flags flags)
{
// Note, applying scaling here would be incorrect for an initial SYN,
// whose window value is always unscaled. However, we don't
@ -421,9 +421,9 @@ static void update_window(TCP_Endpoint* endpoint, unsigned int window,
if ( seq_delta(base_seq, endpoint->window_seq) >= 0 &&
seq_delta(ack_seq, endpoint->window_ack_seq) >= 0 )
{
uint32 new_edge = ack_seq + window;
uint32 old_edge = endpoint->window_ack_seq + endpoint->window;
int32 advance = seq_delta(new_edge, old_edge);
uint32_t new_edge = ack_seq + window;
uint32_t old_edge = endpoint->window_ack_seq + endpoint->window;
int32_t advance = seq_delta(new_edge, old_edge);
if ( advance < 0 )
{
@ -461,7 +461,7 @@ static void syn_weirds(TCP_Flags flags, TCP_Endpoint* endpoint, int data_len)
void TCP_Analyzer::UpdateInactiveState(double t,
TCP_Endpoint* endpoint, TCP_Endpoint* peer,
uint32 base_seq, uint32 ack_seq,
uint32_t base_seq, uint32_t ack_seq,
int len, int is_orig, TCP_Flags flags,
int& do_close, int& gen_event)
{
@ -683,7 +683,7 @@ void TCP_Analyzer::UpdateEstablishedState(
}
void TCP_Analyzer::UpdateClosedState(double t, TCP_Endpoint* endpoint,
int32 delta_last, TCP_Flags flags, int& do_close)
int32_t delta_last, TCP_Flags flags, int& do_close)
{
if ( flags.SYN() )
Weird("SYN_after_close");
@ -728,8 +728,8 @@ void TCP_Analyzer::UpdateResetState(int len, TCP_Flags flags)
void TCP_Analyzer::UpdateStateMachine(double t,
TCP_Endpoint* endpoint, TCP_Endpoint* peer,
uint32 base_seq, uint32 ack_seq,
int len, int32 delta_last, int is_orig, TCP_Flags flags,
uint32_t base_seq, uint32_t ack_seq,
int len, int32_t delta_last, int is_orig, TCP_Flags flags,
int& do_close, int& gen_event)
{
do_close = 0; // whether to report the connection as closed
@ -765,7 +765,7 @@ void TCP_Analyzer::UpdateStateMachine(double t,
}
void TCP_Analyzer::GeneratePacketEvent(
uint64 rel_seq, uint64 rel_ack,
uint64_t rel_seq, uint64_t rel_ack,
const u_char* data, int len, int caplen,
int is_orig, TCP_Flags flags)
{
@ -784,7 +784,7 @@ void TCP_Analyzer::GeneratePacketEvent(
int TCP_Analyzer::DeliverData(double t, const u_char* data, int len, int caplen,
const IP_Hdr* ip, const struct tcphdr* tp,
TCP_Endpoint* endpoint, uint64 rel_data_seq,
TCP_Endpoint* endpoint, uint64_t rel_data_seq,
int is_orig, TCP_Flags flags)
{
return endpoint->DataSent(t, rel_data_seq, len, caplen, data, ip, tp);
@ -820,11 +820,11 @@ void TCP_Analyzer::CheckPIA_FirstPacket(int is_orig, const IP_Hdr* ip)
}
}
uint64 TCP_Analyzer::get_relative_seq(const TCP_Endpoint* endpoint,
uint32 cur_base, uint32 last,
uint32 wraps, bool* underflow)
uint64_t TCP_Analyzer::get_relative_seq(const TCP_Endpoint* endpoint,
uint32_t cur_base, uint32_t last,
uint32_t wraps, bool* underflow)
{
int32 delta = seq_delta(cur_base, last);
int32_t delta = seq_delta(cur_base, last);
if ( delta < 0 )
{
@ -875,7 +875,7 @@ int TCP_Analyzer::get_segment_len(int payload_len, TCP_Flags flags)
}
static void init_endpoint(TCP_Endpoint* endpoint, TCP_Flags flags,
uint32 first_seg_seq, uint32 last_seq, double t)
uint32_t first_seg_seq, uint32_t last_seq, double t)
{
switch ( endpoint->state ) {
case TCP_ENDPOINT_INACTIVE:
@ -951,7 +951,7 @@ static void init_endpoint(TCP_Endpoint* endpoint, TCP_Flags flags,
}
static void init_peer(TCP_Endpoint* peer, TCP_Endpoint* endpoint,
TCP_Flags flags, uint32 ack_seq)
TCP_Flags flags, uint32_t ack_seq)
{
if ( ! flags.SYN() && ! flags.FIN() && ! flags.RST() )
{
@ -976,9 +976,9 @@ static void init_peer(TCP_Endpoint* peer, TCP_Endpoint* endpoint,
peer->InitLastSeq(ack_seq - 1);
}
static void update_ack_seq(TCP_Endpoint* endpoint, uint32 ack_seq)
static void update_ack_seq(TCP_Endpoint* endpoint, uint32_t ack_seq)
{
int32 delta_ack = seq_delta(ack_seq, endpoint->AckSeq());
int32_t delta_ack = seq_delta(ack_seq, endpoint->AckSeq());
if ( ack_seq == 0 && delta_ack > TOO_LARGE_SEQ_DELTA )
// More likely that this is a broken ack than a
@ -991,10 +991,10 @@ static void update_ack_seq(TCP_Endpoint* endpoint, uint32 ack_seq)
// Returns the difference between last_seq and the last sequence
// seen by the endpoint (may be negative).
static int32 update_last_seq(TCP_Endpoint* endpoint, uint32 last_seq,
static int32_t update_last_seq(TCP_Endpoint* endpoint, uint32_t last_seq,
TCP_Flags flags, int len)
{
int32 delta_last = seq_delta(last_seq, endpoint->LastSeq());
int32_t delta_last = seq_delta(last_seq, endpoint->LastSeq());
if ( (flags.SYN() || flags.RST()) &&
(delta_last > TOO_LARGE_SEQ_DELTA ||
@ -1028,7 +1028,7 @@ static int32 update_last_seq(TCP_Endpoint* endpoint, uint32 last_seq,
}
void TCP_Analyzer::DeliverPacket(int len, const u_char* data, bool is_orig,
uint64 seq, const IP_Hdr* ip, int caplen)
uint64_t seq, const IP_Hdr* ip, int caplen)
{
TransportLayerAnalyzer::DeliverPacket(len, data, orig, seq, ip, caplen);
@ -1047,21 +1047,21 @@ void TCP_Analyzer::DeliverPacket(int len, const u_char* data, bool is_orig,
if ( ! ValidateChecksum(tp, endpoint, len, caplen) )
return;
uint32 tcp_hdr_len = data - (const u_char*) tp;
uint32_t tcp_hdr_len = data - (const u_char*) tp;
TCP_Flags flags(tp);
SetPartialStatus(flags, endpoint->IsOrig());
uint32 base_seq = ntohl(tp->th_seq);
uint32 ack_seq = ntohl(tp->th_ack);
uint32_t base_seq = ntohl(tp->th_seq);
uint32_t ack_seq = ntohl(tp->th_ack);
int seg_len = get_segment_len(len, flags);
uint32 seq_one_past_segment = base_seq + seg_len;
uint32_t seq_one_past_segment = base_seq + seg_len;
init_endpoint(endpoint, flags, base_seq, seq_one_past_segment,
current_timestamp);
bool seq_underflow = false;
uint64 rel_seq = get_relative_seq(endpoint, base_seq, endpoint->LastSeq(),
uint64_t rel_seq = get_relative_seq(endpoint, base_seq, endpoint->LastSeq(),
endpoint->SeqWraps(), &seq_underflow);
if ( seq_underflow && ! flags.RST() )
@ -1122,7 +1122,7 @@ void TCP_Analyzer::DeliverPacket(int len, const u_char* data, bool is_orig,
PacketWithRST();
}
uint64 rel_ack = 0;
uint64_t rel_ack = 0;
if ( flags.ACK() )
{
@ -1156,7 +1156,7 @@ void TCP_Analyzer::DeliverPacket(int len, const u_char* data, bool is_orig,
}
}
int32 delta_last = update_last_seq(endpoint, seq_one_past_segment, flags, len);
int32_t delta_last = update_last_seq(endpoint, seq_one_past_segment, flags, len);
endpoint->last_time = current_timestamp;
int do_close;
@ -1178,7 +1178,7 @@ void TCP_Analyzer::DeliverPacket(int len, const u_char* data, bool is_orig,
flags);
if ( tcp_option && tcp_hdr_len > sizeof(*tp) &&
tcp_hdr_len <= uint32(caplen) )
tcp_hdr_len <= uint32_t(caplen) )
ParseTCPOptions(tp, TCPOptionEvent, this, is_orig, 0);
if ( DEBUG_tcp_data_sent )
@ -1187,7 +1187,7 @@ void TCP_Analyzer::DeliverPacket(int len, const u_char* data, bool is_orig,
network_time, len, caplen, Skipping());
}
uint64 rel_data_seq = flags.SYN() ? rel_seq + 1 : rel_seq;
uint64_t rel_data_seq = flags.SYN() ? rel_seq + 1 : rel_seq;
int need_contents = 0;
if ( len > 0 && (caplen >= len || packet_children.size()) &&
@ -1223,7 +1223,7 @@ void TCP_Analyzer::DeliverStream(int len, const u_char* data, bool orig)
Analyzer::DeliverStream(len, data, orig);
}
void TCP_Analyzer::Undelivered(uint64 seq, int len, bool is_orig)
void TCP_Analyzer::Undelivered(uint64_t seq, int len, bool is_orig)
{
Analyzer::Undelivered(seq, len, orig);
}
@ -1692,7 +1692,7 @@ bool TCP_Analyzer::IsReuse(double t, const u_char* pkt)
if ( ! IsClosed() )
{
uint32 base_seq = ntohl(tp->th_seq);
uint32_t base_seq = ntohl(tp->th_seq);
if ( base_seq == conn_orig->StartSeq() )
return false;
@ -1753,7 +1753,7 @@ void TCP_ApplicationAnalyzer::ProtocolViolation(const char* reason,
}
void TCP_ApplicationAnalyzer::DeliverPacket(int len, const u_char* data,
bool is_orig, uint64 seq,
bool is_orig, uint64_t seq,
const IP_Hdr* ip, int caplen)
{
Analyzer::DeliverPacket(len, data, is_orig, seq, ip, caplen);
@ -1834,7 +1834,7 @@ int endian_flip(int n)
return ((n & 0xff) << 8) | ((n & 0xff00) >> 8);
}
int TCPStats_Endpoint::DataSent(double /* t */, uint64 seq, int len, int caplen,
int TCPStats_Endpoint::DataSent(double /* t */, uint64_t seq, int len, int caplen,
const u_char* /* data */,
const IP_Hdr* ip, const struct tcphdr* /* tp */)
{
@ -1894,13 +1894,13 @@ int TCPStats_Endpoint::DataSent(double /* t */, uint64 seq, int len, int caplen,
++num_in_order;
uint64 top_seq = seq + len;
uint64_t top_seq = seq + len;
int32 data_in_flight = seq_delta(endp->LastSeq(), endp->AckSeq());
int32_t data_in_flight = seq_delta(endp->LastSeq(), endp->AckSeq());
if ( data_in_flight < 0 )
data_in_flight = 0;
int64 sequence_delta = top_seq - max_top_seq;
int64_t sequence_delta = top_seq - max_top_seq;
if ( sequence_delta <= 0 )
{
if ( ! BifConst::ignore_keep_alive_rexmit || len > 1 || data_in_flight > 0 )
@ -1977,7 +1977,7 @@ void TCPStats_Analyzer::Done()
});
}
void TCPStats_Analyzer::DeliverPacket(int len, const u_char* data, bool is_orig, uint64 seq, const IP_Hdr* ip, int caplen)
void TCPStats_Analyzer::DeliverPacket(int len, const u_char* data, bool is_orig, uint64_t seq, const IP_Hdr* ip, int caplen)
{
TCP_ApplicationAnalyzer::DeliverPacket(len, data, is_orig, seq, ip, caplen);