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