/*
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 "skype.h"
#include "debug.h"
#include "skypeapi.h"
#include "skypesvc.h"
#include "contacts.h"
#include "utf8.h"
#include "pthread.h"
#include "gchat.h"
#include "m_toptoolbar.h"
#include "voiceservice.h"
#include "msglist.h"
#include "memlist.h"
#include <sys/timeb.h>
#ifndef INVALID_FILE_ATTRIBUTES
#define INVALID_FILE_ATTRIBUTES 0xFFFFFFFF
#endif
/*#ifdef _WIN64
#pragma comment (lib, "bufferoverflowU.lib")
#endif*/
#pragma warning (disable: 4706) // assignment within conditional expression
POPUPDATAT MessagePopup;
// Exported Globals
HWND hSkypeWnd=NULL, g_hWnd=NULL, hSkypeWndSecondary=NULL, hForbiddenSkypeWnd = NULL;
HANDLE SkypeReady, SkypeMsgReceived, hInitChat=NULL, httbButton=NULL, FetchMessageEvent=NULL;
BOOL SkypeInitialized=FALSE, MirandaShuttingDown=FALSE, PopupServiceExists=FALSE;
BOOL UseSockets=FALSE, bSkypeOut=FALSE, bProtocolSet=FALSE, bIsImoproxy=FALSE;
char skype_path[MAX_PATH], protocol=2, *pszProxyCallout=NULL, g_szProtoName[_MAX_FNAME]="SKYPE";
int SkypeStatus=ID_STATUS_OFFLINE, hSearchThread=-1, receivers=1;
long sendwatchers = 0, rcvwatchers = 0;
UINT ControlAPIAttach, ControlAPIDiscover;
LONG AttachStatus=-1;
HINSTANCE hInst;
HANDLE hProtocolAvatarsFolder;
char DefaultAvatarsFolder[MAX_PATH+1];
DWORD mirandaVersion;
int hLangpack = 0;
CRITICAL_SECTION RingAndEndcallMutex, QueryThreadMutex, TimeMutex;
// Module Internal Globals
HANDLE MessagePumpReady;
HANDLE hChatEvent=NULL, hChatMenu=NULL;
HANDLE hEvInitChat=NULL, hBuddyAdded=NULL;
HANDLE hMenuAddSkypeContact=NULL;
DWORD msgPumpThreadId = 0;
#ifdef SKYPEBUG_OFFLN
HANDLE GotUserstatus;
#endif
BOOL bModulesLoaded=FALSE;
char *RequestedStatus=NULL; // To fix Skype-API Statusmode-bug
char cmdMessage[12]="MESSAGE", cmdPartner[8]="PARTNER"; // Compatibility commands
// Direct assignment of user properties to a DB-Setting
static const settings_map m_settings[]= {
{"LANGUAGE", "Language1"},
{"PROVINCE", "State"},
{"CITY", "City"},
{"PHONE_HOME", "Phone"},
{"PHONE_OFFICE", "CompanyPhone"},
{"PHONE_MOBILE", "Cellular"},
{"HOMEPAGE", "Homepage"},
{"ABOUT", "About"}
};
// Imported Globals
extern status_map status_codes[];
BOOL (WINAPI *MyEnableThemeDialogTexture)(HANDLE, DWORD) = 0;
HMODULE hUxTheme = 0;
// function pointers, use typedefs for casting to shut up the compiler when using GetProcAddress()
typedef BOOL (WINAPI *PITA)();
typedef HANDLE (WINAPI *POTD)(HWND, LPCWSTR);
typedef UINT (WINAPI *PDTB)(HANDLE, HDC, int, int, RECT *, RECT *);
typedef UINT (WINAPI *PCTD)(HANDLE);
typedef UINT (WINAPI *PDTT)(HANDLE, HDC, int, int, LPCWSTR, int, DWORD, DWORD, RECT *);
PITA pfnIsThemeActive = 0;
POTD pfnOpenThemeData = 0;
PDTB pfnDrawThemeBackground = 0;
PCTD pfnCloseThemeData = 0;
PDTT pfnDrawThemeText = 0;
#define FIXED_TAB_SIZE 100 // default value for fixed width tabs
typedef struct {
char msgnum[16];
BOOL getstatus;
BOOL bIsRead;
BOOL bDontMarkSeen;
BOOL QueryMsgDirection;
TYP_MSGLENTRY *pMsgEntry;
} fetchmsg_arg;
typedef struct {
HANDLE hContact;
char szId[16];
} msgsendwt_arg;
/*
* visual styles support (XP+)
* returns 0 on failure
*/
int InitVSApi()
{
if((hUxTheme = LoadLibraryA("uxtheme.dll")) == 0)
return 0;
pfnIsThemeActive = (PITA)GetProcAddress(hUxTheme, "IsThemeActive");
pfnOpenThemeData = (POTD)GetProcAddress(hUxTheme, "OpenThemeData");
pfnDrawThemeBackground = (PDTB)GetProcAddress(hUxTheme, "DrawThemeBackground");
pfnCloseThemeData = (PCTD)GetProcAddress(hUxTheme, "CloseThemeData");
pfnDrawThemeText = (PDTT)GetProcAddress(hUxTheme, "DrawThemeText");
MyEnableThemeDialogTexture = (BOOL (WINAPI *)(HANDLE, DWORD))GetProcAddress(hUxTheme, "EnableThemeDialogTexture");
if(pfnIsThemeActive != 0 && pfnOpenThemeData != 0 && pfnDrawThemeBackground != 0 && pfnCloseThemeData != 0 && pfnDrawThemeText != 0) {
return 1;
}
return 0;
}
/*
* unload uxtheme.dll
*/
int FreeVSApi()
{
if(hUxTheme != 0)
FreeLibrary(hUxTheme);
return 0;
}
// Plugin Info
PLUGININFOEX pluginInfo = {
sizeof(PLUGININFOEX),
"Skype Protocol",
PLUGIN_MAKE_VERSION(0,0,0,52),
"Support for Skype network",
"leecher - tweety - jls17",
"leecher@dose.0wnz.at - tweety@user.berlios.de",
"� 2004-2011 leecher - tweety",
"http://developer.berlios.de/projects/mgoodies/",
UNICODE_AWARE,
{ 0xa71f8335, 0x7b87, 0x4432, { 0xb8, 0xa3, 0x81, 0x47, 0x94, 0x31, 0xc6, 0xf5 } } // {A71F8335-7B87-4432-B8A3-81479431C6F5}
};
#define MAPDND 1 // Map Occupied to DND status and say that you support it
//#define MAPNA 1 // Map NA status to Away and say that you support it
/* P R O G R A M */
void RegisterToDbeditorpp(void)
{
// known modules list
if (ServiceExists("DBEditorpp/RegisterSingleModule"))
CallService("DBEditorpp/RegisterSingleModule", (WPARAM)SKYPE_PROTONAME, 0);
}
/*void RegisterToUpdate(void)
{
//Use for the Updater plugin
if(ServiceExists(MS_UPDATE_REGISTER))
{
Update update = {0};
char szVersion[16];
update.szComponentName = pluginInfo.shortName;
update.pbVersion = (BYTE *)CreateVersionStringPlugin((PLUGININFO *)&pluginInfo, szVersion);
update.cpbVersion = (DWORD)strlen((char *)update.pbVersion);
#ifdef _WIN64
#ifdef _UNICODE
update.szBetaUpdateURL = "http://dose.0wnz.at/miranda/Skype/Skype_protocol_unicode_x64.zip";
#else
update.szBetaUpdateURL = "http://dose.0wnz.at/miranda/Skype/Skype_protocol_x64.zip";
#endif
update.szBetaVersionURL = "http://dose.0wnz.at/miranda/Skype/";
update.pbBetaVersionPrefix = (BYTE *)"SKYPE version ";
update.szUpdateURL = update.szBetaUpdateURL; // FIXME!!
update.szVersionURL = update.szBetaVersionURL; // FIXME
update.pbVersionPrefix = update.pbBetaVersionPrefix; //FIXME
#else
#ifdef _UNICODE
update.szBetaUpdateURL = "http://dose.0wnz.at/miranda/Skype/Skype_protocol_unicode.zip";
#else
update.szBetaUpdateURL = "http://dose.0wnz.at/miranda/Skype/Skype_protocol.zip";
#endif
update.szBetaVersionURL = "http://dose.0wnz.at/miranda/Skype/";
update.pbBetaVersionPrefix = (BYTE *)"SKYPE version ";
#ifdef _UNICODE
update.szUpdateURL = update.szBetaUpdateURL; // FIXME!!
update.szVersionURL = update.szBetaVersionURL; // FIXME
update.pbVersionPrefix = update.pbBetaVersionPrefix; //FIXME
#else
update.szUpdateURL = "http://addons.miranda-im.org/feed.php?dlfile=3200";
update.szVersionURL = "http://addons.miranda-im.org/details.php?action=viewfile&id=3200";
update.pbVersionPrefix = (BYTE *)"<span class=\"fileNameHeader\">Skype Protocol</span>";
#endif
#endif
update.cpbVersionPrefix = (DWORD)strlen((char *)update.pbVersionPrefix);
update.cpbBetaVersionPrefix = (DWORD)strlen((char *)update.pbBetaVersionPrefix);
CallService(MS_UPDATE_REGISTER, 0, (WPARAM)&update);
}
}*/
/*
* ShowMessage
*
* Shows a popup, if the popup plugin is enabled.
* mustShow: 1 -> If Popup-Plugin is not available/disabled, show Message
* in a Messagewindow
* If the Popup-Plugin is enabled, let the message stay on
* screen until someone clicks it away.
* 0 -> If Popup-Plugin is not available/disabled, skip message
* Returns 0 on success, -1 on failure
*
*/
int ShowMessage(int iconID, TCHAR *lpzText, int mustShow) {
if (DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "SuppressErrors", 0)) return -1;
lpzText=TranslateTS(lpzText);
if (bModulesLoaded && PopupServiceExists && ServiceExists(MS_POPUP_ADDPOPUPT) && DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "UsePopup", 0) && !MirandaShuttingDown) {
BOOL showPopup, popupWindowColor;
unsigned int popupBackColor, popupTextColor;
int popupTimeSec;
popupTimeSec = DBGetContactSettingDword(NULL, SKYPE_PROTONAME, "popupTimeSecErr", 4);
popupTextColor = DBGetContactSettingDword(NULL, SKYPE_PROTONAME, "popupTextColorErr", GetSysColor(COLOR_WINDOWTEXT));
popupBackColor = DBGetContactSettingDword(NULL, SKYPE_PROTONAME, "popupBackColorErr", GetSysColor(COLOR_BTNFACE));
popupWindowColor = ( 0 != DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "popupWindowColorErr", TRUE));
showPopup = ( 0 != DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "showPopupErr", TRUE));
MessagePopup.lchContact = NULL;
MessagePopup.lchIcon = LoadIcon(hInst,MAKEINTRESOURCE(iconID));
MessagePopup.colorBack = ! popupWindowColor ? popupBackColor : GetSysColor(COLOR_BTNFACE);
MessagePopup.colorText = ! popupWindowColor ? popupTextColor : GetSysColor(COLOR_WINDOWTEXT);
MessagePopup.iSeconds = popupTimeSec;
MessagePopup.PluginData = (void *)1;
lstrcpy(MessagePopup.lptzText, lpzText);
#ifdef _UNICODE
mbstowcs (MessagePopup.lptzContactName, SKYPE_PROTONAME, strlen(SKYPE_PROTONAME)+1);
#else
lstrcpy(MessagePopup.lptzContactName, SKYPE_PROTONAME);
#endif
if(showPopup)
CallService(MS_POPUP_ADDPOPUPT,(WPARAM)&MessagePopup,0);
return 0;
}
else {
if (mustShow==1) MessageBox(NULL,lpzText,_T("Skype Protocol"), MB_OK | MB_ICONWARNING);
return 0;
}
}
#ifdef _UNICODE
int ShowMessageA(int iconID, char *lpzText, int mustShow) {
WCHAR *lpwText;
int iRet;
size_t len = mbstowcs (NULL, lpzText, strlen(lpzText));
if (len == -1 || !(lpwText = calloc(len+1,sizeof(WCHAR)))) return -1;
mbstowcs (lpwText, lpzText, strlen(lpzText));
iRet = ShowMessage(iconID, lpwText, mustShow);
free (lpwText);
return iRet;
}
#endif
// processing Hooks
int HookContactAdded(WPARAM wParam, LPARAM lParam) {
char *szProto;
UNREFERENCED_PARAMETER(lParam);
szProto = (char*)CallService( MS_PROTO_GETCONTACTBASEPROTO, wParam, 0 );
if (szProto!=NULL && !strcmp(szProto, SKYPE_PROTONAME))
add_contextmenu((HANDLE)wParam);
return 0;
}
int HookContactDeleted(WPARAM wParam, LPARAM lParam) {
char *szProto;
UNREFERENCED_PARAMETER(lParam);
szProto = (char*)CallService( MS_PROTO_GETCONTACTBASEPROTO, wParam, 0 );
if (szProto!=NULL && !strcmp(szProto, SKYPE_PROTONAME)) {
DBVARIANT dbv;
int retval;
if (DBGetContactSettingString((HANDLE)wParam, SKYPE_PROTONAME, SKYPE_NAME, &dbv)) return 1;
retval=SkypeSend("SET USER %s BUDDYSTATUS 1", dbv.pszVal);
DBFreeVariant(&dbv);
if (retval) return 1;
}
return 0;
}
void GetInfoThread(HANDLE hContact) {
DBVARIANT dbv;
int i;
char *ptr;
BOOL bSetNick = FALSE;
// All properties are already handled in the WndProc, so we just consume the
// messages here to do proper ERROR handling
// If you add something here, be sure to handle it in WndProc, but let it
// fall through there so that message gets added to the queue in order to be
// consumed by SkypeGet
char *pszProps[] = {
"BIRTHDAY", "COUNTRY", "SEX", "MOOD_TEXT", "TIMEZONE", "IS_VIDEO_CAPABLE"};
LOG (("GetInfoThread started."));
EnterCriticalSection (&QueryThreadMutex);
if (DBGetContactSettingString(hContact, SKYPE_PROTONAME, SKYPE_NAME, &dbv))
{
LOG (("GetInfoThread terminated, cannot find Skype Name for contact %08X.", hContact));
LeaveCriticalSection (&QueryThreadMutex);
return;
}
if (ptr=SkypeGet ("USER", dbv.pszVal, "DISPLAYNAME")) {
// WndProc sets Nick accordingly
if (*ptr) bSetNick = TRUE;
free (ptr);
}
if (ptr=SkypeGet ("USER", dbv.pszVal, "FULLNAME")) {
if (*ptr && !bSetNick && DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "ShowFullname", 1)) {
// No Displayname and FULLNAME requested
SkypeDBWriteContactSettingUTF8String(hContact, SKYPE_PROTONAME, "Nick", ptr);
bSetNick = TRUE;
}
free (ptr);
}
if (!bSetNick) {
// Still no nick set, so use SKYPE Nickname
DBWriteContactSettingString(hContact, SKYPE_PROTONAME, "Nick", dbv.pszVal);
}
if (!bIsImoproxy)
{
for (i=0; i<sizeof(pszProps)/sizeof(pszProps[0]); i++)
if (ptr=SkypeGet ("USER", dbv.pszVal, pszProps[i])) free (ptr);
} else {
if (ptr=SkypeGet ("USER", dbv.pszVal, "MOOD_TEXT")) free (ptr);
}
if (protocol >= 7 || bIsImoproxy) {
// Notify about the possibility of an avatar
ACKDATA ack = {0};
ack.cbSize = sizeof( ACKDATA );
ack.szModule = SKYPE_PROTONAME;
ack.hContact = hContact;
ack.type = ACKTYPE_AVATAR;
ack.result = ACKRESULT_STATUS;
CallService( MS_PROTO_BROADCASTACK, 0, ( LPARAM )&ack );
//if (ptr=SkypeGet ("USER", dbv.pszVal, "RICH_MOOD_TEXT")) free (ptr);
}
if (!bIsImoproxy)
{
for (i=0; i<sizeof(m_settings)/sizeof(m_settings[0]); i++)
if (ptr=SkypeGet ("USER", dbv.pszVal, m_settings[i].SkypeSetting)) free (ptr);
}
ProtoBroadcastAck(SKYPE_PROTONAME, hContact, ACKTYPE_GETINFO, ACKRESULT_SUCCESS, (HANDLE) 1, 0);
LeaveCriticalSection(&QueryThreadMutex);
DBFreeVariant(&dbv);
LOG (("GetInfoThread terminated gracefully."));
}
time_t SkypeTime(time_t *timer) {
struct _timeb tb;
EnterCriticalSection (&TimeMutex);
_ftime(&tb);
if (timer) *timer=tb.time;
LeaveCriticalSection (&TimeMutex);
return tb.time;
}
void BasicSearchThread(char *nick) {
PROTOSEARCHRESULT psr={0};
char *cmd=NULL, *token=NULL, *ptr=NULL, *nextoken;
time_t st;
LOG (("BasicSearchThread started."));
EnterCriticalSection (&QueryThreadMutex);
SkypeTime(&st);
if (SkypeSend("SEARCH USERS %s", nick)==0 && (cmd=SkypeRcvTime("USERS", st, INFINITE))) {
if (strncmp(cmd, "ERROR", 5)) {
psr.cbSize=sizeof(psr);
for (token=strtok_r(cmd+5, ", ", &nextoken); token; token=strtok_r(NULL, ", ", &nextoken)) {
TCHAR *t = mir_utf8decodeT(token), *_ptr = NULL;
psr.nick=psr.id=t;
psr.lastName=NULL;
psr.firstName=NULL;
psr.email=NULL;
if (ptr=SkypeGet("USER", token, "FULLNAME")) {
// We cannot use strtok() to seperate first & last name here,
// because we already use it for parsing the user list
// So we use our own function
_ptr = mir_utf8decodeT(ptr);
if (psr.lastName=_tcschr(_ptr, ' ')) {
*psr.lastName=0;
psr.lastName++;
LOG(("BasicSearchThread: lastName=%s", psr.lastName));
}
psr.firstName=_ptr;
LOG(("BasicSearchThread: firstName=%s", psr.firstName));
}
ProtoBroadcastAck(SKYPE_PROTONAME, NULL, ACKTYPE_SEARCH, ACKRESULT_DATA, (HANDLE)hSearchThread, (LPARAM)(PROTOSEARCHRESULT*)&psr);
if (ptr) free(ptr);
if(t) mir_free(t);
if(_ptr) mir_free(_ptr);
}
} else {
OUT(cmd);
}
free(cmd);
}
ProtoBroadcastAck(SKYPE_PROTONAME, NULL, ACKTYPE_SEARCH, ACKRESULT_SUCCESS, (HANDLE)hSearchThread, 0);
free(nick);
LeaveCriticalSection(&QueryThreadMutex);
LOG (("BasicSearchThread terminated gracefully."));
return;
}
INT_PTR SkypeDBWriteContactSettingUTF8String(HANDLE hContact,const char *szModule,const char *szSetting,const char *val)
{
DBCONTACTWRITESETTING cws;
INT_PTR iRet;
// Try to save it as UTF8 sting to DB. If this doesn't succeed (i.e. older Miranda version), we convert
// accordingly and try to save again.
cws.szModule=szModule;
cws.szSetting=szSetting;
cws.value.type=DBVT_UTF8;
cws.value.pszVal=(char*)val;
// DBVT_UTF8 support started with version 0.5.0.0, right...?
if (mirandaVersion < 0x050000 || (iRet = CallService(MS_DB_CONTACT_WRITESETTING,(WPARAM)hContact,(LPARAM)&cws)))
{
// Failed, try to convert and then try again
cws.value.type=DBVT_TCHAR;
if (!(cws.value.ptszVal = make_tchar_string((const unsigned char*)val))) return -1;
iRet = CallService(MS_DB_CONTACT_WRITESETTING,(WPARAM)hContact,(LPARAM)&cws);
free (cws.value.pszVal);
}
return iRet;
}
// added by TioDuke
void GetDisplaynameThread(char *dummy) {
DBVARIANT dbv;
char *ptr;
UNREFERENCED_PARAMETER(dummy);
LOG(("GetDisplaynameThread started."));
if (DBGetContactSettingString(NULL, SKYPE_PROTONAME, SKYPE_NAME, &dbv)) {
LOG(("GetDisplaynameThread terminated."));
return;
}
EnterCriticalSection(&QueryThreadMutex);
if ((ptr=SkypeGet("USER", dbv.pszVal, "FULLNAME"))) {
if (*ptr) SkypeDBWriteContactSettingUTF8String(NULL, SKYPE_PROTONAME, "Nick", ptr);
free(ptr);
}
DBFreeVariant(&dbv);
LeaveCriticalSection(&QueryThreadMutex);
LOG(("GetDisplaynameThread terminated gracefully."));
}
// Starts importing history from Skype
INT_PTR ImportHistory(WPARAM wParam, LPARAM lParam) {
DBVARIANT dbv;
UNREFERENCED_PARAMETER(lParam);
if (DBGetContactSettingByte((HANDLE)wParam, SKYPE_PROTONAME, "ChatRoom", 0)) {
if (DBGetContactSettingString((HANDLE)wParam, SKYPE_PROTONAME, "ChatRoomID", &dbv)) return 0;
SkypeSend ("GET CHAT %s CHATMESSAGES", dbv.pszVal);
} else {
if (DBGetContactSettingString((HANDLE)wParam, SKYPE_PROTONAME, SKYPE_NAME, &dbv)) return 0;
SkypeSend("SEARCH %sS %s", cmdMessage, dbv.pszVal);
}
DBFreeVariant(&dbv);
return 0;
}
int SearchFriends(void) {
char *ptr, *token, *pStat, *nextoken;
int iRet = 0;
time_t st;
SkypeTime(&st);
if (SkypeSend("SEARCH FRIENDS")!=-1 && (ptr=SkypeRcvTime("USERS", st, INFINITE)))
{
if (strncmp(ptr, "ERROR", 5)) {
if (ptr+5) {
for (token=strtok_r(ptr+5, ", ", &nextoken); token; token=strtok_r(NULL, ", ", &nextoken)) {
if (!(pStat = SkypeGet("USER", token, "ONLINESTATUS")))
{
iRet = -1;
break;
}
free (pStat);
}
}
} else iRet=-1;
free(ptr);
} else iRet=-1;
return iRet;
}
void __cdecl SearchUsersWaitingMyAuthorization(void *dummy) {
char *cmd, *token, *nextoken;
UNREFERENCED_PARAMETER(dummy);
if (SkypeSend("#UWA SEARCH USERSWAITINGMYAUTHORIZATION")) return;
if (!(cmd=SkypeRcv("#UWA USERS", INFINITE))) return;
if (!strncmp(cmd, "ERROR", 5)) {
free(cmd);
return;
}
token=strtok_r(cmd+10, ", ", &nextoken);
while (token) {
CCSDATA ccs={0};
PROTORECVEVENT pre={0};
HANDLE hContact;
char *firstname=NULL, *lastname=NULL, *pCurBlob;
LOG(("Awaiting auth: %s", token));
ccs.szProtoService=PSR_AUTH;
ccs.hContact=hContact=add_contact(token, PALF_TEMPORARY);
ccs.wParam=0;
ccs.lParam=(LPARAM)⪯
pre.flags=0;
pre.timestamp=(DWORD)SkypeTime(NULL);
/* blob is: */
//DWORD protocolSpecific HANDLE hContact
//ASCIIZ nick, firstName, lastName, e-mail, requestReason
if (firstname=SkypeGet("USER", token, "FULLNAME"))
if (lastname=strchr(firstname, ' ')) {
*lastname=0;
lastname++;
}
pre.lParam=sizeof(DWORD)*2 + strlen(token)+5;
if (firstname) pre.lParam += strlen(firstname);
if (lastname) pre.lParam += strlen(lastname);
if (pre.szMessage = pCurBlob = (char *)calloc(1, pre.lParam)) {
pCurBlob+=sizeof(DWORD); // Not used
*(DWORD*)pCurBlob = (DWORD)hContact; pCurBlob += sizeof(DWORD);
strcpy((char *)pCurBlob,token); pCurBlob += strlen((char *)pCurBlob)+1;
if (firstname) {
strcpy((char *)pCurBlob,firstname);
if (lastname) {
pCurBlob+=strlen((char *)pCurBlob)+1;
strcpy((char *)pCurBlob,lastname);
}
}
CallService(MS_PROTO_CHAINRECV,0,(LPARAM)&ccs);
free(pre.szMessage);
}
if (firstname) free(firstname);
token=strtok_r(NULL, ", ", &nextoken);
}
free(cmd);
return;
}
void SearchFriendsThread(char *dummy) {
UNREFERENCED_PARAMETER(dummy);
if (!SkypeInitialized) return;
LOG(("SearchFriendsThread started."));
EnterCriticalSection(&QueryThreadMutex);
SkypeInitialized=FALSE;
SearchFriends();
SkypeInitialized=TRUE;
LeaveCriticalSection(&QueryThreadMutex);
LOG(("SearchFriendsThread terminated gracefully."));
}
void __cdecl SearchRecentChats(void *dummy) {
char *cmd, *token, *nextoken;
UNREFERENCED_PARAMETER(dummy);
if (SkypeSend("#RCH SEARCH RECENTCHATS")) return;
if (!(cmd=SkypeRcv("#RCH CHATS", INFINITE))) return;
if (!strncmp(cmd, "ERROR", 5)) {
free(cmd);
return;
}
for (token=strtok_r(cmd+10, ", ", &nextoken); token; token=strtok_r(NULL, ", ", &nextoken)) {
char *pszStatus = SkypeGet ("CHAT", token, "STATUS");
if (pszStatus) {
if (!strcmp(pszStatus, "MULTI_SUBSCRIBED")) {
// Add chatrooms for active multisubscribed chats
/*if (!find_chatA(token)) */{
char *pszTopic;
EnterCriticalSection (&QueryThreadMutex);
ChatStart(token, TRUE);
if (pszTopic = SkypeGet ("CHAT", token, "TOPIC")) {
TCHAR *psztChatName, *psztTopic;
if (!*pszTopic) {
free (pszTopic);
if (pszTopic = SkypeGet ("CHAT", token, "FRIENDLYNAME"));
}
psztChatName = make_nonutf_tchar_string((const unsigned char*)token);
psztTopic = make_tchar_string((const unsigned char*)pszTopic);
SetChatTopic (psztChatName, psztTopic, FALSE);
free_nonutf_tchar_string(psztChatName);
free (psztTopic);
free (pszTopic);
}
LeaveCriticalSection (&QueryThreadMutex);
}
}
free (pszStatus);
}
}
free(cmd);
return;
}
void __cdecl SkypeSystemInit(char *dummy) {
static BOOL Initializing=FALSE;
DBVARIANT dbv={0};
UNREFERENCED_PARAMETER(dummy);
LOG (("SkypeSystemInit thread started."));
if (SkypeInitialized || Initializing)
{
LOG (("SkypeSystemInit terminated, nothing to do."));
return;
}
Initializing=TRUE;
// Do initial Skype-Tasks
logoff_contacts(FALSE);
// Add friends
// Clear currentuserhandle entries from queue
while (testfor ("CURRENTUSERHANDLE", 0));
if (SkypeSend(SKYPE_PROTO)==-1 || !testfor("PROTOCOL", INFINITE) ||
SkypeSend("GET CURRENTUSERHANDLE")==-1 ||
SkypeSend("GET PRIVILEGE SKYPEOUT")==-1) {
Initializing=FALSE;
LOG (("SkypeSystemInit thread stopped with failure."));
return;
}
if(DBGetContactSettingString(NULL,SKYPE_PROTONAME,"LoginUserName",&dbv) == 0)
{
if (*dbv.pszVal)
{
char *pszUser;
// Username is set in Plugin, therefore we need to match it
// against CURRENTUSERHANDLE
if (pszUser = SkypeRcv ("CURRENTUSERHANDLE", INFINITE))
{
memmove (pszUser, pszUser+18, strlen(pszUser+17));
if (_stricmp(dbv.pszVal, pszUser))
{
char szError[256];
// Doesn't match, maybe we have a second Skype instance we have to take
// care of? If in doubt, let's wait a while for it to report its hWnd to us.
LOG (("Userhandle %s doesn't match username %s from settings", pszUser, dbv.pszVal));
if (!hSkypeWndSecondary) Sleep(3000);
if (hSkypeWndSecondary)
{
hSkypeWnd = hSkypeWndSecondary;
hSkypeWndSecondary = NULL;
Initializing=FALSE;
while (testfor ("CURRENTUSERHANDLE", 0));
LOG (("Trying to init secondary Skype instance"));
SkypeSystemInit(dummy);
}
else
{
hForbiddenSkypeWnd = hSkypeWnd;
// If we need to start Skype as secondary instance, we should do it now
if (DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "StartSkype", 1) &&
DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "secondary", 0))
{
int oldstatus;
hSkypeWnd = NULL;
AttachStatus=-1;
if (g_hWnd) KillTimer (g_hWnd, 1);
oldstatus = SkypeStatus;
InterlockedExchange((long *)&SkypeStatus, ID_STATUS_CONNECTING);
ProtoBroadcastAck(SKYPE_PROTONAME, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE) oldstatus, SkypeStatus);
ConnectToSkypeAPI(skype_path, 1);
}
if (hForbiddenSkypeWnd == hSkypeWnd && !hSkypeWndSecondary)
{
int oldstatus;
sprintf (szError, "Username '%s' provided by Skype API doesn't match username '%s' in "
"your settings. Please either remove username setting in you configuration or correct "
"it. Will not connect!", pszUser, dbv.pszVal);
OUTPUTA (szError);
Initializing=FALSE;
AttachStatus=-1;
logoff_contacts(FALSE);
if (g_hWnd) KillTimer (g_hWnd, 1);
hSkypeWnd = NULL;
oldstatus = SkypeStatus;
InterlockedExchange((long *)&SkypeStatus, ID_STATUS_OFFLINE);
ProtoBroadcastAck(SKYPE_PROTONAME, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE) oldstatus, SkypeStatus);
}
}
}
free (pszUser);
}
}
DBFreeVariant(&dbv);
if (!Initializing) return;
}
#ifdef SKYPEBUG_OFFLN
if (!ResetEvent(GotUserstatus) || SkypeSend("GET USERSTATUS")==-1 ||
WaitForSingleObject(GotUserstatus, INFINITE)==WAIT_FAILED)
{
LOG (("SkypeSystemInit thread stopped with failure."));
Initializing=FALSE;
return;
}
if (SkypeStatus!=ID_STATUS_OFFLINE)
#endif
if (SearchFriends()==-1) {
LOG (("SkypeSystemInit thread stopped with failure."));
Initializing=FALSE;
return;
}
if (protocol>=5 || bIsImoproxy) {
SkypeSend ("CREATE APPLICATION libpurple_typing");
testfor ("CREATE APPLICATION libpurple_typing", 2000);
}
if (protocol>=5 || bIsImoproxy) {
SearchUsersWaitingMyAuthorization(NULL);
if (DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "UseGroupchat", 0))
SearchRecentChats(NULL);
}
SkypeSend("SEARCH MISSED%sS", cmdMessage);
#ifndef SKYPEBUG_OFFLN
if (SkypeSend("GET USERSTATUS")==-1)
{
LOG (("SkypeSystemInit thread stopped with failure."));
Initializing=FALSE;
return;
}
#endif
SetTimer (g_hWnd, 1, PING_INTERVAL, NULL);
SkypeInitialized=TRUE;
Initializing=FALSE;
LOG (("SkypeSystemInit thread terminated gracefully."));
return;
}
void FirstLaunch(char *dummy) {
int counter=0;
UNREFERENCED_PARAMETER(dummy);
LOG (("FirstLaunch thread started."));
if (!DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "StartSkype", 1) || ConnectToSkypeAPI(skype_path, FALSE)==-1)
{
int oldstatus=SkypeStatus;
LOG(("OnModulesLoaded starting offline.."));
InterlockedExchange((long *)&SkypeStatus, ID_STATUS_OFFLINE);
ProtoBroadcastAck(SKYPE_PROTONAME, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE) oldstatus, SkypeStatus);
}
if (AttachStatus==-1 || AttachStatus==SKYPECONTROLAPI_ATTACH_REFUSED || AttachStatus==SKYPECONTROLAPI_ATTACH_NOT_AVAILABLE) {
LOG (("FirstLaunch thread stopped because of invalid Attachstatus."));
return;
}
// When you launch Skype and Attach is Successfull, it still takes some time
// until it becomes available for receiving messages.
// Let's probe this with PINGing
LOG(("CheckIfApiIsResponding Entering test loop"));
for ( ;; ) {
LOG(("Test #%d", counter));
if (SkypeSend("PING")==-1) counter ++; else break;
if (counter>=20) {
OUTPUT(_T("Cannot reach Skype API, plugin disfunct."));
LOG (("FirstLaunch thread stopped: cannot reach Skype API."));
return;
}
Sleep(500);
}
LOG(("CheckIfApiIsResponding: Testing for PONG"));
testfor("PONG", 2000); // Flush PONG from MsgQueue
forkthread(( pThreadFunc )SkypeSystemInit, 0, NULL);
LOG (("FirstLaunch thread terminated gracefully."));
}
int CreateTopToolbarButton(WPARAM wParam, LPARAM lParam) {
TTBButton ttb={0};
UNREFERENCED_PARAMETER(wParam);
UNREFERENCED_PARAMETER(lParam);
ttb.cbSize = sizeof(ttb);
ttb.dwFlags = TTBBF_VISIBLE|TTBBF_SHOWTOOLTIP|TTBBF_DRAWBORDER;
ttb.hbBitmapDown = ttb.hbBitmapUp = LoadBitmap(hInst,MAKEINTRESOURCE(IDB_CALL));
ttb.pszServiceDown = ttb.pszServiceUp = SKYPEOUT_CALL;
ttb.name=Translate("Do a SkypeOut-call");
if ((int)(httbButton=(HANDLE)CallService(MS_TTB_ADDBUTTON, (WPARAM)&ttb, 0))==-1) httbButton=0;
return 0;
}
int OnModulesLoaded(WPARAM wParam, LPARAM lParam) {
bModulesLoaded=TRUE;
UNREFERENCED_PARAMETER(wParam);
UNREFERENCED_PARAMETER(lParam);
PopupServiceExists = ServiceExists(MS_POPUP_ADDPOPUPEX);
logoff_contacts(FALSE);
HookEventsLoaded();
//RegisterToUpdate();
RegisterToDbeditorpp();
VoiceServiceModulesLoaded();
GCInit();
add_contextmenu(NULL);
if ( ServiceExists( MS_GC_REGISTER ))
{
GCREGISTER gcr = {0};
static COLORREF crCols[1] = {0};
char szEvent[MAXMODULELABELLENGTH];
gcr.cbSize = sizeof( GCREGISTER );
gcr.dwFlags = GC_CHANMGR | GC_TCHAR; // |GC_ACKMSG; // TODO: Not implemented yet
gcr.ptszModuleDispName = _T("Skype protocol");
gcr.pszModule = SKYPE_PROTONAME;
if (CallService(MS_GC_REGISTER, 0, (LPARAM)&gcr))
{
OUTPUT(_T("Unable to register with Groupchat module!"));
}
_snprintf (szEvent, sizeof(szEvent), "%s\\ChatInit", SKYPE_PROTONAME);
hInitChat = CreateHookableEvent(szEvent);
hEvInitChat = HookEvent(szEvent, ChatInit);
hChatEvent = HookEvent(ME_GC_EVENT, GCEventHook);
hChatMenu = HookEvent(ME_GC_BUILDMENU, GCMenuHook);
CreateServiceFunction (SKYPE_CHATNEW, SkypeChatCreate);
CreateProtoService (PS_LEAVECHAT, GCOnLeaveChat);
CreateProtoService (PS_JOINCHAT, GCOnJoinChat);
}
// Try folder service first
hProtocolAvatarsFolder = NULL;
if (ServiceExists(MS_FOLDERS_REGISTER_PATH))
{
char *tmpPath;
if (!ServiceExists (MS_UTILS_REPLACEVARS) || !(tmpPath = Utils_ReplaceVars("%miranda_avatarcache%")))
tmpPath = PROFILE_PATH;
mir_snprintf(DefaultAvatarsFolder, sizeof(DefaultAvatarsFolder), "%s\\%s", tmpPath, SKYPE_PROTONAME);
hProtocolAvatarsFolder = (HANDLE) FoldersRegisterCustomPath(SKYPE_PROTONAME, "Avatars Cache", DefaultAvatarsFolder);
}
if (hProtocolAvatarsFolder == NULL)
{
// Use defaults
CallService(MS_DB_GETPROFILEPATH, (WPARAM) MAX_PATH, (LPARAM) DefaultAvatarsFolder);
mir_snprintf(DefaultAvatarsFolder, sizeof(DefaultAvatarsFolder), "%s\\%s", DefaultAvatarsFolder, SKYPE_PROTONAME);
CreateDirectoryA(DefaultAvatarsFolder, NULL);
}
forkthread(( pThreadFunc )FirstLaunch, 0, NULL);
return 0;
}
void FetchMessageThread(fetchmsg_arg *pargs) {
char *who=NULL, *type=NULL, *chat=NULL, *users=NULL, *msg=NULL, *status=NULL;
char *ptr, *msgptr, szPartnerHandle[32], szBuf[128];
int direction=0, msglen = 0;
DWORD timestamp = 0, lwr=0;
CCSDATA ccs={0};
PROTORECVEVENT pre={0};
HANDLE hContact = NULL, hDbEvent, hChat = NULL;
DBEVENTINFO dbei={0};
DBVARIANT dbv={0};
fetchmsg_arg args;
BOOL bEmoted=FALSE, isGroupChat=FALSE, bHasPartList=FALSE;
BOOL bUseGroupChat = DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "UseGroupchat", 0);
if (!pargs) return;
args = *pargs;
free (pargs);
sprintf (szPartnerHandle, "%s_HANDLE", cmdPartner);
pre.lParam = strtoul(args.msgnum, NULL, 10);
if (args.bIsRead) pre.flags |= PREF_CREATEREAD;
//pEvent = MsgList_FindMessage(pre.lParam);
// Get Timestamp
if (!args.pMsgEntry || !args.pMsgEntry->tEdited) {
if (!(ptr=SkypeGet (cmdMessage, args.msgnum, "TIMESTAMP"))) return;
if (strncmp(ptr, "ERROR", 5)) timestamp=atol(ptr);
else timestamp=(DWORD)SkypeTime(NULL);
free(ptr);
} else timestamp=(DWORD)(args.pMsgEntry->tEdited);
__try {
// Get Chatname (also to determine if we need to relay this to a groupchat)
if (!(chat=SkypeGetErr (cmdMessage, args.msgnum, "CHATNAME"))) __leave;
if (hChat = find_chatA(chat)) isGroupChat=TRUE;
// Get chat status
if ((status=SkypeGetErr ("CHAT", chat, "STATUS")) &&
!strcmp(status, "MULTI_SUBSCRIBED")) isGroupChat=TRUE;
// Get chat type
if (!(type=SkypeGetErr (cmdMessage, args.msgnum, "TYPE"))) __leave;
bEmoted = strcmp(type, "EMOTED")==0;
if (strcmp(type, "MULTI_SUBSCRIBED")==0) isGroupChat=TRUE;
// Group chat handling
if (isGroupChat && strcmp(type, "TEXT") && strcmp(type, "SAID") && strcmp(type, "UNKNOWN") && !bEmoted) {
if (bUseGroupChat) {
BOOL bAddedMembers = FALSE;
if (!strcmp(type,"SAWMEMBERS") || !strcmp(type, "CREATEDCHATWITH"))
{
// We have a new Groupchat
LOG(("FetchMessageThread CHAT SAWMEMBERS"));
if (!hChat) ChatStart(chat, FALSE);
__leave;
}
if (!strcmp(type,"KICKED"))
{
GCDEST gcd = {0};
GCEVENT gce = {0};
CONTACTINFO ci = {0};
if (!hChat) __leave;
gcd.pszModule = SKYPE_PROTONAME;
gcd.ptszID = make_nonutf_tchar_string((const unsigned char*)chat);
gcd.iType = GC_EVENT_KICK;
gce.cbSize = sizeof(GCEVENT);
gce.pDest = &gcd;
gce.dwFlags = GCEF_ADDTOLOG | GC_TCHAR;
gce.time = timestamp;
if (users=SkypeGetErr (cmdMessage, args.msgnum, "USERS")) {
ci.hContact = find_contact(users);
gce.ptszUID= make_nonutf_tchar_string((const unsigned char*)users);
if (who=SkypeGetErr (cmdMessage, args.msgnum, szPartnerHandle)) {
gce.ptszStatus= make_nonutf_tchar_string((const unsigned char*)who);
ci.cbSize = sizeof(ci);
ci.szProto = SKYPE_PROTONAME;
ci.dwFlag = CNF_DISPLAY | CNF_TCHAR;
if (ci.hContact && !CallService(MS_CONTACT_GETCONTACTINFO,0,(LPARAM)&ci)) gce.ptszNick=ci.pszVal;
else gce.ptszNick=gce.ptszUID;
CallService(MS_GC_EVENT, 0, (LPARAM)&gce);
RemChatContact (GetChat(gcd.ptszID), gce.ptszUID);
free_nonutf_tchar_string((void*)gce.ptszStatus);
if (ci.pszVal) mir_free (ci.pszVal);
}
free_nonutf_tchar_string((void*)gce.ptszUID);
}
free_nonutf_tchar_string((void*)gcd.ptszID);
__leave;
}
if (!strcmp(type,"SETROLE"))
{
GCDEST gcd = {0};
GCEVENT gce = {0};
CONTACTINFO ci = {0};
gchat_contact *gcContact;
char *pszRole;
// FROM_HANDLE - Wer hats gesetzt
// USERS - Wessen Rolle wurde gesetzt
// ROLE - Die neue Rolle
if (!hChat) __leave;
gcd.pszModule = SKYPE_PROTONAME;
gcd.ptszID = make_nonutf_tchar_string((const unsigned char*)chat);
gcd.iType = GC_EVENT_REMOVESTATUS;
gce.cbSize = sizeof(GCEVENT);
gce.pDest = &gcd;
gce.dwFlags = GCEF_ADDTOLOG | GC_TCHAR;
gce.time = timestamp;
if (users=SkypeGetErr (cmdMessage, args.msgnum, "USERS")) {
gce.ptszUID= make_nonutf_tchar_string((const unsigned char*)users);
if (who=SkypeGetErr (cmdMessage, args.msgnum, szPartnerHandle)) {
ci.cbSize = sizeof(ci);
ci.szProto = SKYPE_PROTONAME;
ci.dwFlag = CNF_DISPLAY | CNF_TCHAR;
ci.hContact = find_contact(who);
if (ci.hContact && !CallService(MS_CONTACT_GETCONTACTINFO,0,(LPARAM)&ci)) {
gce.ptszText=_tcsdup(ci.pszVal);
mir_free (ci.pszVal);
ci.pszVal = NULL;
}
else gce.ptszText=make_tchar_string((const unsigned char*)who);
ci.hContact = find_contact(users);
if (ci.hContact && !CallService(MS_CONTACT_GETCONTACTINFO,0,(LPARAM)&ci)) gce.ptszNick=ci.pszVal;
else gce.ptszNick=gce.ptszUID;
if (gcContact = GetChatContact(GetChat(gcd.ptszID), gce.ptszUID))
{
gce.ptszStatus = gcContact->szRole;
CallService(MS_GC_EVENT, 0, (LPARAM)&gce);
}
if (pszRole=SkypeGetErr (cmdMessage, args.msgnum, "ROLE")) {
gce.ptszStatus = make_nonutf_tchar_string((const unsigned char*)pszRole);
gcd.iType = GC_EVENT_ADDSTATUS;
CallService(MS_GC_EVENT, 0, (LPARAM)&gce);
free_nonutf_tchar_string((void*)gce.ptszStatus);
free (pszRole);
}
free((void*)gce.ptszText);
if (ci.pszVal) mir_free (ci.pszVal);
}
free_nonutf_tchar_string((void*)gce.ptszUID);
}
free_nonutf_tchar_string((void*)gcd.ptszID);
__leave;
}
if (!strcmp(type,"SETTOPIC"))
{
GCDEST gcd = {0};
GCEVENT gce = {0};
CONTACTINFO ci = {0};
LOG(("FetchMessageThread CHAT SETTOPIC"));
gcd.pszModule = SKYPE_PROTONAME;
gcd.ptszID = make_nonutf_tchar_string((const unsigned char*)chat);
gcd.iType = GC_EVENT_TOPIC;
gce.cbSize = sizeof(GCEVENT);
gce.pDest = &gcd;
gce.dwFlags = GCEF_ADDTOLOG | GC_TCHAR;
gce.time = timestamp;
if (who=SkypeGetErr (cmdMessage, args.msgnum, szPartnerHandle)) {
ci.hContact = find_contact(who);
gce.ptszUID = make_nonutf_tchar_string((const unsigned char*)who);
ci.cbSize = sizeof(ci);
ci.szProto = SKYPE_PROTONAME;
ci.dwFlag = CNF_DISPLAY | CNF_TCHAR;
if (ci.hContact && !CallService(MS_CONTACT_GETCONTACTINFO,0,(LPARAM)&ci)) gce.ptszNick=ci.pszVal;
else gce.ptszNick=gce.ptszUID;
if (ptr=SkypeGetErr (cmdMessage, args.msgnum, "BODY")) {
gce.ptszText = make_tchar_string((const unsigned char*)ptr);
CallService(MS_GC_EVENT, 0, (LPARAM)&gce);
free ((void*)gce.ptszText);
free (ptr);
}
free_nonutf_tchar_string ((void*)gce.ptszUID);
if (ci.pszVal) mir_free (ci.pszVal);
}
free_nonutf_tchar_string((void*)gcd.ptszID);
if (!args.bDontMarkSeen)
{
MsgList_Add (pre.lParam, INVALID_HANDLE_VALUE);
SkypeSend("SET %s %s SEEN", cmdMessage, args.msgnum);
}
__leave;
}
if (!strcmp(type,"LEFT") || (bAddedMembers = strcmp(type,"ADDEDMEMBERS")==0))
{
GCDEST gcd = {0};
GCEVENT gce = {0};
CONTACTINFO ci = {0};
char *pszInvited = Translate("invited ");
LOG(("FetchMessageThread CHAT LEFT or ADDEDMEMBERS"));
if (bAddedMembers) {
gcd.pszModule = SKYPE_PROTONAME;
gcd.ptszID = make_nonutf_tchar_string((const unsigned char*)chat);
gcd.iType = GC_EVENT_ACTION;
gce.cbSize = sizeof(GCEVENT);
gce.pDest = &gcd;
gce.dwFlags = GCEF_ADDTOLOG | GC_TCHAR;
gce.time = timestamp;
if (users=SkypeGetErr (cmdMessage, args.msgnum, "USERS")) {
// We assume that users buffer has enough room for "invited" string
memmove (users+strlen(pszInvited), users, strlen(users)+1);
memcpy (users, pszInvited, strlen(pszInvited));
gce.ptszText= make_tchar_string((const unsigned char*)users);
if (who=SkypeGetErr (cmdMessage, args.msgnum, szPartnerHandle)) {
DBVARIANT dbv;
if (DBGetContactSettingString(NULL, SKYPE_PROTONAME, SKYPE_NAME, &dbv)==0) {
gce.bIsMe = strcmp(who, dbv.pszVal)==0;
DBFreeVariant(&dbv);
}
if (!gce.bIsMe) ci.hContact = find_contact(who);
gce.ptszUID= make_nonutf_tchar_string((const unsigned char*)who);
ci.cbSize = sizeof(ci);
ci.szProto = SKYPE_PROTONAME;
ci.dwFlag = CNF_DISPLAY | CNF_TCHAR;
if (!CallService(MS_CONTACT_GETCONTACTINFO,0,(LPARAM)&ci)) gce.ptszNick=ci.pszVal;
else gce.ptszNick=gce.ptszUID;
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
free_nonutf_tchar_string((void*)gce.ptszUID);
if (ci.pszVal) mir_free (ci.pszVal);
}
if (gce.ptszText) free ((void*)gce.ptszText);
}
free_nonutf_tchar_string ((void*)gcd.ptszID);
}
if (!args.QueryMsgDirection) SkypeSend ("GET CHAT %s MEMBERS", chat);
__leave;
}
}
__leave;
}
// Need to get the status?
if (args.getstatus) {
char *status;
if (protocol<4) InterlockedIncrement (&rcvwatchers);
status=SkypeGetID(cmdMessage, args.msgnum, "STATUS");
if (protocol<4) InterlockedDecrement (&rcvwatchers);
if (!status) __leave;
if (!strcmp(status, "SENT")) direction=DBEF_SENT;
free(status);
}
// Who sent it?
if (!(who=SkypeGetErr (cmdMessage, args.msgnum, szPartnerHandle))) __leave;
// Get contact handle
LOG(("FetchMessageThread Finding contact handle"));
DBGetContactSettingString(NULL, SKYPE_PROTONAME, SKYPE_NAME, &dbv);
if (dbv.pszVal && !strcmp (who, dbv.pszVal))
{
char *pTok, *nextoken;
// It's from me.. But to whom?
// CHATMESSAGE .. USERS doesn't return anything, so we have to query the CHAT-Object
if (!(ptr=SkypeGetErr ("CHAT", chat, "ACTIVEMEMBERS"))) {
DBFreeVariant (&dbv);
__leave;
}
for (pTok = strtok_r (ptr, " ", &nextoken); pTok; pTok=strtok_r(NULL, " ", &nextoken)) {
if (strcmp (pTok, dbv.pszVal)) break; // Take the first dude in the list who is not me
}
if (!pTok) {
free (ptr);
DBFreeVariant (&dbv);
__leave; // We failed
}
free (who);
who=memmove (ptr, pTok, strlen(pTok)+1);
direction = DBEF_SENT;
}
DBFreeVariant (&dbv);
if (!(hContact=find_contact(who))) {
// Permanent adding of user obsolete, we use the BUDDYSTATUS now (bug #0000005)
ResetEvent(hBuddyAdded);
SkypeSend("GET USER %s BUDDYSTATUS", who);
WaitForSingleObject(hBuddyAdded, INFINITE);
if (!(hContact=find_contact(who))) {
// Arrgh, the user has been deleted from contact list.
// In this case, we add him temp. to receive the msg at least.
hContact=add_contact(who, PALF_TEMPORARY);
}
}
// Text which was sent (on edited msg, BODY may already be in queue, check)
sprintf (szBuf, "GET %s %s BODY", cmdMessage, args.msgnum);
if (!args.pMsgEntry || !args.pMsgEntry->tEdited || !(ptr=SkypeRcv(szBuf+4, 1000)))
{
if (SkypeSend(szBuf)==-1 || !(ptr=SkypeRcv(szBuf+4, INFINITE)))
__leave;
}
if (strncmp(ptr, "ERROR", 5)) {
msgptr = ptr+strlen(szBuf+4)+1;
bHasPartList = strncmp(msgptr,"<partlist ",10)==0;
if (args.pMsgEntry && args.pMsgEntry->tEdited) {
// Mark the message as edited
if (!*msgptr && args.pMsgEntry->hEvent != INVALID_HANDLE_VALUE) {
// Empty message and edited -> Delete event
if ((int)(hContact = (HANDLE)CallService (MS_DB_EVENT_GETCONTACT, (WPARAM)args.pMsgEntry->hEvent, 0)) != -1) {
CallService (MS_DB_EVENT_DELETE, (WPARAM)hContact, (LPARAM)args.pMsgEntry->hEvent);
free (ptr);
__leave;
}
} else {
msgptr-=9;
memcpy (msgptr, "[EDITED] ", 9);
}
}
if( bEmoted && !isGroupChat) {
CONTACTINFO ci = {0};
int newlen;
char *pMsg, *pszUTFnick=NULL;
ci.cbSize = sizeof(ci);
ci.szProto = SKYPE_PROTONAME;
ci.dwFlag = CNF_DISPLAY | CNF_TCHAR;
if (ci.hContact = hContact) {
CallService(MS_CONTACT_GETCONTACTINFO,0,(LPARAM)&ci);
if (ci.pszVal) {
#ifdef _UNICODE
pszUTFnick = (char*)make_utf8_string(ci.pszVal);
#else
utf8_encode (ci.pszVal, &pszUTFnick);
#endif
mir_free (ci.pszVal);
}
}
newlen = strlen(msgptr) + (pszUTFnick?strlen(pszUTFnick):0) + 9;
if (pMsg = malloc(newlen)) {
sprintf (pMsg, "** %s%s%s **", (pszUTFnick?pszUTFnick:""),(pszUTFnick?" ":""),(char*)msgptr);
free (ptr);
ptr = msgptr = pMsg;
}
if (pszUTFnick) free(pszUTFnick);
}
if (mirandaVersion >= 0x070000 && // 0.7.0+ supports PREF_UTF flag, no need to decode UTF8
!isGroupChat) { // I guess Groupchat doesn't support UTF8?
msg = ptr;
pre.flags |= PREF_UTF;
} else { // Older version has to decode either UTF8->ANSI or UTF8->UNICODE
// This could be replaced by mir_getUTFI - functions for Miranda 0.5+ builds, but we stay
// 0.4 compatible for backwards compatibility. Unfortunately this requires us to link with utf8.c
#ifdef _UNICODE
int wcLen;
#endif
if (utf8_decode(msgptr, &msg)==-1) {
free(ptr);
__leave;
}
#ifdef _UNICODE
msglen = strlen(msg)+1;
msgptr = (char*)make_unicode_string ((const unsigned char*)msgptr);
wcLen = (_tcslen((TCHAR*)msgptr)+1)*sizeof(TCHAR);
msg=realloc(msg, msglen+wcLen);
memcpy (msg+msglen, msgptr, wcLen);
free(msgptr);
pre.flags |= PREF_UNICODE;
#endif
msgptr = msg;
free (ptr);
}
msglen = strlen(msgptr)+1;
} else {
free (ptr);
__leave;
}
// skype sends some xml statics after a call has finished. Check if thats the case and suppress it if necessary...
if ((DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "SuppressCallSummaryMessage", 1) &&
bHasPartList) || msgptr[0]==0) __leave;
if (isGroupChat && bUseGroupChat) {
GCDEST gcd = {0};
GCEVENT gce = {0};
DBVARIANT dbv = {0};
CONTACTINFO ci = {0};
LOG(("FetchMessageThread This is a group chat message"));
if (!hChat) ChatStart(chat, FALSE);
gcd.pszModule = SKYPE_PROTONAME;
gcd.ptszID = make_nonutf_tchar_string((const unsigned char*)chat);
gcd.iType = bEmoted?GC_EVENT_ACTION:GC_EVENT_MESSAGE;
gce.cbSize = sizeof(GCEVENT);
gce.pDest = &gcd;
if ((gce.bIsMe = (direction&DBEF_SENT)?TRUE:FALSE) &&
DBGetContactSettingString(NULL, SKYPE_PROTONAME, SKYPE_NAME, &dbv)==0)
{
free(who);
who = _strdup(dbv.pszVal);
DBFreeVariant(&dbv);
}
gce.ptszUID = make_nonutf_tchar_string((const unsigned char*)who);
ci.cbSize = sizeof(ci);
ci.szProto = SKYPE_PROTONAME;
ci.dwFlag = CNF_DISPLAY | CNF_TCHAR;
ci.hContact = !gce.bIsMe?hContact:NULL;
gce.ptszNick=gce.ptszUID;
if (!CallService(MS_CONTACT_GETCONTACTINFO,0,(LPARAM)&ci)) gce.ptszNick=ci.pszVal;
gce.time = timestamp>0?timestamp:(DWORD)SkypeTime(NULL);
gce.pszText = msgptr;
if (pre.flags & PREF_UNICODE) gce.pszText += msglen;
gce.dwFlags = GCEF_ADDTOLOG | GC_TCHAR;
CallService(MS_GC_EVENT, 0, (LPARAM)&gce);
MsgList_Add (pre.lParam, INVALID_HANDLE_VALUE); // Mark as groupchat
if (ci.pszVal) mir_free (ci.pszVal);
free_nonutf_tchar_string((void*)gce.ptszUID);
free_nonutf_tchar_string(gcd.ptszID);
// Yes, we have successfully read the msg
if (!args.bDontMarkSeen)
SkypeSend("SET %s %s SEEN", cmdMessage, args.msgnum);
__leave;
}
if (args.QueryMsgDirection || (direction&DBEF_SENT)) {
// Check if the timestamp is valid
dbei.cbSize=sizeof(dbei);
dbei.cbBlob=0;
if (hDbEvent=(HANDLE)CallService(MS_DB_EVENT_FINDFIRST,(WPARAM)hContact,0)) {
CallService(MS_DB_EVENT_GET,(WPARAM)hDbEvent,(LPARAM)&dbei);
lwr=dbei.timestamp;
}
dbei.cbSize=sizeof(dbei);
dbei.cbBlob=0;
dbei.timestamp=0;
if (hDbEvent=(HANDLE)CallService(MS_DB_EVENT_FINDLAST,(WPARAM)hContact,0))
CallService(MS_DB_EVENT_GET,(WPARAM)hDbEvent,(LPARAM)&dbei);
LOG(("FetchMessageThread timestamp %ld between %ld and %ld", timestamp, lwr, dbei.timestamp));
if (timestamp<lwr || (direction&DBEF_SENT)) {
TYP_MSGLENTRY *pme;
LOG(("FetchMessageThread Adding event"));
if (!(dbei.szModule=(char*)CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)hContact, 0)))
dbei.szModule=SKYPE_PROTONAME;
dbei.cbBlob=msglen;
if (pre.flags & PREF_UNICODE)
dbei.cbBlob += sizeof(WCHAR)*( (DWORD)wcslen((WCHAR*)&msgptr[dbei.cbBlob])+1);
dbei.pBlob=(PBYTE)msgptr;
dbei.timestamp=timestamp>0?timestamp:(DWORD)SkypeTime(NULL);
dbei.flags=direction;
if (pre.flags & PREF_CREATEREAD) dbei.flags|=DBEF_READ;
if (pre.flags & PREF_UTF) dbei.flags|=DBEF_UTF;
dbei.eventType=EVENTTYPE_MESSAGE;
pme = MsgList_Add (pre.lParam, (HANDLE)CallServiceSync(MS_DB_EVENT_ADD, (WPARAM)(HANDLE)hContact, (LPARAM)&dbei));
// We could call MS_PROTO_CHAINSEND if we want to have MetaContact adding the history for us,
// however we all know that CCSDATA doesn't contain timestamp-information which is
// really bad on importing history for example, as all messages would be added with current
// timestamp. This would cause unreliable jumbled timestamps in metacontact, so we better do this
// ourself.
if (DBGetContactSettingByte(hContact, "MetaContacts", "IsSubcontact", 0))
{
DWORD dwMetaLink = DBGetContactSettingDword(hContact, "MetaContacts", "MetaLink", MAXDWORD);
HANDLE hMetaContact;
if (dwMetaLink != MAXDWORD && (hMetaContact = GetMetaHandle(dwMetaLink)))
{
dbei.szModule=(char*)CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)hMetaContact, 0);
pme->hMetaEvent = (HANDLE)CallServiceSync(MS_DB_EVENT_ADD, (WPARAM)(HANDLE)hMetaContact, (LPARAM)&dbei);
}
}
if (!args.QueryMsgDirection && !args.bDontMarkSeen)
SkypeSend("SET %s %s SEEN", cmdMessage, args.msgnum);
}
}
if (!(direction&DBEF_SENT) && (!args.QueryMsgDirection || (args.QueryMsgDirection && timestamp>dbei.timestamp))) {
LOG(("FetchMessageThread Normal message add..."));
// Normal message received, process it
ccs.szProtoService = PSR_MESSAGE;
ccs.hContact = hContact;
ccs.wParam = 0;
ccs.lParam = (LPARAM)⪯
pre.flags |= direction;
if(isGroupChat && DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "MarkGroupchatRead", 0))
pre.flags |= PREF_CREATEREAD;
pre.timestamp = timestamp>0?timestamp:(DWORD)SkypeTime(NULL);
pre.szMessage = msgptr;
CallServiceSync(MS_PROTO_CHAINRECV, 0, (LPARAM) &ccs);
// Yes, we have successfully read the msg
if (!args.bDontMarkSeen) SkypeSend("SET %s %s SEEN", cmdMessage, args.msgnum);
}
}
__finally {
if (status) free(status);
if (msg) free(msg);
if (users) free(users);
if (chat) free(chat);
if (type) free(type);
if (who) free (who);
}
}
void FetchMessageThreadSync(fetchmsg_arg *pargs) {
// Secure this thread with a mutex.
// This is needed to ensure that we get called after an old msg in the queue has
// been added so that MsgList_FindEntry will find it.
WaitForSingleObject (FetchMessageEvent, 30000); // Wait max. 30 sec. for previous message fetch to complete
if ((pargs->pMsgEntry = MsgList_FindMessage(strtoul(pargs->msgnum, NULL, 10))) && !pargs->pMsgEntry->tEdited) {
// Better don't do this, as we set the msg as read and with this code, we would
// mark messages not opened by user as read which isn't that good
/*
if (pargs->bIsRead && pMsgEvent->hEvent != INVALID_HANDLE_VALUE)
{
HANDLE hContact;
if ((int)(hContact = (HANDLE)CallService (MS_DB_EVENT_GETCONTACT, (WPARAM)pMsgEntry->hEvent, 0)) != -1)
CallService (MS_DB_EVENT_MARKREAD, (WPARAM)hContact, (LPARAM)hDBEvent);
}
*/
free (pargs);
}
else FetchMessageThread (pargs);
SetEvent (FetchMessageEvent);
}
static int MsglCmpProc(const void *pstPElement,const void *pstPToFind)
{
return strcmp ((char*)((fetchmsg_arg*)pstPElement)->pMsgEntry, (char*)((fetchmsg_arg*)pstPToFind)->pMsgEntry);
}
void MessageListProcessingThread(char *str) {
char *token, *nextoken, *chat=NULL;
fetchmsg_arg *args;
TYP_LIST *hListMsgs = List_Init(32);
int i, nCount;
// Frst we need to sort the message timestamps
for ((token=strtok_r(str, ", ", &nextoken)); token; token=strtok_r(NULL, ", ", &nextoken)) {
if (args=calloc(1, sizeof(fetchmsg_arg)+sizeof(DWORD))) {
strncpy (args->msgnum, token, sizeof(args->msgnum));
args->getstatus=TRUE;
args->bIsRead=TRUE;
args->bDontMarkSeen=TRUE;
args->QueryMsgDirection=TRUE;
(char*)args->pMsgEntry = SkypeGet ("CHATMESSAGE", token, "TIMESTAMP"); // Bad abuse of pointer
if (!chat) chat=SkypeGet ("CHATMESSAGE", token, "CHATNAME");
if (args->pMsgEntry) List_InsertSort (hListMsgs, MsglCmpProc, args);
else free(args);
}
}
for (i=0, nCount=List_Count(hListMsgs); i<nCount; i++) {
args = List_ElementAt (hListMsgs, i);
free (args->pMsgEntry);
args->pMsgEntry = NULL;
FetchMessageThreadSync (args);
}
if (chat) {
SkypeSend ("GET CHAT %s MEMBERS", chat);
free (chat);
}
List_Exit (hListMsgs);
free (str);
}
char *GetCallerHandle(char *szSkypeMsg) {
return SkypeGet(szSkypeMsg, "PARTNER_HANDLE", "");
}
HANDLE GetCallerContact(char *szSkypeMsg) {
char *szHandle;
HANDLE hContact=NULL;
if (!(szHandle=GetCallerHandle(szSkypeMsg))) return NULL;
if (!(hContact=find_contact(szHandle))) {
// If it's a SkypeOut-contact, PARTNER_HANDLE = SkypeOUT number
DBVARIANT dbv;
int tCompareResult;
for (hContact=(HANDLE)CallService(MS_DB_CONTACT_FINDFIRST, 0, 0);hContact != NULL;hContact=(HANDLE)CallService( MS_DB_CONTACT_FINDNEXT, (WPARAM)hContact, 0)) {
if (DBGetContactSettingString(hContact, SKYPE_PROTONAME, "SkypeOutNr", &dbv)) continue;
tCompareResult = strcmp(dbv.pszVal, szHandle);
DBFreeVariant(&dbv);
if (tCompareResult) continue; else break;
}
}
free(szHandle);
if (!hContact) {LOG(("GetCallerContact Not found!"));}
return hContact;
}
HANDLE GetMetaHandle(DWORD dwId) {
HANDLE hContact;
char *szProto;
for (hContact=(HANDLE)CallService(MS_DB_CONTACT_FINDFIRST, 0, 0);hContact != NULL;hContact=(HANDLE)CallService( MS_DB_CONTACT_FINDNEXT, (WPARAM)hContact, 0)) {
szProto = (char*)CallService( MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)hContact, 0 );
if (szProto!=NULL && !strcmp(szProto, "MetaContacts") &&
DBGetContactSettingDword(hContact, "MetaContacts", "MetaID", MAXDWORD)==dwId)
return hContact;
}
return 0;
}
LRESULT CALLBACK InCallPopUpProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
switch(msg)
{
case WM_COMMAND:
break;
case WM_CONTEXTMENU:
SendMessage(hwnd,UM_DESTROYPOPUP,0,0);
break;
case UM_FREEPLUGINDATA:
//Here we'd free our own data, if we had it.
return FALSE;
case UM_INITPOPUP:
break;
case UM_DESTROYPOPUP:
break;
case WM_NOTIFY:
default:
break;
}
return DefWindowProc(hwnd,msg,wParam,lParam);
}
void RingThread(char *szSkypeMsg) {
HANDLE hContact;
DBEVENTINFO dbei={0};
DBVARIANT dbv;
char *ptr = NULL;
// We use a single critical section for the RingThread- and the EndCallThread-functions
// so that only one function is running at the same time. This is needed, because when
// a initated and unaccepted call (which is still ringing) is hangup/canceled, skype
// sends two messages. First "CALL xxx STATUS RINGING" .. second "CALL xx STATUS CANCELED".
// This starts two independend threads (first: RingThread; second: EndCallThread). Now
// the two message are processed in reverse order sometimes. This causes the EndCallThread to
// delete the contacts "CallId" property and after that the RingThread saves the contacts
// "CallId" again. After that its not possible to call this contact, because the plugin
// thinks that there is already a call going and the hangup-function isnt working, because
// skype doesnt accept status-changes for finished calls. The CriticalSection syncronizes
// the threads and the messages are processed in correct order.
// Not the best solution, but it works.
EnterCriticalSection (&RingAndEndcallMutex);
LOG(("RingThread started."));
if (protocol >= 5) SkypeSend ("MINIMIZE");
if (hContact=GetCallerContact(szSkypeMsg)) {
// Make sure that an answering thread is not already in progress so that we don't get
// the 'Incoming call' event twice
if (!DBGetContactSettingString(hContact, SKYPE_PROTONAME, "CallId", &dbv)) {
DBFreeVariant(&dbv);
LOG(("RingThread terminated."));
goto l_exitRT;
}
DBWriteContactSettingString(hContact, SKYPE_PROTONAME, "CallId", szSkypeMsg);
}
if (!(ptr=SkypeGet(szSkypeMsg, "TYPE", ""))) {
LOG(("RingThread terminated."));
goto l_exitRT;;
}
if (!strncmp(ptr, "INCOMING", 8))
NofifyVoiceService(hContact, szSkypeMsg, VOICE_STATE_RINGING);
else
NofifyVoiceService(hContact, szSkypeMsg, VOICE_STATE_CALLING);
if (!strncmp(ptr, "INCOMING", 8)) {
if (!hContact) {
char *szHandle;
if (szHandle=GetCallerHandle(szSkypeMsg)) {
if (!(hContact=add_contact(szHandle, PALF_TEMPORARY))) {
free(szHandle);
goto l_exitRT;
}
DBDeleteContactSetting(hContact, "CList", "Hidden");
DBWriteContactSettingWord(hContact, SKYPE_PROTONAME, "Status", (WORD)SkypeStatusToMiranda("SKYPEOUT"));
DBWriteContactSettingString(hContact, SKYPE_PROTONAME, "SkypeOutNr", szHandle);
free(szHandle);
} else goto l_exitRT;
}
}
if (HasVoiceService()) {
// Voice service will handle it
goto l_exitRT;
}
dbei.cbSize=sizeof(dbei);
dbei.eventType=EVENTTYPE_CALL;
dbei.szModule=SKYPE_PROTONAME;
dbei.timestamp=(DWORD)SkypeTime(NULL);
dbei.pBlob=(unsigned char*)Translate("Phonecall");
dbei.cbBlob=strlen((const char*)dbei.pBlob)+1;
if (!strncmp(ptr, "INCOMING", 8))
{
CLISTEVENT cle={0};
char toolTip[256];
if(PopupServiceExists)
{
BOOL showPopup, popupWindowColor;
unsigned int popupBackColor, popupTextColor;
int popupTimeSec;
POPUPDATAT InCallPopup;
TCHAR * lpzContactName = (TCHAR*)CallService(MS_CLIST_GETCONTACTDISPLAYNAME,(WPARAM)hContact,GCDNF_TCHAR);
popupTimeSec = DBGetContactSettingDword(NULL, SKYPE_PROTONAME, "popupTimeSec", 4);
popupTextColor = DBGetContactSettingDword(NULL, SKYPE_PROTONAME, "popupTextColor", GetSysColor(COLOR_WINDOWTEXT));
popupBackColor = DBGetContactSettingDword(NULL, SKYPE_PROTONAME, "popupBackColor", GetSysColor(COLOR_BTNFACE));
popupWindowColor = (0 != DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "popupWindowColor", TRUE));
showPopup = (0 != DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "showPopup", TRUE));
InCallPopup.lchContact = hContact;
InCallPopup.lchIcon = LoadIcon(hInst,MAKEINTRESOURCE(IDI_CALL));
InCallPopup.colorBack = ! popupWindowColor ? popupBackColor : GetSysColor(COLOR_BTNFACE);
InCallPopup.colorText = ! popupWindowColor ? popupTextColor : GetSysColor(COLOR_WINDOWTEXT);
InCallPopup.iSeconds = popupTimeSec;
InCallPopup.PluginWindowProc = (WNDPROC)InCallPopUpProc;
InCallPopup.PluginData = (void *)1;
lstrcpy(InCallPopup.lptzText, TranslateT("Incoming Skype Call"));
lstrcpy(InCallPopup.lptzContactName, lpzContactName);
if(showPopup)
CallService(MS_POPUP_ADDPOPUPT,(WPARAM)&InCallPopup,0);
}
cle.cbSize=sizeof(cle);
cle.hIcon=LoadIcon(hInst,MAKEINTRESOURCE(IDI_CALL));
cle.pszService=SKYPE_ANSWERCALL;
dbei.flags=DBEF_READ;
cle.hContact=hContact;
cle.hDbEvent=(HANDLE)CallService(MS_DB_EVENT_ADD,(WPARAM)hContact,(LPARAM)&dbei);
_snprintf(toolTip,sizeof(toolTip),Translate("Incoming call from %s"),(char*)CallService(MS_CLIST_GETCONTACTDISPLAYNAME,(WPARAM)hContact,0));
cle.pszTooltip=toolTip;
CallServiceSync(MS_CLIST_ADDEVENT,0,(LPARAM)&cle);
}
else
{
dbei.flags=DBEF_SENT;
CallService(MS_DB_EVENT_ADD,(WPARAM)hContact,(LPARAM)&dbei);
}
l_exitRT:
if (ptr) free (ptr);
free(szSkypeMsg);
LeaveCriticalSection (&RingAndEndcallMutex);
}
void EndCallThread(char *szSkypeMsg) {
HANDLE hContact=NULL, hDbEvent;
DBEVENTINFO dbei={0};
DBVARIANT dbv;
int tCompareResult;
// We use a single critical section for the RingThread- and the EndCallThread-functions
// so that only one function is running at the same time. This is needed, because when
// a initated and unaccepted call (which is still ringing) is hangup/canceled, skype
// sends two messages. First "CALL xxx STATUS RINGING" .. second "CALL xx STATUS CANCELED".
// This starts two independend threads (first: RingThread; second: EndCallThread). Now
// the two message are processed in reverse order sometimes. This causes the EndCallThread to
// delete the contacts "CallId" property and after that the RingThread saves the contacts
// "CallId" again. After that its not possible to call this contact, because the plugin
// thinks that there is already a call going and the hangup-function isnt working, because
// skype doesnt accept status-changes for finished calls. The CriticalSection syncronizes
// the threads and the messages are processed in correct order.
// Not the best solution, but it works.
EnterCriticalSection (&RingAndEndcallMutex);
LOG(("EndCallThread started."));
if (szSkypeMsg) {
for (hContact=(HANDLE)CallService(MS_DB_CONTACT_FINDFIRST, 0, 0);hContact != NULL;hContact=(HANDLE)CallService( MS_DB_CONTACT_FINDNEXT, (WPARAM)hContact, 0)) {
if (DBGetContactSettingString(hContact, SKYPE_PROTONAME, "CallId", &dbv)) continue;
tCompareResult = strcmp(dbv.pszVal, szSkypeMsg);
DBFreeVariant(&dbv);
if (tCompareResult) continue; else break;
}
}
if (hContact)
{
NofifyVoiceService(hContact, szSkypeMsg, VOICE_STATE_ENDED);
DBDeleteContactSetting(hContact, SKYPE_PROTONAME, "CallId");
if (!HasVoiceService()) {
dbei.cbSize=sizeof(dbei);
hDbEvent=(HANDLE)CallService(MS_DB_EVENT_FINDFIRSTUNREAD,(WPARAM)hContact,0);
while(hDbEvent) {
dbei.cbBlob=0;
CallService(MS_DB_EVENT_GET,(WPARAM)hDbEvent,(LPARAM)&dbei);
if (!(dbei.flags&(DBEF_SENT|DBEF_READ)) && dbei.eventType==EVENTTYPE_CALL) {
CallService(MS_DB_EVENT_MARKREAD,(WPARAM)hContact,(LPARAM)hDbEvent);
CallService(MS_CLIST_REMOVEEVENT,(WPARAM)hContact,(LPARAM)hDbEvent);
}
if (dbei.pBlob) free(dbei.pBlob);
hDbEvent=(HANDLE)CallService(MS_DB_EVENT_FINDNEXT,(WPARAM)hDbEvent,0);
}
}
if (!DBGetContactSettingString(hContact, SKYPE_PROTONAME, "SkypeOutNr", &dbv)) {
DBFreeVariant(&dbv);
if (!strcmp((char *)CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)hContact, 0), SKYPE_PROTONAME) &&
DBGetContactSettingByte(hContact, "CList", "NotOnList", 0)
)
CallService(MS_DB_CONTACT_DELETE, (WPARAM)hContact, 0);
}
}
free(szSkypeMsg);
LeaveCriticalSection (&RingAndEndcallMutex);
}
void HoldCallThread(char *szSkypeMsg) {
HANDLE hContact;
LOG(("HoldCallThread started"));
if (!szSkypeMsg) {
LOG(("HoldCallThread terminated."));
return;
}
if (hContact=GetCallerContact(szSkypeMsg)) {
DBWriteContactSettingByte(hContact, SKYPE_PROTONAME, "OnHold", 1);
NofifyVoiceService(hContact, szSkypeMsg, VOICE_STATE_ON_HOLD);
}
free(szSkypeMsg);
LOG(("HoldCallThread terminated gracefully"));
}
void ResumeCallThread(char *szSkypeMsg) {
HANDLE hContact;
LOG(("ResumeCallThread started"));
if (!szSkypeMsg) {
LOG(("ResumeCallThread terminated."));
return;
}
if (hContact=GetCallerContact(szSkypeMsg)) {
DBDeleteContactSetting(hContact, SKYPE_PROTONAME, "OnHold");
NofifyVoiceService(hContact, szSkypeMsg, VOICE_STATE_TALKING);
}
free(szSkypeMsg);
LOG(("ResumeCallThread terminated gracefully."));
}
int SetUserStatus(void) {
if (RequestedStatus && AttachStatus!=-1) {
if (SkypeSend("SET USERSTATUS %s", RequestedStatus)==-1) return 1;
}
return 0;
}
void LaunchSkypeAndSetStatusThread(void *newStatus) {
/* if (!DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "UnloadOnOffline", 0)) {
logoff_contacts();
return 1;
}
*/
int oldStatus=SkypeStatus;
static BOOL bLaunching = FALSE;
UNREFERENCED_PARAMETER(newStatus);
if (bLaunching) return;
bLaunching = TRUE;
LOG (("LaunchSkypeAndSetStatusThread started."));
InterlockedExchange((long *)&SkypeStatus, (int)ID_STATUS_CONNECTING);
ProtoBroadcastAck(SKYPE_PROTONAME, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE) oldStatus, SkypeStatus);
if (ConnectToSkypeAPI(skype_path, 1)!=-1) {
forkthread(( pThreadFunc )SkypeSystemInit, 0, NULL);
//InterlockedExchange((long *)&SkypeStatus, (int)newStatus);
//ProtoBroadcastAck(SKYPE_PROTONAME, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE) oldStatus, SkypeStatus);
SetUserStatus();
}
LOG (("LaunchSkypeAndSetStatusThread terminated gracefully."));
bLaunching = FALSE;
}
LONG APIENTRY WndProc(HWND hWndDlg, UINT message, UINT wParam, LONG lParam)
{
PCOPYDATASTRUCT CopyData;
char *ptr, *szSkypeMsg=NULL, *nick, *buf;
static char *onlinestatus=NULL;
static BOOL RestoreUserStatus=FALSE;
int sstat, oldstatus, flag;
HANDLE hContact;
fetchmsg_arg *args;
static int iReentranceCnt = 0;
iReentranceCnt++;
switch (message)
{
case WM_COPYDATA:
LOG(("WM_COPYDATA start"));
if(hSkypeWnd==(HWND)wParam) {
char *pData;
CopyData=(PCOPYDATASTRUCT)lParam;
pData = (char*)CopyData->lpData;
while (*pData==' ') pData++;
szSkypeMsg=_strdup((char*)pData);
ReplyMessage(1);
LOG(("< %s", szSkypeMsg));
if (!strncmp(szSkypeMsg, "CONNSTATUS", 10)) {
if (!strncmp(szSkypeMsg+11, "LOGGEDOUT", 9)) {
SkypeInitialized=FALSE;
ResetEvent(SkypeReady);
AttachStatus=-1;
sstat=ID_STATUS_OFFLINE;
if (g_hWnd) KillTimer (g_hWnd, 1);
logoff_contacts(TRUE);
} else
sstat=SkypeStatusToMiranda(szSkypeMsg+11);
if (sstat) {
oldstatus=SkypeStatus;
InterlockedExchange((long*)&SkypeStatus, sstat);
ProtoBroadcastAck(SKYPE_PROTONAME, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE) oldstatus, SkypeStatus);
if (sstat!=ID_STATUS_OFFLINE) {
if (sstat!=ID_STATUS_CONNECTING && (oldstatus==ID_STATUS_OFFLINE || oldstatus==ID_STATUS_CONNECTING)) {
SkypeInitialized=FALSE;
forkthread(( pThreadFunc )SkypeSystemInit, 0, NULL);
}
if (DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "KeepState", 0)) RestoreUserStatus=TRUE;
}
// if (SkypeStatus==ID_STATUS_ONLINE) SkypeSend("SEARCH MISSEDMESSAGES");
}
// break;
}
if (!strncmp(szSkypeMsg, "USERSTATUS", 10)) {
// if ((sstat=SkypeStatusToMiranda(szSkypeMsg+11)) && SkypeStatus!=ID_STATUS_CONNECTING) {
if ((sstat=SkypeStatusToMiranda(szSkypeMsg+11))) {
if (RestoreUserStatus && RequestedStatus) {
RestoreUserStatus=FALSE;
SkypeSend ("SET USERSTATUS %s", RequestedStatus);
}
oldstatus=SkypeStatus;
InterlockedExchange((long*)&SkypeStatus, sstat);
ProtoBroadcastAck(SKYPE_PROTONAME, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE) oldstatus, sstat);
#ifdef SKYPEBUG_OFFLN
if ((oldstatus==ID_STATUS_OFFLINE || oldstatus==ID_STATUS_CONNECTING) &&
SkypeStatus!=ID_STATUS_CONNECTING && SkypeStatus!=ID_STATUS_OFFLINE)
forkthread(( pThreadFunc )SearchFriendsThread, 0, NULL);
#endif
}
#ifdef SKYPEBUG_OFFLN
SetEvent(GotUserstatus);
#endif
break;
}
if (!strncmp(szSkypeMsg, "APPLICATION libpurple_typing", 28)) {
char *nextoken, *p;
if (p=strtok_r(szSkypeMsg+29, " ", &nextoken))
{
if (!strcmp (p, "STREAMS")) {
char *pStr;
while (p=strtok_r(NULL, " ", &nextoken)) {
if (pStr = strchr(p, ':')) {
*pStr=0;
if (hContact=find_contact(p)) {
*pStr=':';
DBWriteContactSettingString(hContact, SKYPE_PROTONAME, "Typing_Stream", p);
}
}
}
}
else if (!strcmp (p, "DATAGRAM")) {
if (p=strtok_r(NULL, " ", &nextoken)) {
char *pStr;
if (pStr = strchr(p, ':')) {
*pStr=0;
if (hContact=find_contact(p)) {
*pStr=':';
DBWriteContactSettingString(hContact, SKYPE_PROTONAME, "Typing_Stream", p);
if (p=strtok_r(NULL, " ", &nextoken)) {
LPARAM lTyping = PROTOTYPE_CONTACTTYPING_OFF;
if (!strcmp(p, "PURPLE_TYPING")) lTyping=PROTOTYPE_CONTACTTYPING_INFINITE;
CallService(MS_PROTO_CONTACTISTYPING, (WPARAM)hContact, lTyping);
break;
}
}
}
}
}
}
}
if (!strncmp(szSkypeMsg, "USER ", 5)) {
char *nextoken;
buf=_strdup(szSkypeMsg+5);
nick=strtok_r(buf, " ", &nextoken);
ptr=strtok_r(NULL, " ", &nextoken);
if (strcmp(ptr, "BUDDYSTATUS")) {
if (!strcmp(ptr, "RECEIVEDAUTHREQUEST")) {
forkthread(( pThreadFunc )SearchUsersWaitingMyAuthorization, 0, NULL);
free (buf);
break;
}
if (!(hContact=find_contact(nick)) && strcmp(ptr, "FULLNAME")) {
SkypeSend("GET USER %s BUDDYSTATUS", nick);
free (buf);
break;
}
if (!strcmp(ptr, "ONLINESTATUS")) {
if (SkypeStatus!=ID_STATUS_OFFLINE)
{
DBWriteContactSettingWord(hContact, SKYPE_PROTONAME, "Status", (WORD)SkypeStatusToMiranda(ptr+13));
if((WORD)SkypeStatusToMiranda(ptr+13) != ID_STATUS_OFFLINE)
{
LOG(("WndProc Status is not offline so get user info"));
forkthread(GetInfoThread, 0, hContact);
}
}
}
/* We handle the following properties right here in the wndProc, in case that
* Skype protocol broadcasts them to us.
*
* However, we still let them be added to the Message queue im memory, as they
* may get consumed by GetInfoThread.
* This is necessary to have a proper error handling in case the property is
* not supported (i.e. imo2sproxy).
*
* If one of the property GETs returns an error, the error-message has to be
* removed from the message queue, as the error is the answer to the query.
* If we don't remove the ERRORs from the list, another consumer may see the ERROR
* as a reply to his query and process it.
* In case the SKYPE Protocol really broadcasts one of these messages without being
* requested by GetInfoThread (i.e. MOOD_TEXT), the garbage collector will take
* care of them and remove them after some time.
* This may not be the most efficient way, but ensures that we finally do proper
* error handling.
*/
if (!strcmp(ptr, "FULLNAME")) {
char *nm;
if (nm = strtok_r(NULL, " ", &nextoken))
{
SkypeDBWriteContactSettingUTF8String(hContact, SKYPE_PROTONAME, "FirstName", nm);
if (!(nm=strtok_r(NULL, "", &nextoken))) DBDeleteContactSetting(hContact, SKYPE_PROTONAME, "LastName");
else
SkypeDBWriteContactSettingUTF8String(hContact, SKYPE_PROTONAME, "LastName", nm);
}
} else
if (!strcmp(ptr, "BIRTHDAY")) {
unsigned int y, m, d;
if (sscanf(ptr+9, "%04d%02d%02d", &y, &m, &d)==3) {
DBWriteContactSettingWord(hContact, SKYPE_PROTONAME, "BirthYear", (WORD)y);
DBWriteContactSettingByte(hContact, SKYPE_PROTONAME, "BirthMonth", (BYTE)m);
DBWriteContactSettingByte(hContact, SKYPE_PROTONAME, "BirthDay", (BYTE)d);
} else {
DBDeleteContactSetting(hContact, SKYPE_PROTONAME, "BirthYear");
DBDeleteContactSetting(hContact, SKYPE_PROTONAME, "BirthMonth");
DBDeleteContactSetting(hContact, SKYPE_PROTONAME, "BirthDay");
}
} else
if (!strcmp(ptr, "COUNTRY")) {
if (ptr[8]) {
struct CountryListEntry *countries;
int countryCount, i;
CallService(MS_UTILS_GETCOUNTRYLIST, (WPARAM)&countryCount, (LPARAM)&countries);
for (i=0; i<countryCount; i++) {
if (countries[i].id == 0 || countries[i].id == 0xFFFF) continue;
if (!_stricmp(countries[i].szName, ptr+8))
{
DBWriteContactSettingWord(hContact, SKYPE_PROTONAME, "Country", (BYTE)countries[i].id);
break;
}
}
} else DBDeleteContactSetting(hContact, SKYPE_PROTONAME, "Country");
} else
if (!strcmp(ptr, "SEX")) {
if (ptr[4]) {
BYTE sex=0;
if (!_stricmp(ptr+4, "MALE")) sex=0x4D;
if (!_stricmp(ptr+4, "FEMALE")) sex=0x46;
if (sex) DBWriteContactSettingByte(hContact, SKYPE_PROTONAME, "Gender", sex);
} else DBDeleteContactSetting(hContact, SKYPE_PROTONAME, "Gender");
} else
/* if (!strcmp(ptr, "AVATAR" )){
LOG("WndProc", "AVATAR");
if (!(hContact=find_contact(nick)))
SkypeSend("GET USER %s BUDDYSTATUS", nick);
else
{
TCHAR *unicode = NULL;
if(utf8_decode((ptr+9), &Avatar)==-1) break;
if( ServiceExists(MS_AV_SETAVATAR) )
{
CallService(MS_AV_SETAVATAR,(WPARAM) hContact,(LPARAM) Avatar);
}
else
{
if(DBWriteContactSettingTString(hContact, "ContactPhoto", "File", Avatar))
{
#if defined( _UNICODE )
char buff[TEXT_LEN];
WideCharToMultiByte(code_page, 0, Avatar, -1, buff, TEXT_LEN, 0, 0);
buff[TEXT_LEN] = 0;
DBWriteContactSettingString(hContact, "ContactPhoto", "File", buff);
#endif
}
}
}
free(buf);
break;
}
*/
if (!strcmp(ptr, "MOOD_TEXT")){
LOG(("WndProc MOOD_TEXT"));
SkypeDBWriteContactSettingUTF8String (hContact, "CList", "StatusMsg", ptr+10);
} else
if (!strcmp(ptr, "TIMEZONE")){
time_t temp;
struct tm tms;
int value=atoi(ptr+9), tz;
LOG(("WndProc: TIMEZONE %s", nick));
if (value && !DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "IgnoreTimeZones", 0)) {
temp = SkypeTime(NULL);
tms = *localtime(&temp);
//memcpy(&tms,localtime(&temp), sizeof(tm));
//tms = localtime(&temp)
tz=(value >= 86400 )?(256-((2*(atoi(ptr+9)-86400))/3600)):((-2*(atoi(ptr+9)-86400))/3600);
if (tms.tm_isdst == 1 && DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "UseTimeZonePatch", 0))
{
LOG(("WndProc: Using the TimeZonePatch"));
DBWriteContactSettingByte(hContact, "UserInfo", "Timezone", (BYTE)(tz+2));
}
else
{
LOG(("WndProc: Not using the TimeZonePatch"));
DBWriteContactSettingByte(hContact, "UserInfo", "Timezone", (BYTE)(tz+0));
}
} else {
LOG(("WndProc: Deleting the TimeZone in UserInfo Section"));
DBDeleteContactSetting(hContact, "UserInfo", "Timezone");
}
} else
if (!strcmp(ptr, "IS_VIDEO_CAPABLE")){
if (!_stricmp(ptr + 17, "True"))
DBWriteContactSettingString(hContact, SKYPE_PROTONAME, "MirVer", "Skype 2.0");
else
DBWriteContactSettingString(hContact, SKYPE_PROTONAME, "MirVer", "Skype");
} else
if (!strcmp(ptr, "RICH_MOOD_TEXT")) {
DBWriteContactSettingString(hContact, SKYPE_PROTONAME, "MirVer", "Skype 3.0");
} else
if (!strcmp(ptr, "DISPLAYNAME")) {
// Skype Bug? -> If nickname isn't customised in the Skype-App, this won't return anything :-(
if (ptr[12])
SkypeDBWriteContactSettingUTF8String(hContact, SKYPE_PROTONAME, "Nick", ptr+12);
} else // Other proerties that can be directly assigned to a DB-Value
{
int i;
char *pszProp;
for (i=0; i<sizeof(m_settings)/sizeof(m_settings[0]); i++) {
if (!strcmp(ptr, m_settings[i].SkypeSetting)) {
pszProp = ptr+strlen(m_settings[i].SkypeSetting)+1;
if (*pszProp)
SkypeDBWriteContactSettingUTF8String(hContact, SKYPE_PROTONAME, m_settings[i].MirandaSetting, pszProp);
else
DBDeleteContactSetting(hContact, SKYPE_PROTONAME, m_settings[i].MirandaSetting);
}
}
}
} else { // BUDDYSTATUS:
flag=0;
switch(atoi(ptr+12)) {
case 1: if (hContact=find_contact(nick)) CallService(MS_DB_CONTACT_DELETE, (WPARAM)hContact, 0); break;
case 0: break;
case 2: flag=PALF_TEMPORARY;
case 3: add_contact(nick, flag);
SkypeSend("GET USER %s ONLINESTATUS", nick);
break;
}
free(buf);
if (!SetEvent(hBuddyAdded)) TellError(GetLastError());
break;
}
free(buf);
}
if (!strncmp(szSkypeMsg, "CURRENTUSERHANDLE", 17)) { // My username
DBVARIANT dbv={0};
if(DBGetContactSettingString(NULL,SKYPE_PROTONAME,"LoginUserName",&dbv) ||
!*dbv.pszVal || _stricmp (szSkypeMsg+18, dbv.pszVal)==0)
{
DBWriteContactSettingString(NULL, SKYPE_PROTONAME, SKYPE_NAME, szSkypeMsg+18);
DBWriteContactSettingString(NULL, SKYPE_PROTONAME, "Nick", szSkypeMsg+18);
forkthread(( pThreadFunc )GetDisplaynameThread, 0, NULL);
}
if (dbv.pszVal) DBFreeVariant(&dbv);
}
if (strstr(szSkypeMsg, "AUTOAWAY") || !strncmp(szSkypeMsg, "OPEN ",5) ||
(SkypeInitialized && !strncmp (szSkypeMsg, "PONG", 4)) ||
!strncmp (szSkypeMsg, "MINIMIZE", 8))
{
// Currently we do not process these messages
break;
}
if (!strncmp(szSkypeMsg, "CHAT ", 5)) {
// Currently we only process these notifications
if (DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "UseGroupchat", 0) &&
(ptr = strchr (szSkypeMsg, ' ')) && (ptr = strchr (++ptr, ' ')))
{
if (strncmp(ptr, " MEMBERS", 8) == 0) {
LOG(("WndProc AddMembers"));
forkthread(( pThreadFunc )AddMembersThread, 0, _strdup(szSkypeMsg));
} else
if (strncmp(ptr, " FRIENDLYNAME ", 14) == 0) {
// Chat session name
HANDLE hContact;
*ptr=0;
if (hContact = find_chatA(szSkypeMsg+5))
{
GCDEST gcd = {0};
GCEVENT gce = {0};
if (DBGetContactSettingWord(hContact, SKYPE_PROTONAME, "Status", ID_STATUS_OFFLINE) !=
ID_STATUS_OFFLINE)
{
gcd.pszModule = SKYPE_PROTONAME;
gcd.ptszID = make_nonutf_tchar_string((const unsigned char*)szSkypeMsg+5);
gcd.iType = GC_EVENT_CHANGESESSIONAME;
gce.cbSize = sizeof(GCEVENT);
gce.pDest = &gcd;
gce.ptszText = make_tchar_string((const unsigned char*)ptr+14);
gce.dwFlags = GC_TCHAR;
if (gce.ptszText) {
CallService(MS_GC_EVENT, 0, (LPARAM)&gce);
DBWriteContactSettingTString (hContact, SKYPE_PROTONAME, "Nick", gce.ptszText);
free((void*)gce.ptszText);
}
free_nonutf_tchar_string((void*)gcd.ptszID);
}
}
*ptr=' ';
} else
if (strncmp(ptr, " CHATMESSAGES ", 14) == 0) {
forkthread(( pThreadFunc )MessageListProcessingThread, 0, _strdup(ptr+14));
break;
}
}
}
if (!strncmp(szSkypeMsg, "CALL ",5)) {
// incoming calls are already processed by Skype, so no need for us
// to do this.
// However we can give a user the possibility to hang up a call via Miranda's
// context menu
if (ptr=strstr(szSkypeMsg, " STATUS ")) {
ptr[0]=0; ptr+=8;
if (!strcmp(ptr, "RINGING") || !strcmp(ptr, "ROUTING")) forkthread(( pThreadFunc )RingThread, 0, _strdup(szSkypeMsg));
if (!strcmp(ptr, "FAILED") || !strcmp(ptr, "FINISHED") ||
!strcmp(ptr, "MISSED") || !strcmp(ptr, "REFUSED") ||
!strcmp(ptr, "BUSY") || !strcmp(ptr, "CANCELLED"))
forkthread(( pThreadFunc )EndCallThread, 0, _strdup(szSkypeMsg));
if (!strcmp(ptr, "ONHOLD") || !strcmp(ptr, "LOCALHOLD") ||
!strcmp(ptr, "REMOTEHOLD")) forkthread(( pThreadFunc )HoldCallThread, 0, _strdup(szSkypeMsg));
if (!strcmp(ptr, "INPROGRESS")) forkthread(( pThreadFunc )ResumeCallThread, 0, _strdup(szSkypeMsg));
break;
} else if ((!strstr(szSkypeMsg, "PARTNER_HANDLE") && !strstr(szSkypeMsg, "FROM_HANDLE"))
&& !strstr(szSkypeMsg, "TYPE")) break;
}
if (!strncmp(szSkypeMsg, "PRIVILEGE SKYPEOUT", 18)) {
if (!strncmp(szSkypeMsg+19, "TRUE", 4)) {
if (!bSkypeOut) {
CLISTMENUITEM mi={0};
bSkypeOut=TRUE;
mi.cbSize=sizeof(mi);
mi.position=-2000005000;
mi.flags=0;
mi.hIcon=LoadIcon(hInst,MAKEINTRESOURCE(IDI_CALLSKYPEOUT));
mi.pszContactOwner=SKYPE_PROTONAME;
mi.pszName=Translate("Do a SkypeOut-call");
mi.pszService=SKYPEOUT_CALL;
Menu_AddMainMenuItem(&mi);
}
} else {
bSkypeOut=FALSE;
if (httbButton) {
CallService(MS_TTB_REMOVEBUTTON, (WPARAM)httbButton, 0);
httbButton=0;
}
}
break;
}
if (!strncmp(szSkypeMsg, "MESSAGES", 8) || !strncmp(szSkypeMsg, "CHATMESSAGES", 12)) {
if (strlen(szSkypeMsg)<=(UINT)(strchr(szSkypeMsg, ' ')-szSkypeMsg+1))
{
LOG(( "%s %d %s %d", szSkypeMsg,(UINT)(strchr(szSkypeMsg, ' ')-szSkypeMsg+1),
strchr(szSkypeMsg, ' '), strlen(szSkypeMsg)));
break;
}
LOG(("MessageListProcessingThread launched"));
forkthread(( pThreadFunc )MessageListProcessingThread, 0, _strdup(strchr(szSkypeMsg, ' ')+1));
break;
}
if (!strncmp(szSkypeMsg, "MESSAGE", 7) || !strncmp(szSkypeMsg, "CHATMESSAGE", 11))
{
char *pMsgNum;
TYP_MSGLENTRY *pEntry;
if ((pMsgNum = strchr (szSkypeMsg, ' ')) && (ptr = strchr (++pMsgNum, ' ')))
{
BOOL bFetchMsg = FALSE;
if (strncmp(ptr, " EDITED_TIMESTAMP", 17) == 0) {
ptr[0]=0;
if (pEntry = MsgList_FindMessage(strtoul(pMsgNum, NULL, 10))) {
pEntry->tEdited = atol(ptr+18);
}
bFetchMsg = TRUE;
} else bFetchMsg = (strncmp(ptr, " STATUS RE", 10) == 0 && !rcvwatchers) ||
(strncmp(ptr, " STATUS SENT", 12) == 0 && !sendwatchers);
if (bFetchMsg) {
// If new message is available, fetch it
ptr[0]=0;
if (!(args=(fetchmsg_arg *)calloc(1, sizeof(*args)))) break;
strncpy (args->msgnum, pMsgNum, sizeof(args->msgnum));
args->getstatus=FALSE;
//args->bIsRead = strncmp(ptr+8, "READ", 4) == 0;
forkthread(( pThreadFunc )FetchMessageThreadSync, 0, args);
break;
}
}
}
if (!strncmp(szSkypeMsg, "ERROR 68", 8)) {
LOG(("We got a sync problem :( -> SendMessage() will try to recover..."));
break;
}
if (!strncmp(szSkypeMsg, "PROTOCOL ", 9)) {
if ((protocol=(char)atoi(szSkypeMsg+9))>=3) {
strcpy(cmdMessage, "CHATMESSAGE");
strcpy(cmdPartner, "FROM");
}
bProtocolSet = TRUE;
if (protocol<5 && !hMenuAddSkypeContact &&
DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "EnableMenu", 1))
{
hMenuAddSkypeContact = add_mainmenu();
}
}
LOG(("SkypeMsgAdd launched"));
SkypeMsgAdd(szSkypeMsg);
ReleaseSemaphore(SkypeMsgReceived, receivers, NULL);
}
break;
case WM_TIMER:
if (iReentranceCnt>1) break;
if (!bIsImoproxy) SkypeSend("PING");
SkypeMsgCollectGarbage(MAX_MSG_AGE);
MsgList_CollectGarbage();
if (receivers>1)
{
LOG(("Watchdog WARNING: there are still %d receivers waiting for MSGs", receivers));
}
break;
case WM_CLOSE:
PostQuitMessage (0);
break;
case WM_DESTROY:
KillTimer (hWndDlg, 1);
break;
default:
if(message==ControlAPIAttach) {
// Skype responds with Attach to the discover-message
if ((HWND)wParam == hForbiddenSkypeWnd) {
ResetEvent(SkypeReady);
break;
}
AttachStatus=lParam;
if (lParam==SKYPECONTROLAPI_ATTACH_SUCCESS) {
LOG (("AttachStatus success, got hWnd %08X", (HWND)wParam));
if (hSkypeWnd && (HWND)wParam!=hSkypeWnd && IsWindow(hSkypeWnd))
hSkypeWndSecondary = (HWND)wParam;
else {
hSkypeWnd=(HWND)wParam; // Skype gave us the communication window handle
hSkypeWndSecondary = NULL;
}
}
if (AttachStatus!=SKYPECONTROLAPI_ATTACH_API_AVAILABLE &&
AttachStatus!=SKYPECONTROLAPI_ATTACH_NOT_AVAILABLE)
{
LOG(("Attaching: SkypeReady fired, Attachstatus is %d", AttachStatus));
SetEvent(SkypeReady);
}
AttachStatus=lParam;
break;
}
--iReentranceCnt;
return (DefWindowProc(hWndDlg, message, wParam, lParam));
}
LOG(("WM_COPYDATA exit (%08X)", message));
if (szSkypeMsg) free(szSkypeMsg);
--iReentranceCnt;
return 1;
}
void TellError(DWORD err) {
LPVOID lpMsgBuf;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, err,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL);
MessageBox( NULL, (TCHAR*)lpMsgBuf, _T("GetLastError"), MB_OK|MB_ICONINFORMATION );
LocalFree( lpMsgBuf );
return;
}
// SERVICES //
INT_PTR SkypeSetStatus(WPARAM wParam, LPARAM lParam)
{
int oldStatus, iRet;
BOOL UseCustomCommand, UnloadOnOffline;
UNREFERENCED_PARAMETER(lParam);
if (MirandaShuttingDown) return 0;
LOG (("SkypeSetStatus enter"));
UseCustomCommand = DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "UseCustomCommand", 0);
UnloadOnOffline = DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "UnloadOnOffline", 0);
//if (!SkypeInitialized && !DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "UnloadOnOffline", 0)) return 0;
// Workaround for Skype status-bug
if ((int)wParam==ID_STATUS_OFFLINE) logoff_contacts(TRUE);
if (SkypeStatus==(int)wParam) return 0;
oldStatus = SkypeStatus;
if ((int)wParam==ID_STATUS_CONNECTING) return 0;
#ifdef MAPDND
if ((int)wParam==ID_STATUS_OCCUPIED || (int)wParam==ID_STATUS_ONTHEPHONE) wParam=ID_STATUS_DND;
if ((int)wParam==ID_STATUS_OUTTOLUNCH) wParam=ID_STATUS_NA;
#endif
#ifdef MAPNA
if ((int)wParam==ID_STATUS_NA) wParam = ID_STATUS_AWAY;
#endif
RequestedStatus=MirandaStatusToSkype((int)wParam);
/*
if (SkypeStatus != ID_STATUS_OFFLINE)
{
InterlockedExchange((long*)&SkypeStatus, (int)wParam);
ProtoBroadcastAck(SKYPE_PROTONAME, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE) oldStatus, SkypeStatus);
}
*/
if ((int)wParam==ID_STATUS_OFFLINE && UnloadOnOffline)
{
if(UseCustomCommand)
{
DBVARIANT dbv;
if(!DBGetContactSettingString(NULL,SKYPE_PROTONAME,"CommandLine",&dbv))
{
CloseSkypeAPI(dbv.pszVal);
DBFreeVariant(&dbv);
}
}
else
{
CloseSkypeAPI(skype_path);
}
} else if (AttachStatus==-1)
{
forkthread(LaunchSkypeAndSetStatusThread, 0, (void *)wParam);
return 0;
}
iRet = SetUserStatus();
LOG (("SkypeSetStatus exit"));
return iRet;
}
INT64 __stdcall SendBroadcast( HANDLE hContact, int type, int result, HANDLE hProcess, LPARAM lParam )
{
ACKDATA ack = {0};
ack.cbSize = sizeof( ACKDATA );
ack.szModule = SKYPE_PROTONAME;
ack.hContact = hContact;
ack.type = type;
ack.result = result;
ack.hProcess = hProcess;
ack.lParam = lParam;
return CallService( MS_PROTO_BROADCASTACK, 0, ( LPARAM )&ack );
}
static void __cdecl SkypeGetAwayMessageThread( HANDLE hContact )
{
DBVARIANT dbv;
if ( !DBGetContactSettingString( hContact, "CList", "StatusMsg", &dbv )) {
SendBroadcast( hContact, ACKTYPE_AWAYMSG, ACKRESULT_SUCCESS, ( HANDLE )1, ( LPARAM )dbv.pszVal );
DBFreeVariant( &dbv );
}
else SendBroadcast( hContact, ACKTYPE_AWAYMSG, ACKRESULT_SUCCESS, ( HANDLE )1, ( LPARAM )0 );
}
INT_PTR SkypeGetAwayMessage(WPARAM wParam,LPARAM lParam)
{
CCSDATA* ccs = ( CCSDATA* )lParam;
UNREFERENCED_PARAMETER(wParam);
forkthread( SkypeGetAwayMessageThread, 0, ccs->hContact );
return 1;
}
#define POLYNOMIAL (0x488781ED) /* This is the CRC Poly */
#define TOPBIT (1 << (WIDTH - 1)) /* MSB */
#define WIDTH 32
static int GetFileHash(char* filename)
{
HANDLE hFile = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
int remainder = 0, byte, bit;
char data[1024];
DWORD dwRead;
if(hFile == INVALID_HANDLE_VALUE) return 0;
do
{
// Read file chunk
dwRead = 0;
ReadFile(hFile, data, 1024, &dwRead, NULL);
/* loop through each byte of data */
for (byte = 0; byte < (int) dwRead; ++byte) {
/* store the next byte into the remainder */
remainder ^= (data[byte] << (WIDTH - 8));
/* calculate for all 8 bits in the byte */
for ( bit = 8; bit > 0; --bit) {
/* check if MSB of remainder is a one */
if (remainder & TOPBIT)
remainder = (remainder << 1) ^ POLYNOMIAL;
else
remainder = (remainder << 1);
}
}
} while(dwRead == 1024);
CloseHandle(hFile);
return remainder;
}
static int _GetFileSize(char* filename)
{
HANDLE hFile = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
int size;
if(hFile == INVALID_HANDLE_VALUE)
return 0;
size = GetFileSize(hFile, NULL);
CloseHandle(hFile);
return size;
}
/* RetrieveUserAvatar
*
* Purpose: Get a user avatar from skype itself
* Params : param=(void *)(HANDLE)hContact
*/
void RetrieveUserAvatar(void *param)
{
HANDLE hContact = (HANDLE) param, file;
PROTO_AVATAR_INFORMATION AI={0};
ACKDATA ack = {0};
DBVARIANT dbv;
char AvatarFile[MAX_PATH+1], AvatarTmpFile[MAX_PATH+10], *ptr, *pszTempFile;
if (hContact == NULL)
return;
// Mount default ack
ack.cbSize = sizeof( ACKDATA );
ack.szModule = SKYPE_PROTONAME;
ack.hContact = hContact;
ack.type = ACKTYPE_AVATAR;
ack.result = ACKRESULT_FAILED;
AI.cbSize = sizeof( AI );
AI.hContact = hContact;
// Get skype name
if (DBGetContactSettingString(hContact, SKYPE_PROTONAME, SKYPE_NAME, &dbv) == 0)
{
if (dbv.pszVal)
{
// Get filename
FoldersGetCustomPath(hProtocolAvatarsFolder, AvatarFile, sizeof(AvatarFile), DefaultAvatarsFolder);
mir_snprintf(AvatarTmpFile, sizeof(AvatarTmpFile), "AVATAR 1 %s\\%s_tmp.jpg", AvatarFile, dbv.pszVal);
pszTempFile = AvatarTmpFile+9;
mir_snprintf(AvatarFile, sizeof(AvatarFile), "%s\\%s.jpg", AvatarFile, dbv.pszVal);
// Just to be sure
DeleteFileA(pszTempFile);
file = CreateFileA(pszTempFile, 0, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (file != INVALID_HANDLE_VALUE)
{
CloseHandle(file);
if (ptr=SkypeGet ("USER", dbv.pszVal, AvatarTmpFile))
{
if (strncmp(ptr, "ERROR", 5) &&
GetFileAttributesA(pszTempFile) != INVALID_FILE_ATTRIBUTES)
{
ack.result = ACKRESULT_SUCCESS;
// Is no avatar image?
if (!DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "ShowDefaultSkypeAvatar", 0)
&& GetFileHash(pszTempFile) == 0x8d34e05d && _GetFileSize(pszTempFile) == 3751)
{
// Has no avatar
AI.format = PA_FORMAT_UNKNOWN;
ack.hProcess = (HANDLE)&AI;
DeleteFileA(AvatarFile);
}
else
{
// Got it
MoveFileExA(pszTempFile, AvatarFile, MOVEFILE_REPLACE_EXISTING);
AI.format = PA_FORMAT_JPEG;
strcpy(AI.filename, AvatarFile);
ack.hProcess = (HANDLE)&AI;
}
}
free (ptr);
}
DeleteFileA(pszTempFile);
}
}
DBFreeVariant(&dbv);
}
CallService( MS_PROTO_BROADCASTACK, 0, ( LPARAM )&ack );
}
/* SkypeGetAvatarInfo
*
* Purpose: Set user avatar in profile
* Params : wParam=0
* lParam=(LPARAM)(const char*)filename
* Returns: 0 - Success
* -1 - Failure
*/
INT_PTR SkypeGetAvatarInfo(WPARAM wParam,LPARAM lParam)
{
DBVARIANT dbv;
PROTO_AVATAR_INFORMATION* AI = ( PROTO_AVATAR_INFORMATION* )lParam;
if (AI->hContact == NULL) // User
{
if (!DBGetContactSettingString(NULL,SKYPE_PROTONAME, "AvatarFile", &dbv))
{
lstrcpynA(AI->filename, dbv.pszVal, sizeof(AI->filename));
DBFreeVariant(&dbv);
return GAIR_SUCCESS;
}
else
return GAIR_NOAVATAR;
}
else // Contact
{
DBVARIANT dbv;
char AvatarFile[MAX_PATH+1];
if (protocol < 7 && !bIsImoproxy)
return GAIR_NOAVATAR;
if (wParam & GAIF_FORCE)
{
// Request anyway
forkthread(RetrieveUserAvatar, 0, (void *) AI->hContact);
return GAIR_WAITFOR;
}
if (DBGetContactSettingString(AI->hContact, SKYPE_PROTONAME, SKYPE_NAME, &dbv))
// No skype name ??
return GAIR_NOAVATAR;
if (dbv.pszVal == NULL)
{
// No skype name ??
DBFreeVariant(&dbv);
return GAIR_NOAVATAR;
}
// Get filename
FoldersGetCustomPath(hProtocolAvatarsFolder, AvatarFile, sizeof(AvatarFile), DefaultAvatarsFolder);
mir_snprintf(AvatarFile, sizeof(AvatarFile), "%s\\%s.jpg", AvatarFile, dbv.pszVal);
DBFreeVariant(&dbv);
// Check if the file exists
if (GetFileAttributesA(AvatarFile) == INVALID_FILE_ATTRIBUTES)
return GAIR_NOAVATAR;
// Return the avatar
AI->format = PA_FORMAT_JPEG;
strcpy(AI->filename, AvatarFile);
return GAIR_SUCCESS;
}
}
/* SkypeGetAvatarCaps
*
* Purpose: Query avatar caps for a protocol
* Params : wParam=One of AF_*
* lParam=Depends on wParam
* Returns: Depends on wParam
*/
INT_PTR SkypeGetAvatarCaps(WPARAM wParam, LPARAM lParam)
{
switch(wParam)
{
case AF_MAXSIZE:
{
POINT *p = (POINT *) lParam;
if (p == NULL)
return -1;
p->x = 96;
p->y = 96;
return 0;
}
case AF_PROPORTION:
{
return PIP_NONE;
}
case AF_FORMATSUPPORTED:
{
if (lParam == PA_FORMAT_PNG || lParam == PA_FORMAT_JPEG)
return TRUE;
else
return FALSE;
}
case AF_ENABLED:
{
return TRUE;
}
case AF_DONTNEEDDELAYS:
{
return FALSE;
}
}
return -1;
}
INT_PTR SkypeGetStatus(WPARAM wParam, LPARAM lParam) {
UNREFERENCED_PARAMETER(wParam);
UNREFERENCED_PARAMETER(lParam);
return SkypeStatus;
}
INT_PTR SkypeGetInfo(WPARAM wParam,LPARAM lParam) {
CCSDATA *ccs = (CCSDATA *) lParam;
UNREFERENCED_PARAMETER(wParam);
forkthread(GetInfoThread, 0, ccs->hContact);
return 0;
}
INT_PTR SkypeAddToList(WPARAM wParam, LPARAM lParam) {
PROTOSEARCHRESULT *psr=(PROTOSEARCHRESULT*)lParam;
char *name = NULL;
HANDLE ret = INVALID_HANDLE_VALUE;
LOG(("SkypeAddToList Adding API function called"));
if (psr->cbSize!=sizeof(PROTOSEARCHRESULT) || !psr->nick) return 0;
LOG(("SkypeAddToList OK"));
name = mir_utf8encodeT(psr->nick);
ret = add_contact(name, wParam);
mir_free(name);
return (INT_PTR)ret;
}
INT_PTR SkypeBasicSearch(WPARAM wParam, LPARAM lParam) {
UNREFERENCED_PARAMETER(wParam);
LOG(("SkypeBasicSearch %s", (char *)lParam));
if (!SkypeInitialized) return 0;
return (hSearchThread=forkthread(( pThreadFunc )BasicSearchThread, 0, _strdup((char *)lParam)));
}
void MessageSendWatchThread(msgsendwt_arg *arg) {
char *str, *err;
// sendwatchers need to be incremented before starting this thread
LOG(("MessageSendWatchThread started."));
str=SkypeRcvMsg(arg->szId, SkypeTime(NULL)-1, arg->hContact, DBGetContactSettingDword(NULL,"SRMsg","MessageTimeout",TIMEOUT_MSGSEND)+1000);
InterlockedDecrement (&sendwatchers);
if (str)
{
if (!DBGetContactSettingByte(arg->hContact, SKYPE_PROTONAME, "ChatRoom", 0)) {
if (err=GetSkypeErrorMsg(str)) {
ProtoBroadcastAck(SKYPE_PROTONAME, arg->hContact, ACKTYPE_MESSAGE, ACKRESULT_FAILED, (HANDLE) 1, (LPARAM)Translate(err));
free(err);
free(str);
free(arg);
LOG(("MessageSendWatchThread terminated."));
return;
}
ProtoBroadcastAck(SKYPE_PROTONAME, arg->hContact, ACKTYPE_MESSAGE, ACKRESULT_SUCCESS, (HANDLE) 1, 0);
}
free(str);
LOG(("MessageSendWatchThread terminated gracefully."));
}
free (arg);
}
INT_PTR SkypeSendMessage(WPARAM wParam, LPARAM lParam) {
CCSDATA *ccs = (CCSDATA *) lParam;
DBVARIANT dbv;
BOOL sendok=TRUE;
char *msg = (char *) ccs->lParam, *utfmsg=NULL, *mymsgcmd=cmdMessage, szId[16]={0};
static DWORD dwMsgNum = 0;
BYTE bIsChatroom = 0 != DBGetContactSettingByte(ccs->hContact, SKYPE_PROTONAME, "ChatRoom", 0);
UNREFERENCED_PARAMETER(wParam);
if (bIsChatroom)
{
if (DBGetContactSettingString(ccs->hContact, SKYPE_PROTONAME, "ChatRoomID", &dbv))
return 0;
mymsgcmd="CHATMESSAGE";
}
else
{
if (DBGetContactSettingString(ccs->hContact, SKYPE_PROTONAME, SKYPE_NAME, &dbv))
return 0;
mymsgcmd="MESSAGE";
}
if (ccs->wParam & PREF_UTF) {
utfmsg = msg;
} else if (ccs->wParam & PREF_UNICODE) {
utfmsg = (char*)make_utf8_string((WCHAR*)(msg+strlen(msg)+1));
} else {
if (utf8_encode(msg, &utfmsg)==-1) utfmsg=NULL;
}
if (protocol>=4) {
InterlockedIncrement ((LONG*)&dwMsgNum);
sprintf (szId, "#M%d ", dwMsgNum++);
}
InterlockedIncrement (&sendwatchers);
if (!utfmsg || SkypeSend("%s%s %s %s", szId, mymsgcmd, dbv.pszVal, utfmsg)) sendok=FALSE;
if (utfmsg && utfmsg!=msg) free(utfmsg);
DBFreeVariant(&dbv);
if (sendok) {
msgsendwt_arg *psendarg = calloc(1, sizeof(msgsendwt_arg));
if (psendarg) {
psendarg->hContact = ccs->hContact;
strcpy (psendarg->szId, szId);
forkthread(MessageSendWatchThread, 0, psendarg);
} else InterlockedDecrement (&sendwatchers);
return 1;
} else InterlockedDecrement (&sendwatchers);
if (!bIsChatroom)
ProtoBroadcastAck(SKYPE_PROTONAME, ccs->hContact, ACKTYPE_MESSAGE, ACKRESULT_FAILED, (HANDLE) 1, (LPARAM)Translate("Connection to Skype lost"));
return 0;
}
INT_PTR SkypeRecvMessage(WPARAM wParam, LPARAM lParam)
{
DBEVENTINFO dbei={0};
CCSDATA *ccs = (CCSDATA *) lParam;
PROTORECVEVENT *pre = (PROTORECVEVENT *) ccs->lParam;
UNREFERENCED_PARAMETER(wParam);
DBDeleteContactSetting(ccs->hContact, "CList", "Hidden");
dbei.cbSize = sizeof(dbei);
dbei.szModule = SKYPE_PROTONAME;
dbei.timestamp = pre->timestamp;
if (pre->flags & PREF_CREATEREAD) dbei.flags|=DBEF_READ;
if (pre->flags & PREF_UTF) dbei.flags|=DBEF_UTF;
dbei.eventType = EVENTTYPE_MESSAGE;
dbei.cbBlob = strlen(pre->szMessage) + 1;
if (pre->flags & PREF_UNICODE)
dbei.cbBlob += sizeof( wchar_t )*( (DWORD)wcslen(( wchar_t* )&pre->szMessage[dbei.cbBlob] )+1 );
dbei.pBlob = (PBYTE) pre->szMessage;
MsgList_Add (pre->lParam, (HANDLE)CallService(MS_DB_EVENT_ADD, (WPARAM)ccs->hContact, (LPARAM)&dbei));
return 0;
}
INT_PTR SkypeUserIsTyping(WPARAM wParam, LPARAM lParam) {
DBVARIANT dbv={0};
HANDLE hContact = (HANDLE)wParam;
if (protocol<5 && !bIsImoproxy) return 0;
if (DBGetContactSettingString(hContact, SKYPE_PROTONAME, "Typing_Stream", &dbv)) {
if (DBGetContactSettingString(hContact, SKYPE_PROTONAME, SKYPE_NAME, &dbv) == 0) {
char szCmd[256];
_snprintf (szCmd, sizeof(szCmd),
"ALTER APPLICATION libpurple_typing CONNECT %s", dbv.pszVal);
SkypeSend (szCmd);
DBFreeVariant (&dbv);
testfor (szCmd, 2000);
// TODO: We should somehow cache the typing notify result and send it
// after we got a connection, but in the meantime this notification won't
// get sent on first run
}
return 0;
}
SkypeSend ("ALTER APPLICATION libpurple_typing DATAGRAM %s %s", dbv.pszVal,
(lParam==PROTOTYPE_SELFTYPING_ON?"PURPLE_TYPING":"PURPLE_NOT_TYPING"));
DBFreeVariant(&dbv);
return 0;
}
INT_PTR SkypeSendAuthRequest(WPARAM wParam, LPARAM lParam) {
CCSDATA* ccs = (CCSDATA*)lParam;
DBVARIANT dbv;
int retval;
UNREFERENCED_PARAMETER(wParam);
if (!ccs->lParam || DBGetContactSettingString(ccs->hContact, SKYPE_PROTONAME, SKYPE_NAME, &dbv))
return 1;
retval = SkypeSend("SET USER %s BUDDYSTATUS 2 %s", dbv.pszVal, (char *)ccs->lParam);
DBFreeVariant(&dbv);
if (retval) return 1; else return 0;
}
INT_PTR SkypeRecvAuth(WPARAM wParam, LPARAM lParam) {
DBEVENTINFO dbei = {0};
CCSDATA* ccs = (CCSDATA*)lParam;
PROTORECVEVENT* pre = (PROTORECVEVENT*)ccs->lParam;
UNREFERENCED_PARAMETER(wParam);
DBDeleteContactSetting(ccs->hContact, "CList", "Hidden");
dbei.cbSize = sizeof(dbei);
dbei.szModule = SKYPE_PROTONAME;
dbei.timestamp = pre->timestamp;
dbei.flags = ((pre->flags & PREF_CREATEREAD)?DBEF_READ:0);
dbei.eventType = EVENTTYPE_AUTHREQUEST;
dbei.cbBlob = pre->lParam;
dbei.pBlob = (PBYTE)pre->szMessage;
CallService(MS_DB_EVENT_ADD, (WPARAM)NULL, (LPARAM)&dbei);
return 0;
}
char *__skypeauth(WPARAM wParam) {
DBEVENTINFO dbei={0};
if (!SkypeInitialized) return NULL;
dbei.cbSize = sizeof(dbei);
if ((dbei.cbBlob = CallService(MS_DB_EVENT_GETBLOBSIZE, wParam, 0))==-1 ||
!(dbei.pBlob = (unsigned char*)malloc(dbei.cbBlob)))
{ return NULL; }
if (CallService(MS_DB_EVENT_GET, wParam, (LPARAM)&dbei) ||
dbei.eventType != EVENTTYPE_AUTHREQUEST ||
strcmp(dbei.szModule, SKYPE_PROTONAME))
{
free(dbei.pBlob);
return NULL;
}
return (char *)dbei.pBlob;
}
INT_PTR SkypeAuthAllow(WPARAM wParam, LPARAM lParam) {
char *pBlob;
UNREFERENCED_PARAMETER(lParam);
if (pBlob=__skypeauth(wParam))
{
int retval=SkypeSend("SET USER %s ISAUTHORIZED TRUE", pBlob+sizeof(DWORD)*2);
free(pBlob);
if (!retval) return 0;
}
return 1;
}
INT_PTR SkypeAuthDeny(WPARAM wParam, LPARAM lParam) {
char *pBlob;
UNREFERENCED_PARAMETER(lParam);
if (pBlob=__skypeauth(wParam))
{
int retval=SkypeSend("SET USER %s ISAUTHORIZED FALSE", pBlob+sizeof(DWORD)*2);
free(pBlob);
if (!retval) return 0;
}
return 1;
}
INT_PTR SkypeAddToListByEvent(WPARAM wParam, LPARAM lParam) {
char *pBlob;
UNREFERENCED_PARAMETER(lParam);
if (pBlob=__skypeauth(wParam))
{
HANDLE hContact = add_contact(pBlob+sizeof(DWORD)*2, LOWORD(wParam));
free(pBlob);
if (hContact) return (int)hContact;
}
return 0;
}
INT_PTR SkypeRegisterProxy(WPARAM wParam, LPARAM lParam) {
UNREFERENCED_PARAMETER(wParam);
if (!lParam) {
free (pszProxyCallout);
pszProxyCallout = NULL;
}
pszProxyCallout = _strdup((char*)lParam);
bIsImoproxy = TRUE;
return 0;
}
void CleanupNicknames(char *dummy) {
HANDLE hContact;
char *szProto;
DBVARIANT dbv, dbv2;
UNREFERENCED_PARAMETER(dummy);
LOG(("CleanupNicknames Cleaning up..."));
for (hContact=(HANDLE)CallService(MS_DB_CONTACT_FINDFIRST, 0, 0);hContact != NULL;hContact=(HANDLE)CallService( MS_DB_CONTACT_FINDNEXT, (WPARAM)hContact, 0)) {
szProto = (char*)CallService( MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)hContact, 0 );
if (szProto!=NULL && !strcmp(szProto, SKYPE_PROTONAME) &&
DBGetContactSettingByte(hContact, SKYPE_PROTONAME, "ChatRoom", 0)==0)
{
if (DBGetContactSettingString(hContact, SKYPE_PROTONAME, SKYPE_NAME, &dbv)) continue;
if (DBGetContactSettingString(hContact, SKYPE_PROTONAME, "Nick", &dbv2)) {
DBFreeVariant(&dbv);
continue;
}
DBDeleteContactSetting(hContact, SKYPE_PROTONAME, "Nick");
GetInfoThread(hContact);
DBFreeVariant(&dbv);
DBFreeVariant(&dbv2);
}
}
OUTPUT(_T("Cleanup finished."));
}
/////////////////////////////////////////////////////////////////////////////////////////
// EnterBitmapFileName - enters a bitmap filename
int __stdcall EnterBitmapFileName( char* szDest )
{
char szFilter[ 512 ];
OPENFILENAMEA ofn = {0};
*szDest = 0;
CallService( MS_UTILS_GETBITMAPFILTERSTRINGS, sizeof szFilter, ( LPARAM )szFilter );
ofn.lStructSize = sizeof( OPENFILENAME );
ofn.lpstrFilter = szFilter;
ofn.lpstrFile = szDest;
ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
ofn.nMaxFile = MAX_PATH;
ofn.nMaxFileTitle = MAX_PATH;
ofn.lpstrDefExt = "bmp";
if ( !GetOpenFileNameA( &ofn ))
return 1;
return ERROR_SUCCESS;
}
int MirandaExit(WPARAM wParam, LPARAM lParam) {
UNREFERENCED_PARAMETER(wParam);
UNREFERENCED_PARAMETER(lParam);
MirandaShuttingDown=TRUE;
return 0;
}
int OkToExit(WPARAM wParam, LPARAM lParam) {
UNREFERENCED_PARAMETER(wParam);
UNREFERENCED_PARAMETER(lParam);
// logoff_contacts();
MirandaShuttingDown=TRUE;
// Trigger all semaphores and events just to be sure that there is no deadlock
ReleaseSemaphore(SkypeMsgReceived, receivers, NULL);
SetEvent (SkypeReady);
SetEvent (MessagePumpReady);
#ifdef SKYPEBUG_OFFLN
SetEvent(GotUserstatus);
#endif
SetEvent (hBuddyAdded);
SkypeFlush ();
PostMessage (g_hWnd, WM_CLOSE, 0, 0);
return 0;
}
struct PLUGINDI {
char **szSettings;
int dwCount;
};
// Taken from pluginopts.c and modified
int EnumOldPluginName(const char *szSetting,LPARAM lParam)
{
struct PLUGINDI *pdi=(struct PLUGINDI*)lParam;
if (pdi && lParam) {
pdi->szSettings=(char**)realloc(pdi->szSettings,(pdi->dwCount+1)*sizeof(char*));
pdi->szSettings[pdi->dwCount++]=_strdup(szSetting);
}
return 0;
}
// Are there any Skype users on list?
// 1 --> Yes
// 0 --> No
int AnySkypeusers(void)
{
HANDLE hContact;
DBVARIANT dbv;
int tCompareResult;
// already on list?
for (hContact=(HANDLE)CallService(MS_DB_CONTACT_FINDFIRST, 0, 0);
hContact != NULL;
hContact=(HANDLE)CallService( MS_DB_CONTACT_FINDNEXT, (WPARAM)hContact, 0))
{
// GETCONTACTBASEPROTO doesn't work on not loaded protocol, therefore get
// protocol from DB
if (DBGetContactSettingString(hContact, "Protocol", "p", &dbv)) continue;
tCompareResult = !strcmp(dbv.pszVal, SKYPE_PROTONAME);
DBFreeVariant(&dbv);
if (tCompareResult) return 1;
}
return 0;
}
void UpgradeName(char *OldName)
{
DBCONTACTENUMSETTINGS cns;
DBCONTACTWRITESETTING cws;
DBVARIANT dbv;
HANDLE hContact=NULL;
struct PLUGINDI pdi;
LOG(("Updating old database settings if there are any..."));
cns.pfnEnumProc=EnumOldPluginName;
cns.lParam=(LPARAM)&pdi;
cns.szModule=OldName;
cns.ofsSettings=0;
hContact = (HANDLE)CallService(MS_DB_CONTACT_FINDFIRST, 0, 0);
for ( ;; ) {
memset(&pdi,0,sizeof(pdi));
CallService(MS_DB_CONTACT_ENUMSETTINGS,(WPARAM)hContact,(LPARAM)&cns);
// Upgrade Protocol settings to new string
if (pdi.szSettings) {
int i;
LOG(("We're currently upgrading..."));
for (i=0;i<pdi.dwCount;i++) {
if (!DBGetContactSettingString(hContact, OldName, pdi.szSettings[i], &dbv)) {
cws.szModule=SKYPE_PROTONAME;
cws.szSetting=pdi.szSettings[i];
cws.value=dbv;
if (!CallService(MS_DB_CONTACT_WRITESETTING,(WPARAM)hContact,(LPARAM)&cws))
DBDeleteContactSetting(hContact,OldName,pdi.szSettings[i]);
DBFreeVariant(&dbv);
}
free(pdi.szSettings[i]);
}
free(pdi.szSettings);
}
// Upgrade Protocol assignment, if we are not main contact
if (hContact && !DBGetContactSettingString(hContact, "Protocol", "p", &dbv)) {
if (!strcmp(dbv.pszVal, OldName))
DBWriteContactSettingString(hContact, "Protocol", "p", SKYPE_PROTONAME);
DBFreeVariant(&dbv);
}
if (!hContact) break;
hContact = (HANDLE)CallService(MS_DB_CONTACT_FINDNEXT, (WPARAM)hContact, 0);
}
DBWriteContactSettingByte(NULL, SKYPE_PROTONAME, "UpgradeDone", (BYTE)1);
return;
}
void __cdecl MsgPump (char *dummy)
{
MSG msg;
WNDCLASS WndClass;
UNREFERENCED_PARAMETER(dummy);
// Create window class
WndClass.style = CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS;
WndClass.lpfnWndProc = (WNDPROC)WndProc;
WndClass.cbClsExtra = 0;
WndClass.cbWndExtra = 0;
WndClass.hInstance = hInst;
WndClass.hIcon = NULL;
WndClass.hCursor = NULL;
WndClass.hbrBackground = NULL;
WndClass.lpszMenuName = NULL;
WndClass.lpszClassName = _T("SkypeApiDispatchWindow");
RegisterClass(&WndClass);
// Do not check the retval of RegisterClass, because on non-unicode
// win98 it will fail, as it is a stub that returns false() there
// Create main window
g_hWnd=CreateWindowEx( WS_EX_APPWINDOW|WS_EX_WINDOWEDGE,
_T("SkypeApiDispatchWindow"), _T(""), WS_BORDER|WS_SYSMENU|WS_MINIMIZEBOX,
CW_USEDEFAULT, CW_USEDEFAULT, 128, 128, NULL, 0, (HINSTANCE)WndClass.hInstance, 0);
LOG (("Created Dispatch window with handle %08X", (long)g_hWnd));
if (!g_hWnd) {
OUTPUT(_T("Cannot create window."));
TellError(GetLastError());
SetEvent(MessagePumpReady);
return;
}
ShowWindow(g_hWnd, 0);
UpdateWindow(g_hWnd);
msgPumpThreadId = GetCurrentThreadId();
SetEvent(MessagePumpReady);
LOG (("Messagepump started."));
while (GetMessage (&msg, NULL, 0, 0) > 0 && !Miranda_Terminated()) {
TranslateMessage (&msg);
DispatchMessage (&msg);
}
UnregisterClass (WndClass.lpszClassName, hInst);
LOG (("Messagepump stopped."));
}
// DLL Stuff //
__declspec(dllexport) PLUGININFOEX* MirandaPluginInfo(DWORD mirVersion)
{
mirandaVersion = mirVersion;
pluginInfo.cbSize = sizeof(PLUGININFOEX);
return (PLUGININFOEX*) &pluginInfo;
}
__declspec(dllexport) PLUGININFOEX* MirandaPluginInfoEx(DWORD mirVersion)
{
mirandaVersion = mirVersion;
return &pluginInfo;
}
static const MUUID interfaces[] = {MUUID_SKYPE_CALL, MIID_LAST};
__declspec(dllexport) const MUUID * MirandaPluginInterfaces(void)
{
return interfaces;
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL,DWORD fdwReason,LPVOID lpvReserved)
{
UNREFERENCED_PARAMETER(fdwReason);
UNREFERENCED_PARAMETER(lpvReserved);
hInst = hinstDLL;
return TRUE;
}
int PreShutdown(WPARAM wParam, LPARAM lParam) {
UNREFERENCED_PARAMETER(wParam);
UNREFERENCED_PARAMETER(lParam);
PostThreadMessage(msgPumpThreadId, WM_QUIT, 0, 0);
return 0;
}
int __declspec(dllexport) Load()
{
PROTOCOLDESCRIPTOR pd = {0};
DWORD Buffsize;
HKEY MyKey;
BOOL SkypeInstalled;
BOOL UseCustomCommand;
WSADATA wsaData = {0};
char path[MAX_PATH];
mir_getLP(&pluginInfo);
GetModuleFileNameA( hInst, path, sizeof( path ));
_splitpath (path, NULL, NULL, SKYPE_PROTONAME, NULL);
CharUpperA( SKYPE_PROTONAME );
InitializeCriticalSection(&RingAndEndcallMutex);
InitializeCriticalSection(&QueryThreadMutex);
InitializeCriticalSection(&TimeMutex);
#ifdef _DEBUG
init_debug();
#endif
LOG(("Load: Skype Plugin loading..."));
// We need to upgrade SKYPE_PROTOCOL internal name to Skype if not already done
if (!DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "UpgradeDone", 0))
UpgradeName("SKYPE_PROTOCOL");
// Initialisation of Skype MsgQueue must be done because of Cleanup in end and
// Mutex is also initialized here.
LOG(("SkypeMsgInit initializing Skype MSG-queue"));
if (SkypeMsgInit()==-1) {
OUTPUT(_T("Memory allocation error on startup."));
return 0;
}
// On first run on new profile, ask user, if he wants to enable the plugin in
// this profile
// --> Fixing Issue #0000006 from bugtracker.
if (!DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "FirstRun", 0)) {
DBWriteContactSettingByte(NULL, SKYPE_PROTONAME, "FirstRun", 1);
if (AnySkypeusers()==0) // First run, it seems :)
if (MessageBox(NULL, TranslateT("This seems to be the first time that you're running the Skype protocol plugin. Do you want to enable the protocol for this Miranda-Profile? (If you chose NO, you can always enable it in the plugin options later."), _T("Welcome!"), MB_ICONQUESTION|MB_YESNO)==IDNO) {
char path[MAX_PATH], *filename;
GetModuleFileNameA(hInst, path, sizeof(path));
if (filename = strrchr(path,'\\')+1)
DBWriteContactSettingByte(NULL,"PluginDisable",filename,1);
return 0;
}
}
// Check if Skype is installed
SkypeInstalled=TRUE;
UseCustomCommand = (BYTE)DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "UseCustomCommand", 0);
UseSockets = (BOOL)DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "UseSkype2Socket", 0);
if (!UseSockets && !UseCustomCommand)
{
BOOL is_key_opened = FALSE;
if (RegOpenKeyEx(HKEY_CURRENT_USER, _T("Software\\Skype\\Phone"), 0, KEY_READ, &MyKey)!=ERROR_SUCCESS)
{
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("Software\\Skype\\Phone"), 0, KEY_READ, &MyKey)!=ERROR_SUCCESS)
{
SkypeInstalled=FALSE;
}
else
is_key_opened = TRUE;
}
else
is_key_opened = TRUE;
Buffsize=sizeof(skype_path);
if(is_key_opened)
{
if (SkypeInstalled==FALSE)
skype_path[0]=0;
else if (RegQueryValueExA(MyKey, "SkypePath", NULL, NULL, (unsigned char *)skype_path, &Buffsize)!=ERROR_SUCCESS)
{
//OUTPUT("Skype was not found installed :( \nMaybe you are using portable skype.");
RegCloseKey(MyKey);
skype_path[0]=0;
//return 0;
}
else
RegCloseKey(MyKey);
}
}
WSAStartup(MAKEWORD(2,2), &wsaData);
// Start Skype connection
if (!(ControlAPIAttach=RegisterWindowMessage(_T("SkypeControlAPIAttach"))) || !(ControlAPIDiscover=RegisterWindowMessage(_T("SkypeControlAPIDiscover"))))
{
OUTPUT(_T("Cannot register Window message."));
return 0;
}
SkypeMsgReceived=CreateSemaphore(NULL, 0, MAX_MSGS, NULL);
if (!(SkypeReady=CreateEvent(NULL, TRUE, FALSE, NULL)) ||
!(MessagePumpReady=CreateEvent(NULL, FALSE, FALSE, NULL)) ||
#ifdef SKYPEBUG_OFFLN
!(GotUserstatus=CreateEvent(NULL, TRUE, FALSE, NULL)) ||
#endif
!(hBuddyAdded=CreateEvent(NULL, FALSE, FALSE, NULL)) ||
!(FetchMessageEvent=CreateEvent(NULL, FALSE, TRUE, NULL))) {
OUTPUT(_T("Unable to create Mutex!"));
return 0;
}
/* Register the module */
ZeroMemory(&pd, sizeof(pd));
pd.cbSize = PROTOCOLDESCRIPTOR_V3_SIZE;
pd.szName = SKYPE_PROTONAME;
pd.type = PROTOTYPE_PROTOCOL;
CallService(MS_PROTO_REGISTERMODULE, 0, (LPARAM)&pd);
VoiceServiceInit();
CreateServices();
HookEvents();
InitVSApi();
MsgList_Init();
HookEvent(ME_SYSTEM_PRESHUTDOWN, PreShutdown);
// Startup Message-pump
forkthread (( pThreadFunc )MsgPump, 0, NULL);
WaitForSingleObject(MessagePumpReady, INFINITE);
return 0;
}
int __declspec( dllexport ) Unload(void)
{
BOOL UseCustomCommand = DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "UseCustomCommand", 0);
BOOL Shutdown = DBGetContactSettingByte(NULL, SKYPE_PROTONAME, "Shutdown", 0);
LOG (("Unload started"));
if ( Shutdown && ((skype_path && skype_path[0]) ||UseCustomCommand) ) {
if(UseCustomCommand)
{
DBVARIANT dbv;
if(!DBGetContactSettingString(NULL,SKYPE_PROTONAME,"CommandLine",&dbv))
{
char szAbsolutePath[MAX_PATH];
TranslateMirandaRelativePathToAbsolute(dbv.pszVal, szAbsolutePath, FALSE);
_spawnl(_P_NOWAIT, szAbsolutePath, szAbsolutePath, "/SHUTDOWN", NULL);
LOG (("Unload Sent /shutdown to %s", szAbsolutePath));
DBFreeVariant(&dbv);
}
}
else
{
_spawnl(_P_NOWAIT, skype_path, skype_path, "/SHUTDOWN", NULL);
LOG (("Unload Sent /shutdown to %s", skype_path));
}
}
SkypeMsgCleanup();
//WSACleanup();
FreeVSApi();
UnhookEvents();
UnhookEvent(hChatEvent);
UnhookEvent (hChatMenu);
UnhookEvent (hEvInitChat);
DestroyHookableEvent(hInitChat);
VoiceServiceExit();
GCExit();
MsgList_Exit();
CloseHandle(SkypeReady);
CloseHandle(SkypeMsgReceived);
#ifdef SKYPEBUG_OFFLN
CloseHandle(GotUserstatus);
#endif
CloseHandle(MessagePumpReady);
CloseHandle(hBuddyAdded);
CloseHandle(FetchMessageEvent);
DeleteCriticalSection(&RingAndEndcallMutex);
DeleteCriticalSection(&QueryThreadMutex);
SkypeRegisterProxy (0, 0);
LOG (("Unload: Shutdown complete"));
#ifdef _DEBUG
end_debug();
#endif
DeleteCriticalSection(&TimeMutex);
return 0;
}