First git commit.

Author: janvidar

README

@@ -0,0 +1,5 @@
+QuickDC a portable p2p application for ADC/NMDC networks.
+
+* Features built-in ADC hub
+* Multisource downloads
+

core/api/cli.cpp

@@ -0,0 +1,26 @@
+namespace QuickDC {
+namespace CLI {
+
+struct CommandTemplate {
+	const char* cmd;
+	size_t     length;
+	size_t     params;
+	const char* parse_args;
+	const char* desc_args;
+	const char* description;
+};
+
+class ParsedCommand {
+	public:
+		ParsedCommand();
+		virtual ~ParsedCommand();
+		
+	protected:
+		std::vector<char*> arguments;
+};
+
+
+
+
+}
+}

core/api/cli.h

@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2001-2008 Jan Vidar Krey, [email protected]
+ * See the file "COPYING" for licensing details.
+ */
+
+#include "quickdc.h"
+
+#include <samurai/io/net/bandwidth.h>
+#include <samurai/io/net/tlsfactory.h>
+#include <samurai/io/net/socketmonitor.h>
+#include <samurai/io/file.h>
+#include <samurai/timer.h>
+#include <samurai/timestamp.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#include "api/core.h"
+#include "api/server.h"
+#include "config/preferences.h"
+#include "network/connectionmanager.h"
+#include "network/downloadqueue.h"
+#include "network/hubmanager.h"
+#include "network/securitymanager.h"
+#include "network/transfermanager.h"
+#include "network/adc/server/adchub.h"
+
+#include "share/sharemanager.h"
+#include "hash/hashmanager.h"
+
+extern "C" QuickDC::Core* quickdc_core;
+
+QuickDC::Core::Core()
+{
+	QDBG_INIT;
+
+	startup = time(0);
+
+	references = 0;
+	
+	Samurai::IO::File::mkdir("~/.quickdc",         0700);
+	Samurai::IO::File::mkdir("~/.quickdc/hub",     0700);
+	Samurai::IO::File::mkdir("~/.quickdc/hub/bbs", 0700);
+	Samurai::IO::File::mkdir("~/.quickdc/lists",   0700);
+	Samurai::IO::File::mkdir("~/.quickdc/ssl",     0700);
+	
+	config = new Preferences("~/.quickdc/quickdc.conf");
+	quickdc_core = this;
+	
+	monitor = Samurai::IO::Net::SocketMonitor::getInstance();
+	bandwidthManager = new Samurai::IO::Net::BandwidthManager();
+	messageHandler = Samurai::MessageHandler::getInstance();
+	securityManager = new QuickDC::SecurityManager();
+
+	Samurai::IO::Net::TlsFactory::setKeys("~/.quickdc/ssl/quickdc.key", "~/.quickdc/ssl/quickdc.crt");
+
+	hash = new QuickDC::Hash::Manager();
+	shares = new QuickDC::Share::Manager(config, hash);
+	server = new DCServer();
+	connections = new ConnectionManager();
+	hubs = new HubManager();
+	transfers = new TransferManager();
+	timers = new Samurai::TimerManager();
+	localHub = new ADC::Hub();
+	queue = new QuickDC::QueueManager();
+	
+	shares->initialize();
+}
+
+
+QuickDC::Core::~Core() {
+	quickdc_core = 0;
+	delete timers; timers = 0;
+	delete transfers; transfers = 0;
+	delete connections; connections = 0;
+	delete server; server = 0;
+	delete hubs; hubs = 0;
+	delete securityManager; securityManager = 0;
+	delete shares; shares = 0;
+	delete config; config = 0;
+	delete hash; hash = 0;
+	delete localHub; localHub = 0;
+	delete bandwidthManager;
+	delete messageHandler; messageHandler = 0;
+	QDBG_FINI;
+}
+
+
+void QuickDC::Core::run() {
+	// Poll sockets
+	// FIXME: Wait for sigio, it's no point actually waiting!
+	monitor->wait(1000);
+	
+	// Make sure hashing is continued
+	hash->process();
+	
+	// Process timers.
+	// FIXME: it should be sorted so we don't have to iterate ALL timers to
+    // before exit.
+	timers->process();
+	
+	messageHandler->process();
+}
+
+
+QuickDC::Core* QuickDC::Core::getInstance()
+{
+	return quickdc_core;
+}
+
+
+const char* QuickDC::Core::getVersion() const 
+{
+	return PRODUCT " " VERSION " " SYSTEM "/" CPU
+#ifdef BUILD
+	 " (build " BUILD ")"
+#endif
+	 ;
+}
+
+

core/api/core.cpp

@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2001-2008 Jan Vidar Krey, [email protected]
+ * See the file "COPYING" for licensing details.
+ */
+
+#ifndef HAVE_QUICKDC_CORE_API_H
+#define HAVE_QUICKDC_CORE_API_H
+
+#include <samurai/timestamp.h>
+
+namespace Samurai {
+	namespace IO {
+		namespace Net {
+			class BandwidthManager;
+			class SocketMonitor;
+			class Socket;
+		}
+	}
+	
+	class TimerManager;
+	class MessageHandler;
+}
+
+
+namespace ADC {
+	class Hub;
+}
+
+namespace QuickDC {
+namespace Hash { class Manager; }
+namespace Share { class Manager; }
+
+class ConnectionManager;
+class DCCommandProxy;
+class DCHubSession;
+class DCServer;
+class HubManager;
+class Preferences;
+class Server;
+class ShareManager;
+class TransferManager;
+class QueueManager;
+class SecurityManager;
+
+class Core {
+	public:
+		/**
+		 * Run the core for a while.
+		 * This needs to be run often in a loop, in order to 
+		 * keep the networking going and messages dispatched.
+		 *
+		 * QuickDC core is asynchronous so calling this will
+		 * not block your application for a long time. Usually only
+		 * for milliseconds.
+		 *
+		 * In order to get good networking throughput, you should 
+		 * call this method at least 20 times per second.
+		 *
+		 * This call will never block for a considerable long time.
+		 */
+		void run();
+		
+		/**
+		 * Returns an instance of the running Core, 
+		 * or it will create one if none is running.
+		 */
+		static Core* getInstance();
+		
+#if 0
+		/**
+		 * Add a server listener. This will be notified 
+		 * whenever the server receivs a connection.
+		 */
+		 void AddServerListener(const DCServerListener*);
+#endif // 0
+		
+		
+	public:
+		/**
+		 * Returns the version string of the compiled QuickDC core.
+		 */
+		const char* getVersion() const;
+		
+	public:
+		Preferences* config;
+		QuickDC::Share::Manager* shares;
+		DCServer* server;
+		ConnectionManager* connections;
+		HubManager* hubs;
+		QuickDC::Hash::Manager* hash;
+		TransferManager* transfers;
+		Samurai::TimerManager* timers;
+		ADC::Hub* localHub;
+		QuickDC::QueueManager* queue;
+		Samurai::TimeStamp startup;
+		Samurai::MessageHandler* messageHandler;
+		Samurai::IO::Net::SocketMonitor* monitor;
+		QuickDC::SecurityManager* securityManager;
+		Samurai::IO::Net::BandwidthManager* bandwidthManager;
+
+	protected:
+		int references;
+
+	public:
+		/**
+		 * Note: only one Core object can exist
+		 * Constructing multiple will throw an error.
+		 */
+		Core();
+		virtual ~Core();
+};
+
+}
+
+extern "C" QuickDC::Core* quickdc_core;
+
+#endif // HAVE_QUICKDC_CORE_API_H