From c778d1258a3d778d0a6227b632ba5091a0eb25a0 Mon Sep 17 00:00:00 2001 From: w00t Date: Sat, 19 May 2007 16:01:06 +0000 Subject: Helps if I add the w32 specific code, too. :p git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@7044 e03df62e-2008-0410-955e-edbf42e46eb7 --- include/socketengine_iocp.h | 183 ++++++++++++ src/socketengine_iocp.cpp | 323 +++++++++++++++++++++ win/colours.h | 81 ++++++ win/colours.h.orig | 0 win/configure.cpp | 454 +++++++++++++++++++++++++++++ win/configure.cpp.orig | 0 win/configureVC71.vcproj | 229 +++++++++++++++ win/configureVC71.vcproj.orig | 0 win/inspircdVC71.sln | 53 ++++ win/inspircdVC71.sln.orig | 0 win/inspircdVC71.vcproj | 515 +++++++++++++++++++++++++++++++++ win/inspircdVC71.vcproj.orig | 0 win/inspircd_config.h | 32 ++ win/inspircd_config.h.orig | 0 win/inspircd_memory_functions.cpp | 12 + win/inspircd_memory_functions.cpp.orig | 0 win/inspircd_se_config.h | 8 + win/inspircd_se_config.h.orig | 0 win/inspircd_win32wrapper.cpp | 375 ++++++++++++++++++++++++ win/inspircd_win32wrapper.cpp.orig | 0 win/inspircd_win32wrapper.h | 162 +++++++++++ win/inspircd_win32wrapper.h.orig | 0 win/m_spanningtreeVC71.vcproj | 293 +++++++++++++++++++ win/m_spanningtreeVC71.vcproj.orig | 0 24 files changed, 2720 insertions(+) create mode 100644 include/socketengine_iocp.h create mode 100644 src/socketengine_iocp.cpp create mode 100644 win/colours.h create mode 100644 win/colours.h.orig create mode 100644 win/configure.cpp create mode 100644 win/configure.cpp.orig create mode 100644 win/configureVC71.vcproj create mode 100644 win/configureVC71.vcproj.orig create mode 100644 win/inspircdVC71.sln create mode 100644 win/inspircdVC71.sln.orig create mode 100644 win/inspircdVC71.vcproj create mode 100644 win/inspircdVC71.vcproj.orig create mode 100644 win/inspircd_config.h create mode 100644 win/inspircd_config.h.orig create mode 100644 win/inspircd_memory_functions.cpp create mode 100644 win/inspircd_memory_functions.cpp.orig create mode 100644 win/inspircd_se_config.h create mode 100644 win/inspircd_se_config.h.orig create mode 100644 win/inspircd_win32wrapper.cpp create mode 100644 win/inspircd_win32wrapper.cpp.orig create mode 100644 win/inspircd_win32wrapper.h create mode 100644 win/inspircd_win32wrapper.h.orig create mode 100644 win/m_spanningtreeVC71.vcproj create mode 100644 win/m_spanningtreeVC71.vcproj.orig diff --git a/include/socketengine_iocp.h b/include/socketengine_iocp.h new file mode 100644 index 000000000..1b4db096b --- /dev/null +++ b/include/socketengine_iocp.h @@ -0,0 +1,183 @@ +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#ifndef __SOCKETENGINE_IOCP__ +#define __SOCKETENGINE_IOCP__ + +#define READ_BUFFER_SIZE 500 +#define USING_IOCP 1 + +#include "inspircd_config.h" +#include "inspircd_win32wrapper.h" +#include "globals.h" +#include "inspircd.h" +#include "socketengine.h" + +enum SocketIOEvent +{ + SOCKET_IO_EVENT_READ_READY = 0, + SOCKET_IO_EVENT_WRITE_READY = 1, + SOCKET_IO_EVENT_ACCEPT = 2, + SOCKET_IO_EVENT_ERROR = 3, + NUM_SOCKET_IO_EVENTS = 4, +}; + +class Overlapped +{ +public: + OVERLAPPED m_overlap; + SocketIOEvent m_event; + int m_params; + Overlapped(SocketIOEvent ev, int params) : m_event(ev), m_params(params) + { + memset(&m_overlap, 0, sizeof(OVERLAPPED)); + } +}; + +struct accept_overlap +{ + int socket; + char buf[1024]; +}; + +class IOCPEngine : public SocketEngine +{ + /** Creates a "fake" file descriptor for use with an IOCP socket. + * @return -1 if there are no free slots, and an integer if it finds one. + */ + __inline int GenerateFd() + { + register int i = 0; + for(; i < MAX_DESCRIPTORS; ++i) + if(ref[i] == 0) + return i; + return -1; + } + + /** Global I/O completion port that sockets attach to. + */ + HANDLE m_completionPort; + + /** This is kinda shitty... :/ for getting an address from a real fd. + */ + map m_binding; + +public: + /** Creates an IOCP Socket Engine + * @param Instance The creator of this object + */ + IOCPEngine(InspIRCd * Instance); + + /** Deletes an IOCP socket engine and all the attached sockets + */ + ~IOCPEngine(); + + /** Adds an event handler to the completion port, and sets up initial events. + * @param eh EventHandler to add + * @return True if success, false if no room + */ + bool AddFd(EventHandler* eh); + + /** Gets the maximum number of file descriptors that this engine can handle. + * @return The number of file descriptors + */ + __inline int GetMaxFds() { return MAX_DESCRIPTORS; } + + /** Gets the number of free/remaining file descriptors under this engine. + * @return Remaining count + */ + __inline int GetRemainingFds() + { + register int count = 0; + register int i = 0; + for(; i < MAX_DESCRIPTORS; ++i) + if(ref[i] == 0) + ++count; + return count; + } + + /** Removes a file descriptor from the set, preventing it from receiving any more events + * @return True if remove was successful, false otherwise + */ + bool DelFd(EventHandler* eh, bool force = false); + + /** Called every loop to handle input/output events for all sockets under this engine + * @return The number of "changed" sockets. + */ + int DispatchEvents(); + + /** Gets the name of this socket engine as a string. + * @return string of socket engine name + */ + std::string GetName(); + + /** Queues a Write event on the specified event handler. + * @param eh EventHandler that needs data sent on + */ + void WantWrite(EventHandler* eh); + + /** Posts a completion event on the specified socket. + * @param eh EventHandler for message + * @param type Event Type + * @param param Event Parameter + * @return True if added, false if not + */ + bool PostCompletionEvent(EventHandler * eh, SocketIOEvent type, int param); + + /** Posts a read event on the specified socket + * @param eh EventHandler (socket) + */ + void PostReadEvent(EventHandler * eh); + + /** Posts an accept event on the specified socket + * @param eh EventHandler (socket) + */ + void PostAcceptEvent(EventHandler * eh); + + /** Returns the EventHandler attached to a specific fd. + * If the fd isnt in the socketengine, returns NULL. + * @param fd The event handler to look for + * @return A pointer to the event handler, or NULL + */ + EventHandler* GetRef(int fd); + + /** Returns true if a file descriptor exists in + * the socket engine's list. + * @param fd The event handler to look for + * @return True if this fd has an event handler + */ + bool HasFd(int fd); + + /** Returns the EventHandler attached to a specific fd. + * If the fd isnt in the socketengine, returns NULL. + * @param fd The event handler to look for + * @return A pointer to the event handler, or NULL + */ + EventHandler* GetIntRef(int fd); +}; + +//typedef void(*OpHandler)(EventHandler) +/** Event Handler Array + */ + +/** Creates a SocketEngine + */ +class SocketEngineFactory +{ +public: + /** Create a new instance of SocketEngine based on IOCPEngine + */ + SocketEngine* Create(InspIRCd* Instance) { return new IOCPEngine(Instance); } +}; + +#endif diff --git a/src/socketengine_iocp.cpp b/src/socketengine_iocp.cpp new file mode 100644 index 000000000..947b518b6 --- /dev/null +++ b/src/socketengine_iocp.cpp @@ -0,0 +1,323 @@ +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "socketengine_iocp.h" +#include +#include + +IOCPEngine::IOCPEngine(InspIRCd * Instance) : SocketEngine(Instance) +{ + // Create completion port + m_completionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, (ULONG_PTR)0, 0); + + // Null variables out. + CurrentSetSize = 0; + EngineHandle = 0; + memset(ref, 0, sizeof(EventHandler*) * MAX_DESCRIPTORS); +} + +IOCPEngine::~IOCPEngine() +{ + CloseHandle(m_completionPort); +}; + +bool IOCPEngine::AddFd(EventHandler* eh) +{ + int fake_fd = GenerateFd(); + int is_accept = 0; + int opt_len = sizeof(int); + if(fake_fd < 0) + return false; + + // are we a listen socket? + getsockopt(eh->GetFd(), SOL_SOCKET, SO_ACCEPTCONN, (char*)&is_accept, &opt_len); + + // set up the read event so the socket can actually receive data :P + eh->m_internalFd = fake_fd; + eh->m_writeEvent = 0; + eh->m_acceptEvent = 0; + + // assign the socket to the completion port + if(!CreateIoCompletionPort((HANDLE)eh->GetFd(), m_completionPort, (ULONG_PTR)eh->m_internalFd, 0)) + return false; + + // set up binding, increase set size + ref[fake_fd] = eh; + ++CurrentSetSize; + + // setup initial events + if(is_accept) + PostAcceptEvent(eh); + else + PostReadEvent(eh); + + // log message + ServerInstance->Log(DEBUG, "New fake fd: %u, real fd: %u, address 0x%p", fake_fd, eh->GetFd(), eh); + + // post a write event if there is data to be written + if(eh->Writeable()) + WantWrite(eh); + + // we're all good =) + m_binding.insert( map::value_type( eh->GetFd(), eh ) ); + return true; +} + +bool IOCPEngine::DelFd(EventHandler* eh, bool force /* = false */) +{ + int fake_fd = eh->m_internalFd; + int fd = eh->GetFd(); + + if(ref[fake_fd] == 0) + return false; + + ServerInstance->Log(DEBUG, "Removing fake fd %u, real fd %u, address 0x%p", fake_fd, eh->GetFd(), eh); + + // Cancel pending i/o operations. + assert(CancelIo((HANDLE)fd) == TRUE); + + // Free the buffer, and delete the event. + if(eh->m_readEvent != 0) + delete ((Overlapped*)eh->m_readEvent); + + if(eh->m_writeEvent != 0) + delete ((Overlapped*)eh->m_writeEvent); + + if(eh->m_acceptEvent != 0) + { + delete ((accept_overlap*)((Overlapped*)eh->m_acceptEvent)->m_params); + delete ((Overlapped*)eh->m_acceptEvent); + } + + // Clear binding + ref[fake_fd] = 0; + m_binding.erase(eh->GetFd()); + + // decrement set size + --CurrentSetSize; + + // success + return true; +} + +void IOCPEngine::WantWrite(EventHandler* eh) +{ + // Post event - write begin + if(!eh->m_writeEvent) + { + Overlapped * ov = new Overlapped(SOCKET_IO_EVENT_WRITE_READY, 0); + eh->m_writeEvent = (void*)ov; + PostQueuedCompletionStatus(m_completionPort, 0, (ULONG_PTR)eh->m_internalFd, &ov->m_overlap); + } +} + +bool IOCPEngine::PostCompletionEvent(EventHandler * eh, SocketIOEvent type, int param) +{ + Overlapped * ov = new Overlapped(type, param); + return PostQueuedCompletionStatus(m_completionPort, 0, (ULONG_PTR)eh->m_internalFd, &ov->m_overlap); +} + +void IOCPEngine::PostReadEvent(EventHandler * eh) +{ + Overlapped * ov = new Overlapped(SOCKET_IO_EVENT_READ_READY, 0); + DWORD flags = 0; + DWORD r_length = 0; + WSABUF buf; + + // by passing a null buffer pointer, we can have this working in the same way as epoll.. + // its slower, but it saves modifying all network code. + buf.buf = 0; + buf.len = 0; + + // determine socket type. + DWORD sock_type; + int sock_len = sizeof(DWORD); + if(getsockopt(eh->GetFd(), SOL_SOCKET, SO_TYPE, (char*)&sock_type, &sock_len) == -1) + { + // wtfhax? + PostCompletionEvent(eh, SOCKET_IO_EVENT_ERROR, 0); + delete ov; + return; + } + switch(sock_type) + { + case SOCK_DGRAM: // UDP Socket + { + if(WSARecvFrom(eh->GetFd(), &buf, 1, &r_length, &flags, 0, 0, &ov->m_overlap, 0)) + { + int err = WSAGetLastError(); + if(WSAGetLastError() != WSA_IO_PENDING) + { + delete ov; + PostCompletionEvent(eh, SOCKET_IO_EVENT_ERROR, 0); + return; + } + } + }break; + + case SOCK_STREAM: // TCP Socket + { + if(WSARecv(eh->GetFd(), &buf, 1, &r_length, &flags, &ov->m_overlap, 0) == SOCKET_ERROR) + { + if(WSAGetLastError() != WSA_IO_PENDING) + { + delete ov; + PostCompletionEvent(eh, SOCKET_IO_EVENT_ERROR, 0); + return; + } + } + }break; + + default: + { + printf("unknwon socket type: %u\n", sock_type); + assert(false); + }break; + } + eh->m_readEvent = (void*)ov; +} + +int IOCPEngine::DispatchEvents() +{ + DWORD len; + LPOVERLAPPED overlap; + Overlapped * ov; + EventHandler * eh; + int intfd; + int ret; + unsigned long bytes_recv; + + while(GetQueuedCompletionStatus(m_completionPort, &len, (PULONG_PTR)&intfd, &overlap, 100)) + { + // woot, we got an event on a socket :P + eh = ref[intfd]; + ov = CONTAINING_RECORD(overlap, Overlapped, m_overlap); + if(eh == 0) continue; + switch(ov->m_event) + { + case SOCKET_IO_EVENT_WRITE_READY: + { + eh->m_writeEvent = 0; + eh->HandleEvent(EVENT_WRITE, 0); + }break; + + case SOCKET_IO_EVENT_READ_READY: + { + ret = ioctlsocket(eh->GetFd(), FIONREAD, &bytes_recv); + eh->m_readEvent = 0; + if(ret != 0 || bytes_recv == 0) + { + // end of file + PostCompletionEvent(eh, SOCKET_IO_EVENT_ERROR, EIO); + } + else + { + eh->HandleEvent(EVENT_READ, 0); + PostReadEvent(eh); + } + }break; + + case SOCKET_IO_EVENT_ACCEPT: + { + /* this is kinda messy.. :/ */ + eh->HandleEvent(EVENT_READ, ov->m_params); + delete ((accept_overlap*)ov->m_params); + eh->m_acceptEvent = 0; + PostAcceptEvent(eh); + }break; + + case SOCKET_IO_EVENT_ERROR: + { + eh->HandleEvent(EVENT_ERROR, ov->m_params); + }break; + } + + delete ov; + } + + return 0; +} + +void IOCPEngine::PostAcceptEvent(EventHandler * eh) +{ + int fd = WSASocket(AF_INET, SOCK_STREAM, 0, 0, 0, WSA_FLAG_OVERLAPPED); + int len = sizeof(sockaddr_in) + 16; + DWORD dwBytes; + accept_overlap * ao = new accept_overlap; + memset(ao->buf, 0, 1024); + ao->socket = fd; + + Overlapped * ov = new Overlapped(SOCKET_IO_EVENT_ACCEPT, (int)ao); + eh->m_acceptEvent = (void*)ov; + + if(AcceptEx(eh->GetFd(), fd, ao->buf, 0, len, len, &dwBytes, &ov->m_overlap) == FALSE) + { + int err = WSAGetLastError(); + if(err != WSA_IO_PENDING) + { + printf("PostAcceptEvent err: %d\n", err); + } + } +} + + +std::string IOCPEngine::GetName() +{ + return "iocp"; +} + +int __accept_socket(SOCKET s, sockaddr * addr, int * addrlen, void * acceptevent) +{ + Overlapped * ovl = (Overlapped*)acceptevent; + accept_overlap * ov = (accept_overlap*)ovl->m_params; + + sockaddr_in * server_address = (sockaddr_in*)&ov->buf[10]; + sockaddr_in * client_address = (sockaddr_in*)&ov->buf[38]; + + memcpy(addr, client_address, sizeof(sockaddr_in)); + *addrlen = sizeof(sockaddr_in); + + return ov->socket; +} + +int __getsockname(SOCKET s, sockaddr * name, int * namelen, void * acceptevent) +{ + Overlapped * ovl = (Overlapped*)acceptevent; + accept_overlap * ov = (accept_overlap*)ovl->m_params; + + sockaddr_in * server_address = (sockaddr_in*)&ov->buf[10]; + sockaddr_in * client_address = (sockaddr_in*)&ov->buf[38]; + + memcpy(name, server_address, sizeof(sockaddr_in)); + *namelen = sizeof(sockaddr_in); + + return 0; +} + +EventHandler * IOCPEngine::GetRef(int fd) +{ + map::iterator itr = m_binding.find(fd); + return (itr == m_binding.end()) ? 0 : itr->second; +} + +bool IOCPEngine::HasFd(int fd) +{ + return (GetRef(fd) != 0); +} + +EventHandler * IOCPEngine::GetIntRef(int fd) +{ + if(fd < 0 || fd > MAX_DESCRIPTORS) + return 0; + return ref[fd]; +} diff --git a/win/colours.h b/win/colours.h new file mode 100644 index 000000000..574d34640 --- /dev/null +++ b/win/colours.h @@ -0,0 +1,81 @@ +#define TRED FOREGROUND_RED | FOREGROUND_INTENSITY +#define TGREEN FOREGROUND_GREEN | FOREGROUND_INTENSITY +#define TYELLOW FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY +#define TNORMAL FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE +#define TWHITE TNORMAL | FOREGROUND_INTENSITY +#define TBLUE FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY + +inline void sc(WORD color) { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color); } + +/* Handles colors in printf */ +int printf_c(const char * format, ...) +{ + // Better hope we're not multithreaded, otherwise we'll have chickens crossing the road other side to get the to :P + static char message[500]; + static char temp[10]; + int color1, color2; + + /* parse arguments */ + va_list ap; + va_start(ap, format); + vsprintf(message, format, ap); + va_end(ap); + + /* search for unix-style escape sequences */ + int t; + int c = 0; + const char * p = message; + while(*p != 0) + { + if(*p == '\033') + { + // Escape sequence -> copy into the temp buffer, and parse the color. + p++; + t = 0; + while(*p != 'm') + { + temp[t++] = *p; + ++p; + } + + temp[t] = 0; + p++; + if(!stricmp(temp, "[0")) + { + // Returning to normal colour. + SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE); + } + else if(!stricmp(temp, "[1")) + { + // White + SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), TWHITE); + } + else if(sscanf(temp, "[%u;%u", &color1, &color2) == 2) + { + switch(color2) + { + case 32: // Green + SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN | FOREGROUND_INTENSITY); // Yellow + break; + + default: // Unknown + // White + SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY); + break; + } + } + else + { + char message[50]; + sprintf(message, "Unknown color code: %s", temp); + MessageBox(0, message, message, MB_OK); + } + } + + putchar(*p); + ++c; + ++p; + } + + return c; +} diff --git a/win/colours.h.orig b/win/colours.h.orig new file mode 100644 index 000000000..e69de29bb diff --git a/win/configure.cpp b/win/configure.cpp new file mode 100644 index 000000000..94547faee --- /dev/null +++ b/win/configure.cpp @@ -0,0 +1,454 @@ +#include +#include +#include +#include "colours.h" + +using namespace std; +void Run(); +void Banner(); +void WriteCompileModules(); +void WriteCompileCommands(); + +/* detects if we are running windows xp or higher (5.1) */ +bool iswinxp() +{ + OSVERSIONINFO vi; + vi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + GetVersionEx(&vi); + if(vi.dwMajorVersion > 5) + return true; + + if(vi.dwMajorVersion >= 5 && vi.dwMinorVersion >= 1) + return true; + + return false; +} + +int get_int_option(const char * text, int def) +{ + static char buffer[500]; + int ret; + printf_c("%s\n[\033[1;32m%u\033[0m] -> ", text, def); + fgets(buffer, 500, stdin); + if(sscanf(buffer, "%u", &ret) != 1) + ret = def; + + printf("\n"); + return ret; +} + +bool get_bool_option(const char * text, bool def) +{ + static char buffer[500]; + char ret[100]; + printf_c("%s [\033[1;32m%c\033[0m] -> ", text, def ? 'y' : 'n'); + fgets(buffer, 500, stdin); + if(sscanf(buffer, "%s", ret) != 1) + strcpy(ret, def ? "y" : "n"); + + printf("\n"); + return !strncmp(ret, "y", 1); +} + +void get_string_option(const char * text, char * def, char * buf) +{ + static char buffer[500]; + printf_c("%s\n[\033[1;32m%s\033[0m] -> ", text, def); + fgets(buffer, 500, stdin); + if(sscanf(buffer, "%s", buf) != 1) + strcpy(buf, def); + + printf("\n"); +} + +// escapes a string for use in a c++ file +bool escape_string(char * str, size_t size) +{ + size_t len = strlen(str); + char * d_str = (char*)malloc(len * 2); + + size_t i = 0; + size_t j = 0; + + for(; i < len; ++i) + { + if(str[i] == '\\') + { + d_str[j++] = '\\'; + d_str[j++] = '\\'; + } + else + { + d_str[j++] = str[i]; + } + } + + d_str[j++] = 0; + + if(j > size) + { + free(d_str); + return false; + } + + strcpy(str, d_str); + free(d_str); + return true; +} + +/* gets the svn revision */ +int get_svn_revision(char * buffer, size_t len) +{ + /* again.. I am lazy :p cbf to pipe output of svn info to us, so i'll just read the file */ + /* + 8 + + dir + 7033 + */ + char buf[1000]; + FILE * f = fopen("..\\.svn\\entries", "r"); + if(!f) goto bad_rev; + + if(!fgets(buf, 1000, f)) goto bad_rev; + if(!fgets(buf, 1000, f)) goto bad_rev; + if(!fgets(buf, 1000, f)) goto bad_rev; + if(!fgets(buf, 1000, f)) goto bad_rev; + int rev = atoi(buf); + if(rev == 0) goto bad_rev; + sprintf(buffer, "%u", rev); + fclose(f); + return rev; + +bad_rev: + strcpy(buffer, "non-svn"); + if(f) fclose(f); + return 0; +} + +int __stdcall WinMain(IN HINSTANCE hInstance, IN HINSTANCE hPrevInstance, IN LPSTR lpCmdLine, IN int nShowCmd ) +{ + // Skip if configure is already-existant. + FILE * f = fopen("inspircd_config.h", "r"); + if(f) + { + fclose(f); + return 0; + } + + AllocConsole(); + + // pipe standard handles to this console + freopen("CONIN$", "r", stdin); + freopen("CONOUT$", "w", stdout); + freopen("CONOUT$", "w", stderr); + + Banner(); + Run(); + WriteCompileCommands(); + WriteCompileModules(); + FreeConsole(); + return 0; +} + +void Banner() +{ + printf_c("\nWelcome to the \033[1mInspIRCd\033[0m Configuration program! (\033[1minteractive mode\033[0m)\n" + "\033[1mPackage maintainers: Type ./configure --help for non-interactive help\033[0m\n\n"); + printf_c("*** If you are unsure of any of these values, leave it blank for ***\n" + "*** standard settings that will work, and your server will run ***\n" + "*** using them. Please consult your IRC network admin if in doubt. ***\n\n" + "Press \033[1m\033[0m to accept the default for any option, or enter\n" + "a new value. Please note: You will \033[1mHAVE\033[0m to read the docs\n" + "dir, otherwise you won't have a config file!\n\n"); + +} + +void Run() +{ + int max_fd = 1024; + bool use_iocp = false; + bool support_ip6links = false; + char mod_path[MAX_PATH]; + char config_file[MAX_PATH]; + char library_dir[MAX_PATH]; + char base_path[MAX_PATH]; + char bin_dir[MAX_PATH]; + char revision_text[MAX_PATH]; + + int max_clients = 1024; + int nicklen = 31; + int chanlen = 64; + int modechanges = 20; + int identlen = 12; + int quitlen = 255; + int topiclen = 500; + int kicklen = 255; + int rllen = 128; + int awaylen = 200; + int revision = get_svn_revision(revision_text, MAX_PATH); + char version[514]; + + // grab version + FILE * fI = fopen("..\\src\\version.sh", "r"); + if(fI) + { + fgets(version, 514, fI); + fgets(version, 514, fI); + char * p2 = version; + while(*p2 != '\"') + ++p2; + ++p2; + strcpy(version, p2); + p2 = version; + while(*p2 != '\"') + ++p2; + *p2 = 0; + fclose(fI); + } + else + strcpy(version, "InspIRCD-Unknown"); + printf_c("Your operating system is: \033[1;32mwindows \033[0m\n"); + printf_c("InspIRCd revision ID: \033[1;32m%s \033[0m\n\n", revision ? revision_text : "(Non-SVN build)"); + + max_fd = get_int_option("What is the maximum file descriptor count you would like to allow?", 1024); + + // detect windows + if(iswinxp()) + { + printf_c("You are running Windows XP or above, and IOCP support is most likely available.\n" + "This removes the socket number limitation of select and is much more efficent.\n" + "If you are unsure, answer yes.\n\n"); + + use_iocp = get_bool_option("Do you want to use the IOCP implementation?", true); + } + + support_ip6links = get_bool_option("\nYou have chosen to build an \033[1;32mIPV4-only\033[0m server.\nWould you like to enable support for linking to IPV6-enabled InspIRCd servers?\nIf you are using a recent operating system and are unsure, answer yes.\nIf you answer 'no' here, your InspIRCd server will be unable\nto parse IPV6 addresses (e.g. for CIDR bans)", + true); + + printf_c("\033[1mAll paths are relative to the binary directory.\033[0m\n"); + get_string_option("In what directory do you wish to install the InspIRCd base?", "..", base_path); + get_string_option("In what directory are the configuration files?", "../conf", config_file); + get_string_option("In what directory are the modules to be compiled to?", "../modules", mod_path); + get_string_option("In what directory is the IRCd binary to be placed?", ".", bin_dir); + get_string_option("In what directory are the IRCd libraries to be placed?", "../lib", library_dir); + + printf_c("The following questions will ask you for various figures relating\n" + "To your IRCd install. Please note that these should usually be left\n" + "as defaults unless you have a real reason to change them. If they\n" + "changed, then the values must be identical on all servers on your\n" + "network, or malfunctions and/or crashes may occur, with the exception\n" + "of the 'maximum number of clients' setting which may be different on\n" + "different servers on the network.\n\n"); + + + max_clients = get_int_option("Please enter the maximum number of clients at any one time?", 1024); + nicklen = get_int_option("Please enter the maximum length of nicknames?", 31); + chanlen = get_int_option("Please enter the maximum length of channel names?", 64); + modechanges = get_int_option("Please enter the maximum number of mode changes in one line?", 20); + identlen = get_int_option("Please enter the maximum length of an ident (username)?", 12); + quitlen = get_int_option("Please enter the maximum length of a quit message?", 255); + topiclen = get_int_option("Please enter the maximum length of a channel topic?", 307); + kicklen = get_int_option("Please enter the maximum length of a kick message?", 255); + rllen = get_int_option("Please enter the maximum length of a GECOS (real name)?", 128); + awaylen = get_int_option("Please enter the maximum length of an away message?", 200); + + printf_c("\n\033[1;32mPre-build configuration is complete!\n\n"); sc(TNORMAL); + + // dump all the options back out + printf_c("\033[0mBase install path:\033[1;32m %s\n", base_path); + printf_c("\033[0mConfig path:\033[1;32m %s\n", config_file); + printf_c("\033[0mModule path:\033[1;32m %s\n", mod_path); + printf_c("\033[0mLibrary path:\033[1;32m %s\n", library_dir); + printf_c("\033[0mSocket Engine:\033[1;32m %s\n", use_iocp ? "iocp" : "select"); + printf_c("\033[0mMax file descriptors:\033[1;32m %u\n", max_fd); + printf_c("\033[0mMax connections:\033[1;32m %u\n", max_clients); + printf_c("\033[0mMax nickname length:\033[1;32m %u\n", nicklen); + printf_c("\033[0mMax channel length:\033[1;32m %u\n", chanlen); + printf_c("\033[0mMax mode length:\033[1;32m %u\n", modechanges); + printf_c("\033[0mMax ident length:\033[1;32m %u\n", identlen); + printf_c("\033[0mMax quit length:\033[1;32m %u\n", quitlen); + printf_c("\033[0mMax topic length:\033[1;32m %u\n", topiclen); + printf_c("\033[0mMax kick length:\033[1;32m %u\n", kicklen); + printf_c("\033[0mMax name length:\033[1;32m %u\n", rllen); + printf_c("\033[0mMax away length:\033[1;32m %u\n", awaylen); + printf("\n"); sc(TNORMAL); + if(get_bool_option("Are these settings correct?", true) == false) + { + Run(); + return; + } + printf("\n"); + + // escape the pathes + escape_string(config_file, MAX_PATH); + escape_string(mod_path, MAX_PATH); + escape_string(library_dir, MAX_PATH); + + printf("\nWriting inspircd_config.h..."); + FILE * f = fopen("inspircd_config.h", "w"); + fprintf(f, "/* Auto generated by configure, do not modify! */\n"); + fprintf(f, "#ifndef __CONFIGURATION_AUTO__\n"); + fprintf(f, "#define __CONFIGURATION_AUTO__\n\n"); + if(use_iocp) + fprintf(f, "#define CONFIG_USE_IOCP 1\n\n"); + + fprintf(f, "#define CONFIG_FILE \"%s/inspircd.conf\"\n", config_file); + fprintf(f, "#define MOD_PATH \"%s\"\n", mod_path); + fprintf(f, "#define MAX_DESCRIPTORS %u\n", max_fd); + fprintf(f, "#define MAXCLIENTS %u\n", max_clients); + fprintf(f, "#define MAXCLIENTS_S \"%u\"\n", max_clients); + fprintf(f, "#define SOMAXCONN_S \"128\"\n"); + fprintf(f, "#define NICKMAX %u\n", nicklen+1); + fprintf(f, "#define CHANMAX %u\n", chanlen+1); + fprintf(f, "#define MAXMODES %u\n", modechanges); + fprintf(f, "#define IDENTMAX %u\n", identlen); + fprintf(f, "#define MAXQUIT %u\n", quitlen); + fprintf(f, "#define MAXTOPIC %u\n", topiclen); + fprintf(f, "#define MAXKICK %u\n", kicklen); + fprintf(f, "#define MAXGECOS %u\n", rllen); + fprintf(f, "#define MAXAWAY %u\n", awaylen); + fprintf(f, "#define LIBRARYDIR \"%s\"\n", library_dir); + fprintf(f, "#define VERSION \"%s\"\n", version); + fprintf(f, "#define REVISION \"%s\"\n", revision_text); + if(support_ip6links) + fprintf(f, "#define SUPPORT_IP6LINKS 1\n"); + + OSVERSIONINFO vi; + vi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + GetVersionEx(&vi); + fprintf(f, "#define SYSTEM \"Windows %u.%u.%u %s\"\n", vi.dwMajorVersion, vi.dwMinorVersion, vi.dwBuildNumber, vi.szCSDVersion); + fprintf(f, "#define MAXBUF 514\n"); + + fprintf(f, "\n#include \"inspircd_win32wrapper.h\"\n\n"); + fprintf(f, "#endif\n\n"); + fclose(f); + + sc(TGREEN); printf(" done\n"); sc(TNORMAL); + printf("Writing inspircd_se_config.h..."); + + f = fopen("inspircd_se_config.h", "w"); + fprintf(f, "/* Auto generated by configure, do not modify or commit to svn! */\n"); + fprintf(f, "#ifndef __CONFIGURATION_SOCKETENGINE__\n"); + fprintf(f, "#define __CONFIGURATION_SOCKETENGINE__\n\n"); + fprintf(f, "#include \"socketengine_%s.h\"\n\n", use_iocp ? "iocp" : "select"); + fprintf(f, "#endif\n\n"); + fclose(f); + + sc(TGREEN); printf(" done\n"); sc(TNORMAL); + printf("Writing command and module compilation scripts..."); + WriteCompileCommands(); + WriteCompileModules(); + sc(TGREEN); printf(" done\n"); sc(TNORMAL); + + printf("\nconfigure is done.. exiting!\n"); +} + +void WriteCompileCommands() +{ + char commands[300][100]; + int command_count = 0; + printf("\n Finding Command Sources...\n"); + WIN32_FIND_DATA fd; + HANDLE fh = FindFirstFile("..\\src\\cmd_*.cpp", &fd); + if(fh == INVALID_HANDLE_VALUE) + printf_c("\033[1;32m No command sources could be found! This \033[1m*could*\033[1;32m be a bad thing.. :P\033[0m"); + else + { + sc(TGREEN); + do + { + strcpy(commands[command_count], fd.cFileName); + commands[command_count][strlen(fd.cFileName) - 4] = 0; + printf(" %s\n", commands[command_count]); + ++command_count; + } while(FindNextFile(fh, &fd)); + sc(TNORMAL); + } + + // Write our spiffy new makefile :D + // I am such a lazy fucker :P +#ifdef _DEBUG + FILE * f = fopen("..\\src\\commands.mak", "w"); +#else + FILE * f = fopen("..\\src\\commands-release.mak", "w"); +#endif + + fprintf(f, "# Generated at SOMETIME\n"); + fprintf(f, "!include \n\n"); + fprintf(f, "all: "); + + // dump modules.. first time :) + for(int i = 0; i < command_count; ++i) + fprintf(f, "%s.so ", commands[i]); + + fprintf(f, "\n.cpp.obj:\n"); +#ifdef _DEBUG + fprintf(f, " $(cc) /nologo /LD /Od /I \".\" /I \"../include\" /I \"../include/modes\" /I \"../include/commands\" /I \"../win\" /D \"WIN32\" /D \"_DEBUG\" /D \"_CONSOLE\" /D \"_MBCS\" /D \"DLL_BUILD\" /Gm /EHsc /GS /RTC1 /MTd /Fo\"Debug/\" /Fd\"Debug/vc70.pdb\" /W3 /Wp64 /Zi /TP $*.cpp ..\\win\\inspircd_memory_functions.cpp /link ..\\bin\\debug\\bin\\inspircd.lib /OUT:\"$*.so\"\n\n"); +#else + fprintf(f, " $(cc) /nologo /LD /Od /I \".\" /I \"../include\" /I \"../include/modes\" /I \"../include/commands\" /I \"../win\" /D \"WIN32\" /D \"_CONSOLE\" /D \"_MBCS\" /D \"DLL_BUILD\" /EHsc /GS /MT /Fo\"Release/\" /Fd\"Release/vc70.pdb\" /W3 /Wp64 /Zi /TP $*.cpp ..\\win\\inspircd_memory_functions.cpp /link ..\\bin\\release\\bin\\inspircd.lib /OUT:\"$*.so\"\n\n"); +#endif + + + // dump modules.. again the second and last time :) + for(int i = 0; i < command_count; ++i) + fprintf(f, "%s.so : %s.obj\n", commands[i], commands[i]); + + fprintf(f, "\n"); + fclose(f); +} + +void WriteCompileModules() +{ + char modules[300][100]; + int module_count = 0; + + printf("Finding Modules...\n"); + WIN32_FIND_DATA fd; + HANDLE fh = FindFirstFile("..\\src\\modules\\m_*.cpp", &fd); + if(fh == INVALID_HANDLE_VALUE) + printf_c("\033[1;32m No module sources could be found! This \033[1m*could*\033[1;32m be a bad thing.. :P\033[0m"); + else + { + sc(TGREEN); + do + { + strcpy(modules[module_count], fd.cFileName); + modules[module_count][strlen(fd.cFileName) - 4] = 0; + printf(" %s\n", modules[module_count]); + ++module_count; + } while(FindNextFile(fh, &fd)); + sc(TNORMAL); + } + + // Write our spiffy new makefile :D + // I am such a lazy fucker :P +#ifdef _DEBUG + FILE * f = fopen("..\\src\\modules\\modules.mak", "w"); +#else + FILE * f = fopen("..\\src\\modules\\modules-release.mak", "w"); +#endif + + fprintf(f, "# Generated at SOMETIME\n"); + fprintf(f, "!include \n\n"); + fprintf(f, "all: "); + + // dump modules.. first time :) + for(int i = 0; i < module_count; ++i) + fprintf(f, "%s.so ", modules[i]); + + fprintf(f, "\n.cpp.obj:\n"); +#ifdef _DEBUG + fprintf(f, " $(cc) /nologo /LD /Od /I \".\" /I \"../../include\" /I \"../../include/modes\" /I \"../../include/modules\" /I \"../../win\" /D \"WIN32\" /D \"_DEBUG\" /D \"_CONSOLE\" /D \"_MBCS\" /D \"DLL_BUILD\" /Gm /EHsc /GS /RTC1 /MTd /Fo\"Debug/\" /Fd\"Debug/vc70.pdb\" /W3 /Wp64 /Zi /TP $*.cpp ..\\..\\win\\inspircd_memory_functions.cpp /link ..\\..\\bin\\debug\\bin\\inspircd.lib ws2_32.lib /OUT:\"$*.so\"\n\n"); +#else + fprintf(f, " $(cc) /nologo /LD /Od /I \".\" /I \"../../include\" /I \"../../include/modes\" /I \"../../include/modules\" /I \"../../win\" /D \"WIN32\" /D \"_CONSOLE\" /D \"_MBCS\" /D \"DLL_BUILD\" /EHsc /GS /MT /Fo\"Release/\" /Fd\"Release/vc70.pdb\" /W3 /Wp64 /Zi /TP $*.cpp ..\\..\\win\\inspircd_memory_functions.cpp /link ..\\..\\bin\\release\\bin\\inspircd.lib ws2_32.lib /OUT:\"$*.so\"\n\n"); +#endif + + + // dump modules.. again the second and last time :) + for(int i = 0; i < module_count; ++i) + fprintf(f, "%s.so : %s.obj\n", modules[i], modules[i]); + + fprintf(f, "\n"); + fclose(f); +} diff --git a/win/configure.cpp.orig b/win/configure.cpp.orig new file mode 100644 index 000000000..e69de29bb diff --git a/win/configureVC71.vcproj b/win/configureVC71.vcproj new file mode 100644 index 000000000..59bb7bf24 --- /dev/null +++ b/win/configureVC71.vcproj @@ -0,0 +1,229 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/win/configureVC71.vcproj.orig b/win/configureVC71.vcproj.orig new file mode 100644 index 000000000..e69de29bb diff --git a/win/inspircdVC71.sln b/win/inspircdVC71.sln new file mode 100644 index 000000000..2570933bf --- /dev/null +++ b/win/inspircdVC71.sln @@ -0,0 +1,53 @@ +Microsoft Visual Studio Solution File, Format Version 8.00 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "inspircd", "inspircdVC71.vcproj", "{FE82A6FC-41C7-4CB1-AA46-6DBCB6C682C8}" + ProjectSection(ProjectDependencies) = postProject + {B922B569-727E-4EB0-827A-04E133A91DE7} = {B922B569-727E-4EB0-827A-04E133A91DE7} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "configure", "configureVC71.vcproj", "{B922B569-727E-4EB0-827A-04E133A91DE7}" + ProjectSection(ProjectDependencies) = postProject + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "m_spanningtree", "m_spanningtreeVC71.vcproj", "{1EC86B60-AB2A-4984-8A7E-0422C15601E0}" + ProjectSection(ProjectDependencies) = postProject + {FE82A6FC-41C7-4CB1-AA46-6DBCB6C682C8} = {FE82A6FC-41C7-4CB1-AA46-6DBCB6C682C8} + EndProjectSection +EndProject +Global + GlobalSection(SolutionConfiguration) = preSolution + Debug = Debug + Debug-Auto = Debug-Auto + Release = Release + Release-Auto = Release-Auto + EndGlobalSection + GlobalSection(ProjectConfiguration) = postSolution + {FE82A6FC-41C7-4CB1-AA46-6DBCB6C682C8}.Debug.ActiveCfg = Debug|Win32 + {FE82A6FC-41C7-4CB1-AA46-6DBCB6C682C8}.Debug.Build.0 = Debug|Win32 + {FE82A6FC-41C7-4CB1-AA46-6DBCB6C682C8}.Debug-Auto.ActiveCfg = Debug-Auto|Win32 + {FE82A6FC-41C7-4CB1-AA46-6DBCB6C682C8}.Debug-Auto.Build.0 = Debug-Auto|Win32 + {FE82A6FC-41C7-4CB1-AA46-6DBCB6C682C8}.Release.ActiveCfg = Release|Win32 + {FE82A6FC-41C7-4CB1-AA46-6DBCB6C682C8}.Release.Build.0 = Release|Win32 + {FE82A6FC-41C7-4CB1-AA46-6DBCB6C682C8}.Release-Auto.ActiveCfg = Release-Auto|Win32 + {FE82A6FC-41C7-4CB1-AA46-6DBCB6C682C8}.Release-Auto.Build.0 = Release-Auto|Win32 + {B922B569-727E-4EB0-827A-04E133A91DE7}.Debug.ActiveCfg = Debug|Win32 + {B922B569-727E-4EB0-827A-04E133A91DE7}.Debug.Build.0 = Debug|Win32 + {B922B569-727E-4EB0-827A-04E133A91DE7}.Debug-Auto.ActiveCfg = Debug-Auto|Win32 + {B922B569-727E-4EB0-827A-04E133A91DE7}.Debug-Auto.Build.0 = Debug-Auto|Win32 + {B922B569-727E-4EB0-827A-04E133A91DE7}.Release.ActiveCfg = Release|Win32 + {B922B569-727E-4EB0-827A-04E133A91DE7}.Release.Build.0 = Release|Win32 + {B922B569-727E-4EB0-827A-04E133A91DE7}.Release-Auto.ActiveCfg = Release-Auto|Win32 + {B922B569-727E-4EB0-827A-04E133A91DE7}.Release-Auto.Build.0 = Release-Auto|Win32 + {1EC86B60-AB2A-4984-8A7E-0422C15601E0}.Debug.ActiveCfg = Debug|Win32 + {1EC86B60-AB2A-4984-8A7E-0422C15601E0}.Debug.Build.0 = Debug|Win32 + {1EC86B60-AB2A-4984-8A7E-0422C15601E0}.Debug-Auto.ActiveCfg = Debug-Auto|Win32 + {1EC86B60-AB2A-4984-8A7E-0422C15601E0}.Debug-Auto.Build.0 = Debug-Auto|Win32 + {1EC86B60-AB2A-4984-8A7E-0422C15601E0}.Release.ActiveCfg = Release|Win32 + {1EC86B60-AB2A-4984-8A7E-0422C15601E0}.Release.Build.0 = Release|Win32 + {1EC86B60-AB2A-4984-8A7E-0422C15601E0}.Release-Auto.ActiveCfg = Release-Auto|Win32 + {1EC86B60-AB2A-4984-8A7E-0422C15601E0}.Release-Auto.Build.0 = Release-Auto|Win32 + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + EndGlobalSection + GlobalSection(ExtensibilityAddIns) = postSolution + EndGlobalSection +EndGlobal diff --git a/win/inspircdVC71.sln.orig b/win/inspircdVC71.sln.orig new file mode 100644 index 000000000..e69de29bb diff --git a/win/inspircdVC71.vcproj b/win/inspircdVC71.vcproj new file mode 100644 index 000000000..cb92e3c4c --- /dev/null +++ b/win/inspircdVC71.vcproj @@ -0,0 +1,515 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/win/inspircdVC71.vcproj.orig b/win/inspircdVC71.vcproj.orig new file mode 100644 index 000000000..e69de29bb diff --git a/win/inspircd_config.h b/win/inspircd_config.h new file mode 100644 index 000000000..82278a62d --- /dev/null +++ b/win/inspircd_config.h @@ -0,0 +1,32 @@ +/* Auto generated by configure, do not modify! */ +#ifndef __CONFIGURATION_AUTO__ +#define __CONFIGURATION_AUTO__ + +#define CONFIG_USE_IOCP 1 + +#define CONFIG_FILE "../conf/inspircd.conf" +#define MOD_PATH "../modules" +#define MAX_DESCRIPTORS 1024 +#define MAXCLIENTS 1024 +#define MAXCLIENTS_S "1024" +#define SOMAXCONN_S "128" +#define NICKMAX 32 +#define CHANMAX 65 +#define MAXMODES 20 +#define IDENTMAX 12 +#define MAXQUIT 255 +#define MAXTOPIC 307 +#define MAXKICK 255 +#define MAXGECOS 128 +#define MAXAWAY 200 +#define LIBRARYDIR "../lib" +#define VERSION "InspIRCd-1.1.7+Mozarella" +#define REVISION "7042" +#define SUPPORT_IP6LINKS 1 +#define SYSTEM "Windows 5.2.3790 Service Pack 1" +#define MAXBUF 514 + +#include "inspircd_win32wrapper.h" + +#endif + diff --git a/win/inspircd_config.h.orig b/win/inspircd_config.h.orig new file mode 100644 index 000000000..e69de29bb diff --git a/win/inspircd_memory_functions.cpp b/win/inspircd_memory_functions.cpp new file mode 100644 index 000000000..d03330bf5 --- /dev/null +++ b/win/inspircd_memory_functions.cpp @@ -0,0 +1,12 @@ +// Use the global heap for this process for all allocate/free operations. +#include "inspircd_win32wrapper.h" + +void * ::operator new(size_t iSize) +{ + return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, iSize); // zero memory for unix compatibility +} + +void ::operator delete(void * ptr) +{ + HeapFree(GetProcessHeap(), 0, ptr); +} diff --git a/win/inspircd_memory_functions.cpp.orig b/win/inspircd_memory_functions.cpp.orig new file mode 100644 index 000000000..e69de29bb diff --git a/win/inspircd_se_config.h b/win/inspircd_se_config.h new file mode 100644 index 000000000..284cc3352 --- /dev/null +++ b/win/inspircd_se_config.h @@ -0,0 +1,8 @@ +/* Auto generated by configure, do not modify or commit to svn! */ +#ifndef __CONFIGURATION_SOCKETENGINE__ +#define __CONFIGURATION_SOCKETENGINE__ + +#include "socketengine_iocp.h" + +#endif + diff --git a/win/inspircd_se_config.h.orig b/win/inspircd_se_config.h.orig new file mode 100644 index 000000000..e69de29bb diff --git a/win/inspircd_win32wrapper.cpp b/win/inspircd_win32wrapper.cpp new file mode 100644 index 000000000..dbca07862 --- /dev/null +++ b/win/inspircd_win32wrapper.cpp @@ -0,0 +1,375 @@ +#include "inspircd_win32wrapper.h" +#include "inspircd.h" +#include +#include +#include +using namespace std; + +#ifndef INADDR_NONE +#define INADDR_NONE 0xffffffff +#endif + +HANDLE hIPCPipe; + +int inet_aton(const char *cp, struct in_addr *addr) +{ + unsigned long ip = inet_addr(cp); + addr->s_addr = ip; + return (addr->s_addr == INADDR_NONE) ? 0 : 1; +} + +const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt) +{ + + if (af == AF_INET) + { + struct sockaddr_in in; + memset(&in, 0, sizeof(in)); + in.sin_family = AF_INET; + memcpy(&in.sin_addr, src, sizeof(struct in_addr)); + getnameinfo((struct sockaddr *)&in, sizeof(struct + sockaddr_in), dst, cnt, NULL, 0, NI_NUMERICHOST); + return dst; + } + else if (af == AF_INET6) + { + struct sockaddr_in6 in; + memset(&in, 0, sizeof(in)); + in.sin6_family = AF_INET6; + memcpy(&in.sin6_addr, src, sizeof(struct in_addr6)); + getnameinfo((struct sockaddr *)&in, sizeof(struct + sockaddr_in6), dst, cnt, NULL, 0, NI_NUMERICHOST); + return dst; + } + return NULL; +} + +int geteuid() +{ + return 1; +} + +int inet_pton(int af, const char *src, void *dst) +{ + sockaddr_in sa; + int len = sizeof(SOCKADDR); + int rv = WSAStringToAddress((LPSTR)src, af, NULL, (LPSOCKADDR)&sa, &len); + memcpy(dst, &sa.sin_addr, sizeof(struct in_addr)); + return rv; +} + +char * strtok_r(char *_String, const char *_Control, char **_Context) +{ + unsigned char *str; + const unsigned char *ctl = (const unsigned char*)_Control; + unsigned char map[32]; + + if(_Context == 0 || !_Control) + return 0; + + if(!(_String != NULL || *_Context != NULL)) + return 0; + + memset(map, 0, 32); + + do { + map[*ctl >> 3] |= (1 << (*ctl & 7)); + } while (*ctl++); + + /* If string is NULL, set str to the saved + * pointer (i.e., continue breaking tokens out of the string + * from the last strtok call) */ + if (_String != NULL) + { + str = (unsigned char*)_String; + } + else + { + str = (unsigned char*)*_Context; + } + + /* Find beginning of token (skip over leading delimiters). Note that + * there is no token iff this loop sets str to point to the terminal + * null (*str == 0) */ + while ((map[*str >> 3] & (1 << (*str & 7))) && *str != 0) + { + str++; + } + + _String = (char*)str; + + /* Find the end of the token. If it is not the end of the string, + * put a null there. */ + for ( ; *str != 0 ; str++ ) + { + if (map[*str >> 3] & (1 << (*str & 7))) + { + *str++ = 0; + break; + } + } + + /* Update context */ + *_Context = (char*)str; + + /* Determine if a token has been found. */ + if (_String == (char*)str) + { + return NULL; + } + else + { + return _String; + } +} + +void setcolor(int color_code) +{ + SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color_code); +} + +DIR * opendir(const char * path) +{ + std::string search_path = string(path) + "\\*.*"; + WIN32_FIND_DATA fd; + HANDLE f = FindFirstFile(search_path.c_str(), &fd); + if(f != INVALID_HANDLE_VALUE) + { + DIR * d = new DIR; + memcpy(&d->find_data, &fd, sizeof(WIN32_FIND_DATA)); + d->find_handle = f; + d->first = true; + return d; + } + else + { + return 0; + } +} + +dirent * readdir(DIR * handle) +{ + if(handle->first) + handle->first = false; + else + { + if(!FindNextFile(handle->find_handle, &handle->find_data)) + return 0; + } + + strncpy(handle->dirent_pointer.d_name, handle->find_data.cFileName, MAX_PATH); + return &handle->dirent_pointer; +} + +void closedir(DIR * handle) +{ + FindClose(handle->find_handle); + delete handle; +} + +const char * dlerror() +{ + static char errormessage[500]; + DWORD error = GetLastError(); + SetLastError(0); + if(error == 0) + return 0; + + FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 0, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)errormessage, 500, 0); + return errormessage; +} + +int printf_c(const char * format, ...) +{ + // Better hope we're not multithreaded, otherwise we'll have chickens crossing the road other side to get the to :P + static char message[500]; + static char temp[10]; + int color1, color2; + + /* parse arguments */ + va_list ap; + va_start(ap, format); + vsnprintf(message, 500, format, ap); + va_end(ap); + + /* search for unix-style escape sequences */ + int t; + int c = 0; + const char * p = message; + while(*p != 0) + { + if(*p == '\033') + { + // Escape sequence -> copy into the temp buffer, and parse the color. + p++; + t = 0; + while(*p != 'm') + { + temp[t++] = *p; + ++p; + } + + temp[t] = 0; + p++; + if(!stricmp(temp, "[0")) + { + // Returning to normal colour. + SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE); + } + else if(sscanf(temp, "[%u;%u", &color1, &color2) == 2) + { + switch(color2) + { + case 32: // Green + SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN | FOREGROUND_INTENSITY); // Yellow + break; + + default: // Unknown + // White + SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY); + break; + } + } + else + { + char message[50]; + sprintf("Unknown color code: %s", temp); + MessageBox(0, message, message, MB_OK); + } + } + + putchar(*p); + ++c; + ++p; + } + + return c; +} + +int arg_counter = 1; +char optarg[514]; +int getopt_long_only(int ___argc, char *const *___argv, const char *__shortopts, const struct option *__longopts, int *__longind) +{ + // burlex todo: handle the shortops, at the moment it only works with longopts. + + if(___argc == 1 || arg_counter == ___argc) // No arguments (apart from filename) + return -1; + + const char * opt = ___argv[arg_counter]; + int return_val = 0; + + // if we're not an option, return an error. + if(strnicmp(opt, "--", 2) != 0) + return 1; + else + opt += 2; + + + // parse argument list + int i = 0; + for(; __longopts[i].name != 0; ++i) + { + if(!strnicmp(__longopts[i].name, opt, strlen(__longopts[i].name))) + { + // woot, found a valid argument =) + char * par = 0; + if((arg_counter + 1) != ___argc) + { + // grab the parameter from the next argument (if its not another argument) + if(strnicmp(___argv[arg_counter+1], "--", 2) != 0) + { + arg_counter++; // Trash this next argument, we won't be needing it. + par = ___argv[arg_counter]; + } + } + + // increment the argument for next time + arg_counter++; + + // determine action based on type + if(__longopts[i].has_arg == required_argument && !par) + { + // parameter missing and its a required parameter option + return 1; + } + + // store argument in optarg + if(par) + strncpy(optarg, par, 514); + + if(__longopts[i].flag != 0) + { + // this is a variable, we have to set it if this argument is found. + *__longopts[i].flag = 1; + return 0; + } + else + { + if(__longopts[i].val == -1 || par == 0) + return 1; + + return __longopts[i].val; + } + break; + } + } + + // return 1 (invalid argument) + return 1; +} + +/* IPC Messages */ +#define IPC_MESSAGE_REHASH 1 +#define IPC_MESSAGE_DIE 2 +#define IPC_MESSAGE_RESTART 3 + +void InitIPC() +{ + static DWORD buflen = 1024; + static const char * pipename = "\\\\.\\mailslot\\Inspircd"; + hIPCPipe = CreateMailslot(pipename, buflen, 0, 0); + if(hIPCPipe == INVALID_HANDLE_VALUE) + printf("IPC Pipe could not be created. Are you sure you didn't start InspIRCd twice?\n"); +} + +void CheckIPC(InspIRCd * Instance) +{ + if(hIPCPipe == INVALID_HANDLE_VALUE) + return; + + DWORD bytes; + DWORD action; + + BOOL res = ReadFile(hIPCPipe, &action, sizeof(DWORD), &bytes, 0); + if(!res) + { + if(GetLastError() != ERROR_SEM_TIMEOUT) + printf("IPC Pipe Error %u: %s", GetLastError(), dlerror()); + return; + } + + printf("Got IPC Message: %u\n", action); + switch(action) + { + case IPC_MESSAGE_REHASH: + printf("Rehashing...\n"); + InspIRCd::Rehash(0); + break; + + case IPC_MESSAGE_DIE: + printf("Shutting down...\n"); + InspIRCd::Exit(0); + break; + + case IPC_MESSAGE_RESTART: + printf("Restarting...\n"); + Instance->Restart("IPC_MESSAGE_RESTART received by mailslot."); + break; + } +} + +void CloseIPC() +{ + CloseHandle(hIPCPipe); +} + diff --git a/win/inspircd_win32wrapper.cpp.orig b/win/inspircd_win32wrapper.cpp.orig new file mode 100644 index 000000000..e69de29bb diff --git a/win/inspircd_win32wrapper.h b/win/inspircd_win32wrapper.h new file mode 100644 index 000000000..a876b86ba --- /dev/null +++ b/win/inspircd_win32wrapper.h @@ -0,0 +1,162 @@ +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +/* Windows Port + Wrapper Functions/Definitions + By Burlex */ + +#ifndef INSPIRCD_WIN32WRAPPER_H +#define INSPIRCD_WIN32WRAPPER_H + +/* Define the WINDOWS macro. This means we're building on windows to the rest of the server. + I think this is more reasonable than using WIN32, especially if we're gonna be doing 64-bit compiles */ +#define WINDOWS 1 + +/* Macros for exporting symbols - dependant on what is being compiled */ + +#ifdef DLL_BUILD +#define CoreExport __declspec(dllimport) +#define DllExport __declspec(dllexport) +#else +#define CoreExport __declspec(dllexport) +#define DllExport __declspec(dllimport) +#endif + +/* Say we're building on windows 2000. Anyone running something older than this + * reeeeeeeally needs to upgrade! */ + +#define _WIN32_WINNT 0x500 + +/* Normal windows (platform-specific) includes */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* strcasecmp is not defined on windows by default */ +#define strcasecmp stricmp + +/* Error macros need to be redirected to winsock error codes */ +#define ETIMEDOUT WSAETIMEDOUT +#define ECONNREFUSED WSAECONNREFUSED +#define EADDRINUSE WSAEADDRINUSE +#define EINPROGRESS WSAEWOULDBLOCK + +/* Remember file descriptors are treated differently on windows ;) */ +__inline int close(int socket) { return closesocket(socket); } + +/* Convert formatted (xxx.xxx.xxx.xxx) string to in_addr struct */ +CoreExport int inet_pton(int af, const char * src, void * dst); + +/* Convert struct to formatted (xxx.xxx.xxx.xxx) string */ +CoreExport const char * inet_ntop(int af, const void * src, char * dst, socklen_t cnt); + +/* Safe printf functions aren't defined in VC2003 */ +#define snprintf _snprintf +#define vsnprintf _vsnprintf + +/* Recursive token function doesn't exist in VC++ */ +CoreExport char * strtok_r(char *_String, const char *_Control, char **_Context); + +/* Unix-style sleep (argument is in seconds) */ +__inline void sleep(int seconds) { Sleep(seconds * 1000); } + +/* IPV4 only convert string to address struct */ +CoreExport int inet_aton(const char *, struct in_addr *); + +/* Unix-style get running user id */ +CoreExport int geteuid(); + +/* Handles colors in printf */ +CoreExport int printf_c(const char * format, ...); + +/* getopt() wrapper */ +# define no_argument 0 +# define required_argument 1 +# define optional_argument 2 +struct option +{ + char *name; + int has_arg; + int *flag; + int val; +}; +extern char optarg[514]; +int getopt_long_only (int ___argc, char *const *___argv, const char *__shortopts, const struct option *__longopts, int *__longind); + +/* Accept Handlers */ +int CoreExport __accept_socket(SOCKET s, sockaddr * addr, int * addrlen, void * acceptevent); +int CoreExport __getsockname(SOCKET s, sockaddr * name, int * namelen, void * acceptevent); + +/* Module Loading */ +#define dlopen(path, state) (void*)LoadLibrary(path) +#define dlsym(handle, export) (void*)GetProcAddress((HMODULE)handle, export) +#define dlclose(handle) FreeLibrary((HMODULE)handle) +const char * dlerror(); + +/* Unix-style directory searching functions */ +#define chmod(filename, mode) +struct dirent +{ + char d_name[MAX_PATH]; +}; + +struct DIR +{ + dirent dirent_pointer; + HANDLE find_handle; + WIN32_FIND_DATA find_data; + bool first; +}; + +CoreExport DIR * opendir(const char * path); +CoreExport dirent * readdir(DIR * handle); +CoreExport void closedir(DIR * handle); + +/* Disable these stupid warnings.. */ +#pragma warning(disable:4800) +#pragma warning(disable:4251) +#pragma warning(disable:4275) +#pragma warning(disable:4996) +#pragma warning(disable:4244) // warning C4244: '=' : conversion from 'long' to 'short', possible loss of data +#pragma warning(disable:4267) // warning C4267: 'argument' : conversion from 'size_t' to 'int', possible loss of data +#pragma warning(disable:4805) // warning C4805: '!=' : unsafe mix of type 'char' and type 'bool' in operation +#pragma warning(disable:4311) // warning C4311: 'type cast' : pointer truncation from 'accept_overlap *' to 'int' +#pragma warning(disable:4312) // warning C4312: 'type cast' : conversion from 'int' to 'HANDLE' of greater size +#pragma warning(disable:4355) // warning C4355: 'this' : used in base member initializer list + +/* Mehhhh... typedefs. */ + +typedef unsigned char uint8_t; +typedef unsigned long long uint64_t; +typedef signed char int8_t; +typedef signed long int32_t; +typedef signed long long int64_t; + +void * ::operator new(size_t iSize); +void ::operator delete(void * ptr); + +/* IPC Handlers */ +class InspIRCd; + +void InitIPC(); +void CheckIPC(InspIRCd * Instance); +void CloseIPC(); + +#endif + diff --git a/win/inspircd_win32wrapper.h.orig b/win/inspircd_win32wrapper.h.orig new file mode 100644 index 000000000..e69de29bb diff --git a/win/m_spanningtreeVC71.vcproj b/win/m_spanningtreeVC71.vcproj new file mode 100644 index 000000000..35fba1aa6 --- /dev/null +++ b/win/m_spanningtreeVC71.vcproj @@ -0,0 +1,293 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/win/m_spanningtreeVC71.vcproj.orig b/win/m_spanningtreeVC71.vcproj.orig new file mode 100644 index 000000000..e69de29bb -- cgit v1.2.3