~drizzle-trunk/drizzle/development

if (std::find(mysql_admin_ip_addresses.begin(), mysql_admin_ip_addresses.end(), session->getSecurityContext().getIp()) != mysql_admin_ip_addresses.end())

840

return true;

841

else

842

return false;

843

}

844

845

bool ClientMySQLProtocol::netStoreData(const unsigned char *from, size_t length)

846

{

847

size_t packet_length= packet.length();

848

849

The +9 comes from that strings of length longer than 16M require

850

9 bytes to be stored (see storeLength).

851

852

if (packet_length+9+length > packet.alloced_length() &&

853

packet.realloc(packet_length+9+length))

854

return 1;

855

unsigned char *to= storeLength((unsigned char*) packet.ptr()+packet_length, length);

856

memcpy(to,from,length);

857

packet.length((size_t) (to+length-(unsigned char*) packet.ptr()));

858

return 0;

859

}

860

861

/**

862

Format EOF packet according to the current client and

863

write it to the network output buffer.

864

865

866

void ClientMySQLProtocol::writeEOFPacket(uint32_t server_status,

867

uint32_t total_warn_count)

868

{

869

unsigned char buff[5];

870

871

Don't send warn count during SP execution, as the warn_list

872

is cleared between substatements, and mysqltest gets confused

873

874

uint32_t tmp= min(total_warn_count, (uint32_t)65535);

875

buff[0]= DRIZZLE_PROTOCOL_NO_MORE_DATA;

876

int2store(buff+1, tmp);

877

878

The following test should never be true, but it's better to do it

879

because if 'is_fatal_error' is set the server is not going to execute

880

other queries (see the if test in dispatch_command / COM_QUERY)

881

882

if (session->is_fatal_error)

883

server_status&= ~SERVER_MORE_RESULTS_EXISTS;

884

int2store(buff + 3, server_status);

885

drizzleclient_net_write(&net, buff, 5);

886

}

887

888

889

Store an integer with simple packing into a output package

890

891

buffer Store the packed integer here

892

length integers to store

893

894

This is mostly used to store lengths of strings. We have to cast

895

the result for the LL() becasue of a bug in Forte CC compiler.

896

897

RETURN

898

Position in 'buffer' after the packed length

899

900

901

unsigned char *ClientMySQLProtocol::storeLength(unsigned char *buffer, uint64_t length)

902

{

903

if (length < (uint64_t) 251LL)

904

{

905

*buffer=(unsigned char) length;

906

return buffer+1;

907

}

908

/* 251 is reserved for NULL */

909

if (length < (uint64_t) 65536LL)

910

{

911

*buffer++=252;

912

int2store(buffer,(uint32_t) length);

913

return buffer+2;

914

}

915

if (length < (uint64_t) 16777216LL)

916

{

917

*buffer++=253;

918

int3store(buffer,(uint32_t) length);

919

return buffer+3;

920

}

921

*buffer++=254;

922

int8store(buffer,length);

923

return buffer+8;

924

}

925

926

void ClientMySQLProtocol::makeScramble(char *scramble)

927

{

928

/* This is the MySQL algorithm with minimal changes. */

929

random_seed1= (random_seed1 * 3 + random_seed2) % random_max;

930

random_seed2= (random_seed1 + random_seed2 + 33) % random_max;

931

uint32_t seed= static_cast<uint32_t>((static_cast<double>(random_seed1) / random_max_double) * 0xffffffff);

932

933

void *pointer= this;

934

uint32_t pointer_seed;

935

memcpy(&pointer_seed, &pointer, 4);

936

uint32_t random1= (seed + pointer_seed) % random_max;

937

uint32_t random2= (seed + session->variables.pseudo_thread_id + net.vio->get_fd()) % random_max;

938

939

for (char *end= scramble + SCRAMBLE_LENGTH; scramble != end; scramble++)

940

{

941

random1= (random1 * 3 + random2) % random_max;

942

random2= (random1 + random2 + 33) % random_max;

943

*scramble= static_cast<char>((static_cast<double>(random1) / random_max_double) * 94 + 33);

944

}

945

}

946

947

void ClientMySQLProtocol::mysql_compose_ip_addresses(vector<string> options)

948

{

949

for (vector<string>::iterator it= options.begin();

950

it != options.end();

951

++it)

952

{

953

tokenize(*it, mysql_admin_ip_addresses, ",", true);

954

}

955

}

956

957

static ListenMySQLProtocol *listen_obj= NULL;

958

plugin::Create_function<MySQLPassword> *mysql_password= NULL;

959

960

static int init(drizzled::module::Context &context)

961

{

962

context.add(new MysqlProtocolStatus);

963

964

/* Initialize random seeds for the MySQL algorithm with minimal changes. */

965

time_t seed_time= time(NULL);

966

random_seed1= seed_time % random_max;

967

random_seed2= (seed_time / 2) % random_max;

968

969

const module::option_map &vm= context.getOptions();

970

971

mysql_password= new plugin::Create_function<MySQLPassword>(MySQLPasswordName);

972

context.add(mysql_password);

973

974

listen_obj= new ListenMySQLProtocol("mysql_protocol", vm["bind-address"].as<std::string>(), true);

975

context.add(listen_obj);

976

context.registerVariable(new sys_var_constrained_value_readonly<in_port_t>("port", port));

977

context.registerVariable(new sys_var_constrained_value<uint32_t>("connect_timeout", connect_timeout));

978

context.registerVariable(new sys_var_constrained_value<uint32_t>("read_timeout", read_timeout));

979

context.registerVariable(new sys_var_constrained_value<uint32_t>("write_timeout", write_timeout));

980

context.registerVariable(new sys_var_constrained_value<uint32_t>("retry_count", retry_count));

981

context.registerVariable(new sys_var_constrained_value<uint32_t>("buffer_length", buffer_length));

982

context.registerVariable(new sys_var_const_string_val("bind_address",

983

vm["bind-address"].as<std::string>()));

984

985

context.registerVariable(new sys_var_uint32_t_ptr("max-connections", &ListenMySQLProtocol::mysql_counters->max_connections));

986

987

return 0;

988

}

989

990

static void init_options(drizzled::module::option_context &context)

991

{

992

context("port",

993

po::value<port_constraint>(&port)->default_value(3306),

994

N_("Port number to use for connection or 0 for default to with MySQL "

995

"protocol."));

996

context("connect-timeout",

997

po::value<timeout_constraint>(&connect_timeout)->default_value(10),

998

N_("Connect Timeout."));

999

context("read-timeout",

1000

po::value<timeout_constraint>(&read_timeout)->default_value(30),

1001

N_("Read Timeout."));

1002

context("write-timeout",

1003

po::value<timeout_constraint>(&write_timeout)->default_value(60),

1004

N_("Write Timeout."));

1005

context("retry-count",

1006

po::value<retry_constraint>(&retry_count)->default_value(10),

1007

N_("Retry Count."));

1008

context("buffer-length",

1009

po::value<buffer_constraint>(&buffer_length)->default_value(16384),

1010

N_("Buffer length."));

1011

context("bind-address",

1012

po::value<string>()->default_value(""),

1013

N_("Address to bind to."));

1014

context("max-connections",

1015

po::value<uint32_t>(&ListenMySQLProtocol::mysql_counters->max_connections)->default_value(1000),

1016

N_("Maximum simultaneous connections."));

1017

context("admin-ip-addresses",

1018

po::value<vector<string> >()->composing()->notifier(&ClientMySQLProtocol::mysql_compose_ip_addresses),

1019

N_("A restrictive IP address list for incoming admin connections."));

1020

}

1021

1022

static int mysql_protocol_connection_count_func(drizzle_show_var *var, char *buff)

1023

{

1024

var->type= SHOW_LONGLONG;

1025

var->value= buff;

1026

*((uint64_t *)buff)= ListenMySQLProtocol::mysql_counters->connectionCount;

1027

return 0;

1028

}

1029

1030

static int mysql_protocol_connected_count_func(drizzle_show_var *var, char *buff)

1031

{

1032

var->type= SHOW_LONGLONG;

1033

var->value= buff;

1034

*((uint64_t *)buff)= ListenMySQLProtocol::mysql_counters->connected;

1035

return 0;

1036

}

1037

1038

static int mysql_protocol_failed_count_func(drizzle_show_var *var, char *buff)

1039

{

1040

var->type= SHOW_LONGLONG;

1041

var->value= buff;

1042

*((uint64_t *)buff)= ListenMySQLProtocol::mysql_counters->failedConnections;

1043

return 0;

1044

}

1045

1046

static st_show_var_func_container mysql_protocol_connection_count=

1047

{ &mysql_protocol_connection_count_func };

1048

1049

static st_show_var_func_container mysql_protocol_connected_count=

1050

{ &mysql_protocol_connected_count_func };

1051

1052

static st_show_var_func_container mysql_protocol_failed_count=

1053

{ &mysql_protocol_failed_count_func };

1054

1055

static drizzle_show_var mysql_protocol_status_variables[]= {

1056

{"Connections",

1057

(char*) &mysql_protocol_connection_count, SHOW_FUNC},

1058

{"Connected",

1059

(char*) &mysql_protocol_connected_count, SHOW_FUNC},

1060

{"Failed_connections",

1061

(char*) &mysql_protocol_failed_count, SHOW_FUNC},

1062

{NULL, NULL, SHOW_LONGLONG}

1063

};

1064

1065

MysqlProtocolStatus::Generator::Generator(drizzled::Field **fields) :

1066

plugin::TableFunction::Generator(fields)

1067

{

1068

status_var_ptr= mysql_protocol_status_variables;

1069

}

1070

1071

bool MysqlProtocolStatus::Generator::populate()

1072

{

1073

MY_ALIGNED_BYTE_ARRAY(buff_data, SHOW_VAR_FUNC_BUFF_SIZE, int64_t);

1074

char * const buff= (char *) &buff_data;

1075

drizzle_show_var tmp;

1076

1077

if (status_var_ptr->name)

1078

{

1079

std::ostringstream oss;

1080

string return_value;

1081

const char *value;

1082

int type;

1083

1084

push(status_var_ptr->name);

1085

1086

if (status_var_ptr->type == SHOW_FUNC)

1087

{

1088

((drizzle_show_var_func)((st_show_var_func_container *)status_var_ptr->value)->func)(&tmp, buff);

1089

value= buff;

1090

type= tmp.type;

1091

}

1092

else

1093

{

1094

value= status_var_ptr->value;

1095

type= status_var_ptr->type;

1096

}

1097

1098

switch(type)

1099

{

1100

case SHOW_LONGLONG:

1101

oss << *(uint64_t*) value;

1102

return_value= oss.str();

1103

break;

1104

default:

1105

assert(0);

1106

}

1107

if (return_value.length())

1108

push(return_value);

1109

else

1110

push(" ");

1111

1112

status_var_ptr++;

1113

1114

return true;

1115

}

1116

return false;

1117

}

1118

1119

} /* namespace drizzle_plugin */

1120

1121

DRIZZLE_DECLARE_PLUGIN

1122

{

1123

DRIZZLE_VERSION_ID,

1124

"mysql-protocol",

1125

"0.1",

1126

"Eric Day",

1127

"MySQL Protocol Module",

1128

PLUGIN_LICENSE_GPL,

1129

drizzle_plugin::init, /* Plugin Init */

1130

NULL, /* system variables */

1131

drizzle_plugin::init_options /* config options */

1132

}

1133

DRIZZLE_DECLARE_PLUGIN_END;

Older »