VirtualBox

Changeset 97071 in vbox for trunk/src/VBox/NetworkServices


Ignore:
Timestamp:
Oct 10, 2022 4:30:56 PM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
154021
Message:

NetworkServices: Implement support for communicating over the R3 internal network service in driverless mode, bugref:10297

Location:
trunk/src/VBox/NetworkServices
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/NetworkServices/Dhcpd/Makefile.kmk

    r96407 r97071  
    6565VBoxNetDHCP_DEFS      = KBUILD_TYPE=\"$(KBUILD_TYPE)\"
    6666endif
    67 #VBoxNetDHCP_DEFS     = IPv6
     67VBoxNetDHCP_DEFS       += \
     68        $(if $(VBOX_WITH_INTNET_SERVICE_IN_R3),VBOX_WITH_INTNET_SERVICE_IN_R3,)
     69
     70#VBoxNetDHCP_DEFS     += IPv6
    6871#VBoxNetDHCP_DEFS.linux = WITH_VALGRIND
    6972ifneq ($(KBUILD_TARGET),win)
    … …  
    7578 endif
    7679endif
     80VBoxNetDHCP_INCS += \
     81        ../NetLib
    7782VBoxNetDHCP_SOURCES = \
    7883        ClientId.cpp \
    … …  
    8590        Timestamp.cpp \
    8691        VBoxNetDhcpd.cpp \
     92        ../NetLib/IntNetIfCtx.cpp \
    8793        ../../Main/glue/VBoxLogRelCreate.cpp \
    8894        ../../Main/glue/GetVBoxUserHomeDirectory.cpp \

  • trunk/src/VBox/NetworkServices/Dhcpd/VBoxNetDhcpd.cpp

    r96407 r97071  
    8888#endif
    8989
     90#include "IntNetIf.h"
     91
    9092struct delete_pbuf
    9193{
    … …  
    9799
    98100
    99 #define CALL_VMMR0(op, req) \
    100     (SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, (op), 0, &(req).Hdr))
    101 
    102 
    103101class VBoxNetDhcpd
    104102{
    … …  
    109107
    110108    /* intnet plumbing */
    111     PSUPDRVSESSION m_pSession;
    112     INTNETIFHANDLE m_hIf;
    113     PINTNETBUF m_pIfBuf;
     109    INTNETIFCTX    m_hIf;
     110    PINTNETBUF     m_pIfBuf;
    114111
    115112    /* lwip stack connected to the intnet */
    … …  
    178175VBoxNetDhcpd::VBoxNetDhcpd()
    179176  : m_pStderrReleaseLogger(NULL),
    180     m_pSession(NIL_RTR0PTR),
    181177    m_hIf(INTNET_HANDLE_INVALID),
    182178    m_pIfBuf(NULL),
    … …  
    185181    m_Dhcp4Pcb(NULL)
    186182{
    187     int rc;
    188 
    189183    logInitStderr();
    190 
    191     rc = r3Init();
    192     if (RT_FAILURE(rc))
    193         return;
    194 
    195     vmmInit();
    196184}
    197185
    … …  
    200188{
    201189    ifClose();
    202     r3Fini();
    203190}
    204191
    … …  
    241228
    242229
    243 int VBoxNetDhcpd::r3Init()
    244 {
    245     AssertReturn(m_pSession == NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    246 
    247     int rc = SUPR3Init(&m_pSession);
    248     return rc;
    249 }
    250 
    251 
    252 void VBoxNetDhcpd::r3Fini()
    253 {
    254     if (m_pSession == NIL_RTR0PTR)
    255         return;
    256 
    257     SUPR3Term();
    258     m_pSession = NIL_RTR0PTR;
    259 }
    260 
    261 
    262 int VBoxNetDhcpd::vmmInit()
    263 {
    264     char szPathVMMR0[RTPATH_MAX];
    265     int rc = RTPathExecDir(szPathVMMR0, sizeof(szPathVMMR0));
    266     if (RT_SUCCESS(rc))
    267         rc = RTPathAppend(szPathVMMR0, sizeof(szPathVMMR0), "VMMR0.r0");
    268     if (RT_SUCCESS(rc))
    269         rc = SUPR3LoadVMM(szPathVMMR0, NULL /*pErrInfo*/);
    270     return rc;
    271 }
    272 
    273 
    274230int VBoxNetDhcpd::ifInit(const RTCString &strNetwork,
    275231                         const RTCString &strTrunk,
    … …  
    298254                         INTNETTRUNKTYPE enmTrunkType)
    299255{
    300     AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    301     AssertReturn(m_hIf == INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
    302 
    303     INTNETOPENREQ OpenReq;
    304     RT_ZERO(OpenReq);
    305 
    306     OpenReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    307     OpenReq.Hdr.cbReq = sizeof(OpenReq);
    308     OpenReq.pSession = m_pSession;
    309 
    310     int rc = RTStrCopy(OpenReq.szNetwork, sizeof(OpenReq.szNetwork), strNetwork.c_str());
    311     AssertRCReturn(rc, rc);
    312 
    313     rc = RTStrCopy(OpenReq.szTrunk, sizeof(OpenReq.szTrunk), strTrunk.c_str());
    314     AssertRCReturn(rc, rc);
    315 
    316     if (enmTrunkType != kIntNetTrunkType_Invalid)
    317         OpenReq.enmTrunkType = enmTrunkType;
    318     else
    319         OpenReq.enmTrunkType = kIntNetTrunkType_WhateverNone;
    320 
    321     OpenReq.fFlags = 0;
    322     OpenReq.cbSend = _128K;
    323     OpenReq.cbRecv = _256K;
    324 
    325     OpenReq.hIf = INTNET_HANDLE_INVALID;
    326 
    327     rc = CALL_VMMR0(VMMR0_DO_INTNET_OPEN, OpenReq);
    328     if (RT_FAILURE(rc))
    329         return rc;
    330 
    331     m_hIf = OpenReq.hIf;
    332     AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
    333 
    334     return VINF_SUCCESS;
     256    AssertReturn(m_hIf == NULL, VERR_GENERAL_FAILURE);
     257
     258    if (enmTrunkType == kIntNetTrunkType_Invalid)
     259        enmTrunkType = kIntNetTrunkType_WhateverNone;
     260
     261    return IntNetR3IfCtxCreate(&m_hIf, strNetwork.c_str(), enmTrunkType,
     262                               strTrunk.c_str(), _128K /*cbSend*/, _256K /*cbRecv*/,
     263                               0 /*fFlags*/);
    335264}
    336265
    … …  
    338267int VBoxNetDhcpd::ifGetBuf()
    339268{
    340     AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    341     AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
     269    AssertReturn(m_hIf != NULL, VERR_GENERAL_FAILURE);
    342270    AssertReturn(m_pIfBuf == NULL, VERR_GENERAL_FAILURE);
    343271
    344     INTNETIFGETBUFFERPTRSREQ GetBufferPtrsReq;
    345     int rc;
    346 
    347     GetBufferPtrsReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    348     GetBufferPtrsReq.Hdr.cbReq = sizeof(GetBufferPtrsReq);
    349     GetBufferPtrsReq.pSession = m_pSession;
    350     GetBufferPtrsReq.hIf = m_hIf;
    351 
    352     GetBufferPtrsReq.pRing0Buf = NIL_RTR0PTR;
    353     GetBufferPtrsReq.pRing3Buf = NULL;
    354 
    355     rc = CALL_VMMR0(VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS, GetBufferPtrsReq);
    356     if (RT_FAILURE(rc))
    357         return rc;
    358 
    359     m_pIfBuf = GetBufferPtrsReq.pRing3Buf;
     272    return IntNetR3IfCtxQueryBufferPtr(m_hIf, &m_pIfBuf);
     273}
     274
     275
     276int VBoxNetDhcpd::ifActivate()
     277{
     278    AssertReturn(m_hIf != NULL, VERR_GENERAL_FAILURE);
    360279    AssertReturn(m_pIfBuf != NULL, VERR_GENERAL_FAILURE);
    361280
    362     return VINF_SUCCESS;
    363 }
    364 
    365 
    366 int VBoxNetDhcpd::ifActivate()
    367 {
    368     AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    369     AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
    370     AssertReturn(m_pIfBuf != NULL, VERR_GENERAL_FAILURE);
    371 
    372     INTNETIFSETACTIVEREQ ActiveReq;
    373     int rc;
    374 
    375     ActiveReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    376     ActiveReq.Hdr.cbReq = sizeof(ActiveReq);
    377     ActiveReq.pSession = m_pSession;
    378     ActiveReq.hIf = m_hIf;
    379 
    380     ActiveReq.fActive = 1;
    381 
    382     rc = CALL_VMMR0(VMMR0_DO_INTNET_IF_SET_ACTIVE, ActiveReq);
    383     return rc;
     281    return IntNetR3IfCtxSetActive(m_hIf, true /*fActive*/);
    384282}
    385283
    … …  
    398296         * Wait for input:
    399297         */
    400         INTNETIFWAITREQ WaitReq;
    401         WaitReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    402         WaitReq.Hdr.cbReq = sizeof(WaitReq);
    403         WaitReq.pSession = m_pSession;
    404         WaitReq.hIf = m_hIf;
    405         WaitReq.cMillies = RT_INDEFINITE_WAIT;
    406         int rc = CALL_VMMR0(VMMR0_DO_INTNET_IF_WAIT, WaitReq);
    407 
     298        int rc = IntNetR3IfWait(m_hIf, RT_INDEFINITE_WAIT);
    408299        /*
    409300         * Process any pending input before we wait again:
    … …  
    424315int VBoxNetDhcpd::ifProcessInput()
    425316{
    426     AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    427     AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
     317    AssertReturn(m_hIf != NULL, VERR_GENERAL_FAILURE);
    428318    AssertReturn(m_pIfBuf != NULL, VERR_GENERAL_FAILURE);
    429319
    … …  
    544434int VBoxNetDhcpd::ifFlush()
    545435{
    546     INTNETIFSENDREQ SendReq;
    547 
    548     SendReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    549     SendReq.Hdr.cbReq = sizeof(SendReq);
    550     SendReq.pSession = m_pSession;
    551 
    552     SendReq.hIf = m_hIf;
    553 
    554     return CALL_VMMR0(VMMR0_DO_INTNET_IF_SEND, SendReq);
     436    return IntNetR3IfSend(m_hIf);
    555437}
    556438
    … …  
    558440int VBoxNetDhcpd::ifClose()
    559441{
    560     if (m_hIf == INTNET_HANDLE_INVALID)
     442    if (m_hIf == NULL)
    561443        return VINF_SUCCESS;
    562444
    563     INTNETIFCLOSEREQ CloseReq;
    564 
    565     CloseReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    566     CloseReq.Hdr.cbReq = sizeof(CloseReq);
    567     CloseReq.pSession = m_pSession;
    568 
    569     CloseReq.hIf = m_hIf;
    570 
    571     m_hIf = INTNET_HANDLE_INVALID;
    572     m_pIfBuf = NULL;
    573 
    574     CALL_VMMR0(VMMR0_DO_INTNET_IF_CLOSE, CloseReq);
    575     return VINF_SUCCESS;
     445    int rc = IntNetR3IfCtxDestroy(m_hIf);
     446    m_hIf = NULL;
     447    return rc;
    576448}
    577449

  • trunk/src/VBox/NetworkServices/IntNetSwitch/main.cpp

    r97058 r97071  
    456456        {
    457457            /* Send an empty message. */
    458             xpc_object_t hObjPoke = xpc_dictionary_create_empty();
     458            xpc_object_t hObjPoke = xpc_dictionary_create(NULL, NULL, 0);
    459459            xpc_connection_send_message(pSession->hXpcCon, hObjPoke);
    460460        }

  • trunk/src/VBox/NetworkServices/NAT/Makefile.kmk

    r96407 r97071  
    6868VBoxNetNAT_TEMPLATE := $(if-expr defined(VBOX_WITH_HARDENING),VBOXMAINDLL,VBOXMAINCLIENTEXE)
    6969VBoxNetNAT_NAME     := VBoxNetNAT
    70 VBoxNetNAT_DEFS      = IPv6
     70VBoxNetNAT_DEFS      = \
     71        IPv6 \
     72        $(if $(VBOX_WITH_INTNET_SERVICE_IN_R3),VBOX_WITH_INTNET_SERVICE_IN_R3,)
    7173# VBoxNetNAT_DEFS.linux = WITH_VALGRIND # instrument lwip memp.c
    7274VBoxNetNAT_DEFS.win  = VBOX_COM_OUTOFPROC_MODULE _WIN32_WINNT=0x501 # Windows XP
    … …  
    104106        VBoxNetLwipNAT.cpp \
    105107        ../NetLib/IntNetIf.cpp \
     108        ../NetLib/IntNetIfCtx.cpp \
    106109        ../NetLib/VBoxNetPortForwardString.cpp \
    107110        $(addprefix ../../Devices/Network/lwip-new/,$(LWIP_SOURCES)) \

  • trunk/src/VBox/NetworkServices/NetLib/IntNetIf.cpp

    r96407 r97071  
    3333#include <VBox/vmm/pdmnetinline.h>
    3434
    35 #define CALL_VMMR0(op, req) \
    36     (SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, (op), 0, &(req).Hdr))
    37 
    38 
    39 
    4035IntNetIf::IntNetIf()
    41   : m_pSession(NIL_RTR0PTR),
    42     m_hIf(INTNET_HANDLE_INVALID),
     36  : m_hIf(NULL),
    4337    m_pIfBuf(NULL),
    4438    m_pfnInput(NULL),
    … …  
    5751
    5852
    59 
    60 /*
    61  * SUPDrv and VMM initialization and finalization.
    62  */
    63 
    64 int
    65 IntNetIf::r3Init()
    66 {
    67     AssertReturn(m_pSession == NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    68 
    69     int rc = SUPR3Init(&m_pSession);
    70     return rc;
    71 }
    72 
    73 
    74 void
    75 IntNetIf::r3Fini()
    76 {
    77     if (m_pSession == NIL_RTR0PTR)
    78         return;
    79 
    80     SUPR3Term();
    81     m_pSession = NIL_RTR0PTR;
    82 }
    83 
    84 
    85 int
    86 IntNetIf::vmmInit()
    87 {
    88     char szPathVMMR0[RTPATH_MAX];
    89     int rc;
    90 
    91     rc = RTPathExecDir(szPathVMMR0, sizeof(szPathVMMR0));
    92     if (RT_FAILURE(rc))
    93         return rc;
    94 
    95     rc = RTPathAppend(szPathVMMR0, sizeof(szPathVMMR0), "VMMR0.r0");
    96     if (RT_FAILURE(rc))
    97         return rc;
    98 
    99     rc = SUPR3LoadVMM(szPathVMMR0, /* :pErrInfo */ NULL);
    100     return rc;
    101 }
    102 
    103 
    104 
    10553/*
    10654 * Wrappers for VMM ioctl requests and low-level intnet operations.
    … …  
    12169                 const RTCString &strTrunk)
    12270{
    123     AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    124     AssertReturn(m_hIf == INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
    125 
    126     INTNETOPENREQ OpenReq;
    127     RT_ZERO(OpenReq);
    128 
    129     OpenReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    130     OpenReq.Hdr.cbReq = sizeof(OpenReq);
    131     OpenReq.pSession = m_pSession;
    132 
    133     int rc = RTStrCopy(OpenReq.szNetwork, sizeof(OpenReq.szNetwork), strNetwork.c_str());
    134     AssertRCReturn(rc, rc);
    135 
    136     rc = RTStrCopy(OpenReq.szTrunk, sizeof(OpenReq.szTrunk), strTrunk.c_str());
    137     AssertRCReturn(rc, rc);
    138 
    139     if (enmTrunkType != kIntNetTrunkType_Invalid)
    140         OpenReq.enmTrunkType = enmTrunkType;
    141     else
    142         OpenReq.enmTrunkType = kIntNetTrunkType_WhateverNone;
    143 
    144     OpenReq.fFlags = 0;
    145     OpenReq.cbSend = _128K;
    146     OpenReq.cbRecv = _256K;
    147 
    148     OpenReq.hIf = INTNET_HANDLE_INVALID;
    149 
    150     rc = CALL_VMMR0(VMMR0_DO_INTNET_OPEN, OpenReq);
    151     if (RT_FAILURE(rc))
    152         return rc;
    153 
    154     m_hIf = OpenReq.hIf;
    155     AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
    156 
    157     return VINF_SUCCESS;
     71    AssertReturn(m_hIf == NULL, VERR_GENERAL_FAILURE);
     72
     73    if (enmTrunkType == kIntNetTrunkType_Invalid)
     74        enmTrunkType = kIntNetTrunkType_WhateverNone;
     75
     76    return IntNetR3IfCtxCreate(&m_hIf, strNetwork.c_str(), enmTrunkType,
     77                               strTrunk.c_str(), _128K /*cbSend*/, _256K /*cbRecv*/,
     78                               0 /*fFlags*/);
    15879}
    15980
    … …  
    16586IntNetIf::ifSetPromiscuous(bool fPromiscuous)
    16687{
    167     AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    168     AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
    169 
    170     INTNETIFSETPROMISCUOUSMODEREQ SetPromiscuousModeReq;
    171     int rc;
    172 
    173     SetPromiscuousModeReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    174     SetPromiscuousModeReq.Hdr.cbReq = sizeof(SetPromiscuousModeReq);
    175     SetPromiscuousModeReq.pSession = m_pSession;
    176     SetPromiscuousModeReq.hIf = m_hIf;
    177 
    178     SetPromiscuousModeReq.fPromiscuous = fPromiscuous;
    179 
    180     rc = CALL_VMMR0(VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE, SetPromiscuousModeReq);
    181     if (RT_FAILURE(rc))
    182         return rc;
    183 
    184     return VINF_SUCCESS;
     88    AssertReturn(m_hIf != NULL, VERR_GENERAL_FAILURE);
     89
     90    return IntNetR3IfCtxSetPromiscuous(m_hIf, fPromiscuous);
    18591}
    18692
    … …  
    194100IntNetIf::ifGetBuf()
    195101{
    196     AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    197     AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
     102    AssertReturn(m_hIf != NULL, VERR_GENERAL_FAILURE);
    198103    AssertReturn(m_pIfBuf == NULL, VERR_GENERAL_FAILURE);
    199104
    200     INTNETIFGETBUFFERPTRSREQ GetBufferPtrsReq;
    201     int rc;
    202 
    203     GetBufferPtrsReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    204     GetBufferPtrsReq.Hdr.cbReq = sizeof(GetBufferPtrsReq);
    205     GetBufferPtrsReq.pSession = m_pSession;
    206     GetBufferPtrsReq.hIf = m_hIf;
    207 
    208     GetBufferPtrsReq.pRing0Buf = NIL_RTR0PTR;
    209     GetBufferPtrsReq.pRing3Buf = NULL;
    210 
    211     rc = CALL_VMMR0(VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS, GetBufferPtrsReq);
    212     if (RT_FAILURE(rc))
    213         return rc;
    214 
    215     m_pIfBuf = GetBufferPtrsReq.pRing3Buf;
    216     AssertReturn(m_pIfBuf != NULL, VERR_GENERAL_FAILURE);
    217 
    218     return VINF_SUCCESS;
     105    return IntNetR3IfCtxQueryBufferPtr(m_hIf, &m_pIfBuf);
    219106}
    220107
    … …  
    228115IntNetIf::ifActivate()
    229116{
    230     AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    231     AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
     117    AssertReturn(m_hIf != NULL, VERR_GENERAL_FAILURE);
    232118    AssertReturn(m_pIfBuf != NULL, VERR_GENERAL_FAILURE);
    233119
    234     INTNETIFSETACTIVEREQ ActiveReq;
    235     int rc;
    236 
    237     ActiveReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    238     ActiveReq.Hdr.cbReq = sizeof(ActiveReq);
    239     ActiveReq.pSession = m_pSession;
    240     ActiveReq.hIf = m_hIf;
    241 
    242     ActiveReq.fActive = 1;
    243 
    244     rc = CALL_VMMR0(VMMR0_DO_INTNET_IF_SET_ACTIVE, ActiveReq);
    245     return rc;
     120    return IntNetR3IfCtxSetActive(m_hIf, true /*fActive*/);
    246121}
    247122
    … …  
    257132IntNetIf::ifWait(uint32_t cMillies)
    258133{
    259     AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    260     AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
    261 
    262     INTNETIFWAITREQ WaitReq;
    263     int rc;
    264 
    265     WaitReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    266     WaitReq.Hdr.cbReq = sizeof(WaitReq);
    267     WaitReq.pSession = m_pSession;
    268     WaitReq.hIf = m_hIf;
    269 
    270     WaitReq.cMillies = cMillies;
    271 
    272     rc = CALL_VMMR0(VMMR0_DO_INTNET_IF_WAIT, WaitReq);
    273     return rc;
     134    AssertReturn(m_hIf != NULL, VERR_GENERAL_FAILURE);
     135
     136    return IntNetR3IfWait(m_hIf, cMillies);
    274137}
    275138
    … …  
    281144IntNetIf::ifAbort()
    282145{
    283     AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    284     AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
    285 
    286     INTNETIFABORTWAITREQ AbortReq;
    287     int rc;
    288 
    289     AbortReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    290     AbortReq.Hdr.cbReq = sizeof(AbortReq);
    291     AbortReq.pSession = m_pSession;
    292     AbortReq.hIf = m_hIf;
    293 
    294     AbortReq.fNoMoreWaits = true;
    295 
    296     rc = CALL_VMMR0(VMMR0_DO_INTNET_IF_ABORT_WAIT, AbortReq);
    297     return rc;
     146    AssertReturn(m_hIf != NULL, VERR_GENERAL_FAILURE);
     147
     148    return IntNetR3IfWaitAbort(m_hIf);
    298149}
    299150
    … …  
    307158IntNetIf::ifProcessInput()
    308159{
    309     AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    310160    AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
    311161    AssertReturn(m_pIfBuf != NULL, VERR_GENERAL_FAILURE);
    … …  
    374224IntNetIf::ifFlush()
    375225{
    376     AssertReturn(m_pSession != NIL_RTR0PTR, VERR_GENERAL_FAILURE);
    377     AssertReturn(m_hIf != INTNET_HANDLE_INVALID, VERR_GENERAL_FAILURE);
    378 
    379     INTNETIFSENDREQ SendReq;
    380     int rc;
    381 
    382     SendReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    383     SendReq.Hdr.cbReq = sizeof(SendReq);
    384     SendReq.pSession = m_pSession;
    385     SendReq.hIf = m_hIf;
    386 
    387     rc = CALL_VMMR0(VMMR0_DO_INTNET_IF_SEND, SendReq);
    388     return rc;
     226    AssertReturn(m_hIf != NULL, VERR_GENERAL_FAILURE);
     227
     228    return IntNetR3IfSend(m_hIf);
    389229}
    390230
    … …  
    397237IntNetIf::ifClose()
    398238{
    399     if (m_hIf == INTNET_HANDLE_INVALID)
     239    if (m_hIf == NULL)
    400240        return VINF_SUCCESS;
    401241
    402     INTNETIFCLOSEREQ CloseReq;
    403 
    404     CloseReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    405     CloseReq.Hdr.cbReq = sizeof(CloseReq);
    406     CloseReq.pSession = m_pSession;
    407     CloseReq.hIf = m_hIf;
    408 
    409     m_hIf = INTNET_HANDLE_INVALID;
    410     m_pIfBuf = NULL;
    411 
    412     CALL_VMMR0(VMMR0_DO_INTNET_IF_CLOSE, CloseReq);
    413     return VINF_SUCCESS;
     242    int rc = IntNetR3IfCtxDestroy(m_hIf);
     243    m_hIf = NULL;
     244    return rc;
    414245}
    415246
    … …  
    434265               const RTCString &strTrunk)
    435266{
    436     int rc;
    437 
    438     rc = r3Init();
    439     if (RT_FAILURE(rc))
    440         return rc;
    441 
    442     rc = vmmInit();
    443     if (RT_FAILURE(rc))
    444         return rc;
    445 
    446     rc = ifOpen(strNetwork, enmTrunkType, strTrunk);
     267    int rc = ifOpen(strNetwork, enmTrunkType, strTrunk);
    447268    if (RT_FAILURE(rc))
    448269        return rc;
    … …  
    464285{
    465286    ifClose();
    466     r3Fini();
    467287}
    468288

  • trunk/src/VBox/NetworkServices/NetLib/IntNetIf.h

    r96407 r97071  
    4040#include <VBox/vmm/vmm.h>
    4141#include <VBox/intnet.h>
     42
     43
     44
     45/**
     46 * Low-level internal network access helpers to hide away the different variants (R0 SUP or R3 XPC on macOS).
     47 */
     48/** Internal networking interface context handle. */
     49typedef struct INTNETIFCTXINT *INTNETIFCTX;
     50/** Pointer to an internal networking interface context handle. */
     51typedef INTNETIFCTX *PINTNETIFCTX;
     52
     53
     54DECLHIDDEN(int) IntNetR3IfCtxCreate(PINTNETIFCTX phIfCtx, const char *pszNetwork, INTNETTRUNKTYPE enmTrunkType,
     55                                    const char *pszTrunk, size_t cbSend, size_t cbRecv, uint32_t fFlags);
     56DECLHIDDEN(int) IntNetR3IfCtxDestroy(INTNETIFCTX hIfCtx);
     57DECLHIDDEN(int) IntNetR3IfCtxQueryBufferPtr(INTNETIFCTX hIfCtx, PINTNETBUF *ppIfBuf);
     58DECLHIDDEN(int) IntNetR3IfCtxSetActive(INTNETIFCTX hIfCtx, bool fActive);
     59DECLHIDDEN(int) IntNetR3IfCtxSetPromiscuous(INTNETIFCTX hIfCtx, bool fPromiscuous);
     60DECLHIDDEN(int) IntNetR3IfSend(INTNETIFCTX hIfCtx);
     61DECLHIDDEN(int) IntNetR3IfWait(INTNETIFCTX hIfCtx, uint32_t cMillies);
     62DECLHIDDEN(int) IntNetR3IfWaitAbort(INTNETIFCTX hIfCtx);
    4263
    4364
    … …  
    87108
    88109private:
    89     PSUPDRVSESSION m_pSession;
    90     INTNETIFHANDLE m_hIf;
    91     PINTNETBUF m_pIfBuf;
     110    INTNETIFCTX m_hIf;
     111    PINTNETBUF  m_pIfBuf;
    92112
    93113    PFNINPUT m_pfnInput;
    … …  
    120140
    121141private:
    122     int r3Init();
    123     void r3Fini();
    124 
    125     int vmmInit();
    126 
    127142    int ifOpen(const RTCString &strNetwork,
    128143               INTNETTRUNKTYPE enmTrunkType,
Note: See TracChangeset for help on using the changeset viewer.

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