wrap() — netty Function Reference

Source Code

handler/src/main/java/io/netty/handler/ssl/SslHandler.java lines 851–986

    private void wrap(ChannelHandlerContext ctx, boolean inUnwrap) throws SSLException {
        ByteBuf out = null;
        ByteBufAllocator alloc = ctx.alloc();
        try {
            final int wrapDataSize = this.wrapDataSize;
            // Only continue to loop if the handler was not removed in the meantime.
            // See https://github.com/netty/netty/issues/5860
            outer: while (!ctx.isRemoved()) {
                ChannelPromise promise = ctx.newPromise();
                ByteBuf buf = wrapDataSize > 0 ?
                        pendingUnencryptedWrites.remove(alloc, wrapDataSize, promise) :
                        pendingUnencryptedWrites.removeFirst(promise);
                if (buf == null) {
                    break;
                }

                SSLEngineResult result;

                try {
                    if (buf.readableBytes() > MAX_PLAINTEXT_LENGTH) {
                        // If we pulled a buffer larger than the supported packet size, we can slice it up and
                        // iteratively, encrypting multiple packets into a single larger buffer. This substantially
                        // saves on allocations for large responses. Here we estimate how large of a buffer we need.
                        // If we overestimate a bit, that's fine. If we underestimate, we'll simply re-enqueue the
                        // remaining buffer and get it on the next outer loop.
                        int readableBytes = buf.readableBytes();
                        int numPackets = readableBytes / MAX_PLAINTEXT_LENGTH;
                        if (readableBytes % MAX_PLAINTEXT_LENGTH != 0) {
                            numPackets += 1;
                        }

                        if (out == null) {
                            out = allocateOutNetBuf(ctx, readableBytes, buf.nioBufferCount() + numPackets);
                        }
                        result = wrapMultiple(alloc, engine, buf, out);
                    } else {
                        if (out == null) {
                            out = allocateOutNetBuf(ctx, buf.readableBytes(), buf.nioBufferCount());
                        }
                        result = wrap(alloc, engine, buf, out);
                    }
                } catch (SSLException e) {
                    // Either wrapMultiple(...) or wrap(...) did throw. In this case we need to release the buffer
                    // that we removed from pendingUnencryptedWrites before failing the promise and rethrowing it.
                    // Failing to do so would result in a buffer leak.
                    // See https://github.com/netty/netty/issues/14644
                    //
                    // We don't need to release out here as this is done in a finally block already.
                    buf.release();
                    promise.setFailure(e);
                    throw e;
                }

                if (buf.isReadable()) {
                    pendingUnencryptedWrites.addFirst(buf, promise);
                    // When we add the buffer/promise pair back we need to be sure we don't complete the promise
                    // later. We only complete the promise if the buffer is completely consumed.
                    promise = null;
                } else {
                    buf.release();
                }

                // We need to write any data before we invoke any methods which may trigger re-entry, otherwise
                // writes may occur out of order and TLS sequencing may be off (e.g. SSLV3_ALERT_BAD_RECORD_MAC).
                if (out.isReadable()) {
                    final ByteBuf b = out;
                    out = null;
                    if (promise != null) {
                        ctx.write(b, promise);
                    } else {
                        ctx.write(b);
                    }
                } else if (promise != null) {
                    ctx.write(Unpooled.EMPTY_BUFFER, promise);
                }
                // else out is not readable we can re-use it and so save an extra allocation

                if (result.getStatus() == Status.CLOSED) {
                    // First check if there is any write left that needs to be failed, if there is none we don't need
                    // to create a new exception or obtain an existing one.
                    if (!pendingUnencryptedWrites.isEmpty()) {