Ejemplo n.º 1
0
        public static unsafe byte[] ToByteArray(List <SslApplicationProtocol> applicationProtocols)
        {
            long protocolListSize = 0;

            for (int i = 0; i < applicationProtocols.Count; i++)
            {
                int protocolLength = applicationProtocols[i].Protocol.Length;

                if (protocolLength == 0 || protocolLength > byte.MaxValue)
                {
                    throw new ArgumentException(SR.net_ssl_app_protocols_invalid, nameof(applicationProtocols));
                }

                protocolListSize += protocolLength + 1;

                if (protocolListSize > short.MaxValue)
                {
                    throw new ArgumentException(SR.net_ssl_app_protocols_invalid, nameof(applicationProtocols));
                }
            }

            Sec_Application_Protocols protocols = default;

            int protocolListConstSize = sizeof(Sec_Application_Protocols) - sizeof(uint) /* offsetof(Sec_Application_Protocols, ProtocolExtensionType) */;

            protocols.ProtocolListsSize = (uint)(protocolListConstSize + protocolListSize);

            protocols.ProtocolExtensionType = ApplicationProtocolNegotiationExt.ALPN;
            protocols.ProtocolListSize      = (short)protocolListSize;

            byte[] buffer = new byte[sizeof(Sec_Application_Protocols) + protocolListSize];
            int    index  = 0;

            MemoryMarshal.Write(buffer.AsSpan(index), ref protocols);
            index += sizeof(Sec_Application_Protocols);

            for (int i = 0; i < applicationProtocols.Count; i++)
            {
                ReadOnlySpan <byte> protocol = applicationProtocols[i].Protocol.Span;
                buffer[index++] = (byte)protocol.Length;
                protocol.CopyTo(buffer.AsSpan(index));
                index += protocol.Length;
            }

            return(buffer);
        }
Ejemplo n.º 2
0
        public static unsafe byte[] ToByteArray(List <SslApplicationProtocol> applicationProtocols)
        {
            long protocolListSize = 0;

            for (int i = 0; i < applicationProtocols.Count; i++)
            {
                if (applicationProtocols[i].Protocol.Length == 0 || applicationProtocols[i].Protocol.Length > byte.MaxValue)
                {
                    throw new ArgumentException(SR.net_ssl_app_protocols_invalid, nameof(applicationProtocols));
                }

                protocolListSize += applicationProtocols[i].Protocol.Length + 1;

                if (protocolListSize > short.MaxValue)
                {
                    throw new ArgumentException(SR.net_ssl_app_protocols_invalid, nameof(applicationProtocols));
                }
            }

            Sec_Application_Protocols protocols = new Sec_Application_Protocols();

            protocols.ProtocolListsSize      = (uint)(ProtocolListConstSize + protocolListSize);
            protocols.ProtocolExtenstionType = ApplicationProtocolNegotiationExt.ALPN;
            protocols.ProtocolListSize       = (short)protocolListSize;

            Span <byte> pBuffer = new byte[protocolListSize];
            int         index   = 0;

            for (int i = 0; i < applicationProtocols.Count; i++)
            {
                pBuffer[index++] = (byte)applicationProtocols[i].Protocol.Length;
                applicationProtocols[i].Protocol.Span.CopyTo(pBuffer.Slice(index));
                index += applicationProtocols[i].Protocol.Length;
            }

            byte[] buffer = new byte[ProtocolListOffset + protocolListSize];
            fixed(byte *bufferPtr = buffer)
            {
                Marshal.StructureToPtr(protocols, new IntPtr(bufferPtr), false);
                byte *pList = bufferPtr + ProtocolListOffset;

                pBuffer.CopyTo(new Span <byte>(pList, index));
            }

            return(buffer);
        }