src/hci/readline.c

   1 /*
   2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  *
  19  * You can also choose to distribute this program under the terms of
  20  * the Unmodified Binary Distribution Licence (as given in the file
  21  * COPYING.UBDL), provided that you have satisfied its requirements.
  22  */
  23
  24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <errno.h>
  30 #include <ipxe/console.h>
  31 #include <ipxe/keys.h>
  32 #include <ipxe/editstring.h>
  33 #include <readline/readline.h>
  34
  35 /** @file
  36  *
  37  * Minimal readline
  38  *
  39  */
  40
  41 #define READLINE_MAX 1024
  42
  43 /**
  44  * Synchronise console with edited string
  45  *
  46  * @v string            Editable string
  47  */
  48 static void sync_console ( struct edit_string *string ) {
  49         unsigned int mod_start = string->mod_start;
  50         unsigned int mod_end = string->mod_end;
  51         unsigned int cursor = string->last_cursor;
  52         size_t len = strlen ( string->buf );
  53
  54         /* Expand region back to old cursor position if applicable */
  55         if ( mod_start > string->last_cursor )
  56                 mod_start = string->last_cursor;
  57
  58         /* Expand region forward to new cursor position if applicable */
  59         if ( mod_end < string->cursor )
  60                 mod_end = string->cursor;
  61
  62         /* Backspace to start of region */
  63         while ( cursor > mod_start ) {
  64                 putchar ( '\b' );
  65                 cursor--;
  66         }
  67
  68         /* Print modified region */
  69         while ( cursor < mod_end ) {
  70                 putchar ( ( cursor >= len ) ? ' ' : string->buf[cursor] );
  71                 cursor++;
  72         }
  73
  74         /* Backspace to new cursor position */
  75         while ( cursor > string->cursor ) {
  76                 putchar ( '\b' );
  77                 cursor--;
  78         }
  79 }
  80
  81 /**
  82  * Locate history entry
  83  *
  84  * @v history           History buffer
  85  * @v depth             Depth within history buffer
  86  * @ret entry           History entry
  87  */
  88 static struct readline_history_entry *
  89 history_entry ( struct readline_history *history, unsigned int depth ) {
  90         unsigned int offset;
  91
  92         offset = ( ( history->next - depth ) %
  93                    ( sizeof ( history->entries ) /
  94                      sizeof ( history->entries[0] ) ) );
  95         return &history->entries[offset];
  96 }
  97
  98 /**
  99  * Read string from history buffer
 100  *
 101  * @v history           History buffer
 102  * @v depth             Depth within history buffer
 103  * @ret string          String
 104  */
 105 static const char * history_fetch ( struct readline_history *history,
 106                                     unsigned int depth ) {
 107         struct readline_history_entry *entry;
 108
 109         /* Return the temporary copy if it exists, otherwise return
 110          * the persistent copy.
 111          */
 112         entry = history_entry ( history, depth );
 113         return ( entry->temp ? entry->temp : entry->string );
 114 }
 115
 116 /**
 117  * Write temporary string copy to history buffer
 118  *
 119  * @v history           History buffer
 120  * @v depth             Depth within history buffer
 121  * @v string            String
 122  */
 123 static void history_store ( struct readline_history *history,
 124                             unsigned int depth, const char *string ) {
 125         struct readline_history_entry *entry;
 126         char *temp;
 127
 128         /* Create temporary copy of string */
 129         temp = strdup ( string );
 130         if ( ! temp ) {
 131                 /* Just discard the string; there's nothing we can do */
 132                 DBGC ( history, "READLINE %p could not store string\n",
 133                        history );
 134                 return;
 135         }
 136
 137         /* Store temporary copy */
 138         entry = history_entry ( history, depth );
 139         free ( entry->temp );
 140         entry->temp = temp;
 141 }
 142
 143 /**
 144  * Move to new history depth
 145  *
 146  * @v history           History buffer
 147  * @v offset            Offset by which to change depth
 148  * @v old_string        String (possibly modified) at current depth
 149  * @ret new_string      String at new depth, or NULL for no movement
 150  */
 151 static const char * history_move ( struct readline_history *history,
 152                                    int offset, const char *old_string ) {
 153         unsigned int new_depth = ( history->depth + offset );
 154         const char * new_string = history_fetch ( history, new_depth );
 155
 156         /* Depth checks */
 157         if ( new_depth > READLINE_HISTORY_MAX_DEPTH )
 158                 return NULL;
 159         if ( ! new_string )
 160                 return NULL;
 161
 162         /* Store temporary copy of old string at current depth */
 163         history_store ( history, history->depth, old_string );
 164
 165         /* Update depth */
 166         history->depth = new_depth;
 167
 168         /* Return new string */
 169         return new_string;
 170 }
 171
 172 /**
 173  * Append new history entry
 174  *
 175  * @v history           History buffer
 176  * @v string            String
 177  */
 178 static void history_append ( struct readline_history *history,
 179                              const char *string ) {
 180         struct readline_history_entry *entry;
 181
 182         /* Store new entry */
 183         entry = history_entry ( history, 0 );
 184         assert ( entry->string == NULL );
 185         entry->string = strdup ( string );
 186         if ( ! entry->string ) {
 187                 /* Just discard the string; there's nothing we can do */
 188                 DBGC ( history, "READLINE %p could not append string\n",
 189                        history );
 190                 return;
 191         }
 192
 193         /* Increment history position */
 194         history->next++;
 195
 196         /* Prepare empty "next" slot */
 197         entry = history_entry ( history, 0 );
 198         free ( entry->string );
 199         entry->string = NULL;
 200 }
 201
 202 /**
 203  * Clean up history after editing
 204  *
 205  * @v history           History buffer
 206  */
 207 static void history_cleanup ( struct readline_history *history ) {
 208         struct readline_history_entry *entry;
 209         unsigned int i;
 210
 211         /* Discard any temporary strings */
 212         for ( i = 0 ; i < ( sizeof ( history->entries ) /
 213                             sizeof ( history->entries[0] ) ) ; i++ ) {
 214                 entry = &history->entries[i];
 215                 free ( entry->temp );
 216                 entry->temp = NULL;
 217         }
 218
 219         /* Reset depth */
 220         history->depth = 0;
 221
 222         /* Sanity check */
 223         entry = history_entry ( history, 0 );
 224         assert ( entry->string == NULL );
 225 }
 226
 227 /**
 228  * Free history buffer
 229  *
 230  * @v history           History buffer
 231  */
 232 void history_free ( struct readline_history *history ) {
 233         struct readline_history_entry *entry;
 234         unsigned int i;
 235
 236         /* Discard any temporary strings */
 237         for ( i = 0 ; i < ( sizeof ( history->entries ) /
 238                             sizeof ( history->entries[0] ) ) ; i++ ) {
 239                 entry = &history->entries[i];
 240                 assert ( entry->temp == NULL );
 241                 free ( entry->string );
 242         }
 243 }
 244
 245 /**
 246  * Read line from console (with history)
 247  *
 248  * @v prompt            Prompt string
 249  * @v prefill           Prefill string, or NULL for no prefill
 250  * @v history           History buffer, or NULL for no history
 251  * @v timeout           Timeout period, in ticks (0=indefinite)
 252  * @ret line            Line read from console (excluding terminating newline)
 253  * @ret rc              Return status code
 254  *
 255  * The returned line is allocated with malloc(); the caller must
 256  * eventually call free() to release the storage.
 257  */
 258 int readline_history ( const char *prompt, const char *prefill,
 259                        struct readline_history *history, unsigned long timeout,
 260                        char **line ) {
 261         struct edit_string string;
 262         char *buf;
 263         int key;
 264         int move_by;
 265         const char *new_string;
 266         int rc;
 267
 268         /* Avoid returning uninitialised data on error */
 269         *line = NULL;
 270
 271         /* Display prompt, if applicable */
 272         if ( prompt )
 273                 printf ( "%s", prompt );
 274
 275         /* Ensure cursor is visible */
 276         printf ( "\033[?25h" );
 277
 278         /* Allocate buffer and initialise editable string */
 279         buf = zalloc ( READLINE_MAX );
 280         if ( ! buf ) {
 281                 rc = -ENOMEM;
 282                 goto done;
 283         }
 284         memset ( &string, 0, sizeof ( string ) );
 285         init_editstring ( &string, buf, READLINE_MAX );
 286
 287         /* Prefill string, if applicable */
 288         if ( prefill ) {
 289                 replace_string ( &string, prefill );
 290                 sync_console ( &string );
 291         }
 292
 293         while ( 1 ) {
 294
 295                 /* Get keypress */
 296                 key = getkey ( timeout );
 297                 if ( key < 0 ) {
 298                         rc = -ETIMEDOUT;
 299                         goto done;
 300                 }
 301                 timeout = 0;
 302
 303                 /* Handle keypress */
 304                 key = edit_string ( &string, key );
 305                 sync_console ( &string );
 306                 move_by = 0;
 307                 switch ( key ) {
 308                 case CR:
 309                 case LF:
 310                         /* Shrink string (ignoring failures) */
 311                         *line = realloc ( buf,
 312                                           ( strlen ( buf ) + 1 /* NUL */ ) );
 313                         if ( ! *line )
 314                                 *line = buf;
 315                         buf = NULL;
 316                         rc = 0;
 317                         goto done;
 318                 case CTRL_C:
 319                         rc = -ECANCELED;
 320                         goto done;
 321                 case KEY_UP:
 322                         move_by = 1;
 323                         break;
 324                 case KEY_DOWN:
 325                         move_by = -1;
 326                         break;
 327                 default:
 328                         /* Do nothing */
 329                         break;
 330                 }
 331
 332                 /* Handle history movement, if applicable */
 333                 if ( move_by && history ) {
 334                         new_string = history_move ( history, move_by, buf );
 335                         if ( new_string ) {
 336                                 replace_string ( &string, new_string );
 337                                 sync_console ( &string );
 338                         }
 339                 }
 340         }
 341
 342  done:
 343         putchar ( '\n' );
 344         free ( buf );
 345         if ( history ) {
 346                 if ( *line && (*line)[0] )
 347                         history_append ( history, *line );
 348                 history_cleanup ( history );
 349         }
 350         assert ( ( rc == 0 ) ^ ( *line == NULL ) );
 351         return rc;
 352 }
 353
 354 /**
 355  * Read line from console
 356  *
 357  * @v prompt            Prompt string
 358  * @ret line            Line read from console (excluding terminating newline)
 359  *
 360  * The returned line is allocated with malloc(); the caller must
 361  * eventually call free() to release the storage.
 362  */
 363 char * readline ( const char *prompt ) {
 364         char *line;
 365
 366         readline_history ( prompt, NULL, NULL, 0, &line );
 367         return line;
 368 }