Changeset 6a44ee4 in mainline for uspace/lib/net/il/arp_remote.c


Ignore:
Timestamp:
2011-07-20T15:26:21Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
efcebe1
Parents:
25bef0ff (diff), a701812 (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:

Merge mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/net/il/arp_remote.c

    r25bef0ff r6a44ee4  
    3838#include <arp_interface.h>
    3939#include <generic.h>
    40 
    41 #include <async.h>
    42 #include <errno.h>
    4340#include <ipc/services.h>
    4441#include <ipc/arp.h>
    45 
    4642#include <net/modules.h>
    4743#include <net/device.h>
    4844#include <adt/measured_strings.h>
     45#include <async.h>
     46#include <errno.h>
    4947
    50 /** Connects to the ARP module.
     48/** Connect to the ARP module.
    5149 *
    52  * @param service       The ARP module service. Ignored parameter.
    53  * @return              The ARP module phone on success.
     50 * @return ARP module session on success.
     51 *
    5452 */
    55 int arp_connect_module(services_t service)
     53async_sess_t *arp_connect_module(services_t service)
    5654{
    57         if (service != SERVICE_ARP)
    58                 return EINVAL;
    59 
     55        // FIXME: Get rid of the useless argument
    6056        return connect_to_service(SERVICE_ARP);
    6157}
    … …  
    6359/** Cleans the cache.
    6460 *
    65  * @param[in] arp_phone The ARP module phone used for (semi)remote calls.
    66  * @return              EOK on success.
     61 * @param[in] sess ARP module session.
     62 *
     63 * @return EOK on success.
     64 *
    6765 */
    68 int arp_clean_cache_req(int arp_phone)
     66int arp_clean_cache_req(async_sess_t *sess)
    6967{
    70         return (int) async_req_0_0(arp_phone, NET_ARP_CLEAN_CACHE);
     68        async_exch_t *exch = async_exchange_begin(sess);
     69        int rc = async_req_0_0(exch, NET_ARP_CLEAN_CACHE);
     70        async_exchange_end(exch);
     71       
     72        return rc;
    7173}
    7274
    73 /** Clears the given protocol address from the cache.
     75/** Clear the given protocol address from the cache.
    7476 *
    75  * @param[in] arp_phone The ARP module phone used for (semi)remote calls.
    76  * @param[in] device_id The device identifier.
    77  * @param[in] protocol  The requesting protocol service.
    78  * @param[in] address   The protocol address to be cleared.
    79  * @return              EOK on success.
    80  * @return              ENOENT if the mapping is not found.
     77 * @param[in] sess      ARP module session.
     78 * @param[in] device_id Device identifier.
     79 * @param[in] protocol  Requesting protocol service.
     80 * @param[in] address   Protocol address to be cleared.
     81 *
     82 * @return EOK on success.
     83 * @return ENOENT if the mapping is not found.
     84 *
    8185 */
    82 int
    83 arp_clear_address_req(int arp_phone, device_id_t device_id, services_t protocol,
    84     measured_string_t *address)
     86int arp_clear_address_req(async_sess_t *sess, device_id_t device_id,
     87    services_t protocol, measured_string_t *address)
    8588{
    86         aid_t message_id;
     89        async_exch_t *exch = async_exchange_begin(sess);
     90        aid_t message_id = async_send_2(exch, NET_ARP_CLEAR_ADDRESS,
     91            (sysarg_t) device_id, protocol, NULL);
     92        measured_strings_send(exch, address, 1);
     93        async_exchange_end(exch);
     94       
    8795        sysarg_t result;
     96        async_wait_for(message_id, &result);
     97       
     98        return (int) result;
     99}
    88100
    89         message_id = async_send_2(arp_phone, NET_ARP_CLEAR_ADDRESS,
    90             (sysarg_t) device_id, protocol, NULL);
    91         measured_strings_send(arp_phone, address, 1);
     101/** Clear the device cache.
     102 *
     103 * @param[in] sess      ARP module session.
     104 * @param[in] device_id Device identifier.
     105 *
     106 * @return EOK on success.
     107 * @return ENOENT if the device is not found.
     108 *
     109 */
     110int arp_clear_device_req(async_sess_t *sess, device_id_t device_id)
     111{
     112        async_exch_t *exch = async_exchange_begin(sess);
     113        int rc = async_req_1_0(exch, NET_ARP_CLEAR_DEVICE,
     114            (sysarg_t) device_id);
     115        async_exchange_end(exch);
     116       
     117        return rc;
     118}
     119
     120/** Register new device and the requesting protocol service.
     121 *
     122 * Connect to the network interface layer service.
     123 * Determine the device broadcast address, its address lengths and packet size.
     124 *
     125 * @param[in] sess      ARP module session.
     126 * @param[in] device_id New device identifier.
     127 * @param[in] protocol  Requesting protocol service.
     128 * @param[in] netif     Underlying device network interface layer service.
     129 * @param[in] address   Local requesting protocol address of the device.
     130 *
     131 * @return EOK on success.
     132 * @return EEXIST if the device is already used.
     133 * @return ENOMEM if there is not enough memory left.
     134 * @return ENOENT if the network interface service is not known.
     135 * @return EREFUSED if the network interface service is not
     136 *         responding.
     137 * @return Other error codes as defined for the
     138 *         nil_packet_get_size() function.
     139 * @return Other error codes as defined for the nil_get_addr()
     140 *         function.
     141 * @return Other error codes as defined for the
     142 *         nil_get_broadcast_addr() function.
     143 *
     144 */
     145int arp_device_req(async_sess_t *sess, device_id_t device_id,
     146    services_t protocol, services_t netif, measured_string_t *address)
     147{
     148        async_exch_t *exch = async_exchange_begin(sess);
     149        aid_t message_id = async_send_3(exch, NET_ARP_DEVICE,
     150            (sysarg_t) device_id, protocol, netif, NULL);
     151        measured_strings_send(exch, address, 1);
     152        async_exchange_end(exch);
     153       
     154        sysarg_t result;
    92155        async_wait_for(message_id, &result);
    93156
    … …  
    95158}
    96159
    97 /** Clears the device cache.
     160/** Translate the given protocol address to the network interface address.
    98161 *
    99  * @param[in] arp_phone The ARP module phone used for (semi)remote calls.
    100  * @param[in] device_id The device identifier.
    101  * @return              EOK on success.
    102  * @return              ENOENT if the device is not found.
     162 * Broadcast the ARP request if the mapping is not found.
     163 * Allocate and returns the needed memory block as the data parameter.
     164 *
     165 * @param[in]  sess        ARP module session.
     166 * @param[in]  device_id   Device identifier.
     167 * @param[in]  protocol    Requesting protocol service.
     168 * @param[in]  address     Local requesting protocol address.
     169 * @param[out] translation Translation of the local protocol address.
     170 * @param[out] data        Allocated raw translation data container.
     171 *
     172 * @return EOK on success.
     173 * @return EINVAL if the address parameter is NULL.
     174 * @return EBADMEM if the translation or the data parameters are
     175 *         NULL.
     176 * @return ENOENT if the mapping is not found.
     177 *
    103178 */
    104 int arp_clear_device_req(int arp_phone, device_id_t device_id)
     179int arp_translate_req(async_sess_t *sess, device_id_t device_id,
     180    services_t protocol, measured_string_t *address,
     181    measured_string_t **translation, uint8_t **data)
    105182{
    106         return (int) async_req_1_0(arp_phone, NET_ARP_CLEAR_DEVICE,
    107             (sysarg_t) device_id);
    108 }
    109 
    110 /** Registers the new device and the requesting protocol service.
    111  *
    112  * Connects to the network interface layer service.
    113  * Determines the device broadcast address, its address lengths and packet size.
    114  *
    115  * @param[in] arp_phone The ARP module phone used for (semi)remote calls.
    116  * @param[in] device_id The new device identifier.
    117  * @param[in] protocol  The requesting protocol service.
    118  * @param[in] netif     The underlying device network interface layer service.
    119  * @param[in] address   The local requesting protocol address of the device.
    120  * @return              EOK on success.
    121  * @return              EEXIST if the device is already used.
    122  * @return              ENOMEM if there is not enough memory left.
    123  * @return              ENOENT if the network interface service is not known.
    124  * @return              EREFUSED if the network interface service is not
    125  *                      responding.
    126  * @return              Other error codes as defined for the
    127  *                      nil_packet_get_size() function.
    128  * @return              Other error codes as defined for the nil_get_addr()
    129  *                      function.
    130  * @return              Other error codes as defined for the
    131  *                      nil_get_broadcast_addr() function.
    132  */
    133 int arp_device_req(int arp_phone, device_id_t device_id, services_t protocol,
    134     services_t netif, measured_string_t *address)
    135 {
    136         aid_t message_id;
    137         sysarg_t result;
    138 
    139         message_id = async_send_3(arp_phone, NET_ARP_DEVICE,
    140             (sysarg_t) device_id, protocol, netif, NULL);
    141         measured_strings_send(arp_phone, address, 1);
    142         async_wait_for(message_id, &result);
    143 
    144         return (int) result;
    145 }
    146 
    147 /** Translates the given protocol address to the network interface address.
    148  *
    149  * Broadcasts the ARP request if the mapping is not found.
    150  * Allocates and returns the needed memory block as the data parameter.
    151  *
    152  * @param[in] arp_phone The ARP module phone used for (semi)remote calls.
    153  * @param[in] device_id The device identifier.
    154  * @param[in] protocol  The requesting protocol service.
    155  * @param[in] address   The local requesting protocol address.
    156  * @param[out] translation The translation of the local protocol address.
    157  * @param[out] data     The allocated raw translation data container.
    158  * @return              EOK on success.
    159  * @return              EINVAL if the address parameter is NULL.
    160  * @return              EBADMEM if the translation or the data parameters are
    161  *                      NULL.
    162  * @return              ENOENT if the mapping is not found.
    163  */
    164 int
    165 arp_translate_req(int arp_phone, device_id_t device_id, services_t protocol,
    166     measured_string_t *address, measured_string_t **translation, uint8_t **data)
    167 {
    168         return generic_translate_req(arp_phone, NET_ARP_TRANSLATE, device_id,
     183        return generic_translate_req(sess, NET_ARP_TRANSLATE, device_id,
    169184            protocol, address, 1, translation, data);
    170185}
Note: See TracChangeset for help on using the changeset viewer.