Changeset 03c971f in mainline for uspace/srv


Ignore:
Timestamp:
2013-08-15T14:20:16Z (12 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
bb2a5b2
Parents:
f2c19b0 (diff), 2921602 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Mainline changes.

Location:
uspace/srv
Files:
9 added
61 edited
2 moved

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/mfs/mfs_balloc.c

    rf2c19b0 r03c971f  
    128128                start_block = 2 + sbi->ibmap_blocks;
    129129                if (idx > sbi->nzones) {
    130                         printf(NAME ": Error! Trying to free beyond the" \
     130                        printf(NAME ": Error! Trying to free beyond the "
    131131                            "bitmap max size\n");
    132132                        return -1;
    … …  
    137137                start_block = 2;
    138138                if (idx > sbi->ninodes) {
    139                         printf(NAME ": Error! Trying to free beyond the" \
     139                        printf(NAME ": Error! Trying to free beyond the "
    140140                            "bitmap max size\n");
    141141                        return -1;
    … …  
    202202                start_block = 2;
    203203                nblocks = sbi->ibmap_blocks;
    204                 limit = sbi->ninodes;
     204                limit = sbi->ninodes - 1;
    205205        }
    206206        bits_per_block = sbi->block_size * 8;

  • uspace/srv/fs/mfs/mfs_dentry.c

    rf2c19b0 r03c971f  
    3636 *
    3737 * @param mnode         Pointer to the directory node.
    38  * @param d_info        Pointer to a directory entry structure where the dentry info
    39  *                      will be stored.
     38 * @param d_info        Pointer to a directory entry structure where
     39 *                      the dentry info will be stored.
    4040 * @param index         index of the dentry in the list.
    4141 *
    … …  
    101101/**Write a directory entry on disk.
    102102 *
    103  * @param d_info Pointer to the directory entry structure to write on disk.
     103 * @param d_info The directory entry to write to disk.
    104104 *
    105105 * @return       EOK on success or a negative error code.
    … …  
    240240                                goto out;
    241241                        r = mfs_write_map(mnode, pos, b, &dummy);
    242                         if (r != EOK)
     242                        if (r != EOK) {
     243                                mfs_free_zone(mnode->instance, b);
    243244                                goto out;
     245                        }
    244246                }
    245247

  • uspace/srv/fs/mfs/mfs_ops.c

    rf2c19b0 r03c971f  
    8888
    8989/* Hash table interface for open nodes hash table */
    90 
    9190typedef struct {
    9291        service_id_t service_id;
    … …  
    190189                /* This is a V1 or V2 Minix filesystem */
    191190                magic = sb->s_magic;
    192         } else if (check_magic_number(sb3->s_magic, &native, &version, &longnames)) {
     191        } else if (check_magic_number(sb3->s_magic, &native,
     192            &version, &longnames)) {
    193193                /* This is a V3 Minix filesystem */
    194194                magic = sb3->s_magic;
    … …  
    345345        uint32_t inum;
    346346
    347         mfsdebug("%s()\n", __FUNCTION__);
    348 
    349347        r = mfs_instance_get(service_id, &inst);
    350348        if (r != EOK)
    … …  
    379377                ino_i->i_mode = S_IFDIR;
    380378                ino_i->i_nlinks = 1; /* This accounts for the '.' dentry */
    381         } else
     379        } else {
    382380                ino_i->i_mode = S_IFREG;
     381                ino_i->i_nlinks = 0;
     382        }
    383383
    384384        ino_i->i_uid = 0;
    … …  
    419419        free(ino_i);
    420420out_err:
     421        mfs_free_inode(inst, inum);
    421422        return r;
    422423}
    … …  
    429430        struct mfs_dentry_info d_info;
    430431        int r;
    431 
    432         mfsdebug("%s()\n", __FUNCTION__);
    433432
    434433        if (!S_ISDIR(ino_i->i_mode))
    … …  
    478477        struct mfs_instance *instance;
    479478
    480         mfsdebug("%s()\n", __FUNCTION__);
    481 
    482479        rc = mfs_instance_get(service_id, &instance);
    483480        if (rc != EOK)
    … …  
    492489        int rc = EOK;
    493490        struct mfs_node *mnode = fsnode->data;
    494 
    495         mfsdebug("%s()\n", __FUNCTION__);
    496491
    497492        fibril_mutex_lock(&open_nodes_lock);
    … …  
    554549        int rc;
    555550
    556         mfsdebug("%s()\n", __FUNCTION__);
    557 
    558551        fibril_mutex_lock(&open_nodes_lock);
    559552
    … …  
    568561        if (already_open) {
    569562                mnode = hash_table_get_inst(already_open, struct mfs_node, link);
     563
    570564                *rfn = mnode->fsnode;
    571565                mnode->refcnt++;
    … …  
    649643        bool destroy_dentry = false;
    650644
    651         mfsdebug("%s()\n", __FUNCTION__);
    652 
    653645        if (str_size(name) > sbi->max_name_len)
    654646                return ENAMETOOLONG;
    … …  
    673665                r = mfs_insert_dentry(child, "..", parent->ino_i->index);
    674666                if (r != EOK) {
     667                        mfs_remove_dentry(child, ".");
    675668                        destroy_dentry = true;
    676669                        goto exit;
    … …  
    700693        bool has_children;
    701694        int r;
    702 
    703         mfsdebug("%s()\n", __FUNCTION__);
    704695
    705696        if (!parent)
    … …  
    924915               
    925916                r = mfs_write_map(mnode, pos, block, &dummy);
    926                 if (r != EOK)
     917                if (r != EOK) {
     918                        mfs_free_zone(mnode->instance, block);
    927919                        goto out_err;
     920                }
    928921
    929922                flags = BLOCK_FLAGS_NOREAD;
    … …  
    965958mfs_destroy(service_id_t service_id, fs_index_t index)
    966959{
    967         fs_node_t *fn;
     960        fs_node_t *fn = NULL;
    968961        int r;
    969962

  • uspace/srv/hid/input/port/adb.c

    rf2c19b0 r03c971f  
    118118                ipc_callid_t callid = async_get_call(&call);
    119119
    120                 int retval;
     120                int retval = EOK;
    121121               
    122122                if (!IPC_GET_IMETHOD(call)) {

  • uspace/srv/hid/input/port/adb_mouse.c

    rf2c19b0 r03c971f  
    5454                ipc_callid_t callid = async_get_call(&call);
    5555               
    56                 int retval;
     56                int retval = EOK;
    5757               
    5858                if (!IPC_GET_IMETHOD(call)) {

  • uspace/srv/hid/input/port/chardev.c

    rf2c19b0 r03c971f  
    148148                }
    149149
    150                 int retval;
     150                int retval = EOK;
    151151
    152152                switch (IPC_GET_IMETHOD(call)) {

  • uspace/srv/hid/isdv4_tablet/isdv4.h

    rf2c19b0 r03c971f  
    7676} isdv4_source_type_t;
    7777
    78 typedef struct isdv4_event {
     78struct isdv4_event {
    7979        isdv4_event_type_t type;
    8080        isdv4_source_type_t source;
    … …  
    8383        unsigned int pressure;
    8484        unsigned int button;
    85 } isdv4_event_t;
     85};
    8686
    8787extern int isdv4_init(isdv4_state_t *, async_sess_t *, isdv4_event_fn);

  • uspace/srv/net/dnsrsrv/dns_msg.c

    rf2c19b0 r03c971f  
    296296uint32_t dns_uint32_t_decode(uint8_t *buf, size_t buf_size)
    297297{
    298         uint32_t w;
    299298        assert(buf_size >= 4);
    300 
    301         w = ((uint32_t)buf[0] << 24) +
    302             ((uint32_t)buf[1] << 16) +
    303             ((uint32_t)buf[2] << 8) +
     299       
     300        uint32_t w = ((uint32_t) buf[0] << 24) +
     301            ((uint32_t) buf[1] << 16) +
     302            ((uint32_t) buf[2] << 8) +
    304303            buf[3];
    305 
     304       
    306305        return w;
     306}
     307
     308/** Decode unaligned big-endian 128-bit integer */
     309void dns_addr128_t_decode(uint8_t *buf, size_t buf_size, addr128_t addr)
     310{
     311        assert(buf_size >= 16);
     312       
     313        addr128_t_be2host(buf, addr);
    307314}
    308315
    … …  
    400407        int rc;
    401408
    402         rr = calloc(1, sizeof (dns_rr_t));
     409        rr = calloc(1, sizeof(dns_rr_t));
    403410        if (rr == NULL)
    404411                return ENOMEM;
    … …  
    427434
    428435        rr->rtype = dns_uint16_t_decode(bp, bsz);
    429         bp += sizeof(uint16_t); bsz -= sizeof(uint16_t);
     436        bp += sizeof(uint16_t);
     437        bsz -= sizeof(uint16_t);
    430438
    431439        rr->rclass = dns_uint16_t_decode(bp, bsz);
    432         bp += sizeof(uint16_t); bsz -= sizeof(uint16_t);
     440        bp += sizeof(uint16_t);
     441        bsz -= sizeof(uint16_t);
    433442
    434443        rr->ttl = dns_uint32_t_decode(bp, bsz);
    435         bp += sizeof(uint32_t); bsz -= sizeof(uint32_t);
     444        bp += sizeof(uint32_t);
     445        bsz -= sizeof(uint32_t);
    436446
    437447        rdlength = dns_uint16_t_decode(bp, bsz);
    438         bp += sizeof(uint16_t); bsz -= sizeof(uint16_t);
     448        bp += sizeof(uint16_t);
     449        bsz -= sizeof(uint16_t);
    439450
    440451        if (rdlength > bsz) {

  • uspace/srv/net/dnsrsrv/dns_msg.h

    rf2c19b0 r03c971f  
    4040#include <stdbool.h>
    4141#include <stdint.h>
     42#include <inet/addr.h>
    4243#include "dns_std.h"
    4344#include "dns_type.h"
    … …  
    4950extern int dns_name_decode(dns_pdu_t *, size_t, char **, size_t *);
    5051extern uint32_t dns_uint32_t_decode(uint8_t *, size_t);
     52extern void dns_addr128_t_decode(uint8_t *, size_t, addr128_t);
    5153
    5254#endif

  • uspace/srv/net/dnsrsrv/dns_std.h

    rf2c19b0 r03c971f  
    6565        DTYPE_MX        = 15,
    6666        DTYPE_TXT       = 16,
     67        DTYPE_AAAA      = 28,
    6768        DQTYPE_AXFR     = 252,
    6869        DQTYPE_MAILB    = 253,

  • uspace/srv/net/dnsrsrv/dns_type.h

    rf2c19b0 r03c971f  
    3939#include <adt/list.h>
    4040#include <inet/inet.h>
     41#include <inet/addr.h>
    4142#include <stdbool.h>
    4243#include <stdint.h>

  • uspace/srv/net/dnsrsrv/dnsrsrv.c

    rf2c19b0 r03c971f  
    8484}
    8585
    86 static void dnsr_name2host_srv(dnsr_client_t *client, ipc_callid_t callid,
    87     ipc_call_t *call)
    88 {
     86static void dnsr_name2host_srv(dnsr_client_t *client, ipc_callid_t iid,
     87    ipc_call_t *icall)
     88{
     89        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
     90       
     91        uint16_t af = IPC_GET_ARG1(*icall);
     92       
    8993        char *name;
     94        int rc = async_data_write_accept((void **) &name, true, 0,
     95            DNS_NAME_MAX_SIZE, 0, NULL);
     96        if (rc != EOK) {
     97                async_answer_0(iid, rc);
     98                return;
     99        }
     100       
    90101        dns_host_info_t *hinfo;
    91         ipc_callid_t rcallid;
     102        rc = dns_name2host(name, &hinfo, af);
     103        if (rc != EOK) {
     104                async_answer_0(iid, rc);
     105                return;
     106        }
     107       
     108        ipc_callid_t callid;
    92109        size_t size;
    93         sysarg_t retval;
    94         size_t act_size;
    95         int rc;
    96 
     110        if (!async_data_read_receive(&callid, &size)) {
     111                async_answer_0(callid, EREFUSED);
     112                async_answer_0(iid, EREFUSED);
     113                return;
     114        }
     115       
     116        if (size != sizeof(inet_addr_t)) {
     117                async_answer_0(callid, EINVAL);
     118                async_answer_0(iid, EINVAL);
     119                return;
     120        }
     121       
     122        rc = async_data_read_finalize(callid, &hinfo->addr, size);
     123        if (rc != EOK) {
     124                async_answer_0(callid, rc);
     125                async_answer_0(iid, rc);
     126                return;
     127        }
     128       
     129        if (!async_data_read_receive(&callid, &size)) {
     130                async_answer_0(callid, EREFUSED);
     131                async_answer_0(iid, EREFUSED);
     132                return;
     133        }
     134       
     135        size_t act_size = str_size(hinfo->cname);
     136        if (act_size > size) {
     137                async_answer_0(callid, EINVAL);
     138                async_answer_0(iid, EINVAL);
     139                return;
     140        }
     141       
     142        rc = async_data_read_finalize(callid, hinfo->cname, act_size);
     143        if (rc != EOK)
     144                async_answer_0(callid, rc);
     145       
     146        async_answer_0(iid, (sysarg_t) rc);
     147       
     148        dns_hostinfo_destroy(hinfo);
     149}
     150
     151static void dnsr_get_srvaddr_srv(dnsr_client_t *client, ipc_callid_t iid,
     152    ipc_call_t *icall)
     153{
    97154        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    98 
    99         rc = async_data_write_accept((void **) &name, true, 0,
    100             DNS_NAME_MAX_SIZE, 0, NULL);
    101         if (rc != EOK) {
    102                 async_answer_0(callid, rc);
    103                 return;
    104         }
    105 
    106         if (!async_data_read_receive(&rcallid, &size)) {
    107                 async_answer_0(rcallid, EREFUSED);
    108                 async_answer_0(callid, EREFUSED);
    109                 return;
    110         }
    111 
    112         rc = dns_name2host(name, &hinfo);
    113         if (rc != EOK) {
    114                 async_answer_0(rcallid, rc);
    115                 async_answer_0(callid, rc);
    116                 return;
    117         }
    118 
    119         act_size = str_size(hinfo->cname);
    120         if (act_size > size) {
    121                 async_answer_0(rcallid, EOVERFLOW);
    122                 async_answer_0(callid, EOVERFLOW);
    123                 return;
    124         }
    125 
    126         retval = async_data_read_finalize(rcallid, hinfo->cname, act_size);
    127         async_answer_1(callid, retval, hinfo->addr.ipv4);
    128 
    129         dns_hostinfo_destroy(hinfo);
    130 }
    131 
    132 static void dnsr_get_srvaddr_srv(dnsr_client_t *client, ipc_callid_t callid,
    133     ipc_call_t *call)
    134 {
    135         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    136         async_answer_1(callid, EOK, dns_server_addr.ipv4);
    137 }
    138 
    139 static void dnsr_set_srvaddr_srv(dnsr_client_t *client, ipc_callid_t callid,
    140     ipc_call_t *call)
     155       
     156        ipc_callid_t callid;
     157        size_t size;
     158        if (!async_data_read_receive(&callid, &size)) {
     159                async_answer_0(callid, EREFUSED);
     160                async_answer_0(iid, EREFUSED);
     161                return;
     162        }
     163       
     164        if (size != sizeof(inet_addr_t)) {
     165                async_answer_0(callid, EINVAL);
     166                async_answer_0(iid, EINVAL);
     167                return;
     168        }
     169       
     170        // FIXME locking
     171       
     172        int rc = async_data_read_finalize(callid, &dns_server_addr, size);
     173        if (rc != EOK)
     174                async_answer_0(callid, rc);
     175       
     176        async_answer_0(iid, rc);
     177}
     178
     179static void dnsr_set_srvaddr_srv(dnsr_client_t *client, ipc_callid_t iid,
     180    ipc_call_t *icall)
    141181{
    142182        log_msg(LOG_DEFAULT, LVL_DEBUG, "dnsr_set_srvaddr_srv()");
    143 
    144         dns_server_addr.ipv4 = IPC_GET_ARG1(*call);
    145 
    146         async_answer_0(callid, EOK);
     183       
     184        ipc_callid_t callid;
     185        size_t size;
     186        if (!async_data_write_receive(&callid, &size)) {
     187                async_answer_0(callid, EREFUSED);
     188                async_answer_0(iid, EREFUSED);
     189                return;
     190        }
     191       
     192        if (size != sizeof(inet_addr_t)) {
     193                async_answer_0(callid, EINVAL);
     194                async_answer_0(iid, EINVAL);
     195                return;
     196        }
     197       
     198        // FIXME locking
     199       
     200        int rc = async_data_write_finalize(callid, &dns_server_addr, size);
     201        if (rc != EOK) {
     202                async_answer_0(callid, rc);
     203                async_answer_0(iid, rc);
     204        }
     205       
     206        async_answer_0(iid, (sysarg_t) rc);
    147207}
    148208

  • uspace/srv/net/dnsrsrv/query.c

    rf2c19b0 r03c971f  
    3939#include <stdlib.h>
    4040#include <str.h>
    41 
     41#include <net/socket_codes.h>
    4242#include "dns_msg.h"
    4343#include "dns_std.h"
    … …  
    4848static uint16_t msg_id;
    4949
    50 int dns_name2host(const char *name, dns_host_info_t **rinfo)
     50static int dns_name_query(const char *name, dns_qtype_t qtype,
     51    dns_host_info_t *info)
    5152{
    52         dns_message_t *msg;
    53         dns_message_t *amsg;
    54         dns_question_t *question;
    55         dns_host_info_t *info;
    56         char *sname, *cname;
    57         size_t eoff;
    58         int rc;
    59 
    60         question = calloc(1, sizeof(dns_question_t));
    61         if (question == NULL)
    62                 return ENOMEM;
    63 
    64         question->qname = (char *)name;
    65         question->qtype = DTYPE_A;
     53        /* Start with the caller-provided name */
     54        char *sname = str_dup(name);
     55        if (sname == NULL)
     56                return ENOMEM;
     57       
     58        char *qname = str_dup(name);
     59        if (qname == NULL) {
     60                free(sname);
     61                return ENOMEM;
     62        }
     63       
     64        dns_question_t *question = calloc(1, sizeof(dns_question_t));
     65        if (question == NULL) {
     66                free(qname);
     67                free(sname);
     68                return ENOMEM;
     69        }
     70       
     71        question->qname = qname;
     72        question->qtype = qtype;
    6673        question->qclass = DC_IN;
    67 
    68         msg = dns_message_new();
    69         if (msg == NULL)
    70                 return ENOMEM;
    71 
    72         list_append(&question->msg, &msg->question);
    73 
     74       
     75        dns_message_t *msg = dns_message_new();
     76        if (msg == NULL) {
     77                free(question);
     78                free(qname);
     79                free(sname);
     80                return ENOMEM;
     81        }
     82       
    7483        msg->id = msg_id++;
    7584        msg->qr = QR_QUERY;
    … …  
    7988        msg->rd = true;
    8089        msg->ra = false;
    81 
    82         rc = dns_request(msg, &amsg);
     90       
     91        list_append(&question->msg, &msg->question);
     92       
     93        dns_message_t *amsg;
     94        int rc = dns_request(msg, &amsg);
    8395        if (rc != EOK) {
     96                dns_message_destroy(msg);
     97                free(sname);
    8498                return rc;
    8599        }
    86 
    87         /* Start with the caller-provided name */
    88         sname = str_dup(name);
    89 
     100       
    90101        list_foreach(amsg->answer, link) {
    91102                dns_rr_t *rr = list_get_instance(link, dns_rr_t, msg);
    92 
     103               
    93104                log_msg(LOG_DEFAULT, LVL_DEBUG, " - '%s' %u/%u, dsize %zu",
    94                         rr->name, rr->rtype, rr->rclass, rr->rdata_size);
    95 
    96                 if (rr->rtype == DTYPE_CNAME && rr->rclass == DC_IN &&
    97                     str_cmp(rr->name, sname) == 0) {
     105                    rr->name, rr->rtype, rr->rclass, rr->rdata_size);
     106               
     107                if ((rr->rtype == DTYPE_CNAME) && (rr->rclass == DC_IN) &&
     108                    (str_cmp(rr->name, sname) == 0)) {
     109                       
    98110                        log_msg(LOG_DEFAULT, LVL_DEBUG, "decode cname (%p, %zu, %zu)",
    99111                            amsg->pdu.data, amsg->pdu.size, rr->roff);
     112                       
     113                        char *cname;
     114                        size_t eoff;
    100115                        rc = dns_name_decode(&amsg->pdu, rr->roff, &cname, &eoff);
    101116                        if (rc != EOK) {
    102                                 log_msg(LOG_DEFAULT, LVL_DEBUG,
    103                                     "error decoding cname");
    104                                 assert(rc == EINVAL || rc == ENOMEM);
     117                                assert((rc == EINVAL) || (rc == ENOMEM));
     118                               
     119                                log_msg(LOG_DEFAULT, LVL_DEBUG, "error decoding cname");
     120                               
    105121                                dns_message_destroy(msg);
    106122                                dns_message_destroy(amsg);
     123                                free(sname);
     124                               
    107125                                return rc;
    108126                        }
    109 
     127                       
    110128                        log_msg(LOG_DEFAULT, LVL_DEBUG, "name = '%s' "
    111129                            "cname = '%s'", sname, cname);
    112 
     130                       
     131                        /* Continue looking for the more canonical name */
    113132                        free(sname);
    114                         /* Continue looking for the more canonical name */
    115133                        sname = cname;
    116134                }
    117 
    118                 if (rr->rtype == DTYPE_A && rr->rclass == DC_IN &&
    119                         rr->rdata_size == sizeof(uint32_t) &&
    120                             str_cmp(rr->name, sname) == 0) {
    121 
    122                         info = calloc(1, sizeof(dns_host_info_t));
    123                         if (info == NULL) {
     135               
     136                if ((qtype == DTYPE_A) && (rr->rtype == DTYPE_A) &&
     137                    (rr->rclass == DC_IN) && (rr->rdata_size == sizeof(addr32_t)) &&
     138                    (str_cmp(rr->name, sname) == 0)) {
     139                       
     140                        info->cname = str_dup(rr->name);
     141                        if (info->cname == NULL) {
    124142                                dns_message_destroy(msg);
    125143                                dns_message_destroy(amsg);
     144                                free(sname);
     145                               
    126146                                return ENOMEM;
    127147                        }
    128 
    129                         info->cname = str_dup(rr->name);
    130                         info->addr.ipv4 = dns_uint32_t_decode(rr->rdata, rr->rdata_size);
    131                         log_msg(LOG_DEFAULT, LVL_DEBUG, "info->name = '%s' "
    132                             "info->addr = %x", info->cname, info->addr.ipv4);
    133 
     148                       
     149                        inet_addr_set(dns_uint32_t_decode(rr->rdata, rr->rdata_size),
     150                            &info->addr);
     151                       
    134152                        dns_message_destroy(msg);
    135153                        dns_message_destroy(amsg);
    136                         *rinfo = info;
     154                        free(sname);
     155                       
    137156                        return EOK;
    138157                }
    139         }
    140 
     158               
     159                if ((qtype == DTYPE_AAAA) && (rr->rtype == DTYPE_AAAA) &&
     160                    (rr->rclass == DC_IN) && (rr->rdata_size == sizeof(addr128_t)) &&
     161                    (str_cmp(rr->name, sname) == 0)) {
     162               
     163                        info->cname = str_dup(rr->name);
     164                        if (info->cname == NULL) {
     165                                dns_message_destroy(msg);
     166                                dns_message_destroy(amsg);
     167                                free(sname);
     168                               
     169                                return ENOMEM;
     170                        }
     171                       
     172                        addr128_t addr;
     173                        dns_addr128_t_decode(rr->rdata, rr->rdata_size, addr);
     174                       
     175                        inet_addr_set6(addr, &info->addr);
     176                       
     177                        dns_message_destroy(msg);
     178                        dns_message_destroy(amsg);
     179                        free(sname);
     180                       
     181                        return EOK;
     182                }
     183        }
     184       
     185        log_msg(LOG_DEFAULT, LVL_DEBUG, "'%s' not resolved, fail", sname);
     186       
    141187        dns_message_destroy(msg);
    142188        dns_message_destroy(amsg);
    143         log_msg(LOG_DEFAULT, LVL_DEBUG, "'%s' not resolved, fail", sname);
    144 
     189        free(sname);
     190       
    145191        return EIO;
     192}
     193
     194int dns_name2host(const char *name, dns_host_info_t **rinfo, uint16_t af)
     195{
     196        dns_host_info_t *info = calloc(1, sizeof(dns_host_info_t));
     197        if (info == NULL)
     198                return ENOMEM;
     199       
     200        int rc;
     201       
     202        switch (af) {
     203        case AF_NONE:
     204                rc = dns_name_query(name, DTYPE_AAAA, info);
     205               
     206                if (rc != EOK)
     207                        rc = dns_name_query(name, DTYPE_A, info);
     208               
     209                break;
     210        case AF_INET:
     211                rc = dns_name_query(name, DTYPE_A, info);
     212                break;
     213        case AF_INET6:
     214                rc = dns_name_query(name, DTYPE_AAAA, info);
     215                break;
     216        default:
     217                rc = EINVAL;
     218        }
     219       
     220        if (rc == EOK)
     221                *rinfo = info;
     222        else
     223                free(info);
     224       
     225        return rc;
    146226}
    147227

  • uspace/srv/net/dnsrsrv/query.h

    rf2c19b0 r03c971f  
    3939#include "dns_type.h"
    4040
    41 extern int dns_name2host(const char *, dns_host_info_t **);
     41extern int dns_name2host(const char *, dns_host_info_t **, uint16_t);
    4242extern void dns_hostinfo_destroy(dns_host_info_t *);
    4343

  • uspace/srv/net/dnsrsrv/transport.c

    rf2c19b0 r03c971f  
    5252
    5353/** Request timeout (microseconds) */
    54 #define REQ_TIMEOUT (5*1000*1000)
     54#define REQ_TIMEOUT (5 * 1000 * 1000)
    5555
    5656/** Maximum number of retries */
    5757#define REQ_RETRY_MAX 3
     58
     59inet_addr_t dns_server_addr;
    5860
    5961typedef struct {
    … …  
    7274static fid_t recv_fid;
    7375static int transport_fd = -1;
    74 inet_addr_t dns_server_addr;
    7576
    7677/** Outstanding requests */
    … …  
    182183int dns_request(dns_message_t *req, dns_message_t **rresp)
    183184{
    184         int rc;
     185        trans_req_t *treq = NULL;
     186       
    185187        void *req_data;
    186188        size_t req_size;
     189        int rc = dns_message_encode(req, &req_data, &req_size);
     190        if (rc != EOK)
     191                goto error;
     192       
    187193        struct sockaddr_in addr;
    188         trans_req_t *treq;
    189         int ntry;
    190 
    191         req_data = NULL;
    192         treq = NULL;
    193 
    194         addr.sin_family = AF_INET;
    195         addr.sin_port = htons(DNS_SERVER_PORT);
    196         addr.sin_addr.s_addr = host2uint32_t_be(dns_server_addr.ipv4);
    197 
    198         rc = dns_message_encode(req, &req_data, &req_size);
    199         if (rc != EOK)
    200                 goto error;
    201 
    202         ntry = 0;
    203 
     194        struct sockaddr_in6 addr6;
     195        uint16_t af =
     196            inet_addr_sockaddr_in(&dns_server_addr, &addr, &addr6);
     197       
     198        struct sockaddr *address;
     199        socklen_t addrlen;
     200       
     201        switch (af) {
     202        case AF_INET:
     203                addr.sin_port = htons(DNS_SERVER_PORT);
     204                address = (struct sockaddr *) &addr;
     205                addrlen = sizeof(addr);
     206                break;
     207        case AF_INET6:
     208                addr6.sin6_port = htons(DNS_SERVER_PORT);
     209                address = (struct sockaddr *) &addr6;
     210                addrlen = sizeof(addr6);
     211                break;
     212        default:
     213                rc = EAFNOSUPPORT;
     214                goto error;
     215        }
     216       
     217        size_t ntry = 0;
     218       
    204219        while (ntry < REQ_RETRY_MAX) {
    205220                rc = sendto(transport_fd, req_data, req_size, 0,
    206                     (struct sockaddr *)&addr, sizeof(addr));
     221                    (struct sockaddr *) address, addrlen);
    207222                if (rc != EOK)
    208223                        goto error;
    209 
     224               
    210225                treq = treq_create(req);
    211226                if (treq == NULL) {
    … …  
    213228                        goto error;
    214229                }
    215 
    216 
     230               
    217231                fibril_mutex_lock(&treq->done_lock);
    218232                while (treq->done != true) {
    … …  
    224238                        }
    225239                }
    226 
     240               
    227241                fibril_mutex_unlock(&treq->done_lock);
    228 
     242               
    229243                if (rc != ETIMEOUT)
    230244                        break;
    231245        }
    232 
     246       
    233247        if (ntry >= REQ_RETRY_MAX) {
    234248                rc = EIO;
    235249                goto error;
    236250        }
    237 
     251       
    238252        if (treq->status != EOK) {
    239253                rc = treq->status;
    240254                goto error;
    241255        }
    242 
     256       
    243257        *rresp = treq->resp;
    244258        treq_destroy(treq);
    245259        free(req_data);
    246260        return EOK;
     261       
    247262error:
    248263        if (treq != NULL)
    249264                treq_destroy(treq);
     265       
    250266        free(req_data);
    251267        return rc;

  • uspace/srv/net/dnsrsrv/transport.h

    rf2c19b0 r03c971f  
    4040#include "dns_type.h"
    4141
     42extern inet_addr_t dns_server_addr;
     43
    4244extern int transport_init(void);
    4345extern void transport_fini(void);
    4446extern int dns_request(dns_message_t *, dns_message_t **);
    45 
    46 extern inet_addr_t dns_server_addr;
    47 
    4847
    4948#endif

  • uspace/srv/net/ethip/arp.c

    rf2c19b0 r03c971f  
    3838#include <io/log.h>
    3939#include <inet/iplink_srv.h>
     40#include <inet/addr.h>
    4041#include <stdlib.h>
    41 
     42#include <net/socket_codes.h>
    4243#include "arp.h"
    4344#include "atrans.h"
    … …  
    5455void arp_received(ethip_nic_t *nic, eth_frame_t *frame)
    5556{
    56         int rc;
     57        log_msg(LOG_DEFAULT, LVL_DEBUG, "arp_received()");
     58       
    5759        arp_eth_packet_t packet;
    58         arp_eth_packet_t reply;
    59         ethip_link_addr_t *laddr;
    60 
    61         log_msg(LOG_DEFAULT, LVL_DEBUG, "arp_received()");
    62 
    63         rc = arp_pdu_decode(frame->data, frame->size, &packet);
     60        int rc = arp_pdu_decode(frame->data, frame->size, &packet);
    6461        if (rc != EOK)
    6562                return;
    66 
     63       
    6764        log_msg(LOG_DEFAULT, LVL_DEBUG, "ARP PDU decoded, opcode=%d, tpa=%x",
    68             packet.opcode, packet.target_proto_addr.ipv4);
    69 
    70         laddr = ethip_nic_addr_find(nic, &packet.target_proto_addr);
    71         if (laddr != NULL) {
    72                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Request/reply to my address");
    73 
    74                 (void) atrans_add(&packet.sender_proto_addr,
    75                     &packet.sender_hw_addr);
    76 
    77                 if (packet.opcode == aop_request) {
    78                         reply.opcode = aop_reply;
    79                         reply.sender_hw_addr = nic->mac_addr;
    80                         reply.sender_proto_addr = laddr->addr;
    81                         reply.target_hw_addr = packet.sender_hw_addr;
    82                         reply.target_proto_addr = packet.sender_proto_addr;
    83 
    84                         arp_send_packet(nic, &reply);
    85                 }
     65            packet.opcode, packet.target_proto_addr);
     66       
     67        inet_addr_t addr;
     68        inet_addr_set(packet.target_proto_addr, &addr);
     69       
     70        ethip_link_addr_t *laddr = ethip_nic_addr_find(nic, &addr);
     71        if (laddr == NULL)
     72                return;
     73       
     74        addr32_t laddr_v4;
     75        uint16_t laddr_af = inet_addr_get(&laddr->addr, &laddr_v4, NULL);
     76        if (laddr_af != AF_INET)
     77                return;
     78       
     79        log_msg(LOG_DEFAULT, LVL_DEBUG, "Request/reply to my address");
     80       
     81        (void) atrans_add(packet.sender_proto_addr,
     82            packet.sender_hw_addr);
     83       
     84        if (packet.opcode == aop_request) {
     85                arp_eth_packet_t reply;
     86               
     87                reply.opcode = aop_reply;
     88                addr48(nic->mac_addr, reply.sender_hw_addr);
     89                reply.sender_proto_addr = laddr_v4;
     90                addr48(packet.sender_hw_addr, reply.target_hw_addr);
     91                reply.target_proto_addr = packet.sender_proto_addr;
     92               
     93                arp_send_packet(nic, &reply);
    8694        }
    8795}
    8896
    89 int arp_translate(ethip_nic_t *nic, iplink_srv_addr_t *src_addr,
    90     iplink_srv_addr_t *ip_addr, mac48_addr_t *mac_addr)
     97int arp_translate(ethip_nic_t *nic, addr32_t src_addr, addr32_t ip_addr,
     98    addr48_t mac_addr)
    9199{
    92         int rc;
    93         arp_eth_packet_t packet;
    94 
    95         rc = atrans_lookup(ip_addr, mac_addr);
     100        int rc = atrans_lookup(ip_addr, mac_addr);
    96101        if (rc == EOK)
    97102                return EOK;
    98 
     103       
     104        arp_eth_packet_t packet;
     105       
    99106        packet.opcode = aop_request;
    100         packet.sender_hw_addr = nic->mac_addr;
    101         packet.sender_proto_addr = *src_addr;
    102         packet.target_hw_addr.addr = MAC48_BROADCAST;
    103         packet.target_proto_addr = *ip_addr;
    104 
     107        addr48(nic->mac_addr, packet.sender_hw_addr);
     108        packet.sender_proto_addr = src_addr;
     109        addr48(addr48_broadcast, packet.target_hw_addr);
     110        packet.target_proto_addr = ip_addr;
     111       
    105112        rc = arp_send_packet(nic, &packet);
    106113        if (rc != EOK)
    107114                return rc;
    108 
     115       
    109116        (void) atrans_wait_timeout(ARP_REQUEST_TIMEOUT);
    110 
     117       
    111118        return atrans_lookup(ip_addr, mac_addr);
    112119}
    … …  
    128135                return rc;
    129136
    130         frame.dest.addr = packet->target_hw_addr.addr;
    131         frame.src.addr =  packet->sender_hw_addr.addr;
     137        addr48(packet->target_hw_addr, frame.dest);
     138        addr48(packet->sender_hw_addr, frame.src);
    132139        frame.etype_len = ETYPE_ARP;
    133140        frame.data = pdata;

  • uspace/srv/net/ethip/arp.h

    rf2c19b0 r03c971f  
    3939
    4040#include <inet/iplink_srv.h>
     41#include <inet/addr.h>
    4142#include "ethip.h"
    4243
    4344extern void arp_received(ethip_nic_t *, eth_frame_t *);
    44 extern int arp_translate(ethip_nic_t *, iplink_srv_addr_t *,
    45     iplink_srv_addr_t *, mac48_addr_t *);
     45extern int arp_translate(ethip_nic_t *, addr32_t, addr32_t, addr48_t);
    4646
    4747#endif

  • uspace/srv/net/ethip/atrans.c

    rf2c19b0 r03c971f  
    4949static FIBRIL_CONDVAR_INITIALIZE(atrans_cv);
    5050
    51 static ethip_atrans_t *atrans_find(iplink_srv_addr_t *ip_addr)
     51static ethip_atrans_t *atrans_find(addr32_t ip_addr)
    5252{
    5353        list_foreach(atrans_list, link) {
    … …  
    5555                    ethip_atrans_t, atrans_list);
    5656
    57                 if (atrans->ip_addr.ipv4 == ip_addr->ipv4)
     57                if (atrans->ip_addr == ip_addr)
    5858                        return atrans;
    5959        }
    … …  
    6262}
    6363
    64 int atrans_add(iplink_srv_addr_t *ip_addr, mac48_addr_t *mac_addr)
     64int atrans_add(addr32_t ip_addr, addr48_t mac_addr)
    6565{
    6666        ethip_atrans_t *atrans;
    … …  
    7171                return ENOMEM;
    7272
    73         atrans->ip_addr = *ip_addr;
    74         atrans->mac_addr = *mac_addr;
     73        atrans->ip_addr = ip_addr;
     74        addr48(mac_addr, atrans->mac_addr);
    7575
    7676        fibril_mutex_lock(&atrans_list_lock);
    … …  
    8888}
    8989
    90 int atrans_remove(iplink_srv_addr_t *ip_addr)
     90int atrans_remove(addr32_t ip_addr)
    9191{
    9292        ethip_atrans_t *atrans;
    … …  
    106106}
    107107
    108 int atrans_lookup(iplink_srv_addr_t *ip_addr, mac48_addr_t *mac_addr)
     108int atrans_lookup(addr32_t ip_addr, addr48_t mac_addr)
    109109{
    110         ethip_atrans_t *atrans;
    111 
    112110        fibril_mutex_lock(&atrans_list_lock);
    113         atrans = atrans_find(ip_addr);
     111        ethip_atrans_t *atrans = atrans_find(ip_addr);
    114112        if (atrans == NULL) {
    115113                fibril_mutex_unlock(&atrans_list_lock);
    116114                return ENOENT;
    117115        }
    118 
     116       
    119117        fibril_mutex_unlock(&atrans_list_lock);
    120         *mac_addr = atrans->mac_addr;
     118        addr48(atrans->mac_addr, mac_addr);
    121119        return EOK;
    122120}
    … …  
    124122int atrans_wait_timeout(suseconds_t timeout)
    125123{
    126         int rc;
    127 
    128124        fibril_mutex_lock(&atrans_list_lock);
    129         rc = fibril_condvar_wait_timeout(&atrans_cv, &atrans_list_lock,
     125        int rc = fibril_condvar_wait_timeout(&atrans_cv, &atrans_list_lock,
    130126            timeout);
    131127        fibril_mutex_unlock(&atrans_list_lock);
    132 
     128       
    133129        return rc;
    134130}

  • uspace/srv/net/ethip/atrans.h

    rf2c19b0 r03c971f  
    3939
    4040#include <inet/iplink_srv.h>
     41#include <inet/addr.h>
    4142#include "ethip.h"
    4243
    43 extern int atrans_add(iplink_srv_addr_t *, mac48_addr_t *);
    44 extern int atrans_remove(iplink_srv_addr_t *);
    45 extern int atrans_lookup(iplink_srv_addr_t *, mac48_addr_t *);
     44extern int atrans_add(addr32_t, addr48_t);
     45extern int atrans_remove(addr32_t);
     46extern int atrans_lookup(addr32_t, addr48_t);
    4647extern int atrans_wait_timeout(suseconds_t);
    4748

  • uspace/srv/net/ethip/ethip.c

    rf2c19b0 r03c971f  
    4444#include <stdio.h>
    4545#include <stdlib.h>
    46 
     46#include <net/socket_codes.h>
    4747#include "arp.h"
    4848#include "ethip.h"
    … …  
    5555static int ethip_open(iplink_srv_t *srv);
    5656static int ethip_close(iplink_srv_t *srv);
    57 static int ethip_send(iplink_srv_t *srv, iplink_srv_sdu_t *sdu);
     57static int ethip_send(iplink_srv_t *srv, iplink_sdu_t *sdu);
     58static int ethip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu);
    5859static int ethip_get_mtu(iplink_srv_t *srv, size_t *mtu);
    59 static int ethip_addr_add(iplink_srv_t *srv, iplink_srv_addr_t *addr);
    60 static int ethip_addr_remove(iplink_srv_t *srv, iplink_srv_addr_t *addr);
     60static int ethip_get_mac48(iplink_srv_t *srv, addr48_t *mac);
     61static int ethip_addr_add(iplink_srv_t *srv, inet_addr_t *addr);
     62static int ethip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
    6163
    6264static void ethip_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    … …  
    6668        .close = ethip_close,
    6769        .send = ethip_send,
     70        .send6 = ethip_send6,
    6871        .get_mtu = ethip_get_mtu,
     72        .get_mac48 = ethip_get_mac48,
    6973        .addr_add = ethip_addr_add,
    7074        .addr_remove = ethip_addr_remove
    … …  
    164168}
    165169
    166 static int ethip_send(iplink_srv_t *srv, iplink_srv_sdu_t *sdu)
    167 {
    168         ethip_nic_t *nic = (ethip_nic_t *)srv->arg;
     170static int ethip_send(iplink_srv_t *srv, iplink_sdu_t *sdu)
     171{
     172        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_send()");
     173       
     174        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
    169175        eth_frame_t frame;
    170         void *data;
    171         size_t size;
    172         mac48_addr_t dest_mac_addr;
    173         int rc;
    174 
    175         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_send()");
    176 
    177         rc = arp_translate(nic, &sdu->lsrc, &sdu->ldest, &dest_mac_addr);
    178         if (rc != EOK) {
    179                 log_msg(LOG_DEFAULT, LVL_WARN, "Failed to look up IP address 0x%" PRIx32,
    180                     sdu->ldest.ipv4);
    181                 return rc;
    182         }
    183 
    184         frame.dest      = dest_mac_addr;
    185         frame.src       = nic->mac_addr;
     176       
     177        int rc = arp_translate(nic, sdu->src, sdu->dest, frame.dest);
     178        if (rc != EOK) {
     179                log_msg(LOG_DEFAULT, LVL_WARN, "Failed to look up IPv4 address 0x%"
     180                    PRIx32, sdu->dest);
     181                return rc;
     182        }
     183       
     184        addr48(nic->mac_addr, frame.src);
    186185        frame.etype_len = ETYPE_IP;
    187186        frame.data = sdu->data;
    188187        frame.size = sdu->size;
    189 
     188       
     189        void *data;
     190        size_t size;
    190191        rc = eth_pdu_encode(&frame, &data, &size);
    191192        if (rc != EOK)
    192193                return rc;
    193 
     194       
    194195        rc = ethip_nic_send(nic, data, size);
    195196        free(data);
    196 
     197       
    197198        return rc;
    198199}
    199200
     201static int ethip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu)
     202{
     203        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_send6()");
     204       
     205        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
     206        eth_frame_t frame;
     207       
     208        addr48(sdu->dest, frame.dest);
     209        addr48(nic->mac_addr, frame.src);
     210        frame.etype_len = ETYPE_IPV6;
     211        frame.data = sdu->data;
     212        frame.size = sdu->size;
     213       
     214        void *data;
     215        size_t size;
     216        int rc = eth_pdu_encode(&frame, &data, &size);
     217        if (rc != EOK)
     218                return rc;
     219       
     220        rc = ethip_nic_send(nic, data, size);
     221        free(data);
     222       
     223        return rc;
     224}
     225
    200226int ethip_received(iplink_srv_t *srv, void *data, size_t size)
    201227{
    202228        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_received(): srv=%p", srv);
    203         ethip_nic_t *nic = (ethip_nic_t *)srv->arg;
     229        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
     230       
     231        log_msg(LOG_DEFAULT, LVL_DEBUG, " - eth_pdu_decode");
     232       
    204233        eth_frame_t frame;
    205         iplink_srv_sdu_t sdu;
    206         int rc;
    207 
    208         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_received()");
    209 
    210         log_msg(LOG_DEFAULT, LVL_DEBUG, " - eth_pdu_decode");
    211         rc = eth_pdu_decode(data, size, &frame);
     234        int rc = eth_pdu_decode(data, size, &frame);
    212235        if (rc != EOK) {
    213236                log_msg(LOG_DEFAULT, LVL_DEBUG, " - eth_pdu_decode failed");
    214237                return rc;
    215238        }
    216 
     239       
     240        iplink_recv_sdu_t sdu;
     241       
    217242        switch (frame.etype_len) {
    218243        case ETYPE_ARP:
    … …  
    221246        case ETYPE_IP:
    222247                log_msg(LOG_DEFAULT, LVL_DEBUG, " - construct SDU");
    223                 sdu.lsrc.ipv4 = 0;
    224                 sdu.ldest.ipv4 = 0;
    225248                sdu.data = frame.data;
    226249                sdu.size = frame.size;
    227250                log_msg(LOG_DEFAULT, LVL_DEBUG, " - call iplink_ev_recv");
    228                 rc = iplink_ev_recv(&nic->iplink, &sdu);
     251                rc = iplink_ev_recv(&nic->iplink, &sdu, AF_INET);
     252                break;
     253        case ETYPE_IPV6:
     254                log_msg(LOG_DEFAULT, LVL_DEBUG, " - construct SDU IPv6");
     255                sdu.data = frame.data;
     256                sdu.size = frame.size;
     257                log_msg(LOG_DEFAULT, LVL_DEBUG, " - call iplink_ev_recv");
     258                rc = iplink_ev_recv(&nic->iplink, &sdu, AF_INET6);
    229259                break;
    230260        default:
    … …  
    232262                    frame.etype_len);
    233263        }
    234 
     264       
    235265        free(frame.data);
    236266        return rc;
    … …  
    244274}
    245275
    246 static int ethip_addr_add(iplink_srv_t *srv, iplink_srv_addr_t *addr)
    247 {
    248         ethip_nic_t *nic = (ethip_nic_t *)srv->arg;
    249 
    250         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_addr_add(0x%" PRIx32 ")", addr->ipv4);
     276static int ethip_get_mac48(iplink_srv_t *srv, addr48_t *mac)
     277{
     278        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_get_mac48()");
     279       
     280        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
     281        addr48(nic->mac_addr, *mac);
     282       
     283        return EOK;
     284}
     285
     286static int ethip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
     287{
     288        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
     289       
    251290        return ethip_nic_addr_add(nic, addr);
    252291}
    253292
    254 static int ethip_addr_remove(iplink_srv_t *srv, iplink_srv_addr_t *addr)
    255 {
    256         ethip_nic_t *nic = (ethip_nic_t *)srv->arg;
    257 
    258         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_addr_remove(0x%" PRIx32 ")", addr->ipv4);
    259         return ethip_nic_addr_add(nic, addr);
     293static int ethip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr)
     294{
     295        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
     296       
     297        return ethip_nic_addr_remove(nic, addr);
    260298}
    261299

  • uspace/srv/net/ethip/ethip.h

    rf2c19b0 r03c971f  
    4141#include <async.h>
    4242#include <inet/iplink_srv.h>
     43#include <inet/addr.h>
    4344#include <loc.h>
    4445#include <sys/types.h>
    4546
    46 #define MAC48_BROADCAST 0xffffffffffff
    47 
    4847typedef struct {
    49         link_t addr_list;
    50         iplink_srv_addr_t addr;
     48        link_t link;
     49        inet_addr_t addr;
    5150} ethip_link_addr_t;
    5251
    53 /** IEEE MAC-48 identifier */
    54 typedef struct {
    55         /** MAC Address (in lowest 48 bits) */
    56         uint64_t addr;
    57 } mac48_addr_t;
    58 
    5952typedef struct ethip_nic {
    60         link_t nic_list;
     53        link_t link;
    6154        service_id_t svc_id;
    6255        char *svc_name;
    … …  
    6760
    6861        /** MAC address */
    69         mac48_addr_t mac_addr;
    70         /** List of IP addresses configured on this link */
    71         list_t addr_list; /* of ethip_link_addr_t */
     62        addr48_t mac_addr;
     63       
     64        /**
     65         * List of IP addresses configured on this link
     66         * (of the type ethip_link_addr_t)
     67         */
     68        list_t addr_list;
    7269} ethip_nic_t;
    7370
    … …  
    7572typedef struct {
    7673        /** Destination Address */
    77         mac48_addr_t dest;
     74        addr48_t dest;
    7875        /** Source Address */
    79         mac48_addr_t src;
     76        addr48_t src;
    8077        /** Ethertype or Length */
    8178        uint16_t etype_len;
    … …  
    10299        arp_opcode_t opcode;
    103100        /** Sender hardware address */
    104         mac48_addr_t sender_hw_addr;
     101        addr48_t sender_hw_addr;
    105102        /** Sender protocol address */
    106         iplink_srv_addr_t sender_proto_addr;
     103        addr32_t sender_proto_addr;
    107104        /** Target hardware address */
    108         mac48_addr_t target_hw_addr;
     105        addr48_t target_hw_addr;
    109106        /** Target protocol address */
    110         iplink_srv_addr_t target_proto_addr;
     107        addr32_t target_proto_addr;
    111108} arp_eth_packet_t;
    112109
    … …  
    114111typedef struct {
    115112        link_t atrans_list;
    116         iplink_srv_addr_t ip_addr;
    117         mac48_addr_t mac_addr;
     113        addr32_t ip_addr;
     114        addr48_t mac_addr;
    118115} ethip_atrans_t;
    119116

  • uspace/srv/net/ethip/ethip_nic.c

    rf2c19b0 r03c971f  
    4545#include <device/nic.h>
    4646#include <stdlib.h>
    47 
     47#include <net/socket_codes.h>
     48#include <mem.h>
    4849#include "ethip.h"
    4950#include "ethip_nic.h"
    … …  
    8384                already_known = false;
    8485
    85                 list_foreach(ethip_nic_list, nic_link) {
    86                         ethip_nic_t *nic = list_get_instance(nic_link,
    87                             ethip_nic_t, nic_list);
     86                list_foreach(ethip_nic_list, link) {
     87                        ethip_nic_t *nic = list_get_instance(link,
     88                            ethip_nic_t, link);
    8889                        if (nic->svc_id == svcs[i]) {
    8990                                already_known = true;
    … …  
    108109{
    109110        ethip_nic_t *nic = calloc(1, sizeof(ethip_nic_t));
    110 
    111111        if (nic == NULL) {
    112112                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating NIC structure. "
    … …  
    114114                return NULL;
    115115        }
    116 
    117         link_initialize(&nic->nic_list);
     116       
     117        link_initialize(&nic->link);
    118118        list_initialize(&nic->addr_list);
    119 
     119       
    120120        return nic;
    121121}
    122122
    123 static ethip_link_addr_t *ethip_nic_addr_new(iplink_srv_addr_t *addr)
     123static ethip_link_addr_t *ethip_nic_addr_new(inet_addr_t *addr)
    124124{
    125125        ethip_link_addr_t *laddr = calloc(1, sizeof(ethip_link_addr_t));
    126 
    127126        if (laddr == NULL) {
    128127                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating NIC address structure. "
    … …  
    130129                return NULL;
    131130        }
    132 
    133         link_initialize(&laddr->addr_list);
    134         laddr->addr.ipv4 = addr->ipv4;
     131       
     132        link_initialize(&laddr->link);
     133        laddr->addr = *addr;
     134       
    135135        return laddr;
    136136}
    … …  
    140140        if (nic->svc_name != NULL)
    141141                free(nic->svc_name);
     142       
    142143        free(nic);
    143144}
    … …  
    180181
    181182        log_msg(LOG_DEFAULT, LVL_DEBUG, "Opened NIC '%s'", nic->svc_name);
    182         list_append(&nic->nic_list, &ethip_nic_list);
     183        list_append(&nic->link, &ethip_nic_list);
    183184        in_list = true;
    184185
    … …  
    193194                goto error;
    194195        }
    195 
    196         mac48_decode(nic_address.address, &nic->mac_addr);
     196       
     197        addr48(nic_address.address, nic->mac_addr);
    197198
    198199        rc = nic_set_state(nic->sess, NIC_STATE_ACTIVE);
    … …  
    203204        }
    204205
    205         log_msg(LOG_DEFAULT, LVL_DEBUG, "Initialized IP link service, MAC = 0x%" PRIx64,
    206             nic->mac_addr.addr);
     206        log_msg(LOG_DEFAULT, LVL_DEBUG, "Initialized IP link service,");
    207207
    208208        return EOK;
    … …  
    210210error:
    211211        if (in_list)
    212                 list_remove(&nic->nic_list);
     212                list_remove(&nic->link);
     213       
    213214        if (nic->sess != NULL)
    214215                async_hangup(nic->sess);
     216       
    215217        ethip_nic_delete(nic);
    216218        return rc;
    … …  
    313315        list_foreach(ethip_nic_list, link) {
    314316                log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_find_by_iplink_sid - element");
    315                 ethip_nic_t *nic = list_get_instance(link, ethip_nic_t,
    316                     nic_list);
     317                ethip_nic_t *nic = list_get_instance(link, ethip_nic_t, link);
    317318
    318319                if (nic->iplink_sid == iplink_sid) {
    … …  
    335336}
    336337
    337 int ethip_nic_addr_add(ethip_nic_t *nic, iplink_srv_addr_t *addr)
    338 {
    339         ethip_link_addr_t *laddr;
    340 
     338/** Setup accepted multicast addresses
     339 *
     340 * Currently the set of accepted multicast addresses is
     341 * determined only based on IPv6 addresses.
     342 *
     343 */
     344static int ethip_nic_setup_multicast(ethip_nic_t *nic)
     345{
     346        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_setup_multicast()");
     347       
     348        /* Count the number of multicast addresses */
     349       
     350        size_t count = 0;
     351       
     352        list_foreach(nic->addr_list, link) {
     353                ethip_link_addr_t *laddr = list_get_instance(link,
     354                    ethip_link_addr_t, link);
     355               
     356                uint16_t af = inet_addr_get(&laddr->addr, NULL, NULL);
     357                if (af == AF_INET6)
     358                        count++;
     359        }
     360       
     361        if (count == 0)
     362                return nic_multicast_set_mode(nic->sess, NIC_MULTICAST_BLOCKED,
     363                    NULL, 0);
     364       
     365        nic_address_t *mac_list = calloc(count, sizeof(nic_address_t));
     366        if (mac_list == NULL)
     367                return ENOMEM;
     368       
     369        /* Create the multicast MAC list */
     370       
     371        size_t i = 0;
     372       
     373        list_foreach(nic->addr_list, link) {
     374                assert(i < count);
     375               
     376                ethip_link_addr_t *laddr = list_get_instance(link,
     377                    ethip_link_addr_t, link);
     378               
     379                addr128_t v6;
     380                uint16_t af = inet_addr_get(&laddr->addr, NULL, &v6);
     381                if (af != AF_INET6)
     382                        continue;
     383               
     384                addr48_t mac;
     385                addr48_solicited_node(v6, mac);
     386               
     387                /* Avoid duplicate addresses in the list */
     388               
     389                bool found = false;
     390               
     391                for (size_t j = 0; j < i; j++) {
     392                        if (addr48_compare(mac_list[j].address, mac)) {
     393                                found = true;
     394                                break;
     395                        }
     396                }
     397               
     398                if (!found) {
     399                        addr48(mac, mac_list[i].address);
     400                        i++;
     401                } else
     402                        count--;
     403        }
     404       
     405        /* Setup the multicast MAC list */
     406       
     407        int rc = nic_multicast_set_mode(nic->sess, NIC_MULTICAST_LIST,
     408            mac_list, count);
     409       
     410        free(mac_list);
     411        return rc;
     412}
     413
     414int ethip_nic_addr_add(ethip_nic_t *nic, inet_addr_t *addr)
     415{
    341416        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_add()");
    342         laddr = ethip_nic_addr_new(addr);
     417       
     418        ethip_link_addr_t *laddr = ethip_nic_addr_new(addr);
    343419        if (laddr == NULL)
    344420                return ENOMEM;
    345 
    346         list_append(&laddr->addr_list, &nic->addr_list);
    347         return EOK;
    348 }
    349 
    350 int ethip_nic_addr_remove(ethip_nic_t *nic, iplink_srv_addr_t *addr)
    351 {
    352         ethip_link_addr_t *laddr;
    353 
     421       
     422        list_append(&laddr->link, &nic->addr_list);
     423       
     424        return ethip_nic_setup_multicast(nic);
     425}
     426
     427int ethip_nic_addr_remove(ethip_nic_t *nic, inet_addr_t *addr)
     428{
    354429        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_remove()");
    355 
    356         laddr = ethip_nic_addr_find(nic, addr);
     430       
     431        ethip_link_addr_t *laddr = ethip_nic_addr_find(nic, addr);
    357432        if (laddr == NULL)
    358433                return ENOENT;
    359 
    360         list_remove(&laddr->addr_list);
     434       
     435        list_remove(&laddr->link);
    361436        ethip_link_addr_delete(laddr);
    362         return EOK;
     437       
     438        return ethip_nic_setup_multicast(nic);
    363439}
    364440
    365441ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *nic,
    366     iplink_srv_addr_t *addr)
     442    inet_addr_t *addr)
    367443{
    368444        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_find()");
    369 
     445       
    370446        list_foreach(nic->addr_list, link) {
    371447                ethip_link_addr_t *laddr = list_get_instance(link,
    372                     ethip_link_addr_t, addr_list);
    373 
    374                 if (addr->ipv4 == laddr->addr.ipv4)
     448                    ethip_link_addr_t, link);
     449               
     450                if (inet_addr_compare(addr, &laddr->addr))
    375451                        return laddr;
    376452        }
    377 
     453       
    378454        return NULL;
    379455}

  • uspace/srv/net/ethip/ethip_nic.h

    rf2c19b0 r03c971f  
    3939
    4040#include <ipc/loc.h>
     41#include <inet/addr.h>
    4142#include "ethip.h"
    4243
    … …  
    4445extern ethip_nic_t *ethip_nic_find_by_iplink_sid(service_id_t);
    4546extern int ethip_nic_send(ethip_nic_t *, void *, size_t);
    46 extern int ethip_nic_addr_add(ethip_nic_t *, iplink_srv_addr_t *);
    47 extern int ethip_nic_addr_remove(ethip_nic_t *, iplink_srv_addr_t *);
    48 extern ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *,
    49     iplink_srv_addr_t *);
     47extern int ethip_nic_addr_add(ethip_nic_t *, inet_addr_t *);
     48extern int ethip_nic_addr_remove(ethip_nic_t *, inet_addr_t *);
     49extern ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *, inet_addr_t *);
    5050
    5151#endif

  • uspace/srv/net/ethip/pdu.c

    rf2c19b0 r03c971f  
    4646#include "pdu.h"
    4747
    48 #define MAC48_BYTES 6
    49 
    5048/** Encode Ethernet PDU. */
    5149int eth_pdu_encode(eth_frame_t *frame, void **rdata, size_t *rsize)
    … …  
    6260
    6361        hdr = (eth_header_t *)data;
    64         mac48_encode(&frame->src, hdr->src);
    65         mac48_encode(&frame->dest, hdr->dest);
     62        addr48(frame->src, hdr->src);
     63        addr48(frame->dest, hdr->dest);
    6664        hdr->etype_len = host2uint16_t_be(frame->etype_len);
    6765
    … …  
    6967            frame->size);
    7068
    71         log_msg(LOG_DEFAULT, LVL_DEBUG, "Encoding Ethernet frame "
    72             "src=%" PRIx64 " dest=%" PRIx64 " etype=%x",
    73             frame->src.addr, frame->dest.addr, frame->etype_len);
    7469        log_msg(LOG_DEFAULT, LVL_DEBUG, "Encoded Ethernet frame (%zu bytes)", size);
    7570
    … …  
    9893                return ENOMEM;
    9994
    100         mac48_decode(hdr->src, &frame->src);
    101         mac48_decode(hdr->dest, &frame->dest);
     95        addr48(hdr->src, frame->src);
     96        addr48(hdr->dest, frame->dest);
    10297        frame->etype_len = uint16_t_be2host(hdr->etype_len);
    10398
    … …  
    105100            frame->size);
    106101
    107         log_msg(LOG_DEFAULT, LVL_DEBUG, "Decoding Ethernet frame "
    108             "src=%" PRIx64 " dest=%" PRIx64 " etype=%x",
    109             frame->src.addr, frame->dest.addr, frame->etype_len);
    110102        log_msg(LOG_DEFAULT, LVL_DEBUG, "Decoded Ethernet frame payload (%zu bytes)", frame->size);
    111103
    112104        return EOK;
    113 }
    114 
    115 void mac48_encode(mac48_addr_t *addr, void *buf)
    116 {
    117         uint64_t val;
    118         uint8_t *bbuf = (uint8_t *)buf;
    119         int i;
    120 
    121         val = addr->addr;
    122         for (i = 0; i < MAC48_BYTES; i++)
    123                 bbuf[i] = (val >> (8 * (MAC48_BYTES - i - 1))) & 0xff;
    124 }
    125 
    126 void mac48_decode(void *data, mac48_addr_t *addr)
    127 {
    128         uint64_t val;
    129         uint8_t *bdata = (uint8_t *)data;
    130         int i;
    131 
    132         val = 0;
    133         for (i = 0; i < MAC48_BYTES; i++)
    134                 val |= (uint64_t)bdata[i] << (8 * (MAC48_BYTES - i - 1));
    135 
    136         addr->addr = val;
    137105}
    138106
    … …  
    168136        pfmt->proto_addr_size = IPV4_ADDR_SIZE;
    169137        pfmt->opcode = host2uint16_t_be(fopcode);
    170         mac48_encode(&packet->sender_hw_addr, pfmt->sender_hw_addr);
     138        addr48(packet->sender_hw_addr, pfmt->sender_hw_addr);
    171139        pfmt->sender_proto_addr =
    172             host2uint32_t_be(packet->sender_proto_addr.ipv4);
    173         mac48_encode(&packet->target_hw_addr, pfmt->target_hw_addr);
     140            host2uint32_t_be(packet->sender_proto_addr);
     141        addr48(packet->target_hw_addr, pfmt->target_hw_addr);
    174142        pfmt->target_proto_addr =
    175             host2uint32_t_be(packet->target_proto_addr.ipv4);
     143            host2uint32_t_be(packet->target_proto_addr);
    176144
    177145        *rdata = data;
    … …  
    227195        }
    228196
    229         mac48_decode(pfmt->sender_hw_addr, &packet->sender_hw_addr);
    230         packet->sender_proto_addr.ipv4 =
     197        addr48(pfmt->sender_hw_addr, packet->sender_hw_addr);
     198        packet->sender_proto_addr =
    231199            uint32_t_be2host(pfmt->sender_proto_addr);
    232         mac48_decode(pfmt->target_hw_addr, &packet->target_hw_addr);
    233         packet->target_proto_addr.ipv4 =
     200        addr48(pfmt->target_hw_addr, packet->target_hw_addr);
     201        packet->target_proto_addr =
    234202            uint32_t_be2host(pfmt->target_proto_addr);
    235203        log_msg(LOG_DEFAULT, LVL_DEBUG, "packet->tpa = %x\n", pfmt->target_proto_addr);
    … …  
    238206}
    239207
    240 
    241208/** @}
    242209 */

  • uspace/srv/net/ethip/pdu.h

    rf2c19b0 r03c971f  
    4242extern int eth_pdu_encode(eth_frame_t *, void **, size_t *);
    4343extern int eth_pdu_decode(void *, size_t, eth_frame_t *);
    44 extern void mac48_encode(mac48_addr_t *, void *);
    45 extern void mac48_decode(void *, mac48_addr_t *);
    4644extern int arp_pdu_encode(arp_eth_packet_t *, void **, size_t *);
    4745extern int arp_pdu_decode(void *, size_t, arp_eth_packet_t *);
    48 
    4946
    5047#endif

  • uspace/srv/net/ethip/std.h

    rf2c19b0 r03c971f  
    3939
    4040#include <sys/types.h>
     41#include <inet/addr.h>
    4142
    42 #define ETH_ADDR_SIZE 6
    43 #define IPV4_ADDR_SIZE 4
    44 #define ETH_FRAME_MIN_SIZE 60
     43#define ETH_ADDR_SIZE       6
     44#define IPV4_ADDR_SIZE      4
     45#define ETH_FRAME_MIN_SIZE  60
    4546
    4647/** Ethernet frame header */
    4748typedef struct {
    4849        /** Destination Address */
    49         uint8_t dest[ETH_ADDR_SIZE];
     50        addr48_t dest;
    5051        /** Source Address */
    51         uint8_t src[ETH_ADDR_SIZE];
     52        addr48_t src;
    5253        /** Ethertype or Length */
    5354        uint16_t etype_len;
    … …  
    6768        uint16_t opcode;
    6869        /** Sender hardware address */
    69         uint8_t sender_hw_addr[ETH_ADDR_SIZE];
     70        addr48_t sender_hw_addr;
    7071        /** Sender protocol address */
    71         uint32_t sender_proto_addr;
     72        addr32_t sender_proto_addr;
    7273        /** Target hardware address */
    73         uint8_t target_hw_addr[ETH_ADDR_SIZE];
     74        addr48_t target_hw_addr;
    7475        /** Target protocol address */
    75         uint32_t target_proto_addr;
     76        addr32_t target_proto_addr;
    7677} __attribute__((packed)) arp_eth_packet_fmt_t;
    7778
    … …  
    8788/** IP Ethertype */
    8889enum ether_type {
    89         ETYPE_ARP = 0x0806,
    90         ETYPE_IP  = 0x0800
     90        ETYPE_ARP  = 0x0806,
     91        ETYPE_IP   = 0x0800,
     92        ETYPE_IPV6 = 0x86DD
    9193};
    92 
    9394
    9495#endif

  • uspace/srv/net/inetsrv/Makefile

    rf2c19b0 r03c971f  
    3333        addrobj.c \
    3434        icmp.c \
     35        icmpv6.c \
    3536        inetsrv.c \
    3637        inet_link.c \
    37         inet_util.c \
    3838        inetcfg.c \
    3939        inetping.c \
     40        inetping6.c \
     41        ndp.c \
     42        ntrans.c \
    4043        pdu.c \
    4144        reass.c \

  • uspace/srv/net/inetsrv/addrobj.c

    rf2c19b0 r03c971f  
    4242#include <stdlib.h>
    4343#include <str.h>
    44 
     44#include <net/socket_codes.h>
    4545#include "addrobj.h"
    4646#include "inetsrv.h"
    4747#include "inet_link.h"
    48 #include "inet_util.h"
     48#include "ndp.h"
    4949
    5050static inet_addrobj_t *inet_addrobj_find_by_name_locked(const char *, inet_link_t *);
    … …  
    106106/** Find address object matching address @a addr.
    107107 *
    108  * @param addr  Address
    109  * @oaram find  iaf_net to find network (using mask),
    110  *              iaf_addr to find local address (exact match)
     108 * @param addr Address
     109 * @oaram find iaf_net to find network (using mask),
     110 *             iaf_addr to find local address (exact match)
     111 *
    111112 */
    112113inet_addrobj_t *inet_addrobj_find(inet_addr_t *addr, inet_addrobj_find_t find)
    113114{
    114         uint32_t mask;
    115 
    116         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find(%x)", (unsigned)addr->ipv4);
    117 
    118         fibril_mutex_lock(&addr_list_lock);
    119 
     115        fibril_mutex_lock(&addr_list_lock);
     116       
    120117        list_foreach(addr_list, link) {
    121118                inet_addrobj_t *naddr = list_get_instance(link,
    122119                    inet_addrobj_t, addr_list);
    123 
    124                 mask = inet_netmask(naddr->naddr.bits);
    125                 if ((naddr->naddr.ipv4 & mask) == (addr->ipv4 & mask)) {
    126                         fibril_mutex_unlock(&addr_list_lock);
    127                         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: found %p",
    128                             naddr);
    129                         return naddr;
     120               
     121                switch (find) {
     122                case iaf_net:
     123                        if (inet_naddr_compare_mask(&naddr->naddr, addr)) {
     124                                fibril_mutex_unlock(&addr_list_lock);
     125                                log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: found %p",
     126                                    naddr);
     127                                return naddr;
     128                        }
     129                        break;
     130                case iaf_addr:
     131                        if (inet_naddr_compare(&naddr->naddr, addr)) {
     132                                fibril_mutex_unlock(&addr_list_lock);
     133                                log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: found %p",
     134                                    naddr);
     135                                return naddr;
     136                        }
     137                        break;
    130138                }
    131139        }
    132 
     140       
    133141        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: Not found");
    134142        fibril_mutex_unlock(&addr_list_lock);
    135 
     143       
    136144        return NULL;
    137145}
    … …  
    218226{
    219227        inet_addr_t lsrc_addr;
    220         inet_addr_t *ldest_addr;
    221 
    222         lsrc_addr.ipv4 = addr->naddr.ipv4;
    223         ldest_addr = ldest;
    224 
    225         return inet_link_send_dgram(addr->ilink, &lsrc_addr, ldest_addr, dgram,
    226             proto, ttl, df);
     228        inet_naddr_addr(&addr->naddr, &lsrc_addr);
     229       
     230        addr32_t lsrc_v4;
     231        addr128_t lsrc_v6;
     232        uint16_t lsrc_af = inet_addr_get(&lsrc_addr, &lsrc_v4, &lsrc_v6);
     233       
     234        addr32_t ldest_v4;
     235        addr128_t ldest_v6;
     236        uint16_t ldest_af = inet_addr_get(ldest, &ldest_v4, &ldest_v6);
     237       
     238        if (lsrc_af != ldest_af)
     239                return EINVAL;
     240       
     241        int rc;
     242        addr48_t ldest_mac;
     243       
     244        switch (ldest_af) {
     245        case AF_INET:
     246                return inet_link_send_dgram(addr->ilink, lsrc_v4, ldest_v4,
     247                    dgram, proto, ttl, df);
     248        case AF_INET6:
     249                /*
     250                 * Translate local destination IPv6 address.
     251                 */
     252                rc = ndp_translate(lsrc_v6, ldest_v6, ldest_mac, addr->ilink);
     253                if (rc != EOK)
     254                        return rc;
     255               
     256                return inet_link_send_dgram6(addr->ilink, ldest_mac, dgram,
     257                    proto, ttl, df);
     258        }
     259       
     260        return ENOTSUP;
    227261}
    228262

  • uspace/srv/net/inetsrv/addrobj.h

    rf2c19b0 r03c971f  
    5959extern int inet_addrobj_get_id_list(sysarg_t **, size_t *);
    6060
    61 
    6261#endif
    6362

  • uspace/srv/net/inetsrv/icmp.c

    rf2c19b0 r03c971f  
    4040#include <mem.h>
    4141#include <stdlib.h>
    42 
     42#include <net/socket_codes.h>
    4343#include "icmp.h"
    4444#include "icmp_std.h"
    … …  
    120120static int icmp_recv_echo_reply(inet_dgram_t *dgram)
    121121{
    122         icmp_echo_t *reply;
    123         inetping_sdu_t sdu;
    124         uint16_t ident;
    125 
    126122        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv_echo_reply()");
    127 
     123       
    128124        if (dgram->size < sizeof(icmp_echo_t))
    129125                return EINVAL;
    130 
    131         reply = (icmp_echo_t *)dgram->data;
    132 
    133         sdu.src = dgram->src;
    134         sdu.dest = dgram->dest;
     126       
     127        icmp_echo_t *reply = (icmp_echo_t *) dgram->data;
     128       
     129        inetping_sdu_t sdu;
     130       
     131        uint16_t family = inet_addr_get(&dgram->src, &sdu.src, NULL);
     132        if (family != AF_INET)
     133                return EINVAL;
     134       
     135        family = inet_addr_get(&dgram->dest, &sdu.dest, NULL);
     136        if (family != AF_INET)
     137                return EINVAL;
     138       
    135139        sdu.seq_no = uint16_t_be2host(reply->seq_no);
    136140        sdu.data = reply + sizeof(icmp_echo_t);
    137141        sdu.size = dgram->size - sizeof(icmp_echo_t);
    138         ident = uint16_t_be2host(reply->ident);
     142       
     143        uint16_t ident = uint16_t_be2host(reply->ident);
    139144
    140145        return inetping_recv(ident, &sdu);
    … …  
    143148int icmp_ping_send(uint16_t ident, inetping_sdu_t *sdu)
    144149{
    145         inet_dgram_t dgram;
    146         icmp_echo_t *request;
    147         void *rdata;
    148         size_t rsize;
    149         uint16_t checksum;
    150         int rc;
    151 
    152         rsize = sizeof(icmp_echo_t) + sdu->size;
    153         rdata = calloc(rsize, 1);
     150        size_t rsize = sizeof(icmp_echo_t) + sdu->size;
     151        void *rdata = calloc(rsize, 1);
    154152        if (rdata == NULL)
    155153                return ENOMEM;
    156 
    157         request = (icmp_echo_t *)rdata;
    158 
     154       
     155        icmp_echo_t *request = (icmp_echo_t *) rdata;
     156       
    159157        request->type = ICMP_ECHO_REQUEST;
    160158        request->code = 0;
    … …  
    162160        request->ident = host2uint16_t_be(ident);
    163161        request->seq_no = host2uint16_t_be(sdu->seq_no);
    164 
     162       
    165163        memcpy(rdata + sizeof(icmp_echo_t), sdu->data, sdu->size);
    166 
    167         checksum = inet_checksum_calc(INET_CHECKSUM_INIT, rdata, rsize);
     164       
     165        uint16_t checksum = inet_checksum_calc(INET_CHECKSUM_INIT, rdata, rsize);
    168166        request->checksum = host2uint16_t_be(checksum);
    169 
    170         dgram.src = sdu->src;
    171         dgram.dest = sdu->dest;
     167       
     168        inet_dgram_t dgram;
     169       
     170        inet_addr_set(sdu->src, &dgram.src);
     171        inet_addr_set(sdu->dest, &dgram.dest);
     172       
    172173        dgram.tos = ICMP_TOS;
    173174        dgram.data = rdata;
    174175        dgram.size = rsize;
    175 
    176         rc = inet_route_packet(&dgram, IP_PROTO_ICMP, INET_TTL_MAX, 0);
    177 
     176       
     177        int rc = inet_route_packet(&dgram, IP_PROTO_ICMP, INET_TTL_MAX, 0);
     178       
    178179        free(rdata);
    179180        return rc;

  • uspace/srv/net/inetsrv/icmp_std.h

    rf2c19b0 r03c971f  
    4343
    4444/** Type of service used for ICMP */
    45 #define ICMP_TOS        0
     45#define ICMP_TOS  0
    4646
    4747/** ICMP message type */

  • uspace/srv/net/inetsrv/icmpv6.h

    rf2c19b0 r03c971f  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Antonin Steinhauser
    33 * All rights reserved.
    44 *
    … …  
    3535 */
    3636
    37 #include <assert.h>
    38 #include <bitops.h>
    39 #include <sys/types.h>
    40 #include "inet_util.h"
     37#ifndef ICMPV6_H_
     38#define ICMPV6_H_
    4139
    42 uint32_t inet_netmask(int bits)
    43 {
    44         assert(bits >= 0);
    45         assert(bits < 32);
     40#include "inetsrv.h"
    4641
    47         if (bits == 0)
    48                 return 0;
    49         else
    50                 return BIT_RANGE(uint32_t, 31, 31 - (bits - 1));
    51 }
     42extern int icmpv6_recv(inet_dgram_t *);
     43extern int icmpv6_ping_send(uint16_t, inetping6_sdu_t *);
     44
     45#endif
    5246
    5347/** @}

  • uspace/srv/net/inetsrv/inet_link.c

    rf2c19b0 r03c971f  
    4343#include <stdlib.h>
    4444#include <str.h>
    45 
     45#include <net/socket_codes.h>
    4646#include "addrobj.h"
    4747#include "inetsrv.h"
    … …  
    4949#include "pdu.h"
    5050
    51 static int inet_link_open(service_id_t sid);
    52 static int inet_iplink_recv(iplink_t *ilink, iplink_sdu_t *sdu);
     51static bool first_link = true;
     52static bool first_link6 = true;
     53
     54static FIBRIL_MUTEX_INITIALIZE(ip_ident_lock);
     55static uint16_t ip_ident = 0;
     56
     57static int inet_link_open(service_id_t);
     58static int inet_iplink_recv(iplink_t *, iplink_recv_sdu_t *, uint16_t);
    5359
    5460static iplink_ev_ops_t inet_iplink_ev_ops = {
    … …  
    5965static FIBRIL_MUTEX_INITIALIZE(inet_discovery_lock);
    6066
    61 static int inet_iplink_recv(iplink_t *iplink, iplink_sdu_t *sdu)
    62 {
     67static addr128_t link_local_node_ip =
     68    {0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xfe, 0, 0, 0};
     69
     70static void inet_link_local_node_ip(addr48_t mac_addr,
     71    addr128_t ip_addr)
     72{
     73        memcpy(ip_addr, link_local_node_ip, 16);
     74       
     75        ip_addr[8] = mac_addr[0] ^ 0x02;
     76        ip_addr[9] = mac_addr[1];
     77        ip_addr[10] = mac_addr[2];
     78        ip_addr[13] = mac_addr[3];
     79        ip_addr[14] = mac_addr[4];
     80        ip_addr[15] = mac_addr[5];
     81}
     82
     83static int inet_iplink_recv(iplink_t *iplink, iplink_recv_sdu_t *sdu, uint16_t af)
     84{
     85        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_recv()");
     86       
     87        int rc;
    6388        inet_packet_t packet;
    64         int rc;
    65 
    66         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_recv()");
    67         rc = inet_pdu_decode(sdu->data, sdu->size, &packet);
     89       
     90        switch (af) {
     91        case AF_INET:
     92                rc = inet_pdu_decode(sdu->data, sdu->size, &packet);
     93                break;
     94        case AF_INET6:
     95                rc = inet_pdu_decode6(sdu->data, sdu->size, &packet);
     96                break;
     97        default:
     98                log_msg(LOG_DEFAULT, LVL_DEBUG, "invalid address family");
     99                return EINVAL;
     100        }
     101       
    68102        if (rc != EOK) {
    69103                log_msg(LOG_DEFAULT, LVL_DEBUG, "failed decoding PDU");
    70104                return rc;
    71105        }
    72 
     106       
    73107        log_msg(LOG_DEFAULT, LVL_DEBUG, "call inet_recv_packet()");
    74108        rc = inet_recv_packet(&packet);
    75109        log_msg(LOG_DEFAULT, LVL_DEBUG, "call inet_recv_packet -> %d", rc);
    76110        free(packet.data);
    77 
     111       
    78112        return rc;
    79113}
    … …  
    147181        if (ilink->svc_name != NULL)
    148182                free(ilink->svc_name);
     183       
    149184        free(ilink);
    150185}
    … …  
    153188{
    154189        inet_link_t *ilink;
    155         iplink_addr_t iaddr;
     190        inet_addr_t iaddr;
    156191        int rc;
    157192
    … …  
    189224                goto error;
    190225        }
     226       
     227        /*
     228         * Get the MAC address of the link. If the link has a MAC
     229         * address, we assume that it supports NDP.
     230         */
     231        rc = iplink_get_mac48(ilink->iplink, &ilink->mac);
     232        ilink->mac_valid = (rc == EOK);
    191233
    192234        log_msg(LOG_DEFAULT, LVL_DEBUG, "Opened IP link '%s'", ilink->svc_name);
    193235        list_append(&ilink->link_list, &inet_link_list);
    194236
    195         inet_addrobj_t *addr;
    196 
    197         static int first = 1;
    198         /* XXX For testing: set static IP address 10.0.2.15/24 */
    199         addr = inet_addrobj_new();
    200         if (first) {
    201                 addr->naddr.ipv4 = (127 << 24) + (0 << 16) + (0 << 8) + 1;
    202                 first = 0;
     237        inet_addrobj_t *addr = NULL;
     238       
     239        if (first_link) {
     240                addr = inet_addrobj_new();
     241               
     242                inet_naddr(&addr->naddr, 127, 0, 0, 1, 24);
     243                first_link = false;
    203244        } else {
    204                 addr->naddr.ipv4 = (10 << 24) + (0 << 16) + (2 << 8) + 15;
    205         }
    206         addr->naddr.bits = 24;
    207         addr->ilink = ilink;
    208         addr->name = str_dup("v4a");
    209         rc = inet_addrobj_add(addr);
    210         if (rc != EOK) {
    211                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed setting IP address on internet link.");
    212                 inet_addrobj_delete(addr);
    213                 /* XXX Roll back */
    214                 return rc;
    215         }
    216 
    217         iaddr.ipv4 = addr->naddr.ipv4;
    218         rc = iplink_addr_add(ilink->iplink, &iaddr);
    219         if (rc != EOK) {
    220                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed setting IP address on internet link.");
    221                 inet_addrobj_remove(addr);
    222                 inet_addrobj_delete(addr);
    223                 /* XXX Roll back */
    224                 return rc;
    225         }
    226 
     245                /*
     246                 * FIXME
     247                 * Setting static IPv4 address for testing purposes:
     248                 * 10.0.2.15/24
     249                 */
     250                addr = inet_addrobj_new();
     251               
     252                inet_naddr(&addr->naddr, 10, 0, 2, 15, 24);
     253        }
     254       
     255        if (addr != NULL) {
     256                addr->ilink = ilink;
     257                addr->name = str_dup("v4a");
     258               
     259                rc = inet_addrobj_add(addr);
     260                if (rc == EOK) {
     261                        inet_naddr_addr(&addr->naddr, &iaddr);
     262                        rc = iplink_addr_add(ilink->iplink, &iaddr);
     263                        if (rc != EOK) {
     264                                log_msg(LOG_DEFAULT, LVL_ERROR,
     265                                    "Failed setting IPv4 address on internet link.");
     266                                inet_addrobj_remove(addr);
     267                                inet_addrobj_delete(addr);
     268                        }
     269                } else {
     270                        log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding IPv4 address.");
     271                        inet_addrobj_delete(addr);
     272                }
     273        }
     274       
     275        inet_addrobj_t *addr6 = NULL;
     276       
     277        if (first_link6) {
     278                addr6 = inet_addrobj_new();
     279               
     280                inet_naddr6(&addr6->naddr, 0, 0, 0, 0, 0, 0, 0, 1, 128);
     281                first_link6 = false;
     282        } else if (ilink->mac_valid) {
     283                addr6 = inet_addrobj_new();
     284               
     285                addr128_t link_local;
     286                inet_link_local_node_ip(ilink->mac, link_local);
     287               
     288                inet_naddr_set6(link_local, 64, &addr6->naddr);
     289        }
     290       
     291        if (addr6 != NULL) {
     292                addr6->ilink = ilink;
     293                addr6->name = str_dup("v6a");
     294               
     295                rc = inet_addrobj_add(addr6);
     296                if (rc == EOK) {
     297                        inet_naddr_addr(&addr6->naddr, &iaddr);
     298                        rc = iplink_addr_add(ilink->iplink, &iaddr);
     299                        if (rc != EOK) {
     300                                log_msg(LOG_DEFAULT, LVL_ERROR,
     301                                    "Failed setting IPv6 address on internet link.");
     302                                inet_addrobj_remove(addr6);
     303                                inet_addrobj_delete(addr6);
     304                        }
     305                } else {
     306                        log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding IPv6 address.");
     307                        inet_addrobj_delete(addr6);
     308                }
     309        }
     310       
    227311        return EOK;
    228 
     312       
    229313error:
    230314        if (ilink->iplink != NULL)
    231315                iplink_close(ilink->iplink);
     316       
    232317        inet_link_delete(ilink);
    233318        return rc;
    … …  
    253338}
    254339
    255 /** Send datagram over Internet link */
    256 int inet_link_send_dgram(inet_link_t *ilink, inet_addr_t *lsrc,
    257     inet_addr_t *ldest, inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
    258 {
    259         iplink_sdu_t sdu;
    260         inet_packet_t packet;
    261         int rc;
    262         size_t offs, roffs;
    263 
     340/** Send IPv4 datagram over Internet link
     341 *
     342 * @param ilink Internet link
     343 * @param lsrc  Source IPv4 address
     344 * @param ldest Destination IPv4 address
     345 * @param dgram IPv4 datagram body
     346 * @param proto Protocol
     347 * @param ttl   Time-to-live
     348 * @param df    Do-not-Fragment flag
     349 *
     350 * @return EOK on success
     351 * @return ENOMEM when not enough memory to create the datagram
     352 * @return ENOTSUP if networking mode is not supported
     353 *
     354 */
     355int inet_link_send_dgram(inet_link_t *ilink, addr32_t lsrc, addr32_t ldest,
     356    inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
     357{
     358        addr32_t src_v4;
     359        uint16_t src_af = inet_addr_get(&dgram->src, &src_v4, NULL);
     360        if (src_af != AF_INET)
     361                return EINVAL;
     362       
     363        addr32_t dest_v4;
     364        uint16_t dest_af = inet_addr_get(&dgram->dest, &dest_v4, NULL);
     365        if (dest_af != AF_INET)
     366                return EINVAL;
     367       
    264368        /*
    265369         * Fill packet structure. Fragmentation is performed by
    266370         * inet_pdu_encode().
    267371         */
     372       
     373        iplink_sdu_t sdu;
     374       
     375        sdu.src = lsrc;
     376        sdu.dest = ldest;
     377       
     378        inet_packet_t packet;
     379       
    268380        packet.src = dgram->src;
    269381        packet.dest = dgram->dest;
    … …  
    271383        packet.proto = proto;
    272384        packet.ttl = ttl;
     385       
     386        /* Allocate identifier */
     387        fibril_mutex_lock(&ip_ident_lock);
     388        packet.ident = ++ip_ident;
     389        fibril_mutex_unlock(&ip_ident_lock);
     390       
    273391        packet.df = df;
    274392        packet.data = dgram->data;
    275393        packet.size = dgram->size;
    276 
    277         sdu.lsrc.ipv4 = lsrc->ipv4;
    278         sdu.ldest.ipv4 = ldest->ipv4;
    279 
    280         offs = 0;
     394       
     395        int rc;
     396        size_t offs = 0;
     397       
    281398        do {
    282399                /* Encode one fragment */
    283                 rc = inet_pdu_encode(&packet, offs, ilink->def_mtu, &sdu.data,
    284                     &sdu.size, &roffs);
     400               
     401                size_t roffs;
     402                rc = inet_pdu_encode(&packet, src_v4, dest_v4, offs, ilink->def_mtu,
     403                    &sdu.data, &sdu.size, &roffs);
    285404                if (rc != EOK)
    286405                        return rc;
    287 
     406               
    288407                /* Send the PDU */
    289408                rc = iplink_send(ilink->iplink, &sdu);
     409               
    290410                free(sdu.data);
    291 
    292411                offs = roffs;
    293412        } while (offs < packet.size);
    294 
     413       
     414        return rc;
     415}
     416
     417/** Send IPv6 datagram over Internet link
     418 *
     419 * @param ilink Internet link
     420 * @param ldest Destination MAC address
     421 * @param dgram IPv6 datagram body
     422 * @param proto Next header
     423 * @param ttl   Hop limit
     424 * @param df    Do-not-Fragment flag (unused)
     425 *
     426 * @return EOK on success
     427 * @return ENOMEM when not enough memory to create the datagram
     428 *
     429 */
     430int inet_link_send_dgram6(inet_link_t *ilink, addr48_t ldest,
     431    inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
     432{
     433        addr128_t src_v6;
     434        uint16_t src_af = inet_addr_get(&dgram->src, NULL, &src_v6);
     435        if (src_af != AF_INET6)
     436                return EINVAL;
     437       
     438        addr128_t dest_v6;
     439        uint16_t dest_af = inet_addr_get(&dgram->dest, NULL, &dest_v6);
     440        if (dest_af != AF_INET6)
     441                return EINVAL;
     442       
     443        iplink_sdu6_t sdu6;
     444        addr48(ldest, sdu6.dest);
     445       
     446        /*
     447         * Fill packet structure. Fragmentation is performed by
     448         * inet_pdu_encode6().
     449         */
     450       
     451        inet_packet_t packet;
     452       
     453        packet.src = dgram->src;
     454        packet.dest = dgram->dest;
     455        packet.tos = dgram->tos;
     456        packet.proto = proto;
     457        packet.ttl = ttl;
     458       
     459        /* Allocate identifier */
     460        fibril_mutex_lock(&ip_ident_lock);
     461        packet.ident = ++ip_ident;
     462        fibril_mutex_unlock(&ip_ident_lock);
     463       
     464        packet.df = df;
     465        packet.data = dgram->data;
     466        packet.size = dgram->size;
     467       
     468        int rc;
     469        size_t offs = 0;
     470       
     471        do {
     472                /* Encode one fragment */
     473               
     474                size_t roffs;
     475                rc = inet_pdu_encode6(&packet, src_v6, dest_v6, offs, ilink->def_mtu,
     476                    &sdu6.data, &sdu6.size, &roffs);
     477                if (rc != EOK)
     478                        return rc;
     479               
     480                /* Send the PDU */
     481                rc = iplink_send6(ilink->iplink, &sdu6);
     482               
     483                free(sdu6.data);
     484                offs = roffs;
     485        } while (offs < packet.size);
     486       
    295487        return rc;
    296488}

  • uspace/srv/net/inetsrv/inet_link.h

    rf2c19b0 r03c971f  
    4242
    4343extern int inet_link_discovery_start(void);
    44 extern int inet_link_send_dgram(inet_link_t *, inet_addr_t *,
    45     inet_addr_t *, inet_dgram_t *, uint8_t, uint8_t, int);
     44extern int inet_link_send_dgram(inet_link_t *, addr32_t,
     45    addr32_t, inet_dgram_t *, uint8_t, uint8_t, int);
     46extern int inet_link_send_dgram6(inet_link_t *, addr48_t, inet_dgram_t *,
     47    uint8_t, uint8_t, int);
    4648extern inet_link_t *inet_link_get_by_id(sysarg_t);
    4749

  • uspace/srv/net/inetsrv/inet_std.h

    rf2c19b0 r03c971f  
    4040#include <sys/types.h>
    4141
    42 /** Internet Datagram header (fixed part) */
     42#define IP6_NEXT_FRAGMENT  44
     43
     44/** IPv4 Datagram header (fixed part) */
    4345typedef struct {
    4446        /** Version, Internet Header Length */
    … …  
    4850        /** Total Length */
    4951        uint16_t tot_len;
    50         /** Identification */
     52        /** Identifier */
    5153        uint16_t id;
    5254        /** Flags, Fragment Offset */
    … …  
    9092};
    9193
     94/** Bits in ip6_header_fragment_t.offsmf */
     95enum flags_offsmt_bits {
     96        /** More fragments */
     97        OF_FLAG_M = 0,
     98        /** Fragment offset, highest bit */
     99        OF_FRAGOFF_h = 15,
     100        /** Fragment offset, lowest bit */
     101        OF_FRAGOFF_l = 3
     102};
     103
     104/** IPv6 Datagram header (fixed part) */
     105typedef struct {
     106        /** Version, Traffic class first 4 bits */
     107        uint8_t ver_tc;
     108        /** Traffic class (the rest), Flow label */
     109        uint8_t tc_fl[3];
     110        /* Payload length */
     111        uint16_t payload_len;
     112        /** Next header */
     113        uint8_t next;
     114        /** Hop limit */
     115        uint8_t hop_limit;
     116        /** Source address */
     117        uint8_t src_addr[16];
     118        /** Destination address */
     119        uint8_t dest_addr[16];
     120} ip6_header_t;
     121
     122/** IPv6 Datagram Fragment extension header */
     123typedef struct {
     124        /** Next header */
     125        uint8_t next;
     126        /** Reserved */
     127        uint8_t reserved;
     128        /** Fragmentation offset, reserved and M flag */
     129        uint16_t offsmf;
     130        /** Identifier */
     131        uint32_t id;
     132} ip6_header_fragment_t;
     133
    92134/** Fragment offset is expressed in units of 8 bytes */
    93135#define FRAG_OFFS_UNIT 8

  • uspace/srv/net/inetsrv/inetcfg.c

    rf2c19b0 r03c971f  
    5656        inet_link_t *ilink;
    5757        inet_addrobj_t *addr;
    58         iplink_addr_t iaddr;
     58        inet_addr_t iaddr;
    5959        int rc;
    6060
    … …  
    8282        }
    8383
    84         iaddr.ipv4 = addr->naddr.ipv4;
     84        inet_naddr_addr(&addr->naddr, &iaddr);
    8585        rc = iplink_addr_add(ilink->iplink, &iaddr);
    8686        if (rc != EOK) {
    … …  
    236236}
    237237
    238 static void inetcfg_addr_create_static_srv(ipc_callid_t callid,
    239     ipc_call_t *call)
    240 {
     238static void inetcfg_addr_create_static_srv(ipc_callid_t iid,
     239    ipc_call_t *icall)
     240{
     241        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()");
     242       
     243        sysarg_t link_id = IPC_GET_ARG1(*icall);
     244       
     245        ipc_callid_t callid;
     246        size_t size;
     247        if (!async_data_write_receive(&callid, &size)) {
     248                async_answer_0(callid, EINVAL);
     249                async_answer_0(iid, EINVAL);
     250                return;
     251        }
     252       
     253        if (size != sizeof(inet_naddr_t)) {
     254                async_answer_0(callid, EINVAL);
     255                async_answer_0(iid, EINVAL);
     256                return;
     257        }
     258       
     259        inet_naddr_t naddr;
     260        int rc = async_data_write_finalize(callid, &naddr, size);
     261        if (rc != EOK) {
     262                async_answer_0(callid, rc);
     263                async_answer_0(iid, rc);
     264                return;
     265        }
     266       
    241267        char *name;
    242         inet_naddr_t naddr;
    243         sysarg_t link_id;
    244         sysarg_t addr_id;
    245         int rc;
    246 
    247         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()");
    248 
    249268        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    250269            0, NULL);
    251270        if (rc != EOK) {
    252                 async_answer_0(callid, rc);
    253                 return;
    254         }
    255 
    256         naddr.ipv4 = IPC_GET_ARG1(*call);
    257         naddr.bits = IPC_GET_ARG2(*call);
    258         link_id    = IPC_GET_ARG3(*call);
    259 
    260         addr_id = 0;
     271                async_answer_0(iid, rc);
     272                return;
     273        }
     274       
     275        sysarg_t addr_id = 0;
    261276        rc = inetcfg_addr_create_static(name, &naddr, link_id, &addr_id);
    262277        free(name);
    263         async_answer_1(callid, rc, addr_id);
     278        async_answer_1(iid, rc, addr_id);
    264279}
    265280
    … …  
    277292}
    278293
    279 static void inetcfg_addr_get_srv(ipc_callid_t callid, ipc_call_t *call)
    280 {
    281         ipc_callid_t rcallid;
    282         size_t max_size;
    283 
    284         sysarg_t addr_id;
     294static void inetcfg_addr_get_srv(ipc_callid_t iid, ipc_call_t *icall)
     295{
     296        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
     297       
     298        sysarg_t addr_id = IPC_GET_ARG1(*icall);
     299       
    285300        inet_addr_info_t ainfo;
    286         int rc;
    287 
    288         addr_id = IPC_GET_ARG1(*call);
    289         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
    290 
    291         ainfo.naddr.ipv4 = 0;
    292         ainfo.naddr.bits = 0;
     301       
     302        inet_naddr_any(&ainfo.naddr);
    293303        ainfo.ilink = 0;
    294304        ainfo.name = NULL;
    295 
    296         if (!async_data_read_receive(&rcallid, &max_size)) {
    297                 async_answer_0(rcallid, EREFUSED);
    298                 async_answer_0(callid, EREFUSED);
    299                 return;
    300         }
    301 
    302         rc = inetcfg_addr_get(addr_id, &ainfo);
    303         if (rc != EOK) {
    304                 async_answer_0(callid, rc);
    305                 return;
    306         }
    307 
    308         sysarg_t retval = async_data_read_finalize(rcallid, ainfo.name,
    309             min(max_size, str_size(ainfo.name)));
     305       
     306        int rc = inetcfg_addr_get(addr_id, &ainfo);
     307        if (rc != EOK) {
     308                async_answer_0(iid, rc);
     309                return;
     310        }
     311       
     312        ipc_callid_t callid;
     313        size_t size;
     314        if (!async_data_read_receive(&callid, &size)) {
     315                async_answer_0(callid, EREFUSED);
     316                async_answer_0(iid, EREFUSED);
     317                return;
     318        }
     319       
     320        if (size != sizeof(inet_naddr_t)) {
     321                async_answer_0(callid, EINVAL);
     322                async_answer_0(iid, EINVAL);
     323                return;
     324        }
     325       
     326        rc = async_data_read_finalize(callid, &ainfo.naddr, size);
     327        if (rc != EOK) {
     328                async_answer_0(callid, rc);
     329                async_answer_0(iid, rc);
     330                return;
     331        }
     332       
     333        if (!async_data_read_receive(&callid, &size)) {
     334                async_answer_0(callid, EREFUSED);
     335                async_answer_0(iid, EREFUSED);
     336                return;
     337        }
     338       
     339        rc = async_data_read_finalize(callid, ainfo.name,
     340            min(size, str_size(ainfo.name)));
    310341        free(ainfo.name);
    311 
    312         async_answer_3(callid, retval, ainfo.naddr.ipv4, ainfo.naddr.bits,
    313             ainfo.ilink);
     342       
     343        if (rc != EOK) {
     344                async_answer_0(callid, rc);
     345                async_answer_0(iid, rc);
     346                return;
     347        }
     348       
     349        async_answer_1(iid, (sysarg_t) rc, ainfo.ilink);
    314350}
    315351
    … …  
    372408}
    373409
    374 
    375410static void inetcfg_get_link_list_srv(ipc_callid_t callid, ipc_call_t *call)
    376411{
    … …  
    473508}
    474509
    475 static void inetcfg_sroute_create_srv(ipc_callid_t callid,
    476     ipc_call_t *call)
    477 {
     510static void inetcfg_sroute_create_srv(ipc_callid_t iid,
     511    ipc_call_t *icall)
     512{
     513        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
     514
     515        ipc_callid_t callid;
     516        size_t size;
     517        if (!async_data_write_receive(&callid, &size)) {
     518                async_answer_0(callid, EINVAL);
     519                async_answer_0(iid, EINVAL);
     520                return;
     521        }
     522       
     523        if (size != sizeof(inet_naddr_t)) {
     524                async_answer_0(callid, EINVAL);
     525                async_answer_0(iid, EINVAL);
     526                return;
     527        }
     528       
     529        inet_naddr_t dest;
     530        int rc = async_data_write_finalize(callid, &dest, size);
     531        if (rc != EOK) {
     532                async_answer_0(callid, rc);
     533                async_answer_0(iid, rc);
     534                return;
     535        }
     536       
     537        if (!async_data_write_receive(&callid, &size)) {
     538                async_answer_0(callid, EINVAL);
     539                async_answer_0(iid, EINVAL);
     540                return;
     541        }
     542       
     543        if (size != sizeof(inet_addr_t)) {
     544                async_answer_0(callid, EINVAL);
     545                async_answer_0(iid, EINVAL);
     546                return;
     547        }
     548       
     549        inet_addr_t router;
     550        rc = async_data_write_finalize(callid, &router, size);
     551        if (rc != EOK) {
     552                async_answer_0(callid, rc);
     553                async_answer_0(iid, rc);
     554                return;
     555        }
     556       
    478557        char *name;
    479         inet_naddr_t dest;
    480         inet_addr_t router;
    481         sysarg_t sroute_id;
    482         int rc;
    483 
    484         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
    485 
    486558        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
    487559            0, NULL);
    488560        if (rc != EOK) {
    489                 async_answer_0(callid, rc);
    490                 return;
    491         }
    492 
    493         dest.ipv4   = IPC_GET_ARG1(*call);
    494         dest.bits   = IPC_GET_ARG2(*call);
    495         router.ipv4 = IPC_GET_ARG3(*call);
    496 
    497         sroute_id = 0;
     561                async_answer_0(iid, rc);
     562                return;
     563        }
     564       
     565        sysarg_t sroute_id = 0;
    498566        rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id);
    499567        free(name);
    500         async_answer_1(callid, rc, sroute_id);
     568        async_answer_1(iid, rc, sroute_id);
    501569}
    502570
    … …  
    514582}
    515583
    516 static void inetcfg_sroute_get_srv(ipc_callid_t callid, ipc_call_t *call)
    517 {
    518         ipc_callid_t rcallid;
    519         size_t max_size;
    520 
    521         sysarg_t sroute_id;
     584static void inetcfg_sroute_get_srv(ipc_callid_t iid, ipc_call_t *icall)
     585{
     586        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
     587       
     588        sysarg_t sroute_id = IPC_GET_ARG1(*icall);
     589       
    522590        inet_sroute_info_t srinfo;
    523         int rc;
    524 
    525         sroute_id = IPC_GET_ARG1(*call);
    526         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
    527 
    528         srinfo.dest.ipv4 = 0;
    529         srinfo.dest.bits = 0;
    530         srinfo.router.ipv4 = 0;
     591       
     592        inet_naddr_any(&srinfo.dest);
     593        inet_addr_any(&srinfo.router);
    531594        srinfo.name = NULL;
    532 
    533         if (!async_data_read_receive(&rcallid, &max_size)) {
    534                 async_answer_0(rcallid, EREFUSED);
    535                 async_answer_0(callid, EREFUSED);
    536                 return;
    537         }
    538 
    539         rc = inetcfg_sroute_get(sroute_id, &srinfo);
    540         if (rc != EOK) {
    541                 async_answer_0(callid, rc);
    542                 return;
    543         }
    544 
    545         sysarg_t retval = async_data_read_finalize(rcallid, srinfo.name,
    546             min(max_size, str_size(srinfo.name)));
     595       
     596        int rc = inetcfg_sroute_get(sroute_id, &srinfo);
     597        if (rc != EOK) {
     598                async_answer_0(iid, rc);
     599                return;
     600        }
     601       
     602        ipc_callid_t callid;
     603        size_t size;
     604        if (!async_data_read_receive(&callid, &size)) {
     605                async_answer_0(callid, EREFUSED);
     606                async_answer_0(iid, EREFUSED);
     607                return;
     608        }
     609       
     610        if (size != sizeof(inet_naddr_t)) {
     611                async_answer_0(callid, EINVAL);
     612                async_answer_0(iid, EINVAL);
     613                return;
     614        }
     615       
     616        rc = async_data_read_finalize(callid, &srinfo.dest, size);
     617        if (rc != EOK) {
     618                async_answer_0(callid, rc);
     619                async_answer_0(iid, rc);
     620                return;
     621        }
     622       
     623        if (!async_data_read_receive(&callid, &size)) {
     624                async_answer_0(callid, EREFUSED);
     625                async_answer_0(iid, EREFUSED);
     626                return;
     627        }
     628       
     629        if (size != sizeof(inet_addr_t)) {
     630                async_answer_0(callid, EINVAL);
     631                async_answer_0(iid, EINVAL);
     632                return;
     633        }
     634       
     635        rc = async_data_read_finalize(callid, &srinfo.router, size);
     636        if (rc != EOK) {
     637                async_answer_0(callid, rc);
     638                async_answer_0(iid, rc);
     639                return;
     640        }
     641       
     642        if (!async_data_read_receive(&callid, &size)) {
     643                async_answer_0(callid, EREFUSED);
     644                async_answer_0(iid, EREFUSED);
     645                return;
     646        }
     647       
     648        rc = async_data_read_finalize(callid, srinfo.name,
     649            min(size, str_size(srinfo.name)));
    547650        free(srinfo.name);
    548 
    549         async_answer_3(callid, retval, srinfo.dest.ipv4, srinfo.dest.bits,
    550             srinfo.router.ipv4);
     651       
     652        async_answer_0(iid, (sysarg_t) rc);
    551653}
    552654

  • uspace/srv/net/inetsrv/inetping.c

    rf2c19b0 r03c971f  
    4343#include <stdlib.h>
    4444#include <sys/types.h>
    45 
     45#include <net/socket_codes.h>
    4646#include "icmp.h"
    4747#include "icmp_std.h"
    … …  
    5555static uint16_t inetping_ident = 0;
    5656
    57 static inetping_client_t *inetping_client_find(uint16_t);
    58 
    5957static int inetping_send(inetping_client_t *client, inetping_sdu_t *sdu)
    6058{
    … …  
    6260}
    6361
    64 static int inetping_get_srcaddr(inetping_client_t *client, inet_addr_t *remote,
    65     inet_addr_t *local)
    66 {
    67         return inet_get_srcaddr(remote, ICMP_TOS, local);
     62static int inetping_get_srcaddr(inetping_client_t *client, addr32_t remote,
     63    addr32_t *local)
     64{
     65        inet_addr_t remote_addr;
     66        inet_addr_set(remote, &remote_addr);
     67       
     68        inet_addr_t local_addr;
     69        int rc = inet_get_srcaddr(&remote_addr, ICMP_TOS, &local_addr);
     70        if (rc != EOK)
     71                return rc;
     72       
     73        uint16_t family = inet_addr_get(&local_addr, local, NULL);
     74        if (family != AF_INET)
     75                return EINVAL;
     76       
     77        return EOK;
     78}
     79
     80static inetping_client_t *inetping_client_find(uint16_t ident)
     81{
     82        fibril_mutex_lock(&client_list_lock);
     83       
     84        list_foreach(client_list, link) {
     85                inetping_client_t *client = list_get_instance(link,
     86                    inetping_client_t, client_list);
     87               
     88                if (client->ident == ident) {
     89                        fibril_mutex_unlock(&client_list_lock);
     90                        return client;
     91                }
     92        }
     93       
     94        fibril_mutex_unlock(&client_list_lock);
     95        return NULL;
    6896}
    6997
    7098int inetping_recv(uint16_t ident, inetping_sdu_t *sdu)
    7199{
    72         inetping_client_t *client;
    73         async_exch_t *exch;
    74         ipc_call_t answer;
    75 
    76         client = inetping_client_find(ident);
     100        inetping_client_t *client = inetping_client_find(ident);
    77101        if (client == NULL) {
    78102                log_msg(LOG_DEFAULT, LVL_DEBUG, "Unknown ICMP ident. Dropping.");
    79103                return ENOENT;
    80104        }
    81 
    82         exch = async_exchange_begin(client->sess);
    83 
    84         aid_t req = async_send_3(exch, INETPING_EV_RECV, sdu->src.ipv4,
    85             sdu->dest.ipv4, sdu->seq_no, &answer);
     105       
     106        async_exch_t *exch = async_exchange_begin(client->sess);
     107       
     108        ipc_call_t answer;
     109        aid_t req = async_send_3(exch, INETPING_EV_RECV, (sysarg_t) sdu->src,
     110            (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    86111        int rc = async_data_write_start(exch, sdu->data, sdu->size);
     112       
    87113        async_exchange_end(exch);
    88 
     114       
    89115        if (rc != EOK) {
    90116                async_forget(req);
    91117                return rc;
    92118        }
    93 
     119       
    94120        sysarg_t retval;
    95121        async_wait_for(req, &retval);
    96         if (retval != EOK) {
    97                 return retval;
    98         }
    99 
    100         return EOK;
     122       
     123        return (int) retval;
    101124}
    102125
    … …  
    116139        }
    117140
    118         sdu.src.ipv4 = IPC_GET_ARG1(*call);
    119         sdu.dest.ipv4 = IPC_GET_ARG2(*call);
     141        sdu.src = IPC_GET_ARG1(*call);
     142        sdu.dest = IPC_GET_ARG2(*call);
    120143        sdu.seq_no = IPC_GET_ARG3(*call);
    121144
    … …  
    129152    ipc_callid_t callid, ipc_call_t *call)
    130153{
    131         inet_addr_t remote;
    132         inet_addr_t local;
    133         int rc;
    134 
    135154        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_get_srcaddr_srv()");
    136 
    137         remote.ipv4 = IPC_GET_ARG1(*call);
    138         local.ipv4 = 0;
    139 
    140         rc = inetping_get_srcaddr(client, &remote, &local);
    141         async_answer_1(callid, rc, local.ipv4);
     155       
     156        uint32_t remote = IPC_GET_ARG1(*call);
     157        uint32_t local = 0;
     158       
     159        int rc = inetping_get_srcaddr(client, remote, &local);
     160        async_answer_1(callid, rc, (sysarg_t) local);
    142161}
    143162
    … …  
    147166        if (sess == NULL)
    148167                return ENOMEM;
    149 
     168       
    150169        client->sess = sess;
    151170        link_initialize(&client->client_list);
    152 
     171       
    153172        fibril_mutex_lock(&client_list_lock);
    154173        client->ident = ++inetping_ident;
    155174        list_append(&client->client_list, &client_list);
    156175        fibril_mutex_unlock(&client_list_lock);
    157 
     176       
    158177        return EOK;
    159178}
    … …  
    163182        async_hangup(client->sess);
    164183        client->sess = NULL;
    165 
     184       
    166185        fibril_mutex_lock(&client_list_lock);
    167186        list_remove(&client->client_list);
    … …  
    169188}
    170189
    171 static inetping_client_t *inetping_client_find(uint16_t ident)
    172 {
    173         fibril_mutex_lock(&client_list_lock);
    174 
    175         list_foreach(client_list, link) {
    176                 inetping_client_t *client = list_get_instance(link,
    177                     inetping_client_t, client_list);
    178 
    179                 if (client->ident == ident) {
    180                         fibril_mutex_unlock(&client_list_lock);
    181                         return client;
    182                 }
    183         }
    184 
    185         fibril_mutex_unlock(&client_list_lock);
    186         return NULL;
    187 }
    188 
    189190void inetping_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    190191{
    191         inetping_client_t client;
    192         int rc;
    193 
    194192        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()");
    195 
     193       
    196194        /* Accept the connection */
    197195        async_answer_0(iid, EOK);
    198 
    199         rc = inetping_client_init(&client);
     196       
     197        inetping_client_t client;
     198        int rc = inetping_client_init(&client);
    200199        if (rc != EOK)
    201200                return;
    202 
     201       
    203202        while (true) {
    204203                ipc_call_t call;
    205204                ipc_callid_t callid = async_get_call(&call);
    206205                sysarg_t method = IPC_GET_IMETHOD(call);
    207 
     206               
    208207                if (!method) {
    209208                        /* The other side has hung up */
    … …  
    211210                        break;
    212211                }
    213 
     212               
    214213                switch (method) {
    215214                case INETPING_SEND:
    … …  
    223222                }
    224223        }
    225 
     224       
    226225        inetping_client_fini(&client);
    227226}

  • uspace/srv/net/inetsrv/inetping.h

    rf2c19b0 r03c971f  
    3838#define INETPING_H_
    3939
     40#include "inetsrv.h"
     41
    4042extern void inetping_conn(ipc_callid_t, ipc_call_t *, void *);
    4143extern int inetping_recv(uint16_t, inetping_sdu_t *);

  • uspace/srv/net/inetsrv/inetsrv.c

    rf2c19b0 r03c971f  
    4646#include <stdlib.h>
    4747#include <sys/types.h>
    48 
     48#include <net/socket_codes.h>
    4949#include "addrobj.h"
    5050#include "icmp.h"
    5151#include "icmp_std.h"
     52#include "icmpv6.h"
     53#include "icmpv6_std.h"
    5254#include "inetsrv.h"
    5355#include "inetcfg.h"
    5456#include "inetping.h"
     57#include "inetping6.h"
    5558#include "inet_link.h"
    5659#include "reass.h"
    … …  
    5962#define NAME "inetsrv"
    6063
     64static inet_naddr_t solicited_node_mask = {
     65        .family = AF_INET6,
     66        .addr6 = {0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01, 0xff, 0, 0, 0},
     67        .prefix = 104
     68};
     69
     70static inet_addr_t multicast_all_nodes = {
     71        .family = AF_INET6,
     72        .addr6 = {0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01}
     73};
     74
    6175static void inet_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    6276
    … …  
    93107        rc = loc_service_register_with_iface(SERVICE_NAME_INETPING, &sid,
    94108            INET_PORT_PING);
     109        if (rc != EOK) {
     110                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc);
     111                return EEXIST;
     112        }
     113       
     114        rc = loc_service_register_with_iface(SERVICE_NAME_INETPING6, &sid,
     115            INET_PORT_PING6);
    95116        if (rc != EOK) {
    96117                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc);
    … …  
    104125        }
    105126
    106         sroute->dest.ipv4 = 0;
    107         sroute->dest.bits = 0;
    108         sroute->router.ipv4 = (10 << 24) | (0 << 16) | (2 << 8) | 2;
     127        inet_naddr(&sroute->dest, 0, 0, 0, 0, 0);
     128        inet_addr(&sroute->router, 10, 0, 2, 2);
    109129        sroute->name = str_dup("default");
    110130        inet_sroute_add(sroute);
    111131
    112         rc = inet_link_discovery_start();
     132        rc = inet_link_discovery_start();
    113133        if (rc != EOK)
    114134                return EEXIST;
    … …  
    194214
    195215        /* Take source address from the address object */
    196         local->ipv4 = dir.aobj->naddr.ipv4;
     216        inet_naddr_addr(&dir.aobj->naddr, local);
    197217        return EOK;
    198218}
    199219
    200 static void inet_get_srcaddr_srv(inet_client_t *client, ipc_callid_t callid,
    201     ipc_call_t *call)
    202 {
     220static void inet_get_srcaddr_srv(inet_client_t *client, ipc_callid_t iid,
     221    ipc_call_t *icall)
     222{
     223        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srcaddr_srv()");
     224       
     225        uint8_t tos = IPC_GET_ARG1(*icall);
     226       
     227        ipc_callid_t callid;
     228        size_t size;
     229        if (!async_data_write_receive(&callid, &size)) {
     230                async_answer_0(callid, EREFUSED);
     231                async_answer_0(iid, EREFUSED);
     232                return;
     233        }
     234       
     235        if (size != sizeof(inet_addr_t)) {
     236                async_answer_0(callid, EINVAL);
     237                async_answer_0(iid, EINVAL);
     238                return;
     239        }
     240       
    203241        inet_addr_t remote;
    204         uint8_t tos;
     242        int rc = async_data_write_finalize(callid, &remote, size);
     243        if (rc != EOK) {
     244                async_answer_0(callid, rc);
     245                async_answer_0(iid, rc);
     246        }
     247       
    205248        inet_addr_t local;
    206         int rc;
    207 
    208         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srcaddr_srv()");
    209 
    210         remote.ipv4 = IPC_GET_ARG1(*call);
    211         tos = IPC_GET_ARG2(*call);
    212         local.ipv4 = 0;
    213 
    214249        rc = inet_get_srcaddr(&remote, tos, &local);
    215         async_answer_1(callid, rc, local.ipv4);
    216 }
    217 
    218 static void inet_send_srv(inet_client_t *client, ipc_callid_t callid,
    219     ipc_call_t *call)
    220 {
     250        if (rc != EOK) {
     251                async_answer_0(iid, rc);
     252                return;
     253        }
     254       
     255        if (!async_data_read_receive(&callid, &size)) {
     256                async_answer_0(callid, EREFUSED);
     257                async_answer_0(iid, EREFUSED);
     258                return;
     259        }
     260       
     261        if (size != sizeof(inet_addr_t)) {
     262                async_answer_0(callid, EINVAL);
     263                async_answer_0(iid, EINVAL);
     264                return;
     265        }
     266       
     267        rc = async_data_read_finalize(callid, &local, size);
     268        if (rc != EOK) {
     269                async_answer_0(callid, rc);
     270                async_answer_0(iid, rc);
     271                return;
     272        }
     273       
     274        async_answer_0(iid, rc);
     275}
     276
     277static void inet_send_srv(inet_client_t *client, ipc_callid_t iid,
     278    ipc_call_t *icall)
     279{
     280        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send_srv()");
     281       
    221282        inet_dgram_t dgram;
    222         uint8_t ttl;
    223         int df;
    224         int rc;
    225 
    226         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send_srv()");
    227 
    228         dgram.src.ipv4 = IPC_GET_ARG1(*call);
    229         dgram.dest.ipv4 = IPC_GET_ARG2(*call);
    230         dgram.tos = IPC_GET_ARG3(*call);
    231         ttl = IPC_GET_ARG4(*call);
    232         df = IPC_GET_ARG5(*call);
    233 
    234         rc = async_data_write_accept(&dgram.data, false, 0, 0, 0, &dgram.size);
     283       
     284        dgram.tos = IPC_GET_ARG1(*icall);
     285       
     286        uint8_t ttl = IPC_GET_ARG2(*icall);
     287        int df = IPC_GET_ARG3(*icall);
     288       
     289        ipc_callid_t callid;
     290        size_t size;
     291        if (!async_data_write_receive(&callid, &size)) {
     292                async_answer_0(callid, EREFUSED);
     293                async_answer_0(iid, EREFUSED);
     294                return;
     295        }
     296       
     297        if (size != sizeof(inet_addr_t)) {
     298                async_answer_0(callid, EINVAL);
     299                async_answer_0(iid, EINVAL);
     300                return;
     301        }
     302       
     303        int rc = async_data_write_finalize(callid, &dgram.src, size);
    235304        if (rc != EOK) {
    236305                async_answer_0(callid, rc);
    237                 return;
    238         }
    239 
     306                async_answer_0(iid, rc);
     307        }
     308       
     309        if (!async_data_write_receive(&callid, &size)) {
     310                async_answer_0(callid, EREFUSED);
     311                async_answer_0(iid, EREFUSED);
     312                return;
     313        }
     314       
     315        if (size != sizeof(inet_addr_t)) {
     316                async_answer_0(callid, EINVAL);
     317                async_answer_0(iid, EINVAL);
     318                return;
     319        }
     320       
     321        rc = async_data_write_finalize(callid, &dgram.dest, size);
     322        if (rc != EOK) {
     323                async_answer_0(callid, rc);
     324                async_answer_0(iid, rc);
     325        }
     326       
     327        rc = async_data_write_accept(&dgram.data, false, 0, 0, 0,
     328            &dgram.size);
     329        if (rc != EOK) {
     330                async_answer_0(iid, rc);
     331                return;
     332        }
     333       
    240334        rc = inet_send(client, &dgram, client->protocol, ttl, df);
    241 
     335       
    242336        free(dgram.data);
    243         async_answer_0(callid, rc);
     337        async_answer_0(iid, rc);
    244338}
    245339
    … …  
    339433                inetping_conn(iid, icall, arg);
    340434                break;
     435        case INET_PORT_PING6:
     436                inetping6_conn(iid, icall, arg);
     437                break;
    341438        default:
    342439                async_answer_0(iid, ENOTSUP);
    … …  
    366463{
    367464        async_exch_t *exch = async_exchange_begin(client->sess);
    368 
     465       
    369466        ipc_call_t answer;
    370         aid_t req = async_send_3(exch, INET_EV_RECV, dgram->src.ipv4,
    371             dgram->dest.ipv4, dgram->tos, &answer);
    372         int rc = async_data_write_start(exch, dgram->data, dgram->size);
    373         async_exchange_end(exch);
    374 
    375         if (rc != EOK) {
     467        aid_t req = async_send_1(exch, INET_EV_RECV, dgram->tos, &answer);
     468       
     469        int rc = async_data_write_start(exch, &dgram->src, sizeof(inet_addr_t));
     470        if (rc != EOK) {
     471                async_exchange_end(exch);
    376472                async_forget(req);
    377473                return rc;
    378474        }
    379 
     475       
     476        rc = async_data_write_start(exch, &dgram->dest, sizeof(inet_addr_t));
     477        if (rc != EOK) {
     478                async_exchange_end(exch);
     479                async_forget(req);
     480                return rc;
     481        }
     482       
     483        rc = async_data_write_start(exch, dgram->data, dgram->size);
     484       
     485        async_exchange_end(exch);
     486       
     487        if (rc != EOK) {
     488                async_forget(req);
     489                return rc;
     490        }
     491       
    380492        sysarg_t retval;
    381493        async_wait_for(req, &retval);
    382         if (retval != EOK)
    383                 return retval;
    384 
    385         return EOK;
     494       
     495        return (int) retval;
    386496}
    387497
    … …  
    392502        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_recv_dgram_local()");
    393503
    394         /* ICMP messages are handled internally */
     504        /* ICMP and ICMPv6 messages are handled internally */
    395505        if (proto == IP_PROTO_ICMP)
    396506                return icmp_recv(dgram);
     507       
     508        if (proto == IP_PROTO_ICMPV6)
     509                return icmpv6_recv(dgram);
    397510
    398511        client = inet_client_find(proto);
    … …  
    412525
    413526        addr = inet_addrobj_find(&packet->dest, iaf_addr);
    414         if (addr != NULL) {
     527        if ((addr != NULL) ||
     528            (inet_naddr_compare_mask(&solicited_node_mask, &packet->dest)) ||
     529            (inet_addr_compare(&multicast_all_nodes, &packet->dest))) {
    415530                /* Destined for one of the local addresses */
    416531

  • uspace/srv/net/inetsrv/inetsrv.h

    rf2c19b0 r03c971f  
    6363} inetping_client_t;
    6464
     65/** Inetping6 Client */
     66typedef struct {
     67        /** Callback session */
     68        async_sess_t *sess;
     69        /** Session identifier */
     70        uint16_t ident;
     71        /** Link to client list */
     72        link_t client_list;
     73} inetping6_client_t;
     74
    6575/** Address object info */
    6676typedef struct {
    … …  
    103113        uint8_t ttl;
    104114        /** Identifier */
    105         uint16_t ident;
     115        uint32_t ident;
    106116        /** Do not fragment */
    107117        bool df;
    … …  
    131141        iplink_t *iplink;
    132142        size_t def_mtu;
     143        addr48_t mac;
     144        bool mac_valid;
    133145} inet_link_t;
    134146
    … …  
    172184
    173185typedef struct {
    174         inet_addr_t src;
    175         inet_addr_t dest;
     186        uint32_t src;
     187        uint32_t dest;
    176188        uint16_t seq_no;
    177189        void *data;
    178190        size_t size;
    179191} inetping_sdu_t;
     192
     193typedef struct {
     194        addr128_t src;
     195        addr128_t dest;
     196        uint16_t seq_no;
     197        void *data;
     198        size_t size;
     199} inetping6_sdu_t;
    180200
    181201extern int inet_ev_recv(inet_client_t *, inet_dgram_t *);

  • uspace/srv/net/inetsrv/pdu.c

    rf2c19b0 r03c971f  
    4444#include <mem.h>
    4545#include <stdlib.h>
    46 
     46#include <net/socket_codes.h>
    4747#include "inetsrv.h"
    4848#include "inet_std.h"
    4949#include "pdu.h"
    50 
    51 static FIBRIL_MUTEX_INITIALIZE(ip_ident_lock);
    52 static uint16_t ip_ident = 0;
    5350
    5451/** One's complement addition.
    … …  
    8885}
    8986
    90 /** Encode Internet PDU.
     87/** Encode IPv4 PDU.
    9188 *
    9289 * Encode internet packet into PDU (serialized form). Will encode a
    … …  
    9693 * be set in the header, otherwise the offset will equal @a packet->size.
    9794 *
    98  * @param packet        Packet to encode
    99  * @param offs          Offset into packet payload (in bytes)
    100  * @param mtu           MTU (Maximum Transmission Unit) in bytes
    101  * @param rdata         Place to store pointer to allocated data buffer
    102  * @param rsize         Place to store size of allocated data buffer
    103  * @param roffs         Place to store offset of remaning data
    104  */
    105 int inet_pdu_encode(inet_packet_t *packet, size_t offs, size_t mtu,
    106     void **rdata, size_t *rsize, size_t *roffs)
    107 {
    108         void *data;
    109         size_t size;
    110         ip_header_t *hdr;
    111         size_t hdr_size;
    112         size_t data_offs;
    113         uint16_t chksum;
    114         uint16_t ident;
    115         uint16_t flags_foff;
    116         uint16_t foff;
    117         size_t fragoff_limit;
    118         size_t xfer_size;
    119         size_t spc_avail;
    120         size_t rem_offs;
    121 
     95 * @param packet Packet to encode
     96 * @param src    Source address
     97 * @param dest   Destination address
     98 * @param offs   Offset into packet payload (in bytes)
     99 * @param mtu    MTU (Maximum Transmission Unit) in bytes
     100 * @param rdata  Place to store pointer to allocated data buffer
     101 * @param rsize  Place to store size of allocated data buffer
     102 * @param roffs  Place to store offset of remaning data
     103 *
     104 */
     105int inet_pdu_encode(inet_packet_t *packet, addr32_t src, addr32_t dest,
     106    size_t offs, size_t mtu, void **rdata, size_t *rsize, size_t *roffs)
     107{
    122108        /* Upper bound for fragment offset field */
    123         fragoff_limit = 1 << (FF_FRAGOFF_h - FF_FRAGOFF_l);
    124 
     109        size_t fragoff_limit = 1 << (FF_FRAGOFF_h - FF_FRAGOFF_l);
     110       
    125111        /* Verify that total size of datagram is within reasonable bounds */
    126112        if (offs + packet->size > FRAG_OFFS_UNIT * fragoff_limit)
    127113                return ELIMIT;
    128 
    129         hdr_size = sizeof(ip_header_t);
    130         data_offs = ROUND_UP(hdr_size, 4);
    131 
     114       
     115        size_t hdr_size = sizeof(ip_header_t);
     116        if (hdr_size >= mtu)
     117                return EINVAL;
     118       
     119        assert(hdr_size % 4 == 0);
    132120        assert(offs % FRAG_OFFS_UNIT == 0);
    133121        assert(offs / FRAG_OFFS_UNIT < fragoff_limit);
    134 
     122       
    135123        /* Value for the fragment offset field */
    136         foff = offs / FRAG_OFFS_UNIT;
    137 
    138         if (hdr_size >= mtu)
    139                 return EINVAL;
    140 
     124        uint16_t foff = offs / FRAG_OFFS_UNIT;
     125       
    141126        /* Amount of space in the PDU available for payload */
    142         spc_avail = mtu - hdr_size;
     127        size_t spc_avail = mtu - hdr_size;
    143128        spc_avail -= (spc_avail % FRAG_OFFS_UNIT);
    144 
     129       
    145130        /* Amount of data (payload) to transfer */
    146         xfer_size = min(packet->size - offs, spc_avail);
    147 
     131        size_t xfer_size = min(packet->size - offs, spc_avail);
     132       
    148133        /* Total PDU size */
    149         size = hdr_size + xfer_size;
    150 
     134        size_t size = hdr_size + xfer_size;
     135       
    151136        /* Offset of remaining payload */
    152         rem_offs = offs + xfer_size;
    153 
     137        size_t rem_offs = offs + xfer_size;
     138       
    154139        /* Flags */
    155         flags_foff =
     140        uint16_t flags_foff =
    156141            (packet->df ? BIT_V(uint16_t, FF_FLAG_DF) : 0) +
    157142            (rem_offs < packet->size ? BIT_V(uint16_t, FF_FLAG_MF) : 0) +
    158143            (foff << FF_FRAGOFF_l);
    159 
    160         data = calloc(size, 1);
     144       
     145        void *data = calloc(size, 1);
    161146        if (data == NULL)
    162147                return ENOMEM;
    163 
    164         /* Allocate identifier */
    165         fibril_mutex_lock(&ip_ident_lock);
    166         ident = ++ip_ident;
    167         fibril_mutex_unlock(&ip_ident_lock);
    168 
     148       
    169149        /* Encode header fields */
    170         hdr = (ip_header_t *)data;
    171         hdr->ver_ihl = (4 << VI_VERSION_l) | (hdr_size / sizeof(uint32_t));
     150        ip_header_t *hdr = (ip_header_t *) data;
     151       
     152        hdr->ver_ihl =
     153            (4 << VI_VERSION_l) | (hdr_size / sizeof(uint32_t));
    172154        hdr->tos = packet->tos;
    173155        hdr->tot_len = host2uint16_t_be(size);
    174         hdr->id = host2uint16_t_be(ident);
     156        hdr->id = host2uint16_t_be(packet->ident);
    175157        hdr->flags_foff = host2uint16_t_be(flags_foff);
    176158        hdr->ttl = packet->ttl;
    177159        hdr->proto = packet->proto;
    178160        hdr->chksum = 0;
    179         hdr->src_addr = host2uint32_t_be(packet->src.ipv4);
    180         hdr->dest_addr = host2uint32_t_be(packet->dest.ipv4);
    181 
     161        hdr->src_addr = host2uint32_t_be(src);
     162        hdr->dest_addr = host2uint32_t_be(dest);
     163       
    182164        /* Compute checksum */
    183         chksum = inet_checksum_calc(INET_CHECKSUM_INIT, (void *)hdr, hdr_size);
     165        uint16_t chksum = inet_checksum_calc(INET_CHECKSUM_INIT,
     166            (void *) hdr, hdr_size);
    184167        hdr->chksum = host2uint16_t_be(chksum);
    185 
     168       
    186169        /* Copy payload */
    187         memcpy((uint8_t *)data + data_offs, packet->data + offs, xfer_size);
    188 
     170        memcpy((uint8_t *) data + hdr_size, packet->data + offs, xfer_size);
     171       
    189172        *rdata = data;
    190173        *rsize = size;
    191174        *roffs = rem_offs;
    192 
     175       
    193176        return EOK;
    194177}
    195178
     179/** Encode IPv6 PDU.
     180 *
     181 * Encode internet packet into PDU (serialized form). Will encode a
     182 * fragment of the payload starting at offset @a offs. The resulting
     183 * PDU will have at most @a mtu bytes. @a *roffs will be set to the offset
     184 * of remaining payload. If some data is remaining, the MF flag will
     185 * be set in the header, otherwise the offset will equal @a packet->size.
     186 *
     187 * @param packet Packet to encode
     188 * @param src    Source address
     189 * @param dest   Destination address
     190 * @param offs   Offset into packet payload (in bytes)
     191 * @param mtu    MTU (Maximum Transmission Unit) in bytes
     192 * @param rdata  Place to store pointer to allocated data buffer
     193 * @param rsize  Place to store size of allocated data buffer
     194 * @param roffs  Place to store offset of remaning data
     195 *
     196 */
     197int inet_pdu_encode6(inet_packet_t *packet, addr128_t src, addr128_t dest,
     198    size_t offs, size_t mtu, void **rdata, size_t *rsize, size_t *roffs)
     199{
     200        /* IPv6 mandates a minimal MTU of 1280 bytes */
     201        if (mtu < 1280)
     202                return ELIMIT;
     203       
     204        /* Upper bound for fragment offset field */
     205        size_t fragoff_limit = 1 << (OF_FRAGOFF_h - OF_FRAGOFF_l);
     206       
     207        /* Verify that total size of datagram is within reasonable bounds */
     208        if (offs + packet->size > FRAG_OFFS_UNIT * fragoff_limit)
     209                return ELIMIT;
     210       
     211        /* Determine whether we need the Fragment extension header */
     212        bool fragment;
     213        if (offs == 0)
     214                fragment = (packet->size + sizeof(ip6_header_t) > mtu);
     215        else
     216                fragment = true;
     217       
     218        size_t hdr_size;
     219        if (fragment)
     220                hdr_size = sizeof(ip6_header_t) + sizeof(ip6_header_fragment_t);
     221        else
     222                hdr_size = sizeof(ip6_header_t);
     223       
     224        if (hdr_size >= mtu)
     225                return EINVAL;
     226       
     227        assert(sizeof(ip6_header_t) % 8 == 0);
     228        assert(hdr_size % 8 == 0);
     229        assert(offs % FRAG_OFFS_UNIT == 0);
     230        assert(offs / FRAG_OFFS_UNIT < fragoff_limit);
     231       
     232        /* Value for the fragment offset field */
     233        uint16_t foff = offs / FRAG_OFFS_UNIT;
     234       
     235        /* Amount of space in the PDU available for payload */
     236        size_t spc_avail = mtu - hdr_size;
     237        spc_avail -= (spc_avail % FRAG_OFFS_UNIT);
     238       
     239        /* Amount of data (payload) to transfer */
     240        size_t xfer_size = min(packet->size - offs, spc_avail);
     241       
     242        /* Total PDU size */
     243        size_t size = hdr_size + xfer_size;
     244       
     245        /* Offset of remaining payload */
     246        size_t rem_offs = offs + xfer_size;
     247       
     248        /* Flags */
     249        uint16_t offsmf =
     250            (rem_offs < packet->size ? BIT_V(uint16_t, OF_FLAG_M) : 0) +
     251            (foff << OF_FRAGOFF_l);
     252       
     253        void *data = calloc(size, 1);
     254        if (data == NULL)
     255                return ENOMEM;
     256       
     257        /* Encode header fields */
     258        ip6_header_t *hdr6 = (ip6_header_t *) data;
     259       
     260        hdr6->ver_tc = (6 << (VI_VERSION_l));
     261        memset(hdr6->tc_fl, 0, 3);
     262        hdr6->hop_limit = packet->ttl;
     263       
     264        host2addr128_t_be(src, hdr6->src_addr);
     265        host2addr128_t_be(dest, hdr6->dest_addr);
     266       
     267        /* Optionally encode Fragment extension header fields */
     268        if (fragment) {
     269                assert(offsmf != 0);
     270               
     271                hdr6->payload_len = host2uint16_t_be(packet->size +
     272                    sizeof(ip6_header_fragment_t));
     273                hdr6->next = IP6_NEXT_FRAGMENT;
     274               
     275                ip6_header_fragment_t *hdr6f = (ip6_header_fragment_t *)
     276                    (hdr6 + 1);
     277               
     278                hdr6f->next = packet->proto;
     279                hdr6f->reserved = 0;
     280                hdr6f->offsmf = host2uint16_t_be(offsmf);
     281                hdr6f->id = host2uint32_t_be(packet->ident);
     282        } else {
     283                assert(offsmf == 0);
     284               
     285                hdr6->payload_len = host2uint16_t_be(packet->size);
     286                hdr6->next = packet->proto;
     287        }
     288       
     289        /* Copy payload */
     290        memcpy((uint8_t *) data + hdr_size, packet->data + offs, xfer_size);
     291       
     292        *rdata = data;
     293        *rsize = size;
     294        *roffs = rem_offs;
     295       
     296        return EOK;
     297}
     298
     299/** Decode IPv4 datagram
     300 *
     301 * @param data   Serialized IPv4 datagram
     302 * @param size   Length of serialized IPv4 datagram
     303 * @param packet IP datagram structure to be filled
     304 *
     305 * @return EOK on success
     306 * @return EINVAL if the datagram is invalid or damaged
     307 * @return ENOMEM if not enough memory
     308 *
     309 */
    196310int inet_pdu_decode(void *data, size_t size, inet_packet_t *packet)
    197311{
    198         ip_header_t *hdr;
    199         size_t tot_len;
    200         size_t data_offs;
    201         uint8_t version;
    202         uint16_t ident;
    203         uint16_t flags_foff;
    204         uint16_t foff;
    205 
    206312        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_pdu_decode()");
    207 
     313       
    208314        if (size < sizeof(ip_header_t)) {
    209315                log_msg(LOG_DEFAULT, LVL_DEBUG, "PDU too short (%zu)", size);
    210316                return EINVAL;
    211317        }
    212 
    213         hdr = (ip_header_t *)data;
    214 
    215         version = BIT_RANGE_EXTRACT(uint8_t, VI_VERSION_h, VI_VERSION_l,
    216             hdr->ver_ihl);
     318       
     319        ip_header_t *hdr = (ip_header_t *) data;
     320       
     321        uint8_t version = BIT_RANGE_EXTRACT(uint8_t, VI_VERSION_h,
     322            VI_VERSION_l, hdr->ver_ihl);
    217323        if (version != 4) {
    218324                log_msg(LOG_DEFAULT, LVL_DEBUG, "Version (%d) != 4", version);
    219325                return EINVAL;
    220326        }
    221 
    222         tot_len = uint16_t_be2host(hdr->tot_len);
     327       
     328        size_t tot_len = uint16_t_be2host(hdr->tot_len);
    223329        if (tot_len < sizeof(ip_header_t)) {
    224330                log_msg(LOG_DEFAULT, LVL_DEBUG, "Total Length too small (%zu)", tot_len);
    225331                return EINVAL;
    226332        }
    227 
     333       
    228334        if (tot_len > size) {
    229335                log_msg(LOG_DEFAULT, LVL_DEBUG, "Total Length = %zu > PDU size = %zu",
    230                         tot_len, size);
    231                 return EINVAL;
    232         }
    233 
    234         ident = uint16_t_be2host(hdr->id);
    235         flags_foff = uint16_t_be2host(hdr->flags_foff);
    236         foff = BIT_RANGE_EXTRACT(uint16_t, FF_FRAGOFF_h, FF_FRAGOFF_l,
     336                    tot_len, size);
     337                return EINVAL;
     338        }
     339       
     340        uint16_t ident = uint16_t_be2host(hdr->id);
     341        uint16_t flags_foff = uint16_t_be2host(hdr->flags_foff);
     342        uint16_t foff = BIT_RANGE_EXTRACT(uint16_t, FF_FRAGOFF_h, FF_FRAGOFF_l,
    237343            flags_foff);
    238344        /* XXX Checksum */
    239 
    240         packet->src.ipv4 = uint32_t_be2host(hdr->src_addr);
    241         packet->dest.ipv4 = uint32_t_be2host(hdr->dest_addr);
     345       
     346        inet_addr_set(uint32_t_be2host(hdr->src_addr), &packet->src);
     347        inet_addr_set(uint32_t_be2host(hdr->dest_addr), &packet->dest);
    242348        packet->tos = hdr->tos;
    243349        packet->proto = hdr->proto;
    244350        packet->ttl = hdr->ttl;
    245351        packet->ident = ident;
    246 
     352       
    247353        packet->df = (flags_foff & BIT_V(uint16_t, FF_FLAG_DF)) != 0;
    248354        packet->mf = (flags_foff & BIT_V(uint16_t, FF_FLAG_MF)) != 0;
    249355        packet->offs = foff * FRAG_OFFS_UNIT;
    250 
     356       
    251357        /* XXX IP options */
    252         data_offs = sizeof(uint32_t) * BIT_RANGE_EXTRACT(uint8_t, VI_IHL_h,
    253             VI_IHL_l, hdr->ver_ihl);
    254 
     358        size_t data_offs = sizeof(uint32_t) *
     359            BIT_RANGE_EXTRACT(uint8_t, VI_IHL_h, VI_IHL_l, hdr->ver_ihl);
     360       
    255361        packet->size = tot_len - data_offs;
    256362        packet->data = calloc(packet->size, 1);
    … …  
    259365                return ENOMEM;
    260366        }
    261 
    262         memcpy(packet->data, (uint8_t *)data + data_offs, packet->size);
    263 
     367       
     368        memcpy(packet->data, (uint8_t *) data + data_offs, packet->size);
     369       
    264370        return EOK;
    265371}
    266372
     373/** Decode IPv6 datagram
     374 *
     375 * @param data   Serialized IPv6 datagram
     376 * @param size   Length of serialized IPv6 datagram
     377 * @param packet IP datagram structure to be filled
     378 *
     379 * @return EOK on success
     380 * @return EINVAL if the datagram is invalid or damaged
     381 * @return ENOMEM if not enough memory
     382 *
     383 */
     384int inet_pdu_decode6(void *data, size_t size, inet_packet_t *packet)
     385{
     386        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_pdu_decode6()");
     387       
     388        if (size < sizeof(ip6_header_t)) {
     389                log_msg(LOG_DEFAULT, LVL_DEBUG, "PDU too short (%zu)", size);
     390                return EINVAL;
     391        }
     392       
     393        ip6_header_t *hdr6 = (ip6_header_t *) data;
     394       
     395        uint8_t version = BIT_RANGE_EXTRACT(uint8_t, VI_VERSION_h,
     396            VI_VERSION_l, hdr6->ver_tc);
     397        if (version != 6) {
     398                log_msg(LOG_DEFAULT, LVL_DEBUG, "Version (%d) != 6", version);
     399                return EINVAL;
     400        }
     401       
     402        size_t payload_len = uint16_t_be2host(hdr6->payload_len);
     403        if (payload_len + sizeof(ip6_header_t) > size) {
     404                log_msg(LOG_DEFAULT, LVL_DEBUG, "Payload Length = %zu > PDU size = %zu",
     405                    payload_len + sizeof(ip6_header_t), size);
     406                return EINVAL;
     407        }
     408       
     409        uint32_t ident;
     410        uint16_t offsmf;
     411        uint16_t foff;
     412        uint16_t next;
     413        size_t data_offs = sizeof(ip6_header_t);
     414       
     415        /* Fragment extension header */
     416        if (hdr6->next == IP6_NEXT_FRAGMENT) {
     417                ip6_header_fragment_t *hdr6f = (ip6_header_fragment_t *)
     418                    (hdr6 + 1);
     419               
     420                ident = uint32_t_be2host(hdr6f->id);
     421                offsmf = uint16_t_be2host(hdr6f->offsmf);
     422                foff = BIT_RANGE_EXTRACT(uint16_t, OF_FRAGOFF_h, OF_FRAGOFF_l,
     423                    offsmf);
     424                next = hdr6f->next;
     425                data_offs += sizeof(ip6_header_fragment_t);
     426                payload_len -= sizeof(ip6_header_fragment_t);
     427        } else {
     428                ident = 0;
     429                offsmf = 0;
     430                foff = 0;
     431                next = hdr6->next;
     432        }
     433       
     434        addr128_t src;
     435        addr128_t dest;
     436       
     437        addr128_t_be2host(hdr6->src_addr, src);
     438        inet_addr_set6(src, &packet->src);
     439       
     440        addr128_t_be2host(hdr6->dest_addr, dest);
     441        inet_addr_set6(dest, &packet->dest);
     442       
     443        packet->tos = 0;
     444        packet->proto = next;
     445        packet->ttl = hdr6->hop_limit;
     446        packet->ident = ident;
     447       
     448        packet->df = 1;
     449        packet->mf = (offsmf & BIT_V(uint16_t, OF_FLAG_M)) != 0;
     450        packet->offs = foff * FRAG_OFFS_UNIT;
     451       
     452        packet->size = payload_len;
     453        packet->data = calloc(packet->size, 1);
     454        if (packet->data == NULL) {
     455                log_msg(LOG_DEFAULT, LVL_WARN, "Out of memory.");
     456                return ENOMEM;
     457        }
     458       
     459        memcpy(packet->data, (uint8_t *) data + data_offs, packet->size);
     460       
     461        return EOK;
     462}
     463
     464/** Encode NDP packet
     465 *
     466 * @param ndp   NDP packet structure to be serialized
     467 * @param dgram IPv6 datagram structure to be filled
     468 *
     469 * @return EOK on success
     470 *
     471 */
     472int ndp_pdu_encode(ndp_packet_t *ndp, inet_dgram_t *dgram)
     473{
     474        inet_addr_set6(ndp->sender_proto_addr, &dgram->src);
     475        inet_addr_set6(ndp->target_proto_addr, &dgram->dest);
     476        dgram->tos = 0;
     477        dgram->size = sizeof(icmpv6_message_t) + sizeof(ndp_message_t);
     478       
     479        dgram->data = calloc(1, dgram->size);
     480        if (dgram->data == NULL)
     481                return ENOMEM;
     482       
     483        icmpv6_message_t *icmpv6 = (icmpv6_message_t *) dgram->data;
     484       
     485        icmpv6->type = ndp->opcode;
     486        icmpv6->code = 0;
     487        memset(icmpv6->un.ndp.reserved, 0, 3);
     488       
     489        ndp_message_t *message = (ndp_message_t *) (icmpv6 + 1);
     490       
     491        if (ndp->opcode == ICMPV6_NEIGHBOUR_SOLICITATION) {
     492                host2addr128_t_be(ndp->solicited_ip, message->target_address);
     493                message->option = 1;
     494                icmpv6->un.ndp.flags = 0;
     495        } else {
     496                host2addr128_t_be(ndp->sender_proto_addr, message->target_address);
     497                message->option = 2;
     498                icmpv6->un.ndp.flags = NDP_FLAG_OVERRIDE | NDP_FLAG_SOLICITED;
     499        }
     500       
     501        message->length = 1;
     502        addr48(ndp->sender_hw_addr, message->mac);
     503       
     504        icmpv6_phdr_t phdr;
     505       
     506        host2addr128_t_be(ndp->sender_proto_addr, phdr.src_addr);
     507        host2addr128_t_be(ndp->target_proto_addr, phdr.dest_addr);
     508        phdr.length = host2uint32_t_be(dgram->size);
     509        memset(phdr.zeroes, 0, 3);
     510        phdr.next = IP_PROTO_ICMPV6;
     511       
     512        uint16_t cs_phdr =
     513            inet_checksum_calc(INET_CHECKSUM_INIT, &phdr,
     514            sizeof(icmpv6_phdr_t));
     515       
     516        uint16_t cs_all = inet_checksum_calc(cs_phdr, dgram->data,
     517            dgram->size);
     518       
     519        icmpv6->checksum = host2uint16_t_be(cs_all);
     520       
     521        return EOK;
     522}
     523
     524/** Decode NDP packet
     525 *
     526 * @param dgram Incoming IPv6 datagram encapsulating NDP packet
     527 * @param ndp   NDP packet structure to be filled
     528 *
     529 * @return EOK on success
     530 * @return EINVAL if the Datagram is invalid
     531 *
     532 */
     533int ndp_pdu_decode(inet_dgram_t *dgram, ndp_packet_t *ndp)
     534{
     535        uint16_t src_af = inet_addr_get(&dgram->src, NULL,
     536            &ndp->sender_proto_addr);
     537        if (src_af != AF_INET6)
     538                return EINVAL;
     539       
     540        if (dgram->size < sizeof(icmpv6_message_t) + sizeof(ndp_message_t))
     541                return EINVAL;
     542       
     543        icmpv6_message_t *icmpv6 = (icmpv6_message_t *) dgram->data;
     544       
     545        ndp->opcode = icmpv6->type;
     546       
     547        ndp_message_t *message = (ndp_message_t *) (icmpv6 + 1);
     548       
     549        addr128_t_be2host(message->target_address, ndp->target_proto_addr);
     550        addr48(message->mac, ndp->sender_hw_addr);
     551       
     552        return EOK;
     553}
     554
    267555/** @}
    268556 */

  • uspace/srv/net/inetsrv/pdu.h

    rf2c19b0 r03c971f  
    4040#include <sys/types.h>
    4141#include "inetsrv.h"
     42#include "ndp.h"
    4243
    4344#define INET_CHECKSUM_INIT 0xffff
    … …  
    4546extern uint16_t inet_checksum_calc(uint16_t, void *, size_t);
    4647
    47 extern int inet_pdu_encode(inet_packet_t *, size_t, size_t, void **,
    48     size_t *, size_t *);
     48extern int inet_pdu_encode(inet_packet_t *, addr32_t, addr32_t, size_t, size_t,
     49    void **, size_t *, size_t *);
     50extern int inet_pdu_encode6(inet_packet_t *, addr128_t, addr128_t, size_t,
     51    size_t, void **, size_t *, size_t *);
    4952extern int inet_pdu_decode(void *, size_t, inet_packet_t *);
     53extern int inet_pdu_decode6(void *, size_t, inet_packet_t *);
     54
     55extern int ndp_pdu_decode(inet_dgram_t *, ndp_packet_t *);
     56extern int ndp_pdu_encode(ndp_packet_t *, inet_dgram_t *);
    5057
    5158#endif

  • uspace/srv/net/inetsrv/reass.c

    rf2c19b0 r03c971f  
    139139                    dgram_link);
    140140
    141                 if (f1->packet.src.ipv4 == packet->src.ipv4 &&
    142                     f1->packet.dest.ipv4 == packet->dest.ipv4 &&
    143                     f1->packet.proto == packet->proto &&
    144                     f1->packet.ident == packet->ident) {
     141                if ((inet_addr_compare(&f1->packet.src, &packet->src)) &&
     142                    (inet_addr_compare(&f1->packet.dest, &packet->dest)) &&
     143                    (f1->packet.proto == packet->proto) &&
     144                    (f1->packet.ident == packet->ident)) {
    145145                        /* Match */
    146146                        return rdg;
    … …  
    164164                return NULL;
    165165
    166         link_initialize(&rdg->map_link);
     166        list_append(&rdg->map_link, &reass_dgram_map);
    167167        list_initialize(&rdg->frags);
    168168

  • uspace/srv/net/inetsrv/sroute.c

    rf2c19b0 r03c971f  
    4242#include <stdlib.h>
    4343#include <str.h>
    44 
    4544#include "sroute.h"
    4645#include "inetsrv.h"
    4746#include "inet_link.h"
    48 #include "inet_util.h"
    4947
    5048static FIBRIL_MUTEX_INITIALIZE(sroute_list_lock);
    … …  
    9795inet_sroute_t *inet_sroute_find(inet_addr_t *addr)
    9896{
    99         uint32_t mask;
    100         inet_sroute_t *best;
    101 
    102         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find(%x)", (unsigned)addr->ipv4);
    103 
    104         fibril_mutex_lock(&sroute_list_lock);
    105 
    106         best = NULL;
    107 
    108         list_foreach(sroute_list, link) {
    109                 inet_sroute_t *sroute = list_get_instance(link,
    110                     inet_sroute_t, sroute_list);
    111 
     97        uint16_t addr_af = inet_addr_get(addr, NULL, NULL);
     98       
     99        inet_sroute_t *best = NULL;
     100        uint8_t best_bits = 0;
     101       
     102        fibril_mutex_lock(&sroute_list_lock);
     103       
     104        list_foreach(sroute_list, link) {
     105                inet_sroute_t *sroute = list_get_instance(link,
     106                    inet_sroute_t, sroute_list);
     107               
     108                uint8_t dest_bits;
     109                uint16_t dest_af = inet_naddr_get(&sroute->dest, NULL, NULL,
     110                    &dest_bits);
     111               
     112                /* Skip comparison with different address family */
     113                if (addr_af != dest_af)
     114                        continue;
     115               
    112116                /* Look for the most specific route */
    113                 if (best != NULL && best->dest.bits >= sroute->dest.bits)
     117                if ((best != NULL) && (best_bits >= dest_bits))
    114118                        continue;
    115 
    116                 mask = inet_netmask(sroute->dest.bits);
    117                 if ((sroute->dest.ipv4 & mask) == (addr->ipv4 & mask)) {
    118                         fibril_mutex_unlock(&sroute_list_lock);
    119                         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: found %p",
     119               
     120                if (inet_naddr_compare_mask(&sroute->dest, addr)) {
     121                        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: found candidate %p",
    120122                            sroute);
    121                         return sroute;
     123                       
     124                        best = sroute;
     125                        best_bits = dest_bits;
    122126                }
    123127        }
    124 
    125         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: Not found");
    126         fibril_mutex_unlock(&sroute_list_lock);
    127 
    128         return NULL;
     128       
     129        if (best == NULL)
     130                log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: Not found");
     131       
     132        fibril_mutex_unlock(&sroute_list_lock);
     133       
     134        return best;
    129135}
    130136

  • uspace/srv/net/loopip/loopip.c

    rf2c19b0 r03c971f  
    3939#include <errno.h>
    4040#include <inet/iplink_srv.h>
     41#include <inet/addr.h>
     42#include <net/socket_codes.h>
    4143#include <io/log.h>
    4244#include <loc.h>
    … …  
    4446#include <stdlib.h>
    4547
    46 #define NAME "loopip"
     48#define NAME  "loopip"
    4749
    4850static int loopip_open(iplink_srv_t *srv);
    4951static int loopip_close(iplink_srv_t *srv);
    50 static int loopip_send(iplink_srv_t *srv, iplink_srv_sdu_t *sdu);
     52static int loopip_send(iplink_srv_t *srv, iplink_sdu_t *sdu);
     53static int loopip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu);
    5154static int loopip_get_mtu(iplink_srv_t *srv, size_t *mtu);
    52 static int loopip_addr_add(iplink_srv_t *srv, iplink_srv_addr_t *addr);
    53 static int loopip_addr_remove(iplink_srv_t *srv, iplink_srv_addr_t *addr);
     55static int loopip_get_mac48(iplink_srv_t *srv, addr48_t *mac);
     56static int loopip_addr_add(iplink_srv_t *srv, inet_addr_t *addr);
     57static int loopip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
    5458
    5559static void loopip_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    … …  
    5963        .close = loopip_close,
    6064        .send = loopip_send,
     65        .send6 = loopip_send6,
    6166        .get_mtu = loopip_get_mtu,
     67        .get_mac48 = loopip_get_mac48,
    6268        .addr_add = loopip_addr_add,
    6369        .addr_remove = loopip_addr_remove
    … …  
    6975typedef struct {
    7076        link_t link;
    71         iplink_srv_sdu_t sdu;
     77       
     78        uint16_t af;
     79        iplink_recv_sdu_t sdu;
    7280} rqueue_entry_t;
    7381
    … …  
    7785                log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_recv_fibril(): Wait for one item");
    7886                link_t *link = prodcons_consume(&loopip_rcv_queue);
    79                 rqueue_entry_t *rqe = list_get_instance(link, rqueue_entry_t, link);
    80 
    81                 (void) iplink_ev_recv(&loopip_iplink, &rqe->sdu);
    82         }
    83 
     87                rqueue_entry_t *rqe =
     88                    list_get_instance(link, rqueue_entry_t, link);
     89               
     90                (void) iplink_ev_recv(&loopip_iplink, &rqe->sdu, rqe->af);
     91               
     92                free(rqe->sdu.data);
     93                free(rqe);
     94        }
     95       
    8496        return 0;
    8597}
    … …  
    8799static int loopip_init(void)
    88100{
    89         int rc;
    90         service_id_t sid;
    91         category_id_t iplink_cat;
    92         const char *svc_name = "net/loopback";
    93        
    94101        async_set_client_connection(loopip_client_conn);
    95102       
    96         rc = loc_server_register(NAME);
     103        int rc = loc_server_register(NAME);
    97104        if (rc != EOK) {
    98105                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server.");
    99106                return rc;
    100107        }
    101 
     108       
    102109        iplink_srv_init(&loopip_iplink);
    103110        loopip_iplink.ops = &loopip_iplink_ops;
    104111        loopip_iplink.arg = NULL;
    105 
     112       
    106113        prodcons_initialize(&loopip_rcv_queue);
    107 
     114       
     115        const char *svc_name = "net/loopback";
     116        service_id_t sid;
    108117        rc = loc_service_register(svc_name, &sid);
    109118        if (rc != EOK) {
    110                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service %s.", svc_name);
    111                 return rc;
    112         }
    113 
     119                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service %s.",
     120                    svc_name);
     121                return rc;
     122        }
     123       
     124        category_id_t iplink_cat;
    114125        rc = loc_category_get_id("iplink", &iplink_cat, IPC_FLAG_BLOCKING);
    115126        if (rc != EOK) {
    … …  
    117128                return rc;
    118129        }
    119 
     130       
    120131        rc = loc_service_add_to_cat(sid, iplink_cat);
    121132        if (rc != EOK) {
    122                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding %s to category.", svc_name);
    123                 return rc;
    124         }
    125 
     133                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding %s to category.",
     134                    svc_name);
     135                return rc;
     136        }
     137       
    126138        fid_t fid = fibril_create(loopip_recv_fibril, NULL);
    127139        if (fid == 0)
    128140                return ENOMEM;
    129 
     141       
    130142        fibril_add_ready(fid);
    131 
     143       
    132144        return EOK;
    133145}
    … …  
    151163}
    152164
    153 static int loopip_send(iplink_srv_t *srv, iplink_srv_sdu_t *sdu)
    154 {
    155         rqueue_entry_t *rqe;
    156 
     165static int loopip_send(iplink_srv_t *srv, iplink_sdu_t *sdu)
     166{
    157167        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_send()");
    158 
    159         rqe = calloc(1, sizeof(rqueue_entry_t));
     168       
     169        rqueue_entry_t *rqe = calloc(1, sizeof(rqueue_entry_t));
    160170        if (rqe == NULL)
    161171                return ENOMEM;
     172       
    162173        /*
    163174         * Clone SDU
    164175         */
    165         rqe->sdu.lsrc = sdu->ldest;
    166         rqe->sdu.ldest = sdu->lsrc;
     176        rqe->af = AF_INET;
    167177        rqe->sdu.data = malloc(sdu->size);
    168178        if (rqe->sdu.data == NULL) {
    … …  
    170180                return ENOMEM;
    171181        }
    172 
     182       
    173183        memcpy(rqe->sdu.data, sdu->data, sdu->size);
    174184        rqe->sdu.size = sdu->size;
    175 
     185       
    176186        /*
    177187         * Insert to receive queue
    178188         */
    179189        prodcons_produce(&loopip_rcv_queue, &rqe->link);
    180 
     190       
     191        return EOK;
     192}
     193
     194static int loopip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu)
     195{
     196        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip6_send()");
     197       
     198        rqueue_entry_t *rqe = calloc(1, sizeof(rqueue_entry_t));
     199        if (rqe == NULL)
     200                return ENOMEM;
     201       
     202        /*
     203         * Clone SDU
     204         */
     205        rqe->af = AF_INET6;
     206        rqe->sdu.data = malloc(sdu->size);
     207        if (rqe->sdu.data == NULL) {
     208                free(rqe);
     209                return ENOMEM;
     210        }
     211       
     212        memcpy(rqe->sdu.data, sdu->data, sdu->size);
     213        rqe->sdu.size = sdu->size;
     214       
     215        /*
     216         * Insert to receive queue
     217         */
     218        prodcons_produce(&loopip_rcv_queue, &rqe->link);
     219       
    181220        return EOK;
    182221}
    … …  
    189228}
    190229
    191 static int loopip_addr_add(iplink_srv_t *srv, iplink_srv_addr_t *addr)
    192 {
    193         log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_addr_add(0x%" PRIx32 ")", addr->ipv4);
    194         return EOK;
    195 }
    196 
    197 static int loopip_addr_remove(iplink_srv_t *srv, iplink_srv_addr_t *addr)
    198 {
    199         log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_addr_remove(0x%" PRIx32 ")", addr->ipv4);
     230static int loopip_get_mac48(iplink_srv_t *src, addr48_t *mac)
     231{
     232        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_get_mac48()");
     233        return ENOTSUP;
     234}
     235
     236static int loopip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
     237{
     238        return EOK;
     239}
     240
     241static int loopip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr)
     242{
    200243        return EOK;
    201244}
    … …  
    203246int main(int argc, char *argv[])
    204247{
    205         int rc;
    206 
    207         printf(NAME ": HelenOS loopback IP link provider\n");
    208 
    209         if (log_init(NAME) != EOK) {
    210                 printf(NAME ": Failed to initialize logging.\n");
    211                 return 1;
    212         }
    213 
     248        printf("%s: HelenOS loopback IP link provider\n", NAME);
     249       
     250        int rc = log_init(NAME);
     251        if (rc != EOK) {
     252                printf("%s: Failed to initialize logging.\n", NAME);
     253                return rc;
     254        }
     255       
    214256        rc = loopip_init();
    215257        if (rc != EOK)
    216                 return 1;
    217 
    218         printf(NAME ": Accepting connections.\n");
     258                return rc;
     259       
     260        printf("%s: Accepting connections.\n", NAME);
    219261        task_retval(0);
    220262        async_manager();
    221 
     263       
    222264        /* Not reached */
    223265        return 0;

  • uspace/srv/net/slip/Makefile

    rf2c19b0 r03c971f  
    11#
    2 # Copyright (c) 2005 Martin Decky
    3 # Copyright (c) 2007 Jakub Jermar
     2# Copyright (c) 2012 Jiri Svoboda
    43# All rights reserved.
    54#
    … …  
    2928
    3029USPACE_PREFIX = ../../..
    31 BINARY = ata_bd
     30BINARY = slip
    3231
    3332SOURCES = \
    34         ata_bd.c
     33        slip.c
    3534
    3635include $(USPACE_PREFIX)/Makefile.common

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

    rf2c19b0 r03c971f  
    312312static bool tcp_socket_match(tcp_sock_t *sock, tcp_sock_t *patt)
    313313{
    314         log_msg(LOG_DEFAULT, LVL_DEBUG2, "tcp_socket_match(sock=(%x,%u), pat=(%x,%u))",
    315             sock->addr.ipv4, sock->port, patt->addr.ipv4, patt->port);
    316 
    317         if (patt->addr.ipv4 != TCP_IPV4_ANY &&
    318             patt->addr.ipv4 != sock->addr.ipv4)
     314        log_msg(LOG_DEFAULT, LVL_DEBUG2,
     315            "tcp_socket_match(sock=(%u), pat=(%u))", sock->port, patt->port);
     316       
     317        if ((!inet_addr_is_any(&patt->addr)) &&
     318            (!inet_addr_compare(&patt->addr, &sock->addr)))
    319319                return false;
    320320
    321         if (patt->port != TCP_PORT_ANY &&
    322             patt->port != sock->port)
     321        if ((patt->port != TCP_PORT_ANY) &&
     322            (patt->port != sock->port))
    323323                return false;
    324324
    … …  
    355355        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_find_ref(%p)", sp);
    356356       
    357         log_msg(LOG_DEFAULT, LVL_DEBUG2, "compare conn (f:(%x,%u), l:(%x,%u))",
    358             sp->foreign.addr.ipv4, sp->foreign.port,
    359             sp->local.addr.ipv4, sp->local.port);
     357        log_msg(LOG_DEFAULT, LVL_DEBUG2, "compare conn (f:(%u), l:(%u))",
     358            sp->foreign.port, sp->local.port);
    360359       
    361360        fibril_mutex_lock(&conn_list_lock);
    … …  
    365364                tcp_sockpair_t *csp = &conn->ident;
    366365               
    367                 log_msg(LOG_DEFAULT, LVL_DEBUG2, " - with (f:(%x,%u), l:(%x,%u))",
    368                     csp->foreign.addr.ipv4, csp->foreign.port,
    369                     csp->local.addr.ipv4, csp->local.port);
     366                log_msg(LOG_DEFAULT, LVL_DEBUG2, " - with (f:(%u), l:(%u))",
     367                    csp->foreign.port, csp->local.port);
    370368               
    371369                if (tcp_sockpair_match(sp, csp)) {

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

    rf2c19b0 r03c971f  
    128128        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ncsim_fibril()");
    129129
    130 
    131130        while (true) {
    132131                fibril_mutex_lock(&sim_queue_lock);

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

    rf2c19b0 r03c971f  
    4040#include <mem.h>
    4141#include <stdlib.h>
     42#include <net/socket_codes.h>
    4243#include "pdu.h"
    4344#include "segment.h"
    … …  
    144145}
    145146
    146 static void tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr)
    147 {
    148         phdr->src_addr = host2uint32_t_be(pdu->src_addr.ipv4);
    149         phdr->dest_addr = host2uint32_t_be(pdu->dest_addr.ipv4);
    150         phdr->zero = 0;
    151         phdr->protocol = 6; /* XXX Magic number */
    152         phdr->tcp_length = host2uint16_t_be(pdu->header_size + pdu->text_size);
     147static uint16_t tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr,
     148    tcp_phdr6_t *phdr6)
     149{
     150        addr32_t src_v4;
     151        addr128_t src_v6;
     152        uint16_t src_af = inet_addr_get(&pdu->src, &src_v4, &src_v6);
     153       
     154        addr32_t dest_v4;
     155        addr128_t dest_v6;
     156        uint16_t dest_af = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
     157       
     158        assert(src_af == dest_af);
     159       
     160        switch (src_af) {
     161        case AF_INET:
     162                phdr->src = host2uint32_t_be(src_v4);
     163                phdr->dest = host2uint32_t_be(dest_v4);
     164                phdr->zero = 0;
     165                phdr->protocol = IP_PROTO_TCP;
     166                phdr->tcp_length =
     167                    host2uint16_t_be(pdu->header_size + pdu->text_size);
     168                break;
     169        case AF_INET6:
     170                host2addr128_t_be(src_v6, phdr6->src);
     171                host2addr128_t_be(dest_v6, phdr6->dest);
     172                phdr6->tcp_length =
     173                    host2uint32_t_be(pdu->header_size + pdu->text_size);
     174                memset(phdr6->zeroes, 0, 3);
     175                phdr6->next = IP_PROTO_TCP;
     176                break;
     177        default:
     178                assert(false);
     179        }
     180       
     181        return src_af;
    153182}
    154183
    … …  
    235264        uint16_t cs_phdr;
    236265        uint16_t cs_headers;
    237         uint16_t cs_all;
    238266        tcp_phdr_t phdr;
    239 
    240         tcp_phdr_setup(pdu, &phdr);
    241         cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *)&phdr,
    242             sizeof(tcp_phdr_t));
     267        tcp_phdr6_t phdr6;
     268       
     269        uint16_t af = tcp_phdr_setup(pdu, &phdr, &phdr6);
     270        switch (af) {
     271        case AF_INET:
     272                cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *) &phdr,
     273                    sizeof(tcp_phdr_t));
     274                break;
     275        case AF_INET6:
     276                cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *) &phdr6,
     277                    sizeof(tcp_phdr6_t));
     278                break;
     279        default:
     280                assert(false);
     281        }
     282       
    243283        cs_headers = tcp_checksum_calc(cs_phdr, pdu->header, pdu->header_size);
    244         cs_all = tcp_checksum_calc(cs_headers, pdu->text, pdu->text_size);
    245 
    246         return cs_all;
     284        return tcp_checksum_calc(cs_headers, pdu->text, pdu->text_size);
    247285}
    248286
    … …  
    271309
    272310        sp->local.port = uint16_t_be2host(hdr->dest_port);
    273         sp->local.addr = pdu->dest_addr;
     311        sp->local.addr = pdu->dest;
    274312        sp->foreign.port = uint16_t_be2host(hdr->src_port);
    275         sp->foreign.addr = pdu->src_addr;
     313        sp->foreign.addr = pdu->src;
    276314
    277315        *seg = nseg;
    … …  
    290328                return ENOMEM;
    291329
    292         npdu->src_addr = sp->local.addr;
    293         npdu->dest_addr = sp->foreign.addr;
     330        npdu->src = sp->local.addr;
     331        npdu->dest = sp->foreign.addr;
    294332        tcp_header_encode(sp, seg, &npdu->header, &npdu->header_size);
    295333

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

    rf2c19b0 r03c971f  
    179179        }
    180180
    181         sock->laddr.ipv4 = TCP_IPV4_ANY;
     181        inet_addr_any(&sock->laddr);
    182182        sock->lconn = NULL;
    183183        sock->backlog = 0;
    … …  
    314314        log_msg(LOG_DEFAULT, LVL_DEBUG, " - open connections");
    315315       
    316         lsocket.addr.ipv4 = TCP_IPV4_ANY;
     316        inet_addr_any(&lsocket.addr);
    317317        lsocket.port = sock_core->port;
    318         fsocket.addr.ipv4 = TCP_IPV4_ANY;
     318       
     319        inet_addr_any(&fsocket.addr);
    319320        fsocket.port = TCP_PORT_ANY;
    320321       
    … …  
    353354}
    354355
    355 static void tcp_sock_connect(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    356 {
    357         int rc;
    358         struct sockaddr_in *addr;
    359         int socket_id;
     356static void tcp_sock_connect(tcp_client_t *client, ipc_callid_t callid,
     357    ipc_call_t call)
     358{
     359        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect()");
     360       
     361        struct sockaddr_in6 *addr6 = NULL;
    360362        size_t addr_len;
    361         socket_core_t *sock_core;
    362         tcp_sockdata_t *socket;
    363         tcp_error_t trc;
    364         tcp_sock_t lsocket;
    365         tcp_sock_t fsocket;
    366 
    367         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect()");
    368 
    369         rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
    370         if (rc != EOK || addr_len != sizeof(struct sockaddr_in)) {
     363        int rc = async_data_write_accept((void **) &addr6, false, 0, 0, 0, &addr_len);
     364        if (rc != EOK) {
    371365                async_answer_0(callid, rc);
    372366                return;
    373367        }
    374 
    375         socket_id = SOCKET_GET_SOCKET_ID(call);
    376 
    377         sock_core = socket_cores_find(&client->sockets, socket_id);
     368       
     369        if ((addr_len != sizeof(struct sockaddr_in)) &&
     370            (addr_len != sizeof(struct sockaddr_in6))) {
     371                async_answer_0(callid, EINVAL);
     372                goto out;
     373        }
     374       
     375        struct sockaddr_in *addr = (struct sockaddr_in *) addr6;
     376       
     377        int socket_id = SOCKET_GET_SOCKET_ID(call);
     378        socket_core_t *sock_core = socket_cores_find(&client->sockets,
     379            socket_id);
    378380        if (sock_core == NULL) {
    379381                async_answer_0(callid, ENOTSOCK);
    380                 return;
    381         }
    382 
    383         socket = (tcp_sockdata_t *)sock_core->specific_data;
     382                goto out;
     383        }
     384       
     385        tcp_sockdata_t *socket =
     386            (tcp_sockdata_t *) sock_core->specific_data;
     387       
    384388        if (sock_core->port <= 0) {
    385389                rc = socket_bind_free_port(&gsock, sock_core,
    … …  
    388392                if (rc != EOK) {
    389393                        async_answer_0(callid, rc);
    390                         return;
     394                        goto out;
    391395                }
    392396               
    393397                last_used_port = sock_core->port;
    394398        }
    395 
     399       
    396400        fibril_mutex_lock(&socket->lock);
    397 
    398         if (socket->laddr.ipv4 == TCP_IPV4_ANY) {
     401       
     402        if (inet_addr_is_any(&socket->laddr)) {
    399403                /* Determine local IP address */
    400                 inet_addr_t loc_addr, rem_addr;
    401 
    402                 rem_addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
     404                inet_addr_t loc_addr;
     405                inet_addr_t rem_addr;
     406               
     407                switch (addr->sin_family) {
     408                case AF_INET:
     409                        inet_sockaddr_in_addr(addr, &rem_addr);
     410                        break;
     411                case AF_INET6:
     412                        inet_sockaddr_in6_addr(addr6, &rem_addr);
     413                        break;
     414                default:
     415                        fibril_mutex_unlock(&socket->lock);
     416                        async_answer_0(callid, EINVAL);
     417                        goto out;
     418                }
     419               
    403420                rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    404421                if (rc != EOK) {
    … …  
    407424                        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect: Failed to "
    408425                            "determine local address.");
    409                         return;
    410                 }
    411 
    412                 socket->laddr.ipv4 = loc_addr.ipv4;
    413                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Local IP address is %x", socket->laddr.ipv4);
    414         }
    415 
    416         lsocket.addr.ipv4 = socket->laddr.ipv4;
     426                        goto out;
     427                }
     428               
     429                socket->laddr = loc_addr;
     430        }
     431       
     432        tcp_sock_t lsocket;
     433        tcp_sock_t fsocket;
     434       
     435        lsocket.addr = socket->laddr;
    417436        lsocket.port = sock_core->port;
    418         fsocket.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
     437       
     438        switch (addr->sin_family) {
     439        case AF_INET:
     440                inet_sockaddr_in_addr(addr, &fsocket.addr);
     441                break;
     442        case AF_INET6:
     443                inet_sockaddr_in6_addr(addr6, &fsocket.addr);
     444                break;
     445        default:
     446                fibril_mutex_unlock(&socket->lock);
     447                async_answer_0(callid, EINVAL);
     448                goto out;
     449        }
     450       
    419451        fsocket.port = uint16_t_be2host(addr->sin_port);
    420 
    421         trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0, &socket->conn);
    422 
     452       
     453        tcp_error_t trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0,
     454            &socket->conn);
     455       
    423456        if (socket->conn != NULL)
    424                 socket->conn->name = (char *)"C";
    425 
     457                socket->conn->name = (char *) "C";
     458       
    426459        fibril_mutex_unlock(&socket->lock);
    427 
     460       
    428461        switch (trc) {
    429462        case TCP_EOK:
    … …  
    436469                assert(false);
    437470        }
    438 
     471       
    439472        if (rc == EOK)
    440473                fibril_add_ready(socket->recv_fibril);
    441 
     474       
    442475        async_answer_0(callid, rc);
     476       
     477out:
     478        if (addr6 != NULL)
     479                free(addr6);
    443480}
    444481
    … …  
    507544        /* Replenish listening connection */
    508545
    509         lsocket.addr.ipv4 = TCP_IPV4_ANY;
     546        inet_addr_any(&lsocket.addr);
    510547        lsocket.port = sock_core->port;
    511         fsocket.addr.ipv4 = TCP_IPV4_ANY;
     548       
     549        inet_addr_any(&fsocket.addr);
    512550        fsocket.port = TCP_PORT_ANY;
    513551
    … …  
    575613        ipc_callid_t wcallid;
    576614        size_t length;
    577         uint8_t buffer[TCP_SOCK_FRAGMENT_SIZE];
    578615        tcp_error_t trc;
    579616        int rc;
     617       
     618        uint8_t *buffer = calloc(TCP_SOCK_FRAGMENT_SIZE, 1);
     619        if (buffer == NULL) {
     620                async_answer_0(callid, ENOMEM);
     621                return;
     622        }
    580623
    581624        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_send()");
    … …  
    587630        if (sock_core == NULL) {
    588631                async_answer_0(callid, ENOTSOCK);
    589                 return;
     632                goto out;
    590633        }
    591634
    … …  
    603646                        fibril_mutex_unlock(&socket->lock);
    604647                        async_answer_0(callid, EINVAL);
    605                         return;
     648                        goto out;
    606649                }
    607650
    … …  
    613656                        fibril_mutex_unlock(&socket->lock);
    614657                        async_answer_0(callid, rc);
    615                         return;
     658                        goto out;
    616659                }
    617660
    … …  
    638681                        fibril_mutex_unlock(&socket->lock);
    639682                        async_answer_0(callid, rc);
    640                         return;
     683                        goto out;
    641684                }
    642685        }
    … …  
    647690            IPC_GET_ARG2(answer));
    648691        fibril_mutex_unlock(&socket->lock);
     692       
     693out:
     694        free(buffer);
    649695}
    650696
    … …  
    657703static void tcp_sock_recvfrom(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    658704{
    659         int socket_id;
    660         int flags;
    661         size_t addr_length, length;
    662         socket_core_t *sock_core;
    663         tcp_sockdata_t *socket;
    664         ipc_call_t answer;
    665         ipc_callid_t rcallid;
    666         size_t data_len;
    667         struct sockaddr_in addr;
    668         tcp_sock_t *rsock;
    669         int rc;
    670 
    671705        log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: tcp_sock_recv[from]()", client);
    672 
    673         socket_id = SOCKET_GET_SOCKET_ID(call);
    674         flags = SOCKET_GET_FLAGS(call);
    675 
    676         sock_core = socket_cores_find(&client->sockets, socket_id);
     706       
     707        int socket_id = SOCKET_GET_SOCKET_ID(call);
     708       
     709        socket_core_t *sock_core =
     710            socket_cores_find(&client->sockets, socket_id);
    677711        if (sock_core == NULL) {
    678712                async_answer_0(callid, ENOTSOCK);
    679713                return;
    680714        }
    681 
    682         socket = (tcp_sockdata_t *)sock_core->specific_data;
     715       
     716        tcp_sockdata_t *socket =
     717            (tcp_sockdata_t *) sock_core->specific_data;
     718       
    683719        fibril_mutex_lock(&socket->lock);
    684 
     720       
    685721        if (socket->conn == NULL) {
    686722                fibril_mutex_unlock(&socket->lock);
    … …  
    688724                return;
    689725        }
    690 
    691         (void)flags;
    692 
     726       
    693727        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom(): lock recv_buffer_lock");
     728       
    694729        fibril_mutex_lock(&socket->recv_buffer_lock);
    695         while (socket->recv_buffer_used == 0 && socket->recv_error == TCP_EOK) {
     730        while ((socket->recv_buffer_used == 0) &&
     731            (socket->recv_error == TCP_EOK)) {
    696732                log_msg(LOG_DEFAULT, LVL_DEBUG, "wait for recv_buffer_cv + recv_buffer_used != 0");
    697733                fibril_condvar_wait(&socket->recv_buffer_cv,
    698734                    &socket->recv_buffer_lock);
    699735        }
    700 
     736       
    701737        log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
    702 
    703         data_len = socket->recv_buffer_used;
    704         rc = socket->recv_error;
    705 
    706         switch (socket->recv_error) {
     738       
     739        size_t data_len = socket->recv_buffer_used;
     740        tcp_error_t trc = socket->recv_error;
     741        int rc;
     742       
     743        switch (trc) {
    707744        case TCP_EOK:
    708745                rc = EOK;
    … …  
    718755                assert(false);
    719756        }
    720 
     757       
    721758        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv result -> %d", rc);
     759       
    722760        if (rc != EOK) {
    723761                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    726764                return;
    727765        }
    728 
     766       
     767        ipc_callid_t rcallid;
     768       
    729769        if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
    730                 /* Fill addr */
    731                 rsock = &socket->conn->ident.foreign;
    732                 addr.sin_family = AF_INET;
    733                 addr.sin_addr.s_addr = host2uint32_t_be(rsock->addr.ipv4);
    734                 addr.sin_port = host2uint16_t_be(rsock->port);
    735 
    736                 log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
    737                 if (!async_data_read_receive(&rcallid, &addr_length)) {
     770                /* Fill address */
     771                tcp_sock_t *rsock = &socket->conn->ident.foreign;
     772                struct sockaddr_in addr;
     773                struct sockaddr_in6 addr6;
     774                size_t addr_length;
     775               
     776                uint16_t addr_af = inet_addr_sockaddr_in(&rsock->addr, &addr,
     777                    &addr6);
     778               
     779                switch (addr_af) {
     780                case AF_INET:
     781                        addr.sin_port = host2uint16_t_be(rsock->port);
     782                       
     783                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
     784                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     785                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     786                                fibril_mutex_unlock(&socket->lock);
     787                                async_answer_0(callid, EINVAL);
     788                                return;
     789                        }
     790                       
     791                        if (addr_length > sizeof(addr))
     792                                addr_length = sizeof(addr);
     793                       
     794                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
     795                        rc = async_data_read_finalize(rcallid, &addr, addr_length);
     796                        if (rc != EOK) {
     797                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     798                                fibril_mutex_unlock(&socket->lock);
     799                                async_answer_0(callid, EINVAL);
     800                                return;
     801                        }
     802                       
     803                        break;
     804                case AF_INET6:
     805                        addr6.sin6_port = host2uint16_t_be(rsock->port);
     806                       
     807                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read receive");
     808                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     809                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     810                                fibril_mutex_unlock(&socket->lock);
     811                                async_answer_0(callid, EINVAL);
     812                                return;
     813                        }
     814                       
     815                        if (addr_length > sizeof(addr6))
     816                                addr_length = sizeof(addr6);
     817                       
     818                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read finalize");
     819                        rc = async_data_read_finalize(rcallid, &addr6, addr_length);
     820                        if (rc != EOK) {
     821                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     822                                fibril_mutex_unlock(&socket->lock);
     823                                async_answer_0(callid, EINVAL);
     824                                return;
     825                        }
     826                       
     827                        break;
     828                default:
    738829                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    739830                        fibril_mutex_unlock(&socket->lock);
    … …  
    741832                        return;
    742833                }
    743 
    744                 if (addr_length > sizeof(addr))
    745                         addr_length = sizeof(addr);
    746 
    747                 log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
    748                 rc = async_data_read_finalize(rcallid, &addr, addr_length);
    749                 if (rc != EOK) {
    750                         fibril_mutex_unlock(&socket->recv_buffer_lock);
    751                         fibril_mutex_unlock(&socket->lock);
    752                         async_answer_0(callid, EINVAL);
    753                         return;
    754                 }
    755         }
    756 
     834        }
     835       
    757836        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
     837       
     838        size_t length;
    758839        if (!async_data_read_receive(&rcallid, &length)) {
    759840                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    762843                return;
    763844        }
    764 
     845       
    765846        if (length > data_len)
    766847                length = data_len;
    767 
     848       
    768849        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
     850       
    769851        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
    770 
     852       
    771853        socket->recv_buffer_used -= length;
     854       
    772855        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom: %zu left in buffer",
    773856            socket->recv_buffer_used);
     857       
    774858        if (socket->recv_buffer_used > 0) {
    775859                memmove(socket->recv_buffer, socket->recv_buffer + length,
    … …  
    777861                tcp_sock_notify_data(socket->sock_core);
    778862        }
    779 
     863       
    780864        fibril_condvar_broadcast(&socket->recv_buffer_cv);
    781 
    782         if (length < data_len && rc == EOK)
     865       
     866        if ((length < data_len) && (rc == EOK))
    783867                rc = EOVERFLOW;
    784 
     868       
     869        ipc_call_t answer;
     870       
    785871        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    786872        async_answer_1(callid, EOK, IPC_GET_ARG1(answer));
    787 
     873       
    788874        fibril_mutex_unlock(&socket->recv_buffer_lock);
    789875        fibril_mutex_unlock(&socket->lock);

  • uspace/srv/net/tcp/std.h

    rf2c19b0 r03c971f  
    3939
    4040#include <sys/types.h>
     41#include <inet/addr.h>
     42
     43#define IP_PROTO_TCP  6
    4144
    4245/** TCP Header (fixed part) */
    … …  
    7275};
    7376
    74 /** TCP pseudo header */
     77/** TCP over IPv4 checksum pseudo header */
    7578typedef struct {
    7679        /** Source address */
    77         uint32_t src_addr;
     80        uint32_t src;
    7881        /** Destination address */
    79         uint32_t dest_addr;
     82        uint32_t dest;
    8083        /** Zero */
    8184        uint8_t zero;
    … …  
    8588        uint16_t tcp_length;
    8689} tcp_phdr_t;
     90
     91/** TCP over IPv6 checksum pseudo header */
     92typedef struct {
     93        /** Source address */
     94        addr128_t src;
     95        /** Destination address */
     96        addr128_t dest;
     97        /** TCP length */
     98        uint32_t tcp_length;
     99        /** Zeroes */
     100        uint8_t zeroes[3];
     101        /** Next header */
     102        uint8_t next;
     103} tcp_phdr6_t;
    87104
    88105/** Option kind */

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

    rf2c19b0 r03c971f  
    5454#define NAME       "tcp"
    5555
    56 #define IP_PROTO_TCP 6
    57 
    5856static int tcp_inet_ev_recv(inet_dgram_t *dgram);
    5957static void tcp_received_pdu(tcp_pdu_t *pdu);
    … …  
    115113        }
    116114
    117         pdu->src_addr.ipv4 = dgram->src.ipv4;
    118         pdu->dest_addr.ipv4 = dgram->dest.ipv4;
    119         log_msg(LOG_DEFAULT, LVL_DEBUG, "src: 0x%08x, dest: 0x%08x",
    120             pdu->src_addr.ipv4, pdu->dest_addr.ipv4);
     115        pdu->src = dgram->src;
     116        pdu->dest = dgram->dest;
    121117
    122118        tcp_received_pdu(pdu);
    … …  
    145141            pdu->text_size);
    146142
    147         dgram.src.ipv4 = pdu->src_addr.ipv4;
    148         dgram.dest.ipv4 = pdu->dest_addr.ipv4;
     143        dgram.src = pdu->src;
     144        dgram.dest = pdu->dest;
    149145        dgram.tos = 0;
    150146        dgram.data = pdu_raw;

  • uspace/srv/net/tcp/tcp_type.h

    rf2c19b0 r03c971f  
    4343#include <socket_core.h>
    4444#include <sys/types.h>
     45#include <inet/addr.h>
    4546
    4647struct tcp_conn;
    … …  
    112113
    113114typedef struct {
    114         uint32_t ipv4;
    115 } netaddr_t;
    116 
    117 typedef struct {
    118         netaddr_t addr;
     115        inet_addr_t addr;
    119116        uint16_t port;
    120117} tcp_sock_t;
    121 
    122 enum netaddr {
    123         TCP_IPV4_ANY = 0
    124 };
    125118
    126119enum tcp_port {
    … …  
    313306typedef struct {
    314307        /** Source address */
    315         netaddr_t src_addr;
     308        inet_addr_t src;
    316309        /** Destination address */
    317         netaddr_t dest_addr;
    318 
     310        inet_addr_t dest;
    319311        /** Encoded header */
    320312        void *header;
    … …  
    344336        tcp_conn_t *conn;
    345337        /** Local address */
    346         netaddr_t laddr;
     338        inet_addr_t laddr;
    347339        /** Backlog size */
    348340        int backlog;

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

    rf2c19b0 r03c971f  
    5757
    5858        printf("test_srv()\n");
     59       
     60        inet_addr(&lsock.addr, 127, 0, 0, 1);
    5961        lsock.port = 80;
    60         lsock.addr.ipv4 = 0x7f000001;
     62       
     63        inet_addr(&fsock.addr, 127, 0, 0, 1);
    6164        fsock.port = 1024;
    62         fsock.addr.ipv4 = 0x7f000001;
     65       
    6366        printf("S: User open...\n");
    6467        tcp_uc_open(&lsock, &fsock, ap_passive, 0, &conn);
    … …  
    9598
    9699        printf("test_cli()\n");
    97 
     100       
     101        inet_addr(&lsock.addr, 127, 0, 0, 1);
    98102        lsock.port = 1024;
    99         lsock.addr.ipv4 = 0x7f000001;
     103       
     104        inet_addr(&fsock.addr, 127, 0, 0, 1);
    100105        fsock.port = 80;
    101         fsock.addr.ipv4 = 0x7f000001;
    102106
    103107        async_usleep(1000*1000*3);

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

    rf2c19b0 r03c971f  
    282282void tcp_transmit_segment(tcp_sockpair_t *sp, tcp_segment_t *seg)
    283283{
    284         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_transmit_segment(f:(%x,%u),l:(%x,%u), %p)",
    285             sp->foreign.addr.ipv4, sp->foreign.port,
    286             sp->local.addr.ipv4, sp->local.port, seg);
    287 
     284        log_msg(LOG_DEFAULT, LVL_DEBUG,
     285            "tcp_transmit_segment(f:(%u),l:(%u), %p)",
     286            sp->local.port, sp->foreign.port, seg);
     287       
    288288        log_msg(LOG_DEFAULT, LVL_DEBUG, "SEG.SEQ=%" PRIu32 ", SEG.WND=%" PRIu32,
    289289            seg->seq, seg->wnd);

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

    rf2c19b0 r03c971f  
    298298        tcp_conn_t *conn;
    299299
    300         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_as_segment_arrived(f:(%x,%u), l:(%x,%u))",
    301             sp->foreign.addr.ipv4, sp->foreign.port,
    302             sp->local.addr.ipv4, sp->local.port);
     300        log_msg(LOG_DEFAULT, LVL_DEBUG,
     301            "tcp_as_segment_arrived(f:(%u), l:(%u))",
     302            sp->foreign.port, sp->local.port);
    303303
    304304        conn = tcp_conn_find_ref(sp);
    … …  
    319319        }
    320320
    321         if (conn->ident.foreign.addr.ipv4 == TCP_IPV4_ANY)
    322                 conn->ident.foreign.addr.ipv4 = sp->foreign.addr.ipv4;
     321        if (inet_addr_is_any(&conn->ident.foreign.addr))
     322                conn->ident.foreign.addr = sp->foreign.addr;
     323       
    323324        if (conn->ident.foreign.port == TCP_PORT_ANY)
    324325                conn->ident.foreign.port = sp->foreign.port;
    325         if (conn->ident.local.addr.ipv4 == TCP_IPV4_ANY)
    326                 conn->ident.local.addr.ipv4 = sp->local.addr.ipv4;
     326       
     327        if (inet_addr_is_any(&conn->ident.local.addr))
     328                conn->ident.local.addr = sp->local.addr;
    327329
    328330        tcp_conn_segment_arrived(conn, seg);

  • uspace/srv/net/udp/assoc.c

    rf2c19b0 r03c971f  
    8282        if (lsock != NULL)
    8383                assoc->ident.local = *lsock;
     84       
    8485        if (fsock != NULL)
    8586                assoc->ident.foreign = *fsock;
    … …  
    251252                sp.foreign = *fsock;
    252253
    253         if (sp.foreign.addr.ipv4 == 0 || sp.foreign.port == 0)
     254        if ((inet_addr_is_any(&sp.foreign.addr)) ||
     255            (sp.foreign.port == UDP_PORT_ANY))
    254256                return EINVAL;
    255257
    … …  
    370372static bool udp_socket_match(udp_sock_t *sock, udp_sock_t *patt)
    371373{
    372         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_socket_match(sock=(%x,%u), pat=(%x,%u))",
    373             sock->addr.ipv4, sock->port, patt->addr.ipv4, patt->port);
    374 
    375         if (patt->addr.ipv4 != UDP_IPV4_ANY &&
    376             patt->addr.ipv4 != sock->addr.ipv4)
     374        log_msg(LOG_DEFAULT, LVL_DEBUG,
     375            "udp_socket_match(sock=(%u), pat=(%u))", sock->port, patt->port);
     376       
     377        if ((!inet_addr_is_any(&patt->addr)) &&
     378            (!inet_addr_compare(&patt->addr, &sock->addr)))
    377379                return false;
    378 
    379         if (patt->port != UDP_PORT_ANY &&
    380             patt->port != sock->port)
     380       
     381        if ((patt->port != UDP_PORT_ANY) &&
     382            (patt->port != sock->port))
    381383                return false;
    382 
     384       
    383385        log_msg(LOG_DEFAULT, LVL_DEBUG, " -> match");
    384 
     386       
    385387        return true;
    386388}
    … …  
    414416{
    415417        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_find_ref(%p)", sp);
    416 
     418       
    417419        fibril_mutex_lock(&assoc_list_lock);
    418 
     420       
    419421        list_foreach(assoc_list, link) {
    420422                udp_assoc_t *assoc = list_get_instance(link, udp_assoc_t, link);
    421423                udp_sockpair_t *asp = &assoc->ident;
    422                 log_msg(LOG_DEFAULT, LVL_DEBUG, "compare with assoc (f:(%x,%u), l:(%x,%u))",
    423                     asp->foreign.addr.ipv4, asp->foreign.port,
    424                     asp->local.addr.ipv4, asp->local.port);
    425 
     424               
    426425                /* Skip unbound associations */
    427426                if (asp->local.port == UDP_PORT_ANY)
    428427                        continue;
    429 
     428               
    430429                if (udp_sockpair_match(sp, asp)) {
    431430                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Returning assoc %p", assoc);
    … …  
    435434                }
    436435        }
    437 
     436       
    438437        fibril_mutex_unlock(&assoc_list_lock);
    439438        return NULL;

  • uspace/srv/net/udp/pdu.c

    rf2c19b0 r03c971f  
    4040#include <mem.h>
    4141#include <stdlib.h>
    42 
     42#include <inet/addr.h>
     43#include <net/socket_codes.h>
    4344#include "msg.h"
    4445#include "pdu.h"
    … …  
    8485}
    8586
    86 static void udp_phdr_setup(udp_pdu_t *pdu, udp_phdr_t *phdr)
    87 {
    88         phdr->src_addr = host2uint32_t_be(pdu->src.ipv4);
    89         phdr->dest_addr = host2uint32_t_be(pdu->dest.ipv4);
    90         phdr->zero = 0;
    91         phdr->protocol = IP_PROTO_UDP;
    92         phdr->udp_length = host2uint16_t_be(pdu->data_size);
     87static uint16_t udp_phdr_setup(udp_pdu_t *pdu, udp_phdr_t *phdr,
     88    udp_phdr6_t *phdr6)
     89{
     90        addr32_t src_v4;
     91        addr128_t src_v6;
     92        uint16_t src_af = inet_addr_get(&pdu->src, &src_v4, &src_v6);
     93       
     94        addr32_t dest_v4;
     95        addr128_t dest_v6;
     96        uint16_t dest_af = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
     97       
     98        assert(src_af == dest_af);
     99       
     100        switch (src_af) {
     101        case AF_INET:
     102                phdr->src_addr = host2uint32_t_be(src_v4);
     103                phdr->dest_addr = host2uint32_t_be(dest_v4);
     104                phdr->zero = 0;
     105                phdr->protocol = IP_PROTO_UDP;
     106                phdr->udp_length = host2uint16_t_be(pdu->data_size);
     107                break;
     108        case AF_INET6:
     109                host2addr128_t_be(src_v6, phdr6->src_addr);
     110                host2addr128_t_be(dest_v6, phdr6->dest_addr);
     111                phdr6->udp_length = host2uint32_t_be(pdu->data_size);
     112                memset(phdr6->zeroes, 0, 3);
     113                phdr6->next = IP_PROTO_UDP;
     114                break;
     115        default:
     116                assert(false);
     117        }
     118       
     119        return src_af;
    93120}
    94121
    … …  
    107134{
    108135        uint16_t cs_phdr;
    109         uint16_t cs_all;
    110136        udp_phdr_t phdr;
    111 
    112         udp_phdr_setup(pdu, &phdr);
    113         cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *)&phdr,
    114             sizeof(udp_phdr_t));
    115         cs_all = udp_checksum_calc(cs_phdr, pdu->data, pdu->data_size);
    116 
    117         return cs_all;
     137        udp_phdr6_t phdr6;
     138       
     139        uint16_t af = udp_phdr_setup(pdu, &phdr, &phdr6);
     140        switch (af) {
     141        case AF_INET:
     142                cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *) &phdr,
     143                    sizeof(udp_phdr_t));
     144                break;
     145        case AF_INET6:
     146                cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *) &phdr6,
     147                    sizeof(udp_phdr6_t));
     148                break;
     149        default:
     150                assert(false);
     151        }
     152       
     153        return udp_checksum_calc(cs_phdr, pdu->data, pdu->data_size);
    118154}
    119155

  • uspace/srv/net/udp/sock.c

    rf2c19b0 r03c971f  
    159159static void udp_sock_bind(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    160160{
    161         int rc;
    162         struct sockaddr_in *addr;
    163         size_t addr_size;
    164         socket_core_t *sock_core;
    165         udp_sockdata_t *socket;
    166         udp_sock_t fsock;
    167         udp_error_t urc;
    168 
    169161        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_bind()");
    170162        log_msg(LOG_DEFAULT, LVL_DEBUG, " - async_data_write_accept");
    171 
    172         addr = NULL;
    173 
    174         rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_size);
     163       
     164        struct sockaddr_in6 *addr6 = NULL;
     165        size_t addr_len;
     166        int rc = async_data_write_accept((void **) &addr6, false, 0, 0, 0, &addr_len);
    175167        if (rc != EOK) {
    176168                async_answer_0(callid, rc);
    177                 goto out;
    178         }
    179        
    180         if (addr_size != sizeof(struct sockaddr_in)) {
     169                return;
     170        }
     171       
     172        if ((addr_len != sizeof(struct sockaddr_in)) &&
     173            (addr_len != sizeof(struct sockaddr_in6))) {
    181174                async_answer_0(callid, EINVAL);
    182175                goto out;
    183176        }
    184177       
     178        struct sockaddr_in *addr = (struct sockaddr_in *) addr6;
     179       
    185180        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
     181       
    186182        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    187             addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
     183            addr6, addr_len, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
    188184            last_used_port);
    189185        if (rc != EOK) {
    … …  
    193189       
    194190        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
    195         sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
     191       
     192        socket_core_t *sock_core = socket_cores_find(&client->sockets,
     193            SOCKET_GET_SOCKET_ID(call));
    196194        if (sock_core == NULL) {
    197195                async_answer_0(callid, ENOENT);
    198196                goto out;
    199197        }
    200 
    201         socket = (udp_sockdata_t *)sock_core->specific_data;
    202 
    203         fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
    204         fsock.port = sock_core->port;
    205         urc = udp_uc_set_local(socket->assoc, &fsock);
    206 
     198       
     199        udp_sockdata_t *socket =
     200            (udp_sockdata_t *) sock_core->specific_data;
     201       
     202        udp_sock_t fsocket;
     203       
     204        fsocket.port = sock_core->port;
     205       
     206        switch (addr->sin_family) {
     207        case AF_INET:
     208                inet_sockaddr_in_addr(addr, &fsocket.addr);
     209                break;
     210        case AF_INET6:
     211                inet_sockaddr_in6_addr(addr6, &fsocket.addr);
     212                break;
     213        default:
     214                async_answer_0(callid, EINVAL);
     215                goto out;
     216        }
     217       
     218        udp_error_t urc = udp_uc_set_local(socket->assoc, &fsocket);
     219       
    207220        switch (urc) {
    208221        case UDP_EOK:
    … …  
    221234                assert(false);
    222235        }
    223 
     236       
    224237        log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
    225238        async_answer_0(callid, rc);
     239       
    226240out:
    227         if (addr != NULL)
    228                 free(addr);
     241        if (addr6 != NULL)
     242                free(addr6);
    229243}
    230244
    … …  
    251265        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_send()");
    252266       
    253         struct sockaddr_in *addr = NULL;
    254         udp_sock_t fsock;
    255         udp_sock_t *fsock_ptr;
     267        uint8_t *buffer = calloc(UDP_FRAGMENT_SIZE, 1);
     268        if (buffer == NULL) {
     269                async_answer_0(callid, ENOMEM);
     270                return;
     271        }
     272       
     273        struct sockaddr_in6 *addr6 = NULL;
     274        struct sockaddr_in *addr;
     275        udp_sock_t fsocket;
     276        udp_sock_t *fsocket_ptr;
    256277       
    257278        if (IPC_GET_IMETHOD(call) == NET_SOCKET_SENDTO) {
    258                 size_t addr_size;
    259                 int rc = async_data_write_accept((void **) &addr, false,
    260                     0, 0, 0, &addr_size);
     279                size_t addr_len;
     280                int rc = async_data_write_accept((void **) &addr6, false,
     281                    0, 0, 0, &addr_len);
    261282                if (rc != EOK) {
    262283                        async_answer_0(callid, rc);
    … …  
    264285                }
    265286               
    266                 if (addr_size != sizeof(struct sockaddr_in)) {
     287                if ((addr_len != sizeof(struct sockaddr_in)) &&
     288                    (addr_len != sizeof(struct sockaddr_in6))) {
    267289                        async_answer_0(callid, EINVAL);
    268290                        goto out;
    269291                }
    270292               
    271                 fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
    272                 fsock.port = uint16_t_be2host(addr->sin_port);
    273                 fsock_ptr = &fsock;
     293                addr = (struct sockaddr_in *) addr6;
     294               
     295                switch (addr->sin_family) {
     296                case AF_INET:
     297                        inet_sockaddr_in_addr(addr, &fsocket.addr);
     298                        break;
     299                case AF_INET6:
     300                        inet_sockaddr_in6_addr(addr6, &fsocket.addr);
     301                        break;
     302                default:
     303                        async_answer_0(callid, EINVAL);
     304                        goto out;
     305                }
     306               
     307                fsocket.port = uint16_t_be2host(addr->sin_port);
     308                fsocket_ptr = &fsocket;
    274309        } else
    275                 fsock_ptr = NULL;
     310                fsocket_ptr = NULL;
    276311       
    277312        int socket_id = SOCKET_GET_SOCKET_ID(call);
    … …  
    314349        fibril_mutex_lock(&socket->lock);
    315350       
    316         if (socket->assoc->ident.local.addr.ipv4 == UDP_IPV4_ANY) {
     351        if (inet_addr_is_any(&socket->assoc->ident.local.addr)) {
    317352                /* Determine local IP address */
    318                 inet_addr_t loc_addr, rem_addr;
    319                
    320                 rem_addr.ipv4 = fsock_ptr ? fsock.addr.ipv4 :
    321                     socket->assoc->ident.foreign.addr.ipv4;
     353                inet_addr_t loc_addr;
     354                inet_addr_t rem_addr;
     355               
     356                rem_addr = fsocket_ptr ? fsocket.addr :
     357                    socket->assoc->ident.foreign.addr;
    322358               
    323359                int rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    … …  
    327363                        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_sendto: Failed to "
    328364                            "determine local address.");
    329                         return;
    330                 }
    331                
    332                 socket->assoc->ident.local.addr.ipv4 = loc_addr.ipv4;
    333                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Local IP address is %x",
    334                     socket->assoc->ident.local.addr.ipv4);
     365                        goto out;
     366                }
     367               
     368                socket->assoc->ident.local.addr = loc_addr;
    335369        }
    336370       
    … …  
    351385                        length = UDP_FRAGMENT_SIZE;
    352386               
    353                 uint8_t buffer[UDP_FRAGMENT_SIZE];
    354387                int rc = async_data_write_finalize(wcallid, buffer, length);
    355388                if (rc != EOK) {
    … …  
    360393               
    361394                udp_error_t urc =
    362                     udp_uc_send(socket->assoc, fsock_ptr, buffer, length, 0);
     395                    udp_uc_send(socket->assoc, fsocket_ptr, buffer, length, 0);
    363396               
    364397                switch (urc) {
    … …  
    395428       
    396429out:
    397         if (addr != NULL)
    398                 free(addr);
     430        if (addr6 != NULL)
     431                free(addr6);
     432       
     433        free(buffer);
    399434}
    400435
    401436static void udp_sock_recvfrom(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    402437{
    403         int socket_id;
    404         int flags;
    405         size_t addr_length, length;
    406         socket_core_t *sock_core;
    407         udp_sockdata_t *socket;
    408         ipc_call_t answer;
    409         ipc_callid_t rcallid;
    410         size_t data_len;
    411         udp_error_t urc;
    412         udp_sock_t rsock;
    413         struct sockaddr_in addr;
    414         int rc;
    415 
    416438        log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: udp_sock_recv[from]()", client);
    417 
    418         socket_id = SOCKET_GET_SOCKET_ID(call);
    419         flags = SOCKET_GET_FLAGS(call);
    420 
    421         sock_core = socket_cores_find(&client->sockets, socket_id);
     439       
     440        int socket_id = SOCKET_GET_SOCKET_ID(call);
     441       
     442        socket_core_t *sock_core =
     443            socket_cores_find(&client->sockets, socket_id);
    422444        if (sock_core == NULL) {
    423445                async_answer_0(callid, ENOTSOCK);
    424446                return;
    425447        }
    426 
    427         socket = (udp_sockdata_t *)sock_core->specific_data;
     448       
     449        udp_sockdata_t *socket =
     450            (udp_sockdata_t *) sock_core->specific_data;
     451       
    428452        fibril_mutex_lock(&socket->lock);
    429 
     453       
    430454        if (socket->assoc == NULL) {
    431455                fibril_mutex_unlock(&socket->lock);
    … …  
    433457                return;
    434458        }
    435 
    436         (void)flags;
    437 
     459       
    438460        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
     461       
    439462        fibril_mutex_lock(&socket->recv_buffer_lock);
    440         while (socket->recv_buffer_used == 0 && socket->recv_error == UDP_EOK) {
     463       
     464        while ((socket->recv_buffer_used == 0) &&
     465            (socket->recv_error == UDP_EOK)) {
    441466                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
    442467                fibril_condvar_wait(&socket->recv_buffer_cv,
    443468                    &socket->recv_buffer_lock);
    444469        }
    445 
     470       
    446471        log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
    447 
    448         rsock = socket->recv_fsock;
    449         data_len = socket->recv_buffer_used;
    450         urc = socket->recv_error;
    451 
     472       
     473        size_t data_len = socket->recv_buffer_used;
     474        udp_error_t urc = socket->recv_error;
     475       
    452476        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv data_len=%zu", data_len);
    453 
     477       
     478        int rc;
     479       
    454480        switch (urc) {
    455481        case UDP_EOK:
    … …  
    466492                assert(false);
    467493        }
    468 
     494       
    469495        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
     496       
    470497        if (rc != EOK) {
    471498                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    474501                return;
    475502        }
    476 
     503       
     504        ipc_callid_t rcallid;
     505        size_t addr_size = 0;
     506       
    477507        if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
    478                 /* Fill addr */
    479                 addr.sin_family = AF_INET;
    480                 addr.sin_addr.s_addr = host2uint32_t_be(rsock.addr.ipv4);
    481                 addr.sin_port = host2uint16_t_be(rsock.port);
    482 
    483                 log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
    484                 if (!async_data_read_receive(&rcallid, &addr_length)) {
     508                /* Fill address */
     509                udp_sock_t *rsock = &socket->recv_fsock;
     510                struct sockaddr_in addr;
     511                struct sockaddr_in6 addr6;
     512                size_t addr_length;
     513               
     514                uint16_t addr_af = inet_addr_sockaddr_in(&rsock->addr, &addr,
     515                    &addr6);
     516               
     517                switch (addr_af) {
     518                case AF_INET:
     519                        addr.sin_port = host2uint16_t_be(rsock->port);
     520                       
     521                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
     522                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     523                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     524                                fibril_mutex_unlock(&socket->lock);
     525                                async_answer_0(callid, EINVAL);
     526                                return;
     527                        }
     528                       
     529                        if (addr_length > sizeof(addr))
     530                                addr_length = sizeof(addr);
     531                       
     532                        addr_size = sizeof(addr);
     533                       
     534                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
     535                        rc = async_data_read_finalize(rcallid, &addr, addr_length);
     536                        if (rc != EOK) {
     537                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     538                                fibril_mutex_unlock(&socket->lock);
     539                                async_answer_0(callid, EINVAL);
     540                                return;
     541                        }
     542                       
     543                        break;
     544                case AF_INET6:
     545                        addr6.sin6_port = host2uint16_t_be(rsock->port);
     546                       
     547                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read receive");
     548                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     549                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     550                                fibril_mutex_unlock(&socket->lock);
     551                                async_answer_0(callid, EINVAL);
     552                                return;
     553                        }
     554                       
     555                        if (addr_length > sizeof(addr6))
     556                                addr_length = sizeof(addr6);
     557                       
     558                        addr_size = sizeof(addr6);
     559                       
     560                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read finalize");
     561                        rc = async_data_read_finalize(rcallid, &addr6, addr_length);
     562                        if (rc != EOK) {
     563                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     564                                fibril_mutex_unlock(&socket->lock);
     565                                async_answer_0(callid, EINVAL);
     566                                return;
     567                        }
     568                       
     569                        break;
     570                default:
    485571                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    486572                        fibril_mutex_unlock(&socket->lock);
    … …  
    488574                        return;
    489575                }
    490 
    491                 if (addr_length > sizeof(addr))
    492                         addr_length = sizeof(addr);
    493 
    494                 log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
    495                 rc = async_data_read_finalize(rcallid, &addr, addr_length);
    496                 if (rc != EOK) {
    497                         fibril_mutex_unlock(&socket->recv_buffer_lock);
    498                         fibril_mutex_unlock(&socket->lock);
    499                         async_answer_0(callid, EINVAL);
    500                         return;
    501                 }
    502         }
    503 
     576        }
     577       
    504578        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
     579       
     580        size_t length;
    505581        if (!async_data_read_receive(&rcallid, &length)) {
    506582                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    509585                return;
    510586        }
    511 
     587       
    512588        if (length > data_len)
    513589                length = data_len;
    514 
     590       
    515591        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
     592       
    516593        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
    517 
    518         if (length < data_len && rc == EOK)
     594       
     595        if ((length < data_len) && (rc == EOK))
    519596                rc = EOVERFLOW;
    520 
     597       
    521598        log_msg(LOG_DEFAULT, LVL_DEBUG, "read_data_length <- %zu", length);
     599       
     600        ipc_call_t answer;
     601       
    522602        IPC_SET_ARG2(answer, 0);
    523603        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    524         SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(addr));
     604        SOCKET_SET_ADDRESS_LENGTH(answer, addr_size);
    525605        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    526606            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    527 
     607       
    528608        socket->recv_buffer_used = 0;
    529 
     609       
    530610        fibril_condvar_broadcast(&socket->recv_buffer_cv);
    531611        fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    602682        while (true) {
    603683                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] wait for rcv buffer empty()");
    604                 while (sock->recv_buffer_used != 0 && sock->sock_core != NULL) {
     684                while ((sock->recv_buffer_used != 0) && (sock->sock_core != NULL)) {
    605685                        fibril_condvar_wait(&sock->recv_buffer_cv,
    606686                            &sock->recv_buffer_lock);
    … …  
    623703                        log_msg(LOG_DEFAULT, LVL_DEBUG, "[] urc != UDP_EOK, break");
    624704                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
     705                        fibril_mutex_unlock(&sock->recv_buffer_lock);
    625706                        break;
    626707                }

  • uspace/srv/net/udp/std.h

    rf2c19b0 r03c971f  
    4040#include <sys/types.h>
    4141
    42 #define IP_PROTO_UDP 17
     42#define IP_PROTO_UDP  17
    4343
    4444/** UDP Header */
    … …  
    5454} udp_header_t;
    5555
    56 /** UDP pseudo header */
     56/** UDP over IPv4 checksum pseudo header */
    5757typedef struct {
    5858        /** Source address */
    … …  
    6464        /** Protocol */
    6565        uint8_t protocol;
    66         /** TCP length */
     66        /** UDP length */
    6767        uint16_t udp_length;
    6868} udp_phdr_t;
     69
     70/** UDP over IPv6 checksum pseudo header */
     71typedef struct {
     72        /** Source address */
     73        addr128_t src_addr;
     74        /** Destination address */
     75        addr128_t dest_addr;
     76        /** UDP length */
     77        uint32_t udp_length;
     78        /** Zeroes */
     79        uint8_t zeroes[3];
     80        /** Next header */
     81        uint8_t next;
     82} udp_phdr6_t;
    6983
    7084#endif

  • uspace/srv/net/udp/udp_inet.c

    rf2c19b0 r03c971f  
    6767        pdu->data_size = dgram->size;
    6868
    69         pdu->src.ipv4 = dgram->src.ipv4;
    70         pdu->dest.ipv4 = dgram->dest.ipv4;
    71         log_msg(LOG_DEFAULT, LVL_DEBUG, "src: 0x%08x, dest: 0x%08x",
    72             pdu->src.ipv4, pdu->dest.ipv4);
     69        pdu->src = dgram->src;
     70        pdu->dest = dgram->dest;
    7371
    7472        udp_received_pdu(pdu);
    … …  
    8684        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_transmit_pdu()");
    8785
    88         dgram.src.ipv4 = pdu->src.ipv4;
    89         dgram.dest.ipv4 = pdu->dest.ipv4;
     86        dgram.src = pdu->src;
     87        dgram.dest = pdu->dest;
    9088        dgram.tos = 0;
    9189        dgram.data = pdu->data;

  • uspace/srv/net/udp/udp_type.h

    rf2c19b0 r03c971f  
    4040#include <socket_core.h>
    4141#include <sys/types.h>
     42#include <inet/addr.h>
    4243
    4344#define UDP_FRAGMENT_SIZE 4096
    … …  
    5758
    5859typedef enum {
    59         XF_DUMMY        = 0x1
     60        XF_DUMMY = 0x1
    6061} xflags_t;
    61 
    62 typedef struct {
    63         uint32_t ipv4;
    64 } netaddr_t;
    65 
    66 enum netaddr {
    67         UDP_IPV4_ANY = 0
    68 };
    6962
    7063enum udp_port {
    … …  
    7366
    7467typedef struct {
    75         netaddr_t addr;
     68        inet_addr_t addr;
    7669        uint16_t port;
    7770} udp_sock_t;
    … …  
    9386typedef struct {
    9487        /** Source address */
    95         netaddr_t src;
     88        inet_addr_t src;
    9689        /** Destination address */
    97         netaddr_t dest;
    98 
     90        inet_addr_t dest;
     91       
    9992        /** Encoded PDU data including header */
    10093        void *data;
Note: See TracChangeset for help on using the changeset viewer.