Fixes for base64 decoding and encoding of vCard

1 files changed, 16 insertions, 17 deletions

diff --git a/library/backend/vcc_yacc.cpp b/library/backend/vcc_yacc.cpp
index 5f53aef..4006bc2 100644
--- a/library/backend/vcc_yacc.cpp
+++ b/library/backend/vcc_yacc.cpp
@@ -440,49 +440,49 @@ static void enterValues(const char *value)
     {

     if (fieldedProp && *fieldedProp) {

 	if (value) {

 	    addPropValue(curProp,*fieldedProp,value);

 	    }

 	/* else this field is empty, advance to next field */

 	fieldedProp++;

 	}

     else {

 	if (value) {

 	    setVObjectStringZValue_(curProp,strdup( value ));

 	    }

 	}

     deleteStr(value);

     }

 

 static void enterProps(const char *s)

     {

     curProp = addGroup(curObj,s);

     deleteStr(s);

     }

 

 static void enterAttr(const char *s1, const char *s2)

     {

-    const char *p1, *p2;

+    const char *p1, *p2=0;

     p1 = lookupProp_(s1);

     if (s2) {

 	VObject *a;

 	p2 = lookupProp_(s2);

 	a = addProp(curProp,p1);

 	setVObjectStringZValue(a,p2);

 	}

     else

 	addProp(curProp,p1);

     if (qstricmp(p1,VCBase64Prop) == 0 || (s2 && qstricmp(p2,VCBase64Prop)==0))

 	lexPushMode(L_BASE64);

     else if (qstricmp(p1,VCQuotedPrintableProp) == 0

 	    || (s2 && qstricmp(p2,VCQuotedPrintableProp)==0))

 	lexPushMode(L_QUOTED_PRINTABLE);

     deleteStr(s1); deleteStr(s2);

     }

 

 

 #define MAX_LEX_LOOKAHEAD_0 32

 #define MAX_LEX_LOOKAHEAD 64

 #define MAX_LEX_MODE_STACK_SIZE 10

 #define LEXMODE() (lexBuf.lexModeStack[lexBuf.lexModeStackTop])

 

 struct LexBuf {

@@ -812,178 +812,180 @@ void initLex(const char *inputstring, unsigned long inputlen, FILE *inputfile)
     // iniatialize lex buffer.

     lexBuf.inputString = (char*) inputstring;

     lexBuf.inputLen = inputlen;

     lexBuf.curPos = 0;

     lexBuf.inputFile = inputfile;

 

     lexBuf.len = 0;

     lexBuf.getPtr = 0;

 

     lexBuf.maxToken = MAXTOKEN;

     lexBuf.strs = (char*)malloc(MAXTOKEN);

     lexBuf.strsLen = 0;

 

     }

 

 static void finiLex() {

     free(lexBuf.strs);

     }

 

 

 /*-----------------------------------*/

 /* This parses and converts the base64 format for binary encoding into

  * a decoded buffer (allocated with new).  See RFC 1521.

  */

-static char * lexGetDataFromBase64()

+static int lexGetDataFromBase64()

     {

     unsigned long bytesLen = 0, bytesMax = 0;

     int quadIx = 0, pad = 0;

     unsigned long trip = 0;

     unsigned char b;

     int c;

     unsigned char *bytes = NULL;

     unsigned char *oldBytes = NULL;

 

     DBG_(("db: lexGetDataFromBase64\n"));

     while (1) {

 	c = lexGetc();

+	lexSkipWhite();

 	if (c == '\n') {

 	    ++mime_lineNum;

 	    if (lexLookahead() == '\n') {

 		/* a '\n' character by itself means end of data */

 		break;

 		}

 	    else continue; /* ignore '\n' */

 	    }

 	else {

 	    if ((c >= 'A') && (c <= 'Z'))

 		b = (unsigned char)(c - 'A');

 	    else if ((c >= 'a') && (c <= 'z'))

 		b = (unsigned char)(c - 'a') + 26;

 	    else if ((c >= '0') && (c <= '9'))

 		b = (unsigned char)(c - '0') + 52;

 	    else if (c == '+')

 		b = 62;

 	    else if (c == '/')

 		b = 63;

 	    else if (c == '=') {

 		b = 0;

 		pad++;

-	    } else if ((c == ' ') || (c == '\t')) {

-		continue;

 	    } else { /* error condition */

 		if (bytes) free(bytes);

 		else if (oldBytes) free(oldBytes);

 		// error recovery: skip until 2 adjacent newlines.

 		DBG_(("db: invalid character 0x%x '%c'\n", c,c));

 		if (c != EOF)  {

 		    c = lexGetc();

 		    while (c != EOF) {

-			if (c == '\n' && lexLookahead() == '\n') {

-			    ++mime_lineNum;

-			    break;

+			if (c == '\n') {

+			    lexSkipWhite();

+			    if(lexLookahead() == '\n') {

+				++mime_lineNum;

+				break;

+				}

 			    }

 			c = lexGetc();

 			}

 		    }

-		return NULL;

+		return c != EOF;

 		}

 	    trip = (trip << 6) | b;

 	    if (++quadIx == 4) {

 		unsigned char outBytes[3];

 		int numOut;

 		int i;

 		for (i = 0; i < 3; i++) {

 		    outBytes[2-i] = (unsigned char)(trip & 0xFF);

 		    trip >>= 8;

 		    }

 		numOut = 3 - pad;

 		if (bytesLen + numOut > bytesMax) {

 		    if (!bytes) {

 			bytesMax = 1024;

 			bytes = (unsigned char*)malloc((size_t)bytesMax);

 			}

 		    else {

 			bytesMax <<= 2;

 			oldBytes = bytes;

 			bytes = (unsigned char*)realloc(bytes,(size_t)bytesMax);

 			}

 		    if (bytes == 0) {

 			mime_error("out of memory while processing BASE64 data\n");

 			}

 		    }

 		if (bytes) {

 		    memcpy(bytes + bytesLen, outBytes, numOut);

 		    bytesLen += numOut;

 		    }

 		trip = 0;

 		quadIx = 0;

 		}

 	    }

 	} /* while */

     DBG_(("db: bytesLen = %d\n",  bytesLen));

     /* kludge: all this won't be necessary if we have tree form

 	representation */

     if (bytes) {

 	setValueWithSize(curProp,bytes,(unsigned int)bytesLen);

 	free(bytes);

 	}

     else if (oldBytes) {

 	setValueWithSize(curProp,oldBytes,(unsigned int)bytesLen);

 	free(oldBytes);

 	}

-    return 0;

+    return bytesLen;

     }

 

 static int match_begin_end_name(int end) {

     int token;

     lexSkipWhite();

     if (lexLookahead() != ':') return ID;

     lexSkipLookahead();

     lexSkipWhite();

     token = match_begin_name(end);

     if (token == ID) {

 	lexPushLookaheadc(':');

 	DBG_(("db: ID '%s'\n", yylval.str));

 	return ID;

 	}

     else if (token != 0) {

 	lexSkipLookaheadWord();

 	deleteStr(yylval.str);

 	DBG_(("db: begin/end %d\n", token));

 	return token;

 	}

     return 0;

     }

 

 static char* lexGetQuotedPrintable()

 {

     int c;

     lexSkipWhite();

     c = lexLookahead();

     lexClearToken();

 

-    while (c != EOF && c != ';') {

+    while (c != EOF && (c != ';' || !fieldedProp)) {

 	if (c == '\n') {

 	    // break, leave '\n' on remaining chars.

 	    break;

 	} else if (c == '=') {

 	    int cur = 0;

 	    int next;

 

 	    lexSkipLookahead(); // skip '='

 	    next = lexLookahead();

 

 	    if (next == '\n') {

 		// skip and only skip the \n

 		lexSkipLookahead(); 

 		c = lexLookahead();

 		++mime_lineNum; // aid in error reporting

 		continue;

 	    } else if (next >= '0' && next <= '9') {

 		cur = next - '0';

 	    } else if (next >= 'A' && next <= 'F') {

 		cur = next - 'A' + 10;

 	    } else {

 		// we have been sent buggy stuff. doesn't matter

 		// what we do so long as we keep going.

 		// should probably spit an error here

@@ -1031,53 +1033,50 @@ static int yylex() {
 	if (c == ';' && fieldedProp) {

 	    DBG_(("db: SEMICOLON\n"));

 	    lexPushLookaheadc(c);

 	    handleMoreRFC822LineBreak(c);

 	    lexSkipLookahead();

 	    return SEMICOLON;

 	    }

 	else if (strchr("\n",c)) {

 	    ++mime_lineNum;

 	    /* consume all line separator(s) adjacent to each other */

 	    c = lexLookahead();

 	    while (strchr("\n",c)) {

 		lexSkipLookahead();

 		c = lexLookahead();

 		++mime_lineNum;

 		}

 	    DBG_(("db: LINESEP\n"));

 	    return LINESEP;

 	    }

 	else {

 	    char *p = 0;

 	    lexPushLookaheadc(c);

 	    if (lexWithinMode(L_BASE64)) {

 		/* get each char and convert to bin on the fly... */

-		p = lexGetDataFromBase64();

-#if 0
-		yylval.str = p;

-		return STRING;

-#endif		
+		yylval.str = NULL;

+		return lexGetDataFromBase64() ? STRING : 0;

 		}

 	    else if (lexWithinMode(L_QUOTED_PRINTABLE)) {

 		p = lexGetQuotedPrintable();

 		}

 	    else {

 #ifdef _SUPPORT_LINE_FOLDING

 		p = lexGet1Value();

 #else

 		p = lexGetStrUntil(";\n");

 #endif

 		}

 	    if (p) {

 		DBG_(("db: STRING: '%s'\n", p));

 		yylval.str = p;

 		return STRING;

 		}

 	    else return 0;

 	    }

 	}

     else {

 	/* normal mode */

 	while (1) {

 	    int c = lexGetc();

 	    switch(c) {

@@ -1217,49 +1216,49 @@ DLLEXPORT(VObject*) Parse_MIME_FromFileName(char *fname)
 

 static MimeErrorHandler mimeErrorHandler;

 

 DLLEXPORT(void) registerMimeErrorHandler(MimeErrorHandler me)

     {

     mimeErrorHandler = me;

     }

 

 void mime_error(char *s)

     {

     char msg[256];

     if (mimeErrorHandler) {

 	sprintf(msg,"%s at line %d", s, mime_lineNum);

 	mimeErrorHandler(msg);

 	}

     }

 

 void mime_error_(char *s)

     {

     if (mimeErrorHandler) {

 	mimeErrorHandler(s);

 	}

     }

 

-#line 1240 "y.tab.c"
+#line 1241 "y.tab.c"
 #define YYABORT goto yyabort
 #define YYREJECT goto yyabort
 #define YYACCEPT goto yyaccept
 #define YYERROR goto yyerrlab
 int
 #if defined(__STDC__)
 yyparse(void)
 #else
 yyparse()
 #endif
 {
     register int yym, yyn, yystate;
 #if YYDEBUG
     register char *yys;
     extern char *getenv();
 
     if (yys = getenv("YYDEBUG"))
     {
         yyn = *yys;
         if (yyn >= '0' && yyn <= '9')
             yydebug = yyn - '0';
     }
 #endif
 
@@ -1517,49 +1516,49 @@ case 42:
 	if (!pushVObject(VCTodoProp)) YYERROR;

 	}
 break;
 case 43:
 #line 366 "backend/vcc.y"
 {

 	lexPopMode(0);

 	popVObject();

 	}
 break;
 case 44:
 #line 371 "backend/vcc.y"
 {

 	lexPushMode(L_VTODO);

 	if (!pushVObject(VCTodoProp)) YYERROR;

 	}
 break;
 case 45:
 #line 376 "backend/vcc.y"
 {

 	lexPopMode(0);

 	popVObject();

 	}
 break;
-#line 1540 "y.tab.c"
+#line 1541 "y.tab.c"
     }
     yyssp -= yym;
     yystate = *yyssp;
     yyvsp -= yym;
     yym = yylhs[yyn];
     if (yystate == 0 && yym == 0)
     {
 #if YYDEBUG
         if (yydebug)
             printf("%sdebug: after reduction, shifting from state 0 to\
  state %d\n", YYPREFIX, YYFINAL);
 #endif
         yystate = YYFINAL;
         *++yyssp = YYFINAL;
         *++yyvsp = yyval;
         if (yychar < 0)
         {
             if ((yychar = yylex()) < 0) yychar = 0;
 #if YYDEBUG
             if (yydebug)
             {
                 yys = 0;
                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                 if (!yys) yys = "illegal-symbol";