Rev 4747 | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4578 | mejdrech | 1 | /* |
2 | * Copyright (c) 2009 Lukas Mejdrech |
||
3 | * All rights reserved. |
||
4 | * |
||
5 | * Redistribution and use in source and binary forms, with or without |
||
6 | * modification, are permitted provided that the following conditions |
||
7 | * are met: |
||
8 | * |
||
9 | * - Redistributions of source code must retain the above copyright |
||
10 | * notice, this list of conditions and the following disclaimer. |
||
11 | * - Redistributions in binary form must reproduce the above copyright |
||
12 | * notice, this list of conditions and the following disclaimer in the |
||
13 | * documentation and/or other materials provided with the distribution. |
||
14 | * - The name of the author may not be used to endorse or promote products |
||
15 | * derived from this software without specific prior written permission. |
||
16 | * |
||
17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
||
18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
||
19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
||
20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
||
21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
||
22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||
23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||
24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||
25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
||
26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||
27 | */ |
||
28 | |||
29 | /** @addtogroup socket |
||
30 | * @{ |
||
31 | */ |
||
32 | |||
33 | /** @file |
||
34 | * Socket application program interface (API) implementation. |
||
35 | * @see socket.h for more information. |
||
36 | * This is a part of the network application library. |
||
37 | */ |
||
38 | |||
39 | #include <assert.h> |
||
40 | #include <async.h> |
||
4582 | mejdrech | 41 | #include <fibril_sync.h> |
4578 | mejdrech | 42 | |
43 | #include <ipc/services.h> |
||
44 | |||
45 | #include "../err.h" |
||
46 | #include "../modules.h" |
||
47 | |||
48 | #include "../include/in.h" |
||
49 | #include "../include/socket.h" |
||
50 | #include "../include/socket_errno.h" |
||
51 | |||
4589 | mejdrech | 52 | #include "../structures/dynamic_fifo.h" |
4578 | mejdrech | 53 | #include "../structures/int_map.h" |
54 | |||
55 | #include "socket_messages.h" |
||
56 | |||
4701 | mejdrech | 57 | /** Initial received packet queue size. |
58 | */ |
||
4589 | mejdrech | 59 | #define SOCKET_INITIAL_RECEIVED_SIZE 4 |
4701 | mejdrech | 60 | |
61 | /** Maximum received packet queue size. |
||
62 | */ |
||
4747 | mejdrech | 63 | #define SOCKET_MAX_RECEIVED_SIZE 0 |
4589 | mejdrech | 64 | |
4701 | mejdrech | 65 | /** Initial waiting sockets queue size. |
66 | */ |
||
4589 | mejdrech | 67 | #define SOCKET_INITIAL_ACCEPTED_SIZE 1 |
4701 | mejdrech | 68 | |
69 | /** Maximum waiting sockets queue size. |
||
70 | */ |
||
4747 | mejdrech | 71 | #define SOCKET_MAX_ACCEPTED_SIZE 0 |
4589 | mejdrech | 72 | |
4701 | mejdrech | 73 | /** Type definition of the socket specific data. |
74 | * @see socket |
||
75 | */ |
||
4578 | mejdrech | 76 | typedef struct socket socket_t; |
77 | |||
4701 | mejdrech | 78 | /** Type definition of the socket specific data pointer. |
79 | * @see socket |
||
80 | */ |
||
81 | typedef socket_t * socket_ref; |
||
82 | |||
83 | /** Socket specific data. |
||
4726 | mejdrech | 84 | * Each socket lock locks only its structure part and any number of them may be locked simultaneously. |
4701 | mejdrech | 85 | */ |
4578 | mejdrech | 86 | struct socket{ |
4701 | mejdrech | 87 | /** Socket identifier. |
88 | */ |
||
4578 | mejdrech | 89 | int socket_id; |
4701 | mejdrech | 90 | /** Parent module phone. |
91 | */ |
||
4578 | mejdrech | 92 | int phone; |
4701 | mejdrech | 93 | /** Parent module service. |
94 | */ |
||
4578 | mejdrech | 95 | services_t service; |
4701 | mejdrech | 96 | /** Underlying protocol header size. |
97 | * Sending and receiving optimalization. |
||
98 | */ |
||
4708 | mejdrech | 99 | size_t header_size; |
4701 | mejdrech | 100 | /** Packet data fragment size. |
4726 | mejdrech | 101 | * Sending optimalization. |
4701 | mejdrech | 102 | */ |
4708 | mejdrech | 103 | size_t data_fragment_size; |
4726 | mejdrech | 104 | /** Sending safety lock. |
105 | * Locks the header_size and data_fragment_size attributes. |
||
106 | */ |
||
107 | fibril_rwlock_t sending_lock; |
||
4701 | mejdrech | 108 | /** Received packets queue. |
109 | */ |
||
4589 | mejdrech | 110 | dyn_fifo_t received; |
4701 | mejdrech | 111 | /** Received packets safety lock. |
4726 | mejdrech | 112 | * Used for receiving and receive notifications. |
113 | * Locks the received attribute. |
||
4701 | mejdrech | 114 | */ |
4582 | mejdrech | 115 | fibril_mutex_t receive_lock; |
4701 | mejdrech | 116 | /** Received packets signaling. |
4726 | mejdrech | 117 | * Signaled upon receive notification. |
4701 | mejdrech | 118 | */ |
4582 | mejdrech | 119 | fibril_condvar_t receive_signal; |
4701 | mejdrech | 120 | /** Waiting sockets queue. |
121 | */ |
||
4589 | mejdrech | 122 | dyn_fifo_t accepted; |
4701 | mejdrech | 123 | /** Waiting sockets safety lock. |
4726 | mejdrech | 124 | * Used for accepting and accept notifications. |
125 | * Locks the accepted attribute. |
||
4701 | mejdrech | 126 | */ |
4582 | mejdrech | 127 | fibril_mutex_t accept_lock; |
4701 | mejdrech | 128 | /** Waiting sockets signaling. |
4726 | mejdrech | 129 | * Signaled upon accept notification. |
4701 | mejdrech | 130 | */ |
4582 | mejdrech | 131 | fibril_condvar_t accept_signal; |
4726 | mejdrech | 132 | /** The number of blocked functions called. |
133 | * Used while waiting for the received packets or accepted sockets. |
||
134 | */ |
||
135 | int blocked; |
||
4578 | mejdrech | 136 | }; |
137 | |||
4701 | mejdrech | 138 | /** Sockets map. |
139 | * Maps socket identifiers to the socket specific data. |
||
140 | * @see int_map.h |
||
141 | */ |
||
4578 | mejdrech | 142 | INT_MAP_DECLARE( sockets, socket_t ); |
143 | |||
4701 | mejdrech | 144 | /** Socket client library global data. |
145 | */ |
||
4726 | mejdrech | 146 | static struct socket_client_globals { |
4701 | mejdrech | 147 | /** TCP module phone. |
148 | */ |
||
4578 | mejdrech | 149 | int tcp_phone; |
4701 | mejdrech | 150 | /** UDP module phone. |
151 | */ |
||
4578 | mejdrech | 152 | int udp_phone; |
4701 | mejdrech | 153 | /** Active sockets. |
154 | */ |
||
4578 | mejdrech | 155 | sockets_ref sockets; |
4726 | mejdrech | 156 | /** Safety lock. |
157 | * Write lock is used only for adding or removing sockets. |
||
158 | * When locked for writing, no other socket locks need to be locked. |
||
159 | * When locked for reading, any other socket locks may be locked. |
||
160 | * No socket lock may be locked if this lock is unlocked. |
||
161 | */ |
||
162 | fibril_rwlock_t lock; |
||
163 | } socket_globals = { |
||
164 | .tcp_phone = -1, |
||
165 | .udp_phone = -1, |
||
166 | .sockets = NULL, |
||
167 | .lock = { |
||
168 | .readers = 0, |
||
169 | .writers = 0, |
||
170 | .waiters = { |
||
171 | .prev = & socket_globals.lock.waiters, |
||
172 | .next = & socket_globals.lock.waiters |
||
173 | } |
||
174 | } |
||
175 | }; |
||
4578 | mejdrech | 176 | |
177 | INT_MAP_IMPLEMENT( sockets, socket_t ); |
||
178 | |||
4701 | mejdrech | 179 | /** Returns the TCP module phone. |
180 | * Connects to the TCP module if necessary. |
||
181 | * @returns The TCP module phone. |
||
182 | */ |
||
4708 | mejdrech | 183 | static int socket_get_tcp_phone( void ); |
4701 | mejdrech | 184 | |
185 | /** Returns the UDP module phone. |
||
186 | * Connects to the UDP module if necessary. |
||
187 | * @returns The UDP module phone. |
||
188 | */ |
||
4708 | mejdrech | 189 | static int socket_get_udp_phone( void ); |
4701 | mejdrech | 190 | |
191 | /** Returns the active sockets. |
||
192 | * @returns The active sockets. |
||
193 | */ |
||
4708 | mejdrech | 194 | static sockets_ref socket_get_sockets( void ); |
4701 | mejdrech | 195 | |
196 | /** Default thread for new connections. |
||
4756 | mejdrech | 197 | * @param[in] iid The initial message identifier. |
198 | * @param[in] icall The initial message call structure. |
||
4701 | mejdrech | 199 | */ |
4578 | mejdrech | 200 | void socket_connection( ipc_callid_t iid, ipc_call_t * icall ); |
4701 | mejdrech | 201 | |
202 | /** Sends message to the socket parent module with specified data. |
||
4756 | mejdrech | 203 | * @param[in] socket_id Socket identifier. |
204 | * @param[in] message The action message. |
||
205 | * @param[in] arg2 The second message parameter. |
||
206 | * @param[in] data The data to be sent. |
||
207 | * @param[in] datalength The data length. |
||
4701 | mejdrech | 208 | * @returns EOK on success. |
209 | * @returns ENOTSOCK if the socket is not found. |
||
210 | * @returns EBADMEM if the data parameter is NULL. |
||
211 | * @returns NO_DATA if the datalength parameter is zero (0). |
||
212 | * @returns Other error codes as defined for the spcific message. |
||
213 | */ |
||
4708 | mejdrech | 214 | int socket_send_data( int socket_id, ipcarg_t message, ipcarg_t arg2, const void * data, size_t datalength ); |
4701 | mejdrech | 215 | |
216 | /** Initializes a new socket specific data. |
||
4756 | mejdrech | 217 | * @param[in,out] socket The socket to be initialized. |
218 | * @param[in] socket_id The new socket identifier. |
||
219 | * @param[in] phone The parent module phone. |
||
220 | * @param[in] service The parent module service. |
||
4701 | mejdrech | 221 | */ |
4578 | mejdrech | 222 | void socket_initialize( socket_ref socket, int socket_id, int phone, services_t service ); |
4701 | mejdrech | 223 | |
224 | /** Clears and destroys the socket. |
||
4756 | mejdrech | 225 | * @param[in] socket The socket to be destroyed. |
4701 | mejdrech | 226 | */ |
4589 | mejdrech | 227 | void socket_destroy( socket_ref socket ); |
4701 | mejdrech | 228 | |
229 | /** Receives data via the socket. |
||
4756 | mejdrech | 230 | * @param[in] message The action message. |
231 | * @param[in] socket_id Socket identifier. |
||
232 | * @param[out] data The data buffer to be filled. |
||
233 | * @param[in] datalength The data length. |
||
234 | * @param[in] flags Various receive flags. |
||
235 | * @param[out] fromaddr The source address. May be NULL for connected sockets. |
||
236 | * @param[in,out] addrlen The address length. The maximum address length is read. The actual address length is set. Used only if fromaddr is not NULL. |
||
4701 | mejdrech | 237 | * @returns EOK on success. |
238 | * @returns ENOTSOCK if the socket is not found. |
||
239 | * @returns EBADMEM if the data parameter is NULL. |
||
240 | * @returns NO_DATA if the datalength or addrlen parameter is zero (0). |
||
241 | * @returns Other error codes as defined for the spcific message. |
||
242 | */ |
||
4708 | mejdrech | 243 | int recvfrom_core( ipcarg_t message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen ); |
4701 | mejdrech | 244 | |
245 | /** Sends data via the socket to the remote address. |
||
246 | * Binds the socket to a free port if not already connected/bound. |
||
4756 | mejdrech | 247 | * @param[in] message The action message. |
248 | * @param[in] socket_id Socket identifier. |
||
249 | * @param[in] data The data to be sent. |
||
250 | * @param[in] datalength The data length. |
||
251 | * @param[in] flags Various send flags. |
||
252 | * @param[in] toaddr The destination address. May be NULL for connected sockets. |
||
253 | * @param[in] addrlen The address length. Used only if toaddr is not NULL. |
||
4701 | mejdrech | 254 | * @returns EOK on success. |
255 | * @returns ENOTSOCK if the socket is not found. |
||
256 | * @returns EBADMEM if the data or toaddr parameter is NULL. |
||
257 | * @returns NO_DATA if the datalength or the addrlen parameter is zero (0). |
||
258 | * @returns Other error codes as defined for the NET_SOCKET_SENDTO message. |
||
259 | */ |
||
4708 | mejdrech | 260 | int sendto_core( ipcarg_t message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen ); |
4578 | mejdrech | 261 | |
4708 | mejdrech | 262 | static int socket_get_tcp_phone( void ){ |
4578 | mejdrech | 263 | if( socket_globals.tcp_phone < 0 ){ |
264 | socket_globals.tcp_phone = bind_service( SERVICE_TCP, 0, 0, SERVICE_TCP, socket_connection ); |
||
265 | } |
||
266 | return socket_globals.tcp_phone; |
||
267 | } |
||
268 | |||
4708 | mejdrech | 269 | static int socket_get_udp_phone( void ){ |
4578 | mejdrech | 270 | if( socket_globals.udp_phone < 0 ){ |
271 | socket_globals.udp_phone = bind_service( SERVICE_UDP, 0, 0, SERVICE_UDP, socket_connection ); |
||
272 | } |
||
273 | return socket_globals.udp_phone; |
||
274 | } |
||
275 | |||
4708 | mejdrech | 276 | static sockets_ref socket_get_sockets( void ){ |
4578 | mejdrech | 277 | if( ! socket_globals.sockets ){ |
278 | socket_globals.sockets = ( sockets_ref ) malloc( sizeof( sockets_t )); |
||
279 | if( ! socket_globals.sockets ) return NULL; |
||
280 | if( sockets_initialize( socket_globals.sockets ) != EOK ){ |
||
281 | free( socket_globals.sockets ); |
||
282 | socket_globals.sockets = NULL; |
||
283 | } |
||
284 | } |
||
285 | return socket_globals.sockets; |
||
286 | } |
||
287 | |||
288 | void socket_initialize( socket_ref socket, int socket_id, int phone, services_t service ){ |
||
289 | socket->socket_id = socket_id; |
||
290 | socket->phone = phone; |
||
291 | socket->service = service; |
||
4589 | mejdrech | 292 | dyn_fifo_initialize( & socket->received, SOCKET_INITIAL_RECEIVED_SIZE ); |
293 | dyn_fifo_initialize( & socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE ); |
||
4582 | mejdrech | 294 | fibril_mutex_initialize( & socket->receive_lock ); |
295 | fibril_condvar_initialize( & socket->receive_signal ); |
||
296 | fibril_mutex_initialize( & socket->accept_lock ); |
||
297 | fibril_condvar_initialize( & socket->accept_signal ); |
||
4726 | mejdrech | 298 | fibril_rwlock_initialize( & socket->sending_lock ); |
4578 | mejdrech | 299 | } |
300 | |||
301 | void socket_connection( ipc_callid_t iid, ipc_call_t * icall ){ |
||
302 | ERROR_DECLARE; |
||
303 | |||
304 | ipc_callid_t callid; |
||
305 | ipc_call_t call; |
||
306 | socket_ref socket; |
||
307 | socket_ref new_socket; |
||
308 | |||
309 | while( true ){ |
||
310 | |||
311 | callid = async_get_call( & call ); |
||
312 | switch( IPC_GET_METHOD( call )){ |
||
313 | case NET_SOCKET_RECEIVED: |
||
4726 | mejdrech | 314 | fibril_rwlock_read_lock( & socket_globals.lock ); |
4589 | mejdrech | 315 | // find the socket |
4701 | mejdrech | 316 | socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call )); |
4578 | mejdrech | 317 | if( ! socket ){ |
318 | ERROR_CODE = ENOTSOCK; |
||
4726 | mejdrech | 319 | }else{ |
320 | fibril_mutex_lock( & socket->receive_lock ); |
||
321 | // push the number of received packet fragments |
||
322 | if( ! ERROR_OCCURRED( dyn_fifo_push( & socket->received, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_MAX_RECEIVED_SIZE ))){ |
||
323 | // signal the received packet |
||
324 | fibril_condvar_signal( & socket->receive_signal ); |
||
325 | } |
||
326 | fibril_mutex_unlock( & socket->receive_lock ); |
||
4578 | mejdrech | 327 | } |
4726 | mejdrech | 328 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
4578 | mejdrech | 329 | break; |
330 | case NET_SOCKET_ACCEPTED: |
||
4726 | mejdrech | 331 | fibril_rwlock_read_lock( & socket_globals.lock ); |
4589 | mejdrech | 332 | // find the socket |
4701 | mejdrech | 333 | socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call )); |
4578 | mejdrech | 334 | if( ! socket ){ |
335 | ERROR_CODE = ENOTSOCK; |
||
4589 | mejdrech | 336 | }else{ |
4726 | mejdrech | 337 | // create a new scoket |
338 | new_socket = ( socket_ref ) malloc( sizeof( socket_t )); |
||
339 | if( ! new_socket ){ |
||
340 | ERROR_CODE = ENOMEM; |
||
4589 | mejdrech | 341 | }else{ |
4743 | mejdrech | 342 | bzero( new_socket, sizeof( * new_socket )); |
343 | socket_initialize( new_socket, SOCKET_GET_NEW_SOCKET_ID( call ), socket->phone, socket->service ); |
||
4726 | mejdrech | 344 | ERROR_CODE = sockets_add( socket_get_sockets(), new_socket->socket_id, new_socket ); |
345 | if( ERROR_CODE < 0 ){ |
||
346 | free( new_socket ); |
||
347 | }else{ |
||
348 | // push the new socket identifier |
||
349 | fibril_mutex_lock( & socket->accept_lock ); |
||
350 | if( ERROR_OCCURRED( dyn_fifo_push( & socket->accepted, new_socket->socket_id, SOCKET_MAX_ACCEPTED_SIZE ))){ |
||
351 | sockets_exclude( socket_get_sockets(), new_socket->socket_id ); |
||
352 | }else{ |
||
353 | // signal the accepted socket |
||
354 | fibril_condvar_signal( & socket->accept_signal ); |
||
355 | } |
||
356 | fibril_mutex_unlock( & socket->accept_lock ); |
||
357 | ERROR_CODE = EOK; |
||
358 | } |
||
4589 | mejdrech | 359 | } |
4578 | mejdrech | 360 | } |
4726 | mejdrech | 361 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
4578 | mejdrech | 362 | break; |
4589 | mejdrech | 363 | case NET_SOCKET_DATA_FRAGMENT_SIZE: |
4726 | mejdrech | 364 | fibril_rwlock_read_lock( & socket_globals.lock ); |
4589 | mejdrech | 365 | // find the socket |
4701 | mejdrech | 366 | socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call )); |
4578 | mejdrech | 367 | if( ! socket ){ |
368 | ERROR_CODE = ENOTSOCK; |
||
4726 | mejdrech | 369 | }else{ |
370 | fibril_rwlock_write_lock( & socket->sending_lock ); |
||
371 | // set the data fragment size |
||
372 | socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE( call ); |
||
373 | fibril_rwlock_write_unlock( & socket->sending_lock ); |
||
374 | ERROR_CODE = EOK; |
||
4578 | mejdrech | 375 | } |
4726 | mejdrech | 376 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
4578 | mejdrech | 377 | break; |
4589 | mejdrech | 378 | default: |
4578 | mejdrech | 379 | ERROR_CODE = ENOTSUP; |
380 | } |
||
4708 | mejdrech | 381 | ipc_answer_0( callid, ( ipcarg_t ) ERROR_CODE ); |
4578 | mejdrech | 382 | } |
383 | } |
||
384 | |||
385 | int socket( int domain, int type, int protocol ){ |
||
4589 | mejdrech | 386 | ERROR_DECLARE; |
387 | |||
4578 | mejdrech | 388 | socket_ref socket; |
389 | int phone; |
||
390 | int socket_id; |
||
391 | services_t service; |
||
392 | |||
4589 | mejdrech | 393 | // find the appropriate service |
4578 | mejdrech | 394 | switch( domain ){ |
395 | case PF_INET: |
||
396 | switch( type ){ |
||
397 | case SOCK_STREAM: |
||
398 | if( ! protocol ) protocol = IPPROTO_TCP; |
||
399 | switch( protocol ){ |
||
400 | case IPPROTO_TCP: |
||
401 | phone = socket_get_tcp_phone(); |
||
402 | service = SERVICE_TCP; |
||
403 | break; |
||
404 | default: |
||
405 | return EPROTONOSUPPORT; |
||
406 | } |
||
407 | break; |
||
408 | case SOCK_DGRAM: |
||
409 | if( ! protocol ) protocol = IPPROTO_UDP; |
||
410 | switch( protocol ){ |
||
411 | case IPPROTO_UDP: |
||
412 | phone = socket_get_udp_phone(); |
||
413 | service = SERVICE_UDP; |
||
414 | break; |
||
415 | default: |
||
416 | return EPROTONOSUPPORT; |
||
417 | } |
||
418 | break; |
||
419 | case SOCK_RAW: |
||
420 | default: |
||
421 | return ESOCKTNOSUPPORT; |
||
422 | } |
||
423 | break; |
||
424 | // TODO IPv6 |
||
425 | default: |
||
426 | return EPFNOSUPPORT; |
||
427 | } |
||
4589 | mejdrech | 428 | // create a new socket structure |
4578 | mejdrech | 429 | socket = ( socket_ref ) malloc( sizeof( socket_t )); |
430 | if( ! socket ) return ENOMEM; |
||
4736 | mejdrech | 431 | bzero( socket, sizeof( * socket )); |
4589 | mejdrech | 432 | // request a new socket |
4726 | mejdrech | 433 | if( ERROR_OCCURRED(( int ) async_req_3_3( phone, NET_SOCKET, 0, 0, service, ( ipcarg_t * ) & socket_id, ( ipcarg_t * ) & socket->data_fragment_size, ( ipcarg_t * ) & socket->header_size ))){ |
4589 | mejdrech | 434 | free( socket ); |
435 | return ERROR_CODE; |
||
436 | } |
||
437 | // finish the new socket initialization |
||
438 | socket_initialize( socket, socket_id, phone, service ); |
||
439 | // store the new socket |
||
4726 | mejdrech | 440 | fibril_rwlock_write_lock( & socket_globals.lock ); |
4589 | mejdrech | 441 | ERROR_CODE = sockets_add( socket_get_sockets(), socket_id, socket ); |
4726 | mejdrech | 442 | fibril_rwlock_write_unlock( & socket_globals.lock ); |
4589 | mejdrech | 443 | if( ERROR_CODE < 0 ){ |
444 | dyn_fifo_destroy( & socket->received ); |
||
445 | dyn_fifo_destroy( & socket->accepted ); |
||
446 | free( socket ); |
||
4708 | mejdrech | 447 | async_msg_3( phone, NET_SOCKET_CLOSE, ( ipcarg_t ) socket_id, 0, service ); |
4589 | mejdrech | 448 | return ERROR_CODE; |
449 | } |
||
450 | |||
4578 | mejdrech | 451 | return socket_id; |
452 | } |
||
453 | |||
4708 | mejdrech | 454 | int socket_send_data( int socket_id, ipcarg_t message, ipcarg_t arg2, const void * data, size_t datalength ){ |
4578 | mejdrech | 455 | socket_ref socket; |
456 | aid_t message_id; |
||
457 | ipcarg_t result; |
||
458 | |||
459 | if( ! data ) return EBADMEM; |
||
460 | if( ! datalength ) return NO_DATA; |
||
4726 | mejdrech | 461 | |
462 | fibril_rwlock_read_lock( & socket_globals.lock ); |
||
4589 | mejdrech | 463 | // find the socket |
4578 | mejdrech | 464 | socket = sockets_find( socket_get_sockets(), socket_id ); |
4726 | mejdrech | 465 | if( ! socket ){ |
466 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
||
467 | return ENOTSOCK; |
||
468 | } |
||
4589 | mejdrech | 469 | // request the message |
4708 | mejdrech | 470 | message_id = async_send_3( socket->phone, message, ( ipcarg_t ) socket->socket_id, arg2, socket->service, NULL ); |
4589 | mejdrech | 471 | // send the address |
4578 | mejdrech | 472 | ipc_data_write_start( socket->phone, data, datalength ); |
4726 | mejdrech | 473 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
4578 | mejdrech | 474 | async_wait_for( message_id, & result ); |
475 | return ( int ) result; |
||
476 | } |
||
477 | |||
478 | int bind( int socket_id, const struct sockaddr * my_addr, socklen_t addrlen ){ |
||
4708 | mejdrech | 479 | if( addrlen <= 0 ) return EINVAL; |
4589 | mejdrech | 480 | // send the address |
4708 | mejdrech | 481 | return socket_send_data( socket_id, NET_SOCKET_BIND, 0, my_addr, ( size_t ) addrlen ); |
4578 | mejdrech | 482 | } |
483 | |||
484 | int listen( int socket_id, int backlog ){ |
||
4726 | mejdrech | 485 | socket_ref socket; |
486 | int result; |
||
4578 | mejdrech | 487 | |
488 | if( backlog <= 0 ) return EINVAL; |
||
4726 | mejdrech | 489 | fibril_rwlock_read_lock( & socket_globals.lock ); |
4589 | mejdrech | 490 | // find the socket |
4578 | mejdrech | 491 | socket = sockets_find( socket_get_sockets(), socket_id ); |
4726 | mejdrech | 492 | if( ! socket ){ |
493 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
||
494 | return ENOTSOCK; |
||
495 | } |
||
4589 | mejdrech | 496 | // request listen backlog change |
4726 | mejdrech | 497 | result = ( int ) async_req_3_0( socket->phone, NET_SOCKET_LISTEN, ( ipcarg_t ) socket->socket_id, ( ipcarg_t ) backlog, socket->service ); |
498 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
||
499 | return result; |
||
4578 | mejdrech | 500 | } |
501 | |||
502 | int accept( int socket_id, struct sockaddr * cliaddr, socklen_t * addrlen ){ |
||
503 | socket_ref socket; |
||
504 | aid_t message_id; |
||
4589 | mejdrech | 505 | int result; |
4743 | mejdrech | 506 | ipc_call_t answer; |
4578 | mejdrech | 507 | |
4701 | mejdrech | 508 | if(( ! cliaddr ) || ( ! addrlen )) return EBADMEM; |
4726 | mejdrech | 509 | |
510 | fibril_rwlock_read_lock( & socket_globals.lock ); |
||
4589 | mejdrech | 511 | // find the socket |
4578 | mejdrech | 512 | socket = sockets_find( socket_get_sockets(), socket_id ); |
4726 | mejdrech | 513 | if( ! socket ){ |
514 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
||
515 | return ENOTSOCK; |
||
516 | } |
||
4582 | mejdrech | 517 | fibril_mutex_lock( & socket->accept_lock ); |
4589 | mejdrech | 518 | // wait for an accepted socket |
4726 | mejdrech | 519 | ++ socket->blocked; |
4589 | mejdrech | 520 | while( dyn_fifo_value( & socket->accepted ) <= 0 ){ |
4726 | mejdrech | 521 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
4582 | mejdrech | 522 | fibril_condvar_wait( & socket->accept_signal, & socket->accept_lock ); |
4726 | mejdrech | 523 | fibril_rwlock_read_lock( & socket_globals.lock ); |
4578 | mejdrech | 524 | } |
4726 | mejdrech | 525 | -- socket->blocked; |
4589 | mejdrech | 526 | // request accept |
4743 | mejdrech | 527 | message_id = async_send_3( socket->phone, NET_SOCKET_ACCEPT, ( ipcarg_t ) socket->socket_id, 0, socket->service, & answer ); |
4589 | mejdrech | 528 | // read address |
4578 | mejdrech | 529 | ipc_data_read_start( socket->phone, cliaddr, * addrlen ); |
4726 | mejdrech | 530 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
4589 | mejdrech | 531 | async_wait_for( message_id, ( ipcarg_t * ) & result ); |
4578 | mejdrech | 532 | if( result > 0 ){ |
4743 | mejdrech | 533 | // dequeue the accepted socket if successful |
4589 | mejdrech | 534 | dyn_fifo_pop( & socket->accepted ); |
4743 | mejdrech | 535 | // set address length |
536 | * addrlen = SOCKET_GET_ADDRESS_LENGTH( answer ); |
||
537 | }else if( result == ENOTSOCK ){ |
||
538 | // empty the queue if no accepted sockets |
||
539 | while( dyn_fifo_pop( & socket->accepted ) > 0 ); |
||
4578 | mejdrech | 540 | } |
4582 | mejdrech | 541 | fibril_mutex_unlock( & socket->accept_lock ); |
4589 | mejdrech | 542 | return result; |
4578 | mejdrech | 543 | } |
544 | |||
545 | int connect( int socket_id, const struct sockaddr * serv_addr, socklen_t addrlen ){ |
||
4736 | mejdrech | 546 | if( ! serv_addr ) return EDESTADDRREQ; |
547 | if( ! addrlen ) return EDESTADDRREQ; |
||
4589 | mejdrech | 548 | // send the address |
4578 | mejdrech | 549 | return socket_send_data( socket_id, NET_SOCKET_CONNECT, 0, serv_addr, addrlen ); |
550 | } |
||
551 | |||
552 | int closesocket( int socket_id ){ |
||
4589 | mejdrech | 553 | ERROR_DECLARE; |
554 | |||
4578 | mejdrech | 555 | socket_ref socket; |
556 | |||
4729 | mejdrech | 557 | fibril_rwlock_write_lock( & socket_globals.lock ); |
4578 | mejdrech | 558 | socket = sockets_find( socket_get_sockets(), socket_id ); |
4726 | mejdrech | 559 | if( ! socket ){ |
560 | fibril_rwlock_write_unlock( & socket_globals.lock ); |
||
561 | return ENOTSOCK; |
||
562 | } |
||
563 | if( socket->blocked ){ |
||
564 | fibril_rwlock_write_unlock( & socket_globals.lock ); |
||
565 | return EINPROGRESS; |
||
566 | } |
||
4589 | mejdrech | 567 | // request close |
4708 | mejdrech | 568 | ERROR_PROPAGATE(( int ) async_req_3_0( socket->phone, NET_SOCKET_CLOSE, ( ipcarg_t ) socket->socket_id, 0, socket->service )); |
4589 | mejdrech | 569 | // free the socket structure |
570 | socket_destroy( socket ); |
||
4726 | mejdrech | 571 | fibril_rwlock_write_unlock( & socket_globals.lock ); |
4589 | mejdrech | 572 | return EOK; |
4578 | mejdrech | 573 | } |
574 | |||
4589 | mejdrech | 575 | void socket_destroy( socket_ref socket ){ |
576 | int accepted_id; |
||
577 | |||
578 | // destroy all accepted sockets |
||
4701 | mejdrech | 579 | while(( accepted_id = dyn_fifo_pop( & socket->accepted )) >= 0 ){ |
4589 | mejdrech | 580 | socket_destroy( sockets_find( socket_get_sockets(), accepted_id )); |
581 | } |
||
582 | dyn_fifo_destroy( & socket->received ); |
||
583 | dyn_fifo_destroy( & socket->accepted ); |
||
584 | sockets_exclude( socket_get_sockets(), socket->socket_id ); |
||
585 | } |
||
586 | |||
4578 | mejdrech | 587 | int send( int socket_id, void * data, size_t datalength, int flags ){ |
4589 | mejdrech | 588 | // without the address |
589 | return sendto_core( NET_SOCKET_SEND, socket_id, data, datalength, flags, NULL, 0 ); |
||
4578 | mejdrech | 590 | } |
591 | |||
592 | int sendto( int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen ){ |
||
4736 | mejdrech | 593 | if( ! toaddr ) return EDESTADDRREQ; |
594 | if( ! addrlen ) return EDESTADDRREQ; |
||
4589 | mejdrech | 595 | // with the address |
596 | return sendto_core( NET_SOCKET_SENDTO, socket_id, data, datalength, flags, toaddr, addrlen ); |
||
4578 | mejdrech | 597 | } |
598 | |||
4708 | mejdrech | 599 | int sendto_core( ipcarg_t message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen ){ |
4578 | mejdrech | 600 | socket_ref socket; |
601 | aid_t message_id; |
||
602 | ipcarg_t result; |
||
4708 | mejdrech | 603 | size_t fragments; |
4578 | mejdrech | 604 | |
605 | if( ! data ) return EBADMEM; |
||
606 | if( ! datalength ) return NO_DATA; |
||
4726 | mejdrech | 607 | fibril_rwlock_read_lock( & socket_globals.lock ); |
4589 | mejdrech | 608 | // find socket |
4578 | mejdrech | 609 | socket = sockets_find( socket_get_sockets(), socket_id ); |
4726 | mejdrech | 610 | if( ! socket ){ |
611 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
||
612 | return ENOTSOCK; |
||
613 | } |
||
614 | fibril_rwlock_read_lock( & socket->sending_lock ); |
||
4589 | mejdrech | 615 | // compute data fragment count |
616 | fragments = ( datalength + socket->header_size ) / socket->data_fragment_size; |
||
617 | if(( datalength + socket->header_size ) % socket->data_fragment_size ) ++ fragments; |
||
618 | // request send |
||
4726 | mejdrech | 619 | message_id = async_send_5( socket->phone, message, ( ipcarg_t ) socket->socket_id, socket->data_fragment_size, socket->service, ( ipcarg_t ) flags, fragments, NULL ); |
4589 | mejdrech | 620 | // send the address if given |
621 | if(( ! toaddr ) || ( ipc_data_write_start( socket->phone, toaddr, addrlen ) == EOK )){ |
||
622 | if( fragments == 1 ){ |
||
623 | // send all if only one fragment |
||
624 | ipc_data_write_start( socket->phone, data, datalength ); |
||
625 | }else{ |
||
626 | // send the first fragment |
||
627 | ipc_data_write_start( socket->phone, data, socket->data_fragment_size - socket->header_size ); |
||
4708 | mejdrech | 628 | data = (( const uint8_t * ) data ) + socket->data_fragment_size - socket->header_size; |
4589 | mejdrech | 629 | // send the middle fragments |
630 | while(( -- fragments ) > 1 ){ |
||
631 | ipc_data_write_start( socket->phone, data, socket->data_fragment_size ); |
||
4708 | mejdrech | 632 | data = (( const uint8_t * ) data ) + socket->data_fragment_size; |
4589 | mejdrech | 633 | } |
634 | // send the last fragment |
||
635 | ipc_data_write_start( socket->phone, data, ( datalength + socket->header_size ) % socket->data_fragment_size ); |
||
636 | } |
||
4578 | mejdrech | 637 | } |
4726 | mejdrech | 638 | fibril_rwlock_read_unlock( & socket->sending_lock ); |
639 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
||
4578 | mejdrech | 640 | async_wait_for( message_id, & result ); |
641 | return ( int ) result; |
||
642 | } |
||
643 | |||
4589 | mejdrech | 644 | int recv( int socket_id, void * data, size_t datalength, int flags ){ |
645 | // without the address |
||
646 | return recvfrom_core( NET_SOCKET_RECV, socket_id, data, datalength, flags, NULL, NULL ); |
||
647 | } |
||
648 | |||
4578 | mejdrech | 649 | int recvfrom( int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen ){ |
4589 | mejdrech | 650 | if( ! fromaddr ) return EBADMEM; |
651 | if( ! addrlen ) return NO_DATA; |
||
652 | // with the address |
||
653 | return recvfrom_core( NET_SOCKET_RECVFROM, socket_id, data, datalength, flags, fromaddr, addrlen ); |
||
654 | } |
||
655 | |||
4708 | mejdrech | 656 | int recvfrom_core( ipcarg_t message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen ){ |
4578 | mejdrech | 657 | socket_ref socket; |
658 | aid_t message_id; |
||
4589 | mejdrech | 659 | int result; |
4708 | mejdrech | 660 | size_t fragments; |
661 | size_t * lengths; |
||
662 | size_t index; |
||
4589 | mejdrech | 663 | ipc_call_t answer; |
4578 | mejdrech | 664 | |
665 | if( ! data ) return EBADMEM; |
||
666 | if( ! datalength ) return NO_DATA; |
||
4701 | mejdrech | 667 | if( fromaddr && ( ! addrlen )) return EINVAL; |
4726 | mejdrech | 668 | fibril_rwlock_read_lock( & socket_globals.lock ); |
4589 | mejdrech | 669 | // find the socket |
4578 | mejdrech | 670 | socket = sockets_find( socket_get_sockets(), socket_id ); |
4726 | mejdrech | 671 | if( ! socket ){ |
672 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
||
673 | return ENOTSOCK; |
||
674 | } |
||
4582 | mejdrech | 675 | fibril_mutex_lock( & socket->receive_lock ); |
4589 | mejdrech | 676 | // wait for a received packet |
4726 | mejdrech | 677 | ++ socket->blocked; |
4708 | mejdrech | 678 | while(( result = dyn_fifo_value( & socket->received )) <= 0 ){ |
4726 | mejdrech | 679 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
4582 | mejdrech | 680 | fibril_condvar_wait( & socket->receive_signal, & socket->receive_lock ); |
4726 | mejdrech | 681 | fibril_rwlock_read_lock( & socket_globals.lock ); |
4578 | mejdrech | 682 | } |
4726 | mejdrech | 683 | -- socket->blocked; |
4708 | mejdrech | 684 | fragments = ( size_t ) result; |
4589 | mejdrech | 685 | // prepare lengths if more fragments |
686 | if( fragments > 1 ){ |
||
4708 | mejdrech | 687 | lengths = ( size_t * ) malloc( sizeof( size_t ) * fragments + sizeof( size_t )); |
4589 | mejdrech | 688 | if( ! lengths ){ |
689 | fibril_mutex_unlock( & socket->receive_lock ); |
||
4726 | mejdrech | 690 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
4589 | mejdrech | 691 | return ENOMEM; |
692 | } |
||
4708 | mejdrech | 693 | // request packet data |
694 | message_id = async_send_4( socket->phone, message, ( ipcarg_t ) socket->socket_id, 0, socket->service, ( ipcarg_t ) flags, & answer ); |
||
695 | // read the address if desired |
||
696 | if(( ! fromaddr ) || ( ipc_data_read_start( socket->phone, fromaddr, * addrlen ) == EOK )){ |
||
4589 | mejdrech | 697 | // read the fragment lengths |
698 | if( ipc_data_read_start( socket->phone, lengths, sizeof( int ) * ( fragments + 1 )) == EOK ){ |
||
699 | if( lengths[ fragments ] <= datalength ){ |
||
4708 | mejdrech | 700 | // read all fragments if long enough |
4589 | mejdrech | 701 | for( index = 0; index < fragments; ++ index ){ |
702 | ipc_data_read_start( socket->phone, data, lengths[ index ] ); |
||
4708 | mejdrech | 703 | data = (( uint8_t * ) data ) + lengths[ index ]; |
4589 | mejdrech | 704 | } |
705 | } |
||
706 | } |
||
707 | } |
||
708 | free( lengths ); |
||
4708 | mejdrech | 709 | }else{ |
710 | // request packet data |
||
711 | message_id = async_send_4( socket->phone, message, ( ipcarg_t ) socket->socket_id, 0, socket->service, ( ipcarg_t ) flags, & answer ); |
||
712 | // read the address if desired |
||
713 | if(( ! fromaddr ) || ( ipc_data_read_start( socket->phone, fromaddr, * addrlen ) == EOK )){ |
||
714 | // read all if only one fragment |
||
715 | ipc_data_read_start( socket->phone, data, datalength ); |
||
716 | } |
||
4589 | mejdrech | 717 | } |
718 | async_wait_for( message_id, ( ipcarg_t * ) & result ); |
||
719 | // if successful |
||
720 | if( result == EOK ){ |
||
721 | // dequeue the received packet |
||
722 | dyn_fifo_pop( & socket->received ); |
||
723 | // return read data length |
||
4701 | mejdrech | 724 | result = SOCKET_GET_READ_DATA_LENGTH( answer ); |
4603 | mejdrech | 725 | // set address length |
4701 | mejdrech | 726 | if( fromaddr && addrlen ) * addrlen = SOCKET_GET_ADDRESS_LENGTH( answer ); |
4589 | mejdrech | 727 | } |
4582 | mejdrech | 728 | fibril_mutex_unlock( & socket->receive_lock ); |
4726 | mejdrech | 729 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
4589 | mejdrech | 730 | return result; |
4578 | mejdrech | 731 | } |
732 | |||
733 | int getsockopt( int socket_id, int level, int optname, void * value, size_t * optlen ){ |
||
734 | socket_ref socket; |
||
735 | aid_t message_id; |
||
736 | ipcarg_t result; |
||
737 | |||
4589 | mejdrech | 738 | if( !( value && optlen )) return EBADMEM; |
739 | if( !( * optlen )) return NO_DATA; |
||
4726 | mejdrech | 740 | fibril_rwlock_read_lock( & socket_globals.lock ); |
4589 | mejdrech | 741 | // find the socket |
4578 | mejdrech | 742 | socket = sockets_find( socket_get_sockets(), socket_id ); |
4726 | mejdrech | 743 | if( ! socket ){ |
744 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
||
745 | return ENOTSOCK; |
||
746 | } |
||
4589 | mejdrech | 747 | // request option value |
4708 | mejdrech | 748 | message_id = async_send_3( socket->phone, NET_SOCKET_GETSOCKOPT, ( ipcarg_t ) socket->socket_id, ( ipcarg_t ) optname, socket->service, NULL ); |
4589 | mejdrech | 749 | // read the length |
750 | if( ipc_data_read_start( socket->phone, optlen, sizeof( * optlen )) == EOK ){ |
||
751 | // read the value |
||
752 | ipc_data_read_start( socket->phone, value, * optlen ); |
||
753 | } |
||
4726 | mejdrech | 754 | fibril_rwlock_read_unlock( & socket_globals.lock ); |
4578 | mejdrech | 755 | async_wait_for( message_id, & result ); |
756 | return ( int ) result; |
||
757 | } |
||
758 | |||
759 | int setsockopt( int socket_id, int level, int optname, const void * value, size_t optlen ){ |
||
4589 | mejdrech | 760 | // send the value |
4708 | mejdrech | 761 | return socket_send_data( socket_id, NET_SOCKET_SETSOCKOPT, ( ipcarg_t ) optname, value, optlen ); |
4589 | mejdrech | 762 | |
4578 | mejdrech | 763 | } |
764 | |||
765 | /** @} |
||
766 | */ |