com.github.dockerjava.transport.DomainSocket Maven / Gradle / Ivy
The newest version!
/*
* 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));
}
}
}
}