dhcp-print.c

this is sample about DHCP-agent

            printf("/");
            continue;
        }

        if(i >= (len - 4))
            printf(".");
        else
            printf(", ");

        if(line_val > 60) {
            printf("\n");
            line_val = ini_val;

            for(j = 0; j < line_val; j++)
                printf(" ");
        }
    }

    return;
}

/* Same as print_address_list only we add a route with "->" in between. */

void print_address_route_list(const uint8_t *data, int len, int ini_val)
{
    int i, j, line_val;

    if(len <= 0 || len % 8 != 0) {
        printf("<Malformed data>");
        return;
    }

    line_val = ini_val;

    for(i = 0; i < len; i += 4) {

        line_val += print_address(data);
        data += 4;

        if(i != 0 && (i % 8 == 0)) {
            /* We're at a mask. */
            printf("->");
            continue;
        }

        if(i >= (len - 4))
            printf(".");
        else
            printf(", ");

        if(line_val > 60) {
            printf("\n");
            line_val = ini_val;

            for(j = 0; j < line_val; j++)
                printf(" ");
        }
    }

    return;
}

/* Print a string. */

void print_string(const uint8_t *data, int len, int print_val)
{
    char *new_string;

    if(len > MAX_STRING_LEN) {
        printf("<String too long to display>");
        return;
    }

    new_string = xmalloc(sizeof(char) * (len + 1));
    strncpy(new_string, data, len);
    new_string[len] = 0;

    printf("%s", new_string);

    xfree(new_string);

    return;
}

/* Print a signed 32bit integer. */

void print_int32(const uint8_t *data, int len, int print_val)
{
    bpf_int32 val;

    if(len != 4) {
        printf("<Malformed data>");
        return;
    }

    memcpy(&val, data, 4);
    val = ntohl(val);
    printf("%d", val);
    return;
}

/* Print unsigned 32-bit integer. */

void print_uint32(const uint8_t *data, int len, int print_val)
{
    uint32_t val;

    if(len != 4) {
        printf("<Malformed data>");
        return;
    }


    memcpy(&val, data, 4);
    val = ntohl(val);
    printf("%u", val);

    return;
}

/* Print unsigned 16-bit integer. */

void print_uint16(const uint8_t *data, int len, int print_val)
{
    uint16_t val;

    if(len != 2) {
        printf("<Malformed data>");
        return;
    }

    memcpy(&val, data, 2);
    val = ntohs(val);
    printf("%u", val);

    return;
}

/* Print unsigned byte. */

void print_ubyte(const uint8_t *data, int len, int print_val)
{
    if(len != 1) {
        printf("<Malformed data>");
        return;
    }

    printf("%u", (*data));
    return;
}

void print_uint16_list(const uint8_t *data, int len, int ini_val)
{
    int i, j, line_val;
    uint16_t val;

    if(len <= 0 || len % 2 != 0) {
        printf("<Malformed data>");
        return;
    }

    line_val = ini_val;

    for(i = 0; i < len; i += 2) {

        val = *(data);
        line_val += printf("%u", val);
        data += 2;


        if(i < (len - 2))
            printf(", ");

        if(line_val > 60) {
            printf("\n");
            line_val = ini_val;

            for(j = 0; j < line_val; j++)
                printf(" ");
        }
    }

    return;
}

/* Print a boolean value as enabled or disabled. */

void print_en_bool(const uint8_t *data, int len, int print_val)
{

    if(len != 1) {
        printf("<Malformed data>");
        return;
    }

    if(*data == 0)
        printf("Disabled");
    else
        printf("Enabled");

    return;
}

/* Print boolean: "Yes" "No" */

void print_yn_bool(const uint8_t *data, int len, int print_val)
{

    if(len != 1) {
        printf("<Malformed data>");
        return;
    }

    if(*data == 0)
        printf("Yes");
    else
        printf("No");

    return;
}

/* Print netbios node type. */

void print_netbios_node_type(const uint8_t *data, int len, int print_val)
{
    if(len != 1) {
        printf("<Malformed data>");
        return;
    }

    if((*data) && NETBIOS_B_NODE)
        printf("B-Node ");
    if((*data) && NETBIOS_P_NODE)
        printf("P-Node ");
    if((*data) && NETBIOS_M_NODE)
        printf("M-Node ");
    if((*data) && NETBIOS_H_NODE)
        printf("H-Node ");

    return;
}

/* Don't handle handler -- the irony... */

void dont_handle(const uint8_t *data, int len, int print_val)
{
    printf("<Not handled>");
    return;
}

/* Print options.
 *
 * We have an array with all the handlers.
 * We just check if the len, and tag field are legal
 * and then pass the data onto the print structure after
 * printing the prefix.
 *
 */

void print_options_verbose(dhcp_obj * dhcp)
{
    dhcp_opt_t *option;
    uint8_t tag;
    int print_val;
    uint8_t *val;

    dhcp_reset_option_seek(dhcp);

    while((option = dhcp_get_next_option(dhcp)) != NULL) {

        /* Since it's already been copied into the dhcp object
         * we can assume that the code will always be valid. */

        /* FIXME: eventually this will have to be rewritten.  the
         * sniffer, prior to the new dhcp object, expected data
         * in network form. just ask for it here. */

        tag = dhcp_opt_get_tag(option);
        print_val = printf("%s", option_handlers[tag].prefix);
        print_val += printf(": ");

        val = dhcp_opt_get_network_data(option);
        option_handlers[tag].handle_option(val,
                                           dhcp_opt_get_total_len(option), 
                                           print_val);
        xfree(val);
        printf("\n");
    }

    return;

}

/* Print source and destination address (brief). */
void print_ip_brief(ip_obj * ip)
{
    struct in_addr in;

    in.s_addr = ip_get_src_addr(ip);
    printf("srcip: %s ", inet_ntoa(in));

    in.s_addr = ip_get_dst_addr(ip);
    printf("dstip: %s ", inet_ntoa(in));
    return;
}

/* Print source and destination address (verbose). */
void print_ip_verbose(ip_obj * ip)
{
    struct in_addr in;

    printf("-------------------------------IP HDR--------------------------------\n");

    in.s_addr = ip_get_src_addr(ip);
    printf("Source: %-17s", inet_ntoa(in));
    printf("               ");

    in.s_addr = ip_get_dst_addr(ip);
    printf("Destination: %-17s\n", inet_ntoa(in));

    printf("---------------------------------------------------------------------\n");
    return;
}

void print_magic_cookie_brief(dhcp_obj * dhcp)
{
    struct in_addr in;

    memcpy(&in.s_addr, &dhcp->magic_cookie, 4);
    printf("cookie: %s ", inet_ntoa(in));
    return;
}

void print_magic_cookie_verbose(const char *status, dhcp_obj * dhcp)
{
    struct in_addr in;

    memcpy(&in.s_addr, &dhcp->magic_cookie, 4);

    printf("Cookie: %-6s : %-17s\n", status, inet_ntoa(in));
    printf("---------------------------------------------------------------------\n");

    return;
}

void print_timestamp_brief(struct timeval tm)
{
    printf("[%lu.%06lu] ", tm.tv_sec, tm.tv_usec);
    return;
}

void print_timestamp_verbose(struct timeval tm)
{
    printf("%lu.%06lu\n", tm.tv_sec, tm.tv_usec);
    return;
}

void print_eth_brief(eth_obj * eth)
{
    eth_addr_t src_eth_addr;
    eth_addr_t dst_eth_addr;

    src_eth_addr = eth_get_src_addr(eth);
    dst_eth_addr = eth_get_dst_addr(eth);

    printf("smac: %x:%x:%x:%x:%x:%x ", src_eth_addr.data[0], src_eth_addr.data[1],
           src_eth_addr.data[2], src_eth_addr.data[3], src_eth_addr.data[4], src_eth_addr.data[5]);
    printf("dmac: %x:%x:%x:%x:%x:%x ", dst_eth_addr.data[0], dst_eth_addr.data[1],
           dst_eth_addr.data[2], dst_eth_addr.data[3], dst_eth_addr.data[4], dst_eth_addr.data[5]);

    return;
}

void print_eth_verbose(eth_obj * eth)
{
    eth_addr_t src_eth_addr, dst_eth_addr;
    src_eth_addr = eth_get_src_addr(eth);
    dst_eth_addr = eth_get_dst_addr(eth);

    printf("--------------------------Ethernet Header-----------------------------\n");
    printf("SRC MAC: %x:%x:%x:%x:%x:%x", src_eth_addr.data[0], src_eth_addr.data[1],
           src_eth_addr.data[2], src_eth_addr.data[3], src_eth_addr.data[4], src_eth_addr.data[5]);
    printf("             DST MAC: %x:%x:%x:%x:%x:%x\n", dst_eth_addr.data[0], dst_eth_addr.data[1],
           dst_eth_addr.data[2], dst_eth_addr.data[3], dst_eth_addr.data[4], dst_eth_addr.data[5]);

    return;
}

void print_dhcp_packet_verbose(rawnet_t *net)
{
    print_eth_verbose(net->ether_p);
    print_ip_verbose(net->ip_p);
    print_dhcphdr_verbose(net->dhcp_p);
    if(dhcp_valid_magic_cookie(net->dhcp_p))
        print_magic_cookie_verbose("Good", net->dhcp_p);
    else
        print_magic_cookie_verbose("Bad", net->dhcp_p);
    print_options_verbose(net->dhcp_p);

    return;
}

void print_dhcp_packet_brief(rawnet_t *net)
{
    print_timestamp_brief(net->tstamp);
    print_eth_brief(net->ether_p);
    print_ip_brief(net->ip_p);
    print_dhcphdr_brief(net->dhcp_p);
    print_magic_cookie_brief(net->dhcp_p);

    return;
}