void OSGDebugDrawInterface::AddAxes(const dtEntity::Matrix& m, const dtEntity::Vec4f& color,
float size, float duration, bool depthTestEnabled)
{
float arroww = 0.1f;
osg::Vec3 p0(0, 0, 0);
osg::Vec3 p1(0, 0, 1);
osg::Vec3 p2(0, 1, 0);
osg::Vec3 p3(1, 0, 0);
osg::Vec3 p1a(arroww, 0, 1 - arroww);
osg::Vec3 p1b(-arroww, 0, 1 - arroww);
osg::Vec3 p2a(arroww, 1 - arroww, 0);
osg::Vec3 p2b(-arroww, 1 - arroww, 0);
osg::Vec3 p3a(1 - arroww, 0, arroww);
osg::Vec3 p3b(1 - arroww, 0, -arroww);
std::vector<osg::Vec3> lines(18);
lines[0] = m * p0; lines[1] = m * p1;
lines[2] = m * p0; lines[3] = m * p2;
lines[4] = m * p0; lines[5] = m * p3;
lines[6] = m * p1; lines[7] = m * p1a;
lines[8] = m * p1; lines[9] = m * p1b;
lines[10] = m * p2; lines[11] = m * p2a;
lines[12] = m * p2; lines[13] = m * p2b;
lines[14] = m * p3; lines[15] = m * p3a;
lines[16] = m * p3; lines[17] = m * p3b;
AddLines(lines, color, size, duration, depthTestEnabled);
}
QPolygonF UBGeometryUtils::lineToPolygon(const QPointF& pStart, const QPointF& pEnd,
const qreal& pStartWidth, const qreal& pEndWidth)
{
qreal x1 = pStart.x();
qreal y1 = pStart.y();
qreal x2 = pEnd.x();
qreal y2 = pEnd.y();
QLineF line(pStart, pEnd);
qreal alpha = (90.0 - line.angle()) * PI / 180.0;
qreal hypothenuseStart = pStartWidth / 2;
qreal hypothenuseEnd = pEndWidth / 2;
qreal sinAlpha = sin(alpha);
qreal cosAlpha = cos(alpha);
// TODO UB 4.x PERF cache sin/cos table
qreal oppositeStart = sinAlpha * hypothenuseStart;
qreal adjacentStart = cosAlpha * hypothenuseStart;
QPointF p1a(x1 - adjacentStart, y1 - oppositeStart);
QPointF p1b(x1 + adjacentStart, y1 + oppositeStart);
qreal oppositeEnd = sinAlpha * hypothenuseEnd;
qreal adjacentEnd = cosAlpha * hypothenuseEnd;
QPointF p2a(x2 - adjacentEnd, y2 - oppositeEnd);
QPainterPath painterPath;
painterPath.moveTo(p1a);
painterPath.lineTo(p2a);
painterPath.arcTo(x2 - hypothenuseEnd, y2 - hypothenuseEnd, pEndWidth, pEndWidth, (90.0 + line.angle()), -180.0);
painterPath.lineTo(p1b);
painterPath.arcTo(x1 - hypothenuseStart, y1 - hypothenuseStart, pStartWidth, pStartWidth, -1 * (90.0 - line.angle()), -180.0);
painterPath.closeSubpath();
return painterPath.toFillPolygon();
}
int mossa(int numero1, int numero2, int giocatore)
{
int risultato;
if(giocatore==1)
{
risultato = p1a(numero1, numero2);
risultato = p1b(risultato);
}
else
{
risultato = p2a(numero1, numero2);
risultato = p2b(risultato);
}
giocatore=3-giocatore;
if(decodifica1(risultato)<3 || decodifica2(risultato)<3)
return giocatore;
return mossa(decodifica1(risultato), decodifica2(risultato), giocatore);
}
QPolygonF UBGeometryUtils::lineToPolygon(const QLineF& pLine, const qreal& pWidth)
{
qreal x1 = pLine.x1();
qreal y1 = pLine.y1();
qreal x2 = pLine.x2();
qreal y2 = pLine.y2();
qreal alpha = (90.0 - pLine.angle()) * PI / 180.0;
qreal hypothenuse = pWidth / 2;
// TODO UB 4.x PERF cache sin/cos table
qreal opposite = sin(alpha) * hypothenuse;
qreal adjacent = cos(alpha) * hypothenuse;
QPointF p1a(x1 - adjacent, y1 - opposite);
QPointF p1b(x1 + adjacent, y1 + opposite);
QPointF p2a(x2 - adjacent, y2 - opposite);
QPointF p2b(x2 + adjacent, y2 + opposite);
QPainterPath painterPath;
painterPath.moveTo(p1a);
painterPath.lineTo(p2a);
painterPath.arcTo(x2 - hypothenuse, y2 - hypothenuse, pWidth, pWidth, (90.0 + pLine.angle()), -180.0);
//painterPath.lineTo(p2b);
painterPath.lineTo(p1b);
painterPath.arcTo(x1 - hypothenuse, y1 - hypothenuse, pWidth, pWidth, -1 * (90.0 - pLine.angle()), -180.0);
painterPath.closeSubpath();
return painterPath.toFillPolygon();
}
/*
* Dump TCP statistics structure.
*/
void
tcp_stats(char *name)
{
struct tcpstat tcpstat;
int mib[] = { CTL_NET, PF_INET, IPPROTO_TCP, TCPCTL_STATS };
size_t len = sizeof(tcpstat);
if (sysctl(mib, sizeof(mib) / sizeof(mib[0]),
&tcpstat, &len, NULL, 0) == -1) {
if (errno != ENOPROTOOPT)
warn("%s", name);
return;
}
printf("%s:\n", name);
#define p(f, m) if (tcpstat.f || sflag <= 1) \
printf(m, tcpstat.f, plural(tcpstat.f))
#define p1(f, m) if (tcpstat.f || sflag <= 1) \
printf(m, tcpstat.f)
#define p2(f1, f2, m) if (tcpstat.f1 || tcpstat.f2 || sflag <= 1) \
printf(m, tcpstat.f1, plural(tcpstat.f1), tcpstat.f2, plural(tcpstat.f2))
#define p2a(f1, f2, m) if (tcpstat.f1 || tcpstat.f2 || sflag <= 1) \
printf(m, tcpstat.f1, plural(tcpstat.f1), tcpstat.f2)
#define p3(f, m) if (tcpstat.f || sflag <= 1) \
printf(m, tcpstat.f, plurales(tcpstat.f))
p(tcps_sndtotal, "\t%u packet%s sent\n");
p2(tcps_sndpack,tcps_sndbyte,
"\t\t%u data packet%s (%qd byte%s)\n");
p2(tcps_sndrexmitpack, tcps_sndrexmitbyte,
"\t\t%u data packet%s (%qd byte%s) retransmitted\n");
p(tcps_sndrexmitfast, "\t\t%qd fast retransmitted packet%s\n");
p2a(tcps_sndacks, tcps_delack,
"\t\t%u ack-only packet%s (%u delayed)\n");
p(tcps_sndurg, "\t\t%u URG only packet%s\n");
p(tcps_sndprobe, "\t\t%u window probe packet%s\n");
p(tcps_sndwinup, "\t\t%u window update packet%s\n");
p(tcps_sndctrl, "\t\t%u control packet%s\n");
p(tcps_outswcsum, "\t\t%u packet%s software-checksummed\n");
p(tcps_rcvtotal, "\t%u packet%s received\n");
p2(tcps_rcvackpack, tcps_rcvackbyte, "\t\t%u ack%s (for %qd byte%s)\n");
p(tcps_rcvdupack, "\t\t%u duplicate ack%s\n");
p(tcps_rcvacktoomuch, "\t\t%u ack%s for unsent data\n");
p(tcps_rcvacktooold, "\t\t%u ack%s for old data\n");
p2(tcps_rcvpack, tcps_rcvbyte,
"\t\t%u packet%s (%qu byte%s) received in-sequence\n");
p2(tcps_rcvduppack, tcps_rcvdupbyte,
"\t\t%u completely duplicate packet%s (%qd byte%s)\n");
p(tcps_pawsdrop, "\t\t%u old duplicate packet%s\n");
p2(tcps_rcvpartduppack, tcps_rcvpartdupbyte,
"\t\t%u packet%s with some duplicate data (%qd byte%s duplicated)\n");
p2(tcps_rcvoopack, tcps_rcvoobyte,
"\t\t%u out-of-order packet%s (%qd byte%s)\n");
p2(tcps_rcvpackafterwin, tcps_rcvbyteafterwin,
"\t\t%u packet%s (%qd byte%s) of data after window\n");
p(tcps_rcvwinprobe, "\t\t%u window probe%s\n");
p(tcps_rcvwinupd, "\t\t%u window update packet%s\n");
p(tcps_rcvafterclose, "\t\t%u packet%s received after close\n");
p(tcps_rcvbadsum, "\t\t%u discarded for bad checksum%s\n");
p(tcps_rcvbadoff, "\t\t%u discarded for bad header offset field%s\n");
p1(tcps_rcvshort, "\t\t%u discarded because packet too short\n");
p1(tcps_rcvnosec, "\t\t%u discarded for missing IPsec protection\n");
p1(tcps_rcvmemdrop, "\t\t%u discarded due to memory shortage\n");
p(tcps_inswcsum, "\t\t%u packet%s software-checksummed\n");
p(tcps_rcvbadsig, "\t\t%u bad/missing md5 checksum%s\n");
p(tcps_rcvgoodsig, "\t\t%qd good md5 checksum%s\n");
p(tcps_connattempt, "\t%u connection request%s\n");
p(tcps_accepts, "\t%u connection accept%s\n");
p(tcps_connects, "\t%u connection%s established (including accepts)\n");
p2(tcps_closed, tcps_drops,
"\t%u connection%s closed (including %u drop%s)\n");
p(tcps_conndrained, "\t%qd connection%s drained\n");
p(tcps_conndrops, "\t%u embryonic connection%s dropped\n");
p2(tcps_rttupdated, tcps_segstimed,
"\t%u segment%s updated rtt (of %u attempt%s)\n");
p(tcps_rexmttimeo, "\t%u retransmit timeout%s\n");
p(tcps_timeoutdrop, "\t\t%u connection%s dropped by rexmit timeout\n");
p(tcps_persisttimeo, "\t%u persist timeout%s\n");
p(tcps_keeptimeo, "\t%u keepalive timeout%s\n");
p(tcps_keepprobe, "\t\t%u keepalive probe%s sent\n");
p(tcps_keepdrops, "\t\t%u connection%s dropped by keepalive\n");
p(tcps_predack, "\t%u correct ACK header prediction%s\n");
p(tcps_preddat, "\t%u correct data packet header prediction%s\n");
p3(tcps_pcbhashmiss, "\t%u PCB cache miss%s\n");
p(tcps_ecn_accepts, "\t%u ECN connection%s accepted\n");
p(tcps_ecn_rcvece, "\t\t%u ECE packet%s received\n");
p(tcps_ecn_rcvcwr, "\t\t%u CWR packet%s received\n");
p(tcps_ecn_rcvce, "\t\t%u CE packet%s received\n");
p(tcps_ecn_sndect, "\t\t%u ECT packet%s sent\n");
p(tcps_ecn_sndece, "\t\t%u ECE packet%s sent\n");
p(tcps_ecn_sndcwr, "\t\t%u CWR packet%s sent\n");
p1(tcps_cwr_frecovery, "\t\t\tcwr by fastrecovery: %u\n");
p1(tcps_cwr_timeout, "\t\t\tcwr by timeout: %u\n");
p1(tcps_cwr_ecn, "\t\t\tcwr by ecn: %u\n");
p(tcps_badsyn, "\t%u bad connection attempt%s\n");
p1(tcps_sc_added, "\t%qd SYN cache entries added\n");
p(tcps_sc_collisions, "\t\t%qd hash collision%s\n");
p1(tcps_sc_completed, "\t\t%qd completed\n");
p1(tcps_sc_aborted, "\t\t%qd aborted (no space to build PCB)\n");
p1(tcps_sc_timed_out, "\t\t%qd timed out\n");
p1(tcps_sc_overflowed, "\t\t%qd dropped due to overflow\n");
p1(tcps_sc_bucketoverflow, "\t\t%qd dropped due to bucket overflow\n");
p1(tcps_sc_reset, "\t\t%qd dropped due to RST\n");
p1(tcps_sc_unreach, "\t\t%qd dropped due to ICMP unreachable\n");
p(tcps_sc_retransmitted, "\t%qd SYN,ACK%s retransmitted\n");
p(tcps_sc_dupesyn, "\t%qd duplicate SYN%s received for entries "
"already in the cache\n");
p(tcps_sc_dropped, "\t%qd SYN%s dropped (no route or no space)\n");
p(tcps_sack_recovery_episode, "\t%qd SACK recovery episode%s\n");
p(tcps_sack_rexmits,
"\t\t%qd segment rexmit%s in SACK recovery episodes\n");
p(tcps_sack_rexmit_bytes,
"\t\t%qd byte rexmit%s in SACK recovery episodes\n");
p(tcps_sack_rcv_opts,
"\t%qd SACK option%s received\n");
p(tcps_sack_snd_opts, "\t%qd SACK option%s sent\n");
#undef p
#undef p1
#undef p2
#undef p2a
#undef p3
}
/*
* Dump TCP statistics structure.
*/
void
tcp_stats(u_long off, const char *name, int af1 __unused, int proto __unused)
{
struct tcpstat tcpstat;
uint64_t tcps_states[TCP_NSTATES];
#ifdef INET6
if (tcp_done != 0)
return;
else
tcp_done = 1;
#endif
if (fetch_stats("net.inet.tcp.stats", off, &tcpstat,
sizeof(tcpstat), kread_counters) != 0)
return;
if (fetch_stats_ro("net.inet.tcp.states", nl[N_TCPS_STATES].n_value,
&tcps_states, sizeof(tcps_states), kread_counters) != 0)
return;
xo_open_container("tcp");
xo_emit("{T:/%s}:\n", name);
#define p(f, m) if (tcpstat.f || sflag <= 1) \
xo_emit(m, (uintmax_t )tcpstat.f, plural(tcpstat.f))
#define p1a(f, m) if (tcpstat.f || sflag <= 1) \
xo_emit(m, (uintmax_t )tcpstat.f)
#define p2(f1, f2, m) if (tcpstat.f1 || tcpstat.f2 || sflag <= 1) \
xo_emit(m, (uintmax_t )tcpstat.f1, plural(tcpstat.f1), \
(uintmax_t )tcpstat.f2, plural(tcpstat.f2))
#define p2a(f1, f2, m) if (tcpstat.f1 || tcpstat.f2 || sflag <= 1) \
xo_emit(m, (uintmax_t )tcpstat.f1, plural(tcpstat.f1), \
(uintmax_t )tcpstat.f2)
#define p3(f, m) if (tcpstat.f || sflag <= 1) \
xo_emit(m, (uintmax_t )tcpstat.f, pluralies(tcpstat.f))
p(tcps_sndtotal, "\t{:sent-packets/%ju} {N:/packet%s sent}\n");
p2(tcps_sndpack,tcps_sndbyte, "\t\t{:sent-data-packets/%ju} "
"{N:/data packet%s} ({:sent-data-bytes/%ju} {N:/byte%s})\n");
p2(tcps_sndrexmitpack, tcps_sndrexmitbyte, "\t\t"
"{:sent-retransmitted-packets/%ju} {N:/data packet%s} "
"({:sent-retransmitted-bytes/%ju} {N:/byte%s}) "
"{N:retransmitted}\n");
p(tcps_sndrexmitbad, "\t\t"
"{:sent-unnecessary-retransmitted-packets/%ju} "
"{N:/data packet%s unnecessarily retransmitted}\n");
p(tcps_mturesent, "\t\t{:sent-resends-by-mtu-discovery/%ju} "
"{N:/resend%s initiated by MTU discovery}\n");
p2a(tcps_sndacks, tcps_delack, "\t\t{:sent-ack-only-packets/%ju} "
"{N:/ack-only packet%s/} ({:sent-packets-delayed/%ju} "
"{N:delayed})\n");
p(tcps_sndurg, "\t\t{:sent-urg-only-packets/%ju} "
"{N:/URG only packet%s}\n");
p(tcps_sndprobe, "\t\t{:sent-window-probe-packets/%ju} "
"{N:/window probe packet%s}\n");
p(tcps_sndwinup, "\t\t{:sent-window-update-packets/%ju} "
"{N:/window update packet%s}\n");
p(tcps_sndctrl, "\t\t{:sent-control-packets/%ju} "
"{N:/control packet%s}\n");
p(tcps_rcvtotal, "\t{:received-packets/%ju} "
"{N:/packet%s received}\n");
p2(tcps_rcvackpack, tcps_rcvackbyte, "\t\t"
"{:received-ack-packets/%ju} {N:/ack%s} "
"{N:(for} {:received-ack-bytes/%ju} {N:/byte%s})\n");
p(tcps_rcvdupack, "\t\t{:received-duplicate-acks/%ju} "
"{N:/duplicate ack%s}\n");
p(tcps_rcvacktoomuch, "\t\t{:received-acks-for-unsent-data/%ju} "
"{N:/ack%s for unsent data}\n");
p2(tcps_rcvpack, tcps_rcvbyte, "\t\t"
"{:received-in-sequence-packets/%ju} {N:/packet%s} "
"({:received-in-sequence-bytes/%ju} {N:/byte%s}) "
"{N:received in-sequence}\n");
p2(tcps_rcvduppack, tcps_rcvdupbyte, "\t\t"
"{:received-completely-duplicate-packets/%ju} "
"{N:/completely duplicate packet%s} "
"({:received-completely-duplicate-bytes/%ju} {N:/byte%s})\n");
p(tcps_pawsdrop, "\t\t{:received-old-duplicate-packets/%ju} "
"{N:/old duplicate packet%s}\n");
p2(tcps_rcvpartduppack, tcps_rcvpartdupbyte, "\t\t"
"{:received-some-duplicate-packets/%ju} "
"{N:/packet%s with some dup. data} "
"({:received-some-duplicate-bytes/%ju} {N:/byte%s duped/})\n");
p2(tcps_rcvoopack, tcps_rcvoobyte, "\t\t{:received-out-of-order/%ju} "
"{N:/out-of-order packet%s} "
"({:received-out-of-order-bytes/%ju} {N:/byte%s})\n");
p2(tcps_rcvpackafterwin, tcps_rcvbyteafterwin, "\t\t"
"{:received-after-window-packets/%ju} {N:/packet%s} "
"({:received-after-window-bytes/%ju} {N:/byte%s}) "
"{N:of data after window}\n");
p(tcps_rcvwinprobe, "\t\t{:received-window-probes/%ju} "
"{N:/window probe%s}\n");
p(tcps_rcvwinupd, "\t\t{:receive-window-update-packets/%ju} "
"{N:/window update packet%s}\n");
p(tcps_rcvafterclose, "\t\t{:received-after-close-packets/%ju} "
"{N:/packet%s received after close}\n");
p(tcps_rcvbadsum, "\t\t{:discard-bad-checksum/%ju} "
"{N:/discarded for bad checksum%s}\n");
p(tcps_rcvbadoff, "\t\t{:discard-bad-header-offset/%ju} "
"{N:/discarded for bad header offset field%s}\n");
p1a(tcps_rcvshort, "\t\t{:discard-too-short/%ju} "
"{N:discarded because packet too short}\n");
p1a(tcps_rcvmemdrop, "\t\t{:discard-memory-problems/%ju} "
"{N:discarded due to memory problems}\n");
p(tcps_connattempt, "\t{:connection-requests/%ju} "
"{N:/connection request%s}\n");
p(tcps_accepts, "\t{:connections-accepts/%ju} "
"{N:/connection accept%s}\n");
p(tcps_badsyn, "\t{:bad-connection-attempts/%ju} "
"{N:/bad connection attempt%s}\n");
p(tcps_listendrop, "\t{:listen-queue-overflows/%ju} "
"{N:/listen queue overflow%s}\n");
p(tcps_badrst, "\t{:ignored-in-window-resets/%ju} "
"{N:/ignored RSTs in the window%s}\n");
p(tcps_connects, "\t{:connections-established/%ju} "
"{N:/connection%s established (including accepts)}\n");
p(tcps_usedrtt, "\t\t{:connections-hostcache-rtt/%ju} "
"{N:/time%s used RTT from hostcache}\n");
p(tcps_usedrttvar, "\t\t{:connections-hostcache-rttvar/%ju} "
"{N:/time%s used RTT variance from hostcache}\n");
p(tcps_usedssthresh, "\t\t{:connections-hostcache-ssthresh/%ju} "
"{N:/time%s used slow-start threshold from hostcache}\n");
p2(tcps_closed, tcps_drops, "\t{:connections-closed/%ju} "
"{N:/connection%s closed (including} "
"{:connection-drops/%ju} {N:/drop%s})\n");
p(tcps_cachedrtt, "\t\t{:connections-updated-rtt-on-close/%ju} "
"{N:/connection%s updated cached RTT on close}\n");
p(tcps_cachedrttvar, "\t\t"
"{:connections-updated-variance-on-close/%ju} "
"{N:/connection%s updated cached RTT variance on close}\n");
p(tcps_cachedssthresh, "\t\t"
"{:connections-updated-ssthresh-on-close/%ju} "
"{N:/connection%s updated cached ssthresh on close}\n");
p(tcps_conndrops, "\t{:embryonic-connections-dropped/%ju} "
"{N:/embryonic connection%s dropped}\n");
p2(tcps_rttupdated, tcps_segstimed, "\t{:segments-updated-rtt/%ju} "
"{N:/segment%s updated rtt (of} "
"{:segment-update-attempts/%ju} {N:/attempt%s})\n");
p(tcps_rexmttimeo, "\t{:retransmit-timeouts/%ju} "
"{N:/retransmit timeout%s}\n");
p(tcps_timeoutdrop, "\t\t"
"{:connections-dropped-by-retransmit-timeout/%ju} "
"{N:/connection%s dropped by rexmit timeout}\n");
p(tcps_persisttimeo, "\t{:persist-timeout/%ju} "
"{N:/persist timeout%s}\n");
p(tcps_persistdrop, "\t\t"
"{:connections-dropped-by-persist-timeout/%ju} "
"{N:/connection%s dropped by persist timeout}\n");
p(tcps_finwait2_drops, "\t"
"{:connections-dropped-by-finwait2-timeout/%ju} "
"{N:/Connection%s (fin_wait_2) dropped because of timeout}\n");
p(tcps_keeptimeo, "\t{:keepalive-timeout/%ju} "
"{N:/keepalive timeout%s}\n");
p(tcps_keepprobe, "\t\t{:keepalive-probes/%ju} "
"{N:/keepalive probe%s sent}\n");
p(tcps_keepdrops, "\t\t{:connections-dropped-by-keepalives/%ju} "
"{N:/connection%s dropped by keepalive}\n");
p(tcps_predack, "\t{:ack-header-predictions/%ju} "
"{N:/correct ACK header prediction%s}\n");
p(tcps_preddat, "\t{:data-packet-header-predictions/%ju} "
"{N:/correct data packet header prediction%s}\n");
xo_open_container("syncache");
p3(tcps_sc_added, "\t{:entries-added/%ju} "
"{N:/syncache entr%s added}\n");
p1a(tcps_sc_retransmitted, "\t\t{:retransmitted/%ju} "
"{N:/retransmitted}\n");
p1a(tcps_sc_dupsyn, "\t\t{:duplicates/%ju} {N:/dupsyn}\n");
p1a(tcps_sc_dropped, "\t\t{:dropped/%ju} {N:/dropped}\n");
p1a(tcps_sc_completed, "\t\t{:completed/%ju} {N:/completed}\n");
p1a(tcps_sc_bucketoverflow, "\t\t{:bucket-overflow/%ju} "
"{N:/bucket overflow}\n");
p1a(tcps_sc_cacheoverflow, "\t\t{:cache-overflow/%ju} "
"{N:/cache overflow}\n");
p1a(tcps_sc_reset, "\t\t{:reset/%ju} {N:/reset}\n");
p1a(tcps_sc_stale, "\t\t{:stale/%ju} {N:/stale}\n");
p1a(tcps_sc_aborted, "\t\t{:aborted/%ju} {N:/aborted}\n");
p1a(tcps_sc_badack, "\t\t{:bad-ack/%ju} {N:/badack}\n");
p1a(tcps_sc_unreach, "\t\t{:unreachable/%ju} {N:/unreach}\n");
p(tcps_sc_zonefail, "\t\t{:zone-failures/%ju} {N:/zone failure%s}\n");
p(tcps_sc_sendcookie, "\t{:sent-cookies/%ju} {N:/cookie%s sent}\n");
p(tcps_sc_recvcookie, "\t{:receivd-cookies/%ju} "
"{N:/cookie%s received}\n");
xo_close_container("syncache");
xo_open_container("hostcache");
p3(tcps_hc_added, "\t{:entries-added/%ju} "
"{N:/hostcache entr%s added}\n");
p1a(tcps_hc_bucketoverflow, "\t\t{:buffer-overflows/%ju} "
"{N:/bucket overflow}\n");
xo_close_container("hostcache");
xo_open_container("sack");
p(tcps_sack_recovery_episode, "\t{:recovery-episodes/%ju} "
"{N:/SACK recovery episode%s}\n");
p(tcps_sack_rexmits, "\t{:segment-retransmits/%ju} "
"{N:/segment rexmit%s in SACK recovery episodes}\n");
p(tcps_sack_rexmit_bytes, "\t{:byte-retransmits/%ju} "
"{N:/byte rexmit%s in SACK recovery episodes}\n");
p(tcps_sack_rcv_blocks, "\t{:received-blocks/%ju} "
"{N:/SACK option%s (SACK blocks) received}\n");
p(tcps_sack_send_blocks, "\t{:sent-option-blocks/%ju} "
"{N:/SACK option%s (SACK blocks) sent}\n");
p1a(tcps_sack_sboverflow, "\t{:scoreboard-overflows/%ju} "
"{N:/SACK scoreboard overflow}\n");
xo_close_container("sack");
xo_open_container("ecn");
p(tcps_ecn_ce, "\t{:ce-packets/%ju} "
"{N:/packet%s with ECN CE bit set}\n");
p(tcps_ecn_ect0, "\t{:ect0-packets/%ju} "
"{N:/packet%s with ECN ECT(0) bit set}\n");
p(tcps_ecn_ect1, "\t{:ect1-packets/%ju} "
"{N:/packet%s with ECN ECT(1) bit set}\n");
p(tcps_ecn_shs, "\t{:handshakes/%ju} "
"{N:/successful ECN handshake%s}\n");
p(tcps_ecn_rcwnd, "\t{:congestion-reductions/%ju} "
"{N:/time%s ECN reduced the congestion window}\n");
xo_close_container("ecn");
xo_open_container("tcp-signature");
p(tcps_sig_rcvgoodsig, "\t{:received-good-signature/%ju} "
"{N:/packet%s with matching signature received}\n");
p(tcps_sig_rcvbadsig, "\t{:received-bad-signature/%ju} "
"{N:/packet%s with bad signature received}\n");
p(tcps_sig_err_buildsig, "\t{:failed-make-signature/%ju} "
"{N:/time%s failed to make signature due to no SA}\n");
p(tcps_sig_err_sigopt, "\t{:no-signature-expected/%ju} "
"{N:/time%s unexpected signature received}\n");
p(tcps_sig_err_nosigopt, "\t{:no-signature-provided/%ju} "
"{N:/time%s no signature provided by segment}\n");
#undef p
#undef p1a
#undef p2
#undef p2a
#undef p3
xo_close_container("tcp-signature");
xo_open_container("TCP connection count by state");
xo_emit("{T:/TCP connection count by state}:\n");
for (int i = 0; i < TCP_NSTATES; i++) {
/*
* XXXGL: is there a way in libxo to use %s
* in the "content string" of a format
* string? I failed to do that, that's why
* a temporary buffer is used to construct
* format string for xo_emit().
*/
char fmtbuf[80];
if (sflag > 1 && tcps_states[i] == 0)
continue;
snprintf(fmtbuf, sizeof(fmtbuf), "\t{:%s/%%ju} "
"{Np:/connection ,connections} in %s state\n",
tcpstates[i], tcpstates[i]);
xo_emit(fmtbuf, (uintmax_t )tcps_states[i]);
}
xo_close_container("TCP connection count by state");
xo_close_container("tcp");
}
/*
* Dump TCP statistics structure.
*/
void
tcp_stats(u_long off __unused, const char *name, int af1 __unused)
{
struct tcp_stats tcpstat, *stattmp;
struct tcp_stats zerostat[SMP_MAXCPU];
size_t len = sizeof(struct tcp_stats) * SMP_MAXCPU;
int cpucnt;
if (zflag)
memset(zerostat, 0, len);
if ((stattmp = malloc(len)) == NULL) {
return;
} else {
if (sysctlbyname("net.inet.tcp.stats", stattmp, &len,
zflag ? zerostat : NULL, zflag ? len : 0) < 0) {
warn("sysctl: net.inet.tcp.stats");
free(stattmp);
return;
} else {
if ((stattmp = realloc(stattmp, len)) == NULL) {
warn("tcp_stats");
return;
}
}
}
cpucnt = len / sizeof(struct tcp_stats);
tcp_stats_agg(stattmp, &tcpstat, cpucnt);
#ifdef INET6
if (tcp_done != 0)
return;
else
tcp_done = 1;
#endif
printf ("%s:\n", name);
#define p(f, m) if (tcpstat.f || sflag <= 1) \
printf(m, tcpstat.f, plural(tcpstat.f))
#define p1a(f, m) if (tcpstat.f || sflag <= 1) \
printf(m, tcpstat.f)
#define p2(f1, f2, m) if (tcpstat.f1 || tcpstat.f2 || sflag <= 1) \
printf(m, tcpstat.f1, plural(tcpstat.f1), tcpstat.f2, plural(tcpstat.f2))
#define p2a(f1, f2, m) if (tcpstat.f1 || tcpstat.f2 || sflag <= 1) \
printf(m, tcpstat.f1, plural(tcpstat.f1), tcpstat.f2)
#define p3(f, m) if (tcpstat.f || sflag <= 1) \
printf(m, tcpstat.f, plurales(tcpstat.f))
p(tcps_sndtotal, "\t%lu packet%s sent\n");
p2(tcps_sndpack,tcps_sndbyte,
"\t\t%lu data packet%s (%lu byte%s)\n");
p2(tcps_sndrexmitpack, tcps_sndrexmitbyte,
"\t\t%lu data packet%s (%lu byte%s) retransmitted\n");
p2(tcps_sndsackrtopack, tcps_sndsackrtobyte,
"\t\t%lu data packet%s (%lu byte%s) retransmitted by SACK\n");
p2(tcps_sndsackpack, tcps_sndsackbyte,
"\t\t%lu data packet%s (%lu byte%s) sent by SACK recovery\n");
p2(tcps_sackrescue, tcps_sackrescue_try,
"\t\t%lu SACK rescue packet%s sent (of %lu attempt%s)\n");
p2a(tcps_sndfastrexmit, tcps_sndearlyrexmit,
"\t\t%lu Fast Retransmit%s (%lu early)\n");
p(tcps_sndlimited, "\t\t%lu packet%s sent by Limited Transmit\n");
p2(tcps_sndrtobad, tcps_eifelresponse,
"\t\t%lu spurious RTO retransmit%s (%lu Eifel-response%s)\n");
p2a(tcps_sndfastrexmitbad, tcps_sndearlyrexmitbad,
"\t\t%lu spurious Fast Retransmit%s (%lu early)\n");
p2a(tcps_eifeldetected, tcps_rttcantdetect,
"\t\t%lu Eifel-detected spurious retransmit%s (%lu non-RTT)\n");
p(tcps_rttdetected, "\t\t%lu RTT-detected spurious retransmit%s\n");
p(tcps_mturesent, "\t\t%lu resend%s initiated by MTU discovery\n");
p(tcps_sndsackopt, "\t\t%lu SACK option%s sent\n");
p(tcps_snddsackopt, "\t\t%lu D-SACK option%s sent\n");
p2a(tcps_sndacks, tcps_delack,
"\t\t%lu ack-only packet%s (%lu delayed)\n");
p(tcps_sndurg, "\t\t%lu URG only packet%s\n");
p(tcps_sndprobe, "\t\t%lu window probe packet%s\n");
p(tcps_sndwinup, "\t\t%lu window update packet%s\n");
p(tcps_sndctrl, "\t\t%lu control packet%s\n");
p(tcps_rcvtotal, "\t%lu packet%s received\n");
p2(tcps_rcvackpack, tcps_rcvackbyte, "\t\t%lu ack%s (for %lu byte%s)\n");
p(tcps_rcvdupack, "\t\t%lu duplicate ack%s\n");
p(tcps_rcvacktoomuch, "\t\t%lu ack%s for unsent data\n");
p2(tcps_rcvpack, tcps_rcvbyte,
"\t\t%lu packet%s (%lu byte%s) received in-sequence\n");
p2(tcps_rcvduppack, tcps_rcvdupbyte,
"\t\t%lu completely duplicate packet%s (%lu byte%s)\n");
p2(tcps_pawsdrop, tcps_pawsaccept,
"\t\t%lu old duplicate packet%s (%lu packet%s accepted)\n");
p2(tcps_rcvpartduppack, tcps_rcvpartdupbyte,
"\t\t%lu packet%s with some dup. data (%lu byte%s duped)\n");
p2(tcps_rcvoopack, tcps_rcvoobyte,
"\t\t%lu out-of-order packet%s (%lu byte%s)\n");
p2(tcps_rcvpackafterwin, tcps_rcvbyteafterwin,
"\t\t%lu packet%s (%lu byte%s) of data after window\n");
p(tcps_rcvwinprobe, "\t\t%lu window probe%s\n");
p(tcps_rcvwinupd, "\t\t%lu window update packet%s\n");
p(tcps_rcvafterclose, "\t\t%lu packet%s received after close\n");
p(tcps_rcvbadsum, "\t\t%lu discarded for bad checksum%s\n");
p(tcps_rcvbadoff, "\t\t%lu discarded for bad header offset field%s\n");
p1a(tcps_rcvshort, "\t\t%lu discarded because packet too short\n");
p(tcps_rcvbadsackopt, "\t\t%lu bad SACK option%s\n");
p1a(tcps_sackrenege, "\t\t%lu other side reneged\n");
p(tcps_connattempt, "\t%lu connection request%s\n");
p(tcps_accepts, "\t%lu connection accept%s\n");
p(tcps_badsyn, "\t%lu bad connection attempt%s\n");
p(tcps_listendrop, "\t%lu listen queue overflow%s\n");
p(tcps_connects, "\t%lu connection%s established (including accepts)\n");
p2(tcps_closed, tcps_drops,
"\t%lu connection%s closed (including %lu drop%s)\n");
p(tcps_cachedrtt, "\t\t%lu connection%s updated cached RTT on close\n");
p(tcps_cachedrttvar,
"\t\t%lu connection%s updated cached RTT variance on close\n");
p(tcps_cachedssthresh,
"\t\t%lu connection%s updated cached ssthresh on close\n");
p(tcps_conndrops, "\t%lu embryonic connection%s dropped\n");
p2(tcps_rttupdated, tcps_segstimed,
"\t%lu segment%s updated rtt (of %lu attempt%s)\n");
p(tcps_rexmttimeo, "\t%lu retransmit timeout%s\n");
p(tcps_timeoutdrop, "\t\t%lu connection%s dropped by rexmit timeout\n");
p(tcps_persisttimeo, "\t%lu persist timeout%s\n");
p(tcps_persistdrop, "\t\t%lu connection%s dropped by persist timeout\n");
p(tcps_keeptimeo, "\t%lu keepalive timeout%s\n");
p(tcps_keepprobe, "\t\t%lu keepalive probe%s sent\n");
p(tcps_keepdrops, "\t\t%lu connection%s dropped by keepalive\n");
p(tcps_predack, "\t%lu correct ACK header prediction%s\n");
p(tcps_preddat, "\t%lu correct data packet header prediction%s\n");
p(tcps_sndidle, "\t%lu send idle%s\n");
p1a(tcps_sc_added, "\t%lu syncache entries added\n");
p1a(tcps_sc_retransmitted, "\t\t%lu retransmitted\n");
p1a(tcps_sc_dupsyn, "\t\t%lu dupsyn\n");
p1a(tcps_sc_dropped, "\t\t%lu dropped\n");
p1a(tcps_sc_completed, "\t\t%lu completed\n");
p1a(tcps_sc_bucketoverflow, "\t\t%lu bucket overflow\n");
p1a(tcps_sc_cacheoverflow, "\t\t%lu cache overflow\n");
p1a(tcps_sc_reset, "\t\t%lu reset\n");
p1a(tcps_sc_stale, "\t\t%lu stale\n");
p1a(tcps_sc_aborted, "\t\t%lu aborted\n");
p1a(tcps_sc_badack, "\t\t%lu badack\n");
p1a(tcps_sc_unreach, "\t\t%lu unreach\n");
p1a(tcps_sc_zonefail, "\t\t%lu zone failures\n");
p1a(tcps_sc_sendcookie, "\t\t%lu cookies sent\n");
p1a(tcps_sc_recvcookie, "\t\t%lu cookies received\n");
p(tcps_sacksbupdate, "\t%lu SACK scoreboard update%s\n");
p(tcps_sacksboverflow, "\t\t%lu overflow%s\n");
p(tcps_sacksbfailed, "\t\t%lu failure%s\n");
p(tcps_sacksbreused, "\t\t%lu record%s reused\n");
p(tcps_sacksbfast, "\t\t%lu record%s fast allocated\n");
free(stattmp);
#undef p
#undef p1a
#undef p2
#undef p2a
#undef p3
}
