/* $OpenBSD$ */

/*
* Copyright (c) 2019 Nicholas Marriott <[email protected]>
*
* 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;
       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;
               }
               fclose(f);
               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:
       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);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.