Exemple #1
0
int set_avatar(uint32_t friend_number, const uint8_t *data, uint32_t size) {
    if (size > UTOX_AVATAR_MAX_DATA_LENGTH) {
        debug_error("Avatars:\t avatar too large\n");
        return 0;
    }

    uint16_t w, h;
    UTOX_NATIVE_IMAGE *image = decode_image_rgb((UTOX_IMAGE)data, size, &w, &h, 1);
    if(!UTOX_NATIVE_IMAGE_IS_VALID(image)) {
        debug("Avatars:\t avatar is invalid\n");
        return 0;
    } else {
        if (friend_number == -1) {
            avatar_free_image(&self.avatar);
            self.avatar.image  = image;
            self.avatar.width  = w;
            self.avatar.height = h;
            self.avatar.format = UTOX_AVATAR_FORMAT_PNG;
            tox_hash(self.avatar.hash, data, size);
        } else {
            FRIEND *f = &friend[friend_number];
            avatar_free_image(&f->avatar);

            f->avatar.image  = image;
            f->avatar.width  = w;
            f->avatar.height = h;
            f->avatar.format = UTOX_AVATAR_FORMAT_PNG;
            tox_hash(f->avatar.hash, data, size);
        }

        return 1;
    }
}
Exemple #2
0
int set_avatar(AVATAR *avatar, const uint8_t *data, uint32_t size)
{
    if (size > UTOX_AVATAR_MAX_DATA_LENGTH) {
        debug("Avatars:\t avatar too large\n");
        return 0;
    }

    uint16_t w, h;
    UTOX_NATIVE_IMAGE *image = png_to_image((UTOX_PNG_IMAGE)data, size, &w, &h, 1);
    if(!UTOX_NATIVE_IMAGE_IS_VALID(image)) {
        debug("Avatars:\t avatar is invalid\n");
        return 0;
    } else {

        avatar_free_image(avatar);

        avatar->image = image;
        avatar->width = w;
        avatar->height = h;
        avatar->format = UTOX_AVATAR_FORMAT_PNG;
        tox_hash(avatar->hash, data, size);

        return 1;
    }
}
Exemple #3
0
/**
 * @brief Get the tox hash of a cached avatar.
 * @param ownerId Friend ID to get hash.
 * @return Avatar tox hash.
 */
QByteArray Profile::getAvatarHash(const QString& ownerId)
{
    QByteArray pic = loadAvatarData(ownerId);
    QByteArray avatarHash(TOX_HASH_LENGTH, 0);
    tox_hash((uint8_t*)avatarHash.data(), (uint8_t*)pic.data(), pic.size());
    return avatarHash;
}
Exemple #4
0
/*
 * Class:     im_tox_tox4j_impl_jni_ToxCryptoImpl__
 * Method:    hash
 * Signature: ([B)[B
 */
JNIEXPORT jbyteArray JNICALL Java_im_tox_tox4j_impl_jni_ToxCryptoImpl_00024_hash
  (JNIEnv *env, jobject, jbyteArray dataArray)
{
  ByteArray data (env, dataArray);
  std::vector<uint8_t> hash (TOX_HASH_LENGTH);
  bool result = tox_hash (hash.data (), data.data (), data.size ());
  tox4j_assert (result);
  return toJavaArray (env, hash);
}
Exemple #5
0
void CToxProto::SetToxAvatar(std::tstring path)
{
	FILE *hFile = _tfopen(path.c_str(), L"rb");
	if (!hFile)
	{
		debugLogA(__FUNCTION__": failed to open avatar file");
		return;
	}

	fseek(hFile, 0, SEEK_END);
	size_t length = ftell(hFile);
	rewind(hFile);
	if (length > TOX_MAX_AVATAR_SIZE)
	{
		fclose(hFile);
		debugLogA(__FUNCTION__": new avatar size is excessive");
		return;
	}

	uint8_t *data = (uint8_t*)mir_alloc(length);
	if (fread(data, sizeof(uint8_t), length, hFile) != length)
	{
		fclose(hFile);
		debugLogA(__FUNCTION__": failed to read avatar file");
		mir_free(data);
		return;
	}
	fclose(hFile);

	DBVARIANT dbv;
	uint8_t hash[TOX_HASH_LENGTH];
	tox_hash(hash, data, TOX_HASH_LENGTH);
	if (!db_get(NULL, m_szModuleName, TOX_SETTINGS_AVATAR_HASH, &dbv))
	{
		if (memcmp(hash, dbv.pbVal, TOX_HASH_LENGTH) == 0)
		{
			db_free(&dbv);
			mir_free(data);
			debugLogA(__FUNCTION__": new avatar is same with old");
			return;
		}
		db_free(&dbv);
	}

	db_set_blob(NULL, m_szModuleName, TOX_SETTINGS_AVATAR_HASH, (void*)hash, TOX_HASH_LENGTH);

	if (IsOnline())
	{
		for (MCONTACT hContact = db_find_first(m_szModuleName); hContact; hContact = db_find_next(hContact, m_szModuleName))
		{
			if (GetContactStatus(hContact) == ID_STATUS_OFFLINE)
				continue;

			int32_t friendNumber = GetToxFriendNumber(hContact);
			if (friendNumber == UINT32_MAX)
			{
				mir_free(data);
				debugLogA(__FUNCTION__": failed to set new avatar");
				return;
			}

			TOX_ERR_FILE_SEND error;
			uint32_t fileNumber = tox_file_send(tox, friendNumber, TOX_FILE_KIND_AVATAR, length, hash, NULL, 0, &error);
			if (error != TOX_ERR_FILE_SEND_OK)
			{
				mir_free(data);
				debugLogA(__FUNCTION__": failed to set new avatar");
				return;
			}

			AvatarTransferParam *transfer = new AvatarTransferParam(friendNumber, fileNumber, NULL, length);
			transfer->pfts.flags |= PFTS_SENDING;
			memcpy(transfer->hash, hash, TOX_HASH_LENGTH);
			transfer->pfts.hContact = hContact;
			transfer->hFile = _tfopen(path.c_str(), L"rb");
			transfers.Add(transfer);
		}
	}

	mir_free(data);
}
Exemple #6
0
bool CToxProto::SetToxAvatar(std::tstring path, bool checkHash)
{
	int length;
	uint8_t *data;
	FILE *hFile = _tfopen(path.c_str(), L"rb");
	if (!hFile)
	{
		debugLogA("CToxProto::SetMyAvatar: failed to open avatar file");
		return false;
	}

	fseek(hFile, 0, SEEK_END);
	length = ftell(hFile);
	rewind(hFile);
	if (length > TOX_AVATAR_MAX_DATA_LENGTH)
	{
		fclose(hFile);
		debugLogA("CToxProto::SetMyAvatar: new avatar size is excessive");
		return false;
	}

	data = (uint8_t*)mir_alloc(length);
	size_t readed = fread(data, sizeof(uint8_t), length, hFile);
	if (readed != length)
	{
		fclose(hFile);
		debugLogA("CToxProto::SetMyAvatar: failed to read avatar file");
		return false;
	}
	fclose(hFile);

	DBVARIANT dbv;
	uint8_t hash[TOX_HASH_LENGTH];
	tox_hash(hash, data, TOX_HASH_LENGTH);
	if (checkHash && !db_get(NULL, m_szModuleName, TOX_SETTINGS_AVATAR_HASH, &dbv))
	{
		if (memcmp(hash, dbv.pbVal, TOX_HASH_LENGTH) == 0)
		{
			db_free(&dbv);
			mir_free(data);
			debugLogA("CToxProto::SetMyAvatar: new avatar is same with old");
			return false;
		}
		db_free(&dbv);
	}

	if (tox_set_avatar(tox, TOX_AVATAR_FORMAT_PNG, data, length) == TOX_ERROR)
	{
		mir_free(data);
		debugLogA("CToxProto::SetMyAvatar: failed to set new avatar");
		return false;
	}
	mir_free(data);

	if (checkHash)
	{
		db_set_blob(NULL, m_szModuleName, TOX_SETTINGS_AVATAR_HASH, (void*)hash, TOX_HASH_LENGTH);
	}

	return true;
}