path: root/tinyMSRP/src/tmsrp_message.c

/*
* Copyright (C) 2009 Mamadou Diop.
*
* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
*
* This file is part of Open Source Doubango Framework.
*
* DOUBANGO 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 3 of the License, or
* (at your option) any later version.
*
* DOUBANGO 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 DOUBANGO.
*
*/

/**@file tmsrp_message.c
 * @brief MSRP message.
 *
 * @author Mamadou Diop <diopmamadou(at)doubango.org>
 *

 */

#include "tinymsrp/tmsrp_message.h"

#include "tsk_string.h"
#include "tsk_memory.h"
#include "tsk_debug.h"

/*== Predicate function to find tmsrp_header_t object by type. */
static int pred_find_header_by_type(const tsk_list_item_t *item, const void *tmsrp_htype)
{
    if(item && item->data) {
        tmsrp_header_t *header = item->data;
        tmsrp_header_type_t htype = *((tmsrp_header_type_t*)tmsrp_htype);
        return (header->type - htype);
    }
    return -1;
}

/*== Predicate function to find tmsrp_header_t object by name. */
static int pred_find_header_by_name(const tsk_list_item_t *item, const void *name)
{
    if(item && item->data && name) {
        tmsrp_header_t *header = item->data;
        return tsk_stricmp(tmsrp_header_get_nameex(header), (const char*)name);
    }
    return -1;
}


tmsrp_message_t* tmsrp_message_create(tmsrp_message_type_t type, const char* tid, const char* method, short status, const char* comment)
{
    tmsrp_message_t* message;
    if((message = tsk_object_new(tmsrp_message_def_t))) {
        message->type = type;
        message->tid = tsk_strdup(tid);
        if(message->type == tmsrp_response) {
            message->line.response.status = status;
            message->line.response.comment = tsk_strdup(comment);
        }
        else {
            message->line.request.method = tsk_strdup(method);
            message->line.request.type = tmsrp_request_get_type(method);
        }

        message->headers = tsk_list_create();

        message->end_line.tid = tsk_strdup(message->tid);
        message->end_line.cflag = '$';
    }
    return message;
}

tmsrp_message_t* tmsrp_request_create(const char* tid, const char* method)
{
    return tmsrp_message_create(tmsrp_request, tid, method, 0, tsk_null);
}

tmsrp_message_t* tmsrp_response_create(const char* tid, short status, const char* comment)
{
    return tmsrp_message_create(tmsrp_response, tid, tsk_null, status, comment);
}

tmsrp_message_t* tmsrp_message_create_null()
{
    return tmsrp_message_create(tmsrp_unknown, tsk_null, tsk_null, 0, tsk_null);
}


int tmsrp_message_add_header(tmsrp_message_t *self, const tmsrp_header_t *hdr)
{
#define ADD_HEADER(type, field) \
		case tmsrp_htype_##type: \
			{ \
				if(!self->field) \
				{ \
					self->field = (tmsrp_header_##type##_t*)header; \
					return 0; \
				} \
				break; \
			}

    if(self && hdr) {
        tmsrp_header_t *header = tsk_object_ref((void*)hdr);

        switch(header->type) {
            ADD_HEADER(To_Path, To);
            ADD_HEADER(From_Path, From);
            ADD_HEADER(Message_ID, MessageID);
            ADD_HEADER(Byte_Range, ByteRange);
            ADD_HEADER(Failure_Report, FailureReport);
            ADD_HEADER(Success_Report, SuccessReport);
            ADD_HEADER(Status, Status);
            ADD_HEADER(Content_Type, ContentType);

        default:
            break;
        }

        tsk_list_push_back_data(self->headers, (void**)&header);

        return 0;
    }
    return -1;
}

int tmsrp_message_add_headers(tmsrp_message_t *self, ...)
{
    const tsk_object_def_t* objdef;
    tmsrp_header_t *header;
    va_list ap;

    if(!self) {
        TSK_DEBUG_ERROR("Invalid parameter");
        return -1;
    }

    va_start(ap, self);
    while((objdef = va_arg(ap, const tsk_object_def_t*))) {
        if((header = tsk_object_new_2(objdef, &ap))) {
            tmsrp_message_add_header(self, header);
            TSK_OBJECT_SAFE_FREE(header);
        }
    }
    va_end(ap);

    return 0;
}

tmsrp_request_type_t tmsrp_request_get_type(const char* method)
{
    if(method) {
        if(tsk_strequals(method, "SEND")) {
            return tmsrp_SEND;
        }
        else if(tsk_strequals(method, "REPORT")) {
            return tmsrp_REPORT;
        }
        else if(tsk_strequals(method, "AUTH")) {
            return tmsrp_AUTH;
        }
    }
    return tmsrp_NONE;
}

const tmsrp_header_t *tmsrp_message_get_headerAt(const tmsrp_message_t *self, tmsrp_header_type_t type, tsk_size_t index)
{
    tsk_size_t pos = 0;
    tsk_list_item_t *item;
    const tmsrp_header_t* hdr = 0;

    if(self) {
        switch(type) {
        case tmsrp_htype_To_Path:
            if(index == 0) {
                hdr = (const tmsrp_header_t*)self->To;
                goto bail;
            }
            else {
                pos++;
            }
            break;
        case tmsrp_htype_From_Path:
            if(index == 0) {
                hdr = (const tmsrp_header_t*)self->From;
                goto bail;
            }
            else {
                pos++;
            }
            break;
        case tmsrp_htype_Message_ID:
            if(index == 0) {
                hdr = (const tmsrp_header_t*)self->MessageID;
                goto bail;
                break;
            }
            else {
                pos++;
            }
        case tmsrp_htype_Byte_Range:
            if(index == 0) {
                hdr = (const tmsrp_header_t*)self->ByteRange;
                goto bail;
            }
            else {
                pos++;
            }
            break;
        case tmsrp_htype_Failure_Report:
            if(index == 0) {
                hdr = (const tmsrp_header_t*)self->FailureReport;
                goto bail;
            }
            else {
                pos++;
            }
            break;
        case tmsrp_htype_Success_Report:
            if(index == 0) {
                hdr = (const tmsrp_header_t*)self->SuccessReport;
                goto bail;
            }
            else {
                pos++;
            }
            break;
        case tmsrp_htype_Status:
            if(index == 0) {
                hdr = (const tmsrp_header_t*)self->Status;
                goto bail;
            }
            else {
                pos++;
            }
            break;
        case tmsrp_htype_Content_Type:
            if(index == 0) {
                hdr = (const tmsrp_header_t*)self->ContentType;
                goto bail;
            }
            else {
                pos++;
            }
            break;
        default:
            break;
        }

        tsk_list_foreach(item, self->headers) {
            if(!pred_find_header_by_type(item, &type)) {
                if(pos++ >= index) {
                    hdr = item->data;
                    break;
                }
            }
        }
    }

bail:
    return hdr;
}

const tmsrp_header_t *tmsrp_message_get_header(const tmsrp_message_t *self, tmsrp_header_type_t type)
{
    return tmsrp_message_get_headerAt(self, type, 0);
}

const tmsrp_header_t *tmsrp_message_get_headerByName(const tmsrp_message_t *self, const char* name)
{
    if(self && self->headers) {
        const tsk_list_item_t* item;
        if((item = tsk_list_find_item_by_pred(self->headers, pred_find_header_by_name, name))) {
            return item->data;
        }
    }
    return tsk_null;
}

int tmsrp_message_add_content(tmsrp_message_t *self, const char* content_type, const void* content, tsk_size_t size)
{
    if(self) {
        if(content_type) {
            TSK_OBJECT_SAFE_FREE(self->ContentType);
        }
        TSK_OBJECT_SAFE_FREE(self->Content);

        if(content_type) {
            TMSRP_MESSAGE_ADD_HEADER(self, TMSRP_HEADER_CONTENT_TYPE_VA_ARGS(content_type));
        }
        self->Content = tsk_buffer_create(content, size);

        return 0;
    }
    return -1;
}

int tmsrp_message_serialize(const tmsrp_message_t *self, tsk_buffer_t *output)
{
    if(!self || !output) {
        return -1;
    }

    if(TMSRP_MESSAGE_IS_REQUEST(self)) {
        /* 	pMSRP    SP    transact-id    SP    method    CRLF */
        tsk_buffer_append_2(output, "MSRP %s %s\r\n", self->tid, self->line.request.method);
    }
    else {
        /* 	pMSRP    SP    transact-id    SP    status-code    [SP comment]   CRLF */
        tsk_buffer_append_2(output, "MSRP %s %3hi%s%s\r\n",
                            self->tid,
                            self->line.response.status,
                            self->line.response.comment ? " " : "",
                            self->line.response.comment ? self->line.response.comment  : ""
                           );
    }

    /* To-Path */
    if(self->To) {
        tmsrp_header_serialize(TMSRP_HEADER(self->To), output);
    }
    /* From-Path */
    if(self->From) {
        tmsrp_header_serialize(TMSRP_HEADER(self->From), output);
    }
    /* Message-Id */
    if(self->MessageID) {
        tmsrp_header_serialize(TMSRP_HEADER(self->MessageID), output);
    }
    /* Byte-Range */
    if(self->ByteRange) {
        tmsrp_header_serialize(TMSRP_HEADER(self->ByteRange), output);
    }
    /* Failure-Report */
    if(self->FailureReport) {
        tmsrp_header_serialize(TMSRP_HEADER(self->FailureReport), output);
    }
    /* Success-Report */
    if(self->SuccessReport) {
        tmsrp_header_serialize(TMSRP_HEADER(self->SuccessReport), output);
    }
    /* Status */
    if(self->Status) {
        tmsrp_header_serialize(TMSRP_HEADER(self->Status), output);
    }

    /* All other headers (Other-Mime-headers)
    	- Should be empty if no content is added (see below) but ...
    */
    {
        tsk_list_item_t *item;
        tsk_list_foreach(item, self->headers) {
            tmsrp_header_t *hdr = item->data;
            tmsrp_header_serialize(hdr, output);
        }
    }

    /* RFC 4975 - 7.1. Constructing Requests
    	A request with no body MUST NOT include a Content-Type or any other
    	MIME-specific header fields.  A request without a body MUST contain
    	an end-line after the final header field.  No extra CRLF will be
    	present between the header section and the end-line.
    */
    /* CONTENT */
    if(TMSRP_MESSAGE_HAS_CONTENT(self)) {
        /* Content-Type */
        if(self->ContentType) {
            tmsrp_header_serialize(TMSRP_HEADER(self->ContentType), output);
        }
        tsk_buffer_append(output, "\r\n", 2);
        tsk_buffer_append(output, TSK_BUFFER_TO_STRING(self->Content), TSK_BUFFER_SIZE(self->Content));
        tsk_buffer_append(output, "\r\n", 2);
    }

    /* END LINE */
    tsk_buffer_append_2(output, "-------%s%c\r\n", self->end_line.tid, self->end_line.cflag);

    return 0;
}


char* tmsrp_message_tostring(const tmsrp_message_t *self)
{
    tsk_buffer_t* output;
    char* ret = tsk_null;

    if((output = tsk_buffer_create_null())) {
        if(!tmsrp_message_serialize(self, output)) {
            ret = tsk_strndup(output->data, output->size);
        }
        TSK_OBJECT_SAFE_FREE(output);
    }
    return ret;
}




























//=================================================================================================
//	MSRP object definition
//
static void* tmsrp_message_ctor(tsk_object_t * self, va_list * app)
{
    tmsrp_message_t *message = self;
    if(message) {
    }
    return self;
}

static void* tmsrp_message_dtor(tsk_object_t * self)
{
    tmsrp_message_t *message = self;
    if(message) {
        TSK_FREE(message->tid);

        // request
        if(TMSRP_MESSAGE_IS_REQUEST(message)) {
            TSK_FREE(message->line.request.method);
        }
        // response
        if(TMSRP_MESSAGE_IS_RESPONSE(message)) {
            TSK_FREE(message->line.response.comment);
        }

        // Very common headers
        TSK_OBJECT_SAFE_FREE(message->To);
        TSK_OBJECT_SAFE_FREE(message->From);

        TSK_OBJECT_SAFE_FREE(message->MessageID);

        TSK_OBJECT_SAFE_FREE(message->ByteRange);
        TSK_OBJECT_SAFE_FREE(message->FailureReport);
        TSK_OBJECT_SAFE_FREE(message->SuccessReport);
        TSK_OBJECT_SAFE_FREE(message->Status);

        // all other headers
        TSK_OBJECT_SAFE_FREE(message->headers);

        // content
        TSK_OBJECT_SAFE_FREE(message->ContentType);
        TSK_OBJECT_SAFE_FREE(message->Content);

        // end-line
        TSK_FREE(message->end_line.tid);
    }
    return self;
}

static int tmsrp_message_cmp(const tsk_object_t *obj1, const tsk_object_t *obj2)
{
    return -1;
}

static const tsk_object_def_t tmsrp_message_def_s = {
    sizeof(tmsrp_message_t),
    tmsrp_message_ctor,
    tmsrp_message_dtor,
    tmsrp_message_cmp,
};
const tsk_object_def_t *tmsrp_message_def_t = &tmsrp_message_def_s;