From 88b0d33b8b0b1f6ae320cfc863ca6a47fa8fec22 Mon Sep 17 00:00:00 2001
From: zautrix <zautrix>
Date: Sat, 07 Aug 2004 17:24:40 +0000
Subject: Initial revision

---
(limited to 'gammu/emb/common/misc/coding')

diff --git a/gammu/emb/common/misc/coding/coding.c b/gammu/emb/common/misc/coding/coding.c
new file mode 100644
index 0000000..62543ac
--- a/dev/null
+++ b/gammu/emb/common/misc/coding/coding.c
@@ -0,0 +1,1409 @@
+/* (c) 2002-2004 by Marcin Wiacek, Michal Cihar and others */
+/* based on some work from MyGnokii and Gnokii */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <locale.h>
+#ifndef __OpenBSD__
+#  include <wctype.h>
+#endif
+#ifdef WIN32
+#  include "windows.h"
+#endif
+
+#include "../misc.h"
+#include "coding.h"
+
+unsigned int UnicodeLength(const unsigned char *str)
+{
+	unsigned int len = 0;
+
+	if (str == NULL) return 0;
+
+	while(str[len*2] != 0 || str[len*2+1] != 0) len++;
+
+	return len;
+}
+
+/* Convert Unicode char saved in src to dest */
+unsigned int EncodeWithUnicodeAlphabet(const unsigned char *src, wchar_t *dest)
+{
+	char retval;
+
+        switch (retval = mbtowc(dest, src, MB_CUR_MAX)) {
+                case -1 :
+		case  0 : return 1;
+                default : return retval;
+        }
+}
+
+/* Convert Unicode char saved in src to dest */
+unsigned int DecodeWithUnicodeAlphabet(wchar_t src, unsigned char *dest)
+{
+        int retval;
+        
+        switch (retval = wctomb(dest, src)) {
+                case -1:
+                        *dest = '?';
+                        return 1;
+                default:
+                        return retval;
+        }
+}
+
+void DecodeUnicode (const unsigned char *src, unsigned char *dest)
+{
+ 	int 		i=0,o=0;
+ 	wchar_t 	wc;
+
+ 	while (src[(2*i)+1]!=0x00 || src[2*i]!=0x00) {
+ 		wc = src[(2*i)+1] | (src[2*i] << 8);
+		o += DecodeWithUnicodeAlphabet(wc, dest + o);
+ 		i++;
+ 	}
+	dest[o]=0;
+}
+
+/* Decode Unicode string and return as function result */
+unsigned char *DecodeUnicodeString (const unsigned char *src)
+{
+ 	static char dest[500];
+
+	DecodeUnicode(src,dest);
+	return dest;
+}
+
+/* Decode Unicode string to UTF8 or other console charset
+ * and return as function result
+ */
+unsigned char *DecodeUnicodeConsole(const unsigned char *src)
+{
+ 	static char dest[500];
+
+	if (di.coding[0] != 0) {
+		if (!strcmp(di.coding,"utf8")) {
+			EncodeUTF8(dest, src);
+		} else {
+#ifdef WIN32
+			setlocale(LC_ALL, di.coding);
+#endif
+			DecodeUnicode(src,dest);
+		}
+	} else {
+#ifdef WIN32
+		setlocale(LC_ALL, ".OCP");
+#endif
+		DecodeUnicode(src,dest);
+#ifdef WIN32
+		setlocale(LC_ALL, ".ACP");
+#endif
+	}
+	return dest;
+}
+
+/* Encode string to Unicode. Len is number of input chars */
+void EncodeUnicode (unsigned char *dest, const unsigned char *src, int len)
+{
+	int 		i_len = 0, o_len;
+ 	wchar_t 	wc;
+ 
+	for (o_len = 0; i_len < len; o_len++) {
+		i_len += EncodeWithUnicodeAlphabet(&src[i_len], &wc);
+		dest[o_len*2]		= (wc >> 8) & 0xff;
+		dest[(o_len*2)+1]	= wc & 0xff;
+ 	}
+	dest[o_len*2]		= 0;
+	dest[(o_len*2)+1]	= 0;
+}
+
+unsigned char EncodeWithBCDAlphabet(int value)
+{
+	div_t division;
+
+	division=div(value,10);
+	return ( ( (value-division.quot*10) & 0x0f) << 4) | (division.quot & 0xf);
+}
+
+int DecodeWithBCDAlphabet(unsigned char value)
+{
+	return 10*(value & 0x0f)+(value >> 4);
+}
+
+void DecodeBCD (unsigned char *dest, const unsigned char *src, int len)
+{
+	int i,current=0,digit;
+
+	for (i = 0; i < len; i++) {
+	        digit=src[i] & 0x0f;
+                if (digit<10) dest[current++]=digit + '0';
+	        digit=src[i] >> 4;
+                if (digit<10) dest[current++]=digit + '0';
+	}
+	dest[current++]=0;
+}
+
+void EncodeBCD (unsigned char *dest, const unsigned char *src, int len, bool fill)
+{
+	int i,current=0;
+
+	for (i = 0; i < len; i++) {
+        	if (i & 0x01) {
+			dest[current]=dest[current] | ((src[i]-'0') << 4);
+			current++;
+		} else {
+			dest[current]=src[i]-'0';
+		}
+	}
+
+        /* When fill is set: if number consist of odd number of digits,
+	   we fill last bits in last byte with 0x0f
+	 */
+	if (fill && (len & 0x01)) dest[current]=dest[current] | 0xf0;
+}
+
+int DecodeWithHexBinAlphabet (unsigned char mychar)
+{
+	if (mychar>='A' && mychar<='F') return mychar-'A'+10;
+	if (mychar>='a' && mychar<='f') return mychar-'a'+10;
+	if (mychar>='0' && mychar<='9') return mychar-'0';
+	return -1;
+}
+
+unsigned char EncodeWithHexBinAlphabet (int digit)
+{
+	if (digit >= 0 && digit <= 9) return '0'+(digit);
+	if (digit >=10 && digit <=15) return 'A'+(digit-10);
+	return 0;
+}
+
+void DecodeHexUnicode (unsigned char *dest, const unsigned char *src, int len)
+{
+	int 	i,current=0;
+	bool 	first = false;
+
+	if (len != 0 && src[0] == '0' && src[1] == '0') {
+		first = true;
+	} else if (len != 0 && src[2] == '0' && src[3] == '0') {
+		first = false;
+	} else {
+		first = (10 * (src[0] - '0') + (src[1] - '0')) < (10 * (src[2] - '0')+ (src[3] - '0'));
+	}
+	for (i = 0; i < len/4 ; i++) {
+		if (first) {
+			dest[current++] = DecodeWithHexBinAlphabet(src[i*4+0])*16+
+					  DecodeWithHexBinAlphabet(src[i*4+1]);
+			dest[current++] = DecodeWithHexBinAlphabet(src[i*4+2])*16+
+					  DecodeWithHexBinAlphabet(src[i*4+3]);
+		} else {
+			dest[current++] = DecodeWithHexBinAlphabet(src[i*4+2])*16+
+					  DecodeWithHexBinAlphabet(src[i*4+3]);
+			dest[current++] = DecodeWithHexBinAlphabet(src[i*4+0])*16+
+					  DecodeWithHexBinAlphabet(src[i*4+1]);
+		}
+	}
+	dest[current++] = 0;
+	dest[current++] = 0;
+}
+
+void EncodeHexUnicode (unsigned char *dest, const unsigned char *src, int len)
+{
+	int i,current=0;
+
+	for (i = 0; i < len; i++) {
+		dest[current++] = EncodeWithHexBinAlphabet(src[2*i] >> 0x04);
+		dest[current++] = EncodeWithHexBinAlphabet(src[2*i] & 0x0f);
+		dest[current++] = EncodeWithHexBinAlphabet(src[2*i+1] >> 0x04);
+		dest[current++] = EncodeWithHexBinAlphabet(src[2*i+1] & 0x0f);
+	}
+	dest[current++] = 0;
+}
+
+void DecodeHexBin (unsigned char *dest, const unsigned char *src, int len)
+{
+	int i,current=0;
+
+	for (i = 0; i < len/2 ; i++) {
+		dest[current++] = DecodeWithHexBinAlphabet(src[i*2])*16+
+				  DecodeWithHexBinAlphabet(src[i*2+1]);
+	}
+	dest[current++] = 0;
+}
+
+void EncodeHexBin (unsigned char *dest, const unsigned char *src, int len)
+{
+	int i,current=0;
+
+	for (i = 0; i < len; i++) {
+		dest[current++] = EncodeWithHexBinAlphabet(src[i] >> 0x04);
+		dest[current++] = EncodeWithHexBinAlphabet(src[i] & 0x0f);
+	}
+	dest[current++] = 0;
+}
+
+/* ETSI GSM 03.38, section 6.2.1: Default alphabet for SMS messages */
+static unsigned char GSM_DefaultAlphabetUnicode[128+1][2] =
+{
+	{0x00,0x40},{0x00,0xa3},{0x00,0x24},{0x00,0xA5},
+	{0x00,0xE8},{0x00,0xE9},{0x00,0xF9},{0x00,0xEC},/*0x08*/
+	{0x00,0xF2},{0x00,0xC7},{0x00,'\n'},{0x00,0xD8},
+	{0x00,0xF8},{0x00,'\r'},{0x00,0xC5},{0x00,0xE5},
+	{0x03,0x94},{0x00,0x5f},{0x03,0xA6},{0x03,0x93},
+	{0x03,0x9B},{0x03,0xA9},{0x03,0xA0},{0x03,0xA8},
+	{0x03,0xA3},{0x03,0x98},{0x03,0x9E},{0x00,0xb9},
+	{0x00,0xC6},{0x00,0xE6},{0x00,0xDF},{0x00,0xC9},/*0x20*/
+	{0x00,' ' },{0x00,'!' },{0x00,'\"'},{0x00,'#' },
+	{0x00,0xA4},{0x00,'%' },{0x00,'&' },{0x00,'\''},
+	{0x00,'(' },{0x00,')' },{0x00,'*' },{0x00,'+' },
+	{0x00,',' },{0x00,'-' },{0x00,'.' },{0x00,'/' },/*0x30*/
+	{0x00,'0' },{0x00,'1' },{0x00,'2' },{0x00,'3' },
+	{0x00,'4' },{0x00,'5' },{0x00,'6' },{0x00,'7' },
+	{0x00,'8' },{0x00,'9' },{0x00,':' },{0x00,';' },
+	{0x00,'<' },{0x00,'=' },{0x00,'>' },{0x00,'?' },/*0x40*/
+	{0x00,0xA1},{0x00,'A' },{0x00,'B' },{0x00,'C' },
+	{0x00,'D' },{0x00,'E' },{0x00,'F' },{0x00,'G' },
+	{0x00,'H' },{0x00,'I' },{0x00,'J' },{0x00,'K' },
+	{0x00,'L' },{0x00,'M' },{0x00,'N' },{0x00,'O' },
+	{0x00,'P' },{0x00,'Q' },{0x00,'R' },{0x00,'S' },
+	{0x00,'T' },{0x00,'U' },{0x00,'V' },{0x00,'W' },
+	{0x00,'X' },{0x00,'Y' },{0x00,'Z' },{0x00,0xC4},
+	{0x00,0xD6},{0x00,0xD1},{0x00,0xDC},{0x00,0xA7},
+	{0x00,0xBF},{0x00,'a' },{0x00,'b' },{0x00,'c' },
+	{0x00,'d' },{0x00,'e' },{0x00,'f' },{0x00,'g' },
+	{0x00,'h' },{0x00,'i' },{0x00,'j' },{0x00,'k' },
+	{0x00,'l' },{0x00,'m' },{0x00,'n' },{0x00,'o' },
+	{0x00,'p' },{0x00,'q' },{0x00,'r' },{0x00,'s' },
+	{0x00,'t' },{0x00,'u' },{0x00,'v' },{0x00,'w' },
+	{0x00,'x' },{0x00,'y' },{0x00,'z' },{0x00,0xE4},
+	{0x00,0xF6},{0x00,0xF1},{0x00,0xFC},{0x00,0xE0},
+	{0x00,0x00}
+};
+
+/* ETSI GSM 3.38
+ * Some sequences of 2 default alphabet chars (for example,
+ * 0x1b, 0x65) are visible as one single additional char (for example,
+ * 0x1b, 0x65 gives Euro char saved in Unicode as 0x20, 0xAC)
+ * This table contains:
+ * 1. two first chars means sequence of chars from GSM default alphabet
+ * 2. two second is target (encoded) char saved in Unicode
+ */
+static unsigned char GSM_DefaultAlphabetCharsExtension[][4] =
+{
+	{0x1b,0x14,0x00,0x5e},	/* ^	*/
+	{0x1b,0x28,0x00,0x7b},	/* {	*/
+	{0x1b,0x29,0x00,0x7d},	/* }	*/
+	{0x1b,0x2f,0x00,0x5c},	/* \	*/
+	{0x1b,0x3c,0x00,0x5b},	/* [	*/
+	{0x1b,0x3d,0x00,0x7E},	/* ~	*/
+	{0x1b,0x3e,0x00,0x5d},	/* ]	*/
+	{0x1b,0x40,0x00,0x7C},	/* |	*/
+	{0x1b,0x65,0x20,0xAC},	/* Euro */
+	{0x00,0x00,0x00,0x00}
+};
+
+void DecodeDefault (unsigned char *dest, const unsigned char *src, int len, bool UseExtensions, unsigned char *ExtraAlphabet)
+{
+	int 	i,current=0,j;
+	bool	FoundSpecial = false;
+
+#ifdef DEBUG
+	if (di.dl == DL_TEXTALL || di.dl == DL_TEXTALLDATE) DumpMessage(di.df, di.dl, src, len);
+#endif
+
+	for (i = 0; i < len; i++) {
+		FoundSpecial = false;
+		if ((i < (len-1)) && UseExtensions) {
+			j=0;
+			while (GSM_DefaultAlphabetCharsExtension[j][0]!=0x00) {
+				if (GSM_DefaultAlphabetCharsExtension[j][0]==src[i] && 
+				    GSM_DefaultAlphabetCharsExtension[j][1]==src[i+1]) {
+					FoundSpecial = true;
+					dest[current++] = GSM_DefaultAlphabetCharsExtension[j][2];
+					dest[current++] = GSM_DefaultAlphabetCharsExtension[j][3];
+					i++;
+					break;
+				}
+				j++;
+			}
+		}
+       		if (ExtraAlphabet!=NULL && !FoundSpecial) {
+			j = 0;
+			while (ExtraAlphabet[j] != 0x00 || ExtraAlphabet[j+1] != 0x00 || ExtraAlphabet[j+2] != 0x00) {
+				if (ExtraAlphabet[j] == src[i]) {
+					dest[current++] = ExtraAlphabet[j+1];
+					dest[current++] = ExtraAlphabet[j+2];
+					FoundSpecial 	= true;
+                            		break;
+                        	}
+                        	j=j+3;
+                    	}
+                }
+		if (!FoundSpecial) {
+			dest[current++] = GSM_DefaultAlphabetUnicode[src[i]][0];
+			dest[current++] = GSM_DefaultAlphabetUnicode[src[i]][1];
+		}
+	}
+	dest[current++]=0;
+	dest[current++]=0;
+#ifdef DEBUG
+	if (di.dl == DL_TEXTALL || di.dl == DL_TEXTALLDATE) DumpMessage(di.df, di.dl, dest, UnicodeLength(dest)*2);
+#endif
+}
+
+/* There are many national chars with "adds". In phone they're normally
+ * changed to "plain" Latin chars. We have such functionality too.
+ * This table is automatically created from convert.txt file (see
+ * /docs/developers) using --makeconverttable. It contains such chars
+ * to replace in order:
+ * 1. original char (Unicode) 2. destination char (Unicode)
+ */
+static unsigned char ConvertTable[] =
+"\x00\xc0\x00\x41\x00\xe0\x00\x61\x00\xc1\x00\x41\x00\xe1\x00\x61\x00\xc2\x00\x41\x00\xe2\x00\x61\x00\xc3\x00\x41\x00\xe3\x00\x61\x1e\xa0\x00\x41\x1e\xa1\x00\x61\x1e\xa2\x00\x41\x1e\xa3\x00\x61\x1e\xa4\x00\x41\x1e\xa5\x00\x61\x1e\xa6\x00\x41\x1e\xa7\x00\x61\x1e\xa8\x00\x41\x1e\xa9\x00\x61\x1e\xaa\x00\x41\x1e\xab\x00\x61\x1e\xac\x00\x41\x1e\xad\x00\x61\x1e\xae\x00\x41\x1e\xaf\x00\x61\x1e\xb0\x00\x41\x1e\xb1\x00\x61\x1e\xb2\x00\x41\x1e\xb3\x00\x61\x1e\xb4\x00\x41\x1e\xb5\x00\x61\x1e\xb6\x00\x41\x1e\xb7\x00\x61\x01\xcd\x00\x41\x01\xce\x00\x61\x01\x00\x00\x41\x01\x01\x00\x61\x01\x02\x00\x41\x01\x03\x00\x61\x01\x04\x00\x41\x01\x05\x00\x61\x01\xfb\x00\x61\x01\x06\x00\x43\x01\x07\x00\x63\x01\x08\x00\x43\x01\x09\x00\x63\x01\x0a\x00\x43\x01\x0b\x00\x63\x01\x0c\x00\x43\x01\x0d\x00\x63\x00\xe7"\
+"\x00\x63\x01\x0e\x00\x44\x01\x0f\x00\x64\x01\x10\x00\x44\x01\x11\x00\x64\x00\xc8\x00\x45\x00\xca\x00\x45\x00\xea\x00\x65\x00\xcb\x00\x45\x00\xeb\x00\x65\x1e\xb8\x00\x45\x1e\xb9\x00\x65\x1e\xba\x00\x45\x1e\xbb\x00\x65\x1e\xbc\x00\x45\x1e\xbd\x00\x65\x1e\xbe\x00\x45\x1e\xbf\x00\x65\x1e\xc0\x00\x45\x1e\xc1\x00\x65\x1e\xc2\x00\x45\x1e\xc3\x00\x65\x1e\xc4\x00\x45\x1e\xc5\x00\x65\x1e\xc6\x00\x45\x1e\xc7\x00\x65\x01\x12\x00\x45\x01\x13\x00\x65\x01\x14\x00\x45\x01\x15\x00\x65\x01\x16\x00\x45\x01\x17\x00\x65\x01\x18\x00\x45\x01\x19\x00\x65\x01\x1a\x00\x45\x01\x1b\x00\x65\x01\x1c\x00\x47\x01\x1d\x00\x67\x01\x1e\x00\x47\x01\x1f\x00\x67\x01\x20\x00\x47\x01\x21\x00\x67\x01\x22\x00\x47\x01\x23\x00\x67\x01\x24\x00\x48\x01\x25\x00\x68\x01\x26\x00\x48\x01\x27\x00\x68\x00\xcc\x00\x49\x00\xcd\x00\x49\x00\xed"\
+"\x00\x69\x00\xce\x00\x49\x00\xee\x00\x69\x00\xcf\x00\x49\x00\xef\x00\x69\x01\x28\x00\x49\x01\x29\x00\x69\x01\x2a\x00\x49\x01\x2b\x00\x69\x01\x2c\x00\x49\x01\x2d\x00\x69\x01\x2e\x00\x49\x01\x2f\x00\x69\x01\x30\x00\x49\x01\x31\x00\x69\x01\xcf\x00\x49\x01\xd0\x00\x69\x1e\xc8\x00\x49\x1e\xc9\x00\x69\x1e\xca\x00\x49\x1e\xcb\x00\x69\x01\x34\x00\x4a\x01\x35\x00\x6a\x01\x36\x00\x4b\x01\x37\x00\x6b\x01\x39\x00\x4c\x01\x3a\x00\x6c\x01\x3b\x00\x4c\x01\x3c\x00\x6c\x01\x3d\x00\x4c\x01\x3e\x00\x6c\x01\x3f\x00\x4c\x01\x40\x00\x6c\x01\x41\x00\x4c\x01\x42\x00\x6c\x01\x43\x00\x4e\x01\x44\x00\x6e\x01\x45\x00\x4e\x01\x46\x00\x6e\x01\x47\x00\x4e\x01\x48\x00\x6e\x01\x49\x00\x6e\x00\xd2\x00\x4f\x00\xd3\x00\x4f\x00\xf3\x00\x6f\x00\xd4\x00\x4f\x00\xf4\x00\x6f\x00\xd5\x00\x4f\x00\xf5\x00\x6f\x01\x4c\x00\x4f\x01\x4d"\
+"\x00\x6f\x01\x4e\x00\x4f\x01\x4f\x00\x6f\x01\x50\x00\x4f\x01\x51\x00\x6f\x01\xa0\x00\x4f\x01\xa1\x00\x6f\x01\xd1\x00\x4f\x01\xd2\x00\x6f\x1e\xcc\x00\x4f\x1e\xcd\x00\x6f\x1e\xce\x00\x4f\x1e\xcf\x00\x6f\x1e\xd0\x00\x4f\x1e\xd1\x00\x6f\x1e\xd2\x00\x4f\x1e\xd3\x00\x6f\x1e\xd4\x00\x4f\x1e\xd5\x00\x6f\x1e\xd6\x00\x4f\x1e\xd7\x00\x6f\x1e\xd8\x00\x4f\x1e\xd9\x00\x6f\x1e\xda\x00\x4f\x1e\xdb\x00\x6f\x1e\xdc\x00\x4f\x1e\xdd\x00\x6f\x1e\xde\x00\x4f\x1e\xdf\x00\x6f\x1e\xe0\x00\x4f\x1e\xe1\x00\x6f\x1e\xe2\x00\x4f\x1e\xe3\x00\x6f\x01\x54\x00\x52\x01\x55\x00\x72\x01\x56\x00\x52\x01\x57\x00\x72\x01\x58\x00\x52\x01\x59\x00\x72\x01\x5a\x00\x53\x01\x5b\x00\x73\x01\x5c\x00\x53\x01\x5d\x00\x73\x01\x5e\x00\x53\x01\x5f\x00\x73\x01\x60\x00\x53\x01\x61\x00\x73\x01\x62\x00\x54\x01\x63\x00\x74\x01\x64\x00\x54\x01\x65"\
+"\x00\x74\x01\x66\x00\x54\x01\x67\x00\x74\x00\xd9\x00\x55\x00\xda\x00\x55\x00\xfa\x00\x75\x00\xdb\x00\x55\x00\xfb\x00\x75\x01\x68\x00\x55\x01\x69\x00\x75\x01\x6a\x00\x55\x01\x6b\x00\x75\x01\x6c\x00\x55\x01\x6d\x00\x75\x01\x6e\x00\x55\x01\x6f\x00\x75\x01\x70\x00\x55\x01\x71\x00\x75\x01\x72\x00\x55\x01\x73\x00\x75\x01\xaf\x00\x55\x01\xb0\x00\x75\x01\xd3\x00\x55\x01\xd4\x00\x75\x01\xd5\x00\x55\x01\xd6\x00\x75\x01\xd7\x00\x55\x01\xd8\x00\x75\x01\xd9\x00\x55\x01\xda\x00\x75\x01\xdb\x00\x55\x01\xdc\x00\x75\x1e\xe4\x00\x55\x1e\xe5\x00\x75\x1e\xe6\x00\x55\x1e\xe7\x00\x75\x1e\xe8\x00\x55\x1e\xe9\x00\x75\x1e\xea\x00\x55\x1e\xeb\x00\x75\x1e\xec\x00\x55\x1e\xed\x00\x75\x1e\xee\x00\x55\x1e\xef\x00\x75\x1e\xf0\x00\x55\x1e\xf1\x00\x75\x01\x74\x00\x57\x01\x75\x00\x77\x1e\x80\x00\x57\x1e\x81\x00\x77\x1e\x82"\
+"\x00\x57\x1e\x83\x00\x77\x1e\x84\x00\x57\x1e\x85\x00\x77\x00\xdd\x00\x59\x00\xfd\x00\x79\x00\xff\x00\x79\x01\x76\x00\x59\x01\x77\x00\x79\x01\x78\x00\x59\x1e\xf2\x00\x59\x1e\xf3\x00\x75\x1e\xf4\x00\x59\x1e\xf5\x00\x79\x1e\xf6\x00\x59\x1e\xf7\x00\x79\x1e\xf8\x00\x59\x1e\xf9\x00\x79\x01\x79\x00\x5a\x01\x7a\x00\x7a\x01\x7b\x00\x5a\x01\x7c\x00\x7a\x01\x7d\x00\x5a\x01\x7e\x00\x7a\x01\xfc\x00\xc6\x01\xfd\x00\xe6\x01\xfe\x00\xd8\x01\xff\x00\xf8\x00\x00";
+
+void EncodeDefault(unsigned char *dest, const unsigned char *src, int *len, bool UseExtensions, unsigned char *ExtraAlphabet)
+{
+	int 	i,current=0,j,z;
+	char 	ret;
+	bool	FoundSpecial,FoundNormal;
+
+#ifdef DEBUG
+	if (di.dl == DL_TEXTALL || di.dl == DL_TEXTALLDATE) DumpMessage(di.df, di.dl, src, (*len)*2);
+#endif
+
+	for (i = 0; i < *len; i++) {
+		FoundSpecial = false;
+		j = 0;
+		while (GSM_DefaultAlphabetCharsExtension[j][0]!=0x00 && UseExtensions) {
+			if (src[i*2] 	== GSM_DefaultAlphabetCharsExtension[j][2] &&
+			    src[i*2+1] 	== GSM_DefaultAlphabetCharsExtension[j][3]) {
+				dest[current++] = GSM_DefaultAlphabetCharsExtension[j][0];
+				dest[current++] = GSM_DefaultAlphabetCharsExtension[j][1];
+				FoundSpecial 	= true;
+				break;
+			}
+			j++;
+		}
+		if (!FoundSpecial) {
+			ret 		= '?';
+			FoundNormal 	= false;
+			j 		= 0;
+			while (GSM_DefaultAlphabetUnicode[j][1]!=0x00) {
+				if (src[i*2]	== GSM_DefaultAlphabetUnicode[j][0] &&
+				    src[i*2+1]	== GSM_DefaultAlphabetUnicode[j][1]) {
+					ret 		= j;
+					FoundNormal 	= true;
+					break;
+				}
+				j++;
+			}
+			if (ExtraAlphabet!=NULL && !FoundNormal) {
+				j = 0;
+				while (ExtraAlphabet[j] != 0x00 || ExtraAlphabet[j+1] != 0x00 || ExtraAlphabet[j+2] != 0x00) {
+					if (ExtraAlphabet[j+1] == src[i*2] &&
+					    ExtraAlphabet[j+2] == src[i*2 + 1]) {
+						ret		= ExtraAlphabet[j];
+						FoundSpecial	= true;
+						break;
+					}
+					j=j+3;
+				}
+			}
+			if (!FoundNormal && !FoundSpecial) {
+				j = 0;
+				FoundNormal = false;
+				while (ConvertTable[j*4]   != 0x00 ||
+				       ConvertTable[j*4+1] != 0x00) {
+					if (src[i*2]   == ConvertTable[j*4] &&
+					    src[i*2+1] == ConvertTable[j*4+1]) {
+						z = 0;
+						while (GSM_DefaultAlphabetUnicode[z][1]!=0x00) {
+							if (ConvertTable[j*4+2]	== GSM_DefaultAlphabetUnicode[z][0] &&
+							    ConvertTable[j*4+3]	== GSM_DefaultAlphabetUnicode[z][1]) {
+								ret 		= z;
+								FoundNormal 	= true;
+								break;
+							}
+							z++;
+						}
+						if (FoundNormal) break;
+					}
+					j++;
+				}
+			}
+			dest[current++]=ret;
+		}
+	}
+	dest[current]=0;
+#ifdef DEBUG
+	if (di.dl == DL_TEXTALL || di.dl == DL_TEXTALLDATE) DumpMessage(di.df, di.dl, dest, current);
+#endif
+
+	*len = current;
+}
+
+/* You don't have to use ConvertTable here - 1 char is replaced there by 1 char */
+void FindDefaultAlphabetLen(const unsigned char *src, int *srclen, int *smslen, int maxlen)
+{
+	int 	current=0,j,i;
+	bool	FoundSpecial;
+
+	i = 0;
+	while (src[i*2] != 0x00 || src[i*2+1] != 0x00) {
+		FoundSpecial = false;
+		j = 0;
+		while (GSM_DefaultAlphabetCharsExtension[j][0]!=0x00) {
+			if (src[i*2] 	== GSM_DefaultAlphabetCharsExtension[j][2] &&
+			    src[i*2+1] 	== GSM_DefaultAlphabetCharsExtension[j][3]) {
+				FoundSpecial = true;
+				if (current+2 > maxlen) {
+					*srclen = i;
+					*smslen = current;
+					return;
+				}
+				current+=2;
+				break;
+			}
+			j++;
+		}
+		if (!FoundSpecial) {
+			if (current+1 > maxlen) {
+				*srclen = i;
+				*smslen = current;
+				return;
+			}
+			current++;
+		}
+		i++;
+	}
+	*srclen = i;
+	*smslen = current;
+}
+
+#ifndef ENABLE_LGPL
+#  define ByteMask ((1 << Bits) - 1)
+#endif
+
+int GSM_UnpackEightBitsToSeven(int offset, int in_length, int out_length,
+                           unsigned char *input, unsigned char *output)
+{
+#ifndef ENABLE_LGPL
+	/* (c) by Pavel Janik and Pawel Kot */
+
+        unsigned char *OUTPUT 	= output; /* Current pointer to the output buffer */
+        unsigned char *INPUT  	= input;  /* Current pointer to the input buffer */
+        unsigned char Rest 	= 0x00;
+        int	      Bits;
+
+        Bits = offset ? offset : 7;
+
+        while ((INPUT - input) < in_length) {
+
+                *OUTPUT = ((*INPUT & ByteMask) << (7 - Bits)) | Rest;
+                Rest = *INPUT >> Bits;
+
+                /* If we don't start from 0th bit, we shouldn't go to the
+                   next char. Under *OUTPUT we have now 0 and under Rest -
+                   _first_ part of the char. */
+                if ((INPUT != input) || (Bits == 7)) OUTPUT++;
+                INPUT++;
+
+                if ((OUTPUT - output) >= out_length) break;
+
+                /* After reading 7 octets we have read 7 full characters but
+                   we have 7 bits as well. This is the next character */
+                if (Bits == 1) {
+                        *OUTPUT = Rest;
+                        OUTPUT++;
+                        Bits = 7;
+                        Rest = 0x00;
+                } else {
+                        Bits--;
+                }
+        }
+
+        return OUTPUT - output;
+#else
+	return 0;
+#endif
+}
+
+int GSM_PackSevenBitsToEight(int offset, unsigned char *input, unsigned char *output, int length)
+{
+#ifndef ENABLE_LGPL
+	/* (c) by Pavel Janik and Pawel Kot */
+
+        unsigned char 	*OUTPUT = output; /* Current pointer to the output buffer */
+        unsigned char 	*INPUT  = input;  /* Current pointer to the input buffer */
+        int		Bits;             /* Number of bits directly copied to
+                                           * the output buffer */
+        Bits = (7 + offset) % 8;
+
+        /* If we don't begin with 0th bit, we will write only a part of the
+           first octet */
+        if (offset) {
+                *OUTPUT = 0x00;
+                OUTPUT++;
+        }
+
+        while ((INPUT - input) < length) {
+                unsigned char Byte = *INPUT;
+
+                *OUTPUT = Byte >> (7 - Bits);
+                /* If we don't write at 0th bit of the octet, we should write
+                   a second part of the previous octet */
+                if (Bits != 7)
+                        *(OUTPUT-1) |= (Byte & ((1 << (7-Bits)) - 1)) << (Bits+1);
+
+                Bits--;
+
+                if (Bits == -1) Bits = 7; else OUTPUT++;
+
+                INPUT++;
+        }
+        return (OUTPUT - output);
+#else
+	return 0;
+#endif
+}
+
+void GSM_UnpackSemiOctetNumber(unsigned char *retval, unsigned char *Number, bool semioctet)
+{
+	unsigned char	Buffer[50]	= "";
+	int		length		= Number[0];
+
+	if (semioctet) {
+		/* Convert number of semioctets to number of chars */
+		if (length % 2) length++;
+		length=length / 2 + 1;
+	}
+
+	/*without leading byte with format of number*/  
+	length--;
+
+	switch (Number[1]) {
+	case NUMBER_ALPHANUMERIC:
+		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:
+		dbgprintf("International number\n");
+		Buffer[0]='+';
+		DecodeBCD(Buffer+1,Number+2, length);
+		break;
+	default:
+		dbgprintf("Default number %02x\n",Number[1]);
+		DecodeBCD (Buffer, Number+2, length);
+		break;
+	}
+
+	EncodeUnicode(retval,Buffer,strlen(Buffer));
+}
+
+/**
+ * Packing some phone numbers (SMSC, SMS destination and others)
+ *
+ * See GSM 03.40 9.1.1:
+ * 1 byte  - length of number given in semioctets or bytes (when given in
+ *           bytes, includes one byte for byte with number format).
+ *           Returned by function (set semioctet to true, if want result
+ *           in semioctets).
+ * 1 byte  - format of number (see GSM_NumberType in coding.h). Returned
+ *           in unsigned char *Output.
+ * n bytes - 2n or 2n-1 semioctets with number. Returned in unsigned char
+ *           *Output.
+ *
+ * 1 semioctet = 4 bits = half of byte
+ */
+int GSM_PackSemiOctetNumber(unsigned char *Number, unsigned char *Output, bool semioctet)
+{
+	unsigned char	format, buffer[50];
+	int		length, i;
+
+	length=UnicodeLength(Number);
+	memcpy(buffer,DecodeUnicodeString(Number),length+1);
+
+	/* Checking for format number */
+	format = NUMBER_UNKNOWN;
+	for (i=0;i<length;i++) {
+		/* first byte is '+'. Number can be international */
+		if (i==0 && buffer[i]=='+') {
+			format=NUMBER_INTERNATIONAL;  
+		} else {
+			/*char is not number. It must be alphanumeric*/
+			if (!isdigit(buffer[i])) format=NUMBER_ALPHANUMERIC;
+		}
+	}
+
+	/**
+	 * 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:
+		length=GSM_PackSevenBitsToEight(0, buffer, Output+1, strlen(buffer))*2;
+		if (strlen(buffer)==7) length--;
+		break;
+	case NUMBER_INTERNATIONAL:
+		length--;
+		EncodeBCD (Output+1, buffer+1, length, true);
+		break;
+	default:
+		EncodeBCD (Output+1, buffer, length, true);
+		break;
+	}
+
+	if (semioctet) return length;
+
+	/* Convert number of semioctets to number of chars */
+	if (length % 2) length++;
+	return length / 2 + 1;
+}
+
+void CopyUnicodeString(unsigned char *Dest, unsigned char *Source)
+{
+	int j = 0;
+
+	while (Source[j]!=0x00 || Source[j+1]!=0x00) {
+		Dest[j]		= Source[j];
+		Dest[j+1]	= Source[j+1];
+		j=j+2;
+	}
+	Dest[j]		= 0;
+	Dest[j+1]	= 0;
+}
+
+/* Changes minor/major order in Unicode string */
+void ReverseUnicodeString(unsigned char *String)
+{
+	int 		j = 0;
+	unsigned char	byte1, byte2;
+
+	while (String[j]!=0x00 || String[j+1]!=0x00) {
+		byte1		= String[j];
+		byte2		= String[j+1];
+		String[j+1]	= byte1;
+		String[j]	= byte2;
+		j=j+2;
+	}
+	String[j]	= 0;
+	String[j+1]	= 0;
+}
+
+/* All input is in Unicode. First char can show Unicode minor/major order.
+   Output is Unicode string in Gammu minor/major order */
+void ReadUnicodeFile(unsigned char *Dest, unsigned char *Source)
+{
+	int j = 0, current = 0;
+
+	if (Source[0] == 0xFF && Source[1] == 0xFE) j = 2;
+	if (Source[0] == 0xFE && Source[1] == 0xFF) j = 2;
+
+	while (Source[j]!=0x00 || Source[j+1]!=0x00) {
+		if (Source[0] == 0xFF) {
+			Dest[current++] = Source[j+1];
+			Dest[current++]	= Source[j];
+		} else {
+			Dest[current++] = Source[j];
+			Dest[current++]	= Source[j+1];
+		}
+		j=j+2;
+	}
+	Dest[current++] = 0;
+	Dest[current++]	= 0;
+}
+
+int GetBit(unsigned char *Buffer, int BitNum)
+{
+	return Buffer[BitNum/8] & 1<<(7-(BitNum%8));
+}
+
+int SetBit(unsigned char *Buffer, int BitNum)
+{
+	return Buffer[BitNum/8] |= 1<<(7-(BitNum%8));
+}
+
+int ClearBit(unsigned char *Buffer, int BitNum)
+{
+	return Buffer[BitNum/8] &= 255 - (1 << (7-(BitNum%8)));
+}
+
+void BufferAlign(unsigned char *Destination, int *CurrentBit)
+{
+	int i=0;
+
+	while(((*CurrentBit) + i) % 8 != 0) {
+		ClearBit(Destination, (*CurrentBit)+i);
+		i++;
+	}
+
+	(*CurrentBit) = (*CurrentBit) + i;
+}
+
+void BufferAlignNumber(int *CurrentBit)
+{
+	int i=0;
+
+	while(((*CurrentBit) + i) % 8 != 0) {
+		i++;
+	}
+
+	(*CurrentBit) = (*CurrentBit) + i;
+}
+
+void AddBuffer(unsigned char 	*Destination,
+	       int 		*CurrentBit,
+	       unsigned char 	*Source,
+	       int 		BitsToProcess)
+{
+	int i=0;
+
+	while (i!=BitsToProcess) {
+		if (GetBit(Source, i)) {
+			SetBit(Destination, (*CurrentBit)+i);
+		} else {
+			ClearBit(Destination, (*CurrentBit)+i);
+		}
+		i++;
+	}
+	(*CurrentBit) = (*CurrentBit) + BitsToProcess;
+}
+
+void AddBufferByte(unsigned char *Destination,
+		   int 		 *CurrentBit,
+		   unsigned char Source,
+		   int 		 BitsToProcess)
+{
+	unsigned char Byte;
+
+	Byte = Source;
+
+	AddBuffer(Destination, CurrentBit, &Byte, BitsToProcess);
+}
+
+void GetBuffer(unsigned char *Source,
+	       int 	     *CurrentBit,
+	       unsigned char *Destination,
+	       int 	     BitsToProcess)
+{
+	int i=0;
+
+	while (i!=BitsToProcess) {
+		if (GetBit(Source, (*CurrentBit)+i)) {
+			SetBit(Destination, i);
+		} else {
+			ClearBit(Destination, i);
+		}
+		i++;
+	}
+	(*CurrentBit) = (*CurrentBit) + BitsToProcess;
+}
+
+void GetBufferInt(unsigned char *Source,
+		  int 		*CurrentBit,
+		  int 		*integer,
+		  int 		BitsToProcess)
+{
+	int l=0,z=128,i=0;
+
+	while (i!=BitsToProcess) {
+		if (GetBit(Source, (*CurrentBit)+i)) l=l+z;
+		z=z/2;
+		i++;
+	}
+	*integer=l;  
+	(*CurrentBit) = (*CurrentBit) + i;
+}
+
+void GetBufferI(unsigned char 	*Source,
+		int 		*CurrentBit,
+		int 		*result,
+		int 		BitsToProcess)
+{
+	int l=0,z,i=0;
+	
+	z = 1<<(BitsToProcess-1);
+
+	while (i!=BitsToProcess) {
+		if (GetBit(Source, (*CurrentBit)+i)) l=l+z;
+		z=z>>1;
+		i++;
+	}
+	*result=l;  
+	(*CurrentBit) = (*CurrentBit) + i;
+}
+
+/* Unicode char 0x00 0x01 makes blinking in some Nokia phones.
+ * We replace single ~ chars into it. When user give double ~, it's replaced
+ * to single ~
+ */
+void EncodeUnicodeSpecialNOKIAChars(unsigned char *dest, const unsigned char *src, int len)
+{
+	int 	i,current = 0;
+	bool 	special=false;
+
+	for (i = 0; i < len; i++) {
+		if (special) {
+			if (src[i*2] == 0x00 && src[i*2+1] == '~') {
+				dest[current++]	= 0x00;
+				dest[current++]	= '~';
+			} else {
+				dest[current++]	= 0x00;
+				dest[current++]	= 0x01;					
+				dest[current++]	= src[i*2];
+				dest[current++]	= src[i*2+1];
+			}
+			special = false;
+		} else {
+			if (src[i*2] == 0x00 && src[i*2+1] == '~') {
+				special = true;
+			} else {
+				dest[current++]	= src[i*2];
+				dest[current++]	= src[i*2+1];
+			}
+		}
+	}
+	if (special) {
+		dest[current++]	= 0x00;
+		dest[current++]	= 0x01;
+	}
+	dest[current++] = 0x00;
+	dest[current++] = 0x00;
+}
+
+void DecodeUnicodeSpecialNOKIAChars(unsigned char *dest, const unsigned char *src, int len)
+{
+	int i=0,current=0;
+
+	for (i=0;i<len;i++) {
+		switch (src[2*i]) {
+		case 0x00:
+			switch (src[2*i+1]) {
+			case 0x01:
+				dest[current++] = 0x00;
+				dest[current++] = '~';
+				break;
+			case '~':
+				dest[current++] = 0x00;
+				dest[current++] = '~';
+				dest[current++] = 0x00;
+				dest[current++] = '~';
+				break;
+			default:
+				dest[current++] = src[i*2];
+				dest[current++] = src[i*2+1];
+			}
+			break;
+		default:
+			dest[current++] = src[i*2];
+			dest[current++] = src[i*2+1];
+		}
+	}
+	dest[current++] = 0x00;
+	dest[current++] = 0x00;
+}
+
+bool mystrncasecmp(unsigned const char *a, unsigned const char *b, int num)
+{
+	int i;
+
+	if (a == NULL || b == NULL) return false;
+
+	num--;
+   
+	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;
+ 	}
+	return true;
+}
+
+/* Compares two Unicode strings without regarding to case.
+ * Return true, when they're equal
+ */
+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--;
+	
+	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);
+ 		if (mytowlower(wc) != mytowlower(wc2)) return false;
+ 	}
+	return true;
+}
+
+/* wcscmp in Mandrake 9.0 is wrong */
+bool mywstrncmp(unsigned const  char *a, unsigned const  char *b, int num)
+{
+	int i=0;
+  
+	while (1) {
+		if (a[i*2] != b[i*2] || a[i*2+1] != b[i*2+1]) return false;
+		if (a[i*2] == 0x00 && a[i*2+1] == 0x00) return true;
+		i++;
+		if (num == i) return true;
+	}
+}
+
+/* FreeBSD boxes 4.7-STABLE does't have it, although it's ANSI standard */
+bool myiswspace(unsigned const char *src)
+{
+#ifndef HAVE_ISWSPACE
+ 	int 		o;
+	unsigned char	dest[10];
+#endif
+ 	wchar_t 	wc;
+
+	wc = src[1] | (src[0] << 8);
+
+#ifndef HAVE_ISWSPACE
+	o = DecodeWithUnicodeAlphabet(wc, dest);
+	if (o == 1) {
+		if (isspace(((int)dest[0]))!=0) return true;
+		return false;
+	}
+	return false;
+#else
+	return iswspace(wc);
+#endif
+}
+
+/* FreeBSD boxes 4.7-STABLE does't have it, although it's ANSI standard */
+int mytowlower(wchar_t c)
+{
+#ifndef HAVE_TOWLOWER
+	unsigned char dest[10];
+
+	DecodeWithUnicodeAlphabet(c, dest);
+	return tolower(dest[0]);
+#else
+	return towlower(c);
+#endif
+}
+
+/*
+ * Following code is based on wcsstr from the GNU C Library, original
+ * comment follows:
+ */
+/*
+ * The original strstr() file contains the following comment:
+ *
+ * My personal strstr() implementation that beats most other algorithms.
+ * Until someone tells me otherwise, I assume that this is the
+ * 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)
+{
+/* 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') {
+		haystack -= 2;				/* possible ANSI violation */
+		do {
+			haystack += 2;
+			if ((c = tolowerwchar(*haystack)) == L'\0')
+				goto ret0;
+		} while (c != b);
+
+		needle += 2;
+		if ((c = tolowerwchar(*needle)) == L'\0')
+			goto foundneedle;
+		needle += 2;
+		goto jin;
+
+		for (;;) {
+			register wchar_t a;
+			register const unsigned char *rhaystack, *rneedle;
+
+			do {
+				haystack += 2;
+				if ((a = tolowerwchar(*haystack)) == L'\0')
+					goto ret0;
+				if (a == b)
+					break;
+				haystack += 2;
+				if ((a = tolowerwchar(*haystack)) == L'\0')
+					goto ret0;
+shloop:				;
+			} while (a != b);
+
+jin:			haystack += 2;
+			if ((a = tolowerwchar(*haystack)) == L'\0')
+				goto ret0;
+
+			if (a != c)
+				goto shloop;
+
+			rhaystack = haystack + 2;
+			haystack -= 2;
+			rneedle = needle;
+			if (tolowerwchar(*rhaystack) == (a = tolowerwchar(*rneedle)))
+				do {
+					if (a == L'\0')
+						goto foundneedle;
+					rhaystack += 2;
+					needle += 2;
+					if (tolowerwchar(*rhaystack) != (a = tolowerwchar(*needle)))
+						break ;
+					if (a == L'\0')
+						goto foundneedle;
+					rhaystack += 2;
+					needle += 2;
+				} while (tolowerwchar(*rhaystack) == (a = tolowerwchar(*needle)));
+
+			needle = rneedle;		  /* took the register-poor approach */
+
+			if (a == L'\0')
+				break;
+		}
+	}
+foundneedle:
+	return (unsigned char *)haystack;
+ret0:
+	return NULL;
+#undef tolowerwchar
+}
+
+void MyGetLine(unsigned char *Buffer, int *Pos, unsigned char *OutBuffer, int MaxLen)
+{
+	OutBuffer[0] = 0;
+	if (Buffer == NULL) return;
+	while (1) {
+		if ((*Pos) >= MaxLen) return;
+		switch (Buffer[*Pos]) {
+		case 0x00:
+			return;
+		case 0x0A:
+			if (strlen(OutBuffer) != 0) return;
+			break;
+		case 0x0D:
+			if (strlen(OutBuffer) != 0) return;
+			break;
+		default  :
+			OutBuffer[strlen(OutBuffer) + 1] = 0;
+			OutBuffer[strlen(OutBuffer)]     = Buffer[*Pos];
+		}
+		(*Pos)++;
+	}
+}
+
+void StringToDouble(char *text, double *d)
+{
+	bool 		before=true;
+	double		multiply = 1;
+	unsigned int 	i;
+
+	*d = 0;
+	for (i=0;i<strlen(text);i++) {
+		if (isdigit(text[i])) {
+			if (before) {
+				(*d)=(*d)*10+(text[i]-'0');
+			} else {
+				multiply=multiply*0.1;
+				(*d)=(*d)+(text[i]-'0')*multiply;
+			}
+		}
+		if (text[i]=='.' || text[i]==',') before=false;
+	}
+}
+
+/* When char can be converted, convert it from Unicode to UTF8 */
+bool EncodeWithUTF8Alphabet(unsigned char mychar1, unsigned char mychar2, unsigned char *ret1, unsigned char *ret2)
+{
+	unsigned char	mychar3,mychar4;
+	int		j=0;
+      
+	if (mychar1>0x00 || mychar2>128) {
+		mychar3=0x00;
+		mychar4=128;
+		while (true) {
+			if (mychar3==mychar1) {
+				if (mychar4+64>=mychar2) {
+					*ret1=j+0xc2;
+					*ret2=0x80+(mychar2-mychar4);
+					return true;
+				}
+			}
+			if (mychar4==192) {
+				mychar3++;
+				mychar4=0;
+			} else {
+				mychar4=mychar4+64;
+			}
+			j++;
+		}
+	}
+	return false;
+}
+
+/* Make UTF8 string from Unicode input string */
+bool EncodeUTF8QuotedPrintable(unsigned char *dest, const unsigned char *src)
+{
+	int		i,j=0;
+	unsigned char	mychar1, mychar2;
+	bool		retval = false;
+	
+	for (i = 0; i < (int)(UnicodeLength(src)); i++) {
+		if (EncodeWithUTF8Alphabet(src[i*2],src[i*2+1],&mychar1,&mychar2)) {
+			sprintf(dest+j, "=%02X=%02X",mychar1,mychar2);
+			j	= j+6;
+			retval  = true;
+		} else {
+			j += DecodeWithUnicodeAlphabet(((wchar_t)(src[i*2]*256+src[i*2+1])), dest + j);
+	    	}
+	}
+	dest[j++]=0;
+	return retval;
+}
+
+bool EncodeUTF8(unsigned char *dest, const unsigned char *src)
+{
+	int		i,j=0;
+	unsigned char	mychar1, mychar2;
+	bool		retval = false;
+	
+	for (i = 0; i < (int)(UnicodeLength(src)); i++) {
+		if (EncodeWithUTF8Alphabet(src[i*2],src[i*2+1],&mychar1,&mychar2)) {
+			sprintf(dest+j, "%c%c",mychar1,mychar2);
+			j	= j+2;
+			retval  = true;
+	    	} else {
+			j += DecodeWithUnicodeAlphabet(((wchar_t)(src[i*2]*256+src[i*2+1])), dest + j);
+	    	}
+	}
+	dest[j++]=0;
+	return retval;
+}
+
+/* Decode UTF8 char to Unicode char */
+wchar_t DecodeWithUTF8Alphabet(unsigned char mychar3, unsigned char mychar4)
+{
+	unsigned char	mychar1, mychar2;
+	int		j;
+	
+	mychar1=0x00;
+	mychar2=128;
+	for(j=0;j<mychar3-0xc2;j++) {
+		if (mychar2==192) {
+			mychar1++;
+			mychar2 = 0;
+		} else {
+			mychar2 = mychar2+64;
+		}
+	}
+	mychar2 = mychar2+(mychar4-0x80);
+	return mychar2 | (mychar1 << 8);
+}
+
+/* Make Unicode string from UTF8 string */
+void DecodeUTF8QuotedPrintable(unsigned char *dest, const unsigned char *src, int len)
+{
+	int 		i=0,j=0;
+	unsigned char	mychar1, mychar2;
+	wchar_t		ret;
+	
+	while (i<=len) {
+		if (len-6>=i) {
+			/* Need to have correct chars */
+			if (src[i]  =='=' && DecodeWithHexBinAlphabet(src[i+1])!=-1
+	                                  && DecodeWithHexBinAlphabet(src[i+2])!=-1 &&
+			    src[i+3]=='=' && DecodeWithHexBinAlphabet(src[i+4])!=-1 &&
+	                                     DecodeWithHexBinAlphabet(src[i+5])!=-1) {
+				mychar1	= 16*DecodeWithHexBinAlphabet(src[i+1])+DecodeWithHexBinAlphabet(src[i+2]);
+				mychar2	= 16*DecodeWithHexBinAlphabet(src[i+4])+DecodeWithHexBinAlphabet(src[i+5]);
+				ret 	= DecodeWithUTF8Alphabet(mychar1,mychar2);
+				i 	= i+6;
+			} else {
+				i+=EncodeWithUnicodeAlphabet(&src[i], &ret);
+			}   
+		} else {
+			i+=EncodeWithUnicodeAlphabet(&src[i], &ret);
+		}
+		dest[j++] = (ret >> 8) & 0xff;
+		dest[j++] = ret & 0xff;
+	}
+	dest[j++] = 0;
+	dest[j++] = 0;
+}
+
+void DecodeUTF8(unsigned char *dest, const unsigned char *src, int len)
+{
+	int 		i=0,j=0;
+	wchar_t		ret;
+	
+	while (i<=len) {
+		if (len-2>=i) {
+			if (src[i] >= 0xC2) {
+				ret 	= DecodeWithUTF8Alphabet(src[i],src[i+1]);
+				i 	= i+2;
+			} else {
+				i+=EncodeWithUnicodeAlphabet(&src[i], &ret);
+			}
+		} else {
+			i+=EncodeWithUnicodeAlphabet(&src[i], &ret);
+		}
+		dest[j++] = (ret >> 8) & 0xff;
+		dest[j++] = ret & 0xff;
+	}
+	dest[j++] = 0;
+	dest[j++] = 0;
+}
+
+void DecodeUTF7(unsigned char *dest, const unsigned char *src, int len)
+{
+	int 		i=0,j=0,z,p;
+	wchar_t		ret;
+	
+	while (i<=len) {
+		if (len-5>=i) {
+			if (src[i] == '+') {
+				z=0;
+				while (src[z+i+1] != '-' && z+i+1<len) z++;
+				p=DecodeBASE64(src+i+1, dest+j, z);
+				if (p%2 != 0) p--;
+				j+=p;
+				i+=z+2;
+			} else {
+				i+=EncodeWithUnicodeAlphabet(&src[i], &ret);
+				dest[j++] = (ret >> 8) & 0xff;
+				dest[j++] = ret & 0xff;
+			}
+		} else {
+			i+=EncodeWithUnicodeAlphabet(&src[i], &ret);
+			dest[j++] = (ret >> 8) & 0xff;
+			dest[j++] = ret & 0xff;
+		}
+	}
+	dest[j++] = 0;
+	dest[j++] = 0;
+}
+
+/*
+Bob Trower 08/04/01
+Copyright (c) Trantor Standard Systems Inc., 2001
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall
+be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
+OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+static void EncodeBASE64Block(unsigned char in[3], unsigned char out[4], int len)
+{
+	/* BASE64 translation Table as described in RFC1113 */
+	unsigned char cb64[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+	out[0] = cb64[ in[0] >> 2 ];
+	out[1] = cb64[ ((in[0] & 0x03) << 4) | ((in[1] & 0xf0) >> 4) ];
+	out[2] = (unsigned char) (len > 1 ? cb64[ ((in[1] & 0x0f) << 2) | ((in[2] & 0xc0) >> 6) ] : '=');
+	out[3] = (unsigned char) (len > 2 ? cb64[ in[2] & 0x3f ] : '=');
+}
+
+void EncodeBASE64(const unsigned char *Input, unsigned char *Output, int Length)
+{
+	unsigned char 	in[3], out[4];
+	int 		i, pos = 0, len, outpos = 0;
+
+	while (pos < Length) {
+		len = 0;
+		for (i = 0; i < 3; i++) {
+			in[i] = 0;
+			if (pos < Length) {
+				in[i] = Input[pos];
+				len++;
+				pos++;
+			}
+		}
+	        if(len) {
+			EncodeBASE64Block(in, out, len);
+			for (i = 0; i < 4; i++) Output[outpos++] = out[i];
+		}
+        }
+
+	Output[outpos++] = 0;
+}
+
+static void DecodeBASE64Block(unsigned char in[4], unsigned char out[3])
+{   
+	out[0] = (unsigned char) (in[0] << 2 | in[1] >> 4);
+	out[1] = (unsigned char) (in[1] << 4 | in[2] >> 2);
+	out[2] = (unsigned char) (((in[2] << 6) & 0xc0) | in[3]);
+}
+
+int DecodeBASE64(const unsigned char *Input, unsigned char *Output, int Length)
+{
+	unsigned char 	cd64[]="|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\\]^_`abcdefghijklmnopq";
+	unsigned char 	in[4], out[3], v;
+	int 		i, len, pos = 0, outpos = 0;
+
+	while (pos < Length) {
+		len = 0;
+	        for(i = 0; i < 4; i++) {
+	       		v = 0;
+			while(v == 0) {
+				if (pos >= Length) break;
+		                v = (unsigned char) Input[pos++];
+                		v = (unsigned char) ((v < 43 || v > 122) ? 0 : cd64[ v - 43 ]);
+				if (v) v = (unsigned char) ((v == '$') ? 0 : v - 61);
+			}
+			if(pos<=Length) {
+				if (v) {
+					len++;
+					in[i] = (unsigned char) (v - 1);
+				}
+			}
+		}
+		if (len) {
+			DecodeBASE64Block(in, out);
+			for(i = 0; i < len - 1; i++) Output[outpos++] = out[i];
+		}
+	}
+	Output[outpos] = 0;
+	return outpos;
+}
+
+/* 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/coding.h b/gammu/emb/common/misc/coding/coding.h
new file mode 100644
index 0000000..d0c334d
--- a/dev/null
+++ b/gammu/emb/common/misc/coding/coding.h
@@ -0,0 +1,133 @@
+/* (c) 2002-2004 by Marcin Wiacek and others */
+
+#ifndef __coding_h
+#define __coding_h
+
+#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);
+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);
+
+unsigned int	UnicodeLength			(const unsigned char *str);
+unsigned char	*DecodeUnicodeString		(const unsigned char *src);
+unsigned char   *DecodeUnicodeConsole		(const unsigned char *src);
+void		DecodeUnicode			(const unsigned char *src, unsigned char *dest);
+void		EncodeUnicode			(unsigned char *dest, const unsigned char *src, int len);
+
+void 		CopyUnicodeString		(unsigned char *Dest, unsigned char *Source);
+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);
+
+/* ------------------------------- 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);
+
+/* ------------------------------ UTF7 ------------------------------------- */
+void 		DecodeUTF7			(unsigned char *dest, const unsigned char *src, int len);
+
+/* ------------------------------ UTF8 ------------------------------------- */
+wchar_t		DecodeWithUTF8Alphabet		(unsigned char mychar3, unsigned char mychar4);
+bool 		EncodeWithUTF8Alphabet		(unsigned char mychar1, unsigned char mychar2, unsigned char *ret1, unsigned char *ret2);
+
+bool		EncodeUTF8QuotedPrintable	(unsigned char *dest, const unsigned char *src);
+void 		DecodeUTF8QuotedPrintable	(unsigned char *dest, const unsigned char *src, int len);
+
+bool 		EncodeUTF8			(unsigned char *dest, const unsigned char *src);
+void 		DecodeUTF8			(unsigned char *dest, const unsigned char *src, int len);
+
+/* ------------------------------- BASE64 ---------------------------------- */
+void 		EncodeBASE64			(const unsigned char *Input, unsigned char *Output, int Length);
+int 		DecodeBASE64			(const unsigned char *Input, unsigned char *Output, int Length);
+
+/* ----------------------------- HexBin ------------------------------------ */
+void		DecodeHexBin			(unsigned char *dest, const unsigned char *src, int len);
+void		EncodeHexBin			(unsigned char *dest, const unsigned char *src, int len);
+
+/* ----------------------------- HexUnicode -------------------------------- */
+void		DecodeHexUnicode		(unsigned char *dest, const unsigned char *src, int len);
+void		EncodeHexUnicode		(unsigned char *dest, const unsigned char *src, int len);
+
+/* ---------------------- DefaultAlphabet for SMS -------------------------- */
+void 		EncodeDefault			(unsigned char *dest, const unsigned char *src, int *len, bool UseExtensions, unsigned char *ExtraAlphabet);
+void		DecodeDefault			(unsigned char *dest, const unsigned char *src, int len, bool UseExtensions,  unsigned char *ExtraAlphabet);
+void 		FindDefaultAlphabetLen		(const unsigned char *src, int *srclen, int *smslen, int maxlen);
+
+int GSM_PackSevenBitsToEight	(int offset, unsigned char *input, unsigned char *output, int length);
+int GSM_UnpackEightBitsToSeven	(int offset, int in_length, int out_length,
+				 unsigned char *input, unsigned char *output);
+
+/* ----------------- Phone numbers according to GSM specs ------------------ */
+
+/**
+ * Enum to handle types of phones numbers like
+ * specified in GSM 03.40 section 9.1.2.5
+ */
+typedef enum {
+	/**
+	 * Unknown number type
+	 */
+	NUMBER_UNKNOWN		= 0x81,
+	/**
+	 * International number (full number with code of country)
+	 */
+	NUMBER_INTERNATIONAL	= 0x91,
+	/**
+	 * Alphanumeric number (with chars too)
+	 */
+	NUMBER_ALPHANUMERIC	= 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);
+
+/* ---------------------------- Bits --------------------------------------- */
+
+void BufferAlign      (unsigned char *Destination, int *CurrentBit);
+void BufferAlignNumber(int *CurrentBit);
+
+void AddBuffer	  (unsigned char *Destination, int *CurrentBit, unsigned char *Source, int BitsToProcess);
+void AddBufferByte(unsigned char *Destination, int *CurrentBit, unsigned char Source, int BitsToProcess);
+
+void GetBuffer    (unsigned char *Source, int *CurrentBit, unsigned char *Destination, int BitsToProcess);
+void GetBufferInt (unsigned char *Source, int *CurrentBit, int *integer, int BitsToProcess);
+void GetBufferI   (unsigned char *Source, int *CurrentBit, int *result, int BitsToProcess);
+
+int GetBit   (unsigned char *Buffer, int BitNum);
+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);
+
+void MyGetLine(unsigned char *Buffer, int *Pos, unsigned char *OutBuffer, int MaxLen);
+
+#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
new file mode 100644
index 0000000..30fe33f
--- a/dev/null
+++ b/gammu/emb/common/misc/coding/md5.c
@@ -0,0 +1,298 @@
+/* Taken from ReHash (see http://www.reichlsoft.de.vu/) and released
+ * under GPL/LGPL with permission from ReHash author
+ * Dominik Reichl <dominik.reichl@t-online.de>, Germany
+ */
+
+/*
+ **********************************************************************
+ ** MD5.cpp                                                          **
+ **                                                                  **
+ ** - Style modified by Tony Ray, January 2001                       **
+ **   Added support for randomizing initialization constants         **
+ ** - Style modified by Dominik Reichl, April 2003                   **
+ **   Optimized code                                                 **
+ **                                                                  **
+ ** MD5.c                                                            **
+ ** RSA Data Security, Inc. MD5 Message Digest Algorithm             **
+ ** Created: 2/17/90 RLR                                             **
+ ** Revised: 1/91 SRD,AJ,BSK,JT Reference C Version                  **
+ **********************************************************************
+ */
+
+/*
+ **********************************************************************
+ ** MD5.h -- Header file for implementation of MD5                   **
+ ** RSA Data Security, Inc. MD5 Message Digest Algorithm             **
+ ** Created: 2/17/90 RLR                                             **
+ ** Revised: 12/27/90 SRD,AJ,BSK,JT Reference C version              **
+ ** Revised (for MD5): RLR 4/27/91                                   **
+ **   -- G modified to have y&~z instead of y&z                      **
+ **   -- FF, GG, HH modified to add in last register done            **
+ **   -- Access pattern: round 2 works mod 5, round 3 works mod 3    **
+ **   -- distinct additive constant for each step                    **
+ **   -- round 4 added, working mod 7                                **
+ **********************************************************************
+ */
+
+/*
+ **********************************************************************
+ ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
+ **                                                                  **
+ ** License to copy and use this software is granted provided that   **
+ ** it is identified as the "RSA Data Security, Inc. MD5 Message     **
+ ** Digest Algorithm" in all material mentioning or referencing this **
+ ** software or this function.                                       **
+ **                                                                  **
+ ** License is also granted to make and use derivative works         **
+ ** provided that such works are identified as "derived from the RSA **
+ ** Data Security, Inc. MD5 Message Digest Algorithm" in all         **
+ ** material mentioning or referencing the derived work.             **
+ **                                                                  **
+ ** RSA Data Security, Inc. makes no representations concerning      **
+ ** either the merchantability of this software or the suitability   **
+ ** of this software for any particular purpose.  It is provided "as **
+ ** is" without express or implied warranty of any kind.             **
+ **                                                                  **
+ ** These notices must be retained in any copies of any part of this **
+ ** documentation and/or software.                                   **
+ **********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "md5.h"
+
+/* Typedef a 32 bit type */
+#ifndef UINT4
+typedef unsigned long int UINT4;
+#endif
+
+/* Data structure for MD5 (Message Digest) computation */
+typedef struct {
+	UINT4 		i[2];           /* Number of _bits_ handled mod 2^64 	*/
+	UINT4 		buf[4];         /* Scratch buffer 			*/
+	unsigned char 	in[64];         /* Input buffer 			*/
+	unsigned char 	digest[16];     /* Actual digest after MD5Final call 	*/
+} MD5_CTX;
+
+/* Padding */
+static unsigned char MD5_PADDING[64] = {
+	0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+/* MD5_F, MD5_G and MD5_H are basic MD5 functions: selection, majority, parity */
+#define MD5_F(x, y, z) (((x) & (y)) | ((~x) & (z)))
+#define MD5_G(x, y, z) (((x) & (z)) | ((y) & (~z)))
+#define MD5_H(x, y, z) ((x) ^ (y) ^ (z))
+#define MD5_I(x, y, z) ((y) ^ ((x) | (~z)))
+
+/* ROTATE_LEFT rotates x left n bits */
+#ifndef ROTATE_LEFT
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
+#endif
+
+/* MD5_FF, MD5_GG, MD5_HH, and MD5_II transformations for rounds 1, 2, 3, and 4 */
+/* Rotation is separate from addition to prevent recomputation */
+#define MD5_FF(a, b, c, d, x, s, ac) {(a) += MD5_F ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = ROTATE_LEFT ((a), (s)); (a) += (b); }
+#define MD5_GG(a, b, c, d, x, s, ac) {(a) += MD5_G ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = ROTATE_LEFT ((a), (s)); (a) += (b); }
+#define MD5_HH(a, b, c, d, x, s, ac) {(a) += MD5_H ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = ROTATE_LEFT ((a), (s)); (a) += (b); }
+#define MD5_II(a, b, c, d, x, s, ac) {(a) += MD5_I ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = ROTATE_LEFT ((a), (s)); (a) += (b); }
+
+/* Constants for transformation */
+#define MD5_S11 7  /* Round 1 */
+#define MD5_S12 12
+#define MD5_S13 17
+#define MD5_S14 22
+#define MD5_S21 5  /* Round 2 */
+#define MD5_S22 9
+#define MD5_S23 14
+#define MD5_S24 20
+#define MD5_S31 4  /* Round 3 */
+#define MD5_S32 11
+#define MD5_S33 16
+#define MD5_S34 23
+#define MD5_S41 6  /* Round 4 */
+#define MD5_S42 10
+#define MD5_S43 15
+#define MD5_S44 21
+
+/* Basic MD5 step. MD5_Transform buf based on in */
+static void MD5_Transform (UINT4 *buf, UINT4 *in)
+{
+	UINT4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
+
+	/* Round 1 */
+	MD5_FF ( a, b, c, d, in[ 0], MD5_S11, (UINT4) 3614090360u); /* 1 */
+	MD5_FF ( d, a, b, c, in[ 1], MD5_S12, (UINT4) 3905402710u); /* 2 */
+	MD5_FF ( c, d, a, b, in[ 2], MD5_S13, (UINT4)  606105819u); /* 3 */
+	MD5_FF ( b, c, d, a, in[ 3], MD5_S14, (UINT4) 3250441966u); /* 4 */
+	MD5_FF ( a, b, c, d, in[ 4], MD5_S11, (UINT4) 4118548399u); /* 5 */
+	MD5_FF ( d, a, b, c, in[ 5], MD5_S12, (UINT4) 1200080426u); /* 6 */
+	MD5_FF ( c, d, a, b, in[ 6], MD5_S13, (UINT4) 2821735955u); /* 7 */
+	MD5_FF ( b, c, d, a, in[ 7], MD5_S14, (UINT4) 4249261313u); /* 8 */
+	MD5_FF ( a, b, c, d, in[ 8], MD5_S11, (UINT4) 1770035416u); /* 9 */
+	MD5_FF ( d, a, b, c, in[ 9], MD5_S12, (UINT4) 2336552879u); /* 10 */
+	MD5_FF ( c, d, a, b, in[10], MD5_S13, (UINT4) 4294925233u); /* 11 */
+	MD5_FF ( b, c, d, a, in[11], MD5_S14, (UINT4) 2304563134u); /* 12 */
+	MD5_FF ( a, b, c, d, in[12], MD5_S11, (UINT4) 1804603682u); /* 13 */
+	MD5_FF ( d, a, b, c, in[13], MD5_S12, (UINT4) 4254626195u); /* 14 */
+	MD5_FF ( c, d, a, b, in[14], MD5_S13, (UINT4) 2792965006u); /* 15 */
+	MD5_FF ( b, c, d, a, in[15], MD5_S14, (UINT4) 1236535329u); /* 16 */
+
+	/* Round 2 */
+	MD5_GG ( a, b, c, d, in[ 1], MD5_S21, (UINT4) 4129170786u); /* 17 */
+	MD5_GG ( d, a, b, c, in[ 6], MD5_S22, (UINT4) 3225465664u); /* 18 */
+	MD5_GG ( c, d, a, b, in[11], MD5_S23, (UINT4)  643717713u); /* 19 */
+	MD5_GG ( b, c, d, a, in[ 0], MD5_S24, (UINT4) 3921069994u); /* 20 */
+	MD5_GG ( a, b, c, d, in[ 5], MD5_S21, (UINT4) 3593408605u); /* 21 */
+	MD5_GG ( d, a, b, c, in[10], MD5_S22, (UINT4)   38016083u); /* 22 */
+	MD5_GG ( c, d, a, b, in[15], MD5_S23, (UINT4) 3634488961u); /* 23 */
+	MD5_GG ( b, c, d, a, in[ 4], MD5_S24, (UINT4) 3889429448u); /* 24 */
+	MD5_GG ( a, b, c, d, in[ 9], MD5_S21, (UINT4)  568446438u); /* 25 */
+	MD5_GG ( d, a, b, c, in[14], MD5_S22, (UINT4) 3275163606u); /* 26 */
+	MD5_GG ( c, d, a, b, in[ 3], MD5_S23, (UINT4) 4107603335u); /* 27 */
+	MD5_GG ( b, c, d, a, in[ 8], MD5_S24, (UINT4) 1163531501u); /* 28 */
+	MD5_GG ( a, b, c, d, in[13], MD5_S21, (UINT4) 2850285829u); /* 29 */
+	MD5_GG ( d, a, b, c, in[ 2], MD5_S22, (UINT4) 4243563512u); /* 30 */
+	MD5_GG ( c, d, a, b, in[ 7], MD5_S23, (UINT4) 1735328473u); /* 31 */
+	MD5_GG ( b, c, d, a, in[12], MD5_S24, (UINT4) 2368359562u); /* 32 */
+
+	/* Round 3 */
+	MD5_HH ( a, b, c, d, in[ 5], MD5_S31, (UINT4) 4294588738u); /* 33 */
+	MD5_HH ( d, a, b, c, in[ 8], MD5_S32, (UINT4) 2272392833u); /* 34 */
+	MD5_HH ( c, d, a, b, in[11], MD5_S33, (UINT4) 1839030562u); /* 35 */
+	MD5_HH ( b, c, d, a, in[14], MD5_S34, (UINT4) 4259657740u); /* 36 */
+	MD5_HH ( a, b, c, d, in[ 1], MD5_S31, (UINT4) 2763975236u); /* 37 */
+	MD5_HH ( d, a, b, c, in[ 4], MD5_S32, (UINT4) 1272893353u); /* 38 */
+	MD5_HH ( c, d, a, b, in[ 7], MD5_S33, (UINT4) 4139469664u); /* 39 */
+	MD5_HH ( b, c, d, a, in[10], MD5_S34, (UINT4) 3200236656u); /* 40 */
+	MD5_HH ( a, b, c, d, in[13], MD5_S31, (UINT4)  681279174u); /* 41 */
+	MD5_HH ( d, a, b, c, in[ 0], MD5_S32, (UINT4) 3936430074u); /* 42 */
+	MD5_HH ( c, d, a, b, in[ 3], MD5_S33, (UINT4) 3572445317u); /* 43 */
+	MD5_HH ( b, c, d, a, in[ 6], MD5_S34, (UINT4)   76029189u); /* 44 */
+	MD5_HH ( a, b, c, d, in[ 9], MD5_S31, (UINT4) 3654602809u); /* 45 */
+	MD5_HH ( d, a, b, c, in[12], MD5_S32, (UINT4) 3873151461u); /* 46 */
+	MD5_HH ( c, d, a, b, in[15], MD5_S33, (UINT4)  530742520u); /* 47 */
+	MD5_HH ( b, c, d, a, in[ 2], MD5_S34, (UINT4) 3299628645u); /* 48 */
+
+	/* Round 4 */
+	MD5_II ( a, b, c, d, in[ 0], MD5_S41, (UINT4) 4096336452u); /* 49 */
+	MD5_II ( d, a, b, c, in[ 7], MD5_S42, (UINT4) 1126891415u); /* 50 */
+	MD5_II ( c, d, a, b, in[14], MD5_S43, (UINT4) 2878612391u); /* 51 */
+	MD5_II ( b, c, d, a, in[ 5], MD5_S44, (UINT4) 4237533241u); /* 52 */
+	MD5_II ( a, b, c, d, in[12], MD5_S41, (UINT4) 1700485571u); /* 53 */
+	MD5_II ( d, a, b, c, in[ 3], MD5_S42, (UINT4) 2399980690u); /* 54 */
+	MD5_II ( c, d, a, b, in[10], MD5_S43, (UINT4) 4293915773u); /* 55 */
+	MD5_II ( b, c, d, a, in[ 1], MD5_S44, (UINT4) 2240044497u); /* 56 */
+	MD5_II ( a, b, c, d, in[ 8], MD5_S41, (UINT4) 1873313359u); /* 57 */
+	MD5_II ( d, a, b, c, in[15], MD5_S42, (UINT4) 4264355552u); /* 58 */
+	MD5_II ( c, d, a, b, in[ 6], MD5_S43, (UINT4) 2734768916u); /* 59 */
+	MD5_II ( b, c, d, a, in[13], MD5_S44, (UINT4) 1309151649u); /* 60 */
+	MD5_II ( a, b, c, d, in[ 4], MD5_S41, (UINT4) 4149444226u); /* 61 */
+	MD5_II ( d, a, b, c, in[11], MD5_S42, (UINT4) 3174756917u); /* 62 */
+	MD5_II ( c, d, a, b, in[ 2], MD5_S43, (UINT4)  718787259u); /* 63 */
+	MD5_II ( b, c, d, a, in[ 9], MD5_S44, (UINT4) 3951481745u); /* 64 */
+
+	buf[0] += a;
+	buf[1] += b;
+	buf[2] += c;
+	buf[3] += d;
+}
+
+// Set pseudoRandomNumber to zero for RFC MD5 implementation
+void MD5Init (MD5_CTX *mdContext, unsigned long pseudoRandomNumber)
+{
+	mdContext->i[0] = mdContext->i[1] = (UINT4)0;
+
+	/* Load magic initialization constants */
+	mdContext->buf[0] = (UINT4)0x67452301 + (pseudoRandomNumber * 11);
+	mdContext->buf[1] = (UINT4)0xefcdab89 + (pseudoRandomNumber * 71);
+	mdContext->buf[2] = (UINT4)0x98badcfe + (pseudoRandomNumber * 37);
+	mdContext->buf[3] = (UINT4)0x10325476 + (pseudoRandomNumber * 97);
+}
+
+void MD5Update (MD5_CTX *mdContext, unsigned char *inBuf, unsigned int inLen)
+{
+	UINT4 		in[16];
+	int 		mdi = 0;
+	unsigned int 	i = 0, ii = 0;
+
+	/* Compute number of bytes mod 64 */
+	mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
+
+	/* Update number of bits */
+	if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0]) mdContext->i[1]++;
+	mdContext->i[0] += ((UINT4)inLen << 3);
+	mdContext->i[1] += ((UINT4)inLen >> 29);
+
+	while (inLen--) {
+		/* Add new character to buffer, increment mdi */
+		mdContext->in[mdi++] = *inBuf++;
+
+		/* Transform if necessary */
+		if (mdi == 0x40) {
+			for (i = 0, ii = 0; i < 16; i++, ii += 4)
+				in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
+					(((UINT4)mdContext->in[ii+2]) << 16) |
+					(((UINT4)mdContext->in[ii+1]) << 8) |
+					((UINT4)mdContext->in[ii]);
+
+			MD5_Transform (mdContext->buf, in);
+			mdi = 0;
+		}
+	}
+}
+
+void MD5Final (MD5_CTX *mdContext)
+{
+	UINT4 		in[16];
+	int 		mdi = 0;
+	unsigned int 	i = 0, ii = 0, padLen = 0;
+
+	/* Save number of bits */
+	in[14] = mdContext->i[0];
+	in[15] = mdContext->i[1];
+
+	/* Compute number of bytes mod 64 */
+	mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
+
+	/* Pad out to 56 mod 64 */
+	padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
+	MD5Update (mdContext, MD5_PADDING, padLen);
+
+	/* Append length in bits and transform */
+	for (i = 0, ii = 0; i < 14; i++, ii += 4)
+		in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
+			(((UINT4)mdContext->in[ii+2]) << 16) |
+			(((UINT4)mdContext->in[ii+1]) <<  8) |
+			((UINT4)mdContext->in[ii]);
+	MD5_Transform (mdContext->buf, in);
+
+	/* Store buffer in digest */
+	for (i = 0, ii = 0; i < 4; i++, ii += 4) {
+		mdContext->digest[ii]   = (unsigned char)( mdContext->buf[i]        & 0xFF);
+		mdContext->digest[ii+1] = (unsigned char)((mdContext->buf[i] >>  8) & 0xFF);
+		mdContext->digest[ii+2] = (unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
+		mdContext->digest[ii+3] = (unsigned char)((mdContext->buf[i] >> 24) & 0xFF);
+	}
+}
+
+void CalculateMD5(unsigned char *buffer, int length, unsigned char *checksum)
+{
+	int 		i;
+	MD5_CTX 	m_md5;
+
+	MD5Init(&m_md5, 0);
+	MD5Update(&m_md5, buffer, length);
+	MD5Final(&m_md5);
+
+	for (i = 0; i < 16; i++) sprintf(checksum+i*2,"%02X", m_md5.digest[i]);
+}
diff --git a/gammu/emb/common/misc/coding/md5.h b/gammu/emb/common/misc/coding/md5.h
new file mode 100644
index 0000000..9da9229
--- a/dev/null
+++ b/gammu/emb/common/misc/coding/md5.h
@@ -0,0 +1,6 @@
+#ifndef __md5_h
+#define __md5_h
+
+void CalculateMD5(unsigned char *buffer, int length, unsigned char *checksum);
+
+#endif
--
cgit v0.9.0.2