Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset fe4310f in mainline


Ignore:
Timestamp:
2012-02-12T22:40:15Z (8 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
2ff150e
Parents:
bd8bfc5a
Message:

Distinguish between datagram and packet. Deliver received datagrams to
clients based on protocol number.

Location:
uspace
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/nic/e1k/e1k.c

    rbd8bfc5a rfe4310f  
    23092309static void e1000_send_frame(nic_t *nic, void *data, size_t size)
    23102310{
     2311        printf("e1000_send_frame()\n");
    23112312        assert(nic);
    23122313       
  • uspace/srv/ethip/ethip_nic.c

    rbd8bfc5a rfe4310f  
    226226        free(data);
    227227
     228        log_msg(LVL_DEBUG, "ethip_nic_received() done, rc=%d", rc);
    228229        async_answer_0(callid, rc);
    229230}
     
    303304int ethip_nic_send(ethip_nic_t *nic, void *data, size_t size)
    304305{
     306        int rc;
    305307        log_msg(LVL_DEBUG, "ethip_nic_send(size=%zu)", size);
    306         return nic_send_frame(nic->sess, data, size);
     308        rc = nic_send_frame(nic->sess, data, size);
     309        log_msg(LVL_DEBUG, "nic_send_frame -> %d", rc);
     310        log_msg(LVL_DEBUG, "nic_send_frame -> %d", rc);
     311        log_msg(LVL_DEBUG, "nic_send_frame -> %d", rc);
     312        log_msg(LVL_DEBUG, "nic_send_frame -> %d", rc);
     313        log_msg(LVL_DEBUG, "nic_send_frame -> %d", rc);
     314        log_msg(LVL_DEBUG, "nic_send_frame -> %d", rc);
     315        log_msg(LVL_DEBUG, "nic_send_frame -> %d", rc);
     316        log_msg(LVL_DEBUG, "nic_send_frame -> %d", rc);
     317        return rc;
    307318}
    308319
  • uspace/srv/inet/inet.c

    rbd8bfc5a rfe4310f  
    262262}
    263263
     264static inet_client_t *inet_client_find(uint8_t proto)
     265{
     266        fibril_mutex_lock(&client_list_lock);
     267
     268        list_foreach(client_list, link) {
     269                inet_client_t *client = list_get_instance(link, inet_client_t,
     270                    client_list);
     271
     272                if (client->protocol == proto) {
     273                        fibril_mutex_unlock(&client_list_lock);
     274                        return client;
     275                }
     276        }
     277
     278        fibril_mutex_unlock(&client_list_lock);
     279        return NULL;
     280}
     281
    264282int inet_ev_recv(inet_client_t *client, inet_dgram_t *dgram)
    265283{
     
    285303}
    286304
    287 int inet_recv_packet(inet_dgram_t *dgram, uint8_t ttl, int df)
    288 {
    289         return inet_route_packet(dgram, ttl, df);
     305static int inet_recv_dgram_local(inet_dgram_t *dgram, uint8_t proto)
     306{
     307        inet_client_t *client;
     308
     309        log_msg(LVL_DEBUG, "inet_recv_dgram_local()");
     310
     311        client = inet_client_find(proto);
     312        if (client == NULL) {
     313                log_msg(LVL_DEBUG, "No client found for protocol 0x%" PRIx8,
     314                    proto);
     315                return ENOENT;
     316        }
     317
     318        return inet_ev_recv(client, dgram);
     319}
     320
     321int inet_recv_packet(inet_packet_t *packet)
     322{
     323        inet_addrobj_t *addr;
     324        inet_dgram_t dgram;
     325
     326        addr = inet_addrobj_find(&packet->dest, iaf_addr);
     327        if (addr != NULL) {
     328                /* Destined for one of the local addresses */
     329
     330                /* XXX Reassemble packets */
     331                dgram.src = packet->src;
     332                dgram.dest = packet->dest;
     333                dgram.tos = packet->tos;
     334                dgram.data = packet->data;
     335                dgram.size = packet->size;
     336
     337                return inet_recv_dgram_local(&dgram, packet->proto);
     338        }
     339
     340        return ENOENT;
    290341}
    291342
  • uspace/srv/inet/inet.h

    rbd8bfc5a rfe4310f  
    6868        inet_addr_t dest;
    6969        uint8_t tos;
     70        uint8_t proto;
     71        uint8_t ttl;
     72        int df;
     73        void *data;
     74        size_t size;
     75} inet_packet_t;
     76
     77typedef struct {
     78        inet_addr_t src;
     79        inet_addr_t dest;
     80        uint8_t tos;
    7081        void *data;
    7182        size_t size;
     
    8798
    8899extern int inet_ev_recv(inet_client_t *, inet_dgram_t *);
    89 extern int inet_recv_packet(inet_dgram_t *, uint8_t ttl, int df);
     100extern int inet_recv_packet(inet_packet_t *);
    90101
    91102#endif
  • uspace/srv/inet/inet_link.c

    rbd8bfc5a rfe4310f  
    6060static int inet_iplink_recv(iplink_t *iplink, iplink_sdu_t *sdu)
    6161{
    62         inet_dgram_t dgram;
    63         uint8_t ttl;
    64         int df;
     62        inet_packet_t packet;
    6563        int rc;
    6664
    6765        log_msg(LVL_DEBUG, "inet_iplink_recv()");
    68         rc = inet_pdu_decode(sdu->data, sdu->size, &dgram, &ttl, &df);
    69         if (rc != EOK)
     66        rc = inet_pdu_decode(sdu->data, sdu->size, &packet);
     67        if (rc != EOK) {
     68                log_msg(LVL_DEBUG, "failed decoding PDU");
    7069                return rc;
    71 
    72         return inet_recv_packet(&dgram, ttl, df);
     70        }
     71
     72        log_msg(LVL_DEBUG, "call inet_recv_packet()");
     73        rc = inet_recv_packet(&packet);
     74        log_msg(LVL_DEBUG, "call inet_recv_packet -> %d", rc);
     75
     76        return rc;
    7377}
    7478
     
    216220{
    217221        iplink_sdu_t sdu;
    218         int rc;
     222        inet_packet_t packet;
     223        int rc;
     224
     225        /* XXX Fragment packet */
     226        packet.src = dgram->src;
     227        packet.dest = dgram->dest;
     228        packet.tos = dgram->tos;
     229        packet.proto = 42;
     230        packet.ttl = ttl;
     231        packet.df = df;
     232        packet.data = dgram->data;
     233        packet.size = dgram->size;
    219234
    220235        sdu.lsrc.ipv4 = lsrc->ipv4;
    221236        sdu.ldest.ipv4 = ldest->ipv4;
    222         rc = inet_pdu_encode(dgram, ttl, df, &sdu.data, &sdu.size);
     237        rc = inet_pdu_encode(&packet, &sdu.data, &sdu.size);
    223238        if (rc != EOK)
    224239                return rc;
  • uspace/srv/inet/pdu.c

    rbd8bfc5a rfe4310f  
    4848
    4949/** Encode Internet PDU.
    50  *
    51  * XXX We should be encoding from packet, not from datagram.
    5250 */
    53 int inet_pdu_encode(inet_dgram_t *dgram, uint8_t ttl, int df, void **rdata,
    54     size_t *rsize)
     51int inet_pdu_encode(inet_packet_t *packet, void **rdata, size_t *rsize)
    5552{
    5653        void *data;
     
    6158
    6259        hdr_size = sizeof(ip_header_t);
    63         size = hdr_size + dgram->size;
     60        size = hdr_size + packet->size;
    6461        data_offs = ROUND_UP(hdr_size, 4);
    6562
     
    7067        hdr = (ip_header_t *)data;
    7168        hdr->ver_ihl = (4 << VI_VERSION_l) | (hdr_size / sizeof(uint32_t));
    72         hdr->tos = dgram->tos;
     69        hdr->tos = packet->tos;
    7370        hdr->tot_len = host2uint16_t_be(size);
    7471        hdr->id = host2uint16_t_be(42);
    75         hdr->flags_foff = host2uint16_t_be(df ? BIT_V(uint16_t, FF_FLAG_DF) : 0);
    76         hdr->ttl = ttl;
     72        hdr->flags_foff = host2uint16_t_be(packet->df ?
     73            BIT_V(uint16_t, FF_FLAG_DF) : 0);
     74        hdr->ttl = packet->ttl;
    7775        hdr->proto = 0;
    7876        hdr->chksum = 0;
    79         hdr->src_addr = host2uint32_t_be(dgram->src.ipv4);
    80         hdr->dest_addr = host2uint32_t_be(dgram->dest.ipv4);
     77        hdr->src_addr = host2uint32_t_be(packet->src.ipv4);
     78        hdr->dest_addr = host2uint32_t_be(packet->dest.ipv4);
    8179
    82         memcpy((uint8_t *)data + data_offs, dgram->data, dgram->size);
     80        memcpy((uint8_t *)data + data_offs, packet->data, packet->size);
    8381
    8482        *rdata = data;
     
    8785}
    8886
    89 int inet_pdu_decode(void *data, size_t size, inet_dgram_t *dgram, uint8_t *ttl,
    90     int *df)
     87int inet_pdu_decode(void *data, size_t size, inet_packet_t *packet)
    9188{
    9289        ip_header_t *hdr;
     
    131128        /* XXX Checksum */
    132129
    133         dgram->src.ipv4 = uint32_t_be2host(hdr->src_addr);
    134         dgram->dest.ipv4 = uint32_t_be2host(hdr->dest_addr);
    135         dgram->tos = hdr->tos;
    136         *ttl = hdr->ttl;
    137         *df = (uint16_t_be2host(hdr->tos) & BIT_V(uint16_t, FF_FLAG_DF)) ?
    138             1 : 0;
     130        packet->src.ipv4 = uint32_t_be2host(hdr->src_addr);
     131        packet->dest.ipv4 = uint32_t_be2host(hdr->dest_addr);
     132        packet->tos = hdr->tos;
     133        packet->ttl = hdr->ttl;
     134        packet->df = (uint16_t_be2host(hdr->tos) & BIT_V(uint16_t, FF_FLAG_DF))
     135            ? 1 : 0;
    139136
    140137        /* XXX IP options */
     
    142139            VI_IHL_l, hdr->ver_ihl);
    143140
    144         dgram->size = tot_len - data_offs;
    145         dgram->data = calloc(dgram->size, 1);
    146         if (dgram->data == NULL) {
     141        packet->size = tot_len - data_offs;
     142        packet->data = calloc(packet->size, 1);
     143        if (packet->data == NULL) {
    147144                log_msg(LVL_WARN, "Out of memory.");
    148145                return ENOMEM;
    149146        }
    150147
    151         memcpy(dgram->data, (uint8_t *)data + data_offs, dgram->size);
     148        memcpy(packet->data, (uint8_t *)data + data_offs, packet->size);
    152149
    153150        return EOK;
  • uspace/srv/inet/pdu.h

    rbd8bfc5a rfe4310f  
    4040#include "inet.h"
    4141
    42 extern int inet_pdu_encode(inet_dgram_t *, uint8_t, int, void **, size_t *);
    43 extern int inet_pdu_decode(void *, size_t, inet_dgram_t *, uint8_t *, int *);
     42extern int inet_pdu_encode(inet_packet_t *, void **, size_t *);
     43extern int inet_pdu_decode(void *, size_t, inet_packet_t *);
    4444
    4545#endif
Note: See TracChangeset for help on using the changeset viewer.