cmd-load-buffer.c

   1 /* $OpenBSD$ */
   2
   3 /*
   4  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
  15  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  16  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include <sys/types.h>
  20
  21 #include <errno.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26
  27 #include "tmux.h"
  28
  29 /*
  30  * Loads a paste buffer from a file.
  31  */
  32
  33 enum cmd_retval  cmd_load_buffer_exec(struct cmd *, struct cmd_q *);
  34 void             cmd_load_buffer_callback(struct client *, int, void *);
  35
  36 const struct cmd_entry cmd_load_buffer_entry = {
  37         "load-buffer", "loadb",
  38         "b:", 1, 1,
  39         CMD_BUFFER_USAGE " path",
  40         0,
  41         NULL,
  42         cmd_load_buffer_exec
  43 };
  44
  45 enum cmd_retval
  46 cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
  47 {
  48         struct args     *args = self->args;
  49         struct client   *c = cmdq->client;
  50         struct session  *s;
  51         FILE            *f;
  52         const char      *path, *newpath, *wd;
  53         char            *pdata, *new_pdata, *cause;
  54         size_t           psize;
  55         u_int            limit;
  56         int              ch, error, buffer, *buffer_ptr;
  57
  58         if (!args_has(args, 'b'))
  59                 buffer = -1;
  60         else {
  61                 buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
  62                 if (cause != NULL) {
  63                         cmdq_error(cmdq, "buffer %s", cause);
  64                         free(cause);
  65                         return (CMD_RETURN_ERROR);
  66                 }
  67         }
  68
  69         path = args->argv[0];
  70         if (strcmp(path, "-") == 0) {
  71                 buffer_ptr = xmalloc(sizeof *buffer_ptr);
  72                 *buffer_ptr = buffer;
  73
  74                 error = server_set_stdin_callback (c, cmd_load_buffer_callback,
  75                     buffer_ptr, &cause);
  76                 if (error != 0) {
  77                         cmdq_error(cmdq, "%s: %s", path, cause);
  78                         free(cause);
  79                         return (CMD_RETURN_ERROR);
  80                 }
  81                 return (CMD_RETURN_WAIT);
  82         }
  83
  84         if (c != NULL)
  85                 wd = c->cwd;
  86         else if ((s = cmd_current_session(cmdq, 0)) != NULL) {
  87                 wd = options_get_string(&s->options, "default-path");
  88                 if (*wd == '\0')
  89                         wd = s->cwd;
  90         } else
  91                 wd = NULL;
  92         if (wd != NULL && *wd != '\0') {
  93                 newpath = get_full_path(wd, path);
  94                 if (newpath != NULL)
  95                         path = newpath;
  96         }
  97         if ((f = fopen(path, "rb")) == NULL) {
  98                 cmdq_error(cmdq, "%s: %s", path, strerror(errno));
  99                 return (CMD_RETURN_ERROR);
 100         }
 101
 102         pdata = NULL;
 103         psize = 0;
 104         while ((ch = getc(f)) != EOF) {
 105                 /* Do not let the server die due to memory exhaustion. */
 106                 if ((new_pdata = realloc(pdata, psize + 2)) == NULL) {
 107                         cmdq_error(cmdq, "realloc error: %s", strerror(errno));
 108                         goto error;
 109                 }
 110                 pdata = new_pdata;
 111                 pdata[psize++] = ch;
 112         }
 113         if (ferror(f)) {
 114                 cmdq_error(cmdq, "%s: read error", path);
 115                 goto error;
 116         }
 117         if (pdata != NULL)
 118                 pdata[psize] = '\0';
 119
 120         fclose(f);
 121
 122         limit = options_get_number(&global_options, "buffer-limit");
 123         if (buffer == -1) {
 124                 paste_add(&global_buffers, pdata, psize, limit);
 125                 return (CMD_RETURN_NORMAL);
 126         }
 127         if (paste_replace(&global_buffers, buffer, pdata, psize) != 0) {
 128                 cmdq_error(cmdq, "no buffer %d", buffer);
 129                 free(pdata);
 130                 return (CMD_RETURN_ERROR);
 131         }
 132
 133         return (CMD_RETURN_NORMAL);
 134
 135 error:
 136         free(pdata);
 137         if (f != NULL)
 138                 fclose(f);
 139         return (CMD_RETURN_ERROR);
 140 }
 141
 142 void
 143 cmd_load_buffer_callback(struct client *c, int closed, void *data)
 144 {
 145         int     *buffer = data;
 146         char    *pdata;
 147         size_t   psize;
 148         u_int    limit;
 149
 150         if (!closed)
 151                 return;
 152         c->stdin_callback = NULL;
 153
 154         c->references--;
 155         if (c->flags & CLIENT_DEAD)
 156                 return;
 157
 158         psize = EVBUFFER_LENGTH(c->stdin_data);
 159         if (psize == 0 || (pdata = malloc(psize + 1)) == NULL) {
 160                 free(data);
 161                 goto out;
 162         }
 163         memcpy(pdata, EVBUFFER_DATA(c->stdin_data), psize);
 164         pdata[psize] = '\0';
 165         evbuffer_drain(c->stdin_data, psize);
 166
 167         limit = options_get_number(&global_options, "buffer-limit");
 168         if (*buffer == -1)
 169                 paste_add(&global_buffers, pdata, psize, limit);
 170         else if (paste_replace(&global_buffers, *buffer, pdata, psize) != 0) {
 171                 /* No context so can't use server_client_msg_error. */
 172                 evbuffer_add_printf(c->stderr_data, "no buffer %d\n", *buffer);
 173                 server_push_stderr(c);
 174         }
 175
 176         free(data);
 177
 178 out:
 179         cmdq_continue(c->cmdq);
 180 }