void l4dtoolz::OnChangeMaxplayers ( IConVar *var, const char *pOldValue, float flOldValue )
{
if (max_players_friend_lobby == NULL || max_players_connect == NULL || max_players_server_browser == NULL || lobby_sux_ptr == NULL){
Msg("sv_maxplayers init error\n");
return;
}
if(((ConVar*)var)->GetInt() >= 0){
max_players_new[4] = friends_lobby_new[3] = server_bplayers_new[3] = ((ConVar*)var)->GetInt();
if(lobby_match_ptr != NULL){
lobby_match_new[2] = ((ConVar*)var)->GetInt();
WriteSignature(lobby_match_ptr, (const char*)lobby_match_new);
}else{
Msg("sv_maxplayers MS init error\n");
}
WriteSignature(max_players_friend_lobby, (const char*)friends_lobby_new);
WriteSignature(max_players_connect, (const char*)max_players_new);
WriteSignature(lobby_sux_ptr, lobby_sux_new);
WriteSignature(max_players_server_browser, (const char*)server_bplayers_new);
}else{
WriteSignature(max_players_friend_lobby, friends_lobby_org);
WriteSignature(max_players_connect, max_players_org);
WriteSignature(lobby_sux_ptr, lobby_sux_org);
WriteSignature(max_players_server_browser, server_bplayers_org);
if(lobby_match_ptr != NULL)
WriteSignature(lobby_match_ptr, lobby_match_org);
}
}
void l4dtoolz::OnChangeIvailosp ( IConVar *var, const char *pOldValue, float flOldValue )
{
if(tmp_player == NULL || tmp_player2 == NULL){
Msg("L4DToolZ init error\n");
return;
}
WriteSignature(tmp_player, players_org);
WriteSignature(tmp_player2, players_org2);
}
void l4dtoolz::OnChangeRemovehumanlimit ( IConVar *var, const char *pOldValue, float flOldValue )
{
if(chuman_limit == NULL){
Msg( "sv_removehumanlimit init error\n");
return;
}
if( ((ConVar*)var)->GetInt() == 1){
WriteSignature(chuman_limit, human_limit_new);
}else{
WriteSignature(chuman_limit, human_limit_org);
}
}
void l4dtoolz::OnChangeUnreserved ( IConVar *var, const char *pOldValue, float flOldValue )
{
if(unreserved_ptr == NULL ){
Msg("unreserved_ptr init error\n");
return;
}
if( ((ConVar*)var)->GetInt() == 1){
WriteSignature(unreserved_ptr, unreserved_new);
engine->ServerCommand("sv_allow_lobby_connect_only 0\n");
}else{
WriteSignature(unreserved_ptr, unreserved_org);
}
}
bool Write( ostream& out ) const {
return
WriteByteOrder( out ) &&
WriteHeader( out ) &&
WriteSignature( out ) &&
WriteData( out );
}
void WriteTokens( char *signature,
char *table,
ListNode *reserved,
ListNode *structs,
ListNode *unions,
ListNode *vec_secs,
ListNode *macros,
ListNode *primitives )
{ FILE *outfile = open_table_file( table, INIT_FILE, EXT_H );
fprintf( outfile, "\n"
" /* Header file for %s cmodes definition module */\n",
table );
sprintf( buffer, "_%s%s%s_%s",
table, FILENAME_SEPERATOR, INIT_FILE, EXT_H );
fprintf( outfile, "\n#ifndef %s\n#define %s\n\n#include \"cmodes.h\"\n\n",
buffer, buffer );
if( signature != NULL )
{ WriteSignature( outfile, table, signature);
}
WriteReservedTokens( outfile, reserved);
WriteStructTokens( outfile, table, structs);
WriteUnionTokens( outfile, table, unions);
WriteVec_SecTokens( outfile, table, reserved, vec_secs);
WriteAccessMacros( outfile, macros );
WritePrimitiveSorts( outfile, primitives );
WriteExterns( outfile, table);
fprintf( outfile, "#endif\n\n" );
fclose(outfile);
}
bool l4dtoolz::Unload(char *error, size_t maxlen)
{
#if !defined METAMOD_PLAPI_VERSION
SH_RELEASE_CALLCLASS(m_EngineCC);
#endif
if(max_players_friend_lobby != NULL)
WriteSignature(max_players_friend_lobby, friends_lobby_org);
if(max_players_connect != NULL)
WriteSignature(max_players_connect, max_players_org);
if(lobby_sux_ptr != NULL)
WriteSignature(lobby_sux_ptr, lobby_sux_org);
if(max_players_server_browser != NULL)
WriteSignature(max_players_server_browser, server_bplayers_org);
if(chuman_limit != NULL)
WriteSignature(chuman_limit, human_limit_org);
if(tmp_player != NULL)
WriteSignature(tmp_player, players_org);
if(tmp_player2 != NULL)
WriteSignature(tmp_player2, players_org2);
if(unreserved_ptr != NULL)
WriteSignature(unreserved_ptr, unreserved_org);
if(lobby_match_ptr != NULL)
WriteSignature(lobby_match_ptr, lobby_match_org);
#ifdef WIN32
CloseHandle(hProcess);
#endif
delete[] friends_lobby_org;
delete[] max_players_org;
delete[] lobby_sux_org;
delete[] server_bplayers_org;
delete[] human_limit_org;
delete[] players_org;
delete[] players_org2;
delete[] unreserved_org;
return true;
}
HRESULT COutArchive::Create(ISequentialOutStream *stream, bool endMarker)
{
Close();
#ifdef _7Z_VOL
// endMarker = false;
_endMarker = endMarker;
#endif
SeqStream = stream;
if (!endMarker)
{
SeqStream.QueryInterface(IID_IOutStream, &Stream);
if (!Stream)
{
return E_NOTIMPL;
// endMarker = true;
}
}
#ifdef _7Z_VOL
if (endMarker)
{
/*
CStartHeader sh;
sh.NextHeaderOffset = (UInt32)(Int32)-1;
sh.NextHeaderSize = (UInt32)(Int32)-1;
sh.NextHeaderCRC = 0;
WriteStartHeader(sh);
*/
}
else
#endif
{
if (!Stream)
return E_FAIL;
RINOK(WriteSignature());
RINOK(Stream->Seek(0, STREAM_SEEK_CUR, &_prefixHeaderPos));
}
return S_OK;
}
bool
IMI::FlightDownload(Port &port, const RecordedFlightInfo &flight_info,
Path path, OperationEnvironment &env)
{
if (!_connected)
return false;
MessageParser::Reset();
Flight flight;
if (!FlashRead(port, &flight, flight_info.internal.imi, sizeof(flight), env))
return false;
FILE *fileIGC = _tfopen(path.c_str(), _T("w+b"));
if (fileIGC == nullptr)
return false;
unsigned fixesCount = COMM_MAX_PAYLOAD_SIZE / sizeof(Fix);
Fix *fixBuffer = (Fix*)malloc(sizeof(Fix) * fixesCount);
if (fixBuffer == nullptr)
return false;
bool ok = true;
WriteHeader(flight.decl, flight.signature.tampered, fileIGC);
int noenl = 0;
if ((flight.decl.header.sensor & IMINO_ENL_MASK) != 0)
noenl = 1;
unsigned address = flight_info.internal.imi + sizeof(flight);
unsigned fixesRemains = flight.finish.fixes;
while (ok && fixesRemains) {
unsigned fixesToRead = fixesRemains;
if (fixesToRead > fixesCount)
fixesToRead = fixesCount;
if (!FlashRead(port, fixBuffer, address, fixesToRead * sizeof(Fix), env))
ok = false;
for (unsigned i = 0; ok && i < fixesToRead; i++) {
const Fix *pFix = fixBuffer + i;
if (IMIIS_FIX(pFix->id))
WriteFix(*pFix, false, noenl, fileIGC);
}
address = address + fixesToRead * sizeof(Fix);
fixesRemains -= fixesToRead;
if (env.IsCancelled())
// canceled by user
ok = false;
}
free(fixBuffer);
if (ok)
WriteSignature(flight.signature, flight.decl.header.sn, fileIGC);
fclose(fileIGC);
if (!ok)
File::Delete(Path(path));
return ok;
}
bool l4dtoolz::Load(PluginId id, ISmmAPI *ismm, char *error, size_t maxlen, bool late)
{
#ifdef WIN32
hProcess = OpenProcess(PROCESS_ALL_ACCESS,FALSE, GetCurrentProcessId());
#endif
PLUGIN_SAVEVARS();
GET_V_IFACE_CURRENT(GetEngineFactory, engine, IVEngineServer, INTERFACEVERSION_VENGINESERVER);
GET_V_IFACE_CURRENT(GetEngineFactory, icvar, ICvar, CVAR_INTERFACE_VERSION);
#if defined METAMOD_PLAPI_VERSION
if ((vsp_callbacks = ismm->GetVSPInfo(NULL)) == NULL)
#endif
{
ismm->AddListener(this, this);
ismm->EnableVSPListener();
}
#if !defined METAMOD_PLAPI_VERSION
m_EngineCC = SH_GET_CALLCLASS(engine);
#endif
#if SOURCE_ENGINE >= SE_ORANGEBOX
g_pCVar = icvar;
ConVar_Register(0, &s_BaseAccessor);
#else
ConCommandBaseMgr::OneTimeInit(&s_BaseAccessor);
#endif
char* base_addr = NULL;
size_t base_len = 0;
find_base(matchmaking_dll, base_addr, base_len);
#ifdef WIN32
if(base_addr == NULL)
find_base("matchmaking.dll", base_addr, base_len);
#endif
if(lobby_match_ptr == NULL){
lobby_match_ptr = (char*)FindSignature(lobby_match, base_addr, base_len, true);
get_org_sig(lobby_match, (const char*)lobby_match_new, lobby_match_org);
}
find_base(engine_dll, base_addr, base_len);
if(max_players_friend_lobby == NULL){
max_players_friend_lobby = (char*)FindSignature(friends_lobby, base_addr, base_len);
get_org_sig(max_players_friend_lobby, (const char*)friends_lobby_new, friends_lobby_org);
}
if(max_players_connect == NULL){
max_players_connect = (char*)FindSignature(max_players, base_addr, base_len);
if(max_players_connect != NULL){
get_org_sig(max_players_connect, (const char*)max_players_new, max_players_org);
}
}
if(lobby_sux_ptr==NULL){
#ifdef WIN32
lobby_sux_ptr = max_players_connect;
#else
lobby_sux_ptr = (char*)FindSignature(lobby_sux, base_addr, base_len);
#endif
if(lobby_sux_ptr!=NULL){
get_org_sig(lobby_sux_ptr, lobby_sux_new, lobby_sux_org);
}
}
#ifdef WIN32
if(max_players_server_browser == NULL){
max_players_server_browser = (char*)FindSignature(server_bplayers, base_addr, base_len);
get_org_sig(max_players_server_browser, (const char*)server_bplayers_new, server_bplayers_org);
}
#endif
if(tmp_player == NULL){
tmp_player = (char*)FindSignature(players, base_addr, base_len);
if(tmp_player != NULL){
#ifdef WIN32
tmp_player2 = (char*)FindSignature(players2, base_addr, base_len);
#else
tmp_player2 = tmp_player;
#endif
if(tmp_player2 != NULL){
get_org_sig(tmp_player, players_new, players_org);
WriteSignature(tmp_player, players_new);
get_org_sig(tmp_player2, players_new2, players_org2);
WriteSignature(tmp_player2, players_new2);
engine->ServerCommand("maxplayers 32\n");
engine->ServerCommand("L4DToolZ [email protected]\n");
}
}
}
if(unreserved_ptr==NULL){
unreserved_ptr = (char*)FindSignature(unreserved, base_addr, base_len);
get_org_sig(unreserved_ptr, unreserved_new, unreserved_org);
}
find_base(server_dll, base_addr, base_len);
if(chuman_limit == NULL){
chuman_limit = (char*)FindSignature(human_limit, base_addr, base_len);
get_org_sig(chuman_limit, human_limit_new, human_limit_org);
}
#ifndef WIN32
if(max_players_server_browser == NULL){
max_players_server_browser = (char*)FindSignature(server_bplayers, base_addr, base_len);
get_org_sig(max_players_server_browser, (const char*)server_bplayers_new, server_bplayers_org);
}
#endif
return true;
}
void WriteAppx(
const FilePtr &zip,
const std::unordered_map<std::string, std::string> &fileNames,
const std::string *certPath, int compressionLevel, bool isBundle)
{
FileSink zipRawSink(zip.get());
OffsetSink zipOffsetSink;
auto zipSink = MakeMultiSink(zipRawSink, zipOffsetSink);
std::vector<ZIPFileEntry> zipFileEntries;
std::pair<std::string, std::string> appxBundleManifest;
APPXDigests digests;
// Write and hash the ZIP content.
{
SHA256Sink axpcSink;
auto sink = MakeMultiSink(zipSink, axpcSink);
for (const auto &fileNamePair : fileNames) {
const std::string &archiveName = fileNamePair.first;
const std::string &fileName = fileNamePair.second;
const std::string suffix = "AppxBundleManifest.xml";
if (isBundle &&
suffix.size() < archiveName.size() &&
std::equal(suffix.rbegin(), suffix.rend(), archiveName.rbegin())) {
appxBundleManifest = fileNamePair;
continue;
}
zipFileEntries.emplace_back(
WriteZIPFileEntry(sink, zipOffsetSink.Offset(), fileName,
archiveName, compressionLevel));
}
if (isBundle) {
ZIPFileEntry appxBundleManifestEntry = WriteAppxBundleManifestZIPFileEntry(
sink,
zipOffsetSink.Offset(),
appxBundleManifest.second,
appxBundleManifest.first, compressionLevel,
zipFileEntries);
zipFileEntries.emplace_back(std::move(appxBundleManifestEntry));
}
// this creates AppxBlockMap.xml file
ZIPFileEntry blockMap = WriteAppxBlockMapZIPFileEntry(
sink, zipOffsetSink.Offset(), zipFileEntries, isBundle);
digests.axbm = blockMap.sha256;
zipFileEntries.emplace_back(std::move(blockMap));
// this creates [Content_Types].xml
ZIPFileEntry contentTypes = WriteContentTypesZIPFileEntry(
sink, zipOffsetSink.Offset(), isBundle, zipFileEntries);
digests.axct = contentTypes.sha256;
zipFileEntries.emplace_back(std::move(contentTypes));
digests.axpc = axpcSink.SHA256();
}
// Hash (but do not write) the directory, pre-signature.
{
SHA256Sink axcdSink;
OffsetSink tmpOffsetSink = zipOffsetSink;
auto sink = MakeMultiSink(axcdSink, tmpOffsetSink);
for (const ZIPFileEntry &entry : zipFileEntries) {
entry.WriteDirectoryEntry(sink);
}
WriteZIPEndOfCentralDirectoryRecord(sink, tmpOffsetSink.Offset(),
zipFileEntries);
digests.axcd = axcdSink.SHA256();
}
// Sign and write the signature.
if (certPath) {
zipFileEntries.emplace_back(WriteSignature(
zipSink, *certPath, digests, zipOffsetSink.Offset()));
}
// Write the directory.
for (const ZIPFileEntry &entry : zipFileEntries) {
entry.WriteDirectoryEntry(zipSink);
}
WriteZIPEndOfCentralDirectoryRecord(zipSink, zipOffsetSink.Offset(),
zipFileEntries);
}
