src/modules/internet/sockconn.c - R - Git at Google

 /*
  *  R : A Computer Language for Statistical Data Analysis
  *  Copyright (C)  2001-2021   The R Core Team.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, a copy is available at
  *  https://www.R-project.org/Licenses/
  */

 /* <UTF8> chars are only handled as a whole */

 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif


 /* ------------------- socket connections  --------------------- */

 #define R_USE_SIGNALS 1
 #include <Defn.h>
 #include <Rconnections.h>
 #include "sock.h"
 #include <errno.h>

 static void listencleanup(void *data)
 {
     int *psock = data;
     R_SockClose(*psock);
 }

 static Rboolean sock_open(Rconnection con)
 {
     Rsockconn this = (Rsockconn)con->private;
     int sock, sock1, mlen;
     int timeout = this->timeout;
     char buf[256];

     if(timeout == NA_INTEGER || timeout <= 0) timeout = 60;
     this->pend = this->pstart = this->inbuf;

     if(this->server) {
 	if (this->serverfd == -1) {
 	    sock1 = R_SockOpen(this->port); /* socket(), bind(), listen() */
 	    if(sock1 < 0) {
 		warning("port %d cannot be opened", this->port);
 		return FALSE;
 	    }
 	    {
 		RCNTXT cntxt;

 		/* set up a context which will close socket on jump. */
 		begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv,
 			     R_BaseEnv, R_NilValue, R_NilValue);
 		cntxt.cend = &listencleanup;
 		cntxt.cenddata = &sock1;
 		sock = R_SockListen(sock1, buf, 256, timeout); /* accept() */
 		endcontext(&cntxt);
 	    }
 	    R_SockClose(sock1);
 	    if(sock < 0) {
 		/* NOTE: potentially confusing as the error was in accept() */
 		warning("problem in listening on this socket");
 		return FALSE;
 	    }
 	} else {
 	    /* accept() */
 	    sock = R_SockListen(this->serverfd, buf, 256, timeout);
 	    if(sock < 0) {
 		/* "accepting" as this is used with socketAccept() */
 		warning("problem in accepting connections on this socket");
 		return FALSE;
 	    }
 	}
 	free(con->description);
 	con->description = (char *) malloc(strlen(buf) + 10);
 	sprintf(con->description, "<-%s:%d", buf, this->port);
     } else {
 	sock = R_SockConnect(this->port, con->description, timeout);
 	if(sock < 0) {
 	    warning("%s:%d cannot be opened", con->description, this->port);
 	    return FALSE;
 	}
 	sprintf(buf, "->%s:%d", con->description, this->port);
 	strcpy(con->description, buf);
     }
     this->fd = sock;

     if (this->options & RSC_SET_TCP_NODELAY)
 	R_set_nodelay(sock);

     mlen = (int) strlen(con->mode);
     con->isopen = TRUE;
     if(mlen >= 2 && con->mode[mlen - 1] == 'b') con->text = FALSE;
     else con->text = TRUE;
     set_iconv(con); /* OK for output, at least */
     con->save = -1000;
     return TRUE;
 }

 static void sock_close(Rconnection con)
 {
     Rsockconn this = (Rsockconn)con->private;
     R_SockClose(this->fd);
     con->isopen = FALSE;
 }

 static void servsock_close(Rconnection con)
 {
     Rservsockconn this = (Rservsockconn)con->private;
     R_SockClose(this->fd);
     con->isopen = FALSE;
 }

 static ssize_t sock_read_helper(Rconnection con, void *ptr, size_t size)
 {
     Rsockconn this = (Rsockconn)con->private;
     ssize_t res;
     size_t nread = 0, n;

     con->incomplete = FALSE;
     do {
 	/* read data into the buffer if it's empty and size > 0 */
 	if (size > 0 && this->pstart == this->pend) {
 	    this->pstart = this->pend = this->inbuf;
 	    do
 		res = R_SockRead(this->fd, this->inbuf, 4096,
 				 con->blocking, this->timeout);
 #ifdef Win32
 	    while (-res == WSAEINTR);
 	    if (! con->blocking && -res == WSAEWOULDBLOCK) {
 #else
 	    while (-res == EINTR);
 	    if (! con->blocking && (-res == EAGAIN || -res == EWOULDBLOCK)) {
 #endif
 		con->incomplete = TRUE;
 		return nread;
 	    }
 	    else if (res == 0) /* should mean EOF */
 		return nread;
 	    else if (res < 0) return res;
 	    else this->pend = this->inbuf + res;
 	}

 	/* copy data from buffer to ptr */
 	if (this->pstart + size <= this->pend)
 	    n = size;
 	else
 	    n = this->pend - this->pstart;
 	memcpy(ptr, this->pstart, n);
 	ptr = ((char *) ptr) + n;
 	this->pstart += n;
 	size -= n;
 	nread += n;
     } while (size > 0);

     return nread;
 }


 static int sock_fgetc_internal(Rconnection con)
 {
     unsigned char c;
     ssize_t n;

     n = sock_read_helper(con, (char *)&c, 1);
     return (n == 1) ? c : R_EOF;
 }

 static size_t sock_read(void *ptr, size_t size, size_t nitems,
 			Rconnection con)
 {
     ssize_t n = sock_read_helper(con, ptr, size * nitems)/((ssize_t)size);
     return n > 0 ? n : 0;
 }

 static size_t sock_write(const void *ptr, size_t size, size_t nitems,
 			 Rconnection con)
 {
     Rsockconn this = (Rsockconn)con->private;
     ssize_t n = R_SockWrite(this->fd, ptr, (size_t)(size * nitems),
 			    this->timeout)/((ssize_t)size);
     return n > 0 ? n : 0;
 }

 Rconnection in_R_newsock(const char *host, int port, int server, int serverfd,
 			 const char * const mode, int timeout, int options)
 {
     Rconnection new;

     new = (Rconnection) malloc(sizeof(struct Rconn));
     if(!new) error(_("allocation of socket connection failed"));
     new->class = (char *) malloc(strlen("sockconn") + 1);
     if(!new->class) {
 	free(new);
 	error(_("allocation of socket connection failed"));
         /* for Solaris 12.5 */ new = NULL;
     }
     strcpy(new->class, "sockconn");
     new->description = (char *) malloc(strlen(host) + 10);
     if(!new->description) {
 	free(new->class); free(new);
 	error(_("allocation of socket connection failed"));
         /* for Solaris 12.5 */ new = NULL;
     }
     init_con(new, host, CE_NATIVE, mode);
     new->open = &sock_open;
     new->close = &sock_close;
     new->vfprintf = &dummy_vfprintf;
     new->fgetc_internal = &sock_fgetc_internal;
     new->fgetc = &dummy_fgetc;
     new->read = &sock_read;
     new->write = &sock_write;
     new->private = (void *) malloc(sizeof(struct sockconn));
     if(!new->private) {
 	free(new->description); free(new->class); free(new);
 	error(_("allocation of socket connection failed"));
 	/* for Solaris 12.5 */ new = NULL;
     }
     ((Rsockconn)new->private)-> port = port;
     ((Rsockconn)new->private)-> server = server;
     ((Rsockconn)new->private)-> timeout = timeout;
     ((Rsockconn)new->private)-> serverfd = serverfd;
     ((Rsockconn)new->private)-> options = options;
     return new;
 }

 Rconnection in_R_newservsock(int port)
 {
     Rconnection new;

     new = (Rconnection) malloc(sizeof(struct Rconn));
     if(!new) error(_("allocation of server socket connection failed"));
     new->class = (char *) malloc(strlen("servsockconn") + 1);
     if(!new->class) {
 	free(new);
 	error(_("allocation of server socket connection failed"));
         /* for Solaris 12.5 */ new = NULL;
     }
     strcpy(new->class, "servsockconn");
     new->description = (char *) malloc(strlen("localhost") + 10);
     if(!new->description) {
 	free(new->class); free(new);
 	error(_("allocation of server socket connection failed"));
         /* for Solaris 12.5 */ new = NULL;
     }
     init_con(new, "localhost", CE_NATIVE, "a+");
     new->close = &servsock_close;
     new->private = (void *) malloc(sizeof(struct servsockconn));
     if(!new->private) {
 	free(new->description); free(new->class); free(new);
 	error(_("allocation of server socket connection failed"));
 	/* for Solaris 12.5 */ new = NULL;
     }
     ((Rservsockconn)new->private)-> port = port;

     /* socket(), bind(), listen() */
     int sock = R_SockOpen(port);
     if(sock < 0) {
 	free(new->private); free(new->description); free(new->class); free(new);
 	error(_("creation of server socket failed: port %d cannot be opened"),
 	      port);
 	/* for Solaris 12.5 */ new = NULL;
     }
     ((Rservsockconn)new->private)-> fd = sock;
     new->isopen = TRUE;

     return new;
 }
	/*
	* R : A Computer Language for Statistical Data Analysis
	* Copyright (C) 2001-2021 The R Core Team.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, a copy is available at
	* https://www.R-project.org/Licenses/
	*/

	/* <UTF8> chars are only handled as a whole */

	#ifdef HAVE_CONFIG_H
	#include <config.h>
	#endif


	/* ------------------- socket connections --------------------- */

	#define R_USE_SIGNALS 1
	#include <Defn.h>
	#include <Rconnections.h>
	#include "sock.h"
	#include <errno.h>

	static void listencleanup(void *data)
	{
	int *psock = data;
	R_SockClose(*psock);
	}

	static Rboolean sock_open(Rconnection con)
	{
	Rsockconn this = (Rsockconn)con->private;
	int sock, sock1, mlen;
	int timeout = this->timeout;
	char buf[256];

	if(timeout == NA_INTEGER \|\| timeout <= 0) timeout = 60;
	this->pend = this->pstart = this->inbuf;

	if(this->server) {
	if (this->serverfd == -1) {
	sock1 = R_SockOpen(this->port); /* socket(), bind(), listen() */
	if(sock1 < 0) {
	warning("port %d cannot be opened", this->port);
	return FALSE;
	}
	{
	RCNTXT cntxt;

	/* set up a context which will close socket on jump. */
	begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv,
	R_BaseEnv, R_NilValue, R_NilValue);
	cntxt.cend = &listencleanup;
	cntxt.cenddata = &sock1;
	sock = R_SockListen(sock1, buf, 256, timeout); /* accept() */
	endcontext(&cntxt);
	}
	R_SockClose(sock1);
	if(sock < 0) {
	/* NOTE: potentially confusing as the error was in accept() */
	warning("problem in listening on this socket");
	return FALSE;
	}
	} else {
	/* accept() */
	sock = R_SockListen(this->serverfd, buf, 256, timeout);
	if(sock < 0) {
	/* "accepting" as this is used with socketAccept() */
	warning("problem in accepting connections on this socket");
	return FALSE;
	}
	}
	free(con->description);
	con->description = (char *) malloc(strlen(buf) + 10);
	sprintf(con->description, "<-%s:%d", buf, this->port);
	} else {
	sock = R_SockConnect(this->port, con->description, timeout);
	if(sock < 0) {
	warning("%s:%d cannot be opened", con->description, this->port);
	return FALSE;
	}
	sprintf(buf, "->%s:%d", con->description, this->port);
	strcpy(con->description, buf);
	}
	this->fd = sock;

	if (this->options & RSC_SET_TCP_NODELAY)
	R_set_nodelay(sock);

	mlen = (int) strlen(con->mode);
	con->isopen = TRUE;
	if(mlen >= 2 && con->mode[mlen - 1] == 'b') con->text = FALSE;
	else con->text = TRUE;
	set_iconv(con); /* OK for output, at least */
	con->save = -1000;
	return TRUE;
	}

	static void sock_close(Rconnection con)
	{
	Rsockconn this = (Rsockconn)con->private;
	R_SockClose(this->fd);
	con->isopen = FALSE;
	}

	static void servsock_close(Rconnection con)
	{
	Rservsockconn this = (Rservsockconn)con->private;
	R_SockClose(this->fd);
	con->isopen = FALSE;
	}

	static ssize_t sock_read_helper(Rconnection con, void *ptr, size_t size)
	{
	Rsockconn this = (Rsockconn)con->private;
	ssize_t res;
	size_t nread = 0, n;

	con->incomplete = FALSE;
	do {
	/* read data into the buffer if it's empty and size > 0 */
	if (size > 0 && this->pstart == this->pend) {
	this->pstart = this->pend = this->inbuf;
	do
	res = R_SockRead(this->fd, this->inbuf, 4096,
	con->blocking, this->timeout);
	#ifdef Win32
	while (-res == WSAEINTR);
	if (! con->blocking && -res == WSAEWOULDBLOCK) {
	#else
	while (-res == EINTR);
	if (! con->blocking && (-res == EAGAIN \|\| -res == EWOULDBLOCK)) {
	#endif
	con->incomplete = TRUE;
	return nread;
	}
	else if (res == 0) /* should mean EOF */
	return nread;
	else if (res < 0) return res;
	else this->pend = this->inbuf + res;
	}

	/* copy data from buffer to ptr */
	if (this->pstart + size <= this->pend)
	n = size;
	else
	n = this->pend - this->pstart;
	memcpy(ptr, this->pstart, n);
	ptr = ((char *) ptr) + n;
	this->pstart += n;
	size -= n;
	nread += n;
	} while (size > 0);

	return nread;
	}


	static int sock_fgetc_internal(Rconnection con)
	{
	unsigned char c;
	ssize_t n;

	n = sock_read_helper(con, (char *)&c, 1);
	return (n == 1) ? c : R_EOF;
	}

	static size_t sock_read(void *ptr, size_t size, size_t nitems,
	Rconnection con)
	{
	ssize_t n = sock_read_helper(con, ptr, size * nitems)/((ssize_t)size);
	return n > 0 ? n : 0;
	}

	static size_t sock_write(const void *ptr, size_t size, size_t nitems,
	Rconnection con)
	{
	Rsockconn this = (Rsockconn)con->private;
	ssize_t n = R_SockWrite(this->fd, ptr, (size_t)(size * nitems),
	this->timeout)/((ssize_t)size);
	return n > 0 ? n : 0;
	}

	Rconnection in_R_newsock(const char *host, int port, int server, int serverfd,
	const char * const mode, int timeout, int options)
	{
	Rconnection new;

	new = (Rconnection) malloc(sizeof(struct Rconn));
	if(!new) error(_("allocation of socket connection failed"));
	new->class = (char *) malloc(strlen("sockconn") + 1);
	if(!new->class) {
	free(new);
	error(_("allocation of socket connection failed"));
	/* for Solaris 12.5 */ new = NULL;
	}
	strcpy(new->class, "sockconn");
	new->description = (char *) malloc(strlen(host) + 10);
	if(!new->description) {
	free(new->class); free(new);
	error(_("allocation of socket connection failed"));
	/* for Solaris 12.5 */ new = NULL;
	}
	init_con(new, host, CE_NATIVE, mode);
	new->open = &sock_open;
	new->close = &sock_close;
	new->vfprintf = &dummy_vfprintf;
	new->fgetc_internal = &sock_fgetc_internal;
	new->fgetc = &dummy_fgetc;
	new->read = &sock_read;
	new->write = &sock_write;
	new->private = (void *) malloc(sizeof(struct sockconn));
	if(!new->private) {
	free(new->description); free(new->class); free(new);
	error(_("allocation of socket connection failed"));
	/* for Solaris 12.5 */ new = NULL;
	}
	((Rsockconn)new->private)-> port = port;
	((Rsockconn)new->private)-> server = server;
	((Rsockconn)new->private)-> timeout = timeout;
	((Rsockconn)new->private)-> serverfd = serverfd;
	((Rsockconn)new->private)-> options = options;
	return new;
	}

	Rconnection in_R_newservsock(int port)
	{
	Rconnection new;

	new = (Rconnection) malloc(sizeof(struct Rconn));
	if(!new) error(_("allocation of server socket connection failed"));
	new->class = (char *) malloc(strlen("servsockconn") + 1);
	if(!new->class) {
	free(new);
	error(_("allocation of server socket connection failed"));
	/* for Solaris 12.5 */ new = NULL;
	}
	strcpy(new->class, "servsockconn");
	new->description = (char *) malloc(strlen("localhost") + 10);
	if(!new->description) {
	free(new->class); free(new);
	error(_("allocation of server socket connection failed"));
	/* for Solaris 12.5 */ new = NULL;
	}
	init_con(new, "localhost", CE_NATIVE, "a+");
	new->close = &servsock_close;
	new->private = (void *) malloc(sizeof(struct servsockconn));
	if(!new->private) {
	free(new->description); free(new->class); free(new);
	error(_("allocation of server socket connection failed"));
	/* for Solaris 12.5 */ new = NULL;
	}
	((Rservsockconn)new->private)-> port = port;

	/* socket(), bind(), listen() */
	int sock = R_SockOpen(port);
	if(sock < 0) {
	free(new->private); free(new->description); free(new->class); free(new);
	error(_("creation of server socket failed: port %d cannot be opened"),
	port);
	/* for Solaris 12.5 */ new = NULL;
	}
	((Rservsockconn)new->private)-> fd = sock;
	new->isopen = TRUE;

	return new;
	}