"question":                             "\u2753",
	"rabbit":                               "\U0001f430",
	"rabbit2":                              "\U0001f407",
	"raccoon":                              "\U0001f99d",
	"racehorse":                            "\U0001f40e",
	"racing_car":                           "\U0001f3ce\ufe0f",
	"radio":                                "\U0001f4fb",

package os

import (
	"runtime"
)

// rawConn implements syscall.RawConn.
type rawConn struct {
	file *File
}

func (c *rawConn) Control(f func(uintptr)) error {
	if err := c.file.checkValid("SyscallConn.Control"); err != nil {
		return err
	}
	err := c.file.pfd.RawControl(f)
	runtime.KeepAlive(c.file)
	return err
}

func (c *rawConn) Read(f func(uintptr) bool) error {

}

func (c *rawConn) ok() bool { return c != nil && c.fd != nil }

func (c *rawConn) Control(f func(uintptr)) error {
	if !c.ok() {
		return syscall.EINVAL
	}
	err := c.fd.pfd.RawControl(f)
	runtime.KeepAlive(c.fd)
	if err != nil {
		err = &OpError{Op: "raw-control", Net: c.fd.net, Source: nil, Addr: c.fd.laddr, Err: err}
	}
	return err
}

func (c *rawConn) Read(f func(uintptr) bool) error {
	if !c.ok() {

	"syscall"
)

func readRawConn(c syscall.RawConn, b []byte) (int, error) {
	return 0, errors.New("not supported")
}

func writeRawConn(c syscall.RawConn, b []byte) error {
	return errors.New("not supported")
}

func controlRawConn(c syscall.RawConn, addr Addr) error {
	return errors.New("not supported")
}

func controlOnConnSetup(network string, address string, c syscall.RawConn) error {
	return nil

		t.Fatal(err)
	}
	defer client.Close()

	if err := <-errc; err != nil {
		t.Fatalf("server error: %v", err)
	}

	// The socket should be non-blocking.
	rawconn, err := client.(*UnixConn).SyscallConn()
	if err != nil {
		t.Fatal(err)
	}
	err = rawconn.Control(func(fd uintptr) {
		nonblock, err := unix.IsNonblock(int(fd))
		if err != nil {
			t.Fatal(err)
		}
		if !nonblock {

// Copyright 2017 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 syscall

// A RawConn is a raw network connection.
type RawConn interface {
	// Control invokes f on the underlying connection's file
	// descriptor or handle.
	// The file descriptor fd is guaranteed to remain valid while
	// f executes but not after f returns.

	"errors"
	"syscall"
)

func readRawConn(c syscall.RawConn, b []byte) (int, error) {
	var operr error
	var n int
	err := c.Read(func(s uintptr) bool {
		n, operr = syscall.Read(int(s), b)
		if operr == syscall.EAGAIN {
			return false
		}
		return true
	})
	if err != nil {
		return n, err
	}
	return n, operr
}

func writeRawConn(c syscall.RawConn, b []byte) error {
	var operr error

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package net

import (
	"errors"
	"syscall"
	"unsafe"
)

func readRawConn(c syscall.RawConn, b []byte) (int, error) {
	var operr error
	var n int
	err := c.Read(func(s uintptr) bool {
		var read uint32
		var flags uint32
		var buf syscall.WSABuf
		buf.Buf = &b[0]
		buf.Len = uint32(len(b))

import (
	"fmt"
	"syscall"
)

func permitPortReuse(network, address string, c syscall.RawConn) error {
	return fmt.Errorf("port reuse is not supported on Windows")
}

// Windows supports SO_REUSEADDR, but it may cause undefined behavior, as
// there is no protection against port hijacking.
func permitAddressReuse(network, addr string, conn syscall.RawConn) error {
	return fmt.Errorf("address reuse is not supported on Windows")

)

// TODO: if possible implement for non-linux platforms, not a priority at the moment
//
//nolint:unused
func setTCPParametersFn(opts TCPOptions) func(network, address string, c syscall.RawConn) error {
	return func(network, address string, c syscall.RawConn) error {
		return nil
	}
}

// DialContext is a function to make custom Dial for internode communications