Changeset 1affcdf3 in mainline for uspace/lib/net


Ignore:
Timestamp:
2011-06-10T19:33:41Z (15 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1878386
Parents:
13ecdac9 (diff), 79a141a (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

Location:
uspace/lib/net
Files:
12 edited

Legend:

Unmodified
Added
Removed

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

    r13ecdac9 r1affcdf3  
    3737#include <generic.h>
    3838#include <async.h>
     39#include <async_obsolete.h>
    3940#include <ipc/services.h>
    4041#include <net/device.h>
    … …  
    5657    int state, services_t target)
    5758{
    58         async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
     59        async_obsolete_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
    5960            (sysarg_t) state, target);
    6061       
    … …  
    7879    int arg2, services_t service)
    7980{
    80         return (int) async_req_3_0(phone, (sysarg_t) message,
     81        return (int) async_obsolete_req_3_0(phone, (sysarg_t) message,
    8182            (sysarg_t) device_id, (sysarg_t) arg2, (sysarg_t) service);
    8283}
    … …  
    107108
    108109        /* Request the address */
    109         message_id = async_send_1(phone, (sysarg_t) message,
     110        message_id = async_obsolete_send_1(phone, (sysarg_t) message,
    110111            (sysarg_t) device_id, NULL);
    111112        string = measured_strings_return(phone, address, data, 1);
    … …  
    145146        sysarg_t suffix;
    146147       
    147         sysarg_t result = async_req_1_4(phone, (sysarg_t) message,
     148        sysarg_t result = async_obsolete_req_1_4(phone, (sysarg_t) message,
    148149            (sysarg_t) device_id, &addr_len, &prefix, &content, &suffix);
    149150       
    … …  
    172173{
    173174        if (error) {
    174                 async_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id,
     175                async_obsolete_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id,
    175176                    (sysarg_t) packet_id, (sysarg_t) target, (sysarg_t) error);
    176177        } else {
    177                 async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
     178                async_obsolete_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
    178179                    (sysarg_t) packet_id, (sysarg_t) target);
    179180        }
    … …  
    198199{
    199200        if (error) {
    200                 async_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id,
     201                async_obsolete_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id,
    201202                    (sysarg_t) packet_id, (sysarg_t) sender, (sysarg_t) error);
    202203        } else {
    203                 async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
     204                async_obsolete_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
    204205                    (sysarg_t) packet_id, (sysarg_t) sender);
    205206        }
    … …  
    243244
    244245        /* Request the translation */
    245         message_id = async_send_3(phone, (sysarg_t) message,
     246        message_id = async_obsolete_send_3(phone, (sysarg_t) message,
    246247            (sysarg_t) device_id, (sysarg_t) count, (sysarg_t) service, NULL);
    247248        measured_strings_send(phone, configuration, count);

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

    r13ecdac9 r1affcdf3  
    3737
    3838#include <async.h>
     39#include <async_obsolete.h>
    3940#include <errno.h>
    4041#include <ipc/packet.h>
    … …  
    5960 * @return EOK on success.
    6061 * @return Other error codes as defined for the pm_add() function.
    61  * @return Other error codes as defined for the async_share_in_start() function.
     62 * @return Other error codes as defined for the async_obsolete_share_in_start() function.
    6263 *
    6364 */
    … …  
    6970        int rc;
    7071       
    71         message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
     72        message = async_obsolete_send_1(phone, NET_PACKET_GET, packet_id, &answer);
    7273
    7374        *packet = (packet_t *) as_get_mappable_page(size);
    74         rc = async_share_in_start_0_0(phone, *packet, size);
     75        rc = async_obsolete_share_in_start_0_0(phone, *packet, size);
    7576        if (rc != EOK) {
    7677                munmap(*packet, size);
    … …  
    117118                sysarg_t size;
    118119               
    119                 rc = async_req_1_1(phone, NET_PACKET_GET_SIZE, packet_id,
     120                rc = async_obsolete_req_1_1(phone, NET_PACKET_GET_SIZE, packet_id,
    120121                    &size);
    121122                if (rc != EOK)
    … …  
    154155        int rc;
    155156       
    156         rc = async_req_4_2(phone, NET_PACKET_CREATE_4, max_content, addr_len,
     157        rc = async_obsolete_req_4_2(phone, NET_PACKET_CREATE_4, max_content, addr_len,
    157158            max_prefix, max_suffix, &packet_id, &size);
    158159        if (rc != EOK)
    … …  
    185186        int rc;
    186187       
    187         rc = async_req_1_2(phone, NET_PACKET_CREATE_1, content, &packet_id,
     188        rc = async_obsolete_req_1_2(phone, NET_PACKET_CREATE_1, content, &packet_id,
    188189            &size);
    189190        if (rc != EOK)
    … …  
    212213void pq_release_remote(int phone, packet_id_t packet_id)
    213214{
    214         async_msg_1(phone, NET_PACKET_RELEASE, packet_id);
     215        async_obsolete_msg_1(phone, NET_PACKET_RELEASE, packet_id);
    215216}
    216217

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

    r13ecdac9 r1affcdf3  
    4040
    4141#include <async.h>
     42#include <async_obsolete.h>
    4243#include <errno.h>
    4344#include <ipc/services.h>
    … …  
    6869int arp_clean_cache_req(int arp_phone)
    6970{
    70         return (int) async_req_0_0(arp_phone, NET_ARP_CLEAN_CACHE);
     71        return (int) async_obsolete_req_0_0(arp_phone, NET_ARP_CLEAN_CACHE);
    7172}
    7273
    … …  
    8788        sysarg_t result;
    8889
    89         message_id = async_send_2(arp_phone, NET_ARP_CLEAR_ADDRESS,
     90        message_id = async_obsolete_send_2(arp_phone, NET_ARP_CLEAR_ADDRESS,
    9091            (sysarg_t) device_id, protocol, NULL);
    9192        measured_strings_send(arp_phone, address, 1);
    … …  
    104105int arp_clear_device_req(int arp_phone, device_id_t device_id)
    105106{
    106         return (int) async_req_1_0(arp_phone, NET_ARP_CLEAR_DEVICE,
     107        return (int) async_obsolete_req_1_0(arp_phone, NET_ARP_CLEAR_DEVICE,
    107108            (sysarg_t) device_id);
    108109}
    … …  
    137138        sysarg_t result;
    138139
    139         message_id = async_send_3(arp_phone, NET_ARP_DEVICE,
     140        message_id = async_obsolete_send_3(arp_phone, NET_ARP_DEVICE,
    140141            (sysarg_t) device_id, protocol, netif, NULL);
    141142        measured_strings_send(arp_phone, address, 1);

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

    r13ecdac9 r1affcdf3  
    4242#include <net/modules.h>
    4343
     44// FIXME: remove this header
     45#include <kernel/ipc/ipc_methods.h>
     46
    4447/** Default thread for new connections.
    4548 *
    … …  
    7578                 * result.
    7679                 */
    77                 if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    78                     (res == EHANGUP))
     80                if ((!IPC_GET_IMETHOD(call)) || (res == EHANGUP))
    7981                        return;
    8082               

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

    r13ecdac9 r1affcdf3  
    181181        /* Set the header */
    182182        header = (ip_header_t *) data;
    183         header->header_length = IP_COMPUTE_HEADER_LENGTH(sizeof(ip_header_t) +
    184             ipopt_length);
     183        SET_IP_HEADER_LENGTH(header,
     184            (IP_COMPUTE_HEADER_LENGTH(sizeof(ip_header_t) + ipopt_length)));
    185185        header->ttl = (ttl ? ttl : IPDEFTTL);
    186186        header->tos = tos;
    … …  
    188188
    189189        if (dont_fragment)
    190                 header->flags = IPFLAG_DONT_FRAGMENT;
     190                SET_IP_HEADER_FLAGS(header, IPFLAG_DONT_FRAGMENT);
    191191
    192192        return EOK;
    … …  
    227227                *tos = header->tos;
    228228        if (dont_fragment)
    229                 *dont_fragment = header->flags & IPFLAG_DONT_FRAGMENT;
     229                *dont_fragment = GET_IP_HEADER_FLAGS(header) & IPFLAG_DONT_FRAGMENT;
    230230        if (ipopt_length) {
    231231                *ipopt_length = IP_HEADER_LENGTH(header) - sizeof(ip_header_t);

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

    r13ecdac9 r1affcdf3  
    4444#include <packet_client.h>
    4545#include <generic.h>
    46 
     46#include <async_obsolete.h>
    4747#include <ipc/services.h>
    4848#include <ipc/il.h>
    … …  
    6666    in_addr_t address, in_addr_t netmask, in_addr_t gateway)
    6767{
    68         return (int) async_req_4_0(ip_phone, NET_IP_ADD_ROUTE,
     68        return (int) async_obsolete_req_4_0(ip_phone, NET_IP_ADD_ROUTE,
    6969            (sysarg_t) device_id, (sysarg_t) gateway.s_addr,
    7070            (sysarg_t) address.s_addr, (sysarg_t) netmask.s_addr);
    … …  
    150150       
    151151        ipc_call_t answer;
    152         aid_t message_id = async_send_1(ip_phone, NET_IP_GET_ROUTE,
     152        aid_t message_id = async_obsolete_send_1(ip_phone, NET_IP_GET_ROUTE,
    153153            (sysarg_t) protocol, &answer);
    154154       
    155         if ((async_data_write_start(ip_phone, destination, addrlen) == EOK) &&
    156             (async_data_read_start(ip_phone, headerlen,
     155        if ((async_obsolete_data_write_start(ip_phone, destination, addrlen) == EOK) &&
     156            (async_obsolete_data_read_start(ip_phone, headerlen,
    157157            sizeof(*headerlen)) == EOK) && (*headerlen > 0)) {
    158158                *header = malloc(*headerlen);
    159159                if (*header) {
    160                         if (async_data_read_start(ip_phone, *header,
     160                        if (async_obsolete_data_read_start(ip_phone, *header,
    161161                            *headerlen) != EOK)
    162162                                free(*header);
    … …  
    243243    in_addr_t gateway)
    244244{
    245         return (int) async_req_2_0(ip_phone, NET_IP_SET_GATEWAY,
     245        return (int) async_obsolete_req_2_0(ip_phone, NET_IP_SET_GATEWAY,
    246246            (sysarg_t) device_id, (sysarg_t) gateway.s_addr);
    247247}

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

    r13ecdac9 r1affcdf3  
    6464 */
    6565#define IP_FRAGMENT_OFFSET(header) \
    66         ((((header)->fragment_offset_high << 8) + \
     66        (((GET_IP_HEADER_FRAGMENT_OFFSET_HIGH(header) << 8) + \
    6767            (header)->fragment_offset_low) * 8U)
    6868
    … …  
    8383 */
    8484#define IP_HEADER_LENGTH(header) \
    85         ((header)->header_length * 4U)
     85        (GET_IP_HEADER_LENGTH(header) * 4U)
    8686
    8787/** Returns the actual IP packet total length.
    … …  
    143143 */
    144144struct ip_header {
    145 #ifdef ARCH_IS_BIG_ENDIAN
    146         uint8_t version : 4;
    147         uint8_t header_length : 4;
    148 #else
    149         uint8_t header_length : 4;
    150         uint8_t version : 4;
    151 #endif
     145        uint8_t vhl; /* version, header_length */
     146
     147#define GET_IP_HEADER_VERSION(header) \
     148        (((header)->vhl & 0xf0) >> 4)
     149#define SET_IP_HEADER_VERSION(header, version) \
     150        ((header)->vhl = \
     151         ((version & 0x0f) << 4) | ((header)->vhl & 0x0f))
     152
     153#define GET_IP_HEADER_LENGTH(header) \
     154        ((header)->vhl & 0x0f)
     155#define SET_IP_HEADER_LENGTH(header, length) \
     156        ((header)->vhl = \
     157         (length & 0x0f) | ((header)->vhl & 0xf0))
    152158
    153159        uint8_t tos;
    … …  
    155161        uint16_t identification;
    156162
    157 #ifdef ARCH_IS_BIG_ENDIAN
    158         uint8_t flags : 3;
    159         uint8_t fragment_offset_high : 5;
    160 #else
    161         uint8_t fragment_offset_high : 5;
    162         uint8_t flags : 3;
    163 #endif
     163        uint8_t ffoh; /* flags, fragment_offset_high */
     164
     165#define GET_IP_HEADER_FLAGS(header) \
     166        (((header)->ffoh & 0xe0) >> 5)
     167#define SET_IP_HEADER_FLAGS(header, flags) \
     168        ((header)->ffoh = \
     169         ((flags & 0x07) << 5) | ((header)->ffoh & 0x1f))
     170
     171#define GET_IP_HEADER_FRAGMENT_OFFSET_HIGH(header) \
     172        ((header)->ffoh & 0x1f)
     173#define SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(header, fragment_offset_high) \
     174        ((header)->ffoh = \
     175         (fragment_offset_high & 0x1f) | ((header)->ffoh & 0xe0))
    164176
    165177        uint8_t fragment_offset_low;
    … …  
    181193        uint8_t pointer;
    182194
    183 #ifdef ARCH_IS_BIG_ENDIAN
    184         uint8_t overflow : 4;
    185         uint8_t flags : 4;
    186 #else
    187         uint8_t flags : 4;
    188         uint8_t overflow : 4;
    189 #endif
     195        uint8_t of; /* overflow, flags */
     196
     197#define GET_IP_OPTION_OVERFLOW(option) \
     198        (((option)->of & 0xf0) >> 4)
     199#define SET_IP_OPTION_OVERFLOW(option, overflow) \
     200        ((option)->of = \
     201         ((overflow & 0x0f) << 4) | ((option)->of & 0x0f))
     202
     203#define GET_IP_OPTION_FLAGS(option) \
     204        ((option)->of & 0x0f)
     205#define SET_IP_OPTION_FLAGS(option, flags) \
     206        ((option)->of = \
     207         (flags & 0x0f) | ((option)->of & 0xf0))
     208
    190209} __attribute__ ((packed));
    191210

  • uspace/lib/net/netif/netif_remote.c

    r13ecdac9 r1affcdf3  
    3838#include <packet_client.h>
    3939#include <generic.h>
    40 
     40#include <async_obsolete.h>
    4141#include <ipc/services.h>
    4242#include <ipc/netif.h>
    … …  
    8282int netif_probe_req(int netif_phone, device_id_t device_id, int irq, void *io)
    8383{
    84         return async_req_3_0(netif_phone, NET_NETIF_PROBE, device_id, irq,
     84        return async_obsolete_req_3_0(netif_phone, NET_NETIF_PROBE, device_id, irq,
    8585            (sysarg_t) io);
    8686}
    … …  
    119119int netif_start_req(int netif_phone, device_id_t device_id)
    120120{
    121         return async_req_1_0(netif_phone, NET_NETIF_START, device_id);
     121        return async_obsolete_req_1_0(netif_phone, NET_NETIF_START, device_id);
    122122}
    123123
    … …  
    136136int netif_stop_req(int netif_phone, device_id_t device_id)
    137137{
    138         return async_req_1_0(netif_phone, NET_NETIF_STOP, device_id);
     138        return async_obsolete_req_1_0(netif_phone, NET_NETIF_STOP, device_id);
    139139}
    140140
    … …  
    154154                return EBADMEM;
    155155       
    156         aid_t message_id = async_send_1(netif_phone, NET_NETIF_STATS,
     156        aid_t message_id = async_obsolete_send_1(netif_phone, NET_NETIF_STATS,
    157157            (sysarg_t) device_id, NULL);
    158         async_data_read_start(netif_phone, stats, sizeof(*stats));
     158        async_obsolete_data_read_start(netif_phone, stats, sizeof(*stats));
    159159       
    160160        sysarg_t result;

  • uspace/lib/net/netif/netif_skel.c

    r13ecdac9 r1affcdf3  
    5454#include <nil_remote.h>
    5555
     56// FIXME: remove this header
     57#include <kernel/ipc/ipc_methods.h>
     58
    5659DEVICE_MAP_IMPLEMENT(netif_device_map, netif_device_t);
    5760
    … …  
    288291        *count = 0;
    289292       
     293        if (!IPC_GET_IMETHOD(*call))
     294                return EOK;
     295       
    290296        switch (IPC_GET_IMETHOD(*call)) {
    291         case IPC_M_PHONE_HUNGUP:
    292                 return EOK;
    293        
    294297        case NET_NETIF_PROBE:
    295298                return netif_probe_req_local(0, IPC_GET_DEVICE(*call),
    … …  
    385388               
    386389                /* End if said to either by the message or the processing result */
    387                 if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    388                     (res == EHANGUP))
     390                if ((!IPC_GET_IMETHOD(call)) || (res == EHANGUP))
    389391                        return;
    390392               

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

    r13ecdac9 r1affcdf3  
    4242#include <net/modules.h>
    4343
     44// FIXME: remove this header
     45#include <kernel/ipc/ipc_methods.h>
     46
    4447/** Default thread for new connections.
    4548 *
    … …  
    7578                 * result.
    7679                 */
    77                 if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    78                     (res == EHANGUP))
     80                if ((!IPC_GET_IMETHOD(call)) || (res == EHANGUP))
    7981                        return;
    8082               

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

    r13ecdac9 r1affcdf3  
    4141
    4242#include <async.h>
     43#include <async_obsolete.h>
    4344#include <errno.h>
    4445#include <ipc/services.h>
    … …  
    6465    icmp_param_t mtu, packet_t *packet)
    6566{
    66         async_msg_3(icmp_phone, NET_ICMP_DEST_UNREACH, (sysarg_t) code,
     67        async_obsolete_msg_3(icmp_phone, NET_ICMP_DEST_UNREACH, (sysarg_t) code,
    6768            (sysarg_t) packet_get_id(packet), (sysarg_t) mtu);
    6869        return EOK;
    … …  
    8384int icmp_source_quench_msg(int icmp_phone, packet_t *packet)
    8485{
    85         async_msg_2(icmp_phone, NET_ICMP_SOURCE_QUENCH, 0,
     86        async_obsolete_msg_2(icmp_phone, NET_ICMP_SOURCE_QUENCH, 0,
    8687            (sysarg_t) packet_get_id(packet));
    8788        return EOK;
    … …  
    103104int icmp_time_exceeded_msg(int icmp_phone, icmp_code_t code, packet_t *packet)
    104105{
    105         async_msg_2(icmp_phone, NET_ICMP_TIME_EXCEEDED, (sysarg_t) code,
     106        async_obsolete_msg_2(icmp_phone, NET_ICMP_TIME_EXCEEDED, (sysarg_t) code,
    106107            (sysarg_t) packet_get_id(packet));
    107108        return EOK;
    … …  
    125126    icmp_param_t pointer, packet_t *packet)
    126127{
    127         async_msg_3(icmp_phone, NET_ICMP_PARAMETERPROB, (sysarg_t) code,
     128        async_obsolete_msg_3(icmp_phone, NET_ICMP_PARAMETERPROB, (sysarg_t) code,
    128129            (sysarg_t) packet_get_id(packet), (sysarg_t) pointer);
    129130        return EOK;

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

    r13ecdac9 r1affcdf3  
    4242#include <net/modules.h>
    4343
     44// FIXME: remove this header
     45#include <kernel/ipc/ipc_methods.h>
     46
    4447/** Default thread for new connections.
    4548 *
    … …  
    7780                 * result.
    7881                 */
    79                 if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    80                     (res == EHANGUP))
     82                if ((!IPC_GET_IMETHOD(call)) || (res == EHANGUP))
    8183                        return;
    8284               
Note: See TracChangeset for help on using the changeset viewer.