Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/net/tl/tl_common.c

    r14f1db0 rc5b59ce  
    3838#include <async.h>
    3939#include <ipc/services.h>
    40 
    41 #include <net_err.h>
     40#include <errno.h>
     41#include <err.h>
     42
    4243#include <packet/packet.h>
    4344#include <packet/packet_client.h>
     
    5152#include <ip_remote.h>
    5253#include <socket_codes.h>
    53 #include <socket_errno.h>
    5454#include <ip_interface.h>
    5555#include <tl_interface.h>
     
    5858DEVICE_MAP_IMPLEMENT(packet_dimensions, packet_dimension_t);
    5959
    60 int tl_get_address_port(const struct sockaddr * addr, int addrlen, uint16_t * port){
    61         const struct sockaddr_in * address_in;
    62         const struct sockaddr_in6 * address_in6;
    63 
    64         if((addrlen <= 0) || ((size_t) addrlen < sizeof(struct sockaddr))){
    65                 return EINVAL;
    66         }
    67         switch(addr->sa_family){
    68                 case AF_INET:
    69                         if(addrlen != sizeof(struct sockaddr_in)){
     60int
     61tl_get_address_port(const struct sockaddr *addr, int addrlen, uint16_t *port)
     62{
     63        const struct sockaddr_in *address_in;
     64        const struct sockaddr_in6 *address_in6;
     65
     66        if ((addrlen <= 0) || ((size_t) addrlen < sizeof(struct sockaddr)))
     67                return EINVAL;
     68
     69        switch (addr->sa_family) {
     70        case AF_INET:
     71                if (addrlen != sizeof(struct sockaddr_in))
     72                        return EINVAL;
     73
     74                address_in = (struct sockaddr_in *) addr;
     75                *port = ntohs(address_in->sin_port);
     76                break;
     77        case AF_INET6:
     78                if (addrlen != sizeof(struct sockaddr_in6))
    7079                                return EINVAL;
    71                         }
    72                         address_in = (struct sockaddr_in *) addr;
    73                         *port = ntohs(address_in->sin_port);
    74                         break;
    75                 case AF_INET6:
    76                         if(addrlen != sizeof(struct sockaddr_in6)){
    77                                 return EINVAL;
    78                         }
    79                         address_in6 = (struct sockaddr_in6 *) addr;
    80                         *port = ntohs(address_in6->sin6_port);
    81                         break;
    82                 default:
    83                         return EAFNOSUPPORT;
    84         }
     80
     81                address_in6 = (struct sockaddr_in6 *) addr;
     82                *port = ntohs(address_in6->sin6_port);
     83                break;
     84        default:
     85                return EAFNOSUPPORT;
     86        }
     87
    8588        return EOK;
    8689}
     
    112115                return EBADMEM;
    113116       
    114         *packet_dimension = packet_dimensions_find(packet_dimensions, device_id);
     117        *packet_dimension = packet_dimensions_find(packet_dimensions,
     118            device_id);
    115119        if (!*packet_dimension) {
    116120                /* Ask for and remember them if not found */
     
    136140}
    137141
    138 int tl_update_ip_packet_dimension(packet_dimensions_ref packet_dimensions, device_id_t device_id, size_t content){
     142int
     143tl_update_ip_packet_dimension(packet_dimensions_ref packet_dimensions,
     144    device_id_t device_id, size_t content)
     145{
    139146        packet_dimension_ref packet_dimension;
    140147
    141148        packet_dimension = packet_dimensions_find(packet_dimensions, device_id);
    142         if(! packet_dimension){
     149        if (!packet_dimension)
    143150                return ENOENT;
    144         }
    145151        packet_dimension->content = content;
    146         if(device_id != DEVICE_INVALID_ID){
    147                 packet_dimension = packet_dimensions_find(packet_dimensions, DEVICE_INVALID_ID);
    148                 if(packet_dimension){
    149                         if(packet_dimension->content >= content){
     152
     153        if (device_id != DEVICE_INVALID_ID) {
     154                packet_dimension = packet_dimensions_find(packet_dimensions,
     155                    DEVICE_INVALID_ID);
     156
     157                if (packet_dimension) {
     158                        if (packet_dimension->content >= content)
    150159                                packet_dimension->content = content;
    151                         }else{
    152                                 packet_dimensions_exclude(packet_dimensions, DEVICE_INVALID_ID);
    153                         }
     160                        else
     161                                packet_dimensions_exclude(packet_dimensions,
     162                                    DEVICE_INVALID_ID);
     163
    154164                }
    155165        }
     166
    156167        return EOK;
    157168}
    158169
    159 int tl_set_address_port(struct sockaddr * addr, int addrlen, uint16_t port){
    160         struct sockaddr_in * address_in;
    161         struct sockaddr_in6 * address_in6;
     170int tl_set_address_port(struct sockaddr * addr, int addrlen, uint16_t port)
     171{
     172        struct sockaddr_in *address_in;
     173        struct sockaddr_in6 *address_in6;
    162174        size_t length;
    163175
    164         if(addrlen < 0){
    165                 return EINVAL;
    166         }
     176        if (addrlen < 0)
     177                return EINVAL;
     178       
    167179        length = (size_t) addrlen;
    168         if(length < sizeof(struct sockaddr)){
    169                 return EINVAL;
    170         }
    171         switch(addr->sa_family){
    172                 case AF_INET:
    173                         if(length != sizeof(struct sockaddr_in)){
     180        if (length < sizeof(struct sockaddr))
     181                return EINVAL;
     182
     183        switch (addr->sa_family) {
     184        case AF_INET:
     185                if (length != sizeof(struct sockaddr_in))
     186                        return EINVAL;
     187                address_in = (struct sockaddr_in *) addr;
     188                address_in->sin_port = htons(port);
     189                return EOK;
     190        case AF_INET6:
     191                if (length != sizeof(struct sockaddr_in6))
    174192                                return EINVAL;
    175                         }
    176                         address_in = (struct sockaddr_in *) addr;
    177                         address_in->sin_port = htons(port);
    178                         return EOK;
    179                 case AF_INET6:
    180                         if(length != sizeof(struct sockaddr_in6)){
    181                                 return EINVAL;
    182                         }
    183                         address_in6 = (struct sockaddr_in6 *) addr;
    184                         address_in6->sin6_port = htons(port);
    185                         return EOK;
    186                 default:
    187                         return EAFNOSUPPORT;
    188         }
    189 }
    190 
    191 int tl_prepare_icmp_packet(int packet_phone, int icmp_phone, packet_t packet, services_t error){
     193                address_in6 = (struct sockaddr_in6 *) addr;
     194                address_in6->sin6_port = htons(port);
     195                return EOK;
     196        default:
     197                return EAFNOSUPPORT;
     198        }
     199}
     200
     201int
     202tl_prepare_icmp_packet(int packet_phone, int icmp_phone, packet_t packet,
     203    services_t error)
     204{
    192205        packet_t next;
    193         uint8_t * src;
     206        uint8_t *src;
    194207        int length;
    195208
     
    200213       
    201214        length = packet_get_addr(packet, &src, NULL);
    202         if((length > 0)
    203                 && (! error)
    204                 && (icmp_phone >= 0)
    205         // set both addresses to the source one (avoids the source address deletion before setting the destination one)
    206                 && (packet_set_addr(packet, src, src, (size_t) length) == EOK)){
     215        if ((length > 0) && (!error) && (icmp_phone >= 0) &&
     216            // set both addresses to the source one (avoids the source address
     217            // deletion before setting the destination one)
     218            (packet_set_addr(packet, src, src, (size_t) length) == EOK)) {
    207219                return EOK;
    208         }else{
     220        } else
    209221                pq_release_remote(packet_phone, packet_get_id(packet));
    210         }
     222
    211223        return ENOENT;
    212224}
    213225
    214 int tl_socket_read_packet_data(int packet_phone, packet_ref packet, size_t prefix, const packet_dimension_ref dimension, const struct sockaddr * addr, socklen_t addrlen){
     226int
     227tl_socket_read_packet_data(int packet_phone, packet_ref packet, size_t prefix,
     228    const packet_dimension_ref dimension, const struct sockaddr *addr,
     229    socklen_t addrlen)
     230{
    215231        ERROR_DECLARE;
    216232
     
    219235        void * data;
    220236
    221         if(! dimension){
    222                 return EINVAL;
    223         }
     237        if (!dimension)
     238                return EINVAL;
     239
    224240        // get the data length
    225         if(! async_data_write_receive(&callid, &length)){
    226                 return EINVAL;
    227         }
     241        if (!async_data_write_receive(&callid, &length))
     242                return EINVAL;
     243
    228244        // get a new packet
    229         *packet = packet_get_4_remote(packet_phone, length, dimension->addr_len, prefix + dimension->prefix, dimension->suffix);
    230         if(! packet){
     245        *packet = packet_get_4_remote(packet_phone, length, dimension->addr_len,
     246            prefix + dimension->prefix, dimension->suffix);
     247        if (!packet)
    231248                return ENOMEM;
    232         }
     249
    233250        // allocate space in the packet
    234251        data = packet_suffix(*packet, length);
    235         if(! data){
     252        if (!data) {
    236253                pq_release_remote(packet_phone, packet_get_id(*packet));
    237254                return ENOMEM;
    238255        }
     256
    239257        // read the data into the packet
    240         if(ERROR_OCCURRED(async_data_write_finalize(callid, data, length))
    241         // set the packet destination address
    242                 || ERROR_OCCURRED(packet_set_addr(*packet, NULL, (uint8_t *) addr, addrlen))){
     258        if (ERROR_OCCURRED(async_data_write_finalize(callid, data, length)) ||
     259            // set the packet destination address
     260            ERROR_OCCURRED(packet_set_addr(*packet, NULL, (uint8_t *) addr,
     261            addrlen))) {
    243262                pq_release_remote(packet_phone, packet_get_id(*packet));
    244263                return ERROR_CODE;
    245264        }
     265
    246266        return (int) length;
    247267}
Note: See TracChangeset for help on using the changeset viewer.