added a test to check glibc socket functions wrappers

tests/glibc_socket_wrappers/test_sock.c

Index: tests/glibc_socket_wrappers/test_sock.c
===================================================================
--- tests/glibc_socket_wrappers/test_sock.c	(revision 0)
+++ tests/glibc_socket_wrappers/test_sock.c	(revision 0)
@@ -0,0 +1,278 @@
+/*
+ * Copyright 2010 The Native Client Authors. All rights reserved.

[vissi, 2012/04/16 11:20:48]

2012

[vissi, 2012/04/18 16:28:33]

Done.

+ * Use of this source code is governed by a BSD-style license that can
+ * be found in the LICENSE file.
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include "irt_syscalls.h"
+
+#pragma GCC diagnostic ignored "-Wnonnull"

[Evgeniy Stepanov, 2012/04/16 11:26:50]

Do you really need this?

[pasko-google - do not use, 2012/04/16 11:32:26]

why so?

[vissi, 2012/04/18 16:28:33]

no need, removed

+
+int test_var;
+#ifdef __cplusplus
+extern "C" {

[pasko-google - do not use, 2012/04/16 11:32:26]

there is no need for this in test

[vissi, 2012/04/18 16:28:33]

Done.

+#endif
+#define DO_WRAP(name) do { \

[pasko-google - do not use, 2012/04/16 11:32:26]

a better name would be REGISTER_WRAPPER_IN_GLIBC

[vissi, 2012/04/18 16:28:33]

Done.

+    __nacl_irt_##name = __nacl_irt_##name##_wrap; \
+  } while (0)
+#define WRAP(name) __nacl_irt_##name##_wrap
+
+  int WRAP(socket) (int domain, int type, int protocol) {
+    ++test_var;

[Evgeniy Stepanov, 2012/04/16 11:26:50]

It might be easier to return a magic value or an error code, and then check the
function return value or errno?

[vissi, 2012/04/18 16:28:33]

Done.

+    return -1;
+  }
+
+  int WRAP(accept) (int sockfd, struct sockaddr* addr, socklen_t* addrlen) {

[Evgeniy Stepanov, 2012/04/16 11:26:50]

Please remove spaces before argument list and fix lint warnings.

[vissi, 2012/04/18 16:28:33]

Done. Don't we use lint in glibc (irt_syscalls was taken from there)?

+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(bind) (int sockfd, const struct sockaddr* addr, socklen_t addrlen) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(listen) (int sockfd, int backlog) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(connect) (int sockfd, const struct sockaddr* addr,
+                     socklen_t addrlen) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(send) (int sockfd, const void *buf, size_t len, int flags,
+                  int* ret) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(sendto) (int sockfd, const void *buf, size_t len, int flags,
+                    const struct sockaddr *dest_addr, socklen_t addrlen,
+                    int* ret) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(sendmsg) (int sockfd, const struct msghdr *msg, int flags,
+                     int* ret) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(recv) (int sockfd, void *buf, size_t len, int flags, int* ret) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(recvfrom) (int sockfd, void *buf, size_t len, int flags,
+                      struct sockaddr *src_addr, socklen_t *addrlen,
+                      int* ret) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(recvmsg) (int sockfd, struct msghdr *msg, int flags, int* ret) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(getsockname) (int sockfd, struct sockaddr *addr,
+                         socklen_t *addrlen) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(getpeername) (int sockfd, struct sockaddr *addr,
+                         socklen_t *addrlen) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(setsockopt) (int sockfd, int level, int optname, const void *optval,
+                            socklen_t optlen) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(getsockopt) (int sockfd, int level, int optname, void *optval,
+                            socklen_t *optlen) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(epoll_create) (int size) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(epoll_ctl) (int epfd, int op, int fd, struct epoll_event *event) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(epoll_wait) (int epfd, struct epoll_event *events,
+                        int maxevents, int timeout) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(epoll_pwait) (int epfd, struct epoll_event *events,
+                         int maxevents, int timeout, const sigset_t *sigmask,
+                         size_t sigset_size) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(poll) (struct pollfd *fds, nfds_t nfds, int timeout) {
+    ++test_var;
+    return -1;
+  }
+
+  int WRAP(ppoll) (struct pollfd *fds, nfds_t nfds,
+                   const struct timespec *timeout, const sigset_t *sigmask,
+                   size_t sigset_size) {
+    ++test_var;
+    return -1;
+  }
+
+#ifdef __cplusplus
+}
+#endif
+
+#define DIRSIZE 8192
+#define PORT 0x1234
+int main(int argc, char** argv) {
+  DO_WRAP(socket);
+  DO_WRAP(accept);
+  DO_WRAP(bind);
+  DO_WRAP(connect);
+  DO_WRAP(listen);
+  DO_WRAP(recv);
+  DO_WRAP(recvmsg);
+  DO_WRAP(recvfrom);
+  DO_WRAP(send);
+  DO_WRAP(sendto);
+  DO_WRAP(sendmsg);
+  DO_WRAP(setsockopt);
+  DO_WRAP(getsockopt);
+  DO_WRAP(getpeername);
+  DO_WRAP(getsockname);
+  DO_WRAP(epoll_create);
+  DO_WRAP(epoll_ctl);
+  DO_WRAP(epoll_wait);
+  DO_WRAP(epoll_pwait);
+  DO_WRAP(poll);
+  DO_WRAP(ppoll);
+
+  char dir[DIRSIZE];
+  int sd, sd_current;
+  socklen_t addrlen;
+  struct sockaddr_in sin;
+  struct sockaddr_in pin;
+  struct msghdr msg;
+  struct epoll_event event;
+  struct pollfd pollfds;
+  struct timespec timeout;
+  sigset_t sigmask;
+
+  int prev_var = test_var;
+  sd = socket(AF_INET, SOCK_STREAM, 0);
+  assert(test_var - prev_var == 1);
+
+  memset(&sin, 0, sizeof(sin));
+  sin.sin_family = AF_INET;
+  sin.sin_addr.s_addr = INADDR_ANY;
+  sin.sin_port = htons(PORT);
+
+  prev_var = test_var;
+  bind(sd, (struct sockaddr *) &sin, sizeof(sin));
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  listen(sd, 5);
+  assert(test_var - prev_var == 1);
+
+  addrlen = sizeof(pin);
+  prev_var = test_var;
+  sd_current = accept(sd, (struct sockaddr *)  &pin, &addrlen);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  recv(sd_current, dir, sizeof(dir), 0);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  send(sd_current, dir, sizeof(dir), 0);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  sendto(sd_current, dir, sizeof(dir), 0, &sin, 0);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  recvfrom(sd_current, dir, sizeof(dir), 0, &sin, &addrlen);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  recvmsg(sd_current, &msg, 0);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  sendmsg(sd_current, &msg, 0);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  getsockopt(sd, 0, 0, dir, &addrlen);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  setsockopt(sd, 0, 0, dir, addrlen);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  getpeername(sd, &sin, &addrlen);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  getsockname(sd, &sin, &addrlen);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  epoll_create(0);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  epoll_ctl(0, 0, 0, &event);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  epoll_wait(0, &event, 0, 0);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  epoll_pwait(0, &event, 0, 0, &sigmask);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  poll(&pollfds, 0, 0);
+  assert(test_var - prev_var == 1);
+
+  prev_var = test_var;
+  ppoll(&pollfds, 0, &timeout, &sigmask);
+  assert(test_var - prev_var == 1);
+
+  return 0;
+}