aherman
/
proxysql
mirror of https://github.com/sysown/proxysql
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Removed a lot of deprecated code

Browse Source
pull/451/head
René Cannaò 11 years ago
parent 87845f7e2b
commit 95d2671a4e
4 changed files with 0 additions and 560 deletions
Show Stats Download Patch File Download Diff File

18
include/MySQL_Protocol.h
Unescape View File

@ -65,22 +65,11 @@ class MySQL_Protocol {
// - a pointer to void pointer, used to return the packet if not NULL
// - a pointer to unsigned int, used to return the size of the packet if not NULL
// for now, they all return true
// bool generate_pkt_OK(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len, uint8_t sequence_id, unsigned int affected_rows, unsigned int last_insert_id, uint16_t status, uint16_t warnings, char *msg);
// bool generate_pkt_ERR(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len, uint8_t sequence_id, uint16_t error_code, char *sql_state, char *sql_message);
// bool generate_pkt_EOF(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len, uint8_t sequence_id, uint16_t warnings, uint16_t status);
// bool generate_COM_QUIT(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len);
// bool generate_COM_INIT_DB(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len, char *schema);
// bool generate_COM_PING(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len);
// bool generate_COM_RESET_CONNECTION(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len);
bool generate_pkt_OK(bool send, void **ptr, unsigned int *len, uint8_t sequence_id, unsigned int affected_rows, uint64_t last_insert_id, uint16_t status, uint16_t warnings, char *msg);
bool generate_pkt_ERR(bool send, void **ptr, unsigned int *len, uint8_t sequence_id, uint16_t error_code, char *sql_state, char *sql_message);
bool generate_pkt_EOF(bool send, void **ptr, unsigned int *len, uint8_t sequence_id, uint16_t warnings, uint16_t status);
bool generate_COM_QUIT(bool send, void **ptr, unsigned int *len);
// bool generate_COM_INIT_DB(bool send, void **ptr, unsigned int *len, char *schema);
//bool generate_COM_PING(bool send, void **ptr, unsigned int *len);
bool generate_COM_QUERY(bool send, void **ptr, unsigned int *len, char *query);
bool generate_COM_RESET_CONNECTION(bool send, void **ptr, unsigned int *len);
bool generate_COM_CHANGE_USER(bool send, void **ptr, unsigned int *len);
bool generate_pkt_auth_switch_request(bool send, void **ptr, unsigned int *len);
bool process_pkt_auth_swich_response(unsigned char *pkt, unsigned int len);
@ -93,8 +82,6 @@ class MySQL_Protocol {
uint8_t generate_pkt_row2(PtrSizeArray *PSarrayOut, unsigned int *len, uint8_t sequence_id, int colnums, unsigned long *fieldslen, char **fieldstxt);
// bool generate_pkt_initial_handshake(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len);
bool generate_pkt_initial_handshake(bool send, void **ptr, unsigned int *len, uint32_t *thread_id);
// bool generate_pkt_handshake_response(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len);
bool generate_pkt_handshake_response(bool send, void **ptr, unsigned int *len);
// bool generate_statistics_response(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len);
bool generate_statistics_response(bool send, void **ptr, unsigned int *len);
@ -102,14 +89,9 @@ class MySQL_Protocol {
// - a data stream (optionally NULL for some)
// - pointer to the packet
// - size of the packet
// bool process_pkt_OK(MySQL_Data_Stream *myds, unsigned char *pkt, unsigned int len);
// bool process_pkt_handshake_response(MySQL_Data_Stream *myds, unsigned char *pkt, unsigned int len);
// bool process_pkt_initial_handshake(MySQL_Data_Stream *myds, unsigned char *pkt, unsigned int len);
// bool process_pkt_COM_QUERY(MySQL_Data_Stream *myds, unsigned char *pkt, unsigned int len);
bool process_pkt_OK(unsigned char *pkt, unsigned int len);
bool process_pkt_EOF(unsigned char *pkt, unsigned int len);
bool process_pkt_handshake_response(unsigned char *pkt, unsigned int len);
bool process_pkt_initial_handshake(unsigned char *pkt, unsigned int len);
bool process_pkt_COM_QUERY(unsigned char *pkt, unsigned int len);
bool process_pkt_COM_CHANGE_USER(unsigned char *pkt, unsigned int len);
};

12
include/MySQL_Session.h
Unescape View File

@ -40,15 +40,6 @@ class MySQL_Session
{
private:
std::stack<enum session_status> previous_status;
// bool handler___status_CHANGING_SCHEMA(PtrSize_t *);
bool handler___status_CHANGING_USER_SERVER(PtrSize_t *);
// bool handler___status_CHANGING_CHARSET(PtrSize_t *);
// void handler___status_WAITING_SERVER_DATA___STATE_QUERY_SENT(PtrSize_t *);
// void handler___status_WAITING_SERVER_DATA___STATE_PING_SENT(PtrSize_t *);
// void handler___status_WAITING_SERVER_DATA___STATE_ROW(PtrSize_t *);
// void handler___status_WAITING_SERVER_DATA___STATE_EOF1(PtrSize_t *);
//void handler___status_CONNECTING_SERVER___STATE_NOT_CONNECTED(PtrSize_t *);
//void handler___status_CONNECTING_SERVER___STATE_CLIENT_HANDSHAKE(PtrSize_t *, bool *);
void handler___status_CONNECTING_CLIENT___STATE_SERVER_HANDSHAKE(PtrSize_t *, bool *);
void handler___status_CHANGING_USER_CLIENT___STATE_CLIENT_HANDSHAKE(PtrSize_t *, bool *);
@ -69,9 +60,6 @@ class MySQL_Session
bool handler___status_WAITING_CLIENT_DATA___STATE_SLEEP___MYSQL_COM_QUERY_qpo(PtrSize_t *);
void handler___client_DSS_QUERY_SENT___server_DSS_NOT_INITIALIZED__get_connection();
void handler___client_DSS_QUERY_SENT___send_INIT_DB_to_backend();
void handler___client_DSS_QUERY_SENT___send_CHANGE_USER_to_backend();
void handler___client_DSS_QUERY_SENT___send_SET_NAMES_to_backend();
bool handler_special_queries(PtrSize_t *);
void RequestEnd(MySQL_Data_Stream *);

473
lib/MySQL_Protocol.cpp
Unescape View File

@ -82,15 +82,6 @@ void proxy_compute_sha1_hash_multi(uint8 *digest, const char *buf1, int len1, co
SHA1_Update(&sha1_context, buf1, len1);
SHA1_Update(&sha1_context, buf2, len2);
SHA1_Final(digest, &sha1_context);
/*
GChecksum *sha1_context=g_checksum_new(G_CHECKSUM_SHA1);
g_checksum_update(sha1_context, (const unsigned char *)buf1, len1);
g_checksum_update(sha1_context, (const unsigned char *)buf2, len2);
size_t s=SHA_DIGEST_LENGTH;
g_checksum_get_digest(sha1_context,digest,&s);
g_checksum_free(sha1_context);
*/
}
@ -101,14 +92,6 @@ void proxy_compute_sha1_hash(uint8 *digest, const char *buf, int len) {
SHA1_Init(&sha1_context);
SHA1_Update(&sha1_context, buf, len);
SHA1_Final(digest, &sha1_context);
/*
GChecksum *sha1_context=g_checksum_new(G_CHECKSUM_SHA1);
g_checksum_update(sha1_context, (const unsigned char *)buf, len);
size_t s=SHA_DIGEST_LENGTH;
g_checksum_get_digest(sha1_context,digest,&s);
g_checksum_free(sha1_context);
*/
}
void proxy_compute_two_stage_sha1_hash(const char *password, size_t pass_len, uint8 *hash_stage1, uint8 *hash_stage2) {
@ -627,98 +610,6 @@ static unsigned char protocol_version=10;
static uint16_t server_status=1;
//static char *mysql_server_version = (char *)"5.1.30";
/*
//void MySQL_Protocol::generate_server_handshake(MySQL_Data_Stream *myds) {
void MySQL_Protocol::generate_server_handshake() {
(*myds)->DSS=STATE_SERVER_HANDSHAKE;
//proxy_mysql_thread_t *thrLD=pthread_getspecific(tsd_key);
proxy_debug(PROXY_DEBUG_MYSQL_CONNECTION, 7, "Generating handshake pkt\n");
mysql_hdr myhdr;
myhdr.pkt_id=0;
//myhdr.pkt_length=sizeof(glovars.protocol_version)
myhdr.pkt_length=sizeof(protocol_version)
// + (strlen(glovars.mysql_server_version)+1)
+ (strlen(mysql_server_version)+1)
+ sizeof(uint32_t) // thread_id
+ 8 // scramble1
+ 1 // 0x00
//+ sizeof(glovars.server_capabilities)
//+ sizeof(glovars.server_language)
//+ sizeof(glovars.server_status)
+ sizeof(server_capabilities)
+ sizeof(server_language)
+ sizeof(server_status)
+ 3 // unknown stuff
+ 10 // filler
+ 12 // scramble2
+ 1 // 0x00
+ (strlen("mysql_native_password")+1);
unsigned int size=myhdr.pkt_length+sizeof(mysql_hdr);
//mypkt->data=g_slice_alloc0(mypkt->length);
//mypkt->data=l_alloc0(thrLD->sfp, mypkt->length);
unsigned char *ptr=(unsigned char *)l_alloc(size);
memcpy(ptr, &myhdr, sizeof(mysql_hdr));
//Copy4B(ptr, &myhdr);
int l;
l=sizeof(mysql_hdr);
//srand(pthread_self());
//uint32_t thread_id=rand()%100000;
//uint32_t thread_id=__sync_fetch_and_add(&glovars.thread_id,1);
uint32_t thread_id=pthread_self();
rand_struct rand_st;
//randominit(&rand_st,rand(),rand());
rand_st.max_value= 0x3FFFFFFFL;
rand_st.max_value_dbl=0x3FFFFFFFL;
rand_st.seed1=rand()%rand_st.max_value;
rand_st.seed2=rand()%rand_st.max_value;
memcpy(ptr+l, &protocol_version, sizeof(protocol_version)); l+=sizeof(protocol_version);
memcpy(ptr+l, mysql_server_version, strlen(mysql_server_version)); l+=strlen(mysql_server_version)+1;
memcpy(ptr+l, &thread_id, sizeof(uint32_t)); l+=sizeof(uint32_t);
#ifdef MARIADB_BASE_VERSION
proxy_create_random_string((*myds)->myconn->myconn.scramble_buff+0,8,(struct my_rnd_struct *)&rand_st);
#else
proxy_create_random_string((*myds)->myconn->myconn.scramble_buff+0,8,(struct rand_struct *)&rand_st);
#endif
int i;
for (i=0;i<8;i++) {
if ((*myds)->myconn->myconn.scramble_buff[i]==0) {
(*myds)->myconn->myconn.scramble_buff[i]='a';
}
}
memcpy(ptr+l, (*myds)->myconn->myconn.scramble_buff+0, 8); l+=8;
l+=1; //0x00
memcpy(ptr+l,&server_capabilities, sizeof(server_capabilities)); l+=sizeof(server_capabilities);
memcpy(ptr+l,&server_language, sizeof(server_language)); l+=sizeof(server_language);
memcpy(ptr+l,&server_status, sizeof(server_status)); l+=sizeof(server_status);
memcpy(ptr+l,"\x0f\x80\x15",3); l+=3;
l+=10; //filler
//create_random_string(mypkt->data+l,12,(struct my_rnd_struct *)&rand_st); l+=12;
#ifdef MARIADB_BASE_VERSION
proxy_create_random_string((*myds)->myconn->myconn.scramble_buff+8,12,(struct my_rnd_struct *)&rand_st);
#else
proxy_create_random_string((*myds)->myconn->myconn.scramble_buff+8,12,(struct rand_struct *)&rand_st);
#endif
//create_random_string(scramble_buf+8,12,&rand_st);
for (i=8;i<20;i++) {
if ((*myds)->myconn->myconn.scramble_buff[i]==0) {
(*myds)->myconn->myconn.scramble_buff[i]='a';
}
}
memcpy(ptr+l, (*myds)->myconn->myconn.scramble_buff+8, 12); l+=12;
l+=1; //0x00
memcpy(ptr+l,"mysql_native_password",strlen("mysql_native_password"));
(*myds)->PSarrayOUT->add((void *)ptr,size);
}
*/
//bool MySQL_Protocol::generate_statistics_response(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len) {
bool MySQL_Protocol::generate_statistics_response(bool send, void **ptr, unsigned int *len) {
// FIXME : this function generates a not useful string. It is a placeholder for now
@ -884,113 +775,6 @@ bool MySQL_Protocol::generate_pkt_OK(bool send, void **ptr, unsigned int *len, u
return true;
}
//bool MySQL_Protocol::generate_COM_QUIT(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len) {
bool MySQL_Protocol::generate_COM_QUIT(bool send, void **ptr, unsigned int *len) {
mysql_hdr myhdr;
myhdr.pkt_id=0;
myhdr.pkt_length=1;
unsigned int size=myhdr.pkt_length+sizeof(mysql_hdr);
unsigned char *_ptr=(unsigned char *)l_alloc(size);
memcpy(_ptr, &myhdr, sizeof(mysql_hdr));
//Copy4B(_ptr, &myhdr);
int l=sizeof(mysql_hdr);
_ptr[l]=0x01; l++;
if (send==true) {
(*myds)->PSarrayOUT->add((void *)_ptr,size);
}
if (len) { *len=size; }
if (ptr) { *ptr=(void *)_ptr; }
return true;
}
//bool MySQL_Protocol::generate_COM_INIT_DB(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len, char *schema) {
//bool MySQL_Protocol::generate_COM_INIT_DB(bool send, void **ptr, unsigned int *len, char *schema) {
// uint32_t schema_len=strlen(schema);
// mysql_hdr myhdr;
// myhdr.pkt_id=0;
// myhdr.pkt_length=1+schema_len;
// unsigned int size=myhdr.pkt_length+sizeof(mysql_hdr);
// unsigned char *_ptr=(unsigned char *)l_alloc(size);
// memcpy(_ptr, &myhdr, sizeof(mysql_hdr));
// //Copy4B(_ptr, &myhdr);
// int l=sizeof(mysql_hdr);
// _ptr[l]=0x02; l++;
// memcpy(_ptr+l, schema, schema_len);
//
// if (send==true) { (*myds)->PSarrayOUT->add((void *)_ptr,size); }
// if (len) { *len=size; }
// if (ptr) { *ptr=(void *)_ptr; }
//#ifdef DEBUG
// if (dump_pkt) { __dump_pkt(__func__,_ptr,size); }
//#endif
// return true;
//}
bool MySQL_Protocol::generate_COM_QUERY(bool send, void **ptr, unsigned int *len, char *query) {
uint32_t query_len=strlen(query);
mysql_hdr myhdr;
myhdr.pkt_id=0;
myhdr.pkt_length=1+query_len;
unsigned int size=myhdr.pkt_length+sizeof(mysql_hdr);
unsigned char *_ptr=(unsigned char *)l_alloc(size);
memcpy(_ptr, &myhdr, sizeof(mysql_hdr));
//Copy4B(_ptr, &myhdr);
int l=sizeof(mysql_hdr);
_ptr[l]=0x03; l++;
memcpy(_ptr+l, query, query_len);
if (send==true) { (*myds)->PSarrayOUT->add((void *)_ptr,size); }
if (len) { *len=size; }
if (ptr) { *ptr=(void *)_ptr; }
#ifdef DEBUG
if (dump_pkt) { __dump_pkt(__func__,_ptr,size); }
#endif
return true;
}
//bool MySQL_Protocol::generate_COM_PING(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len) {
//bool MySQL_Protocol::generate_COM_PING(bool send, void **ptr, unsigned int *len) {
// mysql_hdr myhdr;
// myhdr.pkt_id=0;
// myhdr.pkt_length=1;
// unsigned int size=myhdr.pkt_length+sizeof(mysql_hdr);
// unsigned char *_ptr=(unsigned char *)l_alloc(size);
// memcpy(_ptr, &myhdr, sizeof(mysql_hdr));
// //Copy4B(_ptr, &myhdr);
// int l=sizeof(mysql_hdr);
// _ptr[l]=0x0e; l++;
//
// if (send==true) { (*myds)->PSarrayOUT->add((void *)_ptr,size); }
// if (len) { *len=size; }
// if (ptr) { *ptr=(void *)_ptr; }
//#ifdef DEBUG
// if (dump_pkt) { __dump_pkt(__func__,_ptr,size); }
//#endif
// return true;
//}
//bool MySQL_Protocol::generate_COM_RESET_CONNECTION(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len) {
bool MySQL_Protocol::generate_COM_RESET_CONNECTION(bool send, void **ptr, unsigned int *len) {
mysql_hdr myhdr;
myhdr.pkt_id=0;
myhdr.pkt_length=1;
unsigned int size=myhdr.pkt_length+sizeof(mysql_hdr);
unsigned char *_ptr=(unsigned char *)l_alloc(size);
memcpy(_ptr, &myhdr, sizeof(mysql_hdr));
//Copy4B(_ptr, &myhdr);
int l=sizeof(mysql_hdr);
_ptr[l]=0x1f; l++;
if (send==true) { (*myds)->PSarrayOUT->add((void *)_ptr,size); }
if (len) { *len=size; }
if (ptr) { *ptr=(void *)_ptr; }
#ifdef DEBUG
if (dump_pkt) { __dump_pkt(__func__,_ptr,size); }
#endif
return true;
}
//bool MySQL_Protocol::generate_pkt_column_count(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len, uint8_t sequence_id, uint64_t count) {
bool MySQL_Protocol::generate_pkt_column_count(bool send, void **ptr, unsigned int *len, uint8_t sequence_id, uint64_t count) {
@ -1206,147 +990,6 @@ uint8_t MySQL_Protocol::generate_pkt_row2(PtrSizeArray *PSarrayOut, unsigned int
return pkt_sid;
}
//bool MySQL_Protocol::generate_pkt_handshake_response(MySQL_Data_Stream *myds, bool send, void **ptr, unsigned int *len) {
bool MySQL_Protocol::generate_pkt_handshake_response(bool send, void **ptr, unsigned int *len) {
proxy_debug(PROXY_DEBUG_MYSQL_CONNECTION, 7, "Generating response handshake pkt\n");
mysql_hdr myhdr;
myhdr.pkt_id=1;
uint32_t capabilities = CLIENT_LONG_PASSWORD | CLIENT_FOUND_ROWS | CLIENT_LONG_FLAG | CLIENT_CONNECT_WITH_DB | CLIENT_PROTOCOL_41 | CLIENT_TRANSACTIONS | CLIENT_SECURE_CONNECTION | CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS | CLIENT_PS_MULTI_RESULTS ;
// enable compression
assert(sess);
assert(sess->mybe);
assert(sess->mybe->server_myds);
MySQL_Connection *myconn=sess->mybe->server_myds->myconn;
assert(myconn);
if (myconn->options.compression_min_length) {
if (myconn->options.server_capabilities & CLIENT_COMPRESS) {
capabilities|=CLIENT_COMPRESS;
}
}
uint32_t max_allowed_packet=1*1024*1024;
assert(sess);
assert(sess->client_myds);
assert(sess->client_myds->myconn);
uint8_t charset=sess->client_myds->myconn->options.charset;
uint8_t _tmp;
/*
pkt += sizeof(mysql_hdr);
capabilities = CPY4(pkt);
pkt += sizeof(uint32_t);
max_pkt = CPY4(pkt);
pkt += sizeof(uint32_t);
charset = *(uint8_t *)pkt;
pkt += 24;
user = pkt;
pkt += strlen((char *)user) + 1;
pass_len = (capabilities & CLIENT_SECURE_CONNECTION ? *pkt++ : strlen((char *)pkt));
memcpy(pass, pkt, pass_len);
pass[pass_len] = 0;
pkt += pass_len;
db = (capabilities & CLIENT_CONNECT_WITH_DB ? pkt : 0);
*/
myhdr.pkt_length= 0
+ sizeof(uint32_t) // capabilities
+ sizeof(uint32_t) // max_allowed_packet
+ sizeof(uint8_t) // charset
+ 23 // padding
+ strlen(userinfo->username)+1 // user
+ ( strlen(userinfo->password) ? 21 : 1 )
+ strlen(userinfo->schemaname) + 1
+ strlen((char *)"mysql_native_password") + 1;
//MYSQL &myc=(*myds)->myconn->myconn;
unsigned int size=myhdr.pkt_length+sizeof(mysql_hdr);
unsigned char *_ptr=(unsigned char *)l_alloc(size);
memcpy(_ptr, &myhdr, sizeof(mysql_hdr));
//Copy4B(_ptr, &myhdr);
int l=sizeof(mysql_hdr);
memcpy(_ptr+l,&capabilities,sizeof(uint32_t)); l+=sizeof(uint32_t);
memcpy(_ptr+l,&max_allowed_packet,sizeof(uint32_t)); l+=sizeof(uint32_t);
_ptr[l]=charset; l++;
memset(_ptr+l,0,23); l+=23;
_tmp=strlen(userinfo->username);
//_ptr[l]=_tmp; l++;
if (_tmp) {
memcpy(_ptr+l,userinfo->username,_tmp); l+=_tmp;
}
_ptr[l++]=0;
if (strlen(userinfo->password)) {
_ptr[l++]=20;
char reply[SHA_DIGEST_LENGTH+1];
reply[SHA_DIGEST_LENGTH]='\0';
proxy_scramble(reply, (*myds)->myconn->scramble_buff, userinfo->password);
memcpy(_ptr+l,reply,20); l+=20;
} else {
_ptr[l++]=0;
}
_tmp=strlen(userinfo->schemaname);
memcpy(_ptr+l,userinfo->schemaname,_tmp+1);
l+=_tmp+1;
memcpy(_ptr+l,(char *)"mysql_native_password",strlen((char *)"mysql_native_password")+1);
if (send==true) { (*myds)->PSarrayOUT->add((void *)_ptr,size); }
if (len) { *len=size; }
if (ptr) { *ptr=(void *)_ptr; }
#ifdef DEBUG
if (dump_pkt) { __dump_pkt(__func__,_ptr,size); }
#endif
return true;
}
bool MySQL_Protocol::generate_COM_CHANGE_USER(bool send, void **ptr, unsigned int *len) {
proxy_debug(PROXY_DEBUG_MYSQL_CONNECTION, 7, "Generating response handshake pkt\n");
mysql_hdr myhdr;
myhdr.pkt_id=0;
uint8_t _tmp;
myhdr.pkt_length= 1 // COM_CHANGE_USER
+ strlen(userinfo->username)+1 // user
+ ( strlen(userinfo->password) ? 21 : 1 )
+ strlen(userinfo->schemaname) + 1;
unsigned int size=myhdr.pkt_length+sizeof(mysql_hdr);
unsigned char *_ptr=(unsigned char *)l_alloc(size);
memcpy(_ptr, &myhdr, sizeof(mysql_hdr));
int l=sizeof(mysql_hdr);
_ptr[l++]=0x11; // COM_CHANGE_USER
_tmp=strlen(userinfo->username);
if (_tmp) {
memcpy(_ptr+l,userinfo->username,_tmp); l+=_tmp;
}
_ptr[l++]=0;
if (strlen(userinfo->password)) {
_ptr[l++]=20;
char reply[SHA_DIGEST_LENGTH+1];
reply[SHA_DIGEST_LENGTH]='\0';
proxy_scramble(reply, (*myds)->myconn->scramble_buff, userinfo->password);
memcpy(_ptr+l,reply,20); l+=20;
} else {
_ptr[l++]=0;
}
_tmp=strlen(userinfo->schemaname);
memcpy(_ptr+l,userinfo->schemaname,_tmp+1);
if (send==true) { (*myds)->PSarrayOUT->add((void *)_ptr,size); }
if (len) { *len=size; }
if (ptr) { *ptr=(void *)_ptr; }
#ifdef DEBUG
if (dump_pkt) { __dump_pkt(__func__,_ptr,size); }
#endif
return true;
}
bool MySQL_Protocol::generate_pkt_auth_switch_request(bool send, void **ptr, unsigned int *len) {
proxy_debug(PROXY_DEBUG_MYSQL_CONNECTION, 7, "Generating auth switch request pkt\n");
mysql_hdr myhdr;
@ -1560,82 +1203,6 @@ bool MySQL_Protocol::process_pkt_COM_QUERY(unsigned char *pkt, unsigned int len)
return ret;
}
//bool MySQL_Protocol::process_pkt_initial_handshake(MySQL_Data_Stream *myds, unsigned char *pkt, unsigned int len) {
bool MySQL_Protocol::process_pkt_initial_handshake(unsigned char *pkt, unsigned int len) {
//return PKT_PARSED;
bool ret=false;
mysql_hdr hdr;
memcpy(&hdr,pkt,sizeof(mysql_hdr));
//Copy4B(&hdr,pkt);
pkt += sizeof(mysql_hdr);
//MYSQL &myc=(*myds)->myconn->myconn;
if (*pkt != 0x0A || len < 33) {
goto exit_process_pkt_initial_handshake;
}
uint8_t protocol;
uint16_t capabilities_lower;
uint16_t capabilities_upper;
uint32_t capabilities;
uint8_t charset;
//uint16_t status;
uint32_t thread_id;
unsigned char * version;
unsigned char * salt1;
unsigned char * salt2;
protocol = *(uint8_t *)pkt;
pkt += sizeof(uint8_t);
version = pkt;
pkt += strlen((char *)version) + 1;
thread_id = CPY4(pkt);
pkt += sizeof(uint32_t);
salt1 = pkt;
pkt += strlen((char *)salt1) + 1;
capabilities_lower = CPY2(pkt);
pkt += sizeof(uint16_t);
charset = *(uint8_t *)pkt;
pkt += sizeof(uint8_t);
prot_status = CPY2(pkt);
pkt += sizeof(uint16_t);
capabilities_upper = CPY2(pkt);
pkt += sizeof(uint16_t);
pkt += 11;
salt2 = pkt;
// FIXME: the next two lines are here just to prevent this: warning: variable ‘salt2’ set but not used [-Wunused-but-set-variable]
// salt2 needs to be handled
salt2++;
salt2 = pkt;
capabilities=capabilities_upper << 16;
capabilities+=capabilities_lower;
proxy_debug(PROXY_DEBUG_MYSQL_PROTOCOL,1,"Handshake <proto:%u ver:\"%s\" thd:%d cap:%d char:%d status:%d>\n", protocol, version, thread_id, capabilities, charset, prot_status);
// if(op.verbose) unmask_caps(caps);
(*myds)->myconn->options.server_capabilities=capabilities;
//myc.charset=(const charset_info_st *)l_alloc(sizeof(struct charset_info_st));
//myc.charset=(const charset_info_st *)malloc(sizeof(struct charset_info_st));
//const_cast<charset_info_st *>(myc.charset)->nr=charset;
//myc.thread_id=thread_id;
//myc.server_version=l_strdup((const char *)version);
(*myds)->myconn->options.server_version=strdup((const char *)version);
(*myds)->myconn->options.protocol_version=protocol;
(*myds)->myconn->options.charset=charset;
memcpy((*myds)->myconn->scramble_buff,(const char *)salt1,strlen((char *)salt1));
memcpy((*myds)->myconn->scramble_buff+strlen((char *)salt1),(const char *)salt2,strlen((char *)salt2));
ret=true;
exit_process_pkt_initial_handshake:
return ret;
}
bool MySQL_Protocol::process_pkt_auth_swich_response(unsigned char *pkt, unsigned int len) {
bool ret=false;
@ -1740,28 +1307,6 @@ bool MySQL_Protocol::process_pkt_COM_CHANGE_USER(unsigned char *pkt, unsigned in
//if (password) free(password);
if (password) l_free_string(password);
/*
//cur+=1;
// g_free(sess->mysql_username);
free(userinfo->username);
//unsigned char *_ptr=pkt+cur;
user=pkt+cur;
//sess->mysql_username=g_strdup(ptr);
cur+=strlen((const char *)user);
cur+=2;
//memcpy(sess->scramble_buf,mypkt->data+cur,20);
memcpy((*myds)->myconn->scramble_buff, pkt+cur, 20);
cur+=20;
//g_free(sess->mysql_schema_cur);
//ptr=mypkt->data+cur;
db=pkt+cur;
//sess->mysql_schema_cur=g_strdup(ptr);
userinfo->username=strdup((const char *)user);
// userinfo->password=strdup((const char *)password);
if (strlen((char *)db)) userinfo->set_schemaname((char *)db,strlen((char *)db)); // FIXME: buggy
proxy_debug(PROXY_DEBUG_MYSQL_CONNECTION, 5, "CHANGE USER: Username %s , schema %s\n" , userinfo->username, userinfo->schemaname);
*/
// ret=true;
return ret;
}
@ -1862,21 +1407,6 @@ bool MySQL_Protocol::process_pkt_handshake_response(unsigned char *pkt, unsigned
if (use_ssl) return true;
if (ret==true) {
//MYSQL &myc=(*myds)->myconn->myconn;
//myc.user=strdup((const char *)user);
//if (password) myc.passwd=strdup(password);
//if (db) myc.db=strdup((const char *)db);
/*
myc.user=l_strdup((const char *)user);
if (password) myc.passwd=l_strdup(password);
if (db) myc.db=l_strdup((const char *)db);
*/
//myc.server_capabilities=capabilities;
//myc.charset=(const charset_info_st *)malloc(sizeof(struct charset_info_st));
// myc.charset=(const charset_info_st *)l_alloc(sizeof(struct charset_info_st));
//onst_cast<charset_info_st *>(myc.charset)->nr=charset;
//myds->myconn->myconn
(*myds)->myconn->options.max_allowed_pkt=max_pkt;
(*myds)->DSS=STATE_CLIENT_HANDSHAKE;
@ -1896,9 +1426,6 @@ bool MySQL_Protocol::process_pkt_handshake_response(unsigned char *pkt, unsigned
return ret;
}
//uint16_t get_status(unsigned char *pkt, unsigned int len) {
//}
MySQL_ResultSet::MySQL_ResultSet(MySQL_Protocol *_myprot, MYSQL_RES *_res, MYSQL *_my) {
transfer_started=false;

57
lib/MySQL_Session.cpp
Unescape View File

@ -1333,36 +1333,6 @@ __exit_DSS__STATE_NOT_INITIALIZED:
}
bool MySQL_Session::handler___status_CHANGING_USER_SERVER(PtrSize_t *pkt) {
proxy_debug(PROXY_DEBUG_MYSQL_CONNECTION, 5, "Statuses: CHANGING_USER_SERVER - UNKNWON\n");
if (mybe->server_myds->myprot.process_pkt_OK((unsigned char *)pkt->ptr,pkt->size)==true) {
l_free(pkt->size,pkt->ptr);
mybe->server_myds->DSS=STATE_READY;
//mybe->myconn=server_myds->myconn;
status=WAITING_SERVER_DATA;
unsigned int k;
PtrSize_t pkt2;
for (k=0; k<mybe->server_myds->PSarrayOUTpending->len;) {
mybe->server_myds->PSarrayOUTpending->remove_index(0,&pkt2);
mybe->server_myds->PSarrayOUT->add(pkt2.ptr, pkt2.size);
mybe->server_myds->DSS=STATE_QUERY_SENT_DS;
}
// set prepared statement processing
mybe->server_myds->myconn->processing_prepared_statement_prepare=client_myds->myconn->processing_prepared_statement_prepare;
return true;
} else {
l_free(pkt->size,pkt->ptr);
set_unhealthy();
//mybe->myconn=server_myds->myconn;
// if we reach here, server_myds->DSS should be STATE_QUERY_SENT , therefore the connection to the backend should be dropped anyway
// although we enforce this here
mybe->server_myds->myconn->reusable=false;
return false;
}
return false;
}
void MySQL_Session::handler___status_WAITING_SERVER_DATA___STATE_READING_COM_STMT_PREPARE_RESPONSE(PtrSize_t *pkt) {
unsigned char c;
c=*((unsigned char *)pkt->ptr+sizeof(mysql_hdr));
@ -1758,33 +1728,6 @@ void MySQL_Session::handler___client_DSS_QUERY_SENT___server_DSS_NOT_INITIALIZED
}
}
void MySQL_Session::handler___client_DSS_QUERY_SENT___send_INIT_DB_to_backend() {
mybe->server_myds->move_from_OUT_to_OUTpending();
mybe->server_myds->myconn->userinfo->set_schemaname(client_myds->myconn->userinfo->schemaname,strlen(client_myds->myconn->userinfo->schemaname));
status=CHANGING_SCHEMA;
mybe->server_myds->DSS=STATE_MARIADB_INITDB;
mybe->server_myds->myconn->async_state_machine=ASYNC_INITDB_START;
mybe->server_myds->myconn->handler(0);
}
void MySQL_Session::handler___client_DSS_QUERY_SENT___send_SET_NAMES_to_backend() {
mybe->server_myds->move_from_OUT_to_OUTpending();
mybe->server_myds->myconn->set_charset(client_myds->myconn->options.charset);
mybe->server_myds->DSS=STATE_MARIADB_SET_NAMES;
mybe->server_myds->myconn->async_state_machine=ASYNC_SET_NAMES_START;
mybe->server_myds->myconn->handler(0);
status=CHANGING_CHARSET;
}
void MySQL_Session::handler___client_DSS_QUERY_SENT___send_CHANGE_USER_to_backend() {
mybe->server_myds->move_from_OUT_to_OUTpending();
mybe->server_myds->myconn->userinfo->set(client_myds->myconn->userinfo);
mybe->server_myds->myprot.generate_COM_CHANGE_USER(true,NULL,NULL);
mybe->server_myds->DSS=STATE_QUERY_SENT_DS;
status=CHANGING_USER_SERVER;
}
void MySQL_Session::MySQL_Result_to_MySQL_wire(MYSQL *mysql, MySQL_ResultSet *MyRS) {
if (MyRS) {
assert(MyRS->result);

Write Preview
Loading…
Cancel
Save