VixError
VixToolsNewEnvIterator(void *userToken, // IN
#ifdef __FreeBSD__
char **envp, // IN
#endif
VixToolsEnvIterator **envItr) // OUT
{
VixError err = VIX_OK;
VixToolsEnvIterator *it = Util_SafeMalloc(sizeof *it);
if (NULL == envItr) {
err = VIX_E_FAIL;
goto abort;
}
*envItr = NULL;
#ifdef _WIN32
if (PROCESS_CREATOR_USER_TOKEN != userToken) {
/*
* The process is impersonating a user, so retrieve the user's
* environment block instead of using the process's environment.
*/
it->envType = VIX_TOOLS_ENV_TYPE_ENV_BLOCK;
err = VixToolsGetEnvBlock(userToken, &it->data.eb.envBlock);
if (VIX_FAILED(err)) {
goto abort;
}
it->data.eb.currEnvVar = it->data.eb.envBlock;
} else {
/*
* The action is being performed as the user running the process
* so the process's environment is fine.
* TODO: Is this totally equivilent to the behavior when impersonated?
* Would fetching the environment block include changes to the user's
* or system's environment made after the process is running?
*/
it->envType = VIX_TOOLS_ENV_TYPE_ENVIRON;
it->data.environ = _wenviron;
}
#elif defined(__APPLE__)
it->environ = *_NSGetEnviron();
#elif defined(__FreeBSD__)
it->environ = envp;
#else
it->environ = environ;
#endif
*envItr = it;
abort:
if (VIX_FAILED(err)) {
free(it);
}
return err;
}
VALUE
_read_var(VALUE self, VALUE rvm, VALUE rvartype, VALUE rname)
{
VixHandle vm = NUM2INT(rb_iv_get(rvm,"@handle"));
VixHandle job;
VixError err;
VALUE retval;
int vartype = NUM2INT(rvartype);
char *name = StringValueCStr(rname);
int opts = 0;
char *var = NULL;
job = VixVM_ReadVariable(vm,vartype,name,opts,NULL,NULL);
err = VixJob_Wait(job, VIX_PROPERTY_JOB_RESULT_VM_VARIABLE_STRING, &var, VIX_PROPERTY_NONE);
Vix_ReleaseHandle(job);
if(VIX_FAILED(err))
{
fprintf(stderr,"Failed to read variable virtual machine:%s\n",Vix_GetErrorText(err,NULL));
return Qnil;
}
fprintf(stderr,"Read var \"%s\", got (%s)\n",name,var);
retval = rb_str_new2(var);
Vix_FreeBuffer(var);
return retval;
}
VixError
VixToolsNewUserEnvironment(void *userToken, // IN
VixToolsUserEnvironment **env) // OUT
{
VixError err = VIX_OK;
VixToolsUserEnvironment *myEnv = Util_SafeMalloc(sizeof *myEnv);
if (NULL == env) {
err = VIX_E_FAIL;
goto abort;
}
*env = NULL;
#ifdef _WIN32
if (PROCESS_CREATOR_USER_TOKEN != userToken) {
myEnv->impersonated = TRUE;
err = VixToolsGetEnvBlock(userToken, &myEnv->envBlock);
if (VIX_FAILED(err)) {
goto abort;
}
} else {
myEnv->impersonated = FALSE;
/* We will just read from the process's environment. */
}
#endif
*env = myEnv;
abort:
if (VIX_FAILED(err)) {
free(myEnv);
}
return err;
}
VALUE
_unpause(VALUE self, VALUE rvm)
{
VixHandle vm = NUM2INT(rb_iv_get(rvm,"@handle"));
VixHandle job;
VixError err;
job = VixVM_Unpause(vm,0,VIX_INVALID_HANDLE,NULL,NULL);
err = VixJob_Wait(job, VIX_PROPERTY_NONE);
Vix_ReleaseHandle(job);
if(VIX_FAILED(err))
{
fprintf(stderr,"Failed to unpause virtual machine: %s\n", Vix_GetErrorText(err,NULL));
return Qnil;
}
return Qtrue;
}
VALUE
_upgrade_vhardware(VALUE self, VALUE rvm)
{
VixHandle vm = NUM2INT(rb_iv_get(rvm,"@handle"));
VixHandle job;
VixError err;
job = VixVM_UpgradeVirtualHardware(vm,0,NULL,NULL);
err = VixJob_Wait(job, VIX_PROPERTY_NONE);
Vix_ReleaseHandle(job);
if(VIX_FAILED(err))
{
fprintf(stderr,"Failed to upgrade the virtual hardware: %s\n",Vix_GetErrorText(err,NULL));
return Qnil;
}
return Qtrue;
}
VALUE
_power_off(VALUE self, VALUE rvm, VALUE ropt)
{
VixHandle vm = NUM2INT(rb_iv_get(rvm,"@handle"));
VixHandle job;
VixError err;
int opt = NUM2INT(ropt);
job = VixVM_PowerOff(vm,opt,NULL,NULL);
err = VixJob_Wait(job, VIX_PROPERTY_NONE);
Vix_ReleaseHandle(job);
if(VIX_FAILED(err))
{
fprintf(stderr,"Failed to power off virtual machine: %s\n", Vix_GetErrorText(err,NULL));
return Qnil;
}
return Qtrue;
}
VALUE
_write_var(VALUE self, VALUE rvm, VALUE rtype, VALUE rname, VALUE rval)
{
VixHandle vm = NUM2INT(rb_iv_get(rvm,"@handle"));
VixHandle job;
VixError err;
int type = NUM2INT(rtype);
char *name = StringValueCStr(rname);
char *val = StringValueCStr(rval);
job = VixVM_WriteVariable(vm,type,name,val,0,NULL,NULL);
err = VixJob_Wait(job, VIX_PROPERTY_NONE);
Vix_ReleaseHandle(job);
if(VIX_FAILED(err))
{
fprintf(stderr,"Failed to write variable (%s) val=(%s): %s\n",name,val,Vix_GetErrorText(err,NULL));
return Qnil;
}
return rval;
}
static PyObject *pyf_extractProperty(VixHandle h, VixPropertyID propID) {
/* Looks up the specified property propID on handle h, then converts the C
* property value to an appropriate Python object. */
PyObject *pyProp = NULL;
VixError err = VIX_OK;
VixPropertyType propType = VIX_PROPERTYTYPE_ANY;
err = Vix_GetPropertyType(h, propID, &propType);
CHECK_VIX_ERROR(err);
switch (propType) {
case VIX_PROPERTYTYPE_STRING: {
char *s = NULL;
err = Vix_GetProperties(h, propID, &s, VIX_PROPERTY_NONE);
if (VIX_FAILED(err)) {
autoRaiseVIXError(err);
pyvix_vix_buffer_free(s);
goto fail;
} else {
assert (s != NULL);
pyProp = PyString_FromString(s);
pyvix_vix_buffer_free(s);
if (pyProp == NULL) { goto fail; }
}
break;
}
case VIX_PROPERTYTYPE_INTEGER: {
int i;
err = Vix_GetProperties(h, propID, &i, VIX_PROPERTY_NONE);
CHECK_VIX_ERROR(err);
pyProp = PyInt_FromLong(i);
if (pyProp == NULL) { goto fail; }
break;
}
case VIX_PROPERTYTYPE_INT64: {
int64 i;
err = Vix_GetProperties(h, propID, &i, VIX_PROPERTY_NONE);
CHECK_VIX_ERROR(err);
pyProp = PythonIntOrLongFrom64BitValue(i);
if (pyProp == NULL) { goto fail; }
break;
}
case VIX_PROPERTYTYPE_BOOL: {
int i;
err = Vix_GetProperties(h, propID, &i, VIX_PROPERTY_NONE);
CHECK_VIX_ERROR(err);
pyProp = PyBool_FromLong(i);
if (pyProp == NULL) { goto fail; }
break;
}
default:
raiseNonNumericVIXError(VIXInternalError,
"Unable to extract this property type."
);
goto fail;
}
assert (!PyErr_Occurred());
assert (pyProp != NULL);
return pyProp;
fail:
assert (PyErr_Occurred());
Py_XDECREF(pyProp);
return NULL;
} /* pyf_extractProperty */
