ApparmorReporting.hpp

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                     _     _   _   _     __     _                     |
|                    | |   | | | \_/ |   /  \   | |                    |
|                    | |   | | | |_| |  / /\ \  | |                    |
|                    | |__ | | | | | | / ____ \ | |__                  |
|                    |____||_| |_| |_|/ /    \ \|____|                 |
|                                                                      |
|                             apparmor-reporting library                          |
|                                                                      |
|                                         (C) SUSE Linux Products GmbH |
\----------------------------------------------------------------------/

  File:       ApparmorReporting.hpp

  Author:     Matt Barringer <mbarringer@suse.de>
  Maintainer: Matt Barringer <mbarringer@suse.de>

  Purpose: To provide an API to work with AppArmor's reporting configuration files,
           which consists of an XML file, /etc/apparmor/reports.conf and a crontab,
           /etc/apparmor/reports.crontab
/-*/
#ifndef   LIMAL_APPARMOR_REPORTING_HPP
#define   LIMAL_APPARMOR_REPORTING_HPP

#include <limal/apparmor-reporting/config.h>
#include <blocxx/String.hpp>
#include <blocxx/COWIntrusiveReference.hpp>
#include <blocxx/Map.hpp>
#include <libxml/tree.h>

namespace LIMAL_NAMESPACE
{
namespace APPARMOR_REPORTING_NAMESPACE
{

class ReportData
{
public:
        ReportData()
        {
                mExportCSV = false;
                mExportHTML = false;
                mRunDay = -1;
                mRunHour = 0;
                mRunMinute = 59;
        }

        ReportData(const ReportData& data)
                : mReportName(data.mReportName),
                  mReportProgram(data.mReportProgram),
                  mProfileName(data.mProfileName),
                  mResource(data.mResource),
                  mAccessMode(data.mAccessMode),
                  mApparmorEvent(data.mApparmorEvent),
                  mExportPath(data.mExportPath),
                  mEmailOne(data.mEmailOne),
                  mEmailTwo(data.mEmailTwo),
                  mEmailThree(data.mEmailThree),
                  mPid(data.mPid),
                  mSeverity(data.mSeverity),
                  mExportCSV(data.mExportCSV),
                  mExportHTML(data.mExportHTML),
                  mTimestamp(data.mTimestamp),
                  mRunDay(data.mRunDay),
                  mRunDayOfWeek(data.mRunDayOfWeek),
                  mRunHour(data.mRunHour),
                  mRunMinute(data.mRunMinute)
        {}

        ReportData* clone() const
        {
                return new ReportData(*this);
        }

        ReportData& operator=(const ReportData &data)
        {
                if (this != &data)
                {
                        mReportName = data.mReportName;
                        mReportProgram = data.mReportProgram;
                        mProfileName = data.mProfileName;
                        mResource = data.mResource;
                        mAccessMode = data.mAccessMode;
                        mApparmorEvent = data.mApparmorEvent;
                        mExportPath = data.mExportPath;
                        mEmailOne = data.mEmailOne;
                        mEmailTwo = data.mEmailTwo;
                        mEmailThree = data.mEmailThree;
                        mPid = data.mPid;
                        mSeverity = data.mSeverity;
                        mExportCSV = data.mExportCSV;
                        mExportHTML = data.mExportHTML;
                        mTimestamp = data.mTimestamp;
                        mRunDay = data.mRunDay;
                        mRunDayOfWeek = data.mRunDayOfWeek;
                        mRunHour = data.mRunHour;
                        mRunMinute = data.mRunMinute;
                }
                return *this;
        }

        blocxx::String getReportName() { return mReportName; }
        void setReportName(const blocxx::String& reportName) { mReportName = reportName; }

        blocxx::String getReportProgram() { return mReportProgram; }
        void setReportProgram(const blocxx::String& reportProgram) { mReportProgram = reportProgram; }

        blocxx::String getProfileName() { return mProfileName; }
        void setProfileName(const blocxx::String& profileName) { mProfileName = profileName; }

        blocxx::String getResource() { return mResource; }
        void setResource(const blocxx::String& resource) { mResource = resource; }

        blocxx::String getAccessMode() { return mAccessMode; }
        void setAccessMode(const blocxx::String& accessMode) { mAccessMode = accessMode; }

        blocxx::String getApparmorEvent() { return mApparmorEvent; }
        void setApparmorEvent(const blocxx::String& apparmorEvent) { mApparmorEvent = apparmorEvent; }
        blocxx::String getExportPath() { return mExportPath; }
        void setExportPath(const blocxx::String& exportPath) { mExportPath = exportPath; }

        blocxx::String getEmailOne() { return mEmailOne; }
        void setEmailOne(const blocxx::String& emailOne) { mEmailOne = emailOne; }

        blocxx::String getEmailTwo() { return mEmailTwo; }
        void setEmailTwo(const blocxx::String& emailTwo) { mEmailTwo = emailTwo; }

        blocxx::String getEmailThree() { return mEmailThree; }
        void setEmailThree(const blocxx::String& emailThree) { mEmailThree = emailThree; }

        blocxx::String getPid() { return mPid; }
        void setPid(const blocxx::String& pid) { mPid = pid; }

        blocxx::String getSeverity() { return mSeverity; }
        void setSeverity(const blocxx::String& severity) { mSeverity = severity; }

        blocxx::String getTimestamp() { return mTimestamp; }
        void setTimestamp(const blocxx::String& timestamp) { mTimestamp = timestamp; }

        bool getExportCSV() { return mExportCSV; }
        void setExportCSV(bool exportCSV) { mExportCSV = exportCSV; }

        bool getExportHTML() { return mExportHTML; }
        void setExportHTML(bool exportHTML) { mExportHTML = exportHTML; }

        int getRunDay() { return mRunDay; }
        void setRunDay(int runDay) { mRunDay = runDay; }

        blocxx::String getRunDayOfWeek() { return mRunDayOfWeek; }
        void setRunDayOfWeek(const blocxx::String& runDayOfWeek) { mRunDayOfWeek = runDayOfWeek; }

        int getRunHour() { return mRunHour; }
        void setRunHour(int runHour) { mRunHour = runHour; }

        int getRunMinute() { return mRunMinute; }
        void setRunMinute(int runMinute) { mRunMinute = runMinute; }

private:
        blocxx::String mReportName;
        blocxx::String mReportProgram;
        blocxx::String mProfileName;
        blocxx::String mResource;
        blocxx::String mAccessMode; // The access mode that caused the event (r/w/l/m/x)
        blocxx::String mApparmorEvent; // ([P]ermit/[R]eject/[A]udit
        blocxx::String mExportPath;
        blocxx::String mEmailOne;
        blocxx::String mEmailTwo;
        blocxx::String mEmailThree;
        blocxx::String mPid;
        blocxx::String mSeverity;
        bool mExportCSV;
        bool mExportHTML;
        blocxx::String mTimestamp;
        // Then, the data contained in the crontab
        int mRunDay;
        blocxx::String mRunDayOfWeek;
        int mRunHour;
        int mRunMinute;
};

typedef blocxx::Map<blocxx::String, ReportData> ReportConfig;

class ApparmorReportingConfig
{
public:
        ApparmorReportingConfig(const blocxx::String& xmlPath = "/etc/apparmor/reports.conf",
                                const blocxx::String& crontabPath = "/etc/apparmor/reports.crontab");

        ~ApparmorReportingConfig();

        ReportConfig
        readConfig();

        bool
        writeConfig(ReportConfig& config);

        void
        removeReport(const blocxx::String& name);

        void
        writeReport(const blocxx::String& currentName,
                     const blocxx::String& newName,
                     const ReportData& reportData);
        bool
        reportExists(const blocxx::String& name);

        ReportData
        findReport(const blocxx::String& name);
        blocxx::String
        getXMLPath();
        
        void
        setXMLPath(const blocxx::String& xmlPath);

        blocxx::String
        getCrontabPath();

        void
        setCrontabPath(const blocxx::String& crontabPath);

private:
        class Data;
        blocxx::COWIntrusiveReference<Data> m_data;
        void loadXML();
        blocxx::String find_text(xmlNodePtr currentElement, const char *tag);
        blocxx::String find_attribute(xmlNodePtr currentElement, const char *tag, const char *attribute);
        bool find_crontab_data(ReportData& data);
};

}      // End of APPARMOR_REPORTING_NAMESPACE

namespace Apparmor
{
        using limal::apparmor_reporting::ApparmorReportingConfig;
}


}      // End of LIMAL_NAMESPACE

#endif // LIMAL_APPARMOR_REPORTING_HPP

---