shareinfo.cpp

Windows CE 6.0 Server 源码

        CReg ShareKey;
        WCHAR wcACL[MAX_PATH];
        WCHAR wcROACL[MAX_PATH];

        StringConverter ShareName;
        ShareName.append(L"Services\\SMBServer\\Shares\\");
        ShareName.append((*it)->GetShareName());

        if(FALSE == ShareKey.Open(HKEY_LOCAL_MACHINE, ShareName.GetString())) {
            continue;
        }
        if(FALSE == ShareKey.ValueSZ(L"UserList", wcACL, MAX_PATH/sizeof(WCHAR))) {
            wcACL[0] = NULL;
        }
        if(FALSE == ShareKey.ValueSZ(L"ROUserList", wcROACL, MAX_PATH/sizeof(WCHAR))) {
            wcROACL[0] = NULL;
        }
        (*it)->SetACL(wcACL, wcROACL);
    }
    return S_OK;
}


Share *
ShareManager::SearchForShare(const WCHAR *pName)
{
    Share *pRet = NULL;
    if(NULL == pName) {
        ASSERT(FALSE);
        return NULL;
    }
    CCritSection csLock(&csShareManager);
    csLock.Lock();

    ce::list<Share *, SHARE_MANANGER_SHARE_ALLOC >::iterator it;
    ce::list<Share *, SHARE_MANANGER_SHARE_ALLOC >::iterator itEnd = MasterListOfShares.end();

    for(it = MasterListOfShares.begin(); it != itEnd; ++it) {
        const WCHAR *pShareName = (*it)->GetShareName();
        ASSERT(pShareName);

        if(pShareName && 0 == _wcsicmp(pShareName, pName)) {
            pRet = *it;
            goto Done;
        }
    }
    Done:
        return pRet;
}


Share *
ShareManager::SearchForShare(UINT uiIdx) {
    Share *pRet = NULL;

    CCritSection csLock(&csShareManager);
    csLock.Lock();

    ce::list<Share *, SHARE_MANANGER_SHARE_ALLOC >::iterator it;
    ce::list<Share *, SHARE_MANANGER_SHARE_ALLOC >::iterator itEnd = MasterListOfShares.end();

    if(uiIdx+1 > MasterListOfShares.size()) {
        pRet = NULL;
        goto Done;
    }

    for(it = MasterListOfShares.begin(); it != itEnd, uiIdx; ++it, uiIdx--) {
    }
    pRet = *it;

    Done:
        return pRet;
}




UINT
ShareManager::NumShares()
{
    UINT uiSize;
    CCritSection csLock(&csShareManager);
    csLock.Lock();
        uiSize = MasterListOfShares.size();
    return uiSize;
}


UINT
ShareManager::NumVisibleShares()
{
    UINT uiSize = 0;
    CCritSection csLock(&csShareManager);
    csLock.Lock();

    ce::list<Share *, SHARE_MANANGER_SHARE_ALLOC >::iterator it;
    ce::list<Share *, SHARE_MANANGER_SHARE_ALLOC >::iterator itEnd = MasterListOfShares.end();

    for(it = MasterListOfShares.begin(); it != itEnd; ++it) {
        if((*it)->IsHidden())
            uiSize ++;
    }
    return uiSize;
}


//
// NOTE: to use this function, you *MUST* Release() the pJobRet
HRESULT
ShareManager::SearchForPrintJob(USHORT usJobID, PrintJob **pJobRet, SMBPrintQueue **pQueueRet)
{
    HRESULT hr = E_FAIL;

    CCritSection csLock(&csShareManager);
    csLock.Lock();

    ce::list<Share *, SHARE_MANANGER_SHARE_ALLOC >::iterator it;
    ce::list<Share *, SHARE_MANANGER_SHARE_ALLOC >::iterator itEnd = MasterListOfShares.end();
    PrintJob *pRet = NULL;

    for(it = MasterListOfShares.begin(); it != itEnd; ++it) {
        SMBPrintQueue *pQueue = (*it)->GetPrintQueue();

        if(pQueue && SUCCEEDED(pQueue->FindPrintJob(usJobID, &pRet))) {
            if(pJobRet)
                *pJobRet = pRet;
            if(pQueueRet)
                *pQueueRet = pQueue;
            hr = S_OK;
            break;
        }
    }
    return hr;
}



TIDState::TIDState():pShare(NULL),
                     usTid(0xFFFF) {
    InitializeCriticalSection(&csTIDLock);
}


#ifdef DEBUG
VOID
TIDState::DebugPrint()
{
    ce::list<ce::smart_ptr<SMBFileStream>, TIDSTATE_FID_STREAM_ALLOC >::iterator it = FIDList.begin();
    ce::list<ce::smart_ptr<SMBFileStream>, TIDSTATE_FID_STREAM_ALLOC >::iterator itEnd = FIDList.end();

    for(it = FIDList.begin(); it != itEnd; it++) {
        TRACEMSG(ZONE_ERROR, (L"    FID(%d) : %s", (*it)->FID(), (*it)->GetFileName()));
    }
}
#endif



HRESULT
TIDState::Init(Share *_pShare)
{
    CCritSection csLock(&csTIDLock);
    csLock.Lock();

    ASSERT(0 == FIDList.size());
    HRESULT hr = E_FAIL;

    //ONLY init ONCE!
    ASSERT(NULL == pShare && 0xFFFF == usTid);

    //
    // Get a fresh TID
    if(FAILED(UIDTidGenerator.GetID(&usTid))) {
        TRACEMSG(ZONE_ERROR, (L"SMB_SRVR: Error -- TIDState couldnt get fresh TID!"));
        ASSERT(FALSE);
        goto Done;
    }
    pShare = _pShare;

    hr = S_OK;
    Done:
        return hr;
}

TIDState::~TIDState()
{
    //
    // Clean up all FIDS as the manager is going down (most likely because
    //   the TID manager is pulling us down... maybe the connction died
    //   or the server is being stopped)
    while(FIDList.size()) {
        RemoveFileStream((FIDList.front())->FID());
    }

    ASSERT(0 == FIDList.size());

    //
    // Free up our TID
    if(0xFFFF != usTid) {
        UIDTidGenerator.RemoveID(usTid);
    }

    DeleteCriticalSection(&csTIDLock);
}

USHORT
TIDState::TID() {
    CCritSection csLock(&csTIDLock);
    csLock.Lock();
    return usTid;
}


HRESULT
TIDState::RemoveFileStream(USHORT usFID)
{
    CCritSection csLock(&csTIDLock);
    csLock.Lock();
    ce::list<ce::smart_ptr<SMBFileStream>, TIDSTATE_FID_STREAM_ALLOC >::iterator it = FIDList.begin();
    ce::list<ce::smart_ptr<SMBFileStream>, TIDSTATE_FID_STREAM_ALLOC >::iterator itEnd = FIDList.end();
    BOOL fFound = FALSE;

    while(it != itEnd) {
        ASSERT(*it);
        if(*it && usFID == (*it)->FID())  {
            FIDList.erase(it++);
            fFound = TRUE;
            break;
        }
        it++;
    }

    if(fFound)  {
        UniqueFID.RemoveID(usFID);
        return S_OK;
    }
    else
        return E_FAIL;
}


HRESULT
TIDState::AddFileStream(SMBFileStream *pConnection)
{
    CCritSection csLock(&csTIDLock);
    csLock.Lock();
    if(!FIDList.push_front(pConnection)) {
        return E_OUTOFMEMORY;
    } else {
        return S_OK;
    }
}

//
// Class factory for building stream -- it builds the stream based on
//   the Share attached to the TIDState
SMBFileStream *
TIDState::CreateFileStream(ce::smart_ptr<ActiveConnection> pMyConnection)
{
    CCritSection csLock(&csTIDLock);
    csLock.Lock();

    SMBFileStream *pRet = NULL;
    Share *pShare = this->GetShare();
    PrintJob *pNewJob = NULL;
    USHORT usFID = 0xFFFF;

    //
    // Make sure this is actually a print queue and fetch queue
    if(g_fPrintServer && STYPE_PRINTQ == pShare->GetShareType()){
        TRACEMSG(ZONE_SMB, (L"SMBSRV-CRACKER: SMB_OpenX -- the TID is for a printer!!"));
    }
    else if(g_fFileServer && STYPE_DISKTREE == pShare->GetShareType()) {
        TRACEMSG(ZONE_SMB, (L"SMBSRV-CRACKER: SMB_OpenX -- the TID is for file server!!"));
    }
    else if(STYPE_IPC == pShare->GetShareType()) {
        TRACEMSG(ZONE_SMB, (L"SMBSRV-CRACKER: SMB_OpenX -- the TID is for IPC!!"));
    }
    else {
        ASSERT(FALSE);
        TRACEMSG(ZONE_ERROR, (L"SMBSRV-CRACKER: SMB_OpenX -- the Tid is for something we dont understand!!"));
        goto Done;
    }

    //
    // Generate a FID
    if(FAILED(UniqueFID.GetID(&usFID))) {
        goto Done;
    }

    //
    // If the TIDState is for a print share, give them back a print stream
    if(STYPE_PRINTQ == pShare->GetShareType()) {

        //
        // Create a new print job
        if(NULL == (pNewJob = new PrintJob(this->GetShare(), usFID))) {
            goto Done;
        }

        //
        // Set our username
        if(FAILED(pNewJob->SetOwnerName(pMyConnection->UserName()))) {
            goto Done;
        }

        //
        // Create a new PrintStream and then add the job to TIDState
        if(!(pRet = new PrintStream(pNewJob,this))) {
           goto Done;
        }
    } else if(STYPE_DISKTREE == pShare->GetShareType()) {
        if(!(pRet = GetNewFileStream(this, usFID))) {
            goto Done;
        }
    }
#ifdef SMB_NMPIPE
    else if(STYPE_IPC == pShare->GetShareType()) {
        if(!(pRet = new IPCStream(this, usFID))) {
            goto Done;
        }
    }
#endif

    Done:
        if(NULL != pNewJob) {
            pNewJob->Release();
        }
        if(!pRet && 0xFFFF != usFID) {
            UniqueFID.RemoveID(usFID);
        }

        return pRet;
}



HRESULT
TIDState::Read(USHORT usFID,
             BYTE *pDest,
             DWORD dwOffset,
             DWORD dwReqSize,
             DWORD *pdwRead)
{
    HRESULT hr = E_FAIL;
    ce::smart_ptr<SMBFileStream> pStream = NULL;

    //
    // Search out the SMBFileStream
    if(FAILED(hr = FindFileStream(usFID, pStream)) || !pStream) {
        TRACEMSG(ZONE_ERROR, (L"SMB-SRV: TIDState(TID:0x%x) cant find FID:0x%x on Read()", this->usTid, usFID));
        goto Done;
    }

    //
    // Perform our operation
    if(FAILED(hr = pStream->Read(pDest, dwOffset, dwReqSize, pdwRead))) {
        TRACEMSG(ZONE_ERROR, (L"SMB-SRV: TIDState(TID:0x%x) (FID:0x%x) operation Read() failed", this->usTid, usFID));
        goto Done;
    } else {
        CCritSection csLock(&SMB_Globals::g_Bookeeping_CS);
        csLock.Lock();
        SMB_Globals::g_Bookeeping_TotalRead.QuadPart += *pdwRead;
    }

    //
    // Success
    hr = S_OK;
    Done:
        return hr;
}

 HRESULT
 TIDState::Write(USHORT usFID,
              BYTE *pSrc,
              DWORD dwOffset,
              DWORD dwReqSize,
              DWORD *pdwWritten)
{
    HRESULT hr = E_FAIL;
    ce::smart_ptr<SMBFileStream> pStream = NULL;

    //
    // Search out the SMBFileStream
    if(FAILED(hr = FindFileStream(usFID, pStream)) || !pStream) {
        TRACEMSG(ZONE_ERROR, (L"SMB-SRV: TIDState(TID:0x%x) cant find FID:0x%x on Write()", this->usTid, usFID));
        goto Done;
    }

    //
    // Perform our operation
    if(FAILED(hr = pStream->Write(pSrc, dwOffset, dwReqSize, pdwWritten))) {
        TRACEMSG(ZONE_ERROR, (L"SMB-SRV: TIDState(TID:0x%x) (FID:0x%x) operation Write() failed", this->usTid, usFID));
        goto Done;
    } else {
        CCritSection csLock(&SMB_Globals::g_Bookeeping_CS);
        csLock.Lock();
        SMB_Globals::g_Bookeeping_TotalWritten.QuadPart += *pdwWritten;
    }

    //
    // Success
    hr = S_OK;
    Done:
        return hr;
}

HRESULT
TIDState::Open(USHORT usFID,
              const WCHAR *pFileName,
              DWORD dwAccess,
              DWORD dwDisposition,
              DWORD dwAttributes,
              DWORD dwShareMode)
{
    HRESULT hr = E_FAIL;