Changeset 609243f4 in mainline for uspace/lib/net


Ignore:
Timestamp:
2011-10-07T15:46:01Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
e2c50e1
Parents:
f51b1d3
Message:

cherrypick general networking improvements from lp:~helenos-nicf/helenos/nicf (after sanitization)
remove obsolete networking drivers
this renders the networking non-functional for the time being

Location:
uspace/lib/net
Files:
3 deleted
23 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/net/Makefile

    rf51b1d3 r609243f4  
    4040        generic/protocol_map.c \
    4141        adt/module_map.c \
    42         netif/netif_remote.c \
    43         netif/netif_skel.c \
    4442        nil/nil_remote.c \
    4543        nil/nil_skel.c \

  • uspace/lib/net/generic/generic.c

    rf51b1d3 r609243f4  
    5454 */
    5555int generic_device_state_msg_remote(async_sess_t *sess, sysarg_t message,
    56     device_id_t device_id, sysarg_t state, services_t target)
     56    nic_device_id_t device_id, sysarg_t state, services_t target)
    5757{
    5858        async_exch_t *exch = async_exchange_begin(sess);
    … …  
    6868 * @param[in] message   Service specific message.
    6969 * @param[in] device_id Device identifier.
    70  * @param[in] arg2      Second argument of the message.
    7170 * @param[in] service   Device module service.
    7271 *
    … …  
    7776 */
    7877int generic_device_req_remote(async_sess_t *sess, sysarg_t message,
    79     device_id_t device_id, sysarg_t arg2, services_t service)
    80 {
    81         async_exch_t *exch = async_exchange_begin(sess);
    82         int rc = async_req_3_0(exch, message, (sysarg_t) device_id,
    83             arg2, (sysarg_t) service);
     78    nic_device_id_t device_id, services_t service)
     79{
     80        async_exch_t *exch = async_exchange_begin(sess);
     81        int rc = async_req_2_0(exch, message, (sysarg_t) device_id,
     82            (sysarg_t) service);
    8483        async_exchange_end(exch);
    8584       
    … …  
    103102 */
    104103int generic_get_addr_req(async_sess_t *sess, sysarg_t message,
    105     device_id_t device_id, measured_string_t **address, uint8_t **data)
    106 {
    107         if ((!address) || (!data))
     104    nic_device_id_t device_id, uint8_t *address, size_t max_len)
     105{
     106        if (!address)
    108107                return EBADMEM;
    109108       
    110109        /* Request the address */
    111110        async_exch_t *exch = async_exchange_begin(sess);
    112         aid_t message_id = async_send_1(exch, message, (sysarg_t) device_id,
     111        aid_t aid = async_send_1(exch, message, (sysarg_t) device_id,
    113112            NULL);
    114         int rc = measured_strings_return(exch, address, data, 1);
     113        int rc = async_data_read_start(exch, address, max_len);
    115114        async_exchange_end(exch);
    116115       
    117116        sysarg_t result;
    118         async_wait_for(message_id, &result);
    119        
    120         /* If not successful */
    121         if ((rc == EOK) && (result != EOK)) {
    122                 /* Clear the data */
    123                 free(*address);
    124                 free(*data);
    125         }
     117        async_wait_for(aid, &result);
     118       
     119        if (rc != EOK)
     120                return rc;
    126121       
    127122        return (int) result;
    … …  
    142137 */
    143138int generic_packet_size_req_remote(async_sess_t *sess, sysarg_t message,
    144     device_id_t device_id, packet_dimension_t *packet_dimension)
     139    nic_device_id_t device_id, packet_dimension_t *packet_dimension)
    145140{
    146141        if (!packet_dimension)
    … …  
    179174 */
    180175int generic_received_msg_remote(async_sess_t *sess, sysarg_t message,
    181     device_id_t device_id, packet_id_t packet_id, services_t target,
     176    nic_device_id_t device_id, packet_id_t packet_id, services_t target,
    182177    services_t error)
    183178{
    … …  
    210205 */
    211206int generic_send_msg_remote(async_sess_t *sess, sysarg_t message,
    212     device_id_t device_id, packet_id_t packet_id, services_t sender,
     207    nic_device_id_t device_id, packet_id_t packet_id, services_t sender,
    213208    services_t error)
    214209{
    … …  
    251246 */
    252247int generic_translate_req(async_sess_t *sess, sysarg_t message,
    253     device_id_t device_id, services_t service,
     248    nic_device_id_t device_id, services_t service,
    254249    measured_string_t *configuration, size_t count,
    255250    measured_string_t **translation, uint8_t **data)

  • uspace/lib/net/generic/net_checksum.c

    rf51b1d3 r609243f4  
    4040
    4141/** Big-endian encoding CRC divider. */
    42 #define CRC_DIVIDER_BE  0x04c11db7
     42#define CRC_DIVIDER_BE  0x04c11db7
    4343
    4444/** Little-endian encoding CRC divider. */
    45 #define CRC_DIVIDER_LE  0xedb88320
     45#define CRC_DIVIDER_LE  0xedb88320
    4646
    4747/** Compacts the computed checksum to the 16 bit number adding the carries.
    … …  
    203203}
    204204
    205 /** Computes the ip header checksum.
     205/** Compute the IP header checksum.
    206206 *
    207207 * To compute the checksum of a new packet, the checksum header field must be

  • uspace/lib/net/generic/net_remote.c

    rf51b1d3 r609243f4  
    3838#include <ipc/services.h>
    3939#include <ipc/net_net.h>
    40 
    4140#include <malloc.h>
    42 
     41#include <async.h>
     42#include <devman.h>
    4343#include <generic.h>
    4444#include <net/modules.h>
    … …  
    9898    size_t count, uint8_t **data)
    9999{
    100         return generic_translate_req(sess, NET_NET_GET_DEVICE_CONF, 0, 0,
     100        return generic_translate_req(sess, NET_NET_GET_CONF, 0, 0,
    101101            *configuration, count, configuration, data);
    102102}
    … …  
    124124 *
    125125 */
    126 int net_get_device_conf_req(async_sess_t *sess, device_id_t device_id,
     126int net_get_device_conf_req(async_sess_t *sess, nic_device_id_t device_id,
    127127    measured_string_t **configuration, size_t count, uint8_t **data)
    128128{
    … …  
    131131}
    132132
     133int net_get_devices_req(async_sess_t *sess, measured_string_t **devices,
     134    size_t *count, uint8_t **data)
     135{
     136        if ((!devices) || (!count))
     137                return EBADMEM;
     138       
     139        async_exch_t *exch = async_exchange_begin(sess);
     140       
     141        int rc = async_req_0_1(exch, NET_NET_GET_DEVICES_COUNT, count);
     142        if (rc != EOK) {
     143                async_exchange_end(exch);
     144                return rc;
     145        }
     146       
     147        if (*count == 0) {
     148                async_exchange_end(exch);
     149                *data = NULL;
     150                return EOK;
     151        }
     152       
     153        aid_t message_id = async_send_0(exch, NET_NET_GET_DEVICES, NULL);
     154        rc = measured_strings_return(exch, devices, data, *count);
     155       
     156        async_exchange_end(exch);
     157       
     158        sysarg_t result;
     159        async_wait_for(message_id, &result);
     160       
     161        if ((rc == EOK) && (result != EOK)) {
     162                free(*devices);
     163                free(*data);
     164        }
     165       
     166        return (int) result;
     167}
     168
     169int net_driver_ready(async_sess_t *sess, devman_handle_t handle)
     170{
     171        async_exch_t *exch = async_exchange_begin(sess);
     172        int rc = async_req_1_0(exch, NET_NET_DRIVER_READY, handle);
     173        async_exchange_end(exch);
     174       
     175        return rc;
     176}
     177
    133178/** @}
    134179 */

  • uspace/lib/net/generic/protocol_map.c

    rf51b1d3 r609243f4  
    5050        switch (nil) {
    5151        case SERVICE_ETHERNET:
    52         case SERVICE_NE2000:
     52        case SERVICE_NILDUMMY:
    5353                switch (il) {
    5454                case SERVICE_IP:
    … …  
    7676        switch (nil) {
    7777        case SERVICE_ETHERNET:
    78         case SERVICE_NE2000:
     78        case SERVICE_NILDUMMY:
    7979                switch (protocol) {
    8080                case ETH_P_IP:
    … …  
    139139        switch (nil) {
    140140        case SERVICE_ETHERNET:
    141         case SERVICE_NE2000:
    142141                return HW_ETHER;
    143142        default:

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

    rf51b1d3 r609243f4  
    8484 *
    8585 */
    86 int arp_clear_address_req(async_sess_t *sess, device_id_t device_id,
     86int arp_clear_address_req(async_sess_t *sess, nic_device_id_t device_id,
    8787    services_t protocol, measured_string_t *address)
    8888{
    … …  
    108108 *
    109109 */
    110 int arp_clear_device_req(async_sess_t *sess, device_id_t device_id)
     110int arp_clear_device_req(async_sess_t *sess, nic_device_id_t device_id)
    111111{
    112112        async_exch_t *exch = async_exchange_begin(sess);
    … …  
    143143 *
    144144 */
    145 int arp_device_req(async_sess_t *sess, device_id_t device_id,
     145int arp_device_req(async_sess_t *sess, nic_device_id_t device_id,
    146146    services_t protocol, services_t netif, measured_string_t *address)
    147147{
    … …  
    177177 *
    178178 */
    179 int arp_translate_req(async_sess_t *sess, device_id_t device_id,
     179int arp_translate_req(async_sess_t *sess, nic_device_id_t device_id,
    180180    services_t protocol, measured_string_t *address,
    181181    measured_string_t **translation, uint8_t **data)

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

    rf51b1d3 r609243f4  
    5555 *
    5656 */
    57 int il_device_state_msg(async_sess_t *sess, device_id_t device_id,
    58     device_state_t state, services_t target)
     57int il_device_state_msg(async_sess_t *sess, nic_device_id_t device_id,
     58    nic_device_state_t state, services_t target)
    5959{
    6060        return generic_device_state_msg_remote(sess, NET_IL_DEVICE_STATE,
    … …  
    7373 *
    7474 */
    75 int il_received_msg(async_sess_t *sess, device_id_t device_id, packet_t *packet,
    76     services_t target)
     75int il_received_msg(async_sess_t *sess, nic_device_id_t device_id,
     76    packet_t *packet, services_t target)
    7777{
    7878        return generic_received_msg_remote(sess, NET_IL_RECEIVED, device_id,
    … …  
    9191 *
    9292 */
    93 int il_mtu_changed_msg(async_sess_t *sess, device_id_t device_id, size_t mtu,
     93int il_mtu_changed_msg(async_sess_t *sess, nic_device_id_t device_id, size_t mtu,
    9494    services_t target)
    9595{
    … …  
    9898}
    9999
     100/** Notify IL layer modules about address change (implemented by ARP)
     101 *
     102 */
     103int il_addr_changed_msg(async_sess_t *sess, nic_device_id_t device_id,
     104    size_t addr_len, const uint8_t *address)
     105{
     106        async_exch_t *exch = async_exchange_begin(sess);
     107       
     108        aid_t message_id = async_send_1(exch, NET_IL_ADDR_CHANGED,
     109                        (sysarg_t) device_id, NULL);
     110        int rc = async_data_write_start(exch, address, addr_len);
     111       
     112        async_exchange_end(exch);
     113       
     114        sysarg_t res;
     115    async_wait_for(message_id, &res);
     116    if (rc != EOK)
     117                return rc;
     118       
     119    return (int) res;
     120}
     121
    100122/** @}
    101123 */

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

    rf51b1d3 r609243f4  
    6262 *
    6363 */
    64 int ip_add_route_req_remote(async_sess_t *sess, device_id_t device_id,
     64int ip_add_route_req_remote(async_sess_t *sess, nic_device_id_t device_id,
    6565    in_addr_t address, in_addr_t netmask, in_addr_t gateway)
    6666{
    … …  
    123123 *
    124124 */
    125 int ip_device_req_remote(async_sess_t *sess, device_id_t device_id,
     125int ip_device_req_remote(async_sess_t *sess, nic_device_id_t device_id,
    126126    services_t service)
    127127{
    128         return generic_device_req_remote(sess, NET_IP_DEVICE, device_id, 0,
     128        return generic_device_req_remote(sess, NET_IP_DEVICE, device_id,
    129129            service);
    130130}
    … …  
    144144int ip_get_route_req_remote(async_sess_t *sess, ip_protocol_t protocol,
    145145    const struct sockaddr *destination, socklen_t addrlen,
    146     device_id_t *device_id, void **header, size_t *headerlen)
     146    nic_device_id_t *device_id, void **header, size_t *headerlen)
    147147{
    148148        if ((!destination) || (addrlen == 0))
    … …  
    196196 *
    197197 */
    198 int ip_packet_size_req_remote(async_sess_t *sess, device_id_t device_id,
     198int ip_packet_size_req_remote(async_sess_t *sess, nic_device_id_t device_id,
    199199    packet_dimension_t *packet_dimension)
    200200{
    … …  
    216216 *
    217217 */
    218 int ip_received_error_msg_remote(async_sess_t *sess, device_id_t device_id,
     218int ip_received_error_msg_remote(async_sess_t *sess, nic_device_id_t device_id,
    219219    packet_t *packet, services_t target, services_t error)
    220220{
    … …  
    240240 *
    241241 */
    242 int ip_send_msg_remote(async_sess_t *sess, device_id_t device_id,
     242int ip_send_msg_remote(async_sess_t *sess, nic_device_id_t device_id,
    243243    packet_t *packet, services_t sender, services_t error)
    244244{
    … …  
    256256 *
    257257 */
    258 int ip_set_gateway_req_remote(async_sess_t *sess, device_id_t device_id,
     258int ip_set_gateway_req_remote(async_sess_t *sess, nic_device_id_t device_id,
    259259    in_addr_t gateway)
    260260{

  • uspace/lib/net/include/arp_interface.h

    rf51b1d3 r609243f4  
    4646/*@{*/
    4747
    48 extern int arp_device_req(async_sess_t *, device_id_t, services_t, services_t,
     48extern int arp_device_req(async_sess_t *, nic_device_id_t, services_t, services_t,
    4949    measured_string_t *);
    50 extern int arp_translate_req(async_sess_t *, device_id_t, services_t,
     50extern int arp_translate_req(async_sess_t *, nic_device_id_t, services_t,
    5151    measured_string_t *, measured_string_t **, uint8_t **);
    52 extern int arp_clear_device_req(async_sess_t *, device_id_t);
    53 extern int arp_clear_address_req(async_sess_t *, device_id_t, services_t,
     52extern int arp_clear_device_req(async_sess_t *, nic_device_id_t);
     53extern int arp_clear_address_req(async_sess_t *, nic_device_id_t, services_t,
    5454    measured_string_t *);
    5555extern int arp_clean_cache_req(async_sess_t *);

  • uspace/lib/net/include/generic.h

    rf51b1d3 r609243f4  
    4545
    4646extern int generic_device_state_msg_remote(async_sess_t *, sysarg_t,
    47     device_id_t, sysarg_t, services_t);
    48 extern int generic_device_req_remote(async_sess_t *, sysarg_t, device_id_t,
    49     sysarg_t, services_t);
    50 extern int generic_get_addr_req(async_sess_t *, sysarg_t, device_id_t,
    51     measured_string_t **, uint8_t **);
    52 extern int generic_packet_size_req_remote(async_sess_t *, sysarg_t, device_id_t,
    53     packet_dimension_t *);
    54 extern int generic_received_msg_remote(async_sess_t *, sysarg_t, device_id_t,
     47    nic_device_id_t, sysarg_t, services_t);
     48extern int generic_device_req_remote(async_sess_t *, sysarg_t, nic_device_id_t,
     49    services_t);
     50extern int generic_get_addr_req(async_sess_t *, sysarg_t, nic_device_id_t,
     51    uint8_t *address, size_t max_length);
     52extern int generic_packet_size_req_remote(async_sess_t *, sysarg_t,
     53    nic_device_id_t, packet_dimension_t *);
     54extern int generic_received_msg_remote(async_sess_t *, sysarg_t,
     55    nic_device_id_t, packet_id_t, services_t, services_t);
     56extern int generic_send_msg_remote(async_sess_t *, sysarg_t, nic_device_id_t,
    5557    packet_id_t, services_t, services_t);
    56 extern int generic_send_msg_remote(async_sess_t *, sysarg_t, device_id_t,
    57     packet_id_t, services_t, services_t);
    58 extern int generic_translate_req(async_sess_t *, sysarg_t, device_id_t,
     58extern int generic_translate_req(async_sess_t *, sysarg_t, nic_device_id_t,
    5959    services_t, measured_string_t *, size_t, measured_string_t **, uint8_t **);
    6060

  • uspace/lib/net/include/il_remote.h

    rf51b1d3 r609243f4  
    5050/*@{*/
    5151
    52 extern int il_device_state_msg(async_sess_t *, device_id_t, device_state_t,
     52extern int il_device_state_msg(async_sess_t *, nic_device_id_t,
     53    nic_device_state_t, services_t);
     54extern int il_received_msg(async_sess_t *, nic_device_id_t, packet_t *,
    5355    services_t);
    54 extern int il_received_msg(async_sess_t *, device_id_t, packet_t *, services_t);
    55 extern int il_mtu_changed_msg(async_sess_t *, device_id_t, size_t, services_t);
     56extern int il_mtu_changed_msg(async_sess_t *, nic_device_id_t, size_t,
     57    services_t);
     58extern int il_addr_changed_msg(async_sess_t *, nic_device_id_t, size_t,
     59    const uint8_t *);
    5660
    5761/*@}*/

  • uspace/lib/net/include/ip_interface.h

    rf51b1d3 r609243f4  
    6969 *
    7070 */
    71 typedef int (*tl_received_msg_t)(device_id_t device_id, packet_t *packet,
     71typedef int (*tl_received_msg_t)(nic_device_id_t device_id, packet_t *packet,
    7272    services_t receiver, services_t error);
    7373

  • uspace/lib/net/include/ip_remote.h

    rf51b1d3 r609243f4  
    4343#include <async.h>
    4444
    45 extern int ip_set_gateway_req_remote(async_sess_t *, device_id_t, in_addr_t);
    46 extern int ip_packet_size_req_remote(async_sess_t *, device_id_t,
     45extern int ip_set_gateway_req_remote(async_sess_t *, nic_device_id_t, in_addr_t);
     46extern int ip_packet_size_req_remote(async_sess_t *, nic_device_id_t,
    4747    packet_dimension_t *);
    48 extern int ip_received_error_msg_remote(async_sess_t *, device_id_t, packet_t *,
     48extern int ip_received_error_msg_remote(async_sess_t *, nic_device_id_t, packet_t *,
    4949    services_t, services_t);
    50 extern int ip_device_req_remote(async_sess_t *, device_id_t, services_t);
    51 extern int ip_add_route_req_remote(async_sess_t *, device_id_t, in_addr_t,
     50extern int ip_device_req_remote(async_sess_t *, nic_device_id_t, services_t);
     51extern int ip_add_route_req_remote(async_sess_t *, nic_device_id_t, in_addr_t,
    5252    in_addr_t, in_addr_t);
    53 extern int ip_send_msg_remote(async_sess_t *, device_id_t, packet_t *,
     53extern int ip_send_msg_remote(async_sess_t *, nic_device_id_t, packet_t *,
    5454    services_t, services_t);
    5555extern int ip_get_route_req_remote(async_sess_t *, ip_protocol_t,
    56     const struct sockaddr *, socklen_t, device_id_t *, void **, size_t *);
     56    const struct sockaddr *, socklen_t, nic_device_id_t *, void **, size_t *);
    5757
    5858#endif

  • uspace/lib/net/include/net_checksum.h

    rf51b1d3 r609243f4  
    3030 * @{
    3131 */
    32 
    3332/** @file
    3433 * General CRC and checksum computation.
    … …  
    4241
    4342/** IP checksum value for computed zero checksum.
     43 *
    4444 * Zero is returned as 0xFFFF (not flipped)
     45 *
    4546 */
    46 #define IP_CHECKSUM_ZERO        0xffffU
     47#define IP_CHECKSUM_ZERO  0xffffU
    4748
    48 #ifdef ARCH_IS_BIG_ENDIAN
     49#ifdef __BE__
     50
    4951#define compute_crc32(seed, data, length) \
    5052        compute_crc32_be(seed, (uint8_t *) data, length)
    51 #else
     53
     54#endif
     55
     56#ifdef __LE__
     57
    5258#define compute_crc32(seed, data, length) \
    5359        compute_crc32_le(seed, (uint8_t *) data, length)
     60
    5461#endif
    5562

  • uspace/lib/net/include/net_interface.h

    rf51b1d3 r609243f4  
    3535
    3636#include <ipc/services.h>
    37 
    3837#include <net/device.h>
    3938#include <adt/measured_strings.h>
    4039#include <async.h>
     40#include <devman.h>
    4141
    4242/** @name Networking module interface
    … …  
    4545/*@{*/
    4646
    47 extern int net_get_device_conf_req(async_sess_t *, device_id_t,
     47extern int net_get_device_conf_req(async_sess_t *, nic_device_id_t,
    4848    measured_string_t **, size_t, uint8_t **);
    4949extern int net_get_conf_req(async_sess_t *, measured_string_t **, size_t,
    5050    uint8_t **);
    5151extern void net_free_settings(measured_string_t *, uint8_t *);
     52extern int net_get_devices_req(async_sess_t *, measured_string_t **, size_t *,
     53    uint8_t **);
     54extern int net_driver_ready(async_sess_t *, devman_handle_t);
    5255extern async_sess_t *net_connect_module(void);
    5356

  • uspace/lib/net/include/nil_remote.h

    rf51b1d3 r609243f4  
    3434#define __NET_NIL_REMOTE_H__
    3535
    36 #include <ipc/services.h>
    3736#include <net/device.h>
    3837#include <net/packet.h>
     38#include <devman.h>
    3939#include <generic.h>
    4040#include <async.h>
    … …  
    5858            packet_get_id(packet), sender, 0)
    5959
    60 #define nil_device_req(sess, device_id, mtu, netif_service) \
    61         generic_device_req_remote(sess, NET_NIL_DEVICE, device_id, mtu, \
    62             netif_service)
    63 
    64 extern int nil_device_state_msg(async_sess_t *, device_id_t, sysarg_t);
    65 extern int nil_received_msg(async_sess_t *, device_id_t, packet_t *,
    66     services_t);
     60extern int nil_device_req(async_sess_t *, nic_device_id_t, devman_handle_t,
     61    size_t);
     62extern int nil_device_state_msg(async_sess_t *, nic_device_id_t, sysarg_t);
     63extern int nil_received_msg(async_sess_t *, nic_device_id_t, packet_id_t);
     64extern int nil_addr_changed_msg(async_sess_t *, nic_device_id_t,
     65    const nic_address_t *);
    6766
    6867#endif

  • uspace/lib/net/include/nil_skel.h

    rf51b1d3 r609243f4  
    7070 *
    7171 */
    72 extern int nil_device_state_msg_local(device_id_t device_id, sysarg_t state);
     72extern int nil_device_state_msg_local(nic_device_id_t device_id, sysarg_t state);
    7373
    7474/** Pass the packet queue to the network interface layer.
    … …  
    8181 * @param[in] device_id Source device identifier.
    8282 * @param[in] packet    Received packet or the received packet queue.
    83  * @param[in] target    Target service. Ignored parameter.
    8483 *
    8584 * @return EOK on success.
    … …  
    8887 *
    8988 */
    90 extern int nil_received_msg_local(device_id_t device_id, packet_t *packet,
    91     services_t target);
     89extern int nil_received_msg_local(nic_device_id_t device_id, packet_t *packet);
    9290
    9391/** Message processing function.

  • uspace/lib/net/include/tl_common.h

    rf51b1d3 r609243f4  
    5252
    5353extern int tl_get_ip_packet_dimension(async_sess_t *, packet_dimensions_t *,
    54     device_id_t, packet_dimension_t **);
     54    nic_device_id_t, packet_dimension_t **);
    5555extern int tl_get_address_port(const struct sockaddr *, int, uint16_t *);
    56 extern int tl_update_ip_packet_dimension(packet_dimensions_t *, device_id_t,
     56extern int tl_update_ip_packet_dimension(packet_dimensions_t *, nic_device_id_t,
    5757    size_t);
    5858extern int tl_set_address_port(struct sockaddr *, int, uint16_t);

  • uspace/lib/net/include/tl_remote.h

    rf51b1d3 r609243f4  
    5151/*@{*/
    5252
    53 extern int tl_received_msg(async_sess_t *, device_id_t, packet_t *, services_t,
    54     services_t);
     53extern int tl_received_msg(async_sess_t *, nic_device_id_t, packet_t *,
     54    services_t, services_t);
    5555
    5656/*@}*/

  • uspace/lib/net/nil/nil_remote.c

    rf51b1d3 r609243f4  
    5454 *
    5555 */
    56 int nil_device_state_msg(async_sess_t *sess, device_id_t device_id,
     56int nil_device_state_msg(async_sess_t *sess, nic_device_id_t device_id,
    5757    sysarg_t state)
    5858{
    … …  
    7676 *
    7777 */
    78 int nil_received_msg(async_sess_t *sess, device_id_t device_id,
    79     packet_t *packet, services_t target)
     78int nil_received_msg(async_sess_t *sess, nic_device_id_t device_id,
     79    packet_id_t packet_id)
    8080{
    8181        return generic_received_msg_remote(sess, NET_NIL_RECEIVED,
    82             device_id, packet_get_id(packet), target, 0);
     82            device_id, packet_id, 0, 0);
     83}
     84
     85/** Notify upper layers that device address has changed
     86 *
     87 */
     88int nil_addr_changed_msg(async_sess_t *sess, nic_device_id_t device_id,
     89    const nic_address_t *address)
     90{
     91        assert(sess);
     92       
     93        async_exch_t *exch = async_exchange_begin(sess);
     94       
     95        aid_t message_id = async_send_1(exch, NET_NIL_ADDR_CHANGED,
     96            (sysarg_t) device_id, NULL);
     97        int rc = async_data_write_start(exch, address, sizeof (nic_address_t));
     98       
     99        async_exchange_end(exch);
     100       
     101        sysarg_t res;
     102    async_wait_for(message_id, &res);
     103       
     104    if (rc != EOK)
     105                return rc;
     106       
     107    return (int) res;
     108}
     109
     110int nil_device_req(async_sess_t *sess, nic_device_id_t device_id,
     111    devman_handle_t handle, size_t mtu)
     112{
     113        async_exch_t *exch = async_exchange_begin(sess);
     114        int rc = async_req_3_0(exch, NET_NIL_DEVICE, (sysarg_t) device_id,
     115            (sysarg_t) handle, (sysarg_t) mtu);
     116        async_exchange_end(exch);
     117        return rc;
    83118}
    84119

  • uspace/lib/net/tl/icmp_client.c

    rf51b1d3 r609243f4  
    3939#include <icmp_header.h>
    4040#include <packet_client.h>
    41 
    42 #ifdef CONFIG_DEBUG
    43 #include <stdio.h>
    44 #endif
    45 
    4641#include <errno.h>
    4742#include <sys/types.h>
    48 
    4943#include <net/icmp_codes.h>
    5044#include <net/packet.h>
    … …  
    6054 * @return              Zero if the packet contains no data.
    6155 */
    62 int
    63 icmp_client_process_packet(packet_t *packet, icmp_type_t *type,
     56int icmp_client_process_packet(packet_t *packet, icmp_type_t *type,
    6457    icmp_code_t *code, icmp_param_t *pointer, icmp_param_t *mtu)
    6558{
    … …  
    8174                *mtu = header->un.frag.mtu;
    8275
    83         /* Remove debug dump */
    84 #ifdef CONFIG_DEBUG
    85         printf("ICMP error %d (%d) in packet %d\n", header->type, header->code,
    86             packet_get_id(packet));
    87 #endif
    8876        return sizeof(icmp_header_t);
    8977}

  • uspace/lib/net/tl/tl_common.c

    rf51b1d3 r609243f4  
    119119 */
    120120int tl_get_ip_packet_dimension(async_sess_t *sess,
    121     packet_dimensions_t *packet_dimensions, device_id_t device_id,
     121    packet_dimensions_t *packet_dimensions, nic_device_id_t device_id,
    122122    packet_dimension_t **packet_dimension)
    123123{
    … …  
    160160int
    161161tl_update_ip_packet_dimension(packet_dimensions_t *packet_dimensions,
    162     device_id_t device_id, size_t content)
     162    nic_device_id_t device_id, size_t content)
    163163{
    164164        packet_dimension_t *packet_dimension;
    … …  
    170170        packet_dimension->content = content;
    171171
    172         if (device_id != DEVICE_INVALID_ID) {
     172        if (device_id != NIC_DEVICE_INVALID_ID) {
    173173                packet_dimension = packet_dimensions_find(packet_dimensions,
    174                     DEVICE_INVALID_ID);
     174                    NIC_DEVICE_INVALID_ID);
    175175
    176176                if (packet_dimension) {
    … …  
    179179                        else
    180180                                packet_dimensions_exclude(packet_dimensions,
    181                                     DEVICE_INVALID_ID, free);
     181                                    NIC_DEVICE_INVALID_ID, free);
    182182                }
    183183        }

  • uspace/lib/net/tl/tl_remote.c

    rf51b1d3 r609243f4  
    5656 *
    5757 */
    58 int tl_received_msg(async_sess_t *sess, device_id_t device_id, packet_t *packet,
     58int tl_received_msg(async_sess_t *sess, nic_device_id_t device_id, packet_t *packet,
    5959    services_t target, services_t error)
    6060{
Note: See TracChangeset for help on using the changeset viewer.