/** \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"); }