/* Dismiss a member from the clan/Resign from the clan */
void do_dismiss( struct char_data *ch, struct clan_type *cptr, struct char_data *vict )
{
if (vict != ch){
if (vict != NULL && GET_CLAN(vict) == GET_CLAN(ch)) {
if (GET_CLAN_RANK(vict) >= GET_CLAN_RANK(ch)) {
send_to_char("You may not dismiss those of equal or greater clan status than yourself!\r\n", ch);
return;
}
/* send some sort of mail to player notifying him/her of dismissal */
sprintf(buf, "%s,\r\n\r\n"
" You have been dismissed from the clan of %s.\r\n"
"If you are unsure of the reason why, please feel\r\n"
"free to contact the leader, %s.\r\n",
GET_NAME(vict), cptr->name, cptr->leadersname);
store_mail(GET_IDNUM(vict), GET_IDNUM(ch), -1, buf);
remove_member(cptr, vict);
}
} else if (GET_CLAN_RANK(vict) == CLAN_LEADER) {
GET_CLAN_RANK(vict) = CLAN_MEMBER;
send_to_char("You have resigned as leader.\r\n", ch);
cptr->leadersname = strdup("NoOne");
save_clans();
return;
}
GET_CLAN(vict) = CLAN_NONE;
GET_CLAN_RANK(vict) = CLAN_NONE;
GET_HOME(vict) = 1;
remove_member(cptr, vict);
save_char(vict, NOWHERE);
save_clans();
return;
}
int admin()
{
int choice;
printf("What function do you want?\n(1)add book\n(2)remove book\n(3)add member\n(4)remove member\n(5)member list\n(6)book list\n(7)exit\n");
scanf("%d",&choice);
switch(choice)
{
case 1:
add_book();
break;
case 2:
remove_book();
break;
case 3:
add_member();
break;
case 4:
remove_member();
break;
case 5:
member_list();
break;
case 6:
book_list();
break;
case 7:
exit(0);
}
return 1;
}
int rl_zrem(rlite *db, const unsigned char *key, long keylen, long members_size, unsigned char **members, long *members_len, long *changed)
{
rl_btree *scores;
rl_skiplist *skiplist;
long scores_page, skiplist_page, levels_page_number;
int retval;
RL_CALL(rl_zset_get_objects, RL_OK, db, key, keylen, &levels_page_number, &scores, &scores_page, &skiplist, &skiplist_page, 1, 1);
long i;
long _changed = 0;
for (i = 0; i < members_size; i++) {
retval = remove_member(db, key, keylen, levels_page_number, scores, scores_page, skiplist, skiplist_page, members[i], members_len[i]);
if (retval != RL_OK && retval != RL_NOT_FOUND && retval != RL_DELETED) {
goto cleanup;
}
else if (retval == RL_OK || retval == RL_DELETED) {
_changed++;
if (retval == RL_DELETED) {
// there is no any other element in the zset, nothing else to delete
break;
}
}
}
*changed = _changed;
retval = RL_OK;
cleanup:
return retval;
}
void TAO_FTEC_Group_Manager::replica_crashed (
const FTRT::Location & location)
{
TAO_FTRTEC::Log(1, ACE_TEXT("TAO_FTEC_Group_Manager::replica_crashed\n"));
FTRTEC::Replication_Service* svc = FTRTEC::Replication_Service::instance();
ACE_WRITE_GUARD (FTRTEC::Replication_Service, lock, *svc);
remove_member(location, IOGR_Maker::instance()->get_ref_version()+1);
}
void watchlist_fetch(struct menu_item *item)
{
struct item_data *data = item->data;
for (int i = data->members.size - 1; i >= 0; --i)
remove_member(data, i);
for (int i = 0; i < settings->n_watches; ++i)
add_member(data, settings->watch_address[i], settings->watch_info[i].type,
i, settings->watch_info[i].anchored,
settings->watch_x[i], settings->watch_y[i],
settings->watch_info[i].position_set);
}
/**
* Recieves and handles a group leave message.
*/
void acceptLeaveMessage(uint32_t src, uint32_t group) {
struct IfDesc *sourceVif;
my_log(LOG_DEBUG, 0,
"Got leave message from %s to %s. Starting last member detection.",
inetFmt(src, s1), inetFmt(group, s2));
// Sanitycheck the group adress...
if(!IN_MULTICAST( ntohl(group) )) {
my_log(LOG_WARNING, 0, "The group address %s is not a valid Multicast group.",
inetFmt(group, s1));
return;
}
// Find the interface on which the report was recieved.
sourceVif = getIfByAddress( src );
if(sourceVif == NULL) {
my_log(LOG_WARNING, 0, "No interfaces found for source %s",
inetFmt(src,s1));
return;
}
// We have a IF so check that it's an downstream IF.
if(sourceVif->state == IF_STATE_DOWNSTREAM) {
GroupVifDesc *gvDesc;
gvDesc = (GroupVifDesc*) malloc(sizeof(GroupVifDesc));
// Tell the route table that we are checking for remaining members...
setRouteLastMemberMode(group);
// Call the group spesific membership querier...
gvDesc->group = group;
gvDesc->vifAddr = sourceVif->InAdr.s_addr;
gvDesc->started = 0;
sendGroupSpecificMemberQuery(gvDesc);
#ifdef RALINK_ESW_SUPPORT
remove_member(ntohl(group), ntohl(src));
#endif
} else {
// just ignore the leave request...
my_log(LOG_DEBUG, 0, "The found if for %s was not downstream. Ignoring leave request.", inetFmt(src, s1));
}
}
int rl_zadd(rlite *db, const unsigned char *key, long keylen, double score, unsigned char *member, long memberlen)
{
int existed;
rl_btree *scores;
rl_skiplist *skiplist;
long scores_page, skiplist_page, levels_page_number;
int retval;
RL_CALL(rl_zset_get_objects, RL_OK, db, key, keylen, &levels_page_number, &scores, &scores_page, &skiplist, &skiplist_page, 1, 1);
retval = remove_member(db, key, keylen, levels_page_number, scores, scores_page, skiplist, skiplist_page, member, memberlen);
if (retval != RL_OK && retval != RL_NOT_FOUND && retval != RL_DELETED) {
goto cleanup;
}
else if (retval == RL_DELETED) {
RL_CALL(rl_zset_get_objects, RL_OK, db, key, keylen, &levels_page_number, &scores, &scores_page, &skiplist, &skiplist_page, 1, 1);
}
existed = retval != RL_NOT_FOUND; // ok or deleted means there was a value
RL_CALL(add_member, RL_OK, db, scores, scores_page, skiplist, skiplist_page, score, member, memberlen);
retval = existed ? RL_FOUND : RL_OK;
cleanup:
return retval;
}
void update_char_kingdom(CHAR_DATA * ch)
{
KINGDOM_DATA *kingdom;
if(!ch || IS_NPC(ch))
return;
if(ch->pcdata->kingdom > 0)
{
kingdom = get_kingdom(ch->pcdata->kingdom);
if(kingdom == &kingdom_default)
{
ch->pcdata->kingdom = 0;
return;
}
if(strstr(kingdom->members, ch->name) == 0 && !is_leader(ch, kingdom->id))
{
remove_trustee(kingdom->id, ch->name);
ch->pcdata->kingdom = 0;
return;
}
return;
}
if(ch->pcdata->krank[0] != '\0')
{
free_string(ch->pcdata->krank);
ch->pcdata->krank = str_dup("");
}
for(kingdom = kingdom_list; kingdom; kingdom = kingdom->next)
{
if(strstr(kingdom->members, ch->name) != 0)
remove_member(kingdom->id, ch->name);
if(strstr(kingdom->trustees, ch->name) != 0)
remove_trustee(kingdom->id, ch->name);
}
}
static int incrby(rlite *db, const unsigned char *key, long keylen, double score, unsigned char *member, long memberlen, double *newscore, int clearnan)
{
rl_btree *scores;
rl_skiplist *skiplist;
long scores_page, skiplist_page, levels_page_number;
double existing_score = 0.0;
int retval;
RL_CALL(rl_zset_get_objects, RL_OK, db, key, keylen, &levels_page_number, &scores, &scores_page, &skiplist, &skiplist_page, 1, 1);
retval = rl_get_zscore(db, scores, member, memberlen, &existing_score);
if (retval != RL_FOUND && retval != RL_NOT_FOUND) {
goto cleanup;
}
else if (retval == RL_FOUND) {
score += existing_score;
if (isnan(score)) {
if (clearnan) {
score = 0.0;
}
else {
retval = RL_NAN;
goto cleanup;
}
}
retval = remove_member(db, key, keylen, levels_page_number, scores, scores_page, skiplist, skiplist_page, member, memberlen);
if (retval == RL_DELETED) {
// it would be nice if we could update the score without destroying the btree, maybe remove_member should have an int destroy?
RL_CALL(rl_zset_get_objects, RL_OK, db, key, keylen, NULL, &scores, &scores_page, &skiplist, &skiplist_page, 0, 1);
}
else if (retval != RL_OK) {
goto cleanup;
}
}
RL_CALL(add_member, RL_OK, db, scores, scores_page, skiplist, skiplist_page, score, member, memberlen);
if (newscore) {
*newscore = score;
}
cleanup:
return retval;
}
void TAO_FTEC_Group_Manager::connection_closed()
{
TAO_FTRTEC::Log(1, ACE_TEXT("TAO_FTEC_Group_Manager::connection_closed\n"));
ACE_ASSERT(impl_->my_position > 0);
// do not use referere here, because the the value pointed by the pointer to
// crashed_location will be repliaced by its successor.
FTRT::Location crashed_location = impl_->info_list[impl_->my_position-1].the_location;
if (impl_->my_position > 1) {
// if I am not the new primary, tell the new primary
try{
TAO_IOP::TAO_IOR_Manipulation::IORList iors;
iors.length(impl_->my_position-1);
for (size_t i = 0; i < impl_->my_position-1; ++i)
iors[i] = CORBA::Object::_duplicate(impl_->info_list[i].ior.in());
CORBA::Object_var obj =
IOGR_Maker::instance()->merge_iors(iors);
FtRtecEventChannelAdmin::EventChannel_var primary =
FtRtecEventChannelAdmin::EventChannel::_narrow(obj.in());
primary->replica_crashed(crashed_location);
return;
}
catch (const CORBA::Exception&){
}
}
try{
remove_member(crashed_location,
IOGR_Maker::instance()->increment_ref_version());
}
catch (const CORBA::Exception&){
}
}
void open_edit_menu(node **head)
{
char option;
while(1)
{
CLS;
printf("\t\t\tHere you can edit different values\n\n");
printf("Choose option :-\n\n");
printf("1 - Add New Member\n2 - Remove existing member\n3 - Edit member info\n4 - Change Bill Amount\n5 - Change Entry Fee\n6 - Remove group activity\n\tBackspace = Main Menu\n");
option = getch();
CLS;
switch(option)
{
case '1':
add_new_member(*head);
grp_tot=bill_amt-per_tot+entry-sub_grp_total;//Set New Group Total
members++;
printf("\nNew Member Added !!");
hold_screen();
break;
case '2':
*head = remove_member(*head);
grp_tot=bill_amt-per_tot+entry-sub_grp_total;//Set New Group Total
members--;
printf("\nMember Removed !!");
hold_screen();
break;
case '3':
printf("\t\t\tHere you can edit member info\n\n");
edit_member_info(*head);
break;
case '4':
printf("\t\t\tHere you can set new bill amount\n\n");
jump:
printf("\tEnter New Final Bill Amount : ");
scanf(" %f",&bill_amt);
if(bill_amt<per_tot)
{
printf(" Wrong Bill Amount !!\n");
goto jump;
}
grp_tot=bill_amt-per_tot+entry-sub_grp_total;//Set New Group Total
printf("\nNew Bill Amount Set !!");
hold_screen();
break;
case '5':
if(entry==0)
printf("No Entry Fee Is Set");
else
{
printf("\t\t\tHere you can set new entry amount\n\n");
set_entry_fee();
grp_tot=bill_amt-per_tot+entry-sub_grp_total;//Set New Group Total
}
hold_screen();
break;
case '6':
if(sub_grp_total<=0)
printf("No existing group activity !!");
else
{
printf("\t\t\tHere You Can Remove Group Activity\n\n");
set_group_activity(*head,0);
printf("\n\tGroup Activity Removed !!");
}
hold_screen();
break;
case 8:
return;
}
}
}
int member_exec( struct ast_channel* chan, void* data ) {
int left = 0 ;
int res;
struct ast_conference *conf = NULL;
struct ast_conf_member *member = NULL;
struct ast_frame *f = NULL;
struct ast_app *app = NULL;
ast_log( AST_CONF_DEBUG, "Launching NConference %s\n", "$Revision: 2325 $" ) ;
// make sure we have a channel to process
if ( chan == NULL )
{
ast_log( LOG_NOTICE, "member channel has closed\n" ) ;
return -1 ;
}
if (chan->_state != AST_STATE_UP)
if ( (res = ast_answer( chan )) )
{
ast_log( LOG_ERROR, "unable to answer call\n" ) ;
return -1 ;
}
member = create_member( chan, (const char*)( data ) ) ;
// unable to create member, return an error
if ( member == NULL )
{
ast_log( LOG_ERROR, "unable to create member\n" ) ;
return -1 ;
}
//
// setup Openpbx read/write formats
//
//ast_log( AST_CONF_DEBUG,
// "CHANNEL INFO, CHANNEL => %s, DNID => %s, CALLER_ID => %s, ANI => %s\n",
// chan->name, chan->cid.cid_dnid, chan->cid.cid_num, chan->cid.cid_ani ) ;
ast_log( AST_CONF_DEBUG,
"CHANNEL CODECS, CHANNEL => %s, NATIVE => %d, READ => %d, WRITE => %d\n",
chan->name, chan->nativeformats, member->read_format, member->write_format ) ;
if ( ast_set_read_format( chan, member->read_format ) < 0 )
{
ast_log( LOG_ERROR, "unable to set read format.\n" ) ;
delete_member( member ) ;
return -1 ;
}
// for right now, we'll send everything as slinear
if ( ast_set_write_format( chan, member->write_format ) < 0 )
{
ast_log( LOG_ERROR, "unable to set write format.\n" ) ;
delete_member( member ) ;
return -1 ;
}
//
// setup a conference for the new member
//
conf = start_conference( member ) ;
if ( conf == NULL )
{
ast_log( LOG_ERROR, "unable to setup member conference\n" ) ;
delete_member( member) ;
return -1 ;
} else {
if (conf->is_locked && (member->type != MEMBERTYPE_MASTER) ) {
if (strlen(conf->pin) == 0 || strncmp(conf->pin,member->pin,sizeof(conf->pin)) ) {
/* Conference is Locked and an invalid PIN was entered */
remove_member(conf, member);
return -2 ;
}
} else {
member->conf = conf;
if ( member->type == MEMBERTYPE_MASTER )
conf->auto_destroy = member->auto_destroy;
}
}
if ( member->type == MEMBERTYPE_MASTER ) {
conf->auto_destroy = member->auto_destroy;
if ( strlen( member->pin ) > 0 ) {
strncpy(conf->pin,member->pin,sizeof(conf->pin));
ast_log( AST_CONF_DEBUG, "Conference pin set to => %s\n", conf->pin ) ;
}
}
//
// process loop for new member ( this runs in it's own thread
//
ast_log( AST_CONF_DEBUG, "begin member event loop, channel => %s\n", chan->name ) ;
// Add user to monitor
if (member->monitor) {
const char * const monitorfilename = pbx_builtin_getvar_helper(chan, "MONITOR_FILENAME");
if (monitorfilename) {
ast_monitor_start(chan, NULL, monitorfilename, 1);
} else if (chan->cdr) {
ast_monitor_start(chan, NULL, chan->cdr->uniqueid, 1);
} else {
char tmpid[256];
snprintf(tmpid, sizeof(tmpid), "chan-%x", rand());
ast_monitor_start(chan, NULL, tmpid, 1);
}
if (member->monitor_join) {
ast_monitor_setjoinfiles(chan, 1);
}
}
// Run AGI script
if (member->agi) {
char * agi = pbx_builtin_getvar_helper(chan, "AGI_CONF_JOIN");
if (agi) {
app = pbx_findapp("agi");
if (app) {
pbx_exec(chan, app, agi, 1);
}
} else {
ast_log(LOG_WARNING, "AGI requested, but AGI_CONF_JOIN missing.\n");
}
conf->agi = 1 ;
}
// Activate the generator for the channel.
res = ast_conf_member_genactivate( member );
if ( !res ) {
member->force_remove_flag = 1;
ast_log( AST_CONF_DEBUG, "member marked for removal => %s\n", chan->name ) ;
}
//Play the join info messages
if (!member->force_remove_flag && !member->quiet_mode && !member->mute_incoming_sounds) {
if (ast_strlen_zero(member->intro_sounds)) {
conference_queue_sound( member, "conf-youareinconfnum" );
conference_queue_number( member, member->id );
}
}
// The member at the very beginningis speaking
member->is_speaking = 1 ;
// tell conference_exec we're ready for frames
member->active_flag = 1 ;
//Main loop.
while ( !member->force_remove_flag || member->soundq != NULL )
{
#ifdef SOLARIS
struct timespec rqtp;
rqtp.tv_sec = 0;
rqtp.tv_nsec = 1000000;
if (nanosleep(&rqtp, (struct timespec *) NULL) == -1) {
ast_log(LOG_NOTICE, "Nanosleep timer errored.\n");
}
#else
usleep(1000);
#endif
//-----------------//
// INCOMING FRAMES //
//-----------------//
if ( member->force_remove_flag == 1 ) {
// break to the loop
break;
}
// wait for an event on this channel
int waittime = ( member->framelen == 0 ) ? AST_CONF_WAITFOR_TIME : member->framelen;
left = ast_waitfor( chan, waittime ) ;
if ( left < 0 )
{
// an error occured
ast_log(
LOG_NOTICE,
"an error occured waiting for a frame, channel => %s, error => %d\n",
chan->name, left
) ;
}
else if ( left == 0 )
{
// No frame avalaible
member->lostframecount ++;
// We have lost a frame.
// In this case, we queue some silence
// Sothat if we keep loosing frames,
// there will be no glitching in the conference.
// Set the speaking state to 0.
if ( member->lostframecount == 1 ) {
queue_incoming_silent_frame(member,1);
}
member->is_speaking = 0;
}
else if ( left > 0 )
{
// a frame has come in before the latency timeout
// was reached, so we process the frame
// let's reset the lost frame count
if ( member->lostframecount ) {
member->lostframecount = 0;
// If vad is not enabled, then set the speaking state back to 1
if ( !member->enable_vad )
member->is_speaking = 1;
}
f = ast_read( chan ) ;
if ( f == NULL )
{
ast_log( AST_CONF_DEBUG, "unable to read from channel, channel => %s. Got Hangup.\n", chan->name ) ;
queue_incoming_silent_frame(member,5);
member->is_speaking = 0;
break ;
}
else {
/*
ast_log( AST_CONF_DEBUG,
"Read (PRE dsp), channel => %s, datalen: %d samplefreq: %ld len: %ld samples %d class: %d\n",
chan->name, f->datalen, member->samplefreq, f->len, f->samples, f->subclass) ;
*/
#if 0 == 1
if ( member->samplefreq == 0 && f->samples != 0 )
{
if ( ( f->len == 0 ) && ( f->datalen == 320 ) && ( f->samples == 160 ) )
member->framelen = 20; // This is probably chan_zap not setting the correct len.
else
member->framelen = f->len; // frame length in milliseconds
member->datalen = f->datalen; // frame length in milliseconds
member->samples = f->samples; // number of samples in framelen
member->samplefreq = (int)(member->samples/member->framelen)*1000; // calculated sample frequency
ast_log( AST_CONF_DEBUG, "MEMBER FRAME DATA: datalen %d samples %d len(ms) %ld, offset: %d \n", f->datalen, f->samples, f->len, f->offset );
}
if (
( (member->framelen != f->len ) && ( f->len !=0 ) )
||
( (member->samples != f->samples ) && ( f->samples !=0 ) && ( f->len !=0 ) )
)
{
ast_log( AST_CONF_DEBUG, "FRAME CHANGE : samples %d len(ms) %ld\n", f->samples, f->len );
ast_log( AST_CONF_DEBUG, "FRAME SHOULDBE: samples %d len(ms) %ld\n", member->samples, member->framelen );
if (member->samples == 0 ) {
member->framelen = f->len; // frame length in milliseconds
member->datalen = f->datalen; // frame length in milliseconds
member->samples = f->samples; // number of samples in framelen
member->samplefreq = (int) ( f->samples/f->len)*1000; // calculated sample frequency
}
}
#endif
member->framelen = f->datalen;
// This fix is for chan_zap
// Chan_zap NEVER sets framelen value.
// Probably when adding support to 16Khz we should add a check for this.
if ( ( member->framelen == 0 ) && ( member->datalen == 320 ) && ( member->samples == 160 ) )
member->framelen = 20;
}
}
// actually process the frame.
res = process_incoming(member, f);
if (member->force_remove_flag)
member->remove_flag = 1 ;
}
// Run AGI script
if (member->agi) {
char * agi = pbx_builtin_getvar_helper(chan, "AGI_CONF_LEAVE");
if (agi) {
app = pbx_findapp("agi");
if (app) {
pbx_exec(chan, app, agi, 1);
}
} else {
ast_log(LOG_WARNING, "AGI requested, but AGI_CONF_LEAVE missing.\n");
}
}
if (conf->agi)
handle_conf_agi_end(conf->name, member);
member->remove_flag = 1 ;
ast_log( AST_CONF_DEBUG, "end member event loop, time_entered => %ld - removal: %d\n", member->time_entered.tv_sec, member->remove_flag ) ;
//ast_log( AST_CONF_DEBUG, "Deactivating generator - Channel => %s\n", member->chan->name ) ;
ast_generator_deactivate(chan);
if (member->hangup_go_on) {
ast_log(AST_CONF_DEBUG, "Hangup go on!\n");
return 0;
}
return -1 ;
}
static int callback_nyx_websockets(struct libwebsocket_context *context,struct libwebsocket *wsi,enum libwebsocket_callback_reasons reason, void *user,void *in,size_t len)
{
struct per_session_data_nyx *pss =(struct per_session_data_nyx*)user;
int n;
node *wsd_state = (node*)libwebsocket_context_user(context);
//node *daemon = (node*)libwebsocket_context_user(context);
//node *wsd_state = node_GetNode(get_value(daemon));
node *found_prot = NULL;
node *state = NULL;
node *block = NULL;
//node *daemon = NULL;
node *daemon_obj = NULL;
node *session_uid = NULL;
long lsession_uid = 0;
node *sessions_num = NULL;
node *sessions = NULL;
long lsessions_num = 0;
if(wsd_state)
{
state = node_GetItem(wsd_state,0);
block = node_GetItem(wsd_state,1);
//daemon = node_GetItem(wsd_state,2);
node *protocols = node_GetItem(wsd_state,3);
session_uid = node_GetItem(wsd_state,4);
node *session_uid_value = node_GetItemByKey(session_uid,"value");
lsession_uid = node_GetSint32(session_uid_value);
sessions_num = node_GetItem(wsd_state,5);
sessions = node_GetItem(wsd_state,6);
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
lsessions_num = node_GetSint32(sessions_num_value);
daemon_obj = node_GetItem(wsd_state,9);
if(wsi)
{
node *protocols_items = node_GetItemByKey(protocols,"items");
const struct libwebsocket_protocols *prot = libwebsockets_get_protocol(wsi);
if(prot && prot->name)
{
node_ItemIterationReset(protocols_items);
while(node_ItemIterationUnfinished(protocols_items))
{
node *proto = node_ItemIterate(protocols_items);
if(!strcmp(get_obj_name(proto),prot->name))
{
found_prot = proto;
}
}
}
}
}
switch(reason)
{
//case LWS_CALLBACK_SERVER_NEW_CLIENT_INSTANTIATED:
case LWS_CALLBACK_CLIENT_ESTABLISHED:
printf("new session created:%d, num:%d\n",lsession_uid,lsessions_num);
pss->session = NULL;
break;
case LWS_CALLBACK_HTTP:
if(len < 1)
{
libwebsockets_return_http_status(context,wsi,HTTP_STATUS_BAD_REQUEST,NULL);
return(-1);
}
if(lws_hdr_total_length(wsi,WSI_TOKEN_POST_URI))
return(0);
if(found_prot)
{
//printf("found prot in http callback : uid:%d,num:%d (sess:%x)\n",lsession_uid+1,lsessions_num,pss->session);
if(!pss->session)
{
lsession_uid++;
node *session_uid_value = node_GetItemByKey(session_uid,"value");
node_SetSint32(session_uid_value,lsession_uid);
lsessions_num++;
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
node_SetSint32(sessions_num_value,lsessions_num);
pss->session = create_session(state,sessions,lsession_uid,get_obj_name(found_prot));
node *session_privates = node_GetItemByKey(pss->session,"privates");
set_obj_int(session_privates,"is_http",1);
//printf("created new session :%d actual sessions num:%d\n",lsession_uid,lsessions_num);
}
node *parameters = create_obj("parameters");
node *base_class = get_base_class(state);
node *prot_value = create_class_instance(base_class);
set_obj_string(prot_value,"name","protocol");
set_obj_string(prot_value,"value",get_obj_name(found_prot));
node_AddItem(parameters,prot_value);
inc_obj_refcount(prot_value);
char *url = str_CreateEmpty();
url = str_AddChars(url,in,len);
node *url_value = create_class_instance(base_class);
set_obj_string(url_value,"name","url");
set_obj_string(url_value,"value",url);
node_AddItem(parameters,url_value);
inc_obj_refcount(url_value);
free(url);
node_AddItem(parameters,pss->session);
inc_obj_refcount(pss->session);
//node_AddItem(parameters,daemon_obj);
node_AddItem(parameters,sessions);
inc_obj_refcount(sessions);
node *tmp_parent = node_GetParent(found_prot);
node *bmembers = node_GetItemByKey(block,"members");
node_SetParent(found_prot,bmembers);
node *ret_obj = execute_obj(state,found_prot,block,parameters,True,False);//,True);resolve
node_SetParent(found_prot,tmp_parent);
//dec_obj_refcount(msg_value);
dec_obj_refcount(prot_value);
//add_garbage(state,msg_value);//TODO check if "just survives"
add_garbage(state,prot_value);
dec_obj_refcount(url_value);
add_garbage(state,url_value);
dec_obj_refcount(pss->session);
dec_obj_refcount(sessions);
node *ret_obj_value = node_GetItemByKey(ret_obj,"value");
if( (node_GetType(ret_obj_value)==NODE_TYPE_STRING && strlen(node_GetString(ret_obj_value))) || (node_GetType(ret_obj_value)==NODE_TYPE_BINARY && node_GetBinaryLength(ret_obj_value)) )
{
//printf("returning http message: [%s] :%d\n",node_GetString(ret_obj_value),strlen(node_GetString(ret_obj_value)));
//node *ret_obj_copy = node_CopyTree(ret_obj,True,True);
node *ret_obj_copy = copy_class(ret_obj);
//reset_obj_refcount(ret_obj_copy);
set_obj_string(ret_obj_copy,"name","message");
add_member(pss->session,ret_obj_copy);
inc_obj_refcount(ret_obj_copy);
}
libwebsocket_callback_on_writable(context, wsi);
}
break;
case LWS_CALLBACK_HTTP_BODY_COMPLETION:
if(found_prot)
{
printf("found prot in http body complete : %d,num:%d\n",lsession_uid,lsessions_num);
if(daemon_obj)
{
printf("body: found daemon_obj\n");
}
}
else
printf("body closed: prot not found\n");
//lwsl_notice("LWS_CALLBACK_HTTP_BODY_COMPLETION\n");
libwebsockets_return_http_status(context,wsi,HTTP_STATUS_OK,NULL);
return(-1);
case LWS_CALLBACK_HTTP_FILE_COMPLETION:
if(found_prot)
{
//printf("found prot in http file complete : %d,num:%d\n",lsession_uid,lsessions_num);
lsessions_num--;
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
node_SetSint32(sessions_num_value,lsessions_num);
delete_session(state,sessions,pss->session);
pss->session = NULL;
if(daemon_obj)
{
printf("http: found daemon_obj\n");
}
}
else
printf("file closed: prot not found\n");
return(-1);
case LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION:
if(found_prot)
{
int n;
static const char *token_names[] =
{
/*[WSI_TOKEN_GET_URI] =*/ "GET URI",
/*[WSI_TOKEN_POST_URI] =*/ "POST URI",
/*[WSI_TOKEN_OPTIONS] =*/ "Options",
/*[WSI_TOKEN_HOST] =*/ "Host",
/*[WSI_TOKEN_CONNECTION] =*/ "Connection",
/*[WSI_TOKEN_KEY1] =*/ "key 1",
/*[WSI_TOKEN_KEY2] =*/ "key 2",
/*[WSI_TOKEN_PROTOCOL] =*/ "Protocol",
/*[WSI_TOKEN_UPGRADE] =*/ "Upgrade",
/*[WSI_TOKEN_ORIGIN] =*/ "Origin",
/*[WSI_TOKEN_DRAFT] =*/ "Draft",
/*[WSI_TOKEN_CHALLENGE] =*/ "Challenge",
/* new for 04 */
/*[WSI_TOKEN_KEY] =*/ "Key",
/*[WSI_TOKEN_VERSION] =*/ "Version",
/*[WSI_TOKEN_SWORIGIN] =*/ "Sworigin",
/* new for 05 */
/*[WSI_TOKEN_EXTENSIONS] =*/ "Extensions",
/* client receives these */
/*[WSI_TOKEN_ACCEPT] =*/ "Accept",
/*[WSI_TOKEN_NONCE] =*/ "Nonce",
/*[WSI_TOKEN_HTTP] =*/ "Http",
"Accept:",
"Accept_Request_Headers:",
"If-None-Match:",
"If-Modified-Since:",
"Accept-Encoding:",
"Accept-Language:",
"Pragma:",
"Cache-Control:",
"Authorization:",
"Cookie:",
"Content-Length:",
"Content-Type:",
"Date:",
"Range:",
"Referer:",
"Uri-Args:",
/*[WSI_TOKEN_MUXURL] =*/ "MuxURL",
};
//printf("found prot in http filter callback : uid:%d,num:%d (sess:%x)\n",lsession_uid+1,lsessions_num,pss->session);
if(!pss->session)
{
lsession_uid++;
node *session_uid_value = node_GetItemByKey(session_uid,"value");
node_SetSint32(session_uid_value,lsession_uid);
lsessions_num++;
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
node_SetSint32(sessions_num_value,lsessions_num);
pss->session = create_session(state,sessions,lsession_uid,get_obj_name(found_prot));
//node *session_privates = node_GetItemByKey(pss->session,"privates");
//set_obj_int(session_privates,"is_http",1);
}
//printf("filter sess:%x\n",pss->session);
for(n=0;n<(int)(sizeof(token_names)/sizeof(token_names[0]));n++)
{
if (!lws_hdr_total_length(wsi, n))
continue;
char *cookies = (char*)malloc(512);
memset(cookies,0,512);
lws_hdr_copy(wsi,cookies,511,n);
//printf("header:%s = [%s]\n",token_names[n],cookies);
//fflush(stdout);
if(pss->session && !strcmp("Cookie:",token_names[n]))
{
//printf("cookie found:%s = [%s]\n",token_names[n],cookies);
//fflush(stdout);
node *base_class = get_base_class(state);
node *cookie_value = create_class_instance(base_class);
set_obj_string(cookie_value,"name","cookie");
set_obj_string(cookie_value,"value",cookies);
add_member(pss->session,cookie_value);
inc_obj_refcount(cookie_value);
}
free(cookies);
}
}
break;
case LWS_CALLBACK_HTTP_WRITEABLE:
case LWS_CALLBACK_SERVER_WRITEABLE:
{
//node_PrintTree(pss->session);
node *message = get_member(pss->session,"message");
node *session_privates = node_GetItemByKey(pss->session,"privates");
node *http_only = node_GetItemByKey(session_privates,"is_http");
while(message)
{
//node *session_id = get_member(pss->session,"id");
//node *session_id_value = node_GetItemByKey(session_id,"value");
node *message_value = node_GetItemByKey(message,"value");
unsigned char *me = NULL;
unsigned long me_len = 0;
if(node_GetType(message_value)==NODE_TYPE_STRING)
{
me = (unsigned char*)node_GetString(message_value);
me_len = strlen((char*)me);
}
else if(node_GetType(message_value)==NODE_TYPE_BINARY)
{
me = (unsigned char*)node_GetBinary(message_value);
me_len = node_GetBinaryLength(message_value);
}
//printf("sending message now: [%s] to: %d\n",me,node_GetSint32(session_id_value));
//fflush(stdout);
unsigned char *buf = (unsigned char*)malloc(LWS_SEND_BUFFER_PRE_PADDING + me_len + LWS_SEND_BUFFER_POST_PADDING);
memcpy(buf+LWS_SEND_BUFFER_PRE_PADDING,me,me_len);
if(http_only)
//n = libwebsocket_write(wsi, me, me_len, LWS_WRITE_HTTP);
n = libwebsocket_write(wsi,buf+LWS_SEND_BUFFER_PRE_PADDING,me_len,LWS_WRITE_HTTP);
else
//n = libwebsocket_write(wsi, me, me_len, LWS_WRITE_TEXT);
n = libwebsocket_write(wsi,buf+LWS_SEND_BUFFER_PRE_PADDING,me_len,LWS_WRITE_TEXT);
free(buf);
if(n<0)
{
printf("ERROR %d writing to socket, hanging up\n", n);
return(1);
}
if(n<(long)me_len)
{
printf("Partial write\n");
return(-1);
}
//node_FreeTree(pss->message);
remove_member(pss->session,message);
dec_obj_refcount(message);
//printf("removing message from queue:%x (%d)\n",message,get_obj_refcount(message));
add_garbage(state,message);
message = get_member(pss->session,"message");
}
if(http_only)
{
//if(lws_http_transaction_completed(wsi))
//{
//printf("removing http session num:%d\n",lsessions_num);
lsessions_num--;
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
node_SetSint32(sessions_num_value,lsessions_num);
delete_session(state,sessions,pss->session);
pss->session = NULL;
//printf("removed http\n");
return -1;
//return(-1);
//}
//else
// libwebsocket_callback_on_writable(context, wsi);
}
}
break;
case LWS_CALLBACK_ESTABLISHED:
if(found_prot)
{
//printf("found prot in establish callback : uid:%d,num:%d (sess:%x)\n",lsession_uid+1,lsessions_num,pss->session);
if(!pss->session)
{
lsession_uid++;
node *session_uid_value = node_GetItemByKey(session_uid,"value");
node_SetSint32(session_uid_value,lsession_uid);
lsessions_num++;
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
node_SetSint32(sessions_num_value,lsessions_num);
pss->session = create_session(state,sessions,lsession_uid,get_obj_name(found_prot));
}
if(daemon_obj)
{
node *connect_handler = get_member(daemon_obj,"connect_handler");
if(connect_handler)
{
connect_handler = resolve_object(state,connect_handler);
node *parameters = create_obj("parameters");
node *base_class = get_base_class(state);
node *prot_value = create_class_instance(base_class);
set_obj_string(prot_value,"name","protocol");
set_obj_string(prot_value,"value",get_obj_name(found_prot));
node_AddItem(parameters,prot_value);
inc_obj_refcount(prot_value);
node_AddItem(parameters,pss->session);
inc_obj_refcount(pss->session);
node_AddItem(parameters,sessions);
inc_obj_refcount(sessions);
node *tmp_parent = node_GetParent(connect_handler);
node *bmembers = node_GetItemByKey(block,"members");
node_SetParent(connect_handler,bmembers);
node *ret_obj = execute_obj(state,connect_handler,block,parameters,True,False);//,True);resolve
node_SetParent(connect_handler,tmp_parent);
dec_obj_refcount(prot_value);
add_garbage(state,prot_value);
dec_obj_refcount(pss->session);
dec_obj_refcount(sessions);
node *ret_obj_value = node_GetItemByKey(ret_obj,"value");
if(node_GetType(ret_obj_value)==NODE_TYPE_STRING && strlen(node_GetString(ret_obj_value)))
{
}
}
}
}
break;
case LWS_CALLBACK_CLOSED_HTTP:
break;
case LWS_CALLBACK_CLOSED:
case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
if(found_prot)
{
//printf("found prot in closed callback : uid:%d,num:%d (sess:%x)\n",lsession_uid,lsessions_num,pss->session);
if(daemon_obj)
{
//printf("closed: found daemon_obj\n");
node *disconnect_handler = get_member(daemon_obj,"disconnect_handler");
if(disconnect_handler)
{
//printf("disc found\n");
disconnect_handler = resolve_object(state,disconnect_handler);
node *parameters = create_obj("parameters");
node *base_class = get_base_class(state);
node *prot_value = create_class_instance(base_class);
set_obj_string(prot_value,"name","protocol");
set_obj_string(prot_value,"value",get_obj_name(found_prot));
node_AddItem(parameters,prot_value);
inc_obj_refcount(prot_value);
node_AddItem(parameters,pss->session);
inc_obj_refcount(pss->session);
node_AddItem(parameters,sessions);
inc_obj_refcount(sessions);
node *tmp_parent = node_GetParent(disconnect_handler);
node *bmembers = node_GetItemByKey(block,"members");
node_SetParent(disconnect_handler,bmembers);
node *ret_obj = execute_obj(state,disconnect_handler,block,parameters,True,False);//,True);resolve
node_SetParent(disconnect_handler,tmp_parent);
dec_obj_refcount(prot_value);
add_garbage(state,prot_value);
dec_obj_refcount(pss->session);
dec_obj_refcount(sessions);
node *ret_obj_value = node_GetItemByKey(ret_obj,"value");
if(node_GetType(ret_obj_value)==NODE_TYPE_STRING && strlen(node_GetString(ret_obj_value)))
{
}
}
}
lsessions_num--;
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
node_SetSint32(sessions_num_value,lsessions_num);
delete_session(state,sessions,pss->session);
pss->session = NULL;
//printf("disconnected\n");
}
else
{
printf("closed connection without prot found\n");
if(pss->session)
printf("but a session was found\n");
}
break;
case LWS_CALLBACK_RECEIVE:
if(len>1024)
{ //TODO use some variable
lwsl_err("Server received packet bigger than %u, hanging up\n", 1024);
return(1);
}
if(found_prot)
{
node *parameters = create_obj("parameters");
node *base_class = get_base_class(state);
node *prot_value = create_class_instance(base_class);
set_obj_string(prot_value,"name","protocol");
set_obj_string(prot_value,"value",get_obj_name(found_prot));
node_AddItem(parameters,prot_value);
inc_obj_refcount(prot_value);
char *msg = str_CreateEmpty();
msg = str_AddChars(msg,in,len);
node *msg_value = create_class_instance(base_class);
set_obj_string(msg_value,"name","message");
set_obj_string(msg_value,"value",msg);
node_AddItem(parameters,msg_value);
inc_obj_refcount(msg_value);
free(msg);
/*node *session_value = create_class_instance(base_class);
reset_obj_refcount(session_value);
add_garbage(state,session_value);
set_obj_string(session_value,"name","session_id");
set_obj_int(session_value,"value",lsession_uid);
set_obj_int(session_value,"item_index",2);
node_AddItem(parameters,session_value);
*/
node_AddItem(parameters,pss->session);
inc_obj_refcount(pss->session);
//node_AddItem(parameters,daemon_obj);
//inc_obj_refcount(daemon_obj);
node_AddItem(parameters,sessions);
inc_obj_refcount(sessions);
//printf("recv callback\n");
//fflush(stdout);
node *tmp_parent = node_GetParent(found_prot);
node *bmembers = node_GetItemByKey(block,"members");
node_SetParent(found_prot,bmembers);
node *ret_obj = execute_obj(state,found_prot,block,parameters,True,False);//,True);resolve
node_SetParent(found_prot,tmp_parent);
//printf("recv callback finished\n");
//fflush(stdout);
dec_obj_refcount(msg_value);
dec_obj_refcount(prot_value);
add_garbage(state,msg_value);//TODO check if "just survives"
add_garbage(state,prot_value);
dec_obj_refcount(pss->session);
dec_obj_refcount(sessions);
//dec_obj_refcount(daemon_obj);
//printf("recv gc\n");
//fflush(stdout);
//node *ret_obj_value = node_GetItemByKey(ret_obj,"value");
//char *me = node_GetString(ret_obj_value);
//printf("returned string:[%s]\n",me);
node *ret_obj_value = node_GetItemByKey(ret_obj,"value");
if(node_GetType(ret_obj_value)==NODE_TYPE_STRING && strlen(node_GetString(ret_obj_value)))
{
//printf("returning message: [%s] :%d\n",node_GetString(ret_obj_value),strlen(node_GetString(ret_obj_value)));
//node *ret_obj_copy = node_CopyTree(ret_obj,True,True);
node *ret_obj_copy = copy_class(ret_obj);
//reset_obj_refcount(ret_obj_copy);
set_obj_string(ret_obj_copy,"name","message");
add_member(pss->session,ret_obj_copy);
inc_obj_refcount(ret_obj_copy);
//set_obj_string(ret_obj,"name","message");
//add_member(pss->session,ret_obj);
//inc_obj_refcount(ret_obj);
}
libwebsocket_callback_on_writable(context, wsi);
}
break;
default:
break;
}
return(0);
}
int main( void )
{
int i;
/* holds both command characters */
char command[ 2 ];
/* set up the three libraries */
struct Ordered_container* lib_title = OC_create_container( comp_Record_by_title );
struct Ordered_container* lib_ID = OC_create_container( comp_Record_by_ID );
struct Ordered_container* catalog = OC_create_container( comp_Collection_by_name );
for ( ; ; )
{
printf( "\nEnter command: " );
/* load the command chars */
for ( i = 0 ; i < 2; ++i)
{
command[ i ] = get_command_char();
}
switch ( command[ 0 ] )
{
case 'f' :/* find (records only)*/
switch ( command[ 1 ] )
{
case 'r' :
find_record_print( lib_title );
break;
default:
print_error_clear( "Unrecognized command!\n");
break;
}
break;
case 'p' : /* print */
switch ( command[ 1 ] )
{
case 'r' :
print_record( lib_ID );
break;
case 'L':
print_containter( lib_title, "Library", "records", (void (*)(void*))print_Record );
break;
case 'C':
/* print_catalog( catalog ); */
print_containter( catalog, "Catalog", "collections", (void (*)(void*))print_Collection );
break;
case 'a': /* allocation */
print_allocation( lib_title, lib_ID, catalog );
break;
case 'c':
print_collection_main( catalog );
break;
default:
print_error_clear( "Unrecognized command!\n");
break;
}
break;
case 'm': /* modify (rating only) */
switch ( command[ 1 ] )
{
case 'r':
modify_rating( lib_ID );
break;
default:
print_error_clear( "Unrecognized command!\n");
break;
}
break;
case 'a' : /* add */
switch ( command[ 1 ] )
{
case 'r' :
add_record( lib_title, lib_ID );
break;
case 'c':
add_coll( catalog );
break;
case 'm':
add_member( lib_ID , catalog );
break;
case 'a': /* allocation */
/* throw error */
print_error_clear( "Unrecognized command!\n");
break;
default:
break;
}
break;
case 'd': /* delete */
switch ( command[ 1 ] )
{
case 'r' :
delete_record( lib_title, lib_ID, catalog );
break;
case 'c':
delete_collection( catalog );
break;
case 'm':
remove_member( lib_ID , catalog );
break;
case 'a': /* allocation */
/* throw error */
break;
default:
print_error_clear( "Unrecognized command!\n");
break;
}
break;
case 'c': /* clear */
switch ( command[ 1 ] )
{
case 'L':
clear_library( lib_title, lib_ID, catalog, "All records deleted\n" );
break;
case 'C':
clear_container( catalog, ( void(*)(void*) )destroy_Collection, "All collections deleted\n" );
break;
case 'A':
clear_all(lib_title, lib_ID, catalog, "All data deleted\n" );
break;
default:
print_error_clear( "Unrecognized command!\n");
break;
}
break;
case 's': /* save */
switch ( command[ 1 ] ) {
case 'A':
save_all_to_file( lib_title, catalog );
break;
default:
print_error_clear( "Unrecognized command!\n");
break;
}
break;
case 'r': /* restore */
switch ( command[ 1 ] ) {
case 'A':
load_from_file( lib_title, lib_ID, catalog );
break;
default:
print_error_clear( "Unrecognized command!\n");
break;
}
break;
case 'q':
switch ( command[ 1 ] )
{
case 'q':
/* clean up memory */
quit( lib_title, lib_ID, catalog );
break;
default:
print_error_clear( "Unrecognized command!\n");
break;
}
default:
/* throw error for bad input */
print_error_clear( "Unrecognized command!\n");
break;
}
}
return 0;
}
static void remove_button_proc(struct menu_item *item, void *data)
{
struct member_data *member_data = data;
remove_member(member_data->data, member_data->index);
}
static void conference_exec( struct cw_conference *conf )
{
struct cw_conf_member *member, *temp_member ;
struct timeval empty_start = {0,0}, tv = {0,0} ;
cw_log( CW_CONF_DEBUG, "Entered conference_exec, name => %s\n", conf->name ) ;
//
// main conference thread loop
//
while ( 1 )
{
//Acquire the mutex
cw_mutex_lock( &conf->lock );
// get list of conference members
member = conf->memberlist ;
// loop over member list to retrieve queued frames
while ( member != NULL )
{
cw_mutex_lock( &member->lock ) ;
// check for dead members
if ( member->remove_flag == 1 )
{
char cnum[80];
cw_log( CW_CONF_DEBUG, "found member slated for removal, channel => %s\n", member->channel_name ) ;
temp_member = member->next ;
if (member->cid.cid_num != NULL)
strncpy( cnum,member->cid.cid_num,sizeof(cnum) );
else
cnum[0] = '\0';
queue_incoming_silent_frame(member,2);
remove_member( conf, member ) ;
member = temp_member ;
if(member && member->beep_only_mode == 0){
add_command_to_queue( conf, NULL, CONF_ACTION_QUEUE_NUMBER , 1, cnum );
add_command_to_queue( conf, NULL, CONF_ACTION_QUEUE_SOUND , 1, "conf-hasleft" );
} else if (member && member->beep_only_mode == 1) {
add_command_to_queue( conf, NULL, CONF_ACTION_QUEUE_SOUND , 1, "beeperr" );
}
continue ;
}
cw_mutex_unlock( &member->lock ) ;
// adjust our pointer to the next inline
member = member->next ;
}
//
// break, if we have no more members
//
if ( conf->memberlist == NULL ) {
if ( empty_start.tv_sec == 0 )
gettimeofday( &empty_start, NULL );
if (conf->auto_destroy) {
cw_log( CW_CONF_DEBUG, "removing conference, count => %d, name => %s\n", conf->membercount, conf->name ) ;
remove_conf( conf ) ; // stop the conference
break ; // break from main processing loop
} else {
//cw_log( CW_CONF_DEBUG, "Delaying conference removal. Auto destroy is not set.\n" ) ;
gettimeofday( &tv, NULL ) ;
if ( tv.tv_sec - empty_start.tv_sec > CW_CONF_DESTROY_TIME )
conf->auto_destroy=1;
}
} else {
empty_start.tv_sec = 0;
}
//
// Check for the commands to be executed by the conference
//
if (conf->command_queue)
cw_conf_command_execute( conf );
//---------//
// CLEANUP //
//---------//
// release conference mutex
cw_mutex_unlock( &conf->lock ) ;
//Sleep for 1ms (relax)
usleep(1000);
} // end while ( 1 )
//
// exit the conference thread
//
cw_log( CW_CONF_DEBUG, "exit conference_exec\n" ) ;
// exit the thread
pthread_exit( NULL ) ;
return ;
}
int
main(int argc, char **argv) {
int i;
char c;
int maxfd;
fd_set rset;
fd_set allset;
int num_ready_fds;
struct timeval *time_out;
struct timeval tv;
bzero(&log_file_name, MAX_FILE_NAME_LEN);
log_flag = 0;
bzero(&room_file_name, MAX_FILE_NAME_LEN);
time_out = (struct timeval *)NULL;
sweep_int = 0;
/* process arguments */
while((c = getopt(argc, argv, optstr)) != -1){
switch(c) {
case 't':
server_tcp_port = atoi(optarg);
break;
case 'u':
server_udp_port = atoi(optarg);
break;
case 'f':
strncpy(log_file_name, optarg, MAX_FILE_NAME_LEN);
break;
case 's':
sweep_int = atoi(optarg);
sweep_int *= 60; /* convert to seconds */
tv.tv_sec = sweep_int;
tv.tv_usec = 0;
if(sweep_int != 0)
time_out = &tv;
break;
case 'r':
strncpy(room_file_name, optarg, MAX_FILE_NAME_LEN);
break;
default:
printf("invalid option\n");
break;
}
}
if(server_tcp_port == 0 || server_udp_port == 0) {
usage(argv);
}
if(log_file_name[0] != 0 ) {
log_flag = 1;
if( (logfp = fopen(log_file_name, "a+")) == NULL) {
perror("fopen");;
exit(1);
}
}
/* initialize tcp and udp server; create rooms if config file present */
init_server();
/* usual preparation stuff for select() */
FD_ZERO(&allset);
FD_SET(tcp_socket_fd, &allset);
FD_SET(udp_socket_fd, &allset);
maxfd = ((udp_socket_fd > tcp_socket_fd) ? udp_socket_fd : tcp_socket_fd);
/*
* server sits in an infinite loop waiting for events
*
* three things can happen:
* 1. chat client connects to server through tcp and sends
* control messages;
* 2. chat client sends chat messages through udp
* 3. server times out periodically to remove dormant/crashed
* clients and rooms that do not have a member
* if time_out == NULL, server will not time out, so 3. won't happen
*/
for( ; ; ) {
rset = allset;
if((num_ready_fds = select(maxfd+1, &rset, NULL, NULL, time_out)) < 0) {
perror("select");
exit(1);
}
if(num_ready_fds <=0 ) {
/* due to time out */
struct member_type *mt;
struct room_type *rt;
/* go through the member list and sweep members that are there for
more than 1 sweep interval without messages */
mt = mem_list_hd;
while(mt != NULL) {
struct member_type *tmp_mt;
tmp_mt=mt->next_member;
if(mt->quiet_flag == 0) {
/* active in the last time interval */
mt->quiet_flag ++ ;
} else {
/* remove this member */
remove_member(mt);
if(log_flag) {
char *tp;
now = time(NULL);
tp = ctime(&now);
tp[strlen(tp)-1] = '\0';
fprintf(logfp,
"%s member [%s] is removed from the session\n",
tp, mt->member_name);
fprintf(logfp, "Total number of members:%d\n",
total_num_of_members);
fflush(logfp);
}
free(mt);
}
mt = tmp_mt;
}
/* go through room list */
rt = room_list_hd;
while(rt != NULL) {
struct room_type *tmp_rt;
tmp_rt = rt->next_room;
if(rt->num_of_members == 0) {
if(rt->empty_flag == 0 ) {
rt->empty_flag ++;
} else {
/* remove this room */
remove_room(rt);
total_num_of_rooms --;
/* need to log this info */
if(log_flag) {
char *tp;
now = time(NULL);
tp = ctime(&now);
tp[strlen(tp)-1] = '\0';
fprintf(logfp,
"%s room [%s] is removed from the session\n",
tp, rt->room_name);
fprintf(logfp, "Total number of rooms:%d\n",
total_num_of_rooms);
fflush(logfp);
}
free(rt);
}
}
rt = tmp_rt;
}
/* reset the timer here */
if(sweep_int != 0) {
tv.tv_sec = sweep_int;
tv.tv_usec = 0;
time_out = &tv;
}
continue;
}
if(FD_ISSET(udp_socket_fd, &rset)) {
/*
* message arrives at the udp server port
* --> chat message
*/
process_chat_msg(udp_socket_fd);
/* no more descriptors are ready, we go back to wait */
if( --num_ready_fds <= 0)
continue;
}
if(FD_ISSET(tcp_socket_fd, &rset)) {
/*
* a request to set up tcp connection for control messages
*/
struct sockaddr_in client_addr;
socklen_t client_addr_len = sizeof(struct sockaddr_in);
int connect_fd;
if( (connect_fd = accept(tcp_socket_fd,
(struct sockaddr *)&client_addr, &client_addr_len)) < 0 ) {
perror("accept");
} else {
/* we accepted a new connection */
if(log_flag) {
get_peer_info(connect_fd, info_str);
fprintf(logfp, "%s connects successfully\n", info_str);
fflush(logfp);
}
/* find a place in fd_table[] to store the accepted fd */
for(i=0; i< MAX_CONTROL_SESSIONS; i++) {
if(fd_table[i] == -1){
fd_table[i] = connect_fd;
break;
}
}
if(i == MAX_CONTROL_SESSIONS) {
if(log_flag) {
fprintf(logfp, "too many connections\n");
fflush(logfp);
}
close(connect_fd);
}
if(i > max_fd_idx)
max_fd_idx = i;
if(connect_fd > maxfd)
maxfd = connect_fd;
FD_SET(connect_fd, &allset);
}
if( --num_ready_fds <= 0)
continue;
}
/*
* check which descriptor has data to read, and process
* the control message
*/
/* tmp_fd_idx is used to denote the second highest fd number:
* it is useful in the case that the max_fd_idx is removed.
*/
int tmp_fd_idx = -1;
for(i=0; i<= max_fd_idx; i++) {
if(fd_table[i] == -1)
continue;
if(FD_ISSET(fd_table[i], &rset)) {
process_control_msg(fd_table[i]);
/*
* close connection after processing since
* the semantics are that a connection is only
* good for one control message
*/
close(fd_table[i]);
FD_CLR(fd_table[i], &allset);
fd_table[i] = -1;
if( --num_ready_fds <=0 )
break;
} else {
tmp_fd_idx = i;
}
}
if(i == max_fd_idx)
max_fd_idx = tmp_fd_idx;
}
return 0;
}
/////////////// DO FUNCTIONS ///////////////////
void do_kingdom(CHAR_DATA * ch, char *argument)
{
KINGDOM_DATA *kingdom;
CHAR_DATA *vch = 0;
DESCRIPTOR_DATA *d = 0;
char buf[MAX_STRING_LENGTH];
char arg1[MAX_STRING_LENGTH];
char arg2[MAX_STRING_LENGTH];
char arg3[MAX_STRING_LENGTH];
long id = 0;
long i = 0;
if(IS_NPC(ch))
return;
smash_tilde(argument);
argument = one_argument_case(argument, arg1);
argument = one_argument_case(argument, arg2);
strcpy(arg3, argument);
if(IS_IMMORTAL(ch) && ch->level == MAX_LEVEL)
{
if(!str_cmp(arg1, "save"))
{
write_kingdoms();
sprintf(buf,"cp %s %s.bak",KINGDOM_FILE,KINGDOM_FILE);
system(buf);
send_to_char("Done, and made backup.\n\r", ch);
return;
}
if(arg1[0] == '\0')
{
send_to_char("Syntax: kingdom create\n\r", ch);
return;
}
if(!str_cmp(arg1, "create"))
{
create_kingdom();
write_kingdoms();
send_to_char("Done.\n\r", ch);
return;
}
if((!is_number(arg1) || !str_cmp(arg1, "help")))
{
send_to_char("Syntax: kingdom <id #> <attribute> <value>\n\r", ch);
send_to_char(" kingdom <id #> delete\n\r", ch);
send_to_char("\n\r", ch);
send_to_char("Attributes:\n\r", ch);
send_to_char(" leader name points pks pds realpoints\n\r", ch);
send_to_char(" noansiname\n\r", ch);
send_to_char("\n\r", ch);
}
else
{
id = atoi(arg1);
if((kingdom = get_kingdom(id)) == &kingdom_default)
{
send_to_char("There is no such kingdom with that ID.\n\r", ch);
return;
}
if(!str_cmp(arg2, "leader"))
{
if((vch = get_char_world(ch, arg3)) == 0)
{
send_to_char("The leader must be logged on.\n\r", ch);
return;
}
free_string(kingdom->leader);
kingdom->leader = str_dup(arg3);
vch->pcdata->kingdom = id;
send_to_char("Done.\n\r", ch);
return;
}
if(!str_cmp(arg2, "name"))
{
free_string(kingdom->name);
kingdom->name = str_dup(arg3);
send_to_char("Done.\n\r", ch);
return;
}
if(!str_cmp(arg2, "noansiname"))
{
free_string(kingdom->noansiname);
kingdom->noansiname = str_dup(arg3);
send_to_char("Done.\n\r", ch);
return;
}
if(!str_cmp(arg2, "delete") && !str_cmp(arg3, "yes"))
{
delete_kingdom(kingdom->id);
return;
}
i = atoi(arg3);
if(!str_cmp(arg2, "points"))
{
kingdom->points = i;
send_to_char("Done.\n\r", ch);
return;
}
if(!str_cmp(arg2, "realpoints"))
{
kingdom->realpoints = i;
send_to_char("Done.\n\r", ch);
return;
}
if(!str_cmp(arg2, "pds"))
{
kingdom->pds = i;
send_to_char("Done.\n\r", ch);
return;
}
if(!str_cmp(arg2, "pks"))
{
kingdom->pks = i;
send_to_char("Done.\n\r", ch);
return;
}
if(!str_cmp(arg2, "assists"))
{
kingdom->assists = i;
send_to_char("Done.\n\r", ch);
return;
}
}
}
if(ch->pcdata->kingdom == 0) // player not in a kingdom
{
if(!str_cmp(arg1, "create"))
{
if(ch->pcdata->quest < 1000)
{
send_to_char("You need 1000 quest points to create a new kingdom.\n\r", ch);
return;
}
if(!arg2 || arg2[0] == '\0' || !arg3 || arg3[0] == '\0')
{
send_to_char
("Syntax (DO NOT MESS THIS UP!): kingdom create \"name WITH ansi\" \"name WITHOUT ansi\"\n\r",
ch);
send_to_char("I suggest you SAY the name a few times to make SURE THE ANSI IS CORRECT.\n\r",
ch);
send_to_char("And if you dont put a final {{x your kingdom will be DELETED.\n\r", ch);
send_to_char("If your kingdom name has more than one word surround it in QUOTES!\n\r", ch);
return;
}
if(ansistrlen(arg2) > 20 || strlen(arg3) > 20)
{
send_to_char("String length is limited to 20 characters!\n\r", ch);
return;
}
kingdom = create_kingdom();
ch->pcdata->kingdom = kingdom->id;
ch->pcdata->quest -= 1000;
free_string(kingdom->leader);
kingdom->leader = str_dup(ch->name);
free_string(kingdom->name);
kingdom->name = str_dup(arg2);
free_string(kingdom->noansiname);
kingdom->noansiname = str_dup(arg3);
kingdom_message(0, "%s has {WCREATED{X The %s Kingdom!", ch->name, kingdom->name);
write_kingdoms();
return;
}
if(ch->pcdata->kingdom_invite == 0)
{
send_to_char("You don't belong to a kingdom.\n\r", ch);
return;
}
// make sure kingdom still exists
if(get_kingdom(ch->pcdata->kingdom_invite) == &kingdom_default)
{
send_to_char("That kingdom was destroyed.\n\r", ch);
return;
}
if(!str_cmp(arg1, "accept"))
{
add_member(ch->pcdata->kingdom_invite, ch);
return;
}
if(!str_cmp(arg1, "decline"))
{
send_to_char("You decline the kingdom's invitation.\n\r", ch);
if((vch = get_char_world(ch, get_kingdom(ch->pcdata->kingdom_invite)->leader)) != 0)
{
sprintf(buf, "%s has declined your invitation.\n\r", ch->name);
send_to_char(buf, vch);
}
ch->pcdata->kingdom_invite = 0;
return;
}
send_to_char("Type either kingdom accept or kingdom decline.\n\r", ch);
return;
}
kingdom = get_kingdom(ch->pcdata->kingdom);
if(!str_cmp(arg1, "leave") && !str_cmp(arg2, "for") && !str_cmp(arg3, "good"))
{
send_to_char("You leave the kingdom!\n\r", ch);
remove_member(kingdom->id, ch->name);
remove_trustee(kingdom->id, ch->name);
return;
}
if(!str_prefix(arg1, "report"))
{
long percent;
char *color;
buf[0] = '\0';
sprintf(buf, "%-4s %-12s{X %5s :: %s\n\r",
"CMBT", "Name", "Hits", "Room" );
for(d = descriptor_list; d; d = d->next)
{
if(d->connected != CON_PLAYING || !(vch = d->character) || vch->pcdata->kingdom != kingdom->id)
continue;
percent = (long) ((float) UMAX(1, vch->hit) / (float) UMAX(1, vch->max_hit) * 100);
if(percent < 10)
color = "{R";
else if(percent < 40)
color = "{B";
else if(percent < 70)
color = "{Y";
else
color = "{C";
sprintf(buf + strlen(buf), "%-4s %s%-12s{X %5li :: %s\n\r",
vch->fighting ? !IS_NPC(vch->fighting) ? "{R(PK){X" : "{r(F){X" : "",
color, vch->name, vch->hit, !vch->in_room ? "somewhere" : vch->in_room->name);
}
send_to_char(buf, ch);
return;
}
if(!is_trustee(ch, kingdom->id))
{
send_to_char("Only leaders and trustees have power to modify their kingdom.\n\r", ch);
return;
}
if(arg1[0] == '\0' || arg2[0] == '\0')
{
if(is_leader(ch, kingdom->id) || IS_IMMORTAL(ch))
{
send_to_char("Syntax:\n\r", ch);
send_to_char(" kingdom report\n\r", ch);
send_to_char(" kingdom invite <player>\n\r", ch);
send_to_char(" kingdom outcast <member>\n\r", ch);
send_to_char(" kingdom war <kingdom ID>\n\r", ch);
send_to_char(" kingdom treaty <kingdom ID>\n\r", ch);
send_to_char(" kingdom rank <member> <rank>\n\r", ch);
send_to_char(" kingdom trust <member>\n\r", ch);
send_to_char(" kingdom recall\n\r", ch);
send_to_char("\n\r", ch);
}
send_to_char("Syntax: kingdom scry <person>\n\r", ch);
return;
}
if(is_leader(ch, kingdom->id))
{
if(!str_cmp(arg1, "recall"))
{
if(kingdom->points < KINGDOM_RECALL_COST)
{
sprintf(buf, "It costs %d kingdom points to set a recall point.\n\r", KINGDOM_RECALL_COST);
send_to_char(buf, ch);
return;
}
if(ch->in_room == 0)
{
send_to_char("You are in a 0 room, eek.\n\r", ch);
return;
}
kingdom->points -= KINGDOM_RECALL_COST;
kingdom->recall = ch->in_room->vnum;
kingdom_message(kingdom->id, "{MThe Kingdom Recall has been set to -> [%s]", ch->in_room->name);
return;
}
if(!str_cmp(arg1, "trust"))
{
if((vch = get_char_world(ch, arg2)) == 0 || IS_NPC(vch))
{
send_to_char("They need to be logged on.\n\r", ch);
return;
}
if(vch->pcdata->kingdom != ch->pcdata->kingdom)
{
send_to_char("They aren't in your kingdom!\n\r", ch);
return;
}
arg2[0] = UPPER(arg2[0]);
if( strstr(kingdom->trustees, arg2) == 0 )
add_trustee(kingdom->id, vch);
else
remove_trustee(kingdom->id, arg2);
return;
}
if(!str_cmp(arg1, "invite"))
{
if((vch = get_char_world(ch, arg2)) == 0)
{
send_to_char("They aren't logged on.\n\r", ch);
return;
}
if(IS_NPC(vch))
{
send_to_char("That's an NPC.\n\r", ch);
return;
}
if(vch->pcdata->kingdom)
{
send_to_char("They are already a part of another kingdom!\n\r", ch);
return;
}
vch->pcdata->kingdom_invite = ch->pcdata->kingdom;
sprintf(buf, "You are invited to join the %s Kingdom by %s.\n\r"
"Type kingdom accept or kingdom decline.\n\r", kingdom->name, ch->name);
send_to_char(buf, vch);
sprintf(buf, "You invite %s to join your glorious kingdom.\n\r", vch->name);
send_to_char(buf, ch);
return;
}
if(!str_cmp(arg1, "outcast"))
{
arg2[0] = UPPER(arg2[0]);
if( strstr(kingdom->members, arg2) == 0 )
{
send_to_char("That person isn't a member!\n\r",ch);
return;
}
if(remove_member(ch->pcdata->kingdom, arg2))
kingdom_message(0, "%s has been outcasted from the %s Kingdom!", capitalize(arg2), kingdom->name);
remove_trustee(kingdom->id, arg2);
return;
}
if(!str_cmp(arg1, "treaty"))
{
if(kingdom->treaty_pending)
{
if(!get_kingdom(kingdom->treaty_pending))
{
kingdom->treaty_pending = 0;
return;
}
if(has_treaty(kingdom->id, kingdom->treaty_pending))
{
send_to_char("You already have a treaty with them.\n\r", ch);
return;
}
if(!str_cmp(arg2, "accept"))
{
add_treaty(kingdom->id, kingdom->treaty_pending);
kingdom->treaty_pending = 0;
return;
}
if(!str_cmp(arg2, "decline"))
{
kingdom_message(kingdom->id, "Your kingdom declines a treaty with the %s Kingdom.",
get_kingdom(kingdom->treaty_pending)->name);
kingdom_message(kingdom->treaty_pending, "%s Kingdom has declined your treaty offer.", kingdom->name);
kingdom->treaty_pending = 0;
return;
}
sprintf(buf, "You have a treaty offer pending with the %s Kingdom.\n\r"
"Please type kingdom treaty accept or kingdom treaty decline.\n\r",
get_kingdom(kingdom->treaty_pending)->name);
send_to_char(buf, ch);
return;
}
if(!is_number(arg2) || get_kingdom(atoi(arg2)) == &kingdom_default)
{
send_to_char("There is no such kingdom to make a treaty with.\n\r", ch);
return;
}
i = atoi(arg2);
if(kingdom->id == i)
{
send_to_char("You already have a treaty with yourself, smart one.\n\r", ch);
return;
}
if(is_at_war(kingdom->id, i))
{
send_to_char("You are at {RWAR{N with that kingdom!\n\r", ch);
return;
}
if(has_treaty(kingdom->id, i))
{
remove_treaty(kingdom->id, i);
return;
}
if(get_kingdom(i)->treaty_pending)
{
send_to_char("They are already pending a treaty confirmation.\n\r", ch);
return;
}
get_kingdom(i)->treaty_pending = kingdom->id;
kingdom_message(i, "The %s Kingdom is asking for a treaty with your kingdom.", kingdom->name);
kingdom_message(kingdom->id, "You ask the %s Kingdom for a treaty.", get_kingdom(i)->name);
return;
}
if(!str_cmp(arg1, "war"))
{
if(!is_number(arg2) || get_kingdom(atoi(arg2)) == &kingdom_default)
{
send_to_char("There is no such kingdom to make war with.\n\r", ch);
return;
}
i = atoi(arg2);
if(i == kingdom->id)
{
send_to_char("That wouldn't be a very smart political move.\n\r", ch);
return;
}
if(get_kingdom(i) == &kingdom_default)
{
send_to_char("That kingdom doesn't exist.\n\r", ch);
return;
}
if(has_treaty(kingdom->id, i))
{
send_to_char("But you have a treaty with them!\n\r", ch);
return;
}
if(is_at_war(kingdom->id, i))
{
remove_war(kingdom->id, i);
return;
}
add_war(kingdom->id, i);
return;
}
if(!str_cmp(arg1, "rank"))
{
if(!arg3 || arg3[0] == '\0')
{
send_to_char("Rank who as what?\n\r", ch);
return;
}
if((vch = get_char_world(ch, arg2)) == 0 || IS_NPC(vch))
{
send_to_char("They aren't on at the moment.\n\r", ch);
return;
}
if(vch->pcdata->kingdom != ch->pcdata->kingdom)
{
send_to_char("They aren't apart of your kingdom!\n\r", ch);
return;
}
if(ansistrlen(arg3) > 15)
{
send_to_char("String length is limited to 20 characters.\n\r", ch);
return;
}
free_string(vch->pcdata->krank);
if(!str_cmp(arg3, "clear"))
{
vch->pcdata->krank = str_dup("");
return;
}
arg3[0] = UPPER(arg3[0]);
vch->pcdata->krank = str_dup(arg3);
send_to_char("Done.\n\r", ch);
return;
}
}
if(!str_cmp(arg1, "scry"))
{
if(arg2[0] == '\0')
{
send_to_char("You must supply the name of the person.\n\r", ch);
return;
}
if((vch = get_char_world(ch, arg2)) == 0 || IS_NPC(vch))
{
send_to_char("They are not online.\n\r", ch);
return;
}
if(kingdom->points < KINGDOM_SCRY_COST)
{
sprintf(buf, "It costs %d Kingdom Points to do this.\n\r", KINGDOM_SCRY_COST);
send_to_char(buf, ch);
return;
}
kingdom_message(kingdom->id, "%s has {cscryed{N %s {C. o O{N ({C%s{N)",
ch->name, vch->name, vch->in_room == 0 ? "Nowhere" : vch->in_room->name);
kingdom->points -= KINGDOM_SCRY_COST;
return;
}
// default message
do_kingdom(ch, "blah");
}
void clubmaster_driver(int cn,int ret,int lastact)
{
struct clubmaster_driver_data *dat;
int co,in,n,rank,cc,val;
struct msg *msg,*next;
char *ptr,tmp[80],name[80];
dat=set_data(cn,DRD_CLUBMASTERDRIVER,sizeof(struct clubmaster_driver_data));
if (!dat) return; // oops...
if (ch[cn].arg) {
clubmaster_driver_parse(cn,dat);
ch[cn].arg=NULL;
}
// loop through our messages
for (msg=ch[cn].msg; msg; msg=next) {
next=msg->next;
// did we see someone?
if (msg->type==NT_CHAR) {
co=msg->dat1;
// dont talk to someone we cant see, and dont talk to ourself
if (!char_see_char(cn,co) || cn==co) { remove_message(cn,msg); continue; }
// dont talk to someone far away
if (char_dist(cn,co)>10) { remove_message(cn,msg); continue; }
// dont talk to the same person twice
if (mem_check_driver(cn,co,7)) { remove_message(cn,msg); continue; }
if (!get_char_club(cn) && !get_char_clan(cn)) quiet_say(cn,"Hello %s! Would you like to found a °c4club°c0?",ch[co].name);
mem_add_driver(cn,co,7);
}
// talk back
if (msg->type==NT_TEXT) {
analyse_text_driver(cn,msg->dat1,(char*)msg->dat2,msg->dat3);
if ((msg->dat1==1 || msg->dat1==2) && (co=msg->dat3)!=cn) { // talk, and not our talk
if ((ptr=strcasestr((char*)msg->dat2,"found:"))) {
if (!(ch[co].flags&CF_PAID)) {
quiet_say(cn,"I'm sorry, %s, but only paying players may found clubs.",ch[co].name);
} else if (!get_char_clan(co) && !get_char_club(co)) {
if (ch[co].gold>=10000*100) {
ptr+=6;
while (isspace(*ptr)) ptr++;
for (n=0; n<79; n++) {
if (!(isalpha(*ptr) || *ptr==' ')) break;
name[n]=*ptr++;
}
name[n]=0;
if ((n=create_club(name))) {
take_money(co,10000*100);
ch[co].clan=n+CLUBOFFSET;
ch[co].clan_serial=club[n].serial;
ch[co].clan_rank=2;
quiet_say(cn,"Congratulations, %s, you are now the leader of the club %s.",ch[co].name,club[n].name);
dlog(co,0,"created club %d %s",n,club[n].name);
} else quiet_say(cn,"Something's wrong with the name.");
} else quiet_say(cn,"You cannot pay the fee of 10,000 gold.");
} else quiet_say(cn,"You are already a member of a clan or club. You cannot found a new one.");
}
if ((ptr=strcasestr((char*)msg->dat2,"accept:"))) {
if (!get_char_club(co) || ch[co].clan_rank<1) {
quiet_say(cn,"You are not a club leader, %s.",ch[co].name);
} else {
ptr+=7;
while (isspace(*ptr)) ptr++;
for (n=0; n<79; n++) {
if (!*ptr || *ptr=='"') break;
dat->accept[n]=*ptr++;
}
dat->accept[n]=0;
strcpy(dat->join,ch[co].name);
dat->accept_clan=get_char_club(co);
dat->accept_cn=co;
quiet_say(cn,"To join %s's club %s, say: 'join: %s'",dat->join,dat->accept,dat->join);
}
}
if ((ptr=strcasestr((char*)msg->dat2,"join:"))) {
if (get_char_clan(co) || get_char_club(co)) {
quiet_say(cn,"You are already a clan or club member, %s.",ch[co].name);
} else {
ptr+=5;
while (isspace(*ptr)) ptr++;
for (n=0; n<79; n++) {
if (!*ptr || *ptr=='"') break;
tmp[n]=*ptr++;
}
tmp[n]=0;
if (strcasecmp(dat->accept,ch[co].name)) {
quiet_say(cn,"You have not been invited, %s.",ch[co].name);
} else if (strcasecmp(dat->join,tmp)) {
quiet_say(cn,"%s has not invited you, %s.",tmp,ch[co].name);
} else {
//add_member(co,dat->accept_clan,dat->join);
ch[co].clan=dat->accept_clan+CLUBOFFSET;
ch[co].clan_serial=club[dat->accept_clan].serial;
ch[co].clan_rank=0;
quiet_say(cn,"%s, you are now a member of %s's club.",ch[co].name,dat->join);
dat->accept[0]=0;
dat->accept_clan=0;
dat->join[0]=0;
}
}
}
if ((ptr=strcasestr((char*)msg->dat2,"leave!"))) {
if (!get_char_club(co)) {
quiet_say(cn,"You are not a club member, %s.",ch[co].name);
} else {
remove_member(co,co);
quiet_say(cn,"You are no longer a member of any club, %s",ch[co].name);
}
}
if ((ptr=strcasestr((char*)msg->dat2,"rank:"))) {
if (!get_char_club(co) || ch[co].clan_rank<2) {
quiet_say(cn,"You are not a club founder, %s.",ch[co].name);
} else {
ptr+=6;
while (isspace(*ptr)) ptr++;
for (n=0; n<79; n++) {
if (!*ptr || *ptr=='"' || isspace(*ptr)) break;
tmp[n]=*ptr++;
}
tmp[n]=0;
rank=atoi(ptr);
if (rank<0 || rank>1) {
quiet_say(cn,"You must use a rank between 0 and 1.");
remove_message(cn,msg);
continue;
}
for (cc=getfirst_char(); cc; cc=getnext_char(cc)) {
if (!strcasecmp(tmp,ch[cc].name) && (ch[cc].flags&CF_PLAYER)) break;
}
if (cc) {
if (!(ch[cc].flags&CF_PAID) && rank>0) {
quiet_say(cn,"%s is not a paying player, you cannot set the rank higher than 0.",ch[cc].name);
} else if (ch[cc].clan_rank==2) {
quiet_say(cn,"%s is the club's founder, cannot change rank.",ch[cc].name);
} else if (get_char_club(cc)==get_char_club(co)) {
ch[cc].clan_rank=rank;
quiet_say(cn,"Set %s's rank to %d.",ch[cc].name,rank);
} else quiet_say(cn,"You cannot change the rank of those not belonging to your club.");
} else {
int uID;
uID=lookup_name(tmp,NULL);
if (uID==0) continue;
if (uID==-1) {
quiet_say(cn,"Sorry, no player by the name %s found.",tmp);
} else {
task_set_clan_rank(uID,ch[co].ID,get_char_club(co)+CLUBOFFSET,rank,ch[co].name);
quiet_say(cn,"Update scheduled (%s,%d).",tmp,rank);
}
}
}
}
if ((ptr=strcasestr((char*)msg->dat2,"fire:"))) {
if (!get_char_club(co) || ch[co].clan_rank<1) {
quiet_say(cn,"You are not a club leader, %s.",ch[co].name);
} else {
ptr+=6;
while (isspace(*ptr)) ptr++;
for (n=0; n<79; n++) {
if (!*ptr || *ptr=='"' || isspace(*ptr)) break;
tmp[n]=*ptr++;
}
tmp[n]=0;
for (cc=getfirst_char(); cc; cc=getnext_char(cc)) {
if (!strcasecmp(tmp,ch[cc].name) && (ch[cc].flags&CF_PLAYER)) break;
}
if (cc) {
if (get_char_club(cc)==get_char_club(co)) {
if (ch[cc].clan_rank<2) {
remove_member(cc,co);
quiet_say(cn,"Fired: %s.",ch[cc].name);
} else quiet_say(cn,"You cannot fire the founder of the club.");
} else quiet_say(cn,"You cannot fire those not belonging to your club.");
} else {
int uID;
uID=lookup_name(tmp,NULL);
if (uID==0) continue;
if (uID==-1) {
quiet_say(cn,"Sorry, no player by the name %s found.",tmp);
} else {
task_fire_from_clan(uID,ch[co].ID,get_char_club(co)+CLUBOFFSET,ch[co].name);
quiet_say(cn,"Update scheduled (%s).",tmp);
}
}
}
}
if ((ptr=strcasestr((char*)msg->dat2,"deposit:"))) {
if (!(n=get_char_club(co))) {
quiet_say(cn,"You are not a club member, %s.",ch[co].name);
} else {
val=atoi(ptr+8)*100;
if (val>0 && ch[co].gold>=val) {
club[n].money+=val;
take_money(co,val);
quiet_say(cn,"You have deposited %dG, for a total of %dG, %s.",val/100,club[n].money/100,ch[co].name);
dlog(co,0,"Deposited %dG into club %d, for a new total of %dG",val/100,n,club[n].money/100);
db_update_club(n);
} else quiet_say(cn,"You do not have that much gold, %s.",ch[co].name);
}
}
if ((ptr=strcasestr((char*)msg->dat2,"withdraw:"))) {
if (!(n=get_char_club(co)) || ch[co].clan_rank<2) {
quiet_say(cn,"You are not a club founder, %s.",ch[co].name);
} else {
val=atoi(ptr+9)*100;
if (val>0 && club[n].money>=val) {
club[n].money-=val;
give_money(co,val,"club withdrawal");
quiet_say(cn,"You have withdrawn %dG, money left in club %dG, %s.",val/100,club[n].money/100,ch[co].name);
dlog(co,0,"Withdrew %dG from club %d, for a new total of %dG",val/100,n,club[n].money/100);
db_update_club(n);
} else quiet_say(cn,"The club does not have that much gold, %s.",ch[co].name);
}
}
}
}
// got an item?
if (msg->type==NT_GIVE) {
co=msg->dat1;
if ((in=ch[cn].citem)) { // we still have it
// try to give it back
if (give_char_item(cn,co)) return;
// didnt work, let it vanish, then
destroy_item(ch[cn].citem);
ch[cn].citem=0;
}
}
remove_message(cn,msg);
}
// do something. whenever possible, call do_idle with as high a tick count
// as reasonable when doing nothing.
if (secure_move_driver(cn,ch[cn].tmpx,ch[cn].tmpy,dat->dir,ret,lastact)) return;
if (ticker>dat->last_talk+TICKS*60 && !RANDOM(25)) {
switch(RANDOM(8)) {
case 0: murmur(cn,"My back itches."); break;
case 1: whisper(cn,"There's something stuck between your teeth."); break;
case 2: murmur(cn,"Oh yeah, those were the days."); break;
case 3: murmur(cn,"Now where did I put it?"); break;
case 4: murmur(cn,"Oh my, life is hard but unfair."); break;
case 5: murmur(cn,"Beware of the fire snails!"); break;
case 6: murmur(cn,"I love the clicking of coins."); break;
case 7: murmur(cn,"Gold and Silver, Silver and Gold."); break;
default: break;
}
dat->last_talk=ticker;
}
if (ticker>dat->memcleartimer) {
mem_erase_driver(cn,7);
dat->memcleartimer=ticker+TICKS*60*60*12;
}
do_idle(cn,TICKS*2);
}
