socksd.cpp

#include"socksd.h"

#include<qapplication.h>
#include"bconsole.h"
#include"bsocket.h"
#include"socks.h"

#include<stdio.h>

class App::Private
{
public:
	Private() {}

	ByteStream *bs;
	BConsole *c;
	SocksServer *serv;
	SocksClient *client;

	QString user, pass;
};

App::App(int port, const QString &user, const QString &pass)
:QObject(0)
{
	d = new Private;
	d->user = user;
	d->pass = pass;
	d->c = new BConsole;
	connect(d->c, SIGNAL(connectionClosed()), SLOT(con_connectionClosed()));
	connect(d->c, SIGNAL(readyRead()), SLOT(con_readyRead()));

	d->bs = 0;
	d->client = 0;
	d->serv = new SocksServer;
	connect(d->serv, SIGNAL(incomingReady()), SLOT(ss_incomingReady()));
	d->serv->listen(port);

	fprintf(stderr, "socksd: listening on port %d\n", port);
}

App::~App()
{
	if(d->client)
		d->client->deleteLater();
	delete d->serv;
	delete d->c;
	delete d;
}

void App::st_connectionClosed()
{
	fprintf(stderr, "socksd: Connection closed by foreign host.\n");
	quit();
}

void App::st_delayedCloseFinished()
{
	quit();
}

void App::st_readyRead()
{
	QByteArray a = d->bs->read();
	d->c->write(a);
}

void App::st_error(int x)
{
	fprintf(stderr, "socksd: Stream error [%d].\n", x);
	quit();
}

void App::con_connectionClosed()
{
	fprintf(stderr, "adconn: Closing.\n");
	d->bs->close();
	if(d->bs->bytesToWrite() == 0)
		quit();
}

void App::con_readyRead()
{
	QByteArray a = d->c->read();
	d->bs->write(a);
}

void App::ss_incomingReady()
{
	fprintf(stderr, "incoming connection!\n");
	SocksClient *c = d->serv->takeIncoming();
	if(!c)
		return;
	fprintf(stderr, "accepted\n");
	connect(c, SIGNAL(incomingMethods(int)), SLOT(sc_incomingMethods(int)));
	connect(c, SIGNAL(incomingAuth(const QString &, const QString &)), SLOT(sc_incomingAuth(const QString &, const QString &)));
	connect(c, SIGNAL(incomingRequest(const QString &, int)), SLOT(sc_incomingRequest(const QString &, int)));
	connect(c, SIGNAL(error(int)), SLOT(sc_error(int)));
	d->client = c;
}

void App::sc_incomingMethods(int m)
{
	fprintf(stderr, "m=%d\n", m);
	if(d->user.isEmpty() && m & SocksClient::AuthNone)
		d->client->chooseMethod(SocksClient::AuthNone);
	else if(m & SocksClient::AuthUsername)
		d->client->chooseMethod(SocksClient::AuthUsername);
	else {
		d->client->deleteLater();
		d->client = 0;
		fprintf(stderr, "unsupported method!\n");
	}
}

void App::sc_incomingAuth(const QString &user, const QString &pass)
{
	fprintf(stderr, "incoming auth: user=[%s], pass=[%s]\n", user.latin1(), pass.latin1());
	if(user == d->user && pass == d->pass) {
		d->client->authGrant(true);
	}
	else {
		d->client->authGrant(false);
		d->client->deleteLater();
		d->client = 0;
	}
}

void App::sc_incomingRequest(const QString &host, int port)
{
	fprintf(stderr, "request: host=[%s], port=[%d]\n", host.latin1(), port);

	disconnect(d->client, SIGNAL(error(int)), this, SLOT(sc_error(int)));
	connect(d->client, SIGNAL(connectionClosed()), SLOT(st_connectionClosed()));
	connect(d->client, SIGNAL(delayedCloseFinished()), SLOT(st_delayedCloseFinished()));
	connect(d->client, SIGNAL(readyRead()), SLOT(st_readyRead()));
	connect(d->client, SIGNAL(error(int)), SLOT(st_error(int)));
	d->bs = d->client;

	d->client->requestGrant(true);
	fprintf(stderr, "<< Active >>\n");
}

void App::sc_error(int)
{
	d->client->deleteLater();
	d->client = 0;

	fprintf(stderr, "error!\n");
}


int main(int argc, char **argv)
{
	QApplication app(argc, argv, false);

	if(argc < 2) {
		printf("usage: socksd [port] [user] [pass]\n\n");
		return 0;
	}

	QString p = argv[1];
	int port = p.toInt();

	QString user, pass;
	if(argc >= 4) {
		user = argv[2];
		pass = argv[3];
	}

	App *a = new App(port, user, pass);
	QObject::connect(a, SIGNAL(quit()), &app, SLOT(quit()));
	app.exec();
	delete a;

	return 0;
}