/**
\ingroup Core_Keys
\brief Add packet to key
\param keydata Key to which to add packet
\param packet Packet to add
\return Pointer to new packet
*/
pgp_subpacket_t *
pgp_add_subpacket(pgp_key_t *keydata, const pgp_subpacket_t *packet)
{
pgp_subpacket_t *subpktp;
EXPAND_ARRAY(keydata, packet);
/* initialise new entry in array */
subpktp = &keydata->packets[keydata->packetc++];
subpktp->length = 0;
subpktp->raw = NULL;
/* now copy it */
return copy_packet(subpktp, packet);
}
int
copy_if_parses(const unsigned char** rptr,
const unsigned char* const end,
int (*f)(const struct packet* pkt,
const unsigned char** s, size_t* s_sz),
struct packet* to,
unsigned char** wptr)
{
const unsigned char* tmp;
size_t tmp_sz;
struct packet pkt;
*rptr = parse_packet(*rptr, end, &pkt);
if (!*rptr || f(&pkt, &tmp, &tmp_sz) < 0)
{
return -1;
}
*wptr = copy_packet(&pkt, to, *wptr);
return 0;
}
static int __init init_reconos_test_module(void)
{
char * shared_mem_h2s;
char * shared_mem_s2h;
int i, j;
long unsigned jiffies_before;
long unsigned jiffies_after;
int len_array[13] = {64, 128, 256, 512, 1024, 1280, 1500, 3000, 6000, 9000, 15000, 30000, 50000};
printk(KERN_INFO "[reconos-interface] Init.\n");
mbox_init(&e_mb_put, 2);
mbox_init(&e_mb_get, 2);
mbox_init(&a_mb_put, 2);
mbox_init(&a_mb_get, 2);
mbox_init(&b_mb_put, 2);
mbox_init(&b_mb_get, 2);
mbox_init(&c_mb_put, 2);
mbox_init(&c_mb_get, 2);
printk(KERN_INFO "[reconos-interface] mbox_init done, starting autodetect.\n");
reconos_init_autodetect();
printk(KERN_INFO "[reconos-interface] Creating hw-thread.\n");
e_res[0].type = RECONOS_TYPE_MBOX;
e_res[0].ptr = &e_mb_put;
e_res[1].type = RECONOS_TYPE_MBOX;
e_res[1].ptr = &e_mb_get;
a_res[0].type = RECONOS_TYPE_MBOX;
a_res[0].ptr = &a_mb_put;
a_res[1].type = RECONOS_TYPE_MBOX;
a_res[1].ptr = &a_mb_get;
s_res[0].type = RECONOS_TYPE_MBOX;
s_res[0].ptr = &s_mb_put;
s_res[1].type = RECONOS_TYPE_MBOX;
s_res[1].ptr = &s_mb_get;
b_res[0].type = RECONOS_TYPE_MBOX;
b_res[0].ptr = &b_mb_put;
b_res[1].type = RECONOS_TYPE_MBOX;
b_res[1].ptr = &b_mb_get;
c_res[0].type = RECONOS_TYPE_MBOX;
c_res[0].ptr = &c_mb_put;
c_res[1].type = RECONOS_TYPE_MBOX;
c_res[1].ptr = &c_mb_get;
reconos_hwt_setresources(&e_hwt,e_res,2);
reconos_hwt_create(&e_hwt,E_HWT_SLOT_NR,NULL);
reconos_hwt_setresources(&a_hwt,a_res,2);
reconos_hwt_create(&a_hwt,A_HWT_SLOT_NR,NULL);
reconos_hwt_setresources(&b_hwt,b_res,2);
reconos_hwt_create(&b_hwt,B_HWT_SLOT_NR,NULL);
reconos_hwt_setresources(&c_hwt,c_res,2);
reconos_hwt_create(&c_hwt,C_HWT_SLOT_NR,NULL);
//setup the hw -> sw thread
printk(KERN_INFO "[reconos-interface] Allocate memory\n");
shared_mem_h2s = __get_free_pages(GFP_KERNEL | __GFP_NOWARN, 4); //allocate 2² pages get_zeroed_page(GFP_KERNEL);
printk(KERN_INFO "[reconos-interface] h2s memory %p\n", shared_mem_h2s);
mbox_put(&b_mb_put, shared_mem_h2s);
//setup the sw -> hw thread
shared_mem_s2h = __get_free_pages(GFP_KERNEL | __GFP_NOWARN, 4); //allocate 2² pages get_zeroed_page(GFP_KERNEL);
printk(KERN_INFO "[reconos-interface] s2h memory %p\n", shared_mem_s2h);
mbox_put(&c_mb_put, shared_mem_s2h);
printk(KERN_INFO "[reconos-interface] HZ= %d\n", HZ);
jiffies_before = jiffies;
printk(KERN_INFO "[reconos-interface] Setting up AES slot \n");
u32 config_data_start=1;
u32 config_rcv=0;
u32 config_data_mode=0; //"....1100"=12=mode128, mode192=13, mode256=14,15
u32 config_data_key0=0x16157e2b; // 50462976; //X"03020100"
u32 config_data_key1=0xa6d2ae28; //117835012; //X"07060504"
u32 config_data_key2=0x8815f7ab; //185207048; //X"0b0a0908"
u32 config_data_key3=0x3c4fcf09; //252579084; //X"0f0e0d0c"
u32 config_data_key4=319951120; //X"13121110"
u32 config_data_key5=387323156; //X"17161514"
u32 config_data_key6=454695192; //X"1b1a1918"
u32 config_data_key7=522067228; //X"1f1e1d1c"
u32 exit_sig=4294967295;
// config_data_mode=16; //key length 128 bit, send everything to eth
config_data_mode=20; //key length 128 bit, send everything to sw
mbox_put(&e_mb_put, config_data_start);
mbox_put(&e_mb_put, config_data_mode);
mbox_put(&e_mb_put, config_data_key0);
mbox_put(&e_mb_put, config_data_key1);
mbox_put(&e_mb_put, config_data_key2);
mbox_put(&e_mb_put, config_data_key3);
mbox_put(&e_mb_put, config_data_key4);
mbox_put(&e_mb_put, config_data_key5);
mbox_put(&e_mb_put, config_data_key6);
mbox_put(&e_mb_put, config_data_key7);
config_rcv=mbox_get(&e_mb_get);
printk(KERN_INFO "[reconos-interface] AES Setup done\n");
while(1){
printk(KERN_INFO "waiting for hw packets \n");
int ret = mbox_get(&b_mb_get);
int i;
for (i = 0; i < 100; i+=4)
printk(KERN_INFO "%x %x %x %x\n", shared_mem_h2s[i], shared_mem_h2s[i+1], shared_mem_h2s[i+2], shared_mem_h2s[i+3]);
printk(KERN_INFO "received packet of len %u\n", ret);
mbox_put(&b_mb_put, shared_mem_h2s );
printk(KERN_INFO "setting up hash table \n");
//config eth
u32 config_eth_hash_1 = 0xabababab;
u32 config_eth_hash_2 = 0xabababab;
u32 config_eth_idp = 0x12341234;
u32 config_eth_address = 1; //global 0, local 1 -> aes
mbox_put(&a_mb_put, config_eth_hash_1 );
mbox_put(&a_mb_put, config_eth_hash_2);
mbox_put(&a_mb_put, config_eth_idp);
mbox_put(&a_mb_put, config_eth_address);
ret = mbox_get(&a_mb_get);
printk(KERN_INFO "hwt_ethernet configured - 1\n");
config_eth_hash_1 = 0xabababab;
config_eth_hash_2 = 0xababab01;
config_eth_idp = 0x56785678;
config_eth_address = 5; //global 1, local 1 -> h2s
mbox_put(&a_mb_put, config_eth_hash_1 );
mbox_put(&a_mb_put, config_eth_hash_2);
mbox_put(&a_mb_put, config_eth_idp);
mbox_put(&a_mb_put, config_eth_address);
ret = mbox_get(&a_mb_get);
printk(KERN_INFO "hwt_ethernet configured - 2\n");
ret = mbox_get(&b_mb_get);
for (i = 0; i < 100; i+=4)
printk(KERN_INFO "%x %x %x %x\n", shared_mem_h2s[i], shared_mem_h2s[i+1], shared_mem_h2s[i+2], shared_mem_h2s[i+3]);
printk(KERN_INFO "received packet of len %u\n", ret);
mbox_put(&b_mb_put, shared_mem_h2s );
//config eth
config_eth_hash_1 = 0xabababab;
config_eth_hash_2 = 0xabababab;
config_eth_idp = 0x12341234;
config_eth_address = 5; //global 1, local 1 -> h2s
mbox_put(&a_mb_put, config_eth_hash_1 );
mbox_put(&a_mb_put, config_eth_hash_2);
mbox_put(&a_mb_put, config_eth_idp);
mbox_put(&a_mb_put, config_eth_address);
ret = mbox_get(&a_mb_get);
printk(KERN_INFO "hwt_ethernet configured - 3\n");
}
#ifdef ADD //get interrupt time
mbox_put(&e_mb_put, shared_mem_s2h);
/**************************************
* only interrupts
**************************************/
u32 data = 2147483648;
int iterations = 1;
jiffies_before = jiffies;
for(i= data; i < data + iterations; i++){
mbox_put(&e_mb_put, i);
int ret = mbox_get(&e_mb_get);
jiffies_after = jiffies;
// printk(KERN_INFO "put %d, ret %d\n", i, ret);
}
jiffies_after = jiffies;
printk(KERN_INFO "[reconos-interface] only interrupts: delta (in jiffies) = %lu for %d iterations", jiffies_after - jiffies_before, iterations);
/***********************************************************************
* len = 64, 128, 512, 1024, 1280, 1518, 3000, 6000, 9000, 12000, 15000
**********************************************************************/
for (j = 11; j < 13; j++){
int len = len_array[j];
printk(KERN_INFO "len = %d %p\n", len, shared_mem_s2h);
memset(shared_mem_s2h, 0, 2*len);
printk(KERN_INFO "len = %d\n", len);
iterations = 1000000;
jiffies_before = jiffies;
for(i=0; i < iterations; i++){
mbox_put(&e_mb_put, len);
mbox_get(&e_mb_get);
}
jiffies_after = jiffies;
int ret = memcmp(shared_mem_s2h, shared_mem_s2h+len, len);
if (ret == 0)
printk(KERN_INFO "copy success\n");
else
printk(KERN_INFO " copy failed\n");
printk(KERN_INFO "[reconos-interface] len = %d: delta = %lu", len, jiffies_after - jiffies_before);
}
//#endif
/****************************************
* Reconfigure ETH to send data to dummy
****************************************/
u32 config_data = 1; //global=0, local=1
mbox_put(&a_mb_put, config_data);
#endif
#ifdef SW_APP
// for(i = 0; i < 10000; i++)
{
for (j = 0; j < 7; j++){
int packet_len = len_array[j];
int iterations = 100000;
int j = 0;
int result = 0;
memset(shared_mem_s2h, 0, 2 * packet_len);
/************************************
* send packet to hardware
************************************/
copy_packet(packet_len, 1, shared_mem_s2h, 1, 0);
jiffies_before = jiffies;
for(i = 0; i < iterations; i++){
mbox_put(&c_mb_put, packet_len + 12);
result = mbox_get(&c_mb_get);
}
jiffies_after = jiffies;
printk(KERN_INFO "[reconos-interface] iterations = %d len = %d: delta = %lu", iterations, packet_len, jiffies_after - jiffies_before);
}
}
#endif
#ifdef old
/************************************
* send packet to hardware
************************************/
copy_packet(packet_len, 2, shared_mem_s2h, 1, 1);
struct noc_pkt * snd_pkt = (struct noc_pkt *)shared_mem_s2h;
mbox_put(&c_mb_put, packet_len);
//printk(KERN_INFO "[reconos-interface] packet sent to hw\n");
result = mbox_get(&c_mb_get);
printk(KERN_INFO "[reconos-interface] packet sent received ack from hw, total packet len %d \n", result);
/************************************
* receive packet from hardware
************************************/
//printk(KERN_INFO "[reconos-interface] wait for packet from hw\n");
result = mbox_get(&b_mb_get);
struct noc_pkt * rcv_pkt = (struct noc_pkt *)shared_mem_h2s;
// packet_len = *(int *)shared_mem_h2s;
printk(KERN_INFO "[reconos-interface] packet received with len from mbox %d, from memory %d\n", result, rcv_pkt->payload_len);
printk(KERN_INFO "packet sent\n");
print_packet(snd_pkt);
printk(KERN_INFO "packet received\n");
print_packet(rcv_pkt);
for (j = 0; j < packet_len + 12; j++){
unsigned char written_val = shared_mem_s2h[j];
unsigned char read_val = shared_mem_h2s[j];
printk(KERN_INFO "%x %x", written_val, read_val);
if ((j + 1) % 8 == 0){
printk(KERN_INFO " ");
}
if ((j + 1) % 16 == 0){
printk(KERN_INFO "\n");
}
}
printk(KERN_INFO "\n");
mbox_put(&b_mb_put, shared_mem_h2s); //dummy_value. it will be the amount of data read in a ring buffer scenario
/**********************************************
* send packet to hardware (s2h -> ADD -> eth)
**********************************************/
copy_packet(packet_len, 3, shared_mem_s2h, 0, 1);
mbox_put(&c_mb_put, packet_len);
//printk(KERN_INFO "[reconos-interface] packet sent to hw\n");
result = mbox_get(&c_mb_get);
printk(KERN_INFO "[reconos-interface] packet sent received ack from hw, total packet len %d \n", result);
/***************************************
* reconfigure ADD to send packet to SW
***************************************/
u32 config_data = 5; //global=1, local=1
mbox_put(&e_mb_put, config_data);
config_data = mbox_get(&e_mb_get);
printk(KERN_INFO "ADD replies : %d\n", config_data);
config_data = mbox_get(&e_mb_get);
printk(KERN_INFO "ADD replies : %d\n", config_data);
config_data = mbox_get(&e_mb_get);
printk(KERN_INFO "ADD replies : %d\n", config_data);
config_data = mbox_get(&e_mb_get);
printk(KERN_INFO "ADD replies : %d\n", config_data);
config_data = mbox_get(&e_mb_get);
printk(KERN_INFO "ADD replies : %d\n", config_data);
/**********************************************
* send packet to hardware (s2h -> ADD -> h2s)
**********************************************/
copy_packet(packet_len, 4, shared_mem_s2h, 0, 1);
mbox_put(&c_mb_put, packet_len);
//printk(KERN_INFO "[reconos-interface] packet sent to hw\n");
result = mbox_get(&c_mb_get);
printk(KERN_INFO "[reconos-interface] packet sent received ack from hw, total packet len %d \n", result);
/************************************
* receive packet from hardware (ADD)
************************************/
//printk(KERN_INFO "[reconos-interface] wait for packet from hw\n");
result = mbox_get(&b_mb_get);
rcv_pkt = (struct noc_pkt *)shared_mem_h2s;
// packet_len = *(int *)shared_mem_h2s;
printk(KERN_INFO "[reconos-interface] packet received with len from mbox %d, from memory %d\n", result, rcv_pkt->payload_len);
printk(KERN_INFO "packet sent\n");
print_packet(snd_pkt);
printk(KERN_INFO "packet received\n");
print_packet(rcv_pkt);
for (j = 0; j < packet_len + 12; j++){
unsigned char written_val = shared_mem_s2h[j];
unsigned char read_val = shared_mem_h2s[j];
printk(KERN_INFO "%x %x", written_val, read_val);
if ((j + 1) % 8 == 0){
printk(KERN_INFO " ");
}
if ((j + 1) % 16 == 0){
printk(KERN_INFO "\n");
}
}
printk(KERN_INFO "\n");
mbox_put(&b_mb_put, shared_mem_h2s); //dummy_value. it will be the amount of data read in a ring buffer scenario
/************************************
* receive packet from hardware (ETH -> h2s)
************************************/
//printk(KERN_INFO "[reconos-interface] wait for packet from hw\n");
result = mbox_get(&b_mb_get);
rcv_pkt = (struct noc_pkt *)shared_mem_h2s;
// packet_len = *(int *)shared_mem_h2s;
printk(KERN_INFO "[reconos-interface] packet received with len from mbox %d, from memory %d\n", result, rcv_pkt->payload_len);
printk(KERN_INFO "packet sent\n");
print_packet(snd_pkt);
printk(KERN_INFO "packet received\n");
print_packet(rcv_pkt);
for (j = 0; j < packet_len + 12; j++){
unsigned char written_val = shared_mem_s2h[j];
unsigned char read_val = shared_mem_h2s[j];
printk(KERN_INFO "%x %x", written_val, read_val);
if ((j + 1) % 8 == 0){
printk(KERN_INFO " ");
}
if ((j + 1) % 16 == 0){
printk(KERN_INFO "\n");
}
}
printk(KERN_INFO "\n");
mbox_put(&b_mb_put, shared_mem_h2s); //dummy_value. it will be the amount of data read in a ring buffer scenario
/*****************************************
* Reconfigure ETH to send packets to ADD
*****************************************/
struct config_data config;
config.dst_idp = 170;
config.src_idp = 187;
config.latency_critical = 1;
config.direction = 0; //0 = ingress
config.priority = 1;
config.global_addr = 0;
config.local_addr = 1;
mbox_put(&a_mb_put, config_data);
config_data = mbox_get(&a_mb_get);
printk(KERN_INFO "ADD replies : %d\n", config_data);
config_data = mbox_get(&a_mb_get);
printk(KERN_INFO "ADD replies : %d\n", config_data);
/************************************
* receive packet from hardware (ETH -> ADD -> h2s)
************************************/
//printk(KERN_INFO "[reconos-interface] wait for packet from hw\n");
result = mbox_get(&b_mb_get);
rcv_pkt = (struct noc_pkt *)shared_mem_h2s;
// packet_len = *(int *)shared_mem_h2s;
printk(KERN_INFO "[reconos-interface] packet received with len from mbox %d, from memory %d\n", result, rcv_pkt->payload_len);
printk(KERN_INFO "packet sent\n");
print_packet(snd_pkt);
printk(KERN_INFO "packet received\n");
print_packet(rcv_pkt);
for (j = 0; j < packet_len + 12; j++){
unsigned char written_val = shared_mem_s2h[j];
unsigned char read_val = shared_mem_h2s[j];
printk(KERN_INFO "%x %x", written_val, read_val);
if ((j + 1) % 8 == 0){
printk(KERN_INFO " ");
}
if ((j + 1) % 16 == 0){
printk(KERN_INFO "\n");
}
}
printk(KERN_INFO "\n");
mbox_put(&b_mb_put, shared_mem_h2s); //dummy_value. it will be the amount of data read in a ring buffer scenario
}
int main(int argc, char *argv[])
{
char buffer[MAX_PACKET_SIZE];
static struct sockaddr_in addr;
int rc, i, count;
struct timeval t1, t2, dt;
KICK(argc < 3, "incorrect usage\n"
"Usage:\n"
"./linphone_proxy <local_ip> <remote_ip>\n");
local_ip = argv[1];
remote_ip = argv[2];
add_poll(&fds[0], STDIN_FILENO);
proxy_to_linphone_socket = create_socket(SOCK_DGRAM, SIP_LINPHONE);
init_sockaddr(&proxy_to_linphone_addr, "127.0.0.1", SIP_PORT);
add_poll(&fds[1], proxy_to_linphone_socket);
eprintf("created proxy_to_linphone SIP socket SRC:localhost:%d - DST:localhost:%d\n",
SIP_LINPHONE, SIP_PORT);
proxy_to_proxy_socket = create_socket(SOCK_DGRAM, SIP_PROXY);
init_sockaddr(&proxy_to_proxy_addr, remote_ip, SIP_PROXY);
add_poll(&fds[2], proxy_to_proxy_socket);
eprintf("created proxy_to_sip SIP socket SRC:localhost:%d - DST:%s:%d\n",
SIP_PROXY, remote_ip, SIP_PROXY);
proxy_to_linphone_data_socket = create_socket(SOCK_DGRAM, DATA_LINPHONE);
init_sockaddr(&proxy_to_linphone_data_addr, "127.0.0.1", DATA_PORT);
add_poll(&fds[3], proxy_to_linphone_data_socket);
eprintf("created proxy_to_linphone DATA socket SRC:localhost:%d - DST:localhost:%d\n",
DATA_LINPHONE, DATA_PORT);
proxy_to_proxy_data_socket = create_socket(SOCK_DGRAM, DATA_PROXY);
init_sockaddr(&proxy_to_proxy_data_addr, remote_ip, DATA_PROXY);
add_poll(&fds[4], proxy_to_proxy_data_socket);
eprintf("created proxy_to_proxy DATA socket SRC:localhost:%d - DST:%s:%d\n",
DATA_PROXY, remote_ip, DATA_PROXY);
manager_socket = create_socket(SOCK_DGRAM, MANAGER_PORT);
init_sockaddr(&manager_addr, "0.0.0.0", MANAGER_PORT);
add_poll(&fds[5], manager_socket);
eprintf("created manager socket SRC:localhost:%d - DST:0.0.0.0:0\n",
MANAGER_PORT);
while (1) {
rc = poll(fds, NUM_FDS, -1);
DIE(-1 == rc, "poll");
for (i = 0; i < NUM_FDS; i++) {
if (0 == fds[i].revents) {
continue;
}
switch(i) {
/* receive line from console */
case 0:
break;
/* receive SIP packet from linphone */
case 1:
gettimeofday_safe(&t1);
count = recv_msg(fds[i].fd, &proxy_to_linphone_addr, buffer);
if (begins_with(buffer, "INVITE")) {
copy_packet(&out_invite, buffer, count);
//printf("captured INVITE packet:\n%s\n", out_invite.buffer);
} else if (begins_with(buffer, "ACK")) {
copy_packet(&out_ack, buffer, count);
//printf("captured ACK packet:\n%s\n", out_ack.buffer);
} else if (strstr(buffer, "200 OK") && strstr(buffer, "OPTIONS" )) {
copy_packet(&out_op_ok, buffer, count);
//printf("captured OPTIONS OK packet:\n%s\n", out_op_ok.buffer);
}
send_msg(proxy_to_proxy_socket, &proxy_to_proxy_addr, buffer, count);
gettimeofday_safe(&t2);
time_diff(&t1, &t2, &dt);
printf("time case 1: %lu.%06lu\n", dt.tv_sec, dt.tv_usec);
break;
/* receive SIP packet from proxy */
case 2:
gettimeofday_safe(&t1);
count = recv_msg(fds[i].fd, &addr, buffer);
send_msg(proxy_to_linphone_socket, &proxy_to_linphone_addr, buffer, count);
gettimeofday_safe(&t2);
time_diff(&t1, &t2, &dt);
printf("time case 2: %lu.%06lu\n", dt.tv_sec, dt.tv_usec);
break;
/* receive data packet from linphone */
case 3:
gettimeofday_safe(&t1);
count = recv_msg(fds[i].fd, &proxy_to_linphone_data_addr, buffer);
send_msg(proxy_to_proxy_data_socket, &proxy_to_proxy_data_addr, buffer, count);
gettimeofday_safe(&t2);
time_diff(&t1, &t2, &dt);
printf("time case 3: %lu.%06lu\n", dt.tv_sec, dt.tv_usec);
break;
/* receive data packet from proxy */
case 4:
gettimeofday_safe(&t1);
count = recv_msg(fds[i].fd, &addr, buffer);
send_msg(proxy_to_linphone_data_socket, &proxy_to_linphone_data_addr, buffer, count);
gettimeofday_safe(&t2);
time_diff(&t1, &t2, &dt);
printf("time case 4: %lu.%06lu\n", dt.tv_sec, dt.tv_usec);
break;
/* receive command from manager */
case 5:
count = recv_msg(fds[i].fd, &manager_addr, buffer);
if (begins_with(buffer, "IP: ")) {
while (!isdigit(buffer[count - 1])) {
buffer[--count] = 0;
}
strcpy(migrate_ip, buffer + 4);
migrate_init();
} else if (begins_with(buffer, "establish")) {
migrate_establish();
} else if (begins_with(buffer, "redirect: ")) {
while (!isdigit(buffer[count - 1])) {
buffer[--count] = 0;
}
strcpy(redirect_ip, buffer + 10);
migrate_redirect();
}
break;
/* error */
default:
break;
}
}
}
return EXIT_SUCCESS;
}
static inline void migrate_establish()
{
char buffer[MAX_PACKET_SIZE];
struct pollfd fd;
int count, rc;
char *p, *q;
add_poll(&fd, manager_socket);
rc = poll(&fd, 1, -1);
DIE(-1 == rc, "poll");
count = recv_msg(manager_socket, &manager_addr, buffer);
copy_packet(&useful_invite, buffer, count);
eprintf("%s\n\n", useful_invite.buffer);
rc = poll(&fd, 1, -1);
DIE(-1 == rc, "poll");
count = recv_msg(manager_socket, &manager_addr, buffer);
copy_packet(&useful_ack, buffer, count);
eprintf("%s\n\n", useful_ack.buffer);
rc = poll(&fd, 1, -1);
DIE(-1 == rc, "poll");
count = recv_msg(manager_socket, &manager_addr, buffer);
copy_packet(&useful_op_ok, buffer, count);
eprintf("%s\n\n", buffer);
get_data(useful_ack.buffer, &ack_data);
printf("\nACK data\n");
printf("branch: %s\n", ack_data.branch);
printf("From: %s\n", ack_data.from);
printf("tag: %s\n", ack_data.from_tag);
printf("To: %s\n", ack_data.to);
printf("tag: %s\n", ack_data.to_tag);
printf("Call-id: %s\n", ack_data.call_id);
printf("\n");
get_data(useful_op_ok.buffer, &op_ok_data);
printf("\nOPTIONS OK data\n");
printf("branch: %s\n", op_ok_data.branch);
printf("From: %s\n", op_ok_data.from);
printf("tag: %s\n", op_ok_data.from_tag);
printf("To: %s\n", op_ok_data.to);
printf("tag: %s\n", op_ok_data.to_tag);
printf("Call-id: %s\n", op_ok_data.call_id);
printf("\n");
p = strstr(ack_data.from, "@") + 1;
q = strstr(p, ">");
count = q - p;
strncpy(initial_ip, p, count);
initial_ip[count] = 0;
printf("initial_ip: %s\n", initial_ip);
replace_all(useful_invite.buffer, remote_ip, local_ip);
replace_all(useful_invite.buffer, initial_ip, remote_ip);
replace_all(useful_invite.buffer, ack_data.from_tag, ack_data.to_tag);
useful_invite.size = strlen(useful_invite.buffer);
printf("INVITE:\n%s\n", useful_invite.buffer);
send_msg(proxy_to_linphone_socket, &proxy_to_linphone_addr,
useful_invite.buffer, strlen(useful_invite.buffer));
add_poll(&fd, proxy_to_linphone_socket);
rc = poll(&fd, 1, -1);
DIE(-1 == rc, "poll");
recv_msg(proxy_to_linphone_socket, &proxy_to_linphone_addr, buffer);
printf("\nreceived:\n%s\n", buffer);
rc = poll(&fd, 1, -1);
DIE(-1 == rc, "poll");
recv_msg(proxy_to_linphone_socket, &proxy_to_linphone_addr, buffer);
printf("\nreceived:\n%s\n", buffer);
get_data(buffer, &data_101);
rc = poll(&fd, 1, -1);
DIE(-1 == rc, "poll");
count = recv_msg(proxy_to_linphone_socket, &proxy_to_linphone_addr, buffer);
copy_packet(&options, buffer, count);
printf("\nreceived:\n%s\n", buffer);
get_data(options.buffer, &options_data);
printf("\nOPTIONS data\n");
printf("branch: %s\n", options_data.branch);
printf("From: %s\n", options_data.from);
printf("tag: %s\n", options_data.from_tag);
printf("To: %s\n", options_data.to);
printf("tag: %s\n", options_data.to_tag);
printf("Call-id: %s\n", options_data.call_id);
printf("\n");
replace_all(useful_op_ok.buffer, remote_ip, local_ip);
replace_all(useful_op_ok.buffer, initial_ip, remote_ip);
replace_all(useful_op_ok.buffer, op_ok_data.from_tag, options_data.from_tag);
replace_all(useful_op_ok.buffer, op_ok_data.to_tag, options_data.to_tag);
replace_all(useful_op_ok.buffer, op_ok_data.branch, options_data.branch);
replace_all(useful_op_ok.buffer, op_ok_data.call_id, options_data.call_id);
printf("\nforged OPTIONS OK: \n%s\n", useful_op_ok.buffer);
send_msg(proxy_to_linphone_socket, &proxy_to_linphone_addr,
useful_op_ok.buffer, strlen(useful_op_ok.buffer));
replace_all(useful_ack.buffer, remote_ip, local_ip);
replace_all(useful_ack.buffer, initial_ip, remote_ip);
replace_all(useful_ack.buffer, ack_data.from_tag, "magic");
replace_all(useful_ack.buffer, ack_data.to_tag, data_101.to_tag);
replace_all(useful_ack.buffer, "magic", ack_data.to_tag);
printf("\nforged ACK: \n%s\n", useful_ack.buffer);
printf("1\n");
rc = poll(&fd, 1, -1);
DIE(-1 == rc, "poll");
recv_msg(proxy_to_linphone_socket, &proxy_to_linphone_addr, buffer);
printf("\nreceived:\n%s\n", buffer);
printf("2\n");
rc = poll(&fd, 1, -1);
DIE(-1 == rc, "poll");
recv_msg(proxy_to_linphone_socket, &proxy_to_linphone_addr, buffer);
printf("\nreceived:\n%s\n", buffer);
printf("3\n");
send_msg(proxy_to_linphone_socket, &proxy_to_linphone_addr,
useful_ack.buffer, strlen(useful_ack.buffer));
printf("4\n");
strcpy(buffer, "done");
send_msg(manager_socket, &manager_addr, buffer, 4);
printf("5\n");
}
