Return to print.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ElectricFence

Annotation of embedaddon/ntp/ElectricFence/print.c, revision 1.1

1.1     ! misho       1: #include "efence.h"
        !             2: #include <stdlib.h>
        !             3: #include <unistd.h>
        !             4: #include <stdarg.h>
        !             5: #include <string.h>
        !             6: #include <signal.h>
        !             7: 
        !             8: /*
        !             9:  * These routines do their printing without using stdio. Stdio can't
        !            10:  * be used because it calls malloc(). Internal routines of a malloc()
        !            11:  * debugger should not re-enter malloc(), so stdio is out.
        !            12:  */
        !            13: 
        !            14: /*
        !            15:  * NUMBER_BUFFER_SIZE is the longest character string that could be needed
        !            16:  * to represent an unsigned integer, assuming we might print in base 2.
        !            17:  */
        !            18: #define        NUMBER_BUFFER_SIZE      (sizeof(ef_number) * NBBY)
        !            19: 
        !            20: static void
        !            21: printNumber(ef_number number, ef_number base)
        !            22: {
        !            23:        char            buffer[NUMBER_BUFFER_SIZE];
        !            24:        char *          s = &buffer[NUMBER_BUFFER_SIZE];
        !            25:        int             size;
        !            26:        
        !            27:        do {
        !            28:                ef_number       digit;
        !            29: 
        !            30:                if ( --s == buffer )
        !            31:                        EF_Abort("Internal error printing number.");
        !            32: 
        !            33:                digit = number % base;
        !            34: 
        !            35:                if ( digit < 10 )
        !            36:                        *s = '0' + digit;
        !            37:                else
        !            38:                        *s = 'a' + digit - 10;
        !            39: 
        !            40:        } while ( (number /= base) > 0 );
        !            41: 
        !            42:        size = &buffer[NUMBER_BUFFER_SIZE] - s;
        !            43: 
        !            44:        if ( size > 0 )
        !            45:                write(2, s, size);
        !            46: }
        !            47: 
        !            48: static void
        !            49: vprint(const char * pattern, va_list args)
        !            50: {
        !            51:        static const char       bad_pattern[] =
        !            52:         "\nBad pattern specifier %%%c in EF_Print().\n";
        !            53:        const char *    s = pattern;
        !            54:        char            c;
        !            55: 
        !            56:        while ( (c = *s++) != '\0' ) {
        !            57:                if ( c == '%' ) {
        !            58:                        c = *s++;
        !            59:                        switch ( c ) {
        !            60:                        case '%':
        !            61:                                (void) write(2, &c, 1);
        !            62:                                break;
        !            63:                        case 'a':
        !            64:                                /*
        !            65:                                 * Print an address passed as a void pointer.
        !            66:                                 * The type of ef_number must be set so that
        !            67:                                 * it is large enough to contain all of the
        !            68:                                 * bits of a void pointer.
        !            69:                                 */
        !            70:                                printNumber(
        !            71:                                 (ef_number)va_arg(args, void *)
        !            72:                                ,0x10);
        !            73:                                break;
        !            74:                        case 's':
        !            75:                                {
        !            76:                                        const char *    string;
        !            77:                                        size_t          length;
        !            78: 
        !            79:                                        string = va_arg(args, char *);
        !            80:                                        length = strlen(string);
        !            81: 
        !            82:                                        (void) write(2, string, length);
        !            83:                                }
        !            84:                                break;
        !            85:                        case 'd':
        !            86:                                {
        !            87:                                        int     n = va_arg(args, int);
        !            88: 
        !            89:                                        if ( n < 0 ) {
        !            90:                                                char    c = '-';
        !            91:                                                write(2, &c, 1);
        !            92:                                                n = -n;
        !            93:                                        }
        !            94:                                        printNumber(n, 10);
        !            95:                                }
        !            96:                                break;
        !            97:                        case 'x':
        !            98:                                printNumber(va_arg(args, u_int), 0x10);
        !            99:                                break;
        !           100:                        case 'c':
        !           101:                                {
        !           102:                                        char    c = va_arg(args, char);
        !           103:                                        
        !           104:                                        (void) write(2, &c, 1);
        !           105:                                }
        !           106:                                break;
        !           107:                        default:
        !           108:                                {
        !           109:                                        EF_Print(bad_pattern, c);
        !           110:                                }
        !           111:                
        !           112:                        }
        !           113:                }
        !           114:                else
        !           115:                        (void) write(2, &c, 1);
        !           116:        }
        !           117: }
        !           118: 
        !           119: void
        !           120: EF_Abort(const char * pattern, ...)
        !           121: {
        !           122:        va_list args;
        !           123: 
        !           124:        va_start(args, pattern);
        !           125: 
        !           126:        EF_Print("\nElectricFence Aborting: ");
        !           127:        vprint(pattern, args);
        !           128:        EF_Print("\n");
        !           129: 
        !           130:        va_end(args);
        !           131: 
        !           132:        /*
        !           133:         * I use kill(getpid(), SIGILL) instead of abort() because some
        !           134:         * mis-guided implementations of abort() flush stdio, which can
        !           135:         * cause malloc() or free() to be called.
        !           136:         */
        !           137:        kill(getpid(), SIGILL);
        !           138:        /* Just in case something handles SIGILL and returns, exit here. */
        !           139:        _exit(-1);
        !           140: }
        !           141: 
        !           142: void
        !           143: EF_Exit(const char * pattern, ...)
        !           144: {
        !           145:        va_list args;
        !           146: 
        !           147:        va_start(args, pattern);
        !           148: 
        !           149:        EF_Print("\nElectricFence Exiting: ");
        !           150:        vprint(pattern, args);
        !           151:        EF_Print("\n");
        !           152: 
        !           153:        va_end(args);
        !           154: 
        !           155:        /*
        !           156:         * I use _exit() because the regular exit() flushes stdio,
        !           157:         * which may cause malloc() or free() to be called.
        !           158:         */
        !           159:        _exit(-1);
        !           160: }
        !           161: 
        !           162: void
        !           163: EF_Print(const char * pattern, ...)
        !           164: {
        !           165:        va_list args;
        !           166: 
        !           167:        va_start(args, pattern);
        !           168:        vprint(pattern, args);
        !           169:        va_end(args);
        !           170: }