/*

* $Id: imc_cmd.c 5016 2008-11-23 15:28:02Z saguti $

*

* imc module - instant messaging conferencing implementation

*

* Copyright (C) 2006 Voice Sistem S.R.L.

*

* This file is part of opensips, a free SIP server.

*

* opensips 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

*

* opensips 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

*

*/

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <unistd.h>

#include <sys/types.h>

#include "../../mem/shm_mem.h"

#include "../../mem/mem.h"

#include "../../sr_module.h"

#include "../../dprint.h"

#include "../../parser/parse_uri.h"

#include "imc.h"

#include "imc_cmd.h"

#define IMC_BUF_SIZE 1024

static char imc_body_buf[IMC_BUF_SIZE];

static str imc_msg_type = { "MESSAGE", 7 };

static str imc_hdr_ctype = { "Content-Type: text/plain\r\n", 26};

int imc_send_message(str *src, str *dst, str *headers, str *body);

int imc_room_broadcast(imc_room_p room, str *ctype, str *body);

void imc_inv_callback( struct cell *t, int type, struct tmcb_params *ps);

/**

* parse cmd

*/

int imc_parse_cmd(char *buf, int len, imc_cmd_p cmd)

{

char *p;

int i;

if(buf==NULL || len<=0 || cmd==NULL)

{

LM_ERR("invalid parameters\n");

return -1;

}

memset(cmd, 0, sizeof(imc_cmd_t));

if(buf[0]!=imc_cmd_start_char)

{

LM_ERR("invalid command [%.*s]\n", len, buf);

return -1;

}

p = &buf[1];

cmd->name.s = p;

while(*p && p<buf+len)

{

if(*p==' ' || *p=='\t' || *p=='\r' || *p=='\n')

break;

p++;

}

if(cmd->name.s == p)

{

LM_ERR("no command in [%.*s]\n", len, buf);

return -1;

}

cmd->name.len = p - cmd->name.s;

/* identify the command */

if(cmd->name.len==(sizeof("create")-1)

&& !strncasecmp(cmd->name.s, "create", cmd->name.len))

{

cmd->type = IMC_CMDID_CREATE;

} else if(cmd->name.len==(sizeof("join")-1)

&& !strncasecmp(cmd->name.s, "join", cmd->name.len)) {

cmd->type = IMC_CMDID_JOIN;

} else if(cmd->name.len==(sizeof("invite")-1)

&& !strncasecmp(cmd->name.s, "invite", cmd->name.len)) {

cmd->type = IMC_CMDID_INVITE;

} else if(cmd->name.len==(sizeof("accept")-1)

&& !strncasecmp(cmd->name.s, "accept", cmd->name.len)) {

cmd->type = IMC_CMDID_ACCEPT;

} else if(cmd->name.len==(sizeof("deny")-1)

&& !strncasecmp(cmd->name.s, "deny", cmd->name.len)) {

cmd->type = IMC_CMDID_DENY;

} else if(cmd->name.len==(sizeof("remove")-1)

&& !strncasecmp(cmd->name.s, "remove", cmd->name.len)) {

cmd->type = IMC_CMDID_REMOVE;

} else if(cmd->name.len==(sizeof("exit")-1)

&& !strncasecmp(cmd->name.s, "exit", cmd->name.len)) {

cmd->type = IMC_CMDID_EXIT;

} else if(cmd->name.len==(sizeof("list")-1)

&& !strncasecmp(cmd->name.s, "list", cmd->name.len)) {

cmd->type = IMC_CMDID_LIST;

} else if(cmd->name.len==(sizeof("destroy")-1)

&& !strncasecmp(cmd->name.s, "destroy", cmd->name.len)) {

cmd->type = IMC_CMDID_DESTROY;

} else if(cmd->name.len==(sizeof("rename")-1)

&& !strncasecmp(cmd->name.s, "rename", cmd->name.len)) {

cmd->type = IMC_CMDID_RENAME;

} else if(cmd->name.len==(sizeof("help")-1)

&& !strncasecmp(cmd->name.s, "help", cmd->name.len)) {

cmd->type = IMC_CMDID_HELP;

goto done;

} else {

cmd->type = IMC_CMDID_UNKNOWN;

goto done;

}

if(*p=='\0' || p>=buf+len)

goto done;

i=0;

do {

while(p<buf+len && (*p==' ' || *p=='\t'))

p++;

if(p>=buf+len || *p=='\0' || *p=='\r' || *p=='\n')

goto done;

cmd->param[i].s = p;

while(p<buf+len)

{

if(*p=='\0' || *p==' ' || *p=='\t' || *p=='\r' || *p=='\n')

break;

p++;

}

cmd->param[i].len = p - cmd->param[i].s;

i++;

if(i>=IMC_CMD_MAX_PARAM)

break;

} while(1);

done:

LM_ERR("command: [%.*s]\n", cmd->name.len, cmd->name.s);

for(i=0; i<IMC_CMD_MAX_PARAM; i++)

{

if(cmd->param[i].len<=0)

break;

LM_DBG("parameter %d=[%.*s]\n", i, cmd->param[i].len, cmd->param[i].s);

}

return 0;

}

/**

*

*/

int imc_handle_create(struct sip_msg* msg, imc_cmd_t *cmd,

struct sip_uri *src, struct sip_uri *dst, str *fullname)

{

imc_room_p room = 0;

imc_member_p member = 0;

int flag_room = 0;

int flag_member = 0;

str body;

room = imc_get_room(&cmd->param[0], &dst->host);

if(room== NULL)

{

LM_DBG("new room [%.*s]\n", cmd->param[0].len, cmd->param[0].s);

if(cmd->param[1].len==IMC_ROOM_PRIVATE_LEN

&& !strncasecmp(cmd->param[1].s, IMC_ROOM_PRIVATE,

cmd->param[1].len))

{

flag_room |= IMC_ROOM_PRIV;

LM_DBG("room with private flag on\n");

}

room= imc_add_room(&cmd->param[0], &dst->host, flag_room);

if(room == NULL)

{

LM_ERR("failed to add new room\n");

goto error;

}

LM_DBG("added room uri= %.*s\n", room->uri.len, room->uri.s);

flag_member |= IMC_MEMBER_OWNER;

/* adding the owner as the forst member*/

member= imc_add_member(room, &src->user, &src->host, fullname, flag_member);

if(member == NULL)

{

LM_ERR("failed to add owner [%.*s]\n", src->user.len, src->user.s);

goto error;

}

LM_DBG("added the owner (%.*s) as the first member "

"[%.*s]\n", member->fullname.len, member->fullname.s, member->uri.len, member->uri.s);

/* send info message */

body.s = "*** room was created";

body.len = sizeof("*** room was created")-1;

imc_send_message(&room->uri, &member->uri, &imc_hdr_ctype, &body);

goto done;

}

/* room already exists */

LM_DBG("room [%.*s] already created\n", cmd->param[0].len, cmd->param[0].s);

if(!(room->flags & IMC_ROOM_PRIV))

{

LM_DBG("checking if the user [%.*s] is a member\n",

src->user.len, src->user.s);

member= imc_get_member(room, &src->user, &src->host);

if(member== NULL)

{

member= imc_add_member(room, &src->user, &src->host, fullname, flag_member);

if(member == NULL)

{

LM_ERR("failed to add member [%.*s]\n",

src->user.len, src->user.s);

goto error;

}

LM_DBG("added as member [%.*s] (%.*s)\n",member->uri.len, member->uri.s, member->fullname.len, member->fullname.s);

/* send info message */

body.s = imc_body_buf;

body.len = snprintf(body.s, IMC_BUF_SIZE,

"*** [%.*s] (%.*s) has joined the room",

member->uri.len, member->uri.s, member->fullname.len, member->fullname.s);

if(body.len>0)

imc_room_broadcast(room, &imc_hdr_ctype, &body);

}

}

done:

if(room!=NULL)

imc_release_room(room);

return 0;

error:

if(room!=NULL)

imc_release_room(room);

return -1;

}

/**

*

*/

int imc_handle_join(struct sip_msg* msg, imc_cmd_t *cmd,

struct sip_uri *src, struct sip_uri *dst, str *fullname)

{

imc_room_p room = 0;

imc_member_p member = 0;

int flag_room = 0;

int flag_member = 0;

str room_name;

str body;

room_name = cmd->param[0].s?cmd->param[0]:dst->user;

room=imc_get_room(&room_name, &dst->host);

if(room== NULL || (room->flags&IMC_ROOM_DELETED))

{

LM_DBG("could not find room [%.*s]- adding\n",

room_name.len, room_name.s);

room= imc_add_room(&room_name, &dst->host, flag_room);

if(room == NULL)

{

LM_ERR("failed to add new room [%.*s]\n",

room_name.len, room_name.s);

goto error;

}

LM_DBG("created a new room [%.*s]\n", room->name.len, room->name.s);

flag_member |= IMC_MEMBER_OWNER;

member= imc_add_member(room, &src->user, &src->host, fullname, flag_member);

if(member == NULL)

{

LM_ERR("failed to add new member [%.*s]\n",

src->user.len, src->user.s);

goto error;

}

/* send info message */

body.s = "*** room was created";

body.len = sizeof("*** room was created")-1;

imc_send_message(&room->uri, &member->uri, &imc_hdr_ctype, &body);

goto done;

}

/* room exists */

LM_DBG("found room [%.*s]\n", room_name.len, room_name.s);

member= imc_get_member(room, &src->user, &src->host);

if(!(room->flags & IMC_ROOM_PRIV))

{

LM_DBG("room [%.*s] is public\n", room_name.len, room_name.s);

if(member== NULL)

{

LM_DBG("adding new member [%.*s]\n", src->user.len, src->user.s);

member= imc_add_member(room, &src->user,

&src->host, fullname, flag_member);

if(member == NULL)

{

LM_ERR("adding new user [%.*s]\n", src->user.len, src->user.s);

goto error;

}

goto build_inform;

} else {

LM_DBG("member [%.*s] (%.*s) is in room already\n",

member->uri.len,member->uri.s, member->fullname.len, member->fullname.s );

}

} else {

if(member==NULL)

{

LM_ERR("attept to join private room [%.*s] from user [%.*s]\n",

room_name.len, room_name.s, src->user.len, src->user.s);

goto build_inform;

}

if(member->flags & IMC_MEMBER_INVITED)

member->flags &= ~IMC_MEMBER_INVITED;

}

build_inform:

/* send info message */

body.s = imc_body_buf;

body.len = snprintf(body.s, IMC_BUF_SIZE, "*** [%.*s] (%.*s) has joined the room",

member->uri.len, member->uri.s, member->fullname.len, member->fullname.s);

if(body.len>0)

imc_room_broadcast(room, &imc_hdr_ctype, &body);

done:

if(room!=NULL)

imc_release_room(room);

return 0;

error:

if(room!=NULL)

imc_release_room(room);

return -1;

}

/**

*

*/

int imc_handle_invite(struct sip_msg* msg, imc_cmd_t *cmd,

struct sip_uri *src, struct sip_uri *dst)

{

imc_room_p room = 0;

imc_member_p member = 0;

int flag_member = 0;

int size = 0;

int i = 0;

int add_domain = 0;

int add_sip = 0;

str uri = {0, 0};

str body;

str room_name;

struct sip_uri inv_uri;

del_member_t *cback_param = NULL;

int result;

size = cmd->param[0].len+2 ;

add_domain = 1;

add_sip = 0;

while (i<size )

{

if(cmd->param[0].s[i]== '@')

{

add_domain = 0;

break;

}

i++;

}

if(add_domain)

size += dst->host.len;

if(cmd->param[0].len<4 || strncasecmp(cmd->param[0].s, "sip:", 4)!=0)

{

size += 4;

add_sip = 1;

}

uri.s = (char*)pkg_malloc(size *sizeof(char));

if(uri.s == NULL)

{

LM_ERR("no more pkg memory\n");

goto error;

}

size= 0;

if(add_sip)

{

strcpy(uri.s, "sip:");

size=4;

}

memcpy(uri.s+size, cmd->param[0].s, cmd->param[0].len);

size += cmd->param[0].len;

if(add_domain)

{

uri.s[size] = '@';

size++;

memcpy(uri.s+ size, dst->host.s, dst->host.len);

size+= dst->host.len;

}

uri.len = size;

if(parse_uri(uri.s, uri.len, &inv_uri)!=0)

{

LM_ERR("bad uri [%.*s]!\n", uri.len, uri.s);

goto error;

}

room_name = (cmd->param[1].s)?cmd->param[1]:dst->user;

room = imc_get_room(&room_name, &dst->host);

if(room== NULL || (room->flags&IMC_ROOM_DELETED))

{

LM_ERR("the room does not exist [%.*s]!\n",

room_name.len, room_name.s);

goto error;

}

member= imc_get_member(room, &src->user, &src->host);

if(member==NULL)

{

LM_ERR("user [%.*s] is not member of[%.*s]!\n",

src->user.len, src->user.s, room_name.len, room_name.s);

goto error;

}

if(!(member->flags & IMC_MEMBER_OWNER) &&

!(member->flags & IMC_MEMBER_ADMIN))

{

LM_ERR("user [%.*s] has no right to invite"

" other users!\n", src->user.len, src->user.s);

goto error;

}

member= imc_get_member(room, &inv_uri.user, &inv_uri.host);

if(member!=NULL)

{

LM_ERR("user [%.*s] is already member"

" of the room!\n", inv_uri.user.len, inv_uri.user.s);

goto error;

}

flag_member |= IMC_MEMBER_INVITED;

member=imc_add_member(room, &inv_uri.user, &inv_uri.host, &inv_uri.user /* TODO fullname dummy */, flag_member);

if(member == NULL)

{

LM_ERR("adding member [%.*s]\n",

inv_uri.user.len, inv_uri.user.s);

goto error;

}

body.len = 13 + member->uri.len - 4/* sip: */ + 28;

if(body.len>=IMC_BUF_SIZE || member->uri.len>=IMC_BUF_SIZE

|| room->uri.len>=IMC_BUF_SIZE)

{

LM_ERR("buffer size overflow\n");

goto error;

}

body.s = imc_body_buf;

memcpy(body.s, "INVITE from: ", 13);

memcpy(body.s+13, member->uri.s + 4, member->uri.len - 4);

memcpy(body.s+ 9 + member->uri.len, "(Type: '#accept' or '#deny')", 28);

body.s[body.len] = '\0';

LM_DBG("to=[%.*s]\nfrom=[%.*s]\nbody=[%.*s]\n",

member->uri.len,member->uri.s,room->uri.len, room->uri.s,

body.len, body.s);

cback_param = (del_member_t*)shm_malloc(sizeof(del_member_t));

if(cback_param==NULL)

{

LM_ERR("no more shm\n");

goto error;

}

memset(cback_param, 0, sizeof(del_member_t));

cback_param->room_name = room->name;

cback_param->room_domain = room->domain;

cback_param->member_name = member->user;

cback_param->member_domain = member->domain;

cback_param->inv_uri = member->uri;

/*?!?! possible race with 'remove user' */

result= tmb.t_request(&imc_msg_type, /* Request Method */

&member->uri, /* Request-URI */

&member->uri, /* To */

&room->uri, /* From */

&imc_hdr_ctype, /* Extra headers */

&body, /* Message body */

(outbound_proxy.s)?&outbound_proxy:NULL,/* outbound proxy*/

imc_inv_callback, /* callback function*/

(void*)(cback_param) /* callback param*/

);

if(result< 0)

{

LM_ERR("in tm send request\n");

shm_free(cback_param);

goto error;

}

if(uri.s!=NULL)

pkg_free(uri.s);

imc_release_room(room);

return 0;

error:

if(uri.s!=0)

pkg_free(uri.s);

if(room!=NULL)

imc_release_room(room);

return -1;

}

/**

*

*/

int imc_handle_accept(struct sip_msg* msg, imc_cmd_t *cmd,

struct sip_uri *src, struct sip_uri *dst)

{

imc_room_p room = 0;

imc_member_p member = 0;

str room_name;

str body;

/* accepting the invitation */

room_name = cmd->param[0].s?cmd->param[0]:dst->user;

room=imc_get_room(&room_name, &dst->host);

if(room== NULL || (room->flags&IMC_ROOM_DELETED))

{

LM_ERR("room [%.*s] is not created!\n", room_name.len, room_name.s);

goto error;

}

/* if aready invited add as a member */

member=imc_get_member(room, &src->user, &src->host);

if(member==NULL || !(member->flags & IMC_MEMBER_INVITED))

{

LM_ERR("user [%.*s] not invited in the room!\n",

src->user.len, src->user.s);

goto error;

}

member->flags &= ~IMC_MEMBER_INVITED;

/* send info message */

body.s = imc_body_buf;

body.len = snprintf(body.s, IMC_BUF_SIZE, "*** [%.*s] (%.*s) has joined the room",

member->uri.len, member->uri.s, member->fullname.len, member->fullname.s);

if(body.len>0)

imc_room_broadcast(room, &imc_hdr_ctype, &body);

imc_release_room(room);

return 0;

error:

if(room!=NULL)

imc_release_room(room);

return -1;

}

/**

*

*/

int imc_handle_remove(struct sip_msg* msg, imc_cmd_t *cmd,

struct sip_uri *src, struct sip_uri *dst)

{

imc_room_p room = 0;

imc_member_p member = 0;

str room_name;

str body;

str uri = {0, 0};

int size =0;

int i = 0;

int add_domain = 0;

int add_sip = 0;

struct sip_uri inv_uri;

size= cmd->param[0].len+2;

add_domain = 1;

while (i<size )

{

if(cmd->param[0].s[i]== '@')

{

add_domain =0;

break;

}

i++;

}

if(add_domain)

size += dst->host.len;

if(cmd->param[0].len<=4 || strncasecmp(cmd->param[0].s, "sip:", 4)!=0)

{

size+= 4;

add_sip = 1;

}

uri.s = (char*)pkg_malloc(size*sizeof(char));

if(uri.s == NULL)

{

LM_ERR("no more pkg memory\n");

goto error;

}

size= 0;

if(add_sip)

{

strcpy(uri.s, "sip:");

size = 4;

}

memcpy(uri.s+size, cmd->param[0].s, cmd->param[0].len);

size+= cmd->param[0].len;

if(add_domain)

{

uri.s[size] = '@';

size++;

memcpy(uri.s+size, dst->host.s, dst->host.len);

size+= dst->host.len;

}

uri.len = size;

if(parse_uri(uri.s, uri.len, &inv_uri)<0)

{

LM_ERR("invalid uri [%.*s]\n", uri.len, uri.s);

goto error;

}

room_name = cmd->param[1].s?cmd->param[1]:dst->user;

room= imc_get_room(&room_name, &dst->host);

if(room==NULL || (room->flags&IMC_ROOM_DELETED))

{

LM_ERR("room [%.*s]does not exist!\n", room_name.len, room_name.s);

goto error;

}

/* verify if the user who sent the request is a member in the room

* and has the right to remove other users */

member= imc_get_member(room, &src->user, &src->host);

if(member== NULL)

{

LM_ERR("user [%.*s] is not member of room [%.*s]!\n",

src->user.len, src->user.s, room_name.len, room_name.s);

goto error;

}

if(!(member->flags & IMC_MEMBER_OWNER) &&

!(member->flags & IMC_MEMBER_ADMIN))

{

LM_ERR("user [%.*s] has no right to remove other users [%.*s]!\n",

src->user.len, src->user.s, uri.len, uri.s);

goto error;

}

/* verify if the user that is to be removed is a member of the room */

member= imc_get_member(room, &inv_uri.user, &inv_uri.host);

if(member== NULL)

{

LM_ERR("user [%.*s] is not member of room [%.*s]!\n",

inv_uri.user.len, inv_uri.user.s, room_name.len, room_name.s);

goto error;

}

if(member->flags & IMC_MEMBER_OWNER)

{

LM_ERR("user [%.*s] is owner of room [%.*s]"

" -- cannot be removed!\n", inv_uri.user.len, inv_uri.user.s,

room_name.len, room_name.s);

goto error;

}

/* send message to the removed person */

body.s = "You have been removed from this room";

body.len = strlen(body.s);

LM_DBG("to: [%.*s]\nfrom: [%.*s]\nbody: [%.*s]\n",

member->uri.len, member->uri.s , room->uri.len, room->uri.s,

body.len, body.s);

imc_send_message(&room->uri, &member->uri, &imc_hdr_ctype, &body);

member->flags |= IMC_MEMBER_DELETED;

imc_del_member(room, &inv_uri.user, &inv_uri.host);

body.s = imc_body_buf;

body.len = snprintf(body.s, IMC_BUF_SIZE, "*** [%.*s] (%.*s) has been removed from the room",

member->uri.len, member->uri.s, member->fullname.len, member->fullname.s);

if(body.len>0)

imc_room_broadcast(room, &imc_hdr_ctype, &body);

if(uri.s!=0)

pkg_free(uri.s);

imc_release_room(room);

return 0;

error:

if(uri.s!=0)

pkg_free(uri.s);

if(room!=NULL)

imc_release_room(room);

return -1;

}

/**

*

*/

int imc_handle_deny(struct sip_msg* msg, imc_cmd_t *cmd,

struct sip_uri *src, struct sip_uri *dst)

{

imc_room_p room = 0;

imc_member_p member = 0;

str room_name;

// str body;

/* denying an invitation */

room_name = cmd->param[0].s?cmd->param[0]:dst->user;

room= imc_get_room(&room_name, &dst->host);

if(room== NULL || (room->flags&IMC_ROOM_DELETED))

{

LM_ERR("room [%.*s] does not exist!\n", room_name.len, room_name.s);

goto error;

}

/* If the user is an invited member, delete it froim the list */

member= imc_get_member(room, &src->user, &src->host);

if(member==NULL || !(member->flags & IMC_MEMBER_INVITED))

{

LM_ERR("user [%.*s] was not invited in room [%.*s]!\n",

src->user.len, src->user.s, room_name.len, room_name.s);

goto error;

}

#if 0

/* send info message */

body.s = imc_body_buf;

body.len = snprintf(body.s, IMC_BUF_SIZE,

"The user [%.*s] has denied the invitation",

src->user.len, src->user.s);

if(body.len>0)

imc_send_message(&room->uri, &memeber->uri, &imc_hdr_ctype, &body);

#endif

LM_ERR("user [%.*s] declined invitation in room [%.*s]!\n",

src->user.len, src->user.s, room_name.len, room_name.s);

imc_del_member(room, &src->user, &src->host);

imc_release_room(room);

return 0;

error:

if(room!=NULL)

imc_release_room(room);

return -1;

}

/**

*

*/

int imc_handle_list(struct sip_msg* msg, imc_cmd_t *cmd,

struct sip_uri *src, struct sip_uri *dst)

{

imc_room_p room = 0;

imc_member_p member = 0;

imc_member_p imp = 0;

str room_name;

str body;

char *p;

/* the user wants to leave the room */

room_name = cmd->param[0].s?cmd->param[0]:dst->user;

room= imc_get_room(&room_name, &dst->host);

if(room== NULL || (room->flags&IMC_ROOM_DELETED))

{

LM_ERR("room [%.*s] does not exist!\n", room_name.len, room_name.s);

goto error;

}

/* verify if the user is a member of the room */

member = imc_get_member(room, &src->user, &src->host);

if(member == NULL)

{

LM_ERR("user [%.*s] is not member of room [%.*s]!\n",

src->user.len, src->user.s, room_name.len, room_name.s);

goto error;

}

p = imc_body_buf;

strncpy(p, "Members:\n", 9);

p+=9;

imp = room->members;

while(imp)

{

if((imp->flags&IMC_MEMBER_INVITED)||(imp->flags&IMC_MEMBER_DELETED)

|| (imp->flags&IMC_MEMBER_SKIP))

{

imp = imp->next;

continue;

}

if(imp->flags & IMC_MEMBER_OWNER)

*p++ = '*';

else if(imp->flags & IMC_MEMBER_ADMIN)

*p++ = '~';

strncpy(p, imp->uri.s, imp->uri.len);

p += imp->uri.len;

/* S: add fullname display in brackets behind URI */

*p++ = ' ';

*p++ = '(';

strncpy(p, imp->fullname.s, imp->fullname.len);

p += imp->fullname.len;

*p++ = ')';

/* E */

*p++ = '\n';

imp = imp->next;

}

imc_release_room(room);

/* write over last '\n' */

*(--p) = 0;

body.s = imc_body_buf;

body.len = p-body.s;

LM_DBG("members = [%.*s]\n", body.len, body.s);

imc_send_message(&room->uri, &member->uri, &imc_hdr_ctype, &body);

return 0;

error:

if(room!=NULL)

imc_release_room(room);

return -1;

}

/**

*

*/

int imc_handle_exit(struct sip_msg* msg, imc_cmd_t *cmd,

struct sip_uri *src, struct sip_uri *dst)

{

imc_room_p room = 0;

imc_member_p member = 0;

str room_name;

str body;

/* the user wants to leave the room */

room_name = cmd->param[0].s?cmd->param[0]:dst->user;

room= imc_get_room(&room_name, &dst->host);

if(room== NULL || (room->flags&IMC_ROOM_DELETED))

{

LM_ERR("room [%.*s] does not exist!\n", room_name.len, room_name.s);

goto error;

}

/* verify if the user is a member of the room */

member= imc_get_member(room, &src->user, &src->host);

if(member== NULL)

{

LM_ERR("user [%.*s] is not member of room [%.*s]!\n",

src->user.len, src->user.s, room_name.len, room_name.s);

goto error;

}

if(member->flags & IMC_MEMBER_OWNER)

{

/*If the user is the owner of the room, the room is distroyed */

room->flags |=IMC_ROOM_DELETED;

body.s = imc_body_buf;

strcpy(body.s, "The room has been destroyed");

body.len = strlen(body.s);

imc_room_broadcast(room, &imc_hdr_ctype, &body);

imc_release_room(room);

imc_del_room(&room_name, &dst->host);

room = NULL;

goto done;

} else {

/* delete user */

member->flags |= IMC_MEMBER_DELETED;

imc_del_member(room, &src->user, &src->host);

body.s = imc_body_buf;

body.len = snprintf(body.s, IMC_BUF_SIZE,

"The user [%.*s] has left the room",

src->user.len, src->user.s);

if(body.len>0)

imc_room_broadcast(room, &imc_hdr_ctype, &body);

}

done:

if(room!=NULL)

imc_release_room(room);

return 0;

error:

if(room!=NULL)

imc_release_room(room);

return -1;

}

/**

*

*/

int imc_handle_destroy(struct sip_msg* msg, imc_cmd_t *cmd,

struct sip_uri *src, struct sip_uri *dst)

{

imc_room_p room = 0;

imc_member_p member = 0;

str room_name;

str body;

/* distrugere camera */

room_name = cmd->param[0].s?cmd->param[0]:dst->user;

room= imc_get_room(&room_name, &dst->host);

if(room== NULL || (room->flags&IMC_ROOM_DELETED))

{

LM_ERR("room [%.*s] does not exist!\n", room_name.len, room_name.s);

goto error;

}

/* verify is the user is a member of the room*/

member= imc_get_member(room, &src->user, &src->host);

if(member== NULL)

{

LM_ERR("user [%.*s] is not a member of room [%.*s]!\n",

src->user.len, src->user.s, room_name.len, room_name.s);

goto error;

}

if(!(member->flags & IMC_MEMBER_OWNER))

{

LM_ERR("user [%.*s] is not owner of room [%.*s] -- cannot destroy it"

"!\n", src->user.len, src->user.s, room_name.len, room_name.s);

goto error;

}

room->flags |= IMC_ROOM_DELETED;

body.s = imc_body_buf;

strcpy(body.s, "The room has been destroyed");

body.len = strlen(body.s);

/* braodcast message */

imc_room_broadcast(room, &imc_hdr_ctype, &body);

imc_release_room(room);

LM_DBG("deleting room\n");

imc_del_room(&room_name, &dst->host);

return 0;

error:

if(room!=NULL)

imc_release_room(room);

return -1;

}

/**

*

*/

int imc_handle_help(struct sip_msg* msg, imc_cmd_t *cmd, str *src, str *dst)

{

str body;

body.s = IMC_HELP_MSG;

body.len = IMC_HELP_MSG_LEN;

LM_DBG("to: [%.*s] from: [%.*s]\n", src->len, src->s, dst->len, dst->s);

tmb.t_request(&imc_msg_type, /* Request method */

NULL, /* Request-URI */

src, /* To */

dst, /* From */

&imc_hdr_ctype, /* Headers */

&body, /* Body */

(outbound_proxy.s)?&outbound_proxy:NULL,/* outbound proxy */

NULL, /* callback function */

NULL /* callback parameter*/

);

return 0;

}

/**