conference_room.c

AnyQ服务端源代码(2004/10/28)源码

	    {
	        log_debug(NAME, "[%s] List set requested by admin...", FZONE);

		result = xmlnode_get_tag(jp->x, "query");

		if(NSCHECK(xmlnode_get_tag(result,"x"),NS_DATA))
		{
		    log_debug(NAME, "[%s] Received x:data", FZONE);
	            jutil_error(jp->x, TERROR_BAD);
		    deliver(dpacket_new(jp->x), NULL);
		    return;
		}
		else
		{
	            con_parse_item(from, jp);
		    return;
		}
            }
	}
	else if(NSCHECK(jp->iq, NS_MUC_OWNER))
	{
	    if(!is_owner(room, from->realid))
	    {   
		jutil_error(jp->x, TERROR_NOTALLOWED);
		deliver(dpacket_new(jp->x), NULL);
		return;
	    }

	    if(j_strcmp(xmlnode_get_name(jp->iq),"query") == 0)
            {

		result = xmlnode_get_tag(jp->x, "query");
		node = xmlnode_get_tag(result, "destroy");

		if(node)
		{
		    log_debug(NAME, "[%s] IQ Set for owner: destroy requested", FZONE);
		    /* Remove old xdb registration */
		    if(room->persistant == 1)
		    {
	                xdb_room_clear(room);
		    }

		    /* inform everyone they have left the room */
		    htb_walk(&room->remote, con_room_leaveall, node);

	            con_room_zap(room);
	            jutil_iqresult(jp->x);
		    deliver(dpacket_new(jp->x), NULL);
		    return;
		}
		else if(NSCHECK(xmlnode_get_tag(result,"x"),NS_DATA))
		{
		    log_debug(NAME, "[%s] Received x:data", FZONE);
		    xdata_handler(room, from, jp);

		    jutil_iqresult(jp->x);
		    deliver(dpacket_new(jp->x), NULL);
		    return;
		}
		else
		{
	            log_debug(NAME, "[%s] IQ Set for owner: configuration set", FZONE);
	            con_parse_item(from, jp);
		    return;
		}
	    }
	    else
            {
	        jutil_error(jp->x, TERROR_BAD);
	        deliver(dpacket_new(jp->x), NULL);
	        return;
	    }
	}
	else if(NSCHECK(jp->iq, NS_REGISTER))
	{
	    log_debug(NAME, "[%s] IQ Set for Registration function", FZONE);

	    jutil_error(jp->x, TERROR_NOTALLOWED);
	    deliver(dpacket_new(jp->x), NULL);
	    return;
	}

        jutil_error(jp->x, TERROR_BAD);
        deliver(dpacket_new(jp->x), NULL);
        return;
    }

    if(jpacket_subtype(jp) == JPACKET__GET)
    {
	if(NSCHECK(jp->iq,NS_VERSION))
	{
	    jutil_iqresult(jp->x);
	    xmlnode_put_attrib(xmlnode_insert_tag(jp->x,"query"),"xmlns",NS_VERSION);
	    jpacket_reset(jp);

	    xmlnode_insert_cdata(xmlnode_insert_tag(jp->iq,"name"),NAME,-1);
	    xmlnode_insert_cdata(xmlnode_insert_tag(jp->iq,"version"),VERSION,-1);

	    deliver(dpacket_new(jp->x),NULL);
	    return;
	}
        else if(NSCHECK(jp->iq, NS_BROWSE))
        {
            jutil_iqresult(jp->x);
            result = xmlnode_insert_tag(jp->x,"item");
            xmlnode_put_attrib(result,"category", "conference");
            xmlnode_put_attrib(result,"xmlns", NS_BROWSE);
            xmlnode_put_attrib(result,"name", room->name);

            if(room->public)
            {
                xmlnode_put_attrib(result,"type", "public");
            }
            else
            {
                xmlnode_put_attrib(result,"type", "private");
            }

            xmlnode_insert_cdata(xmlnode_insert_tag(result,"ns"),NS_MUC,-1);

            htb_walk(&room->local, con_room_browsewalk, (void*)result);
            deliver(dpacket_new(jp->x), NULL);
            return;
        }
	else if(NSCHECK(jp->iq, NS_DISCO_INFO))
	{
	    log_debug(NAME, "[%s] room packet - Disco Info Request", FZONE);

	    _con_room_discoinfo(room, jp);
	    return;
	}
	else if(NSCHECK(jp->iq, NS_DISCO_ITEMS))
	{
	    log_debug(NAME, "[%s] room packet - Disco Items Request", FZONE);

	    jutil_iqresult(jp->x);
            result = xmlnode_insert_tag(jp->x, "query");
            xmlnode_put_attrib(result, "xmlns", NS_DISCO_ITEMS);

            htb_walk(&room->local, _con_room_discoitem, (void*)result);

	    deliver(dpacket_new(jp->x), NULL);
	    return;
	}
	else if(NSCHECK(jp->iq, NS_MUC_ADMIN))
        {
	    log_debug(NAME, "[%s] IQ Get for admin function, %s", FZONE, xmlnode_get_name(jp->iq));

	    if(!is_moderator(room, from->realid))
	    {
	        jutil_error(jp->x, TERROR_FORBIDDEN);
	        deliver(dpacket_new(jp->x), NULL);
	        return;
	    }

	    if(j_strcmp(xmlnode_get_name(jp->iq),"query") == 0)
            {
	        con_parse_item(from, jp);
	        return;
	    }
        }
	else if(NSCHECK(jp->iq, NS_MUC_OWNER))
        {
	    log_debug(NAME, "[%s] IQ Get for owner function, %s", FZONE, xmlnode_get_name(jp->iq));

	    if(!is_owner(room, from->realid))
	    {
	        jutil_error(jp->x, TERROR_FORBIDDEN);
	        deliver(dpacket_new(jp->x), NULL);
	        return;
	    }

	    if(j_strcmp(xmlnode_get_name(jp->iq),"query") == 0)
            {
	        con_parse_item(from, jp);
	        return;
	    }
        }
	else if(NSCHECK(jp->iq, NS_REGISTER))
	{
	    log_debug(NAME, "[%s] IQ Get for Registration function", FZONE);

	    jutil_error(jp->x, TERROR_NOTALLOWED);
	    deliver(dpacket_new(jp->x), NULL);
	    return;
	}
    }

    jutil_error(jp->x, TERROR_BAD);
    deliver(dpacket_new(jp->x), NULL);
    return;

}

cnr con_room_new(cni master, jid roomid, jid owner, char *name, char *secret, int private, int xdata, int persist)
{
    cnr room;
    pool p;
    cnu admin;
    char *key;


    p = pool_new(); /* Create pool for room struct */
    room = pmalloco(p, sizeof(_cnr));
    log_debug(NAME, "[%s] Malloc: _cnr = %d", FZONE, sizeof(_cnr));

    room->p = p;
    room->master = master;

    /* room jid */
    room->id = jid_new(p, jid_full(jid_fix(roomid)));

    /* room name for browse */
    if(name)
	room->name = pstrdup(room->p, name);
    else
        room->name = pstrdup(room->p, room->id->user);

    /* room password */
    room->secret = pstrdup(room->p, secret);
    room->private = private;

    room->history = pmalloco(p, sizeof(xmlnode) * master->history); /* make array of xmlnodes */
    log_debug(NAME, "[%s] Malloc: history = %d", FZONE, sizeof(xmlnode) * master->history);

    /* user hashes */
    htb_init_table(&room->remote, master->maxhash);
    htb_init_table(&room->local, master->maxhash);
    htb_init_table(&room->roster, master->maxhash);
    /* Affiliated hashes */
    htb_init_table(&room->owner, master->maxhash);
    htb_init_table(&room->admin, master->maxhash);
    htb_init_table(&room->member, master->maxhash);
    htb_init_table(&room->outcast, master->maxhash);
    /* Role hashes */
    htb_init_table(&room->moderator, master->maxhash);
    htb_init_table(&room->participant, master->maxhash);
    /* Room messages */
    room->note_leave = xmlnode_get_tag_data(master->config,"notice/leave");
    room->note_join = xmlnode_get_tag_data(master->config,"notice/join");
    room->note_rename = xmlnode_get_tag_data(master->config,"notice/rename");
    /* Room Defaults */
    room->public = master->public;
    room->subjectlock = 0;
    room->maxusers = 30;
    room->persistant = persist;
    room->moderated = 0;
    room->defaulttype = 0;
    room->privmsg = 0;
    room->invitation = 0;
    room->invites = 0;
    room->legacy = 1;
    room->visible = 0;
    room->logfile = NULL;
    room->logformat = LOG_TEXT;
    room->description = NULL;

    if(owner != NULL)
    {
        admin = (void*)con_user_new(room, owner);
	add_roster(room, admin->realid);

	room->creator = jid_new(room->p, jid_full(jid_user(jid_fix(admin->realid))));

	add_affiliate(room->owner, admin->realid, NULL);

	if(xdata > 0 )
		xdata_room_config(room,admin,1,NULL);

	log_debug(NAME, "[%s] Added new admin: %s to room %s", FZONE, jid_full(jid_fix(owner)),jid_full(jid_fix(room->id)));
    }

    key = j_strdup(jid_full(jid_fix(room->id)));
    htb_put(&master->rooms, key, (void*)room);
    free(key);

    log_debug(NAME,"[%s] new room %s (%s/%s/%d)", FZONE, jid_full(jid_fix(room->id)),name,secret,private);

    if(room->persistant == 1)
    {
	xdb_room_set(room);
    }

    return room;
}

void _con_room_send(const char *key, void *data, void *arg)
{
    cnu user = (cnu)data;
    xmlnode x = xmlnode_dup((xmlnode)arg);

    xmlnode_put_attrib(x, "to", jid_full(jid_fix(user->realid)));
    deliver(dpacket_new(x), NULL);
    return;
}

void _con_room_send_legacy(const char *key, void *data, void *arg)
{
    cnu user = (cnu)data;
    xmlnode x = xmlnode_dup((xmlnode)arg);

    if(!is_legacy(user))
    {
        xmlnode_free(x);
        return;
    }

    xmlnode_put_attrib(x, "to", jid_full(jid_fix(user->realid)));
    deliver(dpacket_new(x), NULL);
    return;
}


void con_room_send(cnr room, xmlnode x, int legacy)
{
    log_debug(NAME,"[%s] Sending packet from room %s: %s", FZONE, jid_full(jid_fix(room->id)), xmlnode2str(x));

    /* log */
    con_room_log(room, NULL, xmlnode_get_tag_data(x, "body"));

    xmlnode_put_attrib(x, "from", jid_full(jid_fix(room->id)));

    //deliver__flag = 0;

    if(legacy)
        htb_walk(&room->local, _con_room_send_legacy, (void*)x);
    else
        htb_walk(&room->local, _con_room_send, (void*)x);
    //deliver__flag = 1;
    deliver(NULL, NULL);

    xmlnode_free(x);
    return;
}

/* Clear up room hashes */
void con_room_cleanup(cnr room)
{
    log_debug(NAME, "[%s] cleaning room %s", FZONE, jid_full(jid_fix(room->id)));

    /* Clear old hashes */
    log_debug(NAME, "[%s] zapping list remote in room %s", FZONE, jid_full(jid_fix(room->id)));
    htb_free(&room->remote);
    log_debug(NAME, "[%s] zapping list local in room %s", FZONE, jid_full(jid_fix(room->id)));
    htb_free(&room->local);
    log_debug(NAME, "[%s] zapping list roster in room %s", FZONE, jid_full(jid_fix(room->id)));
    htb_free(&room->roster);
    log_debug(NAME, "[%s] zapping list owner in room %s", FZONE, jid_full(jid_fix(room->id)));
    htb_free(&room->owner);
    log_debug(NAME, "[%s] zapping list admin in room %s", FZONE, jid_full(jid_fix(room->id)));
    htb_free(&room->admin);
    log_debug(NAME, "[%s] zapping list member in room %s", FZONE, jid_full(jid_fix(room->id)));
    htb_free(&room->member);
    log_debug(NAME, "[%s] zapping list outcast in room %s", FZONE, jid_full(jid_fix(room->id)));
    htb_free(&room->outcast);
    log_debug(NAME, "[%s] zapping list moderator in room %s", FZONE, jid_full(jid_fix(room->id)));
    htb_free(&room->moderator);
    log_debug(NAME, "[%s] zapping list participant in room %s", FZONE, jid_full(jid_fix(room->id)));
    htb_free(&room->participant);

    log_debug(NAME, "[%s] closing room log in room %s", FZONE, jid_full(jid_fix(room->id)));
    if(room->logfile && room->logfile != NULL)
	fclose(room->logfile);

    return;
}

/* Zap room entry */
void con_room_zap(cnr room)
{
    log_debug(NAME, "[%s] zapping room %s", FZONE, jid_full(jid_fix(room->id)));

    con_room_cleanup(room);

    log_debug(NAME, "[%s] zapping room %s from list", FZONE, jid_full(jid_fix(room->id)));
    htb_zap(&room->master->rooms, jid_full(jid_fix(room->id)));
    xmlnode_free(room->topic);
    pool_free(room->p);
    return;
}