ObjFW  Check-in [b99e38dcac]

Overview
Comment:OFSPXSocket: Rework blocks-based API
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA3-256: b99e38dcac2cb2db41a49c9d1d2c48c2e3e329d113e24e0f9fc7498496c084ab
User & Date: js on 2024-10-27 16:28:15
Other Links: manifest | tags
Context
2024-10-27
16:38
OFSPXStreamSocket: Rework blocks-based API check-in: 0bd1d8f35c user: js tags: trunk
16:28
OFSPXSocket: Rework blocks-based API check-in: b99e38dcac user: js tags: trunk
16:14
OFSequencedPacketSocket: Rework blocks-based API check-in: 776202396c user: js tags: trunk
Changes

Modified src/OFSPXSocket.h from [7e0f3dc650] to [878d3f1851].

27
28
29
30
31
32
33















34
35
36


37

38
39
40
41
42
43
44
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

54
55
56
57
58
59
60
61







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



+
+
-
+







@class OFSPXSocket;
@class OFString;

#ifdef OF_HAVE_BLOCKS
/**
 * @brief A block which is called when the socket connected.
 *
 * @deprecated Use @ref OFSPXSocketConnectedHandler instead.
 *
 * @param exception An exception which occurred while connecting the socket or
 *		    `nil` on success
 */
typedef void (^OFSPXSocketAsyncConnectBlock)(id _Nullable exception)
    OF_DEPRECATED(ObjFW, 1, 2, "Use OFSPXSocketConnectedHandler instead");

/**
 * @brief A handler which is called when the socket connected.
 *
 * @param socket The socket which connected
 * @param network The network of the node the socket connected to
 * @param node The node the socket connected to
 * @param port The port of the node to which the socket connected
 * @param exception An exception which occurred while connecting the socket or
 *		    `nil` on success
 */
typedef void (^OFSPXSocketConnectedHandler)(OFSPXSocket *socket,
    uint32_t network, const unsigned char node[_Nonnull IPX_NODE_LEN],
typedef void (^OFSPXSocketAsyncConnectBlock)(id _Nullable exception);
    uint16_t port, id _Nullable exception);
#endif

/**
 * @protocol OFSPXSocketDelegate OFSPXSocket.h ObjFW/ObjFW.h
 *
 * A delegate for OFSPXSocket.
 */
127
128
129
130
131
132
133


134
135
136
137
138
139
140
141
142
143

















144
145
146



147
148
149
150
151
152
153
154
155
156
157
158
159
160




















161
162
163
164
165
166
167
144
145
146
147
148
149
150
151
152
153
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







+
+









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



+
+
+













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







			 port: (uint16_t)port
		  runLoopMode: (OFRunLoopMode)runLoopMode;

#ifdef OF_HAVE_BLOCKS
/**
 * @brief Asynchronously connect the OFSPXSocket to the specified destination.
 *
 * @deprecated Use @ref asyncConnectToNetwork:node:port:handler: instead.
 *
 * @param node The node to connect to
 * @param network The network on which the node to connect to is
 * @param port The port (sometimes also called socket number) on the node to
 *	       connect to
 * @param block The block to execute once the connection has been established
 */
- (void)asyncConnectToNetwork: (uint32_t)network
			 node: (const unsigned char [_Nonnull IPX_NODE_LEN])node
			 port: (uint16_t)port
			block: (OFSPXSocketAsyncConnectBlock)block;
			block: (OFSPXSocketAsyncConnectBlock)block
    OF_DEPRECATED(ObjFW, 1, 2,
	"Use -[asyncConnectToNetwork:node:port:handler:] instead");

/**
 * @brief Asynchronously connect the OFSPXSocket to the specified destination.
 *
 * @param node The node to connect to
 * @param network The network on which the node to connect to is
 * @param port The port (sometimes also called socket number) on the node to
 *	       connect to
 * @param handler The handler to call once the connection has been established
 */
- (void)asyncConnectToNetwork: (uint32_t)network
			 node: (const unsigned char [_Nonnull IPX_NODE_LEN])node
			 port: (uint16_t)port
		      handler: (OFSPXSocketConnectedHandler)handler;

/**
 * @brief Asynchronously connect the OFSPXSocket to the specified destination.
 *
 * @deprecated Use @ref asyncConnectToNetwork:node:port:runLoopMode:handler:
 *	       instead.
 *
 * @param node The node to connect to
 * @param network The network on which the node to connect to is
 * @param port The port (sometimes also called socket number) on the node to
 *	       connect to
 * @param runLoopMode The run loop mode in which to perform the asynchronous
 *		      connect
 * @param block The block to execute once the connection has been established
 */
- (void)asyncConnectToNetwork: (uint32_t)network
			 node: (const unsigned char [_Nonnull IPX_NODE_LEN])node
			 port: (uint16_t)port
		  runLoopMode: (OFRunLoopMode)runLoopMode
			block: (OFSPXSocketAsyncConnectBlock)block;
			block: (OFSPXSocketAsyncConnectBlock)block
    OF_DEPRECATED(ObjFW, 1, 2,
	"Use -[asyncConnectToNetwork:node:port:runLoopMode:handler:] instead");

/**
 * @brief Asynchronously connect the OFSPXSocket to the specified destination.
 *
 * @param node The node to connect to
 * @param network The network on which the node to connect to is
 * @param port The port (sometimes also called socket number) on the node to
 *	       connect to
 * @param runLoopMode The run loop mode in which to perform the asynchronous
 *		      connect
 * @param handler The handler to call once the connection has been established
 */
- (void)asyncConnectToNetwork: (uint32_t)network
			 node: (const unsigned char [_Nonnull IPX_NODE_LEN])node
			 port: (uint16_t)port
		  runLoopMode: (OFRunLoopMode)runLoopMode
		      handler: (OFSPXSocketConnectedHandler)handler;
#endif

/**
 * @brief Bind the socket to the specified network, node and port.
 *
 * @param network The IPX network to bind to. 0 means the current network.
 * @param node The IPX network to bind to. An all zero node means the

Modified src/OFSPXSocket.m from [6998eecec7] to [01019c2861].

50
51
52
53
54
55
56
57

58
59
60
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

104
105
106
107
108
109
110
50
51
52
53
54
55
56

57
58
59
60
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
104
105
106
107
108
109
110







-
+








-
+











-
+










-
+













-
+







@interface OFSPXSocketAsyncConnectDelegate: OFObject <OFRunLoopConnectDelegate>
{
	OFSPXSocket *_socket;
	uint32_t _network;
	unsigned char _node[IPX_NODE_LEN];
	uint16_t _port;
#ifdef OF_HAVE_BLOCKS
	OFSPXSocketAsyncConnectBlock _block;
	OFSPXSocketConnectedHandler _handler;
#endif
}

- (instancetype)initWithSocket: (OFSPXSocket *)socket
		       network: (uint32_t)network
			  node: (const unsigned char [IPX_NODE_LEN])node
			  port: (uint16_t)port
#ifdef OF_HAVE_BLOCKS
			 block: (OFSPXSocketAsyncConnectBlock)block
		       handler: (OFSPXSocketConnectedHandler)handler
#endif
;
- (void)startWithRunLoopMode: (OFRunLoopMode)runLoopMode;
@end

@implementation OFSPXSocketAsyncConnectDelegate
- (instancetype)initWithSocket: (OFSPXSocket *)sock
		       network: (uint32_t)network
			  node: (const unsigned char [IPX_NODE_LEN])node
			  port: (uint16_t)port
#ifdef OF_HAVE_BLOCKS
			 block: (OFSPXSocketAsyncConnectBlock)block
		       handler: (OFSPXSocketConnectedHandler)handler
#endif
{
	self = [super init];

	@try {
		_socket = [sock retain];
		_network = network;
		memcpy(_node, node, IPX_NODE_LEN);
		_port = port;
#ifdef OF_HAVE_BLOCKS
		_block = [block copy];
		_handler = [handler copy];
#endif
	} @catch (id e) {
		[self release];
		@throw e;
	}

	return self;
}

- (void)dealloc
{
	[_socket release];
#ifdef OF_HAVE_BLOCKS
	[_block release];
	[_handler release];
#endif

	[super dealloc];
}

- (void)startWithRunLoopMode: (OFRunLoopMode)runLoopMode
{
148
149
150
151
152
153
154
155
156


157
158
159
160
161
162
163
148
149
150
151
152
153
154


155
156
157
158
159
160
161
162
163







-
-
+
+







{
	id <OFSPXSocketDelegate> delegate = ((OFSPXSocket *)sock).delegate;

	if (exception == nil)
		((OFSPXSocket *)sock).canBlock = true;

#ifdef OF_HAVE_BLOCKS
	if (_block != NULL)
		_block(exception);
	if (_handler != NULL)
		_handler(_socket, _network, _node, _port, exception);
	else {
#endif
		if ([delegate respondsToSelector:
		    @selector(socket:didConnectToNetwork:node:port:exception:)])
			[delegate	 socket: _socket
			    didConnectToNetwork: _network
					   node: _node
273
274
275
276
277
278
279
280

281
282
283
284
285
286
287
288
289
290
291
292


















293
294
295
296
297

298
299
300
301
302
303
304
305



















306
307
308
309
310
311
312
313

314
315
316
317
318
319
320
273
274
275
276
277
278
279

280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314

315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349

350
351
352
353
354
355
356
357







-
+












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




-
+








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







-
+








	[[[[OFSPXSocketAsyncConnectDelegate alloc]
	    initWithSocket: self
		   network: network
		      node: node
		      port: port
#ifdef OF_HAVE_BLOCKS
		     block: NULL
		   handler: NULL
#endif
	    ] autorelease] startWithRunLoopMode: runLoopMode];

	objc_autoreleasePoolPop(pool);
}

#ifdef OF_HAVE_BLOCKS
- (void)asyncConnectToNetwork: (uint32_t)network
			 node: (const unsigned char [IPX_NODE_LEN])node
			 port: (uint16_t)port
			block: (OFSPXSocketAsyncConnectBlock)block
{
	OFSPXSocketConnectedHandler handler = ^ (OFSPXSocket *socket,
	    uint32_t network_, const unsigned char node_[IPX_NODE_LEN],
	    uint16_t port_, id exception) {
		block(exception);
	};

	[self asyncConnectToNetwork: network
			       node: node
			       port: port
			runLoopMode: OFDefaultRunLoopMode
			    handler: handler];
}

- (void)asyncConnectToNetwork: (uint32_t)network
			 node: (const unsigned char [IPX_NODE_LEN])node
			 port: (uint16_t)port
		      handler: (OFSPXSocketConnectedHandler)handler
{
	[self asyncConnectToNetwork: network
			       node: node
			       port: port
			runLoopMode: OFDefaultRunLoopMode
			      block: block];
			    handler: handler];
}

- (void)asyncConnectToNetwork: (uint32_t)network
			 node: (const unsigned char [IPX_NODE_LEN])node
			 port: (uint16_t)port
		  runLoopMode: (OFRunLoopMode)runLoopMode
			block: (OFSPXSocketAsyncConnectBlock)block
{
	OFSPXSocketConnectedHandler handler = ^ (OFSPXSocket *socket,
	    uint32_t network_, const unsigned char node_[IPX_NODE_LEN],
	    uint16_t port_, id exception) {
		block(exception);
	};

	[self asyncConnectToNetwork: network
			       node: node
			       port: port
			runLoopMode: runLoopMode
			    handler: handler];
}

- (void)asyncConnectToNetwork: (uint32_t)network
			 node: (const unsigned char [IPX_NODE_LEN])node
			 port: (uint16_t)port
		  runLoopMode: (OFRunLoopMode)runLoopMode
		      handler: (OFSPXSocketConnectedHandler)handler
{
	void *pool = objc_autoreleasePoolPush();

	[[[[OFSPXSocketAsyncConnectDelegate alloc]
	    initWithSocket: self
		   network: network
		      node: node
		      port: port
		     block: block
		   handler: handler
	    ] autorelease] startWithRunLoopMode: runLoopMode];

	objc_autoreleasePoolPop(pool);
}
#endif

- (OFSocketAddress)bindToNetwork: (uint32_t)network