mirror of
https://github.com/golang/go
synced 2024-10-05 16:41:21 -06:00
484 lines
12 KiB
Go
484 lines
12 KiB
Go
|
// 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.
|
||
|
|
||
|
package net
|
||
|
|
||
|
import (
|
||
|
"os";
|
||
|
"ip";
|
||
|
"socket";
|
||
|
"strings";
|
||
|
"syscall"
|
||
|
)
|
||
|
|
||
|
func NewError(s string) *os.Error {
|
||
|
e := new(os.Error);
|
||
|
e.s = s;
|
||
|
return e
|
||
|
}
|
||
|
|
||
|
export var (
|
||
|
BadAddress = NewError("malformed addres");
|
||
|
UnknownNetwork = NewError("unknown network");
|
||
|
UnknownHost = NewError("unknown host");
|
||
|
UnknownPort = NewError("unknown port");
|
||
|
UnknownSocketFamily = NewError("unknown socket family");
|
||
|
)
|
||
|
|
||
|
// Split "host:port" into "host" and "port".
|
||
|
// Host cannot contain colons unless it is bracketed.
|
||
|
func SplitHostPort(hostport string) (host, port string, err *os.Error) {
|
||
|
// The port starts after the last colon.
|
||
|
var i int
|
||
|
for i = len(hostport)-1; i >= 0; i-- {
|
||
|
if hostport[i] == ':' {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
if i < 0 {
|
||
|
return "", "", BadAddress
|
||
|
}
|
||
|
|
||
|
host = hostport[0:i];
|
||
|
port = hostport[i+1:len(hostport)];
|
||
|
|
||
|
// Can put brackets around host ...
|
||
|
if host[0] == '[' && host[len(host)-1] == ']' {
|
||
|
host = host[1:len(host)-1]
|
||
|
} else {
|
||
|
// ... but if there are no brackets, no colons.
|
||
|
for i := 0; i < len(host); i++ {
|
||
|
if host[i] == ':' {
|
||
|
return "", "", BadAddress
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return host, port, nil
|
||
|
}
|
||
|
|
||
|
// Join "host" and "port" into "host:port".
|
||
|
// If host contains colons, will join into "[host]:port".
|
||
|
func JoinHostPort(host, port string) string {
|
||
|
// If host has colons, have to bracket it.
|
||
|
for i := 0; i < len(host); i++ {
|
||
|
if host[i] == ':' {
|
||
|
return "[" + host + "]:" + port
|
||
|
}
|
||
|
}
|
||
|
return host + ":" + port
|
||
|
}
|
||
|
|
||
|
// Convert "host:port" into IP address and port.
|
||
|
// For now, host and port must be numeric literals.
|
||
|
// Eventually, we'll have name resolution.
|
||
|
func HostPortToIP(net string, hostport string) (ip *[]byte, iport int, err *os.Error) {
|
||
|
var host, port string;
|
||
|
host, port, err = SplitHostPort(hostport);
|
||
|
if err != nil {
|
||
|
return nil, 0, err
|
||
|
}
|
||
|
|
||
|
// TODO: Resolve host.
|
||
|
|
||
|
addr := ip.ParseIP(host);
|
||
|
if addr == nil {
|
||
|
print("Failed to parse: ", host, "\n");
|
||
|
return nil, 0, UnknownHost
|
||
|
}
|
||
|
|
||
|
// TODO: Resolve port.
|
||
|
|
||
|
p, ok := strings.atoi(port);
|
||
|
if !ok || p < 0 || p > 0xFFFF {
|
||
|
return nil, 0, UnknownPort
|
||
|
}
|
||
|
|
||
|
return addr, p, nil
|
||
|
}
|
||
|
|
||
|
// Convert socket address into "host:port".
|
||
|
func SockaddrToHostPort(sa *socket.Sockaddr) (hostport string, err *os.Error) {
|
||
|
switch sa.family {
|
||
|
case socket.AF_INET, socket.AF_INET6:
|
||
|
addr, port, e := socket.SockaddrToIP(sa)
|
||
|
if e != nil {
|
||
|
return "", e
|
||
|
}
|
||
|
host := ip.IPToString(addr);
|
||
|
return JoinHostPort(host, strings.itoa(port)), nil
|
||
|
default:
|
||
|
return "", UnknownSocketFamily
|
||
|
}
|
||
|
return "", nil // not reached
|
||
|
}
|
||
|
|
||
|
// Boolean to int.
|
||
|
func boolint(b bool) int {
|
||
|
if b {
|
||
|
return 1
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
|
||
|
// Generic Socket creation.
|
||
|
func Socket(f, p, t int64, la, ra *socket.Sockaddr) (fd int64, err *os.Error) {
|
||
|
s, e := socket.socket(f, p, t);
|
||
|
if e != nil {
|
||
|
return -1, e
|
||
|
}
|
||
|
|
||
|
var r int64
|
||
|
if la != nil {
|
||
|
r, e = socket.bind(s, la)
|
||
|
if e != nil {
|
||
|
syscall.close(s)
|
||
|
return -1, e
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ra != nil {
|
||
|
r, e = socket.connect(s, ra)
|
||
|
if e != nil {
|
||
|
syscall.close(s)
|
||
|
return -1, e
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return s, nil
|
||
|
}
|
||
|
|
||
|
|
||
|
// Generic implementation of Conn interface; not exported.
|
||
|
|
||
|
type ConnBase struct {
|
||
|
fd *os.FD;
|
||
|
raddr string;
|
||
|
}
|
||
|
|
||
|
// Eventually, these will use epoll or some such.
|
||
|
|
||
|
func (c *ConnBase) FD() int64 {
|
||
|
if c == nil || c.fd == nil {
|
||
|
return -1
|
||
|
}
|
||
|
return c.fd.fd
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) Read(b *[]byte) (n int, err *os.Error) {
|
||
|
n, err = c.fd.Read(b)
|
||
|
return n, err
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) Write(b *[]byte) (n int, err *os.Error) {
|
||
|
n, err = c.fd.Write(b)
|
||
|
return n, err
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) ReadFrom(b *[]byte) (n int, raddr string, err *os.Error) {
|
||
|
if c == nil {
|
||
|
return -1, "", os.EINVAL
|
||
|
}
|
||
|
n, err = c.Read(b)
|
||
|
return n, c.raddr, err
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) WriteTo(raddr string, b *[]byte) (n int, err *os.Error) {
|
||
|
if c == nil {
|
||
|
return -1, os.EINVAL
|
||
|
}
|
||
|
if raddr != c.raddr {
|
||
|
return -1, os.EINVAL
|
||
|
}
|
||
|
n, err = c.Write(b)
|
||
|
return n, err
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) Close() *os.Error {
|
||
|
if c == nil {
|
||
|
return os.EINVAL
|
||
|
}
|
||
|
return c.fd.Close()
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) SetReadBuffer(bytes int) *os.Error {
|
||
|
return socket.setsockopt_int(c.FD(), socket.SOL_SOCKET, socket.SO_RCVBUF, bytes);
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) SetWriteBuffer(bytes int) *os.Error {
|
||
|
return socket.setsockopt_int(c.FD(), socket.SOL_SOCKET, socket.SO_SNDBUF, bytes);
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) SetReadTimeout(nsec int64) *os.Error {
|
||
|
return socket.setsockopt_tv(c.FD(), socket.SOL_SOCKET, socket.SO_RCVTIMEO, nsec);
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) SetWriteTimeout(nsec int64) *os.Error {
|
||
|
return socket.setsockopt_tv(c.FD(), socket.SOL_SOCKET, socket.SO_SNDTIMEO, nsec);
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) SetTimeout(nsec int64) *os.Error {
|
||
|
if e := c.SetReadTimeout(nsec); e != nil {
|
||
|
return e
|
||
|
}
|
||
|
return c.SetWriteTimeout(nsec)
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) SetReuseAddr(reuse bool) *os.Error {
|
||
|
return socket.setsockopt_int(c.FD(), socket.SOL_SOCKET, socket.SO_REUSEADDR, boolint(reuse));
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) BindToDevice(dev string) *os.Error {
|
||
|
// TODO: call setsockopt with null-terminated string pointer
|
||
|
return os.EINVAL
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) SetDontRoute(dontroute bool) *os.Error {
|
||
|
return socket.setsockopt_int(c.FD(), socket.SOL_SOCKET, socket.SO_DONTROUTE, boolint(dontroute));
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) SetKeepAlive(keepalive bool) *os.Error {
|
||
|
return socket.setsockopt_int(c.FD(), socket.SOL_SOCKET, socket.SO_KEEPALIVE, boolint(keepalive));
|
||
|
}
|
||
|
|
||
|
func (c *ConnBase) SetLinger(sec int) *os.Error {
|
||
|
return socket.setsockopt_linger(c.FD(), socket.SOL_SOCKET, socket.SO_LINGER, sec);
|
||
|
}
|
||
|
|
||
|
|
||
|
// Internet sockets (TCP, UDP)
|
||
|
|
||
|
// Should we try to use the IPv4 socket interface if we're
|
||
|
// only dealing with IPv4 sockets? As long as the host system
|
||
|
// understands IPv6, it's okay to pass IPv4 addresses to the IPv6
|
||
|
// interface. That simplifies our code and is most general.
|
||
|
// If we need to build on a system without IPv6 support, setting
|
||
|
// PreferIPv4 here should fall back to the IPv4 socket interface when possible.
|
||
|
const PreferIPv4 = false
|
||
|
|
||
|
func DialInternet(net, laddr, raddr string, proto int64) (fd int64, err *os.Error) {
|
||
|
// Parse addresses (unless they are empty).
|
||
|
var lip, rip *[]byte
|
||
|
var lport, rport int
|
||
|
var lerr, rerr *os.Error
|
||
|
if laddr != "" {
|
||
|
lip, lport, lerr = HostPortToIP(net, laddr)
|
||
|
if lerr != nil {
|
||
|
return -1, lerr
|
||
|
}
|
||
|
}
|
||
|
if raddr != "" {
|
||
|
rip, rport, rerr = HostPortToIP(net, raddr)
|
||
|
if rerr != nil {
|
||
|
return -1, rerr
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Figure out IP version.
|
||
|
// If network has a suffix like "tcp4", obey it.
|
||
|
vers := 0;
|
||
|
switch net[len(net)-1] {
|
||
|
case '4':
|
||
|
vers = 4
|
||
|
case '6':
|
||
|
vers = 6
|
||
|
default:
|
||
|
// Otherwise, guess.
|
||
|
// If the addresses are IPv4 and we prefer IPv4, use 4; else 6.
|
||
|
if PreferIPv4
|
||
|
&& (lip == nil || ip.ToIPv4(lip) != nil)
|
||
|
&& (rip == nil || ip.ToIPv4(rip) != nil) {
|
||
|
vers = 4
|
||
|
} else {
|
||
|
vers = 6
|
||
|
}
|
||
|
}
|
||
|
|
||
|
var cvt *(addr *[]byte, port int) (sa *socket.Sockaddr, err *os.Error)
|
||
|
var family int64
|
||
|
if vers == 4 {
|
||
|
cvt = &socket.IPv4ToSockaddr;
|
||
|
family = socket.AF_INET
|
||
|
} else {
|
||
|
cvt = &socket.IPv6ToSockaddr;
|
||
|
family = socket.AF_INET6
|
||
|
}
|
||
|
|
||
|
var la, ra *socket.Sockaddr;
|
||
|
if lip != nil {
|
||
|
la, lerr = cvt(lip, lport);
|
||
|
if lerr != nil {
|
||
|
return -1, lerr
|
||
|
}
|
||
|
}
|
||
|
if rip != nil {
|
||
|
ra, rerr = cvt(rip, rport);
|
||
|
if rerr != nil {
|
||
|
return -1, rerr
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fd, err = Socket(family, proto, 0, la, ra);
|
||
|
return fd, err
|
||
|
}
|
||
|
|
||
|
|
||
|
// TCP connections.
|
||
|
|
||
|
export type ConnTCP struct {
|
||
|
base ConnBase
|
||
|
}
|
||
|
|
||
|
// New TCP methods
|
||
|
func (c *ConnTCP) SetNoDelay(nodelay bool) *os.Error {
|
||
|
if c == nil {
|
||
|
return os.EINVAL
|
||
|
}
|
||
|
return socket.setsockopt_int(c.base.fd.fd, socket.IPPROTO_TCP, socket.TCP_NODELAY, boolint(nodelay))
|
||
|
}
|
||
|
|
||
|
// Wrappers
|
||
|
func (c *ConnTCP) Read(b *[]byte) (n int, err *os.Error) {
|
||
|
n, err = (&c.base).Read(b)
|
||
|
return n, err
|
||
|
}
|
||
|
func (c *ConnTCP) Write(b *[]byte) (n int, err *os.Error) {
|
||
|
n, err = (&c.base).Write(b)
|
||
|
return n, err
|
||
|
}
|
||
|
func (c *ConnTCP) ReadFrom(b *[]byte) (n int, raddr string, err *os.Error) {
|
||
|
n, raddr, err = (&c.base).ReadFrom(b)
|
||
|
return n, raddr, err
|
||
|
}
|
||
|
func (c *ConnTCP) WriteTo(raddr string, b *[]byte) (n int, err *os.Error) {
|
||
|
n, err = (&c.base).WriteTo(raddr, b)
|
||
|
return n, err
|
||
|
}
|
||
|
func (c *ConnTCP) Close() *os.Error {
|
||
|
return (&c.base).Close()
|
||
|
}
|
||
|
func (c *ConnTCP) SetReadBuffer(bytes int) *os.Error {
|
||
|
return (&c.base).SetReadBuffer(bytes)
|
||
|
}
|
||
|
func (c *ConnTCP) SetWriteBuffer(bytes int) *os.Error {
|
||
|
return (&c.base).SetWriteBuffer(bytes)
|
||
|
}
|
||
|
func (c *ConnTCP) SetTimeout(nsec int64) *os.Error {
|
||
|
return (&c.base).SetTimeout(nsec)
|
||
|
}
|
||
|
func (c *ConnTCP) SetReadTimeout(nsec int64) *os.Error {
|
||
|
return (&c.base).SetReadTimeout(nsec)
|
||
|
}
|
||
|
func (c *ConnTCP) SetWriteTimeout(nsec int64) *os.Error {
|
||
|
return (&c.base).SetWriteTimeout(nsec)
|
||
|
}
|
||
|
func (c *ConnTCP) SetLinger(sec int) *os.Error {
|
||
|
return (&c.base).SetLinger(sec)
|
||
|
}
|
||
|
func (c *ConnTCP) SetReuseAddr(reuseaddr bool) *os.Error {
|
||
|
return (&c.base).SetReuseAddr(reuseaddr)
|
||
|
}
|
||
|
func (c *ConnTCP) BindToDevice(dev string) *os.Error {
|
||
|
return (&c.base).BindToDevice(dev)
|
||
|
}
|
||
|
func (c *ConnTCP) SetDontRoute(dontroute bool) *os.Error {
|
||
|
return (&c.base).SetDontRoute(dontroute)
|
||
|
}
|
||
|
func (c *ConnTCP) SetKeepAlive(keepalive bool) *os.Error {
|
||
|
return (&c.base).SetKeepAlive(keepalive)
|
||
|
}
|
||
|
|
||
|
export func DialTCP(net, laddr, raddr string) (c *ConnTCP, err *os.Error) {
|
||
|
fd, e := DialInternet(net, laddr, raddr, socket.SOCK_STREAM)
|
||
|
if e != nil {
|
||
|
return nil, e
|
||
|
}
|
||
|
c = new(ConnTCP);
|
||
|
c.base.fd = os.NewFD(fd);
|
||
|
c.SetNoDelay(true)
|
||
|
return c, nil
|
||
|
}
|
||
|
|
||
|
|
||
|
// TODO: UDP connections
|
||
|
|
||
|
|
||
|
// TODO: raw IP connections
|
||
|
|
||
|
|
||
|
// TODO: raw ethernet connections
|
||
|
|
||
|
|
||
|
export type Conn interface {
|
||
|
Read(b *[]byte) (n int, err *os.Error);
|
||
|
Write(b *[]byte) (n int, err *os.Error);
|
||
|
ReadFrom(b *[]byte) (n int, addr string, err *os.Error);
|
||
|
WriteTo(addr string, b *[]byte) (n int, err *os.Error);
|
||
|
Close() *os.Error;
|
||
|
SetReadBuffer(bytes int) *os.Error;
|
||
|
SetWriteBuffer(bytes int) *os.Error;
|
||
|
SetTimeout(nsec int64) *os.Error;
|
||
|
SetReadTimeout(nsec int64) *os.Error;
|
||
|
SetWriteTimeout(nsec int64) *os.Error;
|
||
|
SetLinger(sec int) *os.Error;
|
||
|
SetReuseAddr(reuseaddr bool) *os.Error;
|
||
|
SetDontRoute(dontroute bool) *os.Error;
|
||
|
SetKeepAlive(keepalive bool) *os.Error;
|
||
|
BindToDevice(dev string) *os.Error;
|
||
|
}
|
||
|
|
||
|
type NoConn struct { unused int }
|
||
|
func (c *NoConn) Read(b *[]byte) (n int, err *os.Error) { return -1, os.EINVAL }
|
||
|
func (c *NoConn) Write(b *[]byte) (n int, err *os.Error) { return -1, os.EINVAL }
|
||
|
func (c *NoConn) ReadFrom(b *[]byte) (n int, addr string, err *os.Error) { return -1, "", os.EINVAL }
|
||
|
func (c *NoConn) WriteTo(addr string, b *[]byte) (n int, err *os.Error) { return -1, os.EINVAL }
|
||
|
func (c *NoConn) Close() *os.Error { return nil }
|
||
|
func (c *NoConn) SetReadBuffer(bytes int) *os.Error { return os.EINVAL }
|
||
|
func (c *NoConn) SetWriteBuffer(bytes int) *os.Error { return os.EINVAL }
|
||
|
func (c *NoConn) SetTimeout(nsec int64) *os.Error { return os.EINVAL }
|
||
|
func (c *NoConn) SetReadTimeout(nsec int64) *os.Error { return os.EINVAL }
|
||
|
func (c *NoConn) SetWriteTimeout(nsec int64) *os.Error { return os.EINVAL }
|
||
|
func (c *NoConn) SetLinger(sec int) *os.Error { return os.EINVAL }
|
||
|
func (c *NoConn) SetReuseAddr(reuseaddr bool) *os.Error { return os.EINVAL }
|
||
|
func (c *NoConn) SetDontRoute(dontroute bool) *os.Error { return os.EINVAL }
|
||
|
func (c *NoConn) SetKeepAlive(keepalive bool) *os.Error { return os.EINVAL }
|
||
|
func (c *NoConn) BindToDevice(dev string) *os.Error { return os.EINVAL }
|
||
|
|
||
|
var noconn NoConn
|
||
|
|
||
|
// Dial's arguments are the network, local address, and remote address.
|
||
|
// Examples:
|
||
|
// Dial("tcp", "", "12.34.56.78:80")
|
||
|
// Dial("tcp", "", "[de:ad:be:ef::ca:fe]:80")
|
||
|
// Dial("tcp", "127.0.0.1:123", "127.0.0.1:88")
|
||
|
//
|
||
|
// Eventually, we plan to allow names in addition to IP addresses,
|
||
|
// but that requires writing a DNS library.
|
||
|
|
||
|
export func Dial(net, laddr, raddr string) (c Conn, err *os.Error) {
|
||
|
switch net {
|
||
|
case "tcp", "tcp4", "tcp6":
|
||
|
c, err := DialTCP(net, laddr, raddr)
|
||
|
if err != nil {
|
||
|
return &noconn, err
|
||
|
}
|
||
|
return c, nil
|
||
|
/*
|
||
|
case "udp", "udp4", "upd6":
|
||
|
c, err := DialUDP(net, laddr, raddr)
|
||
|
return c, err
|
||
|
case "ether":
|
||
|
c, err := DialEther(net, laddr, raddr)
|
||
|
return c, err
|
||
|
case "ipv4":
|
||
|
c, err := DialIPv4(net, laddr, raddr)
|
||
|
return c, err
|
||
|
case "ipv6":
|
||
|
c, err := DialIPv6(net, laddr, raddr)
|
||
|
return c, err
|
||
|
*/
|
||
|
}
|
||
|
return nil, UnknownNetwork
|
||
|
}
|
||
|
|