func childMain() error { var err error pipe := os.NewFile(uintptr(3), "pipe") if pipe != nil { defer pipe.Close() if err == nil { pipe.Write([]byte{DaemonSuccess}) } else { pipe.Write([]byte{DaemonFailure}) } } signal.Ignore(syscall.SIGCHLD) syscall.Close(0) syscall.Close(1) syscall.Close(2) syscall.Setsid() syscall.Umask(022) // syscall.Chdir("/") return nil }
func listenStream(netw, addr string) (l net.Listener, err error) { var ( file *os.File ) fd, err := listen(netw, addr) if err != nil { return nil, err } // Set backlog size to the maximum if err = syscall.Listen(fd, syscall.SOMAXCONN); err != nil { syscall.Close(fd) return nil, err } file = os.NewFile(uintptr(fd), filePrefix+strconv.Itoa(os.Getpid())) if l, err = net.FileListener(file); err != nil { syscall.Close(fd) return nil, err } if err = file.Close(); err != nil { syscall.Close(fd) l.Close() return nil, err } return l, err }
func TestSelect(t *testing.T) { var p1, p2 [2]int mustNil(syscall.Pipe(p1[:])) mustNil(syscall.Pipe(p2[:])) fs := NewFdSet(p1[0], p2[0]) var maxfd int if p1[0] > p2[0] { maxfd = p1[0] + 1 } else { maxfd = p2[0] + 1 } go func() { syscall.Write(p1[1], []byte("to p1")) syscall.Write(p2[1], []byte("to p2")) syscall.Close(p1[1]) syscall.Close(p2[1]) }() e := Select(maxfd+1, fs, nil, nil, nil) if e != nil { t.Errorf("Select(%v, %v, nil, nil, nil) => %v, want <nil>", maxfd+1, fs, e) } syscall.Close(p1[0]) syscall.Close(p2[0]) }
func CaptureStream(file *os.File) (*os.File, func(), error) { pipeR, pipeW, err := os.Pipe() if err != nil { return nil, nil, err } bkupFD, err := syscall.Dup(int(file.Fd())) if err != nil { pipeW.Close() pipeR.Close() return nil, nil, err } err = syscall.Dup2(int(pipeW.Fd()), int(file.Fd())) if err != nil { syscall.Close(bkupFD) pipeW.Close() pipeR.Close() } cleanFunc := func() { syscall.Dup2(bkupFD, int(file.Fd())) syscall.Close(bkupFD) pipeW.Close() pipeR.Close() } return pipeR, cleanFunc, nil }
func (sc *selectCtx) Init() error { sc.rset.Zero() sc.wset.Zero() sc.fdmax = -1 // Create and configure the pipe-ends. b := make([]int, 2) err := syscall.Pipe(b) if err != nil { return err } sc.pfdr, sc.pfdw = b[0], b[1] syscall.CloseOnExec(sc.pfdr) syscall.CloseOnExec(sc.pfdw) err = syscall.SetNonblock(sc.pfdr, true) if err != nil { syscall.Close(sc.pfdr) syscall.Close(sc.pfdw) return err } err = syscall.SetNonblock(sc.pfdw, true) if err != nil { syscall.Close(sc.pfdr) syscall.Close(sc.pfdw) return err } // pfdr (read-end of pipe) is set (and remains set forever) on // rset. sc.rset.Set(sc.pfdr) sc.fdmax = sc.pfdr // allocate dummy selectCtx.{b,b1} buffers. sc.b = make([]byte, 1) sc.b1 = make([]byte, 128) return nil }
// Close wraps syscall.Close. func (sw *Switch) Close(s int) (err error) { so := sw.sockso(s) if so == nil { return syscall.Close(s) } sw.fmu.RLock() f, _ := sw.fltab[FilterClose] sw.fmu.RUnlock() af, err := f.apply(so) if err != nil { return err } so.Err = syscall.Close(s) if err = af.apply(so); err != nil { return err } if so.Err != nil { return so.Err } sw.smu.Lock() delete(sw.sotab, s) sw.stats.getLocked(so.Cookie).Closed++ sw.smu.Unlock() return nil }
func main() { args := Arguments() infile, args, err := args.String("in-file", nil) Check(err) outfile, args, err := args.String("out-file", nil) Check(err) infd, err := syscall.Open(infile, int(ReadOnly), 0) Check(err) defer func() { Check(syscall.Close(infd)) }() flags := Create | WriteOnly | Truncate perms := 0 | UserRead | UserWrite | GroupRead | GroupWrite | OtherRead | OtherWrite outfd, err := syscall.Open(outfile, int(flags), uint32(perms)) Check(err) defer func() { Check(syscall.Close(outfd)) }() bufSize := 1024 buf := make([]byte, bufSize) var n int for { n, err = syscall.Read(infd, buf) Check(err) if n == 0 { break } _, err = syscall.Write(outfd, buf[:n]) Check(err) } }
func (s *Splicer) CopyBytes(in, out *net.TCPConn) { // Close the tcp connection given to us. defer func() { // TODO: Double close problems? out.Close() in.Close() }() // Invoking File() on the connection will duplicate the socket fd, setting // the original (socket fd) to block. inFile, err := in.File() if err != nil { log.Fatal(err) } inFD := int(inFile.Fd()) defer syscall.Close(inFD) outFile, err := out.File() if err != nil { log.Fatal(err) } outFD := int(outFile.Fd()) defer syscall.Close(outFD) var wg sync.WaitGroup wg.Add(2) go s.splice(fmt.Sprintf("from backend: %v -> %v", in.RemoteAddr(), out.RemoteAddr()), inFD, outFD, &wg) go s.splice(fmt.Sprintf("to backend: %v -> %v", out.RemoteAddr(), in.RemoteAddr()), outFD, inFD, &wg) wg.Wait() }
func main() { fd := make([]int, 2) if err := syscall.Pipe(fd); err != nil { log.Fatal("Socketpair:", err) } defer syscall.Close(fd[0]) defer syscall.Close(fd[1]) name := fmt.Sprintf("/proc/%d/fd/%d", os.Getpid(), fd[1]) fmt.Println(name) cmd := exec.Command("ubertooth-btle", "-f", "-d", name) if err := cmd.Start(); err != nil { log.Fatal(err) } f := os.NewFile(uintptr(fd[0]), "server") buf := make([]byte, 1024) for { n, err := f.Read(buf) if err == io.EOF { break } if err != nil { log.Fatal(err) } fmt.Printf("%q\n", buf[:n]) } }
/* c.sa = new(syscall.SockaddrInet4) c.sa.Addr = [4]byte{10, 1, 1, 131} c.sa.Port = port */ func (c *Worker) socket() { begin := time.Now() s, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, 0) if err != nil { syscall.Close(s) return } err = syscall.Connect(s, nil) //TODO if err != nil { lg(err) syscall.Close(s) return } _, err = syscall.Write(s, message.content) if err != nil { syscall.Close(s) return } _, err = syscall.Read(s, c.data) if err != nil { syscall.Close(s) return } syscall.Close(s) time.Now().Sub(begin) }
func ListenPipe(path, sddl string) (net.Listener, error) { var ( sd []byte err error ) if sddl != "" { sd, err = sddlToSecurityDescriptor(sddl) if err != nil { return nil, err } } h, err := makeServerPipeHandle(path, sd, true) if err != nil { return nil, err } // Immediately open and then close a client handle so that the named pipe is // created but not currently accepting connections. h2, err := createFile(path, 0, 0, nil, syscall.OPEN_EXISTING, cSECURITY_SQOS_PRESENT|cSECURITY_ANONYMOUS, 0) if err != nil { syscall.Close(h) return nil, err } syscall.Close(h2) l := &win32PipeListener{ firstHandle: h, path: path, securityDescriptor: sd, acceptCh: make(chan (chan acceptResponse)), closeCh: make(chan int), doneCh: make(chan int), } go l.listenerRoutine() return l, nil }
func afterDaemonize(err error) { // Ignore SIGCHLD signal signal.Ignore(syscall.SIGCHLD) // Close STDOUT, STDIN, STDERR syscall.Close(0) syscall.Close(1) syscall.Close(2) // Become the process group leader syscall.Setsid() // // Clear umask syscall.Umask(022) // // chdir for root directory syscall.Chdir("/") // Notify that the child process started successfuly pipe := os.NewFile(uintptr(3), "pipe") if pipe != nil { defer pipe.Close() if err == nil { pipe.Write([]byte{DAEMONIZE_SUCCESS}) } else { pipe.Write([]byte{DAEMONIZE_FAIL}) } } }
func (w *Watcher) readEvent() { var ( buf [syscall.SizeofInotifyEvent * 4096]byte // Buffer for a maximum of 4096 raw events n int // Number of bytes read with read() errno error // Syscall errno ) for { select { case <-w.done: syscall.Close(w.fd) close(w.acceptEvent) close(w.Error) return default: } n, errno = syscall.Read(w.fd, buf[0:]) if n == 0 { syscall.Close(w.fd) close(w.acceptEvent) close(w.Error) return } if n < syscall.SizeofInotifyEvent { log.Fatal("size of InotifyEvent error", errno) } var offset uint32 = 0 for offset <= uint32(n-syscall.SizeofInotifyEvent) { raw := (*syscall.InotifyEvent)(unsafe.Pointer(&buf[offset])) event := new(FileEvent) event.wd = raw.Wd event.nameLen = raw.Len event.mask = raw.Mask event.cookie = raw.Cookie path := w.wm.paths[int(raw.Wd)] if raw.Len > 0 { // Point "bytes" at the first byte of the filename bytes := (*[syscall.PathMax]byte)(unsafe.Pointer(&buf[offset+syscall.SizeofInotifyEvent])) // The filename is padded with NUL bytes. TrimRight() gets rid of those. event.fileName = path + "/" + strings.TrimRight(string(bytes[0:raw.Len]), "\000") } if _, found := w.skipExt[filepath.Ext(event.fileName)]; !found { fmt.Println("--->", w.skipExt, "--->", filepath.Ext(event.fileName), "--->", found) //发送事件acceptEvent通道 w.acceptEvent <- event } else { fmt.Println("过滤文件:", event.fileName) } offset += syscall.SizeofInotifyEvent + raw.Len } } }
func (io *NetIOManager) ProxyNetAccept(serverinfo syscall.Sockaddr) (sa syscall.Sockaddr, err error) { var clientfd, serverfd int // accpet mongodb client connection request clientfd, clientinfo, err := syscall.Accept(io.proxy_server_fd) if err != nil { goto ClientError } err = syscall.SetNonblock(clientfd, true) if err != nil { goto ClientCleanup } err = syscall.EpollCtl(io.epoll_fd, syscall.EPOLL_CTL_ADD, clientfd, &syscall.EpollEvent{Events: syscall.EPOLLIN | syscall.EPOLLOUT | syscall.EPOLLRDHUP, Fd: int32(clientfd)}) if err != nil { goto ClientCleanup } // establish connection with mongodb server serverfd, err = syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, syscall.IPPROTO_TCP) if err != nil { goto ServerError } err = syscall.Connect(serverfd, serverinfo) if err != nil { goto ServerCleanup } err = syscall.SetNonblock(serverfd, true) if err != nil { goto ServerCleanup } err = syscall.EpollCtl(io.epoll_fd, syscall.EPOLL_CTL_ADD, serverfd, &syscall.EpollEvent{Events: syscall.EPOLLIN | syscall.EPOLLOUT | syscall.EPOLLRDHUP, Fd: int32(serverfd)}) if err != nil { goto ServerCleanup } // now proxy server becomes a bridge between client <-> server add_sock_peer(io, clientfd, clientinfo, serverfd, serverinfo) return clientinfo, nil ServerCleanup: syscall.Close(serverfd) ServerError: syscall.EpollCtl(io.epoll_fd, syscall.EPOLL_CTL_DEL, clientfd, &syscall.EpollEvent{Events: syscall.EPOLLIN | syscall.EPOLLOUT | syscall.EPOLLRDHUP, Fd: int32(clientfd)}) ClientCleanup: syscall.Close(clientfd) ClientError: return nil, err }
func initJob() { // Create Job object and assign current process to it. jobObject, err := createJobObject(nil, nil) if err != nil { log.Printf("CreateJobObject failed: %v", err) return } if err = assignProcessToJobObject(jobObject, currentProcess); err != nil { log.Printf("AssignProcessToJobObject failed: %v", err) syscall.Close(jobObject) return } iocp, err := syscall.CreateIoCompletionPort(syscall.InvalidHandle, 0, 0, 1) if err != nil { log.Printf("CreateIoCompletionPort failed: %v", err) syscall.Close(jobObject) return } port := JOBOBJECT_ASSOCIATE_COMPLETION_PORT{ CompletionKey: uintptr(jobObject), CompletionPort: iocp, } err = setInformationJobObject(jobObject, JobObjectAssociateCompletionPortInformation, uintptr(unsafe.Pointer(&port)), uint32(unsafe.Sizeof(port))) if err != nil { log.Printf("SetInformationJobObject failed: %v", err) syscall.Close(jobObject) syscall.Close(iocp) return } // Read Job notifications about new "child" processes and collect them in childProcesses. go func() { var code, key uint32 var o *syscall.Overlapped for { err := syscall.GetQueuedCompletionStatus(iocp, &code, &key, &o, syscall.INFINITE) if err != nil { log.Printf("GetQueuedCompletionStatus failed: %v", err) return } if key != uint32(jobObject) { panic("Invalid GetQueuedCompletionStatus key parameter") } if code == JOB_OBJECT_MSG_NEW_PROCESS { pid := int(uintptr(unsafe.Pointer(o))) if pid == syscall.Getpid() { continue } c, err := syscall.OpenProcess(syscall.PROCESS_QUERY_INFORMATION, false, uint32(pid)) if err != nil { log.Printf("OpenProcess failed: %v", err) continue } childMu.Lock() childProcesses = append(childProcesses, c) childMu.Unlock() } } }() }
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 }
func (constor *Constor) Write(input *fuse.WriteIn, data []byte) (written uint32, code fuse.Status) { constor.log("%d", input.Fh) ptr := uintptr(input.Fh) offset := input.Offset F := constor.getfd(ptr) if F == nil { constor.error("F == nil") return 0, fuse.EIO } inode, err := constor.inodemap.findInode(input.NodeId) if err != nil { constor.error("%s", err) return 0, fuse.ToStatus(err) } if F.layer != 0 && inode.layer != 0 { err = constor.copyup(inode) if err != nil { constor.error("%s", err) return 0, fuse.ToStatus(err) } path, err := constor.dentrymap.getPath(inode.ino) if err != nil { constor.error("%s", err) return 0, fuse.ToStatus(err) } pathl := Path.Join(constor.layers[0], path) syscall.Close(F.fd) fd, err := syscall.Open(pathl, F.flags, 0) if err != nil { constor.error("%s", err) return 0, fuse.ToStatus(err) } F.fd = fd F.layer = 0 constor.log("reset fd for %s", path) } else if F.layer != 0 && inode.layer == 0 { syscall.Close(F.fd) path, err := constor.dentrymap.getPath(inode.ino) if err != nil { constor.error("%s", err) return 0, fuse.ToStatus(err) } pathl := Path.Join(constor.layers[0] + path) fd, err := syscall.Open(pathl, F.flags, 0) if err != nil { constor.error("%s", err) return 0, fuse.ToStatus(err) } F.fd = fd F.layer = 0 constor.log("reset fd for %s", path) } fd := F.fd n, err := syscall.Pwrite(fd, data, int64(offset)) return uint32(n), fuse.ToStatus(err) }
// 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) } }
// ListenPacket listens for incoming ICMP packets addressed to // address. See net.Dial for the syntax of address. // // For non-privileged datagram-oriented ICMP endpoints, network must // be "udp4" or "udp6". The endpoint allows to read, write a few // limited ICMP messages such as echo request and echo reply. // Currently only Darwin and Linux support this. // // Examples: // ListenPacket("udp4", "192.168.0.1") // ListenPacket("udp4", "0.0.0.0") // ListenPacket("udp6", "fe80::1%en0") // ListenPacket("udp6", "::") // // For privileged raw ICMP endpoints, network must be "ip4" or "ip6" // followed by a colon and an ICMP protocol number or name. // // Examples: // ListenPacket("ip4:icmp", "192.168.0.1") // ListenPacket("ip4:1", "0.0.0.0") // ListenPacket("ip6:ipv6-icmp", "fe80::1%en0") // ListenPacket("ip6:58", "::") func ListenPacket(network, address string) (*PacketConn, error) { var family, proto int switch network { case "udp4": family, proto = syscall.AF_INET, iana.ProtocolICMP case "udp6": family, proto = syscall.AF_INET6, iana.ProtocolIPv6ICMP default: i := last(network, ':') switch network[:i] { case "ip4": proto = iana.ProtocolICMP case "ip6": proto = iana.ProtocolIPv6ICMP } } var cerr error var c net.PacketConn switch family { case syscall.AF_INET, syscall.AF_INET6: s, err := syscall.Socket(family, syscall.SOCK_DGRAM, proto) if err != nil { return nil, os.NewSyscallError("socket", err) } if runtime.GOOS == "darwin" && family == syscall.AF_INET { if err := syscall.SetsockoptInt(s, iana.ProtocolIP, sysIP_STRIPHDR, 1); err != nil { syscall.Close(s) return nil, os.NewSyscallError("setsockopt", err) } } sa, err := sockaddr(family, address) if err != nil { syscall.Close(s) return nil, err } if err := syscall.Bind(s, sa); err != nil { syscall.Close(s) return nil, os.NewSyscallError("bind", err) } f := os.NewFile(uintptr(s), "datagram-oriented icmp") c, cerr = net.FilePacketConn(f) f.Close() default: c, cerr = net.ListenPacket(network, address) } if cerr != nil { return nil, cerr } switch proto { case iana.ProtocolICMP: return &PacketConn{c: c, p4: ipv4.NewPacketConn(c)}, nil case iana.ProtocolIPv6ICMP: return &PacketConn{c: c, p6: ipv6.NewPacketConn(c)}, nil default: return &PacketConn{c: c}, nil } }
func mount(dir string, ready chan<- struct{}, errp *error) (fusefd *os.File, err error) { // linux mount is never delayed close(ready) fds, err := syscall.Socketpair(syscall.AF_FILE, syscall.SOCK_STREAM, 0) if err != nil { return nil, fmt.Errorf("socketpair error: %v", err) } defer syscall.Close(fds[0]) defer syscall.Close(fds[1]) cmd := exec.Command("fusermount", "--", dir) cmd.Env = append(os.Environ(), "_FUSE_COMMFD=3") writeFile := os.NewFile(uintptr(fds[0]), "fusermount-child-writes") defer writeFile.Close() cmd.ExtraFiles = []*os.File{writeFile} out, err := cmd.CombinedOutput() if len(out) > 0 || err != nil { return nil, fmt.Errorf("fusermount: %q, %v", out, err) } readFile := os.NewFile(uintptr(fds[1]), "fusermount-parent-reads") defer readFile.Close() c, err := net.FileConn(readFile) if err != nil { return nil, fmt.Errorf("FileConn from fusermount socket: %v", err) } defer c.Close() uc, ok := c.(*net.UnixConn) if !ok { return nil, fmt.Errorf("unexpected FileConn type; expected UnixConn, got %T", c) } buf := make([]byte, 32) // expect 1 byte oob := make([]byte, 32) // expect 24 bytes _, oobn, _, _, err := uc.ReadMsgUnix(buf, oob) scms, err := syscall.ParseSocketControlMessage(oob[:oobn]) if err != nil { return nil, fmt.Errorf("ParseSocketControlMessage: %v", err) } if len(scms) != 1 { return nil, fmt.Errorf("expected 1 SocketControlMessage; got scms = %#v", scms) } scm := scms[0] gotFds, err := syscall.ParseUnixRights(&scm) if err != nil { return nil, fmt.Errorf("syscall.ParseUnixRights: %v", err) } if len(gotFds) != 1 { return nil, fmt.Errorf("wanted 1 fd; got %#v", gotFds) } f := os.NewFile(uintptr(gotFds[0]), "/dev/fuse") return f, nil }
func Stop() { logger.Log(logger.INFO, "Stop proxy server") if runTunnel != nil { syscall.Close(runTunnel.LFd) for _, tc := range fdTunnelConn { syscall.Close(tc.EFd) syscall.Close(tc.IFd) } } }
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 }
// Listen returns TCP listener with SO_REUSEPORT option set. // // Only tcp4 network is supported. // // ErrNoReusePort error is returned if the system doesn't support SO_REUSEPORT. func Listen(network, addr string) (l net.Listener, err error) { var ( soType, fd int file *os.File sockaddr syscall.Sockaddr ) if sockaddr, soType, err = getSockaddr(network, addr); err != nil { return nil, err } syscall.ForkLock.RLock() fd, err = syscall.Socket(soType, syscall.SOCK_STREAM, syscall.IPPROTO_TCP) if err == nil { syscall.CloseOnExec(fd) } syscall.ForkLock.RUnlock() if err != nil { return nil, err } if err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1); err != nil { syscall.Close(fd) return nil, err } if err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, soReusePort, 1); err != nil { syscall.Close(fd) return nil, &ErrNoReusePort{err} } if err = syscall.Bind(fd, sockaddr); err != nil { syscall.Close(fd) return nil, err } if err = syscall.Listen(fd, syscall.SOMAXCONN); err != nil { syscall.Close(fd) return nil, err } name := fmt.Sprintf("reuseport.%d.%s.%s", os.Getpid(), network, addr) file = os.NewFile(uintptr(fd), name) if l, err = net.FileListener(file); err != nil { file.Close() return nil, err } if err = file.Close(); err != nil { l.Close() return nil, err } return l, err }
func (self *AfAlg) Close() (e error) { err := syscall.Close(self.fd) if err != nil { e = err } syscall.Close(self.conn) if err != nil { e = err } return }
func (gpio *GPIO) AddEdgeDetect(edge GPIOEdge) (chan bool, error) { gpio.RemoveEdgeDetect() err := gpio.SetDirection(GPIO_INPUT) if err != nil { return nil, err } err = gpio.SetEdge(edge) if err != nil { return nil, err } err = gpio.openValueFile() if err != nil { return nil, err } epfd, err := syscall.EpollCreate(1) if err != nil { return nil, err } event := &syscall.EpollEvent{ Events: syscall.EPOLLIN | _EPOLLET | syscall.EPOLLPRI, Fd: int32(gpio.value.Fd()), } err = syscall.EpollCtl(epfd, syscall.EPOLL_CTL_ADD, int(gpio.value.Fd()), event) if err != nil { syscall.Close(epfd) return nil, err } // / first time triggers with current state, so ignore _, err = syscall.EpollWait(epfd, make([]syscall.EpollEvent, 1), -1) if err != nil { syscall.Close(epfd) return nil, err } gpio.epfd.Set(epfd) valueChan := make(chan bool) go func() { for gpio.epfd.Get() != 0 { n, _ := syscall.EpollWait(epfd, make([]syscall.EpollEvent, 1), -1) if n > 0 { value, err := gpio.Value() if err == nil { valueChan <- value } } } }() return valueChan, nil }
// Close all poller file descriptors, but not the one passed to it. func (poller *fdPoller) close() { if poller.pipe[1] != -1 { syscall.Close(poller.pipe[1]) } if poller.pipe[0] != -1 { syscall.Close(poller.pipe[0]) } if poller.epfd != -1 { syscall.Close(poller.epfd) } }
// pivotRoot will call pivot_root such that rootfs becomes the new root // filesystem, and everything else is cleaned up. func pivotRoot(rootfs string) error { // While the documentation may claim otherwise, pivot_root(".", ".") is // actually valid. What this results in is / being the new root but // /proc/self/cwd being the old root. Since we can play around with the cwd // with pivot_root this allows us to pivot without creating directories in // the rootfs. Shout-outs to the LXC developers for giving us this idea. oldroot, err := syscall.Open("/", syscall.O_DIRECTORY|syscall.O_RDONLY, 0) if err != nil { return err } defer syscall.Close(oldroot) newroot, err := syscall.Open(rootfs, syscall.O_DIRECTORY|syscall.O_RDONLY, 0) if err != nil { return err } defer syscall.Close(newroot) // Change to the new root so that the pivot_root actually acts on it. if err := syscall.Fchdir(newroot); err != nil { return err } if err := syscall.PivotRoot(".", "."); err != nil { return fmt.Errorf("pivot_root %s", err) } // Currently our "." is oldroot (according to the current kernel code). // However, purely for safety, we will fchdir(oldroot) since there isn't // really any guarantee from the kernel what /proc/self/cwd will be after a // pivot_root(2). if err := syscall.Fchdir(oldroot); err != nil { return err } // Make oldroot rprivate to make sure our unmounts don't propagate to the // host (and thus bork the machine). if err := syscall.Mount("", ".", "", syscall.MS_PRIVATE|syscall.MS_REC, ""); err != nil { return err } // Preform the unmount. MNT_DETACH allows us to unmount /proc/self/cwd. if err := syscall.Unmount(".", syscall.MNT_DETACH); err != nil { return err } // Switch back to our shiny new root. if err := syscall.Chdir("/"); err != nil { return fmt.Errorf("chdir / %s", err) } return nil }
func (constor *Constor) Write(input *fuse.WriteIn, data []byte) (written uint32, code fuse.Status) { constor.log("%d %d", input.Fh, len(data)) ptr := uintptr(input.Fh) offset := input.Offset wdata := data F := constor.getfd(ptr) if F == nil { constor.error("F == nil") return 0, fuse.EIO } if F.flags&syscall.O_DIRECT != 0 { wdata = directio.AlignedBlock(len(data)) copy(wdata, data) } inode := constor.inodemap.findInodePtr(input.NodeId) if inode == nil { return 0, fuse.ENOENT } if F.layer != 0 && inode.layer != 0 { err := constor.copyup(inode) if err != nil { constor.error("%s", err) return 0, fuse.ToStatus(err) } path := constor.getPath(0, inode.id) syscall.Close(F.fd) fd, err := syscall.Open(path, F.flags, 0) if err != nil { constor.error("%s", err) return 0, fuse.ToStatus(err) } F.fd = fd F.layer = 0 constor.log("reset fd for %s", path) } else if F.layer != 0 && inode.layer == 0 { syscall.Close(F.fd) path := constor.getPath(0, inode.id) fd, err := syscall.Open(path, F.flags, 0) if err != nil { constor.error("%s", err) return 0, fuse.ToStatus(err) } F.fd = fd F.layer = 0 constor.log("reset fd for %s", path) } fd := F.fd n, err := syscall.Pwrite(fd, wdata, int64(offset)) return uint32(n), fuse.ToStatus(err) }
func execinAction(container *libcontainer.Container, cmd *libcontainer.Command, fds []uintptr) error { for _, fd := range fds { if fd > 0 { if err := JoinExistingNamespace(fd, ""); err != nil { for _, fd := range fds { syscall.Close(int(fd)) } return err } } syscall.Close(int(fd)) } if container.Namespaces.Contains(libcontainer.CLONE_NEWNS) && container.Namespaces.Contains(libcontainer.CLONE_NEWPID) { // important: // we need to fork and unshare so that re can remount proc and sys within // the namespace so the CLONE_NEWPID namespace will take effect // if we don't fork we would end up unmounting proc and sys for the entire // namespace child, err := fork() if err != nil { return fmt.Errorf("fork child %s", err) } if child == 0 { if err := unshare(CLONE_NEWNS); err != nil { writeError("unshare newns %s", err) } if err := remountProc(); err != nil { writeError("remount proc %s", err) } if err := remountSys(); err != nil { writeError("remount sys %s", err) } if err := capabilities.DropCapabilities(container); err != nil { writeError("drop caps %s", err) } if err := exec(cmd.Args[0], cmd.Args[0:], cmd.Env); err != nil { writeError("exec %s", err) } // unreachable } exit, err := utils.WaitOnPid(child) if err != nil { writeError("wait on child %s", err) } os.Exit(exit) } return nil }
// Generic socket creation. func socket(net string, f, p, t int, la, ra syscall.Sockaddr, toAddr func(syscall.Sockaddr) Addr) (fd *netFD, err os.Error) { // See ../syscall/exec.go for description of ForkLock. syscall.ForkLock.RLock() s, e := syscall.Socket(f, p, t) if e != 0 { syscall.ForkLock.RUnlock() return nil, os.Errno(e) } syscall.CloseOnExec(s) syscall.ForkLock.RUnlock() // Allow reuse of recently-used addresses. syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1) // Allow broadcast. syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_BROADCAST, 1) if f == syscall.AF_INET6 { // using ip, tcp, udp, etc. // allow both protocols even if the OS default is otherwise. syscall.SetsockoptInt(s, syscall.IPPROTO_IPV6, syscall.IPV6_V6ONLY, 0) } if la != nil { e = syscall.Bind(s, la) if e != 0 { syscall.Close(s) return nil, os.Errno(e) } } if ra != nil { e = syscall.Connect(s, ra) if e != 0 { syscall.Close(s) return nil, os.Errno(e) } } sa, _ := syscall.Getsockname(s) laddr := toAddr(sa) sa, _ = syscall.Getpeername(s) raddr := toAddr(sa) fd, err = newFD(s, f, p, net, laddr, raddr) if err != nil { syscall.Close(s) return nil, err } return fd, nil }