extract-msg 0.48.2__py3-none-any.whl

extract_msg/structures/ole_stream_struct.py

@@ -0,0 +1,117 @@
+__all__ = [
+    'OleStreamStruct',
+]
+
+
+from typing import final, Optional
+
+from ..constants import st
+from ._helpers import BytesReader
+from .mon_stream import MonikerStream
+
+
+@final
+class OleStreamStruct:
+    """
+    The OLEStream structure, as specified in [MS-OLEDS].
+
+    Specifically, this is *only* the version that is used for embedded objects.
+    As such, only some of the fields are ever present.
+    """
+
+    def __init__(self, data: Optional[bytes] = None):
+        """
+        :raises TypeError: The data given is not for an embedded object.
+        """
+        self.__rms = None
+        if not data:
+            self.__flags = 0
+            self.__linkUpdateOption = 0
+            return
+        reader = BytesReader(data)
+        # Assert the version.
+        reader.assertRead(b'\x01\x00\x00\x02', 'Ole stream had invalid version (expected {expected}, got {actual}).')
+        self.__flags = reader.readUnsignedInt()
+        if self.__flags & 1:
+            raise TypeError('Cannot parse an OLEStream structure for a linked object.')
+        self.__linkUpdateOption = reader.readUnsignedInt()
+        reader.assertNull(4, 'Ole stream reserved was not null (got {actual}).')
+        rmsSize = reader.readUnsignedInt()
+        if rmsSize > 0:
+            self.__rms = MonikerStream(reader.read(rmsSize - 4))
+
+    def __bytes__(self) -> bytes:
+        return self.toBytes()
+
+    def toBytes(self) -> bytes:
+        ret = b'\x01\x00\x00\x02'
+        ret += st.ST_LE_UI32.pack(self.__flags)
+        ret += st.ST_LE_UI32.pack(self.__linkUpdateOption)
+        ret += b'\x00\x00\x00\x00'
+        rmsBytes = b'' if self.__rms is None else bytes(self.__rms)
+        rmsLen = (len(rmsBytes) + 4) if rmsBytes else 0
+        ret += st.ST_LE_UI32.pack(rmsLen) + rmsBytes
+
+        return ret
+
+    @property
+    def flags(self) -> int:
+        """
+        The flags for the OLEStream.
+
+        The bit with mask ``0x00001000`` is an implementation-specific hint
+        supplied by the application or by a higher-level protocol that creates
+        the data structure. It MAY be ignored on processing. A server
+        implementation which does not ignore this bit MAY cache the storage
+        when the bit is set.
+
+        :raises ValueError: The property was set with a bit other than the
+            implementation specific bit set.
+        """
+        return self.__flags
+
+    @flags.setter
+    def flags(self, value: int) -> None:
+        if not isinstance(value, int):
+            raise TypeError(':property flags: MUST be an int.')
+        if value != 0 and value != 0x1000:
+            raise ValueError('Cannot set bits other than the implementation specific one.')
+
+        self.__flags = value
+
+    @property
+    def linkUpdateOption(self) -> int:
+        """
+        An implementation-specific hint.
+
+        This hint MAY be ignored. On Windows, this field contains values from
+        the OLEUPDATE enumeration.
+        """
+        return self.__linkUpdateOption
+
+    @linkUpdateOption.setter
+    def linkUpdateOption(self, value: int) -> None:
+        if not isinstance(value, int):
+            raise TypeError(':property linkUpdateOption: MUST be an int.')
+        if value < 0:
+            raise ValueError(':property linkUpdateOption: MUST be positive.')
+        if value > 0xFFFFFFFF:
+            raise ValueError(':property linkUpdateOption: MUST be less than 0x100000000.')
+
+        self.__linkUpdateOption = value
+
+    @property
+    def reservedMonikerStream(self) -> Optional[MonikerStream]:
+        """
+        A MonikerStream structure that can contain any arbitrary value.
+        """
+        return self.__rms
+
+    @reservedMonikerStream.setter
+    def reservedMonikerStream(self, data: Optional[MonikerStream]) -> None:
+        if data is not None and not isinstance(data, MonikerStream):
+            raise TypeError('Reserved moniker stream must be a MonikerStream instance or None.')
+
+        self.__rms = data
+
+

extract_msg/structures/recurrence_pattern.py

@@ -0,0 +1,199 @@
+__all__ = [
+    'RecurrencePattern',
+]
+
+
+from typing import Any, Tuple
+
+from ..enums import RecurCalendarType, RecurDOW, RecurEndType, RecurFrequency, RecurMonthNthWeek, RecurPatternType, RecurPatternTypeSpecificWeekday
+from ._helpers import BytesReader
+
+
+class RecurrencePattern:
+    """
+    A RecurrencePattern structure, as specified in [MS-OXOCAL].
+    """
+
+    def __init__(self, data: bytes):
+        self.__rawData = data
+        reader = BytesReader(data)
+        self.__readerVersion = reader.readUnsignedShort()
+        self.__writerVersion = reader.readUnsignedShort()
+        if not (self.__readerVersion == self.__writerVersion == 0x3004):
+            raise ValueError('Reader version or writer version was not set to 0x3004.')
+
+        self.__recurFrequency = RecurFrequency(reader.readUnsignedShort())
+        self.__patternType = RecurPatternType(reader.readUnsignedShort())
+        self.__calendarType = RecurCalendarType(reader.readUnsignedShort())
+        self.__firstDateTime = reader.readUnsignedInt()
+        self.__period = reader.readUnsignedInt()
+        self.__slidingFlag = reader.readUnsignedInt()
+        # This is just here to help shorten lines.
+        RPTSW = RecurPatternTypeSpecificWeekday
+        # This field changes depending on the recurrence type.
+        if self.__patternType == RecurPatternType.DAY:
+            self.__patternTypeSpecific = None
+        elif self.__patternType == RecurPatternType.WEEK:
+            self.__patternTypeSpecific = RPTSW(reader.readUnsignedInt())
+        elif self.__patternType in (RecurPatternType.MONTH_NTH, RecurPatternType.HJ_MONTH_NTH):
+            self.__patternTypeSpecific = reader.readUnsignedInt()
+        else:
+            self.__patternTypeSpecific = (RPTSW(reader.readUnsignedInt()),
+                                          RecurMonthNthWeek(reader.readUnsignedInt()))
+
+        self.__endType = RecurEndType.fromInt(reader.readUnsignedInt())
+        self.__occurrenceCount = reader.readUnsignedInt()
+        self.__firstDOW = RecurDOW(reader.readUnsignedInt())
+        deletedInstanceCount = reader.readUnsignedInt()
+        self.__deletedInstanceDates = tuple(reader.readUnsignedInt() for _ in range(deletedInstanceCount))
+        modifiedInstanceCount = reader.readUnsignedInt()
+        self.__modifiedInstanceDates = tuple(reader.readUnsignedInt() for _ in range(modifiedInstanceCount))
+        self.__startDate = reader.readUnsignedInt()
+        self.__endDate = reader.readUnsignedInt()
+
+    def __bytes__(self) -> bytes:
+        return self.toBytes()
+
+    def toBytes(self) -> bytes:
+        return self.__rawData
+
+    @property
+    def calendarType(self) -> RecurCalendarType:
+        """
+        The type of calendar that is used.
+        """
+        return self.__calendarType
+
+    @property
+    def deletedInstanceDates(self) -> Tuple[int, ...]:
+        """
+        A tuple of the dates (stored as number of minutes between midnight,
+        January 1, 1601, and midnight on the specified day in the timezone
+        specified in the calendar object), ordered from earliest to latest, of
+        either a deleted instance or a modified instance for this recurrence.
+        """
+        return self.__deletedInstanceDates
+
+    @property
+    def endDate(self) -> int:
+        """
+        An integer that specifies the ending date for the recurrence.
+
+        The value is the number of minutes between midnight, January 1, 1601,
+        and midnight of the date of the last occurrence. When the value of the
+        endType field is ``END_AFTER_N_OCCURRENCES``, this value is calculated
+        based on the number of occurrences. If the recurrence does not have an
+        end date, the value of the endDate field MUST be set to ``0x5AE980DF``.
+        """
+        return self.__endDate
+
+    @property
+    def endType(self) -> RecurEndType:
+        """
+        The ending type for the recurrence.
+        """
+        return self.__endType
+
+    @property
+    def firstDateTime(self) -> int:
+        """
+        The first ever dat, week, or month of a recurring series, dating back to
+        a reference date, which is January 1, 1601, for a Gregorian calendar.
+        """
+        return self.__firstDateTime
+
+    @property
+    def firstDayOfWeek(self) -> RecurDOW:
+        """
+        The day on which the calendar week begins.
+        """
+        return self.__firstDOW
+
+    @property
+    def modifiedInstanceDates(self) -> Tuple[int, ...]:
+        """
+        A tuple of the dates (stored as number of minutes between midnight,
+        January 1, 1601, and midnight on the specified day in the timezone
+        specified in the calendar object), ordered from earliest to latest, of
+        a modified instance.
+        """
+        return self.__modifiedInstanceDates
+
+    @property
+    def occurrenceCount(self) -> int:
+        """
+        Number of occurrences for a recurrence that ends after N occurrences.
+        """
+        return self.__occurrenceCount
+
+    @property
+    def patternType(self) -> RecurPatternType:
+        """
+        The type of recurrence pattern.
+        """
+        return self.__patternType
+
+    @property
+    def patternTypeSpecific(self) -> Any:
+        """
+        The specifics for the pattern type.
+
+        Return is different depending on what type of pattern is being used.
+
+        * RecurPatternType.DAY: No value is returned.
+        * RecurPatternType.WEEK: A set of RecurPatternTypeSpecificWeekday bits.
+        * RecurPatternType.MONTH: The day of the month on which the recurrence
+          falls.
+        * RecurPatternType.MONTH_NTH: A tuple containing information from
+          [MS-OXOCAL] PatternTypeSpecific MonthNth.
+        * RecurPatternType.MONTH_END: The day of the month on which the
+          recurrence falls.
+        * RecurPatternType.HJ_MONTH: The day of the month on which the
+          recurrence falls.
+        * RecurPatternType.HJ_MONTH_NTH: A tuple containing information from
+          [MS-OXOCAL] PatternTypeSpecific MonthNth.
+        * RecurPatternType.HJ_MONTH_END: The day of the month on which the
+          recurrence falls.
+        """
+        return self.__patternTypeSpecific
+
+    @property
+    def period(self) -> int:
+        """
+        An integer that specifies the interval at which the meeting pattern
+        specified in PatternTypeSpecific field repeats.
+
+        The Period value MUST be between 1 and the maximum recurrence interval,
+        which is 999 days for daily recurrences, 99 weeks for weekly
+        recurrences, and 99 months for monthly recurrences.
+        """
+        return self.__period
+
+    @property
+    def readerVersion(self) -> int:
+        return self.__readerVersion
+
+    @property
+    def recurFrequency(self) -> RecurFrequency:
+        """
+        The frequency of the recurring series.
+        """
+        return self.__recurFrequency
+
+    @property
+    def slidingFlag(self) -> int:
+        return self.__slidingFlag
+
+    @property
+    def startDate(self) -> int:
+        """
+        An integer that specifies the date of the first occurrence.
+
+        The value is the number of minutes between midnight, January 1, 1601,
+        and midnight of the date of the first occurrence.
+        """
+        return self.__startDate
+
+    @property
+    def writerVersion(self) -> int:
+        return self.__writerVersion

extract_msg/structures/report_tag.py

@@ -0,0 +1,127 @@
+__all__ = [
+    'ReportTag',
+]
+
+
+from typing import Optional
+
+from ._helpers import BytesReader
+from .entry_id import EntryID, FolderEntryID, MessageEntryID, StoreObjectEntryID
+
+
+class ReportTag:
+    """
+    A Report Tag structure, as defined in [MS-OXOMSG].
+    """
+
+    def __init__(self, data: bytes):
+        self.__rawData = data
+        reader = BytesReader(data)
+
+        self.__cookie = reader.assertRead(b'PCDFEB09\x00')
+
+        self.__version = reader.readUnsignedInt()
+        entrySize = reader.readInt()
+        if entrySize:
+            self.__storeEntryID = StoreObjectEntryID(reader.read(entrySize))
+        else:
+            self.__storeEntryID = None
+
+        entrySize = reader.readInt()
+        if entrySize:
+            self.__folderEntryID = FolderEntryID(reader.read(entrySize))
+        else:
+            self.__folderEntryID = None
+
+        entrySize = reader.readInt()
+        if entrySize:
+            self.__messageEntryID = MessageEntryID(reader.read(entrySize))
+        else:
+            self.__messageEntryID = None
+
+        entrySize = reader.readInt()
+        if entrySize:
+            self.__searchFolderEntryID = FolderEntryID(reader.read(entrySize))
+        else:
+            self.__searchFolderEntryID = None
+
+        entrySize = reader.readInt()
+        if entrySize:
+            self.__messageSearchKey = reader.read(entrySize)
+        else:
+            self.__messageSearchKey = None
+
+        entrySize = reader.readInt()
+        if entrySize:
+            self.__ansiText = reader.read(entrySize)
+        else:
+            self.__ansiText = None
+
+    def __bytes__(self) -> bytes:
+        return self.toBytes()
+
+    def toBytes(self) -> bytes:
+        return self.__rawData
+
+    @property
+    def ansiText(self) -> Optional[bytes]:
+        """
+        The subject of the original message.
+
+        Set to None if not present.
+        """
+        return self.__ansiText
+
+    @property
+    def cookie(self) -> bytes:
+        """
+        String used for validation.
+
+        Set to ``b'PCDFEB09\x00'``.
+        """
+        return self.__cookie
+
+    @property
+    def folderEntryID(self) -> Optional[EntryID]:
+        """
+        The EntryID of the folder than contains the original message.
+        """
+        return self.__folderEntryID
+
+    @property
+    def messageEntryID(self) -> Optional[EntryID]:
+        """
+        The EntryID of the original message.
+        """
+        return self.__messageEntryID
+
+    @property
+    def messageSearchKey(self) -> Optional[bytes]:
+        """
+        The search key of the original message.
+        """
+        return self.__messageSearchKey
+
+    @property
+    def searchFolderEntryID(self) -> Optional[EntryID]:
+        """
+        The EntryID of an alternate folder that contains the original message.
+        """
+        return self.__searchFolderEntryID
+
+    @property
+    def storeEntryID(self) -> Optional[EntryID]:
+        """
+        The EntryID of the mailbox that contains the original message.
+        """
+        return self.__storeEntryID
+
+    @property
+    def version(self) -> int:
+        """
+        The version used.
+
+        If SearchFolderEntryID is present, this MUST be ``0x00020001``,
+        otherwise it MUST be ``0x00010001``.
+        """
+        return self.__version

extract_msg/structures/system_time.py

@@ -0,0 +1,158 @@
+__all__ = [
+    'SystemTime',
+]
+
+
+from typing import Any, Optional
+
+from .. import constants
+
+
+class SystemTime:
+    """
+    A SYSTEMTIME struct, as defined in [MS-DTYP].
+    """
+    def __init__(self, data: Optional[bytes] = None):
+        data = data or (b'\x00' * 16)
+        self.unpack(data)
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, SystemTime) and bytes(self) == bytes(other)
+
+    def __ne__(self, other: Any) -> bool:
+        return not self.__eq__(other)
+
+    def __bytes__(self) -> bytes:
+        return self.toBytes()
+
+    def toBytes(self) -> bytes:
+        """
+        Packs the current data into bytes.
+        """
+        return constants.st.ST_SYSTEMTIME.pack(self.__year,
+                                               self.__month,
+                                               self.__dayOfWeek,
+                                               self.__day,
+                                               self.__hour,
+                                               self.__minute,
+                                               self.__second,
+                                               self.__milliseconds)
+
+    def unpack(self, data: bytes) -> None:
+        """
+        Fills out the fields of this instance by unpacking the bytes.
+        """
+        unpacked = constants.st.ST_SYSTEMTIME.unpack(data)
+        self.__year = unpacked[0]
+        self.__month = unpacked[1]
+        self.__dayOfWeek = unpacked[2]
+        self.__day = unpacked[3]
+        self.__hour = unpacked[4]
+        self.__minute = unpacked[5]
+        self.__second = unpacked[6]
+        self.__milliseconds = unpacked[7]
+
+    @property
+    def day(self) -> int:
+        return self.__day
+
+    @day.setter
+    def day(self, value: int) -> None:
+        if value < 0:
+            raise ValueError('Day must be positive.')
+        if value > 0xFFFF:
+            raise ValueError('Day cannot be greater than 0xFFFF.')
+
+        self.__day = value
+
+    @property
+    def dayOfWeek(self) -> int:
+        return self.__dayOfWeek
+
+    @dayOfWeek.setter
+    def dayOfWeek(self, value: int) -> None:
+        if value < 0:
+            raise ValueError('Day of week must be positive.')
+        if value > 0xFFFF:
+            raise ValueError('Day of week cannot be greater than 0xFFFF.')
+
+        self.__dayOfWeek = value
+
+    @property
+    def hour(self) -> int:
+        return self.__hour
+
+    @hour.setter
+    def hour(self, value: int) -> None:
+        if value < 0:
+            raise ValueError('Hour must be positive.')
+        if value > 0xFFFF:
+            raise ValueError('Hour cannot be greater than 0xFFFF.')
+
+        self.__hour = value
+
+    @property
+    def milliseconds(self) -> int:
+        return self.__milliseconds
+
+    @milliseconds.setter
+    def milliseconds(self, value: int) -> None:
+        if value < 0:
+            raise ValueError('Milliseconds must be positive.')
+        if value > 0xFFFF:
+            raise ValueError('Milliseconds cannot be greater than 0xFFFF.')
+
+        self.__milliseconds = value
+
+    @property
+    def minute(self) -> int:
+        return self.__minute
+
+    @minute.setter
+    def minute(self, value: int) -> None:
+        if value < 0:
+            raise ValueError('Minute must be positive.')
+        if value > 0xFFFF:
+            raise ValueError('Minute cannot be greater than 0xFFFF.')
+
+        self.__minute = value
+
+    @property
+    def month(self) -> int:
+        return self.__month
+
+    @month.setter
+    def month(self, value: int) -> None:
+        if value < 0:
+            raise ValueError('Month must be positive.')
+        if value > 0xFFFF:
+            raise ValueError('Month cannot be greater than 0xFFFF.')
+
+        self.__month = value
+
+    @property
+    def second(self) -> int:
+        return self.__second
+
+    @second.setter
+    def second(self, value: int) -> None:
+        if value < 0:
+            raise ValueError('Second must be positive.')
+        if value > 0xFFFF:
+            raise ValueError('Second cannot be greater than 0xFFFF.')
+
+        self.__second = value
+
+    @property
+    def year(self) -> int:
+        return self.__year
+
+    @year.setter
+    def year(self, value: int) -> None:
+        if value < 0:
+            raise ValueError('Year must be positive.')
+        if value > 0xFFFF:
+            raise ValueError('Year cannot be greater than 0xFFFF.')
+
+        self.__year = value
+