int main(int argc, char **argv)
{
IVirtualBoxClient *vboxclient = NULL;
IVirtualBox *vbox = NULL;
ISession *session = NULL;
ULONG revision = 0;
BSTR versionUtf16 = NULL;
BSTR homefolderUtf16 = NULL;
HRESULT rc; /* Result code of various function (method) calls. */
printf("Starting main()\n");
if (VBoxCGlueInit())
{
fprintf(stderr, "%s: FATAL: VBoxCGlueInit failed: %s\n",
argv[0], g_szVBoxErrMsg);
return EXIT_FAILURE;
}
{
unsigned ver = g_pVBoxFuncs->pfnGetVersion();
printf("VirtualBox version: %u.%u.%u\n", ver / 1000000, ver / 1000 % 1000, ver % 1000);
ver = g_pVBoxFuncs->pfnGetAPIVersion();
printf("VirtualBox API version: %u.%u\n", ver / 1000, ver % 1000);
}
g_pVBoxFuncs->pfnClientInitialize(NULL, &vboxclient);
if (!vboxclient)
{
fprintf(stderr, "%s: FATAL: could not get VirtualBoxClient reference\n", argv[0]);
return EXIT_FAILURE;
}
printf("----------------------------------------------------\n");
rc = IVirtualBoxClient_get_VirtualBox(vboxclient, &vbox);
if (FAILED(rc) || !vbox)
{
PrintErrorInfo(argv[0], "FATAL: could not get VirtualBox reference", rc);
return EXIT_FAILURE;
}
rc = IVirtualBoxClient_get_Session(vboxclient, &session);
if (FAILED(rc) || !session)
{
PrintErrorInfo(argv[0], "FATAL: could not get Session reference", rc);
return EXIT_FAILURE;
}
#ifdef USE_ACTIVE_EVENT_LISTENER
# ifdef WIN32
rc = LoadTypeInfo(&IID_IEventListener, &g_pTInfoIEventListener);
if (FAILED(rc) || !g_pTInfoIEventListener)
{
PrintErrorInfo(argv[0], "FATAL: could not get type information for IEventListener", rc);
return EXIT_FAILURE;
}
# endif /* WIN32 */
#endif /* USE_ACTIVE_EVENT_LISTENER */
/*
* Now ask for revision, version and home folder information of
* this vbox. Were not using fancy macros here so it
* remains easy to see how we access C++'s vtable.
*/
/* 1. Revision */
rc = IVirtualBox_get_Revision(vbox, &revision);
if (SUCCEEDED(rc))
printf("\tRevision: %u\n", revision);
else
PrintErrorInfo(argv[0], "GetRevision() failed", rc);
/* 2. Version */
rc = IVirtualBox_get_Version(vbox, &versionUtf16);
if (SUCCEEDED(rc))
{
char *version = NULL;
g_pVBoxFuncs->pfnUtf16ToUtf8(versionUtf16, &version);
printf("\tVersion: %s\n", version);
g_pVBoxFuncs->pfnUtf8Free(version);
g_pVBoxFuncs->pfnComUnallocString(versionUtf16);
}
else
PrintErrorInfo(argv[0], "GetVersion() failed", rc);
/* 3. Home Folder */
rc = IVirtualBox_get_HomeFolder(vbox, &homefolderUtf16);
if (SUCCEEDED(rc))
{
char *homefolder = NULL;
g_pVBoxFuncs->pfnUtf16ToUtf8(homefolderUtf16, &homefolder);
printf("\tHomeFolder: %s\n", homefolder);
g_pVBoxFuncs->pfnUtf8Free(homefolder);
g_pVBoxFuncs->pfnComUnallocString(homefolderUtf16);
}
else
PrintErrorInfo(argv[0], "GetHomeFolder() failed", rc);
listVMs(argv[0], vbox, session);
ISession_UnlockMachine(session);
printf("----------------------------------------------------\n");
/*
* Do as mom told us: always clean up after yourself.
*/
#ifdef USE_ACTIVE_EVENT_LISTENER
# ifdef WIN32
if (g_pTInfoIEventListener)
{
ITypeInfo_Release(g_pTInfoIEventListener);
g_pTInfoIEventListener = NULL;
}
# endif /* WIN32 */
#endif /* USE_ACTIVE_EVENT_LISTENER */
if (session)
{
ISession_Release(session);
session = NULL;
}
if (vbox)
{
IVirtualBox_Release(vbox);
vbox = NULL;
}
if (vboxclient)
{
IVirtualBoxClient_Release(vboxclient);
vboxclient = NULL;
}
g_pVBoxFuncs->pfnClientUninitialize();
VBoxCGlueTerm();
printf("Finished main()\n");
return 0;
}
int CCertificateRequestGenerator::Generate()
//Generate certificate request and write into a file
{
FILE* fp = NULL;
char* pbPassword = NULL;
EVP_PKEY* pKey = NULL;
X509_REQ* pReq = NULL;
X509_NAME* pSubj = NULL;
const EVP_MD* pDigest = NULL;
DWORD bytesWritten;
struct entry_pack* pEntPack = NULL;
int retFunc = FAIL;
//Get command prompt handle
HANDLE hndl = GetStdHandle(STD_OUTPUT_HANDLE);
OPENSSL_add_all_algorithms_conf();
ERR_load_crypto_strings();
//First read private key from key file
if(!(fp = _tfopen(m_privateKeyFile, _T("r"))))
{
PrintErrorInfo("Error reading key file!", EGeneric, constparams);
WriteConsole(hndl, m_privateKeyFile, wcslen(m_privateKeyFile), &bytesWritten, 0);
return retFunc;
}
if(m_password[0] != 0)
{
DWORD len = 0;
len = _tcslen(m_password);
pbPassword = MakeMBCSString(m_password, CP_UTF8, len);
pKey = PEM_read_PrivateKey(fp, NULL, NULL, pbPassword);
delete pbPassword;
}
else
{
pKey = PEM_read_PrivateKey(fp, NULL, NULL, NULL);
}
fclose(fp); fp = NULL;
if(!pKey)
{
PrintErrorInfo("Error reading private key in key file!", EOPENSSL, constparams);
return retFunc;
}
try
{
//Create a new cert request and add the public key into it
if(!(pReq = X509_REQ_new()))
{
PrintErrorInfo("Error creating X509 request object!", EOPENSSL, constparams);
throw EOPENSSL;
}
X509_REQ_set_pubkey(pReq, pKey);
//Now create DN name entries and assign them to request
if(!(pSubj = X509_NAME_new()))
{
PrintErrorInfo("Error creating X509 name object!", EOPENSSL, constparams);
throw EOPENSSL;
}
//Format DN string
DoFormatted(m_dname, &pEntPack);
if(pEntPack->num == 0)
{
PrintErrorInfo("Error formatting Distinguished Name!", EGeneric, constparams);
throw EGeneric;
}
for (int i = 0; i < pEntPack->num; i++)
{
int nid = 0;
DWORD lent = 0;
X509_NAME_ENTRY *pEnt = NULL;
LPSTR pbMBSTRUTF8 = NULL;
if((pEntPack->entries[i].value == NULL) || (pEntPack->entries[i].key == NULL))
{
PrintErrorInfo("Error in Distinguished Name construction!", EGeneric, constparams);
throw EGeneric;
}
if((nid = OBJ_txt2nid(pEntPack->entries[i].key)) == NID_undef)
{
PrintErrorInfo("Error finding NID for a DN entry!", EOPENSSL, constparams);
throw EOPENSSL;
}
lent = _tcslen(pEntPack->entries[i].value);
pbMBSTRUTF8 = MakeMBCSString(pEntPack->entries[i].value, CP_UTF8, lent);
if(lent > 64) //OpenSSL does not accept a string longer than 64
{
if(!(pEnt = X509_NAME_ENTRY_create_by_NID(NULL, nid, MBSTRING_UTF8, (unsigned char *)"dummy", 5)))
{
PrintErrorInfo("Error creating name entry from NID!", EOPENSSL, constparams);
throw EOPENSSL;
}
pEnt->value->data = (unsigned char *)malloc(lent+1);
for(DWORD j=0; j<lent; j++ )
{
pEnt->value->data[j] = pbMBSTRUTF8[j];
}
pEnt->value->length = lent;
}
else if(!(pEnt = X509_NAME_ENTRY_create_by_NID(NULL, nid, MBSTRING_UTF8, (unsigned char *)pbMBSTRUTF8, lent)))
{
PrintErrorInfo("Error creating name entry from NID!", EOPENSSL, constparams);
throw EOPENSSL;
}
if(X509_NAME_add_entry(pSubj, pEnt, -1, 0) != 1)
{
PrintErrorInfo("Error adding entry to X509 Name!", EOPENSSL, constparams);
throw EOPENSSL;
}
delete pbMBSTRUTF8;
}//for
SYMBIAN_FREE_MEM(pEntPack);
if(X509_REQ_set_subject_name(pReq, pSubj) != 1)
{
PrintErrorInfo("Error adding subject to request!", EOPENSSL, constparams);
throw EOPENSSL;
}
//Find the correct digest and sign the request
if(EVP_PKEY_type(pKey->type) == EVP_PKEY_DSA)
{
pDigest = EVP_dss1();
}
else if(EVP_PKEY_type(pKey->type) == EVP_PKEY_RSA)
{
pDigest = EVP_sha1();
}
else
{
PrintErrorInfo("Error checking private key type!", EOPENSSL, constparams);
throw EOPENSSL;
}
if(!(X509_REQ_sign(pReq, pKey, pDigest)))
{
PrintErrorInfo("Error signing request!", EOPENSSL, constparams);
throw EOPENSSL;
}
if(!(fp = _tfopen(m_RequestFile, _T("w"))))
{
PrintErrorInfo("Error writing to request file!",EGeneric,constparams);
throw EGeneric;
}
if(PEM_write_X509_REQ(fp, pReq) != 1)
{
PrintErrorInfo("Error while writing to request file!", EOPENSSL, constparams);
throw EOPENSSL;
}
//Free variables
EVP_PKEY_free(pKey);
X509_NAME_free(pSubj);
X509_REQ_free(pReq);
fclose(fp);
_tprintf(_T("\nCreated request: "));
WriteConsole(hndl, m_RequestFile, wcslen(m_RequestFile), &bytesWritten, 0);
retFunc = SUCCESS;
}
catch (...)
{
if(pKey)
{
EVP_PKEY_free(pKey);
}
if(pSubj)
{
X509_NAME_free(pSubj);
}
if(pReq)
{
X509_REQ_free(pReq);
}
SYMBIAN_FREE_MEM(pEntPack);
}
return retFunc;
}
/**
* List the registered VMs.
*
* @param argv0 executable name
* @param virtualBox ptr to IVirtualBox object
* @param session ptr to ISession object
*/
static void listVMs(const char *argv0, IVirtualBox *virtualBox, ISession *session)
{
HRESULT rc;
SAFEARRAY *machinesSA = g_pVBoxFuncs->pfnSafeArrayOutParamAlloc();
IMachine **machines = NULL;
ULONG machineCnt = 0;
ULONG i;
unsigned start_id;
/*
* Get the list of all registered VMs.
*/
rc = IVirtualBox_get_Machines(virtualBox, ComSafeArrayAsOutIfaceParam(machinesSA, IMachine *));
if (FAILED(rc))
{
PrintErrorInfo(argv0, "could not get list of machines", rc);
return;
}
/*
* Extract interface pointers from machinesSA, and update the reference
* counter of each object, as destroying machinesSA would call Release.
*/
g_pVBoxFuncs->pfnSafeArrayCopyOutIfaceParamHelper((IUnknown ***)&machines, &machineCnt, machinesSA);
g_pVBoxFuncs->pfnSafeArrayDestroy(machinesSA);
if (!machineCnt)
{
printf("\tNo VMs\n");
return;
}
printf("VM List:\n\n");
/*
* Iterate through the collection.
*/
for (i = 0; i < machineCnt; ++i)
{
IMachine *machine = machines[i];
BOOL isAccessible = FALSE;
printf("\tMachine #%u\n", (unsigned)i);
if (!machine)
{
printf("\t(skipped, NULL)\n");
continue;
}
IMachine_get_Accessible(machine, &isAccessible);
if (isAccessible)
{
BSTR machineNameUtf16;
char *machineName;
IMachine_get_Name(machine, &machineNameUtf16);
g_pVBoxFuncs->pfnUtf16ToUtf8(machineNameUtf16,&machineName);
g_pVBoxFuncs->pfnComUnallocString(machineNameUtf16);
printf("\tName: %s\n", machineName);
g_pVBoxFuncs->pfnUtf8Free(machineName);
}
else
{
printf("\tName: <inaccessible>\n");
}
{
BSTR uuidUtf16;
char *uuidUtf8;
IMachine_get_Id(machine, &uuidUtf16);
g_pVBoxFuncs->pfnUtf16ToUtf8(uuidUtf16, &uuidUtf8);
g_pVBoxFuncs->pfnComUnallocString(uuidUtf16);
printf("\tUUID: %s\n", uuidUtf8);
g_pVBoxFuncs->pfnUtf8Free(uuidUtf8);
}
if (isAccessible)
{
{
BSTR configFileUtf16;
char *configFileUtf8;
IMachine_get_SettingsFilePath(machine, &configFileUtf16);
g_pVBoxFuncs->pfnUtf16ToUtf8(configFileUtf16, &configFileUtf8);
g_pVBoxFuncs->pfnComUnallocString(configFileUtf16);
printf("\tConfig file: %s\n", configFileUtf8);
g_pVBoxFuncs->pfnUtf8Free(configFileUtf8);
}
{
ULONG memorySize;
IMachine_get_MemorySize(machine, &memorySize);
printf("\tMemory size: %uMB\n", memorySize);
}
{
BSTR typeId;
BSTR osNameUtf16;
char *osName;
IGuestOSType *osType = NULL;
IMachine_get_OSTypeId(machine, &typeId);
IVirtualBox_GetGuestOSType(virtualBox, typeId, &osType);
g_pVBoxFuncs->pfnComUnallocString(typeId);
IGuestOSType_get_Description(osType, &osNameUtf16);
g_pVBoxFuncs->pfnUtf16ToUtf8(osNameUtf16,&osName);
g_pVBoxFuncs->pfnComUnallocString(osNameUtf16);
printf("\tGuest OS: %s\n\n", osName);
g_pVBoxFuncs->pfnUtf8Free(osName);
IGuestOSType_Release(osType);
}
}
}
/*
* Let the user chose a machine to start.
*/
printf("Type Machine# to start (0 - %u) or 'quit' to do nothing: ",
(unsigned)(machineCnt - 1));
fflush(stdout);
if (scanf("%u", &start_id) == 1 && start_id < machineCnt)
{
IMachine *machine = machines[start_id];
if (machine)
{
BSTR uuidUtf16 = NULL;
IMachine_get_Id(machine, &uuidUtf16);
startVM(argv0, virtualBox, session, uuidUtf16);
g_pVBoxFuncs->pfnComUnallocString(uuidUtf16);
}
}
/*
* Don't forget to release the objects in the array.
*/
for (i = 0; i < machineCnt; ++i)
{
IMachine *machine = machines[i];
if (machine)
{
IMachine_Release(machine);
}
}
if (machines)
free(machines);
}
int CDSAKeyGenerator::Generate()
//Generate a DSA key with pre-determined length
{
unsigned char* pbSeed = NULL;
DSA* pDSAParams = NULL;
FILE* fp = NULL;
LPSTR pbPassword = NULL;
const _TCHAR* pPrivKeyFile = NULL;
int retVal = FAIL;
int retFunc = FAIL;
pPrivKeyFile = GetPrivateKeyFile();
if(!pPrivKeyFile)
{
PrintErrorInfo("Bad parameter error!", EGeneric, constparams);
return 0;
}
OPENSSL_add_all_algorithms_conf();
ERR_load_crypto_strings();
int dwKeyLength = 0;
dwKeyLength = GetKeyLength();
try
{
retVal = GenerateSeed(dwKeyLength, &pbSeed);
if(retVal != SUCCESS)
{
throw EMSCrypto;
}
//Generate DSA params (p,q and g)
_tprintf(_T("\nGenerating DSA key ."));
pDSAParams = DSA_generate_parameters(dwKeyLength, pbSeed, dwKeyLength, NULL, NULL, DSAKeyStatus, NULL);
if(!pDSAParams)
{
PrintErrorInfo("Error generating DSA key params!", EOPENSSL, constparams);
throw EOPENSSL;
}
//Generate DSA key
retVal = DSA_generate_key(pDSAParams);
if(!retVal)
{
PrintErrorInfo("DSA key generation failed!", EOPENSSL, constparams);
throw EOPENSSL;
}
_tprintf(_T("Generated!\n"));
//Create a key file
fp = _tfopen(pPrivKeyFile, _T("w"));
if(!fp)
{
PrintErrorInfo("Error creating key file!", EGeneric, constparams);
throw EOPENSSL;
}
//Write generated DSA key to the key file
if(m_bPassword)
{
DWORD len = 0;
len = _tcslen(GetPassword());
pbPassword = MakeMBCSString(GetPassword(), CP_UTF8, len);
retVal = PEM_write_DSAPrivateKey(fp, pDSAParams, EVP_des_ede3_cbc(), (unsigned char *) pbPassword, len, NULL, NULL);
delete pbPassword;
}
else if(m_bAsk)
{
retVal = PEM_write_DSAPrivateKey(fp, pDSAParams, EVP_des_ede3_cbc(), NULL, 0, NULL, NULL);
}
else
{
_tprintf(_T("\n"));
retVal = PEM_write_DSAPrivateKey(fp, pDSAParams, NULL , NULL, 0, NULL, NULL);
}
if(!retVal)
{
PrintErrorInfo("Error writing to key file", EOPENSSL, constparams);
throw EOPENSSL;
}
//Free variables
DSA_free(pDSAParams);
fclose(fp);
SYMBIAN_FREE_MEM(pbSeed);
//Get command prompt handle
HANDLE hndl = 0;
hndl = GetStdHandle(STD_OUTPUT_HANDLE);
_tprintf(_T("\nCreated key: "));
DWORD bytesWritten;
WriteConsole(hndl, pPrivKeyFile, wcslen(pPrivKeyFile), &bytesWritten, NULL);
retFunc = SUCCESS;
}
catch (...)
{
//Delete dsa params
if(pDSAParams)
{
DSA_free(pDSAParams);
}
if (fp)
{
fclose(fp);
}
SYMBIAN_FREE_MEM(pbSeed);
}
return retFunc;
}
/**
* Start a VM.
*
* @param argv0 executable name
* @param virtualBox ptr to IVirtualBox object
* @param session ptr to ISession object
* @param id identifies the machine to start
*/
static void startVM(const char *argv0, IVirtualBox *virtualBox, ISession *session, BSTR id)
{
HRESULT rc;
IMachine *machine = NULL;
IProgress *progress = NULL;
BSTR env = NULL;
BSTR sessionType;
rc = IVirtualBox_FindMachine(virtualBox, id, &machine);
if (FAILED(rc) || !machine)
{
PrintErrorInfo(argv0, "Error: Couldn't get the Machine reference", rc);
return;
}
g_pVBoxFuncs->pfnUtf8ToUtf16("gui", &sessionType);
rc = IMachine_LaunchVMProcess(machine, session, sessionType, env, &progress);
g_pVBoxFuncs->pfnUtf16Free(sessionType);
if (SUCCEEDED(rc))
{
BOOL completed;
LONG resultCode;
printf("Waiting for the remote session to open...\n");
IProgress_WaitForCompletion(progress, -1);
rc = IProgress_get_Completed(progress, &completed);
if (FAILED(rc))
fprintf(stderr, "Error: GetCompleted status failed\n");
IProgress_get_ResultCode(progress, &resultCode);
if (FAILED(resultCode))
{
IVirtualBoxErrorInfo *errorInfo;
BSTR textUtf16;
char *text;
IProgress_get_ErrorInfo(progress, &errorInfo);
IVirtualBoxErrorInfo_get_Text(errorInfo, &textUtf16);
g_pVBoxFuncs->pfnUtf16ToUtf8(textUtf16, &text);
printf("Error: %s\n", text);
g_pVBoxFuncs->pfnComUnallocString(textUtf16);
g_pVBoxFuncs->pfnUtf8Free(text);
IVirtualBoxErrorInfo_Release(errorInfo);
}
else
{
fprintf(stderr, "VM process has been successfully started\n");
/* Kick off the event listener demo part, which is quite separate.
* Ignore it if you need a more basic sample. */
#ifdef USE_ACTIVE_EVENT_LISTENER
registerActiveEventListener(virtualBox, session, id);
#else /* !USE_ACTIVE_EVENT_LISTENER */
registerPassiveEventListener(virtualBox, session, id);
#endif /* !USE_ACTIVE_EVENT_LISTENER */
}
IProgress_Release(progress);
}
else
PrintErrorInfo(argv0, "Error: LaunchVMProcess failed", rc);
/* It's important to always release resources. */
IMachine_Release(machine);
}
