static int debug_func (CURL *c, curl_infotype type, char *data, size_t size, void * ptr) {
char buffer[MAXPRINTMSG];
if (type == CURLINFO_TEXT) {
if (size > sizeof(buffer)-1)
size = sizeof(buffer)-1;
memcpy (buffer, data, size);
buffer[size] = 0;
Com_LPrintf (PRINT_DEVELOPER, "[HTTP] %s\n", buffer);
}
return 0;
}
// for debugging problems when out-of-date entity origin is referenced
void CL_CheckEntityPresent(int entnum, const char *what)
{
centity_t *e;
if (entnum == cl.frame.clientNum + 1) {
return; // player entity = current
}
e = &cl_entities[entnum];
if (e->serverframe == cl.frame.number) {
return; // current
}
if (e->serverframe) {
Com_LPrintf(PRINT_DEVELOPER,
"SERVER BUG: %s on entity %d last seen %d frames ago\n",
what, entnum, cl.frame.number - e->serverframe);
} else {
Com_LPrintf(PRINT_DEVELOPER,
"SERVER BUG: %s on entity %d never seen before\n",
what, entnum);
}
}
/*
=================
Qcommon_Init
=================
*/
void Qcommon_Init(int argc, char **argv)
{
if (setjmp(abortframe))
Sys_Error("Error during initialization: %s", com_errorMsg);
com_argc = argc;
com_argv = argv;
Com_SetLastError(NULL);
X86_SetFPCW();
// prepare enough of the subsystems to handle
// cvar and command buffer management
Z_Init();
MSG_Init();
Cbuf_Init();
Cmd_Init();
Cvar_Init();
Key_Init();
Prompt_Init();
Con_Init();
//
// init commands and vars
//
z_perturb = Cvar_Get("z_perturb", "0", 0);
#if USE_CLIENT
host_speeds = Cvar_Get("host_speeds", "0", 0);
#endif
#ifdef _DEBUG
developer = Cvar_Get("developer", "0", 0);
#endif
timescale = Cvar_Get("timescale", "1", CVAR_CHEAT);
fixedtime = Cvar_Get("fixedtime", "0", CVAR_CHEAT);
logfile_enable = Cvar_Get("logfile", "0", 0);
logfile_flush = Cvar_Get("logfile_flush", "0", 0);
logfile_name = Cvar_Get("logfile_name", "console", 0);
logfile_prefix = Cvar_Get("logfile_prefix", "[%Y-%m-%d %H:%M] ", 0);
#if USE_CLIENT
dedicated = Cvar_Get("dedicated", "0", CVAR_NOSET);
cl_running = Cvar_Get("cl_running", "0", CVAR_ROM);
cl_paused = Cvar_Get("cl_paused", "0", CVAR_ROM);
#else
dedicated = Cvar_Get("dedicated", "1", CVAR_ROM);
#endif
sv_running = Cvar_Get("sv_running", "0", CVAR_ROM);
sv_paused = Cvar_Get("sv_paused", "0", CVAR_ROM);
com_timedemo = Cvar_Get("timedemo", "0", CVAR_CHEAT);
com_date_format = Cvar_Get("com_date_format", "%Y-%m-%d", 0);
#ifdef _WIN32
com_time_format = Cvar_Get("com_time_format", "%H.%M", 0);
#else
com_time_format = Cvar_Get("com_time_format", "%H:%M", 0);
#endif
#ifdef _DEBUG
com_debug_break = Cvar_Get("com_debug_break", "0", 0);
#endif
com_fatal_error = Cvar_Get("com_fatal_error", "0", 0);
com_version = Cvar_Get("version", com_version_string, CVAR_SERVERINFO | CVAR_ROM);
allow_download = Cvar_Get("allow_download", COM_DEDICATED ? "0" : "1", CVAR_ARCHIVE);
allow_download_players = Cvar_Get("allow_download_players", "1", CVAR_ARCHIVE);
allow_download_models = Cvar_Get("allow_download_models", "1", CVAR_ARCHIVE);
allow_download_sounds = Cvar_Get("allow_download_sounds", "1", CVAR_ARCHIVE);
allow_download_maps = Cvar_Get("allow_download_maps", "1", CVAR_ARCHIVE);
allow_download_textures = Cvar_Get("allow_download_textures", "1", CVAR_ARCHIVE);
allow_download_pics = Cvar_Get("allow_download_pics", "1", CVAR_ARCHIVE);
allow_download_others = Cvar_Get("allow_download_others", "0", 0);
rcon_password = Cvar_Get("rcon_password", "", CVAR_PRIVATE);
Cmd_AddCommand("z_stats", Z_Stats_f);
//Cmd_AddCommand("setenv", Com_Setenv_f);
Cmd_AddMacro("com_date", Com_Date_m);
Cmd_AddMacro("com_time", Com_Time_m);
Cmd_AddMacro("com_uptime", Com_Uptime_m);
Cmd_AddMacro("com_uptime_long", Com_UptimeLong_m);
Cmd_AddMacro("random", Com_Random_m);
Cmd_AddMacro("com_maplist", Com_MapList_m);
// add any system-wide configuration files
Sys_AddDefaultConfig();
// we need to add the early commands twice, because
// a basedir or cddir needs to be set before execing
// config files, but we want other parms to override
// the settings of the config files
Com_AddEarlyCommands(qfalse);
Sys_Init();
Sys_RunConsole();
FS_Init();
Sys_RunConsole();
// no longer allow CVAR_NOSET modifications
com_initialized = qtrue;
// after FS is initialized, open logfile
logfile_enable->changed = logfile_enable_changed;
logfile_flush->changed = logfile_param_changed;
logfile_name->changed = logfile_param_changed;
logfile_enable_changed(logfile_enable);
// execute configs: default.cfg may come from the packfile, but config.cfg
// and autoexec.cfg must be real files within the game directory
Com_AddConfigFile(COM_DEFAULT_CFG, 0);
Com_AddConfigFile(COM_CONFIG_CFG, FS_TYPE_REAL | FS_PATH_GAME);
Com_AddConfigFile(COM_AUTOEXEC_CFG, FS_TYPE_REAL | FS_PATH_GAME);
Com_AddConfigFile(COM_POSTEXEC_CFG, FS_TYPE_REAL);
Com_AddEarlyCommands(qtrue);
Cmd_AddCommand("lasterror", Com_LastError_f);
Cmd_AddCommand("quit", Com_Quit_f);
#if !USE_CLIENT
Cmd_AddCommand("recycle", Com_Recycle_f);
#endif
srand(Sys_Milliseconds());
Netchan_Init();
NET_Init();
BSP_Init();
CM_Init();
SV_Init();
CL_Init();
TST_Init();
Sys_RunConsole();
// add + commands from command line
if (!Com_AddLateCommands()) {
// if the user didn't give any commands, run default action
char *cmd = COM_DEDICATED ? "dedicated_start" : "client_start";
if ((cmd = Cmd_AliasCommand(cmd)) != NULL) {
Cbuf_AddText(&cmd_buffer, cmd);
Cbuf_Execute(&cmd_buffer);
}
} else {
// the user asked for something explicit
// so drop the loading plaque
SCR_EndLoadingPlaque();
}
// even not given a starting map, dedicated server starts
// listening for rcon commands (create socket after all configs
// are executed to make sure port number is properly set)
if (COM_DEDICATED) {
NET_Config(NET_SERVER);
}
Com_AddConfigFile(COM_POSTINIT_CFG, FS_TYPE_REAL);
Com_Printf("====== " PRODUCT " initialized ======\n\n");
Com_LPrintf(PRINT_NOTICE, APPLICATION " " VERSION ", " __DATE__ "\n");
Com_Printf("http://skuller.net/q2pro/\n\n");
time(&com_startTime);
com_eventTime = Sys_Milliseconds();
}
// A download finished, find out what it was, whether there were any errors and
// if so, how severe. If none, rename file and other such stuff.
static qboolean finish_download(void)
{
int msgs_in_queue;
CURLMsg *msg;
CURLcode result;
dlhandle_t *dl;
CURL *curl;
long response;
double sec, bytes;
char size[16], speed[16];
char temp[MAX_OSPATH];
qboolean fatal_error = qfalse;
const char *err;
print_type_t level;
do {
msg = curl_multi_info_read(curl_multi, &msgs_in_queue);
if (!msg)
break;
if (msg->msg != CURLMSG_DONE)
continue;
curl = msg->easy_handle;
dl = find_handle(curl);
cls.download.current = NULL;
cls.download.percent = 0;
//filelist processing is done on read
if (dl->file) {
fclose(dl->file);
dl->file = NULL;
}
curl_handles--;
result = msg->data.result;
switch (result) {
//for some reason curl returns CURLE_OK for a 404...
case CURLE_HTTP_RETURNED_ERROR:
case CURLE_OK:
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response);
if (result == CURLE_OK && response == 200) {
//success
break;
}
err = http_strerror(response);
//404 is non-fatal
if (response == 404) {
level = PRINT_ALL;
goto fail1;
}
//every other code is treated as fatal
//not marking download as done since
//we are falling back to UDP
level = PRINT_ERROR;
fatal_error = qtrue;
goto fail2;
case CURLE_COULDNT_RESOLVE_HOST:
case CURLE_COULDNT_CONNECT:
case CURLE_COULDNT_RESOLVE_PROXY:
//connection problems are fatal
err = curl_easy_strerror(result);
level = PRINT_ERROR;
fatal_error = qtrue;
goto fail2;
default:
err = curl_easy_strerror(result);
level = PRINT_WARNING;
fail1:
//we mark download as done even if it errored
//to prevent multiple attempts.
CL_FinishDownload(dl->queue);
fail2:
Com_LPrintf(level,
"[HTTP] %s [%s] [%d remaining file%s]\n",
dl->queue->path, err, cls.download.pending,
cls.download.pending == 1 ? "" : "s");
if (dl->path[0]) {
remove(dl->path);
dl->path[0] = 0;
}
if (dl->buffer) {
Z_Free(dl->buffer);
dl->buffer = NULL;
}
curl_multi_remove_handle(curl_multi, curl);
continue;
}
//mark as done
CL_FinishDownload(dl->queue);
//show some stats
curl_easy_getinfo(curl, CURLINFO_TOTAL_TIME, &sec);
curl_easy_getinfo(curl, CURLINFO_SIZE_DOWNLOAD, &bytes);
if (sec < 0.001)
sec = 0.001;
Com_FormatSizeLong(size, sizeof(size), bytes);
Com_FormatSizeLong(speed, sizeof(speed), bytes / sec);
//FIXME:
//technically i shouldn't need to do this as curl will auto reuse the
//existing handle when you change the url. however, the curl_handles goes
//all weird when reusing a download slot in this way. if you can figure
//out why, please let me know.
curl_multi_remove_handle(curl_multi, curl);
Com_Printf("[HTTP] %s [%s, %s/sec] [%d remaining file%s]\n",
dl->queue->path, size, speed, cls.download.pending,
cls.download.pending == 1 ? "" : "s");
if (dl->path[0]) {
//rename the temp file
Q_snprintf(temp, sizeof(temp), "%s/%s", fs_gamedir, dl->queue->path);
if (rename(dl->path, temp))
Com_EPrintf("[HTTP] Failed to rename '%s' to '%s': %s\n",
dl->path, dl->queue->path, strerror(errno));
dl->path[0] = 0;
//a pak file is very special...
if (dl->queue->type == DL_PAK) {
CL_RestartFilesystem(qfalse);
rescan_queue();
}
} else if (!fatal_error) {
parse_file_list(dl);
}
} while (msgs_in_queue > 0);
//fatal error occured, disable HTTP
if (fatal_error) {
abort_downloads();
return qfalse;
}
// see if we have more to dl
CL_RequestNextDownload();
return qtrue;
}
