/////////////////////////////////////////////////////////////////////////////// // GetNoun // note -- you can only call this once after the verb (it eats the rest // of the line!) /////////////////////////////////////////////////////////////////////////////// static void GetNoun( TSTRING& noun ) { static TSTRING prevNoun; TCHAR buf[1024]; TCIN.getline( buf, 1024 ); // // find the end of the noun... // TCHAR* pStart = buf; TCHAR* end = &buf[1023]; while( IsSpace(*pStart) && (! IsEnd(*pStart)) && (pStart < end) ) pStart++; if( IsEnd( *pStart ) || (pStart >= end) ) { // no noun! noun = _T(""); return; } TCHAR* pCur = pStart; bool bQuote = false; if( *pCur == _T('\"') ) { bQuote = true; pCur++; pStart++; } while( pCur < end ) { if( (! bQuote) && IsSpace(*pCur) ) break; if( *pCur == _T('\"') && bQuote) break; pCur++; } noun.assign(pStart, (pCur - pStart)); if( noun.compare( _T("!$") ) == 0 ) { noun = prevNoun; } prevNoun = noun; }
bool cFSParserUtil::MapStringToProperty( const TSTRING& str, int& propIndex ) const { bool fMappedChar = true; // assume we'll recognize this char // and set false if we don't // for short names if( str.length() == 1 ) { switch( str[0] ) { case 'p': propIndex = cFSPropSet::PROP_MODE; break; case 'i': propIndex = cFSPropSet::PROP_INODE; break; case 'n': propIndex = cFSPropSet::PROP_NLINK; break; case 'u': propIndex = cFSPropSet::PROP_UID; break; case 'g': propIndex = cFSPropSet::PROP_GID; break; case 's': propIndex = cFSPropSet::PROP_SIZE; break; case 't': propIndex = cFSPropSet::PROP_FILETYPE;break; case 'd': propIndex = cFSPropSet::PROP_DEV; break; case 'r': propIndex = cFSPropSet::PROP_RDEV; break; case 'b': propIndex = cFSPropSet::PROP_BLOCKS; break; case 'a': propIndex = cFSPropSet::PROP_ATIME; break; case 'm': propIndex = cFSPropSet::PROP_MTIME; break; case 'c': propIndex = cFSPropSet::PROP_CTIME; break; case 'C': propIndex = cFSPropSet::PROP_CRC32; break; case 'M': propIndex = cFSPropSet::PROP_MD5; break; case 'S': propIndex = cFSPropSet::PROP_SHA; break; case 'H': propIndex = cFSPropSet::PROP_HAVAL; break; case 'l': propIndex = cFSPropSet::PROP_GROWING_FILE; break; default: fMappedChar = false; break; } } else { if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_MODE ) ) ) propIndex = cFSPropSet::PROP_MODE; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_INODE ) ) ) propIndex = cFSPropSet::PROP_INODE; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_UID ) ) ) propIndex = cFSPropSet::PROP_UID; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_GID ) ) ) propIndex = cFSPropSet::PROP_GID; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_SIZE ) ) ) propIndex = cFSPropSet::PROP_SIZE; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_FILETYPE ) ) ) propIndex = cFSPropSet::PROP_FILETYPE; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_DEV ) ) ) propIndex = cFSPropSet::PROP_DEV; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_RDEV ) ) ) propIndex = cFSPropSet::PROP_RDEV; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_BLOCKS ) ) ) propIndex = cFSPropSet::PROP_BLOCKS; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_ATIME ) ) ) propIndex = cFSPropSet::PROP_ATIME; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_MTIME ) ) ) propIndex = cFSPropSet::PROP_MTIME; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_CTIME ) ) ) propIndex = cFSPropSet::PROP_CTIME; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_CRC32 ) ) ) propIndex = cFSPropSet::PROP_CRC32; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_MD5 ) ) ) propIndex = cFSPropSet::PROP_MD5; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_SHA ) ) ) propIndex = cFSPropSet::PROP_SHA; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_HAVAL ) ) ) propIndex = cFSPropSet::PROP_HAVAL; else if( 0 == str.compare( TSS_GetString( cFS, fs::STR_PARSER_PROP_GROWING_FILE ) ) ) propIndex = cFSPropSet::PROP_GROWING_FILE; else fMappedChar = false; } return( fMappedChar ); }
/// <summary> /// <para name='Name'>ResolveDisplayName</para> /// <para name='Purpose'>Get an email address from a Display Name</para> /// </summary> /// <param name='szName'>Display Name to resolve</param> /// <param name='szEmailAddress'>[out] Returned email address</param> /// <returns>HRESULT</returns> /// <remarks> /// <para name='Notes'></para> /// <para name='Author'>Kenn Guilstorf</para> /// <para name='LastModified'>28Jan2016</para> /// </remarks> STDMETHODIMP ZybraxiSoft::CMailbox::ResolveDisplayName(TSTRING szName, TSTRING &szEmailAddress) { HRESULT hr = S_OK; LPADRBOOK lpAdrBook = NULL; LPADRLIST lpAdrList = NULL; TSTRING szEX = TSTRING(_T("EX")); bool isExchange = false; enum { prDISPLAY_NAME, NUM_PROPS }; // Check to make sure we have something in szName if (szName.empty() || szName.size() <= 0) { hr = MAPI_E_INVALID_PARAMETER; goto EXIT; } // Log what we're trying to resolve m_log << output::both << level::Informational << "Attempting to resolve '" << szName.c_str() << "'" << endl; // Open the address book // See: https://msdn.microsoft.com/en-us/library/office/cc815381.aspx if (SUCCEEDED(hr = m_lpSession->OpenAddressBook( NULL, // ulUIParam [may be NULL] NULL, // lpInterface [may be NULL; returns IAddrBook:IMAPIProp] NULL, // ulFlags [NULL means no flags] &lpAdrBook))) // lppAdrBook [out] { // Allocate the address list // Note: I like to use 'this' so I know which functions I'm responsible // for if I ever have to work on this... if (SUCCEEDED(hr = this->AllocAdrList( NUM_PROPS, &lpAdrList))) { // Even though we succeeded, do a check to make sure we have // an address list if (lpAdrList) { lpAdrList->cEntries = 1; // only looking for 1 entry lpAdrList->aEntries[0].cValues = NUM_PROPS; // Number of props // Set the SPropValue to whom we're looking for lpAdrList->aEntries[0].rgPropVals[prDISPLAY_NAME].ulPropTag = PR_DISPLAY_NAME; lpAdrList->aEntries[0].rgPropVals[prDISPLAY_NAME].Value.LPSZ = (LPTSTR)szName.c_str(); // Let's try to resolve the name now if (SUCCEEDED(hr = lpAdrBook->ResolveName( 0L, MAPI_UNICODE, NULL, lpAdrList))) { m_log << output::both << level::Informational << "Resolve name yielded " << lpAdrList->aEntries[0].cValues << " properties." << endl; for (UINT i = 0; i < lpAdrList->aEntries[0].cValues; i++) { // Store the property so I don't have to type so much... SPropValue spvCurrent = lpAdrList->aEntries[0].rgPropVals[i]; m_log << output::both << level::Informational << "Found Property '0x" << setfill(_T('0')) << setw(8) << setbase(16) << spvCurrent.ulPropTag << "'"; switch (spvCurrent.ulPropTag) { case PR_ADDRTYPE: if (szEX.compare(spvCurrent.Value.LPSZ) == 0) isExchange = true; break; case PR_DISPLAY_NAME: m_log << ": " << spvCurrent.Value.LPSZ; break; case PR_EMAIL_ADDRESS: m_log << ": " << spvCurrent.Value.LPSZ; szEmailAddress = TSTRING(spvCurrent.Value.LPSZ); break; default: if (((spvCurrent.ulPropTag & 0x1f) == 0x1f) || ((spvCurrent.ulPropTag & 0x1e) == 0x1e)) m_log << ": " << spvCurrent.Value.LPSZ; break; } m_log << endl; } if (!isExchange || (szEmailAddress.empty())) { hr = MAPI_E_NOT_FOUND; goto CLEANUP; } } else { FATAL(_T("lpAdrBook->ResolveName()"), hr); goto CLEANUP; } } } else { FATAL(_T("AllocAdrList()"), hr); goto CLEANUP; } } else { FATAL(_T("OpenAddressBook()"), hr); } CLEANUP: if (lpAdrList) { FreePadrlist(lpAdrList); lpAdrList = NULL; } if (lpAdrBook) { lpAdrBook->Release(); lpAdrBook = NULL; } EXIT: return hr; }
// case sensitive-matching bool cParseNamedAttr::NamesMatch( int nString, const TSTRING& strName ) const { return ( 0 == strName.compare( TSS_GetString( cTWParser, nString ) ) ); }
/////////////////////////////////////////////////////////////////////////////// // Function name : cUnixFSServices::FullPath // Description : // // Return type : bool // Argument : TSTRING& strFullPath // Argument : const TSTRING& strRelPathC // Argument : const TSTRING& pathRelFromC // // TODO -- is throwing an exception the more appropriate alternative to returning // a bool? I think it is ... mdb /////////////////////////////////////////////////////////////////////////////// bool cUnixFSServices::FullPath(TSTRING& strFullPath, const TSTRING& strRelPathC, const TSTRING& pathRelFromC) const { cDebug d("cUnixFSServices::FullPath"); d.TraceDebug("strRelPathC = %s, pathRelFromC = %s\n", strRelPathC.c_str(), pathRelFromC.c_str()); // don't do anything with an empty path if (strRelPathC.empty()) return false; #if USES_DEVICE_PATH TSTRING strRelPath = cDevicePath::AsPosix(strRelPathC); // make non-const temp var #else TSTRING strRelPath = strRelPathC; // make non-const temp var #endif // // get base name (where strRelPath will be relative to), which will either be; // 1. the root directory if strRelPath is an absolute path // 2. pathRelFrom if it's not empty // 3. otherwise ( not abs path AND no rel path ) the current working directory // if (strRelPath[0] == TW_SLASH) // if is absolute path { if (IsRoot(strRelPath)) // if it's root, don't monkey with it, just return it. { strFullPath = strRelPath; d.TraceDebug("Is root; returning %s\n", strFullPath.c_str()); return true; } else { strFullPath = _T(""); // push root, then add path elements from strRelPathC // one by one (in while loop below) } } else // is a relative path, so check pathRelFromC { if (pathRelFromC.empty()) // if we're relative to CWD... { // // get the current working directory // try { GetCurrentDir(strFullPath); #if USES_DEVICE_PATH strFullPath = cDevicePath::AsPosix(strFullPath); #endif util_TrailingSep(strFullPath, false); } catch (eFSServices&) { return false; } d.TraceDebug("Creating prefix relative to CWD: %s\n", strFullPath.c_str()); } else // we're relative to a given dir { #if USES_DEVICE_PATH strFullPath = cDevicePath::AsPosix(pathRelFromC); #else strFullPath = pathRelFromC; #endif util_RemoveDuplicateSeps(strFullPath); util_TrailingSep(strFullPath, false); d.TraceDebug("Creating prefix from supplied path: %s\n", strFullPath.c_str()); } } // // start adding path elements from strRelPath to the base name // ( which already has an absolute starting point. see above. ) // TSTRING strElem; int index = 0; while (util_GetNextPathElement(strRelPath, strElem, index++)) { d.TraceDebug("Path element = %s\n", strElem.c_str()); if (0 == strElem.compare(_T("."))) { // ignore it } else if (0 == strElem.compare(_T(".."))) { // go up a dir ( the function takes care of root dir case ) TSTRING strDummy; util_RemoveLastPathElement(strFullPath, strDummy); } else // just a regular old path element { strFullPath += TW_SLASH; strFullPath += strElem; } d.TraceDebug("FullPath is now %s\n", strFullPath.c_str()); } #if IS_AROS || IS_REDOX strFullPath = cDevicePath::AsNative(strFullPath); #endif d.TraceDebug("Done, returning %s\n", strFullPath.c_str()); return true; }