dhcp-arp.c

this is sample about DHCP-agent

/* $Header: /cvsroot/dhcp-agent/dhcp-agent/src/dhcp-arp.c,v 1.3 2002/11/16 00:23:42 actmodern Exp $
 * 
 * Copyright 2002 Thamer Alharbash <[e-mail]>
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in
 * the documentation and/or other materials provided with the
 * distribution.
 * 3. The names of the authors may not be used to endorse or promote
 * products derived from this software without specific prior
 * written permission.
 * 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#define MODULE_NAME "dhcp-arp"

#include "dhcp-local.h"
#include "dhcp-libutil.h"
#include "dhcp-librawnet.h"

#include "dhcp-align.h"

/* constructor */
arp_obj *arp_create(void)
{
    arp_obj *arp;

    arp = xmalloc(sizeof(arp_obj));

    return arp;
}

/* destructor */
void arp_destroy(arp_obj * arp)
{
    xfree(arp);
    return;
}

/* set routines. */
void arp_set_hardware_type(arp_obj * arp, uint16_t hdr_addr)
{
    arp->header.ar_hrd = htons(hdr_addr);
    return;
}

void arp_set_protocol_type(arp_obj * arp, uint16_t pro)
{
    arp->header.ar_pro = htons(pro);
    return;
}

void arp_set_hardware_len(arp_obj * arp, uint8_t len)
{
    arp->header.ar_hln = len;
    return;
}
void arp_set_protocol_len(arp_obj * arp, uint8_t len)
{
    arp->header.ar_pln = len;
    return;
}

void arp_set_op(arp_obj * arp, uint16_t op)
{
    arp->header.ar_op = htons(op);
    return;
}

void arp_set_sender_hardware_address(arp_obj * arp, eth_addr_t addr)
{
    memcpy(&arp->arp_data.ar_sha, &addr.data, ETH_ADDR_LEN);
    return;
}

void arp_set_sender_protocol_address(arp_obj * arp, uint32_t addr)
{
    memcpy(&arp->arp_data.ar_spa, &addr, IP_ADDR_LEN);
    return;
}

void arp_set_target_hardware_address(arp_obj * arp, eth_addr_t addr)
{
    memcpy(&arp->arp_data.ar_tha, &addr.data, ETH_ADDR_LEN);
    return;
}

void arp_set_target_protocol_address(arp_obj * arp, uint32_t addr)
{
    memcpy(&arp->arp_data.ar_tpa, &addr, IP_ADDR_LEN);
    return;
}

/* get routines. */

uint16_t arp_get_op(arp_obj * arp)
{
    return (ntohs(arp->header.ar_op));
}

uint16_t arp_get_hardware_type(arp_obj * arp)
{
    return (ntohs(arp->header.ar_hrd));
}

uint16_t arp_get_protocol_type(arp_obj * arp)
{
    return (ntohs(arp->header.ar_pro));
}

uint8_t arp_get_hardware_len(arp_obj * arp)
{
    return (arp->header.ar_hln);
}

uint8_t arp_get_protocol_len(arp_obj * arp)
{
    return (arp->header.ar_pln);
}

unsigned char *arp_get_sender_hardware_address(arp_obj * arp)
{
    return (arp->arp_data.ar_sha);
}

unsigned char *arp_get_sender_protocol_address(arp_obj * arp)
{
    return (arp->arp_data.ar_spa);
}

/* dump image to packet. */
void arp_write_packet_image(arp_obj * arp, unsigned char *packet)
{
    memcpy(packet, &arp->header.ar_hrd, sizeof(arp->header.ar_hrd));
    packet += sizeof(arp->header.ar_hrd);

    memcpy(packet, &arp->header.ar_pro, sizeof(arp->header.ar_pro));
    packet += sizeof(arp->header.ar_pro);

    memcpy(packet, &arp->header.ar_hln, sizeof(arp->header.ar_hln));
    packet += sizeof(arp->header.ar_hln);

    memcpy(packet, &arp->header.ar_pln, sizeof(arp->header.ar_pln));
    packet += sizeof(arp->header.ar_pln);

    memcpy(packet, &arp->header.ar_op, sizeof(arp->header.ar_op));
    packet += sizeof(arp->header.ar_op);

    memcpy(packet, &arp->arp_data.ar_sha, sizeof(arp->arp_data.ar_sha));
    packet += sizeof(arp->arp_data.ar_sha);

    memcpy(packet, &arp->arp_data.ar_spa, sizeof(arp->arp_data.ar_spa));
    packet += sizeof(arp->arp_data.ar_spa);

    memcpy(packet, &arp->arp_data.ar_tha, sizeof(arp->arp_data.ar_tha));
    packet += sizeof(arp->arp_data.ar_tha);

    memcpy(packet, &arp->arp_data.ar_tpa, sizeof(arp->arp_data.ar_tpa));

    return;
}

int arp_read_packet_image(arp_obj * arp, const unsigned char *packet, int len)
{
    if(len < (ARP_HDR_LEN + ARP_ETHIP_LEN))
        return -1;

    align_arp_header(packet, &arp->header);
    packet += ARP_HDR_LEN;

    align_arp_data(packet, &arp->arp_data);

    return 0;
}