Exemplo n.º 1
0
Shit *get_shituser(char *userhost, char *channel)
{
	ChanUser *cu;
	Chan	*chan;
	Shit	*shit;
	char	*p;

#ifdef DEBUG
	debug("(get_shituser) userhost = '%s', channel = '%s'\n",
		nullstr(userhost),nullstr(channel));
#endif /* DEBUG */
	/*
	 *  save us a few million function calls if the shitlist is empty
	 */
	if (!current->shitlist)
		return(NULL);
	if (!nickcmp(current->nick,userhost))
		return(NULL);
	for(chan=current->chanlist;chan;chan=chan->next)
	{
		for(cu=chan->users;cu;cu=cu->next)
		{
			p = get_nuh(cu);
			if (matches(userhost,p))
				continue;
			if ((shit = find_shit(p,channel)) != NULL)
				return(shit);
		}
	}
	return(NULL);
}
Exemplo n.º 2
0
int tcl_parse_jump(char *from, char *rest, Hook *hook)
{
	Tcl_Obj	*tcl_result;
	int	i;

#ifdef DEBUG
	debug("(tcl_parse_jump) %s %s %s\n",
		nullstr(hook->self),nullstr(from),nullstr(rest));
#endif /* DEBUG */

	if (from)
		nickcpy(CurrentNick,from);
	else
		*CurrentNick = 0;

	Tcl_SetVar(energymech_tcl,"_from",from,0);
	Tcl_SetVar(energymech_tcl,"_rest",rest,0);

	i = 0;
	if (Tcl_VarEval(energymech_tcl,hook->self," $_from $_rest",NULL) == TCL_OK)
	{
		tcl_result = Tcl_GetObjResult(energymech_tcl);
		Tcl_GetIntFromObj(energymech_tcl,tcl_result,&i);
	}
#ifdef DEBUG
	if (energymech_tcl->result && *energymech_tcl->result)
		debug("(tcl_parse_jump) result = %s\n",nullstr(energymech_tcl->result));
#endif /* DEBUG */
	return(i);
}
Exemplo n.º 3
0
static int
interrupt_command(ClipMachine * ClipMachineMemory, int argc, char **argv)
{
   fprintf(_clip_dbg_out, "interrupt at ");
   fprintf(_clip_dbg_out, "file:%s", nullstr(ClipMachineMemory->fp->filename_of_ClipFrame));
   fprintf(_clip_dbg_out, " line:%d", ClipMachineMemory->fp->line_of_ClipFrame);
   fprintf(_clip_dbg_out, " func:%s\n", nullstr(ClipMachineMemory->fp->procname_of_ClipFrame));
   in_breakpoint = 1;
   return 0;
}
Exemplo n.º 4
0
void print_metrics(){
	
	int i=0;

	ofstream unset;
	string nullstr("");

	mse one(NULL, NULL, -1, -1, unset, nullstr);
	cout<<"\t"<<++i<<": "<<one.get_metric_name()<<"\n";

	rmse two(NULL, NULL, -1, -1, unset, nullstr);
	cout<<"\t"<<++i<<": "<<two.get_metric_name()<<"\n";

	scc three(NULL, NULL, -1, -1, unset, nullstr);
	cout<<"\t"<<++i<<": "<<three.get_metric_name()<<"\n";

	difmap four(NULL, NULL, -1, -1, unset, nullstr);
	cout<<"\t"<<++i<<": "<<four.get_metric_name()<<"\n";

	difmap_wkey five(NULL, NULL, -1, -1, unset, nullstr);
	cout<<"\t"<<++i<<": "<<five.get_metric_name()<<"\n";

	colmap six(NULL, NULL, -1, -1, unset, nullstr);
	cout<<"\t"<<++i<<": "<<six.get_metric_name()<<"\n";

	scorco seven(NULL, NULL, -1, -1, unset, nullstr);
	cout<<"\t"<<++i<<": "<<seven.get_metric_name()<<"\n";
	
	modef eight(NULL, NULL, -1, -1, unset, nullstr);
	cout<<"\t"<<++i<<": "<<eight.get_metric_name()<<"\n";

}
Exemplo n.º 5
0
static int
bt_command(ClipMachine * ClipMachineMemory, int argc, char **argv)
{
   ClipFrame *fp;

   int i;

   for (i = 0, fp = ClipMachineMemory->fp; fp; fp = fp->ClipFrame_up_of_ClipFrame)
   {
      if (!fp->line_of_ClipFrame)
	 continue;
      fprintf(_clip_dbg_out, "%d: file:%s", i, nullstr(fp->filename_of_ClipFrame));
      fprintf(_clip_dbg_out, " line:%d", fp->line_of_ClipFrame);
      fprintf(_clip_dbg_out, " func:%s\n", nullstr(fp->procname_of_ClipFrame));
      i++;
   }

   return 0;
}
Exemplo n.º 6
0
void
_clip_sigint(int sig)
{
   ClipMachine *ClipMachineMemory;

   if (!debugging)
   {
      _clip_signal(sig);
      return;
   }

   ClipMachineMemory = cur_ClipMachine();

   fprintf(_clip_dbg_out, "\nsigint: file %s line %d proc %s",
	   nullstr(ClipMachineMemory->fp->filename_of_ClipFrame), ClipMachineMemory->fp->line_of_ClipFrame, nullstr(ClipMachineMemory->fp->procname_of_ClipFrame));
   fprintf(_clip_dbg_out, "\n.\n");
   fflush(_clip_dbg_out);
   _clip_logg(1, "sigint: file %s line %d proc %s",
	      nullstr(ClipMachineMemory->fp->filename_of_ClipFrame), ClipMachineMemory->fp->line_of_ClipFrame, nullstr(ClipMachineMemory->fp->procname_of_ClipFrame));
   _clip_in_breakpoint();
}
Exemplo n.º 7
0
int
main(int argc,char **argv)
{
    HASHTABLE 	ht;
    char *	s;
    int		i;

    ht = htMake(-1);

    for (i = 0; i < argc; i++)
	htAdd(ht,argv[i],(void*)argv[i]);

    printf("\nContents of hash table: %d items, %d slots\n",
	    htItems( ht ), htSize( ht ) );
    htWalk(ht,1,pfunc);
    printf("\n===============\n");

    while (1)
    {
	printf("Conflicts in table: %d\n",htConflicts(ht));
	htWalk(ht,0,pfunc);
	printf("\n");

	printf("Enter key to remove: (\"quit\" to stop): ");
	s = get_string();
	if (!strcmp(s,"quit"))
	    break;
	printf("Removing element with key \"%s\"... = %s\n",s,
		nullstr((char*)htRemove(ht,s)));
    }

    printf("Closing hash table\n" );
    htCloseWithFunction( ht, close_func );
    
    return 0;
}
Exemplo n.º 8
0
void tcl_dcc_complete(Client *client, int cps)
{
	Tcl_Obj	*obj;
	Tcl_Obj	*vname;
	Hook	*hook;

	vname = Tcl_NewStringObj("_cps",3);
	for(hook=hooklist;hook;hook=hook->next)
	{
		if (hook->flags == HOOK_DCC_COMPLETE &&
			hook->guid && current && hook->guid == current->guid)
		{
			Tcl_SetVar(energymech_tcl,"_filetarget",client->whom,0);
			Tcl_SetVar(energymech_tcl,"_filename",client->filename,0);
			obj = Tcl_NewIntObj(cps);
			Tcl_ObjSetVar2(energymech_tcl,vname,NULL,obj,TCL_GLOBAL_ONLY);
			Tcl_VarEval(energymech_tcl,hook->self," $_filetarget $_filename $_cps",NULL);
#ifdef DEBUG
			if (energymech_tcl->result && *energymech_tcl->result)
				debug("(tcl_dcc_complete) result = %s\n",nullstr(energymech_tcl->result));
#endif /* DEBUG */
		}
	}
}
Exemplo n.º 9
0
static CLIENT *access_check (int rc, struct sockaddr_in ssin)
{
	struct stat _stat;
	ulong ipaddr;
	ACL *acl;
	CLIENT *retval;
	int curconcur;

	if (master->connections > cfg.MaxConnections) {
		write (rc, MSG_SERVERFULL, strlen (MSG_SERVERFULL));
		info ("Too many global connections, increase cfg.MaxConnections");
		return NULL;
	}

	if (stat (cfg.DisableFile, &_stat) == 0) {
		write (rc, cfg.DisableText, strlen (cfg.DisableText));
		write (rc, "\r\n", 2);
		return NULL;
	}

	errno = 0;

	ipaddr = ntohl (ssin.sin_addr.s_addr);

	if ( cfg.JSONACL ) {
		if ( (acl = gethttpacl(inet_ntoa(ssin.sin_addr), curl)) == NULL )
		{
			syslog(LOG_ERR, "Cant get JSON ACL.");
			write(rc, MSG_NOACL, strlen(MSG_NOACL));
			return NULL;
		}
	} else {
		if ( (acl = getacl(ipaddr)) == NULL )
		{
			syslog(LOG_ERR, "Cant get default ACL, define \"acl 0/0\" in access.conf");
			write(rc, MSG_NOACL, strlen(MSG_NOACL));
			return NULL;
		}
	}

	if ( ! nullstr(acl->profile->Disabled) )
	{
		write(rc, "400 ", 4);
		write(rc, acl->profile->Disabled, strlen(acl->profile->Disabled));
		return NULL;
	}

	if (acl->deny) {
		write(rc, MSG_NOPERM, strlen(MSG_NOPERM));
		info("denied connection from %s", inet_ntoa(ssin.sin_addr));
		return NULL;
	}

	if (acl->profile->connections > acl->profile->MaxConnections) {
		write(rc, MSG_TOOMANYCONNSPRF, strlen(MSG_TOOMANYCONNSPRF));
		return NULL;
	}

	semlock_lock (master->semid);
	retval = find_slot (ipaddr, &curconcur, acl->unlimit ? 0 : acl->profile->MaxHostConcurrent);
	semlock_unlock (master->semid);

	if (retval == NULL) {
		char buf[128];
		sprintf (buf, MSG_TOOMANY_CONCURRENT, acl->profile->MaxHostConcurrent);
		write (rc, buf, strlen (buf));
		syslog(LOG_DEBUG, "Too many concurrent connections from %s"
				, inet_ntoa (ssin.sin_addr));
		return NULL;
	}

	retval->acl = acl;
	memcpy (&retval->addr, &ssin, sizeof (ssin));
	retval->socket = rc;

	return retval;
}
Exemplo n.º 10
0
PROTO int cmdauthinfo(char *args)
{
        char subcmd[17], subcmdargs[65];
        USER *newuser;
        PROFILE *oldprf;
        PROFILE *newprf;
        int change_profile;
        AUTHRESULT *authres;

        sscanf (args, "%16[^\r\n\t ] %64[^\r\n]", subcmd, subcmdargs);

        if ( client->authenticated )
                return swriteclient(client, MSG_AUTH_TWICE);

        if (!strcasecmp(subcmd,"user")) 
        {
                if (client->authenticated && strncmp(client->username, subcmdargs, 64))
                        return swriteclient (client, MSG_AUTH_TWICE);
                if ( client->vhost->AddSuffix[0] != '\0' ) {
                    snprintf(client->username, MAX_USERPASS-1, "%s@%s", subcmdargs, client->vhost->AddSuffix);
                } else {
                    strncpy(client->username, subcmdargs, MAX_USERPASS-1);
                }
        } else if ( !strcasecmp(subcmd, "pass") ) {
                strncpy(client->password, subcmdargs, MAX_USERPASS-1);
        } else {
                return swriteclient(client, MSG_AUTH_UNKNOWN);
        }

        if ( client->username[0] == 0 || client->password[0] == 0 )
                return swriteclient(client, MSG_MOREAUTHREQ);

        client->auth = getauth(client->username);

        if ( (authres=new_authresult(client)) == NULL )
                return swriteclient(client, MSG_AUTH_NOMEM);

        void (*authmod)() = find_auth_mod(client->auth->auth->lib);

        if (!authmod) {
                CLEARPASS
                syslog(LOG_ERR, "Can't find authmap: %s", client->auth->auth->lib);
                swriteclient(client, MSG_AUTH_ERR);
                return 0;
        }

        client->authenticated = 0;
        (*authmod)(authres, &cfg, client->auth->auth->args);
        CLEARPASS

        if ( authres->authenticated == true )
        {
                semlock_lock(master->semid);
                client->authenticated++;

                if ( authres->logname != NULL )
                        strcpy(client->logname, authres->logname);

                /* auth module specified profile */
                if ( authres->profile != NULL ) 
                {
                        if ( (newprf = find_user_profile(client->username)) == NULL )
                                if ( (newprf=getprofile(authres->profile)) == NULL )
                                {
                                        client->authenticated--;
                                        semlock_unlock(master->semid);
                                        syslog(LOG_ERR, "Missing profile information from authenticator, rejecting user %s",
                                                        authres->username);
                                        swriteclient(client, MSG_AUTH_ERR);
                                        free_authresult(authres);
                                        return 0;

                                }
                } else {
                        newprf = client->auth->profile;
                }

                PROFILE *p;
                if ( (p = prof_iplookup(newprf, client->addr.sin_addr)) != NULL )
                        newprf = p;

                if ( ! nullstr(newprf->Disabled) )
                {
                        client->authenticated--;
                        semlock_unlock(master->semid);
                        if ( cfg.LogAuthInfo )
                                syslog(LOG_NOTICE, "%s: authinfo login: %s result: 480 %s", 
                                        client->hostname, authres->username, newprf->Disabled);
                        return writeclient(client, "482 %s", newprf->Disabled);
                }

                /* Check and verify we are allowed in our new profile */

                change_profile = 0;
                oldprf = client->profile;
                if ( client->profile != newprf )
                {
                        if ( newprf->connections > newprf->MaxConnections ) 
                        {
                                client->authenticated--;
                                semlock_unlock(master->semid);
                                if ( cfg.LogAuthInfo )
                                        syslog(LOG_NOTICE, "%s: authinfo login: %s result: %s", 
                                                client->hostname, authres->username, MSG_AUTH_TOOMANYCON);
                                return swriteclient(client, MSG_AUTH_TOOMANYCON);
                        } 
                        else if ( newprf->numusers > newprf->MaxUsers )
                        {
                                client->authenticated--;
                                semlock_unlock(master->semid);
                                if ( cfg.LogAuthInfo )
                                        syslog(LOG_NOTICE, "%s: authinfo login: %s result: %s", 
                                                client->hostname, authres->username, MSG_AUTH_TOOMANYUSR);
                                return swriteclient(client, MSG_AUTH_TOOMANYUSR);
                        } else {
                                change_profile = 1;
                        }
                }


                /* Find our other connections from this user to see if we are allowed */

                newuser = find_user(client->username, newprf);
                if ( newuser != client->user && newuser != NULL )
                {
                        if ( newuser->connections > newprf->MaxUserConcurrent )
                        {
                                client->authenticated--;
                                drop_user(newuser->id, newprf);
                                semlock_unlock(master->semid);
                                sleep(cfg.RetryDelay);
                                if ( cfg.LogAuthInfo )
                                        syslog(LOG_NOTICE, "%s: authinfo login: %s result: %s", 
                                                client->hostname, authres->username, MSG_AUTH_USERFULL);
                                free_authresult(authres);
                                return swriteclient(client, MSG_AUTH_USERFULL);
                        }
                }

                if ( newuser == NULL )
                        syslog(LOG_ERR, "newuser == NULL");


                /* check number of different connected hosts from new user */

                int maxhosts = newprf->ASMaxHosts;
                int maxconns = newprf->ASMaxConns;
                if ( maxconns > 0 || maxhosts > 0 ) {
                    char httpresult[2048];
                    semlock_unlock(master->semid);
                    if ( ! check_http_accountsharing(client->username, client->hostname, maxhosts, maxconns, newprf->Name, httpresult) ) {
                            syslog(LOG_DEBUG, "HTTP account sharing returned false. maxhosts=%d, maxconns=%d, user=%s, host=%s, newprf=%s, result=%s", 
                                              maxhosts, maxconns, client->username, client->hostname, newprf->Name, httpresult);
                            semlock_lock(master->semid);
                            client->authenticated--;
                            drop_user(newuser->id, newprf);
                            semlock_unlock(master->semid);
                            sleep(cfg.RetryDelay);
                            free_authresult(authres);
                            return writeclient(client, "482 %s", httpresult);
                    }
                    semlock_lock(master->semid);
                }

                if ( change_profile == 1 )
                {
                        if ( client->profile->connections == 0 )
                                syslog(LOG_ERR, "Trying to drop 0 connections profile from auth: %s", client->profile->Name);
                        else
                                client->profile->connections--;

                        client->profile = newprf;
                        client->profile->connections++;
                }

                drop_user(client->user->id, oldprf);
                client->user = newuser;
                client->user->bytesleft = authres->bytes; // client->initbytes;
                client->posting = authres->posting;

                if ( authres->userkbit > 0 )
                        client->user->MaxUserBPS = authres->userkbit * 1000 / 8;
                else
                        client->user->MaxUserBPS = client->profile->MaxUserBPS;

                if ( authres->timeleft > 0 ) {
                    client->user->timeleft = authres->timeleft;
                }

                if ( authres->readpat ) {
                    strcpy(client->user->readpat, authres->readpat);
                }
                if ( authres->postpat ) {
                    strcpy(client->user->postpat, authres->postpat);
                }


//              syslog(LOG_DEBUG, "%s: assigning-change %s userkey %s", client->hostname, client->profile->Name, client->user->key);

                /* init ratelimiter */
                init_ratelimiter(client);
                semlock_unlock(master->semid);
        }

        if ( cfg.LogAuthInfo )
                syslog(LOG_NOTICE, "%s: authinfo login: %s result: %s", 
                        client->hostname, authres->username, authres->message ? authres->message : "UNKNOWN");
        swriteclient(client, authres->message ? authres->message : MSG_AUTH_ERR);

        free_authresult(authres);
        return 0;
}
Exemplo n.º 11
0
PROTO int group(const char *group, char nogroupecho)
{
        char b[MAX_SERVERRSP];
        ACTIVE *newgroup;
        SERVER *svr;
        CLEARBUF

        if ( nullstr(group) )
        {
                swriteclient(client,"500 You must select a group\r\n");
                return 1;
        }
  
        /* only change group if it has changed */
        if ( client->group == NULL || strcmp(client->group->newsgroup, group) != 0 ) 
        {
                /* check for read permission */
                if ( ! match_expression((unsigned char *)group
                                        , (unsigned char *)getwildmat(client->user->readpat)
                                        , 0) ) 
                {
                        if ( ! nogroupecho )
                                swriteclient(client, MSG_NOSUCHGROUP);
                        return 1;
                }

                /* find and load our new group */
                if ( (newgroup = getgroup(group)) == NULL ) 
                {
                        if ( ! nogroupecho )
                                swriteclient(client, MSG_NOSUCHGROUP);
                        return 1;
                }

                if ( (svr=getserver(newgroup->server)) == NULL )
                        return swriteclient(client, "500 Cant find server for group\r\n");

                /* disconnect first if we have to change server */
                if ( client->groupserver != NULL &&
                        client->connected == 1 &&
                        strcmp(svr->Groups, client->groupserver->Groups) != 0 )
                {
                        disconnect_server(client);
                }

                /* close group and reconnect */
                closegroup();
                client->group = newgroup;

                switch ( connect_groupserver(client, svr->Name) )
                {
                        case CONNECT_ERR:
                                return swriteclient(client, "500 Error selecting server\r\n");

                        case CONNECT_DOWN:
                                sleep(cfg.DownDelay);
                                return writeclient(client, MSG_SERVER_DOWN);

                        default:
                                break;
                }

                /* reset by connect_groupserver (via disconnect_server FIXME) */
                client->group = newgroup;

                client->groups++;
        }

        if ( ! writeserver(client, "GROUP %s\r\n", group) ) return -1;
        if ( ! readserver(client, b, MAX_SERVERRSP-1) ) return -1;

        syslog(LOG_NOTICE, "%s: group %s", client->hostname, group);

        if ( ! nogroupecho ) return swriteclient(client,b);
        return 0;
}
Exemplo n.º 12
0
void skill_editor(Client *conn, const char *argument)
{
    char arg[100];
    argument = one_argument(argument, arg);

    if (!str_cmp(arg, "Q"))
    {
        finish_editing(conn);
        return;
    }

    if (!str_prefix(arg, "show"))
    {
        conn->editing->show(conn);
        return;
    }
    Skill *skill = (Skill *) conn->editing->data;

    if (!str_cmp(arg, "save"))
    {
        save_skill(skill);
        xwriteln(conn, "~CSkill saved.~x");
        return;
    }

    if (!str_cmp(arg, "list"))
    {
        skill_edit_list(conn);
        return;
    }

    if (!str_cmp(arg, "A") || !str_cmp(arg, "name"))
    {

        if (nullstr(argument))
        {
            xwriteln(conn, "~CChange skill name to what?~x");
            return;
        }
        free_str(skill->name);
        skill->name = str_dup(argument);
        conn->editing->show(conn);
        return;
    }

    if (!str_cmp(arg, "B") || !str_cmp(arg, "damage"))
    {

        if (nullstr(argument))
        {
            free_str(skill->damage);
            skill->damage = str_empty;
        }

        else
        {
            free_str(skill->name);
            skill->damage = str_dup(argument);
        }
        conn->editing->show(conn);
        return;
    }

    if (!str_cmp(arg, "C") || !str_cmp(arg, "msgOff"))
    {

        if (nullstr(argument))
        {
            free_str(skill->msgOff);
            skill->msgOff = str_empty;
        }

        else
        {
            free_str(skill->msgOff);
            skill->msgOff = str_dup(argument);
        }
        conn->editing->show(conn);
        return;
    }

    if (!str_cmp(arg, "D") || !str_cmp(arg, "msgObj"))
    {

        if (nullstr(argument))
        {
            free_str(skill->msgObj);
            skill->msgObj = str_empty;
        }

        else
        {
            free_str(skill->msgObj);
            skill->msgObj = str_dup(argument);
        }
        conn->editing->show(conn);
        return;
    }

    if (!str_cmp(arg, "F") || !str_cmp(arg, "mana"))
    {

        if (!is_number(argument))
        {
            xwriteln(conn, "~CThat is not a number.~x");
            return;
        }
        skill->mana = atoi(argument);
        conn->editing->show(conn);
    }

    if (!str_cmp(arg, "E") || !str_cmp(arg, "wait"))
    {

        if (!is_number(argument))
        {
            xwriteln(conn, "~CThat is not a number.~x");
            return;
        }
        skill->mana = atoi(argument);
        conn->editing->show(conn);
        return;
    }

    if (!str_cmp(arg, "G") || !str_cmp(arg, "cost"))
    {

        if (!is_number(argument))
        {
            xwriteln(conn, "~CThat is not a number.~x");
            return;
        }
        skill->mana = (float) atof(argument);
        conn->editing->show(conn);
        return;
    }

    if (!str_cmp(arg, "H") || !str_cmp(arg, "spell"))
    {

        if (nullstr(argument))
        {
            skill->spellfun = 0;
        }

        else
        {
            skill->spellfun = spellfun_lookup(argument);

            if (skill->spellfun == 0)
            {
                xwriteln(conn, "~CValid spells are:~x");
                int i;

                for (i = 0; spellfun_table[i].name != 0; i++)
                {
                    xwritef(conn, "%-10s ",
                            spellfun_table[i].name);

                    if (i % 4 == 0) {
                        xwriteln(conn, "");
                    }
                }

                if (i % 4 != 0) {
                    xwriteln(conn, "");
                }
                return;
            }
        }
        conn->editing->show(conn);
        return;
    }

    if (!str_cmp(arg, "I") || !str_cmp(arg, "gsn"))
    {

        if (nullstr(argument))
        {
            skill->pgsn = 0;
            conn->editing->show(conn);
            return;
        }
        skill->pgsn = gsn_lookup(argument);

        if (skill->pgsn == 0)
        {
            xwriteln(conn, "~CValid gsns are:~x");
            int i;

            for (i = 0; gsn_table[i].name != 0; i++)
            {
                xwritef(conn, "%-10s ", gsn_table[i].name);

                if (i % 4 == 0) {
                    xwriteln(conn, "");
                }
            }

            if (i % 4 != 0) {
                xwriteln(conn, "");
            }
            return;
        }
        conn->editing->show(conn);
        return;
    }

    if (!str_cmp(arg, "J") || !str_cmp(arg, "minpos"))
    {
        long pos = value_lookup(position_table, argument);

        if (pos == -1)
        {
            xwritelnf(conn, "~CValid positions are: ~W%s~x",
                      lookup_names(position_table));
            return;
        }
        skill->minPos = (position_t) pos;
        conn->editing->show(conn);
        return;
    }

    if (!str_cmp(arg, "K") || !str_cmp(arg, "flags"))
    {

        if (edit_flag
                ("flags", conn, &skill->flags, argument, skill_flags)) {
            conn->editing->show(conn);
        }
        return;
    }

    if (!str_cmp(arg, "L") || !str_cmp(arg, "levels"))
    {
        char name[BUF_SIZ];
        argument = one_argument(argument, name);
        int c = class_lookup(name);

        if (c == -1)
        {
            xwriteln(conn, "~CValid classes are:~W");

            for (int i = 0; i < max_class; i++)
            {
                xwritef(conn, "%s ", class_table[i].name);
            }
            xwriteln(conn, "~x");
            return;
        }

        if (!is_number(argument))
        {
            xwriteln(conn, "~CThat is not a valid level.~x");
            return;
        }
        skill->levels[c] = atoi(argument);
        conn->editing->show(conn);
        return;
    }
}
Exemplo n.º 13
0
void ec_set(char *from, char *to)
{
	Chan	*chan;
	UniVar	*varval;
	char	num[20];
	char	*src;
	int	which,uaccess;

	src = ec_src;
	while(*src && *src != ')')
		src++;
	if (*src != ')')
		return;
	*(src++) = 0;

	if ((which = find_setting(ec_src)) >= 0)
	{
		if (which >= CHANSET_SIZE)
		{
			uaccess = get_useraccess(from,ANY_CHANNEL);
			varval = &current->setting[which];
		}
		else
		if ((chan = find_channel_ny(to)))
		{
			uaccess = get_useraccess(from,to);
			varval = &chan->setting[which];
		}
		else
		{
			nobo_strcpy("(unknown channel)");
			return;
		}
		if (uaccess < VarName[which].uaccess)
			return;

		if (IsProc(which))
			varval = varval->proc_var;

		if (IsChar(which))
		{
			num[0] = varval->char_var;
			num[1] = 0;
			nobo_strcpy(num);
		}
		else
		if (IsInt(which))
		{
			sprintf(num,"%i",varval->int_var);
			nobo_strcpy(num);
		}
		else
		if (IsTog(which))
		{
			nobo_strcpy((varval->int_var) ? "on" : "off");
		}
		else
		if (IsStr(which))
		{
			nobo_strcpy(nullstr(varval->str_var));
		}
	}
	else
	{
		nobo_strcpy("(unknown setting)");
	}
	ec_src = src;
}