Gammu internals  1.38.0
Data Structures | Enumerations | Functions
MMS messages
Messages
Collaboration diagram for MMS messages:

Data Structures

struct  GSM_MMSIndicator
 
struct  GSM_OneMMSFolder
 
struct  GSM_MMSFolders
 
struct  GSM_EncodedMultiPartMMSEntry
 
struct  GSM_EncodedMultiPartMMSInfo
 

Enumerations

enum  MMSAddressType { MMSADDRESS_PHONE, MMSADDRESS_UNKNOWN }
 

Functions

GSM_Error GSM_DecodeMMSFileToMultiPart (GSM_Debug_Info *di, GSM_File *file, GSM_EncodedMultiPartMMSInfo *info)
 
GSM_Error GSM_ClearMMSMultiPart (GSM_EncodedMultiPartMMSInfo *info)
 
GSM_Error GSM_GetMMSFolders (GSM_StateMachine *s, GSM_MMSFolders *folders)
 
GSM_Error GSM_GetNextMMSFileInfo (GSM_StateMachine *s, unsigned char *FileID, int *MMSFolder, gboolean start)
 

Detailed Description

MMS messages manipulations.

Enumeration Type Documentation

§ MMSAddressType

enum MMSAddressType

MMS address type.

Enumerator
MMSADDRESS_PHONE 
MMSADDRESS_UNKNOWN 

Definition at line 1085 of file gammu-message.h.

1085  {
1086  MMSADDRESS_PHONE,
1087  MMSADDRESS_UNKNOWN
1088 } MMSAddressType;
MMSADDRESS_PHONE
Definition: gammu-message.h:1086
MMSAddressType
MMSAddressType
Definition: gammu-message.h:1085
MMSADDRESS_UNKNOWN
Definition: gammu-message.h:1087

Function Documentation

§ GSM_ClearMMSMultiPart()

GSM_Error GSM_ClearMMSMultiPart ( GSM_EncodedMultiPartMMSInfo *  info)

Clears MMS data, used to initialize structure.

Definition at line 416 of file gsmdata.c.

References GSM_File::Buffer, GSM_EncodedMultiPartMMSInfo::DateTimeAvailable, GSM_EncodedMultiPartMMSInfo::Entries, ERR_NONE, FALSE, GSM_EncodedMultiPartMMSEntry::File, and GSM_MAX_MULTI_MMS.

417 {
418  int i;
419 
420  for (i=0;i<GSM_MAX_MULTI_MMS;i++) {
421  if (info->Entries[i].File.Buffer != NULL) {
422  free(info->Entries[i].File.Buffer);
423  info->Entries[i].File.Buffer=NULL;
424  }
425  }
426 
427  memset(info,0,sizeof(GSM_EncodedMultiPartMMSInfo));
428 
429  for (i=0;i<GSM_MAX_MULTI_MMS;i++) {
430  info->Entries[i].File.Buffer = NULL;
431  }
432  info->DateTimeAvailable = FALSE;
433 
434  return ERR_NONE;
435 }
GSM_File::Buffer
unsigned char * Buffer
Definition: gammu-file.h:94
ERR_NONE
Definition: gammu-error.h:27
GSM_EncodedMultiPartMMSInfo::DateTimeAvailable
gboolean DateTimeAvailable
Definition: gammu-message.h:1144
FALSE
#define FALSE
Definition: gammu-types.h:25
GSM_EncodedMultiPartMMSInfo
Definition: gammu-message.h:1112
GSM_EncodedMultiPartMMSEntry::File
GSM_File File
Definition: gammu-message.h:1096
GSM_MAX_MULTI_MMS
#define GSM_MAX_MULTI_MMS
Definition: gammu-limits.h:211
GSM_EncodedMultiPartMMSInfo::Entries
GSM_EncodedMultiPartMMSEntry Entries[GSM_MAX_MULTI_MMS]
Definition: gammu-message.h:1152

§ GSM_DecodeMMSFileToMultiPart()

GSM_Error GSM_DecodeMMSFileToMultiPart ( GSM_Debug_Info *  di,
GSM_File *  file,
GSM_EncodedMultiPartMMSInfo *  info 
)

Decodes MMS data.

Definition at line 469 of file gsmdata.c.

References GSM_File::Buffer, GSM_EncodedMultiPartMMSInfo::CC, GSM_EncodedMultiPartMMSInfo::CCType, GSM_EncodedMultiPartMMSEntry::ContentType, GSM_EncodedMultiPartMMSInfo::ContentType, GSM_EncodedMultiPartMMSInfo::DateTime, GSM_EncodedMultiPartMMSInfo::DateTimeAvailable, GSM_EncodedMultiPartMMSInfo::Destination, GSM_EncodedMultiPartMMSInfo::DestinationType, EncodeUnicode(), GSM_EncodedMultiPartMMSInfo::Entries, GSM_EncodedMultiPartMMSInfo::EntriesNum, ERR_FILENOTSUPPORTED, ERR_NONE, FALSE, GSM_EncodedMultiPartMMSEntry::File, Fill_GSM_DateTime(), GSM_AddWAPMIMEType(), MMSADDRESS_PHONE, MMSADDRESS_UNKNOWN, GSM_EncodedMultiPartMMSInfo::MMSReport, GSM_EncodedMultiPartMMSInfo::MMSReportAvailable, GSM_EncodedMultiPartMMSInfo::MSGType, GSM_File::Name, OSDateTime(), smfprintf(), GSM_EncodedMultiPartMMSEntry::SMIL, GSM_EncodedMultiPartMMSInfo::Source, GSM_EncodedMultiPartMMSInfo::SourceType, GSM_EncodedMultiPartMMSInfo::Subject, TRUE, and GSM_File::Used.

470 {
471  size_t pos = 0;
472  int type=0,parts,j;
473  int i,len2,len3,value2;
474  long value;
475  time_t timet;
476  GSM_DateTime Date;
477  char buff[200],buff2[200];
478 
479  /* header */
480  while(1) {
481  if (pos > file->Used) break;
482  if (!(file->Buffer[pos] & 0x80)) break;
483  switch (file->Buffer[pos++] & 0x7F) {
484  case 0x01:
485  smfprintf(di, " BCC : not done yet\n");
486  return ERR_FILENOTSUPPORTED;
487  case 0x02:
488  smfprintf(di, " CC : ");
489  i = 0;
490  while (file->Buffer[pos]!=0x00) {
491  buff[i++] = file->Buffer[pos++];
492  }
493  buff[i] = 0;
494  pos++;
495  if (strstr(buff,"/TYPE=PLMN")!=NULL) {
496  buff[strlen(buff)-10] = 0;
497  info->CCType = MMSADDRESS_PHONE;
498  smfprintf(di, "phone %s\n",buff);
499  } else {
500  info->CCType = MMSADDRESS_UNKNOWN;
501  smfprintf(di, "%s\n",buff);
502  }
503  EncodeUnicode(info->CC,buff,strlen(buff));
504  break;
505  case 0x03:
506  smfprintf(di, " Content location : not done yet\n");
507  return ERR_FILENOTSUPPORTED;
508  case 0x04:
509  smfprintf(di, " Content type : ");
510  buff[0] = 0;
511  if (file->Buffer[pos] <= 0x1E) {
512  len2 = file->Buffer[pos++];
513  type = file->Buffer[pos++] & 0x7f;
514  GSM_AddWAPMIMEType(type, buff);
515  i=0;
516  while (i<len2) {
517  switch (file->Buffer[pos+i]) {
518  case 0x89:
519  strcat(buff, "; type=");
520  i++;
521  while (file->Buffer[pos+i]!=0x00) {
522  buff[strlen(buff)+1] = 0;
523  buff[strlen(buff)] = file->Buffer[pos+i];
524  i++;
525  }
526  i++;
527  break;
528  case 0x8A:
529  strcat(buff, "; start=");
530  i++;
531  while (file->Buffer[pos+i]!=0x00) {
532  buff[strlen(buff)+1] = 0;
533  buff[strlen(buff)] = file->Buffer[pos+i];
534  i++;
535  }
536  i++;
537  break;
538  default:
539  i++;
540  break;
541  }
542  }
543  pos+=len2-1;
544  } else if (file->Buffer[pos] == 0x1F) {
545  /* hack from coded files */
546  len2 = file->Buffer[pos++];
547  type = file->Buffer[pos++] & 0x7f;
548  type +=2;
549  GSM_AddWAPMIMEType(type, buff);
550  i=0;
551  while (i<len2) {
552  switch (file->Buffer[pos+i]) {
553  case 0x89:
554  strcat(buff, "; type=");
555  i++;
556  while (file->Buffer[pos+i]!=0x00) {
557  buff[strlen(buff)+1] = 0;
558  buff[strlen(buff)] = file->Buffer[pos+i];
559  i++;
560  }
561  i++;
562  break;
563  case 0x8A:
564  strcat(buff, "; start=");
565  i++;
566  while (file->Buffer[pos+i]!=0x00) {
567  buff[strlen(buff)+1] = 0;
568  buff[strlen(buff)] = file->Buffer[pos+i];
569  i++;
570  }
571  i++;
572  break;
573  default:
574  i++;
575  break;
576  }
577  }
578  pos+=len2+2;
579  } else if (file->Buffer[pos] >= 0x20 && file->Buffer[pos] <= 0x7F) {
580  smfprintf(di, "not done yet 2\n");
581  return ERR_FILENOTSUPPORTED;
582  } else if (file->Buffer[pos] >= 0x80 && file->Buffer[pos] < 0xFF) {
583  type = file->Buffer[pos++] & 0x7f;
584  GSM_AddWAPMIMEType(type, buff);
585  }
586  smfprintf(di, "%s\n",buff);
587  EncodeUnicode(info->ContentType,buff,strlen(buff));
588  break;
589  case 0x05:
590  smfprintf(di, " Date : ");
591  value=0;
592  len2 = file->Buffer[pos++];
593  for (i=0;i<len2;i++) {
594  value=value<<8;
595  value |= file->Buffer[pos++];
596  }
597  timet = value;
598  Fill_GSM_DateTime(&Date, timet);
599  smfprintf(di, "%s\n",OSDateTime(Date,0));
600  info->DateTimeAvailable = TRUE;
601  memcpy(&info->DateTime,&Date,sizeof(GSM_DateTime));
602  break;
603  case 0x06:
604  smfprintf(di, " Delivery report : ");
605  info->MMSReportAvailable = TRUE;
606  switch(file->Buffer[pos++]) {
607  case 0x80:
608  smfprintf(di, "yes\n");
609  info->MMSReport = TRUE;
610  break;
611  case 0x81:
612  smfprintf(di, "no\n");
613  info->MMSReport = FALSE;
614  break;
615  default:
616  smfprintf(di, "unknown\n");
617  return ERR_FILENOTSUPPORTED;
618  }
619  break;
620  case 0x08:
621  smfprintf(di, " Expiry : ");
622  pos++; /* length? */
623  switch (file->Buffer[pos]) {
624  case 0x80: smfprintf(di, "date - ignored\n"); break;
625  case 0x81: smfprintf(di, "seconds - ignored\n"); break;
626  default : smfprintf(di, "unknown %02x\n",file->Buffer[pos]); break;
627  }
628  pos++;
629  pos++; /* expiry */
630  pos++; /* expiry */
631  pos++; /* expiry */
632  pos++; /* expiry */
633  break;
634  case 0x09:
635  pos++;
636  pos++;
637  if (file->Buffer[pos-1] == 128) {
638  smfprintf(di, " From : ");
639  len2=file->Buffer[pos-2]-1;
640  for (i=0;i<len2;i++) {
641  buff[i] = file->Buffer[pos++];
642  }
643  buff[i] = 0;
644  if (strstr(buff,"/TYPE=PLMN")!=NULL) {
645  buff[strlen(buff)-10] = 0;
646  info->SourceType = MMSADDRESS_PHONE;
647  smfprintf(di, "phone %s\n",buff);
648  } else {
649  info->SourceType = MMSADDRESS_UNKNOWN;
650  smfprintf(di, "%s\n",buff);
651  }
652  EncodeUnicode(info->Source,buff,strlen(buff));
653  }
654  break;
655  case 0x0A:
656  smfprintf(di, " Message class : ");
657  switch (file->Buffer[pos++]) {
658  case 0x80: smfprintf(di, "personal\n"); break;
659  case 0x81: smfprintf(di, "advertisment\n"); break;
660  case 0x82: smfprintf(di, "informational\n"); break;
661  case 0x83: smfprintf(di, "auto\n"); break;
662  default : smfprintf(di, "unknown\n"); break;
663  }
664  break;
665  case 0x0B:
666  smfprintf(di, " Message ID : ");
667  while (file->Buffer[pos]!=0x00) {
668  smfprintf(di, "%c",file->Buffer[pos]);
669  pos++;
670  }
671  smfprintf(di, "\n");
672  pos++;
673  break;
674  case 0x0C:
675  smfprintf(di, " Message type : ");
676  switch (file->Buffer[pos++]) {
677  case 0x80: sprintf(info->MSGType,"m-send-req"); break;
678  case 0x81: sprintf(info->MSGType,"m-send-conf"); break;
679  case 0x82: sprintf(info->MSGType,"m-notification-ind"); break;
680  case 0x83: sprintf(info->MSGType,"m-notifyresp-ind"); break;
681  case 0x84: sprintf(info->MSGType,"m-retrieve-conf"); break;
682  case 0x85: sprintf(info->MSGType,"m-acknowledge-ind"); break;
683  case 0x86: sprintf(info->MSGType,"m-delivery-ind"); break;
684  default : smfprintf(di, "unknown\n"); return ERR_FILENOTSUPPORTED;
685  }
686  smfprintf(di, "%s\n",info->MSGType);
687  break;
688  case 0x0D:
689  value2 = file->Buffer[pos] & 0x7F;
690  smfprintf(di, " MMS version : %i.%i\n", (value2 & 0x70) >> 4, value2 & 0x0f);
691  pos++;
692  break;
693  case 0x0E:
694  smfprintf(di, " Message size : ignored for now\n");
695  pos += 2;
696  break;
697  case 0x0F:
698  smfprintf(di, " Priority : ");
699  switch (file->Buffer[pos++]) {
700  case 0x80: smfprintf(di, "low\n"); break;
701  case 0x81: smfprintf(di, "normal\n"); break;
702  case 0x82: smfprintf(di, "high\n"); break;
703  default : smfprintf(di, "unknown\n"); break;
704  }
705  break;
706  case 0x10:
707  smfprintf(di, " Read reply : ");
708  switch(file->Buffer[pos++]) {
709  case 0x80: smfprintf(di, "yes\n"); break;
710  case 0x81: smfprintf(di, "no\n"); break;
711  default : smfprintf(di, "unknown\n");
712  }
713  break;
714  case 0x11:
715  smfprintf(di, " Report allowed : not done yet\n");
716  return ERR_FILENOTSUPPORTED;
717  case 0x12:
718  smfprintf(di, " Response status : not done yet\n");
719  return ERR_FILENOTSUPPORTED;
720  case 0x13:
721  smfprintf(di, " Response text : not done yet\n");
722  return ERR_FILENOTSUPPORTED;
723  case 0x14:
724  smfprintf(di, " Sender visibility : not done yet\n");
725  return ERR_FILENOTSUPPORTED;
726  case 0x15:
727  smfprintf(di, " Status : ");
728  switch (file->Buffer[pos++]) {
729  case 0x80: smfprintf(di, "expired\n"); break;
730  case 0x81: smfprintf(di, "retrieved\n"); break;
731  case 0x82: smfprintf(di, "rejected\n"); break;
732  case 0x83: smfprintf(di, "deferred\n"); break;
733  case 0x84: smfprintf(di, "unrecognized\n"); break;
734  default : smfprintf(di, "unknown\n");
735  }
736  pos++;
737  pos++;
738  break;
739  case 0x16:
740  smfprintf(di, " Subject : ");
741  if (file->Buffer[pos+1]==0xEA) {
742  pos+=2;
743  }
744  i = 0;
745  while (file->Buffer[pos]!=0x00) {
746  buff[i++] = file->Buffer[pos++];
747  }
748  buff[i] = 0;
749  smfprintf(di, "%s\n",buff);
750  EncodeUnicode(info->Subject,buff,strlen(buff));
751  pos++;
752  break;
753  case 0x17:
754  smfprintf(di, " To : ");
755  i = 0;
756  while (file->Buffer[pos]!=0x00) {
757  buff[i++] = file->Buffer[pos++];
758  }
759  buff[i] = 0;
760  if (strstr(buff,"/TYPE=PLMN")!=NULL) {
761  buff[strlen(buff)-10] = 0;
762  info->DestinationType = MMSADDRESS_PHONE;
763  smfprintf(di, "phone %s\n",buff);
764  } else {
765  info->DestinationType = MMSADDRESS_UNKNOWN;
766  smfprintf(di, "%s\n",buff);
767  }
768  EncodeUnicode(info->Destination,buff,strlen(buff));
769  pos++;
770  break;
771  case 0x18:
772  smfprintf(di, " Transaction ID : ");
773  while (file->Buffer[pos]!=0x00) {
774  smfprintf(di, "%c",file->Buffer[pos]);
775  pos++;
776  }
777  smfprintf(di, "\n");
778  pos++;
779  break;
780  default:
781  smfprintf(di, " unknown1\n");
782  break;
783  }
784  }
785 
786  /* if we don't have any parts, we exit */
787  if (type != 35 && type != 51) return ERR_NONE;
788 
789  value = 0;
790  while (TRUE) {
791  value = value << 7;
792  value |= file->Buffer[pos] & 0x7F;
793  pos++;
794  if (!(file->Buffer[pos-1] & 0x80)) break;
795  }
796  value2 = value;
797  smfprintf(di, " Parts : %i\n",value2);
798  parts = value;
799 
800  for (j=0;j<parts;j++) {
801  value = 0;
802  while (TRUE) {
803  value = value << 7;
804  value |= file->Buffer[pos] & 0x7F;
805  pos++;
806  if (!(file->Buffer[pos-1] & 0x80)) break;
807  }
808  smfprintf(di, " Header len: %li",value);
809  len2 = value;
810 
811  value = 0;
812  while (TRUE) {
813  value = value << 7;
814  value |= file->Buffer[pos] & 0x7F;
815  pos++;
816  if (!(file->Buffer[pos-1] & 0x80)) break;
817  }
818  smfprintf(di, ", data len: %li\n",value);
819  len3 = value;
820 
821  /* content type */
822  i = 0;
823  buff[0] = 0;
824  smfprintf(di, " Content type : ");
825  if (file->Buffer[pos] >= 0x80) {
826  type = file->Buffer[pos] & 0x7f;
827  GSM_AddWAPMIMEType(type, buff);
828  } else if (file->Buffer[pos+i] == 0x1F) {
829  i++;
830  buff[0] = 0;
831  /* len4 = file->Buffer[pos+i]; */
832  i++;
833  if (!(file->Buffer[pos+i] & 0x80)) {
834  while (file->Buffer[pos+i]!=0x00) {
835  buff[strlen(buff)+1] = 0;
836  buff[strlen(buff)] = file->Buffer[pos+i];
837  i++;
838  }
839  i++;
840  } else {
841  value = file->Buffer[pos+i] & 0x7F;
842  GSM_AddWAPMIMEType(value, buff);
843  i++;
844  }
845  } else if (file->Buffer[pos+i] < 0x1F) {
846  i++;
847  if (file->Buffer[pos+i] & 0x80) {
848  type = file->Buffer[pos+i] & 0x7f;
849  GSM_AddWAPMIMEType(type, buff);
850  i++;
851  } else {
852  while (file->Buffer[pos+i]!=0x00) {
853  buff[strlen(buff)+1] = 0;
854  buff[strlen(buff)] = file->Buffer[pos+i];
855  i++;
856  }
857  i++;
858  }
859  } else {
860  while (file->Buffer[pos+i]!=0x00) {
861  buff[strlen(buff)+1] = 0;
862  buff[strlen(buff)] = file->Buffer[pos+i];
863  i++;
864  }
865  }
866  smfprintf(di, "%s\n",buff);
867  EncodeUnicode(info->Entries[info->EntriesNum].ContentType,buff,strlen(buff));
868 
869  pos+=i;
870  len2-=i;
871 
872  i=0;
873  while (i<len2) {
874  switch (file->Buffer[pos+i]) {
875  case 0x81:
876  i++;
877  break;
878  case 0x83:
879  break;
880  case 0x85:
881  /* mms 1.0 file from GSM operator */
882  buff2[0] = 0;
883  i++;
884  while (file->Buffer[pos+i]!=0x00) {
885  buff2[strlen(buff2)+1] = 0;
886  buff2[strlen(buff2)] = file->Buffer[pos+i];
887  i++;
888  }
889  EncodeUnicode(info->Entries[info->EntriesNum].File.Name,buff2,strlen(buff2));
890  break;
891  case 0x86:
892  while (file->Buffer[pos+i]!=0x00) i++;
893  break;
894  case 0x89:
895  strcpy(buff, "; type=");
896  i++;
897  while (file->Buffer[pos+i]!=0x00) {
898  buff[strlen(buff)+1] = 0;
899  buff[strlen(buff)] = file->Buffer[pos+i];
900  i++;
901  }
902  i++;
903  break;
904  case 0x8A:
905  strcpy(buff, "; type=");
906  i++;
907  while (file->Buffer[pos+i]!=0x00) {
908  buff[strlen(buff)+1] = 0;
909  buff[strlen(buff)] = file->Buffer[pos+i];
910  i++;
911  }
912  i++;
913  break;
914  case 0x8E:
915  i++;
916  buff[0] = 0;
917  smfprintf(di, " Name : ");
918  while (file->Buffer[pos+i]!=0x00) {
919  buff[strlen(buff)+1] = 0;
920  buff[strlen(buff)] = file->Buffer[pos+i];
921  i++;
922  }
923  smfprintf(di, "%s\n",buff);
924  EncodeUnicode(info->Entries[info->EntriesNum].File.Name,buff,strlen(buff));
925  break;
926  case 0xAE:
927  while (file->Buffer[pos+i]!=0x00) i++;
928  break;
929  case 0xC0:
930  i++;
931  i++;
932  buff[0] = 0;
933  smfprintf(di, " SMIL CID : ");
934  while (file->Buffer[pos+i]!=0x00) {
935  buff[strlen(buff)+1] = 0;
936  buff[strlen(buff)] = file->Buffer[pos+i];
937  i++;
938  }
939  smfprintf(di, "%s\n",buff);
940  EncodeUnicode(info->Entries[info->EntriesNum].SMIL,buff,strlen(buff));
941  break;
942  default:
943  smfprintf(di, "unknown3 %02x\n",file->Buffer[pos+i]);
944  }
945  i++;
946  }
947  pos+=i;
948 
949  /* data */
950  info->Entries[info->EntriesNum].File.Buffer = (unsigned char *)realloc(info->Entries[info->EntriesNum].File.Buffer,len3);
951  info->Entries[info->EntriesNum].File.Used = len3;
952  memcpy(info->Entries[info->EntriesNum].File.Buffer,file->Buffer+pos,len3);
953 
954  info->EntriesNum++;
955  pos+=len3;
956  }
957  return ERR_NONE;
958 }
GSM_File::Name
unsigned char Name[2 *(GSM_MAX_FILENAME_LENGTH+1)]
Definition: gammu-file.h:74
GSM_AddWAPMIMEType
void GSM_AddWAPMIMEType(int type, char *buffer)
Definition: gsmdata.c:437
GSM_EncodedMultiPartMMSInfo::MSGType
unsigned char MSGType[50]
Definition: gammu-message.h:1142
GSM_EncodedMultiPartMMSEntry::SMIL
unsigned char SMIL[400]
Definition: gammu-message.h:1104
MMSADDRESS_PHONE
Definition: gammu-message.h:1086
GSM_EncodedMultiPartMMSInfo::CCType
MMSAddressType CCType
Definition: gammu-message.h:1129
GSM_EncodedMultiPartMMSInfo::Source
unsigned char Source[200]
Definition: gammu-message.h:1118
GSM_File::Buffer
unsigned char * Buffer
Definition: gammu-file.h:94
GSM_EncodedMultiPartMMSInfo::ContentType
unsigned char ContentType[400]
Definition: gammu-message.h:1138
GSM_EncodedMultiPartMMSInfo::DestinationType
MMSAddressType DestinationType
Definition: gammu-message.h:1124
GSM_File::Used
size_t Used
Definition: gammu-file.h:70
GSM_EncodedMultiPartMMSInfo::MMSReportAvailable
gboolean MMSReportAvailable
Definition: gammu-message.h:1147
ERR_NONE
Definition: gammu-error.h:27
Fill_GSM_DateTime
void Fill_GSM_DateTime(GSM_DateTime *Date, time_t timet)
Definition: misc.c:170
GSM_EncodedMultiPartMMSInfo::CC
unsigned char CC[200]
Definition: gammu-message.h:1128
GSM_EncodedMultiPartMMSInfo::DateTimeAvailable
gboolean DateTimeAvailable
Definition: gammu-message.h:1144
EncodeUnicode
void EncodeUnicode(unsigned char *dest, const char *src, size_t len)
Definition: coding.c:301
FALSE
#define FALSE
Definition: gammu-types.h:25
GSM_EncodedMultiPartMMSInfo::DateTime
GSM_DateTime DateTime
Definition: gammu-message.h:1145
GSM_EncodedMultiPartMMSEntry::ContentType
unsigned char ContentType[400]
Definition: gammu-message.h:1100
GSM_EncodedMultiPartMMSInfo::MMSReport
gboolean MMSReport
Definition: gammu-message.h:1148
GSM_DateTime
Definition: gammu-datetime.h:28
GSM_EncodedMultiPartMMSInfo::Subject
unsigned char Subject[200]
Definition: gammu-message.h:1134
OSDateTime
char * OSDateTime(GSM_DateTime dt, gboolean TimeZone)
Definition: misc.c:264
GSM_EncodedMultiPartMMSInfo::Destination
unsigned char Destination[200]
Definition: gammu-message.h:1123
GSM_EncodedMultiPartMMSEntry::File
GSM_File File
Definition: gammu-message.h:1096
GSM_EncodedMultiPartMMSInfo::EntriesNum
int EntriesNum
Definition: gammu-message.h:1113
smfprintf
int smfprintf(GSM_Debug_Info *d, const char *format,...)
Definition: debug.c:240
ERR_FILENOTSUPPORTED
Definition: gammu-error.h:173
TRUE
#define TRUE
Definition: gammu-types.h:28
GSM_EncodedMultiPartMMSInfo::SourceType
MMSAddressType SourceType
Definition: gammu-message.h:1119
GSM_EncodedMultiPartMMSInfo::Entries
GSM_EncodedMultiPartMMSEntry Entries[GSM_MAX_MULTI_MMS]
Definition: gammu-message.h:1152
MMSADDRESS_UNKNOWN
Definition: gammu-message.h:1087

§ GSM_GetMMSFolders()

GSM_Error GSM_GetMMSFolders ( GSM_StateMachine *  s,
GSM_MMSFolders *  folders 
)

Lists MMS folders.

Parameters
sState machine pointer.
foldersPointer to structure, whehe folder information will be stored.
Returns
Error code.

Lists MMS folders.

Definition at line 1261 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, GSM_Phone_Functions::GetMMSFolders, _GSM_StateMachine::Phone, and PRINT_LOG_ERROR.

1262 {
1263  GSM_Error err;
1264 
1265  CHECK_PHONE_CONNECTION();
1266 
1267  err = s->Phone.Functions->GetMMSFolders(s, folders);
1268  PRINT_LOG_ERROR(err);
1269  return err;
1270 }
GSM_Error
GSM_Error
Definition: gammu-error.h:23
_GSM_StateMachine::Phone
GSM_Phone Phone
Definition: gsmstate.h:1431
PRINT_LOG_ERROR
#define PRINT_LOG_ERROR(err)
Definition: api.c:28
CHECK_PHONE_CONNECTION
#define CHECK_PHONE_CONNECTION()
Definition: api.c:38
GSM_Phone::Functions
GSM_Phone_Functions * Functions
Definition: gsmstate.h:1373
GSM_Phone_Functions::GetMMSFolders
GSM_Error(* GetMMSFolders)(GSM_StateMachine *s, GSM_MMSFolders *folders)
Definition: gsmstate.h:1123

§ GSM_GetNextMMSFileInfo()

GSM_Error GSM_GetNextMMSFileInfo ( GSM_StateMachine *  s,
unsigned char *  FileID,
int *  MMSFolder,
gboolean  start 
)

Retrieves next part of MMS file information.

Parameters
sState machine pointer.
[in,out]FileIDFile ID will be stored here, might be used for consequent reads.
[in,out]MMSFolderMMS folder ID will be stored here, might be used for consequent reads.
[in]startWhether to start reading.
Returns
Error code.

Retrieves next part of MMS file information.

Definition at line 1274 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, GSM_Phone_Functions::GetNextMMSFileInfo, _GSM_StateMachine::Phone, PRINT_LOG_ERROR, and PRINT_START.

1275 {
1276  GSM_Error err;
1277 
1278  CHECK_PHONE_CONNECTION();
1279  PRINT_START();
1280 
1281  err = s->Phone.Functions->GetNextMMSFileInfo(s, FileID, MMSFolder, start);
1282  PRINT_LOG_ERROR(err);
1283  return err;
1284 }
GSM_Error
GSM_Error
Definition: gammu-error.h:23
PRINT_START
#define PRINT_START()
Definition: api.c:21
_GSM_StateMachine::Phone
GSM_Phone Phone
Definition: gsmstate.h:1431
PRINT_LOG_ERROR
#define PRINT_LOG_ERROR(err)
Definition: api.c:28
CHECK_PHONE_CONNECTION
#define CHECK_PHONE_CONNECTION()
Definition: api.c:38
GSM_Phone::Functions
GSM_Phone_Functions * Functions
Definition: gsmstate.h:1373
GSM_Phone_Functions::GetNextMMSFileInfo
GSM_Error(* GetNextMMSFileInfo)(GSM_StateMachine *s, unsigned char *FileID, int *MMSFolder, gboolean start)
Definition: gsmstate.h:1127