/*
* A common server create routine
*/
static SVCXPRT *
svc_com_create(int fd, u_int sendsize, u_int recvsize, char *netid)
{
struct netconfig *nconf;
SVCXPRT *svc;
int madefd = FALSE;
int port;
struct sockaddr_in sin;
if ((nconf = __rpc_getconfip(netid)) == NULL) {
(void) syslog(LOG_ERR, "Could not get %s transport", netid);
return (NULL);
}
if (fd == RPC_ANYSOCK) {
fd = __rpc_nconf2fd(nconf);
if (fd == -1) {
(void) freenetconfigent(nconf);
(void) syslog(LOG_ERR,
"svc%s_create: could not open connection", netid);
return (NULL);
}
madefd = TRUE;
}
memset(&sin, 0, sizeof sin);
sin.sin_family = AF_INET;
bindresvport(fd, &sin);
_listen(fd, SOMAXCONN);
svc = svc_tli_create(fd, nconf, NULL, sendsize, recvsize);
(void) freenetconfigent(nconf);
if (svc == NULL) {
if (madefd)
(void)_close(fd);
return (NULL);
}
port = (((struct sockaddr_in *)svc->xp_ltaddr.buf)->sin_port);
svc->xp_port = ntohs(port);
return (svc);
}
int NetCore::init(u16 port)
{
_port = port;
if (_initEpoll() < 0)
{
return -1;
}
if (_listen(_port) < 0)
{
return -1;
}
if (sem_init(&_semReq, 0, 0) < 0)
{
LogErr("sem_init Failed %s\n", strerror(errno));
return -1;
}
srand(time(NULL));
return 0;
}
bool MDNSResponder::begin(const char* hostname) {
size_t n = strlen(hostname);
if (n > 63) { // max size for a single label.
return false;
}
// Copy in hostname characters as lowercase
_hostName = hostname;
_hostName.toLowerCase();
// If instance name is not already set copy hostname to instance name
if (_instanceName.equals("")) _instanceName = hostname;
_gotIPHandler = WiFi.onStationModeGotIP([this](const WiFiEventStationModeGotIP& event) {
_restart();
});
_disconnectedHandler = WiFi.onStationModeDisconnected([this](const WiFiEventStationModeDisconnected& event) {
_restart();
});
return _listen();
}
static BOOL freerdp_listener_open(freerdp_listener* instance, const char* bind_address, UINT16 port)
{
int status;
int sockfd;
char addr[64];
void* sin_addr;
int option_value;
char servname[16];
struct addrinfo* ai;
struct addrinfo* res;
struct addrinfo hints = { 0 };
rdpListener* listener = (rdpListener*) instance->listener;
#ifdef _WIN32
u_long arg;
#endif
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
if (!bind_address)
hints.ai_flags = AI_PASSIVE;
sprintf_s(servname, sizeof(servname), "%d", port);
status = getaddrinfo(bind_address, servname, &hints, &res);
if (status != 0)
{
#ifdef _WIN32
WLog_ERR("getaddrinfo error: %s", gai_strerrorA(status));
#else
WLog_ERR(TAG, "getaddrinfo");
#endif
return FALSE;
}
for (ai = res; ai && (listener->num_sockfds < 5); ai = ai->ai_next)
{
if ((ai->ai_family != AF_INET) && (ai->ai_family != AF_INET6))
continue;
if (listener->num_sockfds == MAX_LISTENER_HANDLES)
{
WLog_ERR(TAG, "too many listening sockets");
continue;
}
sockfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
if (sockfd == -1)
{
WLog_ERR(TAG, "socket");
continue;
}
if (ai->ai_family == AF_INET)
sin_addr = &(((struct sockaddr_in*) ai->ai_addr)->sin_addr);
else
sin_addr = &(((struct sockaddr_in6*) ai->ai_addr)->sin6_addr);
inet_ntop(ai->ai_family, sin_addr, addr, sizeof(addr));
option_value = 1;
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (void*) &option_value, sizeof(option_value)) == -1)
WLog_ERR(TAG, "setsockopt");
#ifndef _WIN32
fcntl(sockfd, F_SETFL, O_NONBLOCK);
#else
arg = 1;
ioctlsocket(sockfd, FIONBIO, &arg);
#endif
status = _bind((SOCKET) sockfd, ai->ai_addr, ai->ai_addrlen);
if (status != 0)
{
closesocket((SOCKET) sockfd);
continue;
}
status = _listen((SOCKET) sockfd, 10);
if (status != 0)
{
WLog_ERR(TAG, "listen");
closesocket((SOCKET) sockfd);
continue;
}
/* FIXME: these file descriptors do not work on Windows */
listener->sockfds[listener->num_sockfds] = sockfd;
listener->events[listener->num_sockfds] = WSACreateEvent();
if (!listener->events[listener->num_sockfds])
{
listener->num_sockfds = 0;
break;
}
WSAEventSelect(sockfd, listener->events[listener->num_sockfds], FD_READ | FD_ACCEPT | FD_CLOSE);
listener->num_sockfds++;
WLog_INFO(TAG, "Listening on %s:%s", addr, servname);
}
freeaddrinfo(res);
return (listener->num_sockfds > 0 ? TRUE : FALSE);
}
static BOOL freerdp_listener_open_local(freerdp_listener* instance, const char* path)
{
#ifndef _WIN32
int status;
int sockfd;
struct sockaddr_un addr;
rdpListener* listener = (rdpListener*) instance->listener;
HANDLE hevent;
if (listener->num_sockfds == MAX_LISTENER_HANDLES)
{
WLog_ERR(TAG, "too many listening sockets");
return FALSE;
}
sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
if (sockfd == -1)
{
WLog_ERR(TAG, "socket");
return FALSE;
}
fcntl(sockfd, F_SETFL, O_NONBLOCK);
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, path, sizeof(addr.sun_path));
unlink(path);
status = _bind(sockfd, (struct sockaddr*) &addr, sizeof(addr));
if (status != 0)
{
WLog_ERR(TAG, "bind");
closesocket((SOCKET) sockfd);
return FALSE;
}
status = _listen(sockfd, 10);
if (status != 0)
{
WLog_ERR(TAG, "listen");
closesocket((SOCKET) sockfd);
return FALSE;
}
hevent = CreateFileDescriptorEvent(NULL, FALSE, FALSE, sockfd, WINPR_FD_READ);
if (!hevent)
{
WLog_ERR(TAG, "failed to create sockfd event");
closesocket((SOCKET) sockfd);
return FALSE;
}
listener->sockfds[listener->num_sockfds] = sockfd;
listener->events[listener->num_sockfds] = hevent;
listener->num_sockfds++;
WLog_INFO(TAG, "Listening on socket %s.", addr.sun_path);
return TRUE;
#else
return TRUE;
#endif
}
int
rcmd_af(char **ahost, int rport, const char *locuser, const char *remuser,
const char *cmd, int *fd2p, int af)
{
struct addrinfo hints, *res, *ai;
struct sockaddr_storage from;
fd_set reads;
sigset_t oldmask, newmask;
pid_t pid;
int s, aport, lport, timo, error;
char c, *p;
int refused, nres;
char num[8];
static char canonnamebuf[MAXDNAME]; /* is it proper here? */
/* call rcmdsh() with specified remote shell if appropriate. */
if (!issetugid() && (p = getenv("RSH"))) {
struct servent *sp = getservbyname("shell", "tcp");
if (sp && sp->s_port == rport)
return (rcmdsh(ahost, rport, locuser, remuser,
cmd, p));
}
/* use rsh(1) if non-root and remote port is shell. */
if (geteuid()) {
struct servent *sp = getservbyname("shell", "tcp");
if (sp && sp->s_port == rport)
return (rcmdsh(ahost, rport, locuser, remuser,
cmd, NULL));
}
pid = getpid();
memset(&hints, 0, sizeof(hints));
hints.ai_flags = AI_CANONNAME;
hints.ai_family = af;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = 0;
snprintf(num, sizeof(num), "%d", ntohs(rport));
error = getaddrinfo(*ahost, num, &hints, &res);
if (error) {
fprintf(stderr, "rcmd: getaddrinfo: %s\n",
gai_strerror(error));
if (error == EAI_SYSTEM)
fprintf(stderr, "rcmd: getaddrinfo: %s\n",
strerror(errno));
return (-1);
}
if (res->ai_canonname &&
strlen(res->ai_canonname) + 1 < sizeof(canonnamebuf)) {
strncpy(canonnamebuf, res->ai_canonname, sizeof(canonnamebuf));
*ahost = canonnamebuf;
}
nres = 0;
for (ai = res; ai; ai = ai->ai_next)
nres++;
ai = res;
refused = 0;
sigemptyset(&newmask);
sigaddset(&newmask, SIGURG);
_sigprocmask(SIG_BLOCK, (const sigset_t *)&newmask, &oldmask);
for (timo = 1, lport = IPPORT_RESERVED - 1;;) {
s = rresvport_af(&lport, ai->ai_family);
if (s < 0) {
if (errno != EAGAIN && ai->ai_next) {
ai = ai->ai_next;
continue;
}
if (errno == EAGAIN)
fprintf(stderr,
"rcmd: socket: All ports in use\n");
else
fprintf(stderr, "rcmd: socket: %s\n",
strerror(errno));
freeaddrinfo(res);
_sigprocmask(SIG_SETMASK, (const sigset_t *)&oldmask,
NULL);
return (-1);
}
_fcntl(s, F_SETOWN, pid);
if (_connect(s, ai->ai_addr, ai->ai_addrlen) >= 0)
break;
_close(s);
if (errno == EADDRINUSE) {
lport--;
continue;
}
if (errno == ECONNREFUSED)
refused = 1;
if (ai->ai_next == NULL && (!refused || timo > 16)) {
fprintf(stderr, "%s: %s\n", *ahost, strerror(errno));
freeaddrinfo(res);
_sigprocmask(SIG_SETMASK, (const sigset_t *)&oldmask,
NULL);
return (-1);
}
if (nres > 1) {
int oerrno = errno;
getnameinfo(ai->ai_addr, ai->ai_addrlen, paddr,
sizeof(paddr), NULL, 0, NI_NUMERICHOST);
fprintf(stderr, "connect to address %s: ", paddr);
errno = oerrno;
perror(0);
}
if ((ai = ai->ai_next) == NULL) {
/* refused && timo <= 16 */
struct timespec time_to_sleep, time_remaining;
time_to_sleep.tv_sec = timo;
time_to_sleep.tv_nsec = 0;
_nanosleep(&time_to_sleep, &time_remaining);
timo *= 2;
ai = res;
refused = 0;
}
if (nres > 1) {
getnameinfo(ai->ai_addr, ai->ai_addrlen, paddr,
sizeof(paddr), NULL, 0, NI_NUMERICHOST);
fprintf(stderr, "Trying %s...\n", paddr);
}
}
lport--;
if (fd2p == 0) {
_write(s, "", 1);
lport = 0;
} else {
int s2 = rresvport_af(&lport, ai->ai_family), s3;
socklen_t len = ai->ai_addrlen;
int nfds;
if (s2 < 0)
goto bad;
_listen(s2, 1);
snprintf(num, sizeof(num), "%d", lport);
if (_write(s, num, strlen(num)+1) != strlen(num)+1) {
fprintf(stderr,
"rcmd: write (setting up stderr): %s\n",
strerror(errno));
_close(s2);
goto bad;
}
nfds = max(s, s2)+1;
if(nfds > FD_SETSIZE) {
fprintf(stderr, "rcmd: too many files\n");
_close(s2);
goto bad;
}
again:
FD_ZERO(&reads);
FD_SET(s, &reads);
FD_SET(s2, &reads);
errno = 0;
if (_select(nfds, &reads, 0, 0, 0) < 1 || !FD_ISSET(s2, &reads)){
if (errno != 0)
fprintf(stderr,
"rcmd: select (setting up stderr): %s\n",
strerror(errno));
else
fprintf(stderr,
"select: protocol failure in circuit setup\n");
_close(s2);
goto bad;
}
s3 = _accept(s2, (struct sockaddr *)&from, &len);
switch (from.ss_family) {
case AF_INET:
aport = ntohs(((struct sockaddr_in *)&from)->sin_port);
break;
#ifdef INET6
case AF_INET6:
aport = ntohs(((struct sockaddr_in6 *)&from)->sin6_port);
break;
#endif
default:
aport = 0; /* error */
break;
}
/*
* XXX careful for ftp bounce attacks. If discovered, shut them
* down and check for the real auxiliary channel to connect.
*/
if (aport == 20) {
_close(s3);
goto again;
}
_close(s2);
if (s3 < 0) {
fprintf(stderr,
"rcmd: accept: %s\n", strerror(errno));
lport = 0;
goto bad;
}
*fd2p = s3;
if (aport >= IPPORT_RESERVED || aport < IPPORT_RESERVED / 2) {
fprintf(stderr,
"socket: protocol failure in circuit setup.\n");
goto bad2;
}
}
_write(s, locuser, strlen(locuser)+1);
_write(s, remuser, strlen(remuser)+1);
_write(s, cmd, strlen(cmd)+1);
if (_read(s, &c, 1) != 1) {
fprintf(stderr,
"rcmd: %s: %s\n", *ahost, strerror(errno));
goto bad2;
}
if (c != 0) {
while (_read(s, &c, 1) == 1) {
_write(STDERR_FILENO, &c, 1);
if (c == '\n')
break;
}
goto bad2;
}
_sigprocmask(SIG_SETMASK, (const sigset_t *)&oldmask, NULL);
freeaddrinfo(res);
return (s);
bad2:
if (lport)
_close(*fd2p);
bad:
_close(s);
_sigprocmask(SIG_SETMASK, (const sigset_t *)&oldmask, NULL);
freeaddrinfo(res);
return (-1);
}
void listen() { _listen(); }
/* Event/Message loop for gcoap _pid thread. */
static void *_event_loop(void *arg)
{
msg_t msg_rcvd;
(void)arg;
msg_init_queue(_msg_queue, GCOAP_MSG_QUEUE_SIZE);
sock_udp_ep_t local;
memset(&local, 0, sizeof(sock_udp_ep_t));
local.family = AF_INET6;
local.netif = SOCK_ADDR_ANY_NETIF;
local.port = GCOAP_PORT;
int res = sock_udp_create(&_sock, &local, NULL, 0);
if (res < 0) {
DEBUG("gcoap: cannot create sock: %d\n", res);
return 0;
}
while(1) {
res = msg_try_receive(&msg_rcvd);
if (res > 0) {
switch (msg_rcvd.type) {
case GCOAP_MSG_TYPE_TIMEOUT: {
gcoap_request_memo_t *memo = (gcoap_request_memo_t *)msg_rcvd.content.ptr;
/* no retries remaining */
if ((memo->send_limit == GCOAP_SEND_LIMIT_NON)
|| (memo->send_limit == 0)) {
_expire_request(memo);
}
/* reduce retries remaining, double timeout and resend */
else {
memo->send_limit--;
unsigned i = COAP_MAX_RETRANSMIT - memo->send_limit;
uint32_t timeout = ((uint32_t)COAP_ACK_TIMEOUT << i) * US_PER_SEC;
uint32_t variance = ((uint32_t)COAP_ACK_VARIANCE << i) * US_PER_SEC;
timeout = random_uint32_range(timeout, timeout + variance);
ssize_t bytes = sock_udp_send(&_sock, memo->msg.data.pdu_buf,
memo->msg.data.pdu_len,
&memo->remote_ep);
if (bytes > 0) {
xtimer_set_msg(&memo->response_timer, timeout,
&memo->timeout_msg, _pid);
}
else {
DEBUG("gcoap: sock resend failed: %d\n", (int)bytes);
_expire_request(memo);
}
}
break;
}
default:
break;
}
}
_listen(&_sock);
}
return 0;
}
