/*
* struct.h: header file for structures needed for prototypes
*
* Written by Scott Reynolds, based on code by Michael Sandrof
*
* Copyright(c) 1995 Scott Reynolds.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)$eterna: struct.h,v 1.24 2005/09/21 20:03:01 mrg Exp $
*/
#ifndef __struct_h_
#define __struct_h_
/*
* ctcp_entry: the format for each ctcp function. note that the function
* described takes 4 parameters, a pointer to the ctcp entry, who the message
* was from, who the message was to (nickname, channel, etc), and the rest of
* the ctcp message. it can return null, or it can return a malloced string
* that will be inserted into the oringal message at the point of the ctcp.
* if null is returned, nothing is added to the original message
*/
typedef struct _ctcp_entry
{
u_char *name; /* name of ctcp datatag */
u_char *desc; /* description returned by ctcp clientinfo */
int flag;
u_char *(*func)(struct _ctcp_entry *, u_char *, u_char *, u_char *); /* function that does the dirty deed */
} CtcpEntry;
typedef struct DCC_struct
{
unsigned flags;
int read;
int write;
int file;
off_t filesize;
u_char *description;
u_char *user;
u_char *othername;
u_char *remname;
u_short remport;
off_t bytes_read;
off_t bytes_sent;
time_t lasttime;
time_t starttime;
u_char *buffer;
struct DCC_struct *next;
} DCC_list;
/* Hold: your general doubly-linked list type structure */
typedef struct HoldStru
{
u_char *str;
struct HoldStru *next;
struct HoldStru *prev;
int logged;
} Hold;
typedef struct lastlog_stru
{
int level;
u_char *msg;
struct lastlog_stru *next;
struct lastlog_stru *prev;
} Lastlog;
struct MenuOptionTag
{
u_char *Name;
u_char *Arguments;
void (*Func)(u_char *);
};
typedef struct MenuOptionTag MenuOption;
struct MenuTag
{
struct MenuTag *next;
u_char *Name;
int TotalOptions;
MenuOption **Options;
};
typedef struct MenuTag Menu;
struct ScreenStru; /* ooh! */
struct WindowMenuTag
{
Menu *menu;
int lines;
int items_per_line;
int cursor;
};
typedef struct WindowMenuTag WindowMenu;
/* NickList: structure for the list of nicknames of people on a channel */
typedef struct nick_stru
{
struct nick_stru *next; /* pointer to next nickname entry */
u_char *nick; /* nickname of person on channel */
int chanop; /* True if the given nick has chanop */
int hasvoice; /* Has voice? (Notice this is a bit unreliable if chanop) */
} NickList;
typedef struct DisplayStru
{
u_char *line;
int linetype;
struct DisplayStru *next;
} Display;
typedef struct WindowStru
{
unsigned int refnum; /* the unique reference number,
* assigned by IRCII */
u_char *name; /* window's logical name */
int server; /* server index */
int prev_server; /* previous server index */
int top; /* The top line of the window, screen
* coordinates */
int bottom; /* The botton line of the window, screen
* coordinates */
int cursor; /* The cursor position in the window, window
* relative coordinates */
int line_cnt; /* counter of number of lines displayed in
* window */
int scroll; /* true, window scrolls... false window wraps */
int display_size; /* number of lines of window - menu lines */
int old_size; /* if new_size != display_size,
* resize_display is called */
int visible; /* true, window is drawn... false window is
* hidden */
int update; /* window needs updating flag */
unsigned miscflags; /* Miscellaneous flags. */
u_char *prompt; /* A prompt string, usually set by EXEC'd process */
u_char *status_line[2]; /* The status line strings */
int double_status; /* Display the 2nd status line ?*/
Display *top_of_display, /* Pointer to first line of display structure */
*display_ip; /* Pointer to insertiong point of display
* structure */
u_char *current_channel; /* Window's current channel */
u_char *bound_channel; /* Channel that belongs in this window */
u_char *query_nick; /* User being QUERY'ied in this window */
NickList *nicks; /* List of nicks that will go to window */
int window_level; /* The LEVEL of the window, determines what
* messages go to it */
/* hold stuff */
int hold_mode; /* true, hold mode is on for window...
* false it isn't */
int hold_on_next_rite; /* true, the next call to rite() will
* activate a hold */
int held; /* true, the window is currently being
* held */
int last_held; /* Previous value of hold flag. Used
* for various updating needs */
Hold *hold_head, /* Pointer to first entry in hold
* list */
*hold_tail; /* Pointer to last entry in hold list */
int held_lines; /* number of lines being held */
int scrolled_lines; /* number of lines scrolled back */
int new_scrolled_lines; /* number of lines since scroll back
* keys where pressed */
WindowMenu menu; /* The menu (if any) */
/* lastlog stuff */
Lastlog *lastlog_head; /* pointer to top of lastlog list */
Lastlog *lastlog_tail; /* pointer to bottom of lastlog list */
int lastlog_level; /* The LASTLOG_LEVEL, determines what
* messages go to lastlog */
int lastlog_size; /* Max number of messages for the window
* lastlog */
int notify_level; /* the notify level.. */
u_char *logfile; /* window's logfile name */
/* window log stuff */
int log; /* true, file logging for window is on */
FILE *log_fp; /* file pointer for the log file */
struct ScreenStru *screen;
int server_group; /* server group number */
struct WindowStru *next; /* pointer to next entry in window list (null
* is end) */
struct WindowStru *prev; /* pointer to previous entry in window list
* (null is end) */
int sticky; /* make channels stick to window when
changing servers ? */
} Window;
/*
* WindowStack: The structure for the POP, PUSH, and STACK functions. A
* simple linked list with window refnums as the data
*/
typedef struct window_stack_stru
{
unsigned int refnum;
struct window_stack_stru *next;
} WindowStack;
typedef struct
{
int top;
int bottom;
int position;
} ShrinkInfo;
typedef struct PromptStru
{
u_char *prompt;
u_char *data;
int type;
void (*func)(u_char *, u_char *);
struct PromptStru *next;
} WaitPrompt;
typedef struct ScreenInputBufferData
{
u_char buf[INPUT_BUFFER_SIZE+1];
unsigned pos;
unsigned minpos;
/* If you put pointers here, remember to change
* change_input_prompt() which uses memcpy to
* make copies of this struct
*/
} ScreenInputBufferData;
typedef struct ScreenInputData
{
ScreenInputBufferData buffer;
ScreenInputBufferData saved_buffer;
/* Used by update_input() to check if the screen geometry has changed */
int old_co, old_li;
/* screen->co = number of columns on screen
*
* buffer.buf = input line and prompt (utf-8 encoded)
* buffer.pos = byte position of the cursor within string
* buffer.minpos = length of prompt in bytes
*
* When update_input() is ran,
* It checks if the prompt in buffer differs from input_prompt.
* If it does, it replaces the buffer-prompt with the new prompt.
* And sets update to UPDATE_ALL
*
* If geometry has changed,
* update is set to UPDATE_ALL
*
* left_ptr = byte-position of the left edge of screen in buffer
* recalculated when:
* update==UPDATE_JUST_CURSOR
* update==UPDATE_ALL
*
* pos_column = column position of the cursor in the buffer
* recalculated when left_ptr is too
*
* cursor_x = cursor horizontal position on screen (columns, not chars, not bytes)
* recalculated when:
* update==UPDATE_JUST_CURSOR
* update==UPDATE_ALL
*
* cursor_y = cursor vertical position on screen (lines)
* recalculated when screen geometry has changed
*
* zone = screen width
*/
unsigned zone;
unsigned cursor_x;
unsigned cursor_y;
unsigned left_ptr;
unsigned pos_column;
} ScreenInputData;
typedef struct ScreenStru
{
int screennum;
Window *current_window;
unsigned int last_window_refnum; /* reference number of the
* window that was last
* the current_window */
Window *window_list; /* List of all visible
* windows */
Window *window_list_end; /* end of visible window
* list */
Window *cursor_window; /* Last window to have
* something written to it */
int visible_windows; /* total number of windows */
WindowStack *window_stack; /* the windows here */
int meta1_hit; /* if meta1 is hit in this
* screen or not */
int meta2_hit; /* above, for meta2 */
int meta3_hit; /* above, for meta3 */
int meta4_hit; /* above, for meta4 */
int meta5_hit; /* above, for meta5 */
int meta6_hit; /* above, for meta6 */
int meta7_hit; /* above, for meta7 */
int meta8_hit; /* above, for meta8 */
int quote_hit; /* true if a key bound to
* QUOTE_CHARACTER has been
* hit. */
int digraph_hit; /* A digraph key has been hit */
int inside_menu; /* what it says. */
u_char digraph_first;
struct ScreenStru *prev; /* These are the Screen list */
struct ScreenStru *next; /* pointers */
FILE *fpin; /* These are the file pointers */
int fdin; /* and descriptions for the */
FILE *fpout; /* screen's input/output */
int fdout;
int wservin; /* control socket for wserv */
WaitPrompt *promptlist;
u_char *redirect_name;
u_char *redirect_token;
int redirect_server;
u_char *tty_name;
int co, li;
/* term.c:term_resize() */
int old_term_co, old_term_li;
ScreenInputData inputdata;
int alive;
} Screen;
/* ChannelList: structure for the list of channels you are current on */
typedef struct channel_stru
{
struct channel_stru *next; /* pointer to next channel entry */
u_char *channel; /* channel name */
int server; /* server index for this channel */
u_long mode; /* current mode settings for channel */
u_char *s_mode; /* string representation of the above */
int limit; /* max users for the channel */
u_char *key; /* key for this channel */
int connected; /* connection status */
#define CHAN_LIMBO -1
#define CHAN_JOINING 0
#define CHAN_JOINED 1
Window *window; /* the window that the channel is "on" */
NickList *nicks; /* pointer to list of nicks on channel */
int status; /* different flags */
#define CHAN_CHOP 0x01
#define CHAN_NAMES 0x04
#define CHAN_MODE 0x08
} ChannelList;
typedef struct list_stru
{
struct list_stru *next;
u_char *name;
} List;
#endif /* __struct_h_ */
syntax highlighted by Code2HTML, v. 0.9.1