13234378528

Committed 10 Feb 2025 05:42AM UTC coverage: 71.865% (-0.01%) from 71.877%

Build # 13234378528

Build Type

Pull #1688

github

Committed by

DecFox

Commit Message

chore: update toolchain to go1.22.3

Pull Request Pull Request #1688: chore: update toolchain to go1.22.3

Run Details

28107 of 39111 relevant lines covered (71.86%)

46.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.82

/internal/measurexlite/dns.go

package measurexlite

//
// DNS Lookup with tracing
//

import (
        "context"
        "errors"
        "log"
        "net"
        "time"

        "github.com/miekg/dns"
        "github.com/ooni/probe-cli/v3/internal/bytecounter"
        "github.com/ooni/probe-cli/v3/internal/geoipx"
        "github.com/ooni/probe-cli/v3/internal/model"
        "github.com/ooni/probe-cli/v3/internal/netxlite"
)

// wrapResolver resolver wraps the passed resolver to save data into the trace
func (tx *Trace) wrapResolver(resolver model.Resolver) model.Resolver {
        return &resolverTrace{
                r:  resolver,
                tx: tx,
        }
}

// resolverTrace is a trace-aware resolver
type resolverTrace struct {
        r  model.Resolver
        tx *Trace
}

var _ model.Resolver = &resolverTrace{}

// Address implements model.Resolver.Address
func (r *resolverTrace) Address() string {
        return r.r.Address()
}

// Network implements model.Resolver.Network
func (r *resolverTrace) Network() string {
        return r.r.Network()
}

// CloseIdleConnections implements model.Resolver.CloseIdleConnections
func (r *resolverTrace) CloseIdleConnections() {
        r.r.CloseIdleConnections()
}

// emits the resolve_start event
func (r *resolverTrace) emitResolveStart() {
        select {
        case r.tx.networkEvent <- NewAnnotationArchivalNetworkEvent(
                r.tx.Index(), r.tx.TimeSince(r.tx.ZeroTime()), "resolve_start",
                r.tx.tags...,
        ):
        default: // buffer is full
        }
}

// emits the resolve_done event
func (r *resolverTrace) emiteResolveDone() {
        select {
        case r.tx.networkEvent <- NewAnnotationArchivalNetworkEvent(
                r.tx.Index(), r.tx.TimeSince(r.tx.ZeroTime()), "resolve_done",
                r.tx.tags...,
        ):
        default: // buffer is full
        }
}

// LookupHost implements model.Resolver.LookupHost
func (r *resolverTrace) LookupHost(ctx context.Context, hostname string) ([]string, error) {
        defer r.emiteResolveDone()
        r.emitResolveStart()
        return r.r.LookupHost(netxlite.ContextWithTrace(ctx, r.tx), hostname)
}

// LookupHTTPS implements model.Resolver.LookupHTTPS
func (r *resolverTrace) LookupHTTPS(ctx context.Context, domain string) (*model.HTTPSSvc, error) {
        defer r.emiteResolveDone()
        r.emitResolveStart()
        return r.r.LookupHTTPS(netxlite.ContextWithTrace(ctx, r.tx), domain)
}

// LookupNS implements model.Resolver.LookupNS
func (r *resolverTrace) LookupNS(ctx context.Context, domain string) ([]*net.NS, error) {
        defer r.emiteResolveDone()
        r.emitResolveStart()
        return r.r.LookupNS(netxlite.ContextWithTrace(ctx, r.tx), domain)
}

// NewStdlibResolver returns a trace-ware system resolver
func (tx *Trace) NewStdlibResolver(logger model.DebugLogger) model.Resolver {
        // Here we make sure that we're counting bytes sent and received.
        return bytecounter.WrapWithContextAwareSystemResolver(tx.wrapResolver(tx.Netx.NewStdlibResolver(logger)))
}

// NewParallelUDPResolver returns a trace-ware parallel UDP resolver
func (tx *Trace) NewParallelUDPResolver(logger model.DebugLogger, dialer model.Dialer, address string) model.Resolver {
        return tx.wrapResolver(tx.Netx.NewParallelUDPResolver(logger, dialer, address))
}

// NewParallelDNSOverHTTPSResolver returns a trace-aware parallel DoH resolver
func (tx *Trace) NewParallelDNSOverHTTPSResolver(logger model.DebugLogger, URL string) model.Resolver {
        return tx.wrapResolver(tx.Netx.NewParallelDNSOverHTTPSResolver(logger, URL))
}

// OnDNSRoundTripForLookupHost implements model.Trace.OnDNSRoundTripForLookupHost
func (tx *Trace) OnDNSRoundTripForLookupHost(started time.Time, reso model.Resolver, query model.DNSQuery,
        response model.DNSResponse, addrs []string, err error, finished time.Time) {
        t := finished.Sub(tx.ZeroTime())

        select {
        case tx.dnsLookup <- NewArchivalDNSLookupResultFromRoundTrip(
                tx.Index(),
                started.Sub(tx.ZeroTime()),
                reso,
                query,
                response,
                addrs,
                err,
                t,
                tx.tags...,
        ):

        default:
                // buffer is full
        }
}

// DNSNetworkAddresser is the type of something we just used to perform a DNS
// round trip (e.g., model.DNSTransport, model.Resolver) that allows us to get
// the network and the address of the underlying resolver/transport.
type DNSNetworkAddresser interface {
        // Address is like model.DNSTransport.Address
        Address() string

        // Network is like model.DNSTransport.Network
        Network() string
}

// NewArchivalDNSLookupResultFromRoundTrip generates a model.ArchivalDNSLookupResultFromRoundTrip
// from the available information right after the DNS RoundTrip
func NewArchivalDNSLookupResultFromRoundTrip(index int64, started time.Duration,
        reso DNSNetworkAddresser, query model.DNSQuery, response model.DNSResponse,
        addrs []string, err error, finished time.Duration, tags ...string) *model.ArchivalDNSLookupResult {
        return &model.ArchivalDNSLookupResult{
                Answers:          newArchivalDNSAnswers(addrs, response),
                Engine:           reso.Network(),
                Failure:          NewFailure(err),
                GetaddrinfoError: netxlite.ErrorToGetaddrinfoRetvalOrZero(err),
                Hostname:         query.Domain(),
                QueryType:        dns.TypeToString[query.Type()],
                RawResponse:      maybeRawResponse(response),
                Rcode:            maybeResponseRcode(response),
                ResolverHostname: nil,
                ResolverPort:     nil,
                ResolverAddress:  reso.Address(),
                T0:               started.Seconds(),
                T:                finished.Seconds(),
                Tags:             copyAndNormalizeTags(tags),
                TransactionID:    index,
        }
}

// maybeResponseRcode returns the response rcode (when available)
func maybeResponseRcode(resp model.DNSResponse) (out int64) {
        if resp != nil {
                out = int64(resp.Rcode())
        }
        return
}

// maybeRawResponse returns either the raw response (when available) or nil.
func maybeRawResponse(resp model.DNSResponse) (out []byte) {
        if resp != nil {
                out = resp.Bytes()
        }
        return
}

// newArchivalDNSAnswers generates []model.ArchivalDNSAnswer from [addrs] and [resp].
func newArchivalDNSAnswers(addrs []string, resp model.DNSResponse) (out []model.ArchivalDNSAnswer) {
        // Design note: in principle we might want to extract everything from the
        // response but, when we're called by netxlite, netxlite has already extracted
        // the addresses to return them to the caller, so I think it's fine to keep
        // this extraction code as such rather than suppressing passing the addrs from
        // netxlite. Also, a wrong IP address is a bug because netxlite should not
        // return invalid IP addresses from its resolvers, so we want to know about that.

        // Include IP addresses extracted by netxlite
        for _, addr := range addrs {
                ipv6, err := netxlite.IsIPv6(addr)
                if err != nil {
                        log.Printf("BUG: NewArchivalDNSLookupResult: invalid IP address: %s", addr)
                        continue
                }
                asn, org, _ := geoipx.LookupASN(addr) // error if not in the DB; returns sensible values on error
                switch ipv6 {

                case false:
                        out = append(out, model.ArchivalDNSAnswer{
                                ASN:        int64(asn),
                                ASOrgName:  org,
                                AnswerType: "A",
                                Hostname:   "",
                                IPv4:       addr,
                                IPv6:       "",
                                TTL:        nil,
                        })

                case true:
                        out = append(out, model.ArchivalDNSAnswer{
                                ASN:        int64(asn),
                                ASOrgName:  org,
                                AnswerType: "AAAA",
                                Hostname:   "",
                                IPv4:       "",
                                IPv6:       addr,
                                TTL:        nil,
                        })
                }
        }

        // Include additional answer types when a response is available
        if resp != nil {

                // Include CNAME if available
                if cname, err := resp.DecodeCNAME(); err == nil && cname != "" {
                        out = append(out, model.ArchivalDNSAnswer{
                                ASN:        0,
                                ASOrgName:  "",
                                AnswerType: "CNAME",
                                Hostname:   cname,
                                IPv4:       "",
                                IPv6:       "",
                                TTL:        nil,
                        })
                }

                // TODO(bassosimone): what other fields generally present inside A/AAAA replies
                // would it be useful to extract here? Perhaps, the SoA field?
        }
        return
}

// DNSLookupsFromRoundTrip drains the network events buffered inside the DNSLookup channel
func (tx *Trace) DNSLookupsFromRoundTrip() (out []*model.ArchivalDNSLookupResult) {
        for {
                select {
                case ev := <-tx.dnsLookup:
                        out = append(out, ev)
                default:
                        return
                }
        }
}

// FirstDNSLookupOrNil drains the network events buffered inside the DNSLookup channel
// and returns the first DNSLookup, if any. Otherwise, it returns nil.
func (tx *Trace) FirstDNSLookup() *model.ArchivalDNSLookupResult {
        ev := tx.DNSLookupsFromRoundTrip()
        if len(ev) < 1 {
                return nil
        }
        return ev[0]
}

// ErrDelayedDNSResponseBufferFull indicates that the delayed-DNS-response channel buffer is full.
var ErrDelayedDNSResponseBufferFull = errors.New(
        "measurexlite: the delayed-DNS-response channel buffer is full")

// OnDelayedDNSResponse implements model.Trace.OnDelayedDNSResponse
func (tx *Trace) OnDelayedDNSResponse(started time.Time, txp model.DNSTransport, query model.DNSQuery,
        response model.DNSResponse, addrs []string, err error, finished time.Time) error {
        t := finished.Sub(tx.ZeroTime())

        select {
        case tx.delayedDNSResponse <- NewArchivalDNSLookupResultFromRoundTrip(
                tx.Index(),
                started.Sub(tx.ZeroTime()),
                txp,
                query,
                response,
                addrs,
                err,
                t,
                tx.tags...,
        ):
                return nil

        default:
                return ErrDelayedDNSResponseBufferFull
        }
}

// DelayedDNSResponseWithTimeout drains the network events buffered inside
// the delayedDNSResponse channel. We construct a child context based on [ctx]
// and the given [timeout] and we stop reading when original [ctx] has been
// cancelled or the given [timeout] expires, whatever happens first. Once the
// timeout expired, we drain the chan as much as possible before returning.
func (tx *Trace) DelayedDNSResponseWithTimeout(ctx context.Context,
        timeout time.Duration) (out []*model.ArchivalDNSLookupResult) {
        ctx, cancel := context.WithTimeout(ctx, timeout)
        defer cancel()

        for {
                select {

                case <-ctx.Done():
                        for { // once the context is done enter in channel draining mode
                                select {
                                case ev := <-tx.delayedDNSResponse:
                                        out = append(out, ev)
                                default:
                                        return
                                }
                        }

                case ev := <-tx.delayedDNSResponse:
                        out = append(out, ev)
                }
        }
}

1	package measurexlite
2
3	//
4	// DNS Lookup with tracing
5	//
6
7	import (
8	"context"
9	"errors"
10	"log"
11	"net"
12	"time"
13
14	"github.com/miekg/dns"
15	"github.com/ooni/probe-cli/v3/internal/bytecounter"
16	"github.com/ooni/probe-cli/v3/internal/geoipx"
17	"github.com/ooni/probe-cli/v3/internal/model"
18	"github.com/ooni/probe-cli/v3/internal/netxlite"
19	)
20
21	// wrapResolver resolver wraps the passed resolver to save data into the trace
22	func (tx *Trace) wrapResolver(resolver model.Resolver) model.Resolver {	10✔
23	return &resolverTrace{	10✔
24	r: resolver,	10✔
25	tx: tx,	10✔
26	}	10✔
27	}	10✔
28
29	// resolverTrace is a trace-aware resolver
30	type resolverTrace struct {
31	r model.Resolver
32	tx *Trace
33	}
34
35	var _ model.Resolver = &resolverTrace{}
36
37	// Address implements model.Resolver.Address
38	func (r *resolverTrace) Address() string {	1✔
39	return r.r.Address()	1✔
40	}	1✔
41
42	// Network implements model.Resolver.Network
43	func (r *resolverTrace) Network() string {	4✔
44	return r.r.Network()	4✔
45	}	4✔
46
47	// CloseIdleConnections implements model.Resolver.CloseIdleConnections
48	func (r *resolverTrace) CloseIdleConnections() {	1✔
49	r.r.CloseIdleConnections()	1✔
50	}	1✔
51
52	// emits the resolve_start event
53	func (r *resolverTrace) emitResolveStart() {	8✔
54	select {	8✔
55	case r.tx.networkEvent <- NewAnnotationArchivalNetworkEvent(
56	r.tx.Index(), r.tx.TimeSince(r.tx.ZeroTime()), "resolve_start",
57	r.tx.tags...,
58	):	7✔
59	default: // buffer is full	1✔
60	}
61	}
62
63	// emits the resolve_done event
64	func (r *resolverTrace) emiteResolveDone() {	8✔
65	select {	8✔
66	case r.tx.networkEvent <- NewAnnotationArchivalNetworkEvent(
67	r.tx.Index(), r.tx.TimeSince(r.tx.ZeroTime()), "resolve_done",
68	r.tx.tags...,
69	):	7✔
70	default: // buffer is full	1✔
71	}
72	}
73
74	// LookupHost implements model.Resolver.LookupHost
75	func (r *resolverTrace) LookupHost(ctx context.Context, hostname string) ([]string, error) {	6✔
76	defer r.emiteResolveDone()	6✔
77	r.emitResolveStart()	6✔
78	return r.r.LookupHost(netxlite.ContextWithTrace(ctx, r.tx), hostname)	6✔
79	}	6✔
80
81	// LookupHTTPS implements model.Resolver.LookupHTTPS
82	func (r resolverTrace) LookupHTTPS(ctx context.Context, domain string) (model.HTTPSSvc, error) {	1✔
83	defer r.emiteResolveDone()	1✔
84	r.emitResolveStart()	1✔
85	return r.r.LookupHTTPS(netxlite.ContextWithTrace(ctx, r.tx), domain)	1✔
86	}	1✔
87
88	// LookupNS implements model.Resolver.LookupNS
89	func (r resolverTrace) LookupNS(ctx context.Context, domain string) ([]net.NS, error) {	1✔
90	defer r.emiteResolveDone()	1✔
91	r.emitResolveStart()	1✔
92	return r.r.LookupNS(netxlite.ContextWithTrace(ctx, r.tx), domain)	1✔
93	}	1✔
94
95	// NewStdlibResolver returns a trace-ware system resolver
96	func (tx *Trace) NewStdlibResolver(logger model.DebugLogger) model.Resolver {	2✔
97	// Here we make sure that we're counting bytes sent and received.	2✔
98	return bytecounter.WrapWithContextAwareSystemResolver(tx.wrapResolver(tx.Netx.NewStdlibResolver(logger)))	2✔
99	}	2✔
100
101	// NewParallelUDPResolver returns a trace-ware parallel UDP resolver
102	func (tx *Trace) NewParallelUDPResolver(logger model.DebugLogger, dialer model.Dialer, address string) model.Resolver {	2✔
103	return tx.wrapResolver(tx.Netx.NewParallelUDPResolver(logger, dialer, address))	2✔
104	}	2✔
105
106	// NewParallelDNSOverHTTPSResolver returns a trace-aware parallel DoH resolver
107	func (tx *Trace) NewParallelDNSOverHTTPSResolver(logger model.DebugLogger, URL string) model.Resolver {	2✔
108	return tx.wrapResolver(tx.Netx.NewParallelDNSOverHTTPSResolver(logger, URL))	2✔
109	}	2✔
110
111	// OnDNSRoundTripForLookupHost implements model.Trace.OnDNSRoundTripForLookupHost
112	func (tx *Trace) OnDNSRoundTripForLookupHost(started time.Time, reso model.Resolver, query model.DNSQuery,
113	response model.DNSResponse, addrs []string, err error, finished time.Time) {	9✔
114	t := finished.Sub(tx.ZeroTime())	9✔
115		9✔
116	select {	9✔
117	case tx.dnsLookup <- NewArchivalDNSLookupResultFromRoundTrip(
118	tx.Index(),
119	started.Sub(tx.ZeroTime()),
120	reso,
121	query,
122	response,
123	addrs,
124	err,
125	t,
126	tx.tags...,
127	):	7✔
128
129	default:	2✔
130	// buffer is full
131	}
132	}
133
134	// DNSNetworkAddresser is the type of something we just used to perform a DNS
135	// round trip (e.g., model.DNSTransport, model.Resolver) that allows us to get
136	// the network and the address of the underlying resolver/transport.
137	type DNSNetworkAddresser interface {
138	// Address is like model.DNSTransport.Address
139	Address() string
140
141	// Network is like model.DNSTransport.Network
142	Network() string
143	}
144
145	// NewArchivalDNSLookupResultFromRoundTrip generates a model.ArchivalDNSLookupResultFromRoundTrip
146	// from the available information right after the DNS RoundTrip
147	func NewArchivalDNSLookupResultFromRoundTrip(index int64, started time.Duration,
148	reso DNSNetworkAddresser, query model.DNSQuery, response model.DNSResponse,
149	addrs []string, err error, finished time.Duration, tags ...string) *model.ArchivalDNSLookupResult {	16✔
150	return &model.ArchivalDNSLookupResult{	16✔
151	Answers: newArchivalDNSAnswers(addrs, response),	16✔
152	Engine: reso.Network(),	16✔
153	Failure: NewFailure(err),	16✔
154	GetaddrinfoError: netxlite.ErrorToGetaddrinfoRetvalOrZero(err),	16✔
155	Hostname: query.Domain(),	16✔
156	QueryType: dns.TypeToString[query.Type()],	16✔
157	RawResponse: maybeRawResponse(response),	16✔
158	Rcode: maybeResponseRcode(response),	16✔
159	ResolverHostname: nil,	16✔
160	ResolverPort: nil,	16✔
161	ResolverAddress: reso.Address(),	16✔
162	T0: started.Seconds(),	16✔
163	T: finished.Seconds(),	16✔
164	Tags: copyAndNormalizeTags(tags),	16✔
165	TransactionID: index,	16✔
166	}	16✔
167	}	16✔
168
169	// maybeResponseRcode returns the response rcode (when available)
170	func maybeResponseRcode(resp model.DNSResponse) (out int64) {	16✔
171	if resp != nil {	27✔
172	out = int64(resp.Rcode())	11✔
173	}	11✔
174	return	16✔
175	}
176
177	// maybeRawResponse returns either the raw response (when available) or nil.
178	func maybeRawResponse(resp model.DNSResponse) (out []byte) {	16✔
179	if resp != nil {	27✔
180	out = resp.Bytes()	11✔
181	}	11✔
182	return	16✔
183	}
184
185	// newArchivalDNSAnswers generates []model.ArchivalDNSAnswer from [addrs] and [resp].
186	func newArchivalDNSAnswers(addrs []string, resp model.DNSResponse) (out []model.ArchivalDNSAnswer) {	25✔
187	// Design note: in principle we might want to extract everything from the	25✔
188	// response but, when we're called by netxlite, netxlite has already extracted	25✔
189	// the addresses to return them to the caller, so I think it's fine to keep	25✔
190	// this extraction code as such rather than suppressing passing the addrs from	25✔
191	// netxlite. Also, a wrong IP address is a bug because netxlite should not	25✔
192	// return invalid IP addresses from its resolvers, so we want to know about that.	25✔
193		25✔
194	// Include IP addresses extracted by netxlite	25✔
195	for _, addr := range addrs {	44✔
196	ipv6, err := netxlite.IsIPv6(addr)	19✔
197	if err != nil {	21✔
198	log.Printf("BUG: NewArchivalDNSLookupResult: invalid IP address: %s", addr)	2✔
199	continue	2✔
200	}
201	asn, org, _ := geoipx.LookupASN(addr) // error if not in the DB; returns sensible values on error	17✔
202	switch ipv6 {	17✔
203
204	case false:	12✔
205	out = append(out, model.ArchivalDNSAnswer{	12✔
206	ASN: int64(asn),	12✔
207	ASOrgName: org,	12✔
208	AnswerType: "A",	12✔
209	Hostname: "",	12✔
210	IPv4: addr,	12✔
211	IPv6: "",	12✔
212	TTL: nil,	12✔
213	})	12✔
214
215	case true:	5✔
216	out = append(out, model.ArchivalDNSAnswer{	5✔
217	ASN: int64(asn),	5✔
218	ASOrgName: org,	5✔
219	AnswerType: "AAAA",	5✔
220	Hostname: "",	5✔
221	IPv4: "",	5✔
222	IPv6: addr,	5✔
223	TTL: nil,	5✔
224	})	5✔
225	}
226	}
227
228	// Include additional answer types when a response is available
229	if resp != nil {	40✔
230		15✔
231	// Include CNAME if available	15✔
232	if cname, err := resp.DecodeCNAME(); err == nil && cname != "" {	21✔
233	out = append(out, model.ArchivalDNSAnswer{	6✔
234	ASN: 0,	6✔
235	ASOrgName: "",	6✔
236	AnswerType: "CNAME",	6✔
237	Hostname: cname,	6✔
238	IPv4: "",	6✔
239	IPv6: "",	6✔
240	TTL: nil,	6✔
241	})	6✔
242	}	6✔
243
244	// TODO(bassosimone): what other fields generally present inside A/AAAA replies
245	// would it be useful to extract here? Perhaps, the SoA field?
246	}
247	return	25✔
248	}
249
250	// DNSLookupsFromRoundTrip drains the network events buffered inside the DNSLookup channel
251	func (tx Trace) DNSLookupsFromRoundTrip() (out []model.ArchivalDNSLookupResult) {	4✔
252	for {	12✔
253	select {	8✔
254	case ev := <-tx.dnsLookup:	4✔
255	out = append(out, ev)	4✔
256	default:	4✔
257	return	4✔
258	}
259	}
260	}
261
262	// FirstDNSLookupOrNil drains the network events buffered inside the DNSLookup channel
263	// and returns the first DNSLookup, if any. Otherwise, it returns nil.
264	func (tx Trace) FirstDNSLookup() model.ArchivalDNSLookupResult {	2✔
265	ev := tx.DNSLookupsFromRoundTrip()	2✔
266	if len(ev) < 1 {	3✔
267	return nil	1✔
268	}	1✔
269	return ev[0]	1✔
270	}
271
272	// ErrDelayedDNSResponseBufferFull indicates that the delayed-DNS-response channel buffer is full.
273	var ErrDelayedDNSResponseBufferFull = errors.New(
274	"measurexlite: the delayed-DNS-response channel buffer is full")
275
276	// OnDelayedDNSResponse implements model.Trace.OnDelayedDNSResponse
277	func (tx *Trace) OnDelayedDNSResponse(started time.Time, txp model.DNSTransport, query model.DNSQuery,
278	response model.DNSResponse, addrs []string, err error, finished time.Time) error {	2✔
279	t := finished.Sub(tx.ZeroTime())	2✔
280		2✔
281	select {	2✔
282	case tx.delayedDNSResponse <- NewArchivalDNSLookupResultFromRoundTrip(
283	tx.Index(),
284	started.Sub(tx.ZeroTime()),
285	txp,
286	query,
287	response,
288	addrs,
289	err,
290	t,
291	tx.tags...,
292	):	1✔
293	return nil	1✔
294
295	default:	1✔
296	return ErrDelayedDNSResponseBufferFull	1✔
297	}
298	}
299
300	// DelayedDNSResponseWithTimeout drains the network events buffered inside
301	// the delayedDNSResponse channel. We construct a child context based on [ctx]
302	// and the given [timeout] and we stop reading when original [ctx] has been
303	// cancelled or the given [timeout] expires, whatever happens first. Once the
304	// timeout expired, we drain the chan as much as possible before returning.
305	func (tx *Trace) DelayedDNSResponseWithTimeout(ctx context.Context,
306	timeout time.Duration) (out []*model.ArchivalDNSLookupResult) {	4✔
307	ctx, cancel := context.WithTimeout(ctx, timeout)	4✔
308	defer cancel()	4✔
309		4✔
310	for {	14✔
311	select {	10✔
312
313	case <-ctx.Done():	4✔
314	for { // once the context is done enter in channel draining mode	8✔
315	select {	4✔
316	case ev := <-tx.delayedDNSResponse:	×
317	out = append(out, ev)	×
318	default:	4✔
319	return	4✔
320	}
321	}
322
323	case ev := <-tx.delayedDNSResponse:	6✔
324	out = append(out, ev)	6✔
325	}
326	}
327	}

ooni / probe-cli / 13234378528

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous