VirtualBox

Changeset 51254 in vbox for trunk/src/VBox/Additions


Ignore:
Timestamp:
May 15, 2014 8:00:46 AM (11 years ago)
Author:
vboxsync
Message:

Additions/SharedFolders: fixed ShflStringInitBuffer(), do really use this function for initializing the SHFLSTRING content; some cosmetcis

Location:
trunk/src/VBox/Additions
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/SharedFolders/driver/file.c

    r48944 r51254  
    115115
    116116                if (cbToTransfer > pCtx->cbData - cbTransferred)
    117                 {
    118117                    cbToTransfer = pCtx->cbData - cbTransferred;
    119                 }
    120118
    121119                if (cbToTransfer == 0)
    … …  
    131129
    132130                for (iPage = 0; iPage < cPagesToTransfer; iPage++)
    133                 {
    134131                    paPages[iPage] = (RTGCPHYS64)paPfns[iPage + cPagesTransferred] << PAGE_SHIFT;
    135                 }
    136132
    137133                rc = pCtx->pfnTransferPages(pCtx->pClient, pCtx->pMap, pCtx->hFile,
    … …  
    144140                    /* If some data was transferred, then it is no error. */
    145141                    if (cbTransferred > 0)
    146                     {
    147142                        rc = VINF_SUCCESS;
    148                     }
    149143
    150144                    break;
    … …  
    164158                cPagesToTransfer = cPages - cPagesTransferred;
    165159                if (cPagesToTransfer > VBSF_MAX_READ_WRITE_PAGES)
    166                 {
    167160                    cPagesToTransfer = VBSF_MAX_READ_WRITE_PAGES;
    168                 }
    169161            }
    170162
    … …  
    201193                /* If some data was transferred, then it is no error. */
    202194                if (cbTransferred > 0)
    203                 {
    204195                    rc = VINF_SUCCESS;
    205                 }
    206196
    207197                break;
    … …  
    218208            cbToTransfer = pCtx->cbData - cbTransferred;
    219209            if (cbToTransfer > VBSF_MAX_READ_WRITE_PAGES * PAGE_SIZE)
    220             {
    221210                cbToTransfer = VBSF_MAX_READ_WRITE_PAGES * PAGE_SIZE;
    222             }
    223211        }
    224212    }
    … …  
    277265
    278266        if (ByteCount > FileSize - ByteOffset)
    279         {
    280267            ByteCount = (ULONG)(FileSize - ByteOffset);
    281         }
    282268    }
    283269
    284270    /* @todo read 0 bytes == always success? */
    285     if (   BufferMdl == NULL
     271    if (   !BufferMdl
    286272        || ByteCount == 0)
    287273    {
    … …  
    343329                                               RxContext);
    344330
    345     Log(("VBOXSF: MRxRead: RxDispatchToWorkerThread: Status 0x%08X\n",
    346          Status));
     331    Log(("VBOXSF: MRxRead: RxDispatchToWorkerThread: Status 0x%08X\n", Status));
    347332
    348333    if (Status == STATUS_SUCCESS)
    349     {
    350334        Status = STATUS_PENDING;
    351     }
    352335
    353336    return Status;
    … …  
    389372
    390373    /* @todo allow to write 0 bytes. */
    391     if (   BufferMdl == NULL
     374    if (   !BufferMdl
    392375        || ByteCount == 0)
    393376    {
    … …  
    452435
    453436    if (Status == STATUS_SUCCESS)
    454     {
    455437        Status = STATUS_PENDING;
    456     }
    457438
    458439    return Status;
    … …  
    505486
    506487    if (LowIoContext->ParamsFor.Locks.Flags & LOWIO_LOCKSFLAG_FAIL_IMMEDIATELY)
    507     {
    508488        fu32Lock |= SHFL_LOCK_NOWAIT;
    509     }
    510489    else
    511     {
    512490        fu32Lock |= SHFL_LOCK_WAIT;
    513     }
    514491
    515492    vboxRC = vboxCallLock(&pDeviceExtension->hgcmClient, &pNetRootExtension->map, pVBoxFobx->hFile,
    … …  
    518495    Status = VBoxErrorToNTStatus(vboxRC);
    519496
    520     Log(("VBOXSF: MRxLocks: Returned 0x%08X\n",
    521          Status));
     497    Log(("VBOXSF: MRxLocks: Returned 0x%08X\n", Status));
    522498    return Status;
    523499}
    … …  
    551527    Status = VBoxErrorToNTStatus(vboxRC);
    552528
    553     Log(("VBOXSF: MRxFlush: Returned 0x%08X\n",
    554          Status));
     529    Log(("VBOXSF: MRxFlush: Returned 0x%08X\n", Status));
    555530    return Status;
    556531}
    … …  
    580555    cbBuffer = sizeof(SHFLFSOBJINFO);
    581556    pObjInfo = (SHFLFSOBJINFO *)vbsfAllocNonPagedMem(cbBuffer);
    582     if (pObjInfo == NULL)
     557    if (!pObjInfo)
    583558    {
    584559        AssertFailed();
    … …  
    592567                            SHFL_INFO_SET | SHFL_INFO_SIZE, &cbBuffer, (PSHFLDIRINFO)pObjInfo);
    593568
    594     Log(("VBOXSF: vbsfSetEndOfFile: vboxCallFSInfo returned %Rrc\n",
    595          vboxRC));
     569    Log(("VBOXSF: vbsfSetEndOfFile: vboxCallFSInfo returned %Rrc\n", vboxRC));
    596570
    597571    Status = VBoxErrorToNTStatus(vboxRC);
    … …  
    606580
    607581    if (pObjInfo)
    608     {
    609582        vbsfFreeNonPagedMem(pObjInfo);
    610     }
    611 
    612     Log(("VBOXSF: vbsfSetEndOfFile: Returned 0x%08X\n",
    613          Status));
     583
     584    Log(("VBOXSF: vbsfSetEndOfFile: Returned 0x%08X\n", Status));
    614585    return Status;
    615586}

  • trunk/src/VBox/Additions/WINNT/SharedFolders/driver/info.c

    r40532 r51254  
    5454
    5555    ULONG *pNextOffset = 0;
    56     PSHFLSTRING ParsedPath = 0;
     56    PSHFLSTRING ParsedPath = NULL;
    5757
    5858    Log(("VBOXSF: MrxQueryDirectory: FileInformationClass %d, pVBoxFobx %p, hFile %RX64, pInfoBuffer %p\n",
    5959         FileInformationClass, pVBoxFobx, pVBoxFobx->hFile, pInfoBuffer));
    6060
    61     if (NULL == pVBoxFobx)
     61    if (!pVBoxFobx)
    6262    {
    6363        Log(("VBOXSF: MrxQueryDirectory: pVBoxFobx is invalid!\n"));
    … …  
    6565    }
    6666
    67     if (NULL == DirectoryName)
    68     {
     67    if (!DirectoryName)
    6968        return STATUS_INVALID_PARAMETER;
    70     }
    7169
    7270    if (DirectoryName->Length == 0)
    73     {
    7471        Log(("VBOXSF: MrxQueryDirectory: DirectoryName = \\ (null string)\n"));
    75     }
    7672    else
    77     {
    7873        Log(("VBOXSF: MrxQueryDirectory: DirectoryName = %.*ls\n",
    7974             DirectoryName->Length / sizeof(WCHAR), DirectoryName->Buffer));
    80     }
    81 
    82     if (NULL == Template)
    83     {
     75
     76    if (!Template)
    8477        return STATUS_INVALID_PARAMETER;
    85     }
    8678
    8779    if (Template->Length == 0)
    88     {
    8980        Log(("VBOXSF: MrxQueryDirectory: Template = \\ (null string)\n"));
    90     }
    9181    else
    92     {
    9382        Log(("VBOXSF: MrxQueryDirectory: Template = %.*ls\n",
    9483             Template->Length / sizeof(WCHAR), Template->Buffer));
    95     }
    9684
    9785    cbHGCMBuffer = RT_MAX(cbMaxSize, PAGE_SIZE);
    … …  
    10189
    10290    pHGCMBuffer = (uint8_t *)vbsfAllocNonPagedMem(cbHGCMBuffer);
    103     if (pHGCMBuffer == NULL)
     91    if (!pHGCMBuffer)
    10492    {
    10593        AssertFailed();
    … …  
    128116
    129117        /* Calculate length required for parsed path. */
    130         ParsedPathSize = sizeof(*ParsedPath) + (DirectoryName->Length + Template->Length + 3 * sizeof(WCHAR));
    131 
    132         Log(("VBOXSF: MrxQueryDirectory: ParsedPathSize = %d\n",
    133              ParsedPathSize));
     118        ParsedPathSize = sizeof(SHFLSTRING) + DirectoryName->Length + Template->Length + 3 * sizeof(WCHAR);
     119        Log(("VBOXSF: MrxQueryDirectory: ParsedPathSize = %d\n", ParsedPathSize));
    134120
    135121        ParsedPath = (PSHFLSTRING)vbsfAllocNonPagedMem(ParsedPathSize);
    … …  
    141127
    142128        RtlZeroMemory(ParsedPath, ParsedPathSize);
    143         ShflStringInitBuffer(ParsedPath, ParsedPathSize - sizeof(SHFLSTRING));
     129        if (!ShflStringInitBuffer(ParsedPath, ParsedPathSize))
     130        {
     131            Status = STATUS_INSUFFICIENT_RESOURCES;
     132            goto end;
     133        }
    144134
    145135        ParsedPath->u16Size = DirectoryName->Length + Template->Length + sizeof(WCHAR);
    … …  
    223213
    224214    if (Status != STATUS_SUCCESS)
    225     {
    226215        goto end;
    227     }
    228216
    229217    /* Verify that the returned buffer length is not greater than the original one. */
    … …  
    483471        }
    484472        else
    485         {
    486             break;
    487         }
     473            break;
    488474
    489475        if (RxContext->QueryDirectory.ReturnSingleEntry)
    490         {
    491             break;
    492         }
     476            break;
    493477
    494478        /* More left? */
    495479        if (cbHGCMBuffer <= 0)
    496         {
    497             break;
    498         }
     480            break;
    499481
    500482        index++; /* File Index. */
    … …  
    504486
    505487    if (pNextOffset)
    506     {
    507488        *pNextOffset = 0; /* Last pInfo->NextEntryOffset should be set to zero! */
    508     }
    509489
    510490end:
    511491    if (pHGCMBuffer)
    512     {
    513492        vbsfFreeNonPagedMem(pHGCMBuffer);
    514     }
    515493
    516494    if (ParsedPath)
    517     {
    518495        vbsfFreeNonPagedMem(ParsedPath);
    519     }
    520496
    521497    Log(("VBOXSF: MrxQueryDirectory: Returned 0x%08X\n",
    … …  
    567543            Log(("VBOXSF: MrxQueryVolumeInfo: FileFsVolumeInformation\n"));
    568544
    569             if (pVBoxFobx == NULL)
     545            if (!pVBoxFobx)
    570546            {
    571547                Log(("VBOXSF: MrxQueryVolumeInfo: pVBoxFobx is NULL!\n"));
    … …  
    602578            cbHGCMBuffer = sizeof(SHFLVOLINFO);
    603579            pHGCMBuffer = (uint8_t *)vbsfAllocNonPagedMem(cbHGCMBuffer);
    604             if (pHGCMBuffer == NULL)
     580            if (!pHGCMBuffer)
    605581            {
    606582                Status = STATUS_INSUFFICIENT_RESOURCES;
    … …  
    758734            }
    759735
    760             if (pVBoxFobx == NULL)
     736            if (!pVBoxFobx)
    761737            {
    762738                Log(("VBOXSF: MrxQueryVolumeInfo: pVBoxFobx is NULL!\n"));
    … …  
    775751            cbHGCMBuffer = sizeof(SHFLVOLINFO);
    776752            pHGCMBuffer = (uint8_t *)vbsfAllocNonPagedMem(cbHGCMBuffer);
    777             if (pHGCMBuffer == NULL)
     753            if (!pHGCMBuffer)
    778754            {
    779755                Status = STATUS_INSUFFICIENT_RESOURCES;
    … …  
    916892
    917893    if (Status == STATUS_SUCCESS)
    918     {
    919894        RxContext->Info.LengthRemaining = cbInfoBuffer - cbToCopy;
    920     }
    921895    else if (Status == STATUS_BUFFER_TOO_SMALL)
    922896    {
    … …  
    956930    PSHFLFSOBJINFO pFileEntry = NULL;
    957931
    958     if (NULL == pLengthRemaining)
     932    if (!pLengthRemaining)
    959933    {
    960934        Log(("VBOXSF: MrxQueryFileInfo: length pointer is NULL!\n"));
    … …  
    965939         pInfoBuffer, cbInfoBuffer, *pLengthRemaining));
    966940
    967     if (NULL == pVBoxFobx)
     941    if (!pVBoxFobx)
    968942    {
    969943        Log(("VBOXSF: MrxQueryFileInfo: pVBoxFobx is NULL!\n"));
    … …  
    971945    }
    972946
    973     if (NULL == pInfoBuffer)
     947    if (!pInfoBuffer)
    974948    {
    975949        Log(("VBOXSF: MrxQueryFileInfo: pInfoBuffer is NULL!\n"));
    … …  
    1012986
    1013987                if (*pLengthRemaining >= cbToCopy)
    1014                 {
    1015988                    *pInfo = pVBoxFobx->FileStandardInfo;
    1016                 }
    1017                 else
    1018                 {
     989                else
    1019990                    Status = STATUS_BUFFER_TOO_SMALL;
    1020                 }
    1021991                break;
    1022992            }
    … …  
    10411011                }
    10421012                else
    1043                 {
    10441013                    Status = STATUS_BUFFER_TOO_SMALL;
    1045                 }
    10461014                break;
    10471015            }
    … …  
    10601028                }
    10611029                else
    1062                 {
    10631030                    Status = STATUS_BUFFER_TOO_SMALL;
    1064                 }
    10651031                break;
    10661032            }
    … …  
    10771043                }
    10781044                else
    1079                 {
    10801045                    Status = STATUS_BUFFER_TOO_SMALL;
    1081                 }
    10821046                break;
    10831047            }
    … …  
    11011065                }
    11021066                else
    1103                 {
    11041067                    Status = STATUS_BUFFER_TOO_SMALL;
    1105                 }
    11061068                break;
    11071069            }
    … …  
    11241086        pHGCMBuffer = (uint8_t *)vbsfAllocNonPagedMem(cbHGCMBuffer);
    11251087
    1126         if (pHGCMBuffer == NULL)
    1127         {
     1088        if (!pHGCMBuffer)
    11281089            return STATUS_INSUFFICIENT_RESOURCES;
    1129         }
    11301090
    11311091        Assert(pVBoxFobx && pNetRootExtension && pDeviceExtension);
    … …  
    11631123                }
    11641124                else
    1165                 {
    11661125                    Status = STATUS_BUFFER_TOO_SMALL;
    1167                 }
    11681126                break;
    11691127            }
    … …  
    11841142
    11851143                    if (pFileEntry->Attr.fMode & RTFS_DOS_DIRECTORY)
    1186                     {
    11871144                        pInfo->Directory = TRUE;
    1188                     }
    11891145                    else
    1190                     {
    11911146                        pInfo->Directory = FALSE;
    1192                     }
    1193                 }
    1194                 else
    1195                 {
     1147                }
     1148                else
    11961149                    Status = STATUS_BUFFER_TOO_SMALL;
    1197                 }
    11981150                break;
    11991151            }
    … …  
    12181170                }
    12191171                else
    1220                 {
    12211172                    Status = STATUS_BUFFER_TOO_SMALL;
    1222                 }
    12231173                break;
    12241174            }
    … …  
    12371187                }
    12381188                else
    1239                 {
    12401189                    Status = STATUS_BUFFER_TOO_SMALL;
    1241                 }
    12421190                break;
    12431191            }
    … …  
    12511199
    12521200                if (*pLengthRemaining >= cbToCopy)
    1253                 {
    12541201                    pInfo->EaSize = 0;
    1255                 }
    1256                 else
    1257                 {
     1202                else
    12581203                    Status = STATUS_BUFFER_TOO_SMALL;
    1259                 }
    12601204                break;
    12611205            }
    … …  
    12741218                }
    12751219                else
    1276                 {
    12771220                    Status = STATUS_BUFFER_TOO_SMALL;
    1278                 }
    12791221                break;
    12801222            }
    … …  
    12881230
    12891231                if (*pLengthRemaining >= cbToCopy)
    1290                 {
    12911232                    pInfo->EndOfFile.QuadPart = pFileEntry->cbObject;
    1292                 }
    1293                 else
    1294                 {
     1233                else
    12951234                    Status = STATUS_BUFFER_TOO_SMALL;
    1296                 }
    12971235                break;
    12981236            }
    … …  
    13061244
    13071245                if (*pLengthRemaining >= cbToCopy)
    1308                 {
    13091246                    pInfo->AllocationSize.QuadPart = pFileEntry->cbAllocated;
    1310                 }
    1311                 else
    1312                 {
     1247                else
    13131248                    Status = STATUS_BUFFER_TOO_SMALL;
    1314                 }
    13151249                break;
    13161250            }
    … …  
    13341268                }
    13351269                else
    1336                 {
    13371270                    Status = STATUS_BUFFER_TOO_SMALL;
    1338                 }
    13391271                break;
    13401272            }
    … …  
    13781310
    13791311    if (pHGCMBuffer)
    1380     {
    13811312        vbsfFreeNonPagedMem(pHGCMBuffer);
    1382     }
    13831313
    13841314    if (Status == STATUS_SUCCESS)
    … …  
    13881318    }
    13891319
    1390     Log(("VBOXSF: MrxQueryFileInfo: Returned 0x%08X\n",
    1391          Status));
     1320    Log(("VBOXSF: MrxQueryFileInfo: Returned 0x%08X\n", Status));
    13921321    return Status;
    13931322}
    … …  
    14541383            cbBuffer = sizeof(SHFLFSOBJINFO);
    14551384            pHGCMBuffer = (uint8_t *)vbsfAllocNonPagedMem(cbBuffer);
    1456             if (pHGCMBuffer == NULL)
     1385            if (!pHGCMBuffer)
    14571386            {
    14581387                AssertFailed();
    … …  
    15041433                /* Update our internal copy. Ignore zero fields! */
    15051434                if (pInfo->CreationTime.QuadPart && !pVBoxFobx->fKeepCreationTime)
    1506                 {
    15071435                    pVBoxFobx->FileBasicInfo.CreationTime = pInfo->CreationTime;
    1508                 }
    15091436                if (pInfo->LastAccessTime.QuadPart && !pVBoxFobx->fKeepLastAccessTime)
    1510                 {
    15111437                    pVBoxFobx->FileBasicInfo.LastAccessTime = pInfo->LastAccessTime;
    1512                 }
    15131438                if (pInfo->LastWriteTime.QuadPart && !pVBoxFobx->fKeepLastWriteTime)
    1514                 {
    15151439                    pVBoxFobx->FileBasicInfo.LastWriteTime = pInfo->LastWriteTime;
    1516                 }
    15171440                if (pInfo->ChangeTime.QuadPart && !pVBoxFobx->fKeepChangeTime)
    1518                 {
    15191441                    pVBoxFobx->FileBasicInfo.ChangeTime = pInfo->ChangeTime;
    1520                 }
    15211442                if (pInfo->FileAttributes)
    1522                 {
    15231443                    pVBoxFobx->FileBasicInfo.FileAttributes = pInfo->FileAttributes;
    1524                 }
    15251444            }
    15261445
    … …  
    15361455
    15371456            if (pInfo->DeleteFile && capFcb->OpenCount == 1)
    1538             {
    15391457                Status = vbsfRemove(RxContext);
    1540             }
    15411458            else
    1542             {
    15431459                Status = STATUS_SUCCESS;
    1544             }
    15451460            break;
    15461461        }
    … …  
    16291544end:
    16301545    if (pHGCMBuffer)
    1631     {
    16321546        vbsfFreeNonPagedMem(pHGCMBuffer);
    1633     }
    1634 
    1635     Log(("VBOXSF: MrxSetFileInfo: Returned 0x%08X\n",
    1636          Status));
     1547
     1548    Log(("VBOXSF: MrxSetFileInfo: Returned 0x%08X\n", Status));
    16371549    return Status;
    16381550}

  • trunk/src/VBox/Additions/WINNT/SharedFolders/driver/net.c

    r51253 r51254  
    145145    }
    146146
    147     if (pNetRoot->Context == NULL)
     147    if (!pNetRoot->Context)
    148148    {
    149149        /* MRxNetRootSize is not zero in VBoxSF, so it is expected
    … …  
    195195            RootNameLength -= sizeof(WCHAR);
    196196
    197         if (pNetRootExtension->phgcmClient == NULL)
     197        if (!pNetRootExtension->phgcmClient)
    198198        {
    199199            Log(("VBOXSF: MRxCreateVNetRoot: Initialize netroot length = %d, name = %.*ls\n",
    … …  
    209209            }
    210210            memset(ParsedPath, 0, ParsedPathSize);
    211 
    212             ShflStringInitBuffer(ParsedPath, ParsedPathSize - sizeof(SHFLSTRING));
    213             ParsedPath->u16Size = (uint16_t)RootNameLength + sizeof(WCHAR);
     211            if (!ShflStringInitBuffer(ParsedPath, ParsedPathSize))
     212            {
     213                vbsfFreeNonPagedMem(ParsedPath);
     214                Status = STATUS_INSUFFICIENT_RESOURCES;
     215                goto l_Exit;
     216            }
    214217            ParsedPath->u16Length = ParsedPath->u16Size - sizeof(WCHAR); /* without terminating null */
    215218            RtlCopyMemory(ParsedPath->String.ucs2, pRootName, ParsedPath->u16Length);
    … …  
    230233    }
    231234    else
    232     {
    233235        Log(("VBOXSF: MRxCreateVNetRoot: Creating V_NET_ROOT on existing NET_ROOT!\n"));
    234     }
    235236
    236237    vbsfUpdateNetRoot(pNetRoot);
    … …  
    239240    if (Status != STATUS_PENDING)
    240241    {
    241         Log(("VBOXSF: MRxCreateVNetRoot: Returning 0x%08X\n",
    242              Status));
     242        Log(("VBOXSF: MRxCreateVNetRoot: Returning 0x%08X\n", Status));
    243243        pCreateNetRootContext->VirtualNetRootStatus = Status;
    244244        if (fInitializeNetRoot)
    245         {
    246245            pCreateNetRootContext->NetRootStatus = Status;
    247         }
    248246        else
    249         {
    250247            pCreateNetRootContext->NetRootStatus = STATUS_SUCCESS;
    251         }
    252248
    253249        /* Inform RDBSS. */
    … …  
    276272    PMRX_VBOX_NETROOT_EXTENSION pNetRootExtension = VBoxMRxGetNetRootExtension(pNetRoot);
    277273
    278     Log(("VBOXSF: MRxFinalizeNetRoot: NET_ROOT %p\n",
    279          pNetRoot));
     274    Log(("VBOXSF: MRxFinalizeNetRoot: NET_ROOT %p\n", pNetRoot));
    280275
    281276    if (pNetRootExtension->phgcmClient)
    … …  
    283278        int vboxRC = vboxCallUnmapFolder(pNetRootExtension->phgcmClient, &pNetRootExtension->map);
    284279        if (vboxRC != VINF_SUCCESS)
    285         {
    286280            Log(("VBOXSF: MRxFinalizeVNetRoot: vboxCallUnmapFolder failed with %d\n",
    287281                 vboxRC));
    288         }
    289282        pNetRootExtension->phgcmClient = NULL;
    290283    }
    … …  
    401394    }
    402395    else
    403     {
    404396        Verifier = FALSE;
    405     }
    406397
    407398    if (Verifier)
    … …  
    425416    PMRX_SRVCALLDOWN_STRUCTURE SrvCalldownStructure = (PMRX_SRVCALLDOWN_STRUCTURE)(pCallbackContext->SrvCalldownStructure);
    426417
    427     Log(("VBOXSF: MRxCreateSrvCall: %p.\n",
    428          pSrvCall));
     418    Log(("VBOXSF: MRxCreateSrvCall: %p.\n", pSrvCall));
    429419
    430420    if (IoGetCurrentProcess() == RxGetRDBSSProcess())
    … …  
    445435
    446436        if (Status == STATUS_SUCCESS)
    447         {
    448437            Log(("VBOXSF: MRxCreateSrvCall: queued\n"));
    449         }
    450438        else
    451439        {
    … …  
    462450                                 BOOLEAN Force)
    463451{
    464     Log(("VBOXSF: MRxFinalizeSrvCall %p, ctx = %p.\n",
    465          pSrvCall, pSrvCall->Context));
     452    Log(("VBOXSF: MRxFinalizeSrvCall %p, ctx = %p.\n", pSrvCall, pSrvCall->Context));
    466453
    467454    pSrvCall->Context = NULL;

  • trunk/src/VBox/Additions/WINNT/SharedFolders/driver/path.c

    r42154 r51254  
    253253         */
    254254        ParsedPathSize = sizeof(*ParsedPath) + (RemainingName->Length + sizeof(WCHAR));
    255 
    256         Log(("VBOXSF: vbsfProcessCreate: ParsedPathSize = %d\n",
    257              ParsedPathSize));
     255        Log(("VBOXSF: vbsfProcessCreate: ParsedPathSize = %d\n", ParsedPathSize));
    258256
    259257        ParsedPath = (PSHFLSTRING)vbsfAllocNonPagedMem(ParsedPathSize);
    260         if (ParsedPath == NULL)
     258        if (!ParsedPath)
    261259        {
    262260            Status = STATUS_INSUFFICIENT_RESOURCES;
    … …  
    264262        }
    265263
    266         ShflStringInitBuffer(ParsedPath, ParsedPathSize - sizeof(SHFLSTRING));
    267 
    268         ParsedPath->u16Size = RemainingName->Length + sizeof(WCHAR);
     264        if (!ShflStringInitBuffer(ParsedPath, ParsedPathSize))
     265        {
     266            vbsfFreeNonPagedMem(ParsedPath);
     267            Status = STATUS_INSUFFICIENT_RESOURCES;
     268            goto failure;
     269        }
     270
    269271        ParsedPath->u16Length = ParsedPath->u16Size - sizeof(WCHAR); /* without terminating null */
    270272        RtlCopyMemory (ParsedPath->String.ucs2, RemainingName->Buffer, ParsedPath->u16Length);
    … …  
    292294                Status = STATUS_OBJECT_NAME_COLLISION;
    293295                goto failure;
    294             } break;
     296            }
    295297
    296298            /* On POSIX systems, the "mkdir" command returns VERR_FILE_NOT_FOUND when
    … …  
    299301            {
    300302                pCreateParms->Result = SHFL_PATH_NOT_FOUND;
    301             } break;
     303                break;
     304            }
    302305
    303306            default:
    … …  
    306309                Status = VBoxErrorToNTStatus(vboxRC);
    307310                goto failure;
    308             } break;
     311            }
    309312        }
    310313    }
    … …  
    370373        {
    371374            /* A new file was created. */
    372 
    373375            Assert(pCreateParms->Handle != SHFL_HANDLE_NIL);
    374376
    … …  
    382384        {
    383385            /* Existing file was replaced or overwriting. */
    384 
    385386            Assert(pCreateParms->Handle != SHFL_HANDLE_NIL);
    386387
    387388            if (CreateDisposition == FILE_SUPERSEDE)
    388             {
    389389                *pulCreateAction = FILE_SUPERSEDED;
    390             }
    391390            else
    392             {
    393391                *pulCreateAction = FILE_OVERWRITTEN;
    394             }
    395392            /* Go check flags and create FCB. */
    396393            break;
    … …  
    469466
    470467    if (pCreateParms)
    471     {
    472468        vbsfFreeNonPagedMem(pCreateParms);
    473     }
    474469
    475470    return Status;
    … …  
    549544
    550545    RxContext->pFobx = RxCreateNetFobx(RxContext, SrvOpen);
    551     if (RxContext->pFobx == NULL)
     546    if (!RxContext->pFobx)
    552547    {
    553548        Log(("VBOXSF: MRxCreate: RxCreateNetFobx failed\n"));
    … …  
    657652          pVBoxFobx, pVBoxFobx? pVBoxFobx->hFile: 0));
    658653
    659     if (NULL == pVBoxFobx)
    660     {
     654    if (!pVBoxFobx)
    661655        return STATUS_INVALID_PARAMETER;
    662     }
    663656
    664657    return STATUS_SUCCESS;
    … …  
    700693    cbBuffer = sizeof(SHFLFSOBJINFO);
    701694    pHGCMBuffer = (uint8_t *)vbsfAllocNonPagedMem(cbBuffer);
    702     if (pHGCMBuffer == NULL)
     695    if (!pHGCMBuffer)
    703696    {
    704697        AssertFailed();
    … …  
    710703    /* The properties, that need to be changed, are set to something other than zero */
    711704    if (pInfo->CreationTime.QuadPart && (SetAttrFlags & VBOX_FOBX_F_INFO_CREATION_TIME) != 0)
    712     {
    713705        RTTimeSpecSetNtTime(&pSHFLFileInfo->BirthTime, pInfo->CreationTime.QuadPart);
    714     }
    715706    if (pInfo->LastAccessTime.QuadPart && (SetAttrFlags & VBOX_FOBX_F_INFO_LASTACCESS_TIME) != 0)
    716     {
    717707        RTTimeSpecSetNtTime(&pSHFLFileInfo->AccessTime, pInfo->LastAccessTime.QuadPart);
    718     }
    719708    if (pInfo->LastWriteTime.QuadPart && (SetAttrFlags & VBOX_FOBX_F_INFO_LASTWRITE_TIME) != 0)
    720     {
    721709        RTTimeSpecSetNtTime(&pSHFLFileInfo->ModificationTime, pInfo->LastWriteTime.QuadPart);
    722     }
    723710    if (pInfo->ChangeTime.QuadPart && (SetAttrFlags & VBOX_FOBX_F_INFO_CHANGE_TIME) != 0)
    724     {
    725711        RTTimeSpecSetNtTime(&pSHFLFileInfo->ChangeTime, pInfo->ChangeTime.QuadPart);
    726     }
    727712    if (pInfo->FileAttributes && (SetAttrFlags & VBOX_FOBX_F_INFO_ATTRIBUTES) != 0)
    728     {
    729713        pSHFLFileInfo->Attr.fMode = NTToVBoxFileAttributes(pInfo->FileAttributes);
    730     }
    731714
    732715    vboxRC = vboxCallFSInfo(&pDeviceExtension->hgcmClient, &pNetRootExtension->map, pVBoxFobx->hFile,
    … …  
    734717
    735718    if (vboxRC != VINF_SUCCESS)
    736     {
    737719        Status = VBoxErrorToNTStatus(vboxRC);
    738     }
    739720
    740721    if (pHGCMBuffer)
    741     {
    742722        vbsfFreeNonPagedMem(pHGCMBuffer);
    743     }
    744 
    745     Log(("VBOXSF: vbsfSetFileInfo: Returned 0x%08X\n",
    746          Status));
     723
     724    Log(("VBOXSF: vbsfSetFileInfo: Returned 0x%08X\n", Status));
    747725    return Status;
    748726}
    … …  
    788766
    789767    if (vboxRC != VINF_SUCCESS)
    790     {
    791768        Status = VBoxErrorToNTStatus(vboxRC);
    792     }
    793 
    794     Log(("VBOXSF: vbsfCloseFileHandle: Returned 0x%08X\n",
    795          Status));
     769
     770    Log(("VBOXSF: vbsfCloseFileHandle: Returned 0x%08X\n", Status));
    796771    return Status;
    797772}
    … …  
    820795         RemainingName->Length / sizeof(WCHAR), RemainingName->Buffer, RemainingName->Length));
    821796
    822     if (NULL == pVBoxFobx)
    823     {
     797    if (!pVBoxFobx)
    824798        return STATUS_INVALID_PARAMETER;
    825     }
    826799
    827800    if (FlagOn(pSrvOpen->Flags, (SRVOPEN_FLAG_FILE_RENAMED | SRVOPEN_FLAG_FILE_DELETED)))
    … …  
    836809    /* Close file */
    837810    if (pVBoxFobx->hFile != SHFL_HANDLE_NIL)
    838     {
    839811        vbsfCloseFileHandle(pDeviceExtension, pNetRootExtension, pVBoxFobx);
    840     }
    841812
    842813    if (capFcb->FcbState & FCB_STATE_DELETE_ON_CLOSE)
    … …  
    847818        /* Remove file or directory if delete action is pending. */
    848819        if (capFcb->OpenCount == 0)
    849         {
    850820            Status = vbsfRemove(RxContext);
    851         }
    852821    }
    853822
    … …  
    877846    /* Close file first if not already done. */
    878847    if (pVBoxFobx->hFile != SHFL_HANDLE_NIL)
    879     {
    880848        vbsfCloseFileHandle(pDeviceExtension, pNetRootExtension, pVBoxFobx);
    881     }
    882 
    883     /* Calculate length required for parsed path.
    884      */
    885     ParsedPathSize = sizeof(*ParsedPath) + (RemainingName->Length + sizeof(WCHAR));
    886 
    887     Log(("VBOXSF: vbsfRemove: ParsedPathSize %d\n",
    888          ParsedPathSize));
     849
     850    /* Calculate length required for parsed path. */
     851    ParsedPathSize = sizeof(SHFLSTRING) + RemainingName->Length + sizeof(WCHAR);
     852    Log(("VBOXSF: vbsfRemove: ParsedPathSize %d\n", ParsedPathSize));
    889853
    890854    ParsedPath = (PSHFLSTRING)vbsfAllocNonPagedMem(ParsedPathSize);
    891855    if (!ParsedPath)
    892     {
    893856        return STATUS_INSUFFICIENT_RESOURCES;
    894     }
    895 
    896     ShflStringInitBuffer(ParsedPath, ParsedPathSize - sizeof(SHFLSTRING));
     857
     858    if (!ShflStringInitBuffer(ParsedPath, ParsedPathSize))
     859    {
     860        vbsfFreeNonPagedMem(ParsedPath);
     861        return STATUS_INSUFFICIENT_RESOURCES;
     862    }
    897863
    898864    Log(("VBOXSF: vbsfRemove: Setup ParsedPath\n"));
    899     ParsedPath->u16Size = RemainingName->Length + sizeof(WCHAR);
    900865    ParsedPath->u16Length = ParsedPath->u16Size - sizeof(WCHAR); /* without terminating null */
    901866    RtlCopyMemory(ParsedPath->String.ucs2, RemainingName->Buffer, ParsedPath->u16Length);
    … …  
    907872
    908873    if (ParsedPath)
    909     {
    910874        vbsfFreeNonPagedMem(ParsedPath);
    911     }
    912875
    913876    if (vboxRC == VINF_SUCCESS)
    914     {
    915877        SetFlag(capFobx->pSrvOpen->Flags, SRVOPEN_FLAG_FILE_DELETED);
    916     }
    917878
    918879    Status = VBoxErrorToNTStatus(vboxRC);
    919880    if (vboxRC != VINF_SUCCESS)
    920     {
    921         Log(("VBOXSF: vbsfRemove: vboxCallRemove failed with %Rrc\n",
    922              vboxRC));
    923     }
    924 
    925     Log(("VBOXSF: vbsfRemove: Returned 0x%08X\n",
    926          Status));
     881        Log(("VBOXSF: vbsfRemove: vboxCallRemove failed with %Rrc\n", vboxRC));
     882
     883    Log(("VBOXSF: vbsfRemove: Returned 0x%08X\n", Status));
    927884    return Status;
    928885}
    … …  
    957914    /* Must close the file before renaming it! */
    958915    if (pVBoxFobx->hFile != SHFL_HANDLE_NIL)
    959     {
    960916        vbsfCloseFileHandle(pDeviceExtension, pNetRootExtension, pVBoxFobx);
    961     }
    962917
    963918    /* Mark it as renamed, so we do nothing during close */
    … …  
    965920
    966921    /* Calculate length required for destination path. */
    967     ParsedPathSize = sizeof(*DestPath) + (RenameInformation->FileNameLength + sizeof(WCHAR));
    968 
    969     Log(("VBOXSF: vbsfRename: ParsedPathSize = %d\n",
    970          ParsedPathSize));
     922    ParsedPathSize = sizeof(SHFLSTRING) + RenameInformation->FileNameLength + sizeof(WCHAR);
     923    Log(("VBOXSF: vbsfRename: ParsedPathSize = %d\n", ParsedPathSize));
    971924
    972925    DestPath = (PSHFLSTRING)vbsfAllocNonPagedMem(ParsedPathSize);
    973 
    974     if (NULL == DestPath)
    975     {
     926    if (!DestPath)
    976927        return STATUS_INSUFFICIENT_RESOURCES;
    977     }
    978928
    979929    RtlZeroMemory(DestPath, ParsedPathSize);
    980     ShflStringInitBuffer(DestPath, ParsedPathSize - sizeof(SHFLSTRING));
     930    if (!ShflStringInitBuffer(DestPath, ParsedPathSize))
     931    {
     932        vbsfFreeNonPagedMem(DestPath);
     933        return STATUS_INSUFFICIENT_RESOURCES;
     934    }
    981935
    982936    Log(("VBOXSF: vbsfRename: Setting up destination path\n"));
    983 
    984     DestPath->u16Size = (USHORT)(RenameInformation->FileNameLength + sizeof(WCHAR));
    985937    DestPath->u16Length = DestPath->u16Size - sizeof(WCHAR); /* without terminating null */
    986938    RtlCopyMemory(DestPath->String.ucs2, RenameInformation->FileName, DestPath->u16Length);
    … …  
    995947
    996948    SrcPath = (PSHFLSTRING)vbsfAllocNonPagedMem(ParsedPathSize);
    997 
    998     if (NULL == SrcPath)
     949    if (!SrcPath)
    999950    {
    1000951        vbsfFreeNonPagedMem(DestPath);
    … …  
    1003954
    1004955    RtlZeroMemory(SrcPath, ParsedPathSize);
    1005     ShflStringInitBuffer(SrcPath, ParsedPathSize - sizeof(SHFLSTRING));
     956    if (!ShflStringInitBuffer(SrcPath, ParsedPathSize))
     957    {
     958        vbsfFreeNonPagedMem(DestPath);
     959        vbsfFreeNonPagedMem(SrcPath);
     960        return STATUS_INSUFFICIENT_RESOURCES;
     961    }
    1006962
    1007963    Log(("VBOXSF: vbsfRename: Setting up source path\n"));
    1008964
    1009     SrcPath->u16Size = RemainingName->Length + sizeof(WCHAR);
    1010965    SrcPath->u16Length = SrcPath->u16Size - sizeof(WCHAR); /* without terminating null */
    1011966    RtlCopyMemory(SrcPath->String.ucs2, RemainingName->Buffer, SrcPath->u16Length);
    … …  
    1017972    flags = pVBoxFobx->FileStandardInfo.Directory? SHFL_RENAME_DIR : SHFL_RENAME_FILE;
    1018973    if (RenameInformation->ReplaceIfExists)
    1019     {
    1020974        flags |= SHFL_RENAME_REPLACE_IF_EXISTS;
    1021     }
    1022975
    1023976    Log(("VBOXSF: vbsfRename: Calling vboxCallRename\n"));
    … …  
    1029982    Status = VBoxErrorToNTStatus(vboxRC);
    1030983    if (vboxRC != VINF_SUCCESS)
    1031     {
    1032         Log(("VBOXSF: vbsfRename: vboxCallRename failed with %Rrc\n",
    1033              vboxRC));
    1034     }
    1035 
    1036     Log(("VBOXSF: vbsfRename: Returned 0x%08X\n",
    1037          Status));
     984        Log(("VBOXSF: vbsfRename: vboxCallRename failed with %Rrc\n", vboxRC));
     985
     986    Log(("VBOXSF: vbsfRename: Returned 0x%08X\n", Status));
    1038987    return Status;
    1039988}

  • trunk/src/VBox/Additions/WINNT/SharedFolders/driver/vbsf.c

    r49394 r51254  
    103103
    104104                if (State != MRX_VBOX_STARTABLE)
    105                 {
    106105                    Status = STATUS_REDIRECTOR_STARTED;
    107                 }
    108106            }
    109107
    … …  
    111109        }
    112110        else
    113         {
    114111            Status = STATUS_INSUFFICIENT_RESOURCES;
    115         }
    116112
    117113        RxUnregisterMinirdr(VBoxMRxDeviceObject);
    … …  
    121117    Status = IoDeleteSymbolicLink(&UserModeDeviceName);
    122118    if (Status != STATUS_SUCCESS)
    123     {
    124         Log(("VBOXSF: MRxUnload: IoDeleteSymbolicLink Status 0x%08X\n",
    125              Status));
    126     }
     119        Log(("VBOXSF: MRxUnload: IoDeleteSymbolicLink Status 0x%08X\n", Status));
    127120
    128121    RxUnload(DriverObject);
    129122
    130     Log(("VBOXSF: MRxUnload: VBoxSF.sys driver object %p unloaded\n",
    131          DriverObject));
     123    Log(("VBOXSF: MRxUnload: VBoxSF.sys driver object %p unloaded\n", DriverObject));
    132124}
    133125
    … …  
    234226    }
    235227    else
    236     {
    237228        PrefixOK = FALSE;
    238     }
    239229
    240230    return PrefixOK;
    … …  
    425415    Log(("VBOXSF: DriverEntry: Driver object %p\n", DriverObject));
    426416
    427     if (DriverObject == NULL)
     417    if (!DriverObject)
    428418    {
    429419        Log(("VBOXSF: DriverEntry: driver object is NULL.\n"));
    … …  
    435425    if (RT_FAILURE(vboxRC))
    436426    {
    437         Log(("VBOXSF: DriverEntry: ERROR while initializing VBox subsystem (%Rrc)!\n",
    438              vboxRC));
     427        Log(("VBOXSF: DriverEntry: ERROR while initializing VBox subsystem (%Rrc)!\n", vboxRC));
    439428        return STATUS_UNSUCCESSFUL;
    440429    }
    … …  
    639628            Log(("VBOXSF: MRxDevFcbXXXControlFile: IRP_MN_USER_FS_REQUEST: 0x%08X\n",
    640629                 LowIoContext->ParamsFor.FsCtl.MinorFunction));
    641 
    642630            Status = STATUS_INVALID_DEVICE_REQUEST;
    643631            break;
    … …  
    652640                    Log(("VBOXSF: MRxDevFcbXXXControlFile: IOCTL_MRX_VBOX_ADDCONN\n"));
    653641                    Status = vbsfCreateConnection(RxContext, &RxContext->PostRequest);
    654                 } break;
     642                    break;
     643                }
    655644
    656645                case IOCTL_MRX_VBOX_DELCONN:
    … …  
    658647                    Log(("VBOXSF: MRxDevFcbXXXControlFile: IOCTL_MRX_VBOX_DELCONN\n"));
    659648                    Status = vbsfDeleteConnection(RxContext, &RxContext->PostRequest);
    660                 } break;
     649                    break;
     650                }
    661651
    662652                case IOCTL_MRX_VBOX_GETLIST:
    … …  
    667657                    Log(("VBOXSF: MRxDevFcbXXXControlFile: IOCTL_MRX_VBOX_GETLIST\n"));
    668658
    669                     if (NULL == pDeviceExtension)
     659                    if (!pDeviceExtension)
    670660                    {
    671661                        RxContext->InformationToReturn = 0;
    … …  
    673663                    }
    674664
    675                     if ((cbOut >= _MRX_MAX_DRIVE_LETTERS) && (NULL != pu8Out))
     665                    if (cbOut >= _MRX_MAX_DRIVE_LETTERS && !pu8Out)
    676666                    {
    677667                        BOOLEAN fLocked = FALSE;
    … …  
    713703                    RxContext->InformationToReturn = 0;
    714704
    715                     if (NULL == pDeviceExtension)
    716                     {
     705                    if (!pDeviceExtension)
    717706                        break;
    718                     }
    719 
    720                     if ((cbOut >= _MRX_MAX_DRIVE_LETTERS) && (NULL != pu8Out))
     707
     708                    if (cbOut >= _MRX_MAX_DRIVE_LETTERS && !pu8Out)
    721709                    {
    722710                        SHFLMAPPING mappings[_MRX_MAX_DRIVE_LETTERS];
    … …  
    766754                         cbConnectName / sizeof(WCHAR), pwcConnectName, cbConnectName, pwcRemoteName, cbRemoteName));
    767755
    768                     if (NULL == pDeviceExtension)
     756                    if (!pDeviceExtension)
    769757                    {
    770758                        Status = STATUS_INVALID_PARAMETER;
    … …  
    774762                    Log(("VBOXSF: MRxDevFcbXXXControlFile: IOCTL_MRX_VBOX_GETCONN: Looking up connection name and connections\n"));
    775763
    776                     if ((cbConnectName > sizeof(WCHAR)) && (NULL != pwcConnectName))
     764                    if (cbConnectName > sizeof(WCHAR) && !pwcConnectName)
    777765                    {
    778766                        ULONG cbLocalConnectionName;
    … …  
    791779                        ExAcquireFastMutex(&pDeviceExtension->mtxLocalCon);
    792780
    793                         if (NULL == pDeviceExtension->wszLocalConnectionName[idx])
     781                        if (!pDeviceExtension->wszLocalConnectionName[idx])
    794782                        {
    795783                            Log(("VBOXSF: MRxDevFcbXXXControlFile: IOCTL_MRX_VBOX_GETCONN: LocalConnectionName is NULL!\n"));
    … …  
    840828
    841829                    int vboxRC;
    842 
    843830                    PSHFLSTRING pString;
    844831                    uint32_t cbString;
    … …  
    855842                    }
    856843                    memset(pString, 0, cbString);
    857                     ShflStringInitBuffer(pString, cbRemoteName);
     844                    if (!ShflStringInitBuffer(pString, cbString))
     845                    {
     846                        vbsfFreeNonPagedMem(pString);
     847                        Status = STATUS_BAD_NETWORK_NAME;
     848                        break;
     849                    }
    858850
    859851                    vboxRC = vboxCallQueryMapName(&pDeviceExtension->hgcmClient,
    860852                                                  (*pConnectId) & ~0x80 /** @todo fix properly */,
    861                                                   pString,
    862                                                   cbString);
     853                                                  pString, cbString);
    863854                    if (   vboxRC == VINF_SUCCESS
    864855                        && pString->u16Length < cbRemoteName)
    … …  
    871862                    }
    872863                    else
    873                     {
    874864                        Status = STATUS_BAD_NETWORK_NAME;
    875                     }
    876865
    877866                    vbsfFreeNonPagedMem(pString);
    878867
    879868                    RxContext->InformationToReturn = ReturnedSize;
    880                 } break;
     869                    break;
     870                }
    881871
    882872                case IOCTL_MRX_VBOX_START:
    … …  
    10191009
    10201010                    if (Status == STATUS_PENDING && RxContext->PostRequest == TRUE)
    1021                     {
    10221011                        Status = STATUS_MORE_PROCESSING_REQUIRED;
    1023                     }
    1024 
    1025                 } break;
     1012                    break;
     1013                }
    10261014
    10271015                default:
    10281016                    Status = STATUS_INVALID_DEVICE_REQUEST;
    10291017                    break;
    1030             } break;
     1018            }
     1019            break;
    10311020        }
    10321021
    … …  
    10731062    {
    10741063        if (*pwc1 == 0 || *pwc == 0 || *pwc1 != *pwc)
    1075         {
    10761064            break;
    1077         }
    10781065    }
    10791066
    … …  
    10961083               /* @todo should also check that the drive letter corresponds to the name. */
    10971084               if (vboxIsPrefixOK(pwc, cRemainingName * sizeof (WCHAR)))
    1098                {
    10991085                   Status = STATUS_SUCCESS;
    1100                }
    11011086           }
    11021087        }
    … …  
    11801165    pwcConnectName = (PWCHAR)LowIoContext->ParamsFor.IoCtl.pInputBuffer;
    11811166
    1182     if (pDeviceExtension == NULL)
    1183     {
     1167    if (!pDeviceExtension)
    11841168        return STATUS_INVALID_PARAMETER;
    1185     }
    1186 
    1187     if (cbConnectName == 0 || pwcConnectName == NULL)
     1169
     1170    if (cbConnectName == 0 || !pwcConnectName)
    11881171    {
    11891172        Log(("VBOXSF: vbsfCreateConnection: Connection name / length is invalid!\n"));
    … …  
    12121195        {
    12131196            if (*pwc == L':')
    1214             {
    12151197                break;
    1216             }
    12171198            pwc++;
    12181199        }
    … …  
    12441225                    pDeviceExtension->wszLocalConnectionName[idx] = (PUNICODE_STRING)vbsfAllocNonPagedMem(sizeof(UNICODE_STRING) + cbConnectName);
    12451226
    1246                     if (pDeviceExtension->wszLocalConnectionName[idx] == NULL)
     1227                    if (!pDeviceExtension->wszLocalConnectionName[idx])
    12471228                    {
    12481229                        Log(("VBOXSF: vbsfCreateConnection: LocalConnectionName at index %d NOT allocated!\n",
    … …  
    14571438    return STATUS_SUCCESS;
    14581439}
    1459 

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

    r44529 r51254  
    250250    {
    251251        RT_ZERO(*pString);
    252         ShflStringInitBuffer(pString, SHFL_MAX_LEN);
     252        if (!ShflStringInitBuffer(pString, SHFL_MAX_LEN))
     253        {
     254            RTMemFree(pString);
     255            return VERR_INVALID_PARAMETER;
     256        }
    253257
    254258        VbglHGCMParmUInt32Set(&Msg.root, u32Root);
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