// Copyright © 2010 sss
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#include "commonheaders.h"


wstring new_key;
HANDLE new_key_hcnt = NULL;
boost::mutex new_key_hcnt_mutex;
bool _terminate = false;
int returnNoError(HANDLE hContact);

int RecvMsgSvc(WPARAM w, LPARAM l)
{
	CCSDATA *ccs = (CCSDATA*)l;
	if (!ccs)
		return CallService(MS_PROTO_CHAINRECV, w, l);
	PROTORECVEVENT *pre = (PROTORECVEVENT*)(ccs->lParam);
	if (!pre)
		return CallService(MS_PROTO_CHAINRECV, w, l);
	char *msg = pre->szMessage;
	if (!msg)
		return CallService(MS_PROTO_CHAINRECV, w, l);
	HANDLE hContact = ccs->hContact;


	{ //check for gpg related data
		wstring str = toUTF16(msg);
		wstring::size_type s1 = wstring::npos, s2 = wstring::npos;

		if((str.find(_T("-----PGP KEY RESPONSE-----")) != wstring::npos) && !metaIsProtoMetaContacts(ccs->hContact))
		{
			s2 = str.find(_T("-----END PGP PUBLIC KEY BLOCK-----"));
			s1 = str.find(_T("-----BEGIN PGP PUBLIC KEY BLOCK-----"));
			if(s1 != wstring::npos && s2 != wstring::npos)
			{
				s2 += _tcslen(_T("-----END PGP PUBLIC KEY BLOCK-----"));
				DBWriteContactSettingTString(hContact, szGPGModuleName, "GPGPubKey", str.substr(s1,s2-s1).c_str());
				DBWriteContactSettingByte(hContact, szGPGModuleName, "GPGEncryption", 1);
				{ //gpg execute block
					wstring cmd;
					TCHAR tmp2[MAX_PATH] = {0};
					TCHAR *ptmp;
					string output;
					DWORD exitcode;
					{
						ptmp = UniGetContactSettingUtf(NULL, szGPGModuleName, "szHomePath", _T(""));
						_tcscpy(tmp2, ptmp);
						mir_free(ptmp);
						_tcscat(tmp2, _T("\\"));
						_tcscat(tmp2, _T("temporary_exported.asc"));
						DeleteFile(tmp2);
						wfstream f(tmp2, std::ios::out);
						ptmp = UniGetContactSettingUtf(hContact, szGPGModuleName, "GPGPubKey", _T(""));
						wstring new_key = ptmp;
						mir_free(ptmp);
						f<<new_key.c_str();
						f.close();
						cmd += _T(" --batch ");
						cmd += _T(" --import \"");
						cmd += tmp2;
						cmd += _T("\"");
					}
					gpg_execution_params params;
					pxResult result;
					params.cmd = &cmd;
					params.useless = "";
					params.out = &output;
					params.code = &exitcode;
					params.result = &result;
					boost::thread gpg_thread(boost::bind(&pxEexcute_thread, &params));
					if(!gpg_thread.timed_join(boost::posix_time::seconds(10)))
					{
						gpg_thread.~thread();
						debuglog<<time_str()<<": GPG execution timed out, aborted\n";
						return 1;
					}
					if(result == pxNotFound)
						return 1;
					{
						char *tmp = NULL;
						string::size_type s = output.find("gpg: key ") + strlen("gpg: key ");
						string::size_type s2 = output.find(":", s);
						DBWriteContactSettingString(hContact, szGPGModuleName, "KeyID", output.substr(s,s2-s).c_str());
						s2+=2;
						s = output.find("“", s2);
						if(s == string::npos)
						{
							s = output.find("\"", s2);
							s += 1;
						}
						else
							s += 3;
						if((s2 = output.find("(", s)) == string::npos)
							s2 = output.find("<", s);
						else if(s2 > output.find("<", s))
							s2 = output.find("<", s);
						tmp = new char [output.substr(s,s2-s-1).length()+1];
						strcpy(tmp, output.substr(s,s2-s-1).c_str());
						mir_utf8decode(tmp, 0);
						DBWriteContactSettingString(hContact, szGPGModuleName, "KeyMainName", tmp);
						mir_free(tmp);
						if((s = output.find(")", s2)) == string::npos)
							s = output.find(">", s2);
						else if(s > output.find(">", s2))
							s = output.find(">", s2);
						s2++;
						if(output[s] == ')')
						{
							tmp = new char [output.substr(s2,s-s2).length()+1];
							strcpy(tmp, output.substr(s2,s-s2).c_str());
							mir_utf8decode(tmp, 0);
							DBWriteContactSettingString(hContact, szGPGModuleName, "KeyComment", tmp);
							mir_free(tmp);
							s+=3;
							s2 = output.find(">", s);
							tmp = new char [output.substr(s,s2-s).length()+1];
							strcpy(tmp, output.substr(s,s2-s).c_str());
							mir_utf8decode(tmp, 0);
							DBWriteContactSettingString(hContact, szGPGModuleName, "KeyMainEmail", tmp);
							mir_free(tmp);
						}
						else
						{
							tmp = new char [output.substr(s2,s-s2).length()+1];
							strcpy(tmp, output.substr(s2,s-s2).c_str());
							mir_utf8decode(tmp, 0);
							DBWriteContactSettingString(hContact, szGPGModuleName, "KeyMainEmail", output.substr(s2,s-s2).c_str());
							mir_free(tmp);
						}
						DBWriteContactSettingByte(hContact, szGPGModuleName, "bAlwatsTrust", 1);
						void setSrmmIcon(HANDLE);
						void setClistIcon(HANDLE);
						setSrmmIcon(hContact);
						setClistIcon(hContact);
						if(metaIsSubcontact(hContact))
						{
							setSrmmIcon(metaGetContact(hContact));
							setClistIcon(metaGetContact(hContact));
							HistoryLog(metaGetContact(hContact), "PGP Encryption turned on by key autoexchange feature", EVENTTYPE_MESSAGE, DBEF_READ);
						}
						HistoryLog(hContact, "PGP Encryption turned on by key autoexchange feature", EVENTTYPE_MESSAGE, 0);
					}
				}
				hcontact_data[hContact].msgs_to_ignore.push_back(msg);
				return 1;
			}
		}
		if((str.find(_T("-----END PGP PUBLIC KEY BLOCK-----")) != wstring::npos) && (str.find(_T("-----BEGIN PGP PUBLIC KEY BLOCK-----")) != wstring::npos))
		{
			s2 = str.find(_T("-----END PGP PUBLIC KEY BLOCK-----"));
			s1 = str.find(_T("-----BEGIN PGP PUBLIC KEY BLOCK-----"));
		}
		else if((str.find(_T("-----BEGIN PGP PRIVATE KEY BLOCK-----")) != wstring::npos) && (str.find(_T("-----END PGP PRIVATE KEY BLOCK-----")) != wstring::npos))
		{
			s2 = str.find(_T("-----END PGP PRIVATE KEY BLOCK-----"));
			s1 = str.find(_T("-----BEGIN PGP PRIVATE KEY BLOCK-----"));
		}
		if((s2 != wstring::npos) && (s1 != wstring::npos))
		{  //this is public key
			if(metaIsSubcontact(hContact))
				return CallService(MS_PROTO_CHAINRECV, w, l); //yet another metacontacts problem
			debuglog<<time_str()<<": info: "<<"received key from: "<<(TCHAR*)CallService(MS_CLIST_GETCONTACTDISPLAYNAME, (WPARAM)hContact, GCDNF_TCHAR)<<"\n";
			s1 = 0;
			while((s1 = str.find(_T("\r"), s1)) != wstring::npos)
			{
				str.erase(s1, 1);
			}
			void ShowNewKeyDialog();
			if((str.find(_T("-----END PGP PUBLIC KEY BLOCK-----")) != wstring::npos) && (str.find(_T("-----BEGIN PGP PUBLIC KEY BLOCK-----")) != wstring::npos))
			{
				s2 = str.find(_T("-----END PGP PUBLIC KEY BLOCK-----"));
				s1 = str.find(_T("-----BEGIN PGP PUBLIC KEY BLOCK-----"));
				s2 += _tcslen(_T("-----END PGP PUBLIC KEY BLOCK-----"));
			}
			else if((str.find(_T("-----BEGIN PGP PRIVATE KEY BLOCK-----")) != wstring::npos) && (str.find(_T("-----END PGP PRIVATE KEY BLOCK-----")) != wstring::npos))
			{
				s2 = str.find(_T("-----END PGP PRIVATE KEY BLOCK-----"));
				s1 = str.find(_T("-----BEGIN PGP PRIVATE KEY BLOCK-----"));
				s2 += _tcslen(_T("-----END PGP PRIVATE KEY BLOCK-----"));
			}
			new_key.append(str.substr(s1,s2-s1));
			new_key_hcnt_mutex.lock();
			new_key_hcnt = hContact;
			ShowNewKeyDialog();
			return CallService(MS_PROTO_CHAINRECV, w, l);
		}
		if(bAutoExchange && strstr(msg, "-----PGP KEY REQUEST-----") && isGPGConfigured())
		{
			char *tmp = UniGetContactSettingUtf(NULL, szGPGModuleName, "GPGPubKey", "");
			if(tmp[0])
			{
				DBWriteContactSettingByte(hContact, szGPGModuleName, "GPGEncryption", 0);
				string str = "-----PGP KEY RESPONSE-----";
				str.append(tmp);
				CallContactService(hContact, PSS_MESSAGE, (WPARAM)PREF_UTF, (LPARAM)str.c_str());
				DBWriteContactSettingByte(hContact, szGPGModuleName, "GPGEncryption", 1);
			}
			mir_free(tmp);
			if(!isContactHaveKey(hContact) && bAutoExchange && isGPGConfigured())
			{
				LPSTR proto = (LPSTR)CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)hContact, 0);
				DWORD uin = DBGetContactSettingDword(hContact, proto, "UIN", 0);
				if(uin)
				{
					if(ServiceExists("ICQ"PS_ICQ_CHECKCAPABILITY))
					{
						ICQ_CUSTOMCAP cap = {0};
						strcpy(cap.caps, "GPG AutoExchange");
						if(CallService("ICQ"PS_ICQ_CHECKCAPABILITY, (WPARAM)hContact, (LPARAM)&cap))
							CallContactService(hContact, PSS_MESSAGE, (WPARAM)PREF_UTF, (LPARAM)"-----PGP KEY REQUEST-----");
					}
				}
				else
				{
					TCHAR *jid = UniGetContactSettingUtf(hContact, proto, "jid", _T(""));
					if(jid[0])
					{
						extern list <JabberAccount*> Accounts;
						list<JabberAccount*>::iterator end = Accounts.end();
						for(list<JabberAccount*>::iterator p = Accounts.begin(); p != end; p++)
						{
							TCHAR *caps = (*p)->getJabberInterface()->Net()->GetResourceFeatures(jid);
							if(caps)
							{
								wstring str;
								for(int i =0;;i++)
								{
									str.push_back(caps[i]);
									if(caps[i] == '\0')
										if(caps[i+1] == '\0')
											break;
								}
								mir_free(caps);
								if(str.find(_T("GPG_Key_Auto_Exchange:0")) != string::npos)
									CallContactService(hContact, PSS_MESSAGE, (WPARAM)PREF_UTF, (LPARAM)"-----PGP KEY REQUEST-----");
							}
						}
					}
				}
			}
			return 1;
		}
		s1 = str.find(_T("-----BEGIN PGP MESSAGE-----"));
		s2 = str.find(_T("-----END PGP MESSAGE-----"));
		if((s2 != wstring::npos) && (s1 != wstring::npos))
		{ //this is generic encrypted data block
			void setSrmmIcon(HANDLE);
			void setClistIcon(HANDLE);
			bool isContactHaveKey(HANDLE hContact);
			if(!DBGetContactSettingByte(metaGetCurrent(hContact), szGPGModuleName, "GPGEncryption", 0))
			{
				debuglog<<time_str()<<": info: "<<"received message from: "<<(TCHAR*)CallService(MS_CLIST_GETCONTACTDISPLAYNAME, (WPARAM)hContact, GCDNF_TCHAR)<<" whith tyrned off encryption\n";
				if(MessageBox(0, _T("We received encrypted message from contact with encryption turned off.\nDo you want turn on encryption for this contact ?"), _T("Warning"), MB_YESNO) == IDYES)
				{
					if(!isContactHaveKey(hContact))
					{
						void ShowLoadPublicKeyDialog();
						extern map<int, HANDLE> user_data;
						extern int item_num;
						item_num = 0;		 //black magic here
						user_data[1] = hContact;
						ShowLoadPublicKeyDialog();
					}
					else
					{
						DBWriteContactSettingByte(metaGetCurrent(hContact), szGPGModuleName, "GPGEncryption", 1);
						setSrmmIcon(hContact);
						setClistIcon(hContact);
					}
					if(isContactHaveKey(hContact))
					{
						DBWriteContactSettingByte(metaGetCurrent(hContact), szGPGModuleName, "GPGEncryption", 1);
						setSrmmIcon(hContact);
						setClistIcon(hContact);
					}
				}
				else if(MessageBox(0, _T("Do you want try to decrypt encrypted message ?"), _T("Warning"), MB_YESNO) == IDNO)
					return CallService(MS_PROTO_CHAINRECV, w, l);
			}
			{
				wstring::size_type p = 0;
				while((p = str.find(_T("\r"), p)) != wstring::npos)
					str.erase(p, 1);
			}
			s2 += _tcslen(_T("-----END PGP MESSAGE-----"));
			char *tmp = mir_t2a(str.substr(s1,s2-s1).c_str());
			TCHAR *tmp2 = UniGetContactSettingUtf(NULL, szGPGModuleName, "szHomePath", _T(""));
			wstring path = tmp2;
			path.append(_T("\\encrypted_data.asc"));
			DeleteFile(path.c_str());
			fstream f(path.c_str(), std::ios::out);
			f<<tmp;
			mir_free(tmp);
			f.close();
			{
				extern TCHAR *password;
				string out;
				DWORD code;
				wstring cmd;
				cmd += _T("--batch ");
				{
					char *inkeyid = UniGetContactSettingUtf(metaGetCurrent(hContact), szGPGModuleName, "InKeyID", "");
					TCHAR *pass = NULL;
					if(strlen(inkeyid) > 0)
					{
						string dbsetting = "szKey_";
						dbsetting += inkeyid;
						dbsetting += "_Password";
						pass = UniGetContactSettingUtf(NULL, szGPGModuleName, dbsetting.c_str(), _T(""));
						if(_tcslen(pass) > 0)
							debuglog<<time_str()<<": info: found password in database for key id: "<<inkeyid<<", trying to decrypt message from "<<(TCHAR*)CallService(MS_CLIST_GETCONTACTDISPLAYNAME, (WPARAM)hContact, GCDNF_TCHAR)<<" with password\n";
					}
					else
					{
						pass = UniGetContactSettingUtf(NULL, szGPGModuleName, "szKeyPassword", _T(""));
						if(_tcslen(pass) > 0)
							debuglog<<time_str()<<": info: found password for all keys in database, trying to decrypt message from "<<(TCHAR*)CallService(MS_CLIST_GETCONTACTDISPLAYNAME, (WPARAM)hContact, GCDNF_TCHAR)<<" with password\n";
					}
					if(_tcslen(pass) > 0)
					{
						cmd += _T("--passphrase \"");
						cmd += pass;
						cmd += _T("\" ");
					}
					else if(password)
					{
						debuglog<<time_str()<<": info: found password in memory, trying to decrypt message from "<<(TCHAR*)CallService(MS_CLIST_GETCONTACTDISPLAYNAME, (WPARAM)hContact, GCDNF_TCHAR)<<" with password\n";
						cmd += _T("--passphrase \"");
						cmd += password;
						cmd += _T("\" ");
					}
					else
						debuglog<<time_str()<<": info: passwords not found in database or memory, trying to decrypt message from "<<(TCHAR*)CallService(MS_CLIST_GETCONTACTDISPLAYNAME, (WPARAM)hContact, GCDNF_TCHAR)<<" with out password\n";
					mir_free(pass);
					mir_free(inkeyid);
				}
				{
					wstring path = tmp2;
					path += _T("\\decrypted_data");
					DeleteFile(path.c_str());
				}
				cmd += _T("--output \"");
				cmd += tmp2;
				cmd += _T("\\decrypted_data\"");
				cmd += _T(" -d -a \"");
				cmd += path;
				cmd += _T("\"");
				gpg_execution_params params;
				pxResult result;
				params.cmd = &cmd;
				params.useless = "";
				params.out = &out;
				params.code = &code;
				params.result = &result;
				boost::thread *gpg_thread = new boost::thread(boost::bind(&pxEexcute_thread, &params));
				if(!gpg_thread->timed_join(boost::posix_time::seconds(10)))
				{
					delete gpg_thread;
					debuglog<<time_str()<<": GPG execution timed out, aborted\n";
					DeleteFile(path.c_str());
					return CallService(MS_PROTO_CHAINRECV, w, l);
				}
				if(result == pxNotFound)
				{
					DeleteFile(path.c_str());
					return CallService(MS_PROTO_CHAINRECV, w, l);
				}
				_terminate = false;
				while(out.find("public key decryption failed: bad passphrase") != string::npos)
				{
					debuglog<<time_str()<<": info: failed to decrypt messaage from "<<(TCHAR*)CallService(MS_CLIST_GETCONTACTDISPLAYNAME, (WPARAM)hContact, GCDNF_TCHAR)<<" password needed, trying to get one\n";
					if(_terminate)
						break;
					{ //save inkey id
						string::size_type s = out.find(" encrypted with ");
						s = out.find(" ID ", s);
						s += strlen(" ID ");
						string::size_type s2 = out.find(",",s);
						DBWriteContactSettingString(metaGetCurrent(hContact), szGPGModuleName, "InKeyID", out.substr(s, s2-s).c_str());
					}
					void ShowLoadKeyPasswordWindow();
					new_key_hcnt_mutex.lock();
					new_key_hcnt = hContact;
					ShowLoadKeyPasswordWindow();
					wstring cmd2 = cmd;
					if(password)
					{
						debuglog<<time_str()<<": info: found password in memory, trying to decrypt message from "<<(TCHAR*)CallService(MS_CLIST_GETCONTACTDISPLAYNAME, (WPARAM)hContact, GCDNF_TCHAR)<<"\n";
						wstring tmp = _T("--passphrase \"");
						tmp += password;
						tmp += _T("\" ");
						cmd2.insert(0, tmp);
					}
					out.clear();
					gpg_execution_params params;
					pxResult result;
					params.cmd = &cmd2;
					params.useless = "";
					params.out = &out;
					params.code = &code;
					params.result = &result;
					gpg_thread = gpg_thread = new boost::thread(boost::bind(&pxEexcute_thread, &params));
					if(!gpg_thread->timed_join(boost::posix_time::seconds(10)))
					{
						delete gpg_thread;
						debuglog<<time_str()<<": GPG execution timed out, aborted\n";
						DeleteFile(path.c_str());
						return CallService(MS_PROTO_CHAINRECV, w, l);
					}
					if(result == pxNotFound)
					{
						DeleteFile(path.c_str());
						return CallService(MS_PROTO_CHAINRECV, w, l);
					}
				}
				out.clear();
				gpg_thread = new boost::thread(boost::bind(&pxEexcute_thread, &params));
				if(!gpg_thread->timed_join(boost::posix_time::seconds(10)))
				{
					delete gpg_thread;
					debuglog<<time_str()<<": GPG execution timed out, aborted\n";
					DeleteFile(path.c_str());
					return CallService(MS_PROTO_CHAINRECV, w, l);
				}
				if(result == pxNotFound)
				{
					DeleteFile(path.c_str());
					return CallService(MS_PROTO_CHAINRECV, w, l);
				}
				{
					wstring tmp = tmp2;
					tmp += _T("\\encrypted_data.asc");
					DeleteFile(tmp.c_str());
				}
				{
					wstring tmp = tmp2;
					tmp += _T("\\decrypted_data");
					if(_waccess(tmp.c_str(), 0) == -1)
					{
						if(errno == ENOENT)
						{
							string str = pre->szMessage;
							mir_free((void**)pre->szMessage);
							str.insert(0, "Received unencrypted message:\n");
							debuglog<<time_str()<<": info: Failed to decrypt GPG encrypted message.\n";
							char *tmp = new char [str.length()+1];
							strcpy(tmp, str.c_str());
							pre->szMessage = tmp;
							return CallService(MS_PROTO_CHAINRECV, w, (LPARAM)ccs);
						}
					}
				}

				
				str.clear();
				{
					wstring path = tmp2;
					mir_free(tmp2);
					path += _T("\\decrypted_data");
					fstream f(path.c_str(), std::ios::in | std::ios::ate | std::ios::binary);
					if(f.is_open())
					{
						std::wifstream::pos_type size = f.tellg();
						char *tmp = new char [(std::ifstream::pos_type)size+(std::ifstream::pos_type)1];
						f.seekg(0, std::ios::beg);
						f.read(tmp, size);
						tmp[size] = '\0';
						toUTF16(tmp);
						str.append(toUTF16(tmp));
						delete [] tmp;
						f.close();
						DeleteFile(path.c_str());
					}
					if(str.empty())
					{
						string str = pre->szMessage;
						mir_free((void**)pre->szMessage);
						str.insert(0, "Failed to decrypt GPG encrypted message.\nReceived unencrypted message:\n");
						debuglog<<time_str()<<": info: Failed to decrypt GPG encrypted message.\n";
						pre->szMessage = mir_strdup(str.c_str());
						return CallService(MS_PROTO_CHAINRECV, w, (LPARAM)ccs);
					}
					else
					{
						mir_free((void**)pre->szMessage);
						if(bAppendTags)
						{
							str.insert(0, inopentag);
							str.append(inclosetag);
						}
						pre->szMessage = mir_strdup(toUTF8(str).c_str());
						if(metaIsSubcontact(hContact))
						{
							char *msg = mir_strdup(toUTF8(str).c_str());
							HistoryLog(hContact, msg, EVENTTYPE_MESSAGE, DBEF_UTF);
							HistoryLog(metaGetContact(hContact), msg, EVENTTYPE_MESSAGE, DBEF_UTF);
							mir_free(msg);
							return 1;
						}
						return CallService(MS_PROTO_CHAINRECV, w, (LPARAM)ccs);
					}
				}
			}
		}
	}
	if(DBGetContactSettingByte(metaGetCurrent(hContact), szGPGModuleName, "GPGEncryption", 0))
	{
		if(metaIsSubcontact(hContact))
		{
			HistoryLog(hContact, msg, EVENTTYPE_MESSAGE, DBEF_UTF);
			HistoryLog(metaGetContact(hContact), msg, EVENTTYPE_MESSAGE, DBEF_UTF);
			mir_free(msg);
			return 1;
		}
		string str = msg;
		mir_free((void**)pre->szMessage);
		str.insert(0, "Received unencrypted message:\n");
		pre->szMessage = mir_strdup(str.c_str());
		return CallService(MS_PROTO_CHAINRECV, w, (LPARAM)ccs);
	}
	return CallService(MS_PROTO_CHAINRECV, w, l);
}

int SendMsgSvc(WPARAM w, LPARAM l)
{
	CCSDATA *ccs = (CCSDATA*)l;
	if (!ccs)
		return CallService(MS_PROTO_CHAINSEND, w, l);

	char *msg = (char*)(ccs->lParam);
	if (!msg)
		return CallService(MS_PROTO_CHAINSEND, w, l);
	if(strstr(msg,"-----BEGIN PGP MESSAGE-----")) //metecontacts .... %)
		return CallService(MS_PROTO_CHAINSEND, w, l);
	HANDLE hContact = ccs->hContact;
	if(metaIsProtoMetaContacts(hContact))
	{
		hcontact_data[ccs->hContact].msgs_to_ignore.push_back((char*)ccs->lParam);
		return CallService(MS_PROTO_CHAINSEND, w, l); 
	}
	if(!isContactHaveKey(hContact) && bAutoExchange && !strstr(msg, "-----PGP KEY REQUEST-----") && !strstr(msg, "-----BEGIN PGP PUBLIC KEY BLOCK-----") && isGPGConfigured()) //TODO: add all mesages to list, and send after key exchange done, encrypted
	{
		void send_encrypted_msgs_thread(HANDLE hContact);
		LPSTR proto = (LPSTR)CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)hContact, 0);
		DWORD uin = DBGetContactSettingDword(hContact, proto, "UIN", 0);
		if(uin)
		{
			if(ServiceExists("ICQ"PS_ICQ_CHECKCAPABILITY))
			{
				ICQ_CUSTOMCAP cap = {0};
				strcpy(cap.caps, "GPG AutoExchange");
				if(CallService("ICQ"PS_ICQ_CHECKCAPABILITY, (WPARAM)hContact, (LPARAM)&cap))
				{
					CallContactService(hContact, PSS_MESSAGE, (WPARAM)PREF_UTF, (LPARAM)"-----PGP KEY REQUEST-----");
					hcontact_data[hContact].msgs_to_ignore.push_back(msg);
					hcontact_data[hContact].msgs_to_send.push_back(msg);
					boost::thread *thr = new boost::thread(boost::bind(send_encrypted_msgs_thread, hContact));
					return returnNoError(hContact);
				}
			}
		}
		else
		{
			TCHAR *jid = UniGetContactSettingUtf(hContact, proto, "jid", _T(""));
			if(jid[0])
			{
				extern list <JabberAccount*> Accounts;
				list<JabberAccount*>::iterator end = Accounts.end();
				for(list<JabberAccount*>::iterator p = Accounts.begin(); p != end; p++)
				{
					TCHAR *caps = (*p)->getJabberInterface()->Net()->GetResourceFeatures(jid);
					if(caps)
					{
						wstring str;
						for(int i =0;;i++)
						{
							str.push_back(caps[i]);
							if(caps[i] == '\0')
								if(caps[i+1] == '\0')
									break;
						}
						mir_free(caps);
						if(str.find(_T("GPG_Key_Auto_Exchange:0")) != string::npos)
						{
							CallContactService(hContact, PSS_MESSAGE, (WPARAM)PREF_UTF, (LPARAM)"-----PGP KEY REQUEST-----");
							hcontact_data[hContact].msgs_to_ignore.push_back(msg);
							hcontact_data[hContact].msgs_to_send.push_back(msg);
							boost::thread *thr = new boost::thread(boost::bind(send_encrypted_msgs_thread, hContact));
							return returnNoError(hContact);
						}
					}
				}
			}
		}
	}
	if(!isContactSecured(hContact))
		return CallService(MS_PROTO_CHAINSEND, w, l); 


	{ //encrypt data here
		wstring str = toUTF16(msg);
		{ //not xmpp, just replace whole message
			string out;
			DWORD code;
			wstring cmd;
			wstring path;
			extern bool bJabberAPI, bIsMiranda09;
			char *tmp = UniGetContactSettingUtf(hContact, szGPGModuleName, "KeyID", "");
			if(!tmp[0])
			{
				mir_free(tmp);
				HistoryLog(hContact, "Failed to encrypt message with GPG", EVENTTYPE_MESSAGE, DBEF_SENT);
				return CallService(MS_PROTO_CHAINSEND, w, l);
			}
			if(!bJabberAPI || !bIsMiranda09) //force jabber to handle encrypted message by itself
				cmd += _T("--comment \"\" --no-version ");
			if(DBGetContactSettingByte(hContact, szGPGModuleName, "bAlwaysTrust", 0))
				cmd += _T("--trust-model always ");
			cmd += _T("--batch --yes -e -a -r ");
			TCHAR *tmp2 = mir_a2t(tmp);
			mir_free(tmp);
			cmd += tmp2;
			mir_free(tmp2);
			cmd += _T(" \"");
			tmp2 = UniGetContactSettingUtf(NULL, szGPGModuleName, "szHomePath", _T(""));
			path.append(tmp2);
			cmd += tmp2;
			mir_free(tmp2);
			cmd += _T("\\exported_data");
			path.append(_T("\\exported_data"));
			cmd += _T("\"");
			{
				char *tmp;
				tmp = mir_strdup(toUTF8(str).c_str());
				fstream f(path.c_str(), std::ios::out);
				f<<tmp;
				mir_free(tmp);
				f.close();
			}
			gpg_execution_params params;
			pxResult result;
			params.cmd = &cmd;
			params.useless = "";
			params.out = &out;
			params.code = &code;
			params.result = &result;
			boost::thread gpg_thread(boost::bind(&pxEexcute_thread, &params));
			if(!gpg_thread.timed_join(boost::posix_time::seconds(10)))
			{
				gpg_thread.~thread();
				debuglog<<time_str()<<": GPG execution timed out, aborted\n";
				return CallService(MS_PROTO_CHAINSEND, w, l);
			}
			if(result == pxNotFound)
				return CallService(MS_PROTO_CHAINSEND, w, l);
			if(out.find("There is no assurance this key belongs to the named user") != string::npos)
			{
				out.clear();
				if(MessageBox(0, _T("We trying to encrypt with untrusted key, do you want to trust this key permanently ?"), _T("Warning"), MB_YESNO) == IDYES)
				{
					DBWriteContactSettingByte(hContact, szGPGModuleName, "bAlwaysTrust", 1);
					cmd.insert(0, _T("--trust-model always "));
					gpg_execution_params params;
					pxResult result;
					params.cmd = &cmd;
					params.useless = "";
					params.out = &out;
					params.code = &code;
					params.result = &result;
					boost::thread gpg_thread(boost::bind(&pxEexcute_thread, &params));
					if(!gpg_thread.timed_join(boost::posix_time::seconds(10)))
					{
						gpg_thread.~thread();
						debuglog<<time_str()<<": GPG execution timed out, aborted\n";
						return CallService(MS_PROTO_CHAINSEND, w, l);
					}
					if(result == pxNotFound)
						return CallService(MS_PROTO_CHAINSEND, w, l);
				}
				else
					return 0;
			}
			if(out.find("usage: ") != string::npos)
			{
				MessageBox(0, _T("Something wrong, gpg does not understand us, aborting encrypting."), _T("Warning"), MB_OK);
				DeleteFile(path.c_str());
				return CallService(MS_PROTO_CHAINSEND, w, l);
			}
			DeleteFile(path.c_str());
			path.append(_T(".asc"));
			wfstream f(path.c_str(), std::ios::in | std::ios::ate | std::ios::binary);
			str.clear();
			if(f.is_open())
			{
				std::wifstream::pos_type size = f.tellg();
				TCHAR *tmp = new TCHAR [(std::ifstream::pos_type)size+(std::ifstream::pos_type)1];
				f.seekg(0, std::ios::beg);
				f.read(tmp, size);
				tmp[size]= '\0';
				str.append(tmp);
				delete [] tmp;
				f.close();
				DeleteFile(path.c_str());
			}
			if(str.empty())
			{
				HistoryLog(hContact, "Failed to encrypt message with GPG", EVENTTYPE_MESSAGE, DBEF_SENT);
				debuglog<<time_str()<<": info: Failed to encrypt message with GPG";
				return CallService(MS_PROTO_CHAINRECV, w, (LPARAM)ccs);
			}
			if(metaIsSubcontact(hContact))
			{ //dirty hack to avoid metacontacts problem ..., this also broke filters chain
				string str_event = (char*)ccs->lParam;
				if(bAppendTags)
				{
					str_event.insert(0, toUTF8(outopentag));
					str_event.append(toUTF8(outclosetag));
				}
				HistoryLog(hContact, (char*)str_event.c_str(), EVENTTYPE_MESSAGE, DBEF_SENT | DBEF_UTF);
				HistoryLog(metaGetContact(hContact), (char*)str_event.c_str(), EVENTTYPE_MESSAGE, DBEF_SENT | DBEF_UTF);				
				hcontact_data[hContact].msgs_to_ignore.push_back((char*)ccs->lParam);
				hcontact_data[metaGetContact(hContact)].msgs_to_ignore.push_back((char*)ccs->lParam); //hmm, twice ? metacontacts !! %)
				CallContactService(hContact, PSS_MESSAGE, (WPARAM)PREF_UTF, (LPARAM)toUTF8(str).c_str());
				return returnNoError(hContact);
			}
			if(bAppendTags)
				hcontact_data[hContact].msgs_to_tag.push_back((char*)ccs->lParam);
			ccs->lParam = (LPARAM)mir_strdup(toUTF8(str).c_str());
		}		
	}
	return CallService(MS_PROTO_CHAINSEND, w, l);
}

int HookSendMsg(WPARAM w, LPARAM l)
{ //TODO: implement additional filtering for metacontacts data...
	if(!l)
		return 0;
	DBEVENTINFO * dbei = (DBEVENTINFO*)l;
	if((dbei->eventType == EVENTTYPE_MESSAGE) && (dbei->flags & DBEF_SENT))
	{
		if(strstr((char*)dbei->pBlob, "-----BEGIN PGP MESSAGE-----") || strstr((char*)dbei->pBlob, "-----PGP KEY RESPONSE-----") || strstr((char*)dbei->pBlob, "-----PGP KEY REQUEST-----") || strstr((char*)dbei->pBlob, "-----PGP KEY RESPONSE-----")) //grrrr!
			return 1;
		HANDLE hContact = NULL;
		if(!hcontact_data[(HANDLE)w].msgs_to_ignore.empty())
			hContact = (HANDLE)w;
		else if(!hcontact_data[metaGetContact((HANDLE)w)].msgs_to_ignore.empty())
			hContact = metaGetContact((HANDLE)w);
		if(hContact)		
		{
			list<string>::iterator end = hcontact_data[hContact].msgs_to_ignore.end();
			for(list<string>::iterator p = hcontact_data[hContact].msgs_to_ignore.begin(); p != end; p++)
			{
				if(*p == (char*)dbei->pBlob)
				{
					hcontact_data[hContact].msgs_to_ignore.erase(p);
					return 1;
				}
			}
		}
	}
	HANDLE hContact = (HANDLE)w;


	if(metaIsProtoMetaContacts(hContact))
		hContact = metaGetCurrent(hContact); 
	if(!DBGetContactSettingByte(hContact, szGPGModuleName, "GPGEncryption", 0))
		return 0;

	if(bAppendTags)
	{
		if((dbei->eventType == EVENTTYPE_MESSAGE) && (dbei->flags & DBEF_SENT))
		{
			if(!hcontact_data[hContact].msgs_to_tag.empty())
			{
				std::list<string>::iterator end = hcontact_data[hContact].msgs_to_tag.end();
				for(std::list<string>::iterator i = hcontact_data[hContact].msgs_to_tag.begin(); i != end; ++i)
				{
					if(*i == (char*)dbei->pBlob)
					{
						char *msg = (char*)dbei->pBlob;
						wstring str = toUTF16(msg);
						str.insert(0, outopentag);
						str.append(outclosetag);
						char *msg2 = mir_strdup(toUTF8(str).c_str());
						mir_free(dbei->pBlob);
						dbei->pBlob = (PBYTE)msg2;
						dbei->cbBlob = strlen(msg2)+1;
						hcontact_data[hContact].msgs_to_tag.erase(i);
						break;
					}
				}
			}
		}
	}
	if((dbei->eventType == EVENTTYPE_MESSAGE) && !(dbei->flags & DBEF_SENT) && metaIsProtoMetaContacts((HANDLE)w))
	{
		char tmp[29];
		strncpy(tmp, (char*)dbei->pBlob, 27);
		tmp[28] = '\0';
		if(strstr(tmp, "-----BEGIN PGP MESSAGE-----"))
			return 1;
	}
	return 0;
}

int TestHook(WPARAM w, LPARAM l)
{
	return 0;
}


static BOOL CALLBACK DlgProcKeyPassword(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	char *inkeyid = UniGetContactSettingUtf(new_key_hcnt, szGPGModuleName, "InKeyID", "");
	new_key_hcnt_mutex.unlock();
	TCHAR *tmp = NULL;
	
  switch (msg)
  {
  case WM_INITDIALOG:
    {
		TranslateDialogDefault(hwndDlg);
		string questionstr = "Please enter password for key with ID: ";
		questionstr += inkeyid;
		SetDlgItemTextA(hwndDlg, IDC_KEYID, questionstr.c_str());
		EnableWindow(GetDlgItem(hwndDlg, IDC_DEFAULT_PASSWORD), 0);
      return TRUE;
    }
    
 
  case WM_COMMAND:
    {
      switch (LOWORD(wParam))
      {
      case IDOK:
        {
			TCHAR tmp[64];
			GetDlgItemText(hwndDlg, IDC_KEY_PASSWORD, tmp, 64);
			if(_tcslen(tmp) > 0)
			{
				extern TCHAR *password;
				if(IsDlgButtonChecked(hwndDlg, IDC_SAVE_PASSWORD))
				{
					if((strlen(inkeyid) > 0) && !IsDlgButtonChecked(hwndDlg, IDC_DEFAULT_PASSWORD))
					{
						string dbsetting = "szKey_";
						dbsetting += inkeyid;
						dbsetting += "_Password";
						DBWriteContactSettingTString(NULL, szGPGModuleName, dbsetting.c_str(), tmp);
					}
					else
						DBWriteContactSettingTString(NULL, szGPGModuleName, "szKeyPassword", tmp);
				}
				if(password)
					delete [] password;
				password = new TCHAR [_tcslen(tmp)+1];
				_tcscpy(password, tmp);
			}
			mir_free(tmp);
			mir_free(inkeyid);
			DestroyWindow(hwndDlg);
          break;
        }
	  case IDCANCEL:
		  mir_free(inkeyid);
		  _terminate = true;
		  DestroyWindow(hwndDlg);
		  break;
	  default:
		break;
      }
      
      break;
    }
    
  case WM_NOTIFY:
    {
/*      switch (((LPNMHDR)lParam)->code)
      {
	  default:
		  EnableWindow(GetDlgItem(hwndDlg, IDC_DEFAULT_PASSWORD), IsDlgButtonChecked(hwndDlg, IDC_SAVE_PASSWORD)?1:0);
		  break;
      }*/
	}
    break;
  case WM_CLOSE:
	  mir_free(inkeyid);
	  DestroyWindow(hwndDlg);
	  break;
  case WM_DESTROY:
	  break;

  }
  return FALSE;
}

void ShowLoadKeyPasswordWindow()
{
	extern HINSTANCE hInst;
	DialogBox(hInst, MAKEINTRESOURCE(IDD_KEY_PASSWD), NULL, (DLGPROC)DlgProcKeyPassword);
}