Changeset 26de91a in mainline


Ignore:
Timestamp:
2013-10-04T17:19:20Z (11 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9749e47
Parents:
e2839d7
Message:

IPv4 and v6 should not need separate handling by a simple client that is just connecting to a host/address. Add IPv6/DNS support in applications where missing.

Location:
uspace
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/netspeed/netspeed.c

    re2839d7 r26de91a  
    3636 */
    3737
     38#include <assert.h>
     39#include <inet/dnsr.h>
     40#include <net/in.h>
     41#include <net/inet.h>
     42#include <net/socket.h>
    3843#include <stdio.h>
    3944#include <stdlib.h>
    … …  
    4146#include <str_error.h>
    4247#include <task.h>
    43 
    44 #include <net/in.h>
    45 #include <net/inet.h>
    46 #include <net/socket.h>
    4748
    4849#define NAME "netspeed"
    … …  
    114115}
    115116
    116 static int client(sock_type_t sock_type, const char *address, unsigned port,
     117static int client(sock_type_t sock_type, const char *host, unsigned port,
    117118    unsigned long count, char *buf, size_t bufsize)
    118119{
    119         struct sockaddr_in addr;
    120        
    121         addr.sin_family = AF_INET;
    122         addr.sin_port = htons(port);
    123        
    124         int rc = inet_pton(AF_INET, address, (void *) &addr.sin_addr.s_addr);
    125         if (rc != EOK) {
    126                 fprintf(stderr, "inet_pton failed: %s\n", str_error(rc));
    127                 return rc;
    128         }
    129        
    130         int conn_sd = socket(PF_INET, sock_type, 0);
     120        inet_addr_t iaddr;
     121        struct sockaddr *saddr;
     122        socklen_t saddrlen;
     123       
     124        int rc = inet_addr_parse(host, &iaddr);
     125        if (rc != EOK) {
     126                dnsr_hostinfo_t *hinfo = NULL;
     127                rc = dnsr_name2host(host, &hinfo, ip_any);
     128                if (rc != EOK) {
     129                        fprintf(stderr, "Error resolving host '%s'.\n", host);
     130                        return ENOENT;
     131                }
     132               
     133                iaddr = hinfo->addr;
     134        }
     135       
     136        rc = inet_addr_sockaddr(&iaddr, port, &saddr, &saddrlen);
     137        if (rc != EOK) {
     138                assert(rc == ENOMEM);
     139                fprintf(stderr, "Out of memory.\n");
     140                return ENOMEM;
     141        }
     142       
     143        int conn_sd = socket(saddr->sa_family, sock_type, 0);
    131144        if (conn_sd < 0) {
    132145                fprintf(stderr, "socket failed: %s\n", str_error(rc));
    … …  
    135148       
    136149        if (sock_type == SOCK_STREAM) {
    137                 rc = connect(conn_sd, (struct sockaddr *) &addr, sizeof(addr));
     150                rc = connect(conn_sd, saddr, saddrlen);
    138151                if (rc != EOK) {
    139152                        fprintf(stderr, "connect failed: %s\n", str_error(rc));
    … …  
    151164                        rc = send(conn_sd, buf, bufsize, 0);
    152165                } else {
    153                         rc = sendto(conn_sd, buf, bufsize, 0,
    154                             (struct sockaddr *) &addr, sizeof(addr));
     166                        rc = sendto(conn_sd, buf, bufsize, 0, saddr, saddrlen);
    155167                }
    156168                if (rc != EOK) {
    … …  
    161173       
    162174        closesocket(conn_sd);
     175        free(saddr);
    163176        return rc;
    164177}
    … …  
    167180{
    168181        fprintf(stderr, "Usage: netspeed <tcp|udp> server [port] <buffer size>\n");
    169         fprintf(stderr, "       netspeed <tcp|udp> client <ip> <port> <count> <buffer size>\n");
     182        fprintf(stderr, "       netspeed <tcp|udp> client <host> <port> <count> <buffer size>\n");
    170183}
    171184

  • uspace/app/nettest1/nettest1.c

    re2839d7 r26de91a  
    3838#include "print_error.h"
    3939
     40#include <assert.h>
    4041#include <malloc.h>
    4142#include <stdio.h>
    … …  
    326327        }
    327328       
    328         char *addr_s = argv[argc - 1];
     329        char *host = argv[argc - 1];
    329330       
    330331        /* Interpret as address */
    331         inet_addr_t addr_addr;
    332         rc = inet_addr_parse(addr_s, &addr_addr);
     332        inet_addr_t iaddr;
     333        rc = inet_addr_parse(host, &iaddr);
    333334       
    334335        if (rc != EOK) {
    335336                /* Interpret as a host name */
    336337                dnsr_hostinfo_t *hinfo = NULL;
    337                 rc = dnsr_name2host(addr_s, &hinfo, ipver_from_af(family));
     338                rc = dnsr_name2host(host, &hinfo, ipver_from_af(family));
    338339               
    339340                if (rc != EOK) {
    340                         printf("Error resolving host '%s'.\n", addr_s);
     341                        printf("Error resolving host '%s'.\n", host);
    341342                        return EINVAL;
    342343                }
    343344               
    344                 addr_addr = hinfo->addr;
    345         }
    346        
    347         struct sockaddr_in addr;
    348         struct sockaddr_in6 addr6;
    349         uint16_t af = inet_addr_sockaddr_in(&addr_addr, &addr, &addr6);
     345                iaddr = hinfo->addr;
     346        }
     347       
     348        rc = inet_addr_sockaddr(&iaddr, port, &address, &addrlen);
     349        if (rc != EOK) {
     350                assert(rc == ENOMEM);
     351                printf("Out of memory.\n");
     352                return ENOMEM;
     353        }
    350354       
    351355        if (family == AF_NONE)
    352                 family = af;
    353        
    354         if (af != family) {
     356                family = address->sa_family;
     357       
     358        if (address->sa_family != family) {
    355359                printf("Address family does not match explicitly set family.\n");
    356360                return EINVAL;
    357         }
    358        
    359         /* Prepare the address buffer */
    360        
    361         switch (af) {
    362         case AF_INET:
    363                 addr.sin_port = htons(port);
    364                 address = (struct sockaddr *) &addr;
    365                 addrlen = sizeof(addr);
    366                 break;
    367         case AF_INET6:
    368                 addr6.sin6_port = htons(port);
    369                 address = (struct sockaddr *) &addr6;
    370                 addrlen = sizeof(addr6);
    371                 break;
    372         default:
    373                 fprintf(stderr, "Address family is not supported\n");
    374                 return EAFNOSUPPORT;
    375361        }
    376362       
    … …  
    437423            &time_before));
    438424       
     425        free(address);
     426       
    439427        if (verbose)
    440428                printf("Exiting\n");

  • uspace/app/nettest2/nettest2.c

    re2839d7 r26de91a  
    3838#include "print_error.h"
    3939
     40#include <assert.h>
    4041#include <malloc.h>
    4142#include <stdio.h>
    … …  
    281282        }
    282283       
    283         struct sockaddr_in addr;
    284         struct sockaddr_in6 addr6;
    285         uint16_t af = inet_addr_sockaddr_in(&addr_addr, &addr, &addr6);
     284        struct sockaddr *address;
     285        socklen_t addrlen;
     286        rc = inet_addr_sockaddr(&addr_addr, port, &address, &addrlen);
     287        if (rc != EOK) {
     288                assert(rc == ENOMEM);
     289                printf("Out of memory.\n");
     290                return ENOMEM;
     291        }
    286292       
    287293        if (family == AF_NONE)
    288                 family = af;
    289        
    290         if (af != family) {
     294                family = address->sa_family;
     295       
     296        if (address->sa_family != family) {
    291297                printf("Address family does not match explicitly set family.\n");
    292298                return EINVAL;
    293         }
    294        
    295         /* Prepare the address buffer */
    296        
    297         struct sockaddr *address;
    298         socklen_t addrlen;
    299        
    300         switch (af) {
    301         case AF_INET:
    302                 addr.sin_port = htons(port);
    303                 address = (struct sockaddr *) &addr;
    304                 addrlen = sizeof(addr);
    305                 break;
    306         case AF_INET6:
    307                 addr6.sin6_port = htons(port);
    308                 address = (struct sockaddr *) &addr6;
    309                 addrlen = sizeof(addr6);
    310                 break;
    311         default:
    312                 fprintf(stderr, "Address family is not supported\n");
    313                 return EAFNOSUPPORT;
    314299        }
    315300       
    … …  
    427412                return rc;
    428413       
     414        free(address);
     415       
    429416        if (verbose)
    430417                printf("\nExiting\n");

  • uspace/app/nettest3/nettest3.c

    re2839d7 r26de91a  
    3737#include <async.h>
    3838#include <stdio.h>
     39#include <stdlib.h>
    3940#include <str.h>
    4041
    … …  
    5253static char buf[BUF_SIZE];
    5354
    54 static struct sockaddr_in addr;
     55static struct sockaddr *address;
     56static socklen_t addrlen;
    5557
    5658static uint16_t port;
    … …  
    6264        char *endptr;
    6365        dnsr_hostinfo_t *hinfo;
     66        inet_addr_t addr;
     67        char *addr_s;
    6468
    6569        port = 7;
    … …  
    6973
    7074        /* Connect to local IP address by default */
    71         addr.sin_family = AF_INET;
    72         addr.sin_port = htons(port);
    73         addr.sin_addr.s_addr = htonl(0x7f000001);
     75        inet_addr(&addr, 127, 0, 0, 1);
    7476
    7577        if (argc >= 2) {
    7678                printf("parsing address '%s'\n", argv[1]);
    77                 rc = inet_pton(AF_INET, argv[1], (uint8_t *)&addr.sin_addr.s_addr);
     79                rc = inet_addr_parse(argv[1], &addr);
    7880                if (rc != EOK) {
    7981                        /* Try interpreting as a host name */
    … …  
    8486                        }
    8587
    86                         uint16_t af = inet_addr_sockaddr_in(&hinfo->addr, &addr, NULL);
    87                         if (af != AF_INET) {
    88                                 printf("Host '%s' not resolved as IPv4 address.\n", argv[1]);
    89                                 return rc;
    90                         }
     88                        addr = hinfo->addr;
    9189                }
    92                 printf("result: rc=%d, family=%d, addr=%x\n", rc,
    93                     addr.sin_family, addr.sin_addr.s_addr);
     90                rc = inet_addr_format(&addr, &addr_s);
     91                if (rc != EOK) {
     92                        assert(rc == ENOMEM);
     93                        printf("Out of memory.\n");
     94                        return rc;
     95                }
     96                printf("result: rc=%d, ver=%d, addr=%s\n", rc,
     97                    addr.version, addr_s);
     98                free(addr_s);
    9499        }
    95100
    96101        if (argc >= 3) {
    97102                printf("parsing port '%s'\n", argv[2]);
    98                 addr.sin_port = htons(strtoul(argv[2], &endptr, 10));
     103                port = htons(strtoul(argv[2], &endptr, 10));
    99104                if (*endptr != '\0') {
    100105                        fprintf(stderr, "Error parsing port\n");
    … …  
    103108        }
    104109
     110        rc = inet_addr_sockaddr(&hinfo->addr, port, &address, &addrlen);
     111        if (rc != EOK) {
     112                printf("Out of memory.\n");
     113                return rc;
     114        }
     115
    105116        printf("socket()\n");
    106         fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
     117        fd = socket(address->sa_family, SOCK_STREAM, IPPROTO_TCP);
    107118        printf(" -> %d\n", fd);
    108119        if (fd < 0)
    … …  
    110121
    111122        printf("connect()\n");
    112         rc = connect(fd, (struct sockaddr *) &addr, sizeof(addr));
     123        rc = connect(fd, address, addrlen);
    113124        printf(" -> %d\n", rc);
    114125        if (rc != 0)
    … …  
    133144        printf(" -> %d\n", rc);
    134145
     146        free(address);
     147
    135148        return 0;
    136149}

  • uspace/app/nterm/conn.c

    re2839d7 r26de91a  
    3838#include <fibril.h>
    3939#include <inet/dnsr.h>
     40#include <net/inet.h>
    4041#include <net/socket.h>
    4142#include <stdio.h>
     43#include <stdlib.h>
    4244#include <str_error.h>
    4345#include <sys/types.h>
    … …  
    7375}
    7476
    75 int conn_open(const char *addr_s, const char *port_s)
     77int conn_open(const char *host, const char *port_s)
    7678{
    7779        int conn_fd = -1;
     80        struct sockaddr *saddr = NULL;
     81        socklen_t saddrlen;
    7882       
    7983        /* Interpret as address */
    80         inet_addr_t addr_addr;
    81         int rc = inet_addr_parse(addr_s, &addr_addr);
     84        inet_addr_t iaddr;
     85        int rc = inet_addr_parse(host, &iaddr);
    8286       
    8387        if (rc != EOK) {
    8488                /* Interpret as a host name */
    8589                dnsr_hostinfo_t *hinfo = NULL;
    86                 rc = dnsr_name2host(addr_s, &hinfo, ip_any);
     90                rc = dnsr_name2host(host, &hinfo, ip_any);
    8791               
    8892                if (rc != EOK) {
    89                         printf("Error resolving host '%s'.\n", addr_s);
     93                        printf("Error resolving host '%s'.\n", host);
    9094                        goto error;
    9195                }
    9296               
    93                 addr_addr = hinfo->addr;
     97                iaddr = hinfo->addr;
    9498        }
    95        
    96         struct sockaddr_in addr;
    97         struct sockaddr_in6 addr6;
    98         uint16_t af = inet_addr_sockaddr_in(&addr_addr, &addr, &addr6);
    9999       
    100100        char *endptr;
    … …  
    105105        }
    106106       
    107         printf("Connecting to host %s port %u\n", addr_s, port);
     107        rc = inet_addr_sockaddr(&iaddr, port, &saddr, &saddrlen);
     108        if (rc != EOK) {
     109                assert(rc == ENOMEM);
     110                printf("Out of memory.\n");
     111                return ENOMEM;
     112        }
    108113       
    109         conn_fd = socket(PF_INET, SOCK_STREAM, 0);
     114        printf("Connecting to host %s port %u\n", host, port);
     115       
     116        conn_fd = socket(saddr->sa_family, SOCK_STREAM, 0);
    110117        if (conn_fd < 0)
    111118                goto error;
    112119       
    113         switch (af) {
    114         case AF_INET:
    115                 addr.sin_port = htons(port);
    116                 rc = connect(conn_fd, (struct sockaddr *) &addr, sizeof(addr));
    117                 break;
    118         case AF_INET6:
    119                 addr6.sin6_port = htons(port);
    120                 rc = connect(conn_fd, (struct sockaddr *) &addr6, sizeof(addr6));
    121                 break;
    122         default:
    123                 printf("Unknown address family.\n");
    124                 goto error;
    125         }
    126        
     120        rc = connect(conn_fd, saddr, saddrlen);
    127121        if (rc != EOK)
    128122                goto error;
    … …  
    134128        fibril_add_ready(rcv_fid);
    135129       
     130        free(saddr);
    136131        return EOK;
    137        
    138132error:
    139133        if (conn_fd >= 0) {
    … …  
    141135                conn_fd = -1;
    142136        }
     137        free(saddr);
    143138       
    144139        return EIO;

  • uspace/lib/c/generic/inet/addr.c

    re2839d7 r26de91a  
    636636}
    637637
     638int inet_addr_sockaddr(const inet_addr_t *addr, uint16_t port,
     639    sockaddr_t **nsockaddr, socklen_t *naddrlen)
     640{
     641        sockaddr_in_t *sa4;
     642        sockaddr_in6_t *sa6;
     643
     644        switch (addr->version) {
     645        case ip_v4:
     646                sa4 = calloc(1, sizeof(sockaddr_in_t));
     647                if (sa4 == NULL)
     648                        return ENOMEM;
     649
     650                sa4->sin_family = AF_INET;
     651                sa4->sin_port = host2uint16_t_be(port);
     652                sa4->sin_addr.s_addr = host2uint32_t_be(addr->addr);
     653                if (nsockaddr != NULL)
     654                        *nsockaddr = (sockaddr_t *)sa4;
     655                if (naddrlen != NULL)
     656                        *naddrlen = sizeof(*sa4);
     657                break;
     658        case ip_v6:
     659                sa6 = calloc(1, sizeof(sockaddr_in6_t));
     660                if (sa6 == NULL)
     661                        return ENOMEM;
     662
     663                sa6->sin6_family = AF_INET6;
     664                sa6->sin6_port = host2uint16_t_be(port);
     665                host2addr128_t_be(addr->addr6, sa6->sin6_addr.s6_addr);
     666                if (nsockaddr != NULL)
     667                        *nsockaddr = (sockaddr_t *)sa6;
     668                if (naddrlen != NULL)
     669                        *naddrlen = sizeof(*sa6);
     670                break;
     671        default:
     672                assert(false);
     673                break;
     674        }
     675
     676        return EOK;
     677}
     678
    638679/** @}
    639680 */

  • uspace/lib/c/include/inet/addr.h

    re2839d7 r26de91a  
    3939#include <net/in.h>
    4040#include <net/in6.h>
     41#include <net/socket.h>
    4142
    4243typedef uint32_t addr32_t;
    … …  
    135136
    136137extern ip_ver_t ipver_from_af(int af);
     138extern int inet_addr_sockaddr(const inet_addr_t *, uint16_t, sockaddr_t **,
     139    socklen_t *);
    137140
    138141#endif

  • uspace/lib/http/http.c

    re2839d7 r26de91a  
    174174        }
    175175       
    176         struct sockaddr_in addr;
    177         struct sockaddr_in6 addr6;
    178         uint16_t af = inet_addr_sockaddr_in(&http->addr, &addr, &addr6);
    179        
    180         http->conn_sd = socket(PF_INET, SOCK_STREAM, 0);
     176        struct sockaddr *saddr;
     177        socklen_t saddrlen;
     178       
     179        rc = inet_addr_sockaddr(&http->addr, http->port, &saddr, &saddrlen);
     180        if (rc != EOK) {
     181                assert(rc == ENOMEM);
     182                return ENOMEM;
     183        }
     184       
     185        http->conn_sd = socket(saddr->sa_family, SOCK_STREAM, 0);
    181186        if (http->conn_sd < 0)
    182187                return http->conn_sd;
    183188       
    184         switch (af) {
    185         case AF_INET:
    186                 addr.sin_port = htons(http->port);
    187                 rc = connect(http->conn_sd, (struct sockaddr *) &addr, sizeof(addr));
    188                 break;
    189         case AF_INET6:
    190                 addr6.sin6_port = htons(http->port);
    191                 rc = connect(http->conn_sd, (struct sockaddr *) &addr6, sizeof(addr6));
    192                 break;
    193         default:
    194                 return ENOTSUP;
    195         }
     189        rc = connect(http->conn_sd, saddr, saddrlen);
     190        free(saddr);
    196191       
    197192        return rc;

  • uspace/srv/net/dnsrsrv/transport.c

    re2839d7 r26de91a  
    182182{
    183183        trans_req_t *treq = NULL;
     184        struct sockaddr *saddr = NULL;
     185        socklen_t saddrlen;
    184186       
    185187        void *req_data;
    … …  
    189191                goto error;
    190192       
    191         struct sockaddr_in addr;
    192         struct sockaddr_in6 addr6;
    193         uint16_t af =
    194             inet_addr_sockaddr_in(&dns_server_addr, &addr, &addr6);
    195        
    196         struct sockaddr *address;
    197         socklen_t addrlen;
    198        
    199         switch (af) {
    200         case AF_INET:
    201                 addr.sin_port = htons(DNS_SERVER_PORT);
    202                 address = (struct sockaddr *) &addr;
    203                 addrlen = sizeof(addr);
    204                 break;
    205         case AF_INET6:
    206                 addr6.sin6_port = htons(DNS_SERVER_PORT);
    207                 address = (struct sockaddr *) &addr6;
    208                 addrlen = sizeof(addr6);
    209                 break;
    210         default:
    211                 rc = EAFNOSUPPORT;
     193        rc = inet_addr_sockaddr(&dns_server_addr, DNS_SERVER_PORT,
     194            &saddr, &saddrlen);
     195        if (rc != EOK) {
     196                assert(rc == ENOMEM);
    212197                goto error;
    213198        }
    … …  
    217202        while (ntry < REQ_RETRY_MAX) {
    218203                rc = sendto(transport_fd, req_data, req_size, 0,
    219                     (struct sockaddr *) address, addrlen);
     204                    saddr, saddrlen);
    220205                if (rc != EOK)
    221206                        goto error;
    … …  
    256241        treq_destroy(treq);
    257242        free(req_data);
     243        free(saddr);
    258244        return EOK;
    259245       
    … …  
    263249       
    264250        free(req_data);
     251        free(saddr);
    265252        return rc;
    266253}
Note: See TracChangeset for help on using the changeset viewer.