本文整理汇总了Golang中syscall.NsecToTimeval函数的典型用法代码示例。如果您正苦于以下问题:Golang NsecToTimeval函数的具体用法?Golang NsecToTimeval怎么用?Golang NsecToTimeval使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了NsecToTimeval函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: Chtimes
// Chtimes changes the access and modification times of the named
// file, similar to the Unix utime() or utimes() functions.
//
// The argument times are in nanoseconds, although the underlying
// filesystem may truncate or round the values to a more
// coarse time unit.
func Chtimes(name string, atime_ns int64, mtime_ns int64) Error {
var utimes [2]syscall.Timeval
utimes[0] = syscall.NsecToTimeval(atime_ns)
utimes[1] = syscall.NsecToTimeval(mtime_ns)
if e := syscall.Utimes(name, utimes[0:]); e != 0 {
return &PathError{"chtimes", name, Errno(e)}
}
return nil
}
示例2: setClock
func setClock(t time.Time) error {
tv := syscall.NsecToTimeval(t.UnixNano())
if err := syscall.Settimeofday(&tv); err != nil {
return errors.New("settimeofday: " + err.Error())
}
return nil
}
示例3: WaitEvent
// WaitEvent can return dvb.ErrOverflow. If deadline is non zero time WaitEvent
// returns true if it doesn't receive any event up to deatline.
func (f API3) WaitEvent(ev *Event, deadline time.Time) (bool, error) {
fd := f.Fd()
if !deadline.IsZero() {
timeout := deadline.Sub(time.Now())
if timeout <= 0 {
return true, nil
}
var r syscall.FdSet
r.Bits[fd/64] = 1 << (fd % 64)
tv := syscall.NsecToTimeval(int64(timeout))
n, err := syscall.Select(int(fd+1), &r, nil, nil, &tv)
if err != nil {
return false, Error{"get", "event (select)", err}
}
if n == 0 {
return true, nil
}
}
_, _, e := syscall.Syscall(
syscall.SYS_IOCTL,
fd,
_FE_GET_EVENT,
uintptr(unsafe.Pointer(ev)),
)
if e != 0 {
if e == syscall.EOVERFLOW {
return false, dvb.ErrOverflow
}
return false, Error{"get", "event", e}
}
return false, nil
}
示例4: WaitFD
func (p *pollster) WaitFD(nsec int64) (fd int, mode int, err os.Error) {
if p.nReady == 0 {
var timeout *syscall.Timeval
var tv syscall.Timeval
timeout = nil
if nsec > 0 {
tv = syscall.NsecToTimeval(nsec)
timeout = &tv
}
var n, e int
var tmpReadFds, tmpWriteFds syscall.FdSet_t
for {
// Temporary syscall.FdSet_ts into which the values are copied
// because select mutates the values.
tmpReadFds = *p.readFds
tmpWriteFds = *p.writeFds
n, e = syscall.Select(p.maxFd+1, &tmpReadFds, &tmpWriteFds, nil, timeout)
if e != syscall.EINTR {
break
}
}
if e != 0 {
return -1, 0, os.NewSyscallError("select", e)
}
if n == 0 {
return -1, 0, nil
}
p.nReady = n
*p.readyReadFds = tmpReadFds
*p.readyWriteFds = tmpWriteFds
p.lastFd = 0
}
flag := false
for i := p.lastFd; i < p.maxFd+1; i++ {
if syscall.FDIsSet(i, p.readyReadFds) {
flag = true
mode = 'r'
syscall.FDClr(i, p.readyReadFds)
} else if syscall.FDIsSet(i, p.readyWriteFds) {
flag = true
mode = 'w'
syscall.FDClr(i, p.readyWriteFds)
}
if flag {
if !syscall.FDIsSet(i, p.repeatFds) {
p.DelFD(i, mode)
}
p.nReady--
p.lastFd = i
return i, mode, nil
}
}
// Will not reach here. Just to shut up the compiler.
return -1, 0, nil
}
示例5: traceOne
func traceOne(addr *syscall.SockaddrInet4, ttl int) *ReturnArgs {
cli, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_DGRAM, syscall.IPPROTO_UDP)
if err != nil {
exitWithError(err)
}
srv, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_RAW, syscall.IPPROTO_ICMP)
if err != nil {
exitWithError(err)
}
defer syscall.Close(cli)
defer syscall.Close(srv)
// set ttl, stolen from somewhere else...
// https://github.com/aeden/traceroute/blob/master/traceroute.go#L195
if err := syscall.SetsockoptInt(cli, syscall.SOL_IP, syscall.IP_TTL, ttl); err != nil {
exitWithError(err)
}
// set timeout, stolen from somewhere else...
// https://github.com/aeden/traceroute/blob/master/traceroute.go#L197
tv := syscall.NsecToTimeval(1e6 * TIMEOUT)
if err := syscall.SetsockoptTimeval(srv, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &tv); err != nil {
exitWithError(err)
}
if err := syscall.Bind(srv, toAddr(HOST, RECV_PORT)); err != nil {
exitWithError(err)
}
rr := &ReturnArgs{}
start := time.Now()
if err := syscall.Sendto(cli, makeICMP(), 0, addr); err != nil {
return rr
}
buf := make([]byte, 512)
_, from, err := syscall.Recvfrom(srv, buf, 0)
if err != nil {
return rr
}
rr.elapsed = float64(time.Since(start).Nanoseconds()) / 1e6
t, c := parseICMP(buf)
if t == 3 && c == 3 { // Destination port unreachable, type==3 && code==3
rr.done = true
} else if t != 11 { // Time Exceeded, type==11 && code in (0,1)
return rr
}
rr.ok = true
rr.ip = toStr(from)
addrs, err := net.LookupAddr(rr.ip)
if err != nil {
rr.addr = rr.ip
} else {
rr.addr = addrs[0]
}
return rr
}
示例6: Select
// Select wraps syscall.Select with Go types
func Select(n int, r, w, e *FDSet, timeout time.Duration) error {
var timeval *syscall.Timeval
if timeout >= 0 {
t := syscall.NsecToTimeval(timeout.Nanoseconds())
timeval = &t
}
return sysSelect(n, r, w, e, timeval)
}
示例7: Traceroute
// Traceroute executes traceroute to given destination, using options from TracerouteOptions
// and sending updates to chan c
//
// Outbound packets are UDP packets and inbound packets are ICMP.
//
// Returns an error or nil if no error occurred
func Traceroute(dest *net.IPAddr, options *TracerouteOptions, c chan TraceUpdate) (err error) {
var destAddr [4]byte
copy(destAddr[:], dest.IP.To4())
socketAddr, err := getSocketAddr()
if err != nil {
return
}
timeoutMs := (int64)(options.TimeoutMs)
tv := syscall.NsecToTimeval(1000 * 1000 * timeoutMs)
ttl := 1
for {
// Set up receiving socket
recvSocket, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_RAW, syscall.IPPROTO_ICMP)
if err != nil {
log.Fatal("Cannot setup receive socket, please run as root or with CAP_NET_RAW permissions")
return err
}
// Set up sending socket
sendSocket, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_DGRAM, syscall.IPPROTO_UDP)
if err != nil {
log.Fatal("Cannot setup sending socket")
return err
}
start := time.Now()
syscall.SetsockoptInt(sendSocket, 0x0, syscall.IP_TTL, ttl)
syscall.SetsockoptTimeval(recvSocket, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &tv)
syscall.Bind(recvSocket, &syscall.SockaddrInet4{Port: options.Port, Addr: socketAddr})
syscall.Sendto(sendSocket, []byte{0x0}, 0, &syscall.SockaddrInet4{Port: options.Port, Addr: destAddr})
var p = make([]byte, options.PacketSize)
n, from, err := syscall.Recvfrom(recvSocket, p, 0)
elapsed := time.Since(start)
if err == nil {
currAddr := from.(*syscall.SockaddrInet4).Addr
hop := TraceUpdate{Success: true, Address: currAddr, N: n, ElapsedTime: elapsed, TTL: ttl}
currHost, err := net.LookupAddr(hop.addressString())
if err == nil {
hop.Host = currHost[0]
}
// Send update
c <- hop
ttl += 1
// We reached the destination
if ttl > options.MaxTTL || currAddr == destAddr {
ttl = 1
}
} else {
c <- TraceUpdate{Success: false, TTL: ttl}
ttl += 1
}
syscall.Close(recvSocket)
syscall.Close(sendSocket)
}
}
示例8: setSocketTimeout
// setSocketTimeout sets the receive and send timeouts on the given socket.
func setSocketTimeout(fd int, timeout time.Duration) error {
tv := syscall.NsecToTimeval(timeout.Nanoseconds())
for _, opt := range []int{syscall.SO_RCVTIMEO, syscall.SO_SNDTIMEO} {
if err := syscall.SetsockoptTimeval(fd, syscall.SOL_SOCKET, opt, &tv); err != nil {
return os.NewSyscallError("setsockopt", err)
}
}
return nil
}
示例9: Utimens
func (f *AzukiFile) Utimens(a *time.Time, m *time.Time) fuse.Status {
tv := make([]syscall.Timeval, 2)
if a == nil {
tv[0].Usec = _UTIME_OMIT
} else {
n := a.UnixNano()
tv[0] = syscall.NsecToTimeval(n)
}
if m == nil {
tv[1].Usec = _UTIME_OMIT
} else {
n := a.UnixNano()
tv[1] = syscall.NsecToTimeval(n)
}
err := syscall.Futimes(int(f.File.Fd()), tv)
return fuse.ToStatus(err)
}
示例10: Hop
func Hop(port, ttl int, IP_addr net.IP) (*Hop_ret, error) {
ret_addr := net.IPv4(0, 0, 0, 0)
success := false
// make sockets
send_udp_s, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_DGRAM, syscall.IPPROTO_UDP)
if err != nil {
return nil, err
}
recv_icmp_s, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_RAW, syscall.IPPROTO_ICMP)
if err != nil {
return nil, err
}
//editing TTL value for outgoing IPv4 packets
if err := syscall.SetsockoptInt(send_udp_s, syscall.SOL_IP, syscall.IP_TTL, ttl); err != nil {
return nil, err
}
tv := syscall.NsecToTimeval(1000 * 1000 * TIME_OUT_MS)
syscall.SetsockoptTimeval(recv_icmp_s, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &tv)
defer syscall.Close(send_udp_s)
defer syscall.Close(recv_icmp_s)
//connect sockets
if err := syscall.Bind(recv_icmp_s, &syscall.SockaddrInet4{Port: port, Addr: [4]byte{137, 224, 226, 47}}); err != nil {
return nil, err
}
//send udp-packet
var IP [4]byte
copy(IP[:], IP_addr.To4())
if err := syscall.Sendto(send_udp_s, []byte{0x42, 0x42}, 0, &syscall.SockaddrInet4{Port: 1337, Addr: IP}); err != nil {
return nil, err
}
//receive ICMP
recv_buffer := make([]byte, 4096)
_, _, err = syscall.Recvfrom(recv_icmp_s, recv_buffer, 0)
if err == nil {
header, err := ipv4.ParseHeader(recv_buffer)
if err != nil {
log.Errorf("%q", err)
}
success = true
ret_addr = header.Src
} else {
//time out
success = false
ret_addr = net.IPv4(0, 0, 0, 0)
//log.Errorf("%q", err)
}
//resolve (timeout) errors, retry or return false...
return &Hop_ret{Addr: ret_addr, TTL: ttl, success: success}, nil
}
示例11: SetMtime
// This implementation should work for all systems that implement the utimes syscall
func (e *entry) SetMtime(mtime time.Time) error {
tvMtime := syscall.NsecToTimeval(mtime.UnixNano())
tvAtime := syscall.NsecToTimeval(time.Now().UnixNano())
resolvedPath := resolveSymlink(e.realPath())
err := syscall.Utimes(resolvedPath, []syscall.Timeval{tvAtime, tvMtime})
if err != nil {
return err
}
e.fileInfo, err = os.Stat(resolvedPath)
if err != nil {
return err
}
return nil
}
示例12: LockShared
// Take a shared lock on an object.
func (ioctx *IOContext) LockShared(oid, name, cookie, tag, desc string, duration time.Duration, flags *byte) (int, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_cookie := C.CString(cookie)
c_tag := C.CString(tag)
c_desc := C.CString(desc)
var c_duration C.struct_timeval
if duration != 0 {
tv := syscall.NsecToTimeval(time.Now().Add(duration).UnixNano())
c_duration = C.struct_timeval{tv_sec: C.__time_t(tv.Sec), tv_usec: C.__suseconds_t(tv.Usec)}
}
var c_flags C.uint8_t
if flags != nil {
c_flags = C.uint8_t(*flags)
}
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_cookie))
defer C.free(unsafe.Pointer(c_tag))
defer C.free(unsafe.Pointer(c_desc))
ret := C.rados_lock_shared(
ioctx.ioctx,
c_oid,
c_name,
c_cookie,
c_tag,
c_desc,
&c_duration,
c_flags)
// 0 on success, negative error code on failure
// -EBUSY if the lock is already held by another (client, cookie) pair
// -EEXIST if the lock is already held by the same (client, cookie) pair
switch ret {
case 0:
return int(ret), nil
case -16: // EBUSY
return int(ret), nil
case -17: // EEXIST
return int(ret), nil
default:
return int(ret), RadosError(int(ret))
}
}
示例13: SetSocketTimeout
// SetSocketTimeout sets the send and receive timeout for each socket in the
// netlink handle. Although the socket timeout has granularity of one
// microsecond, the effective granularity is floored by the kernel timer tick,
// which default value is four milliseconds.
func (h *Handle) SetSocketTimeout(to time.Duration) error {
if to < time.Microsecond {
return fmt.Errorf("invalid timeout, minimul value is %s", time.Microsecond)
}
tv := syscall.NsecToTimeval(to.Nanoseconds())
for _, sh := range h.sockets {
fd := sh.Socket.GetFd()
err := syscall.SetsockoptTimeval(fd, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &tv)
if err != nil {
return err
}
err = syscall.SetsockoptTimeval(fd, syscall.SOL_SOCKET, syscall.SO_SNDTIMEO, &tv)
if err != nil {
return err
}
}
return nil
}
示例14: main
func main() {
lsFiles := exec.Command("git", "ls-files", "-z")
out, err := lsFiles.Output()
if err != nil {
fmt.Fprint(os.Stderr, err)
os.Exit(1)
}
files := strings.Split(strings.TrimRight(string(out), "\x00"), "\x00")
for _, file := range files {
gitLog := exec.Command(
"/bin/sh", "-c",
fmt.Sprintf(`git log -n 1 --date=rfc2822 "%s" | head -n 3 | tail -n 1`, file),
)
out, err := gitLog.Output()
if err != nil {
fmt.Fprint(os.Stderr, err)
os.Exit(1)
}
mStr := strings.TrimSpace(strings.TrimLeft(string(out), "Date:"))
mTime, err := time.Parse(rfc2822, mStr)
if err != nil {
fmt.Fprintf(os.Stderr, "%s on %s", err, file)
os.Exit(1)
}
mTimeval := syscall.NsecToTimeval(mTime.UnixNano())
times := []syscall.Timeval{
mTimeval,
mTimeval,
}
syscall.Utimes(file, times)
fmt.Printf("%s: %s\n", file, mTime)
}
}
示例15: waitWithTimeout
func waitWithTimeout(socket int, timeout time.Duration) (state SocketState, err error) {
wfdset := &syscall.FdSet{}
FD_ZERO(wfdset)
FD_SET(wfdset, socket)
timeval := syscall.NsecToTimeval(int64(timeout))
syscall.Select(socket+1, nil, wfdset, nil, &timeval)
errcode, err := syscall.GetsockoptInt(socket, syscall.SOL_SOCKET, syscall.SO_ERROR)
if err != nil {
state = SocketError
return
}
if errcode == int(syscall.EHOSTUNREACH) {
state = SocketNotReached
return
}
if errcode == int(syscall.ECONNREFUSED) {
state = SocketPortClosed
return
}
if errcode != 0 {
state = SocketError
err = fmt.Errorf("Connect Error: %v", errcode)
return
}
if FD_ISSET(wfdset, socket) {
state = SocketConnected
} else {
state = SocketTimedOut
}
return
}