root/1.8.3/trunk/hdrs/externs.h

/**
 * \file externs.h
 *
 * \brief Header file for external functions called from many source files.
 *
 *
 */

#ifndef __EXTERNS_H
#define __EXTERNS_H
/* Get the time_t definition that we use in prototypes here */
#include <time.h>
#ifdef I_LIBINTL
#include <libintl.h>
#endif
#if defined(HAVE_GETTEXT) && !defined(DONT_TRANSLATE)
/** Macro for a translated string */
#define T(str) gettext(str)
/** Macro to note that a string has a translation but not to translate */
#define N_(str) gettext_noop(str)
#else
#define T(str) str
#define N_(str) str
#endif
#include "config.h"
#include "copyrite.h"
#include "compile.h"
#include "mushtype.h"
#include "dbdefs.h"
#include "confmagic.h"
#include "mypcre.h"

#ifndef HAVE_STRCASECMP
#ifdef HAVE__STRICMP
#define strcasecmp(s1,s2) _stricmp((s1), (s2))
#else
extern int strcasecmp(const char *s1, const char *s2);
#endif
#endif

#ifndef HAVE_STRNCASECMP
#ifdef HAVE__STRNICMP
#define strncasecmp(s1,s2,n) _strnicmp((s1), (s2), (n))
#else
extern int strncasecmp(const char *s1, const char *s2, size_t n);
#endif
#endif

/* these symbols must be defined by the interface */
extern time_t mudtime;

#define FOPEN_READ "rb"      /**< Arguments to fopen when reading */
#define FOPEN_WRITE "wb"     /**< Arguments to fopen when writing */

int shutdown_flag;              /* if non-zero, interface should shut down */
void emergency_shutdown(void);
void boot_desc(DESC *d);        /* remove a player */
DESC *player_desc(dbref player);        /* find descriptors */
DESC *inactive_desc(dbref player);      /* find descriptors */
DESC *port_desc(int port);      /* find descriptors */
void WIN32_CDECL flag_broadcast(const char *flag1,
                                const char *flag2, const char *fmt, ...)
  __attribute__ ((__format__(__printf__, 3, 4)));

void raw_notify(dbref player, const char *msg);
void notify_list(dbref speaker, dbref thing, const char *atr,
                 const char *msg, int flags);
dbref short_page(const char *match);
dbref visible_short_page(dbref player, const char *match);
void do_doing(dbref player, const char *message);

/* the following symbols are provided by game.c */
void process_command(dbref player, char *command, dbref cause, int from_port);
int init_game_dbs(void);
void init_game_postdb(const char *conf);
void init_game_config(const char *conf);
void dump_database(void);
void NORETURN mush_panic(const char *message);
void NORETURN mush_panicf(const char *fmt, ...)
  __attribute__ ((__format__(__printf__, 1, 2)));
char *scan_list(dbref player, char *command);


#ifdef WIN32
/* From timer.c */
void init_timer(void);
#endif                          /* WIN32 */

/* From log.c */
void penn_perror(const char *);

/* From wait.c */
int lock_file(FILE *);
int unlock_file(FILE *);

/* From bsd.c */
extern FILE *connlog_fp;
extern FILE *checklog_fp;
extern FILE *wizlog_fp;
extern FILE *tracelog_fp;
extern FILE *cmdlog_fp;
extern int restarting;
#ifdef SUN_OS
extern int f_close(FILE * file);
/** SunOS fclose macro */
#define fclose(f) f_close(f);
#endif
int hidden(dbref player);
dbref guest_to_connect(dbref player);
void dump_reboot_db(void);
void close_ssl_connections(void);
int least_idle_time(dbref player);
int least_idle_time_priv(dbref player);
int most_conn_time(dbref player);
int most_conn_time_priv(dbref player);
char *least_idle_ip(dbref player);
char *least_idle_hostname(dbref player);

/* sql.c */
void sql_shutdown(void);

/* The #defs for our notify_anything hacks.. Errr. Functions */
#define NA_NORELAY      0x0001  /**< Don't relay sound */
#define NA_NOENTER      0x0002  /**< No newline at end */
#define NA_NOLISTEN     0x0004  /**< Implies NORELAY. Sorta. */
#define NA_NOPENTER     0x0010  /**< No newline, Pueblo-stylee */
#define NA_PONLY        0x0020  /**< Pueblo-only */
#define NA_PUPPET       0x0040  /**< Ok to puppet */
#define NA_PUPPET2      0x0080  /**< Message to a player from a puppet */
#define NA_MUST_PUPPET  0x0100  /**< Ok to puppet even in same room */
#define NA_INTER_HEAR   0x0200  /**< Message is auditory in nature */
#define NA_INTER_SEE    0x0400  /**< Message is visual in nature */
#define NA_INTER_PRESENCE  0x0800       /**< Message is about presence */
#define NA_NOSPOOF        0x1000        /**< Message comes via a NO_SPOOF object. */
#define NA_PARANOID       0x2000        /**< Message comes via a PARANOID object. */
#define NA_NOPREFIX       0x4000        /**< Don't use @prefix when forwarding */
#define NA_SPOOF        0x8000  /**< @ns* message, overrides NOSPOOF */
#define NA_INTER_LOCK  0x10000  /**< Message subject to @lock/interact even if not otherwise marked */
#define NA_INTERACTION  (NA_INTER_HEAR|NA_INTER_SEE|NA_INTER_PRESENCE|NA_INTER_LOCK)    /**< Message follows interaction rules */
#define NA_PROMPT       0x20000  /**< Message is a prompt, add GOAHEAD */

/** A notify_anything lookup function type definition */
typedef dbref (*na_lookup) (dbref, void *);
void notify_anything(dbref speaker, na_lookup func,
                     void *fdata,
                     char *(*nsfunc) (dbref,
                                      na_lookup func,
                                      void *, int), int flags,
                     const char *message);
void notify_anything_format(dbref speaker, na_lookup func,
                            void *fdata,
                            char *(*nsfunc) (dbref,
                                             na_lookup func,
                                             void *, int), int flags,
                            const char *fmt, ...)
  __attribute__ ((__format__(__printf__, 6, 7)));
void notify_anything_loc(dbref speaker, na_lookup func,
                         void *fdata,
                         char *(*nsfunc) (dbref,
                                          na_lookup func,
                                          void *, int), int flags,
                         const char *message, dbref loc);
dbref na_one(dbref current, void *data);
dbref na_next(dbref current, void *data);
dbref na_loc(dbref current, void *data);
dbref na_nextbut(dbref current, void *data);
dbref na_except(dbref current, void *data);
dbref na_except2(dbref current, void *data);
dbref na_exceptN(dbref current, void *data);
dbref na_channel(dbref current, void *data);
char *ns_esnotify(dbref speaker, na_lookup func, void *fdata, int para);

/** Basic 'notify player with message */
#define notify(p,m)           notify_anything(orator, na_one, &(p), NULL, 0, m)
/** Notify player as a prompt */
#define notify_prompt(p,m)           notify_anything(orator, na_one, &(p), NULL, NA_PROMPT, m)
/** Notify puppet with message, even if owner's there */
#define notify_must_puppet(p,m)           notify_anything(orator, na_one, &(p), NULL, NA_MUST_PUPPET, m)
/** Notify puppet with message as prompt, even if owner's there */
#define notify_prompt_must_puppet(p,m)           notify_anything(orator, na_one, &(p), NULL, NA_MUST_PUPPET|NA_PROMPT, m)
/** Notify player with message, as if from somethign specific */
#define notify_by(t,p,m)           notify_anything(t, na_one, &(p), NULL, 0, m)
/** Notfy player with message, but only puppet propagation */
#define notify_noecho(p,m)    notify_anything(orator, na_one, &(p), NULL, NA_NORELAY | NA_PUPPET, m)
/** Notify player with message if they're not set QUIET */
#define quiet_notify(p,m)     if (!IsQuiet(p)) notify(p,m)
/** Notify player but don't send \n */
#define notify_noenter_by(t,a,b) notify_anything(t, na_one, &(a), NULL, NA_NOENTER, b)
#define notify_noenter(a,b) notify_noenter_by(GOD, a, b)
/** Notify player but don't send <BR> if they're using Pueblo */
#define notify_nopenter_by(t,a,b) notify_anything(t, na_one, &(a), NULL, NA_NOPENTER, b)
#define notify_nopenter(a,b) notify_nopenter_by(GOD, a, b)
/* Notify with a printf-style format */
void notify_format(dbref player, const char *fmt, ...)
  __attribute__ ((__format__(__printf__, 2, 3)));

/* From command.c */
void generic_command_failure(dbref player, dbref cause, char *string);

/* From compress.c */
/* Define this to get some statistics on the attribute compression
 * in @stats/tables. Only for word-based compression (COMPRESSION_TYPE 3 or 4
 */
/* #define COMP_STATS /* */
#if (COMPRESSION_TYPE != 0)
unsigned char *
text_compress(char const *s)
  __attribute_malloc__;
#define compress(str) text_compress(str)
    char *text_uncompress(unsigned char const *s);
#define uncompress(str) text_uncompress(str)
    char *safe_uncompress(unsigned char const *s) __attribute_malloc__;
#else
extern char ucbuff[];
#define init_compress(f) 0
#define compress(s) ((unsigned char *)strdup(s))
#define uncompress(s) (strcpy(ucbuff, (char *) s))
#define safe_uncompress(s) (strdup((char *) s))
#endif

/* From cque.c */
struct _ansi_string;
struct real_pcre;
struct eval_context {
  char *wenv[10];                 /**< working environment (%0-%9) */
  char renv[NUMQ][BUFFER_LEN];    /**< working registers q0-q9,qa-qz */
  char *wnxt[10];                 /**< environment to shove into the queue */
  char *rnxt[NUMQ];               /**< registers to shove into the queue */
  int process_command_port;   /**< port number that a command came from */
  dbref cplr;                     /**< initiating player */
  char ccom[BUFFER_LEN];          /**< raw command */
  char ucom[BUFFER_LEN];      /**< evaluated command */
  int break_called;           /**< Has the break command been called? */
  char break_replace[BUFFER_LEN];  /**< What to replace the break with */
  struct real_pcre *re_code;              /**< The compiled re */
  int re_subpatterns;         /**< The number of re subpatterns */
  int *re_offsets;            /**< The offsets for the subpatterns */
  struct _ansi_string *re_from;             /**< The positions of the subpatterns */
};

typedef struct eval_context EVAL_CONTEXT;
extern EVAL_CONTEXT global_eval_context;

void do_second(void);
int do_top(int ncom);
void do_halt(dbref owner, const char *ncom, dbref victim);
void parse_que(dbref player, const char *command, dbref cause);
int queue_attribute_base
  (dbref executor, const char *atrname, dbref enactor, int noparent);
ATTR *queue_attribute_getatr(dbref executor, const char *atrname, int noparent);
int queue_attribute_useatr(dbref executor, ATTR *a, dbref enactor);

/** Queue the code in an attribute, including parent objects */
#define queue_attribute(a,b,c) queue_attribute_base(a,b,c,0)
/** Queue the code in an attribute, excluding parent objects */
#define queue_attribute_noparent(a,b,c) queue_attribute_base(a,b,c,1)
void dequeue_semaphores(dbref thing, char const *aname, int count,
                        int all, int drain);
void shutdown_queues(void);

/* Regexp saving helpers */
struct re_save {
  struct real_pcre *re_code;              /**< The compiled re */
  int re_subpatterns;         /**< The number of re subpatterns */
  int *re_offsets;            /**< The offsets for the subpatterns */
  struct _ansi_string *re_from;             /**< The positions of the subpatterns */
};

/* From create.c */
dbref do_dig(dbref player, const char *name, char **argv, int tport);
dbref do_create(dbref player, char *name, int cost);
dbref do_real_open(dbref player, const char *direction,
                   const char *linkto, dbref pseudo);
void do_open(dbref player, const char *direction, char **links);
void do_link(dbref player, const char *name, const char *room_name,
             int preserve);
void do_unlink(dbref player, const char *name);
dbref do_clone(dbref player, char *name, char *newname, int preserve);

/* From funtime.c */
int etime_to_secs(char *str1, int *secs);

/* From game.c */
void report(void);
int Hearer(dbref thing);
int Commer(dbref thing);
int Listener(dbref thing);
extern dbref orator;
int parse_chat(dbref player, char *command);
void fork_and_dump(int forking);
void reserve_fd(void);
void release_fd(void);


/* From look.c */
/** Enumeration of types of looks that can be performed */
enum look_type { LOOK_NORMAL, LOOK_TRANS, LOOK_AUTO, LOOK_CLOUDYTRANS,
  LOOK_CLOUDY
};
void look_room(dbref player, dbref loc, enum look_type style);
void do_look_around(dbref player);
void do_look_at(dbref player, const char *name, int key);
char *decompose_str(char *what);

/* From memcheck.c */
void add_check(const char *ref);
void del_check(const char *ref, const char *filename, int line);
void list_mem_check(dbref player);
void log_mem_check(void);

/* From move.c */
void enter_room(dbref player, dbref loc, int nomovemsgs);
int can_move(dbref player, const char *direction);
/** Enumeration of types of movements that can be performed */
enum move_type { MOVE_NORMAL, MOVE_GLOBAL, MOVE_ZONE };
void do_move(dbref player, const char *direction, enum move_type type);
void moveto(dbref what, dbref where);
void safe_tel(dbref player, dbref dest, int nomovemsgs);
int global_exit(dbref player, const char *direction);
int remote_exit(dbref loc, const char *direction);
void move_wrapper(dbref player, const char *command);
void do_follow(dbref player, const char *arg);
void do_unfollow(dbref player, const char *arg);
void do_desert(dbref player, const char *arg);
void do_dismiss(dbref player, const char *arg);
void clear_followers(dbref leader, int noisy);
void clear_following(dbref follower, int noisy);

/* From mycrypt.c */
char *mush_crypt(const char *key);

/* From player.c */
int password_check(dbref player, const char *password);
dbref lookup_player(const char *name);
dbref lookup_player_name(const char *name);
/* from player.c */
dbref create_player(const char *name, const char *password,
                    const char *host, const char *ip);
dbref connect_player(const char *name, const char *password,
                     const char *host, const char *ip, char *errbuf);
void check_last(dbref player, const char *host, const char *ip);
void check_lastfailed(dbref player, const char *host);

/* From parse.c */
bool is_number(const char *str);
bool is_strict_number(const char *str);
bool is_strict_integer(const char *str);
#ifdef HAVE_ISNORMAL
#define is_good_number(n) isnormal((n))
#else
bool is_good_number(NVAL val);
#endif

/* From plyrlist.c */
void clear_players(void);
void add_player(dbref player);
void add_player_alias(dbref player, const char *alias);
void delete_player(dbref player, const char *alias);
void reset_player_list(dbref player, const char *oldname, const char *oldalias,
                       const char *name, const char *alias);

/* From predicat.c */
char *WIN32_CDECL tprintf(const char *fmt, ...)
  __attribute__ ((__format__(__printf__, 1, 2)));

int could_doit(dbref player, dbref thing);
int did_it(dbref player, dbref thing, const char *what,
           const char *def, const char *owhat, const char *odef,
           const char *awhat, dbref loc);
int did_it_with(dbref player, dbref thing, const char *what,
                const char *def, const char *owhat, const char *odef,
                const char *awhat, dbref loc, dbref env0, dbref env1,
                int flags);
int did_it_interact(dbref player, dbref thing, const char *what,
                    const char *def, const char *owhat,
                    const char *odef, const char *awhat, dbref loc, int flags);
int real_did_it(dbref player, dbref thing, const char *what,
                const char *def, const char *owhat, const char *odef,
                const char *awhat, dbref loc, char *myenv[10], int flags);
int can_see(dbref player, dbref thing, int can_see_loc);
int controls(dbref who, dbref what);
int can_pay_fees(dbref who, int pennies);
void giveto(dbref who, int pennies);
int payfor(dbref who, int cost);
int quiet_payfor(dbref who, int cost);
int nearby(dbref obj1, dbref obj2);
int get_current_quota(dbref who);
void change_quota(dbref who, int payment);
int ok_name(const char *name);
int ok_command_name(const char *name);
int ok_function_name(const char *name);
int ok_player_name(const char *name, dbref player, dbref thing);
int ok_player_alias(const char *alias, dbref player, dbref thing);
int ok_password(const char *password);
int ok_tag_attribute(dbref player, const char *params);
dbref parse_match_possessor(dbref player, char **str);
void page_return(dbref player, dbref target, const char *type,
                 const char *message, const char *def);
char *grep_util(dbref player, dbref thing, char *pattern,
                char *lookfor, int sensitive, int wild);
dbref where_is(dbref thing);
int charge_action(dbref player, dbref thing, const char *awhat);
dbref first_visible(dbref player, dbref thing);

/* From rob.c */
void s_Pennies(dbref thing, int amount);

/* From set.c */
void chown_object(dbref player, dbref thing, dbref newowner, int preserve);

/* From speech.c */
int vmessageformat(dbref player, const char *attribute,
                   dbref executor, int flags, int nargs, ...);
int messageformat(dbref player, const char *attribute,
                  dbref executor, int flags, int nargs, char *argv[]);
void do_message_list(dbref player, dbref enactor, char *list, char *attrname,
                     char *message, int flags, int numargs, char *argv[]);
const char *spname(dbref thing);
void notify_except(dbref first, dbref exception, const char *msg, int flags);
void notify_except2(dbref first, dbref exc1, dbref exc2,
                    const char *msg, int flags);
/* Return thing/PREFIX + msg */
void make_prefixstr(dbref thing, const char *msg, char *tbuf1);
int filter_found(dbref thing, const char *msg, int flag);

/* From strutil.c */
char *split_token(char **sp, char sep);
char *chopstr(const char *str, size_t lim);
int string_prefix(const char *restrict string, const char *restrict prefix);
const char *string_match(const char *src, const char *sub);
char *strupper(const char *s);
char *strlower(const char *s);
char *strinitial(const char *s);