void __cdecl SmileyDownloadThread(void*) { bool needext = false; HANDLE hHttpDwnl = NULL; WaitForSingleObject(g_hDlMutex, 3000); while (!Miranda_Terminated() && dlQueue.getCount()) { ReleaseMutex(g_hDlMutex); if (_taccess(dlQueue[0].fname.c_str(), 0) != 0) { InternetDownloadFile(T2A_SM(dlQueue[0].url.c_str()), T2A_SM(dlQueue[0].fname.c_str()), hHttpDwnl); WaitForSingleObject(g_hDlMutex, 3000); CMString fname(dlQueue[0].fname); if (dlQueue[0].needext) { fname += GetImageExt(fname); needext = true; } _trename(dlQueue[0].fname.c_str(), fname.c_str()); } else WaitForSingleObject(g_hDlMutex, 3000); dlQueue.remove(0); } dlQueue.destroy(); if (hHttpDwnl) Netlib_CloseHandle(hHttpDwnl); threadRunning = false; ReleaseMutex(g_hDlMutex); if (!Miranda_Terminated()) { if (needext) CallServiceSync(MS_SMILEYADD_RELOAD, 0, 0); else NotifyEventHooks(hEvent1, 0, 0); } }
int AskStatusMessageThread(HWND hwnd) { DWORD time; HANDLE h; HANDLE ACK=0; pdisplayNameCacheEntry pdnce=NULL; h=GetCurrChain(); if (!h) return 0; ISTREADSTARTED=1; while (h) { time=GetTickCount(); if ((time-RequestTick)<ASKPERIOD) { SleepEx(ASKPERIOD-(time-RequestTick)+10,TRUE); if (Miranda_Terminated()) { ISTREADSTARTED=0; return 0; } } { pdnce = GetDisplayNameCacheEntry((HANDLE)h); if (pdnce->ApparentMode!=ID_STATUS_OFFLINE) //don't ask if contact is always invisible (should be done with protocol) ACK=(HANDLE)CallContactService(h,PSS_GETAWAYMSG,0,0); } if (!ACK) { ACKDATA ack; ack.hContact=h; ack.type=ACKTYPE_AWAYMSG; ack.result=ACKRESULT_FAILED; if (pdnce) ack.szModule=pdnce->szProto; else ack.szModule=NULL; ClcProtoAck((WPARAM)h,(LPARAM) &ack); } RequestTick=time; h=GetCurrChain(); if (h) SleepEx(ASKPERIOD,TRUE); else break; if (Miranda_Terminated()) { ISTREADSTARTED=0; return 0; } } ISTREADSTARTED=0; return 1; }
void __cdecl UpdateMsgsThreadProc(void *) { int numAccs; PROTOACCOUNT **accs; ProtoEnumAccounts(&numAccs, &accs); while (WaitForSingleObject(g_hTerminateUpdateMsgsThread, 0) == WAIT_TIMEOUT && !Miranda_Terminated()) { DWORD MinUpdateTimeDifference = g_MoreOptPage.GetDBValueCopy(IDC_MOREOPTDLG_UPDATEMSGSPERIOD) * 1000; // in milliseconds for (int i = 0; i < numAccs; i++) { PROTOACCOUNT *p = accs[i]; if (CallProtoService(p->szModuleName, PS_GETCAPS, PFLAGNUM_1, 0) & PF1_MODEMSGSEND && !IsAnICQProto(p->szModuleName)) { int Status = CallProtoService(p->szModuleName, PS_GETSTATUS, 0, 0); if (Status < ID_STATUS_OFFLINE || Status > ID_STATUS_OUTTOLUNCH) { Status = g_ProtoStates[p->szModuleName].Status; } if (CallProtoService(p->szModuleName, PS_GETCAPS, PFLAGNUM_3, 0) & Proto_Status2Flag(Status) && g_ProtoStates[p->szModuleName].CurStatusMsg.GetUpdateTimeDifference() >= MinUpdateTimeDifference) { TCString CurMsg(GetDynamicStatMsg(INVALID_CONTACT_ID, p->szModuleName)); if ((TCString)g_ProtoStates[p->szModuleName].CurStatusMsg != (const TCHAR*)CurMsg) { // if the message has changed g_ProtoStates[p->szModuleName].CurStatusMsg = CurMsg; CallAllowedPS_SETAWAYMSG(p->szModuleName, Status, (char*)_T2A(CurMsg)); } } } } SleepEx(PARSE_INTERVAL, true); } }
void ScheduleThread(void*) { time_t waitTime = INFINITE; while (true) { wait: WaitForSingleObject(hScheduleEvent, waitTime); while (ScheduleTask *task = tasks[0]) { if (Miranda_Terminated()) return; mir_cslock lock(threadLock); time_t timestamp = time(NULL); if (task->timestamp > timestamp) { waitTime = (task->timestamp - timestamp - 1) * 1000; goto wait; } tasks.remove(task); mir_forkthread(ExecuteTaskThread, task); } waitTime = INFINITE; } }
void __cdecl UpdateMsgsThreadProc(void *) { int ProtoCount; PROTOCOLDESCRIPTOR **proto; CallService(MS_PROTO_ENUMPROTOCOLS, (WPARAM)&ProtoCount, (LPARAM)&proto); int I; while (WaitForSingleObject(g_hTerminateUpdateMsgsThread, 0) == WAIT_TIMEOUT && !Miranda_Terminated()) { DWORD MinUpdateTimeDifference = g_MoreOptPage.GetDBValueCopy(IDC_MOREOPTDLG_UPDATEMSGSPERIOD) * 1000; // in milliseconds for (I = 0; I < ProtoCount; I++) { if (proto[I]->type == PROTOTYPE_PROTOCOL && CallProtoService(proto[I]->szName, PS_GETCAPS, PFLAGNUM_1, 0) & PF1_MODEMSGSEND && !IsAnICQProto(proto[I]->szName)) { int Status = CallProtoService(proto[I]->szName, PS_GETSTATUS, 0, 0); if (Status < ID_STATUS_OFFLINE || Status > ID_STATUS_OUTTOLUNCH) { Status = g_ProtoStates[proto[I]->szName].Status; } if (CallProtoService(proto[I]->szName, PS_GETCAPS, PFLAGNUM_3, 0) & Proto_Status2Flag(Status) && g_ProtoStates[proto[I]->szName].CurStatusMsg.GetUpdateTimeDifference() >= MinUpdateTimeDifference) { TCString CurMsg(GetDynamicStatMsg(INVALID_HANDLE_VALUE, proto[I]->szName)); if ((TCString)g_ProtoStates[proto[I]->szName].CurStatusMsg != (const TCHAR*)CurMsg) // if the message has changed { g_ProtoStates[proto[I]->szName].CurStatusMsg = CurMsg; CallAllowedPS_SETAWAYMSG(proto[I]->szName, Status, (char*)TCHAR2ANSI(CurMsg)); } } } } SleepEx(PARSE_INTERVAL, true); } }
void aim_direct_connection_initiated(HANDLE hNewConnection, DWORD dwRemoteIP, CAimProto* ppro)//for receiving stuff via dc { file_transfer *ft; char cip[20]; ppro->LOG("Buddy connected from IP: %s", long_ip_to_char_ip(dwRemoteIP, cip)); //okay someone connected to us or we initiated the connection- we need to figure out who they are and if they belong for (int i=21; --i; ) { ft = ppro->ft_list.find_by_ip(dwRemoteIP); if (ft == NULL) ft = ppro->ft_list.find_suitable(); if (ft || Miranda_Terminated()) break; Sleep(100); } if (ft) { ft->hConn = hNewConnection; ppro->aim_dc_helper(ft); } else Netlib_CloseHandle(hNewConnection); }
static int RecvWithTimeoutTime(NetlibConnection *nlc, unsigned dwTimeoutTime, char *buf, int len, int flags) { DWORD dwTimeNow; if (!sslApi.pending(nlc->hSsl)) { while ((dwTimeNow = GetTickCount()) < dwTimeoutTime) { unsigned dwDeltaTime = min(dwTimeoutTime - dwTimeNow, 1000); int res = WaitUntilReadable(nlc->s, dwDeltaTime); switch (res) { case SOCKET_ERROR: return SOCKET_ERROR; case 1: return NLRecv(nlc, buf, len, flags); } if (nlc->termRequested || Miranda_Terminated()) return 0; } SetLastError(ERROR_TIMEOUT); return SOCKET_ERROR; } return NLRecv(nlc, buf, len, flags); }
bool NetlibReconnect(NetlibConnection *nlc) { char buf[4]; bool opened = nlc->s != INVALID_SOCKET; if (opened) { switch (WaitUntilReadable(nlc->s, 0, true)) { case SOCKET_ERROR: opened = false; break; case 0: opened = true; break; case 1: opened = recv(nlc->s, buf, 1, MSG_PEEK) > 0; break; } if (!opened) NetlibDoClose(nlc, true); } if (!opened) { if (Miranda_Terminated()) return false; if (nlc->usingHttpGateway) { nlc->proxyAuthNeeded = true; return my_connect(nlc, &nlc->nloc); } return NetlibDoConnect(nlc); } return true; }
void DeleteJob::waitingThread(void *arg) { DeleteJob *job = (DeleteJob *)arg; while(!Miranda_Terminated()) { mir_cslockfull lock(mutexJobCount); if (iRunningJobCount < MAX_RUNNING_JOBS) { iRunningJobCount++; lock.unlock(); job->run(); delete job; lock.lock(); iRunningJobCount--; lock.unlock(); jobDone.release(); return; } lock.unlock(); jobDone.wait(); } delete job; }
static int HttpPeekFirstResponseLine(NetlibConnection *nlc, DWORD dwTimeoutTime, DWORD recvFlags, int *resultCode, char **ppszResultDescr, int *length) { int bytesPeeked; char buffer[2048]; char *peol; while (true) { bytesPeeked = RecvWithTimeoutTime(nlc, dwTimeoutTime, buffer, _countof(buffer) - 1, MSG_PEEK | recvFlags); if (bytesPeeked == 0) { SetLastError(ERROR_HANDLE_EOF); return 0; } if (bytesPeeked == SOCKET_ERROR) return 0; buffer[bytesPeeked] = '\0'; if ((peol = strchr(buffer, '\n')) != NULL) break; if ((int)mir_strlen(buffer) < bytesPeeked) { SetLastError(ERROR_BAD_FORMAT); return 0; } if (bytesPeeked == _countof(buffer) - 1) { SetLastError(ERROR_BUFFER_OVERFLOW); return 0; } if (Miranda_Terminated()) return 0; Sleep(10); } if (peol == buffer) { SetLastError(ERROR_BAD_FORMAT); return 0; } *peol = '\0'; if (_strnicmp(buffer, "HTTP/", 5)) { SetLastError(ERROR_BAD_FORMAT); return 0; } size_t off = strcspn(buffer, " \t"); if (off >= (unsigned)bytesPeeked) return 0; char* pResultCode = buffer + off; *(pResultCode++) = 0; char* pResultDescr; *resultCode = strtol(pResultCode, &pResultDescr, 10); if (ppszResultDescr) *ppszResultDescr = mir_strdup(lrtrimp(pResultDescr)); if (length) *length = peol - buffer + 1; return 1; }
void __cdecl KeepAliveThread(LPVOID param) { CSametimeProto* proto = (CSametimeProto*)param; int i = 120; proto->debugLog(_T("KeepAliveThread() start")); while (1) { if (i <= 0) { i = 120; // send keepalive every 120 * 250 = 30000[ms] if (mwSession_isStarted(proto->session) && proto->session) { mwSession_sendKeepalive(proto->session); } } i--; SleepEx(250, TRUE); EnterCriticalSection(&(proto->session_cs)); if (Miranda_Terminated() || !proto->session) { LeaveCriticalSection(&(proto->session_cs)); proto->debugLog(_T("KeepAliveThread() end")); break; } LeaveCriticalSection(&(proto->session_cs)); } return; }
static void msgloop_loop(void * vqlink) { WSAEVENT hReadEvent; SOCKET rx_socket = vqp_link_rx_socket((vqp_link_t) vqlink); s_fLoopStarted = TRUE; hReadEvent = WSACreateEvent(); WSAEventSelect(rx_socket, hReadEvent, FD_READ); while(!Miranda_Terminated() && !s_fStopLoop) { DWORD nEvent = WSAWaitForMultipleEvents( 1, &hReadEvent, FALSE, WSA_INFINITE, TRUE); if(nEvent==WSA_WAIT_EVENT_0) { vqp_msg_t msg; WSAResetEvent(hReadEvent); if(!vqp_link_recv((vqp_link_t) vqlink, &msg)) { QueueUserAPC( s_lpfnMsgHandleApc, s_hMainThread, (ULONG_PTR)msg); } } } WSACloseEvent(hReadEvent); /* wait for pending user APC */ while(SleepEx(10, TRUE) == WAIT_IO_COMPLETION) /* nothing */; /* signal that we've finished */ SetEvent(s_hStopWaitEvent); }
void __cdecl CIcqProto::KeepAliveThread(void *arg) { serverthread_info *info = (serverthread_info*)arg; icq_packet packet; DWORD dwInterval = getDword("KeepAliveInterval", KEEPALIVE_INTERVAL); debugLogA("Keep alive thread starting."); info->hKeepAliveEvent = CreateEvent(NULL, FALSE, FALSE, NULL); for (;;) { DWORD dwWait = ICQWaitForSingleObject(info->hKeepAliveEvent, dwInterval); if (serverThreadHandle == NULL) // connection lost, end break; if (dwWait == WAIT_TIMEOUT) { // Send a keep alive packet to server packet.wLen = 0; write_flap(&packet, ICQ_PING_CHAN); sendServPacket(&packet); } else if (dwWait == WAIT_IO_COMPLETION) // Possible shutdown in progress if (Miranda_Terminated()) break; else break; } debugLogA("Keep alive thread ended."); CloseHandle(info->hKeepAliveEvent); info->hKeepAliveEvent = NULL; }
// temporary timer for first run // when this is run, it kill the old startup timer and create the permenant one above VOID CALLBACK timerProc2(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime) { KillTimer(NULL, timerId); ThreadRunning = FALSE; if (db_get_b(NULL, MODULE, "AutoUpdate", 1) && !Miranda_Terminated()) { if (db_get_b(NULL, MODULE, "StartupRetrieve", 1)) CheckAllFeeds(0, 1); timerId = SetTimer(NULL, 0, 30000, (TIMERPROC)timerProc); } }
void GGPROTO::showpopup(const TCHAR* nickname, const TCHAR* msg, int flags) { if (Miranda_Terminated()) return; PopupData *puData = (PopupData*)mir_calloc(sizeof(PopupData)); puData->flags = flags; puData->title = mir_tstrdup(nickname); puData->text = mir_tstrdup(msg); puData->gg = this; CallFunctionAsync(sttMainThreadCallback, puData); }
unsigned int CALLBACK MessagePumpThread(void *param) { HWND hwndTip = 0; MSG hwndMsg = {0}; while (GetMessage(&hwndMsg, 0, 0, 0) > 0 && !Miranda_Terminated()) { if (!IsDialogMessage(hwndMsg.hwnd, &hwndMsg)) { switch(hwndMsg.message) { case MUM_CREATEPOPUP: if(hwndTip) DestroyWindow(hwndTip); // if child of clist, zorder is right, but it steals the first click on a contact :( // copy topmost exstyle from clist, since we'll put clist under tip in WM_CREATE message //LONG clist_exstyle = GetWindowLong((HWND)CallService(MS_CLUI_GETHWND, 0, 0), GWL_EXSTYLE); //hwndTip = CreateWindowEx((clist_exstyle & WS_EX_TOPMOST), POP_WIN_CLASS, _T("TipperPopup"), WS_POPUP, 0, 0, 0, 0, 0/*(HWND)CallService(MS_CLUI_GETHWND, 0, 0)*/, 0, hInst, (LPVOID)hwndMsg.lParam); hwndTip = CreateWindowEx(WS_EX_TOOLWINDOW | WS_EX_TOPMOST, POP_WIN_CLASS, _T("TipperPopup"), WS_POPUP, 0, 0, 0, 0, 0/*(HWND)CallService(MS_CLUI_GETHWND, 0, 0)*/, 0, hInst, (LPVOID)hwndMsg.lParam); if(hwndMsg.lParam) free((LPVOID)hwndMsg.lParam); break; case MUM_DELETEPOPUP: if(hwndTip) { DestroyWindow(hwndTip); hwndTip = NULL; } break; case MUM_GOTSTATUS: if(hwndTip) SendMessage(hwndTip, PUM_SETSTATUSTEXT, hwndMsg.wParam, hwndMsg.lParam); else if(hwndMsg.lParam) free((void *)hwndMsg.lParam); break; case MUM_REDRAW: if(hwndTip) SendMessage(hwndTip, PUM_REFRESH_VALUES, hwndMsg.wParam, hwndMsg.lParam); break; case MUM_GOTAVATAR: if(hwndTip) SendMessage(hwndTip, PUM_SETAVATAR, hwndMsg.wParam, hwndMsg.lParam); break; default: TranslateMessage(&hwndMsg); DispatchMessage(&hwndMsg); break; } } } return 0; }
void CSametimeProto::showPopup(const TCHAR* msg, SametimePopupEnum flag) { if (Miranda_Terminated()) return; PopupData *puData = (PopupData*)mir_calloc(sizeof(PopupData)); puData->flag = flag; puData->title = mir_tstrdup(m_tszUserName); puData->text = mir_tstrdup(msg); puData->proto = this; CallFunctionAsync(sttMainThreadCallback, puData); }
void CMsnProto::MSN_ShowPopup(const TCHAR* nickname, const TCHAR* msg, int flags, const char* url, MCONTACT hContact) { if (Miranda_Terminated()) return; PopupData *pud = (PopupData*)mir_calloc(sizeof(PopupData)); pud->flags = flags; pud->url = mir_strdup(url); pud->title = mir_tstrdup(nickname); pud->text = mir_tstrdup(msg); pud->proto = this; CallFunctionAsync(sttMainThreadCallback, pud); }
static BOOL CallBackAndWait(struct CpuUsageThreadParams *param,BYTE nCpuUsage) { if (param->hFirstEvent != NULL) { /* return value for PollCpuUsage() */ *param->pidThread=GetCurrentThreadId(); SetEvent(param->hFirstEvent); param->hFirstEvent=NULL; /* lower priority after first call */ SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_IDLE); } if (!param->pfnDataAvailProc(nCpuUsage,param->lParam)) return FALSE; SleepEx(param->dwDelayMillis,TRUE); return !Miranda_Terminated(); }
void gg_showpopup(GGPROTO* gg, const char* nickname, const char* msg, int flags) { PopupData* puData; if (Miranda_Terminated()) return; puData = (PopupData*)mir_alloc(sizeof(PopupData)); puData->flags = flags; puData->title = mir_strdup(nickname); puData->text = mir_strdup(msg); puData->gg = gg; CallFunctionAsync(sttMainThreadCallback, puData); }
void CMsnProto::MSN_GoOffline(void) { if (m_iStatus == ID_STATUS_OFFLINE) return; msnLoggedIn = false; if (mStatusMsgTS) ForkThread(&CMsnProto::msn_storeProfileThread, NULL); mir_free(msnPreviousUUX); msnPreviousUUX = NULL; msnSearchId = NULL; if (!Miranda_Terminated()) MSN_EnableMenuItems(false); MSN_FreeGroups(); MsgQueue_Clear(); clearCachedMsg(); if (!Miranda_Terminated()) { int msnOldStatus = m_iStatus; m_iStatus = m_iDesiredStatus = ID_STATUS_OFFLINE; ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)msnOldStatus, ID_STATUS_OFFLINE); isIdle = false; int count = -1; for (;;) { MsnContact *msc = Lists_GetNext(count); if (msc == NULL) break; if (ID_STATUS_OFFLINE != getWord(msc->hContact, "Status", ID_STATUS_OFFLINE)) { setWord(msc->hContact, "Status", ID_STATUS_OFFLINE); setDword(msc->hContact, "IdleTS", 0); } } } }
int ModeChange(WPARAM, LPARAM lparam) { ACKDATA *ack = (ACKDATA *)lparam; if (ack->type != ACKTYPE_STATUS || ack->result != ACKRESULT_SUCCESS || ack->hContact != NULL) return 0; courProtoName = (char *)ack->szModule; if (!IsWatchedProtocol(courProtoName) && strncmp(courProtoName, "MetaContacts", 12)) return 0; DBWriteTimeTS(time(NULL), NULL); // isetting=CallProtoService(ack->szModule,PS_GETSTATUS,0,0); WORD isetting = (WORD)ack->lParam; if (isetting < ID_STATUS_OFFLINE) isetting = ID_STATUS_OFFLINE; if ((isetting > ID_STATUS_OFFLINE) && ((WORD)ack->hProcess <= ID_STATUS_OFFLINE)) { //we have just loged-in db_set_dw(NULL, "UserOnline", ack->szModule, GetTickCount()); if (!Miranda_Terminated() && IsWatchedProtocol(ack->szModule)) { logthread_info *info = (logthread_info *)mir_alloc(sizeof(logthread_info)); mir_strncpy(info->sProtoName, courProtoName, _countof(info->sProtoName)); info->hContact = 0; info->currStatus = 0; mir_forkthread(cleanThread, info); } } else if ((isetting == ID_STATUS_OFFLINE) && ((WORD)ack->hProcess > ID_STATUS_OFFLINE)) { //we have just loged-off if (IsWatchedProtocol(ack->szModule)) { char str[MAXMODULELABELLENGTH + 9]; time_t t; time(&t); mir_snprintf(str, "OffTime-%s", ack->szModule); db_set_dw(NULL, S_MOD, str, t); } } if (isetting == db_get_w(NULL, S_MOD, courProtoName, ID_STATUS_OFFLINE)) return 0; db_set_w(NULL, S_MOD, courProtoName, isetting); if (g_bFileActive) FileWrite(NULL); courProtoName = NULL; return 0; }
void __cdecl CAimProto::aim_dc_helper(void* param) //only called when we are initiating a direct connection with someone else { file_transfer *ft = (file_transfer*)param; sendBroadcast(ft->hContact, ACKTYPE_FILE, ACKRESULT_CONNECTED, ft, 0); NETLIBPACKETRECVER packetRecv = {0}; packetRecv.cbSize = sizeof(packetRecv); packetRecv.dwTimeout = 350000; HANDLE hServerPacketRecver = (HANDLE) CallService(MS_NETLIB_CREATEPACKETRECVER, (WPARAM)ft->hConn, 2048 * 4); int result; if (ft->sending)//we are sending result = sending_file(ft, hServerPacketRecver, packetRecv); else result = receiving_file(ft, hServerPacketRecver, packetRecv); Netlib_CloseHandle(hServerPacketRecver); Netlib_CloseHandle(ft->hConn); ft->hConn = NULL; if (result == 0) { sendBroadcast(ft->hContact, ACKTYPE_FILE, ACKRESULT_SUCCESS, ft, 0); } else { if (!ft->requester && result == 1 && !Miranda_Terminated()) { ft->accepted = false; HANDLE hConn = aim_peer_connect(AIM_PROXY_SERVER, get_default_port()); if (hConn) { LOG("Connected to proxy ip because we want to use a proxy for the file transfer."); ft->requester = true; ft->hConn = hConn; ForkThread(&CAimProto::aim_proxy_helper, ft); return; } } aim_file_ad(hServerConn, seqno, ft->sn, ft->icbm_cookie, true, 0); sendBroadcast(ft->hContact, ACKTYPE_FILE, ACKRESULT_FAILED, ft, 0); } ft_list.remove_by_ft(ft); }
void __cdecl SendThread(LPVOID param) { mwFileTransfer* ft = (mwFileTransfer*)param; if (!ft) return; CSametimeProto* proto = getProtoFromMwFileTransfer(ft); FileTransferClientData* ftcd = (FileTransferClientData*)mwFileTransfer_getClientData(ft); proto->debugLog(_T("SendThread() start")); PROTOFILETRANSFERSTATUS pfts = {0}; pfts.cbSize = sizeof(pfts); pfts.flags = PFTS_UTF; pfts.hContact = ftcd->hContact; if (ftcd->sending == 1) pfts.flags |= PFTS_SENDING; pfts.pszFiles = NULL; pfts.totalFiles = ftcd->first->ft_count; pfts.totalBytes = ftcd->first->totalSize; while(SendFileChunk(proto, ft, ftcd) && !Miranda_Terminated()) { pfts.currentFileNumber = ftcd->ft_number; pfts.totalProgress = ftcd->sizeToHere + mwFileTransfer_getSent(ft); pfts.szWorkingDir = ftcd->save_path; pfts.szCurrentFile = (char*)mwFileTransfer_getFileName(ft); pfts.currentFileSize = mwFileTransfer_getFileSize(ft); pfts.currentFileProgress = mwFileTransfer_getSent(ft); pfts.currentFileTime = 0; //? proto->ProtoBroadcastAck(ftcd->hContact, ACKTYPE_FILE, ACKRESULT_DATA, ftcd->hFt, (LPARAM)&pfts); SleepEx(500,TRUE); } proto->ProtoBroadcastAck(ftcd->hContact, ACKTYPE_FILE, ACKRESULT_SUCCESS, ftcd->hFt, 0); mwFileTransfer_removeClientData(ft); if (ftcd->save_path) free(ftcd->save_path); if (ftcd->buffer) delete[] ftcd->buffer; delete ftcd; proto->debugLog(_T("SendThread() end")); return; }
// main auto-update timer VOID CALLBACK timerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime) { // only run if it is not current updating and the auto update option is enabled if (!ThreadRunning && !Miranda_Terminated()) { BOOL HaveUpdates = FALSE; for (MCONTACT hContact = db_find_first(MODULE); hContact; hContact = db_find_next(hContact, MODULE)) { if (db_get_dw(hContact, MODULE, "UpdateTime", DEFAULT_UPDATE_TIME)) { double diff = difftime(time(NULL), db_get_dw(hContact, MODULE, "LastCheck", 0)); if (db_get_b(NULL, MODULE, "AutoUpdate", 1) != 0 && diff >= db_get_dw(hContact, MODULE, "UpdateTime", DEFAULT_UPDATE_TIME) * 60) { UpdateListAdd(hContact); HaveUpdates = TRUE; } } } if (!ThreadRunning && HaveUpdates) mir_forkthread(UpdateThreadProc, (LPVOID)FALSE); } }
void ShowNotification(const char *caption, const char *message, int flags, MCONTACT hContact) { if (Miranda_Terminated()) return; if (ServiceExists(MS_POPUP_ADDPOPUPT) && db_get_b(NULL, "Popup", "ModuleIsEnabled", 1)) { POPUPDATA ppd = { 0 }; ppd.lchContact = hContact; mir_strncpy(ppd.lpzContactName, caption, MAX_CONTACTNAME); mir_strncpy(ppd.lpzText, message, MAX_SECONDLINE); if (!PUAddPopup(&ppd)) return; } ::MessageBoxA(NULL, message, caption, MB_OK | flags); }
void CSteamProto::ShowNotification(const TCHAR *caption, const wchar_t *message, int flags, MCONTACT hContact) { if (Miranda_Terminated()) return; if (ServiceExists(MS_POPUP_ADDPOPUPT) && db_get_b(NULL, "Popup", "ModuleIsEnabled", 1)) { POPUPDATAT ppd = { 0 }; ppd.lchContact = hContact; wcsncpy(ppd.lpwzContactName, caption, MAX_CONTACTNAME); wcsncpy(ppd.lpwzText, message, MAX_SECONDLINE); ppd.lchIcon = IcoLib_GetIcon(MODULE"_main"); if (!PUAddPopupT(&ppd)) return; } MessageBox(NULL, message, caption, MB_OK | flags); }
HANDLE GetCurrChain() { struct AskChain * workChain; HANDLE res=NULL; while (LockChainDeletion) { SleepEx(0,TRUE); if (Miranda_Terminated()) return 0; } LockChainAddition=1; if (FirstChain) { res=FirstChain->ContactRequest; workChain=FirstChain->Next; mir_free(FirstChain); FirstChain=(AskChain *)workChain; } LockChainAddition=0; return res; }
int AddHandleToChain(HANDLE hContact) { AskChain * workChain; while (LockChainAddition) { SleepEx(0,TRUE); if (Miranda_Terminated()) return 0; } LockChainDeletion=1; { //check that handle is present AskChain * wChain; wChain=FirstChain; if (wChain) { do { if (wChain->ContactRequest==hContact) { LockChainDeletion=0; return 0; } } while(wChain=(AskChain *)wChain->Next); } } if (!FirstChain) { FirstChain=mir_alloc(sizeof(AskChain)); workChain=FirstChain; } else { LastChain->Next=mir_alloc(sizeof(AskChain)); workChain=(AskChain *)LastChain->Next; } LastChain=workChain; workChain->Next=NULL; workChain->ContactRequest=hContact; LockChainDeletion=0; return 1; }
void UpdateThreadProc(LPVOID AvatarCheck) { WaitForSingleObject(hUpdateMutex, INFINITE); if (ThreadRunning) { ReleaseMutex(hUpdateMutex); return; } ThreadRunning = TRUE; // prevent 2 instance of this thread running ReleaseMutex(hUpdateMutex); // update news by getting the first station from the queue until the queue is empty while (UpdateListHead != NULL && !Miranda_Terminated()) { if ((BOOL)AvatarCheck) CheckCurrentFeedAvatar(UpdateGetFirst()); else CheckCurrentFeed(UpdateGetFirst()); } // exit the update thread ThreadRunning = FALSE; }