diff --git a/sdk/fidl/fuchsia.posix.socket/socket.fidl b/sdk/fidl/fuchsia.posix.socket/socket.fidl
index 8d134fb..00e4e56 100644
--- a/sdk/fidl/fuchsia.posix.socket/socket.fidl
+++ b/sdk/fidl/fuchsia.posix.socket/socket.fidl
@@ -533,6 +533,25 @@
         /// The Hop Limit value to set in the IPv6 header of an outgoing
         /// packet.
         2: hoplimit uint8;
+
+        /// Information controlling the local interface and/or address used when
+        /// sending an IPv6 packet.
+        //
+        // This is a structure instead of a table as it is meant to match
+        // `in6_pktinfo` which is not expected to grow.
+        3: pktinfo @generated_name("Ipv6PktInfoSendControlData") struct {
+            /// The interface index from which the IPv6 packet should be sent.
+            ///
+            /// 0 indicates that the local interface is unspecified and the
+            /// stack may choose an appropriate interface.
+            iface fuchsia.net.interface_id;
+            /// The source address from which the IPv6 packet should be sent.
+            ///
+            /// All zeroes indicates that the local address is unspecified and
+            /// the stack may choose an appropriate address (i.e. the local
+            /// address to which the socket is bound).
+            local_addr fuchsia.net.Ipv6Address;
+        };
     };
 };
 
diff --git a/sdk/lib/fdio/socket.cc b/sdk/lib/fdio/socket.cc
index ce94bac..ae660a4 100644
--- a/sdk/lib/fdio/socket.cc
+++ b/sdk/lib/fdio/socket.cc
@@ -295,8 +295,9 @@
   }
 }
 
-int16_t ParseIpv6LevelControlMessage(fsocket::wire::Ipv6SendControlData& fidl_ipv6, int type,
-                                     const void* data, socklen_t data_len) {
+int16_t ParseIpv6LevelControlMessage(fsocket::wire::Ipv6SendControlData& fidl_ipv6,
+                                     fidl::AnyArena& allocator, int type, const void* data,
+                                     socklen_t data_len) {
   switch (type) {
     case IPV6_HOPLIMIT: {
       int hoplimit;
@@ -315,6 +316,21 @@
       }
       return 0;
     }
+    case IPV6_PKTINFO: {
+      in6_pktinfo pktinfo;
+      if (data_len != sizeof(pktinfo)) {
+        return EINVAL;
+      }
+      memcpy(&pktinfo, data, sizeof(pktinfo));
+      fsocket::wire::Ipv6PktInfoSendControlData fidl_pktinfo{
+          .iface = static_cast<uint64_t>(pktinfo.ipi6_ifindex),
+      };
+      static_assert(sizeof(pktinfo.ipi6_addr) == sizeof(fidl_pktinfo.local_addr.addr),
+                    "mismatch between size of FIDL and in6_pktinfo IPv6 addresses");
+      memcpy(fidl_pktinfo.local_addr.addr.data(), &pktinfo.ipi6_addr, sizeof(pktinfo.ipi6_addr));
+      fidl_ipv6.set_pktinfo(allocator, fidl_pktinfo);
+      return 0;
+    }
     default:
       // TODO(https://fxbug.dev/88984): Validate unsupported SOL_IPV6 control messages.
       return 0;
@@ -350,7 +366,7 @@
       if (!fidl_net.has_ipv6()) {
         fidl_net.set_ipv6(allocator, fsocket::wire::Ipv6SendControlData(allocator));
       }
-      return ParseIpv6LevelControlMessage(fidl_net.ipv6(), type, data, data_len);
+      return ParseIpv6LevelControlMessage(fidl_net.ipv6(), allocator, type, data, data_len);
     default:
       return 0;
   }
diff --git a/src/connectivity/network/netstack/fuchsia_posix_socket.go b/src/connectivity/network/netstack/fuchsia_posix_socket.go
index 8a722fc..5e5bbba 100644
--- a/src/connectivity/network/netstack/fuchsia_posix_socket.go
+++ b/src/connectivity/network/netstack/fuchsia_posix_socket.go
@@ -1943,10 +1943,18 @@
 	if in.HasIpv6() {
 		inIpv6 := in.GetIpv6()
 		if inIpv6.HasHoplimit() {
-			hoplimit := inIpv6.GetHoplimit()
-			out.HopLimit = hoplimit
+			out.HopLimit = inIpv6.GetHoplimit()
 			out.HasHopLimit = true
 		}
+
+		if inIpv6.HasPktinfo() {
+			pktInfo := inIpv6.GetPktinfo()
+			out.IPv6PacketInfo = tcpip.IPv6PacketInfo{
+				NIC:  tcpip.NICID(pktInfo.Iface),
+				Addr: toTcpIpAddressDroppingUnspecifiedv6(pktInfo.LocalAddr),
+			}
+			out.HasIPv6PacketInfo = true
+		}
 	}
 
 	return 0
diff --git a/src/connectivity/network/tests/multi_nic/BUILD.gn b/src/connectivity/network/tests/multi_nic/BUILD.gn
index 55139c9..7112cb0 100644
--- a/src/connectivity/network/tests/multi_nic/BUILD.gn
+++ b/src/connectivity/network/tests/multi_nic/BUILD.gn
@@ -7,7 +7,10 @@
 
 test("bin") {
   output_name = "multi_nic_test_client"
-  sources = [ "main.cc" ]
+  sources = [
+    "main.cc",
+    "socket_test.cc",
+  ]
 
   deps = [
     "//src/connectivity/network/testing/netemul/sync-manager/fidl:sync_llcpp",
diff --git a/src/connectivity/network/tests/multi_nic/constants.h b/src/connectivity/network/tests/multi_nic/constants.h
new file mode 100644
index 0000000..eeeb1a7
--- /dev/null
+++ b/src/connectivity/network/tests/multi_nic/constants.h
@@ -0,0 +1,23 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SRC_CONNECTIVITY_NETWORK_TESTS_MULTI_NIC_CONSTANTS_H_
+#define SRC_CONNECTIVITY_NETWORK_TESTS_MULTI_NIC_CONSTANTS_H_
+
+#include <stdint.h>
+
+constexpr char kClientNic1Name[] = "client-ep-1";
+constexpr char kClientNic2Name[] = "client-ep-2";
+
+constexpr char kClientIpv4Addr1[] = "192.168.0.1";
+constexpr char kClientIpv4Addr2[] = "192.168.0.2";
+constexpr char kServerIpv4Addr[] = "192.168.0.254";
+
+constexpr char kClientIpv6Addr1[] = "a::1";
+constexpr char kClientIpv6Addr2[] = "a::2";
+constexpr char kServerIpv6Addr[] = "a::ffff";
+
+constexpr uint16_t kServerPort = 1234;
+
+#endif  // SRC_CONNECTIVITY_NETWORK_TESTS_MULTI_NIC_CONSTANTS_H_
diff --git a/src/connectivity/network/tests/multi_nic/main.cc b/src/connectivity/network/tests/multi_nic/main.cc
index d880e0d..b5a27a3 100644
--- a/src/connectivity/network/tests/multi_nic/main.cc
+++ b/src/connectivity/network/tests/multi_nic/main.cc
@@ -12,20 +12,14 @@
 #include <fbl/unique_fd.h>
 #include <gtest/gtest.h>
 
+#include "constants.h"
+
 namespace {
 
 constexpr char kBusName[] = "test-bus";
 constexpr char kTestClientName[] = "client";
 constexpr char kTestServerName[] = "server";
 
-constexpr char kClientIpv4Addr1[] = "192.168.0.1";
-constexpr char kClientIpv4Addr2[] = "192.168.0.2";
-constexpr char kServerIpv4Addr[] = "192.168.0.254";
-constexpr char kClientIpv6Addr1[] = "a::1";
-constexpr char kClientIpv6Addr2[] = "a::2";
-constexpr char kServerIpv6Addr[] = "a::ffff";
-constexpr uint16_t kServerPort = 1234;
-
 void TestUdpPing(int domain, const sockaddr* bind_addr, socklen_t bind_addr_len,
                  const sockaddr* connect_addr, socklen_t connect_addr_len) {
   fbl::unique_fd s;
diff --git a/src/connectivity/network/tests/multi_nic/socket_test.cc b/src/connectivity/network/tests/multi_nic/socket_test.cc
new file mode 100644
index 0000000..458bbf4
--- /dev/null
+++ b/src/connectivity/network/tests/multi_nic/socket_test.cc
@@ -0,0 +1,259 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+
+#include <algorithm>
+
+#include <fbl/unique_fd.h>
+#include <gtest/gtest.h>
+
+#include "constants.h"
+
+namespace {
+
+struct SendIpv6PacketInfoSuccessTestCase {
+  std::string test_name;
+  std::optional<std::string> send_local_addr_str;
+  std::optional<std::string> send_local_if_str;
+  std::string expected_recv_addr_str;
+};
+
+class SendIpv6PacketInfoSuccessTest
+    : public testing::TestWithParam<SendIpv6PacketInfoSuccessTestCase> {};
+
+TEST_P(SendIpv6PacketInfoSuccessTest, SendAndRecv) {
+  fbl::unique_fd s;
+  ASSERT_TRUE(s = fbl::unique_fd(socket(AF_INET6, SOCK_DGRAM, 0))) << strerror(errno);
+
+  constexpr int kOne = 1;
+  ASSERT_EQ(setsockopt(s.get(), SOL_IPV6, IPV6_RECVPKTINFO, &kOne, sizeof(kOne)), 0)
+      << strerror(errno);
+
+  const sockaddr_in6 bind_addr{
+      .sin6_family = AF_INET6,
+  };
+  ASSERT_EQ(bind(s.get(), reinterpret_cast<const sockaddr*>(&bind_addr), sizeof(bind_addr)), 0)
+      << strerror(errno);
+
+  sockaddr_in6 to_addr = {
+      .sin6_family = AF_INET6,
+      .sin6_port = htons(kServerPort),
+  };
+  ASSERT_EQ(inet_pton(to_addr.sin6_family, kServerIpv6Addr, &to_addr.sin6_addr), 1);
+
+  const auto [test_name, send_local_addr_str, send_local_if_str, expected_recv_addr_str] =
+      GetParam();
+  in6_addr expected_recv_addr;
+  ASSERT_EQ(inet_pton(AF_INET6, expected_recv_addr_str.c_str(), &expected_recv_addr), 1);
+  in6_pktinfo send_pktinfo = {};
+  if (send_local_addr_str.has_value()) {
+    ASSERT_EQ(inet_pton(AF_INET6, send_local_addr_str->c_str(), &send_pktinfo.ipi6_addr), 1);
+  }
+  if (send_local_if_str.has_value()) {
+    send_pktinfo.ipi6_ifindex = if_nametoindex(send_local_if_str->c_str());
+  }
+
+  char send_buf[] = "hello";
+  iovec send_iovec = {
+      .iov_base = send_buf,
+      .iov_len = sizeof(send_buf),
+  };
+  char send_control[CMSG_SPACE(sizeof(send_pktinfo)) + 1];
+  msghdr send_msghdr = {
+      .msg_name = &to_addr,
+      .msg_namelen = sizeof(to_addr),
+      .msg_iov = &send_iovec,
+      .msg_iovlen = 1,
+      .msg_control = send_control,
+      .msg_controllen = sizeof(send_control),
+  };
+  cmsghdr* cmsg = CMSG_FIRSTHDR(&send_msghdr);
+  ASSERT_NE(cmsg, nullptr);
+  cmsg->cmsg_len = CMSG_LEN(sizeof(send_pktinfo));
+  cmsg->cmsg_level = SOL_IPV6;
+  cmsg->cmsg_type = IPV6_PKTINFO;
+  memcpy(CMSG_DATA(cmsg), &send_pktinfo, sizeof(send_pktinfo));
+  ASSERT_EQ(sendmsg(s.get(), &send_msghdr, 0), static_cast<ssize_t>(sizeof(send_buf)))
+      << strerror(errno);
+
+  constexpr char kExpectedRecvBuf[] = "Response: hello";
+  in6_pktinfo recv_pktinfo;
+  char recv_buf[sizeof(kExpectedRecvBuf) + 1];
+  iovec recv_iovec = {
+      .iov_base = recv_buf,
+      .iov_len = sizeof(recv_buf),
+  };
+  char recv_control[CMSG_SPACE(sizeof(recv_pktinfo)) + 1];
+  msghdr recv_msghdr = {
+      .msg_iov = &recv_iovec,
+      .msg_iovlen = 1,
+      .msg_control = recv_control,
+      .msg_controllen = sizeof(recv_control),
+  };
+
+  ASSERT_EQ(recvmsg(s.get(), &recv_msghdr, 0), static_cast<ssize_t>(sizeof(kExpectedRecvBuf)))
+      << strerror(errno);
+  EXPECT_EQ(std::string_view(kExpectedRecvBuf, sizeof(kExpectedRecvBuf)),
+            std::string_view(recv_buf, sizeof(kExpectedRecvBuf)));
+  cmsg = CMSG_FIRSTHDR(&recv_msghdr);
+  ASSERT_NE(cmsg, nullptr);
+  EXPECT_EQ(cmsg->cmsg_len, CMSG_LEN(sizeof(recv_pktinfo)));
+  EXPECT_EQ(cmsg->cmsg_level, SOL_IPV6);
+  EXPECT_EQ(cmsg->cmsg_type, IPV6_PKTINFO);
+  memcpy(&recv_pktinfo, CMSG_DATA(cmsg), sizeof(recv_pktinfo));
+  EXPECT_EQ(memcmp(&recv_pktinfo.ipi6_addr, &expected_recv_addr, sizeof(expected_recv_addr)), 0);
+}
+
+INSTANTIATE_TEST_SUITE_P(SocketTests, SendIpv6PacketInfoSuccessTest,
+                         testing::Values(
+                             SendIpv6PacketInfoSuccessTestCase{
+                                 .test_name = "NIC1 local address",
+                                 .send_local_addr_str = kClientIpv6Addr1,
+                                 .expected_recv_addr_str = kClientIpv6Addr1,
+                             },
+                             SendIpv6PacketInfoSuccessTestCase{
+                                 .test_name = "NIC1 local interface",
+                                 .send_local_if_str = kClientNic1Name,
+                                 .expected_recv_addr_str = kClientIpv6Addr1,
+                             },
+                             SendIpv6PacketInfoSuccessTestCase{
+                                 .test_name = "NIC1 local address and interface",
+                                 .send_local_addr_str = kClientIpv6Addr1,
+                                 .send_local_if_str = kClientNic1Name,
+                                 .expected_recv_addr_str = kClientIpv6Addr1,
+                             },
+                             SendIpv6PacketInfoSuccessTestCase{
+                                 .test_name = "NIC2 local address",
+                                 .send_local_addr_str = kClientIpv6Addr2,
+                                 .expected_recv_addr_str = kClientIpv6Addr2,
+                             },
+                             SendIpv6PacketInfoSuccessTestCase{
+                                 .test_name = "NIC2 local interface",
+                                 .send_local_if_str = kClientNic2Name,
+                                 .expected_recv_addr_str = kClientIpv6Addr2,
+                             },
+                             SendIpv6PacketInfoSuccessTestCase{
+                                 .test_name = "NIC2 local address and interface",
+                                 .send_local_addr_str = kClientIpv6Addr2,
+                                 .send_local_if_str = kClientNic2Name,
+                                 .expected_recv_addr_str = kClientIpv6Addr2,
+                             }),
+                         [](const testing::TestParamInfo<SendIpv6PacketInfoSuccessTestCase>& info) {
+                           std::string test_name(info.param.test_name);
+                           std::replace(test_name.begin(), test_name.end(), ' ', '_');
+                           return test_name;
+                         });
+
+struct SendIpv6PacketInfoFailureTestCase {
+  std::string test_name;
+  std::string bind_addr_str;
+  std::optional<std::string> bind_to_device;
+  std::optional<std::string> send_local_addr_str;
+  std::optional<std::string> send_local_if_str;
+  ssize_t expected_errno;
+};
+
+class SendIpv6PacketInfoFailureTest
+    : public testing::TestWithParam<SendIpv6PacketInfoFailureTestCase> {};
+
+TEST_P(SendIpv6PacketInfoFailureTest, CheckError) {
+  fbl::unique_fd s;
+  ASSERT_TRUE(s = fbl::unique_fd(socket(AF_INET6, SOCK_DGRAM, 0))) << strerror(errno);
+
+  const auto [test_name, bind_addr_str, bind_to_device, send_local_addr_str, send_local_if_str,
+              expected_errno] = GetParam();
+
+  if (bind_to_device.has_value()) {
+    ASSERT_EQ(setsockopt(s.get(), SOL_SOCKET, SO_BINDTODEVICE, bind_to_device->c_str(),
+                         static_cast<socklen_t>(bind_to_device->size())),
+              0)
+        << strerror(errno);
+  }
+
+  sockaddr_in6 bind_addr{
+      .sin6_family = AF_INET6,
+  };
+  ASSERT_EQ(inet_pton(bind_addr.sin6_family, bind_addr_str.c_str(), &bind_addr.sin6_addr), 1);
+  ASSERT_EQ(bind(s.get(), reinterpret_cast<const sockaddr*>(&bind_addr), sizeof(bind_addr)), 0)
+      << strerror(errno);
+
+  sockaddr_in6 to_addr = {
+      .sin6_family = AF_INET6,
+      .sin6_port = htons(kServerPort),
+  };
+  ASSERT_EQ(inet_pton(to_addr.sin6_family, kServerIpv6Addr, &to_addr.sin6_addr), 1);
+
+  in6_pktinfo send_pktinfo = {};
+  if (send_local_addr_str.has_value()) {
+    ASSERT_EQ(inet_pton(AF_INET6, send_local_addr_str->c_str(), &send_pktinfo.ipi6_addr), 1);
+  }
+  if (send_local_if_str.has_value()) {
+    send_pktinfo.ipi6_ifindex = if_nametoindex(send_local_if_str->c_str());
+  }
+
+  char send_buf[] = "hello";
+  iovec send_iovec = {
+      .iov_base = send_buf,
+      .iov_len = sizeof(send_buf),
+  };
+  char send_control[CMSG_SPACE(sizeof(send_pktinfo)) + 1];
+  msghdr send_msghdr = {
+      .msg_name = &to_addr,
+      .msg_namelen = sizeof(to_addr),
+      .msg_iov = &send_iovec,
+      .msg_iovlen = 1,
+      .msg_control = send_control,
+      .msg_controllen = sizeof(send_control),
+  };
+  cmsghdr* cmsg = CMSG_FIRSTHDR(&send_msghdr);
+  ASSERT_NE(cmsg, nullptr);
+  cmsg->cmsg_len = CMSG_LEN(sizeof(send_pktinfo));
+  cmsg->cmsg_level = SOL_IPV6;
+  cmsg->cmsg_type = IPV6_PKTINFO;
+  memcpy(CMSG_DATA(cmsg), &send_pktinfo, sizeof(send_pktinfo));
+  ASSERT_EQ(sendmsg(s.get(), &send_msghdr, 0), -1);
+  EXPECT_EQ(errno, expected_errno) << strerror(errno);
+}
+
+constexpr char kIpv6UnspecifiedAddr[] = "::";
+
+INSTANTIATE_TEST_SUITE_P(SocketTests, SendIpv6PacketInfoFailureTest,
+                         testing::Values(
+                             SendIpv6PacketInfoFailureTestCase{
+                                 .test_name = "Local interface and bound device mismatch",
+                                 .bind_addr_str = kIpv6UnspecifiedAddr,
+                                 .bind_to_device = kClientNic2Name,
+                                 .send_local_if_str = kClientNic1Name,
+                                 .expected_errno = EHOSTUNREACH,
+                             },
+                             SendIpv6PacketInfoFailureTestCase{
+                                 .test_name = "Local address and bound device mismatch",
+                                 .bind_addr_str = kIpv6UnspecifiedAddr,
+                                 .bind_to_device = kClientNic2Name,
+                                 .send_local_addr_str = kClientIpv6Addr1,
+                                 .expected_errno = EADDRNOTAVAIL,
+                             },
+                             SendIpv6PacketInfoFailureTestCase{
+                                 .test_name = "Local addr and interface mismatch",
+                                 .bind_addr_str = kIpv6UnspecifiedAddr,
+                                 .send_local_addr_str = kClientIpv6Addr2,
+                                 .send_local_if_str = kClientNic1Name,
+                                 .expected_errno = EADDRNOTAVAIL,
+                             },
+                             SendIpv6PacketInfoFailureTestCase{
+                                 .test_name = "Bound address and local interface mismatch",
+                                 .bind_addr_str = kClientIpv6Addr1,
+                                 .send_local_if_str = kClientNic2Name,
+                                 .expected_errno = EADDRNOTAVAIL}),
+                         [](const testing::TestParamInfo<SendIpv6PacketInfoFailureTestCase>& info) {
+                           std::string test_name(info.param.test_name);
+                           std::replace(test_name.begin(), test_name.end(), ' ', '_');
+                           return test_name;
+                         });
+
+}  // namespace