TCP socket.

node/TcpSocket.cpp

@@ -0,0 +1,198 @@
+/*
+ * ZeroTier One - Global Peer to Peer Ethernet
+ * Copyright (C) 2011-2014  ZeroTier Networks LLC
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ * --
+ *
+ * ZeroTier may be used and distributed under the terms of the GPLv3, which
+ * are available at: http://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * If you would like to embed ZeroTier into a commercial application or
+ * redistribute it in a modified binary form, please contact ZeroTier Networks
+ * LLC. Start here: http://www.zerotier.com/
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <time.h>
+#include <errno.h>
+#include <sys/types.h>
+
+#include "Constants.hpp"
+#include "TcpSocket.hpp"
+#include "SocketManager.hpp"
+
+#ifdef __WINDOWS__
+#include <WinSock2.h>
+#include <WS2tcpip.h>
+#include <Windows.h>
+#else
+#include <unistd.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <signal.h>
+#endif
+
+#define ZT_TCP_MAX_SENDQ_LENGTH (ZT_SOCKET_MAX_MESSAGE_LEN * 8)
+
+namespace ZeroTier {
+
+TcpSocket::~TcpSocket()
+{
+#ifdef __WINDOWS__
+	::closesocket(_sock);
+#else
+	::close(_sock);
+#endif
+
+	if (_outbuf)
+		::free(_outbuf);
+}
+
+bool TcpSocket::send(const InetAddress &to,const void *msg,unsigned int msglen)
+{
+	if (msglen > ZT_SOCKET_MAX_MESSAGE_LEN)
+		return false; // message too big
+	if (!msglen)
+		return true; // sanity check
+
+	Mutex::Lock _l(_writeLock);
+
+	bool outputWasEnqueued = (_outptr != 0);
+
+	// Ensure that _outbuf is large enough
+	unsigned int newptr = _outptr + 5 + msglen;
+	if (newptr > _outbufsize) {
+		unsigned int newbufsize = _outbufsize;
+		while (newbufsize < newptr)
+			newbufsize += ZT_SOCKET_MAX_MESSAGE_LEN;
+		if (newbufsize > ZT_TCP_MAX_SENDQ_LENGTH)
+			return false; // cannot send, outbuf full
+		unsigned char *newbuf = (unsigned char *)::malloc(newbufsize);
+		if (!newbuf)
+			return false; // cannot send, no memory
+		_outbufsize = newbufsize;
+		if (_outbuf) {
+			memcpy(newbuf,_outbuf,_outptr);
+			::free(_outbuf);
+		}
+		_outbuf = newbuf;
+	}
+
+	_outbuf[_outptr++] = 0x17; // look like TLS data
+	_outbuf[_outptr++] = 0x03;
+	_outbuf[_outptr++] = 0x03; // look like TLS 1.2
+	_outbuf[_outptr++] = (unsigned char)((msglen >> 8) & 0xff);
+	_outbuf[_outptr++] = (unsigned char)(msglen & 0xff);
+	for(unsigned int i=0;i<msglen;++i)
+		_outbuf[_outptr++] = ((const unsigned char *)msg)[i];
+
+	if (!outputWasEnqueued) {
+		// If no output was enqueued before this, try to send() it and then
+		// start a queued write if any remains after that.
+
+		int n = (int)::send(_sock,_outbuf,_outptr,0);
+		if (n > 0)
+			memmove(_outbuf,_outbuf + (unsigned int)n,_outptr -= (unsigned int)n);
+
+		if (_outptr) {
+			_sm->startNotifyWrite(this);
+			_sm->whack();
+		}
+	} // else just leave in _outbuf[] to get written when stream is available for write
+
+	return true;
+}
+
+bool TcpSocket::notifyAvailableForRead(const SharedPtr<Socket> &self,SocketManager *sm)
+{
+	unsigned char buf[65536];
+
+	// will not be called concurrently since only SocketManager::poll() calls this
+
+	int n = (int)::recv(_sock,buf,sizeof(buf),0);
+	if (n <= 0)
+		return false; // read error, stream probably closed
+
+	unsigned int p = _inptr,pl = 0;
+	for(int k=0;k<n;++k) {
+		_inbuf[p++] = buf[k];
+		if (p >= (int)sizeof(_inbuf))
+			return false; // read overrun, packet too large or invalid
+
+		if ((!pl)&&(p >= 5)) {
+			if (_inbuf[0] == 0x17) {
+				// fake TLS data frame, next two bytes are TLS version and are ignored
+				pl = (((unsigned int)_inbuf[3] << 8) | (unsigned int)_inbuf[4]) + 5;
+			} else return false; // in the future we may support fake TLS handshakes
+		}
+
+		if ((pl)&&(p >= pl)) {
+			Buffer<ZT_SOCKET_MAX_MESSAGE_LEN> data(_inbuf + 5,pl - 5);
+			sm->handleReceivedPacket(self,_remote,data);
+			memmove(_inbuf,_inbuf + pl,p - pl);
+			p -= pl;
+			pl = 0;
+		}
+	}
+	_inptr = p;
+
+	return true;
+}
+
+bool TcpSocket::notifyAvailableForWrite(const SharedPtr<Socket> &self,SocketManager *sm)
+{
+	Mutex::Lock _l(_writeLock);
+
+	if (_outptr) {
+		int n = (int)::send(_sock,_outbuf,_outptr,0);
+		if (n < 0) {
+			switch(errno) {
+#ifdef EBADF
+				case EBADF:
+#endif
+#ifdef EINVAL
+				case EINVAL:
+#endif
+#ifdef ENOTSOCK
+				case ENOTSOCK:
+#endif
+#ifdef ECONNRESET
+				case ECONNRESET:
+#endif
+#ifdef EPIPE
+				case EPIPE:
+#endif
+#ifdef ENETDOWN
+				case ENETDOWN:
+#endif
+					return false;
+				default:
+					break;
+			}
+		} else if (n > 0)
+			memmove(_outbuf,_outbuf + (unsigned int)n,_outptr -= (unsigned int)n);
+	}
+
+	if (!_outptr)
+		sm->stopNotifyWrite(this);
+
+	return true;
+}
+
+} // namespace ZeroTier