Annotation of embedaddon/readline/examples/rl-fgets.c, revision 1.1
1.1 ! misho 1: /*
! 2: Date: Tue, 16 Mar 2004 19:38:40 -0800
! 3: From: Harold Levy <Harold.Levy@synopsys.com>
! 4: Subject: fgets(stdin) --> readline() redirector
! 5: To: chet@po.cwru.edu
! 6:
! 7: Hi Chet,
! 8:
! 9: Here is something you may find useful enough to include in the readline
! 10: distribution. It is a shared library that redirects calls to fgets(stdin)
! 11: to readline() via LD_PRELOAD, and it supports a custom prompt and list of
! 12: command names. Many people have asked me for this file, so I thought I'd
! 13: pass it your way in hope of just including it with readline to begin with.
! 14:
! 15: Best Regards,
! 16:
! 17: -Harold
! 18: */
! 19:
! 20: /******************************************************************************
! 21: *******************************************************************************
! 22:
! 23: FILE NAME: fgets.c TARGET: libfgets.so
! 24: AUTHOR: Harold Levy VERSION: 1.0
! 25: hlevy@synopsys.com
! 26:
! 27: ABSTRACT: Customize fgets() behavior via LD_PRELOAD in the following ways:
! 28:
! 29: -- If fgets(stdin) is called, redirect to GNU readline() to obtain
! 30: command-line editing, file-name completion, history, etc.
! 31:
! 32: -- A list of commands for command-name completion can be configured by
! 33: setting the environment-variable FGETS_COMMAND_FILE to a file containing
! 34: the list of commands to be used.
! 35:
! 36: -- Command-line editing with readline() works best when the prompt string
! 37: is known; you can set this with the FGETS_PROMPT environment variable.
! 38:
! 39: -- There special strings that libfgets will interpret as internal commands:
! 40:
! 41: _fgets_reset_ reset the command list
! 42:
! 43: _fgets_dump_ dump status
! 44:
! 45: _fgets_debug_ toggle debug messages
! 46:
! 47: HOW TO BUILD: Here are examples of how to build libfgets.so on various
! 48: platforms; you will have to add -I and -L flags to configure access to
! 49: the readline header and library files.
! 50:
! 51: (32-bit builds with gcc)
! 52: AIX: gcc -fPIC fgets.c -shared -o libfgets.so -lc -ldl -lreadline -ltermcap
! 53: HP-UX: gcc -fPIC fgets.c -shared -o libfgets.so -lc -ldld -lreadline
! 54: Linux: gcc -fPIC fgets.c -shared -o libfgets.so -lc -ldl -lreadline
! 55: SunOS: gcc -fPIC fgets.c -shared -o libfgets.so -lc -ldl -lgen -lreadline
! 56:
! 57: (64-bit builds without gcc)
! 58: SunOS: SUNWspro/bin/cc -D_LARGEFILE64_SOURCE=1 -xtarget=ultra -xarch=v9 \
! 59: -KPIC fgets.c -Bdynamic -lc -ldl -lgen -ltermcap -lreadline
! 60:
! 61: HOW TO USE: Different operating systems have different levels of support
! 62: for the LD_PRELOAD concept. The generic method for 32-bit platforms is to
! 63: put libtermcap.so, libfgets.so, and libreadline.so (with absolute paths)
! 64: in the LD_PRELOAD environment variable, and to put their parent directories
! 65: in the LD_LIBRARY_PATH environment variable. Unfortunately there is no
! 66: generic method for 64-bit platforms; e.g. for 64-bit SunOS, you would have
! 67: to build both 32-bit and 64-bit libfgets and libreadline libraries, and
! 68: use the LD_FLAGS_32 and LD_FLAGS_64 environment variables with preload and
! 69: library_path configurations (a mix of 32-bit and 64-bit calls are made under
! 70: 64-bit SunOS).
! 71:
! 72: EXAMPLE WRAPPER: Here is an example shell script wrapper around the
! 73: program "foo" that uses fgets() for command-line input:
! 74:
! 75: #!/bin/csh
! 76: #### replace this with the libtermcap.so directory:
! 77: set dir1 = "/usr/lib"
! 78: #### replace this with the libfgets.so directory:
! 79: set dir2 = "/usr/fgets"
! 80: #### replace this with the libreadline.so directory:
! 81: set dir3 = "/usr/local/lib"
! 82: set lib1 = "${dir1}/libtermcap.so"
! 83: set lib2 = "${dir2}/libfgets.so"
! 84: set lib3 = "${dir3}/libreadline.so"
! 85: if ( "${?LD_PRELOAD}" ) then
! 86: setenv LD_PRELOAD "${lib1}:${lib2}:${lib3}:${LD_PRELOAD}"
! 87: else
! 88: setenv LD_PRELOAD "${lib1}:${lib2}:${lib3}"
! 89: endif
! 90: if ( "${?LD_LIBRARY_PATH}" ) then
! 91: setenv LD_LIBRARY_PATH "${dir1}:${dir2}:${dir3}:${LD_LIBRARY_PATH}"
! 92: else
! 93: setenv LD_LIBRARY_PATH "${dir1}:${dir2}:${dir3}"
! 94: endif
! 95: setenv FGETS_COMMAND_FILE "${dir2}/foo.commands"
! 96: setenv FGETS_PROMPT "foo> "
! 97: exec "foo" $*
! 98:
! 99: Copyright (C)©2003-2004 Harold Levy.
! 100:
! 101: This code links to the GNU readline library, and as such is bound by the
! 102: terms of the GNU General Public License as published by the Free Software
! 103: Foundation, either version 2 or (at your option) any later version.
! 104:
! 105: The GNU General Public License is often shipped with GNU software, and is
! 106: generally kept in a file called COPYING or LICENSE. If you do not have a
! 107: copy of the license, write to the Free Software Foundation, 59 Temple Place,
! 108: Suite 330, Boston, MA 02111 USA.
! 109:
! 110: This program is distributed in the hope that it will be useful, but WITHOUT
! 111: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
! 112: FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
! 113: details.
! 114:
! 115: *******************************************************************************
! 116: ******************************************************************************/
! 117:
! 118:
! 119:
! 120: #include <dlfcn.h>
! 121: #include <stdio.h>
! 122: #include <strings.h>
! 123: #include <stdlib.h>
! 124: #include <unistd.h>
! 125:
! 126: #include <readline/readline.h>
! 127: #include <readline/history.h>
! 128:
! 129:
! 130:
! 131: /* for dynamically connecting to the native fgets() */
! 132: #if defined(RTLD_NEXT)
! 133: #define REAL_LIBC RTLD_NEXT
! 134: #else
! 135: #define REAL_LIBC ((void *) -1L)
! 136: #endif
! 137: typedef char * ( * fgets_t ) ( char * s, int n, FILE * stream ) ;
! 138:
! 139:
! 140:
! 141: /* private data */
! 142: /* -- writeable data is stored in the shared library's data segment
! 143: -- every process that uses the shared library gets a private memory copy of
! 144: its entire data segment
! 145: -- static data in the shared library is not copied to the application
! 146: -- only read-only (i.e. 'const') data is stored in the shared library's
! 147: text segment
! 148: */
! 149: static char ** my_fgets_names = NULL ;
! 150: static int my_fgets_number_of_names = 0 ;
! 151: static int my_fgets_debug_flag = 0 ;
! 152:
! 153:
! 154:
! 155: /* invoked with _fgets_reset_ */
! 156: static void
! 157: my_fgets_reset (
! 158: void
! 159: ) {
! 160: if ( my_fgets_names && (my_fgets_number_of_names > 0) ) {
! 161: int i ;
! 162: if ( my_fgets_debug_flag ) {
! 163: printf ( "libfgets: removing command list\n" ) ;
! 164: }
! 165: for ( i = 0 ; i < my_fgets_number_of_names ; i ++ ) {
! 166: if ( my_fgets_names[i] ) free ( my_fgets_names[i] ) ;
! 167: }
! 168: free ( my_fgets_names ) ;
! 169: }
! 170: my_fgets_names = NULL ;
! 171: my_fgets_number_of_names = 0 ;
! 172: }
! 173:
! 174:
! 175:
! 176: /* invoked with _fgets_dump_ */
! 177: static void
! 178: my_fgets_dump (
! 179: void
! 180: ) {
! 181: char * s ;
! 182: printf ( "\n" ) ;
! 183: s = getenv ( "FGETS_PROMPT" ) ;
! 184: printf ( "FGETS_PROMPT = %s\n", s ? s : "" ) ;
! 185: s = getenv ( "FGETS_COMMAND_FILE" ) ;
! 186: printf ( "FGETS_COMMAND_FILE = %s\n", s ? s : "" ) ;
! 187: printf ( "debug flag = %d\n", my_fgets_debug_flag ) ;
! 188: printf ( "#commands = %d\n", my_fgets_number_of_names ) ;
! 189: if ( my_fgets_debug_flag ) {
! 190: if ( my_fgets_names && (my_fgets_number_of_names > 0) ) {
! 191: int i ;
! 192: for ( i = 0 ; i < my_fgets_number_of_names ; i ++ ) {
! 193: printf ( "%s\n", my_fgets_names[i] ) ;
! 194: }
! 195: }
! 196: }
! 197: printf ( "\n" ) ;
! 198: }
! 199:
! 200:
! 201:
! 202: /* invoked with _fgets_debug_ */
! 203: static void
! 204: my_fgets_debug_toggle (
! 205: void
! 206: ) {
! 207: my_fgets_debug_flag = my_fgets_debug_flag ? 0 : 1 ;
! 208: if ( my_fgets_debug_flag ) {
! 209: printf ( "libfgets: debug flag = %d\n", my_fgets_debug_flag ) ;
! 210: }
! 211: }
! 212:
! 213:
! 214:
! 215: /* read the command list if needed, return the i-th name */
! 216: static char *
! 217: my_fgets_lookup (
! 218: int index
! 219: ) {
! 220: if ( (! my_fgets_names) || (! my_fgets_number_of_names) ) {
! 221: char * fname ;
! 222: FILE * fp ;
! 223: fgets_t _fgets ;
! 224: int i ;
! 225: char buf1[256], buf2[256] ;
! 226: fname = getenv ( "FGETS_COMMAND_FILE" ) ;
! 227: if ( ! fname ) {
! 228: if ( my_fgets_debug_flag ) {
! 229: printf ( "libfgets: empty or unset FGETS_COMMAND_FILE\n" ) ;
! 230: }
! 231: return NULL ;
! 232: }
! 233: fp = fopen ( fname, "r" ) ;
! 234: if ( ! fp ) {
! 235: if ( my_fgets_debug_flag ) {
! 236: printf ( "libfgets: cannot open '%s' for reading\n", fname ) ;
! 237: }
! 238: return NULL ;
! 239: }
! 240: _fgets = (fgets_t) dlsym ( REAL_LIBC, "fgets" ) ;
! 241: if ( ! _fgets ) {
! 242: fprintf ( stderr,
! 243: "libfgets: failed to dynamically link to native fgets()\n"
! 244: ) ;
! 245: return NULL ;
! 246: }
! 247: for ( i = 0 ; _fgets(buf1,255,fp) ; i ++ ) ;
! 248: if ( ! i ) { fclose(fp) ; return NULL ; }
! 249: my_fgets_names = (char**) calloc ( i, sizeof(char*) ) ;
! 250: rewind ( fp ) ;
! 251: i = 0 ;
! 252: while ( _fgets(buf1,255,fp) ) {
! 253: buf1[255] = 0 ;
! 254: if ( 1 == sscanf(buf1,"%s",buf2) ) {
! 255: my_fgets_names[i] = strdup(buf2) ;
! 256: i ++ ;
! 257: }
! 258: }
! 259: fclose ( fp ) ;
! 260: my_fgets_number_of_names = i ;
! 261: if ( my_fgets_debug_flag ) {
! 262: printf ( "libfgets: successfully read %d commands\n", i ) ;
! 263: }
! 264: }
! 265: if ( index < my_fgets_number_of_names ) {
! 266: return my_fgets_names[index] ;
! 267: } else {
! 268: return NULL ;
! 269: }
! 270: }
! 271:
! 272:
! 273:
! 274: /* generate a list of partial name matches for readline() */
! 275: static char *
! 276: my_fgets_generator (
! 277: const char * text,
! 278: int state
! 279: )
! 280: {
! 281: static int list_index, len ;
! 282: char * name ;
! 283: if ( ! state ) {
! 284: list_index = 0 ;
! 285: len = strlen ( text ) ;
! 286: }
! 287: while ( ( name = my_fgets_lookup(list_index) ) ) {
! 288: list_index ++ ;
! 289: if ( ! strncmp ( name, text, len ) ) {
! 290: return ( strdup ( name ) ) ;
! 291: }
! 292: }
! 293: return ( NULL ) ;
! 294: }
! 295:
! 296:
! 297:
! 298: /* partial name completion callback for readline() */
! 299: static char **
! 300: my_fgets_completion (
! 301: const char * text,
! 302: int start,
! 303: int end
! 304: )
! 305: {
! 306: char ** matches ;
! 307: matches = NULL ;
! 308: if ( ! start ) {
! 309: matches = rl_completion_matches ( text, my_fgets_generator ) ;
! 310: }
! 311: return ( matches ) ;
! 312: }
! 313:
! 314:
! 315:
! 316: /* fgets() intercept */
! 317: char *
! 318: fgets (
! 319: char * s,
! 320: int n,
! 321: FILE * stream
! 322: )
! 323: {
! 324: if ( ! s ) return NULL ;
! 325: if ( stream == stdin ) {
! 326: char * prompt ;
! 327: char * my_fgets_line ;
! 328: rl_already_prompted = 1 ;
! 329: rl_attempted_completion_function = my_fgets_completion ;
! 330: rl_catch_signals = 1 ;
! 331: rl_catch_sigwinch = 1 ;
! 332: rl_set_signals () ;
! 333: prompt = getenv ( "FGETS_PROMPT" ) ;
! 334: for (
! 335: my_fgets_line = 0 ; ! my_fgets_line ; my_fgets_line=readline(prompt)
! 336: ) ;
! 337: if ( ! strncmp(my_fgets_line, "_fgets_reset_", 13) ) {
! 338: my_fgets_reset () ;
! 339: free ( my_fgets_line ) ;
! 340: strcpy ( s, "\n" ) ;
! 341: return ( s ) ;
! 342: }
! 343: if ( ! strncmp(my_fgets_line, "_fgets_dump_", 12) ) {
! 344: my_fgets_dump () ;
! 345: free ( my_fgets_line ) ;
! 346: strcpy ( s, "\n" ) ;
! 347: return ( s ) ;
! 348: }
! 349: if ( ! strncmp(my_fgets_line, "_fgets_debug_", 13) ) {
! 350: my_fgets_debug_toggle () ;
! 351: free ( my_fgets_line ) ;
! 352: strcpy ( s, "\n" ) ;
! 353: return ( s ) ;
! 354: }
! 355: (void) strncpy ( s, my_fgets_line, n-1 ) ;
! 356: (void) strcat ( s, "\n" ) ;
! 357: if ( *my_fgets_line ) add_history ( my_fgets_line ) ;
! 358: free ( my_fgets_line ) ;
! 359: return ( s ) ;
! 360: } else {
! 361: static fgets_t _fgets ;
! 362: _fgets = (fgets_t) dlsym ( REAL_LIBC, "fgets" ) ;
! 363: if ( ! _fgets ) {
! 364: fprintf ( stderr,
! 365: "libfgets: failed to dynamically link to native fgets()\n"
! 366: ) ;
! 367: strcpy ( s, "\n" ) ;
! 368: return ( s ) ;
! 369: }
! 370: return (
! 371: _fgets ( s, n, stream )
! 372: ) ;
! 373: }
! 374: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rl-fgets.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 / examples