diff options
47 files changed, 5327 insertions, 902 deletions
diff --git a/.github/workflows/debian.yml b/.github/workflows/debian.yml index 52c6f9e..6286185 100644 --- a/.github/workflows/debian.yml +++ b/.github/workflows/debian.yml @@ -29,7 +29,7 @@ jobs: dpkg-buildpackage -b -us -uc - name: Archive code coverage results - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: deb path: '*ucode*.deb' diff --git a/.github/workflows/jsdoc.yml b/.github/workflows/jsdoc.yml index b2eaefe..427250b 100644 --- a/.github/workflows/jsdoc.yml +++ b/.github/workflows/jsdoc.yml @@ -20,7 +20,7 @@ jobs: run: npm run doc - name: Archive docs as artifact - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v4 with: name: docs path: ./docs/ diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml index 31e612f..f8eb43b 100644 --- a/.github/workflows/macos.yml +++ b/.github/workflows/macos.yml @@ -15,7 +15,7 @@ jobs: - name: Setup run: | - brew install json-c + brew install json-c libmd - name: Build minimal version run: | @@ -31,7 +31,7 @@ jobs: make - name: Upload build artifacts - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v4 if: failure() with: name: minimal-build diff --git a/.github/workflows/openwrt-ci-master.yml b/.github/workflows/openwrt-ci-master.yml index d50e7dc..53ded7c 100644 --- a/.github/workflows/openwrt-ci-master.yml +++ b/.github/workflows/openwrt-ci-master.yml @@ -24,7 +24,7 @@ jobs: - uses: ynezz/gh-actions-openwrt-ci-native@v0.0.2 - name: Upload build artifacts - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v4 if: failure() with: name: native-build-artifacts @@ -32,56 +32,3 @@ jobs: path: | build/scan tests/cram/**/*.t.err - - sdk_build: - name: Build with OpenWrt ${{ matrix.arch }} SDK - runs-on: ubuntu-latest - - strategy: - fail-fast: false - matrix: - include: - - arch: mips_24kc - target: ath79-generic - - - arch: arm_cortex-a9_neon - target: imx-cortexa9 - - - arch: mipsel_24kc - target: malta-le - - - arch: aarch64_cortex-a53 - target: mediatek-mt7622 - - steps: - - uses: actions/checkout@v3 - with: - fetch-depth: 0 - - - name: Determine branch name - run: | - BRANCH="${GITHUB_BASE_REF#refs/heads/}" - echo "Building for $BRANCH" - echo "BRANCH=$BRANCH" >> $GITHUB_ENV - - - name: Build with OpenWrt ${{ matrix.arch }} SDK - uses: openwrt/gh-action-sdk@v5 - env: - ARCH: ${{ matrix.arch }} - FEEDNAME: ucode_ci - PACKAGES: ucode - - - name: Move created packages to project dir - run: cp bin/packages/${{ matrix.arch }}/ucode_ci/*.ipk . || true - - - name: Store packages - uses: actions/upload-artifact@v3 - with: - name: ${{ matrix.arch }}-packages - path: "*.ipk" - - - name: Store logs - uses: actions/upload-artifact@v3 - with: - name: ${{ matrix.arch }}-logs - path: logs/ diff --git a/.github/workflows/openwrt-ci-pull-request.yml b/.github/workflows/openwrt-ci-pull-request.yml index 2469fb7..4db2cb8 100644 --- a/.github/workflows/openwrt-ci-pull-request.yml +++ b/.github/workflows/openwrt-ci-pull-request.yml @@ -26,7 +26,7 @@ jobs: CI_CLANG_VERSION_LIST: 11 - name: Upload build artifacts - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v4 if: failure() with: name: native-build-artifacts @@ -34,56 +34,3 @@ jobs: path: | build/scan tests/cram/**/*.t.err - - sdk_build: - name: Build with OpenWrt ${{ matrix.arch }} SDK - runs-on: ubuntu-latest - - strategy: - fail-fast: false - matrix: - include: - - arch: mips_24kc - target: ath79-generic - - - arch: arm_cortex-a9_neon - target: imx-cortexa9 - - - arch: mipsel_24kc - target: malta-le - - - arch: aarch64_cortex-a53 - target: mediatek-mt7622 - - steps: - - uses: actions/checkout@v3 - with: - fetch-depth: 0 - - - name: Determine branch name - run: | - BRANCH="${GITHUB_BASE_REF#refs/heads/}" - echo "Building for $BRANCH" - echo "BRANCH=$BRANCH" >> $GITHUB_ENV - - - name: Build with OpenWrt ${{ matrix.arch }} SDK - uses: openwrt/gh-action-sdk@v5 - env: - ARCH: ${{ matrix.arch }} - FEEDNAME: ucode_ci - PACKAGES: ucode - - - name: Move created packages to project dir - run: cp bin/packages/${{ matrix.arch }}/ucode_ci/*.ipk . || true - - - name: Store packages - uses: actions/upload-artifact@v3 - with: - name: ${{ matrix.arch }}-packages - path: "*.ipk" - - - name: Store logs - uses: actions/upload-artifact@v3 - with: - name: ${{ matrix.arch }}-logs - path: logs/ @@ -21,3 +21,15 @@ examples/ !/docs/ucode.css !/docs/.nojekyll !/docs/tutorials/ +/obj-*/ +/debian/.debhelper/ +/debian/tmp/ +/debian/ucode/ +/debian/libucode/ +/debian/libucode-dev/ +/debian/ucode-modules/ +/debian/debhelper-build-stamp +/debian/files +/debian/*.debhelper +/debian/*.debhelper.log +/debian/*.substvars diff --git a/CMakeLists.txt b/CMakeLists.txt index 4564818..d7e7006 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -29,6 +29,7 @@ find_library(libubox NAMES ubox) find_library(libubus NAMES ubus) find_library(libblobmsg_json NAMES blobmsg_json) find_package(ZLIB) +find_library(libmd NAMES libmd.a md) if(LINUX) find_library(libnl_tiny NAMES nl-tiny) @@ -54,6 +55,10 @@ if(ZLIB_FOUND) set(DEFAULT_ZLIB_SUPPORT ON) endif() +if(libmd) + set(DEFAULT_DIGEST_SUPPORT ON) +endif() + option(DEBUG_SUPPORT "Debug plugin support" ON) option(FS_SUPPORT "Filesystem plugin support" ON) option(MATH_SUPPORT "Math plugin support" ON) @@ -67,6 +72,8 @@ option(ULOOP_SUPPORT "Uloop plugin support" ${DEFAULT_ULOOP_SUPPORT}) option(LOG_SUPPORT "Log plugin support" ON) option(SOCKET_SUPPORT "Socket plugin support" ON) option(ZLIB_SUPPORT "Zlib plugin support" ${DEFAULT_ZLIB_SUPPORT}) +option(DIGEST_SUPPORT "Digest plugin support" ${DEFAULT_DIGEST_SUPPORT}) +option(DIGEST_SUPPORT_EXTENDED "Enable additional hash algorithms" ${DEFAULT_DIGEST_SUPPORT}) set(LIB_SEARCH_PATH "${CMAKE_INSTALL_PREFIX}/lib/ucode/*.so:${CMAKE_INSTALL_PREFIX}/share/ucode/*.uc:./*.so:./*.uc" CACHE STRING "Default library search path") string(REPLACE ":" "\", \"" LIB_SEARCH_DEFINE "${LIB_SEARCH_PATH}") @@ -165,7 +172,7 @@ if(UBUS_SUPPORT) set_target_properties(ubus_lib PROPERTIES OUTPUT_NAME ubus PREFIX "") target_link_options(ubus_lib PRIVATE ${UCODE_MODULE_LINK_OPTIONS}) target_link_libraries(ubus_lib ${libubus} ${libblobmsg_json}) - list(APPEND CMAKE_REQUIRED_LIBRARIES ${libubox}) + list(APPEND CMAKE_REQUIRED_LIBRARIES ${libubox} ${libubus}) file(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/test.c" " #include <libubus.h> int main() { return UBUS_STATUS_NO_MEMORY; } @@ -173,7 +180,14 @@ if(UBUS_SUPPORT) try_compile(HAVE_NEW_UBUS_STATUS_CODES ${CMAKE_BINARY_DIR} "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/test.c") - check_symbol_exists(uloop_fd_set_cb "libubox/uloop.h" FD_SET_CB_EXISTS) + check_function_exists(uloop_timeout_remaining64 REMAINING64_FUNCTION_EXISTS) + check_function_exists(ubus_channel_connect HAVE_CHANNEL_SUPPORT) + if(REMAINING64_FUNCTION_EXISTS) + target_compile_definitions(ubus_lib PUBLIC HAVE_ULOOP_TIMEOUT_REMAINING64) + endif() + if(HAVE_CHANNEL_SUPPORT) + target_compile_definitions(ubus_lib PUBLIC HAVE_UBUS_CHANNEL_SUPPORT) + endif() if(HAVE_NEW_UBUS_STATUS_CODES) add_definitions(-DHAVE_NEW_UBUS_STATUS_CODES) endif() @@ -187,6 +201,11 @@ if(UCI_SUPPORT) include_directories(${uci_include_dir}) set(LIBRARIES ${LIBRARIES} uci_lib) add_library(uci_lib MODULE lib/uci.c) + list(APPEND CMAKE_REQUIRED_LIBRARIES ${libubox} ${libuci}) + check_function_exists(uci_set_conf2dir HAVE_UCI_CONF2DIR) + if (HAVE_UCI_CONF2DIR) + target_compile_definitions(uci_lib PUBLIC HAVE_UCI_CONF2DIR) + endif() set_target_properties(uci_lib PROPERTIES OUTPUT_NAME uci PREFIX "") target_link_options(uci_lib PRIVATE ${UCODE_MODULE_LINK_OPTIONS}) target_link_libraries(uci_lib ${libuci} ${libubox}) @@ -290,6 +309,19 @@ if(ZLIB_SUPPORT) target_link_libraries(zlib_lib ZLIB::ZLIB) endif() +if(DIGEST_SUPPORT) + pkg_check_modules(LIBMD REQUIRED libmd) + include_directories(${LIBMD_INCLUDE_DIRS}) + set(LIBRARIES ${LIBRARIES} digest_lib) + add_library(digest_lib MODULE lib/digest.c) + set_target_properties(digest_lib PROPERTIES OUTPUT_NAME digest PREFIX "") + if(DIGEST_SUPPORT_EXTENDED) + target_compile_definitions(digest_lib PUBLIC HAVE_DIGEST_EXTENDED) + endif() + target_link_options(digest_lib PRIVATE ${UCODE_MODULE_LINK_OPTIONS}) + target_link_libraries(digest_lib ${libmd}) +endif() + if(UNIT_TESTING) enable_testing() add_definitions(-DUNIT_TESTING) @@ -67,9 +67,7 @@ uc_chunk_add(uc_chunk_t *chunk, uint8_t byte, size_t offset) uc_offsetinfo_t *offsets = &chunk->debuginfo.offsets; size_t i; - uc_vector_grow(chunk); - - chunk->entries[chunk->count] = byte; + uc_vector_push(chunk, byte); /* offset info is encoded in bytes, for each byte, the first three bits * specify the number of source text bytes to advance since the last entry @@ -81,13 +79,11 @@ uc_chunk_add(uc_chunk_t *chunk, uint8_t byte, size_t offset) * instructions each */ for (i = offset; i > OFFSETINFO_MAX_BYTES; i -= OFFSETINFO_MAX_BYTES) { /* advance by 7 bytes */ - uc_vector_grow(offsets); - offsets->entries[offsets->count++] = OFFSETINFO_ENCODE(OFFSETINFO_MAX_BYTES, 0); + uc_vector_push(offsets, OFFSETINFO_ENCODE(OFFSETINFO_MAX_BYTES, 0)); } /* advance by `i` bytes, count one instruction */ - uc_vector_grow(offsets); - offsets->entries[offsets->count++] = OFFSETINFO_ENCODE(i, 1); + uc_vector_push(offsets, OFFSETINFO_ENCODE(i, 1)); } /* update instruction count at current offset entry */ @@ -97,18 +93,18 @@ uc_chunk_add(uc_chunk_t *chunk, uint8_t byte, size_t offset) * emit another offset entry with the initial three bits set to zero */ if (OFFSETINFO_NUM_INSNS(offsets->entries[offsets->count - 1]) >= OFFSETINFO_MAX_INSNS) { /* advance by 0 bytes, count one instruction */ - uc_vector_grow(offsets); - offsets->entries[offsets->count++] = OFFSETINFO_ENCODE(0, 1); + uc_vector_push(offsets, OFFSETINFO_ENCODE(0, 1)); } else { - offsets->entries[offsets->count - 1] = OFFSETINFO_ENCODE( - OFFSETINFO_NUM_BYTES(offsets->entries[offsets->count - 1]), - OFFSETINFO_NUM_INSNS(offsets->entries[offsets->count - 1]) + 1 - ); + uint8_t *prev = uc_vector_last(offsets); + + *prev = OFFSETINFO_ENCODE( + OFFSETINFO_NUM_BYTES(*prev), + OFFSETINFO_NUM_INSNS(*prev) + 1); } } - return chunk->count++; + return chunk->count - 1; } void @@ -124,10 +120,9 @@ uc_chunk_pop(uc_chunk_t *chunk) n_insns = OFFSETINFO_NUM_INSNS(offsets->entries[offsets->count - 1]); if (n_insns > 0) { - offsets->entries[offsets->count - 1] = OFFSETINFO_ENCODE( - OFFSETINFO_NUM_BYTES(offsets->entries[offsets->count - 1]), - n_insns - 1 - ); + uint8_t *prev = uc_vector_last(offsets); + + *prev = OFFSETINFO_ENCODE(OFFSETINFO_NUM_BYTES(*prev), n_insns - 1); } else { offsets->count--; @@ -162,14 +157,12 @@ uc_chunk_debug_add_variable(uc_chunk_t *chunk, size_t from, size_t to, size_t sl if (upval) slot += (size_t)-1 / 2; - uc_vector_grow(variables); - - variables->entries[variables->count].nameidx = uc_vallist_add(varnames, name); - variables->entries[variables->count].slot = slot; - variables->entries[variables->count].from = from; - variables->entries[variables->count].to = to; - - variables->count++; + uc_vector_push(variables, { + .nameidx = uc_vallist_add(varnames, name), + .slot = slot, + .from = from, + .to = to + }); } uc_value_t * @@ -242,7 +242,17 @@ uc_compiler_parse_advance(uc_compiler_t *compiler) compiler->parser->prev = compiler->parser->curr; while (true) { - compiler->parser->curr = *uc_lexer_next_token(&compiler->parser->lex); + uc_token_t *tok = uc_lexer_next_token(&compiler->parser->lex); + + if (tok->type == TK_COMMENT || tok->type == TK_LSTM) { + ucv_put(tok->uv); + continue; + } + else if (tok->type == TK_RSTM) { + tok->type = TK_SCOL; + } + + compiler->parser->curr = *tok; if (compiler->parser->curr.type != TK_ERROR) break; @@ -813,14 +823,13 @@ uc_compiler_declare_local(uc_compiler_t *compiler, uc_value_t *name, bool consta } } - uc_vector_grow(locals); - - locals->entries[locals->count].name = ucv_get(name); - locals->entries[locals->count].depth = -1; - locals->entries[locals->count].captured = false; - locals->entries[locals->count].from = chunk->count; - locals->entries[locals->count].constant = constant; - locals->count++; + uc_vector_push(locals, { + .name = ucv_get(name), + .depth = -1, + .captured = false, + .from = chunk->count, + .constant = constant + }); return -1; } @@ -886,16 +895,16 @@ uc_compiler_add_upval(uc_compiler_t *compiler, size_t idx, bool local, uc_value_ return -1; } - uc_vector_grow(upvals); - - upvals->entries[upvals->count].local = local; - upvals->entries[upvals->count].index = idx; - upvals->entries[upvals->count].name = ucv_get(name); - upvals->entries[upvals->count].constant = constant; + uc_vector_push(upvals, { + .local = local, + .index = idx, + .name = ucv_get(name), + .constant = constant + }); function->nupvals++; - return upvals->count++; + return upvals->count - 1; } static ssize_t @@ -1608,10 +1617,8 @@ uc_compiler_compile_call(uc_compiler_t *compiler) if (!uc_compiler_parse_check(compiler, TK_RPAREN)) { do { /* if this is a spread arg, remember the argument index */ - if (uc_compiler_parse_match(compiler, TK_ELLIP)) { - uc_vector_grow(&spreads); - spreads.entries[spreads.count++] = nargs; - } + if (uc_compiler_parse_match(compiler, TK_ELLIP)) + uc_vector_push(&spreads, nargs); /* compile argument expression */ uc_compiler_parse_precedence(compiler, P_ASSIGN); @@ -2060,6 +2067,7 @@ uc_compiler_compile_object(uc_compiler_t *compiler) /* emit merge operation */ uc_compiler_emit_insn(compiler, 0, I_MOBJ); + compiler->parser->lex.no_keyword = true; continue; } @@ -2164,14 +2172,14 @@ uc_compiler_declare_internal(uc_compiler_t *compiler, size_t srcpos, const char uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_locals_t *locals = &compiler->locals; - uc_vector_grow(locals); + uc_vector_push(locals, { + .name = ucv_string_new(name), + .depth = compiler->scope_depth, + .captured = false, + .from = chunk->count + }); - locals->entries[locals->count].name = ucv_string_new(name); - locals->entries[locals->count].depth = compiler->scope_depth; - locals->entries[locals->count].captured = false; - locals->entries[locals->count].from = chunk->count; - - return locals->count++; + return locals->count - 1; } static void @@ -2281,8 +2289,7 @@ uc_compiler_compile_if(uc_compiler_t *compiler) /* we just compiled an elsif block */ if (!expect_endif && type == TK_ELIF) { /* emit jump to skip to the end */ - uc_vector_grow(&elifs); - elifs.entries[elifs.count++] = uc_compiler_emit_jmp(compiler, 0); + uc_vector_push(&elifs, uc_compiler_emit_jmp(compiler, 0)); /* point previous conditional jump to beginning of branch */ uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); @@ -2299,8 +2306,7 @@ uc_compiler_compile_if(uc_compiler_t *compiler) } else if (!expect_endif && type == TK_ELSE) { /* emit jump to skip to the end */ - uc_vector_grow(&elifs); - elifs.entries[elifs.count++] = uc_compiler_emit_jmp(compiler, 0); + uc_vector_push(&elifs, uc_compiler_emit_jmp(compiler, 0)); /* point previous conditional jump to beginning of branch */ uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); @@ -2735,13 +2741,9 @@ uc_compiler_compile_switch(uc_compiler_t *compiler) * For the `default` case, beginning and end offsets of the * condition expression are equal. */ - uc_vector_grow(&cases); + uc_vector_extend(&cases, 3); cases.entries[cases.count++] = (locals->count - 1) - value_slot; - - uc_vector_grow(&cases); cases.entries[cases.count++] = chunk->count; - - uc_vector_grow(&cases); cases.entries[cases.count++] = chunk->count; } @@ -2759,13 +2761,9 @@ uc_compiler_compile_switch(uc_compiler_t *compiler) * 2) beginning of condition expression * 3) end of condition expression */ - uc_vector_grow(&cases); + uc_vector_extend(&cases, 3); cases.entries[cases.count++] = (locals->count - 1) - value_slot; - - uc_vector_grow(&cases); cases.entries[cases.count++] = skip_jmp + 5; - - uc_vector_grow(&cases); cases.entries[cases.count++] = uc_compiler_emit_jmp(compiler, 0); /* patch jump skipping over the case value */ @@ -2900,13 +2898,12 @@ uc_compiler_compile_try(uc_compiler_t *compiler) /* Catch block ---------------------------------------------------------- */ if (try_to > try_from) { - uc_vector_grow(ranges); - - ranges->entries[ranges->count].from = try_from; - ranges->entries[ranges->count].to = try_to; - ranges->entries[ranges->count].target = chunk->count; - ranges->entries[ranges->count].slot = ehvar_slot; - ranges->count++; + uc_vector_push(ranges, { + .from = try_from, + .to = try_to, + .target = chunk->count, + .slot = ehvar_slot + }); } uc_compiler_enter_scope(compiler); @@ -2972,10 +2969,8 @@ uc_compiler_compile_control(uc_compiler_t *compiler) uc_compiler_emit_insn(compiler, 0, locals->entries[i - 1].captured ? I_CUPV : I_POP); - uc_vector_grow(p); - - p->entries[p->count++] = - uc_compiler_emit_jmp_dest(compiler, pos, chunk->count + type); + uc_vector_push(p, + uc_compiler_emit_jmp_dest(compiler, pos, chunk->count + type)); uc_compiler_parse_consume(compiler, TK_SCOL); } diff --git a/debian/changelog b/debian/changelog index 66697c9..e87b0b5 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,4 +1,4 @@ -ucode (0.0.20220322-1) UNRELEASED; urgency=medium +ucode (0.0.20220322) UNRELEASED; urgency=medium * Initial release. diff --git a/debian/control b/debian/control index 5e9d7f3..5f86076 100644 --- a/debian/control +++ b/debian/control @@ -1,9 +1,14 @@ Source: ucode Maintainer: Paul Spooren <mail@aparcar.org> -Section: misc +Section: interpreters Priority: optional -Standards-Version: 0.0.20220322-1 -Build-Depends: debhelper-compat (= 12), libjson-c-dev +Standards-Version: 4.5.0 +Rules-Requires-Root: no +Build-Depends: debhelper-compat (= 12), cmake, pkgconf, libjson-c-dev +Homepage: https://github.com/jow-/ucode +Vcs-Browser: https://github.com/jow-/ucode +Vcs-Git: https://github.com/jow-/ucode.git +Bugs: https://github.com/jow-/ucode/issues Package: ucode Architecture: any @@ -24,6 +29,7 @@ Package: ucode-modules Architecture: any Multi-Arch: foreign Depends: libucode (= ${binary:Version}), ${shlibs:Depends}, ${misc:Depends} +Enhances: libucode Description: Extension modules for the ucode language Ucode is a tiny script language featuring ECMA script syntax, builtin JSON support and templating using Jinja inspired markup. The ucode VM is provided @@ -40,6 +46,7 @@ Architecture: any Multi-Arch: same Pre-Depends: ${misc:Pre-Depends} Depends: ${shlibs:Depends}, ${misc:Depends} +Recommends: ucode-modules Section: libs Description: Shared library for the ucode interpreter Ucode is a tiny script language featuring ECMA script syntax, builtin JSON diff --git a/debian/copyright b/debian/copyright index 4bbf4cc..4608cda 100644 --- a/debian/copyright +++ b/debian/copyright @@ -10,7 +10,7 @@ License: ISC Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. - + . THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, diff --git a/debian/lintian-overrides b/debian/lintian-overrides new file mode 100644 index 0000000..7662288 --- /dev/null +++ b/debian/lintian-overrides @@ -0,0 +1 @@ +no-manual-page diff --git a/debian/source/format b/debian/source/format index 163aaf8..89ae9db 100644 --- a/debian/source/format +++ b/debian/source/format @@ -1 +1 @@ -3.0 (quilt) +3.0 (native) diff --git a/docs/README.md b/docs/README.md index 016c7f5..92ab103 100644 --- a/docs/README.md +++ b/docs/README.md @@ -69,14 +69,14 @@ command. ### MacOS -To build on MacOS, first install *cmake* and *json-c* via +To build on MacOS, first install *cmake*, *json-c* and *libmd* via [Homebrew](https://brew.sh/), then clone the ucode repository and execute *cmake* followed by *make*: - $ brew install cmake json-c + $ brew install cmake json-c libmd $ git clone https://github.com/jow-/ucode.git $ cd ucode/ - $ cmake -DUBUS_SUPPORT=OFF -DUCI_SUPPORT=OFF -DULOOP_SUPPORT=OFF . + $ cmake -DUBUS_SUPPORT=OFF -DUCI_SUPPORT=OFF -DULOOP_SUPPORT=OFF -DCMAKE_BUILD_RPATH=/usr/local/lib -DCMAKE_INSTALL_RPATH=/usr/local/lib . $ make $ sudo make install diff --git a/docs/tutorials/02-syntax.md b/docs/tutorials/02-syntax.md index c140804..5510343 100644 --- a/docs/tutorials/02-syntax.md +++ b/docs/tutorials/02-syntax.md @@ -284,7 +284,56 @@ a counting `for` loop that is a variation of the `while` loop. %} ``` -#### 3.3. Alternative syntax +#### 3.3. Switch statement + +The `switch` statement selects code blocks to execute based on an expression's +value. Unlike other control statements, it doesn't support alternative syntax +with colons and end keywords. + +Switch statements use strict equality (`===`) for comparison. Case values can be +arbitrary expressions evaluated at runtime. Without a `break` statement, +execution continues through subsequent cases. + +The optional `default` case executes when no case matches. It's typically placed +last but will only execute if no previous matching case was found. + +The entire switch statement shares one block scope. Variables declared in any +case are visible in all cases. Curly braces may be used within cases to create +case-specific variable scopes. + +```javascript +{% + day = 3; + specialDay = 1; + + switch (day) { + case specialDay + 2: + print("Wednesday\n"); + break; + + case 1: + let message = "Start of week"; + print(message + "\n"); + break; + + case 2: { + let message = "Tuesday"; + print(message + "\n"); + break; + } + + case 4: + case 5: + print("Thursday or Friday\n"); + break; + + default: + print("Weekend\n"); + } +%} +``` + +#### 3.4. Alternative syntax Since conditional statements and loops are often used for template formatting purposes, e.g. to repeat a specific markup for each item of a list, ucode @@ -312,7 +361,8 @@ Printing a list: {% endfor %} ``` -For each control statement type, a corresponding alternative end keyword is defined: +For each control statement type except switch statements, a corresponding +alternative end keyword is defined: - `if (...): ... endif` - `for (...): ... endfor` @@ -629,4 +679,4 @@ in the table below. Operators with a higher precedence value are evaluated before operators with a lower precedence value. When operators have the same precedence, their associativity determines the order of evaluation -(e.g., left-to-right or right-to-left).
\ No newline at end of file +(e.g., left-to-right or right-to-left). diff --git a/docs/tutorials/04-arrays.md b/docs/tutorials/04-arrays.md new file mode 100644 index 0000000..789e990 --- /dev/null +++ b/docs/tutorials/04-arrays.md @@ -0,0 +1,647 @@ +Arrays in ucode are ordered collections that can store any ucode value. Unlike +many other scripting languages where arrays are implemented as hash tables or +linked lists, ucode arrays are true arrays in memory. This implementation detail +provides several distinctive characteristics that developers should understand +when working with arrays in ucode. + +## Key Characteristics of Ucode Arrays + +### True Memory Arrays + +Ucode arrays are implemented as true arrays in memory, which means: +- They offer fast random access to elements by index +- They are stored contiguously in memory +- Memory allocation expands as needed to accommodate the highest used index + +### Sparse Array Behavior + +Because ucode arrays are true arrays in memory: +- Memory is always allocated contiguously up to the highest used index +- All positions (including unused ones) consume memory +- "Empty" or unused positions contain `null` values +- There is no special optimization for sparse arrays + +### Negative Index Support + +Ucode arrays provide convenient negative indexing: +- `-1` refers to the last element +- `-2` refers to the second-last element +- And so on, allowing easy access to elements from the end of the array + +### Type Flexibility + +Arrays in ucode can hold any ucode value type: +- Booleans, numbers (integers and doubles), strings +- Objects and arrays (allowing nested arrays) +- Functions and null values +- No type restrictions between elements (unlike typed arrays in some languages) + +## Core Array Functions + +### Array Information Functions + +#### {@link module:core#length|length(x)} → {number} + +Returns the number of elements in an array. This is one of the most fundamental +array operations in ucode. + +``` +let fruits = ["apple", "banana", "orange"]; +length(fruits); // 3 + +let sparse = []; +sparse[10] = "value"; +length(sparse); // 11 (includes empty slots) +``` + +For arrays, `length()` returns the highest index plus one, which means it +includes empty slots in sparse arrays. If the input is not an array, string, or +object, `length()` returns null. + +#### {@link module:core#index|index(arr_or_str, needle)} → {number} + +Searches for a value in an array and returns the index of the first matching occurrence. + +``` +let colors = ["red", "green", "blue", "green"]; +index(colors, "green"); // 1 (returns first match) +index(colors, "yellow"); // -1 (not found) +``` + +Unlike many other languages where array search functions return -1 or null for +non-matching items, `index()` in ucode specifically returns -1 when the value +isn't found. It returns null only if the first argument is neither an array nor +a string. + +#### {@link module:core#rindex|rindex(arr_or_str, needle)} → {number} + +Similar to `index()`, but searches backward from the end of the array: + +``` +let colors = ["red", "green", "blue", "green"]; +rindex(colors, "green"); // 3 (last occurrence) +``` + +#### Checking if a Value is an Array + +To determine if a value is an array, use the `type()` function: + +``` +function isArray(value) { + return type(value) == "array"; +} + +isArray([1, 2, 3]); // true +isArray("string"); // false +isArray({key: "value"}); // false +isArray(null); // false +``` + +The `type()` function is extremely useful for defensive programming, especially +in ucode where functions often need to determine the type of their arguments to +process them correctly. + +### Manipulation Functions + +#### {@link module:core#push|push(arr, ...values)} → {*} + +Adds one or more elements to the end of an array and returns the last pushed +value. + +``` +let x = [1, 2, 3]; +push(x, 4, 5, 6); // 6 +print(x); // [1, 2, 3, 4, 5, 6] +``` + +Returns null if the array was empty or if a non-array argument was passed. + +#### {@link module:core#pop|pop(arr)} → {*} + +Removes the last element from an array and returns it. + +``` +let x = [1, 2, 3]; +let lastItem = pop(x); // 3 +print(x); // [1, 2] +``` + +Returns null if the array was empty or if a non-array argument was passed. + +#### {@link module:core#unshift|unshift(arr, ...values)} → {*} + +Adds one or more elements to the beginning of an array and returns the last +value added. + +``` +let x = [3, 4, 5]; +unshift(x, 1, 2); // 2 +print(x); // [1, 2, 3, 4, 5] +``` + +#### {@link module:core#shift|shift(arr)} → {*} + +Removes the first element from an array and returns it. + +``` +let x = [1, 2, 3]; +let firstItem = shift(x); // 1 +print(x); // [2, 3] +``` + +Returns null if the array was empty or if a non-array argument was passed. + +### Transformation Functions + +#### {@link module:core#map|map(arr, fn)} → {Array} + +Creates a new array populated with the results of calling a provided function on +every element in the calling array. + +``` +let numbers = [1, 2, 3, 4]; +let squares = map(numbers, x => x * x); // [1, 4, 9, 16] +``` + +Note: The callback function receives three arguments: +1. The current element value +2. The current index +3. The array being processed + +``` +let values = map(["foo", "bar", "baz"], function(value, index, array) { + return `${index}: ${value} (from array of length ${length(array)})`; +}); +``` + +##### Important Pitfall with Built-in Functions + +A common mistake when using `map()` is passing a built-in function directly as +the callback. Consider this example attempting to convert an array of strings to +integers: + +``` +// ⚠️ INCORRECT: This will not work as expected! +let strings = ["10", "32", "13"]; +let nums = map(strings, int); // Results will be unpredictable! +``` + +This fails because the `map()` function calls the callback with three arguments: +1. The current value (`"10"`, `"32"`, etc.) +2. The current index (`0`, `1`, `2`) +3. The original array (`["10", "32", "13"]`) + +So what actually happens is equivalent to: +``` +int("10", 0, ["10", "32", "13"]) // Interprets 0 as base parameter! +int("32", 1, ["10", "32", "13"]) // Interprets 1 as base parameter! +int("13", 2, ["10", "32", "13"]) // Interprets 2 as base parameter! +``` + +The second argument to `int()` is interpreted as the numeric base, causing +unexpected conversion results: + +- `"10"` in base 0 is interpreted as decimal 10 (base 0 is a special case that auto-detects the base) +- `"32"` in base 1 produces `NaN` because base 1 is invalid (a numeral system needs at least 2 distinct digits) +- `"13"` in base 2 produces `1` because in binary only `0` and `1` are valid digits - it converts `"1"` successfully and stops at the invalid character `"3"` + +The actual result would be `[10, NaN, 1]`, which is certainly not what you'd +expect when trying to convert string numbers to integers! + +To fix this, wrap the function call in an arrow function or a regular function +that controls the number of arguments: + +``` +// ✓ CORRECT: Using arrow function to control arguments +let strings = ["10", "32", "13"]; +let nums = map(strings, x => int(x)); // [10, 32, 13] + +// Alternative approach using a named function +function toInt(str) { + return int(str); +} +let nums2 = map(strings, toInt); // [10, 32, 13] +``` + +This pattern applies to many other built-in functions like `length()`, `trim()`, +`b64enc()`, etc. Always wrap built-in functions when using them with `map()` to +ensure they receive only the intended arguments. + +#### {@link module:core#filter|filter(arr, fn)} → {Array} + +Creates a new array with all elements that pass the test implemented by the +provided function. + +``` +let numbers = [1, 2, 3, 4, 5, 6]; +let evens = filter(numbers, x => x % 2 == 0); // [2, 4, 6] +``` + +The callback function receives the same three arguments as in `map()`. + +#### {@link module:core#sort|sort(arr, fn)} → {Array} + +Sorts the elements of an array in place and returns the sorted array, optionally +using a custom compare function. + +``` +let numbers = [3, 1, 4, 2]; +sort(numbers); // [1, 2, 3, 4] +``` + +With a custom compare function: + +``` +let people = [ + { name: "Alice", age: 25 }, + { name: "Bob", age: 30 }, + { name: "Charlie", age: 20 } +]; + +sort(people, (a, b) => a.age - b.age); +// [{ name: "Charlie", age: 20 }, { name: "Alice", age: 25 }, { name: "Bob", age: 30 }] +``` + +#### {@link module:core#reverse|reverse(arr)} → {Array} + +Returns a new array with the order of all elements reversed. + +``` +let arr = [1, 2, 3]; +reverse(arr); // [3, 2, 1] +``` + +This function also works on strings: + +``` +reverse("hello"); // "olleh" +``` + +Returns null if the argument is neither an array nor a string. + +#### {@link module:core#uniq|uniq(array)} → {Array} + +Creates a new array with all duplicate elements removed. + +``` +let array = [1, 2, 2, 3, 1, 4, 5, 4]; +uniq(array); // [1, 2, 3, 4, 5] +``` + +Returns null if a non-array argument is given. + +### Helper Functions and Recipes + +The ucode standard library provides essential array functions, but many common +operations must be implemented manually. Below, you'll find example +implementations for frequently needed array operations that aren't built into +the core library. + +These recipes demonstrate how to leverage ucode's existing functions to build +more complex array utilities. + +#### Array Intersection + +Returns a new array containing elements present in all provided arrays. + +``` +function intersect(...arrays) { + if (!length(arrays)) + return []; + + let result = arrays[0]; + + for (let i = 1; i < length(arrays); i++) { + result = filter(result, item => item in arrays[i]); + } + + return uniq(result); +} + +// Example usage: +let a = [1, 2, 3, 4]; +let b = [2, 3, 5]; +let c = [2, 3, 6]; +intersect(a, b, c); // [2, 3] +``` + +This implementation takes advantage of ucode's `in` operator, which checks if a +value exists in an array using strict equality comparison. This makes the code +more concise than using `index()` and checking if the result is not -1. + +#### Array Merge/Concatenation + +Combines multiple arrays into a new array. Taking advantage of ucode's variadic +`push()` function with the spread operator provides an elegant solution: + +``` +function merge(...arrays) { + let result = []; + + for (arr in arrays) { + push(result, ...arr); // Spreads all elements from the array directly into push + } + + return result; +} + +// Example usage: +let a = [1, 2]; +let b = [3, 4]; +let c = [5, 6]; +merge(a, b, c); // [1, 2, 3, 4, 5, 6] +``` + +This implementation leverages the variadic nature of `push()`, which accepts any +number of arguments. The spread operator (`...`) unpacks each array, passing all +its elements as individual arguments to `push()`. This is both more efficient +and more readable than nested loops. + +For processing very large arrays, you might want to use a batching approach to +avoid potential call stack limitations: + +``` +function mergeWithBatching(...arrays) { + let result = []; + const BATCH_SIZE = 1000; + + for (arr in arrays) { + // Handle array in batches to avoid excessive function arguments + for (let i = 0; i < length(arr); i += BATCH_SIZE) { + let batch = slice(arr, i, i + BATCH_SIZE); + push(result, ...batch); + } + } + + return result; +} +``` + +#### Array Difference + +Returns elements in the first array not present in subsequent arrays. + +``` +function difference(array, ...others) { + return filter(array, item => { + for (other in others) { + if (item in other) + return false; + } + return true; + }); +} + +// Example usage: +let a = [1, 2, 3, 4, 5]; +let b = [2, 3]; +let c = [4]; +difference(a, b, c); // [1, 5] +``` + +This implementation uses the `in` operator for concise and efficient membership +testing, filtering out any elements from the first array that appear in any of +the subsequent arrays. + +#### Array Chunk + +Splits an array into chunks of specified size. + +``` +function chunk(array, size) { + if (size <= 0) + return []; + + let result = []; + + for (let i = 0; i < length(array); i += size) { + push(result, slice(array, i, i + size)); + } + + return result; +} + +// Example usage: +let nums = [1, 2, 3, 4, 5, 6, 7, 8]; +chunk(nums, 3); // [[1, 2, 3], [4, 5, 6], [7, 8]] +``` + +This implementation uses a counting `for` loop combined with `slice()`, which is +both more idiomatic and more efficient. The approach: + +1. Iterates through the array in steps of `size` +2. Uses `slice()` to extract chunks of the appropriate size +3. Automatically handles the last chunk being smaller if the array length isn't divisible by the chunk size + +This pattern leverages ucode's built-in functions for cleaner, more maintainable +code. No temporary variables are needed to track the current chunk or count, +making the implementation more straightforward. + +#### Array Sum + +Calculates the sum of all numeric elements in an array. + +``` +function sum(array) { + let result = 0; + + for (item in array) { + if (type(item) == "int" || type(item) == "double") + result += item; + } + + return result; +} + +// Example usage: +let nums = [1, 2, 3, 4, 5]; +sum(nums); // 15 +``` + +#### Array Flatten + +Flattens a nested array structure. + +``` +function flatten(array, depth) { + if (depth === undefined) + depth = 1; + + let result = []; + + for (item in array) { + if (type(item) == "array" && depth > 0) { + let flattened = flatten(item, depth - 1); + for (subItem in flattened) { + push(result, subItem); + } + } else { + push(result, item); + } + } + + return result; +} + +// Example usage: +let nested = [1, [2, [3, 4], 5], 6]; +flatten(nested); // [1, 2, [3, 4], 5, 6] +flatten(nested, 2); // [1, 2, 3, 4, 5, 6] +``` + +## Advanced Array Techniques and Considerations + +### Memory Management + +When working with arrays in ucode, you should understand several important +memory characteristics that affect performance and resource usage: + +#### Sparse Array Memory Implications + +Since ucode arrays are true arrays in memory, array memory consumption scales +linearly with the highest index used, regardless of how many elements are +actually stored: + +``` +let arr = []; +arr[1000000] = "value"; // Allocates memory for 1,000,001 pointers +``` + +Important technical details about ucode array memory usage: +- Each array element consumes pointer-sized memory (4 bytes on 32-bit systems, 8 bytes on 64-bit systems) +- No optimizations exist for sparse arrays - every position up to the highest index is allocated +- When an array grows beyond its capacity, it's reallocated with a growth factor of 1.5 +- Memory is allocated even for "empty" slots (which contain the `null` value) + +For example, on a 64-bit system, creating an array with a single element at +index 1,000,000 would consume approximately 8MB of memory (1,000,001 * 8 bytes), +even though only one actual value is stored. + +``` +// Demonstrates memory consumption +let smallArray = []; +for (let i = 0; i < 10; i++) + smallArray[i] = i; + +let sparseArray = []; +sparseArray[1000000] = "far away"; + +print(`Small array has ${length(smallArray)} elements\n`); +print(`Sparse array has ${length(sparseArray)} elements\n`); +// Even though only one value is actually set, memory is allocated for all positions +``` + +This behavior makes ucode arrays efficient for random access but potentially +wasteful for very sparse data structures. For data with large gaps or when +working on memory-constrained systems, consider alternative approaches like +objects with numeric string keys. + +#### Negative Index Implementation + +While negative indices provide convenient access to elements from the end of an +array, they involve an internal conversion process: + +``` +let arr = [1, 2, 3, 4, 5]; +arr[-1]; // Internally converted to arr[length(arr) - 1], or arr[4] +arr[-3]; // Internally converted to arr[length(arr) - 3], or arr[2] +``` + +This conversion adds a small computational overhead compared to direct positive +indexing. For performance-critical code processing large arrays, consider using +positive indices when possible. + +#### Mixed-Type Arrays and Sorting + +Arrays in ucode can contain mixed types, offering great flexibility but +requiring careful handling, especially with operations like `sort()`: + +``` +let mixed = ["apple", 10, true, {name: "object"}, [1, 2]]; + +// Sort behaves differently with mixed types +// Numbers come first, then arrays, then strings, then booleans, then objects +sort(mixed); // [10, [1, 2], "apple", true, {name: "object"}] +``` + +When sorting mixed-type arrays, consider implementing a custom comparison +function to define the sorting behavior explicitly: + +``` +function mixedTypeSort(a, b) { + // Sort by type first, then by value + let typeA = type(a); + let typeB = type(b); + + if (typeA != typeB) { + // Define a type precedence order + let typePrecedence = { + "int": 1, + "double": 2, + "string": 3, + "bool": 4, + "array": 5, + "object": 6 + }; + return typePrecedence[typeA] - typePrecedence[typeB]; + } + + // If same type, compare values appropriately + if (typeA == "string" || typeA == "array") + return length(a) - length(b); + return a - b; +} + +// Now sorting is more predictable +sort(mixed, mixedTypeSort); +``` + +### Performance Optimization + +When working with large arrays, consider these optimization techniques: + +1. **Pre-allocation**: Where possible, create arrays with known capacity rather than growing incrementally +2. **Batch operations**: Minimize individual push/pop/shift/unshift calls by processing in batches +3. **Avoid unnecessary copies**: Use in-place operations when possible +4. **Filter early**: Filter arrays early in processing pipelines to reduce subsequent operation sizes + +### Array Deep Copying + +Since arrays are reference types, creating true copies requires special handling: + +``` +function deepCopy(arr) { + if (type(arr) != "array") + return arr; + + let result = []; + for (item in arr) { + if (type(item) == "array") + push(result, deepCopy(item)); + else if (type(item) == "object") + push(result, deepCopyObject(item)); + else + push(result, item); + } + return result; +} + +function deepCopyObject(obj) { + if (type(obj) != "object") + return obj; + + let result = {}; + for (key in keys(obj)) { + if (type(obj[key]) == "array") + result[key] = deepCopy(obj[key]); + else if (type(obj[key]) == "object") + result[key] = deepCopyObject(obj[key]); + else + result[key] = obj[key]; + } + return result; +} +``` + +This approach ensures all nested arrays and objects are properly copied rather +than referenced. diff --git a/docs/tutorials/05-dictionaries.md b/docs/tutorials/05-dictionaries.md new file mode 100644 index 0000000..52c9824 --- /dev/null +++ b/docs/tutorials/05-dictionaries.md @@ -0,0 +1,762 @@ +Dictionaries in ucode (also referred to as objects) are key-value collections +that provide efficient lookups by key. Unlike arrays which use numeric indices, +dictionaries use string keys to access values. Understanding how dictionaries +are implemented in ucode and their distinctive characteristics will help you +write more efficient and effective code. + +## Key Characteristics of Ucode Dictionaries + +### Hash Table Implementation with Ordered Keys + +Ucode dictionaries are implemented as ordered hash tables, which means: +- They offer fast O(1) average-case lookups by key +- Keys are hashed to determine storage location +- Memory allocation is dynamic and grows as needed +- Unlike arrays, memory is not allocated contiguously +- Key order is preserved based on declaration or assignment sequence +- Keys can be reordered using `sort()` + +### String-Only Keys with Important Limitations + +One important limitation of ucode dictionaries: +- All keys must be strings +- Non-string keys are implicitly converted to strings +- Numeric keys become string representations (e.g., `5` becomes `"5"`) +- This differs from JavaScript where objects can use Symbols as keys + +#### Warning: Null Byte Truncation in Keys + +A critical implementation detail to be aware of is that dictionary keys +containing null bytes (`\0`) will be silently truncated at the first null byte: + +``` +let dict = {"foo\0bar": 123}; +print(dict.foo); // 123 +print(exists(dict, "foo\0bar")); // false +print(exists(dict, "foo")); // true +``` + +This happens because the underlying hash table implementation treats keys as +C-style null-terminated strings. While this behavior may change in future +versions of ucode, you should currently: + +- Never use keys containing null bytes +- Sanitize any untrusted external input used as dictionary keys +- Be especially careful when using binary data or user input as keys + +This issue can lead to subtle bugs and potential security vulnerabilities if +malicious users craft input with embedded null bytes to manipulate key lookups. + +### Type Flexibility for Values + +Like arrays, dictionary values in ucode can be of any type: +- Booleans, numbers (integers and doubles), strings +- Objects and arrays (allowing nested structures) +- Functions and null values +- Different keys can store different value types + +### Reference Semantics + +Dictionaries are reference types in ucode: +- Assigning a dictionary to a new variable creates a reference, not a copy +- Modifying a dictionary through any reference affects all references +- Equality comparisons test reference identity, not structural equality + +## Core Dictionary Functions + +### Dictionary Information Functions + +#### {@link module:core#length|length(x)} → {number} + +Returns the number of keys in a dictionary. + +``` +let user = {name: "Alice", age: 30, role: "Admin"}; +length(user); // 3 + +let empty = {}; +length(empty); // 0 +``` + +For dictionaries, `length()` returns the count of keys. If the input is not an +array, string, or object, `length()` returns null. + +#### {@link module:core#keys|keys(obj)} → {Array} + +Returns an array containing all keys in the dictionary. + +``` +let config = {debug: true, timeout: 500, retries: 3}; +keys(config); // ["debug", "timeout", "retries"] +``` + +Unlike many other languages, ucode maintains key ordering based on declaration +or assignment order. Keys are returned in the same order they were defined or +assigned. + +#### {@link module:core#values|values(obj)} → {Array} + +Returns an array containing all values in the dictionary. + +``` +let counts = {apples: 5, oranges: 10, bananas: 7}; +values(counts); // [5, 10, 7] +``` + +The returned values correspond to the declaration/assignment order of keys in +the dictionary, matching the order that would be returned by `keys()`. + +#### {@link module:core#exists|exists(obj, key)} → {boolean} + +Checks whether a key exists in a dictionary. + +``` +let settings = {theme: "dark", fontSize: 16}; +exists(settings, "theme"); // true +exists(settings, "language"); // false +``` + +This function offers a straightforward way to check for key existence without +accessing the value. + +#### Checking if a Value is a Dictionary + +To determine if a value is a dictionary (object), use the `type()` function: + +``` +function isObject(value) { + return type(value) == "object"; +} + +isObject({key: "value"}); // true +isObject([1, 2, 3]); // false +isObject("string"); // false +isObject(null); // false +``` + +### Manipulation Functions + +In ucode, dictionary manipulation is performed primarily through direct property +access using dot notation or bracket notation. + +#### Adding or Updating Properties + +``` +let user = {name: "Bob"}; + +// Adding new properties +user.age = 25; +user["email"] = "bob@example.com"; + +// Updating existing properties +user.name = "Robert"; +user["age"] += 1; + +print(user); // {name: "Robert", age: 26, email: "bob@example.com"} +``` + +#### Removing Properties + +Properties can be removed using the `delete` operator: + +``` +let product = {id: "p123", name: "Laptop", price: 999, discontinued: false}; + +delete product.discontinued; +print(product); // {id: "p123", name: "Laptop", price: 999} + +delete product["price"]; +print(product); // {id: "p123", name: "Laptop"} +``` + +#### Merging Dictionaries + +Ucode supports using spread expressions to merge dictionaries elegantly: + +``` +let defaults = {theme: "light", fontSize: 12, notifications: true}; +let userSettings = {theme: "dark"}; + +// Merge dictionaries with spread syntax +let merged = {...defaults, ...userSettings}; +print(merged); // {theme: "dark", fontSize: 12, notifications: true} +``` + +When merging with spread syntax, properties from later objects overwrite those +from earlier objects if the keys are the same. This provides a clean way to +implement default options with overrides: + +``` +// Apply user preferences with fallbacks +let config = { + ...systemDefaults, + ...globalSettings, + ...userPreferences +}; +``` + +For situations requiring more complex merging logic, you can implement a custom +function: + +``` +function merge(target, ...sources) { + for (source in sources) { + for (key in keys(source)) { + target[key] = source[key]; + } + } + return target; +} + +let defaults = {theme: "light", fontSize: 12, notifications: true}; +let userSettings = {theme: "dark"}; +let merged = merge({}, defaults, userSettings); +print(merged); // {theme: "dark", fontSize: 12, notifications: true} +``` + +Note that this performs a shallow merge. For nested objects, a deep merge would +be needed: + +``` +function deepMerge(target, ...sources) { + if (!sources.length) return target; + + for (source in sources) { + if (type(source) !== "object") continue; + + for (key in keys(source)) { + if (type(source[key]) == "object" && type(target[key]) == "object") { + // Recursively merge nested objects + target[key] = deepMerge({...target[key]}, source[key]); + } else { + // For primitive values or when target key doesn't exist/isn't an object + target[key] = source[key]; + } + } + } + + return target; +} + +let userProfile = { + name: "Alice", + preferences: { + theme: "light", + sidebar: { + visible: true, + width: 250 + } + } +}; + +let updates = { + preferences: { + theme: "dark", + sidebar: { + width: 300 + } + } +}; + +let merged = deepMerge({}, userProfile, updates); +/* Result: +{ + name: "Alice", + preferences: { + theme: "dark", + sidebar: { + visible: true, + width: 300 + } + } +} +*/ +``` + +### Iteration Techniques + +#### Iterating with for-in + +The most common way to iterate through a dictionary is using `for-in`: + +``` +let metrics = {visits: 1024, conversions: 85, bounceRate: 0.35}; + +for (key in metrics) { + printf("%s: %J\n", key, metrics[key]); +} +// Output: +// visits: 1024 +// conversions: 85 +// bounceRate: 0.35 +``` + +#### Iterating over Entries (Key-Value Pairs) + +A more advanced iteration technique gives access to both keys and values: + +``` +let product = {name: "Widget", price: 19.99, inStock: true}; + +for (key in keys(product)) { + let value = product[key]; + printf("%s: %J\n", key, value); +} +``` + +#### Enhanced for-in Loop + +Ucode provides an enhanced for-in loop that can destructure keys and values: + +``` +let inventory = {apples: 50, oranges: 25, bananas: 30}; + +for (item, quantity in inventory) { + printf("We have %d %s in stock\n", quantity, item); +} +// Output: +// We have 50 apples in stock +// We have 25 oranges in stock +// We have 30 bananas in stock +``` + +This syntax offers a more elegant way to work with both keys and values +simultaneously. + +## Key Ordering and Sorting + +One distinctive feature of ucode dictionaries is their predictable key ordering. +Unlike many other languages where hash-based dictionaries have arbitrary or +implementation-dependent key ordering, ucode maintains key order based on +declaration or assignment sequence. + +### Predictable Iteration Order + +When iterating through a dictionary, keys are always processed in their +insertion order: + +``` +let scores = {}; +scores.alice = 95; +scores.bob = 87; +scores.charlie = 92; + +// Keys will be iterated in the exact order they were added +for (name in scores) { + printf("%s: %d\n", name, scores[name]); +} +// Output will consistently be: +// alice: 95 +// bob: 87 +// charlie: 92 +``` + +This predictable ordering applies to all dictionary operations: for-in loops, +`keys()`, and `values()`. + +### Sorting Dictionary Keys + +You can explicitly reorder dictionary keys using the `sort()` function: + +``` +let stats = { + average: 72.5, + median: 68, + mode: 65, + range: 45 +}; + +// Sort keys alphabetically +sort(stats); + +// Now keys will be iterated in alphabetical order +for (metric in stats) { + printf("%s: %J\n", metric, stats[metric]); +} +// Output: +// average: 72.5 +// median: 68 +// mode: 65 +// range: 45 +``` + +Custom sorting is also supported: + +``` +let inventory = { + apples: 45, + bananas: 25, + oranges: 30, + grapes: 60 +}; + +// Sort by value (quantity) in descending order +sort(inventory, (k1, k2, v1, v2) => v2 - v1); + +// Keys will now be ordered by their associated values +for (fruit, quantity in inventory) { + printf("%s: %d\n", fruit, quantity); +} +// Output: +// grapes: 60 +// apples: 45 +// oranges: 30 +// bananas: 25 +``` + +This ability to maintain and manipulate key order makes ucode dictionaries +particularly useful for: +- Configuration objects where property order matters +- UI element definitions that should be processed in a specific sequence +- Data structures that need to maintain insertion chronology + +## Advanced Dictionary Techniques + +### Nested Dictionaries + +Dictionaries can contain other dictionaries, allowing for complex data +structures: + +``` +let company = { + name: "Acme Corp", + founded: 1985, + address: { + street: "123 Main St", + city: "Metropolis", + zipCode: "12345" + }, + departments: { + engineering: { + headCount: 50, + projects: ["Alpha", "Beta", "Gamma"] + }, + sales: { + headCount: 30, + regions: ["North", "South", "East", "West"] + } + } +}; + +// Accessing nested properties +printf("Engineering headcount: %d\n", company.departments.engineering.headCount); +``` + +### Dictionary as a Cache + +Dictionaries are excellent for implementing caches or memoization: + +``` +function memoizedFibonacci() { + let cache = {}; + + // Return the actual fibonacci function with closure over cache + return function fib(n) { + // Check if result exists in cache + if (exists(cache, n)) { + return cache[n]; + } + + // Calculate result for new inputs + let result; + if (n <= 1) { + result = n; + } else { + result = fib(n-1) + fib(n-2); + } + + // Store result in cache + cache[n] = result; + return result; + }; +} + +let fibonacci = memoizedFibonacci(); +printf("Fibonacci 40: %d\n", fibonacci(40)); // Fast computation due to caching +``` + +### Using Dictionaries for Lookups + +Dictionaries excel at lookup tables and can replace complex conditional logic: + +``` +// Instead of: +function getStatusMessage(code) { + if (code == 200) return "OK"; + else if (code == 404) return "Not Found"; + else if (code == 500) return "Server Error"; + // ...and so on + return "Unknown Status"; +} + +// Use a dictionary: +let statusMessages = { + "200": "OK", + "404": "Not Found", + "500": "Server Error" +}; + +function getStatusMessage(code) { + return statusMessages[code] ?? "Unknown Status"; +} +``` + +### Dictionary Patterns and Recipes + +#### Deep Clone + +Creating a deep copy of a dictionary with nested objects: + +``` +function deepClone(obj) { + if (type(obj) != "object") { + return obj; + } + + let clone = {}; + for (key in keys(obj)) { + if (type(obj[key]) == "object") { + clone[key] = deepClone(obj[key]); + } else if (type(obj[key]) == "array") { + clone[key] = deepCloneArray(obj[key]); + } else { + clone[key] = obj[key]; + } + } + return clone; +} + +function deepCloneArray(arr) { + let result = []; + for (item in arr) { + if (type(item) == "object") { + push(result, deepClone(item)); + } else if (type(item) == "array") { + push(result, deepCloneArray(item)); + } else { + push(result, item); + } + } + return result; +} +``` + +#### Dictionary Filtering + +Creating a new dictionary with only desired key-value pairs: + +``` +function filterObject(obj, filterFn) { + let result = {}; + for (key in keys(obj)) { + if (filterFn(key, obj[key])) { + result[key] = obj[key]; + } + } + return result; +} + +// Example: Keep only numeric values +let mixed = {a: 1, b: "string", c: 3, d: true, e: 4.5}; +let numbersOnly = filterObject(mixed, (key, value) => + type(value) == "int" || type(value) == "double" +); +print(numbersOnly); // {a: 1, c: 3, e: 4.5} +``` + +#### Object Mapping + +Transforming values in a dictionary while keeping the same keys: + +``` +function mapObject(obj, mapFn) { + let result = {}; + for (key in keys(obj)) { + result[key] = mapFn(key, obj[key]); + } + return result; +} + +// Example: Double all numeric values +let prices = {apple: 1.25, banana: 0.75, cherry: 2.50}; +let discountedPrices = mapObject(prices, (fruit, price) => price * 0.8); +print(discountedPrices); // {apple: 1, banana: 0.6, cherry: 2} +``` + +#### Dictionary Equality + +Comparing dictionaries by value instead of by reference: + +``` +function objectEquals(obj1, obj2) { + // Check if both are objects + if (type(obj1) != "object" || type(obj2) != "object") { + return obj1 === obj2; + } + + // Check key count + let keys1 = keys(obj1); + let keys2 = keys(obj2); + if (length(keys1) != length(keys2)) { + return false; + } + + // Check each key-value pair + for (key in keys1) { + if (!exists(obj2, key)) { + return false; + } + + if (type(obj1[key]) == "object" && type(obj2[key]) == "object") { + // Recursively check nested objects + if (!objectEquals(obj1[key], obj2[key])) { + return false; + } + } else if (type(obj1[key]) == "array" && type(obj2[key]) == "array") { + // For arrays, we would need array equality check + if (!arrayEquals(obj1[key], obj2[key])) { + return false; + } + } else if (obj1[key] !== obj2[key]) { + return false; + } + } + return true; +} + +function arrayEquals(arr1, arr2) { + if (length(arr1) != length(arr2)) { + return false; + } + + for (let i = 0; i < length(arr1); i++) { + if (type(arr1[i]) == "object" && type(arr2[i]) == "object") { + if (!objectEquals(arr1[i], arr2[i])) { + return false; + } + } else if (type(arr1[i]) == "array" && type(arr2[i]) == "array") { + if (!arrayEquals(arr1[i], arr2[i])) { + return false; + } + } else if (arr1[i] !== arr2[i]) { + return false; + } + } + return true; +} +``` + +## Performance Considerations and Best Practices + +### Hash Collision Impacts + +Since ucode dictionaries use hash tables: +- Hash collisions can occur (different keys hash to same value) +- Hash collision resolution affects performance +- As dictionaries grow large, performance degradation may occur +- Performance is generally consistent but can have occasional spikes due to rehashing + +### Key Naming Considerations + +String keys have important implications: +- Choose short, descriptive keys to minimize memory usage +- Be consistent with key naming conventions +- Remember that property access via dot notation (`obj.prop`) and bracket notation (`obj["prop"]`) are equivalent +- Keys containing special characters or reserved words must use bracket notation: `obj["special-key"]` + +### Memory Usage Optimization + +To optimize dictionary memory usage: +- Delete unused keys to prevent memory leaks +- Use shallow structures when possible +- Consider serialization for large dictionaries not actively used +- Be aware that circular references delay garbage collection until mark-sweep GC runs + +``` +// Circular reference example +let obj1 = {}; +let obj2 = {ref: obj1}; +obj1.ref = obj2; // Creates a circular reference + +// While reference counting won't collect these immediately, +// a mark-sweep GC run will eventually reclaim this memory +// when the objects become unreachable from the root scope +``` + +### Performance Patterns + +#### Property Access Optimization + +When repeatedly accessing the same property in loops, consider caching: + +``` +// Less efficient - repeated property access +for (let i = 0; i < 1000; i++) { + processValue(config.complexComputedValue); +} + +// More efficient - cache the property +let cachedValue = config.complexComputedValue; +for (let i = 0; i < 1000; i++) { + processValue(cachedValue); +} +``` + +#### Key Existence Check Performance + +Different methods for checking key existence have varying performance +implications: + +``` +// Option 1: Using exists() - most explicit and readable +if (exists(user, "email")) { + sendEmail(user.email); +} + +// Option 2: Direct property access with null check +if (user.email != null) { + sendEmail(user.email); +} + +// Option 3: Using in operator with keys +if ("email" in keys(user)) { + sendEmail(user.email); +} +``` + +Option 1 is typically the most performant as it's specifically designed for +this purpose. + +### Dictionary Implementation Details + +Understanding internal implementation details can help write more efficient code: + +1. **Initial Capacity**: Dictionaries start with a small capacity and grow as needed +2. **Load Factor**: When dictionaries reach a certain fullness threshold, they're resized +3. **Hash Function**: Keys are hashed using a specialized string hashing function +4. **Collision Resolution**: Ucode typically uses open addressing with linear probing +5. **Deletion**: When keys are deleted, they're marked as deleted but space isn't reclaimed until rehashing +6. **Order Preservation**: Unlike many hash table implementations, ucode tracks and maintains insertion order + +These implementation details explain why: +- Iterating over a dictionary with many deleted keys might be slower +- Adding many keys may trigger occasional performance pauses for rehashing +- Key order is consistent and predictable, matching declaration/assignment order +- Dictionaries can be deliberately reordered using `sort()` + +## Conclusion + +Dictionaries in ucode provide a powerful and flexible way to organize data by +key-value relationships. By understanding their implementation characteristics +and following best practices, you can effectively leverage dictionaries for +everything from simple configuration storage to complex nested data structures. + +Remember that dictionaries excel at: +- Fast lookups by string key +- Dynamic property addition and removal +- Representing structured data +- Implementing caches and lookup tables + +When working with large dictionaries or performance-critical code, consider the +memory usage patterns and optimization techniques described in this article to +ensure your code remains efficient and maintainable. diff --git a/docs/tutorials/tutorials.json b/docs/tutorials/tutorials.json index df4e339..e6528cc 100644 --- a/docs/tutorials/tutorials.json +++ b/docs/tutorials/tutorials.json @@ -7,5 +7,11 @@ }, "03-memory": { "title": "Memory Management" + }, + "04-arrays": { + "title": "Working with Arrays" + }, + "05-dictionaries": { + "title": "Working with Dictionaries" } } diff --git a/include/linux/nl80211.h b/include/linux/nl80211.h index f97f5ad..6d11437 100644 --- a/include/linux/nl80211.h +++ b/include/linux/nl80211.h @@ -2868,6 +2868,9 @@ enum nl80211_commands { * nested item, it contains attributes defined in * &enum nl80211_if_combination_attrs. * + * @NL80211_ATTR_VIF_RADIO_MASK: Bitmask of allowed radios (u32). + * A value of 0 means all radios. + * * @NUM_NL80211_ATTR: total number of nl80211_attrs available * @NL80211_ATTR_MAX: highest attribute number currently defined * @__NL80211_ATTR_AFTER_LAST: internal use @@ -3416,6 +3419,8 @@ enum nl80211_attrs { NL80211_ATTR_WIPHY_RADIOS, NL80211_ATTR_WIPHY_INTERFACE_COMBINATIONS, + NL80211_ATTR_VIF_RADIO_MASK, + /* add attributes here, update the policy in nl80211.c */ __NL80211_ATTR_AFTER_LAST, @@ -4698,6 +4703,7 @@ enum nl80211_survey_info { * overrides all other flags. * @NL80211_MNTR_FLAG_ACTIVE: use the configured MAC address * and ACK incoming unicast packets. + * @NL80211_MNTR_FLAG_SKIP_TX: do not pass local tx packets * * @__NL80211_MNTR_FLAG_AFTER_LAST: internal use * @NL80211_MNTR_FLAG_MAX: highest possible monitor flag @@ -4710,6 +4716,7 @@ enum nl80211_mntr_flags { NL80211_MNTR_FLAG_OTHER_BSS, NL80211_MNTR_FLAG_COOK_FRAMES, NL80211_MNTR_FLAG_ACTIVE, + NL80211_MNTR_FLAG_SKIP_TX, /* keep last */ __NL80211_MNTR_FLAG_AFTER_LAST, @@ -8031,6 +8038,8 @@ enum nl80211_ap_settings_flags { * @NL80211_WIPHY_RADIO_ATTR_INTERFACE_COMBINATION: Supported interface * combination for this radio. Attribute may be present multiple times * and contains attributes defined in &enum nl80211_if_combination_attrs. + * @NL80211_WIPHY_RADIO_ATTR_ANTENNA_MASK: bitmask (u32) of antennas + * connected to this radio. * * @__NL80211_WIPHY_RADIO_ATTR_LAST: Internal * @NL80211_WIPHY_RADIO_ATTR_MAX: Highest attribute @@ -8041,6 +8050,7 @@ enum nl80211_wiphy_radio_attrs { NL80211_WIPHY_RADIO_ATTR_INDEX, NL80211_WIPHY_RADIO_ATTR_FREQ_RANGE, NL80211_WIPHY_RADIO_ATTR_INTERFACE_COMBINATION, + NL80211_WIPHY_RADIO_ATTR_ANTENNA_MASK, /* keep last */ __NL80211_WIPHY_RADIO_ATTR_LAST, diff --git a/include/ucode/lexer.h b/include/ucode/lexer.h index 1728aa3..fd375b8 100644 --- a/include/ucode/lexer.h +++ b/include/ucode/lexer.h @@ -121,12 +121,14 @@ typedef enum { TK_EXPORT, TK_EOF, + TK_COMMENT, TK_ERROR } uc_tokentype_t; typedef enum { UC_LEX_IDENTIFY_BLOCK, UC_LEX_BLOCK_EXPRESSION_EMIT_TAG, + UC_LEX_BLOCK_STATEMENT_EMIT_TAG, UC_LEX_BLOCK_COMMENT, UC_LEX_IDENTIFY_TOKEN, UC_LEX_PLACEHOLDER_START, @@ -138,6 +140,7 @@ typedef struct { uc_tokentype_t type; uc_value_t *uv; size_t pos; + size_t end; } uc_token_t; typedef struct { @@ -174,10 +177,10 @@ typedef struct { } uc_lexer_t; -__hidden void uc_lexer_init(uc_lexer_t *lex, uc_parse_config_t *config, uc_source_t *source); -__hidden void uc_lexer_free(uc_lexer_t *lex); +void uc_lexer_init(uc_lexer_t *lex, uc_parse_config_t *config, uc_source_t *source); +void uc_lexer_free(uc_lexer_t *lex); -__hidden uc_token_t *uc_lexer_next_token(uc_lexer_t *lex); +uc_token_t *uc_lexer_next_token(uc_lexer_t *lex); __hidden bool uc_lexer_is_keyword(uc_value_t *label); diff --git a/include/ucode/types.h b/include/ucode/types.h index c0ccd38..f149b98 100644 --- a/include/ucode/types.h +++ b/include/ucode/types.h @@ -206,14 +206,16 @@ typedef struct { uc_declare_vector(uc_resource_types_t, uc_resource_type_t *); - -/* Object iteration */ - -extern uc_list_t uc_object_iterators; - typedef struct { uc_list_t list; - struct lh_entry *pos; + struct lh_table *table; + union { + struct lh_entry *pos; + struct { + const void *k; + unsigned long hash; + } kh; + } u; } uc_object_iterator_t; @@ -263,6 +265,19 @@ uc_search_path_free(uc_search_path_t *search_path) { } +/* TLS data */ + +typedef struct { + /* VM owning installed signal handlers */ + uc_vm_t *signal_handler_vm; + + /* Object iteration */ + uc_list_t object_iterators; +} uc_thread_context_t; + +__hidden uc_thread_context_t *uc_thread_context_get(void); + + /* VM definitions */ typedef enum { @@ -381,6 +396,7 @@ uc_value_t *ucv_array_push(uc_value_t *, uc_value_t *); uc_value_t *ucv_array_shift(uc_value_t *); uc_value_t *ucv_array_unshift(uc_value_t *, uc_value_t *); void ucv_array_sort(uc_value_t *, int (*)(const void *, const void *)); +void ucv_array_sort_r(uc_value_t *, int (*)(uc_value_t *, uc_value_t *, void *), void *); bool ucv_array_delete(uc_value_t *, size_t, size_t); bool ucv_array_set(uc_value_t *, size_t, uc_value_t *); size_t ucv_array_length(uc_value_t *); @@ -389,6 +405,7 @@ uc_value_t *ucv_object_new(uc_vm_t *); uc_value_t *ucv_object_get(uc_value_t *, const char *, bool *); bool ucv_object_add(uc_value_t *, const char *, uc_value_t *); void ucv_object_sort(uc_value_t *, int (*)(const void *, const void *)); +void ucv_object_sort_r(uc_value_t *, int (*)(const char *, uc_value_t *, const char *, uc_value_t *, void *), void *); bool ucv_object_delete(uc_value_t *, const char *); size_t ucv_object_length(uc_value_t *); @@ -415,6 +432,17 @@ uc_value_t *ucv_resource_new(uc_resource_type_t *, void *); void *ucv_resource_data(uc_value_t *uv, const char *); void **ucv_resource_dataptr(uc_value_t *, const char *); +static inline uc_value_t * +ucv_resource_create(uc_vm_t *vm, const char *type, void *value) +{ + uc_resource_type_t *t = NULL; + + if (type && (t = ucv_resource_type_lookup(vm, type)) == NULL) + return NULL; + + return ucv_resource_new(t, value); +} + uc_value_t *ucv_regexp_new(const char *, bool, bool, bool, char **); uc_value_t *ucv_upvalref_new(size_t); diff --git a/include/ucode/util.h b/include/ucode/util.h index a3692d5..1360d28 100644 --- a/include/ucode/util.h +++ b/include/ucode/util.h @@ -30,6 +30,14 @@ #define __hidden __attribute__((visibility("hidden"))) #endif +#ifndef localfunc +# if defined(__GNUC__) || defined(__clang__) +# define localfunc static __attribute__((noinline,unused)) +# else +# define localfunc static inline +# endif +#endif + /* alignment & array size */ @@ -42,69 +50,6 @@ #endif -/* vector macros */ - -#define UC_VECTOR_CHUNK_SIZE 8 - -#define uc_declare_vector(name, type) \ - typedef struct { \ - size_t count; \ - type *entries; \ - } name - -#define uc_vector_grow(vec) \ - do { \ - if (((vec)->count % UC_VECTOR_CHUNK_SIZE) == 0) { \ - (vec)->entries = xrealloc((vec)->entries, sizeof((vec)->entries[0]) * ((vec)->count + UC_VECTOR_CHUNK_SIZE)); \ - memset(&(vec)->entries[(vec)->count], 0, sizeof((vec)->entries[0]) * UC_VECTOR_CHUNK_SIZE); \ - } \ - } while(0) - -#define uc_vector_clear(vec) \ - do { \ - free((vec)->entries); \ - (vec)->entries = NULL; \ - (vec)->count = 0; \ - } while(0) - -#define uc_vector_first(vec) \ - (&((vec)->entries[0])) - -#define uc_vector_last(vec) \ - (&((vec)->entries[(vec)->count - 1])) - -#define uc_vector_push(vec, val) do { \ - uc_vector_grow(vec); \ - (vec)->entries[(vec)->count++] = (val); \ -} while(0) - - -/* linked lists */ - -typedef struct uc_list { - struct uc_list *prev; - struct uc_list *next; -} uc_list_t; - -static inline void uc_list_insert(uc_list_t *list, uc_list_t *item) -{ - list->next->prev = item; - item->next = list->next; - item->prev = list; - list->next = item; -} - -static inline void uc_list_remove(uc_list_t *item) -{ - item->next->prev = item->prev; - item->prev->next = item->next; - item->prev = item->next = item; -} - -#define uc_list_foreach(item, list) \ - for (uc_list_t *item = (list)->next; item != (list); item = item->next) - - /* "failsafe" utility functions */ static inline void *xcalloc(size_t size, size_t nmemb) { @@ -195,4 +140,159 @@ static inline struct printbuf *xprintbuf_new(void) { return pb; } + +/* linked lists */ + +typedef struct uc_list { + struct uc_list *prev; + struct uc_list *next; +} uc_list_t; + +static inline void uc_list_insert(uc_list_t *list, uc_list_t *item) +{ + list->next->prev = item; + item->next = list->next; + item->prev = list; + list->next = item; +} + +static inline void uc_list_remove(uc_list_t *item) +{ + item->next->prev = item->prev; + item->prev->next = item->next; + item->prev = item->next = item; +} + +#define uc_list_foreach(item, list) \ + for (uc_list_t *item = (list)->next; item != (list); item = item->next) + + +/* vector macros */ + +#define UC_VECTOR_INIT_SIZE 8 + +#define uc_declare_vector(name, type) \ + typedef struct { \ + size_t count; \ + type *entries; \ + } name + +localfunc size_t +uc_vector_capacity(size_t init, size_t count) +{ + if (count == 0) + return init; + + size_t capacity = init; + + while (capacity <= count) + capacity += (capacity >> 1); + + return capacity; +} + +localfunc void +uc_vector_reduce_(char **base, size_t itemsize, size_t count, size_t remove) +{ + if (*base == NULL) + return; + + if (remove > count) + remove = count; + + size_t next_capacity = uc_vector_capacity(UC_VECTOR_INIT_SIZE, count - remove); + + if (uc_vector_capacity(next_capacity, count) != next_capacity) + *base = (__typeof__(*base))xrealloc(*base, itemsize * next_capacity); +} + +localfunc void * +uc_vector_extend_(char **base, size_t itemsize, size_t count, size_t add) +{ + size_t curr_capacity = uc_vector_capacity(UC_VECTOR_INIT_SIZE, count); + + if (*base == NULL || count + add >= curr_capacity) { + size_t next_capacity = uc_vector_capacity(curr_capacity, count + add); + + *base = (__typeof__(*base))xrealloc(*base, itemsize * next_capacity); + + memset(*base + itemsize * count, 0, + itemsize * (next_capacity - count)); + } + + return *base + itemsize * count; +} + +#define uc_vector_reduce(vec, remove) \ + uc_vector_reduce_((char **)&(vec)->entries, sizeof((vec)->entries[0]), (vec)->count, (remove)) + +#define uc_vector_extend(vec, add) \ + (__typeof__((vec)->entries + 0)) uc_vector_extend_( \ + (char **)&(vec)->entries, \ + sizeof((vec)->entries[0]), \ + (vec)->count, (add)) + +#define uc_vector_grow(vec) \ + uc_vector_extend_((char **)&(vec)->entries, sizeof((vec)->entries[0]), (vec)->count, 1) + +#define uc_vector_clear(vec) \ + do { \ + free((vec)->entries); \ + (vec)->entries = NULL; \ + (vec)->count = 0; \ + } while(0) + +#define uc_vector_first(vec) \ + (&((vec)->entries[0])) + +#define uc_vector_last(vec) \ + ((vec)->count ? &((vec)->entries[(vec)->count - 1]) : NULL) + +#define uc_vector_push(vec, ...) ({ \ + *uc_vector_extend((vec), 1) = ((__typeof__((vec)->entries[0]))__VA_ARGS__); \ + &(vec)->entries[(vec)->count++]; \ +}) + +#define uc_vector_pop(vec) \ + ((vec)->count ? &(vec)->entries[--(vec)->count] : NULL) + +#define uc_vector_foreach(vec, iter) \ + for (__typeof__((vec)->entries + 0) iter = (vec)->entries; \ + iter < (vec)->entries + (vec)->count; \ + iter++) + +#define uc_vector_foreach_reverse(vec, iter) \ + for (__typeof__((vec)->entries + 0) iter = (vec)->count \ + ? (vec)->entries + (vec)->count - 1 : NULL; \ + iter != NULL && iter >= (vec)->entries; \ + iter--) + +#ifdef __APPLE__ + +# define uc_vector_sort_cb(fn_, optype_, udtype_, ...) \ + int fn_(void *ud, const void *k1, const void *k2) { \ + optype_ v1 = *(optype_ *)k1; \ + optype_ v2 = *(optype_ *)k2; \ + udtype_ ctx = (udtype_)ud; \ + __VA_ARGS__ \ + } + +# define uc_vector_sort(v_, cmp_, ud_) \ + qsort_r((v_)->entries, (v_)->count, sizeof((v_)->entries[0]), ud_, cmp_) + +#else + +# define uc_vector_sort_cb(fn_, optype_, udtype_, ...) \ + int fn_(const void *k1, const void *k2, void *ud) { \ + optype_ v1 = *(optype_ *)k1; \ + optype_ v2 = *(optype_ *)k2; \ + udtype_ ctx = (udtype_)ud; \ + __VA_ARGS__ \ + } + +# define uc_vector_sort(v_, cmp_, ud_) \ + qsort_r((v_)->entries, (v_)->count, sizeof((v_)->entries[0]), cmp_, ud_) + +#endif + #endif /* UCODE_UTIL_H */ @@ -145,17 +145,21 @@ emit_op(uc_lexer_t *lex, ssize_t pos, int type, uc_value_t *uv) else lex->curr.pos = (size_t)pos; + lex->curr.end = lex->source->off; + return &lex->curr; } static uc_token_t * emit_buffer(uc_lexer_t *lex, ssize_t pos, int type, const char *strip_trailing_chars) { uc_token_t *rv = NULL; + char *p; if (lex->buffer.count) { if (strip_trailing_chars) - while (lex->buffer.count > 0 && strchr(strip_trailing_chars, *uc_vector_last(&lex->buffer))) - lex->buffer.count--; + for (p = uc_vector_last(&lex->buffer); + p && strchr(strip_trailing_chars, *p); + lex->buffer.count--, p = uc_vector_last(&lex->buffer)); rv = emit_op(lex, pos, type, ucv_string_new_length(uc_vector_first(&lex->buffer), lex->buffer.count)); @@ -172,16 +176,23 @@ emit_buffer(uc_lexer_t *lex, ssize_t pos, int type, const char *strip_trailing_c static uc_token_t * parse_comment(uc_lexer_t *lex, int kind) { + size_t off = lex->source->off - 1; int ch; + uc_vector_push(&lex->buffer, '/'); + while (true) { ch = next_char(lex); + uc_vector_push(&lex->buffer, ch); + if (kind == '/' && (ch == '\n' || ch == EOF)) break; - if (kind == '*' && ch == '*' && check_char(lex, '/')) + if (kind == '*' && ch == '*' && check_char(lex, '/')) { + uc_vector_push(&lex->buffer, '/'); break; + } if (ch == EOF) { lex->state = UC_LEX_EOF; @@ -190,7 +201,7 @@ parse_comment(uc_lexer_t *lex, int kind) } } - return NULL; + return emit_buffer(lex, off, TK_COMMENT, NULL); } static void @@ -338,7 +349,7 @@ parse_escape(uc_lexer_t *lex, const char *regex_macros) static uc_token_t * parse_string(uc_lexer_t *lex, int kind) { - uc_token_t *err; + uc_token_t *err, *tok; unsigned type; int code, ch; size_t off; @@ -359,7 +370,10 @@ parse_string(uc_lexer_t *lex, int kind) if (type == TK_TEMPLATE && check_char(lex, '{')) { lex->state = UC_LEX_PLACEHOLDER_START; - return emit_buffer(lex, off, type, NULL); + tok = emit_buffer(lex, off, type, NULL); + tok->end -= 2; + + return tok; } uc_vector_push(&lex->buffer, '$'); @@ -952,8 +966,7 @@ lex_step(uc_lexer_t *lex) /* found start of statement block */ case '%': - lex->state = UC_LEX_IDENTIFY_TOKEN; - lex->block = STATEMENTS; + lex->state = UC_LEX_BLOCK_STATEMENT_EMIT_TAG; if (check_char(lex, '-')) strip = " \n\t\v\f\r"; @@ -987,6 +1000,8 @@ lex_step(uc_lexer_t *lex) if (!tok) continue; + tok->end -= 2; + return tok; @@ -1012,18 +1027,24 @@ lex_step(uc_lexer_t *lex) return emit_op(lex, lex->lastoff, TK_ERROR, ucv_string_new("Unterminated template block")); } + tok = emit_op(lex, lex->lastoff, TK_COMMENT, NULL); + lex->lastoff = lex->source->off; lex->state = UC_LEX_IDENTIFY_BLOCK; - continue; - + return tok; case UC_LEX_BLOCK_EXPRESSION_EMIT_TAG: lex->state = UC_LEX_IDENTIFY_TOKEN; lex->block = EXPRESSION; - return emit_op(lex, lex->source->off, TK_LEXP, NULL); + return emit_op(lex, lex->source->off - 2, TK_LEXP, NULL); + case UC_LEX_BLOCK_STATEMENT_EMIT_TAG: + lex->state = UC_LEX_IDENTIFY_TOKEN; + lex->block = STATEMENTS; + + return emit_op(lex, lex->source->off - 2, TK_LSTM, NULL); case UC_LEX_IDENTIFY_TOKEN: do { tok = lex_find_token(lex); } while (tok == NULL); @@ -1042,7 +1063,7 @@ lex_step(uc_lexer_t *lex) lex->state = UC_LEX_IDENTIFY_BLOCK; lex->block = NONE; - tok = emit_op(lex, -2, TK_SCOL, NULL); + tok = emit_op(lex, -2, TK_RSTM, NULL); } /* found end of expression block */ @@ -1092,7 +1113,10 @@ lex_step(uc_lexer_t *lex) case UC_LEX_PLACEHOLDER_END: lex->state = UC_LEX_IDENTIFY_TOKEN; - return parse_string(lex, '`'); + tok = parse_string(lex, '`'); + tok->pos++; + + return tok; case UC_LEX_EOF: @@ -1152,8 +1176,10 @@ uc_lexer_next_token(uc_lexer_t *lex) rv = lex_step(lex); - lex->no_keyword = false; - lex->no_regexp = false; + if (rv && rv->type != TK_COMMENT) { + lex->no_keyword = false; + lex->no_regexp = false; + } return rv; } @@ -854,21 +854,22 @@ uc_getenv(uc_vm_t *vm, size_t nargs) { uc_value_t *key = uc_fn_arg(0), *rv = NULL; extern char **environ; + char **env = environ; char *k, *v; if (!key) { rv = ucv_object_new(vm); - while (*environ) { - v = strchr(*environ, '='); + while (*env) { + v = strchr(*env, '='); if (v) { - xasprintf(&k, "%.*s", (int)(v - *environ), *environ); + xasprintf(&k, "%.*s", (int)(v - *env), *env); ucv_object_add(rv, k, ucv_string_new(v + 1)); free(k); } - environ++; + env++; } } else if (ucv_type(key) == UC_STRING) { @@ -1153,6 +1154,29 @@ uc_lc(uc_vm_t *vm, size_t nargs) return rv; } +static bool +uc_map_cb(uc_vm_t *vm, uc_value_t *cb, uc_value_t *out, + uc_value_t *item, uc_value_t *index, uc_value_t *obj) +{ + uc_vm_ctx_push(vm); + uc_vm_stack_push(vm, ucv_get(cb)); + uc_vm_stack_push(vm, ucv_get(item)); + uc_vm_stack_push(vm, index); + uc_vm_stack_push(vm, ucv_get(obj)); + + if (uc_vm_call(vm, true, 3)) { + ucv_put(out); + + return false; + } + + uc_value_t *rv = uc_vm_stack_pop(vm); + + ucv_array_push(out, rv); + + return true; +} + /** * Transform the array passed as the first argument by invoking the function * specified in the second argument for each array item. @@ -1216,30 +1240,33 @@ uc_map(uc_vm_t *vm, size_t nargs) { uc_value_t *obj = uc_fn_arg(0); uc_value_t *func = uc_fn_arg(1); - uc_value_t *arr, *rv; + uc_value_t *arr = NULL; size_t arridx, arrlen; - if (ucv_type(obj) != UC_ARRAY) - return NULL; + switch (ucv_type(obj)) { + case UC_ARRAY: + arr = ucv_array_new(vm); - arr = ucv_array_new(vm); + for (arrlen = ucv_array_length(obj), arridx = 0; arridx < arrlen; arridx++) { + if (!uc_map_cb(vm, func, arr, ucv_array_get(obj, arridx), + ucv_uint64_new(arridx), obj)) + return NULL; + } - for (arrlen = ucv_array_length(obj), arridx = 0; arridx < arrlen; arridx++) { - uc_vm_ctx_push(vm); - uc_vm_stack_push(vm, ucv_get(func)); - uc_vm_stack_push(vm, ucv_get(ucv_array_get(obj, arridx))); - uc_vm_stack_push(vm, ucv_int64_new(arridx)); - uc_vm_stack_push(vm, ucv_get(obj)); + break; - if (uc_vm_call(vm, true, 3)) { - ucv_put(arr); + case UC_OBJECT: + arr = ucv_array_new(vm); - return NULL; + ucv_object_foreach(obj, k, v) { + if (!uc_map_cb(vm, func, arr, v, ucv_string_new(k), obj)) + return NULL; } - rv = uc_vm_stack_pop(vm); + break; - ucv_array_push(arr, rv); + default: + break; } return arr; @@ -1402,14 +1429,14 @@ uc_reverse(uc_vm_t *vm, size_t nargs) } -static struct { +typedef struct { uc_vm_t *vm; bool ex; uc_value_t *fn; -} sort_ctx; +} sort_ctx_t; static int -default_cmp(uc_value_t *v1, uc_value_t *v2) +default_cmp(uc_value_t *v1, uc_value_t *v2, uc_vm_t *vm) { char *s1, *s2; bool f1, f2; @@ -1424,8 +1451,8 @@ default_cmp(uc_value_t *v1, uc_value_t *v2) } /* otherwise convert both operands to strings and compare lexically */ - s1 = uc_cast_string(sort_ctx.vm, &v1, &f1); - s2 = uc_cast_string(sort_ctx.vm, &v2, &f2); + s1 = uc_cast_string(vm, &v1, &f1); + s2 = uc_cast_string(vm, &v2, &f2); res = strcmp(s1, s2); @@ -1436,31 +1463,30 @@ default_cmp(uc_value_t *v1, uc_value_t *v2) } static int -array_sort_fn(const void *k1, const void *k2) +array_sort_fn(uc_value_t *v1, uc_value_t *v2, void *ud) { uc_value_t *rv, *null = ucv_int64_new(0); - uc_value_t * const *v1 = k1; - uc_value_t * const *v2 = k2; + sort_ctx_t *ctx = ud; int res; - if (!sort_ctx.fn) - return default_cmp(*v1, *v2); + if (!ctx->fn) + return default_cmp(v1, v2, ctx->vm); - if (sort_ctx.ex) + if (ctx->ex) return 0; - uc_vm_ctx_push(sort_ctx.vm); - uc_vm_stack_push(sort_ctx.vm, ucv_get(sort_ctx.fn)); - uc_vm_stack_push(sort_ctx.vm, ucv_get(*v1)); - uc_vm_stack_push(sort_ctx.vm, ucv_get(*v2)); + uc_vm_ctx_push(ctx->vm); + uc_vm_stack_push(ctx->vm, ucv_get(ctx->fn)); + uc_vm_stack_push(ctx->vm, ucv_get(v1)); + uc_vm_stack_push(ctx->vm, ucv_get(v2)); - if (uc_vm_call(sort_ctx.vm, true, 2)) { - sort_ctx.ex = true; + if (uc_vm_call(ctx->vm, true, 2)) { + ctx->ex = true; return 0; } - rv = uc_vm_stack_pop(sort_ctx.vm); + rv = uc_vm_stack_pop(ctx->vm); ucv_compare(0, rv, null, &res); @@ -1471,33 +1497,33 @@ array_sort_fn(const void *k1, const void *k2) } static int -object_sort_fn(const void *k1, const void *k2) +object_sort_fn(const char *k1, uc_value_t *v1, const char *k2, uc_value_t *v2, + void *ud) { uc_value_t *rv, *null = ucv_int64_new(0); - struct lh_entry * const *e1 = k1; - struct lh_entry * const *e2 = k2; + sort_ctx_t *ctx = ud; int res; - if (!sort_ctx.fn) - return strcmp((char *)lh_entry_k(*e1), (char *)lh_entry_k(*e2)); + if (!ctx->fn) + return strcmp(k1, k2); - if (sort_ctx.ex) + if (ctx->ex) return 0; - uc_vm_ctx_push(sort_ctx.vm); - uc_vm_stack_push(sort_ctx.vm, ucv_get(sort_ctx.fn)); - uc_vm_stack_push(sort_ctx.vm, ucv_string_new((char *)lh_entry_k(*e1))); - uc_vm_stack_push(sort_ctx.vm, ucv_string_new((char *)lh_entry_k(*e2))); - uc_vm_stack_push(sort_ctx.vm, ucv_get((uc_value_t *)lh_entry_v(*e1))); - uc_vm_stack_push(sort_ctx.vm, ucv_get((uc_value_t *)lh_entry_v(*e2))); + uc_vm_ctx_push(ctx->vm); + uc_vm_stack_push(ctx->vm, ucv_get(ctx->fn)); + uc_vm_stack_push(ctx->vm, ucv_string_new(k1)); + uc_vm_stack_push(ctx->vm, ucv_string_new(k2)); + uc_vm_stack_push(ctx->vm, ucv_get(v1)); + uc_vm_stack_push(ctx->vm, ucv_get(v2)); - if (uc_vm_call(sort_ctx.vm, true, 4)) { - sort_ctx.ex = true; + if (uc_vm_call(ctx->vm, true, 4)) { + ctx->ex = true; return 0; } - rv = uc_vm_stack_pop(sort_ctx.vm); + rv = uc_vm_stack_pop(ctx->vm); ucv_compare(0, rv, null, &res); @@ -1541,27 +1567,29 @@ uc_sort(uc_vm_t *vm, size_t nargs) { uc_value_t *val = uc_fn_arg(0); uc_value_t *fn = uc_fn_arg(1); + sort_ctx_t ctx = { + .vm = vm, + .fn = fn, + .ex = false + }; if (!assert_mutable(vm, val)) return NULL; - sort_ctx.vm = vm; - sort_ctx.fn = fn; - switch (ucv_type(val)) { case UC_ARRAY: - ucv_array_sort(val, array_sort_fn); + ucv_array_sort_r(val, array_sort_fn, &ctx); break; case UC_OBJECT: - ucv_object_sort(val, object_sort_fn); + ucv_object_sort_r(val, object_sort_fn, &ctx); break; default: return NULL; } - return sort_ctx.ex ? NULL : ucv_get(val); + return ctx.ex ? NULL : ucv_get(val); } /** diff --git a/lib/digest.c b/lib/digest.c new file mode 100644 index 0000000..c1287ff --- /dev/null +++ b/lib/digest.c @@ -0,0 +1,372 @@ +/* + * Copyright (C) 2024 Sebastian Ertz <sebastian.ertz@gmx.de> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/** + * # Digest Functions + * + * The `digest` module bundles various digest functions. + * + * @module digest + */ + +#include <md5.h> +#include <sha1.h> +#include <sha2.h> + +#ifdef HAVE_DIGEST_EXTENDED +#include <md2.h> +#include <md4.h> +#endif + +#include "ucode/module.h" + + +static uc_value_t * +uc_digest_calc_data(uc_value_t *str, char *(*fn)(const uint8_t *,size_t,char *)) +{ + char buf[SHA512_DIGEST_STRING_LENGTH]; + + if( ucv_type(str) != UC_STRING ) + return NULL; + + if( fn((const uint8_t *)ucv_string_get(str), ucv_string_length(str), buf) ) + return ucv_string_new(buf); + + return NULL; +} + +static uc_value_t * +uc_digest_calc_file(uc_value_t *path, char *(fn)(const char *,char *)) +{ + char buf[SHA512_DIGEST_STRING_LENGTH]; + + if( ucv_type(path) != UC_STRING ) + return NULL; + + if( fn(ucv_string_get(path), buf) ) + return ucv_string_new(buf); + + return NULL; +} + +/** + * Calculates the MD5 hash of string and returns that hash. + * + * Returns `null` if a non-string argument is given. + * + * @function module:digest#md5 + * + * @param {string} str + * The string to hash. + * + * @returns {?string} + * + * @example + * md5("This is a test"); // Returns "ce114e4501d2f4e2dcea3e17b546f339" + * md5(123); // Returns null + */ +static uc_value_t * +uc_digest_md5(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_data(uc_fn_arg(0), MD5Data); +} + +/** + * Calculates the SHA1 hash of string and returns that hash. + * + * Returns `null` if a non-string argument is given. + * + * @function module:digest#sha1 + * + * @param {string} str + * The string to hash. + * + * @returns {?string} + * + * @example + * sha1("This is a test"); // Returns "a54d88e06612d820bc3be72877c74f257b561b19" + * sha1(123); // Returns null + */ +static uc_value_t * +uc_digest_sha1(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_data(uc_fn_arg(0), SHA1Data); +} + +/** + * Calculates the SHA256 hash of string and returns that hash. + * + * Returns `null` if a non-string argument is given. + * + * @function module:digest#sha256 + * + * @param {string} str + * The string to hash. + * + * @returns {?string} + * + * @example + * sha256("This is a test"); // Returns "c7be1ed902fb8dd4d48997c6452f5d7e509fbcdbe2808b16bcf4edce4c07d14e" + * sha256(123); // Returns null + */ +static uc_value_t * +uc_digest_sha256(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_data(uc_fn_arg(0), SHA256Data); +} + +#ifdef HAVE_DIGEST_EXTENDED +/** + * Calculates the MD2 hash of string and returns that hash. + * + * Returns `null` if a non-string argument is given. + * + * @function module:digest#md2 + * + * @param {string} str + * The string to hash. + * + * @returns {?string} + * + * @example + * md2("This is a test"); // Returns "dc378580fd0722e56b82666a6994c718" + * md2(123); // Returns null + */ +static uc_value_t * +uc_digest_md2(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_data(uc_fn_arg(0), MD2Data); +} + +/** + * Calculates the MD4 hash of string and returns that hash. + * + * Returns `null` if a non-string argument is given. + * + * @function module:digest#md4 + * + * @param {string} str + * The string to hash. + * + * @returns {?string} + * + * @example + * md4("This is a test"); // Returns "3b487cf6856af7e330bc4b1b7d977ef8" + * md4(123); // Returns null + */ +static uc_value_t * +uc_digest_md4(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_data(uc_fn_arg(0), MD4Data); +} + +/** + * Calculates the SHA384 hash of string and returns that hash. + * + * Returns `null` if a non-string argument is given. + * + * @function module:digest#sha384 + * + * @param {string} str + * The string to hash. + * + * @returns {?string} + * + * @example + * sha384("This is a test"); // Returns "a27c7667e58200d4c0688ea136968404a0da366b1a9fc19bb38a0c7a609a1eef2bcc82837f4f4d92031a66051494b38c" + * sha384(123); // Returns null + */ +static uc_value_t * +uc_digest_sha384(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_data(uc_fn_arg(0), SHA384Data); +} + +/** + * Calculates the SHA384 hash of string and returns that hash. + * + * Returns `null` if a non-string argument is given. + * + * @function module:digest#sha384 + * + * @param {string} str + * The string to hash. + * + * @returns {?string} + * + * @example + * sha512("This is a test"); // Returns "a028d4f74b602ba45eb0a93c9a4677240dcf281a1a9322f183bd32f0bed82ec72de9c3957b2f4c9a1ccf7ed14f85d73498df38017e703d47ebb9f0b3bf116f69" + * sha512(123); // Returns null + */ +static uc_value_t * +uc_digest_sha512(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_data(uc_fn_arg(0), SHA512Data); +} +#endif + +/** + * Calculates the MD5 hash of a given file and returns that hash. + * + * Returns `null` if an error occurred. + * + * @function module:digest#md5_file + * + * @param {string} path + * The path to the file. + * + * @returns {?string} + */ +static uc_value_t * +uc_digest_md5_file(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_file(uc_fn_arg(0), MD5File); +} + +/** + * Calculates the SHA1 hash of a given file and returns that hash. + * + * Returns `null` if an error occurred. + * + * @function module:digest#sha1_file + * + * @param {string} path + * The path to the file. + * + * @returns {?string} + */ +static uc_value_t * +uc_digest_sha1_file(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_file(uc_fn_arg(0), SHA1File); +} + +/** + * Calculates the SHA256 hash of a given file and returns that hash. + * + * Returns `null` if an error occurred. + * + * @function module:digest#sha256_file + * + * @param {string} path + * The path to the file. + * + * @returns {?string} + */ +static uc_value_t * +uc_digest_sha256_file(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_file(uc_fn_arg(0), SHA256File); +} + +#ifdef HAVE_DIGEST_EXTENDED +/** + * Calculates the MD2 hash of a given file and returns that hash. + * + * Returns `null` if an error occurred. + * + * @function module:digest#md2_file + * + * @param {string} path + * The path to the file. + * + * @returns {?string} + */ +static uc_value_t * +uc_digest_md2_file(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_file(uc_fn_arg(0), MD2File); +} + +/** + * Calculates the MD4 hash of a given file and returns that hash. + * + * Returns `null` if an error occurred. + * + * @function module:digest#md4_file + * + * @param {string} path + * The path to the file. + * + * @returns {?string} + */ +static uc_value_t * +uc_digest_md4_file(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_file(uc_fn_arg(0), MD4File); +} + +/** + * Calculates the SHA384 hash of a given file and returns that hash. + * + * Returns `null` if an error occurred. + * + * @function module:digest#sha384_file + * + * @param {string} path + * The path to the file. + * + * @returns {?string} + */ +static uc_value_t * +uc_digest_sha384_file(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_file(uc_fn_arg(0), SHA384File); +} + +/** + * Calculates the SHA512 hash of a given file and returns that hash. + * + * Returns `null` if an error occurred. + * + * @function module:digest#sha512_file + * + * @param {string} path + * The path to the file. + * + * @returns {?string} + */ +static uc_value_t * +uc_digest_sha512_file(uc_vm_t *vm, size_t nargs) +{ + return uc_digest_calc_file(uc_fn_arg(0), SHA512File); +} +#endif + + +static const uc_function_list_t global_fns[] = { + { "md5", uc_digest_md5 }, + { "sha1", uc_digest_sha1 }, + { "sha256", uc_digest_sha256 }, + { "md5_file", uc_digest_md5_file }, + { "sha1_file", uc_digest_sha1_file }, + { "sha256_file", uc_digest_sha256_file }, +#ifdef HAVE_DIGEST_EXTENDED + { "md2", uc_digest_md2 }, + { "md4", uc_digest_md4 }, + { "sha384", uc_digest_sha384 }, + { "sha512", uc_digest_sha512 }, + { "md2_file", uc_digest_md2_file }, + { "md4_file", uc_digest_md4_file }, + { "sha384_file", uc_digest_sha384_file }, + { "sha512_file", uc_digest_sha512_file }, +#endif +}; + +void uc_module_init(uc_vm_t *vm, uc_value_t *scope) +{ + uc_function_list_register(scope, global_fns); +} @@ -61,15 +61,28 @@ #include <limits.h> #include <fcntl.h> +#if defined(__linux__) +#define HAS_IOCTL +#endif + +#ifdef HAS_IOCTL +#include <sys/ioctl.h> + +#define IOC_DIR_NONE (_IOC_NONE) +#define IOC_DIR_READ (_IOC_READ) +#define IOC_DIR_WRITE (_IOC_WRITE) +#define IOC_DIR_RW (_IOC_READ | _IOC_WRITE) + +#endif + #include "ucode/module.h" #include "ucode/platform.h" -#define err_return(err) do { last_error = err; return NULL; } while(0) - -//static const uc_ops *ops; -static uc_resource_type_t *file_type, *proc_type, *dir_type; +#define err_return(err) do { \ + uc_vm_registry_set(vm, "fs.last_error", ucv_int64_new(err)); \ + return NULL; \ +} while(0) -static int last_error = 0; /** * Query error information. @@ -92,15 +105,14 @@ static int last_error = 0; static uc_value_t * uc_fs_error(uc_vm_t *vm, size_t nargs) { - uc_value_t *errmsg; + int last_error = ucv_int64_get(uc_vm_registry_get(vm, "fs.last_error")); if (last_error == 0) return NULL; - errmsg = ucv_string_new(strerror(last_error)); - last_error = 0; + uc_vm_registry_set(vm, "fs.last_error", ucv_int64_new(0)); - return errmsg; + return ucv_string_new(strerror(last_error)); } static uc_value_t * @@ -126,8 +138,10 @@ uc_fs_read_common(uc_vm_t *vm, size_t nargs, const char *type) if (llen == 4 && !strcmp(lstr, "line")) { llen = getline(&p, &rlen, *fp); - if (llen == -1) + if (llen == -1) { + free(p); err_return(errno); + } len = (size_t)llen; } @@ -154,8 +168,10 @@ uc_fs_read_common(uc_vm_t *vm, size_t nargs, const char *type) else if (llen == 1) { llen = getdelim(&p, &rlen, *lstr, *fp); - if (llen == -1) + if (llen == -1) { + free(p); err_return(errno); + } len = (size_t)llen; } @@ -503,7 +519,7 @@ uc_fs_popen(uc_vm_t *vm, size_t nargs) if (!fp) err_return(errno); - return uc_resource_new(proc_type, fp); + return ucv_resource_create(vm, "fs.proc", fp); } @@ -929,6 +945,132 @@ uc_fs_fileno(uc_vm_t *vm, size_t nargs) return uc_fs_fileno_common(vm, nargs, "fs.file"); } +#ifdef HAS_IOCTL + +/** + * Performs an ioctl operation on the file. + * + * The direction parameter specifies who is reading and writing, + * from the user's point of view. It can be one of the following values: + * + * | Direction | Description | + * |----------------|-----------------------------------------------------------------------------------| + * | IOC_DIR_NONE | neither userspace nor kernel is writing, ioctl is executed without passing data. | + * | IOC_DIR_WRITE | userspace is writing and kernel is reading. | + * | IOC_DIR_READ | kernel is writing and userspace is reading. | + * | IOC_DIR_RW | userspace is writing and kernel is writing back into the data structure. | + * + * Returns the result of the ioctl operation; for `IOC_DIR_READ` and + * `IOC_DIR_RW` this is a string containing the data, otherwise a number as + * return code. + * + * In case of an error, null is returned and error details are available via + * {@link module:fs#error|error()}. + * + * @function module:fs.file#ioctl + * + * @param {number} direction + * The direction of the ioctl operation. Use constants IOC_DIR_*. + * + * @param {number} type + * The ioctl type (see https://www.kernel.org/doc/html/latest/userspace-api/ioctl/ioctl-number.html) + * + * @param {number} num + * The ioctl sequence number. + * + * @param {number|string} [value] + * The value to pass to the ioctl system call. For `IOC_DIR_NONE`, this argument + * is ignored. With `IOC_DIR_READ`, the value should be a positive integer + * specifying the number of bytes to expect from the kernel. For the other + * directions, `IOC_DIR_WRITE` and `IOC_DIR_RW`, that value parameter must be a + * string, serving as buffer for the data to send. + * + * @returns {?number|?string} + */ +static uc_value_t * +uc_fs_ioctl(uc_vm_t *vm, size_t nargs) +{ + FILE *fp = uc_fn_thisval("fs.file"); + uc_value_t *direction = uc_fn_arg(0); + uc_value_t *type = uc_fn_arg(1); + uc_value_t *num = uc_fn_arg(2); + uc_value_t *value = uc_fn_arg(3); + uc_value_t *mem = NULL; + char *buf = NULL; + unsigned long req = 0; + unsigned int dir, ty, nr; + size_t sz = 0; + int fd, ret; + + if (!fp) + err_return(EBADF); + + fd = fileno(fp); + if (fd == -1) + err_return(EBADF); + + if (ucv_type(direction) != UC_INTEGER || ucv_type(type) != UC_INTEGER || + ucv_type(num) != UC_INTEGER) + err_return(EINVAL); + + dir = ucv_uint64_get(direction); + ty = ucv_uint64_get(type); + nr = ucv_uint64_get(num); + + switch (dir) { + case IOC_DIR_NONE: + break; + + case IOC_DIR_WRITE: + if (ucv_type(value) != UC_STRING) + err_return(EINVAL); + + sz = ucv_string_length(value); + buf = ucv_string_get(value); + break; + + case IOC_DIR_READ: + if (ucv_type(value) != UC_INTEGER) + err_return(EINVAL); + + sz = ucv_to_unsigned(value); + + if (errno != 0) + err_return(errno); + + mem = xalloc(sizeof(uc_string_t) + sz + 1); + mem->type = UC_STRING; + mem->refcount = 1; + buf = ucv_string_get(mem); + ((uc_string_t *)mem)->length = sz; + break; + + case IOC_DIR_RW: + if (ucv_type(value) != UC_STRING) + err_return(EINVAL); + + sz = ucv_string_length(value); + mem = ucv_string_new_length(ucv_string_get(value), sz); + buf = ucv_string_get(mem); + break; + + default: + err_return(EINVAL); + } + + req = _IOC(dir, ty, nr, sz); + ret = ioctl(fd, req, buf); + + if (ret < 0) { + ucv_put(mem); + err_return(errno); + } + + return mem ? mem : ucv_uint64_new(ret); +} + +#endif + /** * Opens a file. * @@ -1045,7 +1187,7 @@ uc_fs_open(uc_vm_t *vm, size_t nargs) err_return(i); } - return uc_resource_new(file_type, fp); + return ucv_resource_create(vm, "fs.file", fp); } /** @@ -1104,7 +1246,7 @@ uc_fs_fdopen(uc_vm_t *vm, size_t nargs) if (!fp) err_return(errno); - return uc_resource_new(file_type, fp); + return ucv_resource_create(vm, "fs.file", fp); } @@ -1305,7 +1447,7 @@ uc_fs_opendir(uc_vm_t *vm, size_t nargs) if (!dp) err_return(errno); - return uc_resource_new(dir_type, dp); + return ucv_resource_create(vm, "fs.dir", dp); } /** @@ -2267,7 +2409,7 @@ uc_fs_mkstemp(uc_vm_t *vm, size_t nargs) err_return(errno); } - return uc_resource_new(file_type, fp); + return ucv_resource_create(vm, "fs.file", fp); } /** @@ -2637,8 +2779,8 @@ uc_fs_pipe(uc_vm_t *vm, size_t nargs) rv = ucv_array_new_length(vm, 2); - ucv_array_push(rv, uc_resource_new(file_type, rfp)); - ucv_array_push(rv, uc_resource_new(file_type, wfp)); + ucv_array_push(rv, ucv_resource_create(vm, "fs.file", rfp)); + ucv_array_push(rv, ucv_resource_create(vm, "fs.file", wfp)); return rv; } @@ -2665,6 +2807,9 @@ static const uc_function_list_t file_fns[] = { { "isatty", uc_fs_isatty }, { "truncate", uc_fs_truncate }, { "lock", uc_fs_lock }, +#if defined(__linux__) + { "ioctl", uc_fs_ioctl }, +#endif }; static const uc_function_list_t dir_fns[] = { @@ -2737,11 +2882,20 @@ void uc_module_init(uc_vm_t *vm, uc_value_t *scope) { uc_function_list_register(scope, global_fns); - proc_type = uc_type_declare(vm, "fs.proc", proc_fns, close_proc); - file_type = uc_type_declare(vm, "fs.file", file_fns, close_file); - dir_type = uc_type_declare(vm, "fs.dir", dir_fns, close_dir); + uc_type_declare(vm, "fs.proc", proc_fns, close_proc); + uc_type_declare(vm, "fs.dir", dir_fns, close_dir); + + uc_resource_type_t *file_type = uc_type_declare(vm, "fs.file", file_fns, close_file); ucv_object_add(scope, "stdin", uc_resource_new(file_type, stdin)); ucv_object_add(scope, "stdout", uc_resource_new(file_type, stdout)); ucv_object_add(scope, "stderr", uc_resource_new(file_type, stderr)); + +#ifdef HAS_IOCTL +#define ADD_CONST(x) ucv_object_add(scope, #x, ucv_int64_new(x)) + ADD_CONST(IOC_DIR_NONE); + ADD_CONST(IOC_DIR_READ); + ADD_CONST(IOC_DIR_WRITE); + ADD_CONST(IOC_DIR_RW); +#endif } @@ -52,7 +52,6 @@ #include "ucode/module.h" -static bool srand_called = false; /** * Returns the absolute value of the given numeric value. @@ -398,11 +397,11 @@ uc_rand(uc_vm_t *vm, size_t nargs) { struct timeval tv; - if (!srand_called) { + if (!ucv_boolean_get(uc_vm_registry_get(vm, "math.srand_called"))) { gettimeofday(&tv, NULL); srand((tv.tv_sec * 1000) + (tv.tv_usec / 1000)); - srand_called = true; + uc_vm_registry_set(vm, "math.srand_called", ucv_boolean_new(true)); } return ucv_int64_new(rand()); @@ -429,7 +428,7 @@ uc_srand(uc_vm_t *vm, size_t nargs) int64_t n = ucv_to_integer(uc_fn_arg(0)); srand((unsigned int)n); - srand_called = true; + uc_vm_registry_set(vm, "math.srand_called", ucv_boolean_new(true)); return NULL; } @@ -477,4 +476,6 @@ static const uc_function_list_t math_fns[] = { void uc_module_init(uc_vm_t *vm, uc_value_t *scope) { uc_function_list_register(scope, math_fns); + + uc_vm_registry_set(vm, "math.srand_called", ucv_boolean_new(false)); } diff --git a/lib/nl80211.c b/lib/nl80211.c index feebaeb..34a3e92 100644 --- a/lib/nl80211.c +++ b/lib/nl80211.c @@ -330,7 +330,7 @@ static const uc_nl_nested_spec_t nl80211_mesh_setup_nla = { static const uc_nl_nested_spec_t nl80211_mntr_flags_nla = { .headsize = 0, - .nattrs = 6, + .nattrs = 7, .attrs = { { NL80211_MNTR_FLAG_FCSFAIL, "fcsfail", DT_FLAG, 0, NULL }, { NL80211_MNTR_FLAG_PLCPFAIL, "plcpfail", DT_FLAG, 0, NULL }, @@ -338,6 +338,7 @@ static const uc_nl_nested_spec_t nl80211_mntr_flags_nla = { { NL80211_MNTR_FLAG_OTHER_BSS, "other_bss", DT_FLAG, 0, NULL }, { NL80211_MNTR_FLAG_COOK_FRAMES, "cook_frames", DT_FLAG, 0, NULL }, { NL80211_MNTR_FLAG_ACTIVE, "active", DT_FLAG, 0, NULL }, + { NL80211_MNTR_FLAG_SKIP_TX, "skip_tx", DT_FLAG, 0, NULL }, } }; @@ -588,7 +589,7 @@ static const uc_nl_nested_spec_t nl80211_wiphy_bands_rates_nla = { static const uc_nl_nested_spec_t nl80211_wiphy_bands_iftype_data_nla = { .headsize = 0, - .nattrs = 7, + .nattrs = 9, .attrs = { { NL80211_BAND_IFTYPE_ATTR_IFTYPES, "iftypes", DT_NESTED, 0, &nl80211_ifcomb_limit_types_nla }, { NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC, "he_cap_mac", DT_U8, DF_ARRAY, NULL }, @@ -597,6 +598,8 @@ static const uc_nl_nested_spec_t nl80211_wiphy_bands_iftype_data_nla = { { NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE, "he_cap_ppe", DT_U8, DF_ARRAY, NULL }, { NL80211_BAND_IFTYPE_ATTR_HE_6GHZ_CAPA, "he_6ghz_capa", DT_U16, 0, NULL }, { NL80211_BAND_IFTYPE_ATTR_VENDOR_ELEMS, "vendor_elems", DT_STRING, DF_BINARY, NULL }, + { NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MAC, "eht_cap_mac", DT_U8, DF_ARRAY, NULL }, + { NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PHY, "eht_cap_phy", DT_U8, DF_ARRAY, NULL }, } }; @@ -693,7 +696,7 @@ static const uc_nl_nested_spec_t nl80211_bss_nla = { static const uc_nl_nested_spec_t nl80211_sta_info_bitrate_nla = { .headsize = 0, - .nattrs = 18, + .nattrs = 22, .attrs = { { NL80211_RATE_INFO_BITRATE, "bitrate", DT_U16, 0, NULL }, { NL80211_RATE_INFO_BITRATE32, "bitrate32", DT_U32, 0, NULL }, @@ -707,10 +710,14 @@ static const uc_nl_nested_spec_t nl80211_sta_info_bitrate_nla = { { NL80211_RATE_INFO_HE_GI, "he_gi", DT_U8, 0, NULL }, { NL80211_RATE_INFO_HE_DCM, "he_dcm", DT_U8, 0, NULL }, { NL80211_RATE_INFO_HE_RU_ALLOC, "he_ru_alloc", DT_U8, 0, NULL }, + { NL80211_RATE_INFO_EHT_MCS, "eht_mcs", DT_U8, 0, NULL }, + { NL80211_RATE_INFO_EHT_NSS, "eht_nss", DT_U8, 0, NULL }, + { NL80211_RATE_INFO_EHT_GI, "eht_gi", DT_U8, 0, NULL }, { NL80211_RATE_INFO_40_MHZ_WIDTH, "width_40", DT_FLAG, 0, NULL }, { NL80211_RATE_INFO_80_MHZ_WIDTH, "width_80", DT_FLAG, 0, NULL }, { NL80211_RATE_INFO_80P80_MHZ_WIDTH, "width_80p80", DT_FLAG, 0, NULL }, { NL80211_RATE_INFO_160_MHZ_WIDTH, "width_160", DT_FLAG, 0, NULL }, + { NL80211_RATE_INFO_320_MHZ_WIDTH, "width_320", DT_FLAG, 0, NULL }, { NL80211_RATE_INFO_10_MHZ_WIDTH, "width_10", DT_FLAG, 0, NULL }, { NL80211_RATE_INFO_5_MHZ_WIDTH, "width_5", DT_FLAG, 0, NULL }, } @@ -844,17 +851,18 @@ static const uc_nl_nested_spec_t nl80211_radio_freq_range_nla = { static const uc_nl_nested_spec_t nl80211_wiphy_radio_nla = { .headsize = 0, - .nattrs = 3, + .nattrs = 4, .attrs = { { NL80211_WIPHY_RADIO_ATTR_INDEX, "index", DT_U32, 0, NULL }, { NL80211_WIPHY_RADIO_ATTR_FREQ_RANGE, "freq_ranges", DT_NESTED, DF_REPEATED, &nl80211_radio_freq_range_nla }, { NL80211_WIPHY_RADIO_ATTR_INTERFACE_COMBINATION, "interface_combinations", DT_NESTED, DF_REPEATED, &nl80211_ifcomb_nla }, + { NL80211_WIPHY_RADIO_ATTR_ANTENNA_MASK, "antenna_mask", DT_U32, 0, NULL }, } }; static const uc_nl_nested_spec_t nl80211_msg = { .headsize = 0, - .nattrs = 128, + .nattrs = 130, .attrs = { { NL80211_ATTR_4ADDR, "4addr", DT_U8, 0, NULL }, { NL80211_ATTR_AIRTIME_WEIGHT, "airtime_weight", DT_U16, 0, NULL }, @@ -881,6 +889,7 @@ static const uc_nl_nested_spec_t nl80211_msg = { { NL80211_ATTR_DFS_REGION, "dfs_region", DT_U8, 0, NULL }, { NL80211_ATTR_DTIM_PERIOD, "dtim_period", DT_U32, 0, NULL }, { NL80211_ATTR_DURATION, "duration", DT_U32, 0, NULL }, + { NL80211_ATTR_EXT_FEATURES, "extended_features", DT_U8, DF_ARRAY, NULL }, { NL80211_ATTR_FEATURE_FLAGS, "feature_flags", DT_U32, 0, NULL }, { NL80211_ATTR_FRAME, "frame", DT_STRING, DF_BINARY, NULL }, { NL80211_ATTR_FRAME_MATCH, "frame_match", DT_STRING, DF_BINARY, NULL }, @@ -984,6 +993,7 @@ static const uc_nl_nested_spec_t nl80211_msg = { { NL80211_ATTR_MAX_AP_ASSOC_STA, "max_ap_assoc", DT_U16, 0, NULL }, { NL80211_ATTR_SURVEY_INFO, "survey_info", DT_NESTED, 0, &nl80211_survey_info_nla }, { NL80211_ATTR_WIPHY_RADIOS, "radios", DT_NESTED, DF_MULTIPLE|DF_AUTOIDX, &nl80211_wiphy_radio_nla }, + { NL80211_ATTR_VIF_RADIO_MASK, "vif_radio_mask", DT_U32, 0, NULL }, } }; @@ -2014,7 +2024,8 @@ typedef struct { reply_state_t state; uc_vm_t *vm; uc_value_t *res; - bool merge; + bool merge_phy_info; + bool single_phy_info; const uc_nl_nested_spec_t *spec; } request_state_t; @@ -2122,14 +2133,23 @@ cb_reply(struct nl_msg *msg, void *arg) if (rv) { if (hdr->nlmsg_flags & NLM_F_MULTI) { - if (!s->res) - s->res = ucv_array_new(s->vm); - - if (s->merge) { + if (s->merge_phy_info && s->single_phy_info) { + if (!s->res) { + s->res = o; + } + else { + deep_merge_object(s->res, o); + ucv_put(o); + } + } + else if (s->merge_phy_info) { idx = ucv_object_get(o, "wiphy", NULL); i = idx ? ucv_int64_get(idx) : -1; if (i >= 0) { + if (!s->res) + s->res = ucv_array_new(s->vm); + idx = ucv_array_get(s->res, i); if (idx) { @@ -2142,6 +2162,9 @@ cb_reply(struct nl_msg *msg, void *arg) } } else { + if (!s->res) + s->res = ucv_array_new(s->vm); + ucv_array_push(s->res, o); } } @@ -2598,9 +2621,19 @@ uc_nl_request(uc_vm_t *vm, size_t nargs) cid -= HWSIM_CMD_OFFSET; st.spec = &hwsim_msg; } + else if (cid == NL80211_CMD_GET_WIPHY) { + id = uc_nl_find_family_id("nl80211"); + st.spec = &nl80211_msg; + st.merge_phy_info = true; + + if (ucv_object_get(payload, "wiphy", NULL) != NULL) + st.single_phy_info = true; + + if (ucv_is_truish(ucv_object_get(payload, "split_wiphy_dump", NULL))) + flagval |= NLM_F_DUMP; + } else { id = uc_nl_find_family_id("nl80211"); - st.merge = (cid == NL80211_CMD_GET_WIPHY); st.spec = &nl80211_msg; } @@ -3612,6 +3612,10 @@ cb_listener_event(struct nl_msg *msg, void *arg) if (uc_vm_call(vm, true, 1) != EXCEPTION_NONE) { uloop_end(); + set_error(NLE_FAILURE, "Runtime exception in callback"); + + errno = EINVAL; + return NL_STOP; } @@ -3631,12 +3635,8 @@ uc_nl_listener_cb(struct uloop_fd *fd, unsigned int events) nl_recvmsgs_default(nl_conn.evsock); - if (errno != 0) { - if (errno != EAGAIN && errno != EWOULDBLOCK) - set_error(errno, NULL); - + if (errno != 0) break; - } } } diff --git a/lib/socket.c b/lib/socket.c index 63ca24f..ebb7649 100644 --- a/lib/socket.c +++ b/lib/socket.c @@ -78,6 +78,7 @@ #if defined(__linux__) # include <linux/if_packet.h> +# include <linux/filter.h> # ifndef SO_TIMESTAMP_OLD # define SO_TIMESTAMP_OLD SO_TIMESTAMP @@ -306,13 +307,16 @@ hwaddr_to_uv(uint8_t *addr, size_t alen) char buf[sizeof("FF:FF:FF:FF:FF:FF:FF:FF")], *p = buf; const char *hex = "0123456789ABCDEF"; - for (size_t i = 0; i < alen && i < 8; i++) { + if (alen > 8) + alen = 8; + + for (size_t i = 0; i < alen; i++) { if (i) *p++ = ':'; *p++ = hex[addr[i] / 16]; *p++ = hex[addr[i] % 16]; } - return ucv_string_new(buf); + return ucv_string_new_length(buf, alen); } static bool @@ -966,6 +970,90 @@ static struct_t st_timeval = { }; #if defined(__linux__) +static bool +filter_to_c(void *st, uc_value_t *uv) +{ + struct sock_fprog **fpp = st; + struct sock_fprog *fp = *fpp; + size_t i, len; + + if (ucv_type(uv) == UC_STRING) { + size_t len = ucv_string_length(uv); + + if (len == 0 || (len % sizeof(struct sock_filter)) != 0) + err_return(EINVAL, "Filter program length not a multiple of %zu", + sizeof(struct sock_filter)); + + fp = *fpp = xrealloc(fp, sizeof(struct sock_fprog) + len); + fp->filter = memcpy((char *)fp + sizeof(struct sock_fprog), ucv_string_get(uv), len); + + if (fp->len == 0) + fp->len = len / sizeof(struct sock_filter); + } + else if (ucv_type(uv) == UC_ARRAY) { + /* Opcode array of array. Each sub-array is a 4 element tuple */ + if (ucv_type(ucv_array_get(uv, 0)) == UC_ARRAY) { + len = ucv_array_length(uv); + + fp = *fpp = xrealloc(fp, sizeof(struct sock_fprog) + + (len * sizeof(struct sock_filter))); + + fp->filter = (struct sock_filter *)((char *)fp + sizeof(struct sock_fprog)); + + for (i = 0; i < len; i++) { + uc_value_t *op = ucv_array_get(uv, i); + + if (ucv_type(op) != UC_ARRAY) + continue; + + fp->filter[i].code = ucv_to_unsigned(ucv_array_get(op, 0)); + fp->filter[i].jt = ucv_to_unsigned(ucv_array_get(op, 1)); + fp->filter[i].jf = ucv_to_unsigned(ucv_array_get(op, 2)); + fp->filter[i].k = ucv_to_unsigned(ucv_array_get(op, 3)); + } + } + + /* Flat opcode array, must be a multiple of 4 */ + else { + len = ucv_array_length(uv); + + if (len % 4) + err_return(EINVAL, "Opcode array length not a multiple of 4"); + + len /= 4; + + fp = *fpp = xrealloc(fp, sizeof(struct sock_fprog) + + (len * sizeof(struct sock_filter))); + + fp->filter = (struct sock_filter *)((char *)fp + sizeof(struct sock_fprog)); + + for (i = 0; i < len; i++) { + fp->filter[i].code = ucv_to_unsigned(ucv_array_get(uv, i * 4 + 0)); + fp->filter[i].jt = ucv_to_unsigned(ucv_array_get(uv, i * 4 + 1)); + fp->filter[i].jf = ucv_to_unsigned(ucv_array_get(uv, i * 4 + 2)); + fp->filter[i].k = ucv_to_unsigned(ucv_array_get(uv, i * 4 + 3)); + } + } + + if (fp->len == 0) + fp->len = i; + } + else { + err_return(EINVAL, "Expecting either BPF bytecode string or array of opcodes"); + } + + return true; +} + +static struct_t st_sock_fprog = { + .size = sizeof(struct sock_fprog), + .members = (member_t []){ + STRUCT_MEMBER_NP(sock_fprog, len, DT_UNSIGNED), + STRUCT_MEMBER_CB(filter, filter_to_c, NULL), + { 0 } + } +}; + static struct_t st_ucred = { .size = sizeof(struct ucred), .members = (member_t []){ @@ -1048,7 +1136,7 @@ in6_ifindex_to_uv(void *st) static bool in6_ifindex_to_c(void *st, uc_value_t *uv) { - struct ipv6_mreq *mr = st; + struct ipv6_mreq *mr = *(struct ipv6_mreq **)st; if (ucv_type(uv) == UC_STRING) { mr->ipv6mr_interface = if_nametoindex(ucv_string_get(uv)); @@ -1186,7 +1274,9 @@ rcv_wscale_to_uv(void *st) static bool snd_wscale_to_c(void *st, uc_value_t *uv) { - ((struct tcp_info *)st)->tcpi_snd_wscale = ucv_to_unsigned(uv); + struct tcp_info *ti = *(struct tcp_info **)st; + + ti->tcpi_snd_wscale = ucv_to_unsigned(uv); if (errno) err_return(errno, "Unable to convert field snd_wscale to unsigned"); @@ -1197,7 +1287,9 @@ snd_wscale_to_c(void *st, uc_value_t *uv) static bool rcv_wscale_to_c(void *st, uc_value_t *uv) { - ((struct tcp_info *)st)->tcpi_rcv_wscale = ucv_to_unsigned(uv); + struct tcp_info *ti = *(struct tcp_info **)st; + + ti->tcpi_rcv_wscale = ucv_to_unsigned(uv); if (errno) err_return(errno, "Unable to convert field rcv_wscale to unsigned"); @@ -1311,7 +1403,7 @@ mr_ifindex_to_uv(void *st) static bool mr_ifindex_to_c(void *st, uc_value_t *uv) { - struct packet_mreq *mr = st; + struct packet_mreq *mr = *(struct packet_mreq **)st; if (ucv_type(uv) == UC_STRING) { mr->mr_ifindex = if_nametoindex(ucv_string_get(uv)); @@ -1341,7 +1433,7 @@ mr_address_to_uv(void *st) static bool mr_address_to_c(void *st, uc_value_t *uv) { - struct packet_mreq *mr = st; + struct packet_mreq *mr = *(struct packet_mreq **)st; size_t len; if (!uv_to_hwaddr(uv, mr->mr_address, &len)) @@ -1396,12 +1488,23 @@ static struct_t st_tpacket_auxdata = { } }; +struct fanout_args_local { +#if __BYTE_ORDER == __LITTLE_ENDIAN + uint16_t id; + uint16_t type_flags; +#else + uint16_t type_flags; + uint16_t id; +#endif + uint32_t max_num_members; +}; + static struct_t st_fanout_args = { - .size = sizeof(struct fanout_args), + .size = sizeof(struct fanout_args_local), .members = (member_t []){ - STRUCT_MEMBER_NP(fanout_args, id, DT_UNSIGNED), - STRUCT_MEMBER_NP(fanout_args, type_flags, DT_UNSIGNED), - STRUCT_MEMBER_NP(fanout_args, max_num_members, DT_UNSIGNED), + STRUCT_MEMBER_NP(fanout_args_local, id, DT_UNSIGNED), + STRUCT_MEMBER_NP(fanout_args_local, type_flags, DT_UNSIGNED), + STRUCT_MEMBER_NP(fanout_args_local, max_num_members, DT_UNSIGNED), { 0 } } }; @@ -1493,7 +1596,7 @@ static sockopt_t sockopts[] = { { SOL_SOCKET, SO_TIMESTAMP, SV_BOOL }, { SOL_SOCKET, SO_TYPE, SV_INT }, #if defined(__linux__) - { SOL_SOCKET, SO_ATTACH_FILTER, SV_STRING }, + { SOL_SOCKET, SO_ATTACH_FILTER, &st_sock_fprog }, { SOL_SOCKET, SO_ATTACH_BPF, SV_INT }, { SOL_SOCKET, SO_ATTACH_REUSEPORT_CBPF, SV_STRING }, { SOL_SOCKET, SO_ATTACH_REUSEPORT_EBPF, SV_INT }, @@ -1778,7 +1881,7 @@ uv_to_struct(uc_value_t *uv, struct_t *spec) break; case DT_CALLBACK: - if (m->u1.to_c && !m->u1.to_c(st, fv)) { + if (m->u1.to_c && !m->u1.to_c(&st, fv)) { free(st); return NULL; } @@ -2846,6 +2949,9 @@ out: * @param {number} [backlog=128] * The maximum length of the queue of pending connections. * + * @param {boolean} [reuseaddr] + * Whether to set the SO_REUSEADDR option before calling bind(). + * * @returns {module:socket.socket} * * @example @@ -2863,7 +2969,7 @@ uc_socket_listen(uc_vm_t *vm, size_t nargs) { int ret, fd, curr_weight, prev_weight, socktype = 0, protocol = 0; struct addrinfo *ai_results, *ai_hints, *ai; - uc_value_t *host, *serv, *hints, *backlog; + uc_value_t *host, *serv, *hints, *backlog, *reuseaddr; struct sockaddr_storage ss = { 0 }; bool v6, lo, ll; socklen_t slen; @@ -2872,7 +2978,8 @@ uc_socket_listen(uc_vm_t *vm, size_t nargs) "host", UC_NULL, true, &host, "service", UC_NULL, true, &serv, "hints", UC_OBJECT, true, &hints, - "backlog", UC_INTEGER, true, &backlog); + "backlog", UC_INTEGER, true, &backlog, + "reuseaddr", UC_BOOLEAN, true, &reuseaddr); ai_hints = hints ? (struct addrinfo *)uv_to_struct(hints, &st_addrinfo) : NULL; @@ -2960,6 +3067,13 @@ uc_socket_listen(uc_vm_t *vm, size_t nargs) if (fd == -1) err_return(errno, "socket()"); + if (ucv_is_truish(reuseaddr)) { + ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &(int){ 1 }, sizeof(int)); + + if (ret == -1) + err_return(errno, "setsockopt()"); + } + ret = bind(fd, (struct sockaddr *)&ss, slen); if (ret == -1) { @@ -3909,10 +4023,6 @@ uc_socket_inst_recvmsg(uc_vm_t *vm, size_t nargs) flagval = flags ? ucv_int64_get(flags) : 0; -#if defined(__linux__) - flagval |= MSG_CMSG_CLOEXEC; -#endif - /* prepare ancillary data buffer */ if (anclength) { size_t sz = ucv_to_unsigned(anclength); diff --git a/lib/struct.c b/lib/struct.c index ad0bc20..7393347 100644 --- a/lib/struct.c +++ b/lib/struct.c @@ -371,8 +371,6 @@ #include "ucode/module.h" #include "ucode/vallist.h" -static uc_resource_type_t *struct_type; - typedef struct formatdef { char format; ssize_t size; @@ -395,6 +393,13 @@ typedef struct { formatcode_t codes[]; } formatstate_t; +typedef struct { + uc_resource_t resource; + size_t length; + size_t capacity; + size_t position; +} formatbuffer_t; + /* Define various structs to figure out the alignments of types */ @@ -2474,12 +2479,59 @@ overflow: return NULL; } -static uc_value_t * -uc_pack_common(uc_vm_t *vm, size_t nargs, formatstate_t *state, size_t argoff) +static bool +grow_buffer(uc_vm_t *vm, void **buf, size_t *bufsz, size_t length) +{ + const size_t overhead = sizeof(uc_string_t) + 1; + + if (length > *bufsz) { + size_t old_size = *bufsz; + size_t new_size = (length + 7u) & ~7u; + + if (*buf != NULL) { + new_size = *bufsz; + + while (length > new_size) { + if (new_size > SIZE_MAX - (new_size >> 1)) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "Overflow reallocating buffer from %zu to %zu bytes", + *bufsz, length); + + return false; + } + + new_size += ((new_size >> 1) + 7u) & ~7u; + } + } + + char *tmp = realloc(*buf, new_size + overhead); + + if (!tmp) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "Error reallocating buffer to %zu+%zu bytes: %m", + new_size, overhead); + + return false; + } + + if (*buf) + memset(tmp + overhead + old_size - 1, 0, new_size - old_size + 1); + else + memset(tmp, 0, new_size + overhead); + + *buf = tmp; + *bufsz = new_size; + } + + return true; +} + +static bool +uc_pack_common(uc_vm_t *vm, size_t nargs, formatstate_t *state, size_t argoff, + void **buf, size_t *pos, size_t *capacity) { - size_t ncode, arg, off; + size_t ncode, arg, off, new_pos; formatcode_t *code; - uc_string_t *buf; ssize_t size, n; const void *p; @@ -2504,16 +2556,16 @@ uc_pack_common(uc_vm_t *vm, size_t nargs, formatstate_t *state, size_t argoff) } } - buf = xalloc(sizeof(*buf) + state->size + off + 1); - buf->header.type = UC_STRING; - buf->header.refcount = 1; - buf->length = state->size + off; + new_pos = *pos + state->size + off; + + if (!grow_buffer(vm, buf, capacity, new_pos)) + return NULL; for (ncode = 0, code = &state->codes[0], off = 0; ncode < state->ncodes; code = &state->codes[++ncode]) { const formatdef_t *e = code->fmtdef; - char *res = buf->str + code->offset + off; + char *res = *buf + sizeof(uc_string_t) + *pos + code->offset + off; ssize_t j = code->repeat; while (j--) { @@ -2526,7 +2578,7 @@ uc_pack_common(uc_vm_t *vm, size_t nargs, formatstate_t *state, size_t argoff) uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Argument for '*' must be a string"); - goto err; + return false; } n = ucv_string_length(v); @@ -2547,7 +2599,7 @@ uc_pack_common(uc_vm_t *vm, size_t nargs, formatstate_t *state, size_t argoff) uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Argument for 's' must be a string"); - goto err; + return false; } n = ucv_string_length(v); @@ -2564,7 +2616,7 @@ uc_pack_common(uc_vm_t *vm, size_t nargs, formatstate_t *state, size_t argoff) uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Argument for 'p' must be a string"); - goto err; + return false; } n = ucv_string_length(v); @@ -2583,69 +2635,43 @@ uc_pack_common(uc_vm_t *vm, size_t nargs, formatstate_t *state, size_t argoff) } else { if (!e->pack(vm, res, v, e)) - goto err; + return false; } res += size; } } - return &buf->header; - -err: - free(buf); + *pos = new_pos; - return NULL; + return true; } static uc_value_t * -uc_unpack_common(uc_vm_t *vm, size_t nargs, formatstate_t *state, size_t argoff) +uc_unpack_common(uc_vm_t *vm, size_t nargs, formatstate_t *state, + const char *buf, long long pos, size_t *rem, bool single) { - uc_value_t *bufval = uc_fn_arg(argoff); - uc_value_t *offset = uc_fn_arg(argoff + 1); - const char *startfrom = NULL; - ssize_t bufrem, size, n; uc_value_t *result; formatcode_t *code; size_t ncode, off; + ssize_t size, n; - if (ucv_type(bufval) != UC_STRING) { - uc_vm_raise_exception(vm, EXCEPTION_TYPE, - "Buffer value not a string"); + if (pos < 0) + pos += *rem; + if (pos < 0 || (size_t)pos >= *rem) return NULL; - } - startfrom = ucv_string_get(bufval); - bufrem = ucv_string_length(bufval); + buf += pos; + *rem -= pos; - if (offset) { - if (ucv_type(offset) != UC_INTEGER) { - uc_vm_raise_exception(vm, EXCEPTION_TYPE, - "Offset value not an integer"); - - return NULL; - } - - n = (ssize_t)ucv_int64_get(offset); - - if (n < 0) - n += bufrem; - - if (n < 0 || n >= bufrem) - return NULL; - - startfrom += n; - bufrem -= n; - } - - result = ucv_array_new(vm); + result = single ? NULL : ucv_array_new(vm); for (ncode = 0, code = &state->codes[0], off = 0; ncode < state->ncodes; code = &state->codes[++ncode]) { const formatdef_t *e = code->fmtdef; - const char *res = startfrom + code->offset + off; + const char *res = buf + code->offset + off; ssize_t j = code->repeat; while (j--) { @@ -2654,12 +2680,12 @@ uc_unpack_common(uc_vm_t *vm, size_t nargs, formatstate_t *state, size_t argoff) size = code->size; if (e->format == '*') { - if (size == -1 || size > bufrem) - size = bufrem; + if (size == -1 || (size_t)size > *rem) + size = *rem; off += size; } - else if (size > bufrem) { + else if (size >= 0 && (size_t)size > *rem) { goto fail; } @@ -2681,10 +2707,13 @@ uc_unpack_common(uc_vm_t *vm, size_t nargs, formatstate_t *state, size_t argoff) if (v == NULL) goto fail; - ucv_array_push(result, v); - res += size; - bufrem -= size; + *rem -= size; + + if (single) + return v; + + ucv_array_push(result, v); } } @@ -2728,7 +2757,8 @@ static uc_value_t * uc_pack(uc_vm_t *vm, size_t nargs) { uc_value_t *fmtval = uc_fn_arg(0); - uc_value_t *res = NULL; + size_t pos = 0, capacity = 0; + uc_string_t *us = NULL; formatstate_t *state; state = parse_format(vm, fmtval); @@ -2736,11 +2766,20 @@ uc_pack(uc_vm_t *vm, size_t nargs) if (!state) return NULL; - res = uc_pack_common(vm, nargs, state, 1); + if (!uc_pack_common(vm, nargs, state, 1, (void **)&us, &pos, &capacity)) { + free(state); + free(us); + + return NULL; + } free(state); - return res; + us->header.type = UC_STRING; + us->header.refcount = 1; + us->length = pos; + + return &us->header; } /** @@ -2780,15 +2819,32 @@ static uc_value_t * uc_unpack(uc_vm_t *vm, size_t nargs) { uc_value_t *fmtval = uc_fn_arg(0); + uc_value_t *bufval = uc_fn_arg(1); + uc_value_t *offset = uc_fn_arg(2); uc_value_t *res = NULL; formatstate_t *state; + long long pos = 0; + size_t rem; + char *buf; + + if (ucv_type(bufval) != UC_STRING) { + uc_vm_raise_exception(vm, EXCEPTION_TYPE, + "Buffer value not a string"); + + return NULL; + } + + if (offset && !ucv_as_longlong(vm, offset, &pos)) + return NULL; state = parse_format(vm, fmtval); if (!state) return NULL; - res = uc_unpack_common(vm, nargs, state, 1); + buf = ucv_string_get(bufval); + rem = ucv_string_length(bufval); + res = uc_unpack_common(vm, nargs, state, buf, pos, &rem, false); free(state); @@ -2848,15 +2904,7 @@ uc_struct_new(uc_vm_t *vm, size_t nargs) if (!state) return NULL; - return uc_resource_new(struct_type, state); -} - -static void -uc_struct_gc(void *ud) -{ - formatstate_t *state = ud; - - free(state); + return ucv_resource_create(vm, "struct.format", state); } /** @@ -2884,12 +2932,24 @@ uc_struct_gc(void *ud) static uc_value_t * uc_struct_pack(uc_vm_t *vm, size_t nargs) { - formatstate_t **state = uc_fn_this("struct"); + formatstate_t **state = uc_fn_this("struct.format"); + size_t pos = 0, capacity = 0; + uc_string_t *us = NULL; if (!state || !*state) return NULL; - return uc_pack_common(vm, nargs, *state, 0); + if (!uc_pack_common(vm, nargs, *state, 0, (void **)&us, &pos, &capacity)) { + free(us); + + return NULL; + } + + us->header.type = UC_STRING; + us->header.refcount = 1; + us->length = pos; + + return &us->header; } /** @@ -2923,12 +2983,682 @@ uc_struct_pack(uc_vm_t *vm, size_t nargs) static uc_value_t * uc_struct_unpack(uc_vm_t *vm, size_t nargs) { - formatstate_t **state = uc_fn_this("struct"); + formatstate_t **state = uc_fn_this("struct.format"); + uc_value_t *bufval = uc_fn_arg(0); + uc_value_t *offset = uc_fn_arg(1); + long long pos = 0; + size_t rem; + char *buf; if (!state || !*state) return NULL; - return uc_unpack_common(vm, nargs, *state, 0); + if (ucv_type(bufval) != UC_STRING) { + uc_vm_raise_exception(vm, EXCEPTION_TYPE, + "Buffer value not a string"); + + return NULL; + } + + if (offset && !ucv_as_longlong(vm, offset, &pos)) + return NULL; + + buf = ucv_string_get(bufval); + rem = ucv_string_length(bufval); + + return uc_unpack_common(vm, nargs, *state, buf, pos, &rem, false); +} + + +/** + * Represents a struct buffer instance created by `buffer()`. + * + * @class module:struct.buffer + * @hideconstructor + * + * @see {@link module:struct#buffer|buffer()} + * + * @example + * + * const buf = struct.buffer(); + * + * buf.put('I', 12345); + * + * const value = buf.get('I'); + */ + +/** + * Creates a new struct buffer instance. + * + * The `buffer()` function creates a new struct buffer object that can be used + * for incremental packing and unpacking of binary data. If an initial data + * string is provided, the buffer is initialized with this content. + * + * Note that even when initial data is provided, the buffer position is always + * set to zero. This design assumes that the primary intent when initializing + * a buffer with data is to read (unpack) from the beginning. If you want to + * append data to a pre-initialized buffer, you need to explicitly move the + * position to the end, either by calling `end()` or by setting the position + * manually with `pos()`. + * + * Returns a new struct buffer instance. + * + * @function module:struct#buffer + * + * @param {string} [initialData] + * Optional initial data to populate the buffer with. + * + * @returns {module:struct.buffer} + * + * @example + * // Create an empty buffer + * const emptyBuf = struct.buffer(); + * + * // Create a buffer with initial data + * const dataBuf = struct.buffer("\x01\x02\x03\x04"); + * + * // Read from the beginning of the initialized buffer + * const value = dataBuf.get('I'); + * + * // Append data to the initialized buffer + * dataBuf.end().put('I', 5678); + * + * // Alternative chained syntax for initializing and appending + * const buf = struct.buffer("\x01\x02\x03\x04").end().put('I', 5678); + */ +static uc_value_t * +uc_fmtbuf_new(uc_vm_t *vm, size_t nargs) +{ + formatbuffer_t *buffer = xalloc(sizeof(*buffer)); + uc_value_t *init_data = uc_fn_arg(0); + + buffer->resource.header.type = UC_RESOURCE; + buffer->resource.header.refcount = 1; + buffer->resource.type = ucv_resource_type_lookup(vm, "struct.buffer"); + + if (ucv_type(init_data) == UC_STRING) { + char *buf = ucv_string_get(init_data); + size_t len = ucv_string_length(init_data); + + if (!grow_buffer(vm, &buffer->resource.data, &buffer->capacity, len)) { + free(buffer); + + return NULL; + } + + buffer->length = len; + memcpy((char *)buffer->resource.data + sizeof(uc_string_t), buf, len); + } + + return &buffer->resource.header; +} + +static formatbuffer_t * +formatbuffer_ctx(uc_vm_t *vm) +{ + uc_value_t *ctx = vm->callframes.entries[vm->callframes.count - 1].ctx; + + if (ucv_type(ctx) != UC_RESOURCE) + return NULL; + + uc_resource_t *res = (uc_resource_t *)ctx; + + if (!res->type || strcmp(res->type->name, "struct.buffer") != 0) + return NULL; + + return (formatbuffer_t *)res; +} + +/** + * Get or set the current position in the buffer. + * + * If called without arguments, returns the current position. + * If called with a position argument, sets the current position to that value. + * + * @function module:struct.buffer#pos + * + * @param {number} [position] + * The position to set. If omitted, the current position is returned. + * + * @returns {number|module:struct.buffer} + * If called without arguments, returns the current position. + * If called with a position argument, returns the buffer instance for chaining. + * + * @example + * const currentPos = buf.pos(); + * buf.pos(10); // Set position to 10 + */ +static uc_value_t * +uc_fmtbuf_pos(uc_vm_t *vm, size_t nargs) +{ + formatbuffer_t *buffer = formatbuffer_ctx(vm); + uc_value_t *new_pos = uc_fn_arg(0); + + if (!buffer) + return NULL; + + if (new_pos) { + long long pos; + + if (!ucv_as_longlong(vm, new_pos, &pos)) + return NULL; + + if (pos < 0) pos += buffer->length; + if (pos < 0) pos = 0; + + if (!grow_buffer(vm, &buffer->resource.data, &buffer->capacity, pos)) + return NULL; + + buffer->position = pos; + + if (buffer->position > buffer->length) + buffer->length = buffer->position; + + return ucv_get(&buffer->resource.header); + } + + return ucv_uint64_new(buffer->position); +} + +/** + * Get or set the current buffer length. + * + * If called without arguments, returns the current length of the buffer. + * If called with a length argument, sets the buffer length to that value, + * padding the data with trailing zero bytes or truncating it depending on + * whether the updated length is larger or smaller than the current length + * respectively. + * + * In case the updated length is smaller than the current buffer offset, the + * position is updated accordingly, so that it points to the new end of the + * truncated buffer data. + * + * @function module:struct.buffer#length + * + * @param {number} [length] + * The length to set. If omitted, the current length is returned. + * + * @returns {number|module:struct.buffer} + * If called without arguments, returns the current length. + * If called with a length argument, returns the buffer instance for chaining. + * + * @example + * const buf = struct.buffer("abc"); // Initialize buffer with three bytes + * const currentLen = buf.length(); // Returns 3 + * + * buf.length(6); // Extend to 6 bytes + * buf.slice(); // Trailing null bytes: "abc\x00\x00\x00" + * + * buf.length(2); // Truncate to 2 bytes + * buf.slice(); // Truncated data: "ab" + */ +static uc_value_t * +uc_fmtbuf_length(uc_vm_t *vm, size_t nargs) +{ + formatbuffer_t *buffer = formatbuffer_ctx(vm); + uc_value_t *new_len = uc_fn_arg(0); + + if (!buffer) + return NULL; + + if (new_len) { + size_t len; + + if (!ucv_as_size_t(vm, new_len, &len)) + return NULL; + + if (len > buffer->length) { + if (!grow_buffer(vm, &buffer->resource.data, &buffer->capacity, len)) + return NULL; + + buffer->length = len; + } + else if (len < buffer->length) { + memset((char *)buffer->resource.data + sizeof(uc_string_t) + len, + 0, buffer->length - len); + + buffer->length = len; + + if (len < buffer->position) + buffer->position = len; + } + + return ucv_get(&buffer->resource.header); + } + + return ucv_uint64_new(buffer->length); +} + +/** + * Set the buffer position to the start (0). + * + * @function module:struct.buffer#start + * + * @returns {module:struct.buffer} + * The buffer instance. + * + * @example + * buf.start(); + */ +static uc_value_t * +uc_fmtbuf_start(uc_vm_t *vm, size_t nargs) +{ + formatbuffer_t *buffer = formatbuffer_ctx(vm); + + if (!buffer) + return NULL; + + buffer->position = 0; + + return ucv_get(&buffer->resource.header); +} + +/** + * Set the buffer position to the end. + * + * @function module:struct.buffer#end + * + * @returns {module:struct.buffer} + * The buffer instance. + * + * @example + * buf.end(); + */ +static uc_value_t * +uc_fmtbuf_end(uc_vm_t *vm, size_t nargs) +{ + formatbuffer_t *buffer = formatbuffer_ctx(vm); + + if (!buffer) + return NULL; + + buffer->position = buffer->length; + + return ucv_get(&buffer->resource.header); +} + +/** + * Pack data into the buffer at the current position. + * + * The `put()` function packs the given values into the buffer according to + * the specified format string, starting at the current buffer position. + * The format string follows the same syntax as used in `struct.pack()`. + * + * For a detailed explanation of the format string syntax, refer to the + * ["Format Strings" section]{@link module:struct} in the module + * documentation. + * + * @function module:struct.buffer#put + * + * @param {string} format + * The format string specifying how to pack the data. + * + * @param {...*} values + * The values to pack into the buffer. + * + * @returns {module:struct.buffer} + * The buffer instance. + * + * @see {@link module:struct#pack|struct.pack()} + * + * @example + * buf.put('II', 1234, 5678); + */ +static uc_value_t * +uc_fmtbuf_put(uc_vm_t *vm, size_t nargs) +{ + formatbuffer_t *buffer = formatbuffer_ctx(vm); + uc_value_t *fmt = uc_fn_arg(0); + formatstate_t *state; + bool res; + + if (!buffer) + return NULL; + + state = parse_format(vm, fmt); + + if (!state) + return NULL; + + res = uc_pack_common(vm, nargs, state, 1, + &buffer->resource.data, &buffer->position, &buffer->capacity); + + free(state); + + if (!res) + return NULL; + + if (buffer->position > buffer->length) + buffer->length = buffer->position; + + return ucv_get(&buffer->resource.header); +} + +static uc_value_t * +fmtbuf_get_common(uc_vm_t *vm, size_t nargs, bool single) +{ + formatbuffer_t *buffer = formatbuffer_ctx(vm); + uc_value_t *fmt = uc_fn_arg(0); + formatstate_t *state; + uc_value_t *result; + size_t rem; + char *buf; + + if (!buffer) + return NULL; + + if (single && ucv_type(fmt) == UC_INTEGER) { + int64_t len = ucv_int64_get(fmt); + + if (errno != 0) + goto ebounds; + + size_t spos, epos; + + if (len < 0) { + if (len == INT64_MIN) + goto ebounds; + + if ((uint64_t)-len > buffer->position) + return NULL; + + spos = buffer->position + len; + epos = buffer->position; + } + else { + if ((uint64_t)len > (SIZE_MAX - buffer->position)) + goto ebounds; + + if (buffer->position + len > buffer->length) + return NULL; + + spos = buffer->position; + epos = buffer->position + len; + + buffer->position = epos; + } + + return ucv_string_new_length( + (char *)buffer->resource.data + sizeof(uc_string_t) + spos, + epos - spos); + +ebounds: + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "Length value out of bounds"); + + return NULL; + } + + state = parse_format(vm, fmt); + + if (!state) + return NULL; + + if (single && (state->ncodes != 1 || state->codes[0].repeat != 1)) { + free(state); + uc_vm_raise_exception(vm, EXCEPTION_TYPE, + "get() expects a format string for a single value. " + "Use read() for multiple values."); + + return NULL; + } + + rem = buffer->length; + buf = (char *)buffer->resource.data + sizeof(uc_string_t); + + result = uc_unpack_common(vm, nargs, state, + buf, buffer->position, &rem, single); + + if (result) + buffer->position = buffer->length - rem; + + free(state); + + return result; +} + +/** + * Unpack a single value from the buffer at the current position. + * + * The `get()` function unpacks a single value from the buffer according to the + * specified format string, starting at the current buffer position. + * The format string follows the same syntax as used in `struct.unpack()`. + * + * For a detailed explanation of the format string syntax, refer to the + * ["Format Strings" section]{@link module:struct} in the module documentation. + * + * Alternatively, `get()` accepts a postive or negative integer as format, which + * specifies the length of a string to unpack before or after the current + * position. Negative values extract that many bytes before the current offset + * while postive ones extracts that many bytes after. + * + * @function module:struct.buffer#get + * + * @param {string|number} format + * The format string specifying how to unpack the data. + * + * @returns {*} + * The unpacked value. + * + * @see {@link module:struct#unpack|struct.unpack()} + * + * @example + * const val = buf.get('I'); + * const str = buf.get(5); // equivalent to buf.get('5s') + * const str = buf.get(-3); // equivalent to buf.pos(buf.pos() - 3).get('3s') + */ +static uc_value_t * +uc_fmtbuf_get(uc_vm_t *vm, size_t nargs) +{ + return fmtbuf_get_common(vm, nargs, true); +} + +/** + * Unpack multiple values from the buffer at the current position. + * + * The `read()` function unpacks multiple values from the buffer according to + * the specified format string, starting at the current buffer position. + * The format string follows the same syntax as used in `struct.unpack()`. + * + * For a detailed explanation of the format string syntax, refer to the + * ["Format Strings" section]{@link module:struct} in the module documentation. + * + * @function module:struct.buffer#get + * + * @param {string} format + * The format string specifying how to unpack the data. + * + * @returns {array} + * An array containing the unpacked values. + * + * @see {@link module:struct#unpack|struct.unpack()} + * + * @example + * const values = buf.get('II'); + */ +static uc_value_t * +uc_fmtbuf_read(uc_vm_t *vm, size_t nargs) +{ + return fmtbuf_get_common(vm, nargs, false); +} + +/** + * Extract a slice of the buffer content. + * + * The `slice()` function returns a substring of the buffer content + * between the specified start and end positions. + * + * Both the start and end position values may be negative, in which case they're + * relative to the end of the buffer, e.g. `slice(-3)` will extract the last + * three bytes of data. + * + * @function module:struct.buffer#slice + * + * @param {number} [start=0] + * The starting position of the slice. + * + * @param {number} [end=buffer.length()] + * The ending position of the slice (exclusive). + * + * @returns {string} + * A string containing the specified slice of the buffer content. + * + * @example + * const slice = buf.slice(4, 8); + */ +static uc_value_t * +uc_fmtbuf_slice(uc_vm_t *vm, size_t nargs) +{ + formatbuffer_t *buffer = formatbuffer_ctx(vm); + uc_value_t *from = uc_fn_arg(0); + uc_value_t *to = uc_fn_arg(1); + long long spos, epos; + char *buf; + + if (!buffer) + return NULL; + + spos = 0; + epos = buffer->length; + + if (from && !ucv_as_longlong(vm, from, &spos)) + return NULL; + + if (to && !ucv_as_longlong(vm, to, &epos)) + return NULL; + + if (spos < 0) spos += buffer->length; + if (spos < 0) spos = 0; + if ((unsigned long long)spos > buffer->length) spos = buffer->length; + + if (epos < 0) epos += buffer->length; + if (epos < spos) epos = spos; + if ((unsigned long long)epos > buffer->length) epos = buffer->length; + + buf = (char *)buffer->resource.data + sizeof(uc_string_t) + spos; + + return ucv_string_new_length(buf, epos - spos); +} + +/** + * Set a slice of the buffer content to given byte value. + * + * The `set()` function overwrites a substring of the buffer content with the + * given byte value, similar to the C `memset()` function, between the specified + * start and end positions. + * + * Both the start and end position values may be negative, in which case they're + * relative to the end of the buffer, e.g. `set(0, -2)` will overwrite the last + * two bytes of data with `\x00`. + * + * When the start or end positions are beyond the current buffer length, the + * buffer is grown accordingly. + * + * @function module:struct.buffer#set + * + * @param {number|string} [value=0] + * The byte value to use when overwriting buffer contents. When a string is + * given, the first character is used as value. + * + * @param {number} [start=0] + * The position to start overwriting from. + * + * @param {number} [end=buffer.length()] + * The position to end overwriting (exclusive). + * + * @returns {module:struct.buffer} + * The buffer instance. + * + * @example + * const buf = struct.buffer("abcde"); + * buf.set("X", 2, 4).slice(); // Buffer content is now "abXXe" + * buf.set().slice(); // Buffer content is now "\x00\x00\x00\x00\x00" + */ +static uc_value_t * +uc_fmtbuf_set(uc_vm_t *vm, size_t nargs) +{ + formatbuffer_t *buffer = formatbuffer_ctx(vm); + uc_value_t *byte = uc_fn_arg(0); + uc_value_t *from = uc_fn_arg(1); + uc_value_t *to = uc_fn_arg(2); + long long spos, epos; + long bval; + + if (!buffer) + return NULL; + + bval = 0; + spos = 0; + epos = buffer->length; + + if (ucv_type(byte) == UC_STRING) + bval = *ucv_string_get(byte); + else if (byte && !ucv_as_long(vm, byte, &bval)) + return NULL; + + if (from && !ucv_as_longlong(vm, from, &spos)) + return NULL; + + if (to && !ucv_as_longlong(vm, to, &epos)) + return NULL; + + if (spos < 0) spos += buffer->length; + if (spos < 0) spos = 0; + + if (epos < 0) epos += buffer->length; + + if (epos > spos) { + if ((unsigned long long)epos > buffer->length) { + if (!grow_buffer(vm, &buffer->resource.data, &buffer->capacity, epos)) + return NULL; + + buffer->length = epos; + } + + memset((char *)buffer->resource.data + sizeof(uc_string_t) + spos, + bval, epos - spos); + } + + return ucv_get(&buffer->resource.header); +} + +/** + * Extract and remove all content from the buffer. + * + * The `pull()` function returns all content of the buffer as a string + * and resets the buffer to an empty state. + * + * @function module:struct.buffer#pull + * + * @returns {string} + * A string containing all the buffer content. + * + * @example + * const allData = buf.pull(); + */ +static uc_value_t * +uc_fmtbuf_pull(uc_vm_t *vm, size_t nargs) +{ + formatbuffer_t *buffer = formatbuffer_ctx(vm); + uc_string_t *us; + + if (!buffer) + return NULL; + + if (!buffer->resource.data) + return ucv_string_new_length("", 0); + + us = buffer->resource.data; + us->header.type = UC_STRING; + us->header.refcount = 1; + us->length = buffer->length; + + buffer->resource.data = NULL; + buffer->capacity = 0; + buffer->position = 0; + buffer->length = 0; + + return &us->header; } @@ -2937,10 +3667,24 @@ static const uc_function_list_t struct_inst_fns[] = { { "unpack", uc_struct_unpack } }; +static const uc_function_list_t buffer_inst_fns[] = { + { "pos", uc_fmtbuf_pos }, + { "length", uc_fmtbuf_length }, + { "start", uc_fmtbuf_start }, + { "end", uc_fmtbuf_end }, + { "set", uc_fmtbuf_set }, + { "put", uc_fmtbuf_put }, + { "get", uc_fmtbuf_get }, + { "read", uc_fmtbuf_read }, + { "slice", uc_fmtbuf_slice }, + { "pull", uc_fmtbuf_pull }, +}; + static const uc_function_list_t struct_fns[] = { { "pack", uc_pack }, { "unpack", uc_unpack }, - { "new", uc_struct_new } + { "new", uc_struct_new }, + { "buffer", uc_fmtbuf_new } }; void uc_module_init(uc_vm_t *vm, uc_value_t *scope) @@ -2949,5 +3693,6 @@ void uc_module_init(uc_vm_t *vm, uc_value_t *scope) uc_function_list_register(scope, struct_fns); - struct_type = uc_type_declare(vm, "struct", struct_inst_fns, uc_struct_gc); + uc_type_declare(vm, "struct.format", struct_inst_fns, free); + uc_type_declare(vm, "struct.buffer", buffer_inst_fns, free); } @@ -15,6 +15,7 @@ */ #include <unistd.h> +#include <limits.h> #include <libubus.h> #include <libubox/blobmsg.h> @@ -22,6 +23,11 @@ #define ok_return(expr) do { set_error(0, NULL); return (expr); } while(0) #define err_return(err, ...) do { set_error(err, __VA_ARGS__); return NULL; } while(0) +#define errval_return(err, ...) do { set_error(err, __VA_ARGS__); return err; } while(0) + +#define REQUIRED 0 +#define OPTIONAL 1 +#define NAMED 2 static struct { enum ubus_msg_status code; @@ -62,14 +68,21 @@ _arg_type(uc_type_t type) } static bool -_args_get(uc_vm_t *vm, size_t nargs, ...) +_args_get(uc_vm_t *vm, bool named, size_t nargs, ...) { - uc_value_t **ptr, *arg; + uc_value_t **ptr, *arg, *obj = NULL; uc_type_t type, t; const char *name; size_t index = 0; va_list ap; - bool opt; + int opt; + + if (named) { + obj = uc_fn_arg(0); + + if (nargs != 1 || ucv_type(obj) != UC_OBJECT) + named = false; + } va_start(ap, nargs); @@ -79,13 +92,18 @@ _args_get(uc_vm_t *vm, size_t nargs, ...) if (!name) break; - arg = uc_fn_arg(index++); - type = va_arg(ap, uc_type_t); opt = va_arg(ap, int); ptr = va_arg(ap, uc_value_t **); - if (!opt && !arg) + if (named) + arg = ucv_object_get(obj, name, NULL); + else if (opt != NAMED) + arg = uc_fn_arg(index++); + else + arg = NULL; + + if (opt == REQUIRED && !arg) err_return(UBUS_STATUS_INVALID_ARGUMENT, "Argument %s is required", name); t = ucv_type(arg); @@ -93,7 +111,7 @@ _args_get(uc_vm_t *vm, size_t nargs, ...) if (t == UC_CFUNCTION) t = UC_CLOSURE; - if (arg && t != type) + if (arg && type && t != type) err_return(UBUS_STATUS_INVALID_ARGUMENT, "Argument %s is not %s", name, _arg_type(type)); *ptr = arg; @@ -104,7 +122,8 @@ _args_get(uc_vm_t *vm, size_t nargs, ...) ok_return(true); } -#define args_get(vm, nargs, ...) do { if (!_args_get(vm, nargs, __VA_ARGS__, NULL)) return NULL; } while(0) +#define args_get_named(vm, nargs, ...) do { if (!_args_get(vm, true, nargs, __VA_ARGS__, NULL)) return NULL; } while(0) +#define args_get(vm, nargs, ...) do { if (!_args_get(vm, false, nargs, __VA_ARGS__, NULL)) return NULL; } while(0) static uc_resource_type_t *subscriber_type; static uc_resource_type_t *listener_type; @@ -113,9 +132,7 @@ static uc_resource_type_t *notify_type; static uc_resource_type_t *object_type; static uc_resource_type_t *defer_type; static uc_resource_type_t *conn_type; - -static uint64_t n_cb_active; -static bool have_own_uloop; +static uc_resource_type_t *chan_type; static struct blob_buf buf; @@ -123,6 +140,9 @@ typedef struct { struct ubus_context ctx; struct blob_buf buf; int timeout; + + uc_vm_t *vm; + int registry_index; } uc_ubus_connection_t; typedef struct { @@ -275,14 +295,24 @@ _uc_reg_clear(uc_vm_t *vm, const char *key, size_t idx, size_t nptrs) } -#define request_reg_add(vm, request, cb, conn) \ - _uc_reg_add(vm, "ubus.requests", 3, request, cb, conn) +#define connection_reg_add(vm, conn, cb, disconnect_cb, fd) \ + _uc_reg_add(vm, "ubus.connections", 4, conn, cb, disconnect_cb, fd) + +#define connection_reg_get(vm, idx, conn, cb, disconnect_cb) \ + _uc_reg_get(vm, "ubus.connections", idx, 3, conn, cb, disconnect_cb) -#define request_reg_get(vm, idx, request, cb) \ - _uc_reg_get(vm, "ubus.requests", idx, 2, request, cb) +#define connection_reg_clear(vm, idx) \ + _uc_reg_clear(vm, "ubus.connections", idx, 4) + + +#define request_reg_add(vm, request, cb, datacb, fdcb, conn, fd) \ + _uc_reg_add(vm, "ubus.requests", 6, request, cb, datacb, fdcb, conn, fd) + +#define request_reg_get(vm, idx, request, cb, datacb, fdcb) \ + _uc_reg_get(vm, "ubus.requests", idx, 4, request, cb, datacb, fdcb) #define request_reg_clear(vm, idx) \ - _uc_reg_clear(vm, "ubus.requests", idx, 3) + _uc_reg_clear(vm, "ubus.requests", idx, 6) #define object_reg_add(vm, obj, msg, cb) \ @@ -495,6 +525,7 @@ uc_ubus_connect(uc_vm_t *vm, size_t nargs) "timeout", UC_INTEGER, true, &timeout); c = xalloc(sizeof(*c)); + c->registry_index = -1; c->timeout = timeout ? ucv_int64_get(timeout) : 30; if (ubus_connect_ctx(&c->ctx, socket ? ucv_string_get(socket) : NULL)) { @@ -539,6 +570,8 @@ _conn_get(uc_vm_t *vm, uc_ubus_connection_t **conn) uc_ubus_connection_t *c = uc_fn_thisval("ubus.connection"); if (!c) + c = uc_fn_thisval("ubus.channel"); + if (!c) err_return(UBUS_STATUS_INVALID_ARGUMENT, "Invalid connection context"); if (c->ctx.sock.fd < 0) @@ -602,7 +635,7 @@ uc_ubus_call_user_cb(uc_ubus_deferred_t *defer, int ret, uc_value_t *reply) { uc_value_t *this, *func; - request_reg_get(defer->vm, defer->registry_index, &this, &func); + request_reg_get(defer->vm, defer->registry_index, &this, &func, NULL, NULL); if (ucv_is_callable(func)) { uc_vm_stack_push(defer->vm, ucv_get(this)); @@ -615,11 +648,6 @@ uc_ubus_call_user_cb(uc_ubus_deferred_t *defer, int ret, uc_value_t *reply) } request_reg_clear(defer->vm, defer->registry_index); - - n_cb_active--; - - if (have_own_uloop && n_cb_active == 0) - uloop_end(); } static void @@ -632,6 +660,51 @@ uc_ubus_call_data_cb(struct ubus_request *req, int type, struct blob_attr *msg) } static void +uc_ubus_call_data_user_cb(struct ubus_request *req, int type, struct blob_attr *msg) +{ + uc_ubus_deferred_t *defer = container_of(req, uc_ubus_deferred_t, request); + uc_value_t *this, *func, *reply; + + request_reg_get(defer->vm, defer->registry_index, &this, NULL, &func, NULL); + + if (ucv_is_callable(func)) { + reply = blob_array_to_ucv(defer->vm, blob_data(msg), blob_len(msg), true); + + uc_vm_stack_push(defer->vm, ucv_get(this)); + uc_vm_stack_push(defer->vm, ucv_get(func)); + uc_vm_stack_push(defer->vm, ucv_get(reply)); + + if (uc_vm_call(defer->vm, true, 1) == EXCEPTION_NONE) + ucv_put(uc_vm_stack_pop(defer->vm)); + else + uloop_end(); + } +} + +static void +uc_ubus_call_fd_cb(struct ubus_request *req, int fd) +{ + uc_ubus_deferred_t *defer = container_of(req, uc_ubus_deferred_t, request); + uc_value_t *this, *func; + + if (defer->complete) + return; + + request_reg_get(defer->vm, defer->registry_index, &this, NULL, NULL, &func); + + if (ucv_is_callable(func)) { + uc_vm_stack_push(defer->vm, ucv_get(this)); + uc_vm_stack_push(defer->vm, ucv_get(func)); + uc_vm_stack_push(defer->vm, ucv_int64_new(fd)); + + if (uc_vm_call(defer->vm, true, 1) == EXCEPTION_NONE) + ucv_put(uc_vm_stack_pop(defer->vm)); + else + uloop_end(); + } +} + +static void uc_ubus_call_done_cb(struct ubus_request *req, int ret) { uc_ubus_deferred_t *defer = container_of(req, uc_ubus_deferred_t, request); @@ -659,117 +732,248 @@ uc_ubus_call_timeout_cb(struct uloop_timeout *timeout) uc_ubus_call_user_cb(defer, UBUS_STATUS_TIMEOUT, NULL); } -static bool -uc_ubus_have_uloop(void) +static int +get_fd(uc_vm_t *vm, uc_value_t *val) { - bool prev = uloop_cancelled; - bool active; + uc_value_t *fn; + int64_t n; -#ifdef HAVE_ULOOP_FD_SET_CB - if (uloop_fd_set_cb) - return true; -#endif + fn = ucv_property_get(val, "fileno"); + + if (ucv_is_callable(fn)) { + uc_vm_stack_push(vm, ucv_get(val)); + uc_vm_stack_push(vm, ucv_get(fn)); + + if (uc_vm_call(vm, true, 0) != EXCEPTION_NONE) + return -1; + + val = uc_vm_stack_pop(vm); + n = ucv_int64_get(val); + ucv_put(val); + } + else { + n = ucv_int64_get(val); + } - uloop_cancelled = true; - active = uloop_cancelling(); - uloop_cancelled = prev; + if (errno || n < 0 || n > (int64_t)INT_MAX) + return -1; - return active; + return (int)n; } -static uc_value_t * -uc_ubus_call(uc_vm_t *vm, size_t nargs) +static int +uc_ubus_call_common(uc_vm_t *vm, uc_ubus_connection_t *c, uc_ubus_call_res_t *res, + uint32_t id, uc_value_t *funname, uc_value_t *funargs, + uc_value_t *fd, uc_value_t *fdcb, uc_value_t *mret) { - uc_value_t *objname, *funname, *funargs, *mret = NULL; - uc_ubus_call_res_t res = { 0 }; - uc_ubus_connection_t *c; + uc_ubus_deferred_t defer = {}; enum ubus_msg_status rv; - uint32_t id; + int fd_val = -1; + + enum { + RET_MODE_SINGLE, + RET_MODE_MULTIPLE, + RET_MODE_IGNORE, + } ret_mode = RET_MODE_SINGLE; + + const char * const ret_modes[] = { + [RET_MODE_SINGLE] = "single", + [RET_MODE_MULTIPLE] = "multiple", + [RET_MODE_IGNORE] = "ignore", + }; + + if (ucv_type(mret) == UC_STRING) { + const char *str = ucv_string_get(mret); + size_t i; + + for (i = 0; i < ARRAY_SIZE(ret_modes); i++) + if (!strcmp(str, ret_modes[i])) + break; - conn_get(vm, &c); + if (i == ARRAY_SIZE(ret_modes)) + errval_return(UBUS_STATUS_INVALID_ARGUMENT, + "Invalid return mode argument"); - args_get(vm, nargs, - "object name", UC_STRING, false, &objname, - "function name", UC_STRING, false, &funname, - "function arguments", UC_OBJECT, true, &funargs, - "multiple return", UC_BOOLEAN, true, &mret); + ret_mode = i; + } + else if (ucv_type(mret) == UC_BOOLEAN) { + ret_mode = ucv_boolean_get(mret); + } + else if (ret_mode) { + errval_return(UBUS_STATUS_INVALID_ARGUMENT, + "Invalid return mode argument"); + } blob_buf_init(&c->buf, 0); if (funargs) ucv_object_to_blob(funargs, &c->buf); - rv = ubus_lookup_id(&c->ctx, ucv_string_get(objname), &id); + if (fd) { + fd_val = get_fd(vm, fd); - if (rv != UBUS_STATUS_OK) - err_return(rv, "Failed to resolve object name '%s'", - ucv_string_get(objname)); + if (fd_val < 0) + errval_return(UBUS_STATUS_INVALID_ARGUMENT, + "Invalid file descriptor argument"); + } - res.mret = ucv_is_truish(mret); + res->mret = (ret_mode == RET_MODE_MULTIPLE); - rv = ubus_invoke(&c->ctx, id, ucv_string_get(funname), c->buf.head, - uc_ubus_call_cb, &res, c->timeout * 1000); + rv = ubus_invoke_async_fd(&c->ctx, id, ucv_string_get(funname), + c->buf.head, &defer.request, fd_val); - if (rv != UBUS_STATUS_OK) - err_return(rv, "Failed to invoke function '%s' on object '%s'", - ucv_string_get(funname), ucv_string_get(objname)); + defer.vm = vm; + defer.ctx = &c->ctx; + defer.request.data_cb = uc_ubus_call_cb; + defer.request.priv = res; - ok_return(res.res); + if (ucv_is_callable(fdcb)) { + defer.request.fd_cb = uc_ubus_call_fd_cb; + defer.registry_index = request_reg_add(vm, NULL, NULL, NULL, ucv_get(fdcb), NULL, NULL); + } + + if (rv == UBUS_STATUS_OK) { + if (ret_mode == RET_MODE_IGNORE) + ubus_abort_request(&c->ctx, &defer.request); + else + rv = ubus_complete_request(&c->ctx, &defer.request, c->timeout * 1000); + } + + if (defer.request.fd_cb) + request_reg_clear(vm, defer.registry_index); + + return rv; } static uc_value_t * -uc_ubus_defer(uc_vm_t *vm, size_t nargs) +uc_ubus_call(uc_vm_t *vm, size_t nargs) { - uc_value_t *objname, *funname, *funargs, *replycb, *conn, *res = NULL; - uc_ubus_deferred_t *defer; + uc_value_t *obj, *funname, *funargs, *fd, *fdcb, *mret = NULL; + uc_ubus_call_res_t res = { 0 }; uc_ubus_connection_t *c; enum ubus_msg_status rv; uint32_t id; + args_get_named(vm, nargs, + "object", 0, REQUIRED, &obj, + "method", UC_STRING, REQUIRED, &funname, + "data", UC_OBJECT, OPTIONAL, &funargs, + "return", 0, OPTIONAL, &mret, + "fd", 0, NAMED, &fd, + "fd_cb", UC_CLOSURE, NAMED, &fdcb); + conn_get(vm, &c); - args_get(vm, nargs, - "object name", UC_STRING, false, &objname, - "function name", UC_STRING, false, &funname, - "function arguments", UC_OBJECT, true, &funargs, - "reply callback", UC_CLOSURE, true, &replycb); + if (ucv_type(obj) == UC_INTEGER) { + id = ucv_int64_get(obj); + } + else if (ucv_type(obj) == UC_STRING) { + rv = ubus_lookup_id(&c->ctx, ucv_string_get(obj), &id); + + if (rv != UBUS_STATUS_OK) + err_return(rv, "Failed to resolve object name '%s'", + ucv_string_get(obj)); + } + else { + err_return(UBUS_STATUS_INVALID_ARGUMENT, + "Argument object is not string or integer"); + } + + rv = uc_ubus_call_common(vm, c, &res, id, funname, funargs, fd, fdcb, mret); + + if (rv != UBUS_STATUS_OK) { + if (ucv_type(obj) == UC_STRING) + err_return(rv, "Failed to invoke function '%s' on object '%s'", + ucv_string_get(funname), ucv_string_get(obj)); + else + err_return(rv, "Failed to invoke function '%s' on system object %d", + ucv_string_get(funname), (int)ucv_int64_get(obj)); + } + + ok_return(res.res); +} + +static uc_value_t * +uc_ubus_chan_request(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *funname, *funargs, *fd, *fdcb, *mret = NULL; + uc_ubus_call_res_t res = { 0 }; + uc_ubus_connection_t *c; + enum ubus_msg_status rv; + + args_get_named(vm, nargs, + "method", UC_STRING, REQUIRED, &funname, + "data", UC_OBJECT, OPTIONAL, &funargs, + "return", 0, OPTIONAL, &mret, + "fd", 0, NAMED, &fd, + "fd_cb", UC_CLOSURE, NAMED, &fdcb); + + conn_get(vm, &c); + + rv = uc_ubus_call_common(vm, c, &res, 0, funname, funargs, fd, fdcb, mret); + + if (rv != UBUS_STATUS_OK) + err_return(rv, "Failed to send request '%s' on channel", + ucv_string_get(funname)); + + ok_return(res.res); +} + +static int +uc_ubus_defer_common(uc_vm_t *vm, uc_ubus_connection_t *c, uc_ubus_call_res_t *res, + uint32_t id, uc_value_t *funname, uc_value_t *funargs, + uc_value_t *fd, uc_value_t *fdcb, uc_value_t *replycb, + uc_value_t *datacb) +{ + uc_ubus_deferred_t *defer; + enum ubus_msg_status rv; + uc_callframe_t *frame; + uc_value_t *conn; + int fd_val = -1; blob_buf_init(&c->buf, 0); if (funargs) ucv_object_to_blob(funargs, &c->buf); - rv = ubus_lookup_id(&c->ctx, ucv_string_get(objname), &id); + if (fd) { + fd_val = get_fd(vm, fd); - if (rv != UBUS_STATUS_OK) - err_return(rv, "Failed to resolve object name '%s'", - ucv_string_get(objname)); + if (fd_val < 0) + errval_return(UBUS_STATUS_INVALID_ARGUMENT, + "Invalid file descriptor argument"); + } defer = xalloc(sizeof(*defer)); - rv = ubus_invoke_async(&c->ctx, id, ucv_string_get(funname), - c->buf.head, &defer->request); + rv = ubus_invoke_async_fd(&c->ctx, id, ucv_string_get(funname), + c->buf.head, &defer->request, fd_val); if (rv == UBUS_STATUS_OK) { defer->vm = vm; defer->ctx = &c->ctx; - defer->request.data_cb = uc_ubus_call_data_cb; + if (ucv_is_callable(datacb)) + defer->request.data_cb = uc_ubus_call_data_user_cb; + else + defer->request.data_cb = uc_ubus_call_data_cb; + + if (ucv_is_callable(fdcb)) + defer->request.fd_cb = uc_ubus_call_fd_cb; + defer->request.complete_cb = uc_ubus_call_done_cb; + ubus_complete_request_async(&c->ctx, &defer->request); defer->timeout.cb = uc_ubus_call_timeout_cb; uloop_timeout_set(&defer->timeout, c->timeout * 1000); - res = uc_resource_new(defer_type, defer); - conn = uc_vector_last(&vm->callframes)->ctx; + res->res = uc_resource_new(defer_type, defer); + frame = uc_vector_last(&vm->callframes); + conn = frame ? frame->ctx : NULL; - defer->registry_index = request_reg_add(vm, ucv_get(res), ucv_get(replycb), ucv_get(conn)); - - if (!uc_ubus_have_uloop()) { - have_own_uloop = true; - uloop_run(); - } + defer->registry_index = request_reg_add(vm, ucv_get(res->res), ucv_get(replycb), ucv_get(datacb), + ucv_get(fdcb), ucv_get(conn), ucv_get(fd)); } else { uc_vm_stack_push(vm, ucv_get(replycb)); @@ -783,11 +987,69 @@ uc_ubus_defer(uc_vm_t *vm, size_t nargs) free(defer); } + return rv; +} + +static uc_value_t * +uc_ubus_defer(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *objname, *funname, *funargs, *replycb, *datacb, *fd, *fdcb = NULL; + uc_ubus_call_res_t res = { 0 }; + uc_ubus_connection_t *c; + uint32_t id; + int rv; + + conn_get(vm, &c); + + rv = ubus_lookup_id(&c->ctx, ucv_string_get(objname), &id); + + if (rv != UBUS_STATUS_OK) + err_return(rv, "Failed to resolve object name '%s'", + ucv_string_get(objname)); + + args_get_named(vm, nargs, + "object", UC_STRING, REQUIRED, &objname, + "method", UC_STRING, REQUIRED, &funname, + "data", UC_OBJECT, OPTIONAL, &funargs, + "cb", UC_CLOSURE, OPTIONAL, &replycb, + "data_cb", UC_CLOSURE, OPTIONAL, &datacb, + "fd", 0, NAMED, &fd, + "fd_cb", UC_CLOSURE, NAMED, &fdcb); + + rv = uc_ubus_defer_common(vm, c, &res, id, funname, funargs, fd, fdcb, replycb, datacb); + if (rv != UBUS_STATUS_OK) err_return(rv, "Failed to invoke function '%s' on object '%s'", ucv_string_get(funname), ucv_string_get(objname)); - ok_return(res); + ok_return(res.res); +} + +static uc_value_t * +uc_ubus_chan_defer(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *funname, *funargs, *replycb, *datacb, *fd, *fdcb = NULL; + uc_ubus_call_res_t res = { 0 }; + uc_ubus_connection_t *c; + int rv; + + conn_get(vm, &c); + + args_get_named(vm, nargs, + "method", UC_STRING, REQUIRED, &funname, + "data", UC_OBJECT, OPTIONAL, &funargs, + "cb", UC_CLOSURE, OPTIONAL, &replycb, + "data_cb", UC_CLOSURE, OPTIONAL, &datacb, + "fd", 0, NAMED, &fd, + "fd_cb", UC_CLOSURE, NAMED, &fdcb); + + rv = uc_ubus_defer_common(vm, c, &res, 0, funname, funargs, fd, fdcb, replycb, datacb); + + if (rv != UBUS_STATUS_OK) + err_return(rv, "Failed to invoke function '%s' on channel", + ucv_string_get(funname)); + + ok_return(res.res); } @@ -797,20 +1059,37 @@ uc_ubus_defer(uc_vm_t *vm, size_t nargs) */ static void -uc_ubus_request_finish(uc_ubus_request_t *callctx, int code, uc_value_t *reply) +uc_ubus_request_finish_common(uc_ubus_request_t *callctx, int code) { - if (callctx->replied) - return; + int fd; - if (reply) { - blob_buf_init(&buf, 0); - ucv_object_to_blob(reply, &buf); - ubus_send_reply(callctx->ctx, &callctx->req, buf.head); - } + fd = ubus_request_get_caller_fd(&callctx->req); - callctx->replied = true; + if (fd >= 0) + close(fd); + callctx->replied = true; ubus_complete_deferred_request(callctx->ctx, &callctx->req, code); +} + +static void +uc_ubus_request_send_reply(uc_ubus_request_t *callctx, uc_value_t *reply) +{ + if (!reply) + return; + + blob_buf_init(&buf, 0); + ucv_object_to_blob(reply, &buf); + ubus_send_reply(callctx->ctx, &callctx->req, buf.head); +} + +static void +uc_ubus_request_finish(uc_ubus_request_t *callctx, int code) +{ + if (callctx->replied) + return; + + uc_ubus_request_finish_common(callctx, code); request_reg_clear(callctx->vm, callctx->registry_index); } @@ -819,7 +1098,7 @@ uc_ubus_request_timeout(struct uloop_timeout *timeout) { uc_ubus_request_t *callctx = container_of(timeout, uc_ubus_request_t, timeout); - uc_ubus_request_finish(callctx, UBUS_STATUS_TIMEOUT, NULL); + uc_ubus_request_finish(callctx, UBUS_STATUS_TIMEOUT); } static uc_value_t * @@ -828,6 +1107,7 @@ uc_ubus_request_reply(uc_vm_t *vm, size_t nargs) uc_ubus_request_t **callctx = uc_fn_this("ubus.request"); int64_t code = UBUS_STATUS_OK; uc_value_t *reply, *rcode; + bool more = false; if (!callctx || !*callctx) err_return(UBUS_STATUS_INVALID_ARGUMENT, "Invalid call context"); @@ -842,11 +1122,17 @@ uc_ubus_request_reply(uc_vm_t *vm, size_t nargs) if (rcode) { code = ucv_int64_get(rcode); - if (errno == ERANGE || code < 0 || code > __UBUS_STATUS_LAST) + if (errno == ERANGE || code < -1 || code > __UBUS_STATUS_LAST) code = UBUS_STATUS_UNKNOWN_ERROR; + + if (code < 0) + more = true; } - uc_ubus_request_finish(*callctx, code, reply); + uc_ubus_request_send_reply(*callctx, reply); + + if (!more) + uc_ubus_request_finish(*callctx, code); ok_return(ucv_boolean_new(true)); } @@ -864,6 +1150,36 @@ uc_ubus_request_defer(uc_vm_t *vm, size_t nargs) } static uc_value_t * +uc_ubus_request_get_fd(uc_vm_t *vm, size_t nargs) +{ + uc_ubus_request_t *callctx = uc_fn_thisval("ubus.request"); + + if (!callctx) + return NULL; + + return ucv_int64_new(ubus_request_get_caller_fd(&callctx->req)); +} + +static uc_value_t * +uc_ubus_request_set_fd(uc_vm_t *vm, size_t nargs) +{ + uc_ubus_request_t *callctx = uc_fn_thisval("ubus.request"); + int fd; + + if (!callctx) + err_return(UBUS_STATUS_INVALID_ARGUMENT, "Invalid call context"); + + fd = get_fd(vm, uc_fn_arg(0)); + + if (fd < 0) + err_return(UBUS_STATUS_INVALID_ARGUMENT, "Invalid file descriptor"); + + ubus_request_set_fd(callctx->ctx, &callctx->req, fd); + + return ucv_boolean_new(true); +} + +static uc_value_t * uc_ubus_request_error(uc_vm_t *vm, size_t nargs) { uc_ubus_request_t **callctx = uc_fn_this("ubus.request"); @@ -884,7 +1200,7 @@ uc_ubus_request_error(uc_vm_t *vm, size_t nargs) if (errno == ERANGE || code < 0 || code > __UBUS_STATUS_LAST) code = UBUS_STATUS_UNKNOWN_ERROR; - uc_ubus_request_finish(*callctx, code, NULL); + uc_ubus_request_finish(*callctx, code); ok_return(ucv_boolean_new(true)); } @@ -1003,13 +1319,13 @@ uc_ubus_object_notify(uc_vm_t *vm, size_t nargs) if (!uuobj || !*uuobj) err_return(UBUS_STATUS_INVALID_ARGUMENT, "Invalid object context"); - args_get(vm, nargs, - "typename", UC_STRING, false, &typename, - "message", UC_OBJECT, true, &message, - "data callback", UC_CLOSURE, true, &data_cb, - "status callback", UC_CLOSURE, true, &status_cb, - "completion callback", UC_CLOSURE, true, &complete_cb, - "timeout", UC_INTEGER, true, &timeout); + args_get_named(vm, nargs, + "type", UC_STRING, REQUIRED, &typename, + "data", UC_OBJECT, OPTIONAL, &message, + "data_cb", UC_CLOSURE, OPTIONAL, &data_cb, + "status_cb", UC_CLOSURE, OPTIONAL, &status_cb, + "cb", UC_CLOSURE, OPTIONAL, &complete_cb, + "timeout", UC_INTEGER, OPTIONAL, &timeout); t = timeout ? ucv_int64_get(timeout) : -1; @@ -1233,6 +1549,9 @@ uc_ubus_handle_reply_common(struct ubus_context *ctx, ubus_defer_request(ctx, req, &callctx->req); + /* fd is copied to deferred request. ensure it does not get closed early */ + ubus_request_get_caller_fd(req); + /* create ucode request type object and set properties */ reqobj = uc_resource_new(request_type, callctx); @@ -1257,7 +1576,7 @@ uc_ubus_handle_reply_common(struct ubus_context *ctx, /* Add wrapped request context into registry to prevent GC'ing * until reply or timeout occurred */ - callctx->registry_index = request_reg_add(vm, ucv_get(reqobj), NULL, NULL); + callctx->registry_index = request_reg_add(vm, ucv_get(reqobj), NULL, NULL, NULL, NULL, NULL); } /* Otherwise, when the function returned an object, treat it as @@ -1267,8 +1586,7 @@ uc_ubus_handle_reply_common(struct ubus_context *ctx, ucv_object_to_blob(res, &buf); ubus_send_reply(ctx, &callctx->req, buf.head); - ubus_complete_deferred_request(ctx, &callctx->req, UBUS_STATUS_OK); - callctx->replied = true; + uc_ubus_request_finish_common(callctx, UBUS_STATUS_OK); } /* If neither a deferred ubus request, nor a plain object were @@ -1284,8 +1602,7 @@ uc_ubus_handle_reply_common(struct ubus_context *ctx, rv = UBUS_STATUS_UNKNOWN_ERROR; } - ubus_complete_deferred_request(ctx, &callctx->req, rv); - callctx->replied = true; + uc_ubus_request_finish_common(callctx, rv); } ucv_put(res); @@ -1299,15 +1616,13 @@ uc_ubus_handle_reply_common(struct ubus_context *ctx, if (rv < UBUS_STATUS_OK || rv >= __UBUS_STATUS_LAST) rv = UBUS_STATUS_UNKNOWN_ERROR; - ubus_complete_deferred_request(ctx, &callctx->req, rv); - callctx->replied = true; + uc_ubus_request_finish_common(callctx, rv); break; /* treat other exceptions as fatal and halt uloop */ default: - ubus_complete_deferred_request(ctx, &callctx->req, UBUS_STATUS_UNKNOWN_ERROR); + uc_ubus_request_finish_common(callctx, UBUS_STATUS_UNKNOWN_ERROR); uloop_end(); - callctx->replied = true; break; } @@ -1963,6 +2278,29 @@ uc_ubus_defer_completed(uc_vm_t *vm, size_t nargs) } static uc_value_t * +uc_ubus_defer_await(uc_vm_t *vm, size_t nargs) +{ + uc_ubus_deferred_t *d = uc_fn_thisval("ubus.deferred"); + int64_t remaining; + + if (!d) + err_return(UBUS_STATUS_INVALID_ARGUMENT, "Invalid deferred context"); + + if (d->complete) + ok_return(ucv_boolean_new(false)); + +#ifdef HAVE_ULOOP_TIMEOUT_REMAINING64 + remaining = uloop_timeout_remaining64(&d->timeout); +#else + remaining = uloop_timeout_remaining(&d->timeout); +#endif + + ubus_complete_request(d->ctx, &d->request, remaining); + + ok_return(ucv_boolean_new(true)); +} + +static uc_value_t * uc_ubus_defer_abort(uc_vm_t *vm, size_t nargs) { uc_ubus_deferred_t **d = uc_fn_this("ubus.deferred"); @@ -1978,20 +2316,161 @@ uc_ubus_defer_abort(uc_vm_t *vm, size_t nargs) request_reg_clear((*d)->vm, (*d)->registry_index); - n_cb_active--; - - if (have_own_uloop && n_cb_active == 0) - uloop_end(); - (*d)->complete = true; ok_return(ucv_boolean_new(true)); } +/* + * channel related methods + * -------------------------------------------------------------------------- + */ + +#ifdef HAVE_UBUS_CHANNEL_SUPPORT +static int +uc_ubus_channel_req_cb(struct ubus_context *ctx, struct ubus_object *obj, + struct ubus_request_data *req, const char *method, + struct blob_attr *msg) +{ + uc_ubus_connection_t *c = container_of(ctx, uc_ubus_connection_t, ctx); + uc_value_t *this, *func, *args, *reqproto; + + connection_reg_get(c->vm, c->registry_index, &this, &func, NULL); + + if (!ucv_is_callable(func)) + return UBUS_STATUS_METHOD_NOT_FOUND; + + args = blob_array_to_ucv(c->vm, blob_data(msg), blob_len(msg), true); + reqproto = ucv_object_new(c->vm); + ucv_object_add(reqproto, "args", ucv_get(args)); + + if (method) + ucv_object_add(reqproto, "type", ucv_get(ucv_string_new(method))); + + return uc_ubus_handle_reply_common(ctx, req, c->vm, this, func, reqproto); +} + +static void +uc_ubus_channel_disconnect_cb(struct ubus_context *ctx) +{ + uc_ubus_connection_t *c = container_of(ctx, uc_ubus_connection_t, ctx); + uc_value_t *this, *func; + + connection_reg_get(c->vm, c->registry_index, &this, NULL, &func); + + if (ucv_is_callable(func)) { + uc_vm_stack_push(c->vm, ucv_get(this)); + uc_vm_stack_push(c->vm, ucv_get(func)); + + if (uc_vm_call(c->vm, true, 0) == EXCEPTION_NONE) + ucv_put(uc_vm_stack_pop(c->vm)); + else + uloop_end(); + } + + blob_buf_free(&c->buf); + + if (c->ctx.sock.fd >= 0) { + ubus_shutdown(&c->ctx); + c->ctx.sock.fd = -1; + } + + if (c->registry_index >= 0) + connection_reg_clear(c->vm, c->registry_index); +} + +static uc_value_t * +uc_ubus_channel_add(uc_vm_t *vm, uc_ubus_connection_t *c, uc_value_t *cb, + uc_value_t *disconnect_cb, uc_value_t *fd) +{ + uc_value_t *chan; + + c->vm = vm; + + if (c->timeout < 0) + c->timeout = 30; + + chan = uc_resource_new(chan_type, c); + c->registry_index = connection_reg_add(vm, ucv_get(chan), ucv_get(cb), ucv_get(disconnect_cb), ucv_get(fd)); + c->ctx.connection_lost = uc_ubus_channel_disconnect_cb; + ubus_add_uloop(&c->ctx); + + ok_return(chan); +} +#endif + +static uc_value_t * +uc_ubus_request_new_channel(uc_vm_t *vm, size_t nargs) +{ +#ifdef HAVE_UBUS_CHANNEL_SUPPORT + uc_ubus_request_t *callctx = uc_fn_thisval("ubus.request"); + uc_value_t *cb, *disconnect_cb, *timeout; + uc_ubus_connection_t *c; + int fd; + + if (!callctx) + err_return(UBUS_STATUS_INVALID_ARGUMENT, "Invalid call context"); + + args_get(vm, nargs, + "cb", UC_CLOSURE, true, &cb, + "disconnect_cb", UC_CLOSURE, true, &disconnect_cb, + "timeout", UC_INTEGER, true, &timeout); + + c = xalloc(sizeof(*c)); + c->timeout = timeout ? ucv_int64_get(timeout) : 30; + + if (ubus_channel_create(&c->ctx, &fd, cb ? uc_ubus_channel_req_cb : NULL)) { + free(c); + err_return(UBUS_STATUS_UNKNOWN_ERROR, "Unable to create ubus channel"); + } + + ubus_request_set_fd(callctx->ctx, &callctx->req, fd); + + return uc_ubus_channel_add(vm, c, cb, disconnect_cb, NULL); +#else + err_return(UBUS_STATUS_NOT_SUPPORTED, "No ubus channel support"); +#endif +} + + +static uc_value_t * +uc_ubus_channel_connect(uc_vm_t *vm, size_t nargs) +{ +#ifdef HAVE_UBUS_CHANNEL_SUPPORT + uc_value_t *fd, *cb, *disconnect_cb, *timeout; + uc_ubus_connection_t *c; + int fd_val; + + args_get(vm, nargs, + "fd", UC_NULL, false, &fd, + "cb", UC_CLOSURE, true, &cb, + "disconnect_cb", UC_CLOSURE, true, &disconnect_cb, + "timeout", UC_INTEGER, true, &timeout); + + fd_val = get_fd(vm, fd); + + if (fd_val < 0) + err_return(UBUS_STATUS_INVALID_ARGUMENT, "Invalid file descriptor argument"); + + c = xalloc(sizeof(*c)); + c->timeout = timeout ? ucv_int64_get(timeout) : 30; + + if (ubus_channel_connect(&c->ctx, fd_val, cb ? uc_ubus_channel_req_cb : NULL)) { + free(c); + err_return(UBUS_STATUS_UNKNOWN_ERROR, "Unable to create ubus channel"); + } + + return uc_ubus_channel_add(vm, c, cb, disconnect_cb, fd); +#else + err_return(UBUS_STATUS_NOT_SUPPORTED, "No ubus channel support"); +#endif +} + static const uc_function_list_t global_fns[] = { { "error", uc_ubus_error }, { "connect", uc_ubus_connect }, + { "open_channel", uc_ubus_channel_connect }, }; static const uc_function_list_t conn_fns[] = { @@ -2007,7 +2486,15 @@ static const uc_function_list_t conn_fns[] = { { "disconnect", uc_ubus_disconnect }, }; +static const uc_function_list_t chan_fns[] = { + { "request", uc_ubus_chan_request }, + { "defer", uc_ubus_chan_defer }, + { "error", uc_ubus_error }, + { "disconnect", uc_ubus_disconnect }, +}; + static const uc_function_list_t defer_fns[] = { + { "await", uc_ubus_defer_await }, { "completed", uc_ubus_defer_completed }, { "abort", uc_ubus_defer_abort }, }; @@ -2022,6 +2509,9 @@ static const uc_function_list_t request_fns[] = { { "reply", uc_ubus_request_reply }, { "error", uc_ubus_request_error }, { "defer", uc_ubus_request_defer }, + { "get_fd", uc_ubus_request_get_fd }, + { "set_fd", uc_ubus_request_set_fd }, + { "new_channel", uc_ubus_request_new_channel }, }; static const uc_function_list_t notify_fns[] = { @@ -2046,6 +2536,8 @@ static void free_connection(void *ud) { if (conn->ctx.sock.fd >= 0) ubus_shutdown(&conn->ctx); + if (conn->registry_index >= 0) + connection_reg_clear(conn->vm, conn->registry_index); free(conn); } @@ -2077,7 +2569,7 @@ static void free_object(void *ud) { static void free_request(void *ud) { uc_ubus_request_t *callctx = ud; - uc_ubus_request_finish(callctx, UBUS_STATUS_TIMEOUT, NULL); + uc_ubus_request_finish(callctx, UBUS_STATUS_TIMEOUT); uloop_timeout_cancel(&callctx->timeout); free(callctx); } @@ -2123,7 +2615,14 @@ void uc_module_init(uc_vm_t *vm, uc_value_t *scope) ADD_CONST(STATUS_SYSTEM_ERROR); #endif + /* virtual status code for reply */ +#define UBUS_STATUS_CONTINUE -1 + ADD_CONST(STATUS_CONTINUE); + + ADD_CONST(SYSTEM_OBJECT_ACL); + conn_type = uc_type_declare(vm, "ubus.connection", conn_fns, free_connection); + chan_type = uc_type_declare(vm, "ubus.channel", chan_fns, free_connection); defer_type = uc_type_declare(vm, "ubus.deferred", defer_fns, free_deferred); object_type = uc_type_declare(vm, "ubus.object", object_fns, free_object); notify_type = uc_type_declare(vm, "ubus.notify", notify_fns, free_notify); @@ -53,11 +53,15 @@ #include "ucode/module.h" -#define ok_return(expr) do { last_error = 0; return (expr); } while(0) -#define err_return(err) do { last_error = err; return NULL; } while(0) +#define ok_return(expr) do { \ + uc_vm_registry_delete(vm, "uci.error"); \ + return (expr); \ +} while(0) -static int last_error = 0; -static uc_resource_type_t *cursor_type; +#define err_return(err) do { \ + uc_vm_registry_set(vm, "uci.error", ucv_int64_new(err)); \ + return NULL; \ +} while(0) enum pkg_cmd { CMD_SAVE, @@ -86,6 +90,7 @@ enum pkg_cmd { static uc_value_t * uc_uci_error(uc_vm_t *vm, size_t nargs) { + int last_error = ucv_int64_get(uc_vm_registry_get(vm, "uci.error")); char buf[sizeof("Unknown error: -9223372036854775808")]; uc_value_t *errmsg; @@ -110,7 +115,7 @@ uc_uci_error(uc_vm_t *vm, size_t nargs) errmsg = ucv_string_new(buf); } - last_error = 0; + uc_vm_registry_delete(vm, "uci.error"); return errmsg; } @@ -146,6 +151,13 @@ uc_uci_error(uc_vm_t *vm, size_t nargs) * uncommitted application changes from the uci cli or other processes on the * system. * + * @param {string} [config2_dir=/var/run/uci] + * The directory to keep override config files in. Files are in the same format + * as in config_dir, but can individually override ones from that directory. + * It defaults to the uci configuration directory `/var/run/uci` but may be + * set to a different path for special purpose applications, or even disabled + * by setting this parameter to an empty string. + * * @returns {?module:uci.cursor} */ static uc_value_t * @@ -153,11 +165,13 @@ uc_uci_cursor(uc_vm_t *vm, size_t nargs) { uc_value_t *cdir = uc_fn_arg(0); uc_value_t *sdir = uc_fn_arg(1); + uc_value_t *c2dir = uc_fn_arg(2); struct uci_context *c; int rv; if ((cdir && ucv_type(cdir) != UC_STRING) || - (sdir && ucv_type(sdir) != UC_STRING)) + (sdir && ucv_type(sdir) != UC_STRING) || + (c2dir && ucv_type(c2dir) != UC_STRING)) err_return(UCI_ERR_INVAL); c = uci_alloc_context(); @@ -179,7 +193,16 @@ uc_uci_cursor(uc_vm_t *vm, size_t nargs) err_return(rv); } - ok_return(uc_resource_new(cursor_type, c)); +#ifdef HAVE_UCI_CONF2DIR + if (c2dir) { + rv = uci_set_conf2dir(c, ucv_string_get(c2dir)); + + if (rv) + err_return(rv); + } +#endif + + ok_return(ucv_resource_create(vm, "uci.cursor", c)); } @@ -191,7 +214,8 @@ uc_uci_cursor(uc_vm_t *vm, size_t nargs) * * Any changes made to configuration values are local to the cursor object and * held in memory only until they're written out to the filesystem using the - * `save()` and `commit()` methods. + * {@link module:uci.cursor#save|save()} and + * {@link module:uci.cursor#commit|commit()} methods. * * Changes performed in one cursor instance are not reflected in another, unless * the first instance writes those changes to the filesystem and the other @@ -1123,6 +1147,143 @@ uc_uci_delete(uc_vm_t *vm, size_t nargs) ok_return(ucv_boolean_new(true)); } +static uc_value_t * +uc_uci_list_modify(uc_vm_t *vm, size_t nargs, + int (*op)(struct uci_context *, struct uci_ptr *)) +{ + struct uci_context **c = uc_fn_this("uci.cursor"); + uc_value_t *conf = uc_fn_arg(0); + uc_value_t *sect = uc_fn_arg(1); + uc_value_t *opt = uc_fn_arg(2); + uc_value_t *val = uc_fn_arg(3); + struct uci_ptr ptr = { 0 }; + bool is_list; + int rv; + + if (ucv_type(conf) != UC_STRING || + ucv_type(sect) != UC_STRING || + ucv_type(opt) != UC_STRING) + err_return(UCI_ERR_INVAL); + + ptr.package = ucv_string_get(conf); + ptr.section = ucv_string_get(sect); + ptr.option = ucv_string_get(opt); + + rv = lookup_ptr(*c, &ptr, true); + + if (rv != UCI_OK) + err_return(rv); + + if (!ptr.s) + err_return(UCI_ERR_NOTFOUND); + + if (uval_to_uci(vm, val, &ptr.value, &is_list) && !is_list) + rv = op(*c, &ptr); + else + rv = UCI_ERR_INVAL; + + free((char *)ptr.value); + + if (rv != UCI_OK) + err_return(rv); + + ok_return(ucv_boolean_new(true)); +} + +/** + * Add an item to a list option in given configuration. + * + * Adds a single value to an existing list option within the specified section + * of the given configuration. The configuration is implicitly loaded into the + * cursor if not already present. + * + * The new value is appended to the end of the list, maintaining the existing order. + * No attempt is made to check for or remove duplicate values. + * + * Returns `true` if the item was successfully added to the list. + * + * Returns `null` on error, e.g. if the targeted option was not found or + * if an invalid value was passed. + * + * @function module:uci.cursor#list_append + * + * @param {string} config + * The name of the configuration file to modify, e.g. `"firewall"` to + * modify `/etc/config/firewall`. + * + * @param {string} section + * The section name containing the list option to modify. + * + * @param {string} option + * The list option name to add a value to. + * + * @param {string|boolean|number} value + * The value to add to the list option. + * + * @returns {?boolean} + * + * @example + * const ctx = cursor(…); + * + * // Add '192.168.1.1' to the 'dns' list in the 'lan' interface + * ctx.add_list('network', 'lan', 'dns', '192.168.1.1'); + * + * // Add a port to the first redirect section + * ctx.add_list('firewall', '@redirect[0]', 'src_dport', '8080'); + */ +static uc_value_t * +uc_uci_list_append(uc_vm_t *vm, size_t nargs) +{ + return uc_uci_list_modify(vm, nargs, uci_add_list); +} + +/** + * Remove an item from a list option in given configuration. + * + * Removes a single value from an existing list option within the specified section + * of the given configuration. The configuration is implicitly loaded into the + * cursor if not already present. + * + * If the specified value appears multiple times in the list, all matching occurrences + * will be removed. + * + * Returns `true` if the item was successfully removed from the list. + * + * Returns `null` on error, e.g. if the targeted option was not foundor if an + * invalid value was passed. + * + * @function module:uci.cursor#list_remove + * + * @param {string} config + * The name of the configuration file to modify, e.g. `"firewall"` to + * modify `/etc/config/firewall`. + * + * @param {string} section + * The section name containing the list option to modify. + * + * @param {string} option + * The list option name to remove a value from. + * + * @param {string|boolean|number} value + * The value to remove from the list option. + * + * @returns {?boolean} + * + * @example + * const ctx = cursor(…); + * + * // Remove '8.8.8.8' from the 'dns' list in the 'lan' interface + * ctx.delete_list('network', 'lan', 'dns', '8.8.8.8'); + * + * // Remove a port from the first redirect section + * ctx.delete_list('firewall', '@redirect[0]', 'src_dport', '8080'); + */ +static uc_value_t * +uc_uci_list_remove(uc_vm_t *vm, size_t nargs) +{ + return uc_uci_list_modify(vm, nargs, uci_del_list); +} + /** * Rename an option or section in given configuration. * @@ -1835,23 +1996,25 @@ uc_uci_configs(uc_vm_t *vm, size_t nargs) static const uc_function_list_t cursor_fns[] = { - { "load", uc_uci_load }, - { "unload", uc_uci_unload }, - { "get", uc_uci_get }, - { "get_all", uc_uci_get_all }, - { "get_first", uc_uci_get_first }, - { "add", uc_uci_add }, - { "set", uc_uci_set }, - { "rename", uc_uci_rename }, - { "save", uc_uci_save }, - { "delete", uc_uci_delete }, - { "commit", uc_uci_commit }, - { "revert", uc_uci_revert }, - { "reorder", uc_uci_reorder }, - { "changes", uc_uci_changes }, - { "foreach", uc_uci_foreach }, - { "configs", uc_uci_configs }, - { "error", uc_uci_error }, + { "load", uc_uci_load }, + { "unload", uc_uci_unload }, + { "get", uc_uci_get }, + { "get_all", uc_uci_get_all }, + { "get_first", uc_uci_get_first }, + { "add", uc_uci_add }, + { "set", uc_uci_set }, + { "rename", uc_uci_rename }, + { "save", uc_uci_save }, + { "delete", uc_uci_delete }, + { "list_append", uc_uci_list_append }, + { "list_remove", uc_uci_list_remove }, + { "commit", uc_uci_commit }, + { "revert", uc_uci_revert }, + { "reorder", uc_uci_reorder }, + { "changes", uc_uci_changes }, + { "foreach", uc_uci_foreach }, + { "configs", uc_uci_configs }, + { "error", uc_uci_error }, }; static const uc_function_list_t global_fns[] = { @@ -1868,5 +2031,5 @@ void uc_module_init(uc_vm_t *vm, uc_value_t *scope) { uc_function_list_register(scope, global_fns); - cursor_type = uc_type_declare(vm, "uci.cursor", cursor_fns, close_uci); + uc_type_declare(vm, "uci.cursor", cursor_fns, close_uci); } @@ -17,7 +17,7 @@ /** * # Zlib bindings * - * The `zlib` module provides single-call-oriented functions for interacting with zlib data. + * The `zlib` module provides single-call and stream-oriented functions for interacting with zlib data. * * @module zlib */ @@ -41,6 +41,16 @@ */ #define CHUNK 16384 +static uc_resource_type_t *zstrmd_type, *zstrmi_type; + +static int last_error = 0; +#define err_return(err) do { last_error = err; return NULL; } while(0) + +typedef struct { + z_stream strm; + uc_stringbuf_t *outbuf; + int flush; +} zstrm_t; /* zlib init error message */ static const char * ziniterr(int ret) @@ -68,24 +78,44 @@ static const char * ziniterr(int ret) return msg; } -static uc_stringbuf_t * -uc_zlib_def_object(uc_vm_t *vm, uc_value_t *obj, z_stream *strm) +static int +def_chunks(zstrm_t * const zstrm) +{ + int ret; + + /* run deflate() on input until output buffer not full */ + do { + printbuf_memset(zstrm->outbuf, printbuf_length(zstrm->outbuf) + CHUNK - 1, 0, 1); + zstrm->outbuf->bpos -= CHUNK; + + zstrm->strm.avail_out = CHUNK; + zstrm->strm.next_out = (unsigned char *)(zstrm->outbuf->buf + zstrm->outbuf->bpos); + + ret = deflate(&zstrm->strm, zstrm->flush); + assert(ret != Z_STREAM_ERROR); + + zstrm->outbuf->bpos += CHUNK - zstrm->strm.avail_out; + } while (zstrm->strm.avail_out == 0); + assert(zstrm->strm.avail_in == 0); // all input will be used + + return ret; +} + +static bool +uc_zlib_def_object(uc_vm_t *const vm, uc_value_t * const obj, zstrm_t * const zstrm) { int ret; bool eof = false; uc_value_t *rfn, *rbuf; - uc_stringbuf_t *buf = NULL; rfn = ucv_property_get(obj, "read"); if (!ucv_is_callable(rfn)) { uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Input object does not implement read() method"); - return NULL; + return false; } - buf = ucv_stringbuf_new(); - do { rbuf = NULL; uc_vm_stack_push(vm, ucv_get(obj)); @@ -107,65 +137,33 @@ uc_zlib_def_object(uc_vm_t *vm, uc_value_t *obj, z_stream *strm) /* check EOF */ eof = (rbuf == NULL || ucv_string_length(rbuf) == 0); - strm->next_in = (unsigned char *)ucv_string_get(rbuf); - strm->avail_in = ucv_string_length(rbuf); - - /* run deflate() on input until output buffer not full */ - do { - // enlarge buf by CHUNK amount as needed - printbuf_memset(buf, printbuf_length(buf) + CHUNK - 1, 0, 1); - buf->bpos -= CHUNK; - - strm->avail_out = CHUNK; - strm->next_out = (unsigned char *)(buf->buf + buf->bpos);; - - ret = deflate(strm, eof ? Z_FINISH : Z_NO_FLUSH); // no bad return value here - assert(ret != Z_STREAM_ERROR); // state never clobbered (would be mem corruption) - (void)ret; // XXX make annoying compiler that ignores assert() happy + zstrm->strm.next_in = (unsigned char *)ucv_string_get(rbuf); + zstrm->strm.avail_in = ucv_string_length(rbuf); - // update bpos past data written by deflate() - buf->bpos += CHUNK - strm->avail_out; - } while (strm->avail_out == 0); - assert(strm->avail_in == 0); // all input will be used + zstrm->flush = eof ? Z_FINISH : Z_NO_FLUSH; + ret = def_chunks(zstrm); + (void)ret; // XXX make annoying compiler that ignores assert() happy ucv_put(rbuf); // release rbuf } while (!eof); // finish compression if all of source has been read in assert(ret == Z_STREAM_END); // stream will be complete - return buf; + return true; fail: ucv_put(rbuf); - printbuf_free(buf); - return NULL; + return false; } -static uc_stringbuf_t * -uc_zlib_def_string(uc_vm_t *vm, uc_value_t *str, z_stream *strm) +static bool +uc_zlib_def_string(uc_vm_t * const vm, uc_value_t * const str, zstrm_t * const zstrm) { - int ret; - uc_stringbuf_t *buf = NULL; - - buf = ucv_stringbuf_new(); - - strm->next_in = (unsigned char *)ucv_string_get(str); - strm->avail_in = ucv_string_length(str); - - do { - printbuf_memset(buf, printbuf_length(buf) + CHUNK - 1, 0, 1); - buf->bpos -= CHUNK; - - strm->avail_out = CHUNK; - strm->next_out = (unsigned char *)(buf->buf + buf->bpos); - - ret = deflate(strm, Z_FINISH); - assert(ret != Z_STREAM_ERROR); + zstrm->strm.next_in = (unsigned char *)ucv_string_get(str); + zstrm->strm.avail_in = ucv_string_length(str); - buf->bpos += CHUNK - strm->avail_out; - } while (ret != Z_STREAM_END); - assert(strm->avail_in == 0); + last_error = def_chunks(zstrm); - return buf; + return true; } /** @@ -185,7 +183,7 @@ uc_zlib_def_string(uc_vm_t *vm, uc_value_t *str, z_stream *strm) * @function module:zlib#deflate * * @param {string} str_or_resource - * The string or resource object to be parsed as JSON. + * The string or resource object to be compressed. * * @param {?boolean} [gzip=false] * Add a gzip header if true (creates a gzip-compliant output, otherwise defaults to Zlib) @@ -203,19 +201,22 @@ uc_zlib_def_string(uc_vm_t *vm, uc_value_t *str, z_stream *strm) * const deflated = deflate(content, Z_BEST_SPEED); */ static uc_value_t * -uc_zlib_deflate(uc_vm_t *vm, size_t nargs) +uc_zlib_deflate(uc_vm_t * const vm, const size_t nargs) { uc_value_t *rv = NULL; uc_value_t *src = uc_fn_arg(0); uc_value_t *gzip = uc_fn_arg(1); uc_value_t *level = uc_fn_arg(2); - uc_stringbuf_t *buf = NULL; int ret, lvl = Z_DEFAULT_COMPRESSION; - bool gz = false; - z_stream strm = { - .zalloc = Z_NULL, - .zfree = Z_NULL, - .opaque = Z_NULL, + bool success, gz = false; + zstrm_t zstrm = { + .strm = { + .zalloc = Z_NULL, + .zfree = Z_NULL, + .opaque = Z_NULL, + }, + .outbuf = NULL, + .flush = Z_FINISH, }; if (gzip) { @@ -236,7 +237,7 @@ uc_zlib_deflate(uc_vm_t *vm, size_t nargs) lvl = (int)ucv_int64_get(level); } - ret = deflateInit2(&strm, lvl, + ret = deflateInit2(&zstrm.strm, lvl, Z_DEFLATED, // only allowed method gz ? 15+16 : 15, // 15 Zlib default, +16 for gzip 8, // default value @@ -246,15 +247,17 @@ uc_zlib_deflate(uc_vm_t *vm, size_t nargs) goto out; } + zstrm.outbuf = ucv_stringbuf_new(); + switch (ucv_type(src)) { case UC_STRING: - buf = uc_zlib_def_string(vm, src, &strm); + success = uc_zlib_def_string(vm, src, &zstrm); break; case UC_RESOURCE: case UC_OBJECT: case UC_ARRAY: - buf = uc_zlib_def_object(vm, src, &strm); + success = uc_zlib_def_object(vm, src, &zstrm); break; default: @@ -263,37 +266,63 @@ uc_zlib_deflate(uc_vm_t *vm, size_t nargs) goto out; } - if (!buf) { + if (!success) { if (vm->exception.type == EXCEPTION_NONE) // do not clobber previous exception - uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Zlib error: %s", strm.msg); + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Zlib error: %s", zstrm.strm.msg); + printbuf_free(zstrm.outbuf); goto out; } - rv = ucv_stringbuf_finish(buf); + rv = ucv_stringbuf_finish(zstrm.outbuf); out: - (void)deflateEnd(&strm); + (void)deflateEnd(&zstrm.strm); return rv; } -static uc_stringbuf_t * -uc_zlib_inf_object(uc_vm_t *vm, uc_value_t *obj, z_stream *strm) +static int +inf_chunks(zstrm_t * const zstrm) +{ + int ret; + + /* run inflate() on input until output buffer not full */ + do { + printbuf_memset(zstrm->outbuf, printbuf_length(zstrm->outbuf) + CHUNK - 1, 0, 1); + zstrm->outbuf->bpos -= CHUNK; + + zstrm->strm.avail_out = CHUNK; + zstrm->strm.next_out = (unsigned char *)(zstrm->outbuf->buf + zstrm->outbuf->bpos); + + ret = inflate(&zstrm->strm, zstrm->flush); + assert(ret != Z_STREAM_ERROR); + switch (ret) { + case Z_NEED_DICT: + case Z_DATA_ERROR: + case Z_MEM_ERROR: + return ret; + } + + zstrm->outbuf->bpos += CHUNK - zstrm->strm.avail_out; + } while (zstrm->strm.avail_out == 0); + + return ret; +} + +static bool +uc_zlib_inf_object(uc_vm_t *const vm, uc_value_t * const obj, zstrm_t * const zstrm) { int ret = Z_STREAM_ERROR; // error out if EOF on first loop bool eof = false; uc_value_t *rfn, *rbuf; - uc_stringbuf_t *buf = NULL; rfn = ucv_property_get(obj, "read"); if (!ucv_is_callable(rfn)) { uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Input object does not implement read() method"); - return NULL; + return false; } - buf = ucv_stringbuf_new(); - do { rbuf = NULL; uc_vm_stack_push(vm, ucv_get(obj)); @@ -317,80 +346,43 @@ uc_zlib_inf_object(uc_vm_t *vm, uc_value_t *obj, z_stream *strm) if (eof) break; - strm->next_in = (unsigned char *)ucv_string_get(rbuf); - strm->avail_in = ucv_string_length(rbuf); - - /* run deflate() on input until output buffer not full */ - do { - // enlarge buf by CHUNK amount as needed - printbuf_memset(buf, printbuf_length(buf) + CHUNK - 1, 0, 1); - buf->bpos -= CHUNK; - - strm->avail_out = CHUNK; - strm->next_out = (unsigned char *)(buf->buf + buf->bpos);; + zstrm->strm.next_in = (unsigned char *)ucv_string_get(rbuf); + zstrm->strm.avail_in = ucv_string_length(rbuf); - ret = inflate(strm, Z_NO_FLUSH); - assert(ret != Z_STREAM_ERROR); // state never clobbered (would be mem corruption) - switch (ret) { - case Z_NEED_DICT: - case Z_DATA_ERROR: - case Z_MEM_ERROR: - goto fail; - } - - // update bpos past data written by deflate() - buf->bpos += CHUNK - strm->avail_out; - } while (strm->avail_out == 0); + ret = inf_chunks(zstrm); + switch (ret) { + case Z_NEED_DICT: + case Z_DATA_ERROR: + case Z_MEM_ERROR: + goto fail; + } ucv_put(rbuf); // release rbuf } while (ret != Z_STREAM_END); // done when inflate() says it's done - if (ret != Z_STREAM_END) { // data error - printbuf_free(buf); - buf = NULL; - } + if (ret != Z_STREAM_END) // data error + return false; - return buf; + return true; fail: ucv_put(rbuf); - printbuf_free(buf); - return NULL; + return false; } -static uc_stringbuf_t * -uc_zlib_inf_string(uc_vm_t *vm, uc_value_t *str, z_stream *strm) +static bool +uc_zlib_inf_string(uc_vm_t * const vm, uc_value_t * const str, zstrm_t * const zstrm) { int ret; - uc_stringbuf_t *buf = NULL; - buf = ucv_stringbuf_new(); + zstrm->strm.next_in = (unsigned char *)ucv_string_get(str); + zstrm->strm.avail_in = ucv_string_length(str); - strm->next_in = (unsigned char *)ucv_string_get(str); - strm->avail_in = ucv_string_length(str); + ret = inf_chunks(zstrm); + assert(zstrm->strm.avail_in == 0); + last_error = ret; - do { - printbuf_memset(buf, printbuf_length(buf) + CHUNK - 1, 0, 1); - buf->bpos -= CHUNK; - - strm->avail_out = CHUNK; - strm->next_out = (unsigned char *)(buf->buf + buf->bpos); - - ret = inflate(strm, Z_FINISH); - assert(ret != Z_STREAM_ERROR); - switch (ret) { - case Z_NEED_DICT: - case Z_DATA_ERROR: - case Z_MEM_ERROR: - printbuf_free(buf); - return NULL; - } - - buf->bpos += CHUNK - strm->avail_out; - } while (ret != Z_STREAM_END); - assert(strm->avail_in == 0); - - return buf; + return Z_STREAM_END == ret; } /** @@ -415,36 +407,43 @@ uc_zlib_inf_string(uc_vm_t *vm, uc_value_t *str, z_stream *strm) * @returns {?string} */ static uc_value_t * -uc_zlib_inflate(uc_vm_t *vm, size_t nargs) +uc_zlib_inflate(uc_vm_t * const vm, const size_t nargs) { uc_value_t *rv = NULL; uc_value_t *src = uc_fn_arg(0); - uc_stringbuf_t *buf = NULL; + bool success; int ret; - z_stream strm = { - .zalloc = Z_NULL, - .zfree = Z_NULL, - .opaque = Z_NULL, - .avail_in = 0, // must be initialized before call to inflateInit - .next_in = Z_NULL, // must be initialized before call to inflateInit + zstrm_t zstrm = { + .strm = { + .zalloc = Z_NULL, + .zfree = Z_NULL, + .opaque = Z_NULL, + .avail_in = 0, // must be initialized before call to inflateInit + .next_in = Z_NULL, // must be initialized before call to inflateInit + }, + .outbuf = NULL, }; /* tell inflateInit2 to perform either zlib or gzip decompression: 15+32 */ - ret = inflateInit2(&strm, 15+32); + ret = inflateInit2(&zstrm.strm, 15+32); if (ret != Z_OK) { uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Zlib error: %s", ziniterr(ret)); goto out; } + zstrm.outbuf = ucv_stringbuf_new(); + switch (ucv_type(src)) { case UC_STRING: - buf = uc_zlib_inf_string(vm, src, &strm); + zstrm.flush = Z_FINISH; + success = uc_zlib_inf_string(vm, src, &zstrm); break; case UC_RESOURCE: case UC_OBJECT: case UC_ARRAY: - buf = uc_zlib_inf_object(vm, src, &strm); + zstrm.flush = Z_NO_FLUSH; + success = uc_zlib_inf_object(vm, src, &zstrm); break; default: @@ -453,28 +452,472 @@ uc_zlib_inflate(uc_vm_t *vm, size_t nargs) goto out; } - if (!buf) { + if (!success) { if (vm->exception.type == EXCEPTION_NONE) // do not clobber previous exception - uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Zlib error: %s", strm.msg); + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Zlib error: %s", zstrm.strm.msg); + printbuf_free(zstrm.outbuf); goto out; } - rv = ucv_stringbuf_finish(buf); + rv = ucv_stringbuf_finish(zstrm.outbuf); out: - (void)inflateEnd(&strm); + (void)inflateEnd(&zstrm.strm); return rv; } +/** + * Represents a handle for interacting with a deflate stream initiated by defnew(). + * + * @class module:zlib.zstrmd + * @hideconstructor + * + * @see {@link module:zlib#defnew()} + * + * @example + * + * const zstrmd = defnew(…); + * + * for (let data = ...; data; data = ...) { + * zstrmd.write(data, Z_PARTIAL_FLUSH); // write uncompressed data to stream + * if (foo) + * let defl = zstrmd.read(); // read back compressed stream content + * } + * + * // terminate the stream if needed (for e.g. file output) + * zstrmd.write('', Z_FINISH); + * defl = ztrmd.read(); + * + * zstrmd.error(); + */ + +/** + * Initializes a deflate stream. + * + * Returns a stream handle on success. + * + * Returns `null` if an error occurred. + * + * @function module:zlib#defnew + * + * @param {?boolean} [gzip=false] + * Add a gzip header if true (creates a gzip-compliant output, otherwise defaults to Zlib) + * + * @param {?number} [level=Z_DEFAULT_COMPRESSION] + * The compression level (0-9). + * + * @returns {?module:zlib.zstrmd} + * + * @example + * // initialize a Zlib deflate stream using default compression + * const zstrmd = defnew(); + * + * // initialize a gzip deflate stream using fastest compression + * const zstrmd = defnew(true, Z_BEST_SPEED); + */ + static uc_value_t * +uc_zlib_defnew(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *gzip = uc_fn_arg(0); + uc_value_t *level = uc_fn_arg(1); + int ret, lvl = Z_DEFAULT_COMPRESSION; + bool gz = false; + zstrm_t *zstrm; + + zstrm = calloc(1, sizeof(*zstrm)); + if (!zstrm) + err_return(ENOMEM); + + zstrm->strm.zalloc = Z_NULL; + zstrm->strm.zfree = Z_NULL; + zstrm->strm.opaque = Z_NULL; + + if (gzip) { + if (ucv_type(gzip) != UC_BOOLEAN) { + last_error = EINVAL; + goto fail; + } + + gz = (int)ucv_boolean_get(gzip); + } + + if (level) { + if (ucv_type(level) != UC_INTEGER) { + last_error = EINVAL; + goto fail; + } + + lvl = (int)ucv_int64_get(level); + } + + ret = deflateInit2(&zstrm->strm, lvl, + Z_DEFLATED, // only allowed method + gz ? 15+16 : 15, // 15 Zlib default, +16 for gzip + 8, // default value + Z_DEFAULT_STRATEGY); // default value + if (ret != Z_OK) { + last_error = ret; + goto fail; + } + + return uc_resource_new(zstrmd_type, zstrm); + +fail: + free(zstrm); + return NULL; +} + +/** + * Writes a chunk of data to the deflate stream. + * + * Input data must be a string, it is internally compressed by the zlib deflate() routine, + * the end is buffered according to the requested `flush` mode until read via + * @see {@link module:zlib.zstrmd#read}. + * If `flush` is `Z_FINISH` (the default) then no more data can be written to the stream. + * Valid `flush`values are `Z_NO_FLUSH, Z_SYNC_FLUSH, Z_PARTIAL_FLUSH, Z_FULL_FLUSH, Z_FINISH` + * + * Returns `true` on success. + * + * Returns `null` if an error occurred. + * + * @function module:zlib.zstrmd#write + * + * @param {string} src + * The string of data to deflate. + * + * @param {?number} [flush=Z_FINISH] + * The zlib flush mode. + * + * @returns {?boolean} + */ +static uc_value_t * +uc_zlib_defwrite(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *src = uc_fn_arg(0); + uc_value_t *flush = uc_fn_arg(1); + zstrm_t **z = uc_fn_this("zlib.strmd"); + zstrm_t *zstrm; + + if (!z || !*z) + err_return(EBADF); + + zstrm = *z; + + if (Z_FINISH == zstrm->flush) + err_return(EPIPE); // can't reuse a finished stream + + if (flush) { + if (ucv_type(flush) != UC_INTEGER) + err_return(EINVAL); + + zstrm->flush = (int)ucv_int64_get(flush); + switch (zstrm->flush) { + case Z_NO_FLUSH: + case Z_SYNC_FLUSH: + case Z_PARTIAL_FLUSH: + case Z_FULL_FLUSH: + case Z_FINISH: + break; + default: + err_return(EINVAL); + } + } + else + zstrm->flush = Z_FINISH; + + /* we only accept strings */ + if (!src || ucv_type(src) != UC_STRING) + err_return(EINVAL); + + if (!zstrm->outbuf) + zstrm->outbuf = ucv_stringbuf_new(); + + return ucv_boolean_new(uc_zlib_def_string(vm, src, zstrm)); +} + +/** + * Reads a chunk of compressed data from the deflate stream. + * + * Returns the current content of the deflate buffer, fed through + * @see {@link module:zlib.zstrmd#write}. + * + * Returns compressed chunk on success. + * + * Returns `null` if an error occurred. + * + * @function module:zlib.zstrmd#read + * + * @returns {?string} + */ +static uc_value_t * +uc_zlib_defread(uc_vm_t *vm, size_t nargs) +{ + zstrm_t **z = uc_fn_this("zlib.strmd"); + zstrm_t *zstrm; + uc_value_t *rv; + + if (!z || !*z) + err_return(EBADF); + + zstrm = *z; + + if (!zstrm->outbuf) + err_return(ENODATA); + + if (Z_FINISH == zstrm->flush) + (void)deflateEnd(&zstrm->strm); + + rv = ucv_stringbuf_finish(zstrm->outbuf); + zstrm->outbuf = NULL; // outbuf is now unuseable + return rv; +} + +/** + * Represents a handle for interacting with an inflate stream initiated by infnew(). + * + * @class module:zlib.zstrmi + * @hideconstructor + * + * @see {@link module:zlib#infnew()} + * + * @example + * + * const zstrmi = infnew(); + * + * for (let data = ...; data; data = ...) { + * zstrmi.write(data, Z_SYNC_FLUSH); // write compressed data to stream + * if (foo) + * let defl = zstrmi.read(); // read back decompressed stream content + * } + * + * // terminate the stream if needed (for e.g. file output) + * zstrmi.write('', Z_FINISH); + * defl = ztrmi.read(); + * + * zstrmi.error(); + */ + +/** + * Initializes an inflate stream. Can process either Zlib or gzip data. + * + * Returns a stream handle on success. + * + * Returns `null` if an error occurred. + * + * @function module:zlib#infnew + * + * @returns {?module:zlib.zstrmi} + * + * @example + * // initialize an inflate stream + * const zstrmi = infnew(); + */ + static uc_value_t * +uc_zlib_infnew(uc_vm_t *vm, size_t nargs) +{ + int ret; + zstrm_t *zstrm; + + zstrm = calloc(1, sizeof(*zstrm)); + if (!zstrm) + err_return(ENOMEM); + + zstrm->strm.zalloc = Z_NULL; + zstrm->strm.zfree = Z_NULL; + zstrm->strm.opaque = Z_NULL; + zstrm->strm.avail_in = 0; + zstrm->strm.next_in = Z_NULL; + + /* tell inflateInit2 to perform either zlib or gzip decompression: 15+32 */ + ret = inflateInit2(&zstrm->strm, 15+32); + if (ret != Z_OK) { + last_error = ret; + goto fail; + } + + return uc_resource_new(zstrmi_type, zstrm); + +fail: + free(zstrm); + return NULL; +} + +/** + * Writes a chunk of data to the inflate stream. + * + * Input data must be a string, it is internally decompressed by the zlib deflate() routine, + * the end is buffered according to the requested `flush` mode until read via + * @see {@link module:zlib.zstrmd#read}. + * If `flush` is `Z_FINISH` (the default) then no more data can be written to the stream. + * Valid `flush` values are `Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH` + * + * Returns `true` on success. + * + * Returns `null` if an error occurred. + * + * @function module:zlib.zstrmi#write + * + * @param {string} src + * The string of data to deflate. + * + * @param {?number} [flush=Z_FINISH] + * The zlib flush mode. + * + * @returns {?boolean} + */ +static uc_value_t * +uc_zlib_infwrite(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *src = uc_fn_arg(0); + uc_value_t *flush = uc_fn_arg(1); + zstrm_t **z = uc_fn_this("zlib.strmi"); + zstrm_t *zstrm; + + if (!z || !*z) + err_return(EBADF); + + zstrm = *z; + + if (Z_FINISH == zstrm->flush) + err_return(EPIPE); // can't reuse a finished stream + + if (flush) { + if (ucv_type(flush) != UC_INTEGER) + err_return(EINVAL); + + zstrm->flush = (int)ucv_int64_get(flush); + switch (zstrm->flush) { + case Z_NO_FLUSH: + case Z_SYNC_FLUSH: + case Z_FINISH: + break; + default: + err_return(EINVAL); + } + } + else + zstrm->flush = Z_FINISH; + + /* we only accept strings */ + if (!src || ucv_type(src) != UC_STRING) + err_return(EINVAL); + + if (!zstrm->outbuf) + zstrm->outbuf = ucv_stringbuf_new(); + + return ucv_boolean_new(uc_zlib_inf_string(vm, src, zstrm)); +} + +/** + * Reads a chunk of decompressed data from the inflate stream. + * + * Returns the current content of the inflate buffer, fed through + * @see {@link module:zlib.zstrmi#write}. + * + * Returns compressed chunk on success. + * + * Returns `null` if an error occurred. + * + * @function module:zlib.zstrmd#read + * + * @returns {?string} + */ +static uc_value_t * +uc_zlib_infread(uc_vm_t *vm, size_t nargs) +{ + zstrm_t **z = uc_fn_this("zlib.strmi"); + zstrm_t *zstrm; + uc_value_t *rv; + + if (!z || !*z) + err_return(EBADF); + + zstrm = *z; + + if (!zstrm->outbuf) + err_return(ENODATA); + + if (Z_FINISH == zstrm->flush) + (void)inflateEnd(&zstrm->strm); + + rv = ucv_stringbuf_finish(zstrm->outbuf); + zstrm->outbuf = NULL; // outbuf is now unuseable + return rv; +} + +/** + * Query error information. + * + * Returns a string containing a description of the last occurred error or + * `null` if there is no error information. + * + * @function module:zlib.zstrmd#error + * + * + * @returns {?string} + */ +static uc_value_t * +uc_zlib_error(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *errmsg; + + if (!last_error) + return NULL; + + // negative last_error only happens for zlib init returns + errmsg = ucv_string_new(last_error < 0 ? ziniterr(last_error) : strerror(last_error)); + last_error = 0; + return errmsg; +} + +static const uc_function_list_t strmd_fns[] = { + { "write", uc_zlib_defwrite }, + { "read", uc_zlib_defread }, + { "error", uc_zlib_error }, +}; + +static const uc_function_list_t strmi_fns[] = { + { "write", uc_zlib_infwrite }, + { "read", uc_zlib_infread }, + { "error", uc_zlib_error }, +}; + static const uc_function_list_t global_fns[] = { { "deflate", uc_zlib_deflate }, { "inflate", uc_zlib_inflate }, + { "defnew", uc_zlib_defnew }, + { "infnew", uc_zlib_infnew }, }; +static void destroy_zstrmd(void *z) +{ + zstrm_t *zstrm = z; + + if (zstrm) { + (void)deflateEnd(&zstrm->strm); + printbuf_free(zstrm->outbuf); + free(zstrm); + } +} + +static void destroy_zstrmi(void *z) +{ + zstrm_t *zstrm = z; + + if (zstrm) { + (void)inflateEnd(&zstrm->strm); + printbuf_free(zstrm->outbuf); + free(zstrm); + } +} + void uc_module_init(uc_vm_t *vm, uc_value_t *scope) { uc_function_list_register(scope, global_fns); + zstrmd_type = uc_type_declare(vm, "zlib.strmd", strmd_fns, destroy_zstrmd); + zstrmi_type = uc_type_declare(vm, "zlib.strmi", strmi_fns, destroy_zstrmi); + #define ADD_CONST(x) ucv_object_add(scope, #x, ucv_int64_new(x)) /** @@ -490,4 +933,20 @@ void uc_module_init(uc_vm_t *vm, uc_value_t *scope) ADD_CONST(Z_BEST_SPEED); ADD_CONST(Z_BEST_COMPRESSION); ADD_CONST(Z_DEFAULT_COMPRESSION); + + /** + * @typedef + * @name flush options + * @description Constants representing flush options. + * @property {number} Z_NO_FLUSH. + * @property {number} Z_PARTIAL_FLUSH. + * @property {number} Z_SYNC_FLUSH. + * @property {number} Z_FULL_FLUSH. + * @property {number} Z_FINISH. + */ + ADD_CONST(Z_NO_FLUSH); + ADD_CONST(Z_PARTIAL_FLUSH); + ADD_CONST(Z_SYNC_FLUSH); + ADD_CONST(Z_FULL_FLUSH); + ADD_CONST(Z_FINISH); } @@ -145,11 +145,16 @@ compile(uc_vm_t *vm, uc_source_t *src, FILE *precompile, bool strip, char *inter switch (rc) { case STATUS_OK: if (print_result) { - uc_vm_stack_push(vm, res); - uc_vm_stack_push(vm, ucv_string_new("\n")); - uc_stdlib_function("print")(vm, 2); - uc_vm_stack_pop(vm); - uc_vm_stack_pop(vm); + if (ucv_type(res) == UC_STRING) { + fwrite(ucv_string_get(res), ucv_string_length(res), 1, stdout); + } + else { + uc_stringbuf_t *pb = xprintbuf_new(); + + ucv_to_stringbuf_formatted(vm, pb, res, 0, '\t', 1); + fwrite(pb->buf, pb->bpos, 1, stdout); + printbuf_free(pb); + } } rc = 0; @@ -501,6 +506,7 @@ main(int argc, char **argv) FILE *precompile = NULL; char *outfile = NULL; uc_vm_t vm = { 0 }; + const char *argv0; int opt, rv = 0; const char *app; uc_value_t *o; @@ -553,6 +559,7 @@ main(int argc, char **argv) uc_search_path_init(&config.module_search_path); + argv0 = argv[optind]; optind = 1; uc_vm_init(&vm, &config); @@ -564,6 +571,8 @@ main(int argc, char **argv) o = ucv_array_new(&vm); ucv_object_add(uc_vm_scope_get(&vm), "ARGV", ucv_get(o)); + if (argv0) + ucv_object_add(uc_vm_scope_get(&vm), "SCRIPT_NAME", ucv_string_new(argv0)); /* parse options iteration 2: process remaining options */ while ((opt = getopt(argc, argv, optspec)) != -1) @@ -157,10 +157,7 @@ uc_source_type_test(uc_source_t *source) void uc_source_line_next(uc_source_t *source) { - uc_lineinfo_t *lines = &source->lineinfo; - - uc_vector_grow(lines); - lines->entries[lines->count++] = 0x80; + uc_vector_push(&source->lineinfo, 0x80); } void @@ -183,11 +180,8 @@ uc_source_line_update(uc_source_t *source, size_t off) while (off > 0) { n = (off > 0x7f) ? 0x7f : off; - uc_vector_grow(lines); - entry = uc_vector_last(lines); - entry[1] = n; + uc_vector_push(lines, n); off -= n; - lines->count++; } } } diff --git a/tests/custom/03_stdlib/40_proto b/tests/custom/03_stdlib/40_proto index d96d124..0f65910 100644 --- a/tests/custom/03_stdlib/40_proto +++ b/tests/custom/03_stdlib/40_proto @@ -38,6 +38,7 @@ When invoked with two arguments, returns the given value. Hello, World! [ { + "ioctl": "function ioctl(...) { [native code] }", "lock": "function lock(...) { [native code] }", "truncate": "function truncate(...) { [native code] }", "isatty": "function isatty(...) { [native code] }", diff --git a/tests/custom/99_bugs/46_getenv_destroys_environ b/tests/custom/99_bugs/46_getenv_destroys_environ new file mode 100644 index 0000000..1879dee --- /dev/null +++ b/tests/custom/99_bugs/46_getenv_destroys_environ @@ -0,0 +1,13 @@ +A call to getenv() without parameters destroys environ, and subsequent calls +to getenv() (with or without parameter) return nothing. + +-- Testcase -- +{% + getenv(); + print(length(getenv()) > 0, '\n'); +%} +-- End -- + +-- Expect stdout -- +true +-- End -- diff --git a/tests/custom/99_bugs/47_compiler_no_prop_kw_after_spread b/tests/custom/99_bugs/47_compiler_no_prop_kw_after_spread new file mode 100644 index 0000000..26f1bff --- /dev/null +++ b/tests/custom/99_bugs/47_compiler_no_prop_kw_after_spread @@ -0,0 +1,17 @@ +Ensure that unquoted property names following spread expressions in object +declaration literals are not treated as keywords. + +-- Testcase -- +{% +printf("%.J\n", { + ...{}, + for: true +}); +%} +-- End -- + +-- Expect stdout -- +{ + "for": true +} +-- End -- diff --git a/tests/custom/99_bugs/48_use_after_free_on_iteration_insert b/tests/custom/99_bugs/48_use_after_free_on_iteration_insert new file mode 100644 index 0000000..558f83a --- /dev/null +++ b/tests/custom/99_bugs/48_use_after_free_on_iteration_insert @@ -0,0 +1,40 @@ +Ensure that adding keys to an object currently being iterated will not +clobber active iterators pointing into that object due to a reallocation +of the underlying hash table array. + +-- Testcase -- +{% + let obj = { '0': 0, '1': 1 }; + let i = 2; + + for (let k, v in obj) { + while (i < 16) { + obj[i] = i; + i++; + } + } + + printf("%.J\n", obj); +%} +-- End -- + +-- Expect stdout -- +{ + "0": 0, + "1": 1, + "2": 2, + "3": 3, + "4": 4, + "5": 5, + "6": 6, + "7": 7, + "8": 8, + "9": 9, + "10": 10, + "11": 11, + "12": 12, + "13": 13, + "14": 14, + "15": 15 +} +-- End -- diff --git a/tests/custom/99_bugs/49_trailing_garbage_string_as_number b/tests/custom/99_bugs/49_trailing_garbage_string_as_number new file mode 100644 index 0000000..1b48146 --- /dev/null +++ b/tests/custom/99_bugs/49_trailing_garbage_string_as_number @@ -0,0 +1,23 @@ +Ensure that numeric strings followed by non-whitespace are treated as NaN. + +-- Testcase -- +{% +printf("%.J\n", [ + "1" == 1, + " 1" == 1, + "1 " == 1, + "1a" == 1, + "1 a" == 1 +]); +%} +-- End -- + +-- Expect stdout -- +[ + true, + true, + true, + false, + false +] +-- End -- diff --git a/tests/custom/99_bugs/50_missing_upvalue_resolving b/tests/custom/99_bugs/50_missing_upvalue_resolving new file mode 100644 index 0000000..5e96634 --- /dev/null +++ b/tests/custom/99_bugs/50_missing_upvalue_resolving @@ -0,0 +1,27 @@ +Commit e5fe6b1 ("treewide: refactor vector usage code") accidentially dropped +the upvalue resolving logic from uc_vm_stack_push(), leading to unresolved +upvalues leaking into the script execution context. + +-- File test.uc -- +export let obj = { foo: true, bar: false }; +-- End -- + +-- Testcase -- +import * as test from "./files/test.uc"; + +printf("%.J\n", [ + type(test.obj), + test.obj.foo +]); +-- End -- + +-- Args -- +-R +-- End -- + +-- Expect stdout -- +[ + "object", + true +] +-- End -- diff --git a/tests/custom/99_bugs/51_preserve_lexer_flags b/tests/custom/99_bugs/51_preserve_lexer_flags new file mode 100644 index 0000000..aba646c --- /dev/null +++ b/tests/custom/99_bugs/51_preserve_lexer_flags @@ -0,0 +1,20 @@ +Ensure keyword and regexp flags are preserved across comments when lexing +object literals and division operators. + +-- Testcase -- +{% + printf("%.J\n", [ + { /* comment */ default: true }, + 4 /* comment */ /2/1 + ]); +%} +-- End -- + +-- Expect stdout -- +[ + { + "default": true + }, + 2 +] +-- End -- @@ -29,11 +29,6 @@ #include "ucode/vm.h" #include "ucode/program.h" -uc_list_t uc_object_iterators = { - .prev = &uc_object_iterators, - .next = &uc_object_iterators -}; - static char *uc_default_search_path[] = { LIB_SEARCH_PATH }; uc_parse_config_t uc_default_parse_config = { @@ -705,17 +700,13 @@ ucv_array_new_length(uc_vm_t *vm, size_t length) { uc_array_t *array; - /* XXX */ - length = 0; - - array = xalloc(sizeof(*array) + length * sizeof(array->entries[0])); + array = xalloc(sizeof(*array)); array->header.type = UC_ARRAY; array->header.refcount = 1; - if (length > 0) - array->count = length; - - uc_vector_grow(array); + /* preallocate memory */ + if (length) + uc_vector_extend(array, length); if (vm) { ucv_ref(&vm->values, &array->ref); @@ -779,10 +770,9 @@ ucv_array_unshift(uc_value_t *uv, uc_value_t *item) if (ucv_type(uv) != UC_ARRAY) return NULL; - array->count++; - uc_vector_grow(array); + uc_vector_extend(array, 1); - for (i = array->count; i > 1; i--) + for (i = ++array->count; i > 1; i--) array->entries[i - 1] = array->entries[i - 2]; array->entries[0] = item; @@ -790,6 +780,28 @@ ucv_array_unshift(uc_value_t *uv, uc_value_t *item) return item; } +typedef struct { + int (*cmp)(uc_value_t *, uc_value_t *, void *); + void *ud; +} array_sort_ctx_t; + +static uc_vector_sort_cb(ucv_array_sort_r_cb, uc_value_t *, array_sort_ctx_t *, { + return ctx->cmp(v1, v2, ctx->ud); +}); + +void +ucv_array_sort_r(uc_value_t *uv, + int (*cmp)(uc_value_t *, uc_value_t *, void *), void *ud) +{ + array_sort_ctx_t ctx = { .cmp = cmp, .ud = ud }; + uc_array_t *array = (uc_array_t *)uv; + + if (ucv_type(uv) != UC_ARRAY || array->count <= 1) + return; + + uc_vector_sort(array, ucv_array_sort_r_cb, &ctx); +} + void ucv_array_sort(uc_value_t *uv, int (*cmp)(const void *, const void *)) { @@ -826,10 +838,9 @@ ucv_array_delete(uc_value_t *uv, size_t offset, size_t count) &array->entries[offset + count], (array->count - (offset + count)) * sizeof(array->entries[0])); + uc_vector_reduce(array, count); array->count -= count; - uc_vector_grow(array); - return true; } @@ -837,24 +848,13 @@ bool ucv_array_set(uc_value_t *uv, size_t index, uc_value_t *item) { uc_array_t *array = (uc_array_t *)uv; - size_t old_count, new_count; if (ucv_type(uv) != UC_ARRAY) return false; if (index >= array->count) { - old_count = array->count; - new_count = (index + 1) & ~(UC_VECTOR_CHUNK_SIZE - 1); - - if (new_count > old_count) { - array->count = new_count; - uc_vector_grow(array); - } - + uc_vector_extend(array, index + 1 - array->count); array->count = index + 1; - - while (old_count < array->count) - array->entries[old_count++] = NULL; } else { ucv_put(array->entries[index]); @@ -893,11 +893,11 @@ ucv_array_length(uc_value_t *uv) static void ucv_free_object_entry(struct lh_entry *entry) { - uc_list_foreach(item, &uc_object_iterators) { + uc_list_foreach(item, &uc_thread_context_get()->object_iterators) { uc_object_iterator_t *iter = (uc_object_iterator_t *)item; - if (iter->pos == entry) - iter->pos = entry->next; + if (iter->u.pos == entry) + iter->u.pos = entry->next; } free(lh_entry_k(entry)); @@ -946,6 +946,24 @@ ucv_object_add(uc_value_t *uv, const char *key, uc_value_t *val) existing_entry = lh_table_lookup_entry_w_hash(object->table, (const void *)key, hash); if (existing_entry == NULL) { + bool rehash = (object->table->count >= object->table->size * LH_LOAD_FACTOR); + + /* insert will rehash table, backup affected iterator states */ + if (rehash) { + uc_list_foreach(item, &uc_thread_context_get()->object_iterators) { + uc_object_iterator_t *iter = (uc_object_iterator_t *)item; + + if (iter->table != object->table) + continue; + + if (iter->u.pos == NULL) + continue; + + iter->u.kh.k = iter->u.pos->k; + iter->u.kh.hash = lh_get_hash(iter->table, iter->u.kh.k); + } + } + k = xstrdup(key); if (lh_table_insert_w_hash(object->table, k, val, hash, 0) != 0) { @@ -954,6 +972,23 @@ ucv_object_add(uc_value_t *uv, const char *key, uc_value_t *val) return false; } + /* restore affected iterator state pointer after rehash */ + if (rehash) { + uc_list_foreach(item, &uc_thread_context_get()->object_iterators) { + uc_object_iterator_t *iter = (uc_object_iterator_t *)item; + + if (iter->table != object->table) + continue; + + if (iter->u.kh.k == NULL) + continue; + + iter->u.pos = lh_table_lookup_entry_w_hash(iter->table, + iter->u.kh.k, + iter->u.kh.hash); + } + } + return true; } @@ -967,8 +1002,29 @@ ucv_object_add(uc_value_t *uv, const char *key, uc_value_t *val) return true; } -void -ucv_object_sort(uc_value_t *uv, int (*cmp)(const void *, const void *)) + +typedef struct { + int (*cmp)(const void *, const void *); + int (*cmpr)(const char *, uc_value_t *, const char *, uc_value_t *, void *); + void *ud; +} object_sort_ctx_t; + +static uc_vector_sort_cb(ucv_object_sort_cb, const void *, object_sort_ctx_t *, { + (void)v1; + (void)v2; + + return ctx->cmp(k1, k2); +}); + +static uc_vector_sort_cb(ucv_object_sort_r_cb, const struct lh_entry *, object_sort_ctx_t *, { + return ctx->cmpr( + v1 ? lh_entry_k(v1) : NULL, v1 ? lh_entry_v(v1) : NULL, + v2 ? lh_entry_k(v2) : NULL, v2 ? lh_entry_v(v2) : NULL, + ctx->ud); +}); + +static void +ucv_object_sort_common(uc_value_t *uv, object_sort_ctx_t *ctx) { uc_object_t *object = (uc_object_t *)uv; struct lh_table *t; @@ -989,7 +1045,8 @@ ucv_object_sort(uc_value_t *uv, int (*cmp)(const void *, const void *)) if (!keys.entries) return; - qsort(keys.entries, keys.count, sizeof(keys.entries[0]), cmp); + uc_vector_sort(&keys, + ctx->cmpr ? ucv_object_sort_r_cb : ucv_object_sort_cb, ctx); for (i = 0; i < keys.count; i++) { e = keys.entries[i]; @@ -1009,6 +1066,25 @@ ucv_object_sort(uc_value_t *uv, int (*cmp)(const void *, const void *)) uc_vector_clear(&keys); } +void +ucv_object_sort_r(uc_value_t *uv, + int (*cmp)(const char *, uc_value_t *, + const char *, uc_value_t *, void *), + void *ud) +{ + object_sort_ctx_t ctx = { .cmp = NULL, .cmpr = cmp, .ud = ud }; + + ucv_object_sort_common(uv, &ctx); +} + +void +ucv_object_sort(uc_value_t *uv, int (*cmp)(const void *, const void *)) +{ + object_sort_ctx_t ctx = { .cmp = cmp, .cmpr = NULL, .ud = NULL }; + + ucv_object_sort_common(uv, &ctx); +} + bool ucv_object_delete(uc_value_t *uv, const char *key) { @@ -1116,8 +1192,7 @@ ucv_resource_type_add(uc_vm_t *vm, const char *name, uc_value_t *proto, void (*f type->proto = proto; type->free = freefn; - uc_vector_grow(&vm->restypes); - vm->restypes.entries[vm->restypes.count++] = type; + uc_vector_push(&vm->restypes, type); return type; } @@ -2220,8 +2295,9 @@ uc_value_t * ucv_key_get(uc_vm_t *vm, uc_value_t *scope, uc_value_t *key) { uc_value_t *o, *v = NULL; + bool found = false; + uc_upvalref_t *ref; int64_t idx; - bool found; char *k; if (ucv_type(scope) == UC_ARRAY) { @@ -2230,23 +2306,48 @@ ucv_key_get(uc_vm_t *vm, uc_value_t *scope, uc_value_t *key) if (idx < 0 && idx > INT64_MIN && (uint64_t)llabs(idx) <= ucv_array_length(scope)) idx += ucv_array_length(scope); - if (idx >= 0 && (uint64_t)idx < ucv_array_length(scope)) - return ucv_get(ucv_array_get(scope, idx)); + if (idx >= 0 && (uint64_t)idx < ucv_array_length(scope)) { + v = ucv_array_get(scope, idx); + found = true; + } } - k = ucv_key_to_string(vm, key); + if (!found) { + k = ucv_key_to_string(vm, key); - for (o = scope; o; o = ucv_prototype_get(o)) { - if (ucv_type(o) != UC_OBJECT) - continue; + for (o = scope; o; o = ucv_prototype_get(o)) { + if (ucv_type(o) != UC_OBJECT) + continue; - v = ucv_object_get(o, k ? k : ucv_string_get(key), &found); + v = ucv_object_get(o, k ? k : ucv_string_get(key), &found); - if (found) - break; + if (found) + break; + } + + free(k); } - free(k); + /* Handle upvalue values in objects; under some specific circumstances + objects may contain upvalues, this primarily happens with wildcard module + import namespace dictionaries. */ +#ifdef __clang_analyzer__ + /* Clang static analyzer does not understand that ucv_type(NULL) can't + * possibly yield UC_UPVALUE. Nudge it. */ + if (v != NULL && ucv_type(v) == UC_UPVALUE) +#else + if (ucv_type(v) == UC_UPVALUE) +#endif + { + ref = (uc_upvalref_t *)v; + + if (ref->closed) + return ucv_get(ref->value); + else if (vm) + return ucv_get(vm->stack.entries[ref->slot]); + else + return NULL; + } return ucv_get(v); } @@ -2375,3 +2476,18 @@ uc_search_path_init(uc_search_path_t *search_path) for (i = 0; i < ARRAY_SIZE(uc_default_search_path); i++) uc_vector_push(search_path, xstrdup(uc_default_search_path[i])); } + + +static __thread uc_thread_context_t *tls_ctx; + +uc_thread_context_t * +uc_thread_context_get(void) +{ + if (tls_ctx == NULL) { + tls_ctx = xalloc(sizeof(*tls_ctx)); + tls_ctx->object_iterators.prev = &tls_ctx->object_iterators; + tls_ctx->object_iterators.next = &tls_ctx->object_iterators; + } + + return tls_ctx; +} @@ -106,7 +106,10 @@ uc_number_parse_common(const char *buf, bool octal, char **end) if (base >= 10 && (**end == '.' || (**end|32) == 'e')) { d = strtod(p, end); - if (!isspace(**end) && **end != 0) + while (isspace(**end)) + (*end)++; + + if (**end != 0) return NULL; if (neg) @@ -115,7 +118,10 @@ uc_number_parse_common(const char *buf, bool octal, char **end) return ucv_double_new(d); } - if (!isspace(**end) && **end != 0) + while (isspace(**end)) + (*end)++; + + if (**end != 0) return NULL; if (neg) { @@ -145,19 +145,21 @@ uc_vm_alloc_global_scope(uc_vm_t *vm) static void uc_vm_output_exception(uc_vm_t *vm, uc_exception_t *ex); -static uc_vm_t *signal_handler_vm; - static void uc_vm_signal_handler(int sig) { - assert(signal_handler_vm); + uc_vm_t *vm = uc_thread_context_get()->signal_handler_vm; + + assert(vm); - uc_vm_signal_raise(signal_handler_vm, sig); + uc_vm_signal_raise(vm, sig); } static void uc_vm_signal_handlers_setup(uc_vm_t *vm) { + uc_thread_context_t *tctx; + memset(&vm->signal, 0, sizeof(vm->signal)); vm->signal.sigpipe[0] = -1; @@ -166,16 +168,48 @@ uc_vm_signal_handlers_setup(uc_vm_t *vm) if (!vm->config->setup_signal_handlers) return; - if (pipe2(vm->signal.sigpipe, O_CLOEXEC | O_NONBLOCK) != 0) + tctx = uc_thread_context_get(); + + if (tctx->signal_handler_vm) return; - signal_handler_vm = vm; + if (pipe2(vm->signal.sigpipe, O_CLOEXEC | O_NONBLOCK) != 0) + return; vm->signal.handler = ucv_array_new_length(vm, UC_SYSTEM_SIGNAL_COUNT); vm->signal.sa.sa_handler = uc_vm_signal_handler; vm->signal.sa.sa_flags = SA_RESTART | SA_ONSTACK; sigemptyset(&vm->signal.sa.sa_mask); + + tctx->signal_handler_vm = vm; +} + +static void +uc_vm_signal_handlers_reset(uc_vm_t *vm) +{ + uc_thread_context_t *tctx = uc_thread_context_get(); + struct sigaction sa = { 0 }; + size_t i, signo; + + if (vm != tctx->signal_handler_vm) + return; + + sa.sa_handler = SIG_DFL; + sigemptyset(&sa.sa_mask); + + for (signo = 0; signo < ucv_array_length(vm->signal.handler); signo++) + if (ucv_is_callable(ucv_array_get(vm->signal.handler, signo))) + sigaction(signo, &sa, NULL); + + for (i = 0; i < ARRAY_SIZE(vm->signal.sigpipe); i++) { + if (vm->signal.sigpipe[i] > STDERR_FILENO) + close(vm->signal.sigpipe[i]); + + vm->signal.sigpipe[i] = -1; + } + + tctx->signal_handler_vm = NULL; } void uc_vm_init(uc_vm_t *vm, uc_parse_config_t *config) @@ -210,6 +244,8 @@ void uc_vm_free(uc_vm_t *vm) uc_upvalref_t *ref; size_t i; + uc_vm_signal_handlers_reset(vm); + ucv_put(vm->exception.stacktrace); free(vm->exception.message); @@ -431,11 +467,7 @@ uc_vm_resolve_upval(uc_vm_t *vm, uc_value_t *value) void uc_vm_stack_push(uc_vm_t *vm, uc_value_t *value) { - uc_vector_grow(&vm->stack); - - ucv_put(vm->stack.entries[vm->stack.count]); - vm->stack.entries[vm->stack.count] = uc_vm_resolve_upval(vm, value); - vm->stack.count++; + uc_vector_push(&vm->stack, uc_vm_resolve_upval(vm, value)); if (vm->trace) { fprintf(stderr, " [+%zd] %s\n", @@ -488,14 +520,13 @@ uc_vm_call_native(uc_vm_t *vm, uc_value_t *ctx, uc_cfunction_t *fptr, bool mcall uc_callframe_t *frame; /* add new callframe */ - uc_vector_grow(&vm->callframes); - - frame = &vm->callframes.entries[vm->callframes.count++]; - frame->stackframe = vm->stack.count - nargs - 1; - frame->cfunction = fptr; - frame->closure = NULL; - frame->ctx = ctx; - frame->mcall = mcall; + frame = uc_vector_push(&vm->callframes, { + .stackframe = vm->stack.count - nargs - 1, + .cfunction = fptr, + .closure = NULL, + .ctx = ctx, + .mcall = mcall + }); if (vm->trace) uc_vm_frame_dump(vm, frame); @@ -641,16 +672,15 @@ uc_vm_call_function(uc_vm_t *vm, uc_value_t *ctx, uc_value_t *fno, bool mcall, s } } - uc_vector_grow(&vm->callframes); - - frame = &vm->callframes.entries[vm->callframes.count++]; - frame->stackframe = stackoff; - frame->cfunction = NULL; - frame->closure = closure; - frame->ctx = ctx; - frame->ip = function->chunk.entries; - frame->mcall = mcall; - frame->strict = function->strict; + frame = uc_vector_push(&vm->callframes, { + .stackframe = stackoff, + .cfunction = NULL, + .closure = closure, + .ctx = ctx, + .ip = function->chunk.entries, + .mcall = mcall, + .strict = function->strict + }); if (vm->trace) uc_vm_frame_dump(vm, frame); @@ -784,11 +814,10 @@ uc_vm_exception_tostring(uc_vm_t *vm, size_t nargs) return message ? ucv_get(message) : ucv_string_new("Exception"); } -static uc_value_t *exception_prototype = NULL; - static uc_value_t * uc_vm_exception_new(uc_vm_t *vm, uc_exception_type_t type, const char *message, uc_value_t *stacktrace) { + uc_value_t *exception_prototype = uc_vm_registry_get(vm, "vm.exception.proto"); uc_value_t *exo; if (exception_prototype == NULL) { @@ -796,6 +825,8 @@ uc_vm_exception_new(uc_vm_t *vm, uc_exception_type_t type, const char *message, ucv_object_add(exception_prototype, "tostring", ucv_cfunction_new("tostring", uc_vm_exception_tostring)); + + uc_vm_registry_set(vm, "vm.exception.proto", exception_prototype); } exo = ucv_object_new(vm); @@ -2225,9 +2256,10 @@ uc_vm_object_iterator_next(uc_vm_t *vm, uc_vm_insn_t insn, res->type = &uc_vm_object_iterator_type; iter = res->data = (char *)res + sizeof(*res); - iter->pos = obj->table->head; + iter->table = obj->table; + iter->u.pos = obj->table->head; - uc_list_insert(&uc_object_iterators, &iter->list); + uc_list_insert(&uc_thread_context_get()->object_iterators, &iter->list); } else if (ucv_type(k) == UC_RESOURCE && res->type == &uc_vm_object_iterator_type && res->data != NULL) { @@ -2241,21 +2273,21 @@ uc_vm_object_iterator_next(uc_vm_t *vm, uc_vm_insn_t insn, } /* no next key */ - if (!iter->pos) { + if (!iter->u.pos) { uc_list_remove(&iter->list); return false; } - uc_vm_stack_push(vm, ucv_string_new(iter->pos->k)); + uc_vm_stack_push(vm, ucv_string_new(iter->u.pos->k)); if (insn == I_NEXTKV) - uc_vm_stack_push(vm, ucv_get((uc_value_t *)iter->pos->v)); + uc_vm_stack_push(vm, ucv_get((uc_value_t *)iter->u.pos->v)); uc_vm_stack_push(vm, &res->header); ucv_put(v); - iter->pos = iter->pos->next; + iter->u.pos = iter->u.pos->next; return true; } @@ -2739,14 +2771,20 @@ uc_vm_signal_dispatch(uc_vm_t *vm) static uc_vm_status_t uc_vm_execute_chunk(uc_vm_t *vm) { - uc_callframe_t *frame = uc_vm_current_frame(vm); - uc_chunk_t *chunk = uc_vm_frame_chunk(frame); + uc_callframe_t *frame = NULL; + uc_chunk_t *chunk = NULL; size_t caller = vm->callframes.count - 1; uc_value_t *retval; uc_vm_insn_t insn; uint8_t *ip; - while (chunk && vm->callframes.count > caller) { + while (vm->callframes.count > caller) { + frame = &vm->callframes.entries[vm->callframes.count - 1]; + chunk = uc_vm_frame_chunk(frame); + + if (!chunk) + break; + if (vm->trace) { ip = frame->ip; insn = uc_vm_decode_insn(vm, frame, chunk); @@ -2936,15 +2974,11 @@ uc_vm_execute_chunk(uc_vm_t *vm) case I_CALL: case I_QCALL: uc_vm_insn_call(vm, insn); - frame = uc_vm_current_frame(vm); - chunk = frame->closure ? uc_vm_frame_chunk(frame) : NULL; break; case I_MCALL: case I_QMCALL: uc_vm_insn_mcall(vm, insn); - frame = uc_vm_current_frame(vm); - chunk = frame->closure ? uc_vm_frame_chunk(frame) : NULL; break; case I_RETURN: @@ -2954,9 +2988,6 @@ uc_vm_execute_chunk(uc_vm_t *vm) if (vm->callframes.count == 0) return STATUS_OK; - - frame = uc_vector_last(&vm->callframes); - chunk = uc_vm_frame_chunk(frame); break; case I_PRINT: @@ -2996,21 +3027,20 @@ exception: /* walk up callframes until something handles the exception or the original caller is reached */ while (!uc_vm_handle_exception(vm)) { + /* no further callframe, report unhandled exception and terminate */ + if (vm->callframes.count == 0) + return ERROR_RUNTIME; + /* if VM returned into native function, don't bubble up */ - if (!chunk) + if (!vm->callframes.entries[vm->callframes.count - 1].closure) return ERROR_RUNTIME; /* no exception handler in current function, pop callframe */ - if (vm->callframes.count > 0) - ucv_put(uc_vm_callframe_pop(vm)); + ucv_put(uc_vm_callframe_pop(vm)); - /* no further callframe, report unhandled exception and terminate */ - if (vm->callframes.count == 0 || vm->callframes.count <= caller) + /* do not bubble past original call depth */ + if (vm->callframes.count <= caller) return ERROR_RUNTIME; - - /* resume execution in next remaining callframe */ - frame = uc_vector_last(&vm->callframes); - chunk = uc_vm_frame_chunk(frame); } } @@ -3032,13 +3062,12 @@ uc_vm_execute(uc_vm_t *vm, uc_program_t *program, uc_value_t **retval) uc_stringbuf_t *buf; uc_value_t *val; - uc_vector_grow(&vm->callframes); - - frame = &vm->callframes.entries[vm->callframes.count++]; - frame->closure = closure; - frame->stackframe = 0; - frame->ip = uc_vm_frame_chunk(frame)->entries; - frame->strict = fn->strict; + frame = uc_vector_push(&vm->callframes, { + .closure = closure, + .stackframe = 0, + .ip = closure->function->chunk.entries, + .strict = fn->strict + }); if (vm->trace) { buf = xprintbuf_new(); |