Example usage for org.springframework.integration.ip.tcp.serializer SoftEndOfStreamException SoftEndOfStreamException

List of usage examples for org.springframework.integration.ip.tcp.serializer SoftEndOfStreamException SoftEndOfStreamException

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.integration.ip.tcp.serializer.*
  5. SoftEndOfStreamException
  6. SoftEndOfStreamException

Introduction

In this page you can find the example usage for org.springframework.integration.ip.tcp.serializer SoftEndOfStreamException SoftEndOfStreamException.

Prototype

public SoftEndOfStreamException(String message)

Source Link

Document

Construct an instance with the message.

Usage

From source file:ru.jts_dev.common.tcp.ProtocolByteArrayLengthHeaderSerializer.java

@Override
protected int readHeader(InputStream inputStream) throws IOException {
    byte[] lengthPart = new byte[this.headerSize];
    try {//  w ww .j  a  v a 2 s . com
        int status = read(inputStream, lengthPart, true);
        if (status < 0) {
            throw new SoftEndOfStreamException("Stream closed between payloads");
        }
        int messageLength;
        switch (this.headerSize) {
        case HEADER_SIZE_INT:
            messageLength = ByteBuffer.wrap(lengthPart).order(LITTLE_ENDIAN).getInt();
            if (messageLength < 0) {
                throw new IllegalArgumentException("Length header:" + messageLength + " is negative");
            }
            break;
        case HEADER_SIZE_UNSIGNED_BYTE:
            messageLength = ByteBuffer.wrap(lengthPart).order(LITTLE_ENDIAN).get() & 0xff;
            break;
        case HEADER_SIZE_UNSIGNED_SHORT:
            messageLength = ByteBuffer.wrap(lengthPart).order(LITTLE_ENDIAN).getShort() & 0xffff;
            break;
        default:
            throw new IllegalArgumentException("Bad header size:" + headerSize);
        }

        messageLength -= headerSize; // substract header size from data
        return messageLength;
    } catch (SoftEndOfStreamException e) {
        throw e;
    } catch (IOException | RuntimeException e) {
        publishEvent(e, lengthPart, -1);
        throw e;
    }
}

From source file:org.springframework.integration.ip.tcp.serializer.ByteArrayLengthHeaderSerializer.java

/**
 * Reads the header and returns the length of the data part.
 * @param inputStream/*from ww w  . ja va2s .  c o  m*/
 * @return The length of the data part
 * @throws IOException
 * @throws SoftEndOfStreamException if socket closes
 * before any length data read.
 */
protected int readHeader(InputStream inputStream) throws IOException {
    byte[] lengthPart = new byte[this.headerSize];
    int status = read(inputStream, lengthPart, true);
    if (status < 0) {
        throw new SoftEndOfStreamException("Stream closed between payloads");
    }
    int messageLength;
    switch (this.headerSize) {
    case HEADER_SIZE_INT:
        messageLength = ByteBuffer.wrap(lengthPart).getInt();
        if (messageLength < 0) {
            throw new IllegalArgumentException("Length header:" + messageLength + " is negative");
        }
        break;
    case HEADER_SIZE_UNSIGNED_BYTE:
        messageLength = ByteBuffer.wrap(lengthPart).get() & 0xff;
        break;
    case HEADER_SIZE_UNSIGNED_SHORT:
        messageLength = ByteBuffer.wrap(lengthPart).getShort() & 0xffff;
        break;
    default:
        throw new IllegalArgumentException("Bad header size:" + headerSize);
    }
    return messageLength;
}

From source file:org.springframework.integration.x.ip.websocket.WebSocketSerializer.java

private DataFrame doDeserialize(InputStream inputStream, DataFrame protoFrame) throws IOException {
    List<DataFrame> headers = checkStreaming(inputStream);
    if (headers != null) {
        return headers.get(0);
    }/*from w  w  w . j  a va2 s . c o  m*/
    int bite;
    if (logger.isDebugEnabled()) {
        logger.debug("Available to read:" + inputStream.available());
    }
    boolean done = false;
    int len = 0;
    int n = 0;
    int dataInx = 0;
    byte[] buffer = null;
    boolean fin = false;
    boolean ping = false;
    boolean pong = false;
    boolean close = false;
    boolean binary = false;
    boolean invalid = false;
    String invalidText = null;
    boolean fragmentedControl = false;
    int lenBytes = 0;
    byte[] mask = new byte[4];
    int maskInx = 0;
    int rsv = 0;
    while (!done) {
        bite = inputStream.read();
        //         logger.debug("Read:" + Integer.toHexString(bite));
        if (this.nio) {
            bite = checkclosed(bite, inputStream);
        }
        if (bite < 0 && n == 0) {
            throw new SoftEndOfStreamException("Stream closed between payloads");
        }
        checkClosure(bite);
        switch (n++) {
        case 0:
            fin = (bite & 0x80) > 0;
            rsv = (bite & 0x70) >> 4;
            bite &= 0x0f;
            switch (bite) {
            case 0x00:
                logger.debug("Continuation, fin=" + fin);
                if (protoFrame == null) {
                    invalid = true;
                    invalidText = "Unexpected continuation frame";
                } else {
                    binary = protoFrame.getType() == WebSocketFrame.TYPE_DATA_BINARY;
                }
                this.getState(inputStream).setPendingFrame(null);
                break;
            case 0x01:
                logger.debug("Text, fin=" + fin);
                if (protoFrame != null) {
                    invalid = true;
                    invalidText = "Expected continuation frame";
                }
                break;
            case 0x02:
                logger.debug("Binary, fin=" + fin);
                if (protoFrame != null) {
                    invalid = true;
                    invalidText = "Expected continuation frame";
                }
                binary = true;
                break;
            case 0x08:
                logger.debug("Close, fin=" + fin);
                fragmentedControl = !fin;
                close = true;
                break;
            case 0x09:
                ping = true;
                binary = true;
                fragmentedControl = !fin;
                logger.debug("Ping, fin=" + fin);
                break;
            case 0x0a:
                pong = true;
                fragmentedControl = !fin;
                logger.debug("Pong, fin=" + fin);
                break;
            case 0x03:
            case 0x04:
            case 0x05:
            case 0x06:
            case 0x07:
            case 0x0b:
            case 0x0c:
            case 0x0d:
            case 0x0e:
            case 0x0f:
                invalid = true;
                invalidText = "Reserved opcode " + Integer.toHexString(bite);
                break;
            default:
                throw new IOException("Unexpected opcode " + Integer.toHexString(bite));
            }
            break;
        case 1:
            if (this.server) {
                if ((bite & 0x80) == 0) {
                    throw new IOException("Illegal: Expected masked data from client");
                }
                bite &= 0x7f;
            }
            if ((bite & 0x80) > 0) {
                throw new IOException("Illegal: Received masked data from server");
            }
            if (bite < 126) {
                len = bite;
                buffer = new byte[len];
            } else if (bite == 126) {
                lenBytes = 2;
            } else {
                lenBytes = 8;
            }
            break;
        case 2:
        case 3:
        case 4:
        case 5:
            if (lenBytes > 4 && bite != 0) {
                throw new IOException("Max supported length exceeded");
            }
        case 6:
            if (lenBytes > 3 && (bite & 0x80) > 0) {
                throw new IOException("Max supported length exceeded");
            }
        case 7:
        case 8:
        case 9:
            if (lenBytes-- > 0) {
                len = len << 8 | (bite & 0xff);
                if (lenBytes == 0) {
                    buffer = new byte[len];
                }
                break;
            }
        default:
            if (this.server && maskInx < 4) {
                mask[maskInx++] = (byte) bite;
            } else {
                if (this.server) {
                    bite ^= mask[dataInx % 4];
                }
                buffer[dataInx++] = (byte) bite;
            }
            done = (server ? maskInx == 4 : true) && dataInx >= len;
        }
    }
    ;

    WebSocketFrame frame;

    if (fragmentedControl) {
        frame = new WebSocketFrame(WebSocketFrame.TYPE_FRAGMENTED_CONTROL, "Fragmented control frame", buffer);
    } else if (invalid) {
        frame = new WebSocketFrame(WebSocketFrame.TYPE_INVALID, invalidText, buffer);
    } else if (!fin) {
        List<byte[]> fragments = this.getState(inputStream).getFragments();
        fragments.add(buffer);
        logger.debug("Fragment");
        return new WebSocketFrame(binary ? WebSocketFrame.TYPE_DATA_BINARY : WebSocketFrame.TYPE_DATA,
                (String) null);
    } else if (ping) {
        frame = new WebSocketFrame(WebSocketFrame.TYPE_PING, buffer);
    } else if (pong) {
        String data = new String(buffer, "UTF-8");
        frame = new WebSocketFrame(WebSocketFrame.TYPE_PONG, data);
    } else if (close) {
        String data = new String(buffer, "UTF-8");
        if (data.length() >= 2) {
            data = data.substring(2);
        }
        WebSocketFrame closeFrame = new WebSocketFrame(WebSocketFrame.TYPE_CLOSE, data);
        short status = 1000;
        if (buffer.length >= 2) {
            status = (short) ((buffer[0] << 8) | (buffer[1] & 0xff));
            closeFrame.setStatus(status);
        }
        if (buffer.length == 1 || buffer.length > 125
                || (buffer.length > 2 && !validateUtf8IfNecessary(buffer, 2, data)) || status < 1000
                || INVALID_STATUS.contains(status) || (status >= 1016 && status < 3000) || status >= 5000) {
            // Simply close in this case; no close reply
            ((WebSocketState) this.getState(inputStream)).setCloseInitiated(true);
        }
        frame = closeFrame;
    } else {
        List<byte[]> fragments = this.getState(inputStream).getFragments();
        if (fragments.size() == 0) {
            if (binary) {
                frame = new WebSocketFrame(WebSocketFrame.TYPE_DATA_BINARY, buffer);
            } else {
                String data = new String(buffer, "UTF-8");
                if (!validateUtf8IfNecessary(buffer, 0, data)) {
                    frame = new WebSocketFrame(WebSocketFrame.TYPE_INVALID_UTF8, "Invalid UTF-8", buffer);
                } else {
                    frame = new WebSocketFrame(WebSocketFrame.TYPE_DATA, data);
                }
            }
        } else {
            fragments.add(buffer);
            int utf8Len = 0;
            for (byte[] fragment : fragments) {
                utf8Len += fragment.length;
            }
            byte[] reconstructed = new byte[utf8Len];
            int utf8Pos = 0;
            for (byte[] fragment : fragments) {
                System.arraycopy(fragment, 0, reconstructed, utf8Pos, fragment.length);
                utf8Pos += fragment.length;
            }
            fragments.clear();
            if (binary) {
                frame = new WebSocketFrame(WebSocketFrame.TYPE_DATA_BINARY, reconstructed);
            } else {
                String data = new String(reconstructed, "UTF-8");
                if (!validateUtf8IfNecessary(reconstructed, 0, data)) {
                    frame = new WebSocketFrame(WebSocketFrame.TYPE_INVALID_UTF8, "Invalid UTF-8",
                            reconstructed);
                } else {
                    frame = new WebSocketFrame(WebSocketFrame.TYPE_DATA, data);
                }
            }
        }
    }
    if (rsv > 0) {
        frame.setRsv(rsv);
    }
    return frame;
}

From source file:org.springframework.yarn.integration.ip.mind.MindRpcSerializer.java

/**
 * Reads the first line as a protocol header and parses sizes of
 * underlying headers and content.//from   www  . j av  a 2  s  . co m
 *
 * @param inputStream the input stream
 * @return int array containing sizes of headers and content
 * @throws IOException if read error occured
 */
protected int[] readHeader(InputStream inputStream) throws IOException {
    int[] ret = new int[] { 0, 0 };
    byte[] buffer = new byte[20];
    int n = 0;
    int bite;
    while (true) {
        bite = inputStream.read();
        if (bite < 0 && n == 0) {
            throw new SoftEndOfStreamException("Stream closed between payloads");
        }
        checkClosure(bite);
        if (n > 0 && bite == '\n' && buffer[n - 1] == '\r') {
            break;
        }
        buffer[n++] = (byte) bite;
        if (n >= 20) {
            throw new IOException("CRLF not found before max message length: " + this.maxMessageSize);
        }

    }
    byte[] assembledData = new byte[n - 1];
    System.arraycopy(buffer, 0, assembledData, 0, n - 1);
    String header = new String(assembledData);

    if (log.isDebugEnabled()) {
        log.debug("Mind rpc header:" + header);
    }

    String[] respBytes = header.split(" ");
    ret[0] = Integer.parseInt(respBytes[1]);
    ret[1] = Integer.parseInt(respBytes[2]);

    if (log.isDebugEnabled()) {
        log.debug("Mind rpc parsed sizes: head=" + ret[0] + " content=" + ret[1]);
    }
    return ret;
}