← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/mysql_protocol/mysql_protocol.cc

  • Committer: Mark Atwood
  • Date: 2011-08-12 04:08:33 UTC
  • mfrom: (2385.2.17 refactor5)
  • Revision ID: me@mark.atwood.name-20110812040833-u6j85nc6ahuc0dtz
merge lp:~olafvdspek/drizzle/refactor5

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/mysql_protocol/mysql_protocol.cc
70
70
  counters.push_back(new drizzled::plugin::ListenCounter(new std::string("failed_connections"), &getCounters().failedConnections));
71
71
}
72
72
 
73
 
const std::string ListenMySQLProtocol::getHost(void) const
 
73
const std::string ListenMySQLProtocol::getHost() const
74
74
{
75
75
  return _hostname;
76
76
}
77
77
 
78
 
in_port_t ListenMySQLProtocol::getPort(void) const
 
78
in_port_t ListenMySQLProtocol::getPort() const
79
79
{
80
80
  return port.get();
81
81
}
219
219
  if (packet_length == 0)                       /* safety */
220
220
  {
221
221
    /* Initialize with COM_SLEEP packet */
222
 
    (*l_packet)[0]= (unsigned char) COM_SLEEP;
 
222
    (*l_packet)[0]= COM_SLEEP;
223
223
    packet_length= 1;
224
224
  }
225
225
  else
258
258
#ifdef NEVER
259
259
  /* See comment above. */
260
260
  /* Restore read timeout value */
261
 
  drizzleclient_net_set_read_timeout(&net,
262
 
                                     session->variables.net_read_timeout);
 
261
  drizzleclient_net_set_read_timeout(&net, session->variables.net_read_timeout);
263
262
#endif
264
263
 
265
264
  return true;
369
368
 
370
369
void ClientMySQLProtocol::sendError(drizzled::error_t sql_errno, const char *err)
371
370
{
372
 
  uint32_t length;
373
 
  /*
374
 
    buff[]: sql_errno:2 + ('#':1 + SQLSTATE_LENGTH:5) + DRIZZLE_ERRMSG_SIZE:512
375
 
  */
376
 
  unsigned char buff[2+1+SQLSTATE_LENGTH+DRIZZLE_ERRMSG_SIZE], *pos;
 
371
  // buff[]: sql_errno:2 + ('#':1 + SQLSTATE_LENGTH:5) + DRIZZLE_ERRMSG_SIZE:512
 
372
  unsigned char buff[2 + 1 + SQLSTATE_LENGTH + DRIZZLE_ERRMSG_SIZE];
377
373
 
378
374
  assert(sql_errno != EE_OK);
379
375
  assert(err && err[0]);
401
397
  }
402
398
 
403
399
  int2store(buff, static_cast<uint16_t>(sql_errno));
404
 
  pos= buff+2;
405
400
 
406
401
  /* The first # is to make the client backward compatible */
407
402
  buff[2]= '#';
408
 
  pos= (unsigned char*) strcpy((char*) buff+3, error::convert_to_sqlstate(sql_errno));
 
403
  unsigned char* pos= (unsigned char*) strcpy((char*) buff+3, error::convert_to_sqlstate(sql_errno));
409
404
  pos+= strlen(error::convert_to_sqlstate(sql_errno));
410
405
 
411
406
  char *tmp= strncpy((char*)pos, err, DRIZZLE_ERRMSG_SIZE-1);
412
407
  tmp+= strlen((char*)pos);
413
408
  tmp[0]= '\0';
414
 
  length= (uint32_t)(tmp-(char*)buff);
415
 
  err= (char*) buff;
416
 
  net.write_command((unsigned char) 255, (unsigned char*) "", 0, (unsigned char*) err, length);
 
409
  net.write_command(255, data_ref().clear(), data_ref(buff, tmp));
417
410
  net.flush();
418
411
  session->main_da().can_overwrite_status= false;
419
412
}
585
578
void ClientMySQLProtocol::store(int32_t from)
586
579
{
587
580
  char buff[12];
588
 
  netStoreData(buff, (internal::int10_to_str(from, buff, -10) - buff));
 
581
  netStoreData(buff, internal::int10_to_str(from, buff, -10) - buff);
589
582
}
590
583
 
591
584
void ClientMySQLProtocol::store(uint32_t from)
592
585
{
593
586
  char buff[11];
594
 
  netStoreData(buff, (size_t) (internal::int10_to_str(from, buff, 10) - buff));
 
587
  netStoreData(buff, internal::int10_to_str(from, buff, 10) - buff);
595
588
}
596
589
 
597
590
void ClientMySQLProtocol::store(int64_t from)
598
591
{
599
592
  char buff[22];
600
 
  netStoreData(buff, (size_t) (internal::int64_t10_to_str(from, buff, -10) - buff));
 
593
  netStoreData(buff, internal::int64_t10_to_str(from, buff, -10) - buff);
601
594
}
602
595
 
603
596
void ClientMySQLProtocol::store(uint64_t from)
604
597
{
605
598
  char buff[21];
606
 
  netStoreData(buff, (size_t) (internal::int64_t10_to_str(from, buff, 10) - buff));
 
599
  netStoreData(buff, internal::int64_t10_to_str(from, buff, 10) - buff);
607
600
}
608
601
 
609
602
void ClientMySQLProtocol::store(double from, uint32_t decimals, String *buffer)
690
683
    *end++= 0; /* an empty byte for some reason */
691
684
 
692
685
    /* At this point we write connection message and read reply */
693
 
    if (net.write_command(
694
 
            (unsigned char) PROTOCOL_VERSION
695
 
          , (unsigned char*) ""
696
 
          , 0
697
 
          , (unsigned char*) buff
698
 
          , (size_t) (end-buff)) 
699
 
        ||    (pkt_len= net.read()) == packet_error 
 
686
    if (net.write_command(PROTOCOL_VERSION, data_ref().clear(), data_ref(buff, end)) 
 
687
        || (pkt_len= net.read()) == packet_error 
700
688
        || pkt_len < MIN_HANDSHAKE_SIZE)
701
689
    {
702
690
      my_error(ER_HANDSHAKE_ERROR, MYF(0), user_identifier->address().c_str());
706
694
  packet.alloc(buffer_length.get());
707
695
 
708
696
  client_capabilities= uint2korr(net.read_pos);
709
 
  if (!(client_capabilities & CLIENT_PROTOCOL_MYSQL41))
 
697
  if (not (client_capabilities & CLIENT_PROTOCOL_MYSQL41))
710
698
  {
711
699
    my_error(ER_HANDSHAKE_ERROR, MYF(0), user_identifier->address().c_str());
712
700
    return false;
822
810
  write it to the network output buffer.
823
811
*/
824
812
 
825
 
void ClientMySQLProtocol::writeEOFPacket(uint32_t server_status,
826
 
                                         uint32_t total_warn_count)
 
813
void ClientMySQLProtocol::writeEOFPacket(uint32_t server_status, uint32_t total_warn_count)
827
814
{
828
815
  unsigned char buff[5];
829
816
  /*
859
846
 
860
847
unsigned char *ClientMySQLProtocol::storeLength(unsigned char *buffer, uint64_t length)
861
848
{
862
 
  if (length < (uint64_t) 251LL)
 
849
  if (length < 251)
863
850
  {
864
 
    *buffer=(unsigned char) length;
 
851
    *buffer= (unsigned char) length;
865
852
    return buffer+1;
866
853
  }
867
854
  /* 251 is reserved for NULL */
868
 
  if (length < (uint64_t) 65536LL)
 
855
  if (length < 65536)
869
856
  {
870
 
    *buffer++=252;
871
 
    int2store(buffer,(uint32_t) length);
 
857
    *buffer++= 252;
 
858
    int2store(buffer, (uint32_t) length);
872
859
    return buffer+2;
873
860
  }
874
 
  if (length < (uint64_t) 16777216LL)
 
861
  if (length < 16777216)
875
862
  {
876
863
    *buffer++=253;
877
 
    int3store(buffer,(uint32_t) length);
 
864
    int3store(buffer, (uint32_t) length);
878
865
    return buffer+3;
879
866
  }
880
867
  *buffer++=254;
881
 
  int8store(buffer,length);
 
868
  int8store(buffer, length);
882
869
  return buffer+8;
883
870
}
884
871