mirror of
https://gitlab.linphone.org/BC/public/linphone-iphone.git
synced 2026-01-18 03:28:07 +00:00
278 lines
11 KiB
C++
278 lines
11 KiB
C++
/*
|
|
* c-content.cpp
|
|
* Copyright (C) 2010-2018 Belledonne Communications SARL
|
|
*
|
|
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "linphone/api/c-content.h"
|
|
#include "linphone/wrapper_utils.h"
|
|
|
|
#include "c-wrapper/c-wrapper.h"
|
|
|
|
#include "content/content.h"
|
|
#include "content/content-type.h"
|
|
#include "content/file-content.h"
|
|
#include "content/file-transfer-content.h"
|
|
|
|
// =============================================================================
|
|
|
|
using namespace std;
|
|
|
|
L_DECLARE_C_CLONABLE_OBJECT_IMPL(Content,
|
|
void *cryptoContext; /**< crypto context used to encrypt file for RCS file transfer */
|
|
mutable char *name;
|
|
mutable char *type;
|
|
mutable char *subtype;
|
|
mutable char *body;
|
|
mutable size_t size;
|
|
mutable char *encoding;
|
|
mutable char *key;
|
|
)
|
|
|
|
// =============================================================================
|
|
// Reference and user data handling functions.
|
|
// =============================================================================
|
|
|
|
LinphoneContent * linphone_content_ref(LinphoneContent *content) {
|
|
belle_sip_object_ref(content);
|
|
return content;
|
|
}
|
|
|
|
void linphone_content_unref(LinphoneContent *content) {
|
|
belle_sip_object_unref(content);
|
|
}
|
|
|
|
void *linphone_content_get_user_data(const LinphoneContent *content) {
|
|
return L_GET_USER_DATA_FROM_C_OBJECT(content);
|
|
}
|
|
|
|
void linphone_content_set_user_data(LinphoneContent *content, void *ud) {
|
|
return L_SET_USER_DATA_FROM_C_OBJECT(content, ud);
|
|
}
|
|
|
|
// =============================================================================
|
|
|
|
const char * linphone_content_get_type(const LinphoneContent *content) {
|
|
if (content->type) ms_free(content->type);
|
|
content->type = ms_strdup(L_STRING_TO_C(L_GET_CPP_PTR_FROM_C_OBJECT(content)->getContentType().getType()));
|
|
return content->type;
|
|
}
|
|
|
|
void linphone_content_set_type(LinphoneContent *content, const char *type) {
|
|
LinphonePrivate::ContentType ct = L_GET_CPP_PTR_FROM_C_OBJECT(content)->getContentType();
|
|
ct.setType(L_C_TO_STRING(type));
|
|
L_GET_CPP_PTR_FROM_C_OBJECT(content)->setContentType(ct);
|
|
}
|
|
|
|
const char * linphone_content_get_subtype(const LinphoneContent *content) {
|
|
if (content->subtype) ms_free(content->subtype);
|
|
content->subtype = ms_strdup(L_STRING_TO_C(L_GET_CPP_PTR_FROM_C_OBJECT(content)->getContentType().getSubType()));
|
|
return content->subtype;
|
|
}
|
|
|
|
void linphone_content_set_subtype(LinphoneContent *content, const char *subtype) {
|
|
LinphonePrivate::ContentType ct = L_GET_CPP_PTR_FROM_C_OBJECT(content)->getContentType();
|
|
ct.setSubType(L_C_TO_STRING(subtype));
|
|
L_GET_CPP_PTR_FROM_C_OBJECT(content)->setContentType(ct);
|
|
}
|
|
|
|
uint8_t * linphone_content_get_buffer(const LinphoneContent *content) {
|
|
return (uint8_t *)L_STRING_TO_C(L_GET_CPP_PTR_FROM_C_OBJECT(content)->getBodyAsString());
|
|
}
|
|
|
|
void linphone_content_set_buffer(LinphoneContent *content, const uint8_t *buffer, size_t size) {
|
|
L_GET_CPP_PTR_FROM_C_OBJECT(content)->setBody(buffer, size);
|
|
}
|
|
|
|
const char * linphone_content_get_string_buffer(const LinphoneContent *content) {
|
|
if (content->body) ms_free(content->body);
|
|
content->body = ms_strdup(L_STRING_TO_C(L_GET_CPP_PTR_FROM_C_OBJECT(content)->getBodyAsString()));
|
|
return content->body;
|
|
}
|
|
|
|
void linphone_content_set_string_buffer(LinphoneContent *content, const char *buffer) {
|
|
L_GET_CPP_PTR_FROM_C_OBJECT(content)->setBody(L_C_TO_STRING(buffer));
|
|
}
|
|
|
|
size_t linphone_content_get_size(const LinphoneContent *content) {
|
|
size_t size = L_GET_CPP_PTR_FROM_C_OBJECT(content)->getSize();
|
|
if (size == 0) {
|
|
size = content->size;
|
|
}
|
|
return size;
|
|
}
|
|
|
|
void linphone_content_set_size(LinphoneContent *content, size_t size) {
|
|
content->size = size;
|
|
}
|
|
|
|
const char * linphone_content_get_encoding(const LinphoneContent *content) {
|
|
return content->encoding;
|
|
}
|
|
|
|
void linphone_content_set_encoding(LinphoneContent *content, const char *encoding) {
|
|
if (content->encoding) ms_free(content->encoding);
|
|
content->encoding = ms_strdup(encoding);
|
|
}
|
|
|
|
const char * linphone_content_get_name(const LinphoneContent *content) {
|
|
const LinphonePrivate::Content *c = L_GET_CPP_PTR_FROM_C_OBJECT(content);
|
|
if (c->isFile()) {
|
|
const LinphonePrivate::FileContent *fc = static_cast<const LinphonePrivate::FileContent *>(c);
|
|
if (content->name) ms_free(content->name);
|
|
content->name = ms_strdup(L_STRING_TO_C(fc->getFileName()));
|
|
} else if (c->isFileTransfer()) {
|
|
const LinphonePrivate::FileTransferContent *ftc = static_cast<const LinphonePrivate::FileTransferContent *>(c);
|
|
if (content->name) ms_free(content->name);
|
|
content->name = ms_strdup(L_STRING_TO_C(ftc->getFileName()));
|
|
}
|
|
return content->name;
|
|
}
|
|
|
|
void linphone_content_set_name(LinphoneContent *content, const char *name) {
|
|
if (content->name) ms_free(content->name);
|
|
|
|
LinphonePrivate::Content *c = L_GET_CPP_PTR_FROM_C_OBJECT(content);
|
|
if (c->isFile()) {
|
|
LinphonePrivate::FileContent *fc = static_cast<LinphonePrivate::FileContent *>(c);
|
|
fc->setFileName(L_C_TO_STRING(name));
|
|
} else if (c->isFileTransfer()) {
|
|
LinphonePrivate::FileTransferContent *ftc = static_cast<LinphonePrivate::FileTransferContent *>(c);
|
|
ftc->setFileName(L_C_TO_STRING(name));
|
|
}
|
|
|
|
content->name = ms_strdup(name);
|
|
}
|
|
|
|
bool_t linphone_content_is_multipart(const LinphoneContent *content) {
|
|
SalBodyHandler *body_handler = sal_body_handler_from_content(content);
|
|
bool_t multipart = sal_body_handler_is_multipart(body_handler);
|
|
sal_body_handler_unref(body_handler);
|
|
return multipart;
|
|
}
|
|
|
|
LinphoneContent * linphone_content_get_part(const LinphoneContent *content, int idx) {
|
|
SalBodyHandler *part_body_handler;
|
|
SalBodyHandler *body_handler = sal_body_handler_from_content(content);
|
|
if (!sal_body_handler_is_multipart(body_handler)) {
|
|
sal_body_handler_unref(body_handler);
|
|
return NULL;
|
|
}
|
|
part_body_handler = sal_body_handler_get_part(body_handler, idx);
|
|
sal_body_handler_unref(body_handler);
|
|
return linphone_content_from_sal_body_handler(part_body_handler);
|
|
}
|
|
|
|
LinphoneContent * linphone_content_find_part_by_header(const LinphoneContent *content, const char *header_name, const char *header_value) {
|
|
SalBodyHandler *part_body_handler;
|
|
SalBodyHandler *body_handler = sal_body_handler_from_content(content);
|
|
if (!sal_body_handler_is_multipart(body_handler)) {
|
|
sal_body_handler_unref(body_handler);
|
|
return NULL;
|
|
}
|
|
part_body_handler = sal_body_handler_find_part_by_header(body_handler, header_name, header_value);
|
|
sal_body_handler_unref(body_handler);
|
|
return linphone_content_from_sal_body_handler(part_body_handler);
|
|
}
|
|
|
|
const char * linphone_content_get_custom_header(const LinphoneContent *content, const char *header_name) {
|
|
SalBodyHandler *body_handler = sal_body_handler_from_content(content);
|
|
const char *header = sal_body_handler_get_header(body_handler, header_name);
|
|
sal_body_handler_unref(body_handler);
|
|
return header;
|
|
}
|
|
|
|
const char *linphone_content_get_key(const LinphoneContent *content) {
|
|
if (content->key) ms_free(content->key);
|
|
|
|
const LinphonePrivate::Content *c = L_GET_CPP_PTR_FROM_C_OBJECT(content);
|
|
if (c->isFileTransfer()) {
|
|
const LinphonePrivate::FileTransferContent *ftc = static_cast<const LinphonePrivate::FileTransferContent *>(c);
|
|
content->key = ms_strdup(ftc->getFileKeyAsString());
|
|
}
|
|
|
|
return content->key;
|
|
}
|
|
|
|
size_t linphone_content_get_key_size(const LinphoneContent *content) {
|
|
const LinphonePrivate::Content *c = L_GET_CPP_PTR_FROM_C_OBJECT(content);
|
|
if (c->isFileTransfer()) {
|
|
const LinphonePrivate::FileTransferContent *ftc = static_cast<const LinphonePrivate::FileTransferContent *>(c);
|
|
return ftc->getFileKeySize();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void linphone_content_set_key(LinphoneContent *content, const char *key, const size_t keyLength) {
|
|
LinphonePrivate::Content *c = L_GET_CPP_PTR_FROM_C_OBJECT(content);
|
|
if (c->isFileTransfer()) {
|
|
LinphonePrivate::FileTransferContent *ftc = static_cast<LinphonePrivate::FileTransferContent *>(c);
|
|
ftc->setFileKey(key, keyLength);
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Private functions.
|
|
// =============================================================================
|
|
|
|
static LinphoneContent * linphone_content_new_with_body_handler(SalBodyHandler *body_handler) {
|
|
LinphoneContent *content = L_INIT(Content);
|
|
content->cryptoContext = NULL;
|
|
LinphonePrivate::Content *c = new LinphonePrivate::Content();
|
|
L_SET_CPP_PTR_FROM_C_OBJECT(content, c);
|
|
if (body_handler != NULL) {
|
|
linphone_content_set_type(content, sal_body_handler_get_type(body_handler));
|
|
linphone_content_set_subtype(content, sal_body_handler_get_subtype(body_handler));
|
|
linphone_content_set_string_buffer(content, (char *)sal_body_handler_get_data(body_handler));
|
|
linphone_content_set_encoding(content, sal_body_handler_get_encoding(body_handler));
|
|
}
|
|
return content;
|
|
}
|
|
|
|
LinphoneContent * linphone_content_new(void) {
|
|
return linphone_content_new_with_body_handler(NULL);
|
|
}
|
|
|
|
LinphoneContent * linphone_content_copy(const LinphoneContent *ref) {
|
|
return (LinphoneContent *)belle_sip_object_ref(belle_sip_object_clone(BELLE_SIP_OBJECT(ref)));
|
|
}
|
|
|
|
LinphoneContent * linphone_core_create_content(LinphoneCore *lc) {
|
|
return linphone_content_new();
|
|
}
|
|
|
|
/* crypto context is managed(allocated/freed) by the encryption function, so provide the address of field in the private structure */
|
|
void ** linphone_content_get_cryptoContext_address(LinphoneContent *content) {
|
|
return &(content->cryptoContext);
|
|
}
|
|
|
|
LinphoneContent * linphone_content_from_sal_body_handler(SalBodyHandler *body_handler) {
|
|
if (body_handler) {
|
|
return linphone_content_new_with_body_handler(body_handler);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
SalBodyHandler * sal_body_handler_from_content(const LinphoneContent *content) {
|
|
if (content == NULL) return NULL;
|
|
SalBodyHandler *body_handler = sal_body_handler_new();
|
|
sal_body_handler_set_type(body_handler, belle_sip_strdup(linphone_content_get_type(content)));
|
|
sal_body_handler_set_subtype(body_handler, belle_sip_strdup(linphone_content_get_subtype(content)));
|
|
sal_body_handler_set_size(body_handler, linphone_content_get_size(content));
|
|
sal_body_handler_set_data(body_handler, belle_sip_strdup(linphone_content_get_string_buffer(content)));
|
|
sal_body_handler_set_encoding(body_handler, belle_sip_strdup(linphone_content_get_encoding(content)));
|
|
return body_handler;
|
|
}
|