3 files changed, 187 insertions, 19 deletions

diff --git a/gammu/emb/common/misc/coding/coding.c b/gammu/emb/common/misc/coding/coding.c
index 62543ac..b30b645 100644
--- a/gammu/emb/common/misc/coding/coding.c
+++ b/gammu/emb/common/misc/coding/coding.c
@@ -1,8 +1,12 @@
 /* (c) 2002-2004 by Marcin Wiacek, Michal Cihar and others */
-/* based on some work from MyGnokii and Gnokii */
+/* based on some work from MyGnokii (www.mwiacek.com) */
+/* based on some work from Gnokii (www.gnokii.org)
+ * (C) 1999-2000 Hugh Blemings & Pavel Janik ml. (C) 2001-2004 Pawel Kot 
+ * GNU GPL version 2 or later
+ */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include <locale.h>
@@ -13,12 +17,161 @@
 #  include "windows.h"
 #endif
 
 #include "../misc.h"
 #include "coding.h"
 
+/* function changes #10 #13 chars to \n \r */
+char *EncodeUnicodeSpecialChars(unsigned char *buffer)
+{
+                int             Pos=0, Pos2=0;
+                static unsigned charBuf[20000];
+
+        while (buffer[Pos*2]!=0x00 || buffer[Pos*2+1]!=0x00) {
+                if (buffer[Pos*2] == 0x00 && buffer[Pos*2+1] == 10) {
+                        Buf[Pos2*2]   = 0x00;
+                        Buf[Pos2*2+1] = '\\';
+                        Pos2++;
+                        Buf[Pos2*2]   = 0x00;
+                        Buf[Pos2*2+1] = 'n';
+                        Pos2++;
+                } else if (buffer[Pos*2] == 0x00 && buffer[Pos*2+1] == 13) {
+                        Buf[Pos2*2]   = 0x00;
+                        Buf[Pos2*2+1] = '\\';
+                        Pos2++;
+                        Buf[Pos2*2]   = 0x00;
+                        Buf[Pos2*2+1] = 'r';
+                        Pos2++;
+                } else if (buffer[Pos*2] == 0x00 && buffer[Pos*2+1] == '\\') {
+                        Buf[Pos2*2]   = 0x00;
+                        Buf[Pos2*2+1] = '\\';
+                        Pos2++;
+                        Buf[Pos2*2]   = 0x00;
+                        Buf[Pos2*2+1] = '\\';
+                        Pos2++;
+                } else {
+                        Buf[Pos2*2]   = buffer[Pos*2];
+                        Buf[Pos2*2+1] = buffer[Pos*2+1];
+                        Pos2++;
+                }
+                Pos++;
+        }
+        Buf[Pos2*2]   = 0;
+        Buf[Pos2*2+1] = 0;
+        return Buf;
+}
+
+/* function changes #10 #13 chars to \n \r */
+char *EncodeSpecialChars(unsigned char *buffer)
+{
+                int             Pos=0, Pos2=0;
+                static unsigned charBuf[10000];
+
+        while (buffer[Pos]!=0x00) {
+                switch (buffer[Pos]) {
+                case 10:
+                        Buf[Pos2++] = '\\';
+                        Buf[Pos2++] = 'n';
+                        break;
+                case 13: 
+                        Buf[Pos2++] = '\\';
+                        Buf[Pos2++] = 'r';
+                        break;
+                case '\\':
+                        Buf[Pos2++] = '\\';
+                        Buf[Pos2++] = '\\';
+                        break;
+                default:
+                        Buf[Pos2++] = buffer[Pos];
+                }
+                Pos++;
+        }
+        Buf[Pos2] = 0;
+        return Buf;
+}
+
+char *DecodeUnicodeSpecialChars(unsigned char *buffer)
+{
+                int             Pos=0, Pos2=0, level=0;
+                static unsigned charBuf[10000];
+
+        while (buffer[Pos*2]!=0x00 || buffer[Pos*2+1]!=0x00) {
+                Buf[Pos2*2]   = buffer[Pos*2];
+                Buf[Pos2*2+1] = buffer[Pos*2+1];
+                switch (level) {
+                case 0:
+                        if (buffer[Pos*2] == 0x00 && buffer[Pos*2+1] == '\\') {
+                                level = 1;
+                        } else {
+                                Pos2++;
+                        }
+                        break;
+                case 1:
+                        if (buffer[Pos*2] == 0x00 && buffer[Pos*2+1] == 'n') {
+                                Buf[Pos2*2]   = 0;
+                                Buf[Pos2*2+1] = 10;
+                        }
+                        if (buffer[Pos*2] == 0x00 && buffer[Pos*2+1] == 'r') {
+                                Buf[Pos2*2]   = 0;
+                                Buf[Pos2*2+1] = 13;
+                        }
+                        if (buffer[Pos*2] == 0x00 && buffer[Pos*2+1] == '\\') {
+                                Buf[Pos2*2]   = 0;
+                                Buf[Pos2*2+1] = '\\';
+                        }
+                        Pos2++;
+                        level = 0;
+                }
+                Pos++;
+        }
+        Buf[Pos2*2]   = 0;
+        Buf[Pos2*2+1] = 0;
+        return Buf;
+}
+
+char *DecodeSpecialChars(unsigned char *buffer)
+{
+                int             Pos=0, Pos2=0, level=0;
+                static unsigned charBuf[10000];
+
+        while (buffer[Pos]!=0x00) {
+                Buf[Pos2] = buffer[Pos];
+                switch (level) {
+                case 0:
+                        if (buffer[Pos] == '\\') {
+                                level = 1;
+                        } else {
+                                Pos2++;
+                        }
+                        break;
+                case 1:
+                        if (buffer[Pos] == 'n') Buf[Pos2] = 10;
+                        if (buffer[Pos] == 'r') Buf[Pos2] = 13;
+                        if (buffer[Pos] == '\\') Buf[Pos2] = '\\';
+                        Pos2++;
+                        level = 0;
+                }
+                Pos++;
+        }
+        Buf[Pos2] = 0;
+        return Buf;
+}
+
+char *mystrcasestr(unsigned const char *a, unsigned const char *b)
+{
+                unsigned char A[2000], B[200];
+                int     i;
+
+        memset(A,0,sizeof(A));
+        memset(B,0,sizeof(B));
+        for (i=0;i<(int)strlen(a);i++) A[i] = tolower(a[i]);
+        for (i=0;i<(int)strlen(b);i++) B[i] = tolower(b[i]);
+
+        return strstr(A,B);
+}
+
 unsigned int UnicodeLength(const unsigned char *str)
 {
         unsigned int len = 0;
 
         if (str == NULL) return 0;
 
@@ -583,20 +736,20 @@ void GSM_UnpackSemiOctetNumber(unsigned char *retval, unsigned char *Number, boo
                 length=length / 2 + 1;
         }
 
         /*without leading byte with format of number*/  
         length--;
 
-        switch (Number[1]) {
-        case NUMBER_ALPHANUMERIC:
+        switch ((Number[1] & 112)) {
+        case (NUMBER_ALPHANUMERIC_NUMBERING_PLAN_UNKNOWN & 112):
                 if (length > 6) length++;
                 dbgprintf("Alphanumeric number, length %i\n",length);
                 GSM_UnpackEightBitsToSeven(0, length, length, Number+2, Buffer);
                 Buffer[length]=0;
                 break;
-        case NUMBER_INTERNATIONAL:
+        case (NUMBER_INTERNATIONAL_NUMBERING_PLAN_ISDN & 112):
                 dbgprintf("International number\n");
                 Buffer[0]='+';
                 DecodeBCD(Buffer+1,Number+2, length);
                 break;
         default:
                 dbgprintf("Default number %02x\n",Number[1]);
@@ -628,36 +781,36 @@ int GSM_PackSemiOctetNumber(unsigned char *Number, unsigned char *Output, bool s
                 int     length, i;
 
         length=UnicodeLength(Number);
         memcpy(buffer,DecodeUnicodeString(Number),length+1);
 
         /* Checking for format number */
-        format = NUMBER_UNKNOWN;
+        format = NUMBER_UNKNOWN_NUMBERING_PLAN_ISDN;
         for (i=0;i<length;i++) {
                 /* first byte is '+'. Number can be international */
                 if (i==0 && buffer[i]=='+') {
-                        format=NUMBER_INTERNATIONAL;  
+                        format=NUMBER_INTERNATIONAL_NUMBERING_PLAN_ISDN;  
                 } else {
                         /*char is not number. It must be alphanumeric*/
-                        if (!isdigit(buffer[i])) format=NUMBER_ALPHANUMERIC;
+                        if (!isdigit(buffer[i])) format=NUMBER_ALPHANUMERIC_NUMBERING_PLAN_UNKNOWN;
                 }
         }
 
         /**
          * First byte is used for saving type of number. See GSM 03.40
          * section 9.1.2.5
          */
         Output[0]=format;
 
         /* After number type we will have number. GSM 03.40 section 9.1.2 */
         switch (format) {
-        case NUMBER_ALPHANUMERIC:
+        case NUMBER_ALPHANUMERIC_NUMBERING_PLAN_UNKNOWN:
                 length=GSM_PackSevenBitsToEight(0, buffer, Output+1, strlen(buffer))*2;
                 if (strlen(buffer)==7) length--;
                 break;
-        case NUMBER_INTERNATIONAL:
+        case NUMBER_INTERNATIONAL_NUMBERING_PLAN_ISDN:
                 length--;
                 EncodeBCD (Output+1, buffer+1, length, true);
                 break;
         default:
                 EncodeBCD (Output+1, buffer, length, true);
                 break;
@@ -916,13 +1069,13 @@ void DecodeUnicodeSpecialNOKIAChars(unsigned char *dest, const unsigned char *sr
 bool mystrncasecmp(unsigned const char *a, unsigned const char *b, int num)
 {
         int i;
 
         if (a == NULL || b == NULL) return false;
 
-        num--;
+        if (num == 0) num = -1;
    
         for (i = 0; i != num; i++) {
                 if (a[i] == 0x00 && b[i] == 0x00) return true;
                 if (a[i] == 0x00 || b[i] == 0x00) return false;
                 if (tolower(a[i]) != tolower(b[i])) return false;
          }
@@ -936,13 +1089,13 @@ bool mywstrncasecmp(unsigned const  char *a, unsigned const  char *b, int num)
 {
                 int     i;
                 wchar_t wc,wc2;
 
         if (a == NULL || b == NULL) return false;
 
-        num--;
+        if (num == 0) num = -1;
         
         for (i = 0; i != num; i++) {
                 if ((a[i*2] == 0x00 && a[i*2+1] == 0x00) && (b[i*2] == 0x00 && b[i*2+1] == 0x00)) return true;
                 if ((a[i*2] == 0x00 && a[i*2+1] == 0x00) || (b[i*2] == 0x00 && b[i*2+1] == 0x00)) return false;
                 wc  = a[i*2+1] | (a[i*2] << 8);
                 wc2 = b[i*2+1] | (b[i*2] << 8);
@@ -1012,13 +1165,13 @@ int mytowlower(wchar_t c)
  * fastest implementation of strstr() in C.
  * I deliberately chose not to comment it.  You should have at least
  * as much fun trying to understand it, as I had to write it :-).
  *
  * Stephen R. van den Berg, berg@pool.informatik.rwth-aachen.de */
 
-unsigned char *mystrstr (const unsigned char *haystack, const unsigned char *needle)
+unsigned char *mywstrstr (const unsigned char *haystack, const unsigned char *needle)
 {
 /* One crazy define to convert unicode used in Gammu to standard wchar_t */
 #define tolowerwchar(x) (mytowlower((wchar_t)( (((&(x))[0] & 0xff) << 8) | (((&(x))[1] & 0xff)) )))
          register wchar_t b, c;
 
         if ((b = tolowerwchar(*needle)) != L'\0') {
diff --git a/gammu/emb/common/misc/coding/coding.h b/gammu/emb/common/misc/coding/coding.h
index d0c334d..4cf0038 100644
--- a/gammu/emb/common/misc/coding/coding.h
+++ b/gammu/emb/common/misc/coding/coding.h
@@ -1,22 +1,26 @@
 /* (c) 2002-2004 by Marcin Wiacek and others */
 
 #ifndef __coding_h
 #define __coding_h
 
+#if defined(_MSC_VER) && defined(__cplusplus)
+    extern "C" {
+#endif
+
 #include <stdlib.h>
 
 #include "../misc.h"
 
 #ifdef __OpenBSD__
         typedef         int wint_t;
 #endif
 
 /* ---------------------------- Unicode ------------------------------------ */
         bool            mywstrncasecmp          (unsigned const char *a, unsigned const char *b, int num);
-        unsigned char   *mystrstr               (unsigned const char *haystack, unsigned const char *needle);
+        unsigned char   *mywstrstr              (unsigned const char *haystack, unsigned const char *needle);
         bool            mywstrncmp              (unsigned const char *a, unsigned const char *b, int num);
         bool            myiswspace              (unsigned const char *src);
         int             mytowlower              (wchar_t c);
 
         unsigned int    EncodeWithUnicodeAlphabet(const unsigned char *value, wchar_t *dest);
         unsigned int    DecodeWithUnicodeAlphabet(wchar_t value, unsigned char *dest);
@@ -32,12 +36,15 @@ void 		ReverseUnicodeString		(unsigned char *String);
 
         void            ReadUnicodeFile                 (unsigned char *Dest, unsigned char *Source);
 
         void            DecodeUnicodeSpecialNOKIAChars(unsigned char *dest, const unsigned char *src, int len);
         void            EncodeUnicodeSpecialNOKIAChars(unsigned char *dest, const unsigned char *src, int len);
 
+        char            *EncodeUnicodeSpecialChars(unsigned char *buffer);
+        char            *DecodeUnicodeSpecialChars(unsigned char *buffer);
+
 /* ------------------------------- BCD ------------------------------------- */
         unsigned char   EncodeWithBCDAlphabet   (int value);
         int             DecodeWithBCDAlphabet   (unsigned char value);
 
         void            DecodeBCD               (unsigned char *dest, const unsigned char *src, int len);
         void            EncodeBCD               (unsigned char *dest, const unsigned char *src, int len, bool fill);
@@ -83,21 +90,21 @@ int GSM_UnpackEightBitsToSeven	(int offset, int in_length, int out_length,
  * specified in GSM 03.40 section 9.1.2.5
  */
 typedef enum {
         /**
          * Unknown number type
          */
-                NUMBER_UNKNOWN  = 0x81,
+                NUMBER_UNKNOWN_NUMBERING_PLAN_ISDN      = 0x81,
         /**
          * International number (full number with code of country)
          */
-                NUMBER_INTERNATIONAL= 0x91,
+                NUMBER_INTERNATIONAL_NUMBERING_PLAN_ISDN= 0x91,
         /**
          * Alphanumeric number (with chars too)
          */
-                NUMBER_ALPHANUMERIC= 0xD0
+                NUMBER_ALPHANUMERIC_NUMBERING_PLAN_UNKNOWN= 0xD0
 
         /* specification give also other values */
 } GSM_NumberType;
 
         void            GSM_UnpackSemiOctetNumber(unsigned char *retval, unsigned char *Number, bool semioctet);
         int             GSM_PackSemiOctetNumber         (unsigned char *Number, unsigned char *Output, bool semioctet);
@@ -119,15 +126,23 @@ int SetBit   (unsigned char *Buffer, int BitNum);
 int ClearBit (unsigned char *Buffer, int BitNum);
 
 /* ---------------------------- Other -------------------------------------- */
 
         void StringToDouble(char *text, double *d);
 
-bool mystrncasecmp (unsigned const char *a, unsigned const char *b, int num);
+        bool mystrncasecmp (unsigned const char *a, unsigned const char *b, int num);
+        char *mystrcasestr (unsigned const char *a, unsigned const char *b);
 
-void MyGetLine(unsigned char *Buffer, int *Pos, unsigned char *OutBuffer, int MaxLen);
+        void MyGetLine  (unsigned char *Buffer, int *Pos, unsigned char *OutBuffer, int MaxLen);
+
+char *EncodeSpecialChars(unsigned char *buffer);
+char *DecodeSpecialChars(unsigned char *buffer);
+
+#if defined(_MSC_VER) && defined(__cplusplus)
+    }
+#endif
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/misc/coding/md5.c b/gammu/emb/common/misc/coding/md5.c
index 30fe33f..abb61be 100644
--- a/gammu/emb/common/misc/coding/md5.c
+++ b/gammu/emb/common/misc/coding/md5.c
@@ -1,7 +1,7 @@
-/* Taken from ReHash (see http://www.reichlsoft.de.vu/) and released
+/* Taken from ReHash (www.reichlsoft.de.vu) and released
  * under GPL/LGPL with permission from ReHash author
  * Dominik Reichl <dominik.reichl@t-online.de>, Germany
  */
 
 /*
  **********************************************************************