flm01/mote/v2/openwrt/package/luci/libs/nixio/src/tls-socket.c

264 lines
6.2 KiB
C
Raw Normal View History

/*
* nixio - Linux I/O library for lua
*
* Copyright (C) 2009 Steven Barth <steven@midlink.org>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "nixio-tls.h"
#include <string.h>
#include <stdlib.h>
static int nixio__tls_sock_perror(lua_State *L, SSL *sock, int code) {
lua_pushnil(L);
lua_pushinteger(L, SSL_get_error(sock, code));
return 2;
}
static int nixio__tls_sock_pstatus(lua_State *L, SSL *sock, int code) {
if (code > 0) {
lua_pushboolean(L, 1);
return 1;
} else {
return nixio__tls_sock_perror(L, sock, code);
}
}
static SSL* nixio__checktlssock(lua_State *L) {
if (lua_istable(L, 1)) {
lua_getfield(L, 1, "connection");
lua_replace(L, 1);
}
nixio_tls_sock *sock = luaL_checkudata(L, 1, NIXIO_TLS_SOCK_META);
luaL_argcheck(L, sock->socket, 1, "invalid context");
return sock->socket;
}
#ifndef WITH_AXTLS
#define nixio_tls__check_connected(L) ;
#define nixio_tls__set_connected(L, val) ;
#else
#define nixio_tls__check_connected(L) \
nixio_tls_sock *ctsock = luaL_checkudata(L, 1, NIXIO_TLS_SOCK_META); \
if (!ctsock->connected) { \
lua_pushnil(L); \
lua_pushinteger(L, 1); \
return 2; \
}
#define nixio_tls__set_connected(L, val) \
((nixio_tls_sock*)luaL_checkudata(L, 1, NIXIO_TLS_SOCK_META))->connected = val;
#endif /* WITH_AXTLS */
static int nixio_tls_sock_recv(lua_State *L) {
SSL *sock = nixio__checktlssock(L);
nixio_tls__check_connected(L);
uint req = luaL_checkinteger(L, 2);
luaL_argcheck(L, req >= 0, 2, "out of range");
/* We limit the readsize to NIXIO_BUFFERSIZE */
req = (req > NIXIO_BUFFERSIZE) ? NIXIO_BUFFERSIZE : req;
#ifndef WITH_AXTLS
char buffer[NIXIO_BUFFERSIZE];
int readc = SSL_read(sock, buffer, req);
if (readc < 0) {
return nixio__tls_sock_pstatus(L, sock, readc);
} else {
lua_pushlstring(L, buffer, readc);
return 1;
}
#else
if (!req) {
lua_pushliteral(L, "");
return 1;
}
nixio_tls_sock *t = lua_touserdata(L, 1);
/* AXTLS doesn't handle buffering for us, so we have to hack around*/
if (req < t->pbufsiz) {
lua_pushlstring(L, t->pbufpos, req);
t->pbufpos += req;
t->pbufsiz -= req;
return 1;
} else {
uint8_t *axbuf;
int axread;
/* while handshake pending */
while ((axread = ssl_read(sock, &axbuf)) == SSL_OK);
if (t->pbufsiz) {
lua_pushlstring(L, t->pbufpos, t->pbufsiz);
}
if (axread < 0) {
/* There is an error */
free(t->pbuffer);
t->pbuffer = t->pbufpos = NULL;
if (axread != SSL_ERROR_CONN_LOST) {
t->pbufsiz = 0;
return nixio__tls_sock_perror(L, sock, axread);
} else {
if (!t->pbufsiz) {
lua_pushliteral(L, "");
} else {
t->pbufsiz = 0;
}
}
} else {
int stillwant = req - t->pbufsiz;
if (stillwant < axread) {
/* we got more data than we need */
lua_pushlstring(L, (char *)axbuf, stillwant);
if(t->pbufsiz) {
lua_concat(L, 2);
}
/* remaining data goes into the buffer */
t->pbufpos = t->pbuffer;
t->pbufsiz = axread - stillwant;
t->pbuffer = realloc(t->pbuffer, t->pbufsiz);
if (!t->pbuffer) {
free(t->pbufpos);
t->pbufpos = NULL;
t->pbufsiz = 0;
return luaL_error(L, "out of memory");
}
t->pbufpos = t->pbuffer;
memcpy(t->pbufpos, axbuf + stillwant, t->pbufsiz);
} else {
lua_pushlstring(L, (char *)axbuf, axread);
if(t->pbufsiz) {
lua_concat(L, 2);
}
/* free buffer */
free(t->pbuffer);
t->pbuffer = t->pbufpos = NULL;
t->pbufsiz = 0;
}
}
return 1;
}
#endif /* WITH_AXTLS */
}
static int nixio_tls_sock_send(lua_State *L) {
SSL *sock = nixio__checktlssock(L);
nixio_tls__check_connected(L);
size_t len;
ssize_t sent;
const char *data = luaL_checklstring(L, 2, &len);
if (lua_gettop(L) > 2) {
int offset = luaL_optint(L, 3, 0);
if (offset) {
if (offset < len) {
data += offset;
len -= offset;
} else {
len = 0;
}
}
unsigned int wlen = luaL_optint(L, 4, len);
if (wlen < len) {
len = wlen;
}
}
sent = SSL_write(sock, data, len);
if (sent > 0) {
lua_pushinteger(L, sent);
return 1;
} else {
return nixio__tls_sock_pstatus(L, sock, sent);
}
}
static int nixio_tls_sock_accept(lua_State *L) {
SSL *sock = nixio__checktlssock(L);
const int stat = SSL_accept(sock);
nixio_tls__set_connected(L, stat == 1);
return nixio__tls_sock_pstatus(L, sock, stat);
}
static int nixio_tls_sock_connect(lua_State *L) {
SSL *sock = nixio__checktlssock(L);
const int stat = SSL_connect(sock);
nixio_tls__set_connected(L, stat == 1);
return nixio__tls_sock_pstatus(L, sock, stat);
}
static int nixio_tls_sock_shutdown(lua_State *L) {
SSL *sock = nixio__checktlssock(L);
nixio_tls__set_connected(L, 0);
return nixio__tls_sock_pstatus(L, sock, SSL_shutdown(sock));
}
static int nixio_tls_sock__gc(lua_State *L) {
nixio_tls_sock *sock = luaL_checkudata(L, 1, NIXIO_TLS_SOCK_META);
if (sock->socket) {
SSL_free(sock->socket);
sock->socket = NULL;
#ifdef WITH_AXTLS
free(sock->pbuffer);
#endif
}
return 0;
}
static int nixio_tls_sock__tostring(lua_State *L) {
SSL *sock = nixio__checktlssock(L);
lua_pushfstring(L, "nixio TLS connection: %p", sock);
return 1;
}
/* ctx function table */
static const luaL_reg M[] = {
{"recv", nixio_tls_sock_recv},
{"send", nixio_tls_sock_send},
{"read", nixio_tls_sock_recv},
{"write", nixio_tls_sock_send},
{"accept", nixio_tls_sock_accept},
{"connect", nixio_tls_sock_connect},
{"shutdown", nixio_tls_sock_shutdown},
{"__gc", nixio_tls_sock__gc},
{"__tostring", nixio_tls_sock__tostring},
{NULL, NULL}
};
void nixio_open_tls_socket(lua_State *L) {
/* create socket metatable */
luaL_newmetatable(L, NIXIO_TLS_SOCK_META);
luaL_register(L, NULL, M);
lua_pushvalue(L, -1);
lua_setfield(L, -2, "__index");
lua_setfield(L, -2, "meta_tls_socket");
}