CGameConfig::CGameConfig(const char *path)
{
strncopy(m_File, path, sizeof(m_File));
strncopy(ParseEngine, IS_DEDICATED_SERVER() ? "engine_ds" : "engine_ls", sizeof(ParseEngine));
m_CustomLevel = 0;
m_CustomHandler = nullptr;
}
static cell_t GameRules_SetPropString(IPluginContext *pContext, const cell_t *params)
{
char *prop;
int offset;
int maxlen;
bool sendChange = true;
if (params[3] == 0)
sendChange = false;
void *pGameRules = GameRules();
CBaseEntity *pProxy = NULL;
if (sendChange && ((pProxy = GetGameRulesProxyEnt()) == NULL))
return pContext->ThrowNativeError("Couldn't find gamerules proxy entity.");
if (!pGameRules || !g_szGameRulesProxy || !strcmp(g_szGameRulesProxy, ""))
return pContext->ThrowNativeError("Gamerules lookup failed.");
pContext->LocalToString(params[1], &prop);
sm_sendprop_info_t info;
if (!gamehelpers->FindSendPropInfo(g_szGameRulesProxy, prop, &info))
{
return pContext->ThrowNativeError("Property \"%s\" not found on the gamerules proxy", prop);
}
offset = info.actual_offset;
if (info.prop->GetType() != DPT_String)
{
return pContext->ThrowNativeError("SendProp %s type is not a string (%d != %d)",
prop,
info.prop->GetType(),
DPT_String);
}
maxlen = DT_MAX_STRING_BUFFERSIZE;
char *src;
char *dest = (char *)((intptr_t)pGameRules + offset);
pContext->LocalToString(params[2], &src);
size_t len = strncopy(dest, src, maxlen);
if (sendChange)
{
dest = (char *)((intptr_t)pProxy + offset);
strncopy(dest, src, maxlen);
gamehelpers->SetEdictStateChanged(gamehelpers->EdictOfIndex(gamehelpers->EntityToBCompatRef(pProxy)), offset);
}
return len;
void ProfileEngine::WriteReport(FILE *fp, ProfileReport *report, const char *name)
{
size_t i, num;
prof_atom_report_t *ar;
char new_name[512];
fprintf(fp, " <report name=\"%s\">\n", name);
num = report->GetNumReports();
for (i = 0; i < num; i++)
{
ar = report->GetReport(i);
strncopy(new_name, ar->atom_name, sizeof(new_name));
UTIL_ReplaceAll(new_name, sizeof(new_name), "<", "<", true);
UTIL_ReplaceAll(new_name, sizeof(new_name), ">", ">", true);
fprintf(fp, " <item name=\"%s\" numcalls=\"%d\" mintime=\"%f\" maxtime=\"%f\" totaltime=\"%f\"/>\n",
new_name,
ar->num_calls,
ar->min_time,
ar->max_time,
ar->total_time);
}
fprintf(fp, " </report>\n");
}
IPreparedQuery *SqDatabase::PrepareQueryEx(const char *query,
size_t len,
char *error,
size_t maxlength,
int *errCode/* =NULL */)
{
sqlite3_stmt *stmt = NULL;
if ((m_LastErrorCode = sqlite3_prepare_v2(m_sq3, query, len, &stmt, NULL)) != SQLITE_OK
|| !stmt)
{
const char *msg;
if (m_LastErrorCode != SQLITE_OK)
{
msg = sqlite3_errmsg(m_sq3);
} else {
msg = "Invalid query string";
m_LastErrorCode = SQLITE_ERROR;
}
if (error)
{
strncopy(error, msg, maxlength);
}
m_LastError.assign(msg);
return NULL;
}
return new SqQuery(this, stmt);
}
// native PushStackString(Stack:handle, const value[]);
static cell AMX_NATIVE_CALL PushStackString(AMX* amx, cell* params)
{
CellArray* vec = ArrayHandles.lookup(params[1]);
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
cell *blk = vec->push();
if (!blk)
{
LogError(amx, AMX_ERR_NATIVE, "Failed to grow stack");
return 0;
}
int len;
const char *value = get_amxstring(amx, params[2], 0, len);
strncopy(blk, value, vec->blocksize());
return 1;
}
static cell_t SetArrayString(IPluginContext *pContext, const cell_t *params)
{
CellArray *array;
HandleError err;
HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
if ((err = handlesys->ReadHandle(params[1], htCellArray, &sec, (void **)&array))
!= HandleError_None)
{
return pContext->ThrowNativeError("Invalid Handle %x (error: %d)", params[1], err);
}
size_t idx = (size_t)params[2];
if (idx >= array->size())
{
return pContext->ThrowNativeError("Invalid index %d (count: %d)", idx, array->size());
}
cell_t *blk = array->at(idx);
char *str;
pContext->LocalToString(params[3], &str);
return strncopy((char *)blk, str, array->blocksize() * sizeof(cell_t));
}
static cell_t PushArrayString(IPluginContext *pContext, const cell_t *params)
{
CellArray *array;
HandleError err;
HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
if ((err = handlesys->ReadHandle(params[1], htCellArray, &sec, (void **)&array))
!= HandleError_None)
{
return pContext->ThrowNativeError("Invalid Handle %x (error: %d)", params[1], err);
}
cell_t *blk = array->push();
if (!blk)
{
return pContext->ThrowNativeError("Failed to grow array");
}
char *str;
pContext->LocalToString(params[2], &str);
strncopy((char *)blk, str, array->blocksize() * sizeof(cell_t));
return (cell_t)(array->size() - 1);
}
// native ArraySetString(Array:which, item, const input[]);
static cell AMX_NATIVE_CALL ArraySetString(AMX* amx, cell* params)
{
CellArray* vec = ArrayHandles.lookup(params[1]);
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
size_t idx = (size_t)params[2];
if (idx >= vec->size())
{
LogError(amx, AMX_ERR_NATIVE, "Invalid index %d (count: %d)", idx, vec->size());
return 0;
}
cell *blk = vec->at(idx);
int len;
char *str = get_amxstring(amx, params[3], 0, len);
return strncopy(blk, str, ke::Min((size_t)len + 1, vec->blocksize()));
}
ConfigResult Translator::OnSourceModConfigChanged(const char *key,
const char *value,
ConfigSource source,
char *error,
size_t maxlength)
{
if (strcasecmp(key, "ServerLang") == 0)
{
if (source == ConfigSource_Console)
{
unsigned int index;
if (!GetLanguageByCode(value, &index))
{
UTIL_Format(error, maxlength, "Language code \"%s\" is not registered", value);
return ConfigResult_Reject;
}
m_ServerLang = index;
} else {
strncopy(m_InitialLang, value, sizeof(m_InitialLang));
}
return ConfigResult_Accept;
}
return ConfigResult_Ignore;
}
TConnectOp(IPluginFunction *func, IDBDriver *driver, const char *_dbname, cell_t data)
{
m_pFunction = func;
m_pDriver = driver;
m_pDatabase = NULL;
m_Data = data;
error[0] = '\0';
strncopy(dbname, _dbname, sizeof(dbname));
me = g_PluginSys.GetPluginByCtx(m_pFunction->GetParentContext()->GetContext());
}
bool CHalfLife2::IsMapValid(const char *map)
{
if (!map || !map[0])
return false;
static char szTmp[PLATFORM_MAX_PATH];
strncopy(szTmp, map, sizeof(szTmp));
return FindMap(szTmp, sizeof(szTmp)) != SMFindMapResult::NotFound;
}
CGameConfig::AddressConf::AddressConf(const char *sigName, size_t sigLength, size_t readCount, int *read)
{
size_t limit = sizeof(m_ReadBytes) / sizeof(m_ReadBytes[0]);
size_t readLimit = (readCount <= limit) ? readCount : limit;
strncopy(m_SignatureName, sigName, sizeof(m_SignatureName));
m_ReadCount = readLimit;
memcpy(&this->m_ReadBytes[0], read, sizeof(this->m_ReadBytes[0]) * readLimit);
}
TConnectOp(IPluginFunction *func, IDBDriver *driver, const char *_dbname, AsyncCallbackMode acm, cell_t data)
{
m_pFunction = func;
m_pDriver = driver;
m_pDatabase = NULL;
m_ACM = acm;
m_Data = data;
error[0] = '\0';
strncopy(dbname, _dbname, sizeof(dbname));
me = scripts->FindPluginByContext(m_pFunction->GetParentContext()->GetContext());
}
void CHalfLife2::PushCommandStack(const CCommand *cmd)
{
CachedCommandInfo info;
info.args = cmd;
#if !defined ORANGEBOX_BUILD
strncopy(info.cmd, cmd->Arg(0), sizeof(info.cmd));
#endif
m_CommandStack.push(info);
}
void LibrarySystem::GetLoaderError(char *buffer, size_t maxlength)
{
#if defined PLATFORM_WINDOWS
GetPlatformError(buffer, maxlength);
#elif defined PLATFORM_POSIX
if (buffer != NULL && maxlength)
{
strncopy(buffer, dlerror(), maxlength);
}
#endif
}
void CHalfLife2::PushCommandStack(const CCommand *cmd)
{
CachedCommandInfo info;
info.args = cmd;
#if SOURCE_ENGINE <= SE_DARKMESSIAH
strncopy(info.cmd, cmd->Arg(0), sizeof(info.cmd));
#endif
m_CommandStack.push(info);
}
/*
* Return path of file to record outgoing messages.
*/
char*
record(char* author, unsigned long flags)
{
register int c;
register char* ap;
register char* rp;
register char* ep;
register char* tp;
rp = state.path.path;
ep = rp + sizeof(state.path.path) - 1;
if ((flags & FOLLOWUP) && (ap = author)) {
if (tp = state.var.followup) {
if (state.var.outfolder && !strchr(METAFILE, *tp) && rp < ep)
*rp++ = '+';
while ((*rp = *tp++) && rp < ep)
rp++;
if (*(rp - 1) != '/' && rp < ep)
*rp++ = '/';
}
else if (state.var.outfolder && rp < ep)
*rp++ = '+';
tp = rp;
ap = author;
for (;;) {
switch (c = *ap++) {
case 0:
break;
case '@':
break;
case '!':
rp = tp;
continue;
default:
if (rp < ep)
*rp++ = c;
continue;
}
break;
}
tp = state.path.path;
*rp = 0;
}
else if (!(tp = state.var.log))
*rp = 0;
else if (state.var.outfolder && !strchr(METAFILE, *tp)) {
if (rp < ep)
*rp++ = '+';
strncopy(rp, tp, ep - rp);
}
return tp && *tp ? expand(tp, 1) : (char*)0;
}
void Translator::RebuildLanguageDatabase(const char *lang_header_file)
{
/* Erase everything we have */
sm_trie_destroy(m_pLCodeLookup);
m_pLCodeLookup = sm_trie_create();
m_pStringTab->Reset();
for (size_t i=0; i<m_Languages.size(); i++)
{
delete m_Languages[i];
}
m_Languages.clear();
/* Start anew */
SMCError err;
SMCStates states;
if ((err=textparsers->ParseFile_SMC(lang_header_file, this, &states)) != SMCError_Okay)
{
const char *str_err = textparsers->GetSMCErrorString(err);
if (!str_err)
{
str_err = m_CustomError.c_str();
}
g_Logger.LogError("[SM] Failed to parse language header file: \"%s\"", lang_header_file);
g_Logger.LogError("[SM] Parse error (line %d, column %d): %s", states.line, states.col, str_err);
}
void *serverLang;
if (!sm_trie_retrieve(m_pLCodeLookup, m_InitialLang, &serverLang))
{
g_Logger.LogError("Server language was set to bad language \"%s\" -- reverting to English", m_InitialLang);
strncopy(m_InitialLang, "en", sizeof(m_InitialLang));
m_ServerLang = SOURCEMOD_LANGUAGE_ENGLISH;
}
m_ServerLang = reinterpret_cast<unsigned int>(serverLang);
if (!m_Languages.size())
{
g_Logger.LogError("[SM] Fatal error, no languages found! Translation will not work.");
}
for (size_t i=0; i<m_Files.size(); i++)
{
m_Files[i]->ReparseFile();
}
}
bool CValveMenu::SetExtOption(MenuOption option, const void *valuePtr)
{
if (option == MenuOption_IntroMessage)
{
strncopy(m_IntroMsg, (const char *)valuePtr, sizeof(m_IntroMsg));
return true;
} else if (option == MenuOption_IntroColor) {
unsigned int *array = (unsigned int *)valuePtr;
m_IntroColor = Color(array[0], array[1], array[2], array[3]);
return true;
}
return false;
}
extern void*
dllplug(const char* lib, const char* name, const char* ver, int flags, char* path, size_t size)
{
void* dll;
int hit;
Dllscan_t* dls;
Dllent_t* dle;
hit = 0;
for (;;)
{
if (dls = dllsopen(lib, name, ver))
{
while (dle = dllsread(dls))
{
hit = 1;
if (dll = dllopen(dle->path, flags|RTLD_GLOBAL|RTLD_PARENT))
{
if (path && size)
strncopy(path, dle->path, size);
break;
}
else
errorf("dll", NiL, 1, "%s: dlopen failed: %s", dle->path, dlerror());
}
dllsclose(dls);
}
if (hit)
return dll;
if (!lib)
break;
lib = 0;
}
if ((dll = dllopen(name, flags)) && dll && path && size)
strncopy(path, name, size);
return dll;
}
SMFindMapResult CHalfLife2::FindMap(char *pMapName, int nMapNameMax)
{
#if SOURCE_ENGINE >= SE_LEFT4DEAD
static char mapNameTmp[PLATFORM_MAX_PATH];
g_SourceMod.Format(mapNameTmp, sizeof(mapNameTmp), "maps%c%s.bsp", PLATFORM_SEP_CHAR, pMapName);
if (filesystem->FileExists(mapNameTmp, "GAME"))
{
// If this is already an exact match, don't attempt to autocomplete it further (de_dust -> de_dust2).
// ... but still check that map file is actually valid.
// We check FileExists first to avoid console message about IsMapValid with invalid map.
return engine->IsMapValid(pMapName) == 0 ? SMFindMapResult::NotFound : SMFindMapResult::Found;
}
static ConCommand *pHelperCmd = g_pCVar->FindCommand("changelevel");
// This shouldn't happen.
if (!pHelperCmd || !pHelperCmd->CanAutoComplete())
{
return engine->IsMapValid(pMapName) == 0 ? SMFindMapResult::NotFound : SMFindMapResult::Found;
}
static size_t helperCmdLen = strlen(pHelperCmd->GetName());
CUtlVector<CUtlString> results;
pHelperCmd->AutoCompleteSuggest(pMapName, results);
if (results.Count() == 0)
return SMFindMapResult::NotFound;
// Results come back as you'd see in autocomplete. (ie. "changelevel fullmapnamehere"),
// so skip ahead to start of map path/name
// Like the engine, we're only going to deal with the first match.
bool bExactMatch = Q_strcmp(pMapName, &results[0][helperCmdLen + 1]) == 0;
if (bExactMatch)
{
return SMFindMapResult::Found;
}
else
{
strncopy(pMapName, &results[0][helperCmdLen + 1], nMapNameMax);
return SMFindMapResult::FuzzyMatch;
}
#elif SOURCE_ENGINE == SE_TF2
return static_cast<SMFindMapResult>(engine->FindMap(pMapName, nMapNameMax));
#else
return engine->IsMapValid(pMapName) == 0 ? SMFindMapResult::NotFound : SMFindMapResult::Found;
#endif
}
FILE*
filetemp(char* buf, int size, int type, int fd)
{
register char* s;
register char* b;
register char* e;
FILE* fp = 0;
if (!(b = buf)) {
if (fd <= 0)
return 0;
b = state.path.path;
size = sizeof(state.path.path);
}
e = b + size - 1;
s = strncopy(b, state.tmp.dir, e - b);
s = strncopy(s, "Mail", e - s);
if (s < e)
*s++ = type;
strncopy(s, "XXXXXX", e - s);
if (fd) {
fd = mkstemp(b);
if (!buf && *b)
remove(b);
if (fd < 0 || !(fp = filefd(fd, "r+"))) {
if (fd >= 0)
close(fd);
note(FATAL|SYSTEM|ERROR|IDENTIFY, "\"%s\": temporary file error", b);
}
}
else
mktemp(b);
if (!*b)
note(FATAL|SYSTEM|ERROR|IDENTIFY, "\"%s\": temporary file error", b);
return fp;
}
static bool get_game_name(char *buffer, size_t maxlength)
{
KeyValues *pGameInfo = new KeyValues("GameInfo");
if (g_HL2.KVLoadFromFile(pGameInfo, basefilesystem, "gameinfo.txt"))
{
const char *str;
if ((str = pGameInfo->GetString("game", NULL)) != NULL)
{
strncopy(buffer, str, maxlength);
pGameInfo->deleteThis();
return true;
}
}
pGameInfo->deleteThis();
return false;
}
void CPlayer::Initialize(const char *name, const char *ip, edict_t *pEntity)
{
m_IsConnected = true;
m_Name.assign(name);
m_Ip.assign(ip);
m_pEdict = pEntity;
m_iIndex = engine->IndexOfEdict(pEntity);
m_LangId = g_Translator.GetServerLanguage();
char ip2[24], *ptr;
strncopy(ip2, ip, sizeof(ip2));
if ((ptr = strchr(ip2, ':')) != NULL)
{
*ptr = '\0';
}
m_IpNoPort.assign(ip2);
}
bool UserMessages::GetMessageName(int msgid, char *buffer, size_t maxlength) const
{
if (m_FallbackSearch)
{
int size;
return gamedll->GetUserMessageInfo(msgid, buffer, maxlength, size);
}
const char *msg = g_SMAPI->GetUserMessage(msgid);
if (msg)
{
strncopy(buffer, msg, maxlength);
return true;
}
return false;
}
DBResult MyBasicResults::CopyString(unsigned int columnId,
char *buffer,
size_t maxlength,
size_t *written)
{
DBResult res;
const char *str;
if ((res = GetString(columnId, &str, NULL)) == DBVal_Error)
{
return DBVal_Error;
}
size_t wr = strncopy(buffer, str, maxlength);
if (written)
{
*written = wr;
}
return res;
}
// native ArrayPushString(Array:which, const input[]);
static cell AMX_NATIVE_CALL ArrayPushString(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
if (vec == NULL)
{
return 0;
}
cell *blk = vec->push();
if (!blk)
{
LogError(amx, AMX_ERR_NATIVE, "Failed to grow array");
return 0;
}
strncopy(blk, get_amxaddr(amx, params[2]), vec->blocksize());
return static_cast<cell>((vec->size() - 1));
}
// native ArrayPushString(Array:which, const input[]);
static cell AMX_NATIVE_CALL ArrayPushString(AMX* amx, cell* params)
{
CellArray* vec = ArrayHandles.lookup(params[1]);
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
cell *blk = vec->push();
if (!blk)
{
LogError(amx, AMX_ERR_NATIVE, "Failed to grow array");
return 0;
}
strncopy(blk, get_amxaddr(amx, params[2]), vec->blocksize());
return static_cast<cell>((vec->size() - 1));
}
static bool ResolveFuzzyMapName(const char *fuzzyName, char *outFullname, int size)
{
static ConCommand *pHelperCmd = g_pCVar->FindCommand("changelevel");
if (!pHelperCmd || !pHelperCmd->CanAutoComplete())
return false;
static size_t helperCmdLen = strlen(pHelperCmd->GetName());
CUtlVector<CUtlString> results;
pHelperCmd->AutoCompleteSuggest(fuzzyName, results);
if (results.Count() == 0)
return false;
// Results come back as you'd see in autocomplete. (ie. "changelevel fullmapnamehere"),
// so skip ahead to start of map path/name
// Like the engine, we're only going to deal with the first match.
strncopy(outFullname, &results[0][helperCmdLen + 1], size);
return true;
}
/*
* Converts Steam2 id, Steam3 id, or SteamId64 to unified, legacy
* admin identity format. (account id part of Steam2 format)
*/
bool AdminCache::GetUnifiedSteamIdentity(const char *ident, char *out, size_t maxlen)
{
int len = strlen(ident);
if (!strcmp(ident, "BOT"))
{
// Bots
strncopy(out, ident, maxlen);
return true;
}
else if (len >= 11 && !strncmp(ident, "STEAM_", 6) && ident[8] != '_')
{
// non-bot/lan Steam2 Id, strip off the STEAM_* part
ke::SafeStrcpy(out, maxlen, &ident[8]);
return true;
}
else if (len >= 7 && !strncmp(ident, "[U:", 3) && ident[len-1] == ']')
{
// Steam3 Id, replicate the Steam2 Post-"STEAM_" part
uint32_t accountId = strtoul(&ident[5], nullptr, 10);
ke::SafeSprintf(out, maxlen, "%u:%u", accountId & 1, accountId >> 1);
return true;
}
