Beispiel #1
0
int ThreadData::sendPacket(const char* cmd, const char* fmt,...)
{
	if (this == NULL) return 0;

	size_t strsize = 512;
	char* str = (char*)mir_alloc(strsize);

	int thisTrid = 0;

	if (fmt == NULL)
		mir_snprintf(str, strsize, "%s", cmd);
	else {
		thisTrid = InterlockedIncrement(&mTrid);
		if (fmt[0] == '\0')
			mir_snprintf(str, strsize, "%s %d", cmd, thisTrid);
		else {
			va_list vararg;
			va_start(vararg, fmt);

			int paramStart = mir_snprintf(str, strsize, "%s %d ", cmd, thisTrid);
			while (mir_vsnprintf(str+paramStart, strsize-paramStart-3, fmt, vararg) == -1)
				str = (char*)mir_realloc(str, strsize += 512);

			str[strsize-3] = 0;
			va_end(vararg);
		}
	}

	if (strchr(str, '\r') == NULL)
		strcat(str,"\r\n");

	int result = send(str, strlen(str));
	mir_free(str);
	return (result > 0) ? thisTrid : -1;
}
Beispiel #2
0
static TCHAR *parseUrlDec(ARGUMENTSINFO *ai)
{
	if (ai->argc != 2)
		return NULL;

	char *res = mir_t2a(ai->targv[1]);
	if (res == NULL)
		return NULL;

	unsigned int cur = 0;
	while (cur < mir_strlen(res)) {
		if ((*(res + cur) == '%') && (mir_strlen(res + cur) >= 3)) {
			char hex[8];
			memset(hex, '\0', sizeof(hex));
			strncpy(hex, res + cur + 1, 2);
			*(res + cur) = (char)strtol(hex, NULL, 16);
			memmove(res + cur + 1, res + cur + 3, mir_strlen(res + cur + 3) + 1);
		}
		cur++;
	}

	res = (char*)mir_realloc(res, mir_strlen(res) + 1);
	TCHAR *tres = mir_a2t(res);
	mir_free(res);
	return tres;
}
LPSTR TranslateU( LPCSTR lpText ) {
	int i;
	for(i=0;i<ca2u;i++) {
		if( pa2u[i].a == lpText ) {
			return pa2u[i].u;
		}
	}
	ca2u++;
	pa2u = (pA2U) mir_realloc(pa2u,sizeof(A2U)*ca2u);
	pa2u[i].a = (LPSTR) lpText;
	if( bCoreUnicode ) {
		LPWSTR lpwText = mir_a2u(lpText);
		LPWSTR lpwTran = TranslateW(lpwText);
		mir_free(lpwText);
		pa2u[i].u = mir_strdup(exp->utf8encode(lpwTran));
	}
	else {
		LPSTR lpTran = Translate(lpText);
		LPWSTR lpwTran = mir_a2u(lpTran);
		lpTran = exp->utf8encode(lpwTran);
		mir_free(lpwTran);
		pa2u[i].u = mir_strdup(lpTran);
	}
	return pa2u[i].u;
}
Beispiel #4
0
static TCHAR *parseUrlEnc(ARGUMENTSINFO *ai)
{
	if (ai->argc != 2)
		return NULL;

	char *res = mir_t2a(ai->targv[1]);
	if (res == NULL)
		return NULL;

	size_t cur = 0;
	while (cur < mir_strlen(res)) {
		if (((*(res + cur) >= '0') && (*(res + cur) <= '9')) || ((*(res + cur) >= 'a') && (*(res + cur) <= 'z')) || ((*(res + cur) >= 'A') && (*(res + cur) <= 'Z'))) {
			cur++;
			continue;
		}
		res = (char*)mir_realloc(res, mir_strlen(res) + 4);
		if (res == NULL)
			return NULL;

		char hex[8];
		memmove(res + cur + 3, res + cur + 1, mir_strlen(res + cur + 1) + 1);
		mir_snprintf(hex, _countof(hex), "%%%x", *(res + cur));
		strncpy(res + cur, hex, mir_strlen(hex));
		cur += mir_strlen(hex);
	}

	TCHAR *tres = mir_a2t(res);
	mir_free(res);
	return tres;
}
Beispiel #5
0
bool EventList::GetEventData(const EventIndex& ev, EventData& data)
{
	if (!ev.isExternal) {
		DWORD newBlobSize = db_event_getBlobSize(ev.hEvent);
		if (newBlobSize > goldBlobSize) {
			gdbei.pBlob = (PBYTE)mir_realloc(gdbei.pBlob,newBlobSize);
			goldBlobSize = newBlobSize;
		}

		gdbei.cbBlob = goldBlobSize;
		if (db_event_get(ev.hEvent, &gdbei) == 0) {
			data.isMe = (gdbei.flags & DBEF_SENT) != 0;
			data.eventType = gdbei.eventType;
			data.timestamp = gdbei.timestamp;
			return true;
		}
	}
	else if (ev.exIdx >= 0 && ev.exIdx < (int)importedMessages.size()) {
		IImport::ExternalMessage& em = importedMessages[ev.exIdx];
		data.isMe = (em.flags & DBEF_SENT) != 0;
		data.eventType = em.eventType;
		data.timestamp = em.timestamp;
		return true;
	}

	return false;
}
Beispiel #6
0
// always gets called in main message loop
static void CALLBACK BufferedProcTimer(HWND hwnd,UINT msg,UINT_PTR idTimer,DWORD currentTick)
{
	struct BufferedCallData *buf;
	UINT uElapsed,uElapseNext=USER_TIMER_MAXIMUM;
	BUFFEREDPROC pfnBuffProc;
	LPARAM lParam;
	#ifdef _DEBUG
	char szDbgLine[256];
	const char *pszProcName;
	#endif

	for(int i=0; i < nCallListCount; ++i) {
		/* find elapsed procs */
		uElapsed=currentTick-callList[i].startTick; /* wraparound works */
		if ((uElapsed+USER_TIMER_MINIMUM)>=callList[i].uElapse) { 
			/* call elapsed proc */
			pfnBuffProc=callList[i].pfnBuffProc;
			lParam=callList[i].lParam;
			#ifdef _DEBUG
				pszProcName=callList[i].pszProcName;
			#endif
			/* resize storage array */
			if ((i+1)<nCallListCount)
				memmove(&callList[i],&callList[i+1],((nCallListCount-i-1)*sizeof(struct BufferedCallData)));
			--nCallListCount;
			--i; /* reiterate current */
			if (nCallListCount) {
				buf=(struct BufferedCallData*)mir_realloc(callList,nCallListCount*sizeof(struct BufferedCallData));
				if (buf != NULL) callList=buf;
			} else {
				mir_free(callList);
				callList=NULL;
			}
			#ifdef _DEBUG
				mir_snprintf(szDbgLine,SIZEOF(szDbgLine),"buffered call: %s(0x%X)\n",pszProcName,lParam); /* all ascii */
				OutputDebugStringA(szDbgLine);
			#endif
			CallFunctionAsync((void (CALLBACK *)(void*))pfnBuffProc,(void*)lParam); /* compatible */
		}
		/* find next timer delay */
		else if ((callList[i].uElapse-uElapsed)<uElapseNext)
			uElapseNext=callList[i].uElapse-uElapsed;
	}

	/* set next timer */
	if (nCallListCount) {
		#ifdef _DEBUG
			mir_snprintf(szDbgLine,SIZEOF(szDbgLine),"next buffered timeout: %ums\n",uElapseNext); /* all ascii */
			OutputDebugStringA(szDbgLine);
		#endif
		idBufferedTimer=SetTimer(hwnd,idBufferedTimer,uElapseNext,BufferedProcTimer); /* will be reset */
	} else {
		KillTimer(hwnd,idTimer);
		idBufferedTimer=0;
		#ifdef _DEBUG
			OutputDebugStringA("empty buffered queue\n");
		#endif
	}
}
Beispiel #7
0
INT_PTR CIrcProto::CallChatEvent(WPARAM wParam, LPARAM lParam)
{
    GCEVENT * gce = (GCEVENT *)lParam;
    INT_PTR iVal = 0;

    // first see if the scripting module should modify or stop this event
    if ( m_bMbotInstalled && m_scriptingEnabled && gce
            && gce->time != 0 && (gce->pDest->pszID == NULL
                                  || lstrlen(gce->pDest->ptszID) != 0 && lstrcmpi(gce->pDest->ptszID , SERVERWINDOW)))
    {
        GCEVENT *gcevent= (GCEVENT*) lParam;
        GCEVENT *gcetemp = NULL;
        WPARAM wp = wParam;
        gcetemp = (GCEVENT *)mir_alloc(sizeof(GCEVENT));
        gcetemp->pDest = (GCDEST *)mir_alloc(sizeof(GCDEST));
        gcetemp->pDest->iType = gcevent->pDest->iType;
        gcetemp->dwFlags = gcevent->dwFlags;
        gcetemp->bIsMe = gcevent->bIsMe;
        gcetemp->cbSize = sizeof(GCEVENT);
        gcetemp->dwItemData = gcevent->dwItemData;
        gcetemp->time = gcevent->time;
        gcetemp->pDest->ptszID = mir_tstrdup( gcevent->pDest->ptszID );
        gcetemp->pDest->pszModule = mir_strdup( gcevent->pDest->pszModule );
        gcetemp->ptszText = mir_tstrdup( gcevent->ptszText );
        gcetemp->ptszUID = mir_tstrdup( gcevent->ptszUID );
        gcetemp->ptszNick = mir_tstrdup( gcevent->ptszNick );
        gcetemp->ptszStatus = mir_tstrdup( gcevent->ptszStatus );
        gcetemp->ptszUserInfo = mir_tstrdup( gcevent->ptszUserInfo );

        if ( Scripting_TriggerMSPGuiIn( &wp, gcetemp ) && gcetemp ) {
            //MBOT CORRECTIONS
            //if ( gcetemp && gcetemp->pDest && gcetemp->pDest->ptszID ) {
            if ( gcetemp && gcetemp->pDest && gcetemp->pDest->ptszID &&
                    !my_strstri(gcetemp->pDest->ptszID, (IsConnected()) ? m_info.sNetwork.c_str() : TranslateT("Offline")) ) {

                CMString sTempId = MakeWndID( gcetemp->pDest->ptszID );
                mir_realloc( gcetemp->pDest->ptszID, sizeof(TCHAR)*(sTempId.GetLength() + 1));
                lstrcpyn(gcetemp->pDest->ptszID, sTempId.c_str(), sTempId.GetLength()+1);
            }
            iVal = CallServiceSync(MS_GC_EVENT, wp, (LPARAM) gcetemp);
        }

        if ( gcetemp ) {
            mir_free(( void* )gcetemp->pszNick);
            mir_free(( void* )gcetemp->pszUID);
            mir_free(( void* )gcetemp->pszStatus);
            mir_free(( void* )gcetemp->pszUserInfo);
            mir_free(( void* )gcetemp->pszText);
            mir_free(( void* )gcetemp->pDest->pszID);
            mir_free(( void* )gcetemp->pDest->pszModule);
            mir_free(( void* )gcetemp->pDest);
            mir_free(( void* )gcetemp);
        }

        return iVal;
    }

    return CallServiceSync( MS_GC_EVENT, wParam, ( LPARAM )gce );
}
Beispiel #8
0
unsigned MimeHeaders::allocSlot(void)
{
	if (++mCount >= mAllocCount) 
	{
		mAllocCount += 10;
		mVals = (MimeHeader*)mir_realloc(mVals, sizeof(MimeHeader) * mAllocCount);
	}
	return mCount - 1; 
}
Beispiel #9
0
void SetStatusBarResultInfo(HWND hwndDlg)
{
	HWND hwndStatus = GetDlgItem(hwndDlg, IDC_STATUSBAR);
	HWND hwndResults = GetDlgItem(hwndDlg, IDC_RESULTS);
	LV_ITEM lvi;
	struct ListSearchResult *lsr;
	struct ProtoResultsSummary *subtotal = NULL;
	int subtotalCount = 0;
	int i, total;
	TCHAR str[256];

	total = ListView_GetItemCount(hwndResults);
	for (lvi.iItem = total-1;lvi.iItem>=0;lvi.iItem--) {
		lvi.mask = LVIF_PARAM;
		ListView_GetItem(hwndResults, &lvi);
		lsr = (struct ListSearchResult*)lvi.lParam;
		if (lsr == NULL) continue;
		for (i=0;i<subtotalCount;i++) {
			if (subtotal[i].szProto == lsr->szProto) {
				subtotal[i].count++;
				break;
			}
		}
		if (i == subtotalCount) {
			subtotal = (struct ProtoResultsSummary*)mir_realloc(subtotal, sizeof(struct ProtoResultsSummary)*(subtotalCount+1));
			subtotal[subtotalCount].szProto = lsr->szProto;
			subtotal[subtotalCount++].count = 1;
		}
	}
	if (total != 0) {
		TCHAR substr[64];
		PROTOACCOUNT *pa = Proto_GetAccount(subtotal[0].szProto);
		if (pa == NULL)
			return;

		if (subtotalCount == 1) {
			if (total == 1) mir_sntprintf(str, SIZEOF(str), TranslateT("1 %s user found"), pa->tszAccountName);
			else mir_sntprintf(str, SIZEOF(str), TranslateT("%d %s users found"), total, pa->tszAccountName);
		}
		else {
			mir_sntprintf(str, SIZEOF(str), TranslateT("%d users found ("), total);
			for (i=0; i < subtotalCount; i++) {
				if (i) {
					if ((pa = Proto_GetAccount(subtotal[i].szProto)) == NULL)
						return;
					lstrcat(str, _T(", "));
				}
				mir_sntprintf(substr, SIZEOF(substr), _T("%d %s"), subtotal[i].count, pa->tszAccountName);
				lstrcat(str, substr);
			}
			lstrcat(str, _T(")"));
		}
		mir_free(subtotal);
	}
	else lstrcpy(str, TranslateT("No users found"));
	SendMessage(hwndStatus, SB_SETTEXT, 2, (LPARAM)str);
}
Beispiel #10
0
void CJabberProto::ListRemoveResource( JABBER_LIST list, const TCHAR* jid )
{
	EnterCriticalSection( &m_csLists );
	int i = ListExist( list, jid );
	JABBER_LIST_ITEM* LI = m_lstRoster[i-1];
	if ( !i || LI == NULL ) {
		LeaveCriticalSection( &m_csLists );
		return;
	}

	const TCHAR* p = _tcschr( jid, '@' );
	const TCHAR* q = _tcschr(( p == NULL ) ? jid : p, '/' );
	if ( q ) {
		const TCHAR* resource = q+1;
		if ( resource[0] ) {
			JABBER_RESOURCE_STATUS* r = LI->resource;
			int j;
			for ( j=0; j < LI->resourceCount; j++, r++ ) {
				if ( !_tcsicmp( r->resourceName, resource ))
					break;
			}
			if ( j < LI->resourceCount ) {
				// Found last seen resource ID to be removed
				if ( LI->lastSeenResource == j )
					LI->lastSeenResource = -1;
				else if ( LI->lastSeenResource > j )
					LI->lastSeenResource--;
				// update manually selected resource ID
				if (LI->resourceMode == RSMODE_MANUAL)
				{
					if ( LI->manualResource == j )
					{
						LI->resourceMode = RSMODE_LASTSEEN;
						LI->manualResource = -1;
					} else if ( LI->manualResource > j )
						LI->manualResource--;
				}

				// Update MirVer due to possible resource changes
				UpdateMirVer(LI);

				JabberListFreeResourceInternal( r );

				if ( LI->resourceCount-- == 1 ) {
					mir_free( r );
					LI->resource = NULL;
				}
				else {
					memmove( r, r+1, ( LI->resourceCount-j )*sizeof( JABBER_RESOURCE_STATUS ));
					LI->resource = ( JABBER_RESOURCE_STATUS* )mir_realloc( LI->resource, LI->resourceCount*sizeof( JABBER_RESOURCE_STATUS ));
	}	}	}	}

	LeaveCriticalSection( &m_csLists );

	MenuUpdateSrmmIcon(LI);
}
Beispiel #11
0
//---------------------------------------------------------------------------
int CSend::OnSend(void *obj, WPARAM, LPARAM lParam)
{
	CSend* self = (CSend*)obj;
	ACKDATA *ack = (ACKDATA*)lParam;
	if (ack->hProcess != self->m_hSend) return 0;
	/*	if(dat->waitingForAcceptance) {
			SetTimer(hwndDlg,1,1000,NULL);
			dat->waitingForAcceptance=0;
			}
			*/

	switch (ack->result) {
	case ACKRESULT_INITIALISING:	//SetFtStatus(hwndDlg, LPGENT("Initialising..."), FTS_TEXT); break;
	case ACKRESULT_CONNECTING:		//SetFtStatus(hwndDlg, LPGENT("Connecting..."), FTS_TEXT); break;
	case ACKRESULT_CONNECTPROXY:	//SetFtStatus(hwndDlg, LPGENT("Connecting to proxy..."), FTS_TEXT); break;
	case ACKRESULT_LISTENING:		//SetFtStatus(hwndDlg, LPGENT("Waiting for connection..."), FTS_TEXT); break;
	case ACKRESULT_CONNECTED:		//SetFtStatus(hwndDlg, LPGENT("Connected"), FTS_TEXT); break;
	case ACKRESULT_SENTREQUEST:		//SetFtStatus(hwndDlg, LPGENT("Decision sent"), FTS_TEXT); break;
	case ACKRESULT_NEXTFILE:		//SetFtStatus(hwndDlg, LPGENT("Moving to next file..."), FTS_TEXT);
	case ACKRESULT_FILERESUME:		//
	case ACKRESULT_DATA:			//transfer is on progress
		break;
	case ACKRESULT_DENIED:
		self->Unhook();
		self->Exit(ack->result);
		break;
	case ACKRESULT_FAILED:
		self->Unhook();
		self->Exit(ack->result);
		//type=ACKTYPE_MESSAGE, result=success/failure, (char*)lParam=error message or NULL.
		//type=ACKTYPE_URL, result=success/failure, (char*)lParam=error message or NULL.
		//type=ACKTYPE_FILE, result=ACKRESULT_FAILED then lParam=(LPARAM)(const char*)szReason
		break;
	case ACKRESULT_SUCCESS:
		self->Unhook();
		switch (ack->type) {
		case ACKTYPE_CHAT:
			break;
		case ACKTYPE_MESSAGE:
			self->DB_EventAdd((WORD)EVENTTYPE_MESSAGE);
			break;
		case ACKTYPE_URL:
			self->DB_EventAdd((WORD)EVENTTYPE_URL);
			break;
		case ACKTYPE_FILE:
			self->m_szEventMsg = (char*)mir_realloc(self->m_szEventMsg, sizeof(DWORD) + self->m_cbEventMsg);
			memmove(self->m_szEventMsg + sizeof(DWORD), self->m_szEventMsg, self->m_cbEventMsg);
			self->m_cbEventMsg += sizeof(DWORD);
			self->DB_EventAdd((WORD)EVENTTYPE_FILE);
			break;
		}
		self->Exit(ack->result);
		break;
	}
	return 0;
}
Beispiel #12
0
static int ProtoAck(WPARAM, LPARAM lParam)
{
	ACKDATA *ack = (ACKDATA*)lParam;
	if (ack->type != ACKTYPE_FILE)
		return 0;

	switch (ack->result) {
	case ACKRESULT_DATA:
		{
			for (int i = 0; i < nTransfersCount; ++i)
				if (transfers[i] == ack->hProcess)
					break; /* already in list */
			/* insert into list */
			HANDLE *buf = (HANDLE*)mir_realloc(transfers, (nTransfersCount + 1)*sizeof(HANDLE));
			if (buf != NULL) {
				transfers = buf;
				transfers[nTransfersCount] = ack->hProcess;
				++nTransfersCount;
			}
			break;
		}
	case ACKRESULT_SUCCESS:
	case ACKRESULT_FAILED:
	case ACKRESULT_DENIED:
		for (int i = 0; i < nTransfersCount; ++i) {
			if (transfers[i] == ack->hProcess) {
				/* remove from list */
				if (i < (nTransfersCount - 1))
					memmove(&transfers[i], &transfers[i + 1], (nTransfersCount - i - 1)*sizeof(HANDLE));
				--nTransfersCount;
				HANDLE *buf = (HANDLE*)mir_realloc(transfers, nTransfersCount*sizeof(HANDLE));
				if (buf != NULL) transfers = buf;
				else if (!nTransfersCount) transfers = NULL;
				/* stop watcher */
				if (!nTransfersCount && (currentWatcherType&SDWTF_FILETRANSFER))
					ShutdownAndStopWatcher();
				break;
			}
		}
		break;
	}
	return 0;
}
Beispiel #13
0
// MonitorInfoEnumProc - CALLBACK for MonitorInfoEnum
BOOL CALLBACK MonitorInfoEnumProc(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) {
	MONITORS* monitors = (MONITORS*)dwData;
	++monitors->count;
	monitors->info = (MONITORINFOEX*)mir_realloc(monitors->info, sizeof(MONITORINFOEX)*monitors->count);
	monitors->info[monitors->count-1].cbSize = sizeof(MONITORINFOEX);
	if(!GetMonitorInfo(hMonitor, (LPMONITORINFO)(monitors->info + monitors->count-1))) {
		return FALSE;	// stop enumeration if error
	}
	return TRUE;
}
Beispiel #14
0
TReceivedItem* TRecvContactsData::AddReceivedItem()
{
	int iItem = cbReceived;

	cbReceived++;
	maReceived = (TReceivedItem**)mir_realloc(maReceived, cbReceived*sizeof(TReceivedItem*));
	maReceived[iItem] = new TReceivedItem();

	return maReceived[iItem];
}
Beispiel #15
0
static DWORD CALLBACK StreamOutCallback(DWORD_PTR dwCookie, LPBYTE pbBuff, LONG cb, LONG * pcb)
{
	MessageSendQueueItem *msi = (MessageSendQueueItem *)dwCookie;
	msi->sendBuffer = (char*)mir_realloc(msi->sendBuffer, msi->sendBufferSize + cb + 2);
	memcpy(msi->sendBuffer + msi->sendBufferSize, pbBuff, cb);
	msi->sendBufferSize += cb;
	*((TCHAR*)(msi->sendBuffer + msi->sendBufferSize)) = '\0';
	*pcb = cb;
	return 0;
}
Beispiel #16
0
static bool ReallocInfoBuffer(ThreadData *info, size_t mDataSize)
{
	char *mData = (char*)mir_realloc(info->mData, mDataSize+1);
	if (mData == NULL)
		return false;

	info->mData = mData;
	info->mDataSize = mDataSize;
	ZeroMemory(&mData[info->mBytesInData], info->mDataSize-info->mBytesInData+1);
	return true;
}
Beispiel #17
0
static TCHAR* GetAwayMessage(int statusMode, char *szProto)
{
	DBVARIANT dbv;
	
	if (szProto && !(CallProtoService(szProto, PS_GETCAPS, PFLAGNUM_3, 0) & Proto_Status2Flag(statusMode)))
		return NULL;

	if (DBGetContactSettingByte(NULL, "SRAway", StatusModeToDbSetting(statusMode, "Ignore"), 0))
		return NULL;

	if (DBGetContactSettingByte(NULL, "SRAway", StatusModeToDbSetting(statusMode, "UsePrev"),0)) 
	{
		if (DBGetContactSettingTString(NULL, "SRAway", StatusModeToDbSetting(statusMode, "Msg"), &dbv))
			dbv.ptszVal = mir_tstrdup(GetDefaultMessage(statusMode));
	}
	else {
		int i;
		TCHAR substituteStr[128];
		if (DBGetContactSettingTString(NULL, "SRAway", StatusModeToDbSetting(statusMode,"Default"), &dbv))
			dbv.ptszVal = mir_tstrdup(GetDefaultMessage(statusMode));

		for (i=0; dbv.ptszVal[i]; i++) 
		{
			if (dbv.ptszVal[i] != '%') continue;
			if (!_tcsnicmp(dbv.ptszVal + i, _T("%time%"), 6)) 
			{
				MIRANDA_IDLE_INFO mii = {0};
				mii.cbSize = sizeof(mii);
				CallService(MS_IDLE_GETIDLEINFO, 0, (LPARAM)&mii);

				if (mii.idleType == 1)
				{
					int mm;
					SYSTEMTIME t;
					GetLocalTime(&t);
					mm = t.wMinute + t.wHour * 60 - mii.idleTime;
					if (mm < 0) mm += 60 * 24;
					t.wMinute = mm % 60;
					t.wHour = mm / 60;
					GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &t, NULL, substituteStr, SIZEOF(substituteStr));
				}
				else GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, NULL, NULL, substituteStr, SIZEOF(substituteStr));
			}
			else if (!_tcsnicmp(dbv.ptszVal + i, _T("%date%"), 6))
				GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL, substituteStr, SIZEOF(substituteStr));
			else continue;
			if (lstrlen(substituteStr) > 6) 
				dbv.ptszVal = (TCHAR*)mir_realloc(dbv.ptszVal, (lstrlen(dbv.ptszVal) + 1 + lstrlen(substituteStr) - 6) * sizeof(TCHAR));
			MoveMemory(dbv.ptszVal + i + lstrlen(substituteStr), dbv.ptszVal + i + 6, (lstrlen(dbv.ptszVal) - i - 5) * sizeof(TCHAR));
			CopyMemory(dbv.ptszVal+i, substituteStr, lstrlen(substituteStr) * sizeof(TCHAR));
		}
	}
	return dbv.ptszVal;
}
void JabberListRemoveByIndex(int index)
{
	EnterCriticalSection(&csLists);
	if (index>=0 && index<count) {
		JabberListFreeItemInternal(&(lists[index]));
		count--;
		memmove(lists+index, lists+index+1, sizeof(JABBER_LIST_ITEM)*(count-index));
		lists = (JABBER_LIST_ITEM *) mir_realloc(lists, sizeof(JABBER_LIST_ITEM)*count);
	}
	LeaveCriticalSection(&csLists);
}
static int RemoveFromList(int pos,void **lpList,int *ListElemCount,int ElemSize)
{
	//memcpy(&((*lpMenuItems)[pos]),&((*lpMenuItems)[pos+1]),sizeof(CListIntMenuItem)*(*MenuItemCount-pos-1));
	void *p1,*p2;
	p1=(void *)( (int)(*lpList)+pos*ElemSize);
	p2=(void *)( (int)(*lpList)+(pos+1)*ElemSize);
	memcpy(p1,p2,ElemSize*(*ListElemCount-pos-1));
	(*ListElemCount)--;
	(*lpList)=mir_realloc((*lpList),ElemSize*(*ListElemCount));
	return 0;
}
int AddModernMaskToList(ModernMask * mm,  ModernMaskList * mmTemplateList)
{
    if (!mmTemplateList || !mm) return -1;
    //if (!mmTemplateList->MaskList) mmTemplateList->MaskList=mir_alloc(1);
    mmTemplateList->MaskList=mir_realloc(mmTemplateList->MaskList,sizeof(ModernMask)*(mmTemplateList->AllocatedMask+1));
    //if (mm->MaskID==0)
	//	mm->MaskID=mmTemplateList->AllocatedMask;   
    memcpy(&(mmTemplateList->MaskList[mmTemplateList->AllocatedMask]),mm,sizeof(ModernMask));
    mmTemplateList->AllocatedMask++;
    return mmTemplateList->AllocatedMask-1;
}
Beispiel #21
0
int CJabberProto::ListAddResource( JABBER_LIST list, const TCHAR* jid, int status, const TCHAR* statusMessage, char priority, const TCHAR* nick )
{
	EnterCriticalSection( &m_csLists );
	int i = ListExist( list, jid );
	if ( !i ) {
		LeaveCriticalSection( &m_csLists );
		return 0;
	}

	JABBER_LIST_ITEM* LI = m_lstRoster[i-1];
	int bIsNewResource = false, j;

	const TCHAR* p = _tcschr( jid, '@' );
	const TCHAR* q = _tcschr(( p == NULL ) ? jid : p, '/' );
	if ( q ) {
		const TCHAR* resource = q+1;
		if ( resource[0] ) {
			JABBER_RESOURCE_STATUS* r = LI->resource;
			for ( j=0; j < LI->resourceCount; j++, r++ ) {
				if ( !_tcscmp( r->resourceName, resource )) {
					// Already exist, update status and statusMessage
					r->status = status;
					replaceStr( r->statusMessage, statusMessage );
					r->priority = priority;
					break;
			}	}

			if ( j >= LI->resourceCount ) {
				// Not already exist, add new resource
				LI->resource = ( JABBER_RESOURCE_STATUS * ) mir_realloc( LI->resource, ( LI->resourceCount+1 )*sizeof( JABBER_RESOURCE_STATUS ));
				bIsNewResource = true;
				r = LI->resource + LI->resourceCount++;
				memset( r, 0, sizeof( JABBER_RESOURCE_STATUS ));
				r->status = status;
				r->affiliation = AFFILIATION_NONE;
				r->role = ROLE_NONE;
				r->resourceName = mir_tstrdup( resource );
				r->nick = mir_tstrdup( nick );
				if ( statusMessage )
					r->statusMessage = mir_tstrdup( statusMessage );
				r->priority = priority;
		}	}
	}
	// No resource, update the main statusMessage
	else {
		LI->itemResource.status = status;
		replaceStr( LI->itemResource.statusMessage, statusMessage );
	}

	LeaveCriticalSection( &m_csLists );

	MenuUpdateSrmmIcon(LI);
	return bIsNewResource;
}
Beispiel #22
0
static void AppendToByteBuffer(struct ResizableByteBuffer *buffer,const void *append,DWORD cbAppendSize)
{
	if (buffer->cbAlloced<=buffer->cbLength+cbAppendSize) {
		BYTE* buf=(BYTE*)mir_realloc(buffer->buf,buffer->cbAlloced+ALLOC_STEP+cbAppendSize);
		if (buf == NULL) return;
		buffer->buf=buf;
		buffer->cbAlloced+=ALLOC_STEP+cbAppendSize;
		OutputDebugStringA("reallocating memory...\n"); /* all ascii */
	}
	memcpy(&buffer->buf[buffer->cbLength],append,cbAppendSize);
	buffer->cbLength+=cbAppendSize;
}
Beispiel #23
0
static int SettingsEnumProc(const char* szSetting, LPARAM lParam)
{
	if (szSetting)
	{
		enumDBSettingsParam* p = (enumDBSettingsParam*)lParam;

		p->count++;
		p->pszSettingName = (char**)mir_realloc(p->pszSettingName, p->count * sizeof(char*));
		p->pszSettingName[p->count - 1] = mir_strdup(szSetting);
	}
	return 0;
}
Beispiel #24
0
/**
 * name:	CLineBuffer::_resizeBuf
 * desc:	ensure, the right size for the buffer
 * param:	cbReq	-	number of bytes required for the next operation
 *
 * return:	TRUE if reallocation successful or memoryblock is large enough, FALSE otherwise
 **/
BYTE CLineBuffer::_resizeBuf(const size_t cbReq)
{
	if (cbReq > _cbVal - _cbUsed) {
		if (!(_pVal = (PBYTE)mir_realloc(_pVal, BLOCKSIZE + _cbVal + 1))) {
			_cbVal = 0;
			_cbUsed = 0;
			return FALSE;
		}
		_cbVal += BLOCKSIZE;
	}
	return TRUE;
}
Beispiel #25
0
void CContactCache::saveHistory(WPARAM wParam, LPARAM)
{
	size_t 	iLength = 0, iStreamLength = 0;
	int 	oldTop = 0;
	char*	szFromStream = NULL;

	if (m_hwnd == 0 || m_dat == 0)
		return;

	if (wParam) {
		oldTop = m_iHistoryTop;
		m_iHistoryTop = (int)wParam;
	}

	szFromStream = ::Message_GetFromStream(GetDlgItem(m_hwnd, IDC_MESSAGE), SF_RTFNOOBJS | SFF_PLAINRTF | SF_NCRFORNONASCII);
	if (szFromStream != NULL) {
		iLength = iStreamLength = (mir_strlen(szFromStream) + 1);

		if (iLength > 0 && m_history != NULL) { // XXX: iLength > 1 ?
			if ((m_iHistoryTop == m_iHistorySize) && oldTop == 0) {         // shift the stack down...
				TInputHistory ihTemp = m_history[0];
				m_iHistoryTop--;
				::memmove((void*)&m_history[0], (void*)&m_history[1], (m_iHistorySize - 1) * sizeof(TInputHistory));
				m_history[m_iHistoryTop] = ihTemp;
			}
			if (iLength > m_history[m_iHistoryTop].lLen) {
				if (m_history[m_iHistoryTop].szText == NULL) {
					if (iLength < HISTORY_INITIAL_ALLOCSIZE)
						iLength = HISTORY_INITIAL_ALLOCSIZE;
					m_history[m_iHistoryTop].szText = (TCHAR*)mir_alloc(iLength);
					m_history[m_iHistoryTop].lLen = iLength;
				}
				else {
					if (iLength > m_history[m_iHistoryTop].lLen) {
						m_history[m_iHistoryTop].szText = (TCHAR*)mir_realloc(m_history[m_iHistoryTop].szText, iLength);
						m_history[m_iHistoryTop].lLen = iLength;
					}
				}
			}
			::memcpy(m_history[m_iHistoryTop].szText, szFromStream, iStreamLength);
			if (!oldTop) {
				if (m_iHistoryTop < m_iHistorySize) {
					m_iHistoryTop++;
					m_iHistoryCurrent = m_iHistoryTop;
				}
			}
		}
		mir_free(szFromStream);
	}
	if (oldTop)
		m_iHistoryTop = oldTop;
}
Beispiel #26
0
static void HTTPFormAppendData(NETLIBHTTPREQUEST* nlhr, size_t* dataMax, char** dataPos, const char* data, size_t len)
{
	nlhr->dataLength = (*dataPos - nlhr->pData);
	if (nlhr->dataLength + len >= *dataMax) {
		*dataPos = nlhr->pData;
		*dataMax += 0x1000 + 0x1000 * (len >> 12);
		nlhr->pData = (char*)mir_realloc(nlhr->pData, *dataMax);
		if (!nlhr->pData) mir_free(*dataPos);
		*dataPos = nlhr->pData;
		if (!*dataPos)
			return;
		*dataPos += nlhr->dataLength;
	}
Beispiel #27
0
char* Log_CreateRtfHeader(MODULEINFO *mi)
{
	int i;

	// guesstimate amount of memory for the RTF header
	size_t bufferEnd = 0, bufferAlloced = 4096;
	char *buffer = (char *)mir_realloc(mi->pszHeader, bufferAlloced);
	buffer[0] = '\0';

	// get the number of pixels per logical inch
	HDC hdc = GetDC(NULL);
	ci.logPixelSY = GetDeviceCaps(hdc, LOGPIXELSY);
	ci.logPixelSX = GetDeviceCaps(hdc, LOGPIXELSX);
	ReleaseDC(NULL, hdc);

	// ### RTF HEADER

	// font table
	Log_Append(buffer, bufferEnd, bufferAlloced, "{\\rtf1\\ansi\\deff0{\\fonttbl");
	for (i = 0; i < OPTIONS_FONTCOUNT; i++)
		Log_Append(buffer, bufferEnd, bufferAlloced, "{\\f%u\\fnil\\fcharset%u%S;}", i, ci.aFonts[i].lf.lfCharSet, ci.aFonts[i].lf.lfFaceName);

	// colour table
	Log_Append(buffer, bufferEnd, bufferAlloced, "}{\\colortbl ;");

	for (i = 0; i < OPTIONS_FONTCOUNT; i++)
		Log_Append(buffer, bufferEnd, bufferAlloced, "\\red%u\\green%u\\blue%u;", GetRValue(ci.aFonts[i].color), GetGValue(ci.aFonts[i].color), GetBValue(ci.aFonts[i].color));

	for (i = 0; i < mi->nColorCount; i++)
		Log_Append(buffer, bufferEnd, bufferAlloced, "\\red%u\\green%u\\blue%u;", GetRValue(mi->crColors[i]), GetGValue(mi->crColors[i]), GetBValue(mi->crColors[i]));

	// new paragraph
	Log_Append(buffer, bufferEnd, bufferAlloced, "}\\pard");

	// set tabs and indents
	int iIndent = 0;

	if (g_Settings->dwIconFlags) {
		iIndent += (14 * 1440) / ci.logPixelSX;
		Log_Append(buffer, bufferEnd, bufferAlloced, "\\tx%u", iIndent);
	}
	if (g_Settings->bShowTime) {
		int iSize = (g_Settings->LogTextIndent * 1440) / ci.logPixelSX;
		Log_Append(buffer, bufferEnd, bufferAlloced, "\\tx%u", iIndent + iSize);
		if (g_Settings->bLogIndentEnabled)
			iIndent += iSize;
	}

	Log_Append(buffer, bufferEnd, bufferAlloced, "\\fi-%u\\li%u", iIndent, iIndent);
	return buffer;
}
Beispiel #28
0
static TCHAR* ListView_GetItemTextEx(HWND hLV, int iItem, int iSubItem)
{
	LVITEM lvi = {0};
	lvi.mask = LVIF_TEXT;
	lvi.iSubItem = iSubItem;
	lvi.cchTextMax = 64;
	lvi.pszText = (TCHAR*)mir_alloc(lvi.cchTextMax * sizeof(TCHAR));
	// loop until the returned size is smaller than buffer size
	while (SendMessage(hLV, LVM_GETITEMTEXT, iItem, (LPARAM)&lvi) == lvi.cchTextMax - 1) { 
		lvi.cchTextMax += 64;
		lvi.pszText = (TCHAR*)mir_realloc(lvi.pszText, lvi.cchTextMax * sizeof(TCHAR));
	}
	return lvi.pszText;
}
Beispiel #29
0
static TCHAR *parseAddAlias(ARGUMENTSINFO *ai)
{
	int res;
	char *szHelp, *szArgsA;

	if (ai->argc != 3)
		return NULL;

	TCHAR *cur = ai->targv[1];
	while (isValidTokenChar(*cur))
		cur++;

	ptrT alias(mir_tstrndup(ai->targv[1], cur - ai->targv[1]));

	int argc;
	TCHAR **argv;
	getArguments(cur, &argv, &argc);
	deRegisterToken(alias);
	addToAliasRegister(alias, argc, argv, ai->targv[2]);
	TCHAR *szArgs = NULL;
	for (int i = 0; i < argc; i++) {
		if (i == 0)
			szArgs = (TCHAR*)mir_calloc((_tcslen(argv[i]) + 2)*sizeof(TCHAR));
		else
			szArgs = (TCHAR*)mir_realloc(szArgs, (_tcslen(szArgs) + _tcslen(argv[i]) + 2)*sizeof(TCHAR));

		_tcscat(szArgs, argv[i]);
		if (i != argc - 1)
			_tcscat(szArgs, _T(","));
	}
	if (szArgs != NULL && argc > 0) {
		szArgsA = mir_t2a(szArgs);

		size_t size = 32 + strlen(szArgsA);
		szHelp = (char *)mir_alloc(size);
		memset(szHelp, '\0', 32 + strlen(szArgsA));
		mir_snprintf(szHelp, size, LPGEN("Alias")"\t(%s)\t"LPGEN("user defined"), szArgsA);
		res = registerIntToken(alias, parseTranslateAlias, TRF_FUNCTION | TRF_UNPARSEDARGS, szHelp);
		mir_free(szArgsA);
	}
	else {
		szHelp = (char*)mir_alloc(32);
		memset(szHelp, '\0', 32);
		mir_snprintf(szHelp, 32, LPGEN("Alias")"\t\t"LPGEN("user defined"));
		res = registerIntToken(alias, parseTranslateAlias, TRF_FIELD | TRF_UNPARSEDARGS, szHelp);
	}
	mir_free(szArgs);
	mir_free(szHelp);
	return (res == 0) ? mir_tstrdup(_T("")) : NULL;
}
Beispiel #30
0
void TlenXmlAddAttr(XmlNode *n, char *name, char *value)
{
	int i;

	if (n == NULL || name == NULL || value == NULL)
		return;

	i = n->numAttr;
	(n->numAttr)++;
	n->attr = (XmlAttr **) mir_realloc(n->attr, sizeof(XmlAttr *) * n->numAttr);
	n->attr[i] = (XmlAttr *) mir_alloc(sizeof(XmlAttr));
	n->attr[i]->name = mir_strdup(name);
	n->attr[i]->value = mir_strdup(value);
}