Annotation of embedaddon/readline/histfile.c, revision 1.1
1.1 ! misho 1: /* histfile.c - functions to manipulate the history file. */
! 2:
! 3: /* Copyright (C) 1989-2010 Free Software Foundation, Inc.
! 4:
! 5: This file contains the GNU History Library (History), a set of
! 6: routines for managing the text of previously typed lines.
! 7:
! 8: History is free software: you can redistribute it and/or modify
! 9: it under the terms of the GNU General Public License as published by
! 10: the Free Software Foundation, either version 3 of the License, or
! 11: (at your option) any later version.
! 12:
! 13: History is distributed in the hope that it will be useful,
! 14: but WITHOUT ANY WARRANTY; without even the implied warranty of
! 15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 16: GNU General Public License for more details.
! 17:
! 18: You should have received a copy of the GNU General Public License
! 19: along with History. If not, see <http://www.gnu.org/licenses/>.
! 20: */
! 21:
! 22: /* The goal is to make the implementation transparent, so that you
! 23: don't have to know what data types are used, just what functions
! 24: you can call. I think I have done that. */
! 25:
! 26: #define READLINE_LIBRARY
! 27:
! 28: #if defined (__TANDEM)
! 29: # include <floss.h>
! 30: #endif
! 31:
! 32: #if defined (HAVE_CONFIG_H)
! 33: # include <config.h>
! 34: #endif
! 35:
! 36: #include <stdio.h>
! 37:
! 38: #include <sys/types.h>
! 39: #if ! defined (_MINIX) && defined (HAVE_SYS_FILE_H)
! 40: # include <sys/file.h>
! 41: #endif
! 42: #include "posixstat.h"
! 43: #include <fcntl.h>
! 44:
! 45: #if defined (HAVE_STDLIB_H)
! 46: # include <stdlib.h>
! 47: #else
! 48: # include "ansi_stdlib.h"
! 49: #endif /* HAVE_STDLIB_H */
! 50:
! 51: #if defined (HAVE_UNISTD_H)
! 52: # include <unistd.h>
! 53: #endif
! 54:
! 55: #include <ctype.h>
! 56:
! 57: #if defined (__EMX__)
! 58: # undef HAVE_MMAP
! 59: #endif
! 60:
! 61: #ifdef HISTORY_USE_MMAP
! 62: # include <sys/mman.h>
! 63:
! 64: # ifdef MAP_FILE
! 65: # define MAP_RFLAGS (MAP_FILE|MAP_PRIVATE)
! 66: # define MAP_WFLAGS (MAP_FILE|MAP_SHARED)
! 67: # else
! 68: # define MAP_RFLAGS MAP_PRIVATE
! 69: # define MAP_WFLAGS MAP_SHARED
! 70: # endif
! 71:
! 72: # ifndef MAP_FAILED
! 73: # define MAP_FAILED ((void *)-1)
! 74: # endif
! 75:
! 76: #endif /* HISTORY_USE_MMAP */
! 77:
! 78: /* If we're compiling for __EMX__ (OS/2) or __CYGWIN__ (cygwin32 environment
! 79: on win 95/98/nt), we want to open files with O_BINARY mode so that there
! 80: is no \n -> \r\n conversion performed. On other systems, we don't want to
! 81: mess around with O_BINARY at all, so we ensure that it's defined to 0. */
! 82: #if defined (__EMX__) || defined (__CYGWIN__)
! 83: # ifndef O_BINARY
! 84: # define O_BINARY 0
! 85: # endif
! 86: #else /* !__EMX__ && !__CYGWIN__ */
! 87: # undef O_BINARY
! 88: # define O_BINARY 0
! 89: #endif /* !__EMX__ && !__CYGWIN__ */
! 90:
! 91: #include <errno.h>
! 92: #if !defined (errno)
! 93: extern int errno;
! 94: #endif /* !errno */
! 95:
! 96: #include "history.h"
! 97: #include "histlib.h"
! 98:
! 99: #include "rlshell.h"
! 100: #include "xmalloc.h"
! 101:
! 102: /* If non-zero, we write timestamps to the history file in history_do_write() */
! 103: int history_write_timestamps = 0;
! 104:
! 105: /* Does S look like the beginning of a history timestamp entry? Placeholder
! 106: for more extensive tests. */
! 107: #define HIST_TIMESTAMP_START(s) (*(s) == history_comment_char && isdigit ((s)[1]) )
! 108:
! 109: /* Return the string that should be used in the place of this
! 110: filename. This only matters when you don't specify the
! 111: filename to read_history (), or write_history (). */
! 112: static char *
! 113: history_filename (filename)
! 114: const char *filename;
! 115: {
! 116: char *return_val;
! 117: const char *home;
! 118: int home_len;
! 119:
! 120: return_val = filename ? savestring (filename) : (char *)NULL;
! 121:
! 122: if (return_val)
! 123: return (return_val);
! 124:
! 125: home = sh_get_env_value ("HOME");
! 126:
! 127: if (home == 0)
! 128: return (NULL);
! 129: else
! 130: home_len = strlen (home);
! 131:
! 132: return_val = (char *)xmalloc (2 + home_len + 8); /* strlen(".history") == 8 */
! 133: strcpy (return_val, home);
! 134: return_val[home_len] = '/';
! 135: #if defined (__MSDOS__)
! 136: strcpy (return_val + home_len + 1, "_history");
! 137: #else
! 138: strcpy (return_val + home_len + 1, ".history");
! 139: #endif
! 140:
! 141: return (return_val);
! 142: }
! 143:
! 144: static char *
! 145: history_backupfile (filename)
! 146: const char *filename;
! 147: {
! 148: char *ret;
! 149: size_t len;
! 150:
! 151: len = strlen (filename);
! 152: ret = xmalloc (len + 2);
! 153: strcpy (ret, filename);
! 154: ret[len] = '-';
! 155: ret[len+1] = '\0';
! 156: return ret;
! 157: }
! 158:
! 159: /* Add the contents of FILENAME to the history list, a line at a time.
! 160: If FILENAME is NULL, then read from ~/.history. Returns 0 if
! 161: successful, or errno if not. */
! 162: int
! 163: read_history (filename)
! 164: const char *filename;
! 165: {
! 166: return (read_history_range (filename, 0, -1));
! 167: }
! 168:
! 169: /* Read a range of lines from FILENAME, adding them to the history list.
! 170: Start reading at the FROM'th line and end at the TO'th. If FROM
! 171: is zero, start at the beginning. If TO is less than FROM, read
! 172: until the end of the file. If FILENAME is NULL, then read from
! 173: ~/.history. Returns 0 if successful, or errno if not. */
! 174: int
! 175: read_history_range (filename, from, to)
! 176: const char *filename;
! 177: int from, to;
! 178: {
! 179: register char *line_start, *line_end, *p;
! 180: char *input, *buffer, *bufend, *last_ts;
! 181: int file, current_line, chars_read;
! 182: struct stat finfo;
! 183: size_t file_size;
! 184: #if defined (EFBIG)
! 185: int overflow_errno = EFBIG;
! 186: #elif defined (EOVERFLOW)
! 187: int overflow_errno = EOVERFLOW;
! 188: #else
! 189: int overflow_errno = EIO;
! 190: #endif
! 191:
! 192: buffer = last_ts = (char *)NULL;
! 193: input = history_filename (filename);
! 194: file = input ? open (input, O_RDONLY|O_BINARY, 0666) : -1;
! 195:
! 196: if ((file < 0) || (fstat (file, &finfo) == -1))
! 197: goto error_and_exit;
! 198:
! 199: file_size = (size_t)finfo.st_size;
! 200:
! 201: /* check for overflow on very large files */
! 202: if (file_size != finfo.st_size || file_size + 1 < file_size)
! 203: {
! 204: errno = overflow_errno;
! 205: goto error_and_exit;
! 206: }
! 207:
! 208: #ifdef HISTORY_USE_MMAP
! 209: /* We map read/write and private so we can change newlines to NULs without
! 210: affecting the underlying object. */
! 211: buffer = (char *)mmap (0, file_size, PROT_READ|PROT_WRITE, MAP_RFLAGS, file, 0);
! 212: if ((void *)buffer == MAP_FAILED)
! 213: {
! 214: errno = overflow_errno;
! 215: goto error_and_exit;
! 216: }
! 217: chars_read = file_size;
! 218: #else
! 219: buffer = (char *)malloc (file_size + 1);
! 220: if (buffer == 0)
! 221: {
! 222: errno = overflow_errno;
! 223: goto error_and_exit;
! 224: }
! 225:
! 226: chars_read = read (file, buffer, file_size);
! 227: #endif
! 228: if (chars_read < 0)
! 229: {
! 230: error_and_exit:
! 231: if (errno != 0)
! 232: chars_read = errno;
! 233: else
! 234: chars_read = EIO;
! 235: if (file >= 0)
! 236: close (file);
! 237:
! 238: FREE (input);
! 239: #ifndef HISTORY_USE_MMAP
! 240: FREE (buffer);
! 241: #endif
! 242:
! 243: return (chars_read);
! 244: }
! 245:
! 246: close (file);
! 247:
! 248: /* Set TO to larger than end of file if negative. */
! 249: if (to < 0)
! 250: to = chars_read;
! 251:
! 252: /* Start at beginning of file, work to end. */
! 253: bufend = buffer + chars_read;
! 254: current_line = 0;
! 255:
! 256: /* Skip lines until we are at FROM. */
! 257: for (line_start = line_end = buffer; line_end < bufend && current_line < from; line_end++)
! 258: if (*line_end == '\n')
! 259: {
! 260: p = line_end + 1;
! 261: /* If we see something we think is a timestamp, continue with this
! 262: line. We should check more extensively here... */
! 263: if (HIST_TIMESTAMP_START(p) == 0)
! 264: current_line++;
! 265: line_start = p;
! 266: }
! 267:
! 268: /* If there are lines left to gobble, then gobble them now. */
! 269: for (line_end = line_start; line_end < bufend; line_end++)
! 270: if (*line_end == '\n')
! 271: {
! 272: /* Change to allow Windows-like \r\n end of line delimiter. */
! 273: if (line_end > line_start && line_end[-1] == '\r')
! 274: line_end[-1] = '\0';
! 275: else
! 276: *line_end = '\0';
! 277:
! 278: if (*line_start)
! 279: {
! 280: if (HIST_TIMESTAMP_START(line_start) == 0)
! 281: {
! 282: add_history (line_start);
! 283: if (last_ts)
! 284: {
! 285: add_history_time (last_ts);
! 286: last_ts = NULL;
! 287: }
! 288: }
! 289: else
! 290: {
! 291: last_ts = line_start;
! 292: current_line--;
! 293: }
! 294: }
! 295:
! 296: current_line++;
! 297:
! 298: if (current_line >= to)
! 299: break;
! 300:
! 301: line_start = line_end + 1;
! 302: }
! 303:
! 304: FREE (input);
! 305: #ifndef HISTORY_USE_MMAP
! 306: FREE (buffer);
! 307: #else
! 308: munmap (buffer, file_size);
! 309: #endif
! 310:
! 311: return (0);
! 312: }
! 313:
! 314: /* Truncate the history file FNAME, leaving only LINES trailing lines.
! 315: If FNAME is NULL, then use ~/.history. Returns 0 on success, errno
! 316: on failure. */
! 317: int
! 318: history_truncate_file (fname, lines)
! 319: const char *fname;
! 320: int lines;
! 321: {
! 322: char *buffer, *filename, *bp, *bp1; /* bp1 == bp+1 */
! 323: int file, chars_read, rv;
! 324: struct stat finfo;
! 325: size_t file_size;
! 326:
! 327: buffer = (char *)NULL;
! 328: filename = history_filename (fname);
! 329: file = filename ? open (filename, O_RDONLY|O_BINARY, 0666) : -1;
! 330: rv = 0;
! 331:
! 332: /* Don't try to truncate non-regular files. */
! 333: if (file == -1 || fstat (file, &finfo) == -1)
! 334: {
! 335: rv = errno;
! 336: if (file != -1)
! 337: close (file);
! 338: goto truncate_exit;
! 339: }
! 340:
! 341: if (S_ISREG (finfo.st_mode) == 0)
! 342: {
! 343: close (file);
! 344: #ifdef EFTYPE
! 345: rv = EFTYPE;
! 346: #else
! 347: rv = EINVAL;
! 348: #endif
! 349: goto truncate_exit;
! 350: }
! 351:
! 352: file_size = (size_t)finfo.st_size;
! 353:
! 354: /* check for overflow on very large files */
! 355: if (file_size != finfo.st_size || file_size + 1 < file_size)
! 356: {
! 357: close (file);
! 358: #if defined (EFBIG)
! 359: rv = errno = EFBIG;
! 360: #elif defined (EOVERFLOW)
! 361: rv = errno = EOVERFLOW;
! 362: #else
! 363: rv = errno = EINVAL;
! 364: #endif
! 365: goto truncate_exit;
! 366: }
! 367:
! 368: buffer = (char *)malloc (file_size + 1);
! 369: if (buffer == 0)
! 370: {
! 371: close (file);
! 372: goto truncate_exit;
! 373: }
! 374:
! 375: chars_read = read (file, buffer, file_size);
! 376: close (file);
! 377:
! 378: if (chars_read <= 0)
! 379: {
! 380: rv = (chars_read < 0) ? errno : 0;
! 381: goto truncate_exit;
! 382: }
! 383:
! 384: /* Count backwards from the end of buffer until we have passed
! 385: LINES lines. bp1 is set funny initially. But since bp[1] can't
! 386: be a comment character (since it's off the end) and *bp can't be
! 387: both a newline and the history comment character, it should be OK. */
! 388: for (bp1 = bp = buffer + chars_read - 1; lines && bp > buffer; bp--)
! 389: {
! 390: if (*bp == '\n' && HIST_TIMESTAMP_START(bp1) == 0)
! 391: lines--;
! 392: bp1 = bp;
! 393: }
! 394:
! 395: /* If this is the first line, then the file contains exactly the
! 396: number of lines we want to truncate to, so we don't need to do
! 397: anything. It's the first line if we don't find a newline between
! 398: the current value of i and 0. Otherwise, write from the start of
! 399: this line until the end of the buffer. */
! 400: for ( ; bp > buffer; bp--)
! 401: {
! 402: if (*bp == '\n' && HIST_TIMESTAMP_START(bp1) == 0)
! 403: {
! 404: bp++;
! 405: break;
! 406: }
! 407: bp1 = bp;
! 408: }
! 409:
! 410: /* Write only if there are more lines in the file than we want to
! 411: truncate to. */
! 412: if (bp > buffer && ((file = open (filename, O_WRONLY|O_TRUNC|O_BINARY, 0600)) != -1))
! 413: {
! 414: if (write (file, bp, chars_read - (bp - buffer)) < 0)
! 415: rv = errno;
! 416:
! 417: #if defined (__BEOS__)
! 418: /* BeOS ignores O_TRUNC. */
! 419: ftruncate (file, chars_read - (bp - buffer));
! 420: #endif
! 421:
! 422: if (close (file) < 0 && rv == 0)
! 423: rv = errno;
! 424: }
! 425:
! 426: truncate_exit:
! 427:
! 428: FREE (buffer);
! 429:
! 430: xfree (filename);
! 431: return rv;
! 432: }
! 433:
! 434: /* Workhorse function for writing history. Writes NELEMENT entries
! 435: from the history list to FILENAME. OVERWRITE is non-zero if you
! 436: wish to replace FILENAME with the entries. */
! 437: static int
! 438: history_do_write (filename, nelements, overwrite)
! 439: const char *filename;
! 440: int nelements, overwrite;
! 441: {
! 442: register int i;
! 443: char *output, *bakname;
! 444: int file, mode, rv;
! 445: #ifdef HISTORY_USE_MMAP
! 446: size_t cursize;
! 447:
! 448: mode = overwrite ? O_RDWR|O_CREAT|O_TRUNC|O_BINARY : O_RDWR|O_APPEND|O_BINARY;
! 449: #else
! 450: mode = overwrite ? O_WRONLY|O_CREAT|O_TRUNC|O_BINARY : O_WRONLY|O_APPEND|O_BINARY;
! 451: #endif
! 452: output = history_filename (filename);
! 453: bakname = (overwrite && output) ? history_backupfile (output) : 0;
! 454:
! 455: if (output && bakname)
! 456: rename (output, bakname);
! 457:
! 458: file = output ? open (output, mode, 0600) : -1;
! 459: rv = 0;
! 460:
! 461: if (file == -1)
! 462: {
! 463: rv = errno;
! 464: if (output && bakname)
! 465: rename (bakname, output);
! 466: FREE (output);
! 467: FREE (bakname);
! 468: return (rv);
! 469: }
! 470:
! 471: #ifdef HISTORY_USE_MMAP
! 472: cursize = overwrite ? 0 : lseek (file, 0, SEEK_END);
! 473: #endif
! 474:
! 475: if (nelements > history_length)
! 476: nelements = history_length;
! 477:
! 478: /* Build a buffer of all the lines to write, and write them in one syscall.
! 479: Suggested by Peter Ho (peter@robosts.oxford.ac.uk). */
! 480: {
! 481: HIST_ENTRY **the_history; /* local */
! 482: register int j;
! 483: int buffer_size;
! 484: char *buffer;
! 485:
! 486: the_history = history_list ();
! 487: /* Calculate the total number of bytes to write. */
! 488: for (buffer_size = 0, i = history_length - nelements; i < history_length; i++)
! 489: #if 0
! 490: buffer_size += 2 + HISTENT_BYTES (the_history[i]);
! 491: #else
! 492: {
! 493: if (history_write_timestamps && the_history[i]->timestamp && the_history[i]->timestamp[0])
! 494: buffer_size += strlen (the_history[i]->timestamp) + 1;
! 495: buffer_size += strlen (the_history[i]->line) + 1;
! 496: }
! 497: #endif
! 498:
! 499: /* Allocate the buffer, and fill it. */
! 500: #ifdef HISTORY_USE_MMAP
! 501: if (ftruncate (file, buffer_size+cursize) == -1)
! 502: goto mmap_error;
! 503: buffer = (char *)mmap (0, buffer_size, PROT_READ|PROT_WRITE, MAP_WFLAGS, file, cursize);
! 504: if ((void *)buffer == MAP_FAILED)
! 505: {
! 506: mmap_error:
! 507: rv = errno;
! 508: close (file);
! 509: if (output && bakname)
! 510: rename (bakname, output);
! 511: FREE (output);
! 512: FREE (bakname);
! 513: return rv;
! 514: }
! 515: #else
! 516: buffer = (char *)malloc (buffer_size);
! 517: if (buffer == 0)
! 518: {
! 519: rv = errno;
! 520: close (file);
! 521: if (output && bakname)
! 522: rename (bakname, output);
! 523: FREE (output);
! 524: FREE (bakname);
! 525: return rv;
! 526: }
! 527: #endif
! 528:
! 529: for (j = 0, i = history_length - nelements; i < history_length; i++)
! 530: {
! 531: if (history_write_timestamps && the_history[i]->timestamp && the_history[i]->timestamp[0])
! 532: {
! 533: strcpy (buffer + j, the_history[i]->timestamp);
! 534: j += strlen (the_history[i]->timestamp);
! 535: buffer[j++] = '\n';
! 536: }
! 537: strcpy (buffer + j, the_history[i]->line);
! 538: j += strlen (the_history[i]->line);
! 539: buffer[j++] = '\n';
! 540: }
! 541:
! 542: #ifdef HISTORY_USE_MMAP
! 543: if (msync (buffer, buffer_size, 0) != 0 || munmap (buffer, buffer_size) != 0)
! 544: rv = errno;
! 545: #else
! 546: if (write (file, buffer, buffer_size) < 0)
! 547: rv = errno;
! 548: xfree (buffer);
! 549: #endif
! 550: }
! 551:
! 552: if (close (file) < 0 && rv == 0)
! 553: rv = errno;
! 554:
! 555: if (rv != 0 && output && bakname)
! 556: rename (bakname, output);
! 557: else if (rv == 0 && bakname)
! 558: unlink (bakname);
! 559:
! 560: FREE (output);
! 561: FREE (bakname);
! 562:
! 563: return (rv);
! 564: }
! 565:
! 566: /* Append NELEMENT entries to FILENAME. The entries appended are from
! 567: the end of the list minus NELEMENTs up to the end of the list. */
! 568: int
! 569: append_history (nelements, filename)
! 570: int nelements;
! 571: const char *filename;
! 572: {
! 573: return (history_do_write (filename, nelements, HISTORY_APPEND));
! 574: }
! 575:
! 576: /* Overwrite FILENAME with the current history. If FILENAME is NULL,
! 577: then write the history list to ~/.history. Values returned
! 578: are as in read_history ().*/
! 579: int
! 580: write_history (filename)
! 581: const char *filename;
! 582: {
! 583: return (history_do_write (filename, history_length, HISTORY_OVERWRITE));
! 584: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to histfile.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline