}

    @Override public void bind(SocketAddress endpoint, int backlog) throws IOException {
      this.endpoint = (InetSocketAddress) endpoint;

      UnixSocketAddress address = new UnixSocketAddress(path);
      serverSocketChannel = UnixServerSocketChannel.open();
      serverSocketChannel.configureBlocking(true);
      serverSocketChannel.socket().bind(address);
    }

    @Override public int getLocalPort() {

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - https://github.com/istio/istio/issues/40268
releaseNotes:
  - |

}

// BindPlugin is an interface that must be implemented by "Bind" plugins. Bind
// plugins are used to bind a pod to a Node.
type BindPlugin interface {
	Plugin
	// Bind plugins will not be called until all pre-bind plugins have completed. Each
	// bind plugin is called in the configured order. A bind plugin may choose whether
	// or not to handle the given Pod. If a bind plugin chooses to handle a Pod, the

		klog.V(4).Infof("Directory %s is already on a shared mount", path)
		return nil
	}

	klog.V(2).Infof("Bind-mounting %q with shared mount propagation", path)
	// mount --bind /var/lib/kubelet /var/lib/kubelet
	if err := syscall.Mount(path, path, "" /*fstype*/, syscall.MS_BIND, "" /*data*/); err != nil {
		return fmt.Errorf("failed to bind-mount %s: %v", path, err)
	}

	// mount --make-rshared /var/lib/kubelet

    }


    /**
     * Bind the handle
     * 
     * @throws DcerpcException
     * @throws IOException
     */
    public void bind () throws DcerpcException, IOException {
        synchronized ( this ) {
            try {
                this.state = 1;
                DcerpcMessage bind = new DcerpcBind(this.binding, this);
                sendrecv(bind);
            }

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
- 28269
releaseNotes:
- |
  **Fixed** when a node has multiple IP addresses (e.g., a VM in the mesh expansion scenario),
  Istio Proxy will now bind `inbound` listeners to the first applicable address in the list

			Servers: []*networking.Server{
				{
					Hosts: []string{host},
					Port:  &networking.Port{Name: portName, Number: portNumber, Protocol: portProtocol},
					Bind:  bind,
					Tls:   &networking.ServerTLSSettings{Mode: mode},
				},
			},
		},
	}
	return c
}

func BenchmarkParseGatewayRDSRouteName(b *testing.B) {
	for range b.N {

	}

	return passthroughBindIPAddresses
}

// getSidecarInboundBindIPs returns the IP that the proxy can bind to along with the sidecar specified port.
// It looks for an unicast address, if none found, then the default wildcard address is used.
// This will make the inbound listener bind to instance_ip:port instead of 0.0.0.0:port where applicable.
func getSidecarInboundBindIPs(node *model.Proxy) []string {

        }
        throw new DcerpcException("DCERPC transport not supported: " + url);
    }

    public void bind() throws DcerpcException, IOException {
synchronized (this) {
        try {
            state = 1;
            DcerpcMessage bind = new DcerpcBind(binding, this);
            sendrecv(bind);
        } catch (IOException ioe) {
            state = 0;
            throw ioe;
        }
}
    }

        factory.wildcardBindingAddress == new InetSocketAddress(0).address
    }

    def "loopback is used as bind address if available"() {
        when:
        defaultAddresses()

        then:
        factory.localBindingAddress == ip(127, 0, 0, 1)
    }

    def "wildcard address is used as bind address if no loopback available"() {
        when:
        loopbackAddresses([])