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

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