Changeset 0e94b979 in mainline for uspace/srv


Ignore:
Timestamp:
2012-03-08T21:12:44Z (14 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
291c792
Parents:
a88a6eac
Message:

Listing configured addresses.

Location:
uspace/srv/inet
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/inet/addrobj.c

    ra88a6eac r0e94b979  
    3636
    3737#include <bitops.h>
     38#include <errno.h>
    3839#include <fibril_synch.h>
    3940#include <io/log.h>
    … …  
    4748static FIBRIL_MUTEX_INITIALIZE(addr_list_lock);
    4849static LIST_INITIALIZE(addr_list);
     50static sysarg_t addr_id = 0;
    4951
    5052static uint32_t inet_netmask(int bits)
    … …  
    6769
    6870        link_initialize(&addr->addr_list);
     71        fibril_mutex_lock(&addr_list_lock);
     72        addr->id = ++addr_id;
     73        fibril_mutex_unlock(&addr_list_lock);
    6974
    7075        return addr;
    … …  
    7378void inet_addrobj_delete(inet_addrobj_t *addr)
    7479{
     80        if (addr->name != NULL)
     81                free(addr->name);
    7582        free(addr);
    7683}
    … …  
    123130}
    124131
     132/** Find address object matching address @a addr.
     133 *
     134 * @param id    Address object ID
     135 * @return      Address object
     136 */
     137inet_addrobj_t *inet_addrobj_get_by_id(sysarg_t id)
     138{
     139        log_msg(LVL_DEBUG, "inet_addrobj_get_by_id(%zu)", (size_t)id);
     140
     141        fibril_mutex_lock(&addr_list_lock);
     142
     143        list_foreach(addr_list, link) {
     144                inet_addrobj_t *naddr = list_get_instance(link,
     145                    inet_addrobj_t, addr_list);
     146
     147                if (naddr->id == id) {
     148                        fibril_mutex_unlock(&addr_list_lock);
     149                        return naddr;
     150                }
     151        }
     152
     153        fibril_mutex_unlock(&addr_list_lock);
     154
     155        return NULL;
     156}
     157
    125158/** Send datagram to directly reachable destination */
    126159int inet_addrobj_send_dgram(inet_addrobj_t *addr, inet_dgram_t *dgram,
    … …  
    137170}
    138171
     172/** Get IDs of all address objects. */
     173int inet_addrobj_get_id_list(sysarg_t **rid_list, size_t *rcount)
     174{
     175        sysarg_t *id_list;
     176        size_t count, i;
     177
     178        fibril_mutex_lock(&addr_list_lock);
     179        count = list_count(&addr_list);
     180
     181        id_list = calloc(count, sizeof(sysarg_t));
     182        if (id_list == NULL) {
     183                fibril_mutex_unlock(&addr_list_lock);
     184                return ENOMEM;
     185        }
     186
     187        i = 0;
     188        list_foreach(addr_list, link) {
     189                inet_addrobj_t *addr = list_get_instance(link,
     190                    inet_addrobj_t, addr_list);
     191
     192                id_list[i++] = addr->id;
     193        }
     194
     195        fibril_mutex_unlock(&addr_list_lock);
     196
     197        *rid_list = id_list;
     198        *rcount = count;
     199
     200        return EOK;
     201}
     202
    139203/** @}
    140204 */

  • uspace/srv/inet/addrobj.h

    ra88a6eac r0e94b979  
    3838#define INET_ADDROBJ_H_
    3939
     40#include <sys/types.h>
    4041#include "inet.h"
    4142
    … …  
    5253extern void inet_addrobj_remove(inet_addrobj_t *);
    5354extern inet_addrobj_t *inet_addrobj_find(inet_addr_t *, inet_addrobj_find_t);
     55extern inet_addrobj_t *inet_addrobj_get_by_id(sysarg_t);
    5456extern int inet_addrobj_send_dgram(inet_addrobj_t *, inet_dgram_t *,
    5557    uint8_t, uint8_t, int);
     58extern int inet_addrobj_get_id_list(sysarg_t **, size_t *);
     59
    5660
    5761#endif

  • uspace/srv/inet/inet.h

    ra88a6eac r0e94b979  
    6868        /** Network address */
    6969        inet_naddr_t naddr;
     70        /** Link service ID */
     71        sysarg_t ilink;
     72        /** Address object name */
     73        char *name;
    7074} inet_addr_info_t;
    7175
    7276/** IP link info */
    7377typedef struct {
    74         int dummy;
     78        /** Link service name */
     79        char *name;
    7580} inet_link_info_t;
    7681
    … …  
    104109typedef struct {
    105110        link_t addr_list;
     111        sysarg_t id;
    106112        inet_naddr_t naddr;
    107113        inet_link_t *ilink;
     114        char *name;
    108115} inet_addrobj_t;
    109116

  • uspace/srv/inet/inet_link.c

    ra88a6eac r0e94b979  
    4242#include <loc.h>
    4343#include <stdlib.h>
     44#include <str.h>
    4445
    4546#include "addrobj.h"
    … …  
    196197        addr->naddr.bits = 24;
    197198        addr->ilink = ilink;
     199        addr->name = str_dup("v4a");
    198200        inet_addrobj_add(addr);
    199201

  • uspace/srv/inet/inetcfg.c

    ra88a6eac r0e94b979  
    4242#include <loc.h>
    4343#include <stdlib.h>
     44#include <str.h>
    4445#include <sys/types.h>
    4546
    … …  
    6768        addr->naddr = *naddr;
    6869        addr->ilink = ilink;
     70        addr->name = str_dup("foo");
    6971        inet_addrobj_add(addr);
    7072
    … …  
    8890static int inetcfg_addr_get(sysarg_t addr_id, inet_addr_info_t *ainfo)
    8991{
     92        inet_addrobj_t *addr;
     93
     94        addr = inet_addrobj_get_by_id(addr_id);
     95        if (addr == NULL)
     96                return ENOENT;
     97
     98        ainfo->naddr = addr->naddr;
     99        ainfo->ilink = addr->ilink->svc_id;
     100        ainfo->name = str_dup(addr->name);
     101
     102        return EOK;
     103}
     104
     105static int inetcfg_get_addr_list(sysarg_t **addrs, size_t *count)
     106{
     107        return inet_addrobj_get_id_list(addrs, count);
     108}
     109
     110static int inetcfg_get_link_list(sysarg_t **addrs, size_t *count)
     111{
    90112        return ENOTSUP;
    91113}
    92114
    93 static int inetcfg_get_addr_list(sysarg_t **addrs, size_t *count)
    94 {
    95         return ENOTSUP;
    96 }
    97 
    98 static int inetcfg_get_link_list(sysarg_t **addrs, size_t *count)
    99 {
    100         return ENOTSUP;
    101 }
    102 
    103 static int inetcfg_link_get(sysarg_t addr_id, inet_link_info_t *ainfo)
    104 {
    105         return ENOTSUP;
     115static int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
     116{
     117        inet_link_t *ilink;
     118
     119        ilink = inet_link_get_by_id(link_id);
     120        if (ilink == NULL) {
     121                return ENOENT;
     122        }
     123
     124        linfo->name = str_dup(ilink->svc_name);
     125        return EOK;
    106126}
    107127
    … …  
    140160static void inetcfg_addr_get_srv(ipc_callid_t callid, ipc_call_t *call)
    141161{
     162        ipc_callid_t rcallid;
     163        size_t max_size;
     164
    142165        sysarg_t addr_id;
    143166        inet_addr_info_t ainfo;
    … …  
    147170        log_msg(LVL_DEBUG, "inetcfg_addr_get_srv()");
    148171
     172        ainfo.naddr.ipv4 = 0;
     173        ainfo.naddr.bits = 0;
     174        ainfo.ilink = 0;
     175        ainfo.name = NULL;
     176
     177        if (!async_data_read_receive(&rcallid, &max_size)) {
     178                async_answer_0(rcallid, EREFUSED);
     179                async_answer_0(callid, EREFUSED);
     180                return;
     181        }
     182
    149183        rc = inetcfg_addr_get(addr_id, &ainfo);
    150         async_answer_2(callid, rc, ainfo.naddr.ipv4, ainfo.naddr.bits);
     184        if (rc != EOK) {
     185                async_answer_0(callid, rc);
     186                return;
     187        }
     188
     189        sysarg_t retval = async_data_read_finalize(rcallid, ainfo.name,
     190            min(max_size, str_size(ainfo.name)));
     191        free(ainfo.name);
     192
     193        async_answer_3(callid, retval, ainfo.naddr.ipv4, ainfo.naddr.bits,
     194            ainfo.ilink);
    151195}
    152196
    153197
    154198static void inetcfg_get_addr_list_srv(ipc_callid_t callid, ipc_call_t *call)
     199{
     200        ipc_callid_t rcallid;
     201        size_t count;
     202        size_t max_size;
     203        size_t act_size;
     204        size_t size;
     205        sysarg_t *id_buf;
     206        int rc;
     207
     208        log_msg(LVL_DEBUG, "inetcfg_get_addr_list_srv()");
     209
     210        if (!async_data_read_receive(&rcallid, &max_size)) {
     211                async_answer_0(rcallid, EREFUSED);
     212                async_answer_0(callid, EREFUSED);
     213                return;
     214        }
     215
     216        rc = inetcfg_get_addr_list(&id_buf, &count);
     217        if (rc != EOK) {
     218                async_answer_0(rcallid, rc);
     219                async_answer_0(callid, rc);
     220                return;
     221        }
     222
     223        act_size = count * sizeof(sysarg_t);
     224        size = min(act_size, max_size);
     225
     226        sysarg_t retval = async_data_read_finalize(rcallid, id_buf, size);
     227        free(id_buf);
     228
     229        async_answer_1(callid, retval, act_size);
     230}
     231
     232static void inetcfg_link_get_srv(ipc_callid_t callid, ipc_call_t *call)
     233{
     234        ipc_callid_t rcallid;
     235        size_t max_size;
     236
     237        sysarg_t link_id;
     238        inet_link_info_t linfo;
     239        int rc;
     240
     241        link_id = IPC_GET_ARG1(*call);
     242        log_msg(LVL_DEBUG, "inetcfg_link_get_srv()");
     243
     244        linfo.name = NULL;
     245
     246        if (!async_data_read_receive(&rcallid, &max_size)) {
     247                async_answer_0(rcallid, EREFUSED);
     248                async_answer_0(callid, EREFUSED);
     249                return;
     250        }
     251
     252        rc = inetcfg_link_get(link_id, &linfo);
     253        if (rc != EOK) {
     254                async_answer_0(rcallid, rc);
     255                async_answer_0(callid, rc);
     256                return;
     257        }
     258
     259        sysarg_t retval = async_data_read_finalize(rcallid, linfo.name,
     260            min(max_size, str_size(linfo.name)));
     261        free(linfo.name);
     262
     263        async_answer_0(callid, retval);
     264}
     265
     266static void inetcfg_get_link_list_srv(ipc_callid_t callid, ipc_call_t *call)
    155267{
    156268        ipc_callid_t rcallid;
    … …  
    161273        int rc;
    162274
    163         log_msg(LVL_DEBUG, "inetcfg_get_addr_list_srv()");
    164 
    165         if (!async_data_read_receive(&rcallid, &max_size)) {
    166                 async_answer_0(rcallid, EREFUSED);
    167                 async_answer_0(callid, EREFUSED);
    168                 return;
    169         }
    170 
    171         rc = inetcfg_get_addr_list(&id_buf, &act_size);
    172         if (rc != EOK) {
    173                 async_answer_0(rcallid, rc);
    174                 async_answer_0(callid, rc);
    175                 return;
    176         }
    177 
    178         size = min(act_size, max_size);
    179 
    180         sysarg_t retval = async_data_read_finalize(rcallid, id_buf, size);
    181         free(id_buf);
    182 
    183         async_answer_1(callid, retval, act_size);
    184 }
    185 
    186 static void inetcfg_link_get_srv(ipc_callid_t callid, ipc_call_t *call)
    187 {
    188         sysarg_t link_id;
    189         inet_link_info_t linfo;
    190         int rc;
    191 
    192         link_id = IPC_GET_ARG1(*call);
    193         log_msg(LVL_DEBUG, "inetcfg_link_get_srv()");
    194 
    195         rc = inetcfg_link_get(link_id, &linfo);
    196         async_answer_0(callid, rc);
    197 }
    198 
    199 static void inetcfg_get_link_list_srv(ipc_callid_t callid, ipc_call_t *call)
    200 {
    201         ipc_callid_t rcallid;
    202         size_t max_size;
    203         size_t act_size;
    204         size_t size;
    205         sysarg_t *id_buf;
    206         int rc;
    207 
    208275        log_msg(LVL_DEBUG, "inetcfg_get_link_list_srv()");
    209276
Note: See TracChangeset for help on using the changeset viewer.