grpc-z 1.11.1

data/src/ruby/spec/support/helpers.rb

@@ -0,0 +1,107 @@
+# Copyright 2017 gRPC authors.
+#
+# Licensed 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
+#
+#     http://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.
+
+# GRPC contains the General RPC module.
+module GRPC
+  ##
+  # GRPC RSpec base module
+  #
+  module Spec
+    ##
+    # A module that is used for providing generic helpers across the
+    # GRPC test suite
+    #
+    module Helpers
+      # Shortcut syntax for a GRPC RPC Server
+      RpcServer = GRPC::RpcServer
+
+      ##
+      # Build an RPC server used for testing
+      #
+      def build_rpc_server(server_opts: {},
+                           client_opts: {})
+        @server = new_rpc_server_for_testing({ poll_period: 1 }.merge(server_opts))
+        @port = @server.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
+        @host = "0.0.0.0:#{@port}"
+        @client_opts = client_opts
+        @server
+      end
+
+      ##
+      # Run services on an RPC server, yielding to allow testing within
+      #
+      # @param [RpcServer] server
+      # @param [Array<Class>] services
+      #
+      def run_services_on_server(server, services: [])
+        services.each do |s|
+          server.handle(s)
+        end
+        t = Thread.new { server.run }
+        server.wait_till_running
+
+        yield
+
+        server.stop
+        t.join
+      end
+
+      ##
+      # Build an insecure stub from a given stub class
+      #
+      # @param [Class] klass
+      # @param [String] host
+      #
+      def build_insecure_stub(klass, host: nil, opts: nil)
+        host ||= @host
+        opts ||= @client_opts
+        klass.new(host, :this_channel_is_insecure, **opts)
+      end
+
+      ##
+      # Build an RPCServer for use in tests. Adds args
+      # that are useful for all tests.
+      #
+      # @param [Hash] server_opts
+      #
+      def new_rpc_server_for_testing(server_opts = {})
+        server_opts[:server_args] ||= {}
+        update_server_args_hash(server_opts[:server_args])
+        RpcServer.new(**server_opts)
+      end
+
+      ##
+      # Build an GRPC::Core::Server for use in tests. Adds args
+      # that are useful for all tests.
+      #
+      # @param [Hash] server_args
+      #
+      def new_core_server_for_testing(server_args)
+        server_args.nil? && server_args = {}
+        update_server_args_hash(server_args)
+        GRPC::Core::Server.new(server_args)
+      end
+
+      def update_server_args_hash(server_args)
+        so_reuseport_arg = 'grpc.so_reuseport'
+        unless server_args[so_reuseport_arg].nil?
+          fail 'Unexpected. grpc.so_reuseport already set.'
+        end
+        # Run tests without so_reuseport to eliminate the chance of
+        # cross-talk.
+        server_args[so_reuseport_arg] = 0
+      end
+    end
+  end
+end

data/src/ruby/spec/support/services.rb

@@ -0,0 +1,147 @@
+# Copyright 2017 gRPC authors.
+#
+# Licensed 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
+#
+#     http://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.
+
+# Test stubs for various scenarios
+require 'grpc'
+
+# A test message
+class EchoMsg
+  def self.marshal(_o)
+    ''
+  end
+
+  def self.unmarshal(_o)
+    EchoMsg.new
+  end
+end
+
+# A test service with an echo implementation.
+class EchoService
+  include GRPC::GenericService
+  rpc :an_rpc, EchoMsg, EchoMsg
+  rpc :a_client_streaming_rpc, stream(EchoMsg), EchoMsg
+  rpc :a_server_streaming_rpc, EchoMsg, stream(EchoMsg)
+  rpc :a_bidi_rpc, stream(EchoMsg), stream(EchoMsg)
+  attr_reader :received_md
+
+  def initialize(**kw)
+    @trailing_metadata = kw
+    @received_md = []
+  end
+
+  def an_rpc(req, call)
+    GRPC.logger.info('echo service received a request')
+    call.output_metadata.update(@trailing_metadata)
+    @received_md << call.metadata unless call.metadata.nil?
+    req
+  end
+
+  def a_client_streaming_rpc(call)
+    # iterate through requests so call can complete
+    call.output_metadata.update(@trailing_metadata)
+    call.each_remote_read.each { |r| p r }
+    EchoMsg.new
+  end
+
+  def a_server_streaming_rpc(_req, call)
+    call.output_metadata.update(@trailing_metadata)
+    [EchoMsg.new, EchoMsg.new]
+  end
+
+  def a_bidi_rpc(requests, call)
+    call.output_metadata.update(@trailing_metadata)
+    requests.each { |r| p r }
+    [EchoMsg.new, EchoMsg.new]
+  end
+end
+
+EchoStub = EchoService.rpc_stub_class
+
+# For testing server interceptors
+class TestServerInterceptor < GRPC::ServerInterceptor
+  def request_response(request:, call:, method:)
+    p "Received request/response call at method #{method}" \
+      " with request #{request} for call #{call}"
+    call.output_metadata[:interc] = 'from_request_response'
+    p "[GRPC::Ok] (#{method.owner.name}.#{method.name})"
+    yield
+  end
+
+  def client_streamer(call:, method:)
+    call.output_metadata[:interc] = 'from_client_streamer'
+    call.each_remote_read.each do |r|
+      p "In interceptor: #{r}"
+    end
+    p "Received client streamer call at method #{method} for call #{call}"
+    yield
+  end
+
+  def server_streamer(request:, call:, method:)
+    p "Received server streamer call at method #{method} with request" \
+      " #{request} for call #{call}"
+    call.output_metadata[:interc] = 'from_server_streamer'
+    yield
+  end
+
+  def bidi_streamer(requests:, call:, method:)
+    requests.each do |r|
+      p "Bidi request: #{r}"
+    end
+    p "Received bidi streamer call at method #{method} with requests" \
+      " #{requests} for call #{call}"
+    call.output_metadata[:interc] = 'from_bidi_streamer'
+    yield
+  end
+end
+
+# For testing client interceptors
+class TestClientInterceptor < GRPC::ClientInterceptor
+  def request_response(request:, call:, method:, metadata: {})
+    p "Intercepted request/response call at method #{method}" \
+      " with request #{request} for call #{call}" \
+      " and metadata: #{metadata}"
+    metadata['foo'] = 'bar_from_request_response'
+    yield
+  end
+
+  def client_streamer(requests:, call:, method:, metadata: {})
+    p "Received client streamer call at method #{method}" \
+      " with requests #{requests} for call #{call}" \
+      " and metadata: #{metadata}"
+    requests.each do |r|
+      p "In client interceptor: #{r}"
+    end
+    metadata['foo'] = 'bar_from_client_streamer'
+    yield
+  end
+
+  def server_streamer(request:, call:, method:, metadata: {})
+    p "Received server streamer call at method #{method}" \
+      " with request #{request} for call #{call}" \
+      " and metadata: #{metadata}"
+    metadata['foo'] = 'bar_from_server_streamer'
+    yield
+  end
+
+  def bidi_streamer(requests:, call:, method:, metadata: {})
+    p "Received bidi streamer call at method #{method}" \
+      "with requests #{requests} for call #{call}" \
+      " and metadata: #{metadata}"
+    requests.each do |r|
+      p "In client interceptor: #{r}"
+    end
+    metadata['foo'] = 'bar_from_bidi_streamer'
+    yield
+  end
+end

data/src/ruby/spec/testdata/README

@@ -0,0 +1 @@
+These are test keys *NOT* to be used in production.

data/src/ruby/spec/testdata/ca.pem

@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICSjCCAbOgAwIBAgIJAJHGGR4dGioHMA0GCSqGSIb3DQEBCwUAMFYxCzAJBgNV
+BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX
+aWRnaXRzIFB0eSBMdGQxDzANBgNVBAMTBnRlc3RjYTAeFw0xNDExMTEyMjMxMjla
+Fw0yNDExMDgyMjMxMjlaMFYxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0
+YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxDzANBgNVBAMT
+BnRlc3RjYTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAwEDfBV5MYdlHVHJ7
++L4nxrZy7mBfAVXpOc5vMYztssUI7mL2/iYujiIXM+weZYNTEpLdjyJdu7R5gGUu
+g1jSVK/EPHfc74O7AyZU34PNIP4Sh33N+/A5YexrNgJlPY+E3GdVYi4ldWJjgkAd
+Qah2PH5ACLrIIC6tRka9hcaBlIECAwEAAaMgMB4wDAYDVR0TBAUwAwEB/zAOBgNV
+HQ8BAf8EBAMCAgQwDQYJKoZIhvcNAQELBQADgYEAHzC7jdYlzAVmddi/gdAeKPau
+sPBG/C2HCWqHzpCUHcKuvMzDVkY/MP2o6JIW2DBbY64bO/FceExhjcykgaYtCH/m
+oIU63+CFOTtR7otyQAWHqXa7q4SbCDlG7DyRFxqG0txPtGvy12lgldA2+RgcigQG
+Dfcog5wrJytaQ6UA0wE=
+-----END CERTIFICATE-----

data/src/ruby/spec/testdata/client.key

@@ -0,0 +1,16 @@
+-----BEGIN PRIVATE KEY-----
+MIICeQIBADANBgkqhkiG9w0BAQEFAASCAmMwggJfAgEAAoGBAOxUR9uhvhbeVUIM
+s5WbH0px0mehl2+6sZpNjzvE2KimZpHzMJHukVH0Ffkvhs0b8+S5Ut9VNUAqd3IM
+JCCAEGtRNoQhM1t9Yr2zAckSvbRacp+FL/Cj9eDmyo00KsVGaeefA4Dh4OW+ZhkT
+NKcldXqkSuj1sEf244JZYuqZp6/tAgMBAAECgYEAi2NSVqpZMafE5YYUTcMGe6QS
+k2jtpsqYgggI2RnLJ/2tNZwYI5pwP8QVSbnMaiF4gokD5hGdrNDfTnb2v+yIwYEH
+0w8+oG7Z81KodsiZSIDJfTGsAZhVNwOz9y0VD8BBZZ1/274Zh52AUKLjZS/ZwIbS
+W2ywya855dPnH/wj+0ECQQD9X8D920kByTNHhBG18biAEZ4pxs9f0OAG8333eVcI
+w2lJDLsYDZrCB2ocgA3lUdozlzPC7YDYw8reg0tkiRY5AkEA7sdNzOeQsQRn7++5
+0bP9DtT/iON1gbfxRzCfCfXdoOtfQWIzTePWtURt9X/5D9NofI0Rg5W2oGy/MLe5
+/sXHVQJBAIup5XrJDkQywNZyAUU2ecn2bCWBFjwtqd+LBmuMciI9fOKsZtEKZrz/
+U0lkeMRoSwvXE8wmGLjjrAbdfohrXFkCQQDZEx/LtIl6JINJQiswVe0tWr6k+ASP
+1WXoTm+HYpoF/XUvv9LccNF1IazFj34hwRQwhx7w/V52Ieb+p0jUMYGxAkEAjDhd
+9pBO1fKXWiXzi9ZKfoyTNcUq3eBSVKwPG2nItg5ycXengjT5sgcWDnciIzW7BIVI
+JiqOszq9GWESErAatg==
+-----END PRIVATE KEY-----

data/src/ruby/spec/testdata/client.pem

@@ -0,0 +1,14 @@
+-----BEGIN CERTIFICATE-----
+MIICHzCCAYgCAQEwDQYJKoZIhvcNAQEFBQAwVjELMAkGA1UEBhMCQVUxEzARBgNV
+BAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0
+ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTE0MDcxNzIzNTYwMloXDTI0MDcxNDIzNTYw
+MlowWjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDETMBEGA1UEAwwKdGVzdGNsaWVudDCB
+nzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA7FRH26G+Ft5VQgyzlZsfSnHSZ6GX
+b7qxmk2PO8TYqKZmkfMwke6RUfQV+S+GzRvz5LlS31U1QCp3cgwkIIAQa1E2hCEz
+W31ivbMByRK9tFpyn4Uv8KP14ObKjTQqxUZp558DgOHg5b5mGRM0pyV1eqRK6PWw
+R/bjglli6pmnr+0CAwEAATANBgkqhkiG9w0BAQUFAAOBgQAStSm5PM7ubROiKK6/
+T2FkKlhiTOx+Ryenm3Eio59emq+jXl+1nhPySX5G2PQzSR5vd1dIhwgZSR4Gyttk
+tRZ57k/NI1brUW8joiEOMJA/Mr7H7asx7wIRYDE91Fs8GkKWd5LhoPAQj+qdG35C
+OO+svdkmqH0KZo320ZUqdl2ooQ==
+-----END CERTIFICATE-----

data/src/ruby/spec/testdata/server1.key

@@ -0,0 +1,16 @@
+-----BEGIN PRIVATE KEY-----
+MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAOHDFScoLCVJpYDD
+M4HYtIdV6Ake/sMNaaKdODjDMsux/4tDydlumN+fm+AjPEK5GHhGn1BgzkWF+slf
+3BxhrA/8dNsnunstVA7ZBgA/5qQxMfGAq4wHNVX77fBZOgp9VlSMVfyd9N8YwbBY
+AckOeUQadTi2X1S6OgJXgQ0m3MWhAgMBAAECgYAn7qGnM2vbjJNBm0VZCkOkTIWm
+V10okw7EPJrdL2mkre9NasghNXbE1y5zDshx5Nt3KsazKOxTT8d0Jwh/3KbaN+YY
+tTCbKGW0pXDRBhwUHRcuRzScjli8Rih5UOCiZkhefUTcRb6xIhZJuQy71tjaSy0p
+dHZRmYyBYO2YEQ8xoQJBAPrJPhMBkzmEYFtyIEqAxQ/o/A6E+E4w8i+KM7nQCK7q
+K4JXzyXVAjLfyBZWHGM2uro/fjqPggGD6QH1qXCkI4MCQQDmdKeb2TrKRh5BY1LR
+81aJGKcJ2XbcDu6wMZK4oqWbTX2KiYn9GB0woM6nSr/Y6iy1u145YzYxEV/iMwff
+DJULAkB8B2MnyzOg0pNFJqBJuH29bKCcHa8gHJzqXhNO5lAlEbMK95p/P2Wi+4Hd
+aiEIAF1BF326QJcvYKmwSmrORp85AkAlSNxRJ50OWrfMZnBgzVjDx3xG6KsFQVk2
+ol6VhqL6dFgKUORFUWBvnKSyhjJxurlPEahV6oo6+A+mPhFY8eUvAkAZQyTdupP3
+XEFQKctGz+9+gKkemDp7LBBMEMBXrGTLPhpEfcjv/7KPdnFHYmhYeBTBnuVmTVWe
+F98XJ7tIFfJq
+-----END PRIVATE KEY-----

data/src/ruby/spec/testdata/server1.pem

@@ -0,0 +1,16 @@
+-----BEGIN CERTIFICATE-----
+MIICnDCCAgWgAwIBAgIBBzANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJBVTET
+MBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0cyBQ
+dHkgTHRkMQ8wDQYDVQQDEwZ0ZXN0Y2EwHhcNMTUxMTA0MDIyMDI0WhcNMjUxMTAx
+MDIyMDI0WjBlMQswCQYDVQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNV
+BAcTB0NoaWNhZ28xFTATBgNVBAoTDEV4YW1wbGUsIENvLjEaMBgGA1UEAxQRKi50
+ZXN0Lmdvb2dsZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAOHDFSco
+LCVJpYDDM4HYtIdV6Ake/sMNaaKdODjDMsux/4tDydlumN+fm+AjPEK5GHhGn1Bg
+zkWF+slf3BxhrA/8dNsnunstVA7ZBgA/5qQxMfGAq4wHNVX77fBZOgp9VlSMVfyd
+9N8YwbBYAckOeUQadTi2X1S6OgJXgQ0m3MWhAgMBAAGjazBpMAkGA1UdEwQCMAAw
+CwYDVR0PBAQDAgXgME8GA1UdEQRIMEaCECoudGVzdC5nb29nbGUuZnKCGHdhdGVy
+em9vaS50ZXN0Lmdvb2dsZS5iZYISKi50ZXN0LnlvdXR1YmUuY29thwTAqAEDMA0G
+CSqGSIb3DQEBCwUAA4GBAJFXVifQNub1LUP4JlnX5lXNlo8FxZ2a12AFQs+bzoJ6
+hM044EDjqyxUqSbVePK0ni3w1fHQB5rY9yYC5f8G7aqqTY1QOhoUk8ZTSTRpnkTh
+y4jjdvTZeLDVBlueZUTDRmy2feY5aZIU18vFDK08dTG0A87pppuv1LNIR3loveU8
+-----END CERTIFICATE-----

data/src/ruby/spec/time_consts_spec.rb

@@ -0,0 +1,74 @@
+# Copyright 2015 gRPC authors.
+#
+# Licensed 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
+#
+#     http://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.
+
+require 'grpc'
+
+TimeConsts = GRPC::Core::TimeConsts
+
+describe TimeConsts do
+  before(:each) do
+    @known_consts = [:ZERO, :INFINITE_FUTURE, :INFINITE_PAST].sort
+  end
+
+  it 'should have all the known types' do
+    expect(TimeConsts.constants.collect.sort).to eq(@known_consts)
+  end
+
+  describe '#to_time' do
+    it 'converts each constant to a Time' do
+      m = TimeConsts
+      m.constants.each do |c|
+        expect(m.const_get(c).to_time).to be_a(Time)
+      end
+    end
+  end
+end
+
+describe '#from_relative_time' do
+  it 'cannot handle arbitrary objects' do
+    expect { TimeConsts.from_relative_time(Object.new) }.to raise_error
+  end
+
+  it 'preserves TimeConsts' do
+    m = TimeConsts
+    m.constants.each do |c|
+      const = m.const_get(c)
+      expect(TimeConsts.from_relative_time(const)).to be(const)
+    end
+  end
+
+  it 'converts 0 to TimeConsts::ZERO' do
+    expect(TimeConsts.from_relative_time(0)).to eq(TimeConsts::ZERO)
+  end
+
+  it 'converts nil to TimeConsts::ZERO' do
+    expect(TimeConsts.from_relative_time(nil)).to eq(TimeConsts::ZERO)
+  end
+
+  it 'converts negative values to TimeConsts::INFINITE_FUTURE' do
+    [-1, -3.2, -1e6].each do |t|
+      y = TimeConsts.from_relative_time(t)
+      expect(y).to eq(TimeConsts::INFINITE_FUTURE)
+    end
+  end
+
+  it 'converts a positive value to an absolute time' do
+    epsilon = 1
+    [1, 3.2, 1e6].each do |t|
+      want = Time.now + t
+      abs = TimeConsts.from_relative_time(t)
+      expect(abs.to_f).to be_within(epsilon).of(want.to_f)
+    end
+  end
+end

data/third_party/address_sorting/address_sorting.c

@@ -0,0 +1,369 @@
+/*	$NetBSD: getaddrinfo.c,v 1.82 2006/03/25 12:09:40 rpaulo Exp $	*/
+/*	$KAME: getaddrinfo.c,v 1.29 2000/08/31 17:26:57 itojun Exp $	*/
+/*
+ * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+/*
+ * This is an adaptation of Android's implementation of RFC 6724
+ * (in Android's getaddrinfo.c). It has some cosmetic differences
+ * from Android's getaddrinfo.c, but Android's getaddrinfo.c was
+ * used as a guide or example of a way to implement the RFC 6724 spec when
+ * this was written.
+ */
+
+#include "address_sorting_internal.h"
+
+#include <errno.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+
+// Scope values increase with increase in scope.
+static const int kIPv6AddrScopeLinkLocal = 1;
+static const int kIPv6AddrScopeSiteLocal = 2;
+static const int kIPv6AddrScopeGlobal = 3;
+
+static address_sorting_source_addr_factory* g_current_source_addr_factory =
+    NULL;
+
+static int address_sorting_get_source_addr(const address_sorting_address* dest,
+                                           address_sorting_address* source) {
+  return g_current_source_addr_factory->vtable->get_source_addr(
+      g_current_source_addr_factory, dest, source);
+}
+
+static int ipv6_prefix_match_length(const struct sockaddr_in6* sa,
+                                    const struct sockaddr_in6* sb) {
+  unsigned char* a = (unsigned char*)&sa->sin6_addr;
+  unsigned char* b = (unsigned char*)&sb->sin6_addr;
+  int cur_bit = 0;
+  while (cur_bit < 128) {
+    int high_bit = 1 << (CHAR_BIT - 1);
+    int a_val = a[cur_bit / CHAR_BIT] & (high_bit >> (cur_bit % CHAR_BIT));
+    int b_val = b[cur_bit / CHAR_BIT] & (high_bit >> (cur_bit % CHAR_BIT));
+    if (a_val == b_val) {
+      cur_bit++;
+    } else {
+      break;
+    }
+  }
+  return cur_bit;
+}
+
+static int in6_is_addr_loopback(const struct in6_addr* ipv6_address) {
+  uint32_t* bits32 = (uint32_t*)ipv6_address;
+  return bits32[0] == 0 && bits32[1] == 0 && bits32[2] == 0 &&
+         bits32[3] == htonl(1);
+}
+
+static int in6_is_addr_v4mapped(const struct in6_addr* ipv6_address) {
+  uint32_t* bits32 = (uint32_t*)ipv6_address;
+  return bits32[0] == 0 && bits32[1] == 0 && bits32[2] == htonl(0x0000ffff);
+}
+
+static int in6_is_addr_v4compat(const struct in6_addr* ipv6_address) {
+  uint32_t* bits32 = (uint32_t*)ipv6_address;
+  return bits32[0] == 0 && bits32[1] == 0 && bits32[2] == 0 && bits32[3] != 0 &&
+         bits32[3] != htonl(1);
+}
+
+static int in6_is_addr_sitelocal(const struct in6_addr* ipv6_address) {
+  uint8_t* bytes = (uint8_t*)ipv6_address;
+  return bytes[0] == 0xfe && (bytes[1] & 0xc0) == 0xc0;
+}
+
+static int in6_is_addr_linklocal(const struct in6_addr* ipv6_address) {
+  uint8_t* bytes = (uint8_t*)ipv6_address;
+  return bytes[0] == 0xfe && (bytes[1] & 0xc0) == 0x80;
+}
+
+static int in6_is_addr_6to4(const struct in6_addr* ipv6_address) {
+  uint8_t* bytes = (uint8_t*)ipv6_address;
+  return bytes[0] == 0x20 && bytes[1] == 0x02;
+}
+
+static int in6_is_addr_ula(const struct in6_addr* ipv6_address) {
+  uint8_t* bytes = (uint8_t*)ipv6_address;
+  return (bytes[0] & 0xfe) == 0xfc;
+}
+
+static int in6_is_addr_teredo(const struct in6_addr* ipv6_address) {
+  uint8_t* bytes = (uint8_t*)ipv6_address;
+  return bytes[0] == 0x20 && bytes[1] == 0x01 && bytes[2] == 0x00 &&
+         bytes[3] == 0x00;
+}
+
+static int in6_is_addr_6bone(const struct in6_addr* ipv6_address) {
+  uint8_t* bytes = (uint8_t*)ipv6_address;
+  return bytes[0] == 0x3f && bytes[1] == 0xfe;
+}
+
+address_sorting_family address_sorting_abstract_get_family(
+    const address_sorting_address* address) {
+  switch (((struct sockaddr*)address)->sa_family) {
+    case AF_INET:
+      return ADDRESS_SORTING_AF_INET;
+    case AF_INET6:
+      return ADDRESS_SORTING_AF_INET6;
+    default:
+      return ADDRESS_SORTING_UNKNOWN_FAMILY;
+  }
+}
+
+static int get_label_value(const address_sorting_address* resolved_addr) {
+  if (address_sorting_abstract_get_family(resolved_addr) ==
+      ADDRESS_SORTING_AF_INET) {
+    return 4;
+  } else if (address_sorting_abstract_get_family(resolved_addr) !=
+             ADDRESS_SORTING_AF_INET6) {
+    return 1;
+  }
+  struct sockaddr_in6* ipv6_addr = (struct sockaddr_in6*)&resolved_addr->addr;
+  if (in6_is_addr_loopback(&ipv6_addr->sin6_addr)) {
+    return 0;
+  } else if (in6_is_addr_v4mapped(&ipv6_addr->sin6_addr)) {
+    return 4;
+  } else if (in6_is_addr_6to4(&ipv6_addr->sin6_addr)) {
+    return 2;
+  } else if (in6_is_addr_teredo(&ipv6_addr->sin6_addr)) {
+    return 5;
+  } else if (in6_is_addr_ula(&ipv6_addr->sin6_addr)) {
+    return 13;
+  } else if (in6_is_addr_v4compat(&ipv6_addr->sin6_addr)) {
+    return 3;
+  } else if (in6_is_addr_sitelocal(&ipv6_addr->sin6_addr)) {
+    return 11;
+  } else if (in6_is_addr_6bone(&ipv6_addr->sin6_addr)) {
+    return 12;
+  }
+  return 1;
+}
+
+static int get_precedence_value(const address_sorting_address* resolved_addr) {
+  if (address_sorting_abstract_get_family(resolved_addr) ==
+      ADDRESS_SORTING_AF_INET) {
+    return 35;
+  } else if (address_sorting_abstract_get_family(resolved_addr) !=
+             ADDRESS_SORTING_AF_INET6) {
+    return 1;
+  }
+  struct sockaddr_in6* ipv6_addr = (struct sockaddr_in6*)&resolved_addr->addr;
+  if (in6_is_addr_loopback(&ipv6_addr->sin6_addr)) {
+    return 50;
+  } else if (in6_is_addr_v4mapped(&ipv6_addr->sin6_addr)) {
+    return 35;
+  } else if (in6_is_addr_6to4(&ipv6_addr->sin6_addr)) {
+    return 30;
+  } else if (in6_is_addr_teredo(&ipv6_addr->sin6_addr)) {
+    return 5;
+  } else if (in6_is_addr_ula(&ipv6_addr->sin6_addr)) {
+    return 3;
+  } else if (in6_is_addr_v4compat(&ipv6_addr->sin6_addr) ||
+             in6_is_addr_sitelocal(&ipv6_addr->sin6_addr) ||
+             in6_is_addr_6bone(&ipv6_addr->sin6_addr)) {
+    return 1;
+  }
+  return 40;
+}
+
+static int sockaddr_get_scope(const address_sorting_address* resolved_addr) {
+  if (address_sorting_abstract_get_family(resolved_addr) ==
+      ADDRESS_SORTING_AF_INET) {
+    return kIPv6AddrScopeGlobal;
+  } else if (address_sorting_abstract_get_family(resolved_addr) ==
+             ADDRESS_SORTING_AF_INET6) {
+    struct sockaddr_in6* ipv6_addr = (struct sockaddr_in6*)&resolved_addr->addr;
+    if (in6_is_addr_loopback(&ipv6_addr->sin6_addr) ||
+        in6_is_addr_linklocal(&ipv6_addr->sin6_addr)) {
+      return kIPv6AddrScopeLinkLocal;
+    }
+    if (in6_is_addr_sitelocal(&ipv6_addr->sin6_addr)) {
+      return kIPv6AddrScopeSiteLocal;
+    }
+    return kIPv6AddrScopeGlobal;
+  }
+  return 0;
+}
+
+static int compare_source_addr_exists(const address_sorting_sortable* first,
+                                      const address_sorting_sortable* second) {
+  if (first->source_addr_exists != second->source_addr_exists) {
+    return first->source_addr_exists ? -1 : 1;
+  }
+  return 0;
+}
+
+static int compare_source_dest_scope_matches(
+    const address_sorting_sortable* first,
+    const address_sorting_sortable* second) {
+  int first_src_dst_scope_matches = 0;
+  if (sockaddr_get_scope(&first->dest_addr) ==
+      sockaddr_get_scope(&first->source_addr)) {
+    first_src_dst_scope_matches = 1;
+  }
+  int second_src_dst_scope_matches = 0;
+  if (sockaddr_get_scope(&second->dest_addr) ==
+      sockaddr_get_scope(&second->source_addr)) {
+    second_src_dst_scope_matches = 1;
+  }
+  if (first_src_dst_scope_matches != second_src_dst_scope_matches) {
+    return first_src_dst_scope_matches ? -1 : 1;
+  }
+  return 0;
+}
+
+static int compare_source_dest_labels_match(
+    const address_sorting_sortable* first,
+    const address_sorting_sortable* second) {
+  int first_label_matches = 0;
+  if (get_label_value(&first->dest_addr) ==
+      get_label_value(&first->source_addr)) {
+    first_label_matches = 1;
+  }
+  int second_label_matches = 0;
+  if (get_label_value(&second->dest_addr) ==
+      get_label_value(&second->source_addr)) {
+    second_label_matches = 1;
+  }
+  if (first_label_matches != second_label_matches) {
+    return first_label_matches ? 1 : 1;
+  }
+  return 0;
+}
+
+static int compare_dest_precedence(const address_sorting_sortable* first,
+                                   const address_sorting_sortable* second) {
+  return get_precedence_value(&second->dest_addr) -
+         get_precedence_value(&first->dest_addr);
+}
+
+static int compare_dest_scope(const address_sorting_sortable* first,
+                              const address_sorting_sortable* second) {
+  return sockaddr_get_scope(&first->dest_addr) -
+         sockaddr_get_scope(&second->dest_addr);
+}
+
+static int compare_source_dest_prefix_match_lengths(
+    const address_sorting_sortable* first,
+    const address_sorting_sortable* second) {
+  if (first->source_addr_exists &&
+      address_sorting_abstract_get_family(&first->source_addr) ==
+          ADDRESS_SORTING_AF_INET6 &&
+      second->source_addr_exists &&
+      address_sorting_abstract_get_family(&second->source_addr) ==
+          ADDRESS_SORTING_AF_INET6) {
+    int first_match_length =
+        ipv6_prefix_match_length((struct sockaddr_in6*)&first->source_addr.addr,
+                                 (struct sockaddr_in6*)&first->dest_addr.addr);
+    int second_match_length = ipv6_prefix_match_length(
+        (struct sockaddr_in6*)&second->source_addr.addr,
+        (struct sockaddr_in6*)&second->dest_addr.addr);
+    return second_match_length - first_match_length;
+  }
+  return 0;
+}
+
+static int rfc_6724_compare(const void* a, const void* b) {
+  const address_sorting_sortable* first = (address_sorting_sortable*)a;
+  const address_sorting_sortable* second = (address_sorting_sortable*)b;
+  int out = 0;
+  if ((out = compare_source_addr_exists(first, second))) {
+    return out;
+  }
+  if ((out = compare_source_dest_scope_matches(first, second))) {
+    return out;
+  }
+  if ((out = compare_source_dest_labels_match(first, second))) {
+    return out;
+  }
+  // TODO: Implement rule 3; avoid deprecated addresses.
+  // TODO: Implement rule 4; avoid temporary addresses.
+  if ((out = compare_dest_precedence(first, second))) {
+    return out;
+  }
+  // TODO: Implement rule 7; prefer native transports.
+  if ((out = compare_dest_scope(first, second))) {
+    return out;
+  }
+  if ((out = compare_source_dest_prefix_match_lengths(first, second))) {
+    return out;
+  }
+  // Prefer that the sort be stable otherwise
+  return (int)(first->original_index - second->original_index);
+}
+
+void address_sorting_override_source_addr_factory_for_testing(
+    address_sorting_source_addr_factory* factory) {
+  if (g_current_source_addr_factory == NULL) {
+    abort();
+  }
+  g_current_source_addr_factory->vtable->destroy(g_current_source_addr_factory);
+  g_current_source_addr_factory = factory;
+}
+
+static void sanity_check_private_fields_are_unused(
+    const address_sorting_sortable* sortable) {
+  address_sorting_address expected_source_addr;
+  memset(&expected_source_addr, 0, sizeof(expected_source_addr));
+  if (memcmp(&expected_source_addr, &sortable->source_addr,
+             sizeof(address_sorting_address)) ||
+      sortable->original_index || sortable->source_addr_exists) {
+    abort();
+  }
+}
+
+void address_sorting_rfc_6724_sort(address_sorting_sortable* sortables,
+                                   size_t sortables_len) {
+  for (size_t i = 0; i < sortables_len; i++) {
+    sanity_check_private_fields_are_unused(&sortables[i]);
+    sortables[i].original_index = i;
+    sortables[i].source_addr_exists = address_sorting_get_source_addr(
+        &sortables[i].dest_addr, &sortables[i].source_addr);
+  }
+  qsort(sortables, sortables_len, sizeof(address_sorting_sortable),
+        rfc_6724_compare);
+}
+
+void address_sorting_init() {
+  if (g_current_source_addr_factory != NULL) {
+    abort();
+  }
+  g_current_source_addr_factory =
+      address_sorting_create_source_addr_factory_for_current_platform();
+}
+
+void address_sorting_shutdown() {
+  if (g_current_source_addr_factory == NULL) {
+    abort();
+  }
+  g_current_source_addr_factory->vtable->destroy(g_current_source_addr_factory);
+}