Subversion Repositories openrisc

// 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 provides a portable interface to Unix networks sockets,

// including TCP/IP, UDP, domain name resolution, and Unix domain sockets.

package net

// TODO(rsc):

//      support for raw ethernet sockets

import (

        "errors"

        "time"

)

// Addr represents a network end point address.

type Addr interface {

        Network() string // name of the network

        String() string  // string form of address

}

// Conn is a generic stream-oriented network connection.

type Conn interface {

        // Read reads data from the connection.

        // Read can be made to time out and return a Error with Timeout() == true

        // after a fixed time limit; see SetDeadline and SetReadDeadline.

        Read(b []byte) (n int, err error)

        // Write writes data to the connection.

        // Write can be made to time out and return a Error with Timeout() == true

        // after a fixed time limit; see SetDeadline and SetWriteDeadline.

        Write(b []byte) (n int, err error)

        // Close closes the connection.

        Close() error

        // LocalAddr returns the local network address.

        LocalAddr() Addr

        // RemoteAddr returns the remote network address.

        RemoteAddr() Addr

        // SetDeadline sets the read and write deadlines associated

        // with the connection.

        SetDeadline(t time.Time) error

        // SetReadDeadline sets the deadline for all Read calls to return.

        // If the deadline is reached, Read will fail with a timeout

        // (see type Error) instead of blocking.

        // A zero value for t means Read will not time out.

        SetReadDeadline(t time.Time) error

        // SetWriteDeadline sets the deadline for all Write calls to return.

        // If the deadline is reached, Write will fail with a timeout

        // (see type Error) instead of blocking.

        // A zero value for t means Write will not time out.

        // Even if write times out, it may return n > 0, indicating that

        // some of the data was successfully written.

        SetWriteDeadline(t time.Time) error

}

// An Error represents a network error.

type Error interface {

        error

        Timeout() bool   // Is the error a timeout?

        Temporary() bool // Is the error temporary?

}

// PacketConn is a generic packet-oriented network connection.

type PacketConn interface {

        // ReadFrom reads a packet from the connection,

        // copying the payload into b.  It returns the number of

        // bytes copied into b and the return address that

        // was on the packet.

        // ReadFrom can be made to time out and return

        // an error with Timeout() == true after a fixed time limit;

        // see SetDeadline and SetReadDeadline.

        ReadFrom(b []byte) (n int, addr Addr, err error)

        // WriteTo writes a packet with payload b to addr.

        // WriteTo can be made to time out and return

        // an error with Timeout() == true after a fixed time limit;

        // see SetDeadline and SetWriteDeadline.

        // On packet-oriented connections, write timeouts are rare.

        WriteTo(b []byte, addr Addr) (n int, err error)

        // Close closes the connection.

        Close() error

        // LocalAddr returns the local network address.

        LocalAddr() Addr

        // SetDeadline sets the read and write deadlines associated

        // with the connection.

        SetDeadline(t time.Time) error

        // SetReadDeadline sets the deadline for all Read calls to return.

        // If the deadline is reached, Read will fail with a timeout

        // (see type Error) instead of blocking.

        // A zero value for t means Read will not time out.

        SetReadDeadline(t time.Time) error

        // SetWriteDeadline sets the deadline for all Write calls to return.

        // If the deadline is reached, Write will fail with a timeout

        // (see type Error) instead of blocking.

        // A zero value for t means Write will not time out.

        // Even if write times out, it may return n > 0, indicating that

        // some of the data was successfully written.

        SetWriteDeadline(t time.Time) error

}

// A Listener is a generic network listener for stream-oriented protocols.

type Listener interface {

        // Accept waits for and returns the next connection to the listener.

        Accept() (c Conn, err error)

        // Close closes the listener.

        Close() error

        // Addr returns the listener's network address.

        Addr() Addr

}

var errMissingAddress = errors.New("missing address")

type OpError struct {

        Op   string

        Net  string

        Addr Addr

        Err  error

}

func (e *OpError) Error() string {

        if e == nil {

                return ""

        }

        s := e.Op

        if e.Net != "" {

                s += " " + e.Net

        }

        if e.Addr != nil {

                s += " " + e.Addr.String()

        }

        s += ": " + e.Err.Error()

        return s

}

type temporary interface {

        Temporary() bool

}

func (e *OpError) Temporary() bool {

        t, ok := e.Err.(temporary)

        return ok && t.Temporary()

}

type timeout interface {

        Timeout() bool

}

func (e *OpError) Timeout() bool {

        t, ok := e.Err.(timeout)

        return ok && t.Timeout()

}

type timeoutError struct{}

func (e *timeoutError) Error() string   { return "i/o timeout" }

func (e *timeoutError) Timeout() bool   { return true }

func (e *timeoutError) Temporary() bool { return true }

var errTimeout error = &timeoutError{}

type AddrError struct {

        Err  string

        Addr string

}

func (e *AddrError) Error() string {

        if e == nil {

                return ""

        }

        s := e.Err

        if e.Addr != "" {

                s += " " + e.Addr

        }

        return s

}

func (e *AddrError) Temporary() bool {

        return false

}

func (e *AddrError) Timeout() bool {

        return false

}

type UnknownNetworkError string

func (e UnknownNetworkError) Error() string   { return "unknown network " + string(e) }

func (e UnknownNetworkError) Temporary() bool { return false }

func (e UnknownNetworkError) Timeout() bool   { return false }

// DNSConfigError represents an error reading the machine's DNS configuration.

type DNSConfigError struct {

        Err error

}

func (e *DNSConfigError) Error() string {

        return "error reading DNS config: " + e.Err.Error()

}

func (e *DNSConfigError) Timeout() bool   { return false }

func (e *DNSConfigError) Temporary() bool { return false }