// // The developer of the original code and/or files is Tripwire, Inc. // Portions created by Tripwire, Inc. are copyright (C) 2000-2018 Tripwire, // Inc. Tripwire is a registered trademark of Tripwire, Inc. All rights // reserved. // // This program is free software. The contents of this file are subject // to the terms of the GNU General Public License as published by the // Free Software Foundation; either version 2 of the License, or (at your // option) any later version. You may redistribute it and/or modify it // only in compliance with the GNU General Public License. // // This program is distributed in the hope that it will be useful. // However, this program is distributed AS-IS WITHOUT ANY // WARRANTY; INCLUDING THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS // FOR A PARTICULAR PURPOSE. Please see the GNU General Public License // for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, // USA. // // Nothing in the GNU General Public License or any other license to use // the code or files shall permit you to use Tripwire's trademarks, // service marks, or other intellectual property without Tripwire's // prior written consent. // // If you have any questions, please contact Tripwire, Inc. at either // info@tripwire.org or www.tripwire.org. // /////////////////////////////////////////////////////////////////////////////// // fconame.h // // cFCOName -- represents the name of an FCO #ifndef __FCONAME_H #define __FCONAME_H #ifndef __SERIALIZABLE_H #include "core/serializable.h" #endif #ifndef __FCONAMEINFO_H #include "fconameinfo.h" #endif /////////////////////////////////////////////////////////////////////////////// // class cFCOName -- How we name a FCO. The implementation has ended up being // a wrapper around a standard string. /////////////////////////////////////////////////////////////////////////////// class cFCONameTblNode; class cFCONameIter; class cFCOName_i; class cFCOName : public iTypedSerializable { DECLARE_TYPEDSERIALIZABLE() public: typedef cFCONameIter iterator; explicit cFCOName(iFCONameInfo* iNI = NULL); cFCOName(const cFCOName& rhs); explicit cFCOName(const TSTRING& rhs, iFCONameInfo* iNI = NULL); explicit cFCOName(const TCHAR* rhs, iFCONameInfo* iNI = NULL); // these ctors are explicit because it is expensive to create these things, so we don't want to // do it unexpectedly virtual ~cFCOName(); cFCOName& operator = (const cFCOName& rhs); cFCOName& operator = (const TSTRING& rhs); cFCOName& operator = (const TCHAR* rhs); bool operator < (const cFCOName& rhs) const; // defines an arbitrary order for cFCONames. This is so that names can // be stored in trees and other ordered data structures in order to facilitate // fast lookups. bool operator == (const cFCOName& rhs) const; bool operator != (const cFCOName& rhs) const; bool IsEqual (const cFCOName& rhs) const; // both of these are synonyms for (GetRelationship(rhs) == REL_EQUAL) TSTRING AsString() const; // return a string representation of the string bool IsCaseSensitive() const; void SetCaseSensitive(bool val); // determines how name comparisons are done. If two cFCONames are compared who are // both case insensitive, a case insensitive compare is done. If both are case sensitive, // a case sensitive compare is done. If one is and one isn't case sensitive (? TODO: what // is the right thing to do in this case? ASSERT(0)? do a case sensitive compare??) TCHAR GetDelimiter() const; void SetDelimiter(TCHAR delimiter); // defines what the path-delimiting character is void Push(const TSTRING& str); // pushes the named string onto the end of the path. A delimiter is implicitely placed between the old end // and the new string. if debug is defined, it is asserted that the new string does not contain the // delimiting character const TCHAR* Pop(); // removes the last part of the path from the name and returns it. ASSERTS and returns an undefined value if // the path is empty const TCHAR* PopFront(); // removes the first part of the path from the name and returns it. ASSERTS and returns an undefined value if // the path is empty void Clear(); // removes all elements from the name; after this, GetSize() == 0. const TCHAR* GetShortName() const; // this will return the final string in the vector. It will assert that the name is not empty. int GetSize() const; // returns the number of path items (strings between delimiters) that are in the fco name. It is always equal // to the number of delimiters in the path plus one. enum Relationship { REL_BELOW, // an fco is below another (/etc/passwd is below /etc) REL_ABOVE, // an fco is above another (/etc is above /etc/passwd) REL_EQUAL, // the fcos are equal (/etc/passwd is equal to /etc/passwd) REL_UNRELATED // the fcos are unrelated (/var/spool/mail is unrelated to /var/log/pig.log) }; Relationship GetRelationship(const cFCOName& rhs) const; // returns the relationship of _this_ name to the one passed in (ie -- if REL_BELOW is returned, // this fco name is below the one passed in) virtual void Read (iSerializer* pSerializer, int32 version = 0); // throw (eSerializer, eArchive) virtual void Write(iSerializer* pSerializer) const; // throw (eSerializer, eArchive) ////////////////////////////////// // Debugging method ////////////////////////////////// static void ClearNameTable(); // this method should _only_ be called when the program is exiting, and you are positively sure you // will not be using or creating any more cFCONames. Violating this rule will result in unpredictable // results. This clears out the cFCOName internal name table, making memory leaks easier to find. protected: friend class cFCOName_i; friend class cFCONameIter; void ParseString(const TCHAR* str); // helper function that takes the pathname pointer to by str and fills out mpPathName void CopyOnModify(); // if the fconame is modified and mpPathName is shared by more than one object, this will // release mpPathName and create a new one, so we don't change any other object's data void SetNameInfo(iFCONameInfo* pNI); // sets the delimiter and case sensitiveness to the name info's cFCOName_i* mpPathName; TCHAR mDelimiter; // the delimiting character in names (ie -- in file systems, it is '/') bool mbCaseSensitive; // determines whether name compares are case sensitive of not // this is what type of structure holds the elements of the name // typedef std::vector ListType; #ifdef DEBUG TSTRING mDebugStrName; // so we can see this guy's value in the debug window #endif }; //----------------------------------------------------------------------------- // cFCONameIter //----------------------------------------------------------------------------- class cFCONameIter_i; class cFCONameIter { public: explicit cFCONameIter(const cFCOName& name); ~cFCONameIter(); int GetSize() const; // returns the number of entries in the fco name void SeekBegin(); void Next(); void Prev(); bool Done() const; int Index() const; // return the current offset from the beginning of the short name list void SeekTo( int index ); // seeks to the given index. asserts that the index is appropriate for the // current fco name. const TCHAR* GetName() const; private: void operator=(const cFCONameIter& rhs); // not impl cFCONameIter(const cFCONameIter& rhs); // not impl // the data... // const cFCOName& mName; cFCOName::ListType::const_iterator mIter; }; //############################################################################# // inline implementation inline bool cFCOName::IsCaseSensitive() const { return mbCaseSensitive; } inline void cFCOName::SetCaseSensitive(bool val) { mbCaseSensitive = val; } inline TCHAR cFCOName::GetDelimiter() const { return mDelimiter; } inline void cFCOName::SetDelimiter(TCHAR delimiter) { mDelimiter = delimiter; } /////////////////////////////////////////////////////////////////////////////// // IsEqual /////////////////////////////////////////////////////////////////////////////// inline bool cFCOName::IsEqual(const cFCOName& rhs) const { return (GetRelationship(rhs) == cFCOName::REL_EQUAL); } inline bool cFCOName::operator==(const cFCOName& rhs) const { return IsEqual(rhs); } inline bool cFCOName::operator!=(const cFCOName& rhs) const { return (! IsEqual(rhs)); } #endif //__FCONAME_H