diff options
43 files changed, 5247 insertions, 323 deletions
diff --git a/libs/nixio/LICENSE b/libs/nixio/LICENSE new file mode 100644 index 000000000..f49a4e16e --- /dev/null +++ b/libs/nixio/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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.
\ No newline at end of file diff --git a/libs/nixio/Makefile b/libs/nixio/Makefile index ca22328ae..8e87eaa10 100644 --- a/libs/nixio/Makefile +++ b/libs/nixio/Makefile @@ -1,21 +1,27 @@ +ifneq (,$(wildcard ../../build/config.mk)) include ../../build/config.mk include ../../build/module.mk include ../../build/gccconfig.mk +else +include standalone.mk +endif AXTLS_VERSION = 1.2.1 AXTLS_DIR = axTLS AXTLS_FILE = $(AXTLS_DIR)-$(AXTLS_VERSION).tar.gz NIXIO_TLS ?= openssl -NIXIO_LDFLAGS = +NIXIO_LDFLAGS = -lcrypt +NIXIO_SO = nixio.so NIXIO_OBJ = src/nixio.o src/socket.o src/sockopt.o src/bind.o src/address.o \ src/poll.o src/io.o src/file.o src/splice.o src/process.o src/syslog.o \ - src/tls-context.o src/tls-socket.o + src/bit.o src/binary.o src/fs.o src/user.o \ + src/tls-crypto.o src/tls-context.o src/tls-socket.o ifeq ($(NIXIO_TLS),axtls) - TLS_CFLAGS = -IaxTLS/ssl -IaxTLS/crypto -IaxTLS/config -include src/openssl-compat.h - TLS_DEPENDS = src/openssl-compat.o - NIXIO_OBJ += src/openssl-compat.o src/libaxtls.a + TLS_CFLAGS = -IaxTLS/ssl -IaxTLS/crypto -IaxTLS/config -include src/axtls-compat.h + TLS_DEPENDS = src/axtls-compat.o + NIXIO_OBJ += src/axtls-compat.o src/libaxtls.a endif ifeq ($(NIXIO_TLS),openssl) @@ -27,26 +33,43 @@ ifeq ($(OS),SunOS) NIXIO_LDFLAGS += -lsocket -lnsl -lsendfile endif +ifneq (,$(findstring MINGW,$(OS))$(findstring mingw,$(OS))$(findstring Windows,$(OS))) + NIXIO_CROSS_CC:=$(shell which i586-mingw32msvc-cc) +ifneq (,$(NIXIO_CROSS_CC)) + CC:=$(NIXIO_CROSS_CC) +endif + NIXIO_OBJ += src/mingw-compat.o + NIXIO_LDFLAGS_POST:=-llua -lssl -lcrypto -lws2_32 -lgdi32 + FPIC:= + EXTRA_CFLAGS += -D_WIN32_WINNT=0x0501 + LUA_CFLAGS:= + NIXIO_SO:=nixio.dll + NIXIO_LDFLAGS:= +endif + %.o: %.c $(COMPILE) $(NIXIO_CFLAGS) $(LUA_CFLAGS) $(FPIC) -c -o $@ $< +src/tls-crypto.o: $(TLS_DEPENDS) src/tls-crypto.c + $(COMPILE) $(NIXIO_CFLAGS) $(LUA_CFLAGS) $(FPIC) $(TLS_CFLAGS) -c -o $@ src/tls-crypto.c + src/tls-context.o: $(TLS_DEPENDS) src/tls-context.c $(COMPILE) $(NIXIO_CFLAGS) $(LUA_CFLAGS) $(FPIC) $(TLS_CFLAGS) -c -o $@ src/tls-context.c src/tls-socket.o: $(TLS_DEPENDS) src/tls-socket.c $(COMPILE) $(NIXIO_CFLAGS) $(LUA_CFLAGS) $(FPIC) $(TLS_CFLAGS) -c -o $@ src/tls-socket.c -src/openssl-compat.o: src/libaxtls.a src/openssl-compat.c - $(COMPILE) $(NIXIO_CFLAGS) $(LUA_CFLAGS) $(FPIC) $(TLS_CFLAGS) -c -o $@ src/openssl-compat.c +src/axtls-compat.o: src/libaxtls.a src/axtls-compat.c + $(COMPILE) $(NIXIO_CFLAGS) $(LUA_CFLAGS) $(FPIC) $(TLS_CFLAGS) -c -o $@ src/axtls-compat.c mkdir -p dist cp -pR axtls-root/* dist/ compile: $(NIXIO_OBJ) - $(LINK) $(SHLIB_FLAGS) $(NIXIO_LDFLAGS) -o src/nixio.so $(NIXIO_OBJ) + $(LINK) $(SHLIB_FLAGS) $(NIXIO_LDFLAGS) -o src/$(NIXIO_SO) $(NIXIO_OBJ) $(NIXIO_LDFLAGS_POST) mkdir -p dist$(LUA_LIBRARYDIR) - cp src/nixio.so dist$(LUA_LIBRARYDIR)/nixio.so + cp src/$(NIXIO_SO) dist$(LUA_LIBRARYDIR)/$(NIXIO_SO) $(AXTLS_DIR)/.prepared: #rm -rf $(AXTLS_DIR) @@ -55,9 +78,13 @@ $(AXTLS_DIR)/.prepared: touch $@ src/libaxtls.a: $(AXTLS_DIR)/.prepared - $(MAKE) -C $(AXTLS_DIR) CC=$(CC) CFLAGS="$(CFLAGS) $(EXTRA_CFLAGS) $(FPIC) '-Dalloca(size)=__builtin_alloca(size)' -Wall -pedantic -I../config -I../ssl -I../crypto" LDFLAGS="$(LDFLAGS)" OS="$(OS)" clean all + $(MAKE) -C $(AXTLS_DIR) CC=$(CC) CFLAGS="$(CFLAGS) $(EXTRA_CFLAGS) $(FPIC) -Wall -pedantic -I../config -I../ssl -I../crypto" LDFLAGS="$(LDFLAGS)" OS="$(OS)" clean all cp -p $(AXTLS_DIR)/_stage/libaxtls.a src clean: luaclean - rm -f src/*.o src/*.so src/*.a + rm -f src/*.o src/*.so src/*.a src/*.dll rm -f $(AXTLS_DIR)/.prepared + +install: build + cp -pR dist$(LUA_MODULEDIR)/* $(LUA_MODULEDIR) + cp -pR dist$(LUA_LIBRARYDIR)/* $(LUA_LIBRARYDIR) diff --git a/libs/nixio/NOTICE b/libs/nixio/NOTICE new file mode 100644 index 000000000..f557831e8 --- /dev/null +++ b/libs/nixio/NOTICE @@ -0,0 +1,10 @@ +nixio - Linux I/O library for lua +Copyright 2009 Steven Barth <steven@midlink.org> +Licensed under the Apache License, Version 2.0. + +Contains code from: +axTLS - Copyright 2008 Cameron Rich + +Thanks for testing, feedback and code snippets: +John Crispin <blogic@openwrt.org> +Jo-Philipp Wich <xm@leipzig.freifunk.net>
\ No newline at end of file diff --git a/libs/nixio/README b/libs/nixio/README index 01b836130..ba9b36b30 100644 --- a/libs/nixio/README +++ b/libs/nixio/README @@ -1,7 +1,13 @@ Building: + Use GNU Make. + make or gmake depending on your system. + + Special make flags: -With axTLS (standard): -make - -With OpenSSL: -make NIXIO_TLS=openssl + OS Override Target OS [Linux|FreeBSD|SunOS|Windows] + NIXIO_TLS TLS-Library [*openssl|axtls] + NIXIO_CROSS_CC MinGW CC (Windows) `which i586-mingw32msvc-cc` + LUA_CFLAGS Lua CFLAGS `pkg-config --cflags lua5.1` + LUA_TARGET Lua compile target [*source|strip|compile] + LUA_MODULEDIR Install LUA_PATH "/usr/share/lua/5.1" + LUA_LIBRARYDIR Install LUA_CPATH "/usr/lib/lua/5.1" diff --git a/libs/nixio/docsrc/README.lua b/libs/nixio/docsrc/README.lua new file mode 100644 index 000000000..20793cefe --- /dev/null +++ b/libs/nixio/docsrc/README.lua @@ -0,0 +1,98 @@ +--- General Information. +module "README" + +--- General error handling information. +-- <ul> +-- <li> Most of the functions available in this library may fail. If any error +-- occurs the function returns <strong>nil or false</strong>, an error code +-- (usually errno) and an additional error message text (if avaialable).</li> +-- <li>At the moment false is only returned when a non-blocking I/O function +-- fails with EAGAIN, EWOULDBLOCK or WSAEWOULDBLOCK for any others nil is +-- returned as first parameter. Therefore you can use false to write portable +-- non-blocking I/O applications.</li> +-- <li>Note that the function documentation does only mention the return values +-- in case of a successful operation.</li> +-- <li>You can find a table of common error numbers and other useful constants +-- like signal numbers in <strong>nixio.const</strong> e.g. nixio.const.EINVAL, +-- nixio.const.SIGTERM, etc. For portability there is a second error constant +-- table <strong>nixio.const_sock</strong> for socket error codes. This might +-- be important if you are dealing with Windows applications, on POSIX however +-- const_sock is just an alias for const.</li> +-- <li>With some exceptions - which are explicitely stated in the function +-- documentation - all blocking functions are signal-protected and will not fail +-- with EINTR.</li> +-- <li>On POSIX the SIGPIPE signal will be set to ignore upon initialization. +-- You should restore the default behaviour or set a custom signal handler +-- in your program after loading nixio if you need this behaviour.</li> +-- </ul> +-- @class table +-- @name Errorhandling +-- @return ! + +--- Function conventions. +-- <br />In general all functions are namend and behave like their POSIX API +-- counterparts - where applicable - applying the following rules: +-- <ul> +-- <li>Functions should be named like the underlying POSIX API function ommiting +-- prefixes or suffixes - especially when placed in an object-context ( +-- lockf -> File:lock, fsync -> File:sync, dup2 -> dup, ...)</li> +-- <li>If you are unclear about the behaviour of a function you should consult +-- your OS API documentation (e.g. the manpages).</li> +-- <li>If the name is significantly different from the POSIX-function, the +-- underlying function(s) are stated in the documentation.</li> +-- <li>Parameters should reflect those of the C-API, buffer length arguments and +-- by-reference parameters should be ommitted for pratical purposes.</li> +-- <li>If a C function accepts a bitfield as parameter, it should be translated +-- into lower case string flags representing the flags if the bitfield is the +-- last parameter and also ommiting prefixes or suffixes. (e.g. waitpid +-- (pid, &s, WNOHANG | WUNTRACED) -> waitpid(pid, "nohang", "untraced"), +-- getsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) -> +-- Socket:getopt("socket", "reuseaddr"), etc.) </li> +-- <li>If it is not applicable to provide a string representation of the +-- bitfield a bitfield generator helper is provided. It is named FUNCTION_flags. +-- (open("/tmp/test", O_RDONLY | O_NONBLOCK) -> open("/tmp/test", open_flags( +-- "rdonly", "nonblock")))</li> +-- </ul> +-- @class table +-- @name Functions +-- @return ! + +--- Platform information. +-- <ul> +-- <li>The minimum platform requirements are a decent POSIX 2001 support. +-- Builds are more or less tested on Linux, Solaris and FreeBSD. Builds for +-- Windows XP SP1 and later can be compiled with MinGW either from Windows +-- itself or using the MinGW cross-compiler. Earlier versions of Windows are not +-- supported.</li> +-- <li>In general all functions which don't have any remarks +-- in their documentation are available on all platforms.</li> +-- <li>Functions with a (POSIX), (Linux) or similar prefix are only available +-- on these specific platforms. Same appplies to parameters of functions +-- with a similar suffix.</li> +-- <li>Some functions might have limitations on some platforms. This should +-- be stated in the documentation. Please also consult your OS API +-- documentation.</li> +-- </ul> +-- @usage Tes +-- @class table +-- @name Platforms +-- @return ! + +--- Cryptography and TLS libraries. +-- <ul> +-- <li>Currently 2 underlying cryptography libraries are supported: openssl and +-- axTLS. The name of the library in use is written to +-- <strong>nixio.tls_provider</strong></li> +-- <li>You should whenever possible use openssl as axTLS has only limited +-- support. It does not provide support for non-blocking sockets and +-- is probably less audited than openssl.</li> +-- <li>However in embedded development if you don't need openssl anyway +-- you may safe an essential amount of flash space (about 1 MB for the openssl +-- library) by choosing axTLS over openssl.</li> +-- <li>As the supported Windows versions are not suitable for embedded devices +-- axTLS is at the moment not supported on Windows.</li> +-- </ul> +-- @usage Tes +-- @class table +-- @name TLS-Crypto +-- @return !
\ No newline at end of file diff --git a/libs/nixio/docsrc/nixio.CryptoHash.lua b/libs/nixio/docsrc/nixio.CryptoHash.lua new file mode 100644 index 000000000..a08b48d68 --- /dev/null +++ b/libs/nixio/docsrc/nixio.CryptoHash.lua @@ -0,0 +1,17 @@ +--- Cryptographical Hash and HMAC object. +-- @cstyle instance +module "nixio.CryptoHash" + +--- Add another chunk of data to be hashed. +-- @class function +-- @name CryptoHash.update +-- @param chunk Chunk of data +-- @return CryptoHash object (self) + +--- Finalize the hash and return the digest. +-- @class function +-- @name CryptoHash.final +-- @usage You cannot call update on a hash object that was already finalized +-- you can however call final multiple times to get the digest. +-- @return hexdigest +-- @return buffer containing binary digest
\ No newline at end of file diff --git a/libs/nixio/docsrc/nixio.File.lua b/libs/nixio/docsrc/nixio.File.lua new file mode 100644 index 000000000..368562a2a --- /dev/null +++ b/libs/nixio/docsrc/nixio.File.lua @@ -0,0 +1,109 @@ +--- Large File Object. +-- Large file operations are supported up to 52 bits if the Lua number type is +-- double (default). +-- @cstyle instance +module "nixio.File" + +--- Write to the file descriptor. +-- @class function +-- @name File.write +-- @usage <strong>Warning:</strong> It is not guaranteed that all data +-- in the buffer is written at once especially when dealing with pipes. +-- You have to check the return value - the number of bytes actually written - +-- or use the safe IO functions in the high-level IO utility module. +-- @usage Unlike standard Lua indexing the lowest offset and default is 0. +-- @param buffer Buffer holding the data to be written. +-- @param offset Offset to start reading the buffer from. (optional) +-- @param length Length of chunk to read from the buffer. (optional) +-- @return number of bytes written + +--- Read from a file descriptor. +-- @class function +-- @name File.read +-- @usage <strong>Warning:</strong> It is not guaranteed that all requested data +-- is read at once especially when dealing with pipes. +-- You have to check the return value - the length of the buffer actually read - +-- or use the safe IO functions in the high-level IO utility module. +-- @usage The length of the return buffer is limited by the (compile time) +-- nixio buffersize which is <em>nixio.const.buffersize</em> (8192 by default). +-- Any read request greater than that will be safely truncated to this value. +-- @param length Amount of data to read (in Bytes). +-- @return buffer containing data successfully read + +--- Reposition read / write offset of the file descriptor. +-- The seek will be done either from the beginning of the file or relative +-- to the current position or relative to the end. +-- @class function +-- @name File.seek +-- @usage This function calls lseek(). +-- @param offset File Offset +-- @param whence Starting point [<strong>"set"</strong>, "cur", "end"] +-- @return new (absolute) offset position + +--- Return the current read / write offset of the file descriptor. +-- @class function +-- @name File.tell +-- @usage This function calls lseek() with offset 0 from the current position. +-- @return offset position + +--- Synchronizes the file with the storage device. +-- Returns when the file is successfully written to the disk. +-- @class function +-- @name File.sync +-- @usage This function calls fsync() when data_only equals false +-- otherwise fdatasync(), on Windows _commit() is used instead. +-- @usage fdatasync() is only supported by Linux and Solaris. For other systems +-- the <em>data_only</em> parameter is ignored and fsync() is always called. +-- @param data_only Do not synchronize the metadata. (optional, boolean) +-- @return true + +--- Apply or test a lock on the file. +-- @class function +-- @name File.lock +-- @usage This function calls lockf() on POSIX and _locking() on Windows. +-- @usage The "lock" command is blocking, "tlock" is non-blocking, +-- "ulock" unlocks and "test" only tests for the lock. +-- @usage The "test" command is not available on Windows. +-- @usage Locks are by default advisory on POSIX, but mandatory on Windows. +-- @param command Locking Command ["lock", "tlock", "ulock", "test"] +-- @param length Amount of Bytes to lock from current offset (optional) +-- @return true + +--- Get file status and attributes. +-- @class function +-- @name File.stat +-- @param field Only return a specific field, not the whole table (optional) +-- @usage This function calls fstat(). +-- @return Table containing: <ul> +-- <li>atime = Last access timestamp</li> +-- <li>blksize = Blocksize (POSIX only)</li> +-- <li>blocks = Blocks used (POSIX only)</li> +-- <li>ctime = Creation timestamp</li> +-- <li>dev = Device ID</li> +-- <li>gid = Group ID</li> +-- <li>ino = Inode</li> +-- <li>modedec = Mode converted into a decimal number</li> +-- <li>modestr = Mode as string as returned by `ls -l`</li> +-- <li>mtime = Last modification timestamp</li> +-- <li>nlink = Number of links</li> +-- <li>rdev = Device ID (if special file)</li> +-- <li>size = Size in bytes</li> +-- <li>type = ["reg", "dir", "chr", "blk", "fifo", "lnk", "sock"]</li> +-- <li>uid = User ID</li> +-- </ul> + +--- Close the file descriptor. +-- @class function +-- @name File.close +-- @return true + +--- Get the number of the filedescriptor. +-- @class function +-- @name File.fileno +-- @return file descriptor number + +--- (POSIX) Set the blocking mode of the file descriptor. +-- @class function +-- @name File.setblocking +-- @param blocking (boolean) +-- @return true
\ No newline at end of file diff --git a/libs/nixio/docsrc/nixio.Socket.lua b/libs/nixio/docsrc/nixio.Socket.lua new file mode 100644 index 000000000..7123393bf --- /dev/null +++ b/libs/nixio/docsrc/nixio.Socket.lua @@ -0,0 +1,170 @@ +--- Socket Object. +-- Supports IPv4, IPv6 and UNIX (POSIX only) families. +-- @cstyle instance +module "nixio.Socket" + +--- Get the local address of a socket. +-- @class function +-- @name Socket.getsockname +-- @return IP-Address +-- @return Port + +--- Get the peer address of a socket. +-- @class function +-- @name Socket.getpeername +-- @return IP-Address +-- @return Port + +--- Bind the socket to a network address. +-- @class function +-- @name Socket.bind +-- @usage This function calls getaddrinfo() and bind() but NOT listen(). +-- @usage If <em>host</em> is a domain name it will be looked up and bind() +-- tries the IP-Addresses in the order returned by the DNS resolver +-- until the bind succeeds. +-- @usage UNIX sockets ignore the <em>port</em>, +-- and interpret <em>host</em> as a socket path. +-- @param host Host (optional, default: all addresses) +-- @param port Port or service description +-- @return true + +--- Connect the socket to a network address. +-- @class function +-- @name Socket.connect +-- @usage This function calls getaddrinfo() and connect(). +-- @usage If <em>host</em> is a domain name it will be looked up and connect() +-- tries the IP-Addresses in the order returned by the DNS resolver +-- until the connect succeeds. +-- @usage UNIX sockets ignore the <em>port</em>, +-- and interpret <em>host</em> as a socket path. +-- @param host Hostname or IP-Address (optional, default: localhost) +-- @param port Port or service description +-- @return true + +--- Listen for connections on the socket. +-- @class function +-- @name Socket.listen +-- @param backlog Length of queue for pending connections +-- @return true + +--- Accept a connection on the socket. +-- @class function +-- @name Socket.accept +-- @return Socket Object +-- @return Peer IP-Address +-- @return Peer Port + +--- Send a message on the socket specifying the destination. +-- @class function +-- @name Socket.sendto +-- @usage <strong>Warning:</strong> It is not guaranteed that all data +-- in the buffer is written at once. +-- You have to check the return value - the number of bytes actually written - +-- or use the safe IO functions in the high-level IO utility module. +-- @usage Unlike standard Lua indexing the lowest offset and default is 0. +-- @param buffer Buffer holding the data to be written. +-- @param host Target IP-Address +-- @param port Target Port +-- @param offset Offset to start reading the buffer from. (optional) +-- @param length Length of chunk to read from the buffer. (optional) +-- @return number of bytes written + +--- Send a message on the socket. +-- This function is identical to sendto except for the missing destination +-- paramters. See the sendto description for a detailed description. +-- @class function +-- @name Socket.send +-- @param buffer Buffer holding the data to be written. +-- @param offset Offset to start reading the buffer from. (optional) +-- @param length Length of chunk to read from the buffer. (optional) +-- @see Socket.sendto +-- @return number of bytes written + +--- Send a message on the socket (This is an alias for send). +-- See the sendto description for a detailed description. +-- @class function +-- @name Socket.write +-- @param buffer Buffer holding the data to be written. +-- @param offset Offset to start reading the buffer from. (optional) +-- @param length Length of chunk to read from the buffer. (optional) +-- @see Socket.sendto +-- @return number of bytes written + +--- Receive a message on the socket including the senders source address. +-- @class function +-- @name Socket.recvfrom +-- @usage <strong>Warning:</strong> It is not guaranteed that all requested data +-- is read at once. +-- You have to check the return value - the length of the buffer actually read - +-- or use the safe IO functions in the high-level IO utility module. +-- @usage The length of the return buffer is limited by the (compile time) +-- nixio buffersize which is <em>nixio.const.buffersize</em> (8192 by default). +-- Any read request greater than that will be safely truncated to this value. +-- @param length Amount of data to read (in Bytes). +-- @return buffer containing data successfully read +-- @return host IP-Address of the sender +-- @return port Port of the sender + +--- Receive a message on the socket. +-- This function is identical to recvfrom except that it does not return +-- the sender's source address. See the recvfrom description for more details. +-- @class function +-- @name Socket.recv +-- @param length Amount of data to read (in Bytes). +-- @see Socket.recvfrom +-- @return buffer containing data successfully read + +--- Receive a message on the socket (This is an alias for recv). +-- See the recvfrom description for more details. +-- @class function +-- @name Socket.read +-- @param length Amount of data to read (in Bytes). +-- @see Socket.recvfrom +-- @return buffer containing data successfully read + +--- Close the socket. +-- @class function +-- @name Socket.close +-- @return true + +--- Shut down part of a full-duplex connection. +-- @class function +-- @name Socket.shutdown +-- @param how (optional, default: rdwr) ["rdwr", "rd", "wr"] +-- @return true + +--- Get the number of the filedescriptor. +-- @class function +-- @name Socket.fileno +-- @return file descriptor number + +--- Set the blocking mode of the socket. +-- @class function +-- @name Socket.setblocking +-- @param blocking (boolean) +-- @return true + +--- Set a socket option. +-- @class function +-- @name Socket.setopt +-- @param level Level ["socket", "tcp", "ip", "ipv6"] +-- @param option Option ["keepalive", "reuseaddr", "sndbuf", "rcvbuf", +-- "priority", "broadcast", "linger", "sndtimeo", "rcvtimeo", "dontroute", +-- "bindtodevice", "error", "oobinline", "cork" (TCP), "nodelay" (TCP), +-- "mtu" (IP, IPv6), "hdrincl" (IP), "multicast_ttl" (IP), "multicast_loop" +-- (IP, IPv6), "multicast_if" (IP, IPv6), "v6only" (IPv6), "multicast_hops" +-- (IPv6), "add_membership" (IP, IPv6), "drop_membership" (IP, IPv6)] +-- @param value Value +-- @return true + +--- Get a socket option. +-- @class function +-- @name Socket.getopt +-- @param level Level ["socket", "tcp", "ip", "ipv6"] +-- @param option Option ["keepalive", "reuseaddr", "sndbuf", "rcvbuf", +-- "priority", "broadcast", "linger", "sndtimeo", "rcvtimeo", "dontroute", +-- "bindtodevice", "error", "oobinline", "cork" (TCP), "nodelay" (TCP), +-- "mtu" (IP, IPv6), "hdrincl" (IP), "multicast_ttl" (IP), "multicast_loop" +-- (IP, IPv6), "multicast_if" (IP, IPv6), "v6only" (IPv6), "multicast_hops" +-- (IPv6), "add_membership" (IP, IPv6), "drop_membership" (IP, IPv6)] +-- @return Value
\ No newline at end of file diff --git a/libs/nixio/docsrc/nixio.TLSContext.lua b/libs/nixio/docsrc/nixio.TLSContext.lua new file mode 100644 index 000000000..7cc071195 --- /dev/null +++ b/libs/nixio/docsrc/nixio.TLSContext.lua @@ -0,0 +1,46 @@ +--- Transport Layer Security Context Object. +-- @cstyle instance +module "nixio.TLSContext" + +--- Create a TLS Socket from a socket descriptor. +-- @class function +-- @name TLSContext.create +-- @param socket Socket Object +-- @return TLSSocket Object + +--- Assign a PEM certificate to this context. +-- @class function +-- @name TLSContext.set_cert +-- @usage This function calls SSL_CTX_use_certificate_chain_file(). +-- @param path Certificate File path +-- @return true + +--- Assign a PEM private key to this context. +-- @class function +-- @name TLSContext.set_key +-- @usage This function calls SSL_CTX_use_PrivateKey_file(). +-- @param path Private Key File path +-- @return true + +--- Set the available ciphers for this context. +-- @class function +-- @name TLSContext.set_ciphers +-- @usage This function calls SSL_CTX_set_cipher_list(). +-- @param cipherlist String containing a list of ciphers +-- @return true + +--- Set the verification depth of this context. +-- @class function +-- @name TLSContext.set_verify_depth +-- @usage This function calls SSL_CTX_set_verify_depth(). +-- @param depth Depth +-- @return true + +--- Set the verification flags of this context. +-- @class function +-- @name TLSContext.set_verify +-- @usage This function calls SSL_CTX_set_verify(). +-- @param flag1 First Flag ["none", "peer", "verify_fail_if_no_peer_cert", +-- "client_once"] +-- @param ... More Flags [-"-] +-- @return true
\ No newline at end of file diff --git a/libs/nixio/docsrc/nixio.TLSSocket.lua b/libs/nixio/docsrc/nixio.TLSSocket.lua new file mode 100644 index 000000000..b932cde0d --- /dev/null +++ b/libs/nixio/docsrc/nixio.TLSSocket.lua @@ -0,0 +1,73 @@ +--- TLS Socket Object. +-- TLS Sockets contain the underlying socket and context in the fields +-- "socket" and "context". +-- @cstyle instance +module "nixio.TLSSocket" + +--- Initiate the TLS handshake as client with the server. +-- @class function +-- @name TLSSocket.connect +-- @usage This function calls SSL_connect(). +-- @usage You have to call either connect or accept before transmitting data. +-- @see TLSSocket.accept +-- @return true + +--- Wait for a TLS handshake from a client. +-- @class function +-- @name TLSSocket.accept +-- @usage This function calls SSL_accept(). +-- @usage You have to call either connect or accept before transmitting data. +-- @see TLSSocket.connect +-- @return true + +--- Send a message to the socket. +-- @class function +-- @name TLSSocket.send +-- @usage This function calls SSL_write(). +-- @usage <strong>Warning:</strong> It is not guaranteed that all data +-- in the buffer is written at once. +-- You have to check the return value - the number of bytes actually written - +-- or use the safe IO functions in the high-level IO utility module. +-- @usage Unlike standard Lua indexing the lowest offset and default is 0. +-- @param buffer Buffer holding the data to be written. +-- @param offset Offset to start reading the buffer from. (optional) +-- @param length Length of chunk to read from the buffer. (optional) +-- @return number of bytes written + +--- Send a message on the socket (This is an alias for send). +-- See the send description for a detailed description. +-- @class function +-- @name TLSSocket.write +-- @param buffer Buffer holding the data to be written. +-- @param offset Offset to start reading the buffer from. (optional) +-- @param length Length of chunk to read from the buffer. (optional) +-- @see TLSSocket.send +-- @return number of bytes written + +--- Receive a message on the socket. +-- @class function +-- @name TLSSocket.recv +-- @usage This function calls SSL_read(). +-- @usage <strong>Warning:</strong> It is not guaranteed that all requested data +-- is read at once. +-- You have to check the return value - the length of the buffer actually read - +-- or use the safe IO functions in the high-level IO utility module. +-- @usage The length of the return buffer is limited by the (compile time) +-- nixio buffersize which is <em>nixio.const.buffersize</em> (8192 by default). +-- Any read request greater than that will be safely truncated to this value. +-- @param length Amount of data to read (in Bytes). +-- @return buffer containing data successfully read + +--- Receive a message on the socket (This is an alias for recv). +-- See the recv description for more details. +-- @class function +-- @name TLSSocket.read +-- @param length Amount of data to read (in Bytes). +-- @see TLSSocket.recv +-- @return buffer containing data successfully read + +--- Shut down the TLS connection. +-- @class function +-- @name TLSSocket.shutdown +-- @usage This function calls SSL_shutdown(). +-- @return true
\ No newline at end of file diff --git a/libs/nixio/docsrc/nixio.UnifiedIO.lua b/libs/nixio/docsrc/nixio.UnifiedIO.lua new file mode 100644 index 000000000..d0b189cf4 --- /dev/null +++ b/libs/nixio/docsrc/nixio.UnifiedIO.lua @@ -0,0 +1,130 @@ +--- Unified high-level I/O utility API for Files, Sockets and TLS-Sockets. +-- These functions are added to the object function tables by doing <strong> +-- require "nixio.util"</strong>, can be used on all nixio IO Descriptors and +-- are based on the shared low-level read() and write() functions. +-- @cstyle instance +module "nixio.UnifiedIO" + +--- Test whether the I/O-Descriptor is a socket. +-- @class function +-- @name UnifiedIO.is_socket +-- @return boolean + +--- Test whether the I/O-Descriptor is a TLS socket. +-- @class function +-- @name UnifiedIO.is_tls_socket +-- @return boolean + +--- Test whether the I/O-Descriptor is a file. +-- @class function +-- @name UnifiedIO.is_file +-- @return boolean + +--- Read a block of data and wait until all data is available. +-- @class function +-- @name UnifiedIO.readall +-- @usage This function uses the low-level read function of the descriptor. +-- @usage If the length parameter is ommited, this function returns all data +-- that can be read before an end-of-file, end-of-stream, connection shutdown +-- or similar happens. +-- @usage If the descriptor is non-blocking this function may fail with EAGAIN. +-- @param length Bytes to read (optional) +-- @return data that was successfully read if no error occured +-- @return - reserved for error code - +-- @return - reserved for error message - +-- @return data that was successfully read even if an error occured + +--- Write a block of data and wait until all data is written. +-- @class function +-- @name UnifiedIO.writeall +-- @usage This function uses the low-level write function of the descriptor. +-- @usage If the descriptor is non-blocking this function may fail with EAGAIN. +-- @param block Bytes to write +-- @return bytes that were successfully written if no error occured +-- @return - reserved for error code - +-- @return - reserved for error message - +-- @return bytes that were successfully written even if an error occured + +--- Create a line-based iterator. +-- Lines may end with either \n or \r\n, these control chars are not included +-- in the return value. +-- @class function +-- @name UnifiedIO.linesource +-- @usage This function uses the low-level read function of the descriptor. +-- @usage <strong>Note:</strong> This function uses an internal buffer to read +-- ahead. Do NOT mix calls to read(all) and the returned iterator. If you want +-- to stop reading line-based and want to use the read(all) functions instead +-- you can pass "true" to the iterator which will flush the buffer +-- and return the bufferd data. +-- @usage If the limit parameter is ommited, this function uses the nixio +-- buffersize (8192B by default). +-- @usage If the descriptor is non-blocking the iterator may fail with EAGAIN. +-- @usage The iterator can be used as an LTN12 source. +-- @param limit Line limit +-- @return Line-based Iterator + +--- Create a block-based iterator. +-- @class function +-- @name UnifiedIO.blocksource +-- @usage This function uses the low-level read function of the descriptor. +-- @usage The blocksize given is only advisory and to be seen as an upper limit, +-- if an underlying read returns less bytes the chunk is nevertheless returned. +-- @usage If the limit parameter is ommited, the iterator returns data +-- until an end-of-file, end-of-stream, connection shutdown or similar happens. +-- @usage The iterator will not buffer so it is safe to mix with calls to read. +-- @usage If the descriptor is non-blocking the iterator may fail with EAGAIN. +-- @usage The iterator can be used as an LTN12 source. +-- @param blocksize Advisory blocksize (optional) +-- @param limit Amount of data to consume (optional) +-- @return Block-based Iterator + +--- Create a sink. +-- This sink will simply write all data that it receives and optionally +-- close the descriptor afterwards. +-- @class function +-- @name UnifiedIO.sink +-- @usage This function uses the writeall function of the descriptor. +-- @usage If the descriptor is non-blocking the sink may fail with EAGAIN. +-- @usage The iterator can be used as an LTN12 sink. +-- @param close_when_done (optional, boolean) +-- @return Sink + +--- Copy data from the current descriptor to another one. +-- @class function +-- @name UnifiedIO.copy +-- @usage This function uses the blocksource function of the source descriptor +-- and the sink function of the target descriptor. +-- @usage If the limit parameter is ommited, data is copied +-- until an end-of-file, end-of-stream, connection shutdown or similar happens. +-- @usage If the descriptor is non-blocking the function may fail with EAGAIN. +-- @param fdout Target Descriptor +-- @param size Bytes to copy (optional) +-- @return bytes that were successfully written if no error occured +-- @return - reserved for error code - +-- @return - reserved for error message - +-- @return bytes that were successfully written even if an error occured + +--- Copy data from the current descriptor to another one using kernel-space +-- copying if possible. +-- @class function +-- @name UnifiedIO.copyz +-- @usage This function uses the sendfile() syscall to copy the data or the +-- blocksource function of the source descriptor and the sink function +-- of the target descriptor as a fallback mechanism. +-- @usage Support for splice() on Linux is not implemented yet. +-- @usage If the limit parameter is ommited, data is copied +-- until an end-of-file, end-of-stream, connection shutdown or similar happens. +-- @usage If the descriptor is non-blocking the function may fail with EAGAIN. +-- @param fdout Target Descriptor +-- @param size Bytes to copy (optional) +-- @return bytes that were successfully written if no error occured +-- @return - reserved for error code - +-- @return - reserved for error message - +-- @return bytes that were successfully written even if an error occured + +--- Close the descriptor. +-- @class function +-- @name UnifiedIO.close +-- @usage If the descriptor is a TLS-socket the underlying descriptor is +-- closed without touching the TLS connection. +-- @return true
\ No newline at end of file diff --git a/libs/nixio/docsrc/nixio.bin.lua b/libs/nixio/docsrc/nixio.bin.lua new file mode 100644 index 000000000..13e125d3c --- /dev/null +++ b/libs/nixio/docsrc/nixio.bin.lua @@ -0,0 +1,33 @@ +--- Binary operations and conversion. +module "nixio.bin" + +--- Return a hexadecimal ASCII represantation of the content of a buffer. +-- @class function +-- @name hexlify +-- @param buffer Buffer +-- @return representation using characters [0-9a-f] + +--- Return a binary buffer from a hexadecimal ASCII representation. +-- @class function +-- @name unhexlify +-- @param hexvalue representation using characters [0-9a-f] +-- @return binary data + +--- Calculate the CRC32 value of a buffer. +-- @class function +-- @name crc32 +-- @param buffer Buffer +-- @param initial Initial CRC32 value (optional) +-- @return crc32 value + +--- Base64 encode a given buffer. +-- @class function +-- @name b64encode +-- @param buffer Buffer +-- @return base64 encoded buffer + +--- Base64 decode a given buffer. +-- @class function +-- @name b64decode +-- @param buffer Base 64 Encoded data +-- @return binary data
\ No newline at end of file diff --git a/libs/nixio/docsrc/nixio.bit.lua b/libs/nixio/docsrc/nixio.bit.lua new file mode 100644 index 000000000..3bdad51f2 --- /dev/null +++ b/libs/nixio/docsrc/nixio.bit.lua @@ -0,0 +1,86 @@ +--- Bitfield operators and mainpulation functions. +-- Can be used as a drop-in replacement for bitlib. +module "nixio.bit" + +--- Bitwise OR several numbers. +-- @class function +-- @name bor +-- @param oper1 First Operand +-- @param oper2 Second Operand +-- @param ... More Operands +-- @return number + +--- Bitwise AND several numbers. +-- @class function +-- @name band +-- @param oper1 First Operand +-- @param oper2 Second Operand +-- @param ... More Operands +-- @return number + +--- Bitwise XOR several numbers. +-- @class function +-- @name bxor +-- @param oper1 First Operand +-- @param oper2 Second Operand +-- @param ... More Operands +-- @return number + +--- Left shift a number. +-- @class function +-- @name shl +-- @param oper number +-- @param shift bits to shift +-- @return number + +--- Right shift a number. +-- @class function +-- @name shr +-- @param oper number +-- @param shift bits to shift +-- @return number + +--- Arithmetically right shift a number. +-- @class function +-- @name ashr +-- @param oper number +-- @param shift bits to shift +-- @return number + +--- Integer division of 2 or more numbers. +-- @class function +-- @name div +-- @param oper1 Operand 1 +-- @param oper2 Operand 2 +-- @param ... More Operands +-- @return number + +--- Cast a number to the bit-operating range. +-- @class function +-- @name cast +-- @param oper number +-- @return number + +--- Sets one or more flags of a bitfield. +-- @class function +-- @name set +-- @param bitfield Bitfield +-- @param flag1 First Flag +-- @param ... More Flags +-- @return altered bitfield + +--- Unsets one or more flags of a bitfield. +-- @class function +-- @name unset +-- @param bitfield Bitfield +-- @param flag1 First Flag +-- @param ... More Flags +-- @return altered bitfield + +--- Checks whether given flags are set in a bitfield. +-- @class function +-- @name check +-- @param bitfield Bitfield +-- @param flag1 First Flag +-- @param ... More Flags +-- @return true when all flags are set, otherwise false
\ No newline at end of file diff --git a/libs/nixio/docsrc/nixio.crypto.lua b/libs/nixio/docsrc/nixio.crypto.lua new file mode 100644 index 000000000..158d0fc0b --- /dev/null +++ b/libs/nixio/docsrc/nixio.crypto.lua @@ -0,0 +1,15 @@ +--- Cryptographical library. +module "nixio.crypto" + +--- Create a hash object. +-- @class function +-- @name nixio.crypto.hash +-- @param algo Algorithm ["sha1", "md5"] +-- @return CryptoHash Object + +--- Create a HMAC object. +-- @class function +-- @name nixio.crypto.hmac +-- @param algo Algorithm ["sha1", "md5"] +-- @param key HMAC-Key +-- @return CryptoHash Object
\ No newline at end of file diff --git a/libs/nixio/docsrc/nixio.fs.lua b/libs/nixio/docsrc/nixio.fs.lua new file mode 100644 index 000000000..5d08719e9 --- /dev/null +++ b/libs/nixio/docsrc/nixio.fs.lua @@ -0,0 +1,265 @@ +--- Low-level and high-level filesystem manipulation library. +module "nixio.fs" + + +--- Check user's permission on a file. +-- @class function +-- @name nixio.fs.access +-- @param path Path +-- @param mode1 First Mode to check ["f", "r", "w", "x"] +-- @param ... More Modes to check [-"-] +-- @return true + +--- Strip the directory part from a path. +-- @class function +-- @name nixio.fs.basename +-- @usage This function cannot fail and will never return nil. +-- @param path Path +-- @return basename + +--- Strip the base from a path. +-- @class function +-- @name nixio.fs.dirname +-- @usage This function cannot fail and will never return nil. +-- @param path Path +-- @return dirname + +--- Return the cannonicalized absolute pathname. +-- @class function +-- @name nixio.fs.realpath +-- @param path Path +-- @return absolute path + +--- Remove a file or directory. +-- @class function +-- @name nixio.fs.remove +-- @param path Path +-- @return true + +--- Delete a name and - if no links are left - the associated file. +-- @class function +-- @name nixio.fs.unlink +-- @param path Path +-- @return true + +--- Renames a file or directory. +-- @class function +-- @name nixio.fs.rename +-- @param src Source path +-- @param dest Destination path +-- @usage It is normally not possible to rename files accross fileystems. +-- @return true + +--- Remove an empty directory. +-- @class function +-- @name nixio.fs.rmdir +-- @param path Path +-- @return true + +--- Create a new directory. +-- @class function +-- @name nixio.fs.mkdir +-- @param path Path +-- @param mode File mode (optional, see chmod and umask) +-- @see nixio.fs.chmod +-- @see nixio.umask +-- @return true + +--- Change the file mode. +-- @class function +-- @name nixio.fs.chmod +-- @usage Windows only supports setting the write-protection through the +-- "Writable to others" bit. +-- @usage <strong>Notice:</strong> The mode-flag for the functions +-- open, mkdir, mkfifo are affected by the umask. +-- @param path Path +-- @param mode File mode +-- [decimal mode number, "[-r][-w][-xsS][-r][-w][-xsS][-r][-w][-xtT]"] +-- @see nixio.umask +-- @return true + +--- Iterate over the entries of a directory. +-- @class function +-- @name nixio.fs.dir +-- @usage The special entries "." and ".." are omitted. +-- @param path Path +-- @return directory iterator returning one entry per call + +--- Create a hard link. +-- @class function +-- @name nixio.fs.link +-- @usage This function calls link() on POSIX and CreateHardLink() on Windows. +-- @param oldpath Path +-- @param newpath Path +-- @return true + +--- Change file last access and last modification time. +-- @class function +-- @name nixio.fs.utimes +-- @param path Path +-- @param actime Last access timestamp (optional, default: current time) +-- @param mtime Last modification timestamp (optional, default: actime) +-- @return true + +--- Get file status and attributes. +-- @class function +-- @name nixio.fs.stat +-- @param path Path +-- @param field Only return a specific field, not the whole table (optional) +-- @return Table containing: <ul> +-- <li>atime = Last access timestamp</li> +-- <li>blksize = Blocksize (POSIX only)</li> +-- <li>blocks = Blocks used (POSIX only)</li> +-- <li>ctime = Creation timestamp</li> +-- <li>dev = Device ID</li> +-- <li>gid = Group ID</li> +-- <li>ino = Inode</li> +-- <li>modedec = Mode converted into a decimal number</li> +-- <li>modestr = Mode as string as returned by `ls -l`</li> +-- <li>mtime = Last modification timestamp</li> +-- <li>nlink = Number of links</li> +-- <li>rdev = Device ID (if special file)</li> +-- <li>size = Size in bytes</li> +-- <li>type = ["reg", "dir", "chr", "blk", "fifo", "lnk", "sock"]</li> +-- <li>uid = User ID</li> +-- </ul> + +--- Get file status and attributes and do not resolve if target is a symlink. +-- @class function +-- @name nixio.fs.lstat +-- @param path Path +-- @param field Only return a specific field, not the whole table (optional) +-- @see nixio.fs.stat +-- @return Table containing attributes (see stat for a detailed description) + +--- (POSIX) Change owner and group of a file. +-- @class function +-- @name nixio.fs.chown +-- @param path Path +-- @param user User ID or Username (optional) +-- @param group Group ID or Groupname (optional) +-- @return true + +--- (POSIX) Change owner and group of a file and do not resolve +-- if target is a symlink. +-- @class function +-- @name nixio.fs.lchown +-- @param path Path +-- @param user User ID or Username (optional) +-- @param group Group ID or Groupname (optional) +-- @return true + +--- (POSIX) Create a FIFO (named pipe). +-- @class function +-- @name nixio.fs.mkfifo +-- @param path Path +-- @param mode File mode (optional, see chmod and umask) +-- @see nixio.fs.chmod +-- @see nixio.umask +-- @return true + +--- (POSIX) Create a symbolic link. +-- @class function +-- @name nixio.fs.symlink +-- @param oldpath Path +-- @param newpath Path +-- @return true + +--- (POSIX) Read the target of a symbolic link. +-- @class function +-- @name nixio.fs.readlink +-- @param path Path +-- @return target path + +--- (POSIX) Find pathnames matching a pattern. +-- @class function +-- @name nixio.fs.glob +-- @param pattern Pattern +-- @return path iterator +-- @return number of matches + +--- (POSIX) Get filesystem statistics. +-- @class function +-- @name nixio.fs.statvfs +-- @param path Path to any file within the filesystem. +-- @return Table containing: <ul> +-- <li>bavail = available blocks</li> +-- <li>bfree = free blocks</li> +-- <li>blocks = number of fragments</li> +-- <li>frsize = fragment size</li> +-- <li>favail = available inodes</li> +-- <li>ffree = free inodes</li> +-- <li>files = inodes</li> +-- <li>flag = flags</li> +-- <li>fsid = filesystem ID</li> +-- <li>namemax = maximum filename length</li> +-- </ul> + +--- Read the contents of a file into a buffer. +-- @class function +-- @name nixio.fs.readfile +-- @param path Path +-- @param limit Maximum bytes to read (optional) +-- @return file contents + +--- Write a buffer into a file truncating the file first. +-- @class function +-- @name nixio.fs.writefile +-- @param path Path +-- @param data Data to write +-- @return true + +--- Copy data between files. +-- @class function +-- @name nixio.fs.datacopy +-- @param src Source file path +-- @param dest Destination file path +-- @param limit Maximum bytes to copy (optional) +-- @return true + +--- Copy a file, directory or symlink non-recursively preserving file mode, +-- timestamps, owner and group. +-- @class function +-- @name nixio.fs.copy +-- @usage The destination must always be a full destination path e.g. do not +-- omit the basename even if source and destination basename are equal. +-- @param src Source path +-- @param dest Destination path +-- @return true + +--- Rename a file, directory or symlink non-recursively across filesystems. +-- @class function +-- @name nixio.fs.move +-- @usage The destination must always be a full destination path e.g. do not +-- omit the basename even if source and destination basename are equal. +-- @param src Source path +-- @param dest Destination path +-- @return true + +--- Create a directory and all needed parent directories recursively. +-- @class function +-- @name nixio.fs.mkdirr +-- @param dest Destination path +-- @param mode File mode (optional, see chmod and umask) +-- @see nixio.fs.chmod +-- @see nixio.umask +-- @return true + +--- Rename a file, directory or symlink recursively across filesystems. +-- @class function +-- @name nixio.fs.mover +-- @usage The destination must always be a full destination path e.g. do not +-- omit the basename even if source and destination basename are equal. +-- @param src Source path +-- @param dest Destination path +-- @return true + +--- Copy a file, directory or symlink recursively preserving file mode, +-- timestamps, owner and group. +-- @class function +-- @name nixio.fs.copyr +-- @usage The destination must always be a full destination path e.g. do not +-- omit the basename even if source and destination basename are equal. +-- @param src Source path +-- @param dest Destination path +-- @return true
\ No newline at end of file diff --git a/libs/nixio/docsrc/nixio.lua b/libs/nixio/docsrc/nixio.lua new file mode 100644 index 000000000..7efeab8ef --- /dev/null +++ b/libs/nixio/docsrc/nixio.lua @@ -0,0 +1,416 @@ +--- General POSIX IO library. +module "nixio" + +--- Look up a hostname and service via DNS. +-- @class function +-- @name nixio.getaddrinfo +-- @param host hostname to lookup (optional) +-- @param family address family [<strong>"any"</strong>, "inet", "inet6"] +-- @param service service name or port (optional) +-- @return Table containing one or more tables containing: <ul> +-- <li>family = ["inet", "inet6"]</li> +-- <li>socktype = ["stream", "dgram", "raw"]</li> +-- <li>address = Resolved IP-Address</li> +-- <li>port = Resolved Port (if service was given)</li> +-- </ul> + +--- Reverse look up an IP-Address via DNS. +-- @class function +-- @name nixio.getnameinfo +-- @param ipaddr IPv4 or IPv6-Address +-- @return FQDN + +--- Create a new socket and bind it to a network address. +-- This function is a shortcut for calling nixio.socket and then bind() +-- on the socket object. +-- @usage This functions calls getaddrinfo(), socket(), +-- setsockopt() and bind() but NOT listen(). +-- @usage The <em>reuseaddr</em>-option is automatically set before binding. +-- @class function +-- @name nixio.bind +-- @param host Hostname or IP-Address (optional, default: all addresses) +-- @param port Port or service description +-- @param family Address family [<strong>"any"</strong>, "inet", "inet6"] +-- @param socktype Socket Type [<strong>"stream"</strong>, "dgram"] +-- @return Socket Object + +--- Create a new socket and connect to a network address. +-- This function is a shortcut for calling nixio.socket and then connect() +-- on the socket object. +-- @usage This functions calls getaddrinfo(), socket() and connect(). +-- @class function +-- @name nixio.connect +-- @param host Hostname or IP-Address (optional, default: localhost) +-- @param port Port or service description +-- @param family Address family [<strong>"any"</strong>, "inet", "inet6"] +-- @param socktype Socket Type [<strong>"stream"</strong>, "dgram"] +-- @return Socket Object + +--- Open a file. +-- @class function +-- @name nixio.open +-- @usage Although this function also supports the traditional fopen() +-- file flags it does not create a file stream but uses the open() syscall. +-- @param path Filesystem path to open +-- @param flags Flag string or number (see open_flags). +-- [<strong>"r"</strong>, "r+", "w", "w+", "a", "a+"] +-- @param mode File mode for newly created files (see chmod, umask). +-- @see nixio.umask +-- @see nixio.open_flags +-- @return File Object + +--- Generate flags for a call to open(). +-- @class function +-- @name nixio.open_flags +-- @usage This function cannot fail and will never return nil. +-- @usage The "nonblock" and "ndelay" flags are aliases. +-- @usage The "nonblock", "ndelay" and "sync" flags are no-ops on Windows. +-- @param flag1 First Flag ["append", "creat", "excl", "nonblock", "ndelay", +-- "sync", "trunc", "rdonly", "wronly", "rdwr"] +-- @param ... More Flags [-"-] +-- @return flag to be used as second paramter to open + +--- Duplicate a file descriptor. +-- @class function +-- @name nixio.dup +-- @usage This funcation calls dup2() if <em>newfd</em> is set, otherwise dup(). +-- @param oldfd Old descriptor [File Object, Socket Object (POSIX only)] +-- @param newfd New descriptor to serve as copy (optional) +-- @return File Object of new descriptor + +--- Create a pipe. +-- @class function +-- @name nixio.pipe +-- @return File Object of the read end +-- @return File Object of the write end + +--- Get the last system error code. +-- @class function +-- @name nixio.errno +-- @return Error code + +--- Get the error message for the corresponding error code. +-- @class function +-- @name nixio.strerror +-- @param errno System error code +-- @return Error message + +--- Sleep for a specified amount of time. +-- @class function +-- @usage Not all systems support nanosecond precision but you can expect +-- to have at least maillisecond precision. +-- @usage This function is not signal-protected and may fail with EINTR. +-- @param seconds Seconds to wait (optional) +-- @param nanoseconds Nanoseconds to wait (optional) +-- @name nixio.nanosleep +-- @return true + +--- Generate events-bitfield or parse revents-bitfield for poll. +-- @class function +-- @name nixio.poll_flags +-- @param mode1 revents-Flag bitfield returned from poll to parse OR +-- ["in", "out", "err", "pri" (POSIX), "hup" (POSIX), "nval" (POSIX)] +-- @param ... More mode strings for generating the flag [-"-] +-- @see nixio.poll +-- @return table with boolean fields reflecting the mode parameter +-- <strong>OR</strong> bitfield to use for the events-Flag field + +--- Wait for some event on a file descriptor. +-- poll() sets the revents-field of the tables provided by fds to a bitfield +-- indicating the events that occured. +-- @class function +-- @usage This function works in-place on the provided table and only +-- writes the revents field, you can use other fields on your demand. +-- @usage All metamethods on the tables provided as fds are ignored. +-- @usage The revents-fields are not reset when the call times out. +-- You have to check the first return value to be 0 to handle this case. +-- @usage If you want to wait on a TLS-Socket you have to use the underlying +-- socket instead. +-- @usage On Windows poll is emulated through select(), can only be used +-- on socket descriptors and cannot take more than 64 descriptors per call. +-- @usage This function is not signal-protected and may fail with EINTR. +-- @param fds Table containing one or more tables containing <ul> +-- <li> fd = I/O Descriptor [Socket Object, File Object (POSIX)]</li> +-- <li> events = events to wait for (bitfield generated with poll_flags)</li> +-- </ul> +-- @param timeout Timeout in milliseconds +-- @name nixio.poll +-- @see nixio.poll_flags +-- @return number of ready IO descriptors +-- @return the fds-table with revents-fields set + +--- (POSIX) Clone the current process. +-- @class function +-- @name nixio.fork +-- @return the child process id for the parent process, 0 for the child process + +--- (POSIX) Send a signal to one or more processes. +-- @class function +-- @name nixio.kill +-- @param target Target process of process group. +-- @param signal Signal to send +-- @return true + +--- (POSIX) Get the parent process id of the current process. +-- @class function +-- @name nixio.getppid +-- @return parent process id + +--- (POSIX) Get the user id of the current process. +-- @class function +-- @name nixio.getuid +-- @return process user id + +--- (POSIX) Get the group id of the current process. +-- @class function +-- @name nixio.getgid +-- @return process group id + +--- (POSIX) Set the group id of the current process. +-- @class function +-- @name nixio.setgid +-- @param gid New Group ID +-- @return true + +--- (POSIX) Set the user id of the current process. +-- @class function +-- @name nixio.setuid +-- @param gid New User ID +-- @return true + +--- (POSIX) Change priority of current process. +-- @class function +-- @name nixio.nice +-- @param nice Nice Value +-- @return true + +--- (POSIX) Create a new session and set the process group ID. +-- @class function +-- @name nixio.setsid +-- @return session id + +--- (POSIX) Wait for a process to change state. +-- @class function +-- @name nixio.waitpid +-- @usage If the "nohang" is given this function becomes non-blocking. +-- @param pid Process ID (optional, default: any childprocess) +-- @param flag1 Flag (optional) ["nohang", "untraced", "continued"] +-- @param ... More Flags [-"-] +-- @return process id of child or 0 if no child has changed state +-- @return ["exited", "signaled", "stopped"] +-- @return [exit code, terminate signal, stop signal] + +--- (POSIX) Get process times. +-- @class function +-- @name nixio.times +-- @return Table containing: <ul> +-- <li>utime = user time</li> +-- <li>utime = system time</li> +-- <li>cutime = children user time</li> +-- <li>cstime = children system time</li> +-- </ul> + +--- (POSIX) Get information about current system and kernel. +-- @class function +-- @name nixio.uname +-- @return Table containing: <ul> +-- <li>sysname = operating system</li> +-- <li>nodename = network name (usually hostname)</li> +-- <li>release = OS release</li> +-- <li>version = OS version</li> +-- <li>machine = hardware identifier</li> +-- </ul> + +--- Change the working directory. +-- @class function +-- @name nixio.chdir +-- @param path New working directory +-- @return true + +--- Ignore or use set the default handler for a signal. +-- @class function +-- @name nixio.signal +-- @param signal Signal +-- @param handler ["ign", "dfl"] +-- @return true + +--- Get the ID of the current process. +-- @class function +-- @name nixio.getpid +-- @return process id + +--- Get the current working directory. +-- @class function +-- @name nixio.getcwd +-- @return workign directory + +--- Get the current environment table or a specific environment variable. +-- @class function +-- @name nixio.getenv +-- @param variable Variable (optional) +-- @return environment table or single environment variable + +--- Set or unset a environment variable. +-- @class function +-- @name nixio.setenv +-- @usage The environment variable will be unset if value is ommited. +-- @param variable Variable +-- @param value Value (optional) +-- @return true + +--- Execute a file to replace the current process. +-- @class function +-- @name nixio.exec +-- @usage The name of the executable is automatically passed as argv[0] +-- @usage This function does not return on success. +-- @param executable Executable +-- @param ... Parameters + +--- Invoke the shell and execute a file to replace the current process. +-- @class function +-- @name nixio.execp +-- @usage The name of the executable is automatically passed as argv[0] +-- @usage This function does not return on success. +-- @param executable Executable +-- @param ... Parameters + +--- Execute a file with a custom environment to replace the current process. +-- @class function +-- @name nixio.exece +-- @usage The name of the executable is automatically passed as argv[0] +-- @usage This function does not return on success. +-- @param executable Executable +-- @param arguments Argument Table +-- @param environment Environment Table (optional) + +--- Sets the file mode creation mask. +-- @class function +-- @name nixio.umask +-- @param mask New creation mask (see chmod for format specifications) +-- @return the old umask as decimal mode number +-- @return the old umask as mode string + +--- (Linux) Get overall system statistics. +-- @class function +-- @name nixio.sysinfo +-- @return Table containing: <ul> +-- <li>uptime = system uptime in seconds</li> +-- <li>loads = {loadavg1, loadavg5, loadavg15}</li> +-- <li>totalram = total RAM</li> +-- <li>freeram = free RAM</li> +-- <li>sharedram = shared RAM</li> +-- <li>bufferram = buffered RAM</li> +-- <li>totalswap = total SWAP</li> +-- <li>freeswap = free SWAP</li> +-- <li>procs = number of running processes</li> +-- </ul> + +--- Create a new socket. +-- @class function +-- @name nixio.socket +-- @param domain Domain ["inet", "inet6", "unix"] +-- @param type Type ["stream", "dgram", "raw"] +-- @return Socket Object + +--- (POSIX) Send data from a file to a socket in kernel-space. +-- @class function +-- @name nixio.sendfile +-- @param socket Socket Object +-- @param file File Object +-- @param length Amount of data to send (in Bytes). +-- @return bytes sent + +--- (Linux) Send data from / to a pipe in kernel-space. +-- @class function +-- @name nixio.splice +-- @param fdin Input I/O descriptor +-- @param fdout Output I/O descriptor +-- @param length Amount of data to send (in Bytes). +-- @param flags (optional, bitfield generated by splice_flags) +-- @see nixio.splice_flags +-- @return bytes sent + +--- (Linux) Generate a flag bitfield for a call to splice. +-- @class function +-- @name nixio.splice_flags +-- @param flag1 First Flag ["move", "nonblock", "more"] +-- @param ... More flags [-"-] +-- @see nixio.splice +-- @return Flag bitfield + +--- (POSIX) Open a connection to the system logger. +-- @class function +-- @name nixio.openlog +-- @param ident Identifier +-- @param flag1 Flag 1 ["cons", "nowait", "pid", "perror", "ndelay", "odelay"] +-- @param ... More flags [-"-] + +--- (POSIX) Close the connection to the system logger. +-- @class function +-- @name nixio.closelog + +--- (POSIX) Write a message to the system logger. +-- @class function +-- @name nixio.syslog +-- @param priority Priority ["emerg", "alert", "crit", "err", "warning", +-- "notice", "info", "debug"] +-- @param message + +--- (POSIX) Set the logmask of the system logger for current process. +-- @class function +-- @name nixio.setlogmask +-- @param priority Priority ["emerg", "alert", "crit", "err", "warning", +-- "notice", "info", "debug"] + +--- (POSIX) Encrypt a user password. +-- @class function +-- @name nixio.crypt +-- @param key Key +-- @param salt Salt +-- @return password hash + +--- (POSIX) Get all or a specific user group. +-- @class function +-- @name nixio.getgr +-- @param group Group ID or groupname (optional) +-- @return Table containing: <ul> +-- <li>name = Group Name</li> +-- <li>gid = Group ID</li> +-- <li>passwd = Password</li> +-- <li>mem = {Member #1, Member #2, ...}</li> +-- </ul> + +--- (POSIX) Get all or a specific user account. +-- @class function +-- @name nixio.getpw +-- @param user User ID or username (optional) +-- @return Table containing: <ul> +-- <li>name = Name</li> +-- <li>uid = ID</li> +-- <li>gid = Group ID</li> +-- <li>passwd = Password</li> +-- <li>dir = Home directory</li> +-- <li>gecos = Information</li> +-- <li>shell = Shell</li> +-- </ul> + +--- (Linux, Solaris) Get all or a specific shadow password entry. +-- @class function +-- @name nixio.getsp +-- @param user username (optional) +-- @return Table containing: <ul> +-- <li>namp = Name</li> +-- <li>expire = Expiration Date</li> +-- <li>flag = Flags</li> +-- <li>inact = Inactivity Date</li> +-- <li>lstchg = Last change</li> +-- <li>max = Maximum</li> +-- <li>min = Minimum</li> +-- <li>warn = Warning</li> +-- <li>pwdp = Password Hash</li> +-- </ul> + +--- Create a new TLS context. +-- @class function +-- @name nixio.tls +-- @return TLSContext Object
\ No newline at end of file diff --git a/libs/nixio/lua/bit.lua b/libs/nixio/lua/bit.lua new file mode 100644 index 000000000..cdfecb1a4 --- /dev/null +++ b/libs/nixio/lua/bit.lua @@ -0,0 +1,15 @@ +--[[ +nixio - Linux I/O library for lua + +Copyright 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 + +$Id$ +]]-- + +return require "nixio".bit
\ No newline at end of file diff --git a/libs/nixio/lua/nixio/fs.lua b/libs/nixio/lua/nixio/fs.lua new file mode 100644 index 000000000..f745ffe78 --- /dev/null +++ b/libs/nixio/lua/nixio/fs.lua @@ -0,0 +1,175 @@ +--[[ +nixio - Linux I/O library for lua + +Copyright 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 + +$Id$ +]]-- + +local table = require "table" +local nixio = require "nixio" +local type, ipairs, setmetatable = type, ipairs, setmetatable +require "nixio.util" + + +module ("nixio.fs", function(m) setmetatable(m, {__index = nixio.fs}) end) + + +function readfile(path, limit) + local fd, code, msg = nixio.open(path, "r") + local data + if not fd then + return nil, code, msg + end + + data, code, msg = fd:readall(limit) + + fd:close() + return data, code, msg +end + + +function writefile(path, data) + local fd, code, msg, stat = nixio.open(path, "w") + if not fd then + return nil, code, msg + end + + stat, code, msg = fd:writeall(data) + + fd:close() + return stat, code, msg +end + +function datacopy(src, dest, size) + local fdin, code, msg = nixio.open(src, "r") + if not fdin then + return nil, code, msg + end + + local fdout, code, msg = nixio.open(dest, "w") + if not fdout then + return nil, code, msg + end + + local stat, code, msg, sent = fdin:copy(fdout, size) + fdin:close() + fdout:close() + + return stat, code, msg, sent +end + +function copy(src, dest) + local stat, code, msg, res = nixio.lstat(src) + if not stat then + return nil, code, msg + end + + if stat.type == "dir" then + if nixio.stat(dest, type) ~= "dir" then + res, code, msg = nixio.mkdir(dest) + else + stat = true + end + elseif stat.type == "lnk" then + res, code, msg = nixio.symlink(nixio.readlink(src), dest) + else + res, code, msg = datacopy(src, dest) + end + + if not res then + return nil, code, msg + end + + nixio.utimes(dest, stat.atime, stat.mtime) + + if nixio.lchown then + nixio.lchown(dest, stat.uid, stat.gid) + end + + if stat.type ~= "lnk" then + nixio.chmod(dest, stat.modedec) + end + + return true +end + +function move(src, dest) + local stat, code, msg = nixio.rename(src, dest) + if not stat and code == nixio.const.EXDEV then + stat, code, msg = nixio.copy(src, dest) + if stat then + stat, code, msg = nixio.unlink(src) + end + end + return stat, code, msg +end + +function mkdirr(dest, mode) + if nixio.stat(dest, "type") == "dir" then + return true + else + local stat, code, msg = nixio.mkdir(dest, mode) + if not stat and code == nixio.const.ENOENT then + stat, code, msg = mkdirr(nixio.dirname(dest), mode) + if stat then + stat, code, msg = nixio.mkdir(dest, mode) + end + end + return stat, code, msg + end +end + +local function _recurse(cb, src, dest) + local type = nixio.lstat(src, "type") + if type ~= "dir" then + return cb(src, dest) + else + local stat, se, code, msg, s, c, m = true, nixio.const.sep + if dest then + s, c, m = cb(src, dest) + stat, code, msg = stat and s, c or code, m or msg + end + + for e in nixio.dir(src) do + if dest then + s, c, m = _recurse(cb, src .. se .. e, dest .. se .. e) + else + s, c, m = _recurse(cb, src .. se .. e) + end + stat, code, msg = stat and s, c or code, m or msg + end + + if not dest then -- Postfix + s, c, m = cb(src) + stat, code, msg = stat and s, c or code, m or msg + end + + return stat, code, msg + end +end + +function copyr(src, dest) + return _recurse(copy, src, dest) +end + +function mover(src, dest) + local stat, code, msg = nixio.rename(src, dest) + if not stat and code == nixio.const.EXDEV then + stat, code, msg = _recurse(copy, src, dest) + if stat then + stat, code, msg = _recurse(nixio.remove, src) + end + end + return stat, code, msg +end + +function remover(src) + return _recurse(nixio.remove, src) +end
\ No newline at end of file diff --git a/libs/nixio/lua/nixio/util.lua b/libs/nixio/lua/nixio/util.lua index 59bdce8f4..2c9fc93a3 100644 --- a/libs/nixio/lua/nixio/util.lua +++ b/libs/nixio/lua/nixio/util.lua @@ -18,11 +18,20 @@ local getmetatable, assert, pairs = getmetatable, assert, pairs module "nixio.util" -local BUFFERSIZE = 8096 +local BUFFERSIZE = nixio.const.buffersize +local ZIOBLKSIZE = 65536 local socket = nixio.meta_socket local tls_socket = nixio.meta_tls_socket local file = nixio.meta_file +function consume(iter) + local tbl = {} + for obj in iter do + tbl[#tbl+1] = obj + end + return tbl +end + local meta = {} function meta.is_socket(self) @@ -38,50 +47,53 @@ function meta.is_file(self) end function meta.readall(self, len) - local block, code, msg = self:read(len) + local block, code, msg = self:read(len or BUFFERSIZE) if not block then - return "", code, msg, len + return nil, code, msg, "" elseif #block == 0 then - return "", nil, nil, len + return "", nil, nil, "" end local data, total = {block}, #block - while len > total do - block, code, msg = self:read(len - total) + while not len or len > total do + block, code, msg = self:read(len and (len - total) or BUFFERSIZE) if not block then - return data, code, msg, len - #data + return nil, code, msg, table.concat(data) elseif #block == 0 then - return data, nil, nil, len - #data + break end data[#data+1], total = block, total + #block end - return (#data > 1 and table.concat(data) or data[1]), nil, nil, 0 + local data = #data > 1 and table.concat(data) or data[1] + return data, nil, nil, data end meta.recvall = meta.readall function meta.writeall(self, data) - local total, block = 0 local sent, code, msg = self:write(data) if not sent then - return total, code, msg, data + return nil, code, msg, 0 end - while sent < #data do - block, total = data:sub(sent + 1), total + sent - sent, code, msg = self:write(block) - + local total = sent + + while total < #data do + sent, code, msg = self:write(data, total) + if not sent then - return total, code, msg, block + return nil, code, msg, total end + + total = total + sent end - return total + sent, nil, nil, "" + return total, nil, nil, total end meta.sendall = meta.writeall @@ -105,9 +117,9 @@ function meta.linesource(self, limit) bpos = endp return line elseif #buffer < limit + bpos then - local newblock, code = self:read(limit + bpos - #buffer) + local newblock, code, msg = self:read(limit + bpos - #buffer) if not newblock then - return nil, code + return nil, code, msg elseif #newblock == 0 then return nil end @@ -135,7 +147,7 @@ function meta.blocksource(self, bs, limit) local block, code, msg = self:read(toread) if not block then - return nil, code + return nil, code, msg elseif #block == 0 then return nil else @@ -162,6 +174,40 @@ function meta.sink(self, close) end end +function meta.copy(self, fdout, size) + local source = self:blocksource(nil, size) + local sink = fdout:sink() + local sent, chunk, code, msg = 0 + + repeat + chunk, code, msg = source() + sink(chunk, code, msg) + sent = chunk and (sent + #chunk) or sent + until not chunk + return not code and sent or nil, code, msg, sent +end + +function meta.copyz(self, fd, size) + local sent, lsent, code, msg = 0 + if self:is_file() then + if nixio.sendfile and fd:is_socket() and self:stat("type") == "reg" then + repeat + lsent, code, msg = nixio.sendfile(fd, self, size or ZIOBLKSIZE) + if lsent then + sent = sent + lsent + size = size and (size - lsent) + end + until (not lsent or lsent == 0 or (size and size == 0)) + if lsent or (not lsent and sent == 0 and + code ~= nixio.const.ENOSYS and code ~= nixio.const.EINVAL) then + return lsent and sent, code, msg, sent + end + end + end + + return self:copy(fd, size) +end + function tls_socket.close(self) return self.socket:close() end diff --git a/libs/nixio/src/address.c b/libs/nixio/src/address.c index 8b9ae2807..835a8a2f9 100644 --- a/libs/nixio/src/address.c +++ b/libs/nixio/src/address.c @@ -18,16 +18,79 @@ #include "nixio.h" #include <sys/types.h> -#include <sys/socket.h> -#include <arpa/inet.h> -#include <netinet/in.h> +#include <errno.h> #include <string.h> -#include <netdb.h> #ifndef NI_MAXHOST #define NI_MAXHOST 1025 #endif +/** + * address pushing helper + */ +int nixio__addr_parse(nixio_addr *addr, struct sockaddr *saddr) { + void *baddr; + + addr->family = saddr->sa_family; + if (saddr->sa_family == AF_INET) { + struct sockaddr_in *inetaddr = (struct sockaddr_in*)saddr; + addr->port = ntohs(inetaddr->sin_port); + baddr = &inetaddr->sin_addr; + } else if (saddr->sa_family == AF_INET6) { + struct sockaddr_in6 *inet6addr = (struct sockaddr_in6*)saddr; + addr->port = ntohs(inet6addr->sin6_port); + baddr = &inet6addr->sin6_addr; + } else { + errno = EAFNOSUPPORT; + return -1; + } + + if (!inet_ntop(saddr->sa_family, baddr, addr->host, sizeof(addr->host))) { + return -1; + } + + return 0; +} + +/** + * address pulling helper + */ +int nixio__addr_write(nixio_addr *addr, struct sockaddr *saddr) { + if (addr->family == AF_UNSPEC) { + if (strchr(addr->host, ':')) { + addr->family = AF_INET6; + } else { + addr->family = AF_INET; + } + } + if (addr->family == AF_INET) { + struct sockaddr_in *inetaddr = (struct sockaddr_in *)saddr; + memset(inetaddr, 0, sizeof(struct sockaddr_in)); + + if (inet_pton(AF_INET, addr->host, &inetaddr->sin_addr) < 1) { + return -1; + } + + inetaddr->sin_family = AF_INET; + inetaddr->sin_port = htons((uint16_t)addr->port); + return 0; + } else if (addr->family == AF_INET6) { + struct sockaddr_in6 *inet6addr = (struct sockaddr_in6 *)saddr; + memset(inet6addr, 0, sizeof(struct sockaddr_in6)); + + if (inet_pton(AF_INET6, addr->host, &inet6addr->sin6_addr) < 1) { + return -1; + } + + inet6addr->sin6_family = AF_INET6; + inet6addr->sin6_port = htons((uint16_t)addr->port); + return 0; + } else { + errno = EAFNOSUPPORT; + return -1; + } +} + /** * getaddrinfo(host, family, port) @@ -70,9 +133,11 @@ static int nixio_getaddrinfo(lua_State *L) { for (rp = result; rp != NULL; rp = rp->ai_next) { /* avoid duplicate results */ +#ifndef __WINNT__ if (!port && rp->ai_socktype != SOCK_STREAM) { continue; } +#endif if (rp->ai_family == AF_INET || rp->ai_family == AF_INET6) { lua_createtable(L, 0, port ? 4 : 2); @@ -101,31 +166,18 @@ static int nixio_getaddrinfo(lua_State *L) { lua_setfield(L, -2, "socktype"); } - char ip[INET6_ADDRSTRLEN]; - void *binaddr = NULL; - uint16_t binport = 0; - - if (rp->ai_family == AF_INET) { - struct sockaddr_in *v4addr = (struct sockaddr_in*)rp->ai_addr; - binport = v4addr->sin_port; - binaddr = (void *)&v4addr->sin_addr; - } else if (rp->ai_family == AF_INET6) { - struct sockaddr_in6 *v6addr = (struct sockaddr_in6*)rp->ai_addr; - binport = v6addr->sin6_port; - binaddr = (void *)&v6addr->sin6_addr; - } - - if (!inet_ntop(rp->ai_family, binaddr, ip, sizeof(ip))) { + nixio_addr addr; + if (nixio__addr_parse(&addr, rp->ai_addr)) { freeaddrinfo(result); - return nixio__perror(L); + return nixio__perror_s(L); } if (port) { - lua_pushinteger(L, ntohs(binport)); + lua_pushinteger(L, addr.port); lua_setfield(L, -2, "port"); } - lua_pushstring(L, ip); + lua_pushstring(L, addr.host); lua_setfield(L, -2, "address"); lua_rawseti(L, -2, i++); } @@ -140,37 +192,29 @@ static int nixio_getaddrinfo(lua_State *L) { * getnameinfo(address, family) */ static int nixio_getnameinfo(lua_State *L) { - const char *ip = luaL_checklstring(L, 1, NULL); - const char *family = luaL_optlstring(L, 2, "inet", NULL); + const char *ip = luaL_checkstring(L, 1); + const char *family = luaL_optstring(L, 2, NULL); char host[NI_MAXHOST]; - struct sockaddr *addr = NULL; - socklen_t alen = 0; - int res; + struct sockaddr_storage saddr; + nixio_addr addr; + memset(&addr, 0, sizeof(addr)); + strncpy(addr.host, ip, sizeof(addr.host) - 1); - if (!strcmp(family, "inet")) { - struct sockaddr_in inetaddr; - memset(&inetaddr, 0, sizeof(inetaddr)); - inetaddr.sin_family = AF_INET; - if (inet_pton(AF_INET, ip, &inetaddr.sin_addr) < 1) { - return luaL_argerror(L, 1, "invalid address"); - } - alen = sizeof(inetaddr); - addr = (struct sockaddr *)&inetaddr; + if (!family) { + addr.family = AF_UNSPEC; + } else if (!strcmp(family, "inet")) { + addr.family = AF_INET; } else if (!strcmp(family, "inet6")) { - struct sockaddr_in6 inet6addr; - memset(&inet6addr, 0, sizeof(inet6addr)); - inet6addr.sin6_family = AF_INET6; - if (inet_pton(AF_INET6, ip, &inet6addr.sin6_addr) < 1) { - return luaL_argerror(L, 1, "invalid address"); - } - alen = sizeof(inet6addr); - addr = (struct sockaddr *)&inet6addr; + addr.family = AF_INET6; } else { return luaL_argerror(L, 2, "supported values: inet, inet6"); } - res = getnameinfo(addr, alen, host, sizeof(host), NULL, 0, NI_NAMEREQD); + nixio__addr_write(&addr, (struct sockaddr *)&saddr); + + int res = getnameinfo((struct sockaddr *)&saddr, sizeof(saddr), + host, sizeof(host), NULL, 0, NI_NAMEREQD); if (res) { lua_pushnil(L); lua_pushinteger(L, res); @@ -183,59 +227,41 @@ static int nixio_getnameinfo(lua_State *L) { } /** - * getsockname() / getpeername() helper + * getsockname() */ -static int nixio_sock__getname(lua_State *L, int sock) { +static int nixio_sock_getsockname(lua_State *L) { int sockfd = nixio__checksockfd(L); - struct sockaddr_storage addr; - socklen_t addrlen = sizeof(addr); - char ipaddr[INET6_ADDRSTRLEN]; - void *binaddr; - uint16_t port; - - if (sock) { - if (getsockname(sockfd, (struct sockaddr*)&addr, &addrlen)) { - return nixio__perror(L); - } - } else { - if (getpeername(sockfd, (struct sockaddr*)&addr, &addrlen)) { - return nixio__perror(L); - } - } - - if (addr.ss_family == AF_INET) { - struct sockaddr_in *inetaddr = (struct sockaddr_in*)&addr; - port = inetaddr->sin_port; - binaddr = &inetaddr->sin_addr; - } else if (addr.ss_family == AF_INET6) { - struct sockaddr_in6 *inet6addr = (struct sockaddr_in6*)&addr; - port = inet6addr->sin6_port; - binaddr = &inet6addr->sin6_addr; - } else { - return luaL_error(L, "unknown address family"); - } + struct sockaddr_storage saddr; + socklen_t addrlen = sizeof(saddr); + nixio_addr addr; - if (!inet_ntop(addr.ss_family, binaddr, ipaddr, sizeof(ipaddr))) { - return nixio__perror(L); + if (getsockname(sockfd, (struct sockaddr*)&saddr, &addrlen) || + nixio__addr_parse(&addr, (struct sockaddr*)&saddr)) { + return nixio__perror_s(L); } - lua_pushstring(L, ipaddr); - lua_pushinteger(L, ntohs(port)); + lua_pushstring(L, addr.host); + lua_pushnumber(L, addr.port); return 2; } /** - * getsockname() - */ -static int nixio_sock_getsockname(lua_State *L) { - return nixio_sock__getname(L, 1); -} - -/** * getpeername() */ static int nixio_sock_getpeername(lua_State *L) { - return nixio_sock__getname(L, 0); + int sockfd = nixio__checksockfd(L); + struct sockaddr_storage saddr; + socklen_t addrlen = sizeof(saddr); + nixio_addr addr; + + if (getpeername(sockfd, (struct sockaddr*)&saddr, &addrlen) || + nixio__addr_parse(&addr, (struct sockaddr*)&saddr)) { + return nixio__perror_s(L); + } + + lua_pushstring(L, addr.host); + lua_pushnumber(L, addr.port); + return 2; } diff --git a/libs/nixio/src/axtls-compat.c b/libs/nixio/src/axtls-compat.c new file mode 100644 index 000000000..2c5b746c2 --- /dev/null +++ b/libs/nixio/src/axtls-compat.c @@ -0,0 +1,297 @@ +/* + * Copyright (c) 2007, Cameron Rich + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * * Neither the name of the axTLS project nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Enable a subset of openssl compatible functions. We don't aim to be 100% + * compatible - just to be able to do basic ports etc. + * + * Only really tested on mini_httpd, so I'm not too sure how extensive this + * port is. + */ + +#include "config.h" + +#include <stdlib.h> +#include <string.h> +#include <stdarg.h> +#include "ssl.h" + +static char *key_password = NULL; + +void *SSLv23_server_method(void) { return NULL; } +void *SSLv3_server_method(void) { return NULL; } +void *TLSv1_server_method(void) { return NULL; } +void *SSLv23_client_method(void) { return NULL; } +void *SSLv3_client_method(void) { return NULL; } +void *TLSv1_client_method(void) { return NULL; } +void *SSLv23_method(void) { return NULL; } +void *TLSv1_method(void) { return NULL; } + +SSL_CTX * SSL_CTX_new(void *meth) +{ + SSL_CTX *ssl_ctx = ssl_ctx_new(SSL_SERVER_VERIFY_LATER, 5); + return ssl_ctx; +} + +void SSL_CTX_free(SSL_CTX * ssl_ctx) +{ + ssl_ctx_free(ssl_ctx); +} + +SSL * SSL_new(SSL_CTX *ssl_ctx) +{ + SSL *ssl; + + ssl = ssl_new(ssl_ctx, -1); /* fd is set later */ + + return ssl; +} + +int SSL_set_fd(SSL *s, int fd) +{ + s->client_fd = fd; + return 1; /* always succeeds */ +} + +int SSL_accept(SSL *ssl) +{ + ssl->next_state = HS_CLIENT_HELLO; + while (ssl_read(ssl, NULL) == SSL_OK) + { + if (ssl->next_state == HS_CLIENT_HELLO) + return 1; /* we're done */ + } + + return -1; +} + +int SSL_connect(SSL *ssl) +{ + SET_SSL_FLAG(SSL_IS_CLIENT); + int stat = do_client_connect(ssl); + ssl_display_error(stat); + return (stat == SSL_OK) ? 1 : -1; +} + +void SSL_free(SSL *ssl) +{ + ssl_free(ssl); +} + +int SSL_read(SSL *ssl, void *buf, int num) +{ + uint8_t *read_buf; + int ret; + + while ((ret = ssl_read(ssl, &read_buf)) == SSL_OK); + + if (ret > SSL_OK) + { + memcpy(buf, read_buf, ret > num ? num : ret); + } + + return ret; +} + +int SSL_write(SSL *ssl, const void *buf, int num) +{ + return ssl_write(ssl, buf, num); +} + +int SSL_CTX_use_certificate_file(SSL_CTX *ssl_ctx, const char *file, int type) +{ + return (ssl_obj_load(ssl_ctx, SSL_OBJ_X509_CERT, file, NULL) == SSL_OK); +} + +int SSL_CTX_use_PrivateKey_file(SSL_CTX *ssl_ctx, const char *file, int type) +{ + return (ssl_obj_load(ssl_ctx, SSL_OBJ_RSA_KEY, file, key_password) == SSL_OK); +} + +int SSL_CTX_use_certificate_ASN1(SSL_CTX *ssl_ctx, int len, const uint8_t *d) +{ + return (ssl_obj_memory_load(ssl_ctx, + SSL_OBJ_X509_CERT, d, len, NULL) == SSL_OK); +} + +int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx, + unsigned int sid_ctx_len) +{ + return 1; +} + +int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx) +{ + return 1; +} + +int SSL_CTX_use_certificate_chain_file(SSL_CTX *ssl_ctx, const char *file) +{ + return (ssl_obj_load(ssl_ctx, + SSL_OBJ_X509_CERT, file, NULL) == SSL_OK); +} + +int SSL_shutdown(SSL *ssl) +{ + return 1; +} + +/*** get/set session ***/ +SSL_SESSION *SSL_get1_session(SSL *ssl) +{ + return (SSL_SESSION *)ssl_get_session_id(ssl); /* note: wrong cast */ +} + +int SSL_set_session(SSL *ssl, SSL_SESSION *session) +{ + memcpy(ssl->session_id, (uint8_t *)session, SSL_SESSION_ID_SIZE); + return 1; +} + +void SSL_SESSION_free(SSL_SESSION *session) { } +/*** end get/set session ***/ + +long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg) +{ + return 0; +} + +void SSL_CTX_set_verify(SSL_CTX *ctx, int mode, + int (*verify_callback)(int, void *)) { + if (mode & SSL_VERIFY_PEER) { + ctx->options &= ~SSL_SERVER_VERIFY_LATER; + ctx->options |= SSL_CLIENT_AUTHENTICATION; + } else { + ctx->options |= SSL_SERVER_VERIFY_LATER; + ctx->options &= ~SSL_CLIENT_AUTHENTICATION; + } +} + +void SSL_CTX_set_verify_depth(SSL_CTX *ctx,int depth) { } + +int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile, + const char *CApath) +{ + return 1; +} + +void *SSL_load_client_CA_file(const char *file) +{ + return (void *)file; +} + +void SSL_CTX_set_client_CA_list(SSL_CTX *ssl_ctx, void *file) +{ + + ssl_obj_load(ssl_ctx, SSL_OBJ_X509_CERT, (const char *)file, NULL); +} + +void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, void *cb) { } + +void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u) +{ + key_password = (char *)u; +} + +int SSL_peek(SSL *ssl, void *buf, int num) +{ + memcpy(buf, ssl->bm_data, num); + return num; +} + +void SSL_set_bio(SSL *ssl, void *rbio, void *wbio) { } + +long SSL_get_verify_result(const SSL *ssl) +{ + return ssl_handshake_status(ssl); +} + +int SSL_state(SSL *ssl) +{ + return 0x03; // ok state +} + +/** end of could do better list */ + +void *SSL_get_peer_certificate(const SSL *ssl) +{ + return &ssl->ssl_ctx->certs[0]; +} + +int SSL_clear(SSL *ssl) +{ + return 1; +} + + +int SSL_CTX_check_private_key(const SSL_CTX *ctx) +{ + return 1; +} + +int SSL_CTX_set_cipher_list(SSL_CTX *s, const char *str) +{ + return 1; +} + +int SSL_get_error(const SSL *ssl, int ret) +{ + ssl_display_error(ret); + return ret; /* TODO: return proper return code */ +} + +void SSL_CTX_set_options(SSL_CTX *ssl_ctx, int option) {} +int SSL_library_init(void ) { return 1; } +void SSL_load_error_strings(void ) {} +void ERR_print_errors_fp(FILE *fp) {} + +long SSL_CTX_get_timeout(const SSL_CTX *ssl_ctx) { + return CONFIG_SSL_EXPIRY_TIME*3600; } +long SSL_CTX_set_timeout(SSL_CTX *ssl_ctx, long t) { + return SSL_CTX_get_timeout(ssl_ctx); } +void BIO_printf(FILE *f, const char *format, ...) +{ + va_list(ap); + va_start(ap, format); + vfprintf(f, format, ap); + va_end(ap); +} + +void* BIO_s_null(void) { return NULL; } +FILE *BIO_new(bio_func_type_t func) +{ + if (func == BIO_s_null) + return fopen("/dev/null", "r"); + else + return NULL; +} + +FILE *BIO_new_fp(FILE *stream, int close_flag) { return stream; } +int BIO_free(FILE *a) { if (a != stdout && a != stderr) fclose(a); return 1; } diff --git a/libs/nixio/src/axtls-compat.h b/libs/nixio/src/axtls-compat.h new file mode 100644 index 000000000..77533ef4f --- /dev/null +++ b/libs/nixio/src/axtls-compat.h @@ -0,0 +1,149 @@ +/* + * Copyright (c) 2007, Cameron Rich + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * * Neither the name of the axTLS project nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Enable a subset of openssl compatible functions. We don't aim to be 100% + * compatible - just to be able to do basic ports etc. + * + * Only really tested on mini_httpd, so I'm not too sure how extensive this + * port is. + */ + +#include "nixio.h" +#include "config.h" + +#define WITH_AXTLS 1 +#define WITHOUT_OPENSSL 1 +#define SSL_OP_NO_SSLv3 0x02000000L +#define SSL_OP_NO_SSLv2 0x01000000L +#define SSL_FILETYPE_PEM 1 +#define SSL_VERIFY_NONE 0x00 +#define SSL_VERIFY_PEER 0x01 +#define SSL_VERIFY_FAIL_IF_NO_PEER_CERT 0x02 +#define SSL_VERIFY_CLIENT_ONCE 0x03 +#define MD5_DIGEST_LENGTH 16 +#define SHA_DIGEST_LENGTH 20 + +#include <stdlib.h> +#include <string.h> +#include <stdarg.h> +#include "ssl.h" + +typedef SHA1_CTX SHA_CTX; + +void *SSLv23_server_method(void); +void *SSLv3_server_method(void); +void *TLSv1_server_method(void); +void *SSLv23_client_method(void); +void *SSLv3_client_method(void); +void *TLSv1_client_method(void); +void *SSLv23_method(void); +void *TLSv1_method(void); + + +typedef void * (*ssl_func_type_t)(void); +typedef void * (*bio_func_type_t)(void); + +SSL_CTX * SSL_CTX_new(void *meth); +void SSL_CTX_free(SSL_CTX * ssl_ctx); +SSL * SSL_new(SSL_CTX *ssl_ctx); +int SSL_set_fd(SSL *s, int fd); +int SSL_accept(SSL *ssl); +int SSL_connect(SSL *ssl); +void SSL_free(SSL *ssl); +int SSL_read(SSL *ssl, void *buf, int num); +int SSL_write(SSL *ssl, const void *buf, int num); +int SSL_CTX_use_certificate_file(SSL_CTX *ssl_ctx, const char *file, int type); +int SSL_CTX_use_PrivateKey_file(SSL_CTX *ssl_ctx, const char *file, int type); +int SSL_CTX_use_certificate_ASN1(SSL_CTX *ssl_ctx, int len, const uint8_t *d); +int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx, + unsigned int sid_ctx_len); +int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx); +int SSL_CTX_use_certificate_chain_file(SSL_CTX *ssl_ctx, const char *file); +int SSL_shutdown(SSL *ssl); + +/*** get/set session ***/ +SSL_SESSION *SSL_get1_session(SSL *ssl); +int SSL_set_session(SSL *ssl, SSL_SESSION *session); +void SSL_SESSION_free(SSL_SESSION *session); +/*** end get/set session ***/ + +long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg); +void SSL_CTX_set_verify(SSL_CTX *ctx, int mode, + int (*verify_callback)(int, void *)); + +void SSL_CTX_set_verify_depth(SSL_CTX *ctx,int depth); + +int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile, + const char *CApath); + +void *SSL_load_client_CA_file(const char *file); + +void SSL_CTX_set_client_CA_list(SSL_CTX *ssl_ctx, void *file); + +void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, void *cb); + +void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u); + +int SSL_peek(SSL *ssl, void *buf, int num); + +void SSL_set_bio(SSL *ssl, void *rbio, void *wbio); + +long SSL_get_verify_result(const SSL *ssl); + +int SSL_state(SSL *ssl); + +/** end of could do better list */ + +void *SSL_get_peer_certificate(const SSL *ssl); + +int SSL_clear(SSL *ssl); + + +int SSL_CTX_check_private_key(const SSL_CTX *ctx); + +int SSL_CTX_set_cipher_list(SSL_CTX *s, const char *str); + +int SSL_get_error(const SSL *ssl, int ret); + +void SSL_CTX_set_options(SSL_CTX *ssl_ctx, int option); +int SSL_library_init(void ); +void SSL_load_error_strings(void ); +void ERR_print_errors_fp(FILE *fp); + +long SSL_CTX_get_timeout(const SSL_CTX *ssl_ctx); +long SSL_CTX_set_timeout(SSL_CTX *ssl_ctx, long t); +void BIO_printf(FILE *f, const char *format, ...); + +void* BIO_s_null(void); +FILE *BIO_new(bio_func_type_t func); + +FILE *BIO_new_fp(FILE *stream, int close_flag); +int BIO_free(FILE *a); diff --git a/libs/nixio/src/binary.c b/libs/nixio/src/binary.c new file mode 100644 index 000000000..72425b113 --- /dev/null +++ b/libs/nixio/src/binary.c @@ -0,0 +1,313 @@ +/* + * 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.h" +#include <stdlib.h> + +static char nixio__bin2hex[] = { +'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' +}; + +static unsigned char nixio__b64encode_tbl[] = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +static unsigned char nixio__b64decode_tbl[] = { + 0x3e, 0xff, 0xff, 0xff, 0x3f, 0x34, 0x35, 0x36, + 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, + 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, + 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, + 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1a, 0x1b, + 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, + 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, + 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33 +}; + +static const uint32_t nixio__crc32_tbl[] = { + 0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U, + 0x706af48fU, 0xe963a535U, 0x9e6495a3U, 0x0edb8832U, 0x79dcb8a4U, + 0xe0d5e91eU, 0x97d2d988U, 0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U, + 0x90bf1d91U, 0x1db71064U, 0x6ab020f2U, 0xf3b97148U, 0x84be41deU, + 0x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U, 0x83d385c7U, 0x136c9856U, + 0x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU, 0x63066cd9U, + 0xfa0f3d63U, 0x8d080df5U, 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U, + 0xa2677172U, 0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU, + 0x35b5a8faU, 0x42b2986cU, 0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U, + 0x45df5c75U, 0xdcd60dcfU, 0xabd13d59U, 0x26d930acU, 0x51de003aU, + 0xc8d75180U, 0xbfd06116U, 0x21b4f4b5U, 0x56b3c423U, 0xcfba9599U, + 0xb8bda50fU, 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U, 0xb10be924U, + 0x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU, 0x76dc4190U, + 0x01db7106U, 0x98d220bcU, 0xefd5102aU, 0x71b18589U, 0x06b6b51fU, + 0x9fbfe4a5U, 0xe8b8d433U, 0x7807c9a2U, 0x0f00f934U, 0x9609a88eU, + 0xe10e9818U, 0x7f6a0dbbU, 0x086d3d2dU, 0x91646c97U, 0xe6635c01U, + 0x6b6b51f4U, 0x1c6c6162U, 0x856530d8U, 0xf262004eU, 0x6c0695edU, + 0x1b01a57bU, 0x8208f4c1U, 0xf50fc457U, 0x65b0d9c6U, 0x12b7e950U, + 0x8bbeb8eaU, 0xfcb9887cU, 0x62dd1ddfU, 0x15da2d49U, 0x8cd37cf3U, + 0xfbd44c65U, 0x4db26158U, 0x3ab551ceU, 0xa3bc0074U, 0xd4bb30e2U, + 0x4adfa541U, 0x3dd895d7U, 0xa4d1c46dU, 0xd3d6f4fbU, 0x4369e96aU, + 0x346ed9fcU, 0xad678846U, 0xda60b8d0U, 0x44042d73U, 0x33031de5U, + 0xaa0a4c5fU, 0xdd0d7cc9U, 0x5005713cU, 0x270241aaU, 0xbe0b1010U, + 0xc90c2086U, 0x5768b525U, 0x206f85b3U, 0xb966d409U, 0xce61e49fU, + 0x5edef90eU, 0x29d9c998U, 0xb0d09822U, 0xc7d7a8b4U, 0x59b33d17U, + 0x2eb40d81U, 0xb7bd5c3bU, 0xc0ba6cadU, 0xedb88320U, 0x9abfb3b6U, + 0x03b6e20cU, 0x74b1d29aU, 0xead54739U, 0x9dd277afU, 0x04db2615U, + 0x73dc1683U, 0xe3630b12U, 0x94643b84U, 0x0d6d6a3eU, 0x7a6a5aa8U, + 0xe40ecf0bU, 0x9309ff9dU, 0x0a00ae27U, 0x7d079eb1U, 0xf00f9344U, + 0x8708a3d2U, 0x1e01f268U, 0x6906c2feU, 0xf762575dU, 0x806567cbU, + 0x196c3671U, 0x6e6b06e7U, 0xfed41b76U, 0x89d32be0U, 0x10da7a5aU, + 0x67dd4accU, 0xf9b9df6fU, 0x8ebeeff9U, 0x17b7be43U, 0x60b08ed5U, + 0xd6d6a3e8U, 0xa1d1937eU, 0x38d8c2c4U, 0x4fdff252U, 0xd1bb67f1U, + 0xa6bc5767U, 0x3fb506ddU, 0x48b2364bU, 0xd80d2bdaU, 0xaf0a1b4cU, + 0x36034af6U, 0x41047a60U, 0xdf60efc3U, 0xa867df55U, 0x316e8eefU, + 0x4669be79U, 0xcb61b38cU, 0xbc66831aU, 0x256fd2a0U, 0x5268e236U, + 0xcc0c7795U, 0xbb0b4703U, 0x220216b9U, 0x5505262fU, 0xc5ba3bbeU, + 0xb2bd0b28U, 0x2bb45a92U, 0x5cb36a04U, 0xc2d7ffa7U, 0xb5d0cf31U, + 0x2cd99e8bU, 0x5bdeae1dU, 0x9b64c2b0U, 0xec63f226U, 0x756aa39cU, + 0x026d930aU, 0x9c0906a9U, 0xeb0e363fU, 0x72076785U, 0x05005713U, + 0x95bf4a82U, 0xe2b87a14U, 0x7bb12baeU, 0x0cb61b38U, 0x92d28e9bU, + 0xe5d5be0dU, 0x7cdcefb7U, 0x0bdbdf21U, 0x86d3d2d4U, 0xf1d4e242U, + 0x68ddb3f8U, 0x1fda836eU, 0x81be16cdU, 0xf6b9265bU, 0x6fb077e1U, + 0x18b74777U, 0x88085ae6U, 0xff0f6a70U, 0x66063bcaU, 0x11010b5cU, + 0x8f659effU, 0xf862ae69U, 0x616bffd3U, 0x166ccf45U, 0xa00ae278U, + 0xd70dd2eeU, 0x4e048354U, 0x3903b3c2U, 0xa7672661U, 0xd06016f7U, + 0x4969474dU, 0x3e6e77dbU, 0xaed16a4aU, 0xd9d65adcU, 0x40df0b66U, + 0x37d83bf0U, 0xa9bcae53U, 0xdebb9ec5U, 0x47b2cf7fU, 0x30b5ffe9U, + 0xbdbdf21cU, 0xcabac28aU, 0x53b39330U, 0x24b4a3a6U, 0xbad03605U, + 0xcdd70693U, 0x54de5729U, 0x23d967bfU, 0xb3667a2eU, 0xc4614ab8U, + 0x5d681b02U, 0x2a6f2b94U, 0xb40bbe37U, 0xc30c8ea1U, 0x5a05df1bU, + 0x2d02ef8dU +}; + +static int nixio_bin_crc32(lua_State *L) { + size_t len; + const char *buffer = luaL_checklstring(L, 1, &len); + uint32_t value = luaL_optnumber(L, 2, 0); + + value = ~value; + for (size_t i=0; i<len; i++) { + value = nixio__crc32_tbl[(value ^ buffer[i]) & 0xffU ] ^ (value >> 8); + } + + lua_pushinteger(L, (int)(value ^ 0xffffffffU)); + return 1; +} + +static int nixio_bin_hexlify(lua_State *L) { + size_t len, lenout; + luaL_checktype(L, 1, LUA_TSTRING); + const unsigned char *data = (unsigned char*)lua_tolstring(L, 1, &len); + + if (len == 0) { + lua_pushvalue(L, 1); + return 1; + } + + lenout = len * 2; + luaL_argcheck(L, lenout > len, 1, "size overflow"); + + char *out = malloc(lenout); + if (!out) { + return luaL_error(L, NIXIO_OOM); + } + + for (size_t i=0; i < len; i++) { + out[2*i] = nixio__bin2hex[(data[i] & 0xf0) >> 4]; + out[2*i+1] = nixio__bin2hex[(data[i] & 0x0f)]; + } + + lua_pushlstring(L, out, lenout); + free(out); + + return 1; +} + + +static int nixio_bin_unhexlify(lua_State *L) { + size_t len, lenout; + const char *data = luaL_checklstring(L, 1, &len); + + if (len == 0) { + lua_pushvalue(L, 1); + return 1; + } else if (len % 2) { + errno = EINVAL; + return nixio__perror(L); + } + + lenout = len / 2; + char *out = malloc(lenout); + if (!out) { + return luaL_error(L, NIXIO_OOM); + } + + for (size_t i=0; i < lenout; i++) { + char c = data[2*i]; + if (c >= '0' && c <= '9') { + out[i] = (c - '0') << 4; + } else if (c >= 'a' && c <= 'f') { + out[i] = (c - 'a' + 10) << 4; + } else if (data[2*i] >= 'A' && c <= 'F') { + out[i] = (c - 'A' + 10) << 4; + } else { + free(out); + errno = EINVAL; + return nixio__perror(L); + } + + c = data[2*i+1]; + if (c >= '0' && c <= '9') { + out[i] += c - '0'; + } else if (c >= 'a' && c <= 'f') { + out[i] += c - 'a' + 10; + } else if (c >= 'A' && c <= 'F') { + out[i] += c - 'A' + 10; + } else { + free(out); + errno = EINVAL; + return nixio__perror(L); + } + } + + lua_pushlstring(L, out, lenout); + free(out); + + return 1; +} + +static int nixio_bin_b64encode(lua_State *L) { + size_t len, lenout, pad, i; + const char *data = luaL_checklstring(L, 1, &len); + + lenout = len / 3; + lenout *= 4; + + pad = len % 3; + + if (len == 0) { + lua_pushvalue(L, 1); + return 1; + } else if (pad) { + lenout += 4; + } + + luaL_argcheck(L, lenout > len, 1, "size overflow"); + + char *out = malloc(lenout); + if (!out) { + return luaL_error(L, NIXIO_OOM); + } + + char *o = out; + for (i = 0; i < len; i += 3) { + uint32_t cv = (data[i] << 16) | (data[i+1] << 8) | data[i+2]; + *(o+3) = nixio__b64encode_tbl[ cv & 0x3f]; + *(o+2) = nixio__b64encode_tbl[(cv >> 6) & 0x3f]; + *(o+1) = nixio__b64encode_tbl[(cv >> 12) & 0x3f]; + *o = nixio__b64encode_tbl[(cv >> 18) & 0x3f]; + o += 4; + } + + if (pad) { + uint32_t cv = data[len-pad] << 16; + *(o-1) = '='; + *(o-2) = '='; + if (pad == 2) { + cv |= data[len-pad+1] << 8; + *(o-2) = nixio__b64encode_tbl[(cv >> 6) & 0x3f]; + } + *(o-3) = nixio__b64encode_tbl[(cv >> 12) & 0x3f]; + *(o-4) = nixio__b64encode_tbl[(cv >> 18) & 0x3f]; + } + + lua_pushlstring(L, out, lenout); + free(out); + return 1; +} + +static int nixio_bin_b64decode(lua_State *L) { + size_t len, lenout, i; + const char *dt = luaL_checklstring(L, 1, &len); + + if (len == 0) { + lua_pushvalue(L, 1); + return 1; + } else if (len % 4) { + errno = EINVAL; + return nixio__perror(L); + } + + lenout = len / 4 * 3; + + unsigned char *out = malloc(lenout); + if (!out) { + return luaL_error(L, NIXIO_OOM); + } + + unsigned char *o = out; + for (i = 0; i < len; i += 4) { + uint32_t cv = 0; + for (int j = 0; j < 4; j++) { + unsigned char c = dt[i + j] - 43; + if (c > 79 || (c = nixio__b64decode_tbl[c]) == 0xff) { + free(out); + errno = EINVAL; + return nixio__perror(L); + } + + cv |= c; + if (j != 3) { + cv <<= 6; + } + } + + *(o+2) = (unsigned char)(cv & 0xff); + *(o+1) = (unsigned char)((cv >> 8) & 0xff); + *o = (unsigned char)((cv >> 16) & 0xff); + o += 3; + } + + if (dt[len-1] == '=') { + lenout--; + } + + if (dt[len-2] == '=') { + lenout--; + } + + lua_pushlstring(L, (char*)out, lenout); + free(out); + return 1; +} + +/* module table */ +static const luaL_reg R[] = { + {"hexlify", nixio_bin_hexlify}, + {"unhexlify", nixio_bin_unhexlify}, + {"crc32", nixio_bin_crc32}, + {"b64encode", nixio_bin_b64encode}, + {"b64decode", nixio_bin_b64decode}, + {NULL, NULL} +}; + + +void nixio_open_bin(lua_State *L) { + lua_newtable(L); + luaL_register(L, NULL, R); + lua_setfield(L, -2, "bin"); +} diff --git a/libs/nixio/src/bind.c b/libs/nixio/src/bind.c index 785a28d5a..7b2b719e3 100644 --- a/libs/nixio/src/bind.c +++ b/libs/nixio/src/bind.c @@ -18,15 +18,11 @@ #include "nixio.h" #include <sys/types.h> -#include <sys/socket.h> -#include <arpa/inet.h> -#include <netinet/in.h> -#include <sys/un.h> #include <string.h> #include <unistd.h> -#include <netdb.h> #include <errno.h> + /** * connect()/bind() shortcut */ @@ -87,6 +83,9 @@ static int nixio__bind_connect(lua_State *L, int do_bind) { } if (do_bind) { + int one = 1; + setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, + (char*)&one, sizeof(one)); status = bind(sock->fd, rp->ai_addr, rp->ai_addrlen); } else { do { @@ -103,7 +102,11 @@ static int nixio__bind_connect(lua_State *L, int do_bind) { } do { +#ifndef __WINNT__ clstat = close(sock->fd); +#else + clstat = closesocket(sock->fd); +#endif } while (clstat == -1 && errno == EINTR); } @@ -111,7 +114,7 @@ static int nixio__bind_connect(lua_State *L, int do_bind) { /* on failure */ if (status) { - return nixio__perror(L); + return nixio__perror_s(L); } luaL_getmetatable(L, NIXIO_META); @@ -183,6 +186,7 @@ static int nixio_sock__bind_connect(lua_State *L, int do_bind) { } freeaddrinfo(result); +#ifndef __WINNT__ } else if (sock->domain == AF_UNIX) { size_t pathlen; const char *path = luaL_checklstring(L, 2, &pathlen); @@ -200,10 +204,11 @@ static int nixio_sock__bind_connect(lua_State *L, int do_bind) { sizeof(addr)); } while (status == -1 && errno == EINTR); } +#endif } else { return luaL_error(L, "not supported"); } - return nixio__pstatus(L, !status); + return nixio__pstatus_s(L, !status); } /** @@ -225,8 +230,8 @@ static int nixio_sock_connect(lua_State *L) { */ static int nixio_sock_listen(lua_State *L) { int sockfd = nixio__checksockfd(L); - lua_Integer backlog = luaL_checkinteger(L, 2); - return nixio__pstatus(L, !listen(sockfd, backlog)); + int backlog = luaL_checkinteger(L, 2); + return nixio__pstatus_s(L, !listen(sockfd, backlog)); } /** @@ -234,18 +239,16 @@ static int nixio_sock_listen(lua_State *L) { */ static int nixio_sock_accept(lua_State *L) { nixio_sock *sock = nixio__checksock(L); - struct sockaddr_storage addr; - socklen_t addrlen = sizeof(addr); - char ipaddr[INET6_ADDRSTRLEN]; - void *binaddr; - uint16_t port; + struct sockaddr_storage saddr; + nixio_addr addr; + socklen_t saddrlen = sizeof(saddr); int newfd; do { - newfd = accept(sock->fd, (struct sockaddr *)&addr, &addrlen); + newfd = accept(sock->fd, (struct sockaddr *)&saddr, &saddrlen); } while (newfd == -1 && errno == EINTR); if (newfd < 0) { - return nixio__perror(L); + return nixio__perror_s(L); } /* create userdata */ @@ -256,25 +259,13 @@ static int nixio_sock_accept(lua_State *L) { memcpy(clsock, sock, sizeof(clsock)); clsock->fd = newfd; - if (addr.ss_family == AF_INET) { - struct sockaddr_in *inetaddr = (struct sockaddr_in*)&addr; - port = inetaddr->sin_port; - binaddr = &inetaddr->sin_addr; - } else if (addr.ss_family == AF_INET6) { - struct sockaddr_in6 *inet6addr = (struct sockaddr_in6*)&addr; - port = inet6addr->sin6_port; - binaddr = &inet6addr->sin6_addr; + if (!nixio__addr_parse(&addr, (struct sockaddr *)&saddr)) { + lua_pushstring(L, addr.host); + lua_pushnumber(L, addr.port); + return 3; } else { - return luaL_error(L, "unknown address family"); + return 1; } - - if (!inet_ntop(addr.ss_family, binaddr, ipaddr, sizeof(ipaddr))) { - return nixio__perror(L); - } - - lua_pushstring(L, ipaddr); - lua_pushinteger(L, ntohs(port)); - return 3; } /* module table */ diff --git a/libs/nixio/src/bit.c b/libs/nixio/src/bit.c new file mode 100644 index 000000000..14fdecab1 --- /dev/null +++ b/libs/nixio/src/bit.c @@ -0,0 +1,125 @@ +/* + * 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.h" +#include <stdint.h> +#include <stdlib.h> + +/* 52 bit maximum precision */ +#define NIXIO_BIT_BMAX 52 +#define NIXIO_BIT_NMAX 0xfffffffffffff + +#define NIXIO_BIT_XOP(BIT_XOP) \ + uint64_t oper = luaL_checknumber(L, 1); \ + const int args = lua_gettop(L); \ + \ + for (int i = 2; i <= args; i++) { \ + uint64_t oper2 = luaL_checknumber(L, i); \ + oper BIT_XOP oper2; \ + } \ + \ + lua_pushnumber(L, oper); \ + return 1; \ + + +static int nixio_bit_or(lua_State *L) { + NIXIO_BIT_XOP(|=); +} + +static int nixio_bit_and(lua_State *L) { + NIXIO_BIT_XOP(&=); +} + +static int nixio_bit_xor(lua_State *L) { + NIXIO_BIT_XOP(^=); +} + +static int nixio_bit_unset(lua_State *L) { + NIXIO_BIT_XOP(&= ~); +} + +static int nixio_bit_not(lua_State *L) { + lua_pushnumber(L, (~((uint64_t)luaL_checknumber(L, 1))) & NIXIO_BIT_NMAX); + return 1; +} + +static int nixio_bit_shl(lua_State *L) { + uint64_t oper = luaL_checknumber(L, 1); + oper <<= luaL_checkinteger(L, 2); + if (oper > NIXIO_BIT_NMAX) { + return luaL_error(L, "arithmetic overflow"); + } else { + lua_pushnumber(L, oper); + return 1; + } +} + +static int nixio_bit_ashr(lua_State *L) { + int64_t oper = luaL_checknumber(L, 1); + lua_pushnumber(L, oper >> luaL_checkinteger(L, 2)); + return 1; +} + +static int nixio_bit_shr(lua_State *L) { + uint64_t oper = luaL_checknumber(L, 1); + lua_pushnumber(L, oper >> luaL_checkinteger(L, 2)); + return 1; +} + +static int nixio_bit_div(lua_State *L) { + NIXIO_BIT_XOP(/=); +} + +static int nixio_bit_check(lua_State *L) { + uint64_t oper = luaL_checknumber(L, 1); + uint64_t oper2 = luaL_checknumber(L, 2); + lua_pushboolean(L, (oper & oper2) == oper2); + return 1; +} + +static int nixio_bit_cast(lua_State *L) { + lua_pushnumber(L, ((uint64_t)luaL_checknumber(L, 1)) & NIXIO_BIT_NMAX); + return 1; +} + +/* module table */ +static const luaL_reg R[] = { + {"bor", nixio_bit_or}, + {"set", nixio_bit_or}, + {"band", nixio_bit_and}, + {"bxor", nixio_bit_xor}, + {"unset", nixio_bit_unset}, + {"bnot", nixio_bit_not}, + {"rshift", nixio_bit_shr}, + {"arshift", nixio_bit_ashr}, + {"lshift", nixio_bit_shl}, + {"div", nixio_bit_div}, + {"check", nixio_bit_check}, + {"cast", nixio_bit_cast}, + {NULL, NULL} +}; + +void nixio_open_bit(lua_State *L) { + lua_newtable(L); + luaL_register(L, NULL, R); + lua_pushnumber(L, NIXIO_BIT_BMAX); + lua_setfield(L, -2, "bits"); + lua_pushnumber(L, NIXIO_BIT_NMAX); + lua_setfield(L, -2, "max"); + lua_setfield(L, -2, "bit"); +} diff --git a/libs/nixio/src/file.c b/libs/nixio/src/file.c index 2fe00c2a8..482752522 100644 --- a/libs/nixio/src/file.c +++ b/libs/nixio/src/file.c @@ -30,12 +30,37 @@ static int nixio_open(lua_State *L) { const char *filename = luaL_checklstring(L, 1, NULL); - int flags = luaL_optint(L, 2, O_RDONLY); - int mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; + int flags; + + if (lua_isnoneornil(L, 2)) { + flags = O_RDONLY; + } else if (lua_isnumber(L, 2)) { + flags = lua_tointeger(L, 2); + } else if (lua_isstring(L, 2)) { + const char *str = lua_tostring(L, 2); + if (!strcmp(str, "r")) { + flags = O_RDONLY; + } else if (!strcmp(str, "r+")) { + flags = O_RDWR; + } else if (!strcmp(str, "w")) { + flags = O_WRONLY | O_CREAT | O_TRUNC; + } else if (!strcmp(str, "w+")) { + flags = O_RDWR | O_CREAT | O_TRUNC; + } else if (!strcmp(str, "a")) { + flags = O_WRONLY | O_CREAT | O_APPEND; + } else if (!strcmp(str, "a+")) { + flags = O_RDWR | O_CREAT | O_APPEND; + } else { + return luaL_argerror(L, 2, "supported values: r, r+, w, w+, a, a+"); + } + } else { + return luaL_argerror(L, 2, "open flags or string expected"); + } + int fd; do { - fd = open(filename, flags, mode); + fd = open(filename, flags, nixio__check_mode(L, 3, 0666)); } while (fd == -1 && errno == EINTR); if (fd == -1) { return nixio__perror(L); @@ -66,9 +91,13 @@ static int nixio_open_flags(lua_State *L) { } else if (!strcmp(flag, "excl")) { mode |= O_EXCL; } else if (!strcmp(flag, "nonblock") || !strcmp(flag, "ndelay")) { +#ifndef __WINNT__ mode |= O_NONBLOCK; +#endif } else if (!strcmp(flag, "sync")) { +#ifndef __WINNT__ mode |= O_SYNC; +#endif } else if (!strcmp(flag, "trunc")) { mode |= O_TRUNC; } else if (!strcmp(flag, "rdonly")) { @@ -141,6 +170,23 @@ static int nixio_file_write(lua_State *L) { 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; + } + } + do { sent = write(fd, data, len); } while(sent == -1 && errno == EINTR); @@ -155,7 +201,7 @@ static int nixio_file_write(lua_State *L) { static int nixio_file_read(lua_State *L) { int fd = nixio__checkfd(L, 1); char buffer[NIXIO_BUFFERSIZE]; - int req = luaL_checkinteger(L, 2); + uint req = luaL_checkinteger(L, 2); int readc; /* We limit the readsize to NIXIO_BUFFERSIZE */ @@ -208,13 +254,33 @@ static int nixio_file_tell(lua_State *L) { } } +static int nixio_file_stat(lua_State *L) { + nixio_stat_t buf; + if (fstat(nixio__checkfd(L, 1), &buf)) { + return nixio__perror(L); + } else { + nixio__push_stat(L, &buf); + if (lua_isstring(L, 2)) { + lua_getfield(L, -1, lua_tostring(L, 2)); + } + return 1; + } +} + static int nixio_file_sync(lua_State *L) { int fd = nixio__checkfd(L, 1); -#ifndef BSD - int meta = lua_toboolean(L, 2); - return nixio__pstatus(L, (meta) ? !fsync(fd) : !fdatasync(fd)); + int stat; +#if (!defined BSD && !defined __WINNT__) + int dataonly = lua_toboolean(L, 2); + do { + stat = (dataonly) ? fdatasync(fd) : fsync(fd); + } while (stat == -1 && errno == EINTR); + return nixio__pstatus(L, !stat); #else - return nixio__pstatus(L, !fsync(fd)); + do { + stat = fsync(fd); + } while (stat == -1 && errno == EINTR); + return nixio__pstatus(L, !stat); #endif } @@ -282,6 +348,7 @@ static const luaL_reg M[] = { {"read", nixio_file_read}, {"tell", nixio_file_tell}, {"seek", nixio_file_seek}, + {"stat", nixio_file_stat}, {"sync", nixio_file_sync}, {"lock", nixio_file_lock}, {"close", nixio_file_close}, @@ -306,5 +373,26 @@ void nixio_open_file(lua_State *L) { luaL_register(L, NULL, M); lua_pushvalue(L, -1); lua_setfield(L, -2, "__index"); + + int *uin = lua_newuserdata(L, sizeof(int)); + int *uout = lua_newuserdata(L, sizeof(int)); + int *uerr = lua_newuserdata(L, sizeof(int)); + + if (!uin || !uout || !uerr) { + luaL_error(L, "out of memory"); + } + + *uin = STDIN_FILENO; + *uout = STDOUT_FILENO; + *uerr = STDERR_FILENO; + + for (int i = -4; i < -1; i++) { + lua_pushvalue(L, -4); + lua_setmetatable(L, i); + } + + lua_setfield(L, -5, "stderr"); + lua_setfield(L, -4, "stdout"); + lua_setfield(L, -3, "stdin"); lua_setfield(L, -2, "meta_file"); } diff --git a/libs/nixio/src/fs.c b/libs/nixio/src/fs.c new file mode 100644 index 000000000..10727d030 --- /dev/null +++ b/libs/nixio/src/fs.c @@ -0,0 +1,566 @@ +/* + * 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.h" +#include <libgen.h> +#include <string.h> +#include <unistd.h> +#include <limits.h> +#include <stdlib.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/time.h> +#include <dirent.h> + +/* Reads argument from given index and transforms it into a mode bitfield */ +int nixio__check_mode(lua_State *L, int idx, int def) { + if (lua_isnoneornil(L, idx) && def > 0) { + return def; + } else if (lua_isstring(L, idx) && lua_objlen(L, idx) == 9) { + int mode = 0; + const char *modestr = lua_tostring(L, idx); + int i; + for (i=0; i<9; i++) { + if (i % 3 == 0) { /* read flags */ + if (modestr[i] == 'r') { + mode |= 1 << (8 - i); + } else if (modestr[i] != '-') { + break; + } + } else if (i % 3 == 1) { /* write flags */ + if (modestr[i] == 'w') { + mode |= 1 << (8 - i); + } else if (modestr[i] != '-') { + break; + } + } else if (i == 2) { + if (modestr[i] == 'x') { + mode |= 00100; + } else if (modestr[i] == 's') { + mode |= 04100; + } else if (modestr[i] == 'S') { + mode |= 04000; + } else if (modestr[i] != '-') { + break; + } + } else if (i == 5) { + if (modestr[i] == 'x') { + mode |= 00010; + } else if (modestr[i] == 's') { + mode |= 02010; + } else if (modestr[i] == 'S') { + mode |= 02000; + } else if (modestr[i] != '-') { + break; + } + } else if (i == 8) { + if (modestr[i] == 'x') { + mode |= 00001; + } else if (modestr[i] == 't') { + mode |= 01001; + } else if (modestr[i] == 'T') { + mode |= 01000; + } else if (modestr[i] != '-') { + break; + } + } + } + if (i == 9) { /* successfully parsed */ + return mode; + } + } else if (lua_isnumber(L, idx)) { + int decmode = lua_tointeger(L, idx); + int s = (decmode % 10000) / 1000; + int u = (decmode % 1000) / 100; + int g = (decmode % 100) / 10; + int o = (decmode % 10); + + if (s>=0 && s<=7 && u>=0 && u<=7 && g>=0 && g<=7 && o>=0 && o<=7) { + return (s << 9) + (u << 6) + (g << 3) + o; + } + } + + return luaL_argerror(L, idx, "supported values: [0-7]?[0-7][0-7][0-7], " + "[-r][-w][-xsS][-r][-w][-xsS][-r][-w][-xtT]"); +} + +/* Transforms a mode into the modestring */ +int nixio__mode_write(int mode, char *modestr) { + if (modestr) { + modestr[0] = (mode & 00400) ? 'r' : '-'; + modestr[1] = (mode & 00200) ? 'w' : '-'; + modestr[2] = ((mode & 04100) == 04100) ? 's' : + (mode & 04000) ? 'S' : (mode & 00100) ? 'x' : '-'; + modestr[3] = (mode & 00040) ? 'r' : '-'; + modestr[4] = (mode & 00020) ? 'w' : '-'; + modestr[5] = ((mode & 02010) == 02010) ? 's' : + (mode & 02000) ? 'S' : (mode & 00010) ? 'x' : '-'; + modestr[6] = (mode & 00004) ? 'r' : '-'; + modestr[7] = (mode & 00002) ? 'w' : '-'; + modestr[8] = ((mode & 01001) == 01001) ? 't' : + (mode & 01000) ? 'T' : (mode & 00001) ? 'x' : '-'; + } + + return (mode & 00007) + ((mode & 00070) >> 3) * 10 + + ((mode & 00700) >> 6) * 100 + ((mode & 07000) >> 9) * 1000; +} + +static int nixio_access(lua_State *L) { + const char *path = luaL_checkstring(L, 1); + int mode = F_OK; + + for (const char *s = luaL_optstring(L, 2, "f"); *s; s++) { + if (*s == 'r') { + mode |= R_OK; + } else if (*s == 'w') { + mode |= W_OK; + } else if (*s == 'x') { + mode |= X_OK; + } else if (*s != 'f') { + return luaL_argerror(L, 2, "supported values: [frwx]"); + } + } + + return nixio__pstatus(L, !access(path, mode)); +} + +static int nixio_basename(lua_State *L) { + const char *path = luaL_checkstring(L, 1); + char base[PATH_MAX]; + base[PATH_MAX-1] = 0; + + strncpy(base, path, PATH_MAX-1); + lua_pushstring(L, basename(base)); + return 1; +} + +static int nixio_dirname(lua_State *L) { + const char *path = luaL_checkstring(L, 1); + char base[PATH_MAX]; + base[PATH_MAX-1] = 0; + + strncpy(base, path, PATH_MAX-1); + lua_pushstring(L, dirname(base)); + return 1; +} + +static int nixio_realpath(lua_State *L) { + const char *path = luaL_checkstring(L, 1); + char real[PATH_MAX]; + + if (!realpath(path, real)) { + return nixio__perror(L); + } else { + lua_pushstring(L, real); + return 1; + } +} + +static int nixio_remove(lua_State *L) { + return nixio__pstatus(L, !remove(luaL_checkstring(L, 1))); +} + +static int nixio_unlink(lua_State *L) { + return nixio__pstatus(L, !unlink(luaL_checkstring(L, 1))); +} + +static int nixio_rename(lua_State *L) { + return nixio__pstatus(L, + !rename(luaL_checkstring(L, 1), luaL_checkstring(L, 2))); +} + +static int nixio_rmdir(lua_State *L) { + return nixio__pstatus(L, !rmdir(luaL_checkstring(L, 1))); +} + +static int nixio_mkdir(lua_State *L) { + return nixio__pstatus(L, + !mkdir(luaL_checkstring(L, 1), nixio__check_mode(L, 2, 0777))); +} + +static int nixio_chmod(lua_State *L) { + return nixio__pstatus(L, + !chmod(luaL_checkstring(L, 1), nixio__check_mode(L, 2, -1))); +} + +static int nixio_dir__gc(lua_State *L) { + DIR **dirp = lua_touserdata(L, 1); + if (dirp && *dirp) { + closedir(*dirp); + *dirp = NULL; + } + return 0; +} + +static int nixio_dir__iter(lua_State *L) { + DIR **dirp = lua_touserdata(L, lua_upvalueindex(1)); + struct dirent *entry; + const char *n = NULL; + + if (*dirp) { + do { + entry = readdir(*dirp); + n = (entry) ? entry->d_name : NULL; + } while(n && n[0] == '.' && (n[1] == 0 || (n[1] == '.' && n[2] == 0))); + } + + if (n) { + lua_pushstring(L, n); + } else { + if (*dirp) { + closedir(*dirp); + *dirp = NULL; + } + lua_pushnil(L); + } + + return 1; +} + +static int nixio_dir(lua_State *L) { + const char *path = luaL_optstring(L, 1, "."); + DIR **dirp = lua_newuserdata(L, sizeof(DIR *)); + + *dirp = opendir(path); + if (!*dirp) { + return nixio__perror(L); + } else { + luaL_getmetatable(L, NIXIO_DIR_META); + lua_setmetatable(L, -2); + lua_pushcclosure(L, nixio_dir__iter, 1); + return 1; + } +} + +static int nixio_link(lua_State *L) { + return nixio__pstatus(L, + !link(luaL_checkstring(L, 1), luaL_checkstring(L, 2))); +} + +static int nixio_utimes(lua_State *L) { + const char *path = luaL_checkstring(L, 1); + if (lua_gettop(L) < 2) { + return nixio__pstatus(L, !utimes(path, NULL)); + } else { + double atime = luaL_checknumber(L, 2); + double mtime = luaL_optnumber(L, 3, atime); + struct timeval times[2]; + + times[0].tv_sec = atime; + times[0].tv_usec = (long)((atime - (int64_t)atime) * 1000000); + times[1].tv_sec = mtime; + times[1].tv_usec = (long)((mtime - (int64_t)mtime) * 1000000); + + return nixio__pstatus(L, !utimes(path, times)); + } +} + +int nixio__push_stat(lua_State *L, nixio_stat_t *buf) { + lua_createtable(L, 0, 15); + + lua_pushinteger(L, buf->st_dev); + lua_setfield(L, -2, "dev"); + + lua_pushinteger(L, buf->st_ino); + lua_setfield(L, -2, "ino"); + + if (S_ISREG(buf->st_mode)) { + lua_pushliteral(L, "reg"); + } else if (S_ISDIR(buf->st_mode)) { + lua_pushliteral(L, "dir"); + } else if (S_ISCHR(buf->st_mode)) { + lua_pushliteral(L, "chr"); + } else if (S_ISBLK(buf->st_mode)) { + lua_pushliteral(L, "blk"); + } else if (S_ISFIFO(buf->st_mode)) { + lua_pushliteral(L, "fifo"); + } else if (S_ISLNK(buf->st_mode)) { + lua_pushliteral(L, "lnk"); + } else if (S_ISSOCK(buf->st_mode)) { + lua_pushliteral(L, "sock"); + } else { + lua_pushliteral(L, "unknown"); + } + lua_setfield(L, -2, "type"); + + char modestr[9]; + lua_pushinteger(L, nixio__mode_write(buf->st_mode, modestr)); + lua_setfield(L, -2, "modedec"); + + lua_pushlstring(L, modestr, 9); + lua_setfield(L, -2, "modestr"); + + lua_pushinteger(L, buf->st_nlink); + lua_setfield(L, -2, "nlink"); + + lua_pushinteger(L, buf->st_uid); + lua_setfield(L, -2, "uid"); + + lua_pushinteger(L, buf->st_gid); + lua_setfield(L, -2, "gid"); + + lua_pushinteger(L, buf->st_rdev); + lua_setfield(L, -2, "rdev"); + + lua_pushnumber(L, buf->st_size); + lua_setfield(L, -2, "size"); + + lua_pushinteger(L, buf->st_atime); + lua_setfield(L, -2, "atime"); + + lua_pushinteger(L, buf->st_mtime); + lua_setfield(L, -2, "mtime"); + + lua_pushinteger(L, buf->st_ctime); + lua_setfield(L, -2, "ctime"); + +#ifndef __WINNT__ + lua_pushinteger(L, buf->st_blksize); + lua_setfield(L, -2, "blksize"); + + lua_pushinteger(L, buf->st_blocks); + lua_setfield(L, -2, "blocks"); +#endif + + return 1; +} + +static int nixio_stat(lua_State *L) { + nixio_stat_t buf; + if (stat(luaL_checkstring(L, 1), &buf)) { + return nixio__perror(L); + } else { + nixio__push_stat(L, &buf); + if (lua_isstring(L, 2)) { + lua_getfield(L, -1, lua_tostring(L, 2)); + } + return 1; + } +} + +static int nixio_lstat(lua_State *L) { + nixio_stat_t buf; + if (stat(luaL_checkstring(L, 1), &buf)) { + return nixio__perror(L); + } else { + nixio__push_stat(L, &buf); + if (lua_isstring(L, 2)) { + lua_getfield(L, -1, lua_tostring(L, 2)); + } + return 1; + } +} + +#ifndef __WINNT__ + +static int nixio_chown(lua_State *L) { + return nixio__pstatus(L, + !chown( + luaL_checkstring(L, 1), + lua_isnoneornil(L, 2) ? -1 : nixio__check_user(L, 2), + lua_isnoneornil(L, 3) ? -1 : nixio__check_group(L, 3) + ) + ); +} + +static int nixio_lchown(lua_State *L) { + return nixio__pstatus(L, + !lchown( + luaL_checkstring(L, 1), + lua_isnoneornil(L, 2) ? -1 : nixio__check_user(L, 2), + lua_isnoneornil(L, 3) ? -1 : nixio__check_group(L, 3) + ) + ); +} + +static int nixio_mkfifo(lua_State *L) { + return nixio__pstatus(L, + !mkfifo(luaL_checkstring(L, 1), nixio__check_mode(L, 2, -1))); +} + +static int nixio_symlink(lua_State *L) { + return nixio__pstatus(L, + !symlink(luaL_checkstring(L, 1), luaL_checkstring(L, 2))); +} + +static int nixio_readlink(lua_State *L) { + char dest[PATH_MAX]; + ssize_t res = readlink(luaL_checkstring(L, 1), dest, sizeof(dest)); + if (res < 0) { + return nixio__perror(L); + } else { + lua_pushlstring(L, dest, res); + return 1; + } +} + +#include <glob.h> + +typedef struct { + glob_t gl; + size_t pos; + int freed; +} nixio_glob_t; + +static int nixio_glob__iter(lua_State *L) { + nixio_glob_t *globres = lua_touserdata(L, lua_upvalueindex(1)); + if (!globres->freed && globres->pos < globres->gl.gl_pathc) { + lua_pushstring(L, globres->gl.gl_pathv[(globres->pos)++]); + } else { + if (!globres->freed) { + globfree(&globres->gl); + globres->freed = 1; + } + lua_pushnil(L); + } + return 1; +} + +static int nixio_glob__gc(lua_State *L) { + nixio_glob_t *globres = lua_touserdata(L, 1); + if (globres && !globres->freed) { + globres->freed = 1; + globfree(&globres->gl); + } + return 0; +} + +static int nixio_glob(lua_State *L) { + const char *pattern = luaL_optstring(L, 1, "*"); + nixio_glob_t *globres = lua_newuserdata(L, sizeof(nixio_glob_t)); + if (!globres) { + return luaL_error(L, NIXIO_OOM); + } + globres->pos = 0; + globres->freed = 0; + + int globstat = glob(pattern, 0, NULL, &globres->gl); + if (globstat == GLOB_NOMATCH) { + lua_pushcfunction(L, nixio__nulliter); + lua_pushinteger(L, 0); + } else if (globstat) { + return nixio__perror(L); + } else { + luaL_getmetatable(L, NIXIO_GLOB_META); + lua_setmetatable(L, -2); + lua_pushcclosure(L, nixio_glob__iter, 1); + lua_pushinteger(L, globres->gl.gl_pathc); + } + return 2; +} + +#include <sys/statvfs.h> + +static int nixio__push_statvfs(lua_State *L, struct statvfs *buf) { + lua_createtable(L, 0, 12); + + lua_pushnumber(L, buf->f_bavail); + lua_setfield(L, -2, "bavail"); + + lua_pushnumber(L, buf->f_bfree); + lua_setfield(L, -2, "bfree"); + + lua_pushnumber(L, buf->f_blocks); + lua_setfield(L, -2, "blocks"); + + lua_pushnumber(L, buf->f_bsize); + lua_setfield(L, -2, "bsize"); + + lua_pushnumber(L, buf->f_frsize); + lua_setfield(L, -2, "frsize"); + + lua_pushnumber(L, buf->f_favail); + lua_setfield(L, -2, "favail"); + + lua_pushnumber(L, buf->f_ffree); + lua_setfield(L, -2, "ffree"); + + lua_pushnumber(L, buf->f_files); + lua_setfield(L, -2, "files"); + + lua_pushnumber(L, buf->f_flag); + lua_setfield(L, -2, "flag"); + + lua_pushnumber(L, buf->f_fsid); + lua_setfield(L, -2, "fsid"); + + lua_pushnumber(L, buf->f_namemax); + lua_setfield(L, -2, "namemax"); + + return 1; +} + +static int nixio_statvfs(lua_State *L) { + struct statvfs buf; + if (statvfs(luaL_optstring(L, 1, "."), &buf)) { + return nixio__perror(L); + } else { + return nixio__push_statvfs(L, &buf); + } +} + +#endif /* !__WINNT__ */ + + + +/* module table */ +static const luaL_reg R[] = { +#ifndef __WINNT__ + {"glob", nixio_glob}, + {"mkfifo", nixio_mkfifo}, + {"symlink", nixio_symlink}, + {"readlink", nixio_readlink}, + {"chown", nixio_chown}, + {"lchown", nixio_lchown}, + {"statvfs", nixio_statvfs}, +#endif + {"chmod", nixio_chmod}, + {"access", nixio_access}, + {"basename", nixio_basename}, + {"dir", nixio_dir}, + {"dirname", nixio_dirname}, + {"realpath", nixio_realpath}, + {"mkdir", nixio_mkdir}, + {"rmdir", nixio_rmdir}, + {"link", nixio_link}, + {"unlink", nixio_unlink}, + {"utimes", nixio_utimes}, + {"rename", nixio_rename}, + {"remove", nixio_remove}, + {"stat", nixio_stat}, + {"lstat", nixio_lstat}, + {NULL, NULL} +}; + +void nixio_open_fs(lua_State *L) { + lua_newtable(L); + luaL_register(L, NULL, R); + lua_setfield(L, -2, "fs"); + + luaL_newmetatable(L, NIXIO_DIR_META); + lua_pushcfunction(L, nixio_dir__gc); + lua_setfield(L, -2, "__gc"); + lua_pop(L, 1); + +#ifndef __WINNT__ + luaL_newmetatable(L, NIXIO_GLOB_META); + lua_pushcfunction(L, nixio_glob__gc); + lua_setfield(L, -2, "__gc"); + lua_pop(L, 1); +#endif +} diff --git a/libs/nixio/src/io.c b/libs/nixio/src/io.c index 0ce4fcc3a..8b8f25b42 100644 --- a/libs/nixio/src/io.c +++ b/libs/nixio/src/io.c @@ -18,12 +18,10 @@ #include "nixio.h" #include <errno.h> +#include <string.h> #include <stdlib.h> #include <stdio.h> #include <sys/types.h> -#include <sys/socket.h> -#include <arpa/inet.h> -#include <netinet/in.h> /** @@ -33,34 +31,46 @@ static int nixio_sock__sendto(lua_State *L, int to) { nixio_sock *sock = nixio__checksock(L); struct sockaddr *addr = NULL; socklen_t alen = 0; + int argoff = 2; if (to) { - const char *address = luaL_checklstring(L, 3, NULL); - uint16_t port = (uint16_t)luaL_checkinteger(L, 4); + argoff += 2; + const char *address = luaL_checkstring(L, 3); struct sockaddr_storage addrstor; addr = (struct sockaddr*)&addrstor; - if (sock->domain == AF_INET) { - struct sockaddr_in *inetaddr = (struct sockaddr_in *)addr; - if (inet_pton(sock->domain, address, &inetaddr->sin_addr) < 0) { - return luaL_argerror(L, 3, "invalid address"); - } - inetaddr->sin_port = htons(port); - alen = sizeof(*inetaddr); - } else if (sock->domain == AF_INET6) { - struct sockaddr_in6 *inet6addr = (struct sockaddr_in6 *)addr; - if (inet_pton(sock->domain, address, &inet6addr->sin6_addr) < 0) { - return luaL_argerror(L, 3, "invalid address"); - } - inet6addr->sin6_port = htons(port); - alen = sizeof(*inet6addr); - } else { - return luaL_argerror(L, 1, "supported families: inet, inet6"); + + nixio_addr naddr; + memset(&naddr, 0, sizeof(naddr)); + strncpy(naddr.host, address, sizeof(naddr.host) - 1); + naddr.port = (uint16_t)luaL_checkinteger(L, 4); + naddr.family = sock->domain; + + if (nixio__addr_write(&naddr, addr)) { + return nixio__perror_s(L); } } size_t len; ssize_t sent; const char *data = luaL_checklstring(L, 2, &len); + + if (lua_gettop(L) > argoff) { + int offset = luaL_optint(L, argoff + 1, 0); + if (offset) { + if (offset < len) { + data += offset; + len -= offset; + } else { + len = 0; + } + } + + unsigned int wlen = luaL_optint(L, argoff + 2, len); + if (wlen < len) { + len = wlen; + } + } + do { sent = sendto(sock->fd, data, len, 0, addr, alen); } while(sent == -1 && errno == EINTR); @@ -68,7 +78,7 @@ static int nixio_sock__sendto(lua_State *L, int to) { lua_pushinteger(L, sent); return 1; } else { - return nixio__perror(L); + return nixio__perror_s(L); } } @@ -94,7 +104,7 @@ static int nixio_sock__recvfrom(lua_State *L, int from) { nixio_sock *sock = nixio__checksock(L); char buffer[NIXIO_BUFFERSIZE]; struct sockaddr_storage addrobj; - int req = luaL_checkinteger(L, 2); + uint req = luaL_checkinteger(L, 2); int readc; if (from && sock->domain != AF_INET && sock->domain != AF_INET6) { @@ -111,38 +121,31 @@ static int nixio_sock__recvfrom(lua_State *L, int from) { readc = recvfrom(sock->fd, buffer, req, 0, addr, &alen); } while (readc == -1 && errno == EINTR); +#ifdef __WINNT__ + if (readc < 0) { + int e = WSAGetLastError(); + if (e == WSAECONNRESET || e == WSAECONNABORTED || e == WSAESHUTDOWN) { + readc = 0; + } + } +#endif + if (readc < 0) { - return nixio__perror(L); + return nixio__perror_s(L); } else { lua_pushlstring(L, buffer, readc); if (!from) { return 1; } else { - char ipaddr[INET6_ADDRSTRLEN]; - void *binaddr; - uint16_t port; - - if (addrobj.ss_family == AF_INET) { - struct sockaddr_in *inetaddr = (struct sockaddr_in*)addr; - port = inetaddr->sin_port; - binaddr = &inetaddr->sin_addr; - } else if (addrobj.ss_family == AF_INET6) { - struct sockaddr_in6 *inet6addr = (struct sockaddr_in6*)addr; - port = inet6addr->sin6_port; - binaddr = &inet6addr->sin6_addr; + nixio_addr naddr; + if (!nixio__addr_parse(&naddr, (struct sockaddr *)&addrobj)) { + lua_pushstring(L, naddr.host); + lua_pushnumber(L, naddr.port); + return 3; } else { - return luaL_error(L, "unknown address family"); - } - - if (!inet_ntop(addrobj.ss_family, binaddr, ipaddr, sizeof(ipaddr))) { - return nixio__perror(L); + return 1; } - - lua_pushstring(L, ipaddr); - lua_pushinteger(L, ntohs(port)); - - return 3; } } } diff --git a/libs/nixio/src/mingw-compat.c b/libs/nixio/src/mingw-compat.c new file mode 100644 index 000000000..02be504a1 --- /dev/null +++ b/libs/nixio/src/mingw-compat.c @@ -0,0 +1,220 @@ +/* + * 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.h" +#include <string.h> +#include <fcntl.h> +#include <errno.h> +#include <sys/locking.h> +#include <sys/time.h> +#include <sys/utime.h> + +void nixio_open__mingw(lua_State *L) { + _fmode = _O_BINARY; + + WSADATA wsa; + + if (WSAStartup(MAKEWORD(2, 2), &wsa)) { + luaL_error(L, "Unable to initialize Winsock"); + } + + lua_newtable(L); + + NIXIO_WSA_CONSTANT(WSAEACCES); + NIXIO_WSA_CONSTANT(WSAEINTR); + NIXIO_WSA_CONSTANT(WSAEINVAL); + NIXIO_WSA_CONSTANT(WSAEBADF); + NIXIO_WSA_CONSTANT(WSAEFAULT); + NIXIO_WSA_CONSTANT(WSAEMFILE); + NIXIO_WSA_CONSTANT(WSAENAMETOOLONG); + NIXIO_WSA_CONSTANT(WSAELOOP); + NIXIO_WSA_CONSTANT(WSAEAFNOSUPPORT); + NIXIO_WSA_CONSTANT(WSAENOBUFS); + NIXIO_WSA_CONSTANT(WSAEPROTONOSUPPORT); + NIXIO_WSA_CONSTANT(WSAENOPROTOOPT); + NIXIO_WSA_CONSTANT(WSAEADDRINUSE); + NIXIO_WSA_CONSTANT(WSAENETDOWN); + NIXIO_WSA_CONSTANT(WSAENETUNREACH); + NIXIO_WSA_CONSTANT(WSAECONNABORTED); + NIXIO_WSA_CONSTANT(WSAECONNRESET); + + lua_setfield(L, -2, "const_sock"); +} + +const char* nixio__mgw_inet_ntop +(int af, const void *src, char *dst, socklen_t size) { + struct sockaddr_storage saddr; + memset(&saddr, 0, sizeof(saddr)); + + DWORD hostlen = size, sl; + if (af == AF_INET) { + struct sockaddr_in *saddr4 = (struct sockaddr_in *)&saddr; + memcpy(&saddr4->sin_addr, src, sizeof(saddr4->sin_addr)); + saddr4->sin_family = AF_INET; + saddr4->sin_port = 0; + sl = sizeof(struct sockaddr_in); + } else if (af == AF_INET6) { + struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)&saddr; + memcpy(&saddr6->sin6_addr, src, sizeof(saddr6->sin6_addr)); + saddr6->sin6_family = AF_INET6; + saddr6->sin6_port = 0; + sl = sizeof(struct sockaddr_in6); + } else { + return NULL; + } + if (WSAAddressToString((struct sockaddr*)&saddr, sl, NULL, dst, &hostlen)) { + return NULL; + } + return dst; +} + +int nixio__mgw_inet_pton (int af, const char *src, void *dst) { + struct sockaddr_storage sa; + int sl = sizeof(sa); + + if (!WSAStringToAddress((char*)src, af, NULL, (struct sockaddr*)&sa, &sl)) { + if (af == AF_INET) { + struct in_addr ina = ((struct sockaddr_in *)&sa)->sin_addr; + memcpy(dst, &ina, sizeof(ina)); + return 1; + } else if (af == AF_INET6) { + struct in_addr6 ina6 = ((struct sockaddr_in6 *)&sa)->sin6_addr; + memcpy(dst, &ina6, sizeof(ina6)); + return 1; + } else { + WSASetLastError(WSAEAFNOSUPPORT); + return -1; + } + } else { + return -1; + } +} + +int nixio__mgw_nanosleep(const struct timespec *req, struct timespec *rem) { + if (rem) { + rem->tv_sec = 0; + rem->tv_nsec = 0; + } + Sleep(req->tv_sec * 1000 + req->tv_nsec * 1000000); + return 0; +} + +int nixio__mgw_poll(struct pollfd *fds, int nfds, int timeout) { + if (!fds || !nfds) { + Sleep(timeout); + return 0; + } + + struct timeval tv; + int high = 0, rf = 0, wf = 0, ef = 0; + fd_set rfds, wfds, efds; + FD_ZERO(&rfds); + FD_ZERO(&wfds); + FD_ZERO(&efds); + + tv.tv_sec = timeout / 1000; + tv.tv_usec = (timeout % 1000) * 1000; + + for (int i = 0; i < nfds; i++) { + if (fds->events & POLLIN) { + FD_SET(fds->fd, &rfds); + rf++; + } + if (fds->events & POLLOUT) { + FD_SET(fds->fd, &wfds); + wf++; + } + if (fds->events & POLLERR) { + FD_SET(fds->fd, &efds); + ef++; + } + if (fds->fd > high) { + high = fds->fd; + } + } + + int stat = select(high + 1, (rf) ? &rfds : NULL, + (wf) ? &wfds : NULL, (ef) ? &efds : NULL, &tv); + if (stat < 1) { + errno = WSAGetLastError(); + return stat; + } + + high = 0; + + for (int i = 0; i < nfds; i++) { + fds->revents = 0; + if ((fds->events & POLLIN) && FD_ISSET(fds->fd, &rfds)) { + fds->revents |= POLLIN; + } + if ((fds->events & POLLOUT) && FD_ISSET(fds->fd, &wfds)) { + fds->revents |= POLLOUT; + } + if ((fds->events & POLLERR) && FD_ISSET(fds->fd, &efds)) { + fds->revents |= POLLERR; + } + if (fds->revents) { + high++; + } + } + + return high; +} + +int nixio__mgw_lockf(int fd, int cmd, off_t len) { + int stat; + if (cmd == F_LOCK) { + do { + stat = _locking(fd, _LK_LOCK, len); + } while (stat == -1 && errno == EDEADLOCK); + } else if (cmd == F_TLOCK) { + stat = _locking(fd, _LK_NBLCK, len); + } else if (cmd == F_ULOCK) { + stat = _locking(fd, _LK_UNLCK, len); + } else { + stat = -1; + errno = EINVAL; + } + return stat; +} + +char* nixio__mgw_realpath(const char *path, char *resolved) { + if (GetFullPathName(path, PATH_MAX, resolved, NULL)) { + return resolved; + } else { + errno = GetLastError(); + return NULL; + } +} + +int nixio__mgw_link(const char *oldpath, const char *newpath) { + if (!CreateHardLink(newpath, oldpath, NULL)) { + errno = GetLastError(); + return -1; + } else { + return 0; + } +} + +int nixio__mgw_utimes(const char *filename, const struct timeval times[2]) { + struct _utimbuf timebuffer; + timebuffer.actime = times[0].tv_sec; + timebuffer.modtime = times[1].tv_sec; + + return _utime(filename, &timebuffer); +} diff --git a/libs/nixio/src/mingw-compat.h b/libs/nixio/src/mingw-compat.h new file mode 100644 index 000000000..a26a4beec --- /dev/null +++ b/libs/nixio/src/mingw-compat.h @@ -0,0 +1,112 @@ +#ifndef NIXIO_MINGW_COMPAT_H_ +#define NIXIO_MINGW_COMPAT_H_ + +#include <winsock2.h> +#include <ws2tcpip.h> +#include <io.h> +#include <process.h> +#include <stdint.h> +#include <sys/stat.h> +#include <errno.h> + +typedef unsigned int uint; +typedef unsigned long ulong; + +#define S_ISLNK(m) 0 +#define S_ISSOCK(m) 0 + +#define EWOULDBLOCK WSAEWOULDBLOCK +#define EAFNOSUPPORT WSAEAFNOSUPPORT +#define ENOPROTOOPT WSAENOPROTOOPT + +#define SHUT_RD SD_RECEIVE +#define SHUT_WR SD_SEND +#define SHUT_RDWR SD_BOTH + +#define pipe(fds) _pipe(fds, 65536, 0) +#define fsync _commit +#define lseek lseek64 +#define stat _stati64 +#define lstat _stati64 +#define fstat _fstati64 + + +#define F_LOCK 1 +#define F_ULOCK 0 +#define F_TLOCK 2 +#define F_TEST 3 +int nixio__mgw_lockf(int fd, int cmd, off_t len); +#define lockf nixio__mgw_lockf + +const char* nixio__mgw_inet_ntop +(int af, const void *src, char *dst, socklen_t size); +#define inet_ntop nixio__mgw_inet_ntop + +int nixio__mgw_inet_pton (int af, const char *src, void *dst); +#define inet_pton nixio__mgw_inet_pton + + +#ifndef POLLIN +#define POLLIN 0x001 +#define POLLOUT 0x004 +#define POLLERR 0x008 +struct pollfd { + int fd; + short events; + short revents; +}; +#endif + +typedef int nfds_t; +int nixio__mgw_poll(struct pollfd *fds, nfds_t nfds, int timeout); +#define poll nixio__mgw_poll + + +struct timespec { + time_t tv_sec; + long tv_nsec; +}; + +int nixio__mgw_nanosleep(const struct timespec *req, struct timespec *rem); +#define nanosleep nixio__mgw_nanosleep + + +char* nixio__mgw_realpath(const char *path, char *resolved); +#define realpath nixio__mgw_realpath + + +int nixio__mgw_link(const char *oldpath, const char *newpath); +#define link nixio__mgw_link + + +int nixio__mgw_utimes(const char *filename, const struct timeval times[2]); +#define utimes nixio__mgw_utimes + + +#define setenv(k, v, o) !SetEnvironmentVariable(k, v) +#define unsetenv(k) !SetEnvironmentVariable(k, NULL) + +#define execv(p, a) execv(p, (const char* const*)a) +#define execvp(p, a) execvp(p, (const char* const*)a) +#define execve(p, a, e) execve(p, (const char* const*)a, (const char* const*)e) + +#define mkdir(p, m) mkdir(p) + + +#define nixio__perror_s(L) \ + errno = WSAGetLastError(); \ + return nixio__perror(L); + +#define nixio__pstatus_s(L, c) \ + errno = WSAGetLastError(); \ + return nixio__pstatus(L, c); + + + +#define NIXIO_WSA_CONSTANT(x) \ + lua_pushinteger(L, x); \ + lua_setfield(L, -2, #x+3); + +void nixio_open__mingw(lua_State *L); + +#endif /* NIXIO_MINGW_COMPAT_H_ */ diff --git a/libs/nixio/src/nixio-tls.h b/libs/nixio/src/nixio-tls.h index 4c58dd136..0fac5a980 100644 --- a/libs/nixio/src/nixio-tls.h +++ b/libs/nixio/src/nixio-tls.h @@ -2,9 +2,12 @@ #define NIXIO_TLS_H_ #include "nixio.h" +#include <sys/types.h> #ifndef WITHOUT_OPENSSL #include <openssl/ssl.h> +#include <openssl/md5.h> +#include <openssl/sha.h> #endif #define NIXIO_TLS_CTX_META "nixio.tls.ctx" @@ -20,4 +23,31 @@ typedef struct nixio_tls_socket { #endif } nixio_tls_sock; +#define NIXIO_CRYPTO_HASH_META "nixio.crypto.hash" +#define NIXIO_DIGEST_SIZE 64 +#define NIXIO_CRYPTO_BLOCK_SIZE 64 + +#define NIXIO_HASH_NONE 0 +#define NIXIO_HASH_MD5 0x01 +#define NIXIO_HASH_SHA1 0x02 + +#define NIXIO_HMAC_BIT 0x40 + +typedef int(*nixio_hash_initcb)(void *); +typedef int(*nixio_hash_updatecb)(void *, const void *, unsigned long); +typedef int(*nixio_hash_finalcb)(unsigned char *, void *); + +typedef struct nixio_hash_obj { + uint type; + unsigned char digest[NIXIO_DIGEST_SIZE]; + size_t digest_size; + unsigned char key[NIXIO_CRYPTO_BLOCK_SIZE]; + size_t key_size; + size_t block_size; + void *ctx; + nixio_hash_initcb init; + nixio_hash_updatecb update; + nixio_hash_finalcb final; +} nixio_hash; + #endif /* NIXIO_TLS_H_ */ diff --git a/libs/nixio/src/nixio.c b/libs/nixio/src/nixio.c index 3a70aa8da..457bbd1f2 100644 --- a/libs/nixio/src/nixio.c +++ b/libs/nixio/src/nixio.c @@ -27,7 +27,7 @@ /* pushes nil, error number and errstring on the stack */ int nixio__perror(lua_State *L) { - if (errno == EAGAIN) { + if (errno == EAGAIN || errno == EWOULDBLOCK) { lua_pushboolean(L, 0); } else { lua_pushnil(L); @@ -85,6 +85,17 @@ int nixio__tofd(lua_State *L, int ud) { return fd; } +/* An empty iterator */ +int nixio__nulliter(lua_State *L) { + lua_pushnil(L); + return 1; +} + +static int nixio_errno(lua_State *L) { + lua_pushinteger(L, errno); + return 1; +} + static int nixio_strerror(lua_State *L) { lua_pushstring(L, strerror(luaL_checkinteger(L, 1))); return 1; @@ -92,12 +103,13 @@ static int nixio_strerror(lua_State *L) { /* object table */ static const luaL_reg R[] = { + {"errno", nixio_errno}, {"strerror", nixio_strerror}, {NULL, NULL} }; /* entry point */ -LUALIB_API int luaopen_nixio(lua_State *L) { +NIXIO_API int luaopen_nixio(lua_State *L) { /* create metatable */ luaL_newmetatable(L, NIXIO_META); @@ -113,6 +125,9 @@ LUALIB_API int luaopen_nixio(lua_State *L) { lua_setfield(L, -2, "meta_socket"); /* register methods */ +#ifdef __WINNT__ + nixio_open__mingw(L); +#endif nixio_open_file(L); nixio_open_socket(L); nixio_open_sockopt(L); @@ -123,6 +138,11 @@ LUALIB_API int luaopen_nixio(lua_State *L) { nixio_open_splice(L); nixio_open_process(L); nixio_open_syslog(L); + nixio_open_bit(L); + nixio_open_bin(L); + nixio_open_fs(L); + nixio_open_user(L); + nixio_open_tls_crypto(L); nixio_open_tls_context(L); nixio_open_tls_socket(L); @@ -131,13 +151,21 @@ LUALIB_API int luaopen_nixio(lua_State *L) { lua_setfield(L, -2, "version"); /* some constants */ - lua_createtable(L, 0, 49); + lua_newtable(L); + + lua_pushliteral(L, NIXIO_SEP); + lua_setfield(L, -2, "sep"); + + lua_pushliteral(L, NIXIO_PATHSEP); + lua_setfield(L, -2, "pathsep"); + + lua_pushinteger(L, NIXIO_BUFFERSIZE); + lua_setfield(L, -2, "buffersize"); NIXIO_PUSH_CONSTANT(EACCES); NIXIO_PUSH_CONSTANT(EINTR); NIXIO_PUSH_CONSTANT(ENOSYS); NIXIO_PUSH_CONSTANT(EINVAL); - NIXIO_PUSH_CONSTANT(EWOULDBLOCK); NIXIO_PUSH_CONSTANT(EAGAIN); NIXIO_PUSH_CONSTANT(ENOMEM); NIXIO_PUSH_CONSTANT(ENOENT); @@ -152,37 +180,51 @@ LUALIB_API int luaopen_nixio(lua_State *L) { NIXIO_PUSH_CONSTANT(EISDIR); NIXIO_PUSH_CONSTANT(EPERM); NIXIO_PUSH_CONSTANT(EEXIST); - NIXIO_PUSH_CONSTANT(ELOOP); NIXIO_PUSH_CONSTANT(EMFILE); NIXIO_PUSH_CONSTANT(ENAMETOOLONG); NIXIO_PUSH_CONSTANT(ENFILE); NIXIO_PUSH_CONSTANT(ENODEV); + NIXIO_PUSH_CONSTANT(EXDEV); NIXIO_PUSH_CONSTANT(ENOTDIR); NIXIO_PUSH_CONSTANT(ENXIO); - NIXIO_PUSH_CONSTANT(EOVERFLOW); NIXIO_PUSH_CONSTANT(EROFS); + NIXIO_PUSH_CONSTANT(EBUSY); + NIXIO_PUSH_CONSTANT(ESRCH); + NIXIO_PUSH_CONSTANT(SIGINT); + NIXIO_PUSH_CONSTANT(SIGTERM); + NIXIO_PUSH_CONSTANT(SIGSEGV); + +#ifndef __WINNT__ + NIXIO_PUSH_CONSTANT(EWOULDBLOCK); + NIXIO_PUSH_CONSTANT(ELOOP); + NIXIO_PUSH_CONSTANT(EOVERFLOW); NIXIO_PUSH_CONSTANT(ETXTBSY); NIXIO_PUSH_CONSTANT(EAFNOSUPPORT); NIXIO_PUSH_CONSTANT(ENOBUFS); NIXIO_PUSH_CONSTANT(EPROTONOSUPPORT); NIXIO_PUSH_CONSTANT(ENOPROTOOPT); - NIXIO_PUSH_CONSTANT(EBUSY); - NIXIO_PUSH_CONSTANT(ESRCH); + NIXIO_PUSH_CONSTANT(EADDRINUSE); + NIXIO_PUSH_CONSTANT(ENETDOWN); + NIXIO_PUSH_CONSTANT(ENETUNREACH); + NIXIO_PUSH_CONSTANT(SIGALRM); - NIXIO_PUSH_CONSTANT(SIGINT); - NIXIO_PUSH_CONSTANT(SIGTERM); NIXIO_PUSH_CONSTANT(SIGKILL); NIXIO_PUSH_CONSTANT(SIGHUP); NIXIO_PUSH_CONSTANT(SIGSTOP); NIXIO_PUSH_CONSTANT(SIGCONT); - NIXIO_PUSH_CONSTANT(SIGSEGV); NIXIO_PUSH_CONSTANT(SIGCHLD); NIXIO_PUSH_CONSTANT(SIGQUIT); NIXIO_PUSH_CONSTANT(SIGUSR1); NIXIO_PUSH_CONSTANT(SIGUSR2); NIXIO_PUSH_CONSTANT(SIGIO); NIXIO_PUSH_CONSTANT(SIGURG); + NIXIO_PUSH_CONSTANT(SIGPIPE); + + lua_pushvalue(L, -1); + lua_setfield(L, -3, "const_sock"); + signal(SIGPIPE, SIG_IGN); +#endif /* !__WINNT__ */ lua_setfield(L, -2, "const"); /* remove meta table */ diff --git a/libs/nixio/src/nixio.h b/libs/nixio/src/nixio.h index 23da17d44..8caa5b969 100644 --- a/libs/nixio/src/nixio.h +++ b/libs/nixio/src/nixio.h @@ -1,9 +1,12 @@ #ifndef NIXIO_H_ #define NIXIO_H_ +#define NIXIO_OOM "out of memory" + #define NIXIO_META "nixio.socket" #define NIXIO_FILE_META "nixio.file" -#define NIXIO_BUFFERSIZE 8096 +#define NIXIO_GLOB_META "nixio.glob" +#define NIXIO_DIR_META "nixio.dir" #define _FILE_OFFSET_BITS 64 #define NIXIO_PUSH_CONSTANT(x) \ @@ -17,6 +20,8 @@ #include <lualib.h> #include <lauxlib.h> +#define NIXIO_BUFFERSIZE 8192 + typedef struct nixio_socket { int fd; int domain; @@ -24,12 +29,66 @@ typedef struct nixio_socket { int protocol; } nixio_sock; +typedef struct nixio_address { + int family; + char host[128]; + int port; +} nixio_addr; + int nixio__perror(lua_State *L); int nixio__pstatus(lua_State *L, int condition); + +#ifndef __WINNT__ + +#define NIXIO_API extern + +#include <sys/types.h> +#include <sys/socket.h> +#include <arpa/inet.h> +#include <netinet/in.h> +#include <netinet/tcp.h> +#include <net/if.h> +#include <sys/un.h> +#include <netdb.h> +#include <poll.h> +#include <sys/stat.h> +#include <errno.h> + +#define NIXIO_SEP "/" +#define NIXIO_PATHSEP ":" + +#define nixio__perror_s nixio__perror +#define nixio__pstatus_s nixio__pstatus + +int nixio__check_group(lua_State *L, int idx); +int nixio__check_user(lua_State *L, int idx); + +typedef struct stat nixio_stat_t; + +#else /* __WINNT__ */ + +#define NIXIO_API extern __declspec(dllexport) +#define NIXIO_SEP "\\" +#define NIXIO_PATHSEP ";" +#include "mingw-compat.h" + +typedef struct _stati64 nixio_stat_t; + +#endif + nixio_sock* nixio__checksock(lua_State *L); int nixio__checksockfd(lua_State *L); int nixio__checkfd(lua_State *L, int ud); int nixio__tofd(lua_State *L, int ud); +int nixio__nulliter(lua_State *L); + +int nixio__addr_parse(nixio_addr *addr, struct sockaddr *saddr); +int nixio__addr_write(nixio_addr *addr, struct sockaddr *saddr); + +int nixio__check_mode(lua_State *L, int idx, int def); +int nixio__mode_write(int mode, char *modestr); + +int nixio__push_stat(lua_State *L, nixio_stat_t *buf); /* Module functions */ void nixio_open_file(lua_State *L); @@ -42,6 +101,11 @@ void nixio_open_io(lua_State *L); void nixio_open_splice(lua_State *L); void nixio_open_process(lua_State *L); void nixio_open_syslog(lua_State *L); +void nixio_open_bit(lua_State *L); +void nixio_open_bin(lua_State *L); +void nixio_open_fs(lua_State *L); +void nixio_open_user(lua_State *L); +void nixio_open_tls_crypto(lua_State *L); void nixio_open_tls_context(lua_State *L); void nixio_open_tls_socket(lua_State *L); diff --git a/libs/nixio/src/poll.c b/libs/nixio/src/poll.c index fdec2caaf..4af32890a 100644 --- a/libs/nixio/src/poll.c +++ b/libs/nixio/src/poll.c @@ -17,12 +17,10 @@ */ #include "nixio.h" -#include <poll.h> #include <time.h> #include <errno.h> #include <string.h> #include <stdlib.h> -#include "nixio.h" /** @@ -71,11 +69,13 @@ static int nixio_poll_flags(lua_State *L) { flags = luaL_checkinteger(L, 1); lua_newtable(L); nixio_poll_flags__r(L, &flags, POLLIN, "in"); - nixio_poll_flags__r(L, &flags, POLLPRI, "pri"); nixio_poll_flags__r(L, &flags, POLLOUT, "out"); nixio_poll_flags__r(L, &flags, POLLERR, "err"); +#ifndef __WINNT__ + nixio_poll_flags__r(L, &flags, POLLPRI, "pri"); nixio_poll_flags__r(L, &flags, POLLHUP, "hup"); nixio_poll_flags__r(L, &flags, POLLNVAL, "nval"); +#endif } else { flags = 0; const int j = lua_gettop(L); @@ -83,16 +83,22 @@ static int nixio_poll_flags(lua_State *L) { const char *flag = luaL_checkstring(L, i); if (!strcmp(flag, "in")) { flags |= POLLIN; - } else if (!strcmp(flag, "pri")) { - flags |= POLLPRI; } else if (!strcmp(flag, "out")) { flags |= POLLOUT; } else if (!strcmp(flag, "err")) { flags |= POLLERR; + } else if (!strcmp(flag, "pri")) { +#ifndef __WINNT__ + flags |= POLLPRI; +#endif } else if (!strcmp(flag, "hup")) { +#ifndef __WINNT__ flags |= POLLHUP; +#endif } else if (!strcmp(flag, "nval")) { +#ifndef __WINNT__ flags |= POLLNVAL; +#endif } else { return luaL_argerror(L, i, "supported values: in, pri, out, err, hup, nval"); @@ -114,11 +120,19 @@ static int nixio_poll(lua_State *L) { /* we are being abused as sleep() replacement... */ if (lua_isnoneornil(L, 1) || len < 1) { - return nixio__pstatus(L, !poll(NULL, 0, timeout)); + if (!poll(NULL, 0, timeout)) { + lua_pushinteger(L, 0); + return 1; + } else { + return nixio__perror(L); + } } luaL_checktype(L, 1, LUA_TTABLE); struct pollfd *fds = calloc(len, sizeof(struct pollfd)); + if (!fds) { + return luaL_error(L, NIXIO_OOM); + } for (i = 0; i < len; i++) { lua_rawgeti(L, 1, i+1); @@ -145,7 +159,11 @@ static int nixio_poll(lua_State *L) { status = poll(fds, (nfds_t)len, timeout); - if (status < 1) { + if (status == 0) { + free(fds); + lua_pushboolean(L, 0); + return 1; + } else if (status < 0) { free(fds); return nixio__perror(L); } diff --git a/libs/nixio/src/process.c b/libs/nixio/src/process.c index a82e5660d..0e8ac8a29 100644 --- a/libs/nixio/src/process.c +++ b/libs/nixio/src/process.c @@ -17,15 +17,98 @@ */ #include "nixio.h" -#include <pwd.h> -#include <grp.h> +#include <stdlib.h> #include <unistd.h> #include <errno.h> #include <string.h> -#include <sys/wait.h> +#include <sys/stat.h> #include <sys/types.h> #include <signal.h> +#define NIXIO_EXECVE 0x01 +#define NIXIO_EXECV 0x02 +#define NIXIO_EXECVP 0x03 + +int nixio__exec(lua_State *L, int m) { + const char *path = luaL_checkstring(L, 1); + const char *arg; + int argn, i; + + if (m == NIXIO_EXECVE) { + luaL_checktype(L, 2, LUA_TTABLE); + argn = lua_objlen(L, 2) + 1; + } else { + argn = lua_gettop(L); + } + + char **args = lua_newuserdata(L, sizeof(char*) * (argn + 1)); + args[argn] = NULL; + args[0] = (char *)path; + + if (m == NIXIO_EXECVE) { + for (i = 1; i < argn; i++) { + lua_rawgeti(L, 2, i); + arg = lua_tostring(L, -1); + luaL_argcheck(L, arg, 2, "invalid argument"); + args[i] = (char *)arg; + } + + if (lua_isnoneornil(L, 3)) { + execv(path, args); + } else { + luaL_checktype(L, 3, LUA_TTABLE); + argn = 0; + lua_pushnil(L); + while (lua_next(L, 3)) { + if (!lua_checkstack(L, 1)) { + lua_settop(L, 0); + return luaL_error(L, "stack overflow"); + } + + if (!lua_type(L, -2) != LUA_TSTRING || !lua_isstring(L, -1)) { + return luaL_argerror(L, 3, "invalid environment"); + } + + lua_pushfstring(L, "%s=%s", + lua_tostring(L, -2), lua_tostring(L, -1)); + + lua_insert(L, 4); + lua_pop(L, 1); + argn++; + } + + char **env = lua_newuserdata(L, sizeof(char*) * (argn + 1)); + env[argn] = NULL; + + for (i = 1; i < argn; i++) { + env[i-1] = (char *)lua_tostring(L, -i); + } + + execve(path, args, env); + } + } else { + for (i = 2; i <= argn; i++) { + arg = luaL_checkstring(L, i); + args[i-1] = (char *)arg; + } + + if (m == NIXIO_EXECV) { + execv(path, args); + } else { + execvp(path, args); + } + } + + return nixio__perror(L); +} + +#ifndef __WINNT__ +#include <sys/utsname.h> +#include <sys/times.h> +#include <sys/wait.h> +#include <pwd.h> +#include <grp.h> + static int nixio_fork(lua_State *L) { pid_t pid = fork(); if (pid == -1) { @@ -36,16 +119,55 @@ static int nixio_fork(lua_State *L) { } } -static int nixio_signal(lua_State *L) { - int sig = luaL_checkinteger(L, 1); - const char *val = luaL_checkstring(L, 2); +static int nixio_kill(lua_State *L) { + return nixio__pstatus(L, !kill(luaL_checkint(L, 1), luaL_checkint(L, 2))); +} - if (!strcmp(val, "ign") || !strcmp(val, "ignore")) { - return nixio__pstatus(L, signal(sig, SIG_IGN) != SIG_ERR); - } else if (!strcmp(val, "dfl") || !strcmp(val, "default")) { - return nixio__pstatus(L, signal(sig, SIG_DFL) != SIG_ERR); +static int nixio_getppid(lua_State *L) { + lua_pushinteger(L, getppid()); + return 1; +} + +static int nixio_getuid(lua_State *L) { + lua_pushinteger(L, getuid()); + return 1; +} + +static int nixio_getgid(lua_State *L) { + lua_pushinteger(L, getgid()); + return 1; +} + +static int nixio_setgid(lua_State *L) { + return nixio__pstatus(L, !setgid(nixio__check_group(L, 1))); +} + +static int nixio_setuid(lua_State *L) { + return nixio__pstatus(L, !setuid(nixio__check_user(L, 1))); +} + +static int nixio_nice(lua_State *L) { + int nval = luaL_checkint(L, 1); + + errno = 0; + nval = nice(nval); + + if (nval == -1 && errno) { + return nixio__perror(L); } else { - return luaL_argerror(L, 2, "supported values: ign, dfl"); + lua_pushinteger(L, nval); + return 1; + } +} + +static int nixio_setsid(lua_State *L) { + pid_t pid = setsid(); + + if (pid == -1) { + return nixio__perror(L); + } else { + lua_pushinteger(L, pid); + return 1; } } @@ -97,103 +219,229 @@ static int nixio_wait(lua_State *L) { return 3; } -static int nixio_kill(lua_State *L) { - return nixio__pstatus(L, !kill(luaL_checkint(L, 1), luaL_checkint(L, 2))); +static int nixio_times(lua_State *L) { + struct tms buf; + if (times(&buf) == -1) { + return nixio__perror(L); + } else { + lua_createtable(L, 0, 4); + lua_pushnumber(L, buf.tms_cstime); + lua_setfield(L, -2, "cstime"); + + lua_pushnumber(L, buf.tms_cutime); + lua_setfield(L, -2, "cutime"); + + lua_pushnumber(L, buf.tms_stime); + lua_setfield(L, -2, "stime"); + + lua_pushnumber(L, buf.tms_utime); + lua_setfield(L, -2, "utime"); + + return 1; + } } -static int nixio_getpid(lua_State *L) { - lua_pushinteger(L, getpid()); +static int nixio_uname(lua_State *L) { + struct utsname buf; + if (uname(&buf)) { + return nixio__perror(L); + } + + lua_createtable(L, 0, 5); + + lua_pushstring(L, buf.machine); + lua_setfield(L, -2, "machine"); + + lua_pushstring(L, buf.version); + lua_setfield(L, -2, "version"); + + lua_pushstring(L, buf.release); + lua_setfield(L, -2, "release"); + + lua_pushstring(L, buf.nodename); + lua_setfield(L, -2, "nodename"); + + lua_pushstring(L, buf.sysname); + lua_setfield(L, -2, "sysname"); + return 1; } -static int nixio_getppid(lua_State *L) { - lua_pushinteger(L, getppid()); - return 1; +#endif /* !__WINNT__ */ + +static int nixio_chdir(lua_State *L) { + return nixio__pstatus(L, !chdir(luaL_checkstring(L, 1))); } -static int nixio_getuid(lua_State *L) { - lua_pushinteger(L, getuid()); - return 1; +static int nixio_signal(lua_State *L) { + int sig = luaL_checkinteger(L, 1); + const char *val = luaL_checkstring(L, 2); + + if (!strcmp(val, "ign") || !strcmp(val, "ignore")) { + return nixio__pstatus(L, signal(sig, SIG_IGN) != SIG_ERR); + } else if (!strcmp(val, "dfl") || !strcmp(val, "default")) { + return nixio__pstatus(L, signal(sig, SIG_DFL) != SIG_ERR); + } else { + return luaL_argerror(L, 2, "supported values: ign, dfl"); + } } -static int nixio_getgid(lua_State *L) { - lua_pushinteger(L, getgid()); +static int nixio_getpid(lua_State *L) { + lua_pushinteger(L, getpid()); return 1; } -static int nixio_setgid(lua_State *L) { - gid_t gid; - if (lua_isstring(L, 1)) { - struct group *g = getgrnam(lua_tostring(L, 1)); - gid = (!g) ? -1 : g->gr_gid; - } else if (lua_isnumber(L, 1)) { - gid = lua_tointeger(L, 1); +static int nixio_getenv(lua_State *L) { + const char *key = luaL_optstring(L, 1, NULL); + if (key) { + const char *val = getenv(key); + if (val) { + lua_pushstring(L, val); + } else { + lua_pushnil(L); + } } else { - return luaL_argerror(L, 1, "supported values: <groupname>, <gid>"); + lua_newtable(L); + extern char **environ; + for (char **c = environ; *c; c++) { + const char *delim = strchr(*c, '='); + if (!delim) { + return luaL_error(L, "invalid environment"); + } + lua_pushlstring(L, *c, delim-*c); + lua_pushstring(L, delim + 1); + lua_rawset(L, -3); + } } + return 1; +} - return nixio__pstatus(L, !setgid(gid)); +static int nixio_setenv(lua_State *L) { + const char *key = luaL_checkstring(L, 1); + const char *val = luaL_optstring(L, 2, NULL); + return nixio__pstatus(L, (val) ? !setenv(key, val, 1) : !unsetenv(key)); } -static int nixio_setuid(lua_State *L) { - uid_t uid; - if (lua_isstring(L, 1)) { - struct passwd *p = getpwnam(lua_tostring(L, 1)); - uid = (!p) ? -1 : p->pw_uid; - } else if (lua_isnumber(L, 1)) { - uid = lua_tointeger(L, 1); - } else { - return luaL_argerror(L, 1, "supported values: <username>, <uid>"); - } +static int nixio_exec(lua_State *L) { + return nixio__exec(L, NIXIO_EXECV); +} - return nixio__pstatus(L, !setuid(uid)); +static int nixio_execp(lua_State *L) { + return nixio__exec(L, NIXIO_EXECVP); } -static int nixio_nice(lua_State *L) { - int nval = luaL_checkint(L, 1); +static int nixio_exece(lua_State *L) { + return nixio__exec(L, NIXIO_EXECVE); +} - errno = 0; - nval = nice(nval); +static int nixio_getcwd(lua_State *L) { + char path[PATH_MAX]; - if (nval == -1 && errno) { - return nixio__perror(L); - } else { - lua_pushinteger(L, nval); + if (getcwd(path, sizeof(path))) { + lua_pushstring(L, path); return 1; + } else { + return nixio__perror(L); } } -static int nixio_setsid(lua_State *L) { - pid_t pid = setsid(); +static int nixio_umask(lua_State *L) { + char mask[9]; + lua_pushinteger(L, + nixio__mode_write(umask(nixio__check_mode(L, 1, -1)), mask)); + lua_pushlstring(L, mask, 9); + return 2; +} - if (pid == -1) { +#ifdef __linux__ + +#include <sys/sysinfo.h> + +static int nixio_sysinfo(lua_State *L) { + struct sysinfo info; + if (sysinfo(&info)) { return nixio__perror(L); - } else { - lua_pushinteger(L, pid); - return 1; } -} -static int nixio_chdir(lua_State *L) { - return nixio__pstatus(L, !chdir(luaL_checkstring(L, 1))); + lua_createtable(L, 0, 12); + + lua_pushnumber(L, info.bufferram); + lua_setfield(L, -2, "bufferram"); + + lua_pushnumber(L, info.freehigh); + lua_setfield(L, -2, "freehigh"); + + lua_pushnumber(L, info.freeram); + lua_setfield(L, -2, "freeram"); + + lua_pushnumber(L, info.freeswap); + lua_setfield(L, -2, "freeswap"); + + lua_createtable(L, 0, 3); + for (int i=0; i<3; i++) { + lua_pushnumber(L, info.loads[i] / 65536.); + lua_rawseti(L, -2, i+1); + } + lua_setfield(L, -2, "loads"); + + lua_pushnumber(L, info.mem_unit); + lua_setfield(L, -2, "mem_unit"); + + lua_pushnumber(L, info.procs); + lua_setfield(L, -2, "procs"); + + lua_pushnumber(L, info.sharedram); + lua_setfield(L, -2, "sharedram"); + + lua_pushnumber(L, info.totalhigh); + lua_setfield(L, -2, "totalhigh"); + + lua_pushnumber(L, info.totalram); + lua_setfield(L, -2, "totalram"); + + lua_pushnumber(L, info.totalswap); + lua_setfield(L, -2, "totalswap"); + + lua_pushnumber(L, info.uptime); + lua_setfield(L, -2, "uptime"); + + return 1; } +#endif + /* module table */ static const luaL_reg R[] = { +#ifdef __linux__ + {"sysinfo", nixio_sysinfo}, +#endif +#ifndef __WINNT__ {"fork", nixio_fork}, - {"wait", nixio_wait}, {"kill", nixio_kill}, {"nice", nixio_nice}, - {"chdir", nixio_chdir}, - {"getpid", nixio_getpid}, {"getppid", nixio_getppid}, {"getuid", nixio_getuid}, {"getgid", nixio_getgid}, {"setuid", nixio_setuid}, {"setgid", nixio_setgid}, {"setsid", nixio_setsid}, + {"wait", nixio_wait}, + {"waitpid", nixio_wait}, + {"times", nixio_times}, + {"uname", nixio_uname}, +#endif + {"chdir", nixio_chdir}, {"signal", nixio_signal}, + {"getpid", nixio_getpid}, + {"getenv", nixio_getenv}, + {"setenv", nixio_setenv}, + {"putenv", nixio_setenv}, + {"exec", nixio_exec}, + {"execp", nixio_execp}, + {"exece", nixio_exece}, + {"getcwd", nixio_getcwd}, + {"umask", nixio_umask}, {NULL, NULL} }; diff --git a/libs/nixio/src/socket.c b/libs/nixio/src/socket.c index 336f34812..17c6afc79 100644 --- a/libs/nixio/src/socket.c +++ b/libs/nixio/src/socket.c @@ -17,12 +17,9 @@ */ #include "nixio.h" -#include <sys/socket.h> -#include <netinet/in.h> #include <unistd.h> #include <string.h> #include <errno.h> -#include "nixio.h" /** @@ -79,7 +76,7 @@ static int nixio_socket(lua_State *L) { sock->fd = socket(sock->domain, sock->type, sock->protocol); if (sock->fd < 0) { - return nixio__perror(L); + return nixio__perror_s(L); } return 1; @@ -95,10 +92,14 @@ static int nixio_sock_close(lua_State *L) { sock->fd = -1; do { +#ifndef __WINNT__ res = close(sockfd); +#else + res = closesocket(sockfd); +#endif } while (res == -1 && errno == EINTR); - return nixio__pstatus(L, !res); + return nixio__pstatus_s(L, !res); } /** @@ -109,7 +110,11 @@ static int nixio_sock__gc(lua_State *L) { int res; if (sock && sock->fd != -1) { do { +#ifndef __WINNT__ res = close(sock->fd); +#else + res = closesocket(sock->fd); +#endif } while (res == -1 && errno == EINTR); } return 0; @@ -141,7 +146,7 @@ static int nixio_sock_shutdown(lua_State *L) { return luaL_argerror(L, 2, "supported values: both, read, write"); } - return nixio__pstatus(L, !shutdown(sockfd, how)); + return nixio__pstatus_s(L, !shutdown(sockfd, how)); } /* module table */ diff --git a/libs/nixio/src/sockopt.c b/libs/nixio/src/sockopt.c index 2d68d12ef..7e063e4a3 100644 --- a/libs/nixio/src/sockopt.c +++ b/libs/nixio/src/sockopt.c @@ -17,17 +17,25 @@ */ #include "nixio.h" + #include <sys/types.h> -#include <sys/socket.h> -#include <netinet/in.h> -#include <netinet/tcp.h> -#include <net/if.h> #include <sys/time.h> #include <string.h> #include <fcntl.h> #include <errno.h> -#include "nixio.h" +#ifndef IPV6_ADD_MEMBERSHIP +#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP +#endif + +#ifndef IPV6_DROP_MEMBERSHIP +#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP +#endif + +static int nixio_sock_fileno(lua_State *L) { + lua_pushinteger(L, nixio__checkfd(L, 1)); + return 1; +} /** * setblocking() @@ -36,6 +44,9 @@ static int nixio_sock_setblocking(lua_State *L) { int fd = nixio__checkfd(L, 1); luaL_checkany(L, 2); int set = lua_toboolean(L, 2); + +#ifndef __WINNT__ + int flags = fcntl(fd, F_GETFL); if (flags == -1) { @@ -49,50 +60,64 @@ static int nixio_sock_setblocking(lua_State *L) { } return nixio__pstatus(L, !fcntl(fd, F_SETFL, flags)); + +#else /* __WINNT__ */ + + lua_getmetatable(L, 1); + luaL_getmetatable(L, NIXIO_META); + if (lua_equal(L, -1, -2)) { /* Socket */ + unsigned long val = !set; + return nixio__pstatus_s(L, !ioctlsocket(fd, FIONBIO, &val)); + } else { /* File */ + WSASetLastError(WSAENOTSOCK); + return nixio__perror_s(L); + } + +#endif /* __WINNT__ */ } static int nixio__gso_int(lua_State *L, int fd, int level, int opt, int set) { int value; socklen_t optlen = sizeof(value); if (!set) { - if (!getsockopt(fd, level, opt, &value, &optlen)) { + if (!getsockopt(fd, level, opt, (char *)&value, &optlen)) { lua_pushinteger(L, value); return 1; } } else { value = luaL_checkinteger(L, set); - if (!setsockopt(fd, level, opt, &value, optlen)) { + if (!setsockopt(fd, level, opt, (char *)&value, optlen)) { lua_pushboolean(L, 1); return 1; } } - return nixio__perror(L); + return nixio__perror_s(L); } static int nixio__gso_ling(lua_State *L, int fd, int level, int opt, int set) { struct linger value; socklen_t optlen = sizeof(value); if (!set) { - if (!getsockopt(fd, level, opt, &value, &optlen)) { + if (!getsockopt(fd, level, opt, (char *)&value, &optlen)) { lua_pushinteger(L, value.l_onoff ? value.l_linger : 0); return 1; } } else { value.l_linger = luaL_checkinteger(L, set); value.l_onoff = value.l_linger ? 1 : 0; - if (!setsockopt(fd, level, opt, &value, optlen)) { + if (!setsockopt(fd, level, opt, (char *)&value, optlen)) { lua_pushboolean(L, 1); return 1; } } - return nixio__perror(L); + return nixio__perror_s(L); } static int nixio__gso_timev(lua_State *L, int fd, int level, int opt, int set) { struct timeval value; socklen_t optlen = sizeof(value); if (!set) { - if (!getsockopt(fd, level, opt, &value, &optlen)) { + if (!getsockopt(fd, level, opt, (char *)&value, &optlen)) { lua_pushinteger(L, value.tv_sec); lua_pushinteger(L, value.tv_usec); return 2; @@ -100,12 +125,12 @@ static int nixio__gso_timev(lua_State *L, int fd, int level, int opt, int set) { } else { value.tv_sec = luaL_checkinteger(L, set); value.tv_usec = luaL_optinteger(L, set + 1, 0); - if (!setsockopt(fd, level, opt, &value, optlen)) { + if (!setsockopt(fd, level, opt, (char *)&value, optlen)) { lua_pushboolean(L, 1); return 1; } } - return nixio__perror(L); + return nixio__perror_s(L); } #ifdef SO_BINDTODEVICE @@ -114,7 +139,7 @@ static int nixio__gso_b(lua_State *L, int fd, int level, int opt, int set) { if (!set) { socklen_t optlen = IFNAMSIZ; char ifname[IFNAMSIZ]; - if (!getsockopt(fd, level, opt, ifname, &optlen)) { + if (!getsockopt(fd, level, opt, (char *)ifname, &optlen)) { lua_pushlstring(L, ifname, optlen); return 1; } @@ -122,16 +147,76 @@ static int nixio__gso_b(lua_State *L, int fd, int level, int opt, int set) { size_t valuelen; const char *value = luaL_checklstring(L, set, &valuelen); luaL_argcheck(L, valuelen <= IFNAMSIZ, set, "invalid interface name"); - if (!setsockopt(fd, level, opt, value, valuelen)) { + if (!setsockopt(fd, level, opt, (char *)value, valuelen)) { lua_pushboolean(L, 1); return 1; } } - return nixio__perror(L); + return nixio__perror_s(L); } #endif /* SO_BINDTODEVICE */ +static int nixio__gso_mreq4(lua_State *L, int fd, int level, int opt, int set) { + struct ip_mreq value; + socklen_t optlen = sizeof(value); + if (!set) { + char buf[INET_ADDRSTRLEN]; + if (!getsockopt(fd, level, opt, (char *)&value, &optlen)) { + if (!inet_ntop(AF_INET, &value.imr_multiaddr, buf, sizeof(buf))) { + return nixio__perror_s(L); + } + lua_pushstring(L, buf); + if (!inet_ntop(AF_INET, &value.imr_interface, buf, sizeof(buf))) { + return nixio__perror_s(L); + } + lua_pushstring(L, buf); + return 2; + } + } else { + const char *maddr = luaL_checkstring(L, set); + const char *iface = luaL_optstring(L, set + 1, "0.0.0.0"); + if (inet_pton(AF_INET, maddr, &value.imr_multiaddr) < 1) { + return nixio__perror_s(L); + } + if (inet_pton(AF_INET, iface, &value.imr_interface) < 1) { + return nixio__perror_s(L); + } + if (!setsockopt(fd, level, opt, (char *)&value, optlen)) { + lua_pushboolean(L, 1); + return 1; + } + } + return nixio__perror_s(L); +} + +static int nixio__gso_mreq6(lua_State *L, int fd, int level, int opt, int set) { + struct ipv6_mreq val; + socklen_t optlen = sizeof(val); + if (!set) { + char buf[INET_ADDRSTRLEN]; + if (!getsockopt(fd, level, opt, (char *)&val, &optlen)) { + if (!inet_ntop(AF_INET6, &val.ipv6mr_multiaddr, buf, sizeof(buf))) { + return nixio__perror_s(L); + } + lua_pushstring(L, buf); + lua_pushnumber(L, val.ipv6mr_interface); + return 2; + } + } else { + const char *maddr = luaL_checkstring(L, set); + if (inet_pton(AF_INET6, maddr, &val.ipv6mr_multiaddr) < 1) { + return nixio__perror_s(L); + } + val.ipv6mr_interface = luaL_optlong(L, set + 1, 0); + if (!setsockopt(fd, level, opt, (char *)&val, optlen)) { + lua_pushboolean(L, 1); + return 1; + } + } + return nixio__perror_s(L); +} + /** * get/setsockopt() helper */ @@ -183,9 +268,6 @@ static int nixio__getsetsockopt(lua_State *L, int set) { ); } } else if (!strcmp(level, "tcp")) { - if (sock->type != SOCK_STREAM) { - return luaL_error(L, "not a TCP socket"); - } if (!strcmp(option, "cork")) { #ifdef TCP_CORK return nixio__gso_int(L, sock->fd, IPPROTO_TCP, TCP_CORK, set); @@ -197,8 +279,71 @@ static int nixio__getsetsockopt(lua_State *L, int set) { } else { return luaL_argerror(L, 3, "supported values: cork, nodelay"); } + } else if (!strcmp(level, "ip")) { + if (!strcmp(option, "mtu")) { +#ifdef IP_MTU + return nixio__gso_int(L, sock->fd, IPPROTO_IP, IP_MTU, set); +#else + return nixio__pstatus(L, !(errno = ENOPROTOOPT)); +#endif + } else if (!strcmp(option, "hdrincl")) { + return nixio__gso_int(L, sock->fd, IPPROTO_IP, IP_HDRINCL, + set); + } else if (!strcmp(option, "multicast_loop")) { + return nixio__gso_int(L, sock->fd, IPPROTO_IP, IP_MULTICAST_LOOP, + set); + } else if (!strcmp(option, "multicast_ttl")) { + return nixio__gso_int(L, sock->fd, IPPROTO_IP, IP_MULTICAST_TTL, + set); + } else if (!strcmp(option, "multicast_if")) { + return nixio__gso_mreq4(L, sock->fd, IPPROTO_IP, IP_MULTICAST_IF, + set); + } else if (!strcmp(option, "add_membership")) { + return nixio__gso_mreq4(L, sock->fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, + set); + } else if (!strcmp(option, "drop_membership")) { + return nixio__gso_mreq4(L, sock->fd, IPPROTO_IP, IP_DROP_MEMBERSHIP, + set); + } else { + return luaL_argerror(L, 3, + "supported values: hdrincl, mtu, multicast_loop, " + "multicast_ttl, multicast_if, add_membership, drop_membership"); + } + } else if (!strcmp(level, "ipv6")) { + if (!strcmp(option, "mtu")) { +#ifdef IPV6_MTU + return nixio__gso_int(L, sock->fd, IPPROTO_IPV6, IPV6_MTU, set); +#else + return nixio__pstatus(L, !(errno = ENOPROTOOPT)); +#endif + } else if (!strcmp(option, "v6only")) { +#ifdef IPV6_V6ONLY + return nixio__gso_int(L, sock->fd, IPPROTO_IPV6, IPV6_V6ONLY, set); +#else + return nixio__pstatus(L, !(errno = ENOPROTOOPT)); +#endif + } else if (!strcmp(option, "multicast_loop")) { + return nixio__gso_int(L, sock->fd, IPPROTO_IPV6, + IPV6_MULTICAST_LOOP, set); + } else if (!strcmp(option, "multicast_hops")) { + return nixio__gso_int(L, sock->fd, IPPROTO_IPV6, + IPV6_MULTICAST_HOPS, set); + } else if (!strcmp(option, "multicast_if")) { + return nixio__gso_mreq6(L, sock->fd, IPPROTO_IPV6, + IPV6_MULTICAST_IF, set); + } else if (!strcmp(option, "add_membership")) { + return nixio__gso_mreq6(L, sock->fd, IPPROTO_IPV6, + IPV6_ADD_MEMBERSHIP, set); + } else if (!strcmp(option, "drop_membership")) { + return nixio__gso_mreq6(L, sock->fd, IPPROTO_IPV6, + IPV6_DROP_MEMBERSHIP, set); + } else { + return luaL_argerror(L, 3, + "supported values: v6only, mtu, multicast_loop, multicast_hops," + " multicast_if, add_membership, drop_membership"); + } } else { - return luaL_argerror(L, 2, "supported values: socket, tcp"); + return luaL_argerror(L, 2, "supported values: socket, tcp, ip, ipv6"); } } @@ -221,6 +366,9 @@ static const luaL_reg M[] = { {"setblocking", nixio_sock_setblocking}, {"getsockopt", nixio_sock_getsockopt}, {"setsockopt", nixio_sock_setsockopt}, + {"getopt", nixio_sock_getsockopt}, + {"setopt", nixio_sock_setsockopt}, + {"fileno", nixio_sock_fileno}, {NULL, NULL} }; @@ -232,5 +380,7 @@ void nixio_open_sockopt(lua_State *L) { luaL_getmetatable(L, NIXIO_FILE_META); lua_pushcfunction(L, nixio_sock_setblocking); lua_setfield(L, -2, "setblocking"); + lua_pushcfunction(L, nixio_sock_fileno); + lua_setfield(L, -2, "fileno"); lua_pop(L, 1); } diff --git a/libs/nixio/src/splice.c b/libs/nixio/src/splice.c index f64144627..db215efb1 100644 --- a/libs/nixio/src/splice.c +++ b/libs/nixio/src/splice.c @@ -27,6 +27,9 @@ #include <unistd.h> #include <sys/param.h> + +#ifndef __WINNT__ + #ifndef BSD #include <sys/sendfile.h> #else @@ -150,6 +153,14 @@ static const luaL_reg R[] = { {NULL, NULL} }; + void nixio_open_splice(lua_State *L) { luaL_register(L, NULL, R); } + +#else /* __WINNT__ */ + +void nixio_open_splice(lua_State *L) { +} + +#endif /* !__WINNT__ */ diff --git a/libs/nixio/src/syslog.c b/libs/nixio/src/syslog.c index 9b3581df1..89f1b1dda 100644 --- a/libs/nixio/src/syslog.c +++ b/libs/nixio/src/syslog.c @@ -18,6 +18,8 @@ #include "nixio.h" #include <string.h> + +#ifndef __WINNT__ #include <syslog.h> @@ -57,7 +59,7 @@ static int nixio_closelog(lua_State *L) { return 0; } -static int nixio__syslogmasg(lua_State *L, int dolog) { +static int nixio__syslogmask(lua_State *L, int dolog) { int priority; const char *flag = luaL_checkstring(L, 1); @@ -92,11 +94,11 @@ static int nixio__syslogmasg(lua_State *L, int dolog) { } static int nixio_setlogmask(lua_State *L) { - return nixio__syslogmasg(L, 0); + return nixio__syslogmask(L, 0); } static int nixio_syslog(lua_State *L) { - return nixio__syslogmasg(L, 1); + return nixio__syslogmask(L, 1); } /* module table */ @@ -111,3 +113,10 @@ static const luaL_reg R[] = { void nixio_open_syslog(lua_State *L) { luaL_register(L, NULL, R); } + +#else /* __WINNT__ */ + +void nixio_open_syslog(lua_State *L) { +} + +#endif /* __WINNT__ */ diff --git a/libs/nixio/src/tls-crypto.c b/libs/nixio/src/tls-crypto.c new file mode 100644 index 000000000..c93b1aa18 --- /dev/null +++ b/libs/nixio/src/tls-crypto.c @@ -0,0 +1,188 @@ +/* + * 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 <errno.h> +#include <fcntl.h> +#include <unistd.h> + +static char nixio__bin2hex[] = { +'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' +}; + +static int nixio_crypto_hash__init(lua_State *L, int hmac) { + const char *type = luaL_checkstring(L, 1); + nixio_hash *hash = lua_newuserdata(L, sizeof(nixio_hash)); + + if (!strcmp(type, "md5")) { + hash->type = NIXIO_HASH_MD5; + hash->digest_size = MD5_DIGEST_LENGTH; + hash->block_size = 64; + hash->ctx = malloc(sizeof(MD5_CTX)); + if (!hash->ctx) { + return luaL_error(L, NIXIO_OOM); + } + MD5_Init((MD5_CTX*)hash->ctx); + hash->init = (nixio_hash_initcb)MD5_Init; + hash->update = (nixio_hash_updatecb)MD5_Update; + hash->final = (nixio_hash_finalcb)MD5_Final; + } else if (!strcmp(type, "sha1")) { + hash->type = NIXIO_HASH_SHA1; + hash->digest_size = SHA_DIGEST_LENGTH; + hash->block_size = 64; + hash->ctx = malloc(sizeof(SHA_CTX)); + if (!hash->ctx) { + return luaL_error(L, NIXIO_OOM); + } + SHA1_Init((SHA_CTX*)hash->ctx); + hash->init = (nixio_hash_initcb)SHA1_Init; + hash->update = (nixio_hash_updatecb)SHA1_Update; + hash->final = (nixio_hash_finalcb)SHA1_Final; + } else { + luaL_argerror(L, 1, "supported values: md5, sha1"); + } + + luaL_getmetatable(L, NIXIO_CRYPTO_HASH_META); + lua_setmetatable(L, -2); + + if (hmac) { + const char *key = luaL_checklstring(L, 2, &hash->key_size); + if (hash->key_size > hash->block_size) { + hash->update(hash->ctx, key, hash->key_size); + hash->final(hash->digest, hash->ctx); + hash->init(hash->ctx); + hash->key_size = hash->digest_size; + memcpy(hash->key, hash->digest, hash->key_size); + } else { + memcpy(hash->key, key, hash->key_size); + } + + unsigned char pad[NIXIO_CRYPTO_BLOCK_SIZE]; + for (uint i = 0; i < hash->block_size; i++) { + pad[i] = (i < hash->key_size) ? (0x36 ^ hash->key[i]) : 0x36; + } + hash->update(hash->ctx, pad, hash->block_size); + hash->type |= NIXIO_HMAC_BIT; + } + + return 1; +} + +static int nixio_crypto_hash(lua_State *L) { + return nixio_crypto_hash__init(L, 0); +} + +static int nixio_crypto_hmac(lua_State *L) { + return nixio_crypto_hash__init(L, 1); +} + +static int nixio_crypto_hash_update(lua_State *L) { + nixio_hash *hash = luaL_checkudata(L, 1, NIXIO_CRYPTO_HASH_META); + if (hash->type) { + size_t len; + const char *chunk = luaL_checklstring(L, 2, &len); + hash->update(hash->ctx, chunk, len); + lua_pushvalue(L, 1); + return 1; + } else { + return luaL_error(L, "Tried to update finalized hash object."); + } +} + +static int nixio_crypto_hash_final(lua_State *L) { + nixio_hash *hash = luaL_checkudata(L, 1, NIXIO_CRYPTO_HASH_META); + if (hash->type & NIXIO_HMAC_BIT) { + hash->final(hash->digest, hash->ctx); + hash->init(hash->ctx); + + unsigned char pad[NIXIO_CRYPTO_BLOCK_SIZE]; + for (uint i = 0; i < hash->block_size; i++) { + pad[i] = (i < hash->key_size) ? (0x5c ^ hash->key[i]) : 0x5c; + } + + hash->update(hash->ctx, pad, hash->block_size); + hash->update(hash->ctx, hash->digest, hash->digest_size); + } + + if (hash->type) { + hash->type = NIXIO_HASH_NONE; + hash->final(hash->digest, hash->ctx); + free(hash->ctx); + } + + char hashdigest[NIXIO_DIGEST_SIZE*2]; + for (uint i=0; i < hash->digest_size; i++) { + hashdigest[2*i] = nixio__bin2hex[(hash->digest[i] & 0xf0) >> 4]; + hashdigest[2*i+1] = nixio__bin2hex[(hash->digest[i] & 0x0f)]; + } + + lua_pushlstring(L, hashdigest, hash->digest_size * 2); + memcpy(hashdigest, hash->digest, hash->digest_size); + lua_pushlstring(L, hashdigest, hash->digest_size); + + return 2; +} + +static int nixio_crypto_hash__gc(lua_State *L) { + nixio_hash *hash = luaL_checkudata(L, 1, NIXIO_CRYPTO_HASH_META); + if (hash->type) { + hash->final(hash->digest, hash->ctx); + free(hash->ctx); + hash->type = NIXIO_HASH_NONE; + } + return 0; +} + +static int nixio_crypto_hash__tostring(lua_State *L) { + nixio_hash *hash = luaL_checkudata(L, 1, NIXIO_CRYPTO_HASH_META); + lua_pushfstring(L, "nixio hash object: %p", hash); + return 1; +} + + +/* module table */ +static const luaL_reg R[] = { + {"hash", nixio_crypto_hash}, + {"hmac", nixio_crypto_hmac}, + {NULL, NULL} +}; + +/* hash table */ +static const luaL_reg M[] = { + {"update", nixio_crypto_hash_update}, + {"final", nixio_crypto_hash_final}, + {"__gc", nixio_crypto_hash__gc}, + {"__tostring", nixio_crypto_hash__tostring}, + {NULL, NULL} +}; + + + +void nixio_open_tls_crypto(lua_State *L) { + luaL_newmetatable(L, NIXIO_CRYPTO_HASH_META); + luaL_register(L, NULL, M); + lua_pushvalue(L, -1); + lua_setfield(L, -2, "__index"); + lua_pop(L, 1); + + lua_newtable(L); + luaL_register(L, NULL, R); + + lua_setfield(L, -2, "crypto"); +} diff --git a/libs/nixio/src/tls-socket.c b/libs/nixio/src/tls-socket.c index 0f504ccbb..fe4cb6075 100644 --- a/libs/nixio/src/tls-socket.c +++ b/libs/nixio/src/tls-socket.c @@ -1,4 +1,4 @@ -/* + /* * nixio - Linux I/O library for lua * * Copyright (C) 2009 Steven Barth <steven@midlink.org> @@ -65,7 +65,7 @@ static SSL* nixio__checktlssock(lua_State *L) { static int nixio_tls_sock_recv(lua_State *L) { SSL *sock = nixio__checktlssock(L); nixio_tls__check_connected(L); - int req = luaL_checkinteger(L, 2); + uint req = luaL_checkinteger(L, 2); luaL_argcheck(L, req >= 0, 2, "out of range"); @@ -172,6 +172,24 @@ static int nixio_tls_sock_send(lua_State *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); diff --git a/libs/nixio/src/user.c b/libs/nixio/src/user.c new file mode 100644 index 000000000..adfe1f4f6 --- /dev/null +++ b/libs/nixio/src/user.c @@ -0,0 +1,257 @@ +/* + * 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.h" +#include <sys/types.h> +#include <errno.h> +#include <unistd.h> +#include <sys/param.h> + +#ifndef __WINNT__ + +#include <grp.h> +#include <pwd.h> + +#ifndef BSD +#include <shadow.h> +#include <crypt.h> +#endif + +int nixio__check_group(lua_State *L, int idx) { + if (lua_isnumber(L, idx)) { + return lua_tointeger(L, idx); + } else if (lua_isstring(L, idx)) { + struct group *g = getgrnam(lua_tostring(L, idx)); + return (!g) ? -1 : g->gr_gid; + } else { + return luaL_argerror(L, idx, "supported values: <groupname>, <gid>"); + } +} + +int nixio__check_user(lua_State *L, int idx) { + if (lua_isnumber(L, idx)) { + return lua_tointeger(L, idx); + } else if (lua_isstring(L, idx)) { + struct passwd *p = getpwnam(lua_tostring(L, idx)); + return (!p) ? -1 : p->pw_uid; + } else { + return luaL_argerror(L, idx, "supported values: <username>, <uid>"); + } +} + + +static int nixio__push_group(lua_State *L, struct group *gr) { + lua_createtable(L, 0, 4); + lua_pushstring(L, gr->gr_name); + lua_setfield(L, -2, "name"); + lua_pushstring(L, gr->gr_passwd); + lua_setfield(L, -2, "passwd"); + lua_pushinteger(L, gr->gr_gid); + lua_setfield(L, -2, "gid"); + lua_newtable(L); + + for (int i=0; gr->gr_mem[i]; i++) { + lua_pushstring(L, gr->gr_mem[i]); + lua_rawseti(L, -2, i+1); + } + + lua_setfield(L, -2, "mem"); + return 1; +} + +static int nixio_getgr(lua_State *L) { + struct group *gr; + errno = 0; + if (lua_isnumber(L, 1)) { + gr = getgrgid(lua_tonumber(L, 1)); + } else if (lua_isstring(L, 1)) { + gr = getgrnam(lua_tostring(L, 1)); + } else if (lua_isnoneornil(L, 1)) { + lua_newtable(L); + int i = 0; + + setgrent(); + while ((gr = getgrent())) { + nixio__push_group(L, gr); + lua_rawseti(L, -2, ++i); + } + + if (errno) { + return nixio__perror(L); + } + + endgrent(); + return 1; + } else { + return luaL_argerror(L, 1, "supported values: <groupname>, <gid>"); + } + + if (!gr) { + return nixio__perror(L); + } else { + return nixio__push_group(L, gr); + } +} + +static int nixio__push_passwd(lua_State *L, struct passwd *pw) { + lua_createtable(L, 0, 7); + lua_pushstring(L, pw->pw_name); + lua_setfield(L, -2, "name"); + lua_pushstring(L, pw->pw_passwd); + lua_setfield(L, -2, "passwd"); + lua_pushinteger(L, pw->pw_gid); + lua_setfield(L, -2, "gid"); + lua_pushinteger(L, pw->pw_uid); + lua_setfield(L, -2, "uid"); + lua_pushstring(L, pw->pw_dir); + lua_setfield(L, -2, "dir"); + lua_pushstring(L, pw->pw_gecos); + lua_setfield(L, -2, "gecos"); + lua_pushstring(L, pw->pw_shell); + lua_setfield(L, -2, "shell"); + return 1; +} + +static int nixio_getpw(lua_State *L) { + struct passwd *pw; + errno = 0; + if (lua_isnumber(L, 1)) { + pw = getpwuid(lua_tonumber(L, 1)); + } else if (lua_isstring(L, 1)) { + pw = getpwnam(lua_tostring(L, 1)); + } else if (lua_isnoneornil(L, 1)) { + lua_newtable(L); + int i = 0; + + setpwent(); + while ((pw = getpwent())) { + nixio__push_passwd(L, pw); + lua_rawseti(L, -2, ++i); + } + + if (errno) { + return nixio__perror(L); + } + + endpwent(); + return 1; + } else { + return luaL_argerror(L, 1, "supported values: <username>, <uid>"); + } + + if (!pw) { + return nixio__perror(L); + } else { + return nixio__push_passwd(L, pw); + } +} + +#ifndef BSD +static int nixio__push_spwd(lua_State *L, struct spwd *sp) { + lua_createtable(L, 0, 9); + lua_pushstring(L, sp->sp_namp); + lua_setfield(L, -2, "namp"); + lua_pushinteger(L, sp->sp_expire); + lua_setfield(L, -2, "expire"); + lua_pushinteger(L, sp->sp_flag); + lua_setfield(L, -2, "flag"); + lua_pushinteger(L, sp->sp_inact); + lua_setfield(L, -2, "inact"); + lua_pushinteger(L, sp->sp_lstchg); + lua_setfield(L, -2, "lstchg"); + lua_pushinteger(L, sp->sp_max); + lua_setfield(L, -2, "max"); + lua_pushinteger(L, sp->sp_min); + lua_setfield(L, -2, "min"); + lua_pushinteger(L, sp->sp_warn); + lua_setfield(L, -2, "warn"); + lua_pushstring(L, sp->sp_pwdp); + lua_setfield(L, -2, "pwdp"); + return 1; +} + +static int nixio_getsp(lua_State *L) { + struct spwd *sp; + errno = 0; + if (lua_isstring(L, 1)) { + sp = getspnam(lua_tostring(L, 1)); + } else if (lua_isnoneornil(L, 1)) { + lua_newtable(L); + int i = 0; + + setspent(); + while ((sp = getspent())) { + nixio__push_spwd(L, sp); + lua_rawseti(L, -2, ++i); + } + + if (errno) { + return nixio__perror(L); + } + + endspent(); + return 1; + } else { + return luaL_argerror(L, 1, "supported values: <username>"); + } + + if (!sp) { + return nixio__perror(L); + } else { + return nixio__push_spwd(L, sp); + } +} +#endif /* !BSD */ + +static int nixio_crypt(lua_State *L) { + const char *key = luaL_checkstring(L, 1); + const char *salt = luaL_checkstring(L, 2); + const char *hash = crypt(key, salt); + + if (hash) { + lua_pushstring(L, hash); + } else { + lua_pushnil(L); + } + + return 1; +} + + +/* module table */ +static const luaL_reg R[] = { + {"crypt", nixio_crypt}, + {"getgr", nixio_getgr}, + {"getpw", nixio_getpw}, +#ifndef BSD + {"getsp", nixio_getsp}, +#endif + {NULL, NULL} +}; + +#else /* __WINNT__ */ + +static const luaL_reg R[] = { + {NULL, NULL} +}; + +#endif + +void nixio_open_user(lua_State *L) { + luaL_register(L, NULL, R); +} diff --git a/libs/nixio/standalone.mk b/libs/nixio/standalone.mk new file mode 100644 index 000000000..fe71f581a --- /dev/null +++ b/libs/nixio/standalone.mk @@ -0,0 +1,56 @@ +LUAC = luac +LUAC_OPTIONS = -s +LUA_TARGET ?= source + +LUA_MODULEDIR = /usr/local/share/lua/5.1 +LUA_LIBRARYDIR = /usr/local/lib/lua/5.1 + +OS ?= $(shell uname) + +LUA_SHLIBS = $(shell pkg-config --silence-errors --libs lua5.1 || pkg-config --silence-errors --libs lua-5.1 || pkg-config --silence-errors --libs lua) +LUA_LIBS = $(if $(LUA_SHLIBS),$(LUA_SHLIBS),$(firstword $(wildcard /usr/lib/liblua.a /usr/local/lib/liblua.a /opt/local/lib/liblua.a))) +LUA_CFLAGS = $(shell pkg-config --silence-errors --cflags lua5.1 || pkg-config --silence-errors --cflags lua-5.1 || pkg-config --silence-errors --cflags lua) + +CC = gcc +AR = ar +RANLIB = ranlib +CFLAGS = -O2 +FPIC = -fPIC +EXTRA_CFLAGS = --std=gnu99 +WFLAGS = -Wall -Werror -pedantic +CPPFLAGS = +COMPILE = $(CC) $(CPPFLAGS) $(CFLAGS) $(EXTRA_CFLAGS) $(WFLAGS) +ifeq ($(OS),Darwin) + SHLIB_FLAGS = -bundle -undefined dynamic_lookup +else + SHLIB_FLAGS = -shared +endif +LINK = $(CC) $(LDFLAGS) + +.PHONY: all build compile luacompile luasource clean luaclean + +all: build + +build: luabuild gccbuild + +luabuild: lua$(LUA_TARGET) + +gccbuild: compile +compile: + +clean: luaclean + +luasource: + mkdir -p dist$(LUA_MODULEDIR) + cp -pR root/* dist 2>/dev/null || true + cp -pR lua/* dist$(LUA_MODULEDIR) 2>/dev/null || true + for i in $$(find dist -name .svn); do rm -rf $$i || true; done + +luastrip: luasource + for i in $$(find dist -type f -name '*.lua'); do perl -e 'undef $$/; open( F, "< $$ARGV[0]" ) || die $$!; $$src = <F>; close F; $$src =~ s/--\[\[.*?\]\](--)?//gs; $$src =~ s/^\s*--.*?\n//gm; open( F, "> $$ARGV[0]" ) || die $$!; print F $$src; close F' $$i; done + +luacompile: luasource + for i in $$(find dist -name *.lua -not -name debug.lua); do $(LUAC) $(LUAC_OPTIONS) -o $$i $$i; done + +luaclean: + rm -rf dist
\ No newline at end of file |