~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;

776

return session->checkUser(passwd, passwd_len, l_db);

843

777

}

844

778

845

779

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

934

868

uint32_t pointer_seed;

935

869

memcpy(&pointer_seed, &pointer, 4);

936

870

uint32_t random1= (seed + pointer_seed) % random_max;

937

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

871

uint32_t random2= (seed + global_thread_id + net.vio->sd) % random_max;

938

872

939

873

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

940

874

{

944

878

}

945

879

}

946

880

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

881

static ListenMySQLProtocol *listen_obj= NULL;

958

882

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

959

883

960

884

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

961

{

962

context.add(new MysqlProtocolStatus);

963

885

{

964

886

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

965

887

time_t seed_time= time(NULL);

966

888

random_seed1= seed_time % random_max;

967

889

random_seed2= (seed_time / 2) % random_max;

968

890

969

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

970

971

891

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

972

892

context.add(mysql_password);

973

893

974

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

894

listen_obj= new ListenMySQLProtocol("mysql_protocol", true);

975

895

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}

896

897

return 0;

898

}

899

900

static DRIZZLE_SYSVAR_UINT(port, port, PLUGIN_VAR_RQCMDARG,

901

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

902

"protocol."),

903

NULL, NULL, 3306, 0, 65535, 0);

904

static DRIZZLE_SYSVAR_UINT(connect_timeout, connect_timeout,

905

PLUGIN_VAR_RQCMDARG, N_("Connect Timeout."),

906

NULL, NULL, 10, 1, 300, 0);

907

static DRIZZLE_SYSVAR_UINT(read_timeout, read_timeout, PLUGIN_VAR_RQCMDARG,

908

N_("Read Timeout."), NULL, NULL, 30, 1, 300, 0);

909

static DRIZZLE_SYSVAR_UINT(write_timeout, write_timeout, PLUGIN_VAR_RQCMDARG,

910

N_("Write Timeout."), NULL, NULL, 60, 1, 300, 0);

911

static DRIZZLE_SYSVAR_UINT(retry_count, retry_count, PLUGIN_VAR_RQCMDARG,

912

N_("Retry Count."), NULL, NULL, 10, 1, 100, 0);

913

static DRIZZLE_SYSVAR_UINT(buffer_length, buffer_length, PLUGIN_VAR_RQCMDARG,

914

N_("Buffer length."), NULL, NULL, 16384, 1024,

915

1024*1024, 0);

916

static DRIZZLE_SYSVAR_STR(bind_address, bind_address, PLUGIN_VAR_READONLY,

917

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

918

919

static drizzle_sys_var* sys_variables[]= {

920

DRIZZLE_SYSVAR(port),

921

DRIZZLE_SYSVAR(connect_timeout),

922

DRIZZLE_SYSVAR(read_timeout),

923

DRIZZLE_SYSVAR(write_timeout),

924

DRIZZLE_SYSVAR(retry_count),

925

DRIZZLE_SYSVAR(buffer_length),

926

DRIZZLE_SYSVAR(bind_address),

927

NULL

1063

928

};

1064

929

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

930

DRIZZLE_DECLARE_PLUGIN

1122

931

{

1123

932

DRIZZLE_VERSION_ID,

1124

"mysql-protocol",

933

"mysql_protocol",

1125

934

"0.1",

1126

935

"Eric Day",

1127

936

"MySQL Protocol Module",

1128

937

PLUGIN_LICENSE_GPL,

1129

drizzle_plugin::init, /* Plugin Init */

1130

NULL, /* system variables */

1131

drizzle_plugin::init_options /* config options */

938

init, /* Plugin Init */

939

sys_variables, /* system variables */

940

NULL /* config options */

1132

941

}

1133

942

DRIZZLE_DECLARE_PLUGIN_END;

Older »