hex2pcap

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
typedef struct
{
    unsigned int magic_number;
    unsigned short version_major;
    unsigned short version_minor;
    unsigned int thiszone;
    unsigned int sigfigs;
    unsigned int snaplen;
    unsigned int network;
}pcap_hdr_t;
 
typedef struct
{
    unsigned int ts_sec;
    unsigned int ts_usec;
    unsigned int incl_len;
    unsigned int orig_len;
}pkt_hdr_t;
 
FILE          *pcap_fd     = NULL;
unsigned char input_buf[]  = {};
unsigned char output_buf[] ={};
int           input_len = , output_len = ;
 
int hexdump(unsigned char *name, unsigned char *data, unsigned short len)
{
    int i, j, p, ret, tmp_len = ;
    static unsigned char dump_buf[] = {};
    printf("hexdump(%s len=%d)\r\n", name, len);
    memset(dump_buf, 0x00, sizeof(dump_buf));
 
    for (i = , j = , p = ; i < len; i++)
    {
        ret = sprintf( (dump_buf + p), " %02x", *(data + i) );
        p += ret;
        j++;
        if(j >= )
        {
            printf("%s\r\n", dump_buf);
            j = ;
            p = ;
        }
    }
    if(p > )
        printf("%s\r\n", dump_buf);
    return ;
}
 
int file_size(FILE *fd)
{
    int cur, len;
    cur = ftell(fd);
    fseek(fd, , SEEK_END);
    len = ftell(fd);
    fseek(fd,cur, SEEK_SET);
    return len;
}
 
int wpkt(unsigned char *buf, int size)
{
    int ret;
    ret = fwrite(buf, size, , pcap_fd);
    if(ret != )
        printf("fwrite %d %d err \n", size, ret);
    return ;
}
 
int pcap_deinit(void)
{
    fclose(pcap_fd);
    return ;
}
 
int eth_pcap(unsigned char *pkt, int len)
{
    pkt_hdr_t pkt_hdr = {};
 
    pkt_hdr.incl_len = pkt_hdr.orig_len = len;
    wpkt((unsigned char *)(&pkt_hdr), sizeof(pkt_hdr));
    wpkt(pkt, len);
    return ;
}
 
int pcap_init(int pkt_type, unsigned char *file)
{
    pcap_hdr_t       pcap = {};
 
    pcap_fd = fopen(file, "wb+");
    if(NULL == pcap_fd)
    {
        printf("create %s err\n", file);
        return -;
    }
    printf("create %s file\r\n", file);
    pcap.magic_number = 0xa1b2c3d4;
    pcap.snaplen = 0x900;
    pcap.version_major = ;
    pcap.version_minor = ;
    pcap.network = pkt_type;//105,1
    wpkt((unsigned char *)(&pcap), sizeof(pcap));
    return ;
}
 
int main(int argc, char *argv[])
{
    FILE *fd;
    unsigned char ch, *token, *delim = " ,";
    int i, ret,pkt_type;
 
    argc--;
    argv++;
    /*hex2pkt -mac -i frame.hex -o mac.pcap*/
    do
    {
        if(  == strcmp(argv[], "-eth"))
        {
            pkt_type = ;
        }
        else if( == strcmp(argv[], "-mac"))
        {
            pkt_type = ;
        }
        else if( == strcmp(argv[], "-i"))
        {
            argv++;
            argc--;
            fd = fopen(argv[], "rb");
            printf("-i %s\r\n", argv[]);
            input_len = file_size(fd);
            ret = fread( input_buf, input_len, , fd );
            if( != ret)
                printf("fread err ret  %d\r\n", ret);
            printf("input_buf(len=%d):\r\n%s\r\n", input_len, input_buf);
            fclose(fd);
        }
        else if( == strcmp(argv[], "-o"))
        {
            argv++;
            argc--;
            for( token = strtok(input_buf, delim), output_len=; token != NULL; token = strtok(NULL, delim) )
            {
                sscanf(token, "%x", &output_buf[output_len++]);
            }
            hexdump("output", output_buf, output_len);
            pcap_init(pkt_type, argv[]);
            eth_pcap(output_buf, output_len);
            pcap_deinit();
        }
        else
        {
            printf("unknow cmd %s\r\n", argv[]);
        }
        argv++;
        argc--;
    }
    while(argc);
 
    return ;
}