rubbos/app/httpd-2.0.64/srclib/apr/test/testsockets.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "apr_network_io.h"
  18 #include "apr_errno.h"
  19 #include "apr_general.h"
  20 #include "apr_lib.h"
  21 #include "test_apr.h"
  22
  23 #if APR_HAVE_IPV6
  24 #define US "::1"
  25 #define FAMILY APR_INET6
  26 #else
  27 #define US "127.0.0.1"
  28 #define FAMILY APR_INET
  29 #endif
  30
  31 #define STRLEN 21
  32
  33 static void tcp_socket(CuTest *tc)
  34 {
  35     apr_status_t rv;
  36     apr_socket_t *sock = NULL;
  37
  38     rv = apr_socket_create(&sock, APR_INET, SOCK_STREAM, p);
  39     CuAssertIntEquals(tc, APR_SUCCESS, rv);
  40     CuAssertPtrNotNull(tc, sock);
  41     apr_socket_close(sock);
  42 }
  43
  44 static void udp_socket(CuTest *tc)
  45 {
  46     apr_status_t rv;
  47     apr_socket_t *sock = NULL;
  48
  49     rv = apr_socket_create(&sock, APR_INET, SOCK_DGRAM, p);
  50     CuAssertIntEquals(tc, APR_SUCCESS, rv);
  51     CuAssertPtrNotNull(tc, sock);
  52     apr_socket_close(sock);
  53 }
  54
  55 static void tcp6_socket(CuTest *tc)
  56 {
  57 #if APR_HAVE_IPV6
  58     apr_status_t rv;
  59     apr_socket_t *sock = NULL;
  60
  61     rv = apr_socket_create(&sock, APR_INET6, SOCK_STREAM, p);
  62     CuAssertIntEquals(tc, APR_SUCCESS, rv);
  63     CuAssertPtrNotNull(tc, sock);
  64     apr_socket_close(sock);
  65 #else
  66     CuNotImpl(tc, "IPv6");
  67 #endif
  68 }
  69
  70 static void udp6_socket(CuTest *tc)
  71 {
  72 #if APR_HAVE_IPV6
  73     apr_status_t rv;
  74     apr_socket_t *sock = NULL;
  75
  76     rv = apr_socket_create(&sock, APR_INET6, SOCK_DGRAM, p);
  77     CuAssertIntEquals(tc, APR_SUCCESS, rv);
  78     CuAssertPtrNotNull(tc, sock);
  79     apr_socket_close(sock);
  80 #else
  81     CuNotImpl(tc, "IPv6");
  82 #endif
  83 }
  84
  85 static void sendto_receivefrom(CuTest *tc)
  86 {
  87     apr_status_t rv;
  88     apr_socket_t *sock = NULL;
  89     apr_socket_t *sock2 = NULL;
  90     char sendbuf[STRLEN] = "APR_INET, SOCK_DGRAM";
  91     char recvbuf[80];
  92     char *ip_addr;
  93     apr_port_t fromport;
  94     apr_sockaddr_t *from;
  95     apr_sockaddr_t *to;
  96     apr_size_t len = 30;
  97
  98     rv = apr_socket_create(&sock, FAMILY, SOCK_DGRAM, p);
  99     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 100     rv = apr_socket_create(&sock2, FAMILY, SOCK_DGRAM, p);
 101     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 102
 103     rv = apr_sockaddr_info_get(&to, US, APR_UNSPEC, 7772, 0, p);
 104     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 105     rv = apr_sockaddr_info_get(&from, US, APR_UNSPEC, 7771, 0, p);
 106     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 107
 108     rv = apr_socket_bind(sock, to);
 109     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 110     rv = apr_socket_bind(sock2, from);
 111     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 112
 113     len = STRLEN;
 114     rv = apr_socket_sendto(sock2, to, 0, sendbuf, &len);
 115     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 116     CuAssertIntEquals(tc, STRLEN, len);
 117
 118     len = 80;
 119     rv = apr_socket_recvfrom(from, sock, 0, recvbuf, &len);
 120     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 121     CuAssertIntEquals(tc, STRLEN, len);
 122     CuAssertStrEquals(tc, "APR_INET, SOCK_DGRAM", recvbuf);
 123
 124     apr_sockaddr_ip_get(&ip_addr, from);
 125     apr_sockaddr_port_get(&fromport, from);
 126     CuAssertStrEquals(tc, US, ip_addr);
 127     CuAssertIntEquals(tc, 7771, fromport);
 128
 129     apr_socket_close(sock);
 130     apr_socket_close(sock2);
 131 }
 132
 133 static void socket_userdata(CuTest *tc)
 134 {
 135     apr_socket_t *sock1, *sock2;
 136     apr_status_t rv;
 137     char *data;
 138     const char *key = "GENERICKEY";
 139
 140     rv = apr_socket_create(&sock1, AF_INET, SOCK_STREAM, p);
 141     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 142     rv = apr_socket_create(&sock2, AF_INET, SOCK_STREAM, p);
 143     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 144
 145     rv = apr_socket_data_set(sock1, "SOCK1", key, NULL);
 146     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 147     rv = apr_socket_data_set(sock2, "SOCK2", key, NULL);
 148     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 149
 150     rv = apr_socket_data_get((void **)&data, key, sock1);
 151     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 152     CuAssertStrEquals(tc, "SOCK1", data);
 153     rv = apr_socket_data_get((void **)&data, key, sock2);
 154     CuAssertIntEquals(tc, APR_SUCCESS, rv);
 155     CuAssertStrEquals(tc, "SOCK2", data);
 156 }
 157
 158 CuSuite *testsockets(void)
 159 {
 160     CuSuite *suite = CuSuiteNew("Socket Creation");
 161
 162     SUITE_ADD_TEST(suite, tcp_socket);
 163     SUITE_ADD_TEST(suite, udp_socket);
 164
 165     SUITE_ADD_TEST(suite, tcp6_socket);
 166     SUITE_ADD_TEST(suite, udp6_socket);
 167
 168     SUITE_ADD_TEST(suite, sendto_receivefrom);
 169
 170     SUITE_ADD_TEST(suite, socket_userdata);
 171
 172     return suite;
 173 }
 174