Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/tcp/conn.c

    r3e2291a9 rdc12262  
    4444#include <stdlib.h>
    4545#include "conn.h"
    46 #include "inet.h"
    4746#include "iqueue.h"
    48 #include "pdu.h"
    49 #include "rqueue.h"
    5047#include "segment.h"
    5148#include "seq_no.h"
    … …  
    6057#define TIME_WAIT_TIMEOUT       (2*MAX_SEGMENT_LIFETIME)
    6158
    62 /** List of all allocated connections */
    6359static LIST_INITIALIZE(conn_list);
    6460/** Taken after tcp_conn_t lock */
    6561static FIBRIL_MUTEX_INITIALIZE(conn_list_lock);
    66 /** Connection association map */
    6762static amap_t *amap;
    68 /** Taken after tcp_conn_t lock */
    69 static FIBRIL_MUTEX_INITIALIZE(amap_lock);
    70 
    71 /** Internal loopback configuration */
    72 tcp_lb_t tcp_conn_lb = tcp_lb_none;
    73 
    74 static void tcp_conn_seg_process(tcp_conn_t *, tcp_segment_t *);
    75 static void tcp_conn_tw_timer_set(tcp_conn_t *);
    76 static void tcp_conn_tw_timer_clear(tcp_conn_t *);
    77 static void tcp_transmit_segment(inet_ep2_t *, tcp_segment_t *);
    78 static void tcp_conn_trim_seg_to_wnd(tcp_conn_t *, tcp_segment_t *);
    79 static void tcp_reply_rst(inet_ep2_t *, tcp_segment_t *);
    80 
    81 static tcp_tqueue_cb_t tcp_conn_tqueue_cb = {
    82         .transmit_seg = tcp_transmit_segment
    83 };
     63
     64static void tcp_conn_seg_process(tcp_conn_t *conn, tcp_segment_t *seg);
     65static void tcp_conn_tw_timer_set(tcp_conn_t *conn);
     66static void tcp_conn_tw_timer_clear(tcp_conn_t *conn);
    8467
    8568/** Initialize connections. */
    … …  
    9578
    9679        return EOK;
    97 }
    98 
    99 /** Finalize connections. */
    100 void tcp_conns_fini(void)
    101 {
    102         assert(list_empty(&conn_list));
    103 
    104         amap_destroy(amap);
    105         amap = NULL;
    10680}
    10781
    … …  
    156130
    157131        /* Initialize retransmission queue */
    158         if (tcp_tqueue_init(&conn->retransmit, conn, &tcp_conn_tqueue_cb)
    159             != EOK) {
     132        if (tcp_tqueue_init(&conn->retransmit, conn) != EOK)
    160133                goto error;
    161         }
    162134
    163135        tqueue_inited = true;
    … …  
    175147        if (epp != NULL)
    176148                conn->ident = *epp;
    177 
    178         fibril_mutex_lock(&conn_list_lock);
    179         list_append(&conn->link, &conn_list);
    180         fibril_mutex_unlock(&conn_list_lock);
    181149
    182150        return conn;
    … …  
    213181{
    214182        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_free(%p)", conn->name, conn);
    215 
    216         assert(conn->mapped == false);
    217183        tcp_tqueue_fini(&conn->retransmit);
    218 
    219         fibril_mutex_lock(&conn_list_lock);
    220         list_remove(&conn->link);
    221         fibril_mutex_unlock(&conn_list_lock);
    222184
    223185        if (conn->rcv_buf != NULL)
    … …  
    309271
    310272        tcp_conn_addref(conn);
    311         fibril_mutex_lock(&amap_lock);
     273        fibril_mutex_lock(&conn_list_lock);
    312274
    313275        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_add: conn=%p", conn);
    … …  
    316278        if (rc != EOK) {
    317279                tcp_conn_delref(conn);
    318                 fibril_mutex_unlock(&amap_lock);
     280                fibril_mutex_unlock(&conn_list_lock);
    319281                return rc;
    320282        }
    321283
    322284        conn->ident = aepp;
    323         conn->mapped = true;
    324         fibril_mutex_unlock(&amap_lock);
     285        list_append(&conn->link, &conn_list);
     286        fibril_mutex_unlock(&conn_list_lock);
    325287
    326288        return EOK;
    … …  
    331293 * Remove connection from the connection map.
    332294 */
    333 static void tcp_conn_remove(tcp_conn_t *conn)
    334 {
    335         if (!conn->mapped)
    336                 return;
    337 
    338         fibril_mutex_lock(&amap_lock);
     295void tcp_conn_remove(tcp_conn_t *conn)
     296{
     297        fibril_mutex_lock(&conn_list_lock);
    339298        amap_remove(amap, &conn->ident);
    340         conn->mapped = false;
    341         fibril_mutex_unlock(&amap_lock);
     299        list_remove(&conn->link);
     300        fibril_mutex_unlock(&conn_list_lock);
    342301        tcp_conn_delref(conn);
    343302}
    … …  
    376335void tcp_conn_sync(tcp_conn_t *conn)
    377336{
    378         assert(fibril_mutex_is_locked(&conn->lock));
    379 
    380337        /* XXX select ISS */
    381338        conn->iss = 1;
    … …  
    431388        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_find_ref(%p)", epp);
    432389
    433         fibril_mutex_lock(&amap_lock);
     390        fibril_mutex_lock(&conn_list_lock);
    434391
    435392        rc = amap_find_match(amap, epp, &arg);
    436393        if (rc != EOK) {
    437394                assert(rc == ENOENT);
    438                 fibril_mutex_unlock(&amap_lock);
     395                fibril_mutex_unlock(&conn_list_lock);
    439396                return NULL;
    440397        }
    … …  
    443400        tcp_conn_addref(conn);
    444401
    445         fibril_mutex_unlock(&amap_lock);
     402        fibril_mutex_unlock(&conn_list_lock);
    446403        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_find_ref: got conn=%p",
    447404            conn);
    … …  
    455412void tcp_conn_reset(tcp_conn_t *conn)
    456413{
    457         assert(fibril_mutex_is_locked(&conn->lock));
    458 
    459414        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_reset()", conn->name);
    460 
    461         if (conn->cstate == st_closed)
    462                 return;
    463 
    464415        conn->reset = true;
    465416        tcp_conn_state_set(conn, st_closed);
    … …  
    914865                return cp_done;
    915866
    916         if (conn->fin_is_acked) {
    917                 log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN acked -> Time-Wait",
    918                     conn->name);
    919                 tcp_conn_state_set(conn, st_time_wait);
    920         }
    921 
     867        /* TODO */
    922868        return cp_continue;
    923869}
    … …  
    11161062                log_msg(LOG_DEFAULT, LVL_DEBUG, " - FIN found in segment.");
    11171063
     1064                /* Send ACK */
     1065                tcp_tqueue_ctrl_seg(conn, CTL_ACK);
     1066
    11181067                conn->rcv_nxt++;
    11191068                conn->rcv_wnd--;
    1120 
    1121                 /* Send ACK */
    1122                 tcp_tqueue_ctrl_seg(conn, CTL_ACK);
    11231069
    11241070                /* Change connection state */
    … …  
    12651211
    12661212                /* Need to remove and re-insert connection with new identity */
    1267                 fibril_mutex_lock(&amap_lock);
     1213                fibril_mutex_lock(&conn_list_lock);
    12681214
    12691215                if (inet_addr_is_any(&conn->ident.remote.addr))
    … …  
    12811227                        assert(rc == ENOMEM);
    12821228                        log_msg(LOG_DEFAULT, LVL_ERROR, "Out of memory.");
    1283                         fibril_mutex_unlock(&amap_lock);
     1229                        fibril_mutex_unlock(&conn_list_lock);
    12841230                        tcp_conn_unlock(conn);
    12851231                        return;
    … …  
    12871233
    12881234                amap_remove(amap, &oldepp);
    1289                 fibril_mutex_unlock(&amap_lock);
     1235                fibril_mutex_unlock(&conn_list_lock);
    12901236
    12911237                conn->name = (char *) "a";
    … …  
    13761322 * @param seg           Segment
    13771323 */
    1378 static void tcp_conn_trim_seg_to_wnd(tcp_conn_t *conn, tcp_segment_t *seg)
     1324void tcp_conn_trim_seg_to_wnd(tcp_conn_t *conn, tcp_segment_t *seg)
    13791325{
    13801326        uint32_t left, right;
    … …  
    14001346}
    14011347
    1402 /** Transmit segment over network.
    1403  *
    1404  * @param epp Endpoint pair with source and destination information
    1405  * @param seg Segment (ownership retained by caller)
    1406  */
    1407 static void tcp_transmit_segment(inet_ep2_t *epp, tcp_segment_t *seg)
    1408 {
    1409         tcp_pdu_t *pdu;
    1410         tcp_segment_t *dseg;
    1411         inet_ep2_t rident;
    1412 
    1413         log_msg(LOG_DEFAULT, LVL_DEBUG,
    1414             "tcp_transmit_segment(l:(%u),f:(%u), %p)",
    1415             epp->local.port, epp->remote.port, seg);
    1416 
    1417         log_msg(LOG_DEFAULT, LVL_DEBUG, "SEG.SEQ=%" PRIu32 ", SEG.WND=%" PRIu32,
    1418             seg->seq, seg->wnd);
    1419 
    1420         tcp_segment_dump(seg);
    1421 
    1422         if (tcp_conn_lb == tcp_lb_segment) {
    1423                 /* Loop back segment */
    1424 //              tcp_ncsim_bounce_seg(sp, seg);
    1425 
    1426                 /* Reverse the identification */
    1427                 tcp_ep2_flipped(epp, &rident);
    1428 
    1429                 /* Insert segment back into rqueue */
    1430                 dseg = tcp_segment_dup(seg);
    1431                 tcp_rqueue_insert_seg(&rident, dseg);
    1432                 return;
    1433         }
    1434 
    1435         if (tcp_pdu_encode(epp, seg, &pdu) != EOK) {
    1436                 log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped.");
    1437                 return;
    1438         }
    1439 
    1440         if (tcp_conn_lb == tcp_lb_pdu) {
    1441                 /* Loop back PDU */
    1442                 if (tcp_pdu_decode(pdu, &rident, &dseg) != EOK) {
    1443                         log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped.");
    1444                         tcp_pdu_delete(pdu);
    1445                         return;
    1446                 }
    1447 
    1448                 tcp_pdu_delete(pdu);
    1449 
    1450                 /* Insert decoded segment into rqueue */
    1451                 tcp_rqueue_insert_seg(&rident, dseg);
    1452                 return;
    1453         }
    1454 
    1455         tcp_transmit_pdu(pdu);
    1456         tcp_pdu_delete(pdu);
    1457 }
    1458 
    14591348/** Compute flipped endpoint pair for response.
    14601349 *
    … …  
    14751364 * @param seg           Incoming segment
    14761365 */
    1477 static void tcp_reply_rst(inet_ep2_t *epp, tcp_segment_t *seg)
     1366void tcp_reply_rst(inet_ep2_t *epp, tcp_segment_t *seg)
    14781367{
    14791368        tcp_segment_t *rseg;
Note: See TracChangeset for help on using the changeset viewer.