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 int
 116 paste_is_empty(void)
 117 {
 118         return RB_ROOT(&paste_by_time) == NULL;
 119 }
 120
 121 /* Get the most recent automatic buffer. */
 122 struct paste_buffer *
 123 paste_get_top(const char **name)
 124 {
 125         struct paste_buffer     *pb;
 126
 127         pb = RB_MIN(paste_time_tree, &paste_by_time);
 128         while (pb != NULL && !pb->automatic)
 129                 pb = RB_NEXT(paste_time_tree, &paste_by_time, pb);
 130         if (pb == NULL)
 131                 return (NULL);
 132         if (name != NULL)
 133                 *name = pb->name;
 134         return (pb);
 135 }
 136
 137 /* Get a paste buffer by name. */
 138 struct paste_buffer *
 139 paste_get_name(const char *name)
 140 {
 141         struct paste_buffer     pbfind;
 142
 143         if (name == NULL || *name == '\0')
 144                 return (NULL);
 145
 146         pbfind.name = (char *)name;
 147         return (RB_FIND(paste_name_tree, &paste_by_name, &pbfind));
 148 }
 149
 150 /* Free a paste buffer. */
 151 void
 152 paste_free(struct paste_buffer *pb)
 153 {
 154         notify_paste_buffer(pb->name, 1);
 155
 156         RB_REMOVE(paste_name_tree, &paste_by_name, pb);
 157         RB_REMOVE(paste_time_tree, &paste_by_time, pb);
 158         if (pb->automatic)
 159                 paste_num_automatic--;
 160
 161         free(pb->data);
 162         free(pb->name);
 163         free(pb);
 164 }
 165
 166 /*
 167  * Add an automatic buffer, freeing the oldest automatic item if at limit. Note
 168  * that the caller is responsible for allocating data.
 169  */
 170 void
 171 paste_add(const char *prefix, char *data, size_t size)
 172 {
 173         struct paste_buffer     *pb, *pb1;
 174         u_int                    limit;
 175
 176         if (prefix == NULL)
 177                 prefix = "buffer";
 178
 179         if (size == 0) {
 180                 free(data);
 181                 return;
 182         }
 183
 184         limit = options_get_number(global_options, "buffer-limit");
 185         RB_FOREACH_REVERSE_SAFE(pb, paste_time_tree, &paste_by_time, pb1) {
 186                 if (paste_num_automatic < limit)
 187                         break;
 188                 if (pb->automatic)
 189                         paste_free(pb);
 190         }
 191
 192         pb = xmalloc(sizeof *pb);
 193
 194         pb->name = NULL;
 195         do {
 196                 free(pb->name);
 197                 xasprintf(&pb->name, "%s%u", prefix, paste_next_index);
 198                 paste_next_index++;
 199         } while (paste_get_name(pb->name) != NULL);
 200
 201         pb->data = data;
 202         pb->size = size;
 203
 204         pb->automatic = 1;
 205         paste_num_automatic++;
 206
 207         pb->created = time(NULL);
 208
 209         pb->order = paste_next_order++;
 210         RB_INSERT(paste_name_tree, &paste_by_name, pb);
 211         RB_INSERT(paste_time_tree, &paste_by_time, pb);
 212
 213         notify_paste_buffer(pb->name, 0);
 214 }
 215
 216 /* Rename a paste buffer. */
 217 int
 218 paste_rename(const char *oldname, const char *newname, char **cause)
 219 {
 220         struct paste_buffer     *pb, *pb_new;
 221
 222         if (cause != NULL)
 223                 *cause = NULL;
 224
 225         if (oldname == NULL || *oldname == '\0') {
 226                 if (cause != NULL)
 227                         *cause = xstrdup("no buffer");
 228                 return (-1);
 229         }
 230         if (newname == NULL || *newname == '\0') {
 231                 if (cause != NULL)
 232                         *cause = xstrdup("new name is empty");
 233                 return (-1);
 234         }
 235
 236         pb = paste_get_name(oldname);
 237         if (pb == NULL) {
 238                 if (cause != NULL)
 239                         xasprintf(cause, "no buffer %s", oldname);
 240                 return (-1);
 241         }
 242
 243         pb_new = paste_get_name(newname);
 244         if (pb_new != NULL)
 245                 paste_free(pb_new);
 246
 247         RB_REMOVE(paste_name_tree, &paste_by_name, pb);
 248
 249         free(pb->name);
 250         pb->name = xstrdup(newname);
 251
 252         if (pb->automatic)
 253                 paste_num_automatic--;
 254         pb->automatic = 0;
 255
 256         RB_INSERT(paste_name_tree, &paste_by_name, pb);
 257
 258         notify_paste_buffer(oldname, 1);
 259         notify_paste_buffer(newname, 0);
 260
 261         return (0);
 262 }
 263
 264 /*
 265  * Add or replace an item in the store. Note that the caller is responsible for
 266  * allocating data.
 267  */
 268 int
 269 paste_set(char *data, size_t size, const char *name, char **cause)
 270 {
 271         struct paste_buffer     *pb, *old;
 272
 273         if (cause != NULL)
 274                 *cause = NULL;
 275
 276         if (size == 0) {
 277                 free(data);
 278                 return (0);
 279         }
 280         if (name == NULL) {
 281                 paste_add(NULL, data, size);
 282                 return (0);
 283         }
 284
 285         if (*name == '\0') {
 286                 if (cause != NULL)
 287                         *cause = xstrdup("empty buffer name");
 288                 return (-1);
 289         }
 290
 291         pb = xmalloc(sizeof *pb);
 292
 293         pb->name = xstrdup(name);
 294
 295         pb->data = data;
 296         pb->size = size;
 297
 298         pb->automatic = 0;
 299         pb->order = paste_next_order++;
 300
 301         pb->created = time(NULL);
 302
 303         if ((old = paste_get_name(name)) != NULL)
 304                 paste_free(old);
 305
 306         RB_INSERT(paste_name_tree, &paste_by_name, pb);
 307         RB_INSERT(paste_time_tree, &paste_by_time, pb);
 308
 309         notify_paste_buffer(name, 0);
 310
 311         return (0);
 312 }
 313
 314 /* Set paste data without otherwise changing it. */
 315 void
 316 paste_replace(struct paste_buffer *pb, char *data, size_t size)
 317 {
 318         free(pb->data);
 319         pb->data = data;
 320         pb->size = size;
 321
 322         notify_paste_buffer(pb->name, 0);
 323 }
 324
 325 /* Convert start of buffer into a nice string. */
 326 char *
 327 paste_make_sample(struct paste_buffer *pb)
 328 {
 329         char            *buf;
 330         size_t           len, used;
 331         const int        flags = VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL;
 332         const size_t     width = 200;
 333
 334         len = pb->size;
 335         if (len > width)
 336                 len = width;
 337         buf = xreallocarray(NULL, len, 4 + 4);
 338
 339         used = utf8_strvis(buf, pb->data, len, flags);
 340         if (pb->size > width || used > width)
 341                 strlcpy(buf + width, "...", 4);
 342         return (buf);
 343 }