Re: Dare support -- complete

Index: src/phones/com_lgvx9100.py
===================================================================
--- src/phones/com_lgvx9100.py	(revision 4628)
+++ src/phones/com_lgvx9100.py	(working copy)
@@ -15,12 +15,13 @@
 import common
 import com_brew
 import com_lg
-import com_lgvx8550
+import com_lgvx10000
 import p_lgvx9100
 import helpids
+import sms
 
 #-------------------------------------------------------------------------------
-parentphone=com_lgvx8550.Phone
+parentphone=com_lgvx10000.Phone
 class Phone(parentphone):
     "Talk to the LG VX9100 cell phone"
 
@@ -82,8 +83,59 @@
                               self.ringtonelocations, results, merge,
                               self.getringtoneindices, False)
         
+    def _getoutboxmessage(self, sf):
+        entry=sms.SMSEntry()
+        entry.folder=entry.Folder_Sent
+        entry.datetime="%d%02d%02dT%02d%02d%02d" % ((sf.timesent))
+        # add all the recipients
+        for r in sf.recipients:
+            if r.number:
+                confirmed=(r.status==5)
+                confirmed_date=None
+                if confirmed:
+                    confirmed_date="%d%02d%02dT%02d%02d%02d" % r.timereceived
+                entry.add_recipient(r.number, confirmed, confirmed_date)
+        entry.subject=sf.subject
+        txt=""
+        if sf.num_msg_elements==1 and not sf.messages[0].binary:
+            txt=self._get_text_from_sms_msg_without_header(sf.messages[0].msg, sf.messages[0].length)
+        else:
+            for i in range(sf.num_msg_elements):
+                txt+=self._get_text_from_sms_msg_with_header(sf.messages[i].msg, sf.messages[i].length)
+        entry.text=unicode(txt, errors='ignore')
+        if sf.priority==0:
+            entry.priority=sms.SMSEntry.Priority_Normal
+        else:
+            entry.priority=sms.SMSEntry.Priority_High
+        entry.locked=sf.locked
+        entry.callback=sf.callback
+        return entry
+
+    def _getinboxmessage(self, sf):
+        entry=sms.SMSEntry()
+        entry.folder=entry.Folder_Inbox
+        entry.datetime="%d%02d%02dT%02d%02d%02d" % (sf.gtimerecv)
+        entry._from=sf.sender_callback
+        entry.subject=sf.subject
+        entry.locked=sf.locked
+        if sf.priority==0:
+            entry.priority=sms.SMSEntry.Priority_Normal
+        else:
+            entry.priority=sms.SMSEntry.Priority_High
+        entry.read=sf.read
+
+        # read message data
+        txt=""
+        for msg in sf.msgs:
+            if msg.msg_length != 0:
+                txt += self._get_text_from_sms_msg_with_header(msg.msg_data.msg, msg.msg_length)
+
+        entry.text=unicode(txt, errors='ignore')
+        entry.callback=sf.sender_callback
+        return entry
+
 #-------------------------------------------------------------------------------
-parentprofile=com_lgvx8550.Profile
+parentprofile=com_lgvx10000.Profile
 class Profile(parentprofile):
     protocolclass=Phone.protocolclass
     serialsname=Phone.serialsname
@@ -122,14 +174,15 @@
 
     _supportedsyncs=(
 ##        ('phonebook', 'read', None),   # all phonebook reading
-##        ('calendar', 'read', None),    # all calendar reading
+        ('calendar', 'read', None),    # all calendar reading
         ('wallpaper', 'read', None),   # all wallpaper reading
         ('ringtone', 'read', None),    # all ringtone reading
-##        ('call_history', 'read', None),# all call history list reading
-##        ('sms', 'read', None),         # all SMS list reading
-##        ('memo', 'read', None),        # all memo list reading
+        ('call_history', 'read', None),# all call history list reading
+        ('sms', 'read', None),         # all SMS list reading
+        ('memo', 'read', None),        # all memo list reading
+        ('t9_udb', 'read', 'OVERWRITE'),
 ##        ('phonebook', 'write', 'OVERWRITE'),  # only overwriting phonebook
-##        ('calendar', 'write', 'OVERWRITE'),   # only overwriting calendar
+        ('calendar', 'write', 'OVERWRITE'),   # only overwriting calendar
         ('wallpaper', 'write', 'MERGE'),      # merge and overwrite wallpaper
 ##        ('wallpaper', 'write', 'OVERWRITE'),
         ('ringtone', 'write', 'MERGE'),       # merge and overwrite ringtone
@@ -138,4 +191,5 @@
 ##        ('memo', 'write', 'OVERWRITE'),       # all memo list writing
 ####        ('playlist', 'read', 'OVERWRITE'),
 ####        ('playlist', 'write', 'OVERWRITE'),
+        ('t9_udb', 'write', 'OVERWRITE'),
         )
Index: src/phones/p_lgvx9100.p
===================================================================
--- src/phones/p_lgvx9100.p	(revision 4628)
+++ src/phones/p_lgvx9100.p	(working copy)
@@ -34,6 +34,18 @@
 INDEX_VIDEO_TYPE=3
 INDEX_IMAGE_TYPE=0
 
+SMS_CANNED_MAX_ITEMS=30
+
+pb_file_name    = 'pim/pbentry.dat'
+pn_file_name    = 'pim/pbnumber.dat'
+speed_file_name = 'pim/pbspeed.dat'
+ice_file_name   = 'pim/pbiceentry.dat'
+
+# SMS index files
+inbox_index     = "dload/inbox.dat"
+outbox_index    = "dload/outbox.dat"
+drafts_index    = "dload/drafts.dat"
+
 %}
 
 PACKET indexentry:
@@ -50,3 +62,57 @@
     "Used for tracking wallpaper and ringtones"
     * LIST {'elementclass': indexentry, 'createdefault': True} +items
 
+PACKET sms_saved:
+    P BOOL { 'default': True } +outboxmsg
+    4 GPSDATE GPStime   # num seconds since 0h 1-6-80, time message received by phone
+    * sms_out outbox
+
+PACKET sms_out:
+    4 UINT unk0             # zero
+    4 UINT index            # starting from 1, unique
+    1 UINT locked           # 1=locked
+    3 UNKNOWN unk1          # zero
+    4 GPSDATE timesent      # time the message was sent
+    4 GPSDATE timestamp
+    61 USTRING {'encoding': PHONE_ENCODING} subject
+    2 UINT num_msg_elements # up to 7 -- this may not be correct
+    2 UINT priority         # 0=normal, 2=high
+    2 UNKNOWN unk2          # always 01 01
+    24 USTRING callback     # this is probably not 24 bytes long
+    * LIST { 'elementclass': recipient_record,'length': 10 } +recipients
+    * LIST {'elementclass': msg_record, 'length': 7} +messages
+    * UNKNOWN pad1
+
+PACKET SMSINBOXMSGFRAGMENT:
+    * LIST { 'length': 222 } +msg:
+        1 UINT byte "individual byte of message"
+
+PACKET sms_in:
+    4  UINT    unk0      # zero
+    4  UINT    index
+    4  UINT    unk1      # 0x0002005C
+    4  GPSDATE gtimerecv # num seconds since 0h 1-6-80, time message received by phone
+    6  SMSDATE timesent
+    2  UINT    unk2      # zero
+    4  GPSDATE gtimesent # num seconds since 0h 1-6-80, time message received by phone
+    1  UINT    read
+    1  UINT    locked
+    1  UINT    priority
+    15 UNKNOWN dunno1
+    64 USTRING {'encoding': PHONE_ENCODING,
+                'raiseonunterminatedread': False } subject
+    # phone could have more than 10 message fragments
+    * LIST { 'length': 10 } +msgs:
+        1 UINT msg_id
+        1 UINT msg_length
+        * SMSINBOXMSGFRAGMENT msg_data
+    2292 UNKNOWN dunno3
+    33   USTRING sender_name
+    33   USTRING sender_callback
+    24   UNKNOWN unk3
+    # this stuff is required by the code, but couldn't figure it out,
+    # so just fake it
+    P UINT { 'default': 0 } +bin_header1
+    P UINT { 'default': 0 } +bin_header2
+    P UINT { 'default': 0 } +multipartID
+    P UINT { 'default': 0 } +bin_header3
Index: src/phones/p_lgvx9100.py
===================================================================
--- src/phones/p_lgvx9100.py	(revision 4628)
+++ src/phones/p_lgvx9100.py	(working copy)
@@ -16,6 +16,8 @@
 UINT=UINTlsb
 BOOL=BOOLlsb
 
+NUMSPEEDDIALS=1000
+
 BREW_FILE_SYSTEM=2
 
 INDEX_RT_TYPE=257
@@ -23,6 +25,18 @@
 INDEX_VIDEO_TYPE=3
 INDEX_IMAGE_TYPE=0
 
+SMS_CANNED_MAX_ITEMS=30
+
+pb_file_name    = 'pim/pbentry.dat'
+pn_file_name    = 'pim/pbnumber.dat'
+speed_file_name = 'pim/pbspeed.dat'
+ice_file_name   = 'pim/pbiceentry.dat'
+
+# SMS index files
+inbox_index     = "dload/inbox.dat"
+outbox_index    = "dload/outbox.dat"
+drafts_index    = "dload/drafts.dat"
+
 class indexentry(BaseProtogenClass):
     __fields=['filename', 'size', 'date', 'type', 'dunno']
 
@@ -254,3 +268,1101 @@
 
 
 
+class sms_saved(BaseProtogenClass):
+    __fields=['outboxmsg', 'GPStime', 'outbox']
+
+    def __init__(self, *args, **kwargs):
+        dict={}
+        # What was supplied to this function
+        dict.update(kwargs)
+        # Parent constructor
+        super(sms_saved,self).__init__(**dict)
+        if self.__class__ is sms_saved:
+            self._update(args,dict)
+
+
+    def getfields(self):
+        return self.__fields
+
+
+    def _update(self, args, kwargs):
+        super(sms_saved,self)._update(args,kwargs)
+        keys=kwargs.keys()
+        for key in keys:
+            if key in self.__fields:
+                setattr(self, key, kwargs[key])
+                del kwargs[key]
+        # Were any unrecognized kwargs passed in?
+        if __debug__:
+            self._complainaboutunusedargs(sms_saved,kwargs)
+        if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
+        # Make all P fields that haven't already been constructed
+        try: self.__field_outboxmsg
+        except:
+            self.__field_outboxmsg=BOOL(**{ 'default': True })
+
+
+    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
+        'Writes this packet to the supplied buffer'
+        self._bufferstartoffset=buf.getcurrentoffset()
+        self.__field_GPStime.writetobuffer(buf)
+        self.__field_outbox.writetobuffer(buf)
+        self._bufferendoffset=buf.getcurrentoffset()
+        if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
+
+
+    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
+        'Reads this packet from the supplied buffer'
+        self._bufferstartoffset=buf.getcurrentoffset()
+        if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
+        self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
+        self.__field_GPStime.readfrombuffer(buf)
+        self.__field_outbox=sms_out()
+        self.__field_outbox.readfrombuffer(buf)
+        self._bufferendoffset=buf.getcurrentoffset()
+
+
+    def __getfield_outboxmsg(self):
+        try: self.__field_outboxmsg
+        except:
+            self.__field_outboxmsg=BOOL(**{ 'default': True })
+        return self.__field_outboxmsg.getvalue()
+
+    def __setfield_outboxmsg(self, value):
+        if isinstance(value,BOOL):
+            self.__field_outboxmsg=value
+        else:
+            self.__field_outboxmsg=BOOL(value,**{ 'default': True })
+
+    def __delfield_outboxmsg(self): del self.__field_outboxmsg
+
+    outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None)
+
+    def __getfield_GPStime(self):
+        return self.__field_GPStime.getvalue()
+
+    def __setfield_GPStime(self, value):
+        if isinstance(value,GPSDATE):
+            self.__field_GPStime=value
+        else:
+            self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
+
+    def __delfield_GPStime(self): del self.__field_GPStime
+
+    GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
+
+    def __getfield_outbox(self):
+        return self.__field_outbox.getvalue()
+
+    def __setfield_outbox(self, value):
+        if isinstance(value,sms_out):
+            self.__field_outbox=value
+        else:
+            self.__field_outbox=sms_out(value,)
+
+    def __delfield_outbox(self): del self.__field_outbox
+
+    outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None)
+
+    def iscontainer(self):
+        return True
+
+    def containerelements(self):
+        yield ('outboxmsg', self.__field_outboxmsg, None)
+        yield ('GPStime', self.__field_GPStime, None)
+        yield ('outbox', self.__field_outbox, None)
+
+
+
+
+class sms_out(BaseProtogenClass):
+    __fields=['unk0', 'index', 'locked', 'unk1', 'timesent', 'timestamp', 'subject', 'num_msg_elements', 'priority', 'unk2', 'callback', 'recipients', 'messages', 'pad1']
+
+    def __init__(self, *args, **kwargs):
+        dict={}
+        # What was supplied to this function
+        dict.update(kwargs)
+        # Parent constructor
+        super(sms_out,self).__init__(**dict)
+        if self.__class__ is sms_out:
+            self._update(args,dict)
+
+
+    def getfields(self):
+        return self.__fields
+
+
+    def _update(self, args, kwargs):
+        super(sms_out,self)._update(args,kwargs)
+        keys=kwargs.keys()
+        for key in keys:
+            if key in self.__fields:
+                setattr(self, key, kwargs[key])
+                del kwargs[key]
+        # Were any unrecognized kwargs passed in?
+        if __debug__:
+            self._complainaboutunusedargs(sms_out,kwargs)
+        if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
+        # Make all P fields that haven't already been constructed
+
+
+    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
+        'Writes this packet to the supplied buffer'
+        self._bufferstartoffset=buf.getcurrentoffset()
+        self.__field_unk0.writetobuffer(buf)
+        self.__field_index.writetobuffer(buf)
+        self.__field_locked.writetobuffer(buf)
+        self.__field_unk1.writetobuffer(buf)
+        self.__field_timesent.writetobuffer(buf)
+        self.__field_timestamp.writetobuffer(buf)
+        self.__field_subject.writetobuffer(buf)
+        self.__field_num_msg_elements.writetobuffer(buf)
+        self.__field_priority.writetobuffer(buf)
+        self.__field_unk2.writetobuffer(buf)
+        self.__field_callback.writetobuffer(buf)
+        try: self.__field_recipients
+        except:
+            self.__field_recipients=LIST(**{ 'elementclass': recipient_record,'length': 10 })
+        self.__field_recipients.writetobuffer(buf)
+        try: self.__field_messages
+        except:
+            self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7})
+        self.__field_messages.writetobuffer(buf)
+        self.__field_pad1.writetobuffer(buf)
+        self._bufferendoffset=buf.getcurrentoffset()
+        if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
+
+
+    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
+        'Reads this packet from the supplied buffer'
+        self._bufferstartoffset=buf.getcurrentoffset()
+        if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
+        self.__field_unk0=UINT(**{'sizeinbytes': 4})
+        self.__field_unk0.readfrombuffer(buf)
+        self.__field_index=UINT(**{'sizeinbytes': 4})
+        self.__field_index.readfrombuffer(buf)
+        self.__field_locked=UINT(**{'sizeinbytes': 1})
+        self.__field_locked.readfrombuffer(buf)
+        self.__field_unk1=UNKNOWN(**{'sizeinbytes': 3})
+        self.__field_unk1.readfrombuffer(buf)
+        self.__field_timesent=GPSDATE(**{'sizeinbytes': 4})
+        self.__field_timesent.readfrombuffer(buf)
+        self.__field_timestamp=GPSDATE(**{'sizeinbytes': 4})
+        self.__field_timestamp.readfrombuffer(buf)
+        self.__field_subject=USTRING(**{'sizeinbytes': 61, 'encoding': PHONE_ENCODING})
+        self.__field_subject.readfrombuffer(buf)
+        self.__field_num_msg_elements=UINT(**{'sizeinbytes': 2})
+        self.__field_num_msg_elements.readfrombuffer(buf)
+        self.__field_priority=UINT(**{'sizeinbytes': 2})
+        self.__field_priority.readfrombuffer(buf)
+        self.__field_unk2=UNKNOWN(**{'sizeinbytes': 2})
+        self.__field_unk2.readfrombuffer(buf)
+        self.__field_callback=USTRING(**{'sizeinbytes': 24})
+        self.__field_callback.readfrombuffer(buf)
+        self.__field_recipients=LIST(**{ 'elementclass': recipient_record,'length': 10 })
+        self.__field_recipients.readfrombuffer(buf)
+        self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7})
+        self.__field_messages.readfrombuffer(buf)
+        self.__field_pad1=UNKNOWN()
+        self.__field_pad1.readfrombuffer(buf)
+        self._bufferendoffset=buf.getcurrentoffset()
+
+
+    def __getfield_unk0(self):
+        return self.__field_unk0.getvalue()
+
+    def __setfield_unk0(self, value):
+        if isinstance(value,UINT):
+            self.__field_unk0=value
+        else:
+            self.__field_unk0=UINT(value,**{'sizeinbytes': 4})
+
+    def __delfield_unk0(self): del self.__field_unk0
+
+    unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None)
+
+    def __getfield_index(self):
+        return self.__field_index.getvalue()
+
+    def __setfield_index(self, value):
+        if isinstance(value,UINT):
+            self.__field_index=value
+        else:
+            self.__field_index=UINT(value,**{'sizeinbytes': 4})
+
+    def __delfield_index(self): del self.__field_index
+
+    index=property(__getfield_index, __setfield_index, __delfield_index, None)
+
+    def __getfield_locked(self):
+        return self.__field_locked.getvalue()
+
+    def __setfield_locked(self, value):
+        if isinstance(value,UINT):
+            self.__field_locked=value
+        else:
+            self.__field_locked=UINT(value,**{'sizeinbytes': 1})
+
+    def __delfield_locked(self): del self.__field_locked
+
+    locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None)
+
+    def __getfield_unk1(self):
+        return self.__field_unk1.getvalue()
+
+    def __setfield_unk1(self, value):
+        if isinstance(value,UNKNOWN):
+            self.__field_unk1=value
+        else:
+            self.__field_unk1=UNKNOWN(value,**{'sizeinbytes': 3})
+
+    def __delfield_unk1(self): del self.__field_unk1
+
+    unk1=property(__getfield_unk1, __setfield_unk1, __delfield_unk1, None)
+
+    def __getfield_timesent(self):
+        return self.__field_timesent.getvalue()
+
+    def __setfield_timesent(self, value):
+        if isinstance(value,GPSDATE):
+            self.__field_timesent=value
+        else:
+            self.__field_timesent=GPSDATE(value,**{'sizeinbytes': 4})
+
+    def __delfield_timesent(self): del self.__field_timesent
+
+    timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
+
+    def __getfield_timestamp(self):
+        return self.__field_timestamp.getvalue()
+
+    def __setfield_timestamp(self, value):
+        if isinstance(value,GPSDATE):
+            self.__field_timestamp=value
+        else:
+            self.__field_timestamp=GPSDATE(value,**{'sizeinbytes': 4})
+
+    def __delfield_timestamp(self): del self.__field_timestamp
+
+    timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None)
+
+    def __getfield_subject(self):
+        return self.__field_subject.getvalue()
+
+    def __setfield_subject(self, value):
+        if isinstance(value,USTRING):
+            self.__field_subject=value
+        else:
+            self.__field_subject=USTRING(value,**{'sizeinbytes': 61, 'encoding': PHONE_ENCODING})
+
+    def __delfield_subject(self): del self.__field_subject
+
+    subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
+
+    def __getfield_num_msg_elements(self):
+        return self.__field_num_msg_elements.getvalue()
+
+    def __setfield_num_msg_elements(self, value):
+        if isinstance(value,UINT):
+            self.__field_num_msg_elements=value
+        else:
+            self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 2})
+
+    def __delfield_num_msg_elements(self): del self.__field_num_msg_elements
+
+    num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None)
+
+    def __getfield_priority(self):
+        return self.__field_priority.getvalue()
+
+    def __setfield_priority(self, value):
+        if isinstance(value,UINT):
+            self.__field_priority=value
+        else:
+            self.__field_priority=UINT(value,**{'sizeinbytes': 2})
+
+    def __delfield_priority(self): del self.__field_priority
+
+    priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None)
+
+    def __getfield_unk2(self):
+        return self.__field_unk2.getvalue()
+
+    def __setfield_unk2(self, value):
+        if isinstance(value,UNKNOWN):
+            self.__field_unk2=value
+        else:
+            self.__field_unk2=UNKNOWN(value,**{'sizeinbytes': 2})
+
+    def __delfield_unk2(self): del self.__field_unk2
+
+    unk2=property(__getfield_unk2, __setfield_unk2, __delfield_unk2, None)
+
+    def __getfield_callback(self):
+        return self.__field_callback.getvalue()
+
+    def __setfield_callback(self, value):
+        if isinstance(value,USTRING):
+            self.__field_callback=value
+        else:
+            self.__field_callback=USTRING(value,**{'sizeinbytes': 24})
+
+    def __delfield_callback(self): del self.__field_callback
+
+    callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
+
+    def __getfield_recipients(self):
+        try: self.__field_recipients
+        except:
+            self.__field_recipients=LIST(**{ 'elementclass': recipient_record,'length': 10 })
+        return self.__field_recipients.getvalue()
+
+    def __setfield_recipients(self, value):
+        if isinstance(value,LIST):
+            self.__field_recipients=value
+        else:
+            self.__field_recipients=LIST(value,**{ 'elementclass': recipient_record,'length': 10 })
+
+    def __delfield_recipients(self): del self.__field_recipients
+
+    recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None)
+
+    def __getfield_messages(self):
+        try: self.__field_messages
+        except:
+            self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7})
+        return self.__field_messages.getvalue()
+
+    def __setfield_messages(self, value):
+        if isinstance(value,LIST):
+            self.__field_messages=value
+        else:
+            self.__field_messages=LIST(value,**{'elementclass': msg_record, 'length': 7})
+
+    def __delfield_messages(self): del self.__field_messages
+
+    messages=property(__getfield_messages, __setfield_messages, __delfield_messages, None)
+
+    def __getfield_pad1(self):
+        return self.__field_pad1.getvalue()
+
+    def __setfield_pad1(self, value):
+        if isinstance(value,UNKNOWN):
+            self.__field_pad1=value
+        else:
+            self.__field_pad1=UNKNOWN(value,)
+
+    def __delfield_pad1(self): del self.__field_pad1
+
+    pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
+
+    def iscontainer(self):
+        return True
+
+    def containerelements(self):
+        yield ('unk0', self.__field_unk0, None)
+        yield ('index', self.__field_index, None)
+        yield ('locked', self.__field_locked, None)
+        yield ('unk1', self.__field_unk1, None)
+        yield ('timesent', self.__field_timesent, None)
+        yield ('timestamp', self.__field_timestamp, None)
+        yield ('subject', self.__field_subject, None)
+        yield ('num_msg_elements', self.__field_num_msg_elements, None)
+        yield ('priority', self.__field_priority, None)
+        yield ('unk2', self.__field_unk2, None)
+        yield ('callback', self.__field_callback, None)
+        yield ('recipients', self.__field_recipients, None)
+        yield ('messages', self.__field_messages, None)
+        yield ('pad1', self.__field_pad1, None)
+
+
+
+
+class SMSINBOXMSGFRAGMENT(BaseProtogenClass):
+    __fields=['msg']
+
+    def __init__(self, *args, **kwargs):
+        dict={}
+        # What was supplied to this function
+        dict.update(kwargs)
+        # Parent constructor
+        super(SMSINBOXMSGFRAGMENT,self).__init__(**dict)
+        if self.__class__ is SMSINBOXMSGFRAGMENT:
+            self._update(args,dict)
+
+
+    def getfields(self):
+        return self.__fields
+
+
+    def _update(self, args, kwargs):
+        super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs)
+        keys=kwargs.keys()
+        for key in keys:
+            if key in self.__fields:
+                setattr(self, key, kwargs[key])
+                del kwargs[key]
+        # Were any unrecognized kwargs passed in?
+        if __debug__:
+            self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs)
+        if len(args):
+            dict2={'elementclass': _gen_p_lgvx9100_88,  'length': 222 }
+            dict2.update(kwargs)
+            kwargs=dict2
+            self.__field_msg=LIST(*args,**dict2)
+        # Make all P fields that haven't already been constructed
+
+
+    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
+        'Writes this packet to the supplied buffer'
+        self._bufferstartoffset=buf.getcurrentoffset()
+        try: self.__field_msg
+        except:
+            self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx9100_88,  'length': 222 })
+        self.__field_msg.writetobuffer(buf)
+        self._bufferendoffset=buf.getcurrentoffset()
+        if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
+
+
+    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
+        'Reads this packet from the supplied buffer'
+        self._bufferstartoffset=buf.getcurrentoffset()
+        if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
+        self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx9100_88,  'length': 222 })
+        self.__field_msg.readfrombuffer(buf)
+        self._bufferendoffset=buf.getcurrentoffset()
+
+
+    def __getfield_msg(self):
+        try: self.__field_msg
+        except:
+            self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx9100_88,  'length': 222 })
+        return self.__field_msg.getvalue()
+
+    def __setfield_msg(self, value):
+        if isinstance(value,LIST):
+            self.__field_msg=value
+        else:
+            self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx9100_88,  'length': 222 })
+
+    def __delfield_msg(self): del self.__field_msg
+
+    msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
+
+    def iscontainer(self):
+        return True
+
+    def containerelements(self):
+        yield ('msg', self.__field_msg, None)
+
+
+
+
+class _gen_p_lgvx9100_88(BaseProtogenClass):
+    'Anonymous inner class'
+    __fields=['byte']
+
+    def __init__(self, *args, **kwargs):
+        dict={}
+        # What was supplied to this function
+        dict.update(kwargs)
+        # Parent constructor
+        super(_gen_p_lgvx9100_88,self).__init__(**dict)
+        if self.__class__ is _gen_p_lgvx9100_88:
+            self._update(args,dict)
+
+
+    def getfields(self):
+        return self.__fields
+
+
+    def _update(self, args, kwargs):
+        super(_gen_p_lgvx9100_88,self)._update(args,kwargs)
+        keys=kwargs.keys()
+        for key in keys:
+            if key in self.__fields:
+                setattr(self, key, kwargs[key])
+                del kwargs[key]
+        # Were any unrecognized kwargs passed in?
+        if __debug__:
+            self._complainaboutunusedargs(_gen_p_lgvx9100_88,kwargs)
+        if len(args):
+            dict2={'sizeinbytes': 1}
+            dict2.update(kwargs)
+            kwargs=dict2
+            self.__field_byte=UINT(*args,**dict2)
+        # Make all P fields that haven't already been constructed
+
+
+    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
+        'Writes this packet to the supplied buffer'
+        self._bufferstartoffset=buf.getcurrentoffset()
+        self.__field_byte.writetobuffer(buf)
+        self._bufferendoffset=buf.getcurrentoffset()
+        if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
+
+
+    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
+        'Reads this packet from the supplied buffer'
+        self._bufferstartoffset=buf.getcurrentoffset()
+        if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
+        self.__field_byte=UINT(**{'sizeinbytes': 1})
+        self.__field_byte.readfrombuffer(buf)
+        self._bufferendoffset=buf.getcurrentoffset()
+
+
+    def __getfield_byte(self):
+        return self.__field_byte.getvalue()
+
+    def __setfield_byte(self, value):
+        if isinstance(value,UINT):
+            self.__field_byte=value
+        else:
+            self.__field_byte=UINT(value,**{'sizeinbytes': 1})
+
+    def __delfield_byte(self): del self.__field_byte
+
+    byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message")
+
+    def iscontainer(self):
+        return True
+
+    def containerelements(self):
+        yield ('byte', self.__field_byte, "individual byte of message")
+
+
+
+
+class sms_in(BaseProtogenClass):
+    __fields=['unk0', 'index', 'unk1', 'gtimerecv', 'timesent', 'unk2', 'gtimesent', 'read', 'locked', 'priority', 'dunno1', 'subject', 'msgs', 'dunno3', 'sender_name', 'sender_callback', 'unk3', 'bin_header1', 'bin_header2', 'multipartID', 'bin_header3']
+
+    def __init__(self, *args, **kwargs):
+        dict={}
+        # What was supplied to this function
+        dict.update(kwargs)
+        # Parent constructor
+        super(sms_in,self).__init__(**dict)
+        if self.__class__ is sms_in:
+            self._update(args,dict)
+
+
+    def getfields(self):
+        return self.__fields
+
+
+    def _update(self, args, kwargs):
+        super(sms_in,self)._update(args,kwargs)
+        keys=kwargs.keys()
+        for key in keys:
+            if key in self.__fields:
+                setattr(self, key, kwargs[key])
+                del kwargs[key]
+        # Were any unrecognized kwargs passed in?
+        if __debug__:
+            self._complainaboutunusedargs(sms_in,kwargs)
+        if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
+        # Make all P fields that haven't already been constructed
+        try: self.__field_bin_header1
+        except:
+            self.__field_bin_header1=UINT(**{ 'default': 0 })
+        try: self.__field_bin_header2
+        except:
+            self.__field_bin_header2=UINT(**{ 'default': 0 })
+        try: self.__field_multipartID
+        except:
+            self.__field_multipartID=UINT(**{ 'default': 0 })
+        try: self.__field_bin_header3
+        except:
+            self.__field_bin_header3=UINT(**{ 'default': 0 })
+
+
+    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
+        'Writes this packet to the supplied buffer'
+        self._bufferstartoffset=buf.getcurrentoffset()
+        self.__field_unk0.writetobuffer(buf)
+        self.__field_index.writetobuffer(buf)
+        self.__field_unk1.writetobuffer(buf)
+        self.__field_gtimerecv.writetobuffer(buf)
+        self.__field_timesent.writetobuffer(buf)
+        self.__field_unk2.writetobuffer(buf)
+        self.__field_gtimesent.writetobuffer(buf)
+        self.__field_read.writetobuffer(buf)
+        self.__field_locked.writetobuffer(buf)
+        self.__field_priority.writetobuffer(buf)
+        self.__field_dunno1.writetobuffer(buf)
+        self.__field_subject.writetobuffer(buf)
+        try: self.__field_msgs
+        except:
+            self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx9100_106,  'length': 10 })
+        self.__field_msgs.writetobuffer(buf)
+        self.__field_dunno3.writetobuffer(buf)
+        self.__field_sender_name.writetobuffer(buf)
+        self.__field_sender_callback.writetobuffer(buf)
+        self.__field_unk3.writetobuffer(buf)
+        self._bufferendoffset=buf.getcurrentoffset()
+        if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
+
+
+    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
+        'Reads this packet from the supplied buffer'
+        self._bufferstartoffset=buf.getcurrentoffset()
+        if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
+        self.__field_unk0=UINT(**{'sizeinbytes': 4})
+        self.__field_unk0.readfrombuffer(buf)
+        self.__field_index=UINT(**{'sizeinbytes': 4})
+        self.__field_index.readfrombuffer(buf)
+        self.__field_unk1=UINT(**{'sizeinbytes': 4})
+        self.__field_unk1.readfrombuffer(buf)
+        self.__field_gtimerecv=GPSDATE(**{'sizeinbytes': 4})
+        self.__field_gtimerecv.readfrombuffer(buf)
+        self.__field_timesent=SMSDATE(**{'sizeinbytes': 6})
+        self.__field_timesent.readfrombuffer(buf)
+        self.__field_unk2=UINT(**{'sizeinbytes': 2})
+        self.__field_unk2.readfrombuffer(buf)
+        self.__field_gtimesent=GPSDATE(**{'sizeinbytes': 4})
+        self.__field_gtimesent.readfrombuffer(buf)
+        self.__field_read=UINT(**{'sizeinbytes': 1})
+        self.__field_read.readfrombuffer(buf)
+        self.__field_locked=UINT(**{'sizeinbytes': 1})
+        self.__field_locked.readfrombuffer(buf)
+        self.__field_priority=UINT(**{'sizeinbytes': 1})
+        self.__field_priority.readfrombuffer(buf)
+        self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 15})
+        self.__field_dunno1.readfrombuffer(buf)
+        self.__field_subject=USTRING(**{'sizeinbytes': 64, 'encoding': PHONE_ENCODING,                'raiseonunterminatedread': False })
+        self.__field_subject.readfrombuffer(buf)
+        self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx9100_106,  'length': 10 })
+        self.__field_msgs.readfrombuffer(buf)
+        self.__field_dunno3=UNKNOWN(**{'sizeinbytes': 2292})
+        self.__field_dunno3.readfrombuffer(buf)
+        self.__field_sender_name=USTRING(**{'sizeinbytes': 33})
+        self.__field_sender_name.readfrombuffer(buf)
+        self.__field_sender_callback=USTRING(**{'sizeinbytes': 33})
+        self.__field_sender_callback.readfrombuffer(buf)
+        self.__field_unk3=UNKNOWN(**{'sizeinbytes': 24})
+        self.__field_unk3.readfrombuffer(buf)
+        self._bufferendoffset=buf.getcurrentoffset()
+
+
+    def __getfield_unk0(self):
+        return self.__field_unk0.getvalue()
+
+    def __setfield_unk0(self, value):
+        if isinstance(value,UINT):
+            self.__field_unk0=value
+        else:
+            self.__field_unk0=UINT(value,**{'sizeinbytes': 4})
+
+    def __delfield_unk0(self): del self.__field_unk0
+
+    unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None)
+
+    def __getfield_index(self):
+        return self.__field_index.getvalue()
+
+    def __setfield_index(self, value):
+        if isinstance(value,UINT):
+            self.__field_index=value
+        else:
+            self.__field_index=UINT(value,**{'sizeinbytes': 4})
+
+    def __delfield_index(self): del self.__field_index
+
+    index=property(__getfield_index, __setfield_index, __delfield_index, None)
+
+    def __getfield_unk1(self):
+        return self.__field_unk1.getvalue()
+
+    def __setfield_unk1(self, value):
+        if isinstance(value,UINT):
+            self.__field_unk1=value
+        else:
+            self.__field_unk1=UINT(value,**{'sizeinbytes': 4})
+
+    def __delfield_unk1(self): del self.__field_unk1
+
+    unk1=property(__getfield_unk1, __setfield_unk1, __delfield_unk1, None)
+
+    def __getfield_gtimerecv(self):
+        return self.__field_gtimerecv.getvalue()
+
+    def __setfield_gtimerecv(self, value):
+        if isinstance(value,GPSDATE):
+            self.__field_gtimerecv=value
+        else:
+            self.__field_gtimerecv=GPSDATE(value,**{'sizeinbytes': 4})
+
+    def __delfield_gtimerecv(self): del self.__field_gtimerecv
+
+    gtimerecv=property(__getfield_gtimerecv, __setfield_gtimerecv, __delfield_gtimerecv, None)
+
+    def __getfield_timesent(self):
+        return self.__field_timesent.getvalue()
+
+    def __setfield_timesent(self, value):
+        if isinstance(value,SMSDATE):
+            self.__field_timesent=value
+        else:
+            self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6})
+
+    def __delfield_timesent(self): del self.__field_timesent
+
+    timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
+
+    def __getfield_unk2(self):
+        return self.__field_unk2.getvalue()
+
+    def __setfield_unk2(self, value):
+        if isinstance(value,UINT):
+            self.__field_unk2=value
+        else:
+            self.__field_unk2=UINT(value,**{'sizeinbytes': 2})
+
+    def __delfield_unk2(self): del self.__field_unk2
+
+    unk2=property(__getfield_unk2, __setfield_unk2, __delfield_unk2, None)
+
+    def __getfield_gtimesent(self):
+        return self.__field_gtimesent.getvalue()
+
+    def __setfield_gtimesent(self, value):
+        if isinstance(value,GPSDATE):
+            self.__field_gtimesent=value
+        else:
+            self.__field_gtimesent=GPSDATE(value,**{'sizeinbytes': 4})
+
+    def __delfield_gtimesent(self): del self.__field_gtimesent
+
+    gtimesent=property(__getfield_gtimesent, __setfield_gtimesent, __delfield_gtimesent, None)
+
+    def __getfield_read(self):
+        return self.__field_read.getvalue()
+
+    def __setfield_read(self, value):
+        if isinstance(value,UINT):
+            self.__field_read=value
+        else:
+            self.__field_read=UINT(value,**{'sizeinbytes': 1})
+
+    def __delfield_read(self): del self.__field_read
+
+    read=property(__getfield_read, __setfield_read, __delfield_read, None)
+
+    def __getfield_locked(self):
+        return self.__field_locked.getvalue()
+
+    def __setfield_locked(self, value):
+        if isinstance(value,UINT):
+            self.__field_locked=value
+        else:
+            self.__field_locked=UINT(value,**{'sizeinbytes': 1})
+
+    def __delfield_locked(self): del self.__field_locked
+
+    locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None)
+
+    def __getfield_priority(self):
+        return self.__field_priority.getvalue()
+
+    def __setfield_priority(self, value):
+        if isinstance(value,UINT):
+            self.__field_priority=value
+        else:
+            self.__field_priority=UINT(value,**{'sizeinbytes': 1})
+
+    def __delfield_priority(self): del self.__field_priority
+
+    priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None)
+
+    def __getfield_dunno1(self):
+        return self.__field_dunno1.getvalue()
+
+    def __setfield_dunno1(self, value):
+        if isinstance(value,UNKNOWN):
+            self.__field_dunno1=value
+        else:
+            self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 15})
+
+    def __delfield_dunno1(self): del self.__field_dunno1
+
+    dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
+
+    def __getfield_subject(self):
+        return self.__field_subject.getvalue()
+
+    def __setfield_subject(self, value):
+        if isinstance(value,USTRING):
+            self.__field_subject=value
+        else:
+            self.__field_subject=USTRING(value,**{'sizeinbytes': 64, 'encoding': PHONE_ENCODING,                'raiseonunterminatedread': False })
+
+    def __delfield_subject(self): del self.__field_subject
+
+    subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
+
+    def __getfield_msgs(self):
+        try: self.__field_msgs
+        except:
+            self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx9100_106,  'length': 10 })
+        return self.__field_msgs.getvalue()
+
+    def __setfield_msgs(self, value):
+        if isinstance(value,LIST):
+            self.__field_msgs=value
+        else:
+            self.__field_msgs=LIST(value,**{'elementclass': _gen_p_lgvx9100_106,  'length': 10 })
+
+    def __delfield_msgs(self): del self.__field_msgs
+
+    msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None)
+
+    def __getfield_dunno3(self):
+        return self.__field_dunno3.getvalue()
+
+    def __setfield_dunno3(self, value):
+        if isinstance(value,UNKNOWN):
+            self.__field_dunno3=value
+        else:
+            self.__field_dunno3=UNKNOWN(value,**{'sizeinbytes': 2292})
+
+    def __delfield_dunno3(self): del self.__field_dunno3
+
+    dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
+
+    def __getfield_sender_name(self):
+        return self.__field_sender_name.getvalue()
+
+    def __setfield_sender_name(self, value):
+        if isinstance(value,USTRING):
+            self.__field_sender_name=value
+        else:
+            self.__field_sender_name=USTRING(value,**{'sizeinbytes': 33})
+
+    def __delfield_sender_name(self): del self.__field_sender_name
+
+    sender_name=property(__getfield_sender_name, __setfield_sender_name, __delfield_sender_name, None)
+
+    def __getfield_sender_callback(self):
+        return self.__field_sender_callback.getvalue()
+
+    def __setfield_sender_callback(self, value):
+        if isinstance(value,USTRING):
+            self.__field_sender_callback=value
+        else:
+            self.__field_sender_callback=USTRING(value,**{'sizeinbytes': 33})
+
+    def __delfield_sender_callback(self): del self.__field_sender_callback
+
+    sender_callback=property(__getfield_sender_callback, __setfield_sender_callback, __delfield_sender_callback, None)
+
+    def __getfield_unk3(self):
+        return self.__field_unk3.getvalue()
+
+    def __setfield_unk3(self, value):
+        if isinstance(value,UNKNOWN):
+            self.__field_unk3=value
+        else:
+            self.__field_unk3=UNKNOWN(value,**{'sizeinbytes': 24})
+
+    def __delfield_unk3(self): del self.__field_unk3
+
+    unk3=property(__getfield_unk3, __setfield_unk3, __delfield_unk3, None)
+
+    def __getfield_bin_header1(self):
+        try: self.__field_bin_header1
+        except:
+            self.__field_bin_header1=UINT(**{ 'default': 0 })
+        return self.__field_bin_header1.getvalue()
+
+    def __setfield_bin_header1(self, value):
+        if isinstance(value,UINT):
+            self.__field_bin_header1=value
+        else:
+            self.__field_bin_header1=UINT(value,**{ 'default': 0 })
+
+    def __delfield_bin_header1(self): del self.__field_bin_header1
+
+    bin_header1=property(__getfield_bin_header1, __setfield_bin_header1, __delfield_bin_header1, None)
+
+    def __getfield_bin_header2(self):
+        try: self.__field_bin_header2
+        except:
+            self.__field_bin_header2=UINT(**{ 'default': 0 })
+        return self.__field_bin_header2.getvalue()
+
+    def __setfield_bin_header2(self, value):
+        if isinstance(value,UINT):
+            self.__field_bin_header2=value
+        else:
+            self.__field_bin_header2=UINT(value,**{ 'default': 0 })
+
+    def __delfield_bin_header2(self): del self.__field_bin_header2
+
+    bin_header2=property(__getfield_bin_header2, __setfield_bin_header2, __delfield_bin_header2, None)
+
+    def __getfield_multipartID(self):
+        try: self.__field_multipartID
+        except:
+            self.__field_multipartID=UINT(**{ 'default': 0 })
+        return self.__field_multipartID.getvalue()
+
+    def __setfield_multipartID(self, value):
+        if isinstance(value,UINT):
+            self.__field_multipartID=value
+        else:
+            self.__field_multipartID=UINT(value,**{ 'default': 0 })
+
+    def __delfield_multipartID(self): del self.__field_multipartID
+
+    multipartID=property(__getfield_multipartID, __setfield_multipartID, __delfield_multipartID, None)
+
+    def __getfield_bin_header3(self):
+        try: self.__field_bin_header3
+        except:
+            self.__field_bin_header3=UINT(**{ 'default': 0 })
+        return self.__field_bin_header3.getvalue()
+
+    def __setfield_bin_header3(self, value):
+        if isinstance(value,UINT):
+            self.__field_bin_header3=value
+        else:
+            self.__field_bin_header3=UINT(value,**{ 'default': 0 })
+
+    def __delfield_bin_header3(self): del self.__field_bin_header3
+
+    bin_header3=property(__getfield_bin_header3, __setfield_bin_header3, __delfield_bin_header3, None)
+
+    def iscontainer(self):
+        return True
+
+    def containerelements(self):
+        yield ('unk0', self.__field_unk0, None)
+        yield ('index', self.__field_index, None)
+        yield ('unk1', self.__field_unk1, None)
+        yield ('gtimerecv', self.__field_gtimerecv, None)
+        yield ('timesent', self.__field_timesent, None)
+        yield ('unk2', self.__field_unk2, None)
+        yield ('gtimesent', self.__field_gtimesent, None)
+        yield ('read', self.__field_read, None)
+        yield ('locked', self.__field_locked, None)
+        yield ('priority', self.__field_priority, None)
+        yield ('dunno1', self.__field_dunno1, None)
+        yield ('subject', self.__field_subject, None)
+        yield ('msgs', self.__field_msgs, None)
+        yield ('dunno3', self.__field_dunno3, None)
+        yield ('sender_name', self.__field_sender_name, None)
+        yield ('sender_callback', self.__field_sender_callback, None)
+        yield ('unk3', self.__field_unk3, None)
+        yield ('bin_header1', self.__field_bin_header1, None)
+        yield ('bin_header2', self.__field_bin_header2, None)
+        yield ('multipartID', self.__field_multipartID, None)
+        yield ('bin_header3', self.__field_bin_header3, None)
+
+
+
+
+class _gen_p_lgvx9100_106(BaseProtogenClass):
+    'Anonymous inner class'
+    __fields=['msg_id', 'msg_length', 'msg_data']
+
+    def __init__(self, *args, **kwargs):
+        dict={}
+        # What was supplied to this function
+        dict.update(kwargs)
+        # Parent constructor
+        super(_gen_p_lgvx9100_106,self).__init__(**dict)
+        if self.__class__ is _gen_p_lgvx9100_106:
+            self._update(args,dict)
+
+
+    def getfields(self):
+        return self.__fields
+
+
+    def _update(self, args, kwargs):
+        super(_gen_p_lgvx9100_106,self)._update(args,kwargs)
+        keys=kwargs.keys()
+        for key in keys:
+            if key in self.__fields:
+                setattr(self, key, kwargs[key])
+                del kwargs[key]
+        # Were any unrecognized kwargs passed in?
+        if __debug__:
+            self._complainaboutunusedargs(_gen_p_lgvx9100_106,kwargs)
+        if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
+        # Make all P fields that haven't already been constructed
+
+
+    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
+        'Writes this packet to the supplied buffer'
+        self._bufferstartoffset=buf.getcurrentoffset()
+        self.__field_msg_id.writetobuffer(buf)
+        self.__field_msg_length.writetobuffer(buf)
+        self.__field_msg_data.writetobuffer(buf)
+        self._bufferendoffset=buf.getcurrentoffset()
+        if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
+
+
+    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
+        'Reads this packet from the supplied buffer'
+        self._bufferstartoffset=buf.getcurrentoffset()
+        if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
+        self.__field_msg_id=UINT(**{'sizeinbytes': 1})
+        self.__field_msg_id.readfrombuffer(buf)
+        self.__field_msg_length=UINT(**{'sizeinbytes': 1})
+        self.__field_msg_length.readfrombuffer(buf)
+        self.__field_msg_data=SMSINBOXMSGFRAGMENT()
+        self.__field_msg_data.readfrombuffer(buf)
+        self._bufferendoffset=buf.getcurrentoffset()
+
+
+    def __getfield_msg_id(self):
+        return self.__field_msg_id.getvalue()
+
+    def __setfield_msg_id(self, value):
+        if isinstance(value,UINT):
+            self.__field_msg_id=value
+        else:
+            self.__field_msg_id=UINT(value,**{'sizeinbytes': 1})
+
+    def __delfield_msg_id(self): del self.__field_msg_id
+
+    msg_id=property(__getfield_msg_id, __setfield_msg_id, __delfield_msg_id, None)
+
+    def __getfield_msg_length(self):
+        return self.__field_msg_length.getvalue()
+
+    def __setfield_msg_length(self, value):
+        if isinstance(value,UINT):
+            self.__field_msg_length=value
+        else:
+            self.__field_msg_length=UINT(value,**{'sizeinbytes': 1})
+
+    def __delfield_msg_length(self): del self.__field_msg_length
+
+    msg_length=property(__getfield_msg_length, __setfield_msg_length, __delfield_msg_length, None)
+
+    def __getfield_msg_data(self):
+        return self.__field_msg_data.getvalue()
+
+    def __setfield_msg_data(self, value):
+        if isinstance(value,SMSINBOXMSGFRAGMENT):
+            self.__field_msg_data=value
+        else:
+            self.__field_msg_data=SMSINBOXMSGFRAGMENT(value,)
+
+    def __delfield_msg_data(self): del self.__field_msg_data
+
+    msg_data=property(__getfield_msg_data, __setfield_msg_data, __delfield_msg_data, None)
+
+    def iscontainer(self):
+        return True
+
+    def containerelements(self):
+        yield ('msg_id', self.__field_msg_id, None)
+        yield ('msg_length', self.__field_msg_length, None)
+        yield ('msg_data', self.__field_msg_data, None)
+
+
+
+