DataRecovery::DataRecovery(Context* context)
: m_tempDir(NULL)
, m_backup(NULL)
, m_context(context)
{
// Check if there is already data to recover
const base::string existent_data_path = get_config_string("DataRecovery", "Path", "");
if (!existent_data_path.empty() &&
base::directory_exists(existent_data_path)) {
// Load the backup data.
m_tempDir = new base::TempDir();
m_tempDir->attach(existent_data_path);
m_backup = new Backup(existent_data_path);
}
else {
// Create a new directory to save the backup information.
m_tempDir = new base::TempDir(PACKAGE);
m_backup = new Backup(m_tempDir->path());
set_config_string("DataRecovery", "Path", m_tempDir->path().c_str());
flush_config_file();
}
m_context->addObserver(this);
}
void Savegame ()
{
set_config_file("Resources/Save.cfg");
set_config_int("Savegame","FireH",FireH);
set_config_int("Savegame","ThunderH",ThunderH);
set_config_int("Savegame","WindH",WindH);
set_config_int("Savegame","FreezeH",FreezeH);
set_config_int("Savegame","FireB",FireB);
set_config_int("Savegame","ThunderB",ThunderB);
set_config_int("Savegame","WindB",WindB);
set_config_int("Savegame","FreezeB",FreezeB);
set_config_int("Savegame","FireS",FireS);
set_config_int("Savegame","ThunderS",ThunderS);
set_config_int("Savegame","WindS",WindS);
set_config_int("Savegame","FreezeS",FreezeS);
set_config_int("Savegame","FireM",FireM);
set_config_int("Savegame","ThunderM",ThunderM);
set_config_int("Savegame","WindM",WindM);
set_config_int("Savegame","FreezeM",FreezeM);
set_config_int("Savegame","FireW",FireW);
set_config_int("Savegame","ThunderW",ThunderW);
set_config_int("Savegame","WindW",WindW);
set_config_int("Savegame","FreezeW",FreezeW);
flush_config_file();
}
int32_t write_config(void)
{
FILE *f = create_config_file(cs_conf);
if (!f)
return 1;
config_sections_save(oscam_conf, f, &cfg);
return flush_config_file(f, cs_conf);
}
void SetEffectsVolume(int volume)
{
int i;
for(i=0; i<voice_len_sfx; i++)
{
voice_set_volume(VoicesSfx[i], Effect_volume);
}
set_config_int("sound","Effect_volume",Effect_volume);
flush_config_file();
}
void SetMusicVolume(int volume)
{
int i;
for(i=0; i<voice_len_music; i++)
{
voice_set_volume(VoicesMusic[i], Music_volume);
}
set_config_int("sound","Music_volume",Music_volume);
flush_config_file();
}
void save_program_options()
{
set_config_int("general", "system_of_measurements", system_of_measurements);
if (display_mode & WINDOWED_MODE_SET)
set_config_int("general", "display_mode", WINDOWED_MODE);
else
set_config_int("general", "display_mode", FULL_SCREEN_MODE);
set_config_int("comm", "baud_rate", comport.baud_rate);
set_config_int("comm", "comport_number", comport.number);
flush_config_file();
}
void Preferences::save()
{
app::gen::GlobalPref::save();
for (auto& pair : m_tools)
pair.second->save();
for (auto& pair : m_docs)
serializeDocPref(pair.first, pair.second, true);
flush_config_file();
}
int32_t write_userdb(void)
{
struct s_auth *account;
FILE *f = create_config_file(cs_user);
if (!f)
return 1;
for (account = cfg.account; account; account = account->next) {
fprintf(f, "[account]\n");
config_list_apply_fixups(account_opts, account);
config_list_save(f, account_opts, account, cfg.http_full_cfg);
fprintf(f, "\n");
}
return flush_config_file(f, cs_user);
}
static void shut_down()
{
//clean up
flush_config_file();
write_log("\nShutting Down Serial Module... ");
serial_module_shutdown();
write_log("OK");
write_log("\nUnloading Data File... ");
unload_datafile(datafile);
write_log("OK");
write_log("\nShutting Down Allegro... ");
allegro_exit();
write_log("OK");
}
KeyHandler::~KeyHandler()
{
// Save key configuration
set_config_file("lander.ini");
set_config_int("keys","left",kLeft);
set_config_int("keys","right",kRight);
set_config_int("keys","max",kMax);
set_config_int("keys","med",kMed);
set_config_int("keys","min",kMin);
set_config_int("keys","all",kAll);
flush_config_file();
Logfile::log("-KeyHandler at 0x%x\n", this);
}
Configuration::~Configuration() {
// Save game information
set_config_file("lander.ini");
// todo: get the window's coordinates
set_config_int("window","posx",-1);
set_config_int("window","posy",-1);
set_config_int("window","fullscreen",fullscreen);
set_config_int("audio","sfx",sfx);
set_config_int("audio","music",music);
flush_config_file();
Logfile::log("Window and Audio config settings saved.\n");
Logfile::log("-Configuration at 0x%x\n", this);
}
int32_t write_services(void)
{
int32_t i;
struct s_sidtab *sidtab = cfg.sidtab;
char *ptr;
FILE *f = create_config_file(cs_sidt);
if(!f)
{ return 1; }
while(sidtab != NULL)
{
ptr = sidtab->label;
while(*ptr)
{
if(*ptr == ' ') { *ptr = '_'; }
ptr++;
}
fprintf(f, "[%s]\n", sidtab->label);
fprintf_conf(f, "caid", "%s", ""); // it should not have \n at the end
for(i = 0; i < sidtab->num_caid; i++)
{
if(i == 0) { fprintf(f, "%04X", sidtab->caid[i]); }
else { fprintf(f, ",%04X", sidtab->caid[i]); }
}
fputc((int)'\n', f);
fprintf_conf(f, "provid", "%s", ""); // it should not have \n at the end
for(i = 0; i < sidtab->num_provid; i++)
{
if(i == 0) { fprintf(f, "%06X", sidtab->provid[i]); }
else { fprintf(f, ",%06X", sidtab->provid[i]); }
}
fputc((int)'\n', f);
fprintf_conf(f, "srvid", "%s", ""); // it should not have \n at the end
for(i = 0; i < sidtab->num_srvid; i++)
{
if(i == 0) { fprintf(f, "%04X", sidtab->srvid[i]); }
else { fprintf(f, ",%04X", sidtab->srvid[i]); }
}
fprintf(f, "\n\n");
sidtab = sidtab->next;
}
return flush_config_file(f, cs_sidt);
}
int change_resolution(int fullscreen, int ResIndex)
{
int screen_mode;
if(!IsInstalled)
{
return install(fullscreen,800,480,32); //Security mesure
}
KillTextures();
allegro_gl_set(AGL_COLOR_DEPTH, Resolutions->mode[ResIndex].bpp);
if(fullscreen)
screen_mode=GFX_OPENGL_FULLSCREEN;
else
screen_mode=GFX_OPENGL_WINDOWED;
if (set_gfx_mode(screen_mode, Resolutions->mode[ResIndex].width,Resolutions->mode[ResIndex].height, 0, 0))
{
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to set graphic mode\n%s\n", allegro_error);
return 1;
}
SetOpenGL2D();
RefreshGLTextures();
AspectRatio=(float)SCREEN_W/(float)SCREEN_H;
Fullscreen=fullscreen;
Width=Resolutions->mode[ResIndex].width;
Height=Resolutions->mode[ResIndex].height;
depth=Resolutions->mode[ResIndex].bpp;
ResolutionIndex=ResIndex;
set_config_file("Resources/Setting.cfg");
set_config_int("graphics","Fullscreen",Fullscreen);
set_config_int("graphics","Width",Width);
set_config_int("graphics","Height",Height);
set_config_int("graphics","depth",depth);
set_config_int("graphics","ResolutionIndex",ResIndex);
flush_config_file();
LoadSavegame();
return 0;
}
void Preferences::serializeDocPref(const app::Document* doc, app::DocumentPreferences* docPref, bool save)
{
bool specific_file = false;
if (doc) {
if (!doc->isAssociatedToFile())
return;
push_config_state();
set_config_file(docConfigFileName(doc).c_str());
specific_file = true;
}
if (save)
docPref->save();
else
docPref->load();
if (specific_file) {
flush_config_file();
pop_config_state();
}
}
int32_t init_srvid(void)
{
int8_t new_syntax = 1;
FILE *fp = open_config_file("oscam.srvid2");
if(!fp)
{
fp = open_config_file(cs_srid);
if(fp)
{
new_syntax = 0;
}
}
if(!fp)
{
fp = create_config_file("oscam.srvid2");
if(fp)
{
flush_config_file(fp, "oscam.srvid2");
}
return 0;
}
int32_t nr = 0, i, j;
char *payload, *saveptr1 = NULL, *saveptr2 = NULL, *token;
const char *tmp;
if(!cs_malloc(&token, MAXLINESIZE))
{ return 0; }
struct s_srvid *srvid = NULL, *new_cfg_srvid[16], *last_srvid[16];
// A cache for strings within srvids. A checksum is calculated which is the start point in the array (some kind of primitive hash algo).
// From this point, a sequential search is done. This greatly reduces the amount of string comparisons.
const char **stringcache[1024];
int32_t allocated[1024] = { 0 };
int32_t used[1024] = { 0 };
struct timeb ts, te;
cs_ftime(&ts);
memset(last_srvid, 0, sizeof(last_srvid));
memset(new_cfg_srvid, 0, sizeof(new_cfg_srvid));
while(fgets(token, MAXLINESIZE, fp))
{
int32_t l, len = 0, len2, srvidtmp;
uint32_t k;
uint32_t pos;
char *srvidasc, *prov;
tmp = trim(token);
if(tmp[0] == '#') { continue; }
if((l = strlen(tmp)) < 6) { continue; }
if(!(srvidasc = strchr(token, ':'))) { continue; }
if(!(payload = strchr(token, '|'))) { continue; }
*payload++ = '\0';
if(!cs_malloc(&srvid, sizeof(struct s_srvid)))
{
NULLFREE(token);
fclose(fp);
return (1);
}
char tmptxt[128];
int32_t offset[4] = { -1, -1, -1, -1 };
char *ptr1 = NULL, *ptr2 = NULL;
const char *searchptr[4] = { NULL, NULL, NULL, NULL };
const char **ptrs[4] = { &srvid->prov, &srvid->name, &srvid->type, &srvid->desc };
uint32_t max_payload_length = MAXLINESIZE - (payload - token);
if(new_syntax)
{
ptrs[0] = &srvid->name;
ptrs[1] = &srvid->type;
ptrs[2] = &srvid->desc;
ptrs[3] = &srvid->prov;
}
// allow empty strings as "||"
if(payload[0] == '|' && (strlen(payload)+2 < max_payload_length))
{
memmove(payload+1, payload, strlen(payload)+1);
payload[0] = ' ';
}
for(k=1; ((k < max_payload_length) && (payload[k] != '\0')); k++)
{
if(payload[k-1] == '|' && payload[k] == '|')
{
if(strlen(payload+k)+2 < max_payload_length-k)
{
memmove(payload+k+1, payload+k, strlen(payload+k)+1);
payload[k] = ' ';
}
else
{
break;
}
}
}
for(i = 0, ptr1 = strtok_r(payload, "|", &saveptr1); ptr1 && (i < 4) ; ptr1 = strtok_r(NULL, "|", &saveptr1), ++i)
{
// check if string is in cache
len2 = strlen(ptr1);
pos = 0;
for(j = 0; j < len2; ++j) { pos += (uint8_t)ptr1[j]; }
pos = pos % 1024;
for(j = 0; j < used[pos]; ++j)
{
if(!strcmp(stringcache[pos][j], ptr1))
{
searchptr[i] = stringcache[pos][j];
break;
}
}
if(searchptr[i]) { continue; }
offset[i] = len;
cs_strncpy(tmptxt + len, trim(ptr1), sizeof(tmptxt) - len);
len += strlen(ptr1) + 1;
}
char *tmpptr = NULL;
if(len > 0 && !cs_malloc(&tmpptr, len))
{ continue; }
srvid->data = tmpptr;
if(len > 0) { memcpy(tmpptr, tmptxt, len); }
for(i = 0; i < 4; i++)
{
if(searchptr[i])
{
*ptrs[i] = searchptr[i];
continue;
}
if(offset[i] > -1)
{
*ptrs[i] = tmpptr + offset[i];
// store string in stringcache
tmp = *ptrs[i];
len2 = strlen(tmp);
pos = 0;
for(j = 0; j < len2; ++j) { pos += (uint8_t)tmp[j]; }
pos = pos % 1024;
if(used[pos] >= allocated[pos])
{
if(allocated[pos] == 0)
{
if(!cs_malloc(&stringcache[pos], 16 * sizeof(char *)))
{ break; }
}
else
{
if(!cs_realloc(&stringcache[pos], (allocated[pos] + 16) * sizeof(char *)))
{ break; }
}
allocated[pos] += 16;
}
stringcache[pos][used[pos]] = tmp;
used[pos] += 1;
}
}
*srvidasc++ = '\0';
if(new_syntax)
{ srvidtmp = dyn_word_atob(token) & 0xFFFF; }
else
{ srvidtmp = dyn_word_atob(srvidasc) & 0xFFFF; }
if(srvidtmp < 0)
{
NULLFREE(tmpptr);
NULLFREE(srvid);
continue;
}
else
{
srvid->srvid = srvidtmp;
}
srvid->ncaid = 0;
for(i = 0, ptr1 = strtok_r(new_syntax ? srvidasc : token, ",", &saveptr1); (ptr1); ptr1 = strtok_r(NULL, ",", &saveptr1), i++)
{
srvid->ncaid++;
}
if(!cs_malloc(&srvid->caid, sizeof(struct s_srvid_caid) * srvid->ncaid))
{
NULLFREE(tmpptr);
NULLFREE(srvid);
return 0;
}
ptr1 = new_syntax ? srvidasc : token;
for(i = 0; i < srvid->ncaid; i++)
{
prov = strchr(ptr1,'@');
srvid->caid[i].nprovid = 0;
if(prov)
{
if(prov[1] != '\0')
{
for(j = 0, ptr2 = strtok_r(prov+1, "@", &saveptr2); (ptr2); ptr2 = strtok_r(NULL, "@", &saveptr2), j++)
{
srvid->caid[i].nprovid++;
}
if(!cs_malloc(&srvid->caid[i].provid, sizeof(uint32_t) * srvid->caid[i].nprovid))
{
for(j = 0; j < i; j++)
{ NULLFREE(srvid->caid[j].provid); }
NULLFREE(srvid->caid);
NULLFREE(tmpptr);
NULLFREE(srvid);
return 0;
}
ptr2 = prov+1;
for(j = 0; j < srvid->caid[i].nprovid; j++)
{
srvid->caid[i].provid[j] = dyn_word_atob(ptr2) & 0xFFFFFF;
ptr2 = ptr2 + strlen(ptr2) + 1;
}
}
else
{
ptr2 = prov+2;
}
prov[0] = '\0';
}
srvid->caid[i].caid = dyn_word_atob(ptr1) & 0xFFFF;
if(prov)
{ ptr1 = ptr2; }
else
{ ptr1 = ptr1 + strlen(ptr1) + 1; }
}
nr++;
if(new_cfg_srvid[srvid->srvid >> 12])
{ last_srvid[srvid->srvid >> 12]->next = srvid; }
else
{ new_cfg_srvid[srvid->srvid >> 12] = srvid; }
last_srvid[srvid->srvid >> 12] = srvid;
}
