Fix bug #3524 ‘vCard does not decode all quoted-printable values’
[claws.git] / src / vcard.c
1 /*
2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2001-2015 Match Grun and the Claws Mail team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 /*
20  * Functions necessary to access vCard files. vCard files are used
21  * by GnomeCard for addressbook, and Netscape for sending business
22  * card information. Refer to http://www.imc.org/pdi/vcard-21.txt and
23  * RFC2426 for more information.
24  */
25
26 #include <glib.h>
27 #include <sys/stat.h>
28 #include <string.h>
29
30 #include "mgutils.h"
31 #include "vcard.h"
32 #include "addritem.h"
33 #include "addrcache.h"
34 #include "adbookbase.h"
35 #include "utils.h"
36 #include "codeconv.h"
37 #include "quoted-printable.h"
38
39 #define GNOMECARD_DIR     ".gnome"
40 #define GNOMECARD_FILE    "GnomeCard"
41 #define GNOMECARD_SECTION "[file]"
42 #define GNOMECARD_PARAM   "open"
43
44 #define VCARD_TEST_LINES  200
45
46 /*
47 * Create new cardfile object.
48 */
49 VCardFile *vcard_create() {
50         VCardFile *cardFile;
51         cardFile = g_new0( VCardFile, 1 );
52         cardFile->type = ADBOOKTYPE_VCARD;
53         cardFile->addressCache = addrcache_create();
54         cardFile->retVal = MGU_SUCCESS;
55
56         cardFile->file = NULL;
57         cardFile->path = NULL;
58         cardFile->bufptr = cardFile->buffer;
59         return cardFile;
60 }
61
62 /*
63 * Properties...
64 */
65 void vcard_set_name( VCardFile* cardFile, const gchar *value ) {
66         cm_return_if_fail( cardFile != NULL );
67         addrcache_set_name( cardFile->addressCache, value );
68 }
69 void vcard_set_file( VCardFile* cardFile, const gchar *value ) {
70         cm_return_if_fail( cardFile != NULL );
71         addrcache_refresh( cardFile->addressCache );
72         cardFile->path = mgu_replace_string( cardFile->path, value );
73         g_strstrip( cardFile->path );
74 }
75 void vcard_set_accessed( VCardFile *cardFile, const gboolean value ) {
76         cm_return_if_fail( cardFile != NULL );
77         cardFile->addressCache->accessFlag = value;
78 }
79
80 /*
81 * Test whether file was modified since last access.
82 * Return: TRUE if file was modified.
83 */
84 gboolean vcard_get_modified( VCardFile *cardFile ) {
85         cm_return_val_if_fail( cardFile != NULL, FALSE );
86         cardFile->addressCache->modified =
87                 addrcache_check_file( cardFile->addressCache, cardFile->path );
88         return cardFile->addressCache->modified;
89 }
90 gboolean vcard_get_accessed( VCardFile *cardFile ) {
91         cm_return_val_if_fail( cardFile != NULL, FALSE );
92         return cardFile->addressCache->accessFlag;
93 }
94
95 /*
96 * Test whether file was read.
97 * Return: TRUE if file was read.
98 */
99 gboolean vcard_get_read_flag( VCardFile *cardFile ) {
100         cm_return_val_if_fail( cardFile != NULL, FALSE );
101         return cardFile->addressCache->dataRead;
102 }
103
104 /*
105 * Return status code from last file operation.
106 * Return: Status code.
107 */
108 gint vcard_get_status( VCardFile *cardFile ) {
109         cm_return_val_if_fail( cardFile != NULL, -1 );
110         return cardFile->retVal;
111 }
112
113 ItemFolder *vcard_get_root_folder( VCardFile *cardFile ) {
114         cm_return_val_if_fail( cardFile != NULL, NULL );
115         return addrcache_get_root_folder( cardFile->addressCache );
116 }
117 gchar *vcard_get_name( VCardFile *cardFile ) {
118         cm_return_val_if_fail( cardFile != NULL, NULL );
119         return addrcache_get_name( cardFile->addressCache );
120 }
121
122 /*
123 * Create new cardfile object for specified file.
124 */
125 static VCardFile *vcard_create_path( const gchar *path ) {
126         VCardFile *cardFile;
127         cardFile = vcard_create();
128         vcard_set_file(cardFile, path);
129         return cardFile;
130 }
131
132 /*
133 * Free up cardfile object by releasing internal memory.
134 */
135 void vcard_free( VCardFile *cardFile ) {
136         cm_return_if_fail( cardFile != NULL );
137
138         /* Close file */
139         if( cardFile->file ) fclose( cardFile->file );
140
141         /* Clear cache */
142         addrcache_clear( cardFile->addressCache );
143         addrcache_free( cardFile->addressCache );
144
145         /* Free internal stuff */
146         g_free( cardFile->path );
147
148         /* Clear pointers */
149         cardFile->file = NULL;
150         cardFile->path = NULL;
151         cardFile->bufptr = NULL;
152
153         cardFile->type = ADBOOKTYPE_NONE;
154         cardFile->addressCache = NULL;
155         cardFile->retVal = MGU_SUCCESS;
156
157         /* Now release file object */
158         g_free( cardFile );
159 }
160
161 /*
162 * Open file for read.
163 * return: TRUE if file opened successfully.
164 */
165 static gint vcard_open_file( VCardFile* cardFile ) {
166         cm_return_val_if_fail( cardFile != NULL, -1 );
167
168         /* g_print( "Opening file\n" ); */
169         cardFile->addressCache->dataRead = FALSE;
170         if( cardFile->path ) {
171                 cardFile->file = g_fopen( cardFile->path, "rb" );
172                 if( ! cardFile->file ) {
173                         /* g_printerr( "can't open %s\n", cardFile->path ); */
174                         cardFile->retVal = MGU_OPEN_FILE;
175                         return cardFile->retVal;
176                 }
177         }
178         else {
179                 /* g_printerr( "file not specified\n" ); */
180                 cardFile->retVal = MGU_NO_FILE;
181                 return cardFile->retVal;
182         }
183
184         /* Setup a buffer area */
185         cardFile->buffer[0] = '\0';
186         cardFile->bufptr = cardFile->buffer;
187         cardFile->retVal = MGU_SUCCESS;
188         return cardFile->retVal;
189 }
190
191 /*
192 * Close file.
193 */
194 static void vcard_close_file( VCardFile *cardFile ) {
195         cm_return_if_fail( cardFile != NULL );
196         if( cardFile->file ) fclose( cardFile->file );
197         cardFile->file = NULL;
198 }
199
200 /*
201 * Read line of text from file.
202 * Return: ptr to buffer where line starts.
203 */
204 static gchar *vcard_read_line( VCardFile *cardFile ) {
205         while( *cardFile->bufptr == '\n' || *cardFile->bufptr == '\0' ) {
206                 if( fgets( cardFile->buffer, VCARDBUFSIZE, cardFile->file ) == NULL )
207                         return NULL;
208                 g_strstrip( cardFile->buffer );
209                 cardFile->bufptr = cardFile->buffer;
210         }
211         return cardFile->bufptr;
212 }
213
214 /*
215 * Read line of text from file.
216 * Return: ptr to buffer where line starts.
217 */
218 static gchar *vcard_get_line( VCardFile *cardFile ) {
219         gchar buf[ VCARDBUFSIZE ];
220         gchar *start, *end;
221         gint len;
222
223         if (vcard_read_line( cardFile ) == NULL ) {
224                 buf[0] = '\0';
225                 return NULL;
226         }
227
228         /* Copy into private buffer */
229         start = cardFile->bufptr;
230         len = strlen( start );
231         end = start + len;
232         strncpy( buf, start, len );
233         buf[ len ] = '\0';
234         g_strstrip(buf);
235         cardFile->bufptr = end + 1;
236
237         /* Return a copy of buffer */   
238         return g_strdup( buf );
239 }
240
241 /*
242 * Free linked lists of character strings.
243 */
244 static void vcard_free_lists( GSList *listName, GSList *listAddr, GSList *listRem, GSList* listID ) {
245         mgu_free_list( listName );
246         mgu_free_list( listAddr );
247         mgu_free_list( listRem );
248         mgu_free_list( listID );
249 }
250
251 /*
252 * Read quoted-printable text, which may span several lines into one long string.
253 * Param: cardFile - object.
254 * Param: tagvalue - will be placed into the linked list.
255 */
256 static gchar *vcard_read_qp( VCardFile *cardFile, char *tagvalue ) {
257         GSList *listQP = NULL;
258         gint len = 0;
259         gchar *line = tagvalue;
260         while( line ) {
261                 listQP = g_slist_append( listQP, line );
262                 len = strlen( line ) - 1;
263                 if( line[ len ] != '=' ) break;
264                 line[ len ] = '\0';
265                 line = vcard_get_line( cardFile );
266         }
267
268         /* Coalesce linked list into one long buffer. */
269         line = mgu_list_coalesce( listQP );
270
271         /* Clean up */
272         mgu_free_list( listQP );
273         listQP = NULL;
274         return line;
275 }
276
277 /*
278 * Parse tag name from line buffer.
279 * Return: Buffer containing the tag name, or NULL if no delimiter char found.
280 */
281 static gchar *vcard_get_tagname( char* line, gchar dlm ) {
282         gint len = 0;
283         gchar *tag = NULL;
284         gchar *lptr = line;
285         gchar *down;
286         while( *lptr++ ) {
287                 if( *lptr == dlm ) {
288                         len = lptr - line;
289                         tag = g_strndup( line, len+1 );
290                         tag[ len ] = '\0';
291                         down = g_utf8_strdown( tag, -1 );
292                         g_free(tag);
293                         return down;
294                 }
295         }
296         return tag;
297 }
298
299 /*
300 * Parse tag value from line buffer.
301 * Return: Buffer containing the tag value. Empty string is returned if
302 * no delimiter char found.
303 */
304 static gchar *vcard_get_tagvalue( gchar* line, gchar dlm ) {
305         gchar *value = NULL;
306         gchar *start = NULL;
307         gchar *lptr;
308         gint len = 0;
309
310         for( lptr = line; *lptr; lptr++ ) {
311                 if( *lptr == dlm ) {
312                         if( ! start )
313                                 start = lptr + 1;
314                 }
315         }
316         if( start ) {
317                 len = lptr - start;
318                 value = g_strndup( start, len+1 );
319         }
320         else {
321                 /* Ensure that we get an empty string */
322                 value = g_strndup( "", 1 );
323         }
324         value[ len ] = '\0';
325         return value;
326 }
327
328 /*
329 * Build an address list entry and append to list of address items.
330 */
331 static void vcard_build_items(
332         VCardFile *cardFile, GSList *listName, GSList *listAddr,
333         GSList *listRem, GSList *listID )
334 {
335         GSList *nodeName = listName;
336         GSList *nodeID = listID;
337         gchar *str;
338         while( nodeName ) {
339                 GSList *nodeAddress = listAddr;
340                 GSList *nodeRemarks = listRem;
341                 ItemPerson *person = addritem_create_item_person();
342                 addritem_person_set_common_name( person, nodeName->data );
343                 while( nodeAddress ) {
344                         str = nodeAddress->data;
345                         if( *str != '\0' ) {
346                                 ItemEMail *email = addritem_create_item_email();
347                                 addritem_email_set_address( email, str );
348                                 if( nodeRemarks ) {
349                                         str = nodeRemarks->data;
350                                         if( str ) {
351                                                 if( g_utf8_collate( str, "internet" ) != 0 ) {
352                                                         if( *str != '\0' )
353                                                                 addritem_email_set_remarks( email, str );
354                                                 }
355                                         }
356                                 }
357                                 addrcache_id_email( cardFile->addressCache, email );
358                                 addrcache_person_add_email( cardFile->addressCache, person, email );
359                         }
360                         nodeAddress = g_slist_next( nodeAddress );
361                         nodeRemarks = g_slist_next( nodeRemarks );
362                 }
363                 if( person->listEMail ) {
364                         addrcache_id_person( cardFile->addressCache, person );
365                         addrcache_add_person( cardFile->addressCache, person );
366                         if( nodeID ) {
367                                 str = nodeID->data;
368                                 addritem_person_set_external_id( person, str );
369                         }
370                 }
371                 else {
372                         addritem_free_item_person( person );
373                 }
374                 nodeName = g_slist_next( nodeName );
375                 nodeID = g_slist_next( nodeID );
376         }
377 }
378
379 /* Unescape characters in quoted-printable string. */
380 static gchar *vcard_unescape_qp( gchar *value ) {
381         gchar *res = NULL;
382         gint len;
383         if (value == NULL)
384                 return NULL;
385                 
386         len = strlen(value);
387         res = g_malloc(len);
388         qp_decode_const(res, len-1, value);
389         if (!g_utf8_validate(res, -1, NULL)) {
390                 gchar *mybuf = g_malloc(strlen(res)*2 +1);
391                 conv_localetodisp(mybuf, strlen(res)*2 +1, res);
392                 g_free(res);
393                 res = mybuf;
394         }
395         return res;
396 }
397
398  /*
399 * Read file data into root folder.
400 * Note that one vCard can have multiple E-Mail addresses (MAIL tags);
401 * these are broken out into separate address items. An address item
402 * is generated for the person identified by FN tag and each EMAIL tag.
403 * If a sub-type is included in the EMAIL entry, this will be used as
404 * the Remarks member. Also note that it is possible for one vCard
405 * entry to have multiple FN tags; this might not make sense. However,
406 * it will generate duplicate address entries for each person listed.
407 */
408 static void vcard_read_file( VCardFile *cardFile ) {
409         gchar *tagtemp = NULL, *tagname = NULL, *tagvalue = NULL, *tagtype = NULL;
410         GSList *listName = NULL, *listAddress = NULL, *listRemarks = NULL, *listID = NULL;
411         /* GSList *listQP = NULL; */
412
413         for( ;; ) {
414                 gchar *line =  vcard_get_line( cardFile );
415                 if( line == NULL ) break;
416
417                 /* g_print( "%s\n", line ); */
418
419                 /* Parse line */
420                 tagtemp = vcard_get_tagname( line, VCARD_SEP_TAG );
421                 if( tagtemp == NULL ) {
422                         g_free( line );
423                         continue;
424                 }
425
426                 /* g_print( "\ttemp:  %s\n", tagtemp ); */
427                 tagvalue = vcard_get_tagvalue( line, VCARD_SEP_TAG );
428                 if( tagvalue == NULL ) {
429                         g_free( tagtemp );
430                         g_free( line );
431                         continue;
432                 }
433
434                 tagname = vcard_get_tagname( tagtemp, VCARD_SEP_TYPE );
435                 tagtype = vcard_get_tagvalue( tagtemp, VCARD_SEP_TYPE );
436                 if( tagname == NULL ) {
437                         tagname = tagtemp;
438                         tagtemp = NULL;
439                 }
440
441                 /* g_print( "\tname:  %s\n", tagname ); */
442                 /* g_print( "\ttype:  %s\n", tagtype ); */
443                 /* g_print( "\tvalue: %s\n", tagvalue ); */
444
445                 if( g_utf8_collate( tagtype, VCARD_TYPE_QP ) == 0
446                     || g_utf8_collate( tagtype, VCARD_TYPE_E_QP ) == 0
447                     || g_utf8_collate( tagtype, VCARD_TYPE_CS_UTF8_E_QP ) == 0) {
448                         gchar *tmp;
449                         /* Quoted-Printable: could span multiple lines */
450                         tagvalue = vcard_read_qp( cardFile, tagvalue );
451                         tmp = vcard_unescape_qp( tagvalue );
452                         g_free(tagvalue);
453                         tagvalue=tmp;
454                         /* g_print( "QUOTED-PRINTABLE !!! final\n>%s<\n", tagvalue ); */
455                 }
456
457                 if( g_utf8_collate( tagname, VCARD_TAG_START ) == 0 &&
458                         g_ascii_strcasecmp( tagvalue, VCARD_NAME ) == 0 ) {
459                         /* g_print( "start card\n" ); */
460                         vcard_free_lists( listName, listAddress, listRemarks, listID );
461                         listName = listAddress = listRemarks = listID = NULL;
462                 }
463                 if( g_utf8_collate( tagname, VCARD_TAG_FULLNAME ) == 0 ) {
464                         /* g_print( "- full name: %s\n", tagvalue ); */
465                         listName = g_slist_append( listName, g_strdup( tagvalue ) );
466                 }
467                 if( g_utf8_collate( tagname, VCARD_TAG_EMAIL ) == 0 ) {
468                         /* g_print( "- address: %s\n", tagvalue ); */
469                         listAddress = g_slist_append( listAddress, g_strdup( tagvalue ) );
470                         listRemarks = g_slist_append( listRemarks, g_strdup( tagtype ) );
471                 }
472                 if( g_utf8_collate( tagname, VCARD_TAG_UID ) == 0 ) {
473                         /* g_print( "- id: %s\n", tagvalue ); */
474                         listID = g_slist_append( listID, g_strdup( tagvalue ) );
475                 }
476                 if( g_utf8_collate( tagname, VCARD_TAG_END ) == 0 &&
477                         g_ascii_strcasecmp( tagvalue, VCARD_NAME ) == 0 ) {
478                         /* vCard is complete */
479                         /* g_print( "end card\n--\n" ); */
480                         /* vcard_dump_lists( listName, listAddress, listRemarks, listID, stdout ); */
481                         vcard_build_items( cardFile, listName, listAddress, listRemarks, listID );
482                         vcard_free_lists( listName, listAddress, listRemarks, listID );
483                         listName = listAddress = listRemarks = listID = NULL;
484                 }
485
486                 g_free( tagname );
487                 g_free( tagtype );
488                 g_free( tagvalue );
489                 g_free( tagtemp );
490                 g_free( line );
491                 line = NULL;
492         }
493
494         /* Free lists */
495         vcard_free_lists( listName, listAddress, listRemarks, listID );
496         listName = listAddress = listRemarks = listID = NULL;
497 }
498
499 /* ============================================================================================ */
500 /*
501 * Read file into list. Main entry point
502 * Return: TRUE if file read successfully.
503 */
504 /* ============================================================================================ */
505 gint vcard_read_data( VCardFile *cardFile ) {
506         cm_return_val_if_fail( cardFile != NULL, -1 );
507
508         cardFile->retVal = MGU_SUCCESS;
509         cardFile->addressCache->accessFlag = FALSE;
510         if( addrcache_check_file( cardFile->addressCache, cardFile->path ) ) {
511                 addrcache_clear( cardFile->addressCache );
512                 vcard_open_file( cardFile );
513                 if( cardFile->retVal == MGU_SUCCESS ) {
514                         /* Read data into the list */
515                         vcard_read_file( cardFile );
516                         vcard_close_file( cardFile );
517
518                         /* Mark cache */
519                         addrcache_mark_file( cardFile->addressCache, cardFile->path );
520                         cardFile->addressCache->modified = FALSE;
521                         cardFile->addressCache->dataRead = TRUE;
522                 }
523         }
524         return cardFile->retVal;
525 }
526
527 /*
528 * Return link list of persons.
529 */
530 GList *vcard_get_list_person( VCardFile *cardFile ) {
531         cm_return_val_if_fail( cardFile != NULL, NULL );
532         return addrcache_get_list_person( cardFile->addressCache );
533 }
534
535 /*
536 * Return link list of folders. This is always NULL since there are
537 * no folders in GnomeCard.
538 * Return: NULL.
539 */
540 GList *vcard_get_list_folder( VCardFile *cardFile ) {
541         cm_return_val_if_fail( cardFile != NULL, NULL );
542         return NULL;
543 }
544
545 /*
546 * Return link list of all persons. Note that the list contains references
547 * to items. Do *NOT* attempt to use the addrbook_free_xxx() functions...
548 * this will destroy the addressbook data!
549 * Return: List of items, or NULL if none.
550 */
551 GList *vcard_get_all_persons( VCardFile *cardFile ) {
552         cm_return_val_if_fail( cardFile != NULL, NULL );
553         return addrcache_get_all_persons( cardFile->addressCache );
554 }
555
556 #define WORK_BUFLEN 1024
557
558 /*
559 * Attempt to find a valid GnomeCard file.
560 * Return: Filename, or home directory if not found. Filename should
561 *       be g_free() when done.
562 */
563 gchar *vcard_find_gnomecard( void ) {
564         const gchar *homedir;
565         gchar buf[ WORK_BUFLEN ];
566         gchar str[ WORK_BUFLEN + 1 ];
567         gchar *fileSpec;
568         gint len, lenlbl, i;
569         FILE *fp;
570
571         homedir = get_home_dir();
572         if( ! homedir ) return NULL;
573
574         strncpy( str, homedir, WORK_BUFLEN );
575         len = strlen( str );
576         if( len > 0 ) {
577                 if( str[ len-1 ] != G_DIR_SEPARATOR ) {
578                         str[ len ] = G_DIR_SEPARATOR;
579                         str[ ++len ] = '\0';
580                 }
581         }
582         strncat( str, GNOMECARD_DIR, WORK_BUFLEN - strlen(str) );
583         strncat( str, G_DIR_SEPARATOR_S, WORK_BUFLEN - strlen(str) );
584         strncat( str, GNOMECARD_FILE, WORK_BUFLEN - strlen(str) );
585
586         fileSpec = NULL;
587         if( ( fp = g_fopen( str, "rb" ) ) != NULL ) {
588                 /* Read configuration file */
589                 lenlbl = strlen( GNOMECARD_SECTION );
590                 while( fgets( buf, sizeof( buf ), fp ) != NULL ) {
591                         if( 0 == g_ascii_strncasecmp( buf, GNOMECARD_SECTION, lenlbl ) ) {
592                                 break;
593                         }
594                 }
595
596                 while( fgets( buf, sizeof( buf ), fp ) != NULL ) {
597                         g_strchomp( buf );
598                         if( buf[0] == '[' ) break;
599                         for( i = 0; i < lenlbl; i++ ) {
600                                 if( buf[i] == '=' ) {
601                                         if( 0 == g_ascii_strncasecmp( buf, GNOMECARD_PARAM, i ) ) {
602                                                 fileSpec = g_strdup( buf + i + 1 );
603                                                 g_strstrip( fileSpec );
604                                         }
605                                 }
606                         }
607                 }
608                 fclose( fp );
609         }
610
611         if( fileSpec == NULL ) {
612                 /* Use the home directory */
613                 str[ len ] = '\0';
614                 fileSpec = g_strdup( str );
615         }
616
617         return fileSpec;
618 }
619
620 /*
621 * Attempt to read file, testing for valid vCard format.
622 * Return: TRUE if file appears to be valid format.
623 */
624 gint vcard_test_read_file( const gchar *fileSpec ) {
625         gboolean haveStart;
626         gchar *tagtemp = NULL, *tagname = NULL, *tagvalue = NULL, *tagtype = NULL, *line;
627         VCardFile *cardFile;
628         gint retVal, lines;
629
630         if( ! fileSpec ) return MGU_NO_FILE;
631
632         cardFile = vcard_create_path( fileSpec );
633         cardFile->retVal = MGU_SUCCESS;
634         vcard_open_file( cardFile );
635         if( cardFile->retVal == MGU_SUCCESS ) {
636                 cardFile->retVal = MGU_BAD_FORMAT;
637                 haveStart = FALSE;
638                 lines = VCARD_TEST_LINES;
639                 while( lines > 0 ) {
640                         lines--;
641                         if( ( line =  vcard_get_line( cardFile ) ) == NULL ) break;
642
643                         /* Parse line */
644                         tagtemp = vcard_get_tagname( line, VCARD_SEP_TAG );
645                         if( tagtemp == NULL ) {
646                                 g_free( line );
647                                 continue;
648                         }
649
650                         tagvalue = vcard_get_tagvalue( line, VCARD_SEP_TAG );
651                         if( tagvalue == NULL ) {
652                                 g_free( tagtemp );
653                                 g_free( line );
654                                 continue;
655                         }
656
657                         tagname = vcard_get_tagname( tagtemp, VCARD_SEP_TYPE );
658                         tagtype = vcard_get_tagvalue( tagtemp, VCARD_SEP_TYPE );
659                         if( tagname == NULL ) {
660                                 tagname = tagtemp;
661                                 tagtemp = NULL;
662                         }
663
664                         if( g_utf8_collate( tagtype, VCARD_TYPE_QP ) == 0 ) {
665                                 gchar *tmp;
666                                 /* Quoted-Printable: could span multiple lines */
667                                 tagvalue = vcard_read_qp( cardFile, tagvalue );
668                                 tmp = vcard_unescape_qp( tagvalue );
669                                 g_free(tagvalue);
670                                 tagvalue=tmp;
671                         }
672                         if( g_utf8_collate( tagname, VCARD_TAG_START ) == 0 &&
673                                 g_ascii_strcasecmp( tagvalue, VCARD_NAME ) == 0 ) {
674                                 haveStart = TRUE;
675                         }
676                         if( g_utf8_collate( tagname, VCARD_TAG_END ) == 0 &&
677                                 g_ascii_strcasecmp( tagvalue, VCARD_NAME ) == 0 ) {
678                                 /* vCard is complete */
679                                 if( haveStart ) cardFile->retVal = MGU_SUCCESS;
680                         }
681
682                         g_free( tagname );
683                         g_free( tagtype );
684                         g_free( tagvalue );
685                         g_free( tagtemp );
686                         g_free( line );
687                 }
688                 vcard_close_file( cardFile );
689         }
690         retVal = cardFile->retVal;
691         vcard_free( cardFile );
692         cardFile = NULL;
693         return retVal;
694 }
695
696 /*
697 * End of Source.
698 */
699