Linux主动发送cdp packet

基于之前在aix上写的代码：http://www.falaosao.net/?p=1309，略作修改编译出Linux下的版本。

主要修改：

sx_write_short和sx_write_long这两个函数从适应big-endian修改为适应little-endian。

直接使用sendto，无需bind和connect，获取mac地址的函数getaddr也去掉了。

详细代码如下：

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/utsname.h>
#include <stdlib.h>
#include <strings.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <linux/if.h>
#include <netpacket/packet.h>
#include <net/ethernet.h>

static char *use_sysname = 0, *use_machine = 0;
static struct utsname myuname;

/* the capability masks */
static int cdp_capset;
#define CDP_CAP_L3R      0x01    /* a layer 3 router */
#define CDP_CAP_L2TB     0x02    /* a layer 2 transparent bridge */
#define CDP_CAP_L2SRB    0x04    /* a layer 2 source-route bridge */
#define CDP_CAP_L2SW     0x08    /* a layer 2 switch (non-spanning tree) */
#define CDP_CAP_L3TXRX   0x10    /* a layer 3 (non routing) host */
#define CDP_CAP_IGRP     0x20    /* does not forward IGMP Packets to non-routers */
#define CDP_CAP_L1       0x40    /* a layer 1 repeater */

#define LIBNET_CKSUM_CARRY(x) \
(x = (x >> 16) + (x & 0xffff), (~(x + (x >> 16)) & 0xffff))
typedef unsigned char  u_int8_t;
typedef unsigned short u_int16_t;
typedef unsigned int   u_int32_t;

struct cdp_header {
/* ethernet 802.3 header */
unsigned char dst_addr[6] __attribute__ ((packed));
unsigned char src_addr[6] __attribute__ ((packed));
u_int16_t length __attribute__ ((packed));
/* LLC */
u_int8_t dsap __attribute__ ((packed));
u_int8_t ssap __attribute__ ((packed));
/* llc control */
u_int8_t control __attribute__ ((packed));
u_int8_t orgcode[3] __attribute__ ((packed));
u_int16_t protocolId __attribute__ ((packed));
};

int sx_write_short(unsigned char* buffer, u_int16_t data)
{
buffer[1]=(data>>8)&0xff;
buffer[0]=data&0xff;
return 1;
};

int sx_write_long(unsigned char* buffer, u_int32_t data)
{
buffer[3]=(data>>24)&0xff;
buffer[2]=(data>>16)&0xff;
buffer[1]=(data>>8)&0xff;
buffer[0]=data&0xff;
return 1;
};

u_int16_t libnet_ip_check(u_int16_t *addr, int len){
int sum;
sum = libnet_in_cksum(addr, len);
return (LIBNET_CKSUM_CARRY(sum));
}

int libnet_in_cksum(u_int16_t *addr, int len)
{
int sum;
#if 0
u_int16_t last_byte;

sum = 0;
last_byte = 0;
#else
union
{
u_int16_t s;
u_int8_t b[2];
}pad;

sum = 0;
#endif

while (len > 1)
{
sum += *addr++;
len -= 2;
}
#if 0
if (len == 1)
{
*(u_int8_t *)&last_byte = *(u_int8_t *)addr;
sum += last_byte;
#else
if (len == 1)
{
pad.b[0] = *(u_int8_t *)addr;
pad.b[1] = 0;
sum += pad.s;
#endif
}

return (sum);
}

int cdp_buffer_init(unsigned char* buffer, int len, unsigned char* srcaddr)
{
memset(buffer,0,len);
buffer[0]=0x01;
buffer[1]=0x00;
buffer[2]=0x0c;
buffer[3]=buffer[4]=buffer[5]=0xcc;
memcpy(buffer+6,srcaddr,6);
((struct cdp_header*)buffer)->dsap=0xaa;
((struct cdp_header*)buffer)->ssap=0xaa;
((struct cdp_header*)buffer)->control=0x03;
((struct cdp_header*)buffer)->orgcode[2]=0x0c;
sx_write_short((unsigned char*)&(((struct cdp_header*)buffer)->protocolId),
htons(0x2000));
buffer+=sizeof(struct cdp_header);
buffer[0]=0x2; /* cdp version */
buffer[1]=0xb4; /* cdp holdtime, 180 sec by default */
buffer[2]=buffer[3]=0; /* checksum - will calculate later */
return 4+sizeof(struct cdp_header);
};

static char *use_hostname = 0;
int cdp_add_device_id(unsigned char* buffer, int len)
{
static char s_hostname[256];
if (!use_hostname) {
gethostname(s_hostname,sizeof(s_hostname)-1);
s_hostname[sizeof(s_hostname)-1] = 0;
use_hostname = s_hostname;
}

if((strlen(use_hostname)+4)>len) return 0;

*(u_int16_t*)buffer=htons(0x0001); /* type=deviceId */
*((u_int16_t*)(buffer+2))=htons(strlen(use_hostname)+4); /* total length */
memcpy(buffer+4,use_hostname,strlen(use_hostname));
return strlen(use_hostname)+4;
};

int cdp_add_interface(unsigned char* buffer, int len, char* interface)
{
if(!interface) return 0;
if(len < (strlen(interface) + 4)) return 0;
sx_write_short(buffer, htons(0x0003)); /*type=PortID */
sx_write_short(buffer + 2, htons(strlen(interface) + 4)); /* totallength*/
memcpy(buffer + 4, interface, strlen(interface));
return strlen(interface) + 4;
};

int cdp_add_capabilities(unsigned char* buffer, int len)
{
if(len<8) return 0;         sx_write_short(buffer,htons(0x0004)); /* type=Capabilities */         sx_write_short(buffer+2,htons(8)); /* totallength*/         sx_write_long(buffer+4,htonl(cdp_capset));         return 8; }; int cdp_add_software_version(unsigned char* buffer, int len) {         if((strlen(use_sysname)+4)>len) return 0;
sx_write_short(buffer,htons(0x0005)); /* type=software version */
sx_write_short(buffer+2,htons(strlen(use_sysname)+4)); /* totallength*/
memcpy(buffer+4,use_sysname,strlen(use_sysname));
return strlen(use_sysname)+4;
};

int cdp_add_platform(unsigned char* buffer, int len)
{
if((strlen(use_machine)+4)>len) return 0;
sx_write_short(buffer,htons(0x0006)); /* type=platform */
sx_write_short(buffer+2,htons(strlen(use_machine)+4)); /* totallength*/
memcpy(buffer+4,use_machine,strlen(use_machine));
return strlen(use_machine)+4;
};

unsigned short cdp_checksum(unsigned char *ptr, int length) {
if (length % 2 == 0) {
return libnet_ip_check((u_short *)ptr, length);
} else {
int c = ptr[length-1];
unsigned short *sp = (unsigned short *)(&ptr[length-1]);
unsigned short ret;
*sp = htons(c);
ret = libnet_ip_check((u_short *)ptr, length+1);
ptr[length-1] = c;
return ret;
}
}

main(int argc, char *argv[]) {
char srcaddr[6];
char *device, dstaddr[6];
u_int ethertype;
u_int count, size;
int s;
int specify_duplex = 0;
int didcap = 0;
if (!didcap) cdp_capset = CDP_CAP_L3TXRX;

uname(&myuname);
if (!use_machine) {
use_machine = myuname.machine;
if (!use_machine) {
use_machine = "(null)";
}
}

if (!use_sysname) {
char *qa, *qb;
int buflen;
qa = myuname.sysname; if (!qa) qa = "(null)";
qb = myuname.release; if (!qb) qb = "(null)";
buflen = strlen(qa) + strlen(qb) + 2;

use_sysname = (char *)malloc(buflen);
if (!use_sysname) {
perror("malloc");
exit(1);
}
sprintf(use_sysname, "%s %s", qa, qb);
use_sysname[buflen-1] = '\0'; /* terminate if truncated */
}

if (argc != 3) {
printf("Usage: %s  count\n",
argv[0]);
printf("EG:    %s en0 1\n",
argv[0]);
exit(1);
}

device = argv[1];
count = atoi(argv[2]);
printf("interface: %s\n", device);
printf("count: %d\n", count);

s = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if (s < 0) {
perror("socket");
exit(1);
}
 static unsigned char buffer[65535];
 int offset = 0;
offset = cdp_buffer_init(buffer, sizeof(buffer), srcaddr);
offset += cdp_add_device_id(buffer + offset, sizeof(buffer) - offset);
offset += cdp_add_interface(buffer + offset, sizeof(buffer) - offset, device);
offset += cdp_add_capabilities(buffer + offset, sizeof(buffer) - offset);
offset += cdp_add_software_version(buffer + offset, sizeof(buffer) - offset);
offset += cdp_add_platform(buffer + offset, sizeof(buffer) - offset);
((struct cdp_header*)buffer) -> length = htons(offset - 14);
*(u_short*)(buffer + sizeof(struct cdp_header) + 2) = cdp_checksum(
buffer + sizeof(struct cdp_header),
offset - sizeof(struct cdp_header));
struct sockaddr_ll sa;
sa.sll_ifindex  = if_nametoindex(argv[1]);
while (count-- > 0) {
if( sendto(s, buffer, offset, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0 ){
perror("send error\n");
exit(4);
}
}
}

同样在gcc下编译通过。