Archive/openmohaa
0
0
Fork 0
mirror of https://github.com/openmoh/openmohaa.git synced 2025-04-28 21:57:57 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
openmohaa/code/gamespy/Chat/chat.h

999 lines
34 KiB
C
Raw Normal View History

Added gamespy SDK
2023-02-04 21:00:01 +01:00
/*
GameSpy Chat SDK
Dan "Mr. Pants" Schoenblum
dan@gamespy.com
Copyright 1999-2007 GameSpy Industries, Inc
devsupport@gamespy.com
*/
#ifndef _CHAT_H_
#define _CHAT_H_
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#include "../common/gsCommon.h"
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
extern "C" {
#endif
/************
** DEFINES **
************/
// User and channel message types.
//////////////////////////////////
#define CHAT_MESSAGE 0
#define CHAT_ACTION 1
#define CHAT_NOTICE 2
#define CHAT_UTM 3
#define CHAT_ATM 4
// User modes.
// PANTS|03.12.01 - These are now bitflags!
// Both CHAT_VOICE and CHAT_OP can be set at the same time.
///////////////////////////////////////////////////////////
#define CHAT_NORMAL 0
#define CHAT_VOICE 1
#define CHAT_OP 2
// Part reasons (see the chatUserParted callback).
//////////////////////////////////////////////////
#define CHAT_LEFT 0 // The user left the channel.
#define CHAT_QUIT 1 // The user quit the chat network.
#define CHAT_KICKED 2 // The user was kicked from the channel.
#define CHAT_KILLED 3 // The user was kicked off the chat network.
// Possible nick errors while connecting.
/////////////////////////////////////////
#define CHAT_NICK_OK 0
#define CHAT_IN_USE 1
#define CHAT_INVALID 2
#define CHAT_UNIQUENICK_EXPIRED 3
#define CHAT_NO_UNIQUENICK 4
#define CHAT_INVALID_UNIQUENICK 5
#define CHAT_NICK_TOO_LONG 6
// Reasons why a connect attempt could fail.
////////////////////////////////////////////
#define CHAT_DISCONNECTED 0
#define CHAT_NICK_ERROR 1
#define CHAT_LOGIN_FAILED 2
/**********
** TYPES **
**********/
// Boolean type.
////////////////
typedef enum { CHATFalse, CHATTrue } CHATBool;
// A CHAT object represents a client connection to a chat server.
/////////////////////////////////////////////////////////////////
typedef void * CHAT;
// Object representing a channel's mode.
////////////////////////////////////////
typedef struct CHATChannelMode
{
CHATBool InviteOnly;
CHATBool Private;
CHATBool Secret;
CHATBool Moderated;
CHATBool NoExternalMessages;
CHATBool OnlyOpsChangeTopic;
CHATBool OpsObeyChannelLimit;
int Limit;
} CHATChannelMode;
// The result of a channel enter attempt,
// passed into the chatEnterChannelCallback().
//////////////////////////////////////////////
typedef enum
{
CHATEnterSuccess, // The channel was successfully entered.
CHATBadChannelName, // The channel name was invalid.
CHATChannelIsFull, // The channel is at its user limit.
CHATInviteOnlyChannel, // The channel is invite only.
CHATBannedFromChannel, // The local user is banned from this channel.
CHATBadChannelPassword, // The channel has a password, and a bad password (or none) was given.
CHATTooManyChannels, // The server won't allow this user in any more channels.
CHATEnterTimedOut, // The attempt to enter timed out.
CHATBadChannelMask // Not sure if any servers use this, or what it means! (ERR_BADCHANMASK)
} CHATEnterResult;
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#ifndef GSI_UNICODE
#define chatConnect chatConnectA
#define chatConnectSpecial chatConnectSpecialA
#define chatConnectSecure chatConnectSecureA
#define chatConnectLogin chatConnectLoginA
#define chatConnectPreAuth chatConnectPreAuthA
#define chatRetryWithNick chatRetryWithNickA
#define chatRegisterUniqueNick chatRegisterUniqueNickA
#define chatSendRaw chatSendRawA
#define chatChangeNick chatChangeNickA
#define chatFixNick chatFixNickA
#define chatTranslateNick chatTranslateNickA
#define chatAuthenticateCDKey chatAuthenticateCDKeyA
#define chatEnumChannels chatEnumChannelsA
#define chatEnterChannel chatEnterChannelA
#define chatLeaveChannel chatLeaveChannelA
#define chatSendChannelMessage chatSendChannelMessageA
#define chatSetChannelTopic chatSetChannelTopicA
#define chatGetChannelTopic chatGetChannelTopicA
#define chatSetChannelMode chatSetChannelModeA
#define chatGetChannelMode chatGetChannelModeA
#define chatSetChannelPassword chatSetChannelPasswordA
#define chatGetChannelPassword chatGetChannelPasswordA
#define chatSetChannelLimit chatSetChannelLimitA
#define chatEnumChannelBans chatEnumChannelBansA
#define chatAddChannelBan chatAddChannelBanA
#define chatRemoveChannelBan chatRemoveChannelBanA
#define chatSetChannelGroup chatSetChannelGroupA
#define chatGetChannelNumUsers chatGetChannelNumUsersA
#define chatInChannel chatInChannelA
#define chatEnumUsers chatEnumUsersA
#define chatSendUserMessage chatSendUserMessageA
#define chatGetUserInfo chatGetUserInfoA
#define chatGetBasicUserInfo chatGetBasicUserInfoA
#define chatGetBasicUserInfoNoWait chatGetBasicUserInfoNoWaitA
#define chatGetChannelBasicUserInfo chatGetChannelBasicUserInfoA
#define chatInviteUser chatInviteUserA
#define chatKickUser chatKickUserA
#define chatBanUser chatBanUserA
#define chatSetUserMode chatSetUserModeA
#define chatGetUserMode chatGetUserModeA
#define chatGetUserModeNoWait chatGetUserModeNoWaitA
#define chatSetGlobalKeys chatSetGlobalKeysA
#define chatSetChannelKeys chatSetChannelKeysA
#define chatGetGlobalKeys chatGetGlobalKeysA
#define chatGetChannelKeys chatGetChannelKeysA
#define chatGetNick chatGetNickA
#define chatGetUdpRelay chatGetUdpRelayA
#else
#define chatConnect chatConnectW
#define chatConnectSpecial chatConnectSpecialW
#define chatConnectSecure chatConnectSecureW
#define chatConnectLogin chatConnectLoginW
#define chatConnectPreAuth chatConnectPreAuthW
#define chatRetryWithNick chatRetryWithNickW
#define chatRegisterUniqueNick chatRegisterUniqueNickW
#define chatSendRaw chatSendRawW
#define chatChangeNick chatChangeNickW
#define chatFixNick chatFixNickW
#define chatTranslateNick chatTranslateNickW
#define chatAuthenticateCDKey chatAuthenticateCDKeyW
#define chatEnumChannels chatEnumChannelsW
#define chatEnterChannel chatEnterChannelW
#define chatLeaveChannel chatLeaveChannelW
#define chatSendChannelMessage chatSendChannelMessageW
#define chatSetChannelTopic chatSetChannelTopicW
#define chatGetChannelTopic chatGetChannelTopicW
#define chatSetChannelMode chatSetChannelModeW
#define chatGetChannelMode chatGetChannelModeW
#define chatSetChannelPassword chatSetChannelPasswordW
#define chatGetChannelPassword chatGetChannelPasswordW
#define chatSetChannelLimit chatSetChannelLimitW
#define chatEnumChannelBans chatEnumChannelBansW
#define chatAddChannelBan chatAddChannelBanW
#define chatRemoveChannelBan chatRemoveChannelBanW
#define chatSetChannelGroup chatSetChannelGroupW
#define chatGetChannelNumUsers chatGetChannelNumUsersW
#define chatInChannel chatInChannelW
#define chatEnumUsers chatEnumUsersW
#define chatSendUserMessage chatSendUserMessageW
#define chatGetUserInfo chatGetUserInfoW
#define chatGetBasicUserInfo chatGetBasicUserInfoW
#define chatGetBasicUserInfoNoWait chatGetBasicUserInfoNoWaitW
#define chatGetChannelBasicUserInfo chatGetChannelBasicUserInfoW
#define chatInviteUser chatInviteUserW
#define chatKickUser chatKickUserW
#define chatBanUser chatBanUserW
#define chatSetUserMode chatSetUserModeW
#define chatGetUserMode chatGetUserModeW
#define chatGetUserModeNoWait chatGetUserModeNoWaitW
#define chatSetGlobalKeys chatSetGlobalKeysW
#define chatSetChannelKeys chatSetChannelKeysW
#define chatGetGlobalKeys chatGetGlobalKeysW
#define chatGetChannelKeys chatGetChannelKeysW
#define chatGetNick chatGetNickW
#define chatGetUdpRelay chatGetUdpRelayW
#endif
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
/**********************
** GLOBALS CALLBACKS **
**********************/
// Gets raw incoming network traffic.
/////////////////////////////////////
typedef void (* chatRaw)(CHAT chat,
const gsi_char * raw,
void * param);
// Called when the client has been disconnected.
////////////////////////////////////////////////
typedef void (* chatDisconnected)(CHAT chat,
const gsi_char * reason,
void * param);
// Called when a private message from another user is received.
// If user==NULL, this is a message from the server.
///////////////////////////////////////////////////////////////
typedef void (* chatPrivateMessage)(CHAT chat,
const gsi_char * user,
const gsi_char * message,
int type, // See defined message types above.
void * param);
// Called when invited into a channel.
//////////////////////////////////////
typedef void (* chatInvited)(CHAT chat,
const gsi_char * channel,
const gsi_char * user,
void * param);
// A connection's global callbacks.
///////////////////////////////////
typedef struct chatGlobalCallbacks
{
chatRaw raw;
chatDisconnected disconnected;
chatPrivateMessage privateMessage;
chatInvited invited;
void * param;
} chatGlobalCallbacks;
/**********************
** CHANNEL CALLBACKS **
**********************/
// Called when a message is received in a channel.
//////////////////////////////////////////////////
typedef void (* chatChannelMessage)(CHAT chat,
const gsi_char * channel,
const gsi_char * user,
const gsi_char * message,
int type, // See defined message types above.
void * param);
// Called when the local client is kicked from a channel.
/////////////////////////////////////////////////////////
typedef void (* chatKicked)(CHAT chat,
const gsi_char * channel,
const gsi_char * user,
const gsi_char * reason,
void * param);
// Called when a user joins a channel we're in.
///////////////////////////////////////////////
typedef void (* chatUserJoined)(CHAT chat,
const gsi_char * channel,
const gsi_char * user,
int mode, // See defined user modes above.
void * param);
// Called when a user parts a channel we're in.
///////////////////////////////////////////////
typedef void (* chatUserParted)(CHAT chat,
const gsi_char * channel,
const gsi_char * user,
int why, // See defined part reasons above.
const gsi_char * reason,
const gsi_char * kicker,
void * param);
// Called when a user in a channel we're in changes nicks.
//////////////////////////////////////////////////////////
typedef void (* chatUserChangedNick)(CHAT chat,
const gsi_char * channel,
const gsi_char * oldNick,
const gsi_char * newNick,
void * param);
// Called when the topic changes in a channel we're in.
///////////////////////////////////////////////////////
typedef void (* chatTopicChanged)(CHAT chat,
const gsi_char * channel,
const gsi_char * topic,
void * param);
// Called when the mode changes in a channel we're in.
//////////////////////////////////////////////////////
typedef void (* chatChannelModeChanged)(CHAT chat,
const gsi_char * channel,
CHATChannelMode * mode,
void * param);
// Called when a user's mode changes in a channel we're in.
///////////////////////////////////////////////////////////
typedef void (* chatUserModeChanged)(CHAT chat,
const gsi_char * channel,
const gsi_char * user,
int mode, // See defined user modes above.
void * param);
// Called when the user list changes (due to a join or a part) in a channel we're in.
/////////////////////////////////////////////////////////////////////////////////////
typedef void (* chatUserListUpdated)(CHAT chat,
const gsi_char * channel,
void * param);
// Called when the chat server sends an entire new user list for a channel we're in.
////////////////////////////////////////////////////////////////////////////////////
typedef void (* chatNewUserList)(CHAT chat,
const gsi_char * channel,
int num,
const gsi_char ** users,
int * modes,
void * param);
// Called when a user changes a broadcast key in a channel we're in.
////////////////////////////////////////////////////////////////////
typedef void (* chatBroadcastKeyChanged)(CHAT chat,
const gsi_char * channel,
const gsi_char * user,
const gsi_char * key,
const gsi_char * value,
void * param);
// A channel's callbacks.
/////////////////////////
typedef struct chatChannelCallbacks
{
chatChannelMessage channelMessage;
chatKicked kicked;
chatUserJoined userJoined;
chatUserParted userParted;
chatUserChangedNick userChangedNick;
chatTopicChanged topicChanged;
chatChannelModeChanged channelModeChanged;
chatUserModeChanged userModeChanged;
chatUserListUpdated userListUpdated;
chatNewUserList newUserList;
chatBroadcastKeyChanged broadcastKeyChanged;
void * param;
} chatChannelCallbacks;
/************
** GENERAL **
************/
// Called when a connect attempt completes.
// failureReason is only set if success is CHATFalse.
/////////////////////////////////////////////////////
typedef void (* chatConnectCallback)(CHAT chat,
CHATBool success,
int failureReason, // CHAT_DISCONNECTED, CHAT_NICK_ERROR, etc.
void * param);
// Called if there is an error with the nick while connecting.
// To retry with a new nick, call chatRetryWithNick.
// Otherwise, call chatDisconnect to stop the connection.
// Suggested nicks are only provided if type is CHAT_INVALID_UNIQUENICK.
////////////////////////////////////////////////////////////////////////
typedef void (* chatNickErrorCallback)(CHAT chat,
int type, // CHAT_IN_USE, CHAT_INVALID, etc.
const gsi_char * nick,
int numSuggestedNicks,
const gsi_char ** suggestedNicks,
void * param);
typedef void (* chatFillInUserCallback)(CHAT chat,
unsigned int IP, // PANTS|08.21.00 - changed from unsigned long
gsi_char user[128],
void * param);
// Connects you to a chat server and returns a CHAT object.
///////////////////////////////////////////////////////////
CHAT chatConnect(const gsi_char * serverAddress,
int port,
const gsi_char * nick,
const gsi_char * user,
const gsi_char * name,
chatGlobalCallbacks * callbacks,
chatNickErrorCallback nickErrorCallback,
chatConnectCallback connectCallback,
void * param,
CHATBool blocking);
CHAT chatConnectSpecial(const gsi_char * serverAddress,
int port,
const gsi_char * nick,
const gsi_char * name,
chatGlobalCallbacks * callbacks,
chatNickErrorCallback nickErrorCallback,
chatFillInUserCallback fillInUserCallback,
chatConnectCallback connectCallback,
void * param,
CHATBool blocking);
CHAT chatConnectSecure(const gsi_char * serverAddress,
int port,
const gsi_char * nick,
const gsi_char * name,
const gsi_char * gamename,
const gsi_char * secretKey,
chatGlobalCallbacks * callbacks,
chatNickErrorCallback nickErrorCallback,
chatFillInUserCallback fillInUserCallback,
chatConnectCallback connectCallback,
void * param,
CHATBool blocking);
CHAT chatConnectLogin(const gsi_char * serverAddress,
int port,
int namespaceID,
const gsi_char * email,
const gsi_char * profilenick,
const gsi_char * uniquenick,
const gsi_char * password,
const gsi_char * name,
const gsi_char * gamename,
const gsi_char * secretKey,
chatGlobalCallbacks * callbacks,
chatNickErrorCallback nickErrorCallback,
chatFillInUserCallback fillInUserCallback,
chatConnectCallback connectCallback,
void * param,
CHATBool blocking);
CHAT chatConnectPreAuth(const gsi_char * serverAddress,
int port,
const gsi_char * authtoken,
const gsi_char * partnerchallenge,
const gsi_char * name,
const gsi_char * gamename,
const gsi_char * secretKey,
chatGlobalCallbacks * callbacks,
chatNickErrorCallback nickErrorCallback,
chatFillInUserCallback fillInUserCallback,
chatConnectCallback connectCallback,
void * param,
CHATBool blocking);
// If the chatNickErrorCallback gets called, then this can be called
// with a new nick to retry. If this isn't called, the connection can be
// disconnected with chatDisconnect. If the new nick is successful, then
// the chatConnectCallback will get called. If there's another nick
// error, the chatNickErrorCallback will get called again.
/////////////////////////////////////////////////////////////////////////
void chatRetryWithNick(CHAT chat,
const gsi_char * nick);
// Register a uniquenick.
// Should be called in response to the chatNickErrorCallback being called
// with a type of CHAT_UNIQUENICK_EXPIRED or CHAT_NO_UNIQUENICK.
// If the uniquenick cannot be registered, the chatNickErrorCallback will
// be called again with a type of CHAT_IN_USE or CHAT_INVALID.
/////////////////////////////////////////////////////////////////////////
void chatRegisterUniqueNick(CHAT chat,
int namespaceID,
const gsi_char * uniquenick,
const gsi_char * cdkey);
// Disconnect the chat connection.
//////////////////////////////////
void chatDisconnect(CHAT chat);
// Processes the chat connection.
/////////////////////////////////
void chatThink(CHAT chat);
// Sends raw data, without any interpretation.
//////////////////////////////////////////////
void chatSendRaw(CHAT chat,
const gsi_char * command);
// Called as a result of a nick change attempt.
///////////////////////////////////////////////
typedef void (* chatChangeNickCallback)(CHAT chat,
CHATBool success,
const gsi_char * oldNick,
const gsi_char * newNick,
void * param);
// Change the local user's nick.
////////////////////////////////
void chatChangeNick(CHAT chat,
const gsi_char * newNick,
chatChangeNickCallback callback,
void * param,
CHATBool blocking);
// Get our local nickname.
//////////////////////////
const gsi_char * chatGetNick(CHAT chat);
// Copies the oldNick to the newNick, replacing any invalid characters with legal ones.
///////////////////////////////////////////////////////////////////////////////////////
void chatFixNick(gsi_char * newNick,
const gsi_char * oldNick);
// Removes the namespace extension from a chat nick.
////////////////////////////////////////////////////
const gsi_char * chatTranslateNick(gsi_char * nick,
const gsi_char * extension);
// Gets the local userID.
// Only valid if connected with chatConnectLogin or chatConnectPreAuth.
///////////////////////////////////////////////////////////////////////
int chatGetUserID(CHAT chat);
// Gets the local profileID.
// Only valid if connected with chatConnectLogin or chatConnectPreAuth.
///////////////////////////////////////////////////////////////////////
int chatGetProfileID(CHAT chat);
// Turn on/off quiet mode.
//////////////////////////
void chatSetQuietMode(CHAT chat,
CHATBool quiet);
// Called as a result of an authenticate CD key attempt.
////////////////////////////////////////////////////////
typedef void (* chatAuthenticateCDKeyCallback)(CHAT chat,
int result,
const gsi_char * message,
void * param);
// Attempts to authenticates a CD key.
//////////////////////////////////////
void chatAuthenticateCDKey(CHAT chat,
const gsi_char * cdkey,
chatAuthenticateCDKeyCallback callback,
void * param,
CHATBool blocking);
/*************
** CHANNELS **
*************/
// Gets called for each channel enumerated.
///////////////////////////////////////////
typedef void (* chatEnumChannelsCallbackEach)(CHAT chat,
CHATBool success,
int index,
const gsi_char * channel,
const gsi_char * topic,
int numUsers,
void * param);
// Gets called after all channels have been enumerated.
///////////////////////////////////////////////////////
typedef void (* chatEnumChannelsCallbackAll)(CHAT chat,
CHATBool success,
int numChannels,
const gsi_char ** channels,
const gsi_char ** topics,
int * numUsers,
void * param);
// Enumerates the channels available on a chat server.
//////////////////////////////////////////////////////
void chatEnumChannels(CHAT chat,
const gsi_char * filter,
chatEnumChannelsCallbackEach callbackEach,
chatEnumChannelsCallbackAll callbackAll,
void * param,
CHATBool blocking);
// Gets called for each channel enumerated.
///////////////////////////////////////////
typedef void (* chatEnumJoinedChannelsCallback)(CHAT chat,
int index,
const gsi_char * channel,
void * param);
// Enumerates the channels that we are joined to
//////////////////////////////////////////////////////
void chatEnumJoinedChannels(CHAT chat,
chatEnumJoinedChannelsCallback callback,
void * param);
// Gets called when a channel has been entered.
///////////////////////////////////////////////
typedef void (* chatEnterChannelCallback)(CHAT chat,
CHATBool success,
CHATEnterResult result,
const gsi_char * channel,
void * param);
// Enters a channel.
////////////////////
void chatEnterChannel(CHAT chat,
const gsi_char * channel,
const gsi_char * password,
chatChannelCallbacks * callbacks,
chatEnterChannelCallback callback,
void * param,
CHATBool blocking);
// Leaves a channel.
////////////////////
void chatLeaveChannel(CHAT chat,
const gsi_char * channel,
const gsi_char * reason); // PANTS|03.13.01
// Sends a message to a channel.
////////////////////////////////
void chatSendChannelMessage(CHAT chat,
const gsi_char * channel,
const gsi_char * message,
int type);
// Sets the topic in a channel.
///////////////////////////////
void chatSetChannelTopic(CHAT chat,
const gsi_char * channel,
const gsi_char * topic);
// Gets called when a channel's topic has been retrieved.
/////////////////////////////////////////////////////////
typedef void (* chatGetChannelTopicCallback)(CHAT chat,
CHATBool success,
const gsi_char * channel,
const gsi_char * topic,
void * param);
// Gets a channel's topic.
//////////////////////////
void chatGetChannelTopic(CHAT chat,
const gsi_char * channel,
chatGetChannelTopicCallback callback,
void * param,
CHATBool blocking);
// Sets a channel's mode.
/////////////////////////
void chatSetChannelMode(CHAT chat,
const gsi_char * channel,
CHATChannelMode * mode);
// Gets called when a channel's mode has been retrieved.
////////////////////////////////////////////////////////
typedef void (* chatGetChannelModeCallback)(CHAT chat,
CHATBool success,
const gsi_char * channel,
CHATChannelMode * mode,
void * param);
// Gets a channel's mode.
/////////////////////////
void chatGetChannelMode(CHAT chat,
const gsi_char * channel,
chatGetChannelModeCallback callback,
void * param,
CHATBool blocking);
// Sets the password in a channel.
//////////////////////////////////
void chatSetChannelPassword(CHAT chat,
const gsi_char * channel,
CHATBool enable,
const gsi_char * password);
// Called when the channel's password has been retrieved.
/////////////////////////////////////////////////////////
typedef void (* chatGetChannelPasswordCallback)(CHAT chat,
CHATBool success,
const gsi_char * channel,
CHATBool enabled,
const gsi_char * password,
void * param);
// Gets the password in a channel.
//////////////////////////////////
void chatGetChannelPassword(CHAT chat,
const gsi_char * channel,
chatGetChannelPasswordCallback callback,
void * param,
CHATBool blocking);
// Set the maximum number of users allowed in a channel.
////////////////////////////////////////////////////////
void chatSetChannelLimit(CHAT chat,
const gsi_char * channel,
int limit);
// Called with the list of bans in a channel.
/////////////////////////////////////////////
typedef void (* chatEnumChannelBansCallback)(CHAT chat,
CHATBool success,
const gsi_char * channel,
int numBans,
const gsi_char ** bans,
void * param);
// Enumerate through the bans in a channel.
///////////////////////////////////////////
void chatEnumChannelBans(CHAT chat,
const gsi_char * channel,
chatEnumChannelBansCallback callback,
void * param,
CHATBool blocking);
// Adds a channel ban.
//////////////////////
void chatAddChannelBan(CHAT chat,
const gsi_char * channel,
const gsi_char * ban);
// Removes a ban string from a channel.
///////////////////////////////////////
void chatRemoveChannelBan(CHAT chat,
const gsi_char * channel,
const gsi_char * ban);
// Set the group this channel is a part of.
///////////////////////////////////////////
void chatSetChannelGroup(CHAT chat,
const gsi_char * channel,
const gsi_char * group);
// Get the number of users in the channel.
// Returns -1 if we are not in the channel.
///////////////////////////////////////////
int chatGetChannelNumUsers(CHAT chat,
const gsi_char * channel);
// Returns CHATTrue if we are in the channel
///////////////////////////////////////////
CHATBool chatInChannel(CHAT chat,
const gsi_char * channel);
/**********
** USERS **
**********/
// Called with the list of users in a channel.
//////////////////////////////////////////////
typedef void (* chatEnumUsersCallback)(CHAT chat,
CHATBool success,
const gsi_char * channel, //PANTS|02.11.00|added paramater
int numUsers,
const gsi_char ** users,
int * modes,
void * param);
// Enumerate through the users in a channel.
////////////////////////////////////////////
void chatEnumUsers(CHAT chat,
const gsi_char * channel,
chatEnumUsersCallback callback,
void * param,
CHATBool blocking);
// Send a private message to a user.
////////////////////////////////////
void chatSendUserMessage(CHAT chat,
const gsi_char * user,
const gsi_char * message,
int type);
// Called with a user's info.
/////////////////////////////
typedef void (* chatGetUserInfoCallback)(CHAT chat,
CHATBool success,
const gsi_char * nick, //PANTS|02.14.2000|added nick and user
const gsi_char * user,
const gsi_char * name,
const gsi_char * address,
int numChannels,
const gsi_char ** channels,
void * param);
// Get a user's info.
/////////////////////
void chatGetUserInfo(CHAT chat,
const gsi_char * user,
chatGetUserInfoCallback callback,
void * param,
CHATBool blocking);
// Called with a user's basic info.
///////////////////////////////////
typedef void (* chatGetBasicUserInfoCallback)(CHAT chat,
CHATBool success,
const gsi_char * nick,
const gsi_char * user,
const gsi_char * address,
void * param);
// Get some basic info on the user.
// PANTS|12.08.2000
///////////////////////////////////
void chatGetBasicUserInfo(CHAT chat,
const gsi_char * user,
chatGetBasicUserInfoCallback callback,
void * param,
CHATBool blocking);
// Get basic info without waiting.
// Returns CHATFalse if the info isn't available.
/////////////////////////////////////////////////
CHATBool chatGetBasicUserInfoNoWait(CHAT chat,
const gsi_char * nick,
const gsi_char ** user,
const gsi_char ** address);
// Called with a user's basic info for everyone in a channel.
// Called with a NULL nick/user/address at the end.
/////////////////////////////////////////////////////////////
typedef void (* chatGetChannelBasicUserInfoCallback)(CHAT chat,
CHATBool success,
const gsi_char * channel,
const gsi_char * nick,
const gsi_char * user,
const gsi_char * address,
void * param);
// Get basic info on all the users in a channel.
// PANTS|12.19.00
////////////////////////////////////////////////
void chatGetChannelBasicUserInfo(CHAT chat,
const gsi_char * channel,
chatGetChannelBasicUserInfoCallback callback,
void * param,
CHATBool blocking);
// Invite a user into a channel.
////////////////////////////////
void chatInviteUser(CHAT chat,
const gsi_char * channel,
const gsi_char * user);
// Kick a user from a channel.
//////////////////////////////
void chatKickUser(CHAT chat,
const gsi_char * channel,
const gsi_char * user,
const gsi_char * reason);
// Ban a user from a channel.
/////////////////////////////
void chatBanUser(CHAT chat,
const gsi_char * channel,
const gsi_char * user);
// Sets a user's mode in a channel.
///////////////////////////////////
void chatSetUserMode(CHAT chat,
const gsi_char * channel,
const gsi_char * user,
int mode);
// Called with the user's mode.
///////////////////////////////
typedef void (* chatGetUserModeCallback)(CHAT chat,
CHATBool success,
const gsi_char * channel,
const gsi_char * user,
int mode,
void * param);
// Gets a user's mode in a channel.
///////////////////////////////////
void chatGetUserMode(CHAT chat,
const gsi_char * channel,
const gsi_char * user,
chatGetUserModeCallback callback,
void * param,
CHATBool blocking);
// Gets a user's mode in a channel.
///////////////////////////////////
CHATBool chatGetUserModeNoWait(CHAT chat,
const gsi_char * channel,
const gsi_char * user,
int * mode);
// Called in response to a request for the UDP relay for a channel
////////////////////////////////////////////////////////////////////
typedef void (* chatGetUdpRelayCallback)(CHAT chat,
const gsi_char * channel,
const gsi_char * udpIp,
unsigned short udpPort,
int udpKey,
void * param);
// Get the UDP relay address for a channel
///////////////////////////////////
void chatGetUdpRelay(CHAT chat,
const gsi_char * channel,
chatGetUdpRelayCallback callback,
void * param,
CHATBool blocking);
/*********
** KEYS **
*********/
// Sets global key/values for the local user.
// Set a value to NULL or "" to clear that key.
///////////////////////////////////////////////
void chatSetGlobalKeys(CHAT chat,
int num,
const gsi_char ** keys,
const gsi_char ** values);
// Called with a user's global key/values.
// If used for a set of users, will be
// called with user==NULL when done.
//////////////////////////////////////////
typedef void (* chatGetGlobalKeysCallback)(CHAT chat,
CHATBool success,
const gsi_char * user,
int num,
const gsi_char ** keys,
const gsi_char ** values,
void * param);
// Gets global key/values for a user or users.
// To get the global key/values for one user, pass in that
// user's nick as the target. To get the global key/values
// for every user in a channel, use the channel name as the target.
///////////////////////////////////////////////////////////////////
void chatGetGlobalKeys(CHAT chat,
const gsi_char * target,
int num,
const gsi_char ** keys,
chatGetGlobalKeysCallback callback,
void * param,
CHATBool blocking);
// Sets channel key/values.
// If user is NULL or "", the keys will be set on the channel.
// Otherwise, they will be set on the user,
// Only ops can set channel keys on other users.
// Set a value to NULL or "" to clear that key.
//////////////////////////////////////////////////////////////
void chatSetChannelKeys(CHAT chat,
const gsi_char * channel,
const gsi_char * user,
int num,
const gsi_char ** keys,
const gsi_char ** values);
// Called with a user's channel key/values, or a channel's key/values.
// If used for a set of users, will be called with user==NULL when done.
// If used for a channel, will be called once with user==NULL.
////////////////////////////////////////////////////////////////////////
typedef void (* chatGetChannelKeysCallback)(CHAT chat,
CHATBool success,
const gsi_char * channel,
const gsi_char * user,
int num,
const gsi_char ** keys,
const gsi_char ** values,
void * param);
// Gets channel key/values for a user or users, or for a channel.
// To get the channel key/values for every user in
// a channel, pass in "*" as the user. To get the keys for a channel,
// pass in NULL or "".
//////////////////////////////////////////////////////////////////////
void chatGetChannelKeys(CHAT chat,
const gsi_char * channel,
const gsi_char * user,
int num,
const gsi_char ** keys,
chatGetChannelKeysCallback callback,
void * param,
CHATBool blocking);
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// This ASCII versions must be available even when GSI_UNICODE is defined
#ifdef GSI_UNICODE
CHATBool chatGetBasicUserInfoNoWaitA(CHAT chat,
const char * nick,
const char ** user,
const char ** address);
#endif
/*
void chatGetBasicUserInfoA(CHAT chat,
const char * user,
chatGetBasicUserInfoCallback callback,
void * param,
CHATBool blocking);
*/
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
} // extern "C"
#endif
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#endif // _CHAT_H_
Reference in a new issue Copy permalink