~drizzle-trunk/drizzle/development

/* Copyright (c) 2008 PrimeBase Technologies GmbH, Germany

 *

 * PrimeBase Media Stream for MySQL

 *

 * 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, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

 *

 * Original author: Paul McCullagh (H&G2JCtL)

 * Continued development: Barry Leslie

 *

 * 2007-05-24

 *

 * CORE SYSTEM:

 * Basic socket I/O.

 *

 */

#include "CSConfig.h"

#include <stdio.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <netinet/in.h>

#include <netinet/tcp.h>

#include <ctype.h>

#include <string.h>

#include <stdlib.h>

#include "CSSocket.h"

#include "CSStream.h"

#include "CSGlobal.h"

#include "CSStrUtil.h"

#include "CSFile.h"

/*

 * ---------------------------------------------------------------

 * CORE SYSTEM SOCKET FACTORY

 */

CSSocket *CSSocket::newSocket()

{

	SCSocket *s;

	new_(s, SCSocket());

	return (CSSocket *) s;

}

/*

 * ---------------------------------------------------------------

 * INTERNAL UTILITIES

 */

void SCSocket::formatAddress(size_t size, char *buffer)

{

	if (iHost) {

		cs_strcpy(size, buffer, iHost);

		if (iService)

			cs_strcat(size, buffer, ":");

	}

	else

		*buffer = 0;

	if (iService)

		cs_strcat(size, buffer, iService);

}

void SCSocket::throwError(const char *func, const char *file, int line, char *address, int err)

{

	if (err)

		CSException::throwFileError(func, file, line, address, err);

	else

		CSException::throwEOFError(func, file, line, address);

}

void SCSocket::throwError(const char *func, const char *file, int line, int err)

{

	char address[CS_SOCKET_ADDRESS_SIZE];

	formatAddress(CS_SOCKET_ADDRESS_SIZE, address);

	throwError(func, file, line, address, err);

}

void SCSocket::setInternalOptions()

{

	int flag = 1;

	if (setsockopt(iHandle, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int)) == -1)

		CSException::throwOSError(CS_CONTEXT, errno);

}

void SCSocket::openInternal()

{

	iHandle = socket(AF_INET, SOCK_STREAM, 0);

	if (iHandle == -1)

		CSException::throwOSError(CS_CONTEXT, errno);

	setInternalOptions();

}

/*

 * ---------------------------------------------------------------

 * SOCKET BASED ON THE STANDARD C SOCKET

 */

CSOutputStream *CSSocket::getOutputStream()

{

	return CSSocketOutputStream::newStream(RETAIN(this));

}

CSInputStream *CSSocket::getInputStream()

{

	return CSSocketInputStream::newStream(RETAIN(this));

}

void SCSocket::publish(char *service, int default_port)

{

	enter_();

	close();

	try_(a) {

		struct servent		*servp;

		struct sockaddr_in	server;

		struct servent		s;

		int					flag = 1;

		openInternal();

		if (service) {

			if (isdigit(service[0])) {

				int i =  atoi(service);

				if (!i)

					CSException::throwCoreError(CS_CONTEXT, CS_ERR_BAD_ADDRESS, service);

				servp = &s;

				s.s_port = htons((uint16_t) i);

				iService = cs_strdup(service);

			}

			else if ((servp = getservbyname(service, "tcp")) == NULL) {

				if (!default_port)

					CSException::throwCoreError(CS_CONTEXT, CS_ERR_UNKNOWN_SERVICE, service);

				servp = &s;

				s.s_port = htons((uint16_t) default_port);

				iService = cs_strdup(default_port);

			}

			else

				iService = cs_strdup(service);

		}

		else {

			if (!default_port)

				CSException::throwCoreError(CS_CONTEXT, CS_ERR_UNKNOWN_SERVICE, "");

			servp = &s;

			s.s_port = htons((uint16_t) default_port);

			iService = cs_strdup(default_port);

		}

		iPort = ntohs(servp->s_port);

		memset(&server, 0, sizeof(server));

		server.sin_family = AF_INET;

		server.sin_addr.s_addr = INADDR_ANY;

		server.sin_port = (uint16_t) servp->s_port;

		if (setsockopt(iHandle, SOL_SOCKET, SO_REUSEADDR, (char *) &flag, sizeof(int)) == -1)

			CSException::throwOSError(CS_CONTEXT, errno);

		if (bind(iHandle, (struct sockaddr *) &server, sizeof(server)) == -1)

			CSException::throwOSError(CS_CONTEXT, errno);

		if (listen(iHandle, SOMAXCONN) == -1)

			CSException::throwOSError(CS_CONTEXT, errno);

	}

	catch_(a) {

		close();

		throw_();

	}

	cont_(a);

	exit_();

}

void SCSocket::open(CSSocket *listener)

{

	enter_();

	close();

	try_(a) {

		int listener_handle;

		char address[CS_SOCKET_ADDRESS_SIZE];

		struct sockaddr_in	remote;

		socklen_t			addrlen = sizeof(remote);

		/* First get all the information we need from the listener: */

		listener_handle = ((SCSocket *) listener)->iHandle;

		listener->formatAddress(CS_SOCKET_ADDRESS_SIZE, address);

		/* I want to make sure no error occurs after the connect!

		 * So I allocate a buffer for the host name up front.

		 * This means it may be to small, but this is not a problem

		 * because the host name stored here is is only used for display

		 * of error message etc.

		 */

		iHost = (char *) cs_malloc(100);

		iHandle = accept(listener_handle, (struct sockaddr *) &remote, &addrlen);

		if (iHandle == -1)

			throwError(CS_CONTEXT, address, errno);

		cs_strcpy(100, iHost, inet_ntoa(remote.sin_addr));

		iPort = ntohs(remote.sin_port);

		setInternalOptions();

	}

	catch_(a) {

		close();

		throw_();

	}

	cont_(a);

	exit_();

}

void SCSocket::open(char *address, int default_port)

{

	enter_();

	close();

	try_(a) {

		char				*portp = strchr(address, ':');

		struct servent		s;

		struct servent		*servp;

		struct hostent		*hostp;

		struct sockaddr_in	server;

		openInternal();

		if (!portp) {

			iHost = cs_strdup(address);

			if (!default_port)

				CSException::throwCoreError(CS_CONTEXT, CS_ERR_BAD_ADDRESS, address);

			iService = cs_strdup(default_port);

		}

		else {

			iHost = cs_strdup(address, (size_t) (portp - address));

			iService = cs_strdup(portp+1);

		}

		if (isdigit(iService[0])) {

			int i =  atoi(iService);

			if (!i)

				CSException::throwCoreError(CS_CONTEXT, CS_ERR_BAD_ADDRESS, address);

			servp = &s;

			s.s_port = htons((uint16_t) i);

		}

		else if ((servp = getservbyname(iService, "tcp")) == NULL)

			CSException::throwCoreError(CS_CONTEXT, CS_ERR_UNKNOWN_SERVICE, iService);

		iPort = (int) ntohs(servp->s_port);

		if ((hostp = gethostbyname(iHost)) == 0)

			CSException::throwCoreError(CS_CONTEXT, CS_ERR_UNKNOWN_HOST, iHost);

		memset(&server, 0, sizeof(server));

		server.sin_family = AF_INET;

		memcpy(&server.sin_addr, hostp->h_addr, (size_t) hostp->h_length);

		server.sin_port = (uint16_t) servp->s_port;

		if (connect(iHandle, (struct sockaddr *) &server, sizeof(server)) == -1)

			throwError(CS_CONTEXT, errno);

	}

	catch_(a) {

		close();

		throw_();

	}

	cont_(a);

	exit_();

}

void SCSocket::close()

{

	if (iHandle != -1) {

		shutdown(iHandle, SHUT_RDWR);

		/* shutdown does not close the socket!!? */

		unix_file_close(iHandle);

		iHandle = -1;

	}

	if (iHost) {

		cs_free(iHost);

		iHost = NULL;

	}

	if (iService) {

		cs_free(iService);

		iService = NULL;

	}

	iPort = 0;

}

size_t SCSocket::read(void *data, size_t len)

{

	ssize_t in;

	enter_();

	/* recv, by default will block until at lease one byte is

	 * returned.

	 * So a return of zero means EOF!

	 */

	retry:

	in = recv(iHandle, data, len, 0);

	self->interrupted();

	if (in == -1) {

		/* Note, we actually ignore all errors on the socket.

		 * If no data was returned by the read so far, then

		 * the error will be considered EOF.

		 */

		if (errno == EAGAIN || errno == EINTR)

			goto retry;

		in = 0;

	}

	return_((size_t) in);

}

int SCSocket::read()

{

	int		ch;

	u_char	buffer[1];

	enter_();

	if (read(buffer, 1) == 1)

		ch = buffer[0];

	else

		ch = -1;

	return_(ch);

}

int SCSocket::peek()

{

	return -1;

}

void SCSocket::write(const void *data, size_t len)

{

	ssize_t	out;

	enter_();

	while (len > 0) {

		out = send(iHandle, data, len, 0);

		self->interrupted();

		if (out == -1) {

			int err = errno;

			if (err == EAGAIN || errno == EINTR)

				continue;

			throwError(CS_CONTEXT, err);

		}

		if ((size_t) out > len)

			break;

		len -= (size_t) out;

		data = ((char *) data) + (size_t) out;

	}

	exit_();

}

void SCSocket::write(char ch)

{

	enter_();

	write(&ch, 1);

	exit_();

}

void SCSocket::flush()

{

}