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