void Component::parseBCLSearchResult(const BCLSearchResult & bclSearchResult)
{
m_componentType = bclSearchResult.componentType().c_str();
m_name = bclSearchResult.name().c_str();
m_uid = bclSearchResult.uid().c_str();
m_versionId = bclSearchResult.versionId().c_str();
m_description = bclSearchResult.description().c_str();
m_fidelityLevel = bclSearchResult.fidelityLevel().c_str();
m_attributes = bclSearchResult.attributes();
m_files = bclSearchResult.files();
m_provenances = bclSearchResult.provenances();
m_tags = bclSearchResult.tags();
std::string componentVersion;
Q_FOREACH(const BCLFile & file, m_files){
if (file.usageType() == "script" && file.softwareProgram() == "OpenStudio"){
componentVersion = file.identifier();
break;
}
}
if (!componentVersion.empty() && VersionString(componentVersion) > VersionString(openStudioVersion())){
m_available = false;
}else{
m_available = true;
}
}
static void FChecks_VersionResponse (void)
{
if (Modules_SecurityLoaded())
Cbuf_AddText (va("say ezQuake %s " QW_PLATFORM ":" QW_RENDERER " crc: %s\n", VersionString(), Auth_Generate_Crc()));
else
Cbuf_AddText (va("say ezQuake %s " QW_PLATFORM ":" QW_RENDERER "\n", VersionString()));
}
VersionString extractOpenStudioVersion(const QVariant& variant) {
QJsonObject topLevel = QJsonDocument::fromVariant(variant).object();
if (topLevel.contains("metadata")) {
topLevel = topLevel["metadata"].toObject();
}
OptionalVersionString version;
if (topLevel.contains("openstudio_version")) {
version = VersionString(topLevel["openstudio_version"].toString().toStdString());
}
else if (topLevel.contains("version")) {
version = VersionString(topLevel["version"].toString().toStdString());
}
else {
LOG_FREE_AND_THROW("openstudio.core.Json","No version identifier found in QJSON variant.");
}
OS_ASSERT(version);
if (version.get() > VersionString(openStudioVersion())) {
LOG_FREE(Warn,"openstudio.Json","Loading json file from version " << version
<< " with OpenStudio version " << VersionString(openStudioVersion())
<< ". OpenStudio json files are not designed to be forwards-compatible. "
<< "Unexpected behavior may result.")
}
return version.get();
}
void ServersListModel::setVersionString(int index, const std::string &version)
{
if (version.empty())
mVersionStrings[index] = VersionString(0, "");
else
{
int width = gui->getFont()->getWidth(version);
mVersionStrings[index] = VersionString(width, version);
}
}
FileReference toFileReference(const QVariant& variant, const VersionString& version) {
QVariantMap map = variant.toMap();
OptionalDateTime timestampCreate, timestampLast;
if (version < VersionString("1.0.4")) {
timestampCreate = DateTime(map["timestamp_create"].toString().toStdString());
timestampLast = DateTime(map["timestamp_last"].toString().toStdString());
}
else {
timestampCreate = DateTime::fromISO8601(map["timestamp_create"].toString().toStdString());
timestampLast = DateTime::fromISO8601(map["timestamp_last"].toString().toStdString());
}
OS_ASSERT(timestampCreate);
OS_ASSERT(timestampLast);
return FileReference(toUUID(map["uuid"].toString().toStdString()),
toUUID(map["version_uuid"].toString().toStdString()),
map.contains("name") ? map["name"].toString().toStdString() : std::string(),
map.contains("display_name") ? map["display_name"].toString().toStdString() : std::string(),
map.contains("description") ? map["description"].toString().toStdString() : std::string(),
toPath(map["path"].toString()),
FileReferenceType(map["file_type"].toString().toStdString()),
timestampCreate.get(),
timestampLast.get(),
map["checksum_create"].toString().toStdString(),
map["checksum_last"].toString().toStdString());
}
std::pair<VersionString, std::string> IddFile::parseVersionBuild(const openstudio::path &p)
{
std::ifstream ifs(openstudio::toString(p));
if (!ifs.good()) {
throw std::runtime_error("Unable to open file for reading: " + openstudio::toString(p));
}
ifs.seekg(0, std::ios_base::end);
const auto end = ifs.tellg();
ifs.seekg(0, std::ios_base::beg);
const auto length_to_read = std::min(std::streampos(10000), end);
std::vector<char> data(length_to_read);
ifs.read(data.data(), length_to_read);
const std::string strdata(data.cbegin(), data.cend());
std::string build;
boost::smatch matches;
if (boost::regex_search(strdata, matches, iddRegex::build())) {
build = std::string(matches[1].first,matches[1].second);
}
if (boost::regex_search(strdata, matches, iddRegex::version())) {
return std::make_pair(VersionString(std::string(matches[1].first, matches[1].second)), build);
}
throw std::runtime_error("Unable to parse version from IDD: " + openstudio::toString(p));
}
bool
GLContext::MarkExtensionGroupUnsupported(GLExtensionGroup extensionGroup)
{
MOZ_ASSERT(IsExtensionSupported(extensionGroup), "extension group is already unsupported!");
if (IsExtensionGroupIsPartOfProfileVersion(extensionGroup, mProfile, mVersion)) {
NS_WARNING(nsPrintfCString("%s marked as unsupported, but it's supposed to be supported by %s %s",
GetExtensionGroupName(extensionGroup),
ProfileString(),
VersionString()).get());
return false;
}
const ExtensionGroupInfo& groupInfo = GetExtensionGroupInfo(extensionGroup);
for (size_t i = 0; true; i++)
{
MOZ_ASSERT(i < kMAX_EXTENSION_GROUP_SIZE, "kMAX_EXTENSION_GROUP_SIZE too small");
if (groupInfo.mExtensions[i] == GLContext::Extensions_End) {
break;
}
MarkExtensionUnsupported(groupInfo.mExtensions[i]);
}
MOZ_ASSERT(!IsExtensionSupported(extensionGroup), "GLContext::MarkExtensionGroupUnsupported has failed!");
NS_WARNING(nsPrintfCString("%s marked as unsupported", GetExtensionGroupName(extensionGroup)).get());
return true;
}
// Prints a directory of contents.
void TessdataManager::Directory() const {
tprintf("Version string:%s\n", VersionString().c_str());
int offset = TESSDATA_NUM_ENTRIES * sizeof(int64_t);
for (int i = 0; i < TESSDATA_NUM_ENTRIES; ++i) {
if (!entries_[i].empty()) {
tprintf("%d:%s:size=%d, offset=%d\n", i, kTessdataFileSuffixes[i],
entries_[i].size(), offset);
offset += entries_[i].size();
}
}
}
/// <summary>Loads game data</summary>
/// <param name="data">arguments.</param>
/// <returns></returns>
DWORD WINAPI GameDataWorker::ThreadMain(GameDataWorkerData* data)
{
try
{
XFileSystem vfs;
HRESULT hr;
// Init COM
if (FAILED(hr=CoInitialize(NULL)))
throw ComException(HERE, hr);
// Feedback
Console << Cons::UserAction << L"Loading " << VersionString(data->Version) << L" game data from " << data->GameFolder << ENDL;
data->SendFeedback(ProgressType::Operation, 0, VString(L"Loading %s game data from '%s'", VersionString(data->Version).c_str(), data->GameFolder.c_str()));
// Build VFS.
vfs.Enumerate(data->GameFolder, data->Version, data);
// language files
StringLib.Enumerate(vfs, data->Language, data);
// script/game objects
ScriptObjectLib.Enumerate(data);
GameObjectLib.Enumerate(vfs, data);
// Descriptions
DescriptionLib.Enumerate(data);
// legacy syntax file
SyntaxLib.Enumerate(data);
// Cleanup
data->SendFeedback(Cons::UserAction, ProgressType::Succcess, 0, VString(L"Loaded %s game data successfully", VersionString(data->Version).c_str()));
CoUninitialize();
return 0;
}
catch (ExceptionBase& e)
{
// Feedback
Console.Log(HERE, e);
Console << ENDL;
data->SendFeedback(Cons::Error, ProgressType::Failure, 0, GuiString(L"Failed to load game data : ") + e.Message);
// BEEP!
MessageBeep(MB_ICONERROR);
// Cleanup
CoUninitialize();
return 0;
}
}
AnalysisJSONLoadResult loadJSON(const openstudio::path& p) {
OptionalAnalysisObject result;
StringStreamLogSink logger;
logger.setLogLevel(Error);
try {
QVariant variant = openstudio::loadJSON(p);
VersionString version = extractOpenStudioVersion(variant);
QVariantMap map = variant.toMap();
QVariantMap objectMap;
if (map.contains("data_point")) {
// leave objectMap blank, because it cannot contain project_dir
result = detail::DataPoint_Impl::factoryFromVariant(map["data_point"],version,boost::none);
}
else if (map.contains("analysis")) {
objectMap = map["analysis"].toMap();
result = detail::Analysis_Impl::fromVariant(objectMap,version);
}
else {
LOG_FREE_AND_THROW("openstudio.analysis.AnalysisObject",
"The file at " << toString(p) << " does not contain a data_point or "
<< "an analysis.");
}
OS_ASSERT(result);
openstudio::path projectDir;
if (version < VersionString("1.1.2")) {
OS_ASSERT(map.contains("metadata"));
if (map["metadata"].toMap().contains("project_dir")) {
projectDir = toPath(map["metadata"].toMap()["project_dir"].toString());
}
}
else {
if (objectMap.contains("project_dir")) {
projectDir = toPath(objectMap["project_dir"].toString());
}
}
return AnalysisJSONLoadResult(*result,projectDir,version);
}
catch (std::exception& e) {
LOG_FREE(Error,"openstudio.analysis.AnalysisObject",
"The file at " << toString(p) << " cannot be parsed as an OpenStudio "
<< "analysis framework json file, because " << e.what());
}
catch (...) {
LOG_FREE(Error,"openstudio.analysis.AnalysisObject",
"The file at " << toString(p) << " cannot be parsed as an OpenStudio "
<< "analysis framework json file.");
}
return AnalysisJSONLoadResult(logger.logMessages());
}
BCLFile::BCLFile(const QDomElement& fileElement)
{
QDomElement softwareProgramElement = fileElement.firstChildElement("version").firstChildElement("software_program");
QDomElement identifierElement = fileElement.firstChildElement("version").firstChildElement("identifier");
QDomElement minCompatibleElement = fileElement.firstChildElement("version").firstChildElement("min_compatible");
QDomElement maxCompatibleElement = fileElement.firstChildElement("version").firstChildElement("max_compatible");
QDomElement filenameElement = fileElement.firstChildElement("filename");
QDomElement urlElement = fileElement.firstChildElement("url");
QDomElement filetypeElement = fileElement.firstChildElement("filetype");
QDomElement usageTypeElement = fileElement.firstChildElement("usage_type");
QDomElement checksumElement = fileElement.firstChildElement("checksum");
m_softwareProgram = softwareProgramElement.firstChild().nodeValue().toStdString();
m_identifier = identifierElement.firstChild().nodeValue().toStdString();
if (minCompatibleElement.isNull()){
try{
// if minCompatibleVersion not explicitly set, assume identifier is min
m_minCompatibleVersion = VersionString(m_identifier);
} catch (const std::exception&){
}
}else{
try{
m_minCompatibleVersion = VersionString(minCompatibleElement.firstChild().nodeValue().toStdString());
} catch (const std::exception&){
}
}
if (!maxCompatibleElement.isNull()){
try{
m_maxCompatibleVersion = VersionString(maxCompatibleElement.firstChild().nodeValue().toStdString());
} catch (const std::exception&){
}
}
m_filename = filenameElement.firstChild().nodeValue().toStdString();
m_url = urlElement.firstChild().nodeValue().toStdString();
m_filetype = filetypeElement.firstChild().nodeValue().toStdString();
m_usageType = usageTypeElement.firstChild().nodeValue().toStdString();
m_checksum = checksumElement.firstChild().nodeValue().toStdString();
}
std::string User::InfoText() const
{
std::ostringstream ss;
ss << std::setw(22) << std::left << "Name: " << std::setw(32) << std::left << name << '\r' <<
std::setw(22) << std::left << "Login: "******"Password Hash: " << std::setw(32) << std::left << PasswordSumString() << '\r' <<
std::setw(22) << std::left << "Address: " << std::setw(32) << std::left << sock.remote_endpoint().address().to_string() << '\r' <<
std::setw(22) << std::left << "Port: " << std::setw(32) << std::left << sock.remote_endpoint().port() << '\r' <<
std::setw(22) << std::left << "Hostname: " << std::setw(32) << std::left << host << '\r' <<
std::setw(22) << std::left << "User ID: " << std::setw(32) << std::left << id << '\r' <<
std::setw(22) << std::left << "Version: " << std::setw(32) << std::left << VersionString() << '\r' <<
std::setw(22) << std::left << "Icon: " << std::setw(32) << std::left << icon << '\r' <<
std::setw(22) << std::left << "Last Transaction ID: " << std::setw(32) << std::left << last_trans_id << '\r' <<
std::setw(22) << std::left << "Transaction Replies: " << std::setw(32) << std::left << nreplies << '\r';
return ss.str();
}
static void Config_PrintPreamble(FILE *f)
{
extern cvar_t name;
char *newlines = "\n";
Config_PrintBorder(f);
Config_PrintBorder(f);
Config_PrintLine(f, "", 3);
Config_PrintLine(f, "", 3);
Config_PrintLine(f, "E Z Q U A K E C O N F I G U R A T I O N", 3);
Config_PrintLine(f, "", 3);
Config_PrintLine(f, "", 3);
Config_PrintBorder(f);
Config_PrintBorder(f);
fprintf(f,"\n// %s's config\n\n", name.string);
fprintf(f,"// ezQuake %s " __DATE__ ", " __TIME__"\n", VersionString());
if (cfg_save_cmdline.value) {
DumpCmdLine(f);
fprintf(f, "%s", newlines);
}
}
/// <summary>Writes a revision</summary>
/// <param name="r">Revision.</param>
/// <param name="parent">root node.</param>
/// <exception cref="Logic::ArgumentNullException">Parent is nullptr</exception>
void BackupFileWriter::WriteRevision(const ScriptRevision& r, XmlElementPtr& parent)
{
REQUIRED(parent);
// <revision title="third revision" date="2013-03-12 18:00:00" path="D:\X3 Albion Prelude\scripts\plugin.piracy.lib.logic.xml">
auto node = WriteElement(parent, L"revision");
WriteAttribute(node, L"title", r.Title);
WriteAttribute(node, L"date", (LPCWSTR)r.Date.Format(L"%Y-%m-%d %H:%M:%S")); // yyyy-mm-dd hh:mm:ss
WriteAttribute(node, L"path", r.FullPath.c_str());
// <scriptname>plugin.piracy.lib.logic</scriptname>
// <version>102</version>
// <game>X3TC</game>
// <description>Piracy logic library</description>
// <command>1019</command>
// <text>* Validate Parameters...</text>
WriteElement(node, L"scriptname", r.ScriptName);
WriteElement(node, L"version", VString(L"%d", r.Version));
WriteElement(node, L"game", VersionString(r.Game, true));
WriteElement(node, L"description", r.Description);
WriteElement(node, L"command", VString(L"%d", r.CommandID));
WriteElement(node, L"text", r.Content);
}
/*
* Print information related to the rVersion resource
* passed as a parameter.
*/
static void
PrintVersionResource(ptr rezPtr)
{
rVersPtr rVers_addr;
String(9) string_version;
unsigned long moreInfo;
int country_num;
char *country;
/* Translate version from raw number to string */
rVers_addr = (rVersPtr)rezPtr;
VersionString(0, rVers_addr->version, (Ptr)&string_version);
/* Print product name and string version */
Print8bitString((ptr) &(rVers_addr->product));
putchar(' ');
PrintPString((ptr) &string_version);
putchar('\n');
/* All done if -b (brief) option was specified */
if ( bflag ) return;
/* The "moreInfo" p-string follows the product p-string */
moreInfo = (unsigned long)&(rVers_addr->product) +
rVers_addr->product.textLength + 1;
Print8bitString((Ptr)moreInfo);
putchar('\n');
/* Print the country information */
if ( (country_num=rVers_addr->country) < NUM_COUNTRY)
country = countryTbl[country_num];
if (country_num >= NUM_COUNTRY || country == NULL )
(void)printf("Country: %d unknown to this version of getvers\n",
country_num);
else
(void)printf("Country: %s\n", country);
}
//childloop
int ChildLoop(int acc, char *client_address, char *greeting){
fd_set read_mask;
fd_set write_mask;
fd_set mask;
int width;
struct timeval timeout;
int end_flag;
int i;
int comm_ptr = 0;
int comm_esc = 0;
int flag_comm_end = 0;
int skip = 0;
int is_exec = 0;
DB(fprintf(stderr,"ChildLoop\n"));
//block mode
SetBlock(acc,0);
//mask
width=0;
FD_ZERO(&mask);
DB(fprintf(stderr,"sizeof(fd_set):%ld:\n",sizeof(fd_set)));
DB(fprintf(stderr,"size of fds_bits:%ld:\n",sizeof(mask.__fds_bits)));
DB(fprintf(stderr,"fds_bits[0]:%ld:\n",mask.__fds_bits[0]));
DB(fprintf(stderr,"acc before FD_SET:%d:\n",acc));
FD_SET(acc,&mask);
DB(fprintf(stderr,"acc after FD_SET:%d:\n",acc));
width=acc+1; //acc: (maximam during read_mask and write_mask) + 1
DB(fprintf(stderr,"width (acc+1):%d:\n",width));
//init data for sending
SendBuf.size=SHORT_BUFF_SIZE;
if((SendBuf.buf=calloc(SendBuf.size,sizeof(char))) == NULL){perror("calloc"); exit(1);}
sprintf(SendBuf.buf,"Ready %s",VersionString());
SendBuf.len=strlen(SendBuf.buf);
//send-secv loop
end_flag=0;
while(1){
is_exec = 0;
read_mask=mask;
if(SendBuf.len>0){
write_mask=mask;
}else{
FD_ZERO(&write_mask);
}
timeout.tv_sec=TIMEOUT_S;
timeout.tv_usec=TIMEOUT_US;
switch(select(width,(fd_set *)&read_mask,&write_mask,NULL,&timeout)){
case -1:
if(errno!=EINTR){
perror("select");
}
break;
case 0:
break;
default:
//recv
if(FD_ISSET(acc,&read_mask)){
//end_flag=RecvData(acc);
RecvData(acc);
}
//operation after recv
DB(fprintf(stderr,"after RecvData() RecvBuf.buf:%s:\n",RecvBuf.buf));
DB(fprintf(stderr,"after RecvData() RecvBuf.len:%d:\n",RecvBuf.len));
if((CommBuf.size - CommBuf.len) > RecvBuf.size){
for(i=0;i<RecvBuf.len;i++){
//if((RecvBuf.buf[i] == ';')&&(comm_esc == 0)){
if((RecvBuf.buf[i] == 0x04)&&(comm_esc == 0)){
CommBuf.buf[comm_ptr + i] = '\0';
CommBuf.len = comm_ptr + i;
flag_comm_end = 1;
comm_esc = 0;
}else if((RecvBuf.buf[i] == '\\')&&(comm_esc == 0)){
comm_ptr = comm_ptr - 1;
comm_esc = 1;
}else if((RecvBuf.buf[i] == '\\')&&(comm_esc > 0)){
CommBuf.buf[comm_ptr + i] = '\\';
CommBuf.len = comm_ptr + i;
comm_esc = 0;
}else{
CommBuf.buf[comm_ptr + i] = RecvBuf.buf[i];
comm_esc = 0;
}
//DB(fprintf(stderr,"commesc:%d:%c:",comm_esc,RecvBuf.buf[i]));
}
}else{
flag_comm_end = 2;
}
/*
if(strncmp(CommBuf.buf,"end",3) == 0){
end_flag = 1;
}
*/
//command operation
if(flag_comm_end == 1){
//preprocess
skip=0;
comm_esc = 0;
for(i=0;i<CommBuf.len;i++){
if((CommBuf.buf[i] >= 33)&&(CommBuf.buf[i] <= 126)){
break;
}else{
skip++;
}
}
for(i=skip; i<CommBuf.len; i++){
CommBuf.buf[i - skip] = CommBuf.buf[i];
}
CommBuf.buf[i - skip] = '\0';
CommBuf.len = CommBuf.len - skip;
DB(fprintf(stderr,"preprocessed COMMSIZE:%d:\n",CommBuf.len));
DB(fprintf(stderr,"preprocessed COMM:"));
DB(fprintf(stderr,"%s",CommBuf.buf));
DB(fprintf(stderr,":\n"));
//exec comm and write to RsltBuf
is_exec = ExecComm();
//create SendData
if((SendBuf.buf = malloc(sizeof(char) * (CommBuf.len + 40 + RsltBuf.len))) == NULL){perror("malloc()"); exit(1);}
sprintf(SendBuf.buf,"%s","comm:");
sprintf(SendBuf.buf+5,"%s",CommBuf.buf);
sprintf(SendBuf.buf+5+CommBuf.len,"%s",":\n");
SendBuf.len = strlen(SendBuf.buf);
if(is_exec > 0){
sprintf(SendBuf.buf+SendBuf.len,"%s",RsltBuf.buf);
SendBuf.len = strlen(SendBuf.buf);
if(RsltBuf.buf != NULL){
free(RsltBuf.buf);
RsltBuf.buf = NULL;
RsltBuf.size = 0;
RsltBuf.len = 0;
}
}
}else if(flag_comm_end == 2){
if((SendBuf.buf = malloc(sizeof(char) * (40))) == NULL){perror("malloc()"); exit(1);}
sprintf(SendBuf.buf,"%s","error: commsize over.\n");
SendBuf.len = strlen(SendBuf.buf);
}
//cleaning
if(flag_comm_end == 1){
if((CommBuf.len > 0) && (strncmp(CommBuf.buf,"end;",4) == 0)){
end_flag = 1;
}
for(i=0;i<CommBuf.len;i++){
CommBuf.buf[i] = '\0';
}
for(i=0;i<RecvBuf.len;i++){
RecvBuf.buf[i] = '\0';
}
comm_ptr = 0;
flag_comm_end = 0;
}else{
comm_ptr = comm_ptr + i;
}
//send
if(FD_ISSET(acc,&write_mask)){
SendData(acc,&SendBuf);
}
break;
}
if(end_flag == 1){
DB(fprintf(stderr,"session break.\n"));
break;
}
}
return(0);
}
/*
===============
SV_InitLocal
===============
*/
void SV_InitLocal (void)
{
int i;
extern cvar_t sv_spectalk;
extern cvar_t sv_mapcheck;
extern cvar_t sv_minping;
extern cvar_t sv_maxpitch;
extern cvar_t sv_minpitch;
extern cvar_t sv_nailhack;
extern cvar_t sv_loadentfiles;
extern cvar_t sv_maxvelocity;
extern cvar_t sv_gravity;
extern cvar_t pm_stopspeed;
extern cvar_t pm_spectatormaxspeed;
extern cvar_t pm_accelerate;
extern cvar_t pm_airaccelerate;
extern cvar_t pm_wateraccelerate;
extern cvar_t pm_friction;
extern cvar_t pm_waterfriction;
extern cvar_t pm_bunnyspeedcap;
extern cvar_t pm_ktjump;
extern cvar_t pm_slidefix;
extern cvar_t pm_airstep;
extern cvar_t pm_pground;
packet_t *packet_freeblock; // initialise delayed packet free block
SV_InitOperatorCommands ();
Cvar_Register (&sv_rconPassword);
Cvar_Register (&sv_password);
Cvar_Register (&sv_spectatorPassword);
Cvar_Register (&sv_phs);
Cvar_Register (&sv_paused);
Cvar_Register (&sv_pausable);
Cmd_AddLegacyCommand ("pausable", "sv_pausable");
Cvar_Register (&sv_nailhack);
Cvar_Register (&sv_maxrate);
Cvar_Register (&sv_fastconnect);
Cvar_Register (&sv_loadentfiles);
if (!dedicated)
sv_mintic.string = "0"; // a value of 0 will tie physics tics to screen updates
Cvar_Register (&sv_mintic);
Cvar_Register (&sv_maxtic);
Cvar_Register (&sv_timeout);
Cmd_AddLegacyCommand ("timeout", "sv_timeout");
Cvar_Register (&sv_zombietime);
Cmd_AddLegacyCommand ("zombietime", "sv_zombietime");
Cvar_Register (&sv_spectalk);
Cvar_Register (&sv_mapcheck);
if (dedicated)
Cvar_Register (&sv_minping);
Cvar_Register (&sv_maxpitch);
Cvar_Register (&sv_minpitch);
Cvar_Register (&deathmatch);
Cvar_Register (&teamplay);
Cvar_Register (&skill);
Cvar_Register (&coop);
Cvar_Register (&fraglimit);
Cvar_Register (&timelimit);
Cvar_Register (&samelevel);
Cvar_Register (&maxclients);
Cvar_Register (&maxspectators);
Cvar_Register (&hostname);
Cvar_Register (&watervis);
Cvar_Register (&sv_maxvelocity);
Cvar_Register (&sv_gravity);
Cvar_Register (&pm_stopspeed);
Cvar_Register (&pm_maxspeed);
Cvar_Register (&pm_spectatormaxspeed);
Cvar_Register (&pm_accelerate);
Cvar_Register (&pm_airaccelerate);
Cvar_Register (&pm_wateraccelerate);
Cvar_Register (&pm_friction);
Cvar_Register (&pm_waterfriction);
Cvar_Register (&pm_bunnyspeedcap);
Cvar_Register (&pm_ktjump);
Cvar_Register (&pm_slidefix);
Cvar_Register (&pm_airstep);
Cvar_Register (&pm_pground);
Cvar_Register (&allow_download);
Cvar_Register (&allow_download_skins);
Cvar_Register (&allow_download_models);
Cvar_Register (&allow_download_sounds);
Cvar_Register (&allow_download_maps);
Cvar_Register (&allow_download_pakmaps);
Cvar_Register (&allow_download_gfx);
Cvar_Register (&allow_download_other);
Cvar_Register (&filterban);
Cmd_AddCommand ("addip", SV_AddIP_f);
Cmd_AddCommand ("removeip", SV_RemoveIP_f);
Cmd_AddCommand ("listip", SV_ListIP_f);
Cmd_AddCommand ("writeip", SV_WriteIP_f);
for (i=1 ; i<MAX_MODELS ; i++)
sprintf (localmodels[i], "*%i", i);
Info_SetValueForStarKey (svs.info, "*version", va(PROGRAM " %s", VersionString()), MAX_SERVERINFO_STRING);
Info_SetValueForStarKey (svs.info, "*z_ext", va("%i", SUPPORTED_EXTENSIONS), MAX_SERVERINFO_STRING);
#ifdef VWEP_TEST
Info_SetValueForStarKey (svs.info, "*vwtest", "1", MAX_SERVERINFO_STRING);
#endif
if (strcmp(com_gamedirfile, "qw"))
Info_SetValueForStarKey (svs.info, "*gamedir", com_gamedirfile, MAX_SERVERINFO_STRING);
// init fraglog stuff
svs.logsequence = 1;
svs.logtime = svs.realtime;
SZ_Init (&svs.log[0], svs.log_buf[0], sizeof(svs.log_buf[0]));
svs.log[0].allowoverflow = true;
SZ_Init (&svs.log[1], svs.log_buf[1], sizeof(svs.log_buf[1]));
svs.log[1].allowoverflow = true;
packet_freeblock = Hunk_AllocName(MAX_DELAYED_PACKETS * sizeof(packet_t), "delayed_packets");
for (i = 0; i < MAX_DELAYED_PACKETS; i++) {
SZ_Init (&packet_freeblock[i].msg, packet_freeblock[i].buf, sizeof(packet_freeblock[i].buf));
packet_freeblock[i].next = &packet_freeblock[i + 1];
}
packet_freeblock[MAX_DELAYED_PACKETS - 1].next = NULL;
svs.free_packets = &packet_freeblock[0];
#ifdef MAUTH
// Set up queues for temporary auth tokens and auth'd clients...
authtokq.maxlen = MAX_AUTH_TOK_QUEUE;
authtokq.curlen = 0;
authtokq.start = NULL;
authclientq.maxlen = MAX_AUTH_CLIENT_QUEUE;
authclientq.curlen = 0;
authclientq.start = NULL;
#endif
}
extern "C" int HandleCommandLine(int argc, char** argv)
{
bool displayHelp = false;
bool displayBuild = false;
bool displayCopyright = false;
bool displayVersion = false;
bool argError = false;
char* iniFile = strdup("/afc/etc/dc.ini");
std::vector<int> commandLineDebugSettings;
int flag = 1;
int c;
CsGetoptReset();
while ( (c = CsGetoptl(argc, argv, Option::shortOptions, Option::longOptions, 1)) != EOF )
{
switch ( c )
{
case Option::ERROROPT:
if ( optopt == Option::ERROROPT )
displayHelp = true;
else
argError = true;
break;
case Option::HELP: displayHelp = true; break;
case Option::BUILD: displayBuild = true; break;
case Option::COPYRIGHT: displayCopyright = true; break;
case Option::VERSION: displayVersion = true; break;
case Option::NOT: flag = 0; break;
case Option::CONSOLE:
CsMsgOptset(CSMSGOP_CONSOLE, &flag, (uint32_t)sizeof(int32_t));
flag = 1;
commandLineDebugSettings.push_back(CSMSGOP_CONSOLE);
break;
case Option::VERBOSE:
CsMsgOptset(CSMSGOP_VERBOSE, &flag, (uint32_t)sizeof(int32_t));
flag = 1;
commandLineDebugSettings.push_back(CSMSGOP_VERBOSE);
break;
case Option::WARNINGS:
CsMsgOptset(CSMSGOP_WARNING, &flag, (uint32_t)sizeof(int32_t));
flag = 1;
commandLineDebugSettings.push_back(CSMSGOP_WARNING);
break;
case Option::DEBUG_HIRES:
CsMsgOptset(CSMSGOP_HIGHRES, &flag, (uint32_t)sizeof(int32_t));
commandLineDebugSettings.push_back(CSMSGOP_HIGHRES);
/*FALLTHROUGH*/
case Option::DEBUG_LEVEL:
flag = atoi(optarg);
if ( (flag <= 0) || (flag > 9) )
{
fprintf(stderr, "illegal debug level -- %s\n", optarg);
argError = true;
}
CsMsgOptset(CSMSGOP_DEBUG, &flag, (uint32_t)sizeof(int32_t));
commandLineDebugSettings.push_back(CSMSGOP_DEBUG);
commandLineDebugSettings.push_back(CSMSGOP_DEBUGENABLED);
flag = 1;
break;
case Option::LOGGER:
CsMsgOptset(CSMSGOP_LOGGER, &optarg, (uint32_t)sizeof(char*));
commandLineDebugSettings.push_back(CSMSGOP_LOGGER);
break;
case Option::INI_FILE:
if ( iniFile != 0 )
free(iniFile);
iniFile = strdup(optarg);
break;
default:
argError = true;
} // switch
if ( (c != Option::NOT) && (flag != 1) )
{
argError = true;
fprintf(stderr, "! applied to incorrect argument '%c'\n", c);
}
} // while getting options
if ( argc != optind )
{
argError = true;
if ( argc > optind )
{
char* name = strrchr(argv[0], CsGetcds());
fprintf(stderr, "%s: unexpected argument -- %s\n", (name == 0 ? argv[0] : name+1), argv[optind]);
}
}
// If all the args are ok, do some logical testing of the arguments.
if ( !argError && !displayCopyright && !displayBuild && !displayVersion && !displayHelp )
{
// check arguments here
if ( (iniFile == 0) || (iniFile[0] == '\0') )
{
fprintf(stderr, "Must supply a .ini file\n");
argError = true;
}
}
// See if we should display a usage message
if ( argError )
CsfUsage(0, argv[0], &usage, help);
if ( displayBuild )
fprintf(stderr, "%s\n", VersionString());
if ( displayVersion && !displayCopyright )
fprintf(stderr, "%s %s\n", usage.ou_version, usage.ou_build);
if ( displayCopyright )
CsfUsage(2, argv[0], &usage, help);
if ( displayHelp )
CsfUsage(1, argv[0], &usage, help);
if ( displayBuild || displayVersion )
exit(3);
// Open the ini file
CsfIniOpen(iniFile, "");
if ( commandLineDebugSettings.empty() )
{
CsMsgOptsetFromIni(0, 0);
}
else
{
int* temp = new int[commandLineDebugSettings.size()];
std::copy(commandLineDebugSettings.begin(), commandLineDebugSettings.end(), temp);
CsMsgOptsetFromIni(temp, commandLineDebugSettings.size());
delete[] temp;
}
// Set up the command server stuff
if ( CsfCmdRegister(&statusCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'status'");
else if ( CsfCmdRegister(&initCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'init'");
else if ( CsfCmdRegister(&refreshCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'refresh'");
else if ( CsfCmdRegister(&scheduleCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'schedule'");
else if ( CsfCmdRegister(&CDCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'cd'");
else if ( CsfCmdRegister(&enableAllCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'enableAll'");
else if ( CsfCmdRegister(&disableAllCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'disableAll'");
else if ( CsfCmdRegister(&sendLocCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'sendloc'");
else if ( CsfCmdRegister(&debugCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'debug'");
else if ( CsfCmdServer("", "Command", NULL, 0, "DC Command Server\n", "DC cmd>" ) != 0 )
{
CsErrx("CsfCmdServer failed to start the command server");
}
free(iniFile);
return 0;
}
VersionString IdfFile::version() const {
return VersionString(m_iddFileAndFactoryWrapper.version());
}
int PrintVersion(){
DB(fprintf(stderr,"PrintVersion()\n"));
printf("%s\n",VersionString());
return(0);
}
void VersionInfo::ShowAboutWindow()
{
AboutBrowserStudio about(VersionString(), ServerName);
about.exec();
}
ServersListModel::ServersListModel(ServerInfos *servers, ServerDialog *parent):
mServers(servers),
mVersionStrings(servers->size(), VersionString(0, "")),
mParent(parent)
{
}
bool VersionString::isNextVersion(const VersionString& nextVersionCandidate) const {
VersionString variantOnThis(str());
VersionString variantOnCandidate = nextVersionCandidate;
if (variantOnCandidate <= variantOnThis) {
return false;
}
// now know nextVersionCandidate > this
if (build() && fidelityEqual(nextVersionCandidate)) {
// true if versions except for build number are equal
variantOnThis = VersionString(major(),minor(),patch().get());
variantOnCandidate = VersionString(nextVersionCandidate.major(),
nextVersionCandidate.minor(),
nextVersionCandidate.patch().get());
if (variantOnCandidate == variantOnThis) {
return true;
}
}
else {
// strip out build numbers as needed, because that is not the level at which the
// versions differ
if (build()) {
variantOnThis = VersionString(major(),minor(),patch().get());
}
if (nextVersionCandidate.build()) {
variantOnCandidate = VersionString(nextVersionCandidate.major(),
nextVersionCandidate.minor(),
nextVersionCandidate.patch().get());
}
}
// now have major.minor or major.minor.patch for both
if (variantOnThis.patch()) {
if (variantOnCandidate.patch()) {
VersionString thisIncremented(major(),minor(),patch().get() + 1);
if (variantOnCandidate == thisIncremented) {
return true;
}
// candidate has patch, but is not next patch version. to be next version,
// must have patch == 0
if (variantOnCandidate.patch().get() != 0) {
return false;
}
}
}
// now major.minor.patch v. major.minor or major.minor.patch v. major.minor.0
// strip out patch numbers
if (variantOnThis.patch()) {
variantOnThis = VersionString(variantOnThis.major(),variantOnThis.minor());
}
if (variantOnCandidate.patch()) {
variantOnCandidate = VersionString(variantOnCandidate.major(),variantOnCandidate.minor());
}
// minor increment
VersionString thisIncremented(variantOnThis.major(),variantOnThis.minor() + 1);
if (variantOnCandidate == thisIncremented) {
return true;
}
// major increment
thisIncremented = VersionString(variantOnThis.major() + 1,0);
if (variantOnCandidate == thisIncremented) {
return true;
}
return false;
}
void Host_Init (int argc, char **argv, int default_memsize)
{
vfsfile_t *vf;
cvar_t *v;
char cfg[MAX_PATH] = {0};
int i;
char *cfg_name;
COM_InitArgv (argc, argv);
COM_StoreOriginalCmdline(argc, argv);
#ifdef WITH_DP_MEM
Memory2_Init ();
#endif
Host_InitMemory (default_memsize);
#ifdef WITH_TCL
// interpreter should be initialized
// before any cvar definitions
TCL_InterpInit ();
#endif
Cbuf_Init ();
Cmd_Init ();
Cvar_Init ();
COM_Init ();
Key_Init ();
#ifdef WITH_DP_MEM
Memory2_Init_Commands ();
#endif
Cache_Init_Commands ();
FS_InitFilesystem ();
NET_Init ();
Commands_For_Configs_Init ();
ConfigManager_Init();
ResetBinds();
i = COM_CheckParm("+cfg_load");
if (i && (i + 1 < COM_Argc())) {
cfg_name = COM_Argv(i + 1);
}
else {
cfg_name = MAIN_CONFIG_FILENAME;
}
snprintf(cfg, sizeof(cfg), "%s", cfg_name);
COM_ForceExtensionEx (cfg, ".cfg", sizeof (cfg));
Cbuf_AddText(va("cfg_load %s\n", cfg));
Cbuf_Execute();
Cbuf_AddEarlyCommands ();
Cbuf_Execute ();
Con_Init ();
NET_InitClient ();
Netchan_Init ();
#if (!defined WITH_PNG_STATIC || !defined WITH_JPEG_STATIC || defined WITH_MP3_PLAYER)
QLib_Init();
#endif
Sys_Init ();
CM_Init ();
PM_Init ();
Mod_Init ();
SV_Init ();
CL_Init ();
Cvar_CleanUpTempVars ();
SYSINFO_Init();
#ifdef WITH_TCL
if (!TCL_InterpLoaded())
Com_Printf_State (PRINT_FAIL, "Could not load "TCL_LIB_NAME", embedded Tcl disabled\n");
#endif
Hunk_AllocName (0, "-HOST_HUNKLEVEL-");
host_hunklevel = Hunk_LowMark ();
host_initialized = true;
// walk through all vars and forse OnChange event if cvar was modified,
// also apply that to variables which mirrored in userinfo because of cl_parsefunchars was't applyed as this moment,
// same for serverinfo and may be this fix something also.
for ( v = NULL; (v = Cvar_Next ( v )); ) {
char val[2048];
// if ( !v->modified )
// continue; // not modified even that strange at this moment
if ( Cvar_GetFlags( v ) & (CVAR_ROM | CVAR_INIT) )
continue;
snprintf(val, sizeof(val), "%s", v->string);
Cvar_Set(v, val);
}
Hud_262LoadOnFirstStart();
Com_Printf_State (PRINT_INFO, "Exe: "__TIME__" "__DATE__"\n");
Com_Printf_State (PRINT_INFO, "Hunk allocation: %4.1f MB.\n", (float) host_memsize / (1024 * 1024));
Com_Printf ("\nezQuake %s\n\n", VersionString());
Com_Printf(Host_PrintBars("ezQuake\x9c" "SourceForge\x9c" "net", 38));
Com_Printf(Host_PrintBars("ezQuake Initialized", 38));
Com_Printf("\n");
Com_Printf ("\nType /help to access the manual.\nUse /describe to learn about commands.\n", VersionString());
if ((vf = FS_OpenVFS("autoexec.cfg", "rb", FS_ANY))) {
Cbuf_AddText ("exec autoexec.cfg\n");
VFS_CLOSE(vf);
}
Cmd_StuffCmds_f (); // process command line arguments
Cbuf_AddText ("cl_warncmd 1\n");
#ifdef WIN32
//
// Verify that ezQuake is associated with the QW:// protocl handler.
//
{
extern qbool CL_CheckIfQWProtocolHandler();
extern cvar_t cl_verify_qwprotocol;
if (cl_verify_qwprotocol.integer >= 2)
{
// Always register the qw:// protocol.
Cbuf_AddText("register_qwurl_protocol\n");
}
else if (cl_verify_qwprotocol.integer == 1 && !CL_CheckIfQWProtocolHandler())
{
// Check if the running exe is the one associated with the qw:// protocol.
Com_PrintVerticalBar(0.8 * vid.conwidth / 8);
Com_Printf("\n");
Com_Printf("This ezQuake is not associated with the ");
Com_Printf("\x02QW:// protocol.\n");
Com_Printf("Register it using ");
Com_Printf("\x02/register_qwurl_protocol\n");
Com_Printf("(set ");
Com_Printf("\x02 cl_verify_qwprotocol ");
Com_Printf("to 0 to hide this warning)\n");
Com_PrintVerticalBar(0.8 * vid.conwidth / 8);
Com_Printf("\n");
}
}
#endif // WIN32
// Check if a qtv/demo file is specified as the first argument, in that case play that
// otherwise, do some more checks of what to show at startup.
{
char cmd[1024] = {0};
if (COM_CheckArgsForPlayableFiles(cmd, sizeof(cmd)))
{
Cbuf_AddText(cmd);
}
else
{
Startup_Place();
}
}
#ifdef _WIN32
SetForegroundWindow(mainwindow);
SetActiveWindow(mainwindow);
#endif
host_everything_loaded = true;
}
