code review 684041: net: implement raw sockets

src/pkg/net/net.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.
 
 // The net package 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 IP sockets
 //      support for raw ethernet sockets
 
 import "os"
 
 // Addr represents a network end point address.
 type Addr interface {
         Network() string // name of the network
         String() string  // string form of address
 }
 
@@ skipping 80 matching lines @@
         Accept() (c Conn, err os.Error)
         Close() os.Error
         Addr() Addr // Listener's network address
 }
 
 // Dial connects to the remote address raddr on the network net.
 // If the string laddr is not empty, it is used as the local address
 // for the connection.
 //
 // Known networks are "tcp", "tcp4" (IPv4-only), "tcp6" (IPv6-only),
-// "udp", "udp4" (IPv4-only), and "udp6" (IPv6-only).
+// "udp", "udp4" (IPv4-only), "udp6" (IPv6-only), "ip", "ip4"
+// (IPv4-only) and "ip6" IPv6-only).
 //
 // For IP networks, addresses have the form host:port.  If host is
 // a literal IPv6 address, it must be enclosed in square brackets.
 //
 // Examples:
 //      Dial("tcp", "", "12.34.56.78:80")
 //      Dial("tcp", "", "google.com:80")
 //      Dial("tcp", "", "[de:ad:be:ef::ca:fe]:80")
 //      Dial("tcp", "127.0.0.1:123", "127.0.0.1:88")
 //
 func Dial(net, laddr, raddr string) (c Conn, err os.Error) {
-        switch net {
+        switch prefixBefore(net, ':') {
         case "tcp", "tcp4", "tcp6":
                 var la, ra *TCPAddr
                 if laddr != "" {
                         if la, err = ResolveTCPAddr(laddr); err != nil {
                                 goto Error
                         }
                 }
                 if raddr != "" {
                         if ra, err = ResolveTCPAddr(raddr); err != nil {
                                 goto Error
@@ skipping 31 matching lines @@
                 if laddr != "" {
                         if la, err = ResolveUnixAddr(net, laddr); err != nil {
                                 goto Error
                         }
                 }
                 c, err = DialUnix(net, la, ra)
                 if err != nil {
                         return nil, err
                 }
                 return c, nil
+        case "ip", "ip4", "ip6":
+                var la, ra *IPAddr
+                if laddr != "" {
+                        if la, err = ResolveIPAddr(laddr); err != nil {
+                                goto Error
+                        }
+                }
+                if raddr != "" {
+                        if ra, err = ResolveIPAddr(raddr); err != nil {
+                                goto Error
+                        }
+                }
+                c, err := DialIP(net, la, ra)
+                if err != nil {
+                        return nil, err
+                }
+                return c, nil
+
         }
         err = UnknownNetworkError(net)
 Error:
         return nil, &OpError{"dial", net + " " + raddr, nil, err}
 }
 
 // Listen announces on the local network address laddr.
 // The network string net must be a stream-oriented
 // network: "tcp", "tcp4", "tcp6", or "unix".
 func Listen(net, laddr string) (l Listener, err os.Error) {
@@ skipping 23 matching lines @@
                 }
                 return l, nil
         }
         return nil, UnknownNetworkError(net)
 }
 
 // ListenPacket announces on the local network address laddr.
 // The network string net must be a packet-oriented network:
 // "udp", "udp4", "udp6", or "unixgram".
 func ListenPacket(net, laddr string) (c PacketConn, err os.Error) {
-        switch net {
+        switch prefixBefore(net, ':') {
         case "udp", "udp4", "udp6":
                 var la *UDPAddr
                 if laddr != "" {
                         if la, err = ResolveUDPAddr(laddr); err != nil {
                                 return nil, err
                         }
                 }
                 c, err := ListenUDP(net, la)
                 if err != nil {
                         return nil, err
                 }
                 return c, nil
         case "unixgram":
                 var la *UnixAddr
                 if laddr != "" {
                         if la, err = ResolveUnixAddr(net, laddr); err != nil {
                                 return nil, err
                         }
                 }
                 c, err := DialUnix(net, la, nil)
                 if err != nil {
                         return nil, err
                 }
                 return c, nil
+        case "ip", "ip4", "ip6":
+                var la *IPAddr
+                if laddr != "" {
+                        if la, err = ResolveIPAddr(laddr); err != nil {
+                                return nil, err
+                        }
+                }
+                c, err := ListenIP(net, la)
+                if err != nil {
+                        return nil, err
+                }
+                return c, nil
         }
         return nil, UnknownNetworkError(net)
 }
 
 var errMissingAddress = os.ErrorString("missing address")
 
 type OpError struct {
         Op    string
         Net   string
         Addr  Addr
@@ skipping 21 matching lines @@
         s := e.Error
         if e.Addr != "" {
                 s += " " + e.Addr
         }
         return s
 }
 
 type UnknownNetworkError string
 
 func (e UnknownNetworkError) String() string { return "unknown network " + string(e) }