pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-05-31 09:06:46 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge upstream/master to incorporate EQEmu fixes

Browse Source 
Resolve CMake style conflict in common/CMakeLists.txt by adopting
the lowercase CMake command style used consistently throughout
the upstream codebase.
This commit is contained in:
Claude
2026-01-24 05:02:16 +00:00
parent 54d54f79ca 9d2cc213ce
commit 385b9922aa
1869 changed files with 10045 additions and 67384 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/CMakeLists.txt
+326 -351
View File
File diff suppressed because it is too large Load Diff
common/SocketLib/Base64.cpp
-266
View File
@@ -1,266 +0,0 @@
/** \file Base64.cpp
** \date 2004-02-13
** \author grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#include "Base64.h"
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
const char *Base64::bstr =
"ABCDEFGHIJKLMNOPQ"
"RSTUVWXYZabcdefgh"
"ijklmnopqrstuvwxy"
"z0123456789+/";
const char Base64::rstr[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0, 0, 0, 0,
0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0,
0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0, 0, 0, 0, 0};
void Base64::encode(FILE *fil, std::string& output, bool add_crlf)
{
size_t remain;
size_t i = 0;
size_t o = 0;
char input[4];
output = "";
remain = fread(input,1,3,fil);
while (remain > 0)
{
if (add_crlf && o && o % 76 == 0)
output += "\n";
switch (remain)
{
case 1:
output += bstr[ ((input[i] >> 2) & 0x3f) ];
output += bstr[ ((input[i] << 4) & 0x30) ];
output += "==";
break;
case 2:
output += bstr[ ((input[i] >> 2) & 0x3f) ];
output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
output += bstr[ ((input[i + 1] << 2) & 0x3c) ];
output += "=";
break;
default:
output += bstr[ ((input[i] >> 2) & 0x3f) ];
output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
output += bstr[ ((input[i + 1] << 2) & 0x3c) + ((input[i + 2] >> 6) & 0x03) ];
output += bstr[ (input[i + 2] & 0x3f) ];
}
o += 4;
//
remain = fread(input,1,3,fil);
}
}
void Base64::encode(const std::string& str_in, std::string& str_out, bool add_crlf)
{
encode(str_in.c_str(), str_in.size(), str_out, add_crlf);
}
void Base64::encode(const char* input,size_t l,std::string& output, bool add_crlf)
{
size_t i = 0;
size_t o = 0;
output = "";
while (i < l)
{
size_t remain = l - i;
if (add_crlf && o && o % 76 == 0)
output += "\n";
switch (remain)
{
case 1:
output += bstr[ ((input[i] >> 2) & 0x3f) ];
output += bstr[ ((input[i] << 4) & 0x30) ];
output += "==";
break;
case 2:
output += bstr[ ((input[i] >> 2) & 0x3f) ];
output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
output += bstr[ ((input[i + 1] << 2) & 0x3c) ];
output += "=";
break;
default:
output += bstr[ ((input[i] >> 2) & 0x3f) ];
output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
output += bstr[ ((input[i + 1] << 2) & 0x3c) + ((input[i + 2] >> 6) & 0x03) ];
output += bstr[ (input[i + 2] & 0x3f) ];
}
o += 4;
i += 3;
}
}
void Base64::encode(unsigned char* input,size_t l,std::string& output,bool add_crlf)
{
size_t i = 0;
size_t o = 0;
output = "";
while (i < l)
{
size_t remain = l - i;
if (add_crlf && o && o % 76 == 0)
output += "\n";
switch (remain)
{
case 1:
output += bstr[ ((input[i] >> 2) & 0x3f) ];
output += bstr[ ((input[i] << 4) & 0x30) ];
output += "==";
break;
case 2:
output += bstr[ ((input[i] >> 2) & 0x3f) ];
output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
output += bstr[ ((input[i + 1] << 2) & 0x3c) ];
output += "=";
break;
default:
output += bstr[ ((input[i] >> 2) & 0x3f) ];
output += bstr[ ((input[i] << 4) & 0x30) + ((input[i + 1] >> 4) & 0x0f) ];
output += bstr[ ((input[i + 1] << 2) & 0x3c) + ((input[i + 2] >> 6) & 0x03) ];
output += bstr[ (input[i + 2] & 0x3f) ];
}
o += 4;
i += 3;
}
}
void Base64::decode(const std::string& input,std::string& output)
{
size_t i = 0;
size_t l = input.size();
output = "";
while (i < l)
{
while (i < l && (input[i] == 13 || input[i] == 10))
i++;
if (i < l)
{
char b1 = (char)((rstr[(int)input[i]] << 2 & 0xfc) +
(rstr[(int)input[i + 1]] >> 4 & 0x03));
output += b1;
if (input[i + 2] != '=')
{
char b2 = (char)((rstr[(int)input[i + 1]] << 4 & 0xf0) +
(rstr[(int)input[i + 2]] >> 2 & 0x0f));
output += b2;
}
if (input[i + 3] != '=')
{
char b3 = (char)((rstr[(int)input[i + 2]] << 6 & 0xc0) +
rstr[(int)input[i + 3]]);
output += b3;
}
i += 4;
}
}
}
void Base64::decode(const std::string& input, unsigned char *output, size_t& sz)
{
size_t i = 0;
size_t l = input.size();
size_t j = 0;
while (i < l)
{
while (i < l && (input[i] == 13 || input[i] == 10))
i++;
if (i < l)
{
unsigned char b1 = (unsigned char)((rstr[(int)input[i]] << 2 & 0xfc) +
(rstr[(int)input[i + 1]] >> 4 & 0x03));
if (output)
{
output[j] = b1;
}
j++;
if (input[i + 2] != '=')
{
unsigned char b2 = (unsigned char)((rstr[(int)input[i + 1]] << 4 & 0xf0) +
(rstr[(int)input[i + 2]] >> 2 & 0x0f));
if (output)
{
output[j] = b2;
}
j++;
}
if (input[i + 3] != '=')
{
unsigned char b3 = (unsigned char)((rstr[(int)input[i + 2]] << 6 & 0xc0) +
rstr[(int)input[i + 3]]);
if (output)
{
output[j] = b3;
}
j++;
}
i += 4;
}
}
sz = j;
}
size_t Base64::decode_length(const std::string& str64)
{
if (!str64.size() || str64.size() % 4)
return 0;
size_t l = 3 * (str64.size() / 4 - 1) + 1;
if (str64[str64.size() - 2] != '=')
l++;
if (str64[str64.size() - 1] != '=')
l++;
return l;
}
#ifdef SOCKETS_NAMESPACE
}
#endif
common/SocketLib/Base64.h
-67
View File
@@ -1,67 +0,0 @@
/** \file Base64.h
** \date 2004-02-13
** \author grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#ifndef _BASE64_H
#define _BASE64_H
#include <stdio.h>
#include <string>
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
/** \defgroup util Utilities */
/** Base64 encode/decode.
\ingroup util */
class Base64 {
public:
static void encode(FILE *, std::string& , bool add_crlf = true);
static void encode(const std::string&, std::string& , bool add_crlf = true);
static void encode(const char *, size_t, std::string& , bool add_crlf = true);
static void encode(unsigned char *, size_t, std::string& , bool add_crlf = true);
static void decode(const std::string&, std::string& );
static void decode(const std::string& in, unsigned char *out, size_t&);
static size_t decode_length(const std::string& );
private:
static const char *bstr;
static const char rstr[128];
};
#ifdef SOCKETS_NAMESPACE
}
#endif
#endif // _BASE64_H
common/SocketLib/File.cpp
-126
View File
@@ -1,126 +0,0 @@
/** \file File.cpp
** \date 2005-04-25
** \author grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#include <stdio.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifndef _WIN32
#include <unistd.h>
#endif
#include "File.h"
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
File::File()
:m_fil(nullptr)
{
}
File::~File()
{
}
bool File::fopen(const std::string& path, const std::string& mode)
{
m_path = path;
m_mode = mode;
m_fil = ::fopen(path.c_str(), mode.c_str());
return m_fil ? true : false;
}
void File::fclose()
{
if (m_fil)
::fclose(m_fil);
}
size_t File::fread(char *ptr, size_t size, size_t nmemb)
{
return m_fil ? ::fread(ptr, size, nmemb, m_fil) : 0;
}
size_t File::fwrite(const char *ptr, size_t size, size_t nmemb)
{
return m_fil ? ::fwrite(ptr, size, nmemb, m_fil) : 0;
}
char *File::fgets(char *s, int size)
{
return m_fil ? ::fgets(s, size, m_fil) : nullptr;
}
void File::fprintf(char *format, ...)
{
va_list ap;
va_start(ap, format);
vfprintf(m_fil, format, ap);
va_end(ap);
}
off_t File::size()
{
struct stat st;
if (stat(m_path.c_str(), &st) == -1)
{
return 0;
}
return st.st_size;
}
bool File::eof()
{
if (m_fil)
{
if (feof(m_fil))
return true;
}
return false;
}
#ifdef SOCKETS_NAMESPACE
}
#endif
common/SocketLib/File.h
-76
View File
@@ -1,76 +0,0 @@
/** \file File.h
** \date 2005-04-25
** \author grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#ifndef _FILE_H
#define _FILE_H
#include "IFile.h"
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
/** IFile implementation of a disk file.
\ingroup file */
class File : public IFile
{
public:
File();
~File();
bool fopen(const std::string&, const std::string&);
void fclose();
size_t fread(char *, size_t, size_t);
size_t fwrite(const char *, size_t, size_t);
char *fgets(char *, int);
void fprintf(char *format, ...);
off_t size();
bool eof();
private:
File(const File& ) {} // copy constructor
File& operator=(const File& ) { return *this; } // assignment operator
std::string m_path;
std::string m_mode;
FILE *m_fil;
};
#ifdef SOCKETS_NAMESPACE
}
#endif
#endif // _FILE_H
common/SocketLib/HTTPSocket.cpp
-366
View File
@@ -1,366 +0,0 @@
/* EQEMu: Everquest Server Emulator
*
* This code originated from `C++ Sockets Library` referenced below.
* Taken and stripped/modified to remove dependancies on parts of
* the library which we are not using, and to suit other needs.
* 2006 - EQEMu Development Team (http://eqemulator.net)
*
*
*/
/** \file HTTPSocket.cpp
** \date 2004-04-06
** \author grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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 "../global_define.h"
#include <stdio.h>
#include <string>
#include <stdarg.h>
#include "Parse.h"
#include "HTTPSocket.h"
#include "../tcp_connection.h"
#include <cstdlib>
#include <cstring>
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
HTTPSocket::HTTPSocket(uint32 ID, SOCKET in_socket, uint32 irIP, uint16 irPort)
:TCPConnection(ID,in_socket,irIP,irPort)
,m_first(true)
,m_header(true)
,m_http_version("HTTP/1.0")
,m_request(false)
,m_response(false)
{
}
HTTPSocket::~HTTPSocket()
{
}
/*
* eqemu stuff
*/
bool HTTPSocket::ProcessReceivedData(char *errbuf)
{
if (errbuf)
errbuf[0] = 0;
if (!recvbuf)
return true;
char *buff=(char *)recvbuf;
unsigned long bufflen=recvbuf_used;
while(1) {
if (m_header) {
char *ptr=(char *)memchr(buff,'\n',bufflen);
if (!ptr)
break;
int length=(ptr-buff)+1;
std::string line;
line.append(buff,length-2);
OnLine(line);
buff+=length;
bufflen-=length;
} else {
OnData(buff,bufflen);
buff+=bufflen;
bufflen=0;
break;
}
}
if (bufflen) {
memmove(recvbuf,buff,bufflen);
recvbuf_used=bufflen;
} else {
safe_delete_array(recvbuf);
}
}
bool HTTPSocket::SendString(const char *str) {
return(TCPConnection::Send((const uchar *) str, strlen(str)));
}
bool HTTPSocket::SendBuf(const char *dat, unsigned int len) {
return(TCPConnection::Send((const uchar *) dat, len));
}
/*
* /eqemu stuff
*/
void HTTPSocket::OnLine(const std::string& line)
{
if (m_first)
{
Parse pa(line);
std::string str = pa.getword();
if (str.substr(0,4) == "HTTP") // response
{
m_http_version = str;
m_status = pa.getword();
m_status_text = pa.getrest();
m_response = true;
}
else // request
{
m_method = str;
m_url = pa.getword();
size_t spl = m_url.find("?");
if (spl != std::string::npos)
{
m_uri = m_url.substr(0,spl);
m_query_string = m_url.substr(spl + 1);
}
else
{
m_uri = m_url;
}
m_http_version = pa.getword();
m_request = true;
}
m_first = false;
OnFirst();
return;
}
if (!line.size())
{
// SetLineProtocol(false);
m_header = false;
OnHeaderComplete();
return;
}
Parse pa(line,":");
std::string key = pa.getword();
std::string value = pa.getrest();
OnHeader(key,value);
/* If remote end tells us to keep connection alive, and we're operating
in http/1.1 mode (not http/1.0 mode), then we mark the socket to be
retained. */
/* if (!strcasecmp(key.c_str(), "connection") &&
!strcasecmp(value.c_str(), "keep-alive") )
{
SetRetain();
}*/
}
void HTTPSocket::SendResponse()
{
std::string msg;
msg = m_http_version + " " + m_status + " " + m_status_text + "\r\n";
for (string_m::iterator it = m_response_header.begin(); it != m_response_header.end(); it++)
{
std::string key = (*it).first;
std::string val = (*it).second;
msg += key + ": " + val + "\r\n";
}
msg += "\r\n";
SendString( msg.c_str() );
}
void HTTPSocket::AddResponseHeader(const std::string& header, const char *format, ...)
{
static char slask[5000];
va_list ap;
va_start(ap, format);
#ifdef _WIN32
vsprintf(slask, format, ap);
#else
vsnprintf(slask, 5000, format, ap);
#endif
va_end(ap);
m_response_header[header] = slask;
}
void HTTPSocket::SendRequest()
{
std::string msg;
msg = m_method + " " + m_url + " " + m_http_version + "\r\n";
for (string_m::iterator it = m_response_header.begin(); it != m_response_header.end(); it++)
{
std::string key = (*it).first;
std::string val = (*it).second;
msg += key + ": " + val + "\r\n";
}
msg += "\r\n";
SendString( msg.c_str() );
}
std::string HTTPSocket::MyUseragent()
{
std::string version = "C++Sockets/";
#ifdef _VERSION
version += _VERSION;
#endif
return version;
}
void HTTPSocket::Reset()
{
m_first = true;
m_header = true;
m_request = false;
m_response = false;
// SetLineProtocol(true);
while (m_response_header.size())
{
string_m::iterator it = m_response_header.begin();
m_response_header.erase(it);
}
}
const std::string& HTTPSocket::GetMethod()
{
return m_method;
}
void HTTPSocket::SetMethod(const std::string& x)
{
m_method = x;
}
const std::string& HTTPSocket::GetUrl()
{
return m_url;
}
void HTTPSocket::SetUrl(const std::string& x)
{
m_url = x;
}
const std::string& HTTPSocket::GetUri()
{
return m_uri;
}
const std::string& HTTPSocket::GetQueryString()
{
return m_query_string;
}
const std::string& HTTPSocket::GetHttpVersion()
{
return m_http_version;
}
const std::string& HTTPSocket::GetStatus()
{
return m_status;
}
const std::string& HTTPSocket::GetStatusText()
{
return m_status_text;
}
bool HTTPSocket::IsRequest()
{
return m_request;
}
bool HTTPSocket::IsResponse()
{
return m_response;
}
void HTTPSocket::SetHttpVersion(const std::string& x)
{
m_http_version = x;
}
void HTTPSocket::SetStatus(const std::string& num, const std::string& text) {
m_status = num;
m_status_text = text;
}
void HTTPSocket::SetStatus(const std::string& x)
{
m_status = x;
}
void HTTPSocket::SetStatusText(const std::string& x)
{
m_status_text = x;
}
void HTTPSocket::AddResponseHeader(const std::string& x,const std::string& y)
{
m_response_header[x] = y;
}
void HTTPSocket::SetUri(const std::string& x)
{
m_uri = x;
}
void HTTPSocket::SendResponse(const std::string& status_num, const std::string& status_text) {
SetStatus(status_num, status_text);
SendResponse();
}
#ifdef SOCKETS_NAMESPACE
}
#endif
common/SocketLib/HTTPSocket.h
-137
View File
@@ -1,137 +0,0 @@
/* EQEMu: Everquest Server Emulator
*
* This code originated from `C++ Sockets Library` referenced below.
* Taken and stripped/modified to remove dependancies on parts of
* the library which we are not using, and to suit other needs.
* 2006 - EQEMu Development Team (http://eqemulator.net)
*
*
*/
/** \file HTTPSocket.h Class HTTPSocket definition.
** \date 2004-04-06
** \author grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#ifndef _HTTPSOCKET_H
#define _HTTPSOCKET_H
#include <map>
#include <string>
#include "../tcp_connection.h"
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
/** \defgroup http HTTP Sockets */
/** HTTP request/response base class.
\ingroup http */
class HTTPSocket : public TCPConnection
{
/** map to hold http header values. */
typedef std::map<std::string,std::string> string_m;
public:
HTTPSocket(uint32 ID, SOCKET in_socket, uint32 irIP, uint16 irPort);
virtual ~HTTPSocket();
void OnLine(const std::string& line);
/** Callback executes when first line has been received.
GetMethod, GetUrl/GetUri, and GetHttpVersion are valid when this callback is executed. */
virtual void OnFirst() = 0;
/** For each header line this callback is executed.
\param key Http header name
\param value Http header value */
virtual void OnHeader(const std::string& key,const std::string& value) = 0;
/** Callback fires when all http headers have been received. */
virtual void OnHeaderComplete() = 0;
/** Chunk of http body data recevied. */
virtual void OnData(const char *,size_t) = 0;
const std::string& GetMethod();
void SetMethod(const std::string& x);
const std::string& GetUrl();
void SetUrl(const std::string& x);
const std::string& GetUri();
void SetUri(const std::string& x);
const std::string& GetQueryString();
const std::string& GetHttpVersion();
const std::string& GetStatus();
const std::string& GetStatusText();
bool IsRequest();
bool IsResponse();
void SetHttpVersion(const std::string& x);
void SetStatus(const std::string& x);
void SetStatus(const std::string& num, const std::string& text);
void SetStatusText(const std::string& x);
void AddResponseHeader(const std::string& x,const std::string& y);
void AddResponseHeader(const std::string& x,const char *format, ...);
void SendResponse();
void SendResponse(const std::string& status_num, const std::string& status_text);
void SendRequest();
/** Implement this to return your own User-agent string. */
virtual std::string MyUseragent();
protected:
/** Reset state of socket to sucessfully implement keep-alive. */
virtual void Reset();
//stubs for crap which used to be in our parent class (TcpSocket)
bool SendString(const char *str);
bool SendBuf(const char *dat, unsigned int len);
virtual bool ProcessReceivedData(char* errbuf = 0);
private:
// HTTPSocket& operator=(const HTTPSocket& ) { return *this; }
bool m_first;
bool m_header;
std::string m_line;
std::string m_method;
std::string m_url;
std::string m_uri;
std::string m_query_string;
std::string m_http_version;
std::string m_status;
std::string m_status_text;
bool m_request;
bool m_response;
string_m m_response_header;
};
#ifdef SOCKETS_NAMESPACE
}
#endif
#endif // _HTTPSOCKET_H
common/SocketLib/HttpdCookies.cpp
-250
View File
@@ -1,250 +0,0 @@
/** \file HttpdCookies.cpp
*/
/*
Copyright (C) 2003-2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#include "../global_define.h"
#ifdef _WIN32
#pragma warning(disable:4786)
#endif
#include "Parse.h"
#include "Utility.h"
#include "HTTPSocket.h"
#include "HttpdCookies.h"
#include "../types.h"
#include <time.h>
#include <cstdlib>
#include <cstring>
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
HttpdCookies::HttpdCookies()
{
}
HttpdCookies::HttpdCookies(const std::string& s)
{
Parse *pa = new Parse(s,";");
std::string slask = pa -> getword();
while (slask.size())
{
Parse *pa2 = new Parse(slask,"=");
std::string name = pa2 -> getword();
std::string value = pa2 -> getword();
delete pa2;
COOKIE *c = new COOKIE(name,value);
m_cookies.push_back(c);
//
slask = pa -> getword();
}
delete pa;
}
HttpdCookies::~HttpdCookies()
{
for (cookie_v::iterator it = m_cookies.begin(); it != m_cookies.end(); it++)
{
COOKIE *c = *it;
delete c;
}
}
bool HttpdCookies::getvalue(const std::string& name,std::string& buffer) //char *buffer,size_t length)
{
for (cookie_v::iterator it = m_cookies.begin(); it != m_cookies.end(); it++)
{
COOKIE *c = *it;
if (!strcasecmp(c -> name.c_str(),name.c_str()))
{
buffer = c -> value;
return true;
}
}
buffer = "";
return false;
}
void HttpdCookies::replacevalue(const std::string& name,const std::string& value)
{
COOKIE *c = nullptr;
for (cookie_v::iterator it = m_cookies.begin(); it != m_cookies.end(); it++)
{
c = *it;
if (!strcasecmp(c -> name.c_str(),name.c_str()))
break;
c = nullptr;
}
if (c)
{
c -> value = value;
}
else
{
c = new COOKIE(name,value);
m_cookies.push_back(c);
}
}
void HttpdCookies::replacevalue(const std::string& name,long l)
{
replacevalue(name, Utility::l2string(l));
}
void HttpdCookies::replacevalue(const std::string& name,int i)
{
replacevalue(name, Utility::l2string(i));
}
size_t HttpdCookies::getlength(const std::string& name)
{
COOKIE *c = nullptr;
for (cookie_v::iterator it = m_cookies.begin(); it != m_cookies.end(); it++)
{
c = *it;
if (!strcasecmp(c -> name.c_str(),name.c_str()))
break;
c = nullptr;
}
return c ? c -> value.size() : 0;
}
void HttpdCookies::setcookie(HTTPSocket *sock, const std::string& domain, const std::string& path, const std::string& name, const std::string& value)
{
char *str = new char[name.size() + value.size() + domain.size() + path.size() + 100];
// set-cookie response
if (domain.size())
{
sprintf(str, "%s=%s; domain=%s; path=%s; expires=%s",
name.c_str(), value.c_str(),
domain.c_str(),
path.c_str(),
expiredatetime().c_str());
}
else
{
sprintf(str, "%s=%s; path=%s; expires=%s",
name.c_str(), value.c_str(),
path.c_str(),
expiredatetime().c_str());
}
sock -> AddResponseHeader("Set-cookie", str);
delete[] str;
replacevalue(name, value);
}
void HttpdCookies::setcookie(HTTPSocket *sock, const std::string& domain, const std::string& path, const std::string& name, long value)
{
char *str = new char[name.size() + domain.size() + path.size() + 100];
char dt[80];
// set-cookie response
if (domain.size())
{
sprintf(str, "%s=%ld; domain=%s; path=%s; expires=%s",
name.c_str(), value,
domain.c_str(),
path.c_str(),
expiredatetime().c_str());
}
else
{
sprintf(str, "%s=%ld; path=%s; expires=%s",
name.c_str(), value,
path.c_str(),
expiredatetime().c_str());
}
sock -> AddResponseHeader("Set-cookie", str);
delete[] str;
sprintf(dt, "%ld", value);
replacevalue(name, dt);
}
void HttpdCookies::setcookie(HTTPSocket *sock, const std::string& domain, const std::string& path, const std::string& name, int value)
{
char *str = new char[name.size() + domain.size() + path.size() + 100];
char dt[80];
// set-cookie response
if (domain.size())
{
sprintf(str, "%s=%d; domain=%s; path=%s; expires=%s",
name.c_str(), value,
domain.c_str(),
path.c_str(),
expiredatetime().c_str());
}
else
{
sprintf(str, "%s=%d; path=%s; expires=%s",
name.c_str(), value,
path.c_str(),
expiredatetime().c_str());
}
sock -> AddResponseHeader("Set-cookie", str);
delete[] str;
sprintf(dt, "%d", value);
replacevalue(name, dt);
}
const std::string& HttpdCookies::expiredatetime()
{
time_t t = time(nullptr);
struct tm * tp = gmtime(&t);
const char *days[7] = {"Sunday", "Monday",
"Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
const char *months[12] = {"Jan", "Feb", "Mar", "Apr", "May",
"Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
char dt[100];
sprintf(dt, "%s, %02d-%s-%04d %02d:%02d:%02d GMT",
days[tp -> tm_wday],
tp -> tm_mday,
months[tp -> tm_mon],
tp -> tm_year + 1910,
tp -> tm_hour,
tp -> tm_min,
tp -> tm_sec);
m_date = dt;
return m_date;
}
#ifdef SOCKETS_NAMESPACE
}
#endif
common/SocketLib/HttpdCookies.h
-91
View File
@@ -1,91 +0,0 @@
/** \file HttpdCookies.h
*/
/*
Copyright (C) 2003-2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#ifndef _COOKIES_H
#define _COOKIES_H
#include <list>
#include <string>
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
//! Store the cookies name/value pairs.
//! Retrieve and manage cookies during a cgi call.
class HTTPSocket;
/** HTTP Cookie parse/container class.
\sa HttpdSocket
\sa HttpdForm
\ingroup webserver */
class HttpdCookies
{
/** Name/value pair store struct.
\ingroup webserver */
struct COOKIE
{
COOKIE(const std::string& n,const std::string& v) : name(n),value(v) {}
std::string name;
std::string value;
};
/** list of key/value structs. */
typedef std::list<COOKIE *> cookie_v;
public:
HttpdCookies();
HttpdCookies(const std::string& query_string);
~HttpdCookies();
// int getvalue(const std::string& ,char *,size_t); // (name, buffer, length)
bool getvalue(const std::string&,std::string&);
void replacevalue(const std::string& ,const std::string& );
void replacevalue(const std::string& ,long);
void replacevalue(const std::string& ,int);
size_t getlength(const std::string& );
void setcookie(HTTPSocket *,const std::string& d,const std::string& p,const std::string& c,const std::string& v);
void setcookie(HTTPSocket *,const std::string& d,const std::string& p,const std::string& c,long v);
void setcookie(HTTPSocket *,const std::string& d,const std::string& p,const std::string& c,int v);
const std::string& expiredatetime();
cookie_v& GetHttpdCookies() { return m_cookies; }
private:
cookie_v m_cookies;
std::string m_date;
};
#ifdef SOCKETS_NAMESPACE
}
#endif
#endif // _COOKIES_H
common/SocketLib/HttpdForm.cpp
-621
View File
@@ -1,621 +0,0 @@
/** \file HttpdForm.cpp - read stdin, parse cgi input
**
** Written: 1999-Feb-10 grymse@alhem.net
**/
/*
Copyright (C) 1999-2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#include <stdio.h>
#ifdef _WIN32
#pragma warning(disable:4786)
#include <windows.h>
#endif
#include "socket_include.h"
#include "Parse.h"
#include "IFile.h"
#include "HttpdForm.h"
#include <cstdlib>
#include <cstring>
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
HttpdForm::HttpdForm(IFile *infil) : raw(false)
{
CGI *cgi = nullptr;
char *c_t = getenv("CONTENT_TYPE");
char *c_l = getenv("CONTENT_LENGTH");
size_t extra = 2;
char name[200];
m_current = m_cgi.end();
*name = 0;
if (c_t && !strncmp(c_t, "multipart/form-data",19))
{
Parse pa(c_t,";=");
char *tempcmp = nullptr;
size_t tc = 0;
size_t l = 0;
std::string str = pa.getword();
m_strBoundary = "";
while (str.size())
{
if (!strcmp(str.c_str(),"boundary"))
{
m_strBoundary = pa.getword();
l = m_strBoundary.size();
tempcmp = new char[l + extra];
}
//
str = pa.getword();
}
if (m_strBoundary.size())
{
std::string content_type;
std::string current_name;
std::string current_filename;
char slask[2000];
infil -> fgets(slask, 200);
while (!infil -> eof())
{
while (strlen(slask) && (slask[strlen(slask) - 1] == 13 || slask[strlen(slask) - 1] == 10))
{
slask[strlen(slask) - 1] = 0;
}
content_type = "";
current_name = "";
current_filename = "";
if ((strstr(slask,m_strBoundary.c_str()) || strstr(m_strBoundary.c_str(),slask)) && strcmp(slask, m_strBoundary.c_str()))
{
m_strBoundary = slask;
l = m_strBoundary.size();
delete[] tempcmp;
tempcmp = new char[l + extra];
}
if (!strcmp(slask, m_strBoundary.c_str()))
{
// Get headers until empty line
infil -> fgets(slask, 200);
while (strlen(slask) && (slask[strlen(slask) - 1] == 13 || slask[strlen(slask) - 1] == 10))
{
slask[strlen(slask) - 1] = 0;
}
while (!infil -> eof() && *slask)
{
Parse pa(slask,";");
std::string h = pa.getword();
if (!strcasecmp(h.c_str(),"Content-type:"))
{
content_type = pa.getword();
}
else
if (!strcasecmp(h.c_str(),"Content-Disposition:"))
{
h = pa.getword();
if (!strcmp(h.c_str(),"form-data"))
{
pa.EnableQuote(true);
h = pa.getword();
while (h.size())
{
Parse pa2(slask,"=");
std::string name = pa2.getword();
std::string h = pa2.getrest();
if (!strcmp(name.c_str(),"name"))
{
if (h.size() && h[0] == '"')
{
current_name = h.substr(1, h.size() - 2);
}
else
{
current_name = h;
}
}
else
if (!strcmp(name.c_str(),"filename"))
{
if (h.size() && h[0] == '"')
{
current_filename = h.substr(1, h.size() - 2);
}
else
{
current_filename = h;
}
size_t x = 0;
for (size_t i = 0; i < current_filename.size(); i++)
{
if (current_filename[i] == '/' || current_filename[i] == '\\')
x = i + 1;
}
if (x)
{
current_filename = current_filename.substr(x);
}
}
h = pa.getword();
}
}
}
// get next header value
infil -> fgets(slask, 200);
while (strlen(slask) && (slask[strlen(slask) - 1] == 13 || slask[strlen(slask) - 1] == 10))
{
slask[strlen(slask) - 1] = 0;
}
}
// Read content, save...?
if (!current_filename.size()) // not a file
{
std::string val;
infil -> fgets(slask,1000);
while (!infil -> eof() && strncmp(slask,m_strBoundary.c_str(),m_strBoundary.size() ))
{
val += slask;
infil -> fgets(slask,1000);
}
// remove trailing cr/linefeed
while (val.size() && (val[val.size() - 1] == 13 || val[val.size() - 1] == 10))
{
val = val.substr(0,val.size() - 1);
}
cgi = new CGI(current_name, val);
m_cgi.push_back(cgi);
}
else // current_filename.size() > 0
{
// read until m_strBoundary...
FILE *fil;
int out = 0;
char c;
char fn[1000]; // where post'd file will be saved
#ifdef _WIN32
{
char tmp_path[1000];
::GetTempPath(1000, tmp_path);
if (tmp_path[strlen(tmp_path) - 1] != '\\')
{
strcat(tmp_path, "\\");
}
sprintf(fn,"%s%s",tmp_path,current_filename.c_str());
}
#else
sprintf(fn,"/tmp/%s",current_filename.c_str());
#endif
if ((fil = fopen(fn, "wb")) != nullptr)
{
infil -> fread(&c,1,1);
while (!infil -> eof())
{
if (out)
{
fwrite(&tempcmp[tc],1,1,fil);
}
tempcmp[tc] = c;
tc++;
if (tc >= l + extra)
{
tc = 0;
out = 1;
}
if (tc)
{
if (!strncmp(tempcmp + tc + extra, m_strBoundary.c_str(), l - tc) &&
!strncmp(tempcmp, m_strBoundary.c_str() + l - tc, tc))
{
break;
}
}
else
{
if (!strncmp(tempcmp + extra, m_strBoundary.c_str(), l))
{
break;
}
}
infil -> fread(&c,1,1);
}
fclose(fil);
cgi = new CGI(current_name,fn,fn);
m_cgi.push_back(cgi);
strcpy(slask, m_strBoundary.c_str());
infil -> fgets(slask + strlen(slask), 200); // next line
}
else
{
// couldn't open file
break;
}
}
}
else
{
// Probably '<m_strBoundary>--'
break;
}
} // while (!infil -> eof())
} // if (m_strBoundary)
if (tempcmp)
{
delete[] tempcmp;
}
}
else
{
int i = 0;
int cl = c_l ? atoi(c_l) : -1;
char c,chigh,clow;
char *slask = new char[8888];
bool got_name = false;
m_current = m_cgi.end();
*name = 0;
infil -> fread(&c,1,1);
cl--;
while (cl >= 0)
{
switch (c)
{
case '=': /* end of name */
slask[i] = 0;
i = 0;
strcpy(name,slask);
got_name = true;
break;
case '&': /* end of value */
slask[i] = 0;
i = 0;
if(got_name) {
got_name = false;
cgi = new CGI(name,slask);
m_cgi.push_back(cgi);
} else {
cgi = new CGI(slask,"");
m_cgi.push_back(cgi);
}
break;
case '+': /* space */
slask[i++] = ' ';
break;
case '%': /* hex value */
infil -> fread(&chigh,1,1);
cl--;
chigh -= 48;
chigh &= 0xff - 32;
if (chigh > 9)
chigh -= 7;
infil -> fread(&clow,1,1);
cl--;
clow -= 48;
clow &= 0xff - 32;
if (clow > 9)
clow -= 7;
slask[i++] = (char)(chigh * 16 + clow);
break;
default: /* just another char */
slask[i++] = c;
break;
}
if(infil -> eof())
break;
//
if (cl > 0)
{
infil -> fread(&c,1,1);
}
cl--;
}
slask[i] = 0;
i = 0;
if(got_name) {
cgi = new CGI(name,slask);
m_cgi.push_back(cgi);
} else {
cgi = new CGI(slask,"");
m_cgi.push_back(cgi);
}
delete[] slask;
}
}
// HttpdForm(buffer,l) -- request_method GET
HttpdForm::HttpdForm(const std::string& buffer,size_t l) : raw(false)
{
CGI *cgi = nullptr;
char slask[8888];
char name[200];
int i = 0;
char c,chigh,clow;
bool got_name = false;
size_t ptr = 0;
m_current = m_cgi.end();
*name = 0;
ptr = 0;
while (ptr < l)
{
c = buffer[ptr++];
switch (c)
{
case '=': /* end of name */
slask[i] = 0;
i = 0;
got_name = true;
strcpy(name,slask);
break;
case '&': /* end of value */
slask[i] = 0;
i = 0;
if(got_name) {
got_name = false;
cgi = new CGI(name,slask);
m_cgi.push_back(cgi);
} else {
cgi = new CGI(slask, "");
m_cgi.push_back(cgi);
}
break;
case '+': /* space */
slask[i++] = ' ';
break;
case '%': /* hex value */
chigh = buffer[ptr++];
chigh -= 48;
chigh &= 0xff - 32;
if (chigh > 9)
chigh -= 7;
clow = buffer[ptr++];
clow -= 48;
clow &= 0xff - 32;
if (clow > 9)
clow -= 7;
slask[i++] = (char)(chigh * 16 + clow);
break;
default: /* just another char */
slask[i++] = c;
break;
}
}
slask[i] = 0;
i = 0;
if(got_name) {
cgi = new CGI(name,slask);
m_cgi.push_back(cgi);
} else {
cgi = new CGI(slask, "");
m_cgi.push_back(cgi);
}
}
HttpdForm::~HttpdForm()
{
CGI *cgi = nullptr; //,*tmp;
for (cgi_v::iterator it = m_cgi.begin(); it != m_cgi.end(); it++)
{
cgi = *it;
delete cgi;
}
}
void HttpdForm::EnableRaw(bool b)
{
raw = b;
}
void HttpdForm::strcpyval(std::string& v,const char *value) //,size_t len)
{
v = "";
for (size_t i = 0; i < strlen(value); i++)
{
if (value[i] == '<')
{
v += "&lt;";
}
else
if (value[i] == '>')
{
v += "&gt;";
}
else
if (value[i] == '&')
{
v += "&amp;";
}
else
{
v += value[i];
}
}
}
bool HttpdForm::getfirst(std::string& n) //char *n,size_t len)
{
m_current = m_cgi.begin();
return getnext(n);
}
bool HttpdForm::getnext(std::string& n) //char *n,size_t len)
{
if (m_current != m_cgi.end() )
{
CGI *current = *m_current;
n = current -> name;
m_current++;
return true;
}
else
{
n = "";
}
return false;
}
bool HttpdForm::getfirst(std::string& n,std::string& v) //char *n,size_t len,char *v,size_t vlen)
{
m_current = m_cgi.begin();
return getnext(n,v);
}
bool HttpdForm::getnext(std::string& n,std::string& v) //char *n,size_t len,char *v,size_t vlen)
{
if (m_current != m_cgi.end() )
{
CGI *current = *m_current;
n = current -> name;
if (raw)
{
v = current -> value;
}
else
{
strcpyval(v,current -> value.c_str());
}
m_current++;
return true;
}
else
{
n = "";
}
return false;
}
int HttpdForm::getvalue(const std::string& n,std::string& v) //char *v,size_t len)
{
CGI *cgi = nullptr;
int r = 0;
for (cgi_v::iterator it = m_cgi.begin(); it != m_cgi.end(); it++)
{
cgi = *it;
if (cgi -> name == n)
break;
cgi = nullptr;
}
if (cgi)
{
if (raw)
{
v = cgi -> value;
}
else
{
strcpyval(v,cgi -> value.c_str());
}
r++;
}
else
{
v = "";
}
return r;
}
std::string HttpdForm::getvalue(const std::string& n)
{
for (cgi_v::iterator it = m_cgi.begin(); it != m_cgi.end(); it++)
{
CGI *cgi = *it;
if (cgi -> name == n)
{
return cgi -> value;
}
}
return "";
}
size_t HttpdForm::getlength(const std::string& n)
{
CGI *cgi = nullptr;
size_t l;
for (cgi_v::iterator it = m_cgi.begin(); it != m_cgi.end(); it++)
{
cgi = *it;
if (cgi -> name == n)
break;
cgi = nullptr;
}
l = cgi ? cgi -> value.size() : 0;
if (cgi && !raw)
{
for (size_t i = 0; i < cgi -> value.size(); i++)
{
switch (cgi -> value[i])
{
case '<': // &lt;
case '>': // &gt;
l += 4;
break;
case '&': // &amp;
l += 5;
break;
}
}
}
return l;
}
HttpdForm::cgi_v& HttpdForm::getbase()
{
return m_cgi;
}
const std::string& HttpdForm::GetBoundary()
{
return m_strBoundary;
}
#ifdef SOCKETS_NAMESPACE
}
#endif
common/SocketLib/HttpdForm.h
-115
View File
@@ -1,115 +0,0 @@
/** \file HttpdForm.h - read stdin, parse cgi input
**
** Written: 1999-Feb-10 grymse@alhem.net
**/
/*
Copyright (C) 1999-2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#ifndef _FORM_H
#define _FORM_H
#include <string>
#include <list>
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
class IFile;
/** Parse/store a http query_string/form-data body.
\ingroup webserver */
class HttpdForm
{
/**
* Store the name/value pairs from a GET/POST operation.
* "name" does not have to be unique.
\ingroup webserver
*/
struct CGI
{
CGI(const std::string& n,const std::string& v) : name(n),value(v) {}
CGI(const std::string& n,const std::string& v,const std::string& p) : name(n),value(v),path(p) {}
std::string name;
std::string value;
std::string path;
};
/** list of key/value pairs. */
typedef std::list<CGI *> cgi_v;
public:
/**
* Default constructor (used in POST operations).
* Input is read from stdin. Number of characters to read
* can be found in the environment variable CONTENT_LENGTH.
*/
HttpdForm(IFile *);
/**
* Another constructor (used in GET operations).
* Input is read from the environment variable QUERY_STRING.
* @param query_string The httpd server provided QUERY_STRING
* @param length Query string length.
*/
HttpdForm(const std::string& query_string,size_t length);
~HttpdForm();
void EnableRaw(bool);
void strcpyval(std::string&,const char *); //,size_t);
/* get names */
bool getfirst(std::string& n); //char *,size_t);
bool getnext(std::string& n); //char *,size_t);
/* get names and values */
bool getfirst(std::string& n,std::string& v); //char *,size_t,char *,size_t);
bool getnext(std::string& n,std::string& v); //char *,size_t,char *,size_t);
/* get value */
int getvalue(const std::string& ,std::string& ); //char *,size_t);
std::string getvalue(const std::string& );
size_t getlength(const std::string& );
cgi_v& getbase();
const std::string& GetBoundary();
private:
HttpdForm(const HttpdForm& ) {}
HttpdForm& operator=(const HttpdForm& ) { return *this; }
cgi_v m_cgi;
cgi_v::iterator m_current;
std::string m_strBoundary;
bool raw;
};
#ifdef SOCKETS_NAMESPACE
}
#endif
#endif // _FORM_H
common/SocketLib/HttpdSocket.cpp
-352
View File
@@ -1,352 +0,0 @@
/** \file HttpdSocket.cpp
*/
/*
Copyright (C) 2001-2004,2005 Anders Hedstrom (grymse@alhem.net)
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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 "../global_define.h"
#include "Utility.h"
#include "HttpdCookies.h"
#include "HttpdForm.h"
#include "MemFile.h"
#include "HttpdSocket.h"
#include "../types.h"
#include <time.h>
#include <stdio.h>
#include <cstdlib>
#include <cstring>
#define DEB(x)
/*
#define DEB(x) { \
FILE *fil = fopen("httpdlog","at"); \
if (!fil) \
fil = fopen("httpdlog","wt"); \
if (fil) { x; fclose(fil); } \
}
*/
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
// statics
int HttpdSocket::m_request_count = 0;
std::string HttpdSocket::m_start = "";
HttpdSocket::HttpdSocket(uint32 ID, SOCKET in_socket, uint32 irIP, uint16 irPort)
: HTTPSocket(ID,in_socket,irIP,irPort)
,m_content_length(0)
,m_file(nullptr)
,m_received(0)
,m_request_id(++m_request_count)
,m_cookies(nullptr)
,m_form(nullptr)
{
m_http_date = datetime2httpdate(GetDate());
if (!m_start.size())
m_start = m_http_date;
}
HttpdSocket::~HttpdSocket()
{
if (m_file)
{
delete m_file;
}
if (m_cookies)
delete m_cookies;
if (m_form)
delete m_form;
}
void HttpdSocket::OnFirst()
{
// printf("Request: %s %s %s\n",GetMethod().c_str(),GetUrl().c_str(),GetHttpVersion().c_str());
}
void HttpdSocket::OnHeader(const std::string& key,const std::string& value)
{
if (!strcasecmp(key.c_str(),"content-length"))
{
m_content_length = atoi(value.c_str());
m_content_length_str = value;
}
else
if (!strcasecmp(key.c_str(),"cookie"))
{
m_http_cookie = value;
}
else
if (!strcasecmp(key.c_str(),"content-type"))
{
m_content_type = value;
}
else
if (!strcasecmp(key.c_str(),"if-modified-since"))
{
m_if_modified_since = value;
}
}
void HttpdSocket::OnHeaderComplete()
{
m_cookies = new HttpdCookies(m_http_cookie);
#if (defined(SOLARIS8) || defined(SOLARIS))
{
char slask[1000];
if (GetMethod() == "GET")
{
sprintf(slask,"QUERY_STRING=%s", GetQueryString().c_str());
putenv(slask);
}
sprintf(slask,"REQUEST_METHOD=%s", GetMethod().c_str());
putenv(slask);
sprintf(slask,"HTTP_COOKIE=%s", m_http_cookie.c_str());
putenv(slask);
sprintf(slask,"CONTENT_TYPE=%s", m_content_type.c_str());
putenv(slask);
sprintf(slask,"CONTENT_LENGTH=%s", m_content_length_str.c_str());
putenv(slask);
}
#elif defined _WIN32
{
char slask[1000];
if (GetMethod() == "GET")
{
sprintf(slask,"QUERY_STRING=%s", GetQueryString().c_str());
_putenv(slask);
}
sprintf(slask,"REQUEST_METHOD=%s", GetMethod().c_str());
_putenv(slask);
sprintf(slask,"HTTP_COOKIE=%s", m_http_cookie.c_str());
_putenv(slask);
sprintf(slask,"CONTENT_TYPE=%s", m_content_type.c_str());
_putenv(slask);
sprintf(slask,"CONTENT_LENGTH=%s", m_content_length_str.c_str());
_putenv(slask);
}
#else
if (GetMethod() == "GET")
{
setenv("QUERY_STRING", GetQueryString().c_str(), 1);
}
setenv("REQUEST_METHOD", GetMethod().c_str(), 1);
setenv("HTTP_COOKIE", m_http_cookie.c_str(), 1);
setenv("CONTENT_TYPE", m_content_type.c_str(), 1);
setenv("CONTENT_LENGTH", m_content_length_str.c_str(), 1);
#endif
if (GetMethod() == "POST")
{
m_file = new MemFile;
}
else
if (GetMethod() == "GET")
{
m_form = new HttpdForm(GetQueryString(), GetQueryString().size() );
AddResponseHeader("Date", datetime2httpdate(GetDate()) );
Exec();
Reset(); // prepare for next request
}
else
{
AddResponseHeader("Date", GetHttpDate());
AddResponseHeader("Connection", "close");
SetStatus("405");
SetStatusText("Method not allowed");
SendResponse();
}
}
void HttpdSocket::OnData(const char *p,size_t l)
{
if (m_file)
{
m_file -> fwrite(p,1,l);
}
m_received += l;
if (m_received >= m_content_length && m_content_length)
{
// all done
if (m_file && !m_form)
{
m_form = new HttpdForm(m_file);
AddResponseHeader("Date", datetime2httpdate(GetDate()) );
Exec();
Reset(); // prepare for next request
}
}
}
void HttpdSocket::Send64(const std::string& str64, const std::string& type)
{
if (!strcasecmp(m_start.c_str(), m_if_modified_since.c_str()))
{
SetStatus("304");
SetStatusText("Not Modified");
SendResponse();
}
else
{
size_t len = Base64::decode_length(str64);
unsigned char *buf = new unsigned char[len];
SetStatus("200");
SetStatusText("OK");
AddResponseHeader("Content-length", Utility::l2string( (long)len) );
AddResponseHeader("Content-type", type );
AddResponseHeader("Last-modified", m_start);
SendResponse();
Base64::decode(str64, buf, len);
SendBuf( (char *)buf, len);
delete[] buf;
}
}
std::string HttpdSocket::datetime2httpdate(const std::string& dt)
{
struct tm tp;
time_t t;
const char *days[] = { "Sun","Mon","Tue","Wed","Thu","Fri","Sat" };
const char *months[] = { "Jan","Feb","Mar","Apr","May","Jun",
"Jul","Aug","Sep","Oct","Nov","Dec" };
int i;
char s[40];
/* 1997-12-16 09:50:40 */
if (dt.size() == 19)
{
tp.tm_year = atoi(dt.substr(0,4).c_str()) - 1900;
i = atoi(dt.substr(5,2).c_str()) - 1;
tp.tm_mon = i >= 0 ? i : 0;
tp.tm_mday = atoi(dt.substr(8,2).c_str());
tp.tm_hour = atoi(dt.substr(11,2).c_str());
tp.tm_min = atoi(dt.substr(14,2).c_str());
tp.tm_sec = atoi(dt.substr(17,2).c_str());
tp.tm_wday = 0;
tp.tm_yday = 0;
tp.tm_isdst = 0;
t = mktime(&tp);
/*if (t == -1)
{
Handler().LogError(this, "datetime2httpdate", 0, "mktime() failed");
}*/
sprintf(s,"%s, %02d %s %d %02d:%02d:%02d GMT",
days[tp.tm_wday],
tp.tm_mday,
months[tp.tm_mon],
tp.tm_year + 1900,
tp.tm_hour,tp.tm_min,tp.tm_sec);
}
else
{
*s = 0;
}
return s;
}
std::string HttpdSocket::GetDate()
{
time_t t = time(nullptr);
struct tm* tp = localtime(&t);
char slask[40];
if (tp)
{
sprintf(slask,"%d-%02d-%02d %02d:%02d:%02d",
tp -> tm_year + 1900,
tp -> tm_mon + 1,
tp -> tm_mday,
tp -> tm_hour,tp -> tm_min,tp -> tm_sec);
}
else
{
*slask = 0;
}
return slask;
}
void HttpdSocket::Reset()
{
HTTPSocket::Reset();
m_content_length = 0;
if (m_file)
{
delete m_file;
m_file = nullptr;
}
m_received = 0;
m_request_id = ++m_request_count;
if (m_cookies)
delete m_cookies;
m_cookies = nullptr;
if (m_form)
delete m_form;
m_form = nullptr;
}
const std::string& HttpdSocket::GetHttpDate()
{
return m_http_date;
}
HttpdCookies *HttpdSocket::GetCookies()
{
return m_cookies;
}
HttpdForm *HttpdSocket::GetHttpForm()
{
return m_form;
}
#ifdef SOCKETS_NAMESPACE
}
#endif
common/SocketLib/HttpdSocket.h
-99
View File
@@ -1,99 +0,0 @@
/** \file HttpdSocket.h
*/
/*
Copyright (C) 2001-2004,2005 Anders Hedstrom (grymse@alhem.net)
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#ifndef _HTTPDSOCKET_H
#define _HTTPDSOCKET_H
#include "HTTPSocket.h"
class TCPConnection;
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
class HttpdCookies;
class HttpdForm;
class IFile;
/** \defgroup webserver Webserver framework */
/** Web server socket framework.
\ingroup webserver */
class HttpdSocket : public HTTPSocket
{
public:
HttpdSocket(uint32 ID, SOCKET in_socket, uint32 irIP, uint16 irPort);
~HttpdSocket();
void OnFirst();
void OnHeader(const std::string& key,const std::string& value);
void OnHeaderComplete();
void OnData(const char *,size_t);
/** This method needs to be implemented with logic to produce
a response to an incoming request. */
virtual void Exec() = 0;
/** Get current date in http rfc format. */
const std::string& GetHttpDate();
/** Get pointer to cookie class. */
HttpdCookies *GetCookies();
/** Get pointer to query string/form data class. */
HttpdForm *GetHttpForm();
protected:
/** Decode and send a base64-encoded string.
\param str64 Base64-encoded string
\param type Mime type of content (content-type header) */
void Send64(const std::string& str64, const std::string& type);
std::string datetime2httpdate(const std::string& dt);
std::string GetDate();
void Reset();
// headers
std::string m_http_cookie;
std::string m_content_type;
std::string m_content_length_str;
std::string m_if_modified_since;
private:
static int m_request_count;
static std::string m_start;
size_t m_content_length;
IFile *m_file;
size_t m_received;
int m_request_id;
std::string m_http_date;
HttpdCookies *m_cookies;
HttpdForm *m_form;
};
#ifdef SOCKETS_NAMESPACE
}
#endif
#endif // _HTTPDSOCKET_H
common/SocketLib/IFile.h
-65
View File
@@ -1,65 +0,0 @@
/** \file IFile.h
** \date 2005-04-25
** \author grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#ifndef _IFILE_H
#define _IFILE_H
#include <string>
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
/** \defgroup file File handling */
/** Pure virtual file I/O interface.
\ingroup file */
class IFile
{
public:
virtual ~IFile() {}
virtual bool fopen(const std::string&, const std::string&) = 0;
virtual void fclose() = 0;
virtual size_t fread(char *, size_t, size_t) = 0;
virtual size_t fwrite(const char *, size_t, size_t) = 0;
virtual char *fgets(char *, int) = 0;
virtual void fprintf(char *format, ...) = 0;
virtual off_t size() = 0;
virtual bool eof() = 0;
};
#ifdef SOCKETS_NAMESPACE
}
#endif
#endif // _IFILE_H
common/SocketLib/MemFile.cpp
-212
View File
@@ -1,212 +0,0 @@
/** \file MemFile.cpp
** \date 2005-04-25
** \author grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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 <stdio.h>
#include <stdarg.h>
#include "MemFile.h"
#include <cstdlib>
#include <cstring>
#ifdef _DEBUG
#define DEB(x) x
#else
#define DEB(x)
#endif
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
std::map<std::string,MemFile::block_t *> MemFile::m_files;
MemFile::MemFile()
:m_temporary(true)
,m_base(new block_t)
,m_current_read(m_base)
,m_current_write(m_base)
,m_read_ptr(0)
,m_write_ptr(0)
{
}
MemFile::MemFile(const std::string& path)
:m_path(path)
,m_temporary(false)
,m_base(m_files[path])
,m_current_read(nullptr)
,m_current_write(nullptr)
,m_read_ptr(0)
,m_write_ptr(0)
{
if (!m_base)
{
m_base = new block_t;
m_files[path] = m_base;
}
m_current_read = m_base;
m_current_write = m_base;
}
MemFile::~MemFile()
{
while (m_base && m_temporary)
{
block_t *p = m_base;
m_base = p -> next;
delete p;
}
}
bool MemFile::fopen(const std::string& path, const std::string& mode)
{
return true;
}
void MemFile::fclose()
{
}
size_t MemFile::fread(char *ptr, size_t size, size_t nmemb)
{
size_t p = m_read_ptr % BLOCKSIZE;
size_t sz = size * nmemb;
if (p + sz < BLOCKSIZE)
{
memcpy(ptr, m_current_read -> data + p, sz);
m_read_ptr += sz;
}
else
{
size_t sz1 = BLOCKSIZE - p;
size_t sz2 = size - sz1;
memcpy(ptr, m_current_read -> data + p, sz1);
m_read_ptr += sz1;
if (m_current_read -> next)
{
m_current_read = m_current_read -> next;
memcpy(ptr + sz1, m_current_read -> data, sz2);
m_read_ptr += sz2;
}
else
{
DEB(printf("Read beyond available data\n");)
return sz1;
}
}
return sz;
}
size_t MemFile::fwrite(const char *ptr, size_t size, size_t nmemb)
{
size_t p = m_write_ptr % BLOCKSIZE;
size_t sz = size * nmemb;
if (p + sz < BLOCKSIZE)
{
memcpy(m_current_write -> data + p, ptr, sz);
m_write_ptr += sz;
}
else
{
size_t sz1 = BLOCKSIZE - p;
size_t sz2 = size - sz1;
memcpy(m_current_write -> data + p, ptr, sz1);
block_t *next = new block_t;
m_current_write -> next = next;
m_current_write = next;
memcpy(m_current_write -> data, ptr + sz1, sz2);
m_write_ptr += sz;
}
return sz;
}
char *MemFile::fgets(char *s, int size)
{
int n = 0;
while (n < size - 1 && !eof())
{
char c;
fread(&c, 1, 1);
if (c == 10)
{
s[n] = 0;
return s;
}
s[n++] = c;
}
s[n] = 0;
return s;
}
void MemFile::fprintf(char *format, ...)
{
va_list ap;
char tmp[BLOCKSIZE];
va_start(ap, format);
#ifdef _WIN32
vsprintf(tmp, format, ap);
#else
vsnprintf(tmp, BLOCKSIZE - 1, format, ap);
#endif
va_end(ap);
fwrite(tmp, 1, strlen(tmp));
}
off_t MemFile::size()
{
return (off_t)m_write_ptr;
}
bool MemFile::eof()
{
return (m_read_ptr < m_write_ptr) ? false : true;
}
#ifdef SOCKETS_NAMESPACE
}
#endif
common/SocketLib/MemFile.h
-93
View File
@@ -1,93 +0,0 @@
/** \file MemFile.h
** \date 2005-04-25
** \author grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#ifndef _MEMFILE_H
#define _MEMFILE_H
#include <map>
#include "IFile.h"
#define BLOCKSIZE 32768
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
/** Implements a memory file.
\ingroup file */
class MemFile : public IFile
{
public:
/** File block structure.
\ingroup file */
struct block_t {
block_t() : next(nullptr) {}
struct block_t *next;
char data[BLOCKSIZE];
};
public:
MemFile();
MemFile(const std::string& path);
~MemFile();
bool fopen(const std::string& path, const std::string& mode);
void fclose();
size_t fread(char *ptr, size_t size, size_t nmemb);
size_t fwrite(const char *ptr, size_t size, size_t nmemb);
char *fgets(char *s, int size);
void fprintf(char *format, ...);
off_t size();
bool eof();
private:
MemFile(const MemFile& ) {} // copy constructor
MemFile& operator=(const MemFile& ) { return *this; } // assignment operator
static std::map<std::string,block_t *> m_files;
std::string m_path;
bool m_temporary;
block_t *m_base;
block_t *m_current_read;
block_t *m_current_write;
size_t m_read_ptr;
size_t m_write_ptr;
};
#ifdef SOCKETS_NAMESPACE
}
#endif
#endif // _MEMFILE_H
common/SocketLib/Mime.cpp
-92
View File
@@ -1,92 +0,0 @@
/**
** File ......... Mime.cpp
** Published .... 2004-07-13
** Author ....... grymse@alhem.net
**/
/*
Copyright (C) 2004 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.
*/
#include <stdio.h>
#include "Parse.h"
#include "Mime.h"
#include <cstring>
Mime::Mime() {
}
Mime::Mime(const std::string& filename) {
LoadMimeFile(filename);
}
bool Mime::LoadMimeFile(const std::string& filename) {
FILE *fil;
if ((fil = fopen(filename.c_str(),"rt")) != nullptr) {
char * slask = new char[1000];
fgets(slask,1000,fil);
while (!feof(fil))
{
while (strlen(slask) && (slask[strlen(slask) - 1] == 13 || slask[strlen(slask) - 1] == 10))
{
slask[strlen(slask) - 1] = 0;
}
Parse pa(slask);
std::string mime_type = pa.getword();
std::string ext = pa.getword();
while (ext.size())
{
m_mime[ext] = mime_type;
ext = pa.getword();
}
//
fgets(slask,1000,fil);
}
delete[] slask;
fclose(fil);
return(true);
}
return(false);
}
Mime::~Mime()
{
}
void Mime::Clear() {
m_mime.clear();
}
std::string Mime::GetMimeFromFilename(const std::string &filename) const {
std::string::size_type pos = filename.find_last_of('.');
if(pos == std::string::npos)
return(std::string("text/plain"));
return(GetMimeFromExtension(filename.substr(pos+1)));
}
std::string Mime::GetMimeFromExtension(const std::string& ext) const {
mime_m::const_iterator res;
res = m_mime.find(ext);
if(res == m_mime.end())
return(std::string("text/plain"));
return res->second;
}
common/SocketLib/Mime.h
-55
View File
@@ -1,55 +0,0 @@
/**
** File ......... Mime.h
** Published .... 2004-07-13
** Author ....... grymse@alhem.net
**/
/*
Copyright (C) 2004 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.
*/
#ifndef _MIME_H
#define _MIME_H
#include <string>
#include <map>
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
class Mime {
typedef std::map<std::string,std::string> mime_m;
public:
Mime();
Mime(const std::string& mime_file);
~Mime();
void Clear();
bool LoadMimeFile(const std::string& mime_file);
std::string GetMimeFromFilename(const std::string &filename) const;
std::string GetMimeFromExtension(const std::string &ext) const;
private:
mime_m m_mime;
};
#ifdef SOCKETS_NAMESPACE
}
#endif
#endif // _MIME_H
common/SocketLib/Parse.cpp
-327
View File
@@ -1,327 +0,0 @@
/** \file Parse.cpp - parse a string
**
** Written: 1999-Feb-10 grymse@alhem.net
**/
/*
Copyright (C) 1999-2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Parse.h"
#ifdef _DEBUG
#define DEB(x)
#else
#define DEB(x)
#endif
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
/* implementation of class Parse */
Parse::Parse()
:pa_the_str("")
,pa_splits("")
,pa_ord("")
,pa_the_ptr(0)
,pa_breakchar(0)
,pa_enable(0)
,pa_disable(0)
,pa_nospace(0)
,pa_quote(false)
{
}
Parse::Parse(const std::string&s)
:pa_the_str(s)
,pa_splits("")
,pa_ord("")
,pa_the_ptr(0)
,pa_breakchar(0)
,pa_enable(0)
,pa_disable(0)
,pa_nospace(0)
,pa_quote(false)
{
}
Parse::Parse(const std::string&s,const std::string&sp)
:pa_the_str(s)
,pa_splits(sp)
,pa_ord("")
,pa_the_ptr(0)
,pa_breakchar(0)
,pa_enable(0)
,pa_disable(0)
,pa_nospace(0)
,pa_quote(false)
{
}
Parse::Parse(const std::string&s,const std::string&sp,short nospace)
:pa_the_str(s)
,pa_splits(sp)
,pa_ord("")
,pa_the_ptr(0)
,pa_breakchar(0)
,pa_enable(0)
,pa_disable(0)
,pa_nospace(1)
,pa_quote(false)
{
}
Parse::~Parse()
{
}
#define C ((pa_the_ptr<pa_the_str.size()) ? pa_the_str[pa_the_ptr] : 0)
short Parse::issplit(char c)
{
for (size_t i = 0; i < pa_splits.size(); i++)
if (pa_splits[i] == c)
return 1;
return 0;
}
void Parse::getsplit(void)
{
size_t x;
if (C == '=')
{
x = pa_the_ptr++;
} else
{
while (C && (issplit(C)))
pa_the_ptr++;
x = pa_the_ptr;
while (C && !issplit(C) && C != '=')
pa_the_ptr++;
}
if (x == pa_the_ptr && C == '=')
pa_the_ptr++;
pa_ord = (x < pa_the_str.size()) ? pa_the_str.substr(x,pa_the_ptr - x) : "";
}
std::string Parse::getword(void)
{
size_t x;
int disabled = 0;
int quote = 0;
int rem = 0;
if (pa_nospace)
{
while (C && issplit(C))
pa_the_ptr++;
x = pa_the_ptr;
while (C && !issplit(C) && (C != pa_breakchar || !pa_breakchar || disabled))
{
if (pa_breakchar && C == pa_disable)
disabled = 1;
if (pa_breakchar && C == pa_enable)
disabled = 0;
if (pa_quote && C == '"')
quote = 1;
pa_the_ptr++;
while (quote && C && C != '"')
{
pa_the_ptr++;
}
if (pa_quote && C == '"')
{
pa_the_ptr++;
}
quote = 0;
}
} else
{
if (C == pa_breakchar && pa_breakchar)
{
x = pa_the_ptr++;
rem = 1;
} else
{
while (C && (C == ' ' || C == 9 || C == 13 || C == 10 || issplit(C)))
pa_the_ptr++;
x = pa_the_ptr;
while (C && C != ' ' && C != 9 && C != 13 && C != 10 && !issplit(C) &&
(C != pa_breakchar || !pa_breakchar || disabled))
{
if (pa_breakchar && C == pa_disable)
disabled = 1;
if (pa_breakchar && C == pa_enable)
disabled = 0;
if (pa_quote && C == '"')
{
quote = 1;
pa_the_ptr++;
while (quote && C && C != '"')
{
pa_the_ptr++;
}
if (pa_quote && C == '"')
{
pa_the_ptr++;
}
}
else
pa_the_ptr++;
quote = 0;
}
pa_the_ptr++;
rem = 1;
}
if (x == pa_the_ptr && C == pa_breakchar && pa_breakchar)
pa_the_ptr++;
}
if (x < pa_the_str.size())
{
pa_ord = pa_the_str.substr(x,pa_the_ptr - x - rem);
}
else
{
pa_ord = "";
}
return pa_ord;
}
void Parse::getword(std::string&s)
{
s = Parse::getword();
}
void Parse::getsplit(std::string&s)
{
Parse::getsplit();
s = pa_ord;
}
void Parse::getword(std::string&s,std::string&fill,int l)
{
Parse::getword();
s = "";
while (s.size() + pa_ord.size() < (size_t)l)
s += fill;
s += pa_ord;
}
std::string Parse::getrest()
{
std::string s;
while (C && (C == ' ' || C == 9 || issplit(C)))
pa_the_ptr++;
s = (pa_the_ptr < pa_the_str.size()) ? pa_the_str.substr(pa_the_ptr) : "";
return s;
}
void Parse::getrest(std::string&s)
{
while (C && (C == ' ' || C == 9 || issplit(C)))
pa_the_ptr++;
s = (pa_the_ptr < pa_the_str.size()) ? pa_the_str.substr(pa_the_ptr) : "";
}
long Parse::getvalue(void)
{
Parse::getword();
return atol(pa_ord.c_str());
}
void Parse::setbreak(char c)
{
pa_breakchar = c;
}
int Parse::getwordlen(void)
{
size_t x,y = pa_the_ptr,len;
if (C == pa_breakchar && pa_breakchar)
{
x = pa_the_ptr++;
} else
{
while (C && (C == ' ' || C == 9 || C == 13 || C == 10 || issplit(C)))
pa_the_ptr++;
x = pa_the_ptr;
while (C && C != ' ' && C != 9 && C != 13 && C != 10 && !issplit(C) && (C != pa_breakchar || !pa_breakchar))
pa_the_ptr++;
}
if (x == pa_the_ptr && C == pa_breakchar && pa_breakchar)
pa_the_ptr++;
len = pa_the_ptr - x;
pa_the_ptr = y;
return (int)len;
}
int Parse::getrestlen(void)
{
size_t y = pa_the_ptr;
size_t len;
while (C && (C == ' ' || C == 9 || issplit(C)))
pa_the_ptr++;
len = strlen(pa_the_str.c_str() + pa_the_ptr);
pa_the_ptr = y;
return (int)len;
}
void Parse::getline(void)
{
size_t x;
x = pa_the_ptr;
while (C && C != 13 && C != 10)
pa_the_ptr++;
pa_ord = (x < pa_the_str.size()) ? pa_the_str.substr(x,pa_the_ptr - x) : "";
if (C == 13)
pa_the_ptr++;
if (C == 10)
pa_the_ptr++;
}
void Parse::getline(std::string&s)
{
getline();
s = pa_ord;
}
/* end of implementation of class Parse */
/***************************************************/
#ifdef SOCKETS_NAMESPACE
}
#endif
common/SocketLib/Parse.h
-95
View File
@@ -1,95 +0,0 @@
/** \file Parse.h - parse a string
**
** Written: 1999-Feb-10 grymse@alhem.net
**/
/*
Copyright (C) 1999-2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#ifndef _PARSE_H
#define _PARSE_H
#include <string>
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
/***************************************************/
/* interface of class Parse */
/** Splits a string whatever way you want.
\ingroup util */
class Parse
{
public:
Parse();
Parse(const std::string&);
Parse(const std::string&,const std::string&);
Parse(const std::string&,const std::string&,short);
~Parse();
short issplit(char);
void getsplit(void);
void getsplit(std::string&);
std::string getword(void);
void getword(std::string&);
void getword(std::string&,std::string&,int);
std::string getrest();
void getrest(std::string&);
long getvalue(void);
void setbreak(char);
int getwordlen(void);
int getrestlen(void);
void enablebreak(char c) {
pa_enable = c;
}
void disablebreak(char c) {
pa_disable = c;
}
void getline(void);
void getline(std::string&);
size_t getptr(void) { return pa_the_ptr; }
void EnableQuote(bool b) { pa_quote = b; }
private:
std::string pa_the_str;
std::string pa_splits;
std::string pa_ord;
size_t pa_the_ptr;
char pa_breakchar;
char pa_enable;
char pa_disable;
short pa_nospace;
bool pa_quote;
};
#ifdef SOCKETS_NAMESPACE
}
#endif
#endif // _PARSE_H
common/SocketLib/README.eqemu
-5
View File
@@ -1,5 +0,0 @@
EQEmu took this code from `C++ Sockets Library`
http://www.alhem.net/Sockets/
and integrated it into our world server. We did not care for the actual
socket code (didnt work on windows) so we scrapped all of it, and just
used the HTTP framework code.
common/SocketLib/README.macosx
-5
View File
@@ -1,5 +0,0 @@
Find uuid.h here
http://www.die.net/doc/linux/include/uuid/uuid.h
or here
http://www.thedna.net/uuid.h
common/SocketLib/Utility.cpp
-167
View File
@@ -1,167 +0,0 @@
/** \file Utility.cpp
** \date 2004-02-13
** \author grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#include "Utility.h"
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
std::string Utility::base64(const std::string& str_in)
{
std::string str;
Base64::encode(str_in, str, false); // , false == do not add cr/lf
return str;
}
std::string Utility::base64d(const std::string& str_in)
{
std::string str;
Base64::decode(str_in, str);
return str;
}
std::string Utility::l2string(long l)
{
std::string str;
char tmp[100];
sprintf(tmp,"%ld",l);
str = tmp;
return str;
}
std::string Utility::bigint2string(uint64_t l)
{
std::string str;
uint64_t tmp = l;
while (tmp)
{
uint64_t a = tmp % 10;
str = (char)(a + 48) + str;
tmp /= 10;
}
if (!str.size())
{
str = "0";
}
return str;
}
uint64_t Utility::atoi64(const std::string& str)
{
uint64_t l = 0;
for (size_t i = 0; i < str.size(); i++)
{
l = l * 10 + str[i] - 48;
}
return l;
}
unsigned int Utility::hex2unsigned(const std::string& str)
{
unsigned int r = 0;
for (size_t i = 0; i < str.size(); i++)
{
r = r * 16 + str[i] - 48 - ((str[i] >= 'A') ? 7 : 0) - ((str[i] >= 'a') ? 32 : 0);
}
return r;
}
/*
* Encode string per RFC1738 URL encoding rules
* tnx rstaveley
*/
std::string Utility::rfc1738_encode(const std::string& src)
{
static char hex[] = "0123456789ABCDEF";
std::string dst;
for (size_t i = 0; i < src.size(); i++)
{
if (isalnum(src[i]))
{
dst += src[i];
}
else
if (src[i] == ' ')
{
dst += '+';
}
else
{
dst += '%';
dst += hex[src[i] / 16];
dst += hex[src[i] % 16];
}
}
return dst;
} // rfc1738_encode
/*
* Decode string per RFC1738 URL encoding rules
* tnx rstaveley
*/
std::string Utility::rfc1738_decode(const std::string& src)
{
std::string dst;
for (size_t i = 0; i < src.size(); i++)
{
if (src[i] == '%' && isxdigit(src[i + 1]) && isxdigit(src[i + 2]))
{
char c1 = src[++i];
char c2 = src[++i];
c1 = c1 - 48 - ((c1 >= 'A') ? 7 : 0) - ((c1 >= 'a') ? 32 : 0);
c2 = c2 - 48 - ((c2 >= 'A') ? 7 : 0) - ((c2 >= 'a') ? 32 : 0);
dst += (char)(c1 * 16 + c2);
}
else
if (src[i] == '+')
{
dst += ' ';
}
else
{
dst += src[i];
}
}
return dst;
} // rfc1738_decode
#ifdef SOCKETS_NAMESPACE
}
#endif
common/SocketLib/Utility.h
-70
View File
@@ -1,70 +0,0 @@
/** \file Utility.h
** \date 2004-02-13
** \author grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#ifndef _UTILITY_H
#define _UTILITY_H
#include <ctype.h>
#ifdef _WIN32
typedef unsigned __int64 uint64_t;
#else
#include <stdlib.h>
#ifdef SOLARIS
# include <sys/types.h>
#else
# include <stdint.h>
#endif
#endif
#include "Base64.h"
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
/** Conversion utilities.
\ingroup util */
class Utility
{
public:
static std::string base64(const std::string& str_in);
static std::string base64d(const std::string& str_in);
static std::string l2string(long l);
static std::string bigint2string(uint64_t l);
static uint64_t atoi64(const std::string& str);
static unsigned int hex2unsigned(const std::string& str);
static std::string rfc1738_encode(const std::string& src);
static std::string rfc1738_decode(const std::string& src);
};
#ifdef SOCKETS_NAMESPACE
}
#endif
#endif // _UTILITY_H
common/SocketLib/gpl.txt
-340
View File
@@ -1,340 +0,0 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
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
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.
common/SocketLib/socket_include.cpp
-87
View File
@@ -1,87 +0,0 @@
/** \file socket_include.cpp
** \date 2004-11-28
** \author grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#include <stdio.h>
// only to be included in win32 projects
const char *StrError(int x)
{
static char tmp[100];
switch (x)
{
case 10004: return "Interrupted function call.";
case 10013: return "Permission denied.";
case 10014: return "Bad address.";
case 10022: return "Invalid argument.";
case 10024: return "Too many open files.";
case 10035: return "Resource temporarily unavailable.";
case 10036: return "Operation now in progress.";
case 10037: return "Operation already in progress.";
case 10038: return "Socket operation on nonsocket.";
case 10039: return "Destination address required.";
case 10040: return "Message too long.";
case 10041: return "Protocol wrong type for socket.";
case 10042: return "Bad protocol option.";
case 10043: return "Protocol not supported.";
case 10044: return "Socket type not supported.";
case 10045: return "Operation not supported.";
case 10046: return "Protocol family not supported.";
case 10047: return "Address family not supported by protocol family.";
case 10048: return "Address already in use.";
case 10049: return "Cannot assign requested address.";
case 10050: return "Network is down.";
case 10051: return "Network is unreachable.";
case 10052: return "Network dropped connection on reset.";
case 10053: return "Software caused connection abort.";
case 10054: return "Connection reset by peer.";
case 10055: return "No buffer space available.";
case 10056: return "Socket is already connected.";
case 10057: return "Socket is not connected.";
case 10058: return "Cannot send after socket shutdown.";
case 10060: return "Connection timed out.";
case 10061: return "Connection refused.";
case 10064: return "Host is down.";
case 10065: return "No route to host.";
case 10067: return "Too many processes.";
case 10091: return "Network subsystem is unavailable.";
case 10092: return "Winsock.dll version out of range.";
case 10093: return "Successful WSAStartup not yet performed.";
case 10101: return "Graceful shutdown in progress.";
case 10109: return "Class type not found.";
case 11001: return "Host not found.";
case 11002: return "Nonauthoritative host not found.";
case 11003: return "This is a nonrecoverable error.";
case 11004: return "Valid name, no data record of requested type.";
default:
break;
}
sprintf(tmp, "Winsock error code: %d", x);
return tmp;
}
common/SocketLib/socket_include.h
-218
View File
@@ -1,218 +0,0 @@
/** \file socket_include.h
** \date 2005-04-12
** \author grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 Anders Hedstrom
This library is made available under the terms of the GNU GPL.
If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.
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.
*/
#ifndef _SOCKET_INCLUDE_H
#define _SOCKET_INCLUDE_H
#if (defined(__unix__) || defined(unix)) && !defined(USG)
#include <sys/param.h>
#endif
#ifndef _WIN32
// ----------------------------------------
// common unix includes / defines
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
#define Errno errno
#define StrError strerror
// WIN32 adapt
#define closesocket close
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
typedef int SOCKET;
#ifndef INADDR_NONE
#define INADDR_NONE ((unsigned long) -1)
#endif // INADDR_NONE
#ifdef SOCKETS_NAMESPACE
}
#endif
#endif // !_WIN32
// ----------------------------------------
// Generic
#ifndef SOL_IP
#define SOL_IP IPPROTO_IP
#endif
// ----------------------------------------
// OS specific adaptions
#ifdef SOLARIS
// ----------------------------------------
// Solaris
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
typedef unsigned short port_t;
#ifdef SOCKETS_NAMESPACE
}
#endif
#define s6_addr16 _S6_un._S6_u8
#define MSG_NOSIGNAL 0
#elif defined __FreeBSD__
// ----------------------------------------
// FreeBSD
# if __FreeBSD_version >= 400014
# define s6_addr16 __u6_addr.__u6_addr16
# if !defined(MSG_NOSIGNAL)
# define MSG_NOSIGNAL 0
# endif
# include <netinet/in.h>
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
typedef in_addr_t ipaddr_t;
typedef in_port_t port_t;
#ifdef SOCKETS_NAMESPACE
}
#endif
# define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
# define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
# else
# error FreeBSD versions prior to 400014 does not support ipv6
# endif
#elif defined MACOSX
// ----------------------------------------
// Mac OS X
#include <string.h>
#include <mach/port.h>
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
typedef unsigned long ipaddr_t;
#ifdef SOCKETS_NAMESPACE
}
#endif
#define s6_addr16 __u6_addr.__u6_addr16
#define MSG_NOSIGNAL 0 // oops - thanks Derek
#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
#elif defined _WIN32
// ----------------------------------------
// Win32
#pragma comment(lib, "wsock32.lib")
#define strcasecmp _stricmp
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
typedef unsigned long ipaddr_t;
typedef unsigned short port_t;
typedef int socklen_t;
#ifdef SOCKETS_NAMESPACE
}
#endif
#define MSG_NOSIGNAL 0
#define SHUT_RDWR 2
// 1.8.6: define FD_SETSIZE to something bigger than 64 if there are a lot of
// simultaneous connections (must be done before including winsock.h)
//#define FD_SETSIZE 1024
#include <winsock.h>
#define Errno WSAGetLastError()
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
const char *StrError(int x);
// class WSAInitializer is a part of the Socket class (on win32)
// as a static instance - so whenever an application uses a Socket,
// winsock is initialized
class WSAInitializer // Winsock Initializer
{
public:
WSAInitializer() {
if (WSAStartup(0x101,&m_wsadata))
{
exit(-1);
}
}
~WSAInitializer() {
WSACleanup();
}
private:
WSADATA m_wsadata;
};
#ifdef SOCKETS_NAMESPACE
}
#endif
#else
// ----------------------------------------
// LINUX
#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif
typedef unsigned long ipaddr_t;
typedef unsigned short port_t;
#ifdef SOCKETS_NAMESPACE
}
#endif
#endif
#ifdef _THREADSAFE_SOCKETS
#include "mutex.h"
#include "Lock.h"
#endif
#endif // _SOCKET_INCLUDE_H
common/StackWalker/StackWalker.h
+1 -1
View File
@@ -14,7 +14,7 @@
// so we need not to check the version (because we only support _MSC_VER >= 1100)!
#pragma once
#include <windows.h>
#include "common/platform/win/include_windows.h"
// special defines for VC5/6 (if no actual PSDK is installed):
#if _MSC_VER < 1300
common/additive_lagged_fibonacci_engine.h
+2 -2
View File
@@ -18,11 +18,11 @@
#pragma once
#include <algorithm>
#include <cstdint>
#include <iostream>
#include <limits>
#include <type_traits>
#include <algorithm>
#include <iostream>
/*
* This is an additive lagged fibonacci generator as seen in The Art of Computer Programming, Vol. 2
common/base_packet.cpp
+3 -4
View File
@@ -16,10 +16,9 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "global_define.h"
#include "base_packet.h"
#include "misc.h"
#include "packet_dump.h"
#include "common/base_packet.h"
#include "common/misc.h"
#include "common/packet_dump.h"
BasePacket::BasePacket(const unsigned char *buf, uint32 len)
{
common/base_packet.h
+6 -17
View File
@@ -15,22 +15,14 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef BASEPACKET_H_
#define BASEPACKET_H_
#include "types.h"
#include "serialize_buffer.h"
#include <stdio.h>
#include <string.h>
#pragma once
#ifdef _WINDOWS
#include <time.h>
#include <winsock2.h>
#include <windows.h>
#else
#include <sys/time.h>
#include <netinet/in.h>
#endif
#include "common/platform/inet.h"
#include "common/serialize_buffer.h"
#include "common/types.h"
#include <cstdio>
class BasePacket {
public:
@@ -93,6 +85,3 @@ protected:
extern void DumpPacketHex(const BasePacket* app);
extern void DumpPacketAscii(const BasePacket* app);
extern void DumpPacketBin(const BasePacket* app);
#endif /*BASEPACKET_H_*/
common/bazaar.cpp
+3 -2
View File
@@ -1,7 +1,8 @@
#include "bazaar.h"
#include "../../common/item_instance.h"
#include "repositories/trader_repository.h"
#include "common/item_instance.h"
#include "common/repositories/trader_repository.h"
#include <memory>
std::vector<BazaarSearchResultsFromDB_Struct>
common/bazaar.h
+4 -7
View File
@@ -1,9 +1,9 @@
#ifndef EQEMU_BAZAAR_H
#define EQEMU_BAZAAR_H
#pragma once
#include "common/item_instance.h"
#include "common/shareddb.h"
#include <vector>
#include "shareddb.h"
#include "../../common/item_instance.h"
class Bazaar {
public:
@@ -11,6 +11,3 @@ public:
GetSearchResults(Database &content_db, Database &db, BazaarSearchCriteria_Struct search, unsigned int char_zone_id, int char_zone_instance_id);
};
#endif //EQEMU_BAZAAR_H
common/bodytypes.cpp
+1 -2
View File
@@ -1,5 +1,4 @@
#include "../common/global_define.h"
#include "../common/bodytypes.h"
#include "bodytypes.h"
std::string BodyType::GetName(uint8 body_type_id)
{
common/bodytypes.h
+4 -5
View File
@@ -15,10 +15,11 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef BODYTYPES_H
#define BODYTYPES_H
#include "types.h"
#pragma once
#include "common/types.h"
#include <map>
#include <string>
@@ -109,5 +110,3 @@ static std::map<uint8, std::string> body_type_names = {
{ BodyType::InvisibleMan, "Invisible Man" },
{ BodyType::Special, "Special" },
};
#endif
common/classes.cpp
+6 -4
View File
@@ -15,10 +15,12 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <fmt/format.h>
#include "../common/global_define.h"
#include "../common/classes.h"
#include "data_verification.h"
#include "classes.h"
#include "common/data_verification.h"
#include "fmt/format.h"
const char *GetClassIDName(uint8 class_id, uint8 level)
{
common/classes.h
+6 -7
View File
@@ -15,13 +15,14 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef CLASSES_CH
#define CLASSES_CH
#include "../common/types.h"
#include "../common/rulesys.h"
#include <string>
#pragma once
#include "common/rulesys.h"
#include "common/types.h"
#include <map>
#include <string>
namespace Class {
constexpr uint8 None = 0;
@@ -156,5 +157,3 @@ bool IsChainClass(uint8 class_id);
bool IsLeatherClass(uint8 class_id);
bool IsClothClass(uint8 class_id);
uint8 ClassArmorType(uint8 class_id);
#endif
common/cli/eqemu_command_handler.cpp
+5 -4
View File
@@ -18,10 +18,11 @@
*
*/
#include <fmt/format.h>
#include "eqemu_command_handler.h"
#include "terminal_color.hpp"
#include "../platform.h"
#include "common/cli/eqemu_command_handler.h"
#include "common/cli/terminal_color.hpp"
#include "common/platform.h"
#include "fmt/format.h"
namespace EQEmuCommand {
common/cli/eqemu_command_handler.h
+6 -6
View File
@@ -18,10 +18,13 @@
*
*/
#ifndef EQEMU_EQEMU_COMMAND_HANDLER_H
#define EQEMU_EQEMU_COMMAND_HANDLER_H
#pragma once
#include "argh.h"
#include "common/cli/argh.h"
#include <map>
#include <string>
#include <vector>
namespace EQEmuCommand {
@@ -70,6 +73,3 @@ namespace EQEmuCommand {
char **argv
);
};
#endif //EQEMU_EQEMU_COMMAND_HANDLER_H
common/compression.cpp
+6 -4
View File
@@ -1,7 +1,9 @@
#include "global_define.h"
#include "types.h"
#include <string.h>
#include <zlib.h>
#include "compression.h"
#include "common/types.h"
#include "zlib.h"
#include <cstring>
namespace EQ
{
common/compression.h
+2
View File
@@ -1,5 +1,7 @@
#pragma once
#include "common/types.h"
namespace EQ
{
uint32 EstimateDeflateBuffer(uint32 len);
common/condition.h
+5 -10
View File
@@ -15,14 +15,12 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __CONDITION_H
#define __CONDITION_H
#include "global_define.h"
#include "mutex.h"
#ifndef WIN32
#include <pthread.h>
#endif
#pragma once
#include "common/mutex.h"
#include "common/platform/posix/include_pthreads.h"
#include "common/platform/win/include_windows.h"
//Sombody, someday needs to figure out how to implement a condition
//system on windows...
@@ -52,6 +50,3 @@ class Condition {
// bool TimedWait(unsigned long usec);
~Condition();
};
#endif
common/content/world_content_service.cpp
+7 -7
View File
@@ -1,13 +1,13 @@
#include "world_content_service.h"
#include <utility>
#include <glm/vec3.hpp>
#include "../database.h"
#include "../rulesys.h"
#include "../eqemu_logsys.h"
#include "../repositories/instance_list_repository.h"
#include "../zone_store.h"
#include "common/database.h"
#include "common/eqemu_logsys.h"
#include "common/repositories/instance_list_repository.h"
#include "common/rulesys.h"
#include "common/zone_store.h"
#include "glm/vec3.hpp"
#include <utility>
WorldContentService::WorldContentService()
{
common/content/world_content_service.h
+6 -7
View File
@@ -1,11 +1,12 @@
#ifndef EQEMU_WORLD_CONTENT_SERVICE_H
#define EQEMU_WORLD_CONTENT_SERVICE_H
#pragma once
#include "common/repositories/content_flags_repository.h"
#include "common/repositories/instance_list_repository.h"
#include "common/repositories/zone_repository.h"
#include <string>
#include <vector>
#include "../repositories/content_flags_repository.h"
#include "../repositories/zone_repository.h"
#include "../repositories/instance_list_repository.h"
class Database;
@@ -199,5 +200,3 @@ private:
WorldContentService *LoadStaticGlobalZoneInstances();
std::vector<InstanceListRepository::InstanceList> m_zone_static_instances;
};
#endif //EQEMU_WORLD_CONTENT_SERVICE_H
common/crash.cpp
+15 -19
View File
@@ -1,29 +1,25 @@
#include "global_define.h"
#include "eqemu_logsys.h"
#include "crash.h"
#include "strings.h"
#include "process/process.h"
#include "http/httplib.h"
#include "http/uri.h"
#include "json/json.h"
#include "version.h"
#include "eqemu_config.h"
#include "serverinfo.h"
#include "rulesys.h"
#include "platform.h"
#include "common/eqemu_config.h"
#include "common/eqemu_logsys.h"
#include "common/http/httplib.h"
#include "common/http/uri.h"
#include "common/json/json.h"
#include "common/platform.h"
#include "common/process/process.h"
#include "common/rulesys.h"
#include "common/serverinfo.h"
#include "common/strings.h"
#include "common/version.h"
#include <cstdio>
#include <vector>
#ifdef _WINDOWS
#define popen _popen
#endif
void SendCrashReport(const std::string &crash_report)
{
// can configure multiple endpoints if need be
std::vector<std::string> endpoints = {
"https://spire.akkadius.com/api/v1/analytics/server-crash-report",
"https://spire.eqemu.dev/api/v1/analytics/server-crash-report",
// "http://localhost:3010/api/v1/analytics/server-crash-report", // development
};
@@ -224,8 +220,8 @@ void set_exception_handler() {
}
#else
#include <stdio.h>
#include <stdlib.h>
#include <cstdio>
#include <cstdlib>
#include <sys/wait.h>
#include <unistd.h>
#include <sys/fcntl.h>
common/crash.h
+1 -4
View File
@@ -1,6 +1,3 @@
#ifndef __EQEMU_CRASH_H
#define __EQEMU_CRASH_H
#pragma once
void set_exception_handler();
#endif
common/crc16.cpp
+3 -2
View File
@@ -1,4 +1,6 @@
#include "crc32.h"
#include "crc16.h"
#include "common/crc32.h"
uint16 CRC16(const unsigned char *buf, int size, int key)
{
@@ -12,4 +14,3 @@ uint16 CRC16(const unsigned char *buf, int size, int key)
crc = CRC32::Update(buf, size, crc);
return CRC32::Finish(crc) & 0xffff;
}
common/crc16.h
+3 -5
View File
@@ -1,7 +1,5 @@
#ifndef _CRC16_H
#define _CRC16_H
#include "types.h"
#pragma once
#include "common/types.h"
uint16 CRC16(const unsigned char *buf, int size, int key);
#endif
common/crc32.cpp
+2 -1
View File
@@ -1,5 +1,6 @@
#include "crc32.h"
#include <assert.h>
#include <cassert>
#include <memory.h>
uint32 CRC32Table[256] =
common/crc32.h
+3 -4
View File
@@ -1,6 +1,6 @@
#ifndef CRC32_H
#define CRC32_H
#include "types.h"
#pragma once
#include "common/types.h"
class CRC32 {
public:
@@ -17,4 +17,3 @@ public:
private:
static inline void Calc(const uint8 byte, uint32& crc32);
};
#endif
common/cron/croncpp.h
+4 -4
View File
@@ -1,13 +1,13 @@
#pragma once
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <ctime>
#include <iomanip>
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>
#if __cplusplus > 201402L
#include <string_view>
common/data_bucket.cpp
+39 -46
View File
@@ -1,25 +1,18 @@
#include "../common/data_bucket.h"
#include "database.h"
#include <ctime>
#include "data_bucket.h"
#include "common/data_bucket.h"
#include "common/database.h"
#include "common/json/json.hpp"
#include <cctype>
#include "../common/json/json.hpp"
#include <ctime>
using json = nlohmann::json;
const std::string NESTED_KEY_DELIMITER = ".";
std::vector<DataBucketsRepository::DataBuckets> g_data_bucket_cache = {};
#if defined(ZONE)
#include "../zone/zonedb.h"
extern ZoneDatabase database;
#elif defined(WORLD)
#include "../world/worlddb.h"
extern WorldDatabase database;
#else
#error "You must define either ZONE or WORLD"
#endif
void DataBucket::SetData(const std::string &bucket_key, const std::string &bucket_value, std::string expires_time)
void DataBucket::SetData(SharedDatabase* database, const std::string &bucket_key, const std::string &bucket_value, std::string expires_time)
{
auto k = DataBucketKey{
.key = bucket_key,
@@ -27,10 +20,10 @@ void DataBucket::SetData(const std::string &bucket_key, const std::string &bucke
.expires = expires_time,
};
DataBucket::SetData(k);
DataBucket::SetData(database, k);
}
void DataBucket::SetData(const DataBucketKey &k_)
void DataBucket::SetData(SharedDatabase *database, const DataBucketKey &k_)
{
DataBucketKey k = k_; // copy the key so we can modify it
bool is_nested = k.key.find(NESTED_KEY_DELIMITER) != std::string::npos;
@@ -39,7 +32,7 @@ void DataBucket::SetData(const DataBucketKey &k_)
}
auto b = DataBucketsRepository::NewEntity();
auto r = GetData(k, true);
auto r = GetData(database, k, true);
// if we have an entry, use it
if (r.id > 0) {
b = r;
@@ -149,10 +142,10 @@ void DataBucket::SetData(const DataBucketKey &k_)
}
}
DataBucketsRepository::UpdateOne(database, b);
DataBucketsRepository::UpdateOne(*database, b);
}
else {
b = DataBucketsRepository::InsertOne(database, b);
b = DataBucketsRepository::InsertOne(*database, b);
// add to cache if it doesn't exist
if (CanCache(k) && !ExistsInCache(b)) {
@@ -162,9 +155,9 @@ void DataBucket::SetData(const DataBucketKey &k_)
}
}
std::string DataBucket::GetData(const std::string &bucket_key)
std::string DataBucket::GetData(SharedDatabase* database, const std::string &bucket_key)
{
return GetData(DataBucketKey{.key = bucket_key}).value;
return GetData(database, DataBucketKey{.key = bucket_key}).value;
}
DataBucketsRepository::DataBuckets DataBucket::ExtractNestedValue(
@@ -214,7 +207,7 @@ DataBucketsRepository::DataBuckets DataBucket::ExtractNestedValue(
// if the bucket doesn't exist, it will be added to the cache as a miss
// if ignore_misses_cache is true, the bucket will not be added to the cache as a miss
// the only place we should be ignoring the misses cache is on the initial read during SetData
DataBucketsRepository::DataBuckets DataBucket::GetData(const DataBucketKey &k_, bool ignore_misses_cache)
DataBucketsRepository::DataBuckets DataBucket::GetData(SharedDatabase* database, const DataBucketKey &k_, bool ignore_misses_cache)
{
DataBucketKey k = k_; // Copy the key so we can modify it
@@ -244,7 +237,7 @@ DataBucketsRepository::DataBuckets DataBucket::GetData(const DataBucketKey &k_,
if (CheckBucketMatch(e, k)) {
if (e.expires > 0 && e.expires < std::time(nullptr)) {
LogDataBuckets("Attempted to read expired key [{}] removing from cache", e.key_);
DeleteData(k);
DeleteData(database, k);
return DataBucketsRepository::NewEntity();
}
@@ -261,7 +254,7 @@ DataBucketsRepository::DataBuckets DataBucket::GetData(const DataBucketKey &k_,
// Fetch the value from the database
auto r = DataBucketsRepository::GetWhere(
database,
*database,
fmt::format(
" {} `key` = '{}' LIMIT 1",
DataBucket::GetScopedDbFilters(k),
@@ -310,7 +303,7 @@ DataBucketsRepository::DataBuckets DataBucket::GetData(const DataBucketKey &k_,
// If the entry has expired, delete it
if (bucket.expires > 0 && bucket.expires < static_cast<long long>(std::time(nullptr))) {
DeleteData(k);
DeleteData(database, k);
return DataBucketsRepository::NewEntity();
}
@@ -337,22 +330,22 @@ DataBucketsRepository::DataBuckets DataBucket::GetData(const DataBucketKey &k_,
return bucket;
}
std::string DataBucket::GetDataExpires(const std::string &bucket_key)
std::string DataBucket::GetDataExpires(SharedDatabase* database, const std::string &bucket_key)
{
return GetDataExpires(DataBucketKey{.key = bucket_key});
return GetDataExpires(database, DataBucketKey{.key = bucket_key});
}
std::string DataBucket::GetDataRemaining(const std::string &bucket_key)
std::string DataBucket::GetDataRemaining(SharedDatabase* database, const std::string &bucket_key)
{
return GetDataRemaining(DataBucketKey{.key = bucket_key});
return GetDataRemaining(database, DataBucketKey{.key = bucket_key});
}
bool DataBucket::DeleteData(const std::string &bucket_key)
bool DataBucket::DeleteData(SharedDatabase* database, const std::string &bucket_key)
{
return DeleteData(DataBucketKey{.key = bucket_key});
return DeleteData(database, DataBucketKey{.key = bucket_key});
}
bool DataBucket::DeleteData(const DataBucketKey &k)
bool DataBucket::DeleteData(SharedDatabase* database, const DataBucketKey &k)
{
bool is_nested_key = k.key.find(NESTED_KEY_DELIMITER) != std::string::npos;
@@ -374,7 +367,7 @@ bool DataBucket::DeleteData(const DataBucketKey &k)
// Regular key deletion, no nesting involved
return DataBucketsRepository::DeleteWhere(
database,
*database,
fmt::format("{} `key` = '{}'", DataBucket::GetScopedDbFilters(k), k.key)
);
}
@@ -384,7 +377,7 @@ bool DataBucket::DeleteData(const DataBucketKey &k)
DataBucketKey top_level_k = k;
top_level_k.key = top_level_key;
auto r = GetData(top_level_k);
auto r = GetData(database, top_level_k);
if (r.id == 0 || r.value.empty() || !Strings::IsValidJson(r.value)) {
LogDataBuckets("Attempted to delete nested key [{}] but parent key [{}] does not exist or is invalid JSON", k.key, top_level_key);
return false;
@@ -444,14 +437,14 @@ bool DataBucket::DeleteData(const DataBucketKey &k)
}
return DataBucketsRepository::DeleteWhere(
database,
*database,
fmt::format("{} `key` = '{}'", DataBucket::GetScopedDbFilters(k), top_level_key)
);
}
// Otherwise, update the existing JSON without the deleted key
r.value = json_value.dump();
DataBucketsRepository::UpdateOne(database, r);
DataBucketsRepository::UpdateOne(*database, r);
// Update cache
if (CanCache(k)) {
@@ -466,7 +459,7 @@ bool DataBucket::DeleteData(const DataBucketKey &k)
return true;
}
std::string DataBucket::GetDataExpires(const DataBucketKey &k)
std::string DataBucket::GetDataExpires(SharedDatabase* database, const DataBucketKey &k)
{
LogDataBuckets(
"Getting bucket expiration key [{}] bot_id [{}] account_id [{}] character_id [{}] npc_id [{}]",
@@ -477,7 +470,7 @@ std::string DataBucket::GetDataExpires(const DataBucketKey &k)
k.npc_id
);
auto r = GetData(k);
auto r = GetData(database, k);
if (r.id == 0) {
return {};
}
@@ -485,7 +478,7 @@ std::string DataBucket::GetDataExpires(const DataBucketKey &k)
return std::to_string(r.expires);
}
std::string DataBucket::GetDataRemaining(const DataBucketKey &k)
std::string DataBucket::GetDataRemaining(SharedDatabase* database, const DataBucketKey &k)
{
LogDataBuckets(
"Getting bucket remaining key [{}] bot_id [{}] account_id [{}] character_id [{}] npc_id [{}] bot_id [{}] zone_id [{}] instance_id [{}]",
@@ -499,7 +492,7 @@ std::string DataBucket::GetDataRemaining(const DataBucketKey &k)
k.instance_id
);
auto r = GetData(k);
auto r = GetData(database, k);
if (r.id == 0) {
return "0";
}
@@ -565,10 +558,10 @@ bool DataBucket::CheckBucketMatch(const DataBucketsRepository::DataBuckets &dbe,
);
}
void DataBucket::LoadZoneCache(uint16 zone_id, uint16 instance_id)
void DataBucket::LoadZoneCache(SharedDatabase* database, uint16 zone_id, uint16 instance_id)
{
const auto &l = DataBucketsRepository::GetWhere(
database,
*database,
fmt::format(
"zone_id = {} AND instance_id = {} AND (`expires` > {} OR `expires` = 0)",
zone_id,
@@ -608,7 +601,7 @@ void DataBucket::LoadZoneCache(uint16 zone_id, uint16 instance_id)
);
}
void DataBucket::BulkLoadEntitiesToCache(DataBucketLoadType::Type t, std::vector<uint32> ids)
void DataBucket::BulkLoadEntitiesToCache(SharedDatabase* database, DataBucketLoadType::Type t, std::vector<uint32> ids)
{
if (ids.empty()) {
return;
@@ -653,7 +646,7 @@ void DataBucket::BulkLoadEntitiesToCache(DataBucketLoadType::Type t, std::vector
}
const auto &l = DataBucketsRepository::GetWhere(
database,
*database,
fmt::format(
"{} IN ({}) AND (`expires` > {} OR `expires` = 0)",
column,
@@ -843,4 +836,4 @@ bool DataBucket::CanCache(const DataBucketKey &key)
}
return false;
}
}
common/data_bucket.h
+18 -19
View File
@@ -1,10 +1,11 @@
#ifndef EQEMU_DATABUCKET_H
#define EQEMU_DATABUCKET_H
#pragma once
#include "common/json/json_archive_single_line.h"
#include "common/repositories/data_buckets_repository.h"
#include "common/shareddb.h"
#include "common/types.h"
#include <string>
#include "types.h"
#include "repositories/data_buckets_repository.h"
#include "json/json_archive_single_line.h"
struct DataBucketKey {
std::string key;
@@ -38,26 +39,26 @@ namespace DataBucketLoadType {
class DataBucket {
public:
// non-scoped bucket methods (for global buckets)
static void SetData(const std::string &bucket_key, const std::string &bucket_value, std::string expires_time = "");
static bool DeleteData(const std::string &bucket_key);
static std::string GetData(const std::string &bucket_key);
static std::string GetDataExpires(const std::string &bucket_key);
static std::string GetDataRemaining(const std::string &bucket_key);
static void SetData(SharedDatabase *database, const std::string &bucket_key, const std::string &bucket_value, std::string expires_time = "");
static bool DeleteData(SharedDatabase *database, const std::string &bucket_key);
static std::string GetData(SharedDatabase *database, const std::string &bucket_key);
static std::string GetDataExpires(SharedDatabase *database, const std::string &bucket_key);
static std::string GetDataRemaining(SharedDatabase *database, const std::string &bucket_key);
// scoped bucket methods
static void SetData(const DataBucketKey &k_);
static bool DeleteData(const DataBucketKey &k);
static DataBucketsRepository::DataBuckets GetData(const DataBucketKey &k_, bool ignore_misses_cache = false);
static std::string GetDataExpires(const DataBucketKey &k);
static std::string GetDataRemaining(const DataBucketKey &k);
static void SetData(SharedDatabase *database, const DataBucketKey &k_);
static bool DeleteData(SharedDatabase *database, const DataBucketKey &k);
static DataBucketsRepository::DataBuckets GetData(SharedDatabase *database, const DataBucketKey &k_, bool ignore_misses_cache = false);
static std::string GetDataExpires(SharedDatabase *database, const DataBucketKey &k);
static std::string GetDataRemaining(SharedDatabase *database, const DataBucketKey &k);
static std::string GetScopedDbFilters(const DataBucketKey &k);
// bucket repository versus key matching
static bool CheckBucketMatch(const DataBucketsRepository::DataBuckets &dbe, const DataBucketKey &k);
static bool ExistsInCache(const DataBucketsRepository::DataBuckets &entry);
static void LoadZoneCache(uint16 zone_id, uint16 instance_id);
static void BulkLoadEntitiesToCache(DataBucketLoadType::Type t, std::vector<uint32> ids);
static void LoadZoneCache(SharedDatabase* database, uint16 zone_id, uint16 instance_id);
static void BulkLoadEntitiesToCache(SharedDatabase* database, DataBucketLoadType::Type t, std::vector<uint32> ids);
static void DeleteCachedBuckets(DataBucketLoadType::Type type, uint32 id, uint32 secondary_id = 0);
static void DeleteFromMissesCache(DataBucketsRepository::DataBuckets e);
@@ -68,5 +69,3 @@ public:
static DataBucketsRepository::DataBuckets
ExtractNestedValue(const DataBucketsRepository::DataBuckets &bucket, const std::string &full_key);
};
#endif //EQEMU_DATABUCKET_H
common/database.cpp
+39 -62
View File
@@ -16,71 +16,48 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "../common/global_define.h"
#include "../common/rulesys.h"
#include "common/data_verification.h"
#include "common/database_schema.h"
#include "common/database.h"
#include "common/eq_packet_structs.h"
#include "common/events/player_event_logs.h"
#include "common/extprofile.h"
#include "common/http/httplib.h"
#include "common/http/uri.h"
#include "common/platform/win/include_windows.h"
#include "common/repositories/account_repository.h"
#include "common/repositories/adventure_stats_repository.h"
#include "common/repositories/bot_data_repository.h"
#include "common/repositories/buyer_repository.h"
#include "common/repositories/character_bind_repository.h"
#include "common/repositories/character_data_repository.h"
#include "common/repositories/character_languages_repository.h"
#include "common/repositories/character_leadership_abilities_repository.h"
#include "common/repositories/character_parcels_repository.h"
#include "common/repositories/character_pet_name_repository.h"
#include "common/repositories/character_skills_repository.h"
#include "common/repositories/data_buckets_repository.h"
#include "common/repositories/group_id_repository.h"
#include "common/repositories/group_leaders_repository.h"
#include "common/repositories/guild_members_repository.h"
#include "common/repositories/instance_list_repository.h"
#include "common/repositories/inventory_snapshots_repository.h"
#include "common/repositories/ip_exemptions_repository.h"
#include "common/repositories/merchantlist_temp_repository.h"
#include "common/repositories/name_filter_repository.h"
#include "common/repositories/npc_types_repository.h"
#include "common/repositories/raid_details_repository.h"
#include "common/repositories/raid_members_repository.h"
#include "common/repositories/reports_repository.h"
#include "common/repositories/trader_repository.h"
#include "common/repositories/variables_repository.h"
#include "common/repositories/zone_repository.h"
#include "common/rulesys.h"
#include "common/strings.h"
#include "common/zone_store.h"
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <algorithm>
#include <mysqld_error.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../common/repositories/account_repository.h"
#include "../common/repositories/adventure_stats_repository.h"
#include "../common/repositories/character_bind_repository.h"
#include "../common/repositories/character_data_repository.h"
#include "../common/repositories/character_languages_repository.h"
#include "../common/repositories/character_leadership_abilities_repository.h"
#include "../common/repositories/character_parcels_repository.h"
#include "../common/repositories/character_skills_repository.h"
#include "../common/repositories/data_buckets_repository.h"
#include "../common/repositories/group_id_repository.h"
#include "../common/repositories/group_leaders_repository.h"
#include "../common/repositories/guild_members_repository.h"
#include "../common/repositories/instance_list_repository.h"
#include "../common/repositories/inventory_snapshots_repository.h"
#include "../common/repositories/ip_exemptions_repository.h"
#include "../common/repositories/name_filter_repository.h"
#include "../common/repositories/npc_types_repository.h"
#include "../common/repositories/raid_details_repository.h"
#include "../common/repositories/raid_members_repository.h"
#include "../common/repositories/reports_repository.h"
#include "../common/repositories/variables_repository.h"
#include "../common/repositories/character_pet_name_repository.h"
#include "../common/events/player_event_logs.h"
// Disgrace: for windows compile
#ifdef _WINDOWS
#include <windows.h>
#define snprintf _snprintf
#define strncasecmp _strnicmp
#define strcasecmp _stricmp
#else
#include "unix.h"
#include <netinet/in.h>
#include <sys/time.h>
#endif
#include "database.h"
#include "data_verification.h"
#include "eq_packet_structs.h"
#include "extprofile.h"
#include "strings.h"
#include "database_schema.h"
#include "http/httplib.h"
#include "http/uri.h"
#include "repositories/zone_repository.h"
#include "zone_store.h"
#include "repositories/merchantlist_temp_repository.h"
#include "repositories/bot_data_repository.h"
#include "repositories/trader_repository.h"
#include "repositories/buyer_repository.h"
extern Client client;
common/database.h
+8 -24
View File
@@ -15,25 +15,22 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef EQEMU_DATABASE_H
#define EQEMU_DATABASE_H
#define AUTHENTICATION_TIMEOUT 60
#define INVALID_ID 0xFFFFFFFF
#pragma once
#include "global_define.h"
#include "eqemu_logsys.h"
#include "types.h"
#include "dbcore.h"
#include "linked_list.h"
#include "eq_packet_structs.h"
#include "common/dbcore.h"
#include "common/eq_packet_structs.h"
#include "common/eqemu_logsys.h"
#include "common/linked_list.h"
#include "common/types.h"
#include <cmath>
#include <string>
#include <vector>
#include <map>
#define AUTHENTICATION_TIMEOUT 60
#define INVALID_ID 0xFFFFFFFF
class MySQLRequestResult;
class Client;
@@ -63,17 +60,6 @@ struct VarCache_Struct {
class PTimerList;
#ifdef _WINDOWS
#if _MSC_VER > 1700 // greater than 2012 (2013+)
# define _ISNAN_(a) std::isnan(a)
#else
# include <float.h>
# define _ISNAN_(a) _isnan(a)
#endif
#else
# define _ISNAN_(a) std::isnan(a)
#endif
#define SQL(...) #__VA_ARGS__
class Database : public DBcore {
@@ -292,5 +278,3 @@ private:
void ClearAllRaidDetails();
void ClearAllRaidLeaders();
};
#endif
common/database/database_dump_service.cpp
+10 -18
View File
@@ -18,28 +18,20 @@
*
*/
#include <string>
#include <cstdio>
#include <iterator>
#include "database_dump_service.h"
#include "../eqemu_logsys.h"
#include "../strings.h"
#include "../eqemu_config.h"
#include "../database_schema.h"
#include "../file.h"
#include "../process/process.h"
#include "../termcolor/rang.hpp"
#include "common/database_schema.h"
#include "common/eqemu_config.h"
#include "common/eqemu_logsys.h"
#include "common/file.h"
#include "common/process/process.h"
#include "common/strings.h"
#include "common/termcolor/rang.hpp"
#include <ctime>
#include <iterator>
#include <string>
#if _WIN32
#include <windows.h>
#else
#include <sys/time.h>
#include <thread>
#endif
#define DATABASE_DUMP_PATH "backups/"
common/database/database_dump_service.h
+2 -5
View File
@@ -18,9 +18,9 @@
*
*/
#ifndef EQEMU_DATABASE_DUMP_SERVICE_H
#define EQEMU_DATABASE_DUMP_SERVICE_H
#pragma once
#include <string>
class DatabaseDumpService {
public:
@@ -97,6 +97,3 @@ private:
void BuildCredentialsFile();
void RemoveCredentialsFile();
};
#endif //EQEMU_DATABASE_DUMP_SERVICE_H
common/database/database_update.cpp
+12 -10
View File
@@ -1,15 +1,17 @@
#include <filesystem>
#include "database_update.h"
#include "../eqemu_logsys.h"
#include "../database.h"
#include "../strings.h"
#include "../rulesys.h"
#include "../http/httplib.h"
#include "database_update_manifest.cpp"
#include "database_update_manifest_custom.cpp"
#include "database_update_manifest_bots.cpp"
#include "database_dump_service.h"
#include "common/database.h"
#include "common/database/database_dump_service.h"
#include "common/database/database_update_manifest_bots.h"
#include "common/database/database_update_manifest_custom.h"
#include "common/database/database_update_manifest.h"
#include "common/eqemu_logsys.h"
#include "common/http/httplib.h"
#include "common/rulesys.h"
#include "common/strings.h"
#include <filesystem>
constexpr int BREAK_LENGTH = 70;
common/database/database_update.h
+2 -6
View File
@@ -1,7 +1,6 @@
#ifndef EQEMU_DATABASE_UPDATE_H
#define EQEMU_DATABASE_UPDATE_H
#pragma once
#include "../database.h"
#include "common/database.h"
struct ManifestEntry {
int version{}; // database version of the migration
@@ -47,7 +46,4 @@ private:
static bool CheckVersionsUpToDate(DatabaseVersion v, DatabaseVersion b);
void InjectBotsVersionColumn();
void InjectCustomVersionColumn();
};
#endif //EQEMU_DATABASE_UPDATE_H
common/database/database_update_manifest.cpp → common/database/database_update_manifest.h
+5 -1
View File
@@ -1,4 +1,8 @@
#include "database_update.h"
#pragma once
#include "common/database/database_update.h"
#include <vector>
std::vector<ManifestEntry> manifest_entries = {
ManifestEntry{
common/database/database_update_manifest_bots.cpp → common/database/database_update_manifest_bots.h
+5 -1
View File
@@ -1,4 +1,8 @@
#include "database_update.h"
#pragma once
#include "common/database/database_update.h"
#include <vector>
std::vector<ManifestEntry> bot_manifest_entries = {
ManifestEntry{
common/database/database_update_manifest_custom.cpp → common/database/database_update_manifest_custom.h
+5 -1
View File
@@ -1,4 +1,8 @@
#include "database_update.h"
#pragma once
#include "common/database/database_update.h"
#include <vector>
std::vector<ManifestEntry> manifest_entries_custom = {
ManifestEntry{
common/database_instances.cpp
+20 -30
View File
@@ -16,39 +16,29 @@ along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "../common/global_define.h"
#include "../common/rulesys.h"
#include "../common/strings.h"
#include "../common/timer.h"
#include "../common/repositories/character_corpses_repository.h"
#include "../common/repositories/dynamic_zone_members_repository.h"
#include "../common/repositories/dynamic_zones_repository.h"
#include "../common/repositories/group_id_repository.h"
#include "../common/repositories/instance_list_repository.h"
#include "../common/repositories/instance_list_player_repository.h"
#include "../common/repositories/raid_members_repository.h"
#include "../common/repositories/respawn_times_repository.h"
#include "../common/repositories/spawn_condition_values_repository.h"
#include "repositories/spawn2_disabled_repository.h"
#include "repositories/data_buckets_repository.h"
#include "repositories/zone_state_spawns_repository.h"
#include "database.h"
#include <iomanip>
#include <iostream>
#include "common/platform/inet.h"
#include "common/platform/platform.h"
#include "common/platform/win/include_windows.h"
#include "common/repositories/character_corpses_repository.h"
#include "common/repositories/data_buckets_repository.h"
#include "common/repositories/dynamic_zone_members_repository.h"
#include "common/repositories/dynamic_zones_repository.h"
#include "common/repositories/group_id_repository.h"
#include "common/repositories/instance_list_player_repository.h"
#include "common/repositories/instance_list_repository.h"
#include "common/repositories/raid_members_repository.h"
#include "common/repositories/respawn_times_repository.h"
#include "common/repositories/spawn_condition_values_repository.h"
#include "common/repositories/spawn2_disabled_repository.h"
#include "common/repositories/zone_state_spawns_repository.h"
#include "common/rulesys.h"
#include "common/strings.h"
#include "common/timer.h"
#include "common/unix.h"
#include "zone/zonedb.h"
// Disgrace: for windows compile
#ifdef _WINDOWS
#include <windows.h>
#define snprintf _snprintf
#define strncasecmp _strnicmp
#define strcasecmp _stricmp
#else
#include "unix.h"
#include "../zone/zonedb.h"
#include <netinet/in.h>
#include <sys/time.h>
#endif
bool Database::AddClientToInstance(uint16 instance_id, uint32 character_id)
common/database_schema.h
+1 -4
View File
@@ -18,8 +18,7 @@
*
*/
#ifndef EQEMU_DATABASE_SCHEMA_H
#define EQEMU_DATABASE_SCHEMA_H
#pragma once
#include <vector>
#include <map>
@@ -438,5 +437,3 @@ namespace DatabaseSchema {
}
}
#endif //EQEMU_DATABASE_SCHEMA_H
common/dbcore.cpp
+15 -25
View File
@@ -1,31 +1,13 @@
#ifdef _WINDOWS
#include <winsock2.h>
#endif
#include "misc_functions.h"
#include "eqemu_logsys.h"
#include "timer.h"
#include "dbcore.h"
#include "mysql_stmt.h"
#include <fstream>
#include <iostream>
#include <mysqld_error.h>
#include <string.h>
#include "strings.h"
#include "common/eqemu_logsys.h"
#include "common/misc_functions.h"
#include "common/mysql_stmt.h"
#include "common/strings.h"
#include "common/timer.h"
#include "common/types.h"
#ifdef _WINDOWS
#define snprintf _snprintf
#define strncasecmp _strnicmp
#define strcasecmp _stricmp
#include <process.h>
#else
#include "unix.h"
#include <pthread.h>
#endif
#include "mysqld_error.h"
#ifdef _EQDEBUG
#define DEBUG_MYSQL_QUERIES 0
@@ -258,9 +240,17 @@ bool DBcore::Open(uint32 *errnum, char *errbuf)
if (pCompress) {
flags |= CLIENT_COMPRESS;
}
//todo: we need to revisit this ssl handling later
//the whole connect code is ancient and tls is starting to come as a default requirement for many db setups
if (pSSL) {
flags |= CLIENT_SSL;
}
else {
int off = 0;
mysql_options(mysql, MYSQL_OPT_SSL_ENFORCE, &off);
mysql_options(mysql, MYSQL_OPT_SSL_VERIFY_SERVER_CERT, &off);
}
if (mysql_real_connect(mysql, pHost, pUser, pPassword, pDatabase, pPort, 0, flags)) {
pStatus = Connected;
common/dbcore.h
+5 -15
View File
@@ -1,17 +1,10 @@
#ifndef DBCORE_H
#define DBCORE_H
#pragma once
#ifdef _WINDOWS
#include <winsock2.h>
#include <windows.h>
#endif
#include "common/mutex.h"
#include "common/mysql_request_result.h"
#include "common/types.h"
#include "../common/mutex.h"
#include "../common/mysql_request_result.h"
#include "../common/types.h"
#include <mysql.h>
#include <string.h>
#include "mysql.h"
#include <mutex>
#define CR_SERVER_GONE_ERROR 2006
@@ -102,6 +95,3 @@ private:
mysql_set_server_option(mysql, MYSQL_OPTION_MULTI_STATEMENTS_OFF);
}
};
#endif
common/deity.h
+3 -5
View File
@@ -17,10 +17,10 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef COMMON_DEITY_H
#define COMMON_DEITY_H
#pragma once
#include "common/types.h"
#include "types.h"
#include <map>
#include <string>
#include <limits>
@@ -113,5 +113,3 @@ static std::map<uint32, uint32> deity_bitmasks = {
{ Deity::Tunare, Deity::Bitmask::Tunare },
{ Deity::Veeshan, Deity::Bitmask::Veeshan }
};
#endif /* COMMON_DEITY_H */
common/discord/discord.cpp
+9 -7
View File
@@ -1,11 +1,13 @@
#include <cereal/archives/json.hpp>
#include <cereal/archives/binary.hpp>
#include "discord.h"
#include "../http/httplib.h"
#include "../json/json.h"
#include "../strings.h"
#include "../eqemu_logsys.h"
#include "../events/player_event_logs.h"
#include "common/eqemu_logsys.h"
#include "common/events/player_event_logs.h"
#include "common/http/httplib.h"
#include "common/json/json.h"
#include "common/strings.h"
#include "cereal/archives/binary.hpp"
#include "cereal/archives/json.hpp"
constexpr int MAX_RETRIES = 10;
common/discord/discord.h
+6 -9
View File
@@ -1,19 +1,16 @@
#ifndef EQEMU_DISCORD_H
#define EQEMU_DISCORD_H
#pragma once
#include "common/events/player_events.h"
#include "common/repositories/player_event_logs_repository.h"
#include "common/types.h"
#include <string>
#include "../types.h"
#include "../repositories/player_event_logs_repository.h"
#include "../events/player_events.h"
class Discord {
class Discord
{
public:
static void SendWebhookMessage(const std::string& message, const std::string& webhook_url);
static std::string FormatDiscordMessage(uint16 category_id, const std::string& message);
static void SendPlayerEventMessage(const PlayerEvent::PlayerEventContainer& e, const std::string &webhook_url);
static bool ValidateWebhookUrl(const std::string &webhook_url);
};
#endif //EQEMU_DISCORD_H
common/discord/discord_manager.cpp
+3 -2
View File
@@ -1,6 +1,7 @@
#include "discord_manager.h"
#include "../../common/discord/discord.h"
#include "../events/player_event_logs.h"
#include "common/discord/discord.h"
#include "common/events/player_event_logs.h"
void DiscordManager::QueueWebhookMessage(uint32 webhook_id, const std::string &message)
{
common/discord/discord_manager.h
+9 -10
View File
@@ -1,14 +1,16 @@
#ifndef EQEMU_DISCORD_MANAGER_H
#define EQEMU_DISCORD_MANAGER_H
#include <mutex>
#pragma once
#include "common/events/player_events.h"
#include "common/repositories/player_event_logs_repository.h"
#include "common/types.h"
#include <map>
#include <mutex>
#include <vector>
#include "../../common/types.h"
#include "../repositories/player_event_logs_repository.h"
#include "../events/player_events.h"
class DiscordManager {
class DiscordManager
{
public:
void QueueWebhookMessage(uint32 webhook_id, const std::string& message);
void ProcessMessageQueue();
@@ -23,6 +25,3 @@ private:
std::mutex webhook_queue_lock{};
std::map<uint32, std::vector<std::string>> webhook_message_queue{};
};
#endif
common/dynamic_zone_base.cpp
+10 -9
View File
@@ -1,13 +1,14 @@
#include "dynamic_zone_base.h"
#include "database.h"
#include "eqemu_logsys.h"
#include "rulesys.h"
#include "servertalk.h"
#include "util/uuid.h"
#include "repositories/character_expedition_lockouts_repository.h"
#include "repositories/dynamic_zone_lockouts_repository.h"
#include "repositories/instance_list_repository.h"
#include "repositories/instance_list_player_repository.h"
#include "common/database.h"
#include "common/eqemu_logsys.h"
#include "common/repositories/character_expedition_lockouts_repository.h"
#include "common/repositories/dynamic_zone_lockouts_repository.h"
#include "common/repositories/instance_list_player_repository.h"
#include "common/repositories/instance_list_repository.h"
#include "common/rulesys.h"
#include "common/servertalk.h"
#include "common/util/uuid.h"
DynamicZoneBase::DynamicZoneBase(DynamicZonesRepository::DynamicZoneInstance&& entry)
{
common/dynamic_zone_base.h
+7 -9
View File
@@ -1,11 +1,11 @@
#ifndef COMMON_DYNAMIC_ZONE_BASE_H
#define COMMON_DYNAMIC_ZONE_BASE_H
#pragma once
#include "common/dynamic_zone_lockout.h"
#include "common/eq_constants.h"
#include "common/repositories/dynamic_zone_members_repository.h"
#include "common/repositories/dynamic_zone_templates_repository.h"
#include "common/repositories/dynamic_zones_repository.h"
#include "dynamic_zone_lockout.h"
#include "eq_constants.h"
#include "repositories/dynamic_zones_repository.h"
#include "repositories/dynamic_zone_members_repository.h"
#include "repositories/dynamic_zone_templates_repository.h"
#include <algorithm>
#include <chrono>
#include <cstdint>
@@ -270,5 +270,3 @@ public:
);
}
};
#endif
common/dynamic_zone_lockout.cpp
+5 -3
View File
@@ -1,9 +1,11 @@
#include "dynamic_zone_lockout.h"
#include "strings.h"
#include "rulesys.h"
#include "strings.h"
#include "util/uuid.h"
#include <fmt/format.h>
#include <cereal/types/chrono.hpp>
#include "fmt/format.h"
#include "cereal/types/chrono.hpp"
#include "cereal/archives/binary.hpp"
DzLockout::DzLockout(std::string uuid, std::string expedition, std::string event, uint64_t expire_time, uint32_t duration)
: m_uuid(std::move(uuid))
common/dynamic_zone_lockout.h
+2 -1
View File
@@ -1,8 +1,9 @@
#pragma once
#include "repositories/base/base_dynamic_zone_lockouts_repository.h"
#include <chrono>
#include <string>
#include "repositories/base/base_dynamic_zone_lockouts_repository.h"
class DzLockout
{
common/emu_constants.cpp
+6 -6
View File
@@ -17,12 +17,12 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "emu_constants.h"
#include "bodytypes.h"
#include "data_verification.h"
#include "eqemu_logsys.h"
#include "eqemu_logsys_log_aliases.h"
#include "rulesys.h"
#include "common/bodytypes.h"
#include "common/data_verification.h"
#include "common/emu_constants.h"
#include "common/eqemu_logsys_log_aliases.h"
#include "common/eqemu_logsys.h"
#include "common/rulesys.h"
int16 EQ::invtype::GetInvTypeSize(int16 inv_type) {
static const int16 local_array[] = {
common/emu_constants.h
+5 -8
View File
@@ -17,14 +17,13 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef COMMON_EMU_CONSTANTS_H
#define COMMON_EMU_CONSTANTS_H
#pragma once
#include "eq_limits.h"
#include "emu_versions.h"
#include "bodytypes.h"
#include "common/bodytypes.h"
#include "common/emu_versions.h"
#include "common/eq_limits.h"
#include <string.h>
#include <cstring>
namespace AccountStatus {
constexpr uint8 Player = 0;
@@ -918,5 +917,3 @@ namespace PetType {
std::string GetName(uint8 pet_type);
bool IsValid(uint8 pet_type);
}
#endif /*COMMON_EMU_CONSTANTS_H*/
common/emu_limits.h
+3 -6
View File
@@ -17,12 +17,11 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef COMMON_EMU_LIMITS_H
#define COMMON_EMU_LIMITS_H
#pragma once
#include "types.h"
#include "common/types.h"
#include <stdlib.h>
#include <cstdlib>
namespace EntityLimits
@@ -124,5 +123,3 @@ namespace EntityLimits
} /*Pet*/
}; /*EntityLimits*/
#endif /*COMMON_EMU_LIMITS_H*/
common/emu_opcodes.cpp
+1 -8
View File
@@ -16,8 +16,7 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
*/
#include "global_define.h"
#include "emu_opcodes.h"
#include "common/emu_opcodes.h"
const char *OpcodeNames[_maxEmuOpcode+1] = {
"OP_Unknown",
@@ -30,9 +29,3 @@ const char *OpcodeNames[_maxEmuOpcode+1] = {
""
};
common/emu_opcodes.h
+2 -5
View File
@@ -15,8 +15,8 @@ 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 04111-1307 USA
*/
#ifndef EMU_OPCODES_H
#define EMU_OPCODES_H
#pragma once
//this is the highest opcode possibly used in the regular EQ protocol
#define MAX_EQ_OPCODE 0xFFFF
@@ -47,6 +47,3 @@ typedef enum { //EQEmu internal opcodes list
constexpr int format_as(EmuOpcode opcode) { return static_cast<int>(opcode); }
extern const char *OpcodeNames[_maxEmuOpcode+1];
#endif
common/emu_versions.cpp
+2 -2
View File
@@ -17,8 +17,8 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "emu_versions.h"
#include "emu_constants.h"
#include "common/emu_versions.h"
#include "common/emu_constants.h"
bool EQ::versions::IsValidClientVersion(ClientVersion client_version)
common/emu_versions.h
+3 -7
View File
@@ -17,13 +17,11 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef COMMON_EMU_VERSIONS_H
#define COMMON_EMU_VERSIONS_H
#pragma once
#include "types.h"
#include <stdlib.h>
#include "common/types.h"
#include <cstdlib>
namespace EQ
{
@@ -218,5 +216,3 @@ namespace EQ
} /*expansions*/
} /*EQEmu*/
#endif /*COMMON_EMU_VERSIONS_H*/
common/eq_constants.h
+3 -6
View File
@@ -17,11 +17,10 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef COMMON_EQ_CONSTANTS_H
#define COMMON_EQ_CONSTANTS_H
#pragma once
#include "skills.h"
#include "types.h"
#include "common/skills.h"
#include "common/types.h"
namespace AppearanceType {
constexpr uint32 Die = 0; // Causes the client to keel over and zone to bind point (default action)
@@ -1096,5 +1095,3 @@ enum ExpSource
namespace DoorType {
constexpr uint32 BuyerStall = 155;
}
#endif /*COMMON_EQ_CONSTANTS_H*/
common/eq_limits.cpp
+3 -3
View File
@@ -17,9 +17,9 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "emu_constants.h"
#include "emu_limits.h"
#include "rulesys.h"
#include "common/emu_constants.h"
#include "common/emu_limits.h"
#include "common/rulesys.h"
#include <memory>
common/eq_limits.h
+10 -13
View File
@@ -17,18 +17,17 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef COMMON_EQ_LIMITS_H
#define COMMON_EQ_LIMITS_H
#pragma once
#include "types.h"
#include "eq_constants.h"
#include "emu_versions.h"
#include "../common/patches/titanium_limits.h"
#include "../common/patches/sof_limits.h"
#include "../common/patches/sod_limits.h"
#include "../common/patches/uf_limits.h"
#include "../common/patches/rof_limits.h"
#include "../common/patches/rof2_limits.h"
#include "common/emu_versions.h"
#include "common/eq_constants.h"
#include "common/patches/rof_limits.h"
#include "common/patches/rof2_limits.h"
#include "common/patches/sod_limits.h"
#include "common/patches/sof_limits.h"
#include "common/patches/titanium_limits.h"
#include "common/patches/uf_limits.h"
#include "common/types.h"
namespace EQ
@@ -268,5 +267,3 @@ namespace Client62
} // namespace constants
} /*Client62*/
#endif /*COMMON_EQ_LIMITS_H*/
common/eq_packet.cpp
+11 -16
View File
@@ -16,25 +16,20 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "crc16.h"
#include "global_define.h"
#include "eq_packet.h"
#include "misc.h"
#include "op_codes.h"
#include "platform.h"
#include "common/misc.h"
#include "common/op_codes.h"
#ifndef STATIC_OPCODE
#include "common/opcodemgr.h"
#endif
#include "common/packet_dump.h"
#include "common/packet_functions.h"
#include "common/platform.h"
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stdio.h>
#ifndef STATIC_OPCODE
#include "opcodemgr.h"
#endif
#include "packet_dump.h"
#include "packet_functions.h"
#include <cstdlib>
#include <cstring>
EQPacket::EQPacket(EmuOpcode op, const unsigned char *buf, uint32 len)
: BasePacket(buf, len),
common/eq_packet.h
+5 -8
View File
@@ -15,18 +15,17 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef _EQPACKET_H
#define _EQPACKET_H
#include "base_packet.h"
#include "platform.h"
#include <iostream>
#pragma once
#include "common/base_packet.h"
#include "common/platform.h"
#ifdef STATIC_OPCODE
typedef unsigned short EmuOpcode;
static const EmuOpcode OP_Unknown = 0;
#else
#include "emu_opcodes.h"
#include "common/emu_opcodes.h"
#endif
class EQPacket : public BasePacket {
@@ -152,5 +151,3 @@ protected:
extern void DumpPacket(const EQApplicationPacket* app, bool iShowInfo = false);
extern std::string DumpPacketToString(const EQApplicationPacket* app);
#endif
common/eq_packet_structs.h
+13 -15
View File
@@ -16,20 +16,20 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef EQ_PACKET_STRUCTS_H
#define EQ_PACKET_STRUCTS_H
#pragma once
#include "common/emu_constants.h"
#include "common/textures.h"
#include "common/types.h"
#include "common/version.h"
#include "cereal/archives/binary.hpp"
#include "cereal/types/string.hpp"
#include "cereal/types/vector.hpp"
#include <list>
#include <string.h>
#include <cstring>
#include <string>
#include <time.h>
#include "../cereal/include/cereal/archives/binary.hpp"
#include "../cereal/include/cereal/types/string.hpp"
#include "../cereal/include/cereal/types/vector.hpp"
#include "../common/version.h"
#include "emu_constants.h"
#include "textures.h"
#include "types.h"
#include <ctime>
static const uint32 BUFF_COUNT = 42;
static const uint32 PET_BUFF_COUNT = 30;
@@ -45,6 +45,7 @@ static const uint32 ADVANCED_LORE_LENGTH = 8192;
** Compiler override to ensure
** byte aligned structures
*/
#pragma pack(push)
#pragma pack(1)
struct LoginInfo {
@@ -6562,7 +6563,4 @@ struct EvolveGetNextItem {
};
// Restore structure packing to default
#pragma pack()
#endif
#pragma pack(pop)
common/eq_stream.cpp
-1440
View File
File diff suppressed because it is too large Load Diff
common/eq_stream.h
-319
View File
@@ -1,319 +0,0 @@
#ifndef _EQSTREAM_H
#define _EQSTREAM_H
#include <vector>
#include <map>
#include <queue>
#include <deque>
#ifndef WIN32
#include <netinet/in.h>
#endif
#include "../common/misc.h"
#include "../common/opcodemgr.h"
#include "../common/timer.h"
#include "eq_packet.h"
#include "eq_stream_intf.h"
#include "eq_stream_type.h"
#include "mutex.h"
class EQApplicationPacket;
class EQProtocolPacket;
#define FLAG_COMPRESSED 0x01
#define FLAG_ENCODED 0x04
#ifndef RATEBASE
#define RATEBASE 1048576
#endif
#ifndef DECAYBASE
#define DECAYBASE 78642
#endif
#ifndef RETRANSMIT_TIMEOUT_MULT
#define RETRANSMIT_TIMEOUT_MULT 3.0
#endif
#ifndef RETRANSMIT_TIMEOUT_MAX
#define RETRANSMIT_TIMEOUT_MAX 5000
#endif
#ifndef AVERAGE_DELTA_MAX
#define AVERAGE_DELTA_MAX 2500
#endif
#ifndef RETRANSMIT_ACKED_PACKETS
#define RETRANSMIT_ACKED_PACKETS true
#endif
#ifndef MAX_SESSION_RETRIES
#define MAX_SESSION_RETRIES 30
#endif
#pragma pack(1)
struct SessionRequest {
uint32 UnknownA;
uint32 Session;
uint32 MaxLength;
};
struct SessionResponse {
uint32 Session;
uint32 Key;
uint8 UnknownA;
uint8 Format;
uint8 UnknownB;
uint32 MaxLength;
uint32 UnknownD;
};
//Deltas are in ms, representing round trip times
struct ClientSessionStats {
/*000*/ uint16 RequestID;
/*002*/ uint32 last_local_delta;
/*006*/ uint32 average_delta;
/*010*/ uint32 low_delta;
/*014*/ uint32 high_delta;
/*018*/ uint32 last_remote_delta;
/*022*/ uint64 packets_sent;
/*030*/ uint64 packets_received;
/*038*/
};
struct ServerSessionStats {
/*000*/ uint16 RequestID;
/*002*/ uint32 ServerTime;
/*006*/ uint64 packets_sent_echo;
/*014*/ uint64 packets_received_echo;
/*022*/ uint64 packets_sent;
/*030*/ uint64 packets_received;
/*038*/
};
#pragma pack()
class OpcodeManager;
class EQRawApplicationPacket;
class EQStream : public EQStreamInterface {
friend class EQStreamPair; //for collector.
protected:
typedef enum {
SeqPast,
SeqInOrder,
SeqFuture
} SeqOrder;
uint32 remote_ip;
uint16 remote_port;
uint8 buffer[8192];
unsigned char *oversize_buffer;
uint32 oversize_offset,oversize_length;
uint8 app_opcode_size;
EQStreamType StreamType;
bool compressed,encoded;
uint32 retransmittimer;
uint32 retransmittimeout;
uint16 sessionAttempts;
bool streamactive;
//uint32 buffer_len;
uint32 Session, Key;
uint16 NextInSeq;
uint32 MaxLen;
uint16 MaxSends;
uint8 active_users; //how many things are actively using this
Mutex MInUse;
EQStreamState State;
Mutex MState;
uint32 LastPacket;
Mutex MVarlock;
// Ack sequence tracking.
long NextAckToSend;
long LastAckSent;
long GetNextAckToSend();
long GetLastAckSent();
void AckPackets(uint16 seq);
void SetNextAckToSend(uint32);
void SetLastAckSent(uint32);
Mutex MAcks;
// Packets waiting to be sent (all protected by MOutboundQueue)
std::queue<EQProtocolPacket *> NonSequencedQueue;
std::deque<EQProtocolPacket *> SequencedQueue;
uint16 NextOutSeq;
uint16 SequencedBase; //the sequence number of SequencedQueue[0]
Mutex MOutboundQueue;
//a buffer we use for compression/decompression
unsigned char _tempBuffer[2048];
// Packets waiting to be processed
std::vector<EQRawApplicationPacket *> InboundQueue;
std::map<unsigned short,EQProtocolPacket *> PacketQueue; //not mutex protected, only accessed by caller of Process()
Mutex MInboundQueue;
static uint16 MaxWindowSize;
int32 BytesWritten;
uint64 sent_packet_count;
uint64 received_packet_count;
Mutex MRate;
int32 RateThreshold;
int32 DecayRate;
uint32 AverageDelta;
OpcodeManager **OpMgr;
EQRawApplicationPacket *MakeApplicationPacket(EQProtocolPacket *p);
EQRawApplicationPacket *MakeApplicationPacket(const unsigned char *buf, uint32 len);
EQProtocolPacket *MakeProtocolPacket(const unsigned char *buf, uint32 len);
void SendPacket(uint16 opcode, EQApplicationPacket *p);
void SetState(EQStreamState state);
void SendSessionResponse();
void SendSessionRequest();
void SendAck(uint16 seq);
void SendOutOfOrderAck(uint16 seq);
void QueuePacket(EQProtocolPacket *p);
void SendPacket(EQProtocolPacket *p);
void NonSequencedPush(EQProtocolPacket *p);
void SequencedPush(EQProtocolPacket *p);
void WritePacket(int fd,EQProtocolPacket *p);
uint32 GetKey() { return Key; }
void SetKey(uint32 k) { Key=k; }
void SetSession(uint32 s) { Session=s; }
void ProcessPacket(EQProtocolPacket *p);
bool Stale(uint32 now, uint32 timeout=30) { return (LastPacket && (now-LastPacket) > timeout); }
void InboundQueuePush(EQRawApplicationPacket *p);
EQRawApplicationPacket *PeekPacket(); //for collector.
EQRawApplicationPacket *PopRawPacket(); //for collector.
void InboundQueueClear();
void OutboundQueueClear();
void PacketQueueClear();
void ProcessQueue();
EQProtocolPacket *RemoveQueue(uint16 seq);
void _SendDisconnect();
void init(bool resetSession=true);
public:
EQStream() { init(); remote_ip = 0; remote_port = 0; State = UNESTABLISHED;
StreamType = UnknownStream; compressed = true; encoded = false; app_opcode_size = 2;
bytes_sent = 0; bytes_recv = 0; create_time = Timer::GetTimeSeconds(); sessionAttempts = 0;
streamactive = false; }
EQStream(sockaddr_in addr) { init(); remote_ip = addr.sin_addr.s_addr;
remote_port = addr.sin_port; State = UNESTABLISHED; StreamType = UnknownStream;
compressed = true; encoded = false; app_opcode_size = 2; bytes_sent = 0; bytes_recv = 0;
create_time = Timer::GetTimeSeconds(); }
virtual ~EQStream() { RemoveData(); SetState(CLOSED); }
void SetMaxLen(uint32 length) { MaxLen=length; }
//interface used by application (EQStreamInterface)
virtual void QueuePacket(const EQApplicationPacket *p, bool ack_req=true);
virtual void FastQueuePacket(EQApplicationPacket **p, bool ack_req=true);
virtual EQApplicationPacket *PopPacket();
virtual void Close();
virtual uint32 GetRemoteIP() const { return remote_ip; }
virtual uint16 GetRemotePort() const { return remote_port; }
virtual void ReleaseFromUse() { MInUse.lock(); if(active_users > 0) active_users--; MInUse.unlock(); }
virtual void RemoveData() { InboundQueueClear(); OutboundQueueClear(); PacketQueueClear(); /*if (CombinedAppPacket) delete CombinedAppPacket;*/ }
virtual bool CheckState(EQStreamState state) { return GetState() == state; }
virtual std::string Describe() const { return("Direct EQStream"); }
virtual void SetOpcodeManager(OpcodeManager **opm) { OpMgr = opm; }
virtual OpcodeManager* GetOpcodeManager() const
{
return (*OpMgr);
};
void CheckTimeout(uint32 now, uint32 timeout=30);
bool HasOutgoingData();
void Process(const unsigned char *data, const uint32 length);
void SetLastPacketTime(uint32 t) {LastPacket=t;}
void Write(int eq_fd);
// whether or not the stream has been assigned (we passed our stream match)
virtual void SetActive(bool val) { streamactive = val; }
//
inline bool IsInUse() { bool flag; MInUse.lock(); flag=(active_users>0); MInUse.unlock(); return flag; }
inline void PutInUse() { MInUse.lock(); active_users++; MInUse.unlock(); }
virtual EQStreamState GetState() { EQStreamState s; MState.lock(); s=State; MState.unlock(); return s; }
static SeqOrder CompareSequence(uint16 expected_seq , uint16 seq);
bool CheckActive() { return GetState()==ESTABLISHED; }
bool CheckClosed() { return GetState()==CLOSED; }
void SetOpcodeSize(uint8 s) { app_opcode_size = s; }
void SetStreamType(EQStreamType t);
inline const EQStreamType GetStreamType() const { return StreamType; }
static const char *StreamTypeString(EQStreamType t);
void Decay();
void AdjustRates(uint32 average_delta);
uint32 bytes_sent;
uint32 bytes_recv;
uint32 create_time;
void AddBytesSent(uint32 bytes)
{
bytes_sent += bytes;
++sent_packet_count;
}
void AddBytesRecv(uint32 bytes)
{
bytes_recv += bytes;
++received_packet_count;
}
virtual const uint32 GetBytesSent() const { return bytes_sent; }
virtual const uint32 GetBytesRecieved() const { return bytes_recv; }
virtual const uint32 GetBytesSentPerSecond() const
{
if((Timer::GetTimeSeconds() - create_time) == 0)
return 0;
return bytes_sent / (Timer::GetTimeSeconds() - create_time);
}
virtual const uint32 GetBytesRecvPerSecond() const
{
if((Timer::GetTimeSeconds() - create_time) == 0)
return 0;
return bytes_recv / (Timer::GetTimeSeconds() - create_time);
}
const uint64 GetPacketsSent() { return sent_packet_count; }
const uint64 GetPacketsReceived() { return received_packet_count; }
//used for dynamic stream identification
virtual MatchState CheckSignature(const Signature *sig);
};
#endif
common/eq_stream_factory.cpp
-299
View File
@@ -1,299 +0,0 @@
#include "global_define.h"
#include "eqemu_logsys.h"
#include "eq_stream_factory.h"
#ifdef _WINDOWS
#include <winsock2.h>
#include <process.h>
#include <io.h>
#include <stdio.h>
#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/select.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <pthread.h>
#endif
#include <iostream>
#include <fcntl.h>
#include "op_codes.h"
ThreadReturnType EQStreamFactoryReaderLoop(void *eqfs)
{
EQStreamFactory *fs=(EQStreamFactory *)eqfs;
fs->ReaderLoop();
THREAD_RETURN(nullptr);
}
ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
{
EQStreamFactory *fs=(EQStreamFactory *)eqfs;
fs->WriterLoop();
THREAD_RETURN(nullptr);
}
EQStreamFactory::EQStreamFactory(EQStreamType type, int port, uint32 timeout)
: Timeoutable(5000), stream_timeout(timeout)
{
StreamType=type;
Port=port;
sock=-1;
}
void EQStreamFactory::Close()
{
Stop();
#ifdef _WINDOWS
closesocket(sock);
#else
close(sock);
#endif
sock=-1;
}
bool EQStreamFactory::Open()
{
struct sockaddr_in address;
#ifndef WIN32
pthread_t t1,t2;
#endif
/* Setup internet address information.
This is used with the bind() call */
memset((char *) &address, 0, sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(Port);
address.sin_addr.s_addr = htonl(INADDR_ANY);
/* Setting up UDP port for new clients */
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
return false;
}
if (bind(sock, (struct sockaddr *) &address, sizeof(address)) < 0) {
close(sock);
sock=-1;
return false;
}
#ifdef _WINDOWS
unsigned long nonblock = 1;
ioctlsocket(sock, FIONBIO, &nonblock);
#else
fcntl(sock, F_SETFL, O_NONBLOCK);
#endif
//moved these because on windows the output was delayed and causing the console window to look bad
#ifdef _WINDOWS
_beginthread(EQStreamFactoryReaderLoop,0, this);
_beginthread(EQStreamFactoryWriterLoop,0, this);
#else
pthread_create(&t1,nullptr,EQStreamFactoryReaderLoop,this);
pthread_create(&t2,nullptr,EQStreamFactoryWriterLoop,this);
#endif
return true;
}
std::shared_ptr<EQStream> EQStreamFactory::Pop()
{
std::shared_ptr<EQStream> s = nullptr;
MNewStreams.lock();
if (!NewStreams.empty()) {
s = NewStreams.front();
NewStreams.pop();
s->PutInUse();
}
MNewStreams.unlock();
return s;
}
void EQStreamFactory::Push(std::shared_ptr<EQStream> s)
{
MNewStreams.lock();
NewStreams.push(s);
MNewStreams.unlock();
}
void EQStreamFactory::ReaderLoop()
{
fd_set readset;
std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
int num;
int length;
unsigned char buffer[2048];
sockaddr_in from;
int socklen = sizeof(sockaddr_in);
timeval sleep_time;
ReaderRunning = true;
while(sock!=-1) {
MReaderRunning.lock();
if (!ReaderRunning)
break;
MReaderRunning.unlock();
FD_ZERO(&readset);
FD_SET(sock,&readset);
sleep_time.tv_sec=30;
sleep_time.tv_usec=0;
if ((num=select(sock+1,&readset,nullptr,nullptr,&sleep_time))<0) {
// What do we wanna do?
continue;
} else if (num==0)
continue;
if(sock == -1)
break; //somebody closed us while we were sleeping.
if (FD_ISSET(sock,&readset)) {
#ifdef _WINDOWS
if ((length=recvfrom(sock,(char*)buffer,sizeof(buffer),0,(struct sockaddr*)&from,(int *)&socklen)) < 2)
#else
if ((length=recvfrom(sock,buffer,2048,0,(struct sockaddr *)&from,(socklen_t *)&socklen)) < 2)
#endif
{
// What do we wanna do?
} else {
MStreams.lock();
stream_itr = Streams.find(std::make_pair(from.sin_addr.s_addr, from.sin_port));
if (stream_itr == Streams.end()) {
if (buffer[1]==OP_SessionRequest) {
std::shared_ptr<EQStream> s = std::make_shared<EQStream>(from);
s->SetStreamType(StreamType);
Streams[std::make_pair(from.sin_addr.s_addr, from.sin_port)]=s;
WriterWork.Signal();
Push(s);
s->AddBytesRecv(length);
s->Process(buffer,length);
s->SetLastPacketTime(Timer::GetCurrentTime());
}
MStreams.unlock();
} else {
std::shared_ptr<EQStream> curstream = stream_itr->second;
//dont bother processing incoming packets for closed connections
if(curstream->CheckClosed())
curstream = nullptr;
else
curstream->PutInUse();
//the in use flag prevents the stream from being deleted while we are using it.
if(curstream) {
curstream->AddBytesRecv(length);
curstream->Process(buffer,length);
curstream->SetLastPacketTime(Timer::GetCurrentTime());
curstream->ReleaseFromUse();
}
MStreams.unlock();
}
}
}
}
}
void EQStreamFactory::CheckTimeout()
{
//lock streams the entire time were checking timeouts, it should be fast.
MStreams.lock();
unsigned long now=Timer::GetCurrentTime();
std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
for(stream_itr = Streams.begin(); stream_itr != Streams.end();) {
std::shared_ptr<EQStream> s = stream_itr->second;
s->CheckTimeout(now, stream_timeout);
EQStreamState state = s->GetState();
//not part of the else so we check it right away on state change
if (state==CLOSED) {
if (s->IsInUse()) {
//give it a little time for everybody to finish with it
} else {
//everybody is done, we can delete it now
auto temp = stream_itr;
++stream_itr;
temp->second = nullptr;
Streams.erase(temp);
continue;
}
}
++stream_itr;
}
MStreams.unlock();
}
void EQStreamFactory::WriterLoop()
{
bool havework = true;
std::vector<std::shared_ptr<EQStream>> wants_write;
std::vector<std::shared_ptr<EQStream>>::iterator cur, end;
bool decay = false;
uint32 stream_count;
Timer DecayTimer(20);
WriterRunning = true;
DecayTimer.Enable();
while (sock != -1) {
MWriterRunning.lock();
if (!WriterRunning)
break;
MWriterRunning.unlock();
havework = false;
wants_write.clear();
decay = DecayTimer.Check();
// copy streams into a seperate list so we dont have to keep
// MStreams locked while we are writting
MStreams.lock();
for (auto stream_itr = Streams.begin(); stream_itr != Streams.end(); ++stream_itr) {
// If it's time to decay the bytes sent, then let's do it before we try to write
if (decay)
stream_itr->second->Decay();
// bullshit checking, to see if this is really happening, GDB seems to think so...
if (stream_itr->second == nullptr) {
fprintf(stderr,
"ERROR: nullptr Stream encountered in EQStreamFactory::WriterLoop for: %i:%i",
stream_itr->first.first, stream_itr->first.second);
continue;
}
if (stream_itr->second->HasOutgoingData()) {
havework = true;
stream_itr->second->PutInUse();
wants_write.push_back(stream_itr->second);
}
}
MStreams.unlock();
// do the actual writes
cur = wants_write.begin();
end = wants_write.end();
for (; cur != end; ++cur) {
(*cur)->Write(sock);
(*cur)->ReleaseFromUse();
}
Sleep(10);
MStreams.lock();
stream_count = Streams.size();
MStreams.unlock();
if (!stream_count) {
WriterWork.Wait();
}
}
}
common/eq_stream_factory.h
-61
View File
@@ -1,61 +0,0 @@
#ifndef _EQSTREAMFACTORY_H
#define _EQSTREAMFACTORY_H
#include <memory>
#include <queue>
#include <map>
#include "../common/eq_stream.h"
#include "../common/condition.h"
#include "../common/timeoutmgr.h"
class EQStream;
class Timer;
class EQStreamFactory : private Timeoutable {
private:
int sock;
int Port;
bool ReaderRunning;
Mutex MReaderRunning;
bool WriterRunning;
Mutex MWriterRunning;
Condition WriterWork;
EQStreamType StreamType;
std::queue<std::shared_ptr<EQStream>> NewStreams;
Mutex MNewStreams;
std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>> Streams;
Mutex MStreams;
virtual void CheckTimeout();
Timer *DecayTimer;
uint32 stream_timeout;
public:
EQStreamFactory(EQStreamType type, uint32 timeout = 135000) : Timeoutable(5000), stream_timeout(timeout) { ReaderRunning=false; WriterRunning=false; StreamType=type; sock=-1; }
EQStreamFactory(EQStreamType type, int port, uint32 timeout = 135000);
std::shared_ptr<EQStream> Pop();
void Push(std::shared_ptr<EQStream> s);
bool Open();
bool Open(unsigned long port) { Port=port; return Open(); }
bool IsOpen() { return sock!=-1; }
void Close();
void ReaderLoop();
void WriterLoop();
void Stop() { StopReader(); StopWriter(); }
void StopReader() { MReaderRunning.lock(); ReaderRunning=false; MReaderRunning.unlock(); }
void StopWriter() { MWriterRunning.lock(); WriterRunning=false; MWriterRunning.unlock(); WriterWork.Signal(); }
void SignalWriter() { WriterWork.Signal(); }
};
#endif
common/eq_stream_ident.cpp
+6 -7
View File
@@ -1,10 +1,10 @@
#include <utility>
#include "global_define.h"
#include "eqemu_logsys.h"
#include "eq_stream_ident.h"
#include "eq_stream_proxy.h"
#include "misc.h"
#include "common/eq_stream_ident.h"
#include "common/eq_stream_proxy.h"
#include "common/eqemu_logsys.h"
#include "common/misc.h"
#include <utility>
EQStreamIdentifier::~EQStreamIdentifier() {
while(!m_identified.empty()) {
@@ -162,4 +162,3 @@ EQStreamIdentifier::Record::Record(std::shared_ptr<EQStreamInterface> s)
expire(STREAM_IDENT_WAIT_MS)
{
}
common/eq_stream_ident.h
+6 -8
View File
@@ -1,11 +1,11 @@
#ifndef EQSTREAMIDENT_H_
#define EQSTREAMIDENT_H_
#pragma once
#include "common/eq_stream_intf.h"
#include "common/timer.h"
#include "eq_stream_intf.h"
#include "timer.h"
#include <vector>
#include <queue>
#include <memory>
#include <queue>
#include <vector>
#define STREAM_IDENT_WAIT_MS 30000
@@ -47,5 +47,3 @@ protected:
std::vector<Record> m_streams; //we own these objects, and the streams contained in them.
std::queue<EQStreamInterface *> m_identified; //we own these objects
};
#endif /*EQSTREAMIDENT_H_*/
common/eq_stream_intf.h
+7 -8
View File
@@ -1,12 +1,13 @@
#ifndef EQSTREAMINTF_H_
#define EQSTREAMINTF_H_
#pragma once
#include "common/emu_versions.h"
#include "common/eq_packet.h"
#include "common/net/reliable_stream_connection.h"
#include <string>
//this is the only part of an EQStream that is seen by the application.
#include <string>
#include "emu_versions.h"
#include "eq_packet.h"
#include "net/reliable_stream_connection.h"
typedef enum {
ESTABLISHED,
@@ -106,5 +107,3 @@ public:
virtual void ResetStats() = 0;
virtual EQStreamManagerInterface* GetManager() const = 0;
};
#endif /*EQSTREAMINTF_H_*/
common/eq_stream_locator.h
+7 -7
View File
@@ -15,16 +15,18 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef _EQSTREAM_LOCATOR_H
#define _EQSTREAM_LOCATOR_H
#pragma once
#include "common/types.h"
#include <map>
#include <string>
/*
This did not turn out nearly as nice as I hoped.
*/
#include <map>
#include <string>
class EQStreamInfo {
public:
EQStreamInfo() {}
@@ -168,5 +170,3 @@ public:
protected:
std::map<const EQStreamInfo, T *> streams;
};
#endif
common/eq_stream_proxy.cpp
+4 -4
View File
@@ -1,9 +1,9 @@
#include "global_define.h"
#include "eq_stream_proxy.h"
#include "struct_strategy.h"
#include "eqemu_logsys.h"
#include "opcodemgr.h"
#include "common/eqemu_logsys.h"
#include "common/opcodemgr.h"
#include "common/struct_strategy.h"
EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStreamInterface> &stream, const StructStrategy *structs, OpcodeManager **opcodes)
common/eq_stream_proxy.h
+3 -7
View File
@@ -1,9 +1,8 @@
#ifndef EQSTREAMPROXY_H_
#define EQSTREAMPROXY_H_
#pragma once
#include "common/eq_stream_intf.h"
#include "common/types.h"
#include "types.h"
#include "eq_stream_intf.h"
#include <memory>
class StructStrategy;
@@ -44,6 +43,3 @@ protected:
OpcodeManager **const m_opcodes;
//we do not own this object.
};
#endif /*EQSTREAMPROXY_H_*/
common/eq_stream_type.h
-15
View File
@@ -1,15 +0,0 @@
#ifndef _EQSTREAMTYPE_H
#define _EQSTREAMTYPE_H
typedef enum {
UnknownStream=0,
LoginStream,
WorldStream,
ZoneStream,
ChatOrMailStream,
ChatStream,
MailStream
} EQStreamType;
#endif
common/eqdb.cpp
+5 -3
View File
@@ -15,10 +15,12 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "global_define.h"
#include "eqdb.h"
#include "database.h"
#include <mysql.h>
#include "common/database.h"
#include "mysql.h"
#include <cstring>
EQDB EQDB::s_EQDB;

Some files were not shown because too many files have changed in this diff Show More