HybridConnection*
hybrid_proxy_connect(const gchar *hostname, gint port, connect_callback func,
gpointer user_data)
{
gint sk;
struct sockaddr addr;
HybridConnection *conn;
g_return_val_if_fail(port != 0, NULL);
g_return_val_if_fail(hostname != NULL, NULL);
hybrid_debug_info("connect", "connecting to %s:%d", hostname, port);
conn = g_new0(HybridConnection, 1);
if ((sk = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
hybrid_debug_error("connect", "create socket: %s", strerror(errno));
hybrid_connection_destroy(conn);
return NULL;
}
if (nonblock(sk) != HYBRID_OK) {
hybrid_connection_destroy(conn);
return NULL;
}
if (addr_init(hostname, port, &addr) != HYBRID_OK) {
hybrid_connection_destroy(conn);
return NULL;
}
if (connect(sk, &addr, sizeof(addr)) != 0) {
if (errno != EINPROGRESS) {
hybrid_debug_error("connect", "connect to \'%s:%d\':%s", hostname,
port, strerror(errno));
hybrid_connection_destroy(conn);
return NULL;
}
hybrid_debug_info("connect", "connect in progress");
hybrid_event_add(sk, HYBRID_EVENT_WRITE, func, user_data);
} else {
/* connection establish imediately */
func(sk, user_data);
}
conn->sk = sk;
conn->host = g_strdup(hostname);
conn->port = port;
return conn;
}
static __init int hi6xxx_pm_drvinit(void)
{
if(dt_insmod_pm_asleep())return 0;
addr_init();
suspend_set_ops(&hi6xxx_pm_ops);
return 0;
}
dnscache_t *
dnscache_create(char *server_addr,
uint16_t port,
uint32_t thread_num)
{
dnscache_t *dnscache = malloc(sizeof(dnscache_t));
if (!dnscache)
return NULL;
dnscache->thread_count_ = thread_num;
dnscache->base_event_ = event_base_new();
dnscache_init_sig(dnscache);
dnscache->tp_ = thread_pool_create(thread_num);
ASSERT(dnscache->tp_, "thread pool create failed");
addr_t addr;
addr_init(&addr, server_addr, port);
dnscache->listen_socket = (socket_t *)malloc(sizeof(socket_t));
int socket_type = addr_get_type(&addr) == ADDR_IPV4 ? AF_INET : AF_INET6;
socket_open(dnscache->listen_socket, socket_type, SOCK_DGRAM, 0);
socket_set_unblock(dnscache->listen_socket, true);
socket_set_addr_reusable(dnscache->listen_socket);
int ret = socket_bind(dnscache->listen_socket, &addr);
ASSERT(ret == 0, "udp server bind failed\n");
int threads_len = thread_num * sizeof(thread_local_param_t *);
dnscache->thread_params_ = (thread_local_param_t **)malloc(threads_len);
ASSERT(dnscache->thread_params_ != NULL, "udp server bind failed\n");
int i = 0;
for (; i < thread_num; ++i)
{
dnscache->thread_params_[i] =
(thread_local_param_t *)malloc(sizeof(thread_local_param_t));
thread_local_param_t *tlp = dnscache->thread_params_[i];
tlp->thread_id_ = i;
tlp->base_ = event_base_new();
tlp->dns_server_ =
dns_server_create(tlp->base_, UDP_SERVER, dnscache->listen_socket, queue_size);
thread_pool_set_thread_data(dnscache->tp_, i, tlp);
}
return dnscache;
}
static void
reply_to_end_user(dns_client_error_code_t error_code,
const char *dns_raw_data,
uint16_t raw_data_len,
const addr_t *name_server_addr,
void *arg)
{
query_session_t *session = (query_session_t *)arg;
if (error_code != QUERY_NO_ERROR)
{
log_warning(QUERY_LOG, "has error during query backend named server\n");
memorypool_free_node(session->zipper_->query_session_pool_, session);
return;
}
socket_write_to(&session->client_socket_,
(uint8_t *)dns_raw_data,
raw_data_len,
&session->client_addr_);
/* -----------------test for dns cache ---------------*/
socket_t client_socket;
socket_open(&client_socket, AF_INET, SOCK_DGRAM, 0);
socket_set_unblock(&client_socket, true);
addr_t server_addr;
addr_init(&server_addr, dnscache_ip, dnscache_port);
if (socket_connect(&client_socket, &server_addr) == 0)
{
socket_write(&client_socket,
(uint8_t *)dns_raw_data,
raw_data_len);
}
socket_close(&client_socket);
/*---------------------------------------------------*/
memorypool_free_node(session->zipper_->query_session_pool_, session);
}
int main(int argc, char **argv)
{
int sd;
socklen_t len;
struct sockaddr_in addr;
// Inizializzazione dell'indirizzo
addr_init (&addr,SERV_PORT,INADDR_ANY);
// Creazione del socket
if ((sd=socket(AF_INET,SOCK_DGRAM,0))<0)
{
printf ("Impossibile creare un socket UDP\n");
exit(3);
}
// Lego il socket appena creato all'indirizzo del server
if (bind(sd, (struct sockaddr*) &addr, sizeof(addr))<0) {
printf ("Impossibile aprire una connessione sulla porta %d\n"
"La porta potrebbe essere già in uso da un'altra applicazione\n",SERV_PORT);
exit(2);
}
while(1)
{
MSG *m ;
m = (MSG*) malloc(sizeof(MSG));
len = sizeof(addr);
if (recvfrom(sd, m,sizeof(MSG), 0 , (struct sockaddr *)&addr, &len ) < 0 )
{
perror("errore in recvfrom");
exit(-1);
}
if( m->type == _M_TIME)
{
printf ("MESSAGGIO DEL CLIENT [ %s:%d, time = %d] \n" , inet_ntoa(addr.sin_addr), ntohs(addr.sin_port) , m->time);
}
sleep(m->time);
m->type = _M_ACK;
m->time = -1 ;
if (sendto(sd, m, sizeof(MSG), 0, (struct sockaddr *) &addr, sizeof(addr) ) < 0)
{
perror("errore in sendto");
exit(-1);
}
else
{
printf ("INVIO ACK AL CLIENT\n\n\n\n");
}
delete_MSG(m);
}
close(sd);
return(0);
}
/**
* Initializes an IPv4 socket address for a NOAAPORT channel from a
* specification of the address of the NOAAPORT multicast group.
*
* @param[in] nportSockAddr The IPv4 socket address.
* @param[in] nportSpec The NOAAPORT IPv4 multicast address.
* @retval 0 Success. `*nportSockAddr` is set.
* @retval 1 Usage error. `log_add()` called.
*/
static int
initNportSockAddr(
struct sockaddr_in* const restrict nportSockAddr,
const char* const restrict nportSpec)
{
in_addr_t addr;
int status = addr_init(&addr, nportSpec);
if (0 == status) {
if (!mcastAddr_isValid(addr)) {
log_add("Invalid multicast address: \"%s\"", nportSpec);
status = 1;
}
else {
unsigned channel = ntohl(addr) & 0xFF;
if (channel == 0 || channel > sizeof(s_port)/sizeof(s_port[0])) {
log_add("Invalid NBS channel: %u", channel);
status = 1;
}
else {
sockAddr_init(nportSockAddr, addr, s_port[channel-1]);
}
