int udp_handle_message(ipv4 *ip)
{
if(ip == NULL){
log_err("ip is null.");
return -1;
}
if(ip->protocol != IPV4_PROTOCOL_UDP){
log_err("ip protocol is not equal to udp.");
return -1;
}
udp *udp;
udp = udp_create_from_raw(ip->payload, ip->payload_length);
if(udp == NULL){
log_err("cannot create udp object.");
return -1;
}
log_debug("udp message received: 0x%0x:%u -> 0x%08x:%u (length = %u)",
ip->src, udp->src, ip->dst, udp->dst, udp->payload_length);
if(udp_recv_callback != NULL){
log_debug("calling callback function.");
(*udp_recv_callback)(ip, udp);
}
udp_destroy(udp);
return 0;
}
int main (void)
{
zctx_t *ctx = zctx_new ();
udp_t *udp = udp_new (PING_PORT_NUMBER);
byte buffer [PING_MSG_SIZE];
zmq_pollitem_t pollitems [] = {{ NULL, udp_handle (udp), ZMQ_POLLIN, 0 }};
// Send first ping right away
uint64_t ping_at = zclock_time ();
while (!zctx_interrupted) {
long timeout = (long) (ping_at - zclock_time ());
if (timeout < 0)
timeout = 0;
if (zmq_poll (pollitems, 1, timeout * ZMQ_POLL_MSEC) == -1)
break; // Interrupted
// Someone answered our ping
if (pollitems [0].revents & ZMQ_POLLIN)
udp_recv (udp, buffer, PING_MSG_SIZE);
if (zclock_time () >= ping_at) {
puts ("Pinging peers...");
buffer [0] = '!';
udp_send (udp, buffer, PING_MSG_SIZE);
ping_at = zclock_time () + PING_INTERVAL;
}
}
udp_destroy (&udp);
zctx_destroy (&ctx);
return 0;
}
/**
* Clean up on exit. This should be called before exiting.
* \param show_status set to one to display the mem status
*/
void cleanup(int show_status)
{
LM_INFO("cleanup\n");
/*clean-up*/
/* hack: force-unlock the shared memory lock in case
some process crashed and let it locked; this will
allow an almost gracious shutdown */
if (mem_lock)
#ifdef HP_MALLOC
{
int i;
for (i = 0; i < HP_HASH_SIZE; i++)
shm_unlock(i);
}
#else
shm_unlock();
#endif
handle_ql_shutdown();
destroy_modules();
udp_destroy();
tcp_destroy();
destroy_timer();
destroy_stats_collector();
destroy_script_cb();
pv_free_extra_list();
destroy_argv_list();
destroy_black_lists();
#ifdef PKG_MALLOC
if (show_status) {
LM_GEN1(memdump, "Memory status (pkg):\n");
pkg_status();
}
#endif
cleanup_debug();
if (pt) shm_free(pt);
pt=0;
if (show_status) {
LM_GEN1(memdump, "Memory status (shm):\n");
shm_status();
}
/* zero all shmem alloc vars that we still use */
shm_mem_destroy();
if (pid_file) unlink(pid_file);
if (pgid_file) unlink(pgid_file);
}
int dhcp_transport_init(dhcp_transport_t *dt, service_id_t link_id,
dhcp_recv_cb_t recv_cb, void *arg)
{
udp_t *udp = NULL;
udp_assoc_t *assoc = NULL;
inet_ep2_t epp;
int rc;
log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcp_transport_init()");
inet_ep2_init(&epp);
epp.local.addr.version = ip_v4;
epp.local.port = dhcp_client_port;
epp.local_link = link_id;
rc = udp_create(&udp);
if (rc != EOK) {
rc = EIO;
goto error;
}
rc = udp_assoc_create(udp, &epp, &dhcp_transport_cb, dt, &assoc);
if (rc != EOK) {
rc = EIO;
goto error;
}
dt->udp = udp;
dt->assoc = assoc;
dt->recv_cb = recv_cb;
dt->cb_arg = arg;
return EOK;
error:
udp_assoc_destroy(assoc);
udp_destroy(udp);
return rc;
}
/*
* pjsip_udp_transport_attach()
*
* Attach UDP socket and start transport.
*/
static pj_status_t transport_attach( pjsip_endpoint *endpt,
pjsip_transport_type_e type,
pj_sock_t sock,
const pjsip_host_port *a_name,
unsigned async_cnt,
pjsip_transport **p_transport)
{
pj_pool_t *pool;
struct udp_transport *tp;
const char *format, *ipv6_quoteb, *ipv6_quotee;
unsigned i;
pj_status_t status;
PJ_ASSERT_RETURN(endpt && sock!=PJ_INVALID_SOCKET && a_name && async_cnt>0,
PJ_EINVAL);
/* Object name. */
if (type & PJSIP_TRANSPORT_IPV6) {
format = "udpv6%p";
ipv6_quoteb = "[";
ipv6_quotee = "]";
} else {
format = "udp%p";
ipv6_quoteb = ipv6_quotee = "";
}
/* Create pool. */
pool = pjsip_endpt_create_pool(endpt, format, PJSIP_POOL_LEN_TRANSPORT,
PJSIP_POOL_INC_TRANSPORT);
if (!pool)
return PJ_ENOMEM;
/* Create the UDP transport object. */
tp = PJ_POOL_ZALLOC_T(pool, struct udp_transport);
/* Save pool. */
tp->base.pool = pool;
pj_memcpy(tp->base.obj_name, pool->obj_name, PJ_MAX_OBJ_NAME);
/* Init reference counter. */
status = pj_atomic_create(pool, 0, &tp->base.ref_cnt);
if (status != PJ_SUCCESS)
goto on_error;
/* Init lock. */
status = pj_lock_create_recursive_mutex(pool, pool->obj_name,
&tp->base.lock);
if (status != PJ_SUCCESS)
goto on_error;
/* Set type. */
tp->base.key.type = type;
/* Remote address is left zero (except the family) */
tp->base.key.rem_addr.addr.sa_family = (pj_uint16_t)
((type & PJSIP_TRANSPORT_IPV6) ? pj_AF_INET6() : pj_AF_INET());
/* Type name. */
tp->base.type_name = "UDP";
/* Transport flag */
tp->base.flag = pjsip_transport_get_flag_from_type(type);
/* Length of addressess. */
tp->base.addr_len = sizeof(tp->base.local_addr);
/* Init local address. */
status = pj_sock_getsockname(sock, &tp->base.local_addr,
&tp->base.addr_len);
if (status != PJ_SUCCESS)
goto on_error;
/* Init remote name. */
if (type == PJSIP_TRANSPORT_UDP)
tp->base.remote_name.host = pj_str("0.0.0.0");
else
tp->base.remote_name.host = pj_str("::0");
tp->base.remote_name.port = 0;
/* Init direction */
tp->base.dir = PJSIP_TP_DIR_NONE;
/* Set endpoint. */
tp->base.endpt = endpt;
/* Transport manager and timer will be initialized by tpmgr */
/* Attach socket and assign name. */
udp_set_socket(tp, sock, a_name);
/* Register to ioqueue */
status = register_to_ioqueue(tp);
if (status != PJ_SUCCESS)
goto on_error;
/* Set functions. */
tp->base.send_msg = &udp_send_msg;
tp->base.do_shutdown = &udp_shutdown;
tp->base.destroy = &udp_destroy;
/* This is a permanent transport, so we initialize the ref count
* to one so that transport manager don't destroy this transport
* when there's no user!
*/
pj_atomic_inc(tp->base.ref_cnt);
/* Register to transport manager. */
tp->base.tpmgr = pjsip_endpt_get_tpmgr(endpt);
status = pjsip_transport_register( tp->base.tpmgr, (pjsip_transport*)tp);
if (status != PJ_SUCCESS)
goto on_error;
/* Create rdata and put it in the array. */
tp->rdata_cnt = 0;
tp->rdata = (pjsip_rx_data**)
pj_pool_calloc(tp->base.pool, async_cnt,
sizeof(pjsip_rx_data*));
for (i=0; i<async_cnt; ++i) {
pj_pool_t *rdata_pool = pjsip_endpt_create_pool(endpt, "rtd%p",
PJSIP_POOL_RDATA_LEN,
PJSIP_POOL_RDATA_INC);
if (!rdata_pool) {
pj_atomic_set(tp->base.ref_cnt, 0);
pjsip_transport_destroy(&tp->base);
return PJ_ENOMEM;
}
init_rdata(tp, i, rdata_pool, NULL);
tp->rdata_cnt++;
}
/* Start reading the ioqueue. */
status = start_async_read(tp);
if (status != PJ_SUCCESS) {
pjsip_transport_destroy(&tp->base);
return status;
}
/* Done. */
if (p_transport)
*p_transport = &tp->base;
PJ_LOG(4,(tp->base.obj_name,
"SIP %s started, published address is %s%.*s%s:%d",
pjsip_transport_get_type_desc((pjsip_transport_type_e)tp->base.key.type),
ipv6_quoteb,
(int)tp->base.local_name.host.slen,
tp->base.local_name.host.ptr,
ipv6_quotee,
tp->base.local_name.port));
return PJ_SUCCESS;
on_error:
udp_destroy((pjsip_transport*)tp);
return status;
}
/*
* Create a new listener on the specified port.
*/
PJ_DEF(pj_status_t) pj_turn_listener_create_udp( pj_turn_srv *srv,
int af,
const pj_str_t *bound_addr,
unsigned port,
unsigned concurrency_cnt,
unsigned flags,
pj_turn_listener **p_listener)
{
pj_pool_t *pool;
struct udp_listener *udp;
pj_ioqueue_callback ioqueue_cb;
unsigned i;
pj_status_t status;
/* Create structure */
pool = pj_pool_create(srv->core.pf, "udp%p", 1000, 1000, NULL);
udp = PJ_POOL_ZALLOC_T(pool, struct udp_listener);
udp->base.pool = pool;
udp->base.obj_name = pool->obj_name;
udp->base.server = srv;
udp->base.tp_type = PJ_TURN_TP_UDP;
udp->base.sock = PJ_INVALID_SOCKET;
udp->base.destroy = &udp_destroy;
udp->read_cnt = concurrency_cnt;
udp->base.flags = flags;
udp->tp.obj_name = udp->base.obj_name;
udp->tp.info = udp->base.info;
udp->tp.listener = &udp->base;
udp->tp.sendto = &udp_sendto;
udp->tp.add_ref = &udp_add_ref;
udp->tp.dec_ref = &udp_dec_ref;
/* Create socket */
status = pj_sock_socket(af, pj_SOCK_DGRAM(), 0, &udp->base.sock);
if (status != PJ_SUCCESS)
goto on_error;
/* Init bind address */
status = pj_sockaddr_init(af, &udp->base.addr, bound_addr,
(pj_uint16_t)port);
if (status != PJ_SUCCESS)
goto on_error;
/* Create info */
pj_ansi_strcpy(udp->base.info, "UDP:");
pj_sockaddr_print(&udp->base.addr, udp->base.info+4,
sizeof(udp->base.info)-4, 3);
/* Bind socket */
status = pj_sock_bind(udp->base.sock, &udp->base.addr,
pj_sockaddr_get_len(&udp->base.addr));
if (status != PJ_SUCCESS)
goto on_error;
/* Register to ioqueue */
pj_bzero(&ioqueue_cb, sizeof(ioqueue_cb));
ioqueue_cb.on_read_complete = on_read_complete;
status = pj_ioqueue_register_sock(pool, srv->core.ioqueue, udp->base.sock,
udp, &ioqueue_cb, &udp->key);
/* Create op keys */
udp->read_op = (struct read_op**)pj_pool_calloc(pool, concurrency_cnt,
sizeof(struct read_op*));
/* Create each read_op and kick off read operation */
for (i=0; i<concurrency_cnt; ++i) {
pj_pool_t *rpool = pj_pool_create(srv->core.pf, "rop%p",
1000, 1000, NULL);
udp->read_op[i] = PJ_POOL_ZALLOC_T(pool, struct read_op);
udp->read_op[i]->pkt.pool = rpool;
on_read_complete(udp->key, &udp->read_op[i]->op_key, 0);
}
/* Done */
PJ_LOG(4,(udp->base.obj_name, "Listener %s created", udp->base.info));
*p_listener = &udp->base;
return PJ_SUCCESS;
on_error:
udp_destroy(&udp->base);
return status;
}
void dhcp_transport_fini(dhcp_transport_t *dt)
{
udp_assoc_destroy(dt->assoc);
udp_destroy(dt->udp);
}
static void* run_discovery(void* data) {
discovery_opts_t* opts = (discovery_opts_t*)data;
char ip[INET_ADDRSTRLEN] = { '\0' };
const char* interface = opts->interface;
udp_t *udp = udp_new(PING_PORT_NUMBER, interface);
assert(udp);
struct pollfd ufds[1];
int ret;
time_t t0, t1;
beacon_t beacon;
uuid_t uuid;
beacon_t recv;
peers_t* peers = peers_new();
struct in_addr addr;
find_my_ip(&addr, NULL);
uuid_generate(uuid);
beacon_fill(&beacon, (uint8_t*)BEACON_PROTOCOL, BEACON_VERSION, uuid, addr, htons(47473));
ufds[0].fd = udp_handle(udp);
ufds[0].events = POLLIN;
t0 = time(NULL);
t1 = time(NULL);
struct sockaddr_in sockaddr;
socklen_t si_len = sizeof(struct sockaddr_in);
while (1) {
t1 = time(NULL);
if ((long)(t1 - t0) >= PING_INTERVAL) {
ret = udp_send(udp, (uint8_t*)(&beacon), sizeof(beacon_t));
assert(ret == sizeof(beacon_t));
t0 = time(NULL);
}
ret = poll(ufds, 1, 200);
if (ret == -1) {
printf("Error: poll returned -1\n");
break;
} else if (ret == 0) {
continue;
}
if (ufds[0].revents & POLLIN) {
ret = udp_recv(udp, (uint8_t*)&recv, sizeof(beacon_t), &sockaddr, si_len);
if (ret == sizeof(beacon_t) && beacon_check(&recv, (uint8_t*)BEACON_PROTOCOL, BEACON_VERSION)) {
if (uuid_compare(uuid, recv.uuid) != 0) {
peer_t* peer = peers_exist(peers, recv.uuid);
if (!peer) {
inet_ntop(sockaddr.sin_family, &sockaddr.sin_addr, ip, INET_ADDRSTRLEN);
peer = peer_new(recv.uuid, ip, recv.port);
peers_add(peers, peer);
opts->add_peer_cb((void*)peer);
}
peer_is_alive(peer);
}
}
}
peers_check(peers);
}
peers_destroy(&peers);
udp_destroy(&udp);
return NULL;
}
