rogo/TS_WIFILED
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

init

Browse Source
This commit is contained in:
rogo
2020-04-04 17:19:13 +02:00
parent 2cb0a7449a
commit f36bfab5aa
78 changed files with 4370 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
include/plugin_definitions.h Normal file
View File

@@ -0,0 +1,74 @@
#ifndef PLUGIN_DEFINITIONS
#define PLUGIN_DEFINITIONS
/* Return values for ts3plugin_offersConfigure */
enum PluginConfigureOffer {
PLUGIN_OFFERS_NO_CONFIGURE = 0, /* Plugin does not implement ts3plugin_configure */
PLUGIN_OFFERS_CONFIGURE_NEW_THREAD, /* Plugin does implement ts3plugin_configure and requests to run this function in an own thread */
PLUGIN_OFFERS_CONFIGURE_QT_THREAD /* Plugin does implement ts3plugin_configure and requests to run this function in the Qt GUI thread */
};
enum PluginMessageTarget {
PLUGIN_MESSAGE_TARGET_SERVER = 0,
PLUGIN_MESSAGE_TARGET_CHANNEL
};
enum PluginItemType {
PLUGIN_SERVER = 0,
PLUGIN_CHANNEL,
PLUGIN_CLIENT
};
enum PluginMenuType {
PLUGIN_MENU_TYPE_GLOBAL = 0,
PLUGIN_MENU_TYPE_CHANNEL,
PLUGIN_MENU_TYPE_CLIENT
};
#define PLUGIN_MENU_BUFSZ 128
struct PluginMenuItem {
enum PluginMenuType type;
int id;
char text[PLUGIN_MENU_BUFSZ];
char icon[PLUGIN_MENU_BUFSZ];
};
#define PLUGIN_HOTKEY_BUFSZ 128
struct PluginHotkey {
char keyword[PLUGIN_HOTKEY_BUFSZ];
char description[PLUGIN_HOTKEY_BUFSZ];
};
struct PluginBookmarkList;
struct PluginBookmarkItem {
char* name;
unsigned char isFolder;
unsigned char reserved[3];
union{
char* uuid;
struct PluginBookmarkList* folder;
};
};
struct PluginBookmarkList{
int itemcount;
struct PluginBookmarkItem items[1]; //should be 0 but compiler complains
};
enum PluginGuiProfile{
PLUGIN_GUI_SOUND_CAPTURE = 0,
PLUGIN_GUI_SOUND_PLAYBACK,
PLUGIN_GUI_HOTKEY,
PLUGIN_GUI_SOUNDPACK,
PLUGIN_GUI_IDENTITY
};
enum PluginConnectTab{
PLUGIN_CONNECT_TAB_NEW = 0,
PLUGIN_CONNECT_TAB_CURRENT,
PLUGIN_CONNECT_TAB_NEW_IF_CURRENT_CONNECTED
};
#endif

23
include/teamlog/logtypes.h Normal file
View File

@@ -0,0 +1,23 @@
#ifndef TEAMLOG_LOGTYPES_H
#define TEAMLOG_LOGTYPES_H
enum LogTypes {
LogType_NONE = 0x0000,
LogType_FILE = 0x0001,
LogType_CONSOLE = 0x0002,
LogType_USERLOGGING = 0x0004,
LogType_NO_NETLOGGING = 0x0008,
LogType_DATABASE = 0x0010,
LogType_SYSLOG = 0x0020,
};
enum LogLevel {
LogLevel_CRITICAL = 0, //these messages stop the program
LogLevel_ERROR, //everything that is really bad, but not so bad we need to shut down
LogLevel_WARNING, //everything that *might* be bad
LogLevel_DEBUG, //output that might help find a problem
LogLevel_INFO, //informational output, like "starting database version x.y.z"
LogLevel_DEVEL //developer only output (will not be displayed in release mode)
};
#endif //TEAMLOG_LOGTYPES_H

24
include/teamspeak/clientlib_publicdefinitions.h Normal file
View File

@@ -0,0 +1,24 @@
#ifndef CLIENTLIB_PUBLICDEFINITIONS_H
#define CLIENTLIB_PUBLICDEFINITIONS_H
enum Visibility {
ENTER_VISIBILITY = 0,
RETAIN_VISIBILITY,
LEAVE_VISIBILITY
};
enum ConnectStatus {
STATUS_DISCONNECTED = 0, //There is no activity to the server, this is the default value
STATUS_CONNECTING, //We are trying to connect, we haven't got a clientID yet, we haven't been accepted by the server
STATUS_CONNECTED, //The server has accepted us, we can talk and hear and we got a clientID, but we don't have the channels and clients yet, we can get server infos (welcome msg etc.)
STATUS_CONNECTION_ESTABLISHING,//we are CONNECTED and we are visible
STATUS_CONNECTION_ESTABLISHED, //we are CONNECTED and we have the client and channels available
};
enum LocalTestMode {
TEST_MODE_OFF = 0,
TEST_MODE_VOICE_LOCAL_ONLY = 1,
TEST_MODE_VOICE_LOCAL_AND_REMOTE = 2,
};
#endif //CLIENTLIB_PUBLICDEFINITIONS_H

391
include/teamspeak/public_definitions.h Normal file
View File

@@ -0,0 +1,391 @@
#ifndef PUBLIC_DEFINITIONS_H
#define PUBLIC_DEFINITIONS_H
#include "teamlog/logtypes.h"
//limited length, measured in characters
#define TS3_MAX_SIZE_CHANNEL_NAME 40
#define TS3_MAX_SIZE_VIRTUALSERVER_NAME 64
#define TS3_MAX_SIZE_CLIENT_NICKNAME 64
#define TS3_MIN_SIZE_CLIENT_NICKNAME 3
#define TS3_MAX_SIZE_REASON_MESSAGE 80
//limited length, measured in bytes (utf8 encoded)
#define TS3_MAX_SIZE_TEXTMESSAGE 8192
#define TS3_MAX_SIZE_CHANNEL_TOPIC 255
#define TS3_MAX_SIZE_CHANNEL_DESCRIPTION 8192
#define TS3_MAX_SIZE_VIRTUALSERVER_WELCOMEMESSAGE 1024
#define TS3_SIZE_MYTSID 44
//minimum amount of seconds before a clientID that was in use can be assigned to a new client
#define TS3_MIN_SECONDS_CLIENTID_REUSE 300
#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32)
typedef unsigned __int16 anyID;
typedef unsigned __int64 uint64;
#ifdef BUILDING_DLL
#define EXPORTDLL __declspec(dllexport)
#else
#define EXPORTDLL
#endif
#else
#include <stdint.h>
typedef uint16_t anyID;
typedef uint64_t uint64;
#ifdef BUILDING_DLL
#define EXPORTDLL __attribute__ ((visibility("default")))
#else
#define EXPORTDLL
#endif
#endif
enum TalkStatus {
STATUS_NOT_TALKING = 0,
STATUS_TALKING = 1,
STATUS_TALKING_WHILE_DISABLED = 2,
};
enum CodecType {
CODEC_SPEEX_NARROWBAND = 0, //mono, 16bit, 8kHz, bitrate dependent on the quality setting
CODEC_SPEEX_WIDEBAND, //mono, 16bit, 16kHz, bitrate dependent on the quality setting
CODEC_SPEEX_ULTRAWIDEBAND, //mono, 16bit, 32kHz, bitrate dependent on the quality setting
CODEC_CELT_MONO, //mono, 16bit, 48kHz, bitrate dependent on the quality setting
CODEC_OPUS_VOICE, //mono, 16bit, 48khz, bitrate dependent on the quality setting, optimized for voice
CODEC_OPUS_MUSIC, //stereo, 16bit, 48khz, bitrate dependent on the quality setting, optimized for music
};
enum CodecEncryptionMode {
CODEC_ENCRYPTION_PER_CHANNEL = 0,
CODEC_ENCRYPTION_FORCED_OFF,
CODEC_ENCRYPTION_FORCED_ON,
};
enum TextMessageTargetMode {
TextMessageTarget_CLIENT=1,
TextMessageTarget_CHANNEL,
TextMessageTarget_SERVER,
TextMessageTarget_MAX
};
enum MuteInputStatus {
MUTEINPUT_NONE = 0,
MUTEINPUT_MUTED,
};
enum MuteOutputStatus {
MUTEOUTPUT_NONE = 0,
MUTEOUTPUT_MUTED,
};
enum HardwareInputStatus {
HARDWAREINPUT_DISABLED = 0,
HARDWAREINPUT_ENABLED,
};
enum HardwareOutputStatus {
HARDWAREOUTPUT_DISABLED = 0,
HARDWAREOUTPUT_ENABLED,
};
enum InputDeactivationStatus {
INPUT_ACTIVE = 0,
INPUT_DEACTIVATED = 1,
};
enum ReasonIdentifier {
REASON_NONE = 0, //no reason data
REASON_MOVED = 1, //{SectionInvoker}
REASON_SUBSCRIPTION = 2, //no reason data
REASON_LOST_CONNECTION = 3, //reasonmsg=reason
REASON_KICK_CHANNEL = 4, //{SectionInvoker} reasonmsg=reason //{SectionInvoker} is only added server->client
REASON_KICK_SERVER = 5, //{SectionInvoker} reasonmsg=reason //{SectionInvoker} is only added server->client
REASON_KICK_SERVER_BAN = 6, //{SectionInvoker} reasonmsg=reason bantime=time //{SectionInvoker} is only added server->client
REASON_SERVERSTOP = 7, //reasonmsg=reason
REASON_CLIENTDISCONNECT = 8, //reasonmsg=reason
REASON_CHANNELUPDATE = 9, //no reason data
REASON_CHANNELEDIT = 10, //{SectionInvoker}
REASON_CLIENTDISCONNECT_SERVER_SHUTDOWN = 11, //reasonmsg=reason
};
enum ChannelProperties {
CHANNEL_NAME = 0, //Available for all channels that are "in view", always up-to-date
CHANNEL_TOPIC, //Available for all channels that are "in view", always up-to-date
CHANNEL_DESCRIPTION, //Must be requested (=> requestChannelDescription)
CHANNEL_PASSWORD, //not available client side
CHANNEL_CODEC, //Available for all channels that are "in view", always up-to-date
CHANNEL_CODEC_QUALITY, //Available for all channels that are "in view", always up-to-date
CHANNEL_MAXCLIENTS, //Available for all channels that are "in view", always up-to-date
CHANNEL_MAXFAMILYCLIENTS, //Available for all channels that are "in view", always up-to-date
CHANNEL_ORDER, //Available for all channels that are "in view", always up-to-date
CHANNEL_FLAG_PERMANENT, //Available for all channels that are "in view", always up-to-date
CHANNEL_FLAG_SEMI_PERMANENT, //Available for all channels that are "in view", always up-to-date
CHANNEL_FLAG_DEFAULT, //Available for all channels that are "in view", always up-to-date
CHANNEL_FLAG_PASSWORD, //Available for all channels that are "in view", always up-to-date
CHANNEL_CODEC_LATENCY_FACTOR, //Available for all channels that are "in view", always up-to-date
CHANNEL_CODEC_IS_UNENCRYPTED, //Available for all channels that are "in view", always up-to-date
CHANNEL_SECURITY_SALT, //Not available client side, not used in teamspeak, only SDK. Sets the options+salt for security hash.
CHANNEL_DELETE_DELAY, //How many seconds to wait before deleting this channel
CHANNEL_ENDMARKER,
};
enum ClientProperties {
CLIENT_UNIQUE_IDENTIFIER = 0, //automatically up-to-date for any client "in view", can be used to identify this particular client installation
CLIENT_NICKNAME, //automatically up-to-date for any client "in view"
CLIENT_VERSION, //for other clients than ourself, this needs to be requested (=> requestClientVariables)
CLIENT_PLATFORM, //for other clients than ourself, this needs to be requested (=> requestClientVariables)
CLIENT_FLAG_TALKING, //automatically up-to-date for any client that can be heard (in room / whisper)
CLIENT_INPUT_MUTED, //automatically up-to-date for any client "in view", this clients microphone mute status
CLIENT_OUTPUT_MUTED, //automatically up-to-date for any client "in view", this clients headphones/speakers/mic combined mute status
CLIENT_OUTPUTONLY_MUTED, //automatically up-to-date for any client "in view", this clients headphones/speakers only mute status
CLIENT_INPUT_HARDWARE, //automatically up-to-date for any client "in view", this clients microphone hardware status (is the capture device opened?)
CLIENT_OUTPUT_HARDWARE, //automatically up-to-date for any client "in view", this clients headphone/speakers hardware status (is the playback device opened?)
CLIENT_INPUT_DEACTIVATED, //only usable for ourself, not propagated to the network
CLIENT_IDLE_TIME, //internal use
CLIENT_DEFAULT_CHANNEL, //only usable for ourself, the default channel we used to connect on our last connection attempt
CLIENT_DEFAULT_CHANNEL_PASSWORD, //internal use
CLIENT_SERVER_PASSWORD, //internal use
CLIENT_META_DATA, //automatically up-to-date for any client "in view", not used by TeamSpeak, free storage for sdk users
CLIENT_IS_MUTED, //only make sense on the client side locally, "1" if this client is currently muted by us, "0" if he is not
CLIENT_IS_RECORDING, //automatically up-to-date for any client "in view"
CLIENT_VOLUME_MODIFICATOR, //internal use
CLIENT_VERSION_SIGN, //sign
CLIENT_SECURITY_HASH, //SDK use, not used by teamspeak. Hash is provided by an outside source. A channel will use the security salt + other client data to calculate a hash, which must be the same as the one provided here.
CLIENT_ENCRYPTION_CIPHERS, //internal use
CLIENT_ENDMARKER,
};
enum VirtualServerProperties {
VIRTUALSERVER_UNIQUE_IDENTIFIER = 0, //available when connected, can be used to identify this particular server installation
VIRTUALSERVER_NAME, //available and always up-to-date when connected
VIRTUALSERVER_WELCOMEMESSAGE, //available when connected, (=> requestServerVariables)
VIRTUALSERVER_PLATFORM, //available when connected
VIRTUALSERVER_VERSION, //available when connected
VIRTUALSERVER_MAXCLIENTS, //only available on request (=> requestServerVariables), stores the maximum number of clients that may currently join the server
VIRTUALSERVER_PASSWORD, //not available to clients, the server password
VIRTUALSERVER_CLIENTS_ONLINE, //only available on request (=> requestServerVariables),
VIRTUALSERVER_CHANNELS_ONLINE, //only available on request (=> requestServerVariables),
VIRTUALSERVER_CREATED, //available when connected, stores the time when the server was created
VIRTUALSERVER_UPTIME, //only available on request (=> requestServerVariables), the time since the server was started
VIRTUALSERVER_CODEC_ENCRYPTION_MODE, //available and always up-to-date when connected
VIRTUALSERVER_ENCRYPTION_CIPHERS, //internal use
VIRTUALSERVER_ENDMARKER,
};
enum ConnectionProperties {
CONNECTION_PING = 0, //average latency for a round trip through and back this connection
CONNECTION_PING_DEVIATION, //standard deviation of the above average latency
CONNECTION_CONNECTED_TIME, //how long the connection exists already
CONNECTION_IDLE_TIME, //how long since the last action of this client
CONNECTION_CLIENT_IP, //IP of this client (as seen from the server side)
CONNECTION_CLIENT_PORT, //Port of this client (as seen from the server side)
CONNECTION_SERVER_IP, //IP of the server (seen from the client side) - only available on yourself, not for remote clients, not available server side
CONNECTION_SERVER_PORT, //Port of the server (seen from the client side) - only available on yourself, not for remote clients, not available server side
CONNECTION_PACKETS_SENT_SPEECH, //how many Speech packets were sent through this connection
CONNECTION_PACKETS_SENT_KEEPALIVE,
CONNECTION_PACKETS_SENT_CONTROL,
CONNECTION_PACKETS_SENT_TOTAL, //how many packets were sent totally (this is PACKETS_SENT_SPEECH + PACKETS_SENT_KEEPALIVE + PACKETS_SENT_CONTROL)
CONNECTION_BYTES_SENT_SPEECH,
CONNECTION_BYTES_SENT_KEEPALIVE,
CONNECTION_BYTES_SENT_CONTROL,
CONNECTION_BYTES_SENT_TOTAL,
CONNECTION_PACKETS_RECEIVED_SPEECH,
CONNECTION_PACKETS_RECEIVED_KEEPALIVE,
CONNECTION_PACKETS_RECEIVED_CONTROL,
CONNECTION_PACKETS_RECEIVED_TOTAL,
CONNECTION_BYTES_RECEIVED_SPEECH,
CONNECTION_BYTES_RECEIVED_KEEPALIVE,
CONNECTION_BYTES_RECEIVED_CONTROL,
CONNECTION_BYTES_RECEIVED_TOTAL,
CONNECTION_PACKETLOSS_SPEECH,
CONNECTION_PACKETLOSS_KEEPALIVE,
CONNECTION_PACKETLOSS_CONTROL,
CONNECTION_PACKETLOSS_TOTAL, //the probability with which a packet round trip failed because a packet was lost
CONNECTION_SERVER2CLIENT_PACKETLOSS_SPEECH, //the probability with which a speech packet failed from the server to the client
CONNECTION_SERVER2CLIENT_PACKETLOSS_KEEPALIVE,
CONNECTION_SERVER2CLIENT_PACKETLOSS_CONTROL,
CONNECTION_SERVER2CLIENT_PACKETLOSS_TOTAL,
CONNECTION_CLIENT2SERVER_PACKETLOSS_SPEECH,
CONNECTION_CLIENT2SERVER_PACKETLOSS_KEEPALIVE,
CONNECTION_CLIENT2SERVER_PACKETLOSS_CONTROL,
CONNECTION_CLIENT2SERVER_PACKETLOSS_TOTAL,
CONNECTION_BANDWIDTH_SENT_LAST_SECOND_SPEECH, //howmany bytes of speech packets we sent during the last second
CONNECTION_BANDWIDTH_SENT_LAST_SECOND_KEEPALIVE,
CONNECTION_BANDWIDTH_SENT_LAST_SECOND_CONTROL,
CONNECTION_BANDWIDTH_SENT_LAST_SECOND_TOTAL,
CONNECTION_BANDWIDTH_SENT_LAST_MINUTE_SPEECH, //howmany bytes/s of speech packets we sent in average during the last minute
CONNECTION_BANDWIDTH_SENT_LAST_MINUTE_KEEPALIVE,
CONNECTION_BANDWIDTH_SENT_LAST_MINUTE_CONTROL,
CONNECTION_BANDWIDTH_SENT_LAST_MINUTE_TOTAL,
CONNECTION_BANDWIDTH_RECEIVED_LAST_SECOND_SPEECH,
CONNECTION_BANDWIDTH_RECEIVED_LAST_SECOND_KEEPALIVE,
CONNECTION_BANDWIDTH_RECEIVED_LAST_SECOND_CONTROL,
CONNECTION_BANDWIDTH_RECEIVED_LAST_SECOND_TOTAL,
CONNECTION_BANDWIDTH_RECEIVED_LAST_MINUTE_SPEECH,
CONNECTION_BANDWIDTH_RECEIVED_LAST_MINUTE_KEEPALIVE,
CONNECTION_BANDWIDTH_RECEIVED_LAST_MINUTE_CONTROL,
CONNECTION_BANDWIDTH_RECEIVED_LAST_MINUTE_TOTAL,
CONNECTION_ENDMARKER,
};
typedef struct {
float x; /* X co-ordinate in 3D space. */
float y; /* Y co-ordinate in 3D space. */
float z; /* Z co-ordinate in 3D space. */
} TS3_VECTOR;
enum GroupWhisperType {
GROUPWHISPERTYPE_SERVERGROUP = 0,
GROUPWHISPERTYPE_CHANNELGROUP = 1,
GROUPWHISPERTYPE_CHANNELCOMMANDER = 2,
GROUPWHISPERTYPE_ALLCLIENTS = 3,
GROUPWHISPERTYPE_ENDMARKER,
};
enum GroupWhisperTargetMode {
GROUPWHISPERTARGETMODE_ALL = 0,
GROUPWHISPERTARGETMODE_CURRENTCHANNEL = 1,
GROUPWHISPERTARGETMODE_PARENTCHANNEL = 2,
GROUPWHISPERTARGETMODE_ALLPARENTCHANNELS = 3,
GROUPWHISPERTARGETMODE_CHANNELFAMILY = 4,
GROUPWHISPERTARGETMODE_ANCESTORCHANNELFAMILY = 5,
GROUPWHISPERTARGETMODE_SUBCHANNELS = 6,
GROUPWHISPERTARGETMODE_ENDMARKER,
};
enum MonoSoundDestination{
MONO_SOUND_DESTINATION_ALL =0, /* Send mono sound to all available speakers */
MONO_SOUND_DESTINATION_FRONT_CENTER =1, /* Send mono sound to front center speaker if available */
MONO_SOUND_DESTINATION_FRONT_LEFT_AND_RIGHT =2 /* Send mono sound to front left/right speakers if available */
};
enum SecuritySaltOptions {
SECURITY_SALT_CHECK_NICKNAME = 1, /* put nickname into security hash */
SECURITY_SALT_CHECK_META_DATA = 2 /* put (game)meta data into security hash */
};
/*this enum is used to disable client commands on the server*/
enum ClientCommand{
CLIENT_COMMAND_requestConnectionInfo = 0,
CLIENT_COMMAND_requestClientMove = 1,
CLIENT_COMMAND_requestXXMuteClients = 2,
CLIENT_COMMAND_requestClientKickFromXXX = 3,
CLIENT_COMMAND_flushChannelCreation = 4,
CLIENT_COMMAND_flushChannelUpdates = 5,
CLIENT_COMMAND_requestChannelMove = 6,
CLIENT_COMMAND_requestChannelDelete = 7,
CLIENT_COMMAND_requestChannelDescription = 8,
CLIENT_COMMAND_requestChannelXXSubscribeXXX = 9,
CLIENT_COMMAND_requestServerConnectionInfo = 10,
CLIENT_COMMAND_requestSendXXXTextMsg = 11,
CLIENT_COMMAND_filetransfers = 12,
CLIENT_COMMAND_ENDMARKER
};
/* Access Control List*/
enum ACLType{
ACL_NONE = 0,
ACL_WHITE_LIST = 1,
ACL_BLACK_LIST = 2
};
/* file transfer actions*/
enum FTAction{
FT_INIT_SERVER = 0,
FT_INIT_CHANNEL = 1,
FT_UPLOAD = 2,
FT_DOWNLOAD = 3,
FT_DELETE = 4,
FT_CREATEDIR = 5,
FT_RENAME = 6,
FT_FILELIST = 7,
FT_FILEINFO = 8
};
/* file transfer status */
enum FileTransferState {
FILETRANSFER_INITIALISING = 0,
FILETRANSFER_ACTIVE,
FILETRANSFER_FINISHED,
};
/* file transfer types */
enum {
FileListType_Directory = 0,
FileListType_File,
};
/* some structs to handle variables in callbacks */
#define MAX_VARIABLES_EXPORT_COUNT 64
struct VariablesExportItem{
unsigned char itemIsValid; /* This item has valid values. ignore this item if 0 */
unsigned char proposedIsSet; /* The value in proposed is set. if 0 ignore proposed */
const char* current; /* current value (stored in memory) */
const char* proposed; /* New value to change to (const, so no updates please) */
};
struct VariablesExport{
struct VariablesExportItem items[MAX_VARIABLES_EXPORT_COUNT];
};
struct ClientMiniExport{
anyID ID;
uint64 channel;
const char* ident;
const char* nickname;
};
struct TransformFilePathExport{
uint64 channel;
const char* filename;
int action;
int transformedFileNameMaxSize;
int channelPathMaxSize;
};
struct TransformFilePathExportReturns{
char* transformedFileName;
char* channelPath;
int logFileAction;
};
struct FileTransferCallbackExport{
anyID clientID;
anyID transferID;
anyID remoteTransferID;
unsigned int status;
const char* statusMessage;
uint64 remotefileSize;
uint64 bytes;
int isSender;
};
/*define for file transfer bandwith limits*/
#define BANDWIDTH_LIMIT_UNLIMITED 0xFFFFFFFFFFFFFFFFll
/*defines for speaker locations used by some sound callbacks*/
#ifndef SPEAKER_FRONT_LEFT
#define SPEAKER_FRONT_LEFT 0x1
#define SPEAKER_FRONT_RIGHT 0x2
#define SPEAKER_FRONT_CENTER 0x4
#define SPEAKER_LOW_FREQUENCY 0x8
#define SPEAKER_BACK_LEFT 0x10
#define SPEAKER_BACK_RIGHT 0x20
#define SPEAKER_FRONT_LEFT_OF_CENTER 0x40
#define SPEAKER_FRONT_RIGHT_OF_CENTER 0x80
#define SPEAKER_BACK_CENTER 0x100
#define SPEAKER_SIDE_LEFT 0x200
#define SPEAKER_SIDE_RIGHT 0x400
#define SPEAKER_TOP_CENTER 0x800
#define SPEAKER_TOP_FRONT_LEFT 0x1000
#define SPEAKER_TOP_FRONT_CENTER 0x2000
#define SPEAKER_TOP_FRONT_RIGHT 0x4000
#define SPEAKER_TOP_BACK_LEFT 0x8000
#define SPEAKER_TOP_BACK_CENTER 0x10000
#define SPEAKER_TOP_BACK_RIGHT 0x20000
#endif
#define SPEAKER_HEADPHONES_LEFT 0x10000000
#define SPEAKER_HEADPHONES_RIGHT 0x20000000
#define SPEAKER_MONO 0x40000000
#endif /*PUBLIC_DEFINITIONS_H*/

194
include/teamspeak/public_errors.h Normal file
View File

@@ -0,0 +1,194 @@
#ifndef PUBLIC_ERRORS_H
#define PUBLIC_ERRORS_H
//The idea here is: the values are 2 bytes wide, the first byte identifies the group, the second the count within that group
enum Ts3ErrorType {
//general
ERROR_ok = 0x0000,
ERROR_undefined = 0x0001,
ERROR_not_implemented = 0x0002,
ERROR_ok_no_update = 0x0003,
ERROR_dont_notify = 0x0004,
ERROR_lib_time_limit_reached = 0x0005,
ERROR_out_of_memory = 0x0006,
ERROR_canceled = 0x0007,
//dunno
ERROR_command_not_found = 0x0100,
ERROR_unable_to_bind_network_port = 0x0101,
ERROR_no_network_port_available = 0x0102,
ERROR_port_already_in_use = 0x0103,
//client
ERROR_client_invalid_id = 0x0200,
ERROR_client_nickname_inuse = 0x0201,
ERROR_client_protocol_limit_reached = 0x0203,
ERROR_client_invalid_type = 0x0204,
ERROR_client_already_subscribed = 0x0205,
ERROR_client_not_logged_in = 0x0206,
ERROR_client_could_not_validate_identity = 0x0207,
ERROR_client_version_outdated = 0x020a,
ERROR_client_is_flooding = 0x020c,
ERROR_client_hacked = 0x020d,
ERROR_client_cannot_verify_now = 0x020e,
ERROR_client_login_not_permitted = 0x020f,
ERROR_client_not_subscribed = 0x0210,
//channel
ERROR_channel_invalid_id = 0x0300,
ERROR_channel_protocol_limit_reached = 0x0301,
ERROR_channel_already_in = 0x0302,
ERROR_channel_name_inuse = 0x0303,
ERROR_channel_not_empty = 0x0304,
ERROR_channel_can_not_delete_default = 0x0305,
ERROR_channel_default_require_permanent = 0x0306,
ERROR_channel_invalid_flags = 0x0307,
ERROR_channel_parent_not_permanent = 0x0308,
ERROR_channel_maxclients_reached = 0x0309,
ERROR_channel_maxfamily_reached = 0x030a,
ERROR_channel_invalid_order = 0x030b,
ERROR_channel_no_filetransfer_supported = 0x030c,
ERROR_channel_invalid_password = 0x030d,
ERROR_channel_invalid_security_hash = 0x030f, //note 0x030e is defined in public_rare_errors;
//server
ERROR_server_invalid_id = 0x0400,
ERROR_server_running = 0x0401,
ERROR_server_is_shutting_down = 0x0402,
ERROR_server_maxclients_reached = 0x0403,
ERROR_server_invalid_password = 0x0404,
ERROR_server_is_virtual = 0x0407,
ERROR_server_is_not_running = 0x0409,
ERROR_server_is_booting = 0x040a,
ERROR_server_status_invalid = 0x040b,
ERROR_server_version_outdated = 0x040d,
ERROR_server_duplicate_running = 0x040e,
//parameter
ERROR_parameter_quote = 0x0600,
ERROR_parameter_invalid_count = 0x0601,
ERROR_parameter_invalid = 0x0602,
ERROR_parameter_not_found = 0x0603,
ERROR_parameter_convert = 0x0604,
ERROR_parameter_invalid_size = 0x0605,
ERROR_parameter_missing = 0x0606,
ERROR_parameter_checksum = 0x0607,
//unsorted, need further investigation
ERROR_vs_critical = 0x0700,
ERROR_connection_lost = 0x0701,
ERROR_not_connected = 0x0702,
ERROR_no_cached_connection_info = 0x0703,
ERROR_currently_not_possible = 0x0704,
ERROR_failed_connection_initialisation = 0x0705,
ERROR_could_not_resolve_hostname = 0x0706,
ERROR_invalid_server_connection_handler_id = 0x0707,
ERROR_could_not_initialise_input_manager = 0x0708,
ERROR_clientlibrary_not_initialised = 0x0709,
ERROR_serverlibrary_not_initialised = 0x070a,
ERROR_whisper_too_many_targets = 0x070b,
ERROR_whisper_no_targets = 0x070c,
ERROR_connection_ip_protocol_missing = 0x070d,
//reserved = 0x070e,
ERROR_illegal_server_license = 0x070f,
//file transfer
ERROR_file_invalid_name = 0x0800,
ERROR_file_invalid_permissions = 0x0801,
ERROR_file_already_exists = 0x0802,
ERROR_file_not_found = 0x0803,
ERROR_file_io_error = 0x0804,
ERROR_file_invalid_transfer_id = 0x0805,
ERROR_file_invalid_path = 0x0806,
ERROR_file_no_files_available = 0x0807,
ERROR_file_overwrite_excludes_resume = 0x0808,
ERROR_file_invalid_size = 0x0809,
ERROR_file_already_in_use = 0x080a,
ERROR_file_could_not_open_connection = 0x080b,
ERROR_file_no_space_left_on_device = 0x080c,
ERROR_file_exceeds_file_system_maximum_size = 0x080d,
ERROR_file_transfer_connection_timeout = 0x080e,
ERROR_file_connection_lost = 0x080f,
ERROR_file_exceeds_supplied_size = 0x0810,
ERROR_file_transfer_complete = 0x0811,
ERROR_file_transfer_canceled = 0x0812,
ERROR_file_transfer_interrupted = 0x0813,
ERROR_file_transfer_server_quota_exceeded = 0x0814,
ERROR_file_transfer_client_quota_exceeded = 0x0815,
ERROR_file_transfer_reset = 0x0816,
ERROR_file_transfer_limit_reached = 0x0817,
//sound
ERROR_sound_preprocessor_disabled = 0x0900,
ERROR_sound_internal_preprocessor = 0x0901,
ERROR_sound_internal_encoder = 0x0902,
ERROR_sound_internal_playback = 0x0903,
ERROR_sound_no_capture_device_available = 0x0904,
ERROR_sound_no_playback_device_available = 0x0905,
ERROR_sound_could_not_open_capture_device = 0x0906,
ERROR_sound_could_not_open_playback_device = 0x0907,
ERROR_sound_handler_has_device = 0x0908,
ERROR_sound_invalid_capture_device = 0x0909,
ERROR_sound_invalid_playback_device = 0x090a,
ERROR_sound_invalid_wave = 0x090b,
ERROR_sound_unsupported_wave = 0x090c,
ERROR_sound_open_wave = 0x090d,
ERROR_sound_internal_capture = 0x090e,
ERROR_sound_device_in_use = 0x090f,
ERROR_sound_device_already_registerred = 0x0910,
ERROR_sound_unknown_device = 0x0911,
ERROR_sound_unsupported_frequency = 0x0912,
ERROR_sound_invalid_channel_count = 0x0913,
ERROR_sound_read_wave = 0x0914,
ERROR_sound_need_more_data = 0x0915, //for internal purposes only
ERROR_sound_device_busy = 0x0916, //for internal purposes only
ERROR_sound_no_data = 0x0917,
ERROR_sound_channel_mask_mismatch = 0x0918,
//permissions
ERROR_permissions_client_insufficient = 0x0a08,
ERROR_permissions = 0x0a0c,
//accounting
ERROR_accounting_virtualserver_limit_reached = 0x0b00,
ERROR_accounting_slot_limit_reached = 0x0b01,
ERROR_accounting_license_file_not_found = 0x0b02,
ERROR_accounting_license_date_not_ok = 0x0b03,
ERROR_accounting_unable_to_connect_to_server = 0x0b04,
ERROR_accounting_unknown_error = 0x0b05,
ERROR_accounting_server_error = 0x0b06,
ERROR_accounting_instance_limit_reached = 0x0b07,
ERROR_accounting_instance_check_error = 0x0b08,
ERROR_accounting_license_file_invalid = 0x0b09,
ERROR_accounting_running_elsewhere = 0x0b0a,
ERROR_accounting_instance_duplicated = 0x0b0b,
ERROR_accounting_already_started = 0x0b0c,
ERROR_accounting_not_started = 0x0b0d,
ERROR_accounting_to_many_starts = 0x0b0e,
//provisioning server
ERROR_provisioning_invalid_password = 0x1100,
ERROR_provisioning_invalid_request = 0x1101,
ERROR_provisioning_no_slots_available = 0x1102,
ERROR_provisioning_pool_missing = 0x1103,
ERROR_provisioning_pool_unknown = 0x1104,
ERROR_provisioning_unknown_ip_location = 0x1105,
ERROR_provisioning_internal_tries_exceeded = 0x1106,
ERROR_provisioning_too_many_slots_requested = 0x1107,
ERROR_provisioning_too_many_reserved = 0x1108,
ERROR_provisioning_could_not_connect = 0x1109,
ERROR_provisioning_auth_server_not_connected = 0x1110,
ERROR_provisioning_auth_data_too_large = 0x1111,
ERROR_provisioning_already_initialized = 0x1112,
ERROR_provisioning_not_initialized = 0x1113,
ERROR_provisioning_connecting = 0x1114,
ERROR_provisioning_already_connected = 0x1115,
ERROR_provisioning_not_connected = 0x1116,
ERROR_provisioning_io_error = 0x1117,
ERROR_provisioning_invalid_timeout = 0x1118,
ERROR_provisioning_ts3server_not_found = 0x1119,
ERROR_provisioning_no_permission = 0x111A,
};
#endif

97
include/teamspeak/public_errors_rare.h Normal file
View File

@@ -0,0 +1,97 @@
#ifndef PUBLIC_ERRORS__RARE_H
#define PUBLIC_ERRORS__RARE_H
//The idea here is: the values are 2 bytes wide, the first byte identifies the group, the second the count within that group
enum Ts3RareErrorType {
//client
ERROR_client_invalid_password = 0x0208,
ERROR_client_too_many_clones_connected = 0x0209,
ERROR_client_is_online = 0x020b,
//channel
ERROR_channel_is_private_channel = 0x030e,
//note 0x030f is defined in public_errors;
//database
ERROR_database = 0x0500,
ERROR_database_empty_result = 0x0501,
ERROR_database_duplicate_entry = 0x0502,
ERROR_database_no_modifications = 0x0503,
ERROR_database_constraint = 0x0504,
ERROR_database_reinvoke = 0x0505,
//permissions
ERROR_permission_invalid_group_id = 0x0a00,
ERROR_permission_duplicate_entry = 0x0a01,
ERROR_permission_invalid_perm_id = 0x0a02,
ERROR_permission_empty_result = 0x0a03,
ERROR_permission_default_group_forbidden = 0x0a04,
ERROR_permission_invalid_size = 0x0a05,
ERROR_permission_invalid_value = 0x0a06,
ERROR_permissions_group_not_empty = 0x0a07,
ERROR_permissions_insufficient_group_power = 0x0a09,
ERROR_permissions_insufficient_permission_power = 0x0a0a,
ERROR_permission_template_group_is_used = 0x0a0b,
//0x0a0c is in public_errors.h
ERROR_permission_used_by_integration = 0x0a0d,
//server
ERROR_server_deployment_active = 0x0405,
ERROR_server_unable_to_stop_own_server = 0x0406,
ERROR_server_wrong_machineid = 0x0408,
ERROR_server_modal_quit = 0x040c,
ERROR_server_time_difference_too_large = 0x040f,
ERROR_server_blacklisted = 0x0410,
//messages
ERROR_message_invalid_id = 0x0c00,
//ban
ERROR_ban_invalid_id = 0x0d00,
ERROR_connect_failed_banned = 0x0d01,
ERROR_rename_failed_banned = 0x0d02,
ERROR_ban_flooding = 0x0d03,
//tts
ERROR_tts_unable_to_initialize = 0x0e00,
//privilege key
ERROR_privilege_key_invalid = 0x0f00,
//voip
ERROR_voip_pjsua = 0x1000,
ERROR_voip_already_initialized = 0x1001,
ERROR_voip_too_many_accounts = 0x1002,
ERROR_voip_invalid_account = 0x1003,
ERROR_voip_internal_error = 0x1004,
ERROR_voip_invalid_connectionId = 0x1005,
ERROR_voip_cannot_answer_initiated_call = 0x1006,
ERROR_voip_not_initialized = 0x1007,
//ed25519
ERROR_ed25519_rng_fail = 0x1300,
ERROR_ed25519_signature_invalid = 0x1301,
ERROR_ed25519_invalid_key = 0x1302,
ERROR_ed25519_unable_to_create_valid_key = 0x1303,
ERROR_ed25519_out_of_memory = 0x1304,
ERROR_ed25519_exists = 0x1305,
ERROR_ed25519_read_beyond_eof = 0x1306,
ERROR_ed25519_write_beyond_eof = 0x1307,
ERROR_ed25519_version = 0x1308,
ERROR_ed25519_invalid = 0x1309,
ERROR_ed25519_invalid_date = 0x130A,
ERROR_ed25519_unauthorized = 0x130B,
ERROR_ed25519_invalid_type = 0x130C,
ERROR_ed25519_address_nomatch = 0x130D,
ERROR_ed25519_not_valid_yet = 0x130E,
ERROR_ed25519_expired = 0x130F,
ERROR_ed25519_index_out_of_range = 0x1310,
ERROR_ed25519_invalid_size = 0x1311,
//mytsid - client
ERROR_invalid_mytsid_data = 0x1200,
ERROR_invalid_integration = 0x1201,
};
#endif

359
include/teamspeak/public_rare_definitions.h Normal file
View File

@@ -0,0 +1,359 @@
#ifndef PUBLIC_RARE_DEFINITIONS_H
#define PUBLIC_RARE_DEFINITIONS_H
#include "public_definitions.h"
//limited length, measured in characters
#define TS3_MAX_SIZE_CLIENT_NICKNAME_NONSDK 30
#define TS3_MIN_SIZE_CLIENT_NICKNAME_NONSDK 3
#define TS3_MAX_SIZE_AWAY_MESSAGE 80
#define TS3_MAX_SIZE_GROUP_NAME 30
#define TS3_MAX_SIZE_TALK_REQUEST_MESSAGE 50
#define TS3_MAX_SIZE_COMPLAIN_MESSAGE 200
#define TS3_MAX_SIZE_CLIENT_DESCRIPTION 200
#define TS3_MAX_SIZE_HOST_MESSAGE 200
#define TS3_MAX_SIZE_HOSTBUTTON_TOOLTIP 50
#define TS3_MAX_SIZE_POKE_MESSAGE 100
#define TS3_MAX_SIZE_OFFLINE_MESSAGE 4096
#define TS3_MAX_SIZE_OFFLINE_MESSAGE_SUBJECT 200
//limited length, measured in bytes (utf8 encoded)
#define TS3_MAX_SIZE_PLUGIN_COMMAND 1024*8
#define TS3_MAX_SIZE_VIRTUALSERVER_HOSTBANNER_GFX_URL 2000
enum GroupShowNameTreeMode {
GroupShowNameTreeMode_NONE= 0, //dont group show name
GroupShowNameTreeMode_BEFORE, //show group name before client name
GroupShowNameTreeMode_BEHIND //show group name behind client name
};
enum PluginTargetMode {
PluginCommandTarget_CURRENT_CHANNEL=0, //send plugincmd to all clients in current channel
PluginCommandTarget_SERVER, //send plugincmd to all clients on server
PluginCommandTarget_CLIENT, //send plugincmd to all given client ids
PluginCommandTarget_CURRENT_CHANNEL_SUBSCRIBED_CLIENTS, //send plugincmd to all subscribed clients in current channel
PluginCommandTarget_MAX
};
enum {
SERVER_BINDING_VIRTUALSERVER=0,
SERVER_BINDING_SERVERQUERY =1,
SERVER_BINDING_FILETRANSFER =2,
};
enum HostMessageMode {
HostMessageMode_NONE=0, //dont display anything
HostMessageMode_LOG, //display message inside log
HostMessageMode_MODAL, //display message inside a modal dialog
HostMessageMode_MODALQUIT //display message inside a modal dialog and quit/close server/connection
};
enum HostBannerMode {
HostBannerMode_NO_ADJUST=0, //Do not adjust
HostBannerMode_ADJUST_IGNORE_ASPECT, //Adjust but ignore aspect ratio
HostBannerMode_ADJUST_KEEP_ASPECT, //Adjust and keep aspect ratio
};
enum ClientType {
ClientType_NORMAL = 0,
ClientType_SERVERQUERY,
};
enum AwayStatus {
AWAY_NONE = 0,
AWAY_ZZZ,
};
enum CommandLinePropertiesRare {
#ifdef SERVER
COMMANDLINE_CREATE_DEFAULT_VIRTUALSERVER= 0, //create default virtualserver
COMMANDLINE_MACHINE_ID, //machine id (starts only virtualserver with given machineID
COMMANDLINE_DEFAULT_VOICE_PORT,
COMMANDLINE_VOICE_IP,
COMMANDLINE_THREADS_VOICE_UDP,
COMMANDLINE_LICENSEPATH,
#ifndef SDK
COMMANDLINE_FILETRANSFER_PORT,
COMMANDLINE_FILETRANSFER_IP,
COMMANDLINE_QUERY_PORT,
COMMANDLINE_QUERY_IP,
COMMANDLINE_QUERY_IP_WHITELIST,
COMMANDLINE_QUERY_IP_BLACKLIST,
COMMANDLINE_CLEAR_DATABASE,
COMMANDLINE_SERVERADMIN_PASSWORD,
COMMANDLINE_DBPLUGIN,
COMMANDLINE_DBPLUGINPARAMETER,
COMMANDLINE_DBSQLPATH,
COMMANDLINE_DBSQLCREATEPATH,
COMMANDLINE_DBCONNECTIONS,
COMMANDLINE_LOGPATH,
COMMANDLINE_CREATEINIFILE,
COMMANDLINE_INIFILE,
COMMANDLINE_LOGQUERYCOMMANDS,
COMMANDLINE_DBCLIENTKEEPDAYS,
COMMANDLINE_NO_PERMISSION_UPDATE,
COMMANDLINE_OPEN_WIN_CONSOLE,
COMMANDLINE_NO_PASSWORD_DIALOG,
COMMANDLINE_LOGAPPEND,
COMMANDLINE_QUERY_SKIPBRUTEFORCECHECK,
COMMANDLINE_QUERY_BUFFER_MB,
COMMANDLINE_HTTP_PROXY,
COMMANDLINE_LICENSE_ACCEPTED,
COMMANDLINE_SERVERQUERYDOCS_PATH,
COMMANDLINE_QUERY_SSH_IP,
COMMANDLINE_QUERY_SSH_PORT,
COMMANDLINE_QUERY_PROTOCOLS,
COMMANDLINE_QUERY_SSH_RSA_HOST_KEY,
COMMANDLINE_QUERY_TIMEOUT,
COMMANDLINE_VERSION,
COMMANDLINE_CRASHDUMPSPATH,
COMMANDLINE_DAEMON,
COMMANDLINE_PID_FILE,
#endif
#else
COMMANDLINE_NOTHING=0,
#endif
COMMANDLINE_ENDMARKER_RARE,
};
enum ServerInstancePropertiesRare {
SERVERINSTANCE_DATABASE_VERSION= 0,
SERVERINSTANCE_FILETRANSFER_PORT,
SERVERINSTANCE_SERVER_ENTROPY,
SERVERINSTANCE_MONTHLY_TIMESTAMP,
SERVERINSTANCE_MAX_DOWNLOAD_TOTAL_BANDWIDTH,
SERVERINSTANCE_MAX_UPLOAD_TOTAL_BANDWIDTH,
SERVERINSTANCE_GUEST_SERVERQUERY_GROUP,
SERVERINSTANCE_SERVERQUERY_FLOOD_COMMANDS, //how many commands we can issue while in the SERVERINSTANCE_SERVERQUERY_FLOOD_TIME window
SERVERINSTANCE_SERVERQUERY_FLOOD_TIME, //time window in seconds for max command execution check
SERVERINSTANCE_SERVERQUERY_BAN_TIME, //how many seconds someone get banned if he floods
SERVERINSTANCE_TEMPLATE_SERVERADMIN_GROUP,
SERVERINSTANCE_TEMPLATE_SERVERDEFAULT_GROUP,
SERVERINSTANCE_TEMPLATE_CHANNELADMIN_GROUP,
SERVERINSTANCE_TEMPLATE_CHANNELDEFAULT_GROUP,
SERVERINSTANCE_PERMISSIONS_VERSION,
SERVERINSTANCE_PENDING_CONNECTIONS_PER_IP,
SERVERINSTANCE_SERVERQUERY_MAX_CONNECTIONS_PER_IP,
SERVERINSTANCE_ENDMARKER_RARE,
};
enum VirtualServerPropertiesRare {
VIRTUALSERVER_DUMMY_1 = VIRTUALSERVER_ENDMARKER,
VIRTUALSERVER_DUMMY_2,
VIRTUALSERVER_DUMMY_3,
VIRTUALSERVER_DUMMY_4,
VIRTUALSERVER_DUMMY_5,
VIRTUALSERVER_DUMMY_6,
VIRTUALSERVER_DUMMY_7,
VIRTUALSERVER_DUMMY_8,
VIRTUALSERVER_KEYPAIR, //internal use
VIRTUALSERVER_HOSTMESSAGE, //available when connected, not updated while connected
VIRTUALSERVER_HOSTMESSAGE_MODE, //available when connected, not updated while connected
VIRTUALSERVER_FILEBASE, //not available to clients, stores the folder used for file transfers
VIRTUALSERVER_DEFAULT_SERVER_GROUP, //the client permissions server group that a new client gets assigned
VIRTUALSERVER_DEFAULT_CHANNEL_GROUP, //the channel permissions group that a new client gets assigned when joining a channel
VIRTUALSERVER_FLAG_PASSWORD, //only available on request (=> requestServerVariables)
VIRTUALSERVER_DEFAULT_CHANNEL_ADMIN_GROUP, //the channel permissions group that a client gets assigned when creating a channel
VIRTUALSERVER_MAX_DOWNLOAD_TOTAL_BANDWIDTH, //only available on request (=> requestServerVariables)
VIRTUALSERVER_MAX_UPLOAD_TOTAL_BANDWIDTH, //only available on request (=> requestServerVariables)
VIRTUALSERVER_HOSTBANNER_URL, //available when connected, always up-to-date
VIRTUALSERVER_HOSTBANNER_GFX_URL, //available when connected, always up-to-date
VIRTUALSERVER_HOSTBANNER_GFX_INTERVAL, //available when connected, always up-to-date
VIRTUALSERVER_COMPLAIN_AUTOBAN_COUNT, //only available on request (=> requestServerVariables)
VIRTUALSERVER_COMPLAIN_AUTOBAN_TIME, //only available on request (=> requestServerVariables)
VIRTUALSERVER_COMPLAIN_REMOVE_TIME, //only available on request (=> requestServerVariables)
VIRTUALSERVER_MIN_CLIENTS_IN_CHANNEL_BEFORE_FORCED_SILENCE,//only available on request (=> requestServerVariables)
VIRTUALSERVER_PRIORITY_SPEAKER_DIMM_MODIFICATOR, //available when connected, always up-to-date
VIRTUALSERVER_ID, //available when connected
VIRTUALSERVER_ANTIFLOOD_POINTS_TICK_REDUCE, //only available on request (=> requestServerVariables)
VIRTUALSERVER_ANTIFLOOD_POINTS_NEEDED_COMMAND_BLOCK, //only available on request (=> requestServerVariables)
VIRTUALSERVER_ANTIFLOOD_POINTS_NEEDED_IP_BLOCK, //only available on request (=> requestServerVariables)
VIRTUALSERVER_CLIENT_CONNECTIONS, //only available on request (=> requestServerVariables)
VIRTUALSERVER_QUERY_CLIENT_CONNECTIONS, //only available on request (=> requestServerVariables)
VIRTUALSERVER_HOSTBUTTON_TOOLTIP, //available when connected, always up-to-date
VIRTUALSERVER_HOSTBUTTON_URL, //available when connected, always up-to-date
VIRTUALSERVER_HOSTBUTTON_GFX_URL, //available when connected, always up-to-date
VIRTUALSERVER_QUERYCLIENTS_ONLINE, //only available on request (=> requestServerVariables)
VIRTUALSERVER_DOWNLOAD_QUOTA, //only available on request (=> requestServerVariables)
VIRTUALSERVER_UPLOAD_QUOTA, //only available on request (=> requestServerVariables)
VIRTUALSERVER_MONTH_BYTES_DOWNLOADED, //only available on request (=> requestServerVariables)
VIRTUALSERVER_MONTH_BYTES_UPLOADED, //only available on request (=> requestServerVariables)
VIRTUALSERVER_TOTAL_BYTES_DOWNLOADED, //only available on request (=> requestServerVariables)
VIRTUALSERVER_TOTAL_BYTES_UPLOADED, //only available on request (=> requestServerVariables)
VIRTUALSERVER_PORT, //only available on request (=> requestServerVariables)
VIRTUALSERVER_AUTOSTART, //only available on request (=> requestServerVariables)
VIRTUALSERVER_MACHINE_ID, //only available on request (=> requestServerVariables)
VIRTUALSERVER_NEEDED_IDENTITY_SECURITY_LEVEL, //only available on request (=> requestServerVariables)
VIRTUALSERVER_LOG_CLIENT, //only available on request (=> requestServerVariables)
VIRTUALSERVER_LOG_QUERY, //only available on request (=> requestServerVariables)
VIRTUALSERVER_LOG_CHANNEL, //only available on request (=> requestServerVariables)
VIRTUALSERVER_LOG_PERMISSIONS, //only available on request (=> requestServerVariables)
VIRTUALSERVER_LOG_SERVER, //only available on request (=> requestServerVariables)
VIRTUALSERVER_LOG_FILETRANSFER, //only available on request (=> requestServerVariables)
VIRTUALSERVER_MIN_CLIENT_VERSION, //only available on request (=> requestServerVariables)
VIRTUALSERVER_NAME_PHONETIC, //available when connected, always up-to-date
VIRTUALSERVER_ICON_ID, //available when connected, always up-to-date
VIRTUALSERVER_RESERVED_SLOTS, //available when connected, always up-to-date
VIRTUALSERVER_TOTAL_PACKETLOSS_SPEECH, //only available on request (=> requestServerVariables)
VIRTUALSERVER_TOTAL_PACKETLOSS_KEEPALIVE, //only available on request (=> requestServerVariables)
VIRTUALSERVER_TOTAL_PACKETLOSS_CONTROL, //only available on request (=> requestServerVariables)
VIRTUALSERVER_TOTAL_PACKETLOSS_TOTAL, //only available on request (=> requestServerVariables)
VIRTUALSERVER_TOTAL_PING, //only available on request (=> requestServerVariables)
VIRTUALSERVER_IP, //internal use | contains comma separated ip list
VIRTUALSERVER_WEBLIST_ENABLED, //only available on request (=> requestServerVariables)
VIRTUALSERVER_AUTOGENERATED_PRIVILEGEKEY, //internal use
VIRTUALSERVER_ASK_FOR_PRIVILEGEKEY, //available when connected
VIRTUALSERVER_HOSTBANNER_MODE, //available when connected, always up-to-date
VIRTUALSERVER_CHANNEL_TEMP_DELETE_DELAY_DEFAULT, //available when connected, always up-to-date
VIRTUALSERVER_MIN_ANDROID_VERSION, //only available on request (=> requestServerVariables)
VIRTUALSERVER_MIN_IOS_VERSION, //only available on request (=> requestServerVariables)
VIRTUALSERVER_MIN_WINPHONE_VERSION, //only available on request (=> requestServerVariables)
VIRTUALSERVER_NICKNAME, //available when connected, always up-to-date
VIRTUALSERVER_ACCOUNTING_TOKEN, //internal use | contains base64 encoded token data
VIRTUALSERVER_PROTOCOL_VERIFY_KEYPAIR, //internal use
VIRTUALSERVER_ANTIFLOOD_POINTS_NEEDED_PLUGIN_BLOCK, //only available on request (=> requestServerVariables)
VIRTUALSERVER_ENDMARKER_RARE
};
enum ChannelPropertiesRare {
CHANNEL_DUMMY_2= CHANNEL_ENDMARKER,
CHANNEL_DUMMY_3,
CHANNEL_DUMMY_4,
CHANNEL_DUMMY_5,
CHANNEL_DUMMY_6,
CHANNEL_DUMMY_7,
CHANNEL_FLAG_MAXCLIENTS_UNLIMITED, //Available for all channels that are "in view", always up-to-date
CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED,//Available for all channels that are "in view", always up-to-date
CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED,//Available for all channels that are "in view", always up-to-date
CHANNEL_FLAG_ARE_SUBSCRIBED, //Only available client side, stores whether we are subscribed to this channel
CHANNEL_FILEPATH, //not available client side, the folder used for file-transfers for this channel
CHANNEL_NEEDED_TALK_POWER, //Available for all channels that are "in view", always up-to-date
CHANNEL_FORCED_SILENCE, //Available for all channels that are "in view", always up-to-date
CHANNEL_NAME_PHONETIC, //Available for all channels that are "in view", always up-to-date
CHANNEL_ICON_ID, //Available for all channels that are "in view", always up-to-date
CHANNEL_BANNER_GFX_URL, //Available for all channels that are "in view", always up-to-date
CHANNEL_BANNER_MODE, //Available for all channels that are "in view", always up-to-date
CHANNEL_ENDMARKER_RARE,
CHANNEL_DELETE_DELAY_DEADLINE = 127 //(for clientlibv2) expected delete time in monotonic clock seconds or 0 if nothing is expected
};
enum ClientPropertiesRare {
CLIENT_DUMMY_4 = CLIENT_ENDMARKER,
CLIENT_DUMMY_5,
CLIENT_DUMMY_6,
CLIENT_DUMMY_7,
CLIENT_DUMMY_8,
CLIENT_DUMMY_9,
CLIENT_KEY_OFFSET, //internal use
CLIENT_LAST_VAR_REQUEST, //internal use
CLIENT_LOGIN_NAME, //used for serverquery clients, makes no sense on normal clients currently
CLIENT_LOGIN_PASSWORD, //used for serverquery clients, makes no sense on normal clients currently
CLIENT_DATABASE_ID, //automatically up-to-date for any client "in view", only valid with PERMISSION feature, holds database client id
CLIENT_CHANNEL_GROUP_ID, //automatically up-to-date for any client "in view", only valid with PERMISSION feature, holds database client id
CLIENT_SERVERGROUPS, //automatically up-to-date for any client "in view", only valid with PERMISSION feature, holds all servergroups client belongs too
CLIENT_CREATED, //this needs to be requested (=> requestClientVariables), first time this client connected to this server
CLIENT_LASTCONNECTED, //this needs to be requested (=> requestClientVariables), last time this client connected to this server
CLIENT_TOTALCONNECTIONS, //this needs to be requested (=> requestClientVariables), how many times this client connected to this server
CLIENT_AWAY, //automatically up-to-date for any client "in view", this clients away status
CLIENT_AWAY_MESSAGE, //automatically up-to-date for any client "in view", this clients away message
CLIENT_TYPE, //automatically up-to-date for any client "in view", determines if this is a real client or a server-query connection
CLIENT_FLAG_AVATAR, //automatically up-to-date for any client "in view", this client got an avatar
CLIENT_TALK_POWER, //automatically up-to-date for any client "in view", only valid with PERMISSION feature, holds database client id
CLIENT_TALK_REQUEST, //automatically up-to-date for any client "in view", only valid with PERMISSION feature, holds timestamp where client requested to talk
CLIENT_TALK_REQUEST_MSG, //automatically up-to-date for any client "in view", only valid with PERMISSION feature, holds matter for the request
CLIENT_DESCRIPTION, //automatically up-to-date for any client "in view"
CLIENT_IS_TALKER, //automatically up-to-date for any client "in view"
CLIENT_MONTH_BYTES_UPLOADED, //this needs to be requested (=> requestClientVariables)
CLIENT_MONTH_BYTES_DOWNLOADED, //this needs to be requested (=> requestClientVariables)
CLIENT_TOTAL_BYTES_UPLOADED, //this needs to be requested (=> requestClientVariables)
CLIENT_TOTAL_BYTES_DOWNLOADED, //this needs to be requested (=> requestClientVariables)
CLIENT_IS_PRIORITY_SPEAKER, //automatically up-to-date for any client "in view"
CLIENT_UNREAD_MESSAGES, //automatically up-to-date for any client "in view"
CLIENT_NICKNAME_PHONETIC, //automatically up-to-date for any client "in view"
CLIENT_NEEDED_SERVERQUERY_VIEW_POWER, //automatically up-to-date for any client "in view"
CLIENT_DEFAULT_TOKEN, //only usable for ourself, the default token we used to connect on our last connection attempt
CLIENT_ICON_ID, //automatically up-to-date for any client "in view"
CLIENT_IS_CHANNEL_COMMANDER, //automatically up-to-date for any client "in view"
CLIENT_COUNTRY, //automatically up-to-date for any client "in view"
CLIENT_CHANNEL_GROUP_INHERITED_CHANNEL_ID, //automatically up-to-date for any client "in view", only valid with PERMISSION feature, contains channel_id where the channel_group_id is set from
CLIENT_BADGES, //automatically up-to-date for any client "in view", stores icons for partner badges
CLIENT_MYTEAMSPEAK_ID, //automatically up-to-date for any client "in view", stores myteamspeak id
CLIENT_INTEGRATIONS, //automatically up-to-date for any client "in view", stores integrations
CLIENT_ACTIVE_INTEGRATIONS_INFO, //stores info from the myts server and contains the subscription info
CLIENT_MYTS_AVATAR,
CLIENT_SIGNED_BADGES,
CLIENT_ENDMARKER_RARE,
CLIENT_HW_ID = 127 //(for clientlibv2) unique hardware id
};
enum ConnectionPropertiesRare {
CONNECTION_DUMMY_0= CONNECTION_ENDMARKER,
CONNECTION_DUMMY_1,
CONNECTION_DUMMY_2,
CONNECTION_DUMMY_3,
CONNECTION_DUMMY_4,
CONNECTION_DUMMY_5,
CONNECTION_DUMMY_6,
CONNECTION_DUMMY_7,
CONNECTION_DUMMY_8,
CONNECTION_DUMMY_9,
CONNECTION_FILETRANSFER_BANDWIDTH_SENT, //how many bytes per second are currently being sent by file transfers
CONNECTION_FILETRANSFER_BANDWIDTH_RECEIVED, //how many bytes per second are currently being received by file transfers
CONNECTION_FILETRANSFER_BYTES_RECEIVED_TOTAL, //how many bytes we received in total through file transfers
CONNECTION_FILETRANSFER_BYTES_SENT_TOTAL, //how many bytes we sent in total through file transfers
CONNECTION_ENDMARKER_RARE,
};
enum BBCodeTags {
BBCodeTag_B = 0x00000001,
BBCodeTag_I = 0x00000002,
BBCodeTag_U = 0x00000004,
BBCodeTag_S = 0x00000008,
BBCodeTag_SUP = 0x00000010,
BBCodeTag_SUB = 0x00000020,
BBCodeTag_COLOR = 0x00000040,
BBCodeTag_SIZE = 0x00000080,
BBCodeTag_group_text = 0x000000FF,
BBCodeTag_LEFT = 0x00001000,
BBCodeTag_RIGHT = 0x00002000,
BBCodeTag_CENTER = 0x00004000,
BBCodeTag_group_align = 0x00007000,
BBCodeTag_URL = 0x00010000,
BBCodeTag_IMAGE = 0x00020000,
BBCodeTag_HR = 0x00040000,
BBCodeTag_LIST = 0x00100000,
BBCodeTag_LISTITEM = 0x00200000,
BBCodeTag_group_list = 0x00300000,
BBCodeTag_TABLE = 0x00400000,
BBCodeTag_TR = 0x00800000,
BBCodeTag_TH = 0x01000000,
BBCodeTag_TD = 0x02000000,
BBCodeTag_group_table = 0x03C00000,
BBCodeTag_def_simple = BBCodeTag_B | BBCodeTag_I | BBCodeTag_U | BBCodeTag_S | BBCodeTag_SUP | BBCodeTag_SUB |BBCodeTag_COLOR | BBCodeTag_URL,
BBCodeTag_def_simple_Img = BBCodeTag_def_simple | BBCodeTag_IMAGE,
BBCodeTag_def_extended = BBCodeTag_group_text | BBCodeTag_group_align | BBCodeTag_URL | BBCodeTag_IMAGE | BBCodeTag_HR | BBCodeTag_group_list | BBCodeTag_group_table,
};
enum LicenseIssue {
Blacklisted = 0,
Greylisted
};
enum MytsDataUnsetFlags {
MytsDataUnsetFlag_None = 0,
MytsDataUnsetFlag_Badges = 1,
MytsDataUnsetFlag_Avatar = 1 << 1,
MytsDataUnsetFlag_All = MytsDataUnsetFlag_Badges | MytsDataUnsetFlag_Avatar // make sure "all" really contains all flags
};
typedef int(*ExtraBBCodeValidator)(void* userparam, const char* tag, const char* paramValue, int paramValueSize, const char* childValue, int childValueSize);
typedef const char* (*ExtraBBCodeParamTransform)(void* userparam, const char* tag, const char* paramValue);
#endif //PUBLIC_RARE_DEFINITIONS_H

283
include/ts3_functions.h Normal file
View File

@@ -0,0 +1,283 @@
#ifndef TS3_FUNCTIONS_H
#define TS3_FUNCTIONS_H
#ifdef __cplusplus
extern "C" {
#endif
#include "teamspeak/clientlib_publicdefinitions.h"
#include "teamspeak/public_definitions.h"
#include "plugin_definitions.h"
/* Functions exported to plugin from main binary */
struct TS3Functions {
unsigned int (*getClientLibVersion)(char** result);
unsigned int (*getClientLibVersionNumber)(uint64* result);
unsigned int (*spawnNewServerConnectionHandler)(int port, uint64* result);
unsigned int (*destroyServerConnectionHandler)(uint64 serverConnectionHandlerID);
/* Error handling */
unsigned int (*getErrorMessage)(unsigned int errorCode, char** error);
/* Memory management */
unsigned int (*freeMemory)(void* pointer);
/* Logging */
unsigned int (*logMessage)(const char* logMessage, enum LogLevel severity, const char* channel, uint64 logID);
/* Sound */
unsigned int (*getPlaybackDeviceList)(const char* modeID, char**** result);
unsigned int (*getPlaybackModeList)(char*** result);
unsigned int (*getCaptureDeviceList)(const char* modeID, char**** result);
unsigned int (*getCaptureModeList)(char*** result);
unsigned int (*getDefaultPlaybackDevice)(const char* modeID, char*** result);
unsigned int (*getDefaultPlayBackMode)(char** result);
unsigned int (*getDefaultCaptureDevice)(const char* modeID, char*** result);
unsigned int (*getDefaultCaptureMode)(char** result);
unsigned int (*openPlaybackDevice)(uint64 serverConnectionHandlerID, const char* modeID, const char* playbackDevice);
unsigned int (*openCaptureDevice)(uint64 serverConnectionHandlerID, const char* modeID, const char* captureDevice);
unsigned int (*getCurrentPlaybackDeviceName)(uint64 serverConnectionHandlerID, char** result, int* isDefault);
unsigned int (*getCurrentPlayBackMode)(uint64 serverConnectionHandlerID, char** result);
unsigned int (*getCurrentCaptureDeviceName)(uint64 serverConnectionHandlerID, char** result, int* isDefault);
unsigned int (*getCurrentCaptureMode)(uint64 serverConnectionHandlerID, char** result);
unsigned int (*initiateGracefulPlaybackShutdown)(uint64 serverConnectionHandlerID);
unsigned int (*closePlaybackDevice)(uint64 serverConnectionHandlerID);
unsigned int (*closeCaptureDevice)(uint64 serverConnectionHandlerID);
unsigned int (*activateCaptureDevice)(uint64 serverConnectionHandlerID);
unsigned int (*playWaveFileHandle)(uint64 serverConnectionHandlerID, const char* path, int loop, uint64* waveHandle);
unsigned int (*pauseWaveFileHandle)(uint64 serverConnectionHandlerID, uint64 waveHandle, int pause);
unsigned int (*closeWaveFileHandle)(uint64 serverConnectionHandlerID, uint64 waveHandle);
unsigned int (*playWaveFile)(uint64 serverConnectionHandlerID, const char* path);
unsigned int (*registerCustomDevice)(const char* deviceID, const char* deviceDisplayName, int capFrequency, int capChannels, int playFrequency, int playChannels);
unsigned int (*unregisterCustomDevice)(const char* deviceID);
unsigned int (*processCustomCaptureData)(const char* deviceName, const short* buffer, int samples);
unsigned int (*acquireCustomPlaybackData)(const char* deviceName, short* buffer, int samples);
/* Preprocessor */
unsigned int (*getPreProcessorInfoValueFloat)(uint64 serverConnectionHandlerID, const char* ident, float* result);
unsigned int (*getPreProcessorConfigValue)(uint64 serverConnectionHandlerID, const char* ident, char** result);
unsigned int (*setPreProcessorConfigValue)(uint64 serverConnectionHandlerID, const char* ident, const char* value);
/* Encoder */
unsigned int (*getEncodeConfigValue)(uint64 serverConnectionHandlerID, const char* ident, char** result);
/* Playback */
unsigned int (*getPlaybackConfigValueAsFloat)(uint64 serverConnectionHandlerID, const char* ident, float* result);
unsigned int (*setPlaybackConfigValue)(uint64 serverConnectionHandlerID, const char* ident, const char* value);
unsigned int (*setClientVolumeModifier)(uint64 serverConnectionHandlerID, anyID clientID, float value);
/* Recording */
unsigned int (*startVoiceRecording)(uint64 serverConnectionHandlerID);
unsigned int (*stopVoiceRecording)(uint64 serverConnectionHandlerID);
/* 3d sound positioning */
unsigned int (*systemset3DListenerAttributes) (uint64 serverConnectionHandlerID, const TS3_VECTOR* position, const TS3_VECTOR* forward, const TS3_VECTOR* up);
unsigned int (*set3DWaveAttributes) (uint64 serverConnectionHandlerID, uint64 waveHandle, const TS3_VECTOR* position);
unsigned int (*systemset3DSettings) (uint64 serverConnectionHandlerID, float distanceFactor, float rolloffScale);
unsigned int (*channelset3DAttributes) (uint64 serverConnectionHandlerID, anyID clientID, const TS3_VECTOR* position);
/* Interaction with the server */
unsigned int (*startConnection)(uint64 serverConnectionHandlerID, const char* identity, const char* ip, unsigned int port, const char* nickname,
const char** defaultChannelArray, const char* defaultChannelPassword, const char* serverPassword);
unsigned int (*stopConnection)(uint64 serverConnectionHandlerID, const char* quitMessage);
unsigned int (*requestClientMove)(uint64 serverConnectionHandlerID, anyID clientID, uint64 newChannelID, const char* password, const char* returnCode);
unsigned int (*requestClientVariables)(uint64 serverConnectionHandlerID, anyID clientID, const char* returnCode);
unsigned int (*requestClientKickFromChannel)(uint64 serverConnectionHandlerID, anyID clientID, const char* kickReason, const char* returnCode);
unsigned int (*requestClientKickFromServer)(uint64 serverConnectionHandlerID, anyID clientID, const char* kickReason, const char* returnCode);
unsigned int (*requestChannelDelete)(uint64 serverConnectionHandlerID, uint64 channelID, int force, const char* returnCode);
unsigned int (*requestChannelMove)(uint64 serverConnectionHandlerID, uint64 channelID, uint64 newChannelParentID, uint64 newChannelOrder, const char* returnCode);
unsigned int (*requestSendPrivateTextMsg)(uint64 serverConnectionHandlerID, const char* message, anyID targetClientID, const char* returnCode);
unsigned int (*requestSendChannelTextMsg)(uint64 serverConnectionHandlerID, const char* message, uint64 targetChannelID, const char* returnCode);
unsigned int (*requestSendServerTextMsg)(uint64 serverConnectionHandlerID, const char* message, const char* returnCode);
unsigned int (*requestConnectionInfo)(uint64 serverConnectionHandlerID, anyID clientID, const char* returnCode);
unsigned int (*requestClientSetWhisperList)(uint64 serverConnectionHandlerID, anyID clientID, const uint64* targetChannelIDArray, const anyID* targetClientIDArray, const char* returnCode);
unsigned int (*requestChannelSubscribe)(uint64 serverConnectionHandlerID, const uint64* channelIDArray, const char* returnCode);
unsigned int (*requestChannelSubscribeAll)(uint64 serverConnectionHandlerID, const char* returnCode);
unsigned int (*requestChannelUnsubscribe)(uint64 serverConnectionHandlerID, const uint64* channelIDArray, const char* returnCode);
unsigned int (*requestChannelUnsubscribeAll)(uint64 serverConnectionHandlerID, const char* returnCode);
unsigned int (*requestChannelDescription)(uint64 serverConnectionHandlerID, uint64 channelID, const char* returnCode);
unsigned int (*requestMuteClients)(uint64 serverConnectionHandlerID, const anyID* clientIDArray, const char* returnCode);
unsigned int (*requestUnmuteClients)(uint64 serverConnectionHandlerID, const anyID* clientIDArray, const char* returnCode);
unsigned int (*requestClientPoke)(uint64 serverConnectionHandlerID, anyID clientID, const char* message, const char* returnCode);
unsigned int (*requestClientIDs)(uint64 serverConnectionHandlerID, const char* clientUniqueIdentifier, const char* returnCode);
unsigned int (*clientChatClosed)(uint64 serverConnectionHandlerID, const char* clientUniqueIdentifier, anyID clientID, const char* returnCode);
unsigned int (*clientChatComposing)(uint64 serverConnectionHandlerID, anyID clientID, const char* returnCode);
unsigned int (*requestServerTemporaryPasswordAdd)(uint64 serverConnectionHandlerID, const char* password, const char* description, uint64 duration, uint64 targetChannelID, const char* targetChannelPW, const char* returnCode);
unsigned int (*requestServerTemporaryPasswordDel)(uint64 serverConnectionHandlerID, const char* password, const char* returnCode);
unsigned int (*requestServerTemporaryPasswordList)(uint64 serverConnectionHandlerID, const char* returnCode);
/* Access clientlib information */
/* Query own client ID */
unsigned int (*getClientID)(uint64 serverConnectionHandlerID, anyID* result);
/* Client info */
unsigned int (*getClientSelfVariableAsInt)(uint64 serverConnectionHandlerID, size_t flag, int* result);
unsigned int (*getClientSelfVariableAsString)(uint64 serverConnectionHandlerID, size_t flag, char** result);
unsigned int (*setClientSelfVariableAsInt)(uint64 serverConnectionHandlerID, size_t flag, int value);
unsigned int (*setClientSelfVariableAsString)(uint64 serverConnectionHandlerID, size_t flag, const char* value);
unsigned int (*flushClientSelfUpdates)(uint64 serverConnectionHandlerID, const char* returnCode);
unsigned int (*getClientVariableAsInt)(uint64 serverConnectionHandlerID, anyID clientID, size_t flag, int* result);
unsigned int (*getClientVariableAsUInt64)(uint64 serverConnectionHandlerID, anyID clientID, size_t flag, uint64* result);
unsigned int (*getClientVariableAsString)(uint64 serverConnectionHandlerID, anyID clientID, size_t flag, char** result);
unsigned int (*getClientList)(uint64 serverConnectionHandlerID, anyID** result);
unsigned int (*getChannelOfClient)(uint64 serverConnectionHandlerID, anyID clientID, uint64* result);
/* Channel info */
unsigned int (*getChannelVariableAsInt)(uint64 serverConnectionHandlerID, uint64 channelID, size_t flag, int* result);
unsigned int (*getChannelVariableAsUInt64)(uint64 serverConnectionHandlerID, uint64 channelID, size_t flag, uint64* result);
unsigned int (*getChannelVariableAsString)(uint64 serverConnectionHandlerID, uint64 channelID, size_t flag, char** result);
unsigned int (*getChannelIDFromChannelNames)(uint64 serverConnectionHandlerID, char** channelNameArray, uint64* result);
unsigned int (*setChannelVariableAsInt)(uint64 serverConnectionHandlerID, uint64 channelID, size_t flag, int value);
unsigned int (*setChannelVariableAsUInt64)(uint64 serverConnectionHandlerID, uint64 channelID, size_t flag, uint64 value);
unsigned int (*setChannelVariableAsString)(uint64 serverConnectionHandlerID, uint64 channelID, size_t flag, const char* value);
unsigned int (*flushChannelUpdates)(uint64 serverConnectionHandlerID, uint64 channelID, const char* returnCode);
unsigned int (*flushChannelCreation)(uint64 serverConnectionHandlerID, uint64 channelParentID, const char* returnCode);
unsigned int (*getChannelList)(uint64 serverConnectionHandlerID, uint64** result);
unsigned int (*getChannelClientList)(uint64 serverConnectionHandlerID, uint64 channelID, anyID** result);
unsigned int (*getParentChannelOfChannel)(uint64 serverConnectionHandlerID, uint64 channelID, uint64* result);
/* Server info */
unsigned int (*getServerConnectionHandlerList)(uint64** result);
unsigned int (*getServerVariableAsInt)(uint64 serverConnectionHandlerID, size_t flag, int* result);
unsigned int (*getServerVariableAsUInt64)(uint64 serverConnectionHandlerID, size_t flag, uint64* result);
unsigned int (*getServerVariableAsString)(uint64 serverConnectionHandlerID, size_t flag, char** result);
unsigned int (*requestServerVariables)(uint64 serverConnectionHandlerID);
/* Connection info */
unsigned int (*getConnectionStatus)(uint64 serverConnectionHandlerID, int* result);
unsigned int (*getConnectionVariableAsUInt64)(uint64 serverConnectionHandlerID, anyID clientID, size_t flag, uint64* result);
unsigned int (*getConnectionVariableAsDouble)(uint64 serverConnectionHandlerID, anyID clientID, size_t flag, double* result);
unsigned int (*getConnectionVariableAsString)(uint64 serverConnectionHandlerID, anyID clientID, size_t flag, char** result);
unsigned int (*cleanUpConnectionInfo)(uint64 serverConnectionHandlerID, anyID clientID);
/* Client related */
unsigned int (*requestClientDBIDfromUID)(uint64 serverConnectionHandlerID, const char* clientUniqueIdentifier, const char* returnCode);
unsigned int (*requestClientNamefromUID)(uint64 serverConnectionHandlerID, const char* clientUniqueIdentifier, const char* returnCode);
unsigned int (*requestClientNamefromDBID)(uint64 serverConnectionHandlerID, uint64 clientDatabaseID, const char* returnCode);
unsigned int (*requestClientEditDescription)(uint64 serverConnectionHandlerID, anyID clientID, const char* clientDescription, const char* returnCode);
unsigned int (*requestClientSetIsTalker)(uint64 serverConnectionHandlerID, anyID clientID, int isTalker, const char* returnCode);
unsigned int (*requestIsTalker)(uint64 serverConnectionHandlerID, int isTalkerRequest, const char* isTalkerRequestMessage, const char* returnCode);
/* Plugin related */
unsigned int (*requestSendClientQueryCommand)(uint64 serverConnectionHandlerID, const char* command, const char* returnCode);
/* Filetransfer */
unsigned int (*getTransferFileName)(anyID transferID, char** result);
unsigned int (*getTransferFilePath)(anyID transferID, char** result);
unsigned int (*getTransferFileSize)(anyID transferID, uint64* result);
unsigned int (*getTransferFileSizeDone)(anyID transferID, uint64* result);
unsigned int (*isTransferSender)(anyID transferID, int* result); /* 1 == upload, 0 == download */
unsigned int (*getTransferStatus)(anyID transferID, int* result);
unsigned int (*getCurrentTransferSpeed)(anyID transferID, float* result);
unsigned int (*getAverageTransferSpeed)(anyID transferID, float* result);
unsigned int (*getTransferRunTime)(anyID transferID, uint64* result);
unsigned int (*sendFile)(uint64 serverConnectionHandlerID, uint64 channelID, const char* channelPW, const char* file, int overwrite, int resume, const char* sourceDirectory, anyID* result, const char* returnCode);
unsigned int (*requestFile)(uint64 serverConnectionHandlerID, uint64 channelID, const char* channelPW, const char* file, int overwrite, int resume, const char* destinationDirectory, anyID* result, const char* returnCode);
unsigned int (*haltTransfer)(uint64 serverConnectionHandlerID, anyID transferID, int deleteUnfinishedFile, const char* returnCode);
unsigned int (*requestFileList)(uint64 serverConnectionHandlerID, uint64 channelID, const char* channelPW, const char* path, const char* returnCode);
unsigned int (*requestFileInfo)(uint64 serverConnectionHandlerID, uint64 channelID, const char* channelPW, const char* file, const char* returnCode);
unsigned int (*requestDeleteFile)(uint64 serverConnectionHandlerID, uint64 channelID, const char* channelPW, const char** file, const char* returnCode);
unsigned int (*requestCreateDirectory)(uint64 serverConnectionHandlerID, uint64 channelID, const char* channelPW, const char* directoryPath, const char* returnCode);
unsigned int (*requestRenameFile)(uint64 serverConnectionHandlerID, uint64 fromChannelID, const char* channelPW, uint64 toChannelID, const char* toChannelPW, const char* oldFile, const char* newFile, const char* returnCode);
/* Offline message management */
unsigned int (*requestMessageAdd)(uint64 serverConnectionHandlerID, const char* toClientUID, const char* subject, const char* message, const char* returnCode);
unsigned int (*requestMessageDel)(uint64 serverConnectionHandlerID, uint64 messageID, const char* returnCode);
unsigned int (*requestMessageGet)(uint64 serverConnectionHandlerID, uint64 messageID, const char* returnCode);
unsigned int (*requestMessageList)(uint64 serverConnectionHandlerID, const char* returnCode);
unsigned int (*requestMessageUpdateFlag)(uint64 serverConnectionHandlerID, uint64 messageID, int flag, const char* returnCode);
/* Interacting with the server - confirming passwords */
unsigned int (*verifyServerPassword)(uint64 serverConnectionHandlerID, const char* serverPassword, const char* returnCode);
unsigned int (*verifyChannelPassword)(uint64 serverConnectionHandlerID, uint64 channelID, const char* channelPassword, const char* returnCode);
/* Interacting with the server - banning */
unsigned int (*banclient)(uint64 serverConnectionHandlerID, anyID clientID, uint64 timeInSeconds, const char* banReason, const char* returnCode);
unsigned int (*banadd)(uint64 serverConnectionHandlerID, const char* ipRegExp, const char* nameRegexp, const char* uniqueIdentity, const char* mytsID, uint64 timeInSeconds, const char* banReason, const char* returnCode);
unsigned int (*banclientdbid)(uint64 serverConnectionHandlerID, uint64 clientDBID, uint64 timeInSeconds, const char* banReason, const char* returnCode);
unsigned int (*bandel)(uint64 serverConnectionHandlerID, uint64 banID, const char* returnCode);
unsigned int (*bandelall)(uint64 serverConnectionHandlerID, const char* returnCode);
unsigned int (*requestBanList)(uint64 serverConnectionHandlerID, uint64 start, unsigned int duration, const char* returnCode);
/* Interacting with the server - complain */
unsigned int (*requestComplainAdd)(uint64 serverConnectionHandlerID, uint64 targetClientDatabaseID, const char* complainReason, const char* returnCode);
unsigned int (*requestComplainDel)(uint64 serverConnectionHandlerID, uint64 targetClientDatabaseID, uint64 fromClientDatabaseID, const char* returnCode);
unsigned int (*requestComplainDelAll)(uint64 serverConnectionHandlerID, uint64 targetClientDatabaseID, const char* returnCode);
unsigned int (*requestComplainList)(uint64 serverConnectionHandlerID, uint64 targetClientDatabaseID, const char* returnCode);
/* Permissions */
unsigned int (*requestServerGroupList)(uint64 serverConnectionHandlerID, const char* returnCode);
unsigned int (*requestServerGroupAdd)(uint64 serverConnectionHandlerID, const char* groupName, int groupType, const char* returnCode);
unsigned int (*requestServerGroupDel)(uint64 serverConnectionHandlerID, uint64 serverGroupID, int force, const char* returnCode);
unsigned int (*requestServerGroupAddClient)(uint64 serverConnectionHandlerID, uint64 serverGroupID, uint64 clientDatabaseID, const char* returnCode);
unsigned int (*requestServerGroupDelClient)(uint64 serverConnectionHandlerID, uint64 serverGroupID, uint64 clientDatabaseID, const char* returnCode);
unsigned int (*requestServerGroupsByClientID)(uint64 serverConnectionHandlerID, uint64 clientDatabaseID, const char* returnCode);
unsigned int (*requestServerGroupAddPerm)(uint64 serverConnectionHandlerID, uint64 serverGroupID, int continueonerror, const unsigned int* permissionIDArray, const int* permissionValueArray, const int* permissionNegatedArray, const int* permissionSkipArray, int arraySize, const char* returnCode);
unsigned int (*requestServerGroupDelPerm)(uint64 serverConnectionHandlerID, uint64 serverGroupID, int continueOnError, const unsigned int* permissionIDArray, int arraySize, const char* returnCode);
unsigned int (*requestServerGroupPermList)(uint64 serverConnectionHandlerID, uint64 serverGroupID, const char* returnCode);
unsigned int (*requestServerGroupClientList)(uint64 serverConnectionHandlerID, uint64 serverGroupID, int withNames, const char* returnCode);
unsigned int (*requestChannelGroupList)(uint64 serverConnectionHandlerID, const char* returnCode);
unsigned int (*requestChannelGroupAdd)(uint64 serverConnectionHandlerID, const char* groupName, int groupType, const char* returnCode);
unsigned int (*requestChannelGroupDel)(uint64 serverConnectionHandlerID, uint64 channelGroupID, int force, const char* returnCode);
unsigned int (*requestChannelGroupAddPerm)(uint64 serverConnectionHandlerID, uint64 channelGroupID, int continueonerror, const unsigned int* permissionIDArray, const int* permissionValueArray, int arraySize, const char* returnCode);
unsigned int (*requestChannelGroupDelPerm)(uint64 serverConnectionHandlerID, uint64 channelGroupID, int continueOnError, const unsigned int* permissionIDArray, int arraySize, const char* returnCode);
unsigned int (*requestChannelGroupPermList)(uint64 serverConnectionHandlerID, uint64 channelGroupID, const char* returnCode);
unsigned int (*requestSetClientChannelGroup)(uint64 serverConnectionHandlerID, const uint64* channelGroupIDArray, const uint64* channelIDArray, const uint64* clientDatabaseIDArray, int arraySize, const char* returnCode);
unsigned int (*requestChannelAddPerm)(uint64 serverConnectionHandlerID, uint64 channelID, const unsigned int* permissionIDArray, const int* permissionValueArray, int arraySize, const char* returnCode);
unsigned int (*requestChannelDelPerm)(uint64 serverConnectionHandlerID, uint64 channelID, const unsigned int* permissionIDArray, int arraySize, const char* returnCode);
unsigned int (*requestChannelPermList)(uint64 serverConnectionHandlerID, uint64 channelID, const char* returnCode);
unsigned int (*requestClientAddPerm)(uint64 serverConnectionHandlerID, uint64 clientDatabaseID, const unsigned int* permissionIDArray, const int* permissionValueArray, const int* permissionSkipArray, int arraySize, const char* returnCode);
unsigned int (*requestClientDelPerm)(uint64 serverConnectionHandlerID, uint64 clientDatabaseID, const unsigned int* permissionIDArray, int arraySize, const char* returnCode);
unsigned int (*requestClientPermList)(uint64 serverConnectionHandlerID, uint64 clientDatabaseID, const char* returnCode);
unsigned int (*requestChannelClientAddPerm)(uint64 serverConnectionHandlerID, uint64 channelID, uint64 clientDatabaseID, const unsigned int* permissionIDArray, const int* permissionValueArray, int arraySize, const char* returnCode);
unsigned int (*requestChannelClientDelPerm)(uint64 serverConnectionHandlerID, uint64 channelID, uint64 clientDatabaseID, const unsigned int* permissionIDArray, int arraySize, const char* returnCode);
unsigned int (*requestChannelClientPermList)(uint64 serverConnectionHandlerID, uint64 channelID, uint64 clientDatabaseID, const char* returnCode);
unsigned int (*privilegeKeyUse)(uint64 serverConnectionHandler, const char* tokenKey, const char* returnCode);
unsigned int (*requestPermissionList)(uint64 serverConnectionHandler, const char* returnCode);
unsigned int (*requestPermissionOverview)(uint64 serverConnectionHandler, uint64 clientDBID, uint64 channelID, const char* returnCode);
/* Helper Functions */
unsigned int (*clientPropertyStringToFlag)(const char* clientPropertyString, size_t* resultFlag);
unsigned int (*channelPropertyStringToFlag)(const char* channelPropertyString, size_t* resultFlag);
unsigned int (*serverPropertyStringToFlag)(const char* serverPropertyString, size_t* resultFlag);
/* Client functions */
void (*getAppPath)(char* path, size_t maxLen);
void (*getResourcesPath)(char* path, size_t maxLen);
void (*getConfigPath)(char* path, size_t maxLen);
void (*getPluginPath)(char* path, size_t maxLen, const char* pluginID);
uint64 (*getCurrentServerConnectionHandlerID)();
void (*printMessage)(uint64 serverConnectionHandlerID, const char* message, enum PluginMessageTarget messageTarget);
void (*printMessageToCurrentTab)(const char* message);
void (*urlsToBB)(const char* text, char* result, size_t maxLen);
void (*sendPluginCommand)(uint64 serverConnectionHandlerID, const char* pluginID, const char* command, int targetMode, const anyID* targetIDs, const char* returnCode);
void (*getDirectories)(const char* path, char* result, size_t maxLen);
unsigned int (*getServerConnectInfo)(uint64 scHandlerID, char* host, unsigned short* port, char* password, size_t maxLen);
unsigned int (*getChannelConnectInfo)(uint64 scHandlerID, uint64 channelID, char* path, char* password, size_t maxLen);
void (*createReturnCode)(const char* pluginID, char* returnCode, size_t maxLen);
unsigned int (*requestInfoUpdate)(uint64 scHandlerID, enum PluginItemType itemType, uint64 itemID);
uint64 (*getServerVersion)(uint64 scHandlerID);
unsigned int (*isWhispering)(uint64 scHandlerID, anyID clientID, int* result);
unsigned int (*isReceivingWhisper)(uint64 scHandlerID, anyID clientID, int* result);
unsigned int (*getAvatar)(uint64 scHandlerID, anyID clientID, char* result, size_t maxLen);
void (*setPluginMenuEnabled)(const char* pluginID, int menuID, int enabled);
void (*showHotkeySetup)();
void (*requestHotkeyInputDialog)(const char* pluginID, const char* keyword, int isDown, void* qParentWindow);
unsigned int (*getHotkeyFromKeyword)(const char* pluginID, const char** keywords, char** hotkeys, size_t arrayLen, size_t hotkeyBufSize);
unsigned int (*getClientDisplayName)(uint64 scHandlerID, anyID clientID, char* result, size_t maxLen);
unsigned int (*getBookmarkList)(struct PluginBookmarkList** list);
unsigned int (*getProfileList)(enum PluginGuiProfile profile, int* defaultProfileIdx, char*** result);
unsigned int (*guiConnect)(enum PluginConnectTab connectTab, const char* serverLabel, const char* serverAddress, const char* serverPassword, const char* nickname, const char* channel, const char* channelPassword, const char* captureProfile, const char* playbackProfile, const char* hotkeyProfile, const char* soundProfile, const char* userIdentity, const char* oneTimeKey, const char* phoneticName, uint64* scHandlerID);
unsigned int (*guiConnectBookmark)(enum PluginConnectTab connectTab, const char* bookmarkuuid, uint64* scHandlerID);
unsigned int (*createBookmark)(const char* bookmarkuuid, const char* serverLabel, const char* serverAddress, const char* serverPassword, const char* nickname, const char* channel, const char* channelPassword, const char* captureProfile, const char* playbackProfile, const char* hotkeyProfile, const char* soundProfile, const char* uniqueUserId, const char* oneTimeKey, const char* phoneticName);
unsigned int (*getPermissionIDByName)(uint64 serverConnectionHandlerID, const char* permissionName, unsigned int* result);
unsigned int (*getClientNeededPermission)(uint64 serverConnectionHandlerID, const char* permissionName, int* result);
void(*notifyKeyEvent)(const char *pluginID, const char *keyIdentifier, int up_down);
};
#ifdef __cplusplus
}
#endif
#endif