/*****************************************************************************
** Function name: void user_init (void)
**
** Descriptions: armazenamos socket's livre para o servidor (tcp), clientes (tcp) e conexão udp
**
** parameters: None
**
** Returned value: None
**
****************************************************************************/
void user_init (void)
{
#if USE_TCP_CLIENT /*Comunicação TCP CLIENT será usada?*/
char i=0;
/*Armazena socket's onde estes serão servidores e se comunicarão com clientes(app's)*/
for(i=0;i<MAX_NUM_SOC;i++)
{
tcp_client_soc[i] = tcp_get_socket(TCP_TYPE_SERVER, 0, 120, tcp_callback_server);
tcp_listen(tcp_client_soc[i],atoi(cfg.tcp.port_serv_loc)); /*Cada socket ouvirá somente a porta 'LOCAL_PORT_SERVER' */
}
#endif /*Fim das declarações para a comunicação via TCP CLIENT*/
#if USE_TCP_SERVER /*Comunicação TCP SERVER será usada?*/
/*Armazena socket onde este será cliente e se comunicará com um servidor*/
tcp_server_soc = tcp_get_socket(TCP_TYPE_CLIENT, 0, 60000, tcp_callback_client);
#endif /*Fim das declarações para a comunicação via TCP SERVER*/
#if USE_UDP /*Comunicação UDP será usada?*/
/*Inicia socket udp*/
udp_soc = udp_get_socket (0, UDP_OPT_SEND_CS | UDP_OPT_CHK_CS,udp_callback);
udp_open(udp_soc, atoi(cfg.tcp.port_udp));
#endif /*Fim das declarações para a comunicação via UDP*/
/*Reseta flags tcp*/
dhcp_tout = DHCP_TOUT;
tcp_state.all = 0;
strcpy((char * )lhost_name,cfg.tcp.host_name);
}
static foreign_t
pl_bind(term_t Socket, term_t Address)
{ struct sockaddr_in sockaddr;
int socket;
memset(&sockaddr, 0, sizeof(sockaddr));
if ( !tcp_get_socket(Socket, &socket) ||
!nbio_get_sockaddr(Address, &sockaddr) )
return FALSE;
if ( nbio_bind(socket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) < 0 )
return FALSE;
if ( PL_is_variable(Address) )
{ SOCKET fd = nbio_fd(socket);
struct sockaddr_in addr;
#ifdef __WINDOWS__
int len = sizeof(addr);
#else
socklen_t len = sizeof(addr);
#endif
if ( getsockname(fd, (struct sockaddr *) &addr, &len) )
return nbio_error(errno, TCP_ERRNO);
return PL_unify_integer(Address, ntohs(addr.sin_port));
}
return TRUE;
}
static foreign_t
udp_send(term_t Socket, term_t Data, term_t To, term_t Options)
{ struct sockaddr_in sockaddr;
#ifdef __WINDOWS__
int alen = sizeof(sockaddr);
#else
int alen = sizeof(sockaddr);
#endif
int socket;
int flags = 0L;
char *data;
size_t dlen;
ssize_t n;
if ( !PL_get_nchars(Data, &dlen, &data, CVT_ALL|CVT_EXCEPTION) )
return FALSE;
if ( !tcp_get_socket(Socket, &socket) ||
!nbio_get_sockaddr(To, &sockaddr) )
return FALSE;
if ( (n=nbio_sendto(socket, data,
(int)dlen,
flags,
(struct sockaddr*)&sockaddr, alen)) == -1 )
return nbio_error(errno, TCP_ERRNO);
return TRUE;
}
static foreign_t
pl_open_socket(term_t Socket, term_t Read, term_t Write)
{ IOSTREAM *in, *out;
int socket;
void *handle;
if ( !tcp_get_socket(Socket, &socket) )
return FALSE;
handle = (void *)(intptr_t)socket;
in = Snew(handle, SIO_INPUT|SIO_RECORDPOS|SIO_FBUF, &readFunctions);
in->encoding = ENC_OCTET;
if ( !PL_open_stream(Read, in) )
return FALSE;
nbio_setopt(socket, TCP_INSTREAM, in);
if ( !(nbio_get_flags(socket) & PLSOCK_LISTEN) )
{ out = Snew(handle, SIO_OUTPUT|SIO_RECORDPOS|SIO_FBUF, &writeFunctions);
out->encoding = ENC_OCTET;
if ( !PL_open_stream(Write, out) )
return FALSE;
nbio_setopt(socket, TCP_OUTSTREAM, out);
}
return TRUE;
}
int access_init()
{
g_send_package_socket = tcp_get_socket (TCP_TYPE_CLIENT, 0, 10, tcp_callback);
set_main_page();
show_main_page();
return 0;
}
static foreign_t
pl_setopt(term_t Socket, term_t opt)
{ int socket;
atom_t a;
int arity;
if ( !tcp_get_socket(Socket, &socket) )
return FALSE;
if ( PL_get_name_arity(opt, &a, &arity) )
{ if ( a == ATOM_reuseaddr && arity == 0 )
{ if ( nbio_setopt(socket, TCP_REUSEADDR, TRUE) == 0 )
return TRUE;
return FALSE;
} else if ( a == ATOM_nodelay && arity <= 1 )
{ int enable, rc;
if ( arity == 0 )
{ enable = TRUE;
} else /*if ( arity == 1 )*/
{ term_t a = PL_new_term_ref();
_PL_get_arg(1, opt, a);
if ( !PL_get_bool(a, &enable) )
return pl_error(NULL, 0, NULL, ERR_DOMAIN, a, "boolean");
}
if ( (rc=nbio_setopt(socket, TCP_NO_DELAY, enable) == 0) )
return TRUE;
if ( rc == -2 )
goto not_implemented;
return FALSE;
} else if ( a == ATOM_broadcast && arity == 0 )
{ if ( nbio_setopt(socket, UDP_BROADCAST, TRUE) == 0 )
return TRUE;
return FALSE;
} else if ( a == ATOM_dispatch && arity == 1 )
{ int val;
term_t a1 = PL_new_term_ref();
if ( PL_get_arg(1, opt, a1) && PL_get_bool(a1, &val) )
{ if ( nbio_setopt(socket, TCP_DISPATCH, val) == 0 )
return TRUE;
return FALSE;
}
} else if ( a == ATOM_nonblock && arity == 0 )
{ if ( nbio_setopt(socket, TCP_NONBLOCK) == 0 )
return TRUE;
return FALSE;
}
}
not_implemented:
return pl_error(NULL, 0, NULL, ERR_DOMAIN, opt, "socket_option");
}
static foreign_t
pl_close_socket(term_t socket)
{ int sock;
if ( !tcp_get_socket(socket, &sock) )
return FALSE;
if ( nbio_closesocket(sock) < 0 )
return nbio_error(errno, TCP_ERRNO);;
return TRUE;
}
static foreign_t
pl_connect(term_t Socket, term_t Address)
{ int sock;
struct sockaddr_in sockaddr;
if ( !tcp_get_socket(Socket, &sock) ||
!nbio_get_sockaddr(Address, &sockaddr) )
return FALSE;
if ( nbio_connect(sock, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == 0 )
return TRUE;
return FALSE;
}
static foreign_t
pl_listen(term_t Sock, term_t BackLog)
{ int socket;
int backlog;
if ( !tcp_get_socket(Sock, &socket) )
return FALSE;
if ( !PL_get_integer(BackLog, &backlog) )
return pl_error(NULL, 0, NULL, ERR_ARGTYPE, -1, BackLog, "integer");
if ( nbio_listen(socket, backlog) < 0 )
return FALSE;
return TRUE;
}
static foreign_t
pl_accept(term_t Master, term_t Slave, term_t Peer)
{ int master, slave;
struct sockaddr_in addr;
socklen_t addrlen = sizeof(addr);
if ( !tcp_get_socket(Master, &master) )
return FALSE;
if ( (slave = nbio_accept(master, (struct sockaddr*)&addr, &addrlen)) < 0 )
return FALSE;
/* TBD: close on failure */
if ( nbio_unify_ip4(Peer, ntohl(addr.sin_addr.s_addr)) &&
tcp_unify_socket(Slave, slave) )
return TRUE;
return FALSE;
}
static foreign_t
udp_receive(term_t Socket, term_t Data, term_t From, term_t options)
{ struct sockaddr_in sockaddr;
#ifdef __WINDOWS__
int alen = sizeof(sockaddr);
#else
socklen_t alen = sizeof(sockaddr);
#endif
int socket;
int flags = 0;
char buf[UDP_MAXDATA];
ssize_t n;
int as = PL_STRING;
if ( !PL_get_nil(options) )
{ term_t tail = PL_copy_term_ref(options);
term_t head = PL_new_term_ref();
term_t arg = PL_new_term_ref();
while(PL_get_list(tail, head, tail))
{ atom_t name;
int arity;
if ( PL_get_name_arity(head, &name, &arity) && arity == 1 )
{ _PL_get_arg(1, head, arg);
if ( name == ATOM_as )
{ atom_t a;
if ( !PL_get_atom(arg, &a) )
return pl_error(NULL, 0, NULL, ERR_TYPE, head, "atom");
if ( a == ATOM_atom )
as = PL_ATOM;
else if ( a == ATOM_codes )
as = PL_CODE_LIST;
else if ( a == ATOM_string )
as = PL_STRING;
else
return pl_error(NULL, 0, NULL, ERR_DOMAIN, arg, "as_option");
}
} else
return pl_error(NULL, 0, NULL, ERR_TYPE, head, "option");
}
if ( !PL_get_nil(tail) )
return pl_error(NULL, 0, NULL, ERR_TYPE, tail, "list");
}
if ( !tcp_get_socket(Socket, &socket) ||
!nbio_get_sockaddr(From, &sockaddr) )
return FALSE;
if ( (n=nbio_recvfrom(socket, buf, sizeof(buf), flags,
(struct sockaddr*)&sockaddr, &alen)) == -1 )
return nbio_error(errno, TCP_ERRNO);
if ( !PL_unify_chars(Data, as, n, buf) )
return FALSE;
return unify_address(From, &sockaddr);
}
static foreign_t
udp_receive(term_t Socket, term_t Data, term_t From, term_t options)
{ struct sockaddr_in sockaddr;
#ifdef __WINDOWS__
int alen = sizeof(sockaddr);
#else
socklen_t alen = sizeof(sockaddr);
#endif
int socket;
int flags = 0;
char smallbuf[UDP_DEFAULT_BUFSIZE];
char *buf = smallbuf;
int bufsize = UDP_DEFAULT_BUFSIZE;
term_t varport = 0;
ssize_t n;
int as = PL_STRING;
int rc;
if ( !PL_get_nil(options) )
{ term_t tail = PL_copy_term_ref(options);
term_t head = PL_new_term_ref();
term_t arg = PL_new_term_ref();
while(PL_get_list(tail, head, tail))
{ atom_t name;
size_t arity;
if ( PL_get_name_arity(head, &name, &arity) && arity == 1 )
{ _PL_get_arg(1, head, arg);
if ( name == ATOM_as )
{ atom_t a;
if ( !PL_get_atom(arg, &a) )
return pl_error(NULL, 0, NULL, ERR_TYPE, head, "atom");
if ( a == ATOM_atom )
as = PL_ATOM;
else if ( a == ATOM_codes )
as = PL_CODE_LIST;
else if ( a == ATOM_string )
as = PL_STRING;
else
return pl_error(NULL, 0, NULL, ERR_DOMAIN, arg, "as_option");
} else if ( name == ATOM_max_message_size )
{ if ( !PL_get_integer(arg, &bufsize) )
return pl_error(NULL, 0, NULL, ERR_TYPE, arg, "integer");
if ( bufsize < 0 || bufsize > UDP_MAXDATA )
return pl_error(NULL, 0, NULL, ERR_DOMAIN, arg, "0 - 65535");
}
} else
return pl_error(NULL, 0, NULL, ERR_TYPE, head, "option");
}
if ( !PL_get_nil(tail) )
return pl_error(NULL, 0, NULL, ERR_TYPE, tail, "list");
}
if ( !tcp_get_socket(Socket, &socket) ||
!nbio_get_sockaddr(From, &sockaddr, &varport) )
return FALSE;
if ( bufsize > UDP_DEFAULT_BUFSIZE )
{ if ( !(buf = malloc(bufsize)) )
return pl_error(NULL, 0, NULL, ERR_RESOURCE, "memory");
}
if ( (n=nbio_recvfrom(socket, buf, bufsize, flags,
(struct sockaddr*)&sockaddr, &alen)) == -1 )
{ rc = nbio_error(errno, TCP_ERRNO);
goto out;
}
rc = ( PL_unify_chars(Data, as, n, buf) &&
unify_address(From, &sockaddr)
);
out:
if ( buf != smallbuf )
free(buf);
return rc;
}
