int main(int argc, char** argv){
char buf[BUFLEN];
char *dev = calloc(10, 1);
struct netdev netdev;
CLEAR(buf);
tun_init(dev);
netdev_init(&netdev, "10.0.0.4", "00:0c:29:6d:50:25");
arp_init();
while(1) {
if (tun_read(buf, BUFLEN) < 0) {
print_error("ERR: Read from tun_fd: %s\n", strerror(errno));
}
print_hexdump(buf, BUFLEN);
struct eth_hdr *hdr = init_eth_hdr(buf);
handle_frame(&netdev, hdr);
}
}
int main(int argc, char* argv[]) {
struct tuntap_dev tuntap;
int i;
int mtu = 1400;
printf("Welcome to n2n\n");
initWin32();
open_wintap(&tuntap, "1.2.3.20", "255.255.255.0", mtu);
for(i=0; i<10; i++) {
u_char buf[MTU];
int rc;
rc = tun_read(&tuntap, buf, sizeof(buf));
buf[0]=2;
buf[1]=3;
buf[2]=4;
printf("tun_read returned %d\n", rc);
rc = tun_write(&tuntap, buf, rc);
printf("tun_write returned %d\n", rc);
}
// rc = tun_open (device->device_name, IF_MODE_TUN);
WSACleanup ();
return(0);
}
void master_callback(evutil_socket_t fd, short type, struct master_config* config) {
char ibuf[1500];
ssize_t ilength;
struct session* session;
ilength = tun_read(fd, ibuf, sizeof(ibuf));
if (ilength < 0) {
return;
}
session = config->sessions.next;
while (session != &config->sessions) {
if (session->rkey == 0) {
session = session->next;
continue;
}
if (hwaddress_isbroadcast((struct hwaddress*)ibuf)) {
write_data(config, session, ibuf, ilength);
} else {
if (memcmp(&session->hwremote, ibuf, 6) == 0) {
write_data(config, session, ibuf, ilength);
/*TODO*/
return;
}
}
session = session->next;
}
fprintf(stderr, "!!no session with hwaddr\n");
}
void *tun_dev_read(void * arg) {
uint8_t buf[2500], read_buf[1500], *fragment;
struct ip6_packet *packet = (struct ip6_packet *)buf;
struct ip_iovec v;
struct lowpan_ctx ctx;
struct ieee154_frame_addr fr;
int len, i;
packet->ip6_data = &v;
v.iov_next = NULL;
v.iov_base = &buf[sizeof(struct ip6_packet)];
ctx.tag = 0;
while (run_state == S_RUNNING) {
len = tun_read(tun_fd, read_buf, 1500);
len -= sizeof(struct tun_pi);
if (len < 0) {
debug("tun_dev_read: read error\n");
continue;
}
/* set up the ip6_packet structure */
memcpy(&packet->ip6_hdr, read_buf + sizeof(struct tun_pi), len);
v.iov_len = len;
ctx.offset = 0;
ctx.tag++;
if (resolve_l2_addresses(packet, &fr) < 0) {
debug("could not resolve next hop; dropping\n");
continue;
}
fragment = xmalloc(128);
/* PPDU : max length 127 (all inclusive) */
/* 1 len + 2 FCS, so max buffer length is 126 (including length) */
while ((len = lowpan_frag_get(&fragment[1], 126, packet, &fr, &ctx)) > 0) {
fragment[0] = TOS_SERIAL_802_15_4_ID;
fragment[1] = len - 1 + 2;
print_buffer(fragment, len + 1);
printf("PUSH: %i\n", queue_push(&pan_q, fragment));
fragment = xmalloc(128);
}
free(fragment);
}
}
void *netdev_rx_loop()
{
while (running) {
if (tun_read(netdev.buf, netdev.buflen) < 0) {
print_error("ERR: Read from tun_fd: %s\n", strerror(errno));
return NULL;
}
struct eth_hdr *hdr = init_eth_hdr(netdev.buf);
handle_frame(&netdev, hdr);
}
return NULL;
}
/**
* Function to run the tunnel
*/
void run_tunnel(char *dest, int server)
{
struct icmp_packet packet;
int tun_fd, sock_fd;
fd_set fs;
tun_fd = tun_alloc("tun0", IFF_TUN | IFF_NO_PI);
printf("[DEBUG] Starting tunnel - Dest: %s, Server: %d\n", dest, server);
printf("[DEBUG] Opening ICMP socket\n");
sock_fd = open_icmp_socket();
if (server) {
printf("[DEBUG] Binding ICMP socket\n");
bind_icmp_socket(sock_fd);
}
configure_network(server);
while (1) {
FD_ZERO(&fs);
FD_SET(tun_fd, &fs);
FD_SET(sock_fd, &fs);
select(tun_fd>sock_fd?tun_fd+1:sock_fd+1, &fs, NULL, NULL, NULL);
if (FD_ISSET(tun_fd, &fs)) {
printf("[DEBUG] Data needs to be readed from tun device\n");
// Reading data from tun device and sending ICMP packet
printf("[DEBUG] Preparing ICMP packet to be sent\n");
// Preparing ICMP packet to be sent
memset(&packet, 0, sizeof(struct icmp_packet));
printf("[DEBUG] Destination address: %s\n", dest);
strcpy(packet.src_addr, "0.0.0.0");
strcpy(packet.dest_addr, dest);
if(server) {
set_reply_type(&packet);
}
else {
set_echo_type(&packet);
}
packet.payload = malloc(MTU);
packet.payload_size = tun_read(tun_fd, packet.payload, MTU);
if(packet.payload_size == -1) {
perror("Error while reading from tun device\n");
exit(EXIT_FAILURE);
}
printf("[DEBUG] Sending ICMP packet with payload_size: %d, payload: %s\n", packet.payload_size, packet.payload);
// Sending ICMP packet
send_icmp_packet(sock_fd, &packet);
free(packet.payload);
}
if (FD_ISSET(sock_fd, &fs)) {
printf("[DEBUG] Received ICMP packet\n");
// Reading data from remote socket and sending to tun device
// Getting ICMP packet
memset(&packet, 0, sizeof(struct icmp_packet));
receive_icmp_packet(sock_fd, &packet);
printf("[DEBUG] Read ICMP packet with src: %s, dest: %s, payload_size: %d, payload: %s\n", packet.src_addr, packet.dest_addr, packet.payload_size, packet.payload);
// Writing out to tun device
tun_write(tun_fd, packet.payload, packet.payload_size);
printf("[DEBUG] Src address being copied: %s\n", packet.src_addr);
strcpy(dest, packet.src_addr);
}
}
}
int icmp_tunnel(int sock, int proxy, struct sockaddr_in *target, int tun_fd, int packetsize, u_int16_t id) {
char* packet;
struct icmp *icmp, *icmpr;
int len;
int result;
fd_set fs;
struct sockaddr_in from;
int fromlen;
int num;
len = sizeof (struct icmp);
packet = malloc (len+packetsize);
memset (packet, 0, len+packetsize);
icmp = (struct icmp*)(packet);
icmpr = (struct icmp*)(packet+sizeof(struct ip));
while (1) {
FD_ZERO (&fs);
FD_SET (tun_fd, &fs);
FD_SET (sock, &fs);
select (tun_fd>sock?tun_fd+1:sock+1, &fs, NULL, NULL, NULL);
/* data available on tunnel device */
if (FD_ISSET (tun_fd, &fs)) {
result = tun_read (tun_fd, packet+len, packetsize);
if (!result) {
return 0;
} else if (result==-1) {
perror ("read");
return -1;
}
icmp->type = proxy ? 0 : 8;
icmp->code = 0;
icmp->id = id;
icmp->seq = 0;
icmp->cksum = 0;
icmp->cksum = in_cksum((u_short*)packet, len+result);
result = sendto (sock, (char*)packet, len+result, 0, (struct sockaddr*)target, sizeof (struct sockaddr_in));
if (result==-1) {
perror ("sendto");
return -1;
}
}
/* data available on socket */
if (FD_ISSET (sock, &fs)) {
fromlen = sizeof (struct sockaddr_in);
num = recvfrom (sock, packet, len+packetsize, 0, (struct sockaddr*)&from, (socklen_t*) &fromlen);
/* the data packet */
if (icmpr->id == id) {
tun_write (tun_fd, packet+sizeof(struct ip)+sizeof(struct icmp), num-sizeof(struct ip)-sizeof(struct icmp));
/* one IPv4 client */
memcpy(&(target->sin_addr.s_addr), &(from.sin_addr.s_addr), 4*sizeof(char));
}
}
/* end of data available */
}
/* end of while(1) */
return 0;
}
