src/commac.c File Reference

#include "copyright.h"
#include "config.h"
#include <ctype.h>
#include <sys/types.h>
#include "db.h"
#include "interface.h"
#include "match.h"
#include "externs.h"
#include "commac.h"

Include dependency graph for commac.c:

Go to the source code of this file.

Functions
void	load_comsystem (FILE *)
void	load_macros (FILE *)
void	save_comsystem (FILE *)
void	save_macros (FILE *)
void	load_comsys_and_macros (char *filename)
void	save_comsys_and_macros (char *filename)
void	load_commac (FILE *fp)
void	purge_commac (void)
void	save_commac (FILE *fp)
commac *	create_new_commac (void)
commac *	get_commac (dbref which)
void	add_commac (struct commac *c)
void	del_commac (dbref who)
void	destroy_commac (struct commac *c)
void	sort_com_aliases (struct commac *c)

---

Function Documentation

void add_commac

(

struct commac *

c

)

Definition at line 245 of file commac.c.

References c, commac_table, coolmenu_type::next, and NUM_COMMAC.

Referenced by get_commac(), load_commac(), and mmdb_db_read().

{
        if(c->who < 0)
                return;

        c->next = commac_table[c->who % NUM_COMMAC];
        commac_table[c->who % NUM_COMMAC] = c;
}

struct commac* create_new_commac

(

void

)

Definition at line 204 of file commac.c.

References c, and coolmenu_type::next.

Referenced by get_commac(), load_commac(), and mmdb_db_read().

{
        struct commac *c;
        int i;

        c = (struct commac *) malloc(sizeof(struct commac));

        c->who = -1;
        c->numchannels = 0;
        c->maxchannels = 0;
        c->alias = NULL;
        c->channels = NULL;

        c->curmac = -1;
        for(i = 0; i < 5; i++)
                c->macros[i] = -1;

        c->next = NULL;
        return c;
}

void del_commac

(

dbref

who

)

Definition at line 254 of file commac.c.

References c, commac_table, destroy_commac(), coolmenu_type::next, commac::next, and NUM_COMMAC.

Referenced by purge_commac(), and toast_player().

{
        struct commac *c;
        struct commac *last;

        if(who < 0)
                return;

        c = commac_table[who % NUM_COMMAC];

        if(c == NULL)
                return;

        if(c->who == who) {
                commac_table[who % NUM_COMMAC] = c->next;
                destroy_commac(c);
                return;
        }
        last = c;
        c = c->next;
        while (c) {
                if(c->who == who) {
                        last->next = c->next;
                        destroy_commac(c);
                        return;
                }
                last = c;
                c = c->next;
        }
}

void destroy_commac

(

struct commac *

c

)

Definition at line 285 of file commac.c.

References c.

Referenced by del_commac().

{
        int i;

        free(c->alias);
        for(i = 0; i < c->numchannels; i++)
                free(c->channels[i]);
        free(c->channels);
        free(c);
}

struct commac* get_commac

(

dbref

which

)

Definition at line 225 of file commac.c.

References add_commac(), c, commac_table, create_new_commac(), coolmenu_type::next, and NUM_COMMAC.

Referenced by do_add_macro(), do_addcom(), do_allcom(), do_clear_macro(), do_clearcom(), do_comconnect(), do_comdisconnect(), do_comlist(), do_create_macro(), do_del_macro(), do_delcom(), do_edit_macro(), do_process_macro(), do_status_macro(), get_channel_from_alias(), and get_macro_set().

{
        struct commac *c;

        if(which < 0)
                return NULL;

        c = commac_table[which % NUM_COMMAC];

        while (c && (c->who != which))
                c = c->next;

        if(!c) {
                c = create_new_commac();
                c->who = which;
                add_commac(c);
        }
        return c;
}

void load_commac

(

FILE *

fp

)

Definition at line 91 of file commac.c.

References add_commac(), c, create_new_commac(), God, Going, Owner, purge_commac(), sort_com_aliases(), StringCopy, TYPE_PLAYER, and Typeof.

Referenced by load_comsys_and_macros().

{
        int i, j;
        char buffer[100];
        int np;
        struct commac *c;
        char *t;
        char in;

        fscanf(fp, "%d\n", &np);
        for(i = 0; i < np; i++) {
                c = create_new_commac();
                fscanf(fp, "%d %d %d %d %d %d %d %d\n", &(c->who),
                           &(c->numchannels), &(c->macros[0]), &(c->macros[1]),
                           &c->macros[2], &(c->macros[3]), &(c->macros[4]), &(c->curmac));
                c->maxchannels = c->numchannels;
                if(c->maxchannels > 0) {
                        c->alias = (char *) malloc(c->maxchannels * 6);
                        c->channels = (char **) malloc(sizeof(char *) * c->maxchannels);

                        for(j = 0; j < c->numchannels; j++) {
                                t = c->alias + j * 6;
                                while ((in = fgetc(fp)) != ' ')
                                        *t++ = in;
                                *t = 0;

                                fscanf(fp, "%[^\n]\n", buffer);

                                c->channels[j] = (char *) malloc(strlen(buffer) + 1);
                                StringCopy(c->channels[j], buffer);
                        }
                        sort_com_aliases(c);
                } else {
                        c->alias = NULL;
                        c->channels = NULL;
                }
                if((Typeof(c->who) == TYPE_PLAYER) || (!God(Owner(c->who))) ||
                   ((!Going(c->who))))
                        add_commac(c);
                purge_commac();
        }
}

void load_comsys_and_macros

(

char *

filename

)

Definition at line 23 of file commac.c.

References commac_table, load_commac(), load_comsystem(), load_macros(), and NUM_COMMAC.

Referenced by load_game().

{
        FILE *fp;
        int i;
        char buffer[200];

        for(i = 0; i < NUM_COMMAC; i++)
                commac_table[i] = NULL;

        if(!(fp = fopen(filename, "r"))) {
                fprintf(stderr, "Error: Couldn't find %s.\n", filename);
        } else {
                fprintf(stderr, "LOADING: %s\n", filename);
                if(fscanf(fp, "*** Begin %s ***\n", buffer) == 1 &&
                   !strcmp(buffer, "COMMAC")) {
                        load_commac(fp);
                } else {
                        fprintf(stderr, "Error: Couldn't find Begin COMMAC in %s.",
                                        filename);
                        return;
                }

                if(fscanf(fp, "*** Begin %s ***\n", buffer) == 1 &&
                   !strcmp(buffer, "COMSYS")) {
                        load_comsystem(fp);
                } else {
                        fprintf(stderr, "Error: Couldn't find Begin COMSYS in %s.",
                                        filename);
                        return;
                }

                if(fscanf(fp, "*** Begin %s ***\n", buffer) == 1 &&
                   !strcmp(buffer, "MACRO")) {
                        load_macros(fp);
                } else {
                        fprintf(stderr, "Error: Couldn't find Begin MACRO in %s.",
                                        filename);
                        return;
                }

                fclose(fp);
                fprintf(stderr, "LOADING: %s (done)\n", filename);
        }
}

void load_comsystem

(

FILE *

)

Definition at line 93 of file comsys.c.

Referenced by load_comsys_and_macros().

{
        int i, j, k, dummy;
        int nc, new = 0;
        struct channel *ch;
        struct comuser *user;
        char temp[LBUF_SIZE];
        char buf[8];

        num_channels = 0;

        fgets(buf, sizeof(buf), fp);
        if(!strncmp(buf, "+V2", 3)) {
                new = 2;
                fscanf(fp, "%d\n", &nc);
        } else if(!strncmp(buf, "+V1", 3)) {
                new = 1;
                fscanf(fp, "%d\n", &nc);
        } else
                nc = atoi(buf);

        num_channels = nc;

        for(i = 0; i < nc; i++) {
                ch = (struct channel *) malloc(sizeof(struct channel));

                fscanf(fp, "%[^\n]\n", temp);

                strncpy(ch->name, temp, CHAN_NAME_LEN);
                ch->name[CHAN_NAME_LEN - 1] = '\0';
                ch->on_users = NULL;

                hashadd(ch->name, (int *) ch, &mudstate.channel_htab);

                ch->last_messages = NULL;

                if(new) {                               /* V1 or higher */

                        if(fscanf(fp,
                                          new ==
                                          1 ? "%d %d %d %d %d %d %d %d\n" :
                                          "%d %d %d %d %d %d %d %d %d\n", &(ch->type),
                                          &(ch->temp1), &(ch->temp2), &(ch->charge),
                                          &(ch->charge_who), &(ch->amount_col),
                                          &(ch->num_messages), &(ch->chan_obj), &dummy) >= 9 &&
                           new > 1) {
                                /* Do things with 'dummy' */
                                if(dummy > 0) {
                                        for(j = 0; j < dummy; j++) {
                                                chmsg *c;

                                                fscanf(fp, "%d %[^\n]\n", &k, temp);
                                                Create(c, chmsg, 1);
                                                c->msg = strdup(temp);
                                                c->time = k;
                                                myfifo_push(&ch->last_messages, c);
                                        }
                                }
                        }
                } else {
                        fscanf(fp, "%d %d %d %d %d %d %d %d %d %d\n", &(ch->type),
                                   &(dummy), &(ch->temp1), &(ch->temp2), &(dummy),
                                   &(ch->charge), &(ch->charge_who), &(ch->amount_col),
                                   &(ch->num_messages), &(ch->chan_obj));
                }

                fscanf(fp, "%d\n", &(ch->num_users));
                ch->max_users = ch->num_users;
                if(ch->num_users > 0) {
                        ch->users = (struct comuser **)
                                calloc(ch->max_users, sizeof(struct comuser *));

                        for(j = 0; j < ch->num_users; j++) {
                                user = (struct comuser *) malloc(sizeof(struct comuser));

                                ch->users[j] = user;

                                if(new) {
                                        fscanf(fp, "%d %d\n", &(user->who), &(user->on));
                                } else {
                                        fscanf(fp, "%d %d %d", &(user->who), &(dummy), &(dummy));
                                        fscanf(fp, "%d\n", &(user->on));
                                }

                                fscanf(fp, "%[^\n]\n", temp);

                                user->title = strdup(temp + 2);

                                if(!(isPlayer(user->who)) && !(Going(user->who) &&
                                                                                           (God(Owner(user->who))))) {
                                        do_joinchannel(user->who, ch);
                                        user->on_next = ch->on_users;
                                        ch->on_users = user;
                                } else {
                                        user->on_next = ch->on_users;
                                        ch->on_users = user;
                                }
                        }
                        sort_users(ch);
                } else
                        ch->users = NULL;
        }
}

void load_macros

(

FILE *

)

Definition at line 779 of file macro.c.

Referenced by load_comsys_and_macros().

{
        int i, j;
        char *c;
        char *t;
        char buffer[LBUF_SIZE];
        struct macros *m;

        TST(fscanf(fp, "%d\n", &nummacros) != 1, "Error: Loading #macros\n");
        maxmacros = nummacros;

        if(maxmacros > 0)
                macros =
                        (struct macros **) malloc(sizeof(struct macros *) * nummacros);
        else
                macros = NULL;

        for(i = 0; i < nummacros; i++) {
                macros[i] = (struct macros *) malloc(sizeof(struct macros));

                m = macros[i];

                fgets(buffer, LBUF_SIZE, fp);
                TST(sscanf(buffer, "%d %d %d\n", &(m->player), &(m->nummacros), &j)
                        != 3, tprintf("Reading macro set #%d\n", i));
                m->status = j;

                fgets(buffer, LBUF_SIZE, fp);
                if(*buffer)
                        if(buffer[strlen(buffer) - 1] == '\n')
                                buffer[strlen(buffer) - 1] = 0;

                m->desc = (char *) malloc(strlen(buffer) - 1);
                StringCopy(m->desc, buffer + 2);

                m->maxmacros = m->nummacros;
                if(m->nummacros > 0) {
                        m->alias = (char *) malloc(5 * m->maxmacros);
                        m->string = (char **) malloc(sizeof(char *) * m->nummacros);

                        for(j = 0; j < m->nummacros; j++) {
                                t = m->alias + j * 5;
                                fgets(buffer, LBUF_SIZE, fp);
                                if(buffer[strlen(buffer) - 1] == '\n')
                                        buffer[strlen(buffer) - 1] = 0;
                                for(c = buffer; *c && *c != ' '; c++);
                                *c = 0;
                                if(strlen(buffer) > 4) {
                                        fprintf(stderr, "Error reading macro set #%d!\n", i);
                                        exit(1);
                                }
                                if(!*buffer) {

/* fprintf(stderr, "Error in macro set #%d (macro %d) : Invalid macro name.\n", i, j); */
                                        t[0] = 0;
                                } else
                                        strcpy(t, buffer);
                                c++;
                                m->string[j] = (char *) malloc(strlen(c) + 1);
                                StringCopy(m->string[j], c);
                        }
                        do_sort_macro_set(m);
                } else {
                        m->alias = NULL;
                        m->string = NULL;
                }
        }
        while (1) {
                for(i = 0; i < nummacros; i++)
                        if(!isPlayer(macros[i]->player))
                                break;
                if(i >= nummacros)
                        break;
                clear_macro_set(i);
        }
}

void purge_commac

(

void

)

Definition at line 134 of file commac.c.

References c, commac_table, commac::curmac, del_commac(), God, Going, commac::macros, commac::next, NUM_COMMAC, commac::numchannels, Owner, TYPE_PLAYER, Typeof, and commac::who.

Referenced by load_commac(), mmdb_db_read(), mmdb_db_write(), and save_commac().

{
        struct commac *c;
        struct commac *d;
        int i;

#ifdef ABORT_PURGE_COMSYS
        return;
#endif /*
            * * ABORT_PURGE_COMSYS  
            */

        for(i = 0; i < NUM_COMMAC; i++) {
                c = commac_table[i];
                while (c) {
                        d = c;
                        c = c->next;
                        if(d->numchannels == 0 && d->curmac == -1 &&
                           d->macros[1] == -1 && d->macros[2] == -1 &&
                           d->macros[3] == -1 && d->macros[4] == -1 &&
                           d->macros[0] == -1) {
                                del_commac(d->who);
                                continue;
                        }

                        /*
                         * if ((Typeof(d->who) != TYPE_PLAYER) && (God(Owner(d->who))) &&
                         * * (Going(d->who))) 
                         */
                        if(Typeof(d->who) == TYPE_PLAYER)
                                continue;
                        if(God(Owner(d->who)) && Going(d->who)) {
                                del_commac(d->who);
                                continue;
                        }
                }
        }
}

void save_commac

(

FILE *

fp

)

Definition at line 173 of file commac.c.

References c, commac_table, commac::next, NUM_COMMAC, commac::numchannels, and purge_commac().

Referenced by save_comsys_and_macros().

{
        int np;
        struct commac *c;
        int i, j;

        purge_commac();
        np = 0;
        for(i = 0; i < NUM_COMMAC; i++) {
                c = commac_table[i];
                while (c) {
                        np++;
                        c = c->next;
                }
        }

        fprintf(fp, "%d\n", np);
        for(i = 0; i < NUM_COMMAC; i++) {
                c = commac_table[i];
                while (c) {
                        fprintf(fp, "%d %d %d %d %d %d %d %d\n", c->who,
                                        c->numchannels, c->macros[0], c->macros[1], c->macros[2],
                                        c->macros[3], c->macros[4], c->curmac);
                        for(j = 0; j < c->numchannels; j++) {
                                fprintf(fp, "%s %s\n", c->alias + j * 6, c->channels[j]);
                        }
                        c = c->next;
                }
        }
}

void save_comsys_and_macros

(

char *

filename

)

Definition at line 68 of file commac.c.

References save_commac(), save_comsystem(), and save_macros().

Referenced by dump_database_internal().

{
        FILE *fp;
        char buffer[500];

        sprintf(buffer, "%s.#", filename);
        if(!(fp = fopen(buffer, "w"))) {
                fprintf(stderr, "Unable to open %s for writing.\n", buffer);
                return;
        }
        fprintf(fp, "*** Begin COMMAC ***\n");
        save_commac(fp);

        fprintf(fp, "*** Begin COMSYS ***\n");
        save_comsystem(fp);

        fprintf(fp, "*** Begin MACRO ***\n");
        save_macros(fp);

        fclose(fp);
        rename(buffer, filename);
}

void save_comsystem

(

FILE *

)

Definition at line 204 of file comsys.c.

Referenced by save_comsys_and_macros().

{
        struct channel *ch;
        struct comuser *user;
        int j, k, player_users;

        fprintf(fp, "+V2\n");
        fprintf(fp, "%d\n", num_channels);
        for(ch = (struct channel *) hash_firstentry(&mudstate.channel_htab);
                ch; ch = (struct channel *) hash_nextentry(&mudstate.channel_htab)) {
                fprintf(fp, "%s\n", ch->name);
                k = myfifo_length(&ch->last_messages);
                /*            1  2  3  4  5  6  7  8  9 */
                fprintf(fp, "%d %d %d %d %d %d %d %d %d\n", ch->type, ch->temp1,
                                ch->temp2, ch->charge, ch->charge_who, ch->amount_col,
                                ch->num_messages, ch->chan_obj, k);

                if(k) {
                        temp_file = fp;
                        myfifo_trav_r(&ch->last_messages, do_save_com);
                }
                player_users = 0;
                for(j = 0; j < ch->num_users; j++)
                        if(isPlayer(ch->users[j]->who) || isRobot(ch->users[j]->who))
                                player_users++;

                fprintf(fp, "%d\n", player_users);
                for(j = 0; j < ch->num_users; j++) {
                        user = ch->users[j];
                        if(!isPlayer(user->who) && !isRobot(user->who))
                                continue;
                        fprintf(fp, "%d %d\n", user->who, user->on);
                        if(strlen(user->title))
                                fprintf(fp, "t:%s\n", user->title);
                        else
                                fprintf(fp, "t:\n");
                }
        }
}

void save_macros

(

FILE *

)

Definition at line 856 of file macro.c.

Referenced by save_comsys_and_macros().

{
        int i, j;
        struct macros *m;

        fprintf(fp, "%d\n", nummacros);

        for(i = 0; i < nummacros; i++) {
                m = macros[i];
                fprintf(fp, "%d %d %d\n", m->player, m->nummacros, (int) m->status);
                fprintf(fp, "D:%s\n", m->desc);
                for(j = 0; j < m->nummacros; j++)
                        fprintf(fp, "%s %s\n", m->alias + j * 5, m->string[j]);
        }
}

void sort_com_aliases

(

struct commac *

c

)

Definition at line 296 of file commac.c.

References c, and StringCopy.

Referenced by load_commac(), and mmdb_db_read().

{
        int i;
        int cont;
        char buffer[10];
        char *s;

        cont = 1;
        while (cont) {
                cont = 0;
                for(i = 0; i < c->numchannels - 1; i++)
                        if(strcasecmp(c->alias + i * 6, c->alias + (i + 1) * 6) > 0) {
                                StringCopy(buffer, c->alias + i * 6);
                                StringCopy(c->alias + i * 6, c->alias + (i + 1) * 6);
                                StringCopy(c->alias + (i + 1) * 6, buffer);
                                s = c->channels[i];
                                c->channels[i] = c->channels[i + 1];
                                c->channels[i + 1] = s;
                                cont = 1;
                        }
        }
}

---