paste.c

   1 /* $OpenBSD$ */
   2
   3 /*
   4  * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
   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 <stdlib.h>
  22 #include <string.h>
  23 #include <time.h>
  24 #include <vis.h>
  25
  26 #include "tmux.h"
  27
  28 /*
  29  * Set of paste buffers. Note that paste buffer data is not necessarily a C
  30  * string!
  31  */
  32
  33 struct paste_buffer {
  34         char            *data;
  35         size_t           size;
  36
  37         char            *name;
  38         time_t           created;
  39         int              automatic;
  40         u_int            order;
  41
  42         RB_ENTRY(paste_buffer) name_entry;
  43         RB_ENTRY(paste_buffer) time_entry;
  44 };
  45
  46 static u_int    paste_next_index;
  47 static u_int    paste_next_order;
  48 static u_int    paste_num_automatic;
  49 static RB_HEAD(paste_name_tree, paste_buffer) paste_by_name;
  50 static RB_HEAD(paste_time_tree, paste_buffer) paste_by_time;
  51
  52 static int      paste_cmp_names(const struct paste_buffer *,
  53                     const struct paste_buffer *);
  54 RB_GENERATE_STATIC(paste_name_tree, paste_buffer, name_entry, paste_cmp_names);
  55
  56 static int      paste_cmp_times(const struct paste_buffer *,
  57                     const struct paste_buffer *);
  58 RB_GENERATE_STATIC(paste_time_tree, paste_buffer, time_entry, paste_cmp_times);
  59
  60 static int
  61 paste_cmp_names(const struct paste_buffer *a, const struct paste_buffer *b)
  62 {
  63         return (strcmp(a->name, b->name));
  64 }
  65
  66 static int
  67 paste_cmp_times(const struct paste_buffer *a, const struct paste_buffer *b)
  68 {
  69         if (a->order > b->order)
  70                 return (-1);
  71         if (a->order < b->order)
  72                 return (1);
  73         return (0);
  74 }
  75
  76 /* Get paste buffer name. */
  77 const char *
  78 paste_buffer_name(struct paste_buffer *pb)
  79 {
  80         return (pb->name);
  81 }
  82
  83 /* Get paste buffer order. */
  84 u_int
  85 paste_buffer_order(struct paste_buffer *pb)
  86 {
  87         return (pb->order);
  88 }
  89
  90 /* Get paste buffer created. */
  91 time_t
  92 paste_buffer_created(struct paste_buffer *pb)
  93 {
  94         return (pb->created);
  95 }
  96
  97 /* Get paste buffer data. */
  98 const char *
  99 paste_buffer_data(struct paste_buffer *pb, size_t *size)
 100 {
 101         if (size != NULL)
 102                 *size = pb->size;
 103         return (pb->data);
 104 }
 105
 106 /* Walk paste buffers by time. */
 107 struct paste_buffer *
 108 paste_walk(struct paste_buffer *pb)
 109 {
 110         if (pb == NULL)
 111                 return (RB_MIN(paste_time_tree, &paste_by_time));
 112         return (RB_NEXT(paste_time_tree, &paste_by_time, pb));
 113 }
 114
 115 /* Get the most recent automatic buffer. */
 116 struct paste_buffer *
 117 paste_get_top(const char **name)
 118 {
 119         struct paste_buffer     *pb;
 120
 121         pb = RB_MIN(paste_time_tree, &paste_by_time);
 122         if (pb == NULL)
 123                 return (NULL);
 124         if (name != NULL)
 125                 *name = pb->name;
 126         return (pb);
 127 }
 128
 129 /* Get a paste buffer by name. */
 130 struct paste_buffer *
 131 paste_get_name(const char *name)
 132 {
 133         struct paste_buffer     pbfind;
 134
 135         if (name == NULL || *name == '\0')
 136                 return (NULL);
 137
 138         pbfind.name = (char *)name;
 139         return (RB_FIND(paste_name_tree, &paste_by_name, &pbfind));
 140 }
 141
 142 /* Free a paste buffer. */
 143 void
 144 paste_free(struct paste_buffer *pb)
 145 {
 146         RB_REMOVE(paste_name_tree, &paste_by_name, pb);
 147         RB_REMOVE(paste_time_tree, &paste_by_time, pb);
 148         if (pb->automatic)
 149                 paste_num_automatic--;
 150
 151         free(pb->data);
 152         free(pb->name);
 153         free(pb);
 154 }
 155
 156 /*
 157  * Add an automatic buffer, freeing the oldest automatic item if at limit. Note
 158  * that the caller is responsible for allocating data.
 159  */
 160 void
 161 paste_add(const char *prefix, char *data, size_t size)
 162 {
 163         struct paste_buffer     *pb, *pb1;
 164         u_int                    limit;
 165
 166         if (prefix == NULL)
 167                 prefix = "buffer";
 168
 169         if (size == 0) {
 170                 free(data);
 171                 return;
 172         }
 173
 174         limit = options_get_number(global_options, "buffer-limit");
 175         RB_FOREACH_REVERSE_SAFE(pb, paste_time_tree, &paste_by_time, pb1) {
 176                 if (paste_num_automatic < limit)
 177                         break;
 178                 if (pb->automatic)
 179                         paste_free(pb);
 180         }
 181
 182         pb = xmalloc(sizeof *pb);
 183
 184         pb->name = NULL;
 185         do {
 186                 free(pb->name);
 187                 xasprintf(&pb->name, "%s%u", prefix, paste_next_index);
 188                 paste_next_index++;
 189         } while (paste_get_name(pb->name) != NULL);
 190
 191         pb->data = data;
 192         pb->size = size;
 193
 194         pb->automatic = 1;
 195         paste_num_automatic++;
 196
 197         pb->created = time(NULL);
 198
 199         pb->order = paste_next_order++;
 200         RB_INSERT(paste_name_tree, &paste_by_name, pb);
 201         RB_INSERT(paste_time_tree, &paste_by_time, pb);
 202 }
 203
 204 /* Rename a paste buffer. */
 205 int
 206 paste_rename(const char *oldname, const char *newname, char **cause)
 207 {
 208         struct paste_buffer     *pb, *pb_new;
 209
 210         if (cause != NULL)
 211                 *cause = NULL;
 212
 213         if (oldname == NULL || *oldname == '\0') {
 214                 if (cause != NULL)
 215                         *cause = xstrdup("no buffer");
 216                 return (-1);
 217         }
 218         if (newname == NULL || *newname == '\0') {
 219                 if (cause != NULL)
 220                         *cause = xstrdup("new name is empty");
 221                 return (-1);
 222         }
 223
 224         pb = paste_get_name(oldname);
 225         if (pb == NULL) {
 226                 if (cause != NULL)
 227                         xasprintf(cause, "no buffer %s", oldname);
 228                 return (-1);
 229         }
 230
 231         pb_new = paste_get_name(newname);
 232         if (pb_new != NULL) {
 233                 if (cause != NULL)
 234                         xasprintf(cause, "buffer %s already exists", newname);
 235                 return (-1);
 236         }
 237
 238         RB_REMOVE(paste_name_tree, &paste_by_name, pb);
 239
 240         free(pb->name);
 241         pb->name = xstrdup(newname);
 242
 243         if (pb->automatic)
 244                 paste_num_automatic--;
 245         pb->automatic = 0;
 246
 247         RB_INSERT(paste_name_tree, &paste_by_name, pb);
 248
 249         return (0);
 250 }
 251
 252 /*
 253  * Add or replace an item in the store. Note that the caller is responsible for
 254  * allocating data.
 255  */
 256 int
 257 paste_set(char *data, size_t size, const char *name, char **cause)
 258 {
 259         struct paste_buffer     *pb, *old;
 260
 261         if (cause != NULL)
 262                 *cause = NULL;
 263
 264         if (size == 0) {
 265                 free(data);
 266                 return (0);
 267         }
 268         if (name == NULL) {
 269                 paste_add(NULL, data, size);
 270                 return (0);
 271         }
 272
 273         if (*name == '\0') {
 274                 if (cause != NULL)
 275                         *cause = xstrdup("empty buffer name");
 276                 return (-1);
 277         }
 278
 279         pb = xmalloc(sizeof *pb);
 280
 281         pb->name = xstrdup(name);
 282
 283         pb->data = data;
 284         pb->size = size;
 285
 286         pb->automatic = 0;
 287         pb->order = paste_next_order++;
 288
 289         pb->created = time(NULL);
 290
 291         if ((old = paste_get_name(name)) != NULL)
 292                 paste_free(old);
 293
 294         RB_INSERT(paste_name_tree, &paste_by_name, pb);
 295         RB_INSERT(paste_time_tree, &paste_by_time, pb);
 296
 297         return (0);
 298 }
 299
 300 /* Set paste data without otherwise changing it. */
 301 void
 302 paste_replace(struct paste_buffer *pb, char *data, size_t size)
 303 {
 304         free(pb->data);
 305         pb->data = data;
 306         pb->size = size;
 307 }
 308
 309 /* Convert start of buffer into a nice string. */
 310 char *
 311 paste_make_sample(struct paste_buffer *pb)
 312 {
 313         char            *buf;
 314         size_t           len, used;
 315         const int        flags = VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL;
 316         const size_t     width = 200;
 317
 318         len = pb->size;
 319         if (len > width)
 320                 len = width;
 321         buf = xreallocarray(NULL, len, 4 + 4);
 322
 323         used = utf8_strvis(buf, pb->data, len, flags);
 324         if (pb->size > width || used > width)
 325                 strlcpy(buf + width, "...", 4);
 326         return (buf);
 327 }