char *lo_address_get_url(lo_address a) { char *buf; int ret=0; int needquote = strchr(a->host, ':') ? 1 : 0; char *fmt; if (needquote) { fmt = "osc.%s://[%s]:%s/"; } else { fmt = "osc.%s://%s:%s/"; } #ifndef _MSC_VER ret = snprintf(NULL, 0, fmt, get_protocol_name(a->protocol), a->host, a->port); #endif if (ret <= 0) { /* this libc is not C99 compliant, guess a size */ ret = 1023; } buf = malloc((ret + 2) * sizeof(char)); snprintf(buf, ret+1, fmt, get_protocol_name(a->protocol), a->host, a->port); return buf; }
static void print_ciphersuite_data(BIO *io, SSL *ssl, int js) { SSL_SESSION* session = SSL_get_session(ssl); long protocol = SSL_version(ssl); const char *protocol_name = get_protocol_name(protocol); const char *eol = js ? "\\n\\\n" : "\n"; if(BIO_printf(io, "Version: 0x%lx %s%s", protocol, protocol_name, eol) <= 0) err_exit("Write error"); if(BIO_printf(io, "Current cipher: %s%s", SSL_CIPHER_get_name(SSL_get_current_cipher(ssl)), eol) <= 0) err_exit("Write error"); STACK_OF(SSL_CIPHER) *ciphers = session->ciphers; SSL_CIPHER *c; int n = sk_SSL_CIPHER_num(ciphers); if(BIO_printf(io, "client sent %d ciphers%s", n, eol) <= 0) err_exit("Write error"); int i; for (i = 0; i < n; i++) { c = sk_SSL_CIPHER_value(ciphers, i); if(BIO_printf(io, "client [%2d of %2d]: %s%s", i, n, SSL_CIPHER_get_name(c), eol) <= 0) err_exit("Write error"); } }
int url_bypasses_socks(unsigned char *url) { int ret = 0; /* against warning */ unsigned char *p; if (!(p = get_protocol_name(url))) return 1; get_prot_info(p, NULL, NULL, NULL, NULL, &ret); mem_free(p); return ret; }
void (*get_external_protocol_function(unsigned char *url))(struct session *, unsigned char *) { unsigned char *p; void (*f)(struct session *, unsigned char *) = NULL; int post = 0; if (!(p = get_protocol_name(url))) return NULL; get_prot_info(p, NULL, NULL, &f, &post, NULL); mem_free(p); if (!post && strchr(cast_const_char url, POST_CHAR)) return NULL; return f; }
void (*get_protocol_handle(unsigned char *url))(struct connection *) { unsigned char *p; void (*f)(struct connection *) = NULL; int post = 0; if (!(p = get_protocol_name(url))) return NULL; get_prot_info(p, NULL, &f, NULL, &post, NULL); mem_free(p); if (!post && strchr(cast_const_char url, POST_CHAR)) return NULL; return f; }
int get_port(unsigned char *url) { unsigned char *h; int hl; long n = -1; if (parse_url(url, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &h, &hl, NULL, NULL, NULL)) return -1; if (h) { n = strtol(cast_const_char h, NULL, 10); if (n > 0 && n < 65536) return (int)n; return -1; } if ((h = get_protocol_name(url))) { int nn = -1; /* against warning */ get_prot_info(h, &nn, NULL, NULL, NULL, NULL); mem_free(h); n = nn; } return (int)n; }
char* Flow::print(char *buf, u_int buf_len) { char buf1[32], buf2[32]; buf[0] = '\0'; if((cli_host == NULL) || (srv_host == NULL)) return(buf); snprintf(buf, buf_len, "%s %s:%u > %s:%u [proto: %u/%s][%u/%u pkts][%llu/%llu bytes]\n", get_protocol_name(), cli_host->get_ip()->print(buf1, sizeof(buf1)), ntohs(cli_port), srv_host->get_ip()->print(buf2, sizeof(buf2)), ntohs(srv_port), ndpi_detected_protocol, ndpi_get_proto_name(iface->get_ndpi_struct(), ndpi_detected_protocol), cli2srv_packets, srv2cli_packets, (long long unsigned) cli2srv_bytes, (long long unsigned) srv2cli_bytes); return(buf); }
const Ekiga::CallManager::InterfaceList Opal::H323::CallManager::get_interfaces () const { Ekiga::CallManager::InterfaceList ilist; OpalListenerList listeners = h323_endpoint.GetListeners (); for (int i = 0 ; i < listeners.GetSize () ; i++) { Ekiga::CallManager::Interface iface; PIPSocket::Address address; WORD port; PString proto_prefix = listeners[i].GetLocalAddress ().GetProtoPrefix (); listeners[i].GetLocalAddress ().GetIpAndPort (address, port); iface.voip_protocol = get_protocol_name (); iface.id = "*"; iface.protocol = (const char*) proto_prefix.Left (proto_prefix.GetLength () - 1); // Strip final $ delimiter iface.port = (unsigned int) port; ilist.push_back (iface); } return ilist; }
int _protocol_init(const char *prot_name, PROTO_PARA *ppp) { /* check whether the protocol version match the csf core version */ if (CORE_VER_REQUIRE > ppp->vcbp->lowest_ver) return PROTO_VER_ERR; logger_init(ppp->chp->logp, NULL, 0, 0); mp_init(20, 100); monitor_init(ppp->chp->mntp); submit_request_init(ppp->chp->sribp); g_pcp = ppp->pcp; set_protocol_name(prot_name); pthread_once(&init_done, pthr_key_create); pthread_setspecific(pthread_key, NULL); if (protocol_init(get_protocol_name()) < 0) return PROTO_INIT_ERR; return PROTO_INIT_OK; }
/* * 把PAR_ITF_ANALYZE_ID结构转换成EA_ITF_PAR_INFO_ID结构. */ void convet_par_itf( EA_ITF_PAR_INFO_ID itf_par_info_id, PAR_ITF_ANALYZE_ID par_itf_analysis_id, char redirect_flag ) { PROTECTED_RESOURCE_ID tmp = NULL; int i = 0; get_protocol_name(itf_par_info_id->protocol_name, par_itf_analysis_id); itf_par_info_id->cfg_file_set = par_itf_analysis_id->cfg_file_set; itf_par_info_id->func_switch = par_itf_analysis_id->func_switch; strcpy(itf_par_info_id->pkt_file_dir, par_itf_analysis_id->pkt_file_dir); itf_par_info_id->deposit_ivl_sec = par_itf_analysis_id->deposit_ivl_sec; itf_par_info_id->usr_list_id = (USR_LIST_MEM_ID) \ get_shm_addr( par_itf_analysis_id->usr_list_key, SHM_RDONLY); itf_par_info_id->usr_all_num = par_itf_analysis_id->usr_num; tmp = (PROTECTED_RESOURCE_ID)get_shm_addr(par_itf_analysis_id->rule_pool_key, SHM_RDONLY); itf_par_info_id->protect_res_num = par_itf_analysis_id->rule_num; if(tmp == -1) exit(-1); else { if((itf_par_info_id->protect_res_id = (PROTECTED_RESOURCE_ID) \ calloc(itf_par_info_id->protect_res_num, \ PROTECTED_RESOURCE_SIZE)) == NULL) { printf("protected_resource_id calloc error\n"); exit(-1); } memcpy(itf_par_info_id->protect_res_id, tmp, \ (itf_par_info_id->protect_res_num) * PROTECTED_RESOURCE_SIZE); for(i = 0; i < itf_par_info_id->protect_res_num; i++) if(get_resource_port(itf_par_info_id->protect_res_id, i)\ == FALSE) exit(-1);/* where is get_resource_port */ } /* ended of if-else */ itf_par_info_id->authorize_network_id = (AUTHORIZE_ACCESS_NETWORK_ID) \ get_shm_addr(par_itf_analysis_id->authorize_network_key, SHM_RDONLY); itf_par_info_id->authorize_network_num = par_itf_analysis_id->authorize_network_num; itf_par_info_id->authorize_cmd_id = (AUTHORIZE_CMD_ID) \ get_shm_addr(par_itf_analysis_id->authorize_cmd_key, SHM_RDONLY); itf_par_info_id->authorize_cmd_num = par_itf_analysis_id->authorize_cmd_num; itf_par_info_id->authorize_account_id = (AUTHORIZE_ACCOUNT_ID) \ get_shm_addr(par_itf_analysis_id->authorize_account_key, SHM_RDONLY); itf_par_info_id->authorize_account_num = par_itf_analysis_id->authorize_account_num; itf_par_info_id->authorize_custom_id = (AUTHORIZE_CUSTOM_ID) \ get_shm_addr( par_itf_analysis_id->authorize_custom_key, SHM_RDONLY); itf_par_info_id->authorize_custom_num = par_itf_analysis_id->authorize_custom_num; itf_par_info_id->authorize_pro_feature_id = (AUTHORIZE_PROTOCOL_FEATURE_ID) get_shm_addr( par_itf_analysis_id->authorize_feature_key, SHM_RDONLY); itf_par_info_id->authorize_pro_feature_num = par_itf_analysis_id->authorize_feature_num; if(redirect_flag) { /* is true */ itf_par_info_id->redirection_port_info_id = (REDIRECTION_PORT_INFO_ID) get_shm_addr(par_itf_analysis_id->redirect_key, 0); itf_par_info_id->redirect_pid = par_itf_analysis_id->redirect_pid; itf_par_info_id->semid = semget(par_itf_analysis_id->sem_key, 0, IPC_CREAT); } }
static int http_serve(SSL *ssl, int s) { char buf[BUFSIZZ]; int r,len; BIO *io,*ssl_bio; io=BIO_new(BIO_f_buffer()); ssl_bio=BIO_new(BIO_f_ssl()); BIO_set_ssl(ssl_bio,ssl,BIO_CLOSE); BIO_push(io,ssl_bio); r=BIO_gets(io,buf,BUFSIZZ-1); switch(SSL_get_error(ssl,r)){ case SSL_ERROR_NONE: len=r; break; default: berr_exit("SSL read problem"); } char *saveptr; char resource[512] = {'\0'}; char *token = strtok_r(buf, " ", &saveptr); if (token && strcasecmp(token, "GET") == 0) { token = strtok_r(NULL, " ", &saveptr); if (token) { strncpy(resource, token, sizeof(resource)); } } if (resource[0]) { while(1){ r=BIO_gets(io,buf,BUFSIZZ-1); switch(SSL_get_error(ssl,r)){ case SSL_ERROR_NONE: len=r; break; default: berr_exit("SSL read problem"); } /* Look for the blank line that signals the end of the HTTP headers */ if(!strcmp(buf,"\r\n") || !strcmp(buf,"\n")) break; } } if (strcasecmp(resource, "/ciphersuites.txt") == 0) { http_serve_headers(io, 200, "OK", "text/plain"); print_ciphersuite_data(io, ssl, 0); } else if (strcasecmp(resource, "/ciphersuites.js") == 0) { long protocol = SSL_version(ssl); http_serve_headers(io, 200, "OK", "text/javascript"); if(BIO_printf(io, "$(function() {\n insert_text('%s', '", get_protocol_name(protocol)) <= 0) err_exit("Write error"); print_ciphersuite_data(io, ssl, 1); if(BIO_printf(io, "');\n});") <= 0) err_exit("Write error"); } else { http_serve_headers(io, 404, "Not Found", "text/plain"); if(BIO_puts(io, "Not found.") <= 0) err_exit("Write error"); } if((r=BIO_flush(io))<0) err_exit("Error flushing BIO"); r=SSL_shutdown(ssl); if(!r){ /* If we called SSL_shutdown() first then we always get return value of '0'. In this case, try again, but first send a TCP FIN to trigger the other side's close_notify*/ shutdown(s,1); r=SSL_shutdown(ssl); } switch(r){ case 1: break; /* Success */ case 0: case -1: default: berr_exit("Shutdown failed"); } SSL_free(ssl); close(s); return(0); }
bool C_ProtocolControl::fromXml (C_XmlData *P_data, T_pConfigValueList P_config_value_list, bool P_display_protocol_stats) { bool L_ret = true ; T_pXmlData_List L_subList ; T_XmlData_List::iterator L_subListIt ; C_XmlData *L_data ; char *L_protocol_name, *L_protocol_type ; int L_protocol_id ; T_ProtocolInstList L_protocol_inst_list ; T_pProtocolInstanceInfo L_protocol_info ; T_ProtocolInstList::iterator L_it ; GEN_DEBUG(1, "C_ProtocolControl::fromXml() start"); if (P_data != NULL) { if ((L_subList = P_data->get_sub_data()) != NULL) { for (L_subListIt = L_subList->begin() ; L_subListIt != L_subList->end() ; L_subListIt++) { L_data = *L_subListIt ; if (L_data != NULL) { if (strcmp(L_data->get_name(), XML_PROTOCOL_SECTION) == 0) { // protocol section definition found L_protocol_name = get_protocol_name (L_data) ; // check protocol type for creation L_protocol_type = get_protocol_type (L_data) ; // check name/type presence if (L_protocol_name == NULL) { GEN_ERROR(E_GEN_FATAL_ERROR, "name mandatory for section " << XML_PROTOCOL_SECTION); L_ret = false ; break ; } if (L_protocol_type == NULL) { GEN_ERROR(E_GEN_FATAL_ERROR, "type mandatory for section " << XML_PROTOCOL_SECTION); L_ret = false ; break ; } // check protocol name unicity if (m_name_map->find(T_ProtocolNameMap::key_type(L_protocol_name)) != m_name_map->end()) { GEN_ERROR(E_GEN_FATAL_ERROR, XML_PROTOCOL_SECTION << " with name [" << L_protocol_name << "] already defined"); L_ret = false ; break ; } // check protocol type or sub type if (strcmp(L_protocol_type, "binary") == 0) { // create protocol instance C_ProtocolBinary *L_protocol_instance = NULL ; T_ConstructorResult L_res ; NEW_VAR(L_protocol_instance, C_ProtocolBinary()); L_protocol_instance->construction_data(L_data, &L_protocol_name, &L_res) ; if (L_res != E_CONSTRUCTOR_OK) { GEN_ERROR(E_GEN_FATAL_ERROR, "Error found in protocol definition"); DELETE_VAR(L_protocol_instance); L_ret = false ; break ; } else { // store new instance if (P_display_protocol_stats == true) { C_ProtocolStats *L_protocol_stats ; NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance)); L_protocol_instance->set_stats(L_protocol_stats); } L_protocol_id = m_id_gen->new_id() ; ALLOC_VAR(L_protocol_info, T_pProtocolInstanceInfo, sizeof(T_ProtocolInstanceInfo)); L_protocol_info->m_instance = L_protocol_instance ; L_protocol_info->m_id = L_protocol_id ; L_protocol_info->m_name = L_protocol_name ; L_protocol_inst_list.push_back(L_protocol_info); m_name_map ->insert(T_ProtocolNameMap::value_type(L_protocol_name, L_protocol_id)) ; } } else if (strcmp(L_protocol_type, "binary-tlv") == 0) { // create protocol instance C_ProtocolTlv *L_protocol_instance = NULL ; T_ConstructorResult L_res ; NEW_VAR(L_protocol_instance, C_ProtocolTlv()); L_protocol_instance->construction_data(L_data, &L_protocol_name, &L_res) ; if (L_res != E_CONSTRUCTOR_OK) { GEN_ERROR(E_GEN_FATAL_ERROR, "Error found in protocol definition"); DELETE_VAR(L_protocol_instance); L_ret = false ; break ; } else { // store new instance if (P_display_protocol_stats == true) { C_ProtocolStats *L_protocol_stats ; NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance)); L_protocol_instance->set_stats(L_protocol_stats); } L_protocol_id = m_id_gen->new_id() ; ALLOC_VAR(L_protocol_info, T_pProtocolInstanceInfo, sizeof(T_ProtocolInstanceInfo)); L_protocol_info->m_instance = L_protocol_instance ; L_protocol_info->m_id = L_protocol_id ; L_protocol_info->m_name = L_protocol_name ; L_protocol_inst_list.push_back(L_protocol_info); m_name_map ->insert(T_ProtocolNameMap::value_type(L_protocol_name, L_protocol_id)) ; } } else if (strcmp(L_protocol_type, "binary-body-not-interpreted") == 0) { // create protocol instance C_ProtocolBinaryBodyNotInterpreted *L_protocol_instance = NULL ; T_ConstructorResult L_res ; NEW_VAR(L_protocol_instance, C_ProtocolBinaryBodyNotInterpreted()); L_protocol_instance->construction_data(L_data, &L_protocol_name, &L_res) ; if (L_res != E_CONSTRUCTOR_OK) { GEN_ERROR(E_GEN_FATAL_ERROR, "Error found in protocol definition"); DELETE_VAR(L_protocol_instance); L_ret = false ; break ; } else { // store new instance if (P_display_protocol_stats == true) { C_ProtocolStats *L_protocol_stats ; NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance)); L_protocol_instance->set_stats(L_protocol_stats); } L_protocol_id = m_id_gen->new_id() ; ALLOC_VAR(L_protocol_info, T_pProtocolInstanceInfo, sizeof(T_ProtocolInstanceInfo)); L_protocol_info->m_instance = L_protocol_instance ; L_protocol_info->m_id = L_protocol_id ; L_protocol_info->m_name = L_protocol_name ; L_protocol_inst_list.push_back(L_protocol_info); m_name_map ->insert(T_ProtocolNameMap::value_type(L_protocol_name, L_protocol_id)) ; } } else if (strcmp(L_protocol_type, "binary-separator") == 0) { // create protocol instance C_ProtocolBinarySeparator *L_protocol_instance = NULL ; T_ConstructorResult L_res ; NEW_VAR(L_protocol_instance, C_ProtocolBinarySeparator()); L_protocol_instance ->construction_data(L_data, &L_protocol_name, &L_res) ; if (L_res != E_CONSTRUCTOR_OK) { GEN_ERROR(E_GEN_FATAL_ERROR, "Error found in protocol definition"); DELETE_VAR(L_protocol_instance); L_ret = false ; break ; } else { // store new instance if (P_display_protocol_stats == true) { C_ProtocolStats *L_protocol_stats ; NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance)); L_protocol_instance->set_stats(L_protocol_stats); } L_protocol_id = m_id_gen->new_id() ; ALLOC_VAR(L_protocol_info, T_pProtocolInstanceInfo, sizeof(T_ProtocolInstanceInfo)); L_protocol_info->m_instance = L_protocol_instance ; L_protocol_info->m_id = L_protocol_id ; L_protocol_info->m_name = L_protocol_name ; L_protocol_inst_list.push_back(L_protocol_info); m_name_map ->insert(T_ProtocolNameMap::value_type(L_protocol_name, L_protocol_id)) ; } } else if (strcmp(L_protocol_type, "external-library") == 0) { C_ProtocolExternal *L_protocol_instance = NULL ; T_ConstructorResult L_res = E_CONSTRUCTOR_OK ; NEW_VAR(L_protocol_instance, C_ProtocolExternal(m_transport_control, L_data, &L_protocol_name, P_config_value_list, &L_res)); if (L_res != E_CONSTRUCTOR_OK) { GEN_ERROR(E_GEN_FATAL_ERROR, "Error found in protocol definition"); DELETE_VAR(L_protocol_instance); L_ret = false ; break ; } else { if (P_display_protocol_stats == true) { C_ProtocolStats *L_protocol_stats ; NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance)); L_protocol_instance->set_stats(L_protocol_stats); } // store new instance L_protocol_id = m_id_gen->new_id() ; ALLOC_VAR(L_protocol_info, T_pProtocolInstanceInfo, sizeof(T_ProtocolInstanceInfo)); L_protocol_info->m_instance = L_protocol_instance ; L_protocol_info->m_id = L_protocol_id ; L_protocol_info->m_name = L_protocol_name ; L_protocol_inst_list.push_back(L_protocol_info); m_name_map ->insert(T_ProtocolNameMap::value_type(L_protocol_name, L_protocol_id)) ; } } else if (strcmp(L_protocol_type, "text") == 0) { C_ProtocolText *L_protocol_instance = NULL ; T_ConstructorResult L_res = E_CONSTRUCTOR_OK ; NEW_VAR(L_protocol_instance, C_ProtocolText()); L_protocol_instance->analyze_data(L_data, &L_protocol_name, P_config_value_list, &L_res); if (L_res != E_CONSTRUCTOR_OK) { GEN_ERROR(E_GEN_FATAL_ERROR, "Error found in protocol definition"); DELETE_VAR(L_protocol_instance); L_ret = false ; break ; } else { if (P_display_protocol_stats == true) { C_ProtocolStats *L_protocol_stats ; NEW_VAR(L_protocol_stats,C_ProtocolStats(L_protocol_instance)); L_protocol_instance->set_stats(L_protocol_stats); } // store new instance L_protocol_id = m_id_gen->new_id() ; ALLOC_VAR(L_protocol_info, T_pProtocolInstanceInfo, sizeof(T_ProtocolInstanceInfo)); L_protocol_info->m_instance = L_protocol_instance ; L_protocol_info->m_id = L_protocol_id ; L_protocol_info->m_name = L_protocol_name ; L_protocol_inst_list.push_back(L_protocol_info); m_name_map ->insert(T_ProtocolNameMap::value_type(L_protocol_name, L_protocol_id)) ; } } else { GEN_ERROR(E_GEN_FATAL_ERROR, XML_PROTOCOL_SECTION << " [" << L_protocol_name << "] with type [" << L_protocol_type << "] unsupported"); L_ret = false ; } } } } if (L_ret != false) { if (!L_protocol_inst_list.empty()) { m_protocol_table_size = L_protocol_inst_list.size() ; ALLOC_TABLE(m_protocol_table, T_pC_ProtocolFrame*, sizeof(T_pC_ProtocolFrame), m_protocol_table_size) ; ALLOC_TABLE(m_protocol_name_table, char**, sizeof(char*), m_protocol_table_size) ; for (L_it = L_protocol_inst_list.begin(); L_it != L_protocol_inst_list.end() ; L_it++) { L_protocol_info = *L_it ; m_protocol_table[L_protocol_info->m_id] = L_protocol_info->m_instance ; m_protocol_name_table[L_protocol_info->m_id] = L_protocol_info->m_name ; } } else { GEN_ERROR(E_GEN_FATAL_ERROR, "No protocol definition found"); L_ret = false ; } } // if L_ret != false if (!L_protocol_inst_list.empty()) { for (L_it = L_protocol_inst_list.begin(); L_it != L_protocol_inst_list.end() ; L_it++) { FREE_VAR(*L_it); } L_protocol_inst_list.erase(L_protocol_inst_list.begin(), L_protocol_inst_list.end()); } }
int main(int argc, char ** argv) { int exit_code = EXIT_FAILURE; char * version = strdup("version 1.0"); const char * usage = "usage: %s [options] host\n"; void * algorithm_options; traceroute_options_t traceroute_options; traceroute_options_t * ptraceroute_options; mda_options_t mda_options; probe_t * probe; pt_loop_t * loop; int family; address_t dst_addr; options_t * options; char * dst_ip; const char * algorithm_name; const char * protocol_name; bool use_icmp, use_udp, use_tcp; // Prepare the commande line options if (!(options = init_options(version))) { fprintf(stderr, "E: Can't initialize options\n"); goto ERR_INIT_OPTIONS; } // Retrieve values passed in the command-line if (options_parse(options, usage, argv) != 1) { fprintf(stderr, "%s: destination required\n", basename(argv[0])); goto ERR_OPT_PARSE; } // We assume that the target IP address is always the last argument dst_ip = argv[argc - 1]; algorithm_name = algorithm_names[0]; protocol_name = protocol_names[0]; // Checking if there is any conflicts between options passed in the commandline if (!check_options(is_icmp, is_tcp, is_udp, is_ipv4, is_ipv6, dst_port[3], src_port[3], protocol_name, algorithm_name)) { goto ERR_CHECK_OPTIONS; } use_icmp = is_icmp || strcmp(protocol_name, "icmp") == 0; use_tcp = is_tcp || strcmp(protocol_name, "tcp") == 0; use_udp = is_udp || strcmp(protocol_name, "udp") == 0; // If not any ip version is set, call address_guess_family. // If only one is set to true, set family to AF_INET or AF_INET6 if (is_ipv4) { family = AF_INET; } else if (is_ipv6) { family = AF_INET6; } else { // Get address family if not defined by the user if (!address_guess_family(dst_ip, &family)) goto ERR_ADDRESS_GUESS_FAMILY; } // Translate the string IP / FQDN into an address_t * instance if (address_from_string(family, dst_ip, &dst_addr) != 0) { fprintf(stderr, "E: Invalid destination address %s\n", dst_ip); goto ERR_ADDRESS_IP_FROM_STRING; } // Probe skeleton definition: IPv4/UDP probe targetting 'dst_ip' if (!(probe = probe_create())) { fprintf(stderr,"E: Cannot create probe skeleton"); goto ERR_PROBE_CREATE; } // Prepare the probe skeleton probe_set_protocols( probe, get_ip_protocol_name(family), // "ipv4" | "ipv6" get_protocol_name(family, use_icmp, use_tcp, use_udp), // "icmpv4" | "icmpv6" | "tcp" | "udp" NULL ); probe_set_field(probe, ADDRESS("dst_ip", &dst_addr)); if (send_time[3]) { if(send_time[0] <= 10) { // seconds probe_set_delay(probe, DOUBLE("delay", send_time[0])); } else { // milli-seconds probe_set_delay(probe, DOUBLE("delay", 0.001 * send_time[0])); } } // ICMPv* do not support src_port and dst_port fields nor payload. if (!use_icmp) { uint16_t sport = 0, dport = 0; if (use_udp) { // Option -U sets port to 53 (DNS) if dst_port is not explicitely set sport = src_port[3] ? src_port[0] : UDP_DEFAULT_SRC_PORT; dport = dst_port[3] ? dst_port[0] : (is_udp ? UDP_DST_PORT_USING_U : UDP_DEFAULT_DST_PORT); } else if (use_tcp) { // Option -T sets port to 80 (http) if dst_port is not explicitely set sport = src_port[3] ? src_port[0] : TCP_DEFAULT_SRC_PORT; dport = dst_port[3] ? dst_port[0] : (is_tcp ? TCP_DST_PORT_USING_T : TCP_DEFAULT_DST_PORT); } // Update ports probe_set_fields( probe, I16("src_port", sport), I16("dst_port", dport), NULL ); // Resize payload (it will be use to set our customized checksum in the {TCP, UDP} layer) probe_payload_resize(probe, 2); } // Algorithm options (dedicated options) if (strcmp(algorithm_name, "paris-traceroute") == 0) { traceroute_options = traceroute_get_default_options(); ptraceroute_options = &traceroute_options; algorithm_options = &traceroute_options; algorithm_name = "traceroute"; } else if ((strcmp(algorithm_name, "mda") == 0) || options_mda_get_is_set()) { mda_options = mda_get_default_options(); ptraceroute_options = &mda_options.traceroute_options; algorithm_options = &mda_options; options_mda_init(&mda_options); } else { fprintf(stderr, "E: Unknown algorithm"); goto ERR_UNKNOWN_ALGORITHM; } // Algorithm options (common options) options_traceroute_init(ptraceroute_options, &dst_addr); // Create libparistraceroute loop if (!(loop = pt_loop_create(loop_handler, NULL))) { fprintf(stderr, "E: Cannot create libparistraceroute loop"); goto ERR_LOOP_CREATE; } // Set network options (network and verbose) options_network_init(loop->network, is_debug); printf("%s to %s (", algorithm_name, dst_ip); address_dump(&dst_addr); printf("), %u hops max, %u bytes packets\n", ptraceroute_options->max_ttl, (unsigned int)packet_get_size(probe->packet) ); // Add an algorithm instance in the main loop if (!pt_add_instance(loop, algorithm_name, algorithm_options, probe)) { fprintf(stderr, "E: Cannot add the chosen algorithm"); goto ERR_INSTANCE; } // Wait for events. They will be catched by handler_user() if (pt_loop(loop, 0) < 0) { fprintf(stderr, "E: Main loop interrupted"); goto ERR_PT_LOOP; } exit_code = EXIT_SUCCESS; // Leave the program ERR_PT_LOOP: ERR_INSTANCE: // pt_loop_free() automatically removes algorithms instances, // probe_replies and events from the memory. // Options and probe must be manually removed. pt_loop_free(loop); ERR_LOOP_CREATE: ERR_UNKNOWN_ALGORITHM: probe_free(probe); ERR_PROBE_CREATE: ERR_ADDRESS_IP_FROM_STRING: ERR_ADDRESS_GUESS_FAMILY: if (errno) perror(gai_strerror(errno)); ERR_CHECK_OPTIONS: ERR_OPT_PARSE: ERR_INIT_OPTIONS: free(version); exit(exit_code); }
void Flow::lua(lua_State* vm, bool detailed_dump) { char buf[64]; lua_newtable(vm); if(get_cli_host()) { if(detailed_dump) lua_push_str_table_entry(vm, "cli.host", get_cli_host()->get_name(buf, sizeof(buf), false)); lua_push_int_table_entry(vm, "cli.source_id", get_cli_host()->getSourceId()); lua_push_str_table_entry(vm, "cli.ip", get_cli_host()->get_ip()->print(buf, sizeof(buf))); lua_push_bool_table_entry(vm, "cli.systemhost", get_cli_host()->isSystemHost()); } else { lua_push_nil_table_entry(vm, "cli.host"); lua_push_nil_table_entry(vm, "cli.ip"); } lua_push_int_table_entry(vm, "cli.port", get_cli_port()); if(get_srv_host()) { if(detailed_dump) lua_push_str_table_entry(vm, "srv.host", get_srv_host()->get_name(buf, sizeof(buf), false)); lua_push_int_table_entry(vm, "srv.source_id", get_cli_host()->getSourceId()); lua_push_str_table_entry(vm, "srv.ip", get_srv_host()->get_ip()->print(buf, sizeof(buf))); lua_push_bool_table_entry(vm, "srv.systemhost", get_srv_host()->isSystemHost()); } else { lua_push_nil_table_entry(vm, "srv.host"); lua_push_nil_table_entry(vm, "srv.ip"); } lua_push_int_table_entry(vm, "srv.port", get_srv_port()); lua_push_int_table_entry(vm, "vlan", get_vlan_id()); lua_push_str_table_entry(vm, "proto.l4", get_protocol_name()); if(((cli2srv_packets+srv2cli_packets) > NDPI_MIN_NUM_PACKETS) || (ndpi_detected_protocol != NDPI_PROTOCOL_UNKNOWN) || iface->is_ndpi_enabled() || iface->is_sprobe_interface()) { lua_push_str_table_entry(vm, "proto.ndpi", get_detected_protocol_name()); } else lua_push_str_table_entry(vm, "proto.ndpi", (char*)CONST_TOO_EARLY); lua_push_int_table_entry(vm, "bytes", cli2srv_bytes+srv2cli_bytes); lua_push_int_table_entry(vm, "bytes.last", get_current_bytes_cli2srv() + get_current_bytes_srv2cli()); lua_push_int_table_entry(vm, "seen.first", get_first_seen()); lua_push_int_table_entry(vm, "seen.last", get_last_seen()); lua_push_int_table_entry(vm, "duration", get_duration()); lua_push_int_table_entry(vm, "cli2srv.bytes", cli2srv_bytes); lua_push_int_table_entry(vm, "srv2cli.bytes", srv2cli_bytes); if(detailed_dump) { lua_push_int_table_entry(vm, "tcp_flags", getTcpFlags()); lua_push_str_table_entry(vm, "category", categorization.category ? categorization.category : (char*)""); lua_push_str_table_entry(vm, "moreinfo.json", get_json_info()); } if(client_proc) processLua(vm, client_proc, true); if(server_proc) processLua(vm, server_proc, false); //ntop->getTrace()->traceEvent(TRACE_NORMAL, "%.2f", bytes_thpt); lua_push_float_table_entry(vm, "throughput", bytes_thpt); lua_push_int_table_entry(vm, "throughput_trend", bytes_thpt_trend); if(!detailed_dump) { lua_pushinteger(vm, key()); // Index lua_insert(vm, -2); lua_settable(vm, -3); } else { lua_push_int_table_entry(vm, "cli2srv.packets", cli2srv_packets); lua_push_int_table_entry(vm, "srv2cli.packets", srv2cli_packets); } }