int handle_trans_message(void *args)
{
struct packet *pkt = (struct packet*)args;
DEBUG(INFO, "%s %d %d %u handle",pkt->ip, pkt->sockfd, pkt->ops_type, pkt->len);
pkt->data += sizeof(struct common_header);
pkt->len -= sizeof(struct common_header);
char *buff = pkt->data;
int len = pkt->len;
int type = pkt->ops_type;
if( buff == NULL || len == 0)
{
DEBUG( ERROR, "Trans message Empty");
return ENORMERR;
}
char *pms_addr;
int pms_port = 0;
int iret = 0;
pms_addr = get_server_address();
pms_port = get_server_port();
if( pms_addr == NULL )
{
DEBUG( ERROR, "\n[%s][%d]pms_addr error\n", __FILE__, __LINE__ );
return ENORMERR;
}
DEBUG( INFO, "\n[%s][%d]pms_addr=[%s] pms_port=[%d]\n", __FILE__, __LINE__, pms_addr, pms_port );
iret = send_message_to_pms( pms_addr, pms_port, type, buff, len );
if( iret != SUCCESS )
{
DEBUG( ERROR, "\n[%s][%d]send message to pms error\n", __FILE__, __LINE__ );
}
return SUCCESS;
}
//LSDB_INFO
int handle_lsdb_snapshoot_dbm_to_pms(void *args)
{
struct pkt * info = (struct pkt*)args;
local_module_header *pkt = (local_module_header*)(info->data);
char *buff = (char*)pkt->pkt;
int len = pkt->pkt_len - sizeof(local_module_header);
send_message_to_pms(get_server_address(), get_server_port(), OPS_PMA_LINKSTATE, buff, len);
}
int handle_bgp_path_info_ic_to_pms(void *args)
{
struct pkt* info = (struct pkt*)args;
local_module_header* pkt = (local_module_header*)(info->data);
char* buff = (char*)pkt->pkt;
int len = pkt->pkt_len - sizeof(local_module_header);
return send_message_to_pms(get_server_address(), get_server_port(),
OPS_PMA_ROUTING_TABLE, buff, len);
}
int handle_bgp_interface_ic_to_pms(void *args)
{
struct pkt* info = (struct pkt*)args;
local_module_header *pkt = (local_module_header*)(info->data);
char* buff = (char*)pkt->pkt;
int len = pkt->pkt_len - sizeof(local_module_header);
return send_message_to_pms(get_server_address(), get_server_port(),
OPS_PMA_BGP_INTERFACE_INFO, buff, len);
}
int handle_trans_packet_to_pms(void *args)
{
struct packet *pkt = (struct packet*)args;
DEBUG(INFO, "%s %d %d %u handle",pkt->ip, pkt->sockfd, pkt->ops_type, pkt->len);
memcpy(pkt->ip , get_server_address(), sizeof(pkt->ip)-1);
pkt->port = get_server_port();
int ret = send_message_to_pms( pkt->ip , pkt->port , pkt->ops_type, pkt->data, pkt->len);
return ret;
}
int heart_beat_send()
{
DEBUG(INFO,"Heart Beat Sended");
int ret = send_message_to_pms( get_server_address(),
get_server_port(), OPS_PMA_HEARTBEAT,
NULL, 0);
pthread_detach(pthread_self());
return ret;
}
//UP_INTERFACE_INFO
int handle_tc_message_to_pms(void *args)
{
struct pkt* info = (struct pkt*)args;
local_module_header *pkt = (local_module_header*)(info->data);
char *buff = (char*)pkt->pkt;
int info_type = pkt->pkt_type;
int len = pkt->pkt_len - sizeof(local_module_header);
return send_message_to_pms(get_server_address(), get_server_port(),
TC_TO_PMA_INTERFACE_INFO, buff, len);
}
int agent_register(u32 agent_id, const char *seq)
{
//pack the login xml
xmlDocPtr doc = create_xml_doc();
xmlNodePtr devnode;
xmlNodePtr childnode;
xmlNodePtr rootnode = create_xml_root_node(doc,"AGENT_REGISTER");
struct timeval now;
gettimeofday(&now, NULL);
char * time = PRINTTIME(now);
add_xml_child(rootnode, "timestamp",time); free(time);
devnode = add_xml_child(rootnode, "device", NULL);
char aid[24];
sprintf(aid,"%d", get_pma_id());
add_xml_child_prop(devnode, "id",aid);
char dev_type[10];
if( get_protocol_type() == OSPF_ROUTER )
sprintf(dev_type, "ospf");
else if( get_protocol_type() == BGP_ROUTER )
sprintf(dev_type, "bgp");
else {}
add_xml_child(devnode, "type", dev_type);
char* xmlbuff;
int len = 0;
xmlDocDumpFormatMemoryEnc( doc, &xmlbuff, &len, "UTF-8", 0);
char* buff = (char*)malloc(len+1);
memcpy(buff, xmlbuff, len);
buff[len] = 0;
xmlFree(xmlbuff);
xmlFreeDoc(doc);
struct req_args *login_args =
(struct req_args *)malloc(sizeof(struct req_args)+len);
memset(login_args->ip, 0, sizeof(login_args->ip));
char *ip = get_server_address();
memcpy(login_args->ip, ip, strlen(ip));
login_args->port = get_server_port();
login_args->ops_type = OPS_PMA_LOGIN;
login_args->len = len;
memcpy(login_args->data, buff, len);
free(buff);
if (login(login_args) == ((void *)-1)) {
free(login_args);
return -1;
}
free(login_args);
agent_login_status = AGENT_LOGIN;
return SUCCESS;
}
void send_udp_packet(
char *ip,
int port,
char message[MAX_PAYLOAD_LENGTH],
int message_length,
int socket
) {
struct sockaddr_in destination_server = get_server_address(ip, port);
sendto(socket, message, message_length, 0, (struct sockaddr*)&destination_server, sizeof(destination_server));
}
int create_socket(char *ip, unsigned int port) {
int socket_ = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
struct sockaddr_in udp_load_balancer_address = get_server_address(ip, port);
bind(
socket_,
(struct sockaddr*)&udp_load_balancer_address,
sizeof(udp_load_balancer_address)
);
return socket_;
}
/**************************************************************************
Connect to a freeciv-server instance -- or at least try to. On success,
return 0; on failure, put an error message in ERRBUF and return -1.
**************************************************************************/
int connect_to_server(const char *username, const char *hostname, int port,
char *errbuf, int errbufsize)
{
if (0 != get_server_address(hostname, port, errbuf, errbufsize)) {
return -1;
}
if (0 != try_to_connect(username, errbuf, errbufsize)) {
return -1;
}
return 0;
}
//UP_ROUTE_INFO
int handle_route_table_ic_to_pms(void *args)
{
struct pkt* info = (struct pkt*)args;
local_module_header *pkt = (local_module_header*)(info->data);
int pkt_len = pkt->pkt_len - sizeof(local_module_header);
char * data = (char*)malloc(pkt_len+1);
memcpy(data, pkt->pkt, pkt_len);
data[pkt_len] = 0;
char *buff = save_router_table_to_xml(data);
int len = strlen(buff);
free(data);
int ret = send_message_to_pms(get_server_address(), get_server_port(),
OPS_PMA_ROUTING_TABLE, buff, len);
free( buff );
return ret;
}
/**************************************************************************
Start trying to autoconnect to civserver. Calls
get_server_address(), then arranges for try_to_autoconnect(), which
calls try_to_connect(), to be called roughly every
AUTOCONNECT_INTERVAL milliseconds, until success, fatal error or
user intervention.
**************************************************************************/
void start_autoconnecting_to_server(void)
{
char buf[512];
output_window_printf(FTC_CLIENT_INFO, NULL,
_("Auto-connecting to server \"%s\" at port %d "
"as \"%s\" every %f second(s) for %d times"),
server_host, server_port, user_name,
0.001 * AUTOCONNECT_INTERVAL,
MAX_AUTOCONNECT_ATTEMPTS);
if (get_server_address(server_host, server_port, buf, sizeof(buf)) < 0) {
freelog(LOG_FATAL,
_("Error contacting server \"%s\" at port %d "
"as \"%s\":\n %s\n"),
server_host, server_port, user_name, buf);
exit(EXIT_FAILURE);
}
autoconnecting = TRUE;
}
int agent_init_request(char* routerid)
{
//pack the login xml
xmlDocPtr doc = create_xml_doc();
xmlNodePtr devnode;
xmlNodePtr childnode;
xmlNodePtr rootnode = create_xml_root_node(doc,"AGENT_INIT");
struct timeval now;
gettimeofday(&now, NULL);
char * time = PRINTTIME(now);
add_xml_child(rootnode, "timestamp",time); free(time);
devnode = add_xml_child(rootnode, "device", NULL);
char aid[24];
sprintf(aid,"%d", get_pma_id());
add_xml_child_prop(devnode, "id",aid);
char dev_type[10];
if( get_protocol_type() == OSPF_ROUTER )
{
sprintf(dev_type, "ospf");
add_xml_child(devnode, "type", dev_type);
}
else if( get_protocol_type() == BGP_ROUTER )
{
sprintf(dev_type, "bgp");
add_xml_child(devnode, "type", dev_type);
}
else {}
char asid[24];
inet_ntop(AF_INET, &pma_conf.as_num , asid, 24);
add_xml_child(devnode, "as_id", asid);
add_xml_child(devnode, "router_id", routerid);
char ctlip[24];
inet_ntop(AF_INET, &pma_conf.ic_config.hello_ip, ctlip,24);
add_xml_child(devnode, "agent_control_ip", ctlip);
char* xmlbuff;
int len = 0;
xmlDocDumpFormatMemoryEnc( doc, &xmlbuff, &len, "UTF-8", 0);
char* buff = (char*)malloc(len+1);
memcpy(buff, xmlbuff, len);
buff[len] = 0;
xmlFree(xmlbuff);
xmlFreeDoc(doc);
len = strlen(buff);
char rid[24];
strcpy(rid,routerid);
struct req_args *req_arg =
(struct req_args *)malloc(sizeof(struct req_args));
memset(req_arg->ip, 0, sizeof(req_arg->ip));
char *ip = get_server_address();
memcpy(req_arg->ip, ip, strlen(ip));
req_arg->port = get_server_port();
req_arg->ops_type = OPS_PMA_INIT_REQUEST;
req_arg->len = 0;
int ret = send_message_to_pms(req_arg->ip,
req_arg->port,
req_arg->ops_type,
buff,
len);
free(req_arg);
free(buff);
return ret;
}
apr_status_t test_server_create(test_baton_t **tb_p,
test_server_action_t *action_list,
apr_size_t action_count,
apr_int32_t options,
const char *host_url,
apr_sockaddr_t *address,
serf_connection_setup_t conn_setup,
apr_pool_t *pool)
{
apr_status_t status;
test_baton_t *tb;
tb = apr_palloc(pool, sizeof(*tb));
*tb_p = tb;
if (address) {
tb->serv_addr = address;
}
else {
status = get_server_address(&tb->serv_addr, pool);
if (status != APR_SUCCESS)
return status;
}
tb->pool = pool;
tb->options = options;
tb->context = serf_context_create(pool);
tb->bkt_alloc = serf_bucket_allocator_create(pool, NULL, NULL);
if (host_url) {
apr_uri_t url;
status = apr_uri_parse(pool, host_url, &url);
if (status != APR_SUCCESS)
return status;
status = serf_connection_create2(&tb->connection, tb->context,
url,
conn_setup ? conn_setup :
default_conn_setup,
tb,
default_closed_connection,
tb,
pool);
if (status != APR_SUCCESS)
return status;
} else {
tb->connection = serf_connection_create(tb->context,
tb->serv_addr,
conn_setup ? conn_setup :
default_conn_setup,
tb,
default_closed_connection,
tb,
pool);
}
tb->action_list = action_list;
tb->action_count = action_count;
/* Prepare a server. */
status = prepare_server(tb, pool);
if (status != APR_SUCCESS)
return status;
return APR_SUCCESS;
}