libs/nixio/src/poll.c

   1 /*
   2  * nixio - Linux I/O library for lua
   3  *
   4  *   Copyright (C) 2009 Steven Barth <steven@midlink.org>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License.
  17  */
  18
  19 #include "nixio.h"
  20 #include <poll.h>
  21 #include <time.h>
  22 #include <errno.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include "nixio.h"
  26
  27
  28 /**
  29  * nanosleep()
  30  */
  31 static int nixio_nanosleep(lua_State *L) {
  32         struct timespec req, rem;
  33         req.tv_sec = luaL_optint(L, 1, 0);
  34         req.tv_nsec = luaL_optint(L, 2, 0);
  35
  36         int status = nanosleep(&req, &rem);
  37         if (!status) {
  38                 lua_pushboolean(L, 1);
  39                 return 1;
  40         } else {
  41                 if (errno == EINTR) {
  42                         lua_pushboolean(L, 0);
  43                         lua_pushinteger(L, rem.tv_sec);
  44                         lua_pushinteger(L, rem.tv_nsec);
  45                         return 3;
  46                 } else {
  47                         return nixio__perror(L);
  48                 }
  49         }
  50 }
  51
  52 /**
  53  * Checks whether a flag is set in the bitmap and sets the matching table value
  54  */
  55 static void nixio_poll_flags__r(lua_State *L, int *map, int f, const char *t) {
  56         lua_pushstring(L, t);
  57         if (*map & f) {
  58                 lua_pushboolean(L, 1);
  59         } else {
  60                 lua_pushnil(L);
  61         }
  62         lua_rawset(L, -3);
  63 }
  64
  65 /**
  66  * Translate integer to poll flags and vice versa
  67  */
  68 static int nixio_poll_flags(lua_State *L) {
  69         int flags;
  70         if (lua_isnumber(L, 1)) {
  71                 flags = luaL_checkinteger(L, 1);
  72                 lua_newtable(L);
  73                 nixio_poll_flags__r(L, &flags, POLLIN, "in");
  74                 nixio_poll_flags__r(L, &flags, POLLPRI, "pri");
  75                 nixio_poll_flags__r(L, &flags, POLLOUT, "out");
  76                 nixio_poll_flags__r(L, &flags, POLLERR, "err");
  77                 nixio_poll_flags__r(L, &flags, POLLHUP, "hup");
  78                 nixio_poll_flags__r(L, &flags, POLLNVAL, "nval");
  79          } else {
  80                 flags = 0;
  81                 const int j = lua_gettop(L);
  82                 for (int i=1; i<=j; i++) {
  83                         const char *flag = luaL_checkstring(L, i);
  84                         if (!strcmp(flag, "in")) {
  85                                 flags |= POLLIN;
  86                         } else if (!strcmp(flag, "pri")) {
  87                                 flags |= POLLPRI;
  88                         } else if (!strcmp(flag, "out")) {
  89                                 flags |= POLLOUT;
  90                         } else if (!strcmp(flag, "err")) {
  91                                 flags |= POLLERR;
  92                         } else if (!strcmp(flag, "hup")) {
  93                                 flags |= POLLHUP;
  94                         } else if (!strcmp(flag, "nval")) {
  95                                 flags |= POLLNVAL;
  96                         } else {
  97                                 return luaL_argerror(L, i,
  98                                  "supported values: in, pri, out, err, hup, nval");
  99                         }
 100                 }
 101                 lua_pushinteger(L, flags);
 102         }
 103         return 1;
 104 }
 105
 106 /**
 107  * poll({{fd = socket, events = FLAGS}, ...}, timeout)
 108  */
 109 static int nixio_poll(lua_State *L) {
 110         int len = lua_objlen(L, 1);
 111         int i, fd;
 112         int timeout = luaL_optint(L, 2, 0);
 113         int status = -1;
 114
 115         /* we are being abused as sleep() replacement... */
 116         if (lua_isnoneornil(L, 1) || len < 1) {
 117                 return nixio__pstatus(L, !poll(NULL, 0, timeout));
 118         }
 119
 120         luaL_checktype(L, 1, LUA_TTABLE);
 121         struct pollfd *fds = calloc(len, sizeof(struct pollfd));
 122
 123         for (i = 0; i < len; i++) {
 124                 lua_rawgeti(L, 1, i+1);
 125                 if (!lua_istable(L, -1)) {
 126                         free(fds);
 127                         return luaL_argerror(L, 1, "invalid datastructure");
 128                 }
 129
 130                 lua_pushliteral(L, "fd");
 131                 lua_rawget(L, -2);
 132                 fd = nixio__tofd(L, -1);
 133                 if (fd == -1) {
 134                         free(fds);
 135                         return luaL_argerror(L, 1, "invalid fd in datastructure");
 136                 }
 137                 fds[i].fd = fd;
 138
 139                 lua_pushliteral(L, "events");
 140                 lua_rawget(L, -3);
 141                 fds[i].events = (short)lua_tointeger(L, -1);
 142
 143                 lua_pop(L, 3);
 144         }
 145
 146         status = poll(fds, (nfds_t)len, timeout);
 147
 148         if (status < 1) {
 149                 free(fds);
 150                 return nixio__perror(L);
 151         }
 152
 153         for (i = 0; i < len; i++) {
 154                 lua_rawgeti(L, 1, i+1);
 155
 156                 lua_pushliteral(L, "revents");
 157                 lua_pushinteger(L, fds[i].revents);
 158                 lua_rawset(L, -3);
 159
 160                 lua_pop(L, 1);
 161         }
 162
 163         free(fds);
 164
 165         lua_pushinteger(L, status);
 166         lua_pushvalue(L, 1);
 167
 168         return 2;
 169 }
 170
 171 /* module table */
 172 static const luaL_reg R[] = {
 173         {"nanosleep",   nixio_nanosleep},
 174         {"poll",                nixio_poll},
 175         {"poll_flags",  nixio_poll_flags},
 176         {NULL,                  NULL}
 177 };
 178
 179 void nixio_open_poll(lua_State *L) {
 180         luaL_register(L, NULL, R);
 181 }