io.netty.channel.uring.MsgHdrMemory Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of netty-transport-classes-io_uring Show documentation
There is a newer version: 4.2.0.Alpha4
Show newest version
/*
 * Copyright 2024 The Netty Project
 *
 * The Netty Project licenses this file to you 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 io.netty.channel.uring;

import io.netty.buffer.ByteBuf;
import io.netty.channel.socket.DatagramPacket;
import io.netty.util.internal.PlatformDependent;

import java.net.InetSocketAddress;

final class MsgHdrMemory {
    private final long memory;
    private final short idx;
    private final long cmsgDataAddr;

    MsgHdrMemory(short idx) {
        this.idx = idx;
        int size = Native.SIZEOF_MSGHDR + Native.SIZEOF_SOCKADDR_STORAGE + Native.SIZEOF_IOVEC + Native.CMSG_SPACE;
        memory = PlatformDependent.allocateMemory(size);
        PlatformDependent.setMemory(memory, size, (byte) 0);

        // We retrieve the address of the data once so we can just be JNI free after construction.
        cmsgDataAddr = Native.cmsghdrData(memory + Native.SIZEOF_MSGHDR +
                Native.SIZEOF_SOCKADDR_STORAGE + Native.SIZEOF_IOVEC);
    }

    void write(LinuxSocket socket, InetSocketAddress address, long bufferAddress , int length, short segmentSize) {
        long sockAddress = memory + Native.SIZEOF_MSGHDR;
        long iovAddress = sockAddress + Native.SIZEOF_SOCKADDR_STORAGE;
        long cmsgAddr = iovAddress + Native.SIZEOF_IOVEC;
        int addressLength;
        if (address == null) {
            addressLength = socket.isIpv6() ? Native.SIZEOF_SOCKADDR_IN6 : Native.SIZEOF_SOCKADDR_IN;
            PlatformDependent.setMemory(sockAddress, Native.SIZEOF_SOCKADDR_STORAGE, (byte) 0);
        } else {
            addressLength = SockaddrIn.write(socket.isIpv6(), sockAddress, address);
        }
        Iov.write(iovAddress, bufferAddress, length);
        MsgHdr.write(memory, sockAddress, addressLength, iovAddress, 1, cmsgAddr, cmsgDataAddr, segmentSize);
    }

    boolean hasPort(IoUringDatagramChannel channel) {
        long sockAddress = memory + Native.SIZEOF_MSGHDR;
        if (channel.socket.isIpv6()) {
            return SockaddrIn.hasPortIpv6(sockAddress);
        }
        return SockaddrIn.hasPortIpv4(sockAddress);
    }

    DatagramPacket read(IoUringDatagramChannel channel, IoUringIoHandler handler, ByteBuf buffer, int bytesRead) {
        long sockAddress = memory + Native.SIZEOF_MSGHDR;
        InetSocketAddress sender;
        if (channel.socket.isIpv6()) {
            byte[] ipv6Bytes = handler.inet6AddressArray();
            byte[] ipv4bytes = handler.inet4AddressArray();

            sender = SockaddrIn.readIPv6(sockAddress, ipv6Bytes, ipv4bytes);
        } else {
            byte[] bytes = handler.inet4AddressArray();
            sender = SockaddrIn.readIPv4(sockAddress, bytes);
        }
        long iovAddress = memory + Native.SIZEOF_MSGHDR + Native.SIZEOF_SOCKADDR_STORAGE;
        long bufferAddress = Iov.readBufferAddress(iovAddress);
        int bufferLength = Iov.readBufferLength(iovAddress);
        // reconstruct the reader index based on the memoryAddress of the buffer and the bufferAddress that was used
        // in the iovec.
        int readerIndex = (int) (bufferAddress - buffer.memoryAddress());

        ByteBuf slice = buffer.slice(readerIndex, bufferLength)
                .writerIndex(bytesRead);
        return new DatagramPacket(slice.retain(), channel.localAddress(), sender);
    }

    short idx() {
        return idx;
    }

    long address() {
        return memory;
    }

    void release() {
        PlatformDependent.freeMemory(memory);
    }
}