︙ | | |
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
-
+
|
*
* @param socket The socket that received a packet
* @param buffer The buffer the packet was stored in
* @param length The length of the packet
* @param sender The address of the sender of the packet
* @param exception An exception which occurred while receiving or `nil` on
* success
* @return A bool whether the same block should be used for the next receive
* @return A bool whether the same handler should be used for the next receive
*/
typedef bool (^OFDatagramSocketPacketReceivedHandler)(OFDatagramSocket *socket,
void *buffer, size_t length, const OFSocketAddress *_Nonnull sender,
id _Nullable exception);
/**
* @brief A block which is called when a packet has been sent.
|
︙ | | |
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
-
+
|
*
* @param socket The datagram socket which received a packet
* @param buffer The buffer the packet has been written to
* @param length The length of the packet
* @param sender The address of the sender of the packet
* @param exception An exception that occurred while receiving, or nil on
* success
* @return A bool whether the same block should be used for the next receive
* @return A bool whether the same handler should be used for the next receive
*/
- (bool)socket: (OFDatagramSocket *)socket
didReceiveIntoBuffer: (void *)buffer
length: (size_t)length
sender: (const OFSocketAddress *_Nonnull)sender
exception: (nullable id)exception;
|
︙ | | |
︙ | | |
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
|
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
|
-
+
-
+
|
@end
# ifdef OF_HAVE_SCTP
@interface OFRunLoopSCTPReceiveQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
OFSCTPSocketAsyncReceiveBlock _block;
OFSCTPSocketMessageReceivedHandler _handler;
# endif
void *_buffer;
size_t _length;
}
@end
@interface OFRunLoopSCTPSendQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
OFSCTPSocketAsyncSendDataBlock _block;
OFSCTPSocketDataSentHandler _handler;
# endif
OFData *_data;
OFSCTPMessageInfo _info;
}
@end
# endif
#endif
|
︙ | | |
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
|
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
|
-
-
+
+
-
+
|
info: &info];
} @catch (id e) {
length = 0;
exception = e;
}
# ifdef OF_HAVE_BLOCKS
if (_block != NULL)
return _block(length, info, exception);
if (_handler != NULL)
return _handler(object, _buffer, length, info, exception);
else {
# endif
if (![_delegate respondsToSelector: @selector(
socket:didReceiveIntoBuffer:length:info:exception:)])
return false;
return [_delegate socket: object
didReceiveIntoBuffer: _buffer
length: length
info: info
exception: exception];
# ifdef OF_HAVE_BLOCKS
}
# endif
}
# ifdef OF_HAVE_BLOCKS
- (void)dealloc
{
[_block release];
[_handler release];
[super dealloc];
}
# endif
@end
@implementation OFRunLoopSCTPSendQueueItem
|
︙ | | |
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
|
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
|
-
-
+
+
|
length: _data.count * _data.itemSize
info: _info];
} @catch (id e) {
exception = e;
}
# ifdef OF_HAVE_BLOCKS
if (_block != NULL) {
newData = _block(exception);
if (_handler != NULL) {
newData = _handler(object, _data, _info, exception);
if (newData == nil)
return false;
oldData = _data;
_data = [newData copy];
[oldData release];
|
︙ | | |
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
|
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
|
-
+
|
}
# endif
}
- (void)dealloc
{
# ifdef OF_HAVE_BLOCKS
[_block release];
[_handler release];
# endif
[_data release];
[_info release];
[super dealloc];
}
@end
|
︙ | | |
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
|
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
|
+
-
-
-
-
+
+
+
+
-
+
-
+
-
+
-
+
-
+
|
# endif
queueItem->_data = [data copy];
QUEUE_ITEM
}
# ifdef OF_HAVE_SCTP
+ (void)
+ (void)of_addAsyncReceiveForSCTPSocket: (OFSCTPSocket *)sock
buffer: (void *)buffer
length: (size_t)length
mode: (OFRunLoopMode)mode
of_addAsyncReceiveForSCTPSocket: (OFSCTPSocket *)sock
buffer: (void *)buffer
length: (size_t)length
mode: (OFRunLoopMode)mode
# ifdef OF_HAVE_BLOCKS
block: (OFSCTPSocketAsyncReceiveBlock)block
handler: (OFSCTPSocketMessageReceivedHandler)handler
# endif
delegate: (id <OFSCTPSocketDelegate>)delegate
delegate: (id <OFSCTPSocketDelegate>)delegate
{
NEW_READ(OFRunLoopSCTPReceiveQueueItem, sock, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
queueItem->_block = [block copy];
queueItem->_handler = [handler copy];
# endif
queueItem->_buffer = buffer;
queueItem->_length = length;
QUEUE_ITEM
}
+ (void)of_addAsyncSendForSCTPSocket: (OFSCTPSocket *)sock
data: (OFData *)data
info: (OFSCTPMessageInfo)info
mode: (OFRunLoopMode)mode
# ifdef OF_HAVE_BLOCKS
block: (OFSCTPSocketAsyncSendDataBlock)block
handler: (OFSCTPSocketDataSentHandler)handler
# endif
delegate: (id <OFSCTPSocketDelegate>)delegate
{
NEW_WRITE(OFRunLoopSCTPSendQueueItem, sock, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
queueItem->_block = [block copy];
queueItem->_handler = [handler copy];
# endif
queueItem->_data = [data copy];
queueItem->_info = [info copy];
QUEUE_ITEM
}
# endif
|
︙ | | |
︙ | | |
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
111
|
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
111
112
113
114
115
116
117
118
119
120
121
|
-
+
+
+
+
-
+
+
-
+
+
+
-
+
-
-
+
+
+
-
+
+
+
+
-
-
+
+
|
extern const OFSCTPMessageInfoKey OFSCTPUnordered;
#ifdef __cplusplus
}
#endif
#ifdef OF_HAVE_BLOCKS
/**
* @brief A block which is called when the socket connected.
* @brief A handler which is called when the socket connected.
*
* @param socket The socket which connected
* @param host The host connected to
* @param port The port on the host connected to
* @param exception An exception which occurred while connecting the socket or
* `nil` on success
*/
typedef void (^OFSCTPSocketAsyncConnectBlock)(id _Nullable exception);
typedef void (^OFSCTPSocketConnectedHandler)(OFSCTPSocket *socket,
OFString *host, uint16_t port, id _Nullable exception);
/**
* @brief A block which is called when a message has been received.
* @brief A handler which is called when a message has been received.
*
* @param socket The SCTP socket which received a message
* @param buffer The buffer the message has been written to
* @param length The length of the message
* @param info Information about the message, see @ref OFSCTPMessageInfo
* @param exception An exception which occurred while receiving or `nil` on
* success
* @return A bool whether the same block should be used for the next receive
* @return A bool whether the same handler should be used for the next receive
*/
typedef bool (^OFSCTPSocketAsyncReceiveBlock)(size_t length,
OFSCTPMessageInfo info, id _Nullable exception);
typedef bool (^OFSCTPSocketMessageReceivedHandler)(OFSCTPSocket *socket,
void *buffer, size_t length, OFSCTPMessageInfo _Nullable info,
id _Nullable exception);
/**
* @brief A block which is called when a message has been sent.
* @brief A handler which is called when a message has been sent.
*
* @param socket The SCTP socket which sent a message
* @param data The data which was sent
* @param info Information about the message, see @ref OFSCTPMessageInfo
* @param exception An exception which occurred while reading or `nil` on
* success
* @return The data to repeat the send with or nil if it should not repeat
*/
typedef OFData *_Nullable (^OFSCTPSocketAsyncSendDataBlock)(
id _Nullable exception);
typedef OFData *_Nullable (^OFSCTPSocketDataSentHandler)(OFSCTPSocket *socket,
OFData *data, OFSCTPMessageInfo _Nullable info, id _Nullable exception);
#endif
/**
* @protocol OFSCTPSocketDelegate OFSCTPSocket.h ObjFW/ObjFW.h
*
* A delegate for OFSCTPSocket.
*/
|
︙ | | |
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
-
+
|
*
* @param socket The SCTP socket which received a message
* @param buffer The buffer the message has been written to
* @param length The length of the message
* @param info Information about the message, see @ref OFSCTPMessageInfo
* @param exception An exception that occurred while receiving, or nil on
* success
* @return A bool whether the same block should be used for the next receive
* @return A bool whether the same handler should be used for the next receive
*/
- (bool)socket: (OFSCTPSocket *)socket
didReceiveIntoBuffer: (void *)buffer
length: (size_t)length
info: (nullable OFSCTPMessageInfo)info
exception: (nullable id)exception;
|
︙ | | |
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
|
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
257
258
259
260
261
262
263
|
-
+
+
-
+
-
+
+
-
+
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Asynchronously connect the OFSCTPSocket to the specified destination.
*
* @param host The host to connect to
* @param port The port on the host to connect to
* @param block The block to execute once the connection has been established
* @param handler The handler to execute once the connection has been
* established
*/
- (void)asyncConnectToHost: (OFString *)host
port: (uint16_t)port
block: (OFSCTPSocketAsyncConnectBlock)block;
handler: (OFSCTPSocketConnectedHandler)handler;
/**
* @brief Asynchronously connect the OFSCTPSocket to the specified destination.
*
* @param host The host to connect to
* @param port The port on the host to connect to
* @param runLoopMode The run loop mode in which to perform the async connect
* @param block The block to execute once the connection has been established
* @param handler The handler to execute once the connection has been
* established
*/
- (void)asyncConnectToHost: (OFString *)host
port: (uint16_t)port
runLoopMode: (OFRunLoopMode)runLoopMode
block: (OFSCTPSocketAsyncConnectBlock)block;
handler: (OFSCTPSocketConnectedHandler)handler;
#endif
/**
* @brief Bind the socket to the specified host and port.
*
* @param host The host to bind to. Use `@"0.0.0.0"` for IPv4 or `@"::"` for
* IPv6 to bind to all.
|
︙ | | |
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
|
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
358
359
360
361
362
363
364
365
366
|
-
-
-
-
-
+
+
+
+
+
+
+
-
-
-
+
+
+
-
-
-
-
-
+
+
+
+
+
+
+
-
-
-
-
+
+
+
+
|
* @brief Asynchronously receives a message and stores it into the specified
* buffer.
*
* If the buffer is too small, the message is truncated.
*
* @param buffer The buffer to write the message to
* @param length The length of the buffer
* @param block The block to call when the message has been received. If the
* block returns true, it will be called again with the same
* buffer and maximum length when more messages have been received.
* If you want the next method in the queue to handle the message
* received next, you need to return false from the method.
* @param handler The handler to call when the message has been received. If the
* handler returns true, it will be called again with the same
* buffer and maximum length when more messages have been
* received. If you want the next method in the queue to handle
* the message received next, you need to return false from the
* method.
*/
- (void)
- (void)asyncReceiveWithInfoIntoBuffer: (void *)buffer
length: (size_t)length
block: (OFSCTPSocketAsyncReceiveBlock)block;
asyncReceiveWithInfoIntoBuffer: (void *)buffer
length: (size_t)length
handler: (OFSCTPSocketMessageReceivedHandler)handler;
/**
* @brief Asynchronously receives a message and stores it into the specified
* buffer.
*
* If the buffer is too small, the message is truncated.
*
* @param buffer The buffer to write the message to
* @param length The length of the buffer
* @param runLoopMode The run loop mode in which to perform the asynchronous
* receive
* @param block The block to call when the message has been received. If the
* block returns true, it will be called again with the same
* buffer and maximum length when more messages have been received.
* If you want the next method in the queue to handle the message
* received next, you need to return false from the method.
* @param handler The handler to call when the message has been received. If the
* handler returns true, it will be called again with the same
* buffer and maximum length when more messages have been
* received. If you want the next method in the queue to handle
* the message received next, you need to return false from the
* method.
*/
- (void)
- (void)asyncReceiveWithInfoIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (OFRunLoopMode)runLoopMode
block: (OFSCTPSocketAsyncReceiveBlock)block;
asyncReceiveWithInfoIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (OFRunLoopMode)runLoopMode
handler: (OFSCTPSocketMessageReceivedHandler)handler;
#endif
/**
* @brief Sends the specified message on the specified stream.
*
* @param buffer The buffer to send as a message
* @param length The length of the buffer
|
︙ | | |
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
|
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
|
-
-
-
+
+
+
-
+
-
-
-
+
+
+
-
+
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Asynchronously sends the specified message on the specified stream.
*
* @param data The data to send as a message
* @param info Information about the message, see @ref OFSCTPMessageInfo
* @param block The block to call when the message has been sent. It should
* return the data for the next send with the same callback or nil
* if it should not repeat.
* @param handler The handler to call when the message has been sent. It should
* return the data for the next send with the same callback or
* nil if it should not repeat.
*/
- (void)asyncSendData: (OFData *)data
info: (nullable OFSCTPMessageInfo)info
block: (OFSCTPSocketAsyncSendDataBlock)block;
handler: (OFSCTPSocketDataSentHandler)handler;
/**
* @brief Asynchronously sends the specified message on the specified stream.
*
* @param data The data to send as a message
* @param info Information about the message, see @ref OFSCTPMessageInfo
* @param runLoopMode The run loop mode in which to perform the asynchronous
* send
* @param block The block to call when the message has been sent. It should
* return the data for the next send with the same callback or nil
* if it should not repeat.
* @param handler The handler to call when the message has been sent. It should
* return the data for the next send with the same callback or
* nil if it should not repeat.
*/
- (void)asyncSendData: (OFData *)data
info: (nullable OFSCTPMessageInfo)info
runLoopMode: (OFRunLoopMode)runLoopMode
block: (OFSCTPSocketAsyncSendDataBlock)block;
handler: (OFSCTPSocketDataSentHandler)handler;
#endif
@end
OF_ASSUME_NONNULL_END
|
︙ | | |
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
|
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
|
-
+
-
+
-
+
-
+
-
+
|
@throw [OFAlreadyOpenException exceptionWithObject: self];
[[[[OFAsyncIPSocketConnector alloc]
initWithSocket: self
host: host
port: port
delegate: _delegate
block: NULL
handler: NULL
] autorelease] startWithRunLoopMode: runLoopMode];
objc_autoreleasePoolPop(pool);
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncConnectToHost: (OFString *)host
port: (uint16_t)port
block: (OFSCTPSocketAsyncConnectBlock)block
handler: (OFSCTPSocketConnectedHandler)handler
{
[self asyncConnectToHost: host
port: port
runLoopMode: OFDefaultRunLoopMode
block: block];
handler: handler];
}
- (void)asyncConnectToHost: (OFString *)host
port: (uint16_t)port
runLoopMode: (OFRunLoopMode)runLoopMode
block: (OFSCTPSocketAsyncConnectBlock)block
handler: (OFSCTPSocketConnectedHandler)handler
{
void *pool = objc_autoreleasePoolPush();
if (_socket != OFInvalidSocketHandle)
@throw [OFAlreadyOpenException exceptionWithObject: self];
[[[[OFAsyncIPSocketConnector alloc]
initWithSocket: self
host: host
port: port
delegate: nil
block: block] autorelease]
handler: handler] autorelease]
startWithRunLoopMode: runLoopMode];
objc_autoreleasePoolPop(pool);
}
#endif
- (OFSocketAddress)bindToHost: (OFString *)host port: (uint16_t)port
|
︙ | | |
430
431
432
433
434
435
436
437
438
439
440
441
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
|
430
431
432
433
434
435
436
437
438
439
440
441
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
|
-
+
+
-
-
-
+
+
+
-
+
-
+
-
+
|
runLoopMode: (OFRunLoopMode)runLoopMode
{
[OFRunLoop of_addAsyncReceiveForSCTPSocket: self
buffer: buffer
length: length
mode: runLoopMode
# ifdef OF_HAVE_BLOCKS
block: NULL
handler: NULL
# endif
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)
- (void)asyncReceiveWithInfoIntoBuffer: (void *)buffer
length: (size_t)length
block: (OFSCTPSocketAsyncReceiveBlock)block
asyncReceiveWithInfoIntoBuffer: (void *)buffer
length: (size_t)length
handler: (OFSCTPSocketMessageReceivedHandler)handler
{
[self asyncReceiveWithInfoIntoBuffer: buffer
length: length
runLoopMode: OFDefaultRunLoopMode
block: block];
handler: handler];
}
- (void)
asyncReceiveWithInfoIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (OFRunLoopMode)runLoopMode
block: (OFSCTPSocketAsyncReceiveBlock)block
handler: (OFSCTPSocketMessageReceivedHandler)handler
{
[OFRunLoop of_addAsyncReceiveForSCTPSocket: self
buffer: buffer
length: length
mode: runLoopMode
block: block
handler: handler
delegate: nil];
}
#endif
- (void)sendBuffer: (const void *)buffer length: (size_t)length
{
[self sendBuffer: buffer length: length info: nil];
|
︙ | | |
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
|
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
|
-
+
-
+
-
+
-
+
-
+
|
runLoopMode: (OFRunLoopMode)runLoopMode
{
[OFRunLoop of_addAsyncSendForSCTPSocket: self
data: data
info: info
mode: runLoopMode
# ifdef OF_HAVE_BLOCKS
block: NULL
handler: NULL
# endif
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncSendData: (OFData *)data
info: (OFSCTPMessageInfo)info
block: (OFSCTPSocketAsyncSendDataBlock)block
handler: (OFSCTPSocketDataSentHandler)handler
{
[self asyncSendData: data
info: info
runLoopMode: OFDefaultRunLoopMode
block: block];
handler: handler];
}
- (void)asyncSendData: (OFData *)data
info: (OFSCTPMessageInfo)info
runLoopMode: (OFRunLoopMode)runLoopMode
block: (OFSCTPSocketAsyncSendDataBlock)block
handler: (OFSCTPSocketDataSentHandler)handler
{
[OFRunLoop of_addAsyncSendForSCTPSocket: self
data: data
info: info
mode: runLoopMode
block: block
handler: handler
delegate: nil];
}
#endif
- (void)setCanDelaySendingMessages: (bool)canDelaySendingMessages
{
int v = !canDelaySendingMessages;
|
︙ | | |
︙ | | |
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
|
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
|
-
+
|
delegate = _delegate;
[[[[OFAsyncIPSocketConnector alloc]
initWithSocket: self
host: host
port: port
delegate: delegate
block: NULL
handler: NULL
] autorelease] startWithRunLoopMode: runLoopMode];
objc_autoreleasePoolPop(pool);
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncConnectToHost: (OFString *)host
|
︙ | | |
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
|
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
|
-
+
|
}
[[[[OFAsyncIPSocketConnector alloc]
initWithSocket: self
host: host
port: port
delegate: delegate
block: (delegate == nil ? block : NULL)] autorelease]
handler: (delegate == nil ? block : NULL)] autorelease]
startWithRunLoopMode: runLoopMode];
objc_autoreleasePoolPop(pool);
}
#endif
- (OFSocketAddress)bindToHost: (OFString *)host port: (uint16_t)port
|
︙ | | |