bool Layer::Load(File* f)
{
if (!f->GetDataLine(&m_name))
{
f->ReportError("Failed to load layer group name");
return false;
}
int numTextures = 0;
if (!f->GetInteger(&numTextures))
{
f->ReportError("Failed to load num textures for layer group " + m_name);
return false;
}
for (int i = 0; i < numTextures; i++)
{
std::string t;
if (!f->GetDataLine(&t))
{
f->ReportError("Failed to load texture name for layer group " + m_name);
return false;
}
Texture* tex = (Texture*)TheResourceManager::Instance()->GetRes(t);
if (!tex)
{
f->ReportError("Failed to load texture " + t + " for layer group " + m_name);
return false;
}
m_textures.push_back(tex);
}
std::cout << "Layer group: loaded " << numTextures << " textures ok.\n";
int numColours = 0;
if (!f->GetInteger(&numColours))
{
f->ReportError("Failed to load num colours for layer group " + m_name);
return false;
}
for (int i = 0; i < numColours; i++)
{
std::string s;
if (!f->GetDataLine(&s))
{
f->ReportError("Failed to load colour for layer group " + m_name);
return false;
}
Colour col = FromHexString(s); // TODO error checking ?
m_colours.push_back(col);
}
std::cout << "Layer group: loaded " << numColours << " colours ok.\n";
return true;
}
IPDriver(const System::Net::IPEndpoint& ep) {
FromHexString("452566E212031284966AB354F7F6CA04",(unsigned char*)id.value,2*16);
sock = System::Net::CreateUDPSocket(ep); //Put a sock in itself.
System::Net::IPEndpoint bound;
sock->GetLocalEndpoint(bound);
for(size_t i = 0;i<3;i++) {
if(routerip) {
gupnp_simple_igd_add_port(gateway.igdContext,"UDP",0,routerip,bound.port,60,"GlobalGrid rules!");
printf("GlobalGrid protocol registered on physical router\n");
break;
}
sleep(1);
}
}
bool Rage::Color::FromString(std::string const &colorString)
{
bool wasSuccessful = false;
if (!colorString.empty())
{
if (colorString.front() == '#')
{
wasSuccessful = FromHexString(colorString.substr(1));
}
else
{
wasSuccessful = FromCommaString(colorString);
}
}
if ( !wasSuccessful )
{
r = g = b = a = 1;
}
return wasSuccessful;
}
bool CStringUtils::FromHexString( const std::wstring& src, BYTE* pDest )
{
std::string s = std::string(src.begin(), src.end());
return FromHexString(s, pDest);
}
int main(int argc, char** argv) {
void* privkey = 0;
bool(*fptr)(void*,unsigned char*,size_t);
void* thisptr = System::ABI::C([&](unsigned char* data, size_t len){
privkey = RSA_Key(data,len);
if(privkey == 0) {
printf("Unable to decode private key with size %i.\n",(int)len);
abort();
}
return false;
},fptr);
DB_EnumPrivateKeys(thisptr,fptr);
if(privkey == 0) {
printf("Generating 4096-bit RSA key. This may take a while....\n");
privkey = RSA_GenKey(4096);
char thumbprint[33];
thumbprint[32] = 0;
RSA_thumbprint(privkey,thumbprint);
unsigned char* cert;
size_t certlen;
void* buffy = RSA_Export(privkey,true);
GlobalGrid::Buffer_Get(buffy,(void**)&cert,&certlen);
printf("Generated certificate taking %i bytes\n",(int)certlen);
DB_Insert_Certificate(thumbprint,cert,certlen,true);
GlobalGrid::GGObject_Free(buffy);
}
if(argc>1) {
if(strcmp(argv[1],"export") == 0) {
//Export public key
void* buffy = RSA_Export(privkey,false);
unsigned char* mander;
size_t sz;
GlobalGrid::Buffer_Get(buffy,&mander,&sz);
write(STDOUT_FILENO,mander,sz);
return 0;
}else {
if(strcmp(argv[1],"import") == 0) {
unsigned char mander[4096];
int len = 0;
int cl;
while((cl = read(STDIN_FILENO,mander+len,4096-len))>0) {
len+=cl;
printf("Read\n");
}
void* key = RSA_Key(mander,len);
if(key == 0) {
printf("Invalid key. Cannot import.\n");
return -1;
}
char thumbprint[33];
thumbprint[32] = 0;
RSA_thumbprint(key,thumbprint);
DB_Insert_Certificate(thumbprint,mander,len,false);
printf("Successfully imported key with thumbprint %s\n",thumbprint);
return 0;
}
}
}
char thumbprint[33];
thumbprint[32] = 0;
RSA_thumbprint(privkey,thumbprint);
printf("Your private key thumbprint is %s\n",thumbprint);
void* router = GlobalGrid::GlobalGrid_InitRouter(privkey);
printf("Registering IP protocol driver with system....\n");
System::Net::IPEndpoint routerBinding;
routerBinding.ip = "::";
routerBinding.port = 0;
if(argc>1) {
routerBinding.ip = argv[4];
routerBinding.port = atoi(argv[5]);
}
std::shared_ptr<IPProto::IIPDriver> deriver = IPProto::CreateDriver(router,routerBinding);
GlobalGrid::GlobalGrid_RegisterProtocolDriver(router,deriver);
void* locksock = deriver->SerializeLocalSocket();
unsigned char* socket_data;
size_t sock_len;
GlobalGrid::Buffer_Get(locksock,&socket_data,&sock_len);
uint16_t portno;
memcpy(&portno,socket_data+16,2);
printf("Protocol driver active and registered (port %i)\n",(int)portno);
//TODO: Server is listening on appropriate port, as verified by netstat -l.
//Client must not be sending handshake appopriately (or server receive loop isn't working).
//Connect to specified endpoint
if(argc>1) {
System::Net::IPEndpoint ep;
ep.ip = argv[1];
ep.port = atoi(argv[2]);
const char* thumbprint = argv[3];
//Connect to remote endpoint.
void* key = DB_FindAuthority(thumbprint);
if(key == 0) {
printf("ERR: Unable to find authority figure.\n");
abort();
}
GlobalGrid::GlobalGrid_InitiateHandshake(router,deriver->MakeSocket(ep),key);
RSA_Free(key);
}
unsigned char izard[16];
memset(izard,0,16);
GlobalGrid::GlobalGrid_SendPacket(router,izard,izard,1);
char mander[256];
auto messenger = System::MakeQueue([&](std::shared_ptr<System::Message> msg){
unsigned char pingmsg = 0;
GlobalGrid::Guid converted;
FromHexString(mander,(unsigned char*)converted.value,16*2);
GlobalGrid::GlobalGrid_SendPacket(router,converted,&pingmsg,1);
printf("PING %s\n",mander);
});
std::thread m([&](){
while(true) {
int br = read(0,mander,256);
if(br <=0) {
break;
}
mander[br] = 0;
messenger->Post(0);
}
});
m.detach();
System::Enter();
return 0;
}
