/** Something went wrong (error code in flags). */ * Input flags, set by the host. This is needed for * handling flags on the guest side. * Note: Has to match Main's ProcessInputFlag_* flags! * Guest session creation flags. * Only handled internally at the moment. * Guest directory removement flags. * Essentially using what IPRT's RTDIRRMREC_F_ /** Delete the content of the directory and the directory itself. */ /** Only delete the content of the directory, omit the directory it self. */ /** Mask of valid flags. */ * Guest process creation flags. * Note: Has to match Main's ProcessCreateFlag_* flags! * Pipe handle IDs used internally for referencing to * Guest path rename flags. * Essentially using what IPRT's RTPATHRENAME_FLAGS_ /** Do not replace anything. */ /** This will replace attempt any target which isn't a directory. */ /** Don't allow symbolic links as part of the path. */ /** Mask of valid flags. */ * Defines for guest process array lengths. /** @name Internal tools built into VBoxService which are used in order to * accomplish tasks host<->guest. * Input status, reported by the client. /** Input is in an undefined state. */ /** Input was written (partially, see cbProcessed). */ /** Input failed with an error (see flags for rc). */ /** Process has abandoned / terminated input handling. */ /** Too much input data. */ * Structure keeping the context of a host callback. /** HGCM Function number. */ /** Protocol version of this guest session. Might * be 0 if not supported. */ * Structure for low level HGCM host callback from * the guest. No deep copy. */ /** Number of HGCM parameters. */ /** Actual HGCM parameters. */ * The service functions which are callable by host. * The host asks the client to cancel all pending waits and exit. * The host wants to create a guest session. * The host wants to close a guest session. * The host wants to execute something in the guest. This can be a command line ** Note: Legacy (VBox < 4.3) command. * Sends input data for stdin to a running process executed by HOST_EXEC_CMD. ** Note: Legacy (VBox < 4.3) command. * Gets the current status of a running process, e.g. ** Note: Legacy (VBox < 4.3) command. * Terminates a running guest process. * Waits for a certain event to happen. This can be an input, output * Reads from an opened guest file. * Reads from an opened guest file at * Write to an opened guest file. * Write to an opened guest file at * Changes the read & write position of an opened guest file. * Gets the current file position of an opened guest file. * Removes a directory on the guest. * Renames a path on the guest. * The service functions which are called by guest. The numbers may not change, * Guest waits for a new message the host wants to process on the guest side. * This is a blocking call and can be deferred. * Guest asks the host to cancel all pending waits the guest itself waits on. * This becomes necessary when the guest wants to quit but still waits for * commands from the host. * Guest disconnected (terminated normally or due to a crash HGCM * detected when calling service::clientDisconnect(). * Sets a message filter to only get messages which have a certain * context ID scheme (that is, a specific session, object etc). * Unsets (and resets) a previously set message filter. * Skips the current assigned message returned by GUEST_MSG_WAIT. * Needed for telling the host service to not keep stale * host commands in the queue. * General reply to a host message. Only contains basic data * along with a simple payload. * General message for updating a pending progress for * Guest reports back a guest session status. * Guest wants to close a specific guest session. * Guests sends output from an executed process. * Guest sends a status update of an executed process to the host. * Guests sends an input status notification to the host. * Guest notifies the host about some I/O event. This can be * a stdout, stderr or a stdin event. The actual event only tells * how many data is available / can be sent without actually * Guest notifies the host about some directory event. * Guest notifies the host about some file event. * Guest session notification types. * @sa HGCMMsgSessionNotify. /** Something went wrong (see rc). */ /** Guest session has been started. */ /** Guest session terminated normally. */ /** Guest session terminated via signal. */ /** Guest session terminated abnormally. */ /** Guest session timed out and was killed. */ /** Guest session timed out and was not killed successfully. */ /** Service/OS is stopping, process was killed. */ * Guest directory notification types. /** Something went wrong (see rc). */ /** Guest directory opened. */ /** Guest directory closed. */ /** Information about an open guest directory. */ /** Guest directory created. */ /** Guest directory deleted. */ * Guest file notification types. * Guest file seeking types. Has to * match FileSeekType in Main. * HGCM parameter structures. * Waits for a host command to arrive. The structure then contains the * actual message type + required number of parameters needed to successfully * retrieve that host command (in a next round). * The returned command the host wants to /** Number of parameters the message needs. */ * Asks the guest control host service to set a command * filter for this client. This filter will then only * deliver messages to the client which match the * wanted context ID (ranges). /** Value to filter for after filter mask /** Mask to add to the current set filter. */ /** Mask to remove from the current set filter. */ /** Filter flags; currently unused. */ * Asks the guest control host service to disable * a previously set message filter again. /** Unset flags; currently unused. */ * Asks the guest control host service to skip the * currently assigned host command returned by * VbglR3GuestCtrlMsgWaitFor(). /** Skip flags; currently unused. */ * Asks the guest control host service to cancel all pending (outstanding) * waits which were not processed yet. This is handy for a graceful shutdown. /** IPRT result of overall operation. */ /** Optional payload to this reply. */ * Creates a guest session. /** The guest control protocol version this * session is about to use. */ /** The user name to run the guest session under. */ /** The user's password. */ /** The domain to run the guest session under. */ /** Session creation flags. */ * Terminates (closes) a guest session. /** Session termination flags. */ * Reports back a guest session's status. /** Notification type. */ /** Notification result. */ /** UInt32: Context ID. */ /** Destination to rename source to. */ /** UInt32: Rename flags. */ * Executes a command inside the guest. /** The command to execute on the guest. */ /** Execution flags (see IGuest::ProcessCreateFlag_*). */ /** Number of arguments. */ /** The actual arguments. */ /** Number of environment value pairs. */ /** Size (in bytes) of environment block, including terminating zeros. */ /** The actual environment block. */ /** The user name to run the executed command under. * Only for VBox < 4.3 hosts. */ * Only for VBox < 4.3 hosts. */ /** Timeout (in msec) which either specifies the * overall lifetime of the process or how long it * can take to bring the process up and running - * (depends on the IGuest::ProcessCreateFlag_*). */ /** Timeout (in ms) which either specifies the * overall lifetime of the process or how long it * can take to bring the process up and running - * (depends on the IGuest::ProcessCreateFlag_*). */ /** Number of process affinity blocks. */ /** Pointer to process affinity blocks (uint64_t). */ * Sends input to a guest process via stdin. /** The process ID (PID) to send the input to. */ /** Input flags (see IGuest::ProcessInputFlag_*). */ /** Actual size of data (in bytes). */ * Retrieves ouptut from a previously executed process /** The process ID (PID). */ * Reports the current status of a guest process. /** The process ID (PID). */ /** The process status. */ /** Optional flags (based on status). */ /** Optional data buffer (not used atm). */ * Reports back the status of data written to a process. /** The process ID (PID). */ /** Status of the operation. */ * Guest control 2.0 messages. * Terminates a guest process. /** The process ID (PID). */ * Waits for certain events to happen. /** The process ID (PID). */ /** Wait (event) flags. */ /** UInt32: Context ID. */ /** Directory to remove. */ /** UInt32: Removement flags. */ /** UInt32: Context ID. */ /** UInt32: Creation mode. */ /** UInt64: Initial offset. */ /** File handle to close. */ * Reads from a guest file. /** File handle to read from. */ /** Size (in bytes) to read. */ * Reads at a specified offset from a guest file. /** File handle to read from. */ /** Offset where to start reading from. */ /** Actual size of data (in bytes). */ * Writes to a guest file. /** File handle to write to. */ /** Actual size of data (in bytes). */ /** Data buffer to write to the file. */ * Writes at a specified offset to a guest file. /** File handle to write to. */ /** Offset where to start reading from. */ /** Actual size of data (in bytes). */ /** Data buffer to write to the file. */ * Seeks the read/write position of a guest file. /** File handle to seek. */ /** The seeking method. */ /** The seeking offset. */ * Tells the current read/write position of a guest file. /** File handle to get the current position for. */ /****************************************************************************** * HGCM replies from the guest. These are handled in Main's low-level HGCM * * callbacks and dispatched to the appropriate guest object. * ******************************************************************************/ /** Notification type. */ /** IPRT result of overall operation. */ /** Guest file handle. */ /** Note: Close does not have any additional data (yet). */ /** Actual data read (if any). */ /** How much data (in bytes) have been successfully written. */ /** Notification type. */ /** IPRT result of overall operation. */ /** Directory information. */ /** Guest directory handle. */ /** Current read directory entry. */ /** Extended entry object information. Optional. */ /****************************************************************************** * Callback data structures. * ******************************************************************************/ * The guest control callback data header. Must come first * on each callback structure defined below this struct. /** Context ID to identify callback data. This is * and *must* be the very first parameter in this * structure to still be backwards compatible. */ * These structures make up the actual low level HGCM callback data sent from * the guest back to the host. /** Callback data header. */ /** Callback data header. */ /** Notification type. */ /** Notification result. Note: int vs. uint32! */ /** Pointer to optional payload. */ /** Payload size (in bytes). */ /** Callback data header. */ /** Notification type. */ /** Notification result. Note: int vs. uint32! */ /** Callback data header. */ /** The process ID (PID). */ /** The process status. */ /** Optional flags, varies, based on u32Status. */ /** Optional data buffer (not used atm). */ /** Size of optional data buffer (not used atm). */ /** Callback data header. */ /** The process ID (PID). */ /** Optional flags (not used atm). */ /** Optional data buffer. */ /** Size (in bytes) of optional data buffer. */ /** Callback data header. */ /** The process ID (PID). */ /** Current input status. */ /** Size (in bytes) of processed input data. */ * General guest directory notification callback. /** Callback data header. */ /** Notification type. */ /** IPRT result of overall operation. */ /** Size (in bytes) of directory information. */ /** Pointer to directory information. */ /** Guest directory handle. */ /** Note: Close does not have any additional data (yet). */ /** Size (in bytes) of directory entry information. */ /** Pointer to directory entry information. */ /** Size (in bytes) of directory entry object information. */ /** Pointer to directory entry object information. */ * General guest file notification callback. /** Callback data header. */ /** Notification type. */ /** IPRT result of overall operation. */ /** Guest file handle. */ /** Note: Close does not have any additional data (yet). */ /** How much data (in bytes) have been read. */ /** Actual data read (if any). */ /** How much data (in bytes) have been successfully written. */ /** New file offset after successful seek. */ /** New file offset after successful tell. */ }
/* namespace guestControl */#
endif /* !___VBox_HostService_GuestControlService_h */