TOOLS_MODULE_EXPORT ToolsPluginData *
ToolsOnLoad(ToolsAppCtx *ctx)
{
static ToolsPluginData regData = {
"vmbackup",
NULL,
NULL
};
RpcChannelCallback rpcs[] = {
{ VMBACKUP_PROTOCOL_START, VmBackupStart, NULL, NULL, NULL, 0 },
#if defined(_WIN32)
/* START_WITH_OPTS command supported only on Windows for now */
{ VMBACKUP_PROTOCOL_START_WITH_OPTS, VmBackupStartWithOpts, NULL,
xdr_GuestQuiesceParams, NULL, sizeof (GuestQuiesceParams) },
#endif
{ VMBACKUP_PROTOCOL_ABORT, VmBackupAbort, NULL, NULL, NULL, 0 },
{ VMBACKUP_PROTOCOL_SNAPSHOT_DONE, VmBackupSnapshotDone, NULL, NULL, NULL, 0 }
};
ToolsPluginSignalCb sigs[] = {
{ TOOLS_CORE_SIG_DUMP_STATE, VmBackupDumpState, NULL },
{ TOOLS_CORE_SIG_RESET, VmBackupReset, NULL },
{ TOOLS_CORE_SIG_SHUTDOWN, VmBackupShutdown, NULL },
};
ToolsAppReg regs[] = {
{ TOOLS_APP_GUESTRPC, VMTools_WrapArray(rpcs, sizeof *rpcs, ARRAYSIZE(rpcs)) },
{ TOOLS_APP_SIGNALS, VMTools_WrapArray(sigs, sizeof *sigs, ARRAYSIZE(sigs)) },
};
#if defined(G_PLATFORM_WIN32)
/*
* If initializing COM fails (unlikely), we'll fallback to the sync driver
* or the null provider, depending on the configuration. On success, send
* a request to unregister the VMware snapshot provider.
*/
if (ToolsCore_InitializeCOM(ctx)) {
VmBackup_UnregisterSnapshotProvider();
} else {
g_warning("Failed to initialize COM, VSS support will be unavailable.");
}
#endif
regData.regs = VMTools_WrapArray(regs, sizeof *regs, ARRAYSIZE(regs));
g_signal_new(TOOLS_CORE_SIG_IO_FREEZE,
G_OBJECT_TYPE(ctx->serviceObj),
0,
0,
NULL,
NULL,
g_cclosure_user_marshal_VOID__POINTER_BOOLEAN,
G_TYPE_NONE,
2,
G_TYPE_POINTER,
G_TYPE_BOOLEAN);
return ®Data;
}
TOOLS_MODULE_EXPORT ToolsPluginData *
ToolsOnLoad(ToolsAppCtx *ctx)
{
static ToolsPluginData regData = {
"hgfsServer",
NULL,
NULL
};
HgfsServerMgrData *mgrData;
if (strcmp(ctx->name, VMTOOLS_GUEST_SERVICE) != 0 &&
strcmp(ctx->name, VMTOOLS_USER_SERVICE) != 0) {
g_info("Unknown container '%s', not loading HGFS plugin.", ctx->name);
return NULL;
}
mgrData = g_malloc0(sizeof *mgrData);
HgfsServerManager_DataInit(mgrData,
ctx->name,
NULL, // rpc channel unused
NULL); // no rpc callback
if (!HgfsServerManager_Register(mgrData)) {
g_warning("HgfsServer_InitState() failed, aborting HGFS server init.\n");
g_free(mgrData);
return NULL;
}
{
RpcChannelCallback rpcs[] = {
{ HGFS_SYNC_REQREP_CMD, HgfsServerRpcDispatch, mgrData, NULL, NULL, 0 }
};
ToolsPluginSignalCb sigs[] = {
{ TOOLS_CORE_SIG_CAPABILITIES, HgfsServerCapReg, ®Data },
{ TOOLS_CORE_SIG_SHUTDOWN, HgfsServerShutdown, ®Data }
};
ToolsAppReg regs[] = {
{ TOOLS_APP_GUESTRPC, VMTools_WrapArray(rpcs, sizeof *rpcs, ARRAYSIZE(rpcs)) },
{ TOOLS_APP_SIGNALS, VMTools_WrapArray(sigs, sizeof *sigs, ARRAYSIZE(sigs)) }
};
regData.regs = VMTools_WrapArray(regs, sizeof *regs, ARRAYSIZE(regs));
}
regData._private = mgrData;
return ®Data;
}
TOOLS_MODULE_EXPORT ToolsPluginData *
ToolsOnLoad(ToolsAppCtx *ctx)
{
static ToolsPluginData regData = {
"powerops",
NULL,
NULL
};
size_t i;
PowerOpState *state;
ToolsPluginSignalCb sigs[] = {
{ TOOLS_CORE_SIG_CAPABILITIES, PowerOpsCapabilityCb, NULL },
{ TOOLS_CORE_SIG_SET_OPTION, PowerOpsSetOption, ®Data },
{ TOOLS_CORE_SIG_SHUTDOWN, PowerOpsShutdown, ®Data }
};
ToolsAppReg regs[] = {
{ TOOLS_APP_GUESTRPC, NULL },
{ TOOLS_APP_SIGNALS, VMTools_WrapArray(sigs, sizeof *sigs, ARRAYSIZE(sigs)) }
};
state = g_malloc0(sizeof *state);
state->ctx = ctx;
state->pid = INVALID_PID;
for (i = 0; i < GUESTOS_STATECHANGE_LAST; i++) {
state->scriptEnabled[i] = TRUE;
}
regs[0].data = g_array_sized_new(FALSE,
TRUE,
sizeof (RpcChannelCallback),
ARRAYSIZE(stateChangeCmdTable));
for (i = 0; i < ARRAYSIZE(stateChangeCmdTable); i++) {
RpcChannelCallback cb = { stateChangeCmdTable[i].tcloCmd,
PowerOpsStateChange,
state, NULL, NULL, 0 };
g_array_append_val(regs[0].data, cb);
}
regData.regs = VMTools_WrapArray(regs, sizeof *regs, ARRAYSIZE(regs));
regData._private = state;
return ®Data;
}
static GArray *
PowerOpsCapabilityCb(gpointer src,
ToolsAppCtx *ctx,
gboolean set,
gpointer data)
{
const ToolsAppCapability caps[] = {
{ TOOLS_CAP_OLD_NOVAL, "statechange", 0, 1 },
{ TOOLS_CAP_OLD_NOVAL, "softpowerop_retry", 0, 1 },
};
return VMTools_WrapArray(caps, sizeof *caps, ARRAYSIZE(caps));
}
TOOLS_MODULE_EXPORT ToolsPluginData *
ToolsOnLoad(ToolsAppCtx *ctx)
{
static ToolsPluginData regData = {
"dndCP",
NULL,
NULL
};
if (ctx->rpc != NULL) {
ToolsPluginSignalCb sigs[] = {
{ TOOLS_CORE_SIG_CAPABILITIES, (void *) DnDCPCapabilities, NULL },
{ TOOLS_CORE_SIG_RESET, (void *) DnDCPReset, NULL },
{ TOOLS_CORE_SIG_SET_OPTION, (void *) DnDCPSetOption, NULL },
{ TOOLS_CORE_SIG_SHUTDOWN, (void *) DnDCPShutdown, NULL }
};
ToolsAppReg regs[] = {
{ TOOLS_APP_SIGNALS, VMTools_WrapArray(sigs, sizeof *sigs, ARRAYSIZE(sigs)) }
};
/*
* DnD/CP Initialization here.
*/
CopyPasteDnDWrapper *p = CopyPasteDnDWrapper::GetInstance();
if (p) {
p->Init(ctx);
p->PointerInit();
}
regData.regs = VMTools_WrapArray(regs, sizeof *regs, ARRAYSIZE(regs));
return ®Data;
}
return NULL;
}
TOOLS_MODULE_EXPORT ToolsPluginData *
ToolsOnLoad(ToolsAppCtx *ctx)
{
static ToolsPluginData regData = {
"vix",
NULL,
NULL
};
RpcChannelCallback rpcs[] = {
{ VIX_BACKDOORCOMMAND_RUN_PROGRAM,
FoundryToolsDaemonRunProgram, NULL, NULL, NULL, 0 },
{ VIX_BACKDOORCOMMAND_GET_PROPERTIES,
FoundryToolsDaemonGetToolsProperties, NULL, NULL, 0 },
{ VIX_BACKDOORCOMMAND_SEND_HGFS_PACKET,
ToolsDaemonHgfsImpersonated, NULL, NULL, NULL, 0 },
{ VIX_BACKDOORCOMMAND_COMMAND,
ToolsDaemonTcloReceiveVixCommand, NULL, NULL, 0 },
{ VIX_BACKDOORCOMMAND_MOUNT_VOLUME_LIST,
ToolsDaemonTcloMountHGFS, NULL, NULL, NULL, 0 },
};
ToolsPluginSignalCb sigs[] = {
{ TOOLS_CORE_SIG_SHUTDOWN, VixShutdown, ®Data }
};
ToolsAppReg regs[] = {
{ TOOLS_APP_GUESTRPC, VMTools_WrapArray(rpcs, sizeof *rpcs, ARRAYSIZE(rpcs)) },
{ TOOLS_APP_SIGNALS, VMTools_WrapArray(sigs, sizeof *sigs, ARRAYSIZE(sigs)) }
};
#if defined(G_PLATFORM_WIN32)
ToolsCore_InitializeCOM(ctx);
#endif
FoundryToolsDaemon_Initialize(ctx);
regData.regs = VMTools_WrapArray(regs, sizeof *regs, ARRAYSIZE(regs));
if (TOOLS_IS_MAIN_SERVICE(ctx) && SyncDriver_Init()) {
size_t i;
size_t reg;
for (reg = 0; reg < ARRAYSIZE(regs); reg++) {
if (regs[reg].type == TOOLS_APP_SIGNALS) {
/*
* If running the system daemon and if the sync driver is active,
* add signal registrations for IO_FREEZE signal.
*/
ToolsPluginSignalCb sysSigs[] = {
{ TOOLS_CORE_SIG_IO_FREEZE, VixIOFreeze, NULL }
};
for (i = 0; i < ARRAYSIZE(sysSigs); i++) {
g_array_append_val(regs[reg].data, sysSigs[i]);
}
}
#if defined(_WIN32) || defined(linux)
else if (regs[reg].type == TOOLS_APP_GUESTRPC) {
/*
* If running the system daemon and if the sync driver is active,
* add RPC registrations for sync driver RPC commands.
*/
RpcChannelCallback sysRpcs[] = {
{ VIX_BACKDOORCOMMAND_SYNCDRIVER_FREEZE,
ToolsDaemonTcloSyncDriverFreeze, NULL, NULL, NULL, 0 },
{ VIX_BACKDOORCOMMAND_SYNCDRIVER_THAW,
ToolsDaemonTcloSyncDriverThaw, NULL, NULL, NULL, 0 }
};
for (i = 0; i < ARRAYSIZE(sysRpcs); i++) {
g_array_append_val(regs[reg].data, sysRpcs[i]);
}
}
#endif
}
}
return ®Data;
}
TOOLS_MODULE_EXPORT ToolsPluginData *
ToolsOnLoad(ToolsAppCtx *ctx)
{
RpcChannelCallback rpcs[] = {
{ "Resolution_Set", &ResolutionResolutionSetCB },
{ "DisplayTopology_Set", &ResolutionDisplayTopologySetCB },
#if defined(RESOLUTION_WIN32)
{ "DisplayTopologyModes_Set", &ResolutionDisplayTopologyModesSetCB },
{ "ChangeHost3DAvailabilityHint", &ResolutionChangeHost3DAvailabilityHintCB },
#endif
};
InitHandle handle;
static ToolsPluginData regData = {
"resolutionSet",
NULL,
NULL
};
ToolsPluginSignalCb sigs[] = {
{ TOOLS_CORE_SIG_CAPABILITIES, ResolutionSetCapabilities, ®Data },
{ TOOLS_CORE_SIG_SHUTDOWN, ResolutionSetShutdown, ®Data }
};
ToolsAppReg regs[] = {
{ TOOLS_APP_GUESTRPC, NULL },
{ TOOLS_APP_SIGNALS, VMTools_WrapArray(sigs, sizeof *sigs, ARRAYSIZE(sigs)) }
};
ResolutionInfoType *resInfo = &resolutionInfo;
/*
* If we aren't running in a VM (e.g., running in bootcamp natively on
* a Mac), then just return NULL.
*/
if (!ctx->isVMware) {
return NULL;
}
/*
* Save the RPC channel name from the ToolsAppCtx so that we can use it later
* in calls to ResolutionSetServerCapability().
*/
if (strcmp(ctx->name, VMTOOLS_GUEST_SERVICE) == 0) {
rpcChannelName = TOOLS_DAEMON_NAME;
} else if (strcmp(ctx->name, VMTOOLS_USER_SERVICE) == 0) {
rpcChannelName = TOOLS_DND_NAME;
} else {
NOT_REACHED();
}
resInfo->initialized = FALSE;
/*
* XXX move to some shared lib or plugin
*/
handle = ResolutionToolkitInit();
ResolutionInit(handle);
regs[0].data = VMTools_WrapArray(rpcs, sizeof *rpcs, ARRAYSIZE(rpcs));
regData.regs = VMTools_WrapArray(regs, sizeof *regs, ARRAYSIZE(regs));
return ®Data;
}
static GArray *
ResolutionSetCapabilities(gpointer src,
ToolsAppCtx *ctx,
gboolean set,
gpointer data)
{
/* The array of capabilities to return to the tools service. */
ToolsAppCapability capabilityArray[RESOLUTION_SET_CAPABILITIES_MAX];
/* The next unused entry in the capabilities array. */
unsigned int capabilityCount = 0;
ResolutionInfoType *resInfo = &resolutionInfo;
g_debug("%s: enter\n", __FUNCTION__);
if (!resInfo->initialized) {
return FALSE;
}
/*
* XXX: We must register display_topology_set before resolution_set to avoid
* a race condition in the host. See bug 472343.
*/
/*
* If we can set the guest topology, add the display_topology_set and
* display_global_offset capabilities to our array.
*/
if (resInfo->canSetTopology) {
/*
* XXX: We use a value of '2' here because, for historical reasons, the
* Workstation/Fusion UI will treat a value of 1 for this capability
* as unsupported. See bug 149541.
*/
capabilityArray[capabilityCount].type = TOOLS_CAP_OLD;
capabilityArray[capabilityCount].name = "display_topology_set";
capabilityArray[capabilityCount].index = 0;
capabilityArray[capabilityCount].value = set ? 2 : 0;
capabilityCount++;
capabilityArray[capabilityCount].type = TOOLS_CAP_OLD;
capabilityArray[capabilityCount].name = "display_global_offset";
capabilityArray[capabilityCount].index = 0;
capabilityArray[capabilityCount].value = set ? 1 : 0;
capabilityCount++;
}
/*
* If we can set the guest resolution, add the resolution_set capability to
* our array.
*/
if (resInfo->canSetResolution) {
capabilityArray[capabilityCount].type = TOOLS_CAP_OLD;
capabilityArray[capabilityCount].name = "resolution_set";
capabilityArray[capabilityCount].index = 0;
capabilityArray[capabilityCount].value = set ? 1 : 0;
capabilityCount++;
/*
* Send the resolution_server RPC to the VMX.
*
* XXX: We need to send this ourselves, instead of including it in the
* capability array, because the resolution_server RPC includes the
* name of the RPC channel that the VMX should use when sending
* resolution set RPCs as an argument.
*/
if (ctx && ctx->rpc && ctx->isVMware) {
ResolutionSetServerCapability(ctx->rpc, set ? 1 : 0);
}
}
#if defined(RESOLUTION_WIN32)
/*
* XXX: I believe we can always handle these RPCs from the service, even on
* Vista, so we always set the capabilities here, regardless of the
* value of resInfo->canSetTopology.
*/
g_debug("%s: setting DPY_TOPO_MODES_SET_IDX to %u\n", __FUNCTION__,
set ? 1 : 0);
capabilityArray[capabilityCount].type = TOOLS_CAP_NEW;
capabilityArray[capabilityCount].name = NULL;
capabilityArray[capabilityCount].index = CAP_SET_TOPO_MODES;
capabilityArray[capabilityCount].value = set ? 1 : 0;
capabilityCount++;
capabilityArray[capabilityCount].type = TOOLS_CAP_NEW;
capabilityArray[capabilityCount].name = NULL;
capabilityArray[capabilityCount].index = CAP_CHANGE_HOST_3D_AVAILABILITY_HINT;
capabilityArray[capabilityCount].value = set ? 1 : 0;
capabilityCount++;
#endif
ASSERT(capabilityCount <= RESOLUTION_SET_CAPABILITIES_MAX);
return VMTools_WrapArray(capabilityArray,
sizeof *capabilityArray,
capabilityCount);
}
