// SetTimeout sets the read timeout for the handle.
//
// See the package documentation for important details regarding 'timeout'.
func (p *InactiveHandle) SetTimeout(timeout time.Duration) error {
p.blockForever = timeout < 0
if status := C.pcap_set_timeout(p.cptr, timeoutMillis(timeout)); status < 0 {
return statusError(status)
}
return nil
}
// OpenLive opens a device and returns a *Handle.
// It takes as arguments the name of the device ("eth0"), the maximum size to
// read for each packet (snaplen), whether to put the interface in promiscuous
// mode, and a timeout.
func OpenLive(device string, snaplen int32, promisc bool, timeout time.Duration) (handle *Handle, _ error) {
var buf *C.char
buf = (*C.char)(C.calloc(errorBufferSize, 1))
defer C.free(unsafe.Pointer(buf))
var pro C.int
if promisc {
pro = 1
}
dev := C.CString(device)
defer C.free(unsafe.Pointer(dev))
// This copies a bunch of the pcap_open_live implementation from pcap.c:
cptr := C.pcap_create(dev, buf)
if cptr == nil {
return nil, errors.New(C.GoString(buf))
}
var status C.int
if status = C.pcap_set_snaplen(cptr, C.int(snaplen)); status < 0 {
goto fail
} else if status = C.pcap_set_promisc(cptr, pro); status < 0 {
goto fail
} else if status = C.pcap_set_timeout(cptr, C.int(timeout/time.Millisecond)); status < 0 {
goto fail
}
return newHandle(cptr), nil
fail:
C.pcap_close(cptr)
return nil, statusError(status)
}
// SetTimeout should only be called on a Pcap that was obtained through Create.
func (p *Pcap) SetTimeout(timeout_ms int32) error {
res := int32(C.pcap_set_timeout(p.cptr, C.int(timeout_ms)))
if res < 0 {
return fmt.Errorf("%s(errnum=%d)", Statustostr(res), res)
}
p.Timeout = timeout_ms
return nil
}
// Set read timeout (milliseconds) that will be used on a capture handle when it is activated.
func (p *Pcap) SetReadTimeout(toMs int32) error {
if C.pcap_set_timeout(p.cptr, C.int(toMs)) != 0 {
return p.Geterror()
}
return nil
}