mirror of
https://github.com/golang/go
synced 2024-10-01 13:18:33 -06:00
f60fcca5f1
My previous https://golang.org/cl/22101 to add context throughout the net package broke Plan 9, which isn't currently tested (#15251). It also broke some old unsupported version of Windows (Windows 2000?) which doesn't have the ConnectEx function, but that was only found visually, since our minimum supported Windows version has ConnectEx. This change simplifies the Windows and deletes the non-ConnectEx code path. Windows 2000 will work even less now, if it even worked before. Windows XP remains our minimum supported version. Specifically, the previous CL stopped using the "dial" function, which 0intro noted: https://github.com/golang/go/issues/15333#issuecomment-210842761 This CL removes the dial function instead and makes plan9's net implementation respect contexts, which likely fixes a number of t.Skipped tests. I'm leaving that to 0intro to investigate. In the process of propagating and respecting contexts for plan9, I had to change some signatures to add contexts to more places and ended up pushing contexts down into the Go-based DNS resolution as well, replacing the pure-Go DNS implementation's use of "timeout time.Duration" with a context instead. Updates #11932 Updates #15328 Fixes #15333 Change-Id: I6ad1e62f38271cdd86b3f40921f2d0f23374936a Reviewed-on: https://go-review.googlesource.com/22144 Reviewed-by: David du Colombier <0intro@gmail.com> Reviewed-by: Mikio Hara <mikioh.mikioh@gmail.com> Reviewed-by: Ian Lance Taylor <iant@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
114 lines
2.8 KiB
Go
114 lines
2.8 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 (
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"syscall"
|
|
)
|
|
|
|
func (c *UDPConn) readFrom(b []byte) (n int, addr *UDPAddr, err error) {
|
|
buf := make([]byte, udpHeaderSize+len(b))
|
|
m, err := c.fd.Read(buf)
|
|
if err != nil {
|
|
return 0, nil, err
|
|
}
|
|
if m < udpHeaderSize {
|
|
return 0, nil, errors.New("short read reading UDP header")
|
|
}
|
|
buf = buf[:m]
|
|
|
|
h, buf := unmarshalUDPHeader(buf)
|
|
n = copy(b, buf)
|
|
return n, &UDPAddr{IP: h.raddr, Port: int(h.rport)}, nil
|
|
}
|
|
|
|
func (c *UDPConn) readMsg(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error) {
|
|
return 0, 0, 0, nil, syscall.EPLAN9
|
|
}
|
|
|
|
func (c *UDPConn) writeTo(b []byte, addr *UDPAddr) (int, error) {
|
|
if addr == nil {
|
|
return 0, errMissingAddress
|
|
}
|
|
h := new(udpHeader)
|
|
h.raddr = addr.IP.To16()
|
|
h.laddr = c.fd.laddr.(*UDPAddr).IP.To16()
|
|
h.ifcaddr = IPv6zero // ignored (receive only)
|
|
h.rport = uint16(addr.Port)
|
|
h.lport = uint16(c.fd.laddr.(*UDPAddr).Port)
|
|
|
|
buf := make([]byte, udpHeaderSize+len(b))
|
|
i := copy(buf, h.Bytes())
|
|
copy(buf[i:], b)
|
|
if _, err := c.fd.Write(buf); err != nil {
|
|
return 0, err
|
|
}
|
|
return len(b), nil
|
|
}
|
|
|
|
func (c *UDPConn) writeMsg(b, oob []byte, addr *UDPAddr) (n, oobn int, err error) {
|
|
return 0, 0, syscall.EPLAN9
|
|
}
|
|
|
|
func dialUDP(ctx context.Context, net string, laddr, raddr *UDPAddr) (*UDPConn, error) {
|
|
fd, err := dialPlan9(ctx, net, laddr, raddr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return newUDPConn(fd), nil
|
|
}
|
|
|
|
const udpHeaderSize = 16*3 + 2*2
|
|
|
|
type udpHeader struct {
|
|
raddr, laddr, ifcaddr IP
|
|
rport, lport uint16
|
|
}
|
|
|
|
func (h *udpHeader) Bytes() []byte {
|
|
b := make([]byte, udpHeaderSize)
|
|
i := 0
|
|
i += copy(b[i:i+16], h.raddr)
|
|
i += copy(b[i:i+16], h.laddr)
|
|
i += copy(b[i:i+16], h.ifcaddr)
|
|
b[i], b[i+1], i = byte(h.rport>>8), byte(h.rport), i+2
|
|
b[i], b[i+1], i = byte(h.lport>>8), byte(h.lport), i+2
|
|
return b
|
|
}
|
|
|
|
func unmarshalUDPHeader(b []byte) (*udpHeader, []byte) {
|
|
h := new(udpHeader)
|
|
h.raddr, b = IP(b[:16]), b[16:]
|
|
h.laddr, b = IP(b[:16]), b[16:]
|
|
h.ifcaddr, b = IP(b[:16]), b[16:]
|
|
h.rport, b = uint16(b[0])<<8|uint16(b[1]), b[2:]
|
|
h.lport, b = uint16(b[0])<<8|uint16(b[1]), b[2:]
|
|
return h, b
|
|
}
|
|
|
|
func listenUDP(ctx context.Context, network string, laddr *UDPAddr) (*UDPConn, error) {
|
|
l, err := listenPlan9(ctx, network, laddr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_, err = l.ctl.WriteString("headers")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
l.data, err = os.OpenFile(l.dir+"/data", os.O_RDWR, 0)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fd, err := l.netFD()
|
|
return newUDPConn(fd), err
|
|
}
|
|
|
|
func listenMulticastUDP(ctx context.Context, network string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error) {
|
|
return nil, syscall.EPLAN9
|
|
}
|