From 434de903bdbc21b5ef0ee9f7f59d1ec3924c56cb Mon Sep 17 00:00:00 2001 From: Mario Fetka Date: Sat, 30 May 2026 19:40:19 +0000 Subject: [PATCH] tests: add AFP create file smoke --- TODO.md | 10 +- tests/linux/CMakeLists.txt | 4 + tests/linux/README.md | 31 +++ tests/linux/afp_create_file_smoke.c | 364 ++++++++++++++++++++++++++++ tests/linux/afp_smoke_suite.sh | 76 ++++++ 5 files changed, 482 insertions(+), 3 deletions(-) create mode 100644 tests/linux/afp_create_file_smoke.c diff --git a/TODO.md b/TODO.md index 77b4e64..bb884ab 100644 --- a/TODO.md +++ b/TODO.md @@ -483,9 +483,13 @@ Endpoint order: `0x00000005`. The same run also confirmed that regular-file AFP Entry IDs stay on the nwatalk/fallback path (`0x067a8d0f` for `PMDFLTS.INI`) while directory scan/basehandle IDs continue to use the NetWare namespace mapping. -- Next implement AFP Create File (`0x02`) and AFP 2.0 Create File (`0x0e`) by - routing through the existing NetWare create/open path and testing only - explicit temporary smoke files with cleanup. +- AFP Create File (`0x02`) and AFP 2.0 Create File (`0x0e`) are now routed + through the existing NetWare file-create path for temporary smoke files. The + Linux smoke helper creates both legacy and AFP 2.0 files under the tested + parent, verifies the returned AFP file ID with Entry ID From Path Name, and + keeps local cleanup best-effort because AFP Delete is still pending. +- Runtime status: create-file smoke is added but still needs a build-server + runtime confirmation before recording success. - Then implement AFP Rename (`0x07`) through the existing NetWare rename/move path, preserving FinderInfo/xattrs and checking Entry ID behavior. - Keep AFP Delete (`0x03`) and Get Macintosh Info On Deleted File (`0x13`) for diff --git a/tests/linux/CMakeLists.txt b/tests/linux/CMakeLists.txt index 5d8939d..0197eb3 100644 --- a/tests/linux/CMakeLists.txt +++ b/tests/linux/CMakeLists.txt @@ -67,6 +67,10 @@ add_executable(afp_create_directory_smoke afp_create_directory_smoke.c) target_include_directories(afp_create_directory_smoke PRIVATE ${NCPFS_INCLUDE_DIR}) target_link_libraries(afp_create_directory_smoke ${NCPFS_LIBRARY}) +add_executable(afp_create_file_smoke afp_create_file_smoke.c) +target_include_directories(afp_create_file_smoke PRIVATE ${NCPFS_INCLUDE_DIR}) +target_link_libraries(afp_create_file_smoke ${NCPFS_LIBRARY}) + add_executable(afp_temp_dir_handle_smoke afp_temp_dir_handle_smoke.c) target_include_directories(afp_temp_dir_handle_smoke PRIVATE ${NCPFS_INCLUDE_DIR}) target_link_libraries(afp_temp_dir_handle_smoke ${NCPFS_LIBRARY}) diff --git a/tests/linux/README.md b/tests/linux/README.md index 0e3f0ab..24384fe 100644 --- a/tests/linux/README.md +++ b/tests/linux/README.md @@ -222,6 +222,37 @@ Unix user while the server created the directory under its own identity. Use that rerunning with the same explicit name may fail if a previous directory still exists. + +## AFP Create File smoke test + +`afp_create_file_smoke` sends the WebSDK/nwafp.h AFP Create File requests +through libncp: + +```text +NCP 0x2222/35/02 AFP Create File +NCP 0x2222/35/0e AFP 2.0 Create File +``` + +The helper derives the parent Entry ID with AFP Entry ID From Path Name, sends +only the new leaf name to Create File, and verifies the returned file ID by +looking the created path up again. This exercises the server-side file create +path through the existing mars_nwe create helpers rather than direct local file +creation from the test. + +Example: + +```sh +./tests/linux/afp_create_file_smoke -S MARS -U SUPERVISOR -P secret SYS:PUBLIC/afpfile +./tests/linux/afp_create_file_smoke --afp20 -S MARS -U SUPERVISOR -P secret SYS:PUBLIC/afpfil2 +``` + +The full smoke suite creates temporary files under the tested parent with fresh +short DOS-compatible leaf names by default. Local removal is best-effort, just +like the create-directory smoke, because the suite usually runs as an +unprivileged Unix user while mars_nwe creates the file as the server-side +identity. Use `--create-file-name NAME` to override the default leaf name; +rerunning with the same explicit name may fail if a previous file still exists. + ## AFP Entry ID smoke test `afp_entry_id_smoke` sends the WebSDK-documented NetWare AFP request: diff --git a/tests/linux/afp_create_file_smoke.c b/tests/linux/afp_create_file_smoke.c new file mode 100644 index 0000000..7cfe954 --- /dev/null +++ b/tests/linux/afp_create_file_smoke.c @@ -0,0 +1,364 @@ +/* + * Linux smoke test for NetWare AFP Create File. + * + * The helper sends the WebSDK/nwafp.h AFP Create File requests through + * ncpfs/libncp and verifies that the returned AFP file ID matches a + * subsequent AFP Entry ID From Path Name lookup for the created file. + */ + +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifndef NCPC_SUBFUNCTION +#define NCPC_SUBFUNCTION 0x10000 +#endif +#ifndef NCPC_SFN +#define NCPC_SFN(FN, SFN) ((FN) | ((SFN) << 8) | NCPC_SUBFUNCTION) +#endif + +#define AFP_CREATE_FILE 0x02 +#define AFP20_CREATE_FILE 0x0e +#define AFP_GET_ENTRY_ID_FROM_PATH 0x0c +#define NWE_INVALID_NAMESPACE 0xbf +#define NWE_INVALID_PATH 0x9c +#define NWE_FILE_EXISTS 0xff +#ifndef NWE_INVALID_NCP_PACKET_LENGTH +#define NWE_INVALID_NCP_PACKET_LENGTH 0x7e +#endif + +static void usage(const char *prog) +{ + fprintf(stderr, + "Usage: %s [--afp20] [--delete-existing] [--expect-completion CODE] [--volume N] " + "[--entry-id ID] [--type FOURCC] [--creator FOURCC] " + "[ncpfs options] PATH\n" + "\n" + "ncpfs options are parsed by ncp_initialize(), for example:\n" + " -S SERVER -U USER -P PASSWORD -n\n" + "\n" + "Examples:\n" + " %s -S MARS -U SUPERVISOR -P secret SYS:PUBLIC/AFPFILE\n" + " %s --afp20 -S MARS -U SUPERVISOR -P secret SYS:PUBLIC/AFPFILE2\n", + prog, prog, prog); +} + +static int parse_u32(const char *text, uint32_t *value) +{ + char *end = NULL; + unsigned long v; + + errno = 0; + v = strtoul(text, &end, 0); + if (errno || !end || *end || v > 0xffffffffUL) + return -1; + *value = (uint32_t)v; + return 0; +} + +static void cpu_to_be32(uint32_t v, uint8_t p[4]) +{ + p[0] = (uint8_t)(v >> 24); + p[1] = (uint8_t)(v >> 16); + p[2] = (uint8_t)(v >> 8); + p[3] = (uint8_t)v; +} + +static uint32_t be32_to_cpu(const uint8_t p[4]) +{ + return ((uint32_t)p[0] << 24) | + ((uint32_t)p[1] << 16) | + ((uint32_t)p[2] << 8) | + p[3]; +} + +static int split_parent_leaf(const char *path, char *parent, size_t parent_size, + char *leaf, size_t leaf_size) +{ + const char *slash = strrchr(path, '/'); + const char *backslash = strrchr(path, '\\'); + const char *sep = slash; + size_t parent_len; + size_t leaf_len; + + if (backslash && (!sep || backslash > sep)) + sep = backslash; + + if (!sep) { + const char *colon = strchr(path, ':'); + if (!colon || colon[1] == '\0') + return -1; + parent_len = (size_t)(colon - path + 1); + leaf_len = strlen(colon + 1); + if (parent_len >= parent_size || leaf_len >= leaf_size || !leaf_len) + return -1; + memcpy(parent, path, parent_len); + parent[parent_len] = '\0'; + memcpy(leaf, colon + 1, leaf_len + 1); + return 0; + } + + parent_len = (size_t)(sep - path); + leaf_len = strlen(sep + 1); + if (!parent_len || !leaf_len || parent_len >= parent_size || + leaf_len >= leaf_size) + return -1; + + memcpy(parent, path, parent_len); + parent[parent_len] = '\0'; + memcpy(leaf, sep + 1, leaf_len + 1); + return 0; +} + +static NWCCODE afp_get_entry_id_from_path(NWCONN_HANDLE conn, + const char *path, + uint32_t *entry_id) +{ + size_t path_len = strlen(path); + uint8_t request[1 + 1 + 255]; + uint8_t reply_buf[4]; + NW_FRAGMENT reply; + NWCCODE err; + + if (path_len > 255) + return NWE_INVALID_PATH; + + request[0] = 0; /* directory handle 0, raw VOL:path */ + request[1] = (uint8_t)path_len; + memcpy(request + 2, path, path_len); + + memset(reply_buf, 0, sizeof(reply_buf)); + reply.fragAddr.rw = reply_buf; + reply.fragSize = sizeof(reply_buf); + + err = NWRequestSimple(conn, + NCPC_SFN(0x23, AFP_GET_ENTRY_ID_FROM_PATH), + request, + 2 + path_len, + &reply); + if (err) + return err; + if (reply.fragSize < 4) + return NWE_INVALID_NCP_PACKET_LENGTH; + + *entry_id = be32_to_cpu(reply_buf); + return 0; +} + +int main(int argc, char **argv) +{ + NWCONN_HANDLE conn; + NW_FRAGMENT reply; + long init_err = 0; + const char *path = NULL; + uint32_t volume_number = 0; + uint32_t base_entry_id = 0; + uint32_t expect_completion = 0xffffffffU; + int afp20 = 0; + int delete_existing = 0; + const char *finder_type = "TEXT"; + const char *finder_creator = "MARS"; + int i; + char parent[256]; + char leaf[256]; + size_t leaf_len; + uint8_t request[1 + 4 + 1 + 32 + 6 + 1 + 255]; + size_t fixed_len; + uint8_t reply_buf[4]; + uint32_t created_entry_id; + uint32_t lookup_entry_id; + NWCCODE err; + + if (NWCallsInit(NULL, NULL)) { + fprintf(stderr, "NWCallsInit failed\n"); + return 2; + } + + conn = ncp_initialize(&argc, argv, 1, &init_err); + if (!conn) { + fprintf(stderr, "ncp_initialize/login failed: %ld\n", init_err); + usage(argv[0]); + return 2; + } + + for (i = 1; i < argc; i++) { + if (!strcmp(argv[i], "--afp20")) { + afp20 = 1; + } else if (!strcmp(argv[i], "--delete-existing")) { + delete_existing = 1; + } else if (!strcmp(argv[i], "--volume")) { + if (++i >= argc || parse_u32(argv[i], &volume_number) || + volume_number > 255) { + fprintf(stderr, "invalid --volume value\n"); + ncp_close(conn); + return 2; + } + } else if (!strcmp(argv[i], "--entry-id")) { + if (++i >= argc || parse_u32(argv[i], &base_entry_id)) { + fprintf(stderr, "invalid --entry-id value\n"); + ncp_close(conn); + return 2; + } + } else if (!strcmp(argv[i], "--expect-completion")) { + if (++i >= argc || parse_u32(argv[i], &expect_completion) || + expect_completion > 255) { + fprintf(stderr, "invalid --expect-completion value\n"); + ncp_close(conn); + return 2; + } + } else if (!strcmp(argv[i], "--type")) { + if (++i >= argc || strlen(argv[i]) != 4) { + fprintf(stderr, "--type must be exactly four characters\n"); + ncp_close(conn); + return 2; + } + finder_type = argv[i]; + } else if (!strcmp(argv[i], "--creator")) { + if (++i >= argc || strlen(argv[i]) != 4) { + fprintf(stderr, "--creator must be exactly four characters\n"); + ncp_close(conn); + return 2; + } + finder_creator = argv[i]; + } else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) { + usage(argv[0]); + ncp_close(conn); + return 0; + } else if (!path) { + path = argv[i]; + } else { + fprintf(stderr, "unexpected argument: %s\n", argv[i]); + usage(argv[0]); + ncp_close(conn); + return 2; + } + } + + if (!path) { + fprintf(stderr, "missing PATH\n"); + usage(argv[0]); + ncp_close(conn); + return 2; + } + + if (split_parent_leaf(path, parent, sizeof(parent), leaf, sizeof(leaf))) { + fprintf(stderr, "PATH must include a parent and new file name: %s\n", path); + ncp_close(conn); + return 2; + } + + leaf_len = strlen(leaf); + if (leaf_len > 255) { + fprintf(stderr, "file name is too long for AFP Create File: %zu\n", + leaf_len); + ncp_close(conn); + return 2; + } + + if (base_entry_id == 0) { + err = afp_get_entry_id_from_path(conn, parent, &base_entry_id); + if (err) { + fprintf(stderr, "AFP parent Entry ID lookup failed for %s: 0x%04x\n", + parent, (unsigned int)err); + ncp_close(conn); + return 1; + } + } + + memset(request, 0, sizeof(request)); + request[0] = (uint8_t)volume_number; + cpu_to_be32(base_entry_id, request + 1); + request[5] = delete_existing ? 1 : 0; /* DeleteExistingFileFlag */ + memcpy(request + 6, finder_type, 4); + memcpy(request + 10, finder_creator, 4); + + if (afp20) { + fixed_len = 44; /* volume..ProDOSInfo */ + request[44] = (uint8_t)leaf_len; + memcpy(request + 45, leaf, leaf_len); + } else { + fixed_len = 38; /* volume..FinderInfo */ + request[38] = (uint8_t)leaf_len; + memcpy(request + 39, leaf, leaf_len); + } + + memset(reply_buf, 0, sizeof(reply_buf)); + reply.fragAddr.rw = reply_buf; + reply.fragSize = sizeof(reply_buf); + + err = NWRequestSimple(conn, + NCPC_SFN(0x23, afp20 ? AFP20_CREATE_FILE + : AFP_CREATE_FILE), + request, + fixed_len + 1 + leaf_len, + &reply); + + if (expect_completion != 0xffffffffU) { + if (((unsigned int)err & 0xff) == expect_completion) { + printf("AFP Create File returned expected completion 0x%02x: " + "subfunction=0x%02x path=%s parent_entry_id=0x%08x\n", + (unsigned int)expect_completion, + afp20 ? AFP20_CREATE_FILE : AFP_CREATE_FILE, + path, base_entry_id); + ncp_close(conn); + return 0; + } + fprintf(stderr, "expected completion 0x%02x but got 0x%04x\n", + (unsigned int)expect_completion, (unsigned int)err); + ncp_close(conn); + return 1; + } + + if (err) { + fprintf(stderr, "AFP Create File failed: subfunction=0x%02x " + "path=%s parent_entry_id=0x%08x error=0x%04x\n", + afp20 ? AFP20_CREATE_FILE : AFP_CREATE_FILE, + path, base_entry_id, (unsigned int)err); + ncp_close(conn); + return 1; + } + + if (reply.fragSize < 4) { + fprintf(stderr, "AFP Create File reply too short: %u\n", + (unsigned int)reply.fragSize); + ncp_close(conn); + return 1; + } + + created_entry_id = be32_to_cpu(reply_buf); + if (!created_entry_id) { + fprintf(stderr, "AFP Create File returned entry_id 0\n"); + ncp_close(conn); + return 1; + } + + err = afp_get_entry_id_from_path(conn, path, &lookup_entry_id); + if (err) { + fprintf(stderr, "AFP Entry ID lookup for created file failed: " + "path=%s error=0x%04x\n", path, (unsigned int)err); + ncp_close(conn); + return 1; + } + + if (created_entry_id != lookup_entry_id) { + fprintf(stderr, "AFP Create File entry mismatch: created=0x%08x " + "lookup=0x%08x path=%s\n", + created_entry_id, lookup_entry_id, path); + ncp_close(conn); + return 1; + } + + printf("AFP Create File subfunction=0x%02x path=%s parent=%s " + "leaf=%s parent_entry_id=0x%08x entry_id=0x%08x verified\n", + afp20 ? AFP20_CREATE_FILE : AFP_CREATE_FILE, + path, parent, leaf, base_entry_id, created_entry_id); + + ncp_close(conn); + return 0; +} diff --git a/tests/linux/afp_smoke_suite.sh b/tests/linux/afp_smoke_suite.sh index bec65ac..a800720 100755 --- a/tests/linux/afp_smoke_suite.sh +++ b/tests/linux/afp_smoke_suite.sh @@ -19,6 +19,7 @@ FINDER_TYPE="TEXT" FINDER_CREATOR="MARS" TIMESTAMP_EPOCH="1700000000" CREATE_DIR_NAME="" +CREATE_FILE_NAME="" READONLY_USER="" READONLY_PASSWORD="" READONLY_NO_PASSWORD=0 @@ -41,6 +42,7 @@ Options: --creator FOURCC FinderInfo creator written by Set File Info (default: $FINDER_CREATOR) --mtime-epoch SECONDS AFP modify/backup timestamp to write (default: $TIMESTAMP_EPOCH) --create-dir-name NAME Temporary directory name for AFP Create Directory (default: generated aHHMMSS) + --create-file-name NAME Temporary file name for AFP Create File (default: generated fHHMMR) --readonly-user USER Optional user expected to lack Modify rights --readonly-password PASS Password for --readonly-user --readonly-no-password Use ncpfs -n for --readonly-user @@ -81,6 +83,8 @@ while [ $# -gt 0 ]; do TIMESTAMP_EPOCH=$2; shift 2 ;; --create-dir-name) CREATE_DIR_NAME=$2; shift 2 ;; + --create-file-name) + CREATE_FILE_NAME=$2; shift 2 ;; --readonly-user) READONLY_USER=$2; shift 2 ;; --readonly-password) @@ -123,6 +127,9 @@ esac case "$CREATE_DIR_NAME" in ""|*/*|*\\*|*:*) echo "--create-dir-name must be a single path component" >&2; exit 2 ;; esac +case "$CREATE_FILE_NAME" in + ""|*/*|*\\*|*:*) echo "--create-file-name must be a single path component" >&2; exit 2 ;; +esac case "$LOG_WINDOW_SECONDS" in ''|*[!0-9]*) echo "--log-window-seconds must be a positive integer" >&2; exit 2 ;; esac @@ -134,10 +141,17 @@ fi if [ -z "$CREATE_DIR_NAME" ]; then CREATE_DIR_NAME=$(date +a%H%M%S) fi +if [ -z "$CREATE_FILE_NAME" ]; then + CREATE_FILE_NAME=$(printf 'f%04d%01d' "$((10#$(date +%H%M) % 10000))" "$((RANDOM % 10))") +fi case "$CREATE_DIR_NAME" in ???????|??????|?????|????|???|??|?) ;; *) echo "--create-dir-name must be at most seven characters so the AFP 2.0 companion name stays DOS-compatible" >&2; exit 2 ;; esac +case "$CREATE_FILE_NAME" in + ???????|??????|?????|????|???|??|?) ;; + *) echo "--create-file-name must be at most seven characters so the AFP 2.0 companion name stays DOS-compatible" >&2; exit 2 ;; +esac DIR_PATH=$NETWARE_PATH case "$NETWARE_PATH" in @@ -152,6 +166,14 @@ UNIX_DIR_PATH=$UNIX_PARENT_PATH/$CREATE_DIR_NAME UNIX_DIR20_PATH=$UNIX_PARENT_PATH/${CREATE_DIR_NAME}2 UNIX_DIR_PATH_DOS=$UNIX_PARENT_PATH/$CREATE_DIR_NAME_DOS UNIX_DIR20_PATH_DOS=$UNIX_PARENT_PATH/$CREATE_DIR20_NAME_DOS +CREATE_FILE_PATH="$DIR_PATH/$CREATE_FILE_NAME" +CREATE_FILE20_PATH="$DIR_PATH/${CREATE_FILE_NAME}2" +CREATE_FILE_NAME_DOS=$(printf '%s' "$CREATE_FILE_NAME" | tr '[:lower:]' '[:upper:]') +CREATE_FILE20_NAME_DOS=$(printf '%s' "${CREATE_FILE_NAME}2" | tr '[:lower:]' '[:upper:]') +UNIX_FILE_PATH=$UNIX_PARENT_PATH/$CREATE_FILE_NAME +UNIX_FILE20_PATH=$UNIX_PARENT_PATH/${CREATE_FILE_NAME}2 +UNIX_FILE_PATH_DOS=$UNIX_PARENT_PATH/$CREATE_FILE_NAME_DOS +UNIX_FILE20_PATH_DOS=$UNIX_PARENT_PATH/$CREATE_FILE20_NAME_DOS REPORT_TMP=$(mktemp "${TMPDIR:-/tmp}/mars-afp-smoke.XXXXXX") LOG_TMP=$(mktemp "${TMPDIR:-/tmp}/mars-afp-log.XXXXXX") @@ -216,6 +238,19 @@ cleanup_created_dir() { fi } +cleanup_created_file() { + local path=$1 + local dos_path=$2 + + if [ -f "$path" ]; then + rm -f "$path" + elif [ -f "$dos_path" ]; then + rm -f "$dos_path" + else + rm -f "$path" + fi +} + run_optional_cmd() { local label=$1 local printable=$2 @@ -300,6 +335,12 @@ emit "unix_dir_path=$UNIX_DIR_PATH" emit "unix_dir20_path=$UNIX_DIR20_PATH" emit "unix_dir_path_dos=$UNIX_DIR_PATH_DOS" emit "unix_dir20_path_dos=$UNIX_DIR20_PATH_DOS" +emit "create_file_path=$CREATE_FILE_PATH" +emit "create_file20_path=$CREATE_FILE20_PATH" +emit "unix_file_path=$UNIX_FILE_PATH" +emit "unix_file20_path=$UNIX_FILE20_PATH" +emit "unix_file_path_dos=$UNIX_FILE_PATH_DOS" +emit "unix_file20_path_dos=$UNIX_FILE20_PATH_DOS" if [ -n "$READONLY_USER" ]; then emit "readonly_user=$READONLY_USER" if [ "$READONLY_NO_PASSWORD" -eq 1 ]; then @@ -317,6 +358,7 @@ for helper in \ afp_dos_name_smoke \ afp_scan_info_smoke \ afp_create_directory_smoke \ + afp_create_file_smoke \ afp_temp_dir_handle_smoke \ afp_open_file_fork_smoke \ afp_set_file_info_smoke @@ -422,6 +464,40 @@ run_optional_cmd \ "rmdir '$UNIX_DIR20_PATH' or '$UNIX_DIR20_PATH_DOS'" \ cleanup_created_dir "$UNIX_DIR20_PATH" "$UNIX_DIR20_PATH_DOS" || true +if [ -f "$UNIX_FILE_PATH" ] || [ -f "$UNIX_FILE_PATH_DOS" ]; then + run_optional_cmd \ + "Prepare AFP Create File cleanup" \ + "rm '$UNIX_FILE_PATH' or '$UNIX_FILE_PATH_DOS'" \ + cleanup_created_file "$UNIX_FILE_PATH" "$UNIX_FILE_PATH_DOS" || true +fi +if [ -f "$UNIX_FILE20_PATH" ] || [ -f "$UNIX_FILE20_PATH_DOS" ]; then + run_optional_cmd \ + "Prepare AFP 2.0 Create File cleanup" \ + "rm '$UNIX_FILE20_PATH' or '$UNIX_FILE20_PATH_DOS'" \ + cleanup_created_file "$UNIX_FILE20_PATH" "$UNIX_FILE20_PATH_DOS" || true +fi + +run_cmd \ + "AFP Create File" \ + "./afp_create_file_smoke $COMMON_PRINT '$CREATE_FILE_PATH'" \ + "$SCRIPT_DIR/afp_create_file_smoke" -S "$SERVER" -U "$USER_NAME" -P "$PASSWORD" "$CREATE_FILE_PATH" + +run_cmd \ + "AFP 2.0 Create File" \ + "./afp_create_file_smoke --afp20 $COMMON_PRINT '$CREATE_FILE20_PATH'" \ + "$SCRIPT_DIR/afp_create_file_smoke" --afp20 \ + -S "$SERVER" -U "$USER_NAME" -P "$PASSWORD" "$CREATE_FILE20_PATH" + +run_optional_cmd \ + "Cleanup AFP Create File" \ + "rm '$UNIX_FILE_PATH' or '$UNIX_FILE_PATH_DOS'" \ + cleanup_created_file "$UNIX_FILE_PATH" "$UNIX_FILE_PATH_DOS" || true + +run_optional_cmd \ + "Cleanup AFP 2.0 Create File" \ + "rm '$UNIX_FILE20_PATH' or '$UNIX_FILE20_PATH_DOS'" \ + cleanup_created_file "$UNIX_FILE20_PATH" "$UNIX_FILE20_PATH_DOS" || true + run_cmd \ "AFP Open File Fork" \ "./afp_open_file_fork_smoke $COMMON_PRINT '$NETWARE_PATH'" \