2011-08-17 11:28:29 -06:00
|
|
|
// Copyright 2009 The Go Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
net, cmd/fix: add IPv6 scoped addressing zone to INET, INET6 address structs
This CL starts to introduce IPv6 scoped addressing capability
into the net package.
The Public API changes are:
+pkg net, type IPAddr struct, Zone string
+pkg net, type IPNet struct, Zone string
+pkg net, type TCPAddr struct, Zone string
+pkg net, type UDPAddr struct, Zone string
Update #4234.
R=rsc, bradfitz, iant
CC=golang-dev
https://golang.org/cl/6849045
2012-11-26 08:45:42 -07:00
|
|
|
// Internet protocol family sockets for Plan 9
|
2011-08-17 11:28:29 -06:00
|
|
|
|
|
|
|
package net
|
|
|
|
|
|
|
|
import (
|
2011-11-01 20:05:34 -06:00
|
|
|
"errors"
|
2011-08-17 11:28:29 -06:00
|
|
|
"os"
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
"syscall"
|
2011-08-17 11:28:29 -06:00
|
|
|
)
|
|
|
|
|
2012-06-06 16:38:56 -06:00
|
|
|
// /sys/include/ape/sys/socket.h:/SOMAXCONN
|
|
|
|
var listenerBacklog = 5
|
|
|
|
|
2012-09-26 01:11:49 -06:00
|
|
|
// probeIPv6Stack returns two boolean values. If the first boolean
|
|
|
|
// value is true, kernel supports basic IPv6 functionality. If the
|
|
|
|
// second boolean value is true, kernel supports IPv6 IPv4-mapping.
|
2011-08-17 11:28:29 -06:00
|
|
|
func probeIPv6Stack() (supportsIPv6, supportsIPv4map bool) {
|
|
|
|
return false, false
|
|
|
|
}
|
|
|
|
|
|
|
|
// parsePlan9Addr parses address of the form [ip!]port (e.g. 127.0.0.1!80).
|
2011-11-01 20:05:34 -06:00
|
|
|
func parsePlan9Addr(s string) (ip IP, iport int, err error) {
|
2012-01-31 08:36:45 -07:00
|
|
|
addr := IPv4zero // address contains port only
|
2012-02-05 17:59:32 -07:00
|
|
|
i := byteIndex(s, '!')
|
2011-08-17 11:28:29 -06:00
|
|
|
if i >= 0 {
|
|
|
|
addr = ParseIP(s[:i])
|
|
|
|
if addr == nil {
|
2012-01-31 08:36:45 -07:00
|
|
|
return nil, 0, errors.New("net: parsing IP failed")
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
|
|
|
}
|
2012-01-31 08:36:45 -07:00
|
|
|
p, _, ok := dtoi(s[i+1:], 0)
|
2011-08-17 11:28:29 -06:00
|
|
|
if !ok {
|
2012-01-31 08:36:45 -07:00
|
|
|
return nil, 0, errors.New("net: parsing port failed")
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
|
|
|
if p < 0 || p > 0xFFFF {
|
2012-01-31 08:36:45 -07:00
|
|
|
return nil, 0, &AddrError{"invalid port", string(p)}
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
|
|
|
return addr, p, nil
|
|
|
|
}
|
|
|
|
|
2011-11-01 20:05:34 -06:00
|
|
|
func readPlan9Addr(proto, filename string) (addr Addr, err error) {
|
2011-08-17 11:28:29 -06:00
|
|
|
var buf [128]byte
|
|
|
|
|
|
|
|
f, err := os.Open(filename)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
2012-06-06 16:38:56 -06:00
|
|
|
defer f.Close()
|
2011-08-17 11:28:29 -06:00
|
|
|
n, err := f.Read(buf[:])
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
ip, port, err := parsePlan9Addr(string(buf[:n]))
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
switch proto {
|
|
|
|
case "tcp":
|
net, cmd/fix: add IPv6 scoped addressing zone to INET, INET6 address structs
This CL starts to introduce IPv6 scoped addressing capability
into the net package.
The Public API changes are:
+pkg net, type IPAddr struct, Zone string
+pkg net, type IPNet struct, Zone string
+pkg net, type TCPAddr struct, Zone string
+pkg net, type UDPAddr struct, Zone string
Update #4234.
R=rsc, bradfitz, iant
CC=golang-dev
https://golang.org/cl/6849045
2012-11-26 08:45:42 -07:00
|
|
|
addr = &TCPAddr{IP: ip, Port: port}
|
2011-08-17 11:28:29 -06:00
|
|
|
case "udp":
|
net, cmd/fix: add IPv6 scoped addressing zone to INET, INET6 address structs
This CL starts to introduce IPv6 scoped addressing capability
into the net package.
The Public API changes are:
+pkg net, type IPAddr struct, Zone string
+pkg net, type IPNet struct, Zone string
+pkg net, type TCPAddr struct, Zone string
+pkg net, type UDPAddr struct, Zone string
Update #4234.
R=rsc, bradfitz, iant
CC=golang-dev
https://golang.org/cl/6849045
2012-11-26 08:45:42 -07:00
|
|
|
addr = &UDPAddr{IP: ip, Port: port}
|
2011-08-17 11:28:29 -06:00
|
|
|
default:
|
2011-11-01 20:05:34 -06:00
|
|
|
return nil, errors.New("unknown protocol " + proto)
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
|
|
|
return addr, nil
|
|
|
|
}
|
|
|
|
|
2011-11-01 20:05:34 -06:00
|
|
|
func startPlan9(net string, addr Addr) (ctl *os.File, dest, proto, name string, err error) {
|
2011-08-17 11:28:29 -06:00
|
|
|
var (
|
|
|
|
ip IP
|
|
|
|
port int
|
|
|
|
)
|
|
|
|
switch a := addr.(type) {
|
|
|
|
case *TCPAddr:
|
|
|
|
proto = "tcp"
|
|
|
|
ip = a.IP
|
|
|
|
port = a.Port
|
|
|
|
case *UDPAddr:
|
|
|
|
proto = "udp"
|
|
|
|
ip = a.IP
|
|
|
|
port = a.Port
|
|
|
|
default:
|
|
|
|
err = UnknownNetworkError(net)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
clone, dest, err := queryCS1(proto, ip, port)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
f, err := os.OpenFile(clone, os.O_RDWR, 0)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var buf [16]byte
|
|
|
|
n, err := f.Read(buf[:])
|
|
|
|
if err != nil {
|
2012-06-06 16:38:56 -06:00
|
|
|
f.Close()
|
2011-08-17 11:28:29 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
return f, dest, proto, string(buf[:n]), nil
|
|
|
|
}
|
|
|
|
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
func netErr(e error) {
|
|
|
|
oe, ok := e.(*OpError)
|
|
|
|
if !ok {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if pe, ok := oe.Err.(*os.PathError); ok {
|
|
|
|
if _, ok = pe.Err.(syscall.ErrorString); ok {
|
|
|
|
oe.Err = pe.Err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func dialPlan9(net string, laddr, raddr Addr) (fd *netFD, err error) {
|
|
|
|
defer func() { netErr(err) }()
|
2011-08-17 11:28:29 -06:00
|
|
|
f, dest, proto, name, err := startPlan9(net, raddr)
|
|
|
|
if err != nil {
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
return nil, &OpError{"dial", net, raddr, err}
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
|
|
|
_, err = f.WriteString("connect " + dest)
|
|
|
|
if err != nil {
|
2012-06-06 16:38:56 -06:00
|
|
|
f.Close()
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
return nil, &OpError{"dial", f.Name(), raddr, err}
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
2013-02-19 18:11:17 -07:00
|
|
|
data, err := os.OpenFile("/net/"+proto+"/"+name+"/data", os.O_RDWR, 0)
|
|
|
|
if err != nil {
|
|
|
|
f.Close()
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
return nil, &OpError{"dial", net, raddr, err}
|
2013-02-19 18:11:17 -07:00
|
|
|
}
|
2011-08-17 11:28:29 -06:00
|
|
|
laddr, err = readPlan9Addr(proto, "/net/"+proto+"/"+name+"/local")
|
|
|
|
if err != nil {
|
2013-02-19 18:11:17 -07:00
|
|
|
data.Close()
|
2012-06-06 16:38:56 -06:00
|
|
|
f.Close()
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
return nil, &OpError{"dial", proto, raddr, err}
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
2013-02-19 18:11:17 -07:00
|
|
|
return newFD(proto, name, f, data, laddr, raddr), nil
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
|
|
|
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
func listenPlan9(net string, laddr Addr) (fd *netFD, err error) {
|
|
|
|
defer func() { netErr(err) }()
|
2011-08-17 11:28:29 -06:00
|
|
|
f, dest, proto, name, err := startPlan9(net, laddr)
|
|
|
|
if err != nil {
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
return nil, &OpError{"listen", net, laddr, err}
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
|
|
|
_, err = f.WriteString("announce " + dest)
|
|
|
|
if err != nil {
|
2012-06-06 16:38:56 -06:00
|
|
|
f.Close()
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
return nil, &OpError{"announce", proto, laddr, err}
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
|
|
|
laddr, err = readPlan9Addr(proto, "/net/"+proto+"/"+name+"/local")
|
|
|
|
if err != nil {
|
2012-06-06 16:38:56 -06:00
|
|
|
f.Close()
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
return nil, &OpError{Op: "listen", Net: net, Err: err}
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
2013-02-19 18:11:17 -07:00
|
|
|
return newFD(proto, name, f, nil, laddr, nil), nil
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
|
|
|
|
2012-11-13 00:18:37 -07:00
|
|
|
func (l *netFD) netFD() *netFD {
|
2013-02-19 18:11:17 -07:00
|
|
|
return newFD(l.proto, l.name, l.ctl, l.data, l.laddr, l.raddr)
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
|
|
|
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
func (l *netFD) acceptPlan9() (fd *netFD, err error) {
|
|
|
|
defer func() { netErr(err) }()
|
2011-08-17 11:28:29 -06:00
|
|
|
f, err := os.Open(l.dir + "/listen")
|
|
|
|
if err != nil {
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
return nil, &OpError{"accept", l.dir + "/listen", l.laddr, err}
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
|
|
|
var buf [16]byte
|
|
|
|
n, err := f.Read(buf[:])
|
|
|
|
if err != nil {
|
2012-06-06 16:38:56 -06:00
|
|
|
f.Close()
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
return nil, &OpError{"accept", l.dir + "/listen", l.laddr, err}
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
|
|
|
name := string(buf[:n])
|
2013-02-19 18:11:17 -07:00
|
|
|
data, err := os.OpenFile("/net/"+l.proto+"/"+name+"/data", os.O_RDWR, 0)
|
2011-08-17 11:28:29 -06:00
|
|
|
if err != nil {
|
2012-06-06 16:38:56 -06:00
|
|
|
f.Close()
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
return nil, &OpError{"accept", l.proto, l.laddr, err}
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
2013-02-19 18:11:17 -07:00
|
|
|
raddr, err := readPlan9Addr(l.proto, "/net/"+l.proto+"/"+name+"/remote")
|
2011-08-17 11:28:29 -06:00
|
|
|
if err != nil {
|
2013-02-19 18:11:17 -07:00
|
|
|
data.Close()
|
2012-06-06 16:38:56 -06:00
|
|
|
f.Close()
|
net, os, syscall: Plan 9: adjust error handling
syscall: Use NewError for all system errors and introduce
some new errors for compatibility with other packages
and proper error handling in net. Also introduce
Temporary and Timeout methods on ErrorString.
net: Make errors from dial, accept, listen functions follow the
OpError standard and discern whether the underlying
error came from syscall. Since Plan 9 uses a correspondence
between file and network operations, all system error
reporting happens through the underlying file operation.
In Go code, we go through package os for file operations,
so there is another level of indirection in error types.
This change allows us to compare the errors with those in
package syscall, when appropriate.
os: Just use the error string already present in package os,
instead of calling out to package syscall.
R=rsc, ality, rminnich, bradfitz
CC=golang-dev
https://golang.org/cl/7398054
2013-02-27 22:43:21 -07:00
|
|
|
return nil, &OpError{"accept", l.proto, l.laddr, err}
|
2011-08-17 11:28:29 -06:00
|
|
|
}
|
2013-02-19 18:11:17 -07:00
|
|
|
return newFD(l.proto, name, f, data, l.laddr, raddr), nil
|
2012-09-26 01:11:49 -06:00
|
|
|
}
|