test/src/test.c

   1 #include <errno.h>
   2 #include <stdio.h>
   3 #include <memory.h>
   4 #include <fcntl.h>
   5 #include <ev.h>
   6
   7 #include <stdlib.h> /* exit, system */
   8 #include <unistd.h>
   9 #include <sys/types.h>
  10 #include <sys/socket.h>
  11 #include <netdb.h>
  12
  13 /* setrlimit */
  14 #include <sys/time.h>
  15 #include <sys/resource.h>
  16
  17 #include <assert.h> /* assert */
  18 #include "core.h"
  19 #include "connect_request.h"
  20 #include "request.h"
  21
  22 #include "data_item.h"
  23
  24 #if 0
  25 void pump_data(output_item *item) {
  26         while(output_remaining(item)) {
  27                 int ret = output_send(item, 1, FDT_PIPE);
  28                 if(ret < 0) {
  29                         perror("Failed to send output...");
  30                         goto err;
  31                 }
  32         }
  33         output_on_complete(item);
  34         goto cleanup;
  35 err:
  36         output_on_error(item, errno);
  37 cleanup:
  38         output_release(item);
  39 }
  40
  41 void memory_test() {
  42         output_item *mem = new_memory_output_item("TEST VALUE\n", strlen("TEST VALUE\n"), 0);
  43         pump_data(mem);
  44 }
  45
  46 output_item *new_file_output_item_byname(const char *name) {
  47         int fd = open(name, O_RDONLY);
  48         if(fd <= 0) {
  49                 perror("Failed to open file");
  50                 return NULL;
  51         }
  52         return new_file_output_item(fd);
  53 }
  54
  55 void file_test() {
  56         output_item *file = new_file_output_item_byname("premake.lua");
  57         pump_data(file);
  58 }
  59
  60 void event_test() {
  61         struct ev_loop *loop = ev_default_loop(0);
  62         output_hook *hook = new_output_hook();
  63         ev_io watcher;
  64         /* SET STDOUT to be non-blocking */
  65         int flags;
  66
  67         output_item *mem = new_memory_output_item("TEST VALUE\n", strlen("TEST VALUE\n"), 0);
  68         output_hook_queue(hook, mem);
  69         mem = new_file_output_item_byname("core/src/output_hook.c");
  70         output_hook_queue(hook, mem);
  71
  72         if(-1 == (flags = fcntl(1, F_GETFL, 0)))
  73                 flags = 0;
  74         fcntl(1, F_SETFL, flags | O_NONBLOCK);
  75         ev_io_init(&watcher, output_hook_callback, /* STDOUT */ 1, EV_WRITE);
  76         watcher.data = hook;
  77         ev_io_start(loop, &watcher);
  78
  79         ev_loop(loop, 0);
  80         release_output_hook(hook);
  81         ev_default_destroy();
  82         return;
  83 }
  84 #endif
  85 static int bad_count = 0;
  86 int connect_err_cb(void *req, int err, void *data) {
  87         int error = errno;
  88         int fd;
  89         bad_count++;
  90         printf("ERROR: %i %i %s\n", err, error, strerror(error));
  91         fd = ConnectRequest_getFd(req);
  92         if(fd > 0)
  93                 close(fd);
  94         free_ConnectRequest(req);
  95         return 0;
  96 }
  97
  98 static int success_count = 0;
  99
 100 void connect_cb(void *req, void *data) {
 101         int fd = ConnectRequest_getFd(req);
 102         success_count++;
 103         close(fd);
 104         free_ConnectRequest(req);
 105 }
 106
 107 int socket_error_cb(void *req, int err, void *data) {
 108         int error = errno;
 109         int fd;
 110         bad_count++;
 111         printf("ERROR: %i %i %s\n", err, error, strerror(error));
 112         fd = SocketRequest_getFd(req);
 113         if(fd > 0 && error != EMFILE && error != ENFILE)
 114                 close(fd);
 115         free(data);
 116         free_SocketRequest(req);
 117         return 0;
 118 }
 119
 120 struct addrContainer {
 121         struct sockaddr *addr;
 122         socklen_t addr_len;
 123 };
 124
 125 void socket_cb(void *req, void *data) {
 126         HandlerCallback callback = {
 127                 connect_cb,
 128                 connect_err_cb,
 129                 NULL
 130         };
 131         core_t *c = SocketRequest_getCore(req);
 132         int fd = SocketRequest_getFd(req);
 133         struct addrContainer *addr = data;
 134         ConnectRequest *cr = new_ConnectRequest(c, callback, fd, addr->addr, addr->addr_len);
 135         ConnectRequest_queue(cr, 10);
 136         free(data);
 137         free_SocketRequest(req);
 138 }
 139
 140 void connect_handler_test() {
 141         core_t *c = new_core();
 142         struct addrinfo ai, *aitop = NULL;
 143         int i;
 144         HandlerCallback callback = {
 145                 socket_cb,
 146                 socket_error_cb
 147         };
 148         assert(c);
 149         memset(&ai, 0, sizeof(ai));
 150         ai.ai_family = AF_INET;
 151         ai.ai_socktype = SOCK_STREAM;
 152         if(0 != getaddrinfo("localhost", "80", &ai, &aitop)) {
 153                 perror("getaddrinfo"); exit(-1);
 154         }
 155         {
 156                 struct rlimit lim;
 157                 getrlimit(RLIMIT_NOFILE, &lim);
 158                 lim.rlim_cur = 64;
 159                 setrlimit(RLIMIT_NOFILE, &lim);
 160         }
 161
 162         for(i = 0; i < 1024; i++) {
 163                 SocketRequest *sr;
 164                 struct addrContainer *cont = calloc(1, sizeof(struct addrContainer));
 165                 cont->addr = aitop->ai_addr;
 166                 cont->addr_len = aitop->ai_addrlen;
 167                 callback.data = cont;
 168                 sr = new_SocketRequest(c, callback, PF_INET, SOCK_STREAM, 0);
 169                 SocketRequest_queue(sr, 0, 0);
 170         }
 171         freeaddrinfo(aitop);
 172         ev_loop(c->loop, 0);
 173         free_core(c);
 174         printf("BAD COUNT: %i\nGOOD COUNT: %i\nTOTAL:%i\n", bad_count, success_count, bad_count + success_count);
 175 }
 176 void data_item_test() {
 177         data_item_t *mem = new_memory_item("HELLO", 6);
 178         printf("MEMORY_TYPE: %i\n", mem->typeID);
 179         free_data_item(mem);
 180 }
 181
 182 int main(int argc, const char **argv) {
 183 #if 0
 184         memory_test();
 185         file_test();
 186 #endif
 187         data_item_test();
 188         if(argc > 1 && !strcmp(argv[1], "--sock")) {
 189                 struct addrinfo ai, *aitop;
 190                 int sock;
 191                 system("nc -l -p 9876 &");
 192                 sleep(1);
 193                 memset(&ai, 0, sizeof(ai));
 194                 ai.ai_family = AF_INET;
 195                 ai.ai_socktype = SOCK_STREAM;
 196                 if(0 != getaddrinfo("localhost", "9876", &ai, &aitop)) {
 197                         perror("getaddrinfo"); return -1;
 198                 }
 199                 sock = socket(PF_INET, SOCK_STREAM, 0);
 200                 if(sock < 0) { perror("Failed to create socket"); return -1; }
 201                 if(0 > connect(sock, aitop->ai_addr, aitop->ai_addrlen)) {
 202                         perror("connect");
 203                         freeaddrinfo(aitop);
 204                         return -1;
 205                 }
 206                 freeaddrinfo(aitop);
 207                 /* Replace stdout w/ the socket */
 208                 if(0 > dup2(sock, 1)) {
 209                         perror("dup2"); return -1;
 210                 }
 211         }
 212 #if 0
 213         event_test();
 214 #endif
 215         connect_handler_test();
 216         return 0;
 217 }