Return to show_if.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / trafshow

Annotation of embedaddon/trafshow/show_if.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  *     Copyright (c) 2004 Rinet Corp., Novosibirsk, Russia
        !             3:  *
        !             4:  * Redistribution and use in source forms, with and without modification,
        !             5:  * are permitted provided that this entire comment appears intact.
        !             6:  *
        !             7:  * THIS SOURCE CODE IS PROVIDED ``AS IS'' WITHOUT ANY WARRANTIES OF ANY KIND.
        !             8:  */
        !             9: 
        !            10: #ifdef HAVE_CONFIG_H
        !            11: #include <config.h>
        !            12: #endif
        !            13: 
        !            14: #include <stdio.h>
        !            15: #include <string.h>
        !            16: #include <pcap.h>
        !            17: 
        !            18: #include "show_if.h"
        !            19: #include "trafshow.h"
        !            20: #include "screen.h"
        !            21: #include "selector.h"
        !            22: #include "addrtoname.h"
        !            23: 
        !            24: #ifdef notdef
        !            25: static void addr2str(const pcap_addr_t *ap, char *addr_buf, int addr_len);
        !            26: #endif
        !            27: 
        !            28: static void
        !            29: scale_size(name, addr, descr)
        !            30:        int *name, *addr, *descr;
        !            31: {
        !            32:        *name   = line_factor * (double)SHOW_IF_NAME;
        !            33:        *addr   = line_factor * (double)SHOW_IF_ADDR;
        !            34:        *descr  = line_factor * (double)SHOW_IF_DESCR;
        !            35: }
        !            36: 
        !            37: static int
        !            38: show_if_header(dst, size, unused)
        !            39:        char *dst;
        !            40:        int size;
        !            41:        const void *unused;
        !            42: {
        !            43:        int name_sz, addr_sz, desc_sz;
        !            44: 
        !            45:        /* sanity check */
        !            46:        if (!dst || size < 1 || unused)
        !            47:                return 0;
        !            48: 
        !            49:        scale_size(&name_sz, &addr_sz, &desc_sz);
        !            50: 
        !            51:        snprintf(dst, size,
        !            52:                 "%-*.*s %-*.*s %-*.*s",
        !            53:                 name_sz, name_sz,      "Interface",
        !            54:                 addr_sz, addr_sz,      "Address",
        !            55:                 desc_sz, desc_sz,      "Description");
        !            56:        return 0;
        !            57: }
        !            58: 
        !            59: #ifdef notdef
        !            60: /* extract list of interface addr/mask pairs */
        !            61: static void
        !            62: addr2str(ap, addr_buf, addr_len)
        !            63:        const pcap_addr_t *ap;
        !            64:        char *addr_buf;
        !            65:        int addr_len;
        !            66: {
        !            67:        int i, rest;
        !            68:        char *cp;
        !            69: 
        !            70:        *addr_buf = '\0';
        !            71:        cp = addr_buf;
        !            72:        rest = addr_len - 1;
        !            73:        for (; ap && rest > 0; ap = ap->next) {
        !            74:                if (ap->addr) {
        !            75:                        if (*addr_buf) {
        !            76:                                *cp++ = ' ';
        !            77:                                *cp = '\0';
        !            78:                                rest--;
        !            79:                        }
        !            80:                        if (satoa(ap->addr, cp, rest)) {
        !            81:                                i = strlen(cp);
        !            82:                                cp += i;
        !            83:                                rest -= i;
        !            84:                        }
        !            85:                }
        !            86:                if (ap->netmask) {
        !            87:                        if (*addr_buf) {
        !            88:                                *cp++ = ' ';
        !            89:                                *cp = '\0';
        !            90:                                rest--;
        !            91:                        }
        !            92:                        if (satoa(ap->netmask, cp, rest)) {
        !            93:                                i = strlen(cp);
        !            94:                                cp += i;
        !            95:                                rest -= i;
        !            96:                        }
        !            97:                }
        !            98:        }
        !            99: }
        !           100: #endif
        !           101: 
        !           102: static int
        !           103: show_if_line(dst, size, ph, idx)
        !           104:        char *dst;
        !           105:        int size;
        !           106:        const PCAP_HANDLER *ph;
        !           107:        int idx;
        !           108: {
        !           109:        int i, name_sz, addr_sz, desc_sz;
        !           110: 
        !           111:        /* sanity check */
        !           112:        if (!dst || size < 1)
        !           113:                return 0;
        !           114: 
        !           115:        *dst = '\0';
        !           116:        for (i = 0; ph; ph = ph->next) {
        !           117:                if (i++ == idx) break;
        !           118:        }
        !           119:        if (!ph) return 0;
        !           120: 
        !           121:        scale_size(&name_sz, &addr_sz, &desc_sz);
        !           122:        snprintf(dst, size,
        !           123:                 "%-*.*s %-*.*s %-*.*s",
        !           124:                 name_sz, name_sz,      ph->name,
        !           125:                 addr_sz, addr_sz,      ph->addrstr,
        !           126:                 desc_sz, desc_sz,      ph->descr ? ph->descr : "");
        !           127:        return 0;
        !           128: }
        !           129: 
        !           130: static int
        !           131: show_if_footer(dst, size, unused)
        !           132:        char *dst;
        !           133:        int size;
        !           134:        const void *unused;
        !           135: {
        !           136:        /* sanity check */
        !           137:        if (!dst || size < 1 || unused)
        !           138:                return 0;
        !           139: 
        !           140:        (void)strncpy(dst, hostname, size);
        !           141:        dst[size-1] = '\0';
        !           142:        return 0;
        !           143: }
        !           144: 
        !           145: SELECTOR *
        !           146: show_if_selector()
        !           147: {
        !           148:        static SELECTOR *sp = 0;
        !           149:        if (!sp && (sp = selector_init()) != 0) {
        !           150:                sp->get_header = show_if_header;
        !           151:                sp->get_line = show_if_line;
        !           152:                sp->get_footer = show_if_footer;
        !           153:        }
        !           154:        return sp;
        !           155: }
        !           156: 
        !           157: int
        !           158: show_if_search(ph, str)
        !           159:        PCAP_HANDLER *ph;
        !           160:        const char *str;
        !           161: {
        !           162:        int idx;
        !           163: 
        !           164:        /* sanity check */
        !           165:        if (!str || *str == '\0')
        !           166:                return -1;
        !           167: 
        !           168:        for (idx = 0; ph; ph = ph->next, idx++) {
        !           169:                if (strstr(ph->name, str))
        !           170:                        return idx;
        !           171:                if (strstr(ph->addrstr, str))
        !           172:                        return idx;
        !           173:        }
        !           174:        return -1;
        !           175: }
        !           176: 
        !           177: SELECTOR *
        !           178: show_if_list(ph)
        !           179:        PCAP_HANDLER *ph;
        !           180: {
        !           181:        SELECTOR *sp;
        !           182: 
        !           183:        /* sanity check */
        !           184:        if (!ph || (sp = show_if_selector()) == 0)
        !           185:                return 0;
        !           186: 
        !           187:        sp->header = 0; /* unused */
        !           188:        sp->footer = 0; /* unused */
        !           189: 
        !           190:        sp->list = ph;
        !           191:        sp->items = 0;
        !           192:        for (; ph; ph = ph->next)
        !           193:                sp->items++;
        !           194: 
        !           195:        return sp;
        !           196: }
        !           197: