/src/tmux/file.c

Source (jump to first uncovered line)
/* $OpenBSD$ */

/*
 * Copyright (c) 2019 Nicholas Marriott <nicholas.marriott@gmail.com>
 *
 * Permission to use, copy, modify, and 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 MIND, 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.
 */

#include <sys/types.h>

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "tmux.h"

/*
 * IPC file handling. Both client and server use the same data structures
 * (client_file and client_files) to store list of active files. Most functions
 * are for use either in client or server but not both.
 */

static int  file_next_stream = 3;

RB_GENERATE(client_files, client_file, entry, file_cmp);

/* Get path for file, either as given or from working directory. */
static char *
file_get_path(struct client *c, const char *file)
{
  char  *path;

  if (*file == '/')
    path = xstrdup(file);
  else
    xasprintf(&path, "%s/%s", server_client_get_cwd(c, NULL), file);
  return (path);
}

/* Tree comparison function. */
int
file_cmp(struct client_file *cf1, struct client_file *cf2)
{
  if (cf1->stream < cf2->stream)
    return (-1);
  if (cf1->stream > cf2->stream)
    return (1);
  return (0);
}

/*
 * Create a file object in the client process - the peer is the server to send
 * messages to. Check callback is fired when the file is finished with so the
 * process can decide if it needs to exit (if it is waiting for files to
 * flush).
 */
struct client_file *
file_create_with_peer(struct tmuxpeer *peer, struct client_files *files,
    int stream, client_file_cb cb, void *cbdata)
{
  struct client_file  *cf;

  cf = xcalloc(1, sizeof *cf);
  cf->c = NULL;
  cf->references = 1;
  cf->stream = stream;

  cf->buffer = evbuffer_new();
  if (cf->buffer == NULL)
    fatalx("out of memory");

  cf->cb = cb;
  cf->data = cbdata;

  cf->peer = peer;
  cf->tree = files;
  RB_INSERT(client_files, files, cf);

  return (cf);
}

/* Create a file object in the server, communicating with the given client. */
struct client_file *
file_create_with_client(struct client *c, int stream, client_file_cb cb,
    void *cbdata)
{
  struct client_file  *cf;

  if (c != NULL && (c->flags & CLIENT_ATTACHED))
    c = NULL;

  cf = xcalloc(1, sizeof *cf);
  cf->c = c;
  cf->references = 1;
  cf->stream = stream;

  cf->buffer = evbuffer_new();
  if (cf->buffer == NULL)
    fatalx("out of memory");

  cf->cb = cb;
  cf->data = cbdata;

  if (cf->c != NULL) {
    cf->peer = cf->c->peer;
    cf->tree = &cf->c->files;
    RB_INSERT(client_files, &cf->c->files, cf);
    cf->c->references++;
  }

  return (cf);
}

/* Free a file. */
void
file_free(struct client_file *cf)
{
  if (--cf->references != 0)
    return;

  evbuffer_free(cf->buffer);
  free(cf->path);

  if (cf->tree != NULL)
    RB_REMOVE(client_files, cf->tree, cf);
  if (cf->c != NULL)
    server_client_unref(cf->c);

  free(cf);
}

/* Event to fire the done callback. */
static void
file_fire_done_cb(__unused int fd, __unused short events, void *arg)
{
  struct client_file  *cf = arg;
  struct client   *c = cf->c;

  if (cf->cb != NULL &&
      (cf->closed || c == NULL || (~c->flags & CLIENT_DEAD)))
    cf->cb(c, cf->path, cf->error, 1, cf->buffer, cf->data);
  file_free(cf);
}

/* Add an event to fire the done callback (used by the server). */
void
file_fire_done(struct client_file *cf)
{
  event_once(-1, EV_TIMEOUT, file_fire_done_cb, cf, NULL);
}

/* Fire the read callback. */
void
file_fire_read(struct client_file *cf)
{
  if (cf->cb != NULL)
    cf->cb(cf->c, cf->path, cf->error, 0, cf->buffer, cf->data);
}

/* Can this file be printed to? */
int
file_can_print(struct client *c)
{
  if (c == NULL ||
      (c->flags & CLIENT_ATTACHED) ||
      (c->flags & CLIENT_CONTROL))
    return (0);
  return (1);
}

/* Print a message to a file. */
void
file_print(struct client *c, const char *fmt, ...)
{
  va_list ap;

  va_start(ap, fmt);
  file_vprint(c, fmt, ap);
  va_end(ap);
}

/* Print a message to a file. */
void
file_vprint(struct client *c, const char *fmt, va_list ap)
{
  struct client_file   find, *cf;
  struct msg_write_open  msg;

  if (!file_can_print(c))
    return;

  find.stream = 1;
  if ((cf = RB_FIND(client_files, &c->files, &find)) == NULL) {
    cf = file_create_with_client(c, 1, NULL, NULL);
    cf->path = xstrdup("-");

    evbuffer_add_vprintf(cf->buffer, fmt, ap);

    msg.stream = 1;
    msg.fd = STDOUT_FILENO;
    msg.flags = 0;
    proc_send(c->peer, MSG_WRITE_OPEN, -1, &msg, sizeof msg);
  } else {
    evbuffer_add_vprintf(cf->buffer, fmt, ap);
    file_push(cf);
  }
}

/* Print a buffer to a file. */
void
file_print_buffer(struct client *c, void *data, size_t size)
{
  struct client_file   find, *cf;
  struct msg_write_open  msg;

  if (!file_can_print(c))
    return;

  find.stream = 1;
  if ((cf = RB_FIND(client_files, &c->files, &find)) == NULL) {
    cf = file_create_with_client(c, 1, NULL, NULL);
    cf->path = xstrdup("-");

    evbuffer_add(cf->buffer, data, size);

    msg.stream = 1;
    msg.fd = STDOUT_FILENO;
    msg.flags = 0;
    proc_send(c->peer, MSG_WRITE_OPEN, -1, &msg, sizeof msg);
  } else {
    evbuffer_add(cf->buffer, data, size);
    file_push(cf);
  }
}

/* Report an error to a file. */
void
file_error(struct client *c, const char *fmt, ...)
{
  struct client_file   find, *cf;
  struct msg_write_open  msg;
  va_list      ap;

  if (!file_can_print(c))
    return;

  va_start(ap, fmt);

  find.stream = 2;
  if ((cf = RB_FIND(client_files, &c->files, &find)) == NULL) {
    cf = file_create_with_client(c, 2, NULL, NULL);
    cf->path = xstrdup("-");

    evbuffer_add_vprintf(cf->buffer, fmt, ap);

    msg.stream = 2;
    msg.fd = STDERR_FILENO;
    msg.flags = 0;
    proc_send(c->peer, MSG_WRITE_OPEN, -1, &msg, sizeof msg);
  } else {
    evbuffer_add_vprintf(cf->buffer, fmt, ap);
    file_push(cf);
  }

  va_end(ap);
}

/* Write data to a file. */
void
file_write(struct client *c, const char *path, int flags, const void *bdata,
    size_t bsize, client_file_cb cb, void *cbdata)
{
  struct client_file  *cf;
  struct msg_write_open *msg;
  size_t       msglen;
  int      fd = -1;
  u_int      stream = file_next_stream++;
  FILE      *f;
  const char    *mode;

  if (strcmp(path, "-") == 0) {
    cf = file_create_with_client(c, stream, cb, cbdata);
    cf->path = xstrdup("-");

    fd = STDOUT_FILENO;
    if (c == NULL ||
        (c->flags & CLIENT_ATTACHED) ||
        (c->flags & CLIENT_CONTROL)) {
      cf->error = EBADF;
      goto done;
    }
    goto skip;
  }

  cf = file_create_with_client(c, stream, cb, cbdata);
  cf->path = file_get_path(c, path);

  if (c == NULL || c->flags & CLIENT_ATTACHED) {
    if (flags & O_APPEND)
      mode = "ab";
    else
      mode = "wb";
    f = fopen(cf->path, mode);
    if (f == NULL) {
      cf->error = errno;
      goto done;
    }
    if (fwrite(bdata, 1, bsize, f) != bsize) {
      fclose(f);
      cf->error = EIO;
      goto done;
    }
    fclose(f);
    goto done;
  }

skip:
  evbuffer_add(cf->buffer, bdata, bsize);

  msglen = strlen(cf->path) + 1 + sizeof *msg;
  if (msglen > MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
    cf->error = E2BIG;
    goto done;
  }
  msg = xmalloc(msglen);
  msg->stream = cf->stream;
  msg->fd = fd;
  msg->flags = flags;
  memcpy(msg + 1, cf->path, msglen - sizeof *msg);
  if (proc_send(cf->peer, MSG_WRITE_OPEN, -1, msg, msglen) != 0) {
    free(msg);
    cf->error = EINVAL;
    goto done;
  }
  free(msg);
  return;

done:
  file_fire_done(cf);
}

/* Read a file. */
struct client_file *
file_read(struct client *c, const char *path, client_file_cb cb, void *cbdata)
{
  struct client_file  *cf;
  struct msg_read_open  *msg;
  size_t       msglen;
  int      fd = -1;
  u_int      stream = file_next_stream++;
  FILE      *f = NULL;
  size_t       size;
  char       buffer[BUFSIZ];

  if (strcmp(path, "-") == 0) {
    cf = file_create_with_client(c, stream, cb, cbdata);
    cf->path = xstrdup("-");

    fd = STDIN_FILENO;
    if (c == NULL ||
        (c->flags & CLIENT_ATTACHED) ||
        (c->flags & CLIENT_CONTROL)) {
      cf->error = EBADF;
      goto done;
    }
    goto skip;
  }

  cf = file_create_with_client(c, stream, cb, cbdata);
  cf->path = file_get_path(c, path);

  if (c == NULL || c->flags & CLIENT_ATTACHED) {
    f = fopen(cf->path, "rb");
    if (f == NULL) {
      cf->error = errno;
      goto done;
    }
    for (;;) {
      size = fread(buffer, 1, sizeof buffer, f);
      if (evbuffer_add(cf->buffer, buffer, size) != 0) {
        cf->error = ENOMEM;
        goto done;
      }
      if (size != sizeof buffer)
        break;
    }
    if (ferror(f)) {
      cf->error = EIO;
      goto done;
    }
    goto done;
  }

skip:
  msglen = strlen(cf->path) + 1 + sizeof *msg;
  if (msglen > MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
    cf->error = E2BIG;
    goto done;
  }
  msg = xmalloc(msglen);
  msg->stream = cf->stream;
  msg->fd = fd;
  memcpy(msg + 1, cf->path, msglen - sizeof *msg);
  if (proc_send(cf->peer, MSG_READ_OPEN, -1, msg, msglen) != 0) {
    free(msg);
    cf->error = EINVAL;
    goto done;
  }
  free(msg);
  return cf;

done:
  if (f != NULL)
    fclose(f);
  file_fire_done(cf);
  return NULL;
}

/* Cancel a file read. */
void
file_cancel(struct client_file *cf)
{
  struct msg_read_cancel   msg;

  log_debug("read cancel file %d", cf->stream);

  if (cf->closed)
    return;
  cf->closed = 1;

  msg.stream = cf->stream;
  proc_send(cf->peer, MSG_READ_CANCEL, -1, &msg, sizeof msg);
}

/* Push event, fired if there is more writing to be done. */
static void
file_push_cb(__unused int fd, __unused short events, void *arg)
{
  struct client_file  *cf = arg;

  if (cf->c == NULL || ~cf->c->flags & CLIENT_DEAD)
    file_push(cf);
  file_free(cf);
}

/* Push uwritten data to the client for a file, if it will accept it. */
void
file_push(struct client_file *cf)
{
  struct msg_write_data *msg;
  size_t       msglen, sent, left;
  struct msg_write_close   close;

  msg = xmalloc(sizeof *msg);
  left = EVBUFFER_LENGTH(cf->buffer);
  while (left != 0) {
    sent = left;
    if (sent > MAX_IMSGSIZE - IMSG_HEADER_SIZE - sizeof *msg)
      sent = MAX_IMSGSIZE - IMSG_HEADER_SIZE - sizeof *msg;

    msglen = (sizeof *msg) + sent;
    msg = xrealloc(msg, msglen);
    msg->stream = cf->stream;
    memcpy(msg + 1, EVBUFFER_DATA(cf->buffer), sent);
    if (proc_send(cf->peer, MSG_WRITE, -1, msg, msglen) != 0)
      break;
    evbuffer_drain(cf->buffer, sent);

    left = EVBUFFER_LENGTH(cf->buffer);
    log_debug("file %d sent %zu, left %zu", cf->stream, sent, left);
  }
  if (left != 0) {
    cf->references++;
    event_once(-1, EV_TIMEOUT, file_push_cb, cf, NULL);
  } else if (cf->stream > 2) {
    close.stream = cf->stream;
    proc_send(cf->peer, MSG_WRITE_CLOSE, -1, &close, sizeof close);
    file_fire_done(cf);
  }
  free(msg);
}

/* Check if any files have data left to write. */
int
file_write_left(struct client_files *files)
{
  struct client_file  *cf;
  size_t       left;
  int      waiting = 0;

  RB_FOREACH(cf, client_files, files) {
    if (cf->event == NULL)
      continue;
    left = EVBUFFER_LENGTH(cf->event->output);
    if (left != 0) {
      waiting++;
      log_debug("file %u %zu bytes left", cf->stream, left);
    }
  }
  return (waiting != 0);
}

/* Client file write error callback. */
static void
file_write_error_callback(__unused struct bufferevent *bev, __unused short what,
    void *arg)
{
  struct client_file  *cf = arg;

  log_debug("write error file %d", cf->stream);

  bufferevent_free(cf->event);
  cf->event = NULL;

  close(cf->fd);
  cf->fd = -1;

  if (cf->cb != NULL)
    cf->cb(NULL, NULL, 0, -1, NULL, cf->data);
}

/* Client file write callback. */
static void
file_write_callback(__unused struct bufferevent *bev, void *arg)
{
  struct client_file  *cf = arg;

  log_debug("write check file %d", cf->stream);

  if (cf->cb != NULL)
    cf->cb(NULL, NULL, 0, -1, NULL, cf->data);

  if (cf->closed && EVBUFFER_LENGTH(cf->event->output) == 0) {
    bufferevent_free(cf->event);
    close(cf->fd);
    RB_REMOVE(client_files, cf->tree, cf);
    file_free(cf);
  }
}

/* Handle a file write open message (client). */
void
file_write_open(struct client_files *files, struct tmuxpeer *peer,
    struct imsg *imsg, int allow_streams, int close_received,
    client_file_cb cb, void *cbdata)
{
  struct msg_write_open *msg = imsg->data;
  size_t       msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
  const char    *path;
  struct msg_write_ready   reply;
  struct client_file   find, *cf;
  const int    flags = O_NONBLOCK|O_WRONLY|O_CREAT;
  int      error = 0;

  if (msglen < sizeof *msg)
    fatalx("bad MSG_WRITE_OPEN size");
  if (msglen == sizeof *msg)
    path = "-";
  else
    path = (const char *)(msg + 1);
  log_debug("open write file %d %s", msg->stream, path);

  find.stream = msg->stream;
  if (RB_FIND(client_files, files, &find) != NULL) {
    error = EBADF;
    goto reply;
  }
  cf = file_create_with_peer(peer, files, msg->stream, cb, cbdata);
  if (cf->closed) {
    error = EBADF;
    goto reply;
  }

  cf->fd = -1;
  if (msg->fd == -1)
    cf->fd = open(path, msg->flags|flags, 0644);
  else if (allow_streams) {
    if (msg->fd != STDOUT_FILENO && msg->fd != STDERR_FILENO)
      errno = EBADF;
    else {
      cf->fd = dup(msg->fd);
      if (close_received)
        close(msg->fd); /* can only be used once */
    }
  } else
        errno = EBADF;
  if (cf->fd == -1) {
    error = errno;
    goto reply;
  }

  cf->event = bufferevent_new(cf->fd, NULL, file_write_callback,
      file_write_error_callback, cf);
  if (cf->event == NULL)
    fatalx("out of memory");
  bufferevent_enable(cf->event, EV_WRITE);
  goto reply;

reply:
  reply.stream = msg->stream;
  reply.error = error;
  proc_send(peer, MSG_WRITE_READY, -1, &reply, sizeof reply);
}

/* Handle a file write data message (client). */
void
file_write_data(struct client_files *files, struct imsg *imsg)
{
  struct msg_write_data *msg = imsg->data;
  size_t       msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
  struct client_file   find, *cf;
  size_t       size = msglen - sizeof *msg;

  if (msglen < sizeof *msg)
    fatalx("bad MSG_WRITE size");
  find.stream = msg->stream;
  if ((cf = RB_FIND(client_files, files, &find)) == NULL)
    fatalx("unknown stream number");
  log_debug("write %zu to file %d", size, cf->stream);

  if (cf->event != NULL)
    bufferevent_write(cf->event, msg + 1, size);
}

/* Handle a file write close message (client). */
void
file_write_close(struct client_files *files, struct imsg *imsg)
{
  struct msg_write_close  *msg = imsg->data;
  size_t       msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
  struct client_file   find, *cf;

  if (msglen != sizeof *msg)
    fatalx("bad MSG_WRITE_CLOSE size");
  find.stream = msg->stream;
  if ((cf = RB_FIND(client_files, files, &find)) == NULL)
    fatalx("unknown stream number");
  log_debug("close file %d", cf->stream);

  if (cf->event == NULL || EVBUFFER_LENGTH(cf->event->output) == 0) {
    if (cf->event != NULL)
      bufferevent_free(cf->event);
    if (cf->fd != -1)
      close(cf->fd);
    RB_REMOVE(client_files, files, cf);
    file_free(cf);
  }
}

/* Client file read error callback. */
static void
file_read_error_callback(__unused struct bufferevent *bev, __unused short what,
    void *arg)
{
  struct client_file  *cf = arg;
  struct msg_read_done   msg;

  log_debug("read error file %d", cf->stream);

  msg.stream = cf->stream;
  msg.error = 0;
  proc_send(cf->peer, MSG_READ_DONE, -1, &msg, sizeof msg);

  bufferevent_free(cf->event);
  close(cf->fd);
  RB_REMOVE(client_files, cf->tree, cf);
  file_free(cf);
}

/* Client file read callback. */
static void
file_read_callback(__unused struct bufferevent *bev, void *arg)
{
  struct client_file  *cf = arg;
  void      *bdata;
  size_t       bsize;
  struct msg_read_data  *msg;
  size_t       msglen;

  msg = xmalloc(sizeof *msg);
  for (;;) {
    bdata = EVBUFFER_DATA(cf->event->input);
    bsize = EVBUFFER_LENGTH(cf->event->input);

    if (bsize == 0)
      break;
    if (bsize > MAX_IMSGSIZE - IMSG_HEADER_SIZE - sizeof *msg)
      bsize = MAX_IMSGSIZE - IMSG_HEADER_SIZE - sizeof *msg;
    log_debug("read %zu from file %d", bsize, cf->stream);

    msglen = (sizeof *msg) + bsize;
    msg = xrealloc(msg, msglen);
    msg->stream = cf->stream;
    memcpy(msg + 1, bdata, bsize);
    proc_send(cf->peer, MSG_READ, -1, msg, msglen);

    evbuffer_drain(cf->event->input, bsize);
  }
  free(msg);
}

/* Handle a file read open message (client). */
void
file_read_open(struct client_files *files, struct tmuxpeer *peer,
    struct imsg *imsg, int allow_streams, int close_received, client_file_cb cb,
    void *cbdata)
{
  struct msg_read_open  *msg = imsg->data;
  size_t       msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
  const char    *path;
  struct msg_read_done   reply;
  struct client_file   find, *cf;
  const int    flags = O_NONBLOCK|O_RDONLY;
  int      error;

  if (msglen < sizeof *msg)
    fatalx("bad MSG_READ_OPEN size");
  if (msglen == sizeof *msg)
    path = "-";
  else
    path = (const char *)(msg + 1);
  log_debug("open read file %d %s", msg->stream, path);

  find.stream = msg->stream;
  if (RB_FIND(client_files, files, &find) != NULL) {
    error = EBADF;
    goto reply;
  }
  cf = file_create_with_peer(peer, files, msg->stream, cb, cbdata);
  if (cf->closed) {
    error = EBADF;
    goto reply;
  }

  cf->fd = -1;
  if (msg->fd == -1)
    cf->fd = open(path, flags);
  else if (allow_streams) {
    if (msg->fd != STDIN_FILENO)
      errno = EBADF;
    else {
      cf->fd = dup(msg->fd);
      if (close_received)
        close(msg->fd); /* can only be used once */
    }
  } else
    errno = EBADF;
  if (cf->fd == -1) {
    error = errno;
    goto reply;
  }

  cf->event = bufferevent_new(cf->fd, file_read_callback, NULL,
      file_read_error_callback, cf);
  if (cf->event == NULL)
    fatalx("out of memory");
  bufferevent_enable(cf->event, EV_READ);
  return;

reply:
  reply.stream = msg->stream;
  reply.error = error;
  proc_send(peer, MSG_READ_DONE, -1, &reply, sizeof reply);
}

/* Handle a read cancel message (client). */
void
file_read_cancel(struct client_files *files, struct imsg *imsg)
{
  struct msg_read_cancel  *msg = imsg->data;
  size_t       msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
  struct client_file   find, *cf;

  if (msglen != sizeof *msg)
    fatalx("bad MSG_READ_CANCEL size");
  find.stream = msg->stream;
  if ((cf = RB_FIND(client_files, files, &find)) == NULL)
    fatalx("unknown stream number");
  log_debug("cancel file %d", cf->stream);

  file_read_error_callback(NULL, 0, cf);
}

/* Handle a write ready message (server). */
void
file_write_ready(struct client_files *files, struct imsg *imsg)
{
  struct msg_write_ready  *msg = imsg->data;
  size_t       msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
  struct client_file   find, *cf;

  if (msglen != sizeof *msg)
    fatalx("bad MSG_WRITE_READY size");
  find.stream = msg->stream;
  if ((cf = RB_FIND(client_files, files, &find)) == NULL)
    return;
  if (msg->error != 0) {
    cf->error = msg->error;
    file_fire_done(cf);
  } else
    file_push(cf);
}

/* Handle read data message (server). */
void
file_read_data(struct client_files *files, struct imsg *imsg)
{
  struct msg_read_data  *msg = imsg->data;
  size_t       msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
  struct client_file   find, *cf;
  void      *bdata = msg + 1;
  size_t       bsize = msglen - sizeof *msg;

  if (msglen < sizeof *msg)
    fatalx("bad MSG_READ_DATA size");
  find.stream = msg->stream;
  if ((cf = RB_FIND(client_files, files, &find)) == NULL)
    return;

  log_debug("file %d read %zu bytes", cf->stream, bsize);
  if (cf->error == 0 && !cf->closed) {
    if (evbuffer_add(cf->buffer, bdata, bsize) != 0) {
      cf->error = ENOMEM;
      file_fire_done(cf);
    } else
      file_fire_read(cf);
  }
}

/* Handle a read done message (server). */
void
file_read_done(struct client_files *files, struct imsg *imsg)
{
  struct msg_read_done  *msg = imsg->data;
  size_t       msglen = imsg->hdr.len - IMSG_HEADER_SIZE;
  struct client_file   find, *cf;

  if (msglen != sizeof *msg)
    fatalx("bad MSG_READ_DONE size");
  find.stream = msg->stream;
  if ((cf = RB_FIND(client_files, files, &find)) == NULL)
    return;

  log_debug("file %d read done", cf->stream);
  cf->error = msg->error;
  file_fire_done(cf);
}

Coverage Report

Created: 2025-08-29 06:28