Examples with NotEnoughDataDecoderException io.netty.handler.codec.http.multipart.HttpPostRequestDecoder.NotEnoughDataDecoderException used on opensource projects

Example 6 with NotEnoughDataDecoderException

use of io.netty.handler.codec.http.multipart.HttpPostRequestDecoder.NotEnoughDataDecoderException in project netty by netty.

the class HttpPostMultipartRequestDecoder method readFileUploadByteMultipartStandard.

/**
     * Read a FileUpload data as Byte (Binary) and add the bytes directly to the
     * FileUpload. If the delimiter is found, the FileUpload is completed.
     *
     * @throws NotEnoughDataDecoderException
     *             Need more chunks but do not reset the readerInder since some
     *             values will be already added to the FileOutput
     * @throws ErrorDataDecoderException
     *             write IO error occurs with the FileUpload
     */
private void readFileUploadByteMultipartStandard(String delimiter) {
    int readerIndex = undecodedChunk.readerIndex();
    // found the decoder limit
    boolean newLine = true;
    int index = 0;
    int lastPosition = undecodedChunk.readerIndex();
    boolean found = false;
    while (undecodedChunk.isReadable()) {
        byte nextByte = undecodedChunk.readByte();
        if (newLine) {
            // Check the delimiter
            if (nextByte == delimiter.codePointAt(index)) {
                index++;
                if (delimiter.length() == index) {
                    found = true;
                    break;
                }
            } else {
                newLine = false;
                index = 0;
                // continue until end of line
                if (nextByte == HttpConstants.CR) {
                    if (undecodedChunk.isReadable()) {
                        nextByte = undecodedChunk.readByte();
                        if (nextByte == HttpConstants.LF) {
                            newLine = true;
                            index = 0;
                            lastPosition = undecodedChunk.readerIndex() - 2;
                        } else {
                            // save last valid position
                            lastPosition = undecodedChunk.readerIndex() - 1;
                            // Unread next byte.
                            undecodedChunk.readerIndex(lastPosition);
                        }
                    }
                } else if (nextByte == HttpConstants.LF) {
                    newLine = true;
                    index = 0;
                    lastPosition = undecodedChunk.readerIndex() - 1;
                } else {
                    // save last valid position
                    lastPosition = undecodedChunk.readerIndex();
                }
            }
        } else {
            // continue until end of line
            if (nextByte == HttpConstants.CR) {
                if (undecodedChunk.isReadable()) {
                    nextByte = undecodedChunk.readByte();
                    if (nextByte == HttpConstants.LF) {
                        newLine = true;
                        index = 0;
                        lastPosition = undecodedChunk.readerIndex() - 2;
                    } else {
                        // save last valid position
                        lastPosition = undecodedChunk.readerIndex() - 1;
                        // Unread next byte.
                        undecodedChunk.readerIndex(lastPosition);
                    }
                }
            } else if (nextByte == HttpConstants.LF) {
                newLine = true;
                index = 0;
                lastPosition = undecodedChunk.readerIndex() - 1;
            } else {
                // save last valid position
                lastPosition = undecodedChunk.readerIndex();
            }
        }
    }
    ByteBuf buffer = undecodedChunk.copy(readerIndex, lastPosition - readerIndex);
    if (found) {
        // found so lastPosition is correct and final
        try {
            currentFileUpload.addContent(buffer, true);
            // just before the CRLF and delimiter
            undecodedChunk.readerIndex(lastPosition);
        } catch (IOException e) {
            throw new ErrorDataDecoderException(e);
        }
    } else {
        // position is OK
        try {
            currentFileUpload.addContent(buffer, false);
            // last valid char (not CR, not LF, not beginning of delimiter)
            undecodedChunk.readerIndex(lastPosition);
            throw new NotEnoughDataDecoderException();
        } catch (IOException e) {
            throw new ErrorDataDecoderException(e);
        }
    }
}

Example 7 with NotEnoughDataDecoderException

use of io.netty.handler.codec.http.multipart.HttpPostRequestDecoder.NotEnoughDataDecoderException in project netty by netty.

the class HttpPostMultipartRequestDecoder method readDelimiterStandard.

/**
     * Read one line up to --delimiter or --delimiter-- and if existing the CRLF
     * or LF Read one line up to --delimiter or --delimiter-- and if existing
     * the CRLF or LF. Note that CRLF or LF are mandatory for opening delimiter
     * (--delimiter) but not for closing delimiter (--delimiter--) since some
     * clients does not include CRLF in this case.
     *
     * @param delimiter
     *            of the form --string, such that '--' is already included
     * @return the String from one line as the delimiter searched (opening or
     *         closing)
     * @throws NotEnoughDataDecoderException
     *             Need more chunks and reset the readerInder to the previous
     *             value
     */
private String readDelimiterStandard(String delimiter) {
    int readerIndex = undecodedChunk.readerIndex();
    try {
        StringBuilder sb = new StringBuilder(64);
        int delimiterPos = 0;
        int len = delimiter.length();
        while (undecodedChunk.isReadable() && delimiterPos < len) {
            byte nextByte = undecodedChunk.readByte();
            if (nextByte == delimiter.charAt(delimiterPos)) {
                delimiterPos++;
                sb.append((char) nextByte);
            } else {
                // delimiter not found so break here !
                undecodedChunk.readerIndex(readerIndex);
                throw new NotEnoughDataDecoderException();
            }
        }
        // Now check if either opening delimiter or closing delimiter
        if (undecodedChunk.isReadable()) {
            byte nextByte = undecodedChunk.readByte();
            // first check for opening delimiter
            if (nextByte == HttpConstants.CR) {
                nextByte = undecodedChunk.readByte();
                if (nextByte == HttpConstants.LF) {
                    return sb.toString();
                } else {
                    // error since CR must be followed by LF
                    // delimiter not found so break here !
                    undecodedChunk.readerIndex(readerIndex);
                    throw new NotEnoughDataDecoderException();
                }
            } else if (nextByte == HttpConstants.LF) {
                return sb.toString();
            } else if (nextByte == '-') {
                sb.append('-');
                // second check for closing delimiter
                nextByte = undecodedChunk.readByte();
                if (nextByte == '-') {
                    sb.append('-');
                    // now try to find if CRLF or LF there
                    if (undecodedChunk.isReadable()) {
                        nextByte = undecodedChunk.readByte();
                        if (nextByte == HttpConstants.CR) {
                            nextByte = undecodedChunk.readByte();
                            if (nextByte == HttpConstants.LF) {
                                return sb.toString();
                            } else {
                                // error CR without LF
                                // delimiter not found so break here !
                                undecodedChunk.readerIndex(readerIndex);
                                throw new NotEnoughDataDecoderException();
                            }
                        } else if (nextByte == HttpConstants.LF) {
                            return sb.toString();
                        } else {
                            // No CRLF but ok however (Adobe Flash uploader)
                            // minus 1 since we read one char ahead but
                            // should not
                            undecodedChunk.readerIndex(undecodedChunk.readerIndex() - 1);
                            return sb.toString();
                        }
                    }
                    // lets try considering it is fine...
                    return sb.toString();
                }
            // only one '-' => not enough
            // whatever now => error since incomplete
            }
        }
    } catch (IndexOutOfBoundsException e) {
        undecodedChunk.readerIndex(readerIndex);
        throw new NotEnoughDataDecoderException(e);
    }
    undecodedChunk.readerIndex(readerIndex);
    throw new NotEnoughDataDecoderException();
}

Example 8 with NotEnoughDataDecoderException

use of io.netty.handler.codec.http.multipart.HttpPostRequestDecoder.NotEnoughDataDecoderException in project netty by netty.

the class HttpPostMultipartRequestDecoder method loadFieldMultipartStandard.

/**
     * Load the field value from a Multipart request
     *
     * @throws NotEnoughDataDecoderException
     *             Need more chunks
     * @throws ErrorDataDecoderException
     */
private void loadFieldMultipartStandard(String delimiter) {
    int readerIndex = undecodedChunk.readerIndex();
    try {
        // found the decoder limit
        boolean newLine = true;
        int index = 0;
        int lastPosition = undecodedChunk.readerIndex();
        boolean found = false;
        while (undecodedChunk.isReadable()) {
            byte nextByte = undecodedChunk.readByte();
            if (newLine) {
                // Check the delimiter
                if (nextByte == delimiter.codePointAt(index)) {
                    index++;
                    if (delimiter.length() == index) {
                        found = true;
                        break;
                    }
                } else {
                    newLine = false;
                    index = 0;
                    // continue until end of line
                    if (nextByte == HttpConstants.CR) {
                        if (undecodedChunk.isReadable()) {
                            nextByte = undecodedChunk.readByte();
                            if (nextByte == HttpConstants.LF) {
                                newLine = true;
                                index = 0;
                                lastPosition = undecodedChunk.readerIndex() - 2;
                            } else {
                                // Unread second nextByte
                                lastPosition = undecodedChunk.readerIndex() - 1;
                                undecodedChunk.readerIndex(lastPosition);
                            }
                        } else {
                            lastPosition = undecodedChunk.readerIndex() - 1;
                        }
                    } else if (nextByte == HttpConstants.LF) {
                        newLine = true;
                        index = 0;
                        lastPosition = undecodedChunk.readerIndex() - 1;
                    } else {
                        lastPosition = undecodedChunk.readerIndex();
                    }
                }
            } else {
                // continue until end of line
                if (nextByte == HttpConstants.CR) {
                    if (undecodedChunk.isReadable()) {
                        nextByte = undecodedChunk.readByte();
                        if (nextByte == HttpConstants.LF) {
                            newLine = true;
                            index = 0;
                            lastPosition = undecodedChunk.readerIndex() - 2;
                        } else {
                            // Unread second nextByte
                            lastPosition = undecodedChunk.readerIndex() - 1;
                            undecodedChunk.readerIndex(lastPosition);
                        }
                    } else {
                        lastPosition = undecodedChunk.readerIndex() - 1;
                    }
                } else if (nextByte == HttpConstants.LF) {
                    newLine = true;
                    index = 0;
                    lastPosition = undecodedChunk.readerIndex() - 1;
                } else {
                    lastPosition = undecodedChunk.readerIndex();
                }
            }
        }
        if (found) {
            // so go back of delimiter size
            try {
                currentAttribute.addContent(undecodedChunk.copy(readerIndex, lastPosition - readerIndex), true);
            } catch (IOException e) {
                throw new ErrorDataDecoderException(e);
            }
            undecodedChunk.readerIndex(lastPosition);
        } else {
            try {
                currentAttribute.addContent(undecodedChunk.copy(readerIndex, lastPosition - readerIndex), false);
            } catch (IOException e) {
                throw new ErrorDataDecoderException(e);
            }
            undecodedChunk.readerIndex(lastPosition);
            throw new NotEnoughDataDecoderException();
        }
    } catch (IndexOutOfBoundsException e) {
        undecodedChunk.readerIndex(readerIndex);
        throw new NotEnoughDataDecoderException(e);
    }
}

Example 9 with NotEnoughDataDecoderException

use of io.netty.handler.codec.http.multipart.HttpPostRequestDecoder.NotEnoughDataDecoderException in project netty by netty.

the class HttpPostMultipartRequestDecoder method readFileUploadByteMultipart.

/**
     * Read a FileUpload data as Byte (Binary) and add the bytes directly to the
     * FileUpload. If the delimiter is found, the FileUpload is completed.
     *
     * @throws NotEnoughDataDecoderException
     *             Need more chunks but do not reset the readerInder since some
     *             values will be already added to the FileOutput
     * @throws ErrorDataDecoderException
     *             write IO error occurs with the FileUpload
     */
private void readFileUploadByteMultipart(String delimiter) {
    SeekAheadOptimize sao;
    try {
        sao = new SeekAheadOptimize(undecodedChunk);
    } catch (SeekAheadNoBackArrayException ignored) {
        readFileUploadByteMultipartStandard(delimiter);
        return;
    }
    int readerIndex = undecodedChunk.readerIndex();
    // found the decoder limit
    boolean newLine = true;
    int index = 0;
    int lastrealpos = sao.pos;
    int lastPosition;
    boolean found = false;
    while (sao.pos < sao.limit) {
        byte nextByte = sao.bytes[sao.pos++];
        if (newLine) {
            // Check the delimiter
            if (nextByte == delimiter.codePointAt(index)) {
                index++;
                if (delimiter.length() == index) {
                    found = true;
                    break;
                }
            } else {
                newLine = false;
                index = 0;
                // continue until end of line
                if (nextByte == HttpConstants.CR) {
                    if (sao.pos < sao.limit) {
                        nextByte = sao.bytes[sao.pos++];
                        if (nextByte == HttpConstants.LF) {
                            newLine = true;
                            index = 0;
                            lastrealpos = sao.pos - 2;
                        } else {
                            // unread next byte
                            sao.pos--;
                            // save last valid position
                            lastrealpos = sao.pos;
                        }
                    }
                } else if (nextByte == HttpConstants.LF) {
                    newLine = true;
                    index = 0;
                    lastrealpos = sao.pos - 1;
                } else {
                    // save last valid position
                    lastrealpos = sao.pos;
                }
            }
        } else {
            // continue until end of line
            if (nextByte == HttpConstants.CR) {
                if (sao.pos < sao.limit) {
                    nextByte = sao.bytes[sao.pos++];
                    if (nextByte == HttpConstants.LF) {
                        newLine = true;
                        index = 0;
                        lastrealpos = sao.pos - 2;
                    } else {
                        // unread next byte
                        sao.pos--;
                        // save last valid position
                        lastrealpos = sao.pos;
                    }
                }
            } else if (nextByte == HttpConstants.LF) {
                newLine = true;
                index = 0;
                lastrealpos = sao.pos - 1;
            } else {
                // save last valid position
                lastrealpos = sao.pos;
            }
        }
    }
    lastPosition = sao.getReadPosition(lastrealpos);
    ByteBuf buffer = undecodedChunk.copy(readerIndex, lastPosition - readerIndex);
    if (found) {
        // found so lastPosition is correct and final
        try {
            currentFileUpload.addContent(buffer, true);
            // just before the CRLF and delimiter
            undecodedChunk.readerIndex(lastPosition);
        } catch (IOException e) {
            throw new ErrorDataDecoderException(e);
        }
    } else {
        // position is OK
        try {
            currentFileUpload.addContent(buffer, false);
            // last valid char (not CR, not LF, not beginning of delimiter)
            undecodedChunk.readerIndex(lastPosition);
            throw new NotEnoughDataDecoderException();
        } catch (IOException e) {
            throw new ErrorDataDecoderException(e);
        }
    }
}

Example 10 with NotEnoughDataDecoderException

use of io.netty.handler.codec.http.multipart.HttpPostRequestDecoder.NotEnoughDataDecoderException in project netty by netty.

the class HttpPostMultipartRequestDecoder method readLineStandard.

/**
     * Read one line up to the CRLF or LF
     *
     * @return the String from one line
     * @throws NotEnoughDataDecoderException
     *             Need more chunks and reset the readerInder to the previous
     *             value
     */
private String readLineStandard() {
    int readerIndex = undecodedChunk.readerIndex();
    try {
        ByteBuf line = buffer(64);
        while (undecodedChunk.isReadable()) {
            byte nextByte = undecodedChunk.readByte();
            if (nextByte == HttpConstants.CR) {
                // check but do not changed readerIndex
                nextByte = undecodedChunk.getByte(undecodedChunk.readerIndex());
                if (nextByte == HttpConstants.LF) {
                    // force read
                    undecodedChunk.readByte();
                    return line.toString(charset);
                } else {
                    // Write CR (not followed by LF)
                    line.writeByte(HttpConstants.CR);
                }
            } else if (nextByte == HttpConstants.LF) {
                return line.toString(charset);
            } else {
                line.writeByte(nextByte);
            }
        }
    } catch (IndexOutOfBoundsException e) {
        undecodedChunk.readerIndex(readerIndex);
        throw new NotEnoughDataDecoderException(e);
    }
    undecodedChunk.readerIndex(readerIndex);
    throw new NotEnoughDataDecoderException();
}