00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031 #include "nip_init.h"
00032 #include "dispatcher.h"
00033 #include "inet.h"
00034 #include "os_core.h"
00035 #include "nip_error.h"
00036 #include "net/net_if.h"
00037 #include "net/udp.h"
00038
00039
00040 #if (NIP_UDP_ENABLE == 1 )
00041
00042 #if (NIP_UDP_USE_FIXED_SOCKETS == 1)
00043
00044 static struct nip_udp_sock udp_sockets[ NIP_UDP_FIXED_SOCKETS ];
00045 #else
00046
00047
00048 static nip_udp_sock_cnt_t udp_socket_cnt;
00049 static nip_mem_handle_t udp_sockets;
00050 #endif // NIP_UDP_USE_FIXED_SOCKETS == 1
00051
00052
00053 static struct nip_udp_buffer udp_rx_queue[ NIP_UDP_PACKET_QUEUE_SIZE ];
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064 nip_udp_sock_id_t nip_udp_socket( struct nip_udp_sock_addr *addr, uint8_t flags )
00065 {
00066 nip_udp_sock_id_t id = 0;
00067 struct nip_udp_sock *sock = NULL;
00068
00069 #if (NIP_UDP_USE_FIXED_SOCKETS==1)
00070 do
00071 {
00072 if ( (udp_sockets[ id ].flags & NIP_UDP_SOCK_FLG_USED) == 0 )
00073 {
00074 sock = & udp_sockets[ id ];
00075 sock->sockid = id;
00076 sock->flags = flags | NIP_UDP_SOCK_FLG_USED;
00077 nip_memcpy( &sock->addr, addr, sizeof( struct nip_udp_sock_addr ) );
00078 sock->rx_packet = NIP_UDP_EOQ;
00079 sock->tx_packet = NIP_MEM_NULL;
00080 return id;
00081 }
00082 } while ( ++id < NIP_UDP_FIXED_SOCKETS );
00083
00084 #else
00085
00086 #endif // (NIP_UDP_USE_FIXED_SOCKETS==1)
00087
00088
00089 nip_error = NIP_E_OUT_OF_RESSOURCES;
00090 return NIP_UDP_NO_SOCKET;
00091
00092 }
00093
00094
00095 void nip_udp_close( nip_udp_sock_id_t id )
00096 {
00097 struct nip_udp_buffer *qbuf = udp_rx_queue;
00098
00099
00100 do
00101 {
00102 if ( qbuf->sockid == id )
00103 {
00104 nip_mem_free( qbuf->buf );
00105 qbuf->buf = NIP_MEM_NULL;
00106 }
00107 } while ( ++qbuf != &udp_rx_queue[NIP_UDP_EOQ] );
00108
00109 #if (NIP_UDP_USE_FIXED_SOCKETS==1)
00110 if ( id >= NIP_UDP_FIXED_SOCKETS ) return;
00111
00112 nip_mem_free( udp_sockets[id].tx_packet );
00113 udp_sockets[ id ].flags = 0;
00114 #else
00115
00116 #endif // (NIP_UDP_USE_FIXED_SOCKETS==1)
00117 }
00118
00119
00120
00121
00122 struct nip_udp_sock *nip_udp_sock_ptr ( nip_udp_sock_id_t sockid )
00123 {
00124 #if (NIP_UDP_USE_FIXED_SOCKETS==1)
00125 if ( sockid < NIP_UDP_FIXED_SOCKETS && udp_sockets[ sockid ].flags & NIP_UDP_SOCK_FLG_USED )
00126 return &udp_sockets[ sockid ];
00127 else
00128 {
00129 nip_error = NIP_E_INVALID_SOCK;
00130 return NULL;
00131 }
00132 #else
00133
00134 #endif // (NIP_UDP_USE_FIXED_SOCKETS==1)
00135 }
00136
00137
00138
00139 nip_mem_handle_t nip_udp_buf_handle( nip_udp_sock_id_t sockid, nip_udp_buf_type_t buftype )
00140 {
00141 struct nip_udp_sock *sock = nip_udp_sock_ptr( sockid );
00142 nip_mem_handle_t res = NIP_MEM_NULL;
00143
00144 if ( sock != NULL )
00145 {
00146 res = sock->tx_packet;
00147
00148 if ( buftype == NIP_UDP_RX_BUF )
00149 {
00150 if ( sock->rx_packet != NIP_UDP_EOQ )
00151 res = udp_rx_queue[ sock->rx_packet ].buf;
00152 else
00153 {
00154 nip_error = NIP_E_INVALID_BLOCK;
00155 }
00156 }
00157 }
00158 else
00159 nip_error = NIP_E_INVALID_SOCK;
00160
00161 return res;
00162 }
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172 void nip_udp_ptr_release( nip_udp_sock_id_t sockid, nip_udp_buf_type_t buftype )
00173 {
00174 nip_mem_handle_t bufhandle = nip_udp_buf_handle( sockid, buftype );
00175
00176 if ( bufhandle != NIP_MEM_NULL )
00177 nip_mem_release_block( bufhandle );
00178 }
00179
00180
00181
00182 void nip_udp_data_mem_ptr( nip_udp_sock_id_t sockid, nip_udp_buf_type_t buftype, nip_mem_ptr_t *res )
00183 {
00184 res->id = nip_udp_buf_handle( sockid, buftype );
00185 if ( res->id != NIP_MEM_NULL )
00186 res->ptr = (void*) sizeof( struct nip_udp_header );
00187 else
00188 res->ptr = NULL;
00189 }
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221 void *nip_udp_data_ptr( nip_udp_sock_id_t sockid, nip_udp_buf_type_t buftype )
00222 {
00223 nip_mem_ptr_t ptr;
00224
00225 nip_udp_data_mem_ptr( sockid, buftype, &ptr );
00226
00227 return nip_mem_ptr( &ptr );
00228 }
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252 nip_error_t nip_udp_init_send( nip_udp_sock_id_t sockid, nip_mem_size_t size )
00253 {
00254 struct nip_udp_sock *sock = nip_udp_sock_ptr( sockid );
00255
00256 if ( sock == NULL )
00257 {
00258 return NIP_E_INVALID_SOCK;
00259 }
00260
00261
00262 size += sizeof ( struct nip_udp_header );
00263 sock->tx_packet = nip_mem_alloc( size, size, NIP_MEM_FLG_DELREAD, NULL );
00264
00265 if ( sock->tx_packet == NIP_MEM_NULL )
00266 {
00267 return NIP_E_OUT_OF_MEMORY;
00268 }
00269
00270
00271
00272 nip_mem_write( sock->tx_packet, NULL, sizeof( struct nip_udp_header ) );
00273
00274 return NIP_E_OK;
00275 }
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286 void nip_udp_cancel_send( nip_udp_sock_id_t sockid )
00287 {
00288 struct nip_udp_sock *sock = nip_udp_sock_ptr( sockid );
00289
00290 nip_mem_free( sock->tx_packet );
00291 sock->tx_packet = NIP_MEM_NULL;
00292 }
00293
00294
00295
00296 nip_error_t nip_udp_write( nip_udp_sock_id_t sockid, uint8_t *buf, nip_mem_size_t size)
00297 {
00298 struct nip_udp_sock *sock = nip_udp_sock_ptr( sockid );
00299
00300
00301 return nip_mem_write( sock->tx_packet, buf, size );
00302 }
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322 nip_error_t nip_udp_transmit( nip_udp_sock_id_t sockid,struct nip_udp_sock_addr *dest_addr, nip_net_if_id_t if_id )
00323 {
00324 struct nip_udp_sock *sock = nip_udp_sock_ptr( sockid );
00325 struct nip_udp_header *head;
00326 nip_net_if_trans_t *trans;
00327
00328 if ( sock == NULL )
00329 return NIP_E_INVALID_SOCK;
00330
00331
00332 trans = nip_ip_route( dest_addr->ip, if_id, NULL );
00333 if ( trans == NULL )
00334 {
00335 return nip_error;
00336 }
00337
00338
00339
00340 trans->payload = sock->tx_packet;
00341 trans->payload_size = nip_mem_buf_used( sock->tx_packet );
00342 trans->flags.free_payload = 1;
00343 trans->flags.reset_status = 1;
00344 trans->params.ip.protocol = NIP_IP_PROTO_UDP;
00345
00346
00347 head = nip_mem_obtain_ptr( sock->tx_packet );
00348 head->src_port = sock->addr.port;
00349 head->dst_port = dest_addr->port;
00350 head->length = htons( trans->payload_size );
00351
00352
00353
00354
00355 head->checksum = 0;
00356
00357
00358 nip_mem_release_block( sock->tx_packet );
00359
00360
00361
00362 sock->tx_packet = NIP_MEM_NULL;
00363
00364
00365 trans->status = NIP_NET_IF_RESOLV_ADDR;
00366 nip_disp_notify( NIP_DISP_CHECK_TRANS );
00367 nip_dispatcher();
00368
00369
00370 return NIP_E_OK;
00371 }
00372
00373
00374
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394 nip_mem_size_t nip_udp_recvfrom( nip_udp_sock_id_t sockid, uint8_t *buf, nip_mem_size_t size, struct nip_udp_sock_addr *from_addr )
00395 {
00396 struct nip_udp_sock *sock;
00397 nip_mem_size_t res;
00398 struct nip_udp_buffer *qbuf;
00399
00400 do
00401 {
00402
00403
00404 sock = nip_udp_sock_ptr( sockid );
00405 if ( sock == NULL )
00406 {
00407 nip_error = NIP_E_INVALID_SOCK;
00408 return 0;
00409 }
00410
00411
00412 if ( sock->rx_packet == NIP_UDP_EOQ && (sock->flags & NIP_UDP_SOCK_FLG_NON_BLOCK) )
00413 {
00414 nip_error = NIP_E_AGAIN;
00415 return 0;
00416 }
00417
00418 } while ( sock->rx_packet == NIP_UDP_EOQ );
00419
00420 qbuf = &udp_rx_queue[ sock->rx_packet ];
00421
00422
00423 if ( from_addr != NULL )
00424 nip_memcpy( from_addr, &qbuf->addr, sizeof( struct nip_udp_sock_addr ) );
00425
00426
00427 size = nip_mem_read( qbuf->buf, buf, size );
00428
00429 res = qbuf->size;
00430 qbuf->size -= size;
00431
00432
00433 if ( res <= size )
00434 {
00435 nip_udp_cancel_recv( sockid );
00436 }
00437
00438 return res;
00439
00440 }
00441
00442
00443
00444
00445 void nip_udp_forward( nip_udp_sock_id_t sockid )
00446 {
00447 struct nip_udp_sock *sock = nip_udp_sock_ptr( sockid );
00448 struct nip_udp_buffer *qbuf;
00449
00450 if ( sock!= NULL && sock->rx_packet != NIP_UDP_EOQ )
00451 {
00452 qbuf = &udp_rx_queue[ sock->rx_packet ];
00453
00454 nip_mem_free( sock->tx_packet );
00455 sock->tx_packet = qbuf->buf;
00456 qbuf->buf = NIP_MEM_NULL;
00457 sock->rx_packet = qbuf->next;
00458 }
00459 }
00460
00461
00462 void nip_udp_cancel_recv( nip_udp_sock_id_t sockid )
00463 {
00464 struct nip_udp_sock *sock = nip_udp_sock_ptr( sockid );
00465 struct nip_udp_buffer *qbuf;
00466
00467 if ( sock->rx_packet != NIP_UDP_EOQ )
00468 {
00469 qbuf = &udp_rx_queue[ sock->rx_packet ];
00470
00471 sock->rx_packet = qbuf->next;
00472
00473 nip_mem_free( qbuf->buf );
00474 qbuf->buf = NIP_MEM_NULL;
00475 }
00476 }
00477
00478
00479 void nip_udp_disp_receive( void )
00480 {
00481 struct nip_udp_header *head;
00482 struct nip_udp_sock *sock;
00483 nip_net_if_trans_t *trans;
00484 nip_udp_sock_id_t sockid;
00485 uint8_t check_cnt;
00486 nip_udp_queue_id_t sock_qid;
00487 nip_udp_queue_id_t ins_qid;
00488 struct nip_udp_buffer *qbuf;
00489 uint16_t h_size;
00490
00491 trans = nip_disp.next.common.trans;
00492
00493 if ( trans->payload_size < sizeof( struct nip_udp_header) )
00494 goto discard;
00495
00496 head = nip_mem_obtain_ptr( trans->payload );
00497
00498 if ( head == NULL )
00499 {
00500
00501 goto discard;
00502 }
00503
00504
00505 #if (NIP_UDP_USE_FIXED_SOCKETS==1)
00506 sockid = 0;
00507 #if (NIP_UDP_FIXED_SOCKETS > 1 )
00508 do
00509 {
00510 #endif
00511 check_cnt = 0;
00512 sock = &udp_sockets[ sockid ];
00513
00514 if (((sock->flags & NIP_UDP_SOCK_FLG_USED) > 0)
00515 && ( sock->addr.port == head->dst_port )
00516 && ((nip_memcmp( sock->addr.ip, trans->params.ip.dst_nw_addr, 4 ) == 0 )
00517 ||(sock->addr.ip[0]==0 && sock->addr.ip[1]==0 && sock->addr.ip[2]==0 && sock->addr.ip[3]==0)
00518 #if NIP_MULTICAST_ENABLE == 1
00519 ||(trans->params.ip.dst_nw_addr[0] >= 0xE0)
00520 #endif
00521 ))
00522 {
00523 goto found;
00524 }
00525 #if (NIP_UDP_FIXED_SOCKETS > 1 )
00526 } while ( ++sockid < NIP_UDP_FIXED_SOCKETS );
00527 #endif
00528 #else
00529
00530 #endif // (NIP_UDP_USE_FIXED_SOCKETS==1)
00531 goto release;
00532
00533 found:
00534 h_size = ntohs(head->length);
00535
00536 if ( nip_mem_buf_used( trans->payload ) < h_size )
00537 {
00538 goto release;
00539 }
00540
00541
00542 ins_qid = 0;
00543 do
00544 {
00545 qbuf = &udp_rx_queue[ ins_qid ];
00546 if ( qbuf->buf == NIP_MEM_NULL )
00547 break;
00548 } while ( ++ins_qid < NIP_UDP_EOQ );
00549
00550
00551 if ( ins_qid == NIP_UDP_EOQ )
00552 goto release;
00553
00554
00555 sock_qid = sock->rx_packet;
00556 while ( sock_qid != NIP_UDP_EOQ )
00557 {
00558 if ( udp_rx_queue[ sock_qid ].next == NIP_UDP_EOQ ) break;
00559 sock_qid = udp_rx_queue[ sock_qid ].next;
00560 }
00561
00562
00563 qbuf->buf = trans->payload;
00564 qbuf->next = NIP_UDP_EOQ;
00565 qbuf->sockid = sockid;
00566 qbuf->size = h_size;
00567 qbuf->addr.port = head->src_port;
00568 nip_memcpy( qbuf->addr.ip, trans->params.ip.src_nw_addr, 4 );
00569
00570
00571 trans->flags.free_payload = 0;
00572
00573
00574
00575 if ( sock->rx_packet == NIP_UDP_EOQ )
00576 {
00577 sock->rx_packet = ins_qid;
00578 }
00579 else
00580 {
00581 udp_rx_queue[ sock_qid ].next = ins_qid;
00582 }
00583
00584
00585
00586 release:
00587 nip_mem_release_block( trans->payload );
00588
00589 discard:
00590 trans->status = NIP_NET_IF_DONE;
00591 nip_reset_trans( trans );
00592 return;
00593 }
00594
00595
00596 #endif // (NIP_UDP_ENABLE == 1 )