/src/php-src/main/streams/stream_errors.c

Source
/*
   +----------------------------------------------------------------------+
   | Copyright (c) The PHP Group                                          |
   +----------------------------------------------------------------------+
   | This source file is subject to the Modified BSD License that is      |
   | bundled with this package in the file LICENSE, and is available      |
   | through the World Wide Web at <https://www.php.net/license/>.        |
   |                                                                      |
   | SPDX-License-Identifier: BSD-3-Clause                                |
   +----------------------------------------------------------------------+
   | Authors: Jakub Zelenka <bukka@php.net>                               |
   +----------------------------------------------------------------------+
 */

#define ZEND_ENUM_StreamErrorCode_USE_NAME_TABLE
#include "php.h"
#include "php_globals.h"
#include "php_streams.h"
#include "php_stream_errors.h"
#include "zend_enum.h"
#include "zend_exceptions.h"
#include "ext/standard/file.h"
#include "stream_errors_arginfo.h"

/* Class entries */
static zend_class_entry *php_ce_stream_error_code;
static zend_class_entry *php_ce_stream_error_mode;
static zend_class_entry *php_ce_stream_error_store;
static zend_class_entry *php_ce_stream_error;
static zend_class_entry *php_ce_stream_exception;

/* Forward declarations */
static void php_stream_error_entry_free(php_stream_error_entry *entry);

/* Helper to create a single StreamError object from an entry */
static void php_stream_error_create_object(zval *zv, const php_stream_error_entry *entry)
{
  object_init_ex(zv, php_ce_stream_error);

  const char *case_name = NULL;
  if (entry->code > 0 && entry->code <= ZEND_ENUM_StreamErrorCode_CASE_COUNT) {
    case_name = zend_enum_StreamErrorCode_case_names[entry->code];
  }
  if (!case_name) {
    case_name = "Generic";
  }

  /* TODO: migrate to zend_enum_get_case_by_id() */
  zend_object *enum_obj = zend_enum_get_case_cstr(php_ce_stream_error_code, case_name);
  ZEND_ASSERT(enum_obj != NULL);

  zval code_enum;
  ZVAL_OBJ_COPY(&code_enum, enum_obj);

  zend_update_property(php_ce_stream_error, Z_OBJ_P(zv), ZEND_STRL("code"), &code_enum);
  zval_ptr_dtor(&code_enum);

  zend_update_property_str(
      php_ce_stream_error, Z_OBJ_P(zv), ZEND_STRL("message"), entry->message);

  zend_update_property_string(php_ce_stream_error, Z_OBJ_P(zv), ZEND_STRL("wrapperName"),
      entry->wrapper_name ? entry->wrapper_name : "");

  zend_update_property_long(
      php_ce_stream_error, Z_OBJ_P(zv), ZEND_STRL("severity"), entry->severity);

  zend_update_property_bool(
      php_ce_stream_error, Z_OBJ_P(zv), ZEND_STRL("terminating"), entry->terminating);
}

/* Create array of StreamError objects from error chain */
static void php_stream_error_create_array(zval *zv, const php_stream_error_entry *first)
{
  array_init(zv);

  const php_stream_error_entry *entry = first;
  while (entry) {
    zval error_obj;
    php_stream_error_create_object(&error_obj, entry);
    zend_hash_next_index_insert_new(Z_ARRVAL_P(zv), &error_obj);
    entry = entry->next;
  }
}

/* Context option helpers */
/* Error mode context options (internal C constants) */
C23_ENUM(php_stream_error_mode, uint8_t) {
  PHP_STREAM_ERROR_MODE_ERROR = 0,
  PHP_STREAM_ERROR_MODE_EXCEPTION = 1,
  PHP_STREAM_ERROR_MODE_SILENT = 2
};

/* Error store context options (internal C constants) */
C23_ENUM(php_stream_error_store, uint8_t) {
  PHP_STREAM_ERROR_STORE_AUTO = 0,
  PHP_STREAM_ERROR_STORE_NONE = 1,
  PHP_STREAM_ERROR_STORE_NON_TERM = 2,
  PHP_STREAM_ERROR_STORE_TERMINAL = 3,
  PHP_STREAM_ERROR_STORE_ALL = 4
};

static php_stream_error_store php_stream_auto_decide_error_store_mode(php_stream_error_mode error_mode)
{
  switch (error_mode) {
    case PHP_STREAM_ERROR_MODE_ERROR:
      return PHP_STREAM_ERROR_STORE_NONE;
    case PHP_STREAM_ERROR_MODE_EXCEPTION:
      return PHP_STREAM_ERROR_STORE_NON_TERM;
    case PHP_STREAM_ERROR_MODE_SILENT:
      return PHP_STREAM_ERROR_STORE_ALL;
    default:
      return PHP_STREAM_ERROR_STORE_NONE;
  }
}

static php_stream_error_mode php_stream_get_error_mode(const php_stream_context *context)
{
  if (!context) {
    return PHP_STREAM_ERROR_MODE_ERROR;
  }

  zval *option = php_stream_context_get_option(context, "stream", "error_mode");
  if (!option) {
    return PHP_STREAM_ERROR_MODE_ERROR;
  }

  if (Z_TYPE_P(option) != IS_OBJECT
      || !instanceof_function(Z_OBJCE_P(option), php_ce_stream_error_mode)) {
    zend_type_error("stream context option 'error_mode' must be of type StreamErrorMode");
    return PHP_STREAM_ERROR_MODE_ERROR;
  }

  switch ((zend_enum_StreamErrorMode) zend_enum_fetch_case_id(Z_OBJ_P(option))) {
    case ZEND_ENUM_StreamErrorMode_Error:
      return PHP_STREAM_ERROR_MODE_ERROR;
    case ZEND_ENUM_StreamErrorMode_Exception:
      return PHP_STREAM_ERROR_MODE_EXCEPTION;
    case ZEND_ENUM_StreamErrorMode_Silent:
      return PHP_STREAM_ERROR_MODE_SILENT;
  }

  return PHP_STREAM_ERROR_MODE_ERROR;
}

static php_stream_error_store php_stream_get_error_store_mode(
  const php_stream_context *context, php_stream_error_mode error_mode)
{
  if (!context) {
    return php_stream_auto_decide_error_store_mode(error_mode);
  }

  zval *option = php_stream_context_get_option(context, "stream", "error_store");
  if (!option) {
    return php_stream_auto_decide_error_store_mode(error_mode);
  }

  if (Z_TYPE_P(option) != IS_OBJECT
      || !instanceof_function(Z_OBJCE_P(option), php_ce_stream_error_store)) {
    zend_type_error("stream context option 'error_store' must be of type StreamErrorStore");
    return php_stream_auto_decide_error_store_mode(error_mode);
  }

  switch ((zend_enum_StreamErrorStore) zend_enum_fetch_case_id(Z_OBJ_P(option))) {
    case ZEND_ENUM_StreamErrorStore_Auto:
      return php_stream_auto_decide_error_store_mode(error_mode);
    case ZEND_ENUM_StreamErrorStore_None:
      return PHP_STREAM_ERROR_STORE_NONE;
    case ZEND_ENUM_StreamErrorStore_NonTerminating:
      return PHP_STREAM_ERROR_STORE_NON_TERM;
    case ZEND_ENUM_StreamErrorStore_Terminating:
      return PHP_STREAM_ERROR_STORE_TERMINAL;
    case ZEND_ENUM_StreamErrorStore_All:
      return PHP_STREAM_ERROR_STORE_ALL;
  }

  return php_stream_auto_decide_error_store_mode(error_mode);
}

/* Helper functions */

static bool php_stream_has_terminating_error(const php_stream_error_operation *op)
{
  const php_stream_error_entry *entry = op->first_error;
  while (entry) {
    if (entry->terminating) {
      return true;
    }
    entry = entry->next;
  }
  return false;
}

static inline php_stream_error_operation *php_stream_get_operation_at_depth(uint32_t depth)
{
  php_stream_error_state *state = &FG(stream_error_state);

  if (depth < PHP_STREAM_ERROR_OPERATION_POOL_SIZE) {
    return &state->operation_pool[depth];
  } else {
    uint32_t overflow_index = depth - PHP_STREAM_ERROR_OPERATION_POOL_SIZE;
    ZEND_ASSERT(overflow_index < state->overflow_capacity);
    return &state->overflow_operations[overflow_index];
  }
}

static inline php_stream_error_operation *php_stream_get_parent_operation(void)
{
  const php_stream_error_state *state = &FG(stream_error_state);

  if (state->operation_depth <= 1) {
    return NULL;
  }

  return php_stream_get_operation_at_depth(state->operation_depth - 2);
}

/* Clean up functions */

static void php_stream_error_entry_free(php_stream_error_entry *entry)
{
  while (entry) {
    php_stream_error_entry *next = entry->next;
    zend_string_release(entry->message);
    efree(entry->wrapper_name);
    efree(entry->docref);
    efree(entry);
    entry = next;
  }
}

PHPAPI void php_stream_error_state_cleanup(void)
{
  php_stream_error_state *state = &FG(stream_error_state);

  while (state->current_operation) {
    php_stream_error_operation *op = state->current_operation;
    state->operation_depth--;
    state->current_operation = php_stream_get_parent_operation();

    php_stream_error_entry_free(op->first_error);

    op->first_error = NULL;
    op->last_error = NULL;
    op->error_count = 0;
  }

  php_stream_stored_error *stored = state->stored_errors;
  while (stored) {
    php_stream_stored_error *next = stored->next;
    php_stream_error_entry_free(stored->first_error);
    efree(stored);
    stored = next;
  }

  state->stored_errors = NULL;
  state->stored_count = 0;
  state->operation_depth = 0;

  if (state->overflow_operations) {
    efree(state->overflow_operations);
    state->overflow_operations = NULL;
    state->overflow_capacity = 0;
  }
}

PHPAPI void php_stream_error_get_last(zval *return_value)
{
  const php_stream_error_state *state = &FG(stream_error_state);

  if (!state->stored_errors) {
    ZVAL_EMPTY_ARRAY(return_value);
    return;
  }

  php_stream_error_create_array(return_value, state->stored_errors->first_error);
}

PHPAPI void php_stream_error_clear_stored(void)
{
  php_stream_error_state *state = &FG(stream_error_state);

  php_stream_stored_error *stored = state->stored_errors;
  while (stored) {
    php_stream_stored_error *next = stored->next;
    php_stream_error_entry_free(stored->first_error);
    efree(stored);
    stored = next;
  }

  state->stored_errors = NULL;
  state->stored_count = 0;
}

/* Error operation stack management */

PHPAPI php_stream_error_operation *php_stream_error_operation_begin(void)
{
  php_stream_error_state *state = &FG(stream_error_state);

  if (state->operation_depth >= PHP_STREAM_ERROR_MAX_DEPTH) {
    php_error_docref(NULL, E_WARNING,
        "Stream error operation depth exceeded (%"PRIu32"), possible infinite recursion",
        state->operation_depth);
    return NULL;
  }

  php_stream_error_operation *op;

  if (state->operation_depth < PHP_STREAM_ERROR_OPERATION_POOL_SIZE) {
    op = &state->operation_pool[state->operation_depth];
  } else {
    uint32_t overflow_index = state->operation_depth - PHP_STREAM_ERROR_OPERATION_POOL_SIZE;

    if (overflow_index >= state->overflow_capacity) {
      uint32_t new_capacity
          = state->overflow_capacity == 0 ? 8 : state->overflow_capacity * 2;
      php_stream_error_operation *new_overflow = erealloc(
          state->overflow_operations, sizeof(php_stream_error_operation) * new_capacity);
      state->overflow_operations = new_overflow;
      state->overflow_capacity = new_capacity;
    }

    op = &state->overflow_operations[overflow_index];
  }

  op->first_error = NULL;
  op->last_error = NULL;
  op->error_count = 0;

  state->current_operation = op;
  state->operation_depth++;

  return op;
}

static void php_stream_error_add(zend_enum_StreamErrorCode code, const char *wrapper_name,
    zend_string *message, const char *docref, int severity, bool terminating)
{
  php_stream_error_operation *op = FG(stream_error_state).current_operation;
  ZEND_ASSERT(op != NULL);

  php_stream_error_entry *entry = emalloc(sizeof(php_stream_error_entry));
  entry->message = message;
  entry->code = code;
  entry->wrapper_name = wrapper_name ? estrdup(wrapper_name) : NULL;
  entry->docref = docref ? estrdup(docref) : NULL;
  entry->severity = severity;
  entry->terminating = terminating;
  entry->next = NULL;

  if (op->last_error) {
    op->last_error->next = entry;
  } else {
    op->first_error = entry;
  }
  op->last_error = entry;
  op->error_count++;
}

/* Error reporting */

static void php_stream_call_error_handler(const zval *handler, zval *errors_array)
{
  zend_fcall_info_cache fcc;
  char *is_callable_error = NULL;

  if (!zend_is_callable_ex(handler, NULL, 0, NULL, &fcc, &is_callable_error)) {
    if (is_callable_error) {
      zend_type_error("stream error handler must be a valid callback, %s", is_callable_error);
      efree(is_callable_error);
    }
    return;
  }

  zend_call_known_fcc(&fcc, NULL, 1, errors_array, NULL);
}

static void php_stream_throw_exception_with_errors(const php_stream_error_operation *op)
{
  if (!op->first_error) {
    return;
  }

  zval ex;
  object_init_ex(&ex, php_ce_stream_exception);

  /* Set message from first error */
  zend_update_property_str(php_ce_stream_exception, Z_OBJ(ex), ZEND_STRL("message"),
      op->first_error->message);

  /* Set code from first error */
  zend_update_property_long(php_ce_stream_exception, Z_OBJ(ex), ZEND_STRL("code"),
      (zend_long) op->first_error->code);

  /* Build errors array and set it */
  zval errors_array;
  php_stream_error_create_array(&errors_array, op->first_error);
  zend_update_property(php_ce_stream_exception, Z_OBJ(ex), ZEND_STRL("errors"), &errors_array);
  zval_ptr_dtor(&errors_array);

  zend_throw_exception_object(&ex);
}

static void php_stream_report_errors(const php_stream_context *context, const php_stream_error_operation *op,
    php_stream_error_mode error_mode, bool is_terminating)
{
  switch (error_mode) {
    case PHP_STREAM_ERROR_MODE_ERROR: {
      const php_stream_error_entry *entry = op->first_error;
      while (entry) {
        php_error_docref(entry->docref, entry->severity, "%s", ZSTR_VAL(entry->message));
        entry = entry->next;
      }
      break;
    }

    case PHP_STREAM_ERROR_MODE_EXCEPTION: {
      if (is_terminating) {
        php_stream_throw_exception_with_errors(op);
      }
      break;
    }

    case PHP_STREAM_ERROR_MODE_SILENT:
      break;
  }

  /* Call user error handler if set */
  const zval *handler
      = context ? php_stream_context_get_option(context, "stream", "error_handler") : NULL;

  if (handler) {
    zval errors_array;
    php_stream_error_create_array(&errors_array, op->first_error);

    php_stream_call_error_handler(handler, &errors_array);

    zval_ptr_dtor(&errors_array);
  }
}

/* Error storage */

PHPAPI void php_stream_error_operation_end(const php_stream_context *context)
{
  php_stream_error_state *state = &FG(stream_error_state);
  php_stream_error_operation *op = state->current_operation;

  if (!op) {
    return;
  }

  if (op->error_count > 0) {
    if (context == NULL) {
      context = FG(default_context);
    }

    php_stream_error_mode error_mode = php_stream_get_error_mode(context);
    php_stream_error_store store_mode = php_stream_get_error_store_mode(context, error_mode);

    bool is_terminating = php_stream_has_terminating_error(op);

    php_stream_report_errors(context, op, error_mode, is_terminating);

    if (store_mode == PHP_STREAM_ERROR_STORE_NONE) {
      php_stream_error_entry_free(op->first_error);
      op->first_error = NULL;
    } else {
      php_stream_error_entry *entry = op->first_error;
      php_stream_error_entry *prev = NULL;
      php_stream_error_entry *to_store_first = NULL;
      php_stream_error_entry *to_store_last = NULL;
      uint32_t to_store_count = 0;
      php_stream_error_entry *remaining_first = NULL;

      while (entry) {
        php_stream_error_entry *next = entry->next;
        bool should_store = false;

        if (store_mode == PHP_STREAM_ERROR_STORE_ALL) {
          should_store = true;
        } else if (store_mode == PHP_STREAM_ERROR_STORE_NON_TERM && !entry->terminating) {
          should_store = true;
        } else if (store_mode == PHP_STREAM_ERROR_STORE_TERMINAL && entry->terminating) {
          should_store = true;
        }

        if (should_store) {
          entry->next = NULL;
          if (to_store_last) {
            to_store_last->next = entry;
          } else {
            to_store_first = entry;
          }
          to_store_last = entry;
          to_store_count++;
        } else {
          entry->next = NULL;
          if (prev) {
            prev->next = entry;
          } else {
            remaining_first = entry;
          }
          prev = entry;
        }

        entry = next;
      }

      if (to_store_first) {
        php_stream_stored_error *stored = emalloc(sizeof(php_stream_stored_error));
        stored->first_error = to_store_first;
        stored->error_count = to_store_count;
        stored->next = state->stored_errors;

        state->stored_errors = stored;
        state->stored_count++;
      }

      if (remaining_first) {
        php_stream_error_entry_free(remaining_first);
      }

      op->first_error = NULL;
    }
  }

  state->operation_depth--;
  state->current_operation = php_stream_get_parent_operation();

  op->first_error = NULL;
  op->last_error = NULL;
  op->error_count = 0;
}

PHPAPI void php_stream_error_operation_end_for_stream(const php_stream *stream)
{
  php_stream_error_state *state = &FG(stream_error_state);
  php_stream_error_operation *op = state->current_operation;

  if (!op) {
    return;
  }

  if (op->error_count == 0) {
    state->operation_depth--;
    state->current_operation = php_stream_get_parent_operation();

    op->first_error = NULL;
    op->last_error = NULL;
    return;
  }

  const php_stream_context *context = PHP_STREAM_CONTEXT(stream);
  php_stream_error_operation_end(context);
}

PHPAPI void php_stream_error_operation_abort(void)
{
  php_stream_error_state *state = &FG(stream_error_state);
  php_stream_error_operation *op = state->current_operation;

  if (!op) {
    return;
  }

  state->operation_depth--;
  state->current_operation = php_stream_get_parent_operation();

  php_stream_error_entry_free(op->first_error);
  op->first_error = NULL;
  op->last_error = NULL;
  op->error_count = 0;
}

/* Wrapper error reporting */

static void php_stream_wrapper_error_internal(const char *wrapper_name, const php_stream_context *context,
    const char *docref, int severity, bool terminating,
    zend_enum_StreamErrorCode code, zend_string *message)
{
  bool implicit_operation = (FG(stream_error_state).current_operation == NULL);
  if (implicit_operation) {
    php_stream_error_operation_begin();
  }

  php_stream_error_add(code, wrapper_name, message, docref, severity, terminating);

  if (implicit_operation) {
    php_stream_error_operation_end(context);
  }
}

PHPAPI void php_stream_wrapper_error_with_name(const char *wrapper_name,
    const php_stream_context *context, const char *docref, int options, int severity,
    bool terminating, zend_enum_StreamErrorCode code, const char *fmt, ...)
{
  if (!(options & REPORT_ERRORS)) {
    return;
  }

  va_list args;
  va_start(args, fmt);
  zend_string *message = vstrpprintf(0, fmt, args);
  va_end(args);

  php_stream_wrapper_error_internal(
      wrapper_name, context, docref, severity, terminating, code, message);
}

PHPAPI void php_stream_wrapper_error(
    const php_stream_wrapper *wrapper,
    const php_stream_context *context,
    const char *docref, int options, int severity, bool terminating,
    zend_enum_StreamErrorCode code, const char *fmt, ...)
{
  if (!(options & REPORT_ERRORS)) {
    return;
  }

  va_list args;
  va_start(args, fmt);
  zend_string *message = vstrpprintf(0, fmt, args);
  va_end(args);

  const char *wrapper_name = PHP_STREAM_ERROR_WRAPPER_NAME(wrapper);

  php_stream_wrapper_error_internal(
      wrapper_name, context, docref, severity, terminating, code, message);
}

/* Stream error reporting */

PHPAPI void php_stream_error(const php_stream *stream, const char *docref, int severity,
    bool terminating, zend_enum_StreamErrorCode code, const char *fmt, ...)
{
  va_list args;
  va_start(args, fmt);

  zend_string *message = vstrpprintf(0, fmt, args);
  va_end(args);

  const char *wrapper_name = stream->wrapper ? stream->wrapper->wops->label : "stream";

  const php_stream_context *context = PHP_STREAM_CONTEXT(stream);

  php_stream_wrapper_error_internal(wrapper_name, context, docref, severity,
      terminating, code, message);
}

/* Legacy wrapper error logging */

static void php_stream_error_entry_dtor_legacy(void *error)
{
  php_stream_error_entry *entry = *(php_stream_error_entry **) error;
  zend_string_release(entry->message);
  efree(entry->wrapper_name);
  efree(entry->docref);
  efree(entry);
}

static void php_stream_error_list_dtor(zval *item)
{
  zend_llist *list = (zend_llist *) Z_PTR_P(item);
  zend_llist_destroy(list);
  efree(list);
}

static void php_stream_wrapper_log_store_error(zend_string *message, zend_enum_StreamErrorCode code,
    const char *wrapper_name, int severity, bool terminating)
{
  php_stream_error_entry *entry = ecalloc(1, sizeof(php_stream_error_entry));
  entry->message = message;
  entry->code = code;
  entry->wrapper_name = wrapper_name ? estrdup(wrapper_name) : NULL;
  entry->severity = severity;
  entry->terminating = terminating;

  if (!FG(wrapper_logged_errors)) {
    ALLOC_HASHTABLE(FG(wrapper_logged_errors));
    zend_hash_init(FG(wrapper_logged_errors), 8, NULL, php_stream_error_list_dtor, 0);
  }

  zend_llist *list
      = zend_hash_str_find_ptr(FG(wrapper_logged_errors), wrapper_name, strlen(wrapper_name));

  if (!list) {
    zend_llist new_list;
    zend_llist_init(
        &new_list, sizeof(php_stream_error_entry *), php_stream_error_entry_dtor_legacy, 0);
    list = zend_hash_str_update_mem(FG(wrapper_logged_errors), wrapper_name,
        strlen(wrapper_name), &new_list, sizeof(new_list));
  }

  zend_llist_add_element(list, &entry);
}

PHPAPI void php_stream_wrapper_log_error(const php_stream_wrapper *wrapper,
    const php_stream_context *context, int options, int severity, bool terminating,
    zend_enum_StreamErrorCode code, const char *fmt, ...)
{
  va_list args;
  va_start(args, fmt);
  zend_string *message = vstrpprintf(0, fmt, args);
  const char *wrapper_name = PHP_STREAM_ERROR_WRAPPER_NAME(wrapper);

  if (options & REPORT_ERRORS) {
    php_stream_wrapper_error_internal(
        wrapper_name, context, NULL, severity, terminating, code, message);
  } else {
    php_stream_wrapper_log_store_error(
        message, code, wrapper_name, severity, terminating);
  }
  va_end(args);
}

static zend_llist *php_stream_get_wrapper_errors_list(const char *wrapper_name)
{
  if (!FG(wrapper_logged_errors)) {
    return NULL;
  }
  return (zend_llist *) zend_hash_str_find_ptr(
      FG(wrapper_logged_errors), wrapper_name, strlen(wrapper_name));
}

PHPAPI void php_stream_display_wrapper_name_errors(const char *wrapper_name,
    const php_stream_context *context, zend_enum_StreamErrorCode code,
    const char *caption)
{
  char *msg;
  char errstr[256];
  bool free_msg = false;

  if (EG(exception)) {
    return;
  }

  if (strcmp(wrapper_name, PHP_STREAM_ERROR_WRAPPER_DEFAULT_NAME)) {
    zend_llist *err_list = php_stream_get_wrapper_errors_list(wrapper_name);
    if (err_list) {
      size_t l = 0;
      size_t brlen;
      const char *br;
      php_stream_error_entry **err_entry_p;
      zend_llist_position pos;

      if (PG(html_errors)) {
        brlen = 7;
        br = "<br />\n";
      } else {
        brlen = 1;
        br = "\n";
      }

      size_t i = 0;
      const size_t count = zend_llist_count(err_list);
      for (i = 0, err_entry_p = zend_llist_get_first_ex(err_list, &pos); err_entry_p;
          err_entry_p = zend_llist_get_next_ex(err_list, &pos), i++) {
        l += ZSTR_LEN((*err_entry_p)->message);
        if (i < count - 1) {
          l += brlen;
        }
      }
      msg = emalloc(l + 1);
      msg[0] = '\0';
      for (err_entry_p = zend_llist_get_first_ex(err_list, &pos), i = 0; err_entry_p;
          err_entry_p = zend_llist_get_next_ex(err_list, &pos), i++) {
        strcat(msg, ZSTR_VAL((*err_entry_p)->message));
        if (i < count - 1) {
          strcat(msg, br);
        }
      }

      free_msg = true;
    } else {
      if (!strcmp(wrapper_name, php_plain_files_wrapper.wops->label)) {
        msg = php_socket_strerror_s(errno, errstr, sizeof(errstr));
      } else {
        msg = "operation failed";
      }
    }
  } else {
    msg = "no suitable wrapper could be found";
  }

  zend_string *message = strpprintf(0, "%s: %s", caption, msg);

  php_stream_wrapper_error_internal(wrapper_name, context, NULL, E_WARNING, true,
      code, message);

  if (free_msg) {
    efree(msg);
  }
}

PHPAPI void php_stream_display_wrapper_errors(const php_stream_wrapper *wrapper,
    const php_stream_context *context, zend_enum_StreamErrorCode code,
    const char *caption)
{
  if (wrapper) {
    const char *wrapper_name = PHP_STREAM_ERROR_WRAPPER_NAME(wrapper);
    php_stream_display_wrapper_name_errors(wrapper_name, context, code, caption);
  }
}

PHPAPI void php_stream_tidy_wrapper_name_error_log(const char *wrapper_name)
{
  if (FG(wrapper_logged_errors)) {
    zend_hash_str_del(FG(wrapper_logged_errors), wrapper_name, strlen(wrapper_name));
  }
}

PHPAPI void php_stream_tidy_wrapper_error_log(const php_stream_wrapper *wrapper)
{
  if (wrapper) {
    const char *wrapper_name = PHP_STREAM_ERROR_WRAPPER_NAME(wrapper);
    php_stream_tidy_wrapper_name_error_log(wrapper_name);
  }
}

/* StreamException methods */

PHP_METHOD(StreamException, getErrors)
{
  ZEND_PARSE_PARAMETERS_NONE();

  const zval *errors = zend_read_property(
      php_ce_stream_exception, Z_OBJ_P(ZEND_THIS), ZEND_STRL("errors"), 1, NULL);

  RETURN_COPY(errors);
}

/* Module init */

PHP_MINIT_FUNCTION(stream_errors)
{
  php_ce_stream_error_code = register_class_StreamErrorCode();
  php_ce_stream_error_mode = register_class_StreamErrorMode();
  php_ce_stream_error_store = register_class_StreamErrorStore();

  php_ce_stream_error = register_class_StreamError();
  php_ce_stream_exception = register_class_StreamException(zend_ce_exception);

  return SUCCESS;
}

PHP_MSHUTDOWN_FUNCTION(stream_errors)
{
  return SUCCESS;
}

Coverage Report

Created: 2026-09-14 06:25