← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/oldlibdrizzle/oldlibdrizzle.cc

  • Committer: Eric Day
  • Date: 2009-08-06 07:14:37 UTC
  • mto: This revision was merged to the branch mainline in revision 1131.
  • Revision ID: eday@oddments.org-20090806071437-c3baqgtvsdxp1l1a
Renamed Protocol to Client, cleaned up some unnecessary methods along the way.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/oldlibdrizzle/oldlibdrizzle.cc
57
57
  return port;
58
58
}
59
59
 
60
 
plugin::Protocol *ListenOldLibdrizzle::protocolFactory(void) const
 
60
plugin::Client *ListenOldLibdrizzle::clientFactory(void) const
61
61
{
62
 
  return new ProtocolOldLibdrizzle;
 
62
  return new ClientOldLibdrizzle;
63
63
}
64
64
 
65
65
static void write_eof_packet(Session *session, NET *net,
66
66
                             uint32_t server_status, uint32_t total_warn_count);
67
67
 
68
 
bool ProtocolOldLibdrizzle::isConnected()
 
68
bool ClientOldLibdrizzle::isConnected()
69
69
{
70
70
  return net.vio != 0;
71
71
}
72
72
 
73
 
void ProtocolOldLibdrizzle::setError(char error)
 
73
void ClientOldLibdrizzle::setError(char error)
74
74
{
75
75
  net.error= error;
76
76
}
77
77
 
78
 
bool ProtocolOldLibdrizzle::haveError(void)
 
78
bool ClientOldLibdrizzle::haveError(void)
79
79
{
80
80
  return net.error || net.vio == 0;
81
81
}
82
82
 
83
 
bool ProtocolOldLibdrizzle::wasAborted(void)
 
83
bool ClientOldLibdrizzle::wasAborted(void)
84
84
{
85
85
  return net.error && net.vio != 0;
86
86
}
87
87
 
88
 
bool ProtocolOldLibdrizzle::haveMoreData(void)
 
88
bool ClientOldLibdrizzle::haveMoreData(void)
89
89
{
90
90
  return drizzleclient_net_more_data(&net);
91
91
}
92
92
 
93
 
bool ProtocolOldLibdrizzle::isReading(void)
 
93
bool ClientOldLibdrizzle::isReading(void)
94
94
{
95
95
  return net.reading_or_writing == 1;
96
96
}
97
97
 
98
 
bool ProtocolOldLibdrizzle::isWriting(void)
 
98
bool ClientOldLibdrizzle::isWriting(void)
99
99
{
100
100
  return net.reading_or_writing == 2;
101
101
}
102
102
 
103
 
bool ProtocolOldLibdrizzle::netStoreData(const unsigned char *from, size_t length)
 
103
bool ClientOldLibdrizzle::netStoreData(const unsigned char *from, size_t length)
104
104
{
105
105
  size_t packet_length= packet->length();
106
106
  /*
127
127
  - id        : Stored in 1-9 bytes
128
128
  - server_status    : Copy of session->server_status;  Can be used by client
129
129
  to check if we are inside an transaction.
130
 
  New in 4.0 protocol
131
 
  - warning_count    : Stored in 2 bytes; New in 4.1 protocol
 
130
  New in 4.0 client
 
131
  - warning_count    : Stored in 2 bytes; New in 4.1 client
132
132
  - message        : Stored as packed length (1-9 bytes) + message.
133
133
  Is not stored if no message.
134
134
 
138
138
  @param message       Message to send to the client (Used by mysql_status)
139
139
*/
140
140
 
141
 
void ProtocolOldLibdrizzle::sendOK()
 
141
void ClientOldLibdrizzle::sendOK()
142
142
{
143
143
  unsigned char buff[DRIZZLE_ERRMSG_SIZE+10],*pos;
144
144
  const char *message= NULL;
196
196
  The eof packet has the following structure:
197
197
 
198
198
  - 254    (DRIZZLE_PROTOCOL_NO_MORE_DATA)    : Marker (1 byte)
199
 
  - warning_count    : Stored in 2 bytes; New in 4.1 protocol
 
199
  - warning_count    : Stored in 2 bytes; New in 4.1 client
200
200
  - status_flag    : Stored in 2 bytes;
201
201
  For flags like SERVER_MORE_RESULTS_EXISTS.
202
202
 
205
205
  client.
206
206
*/
207
207
 
208
 
void ProtocolOldLibdrizzle::sendEOF()
 
208
void ClientOldLibdrizzle::sendEOF()
209
209
{
210
210
  /* Set to true if no active vio, to work well in case of --init-file */
211
211
  if (net.vio != 0)
220
220
 
221
221
 
222
222
/**
223
 
  Format EOF packet according to the current protocol and
 
223
  Format EOF packet according to the current client and
224
224
  write it to the network output buffer.
225
225
*/
226
226
 
247
247
  drizzleclient_net_write(net, buff, 5);
248
248
}
249
249
 
250
 
void ProtocolOldLibdrizzle::sendError(uint32_t sql_errno, const char *err)
 
250
void ClientOldLibdrizzle::sendError(uint32_t sql_errno, const char *err)
251
251
{
252
252
  uint32_t length;
253
253
  /*
283
283
  int2store(buff,sql_errno);
284
284
  pos= buff+2;
285
285
 
286
 
  /* The first # is to make the protocol backward compatible */
 
286
  /* The first # is to make the client backward compatible */
287
287
  buff[2]= '#';
288
288
  pos= (unsigned char*) strcpy((char*) buff+3, drizzle_errno_to_sqlstate(sql_errno));
289
289
  pos+= strlen(drizzle_errno_to_sqlstate(sql_errno));
300
300
}
301
301
 
302
302
 
303
 
ProtocolOldLibdrizzle::ProtocolOldLibdrizzle()
 
303
ClientOldLibdrizzle::ClientOldLibdrizzle()
304
304
{
305
305
  scramble[0]= 0;
306
306
  net.vio= 0;
307
307
}
308
308
 
309
 
ProtocolOldLibdrizzle::~ProtocolOldLibdrizzle()
 
309
ClientOldLibdrizzle::~ClientOldLibdrizzle()
310
310
{
311
311
  if (net.vio)
312
312
    drizzleclient_vio_close(net.vio);
313
313
}
314
314
 
315
 
void ProtocolOldLibdrizzle::setSession(Session *session_arg)
 
315
void ClientOldLibdrizzle::setSession(Session *session_arg)
316
316
{
317
317
  session= session_arg;
318
318
  packet= &session->packet;
319
319
  convert= &session->convert_buffer;
 
320
  prepareForResend();
320
321
}
321
322
 
322
323
 
338
339
    1    Error  (Note that in this case the error is not sent to the
339
340
    client)
340
341
*/
341
 
bool ProtocolOldLibdrizzle::sendFields(List<Item> *list)
 
342
bool ClientOldLibdrizzle::sendFields(List<Item> *list)
342
343
{
343
344
  List_iterator_fast<Item> it(*list);
344
345
  Item *item;
354
355
    SendField field;
355
356
    item->make_field(&field);
356
357
 
357
 
    prepareForResend();
358
 
 
359
358
    if (store(STRING_WITH_LEN("def")) ||
360
359
        store(field.db_name) ||
361
360
        store(field.table_name) ||
379
378
    pos+= 12;
380
379
 
381
380
    packet->length((uint32_t) (pos - packet->ptr()));
382
 
    if (write())
 
381
    if (flush())
383
382
      break;                    /* purecov: inspected */
384
383
  }
385
384
 
401
400
}
402
401
 
403
402
 
404
 
bool ProtocolOldLibdrizzle::write()
 
403
bool ClientOldLibdrizzle::flush()
405
404
{
406
 
  return(drizzleclient_net_write(&net, (unsigned char*) packet->ptr(),
407
 
                           packet->length()));
 
405
  if (net.vio == NULL)
 
406
    return false;
 
407
  bool ret= drizzleclient_net_write(&net, (unsigned char*) packet->ptr(),
 
408
                           packet->length());
 
409
  prepareForResend();
 
410
  return ret;
408
411
}
409
412
 
410
 
void ProtocolOldLibdrizzle::free()
 
413
void ClientOldLibdrizzle::free()
411
414
{
412
415
  packet->free();
413
416
}
414
417
 
415
 
bool ProtocolOldLibdrizzle::setFileDescriptor(int fd)
 
418
bool ClientOldLibdrizzle::setFileDescriptor(int fd)
416
419
{
417
420
  if (drizzleclient_net_init_sock(&net, fd, 0))
418
421
    return true;
424
427
  return false;
425
428
}
426
429
 
427
 
int ProtocolOldLibdrizzle::fileDescriptor(void)
 
430
int ClientOldLibdrizzle::getFileDescriptor(void)
428
431
{
429
432
  return drizzleclient_net_get_sd(&net);
430
433
}
431
434
 
432
 
bool ProtocolOldLibdrizzle::authenticate()
 
435
bool ClientOldLibdrizzle::authenticate()
433
436
{
434
437
  bool connection_is_valid;
435
438
 
453
456
  return true;
454
457
}
455
458
 
456
 
bool ProtocolOldLibdrizzle::readCommand(char **l_packet, uint32_t *packet_length)
 
459
bool ClientOldLibdrizzle::readCommand(char **l_packet, uint32_t *packet_length)
457
460
{
458
461
  /*
459
462
    This thread will do a blocking read from the client which
483
486
    if (session->main_da.status() == Diagnostics_area::DA_ERROR)
484
487
      sendError(session->main_da.sql_errno(), session->main_da.message());
485
488
    else
486
 
      session->protocol->sendOK();
 
489
      sendOK();
487
490
 
488
491
    if (net.error != 3)
489
492
      return false;                       // We have to close it.
523
526
  return true;
524
527
}
525
528
 
526
 
void ProtocolOldLibdrizzle::close(void)
 
529
void ClientOldLibdrizzle::close(void)
527
530
{
528
531
  if (net.vio)
529
532
  { 
532
535
  }
533
536
}
534
537
 
535
 
void ProtocolOldLibdrizzle::forceClose(void)
 
538
void ClientOldLibdrizzle::forceClose(void)
536
539
{
537
540
  if (net.vio)
538
541
    drizzleclient_vio_close(net.vio);
539
542
}
540
543
 
541
 
void ProtocolOldLibdrizzle::prepareForResend()
 
544
void ClientOldLibdrizzle::prepareForResend()
542
545
{
543
546
  packet->length(0);
544
547
}
545
548
 
546
 
bool ProtocolOldLibdrizzle::store(void)
 
549
bool ClientOldLibdrizzle::store(void)
547
550
{
548
551
  char buff[1];
549
552
  buff[0]= (char)251;
551
554
}
552
555
 
553
556
 
554
 
bool ProtocolOldLibdrizzle::store(const char *from, size_t length)
 
557
bool ClientOldLibdrizzle::store(const char *from, size_t length)
555
558
{
556
559
  return netStoreData((const unsigned char *)from, length);
557
560
}
558
561
 
559
562
 
560
 
bool ProtocolOldLibdrizzle::store(int32_t from)
 
563
bool ClientOldLibdrizzle::store(int32_t from)
561
564
{
562
565
  char buff[12];
563
566
  return netStoreData((unsigned char*) buff,
564
567
                      (size_t) (int10_to_str(from, buff, -10) - buff));
565
568
}
566
569
 
567
 
bool ProtocolOldLibdrizzle::store(uint32_t from)
 
570
bool ClientOldLibdrizzle::store(uint32_t from)
568
571
{
569
572
  char buff[11];
570
573
  return netStoreData((unsigned char*) buff,
571
574
                      (size_t) (int10_to_str(from, buff, 10) - buff));
572
575
}
573
576
 
574
 
bool ProtocolOldLibdrizzle::store(int64_t from)
 
577
bool ClientOldLibdrizzle::store(int64_t from)
575
578
{
576
579
  char buff[22];
577
580
  return netStoreData((unsigned char*) buff,
578
581
                      (size_t) (int64_t10_to_str(from, buff, -10) - buff));
579
582
}
580
583
 
581
 
bool ProtocolOldLibdrizzle::store(uint64_t from)
 
584
bool ClientOldLibdrizzle::store(uint64_t from)
582
585
{
583
586
  char buff[21];
584
587
  return netStoreData((unsigned char*) buff,
586
589
}
587
590
 
588
591
 
589
 
bool ProtocolOldLibdrizzle::store(double from, uint32_t decimals, String *buffer)
 
592
bool ClientOldLibdrizzle::store(double from, uint32_t decimals, String *buffer)
590
593
{
591
594
  buffer->set_real(from, decimals, session->charset());
592
595
  return netStoreData((unsigned char*) buffer->ptr(), buffer->length());
593
596
}
594
597
 
595
598
 
596
 
bool ProtocolOldLibdrizzle::store(Field *from)
 
599
bool ClientOldLibdrizzle::store(Field *from)
597
600
{
598
601
  if (from->is_null())
599
602
    return store();
612
615
    we support 0-6 decimals for time.
613
616
*/
614
617
 
615
 
bool ProtocolOldLibdrizzle::store(const DRIZZLE_TIME *tm)
 
618
bool ClientOldLibdrizzle::store(const DRIZZLE_TIME *tm)
616
619
{
617
620
  char buff[40];
618
621
  uint32_t length;
658
661
  return netStoreData((unsigned char*) buff, length);
659
662
}
660
663
 
661
 
bool ProtocolOldLibdrizzle::checkConnection(void)
 
664
bool ClientOldLibdrizzle::checkConnection(void)
662
665
{
663
666
  uint32_t pkt_len= 0;
664
667
  char *end;
669
672
  // TCP/IP connection
670
673
  {
671
674
    char ip[NI_MAXHOST];
 
675
    uint16_t port;
672
676
 
673
 
    if (drizzleclient_net_peer_addr(&net, ip, &session->peer_port, NI_MAXHOST))
 
677
    if (drizzleclient_net_peer_addr(&net, ip, &port, NI_MAXHOST))
674
678
    {
675
679
      my_error(ER_BAD_HOST_ERROR, MYF(0), session->security_ctx.ip.c_str());
676
680
      return false;
780
784
    the size (1 byte) + string (not null-terminated). Hence in case of empty
781
785
    password both send '\0'.
782
786
 
783
 
    This strlen() can't be easily deleted without changing protocol.
 
787
    This strlen() can't be easily deleted without changing client.
784
788
 
785
789
    Cast *passwd to an unsigned char, so that it doesn't extend the sign for
786
790
    *passwd > 127 and become 2**32-127+ after casting to uint.
789
793
    (unsigned char)(*passwd++) : strlen(passwd);
790
794
  l_db= client_capabilities & CLIENT_CONNECT_WITH_DB ? l_db + passwd_len + 1 : 0;
791
795
 
792
 
  /* strlen() can't be easily deleted without changing protocol */
 
796
  /* strlen() can't be easily deleted without changing client */
793
797
  uint32_t db_len= l_db ? strlen(l_db) : 0;
794
798
 
795
799
  if (passwd + passwd_len + db_len > (char *) net.read_pos + pkt_len)
848
852
  "oldlibdrizzle",
849
853
  "0.1",
850
854
  "Eric Day",
851
 
  "Old libdrizzle Protocol",
 
855
  "Old libdrizzle Client",
852
856
  PLUGIN_LICENSE_GPL,
853
857
  init,             /* Plugin Init */
854
858
  deinit,           /* Plugin Deinit */