source4/torture/local/socket.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    local testing of socket routines.
   5
   6    Copyright (C) Andrew Tridgell 2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "lib/socket/socket.h"
  25 #include "lib/events/events.h"
  26
  27 #define CHECK_STATUS(status, correct) do { \
  28         if (!NT_STATUS_EQUAL(status, correct)) { \
  29                 printf("(%s) Incorrect status %s - should be %s\n", \
  30                        __location__, nt_errstr(status), nt_errstr(correct)); \
  31                 ret = False; \
  32                 goto done; \
  33         }} while (0)
  34
  35
  36 /*
  37   basic testing of udp routines
  38 */
  39 static BOOL test_udp(TALLOC_CTX *mem_ctx)
  40 {
  41         struct socket_context *sock1, *sock2;
  42         NTSTATUS status;
  43         struct socket_address *srv_addr, *from_addr, *localhost;
  44         size_t size = 100 + (random() % 100);
  45         DATA_BLOB blob, blob2;
  46         size_t sent, nread;
  47         BOOL ret = True;
  48
  49         printf("TESTING UDP SOCKETS\n");
  50
  51         status = socket_create("ip", SOCKET_TYPE_DGRAM, &sock1, 0);
  52         CHECK_STATUS(status, NT_STATUS_OK);
  53         talloc_steal(mem_ctx, sock1);
  54
  55         status = socket_create("ip", SOCKET_TYPE_DGRAM, &sock2, 0);
  56         CHECK_STATUS(status, NT_STATUS_OK);
  57         talloc_steal(mem_ctx, sock2);
  58
  59         localhost = socket_address_from_strings(sock1, sock1->backend_name,
  60                                                 iface_best_ip("127.0.0.1"), 0);
  61         if (!localhost) {
  62                 return False;
  63         }
  64
  65         status = socket_listen(sock1, localhost, 0, 0);
  66         CHECK_STATUS(status, NT_STATUS_OK);
  67
  68         srv_addr = socket_get_my_addr(sock1, mem_ctx);
  69         if (srv_addr == NULL || strcmp(srv_addr->addr, iface_best_ip("127.0.0.1")) != 0) {
  70                 printf("Expected server address of %s but got %s\n",
  71                        iface_best_ip("127.0.0.1"), srv_addr ? srv_addr->addr : NULL);
  72                 return False;
  73         }
  74
  75         printf("server port is %d\n", srv_addr->port);
  76
  77         blob  = data_blob_talloc(mem_ctx, NULL, size);
  78         blob2 = data_blob_talloc(mem_ctx, NULL, size);
  79         generate_random_buffer(blob.data, blob.length);
  80
  81         sent = size;
  82         status = socket_sendto(sock2, &blob, &sent, 0, srv_addr);
  83         CHECK_STATUS(status, NT_STATUS_OK);
  84
  85         status = socket_recvfrom(sock1, blob2.data, size, &nread, 0,
  86                                  sock1, &from_addr);
  87         CHECK_STATUS(status, NT_STATUS_OK);
  88
  89         if (strcmp(from_addr->addr, srv_addr->addr) != 0) {
  90                 printf("Unexpected recvfrom addr %s\n", from_addr->addr);
  91                 ret = False;
  92         }
  93         if (nread != size) {
  94                 printf("Unexpected recvfrom size %d should be %d\n", (int)nread, (int)size);
  95                 ret = False;
  96         }
  97
  98         if (memcmp(blob2.data, blob.data, size) != 0) {
  99                 printf("Bad data in recvfrom\n");
 100                 ret = False;
 101         }
 102
 103         generate_random_buffer(blob.data, blob.length);
 104         status = socket_sendto(sock1, &blob, &sent, 0, from_addr);
 105         CHECK_STATUS(status, NT_STATUS_OK);
 106
 107         status = socket_recvfrom(sock2, blob2.data, size, &nread, 0,
 108                                  sock2, &from_addr);
 109         CHECK_STATUS(status, NT_STATUS_OK);
 110         if (strcmp(from_addr->addr, srv_addr->addr) != 0) {
 111                 printf("Unexpected recvfrom addr %s\n", from_addr->addr);
 112                 ret = False;
 113         }
 114         if (nread != size) {
 115                 printf("Unexpected recvfrom size %d should be %d\n", (int)nread, (int)size);
 116                 ret = False;
 117         }
 118         if (from_addr->port != srv_addr->port) {
 119                 printf("Unexpected recvfrom port %d should be %d\n",
 120                        from_addr->port, srv_addr->port);
 121                 ret = False;
 122         }
 123         if (memcmp(blob2.data, blob.data, size) != 0) {
 124                 printf("Bad data in recvfrom\n");
 125                 ret = False;
 126         }
 127
 128 done:
 129         talloc_free(sock1);
 130         talloc_free(sock2);
 131
 132         return ret;
 133 }
 134
 135 /*
 136   basic testing of tcp routines
 137 */
 138 static BOOL test_tcp(TALLOC_CTX *mem_ctx)
 139 {
 140         struct socket_context *sock1, *sock2, *sock3;
 141         NTSTATUS status;
 142         struct socket_address *srv_addr, *from_addr, *localhost;
 143         size_t size = 100 + (random() % 100);
 144         DATA_BLOB blob, blob2;
 145         size_t sent, nread;
 146         BOOL ret = True;
 147         struct event_context *ev = event_context_init(mem_ctx);
 148
 149         printf("TESTING TCP SOCKETS\n");
 150
 151         status = socket_create("ip", SOCKET_TYPE_STREAM, &sock1, 0);
 152         CHECK_STATUS(status, NT_STATUS_OK);
 153         talloc_steal(mem_ctx, sock1);
 154
 155         status = socket_create("ip", SOCKET_TYPE_STREAM, &sock2, 0);
 156         CHECK_STATUS(status, NT_STATUS_OK);
 157         talloc_steal(mem_ctx, sock2);
 158
 159         localhost = socket_address_from_strings(sock1, sock1->backend_name,
 160                                                 iface_best_ip("127.0.0.1"), 0);
 161         if (!localhost) {
 162                 return False;
 163         }
 164
 165         status = socket_listen(sock1, localhost, 0, 0);
 166         CHECK_STATUS(status, NT_STATUS_OK);
 167
 168         srv_addr = socket_get_my_addr(sock1, mem_ctx);
 169         if (srv_addr == NULL || !srv_addr->addr) {
 170                 printf("Unexpected socket_get_my_addr NULL\n");
 171                 return False;
 172         }
 173
 174         if (strcmp(srv_addr->addr, iface_best_ip("127.0.0.1")) != 0) {
 175                 printf("Expected server address of %s but got %s\n",
 176                        iface_best_ip("127.0.0.1"), srv_addr ? srv_addr->addr : NULL);
 177                 return False;
 178         }
 179
 180         printf("server port is %d\n", srv_addr->port);
 181
 182         status = socket_connect_ev(sock2, NULL, srv_addr, 0, ev);
 183         CHECK_STATUS(status, NT_STATUS_OK);
 184
 185         status = socket_accept(sock1, &sock3);
 186         CHECK_STATUS(status, NT_STATUS_OK);
 187         talloc_steal(mem_ctx, sock3);
 188         talloc_free(sock1);
 189
 190         blob  = data_blob_talloc(mem_ctx, NULL, size);
 191         blob2 = data_blob_talloc(mem_ctx, NULL, size);
 192         generate_random_buffer(blob.data, blob.length);
 193
 194         sent = size;
 195         status = socket_send(sock2, &blob, &sent, 0);
 196         CHECK_STATUS(status, NT_STATUS_OK);
 197
 198         status = socket_recv(sock3, blob2.data, size, &nread, 0);
 199         CHECK_STATUS(status, NT_STATUS_OK);
 200
 201         from_addr = socket_get_peer_addr(sock3, mem_ctx);
 202
 203         if (!from_addr || !from_addr->addr) {
 204                 printf("Unexpected recvfrom addr NULL\n");
 205                 return False;
 206         }
 207         if (strcmp(from_addr->addr, srv_addr->addr) != 0) {
 208                 printf("Unexpected recvfrom addr %s\n", from_addr ? from_addr->addr : NULL);
 209                 ret = False;
 210         }
 211         if (nread != size) {
 212                 printf("Unexpected recvfrom size %d should be %d\n", (int)nread, (int)size);
 213                 ret = False;
 214         }
 215
 216         if (memcmp(blob2.data, blob.data, size) != 0) {
 217                 printf("Bad data in recvfrom\n");
 218                 ret = False;
 219         }
 220
 221         generate_random_buffer(blob.data, blob.length);
 222         status = socket_send(sock3, &blob, &sent, 0);
 223         CHECK_STATUS(status, NT_STATUS_OK);
 224
 225         status = socket_recv(sock2, blob2.data, size, &nread, 0);
 226         CHECK_STATUS(status, NT_STATUS_OK);
 227
 228         from_addr = socket_get_peer_addr(sock2, mem_ctx);
 229
 230         if (!from_addr || !from_addr->addr) {
 231                 printf("Unexpected recvfrom addr NULL\n");
 232                 return False;
 233         }
 234         if (strcmp(from_addr->addr, srv_addr->addr) != 0) {
 235                 printf("Unexpected recvfrom addr %s\n", from_addr ? from_addr->addr : NULL);
 236                 ret = False;
 237         }
 238         if (nread != size) {
 239                 printf("Unexpected recvfrom size %d should be %d\n", (int)nread, (int)size);
 240                 ret = False;
 241         }
 242         if (from_addr->port != srv_addr->port) {
 243                 printf("Unexpected recvfrom port %d should be %d\n",
 244                        from_addr->port, srv_addr->port);
 245                 ret = False;
 246         }
 247         if (memcmp(blob2.data, blob.data, size) != 0) {
 248                 printf("Bad data in recvfrom\n");
 249                 ret = False;
 250         }
 251
 252 done:
 253
 254         return ret;
 255 }
 256
 257 BOOL torture_local_socket(void)
 258 {
 259         BOOL ret = True;
 260         TALLOC_CTX *mem_ctx = talloc_new(NULL);
 261
 262         ret &= test_udp(mem_ctx);
 263         ret &= test_tcp(mem_ctx);
 264
 265         return ret;
 266 }