GitHub/amxmodx
2
0
Fork 0
mirror of https://github.com/alliedmodders/amxmodx.git synced 2024-12-24 13:55:36 +03:00
Code Issues Projects Releases Wiki Activity

Dear me, many changes

Browse Source 
Rewrote Lang (still does not work though!)
New String class funcs+name
Added Queue class
Added MD5 class + functions
This commit is contained in:
David Anderson 2004-08-15 10:53:48 +00:00
parent 76684e68c2
commit 3bbfca6d08
23 changed files with 1547 additions and 541 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
amxmodx/CCmd.h
View File

@ -52,10 +52,10 @@ public:
friend class CmdMngr;
CPluginMngr::CPlugin* plugin;
CmdMngr* parent;
CString command;
CString argument;
CString commandline;
CString info;
String command;
String argument;
String commandline;
String info;
bool listable;
int function;
int flags;
@ -100,7 +100,7 @@ private:
CmdLink* clcmdlist;
struct CmdPrefix {
CString name;
String name;
CmdMngr* parent;
CmdLink* list;
CmdPrefix* next;

2
amxmodx/CEvent.h
View File

@ -88,7 +88,7 @@ public:
{
int paramId; // the message parameter id
CString sValue; // value (string)
String sValue; // value (string)
float fValue; // value (float)
int iValue; // value (int)
int type; // type (can be int, float, string)

4
amxmodx/CFile.cpp
View File

@ -52,7 +52,7 @@ File::operator bool ( ) const
return fp && !feof(fp);
}
File& operator<<( File& f, const CString& n )
File& operator<<( File& f, const String& n )
{
if ( f ) fputs( n.c_str() , f.fp ) ;
return f;
@ -77,7 +77,7 @@ File& operator<<( File& f, const char& c )
return f;
}
File& operator>>( File& f, CString& n )
File& operator>>( File& f, String& n )
{
if ( !f ) return f;
char temp[1024];

6
amxmodx/CFile.h
View File

@ -30,7 +30,7 @@
*/
#include <stdio.h>
#include "CString.h"
#include "String.h"
// *****************************************************
// class File
@ -44,11 +44,11 @@ public:
File( const char* n, const char* m );
~File( );
operator bool ( ) const;
friend File& operator<<( File& f, const CString& n );
friend File& operator<<( File& f, const String& n );
friend File& operator<<( File& f, const char* n );
friend File& operator<<( File& f, const char& c );
friend File& operator<<( File& f, int n );
friend File& operator>>( File& f, CString& n );
friend File& operator>>( File& f, String& n );
friend File& operator>>( File& f, char* n );
int getline( char* buf, int sz );
File& skipWs( );

879
amxmodx/CLang.cpp
View File

File diff suppressed because it is too large Load Diff

77
amxmodx/CLang.h
View File

@ -35,14 +35,28 @@
#define LANG_SERVER 0
#define LANG_PLAYER -1
struct md5Pair
{
String file;
String val;
};
struct keyEntry
{
String key;
uint32_t hash;
};
struct sKeyDef
{
sKeyDef() { key = -1; def = 0; }
~sKeyDef() { if (def) delete def; }
int key;
String *def;
};
class CLangMngr
{
struct sKeyDef
{
const char *key;
const char *def;
};
class CLang
{
public:
@ -51,7 +65,7 @@ class CLangMngr
~CLang();
const char *GetDef(const char *key);
void MergeDefinitions(CVector<sKeyDef> & vec);
void MergeDefinitions(CQueue <sKeyDef*> & vec);
void Clear();
friend bool operator == (const CLang &left, const char *right)
@ -59,9 +73,9 @@ class CLangMngr
return strcmp(left.m_LanguageName, right)==0 ? true : false;
}
const char *GetName() { return m_LanguageName; }
void Dump();
bool Save(FILE *fp);
bool Load(FILE *fp);
void SetMngr(CLangMngr *l) { lman = l; }
private:
static uint32_t MakeHash(const char *src, bool makeLower = false);
@ -69,56 +83,62 @@ class CLangMngr
class LangEntry
{
uint32_t m_DefHash;
uint32_t m_KeyHash;
char *m_pKey;
char *m_pDef;
void SetKey(const char *pKey);
void SetDef(const char *pDef);
int key;
String m_pDef;
public:
void SetKey(int key);
void SetDef(const char *pDef);
uint32_t GetDefHash();
uint32_t GetKeyHash();
const char *GetKey();
int GetKey();
const char *GetDef();
LangEntry();
LangEntry(const char *pKey);
LangEntry(const char *pKey, const char *pDef);
LangEntry(int key);
LangEntry(int key, const char *pDef);
LangEntry(const LangEntry &other);
void operator= (const char *pNewDef);
bool operator== (uint32_t hash);
void Clear();
};
LangEntry & GetEntry(const char *key);
typedef CVector<LangEntry> LookUpVec;
LangEntry * GetEntry(int key);
typedef CVector<LangEntry*> LookUpVec;
typedef LookUpVec::iterator LookUpVecIter;
char m_LanguageName[3];
LookUpVec m_LookUpTable;
CLangMngr *lman;
};
void MergeDefinitions(const char *lang, CVector<sKeyDef> &tmpVec);
void MergeDefinitions(const char *lang, CQueue <sKeyDef*> &tmpVec);
static size_t strip(char *str, char *newstr, bool makelower=false);
typedef CVector<CLang> LangVec;
typedef LangVec::iterator LangVecIter;
typedef CVector<CLang*> LangVec;
typedef CVector<CLang*>::iterator LangVecIter;
LangVec m_Languages;
CVector<md5Pair *> FileList;
CVector<keyEntry*> KeyList;
CLang & GetLang(const char *name);
CLang * GetLang(const char *name);
int m_CurGlobId;
public:
int MergeDefinitionFile(const char *file);
void Dump();
const char *GetDef(const char *langName, const char *key);
const char *Format(const char *src, ...);
char *FormatAmxString(AMX *amx, cell *params, int parm, int &len);
bool Save(const char *filename);
bool Load(const char *filename);
bool LoadCache(const char *filename);
bool SaveCache(const char *filename);
int GetKeyEntry(String &key);
int GetKeyEntry(const char *key);
int GetKeyHash(int key);
const char *GetKey(int key);
int AddKeyEntry(String &key);
uint32_t MakeHash(const char *src, bool makeLower);
int GetLangsNum();
const char *GetLangName(int langId);
@ -127,6 +147,9 @@ public:
// When a language id in a format string in FormatAmxString is 0, the glob id decides which language to take.
void SetDefLang(int id);
void Clear();
CLangMngr();
~CLangMngr();
};
#endif //_INCLUDE_CLANG_H

2
amxmodx/CLogEvent.h
View File

@ -63,7 +63,7 @@ public:
friend class LogEventsMngr;
friend class CLogEvent;
LogEventsMngr* parent;
CString text;
String text;
int logid;
int pos;
int result;

2
amxmodx/CMenu.h
View File

@ -40,7 +40,7 @@ class MenuMngr
{
struct MenuIdEle
{
CString name;
String name;
AMX* amx;
MenuIdEle* next;
int id;

18
amxmodx/CMisc.h
View File

@ -40,8 +40,8 @@
class CCVar
{
cvar_t cvar;
CString name;
CString plugin;
String name;
String plugin;
public:
CCVar( const char* pname, const char* pplugin,
int pflags, float pvalue ) : name(pname) , plugin(pplugin ) {
@ -68,9 +68,9 @@ class CPlayer
public:
edict_t* pEdict;
CString name;
CString ip;
CString team;
String name;
String ip;
String team;
bool initialized;
bool ingame;
@ -98,7 +98,7 @@ public:
int death_killer;
int death_victim;
bool death_tk;
CString death_weapon;
String death_weapon;
Vector lastTrace;
Vector thisTrace;
@ -149,7 +149,7 @@ public:
// class ForceObject
// *****************************************************
class ForceObject {
CString filename;
String filename;
FORCE_TYPE type;
Vector mins;
Vector maxs;
@ -203,7 +203,7 @@ public:
// *****************************************************
class CScript
{
CString filename;
String filename;
AMX* amx;
void* code;
public:
@ -220,7 +220,7 @@ public:
class TeamIds
{
struct TeamEle {
CString name;
String name;
int id;
char tid;
static char uid;

2
amxmodx/CModule.h
View File

@ -69,7 +69,7 @@ struct amxx_module_info_s
class CModule
{
CString m_Filename; // Filename
String m_Filename; // Filename
bool m_Metamod; // Using metamod?
bool m_Amxx; // Using new module interface?
module_info_s* m_InfoOld; // module info (old module interface)

8
amxmodx/CPlugin.h
View File

@ -59,10 +59,10 @@ public:
AMX amx;
void* code;
CString name;
CString version;
CString title;
CString author;
String name;
String version;
String title;
String author;
int paused_fun;
int status;
CPlugin* next;

125
amxmodx/CQueue.h Executable file
View File

@ -0,0 +1,125 @@
/* AMX Mod X
*
* by the AMX Mod X Development Team
* originally developed by OLO
*
*
* 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
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*/
//by David "BAILOPAN" Anderson
#ifndef _INCLUDE_CQUEUE_H
#define _INCLUDE_CQUEUE_H
template <class T>
class CQueue
{
public:
class CQueueItem
{
public:
CQueueItem(const T &i, CQueueItem *n)
{
item = i;
next = n;
}
CQueueItem *GetNext()
{
return next;
}
T & GetItem()
{
return item;
}
void SetNext(CQueueItem *n)
{
next = n;
}
private:
T item;
CQueueItem *next;
};
public:
CQueue()
{
mSize = 0;
mFirst = NULL;
mLast = NULL;
}
bool empty()
{
return ((mSize==0)?true:false);
}
void push(const T &v)
{
CQueueItem *p = new CQueueItem(v, NULL);
if (empty())
{
mFirst = p;
} else {
mLast->SetNext(p);
}
mLast = p;
mSize++;
}
void pop()
{
if (mFirst == mLast)
{
delete mFirst;
mFirst = NULL;
mLast = NULL;
} else {
CQueueItem *p = mFirst->GetNext();
delete mFirst;
mFirst = p;
}
mSize--;
}
T & front()
{
return mFirst->GetItem();
}
T & back()
{
return mLast->GetItem();
}
unsigned int size()
{
return mSize;
}
private:
CQueueItem *mFirst;
CQueueItem *mLast;
unsigned int mSize;
};
#endif //_INCLUDE_CQUEUE_H

281
amxmodx/CString.h
View File

@ -33,30 +33,67 @@
#define _INCLUDE_CSTRING_H
//by David "BAILOPAN" Anderson
class CString
class String
{
public:
CString() { v = NULL; mSize = 0; }
~CString() { if (v) delete [] v; }
String()
{
v = NULL;
mSize = 0;
cSize = 0;
Grow(2);
assign("");
}
//added these for amxx
CString(const char *src) { v = NULL; mSize = 0; assign(src); }
CString(CString &src) { v = NULL; mSize = 0; assign(src.c_str()); }
~String()
{
if (v)
delete [] v;
}
String(const char *src)
{
v = NULL;
mSize = 0;
cSize = 0; assign(src);
}
String(String &src)
{
v = NULL;
mSize = 0;
cSize = 0;
assign(src.c_str());
}
const char *c_str() { return v?v:""; }
const char *c_str() const { return v?v:""; }
void append(const char *t)
{
Grow(strlen(v) + strlen(t));
Grow(cSize + strlen(t));
strcat(v, t);
cSize = strlen(v);
}
void append(CString &d)
void append(const char c)
{
Grow(cSize + 2);
v[cSize] = c;
v[++cSize] = 0;
}
void append(String &d)
{
const char *t = d.c_str();
Grow(strlen(v) + strlen(t));
Grow(cSize + strlen(t));
strcat(v, t);
cSize = strlen(v);
}
void assign(const String &src)
{
assign(src.c_str());
}
void assign(const char *d)
@ -64,20 +101,27 @@ public:
if (!d)
{
Grow(1);
cSize = 0;
strcpy(v, "");
return;
}
Grow(strlen(d));
if (v)
{
strcpy(v, d);
cSize = strlen(v);
} else {
cSize = 0;
}
}
void clear()
{
if (v)
delete [] v;
v = NULL;
mSize = 0;
{
v[0] = 0;
cSize = 0;
}
}
int compare (const char *d)
@ -100,7 +144,7 @@ public:
//Added this for amxx inclusion
bool empty()
{
if (!v || !mSize)
if (!v || !cSize)
return true;
return false;
@ -110,20 +154,218 @@ public:
{
if (!v)
return 0;
return strlen(v);
return cSize;
}
const char * _fread(FILE *fp)
{
Grow(512);
char * ret = fgets(v, 511, fp);
cSize = strlen(v);
return ret;
}
int find(const char c, int index = 0)
{
if (!v)
return npos;
unsigned int i = 0;
for (i=index; i<cSize; i++)
{
if (v[i] == c)
{
return i;
}
}
return npos;
}
bool is_space(int c)
{
if (c == '\f' || c == '\n' ||
c == '\t' || c == '\r' ||
c == 'v' || c == ' ')
{
return true;
}
return false;
}
void trim()
{
if (!v)
return;
unsigned int i = 0;
unsigned int j = 0;
if (cSize == 1)
{
if (is_space(v[i]))
{
clear();
return;
}
}
unsigned char c0 = v[0];
if (is_space(c0))
{
for (i=0; i<cSize; i++)
{
if (!is_space(v[i]) || (is_space(v[i]) && ((unsigned char)i==cSize-1)))
{
erase(0, i);
break;
}
}
}
cSize = strlen(v);
if (cSize < 1)
{
return;
}
if (is_space(v[cSize-1]))
{
for (i=cSize-1; i>=0; i--)
{
if (!is_space(v[i])
|| (is_space(v[i]) && i==0))
{
erase(i+1, j);
break;
}
j++;
}
}
if (cSize == 1)
{
if (is_space(v[0]))
{
clear();
return;
}
}
}
String & erase(unsigned int start, int num = npos)
{
if (!v)
return (*this);
unsigned int i = 0;
//check for bounds
if (num == npos || start+num > cSize-num+1)
num = cSize - start;
//do the erasing
bool copyflag = false;
for (i=0; i<cSize; i++)
{
if (i>=start && i<start+num)
{
if (i+num < cSize)
{
v[i] = v[i+num];
} else {
v[i] = 0;
}
copyflag = true;
} else if (copyflag) {
if (i+num < cSize)
{
v[i] = v[i+num];
} else {
v[i] = 0;
}
}
}
v[i] = 0;
cSize -= num;
return (*this);
}
String substr(unsigned int index, int num = npos)
{
unsigned int rnum = (unsigned int)((num<0)?(cSize):(num));
String ns;
if (index >= cSize || !v)
return ns;
if (index+rnum >= cSize)
{
rnum = cSize - index+1;
}
unsigned int i = 0, j=0;
char *s = new char[cSize+1];
for (i=index; i<index+rnum; i++)
{
s[j++] = v[i];
}
s[j] = 0;
ns.assign(s);
delete [] s;
return ns;
}
void toLower()
{
if (!v)
return;
unsigned int i = 0;
for (i=0; i<cSize; i++)
{
if (v[i] >= 65 && v[i] <= 90)
v[i] |= 32;
}
}
String & operator = (const String &src)
{
assign(src);
return *this;
}
String & operator = (const char *src)
{
assign(src);
return *this;
}
char operator [] (unsigned int index)
{
if (index > cSize)
{
return -1;
} else {
return v[index];
}
}
private:
void Grow(int d)
void Grow(unsigned int d)
{
if (d<1)
return;
if (d > mSize)
{
mSize = d + 16; // allocate a buffer
char *t = new char[d+1];
if (v) {
strcpy(t, v);
t[strlen(v)] = 0;
t[cSize] = 0;
delete [] v;
}
v = t;
@ -132,7 +374,10 @@ private:
}
char *v;
int mSize;
unsigned int mSize;
unsigned int cSize;
public:
static const int npos = -1;
};
#endif //_INCLUDE_CSTRING_H
#endif //_INCLUDE_CSTRING_H

12
amxmodx/CVault.h
View File

@ -32,7 +32,7 @@
#ifndef VAULT_CUSTOM_H
#define VAULT_CUSTOM_H
#include "CString.h"
#include "String.h"
#include "CList.h"
// *****************************************************
@ -43,14 +43,14 @@ class Vault
{
struct Obj
{
CString key;
CString value;
String key;
String value;
int number;
Obj *next;
Obj( const char* k, const char* v);
} *head;
CString path;
String path;
Obj** find( const char* n );
@ -79,8 +79,8 @@ public:
iterator& operator++() { if ( a ) a = a->next; return *this; }
bool operator==(const iterator& b) const { return a == b.a; }
bool operator!=(const iterator& b) const { return !operator==(b); }
CString& key() const { return a->key; }
CString& value() const { return a->value; }
String& key() const { return a->key; }
String& value() const { return a->value; }
};
inline iterator begin() const { return iterator(head); }

37
amxmodx/amxmodx.cpp
View File

@ -796,6 +796,41 @@ static cell AMX_NATIVE_CALL get_plugin(AMX *amx, cell *params) /* 11 param */
return -1;
}
static cell AMX_NATIVE_CALL amx_md5(AMX *amx, cell *params)
{
int len = 0;
char *str = get_amxstring(amx, params[1], 0, len);
char buffer[33];
MD5 md5;
md5.update((unsigned char *)str, len);
md5.finalize();
md5.hex_digest(buffer);
return set_amxstring(amx, params[2], buffer, 32);
}
static cell AMX_NATIVE_CALL amx_md5_file(AMX *amx, cell *params)
{
int len = 0;
char *str = get_amxstring(amx, params[1], 0, len);
char buffer[33];
FILE *fp = fopen(str, "rb");
if (!fp)
{
amx_RaiseError(amx, AMX_ERR_NATIVE);
return 0;
}
MD5 md5;
md5.update(fp); //closes for you
md5.finalize();
md5.hex_digest(buffer);
return set_amxstring(amx, params[2], buffer, 32);
}
static cell AMX_NATIVE_CALL get_pluginsnum(AMX *amx, cell *params)
{
return g_plugins.getPluginsNum();
@ -2749,5 +2784,7 @@ AMX_NATIVE_INFO amxmod_Natives[] = {
{ "get_lang", get_lang },
{ "register_dictionary", register_dictionary },
{ "lang_exists", lang_exists },
{ "md5", amx_md5 },
{ "md5_file", amx_md5_file },
{ NULL, NULL }
};

8
amxmodx/amxmodx.h
View File

@ -41,8 +41,10 @@
#include "mmgr/mmgr.h"
#endif
#include "md5.h"
#include "CVector.h"
#include "CList.h"
#include "CQueue.h"
#include "modules.h"
#include "CString.h"
#include "CPlugin.h"
@ -115,7 +117,7 @@ void UTIL_ShowMenu( edict_t* pEntity, int slots, int time, char *menu, int mlen
#define GET_PLAYER_POINTER_I(i) (&g_players[i])
struct WeaponsVault {
CString fullName;
String fullName;
short int iId;
short int ammoSlot;
};
@ -145,8 +147,8 @@ extern Grenades g_grenades;
extern LogEventsMngr g_logevents;
extern MenuMngr g_menucmds;
extern CLangMngr g_langMngr;
extern CString g_log_dir;
extern CString g_mod_name;
extern String g_log_dir;
extern String g_mod_name;
extern TeamIds g_teamsIds;
extern Vault g_vault;
extern CForwardMngr g_forwards;

2
amxmodx/amxxlog.cpp
View File

@ -106,7 +106,7 @@ void CLog::CreateNewFile()
fclose(fp);
}
void CLog::UseFile(const CString &fileName)
void CLog::UseFile(const String &fileName)
{
m_LogFile.assign(build_pathname("%s/%s", g_log_dir.c_str(), fileName.c_str()));
}

6
amxmodx/amxxlog.h
View File

@ -34,11 +34,11 @@
class CLog
{
private:
CString m_LogFile;
String m_LogFile;
int m_LogType;
void GetLastFile(int &outMonth, int &outDay, CString &outFilename);
void UseFile(const CString &fileName);
void GetLastFile(int &outMonth, int &outDay, String &outFilename);
void UseFile(const String &fileName);
public:
CLog();
~CLog();

2
amxmodx/fakemeta.h
View File

@ -74,7 +74,7 @@ public:
{
private:
// plugin info
CString m_Path;
String m_Path;
PLUG_STATUS m_Status;
plugin_info_t *m_Info;
// Function tables

474
amxmodx/md5.cpp Executable file
View File

@ -0,0 +1,474 @@
// MD5.CC - source code for the C++/object oriented translation and
// modification of MD5.
// Translation and modification (c) 1995 by Mordechai T. Abzug
// This translation/ modification is provided "as is," without express or
// implied warranty of any kind.
// The translator/ modifier does not claim (1) that MD5 will do what you think
// it does; (2) that this translation/ modification is accurate; or (3) that
// this software is "merchantible." (Language for this disclaimer partially
// copied from the disclaimer below).
/* based on:
MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
MDDRIVER.C - test driver for MD2, MD4 and MD5
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
*/
#include "md5.h"
#include <assert.h>
#include <string.h>
// MD5 simple initialization method
MD5::MD5(){
init();
}
// MD5 block update operation. Continues an MD5 message-digest
// operation, processing another message block, and updating the
// context.
void MD5::update (uint1 *input, uint4 input_length) {
uint4 input_index, buffer_index;
uint4 buffer_space; // how much space is left in buffer
if (finalized){ // so we can't update!
/*cerr << "MD5::update: Can't update a finalized digest!" << endl;*/
return;
}
// Compute number of bytes mod 64
buffer_index = (unsigned int)((count[0] >> 3) & 0x3F);
// Update number of bits
if ( (count[0] += ((uint4) input_length << 3))<((uint4) input_length << 3) )
count[1]++;
count[1] += ((uint4)input_length >> 29);
buffer_space = 64 - buffer_index; // how much space is left in buffer
// Transform as many times as possible.
if (input_length >= buffer_space) { // ie. we have enough to fill the buffer
// fill the rest of the buffer and transform
memcpy (buffer + buffer_index, input, buffer_space);
transform (buffer);
// now, transform each 64-byte piece of the input, bypassing the buffer
for (input_index = buffer_space; input_index + 63 < input_length;
input_index += 64)
transform (input+input_index);
buffer_index = 0; // so we can buffer remaining
}
else
input_index=0; // so we can buffer the whole input
// and here we do the buffering:
memcpy(buffer+buffer_index, input+input_index, input_length-input_index);
}
// MD5 update for files.
// Like above, except that it works on files (and uses above as a primitive.)
void MD5::update(FILE *file){
unsigned char buffer[1024];
int len;
while (len=fread(buffer, 1, 1024, file))
update(buffer, len);
fclose (file);
}
// MD5 finalization. Ends an MD5 message-digest operation, writing the
// the message digest and zeroizing the context.
void MD5::finalize (){
unsigned char bits[8];
unsigned int index, padLen;
static uint1 PADDING[64]={
0x80, 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, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
if (finalized){
/* cerr << "MD5::finalize: Already finalized this digest!" << endl;*/
return;
}
// Save number of bits
encode (bits, count, 8);
// Pad out to 56 mod 64.
index = (uint4) ((count[0] >> 3) & 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
update (PADDING, padLen);
// Append length (before padding)
update (bits, 8);
// Store state in digest
encode (digest, state, 16);
// Zeroize sensitive information
memset (buffer, 0, sizeof(*buffer));
finalized=1;
}
MD5::MD5(FILE *file){
init(); // must be called be all constructors
update(file);
finalize ();
}
unsigned char *MD5::raw_digest(){
uint1 *s = new uint1[16];
if (!finalized){
/* cerr << "MD5::raw_digest: Can't get digest if you haven't "<<
"finalized the digest!" <<endl;*/
return ( (unsigned char*) "");
}
memcpy(s, digest, 16);
return s;
}
char *MD5::hex_digest(){
int i;
char *s= new char[33];
if (!finalized){
/* cerr << "MD5::hex_digest: Can't get digest if you haven't "<<
"finalized the digest!" <<endl;*/
return "";
}
for (i=0; i<16; i++)
sprintf(s+i*2, "%02x", digest[i]);
s[32]='\0';
return s;
}
char *MD5::hex_digest(char buffer[33]){
int i;
if (!finalized)
{
/* cerr << "MD5::hex_digest: Can't get digest if you haven't "<<
"finalized the digest!" <<endl;*/
return "";
}
for (i=0; i<16; i++)
sprintf(buffer+i*2, "%02x", digest[i]);
buffer[32]='\0';
return buffer;
}
// PRIVATE METHODS:
void MD5::init(){
finalized=0; // we just started!
// Nothing counted, so count=0
count[0] = 0;
count[1] = 0;
// Load magic initialization constants.
state[0] = 0x67452301;
state[1] = 0xefcdab89;
state[2] = 0x98badcfe;
state[3] = 0x10325476;
}
// Constants for MD5Transform routine.
// Although we could use C++ style constants, defines are actually better,
// since they let us easily evade scope clashes.
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
// MD5 basic transformation. Transforms state based on block.
void MD5::transform (uint1 block[64]){
uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
decode (x, block, 64);
assert(!finalized); // not just a user error, since the method is private
/* Round 1 */
FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
/* Round 2 */
GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
/* Round 3 */
HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
/* Round 4 */
II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
// Zeroize sensitive information.
memset ( (uint1 *) x, 0, sizeof(x));
}
// Encodes input (UINT4) into output (unsigned char). Assumes len is
// a multiple of 4.
void MD5::encode (uint1 *output, uint4 *input, uint4 len) {
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4) {
output[j] = (uint1) (input[i] & 0xff);
output[j+1] = (uint1) ((input[i] >> 8) & 0xff);
output[j+2] = (uint1) ((input[i] >> 16) & 0xff);
output[j+3] = (uint1) ((input[i] >> 24) & 0xff);
}
}
// Decodes input (unsigned char) into output (UINT4). Assumes len is
// a multiple of 4.
void MD5::decode (uint4 *output, uint1 *input, uint4 len){
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
(((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
}
// Note: Replace "for loop" with standard memcpy if possible.
void MD5::memcpy (uint1 *output, uint1 *input, uint4 len){
unsigned int i;
for (i = 0; i < len; i++)
output[i] = input[i];
}
// Note: Replace "for loop" with standard memset if possible.
void MD5::memset (uint1 *output, uint1 value, uint4 len){
unsigned int i;
for (i = 0; i < len; i++)
output[i] = value;
}
// ROTATE_LEFT rotates x left n bits.
inline unsigned int MD5::rotate_left (uint4 x, uint4 n){
return (x << n) | (x >> (32-n)) ;
}
// F, G, H and I are basic MD5 functions.
inline unsigned int MD5::F (uint4 x, uint4 y, uint4 z){
return (x & y) | (~x & z);
}
inline unsigned int MD5::G (uint4 x, uint4 y, uint4 z){
return (x & z) | (y & ~z);
}
inline unsigned int MD5::H (uint4 x, uint4 y, uint4 z){
return x ^ y ^ z;
}
inline unsigned int MD5::I (uint4 x, uint4 y, uint4 z){
return y ^ (x | ~z);
}
// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
// Rotation is separate from addition to prevent recomputation.
inline void MD5::FF(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac){
a += F(b, c, d) + x + ac;
a = rotate_left (a, s) +b;
}
inline void MD5::GG(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac){
a += G(b, c, d) + x + ac;
a = rotate_left (a, s) +b;
}
inline void MD5::HH(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac){
a += H(b, c, d) + x + ac;
a = rotate_left (a, s) +b;
}
inline void MD5::II(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac){
a += I(b, c, d) + x + ac;
a = rotate_left (a, s) +b;
}

105
amxmodx/md5.h Executable file
View File

@ -0,0 +1,105 @@
// MD5.CC - source code for the C++/object oriented translation and
// modification of MD5.
// Translation and modification (c) 1995 by Mordechai T. Abzug
// This translation/ modification is provided "as is," without express or
// implied warranty of any kind.
// The translator/ modifier does not claim (1) that MD5 will do what you think
// it does; (2) that this translation/ modification is accurate; or (3) that
// this software is "merchantible." (Language for this disclaimer partially
// copied from the disclaimer below).
/* based on:
MD5.H - header file for MD5C.C
MDDRIVER.C - test driver for MD2, MD4 and MD5
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
*/
#include <stdio.h>
//#include <fstream.h>
//#include <iostream.h>
class MD5 {
public:
// methods for controlled operation:
MD5 (); // simple initializer
void update (unsigned char *input, unsigned int input_length);
void update (FILE *file);
void finalize ();
// constructors for special circumstances. All these constructors finalize
// the MD5 context.
MD5 (unsigned char *string); // digest string, finalize
MD5 (FILE *file); // digest file, close, finalize
// methods to acquire finalized result
unsigned char *raw_digest (); // digest as a 16-byte binary array
char * hex_digest (); // digest as a 33-byte ascii-hex string
char * hex_digest (char buffer[33]); //same as above, passing buffer
private:
// first, some types:
typedef unsigned int uint4; // assumes integer is 4 words long
typedef unsigned short int uint2; // assumes short integer is 2 words long
typedef unsigned char uint1; // assumes char is 1 word long
// next, the private data:
uint4 state[4];
uint4 count[2]; // number of *bits*, mod 2^64
uint1 buffer[64]; // input buffer
uint1 digest[16];
uint1 finalized;
// last, the private methods, mostly static:
void init (); // called by all constructors
void transform (uint1 *buffer); // does the real update work. Note
// that length is implied to be 64.
static void encode (uint1 *dest, uint4 *src, uint4 length);
static void decode (uint4 *dest, uint1 *src, uint4 length);
static void memcpy (uint1 *dest, uint1 *src, uint4 length);
static void memset (uint1 *start, uint1 val, uint4 length);
static inline uint4 rotate_left (uint4 x, uint4 n);
static inline uint4 F (uint4 x, uint4 y, uint4 z);
static inline uint4 G (uint4 x, uint4 y, uint4 z);
static inline uint4 H (uint4 x, uint4 y, uint4 z);
static inline uint4 I (uint4 x, uint4 y, uint4 z);
static inline void FF (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac);
static inline void GG (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac);
static inline void HH (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac);
static inline void II (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac);
};

12
amxmodx/meta_api.cpp
View File

@ -73,8 +73,8 @@ Grenades g_grenades;
LogEventsMngr g_logevents;
MenuMngr g_menucmds;
CLangMngr g_langMngr;
CString g_log_dir;
CString g_mod_name;
String g_log_dir;
String g_mod_name;
XVars g_xvars;
bool g_bmod_cstrike;
bool g_bmod_dod;
@ -91,7 +91,7 @@ float g_auth_time;
#ifdef MEMORY_TEST
float g_next_memreport_time;
unsigned int g_memreport_count;
CString g_memreport_dir;
String g_memreport_dir;
bool g_memreport_enabled;
#define MEMREPORT_INTERVAL 300.0f /* 5 mins */
#endif // MEMORY_TEST
@ -218,8 +218,8 @@ int C_Spawn( edict_t *pent ) {
g_tasksMngr.registerTimers( &gpGlobals->time, &mp_timelimit->value, &g_game_timeleft );
// ###### Load lang
g_langMngr.Load(build_pathname("%s/languages.dat", get_localinfo("amxx_datadir", "addons/amxx/data")));
g_langMngr.MergeDefinitionFile(build_pathname("%s/langnames.lng", get_localinfo("amxx_datadir", "addons/amxx/data")));
g_langMngr.LoadCache(build_pathname("%s/dictionary.cache", get_localinfo("amxx_datadir", "addons/amxx/data")));
// g_langMngr.Load(build_pathname("%s/languages.dat", get_localinfo("amxx_datadir", "addons/amxx/data")));
// ###### Initialize commands prefixes
g_commands.registerPrefix( "amx" );
g_commands.registerPrefix( "amxx" );
@ -402,6 +402,7 @@ void C_ServerActivate_Post( edict_t *pEdictList, int edictCount, int clientMax )
executeForwards(FF_PluginCfg);
// ###### Save lang
g_langMngr.SaveCache(build_pathname("%s/dictionary.cache", get_localinfo("amxx_datadir", "addons/amxx/data")));
g_langMngr.Save(build_pathname("%s/languages.dat", get_localinfo("amxx_datadir", "addons/amxx/data")));
// Correct time in Counter-Strike and other mods (except DOD)
@ -461,6 +462,7 @@ void C_ServerDeactivate_Post() {
g_vault.clear();
g_xvars.clear();
g_plugins.clear();
g_langMngr.SaveCache(build_pathname("%s/dictionary.cache", get_localinfo("amxx_datadir", "addons/amxx/data")));
g_langMngr.Save(build_pathname("%s/languages.dat", get_localinfo("amxx_datadir", "addons/amxx/data")));
g_langMngr.Clear();
// last memreport

14
amxmodx/msvc/amxmodx_mm 7.1.vcproj
View File

@ -25,7 +25,7 @@
AdditionalIncludeDirectories="&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\pm_shared&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\dlls&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\engine&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\common&quot;;C:\Files\Programming\metamod\metamod"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;amxmodx_mm_EXPORTS"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
RuntimeLibrary="5"
StructMemberAlignment="3"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
@ -661,6 +661,9 @@
<File
RelativePath="..\float.cpp">
</File>
<File
RelativePath="..\md5.cpp">
</File>
<File
RelativePath="..\meta_api.cpp">
</File>
@ -774,6 +777,12 @@
<File
RelativePath="..\CPlugin.h">
</File>
<File
RelativePath="..\CQueue.h">
</File>
<File
RelativePath="..\CRList.h">
</File>
<File
RelativePath="..\CString.h">
</File>
@ -789,6 +798,9 @@
<File
RelativePath="..\fakemeta.h">
</File>
<File
RelativePath="..\md5.h">
</File>
<File
RelativePath="..\modules.h">
</File>