libs/nixio/src/bind.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 <lua.h>
  20 #include <lualib.h>
  21 #include <lauxlib.h>
  22 #include <sys/types.h>
  23 #include <sys/socket.h>
  24 #include <arpa/inet.h>
  25 #include <sys/un.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <netdb.h>
  29 #include "nixio.h"
  30
  31 /**
  32  * connect()/bind() shortcut
  33  */
  34 static int nixio__bind_connect(lua_State *L, int do_bind) {
  35         const char *host = NULL;
  36         if (!lua_isnoneornil(L, 1)) {
  37                 host = luaL_checklstring(L, 1, NULL);
  38         }
  39         const char *port = luaL_checklstring(L, 2, NULL);
  40         const char *family = luaL_optlstring(L, 3, "any", NULL);
  41         const char *socktype = luaL_optlstring(L, 4, "stream", NULL);
  42
  43         struct addrinfo hints, *result, *rp;
  44         memset(&hints, 0, sizeof(hints));
  45
  46         if (!strcmp(family, "any")) {
  47                 hints.ai_family = AF_UNSPEC;
  48         } else if (!strcmp(family, "inet")) {
  49                 hints.ai_family = AF_INET;
  50         } else if (!strcmp(family, "inet6")) {
  51                 hints.ai_family = AF_INET6;
  52         } else {
  53                 return luaL_argerror(L, 3, "supported values: any, inet, inet6");
  54         }
  55
  56         if (!strcmp(socktype, "any")) {
  57                 hints.ai_socktype = 0;
  58         } else if (!strcmp(socktype, "stream")) {
  59                 hints.ai_socktype = SOCK_STREAM;
  60         } else if (!strcmp(socktype, "dgram")) {
  61                 hints.ai_socktype = SOCK_DGRAM;
  62         } else {
  63                 return luaL_argerror(L, 4, "supported values: any, stream, dgram");
  64         }
  65
  66         if (do_bind) {
  67                 hints.ai_flags |= AI_PASSIVE;
  68         }
  69
  70         hints.ai_protocol = 0;
  71
  72         int aistat = getaddrinfo(host, port, &hints, &result);
  73         if (aistat) {
  74                 lua_pushnil(L);
  75                 lua_pushinteger(L, aistat);
  76                 lua_pushstring(L, gai_strerror(aistat));
  77                 return 3;
  78         }
  79
  80         /* create socket object */
  81         nixio_sock *sock = lua_newuserdata(L, sizeof(nixio_sock));
  82         int status = -1;
  83
  84         for (rp = result; rp != NULL; rp = rp->ai_next) {
  85                 sock->fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
  86                 if (sock->fd == -1) {
  87                         continue;
  88                 }
  89
  90                 if (do_bind) {
  91                         status = bind(sock->fd, rp->ai_addr, rp->ai_addrlen);
  92                 } else {
  93                         status = connect(sock->fd, rp->ai_addr, rp->ai_addrlen);
  94                 }
  95
  96                 /* on success */
  97                 if (!status) {
  98                         sock->domain = rp->ai_family;
  99                         sock->type = rp->ai_socktype;
 100                         sock->protocol = rp->ai_protocol;
 101                         break;
 102                 }
 103
 104                 close(sock->fd);
 105         }
 106
 107         freeaddrinfo(result);
 108
 109         /* on failure */
 110         if (status) {
 111                 return nixio__perror(L);
 112         }
 113
 114         luaL_getmetatable(L, NIXIO_META);
 115         lua_setmetatable(L, -2);
 116
 117         return 1;
 118 }
 119
 120 /**
 121  * bind(host, port, [family=any], [type=any]) shortcut
 122  */
 123 static int nixio_bind(lua_State *L) {
 124         return nixio__bind_connect(L, 1);
 125 }
 126
 127 /**
 128  * connect(host, port, [family=any], [type=any]) shortcut
 129  */
 130 static int nixio_connect(lua_State *L) {
 131         return nixio__bind_connect(L, 0);
 132 }
 133
 134 /**
 135  * bind()/connect() helper
 136  */
 137 static int nixio_sock__bind_connect(lua_State *L, int do_bind) {
 138         nixio_sock *sock = nixio__checksock(L);
 139         int status = -1;
 140
 141         if (sock->domain == AF_INET || sock->domain == AF_INET6) {
 142                 const char *host = NULL;
 143                 if (!lua_isnoneornil(L, 2)) {
 144                         host = luaL_checklstring(L, 2, NULL);
 145                 }
 146                 const char *port = luaL_checklstring(L, 3, NULL);
 147
 148                 struct addrinfo hints, *result, *rp;
 149
 150                 memset(&hints, 0, sizeof(hints));
 151                 hints.ai_family = sock->domain;
 152                 hints.ai_socktype = sock->type;
 153                 hints.ai_protocol = sock->protocol;
 154
 155                 if (do_bind) {
 156                         hints.ai_flags |= AI_PASSIVE;
 157                 }
 158
 159                 int aistat = getaddrinfo(host, port, &hints, &result);
 160                 if (aistat) {
 161                         lua_pushnil(L);
 162                         lua_pushinteger(L, aistat);
 163                         lua_pushstring(L, gai_strerror(aistat));
 164                         return 3;
 165                 }
 166
 167                 for (rp = result; rp != NULL; rp = rp->ai_next) {
 168                         if (do_bind) {
 169                                 status = bind(sock->fd, rp->ai_addr, rp->ai_addrlen);
 170                         } else {
 171                                 status = connect(sock->fd, rp->ai_addr, rp->ai_addrlen);
 172                         }
 173
 174                         /* on success */
 175                         if (!status) {
 176                                 break;
 177                         }
 178                 }
 179
 180                 freeaddrinfo(result);
 181         } else if (sock->domain == AF_UNIX) {
 182                 size_t pathlen;
 183                 const char *path = luaL_checklstring(L, 2, &pathlen);
 184
 185                 struct sockaddr_un addr;
 186                 addr.sun_family = AF_UNIX;
 187                 luaL_argcheck(L, pathlen < sizeof(addr.sun_path), 2, "out of range");
 188                 strncpy(addr.sun_path, path, sizeof(addr.sun_path));
 189
 190                 if (do_bind) {
 191                         status = bind(sock->fd, (struct sockaddr*)&addr, sizeof(addr));
 192                 } else {
 193                         status = connect(sock->fd, (struct sockaddr*)&addr, sizeof(addr));
 194                 }
 195         } else {
 196                 return luaL_error(L, "not supported");
 197         }
 198         return nixio__pstatus(L, !status);
 199 }
 200
 201 /**
 202  * bind()
 203  */
 204 static int nixio_sock_bind(lua_State *L) {
 205         return nixio_sock__bind_connect(L, 1);
 206 }
 207
 208 /**
 209  * connect()
 210  */
 211 static int nixio_sock_connect(lua_State *L) {
 212         return nixio_sock__bind_connect(L, 0);
 213 }
 214
 215 /**
 216  * listen()
 217  */
 218 static int nixio_sock_listen(lua_State *L) {
 219         int sockfd = nixio__checksockfd(L);
 220         lua_Integer backlog = luaL_checkinteger(L, 2);
 221         return nixio__pstatus(L, !listen(sockfd, backlog));
 222 }
 223
 224 /**
 225  * accept()
 226  */
 227 static int nixio_sock_accept(lua_State *L) {
 228         nixio_sock *sock = nixio__checksock(L);
 229         struct sockaddr_storage addr;
 230         socklen_t addrlen = sizeof(addr);
 231         char ipaddr[INET6_ADDRSTRLEN];
 232         void *binaddr;
 233         uint16_t port;
 234
 235         int newfd = accept(sock->fd, (struct sockaddr *)&addr, &addrlen);
 236         if (newfd < 0) {
 237                 return nixio__perror(L);
 238         }
 239
 240         /* create userdata */
 241         nixio_sock *clsock = lua_newuserdata(L, sizeof(nixio_sock));
 242         luaL_getmetatable(L, NIXIO_META);
 243         lua_setmetatable(L, -2);
 244
 245         memcpy(clsock, sock, sizeof(clsock));
 246         clsock->fd = newfd;
 247
 248         if (addr.ss_family == AF_INET) {
 249                 struct sockaddr_in *inetaddr = (struct sockaddr_in*)&addr;
 250                 port = inetaddr->sin_port;
 251                 binaddr = &inetaddr->sin_addr;
 252         } else if (addr.ss_family == AF_INET6) {
 253                 struct sockaddr_in6 *inet6addr = (struct sockaddr_in6*)&addr;
 254                 port = inet6addr->sin6_port;
 255                 binaddr = &inet6addr->sin6_addr;
 256         } else {
 257                 return luaL_error(L, "unknown address family");
 258         }
 259
 260         if (!inet_ntop(addr.ss_family, binaddr, ipaddr, sizeof(ipaddr))) {
 261                 return nixio__perror(L);
 262         }
 263
 264         lua_pushstring(L, ipaddr);
 265         lua_pushinteger(L, ntohs(port));
 266         return 3;
 267 }
 268
 269 /* module table */
 270 static const luaL_reg R[] = {
 271         {"bind",                nixio_bind},
 272         {"connect",             nixio_connect},
 273         {NULL,                  NULL}
 274 };
 275
 276 /* object table */
 277 static const luaL_reg M[] = {
 278         {"bind",                nixio_sock_bind},
 279         {"connect",             nixio_sock_connect},
 280         {"listen",              nixio_sock_listen},
 281         {"accept",              nixio_sock_accept},
 282         {NULL,                  NULL}
 283 };
 284
 285 void nixio_open_bind(lua_State *L) {
 286         luaL_register(L, NULL, R);
 287
 288         lua_pushvalue(L, -2);
 289         luaL_register(L, NULL, M);
 290         lua_pop(L, 1);
 291 }