fds.c

   1 #include <errno.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <unistd.h>
   6 #include <sys/epoll.h>
   7 #include <sys/eventfd.h>
   8
   9 #include "epoll.h"
  10 #include "eventfd.h"
  11 #include "files.h"
  12 #include "log.h"
  13 #include "net.h"
  14 #include "params.h"
  15 #include "perf.h"
  16 #include "pids.h"
  17 #include "pipes.h"
  18 #include "random.h"
  19 #include "sanitise.h"
  20 #include "shm.h"
  21 #include "trinity.h"
  22
  23 static int get_new_random_fd(void)
  24 {
  25         unsigned int i;
  26         int fd = 0;
  27
  28 retry:
  29         i = rand() % 6;
  30
  31         if (do_specific_proto == TRUE)
  32                 i = 1;
  33
  34         if (no_files == TRUE)
  35                 i = 1;
  36
  37         /* Ugly special case.
  38          * Sometimes, we can get here without any fd's setup.
  39          * If this happens, we divide by zero if we pick case 0 because
  40          * nr_file_fds is zero
  41          *
  42          * When this circumstance occurs, we just force it to use another network socket.
  43          *
  44          * FIXME: A better solution would be to like, actually open an fd. duh.
  45          */
  46         if (nr_file_fds == 0)
  47                 i = 1;
  48
  49         switch (i) {
  50         case 0:
  51                 fd = rand_file_fd();
  52                 break;
  53
  54         case 1:
  55                 /* When using victim files, sockets can be 0.
  56                  * Use files as a fallback, or pipes if no files are open.
  57                  */
  58                 if (nr_sockets == 0) {
  59                         if (nr_file_fds > 0)
  60                                 fd = rand_file_fd();
  61                         else
  62                                 fd = rand_pipe_fd();
  63                         return fd;
  64                 }
  65                 fd = shm->sockets[rand() % nr_sockets].fd;
  66                 break;
  67
  68         case 2:
  69                 fd = rand_pipe_fd();
  70                 break;
  71
  72         case 3:
  73                 if (shm->perf_fds[0] == 0)      /* perf unavailable/disabled. */
  74                         goto retry;
  75
  76                 fd = rand_perf_fd();
  77                 break;
  78
  79         case 4:
  80                 fd = rand_epoll_fd();
  81                 break;
  82
  83         case 5:
  84                 fd = rand_eventfd_fd();
  85                 break;
  86
  87         }
  88
  89         return fd;
  90 }
  91
  92 int get_random_fd(void)
  93 {
  94         /* 25% chance of returning something new. */
  95         if ((rand() % 4) == 0)
  96                 return get_new_random_fd();
  97
  98         /* the rest of the time, return the same fd as last time. */
  99 regen:
 100         if (shm->fd_lifetime == 0) {
 101                 shm->current_fd = get_new_random_fd();
 102                 shm->fd_lifetime = (rand() % max_children) + 5;
 103         } else
 104                 shm->fd_lifetime--;
 105
 106         if (shm->current_fd == 0) {
 107                 shm->fd_lifetime = 0;
 108                 goto regen;
 109         }
 110
 111         return shm->current_fd;
 112 }
 113
 114 unsigned int setup_fds(void)
 115 {
 116         int ret = TRUE;
 117
 118         /* If we have victim files, don't worry about sockets. */
 119         if (victim_path == NULL) {
 120                 ret = open_sockets();
 121                 if (ret == FALSE)
 122                         return FALSE;
 123         }
 124
 125         open_pipes();
 126
 127         open_perf_fds();
 128
 129         open_epoll_fds();
 130
 131         open_eventfd_fds();
 132
 133         if (no_files == FALSE)
 134                 ret = open_files();
 135
 136         return ret;
 137 }
 138
 139 void regenerate_fds(void)
 140 {
 141         if (no_files == TRUE)
 142                 return;
 143
 144         close_files();
 145         open_files();
 146 }