io.c File Reference

IO capture implementation. More...

Go to the source code of this file.

Macros
#define	LOG_IO_BUFFER_SIZE   8192

Functions
log_io_t	log_io_start (void)
	Start capturing stdout and stderr.
void	log_io_stop (log_io_t capture, const char *prefix)
	Stop capturing and log the accumulated output.

Detailed Description

IO capture implementation.

Definition in file io.c.

Macro Definition Documentation

LOG_IO_BUFFER_SIZE

#define LOG_IO_BUFFER_SIZE   8192

Definition at line 13 of file io.c.

Referenced by log_io_stop().

Function Documentation

log_io_start()

log_io_t log_io_start

(

void

)

Start capturing stdout and stderr.

Redirects both stdout and stderr to a temporary file so their output can be captured and logged. Call log_io_stop() to end capture and log the accumulated output.

Returns

Capture handle (use with log_io_stop)

Note

If capture fails, returns a handle with saved_stdout_fd = -1

Do not use stdout/stderr directly while capturing

Definition at line 15 of file io.c.

                            {
  log_io_t capture = {.saved_stdout_fd = -1, .saved_stderr_fd = -1, .output = NULL};
 
  // A pipe cannot be drained until the wrapped call returns. A temporary file
  // lets backend worker threads finish even when diagnostics exceed pipe capacity.
  capture.output = platform_tmpfile();
  if (!capture.output)
    return capture;
 
  fflush(stdout);
  fflush(stderr);
  capture.saved_stdout_fd = platform_dup(STDOUT_FILENO);
  capture.saved_stderr_fd = platform_dup(STDERR_FILENO);
  if (capture.saved_stdout_fd < 0 || capture.saved_stderr_fd < 0)
    goto fail;
 
  int output_fd = platform_fileno(capture.output);
  if (platform_dup2(output_fd, STDOUT_FILENO) != ASCIICHAT_OK)
    goto fail;
  if (platform_dup2(output_fd, STDERR_FILENO) != ASCIICHAT_OK) {
    // Restore stdout if only the first redirection succeeded.
    platform_dup2(capture.saved_stdout_fd, STDOUT_FILENO);
    goto fail;
  }
  return capture;
 
fail:
  if (capture.saved_stdout_fd >= 0)
    platform_close(capture.saved_stdout_fd);
  if (capture.saved_stderr_fd >= 0)
    platform_close(capture.saved_stderr_fd);
  fclose(capture.output);
  return (log_io_t){.saved_stdout_fd = -1, .saved_stderr_fd = -1, .output = NULL};
}

References ASCIICHAT_OK, log_io_t::output, platform_dup(), platform_dup2(), platform_fileno(), log_io_t::saved_stderr_fd, and log_io_t::saved_stdout_fd.

log_io_stop()

void log_io_stop	(	log_io_t	capture,
		const char *	prefix )

Stop capturing and log the accumulated output.

Restores stdout and stderr to their original state, reads all captured output from the temporary file, and logs it at DEBUG level with the given prefix.

Parameters

capture	Capture handle returned by log_io_start()
prefix	Prefix to use in log messages (e.g., "ffmpeg", "portaudio")

Note

Safe to call with invalid handle (saved_stdout_fd = -1)

After calling this, the capture handle is invalidated

Definition at line 50 of file io.c.

                                                       {
  if (capture.saved_stdout_fd < 0 || capture.saved_stderr_fd < 0) {
    return; // Capture was not started successfully
  }
 
  // Flush before restoring so buffered backend output is captured.
  fflush(stdout);
  fflush(stderr);
 
  // Restore stdout and stderr
  platform_dup2(capture.saved_stdout_fd, STDOUT_FILENO);
  platform_dup2(capture.saved_stderr_fd, STDERR_FILENO);
  platform_close(capture.saved_stdout_fd);
  platform_close(capture.saved_stderr_fd);
 
  // Read and log the captured output
  if (capture.output) {
    char buffer[LOG_IO_BUFFER_SIZE];
    size_t bytes_read;
 
    // Replay only after restoring the descriptors, so logger output cannot feed
    // back into this capture. fseek synchronizes the stream with descriptor writes.
    if (fseek(capture.output, 0, SEEK_SET) != 0) {
      fclose(capture.output);
      return;
    }
    while ((bytes_read = fread(buffer, 1, sizeof(buffer) - 1, capture.output)) > 0) {
      buffer[bytes_read] = '\0';
 
      // Split by lines and log each line
      char *line_start = buffer;
      char *line_end;
 
      while ((line_end = strchr(line_start, '\n')) != NULL) {
        // Null-terminate the line (overwriting the newline)
        *line_end = '\0';
 
        // Log the line if it's not empty
        if (line_start[0] != '\0') {
          if (prefix) {
            log_debug("[%s] %s", prefix, line_start);
          } else {
            log_debug("%s", line_start);
          }
        }
 
        // Move to the next line
        line_start = line_end + 1;
      }
 
      // Log any remaining partial line
      if (line_start[0] != '\0') {
        if (prefix) {
          log_debug("[%s] %s", prefix, line_start);
        } else {
          log_debug("%s", line_start);
        }
      }
    }
 
    fclose(capture.output);
  }
}

References log_debug, LOG_IO_BUFFER_SIZE, log_io_t::output, platform_dup2(), log_io_t::saved_stderr_fd, and log_io_t::saved_stdout_fd.