VirtualBox

Changeset 44863 in vbox


Ignore:
Timestamp:
Feb 28, 2013 12:18:17 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
84015
Message:

GuestCtrl: Infrastructure changes for handling and executing dedicated guest sessions and protocol versioning (untested, work in progress).

Location:
trunk
Files:
2 added
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/HostServices/GuestControlSvc.h

    r42846 r44863  
    44
    55/*
    6  * Copyright (C) 2011-2012 Oracle Corporation
     6 * Copyright (C) 2011-2013 Oracle Corporation
    77 *
    88 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    4141* Typedefs, constants and inlines                                             *
    4242******************************************************************************/
     43
     44#define HGCMSERVICE_NAME "VBoxGuestControlSvc"
     45
     46/** Maximum number of concurrent guest sessions a VM can have. */
     47#define VBOX_GUESTCTRL_MAX_SESSIONS     32
     48/** Maximum number of concurrent guest objects (processes, files, ...)
     49 *  a guest session can have. */
     50#define VBOX_GUESTCTRL_MAX_OBJECTS      _2K
     51/** Maximum of callback contexts a guest process can have. */
     52#define VBOX_GUESTCTRL_MAX_CONTEXTS     _64K
     53
     54/** Builds a context ID out of the session ID, object ID and an
     55 *  increasing count. */
     56#define VBOX_GUESTCTRL_CONTEXTID_MAKE(uSession, uObject, uCount) \
     57    (  (uint32_t)((uSession) &   0x1f) << 27 \
     58     | (uint32_t)((uObject)  &  0x7ff) << 16 \
     59     | (uint32_t)((uCount)   & 0xffff)       \
     60    )
     61#define VBOX_GUESTCTRL_CONTEXTID_MAKE_SESSION(uSession) \
     62    ((uint32_t)((uSession) & 0x1f) << 27)
     63/** Gets the session ID out of a context ID. */
     64#define VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(uContextID) \
     65    ((uContextID) >> 27)
     66/** Gets the process ID out of a context ID. */
     67#define VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(uContextID) \
     68    (((uContextID) >> 16) & 0x7ff)
     69/** Gets the context count of a process out of a context ID. */
     70#define VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID) \
     71    ((uContextID) & 0xffff)
    4372
    4473/**
    … …  
    104133#define GUESTPROCESS_MAX_USER_LEN           128
    105134#define GUESTPROCESS_MAX_PASSWORD_LEN       128
     135#define GUESTPROCESS_MAX_DOMAIN_LEN         256
    106136
    107137/** @name Internal tools built into VBoxService which are used in order to
    … …  
    135165
    136166/**
    137  * The guest control callback data header. Must come first
    138  * on each callback structure defined below this struct.
    139  */
    140 typedef struct VBoxGuestCtrlCallbackHeader
    141 {
    142     /** Magic number to identify the structure. */
    143     uint32_t u32Magic;
    144     /** Context ID to identify callback data. */
    145     uint32_t u32ContextID;
    146 } CALLBACKHEADER;
    147 typedef CALLBACKHEADER *PCALLBACKHEADER;
    148 
    149 typedef struct VBoxGuestCtrlCallbackDataClientDisconnected
    150 {
    151     /** Callback data header. */
    152     CALLBACKHEADER hdr;
    153 } CALLBACKDATACLIENTDISCONNECTED;
    154 typedef CALLBACKDATACLIENTDISCONNECTED *PCALLBACKDATACLIENTDISCONNECTED;
    155 
    156 /**
    157  * Data structure to pass to the service extension callback.  We use this to
    158  * notify the host of changes to properties.
    159  */
    160 typedef struct VBoxGuestCtrlCallbackDataExecStatus
    161 {
    162     /** Callback data header. */
    163     CALLBACKHEADER hdr;
    164     /** The process ID (PID). */
    165     uint32_t u32PID;
    166     /** The process status. */
    167     uint32_t u32Status;
    168     /** Optional flags, varies, based on u32Status. */
    169     uint32_t u32Flags;
    170     /** Optional data buffer (not used atm). */
    171     void *pvData;
    172     /** Size of optional data buffer (not used atm). */
    173     uint32_t cbData;
    174 } CALLBACKDATAEXECSTATUS;
    175 typedef CALLBACKDATAEXECSTATUS *PCALLBACKDATAEXECSTATUS;
    176 
    177 typedef struct VBoxGuestCtrlCallbackDataExecOut
    178 {
    179     /** Callback data header. */
    180     CALLBACKHEADER hdr;
    181     /** The process ID (PID). */
    182     uint32_t u32PID;
    183     /** The handle ID (stdout/stderr). */
    184     uint32_t u32HandleId;
    185     /** Optional flags (not used atm). */
    186     uint32_t u32Flags;
    187     /** Optional data buffer. */
    188     void *pvData;
    189     /** Size (in bytes) of optional data buffer. */
    190     uint32_t cbData;
    191 } CALLBACKDATAEXECOUT;
    192 typedef CALLBACKDATAEXECOUT *PCALLBACKDATAEXECOUT;
    193 
    194 typedef struct VBoxGuestCtrlCallbackDataExecInStatus
    195 {
    196     /** Callback data header. */
    197     CALLBACKHEADER hdr;
    198     /** The process ID (PID). */
    199     uint32_t u32PID;
    200     /** Current input status. */
    201     uint32_t u32Status;
    202     /** Optional flags. */
    203     uint32_t u32Flags;
    204     /** Size (in bytes) of processed input data. */
    205     uint32_t cbProcessed;
    206 } CALLBACKDATAEXECINSTATUS;
    207 typedef CALLBACKDATAEXECINSTATUS *PCALLBACKDATAEXECINSTATUS;
    208 
    209 enum eVBoxGuestCtrlCallbackDataMagic
    210 {
    211     CALLBACKDATAMAGIC_CLIENT_DISCONNECTED = 0x08041984,
    212 
    213     CALLBACKDATAMAGIC_EXEC_STATUS = 0x26011982,
    214     CALLBACKDATAMAGIC_EXEC_OUT = 0x11061949,
    215     CALLBACKDATAMAGIC_EXEC_IN_STATUS = 0x19091951
    216 };
    217 
    218 enum eVBoxGuestCtrlCallbackType
    219 {
    220     VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN = 0,
    221 
    222     VBOXGUESTCTRLCALLBACKTYPE_EXEC_START = 1,
    223     VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT = 2,
    224     VBOXGUESTCTRLCALLBACKTYPE_EXEC_INPUT_STATUS = 3
    225 };
     167 * Structure keeping the context of a host callback.
     168 */
     169typedef struct VBoxGuestCtrlHostCbCtx
     170{
     171    /** HGCM Function number. */
     172    uint32_t uFunction;
     173    /** The context ID. */
     174    uint32_t uContextID;
     175    /** Protocol version of this guest session. Might
     176     *  be 0 if not supported. */
     177    uint32_t uProtocol;
     178
     179} VBOXGUESTCTRLHOSTCBCTX, *PVBOXGUESTCTRLHOSTCBCTX;
     180
     181/**
     182 * Structure for low level HGCM host callback from
     183 * the guest. No deep copy. */
     184typedef struct VBoxGuestCtrlHostCallback
     185{
     186    VBoxGuestCtrlHostCallback(uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     187                                : mParms(cParms), mpaParms(paParms) { }
     188
     189    uint32_t mParms;
     190    PVBOXHGCMSVCPARM mpaParms;
     191
     192} VBOXGUESTCTRLHOSTCALLBACK, *PVBOXGUESTCTRLHOSTCALLBACK;
    226193
    227194/**
    … …  
    234201     */
    235202    HOST_CANCEL_PENDING_WAITS = 0,
    236 
    237     /*
    238      * Execution handling.
    239      */
    240 
     203    /**
     204     * The host wants to create a guest session.
     205     */
     206    HOST_SESSION_CREATE = 20,
     207    /**
     208     * The host wants to close a guest session.
     209     */
     210    HOST_SESSION_CLOSE = 21,
    241211    /**
    242212     * The host wants to execute something in the guest. This can be a command line
    243213     * or starting a program.
     214     ** Note: Legacy (VBox < 4.3) command.
    244215     */
    245216    HOST_EXEC_CMD = 100,
    246217    /**
    247218     * Sends input data for stdin to a running process executed by HOST_EXEC_CMD.
     219     ** Note: Legacy (VBox < 4.3) command.
    248220     */
    249221    HOST_EXEC_SET_INPUT = 101,
    … …  
    251223     * Gets the current status of a running process, e.g.
    252224     * new data on stdout/stderr, process terminated etc.
     225     ** Note: Legacy (VBox < 4.3) command.
    253226     */
    254227    HOST_EXEC_GET_OUTPUT = 102,
    255 
    256     /*
    257      * Guest control 2.0 commands start in the 2xx number space.
    258      */
    259 
     228    /**
     229     * Terminates a running guest process.
     230     */
     231    HOST_EXEC_TERMINATE = 110,
    260232    /**
    261233     * Waits for a certain event to happen. This can be an input, output
    262234     * or status event.
    263235     */
    264     HOST_EXEC_WAIT_FOR = 210,
     236    HOST_EXEC_WAIT_FOR = 120,
    265237    /**
    266238     * Opens a guest file.
    … …  
    274246     * Reads from an opened guest file.
    275247     */
    276     HOST_FILE_READ = 242,
     248    HOST_FILE_READ = 250,
     249    /**
     250     * Reads from an opened guest file at
     251     * a specified offset.
     252     */
     253    HOST_FILE_READ_AT = 251,
    277254    /**
    278255     * Write to an opened guest file.
    279256     */
    280     HOST_FILE_WRITE = 243,
     257    HOST_FILE_WRITE = 260,
     258    /**
     259     * Write to an opened guest file at
     260     * a specified offset.
     261     */
     262    HOST_FILE_WRITE_AT = 261,
    281263    /**
    282264     * Changes the read & write position of an opened guest file.
    283265     */
    284     HOST_FILE_SEEK = 244,
     266    HOST_FILE_SEEK = 270,
    285267    /**
    286268     * Gets the current file position of an opened guest file.
    287269     */
    288     HOST_FILE_TELL = 245
     270    HOST_FILE_TELL = 271
    289271};
    290272
    291273/**
    292  * The service functions which are called by guest.  The numbers may not change,
     274 * The service functions which are called by guest. The numbers may not change,
    293275 * so we hardcode them.
     276 *
     277 * Note: Callbacks start at 100. See CALLBACKTYPE enum.
    294278 */
    295279enum eGuestFn
    … …  
    299283     * This is a blocking call and can be deferred.
    300284     */
    301     GUEST_GET_HOST_MSG = 1,
     285    GUEST_MSG_WAIT = 1,
    302286    /**
    303287     * Guest asks the host to cancel all pending waits the guest itself waits on.
    … …  
    311295     */
    312296    GUEST_DISCONNECTED = 3,
    313 
    314     /*
    315      * Process execution.
    316      * The 1xx commands are legacy guest control commands and
    317      * will be replaced by newer commands in the future.
    318      */
    319 
     297    /**
     298     * Sets a message filter to only get messages which have a certain
     299     * context ID scheme (that is, a specific session, object etc).
     300     * Since VBox 4.3+.
     301     */
     302    GUEST_MSG_FILTER = 4,
     303    /**
     304     * Guest reports back a guest session status.
     305     */
     306    GUEST_SESSION_NOTIFY = 20,
    320307    /**
    321308     * Guests sends output from an executed process.
    322309     */
    323     GUEST_EXEC_SEND_OUTPUT = 100,
     310    GUEST_EXEC_OUTPUT = 100,
    324311    /**
    325312     * Guest sends a status update of an executed process to the host.
    326313     */
    327     GUEST_EXEC_SEND_STATUS = 101,
     314    GUEST_EXEC_STATUS = 101,
    328315    /**
    329316     * Guests sends an input status notification to the host.
    330317     */
    331     GUEST_EXEC_SEND_INPUT_STATUS = 102,
    332 
    333     /*
    334      * Guest control 2.0 commands start in the 2xx number space.
    335      */
    336 
     318    GUEST_EXEC_INPUT_STATUS = 102,
    337319    /**
    338320     * Guest notifies the host about some I/O event. This can be
    … …  
    349331
    350332/**
     333 * Guest session notification types.
     334 * @sa HGCMMsgSessionNotify.
     335 */
     336enum GUEST_SESSION_NOTIFYTYPE
     337{
     338    GUEST_SESSION_NOTIFYTYPE_UNKNOWN = 0,
     339    GUEST_SESSION_NOTIFYTYPE_ERROR = 1,
     340    GUEST_SESSION_NOTIFYTYPE_OPEN = 10,
     341    GUEST_SESSION_NOTIFYTYPE_CLOSE = 20
     342};
     343
     344/**
    351345 * Guest file notification types.
    352346 */
    353 enum eGuestFileNotifyType
    354 {
    355     GUESTFILENOTIFYTYPE_ERROR = 0,
    356     GUESTFILENOTIFYTYPE_OPEN = 10,
    357     GUESTFILENOTIFYTYPE_CLOSE = 20,
    358     GUESTFILENOTIFYTYPE_READ = 30,
    359     GUESTFILENOTIFYTYPE_WRITE = 40,
    360     GUESTFILENOTIFYTYPE_SEEK = 50,
    361     GUESTFILENOTIFYTYPE_TELL = 60
     347enum GUEST_FILE_NOTIFYTYPE
     348{
     349    GUEST_FILE_NOTIFYTYPE_UNKNOWN = 0,
     350    GUEST_FILE_NOTIFYTYPE_ERROR = 1,
     351    GUEST_FILE_NOTIFYTYPE_OPEN = 10,
     352    GUEST_FILE_NOTIFYTYPE_CLOSE = 20,
     353    GUEST_FILE_NOTIFYTYPE_READ = 30,
     354    GUEST_FILE_NOTIFYTYPE_WRITE = 40,
     355    GUEST_FILE_NOTIFYTYPE_SEEK = 50,
     356    GUEST_FILE_NOTIFYTYPE_TELL = 60
     357};
     358
     359/**
     360 * Guest file seeking types.
     361 */
     362enum GUEST_FILE_SEEKTYPE
     363{
     364    GUEST_FILE_SEEKTYPE_BEGIN = 1,
     365    GUEST_FILE_SEEKTYPE_CURRENT = 4,
     366    GUEST_FILE_SEEKTYPE_END = 8
    362367};
    363368
    … …  
    367372#pragma pack (1)
    368373
    369 typedef struct VBoxGuestCtrlHGCMMsgType
     374/**
     375 * Waits for a host command to arrive. The structure then contains the
     376 * actual message type + required number of parameters needed to successfully
     377 * retrieve that host command (in a next round).
     378 */
     379typedef struct HGCMMsgCmdWaitFor
    370380{
    371381    VBoxGuestHGCMCallInfo hdr;
    … …  
    379389    HGCMFunctionParameter num_parms; /* OUT uint32_t */
    380390
    381 } VBoxGuestCtrlHGCMMsgType;
     391} HGCMMsgCmdWaitFor;
     392
     393/**
     394 * Asks the guest control host service to set a command
     395 * filter for this client. The filter itself will affect
     396 * the context ID bound to a command.
     397 */
     398typedef struct HGCMMsgCmdSetFilter
     399{
     400    VBoxGuestHGCMCallInfo hdr;
     401
     402    /* Mask of context IDs to be filtered. */
     403    HGCMFunctionParameter add;      /* IN uint32_t */
     404    /* Exclude masked; unused. */
     405    HGCMFunctionParameter remove;   /* IN uint32_t */
     406
     407} HGCMMsgCmdSetFilter;
    382408
    383409/**
    … …  
    385411 * waits which were not processed yet.  This is handy for a graceful shutdown.
    386412 */
    387 typedef struct VBoxGuestCtrlHGCMMsgCancelPendingWaits
    388 {
    389     VBoxGuestHGCMCallInfo hdr;
    390 } VBoxGuestCtrlHGCMMsgCancelPendingWaits;
     413typedef struct HGCMMsgCancelPendingWaits
     414{
     415    VBoxGuestHGCMCallInfo hdr;
     416} HGCMMsgCancelPendingWaits;
     417
     418/**
     419 * Creates a guest session.
     420 */
     421typedef struct HGCMMsgSessionOpen
     422{
     423    VBoxGuestHGCMCallInfo hdr;
     424    /** Context ID. */
     425    HGCMFunctionParameter context;
     426    /** The guest control protocol version this
     427     *  session is about to use. */
     428    HGCMFunctionParameter protocol;
     429    /** The user name to run the guest session under. */
     430    HGCMFunctionParameter username;
     431    /** The user's password. */
     432    HGCMFunctionParameter password;
     433    /** The domain to run the guest session under. */
     434    HGCMFunctionParameter domain;
     435    /** Session creation flags. */
     436    HGCMFunctionParameter flags;
     437} HGCMMsgSessionOpen;
     438
     439/**
     440 * Terminates (closes) a guest session.
     441 */
     442typedef struct HGCMMsgSessionClose
     443{
     444    VBoxGuestHGCMCallInfo hdr;
     445    /** Context ID. */
     446    HGCMFunctionParameter context;
     447    /** Session termination flags. */
     448    HGCMFunctionParameter flags;
     449} HGCMMsgSessionClose;
     450
     451/**
     452 * Reports back a guest session's status.
     453 */
     454typedef struct HGCMMsgSessionNotify
     455{
     456    VBoxGuestHGCMCallInfo hdr;
     457    /** Context ID. */
     458    HGCMFunctionParameter context;
     459    /** Notification type. */
     460    HGCMFunctionParameter type;
     461    /** Notification result. */
     462    HGCMFunctionParameter result;
     463} HGCMMsgSessionNotify;
    391464
    392465/**
    393466 * Executes a command inside the guest.
    394467 */
    395 typedef struct VBoxGuestCtrlHGCMMsgExecCmd
     468typedef struct HGCMMsgProcExec
    396469{
    397470    VBoxGuestHGCMCallInfo hdr;
    … …  
    412485    /** The actual environment block. */
    413486    HGCMFunctionParameter env;
    414     /** The user name to run the executed command under. */
    415     HGCMFunctionParameter username;
    416     /** The user's password. */
    417     HGCMFunctionParameter password;
    418     /** Timeout (in msec) which either specifies the
    419      *  overall lifetime of the process or how long it
    420      *  can take to bring the process up and running -
    421      *  (depends on the IGuest::ProcessCreateFlag_*). */
    422     HGCMFunctionParameter timeout;
    423 
    424 } VBoxGuestCtrlHGCMMsgExecCmd;
    425 
    426 /**
    427  * Injects input to a previously executed process via stdin.
    428  */
    429 typedef struct VBoxGuestCtrlHGCMMsgExecIn
     487    union
     488    {
     489        struct
     490        {
     491            /** The user name to run the executed command under.
     492             *  Only for VBox < 4.3 hosts. */
     493            HGCMFunctionParameter username;
     494            /** The user's password.
     495             *  Only for VBox < 4.3 hosts. */
     496            HGCMFunctionParameter password;
     497            /** Timeout (in msec) which either specifies the
     498             *  overall lifetime of the process or how long it
     499             *  can take to bring the process up and running -
     500             *  (depends on the IGuest::ProcessCreateFlag_*). */
     501            HGCMFunctionParameter timeout;
     502        } v1;
     503        struct
     504        {
     505            /** Timeout (in msec) which either specifies the
     506             *  overall lifetime of the process or how long it
     507             *  can take to bring the process up and running -
     508             *  (depends on the IGuest::ProcessCreateFlag_*). */
     509            HGCMFunctionParameter timeout;
     510            /** Process priority. */
     511            HGCMFunctionParameter priority;
     512            /** Number of process affinity blocks. */
     513            HGCMFunctionParameter num_affinity;
     514            /** Pointer to process affinity blocks (uint64_t). */
     515            HGCMFunctionParameter affinity;
     516        } v2;
     517    } u;
     518
     519} HGCMMsgProcExec;
     520
     521/**
     522 * Sends input to a guest process via stdin.
     523 */
     524typedef struct HGCMMsgProcInput
    430525{
    431526    VBoxGuestHGCMCallInfo hdr;
    … …  
    441536    HGCMFunctionParameter size;
    442537
    443 } VBoxGuestCtrlHGCMMsgExecIn;
     538} HGCMMsgProcInput;
    444539
    445540/**
    … …  
    447542 * from stdout/stderr.
    448543 */
    449 typedef struct VBoxGuestCtrlHGCMMsgExecOut
     544typedef struct HGCMMsgProcOutput
    450545{
    451546    VBoxGuestHGCMCallInfo hdr;
    … …  
    461556    HGCMFunctionParameter data;
    462557
    463 } VBoxGuestCtrlHGCMMsgExecOut;
    464 
    465 /**
    466  * Reports the current status of a (just) started
    467  * or terminated process.
    468  */
    469 typedef struct VBoxGuestCtrlHGCMMsgExecStatus
     558} HGCMMsgProcOutput;
     559
     560/**
     561 * Reports the current status of a guest process.
     562 */
     563typedef struct HGCMMsgProcStatus
    470564{
    471565    VBoxGuestHGCMCallInfo hdr;
    … …  
    481575    HGCMFunctionParameter data;
    482576
    483 } VBoxGuestCtrlHGCMMsgExecStatus;
     577} HGCMMsgProcStatus;
    484578
    485579/**
    486580 * Reports back the status of data written to a process.
    487581 */
    488 typedef struct VBoxGuestCtrlHGCMMsgExecStatusIn
     582typedef struct HGCMMsgProcStatusInput
    489583{
    490584    VBoxGuestHGCMCallInfo hdr;
    … …  
    500594    HGCMFunctionParameter written;
    501595
    502 } VBoxGuestCtrlHGCMMsgExecStatusIn;
     596} HGCMMsgProcStatusInput;
    503597
    504598/*
    … …  
    507601
    508602/**
    509  * Reports back the currente I/O status of a guest process.
    510  */
    511 typedef struct VBoxGuestCtrlHGCMMsgExecIONotify
    512 {
    513     VBoxGuestHGCMCallInfo hdr;
    514     /** Context ID. */
    515     HGCMFunctionParameter context;
    516     /** Data written. */
    517     HGCMFunctionParameter written;
    518 
    519 } VBoxGuestCtrlHGCMMsgExecIONotify;
     603 * Terminates a guest process.
     604 */
     605typedef struct HGCMMsgProcTerminate
     606{
     607    VBoxGuestHGCMCallInfo hdr;
     608    /** Context ID. */
     609    HGCMFunctionParameter context;
     610    /** The process ID (PID). */
     611    HGCMFunctionParameter pid;
     612
     613} HGCMMsgProcTerminate;
     614
     615/**
     616 * Waits for certain events to happen.
     617 */
     618typedef struct HGCMMsgProcWaitFor
     619{
     620    VBoxGuestHGCMCallInfo hdr;
     621    /** Context ID. */
     622    HGCMFunctionParameter context;
     623    /** The process ID (PID). */
     624    HGCMFunctionParameter pid;
     625    /** Wait (event) flags. */
     626    HGCMFunctionParameter flags;
     627    /** Timeout (in ms). */
     628    HGCMFunctionParameter timeout;
     629
     630} HGCMMsgProcWaitFor;
    520631
    521632/**
    522633 * Opens a guest file.
    523634 */
    524 typedef struct VBoxGuestCtrlHGCMMsgFileOpen
    525 {
    526     VBoxGuestHGCMCallInfo hdr;
    527     /** Context ID. */
    528     HGCMFunctionParameter context;
    529     /** File to open. */
     635typedef struct HGCMMsgFileOpen
     636{
     637    VBoxGuestHGCMCallInfo hdr;
     638    /** UInt32: Context ID. */
     639    HGCMFunctionParameter context;
     640    /** String: File to open. */
    530641    HGCMFunctionParameter filename;
    531     /** Open mode. */
     642    /** String: Open mode. */
    532643    HGCMFunctionParameter openmode;
    533     /** Disposition. */
     644    /** String: Disposition. */
    534645    HGCMFunctionParameter disposition;
    535     /** Creation mode. */
     646    /** UInt32: Creation mode. */
    536647    HGCMFunctionParameter creationmode;
    537     /** Offset. */
     648    /** UInt64: Initial offset. */
    538649    HGCMFunctionParameter offset;
    539650
    540 } VBoxGuestCtrlHGCMMsgFileOpen;
     651} HGCMMsgFileOpen;
    541652
    542653/**
    543654 * Closes a guest file.
    544655 */
    545 typedef struct VBoxGuestCtrlHGCMMsgFileClose
     656typedef struct HGCMMsgFileClose
    546657{
    547658    VBoxGuestHGCMCallInfo hdr;
    … …  
    551662    HGCMFunctionParameter handle;
    552663
    553 } VBoxGuestCtrlHGCMMsgFileClose;
     664} HGCMMsgFileClose;
    554665
    555666/**
    556667 * Reads from a guest file.
    557668 */
    558 typedef struct VBoxGuestCtrlHGCMMsgFileRead
     669typedef struct HGCMMsgFileRead
    559670{
    560671    VBoxGuestHGCMCallInfo hdr;
    … …  
    568679    HGCMFunctionParameter data;
    569680
    570 } VBoxGuestCtrlHGCMMsgFileRead;
     681} HGCMMsgFileRead;
     682
     683/**
     684 * Reads at a specified offset from a guest file.
     685 */
     686typedef struct HGCMMsgFileReadAt
     687{
     688    VBoxGuestHGCMCallInfo hdr;
     689    /** Context ID. */
     690    HGCMFunctionParameter context;
     691    /** File handle to read from. */
     692    HGCMFunctionParameter handle;
     693    /** Offset where to start reading from. */
     694    HGCMFunctionParameter offset;
     695    /** Actual size of data (in bytes). */
     696    HGCMFunctionParameter size;
     697    /** Where to put the read data into. */
     698    HGCMFunctionParameter data;
     699
     700} HGCMMsgFileReadAt;
    571701
    572702/**
    573703 * Writes to a guest file.
    574704 */
    575 typedef struct VBoxGuestCtrlHGCMMsgFileWrite
     705typedef struct HGCMMsgFileWrite
    576706{
    577707    VBoxGuestHGCMCallInfo hdr;
    … …  
    585715    HGCMFunctionParameter data;
    586716
    587 } VBoxGuestCtrlHGCMMsgFileWrite;
     717} HGCMMsgFileWrite;
     718
     719/**
     720 * Writes at a specified offset to a guest file.
     721 */
     722typedef struct HGCMMsgFileWriteAt
     723{
     724    VBoxGuestHGCMCallInfo hdr;
     725    /** Context ID. */
     726    HGCMFunctionParameter context;
     727    /** File handle to write to. */
     728    HGCMFunctionParameter handle;
     729    /** Offset where to start reading from. */
     730    HGCMFunctionParameter offset;
     731    /** Actual size of data (in bytes). */
     732    HGCMFunctionParameter size;
     733    /** Data buffer to write to the file. */
     734    HGCMFunctionParameter data;
     735
     736} HGCMMsgFileWriteAt;
    588737
    589738/**
    590739 * Seeks the read/write position of a guest file.
    591740 */
    592 typedef struct VBoxGuestCtrlHGCMMsgFileSeek
     741typedef struct HGCMMsgFileSeek
    593742{
    594743    VBoxGuestHGCMCallInfo hdr;
    … …  
    602751    HGCMFunctionParameter offset;
    603752
    604 } VBoxGuestCtrlHGCMMsgFileSeek;
     753} HGCMMsgFileSeek;
    605754
    606755/**
    607756 * Tells the current read/write position of a guest file.
    608757 */
    609 typedef struct VBoxGuestCtrlHGCMMsgFileTell
     758typedef struct HGCMMsgFileTell
    610759{
    611760    VBoxGuestHGCMCallInfo hdr;
    … …  
    615764    HGCMFunctionParameter handle;
    616765
    617 } VBoxGuestCtrlHGCMMsgFileTell;
    618 
    619 typedef struct VBoxGuestCtrlHGCMMsgFileNotify
    620 {
    621     VBoxGuestHGCMCallInfo hdr;
    622     /** Context ID. */
    623     HGCMFunctionParameter context;
    624     /** The file handle. */
    625     HGCMFunctionParameter handle;
     766} HGCMMsgFileTell;
     767
     768typedef struct HGCMMsgFileNotify
     769{
     770    VBoxGuestHGCMCallInfo hdr;
     771    /** Context ID. */
     772    HGCMFunctionParameter context;
    626773    /** Notification type. */
    627774    HGCMFunctionParameter type;
    … …  
    629776    HGCMFunctionParameter payload;
    630777
    631 } VBoxGuestCtrlHGCMMsgFileNotify;
     778} HGCMMsgFileNotify;
    632779
    633780#pragma pack ()
    634781
    635 /**
    636  * Structure for buffering execution requests in the host service.
    637  */
    638 typedef struct VBoxGuestCtrlParamBuffer
    639 {
    640     uint32_t uMsg;
    641     uint32_t uParmCount;
    642     PVBOXHGCMSVCPARM pParms;
    643 } VBOXGUESTCTRPARAMBUFFER;
    644 typedef VBOXGUESTCTRPARAMBUFFER *PVBOXGUESTCTRPARAMBUFFER;
     782/******************************************************************************
     783* Callback data structures.                                                   *
     784******************************************************************************/
     785
     786/**
     787 * The guest control callback data header. Must come first
     788 * on each callback structure defined below this struct.
     789 */
     790typedef struct CALLBACKDATA_HEADER
     791{
     792    /** Context ID to identify callback data. This is
     793     *  and *must* be the very first parameter in this
     794     *  structure to still be backwards compatible. */
     795    uint32_t uContextID;
     796} CALLBACKDATA_HEADER, *PCALLBACKDATA_HEADER;
     797
     798/*
     799 * These structures make up the actual low level HGCM callback data sent from
     800 * the guest back to the host.
     801 */
     802
     803typedef struct CALLBACKDATA_CLIENT_DISCONNECTED
     804{
     805    /** Callback data header. */
     806    CALLBACKDATA_HEADER hdr;
     807} CALLBACKDATA_CLIENT_DISCONNECTED, *PCALLBACKDATA_CLIENT_DISCONNECTED;
     808
     809typedef struct CALLBACKDATA_SESSION_NOTIFY
     810{
     811    /** Callback data header. */
     812    CALLBACKDATA_HEADER hdr;
     813    /** Notification type. */
     814    uint32_t uType;
     815    /** Notification result. */
     816    uint32_t uResult;
     817} CALLBACKDATA_SESSION_NOTIFY, *PCALLBACKDATA_SESSION_NOTIFY;
     818
     819typedef struct CALLBACKDATA_PROC_STATUS
     820{
     821    /** Callback data header. */
     822    CALLBACKDATA_HEADER hdr;
     823    /** The process ID (PID). */
     824    uint32_t uPID;
     825    /** The process status. */
     826    uint32_t uStatus;
     827    /** Optional flags, varies, based on u32Status. */
     828    uint32_t uFlags;
     829    /** Optional data buffer (not used atm). */
     830    void *pvData;
     831    /** Size of optional data buffer (not used atm). */
     832    uint32_t cbData;
     833} CALLBACKDATA_PROC_STATUS, *PCALLBACKDATA_PROC_STATUS;
     834
     835typedef struct CALLBACKDATA_PROC_OUTPUT
     836{
     837    /** Callback data header. */
     838    CALLBACKDATA_HEADER hdr;
     839    /** The process ID (PID). */
     840    uint32_t uPID;
     841    /** The handle ID (stdout/stderr). */
     842    uint32_t uHandle;
     843    /** Optional flags (not used atm). */
     844    uint32_t uFlags;
     845    /** Optional data buffer. */
     846    void *pvData;
     847    /** Size (in bytes) of optional data buffer. */
     848    uint32_t cbData;
     849} CALLBACKDATA_PROC_OUTPUT, *PCALLBACKDATA_PROC_OUTPUT;
     850
     851typedef struct CALLBACKDATA_PROC_INPUT
     852{
     853    /** Callback data header. */
     854    CALLBACKDATA_HEADER hdr;
     855    /** The process ID (PID). */
     856    uint32_t uPID;
     857    /** Current input status. */
     858    uint32_t uStatus;
     859    /** Optional flags. */
     860    uint32_t uFlags;
     861    /** Size (in bytes) of processed input data. */
     862    uint32_t uProcessed;
     863} CALLBACKDATA_PROC_INPUT, *PCALLBACKDATA_PROC_INPUT;
     864
     865typedef struct CALLBACKDATA_FILE_NOTIFY
     866{
     867    /** Callback data header. */
     868    CALLBACKDATA_HEADER hdr;
     869    /** The file handle. */
     870    uint32_t uHandle;
     871} CALLBACKDATA_FILE_NOTIFY, *PCALLBACKDATA_FILE_NOTIFY;
     872
     873/******************************************************************************
     874* Callback payload structures.                                                *
     875******************************************************************************/
     876
     877/*
     878 * These structures contain the actual payload, based of the given payload
     879 * type the HGCM message includes.
     880 */
     881
     882typedef struct CALLBACKPAYLOAD_FILE_NOTFIY_OPEN
     883{
     884    /** IPRT result of overall operation. */
     885    int32_t rc;
     886    /** File handle on successful opening. */
     887    uint32_t uHandle;
     888} CALLBACKPAYLOAD_FILE_NOTFIY_OPEN, *PCALLBACKPAYLOAD_FILE_NOTFIY_OPEN;
     889
     890typedef struct CALLBACKPAYLOAD_FILE_NOTFIY_CLOSE
     891{
     892    /** IPRT result of overall operation. */
     893    int32_t rc;
     894} CALLBACKPAYLOAD_FILE_NOTFIY_CLOSE, *PCALLBACKPAYLOAD_FILE_NOTFIY_CLOSE;
     895
     896typedef struct CALLBACKPAYLOAD_FILE_NOTFIY_READ
     897{
     898    /** IPRT result of overall operation. */
     899    int32_t rc;
     900    /** How much data (in bytes) have been read. */
     901    uint32_t cbData;
     902    /** Actual data read (if any). */
     903    void *pvData;
     904} CALLBACKPAYLOAD_FILE_NOTFIY_READ, *PCALLBACKPAYLOAD_FILE_NOTFIY_READ;
     905
     906typedef struct CALLBACKPAYLOAD_FILE_NOTFIY_WRITE
     907{
     908    /** IPRT result of overall operation. */
     909    int32_t rc;
     910    /** How much data (in bytes) have been successfully written. */
     911    uint32_t cbWritten;
     912} CALLBACKPAYLOAD_FILE_NOTFIY_WRITE, *PCALLBACKPAYLOAD_FILE_NOTFIY_WRITE;
     913
     914typedef struct CALLBACKPAYLOAD_FILE_NOTFIY_SEEK
     915{
     916    /** IPRT result of overall operation. */
     917    int32_t rc;
     918    /** New file offset after successful seek. */
     919    uint64_t uOffActual;
     920} CALLBACKPAYLOAD_FILE_NOTFIY_SEEK, *PCALLBACKPAYLOAD_FILE_NOTFIY_SEEK;
     921
     922typedef struct CALLBACKPAYLOAD_FILE_NOTFIY_TELL
     923{
     924    /** IPRT result of overall operation. */
     925    int32_t rc;
     926    /** Current file offset after successful tell. */
     927    uint64_t uOffActual;
     928} CALLBACKPAYLOAD_FILE_NOTFIY_TELL, *PCALLBACKPAYLOAD_FILE_NOTFIY_TELL;
    645929
    646930} /* namespace guestControl */

  • trunk/include/VBox/VBoxGuestLib.h

    r44528 r44863  
    571571/** @name Guest control
    572572 * @{ */
    573 /** @todo Clean this up, uniform formatting. */
    574 VBGLR3DECL(int)     VbglR3GuestCtrlConnect(uint32_t *pu32ClientId);
    575 VBGLR3DECL(int)     VbglR3GuestCtrlDisconnect(uint32_t u32ClientId);
    576 VBGLR3DECL(int)     VbglR3GuestCtrlWaitForHostMsg(uint32_t u32ClientId, uint32_t *puMsg, uint32_t *puNumParms);
    577 VBGLR3DECL(int)     VbglR3GuestCtrlCancelPendingWaits(uint32_t u32ClientId);
    578 /* Process execution. */
    579 VBGLR3DECL(int)     VbglR3GuestCtrlExecGetHostCmdExec(uint32_t  u32ClientId,    uint32_t  cParms,
    580                                                       uint32_t *puContext,
    581                                                       char     *pszCmd,         uint32_t  cbCmd,
    582                                                       uint32_t *puFlags,
    583                                                       char     *pszArgs,        uint32_t  cbArgs,   uint32_t *puNumArgs,
    584                                                       char     *pszEnv,         uint32_t *pcbEnv,   uint32_t *puNumEnvVars,
    585                                                       char     *pszUser,        uint32_t  cbUser,
    586                                                       char     *pszPassword,    uint32_t  cbPassword,
    587                                                       uint32_t *puTimeLimit);
    588 VBGLR3DECL(int)     VbglR3GuestCtrlExecGetHostCmdInput(uint32_t  u32ClientId,    uint32_t   uNumParms,
    589                                                        uint32_t *puContext,      uint32_t  *puPID,
    590                                                        uint32_t *puFlags,        void      *pvData,
    591                                                        uint32_t  cbData,         uint32_t  *pcbSize);
    592 VBGLR3DECL(int)     VbglR3GuestCtrlExecGetHostCmdOutput(uint32_t  u32ClientId,    uint32_t  uNumParms,
    593                                                         uint32_t *puContext,      uint32_t *puPID,
    594                                                         uint32_t *puHandle,       uint32_t *puFlags);
    595 VBGLR3DECL(int)     VbglR3GuestCtrlExecReportStatus(uint32_t  u32ClientId,
    596                                                     uint32_t  u32Context,
    597                                                     uint32_t  u32PID,
    598                                                     uint32_t  u32Status,
    599                                                     uint32_t  u32Flags,
    600                                                     void     *pvData,
    601                                                     uint32_t  cbData);
    602 VBGLR3DECL(int)     VbglR3GuestCtrlExecSendOut(uint32_t     u32ClientId,
    603                                                uint32_t     u32Context,
    604                                                uint32_t     u32PID,
    605                                                uint32_t     u32Handle,
    606                                                uint32_t     u32Flags,
    607                                                void        *pvData,
    608                                                uint32_t     cbData);
    609 VBGLR3DECL(int)     VbglR3GuestCtrlExecReportStatusIn(uint32_t     u32ClientId,
    610                                                       uint32_t     u32Context,
    611                                                       uint32_t     u32PID,
    612                                                       uint32_t     u32Status,
    613                                                       uint32_t     u32Flags,
    614                                                       uint32_t     cbWritten);
    615 /* Native file handling. */
    616 VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdOpen(uint32_t     uClientId,           uint32_t cParms,
    617                                                   uint32_t    *puContext,
    618                                                   char        *pszFileName,         uint32_t cbFileName,
    619                                                   char        *pszOpenMode,         uint32_t cbOpenMode,
    620                                                   char        *pszDisposition,      uint32_t cbDisposition,
    621                                                   uint32_t    *puCreationMode,
    622                                                   uint64_t    *puOffset);
    623 VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdClose(uint32_t     uClientId,           uint32_t cParms,
    624                                                    uint32_t    *puContext,
    625                                                    uint32_t    *puHandle);
    626 VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdRead(uint32_t     uClientId,           uint32_t     cParms,
    627                                                   uint32_t    *puContext,
    628                                                   uint32_t    *puHandle,            uint32_t    *puToRead);
    629 VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdWrite(uint32_t     uClientId,           uint32_t    cParms,
    630                                                    uint32_t    *puContext,
    631                                                    uint32_t    *puHandle,
    632                                                    void        *pvData,              uint32_t    cbData,
    633                                                    uint32_t    *pcbSize);
    634 VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdSeek(uint32_t     uClientId,           uint32_t  cParms,
    635                                                   uint32_t    *puContext,
    636                                                   uint32_t    *puHandle,
    637                                                   uint32_t    *puSeekMethod,        uint64_t *puOffset);
    638 VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdTell(uint32_t     uClientId,           uint32_t  cParms,
    639                                                   uint32_t    *puContext,
    640                                                   uint32_t    *puHandle);
    641 VBGLR3DECL(int) VbglR3GuestCtrlFileNotify(uint32_t     uClientId,
    642                                           uint32_t     uContext,        uint32_t      uHandle,
    643                                           uint32_t     uType,
    644                                           void        *pvPayload,       uint32_t      cbPayload);
     573
     574/**
     575 * Structure containing the command
     576 */
     577typedef struct VBGLR3GUESTCTRLHOSTCTX
     578{
     579    /** IN: HGCM client ID. */
     580    uint32_t uClientID;
     581    /** IN: Protocol version to use. */
     582    uint32_t uProtocol;
     583    /** IN: Number of parameters. */
     584    uint32_t uNumParms;
     585    /** OUT: Context ID. */
     586    uint32_t uContextID;
     587} VBGLR3GUESTCTRLHOSTCTX, *PVBGLR3GUESTCTRLHOSTCTX;
     588
     589/* General message handling on the guest. */
     590VBGLR3DECL(int) VbglR3GuestCtrlConnect(uint32_t *puClientId);
     591VBGLR3DECL(int) VbglR3GuestCtrlDisconnect(uint32_t uClientId);
     592VBGLR3DECL(int) VbglR3GuestCtrlMsgWaitFor(uint32_t uClientId, uint32_t *puMsg, uint32_t *puNumParms);
     593VBGLR3DECL(int) VbglR3GuestCtrlMsgSetFilter(uint32_t uClientId, uint32_t uFilterAdd, uint32_t uFilterRemove);
     594VBGLR3DECL(int) VbglR3GuestCtrlCancelPendingWaits(uint32_t u32ClientId);
     595/* Guest session handling. */
     596VBGLR3DECL(int) VbglR3GuestCtrlSessionNotify(uint32_t uClientId, uint32_t uContext, uint32_t uType, uint32_t uResult);
     597VBGLR3DECL(int) VbglR3GuestCtrlSessionGetOpen(PVBGLR3GUESTCTRLHOSTCTX pCtx, uint32_t *puProtocol, char *pszUser, uint32_t  cbUser, char *pszPassword, uint32_t  cbPassword, char *pszDomain, uint32_t cbDomain, uint32_t *puFlags, uint32_t *puSessionID);
     598VBGLR3DECL(int) VbglR3GuestCtrlSessionGetClose(PVBGLR3GUESTCTRLHOSTCTX pCtx, uint32_t *puFlags, uint32_t *puSessionID);
     599/* Guest process execution. */
     600VBGLR3DECL(int) VbglR3GuestCtrlProcGetStart(PVBGLR3GUESTCTRLHOSTCTX pCtx, char *pszCmd, uint32_t cbCmd, uint32_t *puFlags, char *pszArgs, uint32_t cbArgs, uint32_t *puNumArgs, char *pszEnv, uint32_t *pcbEnv, uint32_t *puNumEnvVars, char *pszUser, uint32_t cbUser, char *pszPassword, uint32_t cbPassword, uint32_t *puTimeoutMS, uint32_t *puPriority, uint64_t *puAffinity, uint32_t cbAffinity, uint32_t *pcAffinity);
     601VBGLR3DECL(int) VbglR3GuestCtrlProcGetTerminate(PVBGLR3GUESTCTRLHOSTCTX pCtx, uint32_t *puPID);
     602VBGLR3DECL(int) VbglR3GuestCtrlProcGetInput(PVBGLR3GUESTCTRLHOSTCTX pCtx, uint32_t *puPID, uint32_t *puFlags, void *pvData, uint32_t cbData, uint32_t *pcbSize);
     603VBGLR3DECL(int) VbglR3GuestCtrlProcGetOutput(PVBGLR3GUESTCTRLHOSTCTX pCtx, uint32_t *puPID, uint32_t *puHandle, uint32_t *puFlags);
     604VBGLR3DECL(int) VbglR3GuestCtrlProcGetWaitFor(PVBGLR3GUESTCTRLHOSTCTX pCtx, uint32_t *puPID, uint32_t *puWaitFlags, uint32_t *puTimeoutMS);
     605/* Guest native file handling. */
     606VBGLR3DECL(int) VbglR3GuestCtrlFileGetOpen(PVBGLR3GUESTCTRLHOSTCTX pCtx, char *pszFileName, uint32_t cbFileName, char *pszOpenMode, uint32_t cbOpenMode, char *pszDisposition, uint32_t cbDisposition, uint32_t *puCreationMode, uint64_t *puOffset);
     607VBGLR3DECL(int) VbglR3GuestCtrlFileGetClose(PVBGLR3GUESTCTRLHOSTCTX pCtx, uint32_t *puHandle);
     608VBGLR3DECL(int) VbglR3GuestCtrlFileGetRead(PVBGLR3GUESTCTRLHOSTCTX pCtx, uint32_t *puHandle, uint32_t *puToRead);
     609VBGLR3DECL(int) VbglR3GuestCtrlFileGetReadAt(PVBGLR3GUESTCTRLHOSTCTX pCtx, uint32_t *puHandle, uint32_t *puToRead, uint64_t *puOffset);
     610VBGLR3DECL(int) VbglR3GuestCtrlFileGetWrite(PVBGLR3GUESTCTRLHOSTCTX pCtx, uint32_t *puHandle, void *pvData, uint32_t cbData, uint32_t *pcbSize);
     611VBGLR3DECL(int) VbglR3GuestCtrlFileGetWriteAt(PVBGLR3GUESTCTRLHOSTCTX pCtx, uint32_t *puHandle, void *pvData, uint32_t cbData, uint32_t *pcbSize, uint64_t *puOffset);
     612VBGLR3DECL(int) VbglR3GuestCtrlFileGetSeek(PVBGLR3GUESTCTRLHOSTCTX pCtx, uint32_t *puHandle, uint32_t *puSeekMethod, uint64_t *puOffset);
     613VBGLR3DECL(int) VbglR3GuestCtrlFileGetTell(PVBGLR3GUESTCTRLHOSTCTX pCtx, uint32_t *puHandle);
     614
     615/* Guest -> Host. */
     616VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatus(uint32_t uClientId, uint32_t uContext, uint32_t uPID, uint32_t uStatus, uint32_t uFlags, void *pvData, uint32_t cbData);
     617VBGLR3DECL(int) VbglR3GuestCtrlProcCbOutput(uint32_t uClientId, uint32_t uContext, uint32_t uPID, uint32_t uHandle, uint32_t uFlags, void *pvData, uint32_t cbData);
     618VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatusInput(uint32_t uClientId, uint32_t uContext, uint32_t u32PID, uint32_t uStatus, uint32_t uFlags, uint32_t cbWritten);
     619VBGLR3DECL(int) VbglR3GuestCtrlFileNotify(uint32_t uClientId, uint32_t uContext, uint32_t uType, void *pvPayload, uint32_t cbPayload);
     620
    645621/** @}  */
    646622# endif /* VBOX_WITH_GUEST_CONTROL defined */

  • trunk/src/VBox

    • Property svn:mergeinfo set to (toggle deleted branches)
      /branches/VBox-3.0/src/VBox58652,​70973
      /branches/VBox-3.2/src/VBox66309,​66318
      /branches/VBox-4.0/src/VBox70873
      /branches/VBox-4.1/src/VBox74233,​78414,​78691,​81841,​82127
      /branches/andy/guestctrl20/src/VBox78916,​78930
      /branches/dsen/gui/src/VBox79076-79078,​79089,​79109-79110,​79112-79113,​79127-79130,​79134,​79141,​79151,​79155,​79157-79159,​79193,​79197
      /branches/dsen/gui2/src/VBox79224,​79228,​79233,​79235,​79258,​79262-79263,​79273,​79341,​79345,​79354,​79357,​79387-79388,​79559-79569,​79572-79573,​79578,​79581-79582,​79590-79591,​79598-79599,​79602-79603,​79605-79606,​79632,​79635,​79637,​79644
      /branches/dsen/gui3/src/VBox79645-79692

  • trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibGuestCtrl.cpp

    r44528 r44863  
    55
    66/*
    7  * Copyright (C) 2010-2012 Oracle Corporation
     7 * Copyright (C) 2010-2013 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    5050 *
    5151 * @returns VBox status code
    52  * @param   pu32ClientId    Where to put the client id on success. The client id
    53  *                          must be passed to all the other calls to the service.
    54  */
    55 VBGLR3DECL(int) VbglR3GuestCtrlConnect(uint32_t *pu32ClientId)
     52 * @param   puClientId    Where to put the client id on success. The client id
     53 *                        must be passed to all the other calls to the service.
     54 */
     55VBGLR3DECL(int) VbglR3GuestCtrlConnect(uint32_t *puClientId)
    5656{
    5757    VBoxGuestHGCMConnectInfo Info;
    … …  
    6767        rc = Info.result;
    6868        if (RT_SUCCESS(rc))
    69             *pu32ClientId = Info.u32ClientID;
     69            *puClientId = Info.u32ClientID;
    7070    }
    7171    return rc;
    … …  
    7777 *
    7878 * @returns VBox status code.
    79  * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
    80  */
    81 VBGLR3DECL(int) VbglR3GuestCtrlDisconnect(uint32_t u32ClientId)
     79 * @param   uClientId     The client id returned by VbglR3GuestCtrlConnect().
     80 */
     81VBGLR3DECL(int) VbglR3GuestCtrlDisconnect(uint32_t uClientId)
    8282{
    8383    VBoxGuestHGCMDisconnectInfo Info;
    8484    Info.result = VERR_WRONG_ORDER;
    85     Info.u32ClientID = u32ClientId;
     85    Info.u32ClientID = uClientId;
    8686
    8787    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_DISCONNECT, &Info, sizeof(Info));
    … …  
    9797 *
    9898 * @returns VBox status code.
    99  * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
     99 * @param   uClientId       The client id returned by VbglR3GuestCtrlConnect().
    100100 * @param   puMsg           Where to store the message id.
    101101 * @param   puNumParms      Where to store the number  of parameters which will be received
    102102 *                          in a second call to the host.
    103103 */
    104 VBGLR3DECL(int) VbglR3GuestCtrlWaitForHostMsg(uint32_t u32ClientId, uint32_t *puMsg, uint32_t *puNumParms)
     104VBGLR3DECL(int) VbglR3GuestCtrlMsgWaitFor(uint32_t uClientId, uint32_t *puMsg, uint32_t *puNumParms)
    105105{
    106106    AssertPtrReturn(puMsg, VERR_INVALID_POINTER);
    107107    AssertPtrReturn(puNumParms, VERR_INVALID_POINTER);
    108108
    109     VBoxGuestCtrlHGCMMsgType Msg;
    110 
    111     Msg.hdr.result      = VERR_WRONG_ORDER;
    112     Msg.hdr.u32ClientID = u32ClientId;
    113     Msg.hdr.u32Function = GUEST_GET_HOST_MSG; /* Tell the host we want our next command. */
    114     Msg.hdr.cParms      = 2;                  /* Just peek for the next message! */
     109    HGCMMsgCmdWaitFor Msg;
     110
     111    Msg.hdr.result      = VERR_WRONG_ORDER;
     112    Msg.hdr.u32ClientID = uClientId;
     113    Msg.hdr.u32Function = GUEST_MSG_WAIT; /* Tell the host we want our next command. */
     114    Msg.hdr.cParms      = 2;              /* Just peek for the next message! */
    115115
    116116    VbglHGCMParmUInt32Set(&Msg.msg, 0);
    … …  
    132132
    133133/**
     134 * Asks the host guest control service to set a command filter to this
     135 * client so that it only will receive certain commands in the future.
     136 *
     137 * @return  IPRT status code.
     138 * @param   uClientId       The client id returned by VbglR3GuestCtrlConnect().
     139 * @param   uFilterAdd      Filter mask to add.
     140 * @param   uFilterRemove   Filter mask to remove.
     141 */
     142VBGLR3DECL(int) VbglR3GuestCtrlMsgSetFilter(uint32_t uClientId,
     143                                            uint32_t uFilterAdd, uint32_t uFilterRemove)
     144{
     145    HGCMMsgCmdSetFilter Msg;
     146
     147    Msg.hdr.result      = VERR_WRONG_ORDER;
     148    Msg.hdr.u32ClientID = uClientId;
     149    Msg.hdr.u32Function = GUEST_MSG_FILTER; /* Tell the host we want to set a filter. */
     150    Msg.hdr.cParms      = 2;
     151
     152    VbglHGCMParmUInt32Set(&Msg.add, uFilterAdd);
     153    VbglHGCMParmUInt32Set(&Msg.remove, uFilterRemove);
     154
     155    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     156    if (RT_SUCCESS(rc))
     157        rc = Msg.hdr.result;
     158    return rc;
     159}
     160
     161
     162/**
    134163 * Asks the host to cancel (release) all pending waits which were deferred.
    135164 *
    136165 * @returns VBox status code.
    137  * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
    138  */
    139 VBGLR3DECL(int) VbglR3GuestCtrlCancelPendingWaits(uint32_t u32ClientId)
    140 {
    141     VBoxGuestCtrlHGCMMsgCancelPendingWaits Msg;
    142 
    143     Msg.hdr.result      = VERR_WRONG_ORDER;
    144     Msg.hdr.u32ClientID = u32ClientId;
     166 * @param   uClientId     The client id returned by VbglR3GuestCtrlConnect().
     167 */
     168VBGLR3DECL(int) VbglR3GuestCtrlCancelPendingWaits(uint32_t uClientId)
     169{
     170    HGCMMsgCancelPendingWaits Msg;
     171
     172    Msg.hdr.result      = VERR_WRONG_ORDER;
     173    Msg.hdr.u32ClientID = uClientId;
    145174    Msg.hdr.u32Function = GUEST_CANCEL_PENDING_WAITS;
    146175    Msg.hdr.cParms      = 0;
    … …  
    157186
    158187
     188VBGLR3DECL(int) VbglR3GuestCtrlSessionNotify(uint32_t uClientId, uint32_t uContext,
     189                                             uint32_t uType, uint32_t uResult)
     190{
     191    HGCMMsgSessionNotify Msg;
     192
     193    Msg.hdr.result      = VERR_WRONG_ORDER;
     194    Msg.hdr.u32ClientID = uClientId;
     195    Msg.hdr.u32Function = GUEST_SESSION_NOTIFY;
     196    Msg.hdr.cParms      = 3;
     197
     198    VbglHGCMParmUInt32Set(&Msg.context, uContext);
     199    VbglHGCMParmUInt32Set(&Msg.type, uType);
     200    VbglHGCMParmUInt32Set(&Msg.result, uResult);
     201
     202    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     203    if (RT_SUCCESS(rc))
     204    {
     205        int rc2 = Msg.hdr.result;
     206        if (RT_FAILURE(rc2))
     207            rc = rc2;
     208    }
     209    return rc;
     210}
     211
     212
     213/**
     214 * Retrieves the request to create a new guest session.
     215 *
     216 * @return  IPRT status code.
     217 * @param   pHostCtx                    Host context.
     218 ** @todo Docs!
     219 */
     220VBGLR3DECL(int) VbglR3GuestCtrlSessionGetOpen(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
     221                                              uint32_t *puProtocol,
     222                                              char     *pszUser,     uint32_t  cbUser,
     223                                              char     *pszPassword, uint32_t  cbPassword,
     224                                              char     *pszDomain,   uint32_t  cbDomain,
     225                                              uint32_t *puFlags,     uint32_t *puSessionID)
     226{
     227    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     228    AssertReturn(pHostCtx->uNumParms == 6, VERR_INVALID_PARAMETER);
     229
     230    AssertPtrReturn(puProtocol, VERR_INVALID_POINTER);
     231    AssertPtrReturn(pszUser, VERR_INVALID_POINTER);
     232    AssertPtrReturn(pszPassword, VERR_INVALID_POINTER);
     233    AssertPtrReturn(pszDomain, VERR_INVALID_POINTER);
     234    AssertPtrReturn(puFlags, VERR_INVALID_POINTER);
     235
     236    HGCMMsgSessionOpen Msg;
     237
     238    Msg.hdr.result      = VERR_WRONG_ORDER;
     239    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     240    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     241    Msg.hdr.cParms      = pHostCtx->uNumParms;
     242
     243    VbglHGCMParmUInt32Set(&Msg.context, 0);
     244    VbglHGCMParmUInt32Set(&Msg.protocol, 0);
     245    VbglHGCMParmPtrSet(&Msg.username, pszUser, cbUser);
     246    VbglHGCMParmPtrSet(&Msg.password, pszPassword, cbPassword);
     247    VbglHGCMParmPtrSet(&Msg.domain, pszDomain, cbDomain);
     248    VbglHGCMParmUInt32Set(&Msg.flags, 0);
     249
     250    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     251    if (RT_SUCCESS(rc))
     252    {
     253        int rc2 = Msg.hdr.result;
     254        if (RT_FAILURE(rc2))
     255        {
     256            rc = rc2;
     257        }
     258        else
     259        {
     260            Msg.context.GetUInt32(&pHostCtx->uContextID);
     261            Msg.protocol.GetUInt32(puProtocol);
     262            Msg.flags.GetUInt32(puFlags);
     263
     264            if (puSessionID)
     265                *puSessionID = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pHostCtx->uContextID);
     266        }
     267    }
     268
     269    return rc;
     270}
     271
     272
     273/**
     274 * Retrieves the request to terminate an existing guest session.
     275 *
     276 * @return  IPRT status code.
     277 * @param   pHostCtx                    Host context.
     278 ** @todo Docs!
     279 */
     280VBGLR3DECL(int) VbglR3GuestCtrlSessionGetClose(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puFlags, uint32_t *puSessionID)
     281{
     282    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     283    AssertReturn(pHostCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
     284
     285    AssertPtrReturn(puFlags, VERR_INVALID_POINTER);
     286
     287    HGCMMsgSessionClose Msg;
     288
     289    Msg.hdr.result      = VERR_WRONG_ORDER;
     290    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     291    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     292    Msg.hdr.cParms      = pHostCtx->uNumParms;
     293
     294    VbglHGCMParmUInt32Set(&Msg.context, 0);
     295    VbglHGCMParmUInt32Set(&Msg.flags, 0);
     296
     297    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     298    if (RT_SUCCESS(rc))
     299    {
     300        int rc2 = Msg.hdr.result;
     301        if (RT_FAILURE(rc2))
     302        {
     303            rc = rc2;
     304        }
     305        else
     306        {
     307            Msg.context.GetUInt32(&pHostCtx->uContextID);
     308            Msg.flags.GetUInt32(puFlags);
     309
     310            if (puSessionID)
     311                *puSessionID = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pHostCtx->uContextID);
     312        }
     313    }
     314
     315    return rc;
     316}
     317
     318
    159319/**
    160320 * Allocates and gets host data, based on the message id.
    … …  
    163323 *
    164324 * @returns VBox status code.
    165  * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
    166  * @param   uNumParms
    167325 ** @todo Docs!
    168  */
    169 VBGLR3DECL(int) VbglR3GuestCtrlExecGetHostCmdExec(uint32_t  u32ClientId,    uint32_t  cParms,
    170                                                   uint32_t *puContext,
    171                                                   char     *pszCmd,         uint32_t  cbCmd,
    172                                                   uint32_t *puFlags,
    173                                                   char     *pszArgs,        uint32_t  cbArgs,   uint32_t *pcArgs,
    174                                                   char     *pszEnv,         uint32_t *pcbEnv,   uint32_t *pcEnvVars,
    175                                                   char     *pszUser,        uint32_t  cbUser,
    176                                                   char     *pszPassword,    uint32_t  cbPassword,
    177                                                   uint32_t *pcMsTimeLimit)
    178 {
    179     AssertReturn(cParms == 11, VERR_INVALID_PARAMETER);
    180 
    181     AssertPtrReturn(puContext, VERR_INVALID_POINTER);
     326 ** @todo Move the parameters in an own struct!
     327 */
     328VBGLR3DECL(int) VbglR3GuestCtrlProcGetStart(PVBGLR3GUESTCTRLHOSTCTX   pHostCtx,
     329                                            char     *pszCmd,         uint32_t  cbCmd,
     330                                            uint32_t *puFlags,
     331                                            char     *pszArgs,        uint32_t  cbArgs,     uint32_t *pcArgs,
     332                                            char     *pszEnv,         uint32_t *pcbEnv,     uint32_t *pcEnvVars,
     333                                            char     *pszUser,        uint32_t  cbUser,
     334                                            char     *pszPassword,    uint32_t  cbPassword,
     335                                            uint32_t *puTimeoutMS,
     336                                            uint32_t *puPriority,
     337                                            uint64_t *puAffinity,     uint32_t  cbAffinity, uint32_t *pcAffinity)
     338{
     339    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     340
    182341    AssertPtrReturn(pszCmd, VERR_INVALID_POINTER);
    183342    AssertPtrReturn(puFlags, VERR_INVALID_POINTER);
    … …  
    187346    AssertPtrReturn(pcbEnv, VERR_INVALID_POINTER);
    188347    AssertPtrReturn(pcEnvVars, VERR_INVALID_POINTER);
    189     AssertPtrReturn(pszUser, VERR_INVALID_POINTER);
    190     AssertPtrReturn(pszPassword, VERR_INVALID_POINTER);
    191     AssertPtrReturn(pcMsTimeLimit, VERR_INVALID_POINTER);
    192 
    193     VBoxGuestCtrlHGCMMsgExecCmd Msg;
    194 
    195     Msg.hdr.result      = VERR_WRONG_ORDER;
    196     Msg.hdr.u32ClientID = u32ClientId;
    197     Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
    198     Msg.hdr.cParms      = 11;
     348    AssertPtrReturn(puTimeoutMS, VERR_INVALID_POINTER);
     349
     350    HGCMMsgProcExec Msg;
     351
     352    Msg.hdr.result      = VERR_WRONG_ORDER;
     353    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     354    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     355    Msg.hdr.cParms      = pHostCtx->uNumParms;
    199356
    200357    VbglHGCMParmUInt32Set(&Msg.context, 0);
    … …  
    206363    VbglHGCMParmUInt32Set(&Msg.cb_env, 0);
    207364    VbglHGCMParmPtrSet(&Msg.env, pszEnv, *pcbEnv);
    208     VbglHGCMParmPtrSet(&Msg.username, pszUser, cbUser);
    209     VbglHGCMParmPtrSet(&Msg.password, pszPassword, cbPassword);
    210     VbglHGCMParmUInt32Set(&Msg.timeout, 0);
    211 
    212     int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    213     if (RT_SUCCESS(rc))
    214     {
    215         int rc2 = Msg.hdr.result;
    216         if (RT_FAILURE(rc2))
    217         {
    218             rc = rc2;
    219         }
    220         else
    221         {
    222             Msg.context.GetUInt32(puContext);
     365    if (pHostCtx->uProtocol < 2)
     366    {
     367        AssertPtrReturn(pszUser, VERR_INVALID_POINTER);
     368        AssertReturn(cbUser, VERR_INVALID_PARAMETER);
     369        AssertPtrReturn(pszPassword, VERR_INVALID_POINTER);
     370        AssertReturn(pszPassword, VERR_INVALID_PARAMETER);
     371
     372        VbglHGCMParmPtrSet(&Msg.u.v1.username, pszUser, cbUser);
     373        VbglHGCMParmPtrSet(&Msg.u.v1.password, pszPassword, cbPassword);
     374        VbglHGCMParmUInt32Set(&Msg.u.v1.timeout, 0);
     375    }
     376    else
     377    {
     378        AssertPtrReturn(puAffinity, VERR_INVALID_POINTER);
     379        AssertReturn(cbAffinity, VERR_INVALID_PARAMETER);
     380
     381        VbglHGCMParmUInt32Set(&Msg.u.v2.timeout, 0);
     382        VbglHGCMParmUInt32Set(&Msg.u.v2.priority, 0);
     383        VbglHGCMParmUInt32Set(&Msg.u.v2.num_affinity, 0);
     384        VbglHGCMParmPtrSet(&Msg.u.v2.affinity, puAffinity, cbAffinity);
     385    }
     386
     387    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     388    if (RT_SUCCESS(rc))
     389    {
     390        int rc2 = Msg.hdr.result;
     391        if (RT_FAILURE(rc2))
     392        {
     393            rc = rc2;
     394        }
     395        else
     396        {
     397            Msg.context.GetUInt32(&pHostCtx->uContextID);
    223398            Msg.flags.GetUInt32(puFlags);
    224399            Msg.num_args.GetUInt32(pcArgs);
    225400            Msg.num_env.GetUInt32(pcEnvVars);
    226401            Msg.cb_env.GetUInt32(pcbEnv);
    227             Msg.timeout.GetUInt32(pcMsTimeLimit);
     402            if (pHostCtx->uProtocol < 2)
     403            {
     404                Msg.u.v1.timeout.GetUInt32(puTimeoutMS);
     405            }
     406            else
     407            {
     408                Msg.u.v2.timeout.GetUInt32(puTimeoutMS);
     409                Msg.u.v2.priority.GetUInt32(puPriority);
     410                Msg.u.v2.num_affinity.GetUInt32(pcAffinity);
     411            }
    228412        }
    229413    }
    … …  
    238422 *
    239423 * @returns VBox status code.
    240  * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
    241  * @param   cParms
    242424 ** @todo Docs!
    243425 */
    244 VBGLR3DECL(int) VbglR3GuestCtrlExecGetHostCmdOutput(uint32_t  u32ClientId,    uint32_t  cParms,
    245                                                     uint32_t *puContext,      uint32_t *puPID,
    246                                                     uint32_t *puHandle,       uint32_t *puFlags)
    247 {
    248     AssertReturn(cParms == 4, VERR_INVALID_PARAMETER);
    249 
    250     AssertPtrReturn(puContext, VERR_INVALID_POINTER);
     426VBGLR3DECL(int) VbglR3GuestCtrlProcGetOutput(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
     427                                             uint32_t *puPID, uint32_t *puHandle, uint32_t *puFlags)
     428{
     429    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     430    AssertReturn(pHostCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
     431
    251432    AssertPtrReturn(puPID, VERR_INVALID_POINTER);
    252433    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
    253434    AssertPtrReturn(puFlags, VERR_INVALID_POINTER);
    254435
    255     VBoxGuestCtrlHGCMMsgExecOut Msg;
     436    HGCMMsgProcOutput Msg;
    256437
    257438    Msg.hdr.result = VERR_WRONG_ORDER;
    258     Msg.hdr.u32ClientID = u32ClientId;
    259     Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
    260     Msg.hdr.cParms = 4;
     439    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     440    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     441    Msg.hdr.cParms      = pHostCtx->uNumParms;
    261442
    262443    VbglHGCMParmUInt32Set(&Msg.context, 0);
    … …  
    275456        else
    276457        {
    277             Msg.context.GetUInt32(puContext);
     458            Msg.context.GetUInt32(&pHostCtx->uContextID);
    278459            Msg.pid.GetUInt32(puPID);
    279460            Msg.handle.GetUInt32(puHandle);
    … …  
    292473 *
    293474 * @returns VBox status code.
    294  * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
    295  * @param   cParms
    296475 ** @todo Docs!
    297476 */
    298 VBGLR3DECL(int) VbglR3GuestCtrlExecGetHostCmdInput(uint32_t  u32ClientId,    uint32_t   cParms,
    299                                                    uint32_t *puContext,      uint32_t  *puPID,
    300                                                    uint32_t *puFlags,
    301                                                    void     *pvData,         uint32_t  cbData,
    302                                                    uint32_t *pcbSize)
    303 {
    304     AssertReturn(cParms == 5, VERR_INVALID_PARAMETER);
    305 
    306     AssertPtrReturn(puContext, VERR_INVALID_POINTER);
     477VBGLR3DECL(int) VbglR3GuestCtrlProcGetInput(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
     478                                            uint32_t  *puPID,       uint32_t *puFlags,
     479                                            void      *pvData,      uint32_t  cbData,
     480                                            uint32_t  *pcbSize)
     481{
     482    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     483    AssertReturn(pHostCtx->uNumParms == 5, VERR_INVALID_PARAMETER);
     484
    307485    AssertPtrReturn(puPID, VERR_INVALID_POINTER);
    308486    AssertPtrReturn(puFlags, VERR_INVALID_POINTER);
    … …  
    310488    AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
    311489
    312     VBoxGuestCtrlHGCMMsgExecIn Msg;
    313 
    314     Msg.hdr.result      = VERR_WRONG_ORDER;
    315     Msg.hdr.u32ClientID = u32ClientId;
    316     Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
    317     Msg.hdr.cParms      = 5;
     490    HGCMMsgProcInput Msg;
     491
     492    Msg.hdr.result      = VERR_WRONG_ORDER;
     493    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     494    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     495    Msg.hdr.cParms      = pHostCtx->uNumParms;
    318496
    319497    VbglHGCMParmUInt32Set(&Msg.context, 0);
    … …  
    333511        else
    334512        {
    335             Msg.context.GetUInt32(puContext);
     513            Msg.context.GetUInt32(&pHostCtx->uContextID);
    336514            Msg.pid.GetUInt32(puPID);
    337515            Msg.flags.GetUInt32(puFlags);
    … …  
    343521
    344522
    345 /**
    346  * Reports the process status (along with some other stuff) to the host.
    347  *
    348  * @returns VBox status code.
    349  ** @todo Docs!
    350  */
    351 VBGLR3DECL(int) VbglR3GuestCtrlExecReportStatus(uint32_t     u32ClientId,
    352                                                 uint32_t     u32Context,
    353                                                 uint32_t     u32PID,
    354                                                 uint32_t     u32Status,
    355                                                 uint32_t     u32Flags,
    356                                                 void        *pvData,
    357                                                 uint32_t     cbData)
    358 {
    359     VBoxGuestCtrlHGCMMsgExecStatus Msg;
    360 
    361     Msg.hdr.result = VERR_WRONG_ORDER;
    362     Msg.hdr.u32ClientID = u32ClientId;
    363     Msg.hdr.u32Function = GUEST_EXEC_SEND_STATUS;
    364     Msg.hdr.cParms = 5;
    365 
    366     VbglHGCMParmUInt32Set(&Msg.context, u32Context);
    367     VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
    368     VbglHGCMParmUInt32Set(&Msg.status, u32Status);
    369     VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
    370     VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
    371 
    372     int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    373     if (RT_SUCCESS(rc))
    374     {
    375         int rc2 = Msg.hdr.result;
    376         if (RT_FAILURE(rc2))
    377             rc = rc2;
    378     }
    379     return rc;
    380 }
    381 
    382 
    383 /**
    384  * Sends output (from stdout/stderr) from a running process.
    385  *
    386  * @returns VBox status code.
    387  ** @todo Docs!
    388  */
    389 VBGLR3DECL(int) VbglR3GuestCtrlExecSendOut(uint32_t     u32ClientId,
    390                                            uint32_t     u32Context,
    391                                            uint32_t     u32PID,
    392                                            uint32_t     u32Handle,
    393                                            uint32_t     u32Flags,
    394                                            void        *pvData,
    395                                            uint32_t     cbData)
    396 {
    397     VBoxGuestCtrlHGCMMsgExecOut Msg;
    398 
    399     Msg.hdr.result = VERR_WRONG_ORDER;
    400     Msg.hdr.u32ClientID = u32ClientId;
    401     Msg.hdr.u32Function = GUEST_EXEC_SEND_OUTPUT;
    402     Msg.hdr.cParms = 5;
    403 
    404     VbglHGCMParmUInt32Set(&Msg.context, u32Context);
    405     VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
    406     VbglHGCMParmUInt32Set(&Msg.handle, u32Handle);
    407     VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
    408     VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
    409 
    410     int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    411     if (RT_SUCCESS(rc))
    412     {
    413         int rc2 = Msg.hdr.result;
    414         if (RT_FAILURE(rc2))
    415             rc = rc2;
    416     }
    417     return rc;
    418 }
    419 
    420 
    421 /**
    422  * Reports back the input status to the host.
    423  *
    424  * @returns VBox status code.
    425  ** @todo Docs!
    426  */
    427 VBGLR3DECL(int) VbglR3GuestCtrlExecReportStatusIn(uint32_t     u32ClientId,
    428                                                   uint32_t     u32Context,
    429                                                   uint32_t     u32PID,
    430                                                   uint32_t     u32Status,
    431                                                   uint32_t     u32Flags,
    432                                                   uint32_t     cbWritten)
    433 {
    434     VBoxGuestCtrlHGCMMsgExecStatusIn Msg;
    435 
    436     Msg.hdr.result = VERR_WRONG_ORDER;
    437     Msg.hdr.u32ClientID = u32ClientId;
    438     Msg.hdr.u32Function = GUEST_EXEC_SEND_INPUT_STATUS;
    439     Msg.hdr.cParms = 5;
    440 
    441     VbglHGCMParmUInt32Set(&Msg.context, u32Context);
    442     VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
    443     VbglHGCMParmUInt32Set(&Msg.status, u32Status);
    444     VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
    445     VbglHGCMParmUInt32Set(&Msg.written, cbWritten);
    446 
    447     int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
    448     if (RT_SUCCESS(rc))
    449     {
    450         int rc2 = Msg.hdr.result;
    451         if (RT_FAILURE(rc2))
    452             rc = rc2;
    453     }
    454     return rc;
    455 }
    456 
    457 
    458 VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdOpen(uint32_t     uClientId,           uint32_t cParms,
    459                                                   uint32_t    *puContext,
    460                                                   char        *pszFileName,         uint32_t cbFileName,
    461                                                   char        *pszOpenMode,         uint32_t cbOpenMode,
    462                                                   char        *pszDisposition,      uint32_t cbDisposition,
    463                                                   uint32_t    *puCreationMode,
    464                                                   uint64_t    *puOffset)
    465 {
    466     AssertReturn(cParms == 6, VERR_INVALID_PARAMETER);
    467     AssertPtrReturn(puContext, VERR_INVALID_POINTER);
     523VBGLR3DECL(int) VbglR3GuestCtrlFileGetOpen(PVBGLR3GUESTCTRLHOSTCTX      pHostCtx,
     524                                           char     *pszFileName,       uint32_t cbFileName,
     525                                           char     *pszOpenMode,       uint32_t cbOpenMode,
     526                                           char     *pszDisposition,    uint32_t cbDisposition,
     527                                           uint32_t *puCreationMode,
     528                                           uint64_t *puOffset)
     529{
     530    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     531    AssertReturn(pHostCtx->uNumParms == 6, VERR_INVALID_PARAMETER);
     532
    468533    AssertPtrReturn(pszFileName, VERR_INVALID_POINTER);
    469534    AssertReturn(cbFileName, VERR_INVALID_PARAMETER);
    … …  
    475540    AssertPtrReturn(puOffset, VERR_INVALID_POINTER);
    476541
    477     VBoxGuestCtrlHGCMMsgFileOpen Msg;
    478 
    479     Msg.hdr.result      = VERR_WRONG_ORDER;
    480     Msg.hdr.u32ClientID = uClientId;
    481     Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
    482     Msg.hdr.cParms      = 6;
     542    HGCMMsgFileOpen Msg;
     543
     544    Msg.hdr.result      = VERR_WRONG_ORDER;
     545    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     546    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     547    Msg.hdr.cParms      = pHostCtx->uNumParms;
    483548
    484549    VbglHGCMParmUInt32Set(&Msg.context, 0);
    … …  
    499564        else
    500565        {
    501             Msg.context.GetUInt32(puContext);
     566            Msg.context.GetUInt32(&pHostCtx->uContextID);
    502567            Msg.creationmode.GetUInt32(puCreationMode);
    503568            Msg.offset.GetUInt64(puOffset);
    … …  
    508573
    509574
    510 VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdClose(uint32_t     uClientId,           uint32_t cParms,
    511                                                    uint32_t    *puContext,
    512                                                    uint32_t    *puHandle)
    513 {
    514     AssertReturn(cParms == 2, VERR_INVALID_PARAMETER);
    515     AssertPtrReturn(puContext, VERR_INVALID_POINTER);
     575VBGLR3DECL(int) VbglR3GuestCtrlFileGetClose(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puHandle)
     576{
     577    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     578
     579    AssertReturn(pHostCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
    516580    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
    517581
    518     VBoxGuestCtrlHGCMMsgFileClose Msg;
    519 
    520     Msg.hdr.result      = VERR_WRONG_ORDER;
    521     Msg.hdr.u32ClientID = uClientId;
    522     Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
    523     Msg.hdr.cParms      = 2;
     582    HGCMMsgFileClose Msg;
     583
     584    Msg.hdr.result      = VERR_WRONG_ORDER;
     585    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     586    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     587    Msg.hdr.cParms      = pHostCtx->uNumParms;
    524588
    525589    VbglHGCMParmUInt32Set(&Msg.context, 0);
    … …  
    536600        else
    537601        {
    538             Msg.context.GetUInt32(puContext);
     602            Msg.context.GetUInt32(&pHostCtx->uContextID);
    539603            Msg.handle.GetUInt32(puHandle);
    540604        }
    … …  
    544608
    545609
    546 VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdRead(uint32_t     uClientId,           uint32_t     cParms,
    547                                                   uint32_t    *puContext,
    548                                                   uint32_t    *puHandle,            uint32_t    *puToRead)
    549 {
    550     AssertReturn(cParms == 4, VERR_INVALID_PARAMETER);
    551     AssertPtrReturn(puContext, VERR_INVALID_POINTER);
     610VBGLR3DECL(int) VbglR3GuestCtrlFileGetRead(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
     611                                           uint32_t *puHandle, uint32_t *puToRead)
     612{
     613    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     614
     615    AssertReturn(pHostCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
    552616    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
    553617    AssertPtrReturn(puToRead, VERR_INVALID_POINTER);
    554618
    555     VBoxGuestCtrlHGCMMsgFileRead Msg;
    556 
    557     Msg.hdr.result      = VERR_WRONG_ORDER;
    558     Msg.hdr.u32ClientID = uClientId;
    559     Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
    560     Msg.hdr.cParms      = 4;
     619    HGCMMsgFileRead Msg;
     620
     621    Msg.hdr.result      = VERR_WRONG_ORDER;
     622    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     623    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     624    Msg.hdr.cParms      = pHostCtx->uNumParms;
    561625
    562626    VbglHGCMParmUInt32Set(&Msg.context, 0);
    … …  
    574638        else
    575639        {
    576             Msg.context.GetUInt32(puContext);
     640            Msg.context.GetUInt32(&pHostCtx->uContextID);
    577641            Msg.handle.GetUInt32(puHandle);
    578642            Msg.size.GetUInt32(puToRead);
    … …  
    582646}
    583647
    584 VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdWrite(uint32_t     uClientId,           uint32_t    cParms,
    585                                                    uint32_t    *puContext,
    586                                                    uint32_t    *puHandle,
    587                                                    void        *pvData,              uint32_t    cbData,
    588                                                    uint32_t    *pcbSize)
    589 {
    590     AssertReturn(cParms == 4, VERR_INVALID_PARAMETER);
    591     AssertPtrReturn(puContext, VERR_INVALID_POINTER);
     648
     649VBGLR3DECL(int) VbglR3GuestCtrlFileGetReadAt(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
     650                                             uint32_t *puHandle, uint32_t *puToRead, uint64_t *puOffset)
     651{
     652    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     653
     654    AssertReturn(pHostCtx->uNumParms == 5, VERR_INVALID_PARAMETER);
     655    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
     656    AssertPtrReturn(puToRead, VERR_INVALID_POINTER);
     657
     658    HGCMMsgFileRead Msg;
     659
     660    Msg.hdr.result      = VERR_WRONG_ORDER;
     661    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     662    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     663    Msg.hdr.cParms      = pHostCtx->uNumParms;
     664
     665    VbglHGCMParmUInt32Set(&Msg.context, 0);
     666    VbglHGCMParmUInt32Set(&Msg.handle, 0);
     667    VbglHGCMParmUInt32Set(&Msg.size, 0);
     668
     669    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     670    if (RT_SUCCESS(rc))
     671    {
     672        int rc2 = Msg.hdr.result;
     673        if (RT_FAILURE(rc2))
     674        {
     675            rc = rc2;
     676        }
     677        else
     678        {
     679            Msg.context.GetUInt32(&pHostCtx->uContextID);
     680            Msg.handle.GetUInt32(puHandle);
     681            Msg.size.GetUInt32(puToRead);
     682        }
     683    }
     684    return rc;
     685}
     686
     687
     688VBGLR3DECL(int) VbglR3GuestCtrlFileGetWrite(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puHandle,
     689                                            void *pvData, uint32_t cbData, uint32_t *pcbSize)
     690{
     691    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     692
     693    AssertReturn(pHostCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
    592694    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
    593695    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
    … …  
    595697    AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
    596698
    597     VBoxGuestCtrlHGCMMsgFileWrite Msg;
    598 
    599     Msg.hdr.result      = VERR_WRONG_ORDER;
    600     Msg.hdr.u32ClientID = uClientId;
    601     Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
    602     Msg.hdr.cParms      = 4;
     699    HGCMMsgFileWrite Msg;
     700
     701    Msg.hdr.result      = VERR_WRONG_ORDER;
     702    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     703    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     704    Msg.hdr.cParms      = pHostCtx->uNumParms;
    603705
    604706    VbglHGCMParmUInt32Set(&Msg.context, 0);
    … …  
    617719        else
    618720        {
    619             Msg.context.GetUInt32(puContext);
     721            Msg.context.GetUInt32(&pHostCtx->uContextID);
    620722            Msg.handle.GetUInt32(puHandle);
    621723            Msg.size.GetUInt32(pcbSize);
    … …  
    626728
    627729
    628 VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdSeek(uint32_t     uClientId,           uint32_t  cParms,
    629                                                   uint32_t    *puContext,
    630                                                   uint32_t    *puHandle,
    631                                                   uint32_t    *puSeekMethod,        uint64_t *puOffset)
    632 {
    633     AssertReturn(cParms == 4, VERR_INVALID_PARAMETER);
    634     AssertPtrReturn(puContext, VERR_INVALID_POINTER);
     730VBGLR3DECL(int) VbglR3GuestCtrlFileGetWriteAt(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puHandle,
     731                                              void *pvData, uint32_t cbData, uint32_t *pcbSize, uint64_t *puOffset)
     732{
     733    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     734
     735    AssertReturn(pHostCtx->uNumParms == 5, VERR_INVALID_PARAMETER);
     736    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
     737    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
     738    AssertReturn(cbData, VERR_INVALID_PARAMETER);
     739    AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
     740
     741    HGCMMsgFileWriteAt Msg;
     742
     743    Msg.hdr.result      = VERR_WRONG_ORDER;
     744    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     745    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     746    Msg.hdr.cParms      = pHostCtx->uNumParms;
     747
     748    VbglHGCMParmUInt32Set(&Msg.context, 0);
     749    VbglHGCMParmUInt32Set(&Msg.handle, 0);
     750    VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
     751    VbglHGCMParmUInt32Set(&Msg.size, 0);
     752    VbglHGCMParmUInt32Set(&Msg.offset, 0);
     753
     754    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     755    if (RT_SUCCESS(rc))
     756    {
     757        int rc2 = Msg.hdr.result;
     758        if (RT_FAILURE(rc2))
     759        {
     760            rc = rc2;
     761        }
     762        else
     763        {
     764            Msg.context.GetUInt32(&pHostCtx->uContextID);
     765            Msg.handle.GetUInt32(puHandle);
     766            Msg.size.GetUInt32(pcbSize);
     767        }
     768    }
     769    return rc;
     770}
     771
     772
     773VBGLR3DECL(int) VbglR3GuestCtrlFileGetSeek(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
     774                                           uint32_t *puHandle, uint32_t *puSeekMethod, uint64_t *puOffset)
     775{
     776    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     777
     778    AssertReturn(pHostCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
    635779    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
    636780    AssertPtrReturn(puSeekMethod, VERR_INVALID_POINTER);
    637781    AssertPtrReturn(puOffset, VERR_INVALID_POINTER);
    638782
    639     VBoxGuestCtrlHGCMMsgFileSeek Msg;
    640 
    641     Msg.hdr.result      = VERR_WRONG_ORDER;
    642     Msg.hdr.u32ClientID = uClientId;
    643     Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
    644     Msg.hdr.cParms      = 4;
     783    HGCMMsgFileSeek Msg;
     784
     785    Msg.hdr.result      = VERR_WRONG_ORDER;
     786    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     787    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     788    Msg.hdr.cParms      = pHostCtx->uNumParms;
    645789
    646790    VbglHGCMParmUInt32Set(&Msg.context, 0);
    … …  
    659803        else
    660804        {
    661             Msg.context.GetUInt32(puContext);
     805            Msg.context.GetUInt32(&pHostCtx->uContextID);
    662806            Msg.handle.GetUInt32(puHandle);
    663807            Msg.method.GetUInt32(puSeekMethod);
    … …  
    669813
    670814
    671 VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdTell(uint32_t     uClientId,           uint32_t  cParms,
    672                                                   uint32_t    *puContext,
    673                                                   uint32_t    *puHandle)
    674 {
    675     AssertReturn(cParms == 2, VERR_INVALID_PARAMETER);
    676     AssertPtrReturn(puContext, VERR_INVALID_POINTER);
     815VBGLR3DECL(int) VbglR3GuestCtrlFileGetTell(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puHandle)
     816{
     817    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     818
     819    AssertReturn(pHostCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
    677820    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
    678821
    679     VBoxGuestCtrlHGCMMsgFileTell Msg;
    680 
    681     Msg.hdr.result      = VERR_WRONG_ORDER;
    682     Msg.hdr.u32ClientID = uClientId;
    683     Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
    684     Msg.hdr.cParms      = 2;
     822    HGCMMsgFileTell Msg;
     823
     824    Msg.hdr.result      = VERR_WRONG_ORDER;
     825    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     826    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     827    Msg.hdr.cParms      = pHostCtx->uNumParms;
    685828
    686829    VbglHGCMParmUInt32Set(&Msg.context, 0);
    … …  
    697840        else
    698841        {
    699             Msg.context.GetUInt32(puContext);
     842            Msg.context.GetUInt32(&pHostCtx->uContextID);
    700843            Msg.handle.GetUInt32(puHandle);
    701844        }
    … …  
    705848
    706849
    707 VBGLR3DECL(int) VbglR3GuestCtrlFileNotify(uint32_t     uClientId,
    708                                           uint32_t     uContext,        uint32_t      uHandle,
     850VBGLR3DECL(int) VbglR3GuestCtrlProcGetTerminate(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puPID)
     851{
     852    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     853
     854    AssertReturn(pHostCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
     855    AssertPtrReturn(puPID, VERR_INVALID_POINTER);
     856
     857    HGCMMsgProcTerminate Msg;
     858
     859    Msg.hdr.result      = VERR_WRONG_ORDER;
     860    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     861    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     862    Msg.hdr.cParms      = pHostCtx->uNumParms;
     863
     864    VbglHGCMParmUInt32Set(&Msg.context, 0);
     865    VbglHGCMParmUInt32Set(&Msg.pid, 0);
     866
     867    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     868    if (RT_SUCCESS(rc))
     869    {
     870        int rc2 = Msg.hdr.result;
     871        if (RT_FAILURE(rc2))
     872        {
     873            rc = rc2;
     874        }
     875        else
     876        {
     877            Msg.context.GetUInt32(&pHostCtx->uContextID);
     878            Msg.pid.GetUInt32(puPID);
     879        }
     880    }
     881    return rc;
     882}
     883
     884
     885VBGLR3DECL(int) VbglR3GuestCtrlProcGetWaitFor(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puPID, uint32_t *puWaitFlags, uint32_t *puTimeoutMS)
     886{
     887    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     888
     889    AssertReturn(pHostCtx->uNumParms == 5, VERR_INVALID_PARAMETER);
     890    AssertPtrReturn(puPID, VERR_INVALID_POINTER);
     891
     892    HGCMMsgProcWaitFor Msg;
     893
     894    Msg.hdr.result      = VERR_WRONG_ORDER;
     895    Msg.hdr.u32ClientID = pHostCtx->uClientID;
     896    Msg.hdr.u32Function = GUEST_MSG_WAIT;
     897    Msg.hdr.cParms      = pHostCtx->uNumParms;
     898
     899    VbglHGCMParmUInt32Set(&Msg.context, 0);
     900    VbglHGCMParmUInt32Set(&Msg.pid, 0);
     901    VbglHGCMParmUInt32Set(&Msg.flags, 0);
     902    VbglHGCMParmUInt32Set(&Msg.timeout, 0);
     903
     904    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     905    if (RT_SUCCESS(rc))
     906    {
     907        int rc2 = Msg.hdr.result;
     908        if (RT_FAILURE(rc2))
     909        {
     910            rc = rc2;
     911        }
     912        else
     913        {
     914            Msg.context.GetUInt32(&pHostCtx->uContextID);
     915            Msg.pid.GetUInt32(puPID);
     916            Msg.flags.GetUInt32(puWaitFlags);
     917            Msg.timeout.GetUInt32(puTimeoutMS);
     918        }
     919    }
     920    return rc;
     921}
     922
     923
     924VBGLR3DECL(int) VbglR3GuestCtrlFileNotify(uint32_t     uClientId,    uint32_t     uContext,
    709925                                          uint32_t     uType,
    710                                           void        *pvPayload,       uint32_t      cbPayload)
     926                                          void        *pvPayload,    uint32_t     cbPayload)
    711927{
    712928    AssertPtrReturn(uContext, VERR_INVALID_POINTER);
    713     AssertPtrReturn(uHandle, VERR_INVALID_POINTER);
    714929    AssertPtrReturn(pvPayload, VERR_INVALID_POINTER);
    715930    AssertReturn(cbPayload, VERR_INVALID_PARAMETER);
    716931
    717     VBoxGuestCtrlHGCMMsgFileNotify Msg;
     932    HGCMMsgFileNotify Msg;
    718933
    719934    Msg.hdr.result      = VERR_WRONG_ORDER;
    720935    Msg.hdr.u32ClientID = uClientId;
    721     Msg.hdr.u32Function = GUEST_FILE_NOTIFY;
    722     Msg.hdr.cParms      = 4;
     936    //Msg.hdr.u32Function = GUEST_FILE_NOTIFY;
     937    Msg.hdr.cParms      = 3;
    723938
    724939    VbglHGCMParmUInt32Set(&Msg.context, uContext);
    725     VbglHGCMParmUInt32Set(&Msg.handle, uHandle);
    726940    VbglHGCMParmUInt32Set(&Msg.type, uType);
    727941    VbglHGCMParmPtrSet(&Msg.payload, pvPayload, cbPayload);
    … …  
    737951}
    738952
     953
     954/**
     955 * Callback for reporting a guest process status (along with some other stuff) to the host.
     956 *
     957 * @returns VBox status code.
     958 ** @todo Docs!
     959 */
     960VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatus(uint32_t     u32ClientID,
     961                                            uint32_t     u32Context,
     962                                            uint32_t     u32PID,
     963                                            uint32_t     u32Status,
     964                                            uint32_t     u32Flags,
     965                                            void        *pvData,
     966                                            uint32_t     cbData)
     967{
     968    HGCMMsgProcStatus Msg;
     969
     970    Msg.hdr.result = VERR_WRONG_ORDER;
     971    Msg.hdr.u32ClientID = u32ClientID;
     972    Msg.hdr.u32Function = GUEST_EXEC_STATUS;
     973    Msg.hdr.cParms = 5;
     974
     975    VbglHGCMParmUInt32Set(&Msg.context, u32Context);
     976    VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
     977    VbglHGCMParmUInt32Set(&Msg.status, u32Status);
     978    VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
     979    VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
     980
     981    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     982    if (RT_SUCCESS(rc))
     983    {
     984        int rc2 = Msg.hdr.result;
     985        if (RT_FAILURE(rc2))
     986            rc = rc2;
     987    }
     988    return rc;
     989}
     990
     991
     992/**
     993 * Sends output (from stdout/stderr) from a running process.
     994 *
     995 * @returns VBox status code.
     996 ** @todo Docs!
     997 */
     998VBGLR3DECL(int) VbglR3GuestCtrlProcCbOutput(uint32_t     u32ClientID,
     999                                            uint32_t     u32Context,
     1000                                            uint32_t     u32PID,
     1001                                            uint32_t     u32Handle,
     1002                                            uint32_t     u32Flags,
     1003                                            void        *pvData,
     1004                                            uint32_t     cbData)
     1005{
     1006    HGCMMsgProcOutput Msg;
     1007
     1008    Msg.hdr.result = VERR_WRONG_ORDER;
     1009    Msg.hdr.u32ClientID = u32ClientID;
     1010    Msg.hdr.u32Function = GUEST_EXEC_OUTPUT;
     1011    Msg.hdr.cParms = 5;
     1012
     1013    VbglHGCMParmUInt32Set(&Msg.context, u32Context);
     1014    VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
     1015    VbglHGCMParmUInt32Set(&Msg.handle, u32Handle);
     1016    VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
     1017    VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
     1018
     1019    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     1020    if (RT_SUCCESS(rc))
     1021    {
     1022        int rc2 = Msg.hdr.result;
     1023        if (RT_FAILURE(rc2))
     1024            rc = rc2;
     1025    }
     1026    return rc;
     1027}
     1028
     1029
     1030/**
     1031 * Callback for reporting back the input status of a guest process to the host.
     1032 *
     1033 * @returns VBox status code.
     1034 ** @todo Docs!
     1035 */
     1036VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatusInput(uint32_t     u32ClientID,
     1037                                                 uint32_t     u32Context,
     1038                                                 uint32_t     u32PID,
     1039                                                 uint32_t     u32Status,
     1040                                                 uint32_t     u32Flags,
     1041                                                 uint32_t     cbWritten)
     1042{
     1043    HGCMMsgProcStatusInput Msg;
     1044
     1045    Msg.hdr.result = VERR_WRONG_ORDER;
     1046    Msg.hdr.u32ClientID = u32ClientID;
     1047    Msg.hdr.u32Function = GUEST_EXEC_INPUT_STATUS;
     1048    Msg.hdr.cParms = 5;
     1049
     1050    VbglHGCMParmUInt32Set(&Msg.context, u32Context);
     1051    VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
     1052    VbglHGCMParmUInt32Set(&Msg.status, u32Status);
     1053    VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
     1054    VbglHGCMParmUInt32Set(&Msg.written, cbWritten);
     1055
     1056    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
     1057    if (RT_SUCCESS(rc))
     1058    {
     1059        int rc2 = Msg.hdr.result;
     1060        if (RT_FAILURE(rc2))
     1061            rc = rc2;
     1062    }
     1063    return rc;
     1064}
     1065

  • trunk/src/VBox/Additions/common/VBoxService

    • Property svn:mergeinfo set to (toggle deleted branches)
      /branches/VBox-3.0/src/VBox/Additions/common/VBoxService58652,​70973
      /branches/VBox-3.2/src/VBox/Additions/common/VBoxService66309,​66318
      /branches/VBox-4.0/src/VBox/Additions/common/VBoxService70873
      /branches/VBox-4.1/src/VBox/Additions/common/VBoxService74233,​78414,​78691
      /branches/VBox-4.2/src/VBox/Additions/common/VBoxService82653,​83625-83626,​83665,​83678
      /branches/dsen/gui/src/VBox/Additions/common/VBoxService79076-79078,​79089,​79109-79110,​79112-79113,​79127-79130,​79134,​79141,​79151,​79155,​79157-79159,​79193,​79197
      /branches/dsen/gui2/src/VBox/Additions/common/VBoxService79224,​79228,​79233,​79235,​79258,​79262-79263,​79273,​79341,​79345,​79354,​79357,​79387-79388,​79559-79569,​79572-79573,​79578,​79581-79582,​79590-79591,​79598-79599,​79602-79603,​79605-79606,​79632,​79635,​79637,​79644
      /branches/dsen/gui3/src/VBox/Additions/common/VBoxService79645-79692

  • trunk/src/VBox/Additions/common/VBoxService/Makefile.kmk

    r43791 r44863  
    55
    66#
    7 # Copyright (C) 2007-2012 Oracle Corporation
     7# Copyright (C) 2007-2013 Oracle Corporation
    88#
    99# This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    7474 VBoxService_SOURCES    += \
    7575        VBoxServiceControl.cpp \
    76         VBoxServiceControlThread.cpp
     76        VBoxServiceControlThread.cpp \
     77        VBoxServiceControlSession.cpp
    7778endif
    7879

  • trunk/src/VBox/Additions/common/VBoxService/VBoxService.cpp

    r44528 r44863  
    5757
    5858#include "VBoxServiceInternal.h"
     59#ifdef VBOX_WITH_GUEST_CONTROL
     60# include "VBoxServiceControl.h"
     61#endif
    5962
    6063
    … …  
    6669/** The current verbosity level. */
    6770int                  g_cVerbosity = 0;
     71char                 g_szLogFile[RTPATH_MAX + 128] = "";
    6872/** Logging parameters. */
    6973/** @todo Make this configurable later. */
    … …  
    216220 * @param   pszLogFile              Filename for log output.  Optional.
    217221 */
    218 static int VBoxServiceLogCreate(const char *pszLogFile)
     222int VBoxServiceLogCreate(const char *pszLogFile)
    219223{
    220224    /* Create release logger (stdout + file). */
    … …  
    242246}
    243247
    244 static void VBoxServiceLogDestroy(void)
     248
     249void VBoxServiceLogDestroy(void)
    245250{
    246251    RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
    … …  
    634639        }
    635640
     641    VBoxServiceVerbose(3, "All stop functions for services called\n");
     642
    636643    /*
    637644     * Wait for all the service threads to complete.
    … …  
    792799     */
    793800    if (    argc == 2
    794         &&  !strcmp(argv[1], "--pagefusionfork"))
     801        &&  !RTStrICmp(argv[1], "pagefusion"))
    795802        return VBoxServicePageSharingInitFork();
    796803#endif
    797804
    798     char szLogFile[RTPATH_MAX + 128] = "";
     805    /*
     806     * Check if we're the specially spawned VBoxService.exe process that
     807     * handles a guest control session.
     808     */
     809    if (    argc >= 2
     810        &&  !RTStrICmp(argv[1], "guestsession"))
     811        return VBoxServiceControlSessionForkInit(argc, argv);
    799812
    800813    /*
    … …  
    926939                {
    927940                    rc = VBoxServiceArgString(argc, argv, psz + 1, &i,
    928                                               szLogFile, sizeof(szLogFile));
     941                                              g_szLogFile, sizeof(g_szLogFile));
    929942                    if (rc)
    930943                        return rc;
    … …  
    961974        return RTMsgErrorExit(RTEXITCODE_SYNTAX, "At least one service must be enabled\n");
    962975
    963     rc = VBoxServiceLogCreate(strlen(szLogFile) ? szLogFile : NULL);
     976    rc = VBoxServiceLogCreate(strlen(g_szLogFile) ? g_szLogFile : NULL);
    964977    if (RT_FAILURE(rc))
    965978        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to create release log (%s, %Rrc)",
    966                               strlen(szLogFile) ? szLogFile : "<None>", rc);
     979                              strlen(g_szLogFile) ? g_szLogFile : "<None>", rc);
    967980
    968981    /* Call pre-init if we didn't do it already. */

  • trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControl.cpp

    r44248 r44863  
    2222#include <iprt/asm.h>
    2323#include <iprt/assert.h>
     24#include <iprt/env.h>
    2425#include <iprt/file.h>
    2526#include <iprt/getopt.h>
    2627#include <iprt/mem.h>
    2728#include <iprt/path.h>
     29#include <iprt/process.h>
    2830#include <iprt/semaphore.h>
    2931#include <iprt/thread.h>
    … …  
    3133#include <VBox/HostServices/GuestControlSvc.h>
    3234#include "VBoxServiceInternal.h"
     35#include "VBoxServiceControl.h"
    3336#include "VBoxServiceUtils.h"
    3437
    … …  
    4245/** The semaphore we're blocking our main control thread on. */
    4346static RTSEMEVENTMULTI      g_hControlEvent = NIL_RTSEMEVENTMULTI;
     47/** The VM session ID. Changes whenever the VM is restored or reset. */
     48static uint64_t             g_idControlSession;
    4449/** The guest control service client ID. */
    4550static uint32_t             g_uControlSvcClientID = 0;
    … …  
    5863/** Critical section protecting g_GuestControlExecThreads. */
    5964static RTCRITSECT           g_csControlThreads;
    60 /** List of guest control files (VBOXSERVICECTRLFILE).
    61  **@todo Use a map (later). */
    62 static RTLISTANCHOR         g_lstControlFiles;
    63 /** The internal file count for building our internal file handles.
    64  *  Should be enough for now. */
    65 static uint32_t             g_uControlFileCount = 0;
    66 
     65/** List of guest control sessions (VBOXSERVICECTRLSESSION). */
     66RTLISTANCHOR                g_lstControlSessions;
    6767
    6868/*******************************************************************************
    6969*   Internal Functions                                                         *
    7070*******************************************************************************/
    71 /** @todo Shorten "VBoxServiceControl" to "gstsvcCntl". */
    72 static int gstcntlReapThreads(void);
    73 static int gstcntlStartAllowed(bool *pbAllowed);
    74 static int gstcntlHandleCmdStartProc(uint32_t u32ClientId, uint32_t uNumParms);
    75 static int gstcntlHandleCmdSetInput(uint32_t u32ClientId, uint32_t uNumParms, void *pvScratchBuf, size_t cbScratchBuf);
    76 static int gstcntlHandleCmdGetOutput(uint32_t u32ClientId, uint32_t uNumParms);
    77 static int gstcntlHandleFileOpen(uint32_t idClient, uint32_t cParms);
    78 static int gstcntlHandleFileClose(uint32_t idClient, uint32_t cParms);
    79 static int gstcntlHandleFileRead(uint32_t idClient, uint32_t cParms);
    80 static int gstcntlHandleFileWrite(uint32_t idClient, uint32_t cParms, void *pvScratchBuf, size_t cbScratchBuf);
    81 static int gstcntlHandleFileSeek(uint32_t idClient, uint32_t cParms);
    82 static int gstcntlHandleFileTell(uint32_t idClient, uint32_t cParms);
     71static int  gstcntlHandleSessionOpen(PVBGLR3GUESTCTRLHOSTCTX pHostCtx);
     72static int  gstcntlHandleSessionClose(PVBGLR3GUESTCTRLHOSTCTX pHostCtx);
     73static int  gstcntlHandleProcExec(PVBGLR3GUESTCTRLHOSTCTX pHostCtx);
     74static int  gstcntlHandleProcInput(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, void *pvScratchBuf, size_t cbScratchBuf);
     75static int  gstcntlHandleProcOutput(PVBGLR3GUESTCTRLHOSTCTX pHostCtx);
     76static int  gstcntlHandleProcTerminate(PVBGLR3GUESTCTRLHOSTCTX pHostCtx);
     77static int  gstcntlHandleProcWaitFor(PVBGLR3GUESTCTRLHOSTCTX pHostCtx);
     78static int  gstcntlReapThreads(void);
     79static void VBoxServiceControlShutdown(void);
     80static int  vboxServiceControlProcessCloseAll(void);
     81static int  gstcntlStartAllowed(bool *pbAllowed);
    8382
    8483#ifdef DEBUG
    … …  
    137136    else
    138137    {
    139         rc = VBoxServiceReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--control-procs-max-kept",
    140                                        &g_uControlProcsMaxKept, 0, UINT32_MAX - 1);
    141 
    142138        VbglR3GuestPropDisconnect(uGuestPropSvcClientID);
    143139    }
    … …  
    162158        rc = VBoxServiceArgUInt32(argc, argv, "", pi,
    163159                                  &g_uControlIntervalMS, 1, UINT32_MAX - 1);
    164     else if (!strcmp(argv[*pi], "--control-procs-max-kept"))
    165         rc = VBoxServiceArgUInt32(argc, argv, "", pi,
    166                                   &g_uControlProcsMaxKept, 0, UINT32_MAX - 1);
    167160#ifdef DEBUG
    168161    else if (!strcmp(argv[*pi], "--control-dump-stderr"))
    … …  
    194187    AssertRCReturn(rc, rc);
    195188
     189    VbglR3GetSessionId(&g_idControlSession);
     190    /* The status code is ignored as this information is not available with VBox < 3.2.10. */
     191
    196192    rc = VbglR3GuestCtrlConnect(&g_uControlSvcClientID);
    197193    if (RT_SUCCESS(rc))
    … …  
    202198        RTListInit(&g_lstControlThreadsActive);
    203199        RTListInit(&g_lstControlThreadsInactive);
    204         RTListInit(&g_lstControlFiles);
     200        RTListInit(&g_lstControlSessions);
    205201
    206202        /* Init critical section for protecting the thread lists. */
    … …  
    245241    AssertPtrReturn(pvScratchBuf, VERR_NO_MEMORY);
    246242
    247     /*
    248      * Execution loop.
    249      *
    250      * @todo
    251      */
     243    VBGLR3GUESTCTRLHOSTCTX ctxHost = { g_uControlSvcClientID,
     244                                       1 /* Default protocol version */ };
    252245    for (;;)
    253246    {
    … …  
    255248        uint32_t uMsg = 0;
    256249        uint32_t cParms = 0;
    257         rc = VbglR3GuestCtrlWaitForHostMsg(g_uControlSvcClientID, &uMsg, &cParms);
     250        rc = VbglR3GuestCtrlMsgWaitFor(g_uControlSvcClientID, &uMsg, &cParms);
    258251        if (rc == VERR_TOO_MUCH_DATA)
    259252        {
    … …  
    266259        {
    267260            VBoxServiceVerbose(3, "Msg=%u (%u parms) retrieved\n", uMsg, cParms);
     261
     262            /* Set number of parameters for current host context. */
     263            ctxHost.uNumParms = cParms;
     264
     265            /* Check for VM session change. */
     266            uint64_t idNewSession = g_idControlSession;
     267            int rc2 = VbglR3GetSessionId(&idNewSession);
     268            if (   RT_SUCCESS(rc2)
     269                && (idNewSession != g_idControlSession))
     270            {
     271                VBoxServiceVerbose(1, "The VM session ID changed\n");
     272                g_idControlSession = idNewSession;
     273
     274                /* Close all opened guest sessions -- all context IDs, sessions etc.
     275                 * are now invalid. */
     276                rc2 = vboxServiceControlProcessCloseAll();
     277                AssertRC(rc2);
     278            }
     279
    268280            switch (uMsg)
    269281            {
    270282                case HOST_CANCEL_PENDING_WAITS:
    271                     VBoxServiceVerbose(3, "Host asked us to quit ...\n");
     283                    VBoxServiceVerbose(1, "We were asked to quit ...\n");
    272284                    break;
    273285
     286                case HOST_SESSION_CREATE:
     287                    rc = gstcntlHandleSessionOpen(&ctxHost);
     288                    break;
     289
     290                case HOST_SESSION_CLOSE:
     291                    rc = gstcntlHandleSessionClose(&ctxHost);
     292                    break;
     293
    274294                case HOST_EXEC_CMD:
    275                     rc = gstcntlHandleCmdStartProc(g_uControlSvcClientID, cParms);
     295                    rc = gstcntlHandleProcExec(&ctxHost);
    276296                    break;
    277297
    278298                case HOST_EXEC_SET_INPUT:
    279                     rc = gstcntlHandleCmdSetInput(g_uControlSvcClientID, cParms,
    280                                                              pvScratchBuf, cbScratchBuf);
     299                    rc = gstcntlHandleProcInput(&ctxHost,
     300                                                pvScratchBuf, cbScratchBuf);
    281301                    break;
    282302
    283303                case HOST_EXEC_GET_OUTPUT:
    284                     rc = gstcntlHandleCmdGetOutput(g_uControlSvcClientID, cParms);
     304                    rc = gstcntlHandleProcOutput(&ctxHost);
    285305                    break;
    286306
    287                case HOST_FILE_OPEN:
    288                     rc = gstcntlHandleFileOpen(g_uControlSvcClientID, cParms);
     307                case HOST_EXEC_TERMINATE:
     308                    rc = gstcntlHandleProcTerminate(&ctxHost);
    289309                    break;
    290310
    291                 case HOST_FILE_CLOSE:
    292                     rc = gstcntlHandleFileClose(g_uControlSvcClientID, cParms);
    293                     break;
    294 
    295                 case HOST_FILE_READ:
    296                     rc = gstcntlHandleFileRead(g_uControlSvcClientID, cParms);
    297                     break;
    298 
    299                 case HOST_FILE_WRITE:
    300                     rc = gstcntlHandleFileWrite(g_uControlSvcClientID, cParms,
    301                                                            pvScratchBuf, cbScratchBuf);
    302                     break;
    303 
    304                 case HOST_FILE_SEEK:
    305                     rc = gstcntlHandleFileSeek(g_uControlSvcClientID, cParms);
    306                     break;
    307 
    308                 case HOST_FILE_TELL:
    309                     rc = gstcntlHandleFileTell(g_uControlSvcClientID, cParms);
     311                case HOST_EXEC_WAIT_FOR:
     312                    rc = gstcntlHandleProcWaitFor(&ctxHost);
    310313                    break;
    311314
    … …  
    321324            || (RT_SUCCESS(rc) && uMsg == HOST_CANCEL_PENDING_WAITS))
    322325        {
    323             rc = VINF_SUCCESS;
    324326            break;
    325327        }
    … …  
    328330        RTThreadYield();
    329331    }
     332
     333    VBoxServiceVerbose(0, "Guest control service stopped\n");
    330334
    331335    /* Delete scratch buffer. */
    … …  
    333337        RTMemFree(pvScratchBuf);
    334338
     339    VBoxServiceVerbose(0, "Guest control worker returned with rc=%Rrc\n", rc);
    335340    return rc;
    336341}
    … …  
    344349 * @param   cParms          The number of parameters the host is offering.
    345350 */
    346 static int gstcntlHandleCmdStartProc(uint32_t uClientID, uint32_t cParms)
    347 {
    348     uint32_t uContextID = 0;
     351static int gstcntlHandleProcExec(PVBGLR3GUESTCTRLHOSTCTX pHostCtx)
     352{
     353    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
    349354
    350355    int rc;
    351356    bool fStartAllowed = false; /* Flag indicating whether starting a process is allowed or not. */
    352     if (cParms == 11)
    353     {
    354         VBOXSERVICECTRLPROCESS proc;
     357
     358    if (   (pHostCtx->uProtocol < 2  && pHostCtx->uNumParms == 11)
     359        || (pHostCtx->uProtocol >= 2 && pHostCtx->uNumParms == 12)
     360       )
     361    {
     362        VBOXSERVICECTRLPROCSTARTUPINFO proc;
    355363        RT_ZERO(proc);
    356364
    … …  
    360368        proc.cbEnv = sizeof(proc.szEnv);
    361369
    362         rc = VbglR3GuestCtrlExecGetHostCmdExec(uClientID,
    363                                                cParms,
    364                                                &uContextID,
    365                                                /* Command */
    366                                                proc.szCmd,      sizeof(proc.szCmd),
    367                                                /* Flags */
    368                                                &proc.uFlags,
    369                                                /* Arguments */
    370                                                proc.szArgs,     sizeof(proc.szArgs), &proc.uNumArgs,
    371                                                /* Environment */
    372                                                proc.szEnv, &proc.cbEnv, &proc.uNumEnvVars,
    373                                                /* Credentials */
    374                                                proc.szUser,     sizeof(proc.szUser),
    375                                                proc.szPassword, sizeof(proc.szPassword),
    376                                                /* Timelimit */
    377                                                &proc.uTimeLimitMS);
    378         if (RT_SUCCESS(rc))
    379         {
    380             VBoxServiceVerbose(3, "Request to start process szCmd=%s, uFlags=0x%x, szArgs=%s, szEnv=%s, szUser=%s, szPassword=%s, uTimeout=%u\n",
     370        rc = VbglR3GuestCtrlProcGetStart(pHostCtx,
     371                                         /* Command */
     372                                         proc.szCmd,      sizeof(proc.szCmd),
     373                                         /* Flags */
     374                                         &proc.uFlags,
     375                                         /* Arguments */
     376                                         proc.szArgs,     sizeof(proc.szArgs), &proc.uNumArgs,
     377                                         /* Environment */
     378                                         proc.szEnv, &proc.cbEnv, &proc.uNumEnvVars,
     379                                         /* Credentials; for hosts with VBox < 4.3. */
     380                                         proc.szUser,     sizeof(proc.szUser),
     381                                         proc.szPassword, sizeof(proc.szPassword),
     382                                         /* Timelimit */
     383                                         &proc.uTimeLimitMS,
     384                                         /* Process priority */
     385                                         &proc.uPriority,
     386                                         /* Process affinity */
     387                                         proc.uAffinity,  sizeof(proc.uAffinity), &proc.uNumAffinity);
     388        if (RT_SUCCESS(rc))
     389        {
     390            VBoxServiceVerbose(3, "Request to start process szCmd=%s, uFlags=0x%x, szArgs=%s, szEnv=%s, szUser=%s, szPassword=%s, uTimeout=%RU32\n",
    381391                               proc.szCmd, proc.uFlags,
    382392                               proc.uNumArgs ? proc.szArgs : "<None>",
    … …  
    400410                if (fStartAllowed)
    401411                {
    402                     rc = GstCntlProcessStart(uContextID, &proc);
     412                    rc = GstCntlProcessStart(pHostCtx->uContextID, &proc);
    403413                }
    404414                else
    … …  
    408418    }
    409419    else
    410         rc = VERR_INVALID_PARAMETER; /* Incorrect number of parameters. */
     420        rc = VERR_NOT_SUPPORTED; /* Unsupported number of parameters. */
    411421
    412422    /* In case of an error we need to notify the host to not wait forever for our response. */
    … …  
    419429         *       from the host. The host in case has to deal with that!
    420430         */
    421         int rc2 = VbglR3GuestCtrlExecReportStatus(uClientID, uContextID /* Might be 0 */, 0 /* PID, invalid */,
    422                                                   PROC_STS_ERROR, rc,
    423                                                   NULL /* pvData */, 0 /* cbData */);
     431        int rc2 = VbglR3GuestCtrlProcCbStatus(pHostCtx->uClientID, pHostCtx->uContextID,
     432                                              0 /* PID, invalid */,
     433                                              PROC_STS_ERROR, rc,
     434                                              NULL /* pvData */, 0 /* cbData */);
    424435        if (RT_FAILURE(rc2))
    425436        {
    … …  
    427438            if (RT_SUCCESS(rc))
    428439                rc = rc2;
     440        }
     441    }
     442
     443    return rc;
     444}
     445
     446
     447static int gstcntlHandleProcTerminate(PVBGLR3GUESTCTRLHOSTCTX pHostCtx)
     448{
     449    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     450
     451    uint32_t uPID;
     452    int rc = VbglR3GuestCtrlProcGetTerminate(pHostCtx, &uPID);
     453    if (RT_SUCCESS(rc))
     454    {
     455        PVBOXSERVICECTRLREQUEST pRequest;
     456        rc = GstCntlProcessRequestAllocEx(&pRequest, VBOXSERVICECTRLREQUEST_PROC_TERM,
     457                                          NULL /* pvBuf */, NULL /* cbBuf */, pHostCtx->uContextID);
     458        if (RT_SUCCESS(rc))
     459        {
     460            rc = GstCntlProcessPerform(uPID, pRequest);
     461            GstCntlProcessRequestFree(pRequest);
     462        }
     463    }
     464
     465    return rc;
     466}
     467
     468
     469static int gstcntlHandleProcWaitFor(PVBGLR3GUESTCTRLHOSTCTX pHostCtx)
     470{
     471    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     472
     473    uint32_t uPID;
     474    uint32_t uWaitFlags; uint32_t uTimeoutMS;
     475
     476    int rc = VbglR3GuestCtrlProcGetWaitFor(pHostCtx, &uPID, &uWaitFlags, &uTimeoutMS);
     477    if (RT_SUCCESS(rc))
     478    {
     479        PVBOXSERVICECTRLREQUEST pRequest;
     480        VBOXSERVICECTRLREQDATA_WAIT_FOR reqData = { uWaitFlags, uTimeoutMS };
     481        rc = GstCntlProcessRequestAllocEx(&pRequest, VBOXSERVICECTRLREQUEST_WAIT_FOR,
     482                                          &reqData, sizeof(reqData), pHostCtx->uContextID);
     483        if (RT_SUCCESS(rc))
     484        {
     485            rc = GstCntlProcessPerform(uPID, pRequest);
     486            GstCntlProcessRequestFree(pRequest);
    429487        }
    430488    }
    … …  
    439497 * @return  IPRT status code.
    440498 * @param   uPID                    PID of process to retrieve the output from.
     499 * @param   uCID                    Context ID.
    441500 * @param   uHandleId               Stream ID (stdout = 0, stderr = 2) to get the output from.
    442501 * @param   cMsTimeout              Timeout (in ms) to wait for output becoming
    … …  
    459518    {
    460519        case OUTPUT_HANDLE_ID_STDERR:
    461             reqType = VBOXSERVICECTRLREQUEST_STDERR_READ;
     520            reqType = VBOXSERVICECTRLREQUEST_PROC_STDERR;
    462521            break;
    463522
    464523        case OUTPUT_HANDLE_ID_STDOUT:
    465524        case OUTPUT_HANDLE_ID_STDOUT_DEPRECATED:
    466             reqType = VBOXSERVICECTRLREQUEST_STDOUT_READ;
     525            reqType = VBOXSERVICECTRLREQUEST_PROC_STDOUT;
    467526            break;
    468527
    … …  
    505564    if (RT_SUCCESS(rc))
    506565    {
    507         VBoxServiceVerbose(3, "Setting thread (PID %u) to list %d\n",
     566        VBoxServiceVerbose(3, "Setting thread (PID %RU32) to list %d\n",
    508567                           pThread->uPID, enmList);
    509568
    … …  
    572631    int rc = GstCntlProcessRequestAllocEx(&pRequest,
    573632                                          fPendingClose
    574                                           ? VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF
    575                                           : VBOXSERVICECTRLREQUEST_STDIN_WRITE,
     633                                          ? VBOXSERVICECTRLREQUEST_PROC_STDIN_EOF
     634                                          : VBOXSERVICECTRLREQUEST_PROC_STDIN,
    576635                                          pvBuf, cbBuf, uCID);
    577636    if (RT_SUCCESS(rc))
    … …  
    596655 *
    597656 * @returns IPRT status code.
    598  * @param   idClient                    The HGCM client session ID.
    599  * @param   cParms                      The number of parameters the host is
    600  *                                      offering.
    601657 * @param   pvScratchBuf                The scratch buffer.
    602658 * @param   cbScratchBuf                The scratch buffer size for retrieving the input data.
    603659 */
    604 static int gstcntlHandleCmdSetInput(uint32_t idClient, uint32_t cParms,
    605                                     void *pvScratchBuf, size_t cbScratchBuf)
    606 {
     660static int gstcntlHandleProcInput(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
     661                                  void *pvScratchBuf, size_t cbScratchBuf)
     662{
     663    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
    607664    AssertPtrReturn(cbScratchBuf, VERR_INVALID_PARAMETER);
    608665    AssertPtrReturn(pvScratchBuf, VERR_INVALID_POINTER);
    609666
    610     uint32_t uContextID;
    611667    uint32_t uPID;
    612668    uint32_t uFlags;
    … …  
    619675     * Ask the host for the input data.
    620676     */
    621     int rc = VbglR3GuestCtrlExecGetHostCmdInput(idClient, cParms,
    622                                                 &uContextID, &uPID, &uFlags,
    623                                                 pvScratchBuf, cbScratchBuf, &cbSize);
     677    int rc = VbglR3GuestCtrlProcGetInput(pHostCtx, &uPID, &uFlags,
     678                                         pvScratchBuf, cbScratchBuf, &cbSize);
    624679    if (RT_FAILURE(rc))
    625680    {
    626         VBoxServiceError("[PID %u]: Failed to retrieve exec input command! Error: %Rrc\n",
     681        VBoxServiceError("[PID %RU32]: Failed to retrieve exec input command! Error: %Rrc\n",
    627682                         uPID, rc);
    628683    }
    629684    else if (cbSize > cbScratchBuf)
    630685    {
    631         VBoxServiceError("[PID %u]: Too much input received! cbSize=%u, cbScratchBuf=%u\n",
     686        VBoxServiceError("[PID %RU32]: Too much input received! cbSize=%u, cbScratchBuf=%u\n",
    632687                         uPID, cbSize, cbScratchBuf);
    633688        rc = VERR_INVALID_PARAMETER;
    … …  
    642697        {
    643698            fPendingClose = true;
    644             VBoxServiceVerbose(4, "[PID %u]: Got last input block of size %u ...\n",
     699            VBoxServiceVerbose(4, "[PID %RU32]: Got last input block of size %u ...\n",
    645700                               uPID, cbSize);
    646701        }
    647702
    648         rc = VBoxServiceControlSetInput(uPID, uContextID, fPendingClose, pvScratchBuf,
     703        rc = VBoxServiceControlSetInput(uPID, pHostCtx->uContextID, fPendingClose, pvScratchBuf,
    649704                                        cbSize, &cbWritten);
    650         VBoxServiceVerbose(4, "[PID %u]: Written input, CID=%u, rc=%Rrc, uFlags=0x%x, fPendingClose=%d, cbSize=%u, cbWritten=%u\n",
    651                            uPID, uContextID, rc, uFlags, fPendingClose, cbSize, cbWritten);
     705        VBoxServiceVerbose(4, "[PID %RU32]: Written input, CID=%u, rc=%Rrc, uFlags=0x%x, fPendingClose=%d, cbSize=%u, cbWritten=%u\n",
     706                           uPID, pHostCtx->uContextID, rc, uFlags, fPendingClose, cbSize, cbWritten);
    652707        if (RT_SUCCESS(rc))
    653708        {
    … …  
    676731    Assert(uStatus > INPUT_STS_UNDEFINED);
    677732
    678     VBoxServiceVerbose(3, "[PID %u]: Input processed, CID=%u, uStatus=%u, uFlags=0x%x, cbWritten=%u\n",
    679                        uPID, uContextID, uStatus, uFlags, cbWritten);
     733    VBoxServiceVerbose(3, "[PID %RU32]: Input processed, CID=%u, uStatus=%u, uFlags=0x%x, cbWritten=%u\n",
     734                       uPID, pHostCtx->uContextID, uStatus, uFlags, cbWritten);
    680735
    681736    /* Note: Since the context ID is unique the request *has* to be completed here,
    682737     *       regardless whether we got data or not! Otherwise the progress object
    683738     *       on the host never will get completed! */
    684     rc = VbglR3GuestCtrlExecReportStatusIn(idClient, uContextID, uPID,
    685                                            uStatus, uFlags, (uint32_t)cbWritten);
     739    rc = VbglR3GuestCtrlProcCbStatusInput(pHostCtx->uClientID, pHostCtx->uContextID, uPID,
     740                                          uStatus, uFlags, (uint32_t)cbWritten);
    686741
    687742    if (RT_FAILURE(rc))
    688         VBoxServiceError("[PID %u]: Failed to report input status! Error: %Rrc\n",
     743        VBoxServiceError("[PID %RU32]: Failed to report input status! Error: %Rrc\n",
    689744                         uPID, rc);
    690     return rc;
    691 }
    692 
    693 
    694 static PVBOXSERVICECTRLFILE gstcntlGetFile(uint32_t uHandle)
    695 {
    696     PVBOXSERVICECTRLFILE pFileCur = NULL;
    697     /** @todo Use a map later! */
    698     RTListForEach(&g_lstControlFiles, pFileCur, VBOXSERVICECTRLFILE, Node)
    699     {
    700         if (pFileCur->uHandle == uHandle)
    701             return pFileCur;
    702     }
    703 
    704     return NULL;
    705 }
    706 
    707 
    708 static int gstcntlHandleFileOpen(uint32_t idClient, uint32_t cParms)
    709 {
    710     uint32_t uContextID;
    711 
    712     char szFile[RTPATH_MAX];
    713     char szOpenMode[64];
    714     char szDisposition[64];
    715     uint32_t uCreationMode;
    716     uint64_t uOffset;
    717 
    718     int rc = VbglR3GuestCtrlFileGetHostCmdOpen(idClient, cParms, &uContextID,
    719                                                /* File to open. */
    720                                                szFile, sizeof(szFile),
    721                                                /* Open mode. */
    722                                                szOpenMode, sizeof(szOpenMode),
    723                                                /* Disposition. */
    724                                                szDisposition, sizeof(szDisposition),
    725                                                /* Creation mode. */
    726                                                &uCreationMode,
    727                                                /* Offset. */
    728                                                &uOffset);
    729     if (RT_SUCCESS(rc))
    730     {
    731         PVBOXSERVICECTRLFILE pFile = (PVBOXSERVICECTRLFILE)RTMemAlloc(sizeof(VBOXSERVICECTRLFILE));
    732         if (!pFile)
    733             return VERR_NO_MEMORY;
    734 
    735         if (!RTStrPrintf(pFile->szName, sizeof(pFile->szName), "%s", szFile))
    736             rc = VERR_BUFFER_UNDERFLOW;
    737 
    738         if (RT_SUCCESS(rc))
    739         {
    740             uint64_t fFlags = RTFILE_O_OPEN_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE; /** @todo Modes! */
    741             rc = RTFileOpen(&pFile->hFile, pFile->szName, fFlags);
    742             if (   RT_SUCCESS(rc)
    743                 && uOffset)
    744             {
    745                 /* Seeking is optional. */
    746                 int rc2 = RTFileSeek(pFile->hFile, (int64_t)uOffset, RTFILE_SEEK_BEGIN, NULL /* Current offset */);
    747                 if (RT_FAILURE(rc2))
    748                     VBoxServiceVerbose(3, "[File %s]: Seeking to offset %RU64 failed; rc=%Rrc\n",
    749                                        pFile->szName, uOffset, rc);
    750             }
    751             else
    752                 VBoxServiceVerbose(3, "[File %s]: Opening failed; rc=%Rrc\n",
    753                                    pFile->szName, rc);
    754         }
    755 
    756         uint32_t uHandle = 0;
    757         if (RT_SUCCESS(rc))
    758         {
    759             VBoxServiceVerbose(3, "[File %s]: Opened.\n", pFile->szName);
    760 
    761             uHandle = g_uControlFileCount++;
    762             pFile->uHandle = uHandle;
    763             /* rc = */ RTListAppend(&g_lstControlFiles, &pFile->Node);
    764         }
    765 
    766         if (RT_FAILURE(rc))
    767             RTMemFree(pFile);
    768 
    769         /* Report back in any case. */
    770         int rc2 = VbglR3GuestCtrlFileNotify(idClient, uContextID, uHandle,
    771                                             GUESTFILENOTIFYTYPE_OPEN, &rc, sizeof(rc));
    772         if (RT_FAILURE(rc2))
    773             VBoxServiceError("[File %s]: Failed to report open status, rc=%Rrc\n",
    774                              szFile, rc2);
    775         if (RT_SUCCESS(rc))
    776             rc = rc2;
    777     }
    778     return rc;
    779 }
    780 
    781 
    782 static int gstcntlHandleFileClose(uint32_t idClient, uint32_t cParms)
    783 {
    784     uint32_t uContextID;
    785     uint32_t uHandle;
    786 
    787     int rc = VbglR3GuestCtrlFileGetHostCmdClose(idClient, cParms, &uContextID,
    788                                                 /* File handle to close. */
    789                                                 &uHandle);
    790     if (RT_SUCCESS(rc))
    791     {
    792         PVBOXSERVICECTRLFILE pFile = gstcntlGetFile(uHandle);
    793         if (pFile)
    794         {
    795             rc = RTFileClose(pFile->hFile);
    796         }
    797         else
    798             rc = VERR_NOT_FOUND;
    799 
    800         /* Report back in any case. */
    801         int rc2 = VbglR3GuestCtrlFileNotify(idClient, uContextID, uHandle,
    802                                             GUESTFILENOTIFYTYPE_CLOSE, &rc, sizeof(rc));
    803         if (RT_FAILURE(rc2))
    804             VBoxServiceError("Failed to report close status, rc=%Rrc\n", rc2);
    805         if (RT_SUCCESS(rc))
    806             rc = rc2;
    807     }
    808     return rc;
    809 }
    810 
    811 
    812 static int gstcntlHandleFileRead(uint32_t idClient, uint32_t cParms)
    813 {
    814     uint32_t uContextID;
    815     uint32_t uHandle;
    816     uint32_t cbToRead;
    817 
    818     int rc = VbglR3GuestCtrlFileGetHostCmdRead(idClient, cParms, &uContextID,
    819                                                &uHandle, &cbToRead);
    820     if (RT_SUCCESS(rc))
    821     {
    822 
    823     }
    824     return rc;
    825 }
    826 
    827 
    828 static int gstcntlHandleFileWrite(uint32_t idClient, uint32_t cParms,
    829                                              void *pvScratchBuf, size_t cbScratchBuf)
    830 {
    831     AssertPtrReturn(cbScratchBuf, VERR_INVALID_PARAMETER);
    832     AssertPtrReturn(pvScratchBuf, VERR_INVALID_POINTER);
    833 
    834     uint32_t uContextID;
    835     uint32_t uHandle;
    836     uint32_t cbToWrite;
    837 
    838     int rc = VbglR3GuestCtrlFileGetHostCmdWrite(idClient, cParms, &uContextID,
    839                                                 &uHandle, pvScratchBuf, cbScratchBuf,
    840                                                 &cbToWrite);
    841     if (RT_SUCCESS(rc))
    842     {
    843 
    844     }
    845     return rc;
    846 }
    847 
    848 
    849 static int gstcntlHandleFileSeek(uint32_t idClient, uint32_t cParms)
    850 {
    851     uint32_t uContextID;
    852     uint32_t uHandle;
    853     uint32_t uSeekMethod;
    854     uint64_t uOffset; /* Will be converted to int64_t. */
    855 
    856     int rc = VbglR3GuestCtrlFileGetHostCmdSeek(idClient, cParms, &uContextID,
    857                                                &uHandle, &uSeekMethod, &uOffset);
    858     if (RT_SUCCESS(rc))
    859     {
    860 
    861     }
    862     return rc;
    863 }
    864 
    865 
    866 static int gstcntlHandleFileTell(uint32_t idClient, uint32_t cParms)
    867 {
    868     uint32_t uContextID;
    869     uint32_t uHandle;
    870 
    871     int rc = VbglR3GuestCtrlFileGetHostCmdTell(idClient, cParms, &uContextID,
    872                                                &uHandle);
    873     if (RT_SUCCESS(rc))
    874     {
    875 
    876     }
    877745    return rc;
    878746}
    … …  
    883751 *
    884752 * @return  IPRT status code.
    885  * @param   idClient        The HGCM client session ID.
    886  * @param   cParms          The number of parameters the host is offering.
    887  */
    888 static int gstcntlHandleCmdGetOutput(uint32_t idClient, uint32_t cParms)
    889 {
    890     uint32_t uContextID;
     753 */
     754static int gstcntlHandleProcOutput(PVBGLR3GUESTCTRLHOSTCTX pHostCtx)
     755{
     756    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     757
    891758    uint32_t uPID;
    892759    uint32_t uHandleID;
    893760    uint32_t uFlags;
    894761
    895     int rc = VbglR3GuestCtrlExecGetHostCmdOutput(idClient, cParms,
    896                                                  &uContextID, &uPID, &uHandleID, &uFlags);
     762    int rc = VbglR3GuestCtrlProcGetOutput(pHostCtx, &uPID, &uHandleID, &uFlags);
    897763    if (RT_SUCCESS(rc))
    898764    {
    … …  
    901767        {
    902768            uint32_t cbRead = 0;
    903             rc = VBoxServiceControlExecGetOutput(uPID, uContextID, uHandleID, RT_INDEFINITE_WAIT /* Timeout */,
     769            rc = VBoxServiceControlExecGetOutput(uPID, pHostCtx->uContextID, uHandleID, RT_INDEFINITE_WAIT /* Timeout */,
    904770                                                 pBuf, _64K /* cbSize */, &cbRead);
    905             VBoxServiceVerbose(3, "[PID %u]: Got output, rc=%Rrc, CID=%u, cbRead=%u, uHandle=%u, uFlags=%u\n",
    906                                uPID, rc, uContextID, cbRead, uHandleID, uFlags);
     771            VBoxServiceVerbose(3, "[PID %RU32]: Got output, rc=%Rrc, CID=%u, cbRead=%u, uHandle=%u, uFlags=%u\n",
     772                               uPID, rc, pHostCtx->uContextID, cbRead, uHandleID, uFlags);
    907773
    908774#ifdef DEBUG
    … …  
    934800             *       regardless whether we got data or not! Otherwise the progress object
    935801             *       on the host never will get completed! */
    936             int rc2 = VbglR3GuestCtrlExecSendOut(idClient, uContextID, uPID, uHandleID, uFlags,
    937                                                  pBuf, cbRead);
     802            int rc2 = VbglR3GuestCtrlProcCbOutput(pHostCtx->uClientID, pHostCtx->uContextID, uPID, uHandleID, uFlags,
     803                                                  pBuf, cbRead);
    938804            if (RT_SUCCESS(rc))
    939805                rc = rc2;
    … …  
    948814
    949815    if (RT_FAILURE(rc))
    950         VBoxServiceError("[PID %u]: Error handling output command! Error: %Rrc\n",
     816        VBoxServiceError("[PID %RU32]: Error handling output command! Error: %Rrc\n",
    951817                         uPID, rc);
     818    return rc;
     819}
     820
     821
     822static int gstcntlHandleSessionOpen(PVBGLR3GUESTCTRLHOSTCTX pHostCtx)
     823{
     824    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     825
     826    VBOXSERVICECTRLSESSIONSTARTUPINFO ssInfo = { 0 };
     827    int rc = VbglR3GuestCtrlSessionGetOpen(pHostCtx,
     828                                           &ssInfo.uProtocol,
     829                                           ssInfo.szUser,     sizeof(ssInfo.szUser),
     830                                           ssInfo.szPassword, sizeof(ssInfo.szPassword),
     831                                           ssInfo.szDomain,   sizeof(ssInfo.szDomain),
     832                                           &ssInfo.uFlags,    &ssInfo.uSessionID);
     833    if (RT_SUCCESS(rc))
     834    {
     835        /* The session open call has the protocol version the host
     836         * wants to use. Store it in the host context for later calls. */
     837        pHostCtx->uProtocol = ssInfo.uProtocol;
     838
     839        rc = GstCntlSessionOpen(&ssInfo, NULL /* Node */);
     840    }
     841
     842    /* Report back session opening status in any case. */
     843    int rc2 = VbglR3GuestCtrlSessionNotify(pHostCtx->uClientID, pHostCtx->uContextID,
     844                                           GUEST_SESSION_NOTIFYTYPE_OPEN, rc /* uint32_t vs. int */);
     845    if (RT_FAILURE(rc2))
     846    {
     847        VBoxServiceError("Reporting session opening status failed with rc=%Rrc\n", rc2);
     848        if (RT_SUCCESS(rc))
     849            rc = rc2;
     850    }
     851
     852    VBoxServiceVerbose(3, "Opening a new guest session returned rc=%Rrc\n", rc);
     853    return rc;
     854}
     855
     856
     857static int gstcntlHandleSessionClose(PVBGLR3GUESTCTRLHOSTCTX pHostCtx)
     858{
     859    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     860
     861    uint32_t uSessionID, uFlags;
     862
     863    int rc = VbglR3GuestCtrlSessionGetClose(pHostCtx, &uFlags, &uSessionID);
     864    if (RT_SUCCESS(rc))
     865    {
     866        rc = VERR_NOT_FOUND;
     867
     868        PVBOXSERVICECTRLSESSION pSession;
     869        RTListForEach(&g_lstControlSessions, pSession, VBOXSERVICECTRLSESSION, Node)
     870        {
     871            if (pSession->StartupInfo.uSessionID == uSessionID)
     872            {
     873                rc = GstCntlSessionClose(pSession, uFlags);
     874                break;
     875            }
     876        }
     877    }
     878
     879    /* Report back session closing status in any case. */
     880    int rc2 = VbglR3GuestCtrlSessionNotify(pHostCtx->uClientID, pHostCtx->uContextID,
     881                                           GUEST_SESSION_NOTIFYTYPE_CLOSE, rc /* uint32_t vs. int */);
     882    if (RT_FAILURE(rc2))
     883    {
     884        VBoxServiceError("Reporting session closing status failed with rc=%Rrc\n", rc2);
     885        if (RT_SUCCESS(rc))
     886            rc = rc2;
     887    }
     888
     889    VBoxServiceVerbose(2, "Closing guest session %RU32 returned rc=%Rrc\n",
     890                       uSessionID, rc);
    952891    return rc;
    953892}
    … …  
    1030969
    1031970
    1032 /**
    1033  * Destroys all guest process threads which are still active.
    1034  */
    1035 static void VBoxServiceControlShutdown(void)
    1036 {
    1037     VBoxServiceVerbose(2, "Shutting down ...\n");
     971static int vboxServiceControlProcessClose()
     972{
     973    /** Note: This will be a guest tsession task later. */
    1038974
    1039975    /* Signal all threads in the active list that we want to shutdown. */
    … …  
    1053989                                     NULL /* rc */);
    1054990        if (RT_FAILURE(rc2))
     991        {
    1055992            VBoxServiceError("Guest process thread failed to stop; rc=%Rrc\n", rc2);
     993            /* Keep going. */
     994        }
    1056995
    1057996        if (fLast)
    … …  
    10611000    }
    10621001
    1063     int rc2 = gstcntlReapThreads();
    1064     if (RT_FAILURE(rc2))
    1065         VBoxServiceError("Reaping inactive threads failed with rc=%Rrc\n", rc2);
     1002    int rc = gstcntlReapThreads();
     1003    if (RT_FAILURE(rc))
     1004        VBoxServiceError("Reaping inactive threads failed with rc=%Rrc\n", rc);
    10661005
    10671006    AssertMsg(RTListIsEmpty(&g_lstControlThreadsActive),
    … …  
    10701009              ("Guest process inactive thread list still contains entries when it should not\n"));
    10711010
     1011    return rc;
     1012}
     1013
     1014
     1015static int vboxServiceControlProcessCloseAll(void)
     1016{
     1017    return vboxServiceControlProcessClose();
     1018}
     1019
     1020
     1021/**
     1022 * Destroys all guest process threads which are still active.
     1023 */
     1024static void VBoxServiceControlShutdown(void)
     1025{
     1026    VBoxServiceVerbose(2, "Shutting down ...\n");
     1027
     1028    int rc2 = vboxServiceControlProcessCloseAll();
     1029    AssertRC(rc2);
     1030
    10721031    /* Destroy critical section. */
    10731032    RTCritSectDelete(&g_csControlThreads);
    1074 
    1075     /* Close all left guest files. */
    1076     PVBOXSERVICECTRLFILE pFile;
    1077     pFile = RTListGetFirst(&g_lstControlFiles, VBOXSERVICECTRLFILE, Node);
    1078     while (pFile)
    1079     {
    1080         PVBOXSERVICECTRLFILE pNext = RTListNodeGetNext(&pFile->Node, VBOXSERVICECTRLFILE, Node);
    1081         bool fLast = RTListNodeIsLast(&g_lstControlFiles, &pFile->Node);
    1082 
    1083         rc2 = RTFileClose(pFile->hFile);
    1084         if (RT_FAILURE(rc2))
    1085         {
    1086             VBoxServiceError("Unable to close file \"%s\"; rc=%Rrc\n",
    1087                              pFile->szName, rc2);
    1088             /* Keep going. */
    1089         }
    1090 
    1091         RTListNodeRemove(&pFile->Node);
    1092 
    1093         if (fLast)
    1094             break;
    1095 
    1096         pFile = pNext;
    1097     }
    1098 
    1099     AssertMsg(RTListIsEmpty(&g_lstControlFiles),
    1100               ("Guest file list still contains entries when it should not\n"));
    11011033
    11021034    VBoxServiceVerbose(2, "Shutting down complete\n");
    … …  
    12511183                    uint32_t uTriedPID = uPID;
    12521184                    uPID += 391939;
    1253                     VBoxServiceVerbose(2, "PID %u was used before, trying again with %u ...\n",
     1185                    VBoxServiceVerbose(2, "PID %RU32 was used before, trying again with %u ...\n",
    12541186                                       uTriedPID, uPID);
    12551187                    fTryAgain = true;
    … …  
    12831215    "              [--control-dump-stderr] [--control-dump-stdout]\n"
    12841216#endif
    1285     "              [--control-interval <ms>] [--control-procs-max-kept <x>]\n"
     1217    "              [--control-interval <ms>]\n"
    12861218    "              [--control-procs-mem-std[in|out|err] <KB>]"
    12871219    ,
    … …  
    12951227    "    --control-interval      Specifies the interval at which to check for\n"
    12961228    "                            new control commands. The default is 1000 ms.\n"
    1297     "    --control-procs-max-kept\n"
    1298     "                            Specifies how many started guest processes are\n"
    1299     "                            kept into memory to work with. Default is 256.\n"
    13001229    ,
    13011230    /* methods */

  • trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControlThread.cpp

    r44248 r44863  
    11/* $Id$ */
    22/** @file
    3  * VBoxServiceControlExecThread - Thread for every started guest process.
     3 * VBoxServiceControlThread - Guest process handling.
    44 */
    55
    … …  
    3939
    4040#include "VBoxServiceInternal.h"
     41#include "VBoxServiceControl.h"
    4142
    4243using namespace guestControl;
    … …  
    423424
    424425
     426/**
     427 * Signals the given request.
     428 *
     429 * @return  IPRT status code.
     430 * @param   pRequest                Pointer to request to signal.
     431 * @param   rc                      rc to set request result to.
     432 */
     433static int gstcntlProcessSignalRequest(PVBOXSERVICECTRLREQUEST pRequest, int rc)
     434{
     435    AssertPtrReturn(pRequest, VERR_INVALID_POINTER);
     436
     437    /* Assign overall result. */
     438    pRequest->rc = rc;
     439
     440#ifdef _DEBUG
     441    VBoxServiceVerbose(4, "Handled req=%u, CID=%u, rc=%Rrc, cbData=%u, pvData=%p\n",
     442                       pRequest->enmType, pRequest->uCID, pRequest->rc,
     443                       pRequest->cbData, pRequest->pvData);
     444#endif
     445
     446    /* In any case, regardless of the result, we notify
     447     * the main guest control to unblock it. */
     448    int rc2 = RTSemEventMultiSignal(pRequest->Event);
     449    AssertRC(rc2);
     450
     451    return rc2;
     452}
     453
     454
    425455static int gstcntlProcessHandleRequest(RTPOLLSET hPollSet, uint32_t fPollEvt,
    426456                                       PRTPIPE phStdInW, PRTPIPE phStdOutR, PRTPIPE phStdErrR,
    427                                        PVBOXSERVICECTRLTHREAD pThread)
    428 {
    429     AssertPtrReturn(pThread, VERR_INVALID_POINTER);
     457                                       PVBOXSERVICECTRLTHREAD pThread, PVBOXSERVICECTRLREQUEST pRequest)
     458{
    430459    AssertPtrReturn(phStdInW, VERR_INVALID_POINTER);
    431460    AssertPtrReturn(phStdOutR, VERR_INVALID_POINTER);
    432461    AssertPtrReturn(phStdErrR, VERR_INVALID_POINTER);
     462    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
     463    AssertPtrReturn(pRequest, VERR_INVALID_POINTER);
    433464
    434465    /* Drain the notification pipe. */
    … …  
    439470        VBoxServiceError("Draining IPC notification pipe failed with rc=%Rrc\n", rc);
    440471
     472    bool fDefer = false; /* Whether the request completion should be deferred or not. */
    441473    int rcReq = VINF_SUCCESS; /* Actual request result. */
    442 
    443     PVBOXSERVICECTRLREQUEST pRequest = pThread->pRequest;
    444     if (!pRequest)
    445     {
    446         VBoxServiceError("IPC request is invalid\n");
    447         return VERR_INVALID_POINTER;
    448     }
    449474
    450475    switch (pRequest->enmType)
    … …  
    459484        }
    460485
    461         case VBOXSERVICECTRLREQUEST_STDIN_WRITE:
    462         case VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF:
     486        case VBOXSERVICECTRLREQUEST_PROC_STDIN:
     487        case VBOXSERVICECTRLREQUEST_PROC_STDIN_EOF:
    463488        {
    464489            size_t cbWritten = 0;
    … …  
    480505             * the poll set.
    481506             */
    482             if (   pRequest->enmType == VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF
     507            if (   pRequest->enmType == VBOXSERVICECTRLREQUEST_PROC_STDIN_EOF
    483508                && pRequest->cbData  == cbWritten)
    484509            {
    … …  
    491516        }
    492517
    493         case VBOXSERVICECTRLREQUEST_STDOUT_READ:
    494         case VBOXSERVICECTRLREQUEST_STDERR_READ:
     518        case VBOXSERVICECTRLREQUEST_PROC_STDOUT:
     519        case VBOXSERVICECTRLREQUEST_PROC_STDERR:
    495520        {
    496521            AssertPtrReturn(pRequest->pvData, VERR_INVALID_POINTER);
    497522            AssertReturn(pRequest->cbData, VERR_INVALID_PARAMETER);
    498523
    499             PRTPIPE pPipeR = pRequest->enmType == VBOXSERVICECTRLREQUEST_STDERR_READ
     524            PRTPIPE pPipeR = pRequest->enmType == VBOXSERVICECTRLREQUEST_PROC_STDERR
    500525                           ? phStdErrR : phStdOutR;
    501526            AssertPtr(pPipeR);
    … …  
    508533                if (RT_FAILURE(rcReq))
    509534                {
    510                     RTPollSetRemove(hPollSet, pRequest->enmType == VBOXSERVICECTRLREQUEST_STDERR_READ
     535                    RTPollSetRemove(hPollSet, pRequest->enmType == VBOXSERVICECTRLREQUEST_PROC_STDERR
    511536                                              ? VBOXSERVICECTRLPIPEID_STDERR : VBOXSERVICECTRLPIPEID_STDOUT);
    512537                    RTPipeClose(*pPipeR);
    … …  
    524549        }
    525550
     551        case VBOXSERVICECTRLREQUEST_PROC_TERM:
     552            ASMAtomicXchgBool(&pThread->fShutdown, true);
     553            fDefer = true;
     554            break;
     555
    526556        default:
    527557            rcReq = VERR_NOT_IMPLEMENTED;
    … …  
    529559    }
    530560
    531     /* Assign overall result. */
    532     pRequest->rc = RT_SUCCESS(rc)
    533                  ? rcReq : rc;
    534 
    535     VBoxServiceVerbose(2, "[PID %u]: Handled req=%u, CID=%u, rc=%Rrc, cbData=%u\n",
    536                        pThread->uPID, pRequest->enmType, pRequest->uCID, pRequest->rc, pRequest->cbData);
    537 
    538     /* In any case, regardless of the result, we notify
    539      * the main guest control to unblock it. */
    540     int rc2 = RTSemEventMultiSignal(pRequest->Event);
    541     AssertRC(rc2);
    542 
    543     /* No access to pRequest here anymore -- could be out of scope
    544      * or modified already! */
    545     pThread->pRequest = pRequest = NULL;
     561    if (   RT_FAILURE(rc)
     562        || !fDefer)
     563    {
     564        rc = gstcntlProcessSignalRequest(pRequest,
     565                                         RT_SUCCESS(rc) ? rcReq : rc);
     566
     567        /* No access to pRequest here anymore -- could be out of scope
     568         * or modified already! */
     569        pThread->pRequest = pRequest = NULL;
     570    }
     571    else /* Completing the request defered. */
     572        rc = VINF_AIO_TASK_PENDING; /** @todo Find an own rc! */
    546573
    547574    return rc;
    … …  
    601628    VBoxServiceVerbose(2, "[PID %u]: Process \"%s\" started, CID=%u, User=%s\n",
    602629                       pThread->uPID, pThread->pszCmd, pThread->uContextID, pThread->pszUser);
    603     rc = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID,
    604                                          pThread->uPID, PROC_STS_STARTED, 0 /* u32Flags */,
    605                                          NULL /* pvData */, 0 /* cbData */);
     630    rc = VbglR3GuestCtrlProcCbStatus(pThread->uClientID, pThread->uContextID,
     631                                     pThread->uPID, PROC_STS_STARTED, 0 /* u32Flags */,
     632                                     NULL /* pvData */, 0 /* cbData */);
    606633
    607634    /*
    608635     * Process input, output, the test pipe and client requests.
    609636     */
     637    PVBOXSERVICECTRLREQUEST pReq = NULL;
    610638    while (   RT_SUCCESS(rc)
    611639           && RT_UNLIKELY(!pThread->fShutdown))
    … …  
    642670
    643671                case VBOXSERVICECTRLPIPEID_IPC_NOTIFY:
     672                    pReq = pThread->pRequest; /** @todo Implement request queue. */
    644673                    rc = gstcntlProcessHandleRequest(hPollSet, fPollEvt,
    645                                                      phStdInW, phStdOutR, phStdErrR, pThread);
     674                                                     phStdInW, phStdOutR, phStdErrR,
     675                                                     pThread, pReq);
     676                    if (rc != VINF_AIO_TASK_PENDING)
     677                        pReq = NULL;
    646678                    break;
    647679
    … …  
    707739            if (cMsElapsed >= cMsTimeout)
    708740            {
    709                 VBoxServiceVerbose(3, "[PID %u]: Timed out (%ums elapsed > %ums timeout), killing ...",
     741                VBoxServiceVerbose(3, "[PID %u]: Timed out (%ums elapsed > %ums timeout), killing ...\n",
    710742                                   pThread->uPID, cMsElapsed, cMsTimeout);
    711743
    … …  
    787819        if (fProcessAlive)
    788820            VBoxServiceVerbose(3, "[PID %u]: Could not be killed\n", pThread->uPID);
     821
     822        if (   pReq /* Handle deferred termination request. */
     823            && pReq->enmType == VBOXSERVICECTRLREQUEST_PROC_TERM)
     824        {
     825            rc2 = gstcntlProcessSignalRequest(pReq,
     826                                              fProcessAlive ? VINF_SUCCESS : VERR_PROCESS_RUNNING);
     827            pReq = NULL;
     828        }
     829        else if (pReq)
     830            AssertMsgFailed(("Unable to handle unknown deferred request (type: %RU32)\n", pReq->enmType));
    789831    }
    790832
    … …  
    861903        if (!(pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_START))
    862904        {
    863             rc2 = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID,
    864                                                  pThread->uPID, uStatus, uFlags,
    865                                                  NULL /* pvData */, 0 /* cbData */);
     905            rc2 = VbglR3GuestCtrlProcCbStatus(pThread->uClientID, pThread->uContextID,
     906                                              pThread->uPID, uStatus, uFlags,
     907                                              NULL /* pvData */, 0 /* cbData */);
    866908            if (RT_FAILURE(rc2))
    867909                VBoxServiceError("[PID %u]: Error reporting final status to host; rc=%Rrc\n",
    … …  
    10501092 *                              should service.
    10511093 */
    1052 static int gstcntlProcessSetupPipe(const char *pszHowTo, int fd,
    1053                                    PRTHANDLE ph, PRTHANDLE *pph, PRTPIPE phPipe)
     1094int GstcntlProcessSetupPipe(const char *pszHowTo, int fd,
     1095                            PRTHANDLE ph, PRTHANDLE *pph, PRTPIPE phPipe)
    10541096{
    10551097    AssertPtrReturn(ph, VERR_INVALID_POINTER);
    … …  
    14861528            RTHANDLE    hStdIn;
    14871529            PRTHANDLE   phStdIn;
    1488             rc = gstcntlProcessSetupPipe("|", 0 /*STDIN_FILENO*/,
     1530            rc = GstcntlProcessSetupPipe("|", 0 /*STDIN_FILENO*/,
    14891531                                         &hStdIn, &phStdIn, &pThread->pipeStdInW);
    14901532            if (RT_SUCCESS(rc))
    … …  
    14931535                PRTHANDLE   phStdOut;
    14941536                RTPIPE      pipeStdOutR;
    1495                 rc = gstcntlProcessSetupPipe(  (pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDOUT)
     1537                rc = GstcntlProcessSetupPipe(  (pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDOUT)
    14961538                                             ? "|" : "/dev/null",
    14971539                                             1 /*STDOUT_FILENO*/,
    … …  
    15021544                    PRTHANDLE   phStdErr;
    15031545                    RTPIPE      pipeStdErrR;
    1504                     rc = gstcntlProcessSetupPipe(  (pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDERR)
     1546                    rc = GstcntlProcessSetupPipe(  (pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDERR)
    15051547                                                 ? "|" : "/dev/null",
    15061548                                                 2 /*STDERR_FILENO*/,
    … …  
    16271669        if (RT_FAILURE(rc))
    16281670        {
    1629             rc2 = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID, pThread->uPID,
    1630                                                   PROC_STS_ERROR, rc,
    1631                                                   NULL /* pvData */, 0 /* cbData */);
     1671            rc2 = VbglR3GuestCtrlProcCbStatus(pThread->uClientID, pThread->uContextID, pThread->uPID,
     1672                                              PROC_STS_ERROR, rc,
     1673                                              NULL /* pvData */, 0 /* cbData */);
    16321674            if (RT_FAILURE(rc2))
    16331675                VBoxServiceError("Could not report process failure error; rc=%Rrc (process error %Rrc)\n",
    … …  
    16351677        }
    16361678
    1637         VBoxServiceVerbose(3, "[PID %u]: Cancelling pending host requests (client ID=%u)\n",
    1638                            pThread->uPID, pThread->uClientID);
    1639         rc2 = VbglR3GuestCtrlCancelPendingWaits(pThread->uClientID);
    1640         if (RT_FAILURE(rc2))
    1641         {
    1642             VBoxServiceError("[PID %u]: Cancelling pending host requests failed; rc=%Rrc\n",
    1643                              pThread->uPID, rc2);
    1644             if (RT_SUCCESS(rc))
    1645                 rc = rc2;
    1646         }
    1647 
    1648         /* Disconnect from guest control service. */
     1679        /* Disconnect this client from the guest control service. This also cancels all
     1680         * outstanding host requests. */
    16491681        VBoxServiceVerbose(3, "[PID %u]: Disconnecting (client ID=%u) ...\n",
    16501682                           pThread->uPID, pThread->uClientID);

  • trunk/src/VBox/Additions/common/VBoxService/VBoxServiceInternal.h

    r44528 r44863  
    108108#endif /* RT_OS_WINDOWS */
    109109
    110 #ifdef VBOX_WITH_GUEST_CONTROL
    111 /**
    112  * Pipe IDs for handling the guest process poll set.
    113  */
    114 typedef enum VBOXSERVICECTRLPIPEID
    115 {
    116     VBOXSERVICECTRLPIPEID_UNKNOWN           = 0,
    117     VBOXSERVICECTRLPIPEID_STDIN             = 10,
    118     VBOXSERVICECTRLPIPEID_STDIN_WRITABLE    = 11,
    119     /** Pipe for reading from guest process' stdout. */
    120     VBOXSERVICECTRLPIPEID_STDOUT            = 40,
    121     /** Pipe for reading from guest process' stderr. */
    122     VBOXSERVICECTRLPIPEID_STDERR            = 50,
    123     /** Notification pipe for waking up the guest process
    124      *  control thread. */
    125     VBOXSERVICECTRLPIPEID_IPC_NOTIFY        = 100
    126 } VBOXSERVICECTRLPIPEID;
    127 
    128 /**
    129  * Request types to perform on a started guest process.
    130  */
    131 typedef enum VBOXSERVICECTRLREQUESTTYPE
    132 {
    133     /** Unknown request. */
    134     VBOXSERVICECTRLREQUEST_UNKNOWN          = 0,
    135     /** Main control thread asked used to quit. */
    136     VBOXSERVICECTRLREQUEST_QUIT             = 1,
    137     /** Performs reading from stdout. */
    138     VBOXSERVICECTRLREQUEST_STDOUT_READ      = 50,
    139     /** Performs reading from stderr. */
    140     VBOXSERVICECTRLREQUEST_STDERR_READ      = 60,
    141     /** Performs writing to stdin. */
    142     VBOXSERVICECTRLREQUEST_STDIN_WRITE      = 70,
    143     /** Same as VBOXSERVICECTRLREQUEST_STDIN_WRITE, but
    144      *  marks the end of input. */
    145     VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF  = 71,
    146     /** Kill/terminate process.
    147      *  @todo Implement this! */
    148     VBOXSERVICECTRLREQUEST_KILL             = 90,
    149     /** Gently ask process to terminate.
    150      *  @todo Implement this! */
    151     VBOXSERVICECTRLREQUEST_HANGUP           = 91,
    152     /** Ask the process in which status it
    153      *  currently is.
    154      *  @todo Implement this! */
    155     VBOXSERVICECTRLREQUEST_STATUS           = 100
    156 } VBOXSERVICECTRLREQUESTTYPE;
    157 
    158 /**
    159  * Thread list types.
    160  */
    161 typedef enum VBOXSERVICECTRLTHREADLISTTYPE
    162 {
    163     /** Unknown list -- uncool to use. */
    164     VBOXSERVICECTRLTHREADLIST_UNKNOWN       = 0,
    165     /** Stopped list: Here all guest threads end up
    166      *  when they reached the stopped state and can
    167      *  be shut down / free'd safely. */
    168     VBOXSERVICECTRLTHREADLIST_STOPPED       = 1,
    169     /**
    170      * Started list: Here all threads are registered
    171      * when they're up and running (that is, accepting
    172      * commands).
    173      */
    174     VBOXSERVICECTRLTHREADLIST_RUNNING       = 2
    175 } VBOXSERVICECTRLTHREADLISTTYPE;
    176 
    177 /**
    178  * Structure to perform a request on a started guest
    179  * process. Needed for letting the main guest control thread
    180  * to communicate (and wait) for a certain operation which
    181  * will be done in context of the started guest process thread.
    182  */
    183 typedef struct VBOXSERVICECTRLREQUEST
    184 {
    185     /** Event semaphore to serialize access. */
    186     RTSEMEVENTMULTI            Event;
    187     /** The request type to handle. */
    188     VBOXSERVICECTRLREQUESTTYPE enmType;
    189     /** Payload size; on input, this contains the (maximum) amount
    190      *  of data the caller  wants to write or to read. On output,
    191      *  this show the actual amount of data read/written. */
    192     size_t                     cbData;
    193     /** Payload data; a pre-allocated data buffer for input/output. */
    194     void                      *pvData;
    195     /** The context ID which is required to complete the
    196      *  request. Not used at the moment. */
    197     uint32_t                   uCID;
    198     /** The overall result of the operation. */
    199     int                        rc;
    200 } VBOXSERVICECTRLREQUEST;
    201 /** Pointer to request. */
    202 typedef VBOXSERVICECTRLREQUEST *PVBOXSERVICECTRLREQUEST;
    203 
    204 /**
    205  * Structure holding information for starting a guest
    206  * process.
    207  */
    208 typedef struct VBOXSERVICECTRLPROCESS
    209 {
    210     /** Full qualified path of process to start (without arguments). */
    211     char szCmd[GUESTPROCESS_MAX_CMD_LEN];
    212     /** Process execution flags. @sa */
    213     uint32_t uFlags;
    214     /** Command line arguments. */
    215     char szArgs[GUESTPROCESS_MAX_ARGS_LEN];
    216     /** Number of arguments specified in pszArgs. */
    217     uint32_t uNumArgs;
    218     /** String of environment variables ("FOO=BAR") to pass to the process
    219       * to start. */
    220     char szEnv[GUESTPROCESS_MAX_ENV_LEN];
    221     /** Size (in bytes) of environment variables block. */
    222     uint32_t cbEnv;
    223     /** Number of environment variables specified in pszEnv. */
    224     uint32_t uNumEnvVars;
    225     /** User name (account) to start the process under. */
    226     char szUser[GUESTPROCESS_MAX_USER_LEN];
    227     /** Password of specified user name (account). */
    228     char szPassword[GUESTPROCESS_MAX_PASSWORD_LEN];
    229     /** Time limit (in ms) of the process' life time. */
    230     uint32_t uTimeLimitMS;
    231 } VBOXSERVICECTRLPROCESS;
    232 /** Pointer to a guest process block. */
    233 typedef VBOXSERVICECTRLPROCESS *PVBOXSERVICECTRLPROCESS;
    234 
    235 /**
    236  * Structure for holding data for one (started) guest process.
    237  */
    238 typedef struct VBOXSERVICECTRLTHREAD
    239 {
    240     /** Pointer to list archor of following
    241      *  list node.
    242      *  @todo Would be nice to have a RTListGetAnchor(). */
    243     PRTLISTANCHOR                   pAnchor;
    244     /** Node. */
    245     RTLISTNODE                      Node;
    246     /** The worker thread. */
    247     RTTHREAD                        Thread;
    248     /** Shutdown indicator; will be set when the thread
    249       * needs (or is asked) to shutdown. */
    250     bool volatile                   fShutdown;
    251     /** Indicator set by the service thread exiting. */
    252     bool volatile                   fStopped;
    253     /** Whether the service was started or not. */
    254     bool                            fStarted;
    255     /** Client ID. */
    256     uint32_t                        uClientID;
    257     /** Context ID. */
    258     uint32_t                        uContextID;
    259     /** Critical section for thread-safe use. */
    260     RTCRITSECT                      CritSect;
    261     /** @todo Document me! */
    262     uint32_t                        uPID;
    263     char                           *pszCmd;
    264     uint32_t                        uFlags;
    265     char                          **papszArgs;
    266     uint32_t                        uNumArgs;
    267     char                          **papszEnv;
    268     uint32_t                        uNumEnvVars;
    269     /** Name of specified user account to run the
    270      *  guest process under. */
    271     char                           *pszUser;
    272     /** Password of specified user account. */
    273     char                           *pszPassword;
    274     /** Overall time limit (in ms) that the guest process
    275      *  is allowed to run. 0 for indefinite time. */
    276     uint32_t                        uTimeLimitMS;
    277     /** Pointer to the current IPC request being
    278      *  processed. */
    279     PVBOXSERVICECTRLREQUEST         pRequest;
    280     /** StdIn pipe for addressing writes to the
    281      *  guest process' stdin.*/
    282     RTPIPE                          pipeStdInW;
    283     /** The notification pipe associated with this guest process.
    284      *  This is NIL_RTPIPE for output pipes. */
    285     RTPIPE                          hNotificationPipeW;
    286     /** The other end of hNotificationPipeW. */
    287     RTPIPE                          hNotificationPipeR;
    288 } VBOXSERVICECTRLTHREAD;
    289 /** Pointer to thread data. */
    290 typedef VBOXSERVICECTRLTHREAD *PVBOXSERVICECTRLTHREAD;
    291 
    292 /**
    293  * Structure for one (opened) guest file.
    294  */
    295 typedef struct VBOXSERVICECTRLFILE
    296 {
    297     /** Pointer to list archor of following
    298      *  list node.
    299      *  @todo Would be nice to have a RTListGetAnchor(). */
    300     PRTLISTANCHOR                   pAnchor;
    301     /** Node. */
    302     RTLISTNODE                      Node;
    303     /** The file name. */
    304     char                            szName[RTPATH_MAX];
    305     /** The file handle on the guest. */
    306     RTFILE                          hFile;
    307     /** File handle to identify this file. */
    308     uint32_t                        uHandle;
    309     /** Context ID. */
    310     uint32_t                        uContextID;
    311 } VBOXSERVICECTRLFILE;
    312 /** Pointer to thread data. */
    313 typedef VBOXSERVICECTRLFILE *PVBOXSERVICECTRLFILE;
    314 #endif /* VBOX_WITH_GUEST_CONTROL */
    315110#ifdef VBOX_WITH_GUEST_PROPS
    316 
    317111/**
    318112 * A guest property cache.
    … …  
    359153extern char        *g_pszProgName;
    360154extern int          g_cVerbosity;
     155extern char         g_szLogFile[RTPATH_MAX + 128];
    361156extern uint32_t     g_DefaultInterval;
    362157extern VBOXSERVICE  g_TimeSync;
    … …  
    406201#endif /* RT_OS_WINDOWS */
    407202
    408 #ifdef VBOX_WITH_GUEST_CONTROL
    409 /* Guest control main thread functions. */
    410 extern int                      GstCntlAssignPID(PVBOXSERVICECTRLTHREAD pThread, uint32_t uPID);
    411 extern int                      GstCntlListSet(VBOXSERVICECTRLTHREADLISTTYPE enmList,
    412                                                           PVBOXSERVICECTRLTHREAD pThread);
    413 extern PVBOXSERVICECTRLTHREAD   GstCntlLockThread(uint32_t uPID);
    414 extern void                     GstCntlUnlockThread(const PVBOXSERVICECTRLTHREAD pThread);
    415 extern int                      GstCntlSetInactive(PVBOXSERVICECTRLTHREAD pThread);
    416 /* Per-thread guest process functions. */
    417 extern int                      GstCntlProcessStart(uint32_t uContext,
    418                                                               PVBOXSERVICECTRLPROCESS pProcess);
    419 extern int                      GstCntlProcessPerform(uint32_t uPID, PVBOXSERVICECTRLREQUEST pRequest);
    420 extern int                      GstCntlProcessStop(const PVBOXSERVICECTRLTHREAD pThread);
    421 extern int                      GstCntlProcessWait(const PVBOXSERVICECTRLTHREAD pThread,
    422                                                    RTMSINTERVAL msTimeout, int *prc);
    423 extern int                      GstCntlProcessFree(PVBOXSERVICECTRLTHREAD pThread);
    424 /* Request handling. */
    425 extern int                      GstCntlProcessRequestAlloc(PVBOXSERVICECTRLREQUEST   *ppReq,
    426                                                            VBOXSERVICECTRLREQUESTTYPE enmType);
    427 extern int                      GstCntlProcessRequestAllocEx(PVBOXSERVICECTRLREQUEST    *ppReq,
    428                                                              VBOXSERVICECTRLREQUESTTYPE  enmType,
    429                                                              void                       *pvData,
    430                                                              size_t                      cbData,
    431                                                              uint32_t                    uCID);
    432 extern void                     GstCntlProcessRequestFree(PVBOXSERVICECTRLREQUEST pReq);
    433 #endif /* VBOX_WITH_GUEST_CONTROL */
    434 
    435203#ifdef VBOXSERVICE_MANAGEMENT
    436204extern uint32_t                 VBoxServiceBalloonQueryPages(uint32_t cbPage);

  • trunk/src/VBox/Additions/common/VBoxService/VBoxServicePageSharing.cpp

    r44528 r44863  
    696696                char const *papszArgs[3];
    697697                papszArgs[0] = pszExeName;
    698                 papszArgs[1] = "--pagefusionfork";
     698                papszArgs[1] = "pagefusion";
    699699                papszArgs[2] = NULL;
    700700                rc = RTProcCreate(pszExeName, papszArgs, RTENV_DEFAULT, 0 /* normal child */, &hProcess);

  • trunk/src/VBox/Additions/common/VBoxService/VBoxServiceToolBox.cpp

    r43877 r44863  
    15261526
    15271527    while (   (ch = RTGetOpt(&GetState, &ValueUnion))
    1528               && RT_SUCCESS(rc))
     1528           && RT_SUCCESS(rc))
    15291529    {
    15301530        /* For options that require an argument, ValueUnion has received the value. */

  • trunk/src/VBox/HostServices/GuestControl/service.cpp

    r44528 r44863  
    5050 * host calls in order the client terminated/crashed (HGCM detects disconnected
    5151 * clients and reports it to this service's callback).
     52 *
     53 * Starting at VBox 4.2 the context ID itself consists of a session ID, an object
     54 * ID (for example a process or file ID) and a count. This is necessary to not break
     55 * compatibility between older hosts and to manage guest session on the host.
    5256 */
    5357
    … …  
    5963
    6064#include <VBox/log.h>
    61 #include <iprt/asm.h> /* For ASMBreakpoint(). */
    6265#include <iprt/assert.h>
    6366#include <iprt/cpp/autores.h>
    … …  
    6568#include <iprt/err.h>
    6669#include <iprt/mem.h>
     70#include <iprt/list.h>
    6771#include <iprt/req.h>
    6872#include <iprt/string.h>
    … …  
    7074#include <iprt/time.h>
    7175
     76#include <map>
    7277#include <memory>  /* for auto_ptr */
    7378#include <string>
    … …  
    7883namespace guestControl {
    7984
     85/** Flag for indicating that the client only is interested in
     86 *  messages for specific contexts. */
     87#define CLIENTSTATE_FLAG_CONTEXTFILTER      RT_BIT(0)
     88
     89/**
     90 * Structure for maintaining a pending (that is, a deferred and not yet completed)
     91 * client command.
     92 */
     93typedef struct ClientConnection
     94{
     95    /** The call handle */
     96    VBOXHGCMCALLHANDLE mHandle;
     97    /** Number of parameters */
     98    uint32_t mNumParms;
     99    /** The call parameters */
     100    VBOXHGCMSVCPARM *mParms;
     101    /** The standard constructor. */
     102    ClientConnection(void) : mHandle(0), mNumParms(0), mParms(NULL) {}
     103} ClientConnection;
     104
     105/**
     106 * Structure for holding a buffered host command which has
     107 * not been processed yet.
     108 */
     109typedef struct HostCommand
     110{
     111    RTLISTNODE Node;
     112
     113    uint32_t AddRef(void)
     114    {
     115        return ++mRefCount;
     116    }
     117
     118    uint32_t Release(void)
     119    {
     120        LogFlowFunc(("Releasing CID=%RU32, refCount=%RU32\n",
     121                     mContextID, mRefCount));
     122
     123        /* Release reference for current command. */
     124        Assert(mRefCount);
     125        if (--mRefCount == 0)
     126            Free();
     127
     128        return mRefCount;
     129    }
     130
     131    /**
     132     * Allocates the command with an HGCM request. Needs to be free'd using Free().
     133     *
     134     * @return  IPRT status code.
     135     * @param   uMsg                    Message type.
     136     * @param   cParms                  Number of parameters of HGCM request.
     137     * @param   paParms                 Array of parameters of HGCM request.
     138     */
     139    int Allocate(uint32_t uMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     140    {
     141        LogFlowFunc(("Allocating uMsg=%RU32, cParms=%RU32, paParms=%p\n",
     142                     uMsg, cParms, paParms));
     143
     144        if (!cParms) /* At least one parameter (context ID) must be present. */
     145            return VERR_INVALID_PARAMETER;
     146
     147        AssertPtrReturn(paParms, VERR_INVALID_POINTER);
     148
     149        /* Paranoia. */
     150        if (cParms > 256)
     151            cParms = 256;
     152
     153        int rc = VINF_SUCCESS;
     154
     155        /*
     156         * Don't verify anything here (yet), because this function only buffers
     157         * the HGCM data into an internal structure and reaches it back to the guest (client)
     158         * in an unmodified state.
     159         */
     160        mMsgType = uMsg;
     161        mParmCount = cParms;
     162        if (mParmCount)
     163        {
     164            mpParms = (VBOXHGCMSVCPARM*)RTMemAllocZ(sizeof(VBOXHGCMSVCPARM) * mParmCount);
     165            if (NULL == mpParms)
     166                rc = VERR_NO_MEMORY;
     167        }
     168
     169        if (RT_SUCCESS(rc))
     170        {
     171            for (uint32_t i = 0; i < mParmCount; i++)
     172            {
     173                mpParms[i].type = paParms[i].type;
     174                switch (paParms[i].type)
     175                {
     176                    case VBOX_HGCM_SVC_PARM_32BIT:
     177                        mpParms[i].u.uint32 = paParms[i].u.uint32;
     178                        break;
     179
     180                    case VBOX_HGCM_SVC_PARM_64BIT:
     181                        /* Not supported yet. */
     182                        break;
     183
     184                    case VBOX_HGCM_SVC_PARM_PTR:
     185                        mpParms[i].u.pointer.size = paParms[i].u.pointer.size;
     186                        if (mpParms[i].u.pointer.size > 0)
     187                        {
     188                            mpParms[i].u.pointer.addr = RTMemAlloc(mpParms[i].u.pointer.size);
     189                            if (NULL == mpParms[i].u.pointer.addr)
     190                            {
     191                                rc = VERR_NO_MEMORY;
     192                                break;
     193                            }
     194                            else
     195                                memcpy(mpParms[i].u.pointer.addr,
     196                                       paParms[i].u.pointer.addr,
     197                                       mpParms[i].u.pointer.size);
     198                        }
     199                        else
     200                        {
     201                            /* Size is 0 -- make sure we don't have any pointer. */
     202                            mpParms[i].u.pointer.addr = NULL;
     203                        }
     204                        break;
     205
     206                    default:
     207                        break;
     208                }
     209                if (RT_FAILURE(rc))
     210                    break;
     211            }
     212        }
     213
     214        if (RT_SUCCESS(rc))
     215        {
     216            /*
     217             * Assume that the context ID *always* is the first parameter,
     218             * assign the context ID to the command.
     219             */
     220            rc = mpParms[0].getUInt32(&mContextID);
     221        }
     222
     223        LogFlowFunc(("Returned with rc=%Rrc\n", rc));
     224        return rc;
     225    }
     226
     227    /**
     228     * Frees the buffered HGCM request.
     229     *
     230     * @return  IPRT status code.
     231     */
     232    void Free(void)
     233    {
     234        AssertMsg(mRefCount == 0, ("Command still being used by a client (%RU32 refs), cannot free yet\n",
     235                                   mRefCount));
     236
     237        LogFlowFunc(("Freeing host command CID=%RU32, mMsgType=%RU32, mParmCount=%RU32, mpParms=%p\n",
     238                     mContextID, mMsgType, mParmCount, mpParms));
     239
     240        for (uint32_t i = 0; i < mParmCount; i++)
     241        {
     242            switch (mpParms[i].type)
     243            {
     244                case VBOX_HGCM_SVC_PARM_PTR:
     245                    if (mpParms[i].u.pointer.size > 0)
     246                        RTMemFree(mpParms[i].u.pointer.addr);
     247                    break;
     248            }
     249        }
     250
     251        if (mpParms)
     252            RTMemFree(mpParms);
     253
     254        mParmCount = 0;
     255    }
     256
     257    /**
     258     * Copies data from the buffered HGCM request to the current HGCM request.
     259     *
     260     * @return  IPRT status code.
     261     * @param   paDstParms              Array of parameters of HGCM request to fill the data into.
     262     * @param   cPDstarms               Number of parameters the HGCM request can handle.
     263     * @param   pSrcBuf                 Parameter buffer to assign.
     264     */
     265    int CopyTo(VBOXHGCMSVCPARM paDstParms[], uint32_t cDstParms) const
     266    {
     267        int rc = VINF_SUCCESS;
     268        if (cDstParms != mParmCount)
     269        {
     270            LogFlowFunc(("Parameter count does not match (got %RU32, expected %RU32)\n",
     271                         cDstParms, mParmCount));
     272            rc = VERR_INVALID_PARAMETER;
     273        }
     274        else
     275        {
     276            for (uint32_t i = 0; i < mParmCount; i++)
     277            {
     278                if (paDstParms[i].type != mpParms[i].type)
     279                {
     280                    LogFlowFunc(("Parameter %RU32 type mismatch (got %RU32, expected %RU32)\n",
     281                                 i, paDstParms[i].type, mpParms[i].type));
     282                    rc = VERR_INVALID_PARAMETER;
     283                }
     284                else
     285                {
     286                    switch (mpParms[i].type)
     287                    {
     288                        case VBOX_HGCM_SVC_PARM_32BIT:
     289                            paDstParms[i].u.uint32 = mpParms[i].u.uint32;
     290                            break;
     291
     292                        case VBOX_HGCM_SVC_PARM_PTR:
     293                        {
     294                            if (!mpParms[i].u.pointer.size)
     295                                continue; /* Only copy buffer if there actually is something to copy. */
     296
     297                            if (!paDstParms[i].u.pointer.addr)
     298                                rc = VERR_INVALID_PARAMETER;
     299
     300                            if (paDstParms[i].u.pointer.size < mpParms[i].u.pointer.size)
     301                                rc = VERR_BUFFER_OVERFLOW;
     302
     303                            if (RT_SUCCESS(rc))
     304                            {
     305                                memcpy(paDstParms[i].u.pointer.addr,
     306                                       mpParms[i].u.pointer.addr,
     307                                       mpParms[i].u.pointer.size);
     308                            }
     309
     310                            break;
     311                        }
     312
     313                        case VBOX_HGCM_SVC_PARM_64BIT:
     314                            /* Fall through is intentional. */
     315                        default:
     316                            LogFlowFunc(("Parameter %RU32 of type %RU32 is not supported yet\n",
     317                                         i, mpParms[i].type));
     318                            rc = VERR_NOT_SUPPORTED;
     319                            break;
     320                    }
     321                }
     322
     323                if (RT_FAILURE(rc))
     324                {
     325                    LogFlowFunc(("Parameter %RU32 invalid (rc=%Rrc), refusing\n",
     326                                 i, rc));
     327                    break;
     328                }
     329            }
     330        }
     331
     332        return rc;
     333    }
     334
     335    int AssignToConnection(const ClientConnection *pConnection)
     336    {
     337        int rc;
     338
     339        LogFlowFunc(("mMsgType=%RU32, mParmCount=%RU32, mpParms=%p\n",
     340                     mMsgType, mParmCount, mpParms));
     341
     342        /* Does the current host command need more parameter space which
     343         * the client does not provide yet? */
     344        if (mParmCount > pConnection->mNumParms)
     345        {
     346            pConnection->mParms[0].setUInt32(mMsgType);   /* Message ID */
     347            pConnection->mParms[1].setUInt32(mParmCount); /* Required parameters for message */
     348
     349            /*
     350            * So this call apparently failed because the guest wanted to peek
     351            * how much parameters it has to supply in order to successfully retrieve
     352            * this command. Let's tell him so!
     353            */
     354            rc = VERR_TOO_MUCH_DATA;
     355        }
     356        else
     357        {
     358            rc = CopyTo(pConnection->mParms, pConnection->mNumParms);
     359
     360            /* Has there been enough parameter space but the wrong parameter types
     361             * were submitted -- maybe the client was just asking for the next upcoming
     362             * host message?
     363             *
     364             * Note: To keep this compatible to older clients we return VERR_TOO_MUCH_DATA
     365             *       in every case. */
     366            if (RT_FAILURE(rc))
     367                rc = VERR_TOO_MUCH_DATA;
     368        }
     369
     370        LogFlowFunc(("Returned with rc=%Rrc\n", rc));
     371        return rc;
     372    }
     373
     374    /** Reference count for keeping track how many connected
     375     *  clients still need to process this command until it can
     376     *  be removed. */
     377    uint32_t mRefCount;
     378    /** The context ID this command belongs to. Will be extracted
     379     *  *always* from HGCM parameter [0]. */
     380    uint32_t mContextID;
     381    /** Dynamic structure for holding the HGCM parms */
     382    uint32_t mMsgType;
     383    uint32_t mParmCount;
     384    PVBOXHGCMSVCPARM mpParms;
     385} HostCommand;
     386
     387/**
     388 * Per-client structure used for book keeping/state tracking a
     389 * certain host command.
     390 */
     391typedef struct ClientContext
     392{
     393    /* Pointer to list node of this command. */
     394    HostCommand *mpHostCmd;
     395    /** The standard constructor. */
     396    ClientContext(void) : mpHostCmd(NULL) {}
     397    /** Internal constrcutor. */
     398    ClientContext(HostCommand *pHostCmd) : mpHostCmd(pHostCmd) {}
     399} ClientContext;
     400typedef std::map< uint32_t, ClientContext > ClientContextMap;
     401typedef std::map< uint32_t, ClientContext >::iterator ClientContextMapIter;
     402typedef std::map< uint32_t, ClientContext >::const_iterator ClientContextMapIterConst;
     403
    80404/**
    81405 * Structure for holding all clients with their
    82406 * generated host contexts. This is necessary for
    83  * maintaining the relationship between a client and its context IDs.
    84  */
    85 struct ClientContexts
    86 {
    87     /** This client ID. */
    88     uint32_t mClientID;
    89     /** The list of contexts a client is assigned to. */
    90     std::list< uint32_t > mContextList;
    91 
    92     /** The normal constructor. */
    93     ClientContexts(uint32_t aClientID)
    94                    : mClientID(aClientID) {}
    95 };
    96 /** The client list + iterator type */
    97 typedef std::list< ClientContexts > ClientContextsList;
    98 typedef std::list< ClientContexts >::iterator ClientContextsListIter;
    99 typedef std::list< ClientContexts >::const_iterator ClientContextsListIterConst;
    100 
    101 /**
    102  * Structure for holding an uncompleted guest call.
    103  */
    104 struct ClientWaiter
    105 {
    106     /** Client ID; a client can have multiple handles! */
    107     uint32_t mClientID;
    108     /** The call handle */
    109     VBOXHGCMCALLHANDLE mHandle;
    110     /** The call parameters */
    111     VBOXHGCMSVCPARM *mParms;
    112     /** Number of parameters */
    113     uint32_t mNumParms;
    114 
    115     /** The standard constructor. */
    116     ClientWaiter() : mClientID(0), mHandle(0), mParms(NULL), mNumParms(0) {}
    117     /** The normal constructor. */
    118     ClientWaiter(uint32_t aClientID, VBOXHGCMCALLHANDLE aHandle,
    119               VBOXHGCMSVCPARM aParms[], uint32_t cParms)
    120               : mClientID(aClientID), mHandle(aHandle), mParms(aParms), mNumParms(cParms) {}
    121 };
    122 /** The guest call list type */
    123 typedef std::list< ClientWaiter > ClientWaiterList;
    124 typedef std::list< ClientWaiter >::iterator CallListIter;
    125 typedef std::list< ClientWaiter >::const_iterator CallListIterConst;
    126 
    127 /**
    128  * Structure for holding a buffered host command.
    129  */
    130 typedef struct VBOXGUESTCTRLHOSTCMD
    131 {
    132     /** The context ID this command belongs to. Will be extracted
    133       * from the HGCM parameters. */
    134     uint32_t mContextID;
     407 * maintaining the relationship between a client and its context ID(s).
     408 */
     409typedef struct ClientState
     410{
     411    ClientState(PVBOXHGCMSVCHELPERS pSvcHelpers)
     412        : mSvcHelpers(pSvcHelpers), mpHostCmd(NULL),
     413          mFlags(0), mContextFilter(0), mIsPending(false),
     414          mHostCmdTries(0), mHostCmdRc(VINF_SUCCESS) {}
     415
     416    ClientState(void)
     417        : mSvcHelpers(NULL), mpHostCmd(NULL),
     418          mFlags(0), mContextFilter(0), mIsPending(false),
     419          mHostCmdTries(0), mHostCmdRc(VINF_SUCCESS) {}
     420
     421    bool WantsHostCommand(const HostCommand *pHostCmd) const
     422    {
     423        AssertPtrReturn(pHostCmd, false);
     424
     425        /*
     426         * If a sesseion filter is set, only obey those sessions we're interested in.
     427         */
     428        if (mFlags & CLIENTSTATE_FLAG_CONTEXTFILTER)
     429        {
     430            if (VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pHostCmd->mContextID) == mContextFilter)
     431                return true;
     432        }
     433        else /* Client is interested in all commands. */
     434            return true;
     435
     436        return false;
     437    }
     438
     439    int SetPending(const ClientConnection *pConnection)
     440    {
     441        AssertPtrReturn(pConnection, VERR_INVALID_POINTER);
     442
     443        if (mpHostCmd == NULL)
     444        {
     445            AssertMsg(mIsPending == false,
     446                      ("Client %p already is pending but tried to receive a new host command\n", this));
     447
     448            mPending.mHandle   = pConnection->mHandle;
     449            mPending.mNumParms = pConnection->mNumParms;
     450            mPending.mParms    = pConnection->mParms;
     451
     452            mIsPending = true;
     453
     454            LogFlowFunc(("Client now is in pending mode\n"));
     455
     456            /*
     457             * Signal that we don't and can't return yet.
     458             */
     459            return VINF_HGCM_ASYNC_EXECUTE;
     460        }
     461
     462        /*
     463         * Signal that there already is a connection pending.
     464         * Shouldn't happen in daily usage.
     465         */
     466        AssertMsgFailed(("Client already has a connection pending\n"));
     467        return VERR_SIGNAL_PENDING;
     468    }
     469
     470    int Run(const ClientConnection *pConnection,
     471            const RTLISTANCHOR     *pHostCmdList)
     472    {
     473        int rc = VINF_SUCCESS;
     474
     475        LogFlowFunc(("Client pConnection=%p, pHostCmdList=%p\n",
     476                      pConnection, pHostCmdList));
     477        LogFlowFunc(("Client hostCmd=%p, mHostCmdRc=%Rrc, mHostCmdTries=%RU32\n",
     478                      mpHostCmd, mHostCmdRc, mHostCmdTries));
     479
     480        /* Do we have a current command? */
     481        if (mpHostCmd)
     482        {
     483            bool fRemove = false;
     484            if (RT_FAILURE(mHostCmdRc))
     485            {
     486                mHostCmdTries++;
     487
     488                /*
     489                 * If the client understood the message but supplied too little buffer space
     490                 * don't send this message again and drop it after 3 unsuccessful attempts.
     491                 * The host then should take care of next actions (maybe retry it with a smaller buffer).
     492                 */
     493                if (   mHostCmdRc    == VERR_TOO_MUCH_DATA
     494                    && mHostCmdTries >= 3)
     495                {
     496                    fRemove = true;
     497                }
     498                /* Client did not understand the message or something else weird happened. Try again one
     499                 * more time and drop it if it didn't get handled then. */
     500                else if (mHostCmdTries > 1)
     501                    fRemove = true;
     502            }
     503            else
     504                fRemove = true; /* Everything went fine, remove it. */
     505
     506            LogFlowFunc(("Client tried CID=%RU32 for %RU32 times, (last result=%Rrc, fRemove=%RTbool)\n",
     507                         mpHostCmd->mContextID, mHostCmdTries, mHostCmdRc, fRemove));
     508
     509            if (fRemove)
     510            {
     511                LogFlowFunc(("Client removes itself from command CID=%RU32\n",
     512                              mpHostCmd->mContextID));
     513
     514                /* Remove command from context map. */
     515                mContextMap.erase(mpHostCmd->mContextID);
     516
     517                /* Release reference for current command. */
     518                if (mpHostCmd->Release() == 0)
     519                {
     520                    LogFlowFunc(("Destroying and removing command CID=%RU32 from list\n",
     521                                 mpHostCmd->mContextID));
     522
     523                    /* Last reference removes the command from the list. */
     524                    RTListNodeRemove(&mpHostCmd->Node);
     525
     526                    RTMemFree(mpHostCmd);
     527                    mpHostCmd = NULL;
     528                }
     529
     530                /* Reset everything else. */
     531                mHostCmdRc    = VINF_SUCCESS;
     532                mHostCmdTries = 0;
     533            }
     534        }
     535
     536        /* ... or don't we have one (anymore?) Try getting a new one to process now. */
     537        if (mpHostCmd == NULL)
     538        {
     539            /* Get the next host command the clienet is interested in. */
     540            bool fFoundCmd = false;
     541            HostCommand *pCurCmd;
     542            RTListForEach(pHostCmdList, pCurCmd, HostCommand, Node)
     543            {
     544                fFoundCmd = WantsHostCommand(pCurCmd);
     545                if (fFoundCmd)
     546                {
     547                    mpHostCmd = pCurCmd;
     548                    AssertPtr(mpHostCmd);
     549                    mpHostCmd->AddRef();
     550
     551                    /* Create a command context to keep track of client-specific
     552                     * information about a certain command. */
     553                    Assert(mContextMap.find(mpHostCmd->mContextID) == mContextMap.end());
     554                    mContextMap[mpHostCmd->mContextID] = ClientContext(mpHostCmd);
     555                    /** @todo Exception handling! */
     556
     557                    LogFlowFunc(("Assigning next host comamnd CID=%RU32, cmdType=%RU32, cmdParms=%RU32, new refCount=%RU32\n",
     558                                 mpHostCmd->mContextID, mpHostCmd->mMsgType, mpHostCmd->mParmCount, mpHostCmd->mRefCount));
     559                    break;
     560                }
     561            }
     562
     563            LogFlowFunc(("Client %s new command\n",
     564                         fFoundCmd ? "found" : "did not find a"));
     565
     566            /* If no new command was found, set client into pending state. */
     567            if (!fFoundCmd)
     568                rc = SetPending(pConnection);
     569        }
     570
     571        if (mpHostCmd)
     572        {
     573            AssertPtr(mpHostCmd);
     574            mHostCmdRc = SendReply(pConnection, mpHostCmd);
     575            if (RT_FAILURE(mHostCmdRc))
     576            {
     577                LogFlowFunc(("Processing command CID=%RU32 ended with rc=%Rrc\n",
     578                             mpHostCmd->mContextID, mHostCmdRc));
     579            }
     580
     581            if (RT_SUCCESS(rc))
     582                rc = mHostCmdRc;
     583        }
     584
     585        LogFlowFunc(("Returned with rc=%Rrc\n", rc));
     586        return rc;
     587    }
     588
     589    int RunNow(const ClientConnection *pConnection,
     590               const PRTLISTANCHOR     pHostCmdList)
     591    {
     592        AssertPtrReturn(pConnection, VERR_INVALID_POINTER);
     593        AssertPtrReturn(pHostCmdList, VERR_INVALID_POINTER);
     594
     595        AssertMsgReturn(!mIsPending, ("Can't use another connection when client still is in pending mode\n"),
     596                        VERR_INVALID_PARAMETER);
     597
     598        int rc = Run(pConnection, pHostCmdList);
     599
     600        LogFlowFunc(("Returned with rc=%Rrc\n"));
     601        return rc;
     602    }
     603
     604    int Wakeup(const PRTLISTANCHOR pHostCmdList)
     605    {
     606        AssertMsgReturn(mIsPending, ("Cannot wake up a client which is not in pending mode\n"),
     607                        VERR_INVALID_PARAMETER);
     608
     609        int rc = Run(&mPending, pHostCmdList);
     610
     611        /* Reset pending state. */
     612        mIsPending = false;
     613
     614        LogFlowFunc(("Returned with rc=%Rrc\n"));
     615        return rc;
     616    }
     617
     618    int CancelWaiting(int rcPending)
     619    {
     620        LogFlowFunc(("Cancelling waiting with %Rrc, isPending=%RTbool, pendingNumParms=%RU32, flags=%x\n",
     621                     rcPending, mIsPending, mPending.mNumParms, mFlags));
     622
     623        if (   mIsPending
     624            && mPending.mNumParms >= 2)
     625        {
     626            mPending.mParms[0].setUInt32(HOST_CANCEL_PENDING_WAITS); /* Message ID. */
     627            mPending.mParms[1].setUInt32(0);                         /* Required parameters for message. */
     628
     629            AssertPtr(mSvcHelpers);
     630            mSvcHelpers->pfnCallComplete(mPending.mHandle, rcPending);
     631
     632            mIsPending = false;
     633        }
     634
     635        return VINF_SUCCESS;
     636    }
     637
     638    int SendReply(const ClientConnection *pConnection,
     639                        HostCommand      *pHostCmd)
     640    {
     641        AssertPtrReturn(pConnection, VERR_INVALID_POINTER);
     642        AssertPtrReturn(pHostCmd, VERR_INVALID_POINTER);
     643
     644        /* Try assigning the host command to the client and store the
     645         * result code for later use. */
     646        int rc = pHostCmd->AssignToConnection(pConnection);
     647
     648        /* In any case the client did something, so wake up and remove from list. */
     649        AssertPtr(mSvcHelpers);
     650        mSvcHelpers->pfnCallComplete(pConnection->mHandle, rc);
     651
     652        LogFlowFunc(("pConnection=%p, pHostCmd=%p, rc=%Rrc\n",
     653                     pConnection, pHostCmd, rc));
     654        return rc;
     655    }
     656
     657    PVBOXHGCMSVCHELPERS mSvcHelpers;
     658    /** Client flags. @sa CLIENTSTATE_FLAG_ flags. */
     659    uint32_t mFlags;
     660    /** The context ID filter, based on the flags set. */
     661    uint32_t mContextFilter;
     662    /** Map containing all context IDs a client is assigned to. */
     663    //std::map< uint32_t, ClientContext > mContextMap;
     664    /** Pointer to current host command to process. */
     665    HostCommand *mpHostCmd;
     666    /** Last (most recent) rc after handling the
     667     *  host command. */
     668    int mHostCmdRc;
    135669    /** How many times the host service has tried to deliver this
    136      *  command to the guest. */
    137     uint32_t mTries;
    138     /** Dynamic structure for holding the HGCM parms */
    139     VBOXGUESTCTRPARAMBUFFER mParmBuf;
    140 
    141     /** The standard constructor. */
    142     VBOXGUESTCTRLHOSTCMD() : mContextID(0), mTries(0) {}
    143 };
    144 /** The host cmd list + iterator type */
    145 typedef std::list< VBOXGUESTCTRLHOSTCMD > HostCmdList;
    146 typedef std::list< VBOXGUESTCTRLHOSTCMD >::iterator HostCmdListIter;
    147 typedef std::list< VBOXGUESTCTRLHOSTCMD >::const_iterator HostCmdListIterConst;
     670     *  command to the according client. */
     671    uint32_t mHostCmdTries;
     672    /** Map containing all context IDs a client is assigned to. */
     673    ClientContextMap mContextMap;
     674    /** Flag indicating whether the client currently is pending. */
     675    bool mIsPending;
     676    /** The client's pending connection. */
     677    ClientConnection mPending;
     678} ClientState;
     679typedef std::map< uint32_t, ClientState > ClientStateMap;
     680typedef std::map< uint32_t, ClientState >::iterator ClientStateMapIter;
     681typedef std::map< uint32_t, ClientState >::const_iterator ClientStateMapIterConst;
    148682
    149683/**
    … …  
    152686class Service : public RTCNonCopyable
    153687{
     688
    154689private:
     690
    155691    /** Type definition for use in callback functions. */
    156692    typedef Service SELF;
    157693    /** HGCM helper functions. */
    158694    PVBOXHGCMSVCHELPERS mpHelpers;
    159     /*
     695    /**
    160696     * Callback function supplied by the host for notification of updates
    161697     * to properties.
    … …  
    164700    /** User data pointer to be supplied to the host callback function. */
    165701    void *mpvHostData;
    166     /** The deferred calls list. */
    167     ClientWaiterList mClientWaiterList;
    168     /** The host command list. */
    169     HostCmdList mHostCmds;
    170     /** Client contexts list. */
    171     ClientContextsList mClientContextsList;
    172     /** Number of connected clients. */
    173     uint32_t mNumClients;
     702    /** List containing all buffered host commands. */
     703    RTLISTANCHOR mHostCmdList;
     704    /** Map containing all connected clients. The primary key contains
     705     *  the HGCM client ID to identify the client. */
     706    ClientStateMap mClientStateMap;
    174707public:
    175708    explicit Service(PVBOXHGCMSVCHELPERS pHelpers)
    … …  
    177710        , mpfnHostCallback(NULL)
    178711        , mpvHostData(NULL)
    179         , mNumClients(0)
    180     {
     712    {
     713        RTListInit(&mHostCmdList);
    181714    }
    182715
    … …  
    207740        LogFlowFunc (("pvService=%p, u32ClientID=%u, pvClient=%p\n", pvService, u32ClientID, pvClient));
    208741        SELF *pSelf = reinterpret_cast<SELF *>(pvService);
    209         int rc = pSelf->clientConnect(u32ClientID, pvClient);
    210         LogFlowFunc (("rc=%Rrc\n", rc));
    211         return rc;
     742        return pSelf->clientConnect(u32ClientID, pvClient);
    212743    }
    213744
    … …  
    223754        LogFlowFunc (("pvService=%p, u32ClientID=%u, pvClient=%p\n", pvService, u32ClientID, pvClient));
    224755        SELF *pSelf = reinterpret_cast<SELF *>(pvService);
    225         int rc = pSelf->clientDisconnect(u32ClientID, pvClient);
    226         LogFlowFunc (("rc=%Rrc\n", rc));
    227         return rc;
     756        return pSelf->clientDisconnect(u32ClientID, pvClient);
    228757    }
    229758
    … …  
    241770    {
    242771        AssertLogRelReturnVoid(VALID_PTR(pvService));
    243         LogFlowFunc (("pvService=%p, callHandle=%p, u32ClientID=%u, pvClient=%p, u32Function=%u, cParms=%u, paParms=%p\n", pvService, callHandle, u32ClientID, pvClient, u32Function, cParms, paParms));
     772        LogFlowFunc (("pvService=%p, callHandle=%p, u32ClientID=%u, pvClient=%p, u32Function=%u, cParms=%u, paParms=%p\n",
     773                      pvService, callHandle, u32ClientID, pvClient, u32Function, cParms, paParms));
    244774        SELF *pSelf = reinterpret_cast<SELF *>(pvService);
    245775        pSelf->call(callHandle, u32ClientID, pvClient, u32Function, cParms, paParms);
    246         LogFlowFunc (("returning\n"));
    247776    }
    248777
    … …  
    259788        LogFlowFunc (("pvService=%p, u32Function=%u, cParms=%u, paParms=%p\n", pvService, u32Function, cParms, paParms));
    260789        SELF *pSelf = reinterpret_cast<SELF *>(pvService);
    261         int rc = pSelf->hostCall(u32Function, cParms, paParms);
    262         LogFlowFunc (("rc=%Rrc\n", rc));
    263         return rc;
     790        return pSelf->hostCall(u32Function, cParms, paParms);
    264791    }
    265792
    … …  
    278805        return VINF_SUCCESS;
    279806    }
     807
    280808private:
    281     int paramBufferAllocate(PVBOXGUESTCTRPARAMBUFFER pBuf, uint32_t uMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    282     void paramBufferFree(PVBOXGUESTCTRPARAMBUFFER pBuf);
    283     int paramBufferAssign(VBOXHGCMSVCPARM paDstParms[], uint32_t cDstParms, const VBOXGUESTCTRPARAMBUFFER *pSrcBuf);
     809
    284810    int prepareExecute(uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    285811    int clientConnect(uint32_t u32ClientID, void *pvClient);
    286812    int clientDisconnect(uint32_t u32ClientID, void *pvClient);
    287     int assignHostCmdToGuest(const VBOXGUESTCTRLHOSTCMD *pCmd, VBOXHGCMCALLHANDLE callHandle, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    288     int retrieveNextHostCmd(uint32_t u32ClientID, VBOXHGCMCALLHANDLE callHandle, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     813    int clientGetCommand(uint32_t u32ClientID, VBOXHGCMCALLHANDLE callHandle, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     814    int clientSetMsgFilter(uint32_t u32ClientID, VBOXHGCMCALLHANDLE callHandle, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    289815    int cancelHostCmd(uint32_t u32ContextID);
    290     int cancelPendingWaits(uint32_t u32ClientID);
    291     int notifyHost(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    292     int processHostCmd(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    293     void call(VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID,
    294               void *pvClient, uint32_t eFunction, uint32_t cParms,
    295               VBOXHGCMSVCPARM paParms[]);
     816    int cancelPendingWaits(uint32_t u32ClientID, int rcPending);
     817    int hostCallback(VBOXHGCMCALLHANDLE callHandle, uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     818    int hostProcessCommand(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     819    void call(VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID, void *pvClient, uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    296820    int hostCall(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    297     int uninit();
     821    int uninit(void);
    298822};
    299 
    300 
    301 /**
    302  * Stores a HGCM request in an internal buffer. Needs to be free'd using paramBufferFree().
    303  *
    304  * @return  IPRT status code.
    305  * @param   pBuf                    Buffer to store the HGCM request into.
    306  * @param   uMsg                    Message type.
    307  * @param   cParms                  Number of parameters of HGCM request.
    308  * @param   paParms                 Array of parameters of HGCM request.
    309  */
    310 int Service::paramBufferAllocate(PVBOXGUESTCTRPARAMBUFFER pBuf, uint32_t uMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    311 {
    312     AssertPtrReturn(pBuf, VERR_INVALID_POINTER);
    313     if (cParms)
    314         AssertPtrReturn(paParms, VERR_INVALID_POINTER);
    315 
    316     /* Paranoia. */
    317     if (cParms > 256)
    318         cParms = 256;
    319 
    320     int rc = VINF_SUCCESS;
    321 
    322     /*
    323      * Don't verify anything here (yet), because this function only buffers
    324      * the HGCM data into an internal structure and reaches it back to the guest (client)
    325      * in an unmodified state.
    326      */
    327     pBuf->uMsg = uMsg;
    328     pBuf->uParmCount = cParms;
    329     if (pBuf->uParmCount)
    330     {
    331         pBuf->pParms = (VBOXHGCMSVCPARM*)RTMemAlloc(sizeof(VBOXHGCMSVCPARM) * pBuf->uParmCount);
    332         if (NULL == pBuf->pParms)
    333             rc = VERR_NO_MEMORY;
    334     }
    335 
    336     if (RT_SUCCESS(rc))
    337     {
    338         for (uint32_t i = 0; i < pBuf->uParmCount; i++)
    339         {
    340             pBuf->pParms[i].type = paParms[i].type;
    341             switch (paParms[i].type)
    342             {
    343                 case VBOX_HGCM_SVC_PARM_32BIT:
    344                     pBuf->pParms[i].u.uint32 = paParms[i].u.uint32;
    345                     break;
    346 
    347                 case VBOX_HGCM_SVC_PARM_64BIT:
    348                     /* Not supported yet. */
    349                     break;
    350 
    351                 case VBOX_HGCM_SVC_PARM_PTR:
    352                     pBuf->pParms[i].u.pointer.size = paParms[i].u.pointer.size;
    353                     if (pBuf->pParms[i].u.pointer.size > 0)
    354                     {
    355                         pBuf->pParms[i].u.pointer.addr = RTMemAlloc(pBuf->pParms[i].u.pointer.size);
    356                         if (NULL == pBuf->pParms[i].u.pointer.addr)
    357                         {
    358                             rc = VERR_NO_MEMORY;
    359                             break;
    360                         }
    361                         else
    362                             memcpy(pBuf->pParms[i].u.pointer.addr,
    363                                    paParms[i].u.pointer.addr,
    364                                    pBuf->pParms[i].u.pointer.size);
    365                     }
    366                     else
    367                     {
    368                         /* Size is 0 -- make sure we don't have any pointer. */
    369                         pBuf->pParms[i].u.pointer.addr = NULL;
    370                     }
    371                     break;
    372 
    373                 default:
    374                     break;
    375             }
    376             if (RT_FAILURE(rc))
    377                 break;
    378         }
    379     }
    380     return rc;
    381 }
    382 
    383 /**
    384  * Frees a buffered HGCM request.
    385  *
    386  * @return  IPRT status code.
    387  * @param   pBuf                    Parameter buffer to free.
    388  */
    389 void Service::paramBufferFree(PVBOXGUESTCTRPARAMBUFFER pBuf)
    390 {
    391     AssertPtr(pBuf);
    392     for (uint32_t i = 0; i < pBuf->uParmCount; i++)
    393     {
    394         switch (pBuf->pParms[i].type)
    395         {
    396             case VBOX_HGCM_SVC_PARM_PTR:
    397                 if (pBuf->pParms[i].u.pointer.size > 0)
    398                     RTMemFree(pBuf->pParms[i].u.pointer.addr);
    399                 break;
    400         }
    401     }
    402     if (pBuf->uParmCount)
    403     {
    404         RTMemFree(pBuf->pParms);
    405         pBuf->uParmCount = 0;
    406     }
    407 }
    408 
    409 /**
    410  * Copies data from a buffered HGCM request to the current HGCM request.
    411  *
    412  * @return  IPRT status code.
    413  * @param   paDstParms              Array of parameters of HGCM request to fill the data into.
    414  * @param   cPDstarms               Number of parameters the HGCM request can handle.
    415  * @param   pSrcBuf                 Parameter buffer to assign.
    416  */
    417 int Service::paramBufferAssign(VBOXHGCMSVCPARM paDstParms[], uint32_t cDstParms, const VBOXGUESTCTRPARAMBUFFER *pSrcBuf)
    418 {
    419     AssertPtr(pSrcBuf);
    420     int rc = VINF_SUCCESS;
    421     if (cDstParms != pSrcBuf->uParmCount)
    422     {
    423         LogFlowFunc(("Parameter count does not match (got %u, expected %u)\n",
    424                      cDstParms, pSrcBuf->uParmCount));
    425         rc = VERR_INVALID_PARAMETER;
    426     }
    427     else
    428     {
    429         for (uint32_t i = 0; i < pSrcBuf->uParmCount; i++)
    430         {
    431             if (paDstParms[i].type != pSrcBuf->pParms[i].type)
    432             {
    433                 LogFlowFunc(("Parameter %u type mismatch (got %u, expected %u)\n",
    434                              i, paDstParms[i].type, pSrcBuf->pParms[i].type));
    435                 rc = VERR_INVALID_PARAMETER;
    436             }
    437             else
    438             {
    439                 switch (pSrcBuf->pParms[i].type)
    440                 {
    441                     case VBOX_HGCM_SVC_PARM_32BIT:
    442                         paDstParms[i].u.uint32 = pSrcBuf->pParms[i].u.uint32;
    443                         break;
    444 
    445                     case VBOX_HGCM_SVC_PARM_PTR:
    446                     {
    447                         if (!pSrcBuf->pParms[i].u.pointer.size)
    448                             continue; /* Only copy buffer if there actually is something to copy. */
    449 
    450                         if (!paDstParms[i].u.pointer.addr)
    451                             rc = VERR_INVALID_PARAMETER;
    452 
    453                         if (paDstParms[i].u.pointer.size < pSrcBuf->pParms[i].u.pointer.size)
    454                             rc = VERR_BUFFER_OVERFLOW;
    455 
    456                         if (RT_SUCCESS(rc))
    457                         {
    458                             memcpy(paDstParms[i].u.pointer.addr,
    459                                    pSrcBuf->pParms[i].u.pointer.addr,
    460                                    pSrcBuf->pParms[i].u.pointer.size);
    461                         }
    462 
    463                         break;
    464                     }
    465 
    466                     case VBOX_HGCM_SVC_PARM_64BIT:
    467                         /* Fall through is intentional. */
    468                     default:
    469                         LogFlowFunc(("Parameter %u of type %u is not supported yet\n",
    470                                      i, pSrcBuf->pParms[i].type));
    471                         rc = VERR_NOT_SUPPORTED;
    472                         break;
    473                 }
    474             }
    475 
    476             if (RT_FAILURE(rc))
    477             {
    478                 LogFlowFunc(("Parameter %u invalid (rc=%Rrc), refusing\n",
    479                              i, rc));
    480                 break;
    481             }
    482         }
    483     }
    484     return rc;
    485 }
    486823
    487824/**
    … …  
    494831int Service::clientConnect(uint32_t u32ClientID, void *pvClient)
    495832{
    496     LogFlowFunc(("New client (%ld) connected\n", u32ClientID));
    497     if (mNumClients < UINT32_MAX)
    498         mNumClients++;
    499     else
    500         AssertMsgFailed(("Max. number of clients reached\n"));
     833    LogFlowFunc(("New client with ID=%RU32 connected\n", u32ClientID));
     834#ifdef VBOX_STRICT
     835    ClientStateMapIterConst it = mClientStateMap.find(u32ClientID);
     836    if (it != mClientStateMap.end())
     837    {
     838        AssertMsgFailed(("Client with ID=%RU32 already connected when it should not\n",
     839                         u32ClientID));
     840        return VERR_ALREADY_EXISTS;
     841    }
     842#endif
     843    ClientState cs(mpHelpers);
     844    mClientStateMap[u32ClientID] = cs;
     845    /** @todo Exception handling! */
    501846    return VINF_SUCCESS;
    502847}
    … …  
    513858int Service::clientDisconnect(uint32_t u32ClientID, void *pvClient)
    514859{
    515     LogFlowFunc(("Client (ID=%u, %u clients total) disconnected\n",
    516                  u32ClientID, mNumClients));
    517     Assert(mNumClients > 0);
    518     mNumClients--;
     860    LogFlowFunc(("Client with ID=%RU32 (%zu clients total) disconnected\n",
     861                 u32ClientID, mClientStateMap.size()));
    519862
    520863    /* If this was the last connected (guest) client we need to
    521864     * unblock all eventually queued up (waiting) host calls. */
    522     bool fAllClientsDisconnected = mNumClients == 0;
     865    bool fAllClientsDisconnected = mClientStateMap.size() == 0;
    523866    if (fAllClientsDisconnected)
    524         LogFlowFunc(("No connected clients left, notifying all queued up callbacks\n"));
     867        LogFlowFunc(("No connected clients left, notifying all queued up host callbacks\n"));
    525868
    526869    /*
    … …  
    529872    int rc = VINF_SUCCESS;
    530873
    531     CallListIter itCall = mClientWaiterList.begin();
    532     while (itCall != mClientWaiterList.end())
    533     {
    534         if (itCall->mClientID == u32ClientID)
    535         {
    536             itCall = mClientWaiterList.erase(itCall);
    537         }
    538         else
    539             itCall++;
    540     }
    541 
    542     ClientContextsListIter itContextList = mClientContextsList.begin();
    543     while (   itContextList != mClientContextsList.end()
     874    ClientStateMapIter itClientState = mClientStateMap.begin();
     875    while (   itClientState != mClientStateMap.end()
    544876           && RT_SUCCESS(rc))
    545877    {
    … …  
    549881         * anymore.
    550882         */
    551         if (   itContextList->mClientID == u32ClientID
     883        if (   itClientState->first == u32ClientID
    552884            || fAllClientsDisconnected)
    553885        {
    554             std::list< uint32_t >::iterator itContext = itContextList->mContextList.begin();
    555             while (itContext != itContextList->mContextList.end())
     886            LogFlowFunc(("Cancelling %RU32 context of client ID=%RU32\n",
     887                         itClientState->second.mContextMap.size(), u32ClientID));
     888
     889            ClientContextMapIter itContext = itClientState->second.mContextMap.begin();
     890            while (itContext != itClientState->second.mContextMap.end())
    556891            {
    557                 uint32_t uContextID = (*itContext);
     892                uint32_t uContextID = itContext->first;
    558893
    559894                /*
    … …  
    561896                 * around and need to be cleaned up (canceling waits etc).
    562897                 */
    563                 LogFlowFunc(("Notifying CID=%u of disconnect ...\n", uContextID));
    564                 rc = cancelHostCmd(uContextID);
     898                LogFlowFunc(("Notifying CID=%RU32 of disconnect ...\n", uContextID));
     899                int rc2 = cancelHostCmd(uContextID);
    565900                if (RT_FAILURE(rc))
    566901                {
    567                     LogFlowFunc(("Cancelling of CID=%u failed with rc=%Rrc\n",
    568                                  uContextID, rc));
     902                    LogFlowFunc(("Cancelling assigned client CID=%RU32 failed with rc=%Rrc\n",
     903                                 uContextID, rc2));
    569904                    /* Keep going. */
    570905                }
    571906
     907                AssertPtr(itContext->second.mpHostCmd);
     908                itContext->second.mpHostCmd->Release();
     909
     910                LogFlowFunc(("Released host command CID=%RU32 returned with rc=%Rrc\n",
     911                             uContextID, rc2));
     912
    572913                itContext++;
    573914            }
    574             itContextList = mClientContextsList.erase(itContextList);
     915            itClientState = mClientStateMap.erase(itClientState);
    575916        }
    576917        else
    577             itContextList++;
     918            itClientState++;
    578919    }
    579920
    … …  
    585926         * via a (multi stage) progress object.
    586927         */
    587         HostCmdListIter itHostCmd;
    588         for (itHostCmd = mHostCmds.begin(); itHostCmd != mHostCmds.end(); itHostCmd++)
    589         {
    590             rc = cancelHostCmd(itHostCmd->mContextID);
    591             if (RT_FAILURE(rc))
     928        HostCommand *pCurCmd = RTListGetFirst(&mHostCmdList, HostCommand, Node);
     929        while (pCurCmd)
     930        {
     931            HostCommand *pNext = RTListNodeGetNext(&pCurCmd->Node, HostCommand, Node);
     932            bool fLast = RTListNodeIsLast(&mHostCmdList, &pCurCmd->Node);
     933
     934            int rc2 = cancelHostCmd(pCurCmd->mContextID);
     935            if (RT_FAILURE(rc2))
    592936            {
    593                 LogFlowFunc(("Cancelling of buffered CID=%u failed with rc=%Rrc\n",
    594                              itHostCmd->mContextID, rc));
     937                LogFlowFunc(("Cancelling host command with CID=%u (refCount=%RU32) failed with rc=%Rrc\n",
     938                             pCurCmd->mContextID, pCurCmd->mRefCount, rc2));
    595939                /* Keep going. */
    596940            }
    597941
    598             paramBufferFree(&itHostCmd->mParmBuf);
    599         }
    600 
    601         mHostCmds.clear();
    602     }
    603 
    604     return rc;
    605 }
    606 
    607 /**
    608  * Assigns a specified host command to a client.
    609  *
    610  * @return  IPRT status code.
    611  * @param   pCmd                    Host command to send.
    612  * @param   callHandle              Call handle of the client to send the command to.
    613  * @param   cParms                  Number of parameters.
    614  * @param   paParms                 Array of parameters.
    615  */
    616 int Service::assignHostCmdToGuest(const VBOXGUESTCTRLHOSTCMD *pCmd, VBOXHGCMCALLHANDLE callHandle, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    617 {
    618     AssertPtrReturn(pCmd, VERR_INVALID_POINTER);
    619     int rc;
    620 
    621     /* Does the current host command need more parameter space which
    622      * the client does not provide yet? */
    623     if (pCmd->mParmBuf.uParmCount > cParms)
    624     {
    625         paParms[0].setUInt32(pCmd->mParmBuf.uMsg);       /* Message ID */
    626         paParms[1].setUInt32(pCmd->mParmBuf.uParmCount); /* Required parameters for message */
    627 
    628         /*
    629         * So this call apparently failed because the guest wanted to peek
    630         * how much parameters it has to supply in order to successfully retrieve
    631         * this command. Let's tell him so!
    632         */
    633         rc = VERR_TOO_MUCH_DATA;
    634     }
    635     else
    636     {
    637         rc = paramBufferAssign(paParms, cParms, &pCmd->mParmBuf);
    638 
    639         /* Has there been enough parameter space but the wrong parameter types
    640          * were submitted -- maybe the client was just asking for the next upcoming
    641          * host message?
    642          *
    643          * Note: To keep this compatible to older clients we return VERR_TOO_MUCH_DATA
    644          *       in every case. */
    645         if (RT_FAILURE(rc))
    646             rc = VERR_TOO_MUCH_DATA;
    647     }
    648 
    649     LogFlowFunc(("Returned with rc=%Rrc\n", rc));
     942            pCurCmd->Free();
     943
     944            RTListNodeRemove(&pCurCmd->Node);
     945            RTMemFree(pCurCmd);
     946
     947            if (fLast)
     948                break;
     949
     950            pCurCmd = pNext;
     951        }
     952
     953        Assert(RTListIsEmpty(&mHostCmdList));
     954    }
     955
    650956    return rc;
    651957}
    … …  
    661967 * @param   paParms                     Array of parameters.
    662968 */
    663 int Service::retrieveNextHostCmd(uint32_t u32ClientID, VBOXHGCMCALLHANDLE callHandle,
    664                                  uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    665 {
    666     int rc = VINF_SUCCESS;
    667 
     969int Service::clientGetCommand(uint32_t u32ClientID, VBOXHGCMCALLHANDLE callHandle,
     970                              uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     971{
    668972    /*
    669973     * Lookup client in our list so that we can assign the context ID of
    670974     * a command to that client.
    671975     */
    672     std::list< ClientContexts >::reverse_iterator it = mClientContextsList.rbegin();
    673     while (it != mClientContextsList.rend())
    674     {
    675         if (it->mClientID == u32ClientID)
    676             break;
    677         it++;
    678     }
    679 
    680     /* Not found? Add client to list. */
    681     if (it == mClientContextsList.rend())
    682     {
    683         mClientContextsList.push_back(ClientContexts(u32ClientID));
    684         it = mClientContextsList.rbegin();
    685     }
    686     Assert(it != mClientContextsList.rend());
     976    ClientStateMapIter itClientState = mClientStateMap.find(u32ClientID);
     977    AssertMsg(itClientState != mClientStateMap.end(), ("Client with ID=%RU32 not found when it should be present\n",
     978                                                       u32ClientID));
     979    if (itClientState == mClientStateMap.end())
     980        return VERR_NOT_FOUND; /* Should never happen. */
     981
     982    ClientState &clientState = itClientState->second;
     983
     984    /* Use the current (inbound) connection. */
     985    ClientConnection thisCon;
     986    thisCon.mHandle   = callHandle;
     987    thisCon.mNumParms = cParms;
     988    thisCon.mParms    = paParms;
    687989
    688990    /*
    689991     * If host command list is empty (nothing to do right now) just
    690992     * defer the call until we got something to do (makes the client
    691      * wait, depending on the flags set).
    692      */
    693     if (mHostCmds.empty()) /* If command list is empty, defer ... */
    694     {
    695         mClientWaiterList.push_back(ClientWaiter(u32ClientID, callHandle, paParms, cParms));
    696         rc = VINF_HGCM_ASYNC_EXECUTE;
     993     * wait).
     994     */
     995    int rc;
     996    if (RTListIsEmpty(&mHostCmdList))
     997    {
     998        rc = clientState.SetPending(&thisCon);
    697999    }
    6981000    else
    6991001    {
    700         /*
    701          * Get the next unassigned host command in the list.
    702          */
    703          VBOXGUESTCTRLHOSTCMD &curCmd = mHostCmds.front();
    704          rc = assignHostCmdToGuest(&curCmd, callHandle, cParms, paParms);
    705          if (RT_SUCCESS(rc))
    706          {
    707              /* Remember which client processes which context (for
    708               * later reference & cleanup). */
    709              /// @todo r=bird: check if already in the list.
    710              /// @todo Use a map instead of a list?
    711              it->mContextList.push_back(curCmd.mContextID);
    712 
    713              /* Only if the guest really got and understood the message remove it from the list. */
    714              paramBufferFree(&curCmd.mParmBuf);
    715              mHostCmds.pop_front();
    716          }
    717          else
    718          {
    719              bool fRemoveCmd = false;
    720              uint32_t uTries = curCmd.mTries++;
    721 
    722              /* If the client understood the message but supplied too little buffer space
    723               * don't send this message again and drop it after 3 unsuccessful attempts.
    724               * The host then should take care of next actions (maybe retry it with a smaller buffer). */
    725              if (   rc     == VERR_BUFFER_OVERFLOW
    726                  && uTries >= 3)
    727              {
    728                  fRemoveCmd = true;
    729              }
    730              /* Client did not understand the message or something else weird happened. Try again one
    731               * more time and drop it if it didn't get handled then. */
    732              else if (uTries > 1)
    733                  fRemoveCmd = true;
    734 
    735              if (fRemoveCmd)
    736              {
    737                  paramBufferFree(&curCmd.mParmBuf);
    738                  mHostCmds.pop_front();
    739              }
    740          }
    741     }
     1002        rc = clientState.RunNow(&thisCon, &mHostCmdList);
     1003    }
     1004
     1005    LogFlowFunc(("Returned with rc=%Rrc\n", rc));
    7421006    return rc;
    7431007}
    7441008
    745 /**
    746  * Cancels a buffered host command to unblock waits on Main side
    747  * (via (multi stage) progress objects.
     1009int Service::clientSetMsgFilter(uint32_t u32ClientID, VBOXHGCMCALLHANDLE callHandle,
     1010                                uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     1011{
     1012    /*
     1013     * Lookup client in our list so that we can assign the context ID of
     1014     * a command to that client.
     1015     */
     1016    ClientStateMapIter itClientState = mClientStateMap.find(u32ClientID);
     1017    AssertMsg(itClientState != mClientStateMap.end(), ("Client with ID=%RU32 not found when it should be present\n",
     1018                                                       u32ClientID));
     1019    if (itClientState == mClientStateMap.end())
     1020        return VERR_NOT_FOUND; /* Should never happen. */
     1021
     1022    if (cParms != 2)
     1023        return VERR_INVALID_PARAMETER;
     1024
     1025    uint32_t uMaskAdd;
     1026    int rc = paParms[0].getUInt32(&uMaskAdd);
     1027    if (RT_SUCCESS(rc))
     1028    {
     1029        /* paParms[1] unused yet. */
     1030
     1031        ClientState &clientState = itClientState->second;
     1032
     1033        clientState.mFlags |= CLIENTSTATE_FLAG_CONTEXTFILTER;
     1034        clientState.mContextFilter = uMaskAdd;
     1035
     1036        LogFlowFunc(("Client ID=%RU32 now has filter=%x enabled (flags=%x)\n",
     1037                     u32ClientID, clientState.mContextFilter, clientState.mFlags));
     1038    }
     1039
     1040    LogFlowFunc(("Returned with rc=%Rrc\n", rc));
     1041    return rc;
     1042}
     1043
     1044/**
     1045 * Cancels a buffered host command to unblock waiting on Main side
     1046 * via callbacks.
    7481047 *
    7491048 * @return  IPRT status code.
    … …  
    7561055    LogFlowFunc(("Cancelling CID=%u ...\n", u32ContextID));
    7571056
    758     CALLBACKDATACLIENTDISCONNECTED data;
    759     data.hdr.u32Magic = CALLBACKDATAMAGIC_CLIENT_DISCONNECTED;
    760     data.hdr.u32ContextID = u32ContextID;
     1057    CALLBACKDATA_CLIENT_DISCONNECTED data;
     1058    data.hdr.uContextID = u32ContextID;
    7611059
    7621060    AssertPtr(mpfnHostCallback);
    … …  
    7721070 * @return  IPRT status code.
    7731071 * @param   u32ClientID                 The client's ID.
    774  */
    775 int Service::cancelPendingWaits(uint32_t u32ClientID)
    776 {
    777     int rc = VINF_SUCCESS;
    778     CallListIter it = mClientWaiterList.begin();
    779     while (it != mClientWaiterList.end())
    780     {
    781         if (it->mClientID == u32ClientID)
    782         {
    783             if (it->mNumParms >= 2)
    784             {
    785                 it->mParms[0].setUInt32(HOST_CANCEL_PENDING_WAITS); /* Message ID. */
    786                 it->mParms[1].setUInt32(0);                         /* Required parameters for message. */
    787             }
    788             if (mpHelpers)
    789                 mpHelpers->pfnCallComplete(it->mHandle, rc);
    790             it = mClientWaiterList.erase(it);
    791         }
    792         else
    793             it++;
    794     }
    795     return rc;
     1072 * @param   rcPending                   Result code for completing pending operation.
     1073 */
     1074int Service::cancelPendingWaits(uint32_t u32ClientID, int rcPending)
     1075{
     1076    ClientStateMapIter itClientState = mClientStateMap.find(u32ClientID);
     1077    if (itClientState != mClientStateMap.end())
     1078        return itClientState->second.CancelWaiting(rcPending);
     1079
     1080    return VINF_SUCCESS;
    7961081}
    7971082
    … …  
    8011086 *
    8021087 * @return  IPRT status code.
     1088 * @param   callHandle              Call handle.
    8031089 * @param   eFunction               Function (event) that occured.
    8041090 * @param   cParms                  Number of parameters.
    8051091 * @param   paParms                 Array of parameters.
    8061092 */
    807 int Service::notifyHost(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     1093int Service::hostCallback(VBOXHGCMCALLHANDLE callHandle,
     1094                          uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    8081095{
    8091096    LogFlowFunc(("eFunction=%ld, cParms=%ld, paParms=%p\n",
    8101097                 eFunction, cParms, paParms));
    811     int rc = VINF_SUCCESS;
    812     if (   eFunction == GUEST_EXEC_SEND_STATUS
    813         && cParms    == 5)
    814     {
    815         CALLBACKDATAEXECSTATUS data;
    816         data.hdr.u32Magic = CALLBACKDATAMAGIC_EXEC_STATUS;
    817         paParms[0].getUInt32(&data.hdr.u32ContextID);
    818 
    819         paParms[1].getUInt32(&data.u32PID);
    820         paParms[2].getUInt32(&data.u32Status);
    821         paParms[3].getUInt32(&data.u32Flags);
    822         paParms[4].getPointer(&data.pvData, &data.cbData);
    823 
    824         if (mpfnHostCallback)
    825             rc = mpfnHostCallback(mpvHostData, eFunction,
    826                                   (void *)(&data), sizeof(data));
    827     }
    828     else if (   eFunction == GUEST_EXEC_SEND_OUTPUT
    829              && cParms    == 5)
    830     {
    831         CALLBACKDATAEXECOUT data;
    832         data.hdr.u32Magic = CALLBACKDATAMAGIC_EXEC_OUT;
    833         paParms[0].getUInt32(&data.hdr.u32ContextID);
    834 
    835         paParms[1].getUInt32(&data.u32PID);
    836         paParms[2].getUInt32(&data.u32HandleId);
    837         paParms[3].getUInt32(&data.u32Flags);
    838         paParms[4].getPointer(&data.pvData, &data.cbData);
    839 
    840         if (mpfnHostCallback)
    841             rc = mpfnHostCallback(mpvHostData, eFunction,
    842                                   (void *)(&data), sizeof(data));
    843     }
    844     else if (   eFunction == GUEST_EXEC_SEND_INPUT_STATUS
    845              && cParms    == 5)
    846     {
    847         CALLBACKDATAEXECINSTATUS data;
    848         data.hdr.u32Magic = CALLBACKDATAMAGIC_EXEC_IN_STATUS;
    849         paParms[0].getUInt32(&data.hdr.u32ContextID);
    850 
    851         paParms[1].getUInt32(&data.u32PID);
    852         paParms[2].getUInt32(&data.u32Status);
    853         paParms[3].getUInt32(&data.u32Flags);
    854         paParms[4].getUInt32(&data.cbProcessed);
    855 
    856         if (mpfnHostCallback)
    857             rc = mpfnHostCallback(mpvHostData, eFunction,
    858                                   (void *)(&data), sizeof(data));
     1098
     1099    int rc;
     1100    if (mpfnHostCallback)
     1101    {
     1102        VBOXGUESTCTRLHOSTCALLBACK data(cParms, paParms);
     1103        rc = mpfnHostCallback(mpvHostData, eFunction,
     1104                              (void *)(&data), sizeof(data));
    8591105    }
    8601106    else
    8611107        rc = VERR_NOT_SUPPORTED;
    862     LogFlowFunc(("returning %Rrc\n", rc));
     1108
     1109    LogFlowFunc(("Returning rc=%Rrc\n", rc));
    8631110    return rc;
    8641111}
    … …  
    8731120 * @param   paParms                 Array of parameters.
    8741121 */
    875 int Service::processHostCmd(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     1122int Service::hostProcessCommand(uint32_t eFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    8761123{
    8771124    /*
    … …  
    8811128     * the guest is not running/system is messed up somehow.
    8821129     */
    883     if (mNumClients == 0)
     1130    if (mClientStateMap.size() == 0)
    8841131        return VERR_NOT_FOUND;
    885     VBOXGUESTCTRLHOSTCMD newCmd;
    886     int rc = paramBufferAllocate(&newCmd.mParmBuf, eFunction, cParms, paParms);
    887     if (   RT_SUCCESS(rc)
    888         && cParms) /* Make sure we at least get one parameter (that is, the context ID). */
    889     {
     1132
     1133    int rc;
     1134    HostCommand *pHostCmd = (HostCommand*)RTMemAllocZ(sizeof(HostCommand));
     1135    if (pHostCmd)
     1136    {
     1137        rc = pHostCmd->Allocate(eFunction, cParms, paParms);
     1138        if (RT_SUCCESS(rc))
     1139            RTListAppend(&mHostCmdList, &pHostCmd->Node);
     1140    }
     1141    else
     1142        rc = VERR_NO_MEMORY;
     1143
     1144    if (RT_SUCCESS(rc))
     1145    {
     1146        LogFlowFunc(("Handling host command CID=%RU32, numClients=%zu\n",
     1147                     pHostCmd->mContextID, mClientStateMap.size()));
     1148
    8901149        /*
    891          * Assume that the context ID *always* is the first parameter,
    892          * assign the context ID to the command.
     1150         * Wake up all pending clients which are interested in this
     1151         * host command.
    8931152         */
    894         newCmd.mParmBuf.pParms[0].getUInt32(&newCmd.mContextID);
    895     }
    896     else if (!cParms)
    897         rc = VERR_INVALID_PARAMETER;
    898 
    899     if (RT_SUCCESS(rc))
    900     {
    901         LogFlowFunc(("Handling host command CID = %u\n",
    902                      newCmd.mContextID));
    903 
    904         bool fProcessed = false;
    905 
    906         /* Can we wake up a waiting client on guest? */
    907         if (!mClientWaiterList.empty())
    908         {
    909             ClientWaiter guest = mClientWaiterList.front();
    910             rc = assignHostCmdToGuest(&newCmd,
    911                                       guest.mHandle, guest.mNumParms, guest.mParms);
    912 
    913             /* In any case the client did something, so wake up and remove from list. */
    914             AssertPtr(mpHelpers);
    915             mpHelpers->pfnCallComplete(guest.mHandle, rc);
    916             mClientWaiterList.pop_front();
    917 
    918             /*
    919              * If we got back an error (like VERR_TOO_MUCH_DATA or VERR_BUFFER_OVERFLOW)
    920              * we buffer the host command in the next block and return success to the host.
    921              */
    922             if (RT_FAILURE(rc))
     1153#ifdef DEBUG
     1154        uint32_t uClientsWokenUp = 0;
     1155#endif
     1156
     1157        ClientStateMapIter itClientState = mClientStateMap.begin();
     1158        AssertMsg(itClientState != mClientStateMap.end(), ("Client state map is empty when it should not\n"));
     1159        while (itClientState != mClientStateMap.end())
     1160        {
     1161            if (itClientState->second.mIsPending) /* Only wake up pending clients. */
    9231162            {
    924                 rc = VINF_SUCCESS;
    925             }
    926             else /* If command was understood by the client, free and remove from host commands list. */
    927             {
    928                 LogFlowFunc(("Host command CID = %u processed with rc=%Rrc\n",
    929                              newCmd.mContextID, rc));
    930 
    931                 paramBufferFree(&newCmd.mParmBuf);
    932             }
    933         }
    934 
    935         if (!fProcessed)
    936         {
    937             LogFlowFunc(("Buffering host command CID = %u (rc=%Rrc)\n",
    938                          newCmd.mContextID, rc));
    939 
    940             mHostCmds.push_back(newCmd);
    941         }
     1163                LogFlowFunc(("Waking up client ID=%RU32 (isPending=%RTbool) ...\n",
     1164                             itClientState->first, itClientState->second.mIsPending));
     1165
     1166                ClientState &clientState = itClientState->second;
     1167                int rc2 = clientState.Wakeup(&mHostCmdList);
     1168                LogFlowFunc(("Client ID=%RU32 wakeup ended with rc=%Rrc\n",
     1169                             itClientState->first, rc2));
     1170#ifdef DEBUG
     1171                uClientsWokenUp++;
     1172#endif
     1173            }
     1174            else
     1175                LogFlowFunc(("Client ID=%RU32 is not in pending state\n",
     1176                             itClientState->first));
     1177
     1178            itClientState++;
     1179        }
     1180
     1181#ifdef DEBUG
     1182        LogFlowFunc(("%RU32 clients have been succcessfully woken up\n",
     1183                      uClientsWokenUp));
     1184#endif
    9421185    }
    9431186
    … …  
    9601203{
    9611204    int rc = VINF_SUCCESS;
    962     LogFlowFunc(("u32ClientID = %u, fn = %u, cParms = %u, paParms = 0x%p\n",
     1205    LogFlowFunc(("u32ClientID=%RU32, fn=%RU32, cParms=%RU32, paParms=0x%p\n",
    9631206                 u32ClientID, eFunction, cParms, paParms));
    9641207    try
    9651208    {
    966         switch (eFunction)
    967         {
    968             /*
    969              * The guest asks the host for the next message to process.
    970              */
    971             case GUEST_GET_HOST_MSG:
    972                 LogFlowFunc(("GUEST_GET_HOST_MSG\n"));
    973                 rc = retrieveNextHostCmd(u32ClientID, callHandle, cParms, paParms);
    974                 break;
    975 
    976             /*
    977              * The guest wants to shut down and asks us (this service) to cancel
    978              * all blocking pending waits (VINF_HGCM_ASYNC_EXECUTE) so that the
    979              * guest can gracefully shut down.
    980              */
    981             case GUEST_CANCEL_PENDING_WAITS:
    982                 LogFlowFunc(("GUEST_CANCEL_PENDING_WAITS\n"));
    983                 rc = cancelPendingWaits(u32ClientID);
    984                 break;
    985 
    986             /*
    987              * For all other regular commands we call our notifyHost
    988              * function. If the current command does not support notifications
    989              * notifyHost will return VERR_NOT_SUPPORTED.
    990              */
    991             default:
    992                 rc = notifyHost(eFunction, cParms, paParms);
    993                 break;
    994         }
    995         if (rc != VINF_HGCM_ASYNC_EXECUTE)
    996         {
    997             /* Tell the client that the call is complete (unblocks waiting). */
    998             AssertPtr(mpHelpers);
    999             mpHelpers->pfnCallComplete(callHandle, rc);
     1209        /*
     1210         * The guest asks the host for the next message to process.
     1211         */
     1212        if (eFunction == GUEST_MSG_WAIT)
     1213        {
     1214            LogFlowFunc(("GUEST_MSG_GET\n"));
     1215            rc = clientGetCommand(u32ClientID, callHandle, cParms, paParms);
     1216        }
     1217        else
     1218        {
     1219            switch (eFunction)
     1220            {
     1221                /*
     1222                 * A client wants to shut down and asks us (this service) to cancel
     1223                 * all blocking/pending waits (VINF_HGCM_ASYNC_EXECUTE) so that the
     1224                 * client can gracefully shut down.
     1225                 */
     1226                case GUEST_CANCEL_PENDING_WAITS:
     1227                    LogFlowFunc(("GUEST_CANCEL_PENDING_WAITS\n"));
     1228                    rc = cancelPendingWaits(u32ClientID, VINF_SUCCESS /* Pending result */);
     1229                    break;
     1230
     1231                /*
     1232                 * The guest only wants certain messages set by the filter mask(s).
     1233                 * Since VBox 4.3+.
     1234                 */
     1235                case GUEST_MSG_FILTER:
     1236                    LogFlowFunc(("GUEST_MSG_FILTER\n"));
     1237                    rc = clientSetMsgFilter(u32ClientID, callHandle, cParms, paParms);
     1238                    break;
     1239
     1240                /*
     1241                 * For all other regular commands we call our hostCallback
     1242                 * function. If the current command does not support notifications,
     1243                 * notifyHost will return VERR_NOT_SUPPORTED.
     1244                 */
     1245                default:
     1246                    rc = hostCallback(callHandle, eFunction, cParms, paParms);
     1247                    break;
     1248            }
     1249
     1250            if (rc != VINF_HGCM_ASYNC_EXECUTE)
     1251            {
     1252                /* Tell the client that the call is complete (unblocks waiting). */
     1253                AssertPtr(mpHelpers);
     1254                mpHelpers->pfnCallComplete(callHandle, rc);
     1255            }
    10001256        }
    10011257    }
    … …  
    10041260        rc = VERR_NO_MEMORY;
    10051261    }
    1006     LogFlowFunc(("rc = %Rrc\n", rc));
    10071262}
    10081263
    … …  
    10151270{
    10161271    int rc = VERR_NOT_SUPPORTED;
    1017     LogFlowFunc(("fn = %u, cParms = %u, paParms = 0x%p\n",
     1272    LogFlowFunc(("fn=%RU32, cParms=%RU32, paParms=0x%p\n",
    10181273                 eFunction, cParms, paParms));
    10191274    try
    10201275    {
    1021         rc = processHostCmd(eFunction, cParms, paParms);
     1276        switch (eFunction)
     1277        {
     1278            /**
     1279             * Host
     1280             */
     1281            case HOST_CANCEL_PENDING_WAITS:
     1282            {
     1283                LogFlowFunc(("HOST_CANCEL_PENDING_WAITS\n"));
     1284                ClientStateMapIter itClientState = mClientStateMap.begin();
     1285                while (itClientState != mClientStateMap.end())
     1286                {
     1287                    int rc2 = itClientState->second.CancelWaiting(VINF_SUCCESS /* Pending rc. */);
     1288                    if (RT_FAILURE(rc2))
     1289                        LogFlowFunc(("Cancelling waiting for client ID=%RU32 failed with rc=%Rrc",
     1290                                     itClientState->first, rc2));
     1291                    itClientState++;
     1292                }
     1293                rc = VINF_SUCCESS;
     1294                break;
     1295            }
     1296
     1297            default:
     1298                rc = hostProcessCommand(eFunction, cParms, paParms);
     1299                break;
     1300        }
    10221301    }
    10231302    catch (std::bad_alloc)
    … …  
    10261305    }
    10271306
    1028     LogFlowFunc(("rc = %Rrc\n", rc));
    10291307    return rc;
    10301308}
    … …  
    10321310int Service::uninit()
    10331311{
    1034     Assert(mHostCmds.empty());
     1312    Assert(RTListIsEmpty(&mHostCmdList));
    10351313
    10361314    return VINF_SUCCESS;

  • trunk/src/VBox/HostServices/GuestControl/testcase/tstGuestControlSvc.cpp

    r36873 r44863  
    66
    77/*
    8  * Copyright (C) 2011 Oracle Corporation
     8 * Copyright (C) 2011-2013 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    157157    static CMDHOST s_aCmdHostAll[] =
    158158    {
    159         /** No client connected, invalid command. */
    160         { 1024 /* Not existing command */, 0, 0, false, VERR_NOT_SUPPORTED },
    161         { -1 /* Invalid command */, 0, 0, false, VERR_NOT_SUPPORTED },
     159        #if 0
     160        /** No client connected. */
     161        { 1024 /* Not existing command */, 0, 0, false, VERR_NOT_FOUND },
     162        { -1 /* Invalid command */, 0, 0, false, VERR_NOT_FOUND },
    162163        { HOST_CANCEL_PENDING_WAITS, 1024, 0, false, VERR_NOT_FOUND },
    163164        { HOST_CANCEL_PENDING_WAITS, 0, &s_aParms[0], false, VERR_NOT_FOUND },
    … …  
    166167        { HOST_CANCEL_PENDING_WAITS, 0, 0, false, VERR_NOT_FOUND },
    167168
    168         /** Client connected. */
    169         { 1024 /* Not existing command */, 0, 0, true, VERR_NOT_SUPPORTED },
    170         { -1 /* Invalid command */, 0, 0, true, VERR_NOT_SUPPORTED },
     169        /** Client connected, no parameters given. */
     170        { HOST_EXEC_SET_INPUT, 0 /* No parameters given */, 0, true, VERR_INVALID_PARAMETER },
     171        { 1024 /* Not existing command */, 0 /* No parameters given */, 0, true, VERR_INVALID_PARAMETER },
     172        { -1 /* Invalid command */, 0 /* No parameters given */, 0, true, VERR_INVALID_PARAMETER },
    171173
    172174        /** Client connected, valid parameters given. */
    … …  
    174176        { HOST_CANCEL_PENDING_WAITS, 1024, &s_aParms[0], true, VINF_SUCCESS },
    175177        { HOST_CANCEL_PENDING_WAITS, 0, &s_aParms[0], true, VINF_SUCCESS},
     178        #endif
    176179
    177180        /** Client connected, invalid parameters given. */
    178         { HOST_CANCEL_PENDING_WAITS, 1024, 0, true, VERR_INVALID_POINTER },
    179         { HOST_CANCEL_PENDING_WAITS, 1, 0, true, VERR_INVALID_POINTER },
    180         { HOST_CANCEL_PENDING_WAITS, -1, 0, true, VERR_INVALID_POINTER },
     181        { HOST_EXEC_CMD, 1024, 0, true, VERR_INVALID_POINTER },
     182        { HOST_EXEC_CMD, 1, 0, true, VERR_INVALID_POINTER },
     183        { HOST_EXEC_CMD, -1, 0, true, VERR_INVALID_POINTER },
    181184
    182185        /** Client connected, parameters given. */
    … …  
    184187        { HOST_EXEC_CMD, 1, &s_aParms[0], true, VINF_SUCCESS },
    185188        { HOST_EXEC_SET_INPUT, 1, &s_aParms[0], true, VINF_SUCCESS },
    186         { HOST_EXEC_GET_OUTPUT, 1, &s_aParms[0], true, VINF_SUCCESS }
     189        { HOST_EXEC_GET_OUTPUT, 1, &s_aParms[0], true, VINF_SUCCESS },
     190
     191        /** Client connected, unknown command + valid parameters given. */
     192        { -1, 1, &s_aParms[0], true, VINF_SUCCESS }
    187193    };
    188194
    … …  
    203209        /* No commands from host yet. */
    204210        static VBOXHGCMSVCPARM s_aParmsGuest[8];
     211        s_aParmsGuest[0].setUInt32(0 /* Msg type */);
     212        s_aParmsGuest[1].setUInt32(0 /* Parameters */);
    205213        pTable->pfnCall(pTable->pvService, &callHandle, 1 /* Client ID */, NULL /* pvClient */,
    206                         GUEST_GET_HOST_MSG, 2, &s_aParmsGuest[0]);
     214                        GUEST_MSG_WAIT, 2, &s_aParmsGuest[0]);
    207215        RTTEST_CHECK_RC_RET(g_hTest, callHandle.rc, VINF_SUCCESS, callHandle.rc);
    208216
    … …  
    211219        s_aParmsHost[0].setUInt32(1000 /* Context ID */);
    212220        s_aParmsHost[1].setString("foo.bar");
    213 
    214         rc = pTable->pfnHostCall(pTable->pvService, HOST_EXEC_CMD, 2, &s_aParmsHost[0]);
     221        s_aParmsHost[2].setString("baz");
     222
     223        rc = pTable->pfnHostCall(pTable->pvService, HOST_EXEC_CMD, 3, &s_aParmsHost[0]);
    215224        RTTEST_CHECK_RC_RET(g_hTest, rc, VINF_SUCCESS, rc);
    216 
    217         /* Client: Get host command with a invalid parameter count specified. */
    218         pTable->pfnCall(pTable->pvService, &callHandle, 1 /* Client ID */, NULL /* pvClient */,
    219                         GUEST_GET_HOST_MSG, 1024, &s_aParmsGuest[0]);
    220         RTTEST_CHECK_RC_RET(g_hTest, callHandle.rc, VERR_INVALID_PARAMETER, callHandle.rc);
    221         pTable->pfnCall(pTable->pvService, &callHandle, 1 /* Client ID */, NULL /* pvClient */,
    222                         GUEST_GET_HOST_MSG, -1, &s_aParmsGuest[0]);
    223         RTTEST_CHECK_RC_RET(g_hTest, callHandle.rc, VERR_INVALID_PARAMETER, callHandle.rc);
    224         pTable->pfnCall(pTable->pvService, &callHandle, 1 /* Client ID */, NULL /* pvClient */,
    225                         GUEST_GET_HOST_MSG, -1, NULL);
    226         RTTEST_CHECK_RC_RET(g_hTest, callHandle.rc, VERR_INVALID_PARAMETER, callHandle.rc);
    227         pTable->pfnCall(pTable->pvService, &callHandle, 1 /* Client ID */, NULL /* pvClient */,
    228                         GUEST_GET_HOST_MSG, 16, NULL);
    229         RTTEST_CHECK_RC_RET(g_hTest, callHandle.rc, VERR_INVALID_PARAMETER, callHandle.rc);
    230 
    231         /* Client: Get host command with a too small HGCM array. */
    232         pTable->pfnCall(pTable->pvService, &callHandle, 1 /* Client ID */, NULL /* pvClient */,
    233                         GUEST_GET_HOST_MSG, 0, &s_aParmsGuest[0]);
    234         RTTEST_CHECK_RC_RET(g_hTest, callHandle.rc, VERR_TOO_MUCH_DATA, callHandle.rc);
    235         pTable->pfnCall(pTable->pvService, &callHandle, 1 /* Client ID */, NULL /* pvClient */,
    236                         GUEST_GET_HOST_MSG, 1, &s_aParmsGuest[0]);
    237         RTTEST_CHECK_RC_RET(g_hTest, callHandle.rc, VERR_TOO_MUCH_DATA, callHandle.rc);
    238 
    239         /* Client: Get host command without an allocated buffer. */
    240         pTable->pfnCall(pTable->pvService, &callHandle, 1 /* Client ID */, NULL /* pvClient */,
    241                         GUEST_GET_HOST_MSG, 2, &s_aParmsGuest[0]);
    242         RTTEST_CHECK_RC_RET(g_hTest, callHandle.rc, VERR_BUFFER_OVERFLOW, callHandle.rc);
    243 
    244         /* Client: Get host command, this time with a valid buffer. */
    245         char szBuf[16];
    246         s_aParmsGuest[1].setPointer(szBuf, sizeof(szBuf));
    247         pTable->pfnCall(pTable->pvService, &callHandle, 1 /* Client ID */, NULL /* pvClient */,
    248                         GUEST_GET_HOST_MSG, 2, &s_aParmsGuest[0]);
    249         RTTEST_CHECK_RC_RET(g_hTest, callHandle.rc, VINF_SUCCESS, callHandle.rc);
    250 
    251         /* Client: Now make sure there's no host message left anymore. */
    252         pTable->pfnCall(pTable->pvService, &callHandle, 1 /* Client ID */, NULL /* pvClient */,
    253                         GUEST_GET_HOST_MSG, 2, &s_aParmsGuest[0]);
    254         RTTEST_CHECK_RC_RET(g_hTest, callHandle.rc, VINF_SUCCESS, callHandle.rc);
    255225
    256226        /* Client: Disconnect again. */

  • trunk/src/VBox/Main/include/GuestCtrlImplPrivate.h

    r43162 r44863  
    55
    66/*
    7  * Copyright (C) 2011-2012 Oracle Corporation
     7 * Copyright (C) 2011-2013 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    1919#define ____H_GUESTIMPLPRIVATE
    2020
     21#include "ConsoleImpl.h"
     22
    2123#include <iprt/asm.h>
    2224#include <iprt/semaphore.h>
    … …  
    3739#endif
    3840
    39 /** Maximum number of guest sessions a VM can have. */
    40 #define VBOX_GUESTCTRL_MAX_SESSIONS     32
    41 /** Maximum number of guest objects (processes, files, ...)
    42  *  a guest session can have. */
    43 #define VBOX_GUESTCTRL_MAX_OBJECTS      _2K
    44 /** Maximum of callback contexts a guest process can have. */
    45 #define VBOX_GUESTCTRL_MAX_CONTEXTS     _64K
    46 
    47 /** Builds a context ID out of the session ID, object ID and an
    48  *  increasing count. */
    49 #define VBOX_GUESTCTRL_CONTEXTID_MAKE(uSession, uObject, uCount) \
    50     (  (uint32_t)((uSession) &   0x1f) << 27 \
    51      | (uint32_t)((uObject)  &  0x7ff) << 16 \
    52      | (uint32_t)((uCount)   & 0xffff)       \
    53     )
    54 /** Gets the session ID out of a context ID. */
    55 #define VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(uContextID) \
    56     ((uContextID) >> 27)
    57 /** Gets the process ID out of a context ID. */
    58 #define VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(uContextID) \
    59     (((uContextID) >> 16) & 0x7ff)
    60 /** Gets the conext count of a process out of a context ID. */
    61 #define VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID) \
    62     ((uContextID) & 0xffff)
    63 
    6441/** Vector holding a process' CPU affinity. */
    6542typedef std::vector <LONG> ProcessAffinity;
    … …  
    6845
    6946class GuestProcessStreamBlock;
     47class GuestSession;
    7048
    7149
    … …  
    11694
    11795/*
     96 * Enumeration holding the host callback types.
     97 */
     98enum CALLBACKTYPE
     99{
     100    CALLBACKTYPE_UNKNOWN = 0,
     101    /** Guest session status. */
     102    CALLBACKTYPE_SESSION_NOTIFY = 10,
     103    /** Guest process status. */
     104    CALLBACKTYPE_PROC_STATUS = 100,
     105    /** Guest process output notification. */
     106    CALLBACKTYPE_PROC_OUTPUT = 105,
     107    /** Guest process input notification. */
     108    CALLBACKTYPE_PROC_INPUT = 106,
     109    /** @todo Docs! */
     110    CALLBACKTYPE_FILE_OPEN = 210,
     111    CALLBACKTYPE_FILE_CLOSE = 215,
     112    CALLBACKTYPE_FILE_READ = 230,
     113    CALLBACKTYPE_FILE_WRITE = 240,
     114    CALLBACKTYPE_FILE_SEEK = 250,
     115    CALLBACKTYPE_FILE_TELL = 260
     116};
     117
     118
     119/*
    118120 * Class representing a guest control callback.
    119121 */
    120122class GuestCtrlCallback : public GuestCtrlEvent
    121123{
     124
    122125public:
    123126
    124127    GuestCtrlCallback(void);
    125128
    126     GuestCtrlCallback(eVBoxGuestCtrlCallbackType enmType);
     129    GuestCtrlCallback(CALLBACKTYPE enmType);
    127130
    128131    virtual ~GuestCtrlCallback(void);
    … …  
    132135    void Destroy(void);
    133136
    134     int Init(eVBoxGuestCtrlCallbackType enmType);
    135 
    136     eVBoxGuestCtrlCallbackType GetCallbackType(void) { return mType; }
     137    int Init(CALLBACKTYPE enmType);
     138
     139    CALLBACKTYPE GetCallbackType(void) { return mType; }
    137140
    138141    const void* GetDataRaw(void) const { return pvData; }
    … …  
    155158    size_t                      cbData;
    156159    /** The callback type. */
    157     eVBoxGuestCtrlCallbackType  mType;
     160    CALLBACKTYPE                mType;
    158161    /** Callback flags. */
    159162    uint32_t                    uFlags;
    … …  
    258261
    259262    std::map <Utf8Str, Utf8Str> mEnvironment;
     263};
     264
     265
     266/**
     267 * Structure for keeping all the relevant guest file
     268 * information around.
     269 */
     270struct GuestFileOpenInfo
     271{
     272    /** The filename. */
     273    Utf8Str                 mFileName;
     274    /** Then file's opening mode. */
     275    Utf8Str                 mOpenMode;
     276    /** The file's disposition mode. */
     277    Utf8Str                 mDisposition;
     278    /** Octal creation mode. */
     279    uint32_t                mCreationMode;
     280    /** The initial offset on open. */
     281    int64_t                 mInitialOffset;
    260282};
    261283
    … …  
    317339    uint32_t                    mFlags;
    318340    ULONG                       mTimeoutMS;
     341    /** Process priority. */
    319342    ProcessPriority_T           mPriority;
    320     ProcessAffinity             mAffinity;
     343    /** Process affinity. */
     344    uint64_t                    mAffinity;
    321345};
    322346
    … …  
    378402    uint32_t GetUInt32(const char *pszKey) const;
    379403
    380     bool IsEmpty(void) { return m_mapPairs.empty(); }
     404    bool IsEmpty(void) { return mPairs.empty(); }
    381405
    382406    int SetValue(const char *pszKey, const char *pszValue);
    … …  
    384408protected:
    385409
    386     GuestCtrlStreamPairMap m_mapPairs;
     410    GuestCtrlStreamPairMap mPairs;
    387411};
    388412
    … …  
    479503    ULONG   uFlags;
    480504};
     505
     506/**
     507 * Pure virtual class (interface) for guest objects (processes, files, ...) --
     508 * contains all per-object callback management.
     509 */
     510class GuestObject
     511{
     512
     513public:
     514
     515    ULONG getObjectID(void) { return mObject.mObjectID; }
     516
     517protected:
     518
     519    /** Callback dispatcher -- must be implemented by the actual object. */
     520    virtual int callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb) = 0;
     521
     522protected:
     523
     524    int bindToSession(Console *pConsole, GuestSession *pSession, uint32_t uObjectID);
     525    int callbackAdd(GuestCtrlCallback *pCallback, uint32_t *puContextID);
     526    bool callbackExists(uint32_t uContextID);
     527    int callbackRemove(uint32_t uContextID);
     528    int callbackRemoveAll(void);
     529    int sendCommand(uint32_t uFunction, uint32_t uParms, PVBOXHGCMSVCPARM paParms);
     530
     531protected:
     532
     533    /**
     534     * Commom structure for all derived objects, when then have
     535     * an own mData structure to keep their specific data around.
     536     */
     537    struct Object
     538    {
     539        /** Pointer to parent session. Per definition
     540         *  this objects *always* lives shorter than the
     541         *  parent. */
     542        GuestSession            *mSession;
     543        /** Pointer to the console object. Needed
     544         *  for HGCM (VMMDev) communication. */
     545        Console                 *mConsole;
     546        /** All related callbacks to this object. */
     547        GuestCtrlCallbacks       mCallbacks;
     548        /** The next upcoming context ID for this object. */
     549        ULONG                    mNextContextID;
     550        /** The object ID -- must be unique for each guest
     551         *  session and is encoded into the context ID. Must
     552         *  be set manually when initializing the object.
     553         *
     554         *  For guest processes this is the internal PID,
     555         *  for guest files this is the internal file ID. */
     556        uint32_t                 mObjectID;
     557    } mObject;
     558};
     559
     560#if 0
     561/*
     562 * Guest (HGCM) callbacks. All classes will throw
     563 * an exception on misuse.
     564 */
     565
     566/** Callback class for guest process status. */
     567class GuestCbProcessStatus : public GuestCtrlCallback
     568{
     569
     570public:
     571
     572    int Init(uint32_t uProtocol, uint32_t uFunction,
     573             PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
     574    {
     575        AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
     576
     577        int rc = GuestCtrlCallback::Init();
     578        if (RT_FAILURE(rc))
     579            return rc;
     580
     581        if (   uFunction != GUEST_EXEC_SEND_STATUS
     582            || pSvcCb->mParms < 5)
     583            return VERR_INVALID_PARAMETER;
     584
     585        /* pSvcCb->mpaParms[0] always contains the context ID. */
     586        pSvcCb->mpaParms[1].getUInt32(&mPID);
     587        pSvcCb->mpaParms[2].getUInt32(&mStatus);
     588        pSvcCb->mpaParms[3].getUInt32(&mFlags); /* Can contain an IPRT error, which is a signed int. */
     589        pSvcCb->mpaParms[4].getPointer(&mData, &mcbData);
     590
     591        return VINF_SUCCESS;
     592    }
     593
     594    void Destroy(void) { }
     595
     596    uint32_t  mPID;
     597    uint32_t  mStatus;
     598    uint32_t  mFlags;
     599    void     *mData;
     600    uint32_t  mcbData;
     601};
     602
     603/** Callback class for guest process input. */
     604class GuestCbProcessInput : public GuestCtrlCallback
     605{
     606
     607public:
     608
     609    int Init(uint32_t uProtocol, uint32_t uFunction,
     610             PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
     611    {
     612        AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
     613
     614        int rc = GuestCtrlCallback::Init();
     615        if (RT_FAILURE(rc))
     616            return rc;
     617
     618        if (   uFunction != GUEST_EXEC_SEND_INPUT_STATUS
     619            || pSvcCb->mParms < 5)
     620            return VERR_INVALID_PARAMETER;
     621
     622        /* pSvcCb->mpaParms[0] always contains the context ID. */
     623        pSvcCb->mpaParms[1].getUInt32(&mPID);
     624        /* Associated file handle. */
     625        pSvcCb->mpaParms[2].getUInt32(&mStatus);
     626        pSvcCb->mpaParms[3].getUInt32(&mFlags);
     627        pSvcCb->mpaParms[4].getUInt32(&mProcessed);
     628
     629        return VINF_SUCCESS;
     630    }
     631
     632    void Destroy(void) { }
     633
     634    GuestCbProcessInput& operator=(const GuestCbProcessInput &that)
     635    {
     636        mPID = that.mPID;
     637        mStatus = that.mStatus;
     638        mFlags = that.mFlags;
     639        mProcessed = that.mProcessed;
     640        return *this;
     641    }
     642
     643    uint32_t  mPID;
     644    uint32_t  mStatus;
     645    uint32_t  mFlags;
     646    uint32_t  mProcessed;
     647};
     648
     649/** Callback class for guest process output. */
     650class GuestCbProcessOutput : public GuestCtrlCallback
     651{
     652
     653public:
     654
     655    int Init(uint32_t uProtocol, uint32_t uFunction,
     656             PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
     657    {
     658        AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
     659
     660        int rc = GuestCtrlCallback::Init();
     661        if (RT_FAILURE(rc))
     662            return rc;
     663
     664        if (   uFunction != GUEST_EXEC_SEND_OUTPUT
     665            || pSvcCb->mParms < 5)
     666            return VERR_INVALID_PARAMETER;
     667
     668        /* pSvcCb->mpaParms[0] always contains the context ID. */
     669        pSvcCb->mpaParms[1].getUInt32(&mPID);
     670        /* Associated file handle. */
     671        pSvcCb->mpaParms[2].getUInt32(&mHandle);
     672        pSvcCb->mpaParms[3].getUInt32(&mFlags);
     673
     674        void *pbData; uint32_t cbData;
     675        rc = pSvcCb->mpaParms[4].getPointer(&pbData, &cbData);
     676        if (RT_SUCCESS(rc))
     677        {
     678            Assert(cbData);
     679            mData = RTMemAlloc(cbData);
     680            AssertPtrReturn(mData, VERR_NO_MEMORY);
     681            memcpy(mData, pbData, cbData);
     682            mcbData = cbData;
     683        }
     684
     685        return rc;
     686    }
     687
     688    void Destroy(void)
     689    {
     690        if (mData)
     691        {
     692            RTMemFree(mData);
     693            mData = NULL;
     694            mcbData = 0;
     695        }
     696    }
     697
     698    GuestCbProcessOutput& operator=(const GuestCbProcessOutput &that)
     699    {
     700        mPID = that.mPID;
     701        mHandle = that.mHandle;
     702        mFlags = that.mFlags;
     703
     704        Destroy();
     705        if (that.mcbData)
     706        {
     707            void *pvData = RTMemAlloc(that.mcbData);
     708            if (pvData)
     709            {
     710                AssertPtr(pvData);
     711                memcpy(pvData, that.mData, that.mcbData);
     712                mData = pvData;
     713                mcbData = that.mcbData;
     714            }
     715        }
     716
     717        return *this;
     718    }
     719
     720    uint32_t  mPID;
     721    uint32_t  mHandle;
     722    uint32_t  mFlags;
     723    void     *mData;
     724    size_t    mcbData;
     725};
     726
     727/** Callback class for guest process IO notifications. */
     728class GuestCbProcessIO : public GuestCtrlCallback
     729{
     730
     731public:
     732
     733    int Init(uint32_t uProtocol, uint32_t uFunction,
     734             PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
     735    {
     736        AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
     737
     738        int rc = GuestCtrlCallback::Init();
     739        if (RT_FAILURE(rc))
     740            return rc;
     741
     742        return VERR_NOT_IMPLEMENTED;
     743    }
     744
     745    void Destroy(void) { GuestCtrlCallback::Destroy(); }
     746
     747    GuestCbProcessIO& operator=(const GuestCbProcessIO &that)
     748    {
     749        return *this;
     750    }
     751};
     752#endif
    481753#endif // ____H_GUESTIMPLPRIVATE
    482754

  • trunk/src/VBox/Main/include/GuestFileImpl.h

    r43162 r44863  
    22/* $Id$ */
    33/** @file
    4  * VirtualBox Main - XXX.
     4 * VirtualBox Main - Guest file handling.
    55 */
    66
    77/*
    8  * Copyright (C) 2012 Oracle Corporation
     8 * Copyright (C) 2012-2013 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2323
    2424#include "GuestFsObjInfoImpl.h"
     25#include "GuestCtrlImplPrivate.h"
    2526
     27class Console;
    2628class GuestSession;
    2729class GuestProcess;
    … …  
    3234class ATL_NO_VTABLE GuestFile :
    3335    public VirtualBoxBase,
     36    public GuestObject,
    3437    VBOX_SCRIPTABLE_IMPL(IGuestFile)
    3538{
    … …  
    4649    DECLARE_EMPTY_CTOR_DTOR(GuestFile)
    4750
    48     int     init(GuestSession *pSession, const Utf8Str &strPath, const Utf8Str &strOpenMode, const Utf8Str &strDisposition, uint32_t uCreationMode, int64_t iOffset, int *pGuestRc);
     51    int     init(Console *pConsole, GuestSession *pSession, ULONG uFileID, const GuestFileOpenInfo &openInfo);
    4952    void    uninit(void);
    5053    HRESULT FinalConstruct(void);
    … …  
    7477    /** @name Public internal methods.
    7578     * @{ */
     79    int             callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
    7680    static uint32_t getDispositionFromString(const Utf8Str &strDisposition);
    7781    static uint32_t getOpenModeFromString(const Utf8Str &strOpenMode);
     82    int             onFileNotify(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
     83    int             onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
     84    int             openFile(int *pGuestRc);
    7885    /** @}  */
    7986
    … …  
    8289    struct Data
    8390    {
     91        /** The internal console object. */
     92        Console                *mConsole;
    8493        /** The associate session this file belongs to. */
    8594        GuestSession           *mSession;
    86         uint32_t                mCreationMode;
    87         uint32_t                mDisposition;
    88         Utf8Str                 mFileName;
    89         int64_t                 mInitialSize;
    90         uint32_t                mOpenMode;
    91         int64_t                 mOffset;
     95        /** All related callbacks to this file. */
     96        GuestCtrlCallbacks      mCallbacks;
     97        /** The file's open info. */
     98        GuestFileOpenInfo       mOpenInfo;
     99        /** The file's initial size on open. */
     100        uint64_t                mInitialSize;
     101        /** The file's current offset. */
     102        uint64_t                mOffCurrent;
    92103    } mData;
    93104};

  • trunk/src/VBox/Main/include/GuestImpl.h

    r43908 r44863  
    114114#ifdef VBOX_WITH_GUEST_CONTROL
    115115    /** Static callback for handling guest control notifications. */
    116     static DECLCALLBACK(int) notifyCtrlDispatcher(void *pvExtension, uint32_t u32Function, void *pvParms, uint32_t cbParms);
     116    static DECLCALLBACK(int) notifyCtrlDispatcher(void *pvExtension, uint32_t u32Function, void *pvData, uint32_t cbData);
    117117    static void staticUpdateStats(RTTIMERLR hTimerLR, void *pvUser, uint64_t iTick);
    118118#endif
    … …  
    137137    }
    138138#ifdef VBOX_WITH_GUEST_CONTROL
    139     int         dispatchToSession(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData);
     139    int         dispatchToSession(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
    140140    uint32_t    getAdditionsVersion(void) { return mData.mAdditionsVersionFull; }
    141141    Console    *getConsole(void) { return mParent; }

  • trunk/src/VBox/Main/include/GuestProcessImpl.h

    r43162 r44863  
    22/* $Id$ */
    33/** @file
    4  * VirtualBox Main - XXX.
     4 * VirtualBox Main - Guest process handling.
    55 */
    66
    77/*
    8  * Copyright (C) 2012 Oracle Corporation
     8 * Copyright (C) 2012-2013 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2727
    2828/**
    29  * TODO
     29 * Class for handling a guest process.
    3030 */
    3131class ATL_NO_VTABLE GuestProcess :
    3232    public VirtualBoxBase,
     33    public GuestObject,
    3334    VBOX_SCRIPTABLE_IMPL(IGuestProcess)
    3435{
    … …  
    7273    /** @name Public internal methods.
    7374     * @{ */
    74     int callbackDispatcher(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData);
    75     inline bool callbackExists(uint32_t uContextID);
     75    int callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
    7676    inline int checkPID(uint32_t uPID);
    7777    static Utf8Str guestErrorToString(int guestRc);
    7878    bool isReady(void);
    79     ULONG getProcessID(void) { return mData.mProcessID; }
    8079    int readData(uint32_t uHandle, uint32_t uSize, uint32_t uTimeoutMS, void *pvData, size_t cbData, size_t *pcbRead, int *pGuestRc);
    8180    static HRESULT setErrorExternal(VirtualBoxBase *pInterface, int guestRc);
    8281    int startProcess(int *pGuestRc);
    8382    int startProcessAsync(void);
    84     int terminateProcess(void);
     83    int terminateProcess(int *pGuestRc);
    8584    int waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, ProcessWaitResult_T &waitResult, int *pGuestRc);
    8685    int writeData(uint32_t uHandle, uint32_t uFlags, void *pvData, size_t cbData, uint32_t uTimeoutMS, uint32_t *puWritten, int *pGuestRc);
    … …  
    9089    /** @name Protected internal methods.
    9190     * @{ */
    92     inline int callbackAdd(GuestCtrlCallback *pCallback, uint32_t *puContextID);
    93     inline int callbackRemove(uint32_t uContextID);
    9491    inline bool isAlive(void);
    95     int onGuestDisconnected(GuestCtrlCallback *pCallback, PCALLBACKDATACLIENTDISCONNECTED pData);
    96     int onProcessInputStatus(GuestCtrlCallback *pCallback, PCALLBACKDATAEXECINSTATUS pData);
    97     int onProcessNotifyIO(GuestCtrlCallback *pCallback, PCALLBACKDATAEXECSTATUS pData);
    98     int onProcessStatusChange(GuestCtrlCallback *pCallback, PCALLBACKDATAEXECSTATUS pData);
    99     int onProcessOutput(GuestCtrlCallback *pCallback, PCALLBACKDATAEXECOUT pData);
     92    int onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
     93    int onProcessInputStatus(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
     94    int onProcessNotifyIO(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, GuestCtrlCallback * pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
     95    int onProcessStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
     96    int onProcessOutput(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
    10097    int prepareExecuteEnv(const char *pszEnv, void **ppvList, ULONG *pcbList, ULONG *pcEnvVars);
    101     int sendCommand(uint32_t uFunction, uint32_t uParms, PVBOXHGCMSVCPARM paParms);
    10298    int setProcessStatus(ProcessStatus_T procStatus, int procRc);
    10399    int signalWaiters(ProcessWaitResult_T enmWaitResult, int rc = VINF_SUCCESS);
    … …  
    109105    struct Data
    110106    {
    111         /** Pointer to parent session. Per definition
    112          *  this objects *always* lives shorter than the
    113          *  parent. */
    114         GuestSession            *mParent;
    115         /** Pointer to the console object. Needed
    116          *  for HGCM (VMMDev) communication. */
    117         Console                 *mConsole;
    118         /** All related callbacks to this process. */
    119         GuestCtrlCallbacks       mCallbacks;
    120107        /** The process start information. */
    121108        GuestProcessStartupInfo  mProcess;
    … …  
    124111        /** PID reported from the guest. */
    125112        ULONG                    mPID;
    126         /** Internal, host-side process ID. */
    127         ULONG                    mProcessID;
    128113        /** The current process status. */
    129114        ProcessStatus_T          mStatus;
    130115        int                      mRC;
    131         /** The next upcoming context ID. */
    132         ULONG                    mNextContextID;
    133116        /** The mutex for protecting the waiter(s). */
    134117        RTSEMMUTEX               mWaitMutex;

  • trunk/src/VBox/Main/include/GuestSessionImpl.h

    r43162 r44863  
    22/* $Id$ */
    33/** @file
    4  * VirtualBox Main - XXX.
     4 * VirtualBox Main - Guest session handling.
    55 */
    66
    77/*
    8  * Copyright (C) 2012 Oracle Corporation
     8 * Copyright (C) 2012-2013 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    6464     *  asynchronously. Optional. */
    6565    ComObjPtr<Progress>     mProgress;
     66};
     67
     68/**
     69 * Task for opening a guest session.
     70 */
     71class SessionTaskOpen : public GuestSessionTask
     72{
     73public:
     74
     75    SessionTaskOpen(GuestSession *pSession,
     76                    uint32_t uFlags,
     77                    uint32_t uTimeoutMS);
     78
     79    virtual ~SessionTaskOpen(void);
     80
     81public:
     82
     83    int Run(void);
     84    int RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress);
     85    static int taskThread(RTTHREAD Thread, void *pvUser);
     86
     87protected:
     88
     89    /** Session creation flags. */
     90    uint32_t mFlags;
     91    /** Session creation timeout (in ms). */
     92    uint32_t mTimeoutMS;
    6693};
    6794
    … …  
    288315
    289316    typedef std::vector <ComObjPtr<GuestDirectory> > SessionDirectories;
    290     typedef std::vector <ComObjPtr<GuestFile> > SessionFiles;
     317    /** Map of guest files. The key specifies the internal file ID. */
     318    typedef std::map <uint32_t, ComObjPtr<GuestFile> > SessionFiles;
    291319    /** Map of guest processes. The key specifies the internal process number.
    292320     *  To retrieve the process' guest PID use the Id() method of the IProcess interface. */
    … …  
    296324    /** @name Public internal methods.
    297325     * @{ */
     326    int                     closeSession(uint32_t uFlags, uint32_t uTimeoutMS, int *pGuestRc);
    298327    int                     directoryRemoveFromList(GuestDirectory *pDirectory);
    299328    int                     directoryCreateInternal(const Utf8Str &strPath, uint32_t uMode, uint32_t uFlags, int *pGuestRc);
    … …  
    301330    int                     directoryOpenInternal(const Utf8Str &strPath, const Utf8Str &strFilter, uint32_t uFlags, ComObjPtr<GuestDirectory> &pDirectory);
    302331    int                     directoryQueryInfoInternal(const Utf8Str &strPath, GuestFsObjData &objData, int *pGuestRc);
    303     int                     dispatchToProcess(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData);
     332    int                     dispatchToFile(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
     333    int                     dispatchToProcess(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
     334    int                     dispatchToThis(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
     335    inline bool             fileExists(uint32_t uFileID, ComObjPtr<GuestFile> *pFile);
    304336    int                     fileRemoveFromList(GuestFile *pFile);
    305337    int                     fileRemoveInternal(const Utf8Str &strPath, int *pGuestRc);
    306     int                     fileOpenInternal(const Utf8Str &strPath, const Utf8Str &strOpenMode, const Utf8Str &strDisposition,
    307                                              uint32_t uCreationMode, int64_t iOffset, ComObjPtr<GuestFile> &pFile, int *pGuestRc);
     338    int                     fileOpenInternal(const GuestFileOpenInfo &openInfo, ComObjPtr<GuestFile> &pFile, int *pGuestRc);
    308339    int                     fileQueryInfoInternal(const Utf8Str &strPath, GuestFsObjData &objData, int *pGuestRc);
    309340    int                     fileQuerySizeInternal(const Utf8Str &strPath, int64_t *pllSize, int *pGuestRc);
    … …  
    313344    Utf8Str                 getName(void);
    314345    ULONG                   getId(void) { return mData.mId; }
     346    int                     onSessionStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
     347    int                     openSession(uint32_t uFlags, uint32_t uTimeoutMS, int *pGuestRc);
    315348    Guest                  *getParent(void) { return mData.mParent; }
    316349    uint32_t                getProtocolVersion(void) { return mData.mProtocolVersion; }
    … …  
    319352    inline bool             processExists(uint32_t uProcessID, ComObjPtr<GuestProcess> *pProcess);
    320353    inline int              processGetByPID(ULONG uPID, ComObjPtr<GuestProcess> *pProcess);
     354    int                     sendCommand(uint32_t uFunction, uint32_t uParms, PVBOXHGCMSVCPARM paParms);
    321355    int                     startTaskAsync(const Utf8Str &strTaskDesc, GuestSessionTask *pTask, ComObjPtr<Progress> &pProgress);
    322356    int                     queryInfo(void);
    … …  
    328362    {
    329363        /** Guest control protocol version to be used.
    330          *  Guest Additions < VBox 4.2 have version 1,
     364         *  Guest Additions < VBox 4.3 have version 1,
    331365         *  any newer version will have version 2. */
    332366        uint32_t             mProtocolVersion;
    … …  
    347381         *  overwritten/extended by ProcessCreate(Ex). */
    348382        GuestEnvironment     mEnvironment;
     383        /** The session callback, needed for communicating
     384         *  with the guest. */
     385        GuestCtrlCallback    mCallback;
    349386        /** Directory objects bound to this session. */
    350387        SessionDirectories   mDirectories;

  • trunk/src/VBox/Main/src-client/GuestCtrlImpl.cpp

    r43170 r44863  
    6565DECLCALLBACK(int) Guest::notifyCtrlDispatcher(void    *pvExtension,
    6666                                              uint32_t u32Function,
    67                                               void    *pvParms,
    68                                               uint32_t cbParms)
     67                                              void    *pvData,
     68                                              uint32_t cbData)
    6969{
    7070    using namespace guestControl;
    … …  
    7575     */
    7676    LogFlowFunc(("pvExtension=%p, u32Function=%RU32, pvParms=%p, cbParms=%RU32\n",
    77                  pvExtension, u32Function, pvParms, cbParms));
     77                 pvExtension, u32Function, pvData, cbData));
    7878    ComObjPtr<Guest> pGuest = reinterpret_cast<Guest *>(pvExtension);
    7979    Assert(!pGuest.isNull());
    … …  
    8686     * - Dispatch the whole stuff to the appropriate session (if still exists)
    8787     */
    88 
    89     PCALLBACKHEADER pHeader = (PCALLBACKHEADER)pvParms;
    90     AssertPtr(pHeader);
    91 
     88    if (cbData != sizeof(VBOXGUESTCTRLHOSTCALLBACK))
     89        return VERR_NOT_SUPPORTED;
     90    PVBOXGUESTCTRLHOSTCALLBACK pSvcCb = (PVBOXGUESTCTRLHOSTCALLBACK)pvData;
     91    AssertPtr(pSvcCb);
     92
     93    if (!pSvcCb->mParms) /* At least context ID must be present. */
     94        return VERR_INVALID_PARAMETER;
     95
     96    uint32_t uContextID;
     97    int rc = pSvcCb->mpaParms[0].getUInt32(&uContextID);
     98    AssertMsgRC(rc, ("Unable to extract callback context ID, pvData=%p\n", pSvcCb));
     99    if (RT_FAILURE(rc))
     100        return rc;
    92101#ifdef DEBUG
    93102    LogFlowFunc(("CID=%RU32, uSession=%RU32, uObject=%RU32, uCount=%RU32\n",
    94                  pHeader->u32ContextID,
    95                  VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pHeader->u32ContextID),
    96                  VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pHeader->u32ContextID),
    97                  VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(pHeader->u32ContextID)));
     103                 uContextID,
     104                 VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(uContextID),
     105                 VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(uContextID),
     106                 VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID)));
    98107#endif
    99108
    100     bool fDispatch = true;
    101 #ifdef DEBUG
    102     /*
    103      * Pre-check: If we got a status message with an error and VERR_TOO_MUCH_DATA
    104      *            it means that that guest could not handle the entire message
    105      *            because of its exceeding size. This should not happen on daily
    106      *            use but testcases might try this. It then makes no sense to dispatch
    107      *            this further because we don't have a valid context ID.
    108      */
    109     if (u32Function == GUEST_EXEC_SEND_STATUS)
    110     {
    111         PCALLBACKDATAEXECSTATUS pCallbackData = reinterpret_cast<PCALLBACKDATAEXECSTATUS>(pvParms);
    112         AssertPtr(pCallbackData);
    113         AssertReturn(sizeof(CALLBACKDATAEXECSTATUS) == cbParms, VERR_INVALID_PARAMETER);
    114         AssertReturn(CALLBACKDATAMAGIC_EXEC_STATUS == pCallbackData->hdr.u32Magic, VERR_INVALID_PARAMETER);
    115 
    116         if (   pCallbackData->u32Status == PROC_STS_ERROR
    117             && ((int)pCallbackData->u32Flags)  == VERR_TOO_MUCH_DATA)
    118         {
    119             LogFlowFunc(("Requested command with too much data, skipping dispatching ...\n"));
    120 
    121             Assert(pCallbackData->u32PID == 0);
    122             fDispatch = false;
    123         }
    124     }
    125 #endif
    126     int rc = VINF_SUCCESS;
    127     if (fDispatch)
    128     {
    129         rc = pGuest->dispatchToSession(pHeader->u32ContextID, u32Function, pvParms, cbParms);
    130         if (RT_SUCCESS(rc))
    131             return rc;
    132     }
    133 
     109    VBOXGUESTCTRLHOSTCBCTX ctxCb = { u32Function, uContextID };
     110    rc = pGuest->dispatchToSession(&ctxCb, pSvcCb);
    134111    LogFlowFuncLeaveRC(rc);
    135112    return rc;
    … …  
    224201/////////////////////////////////////////////////////////////////////////////
    225202
    226 int Guest::dispatchToSession(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData)
    227 {
    228     LogFlowFuncEnter();
     203int Guest::dispatchToSession(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
     204{
     205    LogFlowFunc(("pCtxCb=%p, pSvcCb=%p\n", pCtxCb, pSvcCb));
     206
     207    AssertPtrReturn(pCtxCb, VERR_INVALID_POINTER);
     208    AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
    229209
    230210    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    231211
    232     uint32_t uSessionID = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(uContextID);
     212    uint32_t uSessionID = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pCtxCb->uContextID);
    233213#ifdef DEBUG
    234     LogFlowFunc(("uSessionID=%RU32 (%RU32 total)\n",
     214    LogFlowFunc(("uSessionID=%RU32 (%zu total)\n",
    235215                 uSessionID, mData.mGuestSessions.size()));
    236216#endif
    237     int rc;
    238217    GuestSessions::const_iterator itSession
    239218        = mData.mGuestSessions.find(uSessionID);
     219
     220    int rc;
    240221    if (itSession != mData.mGuestSessions.end())
    241222    {
    … …  
    244225
    245226        alock.release();
    246         rc = pSession->dispatchToProcess(uContextID, uFunction, pvData, cbData);
     227
     228        bool fDispatch = true;
     229#ifdef DEBUG
     230        /*
     231         * Pre-check: If we got a status message with an error and VERR_TOO_MUCH_DATA
     232         *            it means that that guest could not handle the entire message
     233         *            because of its exceeding size. This should not happen on daily
     234         *            use but testcases might try this. It then makes no sense to dispatch
     235         *            this further because we don't have a valid context ID.
     236         */
     237        if (   pCtxCb->uFunction == GUEST_EXEC_STATUS
     238            && pSvcCb->mParms    >= 5)
     239        {
     240            CALLBACKDATA_PROC_STATUS dataCb;
     241            /* pSvcCb->mpaParms[0] always contains the context ID. */
     242            pSvcCb->mpaParms[1].getUInt32(&dataCb.uPID);
     243            pSvcCb->mpaParms[2].getUInt32(&dataCb.uStatus);
     244            pSvcCb->mpaParms[3].getUInt32(&dataCb.uFlags);
     245            pSvcCb->mpaParms[4].getPointer(&dataCb.pvData, &dataCb.cbData);
     246
     247            if (   (dataCb.uStatus == PROC_STS_ERROR)
     248                && (dataCb.uFlags  == VERR_TOO_MUCH_DATA))
     249            {
     250                LogFlowFunc(("Requested command with too much data, skipping dispatching ...\n"));
     251
     252                Assert(dataCb.uPID == 0);
     253                fDispatch = false;
     254            }
     255        }
     256#endif
     257        if (fDispatch)
     258        {
     259            switch (pCtxCb->uFunction)
     260            {
     261                case GUEST_DISCONNECTED:
     262                   break;
     263
     264                case GUEST_SESSION_NOTIFY:
     265                    rc = pSession->dispatchToThis(pCtxCb, pSvcCb);
     266                    break;
     267
     268                case GUEST_EXEC_STATUS:
     269                case GUEST_EXEC_OUTPUT:
     270                case GUEST_EXEC_INPUT_STATUS:
     271                case GUEST_EXEC_IO_NOTIFY:
     272                    rc = pSession->dispatchToProcess(pCtxCb, pSvcCb);
     273                    break;
     274
     275                case GUEST_FILE_NOTIFY:
     276                    rc = pSession->dispatchToFile(pCtxCb, pSvcCb);
     277                    break;
     278
     279                default:
     280                    rc = VERR_NOT_SUPPORTED;
     281                    break;
     282            }
     283        }
     284        else
     285            rc = VERR_NOT_FOUND;
    247286    }
    248287    else
    … …  
    318357        if (FAILED(hr)) throw VERR_COM_UNEXPECTED;
    319358
     359        rc = pGuestSession->queryInfo();
     360        if (RT_FAILURE(rc)) throw rc;
    320361        rc = pGuestSession->init(this, uNewSessionID,
    321362                                 strUser, strPassword, strDomain, strSessionName);
    322363        if (RT_FAILURE(rc)) throw rc;
    323364
     365        /*
     366         * Add session object to our session map. This is necessary
     367         * before calling openSession because the guest calls back
     368         * with the creation result to this session.
     369         */
    324370        mData.mGuestSessions[uNewSessionID] = pGuestSession;
    325371
    326         LogFlowFunc(("Added new session (pSession=%p, ID=%RU32), now %ld sessions total\n",
    327                      (GuestSession *)pGuestSession, uNewSessionID, mData.mGuestSessions.size()));
     372        /* Drop write lock before opening session, because this will
     373         * involve the main dispatcher to run. */
     374        alock.release();
     375
     376        /** @todo Do we need an openSessioAsync() call? This might be
     377         *        a problem on webservice calls (= timeouts) if opening the
     378         *        guest session takes too long -> Then we also would
     379         *        need some session.getStatus() API call! */
     380
     381        /* Open (create) the session on the guest. */
     382        int guestRc;
     383        rc = pGuestSession->openSession(0 /* Flags */, 30 * 1000 /* 30s timeout */,
     384                                        &guestRc);
     385        if (RT_FAILURE(rc))
     386        {
     387            switch (rc)
     388            {
     389                case VERR_MAX_PROCS_REACHED:
     390                    hr = setError(VBOX_E_IPRT_ERROR, tr("Maximum number of guest sessions (%ld) reached"),
     391                                                        VBOX_GUESTCTRL_MAX_SESSIONS);
     392                    break;
     393
     394                /** @todo Add more errors here. */
     395
     396                default:
     397                    hr = setError(VBOX_E_IPRT_ERROR, tr("Could not create guest session, rc=%Rrc"), rc);
     398                    break;
     399            }
     400
     401            /* Remove failed session again. */
     402            int rc2 = sessionRemove(pGuestSession);
     403            AssertRC(rc2);
     404        }
     405        else
     406            LogFlowFunc(("Created new guest session (pSession=%p, ID=%RU32), now %zu sessions total\n",
     407                         (GuestSession *)pGuestSession, uNewSessionID, mData.mGuestSessions.size()));
    328408    }
    329409    catch (int rc2)
    … …  
    332412    }
    333413
     414    LogFlowFuncLeaveRC(rc);
    334415    return rc;
    335416}
    … …  
    371452        if (FAILED(hr2))
    372453            rc = VERR_COM_OBJECT_NOT_FOUND;
    373 
    374         if (RT_SUCCESS(rc))
    375             rc = pSession->queryInfo();
    376454    }
    377455

  • trunk/src/VBox/Main/src-client/GuestCtrlPrivate.cpp

    r43162 r44863  
    66
    77/*
    8  * Copyright (C) 2011-2012 Oracle Corporation
     8 * Copyright (C) 2011-2013 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2121 ******************************************************************************/
    2222#include "GuestCtrlImplPrivate.h"
     23#include "GuestSessionImpl.h"
     24#include "VMMDev.h"
    2325
    2426#include <iprt/asm.h>
    … …  
    122124    : pvData(NULL),
    123125      cbData(0),
    124       mType(VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN),
     126      mType(CALLBACKTYPE_UNKNOWN),
    125127      uFlags(0),
    126128      pvPayload(NULL),
    … …  
    129131}
    130132
    131 GuestCtrlCallback::GuestCtrlCallback(eVBoxGuestCtrlCallbackType enmType)
     133GuestCtrlCallback::GuestCtrlCallback(CALLBACKTYPE enmType)
    132134    : pvData(NULL),
    133135      cbData(0),
    134       mType(VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN),
     136      mType(CALLBACKTYPE_UNKNOWN),
    135137      uFlags(0),
    136138      pvPayload(NULL),
    … …  
    146148}
    147149
    148 int GuestCtrlCallback::Init(eVBoxGuestCtrlCallbackType enmType)
    149 {
    150     AssertReturn(enmType > VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN, VERR_INVALID_PARAMETER);
     150int GuestCtrlCallback::Init(CALLBACKTYPE enmType)
     151{
     152    AssertReturn(enmType > CALLBACKTYPE_UNKNOWN, VERR_INVALID_PARAMETER);
    151153    Assert((pvData == NULL) && !cbData);
    152154
     155    int rc = VINF_SUCCESS;
     156
    153157    switch (enmType)
    154158    {
    155         case VBOXGUESTCTRLCALLBACKTYPE_EXEC_START:
    156         {
    157             pvData = (PCALLBACKDATAEXECSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECSTATUS));
     159        case CALLBACKTYPE_SESSION_NOTIFY:
     160        {
     161            pvData = (PCALLBACKDATA_SESSION_NOTIFY)RTMemAllocZ(sizeof(CALLBACKDATA_SESSION_NOTIFY));
    158162            AssertPtrReturn(pvData, VERR_NO_MEMORY);
    159             RT_BZERO(pvData, sizeof(CALLBACKDATAEXECSTATUS));
    160             cbData = sizeof(CALLBACKDATAEXECSTATUS);
    161             break;
    162         }
    163 
    164         case VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT:
    165         {
    166             pvData = (PCALLBACKDATAEXECOUT)RTMemAlloc(sizeof(CALLBACKDATAEXECOUT));
     163            cbData = sizeof(CALLBACKDATA_SESSION_NOTIFY);
     164            break;
     165        }
     166
     167        case CALLBACKTYPE_PROC_STATUS:
     168        {
     169            pvData = (PCALLBACKDATA_PROC_STATUS)RTMemAllocZ(sizeof(CALLBACKDATA_PROC_STATUS));
    167170            AssertPtrReturn(pvData, VERR_NO_MEMORY);
    168             RT_BZERO(pvData, sizeof(CALLBACKDATAEXECOUT));
    169             cbData = sizeof(CALLBACKDATAEXECOUT);
    170             break;
    171         }
    172 
    173         case VBOXGUESTCTRLCALLBACKTYPE_EXEC_INPUT_STATUS:
    174         {
    175             pvData = (PCALLBACKDATAEXECINSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECINSTATUS));
     171            cbData = sizeof(CALLBACKDATA_PROC_STATUS);
     172            break;
     173        }
     174
     175        case CALLBACKTYPE_PROC_OUTPUT:
     176        {
     177            pvData = (PCALLBACKDATA_PROC_OUTPUT)RTMemAllocZ(sizeof(CALLBACKDATA_PROC_OUTPUT));
    176178            AssertPtrReturn(pvData, VERR_NO_MEMORY);
    177             RT_BZERO(pvData, sizeof(CALLBACKDATAEXECINSTATUS));
    178             cbData = sizeof(CALLBACKDATAEXECINSTATUS);
     179            cbData = sizeof(CALLBACKDATA_PROC_OUTPUT);
     180            break;
     181        }
     182
     183        case CALLBACKTYPE_PROC_INPUT:
     184        {
     185            pvData = (PCALLBACKDATA_PROC_INPUT)RTMemAllocZ(sizeof(CALLBACKDATA_PROC_INPUT));
     186            AssertPtrReturn(pvData, VERR_NO_MEMORY);
     187            cbData = sizeof(CALLBACKDATA_PROC_INPUT);
    179188            break;
    180189        }
    181190
    182191        default:
    183             AssertMsgFailed(("Unknown callback type specified (%d)\n", enmType));
    184             break;
    185     }
    186 
    187     int rc = GuestCtrlEvent::Init();
     192            AssertMsgFailed(("Unknown callback type specified (%ld)\n", enmType));
     193            rc = VERR_NOT_IMPLEMENTED;
     194            break;
     195    }
     196
    188197    if (RT_SUCCESS(rc))
    189         mType  = enmType;
     198    {
     199        rc = GuestCtrlEvent::Init();
     200        if (RT_SUCCESS(rc))
     201            mType  = enmType;
     202    }
    190203
    191204    return rc;
    … …  
    198211    switch (mType)
    199212    {
    200         case VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT:
    201         {
    202             PCALLBACKDATAEXECOUT pThis = (PCALLBACKDATAEXECOUT)pvData;
     213        case CALLBACKTYPE_PROC_OUTPUT:
     214        {
     215            PCALLBACKDATA_PROC_OUTPUT pThis = (PCALLBACKDATA_PROC_OUTPUT)pvData;
    203216            AssertPtr(pThis);
    204217            if (pThis->pvData)
    205218                RTMemFree(pThis->pvData);
     219            break;
     220        }
     221
     222        case CALLBACKTYPE_FILE_READ:
     223        {
     224            PCALLBACKPAYLOAD_FILE_NOTFIY_READ pThis = (PCALLBACKPAYLOAD_FILE_NOTFIY_READ)pvData;
     225            AssertPtr(pThis);
     226            if (pThis->pvData)
     227                RTMemFree(pThis->pvData);
     228            break;
    206229        }
    207230
    … …  
    210233    }
    211234
    212     mType = VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN;
     235    mType = CALLBACKTYPE_UNKNOWN;
    213236    if (pvData)
    214237    {
    … …  
    232255    AssertPtr(pvCallback);
    233256
     257    int rc = VINF_SUCCESS;
    234258    switch (mType)
    235259    {
    236         case VBOXGUESTCTRLCALLBACKTYPE_EXEC_START:
    237         {
    238             PCALLBACKDATAEXECSTATUS pThis = (PCALLBACKDATAEXECSTATUS)pvData;
    239             PCALLBACKDATAEXECSTATUS pCB   = (PCALLBACKDATAEXECSTATUS)pvCallback;
    240             Assert(cbCallback == sizeof(CALLBACKDATAEXECSTATUS));
    241 
    242             pThis->u32Flags  = pCB->u32Flags;
    243             pThis->u32PID    = pCB->u32PID;
    244             pThis->u32Status = pCB->u32Status;
    245             break;
    246         }
    247 
    248         case VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT:
    249         {
    250             PCALLBACKDATAEXECOUT pThis = (PCALLBACKDATAEXECOUT)pvData;
    251             PCALLBACKDATAEXECOUT pCB   = (PCALLBACKDATAEXECOUT)pvCallback;
    252             Assert(cbCallback == sizeof(CALLBACKDATAEXECOUT));
    253 
    254             pThis->cbData   = pCB->cbData;
    255             if (pThis->cbData)
     260        case CALLBACKTYPE_SESSION_NOTIFY:
     261        {
     262            PCALLBACKDATA_SESSION_NOTIFY pThis = (PCALLBACKDATA_SESSION_NOTIFY)pvData;
     263            PCALLBACKDATA_SESSION_NOTIFY pCB   = (PCALLBACKDATA_SESSION_NOTIFY)pvCallback;
     264            Assert(cbCallback == sizeof(CALLBACKDATA_SESSION_NOTIFY));
     265
     266            pThis->uType   = pCB->uType;
     267            pThis->uResult = pCB->uResult;
     268            break;
     269        }
     270
     271        case CALLBACKTYPE_PROC_STATUS:
     272        {
     273            PCALLBACKDATA_PROC_STATUS pThis = (PCALLBACKDATA_PROC_STATUS)pvData;
     274            PCALLBACKDATA_PROC_STATUS pCB   = (PCALLBACKDATA_PROC_STATUS)pvCallback;
     275            Assert(cbCallback == sizeof(CALLBACKDATA_PROC_STATUS));
     276
     277            pThis->uFlags  = pCB->uFlags;
     278            pThis->uPID    = pCB->uPID;
     279            pThis->uStatus = pCB->uStatus;
     280            break;
     281        }
     282
     283        case CALLBACKTYPE_PROC_OUTPUT:
     284        {
     285            PCALLBACKDATA_PROC_OUTPUT pThis = (PCALLBACKDATA_PROC_OUTPUT)pvData;
     286            PCALLBACKDATA_PROC_OUTPUT pCB   = (PCALLBACKDATA_PROC_OUTPUT)pvCallback;
     287            Assert(cbCallback == sizeof(CALLBACKDATA_PROC_OUTPUT));
     288
     289            if (pCB->cbData)
    256290            {
    257291                pThis->pvData   = RTMemAlloc(pCB->cbData);
    258292                AssertPtrReturn(pThis->pvData, VERR_NO_MEMORY);
    259293                memcpy(pThis->pvData, pCB->pvData, pCB->cbData);
     294                pThis->cbData   = pCB->cbData;
    260295            }
    261             pThis->u32Flags = pCB->u32Flags;
    262             pThis->u32PID   = pCB->u32PID;
    263             break;
    264         }
    265 
    266         case VBOXGUESTCTRLCALLBACKTYPE_EXEC_INPUT_STATUS:
    267         {
    268             PCALLBACKDATAEXECINSTATUS pThis = (PCALLBACKDATAEXECINSTATUS)pvData;
    269             PCALLBACKDATAEXECINSTATUS pCB   = (PCALLBACKDATAEXECINSTATUS)pvCallback;
    270             Assert(cbCallback == sizeof(CALLBACKDATAEXECINSTATUS));
    271 
    272             pThis->cbProcessed = pCB->cbProcessed;
    273             pThis->u32Flags    = pCB->u32Flags;
    274             pThis->u32PID      = pCB->u32PID;
    275             pThis->u32Status   = pCB->u32Status;
     296            pThis->uFlags = pCB->uFlags;
     297            pThis->uPID   = pCB->uPID;
     298            break;
     299        }
     300
     301        case CALLBACKTYPE_PROC_INPUT:
     302        {
     303            PCALLBACKDATA_PROC_INPUT pThis = (PCALLBACKDATA_PROC_INPUT)pvData;
     304            PCALLBACKDATA_PROC_INPUT pCB   = (PCALLBACKDATA_PROC_INPUT)pvCallback;
     305            Assert(cbCallback == sizeof(CALLBACKDATA_PROC_INPUT));
     306
     307            pThis->uProcessed = pCB->uProcessed;
     308            pThis->uFlags     = pCB->uFlags;
     309            pThis->uPID       = pCB->uPID;
     310            pThis->uStatus    = pCB->uStatus;
     311            break;
     312        }
     313
     314        case CALLBACKTYPE_FILE_OPEN:
     315        {
     316            PCALLBACKPAYLOAD_FILE_NOTFIY_OPEN pThis = (PCALLBACKPAYLOAD_FILE_NOTFIY_OPEN)pvData;
     317            PCALLBACKPAYLOAD_FILE_NOTFIY_OPEN pCB   = (PCALLBACKPAYLOAD_FILE_NOTFIY_OPEN)pvCallback;
     318            Assert(cbCallback == sizeof(CALLBACKPAYLOAD_FILE_NOTFIY_OPEN));
     319
     320            pThis->rc = pCB->rc;
     321            pThis->uHandle = pCB->uHandle;
     322            break;
     323        }
     324
     325        case CALLBACKTYPE_FILE_CLOSE:
     326        {
     327            PCALLBACKPAYLOAD_FILE_NOTFIY_CLOSE pThis = (PCALLBACKPAYLOAD_FILE_NOTFIY_CLOSE)pvData;
     328            PCALLBACKPAYLOAD_FILE_NOTFIY_CLOSE pCB   = (PCALLBACKPAYLOAD_FILE_NOTFIY_CLOSE)pvCallback;
     329            Assert(cbCallback == sizeof(CALLBACKPAYLOAD_FILE_NOTFIY_CLOSE));
     330
     331            pThis->rc = pCB->rc;
     332            break;
     333        }
     334
     335        case CALLBACKTYPE_FILE_READ:
     336        {
     337            PCALLBACKPAYLOAD_FILE_NOTFIY_READ pThis = (PCALLBACKPAYLOAD_FILE_NOTFIY_READ)pvData;
     338            PCALLBACKPAYLOAD_FILE_NOTFIY_READ pCB   = (PCALLBACKPAYLOAD_FILE_NOTFIY_READ)pvCallback;
     339            Assert(cbCallback == sizeof(CALLBACKPAYLOAD_FILE_NOTFIY_READ));
     340
     341            pThis->rc = pCB->rc;
     342            if (pCB->cbData)
     343            {
     344                pThis->pvData   = RTMemAlloc(pCB->cbData);
     345                AssertPtrReturn(pThis->pvData, VERR_NO_MEMORY);
     346                memcpy(pThis->pvData, pCB->pvData, pCB->cbData);
     347                pThis->cbData   = pCB->cbData;
     348            }
     349            break;
     350        }
     351
     352        case CALLBACKTYPE_FILE_WRITE:
     353        {
     354            PCALLBACKPAYLOAD_FILE_NOTFIY_WRITE pThis = (PCALLBACKPAYLOAD_FILE_NOTFIY_WRITE)pvData;
     355            PCALLBACKPAYLOAD_FILE_NOTFIY_WRITE pCB   = (PCALLBACKPAYLOAD_FILE_NOTFIY_WRITE)pvCallback;
     356            Assert(cbCallback == sizeof(CALLBACKPAYLOAD_FILE_NOTFIY_WRITE));
     357
     358            pThis->rc = pCB->rc;
     359            pThis->cbWritten = pCB->cbWritten;
     360            break;
     361        }
     362
     363        case CALLBACKTYPE_FILE_SEEK:
     364        {
     365            PCALLBACKPAYLOAD_FILE_NOTFIY_SEEK pThis = (PCALLBACKPAYLOAD_FILE_NOTFIY_SEEK)pvData;
     366            PCALLBACKPAYLOAD_FILE_NOTFIY_SEEK pCB   = (PCALLBACKPAYLOAD_FILE_NOTFIY_SEEK)pvCallback;
     367            Assert(cbCallback == sizeof(CALLBACKPAYLOAD_FILE_NOTFIY_SEEK));
     368
     369            pThis->rc = pCB->rc;
     370            pThis->uOffActual = pCB->uOffActual;
     371            break;
     372        }
     373
     374        case CALLBACKTYPE_FILE_TELL:
     375        {
     376            PCALLBACKPAYLOAD_FILE_NOTFIY_TELL pThis = (PCALLBACKPAYLOAD_FILE_NOTFIY_TELL)pvData;
     377            PCALLBACKPAYLOAD_FILE_NOTFIY_TELL pCB   = (PCALLBACKPAYLOAD_FILE_NOTFIY_TELL)pvCallback;
     378            Assert(cbCallback == sizeof(CALLBACKPAYLOAD_FILE_NOTFIY_TELL));
     379
     380            pThis->rc = pCB->rc;
     381            pThis->uOffActual = pCB->uOffActual;
    276382            break;
    277383        }
    278384
    279385        default:
    280             AssertMsgFailed(("Callback type not handled (%d)\n", mType));
    281             break;
    282     }
    283 
    284     return VINF_SUCCESS;
     386            AssertMsgFailed(("Callback type not supported (%ld)\n", mType));
     387            rc = VERR_NOT_SUPPORTED;
     388            break;
     389    }
     390
     391    return rc;
    285392}
    286393
    … …  
    677784GuestProcessStreamBlock::GuestProcessStreamBlock(const GuestProcessStreamBlock &otherBlock)
    678785{
    679     for (GuestCtrlStreamPairsIter it = otherBlock.m_mapPairs.begin();
     786    for (GuestCtrlStreamPairsIter it = otherBlock.mPairs.begin();
    680787         it != otherBlock.end(); it++)
    681788    {
    682         m_mapPairs[it->first] = new
     789        mPairs[it->first] = new
    683790        if (it->second.pszValue)
    684791        {
    … …  
    701808void GuestProcessStreamBlock::Clear(void)
    702809{
    703     m_mapPairs.clear();
     810    mPairs.clear();
    704811}
    705812
    … …  
    708815{
    709816    LogFlowFunc(("Dumping contents of stream block=0x%p (%ld items):\n",
    710                  this, m_mapPairs.size()));
    711 
    712     for (GuestCtrlStreamPairMapIterConst it = m_mapPairs.begin();
    713          it != m_mapPairs.end(); it++)
     817                 this, mPairs.size()));
     818
     819    for (GuestCtrlStreamPairMapIterConst it = mPairs.begin();
     820         it != mPairs.end(); it++)
    714821    {
    715822        LogFlowFunc(("\t%s=%s\n", it->first.c_str(), it->second.mValue.c_str()));
    … …  
    759866size_t GuestProcessStreamBlock::GetCount(void) const
    760867{
    761     return m_mapPairs.size();
     868    return mPairs.size();
    762869}
    763870
    … …  
    774881    try
    775882    {
    776         GuestCtrlStreamPairMapIterConst itPairs = m_mapPairs.find(Utf8Str(pszKey));
    777         if (itPairs != m_mapPairs.end())
     883        GuestCtrlStreamPairMapIterConst itPairs = mPairs.find(Utf8Str(pszKey));
     884        if (itPairs != mPairs.end())
    778885            return itPairs->second.mValue.c_str();
    779886    }
    … …  
    837944        /* Take a shortcut and prevent crashes on some funny versions
    838945         * of STL if map is empty initially. */
    839         if (!m_mapPairs.empty())
    840         {
    841             GuestCtrlStreamPairMapIter it = m_mapPairs.find(Utf8Key);
    842             if (it != m_mapPairs.end())
    843                  m_mapPairs.erase(it);
     946        if (!mPairs.empty())
     947        {
     948            GuestCtrlStreamPairMapIter it = mPairs.find(Utf8Key);
     949            if (it != mPairs.end())
     950                 mPairs.erase(it);
    844951        }
    845952
    … …  
    847954        {
    848955            GuestProcessStreamValue val(pszValue);
    849             m_mapPairs[Utf8Key] = val;
     956            mPairs[Utf8Key] = val;
    850957        }
    851958    }
    … …  
    10761183}
    10771184
     1185int GuestObject::bindToSession(Console *pConsole, GuestSession *pSession, uint32_t uObjectID)
     1186{
     1187    AssertPtrReturn(pConsole, VERR_INVALID_POINTER);
     1188    AssertPtrReturn(pSession, VERR_INVALID_POINTER);
     1189
     1190    mObject.mConsole = pConsole;
     1191    mObject.mSession = pSession;
     1192
     1193    mObject.mNextContextID = 0;
     1194    mObject.mObjectID = uObjectID;
     1195
     1196    return VINF_SUCCESS;
     1197}
     1198
     1199int GuestObject::callbackAdd(GuestCtrlCallback *pCallback, uint32_t *puContextID)
     1200{
     1201    const ComObjPtr<GuestSession> pSession(mObject.mSession);
     1202    Assert(!pSession.isNull());
     1203    ULONG uSessionID = 0;
     1204    HRESULT hr = pSession->COMGETTER(Id)(&uSessionID);
     1205    ComAssertComRC(hr);
     1206
     1207    /* Create a new context ID and assign it. */
     1208    int vrc = VERR_NOT_FOUND;
     1209
     1210    ULONG uCount = mObject.mNextContextID++;
     1211    ULONG uNewContextID = 0;
     1212    ULONG uTries = 0;
     1213    for (;;)
     1214    {
     1215        if (uCount == VBOX_GUESTCTRL_MAX_CONTEXTS)
     1216            uCount = 0;
     1217
     1218        /* Create a new context ID ... */
     1219        uNewContextID = VBOX_GUESTCTRL_CONTEXTID_MAKE(uSessionID, mObject.mObjectID, uCount);
     1220
     1221        /* Is the context ID already used?  Try next ID ... */
     1222        if (!callbackExists(uCount))
     1223        {
     1224            /* Callback with context ID was not found. This means
     1225             * we can use this context ID for our new callback we want
     1226             * to add below. */
     1227            vrc = VINF_SUCCESS;
     1228            break;
     1229        }
     1230
     1231        uCount++;
     1232        if (++uTries == UINT32_MAX)
     1233            break; /* Don't try too hard. */
     1234    }
     1235
     1236    if (RT_SUCCESS(vrc))
     1237    {
     1238        /* Add callback with new context ID to our callback map.
     1239         * Note: This is *not* uNewContextID (which also includes
     1240         *       the session + process ID), just the context count
     1241         *       will be used here. */
     1242        mObject.mCallbacks[uCount] = pCallback;
     1243        Assert(mObject.mCallbacks.size());
     1244
     1245        /* Report back new context ID. */
     1246        if (puContextID)
     1247            *puContextID = uNewContextID;
     1248
     1249        LogFlowThisFunc(("Added new callback (Session: %RU32, Object: %RU32, Count: %RU32) CID=%RU32\n",
     1250                         uSessionID, mObject.mObjectID, uCount, uNewContextID));
     1251    }
     1252
     1253    return vrc;
     1254}
     1255
     1256bool GuestObject::callbackExists(uint32_t uContextID)
     1257{
     1258    GuestCtrlCallbacks::const_iterator it =
     1259        mObject.mCallbacks.find(VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID));
     1260    return (it == mObject.mCallbacks.end()) ? false : true;
     1261}
     1262
     1263int GuestObject::callbackRemove(uint32_t uContextID)
     1264{
     1265    LogFlowThisFunc(("Removing callback (Session=%RU32, Object=%RU32, Count=%RU32) CID=%RU32\n",
     1266                     VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(uContextID),
     1267                     VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(uContextID),
     1268                     VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID),
     1269                     uContextID));
     1270
     1271    GuestCtrlCallbacks::iterator it =
     1272        mObject.mCallbacks.find(VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID));
     1273    if (it != mObject.mCallbacks.end())
     1274    {
     1275        delete it->second;
     1276        mObject.mCallbacks.erase(it);
     1277
     1278        return VINF_SUCCESS;
     1279    }
     1280
     1281    return VERR_NOT_FOUND;
     1282}
     1283
     1284int GuestObject::callbackRemoveAll(void)
     1285{
     1286    int vrc = VINF_SUCCESS;
     1287
     1288    /*
     1289     * Cancel all callbacks + waiters.
     1290     * Note: Deleting them is the job of the caller!
     1291     */
     1292    for (GuestCtrlCallbacks::iterator itCallbacks = mObject.mCallbacks.begin();
     1293         itCallbacks != mObject.mCallbacks.end(); ++itCallbacks)
     1294    {
     1295        GuestCtrlCallback *pCallback = itCallbacks->second;
     1296        AssertPtr(pCallback);
     1297        int rc2 = pCallback->Cancel();
     1298        if (RT_SUCCESS(vrc))
     1299            vrc = rc2;
     1300    }
     1301    mObject.mCallbacks.clear();
     1302
     1303    return vrc;
     1304}
     1305
     1306int GuestObject::sendCommand(uint32_t uFunction,
     1307                             uint32_t uParms, PVBOXHGCMSVCPARM paParms)
     1308{
     1309    LogFlowThisFuncEnter();
     1310
     1311#ifndef VBOX_GUESTCTRL_TEST_CASE
     1312    ComObjPtr<Console> pConsole = mObject.mConsole;
     1313    Assert(!pConsole.isNull());
     1314
     1315    /* Forward the information to the VMM device. */
     1316    VMMDev *pVMMDev = pConsole->getVMMDev();
     1317    AssertPtr(pVMMDev);
     1318
     1319    LogFlowThisFunc(("uFunction=%RU32, uParms=%RU32\n", uFunction, uParms));
     1320    int vrc = pVMMDev->hgcmHostCall(HGCMSERVICE_NAME, uFunction, uParms, paParms);
     1321    if (RT_FAILURE(vrc))
     1322    {
     1323        /** @todo What to do here? */
     1324    }
     1325#else
     1326    /* Not needed within testcases. */
     1327    int vrc = VINF_SUCCESS;
     1328#endif
     1329    LogFlowFuncLeaveRC(vrc);
     1330    return vrc;
     1331}
     1332

  • trunk/src/VBox/Main/src-client/GuestFileImpl.cpp

    r43162 r44863  
    22/* $Id$ */
    33/** @file
    4  * VirtualBox Main - XXX.
     4 * VirtualBox Main - Guest file handling.
    55 */
    66
    77/*
    8  * Copyright (C) 2012 Oracle Corporation
     8 * Copyright (C) 2012-2013 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2424#include "GuestSessionImpl.h"
    2525#include "GuestCtrlImplPrivate.h"
     26#include "ConsoleImpl.h"
    2627
    2728#include "Global.h"
    2829#include "AutoCaller.h"
    2930
     31#include <iprt/file.h>
    3032#include <VBox/com/array.h>
    3133
    … …  
    5961/////////////////////////////////////////////////////////////////////////////
    6062
    61 int GuestFile::init(GuestSession *pSession, const Utf8Str &strPath,
    62                     const Utf8Str &strOpenMode, const Utf8Str &strDisposition, uint32_t uCreationMode,
    63                     int64_t iOffset, int *pGuestRc)
    64 {
     63int GuestFile::init(Console *pConsole, GuestSession *pSession, ULONG uFileID, const GuestFileOpenInfo &openInfo)
     64{
     65    LogFlowThisFunc(("pConsole=%p, pSession=%p, uFileID=%RU32, strPath=%s\n",
     66                     pConsole, pSession, uFileID, openInfo.mFileName.c_str()));
     67
     68    AssertPtrReturn(pConsole, VERR_INVALID_POINTER);
     69    AssertPtrReturn(pSession, VERR_INVALID_POINTER);
     70
    6571    /* Enclose the state transition NotReady->InInit->Ready. */
    6672    AutoInitSpan autoInitSpan(this);
    67     AssertReturn(autoInitSpan.isOk(), E_FAIL);
    68 
    69     mData.mSession = pSession;
    70     mData.mCreationMode = uCreationMode;
    71     mData.mDisposition = GuestFile::getDispositionFromString(strDisposition);
    72     mData.mFileName = strPath;
    73     mData.mInitialSize = 0;
    74     mData.mOpenMode = GuestFile::getOpenModeFromString(strOpenMode);
    75     mData.mOffset = iOffset;
    76 
    77     /** @todo Validate parameters! */
    78     /** @todo Implement guest side file handling! */
    79 
    80     /* Confirm a successful initialization when it's the case. */
    81     autoInitSpan.setSucceeded();
    82 
    83     return VINF_SUCCESS;
     73    AssertReturn(autoInitSpan.isOk(), VERR_OBJECT_DESTROYED);
     74
     75    int vrc = bindToSession(pConsole, pSession, uFileID /* Object ID */);
     76    if (RT_SUCCESS(vrc))
     77    {
     78        mData.mInitialSize = 0;
     79
     80        /* Confirm a successful initialization when it's the case. */
     81        autoInitSpan.setSucceeded();
     82        return vrc;
     83    }
     84
     85    autoInitSpan.setFailed();
     86    return vrc;
    8487}
    8588
    … …  
    97100        return;
    98101
     102#ifdef VBOX_WITH_GUEST_CONTROL
     103    /*
     104     * Cancel + remove all callbacks + waiters.
     105     * Note: Deleting them is the job of the caller!
     106     */
     107    callbackRemoveAll();
     108#endif
     109
    99110    LogFlowThisFuncLeave();
    100111}
    … …  
    115126    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    116127
    117     *aCreationMode = mData.mCreationMode;
    118 
    119     return S_OK;
    120 #endif /* VBOX_WITH_GUEST_CONTROL */
    121 }
    122 
     128    *aCreationMode = mData.mOpenInfo.mCreationMode;
     129
     130    return S_OK;
     131#endif /* VBOX_WITH_GUEST_CONTROL */
     132}
     133
     134/** @todo For 4.3: Change ULONG* to BSTR* ?*/
    123135STDMETHODIMP GuestFile::COMGETTER(Disposition)(ULONG *aDisposition)
    124136{
    … …  
    133145    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    134146
    135     *aDisposition = mData.mDisposition;
     147    *aDisposition = getDispositionFromString(mData.mOpenInfo.mDisposition);
    136148
    137149    return S_OK;
    … …  
    151163    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    152164
    153     mData.mFileName.cloneTo(aFileName);
     165    mData.mOpenInfo.mFileName.cloneTo(aFileName);
    154166
    155167    return S_OK;
    … …  
    187199    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    188200
    189     *aOffset = mData.mOffset;
    190 
    191     return S_OK;
    192 #endif /* VBOX_WITH_GUEST_CONTROL */
    193 }
    194 
     201    *aOffset = mData.mOffCurrent;
     202
     203    return S_OK;
     204#endif /* VBOX_WITH_GUEST_CONTROL */
     205}
     206
     207/** @todo For 4.3: Change ULONG* to BSTR* ?*/
    195208STDMETHODIMP GuestFile::COMGETTER(OpenMode)(ULONG *aOpenMode)
    196209{
    … …  
    205218    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    206219
    207     *aOpenMode = mData.mOpenMode;
     220    *aOpenMode = getOpenModeFromString(mData.mOpenInfo.mOpenMode);
    208221
    209222    return S_OK;
    … …  
    214227/////////////////////////////////////////////////////////////////////////////
    215228
     229int GuestFile::callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
     230{
     231#ifdef DEBUG
     232    LogFlowThisFunc(("strName=%s, uContextID=%RU32, uFunction=%RU32, pSvcCb=%p\n",
     233                     mData.mOpenInfo.mFileName.c_str(), pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb));
     234#endif
     235    AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
     236
     237    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     238
     239    /* Get the optional callback associated to this context ID.
     240     * The callback may not be around anymore if just kept locally by the caller when
     241     * doing the actual HGCM sending stuff. */
     242    GuestCtrlCallback *pCallback = NULL;
     243    GuestCtrlCallbacks::const_iterator it
     244        = mData.mCallbacks.find(VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(pCbCtx->uContextID));
     245    if (it != mData.mCallbacks.end())
     246    {
     247        pCallback = it->second;
     248        AssertPtr(pCallback);
     249#ifdef DEBUG
     250        LogFlowThisFunc(("pCallback=%p, CID=%RU32, Count=%RU32\n",
     251                         pCallback, pCbCtx->uContextID, VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(pCbCtx->uContextID)));
     252#endif
     253    }
     254
     255    int vrc;
     256    switch (pCbCtx->uFunction)
     257    {
     258        case GUEST_DISCONNECTED:
     259            vrc = onGuestDisconnected(pCbCtx, pCallback, pSvcCb); /* Affects all callbacks. */
     260            break;
     261
     262        case GUEST_FILE_NOTIFY:
     263            vrc = onFileNotify(pCbCtx, pCallback, pSvcCb);
     264            break;
     265
     266        default:
     267            /* Silently ignore not implemented functions. */
     268            vrc = VERR_NOT_SUPPORTED;
     269            break;
     270    }
     271
     272#ifdef DEBUG
     273    LogFlowFuncLeaveRC(vrc);
     274#endif
     275    return vrc;
     276}
     277
    216278/* static */
    217279uint32_t GuestFile::getDispositionFromString(const Utf8Str &strDisposition)
    … …  
    223285uint32_t GuestFile::getOpenModeFromString(const Utf8Str &strOpenMode)
    224286{
    225     return 0; /** @todo Implement me! */
     287    uint32_t uOpenMode = 0;
     288
     289    const char *pc = strOpenMode.c_str();
     290    while (*pc != '\0')
     291    {
     292        switch (*pc++)
     293        {
     294            case 'r':
     295                uOpenMode |= RTFILE_O_READ;
     296                break;
     297
     298            case 'w':
     299                uOpenMode |= RTFILE_O_WRITE;
     300                break;
     301
     302            default:
     303                /* Silently skip unknown values. */
     304                break;
     305        }
     306    }
     307
     308    return uOpenMode;
     309}
     310
     311int GuestFile::onFileNotify(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
     312{
     313    AssertPtrReturn(pCallback, VERR_INVALID_POINTER);
     314    AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
     315
     316    if (pSvcCbData->mParms < 3)
     317        return VERR_INVALID_PARAMETER;
     318
     319    uint32_t uType;
     320    void *pvData; uint32_t cbData;
     321    /* pSvcCb->mpaParms[0] always contains the context ID. */
     322    pSvcCbData->mpaParms[1].getUInt32(&uType);
     323    pSvcCbData->mpaParms[2].getPointer(&pvData, &cbData);
     324
     325    LogFlowThisFunc(("strName=%s, uType=%RU32, pvData=%p, cbData=%RU32, pCallback=%p\n",
     326                     mData.mOpenInfo.mFileName.c_str(), uType, pvData, cbData, pCallback));
     327
     328    /* Signal callback in every case (if available). */
     329    int vrc = VINF_SUCCESS;
     330    if (pCallback)
     331    {
     332        vrc = pCallback->SetData(pvData, cbData);
     333
     334        int rc2 = pCallback->Signal();
     335        if (RT_SUCCESS(vrc))
     336            vrc = rc2;
     337    }
     338
     339    LogFlowFuncLeaveRC(vrc);
     340    return vrc;
     341}
     342
     343int GuestFile::onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
     344{
     345    AssertPtrReturn(pCallback, VERR_INVALID_POINTER);
     346
     347    LogFlowThisFunc(("strFile=%s, pCallback=%p\n", mData.mOpenInfo.mFileName.c_str(), pCallback));
     348
     349    /* First, signal callback in every case. */
     350    if (pCallback)
     351        pCallback->Signal();
     352
     353    /** @todo More on onGuestDisconnected? */
     354    int vrc = VINF_SUCCESS;
     355
     356    LogFlowFuncLeaveRC(vrc);
     357    return vrc;
     358}
     359
     360int GuestFile::openFile(int *pGuestRc)
     361{
     362    LogFlowThisFunc(("strFile=%s, strOpenMode=%s, strDisposition=%s, uCreationMode=%RU32\n",
     363                     mData.mOpenInfo.mFileName.c_str(), mData.mOpenInfo.mOpenMode.c_str(),
     364                     mData.mOpenInfo.mDisposition.c_str(), mData.mOpenInfo.mCreationMode));
     365
     366    /* Wait until the caller function (if kicked off by a thread)
     367     * has returned and continue operation. */
     368    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     369
     370    AssertPtr(mData.mSession);
     371    uint32_t uProtocol = mData.mSession->getProtocolVersion();
     372    if (uProtocol < 2)
     373        return VERR_NOT_SUPPORTED;
     374
     375    int vrc = VINF_SUCCESS;
     376    uint32_t uContextID = 0;
     377
     378    GuestCtrlCallback *pCallbackOpen;
     379    try
     380    {
     381        pCallbackOpen = new GuestCtrlCallback();
     382    }
     383    catch(std::bad_alloc &)
     384    {
     385        vrc = VERR_NO_MEMORY;
     386    }
     387
     388    if (RT_SUCCESS(vrc))
     389    {
     390        /* Create callback and add it to the map. */
     391        vrc = pCallbackOpen->Init(CALLBACKTYPE_FILE_OPEN);
     392        if (RT_SUCCESS(vrc))
     393            vrc = callbackAdd(pCallbackOpen, &uContextID);
     394    }
     395
     396    if (RT_SUCCESS(vrc))
     397    {
     398        GuestSession *pSession = mData.mSession;
     399        AssertPtr(pSession);
     400
     401        const GuestCredentials &sessionCreds = pSession->getCredentials();
     402
     403        if (RT_SUCCESS(vrc))
     404        {
     405            /* Prepare HGCM call. */
     406            VBOXHGCMSVCPARM paParms[8];
     407            int i = 0;
     408            paParms[i++].setUInt32(uContextID);
     409            paParms[i++].setPointer((void*)mData.mOpenInfo.mFileName.c_str(),
     410                                    (ULONG)mData.mOpenInfo.mFileName.length() + 1);
     411            paParms[i++].setPointer((void*)mData.mOpenInfo.mOpenMode.c_str(),
     412                                    (ULONG)mData.mOpenInfo.mOpenMode.length() + 1);
     413            paParms[i++].setPointer((void*)mData.mOpenInfo.mDisposition.c_str(),
     414                                    (ULONG)mData.mOpenInfo.mDisposition.length() + 1);
     415            paParms[i++].setUInt32(mData.mOpenInfo.mCreationMode);
     416            paParms[i++].setUInt64(mData.mOpenInfo.mInitialOffset);
     417
     418            /* Note: Don't hold the write lock in here. */
     419            vrc = sendCommand(HOST_FILE_OPEN, i, paParms);
     420        }
     421
     422        /* Drop the write lock again before waiting. */
     423        alock.release();
     424
     425        if (RT_SUCCESS(vrc))
     426        {
     427            /*
     428             * Let's wait for the process being started.
     429             * Note: Be sure not keeping a AutoRead/WriteLock here.
     430             */
     431            LogFlowThisFunc(("Waiting for callback (30s) ...\n"));
     432            vrc = pCallbackOpen->Wait(30 *  1000 /* Wait 30s max. */);
     433            if (RT_SUCCESS(vrc)) /* Wait was successful, check for supplied information. */
     434            {
     435                int guestRc = pCallbackOpen->GetResultCode();
     436                if (RT_SUCCESS(guestRc))
     437                {
     438
     439                }
     440
     441                if (pGuestRc)
     442                    *pGuestRc = guestRc;
     443                LogFlowThisFunc(("Callback returned rc=%Rrc\n", guestRc));
     444            }
     445            else
     446                vrc = VERR_TIMEOUT;
     447        }
     448
     449        AutoWriteLock awlock(this COMMA_LOCKVAL_SRC_POS);
     450
     451        AssertPtr(pCallbackOpen);
     452        int rc2 = callbackRemove(uContextID);
     453        if (RT_SUCCESS(vrc))
     454            vrc = rc2;
     455    }
     456
     457    LogFlowFuncLeaveRC(vrc);
     458    return vrc;
    226459}
    227460

  • trunk/src/VBox/Main/src-client/GuestProcessImpl.cpp

    r43301 r44863  
    22/* $Id$ */
    33/** @file
    4  * VirtualBox Main - XXX.
     4 * VirtualBox Main - Guest process handling.
    55 */
    66
    77/*
    8  * Copyright (C) 2012 Oracle Corporation
     8 * Copyright (C) 2012-2013 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    3636#include "Global.h"
    3737#include "AutoCaller.h"
    38 #include "VMMDev.h"
    3938
    4039#include <memory> /* For auto_ptr. */
    … …  
    4241#include <iprt/asm.h>
    4342#include <iprt/getopt.h>
    44 #include <VBox/VMMDev.h>
    4543#include <VBox/com/array.h>
    4644
    … …  
    8078};
    8179
    82 
    8380// constructor / destructor
    8481/////////////////////////////////////////////////////////////////////////////
    … …  
    9188
    9289    mData.mExitCode = 0;
    93     mData.mNextContextID = 0;
    9490    mData.mPID = 0;
    95     mData.mProcessID = 0;
    9691    mData.mRC = VINF_SUCCESS;
    9792    mData.mStatus = ProcessStatus_Undefined;
    … …  
    115110/////////////////////////////////////////////////////////////////////////////
    116111
    117 int GuestProcess::init(Console *aConsole, GuestSession *aSession, ULONG aProcessID, const GuestProcessStartupInfo &aProcInfo)
     112int GuestProcess::init(Console *aConsole, GuestSession *aSession,
     113                       ULONG aProcessID, const GuestProcessStartupInfo &aProcInfo)
    118114{
    119115    LogFlowThisFunc(("aConsole=%p, aSession=%p, aProcessID=%RU32\n",
    120116                     aConsole, aSession, aProcessID));
    121117
     118    AssertPtrReturn(aConsole, VERR_INVALID_POINTER);
    122119    AssertPtrReturn(aSession, VERR_INVALID_POINTER);
    123120
    … …  
    126123    AssertReturn(autoInitSpan.isOk(), VERR_OBJECT_DESTROYED);
    127124
    128     mData.mConsole = aConsole;
    129     mData.mParent = aSession;
    130     mData.mProcessID = aProcessID;
    131     mData.mProcess = aProcInfo;
    132     /* Everything else will be set by the actual starting routine. */
    133 
    134     /* Confirm a successful initialization when it's the case. */
    135     autoInitSpan.setSucceeded();
    136 
    137     return VINF_SUCCESS;
     125    int vrc = bindToSession(aConsole, aSession, aProcessID /* Object ID */);
     126    if (RT_SUCCESS(vrc))
     127    {
     128        mData.mProcess = aProcInfo;
     129        /* Everything else will be set by the actual starting routine. */
     130
     131        /* Confirm a successful initialization when it's the case. */
     132        autoInitSpan.setSucceeded();
     133
     134        return vrc;
     135    }
     136
     137    autoInitSpan.setFailed();
     138    return vrc;
    138139}
    139140
    … …  
    156157#ifdef VBOX_WITH_GUEST_CONTROL
    157158    /*
    158      * Cancel all callbacks + waiters.
     159     * Cancel + remove all callbacks + waiters.
    159160     * Note: Deleting them is the job of the caller!
    160161     */
    161     for (GuestCtrlCallbacks::iterator itCallbacks = mData.mCallbacks.begin();
    162          itCallbacks != mData.mCallbacks.end(); ++itCallbacks)
    163     {
    164         GuestCtrlCallback *pCallback = itCallbacks->second;
    165         AssertPtr(pCallback);
    166         int rc2 = pCallback->Cancel();
    167         if (RT_SUCCESS(vrc))
    168             vrc = rc2;
    169     }
    170     mData.mCallbacks.clear();
     162    callbackRemoveAll();
    171163
    172164    if (mData.mWaitEvent)
    … …  
    343335/////////////////////////////////////////////////////////////////////////////
    344336
    345 inline int GuestProcess::callbackAdd(GuestCtrlCallback *pCallback, uint32_t *puContextID)
    346 {
    347     const ComObjPtr<GuestSession> pSession(mData.mParent);
    348     Assert(!pSession.isNull());
    349     ULONG uSessionID = 0;
    350     HRESULT hr = pSession->COMGETTER(Id)(&uSessionID);
    351     ComAssertComRC(hr);
    352 
    353     /* Create a new context ID and assign it. */
    354     int vrc = VERR_NOT_FOUND;
    355 
    356     ULONG uCount = mData.mNextContextID++;
    357     ULONG uNewContextID = 0;
    358     ULONG uTries = 0;
    359     for (;;)
    360     {
    361         if (uCount == VBOX_GUESTCTRL_MAX_CONTEXTS)
    362             uCount = 0;
    363 
    364         /* Create a new context ID ... */
    365         uNewContextID = VBOX_GUESTCTRL_CONTEXTID_MAKE(uSessionID,
    366                                                       mData.mProcessID, uCount);
    367 
    368         /* Is the context ID already used?  Try next ID ... */
    369         if (!callbackExists(uCount))
    370         {
    371             /* Callback with context ID was not found. This means
    372              * we can use this context ID for our new callback we want
    373              * to add below. */
    374             vrc = VINF_SUCCESS;
    375             break;
    376         }
    377 
    378         uCount++;
    379         if (++uTries == UINT32_MAX)
    380             break; /* Don't try too hard. */
    381     }
    382 
    383     if (RT_SUCCESS(vrc))
    384     {
    385         /* Add callback with new context ID to our callback map.
    386          * Note: This is *not* uNewContextID (which also includes
    387          *       the session + process ID), just the context count
    388          *       will be used here. */
    389         mData.mCallbacks[uCount] = pCallback;
    390         Assert(mData.mCallbacks.size());
    391 
    392         /* Report back new context ID. */
    393         if (puContextID)
    394             *puContextID = uNewContextID;
    395 
    396         LogFlowThisFunc(("Added new callback (Session: %RU32, Process: %RU32, Count=%RU32) CID=%RU32\n",
    397                          uSessionID, mData.mProcessID, uCount, uNewContextID));
    398     }
    399 
    400     return vrc;
    401 }
    402 
    403 int GuestProcess::callbackDispatcher(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData)
    404 {
     337int GuestProcess::callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
     338{
     339    AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
     340    AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
    405341#ifdef DEBUG
    406     LogFlowThisFunc(("uPID=%RU32, uContextID=%RU32, uFunction=%RU32, pvData=%p, cbData=%RU32\n",
    407                      mData.mPID, uContextID, uFunction, pvData, cbData));
     342    LogFlowThisFunc(("uPID=%RU32, uContextID=%RU32, uFunction=%RU32, pSvcCb=%p\n",
     343                     mData.mPID, pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb));
    408344#endif
    409345
    410     AssertPtrReturn(pvData, VERR_INVALID_POINTER);
    411     AssertReturn(cbData, VERR_INVALID_PARAMETER);
    412 
    413346    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    414 
    415     int vrc;
    416347
    417348    /* Get the optional callback associated to this context ID.
    … …  
    420351    GuestCtrlCallback *pCallback = NULL;
    421352    GuestCtrlCallbacks::const_iterator it
    422         = mData.mCallbacks.find(VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID));
    423     if (it != mData.mCallbacks.end())
     353        = mObject.mCallbacks.find(VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(pCbCtx->uContextID));
     354    if (it != mObject.mCallbacks.end())
    424355    {
    425356        pCallback = it->second;
    … …  
    427358#ifdef DEBUG
    428359        LogFlowThisFunc(("pCallback=%p, CID=%RU32, Count=%RU32\n",
    429                          pCallback, uContextID, VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID)));
     360                         pCallback, pCbCtx->uContextID, VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(pCbCtx->uContextID)));
    430361#endif
    431362    }
    432363
    433     switch (uFunction)
     364    int vrc;
     365    switch (pCbCtx->uFunction)
    434366    {
    435367        case GUEST_DISCONNECTED:
    436368        {
    437             PCALLBACKDATACLIENTDISCONNECTED pCallbackData = reinterpret_cast<PCALLBACKDATACLIENTDISCONNECTED>(pvData);
    438             AssertPtr(pCallbackData);
    439             AssertReturn(sizeof(CALLBACKDATACLIENTDISCONNECTED) == cbData, VERR_INVALID_PARAMETER);
    440             AssertReturn(CALLBACKDATAMAGIC_CLIENT_DISCONNECTED == pCallbackData->hdr.u32Magic, VERR_INVALID_PARAMETER);
    441 
    442             vrc = onGuestDisconnected(pCallback, pCallbackData); /* Affects all callbacks. */
    443             break;
    444         }
    445 
    446         case GUEST_EXEC_SEND_STATUS:
    447         {
    448             PCALLBACKDATAEXECSTATUS pCallbackData = reinterpret_cast<PCALLBACKDATAEXECSTATUS>(pvData);
    449             AssertPtr(pCallbackData);
    450             AssertReturn(sizeof(CALLBACKDATAEXECSTATUS) == cbData, VERR_INVALID_PARAMETER);
    451             AssertReturn(CALLBACKDATAMAGIC_EXEC_STATUS == pCallbackData->hdr.u32Magic, VERR_INVALID_PARAMETER);
    452 
    453             vrc = onProcessStatusChange(pCallback, pCallbackData);
    454             break;
    455         }
    456 
    457         case GUEST_EXEC_SEND_OUTPUT:
    458         {
    459             PCALLBACKDATAEXECOUT pCallbackData = reinterpret_cast<PCALLBACKDATAEXECOUT>(pvData);
    460             AssertPtr(pCallbackData);
    461             AssertReturn(sizeof(CALLBACKDATAEXECOUT) == cbData, VERR_INVALID_PARAMETER);
    462             AssertReturn(CALLBACKDATAMAGIC_EXEC_OUT == pCallbackData->hdr.u32Magic, VERR_INVALID_PARAMETER);
    463 
    464             vrc = onProcessOutput(pCallback, pCallbackData);
    465             break;
    466         }
    467 
    468         case GUEST_EXEC_SEND_INPUT_STATUS:
    469         {
    470             PCALLBACKDATAEXECINSTATUS pCallbackData = reinterpret_cast<PCALLBACKDATAEXECINSTATUS>(pvData);
    471             AssertPtr(pCallbackData);
    472             AssertReturn(sizeof(CALLBACKDATAEXECINSTATUS) == cbData, VERR_INVALID_PARAMETER);
    473             AssertReturn(CALLBACKDATAMAGIC_EXEC_IN_STATUS == pCallbackData->hdr.u32Magic, VERR_INVALID_PARAMETER);
    474 
    475             vrc = onProcessInputStatus(pCallback, pCallbackData);
     369            vrc = onGuestDisconnected(pCbCtx, pCallback, pSvcCb); /* Affects all callbacks. */
     370            break;
     371        }
     372
     373        case GUEST_EXEC_STATUS:
     374        {
     375            vrc = onProcessStatusChange(pCbCtx, pCallback, pSvcCb);
     376            break;
     377        }
     378
     379        case GUEST_EXEC_OUTPUT:
     380        {
     381            vrc = onProcessOutput(pCbCtx, pCallback, pSvcCb);
     382            break;
     383        }
     384
     385        case GUEST_EXEC_INPUT_STATUS:
     386        {
     387            vrc = onProcessInputStatus(pCbCtx, pCallback, pSvcCb);
    476388            break;
    477389        }
    … …  
    479391        default:
    480392            /* Silently ignore not implemented functions. */
    481             vrc = VERR_NOT_IMPLEMENTED;
     393            vrc = VERR_NOT_SUPPORTED;
    482394            break;
    483395    }
    … …  
    487399#endif
    488400    return vrc;
    489 }
    490 
    491 inline bool GuestProcess::callbackExists(uint32_t uContextID)
    492 {
    493     GuestCtrlCallbacks::const_iterator it =
    494         mData.mCallbacks.find(VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID));
    495     return (it == mData.mCallbacks.end()) ? false : true;
    496 }
    497 
    498 inline int GuestProcess::callbackRemove(uint32_t uContextID)
    499 {
    500     LogFlowThisFunc(("Removing callback (Session: %RU32, Process: %RU32, Count=%RU32) CID=%RU32\n",
    501                      VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(uContextID),
    502                      VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(uContextID),
    503                      VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID),
    504                      uContextID));
    505 
    506     GuestCtrlCallbacks::iterator it =
    507         mData.mCallbacks.find(VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(uContextID));
    508     if (it != mData.mCallbacks.end())
    509     {
    510         delete it->second;
    511         mData.mCallbacks.erase(it);
    512 
    513         return VINF_SUCCESS;
    514     }
    515 
    516     return VERR_NOT_FOUND;
    517401}
    518402
    … …  
    538422
    539423         */
    540         if (mData.mParent->getProtocolVersion() < 2)
     424        if (mObject.mSession->getProtocolVersion() < 2)
    541425        {
    542426            /* Simply ignore the stale requests. */
    … …  
    613497
    614498        default:
    615             strError += Utf8StrFmt(tr("%Rrc"), guestRc);
     499            strError += Utf8StrFmt("%Rrc", guestRc);
    616500            break;
    617501    }
    … …  
    640524}
    641525
    642 int GuestProcess::onGuestDisconnected(GuestCtrlCallback *pCallback, PCALLBACKDATACLIENTDISCONNECTED pData)
    643 {
    644     /* pCallback is optional. */
    645     AssertPtrReturn(pData, VERR_INVALID_POINTER);
    646 
    647     LogFlowThisFunc(("uPID=%RU32, pCallback=%p, pData=%p\n", mData.mPID, pCallback, pData));
     526int GuestProcess::onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx,
     527                                      GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
     528{
     529    AssertPtrReturn(pCallback, VERR_INVALID_POINTER);
     530
     531    LogFlowThisFunc(("uPID=%RU32, pCallback=%p\n", mData.mPID, pCallback));
    648532
    649533    mData.mStatus = ProcessStatus_Down;
    … …  
    668552}
    669553
    670 int GuestProcess::onProcessInputStatus(GuestCtrlCallback *pCallback, PCALLBACKDATAEXECINSTATUS pData)
    671 {
    672     /* pCallback is optional. */
    673     AssertPtrReturn(pData, VERR_INVALID_POINTER);
    674 
    675     LogFlowThisFunc(("uPID=%RU32, uStatus=%RU32, uFlags=%RU32, cbProcessed=%RU32, pCallback=%p, pData=%p\n",
    676                      mData.mPID, pData->u32Status, pData->u32Flags, pData->cbProcessed, pCallback, pData));
    677 
    678     int vrc = checkPID(pData->u32PID);
     554int GuestProcess::onProcessInputStatus(PVBOXGUESTCTRLHOSTCBCTX pCbCtx,
     555                                       GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
     556{
     557    AssertPtrReturn(pCallback, VERR_INVALID_POINTER);
     558    AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
     559
     560    if (pSvcCbData->mParms < 5)
     561        return VERR_INVALID_PARAMETER;
     562
     563    CALLBACKDATA_PROC_INPUT dataCb;
     564    /* pSvcCb->mpaParms[0] always contains the context ID. */
     565    pSvcCbData->mpaParms[1].getUInt32(&dataCb.uPID);
     566    pSvcCbData->mpaParms[2].getUInt32(&dataCb.uStatus);
     567    pSvcCbData->mpaParms[3].getUInt32(&dataCb.uFlags);
     568    pSvcCbData->mpaParms[4].getUInt32(&dataCb.uProcessed);
     569
     570    LogFlowThisFunc(("uPID=%RU32, uStatus=%RU32, uFlags=%RI32, cbProcessed=%RU32, pCallback=%p\n",
     571                     dataCb.uPID, dataCb.uStatus, dataCb.uFlags, dataCb.uProcessed, pCallback));
     572
     573    int vrc = checkPID(dataCb.uPID);
    679574    if (RT_FAILURE(vrc))
    680575        return vrc;
    … …  
    683578    if (pCallback)
    684579    {
    685         vrc = pCallback->SetData(pData, sizeof(CALLBACKDATAEXECINSTATUS));
     580        vrc = pCallback->SetData(&dataCb, sizeof(dataCb));
    686581
    687582        int rc2 = pCallback->Signal();
    … …  
    704599}
    705600
    706 int GuestProcess::onProcessNotifyIO(GuestCtrlCallback *pCallback, PCALLBACKDATAEXECSTATUS pData)
     601int GuestProcess::onProcessNotifyIO(PVBOXGUESTCTRLHOSTCBCTX pCbCtx,
     602                                    GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
     603{
     604    AssertPtrReturn(pCallback, VERR_INVALID_POINTER);
     605
     606    return VERR_NOT_IMPLEMENTED;
     607}
     608
     609int GuestProcess::onProcessStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx,
     610                                        GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
    707611{
    708612    /* pCallback is optional. */
    709     AssertPtrReturn(pData, VERR_INVALID_POINTER);
    710 
    711     return 0;
    712 }
    713 
    714 int GuestProcess::onProcessStatusChange(GuestCtrlCallback *pCallback, PCALLBACKDATAEXECSTATUS pData)
    715 {
    716     /* pCallback is optional. */
    717     AssertPtrReturn(pData, VERR_INVALID_POINTER);
    718 
    719     LogFlowThisFunc(("uPID=%RU32, uStatus=%RU32, uFlags=%RU32, pCallback=%p, pData=%p\n",
    720                      pData->u32PID, pData->u32Status, pData->u32Flags, pCallback, pData));
    721 
    722     int vrc = checkPID(pData->u32PID);
     613    AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
     614
     615    if (pSvcCbData->mParms < 5)
     616        return VERR_INVALID_PARAMETER;
     617
     618    CALLBACKDATA_PROC_STATUS dataCb;
     619    /* pSvcCb->mpaParms[0] always contains the context ID. */
     620    pSvcCbData->mpaParms[1].getUInt32(&dataCb.uPID);
     621    pSvcCbData->mpaParms[2].getUInt32(&dataCb.uStatus);
     622    pSvcCbData->mpaParms[3].getUInt32(&dataCb.uFlags);
     623    pSvcCbData->mpaParms[4].getPointer(&dataCb.pvData, &dataCb.cbData);
     624
     625    LogFlowThisFunc(("uPID=%RU32, uStatus=%RU32, uFlags=%RU32, pCallback=%p, pSvcCbData=%p\n",
     626                     dataCb.uPID, dataCb.uStatus, dataCb.uFlags, pCallback, pSvcCbData));
     627
     628    int vrc = checkPID(dataCb.uPID);
    723629    if (RT_FAILURE(vrc))
    724630        return vrc;
    … …  
    732638    uint32_t uWaitFlags = mData.mWaitEvent
    733639                        ? mData.mWaitEvent->GetWaitFlags() : 0;
    734     switch (pData->u32Status)
     640    switch (dataCb.uStatus)
    735641    {
    736642        case PROC_STS_STARTED:
    … …  
    744650
    745651            procStatus = ProcessStatus_Started;
    746             mData.mPID = pData->u32PID; /* Set the process PID. */
     652            mData.mPID = dataCb.uPID; /* Set the process PID. */
    747653            break;
    748654        }
    … …  
    754660
    755661            procStatus = ProcessStatus_TerminatedNormally;
    756             mData.mExitCode = pData->u32Flags; /* Contains the exit code. */
     662            mData.mExitCode = dataCb.uFlags; /* Contains the exit code. */
    757663            break;
    758664        }
    … …  
    764670
    765671            procStatus = ProcessStatus_TerminatedSignal;
    766             mData.mExitCode = pData->u32Flags; /* Contains the signal. */
     672            mData.mExitCode = dataCb.uFlags; /* Contains the signal. */
    767673            break;
    768674        }
    … …  
    813719            waitRes = ProcessWaitResult_Error;
    814720
    815             procRc = pData->u32Flags; /** @todo pData->u32Flags: int vs. uint32 -- IPRT errors are *negative* !!! */
     721            procRc = dataCb.uFlags; /* mFlags contains the IPRT error sent from the guest. */
    816722            procStatus = ProcessStatus_Error;
    817723            break;
    … …  
    842748     */
    843749    if (pCallback)
    844         vrc = pCallback->Signal(procRc);
     750    {
     751        rc2 = pCallback->Signal(procRc);
     752        if (RT_SUCCESS(vrc))
     753            vrc = rc2;
     754    }
    845755
    846756    if (fSignalWaiters)
    … …  
    855765}
    856766
    857 int GuestProcess::onProcessOutput(GuestCtrlCallback *pCallback, PCALLBACKDATAEXECOUT pData)
    858 {
    859     /* pCallback is optional. */
    860     AssertPtrReturn(pData, VERR_INVALID_POINTER);
    861 
    862     LogFlowThisFunc(("uPID=%RU32, uHandle=%RU32, uFlags=%RU32, pvData=%p, cbData=%RU32, pCallback=%p, pData=%p\n",
    863                      mData.mPID, pData->u32HandleId, pData->u32Flags, pData->pvData, pData->cbData, pCallback, pData));
    864 
    865     int vrc = checkPID(pData->u32PID);
     767int GuestProcess::onProcessOutput(PVBOXGUESTCTRLHOSTCBCTX pCbCtx,
     768                                  GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
     769{
     770    AssertPtrReturn(pCallback, VERR_INVALID_POINTER);
     771    AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
     772
     773    if (pSvcCbData->mParms < 5)
     774        return VERR_INVALID_PARAMETER;
     775
     776    CALLBACKDATA_PROC_OUTPUT dataCb;
     777    /* pSvcCb->mpaParms[0] always contains the context ID. */
     778    pSvcCbData->mpaParms[1].getUInt32(&dataCb.uPID);
     779    pSvcCbData->mpaParms[2].getUInt32(&dataCb.uHandle);
     780    pSvcCbData->mpaParms[3].getUInt32(&dataCb.uFlags);
     781    pSvcCbData->mpaParms[4].getPointer(&dataCb.pvData, &dataCb.cbData);
     782
     783    LogFlowThisFunc(("uPID=%RU32, uHandle=%RU32, uFlags=%RI32, pvData=%p, cbData=%RU32, pCallback=%p\n",
     784                     dataCb.uPID, dataCb.uHandle, dataCb.uFlags, dataCb.pvData, dataCb.cbData, pCallback));
     785
     786    int vrc = checkPID(dataCb.uPID);
    866787    if (RT_FAILURE(vrc))
    867788        return vrc;
    … …  
    870791    if (pCallback)
    871792    {
    872         vrc = pCallback->SetData(pData, sizeof(CALLBACKDATAEXECOUT));
     793        vrc = pCallback->SetData(&dataCb, sizeof(dataCb));
    873794
    874795        int rc2 = pCallback->Signal();
    … …  
    888809    }
    889810    else if (   (uWaitFlags & ProcessWaitForFlag_StdOut)
    890              && (pData->u32HandleId == OUTPUT_HANDLE_ID_STDOUT))
     811             && (dataCb.uHandle == OUTPUT_HANDLE_ID_STDOUT))
    891812    {
    892813        fSignal = TRUE;
    893814    }
    894815    else if (   (uWaitFlags & ProcessWaitForFlag_StdErr)
    895              && (pData->u32HandleId == OUTPUT_HANDLE_ID_STDERR))
     816             && (dataCb.uHandle == OUTPUT_HANDLE_ID_STDERR))
    896817    {
    897818        fSignal = TRUE;
    … …  
    901822    {
    902823        int rc2;
    903         if (pData->u32HandleId == OUTPUT_HANDLE_ID_STDOUT)
     824        if (dataCb.uHandle == OUTPUT_HANDLE_ID_STDOUT)
    904825            rc2 = signalWaiters(ProcessWaitResult_StdOut);
    905         else
     826        else if (dataCb.uHandle == OUTPUT_HANDLE_ID_STDERR)
    906827            rc2 = signalWaiters(ProcessWaitResult_StdErr);
    907828        if (RT_SUCCESS(vrc))
    … …  
    950871    if (RT_SUCCESS(vrc))
    951872    {
    952         vrc = pCallbackRead->Init(VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT);
     873        vrc = pCallbackRead->Init(CALLBACKTYPE_PROC_OUTPUT);
    953874        if (RT_SUCCESS(vrc))
    954875            vrc = callbackAdd(pCallbackRead, &uContextID);
    … …  
    968889
    969890        vrc = sendCommand(HOST_EXEC_GET_OUTPUT, i, paParms);
     891        if (RT_FAILURE(vrc))
     892        {
     893            int rc2 = setProcessStatus(ProcessStatus_Error, vrc);
     894            AssertRC(rc2);
     895        }
    970896    }
    971897
    … …  
    985911            if (RT_SUCCESS(guestRc))
    986912            {
    987                 Assert(pCallbackRead->GetDataSize() == sizeof(CALLBACKDATAEXECOUT));
    988                 PCALLBACKDATAEXECOUT pData = (PCALLBACKDATAEXECOUT)pCallbackRead->GetDataRaw();
     913                Assert(pCallbackRead->GetDataSize() == sizeof(CALLBACKDATA_PROC_OUTPUT));
     914                PCALLBACKDATA_PROC_OUTPUT pData = (PCALLBACKDATA_PROC_OUTPUT)pCallbackRead->GetDataRaw();
    989915                AssertPtr(pData);
    990916
    … …  
    1020946}
    1021947
    1022 int GuestProcess::sendCommand(uint32_t uFunction,
    1023                               uint32_t uParms, PVBOXHGCMSVCPARM paParms)
    1024 {
    1025     LogFlowThisFuncEnter();
    1026 
    1027     ComObjPtr<Console> pConsole = mData.mConsole;
    1028     Assert(!pConsole.isNull());
    1029 
    1030     /* Forward the information to the VMM device. */
    1031     VMMDev *pVMMDev = pConsole->getVMMDev();
    1032     AssertPtr(pVMMDev);
    1033 
    1034     LogFlowThisFunc(("uFunction=%RU32, uParms=%RU32\n", uFunction, uParms));
    1035     int vrc = pVMMDev->hgcmHostCall("VBoxGuestControlSvc", uFunction, uParms, paParms);
    1036     if (RT_FAILURE(vrc))
    1037     {
    1038         int rc2 = setProcessStatus(ProcessStatus_Error, vrc);
    1039         AssertRC(rc2);
    1040     }
    1041 
    1042     LogFlowFuncLeaveRC(vrc);
    1043     return vrc;
    1044 }
    1045 
    1046948/* Does not do locking; caller is responsible for that! */
    1047949int GuestProcess::setProcessStatus(ProcessStatus_T procStatus, int procRc)
    … …  
    1050952                     mData.mStatus, procStatus, procRc));
    1051953
    1052 #ifdef DEBUG
     954#if 0
    1053955    if (procStatus == ProcessStatus_Error)
    1054956    {
    … …  
    11181020
    11191021        /* Create callback and add it to the map. */
    1120         vrc = pCallbackStart->Init(VBOXGUESTCTRLCALLBACKTYPE_EXEC_START);
     1022        vrc = pCallbackStart->Init(CALLBACKTYPE_PROC_STATUS);
    11211023        if (RT_SUCCESS(vrc))
    11221024            vrc = callbackAdd(pCallbackStart, &uContextID);
    … …  
    11251027    if (RT_SUCCESS(vrc))
    11261028    {
    1127         GuestSession *pSession = mData.mParent;
     1029        GuestSession *pSession = mObject.mSession;
    11281030        AssertPtr(pSession);
    11291031
    … …  
    11751077        if (RT_SUCCESS(vrc))
    11761078        {
     1079            AssertPtr(mObject.mSession);
     1080            uint32_t uProtocol = mObject.mSession->getProtocolVersion();
     1081
    11771082            /* Prepare HGCM call. */
    1178             VBOXHGCMSVCPARM paParms[15];
     1083            VBOXHGCMSVCPARM paParms[16];
    11791084            int i = 0;
    11801085            paParms[i++].setUInt32(uContextID);
    … …  
    11871092            paParms[i++].setUInt32(cbEnv);
    11881093            paParms[i++].setPointer((void*)pvEnv, cbEnv);
    1189             paParms[i++].setPointer((void*)sessionCreds.mUser.c_str(), (ULONG)sessionCreds.mUser.length() + 1);
    1190             paParms[i++].setPointer((void*)sessionCreds.mPassword.c_str(), (ULONG)sessionCreds.mPassword.length() + 1);
    1191             /** @todo New command needs the domain as well! */
    1192 
     1094            if (uProtocol < 2)
     1095            {
     1096                /* In protocol v1 (VBox < 4.3) the credentials were part of the execution
     1097                 * call. In newer protocols these credentials are part of the opened guest
     1098                 * session, so not needed anymore here. */
     1099                paParms[i++].setPointer((void*)sessionCreds.mUser.c_str(), (ULONG)sessionCreds.mUser.length() + 1);
     1100                paParms[i++].setPointer((void*)sessionCreds.mPassword.c_str(), (ULONG)sessionCreds.mPassword.length() + 1);
     1101            }
    11931102            /*
    11941103             * If the WaitForProcessStartOnly flag is set, we only want to define and wait for a timeout
    … …  
    12011110            else
    12021111                paParms[i++].setUInt32(mData.mProcess.mTimeoutMS);
    1203 
    1204             /* Note: Don't hold the write lock in here, because setErrorInternal */
     1112            if (uProtocol >= 2)
     1113            {
     1114                paParms[i++].setUInt32(mData.mProcess.mPriority);
     1115                /* CPU affinity: We only support one CPU affinity block at the moment,
     1116                 * so that makes up to 64 CPUs total. This can be more in the future. */
     1117                paParms[i++].setUInt32(1);
     1118                /* The actual CPU affinity blocks. */
     1119                paParms[i++].setPointer((void*)&mData.mProcess.mAffinity, sizeof(mData.mProcess.mAffinity));
     1120            }
     1121
     1122            /* Note: Don't hold the write lock in here. */
    12051123            vrc = sendCommand(HOST_EXEC_CMD, i, paParms);
     1124            if (RT_FAILURE(vrc))
     1125            {
     1126                int rc2 = setProcessStatus(ProcessStatus_Error, vrc);
     1127                AssertRC(rc2);
     1128            }
    12061129        }
    12071130
    … …  
    12991222}
    13001223
    1301 int GuestProcess::terminateProcess(void)
     1224int GuestProcess::terminateProcess(int *pGuestRc)
    13021225{
    13031226    LogFlowThisFuncEnter();
    … …  
    13051228    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    13061229
    1307     if (mData.mParent->getProtocolVersion() < 2)
     1230    if (mObject.mSession->getProtocolVersion() < 2)
    13081231        return VERR_NOT_SUPPORTED;
    13091232
    1310     LogFlowThisFuncLeave();
    1311     return VERR_NOT_IMPLEMENTED;
     1233    if (mData.mStatus != ProcessStatus_Started)
     1234        return VINF_SUCCESS; /* Nothing to do (anymore). */
     1235
     1236    int vrc = VINF_SUCCESS;
     1237
     1238    GuestCtrlCallback *pCallbackTerminate = NULL;
     1239    try
     1240    {
     1241        pCallbackTerminate = new GuestCtrlCallback();
     1242    }
     1243    catch(std::bad_alloc &)
     1244    {
     1245        vrc = VERR_NO_MEMORY;
     1246    }
     1247
     1248    /* Create callback and add it to the map. */
     1249    uint32_t uContextID = 0;
     1250    if (RT_SUCCESS(vrc))
     1251        vrc = callbackAdd(pCallbackTerminate, &uContextID);
     1252
     1253    alock.release(); /* Drop the write lock again. */
     1254
     1255    if (RT_SUCCESS(vrc))
     1256    {
     1257        VBOXHGCMSVCPARM paParms[5];
     1258
     1259        int i = 0;
     1260        paParms[i++].setUInt32(uContextID);
     1261        paParms[i++].setUInt32(mData.mPID);
     1262
     1263        //vrc = sendCommand(HOST_EXEC_TERMINATE, i, paParms);
     1264    }
     1265
     1266    if (RT_SUCCESS(vrc))
     1267    {
     1268        /*
     1269         * Let's wait for the process being terminated.
     1270         * Note: Be sure not keeping a AutoRead/WriteLock here.
     1271         */
     1272        LogFlowThisFunc(("Waiting for callback (30s) ...\n"));
     1273        vrc = pCallbackTerminate->Wait(30 * 1000);
     1274        if (RT_SUCCESS(vrc)) /* Wait was successful, check for supplied information. */
     1275        {
     1276            int guestRc = pCallbackTerminate->GetResultCode();
     1277            LogFlowThisFunc(("Callback returned rc=%Rrc\n", guestRc));
     1278            if (pGuestRc)
     1279                *pGuestRc = guestRc;
     1280        }
     1281    }
     1282
     1283    alock.acquire();
     1284
     1285    AssertPtr(pCallbackTerminate);
     1286    int rc2 = callbackRemove(uContextID);
     1287    if (RT_SUCCESS(vrc))
     1288        vrc = rc2;
     1289
     1290    LogFlowFuncLeaveRC(vrc);
     1291    return vrc;
    13121292}
    13131293
    … …  
    14151395    /* Filter out waits which are *not* supported using
    14161396     * older guest control Guest Additions. */
    1417     if (mData.mParent->getProtocolVersion() < 2)
     1397    if (mObject.mSession->getProtocolVersion() < 2)
    14181398    {
    14191399        if (   waitResult == ProcessWaitResult_None
    … …  
    14421422    }
    14431423
    1444     if (mData.mWaitCount > 0)
     1424    if (mData.mWaitCount > 0) /* We only support one waiting caller a time at the moment. */
    14451425        return VERR_ALREADY_EXISTS;
    14461426    mData.mWaitCount++;
    … …  
    15281508    if (RT_SUCCESS(vrc))
    15291509    {
    1530         vrc = pCallbackWrite->Init(VBOXGUESTCTRLCALLBACKTYPE_EXEC_INPUT_STATUS);
     1510        vrc = pCallbackWrite->Init(CALLBACKTYPE_PROC_INPUT);
    15311511        if (RT_SUCCESS(vrc))
    15321512            vrc = callbackAdd(pCallbackWrite, &uContextID);
    … …  
    15471527
    15481528        vrc = sendCommand(HOST_EXEC_SET_INPUT, i, paParms);
     1529        if (RT_FAILURE(vrc))
     1530        {
     1531            int rc2 = setProcessStatus(ProcessStatus_Error, vrc);
     1532            AssertRC(rc2);
     1533        }
    15491534    }
    15501535
    … …  
    15641549            if (RT_SUCCESS(guestRc))
    15651550            {
    1566                 Assert(pCallbackWrite->GetDataSize() == sizeof(CALLBACKDATAEXECINSTATUS));
    1567                 PCALLBACKDATAEXECINSTATUS pData = (PCALLBACKDATAEXECINSTATUS)pCallbackWrite->GetDataRaw();
     1551                Assert(pCallbackWrite->GetDataSize() == sizeof(CALLBACKDATA_PROC_INPUT));
     1552                PCALLBACKDATA_PROC_INPUT pData = (PCALLBACKDATA_PROC_INPUT)pCallbackWrite->GetDataRaw();
    15681553                AssertPtr(pData);
    15691554
    15701555                uint32_t cbWritten = 0;
    1571                 switch (pData->u32Status)
     1556                switch (pData->uStatus)
    15721557                {
    15731558                    case INPUT_STS_WRITTEN:
    1574                         cbWritten = pData->cbProcessed;
     1559                        cbWritten = pData->uProcessed;
    15751560                        break;
    15761561
    15771562                    case INPUT_STS_ERROR:
    1578                         vrc = pData->u32Flags; /** @todo Fix int vs. uint32_t! */
     1563                        vrc = pData->uFlags; /** @todo Fix int vs. uint32_t! */
    15791564                        break;
    15801565
    … …  
    16791664    HRESULT hr = S_OK;
    16801665
    1681     int vrc = terminateProcess();
     1666    int guestRc;
     1667    int vrc = terminateProcess(&guestRc);
    16821668    if (RT_FAILURE(vrc))
    16831669    {
    16841670        switch (vrc)
    16851671        {
    1686             case VERR_NOT_IMPLEMENTED:
    1687                 ReturnComNotImplemented();
    1688                 break; /* Never reached. */
     1672           case VERR_GENERAL_FAILURE: /** @todo Special guest control rc needed! */
     1673                hr = GuestProcess::setErrorExternal(this, guestRc);
     1674                break;
    16891675
    16901676            case VERR_NOT_SUPPORTED:
    … …  
    17021688    }
    17031689
    1704     AssertPtr(mData.mParent);
    1705     mData.mParent->processRemoveFromList(this);
     1690    AssertPtr(mObject.mSession);
     1691    mObject.mSession->processRemoveFromList(this);
    17061692
    17071693    /*
    … …  
    18861872        vrc = fAsync ? pProcess->startProcessAsync() : pProcess->startProcess(pGuestRc);
    18871873
    1888     if (   !fAsync
     1874    if (   RT_SUCCESS(vrc)
     1875        && !fAsync
    18891876        && (   pGuestRc
    18901877            && RT_FAILURE(*pGuestRc)

  • trunk/src/VBox/Main/src-client/GuestSessionImpl.cpp

    r43981 r44863  
    22/* $Id$ */
    33/** @file
    4  * VirtualBox Main - XXX.
     4 * VirtualBox Main - Guest session handling.
    55 */
    66
    77/*
    8  * Copyright (C) 2012 Oracle Corporation
     8 * Copyright (C) 2012-2013 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2828#include "AutoCaller.h"
    2929#include "ProgressImpl.h"
     30#include "VMMDev.h"
    3031
    3132#include <memory> /* For auto_ptr. */
    … …  
    4344#include <VBox/log.h>
    4445
    45 
    4646// constructor / destructor
    4747/////////////////////////////////////////////////////////////////////////////
    … …  
    6666/////////////////////////////////////////////////////////////////////////////
    6767
     68/**
     69 * Initializes a guest session but does *not* open in on the guest side
     70 * yet. This needs to be done via the openSession() call.
     71 *
     72 * @return  IPRT status code.
     73 * @param   aGuest
     74 * @param   aSessionID
     75 * @param   aUser
     76 * @param   aPassword
     77 * @param   aDomain
     78 * @param   aName
     79 */
    6880int GuestSession::init(Guest *aGuest, ULONG aSessionID,
    6981                       Utf8Str aUser, Utf8Str aPassword, Utf8Str aDomain, Utf8Str aName)
    … …  
    409421
    410422// private methods
    411 /////////////////////////////////////////////////////////////////////////////
     423///////////////////////////////////////////////////////////////////////////////
     424
     425int GuestSession::closeSession(uint32_t uFlags, uint32_t uTimeoutMS, int *pGuestRc)
     426{
     427    LogFlowThisFunc(("uFlags=%x, uTimeoutMS=%RU32\n", uFlags, uTimeoutMS));
     428
     429    /* Legacy Guest Additions don't support opening dedicated
     430       guest sessions. */
     431    if (mData.mProtocolVersion < 2)
     432    {
     433        LogFlowThisFunc(("Installed Guest Additions don't support closing separate sessions\n"));
     434        return VINF_SUCCESS;
     435    }
     436
     437    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     438
     439    /* Destroy a pending callback request. */
     440    mData.mCallback.Destroy();
     441
     442    int vrc = mData.mCallback.Init(CALLBACKTYPE_SESSION_NOTIFY);
     443
     444    alock.release(); /* Drop the write lock again. */
     445
     446    if (RT_SUCCESS(vrc))
     447    {
     448        uint32_t uContextID = VBOX_GUESTCTRL_CONTEXTID_MAKE(mData.mId, 0 /* Object */, 0 /* Count */);
     449
     450        VBOXHGCMSVCPARM paParms[4];
     451
     452        int i = 0;
     453        paParms[i++].setUInt32(uContextID);
     454        paParms[i++].setUInt32(0 /* Flags, unused. */);
     455
     456        vrc = sendCommand(HOST_SESSION_CLOSE, i, paParms);
     457    }
     458
     459    if (RT_SUCCESS(vrc))
     460    {
     461        /*
     462         * Let's wait for the process being started.
     463         * Note: Be sure not keeping a AutoRead/WriteLock here.
     464         */
     465        LogFlowThisFunc(("Waiting for callback (%RU32ms) ...\n", uTimeoutMS));
     466        vrc = mData.mCallback.Wait(uTimeoutMS);
     467        if (RT_SUCCESS(vrc)) /* Wait was successful, check for supplied information. */
     468        {
     469            int guestRc = mData.mCallback.GetResultCode();
     470            if (pGuestRc)
     471                *pGuestRc = guestRc;
     472            LogFlowThisFunc(("Callback returned rc=%Rrc\n", guestRc));
     473        }
     474        else
     475            vrc = VERR_TIMEOUT;
     476    }
     477
     478    AutoWriteLock awlock(this COMMA_LOCKVAL_SRC_POS);
     479
     480    mData.mCallback.Destroy();
     481
     482    LogFlowFuncLeaveRC(vrc);
     483    return vrc;
     484}
    412485
    413486int GuestSession::directoryRemoveFromList(GuestDirectory *pDirectory)
    … …  
    464537    procInfo.mArguments.push_back(strPath); /* The directory we want to create. */
    465538
    466     int guestRc;
    467539    if (RT_SUCCESS(vrc))
    468540    {
     541        int guestRc;
    469542        GuestProcessTool procTool;
    470543        vrc = procTool.Init(this, procInfo, false /* Async */, &guestRc);
    … …  
    481554        }
    482555
    483         if (pGuestRc)
     556        if (vrc == VERR_GENERAL_FAILURE) /** @todo Special guest control rc needed! */
    484557            *pGuestRc = guestRc;
    485558    }
    486559
    487560    LogFlowFuncLeaveRC(vrc);
    488     if (RT_FAILURE(vrc))
    489         return vrc;
    490     return RT_SUCCESS(guestRc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE; /** @todo Special guest control rc needed! */
     561    return vrc;
    491562}
    492563
    … …  
    536607    }
    537608
    538     if (pGuestRc)
     609    if (   vrc == VERR_GENERAL_FAILURE /** @todo Special guest control rc needed! */
     610        && pGuestRc)
    539611        *pGuestRc = guestRc;
    540612
    541     if (RT_FAILURE(vrc))
    542         return vrc;
    543     return RT_SUCCESS(guestRc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE; /** @todo Special guest control rc needed! */
     613    LogFlowFuncLeaveRC(vrc);
     614    return vrc;
    544615}
    545616
    … …  
    572643}
    573644
    574 int GuestSession::dispatchToProcess(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData)
    575 {
    576     LogFlowFuncEnter();
     645int GuestSession::dispatchToFile(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
     646{
     647    LogFlowFunc(("pCtxCb=%p, pSvcCb=%p\n", pCtxCb, pSvcCb));
     648
     649    AssertPtrReturn(pCtxCb, VERR_INVALID_POINTER);
     650    AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
    577651
    578652    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    579653
    580     uint32_t uProcessID = VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(uContextID);
     654    uint32_t uFileID = VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCtxCb->uContextID);
     655#ifdef DEBUG
     656    LogFlowFunc(("uFileID=%RU32 (%RU32 total)\n",
     657                 uFileID, mData.mFiles.size()));
     658#endif
     659    int rc;
     660    SessionFiles::const_iterator itFile
     661        = mData.mFiles.find(uFileID);
     662    if (itFile != mData.mFiles.end())
     663    {
     664        ComObjPtr<GuestFile> pFile(itFile->second);
     665        Assert(!pFile.isNull());
     666
     667        alock.release();
     668
     669        rc = pFile->callbackDispatcher(pCtxCb, pSvcCb);
     670    }
     671    else
     672        rc = VERR_NOT_FOUND;
     673
     674    LogFlowFuncLeaveRC(rc);
     675    return rc;
     676}
     677
     678int GuestSession::dispatchToProcess(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
     679{
     680    LogFlowFunc(("pCtxCb=%p, pSvcCb=%p\n", pCtxCb, pSvcCb));
     681
     682    AssertPtrReturn(pCtxCb, VERR_INVALID_POINTER);
     683    AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
     684
     685    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     686
     687    uint32_t uProcessID = VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCtxCb->uContextID);
    581688#ifdef DEBUG
    582689    LogFlowFunc(("uProcessID=%RU32 (%RU32 total)\n",
    … …  
    591698        Assert(!pProcess.isNull());
    592699
     700        /* Set protocol version so that pSvcCb can
     701         * be interpreted right. */
     702        pCtxCb->uProtocol = mData.mProtocolVersion;
     703
    593704        alock.release();
    594         rc = pProcess->callbackDispatcher(uContextID, uFunction, pvData, cbData);
     705        rc = pProcess->callbackDispatcher(pCtxCb, pSvcCb);
    595706    }
    596707    else
    … …  
    601712}
    602713
     714int GuestSession::dispatchToThis(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
     715{
     716    AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
     717    AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
     718
     719    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     720
     721#ifdef DEBUG
     722    LogFlowThisFunc(("ID=%RU32, uContextID=%RU32, uFunction=%RU32, pSvcCb=%p\n",
     723                     mData.mId, pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb));
     724#endif
     725
     726    int rc = VINF_SUCCESS;
     727    switch (pCbCtx->uFunction)
     728    {
     729        case GUEST_SESSION_NOTIFY:
     730        {
     731            rc = onSessionStatusChange(pCbCtx,
     732                                       &mData.mCallback, pSvcCb);
     733            break;
     734        }
     735
     736        default:
     737            /* Silently skip unknown callbacks. */
     738            break;
     739    }
     740
     741    LogFlowFuncLeaveRC(rc);
     742    return rc;
     743}
     744
     745inline bool GuestSession::fileExists(uint32_t uFileID, ComObjPtr<GuestFile> *pFile)
     746{
     747    SessionFiles::const_iterator it = mData.mFiles.find(uFileID);
     748    if (it != mData.mFiles.end())
     749    {
     750        if (pFile)
     751            *pFile = it->second;
     752        return true;
     753    }
     754    return false;
     755}
     756
    603757int GuestSession::fileRemoveFromList(GuestFile *pFile)
    604758{
    … …  
    608762         itFiles != mData.mFiles.end(); ++itFiles)
    609763    {
    610         if (pFile == (*itFiles))
    611         {
     764        if (pFile == itFiles->second)
     765        {
     766            GuestFile *pThis = itFiles->second;
     767            AssertPtr(pThis);
     768
    612769            Bstr strName;
    613             HRESULT hr = (*itFiles)->COMGETTER(FileName)(strName.asOutParam());
     770            HRESULT hr = pThis->COMGETTER(FileName)(strName.asOutParam());
    614771            ComAssertComRC(hr);
    615772
    … …  
    652809    }
    653810
    654     if (pGuestRc)
     811    if (   vrc == VERR_GENERAL_FAILURE /** @todo Special guest control rc needed! */
     812        && pGuestRc)
    655813        *pGuestRc = guestRc;
    656814
    657     if (RT_FAILURE(vrc))
    658         return vrc;
    659     return RT_SUCCESS(guestRc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE; /** @todo Special guest control rc needed! */
    660 }
    661 
    662 int GuestSession::fileOpenInternal(const Utf8Str &strPath, const Utf8Str &strOpenMode, const Utf8Str &strDisposition,
    663                                    uint32_t uCreationMode, int64_t iOffset, ComObjPtr<GuestFile> &pFile, int *pGuestRc)
     815    LogFlowFuncLeaveRC(vrc);
     816    return vrc;
     817}
     818
     819int GuestSession::fileOpenInternal(const GuestFileOpenInfo &openInfo, ComObjPtr<GuestFile> &pFile, int *pGuestRc)
    664820{
    665821    LogFlowThisFunc(("strPath=%s, strOpenMode=%s, strDisposition=%s, uCreationMode=%x, iOffset=%RI64\n",
    666                      strPath.c_str(), strOpenMode.c_str(), strDisposition.c_str(), uCreationMode, iOffset));
     822                     openInfo.mFileName.c_str(), openInfo.mOpenMode.c_str(), openInfo.mDisposition.c_str(),
     823                     openInfo.mCreationMode, openInfo.mInitialOffset));
     824
     825    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     826
     827    int rc = VERR_MAX_PROCS_REACHED;
     828    if (mData.mNumObjects >= VBOX_GUESTCTRL_MAX_OBJECTS)
     829        return rc;
     830
     831    /* Create a new (host-based) file ID and assign it. */
     832    uint32_t uNewFileID = 0;
     833    ULONG uTries = 0;
     834
     835    for (;;)
     836    {
     837        /* Is the file ID already used? */
     838        if (!fileExists(uNewFileID, NULL /* pProgress */))
     839        {
     840            /* Callback with context ID was not found. This means
     841             * we can use this context ID for our new callback we want
     842             * to add below. */
     843            rc = VINF_SUCCESS;
     844            break;
     845        }
     846        uNewFileID++;
     847        if (uNewFileID == VBOX_GUESTCTRL_MAX_OBJECTS)
     848            uNewFileID = 0;
     849
     850        if (++uTries == UINT32_MAX)
     851            break; /* Don't try too hard. */
     852    }
     853
     854    if (RT_FAILURE(rc))
     855        return rc;
    667856
    668857    /* Create the directory object. */
    … …  
    671860        return VERR_COM_UNEXPECTED;
    672861
    673     int vrc = pFile->init(this /* Parent */,
    674                           strPath, strOpenMode, strDisposition, uCreationMode, iOffset, pGuestRc);
    675     if (RT_FAILURE(vrc))
    676         return vrc;
    677     /** @todo Handle guestRc. */
    678 
    679     /* Add the created directory to our vector. */
    680     mData.mFiles.push_back(pFile);
     862    Console *pConsole = mData.mParent->getConsole();
     863    AssertPtr(pConsole);
     864
     865    rc = pFile->init(pConsole, this /* GuestSession */,
     866                     uNewFileID, openInfo);
     867    if (RT_FAILURE(rc))
     868        return rc;
     869
     870    /* Add the created file to our vector. */
     871    mData.mFiles[uNewFileID] = pFile;
    681872    mData.mNumObjects++;
    682873    Assert(mData.mNumObjects <= VBOX_GUESTCTRL_MAX_OBJECTS);
    683874
    684875    LogFlowFunc(("Added new file \"%s\" (Session: %RU32) (now total %ld files, %ld objects)\n",
    685                  strPath.c_str(), mData.mId, mData.mProcesses.size(), mData.mNumObjects));
    686 
    687     LogFlowFuncLeaveRC(vrc);
    688     return vrc;
     876                 openInfo.mFileName.c_str(), mData.mId, mData.mFiles.size(), mData.mNumObjects));
     877
     878    LogFlowFuncLeaveRC(rc);
     879    return rc;
    689880}
    690881
    … …  
    746937    }
    747938
    748     if (pGuestRc)
     939    if (   vrc == VERR_GENERAL_FAILURE /** @todo Special guest control rc needed! */
     940        && pGuestRc)
    749941        *pGuestRc = guestRc;
    750942
    751943    LogFlowFuncLeaveRC(vrc);
    752     if (RT_FAILURE(vrc))
    753         return vrc;
    754     return RT_SUCCESS(guestRc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE; /** @todo Special guest control rc needed! */
     944    return vrc;
    755945}
    756946
    … …  
    768958{
    769959    return mData.mName;
     960}
     961
     962/** No locking! */
     963int GuestSession::onSessionStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx,
     964                                        GuestCtrlCallback *pCallback, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
     965{
     966    /* pCallback is optional. */
     967    AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
     968
     969    if (pSvcCbData->mParms < 3)
     970        return VERR_INVALID_PARAMETER;
     971
     972    CALLBACKDATA_SESSION_NOTIFY dataCb;
     973    /* pSvcCb->mpaParms[0] always contains the context ID. */
     974    pSvcCbData->mpaParms[1].getUInt32(&dataCb.uType);
     975    pSvcCbData->mpaParms[2].getUInt32(&dataCb.uResult);
     976
     977    int rcCb = dataCb.uResult; /** @todo uint32_t vs. int. */
     978
     979    LogFlowThisFunc(("ID=%RU32, uType=%RU32, rc=%Rrc, pCallback=%p, pData=%p\n",
     980                     mData.mId, dataCb.uType, rcCb, pCallback, pSvcCbData));
     981
     982    int vrc = VINF_SUCCESS;
     983
     984    /*
     985     * Now do the signalling stuff.
     986     */
     987    if (pCallback)
     988    {
     989        vrc = pCallback->SetData(&dataCb, sizeof(dataCb));
     990
     991        int rc2 = pCallback->Signal(rcCb);
     992        if (RT_SUCCESS(vrc))
     993            vrc = rc2;
     994    }
     995
     996    LogFlowFuncLeaveRC(vrc);
     997    return vrc;
     998}
     999
     1000int GuestSession::openSession(uint32_t uFlags, uint32_t uTimeoutMS, int *pGuestRc)
     1001{
     1002    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     1003
     1004    LogFlowThisFunc(("uProtocolVersion=%RU32, uFlags=%x, uTimeoutMS=%RU32\n",
     1005                     mData.mProtocolVersion, uFlags, uTimeoutMS));
     1006
     1007    /* Legacy Guest Additions don't support opening dedicated
     1008       guest sessions. */
     1009    if (mData.mProtocolVersion < 2)
     1010    {
     1011        LogFlowThisFunc(("Installed Guest Additions don't support opening separate sessions\n"));
     1012        return VINF_SUCCESS;
     1013    }
     1014
     1015    /** @todo uFlags validation. */
     1016
     1017    /* Destroy a pending callback request. */
     1018    mData.mCallback.Destroy();
     1019
     1020    int vrc = mData.mCallback.Init(CALLBACKTYPE_SESSION_NOTIFY);
     1021
     1022    alock.release(); /* Drop the write lock again. */
     1023
     1024    if (RT_SUCCESS(vrc))
     1025    {
     1026        uint32_t uContextID =
     1027            VBOX_GUESTCTRL_CONTEXTID_MAKE(mData.mId, 0 /* Object */, 0 /* Count */);
     1028
     1029        VBOXHGCMSVCPARM paParms[8];
     1030
     1031        int i = 0;
     1032        paParms[i++].setUInt32(uContextID);
     1033        paParms[i++].setUInt32(mData.mProtocolVersion);
     1034        paParms[i++].setPointer((void*)mData.mCredentials.mUser.c_str(),
     1035                                (ULONG)mData.mCredentials.mUser.length() + 1);
     1036        paParms[i++].setPointer((void*)mData.mCredentials.mPassword.c_str(),
     1037                                (ULONG)mData.mCredentials.mPassword.length() + 1);
     1038        paParms[i++].setPointer((void*)mData.mCredentials.mDomain.c_str(),
     1039                                (ULONG)mData.mCredentials.mDomain.length() + 1);
     1040        paParms[i++].setUInt32(uFlags);
     1041
     1042        vrc = sendCommand(HOST_SESSION_CREATE, i, paParms);
     1043    }
     1044
     1045    if (RT_SUCCESS(vrc))
     1046    {
     1047        /*
     1048         * Let's wait for the process being started.
     1049         * Note: Be sure not keeping a AutoRead/WriteLock here.
     1050         */
     1051        LogFlowThisFunc(("Waiting for callback (%RU32ms) ...\n", uTimeoutMS));
     1052        vrc = mData.mCallback.Wait(uTimeoutMS);
     1053        if (RT_SUCCESS(vrc)) /* Wait was successful, check for supplied information. */
     1054        {
     1055            int guestRc = mData.mCallback.GetResultCode();
     1056            if (pGuestRc)
     1057                *pGuestRc = guestRc;
     1058            LogFlowThisFunc(("Callback returned rc=%Rrc\n", guestRc));
     1059        }
     1060        else
     1061            vrc = VERR_TIMEOUT;
     1062    }
     1063
     1064    AutoWriteLock awlock(this COMMA_LOCKVAL_SRC_POS);
     1065
     1066    /* Destroy callback. */
     1067    mData.mCallback.Destroy();
     1068
     1069    LogFlowFuncLeaveRC(vrc);
     1070    return vrc;
    7701071}
    7711072
    … …  
    7961097            Assert(mData.mNumObjects);
    7971098            LogFlowFunc(("Removing process (Session: %RU32) with process ID=%RU32, guest PID=%RU32 (now total %ld processes, %ld objects)\n",
    798                          mData.mId, pCurProc->getProcessID(), uPID, mData.mProcesses.size() - 1, mData.mNumObjects - 1));
     1099                         mData.mId, pCurProc->getObjectID(), uPID, mData.mProcesses.size() - 1, mData.mNumObjects - 1));
    7991100
    8001101            mData.mProcesses.erase(itProcs);
    … …  
    9591260}
    9601261
     1262int GuestSession::sendCommand(uint32_t uFunction,
     1263                              uint32_t uParms, PVBOXHGCMSVCPARM paParms)
     1264{
     1265    LogFlowThisFuncEnter();
     1266
     1267#ifndef VBOX_GUESTCTRL_TEST_CASE
     1268    ComObjPtr<Console> pConsole = mData.mParent->getConsole();
     1269    Assert(!pConsole.isNull());
     1270
     1271    /* Forward the information to the VMM device. */
     1272    VMMDev *pVMMDev = pConsole->getVMMDev();
     1273    AssertPtr(pVMMDev);
     1274
     1275    LogFlowThisFunc(("uFunction=%RU32, uParms=%RU32\n", uFunction, uParms));
     1276    int vrc = pVMMDev->hgcmHostCall(HGCMSERVICE_NAME, uFunction, uParms, paParms);
     1277    if (RT_FAILURE(vrc))
     1278    {
     1279        /** @todo What to do here? */
     1280    }
     1281#else
     1282    /* Not needed within testcases. */
     1283    int vrc = VINF_SUCCESS;
     1284#endif
     1285    LogFlowFuncLeaveRC(vrc);
     1286    return vrc;
     1287}
     1288
    9611289int GuestSession::startTaskAsync(const Utf8Str &strTaskDesc,
    9621290                                 GuestSessionTask *pTask, ComObjPtr<Progress> &pProgress)
    … …  
    10021330#if 1
    10031331    /* Since the new functions were not implemented yet, force Main to use protocol ver 1. */
    1004     mData.mProtocolVersion = 1;
     1332    mData.mProtocolVersion = 2;
    10051333#else
    10061334    /*
    … …  
    10131341    uint32_t uVerAdditions = pGuest->getAdditionsVersion();
    10141342    mData.mProtocolVersion = (   VBOX_FULL_VERSION_GET_MAJOR(uVerAdditions) >= 4
    1015                               && VBOX_FULL_VERSION_GET_MINOR(uVerAdditions) >= 2) /** @todo What's about v5.0 ? */
     1343                              && VBOX_FULL_VERSION_GET_MINOR(uVerAdditions) >= 3) /** @todo What's about v5.0 ? */
    10161344                           ? 2  /* Guest control 2.0. */
    1017                            : 1; /* Legacy guest control (VBox < 4.2). */
     1345                           : 1; /* Legacy guest control (VBox < 4.3). */
    10181346    /* Build revision is ignored. */
    10191347
    … …  
    10401368    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    10411369
     1370    /* Close session on guest session. */
     1371    int guestRc;
     1372    int rc = closeSession(0 /* Flags */, 30 * 1000 /* Timeout */,
     1373                          &guestRc);
     1374    if (RT_FAILURE(rc))
     1375    {
     1376
     1377    }
     1378
    10421379    /* Remove ourselves from the session list. */
    10431380    mData.mParent->sessionRemove(this);
    … …  
    16942031    HRESULT hr = S_OK;
    16952032
     2033    GuestFileOpenInfo openInfo;
     2034    openInfo.mFileName = Utf8Str(aPath);
     2035    openInfo.mOpenMode = Utf8Str(aOpenMode);
     2036    openInfo.mDisposition = Utf8Str(aDisposition);
     2037    openInfo.mCreationMode = aCreationMode;
     2038    openInfo.mInitialOffset = aOffset;
     2039
    16962040    ComObjPtr <GuestFile> pFile; int guestRc;
    1697     int vrc = fileOpenInternal(Utf8Str(aPath), Utf8Str(aOpenMode), Utf8Str(aDisposition),
    1698                                aCreationMode, aOffset, pFile, &guestRc);
     2041    int vrc = fileOpenInternal(openInfo, pFile, &guestRc);
    16992042    if (RT_SUCCESS(vrc))
    17002043    {
    … …  
    19192262            com::SafeArray<LONG> affinity(ComSafeArrayInArg(aAffinity));
    19202263            for (size_t i = 0; i < affinity.size(); i++)
    1921                 procInfo.mAffinity[i] = affinity[i]; /** @todo Really necessary? Later. */
     2264            {
     2265                if (affinity[i])
     2266                    procInfo.mAffinity |= (uint64_t)1 << i;
     2267            }
    19222268        }
    19232269

  • trunk/src/VBox/Main/src-client/GuestSessionImplTasks.cpp

    r43493 r44863  
    139139HRESULT GuestSessionTask::setProgressErrorMsg(HRESULT hr, const Utf8Str &strMsg)
    140140{
     141    LogFlowFunc(("mProgress=%p, hr=%Rhrc, strMsg=%s\n",
     142                 mProgress, hr, strMsg.c_str()));
     143
    141144    if (mProgress.isNull()) /* Progress is optional. */
    142145        return hr; /* Return original rc. */
    … …  
    157160    }
    158161    return hr; /* Return original rc. */
     162}
     163
     164SessionTaskOpen::SessionTaskOpen(GuestSession *pSession,
     165                                 uint32_t uFlags,
     166                                 uint32_t uTimeoutMS)
     167                                 : GuestSessionTask(pSession),
     168                                   mFlags(uFlags),
     169                                   mTimeoutMS(uTimeoutMS)
     170{
     171
     172}
     173
     174SessionTaskOpen::~SessionTaskOpen(void)
     175{
     176
     177}
     178
     179int SessionTaskOpen::Run(void)
     180{
     181    LogFlowThisFuncEnter();
     182
     183    ComObjPtr<GuestSession> pSession = mSession;
     184    Assert(!pSession.isNull());
     185
     186    AutoCaller autoCaller(pSession);
     187    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     188
     189    int vrc = pSession->openSession(mFlags, mTimeoutMS,
     190                                    NULL /* Guest rc, ignored */);
     191    /* Nothing to do here anymore. */
     192
     193    LogFlowFuncLeaveRC(vrc);
     194    return vrc;
     195}
     196
     197int SessionTaskOpen::RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress)
     198{
     199    LogFlowThisFunc(("strDesc=%s\n", strDesc.c_str()));
     200
     201    mDesc = strDesc;
     202    mProgress = pProgress;
     203
     204    int rc = RTThreadCreate(NULL, SessionTaskOpen::taskThread, this,
     205                            0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
     206                            "gctlSesOpen");
     207    LogFlowFuncLeaveRC(rc);
     208    return rc;
     209}
     210
     211/* static */
     212int SessionTaskOpen::taskThread(RTTHREAD Thread, void *pvUser)
     213{
     214    std::auto_ptr<SessionTaskOpen> task(static_cast<SessionTaskOpen*>(pvUser));
     215    AssertReturn(task.get(), VERR_GENERAL_FAILURE);
     216
     217    LogFlowFunc(("pTask=%p\n", task.get()));
     218    return task->Run();
    159219}
    160220
    … …  
    821881    if (RT_SUCCESS(rc))
    822882    {
    823         LogFlowThisFunc(("Copying Guest Additions installer file \"%s\" to \"%s\" on guest ...\n",
    824                          strFileSource.c_str(), strFileDest.c_str()));
     883        LogRel(("Copying Guest Additions installer file \"%s\" to \"%s\" on guest ...\n",
     884                strFileSource.c_str(), strFileDest.c_str()));
    825885
    826886        if (RT_SUCCESS(rc))
    … …  
    859919    if (RT_SUCCESS(rc))
    860920    {
    861         LogFlowThisFunc(("Verifying Guest Additions installer file \"%s\" ...\n",
    862                          strFileDest.c_str()));
     921        LogRel(("Verifying Guest Additions installer file \"%s\" ...\n",
     922                strFileDest.c_str()));
    863923
    864924        GuestFsObjData objData;
    … …  
    875935            if (RT_SUCCESS(rc)) /* Size does not match. */
    876936            {
    877                 LogFlowThisFunc(("Size of Guest Additions installer file \"%s\" does not match: %RI64bytes copied, %RU64bytes expected\n",
    878                                  strFileDest.c_str(), cbSizeOnGuest, cbSize));
     937                LogRel(("Size of Guest Additions installer file \"%s\" does not match: %RI64 bytes copied, %RU64 bytes expected\n",
     938                        strFileDest.c_str(), cbSizeOnGuest, cbSize));
    879939                rc = VERR_BROKEN_PIPE; /** @todo Find a better error. */
    880940            }
    … …  
    11741234                {
    11751235                    case VERR_GENERAL_FAILURE: /** @todo Special guest control rc needed! */
    1176                         setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    1177                                             GuestProcess::guestErrorToString(guestRc));
     1236                        hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
     1237                                                 GuestProcess::guestErrorToString(guestRc));
    11781238                        break;
    11791239
    11801240                    default:
    1181                         setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    1182                                             Utf8StrFmt(GuestSession::tr("Error creating installation directory \"%s\" on the guest: %Rrc"),
    1183                                                        strUpdateDir.c_str(), rc));
     1241                        hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
     1242                                                 Utf8StrFmt(GuestSession::tr("Error creating installation directory \"%s\" on the guest: %Rrc"),
     1243                                                 strUpdateDir.c_str(), rc));
    11841244                        break;
    11851245                }
    … …  
    13741434            if (!mProgress.isNull()) /* Progress object is optional. */
    13751435            {
    1376                 ComPtr<IVirtualBoxErrorInfo> pError;
    1377                 hr = mProgress->COMGETTER(ErrorInfo)(pError.asOutParam());
    1378                 Assert(!pError.isNull());
    1379                 if (SUCCEEDED(hr))
    1380                 {
    1381                     Bstr strVal;
    1382                     hr = pError->COMGETTER(Text)(strVal.asOutParam());
    1383                     if (   SUCCEEDED(hr)
    1384                         && strVal.isNotEmpty())
    1385                         strError = strVal;
    1386                 }
    1387             }
    1388 
    1389             LogRel(("Automatic update of Guest Additions failed: %s\n", strError.c_str()));
     1436                com::ProgressErrorInfo errorInfo(mProgress);
     1437                if (   errorInfo.isFullAvailable()
     1438                    || errorInfo.isBasicAvailable())
     1439                {
     1440                    strError = errorInfo.getText();
     1441                }
     1442            }
     1443
     1444            LogRel(("Automatic update of Guest Additions failed: %s (%Rhrc)\n",
     1445                    strError.c_str(), hr));
    13901446        }
    13911447
    13921448        LogRel(("Please install Guest Additions manually\n"));
    13931449    }
     1450
     1451    /** @todo Clean up copied / left over installation files. */
    13941452
    13951453    LogFlowFuncLeaveRC(rc);

  • trunk/src/VBox/Main/testcase/Makefile.kmk

    r44528 r44863  
    154154#
    155155tstGuestCtrlParseBuffer_TEMPLATE = VBOXMAINCLIENTEXE
    156 tstGuestCtrlParseBuffer_DEFS    += VBOX_WITH_HGCM VBOX_WITH_GUEST_CONTROL
     156tstGuestCtrlParseBuffer_DEFS    += VBOX_WITH_HGCM VBOX_WITH_GUEST_CONTROL VBOX_GUESTCTRL_TEST_CASE
    157157tstGuestCtrlParseBuffer_SOURCES  = \
    158158        tstGuestCtrlParseBuffer.cpp \
    … …  
    170170#
    171171tstGuestCtrlContextID_TEMPLATE = VBOXMAINCLIENTEXE
    172 tstGuestCtrlContextID_DEFS    += VBOX_WITH_HGCM VBOX_WITH_GUEST_CONTROL
     172tstGuestCtrlContextID_DEFS    += VBOX_WITH_HGCM VBOX_WITH_GUEST_CONTROL VBOX_GUESTCTRL_TEST_CASE
    173173tstGuestCtrlContextID_SOURCES  = \
    174174        tstGuestCtrlContextID.cpp \

  • trunk/src/VBox/Main/testcase/tstGuestCtrlContextID.cpp

    r43036 r44863  
    5252    RTAssertSetQuiet(true);
    5353
     54#if 0
     55    for (int t = 0; t < 4 && !RTTestErrorCount(hTest); t++)
     56    {
     57        uint32_t uSession = RTRandU32Ex(0, VBOX_GUESTCTRL_MAX_SESSIONS - 1);
     58        uint32_t uFilter = VBOX_GUESTCTRL_CONTEXTID_MAKE_SESSION(uSession);
     59        RTTestIPrintf(RTTESTLVL_INFO, "Session: %RU32, Filter: %x\n", uSession, uFilter);
     60
     61        uint32_t uSession2 = RTRandU32Ex(0, VBOX_GUESTCTRL_MAX_SESSIONS - 1);
     62        uint32_t uCID = VBOX_GUESTCTRL_CONTEXTID_MAKE(uSession2,
     63                                                      RTRandU32Ex(0, VBOX_GUESTCTRL_MAX_OBJECTS - 1),
     64                                                      RTRandU32Ex(0, VBOX_GUESTCTRL_MAX_CONTEXTS - 1));
     65        RTTestIPrintf(RTTESTLVL_INFO, "CID: %x (Session: %d), Masked: %x\n",
     66                      uCID, VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(uCID), uCID & uFilter);
     67        if ((uCID & uFilter) == uCID)
     68        {
     69            RTTestIPrintf(RTTESTLVL_INFO, "=========== Masking works: %x vs. %x\n",
     70                          uCID & uFilter, uFilter);
     71        }
     72    }
     73#endif
     74
    5475    uint32_t uContextMax = UINT32_MAX;
    5576    RTTestIPrintf(RTTESTLVL_DEBUG, "Max context is: %RU32\n", uContextMax);
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette