/*

* Copyright 2012-2020 the original author or authors.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* https://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package com.github.dockerjava.transport;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

import java.nio.ByteBuffer;

import com.github.dockerjava.transport.FileDescriptor.Handle;

import com.sun.jna.LastErrorException;

import com.sun.jna.Native;

import com.sun.jna.Platform;

/**

* A {@link Socket} implementation for Linux of BSD domain sockets.

*

* @author Phillip Webb

*/

public abstract class DomainSocket extends AbstractSocket {

private static final int SHUT_RD = 0;

private static final int SHUT_WR = 1;

protected static final int PF_LOCAL = 1;

protected static final byte AF_LOCAL = 1;

protected static final int SOCK_STREAM = 1;

private final FileDescriptor fileDescriptor;

private final InputStream inputStream;

private final OutputStream outputStream;

static {

Native.register(Platform.C_LIBRARY_NAME);

}

DomainSocket(String path) throws IOException {

try {

this.fileDescriptor = open(path);

this.inputStream = new DomainSocketInputStream();

this.outputStream = new DomainSocketOutputStream();

} catch (LastErrorException ex) {

throw new IOException(ex);

}

}

private FileDescriptor open(String path) {

int handle = socket(PF_LOCAL, SOCK_STREAM, 0);

connect(path, handle);

return new FileDescriptor(handle, this::close);

}

private int read(ByteBuffer buffer) throws IOException {

try (Handle handle = this.fileDescriptor.acquire()) {

if (handle.isClosed()) {

return -1;

}

try {

return read(handle.intValue(), buffer, buffer.remaining());

} catch (LastErrorException ex) {

throw new IOException(ex);

}

}

}

public void write(ByteBuffer buffer) throws IOException {

try (Handle handle = this.fileDescriptor.acquire()) {

if (!handle.isClosed()) {

try {

write(handle.intValue(), buffer, buffer.remaining());

} catch (LastErrorException ex) {

throw new IOException(ex);

}

}

}

}

@Override

public InputStream getInputStream() {

return this.inputStream;

}

@Override

public OutputStream getOutputStream() {

return this.outputStream;

}

@Override

public void close() throws IOException {

super.close();

try {

this.fileDescriptor.close();

} catch (LastErrorException ex) {

throw new IOException(ex);

}

}

protected abstract void connect(String path, int handle);

private native int socket(int domain, int type, int protocol) throws LastErrorException;

private native int read(int fd, ByteBuffer buffer, int count) throws LastErrorException;

private native int write(int fd, ByteBuffer buffer, int count) throws LastErrorException;

private native int close(int fd) throws LastErrorException;

/**

* Return a new {@link DomainSocket} for the given path.

* @param path the path to the domain socket

* @return a {@link DomainSocket} instance

* @throws IOException if the socket cannot be opened

* @deprecated use {@link UnixSocket#get(String)}

*/

@Deprecated

public static DomainSocket get(String path) throws IOException {

if (Platform.isMac() || isBsdPlatform()) {

return new BsdDomainSocket(path);

}

return new LinuxDomainSocket(path);

}

private static boolean isBsdPlatform() {

return Platform.isFreeBSD() || Platform.iskFreeBSD() || Platform.isNetBSD() || Platform.isOpenBSD();

}

/**

* {@link InputStream} returned from the {@link DomainSocket}.

*/

private class DomainSocketInputStream extends InputStream {

@Override

public int read() throws IOException {

ByteBuffer buffer = ByteBuffer.allocate(1);

int amountRead = DomainSocket.this.read(buffer);

return (amountRead != 1) ? -1 : buffer.get() & 0xFF;

}

@Override

public int read(byte[] b, int off, int len) throws IOException {

if (len == 0) {

return 0;

}

int amountRead = DomainSocket.this.read(ByteBuffer.wrap(b, off, len));

return (amountRead > 0) ? amountRead : -1;

}

}

/**

* {@link OutputStream} returned from the {@link DomainSocket}.

*/

private class DomainSocketOutputStream extends OutputStream {

@Override

public void write(int b) throws IOException {

ByteBuffer buffer = ByteBuffer.allocate(1);

buffer.put(0, (byte) (b & 0xFF));

DomainSocket.this.write(buffer);

}

@Override

public void write(byte[] b, int off, int len) throws IOException {

if (len != 0) {

DomainSocket.this.write(ByteBuffer.wrap(b, off, len));

}

}

}

}