VirtualBox

Changeset 4269 in vbox


Ignore:
Timestamp:
Aug 21, 2007 9:39:48 PM (18 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
23779
Message:

implemented Main functionality for serial ports

Location:
trunk/src/VBox
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManage.cpp

    r4127 r4269  
    332332                 "                            [-nictracefile<1-N> <filename>]\n"
    333333                 "                            [-hostifdev<1-N> none|<devicename>]\n"
    334                  "                            [-intnet<1-N> network]\n"
     334                 "                            [-intnet<1-N> <network>]\n"
    335335                 "                            [-macaddress<1-N> auto|<mac>]\n"
    336                  "                            [-uart<1-N> off | <I/O base> <IRQ> server|client\n"
    337                  "                                              <host pipename>]\n"
     336                 "                            [-uart<1-N> off|<I/O base> <IRQ>]\n"
     337                 "                            [-uartmode<1-N> server|client <pipe name>|\n"
     338                 "                                            <device name>]\n"
    338339                 );
    339340        if (fLinux)
    … …  
    10541055            else
    10551056            {
    1056                 ULONG uIRQ, uIOBase;
    1057                 Bstr pipe;
     1057                ULONG uIRQ, uIOBase, uHostMode;
     1058                Bstr path;
    10581059                BOOL fServer;
    10591060                uart->COMGETTER(IRQ)(&uIRQ);
    10601061                uart->COMGETTER(IOBase)(&uIOBase);
    1061                 uart->COMGETTER(Pipe)(pipe.asOutParam());
     1062                uart->COMGETTER(Path)(path.asOutParam());
    10621063                uart->COMGETTER(Server)(&fServer);
    1063 
    1064                 RTPrintf("UART %d:          I/O base: 0x%04x, IRQ: %d, %s, pipe '%lS'\n",
    1065                          currentUART + 1, uIOBase, uIRQ, fServer ? "isServer" : "isClient",
    1066                          pipe.raw());
     1064                uart->COMGETTER(HostMode)(&uHostMode);
     1065
     1066                RTPrintf("UART %d:          I/O base: 0x%04x, IRQ: %d",
     1067                         currentUART + 1, uIOBase, uIRQ);
     1068                switch (uHostMode)
     1069                {
     1070                    default:
     1071                    case SerialHostMode_Disconnected:
     1072                        RTPrintf(", disconnected\n");
     1073                        break;
     1074                    case SerialHostMode_HostPipe:
     1075                        RTPrintf(", attached to pipe (%s) '%lS'\n",
     1076                                fServer ? "server" : "client", path.raw());
     1077                        break;
     1078                    case SerialHostMode_HostDevice:
     1079                        RTPrintf(", attached to device '%lS'\n", path.raw());
     1080                        break;
     1081                }
    10671082            }
    10681083        }
    … …  
    28252840#endif
    28262841    std::vector <char *> macs (NetworkAdapterCount, 0);
     2842    std::vector <char *> uarts_mode (SerialPortCount, 0);
    28272843    std::vector <ULONG>  uarts_base (SerialPortCount, 0);
    28282844    std::vector <ULONG>  uarts_irq (SerialPortCount, 0);
    2829     std::vector <char *> uarts_pipe (SerialPortCount, 0);
    2830     std::vector <char *> uarts_server (SerialPortCount, 0);
     2845    std::vector <char *> uarts_path (SerialPortCount, 0);
    28312846
    28322847    for (int i = 1; i < argc; i++)
    … …  
    32683283            snapshotFolder = argv[i];
    32693284        }
     3285        else if (strncmp(argv[i], "-uartmode", 9) == 0)
     3286        {
     3287            unsigned n = parseNum(&argv[i][9], SerialPortCount, "UART");
     3288            if (!n)
     3289                return 1;
     3290            i++;
     3291            if (strcmp(argv[i], "server") == 0 || strcmp(argv[i], "client") == 0)
     3292            {
     3293                uarts_mode[n - 1] = argv[i];
     3294                i++;
     3295#ifdef RT_OS_WINDOWS
     3296                if (strncmp(argv[i], "\\\\.\\pipe\\", 9))
     3297                    return errorArgument("Uart pipe must start with \\\\.\\pipe\\");
     3298#endif
     3299            }
     3300            else
     3301            {
     3302                uarts_mode[n - 1] = (char*)"device";
     3303            }
     3304            if (argc <= i)
     3305            {
     3306                return errorArgument("Missing argument to -uartmode");
     3307            }
     3308            uarts_path[n - 1] = argv[i];
     3309        }
    32703310        else if (strncmp(argv[i], "-uart", 5) == 0)
    32713311        {
    … …  
    32843324            else
    32853325            {
    3286                 if (argc <= i + 2)
     3326                if (argc <= i + 1)
    32873327                {
    32883328                    return errorArgument("Missing argument to '%s'", argv[i-1]);
    … …  
    32993339                    return errorArgument("Error parsing UART IRQ '%s'", argv[i]);
    33003340                uarts_irq[n - 1]  = uVal;
    3301                 i++;
    3302                 if (strcmp(argv[i], "server") && strcmp(argv[i], "client"))
    3303                     return errorArgument("Third UART argument must be 'client' or 'server'");
    3304                 uarts_server[n - 1] = argv[i];
    3305                 i++;
    3306 #ifdef RT_OS_WINDOWS
    3307                 if (strncmp(argv[i], "\\\\.\\pipe\\", 9))
    3308                     return errorArgument("Uart pipe must start with \\\\.\\pipe\\");
    3309 #endif
    3310                 uarts_pipe[n - 1] = argv[i];
    33113341            }
    33123342        }
    … …  
    40554085            ASSERT(uart);
    40564086
    4057             /* something about the NIC? */
    40584087            if (uarts_base[n])
    40594088            {
    … …  
    40664095                    CHECK_ERROR_RET(uart, COMSETTER(IOBase) (uarts_base[n]), 1);
    40674096                    CHECK_ERROR_RET(uart, COMSETTER(IRQ) (uarts_irq[n]), 1);
    4068                     CHECK_ERROR_RET(uart, COMSETTER(Pipe) (Bstr(uarts_pipe[n])), 1);
    4069                     CHECK_ERROR_RET(uart, COMSETTER(Server)
    4070                                           (0 == strcmp(uarts_server[n], "server")), 1);
    40714097                    CHECK_ERROR_RET(uart, COMSETTER(Enabled) (TRUE), 1);
    40724098                }
     4099            }
     4100            if (uarts_mode[n])
     4101            {
     4102                if (strcmp(uarts_mode[n], "server") == 0)
     4103                {
     4104                    CHECK_ERROR_RET(uart, COMSETTER(HostMode) (SerialHostMode_HostPipe), 1);
     4105                    CHECK_ERROR_RET(uart, COMSETTER(Server) (TRUE), 1);
     4106                }
     4107                else if (strcmp(uarts_mode[n], "client") == 0)
     4108                {
     4109                    CHECK_ERROR_RET(uart, COMSETTER(HostMode) (SerialHostMode_HostPipe), 1);
     4110                    CHECK_ERROR_RET(uart, COMSETTER(Server) (FALSE), 1);
     4111                }
     4112                else
     4113                {
     4114                    CHECK_ERROR_RET(uart, COMSETTER(HostMode) (SerialHostMode_HostDevice), 1);
     4115                }
     4116                CHECK_ERROR_RET(uart, COMSETTER(Path) (Bstr(uarts_path[n])), 1);
    40734117            }
    40744118        }

  • trunk/src/VBox/Main/ConsoleImpl.cpp

    r4234 r4269  
    58675867        rc = CFGMR3InsertNode(pInst, "Config", &pCfg);                              RC_CHECK();
    58685868
    5869         ULONG uIRQ, uIOBase;
    5870         Bstr  pipe;
     5869        ULONG uIRQ, uIOBase, uHostMode;
     5870        Bstr  path;
    58715871        BOOL  fServer;
     5872        hrc = serialPort->COMGETTER(HostMode)(&uHostMode);                          H();
    58725873        hrc = serialPort->COMGETTER(IRQ)(&uIRQ);                                    H();
    58735874        hrc = serialPort->COMGETTER(IOBase)(&uIOBase);                              H();
    5874         hrc = serialPort->COMGETTER(Pipe)(pipe.asOutParam());                       H();
     5875        hrc = serialPort->COMGETTER(Path)(path.asOutParam());                       H();
    58755876        hrc = serialPort->COMGETTER(Server)(&fServer);                              H();
    58765877        rc = CFGMR3InsertInteger(pCfg,   "IRQ", uIRQ);                              RC_CHECK();
    58775878        rc = CFGMR3InsertInteger(pCfg,   "IOBase", uIOBase);                        RC_CHECK();
    5878         rc = CFGMR3InsertNode(pInst,     "LUN#0", &pLunL0);                         RC_CHECK();
    5879         rc = CFGMR3InsertString(pLunL0,  "Driver", "Char");                         RC_CHECK();
    5880         rc = CFGMR3InsertNode(pLunL0,    "AttachedDriver", &pLunL1);                RC_CHECK();
    5881         rc = CFGMR3InsertString(pLunL1,  "Driver", "NamedPipe");                    RC_CHECK();
    5882         rc = CFGMR3InsertNode(pLunL1,    "Config", &pLunL2);                        RC_CHECK();
    5883         rc = CFGMR3InsertString(pLunL2,  "Location", Utf8Str(pipe));                RC_CHECK();
    5884         rc = CFGMR3InsertInteger(pLunL2, "IsServer", fServer);                      RC_CHECK();
     5879        if (uHostMode != SerialHostMode_Disconnected)
     5880        {
     5881            rc = CFGMR3InsertNode(pInst,     "LUN#0", &pLunL0);                     RC_CHECK();
     5882            if (uHostMode == SerialHostMode_HostPipe)
     5883            {
     5884                rc = CFGMR3InsertString(pLunL0,  "Driver", "Char");                 RC_CHECK();
     5885                rc = CFGMR3InsertNode(pLunL0,    "AttachedDriver", &pLunL1);        RC_CHECK();
     5886                rc = CFGMR3InsertString(pLunL1,  "Driver", "NamedPipe");            RC_CHECK();
     5887                rc = CFGMR3InsertNode(pLunL1,    "Config", &pLunL2);                RC_CHECK();
     5888                rc = CFGMR3InsertString(pLunL2,  "Location", Utf8Str(path));        RC_CHECK();
     5889                rc = CFGMR3InsertInteger(pLunL2, "IsServer", fServer);              RC_CHECK();
     5890            }
     5891            else if (uHostMode == SerialHostMode_HostDevice)
     5892            {
     5893                rc = CFGMR3InsertString(pLunL0,  "Driver", "Host Serial");          RC_CHECK();
     5894                rc = CFGMR3InsertNode(pLunL0,    "Config", &pLunL1);                RC_CHECK();
     5895                rc = CFGMR3InsertString(pLunL1,  "DevicePath", Utf8Str(path));      RC_CHECK();
     5896            }
     5897        }
    58855898    }
    58865899

  • trunk/src/VBox/Main/SerialPortImpl.cpp

    r4071 r4269  
    256256    bool fEnabled = false;
    257257    CFGLDRQueryBool (portNode, "enabled", &fEnabled);
     258    Bstr mode;
     259    uint32_t uIOBase;
    258260    /* I/O base (required) */
    259     uint32_t uIOBase;
    260261    CFGLDRQueryUInt32 (portNode, "IOBase", &uIOBase);
    261262    /* IRQ (required) */
    262263    uint32_t uIRQ;
    263264    CFGLDRQueryUInt32 (portNode, "IRQ", &uIRQ);
     265    /* host mode (required) */
     266    CFGLDRQueryBSTR (portNode, "HostMode", mode.asOutParam());
     267    if (mode == L"HostPipe")
     268        mData->mHostMode = SerialHostMode_HostPipe;
     269    else if (mode == L"HostDevice")
     270        mData->mHostMode = SerialHostMode_HostDevice;
     271    else
     272        mData->mHostMode = SerialHostMode_Disconnected;
    264273    /* name of the pipe (required) */
    265     Bstr pipe;
    266     CFGLDRQueryBSTR   (portNode, "pipe", pipe.asOutParam());
     274    Bstr path;
     275    int rc = CFGLDRQueryBSTR(portNode, "path", path.asOutParam());
     276    /* backward compatibility */
     277    if (rc == VERR_CFG_NO_VALUE)
     278        CFGLDRQueryBSTR(portNode, "pipe", path.asOutParam());
    267279    bool fServer = true;
    268280    CFGLDRQueryBool   (portNode, "server", &fServer);
    269281
    270     mData->mEnabled = fEnabled;
    271     mData->mSlot    = uSlot;
    272     mData->mIOBase  = uIOBase;
    273     mData->mIRQ     = uIRQ;
    274     mData->mPipe    = pipe;
    275     mData->mServer  = fServer;
     282    mData->mEnabled  = fEnabled;
     283    mData->mSlot     = uSlot;
     284    mData->mIOBase   = uIOBase;
     285    mData->mIRQ      = uIRQ;
     286    mData->mPath     = path;
     287    mData->mServer   = fServer;
    276288
    277289    return S_OK;
    … …  
    291303    ComAssertRCRet (vrc, E_FAIL);
    292304
     305    const char *mode;
     306    switch (mData->mHostMode)
     307    {
     308        default:
     309        case SerialHostMode_Disconnected:
     310            mode = "Disconnected";
     311            break;
     312        case SerialHostMode_HostPipe:
     313            mode = "HostPipe";
     314            break;
     315        case SerialHostMode_HostDevice:
     316            mode = "HostDevice";
     317            break;
     318    }
    293319    CFGLDRSetUInt32 (portNode, "slot",    mData->mSlot);
    294320    CFGLDRSetBool   (portNode, "enabled", !!mData->mEnabled);
    295     CFGLDRSetUInt32 (portNode, "IOBase",  mData->mIOBase);
    296     CFGLDRSetUInt32 (portNode, "IRQ",     mData->mIRQ);
    297     CFGLDRSetBSTR   (portNode, "pipe",    mData->mPipe);
    298     CFGLDRSetBool   (portNode, "server",  !!mData->mServer);
     321    if (mData->mEnabled)
     322    {
     323        CFGLDRSetUInt32 (portNode, "IOBase",  mData->mIOBase);
     324        CFGLDRSetUInt32 (portNode, "IRQ",     mData->mIRQ);
     325        CFGLDRSetString (portNode, "HostMode", mode);
     326        CFGLDRSetBSTR   (portNode, "path",    mData->mPath);
     327        if (mData->mHostMode == SerialHostMode_HostPipe)
     328            CFGLDRSetBool   (portNode, "server",  !!mData->mServer);
     329    }
    299330
    300331    return S_OK;
    … …  
    346377}
    347378
    348 STDMETHODIMP SerialPort::COMGETTER(Slot) (ULONG *aSlot)
    349 {
    350     if (!aSlot)
     379STDMETHODIMP SerialPort::COMGETTER(HostMode) (ULONG *aHostMode)
     380{
     381    if (!aHostMode)
    351382        return E_POINTER;
    352383
    … …  
    356387    AutoReaderLock alock (this);
    357388
    358     *aSlot = mData->mSlot;
    359 
    360     return S_OK;
    361 }
    362 
    363 STDMETHODIMP SerialPort::COMGETTER(IRQ) (ULONG *aIRQ)
    364 {
    365     if (!aIRQ)
    366         return E_POINTER;
    367 
    368     AutoCaller autoCaller (this);
    369     CheckComRCReturnRC (autoCaller.rc());
    370 
    371     AutoReaderLock alock (this);
    372 
    373     *aIRQ = mData->mIRQ;
    374 
    375     return S_OK;
    376 }
    377 
    378 STDMETHODIMP SerialPort::COMSETTER(IRQ)(ULONG aIRQ)
     389    *aHostMode = mData->mHostMode;
     390
     391    return S_OK;
     392}
     393
     394STDMETHODIMP SerialPort::COMSETTER(HostMode) (ULONG aHostMode)
    379395{
    380396    AutoCaller autoCaller (this);
    … …  
    390406    bool emitChangeEvent = false;
    391407
     408    if (mData->mHostMode != aHostMode)
     409    {
     410        mData.backup();
     411        mData->mHostMode = aHostMode;
     412        emitChangeEvent = true;
     413    }
     414
     415    if (emitChangeEvent)
     416    {
     417        /* leave the lock before informing callbacks */
     418        alock.unlock();
     419
     420        mParent->onSerialPortChange (this);
     421    }
     422
     423    return rc;
     424}
     425
     426STDMETHODIMP SerialPort::COMGETTER(Slot) (ULONG *aSlot)
     427{
     428    if (!aSlot)
     429        return E_POINTER;
     430
     431    AutoCaller autoCaller (this);
     432    CheckComRCReturnRC (autoCaller.rc());
     433
     434    AutoReaderLock alock (this);
     435
     436    *aSlot = mData->mSlot;
     437
     438    return S_OK;
     439}
     440
     441STDMETHODIMP SerialPort::COMGETTER(IRQ) (ULONG *aIRQ)
     442{
     443    if (!aIRQ)
     444        return E_POINTER;
     445
     446    AutoCaller autoCaller (this);
     447    CheckComRCReturnRC (autoCaller.rc());
     448
     449    AutoReaderLock alock (this);
     450
     451    *aIRQ = mData->mIRQ;
     452
     453    return S_OK;
     454}
     455
     456STDMETHODIMP SerialPort::COMSETTER(IRQ)(ULONG aIRQ)
     457{
     458    AutoCaller autoCaller (this);
     459    CheckComRCReturnRC (autoCaller.rc());
     460
     461    /* the machine needs to be mutable */
     462    Machine::AutoMutableStateDependency adep (mParent);
     463    CheckComRCReturnRC (adep.rc());
     464
     465    AutoLock alock (this);
     466
     467    HRESULT rc = S_OK;
     468    bool emitChangeEvent = false;
     469
    392470    if (mData->mIRQ != aIRQ)
    393471    {
    … …  
    455533}
    456534
    457 STDMETHODIMP SerialPort::COMGETTER(Pipe) (BSTR *aPipe)
    458 {
    459     if (!aPipe)
     535STDMETHODIMP SerialPort::COMGETTER(Path) (BSTR *aPath)
     536{
     537    if (!aPath)
    460538        return E_POINTER;
    461539
    … …  
    465543    AutoReaderLock alock (this);
    466544
    467     mData->mPipe.cloneTo (aPipe);
    468 
    469     return S_OK;
    470 }
    471 
    472 STDMETHODIMP SerialPort::COMSETTER(Pipe) (INPTR BSTR aPipe)
    473 {
    474     if (!aPipe || *aPipe == 0)
     545    mData->mPath.cloneTo (aPath);
     546
     547    return S_OK;
     548}
     549
     550STDMETHODIMP SerialPort::COMSETTER(Path) (INPTR BSTR aPath)
     551{
     552    if (!aPath || *aPath == 0)
    475553        return E_INVALIDARG;
    476554
    … …  
    484562    AutoLock alock (this);
    485563
    486     if (mData->mPipe != aPipe)
     564    if (mData->mPath != aPath)
    487565    {
    488566        mData.backup();
    489         mData->mPipe = aPipe;
     567        mData->mPath = aPath;
    490568
    491569        /* leave the lock before informing callbacks */

  • trunk/src/VBox/Main/idl/VirtualBox.xidl

    r4131 r4269  
    70067006  -->
    70077007
     7008  <enum
     7009     name="SerialHostMode"
     7010     uuid="5ac6ae50-30d4-4c89-8f9c-35b4500a5b9f"
     7011     >
     7012    <const name="Disconnected"        value="0"/>
     7013    <const name="HostPipe"            value="1"/>
     7014    <const name="HostDevice"          value="2"/>
     7015  </enum>
     7016
    70087017  <interface
    70097018     name="ISerialPort" extends="$unknown"
    … …  
    70357044    </attribute>
    70367045
    7037     <attribute name="pipe" type="wstring">
    7038       <desc>Gets the name of the host pipe connected to the serial port.</desc>
     7046    <attribute name="HostMode" type="SerialHostMode">
     7047      <desc>How is this port connected to the host.</desc>
    70397048    </attribute>
    70407049
    70417050    <attribute name="server" type="boolean">
     7051      <desc>Flag whether this serial port acts as a server or a client.</desc>
     7052    </attribute>
     7053
     7054    <attribute name="path" type="wstring">
    70427055      <desc>Flag whether this serial port acts as a server or a client.</desc>
    70437056    </attribute>

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

    r4071 r4269  
    3737        Data()
    3838            : mSlot (0)
    39             , mEnabled(FALSE)
     39            , mEnabled (FALSE)
     40            , mHostMode (SerialHostMode_Disconnected)
    4041            , mIRQ (4)
    4142            , mIOBase (0x3f8)
     43            , mServer (FALSE)
    4244        {}
    4345
    … …  
    4547        {
    4648            return this == &that ||
    47                    (mSlot == that.mSlot &&
    48                     mEnabled == that.mEnabled &&
    49                     mIRQ == that.mIRQ &&
    50                     mIOBase == that.mIOBase);
     49                   (mSlot     == that.mSlot     &&
     50                    mEnabled  == that.mEnabled  &&
     51                    mHostMode == that.mHostMode &&
     52                    mIRQ      == that.mIRQ      &&
     53                    mIOBase   == that.mIOBase);
    5154        }
    5255
    5356        ULONG mSlot;
    5457        BOOL  mEnabled;
     58        ULONG mHostMode;
    5559        ULONG mIRQ;
    5660        ULONG mIOBase;
    57         Bstr  mPipe;
     61        Bstr  mPath;
    5862        BOOL  mServer;
    5963    };
    … …  
    8488
    8589    // ISerialPort properties
    86     STDMETHOD(COMGETTER(Slot))    (ULONG     *aSlot);
    87     STDMETHOD(COMGETTER(Enabled)) (BOOL      *aEnabled);
    88     STDMETHOD(COMSETTER(Enabled)) (BOOL       aEnabled);
    89     STDMETHOD(COMGETTER(IRQ))     (ULONG     *aIRQ);
    90     STDMETHOD(COMSETTER(IRQ))     (ULONG      aIRQ);
    91     STDMETHOD(COMGETTER(IOBase))  (ULONG     *aIOBase);
    92     STDMETHOD(COMSETTER(IOBase))  (ULONG      aIOBase);
    93     STDMETHOD(COMGETTER(Pipe))    (BSTR      *aPipe);
    94     STDMETHOD(COMSETTER(Pipe))    (INPTR BSTR aPipe);
    95     STDMETHOD(COMGETTER(Server))  (BOOL      *aServer);
    96     STDMETHOD(COMSETTER(Server))  (BOOL       aServer);
     90    STDMETHOD(COMGETTER(Slot))     (ULONG     *aSlot);
     91    STDMETHOD(COMGETTER(Enabled))  (BOOL      *aEnabled);
     92    STDMETHOD(COMSETTER(Enabled))  (BOOL       aEnabled);
     93    STDMETHOD(COMGETTER(HostMode)) (ULONG    *aHostMode);
     94    STDMETHOD(COMSETTER(HostMode)) (ULONG     aHostMode);
     95    STDMETHOD(COMGETTER(IRQ))      (ULONG     *aIRQ);
     96    STDMETHOD(COMSETTER(IRQ))      (ULONG      aIRQ);
     97    STDMETHOD(COMGETTER(IOBase) )  (ULONG     *aIOBase);
     98    STDMETHOD(COMSETTER(IOBase))   (ULONG      aIOBase);
     99    STDMETHOD(COMGETTER(Path))     (BSTR      *aPath);
     100    STDMETHOD(COMSETTER(Path))     (INPTR BSTR aPath);
     101    STDMETHOD(COMGETTER(Server))   (BOOL      *aServer);
     102    STDMETHOD(COMSETTER(Server))   (BOOL       aServer);
    97103
    98104    // public methods only for internal purposes

  • trunk/src/VBox/Main/xml/VirtualBox-settings-common.xsd

    r4071 r4269  
    172172</xsd:simpleType>
    173173
     174<xsd:simpleType name="TUartHostModeType">
     175    <xsd:restriction base="xsd:string">
     176      <xsd:enumeration value="Disconnected"/>
     177      <xsd:enumeration value="HostPipe"/>
     178      <xsd:enumeration value="HostDevice"/>
     179    </xsd:restriction>
     180</xsd:simpleType>
     181
    174182<!--
    175183// Complex types
    … …  
    523531  <xsd:attribute name="IRQ" type="xsd:unsignedInt" default="4"/>
    524532  <xsd:attribute name="IOBase" type="xsd:unsignedInt" default="1016"/>
     533  <xsd:attribute name="HostMode" type="TUartHostModeType" default="Disconnected"/>
    525534  <xsd:attribute name="pipe" type="xsd:string"/>
     535  <xsd:attribute name="path" type="xsd:string"/>
    526536  <xsd:attribute name="server" type="xsd:boolean"/>
    527537</xsd:complexType>
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