Return to utilities.c CVS log

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

Annotation of embedaddon/ntp/sntp/utilities.c, revision 1.1

1.1     ! misho       1: #include <config.h>
        !             2: #include "utilities.h"
        !             3: #include <assert.h>
        !             4: 
        !             5: /* Display a NTP packet in hex with leading address offset 
        !             6:  * e.g. offset: value, 0: ff 1: fe ... 255: 00
        !             7:  */ 
        !             8: void 
        !             9: pkt_output (
        !            10:                struct pkt *dpkg,
        !            11:                int pkt_length, 
        !            12:                FILE *output
        !            13:           )
        !            14: {
        !            15:        register int a;
        !            16:        u_char *pkt;
        !            17: 
        !            18:        pkt = (u_char *)dpkg;
        !            19: 
        !            20:        fprintf(output, HLINE);
        !            21: 
        !            22:        for (a = 0; a < pkt_length; a++) {
        !            23:                if (a > 0 && a % 8 == 0)
        !            24:                        fprintf(output, "\n");
        !            25: 
        !            26:                fprintf(output, "%d: %x \t", a, pkt[a]);
        !            27:        }
        !            28: 
        !            29:        fprintf(output, "\n");
        !            30:        fprintf(output, HLINE);
        !            31: }
        !            32: 
        !            33: /* Output a long floating point value in hex in the style described above 
        !            34:  */
        !            35: void
        !            36: l_fp_output (
        !            37:                l_fp *ts,
        !            38:                FILE *output
        !            39:            )
        !            40: {
        !            41:        register int a;
        !            42: 
        !            43:        fprintf(output, HLINE);
        !            44: 
        !            45:        for(a=0; a<8; a++) 
        !            46:                fprintf(output, "%i: %x \t", a, ((unsigned char *) ts)[a]);
        !            47: 
        !            48:        fprintf(output, "\n");
        !            49:        fprintf(output, HLINE);
        !            50: 
        !            51: }
        !            52: 
        !            53: /* Output a long floating point value in binary in the style described above
        !            54:  */
        !            55: void 
        !            56: l_fp_output_bin (
        !            57:                l_fp *ts,
        !            58:                FILE *output
        !            59:                )
        !            60: {
        !            61:        register int a, b;
        !            62: 
        !            63:        fprintf(output, HLINE);
        !            64: 
        !            65:        for(a=0; a<8; a++) {
        !            66:                short tmp = ((unsigned char *) ts)[a];
        !            67:                tmp++;
        !            68: 
        !            69:                fprintf(output, "%i: ", a);
        !            70: 
        !            71:                for(b=7; b>=0; b--) {
        !            72:                        int texp = (int) pow(2, b);
        !            73: 
        !            74:                        if(tmp - texp > 0) {
        !            75:                                fprintf(output, "1");
        !            76:                                tmp -= texp;
        !            77:                        }
        !            78:                        else {
        !            79:                                fprintf(output, "0");
        !            80:                        }
        !            81:                }
        !            82: 
        !            83:                fprintf(output, " ");
        !            84:        }
        !            85: 
        !            86:        fprintf(output, "\n");
        !            87:        fprintf(output, HLINE);
        !            88: }
        !            89: 
        !            90: /* Output a long floating point value in decimal in the style described above
        !            91:  */
        !            92: void
        !            93: l_fp_output_dec (
        !            94:                l_fp *ts,
        !            95:                FILE *output
        !            96:            )
        !            97: {
        !            98:        register int a;
        !            99: 
        !           100:        fprintf(output, HLINE);
        !           101: 
        !           102:        for(a=0; a<8; a++) 
        !           103:                fprintf(output, "%i: %i \t", a, ((unsigned char *) ts)[a]);
        !           104: 
        !           105:        fprintf(output, "\n");
        !           106:        fprintf(output, HLINE);
        !           107: 
        !           108: }
        !           109: 
        !           110: /* Convert a struct addrinfo to a string containing the address in style
        !           111:  * of inet_ntoa
        !           112:  */
        !           113: char *
        !           114: addrinfo_to_str (
        !           115:        struct addrinfo *addr
        !           116:        )
        !           117: {
        !           118:        sockaddr_u      s;
        !           119:        
        !           120:        memset(&s, 0, sizeof(s));
        !           121:        memcpy(&s, addr->ai_addr, min(sizeof(s), addr->ai_addrlen));
        !           122: 
        !           123:        return ss_to_str(&s);
        !           124: }
        !           125: 
        !           126: /* Convert a sockaddr_u to a string containing the address in
        !           127:  * style of inet_ntoa
        !           128:  * Why not switch callers to use stoa from libntp?  No free() needed
        !           129:  * in that case.
        !           130:  */
        !           131: char *
        !           132: ss_to_str (
        !           133:        sockaddr_u *saddr
        !           134:        )
        !           135: {
        !           136:        char *  buf;
        !           137:        
        !           138:        buf = emalloc(INET6_ADDRSTRLEN);
        !           139:        strncpy(buf, stoa(saddr), INET6_ADDRSTRLEN);
        !           140: 
        !           141:        return buf;
        !           142: }
        !           143: /*
        !           144:  * Converts a struct tv to a date string
        !           145:  */
        !           146: char *
        !           147: tv_to_str(
        !           148:        const struct timeval *tv
        !           149:        )
        !           150: {
        !           151:        const size_t bufsize = 48;
        !           152:        char *buf;
        !           153:        time_t gmt_time, local_time;
        !           154:        struct tm *p_tm_local;
        !           155:        int hh, mm, lto;
        !           156: 
        !           157:        /*
        !           158:         * convert to struct tm in UTC, then intentionally feed
        !           159:         * that tm to mktime() which expects local time input, to
        !           160:         * derive the offset from UTC to local time.
        !           161:         */
        !           162:        gmt_time = tv->tv_sec;
        !           163:        local_time = mktime(gmtime(&gmt_time));
        !           164:        p_tm_local = localtime(&gmt_time);
        !           165: 
        !           166:        /* Local timezone offsets should never cause an overflow.  Yeah. */
        !           167:        lto = difftime(local_time, gmt_time);
        !           168:        lto /= 60;
        !           169:        hh = lto / 60;
        !           170:        mm = abs(lto % 60);
        !           171: 
        !           172:        buf = emalloc(bufsize);
        !           173:        snprintf(buf, bufsize,
        !           174:                 "%d-%.2d-%.2d %.2d:%.2d:%.2d.%.6d (%+03d%02d)",
        !           175:                 p_tm_local->tm_year + 1900,
        !           176:                 p_tm_local->tm_mon + 1,
        !           177:                 p_tm_local->tm_mday,
        !           178:                 p_tm_local->tm_hour,
        !           179:                 p_tm_local->tm_min,
        !           180:                 p_tm_local->tm_sec,
        !           181:                 (int)tv->tv_usec,
        !           182:                 hh,
        !           183:                 mm);
        !           184: 
        !           185:        return buf;
        !           186: }
        !           187: 
        !           188: 
        !           189: 
        !           190: