Ignore:
File:
1 edited

Legend:

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

    rc5b59ce r14f1db0  
    3838#include <async.h>
    3939#include <ipc/services.h>
    40 #include <errno.h>
    41 #include <err.h>
    42 
     40
     41#include <net_err.h>
    4342#include <packet/packet.h>
    4443#include <packet/packet_client.h>
     
    5251#include <ip_remote.h>
    5352#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
    61 tl_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))
    79                                 return EINVAL;
    80 
    81                 address_in6 = (struct sockaddr_in6 *) addr;
    82                 *port = ntohs(address_in6->sin6_port);
    83                 break;
    84         default:
    85                 return EAFNOSUPPORT;
    86         }
    87 
     60int 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)){
     70                                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        }
    8885        return EOK;
    8986}
     
    115112                return EBADMEM;
    116113       
    117         *packet_dimension = packet_dimensions_find(packet_dimensions,
    118             device_id);
     114        *packet_dimension = packet_dimensions_find(packet_dimensions, device_id);
    119115        if (!*packet_dimension) {
    120116                /* Ask for and remember them if not found */
     
    140136}
    141137
    142 int
    143 tl_update_ip_packet_dimension(packet_dimensions_ref packet_dimensions,
    144     device_id_t device_id, size_t content)
    145 {
     138int tl_update_ip_packet_dimension(packet_dimensions_ref packet_dimensions, device_id_t device_id, size_t content){
    146139        packet_dimension_ref packet_dimension;
    147140
    148141        packet_dimension = packet_dimensions_find(packet_dimensions, device_id);
    149         if (!packet_dimension)
     142        if(! packet_dimension){
    150143                return ENOENT;
     144        }
    151145        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)
     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){
    159150                                packet_dimension->content = content;
    160                         else
    161                                 packet_dimensions_exclude(packet_dimensions,
    162                                     DEVICE_INVALID_ID);
    163 
     151                        }else{
     152                                packet_dimensions_exclude(packet_dimensions, DEVICE_INVALID_ID);
     153                        }
    164154                }
    165155        }
    166 
    167156        return EOK;
    168157}
    169158
    170 int 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;
     159int tl_set_address_port(struct sockaddr * addr, int addrlen, uint16_t port){
     160        struct sockaddr_in * address_in;
     161        struct sockaddr_in6 * address_in6;
    174162        size_t length;
    175163
    176         if (addrlen < 0)
    177                 return EINVAL;
    178        
     164        if(addrlen < 0){
     165                return EINVAL;
     166        }
    179167        length = (size_t) addrlen;
    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))
    192                                 return EINVAL;
    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 
    201 int
    202 tl_prepare_icmp_packet(int packet_phone, int icmp_phone, packet_t packet,
    203     services_t error)
    204 {
     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)){
     174                                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
     191int tl_prepare_icmp_packet(int packet_phone, int icmp_phone, packet_t packet, services_t error){
    205192        packet_t next;
    206         uint8_t *src;
     193        uint8_t * src;
    207194        int length;
    208195
     
    213200       
    214201        length = packet_get_addr(packet, &src, NULL);
    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)) {
     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)){
    219207                return EOK;
    220         } else
     208        }else{
    221209                pq_release_remote(packet_phone, packet_get_id(packet));
    222 
     210        }
    223211        return ENOENT;
    224212}
    225213
    226 int
    227 tl_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 {
     214int 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){
    231215        ERROR_DECLARE;
    232216
     
    235219        void * data;
    236220
    237         if (!dimension)
    238                 return EINVAL;
    239 
     221        if(! dimension){
     222                return EINVAL;
     223        }
    240224        // get the data length
    241         if (!async_data_write_receive(&callid, &length))
    242                 return EINVAL;
    243 
     225        if(! async_data_write_receive(&callid, &length)){
     226                return EINVAL;
     227        }
    244228        // get a new packet
    245         *packet = packet_get_4_remote(packet_phone, length, dimension->addr_len,
    246             prefix + dimension->prefix, dimension->suffix);
    247         if (!packet)
     229        *packet = packet_get_4_remote(packet_phone, length, dimension->addr_len, prefix + dimension->prefix, dimension->suffix);
     230        if(! packet){
    248231                return ENOMEM;
    249 
     232        }
    250233        // allocate space in the packet
    251234        data = packet_suffix(*packet, length);
    252         if (!data) {
     235        if(! data){
    253236                pq_release_remote(packet_phone, packet_get_id(*packet));
    254237                return ENOMEM;
    255238        }
    256 
    257239        // read the data into the packet
    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))) {
     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))){
    262243                pq_release_remote(packet_phone, packet_get_id(*packet));
    263244                return ERROR_CODE;
    264245        }
    265 
    266246        return (int) length;
    267247}
Note: See TracChangeset for help on using the changeset viewer.