lib/lws-plat-unix.c

   1 #include "private-libwebsockets.h"
   2
   3 /*
   4  * included from libwebsockets.c for unix builds
   5  */
   6
   7 unsigned long long time_in_microseconds(void)
   8 {
   9         struct timeval tv;
  10         gettimeofday(&tv, NULL);
  11         return (tv.tv_sec * 1000000) + tv.tv_usec;
  12 }
  13
  14 LWS_VISIBLE int libwebsockets_get_random(struct libwebsocket_context *context,
  15                                                              void *buf, int len)
  16 {
  17         return read(context->fd_random, (char *)buf, len);
  18 }
  19
  20 LWS_VISIBLE int lws_send_pipe_choked(struct libwebsocket *wsi)
  21 {
  22         struct libwebsocket_pollfd fds;
  23
  24         /* treat the fact we got a truncated send pending as if we're choked */
  25         if (wsi->truncated_send_len)
  26                 return 1;
  27
  28         fds.fd = wsi->sock;
  29         fds.events = POLLOUT;
  30         fds.revents = 0;
  31
  32         if (poll(&fds, 1, 0) != 1)
  33                 return 1;
  34
  35         if ((fds.revents & POLLOUT) == 0)
  36                 return 1;
  37
  38         /* okay to send another packet without blocking */
  39
  40         return 0;
  41 }
  42
  43 LWS_VISIBLE int
  44 lws_poll_listen_fd(struct libwebsocket_pollfd *fd)
  45 {
  46         return poll(fd, 1, 0);
  47 }
  48
  49 /*
  50  * This is just used to interrupt poll waiting
  51  * we don't have to do anything with it.
  52  */
  53 static void lws_sigusr2(int sig)
  54 {
  55 }
  56
  57 /**
  58  * libwebsocket_cancel_service() - Cancel servicing of pending websocket activity
  59  * @context:    Websocket context
  60  *
  61  *      This function let a call to libwebsocket_service() waiting for a timeout
  62  *      immediately return.
  63  */
  64 LWS_VISIBLE void
  65 libwebsocket_cancel_service(struct libwebsocket_context *context)
  66 {
  67         char buf = 0;
  68
  69         if (write(context->dummy_pipe_fds[1], &buf, sizeof(buf)) != 1)
  70                 lwsl_err("Cannot write to dummy pipe");
  71 }
  72
  73 LWS_VISIBLE void lwsl_emit_syslog(int level, const char *line)
  74 {
  75         int syslog_level = LOG_DEBUG;
  76
  77         switch (level) {
  78         case LLL_ERR:
  79                 syslog_level = LOG_ERR;
  80                 break;
  81         case LLL_WARN:
  82                 syslog_level = LOG_WARNING;
  83                 break;
  84         case LLL_NOTICE:
  85                 syslog_level = LOG_NOTICE;
  86                 break;
  87         case LLL_INFO:
  88                 syslog_level = LOG_INFO;
  89                 break;
  90         }
  91         syslog(syslog_level, "%s", line);
  92 }
  93
  94 LWS_VISIBLE int
  95 lws_plat_service(struct libwebsocket_context *context, int timeout_ms)
  96 {
  97         int n;
  98         int m;
  99         char buf;
 100
 101         /* stay dead once we are dead */
 102
 103         if (!context)
 104                 return 1;
 105
 106         lws_libev_run(context);
 107
 108         context->service_tid = context->protocols[0].callback(context, NULL,
 109                                      LWS_CALLBACK_GET_THREAD_ID, NULL, NULL, 0);
 110
 111         n = poll(context->fds, context->fds_count, timeout_ms);
 112         context->service_tid = 0;
 113
 114         if (n == 0) /* poll timeout */ {
 115                 libwebsocket_service_fd(context, NULL);
 116                 return 0;
 117         }
 118
 119         if (n < 0) {
 120                 if (LWS_ERRNO != LWS_EINTR)
 121                         return -1;
 122                 return 0;
 123         }
 124
 125         /* any socket with events to service? */
 126
 127         for (n = 0; n < context->fds_count; n++) {
 128                 if (!context->fds[n].revents)
 129                         continue;
 130
 131                 if (context->fds[n].fd == context->dummy_pipe_fds[0]) {
 132                         if (read(context->fds[n].fd, &buf, 1) != 1)
 133                                 lwsl_err("Cannot read from dummy pipe.");
 134                         continue;
 135                 }
 136
 137                 m = libwebsocket_service_fd(context, &context->fds[n]);
 138                 if (m < 0)
 139                         return -1;
 140                 /* if something closed, retry this slot */
 141                 if (m)
 142                         n--;
 143         }
 144
 145         return 0;
 146 }
 147
 148 LWS_VISIBLE int
 149 lws_plat_set_socket_options(struct libwebsocket_context *context, int fd)
 150 {
 151         int optval = 1;
 152         socklen_t optlen = sizeof(optval);
 153
 154 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
 155     defined(__OpenBSD__)
 156         struct protoent *tcp_proto;
 157 #endif
 158
 159         if (context->ka_time) {
 160                 /* enable keepalive on this socket */
 161                 optval = 1;
 162                 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE,
 163                                              (const void *)&optval, optlen) < 0)
 164                         return 1;
 165
 166 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
 167         defined(__CYGWIN__) || defined(__OpenBSD__)
 168
 169                 /*
 170                  * didn't find a way to set these per-socket, need to
 171                  * tune kernel systemwide values
 172                  */
 173 #else
 174                 /* set the keepalive conditions we want on it too */
 175                 optval = context->ka_time;
 176                 if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE,
 177                                              (const void *)&optval, optlen) < 0)
 178                         return 1;
 179
 180                 optval = context->ka_interval;
 181                 if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL,
 182                                              (const void *)&optval, optlen) < 0)
 183                         return 1;
 184
 185                 optval = context->ka_probes;
 186                 if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT,
 187                                              (const void *)&optval, optlen) < 0)
 188                         return 1;
 189 #endif
 190         }
 191
 192         /* Disable Nagle */
 193         optval = 1;
 194 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \
 195     !defined(__OpenBSD__)
 196         setsockopt(fd, SOL_TCP, TCP_NODELAY, (const void *)&optval, optlen);
 197 #else
 198         tcp_proto = getprotobyname("TCP");
 199         setsockopt(fd, tcp_proto->p_proto, TCP_NODELAY, &optval, optlen);
 200 #endif
 201
 202         /* We are nonblocking... */
 203         fcntl(fd, F_SETFL, O_NONBLOCK);
 204
 205         return 0;
 206 }
 207
 208 LWS_VISIBLE void
 209 lws_plat_drop_app_privileges(struct lws_context_creation_info *info)
 210 {
 211         if (info->gid != -1)
 212                 if (setgid(info->gid))
 213                         lwsl_warn("setgid: %s\n", strerror(LWS_ERRNO));
 214         if (info->uid != -1)
 215                 if (setuid(info->uid))
 216                         lwsl_warn("setuid: %s\n", strerror(LWS_ERRNO));
 217 }
 218
 219 LWS_VISIBLE int
 220 lws_plat_init_fd_tables(struct libwebsocket_context *context)
 221 {
 222         if (lws_libev_init_fd_table(context))
 223                 /* libev handled it instead */
 224                 return 0;
 225
 226         if (pipe(context->dummy_pipe_fds)) {
 227                 lwsl_err("Unable to create pipe\n");
 228                 return 1;
 229         }
 230
 231         /* use the read end of pipe as first item */
 232         context->fds[0].fd = context->dummy_pipe_fds[0];
 233         context->fds[0].events = LWS_POLLIN;
 234         context->fds[0].revents = 0;
 235         context->fds_count = 1;
 236
 237         context->fd_random = open(SYSTEM_RANDOM_FILEPATH, O_RDONLY);
 238         if (context->fd_random < 0) {
 239                 lwsl_err("Unable to open random device %s %d\n",
 240                                     SYSTEM_RANDOM_FILEPATH, context->fd_random);
 241                 return 1;
 242         }
 243
 244         return 0;
 245 }
 246
 247 static void sigpipe_handler(int x)
 248 {
 249 }
 250
 251
 252 LWS_VISIBLE int
 253 lws_plat_context_early_init(void)
 254 {
 255         sigset_t mask;
 256
 257         signal(SIGUSR2, lws_sigusr2);
 258         sigemptyset(&mask);
 259         sigaddset(&mask, SIGUSR2);
 260
 261         sigprocmask(SIG_BLOCK, &mask, NULL);
 262
 263         signal(SIGPIPE, sigpipe_handler);
 264
 265         return 0;
 266 }
 267
 268 LWS_VISIBLE void
 269 lws_plat_context_early_destroy(struct libwebsocket_context *context)
 270 {
 271 }
 272
 273 LWS_VISIBLE void
 274 lws_plat_context_late_destroy(struct libwebsocket_context *context)
 275 {
 276         close(context->dummy_pipe_fds[0]);
 277         close(context->dummy_pipe_fds[1]);
 278         close(context->fd_random);
 279 }
 280
 281 /* cast a struct sockaddr_in6 * into addr for ipv6 */
 282
 283 LWS_VISIBLE int
 284 interface_to_sa(struct libwebsocket_context *context,
 285                 const char *ifname, struct sockaddr_in *addr, size_t addrlen)
 286 {
 287         int rc = -1;
 288
 289         struct ifaddrs *ifr;
 290         struct ifaddrs *ifc;
 291 #ifdef LWS_USE_IPV6
 292         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
 293 #endif
 294
 295         getifaddrs(&ifr);
 296         for (ifc = ifr; ifc != NULL && rc; ifc = ifc->ifa_next) {
 297                 if (!ifc->ifa_addr)
 298                         continue;
 299
 300                 lwsl_info(" interface %s vs %s\n", ifc->ifa_name, ifname);
 301
 302                 if (strcmp(ifc->ifa_name, ifname))
 303                         continue;
 304
 305                 switch (ifc->ifa_addr->sa_family) {
 306                 case AF_INET:
 307 #ifdef LWS_USE_IPV6
 308                         if (LWS_IPV6_ENABLED(context)) {
 309                                 /* map IPv4 to IPv6 */
 310                                 bzero((char *)&addr6->sin6_addr,
 311                                                 sizeof(struct in6_addr));
 312                                 addr6->sin6_addr.s6_addr[10] = 0xff;
 313                                 addr6->sin6_addr.s6_addr[11] = 0xff;
 314                                 memcpy(&addr6->sin6_addr.s6_addr[12],
 315                                         &((struct sockaddr_in *)ifc->ifa_addr)->sin_addr,
 316                                                         sizeof(struct in_addr));
 317                         } else
 318 #endif
 319                                 memcpy(addr,
 320                                         (struct sockaddr_in *)ifc->ifa_addr,
 321                                                     sizeof(struct sockaddr_in));
 322                         break;
 323 #ifdef LWS_USE_IPV6
 324                 case AF_INET6:
 325                         if (rc >= 0)
 326                                 break;
 327                         memcpy(&addr6->sin6_addr,
 328                           &((struct sockaddr_in6 *)ifc->ifa_addr)->sin6_addr,
 329                                                        sizeof(struct in6_addr));
 330                         break;
 331 #endif
 332                 default:
 333                         continue;
 334                 }
 335                 rc = 0;
 336         }
 337
 338         freeifaddrs(ifr);
 339
 340         if (rc == -1) {
 341                 /* check if bind to IP adddress */
 342 #ifdef LWS_USE_IPV6
 343                 if (inet_pton(AF_INET6, ifname, &addr6->sin6_addr) == 1)
 344                         rc = 0;
 345                 else
 346 #endif
 347                 if (inet_pton(AF_INET, ifname, &addr->sin_addr) == 1)
 348                         rc = 0;
 349         }
 350
 351         return rc;
 352 }
 353
 354 LWS_VISIBLE void
 355 lws_plat_insert_socket_into_fds(struct libwebsocket_context *context,
 356                                                        struct libwebsocket *wsi)
 357 {
 358         lws_libev_io(context, wsi, LWS_EV_START | LWS_EV_READ);
 359         context->fds[context->fds_count++].revents = 0;
 360 }
 361
 362 LWS_VISIBLE void
 363 lws_plat_delete_socket_from_fds(struct libwebsocket_context *context,
 364                                                 struct libwebsocket *wsi, int m)
 365 {
 366 }
 367
 368 LWS_VISIBLE void
 369 lws_plat_service_periodic(struct libwebsocket_context *context)
 370 {
 371         /* if our parent went down, don't linger around */
 372         if (context->started_with_parent &&
 373                               kill(context->started_with_parent, 0) < 0)
 374                 kill(getpid(), SIGTERM);
 375 }
 376
 377 LWS_VISIBLE int
 378 lws_plat_change_pollfd(struct libwebsocket_context *context,
 379                       struct libwebsocket *wsi, struct libwebsocket_pollfd *pfd)
 380 {
 381         return 0;
 382 }
 383
 384 LWS_VISIBLE int
 385 lws_plat_open_file(const char* filename, unsigned long* filelen)
 386 {
 387         struct stat stat_buf;
 388         int ret = open(filename, O_RDONLY);
 389
 390         if (ret < 0)
 391                 return LWS_INVALID_FILE;
 392
 393         fstat(ret, &stat_buf);
 394         *filelen = stat_buf.st_size;
 395         return ret;
 396 }
 397
 398 #ifdef LWS_USE_IPV6
 399 LWS_VISIBLE const char *
 400 lws_plat_inet_ntop(int af, const void *src, char *dst, int cnt)
 401 {
 402         return inet_ntop(af, src, dst, cnt);
 403 }
 404 #endif