#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <libnet.h>
#include <netinet/igmp.h>

/* Structure to represent IGMP extra information */
struct igmp_extra {
    u_int8_t igmp_version;
    char *igmp_tag;
    u_int8_t igmp_type;             /* IGMP type */
    u_int8_t igmp_code;             /* routing code */
    char *igmp_dst;
    int group_override_dst;
} g_igmp_pkts[] = {
    /* name,  type (or version+type), code */
    { 1, "query",  0x11, 0, "224.0.0.1", 0 },
    { 1, "report", 0x12, 0, "224.0.0.1", 1 },
    { 1, "dvmrp",  0x13, 0, "224.0.0.1", 0 },
    { 2, "query",  0x11, 1, "224.0.0.1", 0 },
    { 2, "report", 0x16, 1, "224.0.0.2", 1 },
    { 2, "leave",  0x17, 1, "224.0.0.2", 0 },
    /* Note: end of list (please keep) */
    { 0, 0, 0, 0 },
};

void usage(char *name)
{
    fprintf(stderr, "usage: %s -i ethdevice -g group -t packet.version\n", name);
}

int main(int argc, char **argv)
{
    u_int32_t ip_src = 0;
    char *ip_src_str = NULL;
    /* libnet stuff */
    char neterr[LIBNET_ERRBUF_SIZE];
    libnet_t *netcontext = NULL;

    /* misc */
    int c;
    char *device = NULL;
    u_int8_t igmp_version = 0;
    char *cp = NULL;
    int found = 0;
    struct igmp_extra *pkt_ptr;
    u_char igmp_type = 0;
    u_char igmp_code = 0;

    printf("IGMP packet generator\n\n");

    printf("Parsing command line...\n");
    while((c = getopt(argc, argv, "i:t:g:")) != EOF)
    {
        switch (c)
        {
            case 'i':
                printf("  Net interface = [%s]\n", optarg);
                device = optarg;
                break;
            case 't':
                if (!(cp = strrchr(optarg, '.'))) {
                    usage(argv[0]);
                    exit(1);
                }
                *cp++ = 0;
                igmp_version = (u_short)atoi(cp);
                pkt_ptr = g_igmp_pkts;
                while (pkt_ptr->igmp_version || pkt_ptr->igmp_tag) {
                    if ((strcasecmp(pkt_ptr->igmp_tag, optarg) == 0) 
                        && (igmp_version == pkt_ptr->igmp_version)) {
                        found = 1;
                        igmp_type = pkt_ptr->igmp_type;
                        igmp_code = pkt_ptr->igmp_code;
                        break;
                    }
                    pkt_ptr++;
                }
                if (!found) {
                    usage(argv[0]);
                    exit(1);
                }
                break;
            case 'g':
                // Group argument handling logic
                printf("  Group = [%s]\n", optarg);
            	igmp_group_str = optarg;
                break;

                break;
            default:
                usage(argv[0]);
                exit(1);
        }
    }
    if (!device)
    {
        usage(argv[0]);
        exit(EXIT_FAILURE);
    }

    printf("done\n");

    /* Memory initialization */
    printf("Initializing libnet context...\n");
    netcontext = libnet_init(LIBNET_RAW4, device, neterr);
    if (!netcontext) {
        fprintf(stderr, "%s\n", neterr);
        exit(1);
    }
    libnet_clear_packet(netcontext);

    if (!ip_src_str) {
        ip_src = libnet_get_ipaddr4(netcontext);
        ip_src_str = libnet_addr2name4(ip_src, LIBNET_DONT_RESOLVE);
    }

    printf("Packet construction...\n");

    /* Packet construction: IGMP */
    printf("  Building IGMP content...\n");
    libnet_ptag_t ptag;
    ptag = libnet_build_igmp(
        igmp_type,        // IGMP type
        igmp_code,        // IGMP code
        0,                // checksum
        0,                // group address
        NULL,             // payload
        0,                // payload size
        netcontext,       // libnet context
        0                 // ptag
    );
    if (ptag == -1) {
        fprintf(stderr, "Error building IGMP header: %s\n", libnet_geterror(netcontext));
        libnet_destroy(netcontext);
        exit(EXIT_FAILURE);
    }

    printf("  done\n");

    /* Send packet */
    if (libnet_write(netcontext) == -1) {
        fprintf(stderr, "Error sending packet: %s\n", libnet_geterror(netcontext));
    } else {
        printf("Packet sent successfully.\n");
    }

    libnet_destroy(netcontext);
    return 0;
}