Don't just allow "TYPE=<value>".. This makes the vcard import filter more

robust against unexpected typos..

1 files changed, 4 insertions, 2 deletions

diff --git a/library/backend/vobject.cpp b/library/backend/vobject.cpp
index 592d116..28b8bae 100644
--- a/library/backend/vobject.cpp
+++ b/library/backend/vobject.cpp
@@ -1102,263 +1102,265 @@ static void writeEncString(OFile *fp, const char *s, bool nosemi)
             break;
     }
 }
 
 static bool includesUnprintable(VObject *o, bool nosemi)
 {
     if (o) {
         if (VALUE_TYPE(o) == VCVT_STRINGZ) {
             const char *p = STRINGZ_VALUE_OF(o);
             if (p) {
                 while (*p) {
                     if (*p==' ' && (!p[1] || p[1]=='\n') // RFC 1521: spaces at ends need quoting
                             || qpReplaceChar(*p)
                             || *p==';' && nosemi )
                         return TRUE;
                     p++;
                 }
             }
         }
     }
     return FALSE;
 }
             
 static void writeVObject_(OFile *fp, VObject *o);
 
 static void writeValue(OFile *fp, VObject *o, unsigned long size, bool nosemi)
 {
     if (o == 0) return;
     switch (VALUE_TYPE(o)) {
         case VCVT_STRINGZ: {
             writeEncString(fp, STRINGZ_VALUE_OF(o), nosemi);
             break;
             }
         case VCVT_UINT: {
             char buf[16];
             sprintf(buf,"%u", INTEGER_VALUE_OF(o));
             appendsOFile(fp,buf);
             break;
             }
         case VCVT_ULONG: {
             char buf[16];
             sprintf(buf,"%lu", LONG_VALUE_OF(o));
             appendsOFile(fp,buf);
             break;
             }
         case VCVT_RAW: {
             appendcOFile(fp,'\n');
             writeBase64(fp,(unsigned char*)(ANY_VALUE_OF(o)),size);
             break;
             }
         case VCVT_VOBJECT:
             appendcOFile(fp,'\n');
             writeVObject_(fp,VOBJECT_VALUE_OF(o));
             break;
         }
 }
 
 static void writeAttrValue(OFile *fp, VObject *o)
 {
     if (NAME_OF(o)) {
         struct PreDefProp *pi;
         pi = lookupPropInfo(NAME_OF(o));
         if (pi && ((pi->flags & PD_INTERNAL) != 0)) return;
         if ( includesUnprintable(o,TRUE) )
             appendsOFileEncCs(fp);
         appendcOFile(fp,';');
         appendsOFile(fp,NAME_OF(o));
     } else {
         appendcOFile(fp,';');
     }
     if (VALUE_TYPE(o)) {
         appendcOFile(fp,'=');
         writeValue(fp,o,0,TRUE);
     }
 }
 
 static void writeGroup(OFile *fp, VObject *o)
 {
     char buf1[256];
     char buf2[256];
     strcpy(buf1,NAME_OF(o));
     while ((o=isAPropertyOf(o,VCGroupingProp)) != 0) {
         strcpy(buf2,STRINGZ_VALUE_OF(o));
         strcat(buf2,".");
         strcat(buf2,buf1);
         strcpy(buf1,buf2);
         }
     appendsOFile(fp,buf1);
 }
 
 static int inList(const char **list, const char *s)
 {
     if (list == 0) return 0;
     while (*list) {
         if (qstricmp(*list,s) == 0) return 1;
         list++;
         }
     return 0;
 }
 
 static void writeProp(OFile *fp, VObject *o)
 {
     if (NAME_OF(o)) {
         struct PreDefProp *pi;
         VObjectIterator t;
         const char **fields_ = 0;
         pi = lookupPropInfo(NAME_OF(o));
         if (pi && ((pi->flags & PD_BEGIN) != 0)) {
             writeVObject_(fp,o);
             return;
             }
         if (isAPropertyOf(o,VCGroupingProp))
             writeGroup(fp,o);
         else
             appendsOFile(fp,NAME_OF(o));
         if (pi) fields_ = pi->fields;
         initPropIterator(&t,o);
         while (moreIteration(&t)) {
             const char *s;
             VObject *eachProp = nextVObject(&t);
             s = NAME_OF(eachProp);
             if (qstricmp(VCGroupingProp,s) && !inList(fields_,s))
                 writeAttrValue(fp,eachProp);
             }
         if (fields_) {
             int i = 0, n = 0;
             const char** fields = fields_;
             /* output prop as fields */
             bool printable = TRUE;
             while (*fields && printable) {
                 VObject *t = isAPropertyOf(o,*fields);
                 if (includesUnprintable(t,TRUE))
                     printable = FALSE;
                 fields++;
             }
             fields = fields_;
             if (!printable)
                 appendsOFileEncCs(fp);
             appendcOFile(fp,':');
             while (*fields) {
                 VObject *t = isAPropertyOf(o,*fields);
                 i++;
                 if (t) n = i;
                 fields++;
             }
             fields = fields_;
             for (i=0;i<n;i++) {
                 writeValue(fp,isAPropertyOf(o,*fields),0,TRUE);
                 fields++;
                 if (i<(n-1)) appendcOFile(fp,';');
             }
             }
         }
 
         
     if (VALUE_TYPE(o)) {
             if ( includesUnprintable(o,FALSE) )
                         appendsOFileEncCs(fp);
         unsigned long size = 0;
         VObject *p = isAPropertyOf(o,VCDataSizeProp);
         if (p) size = LONG_VALUE_OF(p);
         appendcOFile(fp,':');
         writeValue(fp,o,size,FALSE);
         }
 
     appendcOFile(fp,'\n');
 }
 
 static void writeVObject_(OFile *fp, VObject *o)
 {
     if (NAME_OF(o)) {
         struct PreDefProp *pi;
         pi = lookupPropInfo(NAME_OF(o));
 
         if (pi && ((pi->flags & PD_BEGIN) != 0)) {
             VObjectIterator t;
             const char *begin = NAME_OF(o);
             appendsOFile(fp,"BEGIN:");
             appendsOFile(fp,begin);
             appendcOFile(fp,'\n');
             initPropIterator(&t,o);
             while (moreIteration(&t)) {
                 VObject *eachProp = nextVObject(&t);
                 writeProp(fp, eachProp);
                 }
             appendsOFile(fp,"END:");
             appendsOFile(fp,begin);
             appendsOFile(fp,"\n\n");
             }
         }
 }
 
 static void initVObjectEncoding()
 {
     Config pimConfig( "Beam" );
     pimConfig.setGroup("Send");
     Config devcfg(pimConfig.readEntry("DeviceConfig"),Config::File);
     QString enc = "QP";
     QString cs = "UTF-8";
     if ( devcfg.isValid() ) {
         devcfg.setGroup("Send");
         enc = devcfg.readEntry("Encoding","QP"); 
         cs = devcfg.readEntry("CharSet","UTF-8"); 
     }
     strncpy(vobj_cs,cs.latin1(),10);
     if ( enc == "QP" ) {
         vobj_enc = QuotedPrintable;
         vobj_enc_s = VCQuotedPrintableProp;
     } else if ( enc == "B64" ) {
         vobj_enc = Base64;
         vobj_enc_s = VCBase64Prop;
     } else {
         vobj_enc = EightBit;
         vobj_enc_s = 0;
     }
 }
 
 void writeVObject(FILE *fp, VObject *o)
 {
     initVObjectEncoding();
 
     OFile ofp;
     // #####
     //_setmode(_fileno(fp), _O_BINARY);
     initOFile(&ofp,fp);
     writeVObject_(&ofp,o);
 }
 
 DLLEXPORT(void) writeVObjectToFile(char *fname, VObject *o)
 {
         QFileDirect f( fname);
         if ( !f.open( IO_WriteOnly ) ) {
                 qWarning("Unable to open vobject write %s", fname);
                 return;
         }
 
     writeVObject( f.directHandle(),o );
 }
 
 DLLEXPORT(void) writeVObjectsToFile(char *fname, VObject *list)
 {
         QFileDirect f( fname);
         if ( !f.open( IO_WriteOnly ) ) {
                 qWarning("Unable to open vobject write %s", fname);
                 return;
         }
 
         while (list) {
             writeVObject(f.directHandle(),list);
             list = nextVObjectInList(list);
             }
 }
 
 DLLEXPORT(const char *) vObjectTypeInfo(VObject *o)
 {
     const char *type = vObjectName( o );
-    if ( strcmp( type, "TYPE" ) == 0 )
-        type = vObjectStringZValue( o );
+    if ( strcmp( type, "type" ) == 0 || 
+         strcmp( type, "TYPE" ) == 0 ||
+         strcmp( type, "Type" ) == 0 )
+            type = vObjectStringZValue( o );
     return type;
 }
 
 
 // end of source file vobject.c