Implement jerry_port_path_normalize in a more reliable way

Replace jerry_port_path_normalize,jerry_port_path_free,jerry_port_path_base with jerry_port_path_style,jerry_port_get_cwd

Partially fixes jerryscript-project#4979
Closes: jerryscript-project#4983

JerryScript-DCO-1.0-Signed-off-by: Yonggang Luo [email protected]

Author: lygstate

docs/05.PORT-API.md

@@ -163,52 +163,33 @@ void jerry_port_line_free (jerry_char_t *buffer_p);
 
 ## Filesystem
 
-```
-/**
- * Canonicalize a file path.
- *
- * If possible, the implementation should resolve symbolic links and other directory references found in the input path,
- * and create a fully canonicalized file path as the result.
- *
- * The function may return with NULL in case an error is encountered, in which case the calling operation will not
- * proceed.
- *
- * The implementation should allocate storage for the result path as necessary. Non-NULL return values will be passed
- * to `jerry_port_path_free` when the result is no longer needed by the caller, which can be used to finalize
- * dynamically allocated buffers.
- *
- * NOTE: The implementation must not return directly with the input, as the input buffer is released after the call.
- *
- * @param path_p: zero-terminated string containing the input path
- * @param path_size: size of the input path string in bytes, excluding terminating zero
- *
- * @return buffer with the normalized path if the operation is successful,
- *         NULL otherwise
- */
-jerry_char_t *jerry_port_path_normalize (const jerry_char_t *path_p, jerry_size_t path_size);
-```
-
 ```c
 /**
- * Free a path buffer returned by jerry_port_path_normalize.
+ * Get the path style of the current OS
  *
- * @param path_p: the path buffer to free
+ * @return path style
  */
-void jerry_port_path_free (jerry_char_t *path_p);
+jerry_path_style_t jerry_port_path_style (void);
 ```
 
 ```c
 /**
- * Get the offset of the basename component in the input path.
+ * Get the cwd, the output string will be zero-terminated
  *
- * The implementation should return the offset of the first character after the last path separator found in the path.
- * This is used by the caller to split the path into a directory name and a file name.
+ * @param buffer_p: the buffer to storage the cwd
+ * @param buffer_size: the `buffer_p` buffer size, including '\0` terminator
  *
- * @param path_p: input zero-terminated path string
+ * @note
+ * - cwd: current working directory
  *
- * @return offset of the basename component in the input path
+ * @return The length of cwd, excluding '\0' terminator
+ *         - When buffer_p is `NULL` and get cwd succeed return length of cwd
+ *         - When buffer_p is `NULL` and get cwd failed return 0
+ *         - When buffer_p is not `NULL` and the `buffer_size - 1` just equal to
+ *           length of cwd; and get cwd succeed return `buffer_size - 1`.
+ *         - Otherwise means get cwd failed and return 0
  */
-jerry_size_t jerry_port_path_base (const jerry_char_t *path_p);
+jerry_size_t jerry_port_get_cwd (jerry_char_t *buffer_p, jerry_size_t buffer_size);
 ```
 
 ```c

jerry-core/api/jerry-module.c

@@ -37,6 +37,15 @@ JERRY_C_API_BEGIN
  * @{
  */
 
+/**
+ * The path style of the OS
+ */
+typedef enum
+{
+  JERRY_PATH_STYLE_WINDOWS,
+  JERRY_PATH_STYLE_POSIX,
+} jerry_path_style_t;
+
 /**
  * Error codes that can be passed by the engine when calling jerry_port_fatal
  */
@@ -191,46 +200,29 @@ void jerry_port_line_free (jerry_char_t *buffer_p);
  */
 
 /**
- * Canonicalize a file path.
- *
- * If possible, the implementation should resolve symbolic links and other directory references found in the input path,
- * and create a fully canonicalized file path as the result.
- *
- * The function may return with NULL in case an error is encountered, in which case the calling operation will not
- * proceed.
- *
- * The implementation should allocate storage for the result path as necessary. Non-NULL return values will be passed
- * to `jerry_port_path_free` when the result is no longer needed by the caller, which can be used to finalize
- * dynamically allocated buffers.
- *
- * NOTE: The implementation must not return directly with the input, as the input buffer is released after the call.
- *
- * @param path_p: zero-terminated string containing the input path
- * @param path_size: size of the input path string in bytes, excluding terminating zero
- *
- * @return buffer with the normalized path if the operation is successful,
- *         NULL otherwise
- */
-jerry_char_t *jerry_port_path_normalize (const jerry_char_t *path_p, jerry_size_t path_size);
-
-/**
- * Free a path buffer returned by jerry_port_path_normalize.
+ * Get the path style of the current OS
  *
- * @param path_p: the path buffer to free
+ * @return path style
  */
-void jerry_port_path_free (jerry_char_t *path_p);
+jerry_path_style_t jerry_port_path_style (void);
 
 /**
- * Get the offset of the basename component in the input path.
+ * Get the cwd, the output string will be zero-terminated
  *
- * The implementation should return the offset of the first character after the last path separator found in the path.
- * This is used by the caller to split the path into a directory name and a file name.
+ * @param buffer_p: the buffer to storage the cwd
+ * @param buffer_size: the `buffer_p` buffer size, including '\0` terminator
  *
- * @param path_p: input zero-terminated path string
+ * @note
+ * - cwd: current working directory
  *
- * @return offset of the basename component in the input path
+ * @return The length of cwd, excluding '\0' terminator
+ *         - When buffer_p is `NULL` and get cwd succeed return length of cwd
+ *         - When buffer_p is `NULL` and get cwd failed return 0
+ *         - When buffer_p is not `NULL` and the `buffer_size - 1` just equal to
+ *           length of cwd; and get cwd succeed return `buffer_size - 1`.
+ *         - Otherwise means get cwd failed and return 0
  */
-jerry_size_t jerry_port_path_base (const jerry_char_t *path_p);
+jerry_size_t jerry_port_get_cwd (jerry_char_t *buffer_p, jerry_size_t buffer_size);
 
 /**
  * Open a source file and read the content into a buffer.

jerry-core/include/jerryscript-port.h

@@ -153,6 +153,15 @@ typedef uint32_t jerry_length_t;
  */
 typedef uint32_t jerry_value_t;
 
+/**
+ * Description of a JerryScript string for arguments passing
+ */
+typedef struct
+{
+  const jerry_char_t *ptr; /**< pointer to the zero-terminated ASCII/UTF-8/CESU-8 string */
+  jerry_size_t size; /**< size of the string, excluding '\0' terminator */
+} jerry_string_t;
+
 /**
  * Option bits for jerry_parse_options_t.
  */
@@ -856,10 +865,16 @@ typedef void (*jerry_arraybuffer_free_cb_t) (jerry_arraybuffer_type_t buffer_typ
                                              void *arraybuffer_user_p,
                                              void *user_p);
 
+/**
+ * Helper to to ensure str is a string literal
+ */
+#define JERRY_ZSTR_ENSURE_STRING_LITERAL(str) str ""
+
 /**
  * Helper to expand string literal to [string pointer, string size] argument pair.
  */
-#define JERRY_ZSTR_ARG(str) ((const jerry_char_t *) (str)), ((jerry_size_t) (sizeof (str) - 1))
+#define JERRY_ZSTR_ARG(str) \
+  ((const jerry_char_t *) (JERRY_ZSTR_ENSURE_STRING_LITERAL (str))), ((jerry_size_t) (sizeof (str) - 1))
 
 /**
  * @}

jerry-core/include/jerryscript-types.h

@@ -20,10 +20,10 @@
 
 JERRY_C_API_BEGIN
 
-jerry_value_t jerryx_source_parse_script (const char* path);
-jerry_value_t jerryx_source_exec_script (const char* path);
-jerry_value_t jerryx_source_exec_module (const char* path);
-jerry_value_t jerryx_source_exec_snapshot (const char* path, size_t function_index);
+jerry_value_t jerryx_source_parse_script (const jerry_string_t *path);
+jerry_value_t jerryx_source_exec_script (const jerry_string_t *path);
+jerry_value_t jerryx_source_exec_module (const jerry_string_t *path);
+jerry_value_t jerryx_source_exec_snapshot (const jerry_string_t *path, size_t function_index);
 jerry_value_t jerryx_source_exec_stdin (void);
 
 JERRY_C_API_END

jerry-ext/include/jerryscript-ext/sources.h

@@ -27,14 +27,14 @@
 #include "jerryscript-ext/print.h"
 
 jerry_value_t
-jerryx_source_parse_script (const char *path_p)
+jerryx_source_parse_script (const jerry_string_t *path_p)
 {
   jerry_size_t source_size;
-  jerry_char_t *source_p = jerry_port_source_read (path_p, &source_size);
+  jerry_char_t *source_p = jerry_port_source_read ((const char *) path_p->ptr, &source_size);
 
   if (source_p == NULL)
   {
-    jerry_log (JERRY_LOG_LEVEL_ERROR, "Failed to open file: %s\n", path_p);
+    jerry_log (JERRY_LOG_LEVEL_ERROR, "Failed to open file: %.*s\n", path_p->size, path_p->ptr);
     return jerry_throw_sz (JERRY_ERROR_SYNTAX, "Source file not found");
   }
 
@@ -46,8 +46,7 @@ jerryx_source_parse_script (const char *path_p)
 
   jerry_parse_options_t parse_options;
   parse_options.options = JERRY_PARSE_HAS_SOURCE_NAME;
-  parse_options.source_name =
-    jerry_string ((const jerry_char_t *) path_p, (jerry_size_t) strlen (path_p), JERRY_ENCODING_UTF8);
+  parse_options.source_name = jerry_string (path_p->ptr, path_p->size, JERRY_ENCODING_UTF8);
 
   jerry_value_t result = jerry_parse (source_p, source_size, &parse_options);
 
@@ -58,7 +57,7 @@ jerryx_source_parse_script (const char *path_p)
 } /* jerryx_source_parse_script */
 
 jerry_value_t
-jerryx_source_exec_script (const char *path_p)
+jerryx_source_exec_script (const jerry_string_t *path_p)
 {
   jerry_value_t result = jerryx_source_parse_script (path_p);
 
@@ -73,10 +72,9 @@ jerryx_source_exec_script (const char *path_p)
 } /* jerryx_source_exec_script */
 
 jerry_value_t
-jerryx_source_exec_module (const char *path_p)
+jerryx_source_exec_module (const jerry_string_t *path_p)
 {
-  jerry_value_t specifier =
-    jerry_string ((const jerry_char_t *) path_p, (jerry_size_t) strlen (path_p), JERRY_ENCODING_UTF8);
+  jerry_value_t specifier = jerry_string (path_p->ptr, path_p->size, JERRY_ENCODING_UTF8);
   jerry_value_t referrer = jerry_undefined ();
 
   jerry_value_t module = jerry_module_resolve (specifier, referrer, NULL);
@@ -110,14 +108,14 @@ jerryx_source_exec_module (const char *path_p)
 } /* jerryx_source_exec_module */
 
 jerry_value_t
-jerryx_source_exec_snapshot (const char *path_p, size_t function_index)
+jerryx_source_exec_snapshot (const jerry_string_t *path_p, size_t function_index)
 {
   jerry_size_t source_size;
-  jerry_char_t *source_p = jerry_port_source_read (path_p, &source_size);
+  jerry_char_t *source_p = jerry_port_source_read ((const char *) path_p->ptr, &source_size);
 
   if (source_p == NULL)
   {
-    jerry_log (JERRY_LOG_LEVEL_ERROR, "Failed to open file: %s\n", path_p);
+    jerry_log (JERRY_LOG_LEVEL_ERROR, "Failed to open file: %.*s\n", path_p->size, path_p->ptr);
     return jerry_throw_sz (JERRY_ERROR_SYNTAX, "Snapshot file not found");
   }
 

jerry-ext/util/sources.c

@@ -130,17 +130,18 @@ main (int argc, char **argv)
   {
     main_source_t *source_file_p = sources_p + source_index;
     const char *file_path_p = argv[source_file_p->path_index];
+    jerry_string_t file_path = { (const jerry_char_t *) file_path_p, (jerry_size_t) strlen (file_path_p) };
 
     switch (source_file_p->type)
     {
       case SOURCE_MODULE:
       {
-        result = jerryx_source_exec_module (file_path_p);
+        result = jerryx_source_exec_module (&file_path);
         break;
       }
       case SOURCE_SNAPSHOT:
       {
-        result = jerryx_source_exec_snapshot (file_path_p, source_file_p->snapshot_index);
+        result = jerryx_source_exec_snapshot (&file_path, source_file_p->snapshot_index);
         break;
       }
       default:
@@ -149,11 +150,11 @@ main (int argc, char **argv)
 
         if ((arguments.option_flags & OPT_FLAG_PARSE_ONLY) != 0)
         {
-          result = jerryx_source_parse_script (file_path_p);
+          result = jerryx_source_parse_script (&file_path);
         }
         else
         {
-          result = jerryx_source_exec_script (file_path_p);
+          result = jerryx_source_exec_script (&file_path);
         }
 
         break;

jerry-main/main-desktop.c

@@ -25,7 +25,7 @@
 #ifndef S_ISDIR
 #define S_ISDIR(mode) (((mode) &S_IFMT) == S_IFDIR)
 #endif /* !defined(S_ISDIR) */
-#endif /* __GLIBC__ */
+#endif /* defined(__GLIBC__) || defined(_WIN32) */
 
 /**
  * Determines the size of the given file.
@@ -59,7 +59,7 @@ jerry_port_source_read (const char *file_name_p, /**< file name */
   {
     return NULL;
   }
-#endif /* __GLIBC__ */
+#endif /* defined(__GLIBC__) || defined(_WIN32) */
 
   FILE *file_p = fopen (file_name_p, "rb");
 
@@ -101,62 +101,39 @@ jerry_port_source_free (uint8_t *buffer_p) /**< buffer to free */
   free (buffer_p);
 } /* jerry_port_source_free */
 
+#if !defined(_WIN32)
+
+jerry_path_style_t
+jerry_port_path_style (void)
+{
+  return JERRY_PATH_STYLE_POSIX;
+} /* jerry_port_path_style */
+
+#endif /* !defined(_WIN32) */
+
 /**
  * These functions provide generic implementation for paths and are only enabled when the compiler support weak symbols,
  * and we are not building for a platform that has platform specific versions.
  */
 #if defined(JERRY_WEAK_SYMBOL_SUPPORT) && !(defined(__unix__) || defined(__APPLE__) || defined(_WIN32))
 
 /**
- * Normalize a file path.
- *
- * @return a newly allocated buffer with the normalized path if the operation is successful,
- *         NULL otherwise
+ * Default to `/`
  */
-jerry_char_t *JERRY_ATTR_WEAK
-jerry_port_path_normalize (const jerry_char_t *path_p, /**< input path */
-                           jerry_size_t path_size) /**< size of the path */
+jerry_size_t JERRY_ATTR_WEAK
+jerry_port_get_cwd (jerry_char_t *buffer_p, jerry_size_t buffer_size)
 {
-  jerry_char_t *buffer_p = (jerry_char_t *) malloc (path_size + 1);
-
   if (buffer_p == NULL)
   {
-    return NULL;
+    return 1;
   }
-
-  /* Also copy terminating zero byte. */
-  memcpy (buffer_p, path_p, path_size + 1);
-
-  return buffer_p;
-} /* jerry_port_path_normalize */
-
-/**
- * Free a path buffer returned by jerry_port_path_normalize.
- *
- * @param path_p: the path to free
- */
-void JERRY_ATTR_WEAK
-jerry_port_path_free (jerry_char_t *path_p)
-{
-  free (path_p);
-} /* jerry_port_path_free */
-
-/**
- * Computes the end of the directory part of a path.
- *
- * @return end of the directory part of a path.
- */
-jerry_size_t JERRY_ATTR_WEAK
-jerry_port_path_base (const jerry_char_t *path_p) /**< path */
-{
-  const jerry_char_t *basename_p = (jerry_char_t *) strrchr ((char *) path_p, '/') + 1;
-
-  if (basename_p == NULL)
+  if (buffer_size == 2)
   {
-    return 0;
+    path_p[0] = '/';
+    path_p[1] = '\0';
+    return 1;
   }
-
-  return (jerry_size_t) (basename_p - path_p);
-} /* jerry_port_get_directory_end */
+  return 0;
+} /* jerry_port_get_cwd */
 
 #endif /* defined(JERRY_WEAK_SYMBOL_SUPPORT) && !(defined(__unix__) || defined(__APPLE__) || defined(_WIN32)) */

jerry-port/common/jerry-port-fs.c

@@ -19,45 +19,42 @@
 
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
-/**
- * Normalize a file path using realpath.
- *
- * @param path_p: input path
- * @param path_size: input path size
- *
- * @return a newly allocated buffer with the normalized path if the operation is successful,
- *         NULL otherwise
- */
-jerry_char_t *
-jerry_port_path_normalize (const jerry_char_t *path_p, /**< input path */
-                           jerry_size_t path_size) /**< size of the path */
-{
-  (void) path_size;
-
-  return (jerry_char_t *) realpath ((char *) path_p, NULL);
-} /* jerry_port_path_normalize */
-
-/**
- * Free a path buffer returned by jerry_port_path_normalize.
- */
-void
-jerry_port_path_free (jerry_char_t *path_p)
-{
-  free (path_p);
-} /* jerry_port_path_free */
-
-/**
- * Computes the end of the directory part of a path.
- *
- * @return end of the directory part of a path.
- */
-jerry_size_t JERRY_ATTR_WEAK
-jerry_port_path_base (const jerry_char_t *path_p) /**< path */
+jerry_size_t
+jerry_port_get_cwd (jerry_char_t *buffer_p, jerry_size_t buffer_size)
 {
-  const jerry_char_t *basename_p = (jerry_char_t *) strrchr ((char *) path_p, '/') + 1;
-
-  return (jerry_size_t) (basename_p - path_p);
-} /* jerry_port_get_directory_end */
+  if (buffer_p == NULL)
+  {
+    jerry_size_t size = 260;
+    char *buf = NULL;
+    char *ptr = NULL;
+    for (; ptr == NULL; size *= 2)
+    {
+      if ((buf = realloc (buf, size)) == NULL)
+      {
+        break;
+      }
+      ptr = getcwd (buf, size);
+      if (ptr == NULL && errno != ERANGE)
+      {
+        break;
+      }
+    }
+    size = ptr ? (jerry_size_t) strlen (ptr) : 0;
+    if (buf)
+      free (buf);
+    return size;
+  }
+
+  if (getcwd ((char *) buffer_p, buffer_size) != NULL)
+  {
+    if ((strlen ((char *) buffer_p) + 1) == buffer_size)
+    {
+      return buffer_size - 1;
+    }
+  }
+  return 0;
+} /* jerry_port_get_cwd */
 
 #endif /* defined(__unix__) || defined(__APPLE__) */

jerry-port/unix/jerry-port-unix-fs.c

@@ -17,56 +17,50 @@
 
 #if defined(_WIN32)
 
+#include <direct.h>
 #include <stdlib.h>
 #include <string.h>
 
-/**
- * Normalize a file path.
- *
- * @return a newly allocated buffer with the normalized path if the operation is successful,
- *         NULL otherwise
- */
-jerry_char_t *
-jerry_port_path_normalize (const jerry_char_t *path_p, /**< input path */
-                           jerry_size_t path_size) /**< size of the path */
-{
-  (void) path_size;
-
-  return (jerry_char_t *) _fullpath (NULL, path_p, _MAX_PATH);
-} /* jerry_port_path_normalize */
-
-/**
- * Free a path buffer returned by jerry_port_path_normalize.
- */
-void
-jerry_port_path_free (jerry_char_t *path_p)
+jerry_path_style_t
+jerry_port_path_style (void)
 {
-  free (path_p);
-} /* jerry_port_path_free */
+  return JERRY_PATH_STYLE_WINDOWS;
+} /* jerry_port_path_style */
 
-/**
- * Get the end of the directory part of the input path.
- *
- * @param path_p: input zero-terminated path string
- *
- * @return offset of the directory end in the input path string
- */
 jerry_size_t
-jerry_port_path_base (const jerry_char_t *path_p)
+jerry_port_get_cwd (jerry_char_t *buffer_p, jerry_size_t buffer_size)
 {
-  const jerry_char_t *end_p = path_p + strlen ((const char *) path_p);
-
-  while (end_p > path_p)
+  if (buffer_p == NULL)
   {
-    if (end_p[-1] == '/' || end_p[-1] == '\\')
+    jerry_size_t size = _MAX_PATH;
+    char *buf = NULL;
+    char *ptr = NULL;
+    for (; ptr == NULL; size *= 2)
     {
-      return (jerry_size_t) (end_p - path_p);
+      if ((buf = realloc (buf, size)) == NULL)
+      {
+        break;
+      }
+      ptr = getcwd (buf, size);
+      if (ptr == NULL && errno != ERANGE)
+      {
+        break;
+      }
     }
-
-    end_p--;
+    size = ptr ? (jerry_size_t) strlen (ptr) : 0;
+    if (buf)
+      free (buf);
+    return size;
   }
 
+  if (getcwd ((char *) buffer_p, buffer_size) != NULL)
+  {
+    if ((strlen ((char *) buffer_p) + 1) == buffer_size)
+    {
+      return buffer_size - 1;
+    }
+  }
   return 0;
-} /* jerry_port_path_base */
+} /* jerry_port_get_cwd */
 
 #endif /* defined(_WIN32) */