bro_docs.8a82: TCP_Contents class Reference

00247         {
00248         endp = arg_endp;
00249         endp->AddContentsProcessor(this);
00250         t_reassem = new TCP_Reassembler(this, endp->src_addr);
00251         skip_deliveries = 0;
00252         stop_on_gap = arg_stop_on_gap;
00253         did_EOF = 0;
00254         }

00257         {
00258         Unref(t_reassem);
00259         }

00293         {
00294         if ( endp->FIN_cnt > 0 && seq >= endp->FIN_seq )
00295                 // TrimToSeq: FIN_seq - 1
00296                 seq = endp->FIN_seq - 1;
00297 
00298         if ( ! SkippingDeliveries() && ! Conn()->Skipping() &&
00299              ! t_reassem->TrimToSeq(seq) &&
00300              reading_live && endp->state != TCP_PARTIAL && endp->peer->state != TCP_PARTIAL )
00301                 // Only generate these events when reading live; from
00302                 // a trace file, the hole might exist because the
00303                 // file was trimmed while writing it.
00304                 Conn()->Event(ack_above_hole);
00305 
00306         // Check EOF here because t_reassem->LastReassemSeq() may have
00307         // changed after calling TrimToSeq().
00308         CheckEOF();
00309         }

00312         {
00313         if ( ! did_EOF &&
00314              (endp->FIN_cnt > 0 || endp->state == TCP_CLOSED || endp->state == TCP_RESET) &&
00315              (Conn()->Skipping() || skip_deliveries ||
00316               endp->StartSeq() + t_reassem->LastReassemSeq() >= endp->LastSeq() - 1) )
00317                 {
00318                 // We've now delivered all of the data.
00319                 did_EOF = 1;
00320                 Conn()->EndpointEOF(this);
00321                 }
00322         }

00094 { return endp->Conn(); }

00093 { return endp->Conn(); }

00343         {
00344         uint32 delivered_seq = Endpoint()->StartSeq() + DataSeq();
00345 
00346         // We've delivered everything if we're up to the penultimate
00347         // sequence number (since a FIN consumes an octet in the
00348         // sequence space), or right at it (because a RST does not).
00349         if ( delivered_seq != Endpoint()->LastSeq() - 1 &&
00350              delivered_seq != Endpoint()->LastSeq() )
00351                 return 1;
00352 
00353         // If we've sent RST, then we can't send ACKs any more.
00354         if ( Endpoint()->state != TCP_RESET &&
00355              Endpoint()->peer->HasUndeliveredData() )
00356                 return 1;
00357 
00358         return 0;
00359         }

00263         {
00264         if ( skip_deliveries )
00265                 return 0;
00266 
00267         int ack = endp->AckSeq() - endp->StartSeq();
00268         int upper_seq = seq + len;
00269 
00270         if ( seq < ack )
00271                 {
00272                 if ( upper_seq <= ack )
00273                         // We've already delivered this and it's been acked.
00274                         return 0;
00275 
00276                 // We've seen an ack for part of this packet, but not the
00277                 // whole thing.  This can happen when, for example, a previous
00278                 // packet held [a, a+b) and this packet holds [a, a+c) for c>b
00279                 // (which some TCP's will do when retransmitting).  Trim the
00280                 // packet to just the unacked data.
00281                 int amount_acked = ack - seq;
00282                 seq += amount_acked;
00283                 data += amount_acked;
00284                 len -= amount_acked;
00285                 }
00286 
00287         t_reassem->NewBlock(t, seq, len, data);
00288 
00289         return 1;
00290         }

00079 { return t_reassem->LastReassemSeq(); }

00325         {
00326         Conn()->Deliver(endp, t, seq, len, data);
00327         }

00091 { return endp; }

00090 { return endp; }

00076 { return t_reassem->HasBlocks(); }

00096 { return endp->IsOrig(); }

00369         {
00370         SerialInfo serial;
00371         return SerialObj::Serialize(s, &serial, true);
00372         }

00362         {
00363         t_reassem->SetContentsFile(f);
00364         }

00086                 { skip_deliveries = should_skip; }

00084 { return skip_deliveries; }

00330         {
00331         if ( stop_on_gap )
00332                 // No more data will be sent to the reassembler via
00333                 // DataSent, and thus no data will be delivered. Note
00334                 // that it is safe to stop right here because all the data
00335                 // before seq that exists in the trace must have already
00336                 // appeared.
00337                 SetSkipDeliveries(1);
00338 
00339         Conn()->Undelivered(endp, seq, len);
00340         }

00375         {
00376         return (TCP_Contents*) SerialObj::Unserialize(s, SER_TCP_CONTENTS, true);
00377         }


Public Member Functions
	TCP_Contents (TCP_Endpoint *endp, int stop_on_gap=0)
virtual	~TCP_Contents ()
int	DataSent (double t, int seq, int len, const u_char *data)
void	AckReceived (int seq)
void	CheckEOF ()
int	HasUndeliveredData () const
int	DataPending () const
void	MatchUndeliveredData ()
int	DataSeq () const
virtual void	Deliver (double t, int seq, int len, u_char *data)
virtual void	Undelivered (int seq, int len)
int	SkippingDeliveries () const
void	SetSkipDeliveries (int should_skip)
void	SetContentsFile (BroFile *f)
TCP_Endpoint *	Endpoint ()
const TCP_Endpoint *	Endpoint () const
TCP_Connection *	Conn ()
const TCP_Connection *	Conn () const
int	IsOrig () const
bool	Serialize (Serializer *s) const
Static Public Member Functions
TCP_Contents *	Unserialize (Serializer *ser)
Protected Member Functions
	TCP_Contents ()
Protected Attributes
TCP_Endpoint *	endp
TCP_Reassembler *	t_reassem
unsigned int	skip_deliveries:1
unsigned int	stop_on_gap:1
unsigned int	did_EOF:1

TCP_Contents Class Reference

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation