// CopyFileToHost copies a file or directory from the guest operating system to the local
// system (where the VIX client is running).
//
// Parameters:
//
// guestpath: The path name of a file on a file system available to the guest.
// hostpath: The path name of a file on a file system available to the Vix
// client.
//
func (g *Guest) CopyFileToHost(guestpath, hostpath string) error {
var jobHandle C.VixHandle = C.VIX_INVALID_HANDLE
var err C.VixError = C.VIX_OK
gpath := C.CString(guestpath)
hpath := C.CString(hostpath)
defer C.free(unsafe.Pointer(gpath))
defer C.free(unsafe.Pointer(hpath))
jobHandle = C.VixVM_CopyFileFromGuestToHost(g.handle,
gpath, // src name
hpath, // dest name
0, // options
C.VIX_INVALID_HANDLE, // propertyListHandle
nil, // callbackProc
nil) // clientData
defer C.Vix_ReleaseHandle(jobHandle)
err = C.vix_job_wait(jobHandle)
if C.VIX_OK != err {
return &Error{
Operation: "guest.CopyFileToHost",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return nil
}
// Mv renames a file or directory in the guest operating system.
//
// Parameters:
//
// path1: The path to the file to be renamed.
// path2: The path to the new file.
//
// Remarks:
//
// * Only absolute paths should be used for files in the guest; the resolution
// of relative paths is not specified.
//
// * On Windows guests, it fails on directory moves when the destination is on a
// different volume.
//
// * Because of the differences in how various operating systems handle
// filenames, Vix may return either VIX_E_INVALID_ARG or
// VIX_E_FILE_NAME_TOO_LONG for filenames longer than 255 characters.
//
// Since VMware Workstation 6.0
// Minimum Supported Guest OS: Microsoft Windows NT Series, Linux
func (g *Guest) Mv(path1, path2 string) error {
var jobHandle C.VixHandle = C.VIX_INVALID_HANDLE
var err C.VixError = C.VIX_OK
cpath1 := C.CString(path1)
cpath2 := C.CString(path2)
defer C.free(unsafe.Pointer(cpath1))
defer C.free(unsafe.Pointer(cpath2))
jobHandle = C.VixVM_RenameFileInGuest(g.handle,
cpath1, //oldName
cpath2, //newName
0, //options
C.VIX_INVALID_HANDLE, //propertyListHandle
nil, //callbackProc
nil) //clientData
defer C.Vix_ReleaseHandle(jobHandle)
err = C.vix_job_wait(jobHandle)
if C.VIX_OK != err {
return &Error{
Operation: "guest.Mv",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return nil
}
// RmFile deletes a file in the guest operating system.
//
// Parameters:
//
// filepath: file path to be deleted in the guest OS
//
// Remarks:
// * Only absolute paths should be used for files in the guest; the resolution
// of relative paths is not specified.
//
// Since VMware Workstation 6.0
// Minimum Supported Guest OS: Microsoft Windows NT Series, Linux
func (g *Guest) RmFile(filepath string) error {
var jobHandle C.VixHandle = C.VIX_INVALID_HANDLE
var err C.VixError = C.VIX_OK
fpath := C.CString(filepath)
defer C.free(unsafe.Pointer(fpath))
jobHandle = C.VixVM_DeleteFileInGuest(g.handle,
fpath, // file path name
nil, // callbackProc
nil) // clientData
defer C.Vix_ReleaseHandle(jobHandle)
err = C.vix_job_wait(jobHandle)
if C.VIX_OK != err {
return &Error{
Operation: "guest.RmFile",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return nil
}
// MkDir creates a directory in the guest operating system.
//
// Parameters:
//
// path: Directory path to be created in the guest OS
//
// Remarks:
//
// * If the parent directories for the specified path do not exist, this
// function will create them.
//
// * If the directory already exists, the error will be set to
// VIX_E_FILE_ALREADY_EXISTS.
//
// * Only absolute paths should be used for files in the guest; the resolution
// of relative paths is not specified.
//
// Since Workstation 6.0
// Minimum Supported Guest OS: Microsoft Windows NT Series, Linux
func (g *Guest) MkDir(path string) error {
var jobHandle C.VixHandle = C.VIX_INVALID_HANDLE
var err C.VixError = C.VIX_OK
cpath := C.CString(path)
defer C.free(unsafe.Pointer(cpath))
jobHandle = C.VixVM_CreateDirectoryInGuest(g.handle,
cpath, // path name
C.VIX_INVALID_HANDLE, // propertyListHandle
nil, // callbackProc
nil) // clientData
defer C.Vix_ReleaseHandle(jobHandle)
err = C.vix_job_wait(jobHandle)
if C.VIX_OK != err {
return &Error{
Operation: "guest.MkDir",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return nil
}
// This function finds Vix objects. For example, when used to find all
// running virtual machines, Host.FindItems() returns a series of virtual
// machine file path names.
func (h *Host) FindItems(options SearchType) ([]string, error) {
var jobHandle C.VixHandle = C.VIX_INVALID_HANDLE
var err C.VixError = C.VIX_OK
var items []string
callback := func(item *C.char) {
items = append(items, C.GoString(item))
}
jobHandle = C.VixHost_FindItems(h.handle,
C.VixFindItemType(options), //searchType
C.VIX_INVALID_HANDLE, //searchCriteria
-1, //timeout
(*C.VixEventProc)(C.find_items_callback), //callbackProc
unsafe.Pointer(&callback)) //clientData
defer C.Vix_ReleaseHandle(jobHandle)
err = C.vix_job_wait(jobHandle)
if C.VIX_OK != err {
return nil, &Error{
Operation: "host.FindItems",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return items, nil
}
// Copies a file or directory from the local system (where the Vix client is
// running) to the guest operating system.
//
// Parameters:
//
// src: The path name of a file on a file system available to the Vix client.
// guest: Guest instance where the file is going to be copied to
// dest: The path name of a file on a file system available to the guest.
//
// Remarks:
//
// * The virtual machine must be running while the file is copied from the Vix
// client machine to the guest operating system.
//
// * Existing files of the same name are overwritten, and folder contents are
// merged.
//
// * The copy operation requires VMware Tools to be installed and running in
// the guest operating system.
//
// * You must call VM.LoginInGuest() before calling this function in order
// to get a Guest instance.
//
// * The format of the file name depends on the guest or local operating system.
// For example, a path name for a Microsoft Windows guest or host requires
// backslash as a directory separator, whereas a Linux guest or host requires
// a forward slash. If the path name includes backslash characters,
// you need to precede each one with an escape character.
//
// * Only absolute paths should be used for files in the guest; the resolution
// of relative paths is not specified.
//
// * If any file fails to be copied, Vix aborts the operation, does not attempt
// to copy the remaining files, and returns an error.
//
// * In order to copy a file to a mapped network drive in a Windows guest
// operating system, it is necessary to call VixVM_LoginInGuest() with the
// LOGIN_IN_GUEST_REQUIRE_INTERACTIVE_ENVIRONMENT flag set.
// Using the interactive session option incurs an overhead in file transfer
// speed.
//
// Since VMware Server 1.0
// Minimum Supported Guest OS: Microsoft Windows NT Series, Linux
//
func (h *Host) CopyFileToGuest(src string, guest *Guest, dest string) error {
var jobHandle C.VixHandle = C.VIX_INVALID_HANDLE
var err C.VixError = C.VIX_OK
csrc := C.CString(src)
cdest := C.CString(dest)
defer C.free(unsafe.Pointer(csrc))
defer C.free(unsafe.Pointer(cdest))
jobHandle = C.VixVM_CopyFileFromHostToGuest(
guest.handle, // VM handle
csrc, // src name
cdest, // dest name
C.int(0), // options
C.VIX_INVALID_HANDLE, // propertyListHandle
nil, // callbackProc
nil) // clientData
defer C.Vix_ReleaseHandle(jobHandle)
err = C.vix_job_wait(jobHandle)
if C.VIX_OK != err {
return &Error{
Operation: "host.CopyFileToGuest",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return nil
}
// This function removes a virtual machine from the host's inventory.
//
// Parameters:
//
// VmxFile: The path name of the .vmx file on the host.
//
// Remarks:
//
// * This function unregisters the virtual machine identified by vmxFile,
// which is a storage path to the configuration file (.vmx) for that virtual
// machine. A virtual machine must be powered off to unregister it.
// * The format of the storage path depends on the host operating system.
// If the storage path includes backslash characters, you need to precede each
// one with an escape character. Path to storage [standard] or [storage1] may
// vary.
// * For VMware Server 1.x, supply the full path name instead of storage path,
// and specify VMWARE_SERVER provider to connect.
// * This function has no effect on Workstation or Player, which lack a virtual
// machine inventory.
// * It is not a Vix error to unregister an already-unregistered virtual machine,
// nor is it a Vix error to unregister a non-existent virtual machine.
//
// Since VMware Server 1.0
func (h *Host) UnregisterVM(vmxFile string) error {
var jobHandle C.VixHandle = C.VIX_INVALID_HANDLE
var err C.VixError = C.VIX_OK
cVmxFile := C.CString(vmxFile)
defer C.free(unsafe.Pointer(cVmxFile))
jobHandle = C.VixHost_UnregisterVM(h.handle,
cVmxFile,
nil, // callbackProc
nil) // clientData
defer C.Vix_ReleaseHandle(jobHandle)
err = C.vix_job_wait(jobHandle)
if C.VIX_OK != err {
return &Error{
Operation: "host.UnregisterVM",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return nil
}
// Ls lists a directory in the guest operating system.
//
// Parameters:
//
// dir: The path name of a directory to be listed.
//
// Remarks:
//
// * Only absolute paths should be used for files in the guest; the resolution
// of relative paths is not specified.
//
// Since VMware Workstation 6.0
// Minimum Supported Guest OS: Microsoft Windows NT Series, Linux
func (g *Guest) Ls(dir string) ([]*GuestFile, error) {
var jobHandle C.VixHandle = C.VIX_INVALID_HANDLE
var err C.VixError = C.VIX_OK
var files []*GuestFile
guestdir := C.CString(dir)
defer C.free(unsafe.Pointer(guestdir))
jobHandle = C.VixVM_ListDirectoryInGuest(g.handle, guestdir, 0, nil, nil)
defer C.Vix_ReleaseHandle(jobHandle)
err = C.vix_job_wait(jobHandle)
if C.VIX_OK != err {
return nil, &Error{
Operation: "guest.Ls.ListDirectoryInGuest",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
num := C.VixJob_GetNumProperties(jobHandle, C.VIX_PROPERTY_JOB_RESULT_ITEM_NAME)
for i := 0; i < int(num); i++ {
var name *C.char
var size *C.int64
var modtime *C.int64
var attrs *C.int
gfile := &GuestFile{}
err = C.get_guest_file(jobHandle, C.int(i), name, size, modtime, attrs)
if C.VIX_OK != err {
return nil, &Error{
Operation: "guest.Ls.get_guest_file",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
gfile.Path = C.GoString(name)
C.Vix_FreeBuffer(unsafe.Pointer(name))
gfile.Size = int64(*size)
gfile.Modtime = int64(*modtime)
gfile.Attrs = FileAttr(*attrs)
files = append(files, gfile)
}
return files, nil
}
// Logout removes any guest operating system authentication
// context created by a previous call to VM.LoginInGuest().
//
// Remarks:
// * This function has no effect and returns success if VM.LoginInGuest()
// has not been called.
// * If you call this function while guest operations are in progress,
// subsequent operations may fail with a permissions error.
// It is best to wait for guest operations to complete before logging out.
//
// Since VMware Workstation 6.0
// Minimum Supported Guest OS: Microsoft Windows NT Series, Linux
func (g *Guest) Logout() error {
var jobHandle C.VixHandle = C.VIX_INVALID_HANDLE
var err C.VixError = C.VIX_OK
jobHandle = C.VixVM_LogoutFromGuest(g.handle,
nil, // callbackProc
nil) // clientData
defer C.Vix_ReleaseHandle(jobHandle)
err = C.vix_job_wait(jobHandle)
if C.VIX_OK != err {
return &Error{
Operation: "guest.Logout",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return nil
}
// Kill terminates a process in the guest operating system.
//
// Parameters:
//
// pid: The ID of the process to be killed.
//
// Remarks:
//
// * Depending on the behavior of the guest operating system, there may be a
// short delay after the job completes before the process truly disappears.
//
// * Because of differences in how various Operating Systems handle process IDs,
// Vix may return either VIX_E_INVALID_ARG or VIX_E_NO_SUCH_PROCESS
// for invalid process IDs.
//
// Since VMware Workstation 6.0
// Minimum Supported Guest OS: Microsoft Windows NT Series, Linux
func (g *Guest) Kill(pid uint64) error {
var jobHandle C.VixHandle = C.VIX_INVALID_HANDLE
var err C.VixError = C.VIX_OK
jobHandle = C.VixVM_KillProcessInGuest(g.handle,
C.uint64(pid), // file path name
0, // options
nil, // callbackProc
nil) // clientData
defer C.Vix_ReleaseHandle(jobHandle)
err = C.vix_job_wait(jobHandle)
if C.VIX_OK != err {
return &Error{
Operation: "guest.Kill",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return nil
}
// Ps lists the running processes in the guest operating system.
//
// Since Workstation 6.0
// Minimum Supported Guest OS: Microsoft Windows NT Series, Linux
func (g *Guest) Ps() ([]*GuestProcess, error) {
var jobHandle C.VixHandle = C.VIX_INVALID_HANDLE
var err C.VixError = C.VIX_OK
var processes []*GuestProcess
jobHandle = C.VixVM_ListProcessesInGuest(g.handle, 0, nil, nil)
defer C.Vix_ReleaseHandle(jobHandle)
err = C.vix_job_wait(jobHandle)
if C.VIX_OK != err {
return nil, &Error{
Operation: "guest.Ps",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
num := C.VixJob_GetNumProperties(jobHandle, C.VIX_PROPERTY_JOB_RESULT_ITEM_NAME)
for i := 0; i < int(num); i++ {
var name *C.char
var pid *C.uint64
var owner *C.char
var cmdline *C.char
var isDebugged *C.Bool
var startTime *C.int
gprocess := &GuestProcess{}
err = C.get_guest_process(jobHandle, C.int(i),
name,
pid,
owner,
cmdline,
isDebugged,
startTime)
if C.VIX_OK != err {
return nil, &Error{
Operation: "guest.Ps.get_guest_process",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
gprocess.Name = C.GoString(name)
C.Vix_FreeBuffer(unsafe.Pointer(name))
gprocess.Pid = uint64(*pid)
gprocess.Owner = C.GoString(owner)
C.Vix_FreeBuffer(unsafe.Pointer(owner))
gprocess.Cmdline = C.GoString(cmdline)
C.Vix_FreeBuffer(unsafe.Pointer(cmdline))
if *isDebugged == 1 {
gprocess.IsDebugged = true
} else {
gprocess.IsDebugged = false
}
gprocess.StartTime = int(*startTime)
processes = append(processes, gprocess)
}
return processes, nil
}
