← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/drizzle_protocol/oldlibdrizzle.cc

  • Committer: Brian Aker
  • Date: 2009-11-13 18:25:26 UTC
  • mfrom: (971.7.11 eday-dev)
  • Revision ID: brian@gaz-20091113182526-evaib6rmmndruddq
Merge Eric

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/drizzle_protocol/oldlibdrizzle.cc
35
35
 
36
36
#define PROTOCOL_VERSION 10
37
37
 
38
 
extern uint32_t drizzled_tcp_port;
39
 
 
40
38
static const unsigned int PACKET_BUFFER_EXTRA_ALLOC= 1024;
 
39
static uint32_t port;
41
40
static uint32_t connect_timeout;
42
41
static uint32_t read_timeout;
43
42
static uint32_t write_timeout;
45
44
static uint32_t buffer_length;
46
45
static char* bind_address;
47
46
 
48
 
const char* ListenOldLibdrizzle::getHost(void) const
 
47
const char* ListenDrizzleProtocol::getHost(void) const
49
48
{
50
49
  return bind_address;
51
50
}
52
51
 
53
 
in_port_t ListenOldLibdrizzle::getPort(void) const
 
52
in_port_t ListenDrizzleProtocol::getPort(void) const
54
53
{
55
 
  return (in_port_t) drizzled_tcp_port;
 
54
  struct servent *serv_ptr;
 
55
  char *env;
 
56
 
 
57
  if (port == 0)
 
58
  {
 
59
    port= DRIZZLE_TCP_PORT;
 
60
 
 
61
    if (DRIZZLE_TCP_PORT_DEFAULT == 0)
 
62
    {
 
63
      if ((serv_ptr= getservbyname("drizzle", "tcp")))
 
64
        port= ntohs((u_short) serv_ptr->s_port);
 
65
    }
 
66
 
 
67
    if ((env = getenv("DRIZZLE_TCP_PORT")))
 
68
      port= (uint32_t) atoi(env);
 
69
 
 
70
    assert(port != 0);
 
71
  }
 
72
 
 
73
  return (in_port_t) port;
56
74
}
57
75
 
58
 
plugin::Client *ListenOldLibdrizzle::getClient(int fd)
 
76
plugin::Client *ListenDrizzleProtocol::getClient(int fd)
59
77
{
60
78
  int new_fd;
61
79
  new_fd= acceptTcp(fd);
62
80
  if (new_fd == -1)
63
81
    return NULL;
64
82
 
65
 
  return new (nothrow) ClientOldLibdrizzle(new_fd);
 
83
  return new (nothrow) ClientDrizzleProtocol(new_fd, using_mysql41_protocol);
66
84
}
67
85
 
68
 
ClientOldLibdrizzle::ClientOldLibdrizzle(int fd)
 
86
ClientDrizzleProtocol::ClientDrizzleProtocol(int fd, bool using_mysql41_protocol_arg):
 
87
  using_mysql41_protocol(using_mysql41_protocol_arg)
69
88
{
70
89
  net.vio= 0;
71
90
 
80
99
  net.retry_count=retry_count;
81
100
}
82
101
 
83
 
ClientOldLibdrizzle::~ClientOldLibdrizzle()
 
102
ClientDrizzleProtocol::~ClientDrizzleProtocol()
84
103
{
85
104
  if (net.vio)
86
105
    drizzleclient_vio_close(net.vio);
87
106
}
88
107
 
89
 
int ClientOldLibdrizzle::getFileDescriptor(void)
 
108
int ClientDrizzleProtocol::getFileDescriptor(void)
90
109
{
91
110
  return drizzleclient_net_get_sd(&net);
92
111
}
93
112
 
94
 
bool ClientOldLibdrizzle::isConnected()
 
113
bool ClientDrizzleProtocol::isConnected()
95
114
{
96
115
  return net.vio != 0;
97
116
}
98
117
 
99
 
bool ClientOldLibdrizzle::isReading(void)
 
118
bool ClientDrizzleProtocol::isReading(void)
100
119
{
101
120
  return net.reading_or_writing == 1;
102
121
}
103
122
 
104
 
bool ClientOldLibdrizzle::isWriting(void)
 
123
bool ClientDrizzleProtocol::isWriting(void)
105
124
{
106
125
  return net.reading_or_writing == 2;
107
126
}
108
127
 
109
 
bool ClientOldLibdrizzle::flush()
 
128
bool ClientDrizzleProtocol::flush()
110
129
{
111
130
  if (net.vio == NULL)
112
131
    return false;
116
135
  return ret;
117
136
}
118
137
 
119
 
void ClientOldLibdrizzle::close(void)
 
138
void ClientDrizzleProtocol::close(void)
120
139
{
121
140
  if (net.vio)
122
141
  { 
125
144
  }
126
145
}
127
146
 
128
 
bool ClientOldLibdrizzle::authenticate()
 
147
bool ClientDrizzleProtocol::authenticate()
129
148
{
130
149
  bool connection_is_valid;
131
150
 
149
168
  return true;
150
169
}
151
170
 
152
 
bool ClientOldLibdrizzle::readCommand(char **l_packet, uint32_t *packet_length)
 
171
bool ClientDrizzleProtocol::readCommand(char **l_packet, uint32_t *packet_length)
153
172
{
154
173
  /*
155
174
    This thread will do a blocking read from the client which
203
222
    (*l_packet)[0]= (unsigned char) COM_SLEEP;
204
223
    *packet_length= 1;
205
224
  }
 
225
  else if (using_mysql41_protocol)
 
226
  {
 
227
    /* Map from MySQL commands to Drizzle commands. */
 
228
    switch ((int)(*l_packet)[0])
 
229
    {
 
230
    case 0: /* SLEEP */
 
231
    case 1: /* QUIT */
 
232
    case 2: /* INIT_DB */
 
233
    case 3: /* QUERY */
 
234
      break;
 
235
 
 
236
    case 8: /* SHUTDOWN */
 
237
      (*l_packet)[0]= (unsigned char) COM_SHUTDOWN;
 
238
      break;
 
239
 
 
240
    case 14: /* PING */
 
241
      (*l_packet)[0]= (unsigned char) COM_SHUTDOWN;
 
242
      break;
 
243
 
 
244
 
 
245
    default:
 
246
      /* Just drop connection for MySQL commands we don't support. */
 
247
      (*l_packet)[0]= (unsigned char) COM_QUIT;
 
248
      *packet_length= 1;
 
249
      break;
 
250
    }
 
251
  }
 
252
 
206
253
  /* Do not rely on drizzleclient_net_read, extra safety against programming errors. */
207
254
  (*l_packet)[*packet_length]= '\0';                  /* safety */
208
255
 
237
284
  @param message       Message to send to the client (Used by mysql_status)
238
285
*/
239
286
 
240
 
void ClientOldLibdrizzle::sendOK()
 
287
void ClientDrizzleProtocol::sendOK()
241
288
{
242
289
  unsigned char buff[DRIZZLE_ERRMSG_SIZE+10],*pos;
243
290
  const char *message= NULL;
304
351
  client.
305
352
*/
306
353
 
307
 
void ClientOldLibdrizzle::sendEOF()
 
354
void ClientDrizzleProtocol::sendEOF()
308
355
{
309
356
  /* Set to true if no active vio, to work well in case of --init-file */
310
357
  if (net.vio != 0)
319
366
}
320
367
 
321
368
 
322
 
void ClientOldLibdrizzle::sendError(uint32_t sql_errno, const char *err)
 
369
void ClientDrizzleProtocol::sendError(uint32_t sql_errno, const char *err)
323
370
{
324
371
  uint32_t length;
325
372
  /*
389
436
    1    Error  (Note that in this case the error is not sent to the
390
437
    client)
391
438
*/
392
 
bool ClientOldLibdrizzle::sendFields(List<Item> *list)
 
439
bool ClientDrizzleProtocol::sendFields(List<Item> *list)
393
440
{
394
441
  List_iterator_fast<Item> it(*list);
395
442
  Item *item;
422
469
    /* No conversion */
423
470
    int2store(pos, field.charsetnr);
424
471
    int4store(pos+2, field.length);
425
 
    /* Add one to compensate for tinyint removal from enum. */
426
 
    pos[6]= field.type + 1;
 
472
 
 
473
    if (using_mysql41_protocol)
 
474
    {
 
475
      /* Switch to MySQL field numbering. */
 
476
      switch (field.type)
 
477
      {
 
478
      case DRIZZLE_TYPE_LONG:
 
479
        pos[6]= 3;
 
480
        break;
 
481
 
 
482
      case DRIZZLE_TYPE_DOUBLE:
 
483
        pos[6]= 5;
 
484
        break;
 
485
 
 
486
      case DRIZZLE_TYPE_NULL:
 
487
        pos[6]= 6;
 
488
        break;
 
489
 
 
490
      case DRIZZLE_TYPE_TIMESTAMP:
 
491
        pos[6]= 7;
 
492
        break;
 
493
 
 
494
      case DRIZZLE_TYPE_LONGLONG:
 
495
        pos[6]= 8;
 
496
        break;
 
497
 
 
498
      case DRIZZLE_TYPE_DATETIME:
 
499
        pos[6]= 12;
 
500
        break;
 
501
 
 
502
      case DRIZZLE_TYPE_DATE:
 
503
        pos[6]= 14;
 
504
        break;
 
505
 
 
506
      case DRIZZLE_TYPE_VARCHAR:
 
507
        pos[6]= 15;
 
508
        break;
 
509
 
 
510
      case DRIZZLE_TYPE_DECIMAL:
 
511
        pos[6]= (char)246;
 
512
        break;
 
513
 
 
514
      case DRIZZLE_TYPE_ENUM:
 
515
        pos[6]= (char)247;
 
516
        break;
 
517
 
 
518
      case DRIZZLE_TYPE_BLOB:
 
519
        pos[6]= (char)252;
 
520
        break;
 
521
      }
 
522
    }
 
523
    else
 
524
    {
 
525
      /* Add one to compensate for tinyint removal from enum. */
 
526
      pos[6]= field.type + 1;
 
527
    }
 
528
 
427
529
    int2store(pos+7,field.flags);
428
530
    pos[9]= (char) field.decimals;
429
531
    pos[10]= 0;                // For the future
449
551
  return 1;
450
552
}
451
553
 
452
 
bool ClientOldLibdrizzle::store(Field *from)
 
554
bool ClientDrizzleProtocol::store(Field *from)
453
555
{
454
556
  if (from->is_null())
455
557
    return store();
461
563
  return netStoreData((const unsigned char *)str.ptr(), str.length());
462
564
}
463
565
 
464
 
bool ClientOldLibdrizzle::store(void)
 
566
bool ClientDrizzleProtocol::store(void)
465
567
{
466
568
  char buff[1];
467
569
  buff[0]= (char)251;
468
570
  return packet.append(buff, sizeof(buff), PACKET_BUFFER_EXTRA_ALLOC);
469
571
}
470
572
 
471
 
bool ClientOldLibdrizzle::store(int32_t from)
 
573
bool ClientDrizzleProtocol::store(int32_t from)
472
574
{
473
575
  char buff[12];
474
576
  return netStoreData((unsigned char*) buff,
475
577
                      (size_t) (int10_to_str(from, buff, -10) - buff));
476
578
}
477
579
 
478
 
bool ClientOldLibdrizzle::store(uint32_t from)
 
580
bool ClientDrizzleProtocol::store(uint32_t from)
479
581
{
480
582
  char buff[11];
481
583
  return netStoreData((unsigned char*) buff,
482
584
                      (size_t) (int10_to_str(from, buff, 10) - buff));
483
585
}
484
586
 
485
 
bool ClientOldLibdrizzle::store(int64_t from)
 
587
bool ClientDrizzleProtocol::store(int64_t from)
486
588
{
487
589
  char buff[22];
488
590
  return netStoreData((unsigned char*) buff,
489
591
                      (size_t) (int64_t10_to_str(from, buff, -10) - buff));
490
592
}
491
593
 
492
 
bool ClientOldLibdrizzle::store(uint64_t from)
 
594
bool ClientDrizzleProtocol::store(uint64_t from)
493
595
{
494
596
  char buff[21];
495
597
  return netStoreData((unsigned char*) buff,
496
598
                      (size_t) (int64_t10_to_str(from, buff, 10) - buff));
497
599
}
498
600
 
499
 
bool ClientOldLibdrizzle::store(double from, uint32_t decimals, String *buffer)
 
601
bool ClientDrizzleProtocol::store(double from, uint32_t decimals, String *buffer)
500
602
{
501
603
  buffer->set_real(from, decimals, session->charset());
502
604
  return netStoreData((unsigned char*) buffer->ptr(), buffer->length());
503
605
}
504
606
 
505
 
bool ClientOldLibdrizzle::store(const char *from, size_t length)
 
607
bool ClientDrizzleProtocol::store(const char *from, size_t length)
506
608
{
507
609
  return netStoreData((const unsigned char *)from, length);
508
610
}
509
611
 
510
 
bool ClientOldLibdrizzle::wasAborted(void)
 
612
bool ClientDrizzleProtocol::wasAborted(void)
511
613
{
512
614
  return net.error && net.vio != 0;
513
615
}
514
616
 
515
 
bool ClientOldLibdrizzle::haveMoreData(void)
 
617
bool ClientDrizzleProtocol::haveMoreData(void)
516
618
{
517
619
  return drizzleclient_net_more_data(&net);
518
620
}
519
621
 
520
 
bool ClientOldLibdrizzle::haveError(void)
 
622
bool ClientDrizzleProtocol::haveError(void)
521
623
{
522
624
  return net.error || net.vio == 0;
523
625
}
524
626
 
525
 
bool ClientOldLibdrizzle::checkConnection(void)
 
627
bool ClientDrizzleProtocol::checkConnection(void)
526
628
{
527
629
  uint32_t pkt_len= 0;
528
630
  char *end;
530
632
  // TCP/IP connection
531
633
  {
532
634
    char ip[NI_MAXHOST];
533
 
    uint16_t port;
 
635
    uint16_t peer_port;
534
636
 
535
 
    if (drizzleclient_net_peer_addr(&net, ip, &port, NI_MAXHOST))
 
637
    if (drizzleclient_net_peer_addr(&net, ip, &peer_port, NI_MAXHOST))
536
638
    {
537
639
      my_error(ER_BAD_HOST_ERROR, MYF(0), session->security_ctx.ip.c_str());
538
640
      return false;
549
651
 
550
652
    server_capabilites= CLIENT_BASIC_FLAGS;
551
653
 
 
654
    if (using_mysql41_protocol)
 
655
      server_capabilites|= CLIENT_PROTOCOL_MYSQL41;
 
656
 
552
657
#ifdef HAVE_COMPRESS
553
658
    server_capabilites|= CLIENT_COMPRESS;
554
659
#endif /* HAVE_COMPRESS */
659
764
  return session->checkUser(passwd, passwd_len, l_db);
660
765
}
661
766
 
662
 
bool ClientOldLibdrizzle::netStoreData(const unsigned char *from, size_t length)
 
767
bool ClientDrizzleProtocol::netStoreData(const unsigned char *from, size_t length)
663
768
{
664
769
  size_t packet_length= packet.length();
665
770
  /*
680
785
  write it to the network output buffer.
681
786
*/
682
787
 
683
 
void ClientOldLibdrizzle::writeEOFPacket(uint32_t server_status,
 
788
void ClientDrizzleProtocol::writeEOFPacket(uint32_t server_status,
684
789
                                         uint32_t total_warn_count)
685
790
{
686
791
  unsigned char buff[5];
702
807
  drizzleclient_net_write(&net, buff, 5);
703
808
}
704
809
 
705
 
static ListenOldLibdrizzle *listen_obj= NULL;
 
810
static ListenDrizzleProtocol *listen_obj= NULL;
706
811
 
707
812
static int init(drizzled::plugin::Registry &registry)
708
813
{
709
 
  listen_obj= new ListenOldLibdrizzle("oldlibdrizzle");
 
814
  listen_obj= new ListenDrizzleProtocol("drizzle_protocol", false);
710
815
  registry.add(listen_obj); 
711
816
  return 0;
712
817
}
718
823
  return 0;
719
824
}
720
825
 
 
826
static DRIZZLE_SYSVAR_UINT(port, port, PLUGIN_VAR_RQCMDARG,
 
827
                           N_("Port number to use for connection or 0 for default to, in order of "
 
828
                              "preference, drizzle.cnf, $DRIZZLE_TCP_PORT, built-in default ("
 
829
                              STRINGIFY_ARG(DRIZZLE_TCP_PORT) ")."),
 
830
                           NULL, NULL, 0, 0, 65535, 0);
721
831
static DRIZZLE_SYSVAR_UINT(connect_timeout, connect_timeout,
722
832
                           PLUGIN_VAR_RQCMDARG, N_("Connect Timeout."),
723
833
                           NULL, NULL, 10, 1, 300, 0);
734
844
                          N_("Address to bind to."), NULL, NULL, NULL);
735
845
 
736
846
static struct st_mysql_sys_var* system_variables[]= {
 
847
  DRIZZLE_SYSVAR(port),
737
848
  DRIZZLE_SYSVAR(connect_timeout),
738
849
  DRIZZLE_SYSVAR(read_timeout),
739
850
  DRIZZLE_SYSVAR(write_timeout),
743
854
  NULL
744
855
};
745
856
 
746
 
drizzle_declare_plugin(oldlibdrizzle)
 
857
drizzle_declare_plugin(drizzle_protocol)
747
858
{
748
 
  "oldlibdrizzle",
 
859
  "drizzle_protocol",
749
860
  "0.1",
750
861
  "Eric Day",
751
 
  "Old libdrizzle Client",
 
862
  "Drizzle Protocol Module",
752
863
  PLUGIN_LICENSE_GPL,
753
864
  init,             /* Plugin Init */
754
865
  deinit,           /* Plugin Deinit */