ObjFW  Check-in [1abe178915]

Overview
Comment:Always use AF_INET6 for MPTCP on Linux

This allows using IPv4 and IPv6 for the same connection.

Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | mptcp
Files: files | file ages | folders
SHA3-256: 1abe1789159219c2b0885647fb004a823ca41c21d8a00832572d5a2938281854
User & Date: js on 2024-10-30 21:11:27
Other Links: branch diff | manifest | tags
Context
2024-10-30
21:51
configure: Check if we have <linux/mptcp.h> check-in: 758e5eafae user: js tags: mptcp
21:11
Always use AF_INET6 for MPTCP on Linux check-in: 1abe178915 user: js tags: mptcp
2024-10-28
23:46
Initial MPTCP implementation for macOS/iOS check-in: 4e763857b8 user: js tags: mptcp
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified src/OFTCPSocket.m from [2efb3cbab4] to [31cc0fb260].

︙
61
62
63
64
65
66
67

68

69
70
71
72
73
74
75




















76
77
78
79
80
81
82

61
62
63
64
65
66
67
68

69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103








+
-
+







+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+








# ifndef AF_MULTIPATH
#  define AF_MULTIPATH 39
# endif
#endif

enum {
	flagUseMPTCP = 1,
	flagMapIPv4 = 2,
	flagUseConnectX = 2
	flagUseConnectX = 4
};

static const OFRunLoopMode connectRunLoopMode =
    @"OFTCPSocketConnectRunLoopMode";

static OFString *defaultSOCKS5Host = nil;
static uint16_t defaultSOCKS5Port = 1080;

#if defined(OF_LINUX) && defined(IPPROTO_MPTCP)
static OFSocketAddress
mapIPv4(const OFSocketAddress *IPv4Address)
{
	OFSocketAddress IPv6Address = {
		.family = OFSocketAddressFamilyIPv6,
		.length = sizeof(struct sockaddr_in6)
	};

	IPv6Address.sockaddr.in6.sin6_family = AF_INET6;
	IPv6Address.sockaddr.in6.sin6_port = IPv4Address->sockaddr.in.sin_port;
	memcpy(&IPv6Address.sockaddr.in6.sin6_addr.s6_addr[12],
	    &IPv4Address->sockaddr.in.sin_addr.s_addr, 4);
	IPv6Address.sockaddr.in6.sin6_addr.s6_addr[10] = 0xFF;
	IPv6Address.sockaddr.in6.sin6_addr.s6_addr[11] = 0xFF;

	return IPv6Address;
}
#endif

@interface OFTCPSocket () <OFAsyncIPSocketConnecting>
@end

@interface OFTCPSocketConnectDelegate: OFObject <OFTCPSocketDelegate>
{
@public
︙
154
155
156
157
158
159
160
161

162
163

164
165

166




167

168
169
170


171
172
173
174
175
176
177






178
179
180
181
182
183




184
185

186
187
188
189
190
191
192
193
194
195

196
197


198
199
200
201
202
203

204
205
206
207
208
209
210
211
212
213
214
215




216
217
218











219
220
221
222
223
224
225

175
176
177
178
179
180
181

182
183

184


185
186
187
188
189
190

191



192
193







194
195
196
197
198
199


200
201


202
203
204
205
206

207








208

209

210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256








-
+

-
+
-
-
+

+
+
+
+
-
+
-
-
-
+
+
-
-
-
-
-
-
-
+
+
+
+
+
+
-
-


-
-
+
+
+
+

-
+
-
-
-
-
-
-
-
-

-
+
-

+
+






+












+
+
+
+



+
+
+
+
+
+
+
+
+
+
+








- (bool)of_createSocketForAddress: (const OFSocketAddress *)address
			    errNo: (int *)errNo
{
#if SOCK_CLOEXEC == 0 && defined(HAVE_FCNTL) && defined(FD_CLOEXEC)
	int flags;
#endif

	if (_socket != OFInvalidSocketHandle) {
	if (_socket != OFInvalidSocketHandle)
		@throw [OFAlreadyOpenException exceptionWithObject: self];
	}


#if defined(OF_LINUX)
#if defined(OF_LINUX) && defined(IPPROTO_MPTCP)
	if (_flags & flagUseMPTCP) {
		/*
		 * For MPTCP sockets, we always use AF_INET6, so that IPv4 and
		 * IPv6 can both be used for a single connection.
		 */
		if ((_socket = socket(
		_socket = socket(AF_INET6, SOCK_STREAM | SOCK_CLOEXEC,
		    ((struct sockaddr *)&address->sockaddr)->sa_family,
		    SOCK_STREAM | SOCK_CLOEXEC, IPPROTO_MPTCP)) ==
		    OFInvalidSocketHandle) {
		    IPPROTO_MPTCP);

			if ((_socket = socket(
			    ((struct sockaddr *)&address->sockaddr)->sa_family,
			    SOCK_STREAM | SOCK_CLOEXEC, 0)) ==
			    OFInvalidSocketHandle) {
				*errNo = _OFSocketErrNo();
				return false;
			}
		if (_socket != OFInvalidSocketHandle &&
		    address->family == OFSocketAddressFamilyIPv4)
			_flags |= flagMapIPv4;
		else
			_flags &= ~flagMapIPv4;
	}
		}
	} else
#elif defined(OF_MACOS) || defined(OF_IOS)
	if (_flags & flagUseMPTCP) {
		if ((_socket = socket(AF_MULTIPATH, SOCK_STREAM | SOCK_CLOEXEC,
		    IPPROTO_TCP)) != OFInvalidSocketHandle)
		_socket = socket(AF_MULTIPATH, SOCK_STREAM | SOCK_CLOEXEC,
		    IPPROTO_TCP);

		if (_socket != OFInvalidSocketHandle)
			_flags |= flagUseConnectX;
		else {
		else
			if ((_socket = socket(
			    ((struct sockaddr *)&address->sockaddr)->sa_family,
			    SOCK_STREAM | SOCK_CLOEXEC, 0)) ==
			    OFInvalidSocketHandle) {
				*errNo = _OFSocketErrNo();
				return false;
			}

			_flags &= ~flagUseConnectX;
		}
	}
	} else
#endif

	if (_socket == OFInvalidSocketHandle) {
		if ((_socket = socket(
		    ((struct sockaddr *)&address->sockaddr)->sa_family,
		    SOCK_STREAM | SOCK_CLOEXEC, 0)) == OFInvalidSocketHandle) {
			*errNo = _OFSocketErrNo();
			return false;
		}
	}

#if SOCK_CLOEXEC == 0 && defined(HAVE_FCNTL) && defined(FD_CLOEXEC)
	if ((flags = fcntl(_socket, F_GETFD, 0)) != -1)
		fcntl(_socket, F_SETFD, flags | FD_CLOEXEC);
#endif

	return true;
}

- (bool)of_connectSocketToAddress: (const OFSocketAddress *)address
			    errNo: (int *)errNo
{
#if defined(OF_LINUX) && defined(IPPROTO_MPTCP)
	OFSocketAddress mappedIPv4;
#endif

	if (_socket == OFInvalidSocketHandle) {
		@throw [OFNotOpenException exceptionWithObject: self];
	}

#if defined(OF_LINUX) && defined(IPPROTO_MPTCP)
	if (_flags & flagMapIPv4) {
		/*
		 * For MPTCP sockets, we always use AF_INET6, so that IPv4 and
		 * IPv6 can both be used for a single connection.
		 */
		mappedIPv4 = mapIPv4(address);
		address = &mappedIPv4;
	}
#endif

#if defined(OF_MACOS) || defined(OF_IOS)
	if (_flags & flagUseConnectX) {
		sa_endpoints_t endpoints = {
			.sae_dstaddr = (struct sockaddr *)&address->sockaddr,
			.sae_dstaddrlen = address->length
		};
︙
411
412
413
414
415
416
417
418

419




420

421
422
423


424
425
426
427

428
429
430
431
432
433



434
435


436
437
438
439
440
441
442

442
443
444
445
446
447
448

449
450
451
452
453
454

455



456
457




458






459
460
461

462
463
464
465
466
467
468
469
470
471








-
+

+
+
+
+
-
+
-
-
-
+
+
-
-
-
-
+
-
-
-
-
-
-
+
+
+
-

+
+








	socketAddresses = [[OFThread DNSResolver]
	    resolveAddressesForHost: host
		      addressFamily: OFSocketAddressFamilyAny];

	address = *(OFSocketAddress *)[socketAddresses itemAtIndex: 0];
	OFSocketAddressSetIPPort(&address, port);

#ifdef OF_LINUX
#if defined(OF_LINUX) && defined(IPPROTO_MPTCP)
	if (_flags & flagUseMPTCP) {
		/*
		 * For MPTCP sockets, we always use AF_INET6, so that IPv4 and
		 * IPv6 can both be used for a single connection.
		 */
		if ((_socket = socket(
		_socket = socket(AF_INET6, SOCK_STREAM | SOCK_CLOEXEC,
		    ((struct sockaddr *)&address.sockaddr)->sa_family,
		    SOCK_STREAM | SOCK_CLOEXEC, IPPROTO_MPTCP)) ==
		    OFInvalidSocketHandle) {
		    IPPROTO_MPTCP);

			if ((_socket = socket(
			    ((struct sockaddr *)&address.sockaddr)->sa_family,
			    SOCK_STREAM | SOCK_CLOEXEC, 0)) ==
			    OFInvalidSocketHandle)
		if (_socket != OFInvalidSocketHandle &&
				@throw [OFBindIPSocketFailedException
				    exceptionWithHost: host
						 port: port
					       socket: self
						errNo: _OFSocketErrNo()];
		}
		    address.family == OFSocketAddressFamilyIPv4)
			address = mapIPv4(&address);
	}
	} else
#endif

	if (_socket == OFInvalidSocketHandle)
		if ((_socket = socket(
		    ((struct sockaddr *)&address.sockaddr)->sa_family,
		    SOCK_STREAM | SOCK_CLOEXEC, 0)) == OFInvalidSocketHandle)
			@throw [OFBindIPSocketFailedException
			    exceptionWithHost: host
					 port: port
				       socket: self
︙
603
604
605
606
607
608
609
610

611
612
613
614
615
616
617

632
633
634
635
636
637
638

639
640
641
642
643
644
645
646








-
+








		_flags |= flagUseMPTCP;
	else
		_flags &= ~flagUseMPTCP;
}

- (bool)usesMPTCP
{
#ifdef OF_LINUX
#if defined(OF_LINUX) && defined(SOL_MPTCP) && defined(MPTCP_INFO)
	struct mptcp_info info;
	socklen_t infoLen = (socklen_t)sizeof(info);

	if (getsockopt(_socket, SOL_MPTCP, MPTCP_INFO, &info, &infoLen) != -1)
		return true;
#endif
︙