summaryrefslogtreecommitdiff
path: root/src/Sockets/tests
diff options
context:
space:
mode:
Diffstat (limited to 'src/Sockets/tests')
-rw-r--r--src/Sockets/tests/Makefile73
-rw-r--r--src/Sockets/tests/base64.cpp34
-rw-r--r--src/Sockets/tests/copy.cpp264
-rw-r--r--src/Sockets/tests/crlf.cpp139
-rw-r--r--src/Sockets/tests/echoserver.cpp237
-rw-r--r--src/Sockets/tests/events.cpp212
-rw-r--r--src/Sockets/tests/http.cpp65
-rw-r--r--src/Sockets/tests/http_post.cpp107
-rw-r--r--src/Sockets/tests/httpd.cpp109
-rw-r--r--src/Sockets/tests/https.cpp113
-rw-r--r--src/Sockets/tests/resolve.cpp156
-rw-r--r--src/Sockets/tests/resume.cpp111
-rw-r--r--src/Sockets/tests/retry.cpp67
-rw-r--r--src/Sockets/tests/semtest.cpp96
-rw-r--r--src/Sockets/tests/sloppy_http.cpp55
-rw-r--r--src/Sockets/tests/sockets_test.cpp347
-rw-r--r--src/Sockets/tests/stressclient.cpp516
-rw-r--r--src/Sockets/tests/x.cpp298
18 files changed, 2999 insertions, 0 deletions
diff --git a/src/Sockets/tests/Makefile b/src/Sockets/tests/Makefile
new file mode 100644
index 0000000..0bbabf8
--- /dev/null
+++ b/src/Sockets/tests/Makefile
@@ -0,0 +1,73 @@
+SOCKETS = ..
+PLATFORM = linux-x86-32
+LIBS = -L$(SOCKETS) -lSockets
+
+INCLUDE = -I$(SOCKETS)
+include $(SOCKETS)/Makefile.version
+include $(SOCKETS)/Makefile.Defines.$(PLATFORM)
+
+CPPFLAGS = $(CFLAGS)
+
+#LIBS += -lsctp
+
+PROGS = events resolve sockets_test base64 semtest \
+ echoserver stressclient http httpd retry resume \
+ http_post x copy crlf https sloppy_http
+
+all: $(PROGS)
+
+events: events.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+resolve: resolve.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+sockets_test: sockets_test.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+base64: base64.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+semtest: semtest.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+echoserver: echoserver.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+stressclient: stressclient.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+http: http.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+httpd: httpd.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+retry: retry.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+resume: resume.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+http_post: http_post.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+x: x.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+copy: copy.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+crlf: crlf.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+https: https.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+sloppy_http: sloppy_http.o
+ $(CXX) -o $@ $^ $(LIBS)
+
+clean:
+ rm -f *.o *~ slask *.d $(PROGS)
+
+-include *.d
diff --git a/src/Sockets/tests/base64.cpp b/src/Sockets/tests/base64.cpp
new file mode 100644
index 0000000..722439d
--- /dev/null
+++ b/src/Sockets/tests/base64.cpp
@@ -0,0 +1,34 @@
+#include <stdio.h>
+
+#include "Base64.h"
+
+
+int main(int argc,char *argv[])
+{
+ if (argc < 2)
+ return -1;
+ std::string str;
+ std::string str2;
+ Base64 b;
+ if (!strcmp(argv[1],"-file"))
+ {
+ if (argc < 3)
+ return -2;
+ FILE *fil;
+ if ((fil = fopen(argv[2],"rt")) != NULL)
+ {
+ b.encode(fil, str);
+ fclose(fil);
+ }
+ printf("File:\n%s\n--End of File\n",str.c_str());
+ b.decode(str, str2);
+ printf("Content:\n%s\n--End of Content\n",str2.c_str());
+ }
+ else
+ {
+ b.encode(argv[1], strlen(argv[1]), str);
+ printf("'%s' ==> '%s'",argv[1], str.c_str());
+ b.decode(str, str2);
+ printf(" ==> '%s'\n",str2.c_str());
+ }
+}
diff --git a/src/Sockets/tests/copy.cpp b/src/Sockets/tests/copy.cpp
new file mode 100644
index 0000000..2134ac2
--- /dev/null
+++ b/src/Sockets/tests/copy.cpp
@@ -0,0 +1,264 @@
+#include <TcpSocket.h>
+#include <SocketHandler.h>
+#include <ListenSocket.h>
+#include <Utility.h>
+
+#define BUFSZ 7024
+
+#ifdef _WIN32
+#define MIN(a,b) (a<b?a:b)
+
+#endif
+
+static int quit = 0;
+static size_t lim = 120000;
+
+
+class CopySocket : public TcpSocket
+{
+public:
+ CopySocket(ISocketHandler& h) : TcpSocket(h), m_fil(NULL), m_out(NULL), m_b_server(false), m_sz(0) {
+ SetTransferLimit(60000);
+ }
+ CopySocket(ISocketHandler& h, size_t sz) : TcpSocket(h), m_fil(NULL), m_out(NULL), m_b_server(false), m_sz(sz) {
+ SetTransferLimit(60000);
+ quit++;
+ }
+ CopySocket(ISocketHandler& h, const std::string& filename) : TcpSocket(h), m_filename(filename), m_fil(NULL), m_out(NULL), m_b_server(false), m_sz(0) {
+ SetTransferLimit(60000);
+ quit++;
+ }
+ ~CopySocket() {
+ quit--;
+ }
+
+ void OnConnect() {
+ Utility::GetTime(&m_start);
+ if (!m_filename.size())
+ {
+ Send("\n");
+ char buf[BUFSZ];
+ int n = MIN(m_sz, BUFSZ);
+ while (n > 0 && GetOutputLength() < lim)
+ {
+ SendBuf(buf, n);
+ m_sz -= n;
+ n = MIN(m_sz, BUFSZ);
+ }
+ if (!n)
+ {
+ SetCloseAndDelete();
+ }
+ else
+ {
+ SendBuf(buf, n);
+ m_sz -= n;
+ }
+ return;
+ }
+ size_t x = 0;
+ for (size_t i = 0; i < m_filename.size(); i++)
+ if (m_filename[i] == '/')
+ x = i + 1;
+ Send(m_filename.substr(x) + "\n");
+ m_fil = fopen(m_filename.c_str(), "rb");
+ if (m_fil)
+ {
+ char buf[BUFSZ];
+ int n = fread(buf, 1, BUFSZ, m_fil);
+ while (n > 0 && GetOutputLength() < lim)
+ {
+ SendBuf(buf, n);
+ n = fread(buf, 1, BUFSZ, m_fil);
+ }
+ if (!n)
+ {
+ SetCloseAndDelete();
+ fclose(m_fil);
+ m_fil = NULL;
+ }
+ else
+ {
+ SendBuf(buf, n);
+ }
+ }
+ }
+
+ void OnWriteComplete() {
+ }
+
+ void OnTransferLimit() {
+ if (!m_filename.size())
+ {
+ char buf[BUFSZ];
+ int n = MIN(m_sz, BUFSZ);
+ while (n > 0 && GetOutputLength() < lim)
+ {
+ SendBuf(buf, n);
+ m_sz -= n;
+ n = MIN(m_sz, BUFSZ);
+ }
+ if (!n)
+ {
+ SetCloseAndDelete();
+ }
+ else
+ {
+ SendBuf(buf, n);
+ m_sz -= n;
+ }
+ return;
+ }
+ if (m_fil)
+ {
+ char buf[BUFSZ];
+ int n = fread(buf, 1, BUFSZ, m_fil);
+ while (n > 0 && GetOutputLength() < lim)
+ {
+ SendBuf(buf, n);
+ n = fread(buf, 1, BUFSZ, m_fil);
+ }
+ if (!n)
+ {
+ SetCloseAndDelete();
+ fclose(m_fil);
+ m_fil = NULL;
+ }
+ else
+ {
+ SendBuf(buf, n);
+ }
+ }
+ }
+
+ void OnAccept() {
+ Utility::GetTime(&m_start);
+ m_b_server = true;
+ SetLineProtocol();
+ DisableInputBuffer();
+ }
+
+ void OnLine(const std::string& line) {
+ if (line.size())
+ m_out = fopen(line.c_str(), "wb");
+ SetLineProtocol(false);
+ DisableInputBuffer();
+ }
+
+ void OnDelete() {
+ struct timeval stop;
+ Utility::GetTime(&stop);
+ stop.tv_sec -= m_start.tv_sec;
+ stop.tv_usec -= m_start.tv_usec;
+ if (stop.tv_usec < 0)
+ {
+ stop.tv_usec += 1000000;
+ stop.tv_sec -= 1;
+ }
+ double t = stop.tv_usec;
+ t /= 1000000;
+ t += stop.tv_sec;
+ printf("OnDelete: %s\n", m_b_server ? "SERVER" : "CLIENT");
+ printf(" Time: %ld.%06ld (%f)\n", stop.tv_sec, stop.tv_usec, t);
+ double r = GetBytesReceived();
+ printf(" bytes in: %lld (%f Mbytes/sec)\n", GetBytesReceived(), r / t / 1000000);
+ double s = GetBytesSent();
+ printf(" bytes out: %lld (%f Mbytes/sec)\n", GetBytesSent(), s / t / 1000000);
+ printf("\n");
+ if (m_out)
+ fclose(m_out);
+ }
+
+ void OnRawData(const char *buf, size_t len) {
+ if (m_out)
+ fwrite(buf, 1, len, m_out);
+ }
+
+private:
+ std::string m_filename;
+ FILE *m_fil;
+ FILE *m_out;
+ bool m_b_server;
+ struct timeval m_start;
+ size_t m_sz;
+};
+
+
+int main(int argc, char *argv[])
+{
+ std::string host = "127.0.0.1";
+ int port = 12344;
+ std::list<std::string> filenames;
+
+ for (int i = 1; i < argc; i++)
+ {
+ if (!strcmp(argv[i], "-host") && i < argc - 1)
+ host = argv[++i];
+ else
+ if (!strcmp(argv[i], "-port") && i < argc - 1)
+ port = atoi(argv[++i]);
+ else
+ if (!strcmp(argv[i], "-h"))
+ {
+ fprintf(stderr, "Usage: %s [-host <host>] [-port <port>] [<file to send>]\n", *argv);
+ fprintf(stderr, " Will run as host only if <file to send> isn't specified.\n");
+ fprintf(stderr, " host default: 127.0.0.1\n");
+ fprintf(stderr, " port default: 12344\n");
+ return 0;
+ }
+ else
+ {
+ filenames.push_back( argv[i] );
+ }
+ }
+
+ try
+ {
+ SocketHandler h;
+ ListenSocket<CopySocket> l(h);
+ if (filenames.empty())
+ {
+ if (l.Bind( port ) != 0)
+ {
+ fprintf(stderr, "Bind() port %d failed - exiting\n", port);
+ return -1;
+ }
+ h.Add(&l);
+ }
+ for (std::list<std::string>::iterator it = filenames.begin(); it != filenames.end(); it++)
+ {
+ std::string filename = *it;
+ size_t sz = atol(filename.c_str());
+ if (sz)
+ {
+ CopySocket *sock = new CopySocket(h, sz);
+ sock -> SetDeleteByHandler();
+ sock -> Open(host, port);
+ h.Add(sock);
+ }
+ else
+ {
+ CopySocket *sock = new CopySocket(h, filename);
+ sock -> SetDeleteByHandler();
+ sock -> Open(host, port);
+ h.Add(sock);
+ }
+ }
+ if (!filenames.size())
+ {
+ fprintf(stderr, "Starting as server only, listening on port %d\n", port);
+ quit++;
+ }
+ while (quit > 0)
+ {
+ h.Select(5, 0);
+ }
+ return 0;
+ }
+ catch (const Exception& e)
+ {
+ printf("%s\n", e.ToString().c_str());
+ }
+}
+
+
diff --git a/src/Sockets/tests/crlf.cpp b/src/Sockets/tests/crlf.cpp
new file mode 100644
index 0000000..34500c4
--- /dev/null
+++ b/src/Sockets/tests/crlf.cpp
@@ -0,0 +1,139 @@
+#include <TcpSocket.h>
+#include <SocketHandler.h>
+#include <ListenSocket.h>
+
+
+static bool quit = false;
+
+
+class IOSocket : public TcpSocket
+{
+public:
+ IOSocket(ISocketHandler& h) : TcpSocket(h) {
+ SetLineProtocol();
+ }
+ ~IOSocket() {}
+
+ void OnConnect() {
+ Utility::GetTime(&m_start);
+ while (GetOutputLength() < 500000)
+ {
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk54\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk543\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk54\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk543\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk54\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk543\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk54\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk543\r\n");
+ }
+// Send("\r\n");
+ }
+
+ void OnAccept() {
+ SetLineProtocol();
+ }
+
+ void OnDelete() {
+ printf("OnDelete\n");
+ }
+
+ void OnWriteComplete() {
+printf("OnWriteComplete\n");
+ struct timeval tv;
+ Utility::GetTime(&tv);
+
+ tv.tv_sec -= m_start.tv_sec;
+ tv.tv_usec -= m_start.tv_usec;
+ Utility::GetTime(&m_start);
+ if (tv.tv_usec < 0)
+ {
+ tv.tv_usec += 1000000;
+ tv.tv_sec -= 1;
+ }
+ double t = tv.tv_usec;
+ t /= 1000000;
+ t += tv.tv_sec;
+ printf(" Time: %ld.%06ld (%f)\n", tv.tv_sec, tv.tv_usec, t);
+ double r = GetBytesReceived();
+ printf(" bytes in: %lld (%f Mbytes/sec)\n", GetBytesReceived(true), r / t / 1000000);
+ double s = GetBytesSent();
+ printf(" bytes out: %lld (%f Mbytes/sec)\n", GetBytesSent(true), s / t / 1000000);
+ printf("\n");
+
+ while (GetOutputLength() < 500000)
+ {
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk54\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk543\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk54\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk543\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk54\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk543\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk54\r\n");
+ Send("zzzzzzzzzmmmmmmmmm1234lkkk543\r\n");
+ }
+// Send("\r\n");
+ }
+
+ void OnLine(const std::string& line) {
+ if (line == "")
+ {
+ struct timeval tv;
+ Utility::GetTime(&tv);
+
+ tv.tv_sec -= m_start.tv_sec;
+ tv.tv_usec -= m_start.tv_usec;
+ Utility::GetTime(&m_start);
+ if (tv.tv_usec < 0)
+ {
+ tv.tv_usec += 1000000;
+ tv.tv_sec -= 1;
+ }
+ double t = tv.tv_usec;
+ t /= 1000000;
+ t += tv.tv_sec;
+ printf(" Time: %ld.%06ld (%f)\n", tv.tv_sec, tv.tv_usec, t);
+ double r = GetBytesReceived();
+ printf(" bytes in: %lld (%f Mbytes/sec)\n", GetBytesReceived(true), r / t / 1000000);
+ double s = GetBytesSent();
+ printf(" bytes out: %lld (%f Mbytes/sec)\n", GetBytesSent(true), s / t / 1000000);
+ printf("\n");
+
+ }
+ else
+ if (line != "zzzzzzzzzmmmmmmmmm1234lkkk54" &&
+ line != "zzzzzzzzzmmmmmmmmm1234lkkk543")
+ {
+printf("\n-------------------------------------------------------\n");
+ for (size_t i = 0; i < line.size(); i++)
+ if (!isprint(line[i]))
+ printf("<%d>", line[i]);
+ else
+ printf("%c", line[i]);
+ printf("\n");
+fflush(stdout);
+exit(-1);
+ quit = true;
+ }
+ }
+
+ struct timeval m_start;
+};
+
+
+int main(int argc, char *argv[])
+{
+ SocketHandler h;
+ ListenSocket<IOSocket> l(h);
+ l.Bind(12344);
+ h.Add(&l);
+ IOSocket sock(h);
+ sock.Open("192.168.7.4", 12344);
+ h.Add(&sock);
+ while (!quit)
+ {
+ h.Select(1, 0);
+ }
+}
+
+
diff --git a/src/Sockets/tests/echoserver.cpp b/src/Sockets/tests/echoserver.cpp
new file mode 100644
index 0000000..45cb6c2
--- /dev/null
+++ b/src/Sockets/tests/echoserver.cpp
@@ -0,0 +1,237 @@
+/**
+ ** \file echoserver.cpp
+ ** \date 2006-10-02
+ ** \author grymse@alhem.net
+**/
+/*
+Copyright (C) 2006 Anders Hedstrom
+
+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.
+*/
+#ifdef _WIN32
+#pragma warning(disable:4786)
+#endif
+#include <StdoutLog.h>
+#include <ListenSocket.h>
+#include <SocketHandler.h>
+#include <TcpSocket.h>
+#ifndef _WIN32
+#include <signal.h>
+#endif
+#include <HttpDebugSocket.h>
+
+
+#ifdef ENABLE_DETACH
+static bool g_b_detach = false;
+#endif
+#ifdef HAVE_OPENSSL
+static bool g_b_ssl = false;
+#endif
+static std::string gFilename = "server.pem";
+static std::string gPw;
+static bool quit = false;
+static bool g_b_http = false;
+static bool g_b_nobuf = false;
+#ifdef ENABLE_DETACH
+static bool g_b_detach2 = false;
+#endif
+
+#define DEB(x)
+
+
+class MySocket : public TcpSocket
+{
+public:
+ MySocket(ISocketHandler& h) : TcpSocket(h) {
+ SetLineProtocol();
+#ifdef HAVE_OPENSSL
+ if (g_b_ssl)
+ EnableSSL();
+#endif
+ if (g_b_nobuf)
+ DisableInputBuffer();
+ }
+ ~MySocket() {
+ }
+
+ void OnAccept() {
+#ifdef ENABLE_DETACH
+ if (g_b_detach)
+ {
+ if (!Detach())
+ fprintf(stderr, "\nDetach failed\n");
+ }
+#endif
+ }
+
+ void OnRawData(const char *buf,size_t len) {
+ if (g_b_nobuf)
+ {
+ SendBuf(buf, len);
+ }
+ }
+
+ void OnLine(const std::string& line) {
+#ifdef ENABLE_DETACH
+ if (g_b_detach2 && !IsDetach())
+ {
+ m_line = line;
+ if (!Detach())
+ {
+ fprintf(stderr, "\nDetach failed\n");
+ }
+ return;
+ }
+DEB(printf("fd %d OnLine; %s\n", GetSocket(), Handler().IsSlave() ? "slave" : "master");)
+#endif
+ Send(line + "\n");
+ }
+
+ void OnDetached() {
+DEB(printf("fd %d OnDetached; %s\n", GetSocket(), Handler().IsSlave() ? "slave" : "master");)
+// fprintf(stderr, "-");
+// fflush(stderr);
+#ifdef ENABLE_DETACH
+ if (g_b_detach2)
+ {
+ Send(m_line + "\n");
+ }
+#endif
+ }
+
+#ifdef HAVE_OPENSSL
+ void InitSSLServer() {
+ InitializeContext("echoserver", gFilename, gPw, SSLv23_method());
+ }
+#endif
+
+private:
+ std::string m_line;
+};
+
+
+#ifndef _WIN32
+void sigint(int)
+{
+ quit = true;
+}
+#endif
+
+int main(int argc,char *argv[])
+{
+#ifndef _WIN32
+ signal(SIGPIPE, SIG_IGN);
+ signal(SIGINT, sigint);
+#endif
+ port_t port = 2222;
+ bool enableLog = false;
+ int queue = 20;
+ for (int i = 1; i < argc; i++)
+ {
+#ifdef ENABLE_DETACH
+ if (!strcmp(argv[i], "-detach"))
+ g_b_detach = true;
+ if (!strcmp(argv[i], "-detach2"))
+ g_b_detach2 = true;
+#endif
+#ifdef HAVE_OPENSSL
+ if (!strcmp(argv[i], "-ssl"))
+ g_b_ssl = true;
+ if (!strcmp(argv[i], "-file") && i < argc - 1)
+ gFilename = argv[++i];
+#endif
+ if (!strcmp(argv[i], "-port") && i < argc - 1)
+ port = atoi(argv[++i]);
+ if (!strcmp(argv[i], "-pw") && i < argc - 1)
+ gPw = argv[++i];
+ if (!strcmp(argv[i], "-log"))
+ enableLog = true;
+ if (!strcmp(argv[i], "-queue") && i < argc - 1)
+ queue = atoi(argv[++i]);
+ if (!strcmp(argv[i], "-http"))
+ g_b_http = true;
+ if (!strcmp(argv[i], "-nobuf"))
+ g_b_nobuf = true;
+ if (!strcmp(argv[i], "-h"))
+ {
+ printf("Usage: %s [ options ] [-ssl]\n", *argv);
+ printf(" -port nn listen on port nn\n");
+#ifdef ENABLE_DETACH
+ printf(" -detach detach each socket on accept\n");
+ printf(" -detach2 detach when line received\n");
+#endif
+#ifdef HAVE_OPENSSL
+ printf(" -ssl run as ssl server, .pem file needed\n");
+ printf(" -file xx .pem filename, default is \"server.pem\"\n");
+#endif
+ printf(" -pw xx private key password\n");
+ printf(" -log enable sockethandler debug log\n");
+ printf(" -queue nn listen queue size (default 20)\n");
+ printf(" -http enable http server with dummy response\n");
+ printf(" -nobuf echo raw data\n");
+ exit(-1);
+ }
+ }
+ if (g_b_http && g_b_nobuf)
+ {
+ printf("Nobuf and Http does not work together\n");
+ exit(-1);
+ }
+ StdoutLog *log = enableLog ? new StdoutLog() : NULL;
+ SocketHandler h(log);
+ ListenSocket<MySocket> l(h);
+ ListenSocket<HttpDebugSocket> l2(h);
+ if (!g_b_http)
+ {
+ if (l.Bind(port, queue))
+ {
+ fprintf(stderr, "Bind to port %d failed\n", port);
+ return -1;
+ }
+ fprintf(stderr, "Listening on port %d\n", port);
+ h.Add(&l);
+ }
+ else
+ {
+ printf("Enable HttpDebugSocket\n");
+ if (l2.Bind(port, queue))
+ {
+ fprintf(stderr, "Bind to port %d failed\n", port);
+ return -1;
+ }
+ fprintf(stderr, "Listening on port %d\n", port);
+ h.Add(&l2);
+ }
+#ifdef ENABLE_DETACH
+ if (g_b_detach)
+ fprintf(stderr, "Will detach each incoming socket\n");
+#endif
+#ifdef HAVE_OPENSSL
+ if (g_b_ssl)
+ fprintf(stderr, "Using SSL\n");
+#endif
+ while (!quit)
+ {
+ h.Select(1, 0);
+ }
+ fprintf(stderr, "\nExiting...\n");
+ if (log)
+ {
+// delete log;
+ }
+ return 0;
+}
+
+
diff --git a/src/Sockets/tests/events.cpp b/src/Sockets/tests/events.cpp
new file mode 100644
index 0000000..5d08973
--- /dev/null
+++ b/src/Sockets/tests/events.cpp
@@ -0,0 +1,212 @@
+#include <EventHandler.h>
+#include <TcpSocket.h>
+#include <IEventOwner.h>
+#include <ListenSocket.h>
+#include <StdoutLog.h>
+#include <iostream>
+
+
+double start;
+
+double gettime()
+{
+ struct timeval tv;
+ Utility::GetTime(&tv);
+ return tv.tv_sec + (double)tv.tv_usec / 1000000;
+}
+
+
+class MyEvHandler : public EventHandler
+{
+public:
+ MyEvHandler() : EventHandler() {}
+ MyEvHandler(StdLog *p) : EventHandler(p) {}
+
+};
+
+
+class EvThread : public Thread
+{
+public:
+ EvThread(Socket *p) : m_socket(p) {}
+
+ void Run();
+
+private:
+ Socket *m_socket;
+};
+
+
+class EvSocket : public TcpSocket, public IEventOwner
+{
+public:
+ EvSocket(ISocketHandler& h) : TcpSocket(h)
+ , IEventOwner( static_cast<MyEvHandler&>(h) ) {
+ }
+
+ void OnEvent(int id) {
+ std::cout << "OnEvent" << std::endl;
+ std::cout << gettime() - start << std::endl;
+ SetCloseAndDelete();
+ }
+
+ void OnAccept() {
+ std::cout << "Incoming" << std::endl;
+ }
+
+ void OnConnect() {
+ std::cout << "Connected" << std::endl;
+ EvThread *thr = new EvThread( this );
+ thr -> SetDeleteOnExit();
+ }
+
+ void OnDelete() {
+ std::cout << "EvSocket::OnDelete()" << std::endl;
+ }
+};
+
+
+void EvThread::Run()
+{
+ Socket *p0 = (Socket *)m_socket;
+ EvSocket *p = dynamic_cast<EvSocket *>(p0);
+ if (p)
+ {
+#ifdef _WIN32
+ Sleep( 5000 );
+#else
+ sleep(10);
+#endif
+ std::cout << "Add event" << std::endl;
+ start = gettime();
+ p -> AddEvent(1, 50000);
+ }
+ else
+ {
+ std::cout << "Thread: not an EvSocket" << std::endl;
+ }
+}
+
+
+//------------------------------------------------------------
+// myTimer class
+//------------------------------------------------------------
+class myTimer : public IEventOwner
+{
+public:
+ // Prototype of user call back function
+ typedef void (*myTimer_cb)(myTimer* user_func, void* user_id);
+
+ myTimer(IEventHandler& h, long ssec, long susec,
+ long psec, long pusec, myTimer_cb func, void* id);
+ ~myTimer();
+
+private:
+ void OnEvent(int id);
+ long ssec_;
+ long susec_;
+ long psec_;
+ long pusec_;
+ myTimer_cb user_func_;
+ void* user_id_;
+ bool periodic_;
+};
+
+
+//------------------------------------------------------------
+myTimer::myTimer(IEventHandler& h, long ssec, long susec,
+ long psec, long pusec, myTimer_cb user_func,
+ void* user_id) :
+ IEventOwner(h),
+ ssec_(ssec),
+ susec_(susec),
+ psec_(psec),
+ pusec_(pusec),
+ user_func_(user_func),
+ user_id_(user_id),
+ periodic_(psec != 0 || pusec != 0)
+{
+ AddEvent(ssec_, susec_);
+}
+
+
+//------------------------------------------------------------
+myTimer::~myTimer()
+{
+ ClearEvents();
+}
+
+
+//------------------------------------------------------------
+void myTimer::OnEvent(int id)
+{
+ if (periodic_)
+ {
+ int n = AddEvent(psec_, pusec_);
+ }
+
+ user_func_(this, user_id_);
+
+ if (!periodic_)
+ {
+ delete this;
+ }
+}
+
+
+//------------------------------------------------------------
+static void myfunc(myTimer* t, void* user_id)
+{
+ printf("Event %s\n", (char*)user_id);
+}
+
+
+/*
+int main(int argc, char *argv[])
+{
+ EventHandler h;
+
+ // Example 1: Create a 2 sec one-shot timer.
+ // No need to save the pointer as it will delete
+ // itself upon expiry.
+ new myTimer(h, 2, 0, 0, 0, myfunc, (void*)"My Timer 0");
+
+ // Example 2: Create a 1 sec periodic timer.
+ // Save the pointer because we can stop the timer
+ // later with a "delete mytimer".
+ myTimer* mytimer = new myTimer(h, 0, 0, 1, 0, myfunc,
+ (void*)"My Timer 1");
+
+ // Drop into the event handler ..
+ h.EventLoop();
+}
+*/
+
+
+int main(int argc, char *argv[])
+{
+ StdoutLog log;
+ MyEvHandler h(&log);
+ ListenSocket<EvSocket> l(h);
+ l.Bind("localhost", 12344);
+ h.Add(&l);
+
+ EvSocket sock(h);
+ sock.Open("localhost", 12344);
+ h.Add(&sock);
+
+ // Example 1: Create a 2 sec one-shot timer.
+ // No need to save the pointer as it will delete
+ // itself upon expiry.
+ new myTimer(h, 2, 0, 0, 0, myfunc, (void*)"My Timer 0");
+
+ // Example 2: Create a 1 sec periodic timer.
+ // Save the pointer because we can stop the timer
+ // later with a "delete mytimer".
+ myTimer* mytimer = new myTimer(h, 0, 0, 1, 0, myfunc,
+ (void*)"My Timer 1");
+
+ h.EventLoop();
+}
+
+
diff --git a/src/Sockets/tests/http.cpp b/src/Sockets/tests/http.cpp
new file mode 100644
index 0000000..6800699
--- /dev/null
+++ b/src/Sockets/tests/http.cpp
@@ -0,0 +1,65 @@
+#include <HTTPSocket.h>
+#include <SocketHandler.h>
+
+
+class tSocket : public HTTPSocket
+{
+public:
+ tSocket(ISocketHandler& h, const std::string& host) : HTTPSocket(h), m_host(host)
+ , m_first(false)
+ , m_sz(0) {
+ Open(host, 80);
+ }
+
+ void OnConnect() {
+ Send("GET /index.html HTTP/1.0\r\n");
+ Send("Host: " + m_host + "\r\n");
+ Send("\r\n");
+ }
+
+ void OnFirst() {
+ }
+
+ void OnHeader(const std::string& key, const std::string& value) {
+ fprintf(stderr, "%s: %s\n", key.c_str(), value.c_str());
+ }
+
+ void OnHeaderComplete() {
+ fprintf(stderr, "\n");
+ }
+
+ void OnData(const char *buf, size_t sz) {
+ if (1||!m_first)
+ {
+ std::string str = buf;
+ str.resize( sz );
+ printf("%s", str.c_str());
+ m_first = true;
+ }
+ m_sz += sz;
+ }
+
+ void OnDelete() {
+ fprintf(stderr, "Content length: %d\n", m_sz);
+ }
+
+private:
+ std::string m_host;
+ bool m_first;
+ size_t m_sz;
+};
+
+
+int main(int argc, char *argv[])
+{
+ std::string host = argc > 1 ? argv[1] : "www.alhem.net";
+ SocketHandler h;
+ tSocket sock(h, host);
+ h.Add(&sock);
+ while (h.GetCount())
+ {
+ h.Select(1, 0);
+ }
+}
+
+
diff --git a/src/Sockets/tests/http_post.cpp b/src/Sockets/tests/http_post.cpp
new file mode 100644
index 0000000..3b0b830
--- /dev/null
+++ b/src/Sockets/tests/http_post.cpp
@@ -0,0 +1,107 @@
+#include <HttpdSocket.h>
+#include <SocketHandler.h>
+#include <ListenSocket.h>
+#include <StdoutLog.h>
+#include <HttpPostSocket.h>
+#include <HttpPutSocket.h>
+#include <HttpdForm.h>
+
+
+class sSocket : public HttpdSocket
+{
+public:
+ sSocket(ISocketHandler& h) : HttpdSocket(h) {
+ }
+
+ void Init()
+ {
+ if (GetParent() -> GetPort() == 443 || GetParent() -> GetPort() == 8443)
+ {
+#ifdef HAVE_OPENSSL
+ EnableSSL();
+#else
+ fprintf(stderr, "SSL not available\n");
+#endif
+ }
+ }
+
+ void Exec()
+ {
+ std::string name;
+ std::string value;
+ GetForm() -> getfirst(name, value);
+ while (name.size())
+ {
+fprintf(stderr, "%s: '%s'\n", name.c_str(), value.c_str());
+ GetForm() -> getnext(name, value);
+ }
+ CreateHeader();
+ GenerateDocument();
+ }
+
+ void CreateHeader()
+ {
+ SetStatus("200");
+ SetStatusText("OK");
+fprintf(stderr, "Uri: '%s'\n", GetUri().c_str());
+ {
+ size_t x = 0;
+ for (size_t i = 0; i < GetUri().size(); i++)
+ if (GetUri()[i] == '.')
+ x = i;
+ std::string ext = GetUri().substr(x + 1);
+ if (ext == "gif" || ext == "jpg" || ext == "png")
+ AddResponseHeader("Content-type", "image/" + ext);
+ else
+ AddResponseHeader("Content-type", "text/" + ext);
+ }
+ AddResponseHeader("Connection", "close");
+ SendResponse();
+ }
+
+ void GenerateDocument()
+ {
+ Send("<html></html>");
+ SetCloseAndDelete();
+ }
+
+#ifdef HAVE_OPENSSL
+ void InitSSLServer()
+ {
+ InitializeContext("httpd", "comb.pem", "", SSLv23_method());
+ }
+#endif
+
+};
+
+
+int main(int argc, char *argv[])
+{
+ std::string host = argc > 1 ? argv[1] : "www.alhem.net";
+ StdoutLog log;
+ SocketHandler h(&log);
+ ListenSocket<sSocket> l(h);
+ if (l.Bind(1028))
+ {
+ printf("Bind port 1028 failed\n");
+ return -1;
+ }
+ h.Add(&l);
+ ListenSocket<sSocket> l2(h);
+ if (l2.Bind(8443))
+ {
+ printf("Bind port 8443 failed\n");
+ return -1;
+ }
+ h.Add(&l2);
+ HttpPostSocket sock(h, "http://localhost:1028/postdata");
+ sock.AddField("name", "value");
+ sock.Open();
+ h.Add(&sock);
+ while (h.GetCount())
+ {
+ h.Select(1, 0);
+ }
+}
+
+
diff --git a/src/Sockets/tests/httpd.cpp b/src/Sockets/tests/httpd.cpp
new file mode 100644
index 0000000..e1106a0
--- /dev/null
+++ b/src/Sockets/tests/httpd.cpp
@@ -0,0 +1,109 @@
+#include <HttpdSocket.h>
+#include <SocketHandler.h>
+#include <ListenSocket.h>
+#include <StdoutLog.h>
+
+
+class sSocket : public HttpdSocket
+{
+public:
+ sSocket(ISocketHandler& h) : HttpdSocket(h) {
+ }
+
+ void Init()
+ {
+ if (GetParent() -> GetPort() == 443 || GetParent() -> GetPort() == 8443)
+ {
+#ifdef HAVE_OPENSSL
+ EnableSSL();
+#else
+ fprintf(stderr, "SSL not available\n");
+#endif
+ }
+ }
+
+ void Exec()
+ {
+ CreateHeader();
+ GenerateDocument();
+ }
+
+ void CreateHeader()
+ {
+ SetStatus("200");
+ SetStatusText("OK");
+fprintf(stderr, "Uri: '%s'\n", GetUri().c_str());
+ {
+ size_t x = 0;
+ for (size_t i = 0; i < GetUri().size(); i++)
+ if (GetUri()[i] == '.')
+ x = i;
+ std::string ext = GetUri().substr(x + 1);
+ if (ext == "gif" || ext == "jpg" || ext == "png")
+ AddResponseHeader("Content-type", "image/" + ext);
+ else
+ AddResponseHeader("Content-type", "text/" + ext);
+ }
+ AddResponseHeader("Connection", "close");
+ SendResponse();
+ }
+
+ void GenerateDocument()
+ {
+ std::string fn = GetUri().substr(1);
+ FILE *fil = fopen(fn.c_str(), "rb");
+ if (fil)
+ {
+ char slask[1000];
+ int n = fread(slask,1,1000,fil);
+ while (n > 0)
+ {
+ SendBuf(slask, n);
+ n = fread(slask,1,1000,fil);
+ }
+ fclose(fil);
+ }
+ else
+ {
+ SetStatus("404");
+ SetStatusText("Not Found");
+ }
+ SetCloseAndDelete();
+ }
+
+#ifdef HAVE_OPENSSL
+ void InitSSLServer()
+ {
+ InitializeContext("httpd", "comb.pem", "", SSLv23_method());
+ }
+#endif
+
+};
+
+
+int main(int argc, char *argv[])
+{
+ std::string host = argc > 1 ? argv[1] : "www.alhem.net";
+ StdoutLog log;
+ SocketHandler h(&log);
+ ListenSocket<sSocket> l(h);
+ if (l.Bind(1028))
+ {
+ printf("Bind port 1028 failed\n");
+ return -1;
+ }
+ h.Add(&l);
+ ListenSocket<sSocket> l2(h);
+ if (l2.Bind(8443))
+ {
+ printf("Bind port 8443 failed\n");
+ return -1;
+ }
+ h.Add(&l2);
+ while (h.GetCount())
+ {
+ h.Select(1, 0);
+ }
+}
+
+
diff --git a/src/Sockets/tests/https.cpp b/src/Sockets/tests/https.cpp
new file mode 100644
index 0000000..45b36ff
--- /dev/null
+++ b/src/Sockets/tests/https.cpp
@@ -0,0 +1,113 @@
+#include <HTTPSocket.h>
+#include <SocketHandler.h>
+#include <ListenSocket.h>
+#include <Exception.h>
+
+
+class tSocket : public HTTPSocket
+{
+public:
+ tSocket(ISocketHandler& h) : HTTPSocket(h)
+ , m_first(false)
+ , m_sz(0) {
+ EnableSSL();
+ }
+
+ tSocket(ISocketHandler& h, const std::string& host) : HTTPSocket(h), m_host(host)
+ , m_first(false)
+ , m_sz(0) {
+ EnableSSL();
+ Open(host, 4443);
+ }
+
+ void InitSSLServer() {
+ InitializeContext("", "comb.pem", "", SSLv23_method());
+ }
+
+ void OnSSLAccept() {
+ printf("OnSSLAccept()\n");
+ HTTPSocket::OnSSLAccept();
+ }
+
+ void OnSSLConnect() {
+ printf("OnSSLConnect()\n");
+ HTTPSocket::OnSSLConnect();
+ }
+
+ void OnAccept() {
+printf("OnAccept\n");
+ }
+
+ void OnConnect() {
+printf("OnConnect\n");
+ Send("GET /index.html HTTP/1.0\r\n");
+ Send("Host: " + m_host + "\r\n");
+ Send("\r\n");
+ }
+
+ void OnFirst() {
+ }
+
+ void OnHeader(const std::string& key, const std::string& value) {
+ fprintf(stderr, "%s: %s\n", key.c_str(), value.c_str());
+ }
+
+ void OnHeaderComplete() {
+ fprintf(stderr, "\n");
+ }
+
+ void OnData(const char *buf, size_t sz) {
+ if (1||!m_first)
+ {
+ std::string str = buf;
+ str.resize( sz );
+ printf("%s", str.c_str());
+ m_first = true;
+ }
+ m_sz += sz;
+ }
+
+ void OnDelete() {
+ fprintf(stderr, "Content length: %d\n", m_sz);
+ }
+
+private:
+ std::string m_host;
+ bool m_first;
+ size_t m_sz;
+};
+
+
+int main(int argc, char *argv[])
+{
+ try
+ {
+ SocketHandler h;
+ if (argc > 1 && !strcmp(argv[1], "-server"))
+ {
+ ListenSocket<tSocket> l(h);
+ l.Bind(4443);
+ h.Add(&l);
+ while (h.GetCount())
+ {
+ h.Select(1, 0);
+ }
+ }
+ else
+ {
+ std::string host = argc > 1 ? argv[1] : "www.alhem.net";
+ tSocket sock(h, host);
+ h.Add(&sock);
+ while (h.GetCount())
+ {
+ h.Select(1, 0);
+ }
+ }
+ }
+ catch (const Exception& e)
+ {
+ printf("%s\n", e.ToString().c_str());
+ }
+}
+
+
diff --git a/src/Sockets/tests/resolve.cpp b/src/Sockets/tests/resolve.cpp
new file mode 100644
index 0000000..802b910
--- /dev/null
+++ b/src/Sockets/tests/resolve.cpp
@@ -0,0 +1,156 @@
+#include <sys/types.h>
+#ifndef _WIN32
+#include <sys/socket.h>
+#include <netdb.h>
+#endif
+#include <string.h>
+#include <string>
+#include <Utility.h>
+#include <Ipv4Address.h>
+#include <Ipv6Address.h>
+#include <assert.h>
+#include <SocketHandler.h>
+#include <StdoutLog.h>
+
+
+int main(int argc, char *argv[])
+{
+ StdoutLog log;
+ SocketHandler h(&log);
+/*
+ h.EnableResolver(9999);
+
+// printf("Waiting for resolver ...");
+ while (!h.ResolverReady())
+ ;
+// printf(" resolver ready!\n");
+*/
+ std::string hostname = argc < 2 ? "www.ipv6.org" : argv[1];
+
+ {
+ printf("Using hostname : %s\n", hostname.c_str());
+ printf("------------------------------------------- normal (old) Utility::u2ip\n");
+ ipaddr_t oa;
+ if (!Utility::u2ip(hostname, oa))
+ printf("Ipv4 lookup failed\n");
+#ifdef ENABLE_IPV6
+ in6_addr oa6;
+ if (!Utility::u2ip(hostname, oa6))
+ printf("Ipv6 lookup failed\n");
+#endif
+ std::string oname;
+ Utility::l2ip(oa, oname);
+ printf("Ipv4 : %s (old)\n", oname.c_str());
+
+#ifdef ENABLE_IPV6
+ std::string oname6;
+ Utility::l2ip(oa6, oname6);
+ printf("Ipv6 : %s (old)\n", oname6.c_str());
+#endif
+
+ printf("------------------------------------------- new Utility::u2ip, Utility::reverse\n");
+ struct sockaddr_in sa;
+ if (!Utility::u2ip(hostname, sa))
+ printf("Ipv4 lookup failed\n");
+
+ ipaddr_t a;
+ memcpy(&a, &sa.sin_addr, sizeof(a));
+ std::string l2ipname;
+ Utility::l2ip(a, l2ipname);
+ printf("Ipv4 : %s\n", l2ipname.c_str());
+
+ std::string numeric;
+ Utility::reverse((struct sockaddr *)&sa, sizeof(sa), numeric, NI_NUMERICHOST);
+ printf("Ipv4 numeric : %s\n", numeric.c_str());
+
+ std::string rname;
+ if (!Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), rname))
+ printf("Reverse Ipv4 failed\n");
+ else
+ printf("Ipv4 Utility::reverse : %s\n", rname.c_str());
+
+#ifdef ENABLE_IPV6
+ printf("------------------------------------------- new Utility::u2ip, Utility::reverse (Ipv6)\n");
+ struct sockaddr_in6 sa6;
+ if (!Utility::u2ip(hostname, sa6))
+ printf("Ipv6 lookup failed\n");
+
+ std::string l2ipname6;
+ Utility::l2ip(sa6.sin6_addr, l2ipname6);
+ printf("Ipv6 : %s\n", l2ipname6.c_str());
+
+ std::string numeric6;
+ Utility::reverse((struct sockaddr *)&sa6, sizeof(sa6), numeric6, NI_NUMERICHOST);
+ printf("Ipv6 numeric : %s\n", numeric6.c_str());
+
+ std::string rname6;
+ if (!Utility::reverse( (struct sockaddr *)&sa6, sizeof(sa6), rname6))
+ printf("Reverse Ipv6 failed\n");
+ else
+ printf("Ipv6 Utility::reverse : %s\n", rname6.c_str());
+#endif
+
+ printf("-------------------------------------------\n");
+ in_addr ia;
+ /** Resolve hostname. */
+//static bool Resolve(const std::string& hostname,struct in_addr& a);
+ /** Reverse resolve (IP to hostname). */
+//static bool Reverse(struct in_addr& a,std::string& name);
+ /** Convert address struct to text. */
+//static std::string Convert(struct in_addr& a);
+ std::string name;
+ if (!Ipv4Address::Resolve(hostname, ia))
+ printf("Ipv4 lookup failed (Ipv4Address)\n");
+ memcpy(&a, &ia, sizeof(a));
+ Utility::l2ip(a, name);
+ printf("Ipv4 : %s (Ipv4Address)\n", name.c_str());
+ assert(name == l2ipname);
+ if (!Ipv4Address::Reverse(ia, name))
+ printf("Reverse Ipv4 lookup failed (Ipv4Address)\n");
+ else
+ printf("Reverse Ipv4 : %s\n", name.c_str());
+ assert(name == rname);
+ assert(Ipv4Address::Convert(ia) == l2ipname);
+
+#ifdef ENABLE_IPV6
+ printf("-------------------------------------------\n");
+ /** Resolve hostname. */
+//static bool Resolve(const std::string& hostname,struct in6_addr& a);
+ /** Reverse resolve (IP to hostname). */
+//static bool Reverse(struct in6_addr& a,std::string& name);
+ /** Convert address struct to text. */
+//static std::string Convert(struct in6_addr& a,bool mixed = false);
+ if (!Ipv6Address::Resolve(hostname, oa6))
+ printf("Ipv6 lookup failed (Ipv4Address)\n");
+ Utility::l2ip(oa6, name);
+ assert(name == l2ipname6);
+ printf("Ipv6 : %s (Ipv6Address)\n", name.c_str());
+ if (!Ipv6Address::Reverse(oa6, name))
+ printf("Reverse Ipv6 lookup failed (Ipv4Address)\n");
+ else
+ printf("Reverse Ipv6 : %s\n", name.c_str());
+ assert(name == rname6);
+ std::string mixed_false = Ipv6Address::Convert(oa6, false);
+ std::string mixed_true = Ipv6Address::Convert(oa6, true);
+ printf("Ipv6Address::Convert(false) : %s\n", mixed_false.c_str());
+ printf("Ipv6Address::Convert(true ) : %s\n", mixed_true.c_str());
+ assert(mixed_false == l2ipname6);
+#endif
+/*
+ printf("-------------------------------------------\n");
+ int protocol;
+ Utility::u2service("tcp", protocol);
+ printf("tcp: %d\n", protocol);
+ Utility::u2service("udp", protocol);
+ printf("udp: %d\n", protocol);
+ Utility::u2service("echo", protocol);
+ printf("echo: %d\n", protocol);
+*/
+ }
+ printf("\n");
+ printf("OK\n");
+
+// sleep(100);
+}
+
+
diff --git a/src/Sockets/tests/resume.cpp b/src/Sockets/tests/resume.cpp
new file mode 100644
index 0000000..e518109
--- /dev/null
+++ b/src/Sockets/tests/resume.cpp
@@ -0,0 +1,111 @@
+#include <EventHandler.h>
+#include <TcpSocket.h>
+#include <Utility.h>
+#include <IEventOwner.h>
+#include <ListenSocket.h>
+
+
+class eHandler : public EventHandler
+{
+public:
+ eHandler() : EventHandler() {}
+};
+
+
+class eSocket : public TcpSocket, public IEventOwner
+{
+public:
+ eSocket(ISocketHandler& h) : TcpSocket(h), IEventOwner(static_cast<eHandler&>(h)), m_listen_socket(NULL), m_server(false) {
+ SetLineProtocol();
+ }
+
+ bool OnConnectRetry() {
+ printf("Retrying connect\n");
+ if (GetConnectionRetries() == 5)
+ {
+ printf("Creating ListenSocket\n");
+ m_listen_socket = new ListenSocket<eSocket>(Handler());
+ if (m_listen_socket -> Bind(12345))
+ {
+ printf("Bind port 12345 failed\n");
+ }
+ m_listen_socket -> SetDeleteByHandler();
+ Handler().Add( m_listen_socket );
+ }
+ return true;
+ }
+
+ void OnAccept() {
+ m_id_stop_socket = AddEvent(5, 0);
+printf("Stop socket id: %d\n", m_id_stop_socket);
+ m_server = true;
+ }
+
+ void OnConnect() {
+ m_id_stop_listen = AddEvent(10, 0);
+printf("Stop listen id: %d\n", m_id_stop_listen);
+ }
+
+ void OnEvent(int id) {
+printf("Event id: %d\n", id);
+ if (id == m_id_stop_socket && m_server)
+ SetCloseAndDelete();
+ if (id == m_id_stop_listen && !m_server)
+ m_listen_socket -> SetCloseAndDelete();
+ }
+
+ void OnLine(const std::string& line) {
+ printf("Incoming data: %s\n", line.c_str());
+ }
+
+ void OnDelete() {
+ printf("eSocket::OnDelete(), server: %s\n", m_server ? "true" : "false");
+ }
+
+ void OnDisconnect() {
+ printf("Disconnect, server: %s\n", m_server ? "true" : "false");
+ }
+
+private:
+ ListenSocket<eSocket> *m_listen_socket;
+ int m_id_stop_socket;
+ int m_id_stop_listen;
+ bool m_server;
+};
+
+
+class Sender : public IEventOwner
+{
+public:
+ Sender(IEventHandler& h, TcpSocket& ref) : IEventOwner(h), m_socket(ref), m_count(1) {
+ AddEvent(1, 0);
+ }
+
+ void OnEvent(int id) {
+ if (static_cast<eHandler&>(EventHandler()).Valid(&m_socket))
+ m_socket.Send("Event#" + Utility::l2string(m_count++) + "\n");
+ EventHandler().AddEvent(this, 1, 0);
+ }
+
+private:
+ TcpSocket& m_socket;
+ int m_count;
+};
+
+
+int main(int argc, char *argv[])
+{
+ eHandler h;
+ eSocket sock(h);
+ sock.SetConnectTimeout(3);
+ sock.SetConnectionRetry(-1);
+#ifdef ENABLE_RECONNECT
+ sock.SetReconnect();
+#endif
+ sock.Open("localhost", 12345);
+ h.Add( &sock );
+ Sender send(h, sock);
+ h.AddEvent( &send, 1, 0 );
+ h.EventLoop();
+}
+
diff --git a/src/Sockets/tests/retry.cpp b/src/Sockets/tests/retry.cpp
new file mode 100644
index 0000000..36954a6
--- /dev/null
+++ b/src/Sockets/tests/retry.cpp
@@ -0,0 +1,67 @@
+#include <TcpSocket.h>
+#include <SocketHandler.h>
+#include <ListenSocket.h>
+
+
+ bool quit = false;
+
+/*
+ virtual bool OnConnectRetry();
+- void SetRetryClientConnect(bool x = true);
+- bool RetryClientConnect();
+ void SetConnectionRetry(int n);
+ int GetConnectionRetry();
+ void IncreaseConnectionRetries();
+ int GetConnectionRetries();
+ void ResetConnectionRetries();
+*/
+class RetrySocket : public TcpSocket
+{
+public:
+ RetrySocket(ISocketHandler& h) : TcpSocket(h) {
+ SetConnectTimeout(2);
+ SetConnectionRetry(-1);
+ }
+
+ bool OnConnectRetry() {
+ printf("Connection attempt#%d\n", GetConnectionRetries());
+ if (GetConnectionRetries() == 3)
+ {
+ ListenSocket<RetrySocket> *l = new ListenSocket<RetrySocket>(Handler());
+ if (l -> Bind(12345))
+ {
+ printf("Bind port 12345 failed\n");
+ }
+ l -> SetDeleteByHandler();
+ Handler().Add(l);
+ }
+ return true;
+ }
+
+ void OnConnect() {
+ printf("Connected\n");
+ printf("GetRemoteAddress(): %s\n", GetRemoteAddress().c_str());
+ printf("Remote address: %s\n", GetRemoteSocketAddress() -> Convert(false).c_str());
+ printf("Remote address: %s\n", GetRemoteSocketAddress() -> Convert(true).c_str());
+ SetCloseAndDelete();
+ }
+
+ void OnDelete() {
+ quit = true;
+ }
+};
+
+
+int main(int argc, char *argv[])
+{
+ SocketHandler h;
+ RetrySocket sock(h);
+ sock.Open("localhost", 12345);
+ h.Add(&sock);
+ while (!quit)
+ {
+ h.Select(0, 200000);
+ }
+}
+
+
diff --git a/src/Sockets/tests/semtest.cpp b/src/Sockets/tests/semtest.cpp
new file mode 100644
index 0000000..442d5d6
--- /dev/null
+++ b/src/Sockets/tests/semtest.cpp
@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifndef _WIN32
+#include <unistd.h>
+#include <Semaphore.h>
+#include <Mutex.h>
+#include <Thread.h>
+#include <Utility.h>
+#include <Lock.h>
+
+
+class MyThread : public Thread
+{
+public:
+ void Run() {
+ printf("Thread\n");
+ }
+};
+
+
+class SemLock
+{
+public:
+ SemLock(Semaphore& sem) : m_sem(sem) {
+ m_sem.Wait();
+ }
+ ~SemLock() {
+ m_sem.Post();
+ }
+
+private:
+ Semaphore& m_sem;
+};
+
+
+/**
+ * Return time difference between two struct timeval's, in seconds
+ * \param t0 start time
+ * \param t end time
+ */
+double Diff(struct timeval t0,struct timeval t)
+{
+ t.tv_sec -= t0.tv_sec;
+ t.tv_usec -= t0.tv_usec;
+ if (t.tv_usec < 0)
+ {
+ t.tv_usec += 1000000;
+ t.tv_sec -= 1;
+ }
+ return t.tv_sec + (double)t.tv_usec / 1000000;
+}
+
+
+static int val = 0;
+
+void lock(Mutex& m, int i)
+{
+ Lock l(m);
+ val += i;
+}
+
+
+void lock(Semaphore& s, int i)
+{
+ SemLock l(s);
+ val += i;
+}
+#endif // WIN32
+
+
+int main()
+{
+#ifndef _WIN32
+ Mutex mutex;
+ Semaphore sema(1);
+ struct timeval start;
+ struct timeval tt;
+ double d;
+
+ Utility::GetTime(&start);
+ for (int i = 0; i < 100000; i++)
+ lock(mutex, i);
+ Utility::GetTime(&tt);
+ d = Diff(start, tt);
+ printf("%.4f sec\n", d);
+
+ Utility::GetTime(&start);
+ for (int i = 0; i < 100000; i++)
+ lock(sema, i);
+ Utility::GetTime(&tt);
+ d = Diff(start, tt);
+ printf("%.4f sec\n", d);
+#endif
+}
+
+
diff --git a/src/Sockets/tests/sloppy_http.cpp b/src/Sockets/tests/sloppy_http.cpp
new file mode 100644
index 0000000..9ea79c1
--- /dev/null
+++ b/src/Sockets/tests/sloppy_http.cpp
@@ -0,0 +1,55 @@
+#include <SocketHandler.h>
+#include <TcpSocket.h>
+
+
+class GetHttp : public TcpSocket
+{
+public:
+ GetHttp(ISocketHandler& h, const char *request) : TcpSocket(h)
+ , m_request(request) {}
+
+ void OnConnect() {
+ Send( m_request );
+ }
+
+ void OnRawData( const char *buf, size_t len ) {
+ if (len > 0) {
+ std::string tmp;
+ tmp.resize( len );
+ memcpy( &tmp[0], buf, len );
+ m_response += tmp;
+ }
+ }
+
+ const std::string& Response() {
+ return m_response;
+ }
+
+private:
+ std::string m_request;
+ std::string m_response;
+};
+
+
+std::string get_http(const char *host, int port, const char *request)
+{
+ SocketHandler h;
+ GetHttp sock(h, request);
+ sock.Open( host, port );
+ h.Add(&sock);
+ while (h.GetCount()) {
+ h.Select(1, 0);
+ }
+ return sock.Response();
+}
+
+
+int main(int argc, char *argv[])
+{
+ std::string zz = get_http("www.alhem.net", 80, "GET /index.html HTTP/1.0\r\n"
+ "Host: www.alhem.net\r\n"
+ "\r\n");
+ printf("%s\n%d\n", zz.c_str(), zz.size());
+}
+
+
diff --git a/src/Sockets/tests/sockets_test.cpp b/src/Sockets/tests/sockets_test.cpp
new file mode 100644
index 0000000..78fd2bc
--- /dev/null
+++ b/src/Sockets/tests/sockets_test.cpp
@@ -0,0 +1,347 @@
+#ifdef _WIN32
+#pragma warning(disable:4786)
+#endif
+#include <StdoutLog.h>
+#include <SocketHandler.h>
+#include <TcpSocket.h>
+#include <ListenSocket.h>
+#include <Utility.h>
+#include <Parse.h>
+#include <HttpGetSocket.h>
+#include <Socket.h>
+#include <HttpDebugSocket.h>
+
+#ifdef SOCKETS_NAMESPACE
+using namespace SOCKETS_NAMESPACE;
+#endif
+
+
+class MyHandler : public SocketHandler
+{
+public:
+ MyHandler(StdLog *p) : SocketHandler(p),m_done(false),m_quit(false) {}
+ ~MyHandler() {}
+
+ void List(TcpSocket *p) {
+ for (socket_m::iterator it = m_sockets.begin(); it != m_sockets.end(); it++)
+ {
+ Socket *p0 = (*it).second;
+#ifdef ENABLE_POOL
+ if (dynamic_cast<ISocketHandler::PoolSocket *>(p0))
+ {
+ p -> Send("PoolSocket\n");
+ }
+ else
+#endif
+ if (dynamic_cast<HttpGetSocket *>(p0))
+ {
+ p -> Send("HttpGetSocket\n");
+ }
+ else
+ if (dynamic_cast<TcpSocket *>(p0))
+ {
+ p -> Send("TcpSocket\n");
+ }
+ else
+ {
+ p -> Send("Some kind of Socket\n");
+ }
+ bool r;
+ bool w;
+ bool e;
+ Get(p -> GetSocket(), r, w, e);
+ char slask[1000];
+ sprintf(slask," Read: %s Write: %s Exception: %s\n",
+ r ? "SET" : "not set",
+ w ? "SET" : "not set",
+ e ? "SET" : "not set");
+ p -> Send( slask );
+ }
+ }
+ void SetQuit() { m_quit = true; }
+ bool Quit() { return m_quit; }
+ void CheckHtml() {
+ if (m_done)
+ {
+ if (m_ok)
+ printf("Html OK:\n%s\n", m_html.c_str());
+ else
+ printf("Html Failed\n");
+ m_done = false;
+ }
+ }
+
+ std::string m_html;
+ bool m_ok;
+ bool m_done;
+
+private:
+ bool m_quit;
+};
+
+
+class MySocket : public TcpSocket
+{
+public:
+ MySocket(ISocketHandler& h) : TcpSocket(h) {
+ }
+ void OnAccept() {
+ int port = GetParent() -> GetPort();
+ Send("I'm the server at port " +
+ Utility::l2string(port) + "\n");
+ SetCloseAndDelete();
+ }
+};
+
+
+class hSocket : public HttpGetSocket
+{
+public:
+ hSocket(ISocketHandler& h,const std::string& x,const std::string& y) : HttpGetSocket(h,x,y) {}
+
+ void OnConnect() {
+ printf("hSocket::OnConnect\n");
+ HttpGetSocket::OnConnect();
+ }
+};
+
+
+class OrderSocket : public TcpSocket
+{
+public:
+ OrderSocket(ISocketHandler& h) : TcpSocket(h) {
+ SetLineProtocol();
+ }
+ Socket *Create() {
+ Handler().LogError(this, "Create", 0, "OrderSocket", LOG_LEVEL_INFO);
+ return new OrderSocket(Handler());
+ }
+ void OnAccept() {
+ Send("Cmd (get,quit,list,stop,detach,count,resolve <name>)>");
+ }
+ void OnLine(const std::string& line) {
+ Parse pa(line);
+ std::string cmd = pa.getword();
+ std::string arg = pa.getrest();
+ if (cmd == "get")
+ {
+ HttpGetSocket *p = new hSocket(Handler(), arg, "tmpfile.html");
+ p -> SetHttpVersion("HTTP/1.1");
+ p -> AddResponseHeader("Connection", "keep-alive");
+ p -> SetDeleteByHandler();
+ Handler().Add( p );
+ Send("Reading url '" + arg + "'\n");
+ }
+ else
+ if (cmd == "quit")
+ {
+ Send("Goodbye!\n");
+ SetCloseAndDelete();
+ }
+ else
+ if (cmd == "list")
+ {
+ static_cast<MyHandler&>(Handler()).List( this );
+ }
+ else
+ if (cmd == "stop")
+ {
+ static_cast<MyHandler&>(Handler()).SetQuit();
+ }
+ else
+ if (cmd == "resolve")
+ {
+ //Resolve( arg );
+ ipaddr_t a;
+ if (Utility::u2ip(arg, a))
+ {
+ std::string tmp;
+ Utility::l2ip(a, tmp);
+ Send("Resolved: " + tmp + "\n");
+ }
+ else
+ {
+ Send("Resolve failed: " + arg + "\n");
+ }
+ }
+ else
+/*
+ if (cmd == "reverse")
+ {
+ ipaddr_t a;
+ Utility::u2ip(arg, a); // ip -> ipaddr_t
+ int id = Socket::Resolve(a, 0);
+ Send("Resolve id = " + Utility::l2string(id) + "\n");
+ }
+ else
+*/
+#ifdef ENABLE_DETACH
+ if (cmd == "detach")
+ {
+ if (!Detach())
+ {
+ Send("Detach() call failed\n");
+ }
+ else
+ {
+ Send("Ok.\n");
+ }
+ }
+ else
+#endif
+ if (cmd == "count")
+ {
+ Send("Socket count: " + Utility::l2string( (long)Handler().GetCount()) + "\n");
+ }
+ else
+ {
+ Send("Huh?\n");
+ }
+ Send("Cmd>");
+ }
+ void OnDelete() {
+ printf("OrderSocket::OnDelete()\n");
+ }
+#ifdef ENABLE_RESOLVER
+ void OnResolved(int id,ipaddr_t a,port_t port)
+ {
+ }
+ void OnResolved(int id,const std::string& name,port_t port)
+ {
+ Send("Resolve id " + Utility::l2string(id) + " = " + name + "\n");
+ }
+/*
+ void OnResolved(const char *p,size_t l) {
+ printf("OnResolved, %d bytes:\n", l);
+ for (size_t i = 0; i < l; i++)
+ {
+ unsigned char c = p[i];
+ if (isprint(c))
+ printf("%c",c);
+ else
+ printf("<%02X>",c);
+ }
+ printf("\n");
+ }
+*/
+#endif
+#ifdef ENABLE_DETACH
+ void OnDetached() {
+ Send("\nDetached.\nCmd>");
+ }
+#endif
+};
+
+
+class TestSocket : public TcpSocket
+{
+public:
+ TestSocket(ISocketHandler& h) : TcpSocket(h) {
+ SetLineProtocol();
+ }
+ void OnConnect() {
+ printf("TestSocket connected, sending QUIT\n");
+ Send( "quit\n" );
+ }
+ void OnConnectFailed() {
+ printf("TestSocket::OnConnectFailed\n");
+ SetCloseAndDelete();
+ }
+ void OnLine(const std::string& line) {
+ printf("TestSocket: %s\n", line.c_str());
+ }
+ void OnDelete() {
+ printf("TestSocket::OnDelete()\n");
+ }
+#ifdef ENABLE_RESOLVER
+ void OnResolved(int id,ipaddr_t a,port_t port) {
+ printf("TestSocket::OnResolved(): %d, %08x:%d\n", id, a, port);
+ TcpSocket::OnResolved(id,a,port);
+ }
+#endif
+};
+
+
+int main()
+{
+ StdoutLog log;
+ MyHandler h(&log);
+
+#ifdef ENABLE_RESOLVER
+ h.EnableResolver(9999);
+#endif
+// Utility::ResolveLocal();
+ printf(" *** My hostname: %s\n", Utility::GetLocalHostname().c_str());
+ printf(" *** My local IP: %s\n", Utility::GetLocalAddress().c_str());
+
+ // socks4 options
+/*
+ h.SetSocks4Host("127.0.0.1");
+ h.SetSocks4Port(1080);
+ h.SetSocks4Userid("www.alhem.net");
+ h.SetSocks4TryDirect( true );
+ printf("Socks4Host: %x\n", h.GetSocks4Host());
+*/
+
+ // first server
+ ListenSocket<MySocket> l1(h);
+ if (l1.Bind(1024))
+ {
+ printf("Bind 1024 failed\n");
+ exit(-1);
+ }
+ h.Add(&l1);
+
+ // second server
+ ListenSocket<MySocket> l2(h);
+ if (l2.Bind(1025))
+ {
+ printf("Bind 1025 failed\n");
+ exit(-1);
+ }
+ h.Add(&l2);
+
+ // line server
+ ListenSocket<OrderSocket> l3(h);
+ if (l3.Bind(1027))
+ {
+ printf("Bind 1027 failed\n");
+ exit(-1);
+ }
+ h.Add(&l3);
+
+ // http debug
+ ListenSocket<HttpDebugSocket> l4(h);
+ if (l4.Bind(8080))
+ {
+ printf("Bind 8080 failed\n");
+ exit(-1);
+ }
+ h.Add(&l4);
+
+ // wait for resolver to really start
+#ifdef ENABLE_RESOLVER
+ printf("Waiting for resolver ...");
+ while (!h.ResolverReady())
+ ;
+ printf(" resolver ready!\n");
+#endif
+
+ TestSocket ts(h);
+printf(">>> TestSocket.Open\n");
+ ts.Open("localhost", 1027);
+printf(">>> Adding TestSocket\n");
+ h.Add(&ts);
+
+printf(">>> mainloop\n");
+ h.Select(0,0);
+ while (!h.Quit())
+ {
+ h.Select(1,0);
+ h.CheckSanity();
+ }
+
+ return 0;
+}
+
+
diff --git a/src/Sockets/tests/stressclient.cpp b/src/Sockets/tests/stressclient.cpp
new file mode 100644
index 0000000..4187868
--- /dev/null
+++ b/src/Sockets/tests/stressclient.cpp
@@ -0,0 +1,516 @@
+/**
+ ** \file stressclient.cpp
+ ** \date 2006-10-02
+ ** \author grymse@alhem.net
+**/
+/*
+Copyright (C) 2006 Anders Hedstrom
+
+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.
+*/
+#ifdef _WIN32
+#pragma warning(disable:4786)
+#endif
+#include <StdoutLog.h>
+#include <ListenSocket.h>
+#include <SocketHandler.h>
+#include <TcpSocket.h>
+#include <Utility.h>
+#ifndef _WIN32
+#include <signal.h>
+#include <stdint.h>
+#else
+typedef __int64 int64_t;
+#endif
+#include <HttpGetSocket.h>
+
+
+static double g_min_time = 10000;
+static double g_max_time = 0;
+static double g_tot_time = 0;
+static int g_ant = 0;
+static double g_min_time2 = 10000;
+static double g_max_time2 = 0;
+static double g_tot_time2 = 0;
+static int g_ant2 = 0;
+static bool gQuit = false;
+static size_t g_max_connections = 0;
+static std::string gHost = "localhost";
+static port_t gPort = 2222;
+static bool g_b_flood = false;
+static bool g_b_off = false;
+static bool g_b_limit = false;
+static int64_t gBytesIn = 0;
+static int64_t gBytesOut = 0;
+static bool g_b_repeat = false;
+static std::string g_data;
+static size_t g_data_size = 1024;
+static bool g_b_stop = false;
+#ifdef HAVE_OPENSSL
+static bool g_b_ssl = false;
+#endif
+static bool g_b_instant = false;
+static struct timeval g_t_start;
+
+
+/**
+ * Return time difference between two struct timeval's, in seconds
+ * \param t0 start time
+ * \param t end time
+ */
+double Diff(struct timeval t0,struct timeval t)
+{
+ t.tv_sec -= t0.tv_sec;
+ t.tv_usec -= t0.tv_usec;
+ if (t.tv_usec < 0)
+ {
+ t.tv_usec += 1000000;
+ t.tv_sec -= 1;
+ }
+ return t.tv_sec + (double)t.tv_usec / 1000000;
+}
+
+
+void gettime(struct timeval *p, struct timezone *)
+{
+#ifdef _WIN32
+ FILETIME ft; // Contains a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC).
+ GetSystemTimeAsFileTime(&ft);
+ uint64_t tt;
+ memcpy(&tt, &ft, sizeof(tt));
+ tt /= 10;
+ p->tv_sec = tt / 1000000;
+ p->tv_usec = tt % 1000000;
+#else
+ gettimeofday(p, NULL);
+#endif
+}
+
+
+void printreport()
+{
+ struct timeval tv;
+ gettime(&tv, NULL);
+ double rt = Diff(g_t_start, tv);
+ g_t_start = tv;
+ //
+ printf("\n");
+ if (g_ant)
+ printf("connect; ant: %5d min: %.4f max: %.4f med: %.4f\n", g_ant, g_min_time, g_max_time, g_tot_time / g_ant);
+ if (g_ant2)
+ printf("reply; ant: %5d min: %.4f max: %.4f med: %.4f\n", g_ant2, g_min_time2, g_max_time2, g_tot_time2 / g_ant2);
+ double mbi = (double)gBytesIn / 1024;
+ mbi /= 1024;
+ mbi /= rt;
+ double mbo = (double)gBytesOut / 1024;
+ mbo /= 1024;
+ mbo /= rt;
+ printf("bytes in: %lld", gBytesIn);
+ printf(" (%.2f MB/sec)", mbi);
+ printf(" bytes out: %lld", gBytesOut);
+ printf(" (%.2f MB/sec)", mbo);
+ printf(" time: %.2f sec\n", rt);
+}
+
+
+void printreport_reset()
+{
+ printreport();
+ //
+ g_min_time = 10000;
+ g_max_time = 0;
+ g_tot_time = 0;
+ g_ant = 0;
+ g_min_time2 = 10000;
+ g_max_time2 = 0;
+ g_tot_time2 = 0;
+ g_ant2 = 0;
+ gBytesIn = gBytesOut = 0;
+}
+
+
+class MySocket : public TcpSocket
+{
+public:
+ MySocket(ISocketHandler& h,bool one) : TcpSocket(h), m_b_client(false), m_b_one(one), m_b_created(false), m_b_active(false) {
+ gettime(&m_create, NULL);
+ SetLineProtocol();
+#ifdef HAVE_OPENSSL
+ if (g_b_ssl)
+ EnableSSL();
+#endif
+ if (g_max_connections && !m_b_one && Handler().GetCount() >= g_max_connections)
+ {
+ fprintf(stderr, "\nConnection limit reached: %d, continuing in single connection stress mode\n", (int)g_max_connections);
+ if (g_b_off)
+ printreport_reset();
+ g_b_limit = true;
+ m_b_one = true;
+ //
+ g_b_flood = g_b_repeat;
+ }
+ if (!m_b_one && Handler().GetCount() >= FD_SETSIZE - 17)
+ {
+ fprintf(stderr, "\nFD_SETSIZE connection limit reached: %d, continuing in single connection stress mode\n", (int)Handler().GetCount());
+ if (g_b_off)
+ printreport_reset();
+ g_b_limit = true;
+ m_b_one = true;
+ //
+ g_b_flood = g_b_repeat;
+ }
+ }
+ ~MySocket() {
+ }
+
+ void OnConnect() {
+ gettime(&m_connect, NULL);
+ m_b_active = true;
+ {
+ double tconnect = Diff(m_create, m_connect);
+ //
+ g_min_time = tconnect < g_min_time ? tconnect : g_min_time;
+ g_max_time = tconnect > g_max_time ? tconnect : g_max_time;
+ g_tot_time += tconnect;
+ g_ant += 1;
+ }
+ SendBlock();
+ m_b_client = true;
+ }
+
+ void SendBlock() {
+ gettime(&m_send, NULL);
+ Send(g_data + "\n");
+ }
+
+ void OnLine(const std::string& line) {
+ gettime(&m_reply, NULL);
+ m_b_active = true;
+ {
+ double treply = Diff(m_send, m_reply);
+ //
+ g_min_time2 = treply < g_min_time2 ? treply : g_min_time2;
+ g_max_time2 = treply > g_max_time2 ? treply : g_max_time2;
+ g_tot_time2 += treply;
+ g_ant2 += 1;
+ }
+ //
+ if (line != g_data)
+ {
+ fprintf(stderr, "\n%s\n%s\n", line.c_str(), g_data.c_str());
+ fprintf(stderr, "(reply did not match data - exiting)\n");
+ exit(-1);
+ }
+ //
+ gBytesIn += GetBytesReceived(true);
+ gBytesOut += GetBytesSent(true);
+ if (m_b_one)
+ {
+ SetCloseAndDelete();
+ }
+ else
+ if (g_b_repeat && g_b_limit)
+ {
+ SendBlock();
+ }
+ // add another
+ if (!m_b_created && (!g_b_limit || !g_b_off) && !g_b_instant)
+ {
+ MySocket *p = new MySocket(Handler(), m_b_one);
+ p -> SetDeleteByHandler();
+ p -> Open(gHost, gPort);
+ Handler().Add(p);
+ m_b_created = true;
+ }
+ }
+
+ bool IsActive() {
+ bool b = m_b_active;
+ m_b_active = false;
+ return b;
+ }
+
+private:
+ bool m_b_client;
+ bool m_b_one;
+ bool m_b_created;
+ bool m_b_active;
+ struct timeval m_create;
+ struct timeval m_connect;
+ struct timeval m_send;
+ struct timeval m_reply;
+};
+
+
+class MyHttpSocket : public HttpGetSocket
+{
+public:
+ MyHttpSocket(ISocketHandler& h,const std::string& url) : HttpGetSocket(h,url), m_url(url) {
+ gettime(&m_create, NULL);
+ AddResponseHeader("content-length", Utility::l2string(g_data_size));
+ }
+ ~MyHttpSocket() {}
+
+ void OnConnect() {
+ gettime(&m_connect, NULL);
+ {
+ double tconnect = Diff(m_create, m_connect);
+ //
+ g_min_time = tconnect < g_min_time ? tconnect : g_min_time;
+ g_max_time = tconnect > g_max_time ? tconnect : g_max_time;
+ g_tot_time += tconnect;
+ g_ant += 1;
+ }
+ gettime(&m_send, NULL);
+
+ // send request header
+ HttpGetSocket::OnConnect();
+
+ // send body
+ Send(g_data);
+ }
+
+ void OnContent() {
+ gettime(&m_reply, NULL);
+ {
+ double treply = Diff(m_send, m_reply);
+ //
+ g_min_time2 = treply < g_min_time2 ? treply : g_min_time2;
+ g_max_time2 = treply > g_max_time2 ? treply : g_max_time2;
+ g_tot_time2 += treply;
+ g_ant2 += 1;
+ }
+ CreateNew();
+ }
+ void CreateNew() {
+ if (g_b_off)
+ return;
+ MyHttpSocket *p = new MyHttpSocket(Handler(), m_url);
+ p -> SetDeleteByHandler();
+ Handler().Add(p);
+ SetCloseAndDelete();
+ }
+
+private:
+ std::string m_url;
+ struct timeval m_create;
+ struct timeval m_connect;
+ struct timeval m_send;
+ struct timeval m_reply;
+};
+
+
+#ifndef _WIN32
+void sigint(int)
+{
+ printreport();
+ gQuit = true;
+}
+
+
+void sigusr1(int)
+{
+ g_b_flood = true;
+}
+
+
+void sigusr2(int)
+{
+ printreport_reset();
+}
+#endif
+
+
+class MyHandler : public SocketHandler
+{
+public:
+ MyHandler() : SocketHandler() {
+ }
+ MyHandler(StdoutLog *p) : SocketHandler(p) {
+ }
+ ~MyHandler() {
+ }
+ void Flood() {
+ for (socket_m::iterator it = m_sockets.begin(); it != m_sockets.end(); it++)
+ {
+ Socket *p0 = it -> second;
+ MySocket *p = dynamic_cast<MySocket *>(p0);
+ if (p)
+ {
+ p -> SendBlock();
+ }
+ }
+ }
+ void Report() {
+ int ant = 0;
+ int act = 0;
+ for (socket_m::iterator it = m_sockets.begin(); it != m_sockets.end(); it++)
+ {
+ MySocket *p = dynamic_cast<MySocket *>(it -> second);
+ if (p)
+ {
+ ant++;
+ if (p -> IsActive())
+ {
+ act++;
+ }
+ }
+ }
+ printf("Number of //stress// sockets: %d Active: %d\n", ant, act);
+ }
+};
+
+
+int main(int argc,char *argv[])
+{
+ bool many = false;
+ bool one = false;
+ bool enableLog = false;
+ bool http = false;
+ std::string url;
+ time_t report_period = 10;
+ for (int i = 1; i < argc; i++)
+ {
+ if (!strcmp(argv[i], "-many"))
+ many = true;
+ if (!strcmp(argv[i], "-one"))
+ one = true;
+ if (*argv[i] == '-' && strlen(argv[i]) > 1 && isdigit(argv[i][1]) )
+ g_max_connections = atoi(argv[i] + 1);
+ if (!strcmp(argv[i], "-host") && i < argc - 1)
+ gHost = argv[++i];
+ if (!strcmp(argv[i], "-port") && i < argc - 1)
+ gPort = atoi(argv[++i]);
+ if (!strcmp(argv[i], "-off"))
+ g_b_off = true;
+ if (!strcmp(argv[i], "-repeat"))
+ g_b_repeat = true;
+ if (!strcmp(argv[i], "-size") && i < argc - 1)
+ g_data_size = atoi(argv[++i]);
+ if (!strcmp(argv[i], "-log"))
+ enableLog = true;
+ if (!strcmp(argv[i], "-time") && i < argc - 1)
+ report_period = atoi(argv[++i]);
+ if (!strcmp(argv[i], "-stop"))
+ g_b_stop = true;
+#ifdef HAVE_OPENSSL
+ if (!strcmp(argv[i], "-ssl"))
+ g_b_ssl = true;
+#endif
+ if (!strcmp(argv[i], "-instant"))
+ g_b_instant = true;
+ if (!strcmp(argv[i], "-http"))
+ http = true;
+ if (!strcmp(argv[i], "-url") && i < argc - 1)
+ url = argv[++i];
+ }
+ if (argc < 2 || (!many && !one && !g_max_connections && !http) )
+ {
+ printf("Usage: %s [mode] [options]\n", *argv);
+ printf(" Modes (only use one of these):\n");
+ printf(" -many start max number of connections\n");
+ printf(" -one open - close - repeat\n");
+ printf(" -nn open nn connections, then start -one mode\n");
+ printf(" -http send/receive http request/response\n");
+ printf(" Options:\n");
+ printf(" -host xx host to connect to\n");
+ printf(" -port nn port number to connection to\n");
+ printf(" -off turn off new connections when connection limit reached\n");
+ printf(" -repeat send new block when reply is received\n");
+ printf(" -size nn size of block to send, default is 1024 bytes\n");
+ printf(" -log enable debug log\n");
+ printf(" -time nn time between reports, default 10s\n");
+ printf(" -stop stop after time elapsed\n");
+ printf(" -instant create all sockets at once\n");
+#ifdef HAVE_OPENSSL
+ printf(" -ssl use ssl\n");
+#endif
+ printf(" -url xx url to use in http mode (default http://<host>:<port>/)\n");
+ exit(-1);
+ }
+ fprintf(stderr, "Using data size: %d bytes\n", (int)g_data_size);
+ std::string chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ while (g_data.size() < g_data_size)
+ {
+ g_data += chars[rand() % chars.size()];
+ }
+#ifndef _WIN32
+ signal(SIGINT, sigint);
+ signal(SIGUSR1, sigusr1);
+ signal(SIGUSR2, sigusr2);
+ signal(SIGPIPE, SIG_IGN);
+#endif
+ StdoutLog *log = enableLog ? new StdoutLog() : NULL;
+ MyHandler h(log);
+ if (http)
+ {
+ if (!url.size())
+ {
+ url = "http://" + gHost + ":" + Utility::l2string(gPort) + "/";
+ }
+ MyHttpSocket *s = new MyHttpSocket(h, url);
+ s -> SetDeleteByHandler();
+ h.Add(s);
+ }
+ else
+ if (g_b_instant)
+ {
+ for (size_t i = 0; i < g_max_connections; i++)
+ {
+ MySocket *s = new MySocket(h, one);
+ s -> SetDeleteByHandler();
+ s -> Open(gHost, gPort);
+ h.Add(s);
+ }
+ g_b_limit = true;
+ }
+ else
+ {
+ MySocket *s = new MySocket(h, one);
+ s -> SetDeleteByHandler();
+ s -> Open(gHost, gPort);
+ h.Add(s);
+ }
+ time_t t = time(NULL);
+ gettime(&g_t_start, NULL);
+ while (!gQuit)
+ {
+ h.Select(1, 0);
+ if (g_b_flood)
+ {
+ fprintf(stderr, "\nFlooding\n");
+ h.Flood();
+ g_b_flood = false;
+ }
+ if (time(NULL) - t >= report_period) // report
+ {
+ t = time(NULL);
+ printreport_reset();
+ h.Report();
+ if (g_b_stop)
+ {
+ gQuit = true;
+ }
+ }
+ }
+ fprintf(stderr, "\nExiting...\n");
+ if (log)
+ {
+// delete log;
+ }
+ return 0;
+}
+
+
diff --git a/src/Sockets/tests/x.cpp b/src/Sockets/tests/x.cpp
new file mode 100644
index 0000000..2ca9b26
--- /dev/null
+++ b/src/Sockets/tests/x.cpp
@@ -0,0 +1,298 @@
+#include <SocketHandler.h>
+#include <TcpSocket.h>
+#include <StdoutLog.h>
+#ifndef _WIN32
+#include <signal.h>
+#endif
+#include <IEventOwner.h>
+#include <EventHandler.h>
+
+#define HOST "localhost"
+#define PORT 2222
+
+#define TIME_US 250000
+
+#define DEB(x) x
+
+
+static bool quit = false;
+static EventHandler *ph = NULL;
+
+static int lc = 0;
+static int l2c = 0;
+static int l3c = 0;
+
+
+#ifndef _WIN32
+void sighandler(int s)
+{
+ quit = true;
+ ph -> SetQuit();
+}
+
+
+void sigpipe(int s)
+{
+}
+#endif
+
+
+class evHandler : public EventHandler
+{
+public:
+ evHandler() : EventHandler() {}
+ evHandler(StdLog *p) : EventHandler(p) {}
+
+ void CloseAll() {
+ for (socket_m::iterator it = m_sockets.begin(); it != m_sockets.end(); it++)
+ {
+ Socket *p = it -> second;
+ p -> SetCloseAndDelete();
+ }
+ }
+
+};
+
+
+class lSocket : public TcpSocket, public IEventOwner
+{
+public:
+ lSocket(ISocketHandler& h, bool first = false) : TcpSocket(h), IEventOwner(static_cast<evHandler&>(h)), m_id(0), m_first(first) {
+ SetLineProtocol();
+ lc++;
+ }
+ ~lSocket() {
+ }
+
+ void OnConnect() {
+ if (!m_id)
+ {
+ m_id = AddEvent(0, TIME_US);
+ }
+ printf(".");
+ fflush(stdout);
+ }
+ void OnConnectFailed() {
+ printf("lSocket::OnConnectFailed\n");
+ }
+
+ void OnDelete() {
+ if (m_first)
+ printf("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
+ "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
+ "@@@@@@@@@@@@@@ OnDelete() first @@@@@@@@@@@@@@@@@@\n"
+ "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
+ "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
+ }
+
+ void OnEvent(int id) {
+ if (id != m_id)
+ {
+ printf("ID MISMATCH!\n");
+ exit(-1);
+ }
+ if (!quit)
+ {
+ lSocket *p = new lSocket(Handler());
+ p -> SetDeleteByHandler();
+ p -> Open(HOST, PORT);
+ Handler().Add(p);
+ }
+ static_cast<evHandler&>(Handler()).SetQuit( quit );
+ SetCloseAndDelete();
+ }
+
+private:
+ int m_id;
+ bool m_first;
+};
+
+
+class l2Socket : public TcpSocket, public IEventOwner
+{
+public:
+ l2Socket(ISocketHandler& h, bool first = false) : TcpSocket(h), IEventOwner(static_cast<evHandler&>(h)), m_id(0), m_first(first) {
+ SetLineProtocol();
+ l2c++;
+ }
+ ~l2Socket() {
+ }
+
+ void OnConnect() {
+ printf(".");
+ fflush(stdout);
+ }
+ void OnConnectFailed() {
+ printf("l2Socket::OnConnectFailed\n");
+ }
+
+ void OnLine(const std::string& line) {
+ if (!m_id)
+ {
+ m_id = AddEvent(0, TIME_US);
+ }
+ }
+
+ void OnDelete() {
+ if (m_first)
+ printf("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
+ "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
+ "@@@@@@@@@@@@@@ OnDelete() first @@@@@@@@@@@@@@@@@@\n"
+ "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
+ "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
+ }
+
+ void OnEvent(int id) {
+ if (id != m_id)
+ {
+ printf("ID MISMATCH!\n");
+ exit(-1);
+ }
+ if (!quit)
+ {
+ l2Socket *p = new l2Socket(Handler());
+ p -> SetDeleteByHandler();
+ p -> Open(HOST, PORT);
+ Handler().Add(p);
+ }
+ static_cast<evHandler&>(Handler()).SetQuit( quit );
+ SetCloseAndDelete();
+ }
+
+private:
+ int m_id;
+ bool m_first;
+};
+
+
+class l3Socket : public TcpSocket, public IEventOwner
+{
+public:
+ l3Socket(ISocketHandler& h, bool first = false) : TcpSocket(h), IEventOwner(static_cast<evHandler&>(h)), m_ehlo(false), m_id(0), m_first(first) {
+ SetLineProtocol();
+ l3c++;
+ }
+ ~l3Socket() {
+ }
+
+ void OnConnect() {
+ printf(".");
+ fflush(stdout);
+ }
+ void OnConnectFailed() {
+ printf("l3Socket::OnConnectFailed\n");
+ }
+
+ void OnLine(const std::string& line) {
+ if (!m_ehlo)
+ {
+ Send("EHLO alhem.net\r\n");
+ m_ehlo = true;
+ }
+ else
+ if (!m_id)
+ {
+ m_id = AddEvent(0, TIME_US);
+ }
+ }
+
+ void OnDelete() {
+ if (m_first)
+ printf("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
+ "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
+ "@@@@@@@@@@@@@@ OnDelete() first @@@@@@@@@@@@@@@@@@\n"
+ "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
+ "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
+ }
+
+ void OnEvent(int id) {
+ if (id != m_id)
+ {
+ printf("ID MISMATCH!\n");
+ exit(-1);
+ }
+ if (!quit)
+ {
+ l3Socket *p = new l3Socket(Handler());
+ p -> SetDeleteByHandler();
+ p -> Open(HOST, PORT);
+ Handler().Add(p);
+ }
+ static_cast<evHandler&>(Handler()).SetQuit( quit );
+ Send("QUIT\r\n");
+ }
+
+private:
+ bool m_ehlo;
+ int m_id;
+ bool m_first;
+};
+
+
+int main(int argc, char *argv[])
+{
+#ifndef _WIN32
+ signal(SIGHUP, sighandler);
+ signal(SIGINT, sighandler);
+ signal(SIGPIPE, sigpipe);
+#endif
+
+ time_t tstart = time(NULL);
+ {
+ StdoutLog log;
+ {
+ evHandler h(&log);
+ ph = &h;
+ {
+ lSocket sock(h, true);
+ sock.Open(HOST, PORT);
+ h.Add(&sock);
+ {
+ l2Socket sock2(h, true);
+ sock2.Open(HOST, PORT);
+ h.Add(&sock2);
+ {
+ l3Socket sock3(h, true);
+ sock3.Open(HOST, PORT);
+ h.Add(&sock3);
+
+ h.EventLoop();
+ h.CloseAll();
+
+ // %! one socket refuses to go away
+ while (h.GetCount() > 1)
+ {
+ h.Select(1, 0);
+ }
+ printf("Exiting 1...\n");
+ fflush(stdout);
+ }
+ printf("Exiting 2...\n");
+ fflush(stdout);
+ }
+ printf("Exiting 3...\n");
+ fflush(stdout);
+ }
+ printf("Exiting 4...\n");
+ fflush(stdout);
+ }
+ printf("Exiting 5...\n");
+ fflush(stdout);
+ }
+ printf("Exiting 6...\n");
+ fflush(stdout);
+
+ time_t tstop = time(NULL);
+
+ time_t total = tstop - tstart + 1;
+
+ printf("lc: %d\n", lc);
+ printf("l2c: %d\n", l2c);
+ printf("l3c: %d\n", l3c);
+
+ printf("lc: %f\n", (double)lc / (double)total);
+ printf("l2c: %f\n", (double)l2c / (double)total);
+ printf("l3c: %f\n", (double)l3c / (double)total);
+}
+
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-06 16:04:11 +0000