1  /*
  2   *
  3   * Copyright (C) 2008 coresystems GmbH
  4   *
  5   * Redistribution and use in source and binary forms, with or without
  6   * modification, are permitted provided that the following conditions
  7   * are met:
  8   * 1. Redistributions of source code must retain the above copyright
  9   *    notice, this list of conditions and the following disclaimer.
 10   * 2. Redistributions in binary form must reproduce the above copyright
 11   *    notice, this list of conditions and the following disclaimer in the
 12   *    documentation and/or other materials provided with the distribution.
 13   * 3. The name of the author may not be used to endorse or promote products
 14   *    derived from this software without specific prior written permission.
 15   *
 16   * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 17   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 18   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 19   * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 20   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 21   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 22   * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 23   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 24   * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 25   * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 26   * SUCH DAMAGE.
 27   */
 28  
 29  /**
 30   * @file libc/readline.c
 31   * Simple readline implementation
 32   */
 33  
 34  #include <libpayload.h>
 35  
 36  static char *readline_buffer;
 37  static int readline_bufferlen;
 38  
 39  /**
 40   * Read a line from the terminal and return it.
 41   *
 42   * This readline implementation is rather simple, but it does more than the
 43   * original readline() because it allows us to have a pre-filled buffer.
 44   * To pre-fill the buffer, use the getline() function.
 45   *
 46   * @param prompt A prompt to display on the line.
 47   * @return A pointer to the input string.
 48   */
 49  char *readline(const char *prompt)
 50  {
 51  	char *buffer;
 52  	int current, ch, nonspace_seen;
 53  
 54  	if (!readline_buffer || !readline_bufferlen) {
 55  #define READLINE_BUFFERSIZE	256
 56  		readline_buffer = malloc(READLINE_BUFFERSIZE);
 57  		if (!readline_buffer)
 58  			return NULL;
 59  		readline_bufferlen = READLINE_BUFFERSIZE;
 60  		memset(readline_buffer, 0, readline_bufferlen);
 61  	}
 62  
 63  	buffer = readline_buffer;
 64  
 65  	/* print prompt */
 66  	if (prompt) {
 67  		current = 0;
 68  		while (prompt[current]) {
 69  			putchar(prompt[current]);
 70  			current++;
 71  		}
 72  	}
 73  
 74  	/* print existing buffer, if there is one */
 75  	current = 0;
 76  	while (buffer[current]) {
 77  		putchar(buffer[current]);
 78  		current++;
 79  	}
 80  
 81  	while (1) {
 82  		ch = getchar();
 83  		switch (ch) {
 84  		case '\r':
 85  		case '\n':
 86  			/* newline */
 87  			putchar('\n');
 88  			goto out;
 89  		case '\b':
 90  		case '\x7f':
 91  			/* backspace */
 92  			if (current > 0) {
 93  				putchar('\b');
 94  				putchar(' ');
 95  				putchar('\b');
 96  				current--;
 97  			}
 98  			break;
 99  		case 'W' & 0x1f:	/* CTRL-W */
100  			/* word erase */
101  			nonspace_seen = 0;
102  			while (current) {
103  				if (buffer[current - 1] != ' ')
104  					nonspace_seen = 1;
105  				putchar('\b');
106  				putchar(' ');
107  				putchar('\b');
108  				current--;
109  				if (nonspace_seen && (current < readline_bufferlen - 1)
110  				    && (current > 0) && (buffer[current - 1] == ' '))
111  					break;
112  			}
113  			break;
114  		case 'U' & 0x1f:	/* CTRL-U */
115  			/* line erase */
116  			while (current) {
117  				putchar('\b');
118  				putchar(' ');
119  				putchar('\b');
120  				current--;
121  			}
122  			current = 0;
123  			break;
124  		default:
125  			/* all other characters */
126  
127  			/* ignore control characters */
128  			if (ch < 0x20)
129  				break;
130  
131  			/* ignore unprintable characters */
132  			if (ch >= 0x7f)
133  				break;
134  
135  			if (current + 1 < readline_bufferlen) {
136  				/* print new character */
137  				putchar(ch);
138  				/* and add it to the array */
139  				buffer[current] = ch;
140  				current++;
141  			}
142  		}
143  	}
144  
145  out:
146  	if (current >= readline_bufferlen)
147  		current = readline_bufferlen - 1;
148  	buffer[current] = '\0';
149  
150  	return buffer;
151  }
152  
153  /**
154   * Read a line from the input and store it in a buffer.
155   *
156   * This function allows the user to pass a predefined buffer to readline().
157   * The buffer may be filled with a default value which will be displayed by
158   * readline() and can be edited as normal.
159   * The final input string returned by readline() will be returned in
160   * the buffer and the function will return the length of the string.
161   *
162   * @param buffer Pointer to a buffer to store the line in.
163   * @param len Length of the buffer.
164   * @return The final length of the string.
165   */
166  int getline(char *buffer, int len)
167  {
168  	readline_buffer = buffer;
169  	readline_bufferlen = len;
170  	readline(NULL);
171  
172  	return strlen(buffer);
173  }