Changeset 1affcdf3 in mainline for uspace/srv/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/srv/net
Files:
11 edited

Legend:

Unmodified
Added
Removed

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

    r13ecdac9 r1affcdf3  
    845845       
    846846        *count = 0;
     847       
     848        if (!IPC_GET_IMETHOD(*call))
     849                return EOK;
     850       
    847851        switch (IPC_GET_IMETHOD(*call)) {
    848         case IPC_M_PHONE_HUNGUP:
    849                 return EOK;
    850        
    851852        case NET_ARP_DEVICE:
    852853                rc = measured_strings_receive(&address, &data, 1);

  • uspace/srv/net/il/ip/ip.c

    r13ecdac9 r1affcdf3  
    7777#include <il_skel.h>
    7878
     79// FIXME: remove this header
     80#include <kernel/ipc/ipc_methods.h>
     81
    7982/** IP module name. */
    8083#define NAME                    "ip"
    … …  
    201204
    202205        /* Set the destination address */
    203         switch (header->version) {
     206        switch (GET_IP_HEADER_VERSION(header)) {
    204207        case IPVERSION:
    205208                addrlen = sizeof(dest_in);
    … …  
    635638
    636639        /* Process all IP options */
    637         while (next < first->header_length) {
     640        while (next < GET_IP_HEADER_LENGTH(first)) {
    638641                option = (ip_option_t *) (((uint8_t *) first) + next);
    639642                /* Skip end or noop */
    … …  
    656659        if (length % 4) {
    657660                bzero(((uint8_t *) last) + length, 4 - (length % 4));
    658                 last->header_length = length / 4 + 1;
     661                SET_IP_HEADER_LENGTH(last, (length / 4 + 1));
    659662        } else {
    660                 last->header_length = length / 4;
     663                SET_IP_HEADER_LENGTH(last, (length / 4));
    661664        }
    662665
    … …  
    706709                return rc;
    707710       
    708         header->version = IPV4;
    709         header->fragment_offset_high = 0;
     711        SET_IP_HEADER_VERSION(header, IPV4);
     712        SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(header, 0);
    710713        header->fragment_offset_low = 0;
    711714        header->header_checksum = 0;
    … …  
    735738                        memcpy(middle_header, last_header,
    736739                            IP_HEADER_LENGTH(last_header));
    737                         header->flags |= IPFLAG_MORE_FRAGMENTS;
     740                        SET_IP_HEADER_FLAGS(header,
     741                            (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
    738742                        middle_header->total_length =
    739743                            htons(packet_get_data_length(next));
    740                         middle_header->fragment_offset_high =
    741                             IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length);
     744                        SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(middle_header,
     745                            IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length));
    742746                        middle_header->fragment_offset_low =
    743747                            IP_COMPUTE_FRAGMENT_OFFSET_LOW(length);
    … …  
    768772                middle_header->total_length =
    769773                    htons(packet_get_data_length(next));
    770                 middle_header->fragment_offset_high =
    771                     IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length);
     774                SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(middle_header,
     775                    IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length));
    772776                middle_header->fragment_offset_low =
    773777                    IP_COMPUTE_FRAGMENT_OFFSET_LOW(length);
    … …  
    785789                length += packet_get_data_length(next);
    786790                free(last_header);
    787                 header->flags |= IPFLAG_MORE_FRAGMENTS;
     791                SET_IP_HEADER_FLAGS(header,
     792                    (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
    788793        }
    789794
    … …  
    834839        new_header->total_length = htons(IP_HEADER_LENGTH(new_header) + length);
    835840        offset = IP_FRAGMENT_OFFSET(header) + IP_HEADER_DATA_LENGTH(header);
    836         new_header->fragment_offset_high =
    837             IP_COMPUTE_FRAGMENT_OFFSET_HIGH(offset);
     841        SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(new_header,
     842            IP_COMPUTE_FRAGMENT_OFFSET_HIGH(offset));
    838843        new_header->fragment_offset_low =
    839844            IP_COMPUTE_FRAGMENT_OFFSET_LOW(offset);
    … …  
    865870                return NULL;
    866871        memcpy(middle, last, IP_HEADER_LENGTH(last));
    867         middle->flags |= IPFLAG_MORE_FRAGMENTS;
     872        SET_IP_HEADER_FLAGS(middle,
     873            (GET_IP_HEADER_FLAGS(middle) | IPFLAG_MORE_FRAGMENTS));
    868874        return middle;
    869875}
    … …  
    922928
    923929        /* Fragmentation forbidden? */
    924         if(header->flags & IPFLAG_DONT_FRAGMENT)
     930        if(GET_IP_HEADER_FLAGS(header) & IPFLAG_DONT_FRAGMENT)
    925931                return EPERM;
    926932
    … …  
    958964
    959965        /* Mark the first as fragmented */
    960         header->flags |= IPFLAG_MORE_FRAGMENTS;
     966        SET_IP_HEADER_FLAGS(header,
     967            (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
    961968
    962969        /* Create middle fragments */
    … …  
    13191326        int rc;
    13201327
    1321         if ((header->flags & IPFLAG_MORE_FRAGMENTS) ||
     1328        if ((GET_IP_HEADER_FLAGS(header) & IPFLAG_MORE_FRAGMENTS) ||
    13221329            IP_FRAGMENT_OFFSET(header)) {
    13231330                // TODO fragmented
    … …  
    13251332        }
    13261333       
    1327         switch (header->version) {
     1334        switch (GET_IP_HEADER_VERSION(header)) {
    13281335        case IPVERSION:
    13291336                addrlen = sizeof(src_in);
    … …  
    14471454
    14481455        /* Set the destination address */
    1449         switch (header->version) {
     1456        switch (GET_IP_HEADER_VERSION(header)) {
    14501457        case IPVERSION:
    14511458                addrlen = sizeof(addr_in);
    … …  
    19091916       
    19101917        *answer_count = 0;
     1918       
     1919        if (!IPC_GET_IMETHOD(*call))
     1920                return EOK;
     1921       
    19111922        switch (IPC_GET_IMETHOD(*call)) {
    1912         case IPC_M_PHONE_HUNGUP:
    1913                 return EOK;
    1914        
    19151923        case IPC_M_CONNECT_TO_ME:
    19161924                return ip_register(IL_GET_PROTO(*call), IL_GET_SERVICE(*call),

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

    r13ecdac9 r1affcdf3  
    4141#include <ctype.h>
    4242#include <ddi.h>
     43#include <ns.h>
    4344#include <errno.h>
    4445#include <malloc.h>
    … …  
    339340                goto out;
    340341       
    341         rc = async_connect_to_me(PHONE_NS, SERVICE_NETWORKING, 0, 0, NULL);
     342        rc = service_register(SERVICE_NETWORKING);
    342343        if (rc != EOK)
    343344                goto out;
    … …  
    638639       
    639640        *answer_count = 0;
     641       
     642        if (!IPC_GET_IMETHOD(*call))
     643                return EOK;
     644       
    640645        switch (IPC_GET_IMETHOD(*call)) {
    641         case IPC_M_PHONE_HUNGUP:
    642                 return EOK;
    643646        case NET_NET_GET_DEVICE_CONF:
    644647                rc = measured_strings_receive(&strings, &data,
    … …  
    703706               
    704707                /* End if told to either by the message or the processing result */
    705                 if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
     708                if ((!IPC_GET_IMETHOD(call)) || (res == EHANGUP))
    706709                        return;
    707710               

  • uspace/srv/net/netif/lo/lo.c

    r13ecdac9 r1affcdf3  
    3939#include <stdio.h>
    4040#include <str.h>
     41#include <ns.h>
    4142#include <ipc/services.h>
    4243#include <ipc/nil.h>
    … …  
    164165int netif_initialize(void)
    165166{
    166         return async_connect_to_me(PHONE_NS, SERVICE_LO, 0, 0, NULL);
     167        return service_register(SERVICE_LO);
    167168}
    168169

  • uspace/srv/net/nil/eth/eth.c

    r13ecdac9 r1affcdf3  
    5959#include <packet_remote.h>
    6060#include <nil_skel.h>
     61
     62// FIXME: remove this header
     63#include <kernel/ipc/ipc_methods.h>
    6164
    6265#include "eth.h"
    … …  
    846849       
    847850        *answer_count = 0;
     851       
     852        if (!IPC_GET_IMETHOD(*call))
     853                return EOK;
     854       
    848855        switch (IPC_GET_IMETHOD(*call)) {
    849         case IPC_M_PHONE_HUNGUP:
    850                 return EOK;
    851        
    852856        case NET_NIL_DEVICE:
    853857                return eth_device_message(IPC_GET_DEVICE(*call),

  • uspace/srv/net/nil/nildummy/nildummy.c

    r13ecdac9 r1affcdf3  
    5454#include <nil_skel.h>
    5555
     56// FIXME: remove this header
     57#include <kernel/ipc/ipc_methods.h>
     58
    5659#include "nildummy.h"
    5760
    … …  
    393396       
    394397        *answer_count = 0;
     398       
     399        if (!IPC_GET_IMETHOD(*call))
     400                return EOK;
     401       
    395402        switch (IPC_GET_IMETHOD(*call)) {
    396         case IPC_M_PHONE_HUNGUP:
    397                 return EOK;
    398        
    399403        case NET_NIL_DEVICE:
    400404                return nildummy_device_message(IPC_GET_DEVICE(*call),

  • uspace/srv/net/tl/icmp/Makefile

    r13ecdac9 r1affcdf3  
    3232EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
    3333BINARY = icmp
     34STATIC_ONLY = y
    3435
    3536SOURCES = \

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

    r13ecdac9 r1affcdf3  
    612612static void icmp_receiver(ipc_callid_t iid, ipc_call_t *icall)
    613613{
    614         bool loop = true;
    615614        packet_t *packet;
    616615        int rc;
    617616       
    618         while (loop) {
     617        while (true) {
     618                if (!IPC_GET_IMETHOD(*icall))
     619                        break;
     620               
    619621                switch (IPC_GET_IMETHOD(*icall)) {
    620622                case NET_TL_RECEIVED:
    … …  
    629631                        async_answer_0(iid, (sysarg_t) rc);
    630632                        break;
    631                 case IPC_M_PHONE_HUNGUP:
    632                         loop = false;
    633                         continue;
    634633                default:
    635634                        async_answer_0(iid, (sysarg_t) ENOTSUP);

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

    r13ecdac9 r1affcdf3  
    3838#include <assert.h>
    3939#include <async.h>
     40#include <async_obsolete.h>
    4041#include <fibril_synch.h>
    4142#include <malloc.h>
    … …  
    7273#include "tcp.h"
    7374#include "tcp_header.h"
     75
     76// FIXME: remove this header
     77#include <kernel/ipc/ipc_methods.h>
    7478
    7579/** TCP module name. */
    … …  
    476480        old_incoming = socket_data->next_incoming;
    477481
    478         if (header->finalize) {
     482        if (GET_TCP_HEADER_FINALIZE(header)) {
    479483                socket_data->fin_incoming = new_sequence_number +
    480484                    total_length - TCP_HEADER_LENGTH(header);
    … …  
    799803
    800804        /* Notify the destination socket */
    801         async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
     805        async_obsolete_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    802806            (sysarg_t) socket->socket_id,
    803807            ((packet_dimension->content < socket_data->data_fragment_size) ?
    … …  
    820824
    821825        /* Notify the destination socket */
    822         async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
     826        async_obsolete_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    823827            (sysarg_t) socket->socket_id,
    824828            0, 0, 0,
    … …  
    838842        assert(packet);
    839843
    840         if (!header->synchronize)
     844        if (!GET_TCP_HEADER_SYNCHRONIZE(header))
    841845                return tcp_release_and_return(packet, EINVAL);
    842846       
    … …  
    903907        assert(packet);
    904908
    905         if (!header->synchronize)
     909        if (!GET_TCP_HEADER_SYNCHRONIZE(header))
    906910                return tcp_release_and_return(packet, EINVAL);
    907911
    … …  
    10571061        assert(packet);
    10581062
    1059         if (!header->acknowledge)
     1063        if (!GET_TCP_HEADER_ACKNOWLEDGE(header))
    10601064                return tcp_release_and_return(packet, EINVAL);
    10611065
    … …  
    10781082                if (rc == EOK) {
    10791083                        /* Notify the destination socket */
    1080                         async_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
     1084                        async_obsolete_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
    10811085                            (sysarg_t) listening_socket->socket_id,
    10821086                            socket_data->data_fragment_size, TCP_HEADER_SIZE,
    … …  
    11261130        assert(header);
    11271131
    1128         if (!header->acknowledge)
     1132        if (!GET_TCP_HEADER_ACKNOWLEDGE(header))
    11291133                return;
    11301134
    … …  
    12691273{
    12701274        int res;
    1271         bool keep_on_going = true;
    12721275        socket_cores_t local_sockets;
    12731276        int app_phone = IPC_GET_PHONE(call);
    … …  
    12931296        fibril_rwlock_initialize(&lock);
    12941297
    1295         while (keep_on_going) {
     1298        while (true) {
    12961299
    12971300                /* Answer the call */
    … …  
    13011304                /* Get the next call */
    13021305                callid = async_get_call(&call);
     1306               
     1307                if (!IPC_GET_IMETHOD(call)) {
     1308                        res = EHANGUP;
     1309                        break;
     1310                }
    13031311
    13041312                /* Process the call */
    13051313                switch (IPC_GET_IMETHOD(call)) {
    1306                 case IPC_M_PHONE_HUNGUP:
    1307                         keep_on_going = false;
    1308                         res = EHANGUP;
    1309                         break;
    1310 
    13111314                case NET_SOCKET:
    13121315                        socket_data =
    … …  
    15061509
    15071510        /* Release the application phone */
    1508         async_hangup(app_phone);
     1511        async_obsolete_hangup(app_phone);
    15091512
    15101513        printf("release\n");
    … …  
    18331836
    18341837        /* Remember the outgoing FIN */
    1835         if (header->finalize)
     1838        if (GET_TCP_HEADER_FINALIZE(header))
    18361839                socket_data->fin_outgoing = socket_data->next_outgoing;
    18371840       
    … …  
    19521955                header->acknowledgement_number =
    19531956                    htonl(socket_data->next_incoming);
    1954                 header->acknowledge = 1;
     1957                SET_TCP_HEADER_ACKNOWLEDGE(header, 1);
    19551958        }
    19561959        header->window = htons(socket_data->window);
    … …  
    20242027        header->source_port = htons(socket->port);
    20252028        header->source_port = htons(socket_data->dest_port);
    2026         header->header_length = TCP_COMPUTE_HEADER_LENGTH(sizeof(*header));
    2027         header->synchronize = synchronize;
    2028         header->finalize = finalize;
     2029        SET_TCP_HEADER_LENGTH(header,
     2030            TCP_COMPUTE_HEADER_LENGTH(sizeof(*header)));
     2031        SET_TCP_HEADER_SYNCHRONIZE(header, synchronize);
     2032        SET_TCP_HEADER_FINALIZE(header, finalize);
    20292033}
    20302034

  • uspace/srv/net/tl/tcp/tcp_header.h

    r13ecdac9 r1affcdf3  
    4747 * @param[in] header The TCP packet header.
    4848 */
    49 #define TCP_HEADER_LENGTH(header)               ((header)->header_length * 4U)
     49#define TCP_HEADER_LENGTH(header)               (GET_TCP_HEADER_LENGTH(header) * 4U)
    5050
    5151/** Returns the TCP header length.
    … …  
    7373        uint32_t sequence_number;
    7474        uint32_t acknowledgement_number;
    75        
    76 #ifdef ARCH_IS_BIG_ENDIAN
    77         uint8_t header_length:4;
    78         uint8_t reserved1:4;
    79 #else
    80         uint8_t reserved1:4;
    81         uint8_t header_length:4;
    82 #endif
    8375
    84 #ifdef ARCH_IS_BIG_ENDIAN
    85         uint8_t reserved2:2;
    86         uint8_t urgent:1;
    87         uint8_t acknowledge:1;
    88         uint8_t push:1;
    89         uint8_t reset:1;
    90         uint8_t synchronize:1;
    91         uint8_t finalize:1;
    92 #else
    93         uint8_t finalize:1;
    94         uint8_t synchronize:1;
    95         uint8_t reset:1;
    96         uint8_t push:1;
    97         uint8_t acknowledge:1;
    98         uint8_t urgent:1;
    99         uint8_t reserved2:2;
    100 #endif
     76        uint8_t hlr; /* header length, reserved1 */
     77
     78#define GET_TCP_HEADER_LENGTH(header) \
     79        (((header)->hlr & 0xf0) >> 4)
     80#define SET_TCP_HEADER_LENGTH(header, length) \
     81        ((header)->hlr = \
     82         ((length & 0x0f) << 4) | ((header)->hlr & 0x0f))
     83
     84#define GET_TCP_HEADER_RESERVED1(header) \
     85        ((header)->hlr & 0x0f)
     86#define SET_TCP_HEADER_RESERVED1(header, reserved1) \
     87        ((header)->hlr = \
     88         (reserved1 & 0x0f) | ((header)->hlr & 0xf0))
     89
     90        /* reserved2, urgent, acknowledge, push, reset, synchronize, finalize */
     91        uint8_t ruaprsf; 
     92
     93#define GET_TCP_HEADER_RESERVED2(header) \
     94        (((header)->ruaprsf & 0xc0) >> 6)
     95#define SET_TCP_HEADER_RESERVED2(header, reserved2) \
     96        ((header)->ruaprsf = \
     97         ((reserved2 & 0x03) << 6) | ((header)->ruaprsf & 0x3f))
     98
     99#define GET_TCP_HEADER_URGENT(header) \
     100        (((header)->ruaprsf & 0x20) >> 5)
     101#define SET_TCP_HEADER_URGENT(header, urgent) \
     102        ((header)->ruaprsf = \
     103         ((urgent & 0x01) << 5) | ((header)->ruaprsf & 0xdf))
     104
     105#define GET_TCP_HEADER_ACKNOWLEDGE(header) \
     106        (((header)->ruaprsf & 0x10) >> 4)
     107#define SET_TCP_HEADER_ACKNOWLEDGE(header, acknowledge) \
     108        ((header)->ruaprsf = \
     109         ((acknowledge & 0x01) << 4) | ((header)->ruaprsf & 0xef))
     110
     111#define GET_TCP_HEADER_PUSH(header) \
     112        (((header)->ruaprsf & 0x08) >> 3)
     113#define SET_TCP_HEADER_PUSH(header, push) \
     114        ((header)->ruaprsf = \
     115         ((push & 0x01) << 3) | ((header)->ruaprsf & 0xf7))
     116
     117#define GET_TCP_HEADER_RESET(header) \
     118        (((header)->ruaprsf & 0x04) >> 2)
     119#define SET_TCP_HEADER_RESET(header, reset) \
     120        ((header)->ruaprsf = \
     121         ((reset & 0x01) << 2) | ((header)->ruaprsf & 0xfb))
     122
     123#define GET_TCP_HEADER_SYNCHRONIZE(header) \
     124        (((header)->ruaprsf & 0x02) >> 1)
     125#define SET_TCP_HEADER_SYNCHRONIZE(header, synchronize) \
     126        ((header)->ruaprsf = \
     127         ((synchronize & 0x01) << 1) | ((header)->ruaprsf & 0xfd))
     128
     129#define GET_TCP_HEADER_FINALIZE(header) \
     130        ((header)->ruaprsf & 0x01)
     131#define SET_TCP_HEADER_FINALIZE(header, finalize) \
     132        ((header)->ruaprsf = \
     133         (finalize & 0x01) | ((header)->ruaprsf & 0xfe))
    101134
    102135        uint16_t window;

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

    r13ecdac9 r1affcdf3  
    3737
    3838#include <async.h>
     39#include <async_obsolete.h>
    3940#include <fibril_synch.h>
    4041#include <malloc.h>
    … …  
    6970#include "udp.h"
    7071#include "udp_header.h"
     72
     73// FIXME: remove this header
     74#include <kernel/ipc/ipc_methods.h>
    7175
    7276/** UDP module name. */
    … …  
    299303        /* Notify the destination socket */
    300304        fibril_rwlock_write_unlock(&udp_globals.lock);
    301         async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
     305        async_obsolete_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    302306            (sysarg_t) socket->socket_id, packet_dimension->content, 0, 0,
    303307            (sysarg_t) fragments);
    … …  
    748752{
    749753        int res;
    750         bool keep_on_going = true;
    751754        socket_cores_t local_sockets;
    752755        int app_phone = IPC_GET_PHONE(call);
    … …  
    773776        socket_cores_initialize(&local_sockets);
    774777
    775         while (keep_on_going) {
     778        while (true) {
    776779
    777780                /* Answer the call */
    … …  
    783786                /* Get the next call */
    784787                callid = async_get_call(&call);
     788               
     789                if (!IPC_GET_IMETHOD(call)) {
     790                        res = EHANGUP;
     791                        break;
     792                }
    785793
    786794                /* Process the call */
    787795                switch (IPC_GET_IMETHOD(call)) {
    788                 case IPC_M_PHONE_HUNGUP:
    789                         keep_on_going = false;
    790                         res = EHANGUP;
    791                         break;
    792 
    793796                case NET_SOCKET:
    794797                        socket_id = SOCKET_GET_SOCKET_ID(call);
    … …  
    880883
    881884        /* Release the application phone */
    882         async_hangup(app_phone);
     885        async_obsolete_hangup(app_phone);
    883886
    884887        /* Release all local sockets */
Note: See TracChangeset for help on using the changeset viewer.