void Com_AddConfigFile(const char *name, unsigned flags)
{
qerror_t ret;
ret = Cmd_ExecuteFile(name, flags);
if (ret == Q_ERR_SUCCESS) {
Cbuf_Execute(&cmd_buffer);
} else if (ret != Q_ERR_NOENT) {
Com_WPrintf("Couldn't exec %s: %s\n", name, Q_ErrorString(ret));
}
}
// optionally load the entity string from external source
static void override_entity_string( const char *server ) {
char *path = map_override_path->string;
char buffer[MAX_QPATH], *str;
ssize_t len;
if( !*path ) {
return;
}
len = Q_concat( buffer, sizeof( buffer ), path, server, ".ent", NULL );
if( len >= sizeof( buffer ) ) {
len = Q_ERR_NAMETOOLONG;
goto fail1;
}
len = SV_LoadFile( buffer, ( void ** )&str );
if( !str ) {
if( len == Q_ERR_NOENT ) {
return;
}
goto fail1;
}
if( len > MAX_MAP_ENTSTRING ) {
len = Q_ERR_FBIG;
goto fail2;
}
Com_Printf( "Loaded entity string from %s\n", buffer );
sv.entitystring = str;
return;
fail2:
SV_FreeFile( str );
fail1:
Com_EPrintf( "Couldn't load entity string from %s: %s\n",
buffer, Q_ErrorString( len ) );
}
/*
@@@@@@@@@@@@@@@@@@@@@
R_BeginRegistration
Specifies the model that will be used as the world
@@@@@@@@@@@@@@@@@@@@@
*/
void R_BeginRegistration(const char *model)
{
char fullname[MAX_QPATH];
bsp_t *bsp;
qerror_t ret;
int i;
registration_sequence++;
r_oldviewcluster = -1; // force markleafs
D_FlushCaches();
Q_concat(fullname, sizeof(fullname), "maps/", model, ".bsp", NULL);
ret = BSP_Load(fullname, &bsp);
if (!bsp) {
Com_Error(ERR_DROP, "%s: couldn't load %s: %s",
__func__, fullname, Q_ErrorString(ret));
}
if (bsp == r_worldmodel) {
for (i = 0; i < bsp->numtexinfo; i++) {
bsp->texinfo[i].image->registration_sequence = registration_sequence;
}
bsp->refcount--;
return;
}
BSP_Free(r_worldmodel);
r_worldmodel = bsp;
ProcessTexinfo(bsp);
ProcessFaces(bsp);
// TODO
R_NewMap();
}
static void logfile_write(print_type_t type, const char *s)
{
char text[MAXPRINTMSG];
char buf[MAX_QPATH];
char *p, *maxp;
size_t len;
ssize_t ret;
int c;
if (logfile_prefix->string[0]) {
p = strchr(logfile_prefix->string, '@');
if (p) {
// expand it in place, hacky
switch (type) {
case PRINT_TALK: *p = 'T'; break;
case PRINT_DEVELOPER: *p = 'D'; break;
case PRINT_WARNING: *p = 'W'; break;
case PRINT_ERROR: *p = 'E'; break;
case PRINT_NOTICE: *p = 'N'; break;
default: *p = 'A'; break;
}
}
len = format_local_time(buf, sizeof(buf), logfile_prefix->string);
if (p) {
*p = '@';
}
} else {
len = 0;
}
p = text;
maxp = text + sizeof(text) - 1;
while (*s) {
if (com_logNewline) {
if (len > 0 && p + len < maxp) {
memcpy(p, buf, len);
p += len;
}
com_logNewline = qfalse;
}
if (p == maxp) {
break;
}
c = *s++;
if (c == '\n') {
com_logNewline = qtrue;
} else {
c = Q_charascii(c);
}
*p++ = c;
}
*p = 0;
len = p - text;
ret = FS_Write(text, len, com_logFile);
if (ret != len) {
// zero handle BEFORE doing anything else to avoid recursion
qhandle_t tmp = com_logFile;
com_logFile = 0;
FS_FCloseFile(tmp);
Com_EPrintf("Couldn't write console log: %s\n", Q_ErrorString(ret));
Cvar_Set("logfile", "0");
}
}
// Actually starts a download by adding it to the curl multi handle.
static void start_download(dlqueue_t *entry, dlhandle_t *dl)
{
size_t len;
char temp[MAX_QPATH];
char escaped[MAX_QPATH * 4];
CURLMcode ret;
qerror_t err;
//yet another hack to accomodate filelists, how i wish i could push :(
//NULL file handle indicates filelist.
if (entry->type == DL_LIST) {
dl->file = NULL;
dl->path[0] = 0;
//filelist paths are absolute
escape_path(entry->path, escaped);
} else {
len = Q_snprintf(dl->path, sizeof(dl->path), "%s/%s.tmp", fs_gamedir, entry->path);
if (len >= sizeof(dl->path)) {
Com_EPrintf("[HTTP] Refusing oversize temporary file path.\n");
goto fail;
}
//prepend quake path with gamedir
len = Q_snprintf(temp, sizeof(temp), "%s/%s", http_gamedir(), entry->path);
if (len >= sizeof(temp)) {
Com_EPrintf("[HTTP] Refusing oversize server file path.\n");
goto fail;
}
escape_path(temp, escaped);
err = FS_CreatePath(dl->path);
if (err < 0) {
Com_EPrintf("[HTTP] Couldn't create path to '%s': %s\n", dl->path, Q_ErrorString(err));
goto fail;
}
//don't bother with http resume... too annoying if server doesn't support it.
dl->file = fopen(dl->path, "wb");
if (!dl->file) {
Com_EPrintf("[HTTP] Couldn't open '%s' for writing: %s\n", dl->path, strerror(errno));
goto fail;
}
}
len = Q_snprintf(dl->url, sizeof(dl->url), "%s%s", download_server, escaped);
if (len >= sizeof(dl->url)) {
Com_EPrintf("[HTTP] Refusing oversize download URL.\n");
goto fail;
}
dl->buffer = NULL;
dl->size = 0;
dl->position = 0;
dl->queue = entry;
if (!dl->curl)
dl->curl = curl_easy_init();
curl_easy_setopt(dl->curl, CURLOPT_ENCODING, "");
#ifdef _DEBUG
if (cl_http_debug->integer) {
curl_easy_setopt(dl->curl, CURLOPT_DEBUGFUNCTION, debug_func);
curl_easy_setopt(dl->curl, CURLOPT_VERBOSE, 1);
}
#endif
curl_easy_setopt(dl->curl, CURLOPT_NOPROGRESS, 0);
if (dl->file) {
curl_easy_setopt(dl->curl, CURLOPT_WRITEDATA, dl->file);
curl_easy_setopt(dl->curl, CURLOPT_WRITEFUNCTION, NULL);
} else {
curl_easy_setopt(dl->curl, CURLOPT_WRITEDATA, dl);
curl_easy_setopt(dl->curl, CURLOPT_WRITEFUNCTION, recv_func);
}
curl_easy_setopt(dl->curl, CURLOPT_FAILONERROR, 1);
curl_easy_setopt(dl->curl, CURLOPT_PROXY, cl_http_proxy->string);
curl_easy_setopt(dl->curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(dl->curl, CURLOPT_MAXREDIRS, 5);
curl_easy_setopt(dl->curl, CURLOPT_PROGRESSFUNCTION, progress_func);
curl_easy_setopt(dl->curl, CURLOPT_PROGRESSDATA, dl);
curl_easy_setopt(dl->curl, CURLOPT_USERAGENT, com_version->string);
curl_easy_setopt(dl->curl, CURLOPT_REFERER, download_referer);
curl_easy_setopt(dl->curl, CURLOPT_URL, dl->url);
ret = curl_multi_add_handle(curl_multi, dl->curl);
if (ret != CURLM_OK) {
Com_EPrintf("[HTTP] Failed to add download handle: %s\n",
curl_multi_strerror(ret));
fail:
CL_FinishDownload(entry);
// see if we have more to dl
CL_RequestNextDownload();
return;
}
Com_DPrintf("[HTTP] Fetching %s...\n", dl->url);
entry->state = DL_RUNNING;
curl_handles++;
}
static qboolean Parse_File(const char *path, int depth)
{
char *raw, *data, *p, *cmd;
int argc;
menuFrameWork_t *menu = NULL;
qerror_t ret;
ret = FS_LoadFile(path, (void **)&raw);
if (!raw) {
if (ret != Q_ERR_NOENT || depth) {
Com_WPrintf("Couldn't %s %s: %s\n", depth ? "include" : "load",
path, Q_ErrorString(ret));
}
return qfalse;
}
data = raw;
COM_Compress(data);
while (*data) {
p = strchr(data, '\n');
if (p) {
*p = 0;
}
Cmd_TokenizeString(data, qtrue);
argc = Cmd_Argc();
if (argc) {
cmd = Cmd_Argv(0);
if (menu) {
if (!strcmp(cmd, "end")) {
if (menu->nitems) {
List_Append(&ui_menus, &menu->entry);
} else {
Com_WPrintf("Menu entry without items\n");
menu->free(menu);
}
menu = NULL;
} else if (!strcmp(cmd, "title")) {
if (menu->title) {
Z_Free(menu->title);
}
menu->title = UI_CopyString(Cmd_Argv(1));
} else if (!strcmp(cmd, "plaque")) {
Parse_Plaque(menu);
} else if (!strcmp(cmd, "banner")) {
Parse_Banner(menu);
} else if (!strcmp(cmd, "background")) {
Parse_Background(menu);
} else if (!strcmp(cmd, "style")) {
Parse_Style(menu);
} else if (!strcmp(cmd, "values")) {
Parse_Spin(menu, MTYPE_SPINCONTROL);
} else if (!strcmp(cmd, "strings")) {
Parse_Spin(menu, MTYPE_STRINGS);
} else if (!strcmp(cmd, "pairs")) {
Parse_Pairs(menu);
} else if (!strcmp(cmd, "range")) {
Parse_Range(menu);
} else if (!strcmp(cmd, "action")) {
Parse_Action(menu);
} else if (!strcmp(cmd, "bitmap")) {
Parse_Bitmap(menu);
} else if (!strcmp(cmd, "bind")) {
Parse_Bind(menu);
} else if (!strcmp(cmd, "savegame")) {
Parse_Savegame(menu, MTYPE_SAVEGAME);
} else if (!strcmp(cmd, "loadgame")) {
Parse_Savegame(menu, MTYPE_LOADGAME);
} else if (!strcmp(cmd, "toggle")) {
Parse_Toggle(menu);
} else if (!strcmp(cmd, "field")) {
Parse_Field(menu);
} else if (!strcmp(cmd, "blank")) {
Parse_Blank(menu);
} else {
Com_WPrintf("Unknown keyword '%s'\n", cmd);
}
} else {
if (!strcmp(cmd, "begin")) {
char *s = Cmd_Argv(1);
if (!*s) {
Com_WPrintf("Expected menu name after '%s'\n", cmd);
break;
}
menu = UI_FindMenu(s);
if (menu) {
if (menu->free) {
menu->free(menu);
}
List_Remove(&menu->entry);
}
menu = UI_Mallocz(sizeof(*menu));
menu->name = UI_CopyString(s);
menu->push = Menu_Push;
menu->pop = Menu_Pop;
menu->free = Menu_Free;
menu->image = uis.backgroundHandle;
menu->color.u32 = uis.color.background.u32;
menu->transparent = uis.transparent;
} else if (!strcmp(cmd, "include")) {
char *s = Cmd_Argv(1);
if (!*s) {
Com_WPrintf("Expected file name after '%s'\n", cmd);
break;
}
if (depth == 16) {
Com_WPrintf("Includes too deeply nested\n");
} else {
Parse_File(s, depth + 1);
}
} else if (!strcmp(cmd, "color")) {
Parse_Color();
} else if (!strcmp(cmd, "background")) {
char *s = Cmd_Argv(1);
if (SCR_ParseColor(s, &uis.color.background)) {
uis.backgroundHandle = 0;
uis.transparent = uis.color.background.u8[3] != 255;
} else {
uis.backgroundHandle = R_RegisterPic(s);
uis.transparent = R_GetPicSize(NULL, NULL, uis.backgroundHandle);
}
} else if (!strcmp(cmd, "font")) {
uis.fontHandle = R_RegisterFont(Cmd_Argv(1));
} else if (!strcmp(cmd, "cursor")) {
uis.cursorHandle = R_RegisterPic(Cmd_Argv(1));
R_GetPicSize(&uis.cursorWidth,
&uis.cursorHeight, uis.cursorHandle);
} else if (!strcmp(cmd, "weapon")) {
Cmd_ArgvBuffer(1, uis.weaponModel, sizeof(uis.weaponModel));
} else {
Com_WPrintf("Unknown keyword '%s'\n", cmd);
break;
}
}
}
if (!p) {
break;
}
data = p + 1;
}
FS_FreeFile(raw);
if (menu) {
Com_WPrintf("Menu entry without 'end' terminator\n");
menu->free(menu);
}
return qtrue;
}
