void TestStringSizeIs()
{
std::string file = "..\\Ch14\\data\\count-size";
std::vector<std::string> vec;
PushString(file, vec);
for (const auto& v : vec)
{
std::cout << v << " ";
}
std::cout << std::endl;
for (size_t i = 1; i != 10; i++)
{
StringSizeIs ssi(i);
std::cout << "The count of " << i << " size words is: " << count_if(vec.begin(), vec.end(), ssi) << std::endl;
}
}
/**
* Same as {@code System.arraycopy(src, 0, dest, 0, length)}.
*
* @param src the source array.
* @param srcSize the size of the source array.
* @param dest the destination array.
* @param destSize the size of the destination array.
* @param length the number of array elements to be copied.
*/
void CryptoHelper::copyByteArray(const byte src[], size_t srcSize, byte dest[], size_t destSize, size_t copySize)
{
ASSERT(src);
ASSERT(srcSize);
ASSERT(dest);
ASSERT(destSize);
ASSERT(srcSize >= copySize);
ASSERT(destSize >= copySize);
if(!src)
throw IllegalArgumentException("Source array cannot be nul");
if(!dest)
throw IllegalArgumentException("Destination array cannot be nul");
try
{
// Will throw if ptr wraps. T* and size_t causing trouble on Linux
SafeInt<size_t> ssi((size_t)src); ssi += srcSize;
g_dummy = (void*)(size_t)ssi;
SafeInt<size_t> dsi((size_t)dest); dsi += destSize;
g_dummy = (void*)(size_t)dsi;
}
catch(const SafeIntException&)
{
throw IllegalArgumentException("Source or destination array pointer wrap");
}
const size_t req = std::min(copySize, std::min(srcSize, destSize));
ASSERT(req > 0);
ASSERT(req == copySize);
if(req != copySize)
throw IllegalArgumentException("Copy size exceeds source or destination size");
ESAPI_MS_NO_WARNING(4996);
std::copy(src, src+req, dest);
ESAPI_MS_DEF_WARNING(4996);
}
CL_Error CL_RIFFImage::Locate(char const * iname, int const enum_id)
{
_LOGPRINT(("RIF File image finder called for %s, id %d\n",iname,enum_id));
if (!Env_Chunk)
_LOGPUT("WARNING! no .RIF file loaded\n");
if (!Env_Chunk) return CLE_RIFFERROR;
switch (imode)
{
case CLM_ATTACHEDPALETTE:
case CLM_16BIT:
case CLM_24BIT:
case CLM_32BIT:
case CLM_GLOBALPALETTE:
case CLM_TLTPALETTE:
break;
default:
_LOGPUT("WARNING! undefined video mode\n");
return CLE_INVALIDDXMODE;
}
// remove projectsubdirectory from start of image name if it is there
unsigned int const psdirlen = strlen(projectsubdirectory);
if (!strncmp(projectsubdirectory,iname,psdirlen))
iname += psdirlen;
List<Chunk *> envdl (Env_Chunk->lookup_child("REBENVDT"));
if (!envdl.size())
{
_LOGPUT("WARNING! no environment data chunk\n");
return CLE_RIFFERROR;
}
Environment_Data_Chunk * envd = (Environment_Data_Chunk *) envdl.first_entry();
CL_Error retval = CLE_OK;
Environment_Game_Mode_Chunk * egmc = 0;
if (game_mode)
{
if (*game_mode)
{
List<Chunk *> egmcl (envd->lookup_child("GAMEMODE"));
for (LIF<Chunk *> egmci(&egmcl); !egmci.done(); egmci.next())
{
Environment_Game_Mode_Chunk * egmcm = (Environment_Game_Mode_Chunk *) egmci();
if (egmcm->id_equals(game_mode))
{
egmc = egmcm;
break;
}
}
if (!egmc) retval = CLE_INVALIDGAMEMODE;
// only returns this error if the game mode cannot be found *and* the image is not listed
}
}
if (name)
{
delete[] name;
name = 0;
}
if (iname) name = strip_file_extension(strip_path(iname));
char * rcname = 0;
if (iname)
{
if (strchr(iname,'\\'))
{
rcname = new char[strlen(iname)+1];
strcpy(rcname,iname);
*strchr(rcname,'\\')=0;
}
else if (strchr(iname,'/'))
{
rcname = new char[strlen(iname)+1];
strcpy(rcname,iname);
*strchr(rcname,'/')=0;
}
}
if (egmc)
{
int shapefoundingm = rcname ? 0 : 1;
// Get the matching image 'Processor' chunk
List<Chunk *> micl = egmc->lookup_child("MATCHIMG");
Matching_Images_Chunk * mic = 0;
if (micl.size()) mic = (Matching_Images_Chunk *)micl.first_entry();
List<Chunk *> rcl = egmc->lookup_child("RIFCHILD");
for (LIF<Chunk *> rci(&rcl); !rci.done(); rci.next())
{
RIF_Child_Chunk * rcm = (RIF_Child_Chunk *) rci();
if (rcname)
{
if (_stricmp(rcname,rcm->rifname) && (*rcname || *rcm->filename))
continue;
shapefoundingm = 1;
}
for (LIF<BMP_Flags> bmpfi(&rcm->bmps); !bmpfi.done(); bmpfi.next())
{
BMP_Flags bmpft(bmpfi());
strip_file_extension(bmpft.filename);
if (iname ? !_stricmp(name,strip_path(bmpft.filename)) : enum_id == bmpft.enum_id)
{
// select image descriptor
ImageDescriptor const idsc
(
*rcm->filename ?
(IDscFlags)((bmpft.flags & ChunkBMPFlag_FixedPalette ?
IDSCF_FIXEDPALETTE
:
IDSCF_0)
|IDSCF_INCLUDED)
:
IDSCF_0,
bmpfi().filename,
*rcm->filename ? rcm->rifname : 0
);
ImageDescriptor const * p_idsc = &idsc;
if (mic) p_idsc = &mic->GetLoadImage(idsc);
else _LOGPRINT(("WARNING! no rule to find matching images in game mode %s\n",egmc->header->mode_identifier));
// load this image
GetPath(*p_idsc,envd,bmpft.flags);
if (fname)
{
if (rcname)
{
delete[] rcname;
rcname = 0;
}
flags.located = 1;
return CLE_OK;
}
}
}
}
List<Chunk *> ssc = egmc->lookup_child("SHBMPNAM");
for (LIF<Chunk *> ssi(&ssc); !ssi.done(); ssi.next())
{
External_Shape_BMPs_Store_Chunk * ss = (External_Shape_BMPs_Store_Chunk *) ssi();
if (rcname)
if (_stricmp(rcname,ss->shapename) && *rcname)
continue;
for (LIF<BMP_Name> bmpfi(&ss->bmps); !bmpfi.done(); bmpfi.next())
{
BMP_Name bmpft(bmpfi());
strip_file_extension(bmpft.filename);
if (iname ? !_stricmp(name,strip_path(bmpft.filename)) : enum_id == bmpft.enum_id)
{
// select image descriptor
ImageDescriptor const idsc
(
(IDscFlags)((bmpft.flags & ChunkBMPFlag_FixedPalette ?
IDSCF_FIXEDPALETTE
:
IDSCF_0)
|(ss->GetExtendedData()->flags & GBF_SPRITE ?
IDSCF_SPRITE
:
IDSCF_SUBSHAPE)
|IDSCF_INCLUDED),
bmpfi().filename,
ss->shapename,
bmpft.flags & ChunkBMPFlag_FixedPalette ? ss->rifname : 0
);
ImageDescriptor const * p_idsc = &idsc;
if (mic) p_idsc = &mic->GetLoadImage(idsc);
else _LOGPRINT(("WARNING! no rule to find matching images in game mode %s\n",egmc->header->mode_identifier));
#if TRY_OLD_DIRS // temporary until all textures move to SubShps/All directory
if (*p_idsc == idsc)
{
// select image descriptor
ImageDescriptor const idsc2
(
(IDscFlags)((bmpft.flags & ChunkBMPFlag_FixedPalette ?
IDSCF_FIXEDPALETTE
:
IDSCF_0)
|(ss->GetExtendedData()->flags & GBF_SPRITE ?
IDSCF_SPRITE
:
IDSCF_0)
|IDSCF_INCLUDED),
bmpfi().filename,
ss->shapename,
bmpft.flags & ChunkBMPFlag_FixedPalette ? ss->rifname : 0
);
ImageDescriptor const * p_idsc2 = &idsc2;
if (mic) p_idsc2 = &mic->GetLoadImage(idsc2);
else _LOGPRINT(("WARNING! no rule to find matching images in game mode %s\n",egmc->header->mode_identifier));
if (*p_idsc2 != idsc2)
{
_LOGPUT("WARNING! Not listed as in SubShps directory\n");
p_idsc = p_idsc2;
}
}
#endif
// load this image
GetPath(*p_idsc,envd,bmpft.flags);
if (fname)
{
if (rcname)
{
delete[] rcname;
rcname = 0;
}
flags.located = 1;
return CLE_OK;
}
}
}
}
if (rcname)
{
if (!shapefoundingm)
_LOGPRINT(("WARNING! shape/sprite %s not found in this RIF file\n",rcname));
else
_LOGPRINT(("WARNING! shape/sprite %s does not appear to list %s\n",rcname,name));
}
}
List<Chunk *> micl = envd->lookup_child("MATCHIMG");
Matching_Images_Chunk * mic_fix = 0;
Matching_Images_Chunk * mic_nrm = 0;
for (LIF<Chunk *> mici(&micl); !mici.done(); mici.next())
{
Matching_Images_Chunk * mic = (Matching_Images_Chunk *)mici();
if (mic->flags & MICF_FIXEDPALETTE)
mic_fix = mic;
else
mic_nrm = mic;
}
List<Chunk_With_Children *> shapesandsprites;
List<Chunk *> shlst = Env_Chunk->lookup_child("REBSHAPE");
for (LIF<Chunk *> shLIF(&shlst); !shLIF.done(); shLIF.next())
{
List<Chunk *> shxflst = ((Shape_Chunk *)shLIF())->lookup_child("SHPEXTFL");
if (shxflst.size())
{
shapesandsprites.add_entry( (Shape_External_File_Chunk *)shxflst.first_entry() );
}
}
shlst = Env_Chunk->lookup_child("RSPRITES");
if (shlst.size())
{
List<Chunk *> splst = ((Chunk_With_Children *)shlst.first_entry())->lookup_child("SPRIHEAD");
for (LIF<Chunk *> spLIF(&splst); !spLIF.done(); spLIF.next())
{
shapesandsprites.add_entry( (Chunk_With_Children *)spLIF() );
}
}
int shapefound = rcname ? 0 : 1;
for (LIF<Chunk_With_Children *> sasLIF(&shapesandsprites); !sasLIF.done(); sasLIF.next())
{
char * subrifname = riff_basename(sasLIF());
if (rcname)
{
if (_stricmp(subrifname,rcname)) // must match shapes name exactly
{
delete[] subrifname;
continue;
}
shapefound = 1;
}
List<Chunk *> blsclst = sasLIF()->lookup_child("BMPLSTST");
if (blsclst.size())
{
Bitmap_List_Store_Chunk * gbnc = (Bitmap_List_Store_Chunk *) blsclst.first_entry();
for (LIF<BMP_Name> bmpni(&gbnc->bmps); !bmpni.done(); bmpni.next())
{
BMP_Name bmpnt(bmpni());
strip_file_extension(bmpnt.filename);
if (iname ? !_stricmp(name,strip_path(bmpnt.filename)) : enum_id == bmpnt.enum_id)
{
// select image descriptor
char * riffname = riff_basename(envd);
ImageDescriptor const idsc
(
(IDscFlags)((bmpnt.flags & ChunkBMPFlag_FixedPalette ?
IDSCF_FIXEDPALETTE
:
IDSCF_0)
|(gbnc->GetExtendedData()->flags & GBF_SPRITE ?
IDSCF_SPRITE
:
IDSCF_SUBSHAPE)
|IDSCF_INCLUDED),
bmpni().filename,
subrifname,
bmpnt.flags & ChunkBMPFlag_FixedPalette ? riffname : 0
);
ImageDescriptor const * p_idsc = &idsc;
delete[] riffname;
if (bmpnt.flags & ChunkBMPFlag_FixedPalette)
{
if (mic_fix) p_idsc = &mic_fix->GetLoadImage(idsc);
else _LOGPUT("WARNING! no rule to find fixed palette matching images in environment data\n");
}
else
{
if (mic_nrm) p_idsc = &mic_nrm->GetLoadImage(idsc);
else _LOGPUT("WARNING! no rule to find matching images in environment data (interface engine?)\n");
}
#if TRY_OLD_DIRS // temporary until all textures move to SubShps/All directory
if (*p_idsc == idsc)
{
// select image descriptor
char * riffname = riff_basename(envd);
ImageDescriptor const idsc2
(
(IDscFlags)((bmpnt.flags & ChunkBMPFlag_FixedPalette ?
IDSCF_FIXEDPALETTE
:
IDSCF_0)
|(gbnc->GetExtendedData()->flags & GBF_SPRITE ?
IDSCF_SPRITE
:
IDSCF_0)
|IDSCF_INCLUDED),
bmpni().filename,
subrifname,
bmpnt.flags & ChunkBMPFlag_FixedPalette ? riffname : 0
);
ImageDescriptor const * p_idsc2 = &idsc2;
delete[] riffname;
if (bmpnt.flags & ChunkBMPFlag_FixedPalette)
{
if (mic_fix) p_idsc2 = &mic_fix->GetLoadImage(idsc2);
else _LOGPUT("WARNING! no rule to find fixed palette matching images in environment data\n");
}
else
{
if (mic_nrm) p_idsc2 = &mic_nrm->GetLoadImage(idsc2);
else _LOGPUT("WARNING! no rule to find matching images in environment data (interface engine?)\n");
}
if (*p_idsc2 != idsc2)
{
_LOGPUT("WARNING! Not listed as in SubShps directory\n");
p_idsc = p_idsc2;
}
}
#endif
// load this image
GetPath(*p_idsc,envd,bmpnt.flags);
if (fname)
{
delete[] subrifname;
if (rcname)
{
delete[] rcname;
rcname = 0;
}
flags.located = 1;
return CLE_OK;
}
}
}
}
delete[] subrifname;
}
if (rcname)
{
if (!shapefound)
_LOGPRINT(("WARNING! shape/sprite %s not found in this RIF file\n",rcname));
else
_LOGPRINT(("WARNING! shape/sprite %s does not appear to list %s\n",rcname,name));
delete[] rcname;
rcname = 0;
}
// not found in game textures, so look in default
else // but only if there is no virtual shape directory
{
List<Chunk *> gbncl = envd->lookup_child("BMPNAMES");
if (gbncl.size())
{
Global_BMP_Name_Chunk * gbnc = (Global_BMP_Name_Chunk *) gbncl.first_entry();
for (LIF<BMP_Name> bmpni(&gbnc->bmps); !bmpni.done(); bmpni.next())
{
BMP_Name bmpnt(bmpni());
strip_file_extension(bmpnt.filename);
if (iname ? !_stricmp(name,strip_path(bmpnt.filename)) : enum_id == bmpnt.enum_id)
{
// select image descriptor
ImageDescriptor const idsc (bmpnt.flags & ChunkBMPFlag_FixedPalette ? IDSCF_FIXEDPALETTE : IDSCF_0, bmpni().filename);
ImageDescriptor const * p_idsc = &idsc;
if (bmpnt.flags & ChunkBMPFlag_FixedPalette)
{
if (mic_fix) p_idsc = &mic_fix->GetLoadImage(idsc);
else _LOGPUT("WARNING! no rule to find fixed palette matching images in environment data\n");
}
else
{
if (mic_nrm) p_idsc = &mic_nrm->GetLoadImage(idsc);
else _LOGPUT("WARNING! no rule to find matching images in environment data (interface engine?)\n");
}
// load this image
GetPath(*p_idsc,envd,bmpnt.flags);
if (fname)
{
flags.located = 1;
return CLE_OK;
}
}
}
}
}
if (retval != CLE_OK) return retval;
return CLE_FINDERROR;
}
void
setconfig (char *name, char *value, struct config_data *cfg)
{
int len, dstlen;
void *src, *dst;
char tmpname[128];
int i;
#define CONF0(NAMESTR, CFG) \
setdst (name, NAMESTR, &CFG, sizeof CFG, &dst, &dstlen)
#define CONF(NAME) \
CONF0 (#NAME, cfg->NAME)
#define CONF1(NAMEFMT, ARG1, CFG) \
snprintf (tmpname, sizeof tmpname, NAMEFMT, ARG1), \
CONF0 (tmpname, CFG)
name = strdup (name);
len = strlen (value);
src = strdup (value);
dst = NULL;
dstlen = 0;
/* idman */
ss (file, &name, &src, &len, "idman.crl01File", "idman.crl01");
ss (file, &name, &src, &len, "idman.crl02File", "idman.crl02");
ss (file, &name, &src, &len, "idman.crl03File", "idman.crl03");
ss (file, &name, &src, &len, "idman.pkc01File", "idman.pkc01");
ss (file, &name, &src, &len, "idman.pkc02File", "idman.pkc02");
ss (file, &name, &src, &len, "idman.pkc03File", "idman.pkc03");
ss (uintnum, &name, &src, &len, "idman.randomSeedSize",
"idman.randomSeedSize");
ss (uintnum, &name, &src, &len, "idman.maxPinLen", "idman.maxPinLen");
ss (uintnum, &name, &src, &len, "idman.minPinLen", "idman.minPinLen");
ss (authmethod, &name, &src, &len, "idman.authenticationMethod",
"idman.authenticationMethod");
/* VPN */
ss (file, &name, &src, &len, "vpn.vpnCertFileV4", "vpn.vpnCertV4");
ss (file, &name, &src, &len, "vpn.vpnCaCertFileV4", "vpn.vpnCaCertV4");
ss (file, &name, &src, &len, "vpn.vpnRsaKeyFileV4", "vpn.vpnRsaKeyV4");
ss (file, &name, &src, &len, "vpn.vpnCertFileV6", "vpn.vpnCertV6");
ss (file, &name, &src, &len, "vpn.vpnCaCertFileV6", "vpn.vpnCaCertV6");
ss (file, &name, &src, &len, "vpn.vpnRsaKeyFileV6", "vpn.vpnRsaKeyV6");
/* storage */
for (i = 0; i < NUM_OF_STORAGE_KEYS; i++)
ssi (keyplace, &name, &src, &len,
"storage.encryptionKey%d.place", "storage.keys[%d]", i);
for (i = 0; i < NUM_OF_STORAGE_KEYS_CONF; i++) {
ssi (storage_conf_guid, &name, &src, &len,
"storage.conf%d.guid", "storage.keys_conf[%d].guid", i);
ssi (storage_conf_type, &name, &src, &len,
"storage.conf%d.type", "storage.keys_conf[%d].type", i);
ssi (u8num, &name, &src, &len, "storage.conf%d.host_id",
"storage.keys_conf[%d].host_id", i);
ssi (u16num, &name, &src, &len, "storage.conf%d.device_id",
"storage.keys_conf[%d].device_id", i);
ssi (u64num, &name, &src, &len, "storage.conf%d.lba_low",
"storage.keys_conf[%d].lba_low", i);
ssi (u64num, &name, &src, &len, "storage.conf%d.lba_high",
"storage.keys_conf[%d].lba_high", i);
ssi (noconv, &name, &src, &len, "storage.conf%d.crypto_name",
"storage.keys_conf[%d].crypto_name", i);
ssi (u8num, &name, &src, &len, "storage.conf%d.keyindex",
"storage.keys_conf[%d].keyindex", i);
ssi (u16num, &name, &src, &len, "storage.conf%d.keybits",
"storage.keys_conf[%d].keybits", i);
ssi (noconv, &name, &src, &len, "storage.conf%d.extend",
"storage.keys_conf[%d].extend", i);
}
/* vmm */
ss (uintnum, &name, &src, &len, "vmm.f11panic", "vmm.f11panic");
ss (uintnum, &name, &src, &len, "vmm.f12msg", "vmm.f12msg");
ss (uintnum, &name, &src, &len, "vmm.auto_reboot", "vmm.auto_reboot");
ss (uintnum, &name, &src, &len, "vmm.shell", "vmm.shell");
ss (uintnum, &name, &src, &len, "vmm.dbgsh", "vmm.dbgsh");
ss (uintnum, &name, &src, &len, "vmm.status", "vmm.status");
ss (uintnum, &name, &src, &len, "vmm.boot_active", "vmm.boot_active");
ss (uintnum, &name, &src, &len, "vmm.tty_pro1000", "vmm.tty_pro1000");
ss (mac_addr, &name, &src, &len, "vmm.tty_pro1000_mac_address",
"vmm.tty_pro1000_mac_address");
ss (uintnum, &name, &src, &len, "vmm.tty_rtl8169", "vmm.tty_rtl8169");
ss (mac_addr, &name, &src, &len, "vmm.tty_rtl8169_mac_address",
"vmm.tty_rtl8169_mac_address");
ss (uintnum, &name, &src, &len, "vmm.driver.ata", "vmm.driver.ata");
ss (uintnum, &name, &src, &len, "vmm.driver.usb.uhci", "vmm.driver.usb.uhci");
ss (uintnum, &name, &src, &len, "vmm.driver.usb.ehci", "vmm.driver.usb.ehci");
ss (uintnum, &name, &src, &len, "vmm.driver.concealEHCI",
"vmm.driver.concealEHCI");
ss (uintnum, &name, &src, &len, "vmm.driver.conceal1394",
"vmm.driver.conceal1394");
ss (uintnum, &name, &src, &len, "vmm.driver.concealPRO1000",
"vmm.driver.concealPRO1000");
ss (uintnum, &name, &src, &len, "vmm.driver.vpn.PRO100",
"vmm.driver.vpn.PRO100");
ss (uintnum, &name, &src, &len, "vmm.driver.vpn.PRO1000",
"vmm.driver.vpn.PRO1000");
ss (uintnum, &name, &src, &len, "vmm.driver.vpn.RTL8169",
"vmm.driver.vpn.RTL8169");
ss (uintnum, &name, &src, &len, "vmm.driver.vpn.ve",
"vmm.driver.vpn.ve");
ss (uintnum, &name, &src, &len, "vmm.iccard.enable",
"vmm.iccard.enable");
ss (uintnum, &name, &src, &len, "vmm.iccard.status",
"vmm.iccard.status");
/* idman */
CONF (idman.crl01);
CONF (idman.crl02);
CONF (idman.crl03);
CONF (idman.pkc01);
CONF (idman.pkc02);
CONF (idman.pkc03);
CONF (idman.randomSeedSize);
CONF (idman.maxPinLen);
CONF (idman.minPinLen);
CONF (idman.authenticationMethod);
/* VPN */
CONF (vpn.mode);
CONF (vpn.virtualGatewayMacAddress);
CONF (vpn.bindV4);
CONF (vpn.guestIpAddressV4);
CONF (vpn.guestIpSubnetV4);
CONF (vpn.guestMtuV4);
CONF (vpn.guestVirtualGatewayIpAddressV4);
CONF (vpn.dhcpV4);
CONF (vpn.dhcpLeaseExpiresV4);
CONF (vpn.dhcpDnsV4);
CONF (vpn.dhcpDomainV4);
CONF (vpn.adjustTcpMssV4);
CONF (vpn.hostIpAddressV4);
CONF (vpn.hostIpSubnetV4);
CONF (vpn.hostMtuV4);
CONF (vpn.hostIpDefaultGatewayV4);
CONF (vpn.optionV4ArpExpires);
CONF (vpn.optionV4ArpDontUpdateExpires);
CONF (vpn.vpnGatewayAddressV4);
CONF (vpn.vpnAuthMethodV4);
CONF (vpn.vpnPasswordV4);
CONF (vpn.vpnIdStringV4);
CONF (vpn.vpnCertV4);
CONF (vpn.vpnCaCertV4);
CONF (vpn.vpnRsaKeyV4);
CONF (vpn.vpnSpecifyIssuerV4);
CONF (vpn.vpnPhase1CryptoV4);
CONF (vpn.vpnPhase1HashV4);
CONF (vpn.vpnPhase1LifeSecondsV4);
CONF (vpn.vpnPhase1LifeKilobytesV4);
CONF (vpn.vpnWaitPhase2BlankSpanV4);
CONF (vpn.vpnPhase2CryptoV4);
CONF (vpn.vpnPhase2HashV4);
CONF (vpn.vpnPhase2LifeSecondsV4);
CONF (vpn.vpnPhase2LifeKilobytesV4);
CONF (vpn.vpnConnectTimeoutV4);
CONF (vpn.vpnIdleTimeoutV4);
CONF (vpn.vpnPingTargetV4);
CONF (vpn.vpnPingIntervalV4);
CONF (vpn.vpnPingMsgSizeV4);
CONF (vpn.bindV6);
CONF (vpn.guestIpAddressPrefixV6);
CONF (vpn.guestIpAddressSubnetV6);
CONF (vpn.guestMtuV6);
CONF (vpn.guestVirtualGatewayIpAddressV6);
CONF (vpn.raV6);
CONF (vpn.raLifetimeV6);
CONF (vpn.raDnsV6);
CONF (vpn.hostIpAddressV6);
CONF (vpn.hostIpAddressSubnetV6);
CONF (vpn.hostMtuV6);
CONF (vpn.hostIpDefaultGatewayV6);
CONF (vpn.optionV6NeighborExpires);
CONF (vpn.vpnGatewayAddressV6);
CONF (vpn.vpnAuthMethodV6);
CONF (vpn.vpnPasswordV6);
CONF (vpn.vpnIdStringV6);
CONF (vpn.vpnCertV6);
CONF (vpn.vpnCaCertV6);
CONF (vpn.vpnRsaKeyV6);
CONF (vpn.vpnSpecifyIssuerV6);
CONF (vpn.vpnPhase1CryptoV6);
CONF (vpn.vpnPhase1HashV6);
CONF (vpn.vpnPhase1LifeSecondsV6);
CONF (vpn.vpnPhase1LifeKilobytesV6);
CONF (vpn.vpnWaitPhase2BlankSpanV6);
CONF (vpn.vpnPhase2CryptoV6);
CONF (vpn.vpnPhase2HashV6);
CONF (vpn.vpnPhase2LifeSecondsV6);
CONF (vpn.vpnPhase2LifeKilobytesV6);
CONF (vpn.vpnPhase2StrictIdV6);
CONF (vpn.vpnConnectTimeoutV6);
CONF (vpn.vpnIdleTimeoutV6);
CONF (vpn.vpnPingTargetV6);
CONF (vpn.vpnPingIntervalV6);
CONF (vpn.vpnPingMsgSizeV6);
/* storage */
for (i = 0; i < NUM_OF_STORAGE_KEYS; i++)
CONF1 ("storage.keys[%d]", i, cfg->storage.keys[i]);
for (i = 0; i < NUM_OF_STORAGE_KEYS_CONF; i++) {
CONF1 ("storage.keys_conf[%d].guid", i,
cfg->storage.keys_conf[i].guid);
CONF1 ("storage.keys_conf[%d].type", i,
cfg->storage.keys_conf[i].type);
CONF1 ("storage.keys_conf[%d].host_id", i,
cfg->storage.keys_conf[i].host_id);
CONF1 ("storage.keys_conf[%d].device_id", i,
cfg->storage.keys_conf[i].device_id);
CONF1 ("storage.keys_conf[%d].lba_low", i,
cfg->storage.keys_conf[i].lba_low);
CONF1 ("storage.keys_conf[%d].lba_high", i,
cfg->storage.keys_conf[i].lba_high);
CONF1 ("storage.keys_conf[%d].crypto_name", i,
cfg->storage.keys_conf[i].crypto_name);
CONF1 ("storage.keys_conf[%d].keyindex", i,
cfg->storage.keys_conf[i].keyindex);
CONF1 ("storage.keys_conf[%d].keybits", i,
cfg->storage.keys_conf[i].keybits);
CONF1 ("storage.keys_conf[%d].extend", i,
cfg->storage.keys_conf[i].extend);
}
/* vmm */
CONF (vmm.f11panic);
CONF (vmm.f12msg);
CONF (vmm.auto_reboot);
CONF (vmm.shell);
CONF (vmm.dbgsh);
CONF (vmm.status);
CONF (vmm.boot_active);
CONF (vmm.tty_pro1000);
CONF (vmm.tty_pro1000_mac_address);
CONF (vmm.tty_rtl8169);
CONF (vmm.tty_rtl8169_mac_address);
CONF (vmm.driver.ata);
CONF (vmm.driver.usb.uhci);
CONF (vmm.driver.usb.ehci);
CONF (vmm.driver.concealEHCI);
CONF (vmm.driver.conceal1394);
CONF (vmm.driver.concealPRO1000);
CONF (vmm.driver.vpn.PRO100);
CONF (vmm.driver.vpn.PRO1000);
CONF (vmm.driver.vpn.RTL8169);
CONF (vmm.driver.vpn.ve);
CONF (vmm.driver.pci_conceal);
CONF (vmm.iccard.enable);
CONF (vmm.iccard.status);
if (!dst) {
fprintf (stderr, "unknown config \"%s\"\n", name);
exit (EXIT_FAILURE);
}
if (len > dstlen) {
fprintf (stderr, "config \"%s\" is too long\n", name);
exit (EXIT_FAILURE);
}
memset (dst, 0, dstlen);
memcpy (dst, src, len);
free (name);
free (src);
}
proc_t *scheduler_next(proc_t *current, int reds_left)
{
set_phase(PHASE_NEXT);
uint32_t reds_used = SLICE_REDUCTIONS -reds_left;
ssi(SYS_STATS_CTX_SWITCHES);
ssa(SYS_STATS_REDUCTIONS, reds_used);
current->total_reds += reds_used;
proc_t *next_proc = 0;
uint64_t ticks = monotonic_clock(); // freeze time
assert(current->my_queue == MY_QUEUE_NONE);
#ifdef PROFILE_HARNESS
static uint64_t proc_started_ns = 0;
if (proc_started_ns != 0)
prof_slice_complete(current->pid,
current->result.what, current->cap.ip, proc_started_ns, ticks);
#endif
proc_t *expired;
while ((expired = wait_list_expired(&queues.on_timed_receive, ticks)) != 0)
{
expired->cap.ip = expired->result.jump_to;
if (scheduler_park_runnable_N(expired) < 0)
scheduler_exit_process(expired, A_NO_MEMORY);
}
int memory_exhausted = 0;
switch (current->result.what)
{
case SLICE_RESULT_YIELD:
if (scheduler_park_runnable_N(current) < 0)
memory_exhausted = 1;
break;
case SLICE_RESULT_WAIT:
if (current->result.until_when == LING_INFINITY)
{
if (proc_list_put_N(&queues.on_infinite_receive, current) < 0)
memory_exhausted = 1;
else
current->my_queue = MY_QUEUE_INF_WAIT;
}
else
{
if (wait_list_put_N(&queues.on_timed_receive,
current, current->result.until_when) < 0)
memory_exhausted = 1;
else
current->my_queue = MY_QUEUE_TIMED_WAIT;
}
break;
case SLICE_RESULT_DONE:
scheduler_exit_process(current, A_NORMAL);
break;
case SLICE_RESULT_PURGE_PROCS:
// purge_module() call may have detected processes lingering on the old
// code - terminate them
if (scheduler_park_runnable_N(current) < 0)
memory_exhausted = 1;
for (int i = 0; i < num_purged; i++)
if (scheduler_signal_exit_N(purgatory[i], current->pid, A_KILL) < 0)
memory_exhausted = 1;
num_purged = 0;
break;
case SLICE_RESULT_EXIT:
scheduler_exit_process(current, current->result.reason);
// what about the returned value when main function just returns?
break;
case SLICE_RESULT_EXIT2:
// only needed to implement erlang:exit/2
if (scheduler_park_runnable_N(current) < 0 ||
(scheduler_signal_exit_N(current->result.victim,
current->pid,
current->result.reason2) < 0))
memory_exhausted = 1;
break;
case SLICE_RESULT_ERROR:
scheduler_exit_process(current, current->result.reason);
// how is this different from SLICE_RESULT_EXIT?
break;
case SLICE_RESULT_THROW:
scheduler_exit_process(current, current->result.reason);
// how is this different from SLICE_RESULT_EXIT?
break;
default:
{
assert(current->result.what == SLICE_RESULT_OUTLET_CLOSE);
if (scheduler_park_runnable_N(current) < 0)
memory_exhausted = 1;
outlet_t *closing = current->result.closing;
//assert(is_atom(current->result.why));
outlet_close(closing, current->result.why);
break;
}
}
if (memory_exhausted)
scheduler_exit_process(current, A_NO_MEMORY);
do_pending:
ticks = monotonic_clock();
while ((expired = wait_list_expired(&queues.on_timed_receive, ticks)) != 0)
{
expired->cap.ip = expired->result.jump_to;
if (scheduler_park_runnable_N(expired) < 0)
scheduler_exit_process(expired, A_NO_MEMORY);
}
set_phase(PHASE_EVENTS);
// software events/timeouts
net_check_timeouts();
etimer_expired(ticks);
// 'hardware' events
int nr_fired = events_do_pending();
update_event_times(nr_fired, ticks);
set_phase(PHASE_NEXT);
// select_runnable
if (!proc_queue_is_empty(&queues.high_prio))
next_proc = proc_queue_get(&queues.high_prio);
else if (normal_count < NORMAL_ADVANTAGE)
{
if (!proc_queue_is_empty(&queues.normal_prio))
next_proc = proc_queue_get(&queues.normal_prio);
else if (!proc_queue_is_empty(&queues.low_prio))
next_proc = proc_queue_get(&queues.low_prio);
normal_count++;
}
else
{
if (!proc_queue_is_empty(&queues.low_prio))
next_proc = proc_queue_get(&queues.low_prio);
else if (!proc_queue_is_empty(&queues.normal_prio))
next_proc = proc_queue_get(&queues.normal_prio);
normal_count = 0;
}
if (next_proc == 0)
{
// no runnable processes; poll for events from all three sources
// Beware that events_poll() reports events 5us after they occur. If
// a new event is expected very soon we are better off polling event
// bits manually (using events_do_pending())
// Devote a portion of time until the next event to gc waiting processes
garbage_collect_waiting_processes(expect_event_in_ns /2);
if (expect_event_in_ns < MANUAL_POLLING_THRESHOLD)
goto do_pending;
uint64_t next_ticks = wait_list_timeout(&queues.on_timed_receive);
uint64_t closest_timeout = etimer_closest_timeout();
if (closest_timeout < next_ticks)
next_ticks = closest_timeout;
closest_timeout = lwip_closest_timeout();
if (closest_timeout < next_ticks)
next_ticks = closest_timeout;
scheduler_runtime_update();
events_poll(next_ticks); // LING_INFINITY is big enough
scheduler_runtime_start();
goto do_pending;
}
next_proc->my_queue = MY_QUEUE_NONE;
//TODO: update stats
#ifdef PROFILE_HARNESS
proc_started_ns = ticks;
#endif
set_phase(PHASE_ERLANG);
return next_proc;
}
void IMG_createslice(Image_t *img, const char *name, uaddr_t addr) {
assert(img != NULL);
#if 1
//printf("creating slice for %s\n", name);
// Create module if not created yet
sqlq_t sqsel(img->db, "SELECT modid FROM tab_module WHERE name = @N");
sqsel.bind_str(1, name);
int modid = sqsel.answer();
if (modid == 0) {
sqlq_t ssi(img->db, "INSERT INTO tab_module(name) VALUES(@A)");
ssi.bind_str(1, name);
ssi.run();
modid = sqsel.answer();
if (modid == 0) {
printf("ERROR\n");
}
}
// get segment for this slice
sqlq_t segq(img->db, "SELECT segid FROM tab_segment WHERE address <= @A AND address + size > @B");
segq.bind_int(1, addr);
segq.bind_int(2, addr);
int segid = segq.answer();
if (segid == 0) {
return;
}
// adjust previous slices' sizes
int secid = uaddr_sec(addr);
int secsize = IMG_getsecsize(img, secid);
uaddr_t secstart = uaddr_mk(secid, 0);
uaddr_t secend = uaddr_mk(secid, secsize);
// passa por todos os slices deste seg
sqlq_t sq(img->db, "SELECT address,size FROM tab_modslice WHERE address >= @A AND address < @B ORDER BY address ASC");
sq.bind_int(1, secstart);
sq.bind_int(2, secend);
int size = secend - addr;
while(sq.step()) {
int this_start = sq.col_int(0);
int this_size = sq.col_int(1);
int this_end = this_start + this_size;
if (this_end <= addr) {
// do nothing
// Achei um slice antes do meu que tem que ser cortado
} else if (this_start < addr && this_end > addr) {
//if (this_start > addr) {
// muda o size do atual
sqlq_t upd(img->db, "update tab_modslice set size=@a where address=@b");
uaddr_t this_new_end = addr;
int this_new_size = this_new_end - this_start;
upd.bind_int(1, this_new_size);
upd.bind_int(2, this_start);
if (!upd.run()) {
printf("; update slice size error\n");
}
//size = this_end - addr;
//break;
// Achei um slice depois do meu, entao vou me aparar
} else if (addr < this_start) {
size = this_start - addr;
break;
} else {
printf("SLICE POSITIONING ERROR\n");
}
}
// Insert this slice
sqlq_t ins(img->db, "INSERT INTO tab_modslice(address, size, module, segment) VALUES(@A, @B, @C, @D)");
ins.bind_int(1, addr);
ins.bind_int(2, size);
ins.bind_int(3, modid);
ins.bind_int(4, segid);
if (!ins.run()) {
printf("; Create slice error\n");
} else {
//printf("; Created slice %s\n", name);
}
#endif
#if 0
sqlq_t s(img->db, "INSERT INTO tab_modslice(address, size, module, segment) VALUES(@A, @B, @C, @D, @E, @F)");
s.bind_str(1, name);
s.bind_str(2, sclass);
s.bind_int(3, align);
s.bind_int(4, use);
s.bind_int(5, addr);
s.bind_int(6, priority);
if (!s.run()) {
printf("; Create segment error\n");
} else {
printf("; Created segment %s\n", name);
}
#endif
}
