sockets.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <unistd.h>
   5 #include <fcntl.h>
   6 #include <errno.h>
   7 #include <sys/types.h>
   8 #include <sys/socket.h>
   9 #include <sys/stat.h>
  10
  11 #include "constants.h"
  12 #include "log.h"
  13 #include "net.h"
  14 #include "maps.h"
  15 #include "params.h"     // verbose, do_specific_proto
  16 #include "protocols.h"
  17 #include "random.h"
  18 #include "shm.h"
  19 #include "trinity.h"
  20 #include "utils.h"
  21
  22 unsigned int nr_sockets = 0;
  23
  24 static const char *cachefilename="trinity.socketcache";
  25
  26 #define MAX_PER_DOMAIN 5
  27 #define MAX_TRIES_PER_DOMAIN 10
  28
  29 static int open_socket(unsigned int domain, unsigned int type, unsigned int protocol)
  30 {
  31         int fd;
  32         __unused__ int ret;
  33         struct sockaddr *sa = NULL;
  34         socklen_t salen;
  35         struct sockopt so = { 0, 0, 0, 0 };
  36
  37         fd = socket(domain, type, protocol);
  38         if (fd == -1)
  39                 return fd;
  40
  41         shm->sockets[nr_sockets].fd = fd;
  42         shm->sockets[nr_sockets].triplet.family = domain;
  43         shm->sockets[nr_sockets].triplet.type = type;
  44         shm->sockets[nr_sockets].triplet.protocol = protocol;
  45
  46         output(2, "fd[%i] = domain:%i (%s) type:0x%x protocol:%i\n",
  47                 fd, domain, get_proto_name(domain), type, protocol);
  48
  49         /* Set some random socket options. */
  50         sso_socket(&shm->sockets[nr_sockets].triplet, &so, fd);
  51
  52         nr_sockets++;
  53
  54         /* Sometimes, listen on created sockets. */
  55         if (rand_bool()) {
  56                 /* fake a sockaddr. */
  57                 generate_sockaddr((struct sockaddr **) &sa, (socklen_t *) &salen, domain);
  58
  59                 ret = bind(fd, sa, salen);
  60 /*              if (ret == -1)
  61                         debugf("bind: %s\n", strerror(errno));
  62                 else
  63                         debugf("bind: success!\n");
  64 */
  65                 ret = listen(fd, (rand() % 2) + 1);
  66 /*              if (ret == -1)
  67                         debugf("listen: %s\n", strerror(errno));
  68                 else
  69                         debugf("listen: success!\n");
  70 */
  71         }
  72
  73         /* If we didn't have a function for this sockaddr type, we would
  74          * have returned page_rand, so don't free() it or we segv. */
  75         if (sa == (struct sockaddr *) page_rand)
  76                 return fd;
  77
  78         if (sa != NULL)
  79                 free(sa);
  80
  81         return fd;
  82 }
  83
  84 static void lock_cachefile(int cachefile, int type)
  85 {
  86         struct flock fl = {
  87                 .l_len = 0,
  88                 .l_start = 0,
  89                 .l_whence = SEEK_SET,
  90         };
  91
  92         fl.l_pid = getpid();
  93         fl.l_type = type;
  94
  95         if (verbose)
  96                 output(2, "waiting on lock for cachefile\n");
  97
  98         if (fcntl(cachefile, F_SETLKW, &fl) == -1) {
  99                 perror("fcntl F_SETLKW");
 100                 exit(1);
 101         }
 102
 103         if (verbose)
 104                 output(2, "took lock for cachefile\n");
 105 }
 106
 107 static void unlock_cachefile(int cachefile)
 108 {
 109         struct flock fl = {
 110                 .l_len = 0,
 111                 .l_start = 0,
 112                 .l_whence = SEEK_SET,
 113         };
 114
 115         fl.l_pid = getpid();
 116         fl.l_type = F_UNLCK;
 117
 118         if (fcntl(cachefile, F_SETLK, &fl) == -1) {
 119                 perror("fcntl F_UNLCK F_SETLK ");
 120                 exit(1);
 121         }
 122
 123         if (verbose)
 124                 output(2, "dropped lock for cachefile\n");
 125 }
 126
 127 static void generate_sockets(void)
 128 {
 129         int fd, n;
 130         int cachefile;
 131         unsigned int nr_to_create = NR_SOCKET_FDS;
 132         unsigned int buffer[3];
 133
 134         cachefile = creat(cachefilename, S_IWUSR|S_IRUSR);
 135         if (cachefile < 0) {
 136                 outputerr("Couldn't open cachefile for writing! (%s)\n",
 137                         strerror(errno));
 138                 exit(EXIT_FAILURE);
 139         }
 140
 141         lock_cachefile(cachefile, F_WRLCK);
 142
 143         /*
 144          * Don't loop forever if all protos all are disabled.
 145          */
 146         if (!do_specific_proto) {
 147                 for (n = 0; n < (int)ARRAY_SIZE(no_protos); n++) {
 148                         if (!no_protos[n])
 149                                 break;
 150                 }
 151
 152                 if (n >= (int)ARRAY_SIZE(no_protos))
 153                         nr_to_create = 0;
 154         }
 155
 156         while (nr_to_create > 0) {
 157
 158                 struct socket_triplet st;
 159
 160                 if (shm->exit_reason != STILL_RUNNING) {
 161                         close(cachefile);
 162                         return;
 163                 }
 164
 165                 for (st.family = 0; st.family < TRINITY_PF_MAX; st.family++) {
 166
 167                         if (do_specific_proto == TRUE)
 168                                 st.family = specific_proto;
 169
 170                         if (get_proto_name(st.family) == NULL)
 171                                 goto skip;
 172
 173                         BUG_ON(st.family >= ARRAY_SIZE(no_protos));
 174                         if (no_protos[st.family])
 175                                 goto skip;
 176
 177                         if (sanitise_socket_triplet(&st) == -1)
 178                                 rand_proto_type(&st);
 179
 180                         fd = open_socket(st.family, st.type, st.protocol);
 181                         if (fd > -1) {
 182                                 nr_to_create--;
 183
 184                                 buffer[0] = st.family;
 185                                 buffer[1] = st.type;
 186                                 buffer[2] = st.protocol;
 187                                 n = write(cachefile, &buffer, sizeof(int) * 3);
 188                                 if (n == -1) {
 189                                         outputerr("something went wrong writing the cachefile!\n");
 190                                         exit(EXIT_FAILURE);
 191                                 }
 192
 193                                 if (nr_to_create == 0)
 194                                         goto done;
 195                         } else {
 196                                 //outputerr("Couldn't open family:%d (%s)\n", st.family, get_proto_name(st.family));
 197                         }
 198 skip:
 199
 200                         /* check for ctrl-c */
 201                         if (shm->exit_reason != STILL_RUNNING)
 202                                 return;
 203
 204                         //FIXME: If we've passed -P and we're spinning here without making progress
 205                         // then we should abort after a few hundred loops.
 206                 }
 207         }
 208
 209 done:
 210         unlock_cachefile(cachefile);
 211
 212         output(1, "created %d sockets\n", nr_sockets);
 213
 214         close(cachefile);
 215 }
 216
 217
 218 void close_sockets(void)
 219 {
 220         unsigned int i;
 221         int fd;
 222         int r = 0;
 223         struct linger ling = { .l_onoff = FALSE, .l_linger = 0 };
 224
 225         for (i = 0; i < nr_sockets; i++) {
 226
 227                 //FIXME: This is a workaround for a weird bug where we hang forevre
 228                 // waiting for bluetooth sockets when we setsockopt.
 229                 // Hopefully at some point we can remove this when someone figures out what's going on.
 230                 if (shm->sockets[i].triplet.family == PF_BLUETOOTH)
 231                         continue;
 232
 233                 /* Grab an fd, and nuke it before someone else uses it. */
 234                 fd = shm->sockets[i].fd;
 235                 shm->sockets[i].fd = 0;
 236
 237                 /* disable linger */
 238                 r = setsockopt(fd, SOL_SOCKET, SO_LINGER, &ling, sizeof(struct linger));
 239                 if (r)
 240                         perror("setsockopt");
 241
 242                 r = shutdown(fd, SHUT_RDWR);
 243                 if (r)
 244                         perror("shutdown");
 245
 246                 if (close(fd) != 0)
 247                         output(1, "failed to close socket [%d:%d:%d].(%s)\n",
 248                                 shm->sockets[i].triplet.family,
 249                                 shm->sockets[i].triplet.type,
 250                                 shm->sockets[i].triplet.protocol,
 251                                 strerror(errno));
 252         }
 253
 254         nr_sockets = 0;
 255 }
 256
 257 void open_sockets(void)
 258 {
 259         int cachefile;
 260         unsigned int domain, type, protocol;
 261         unsigned int buffer[3];
 262         int bytesread=-1;
 263         int fd;
 264
 265         cachefile = open(cachefilename, O_RDONLY);
 266         if (cachefile < 0) {
 267                 output(1, "Couldn't find socket cachefile. Regenerating.\n");
 268                 generate_sockets();
 269                 return;
 270         }
 271
 272         lock_cachefile(cachefile, F_RDLCK);
 273
 274         while (bytesread != 0) {
 275                 bytesread = read(cachefile, buffer, sizeof(int) * 3);
 276                 if (bytesread == 0)
 277                         break;
 278
 279                 domain = buffer[0];
 280                 type = buffer[1];
 281                 protocol = buffer[2];
 282
 283                 if ((do_specific_proto == TRUE && domain != specific_proto) ||
 284                     (domain < ARRAY_SIZE(no_protos) && no_protos[domain] == TRUE)) {
 285                         output(1, "ignoring socket cachefile due to specific "
 286                                "protocol request (or protocol disabled), "
 287                                "and stale data in cachefile.\n");
 288 regenerate:
 289                                 unlock_cachefile(cachefile);    /* drop the reader lock. */
 290                                 close(cachefile);
 291                                 unlink(cachefilename);
 292                                 generate_sockets();
 293                                 return;
 294                 }
 295
 296                 fd = open_socket(domain, type, protocol);
 297                 if (fd < 0) {
 298                         output(1, "Cachefile is stale. Need to regenerate.\n");
 299                         close_sockets();
 300                         goto regenerate;
 301                 }
 302
 303                 /* check for ctrl-c */
 304                 if (shm->exit_reason != STILL_RUNNING) {
 305                         close(cachefile);
 306                         return;
 307                 }
 308         }
 309
 310         if (nr_sockets < NR_SOCKET_FDS) {
 311                 output(1, "Insufficient sockets in cachefile (%d). Regenerating.\n", nr_sockets);
 312                 goto regenerate;
 313         }
 314
 315         output(1, "%d sockets created based on info from socket cachefile.\n", nr_sockets);
 316
 317         unlock_cachefile(cachefile);
 318         close(cachefile);
 319 }
 320