← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzleclient/drizzle.c

  • Committer: Monty Taylor
  • Date: 2009-02-08 11:11:30 UTC
  • mto: This revision was merged to the branch mainline in revision 852.
  • Revision ID: mordred@inaugust.com-20090208111130-futpwptxv5he3boe
Renamed non-prefixed things from libdrizzleclient to drizzleclient.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzleclient/drizzle.c
61
61
 
62
62
static DRIZZLE_METHODS client_methods=
63
63
{
64
 
  cli_read_query_result,                       /* read_query_result */
65
 
  cli_advanced_command,                        /* advanced_command */
66
 
  cli_read_rows,                               /* read_rows */
67
 
  cli_use_result,                              /* use_result */
68
 
  cli_fetch_lengths,                           /* fetch_lengths */
69
 
  cli_flush_use_result,                        /* flush_use_result */
70
 
  cli_list_fields,                             /* list_fields */
71
 
  cli_unbuffered_fetch,                        /* unbuffered_fetch */
72
 
  cli_read_statistics,                         /* read_statistics */
73
 
  cli_read_query_result,                       /* next_result */
74
 
  cli_read_change_user_result,                 /* read_change_user_result */
 
64
  drizzleclient_cli_read_query_result,                       /* read_query_result */
 
65
  drizzleclient_cli_advanced_command,                        /* advanced_command */
 
66
  drizzleclient_cli_read_rows,                               /* read_rows */
 
67
  drizzleclient_cli_use_result,                              /* use_result */
 
68
  drizzleclient_cli_fetch_lengths,                           /* fetch_lengths */
 
69
  drizzleclient_cli_flush_use_result,                        /* flush_use_result */
 
70
  drizzleclient_cli_list_fields,                             /* list_fields */
 
71
  drizzleclient_cli_unbuffered_fetch,                        /* unbuffered_fetch */
 
72
  drizzleclient_cli_read_statistics,                         /* read_statistics */
 
73
  drizzleclient_cli_read_query_result,                       /* next_result */
 
74
  drizzleclient_cli_read_change_user_result,                 /* read_change_user_result */
75
75
};
76
76
 
77
77
 
124
124
 
125
125
    if (ptr == NULL)
126
126
    {
127
 
      drizzle_set_error(NULL, CR_OUT_OF_MEMORY, sqlstate_get_unknown());
 
127
      drizzle_set_error(NULL, CR_OUT_OF_MEMORY, drizzleclient_sqlstate_get_unknown());
128
128
      return 0;
129
129
    }
130
130
    memset(ptr, 0, sizeof(DRIZZLE));
136
136
  }
137
137
 
138
138
  ptr->options.connect_timeout= CONNECT_TIMEOUT;
139
 
  strcpy(ptr->net.sqlstate, sqlstate_get_not_error());
 
139
  strcpy(ptr->net.sqlstate, drizzleclient_sqlstate_get_not_error());
140
140
 
141
141
  /*
142
142
    Only enable LOAD DATA INFILE by default if configured with
262
262
 
263
263
    if (gai_errno != 0)
264
264
    {
265
 
      drizzle_set_extended_error(drizzle, CR_UNKNOWN_HOST, sqlstate_get_unknown(),
 
265
      drizzle_set_extended_error(drizzle, CR_UNKNOWN_HOST, drizzleclient_sqlstate_get_unknown(),
266
266
                                 ER(CR_UNKNOWN_HOST), host, errno);
267
267
 
268
268
      goto error;
282
282
        continue;
283
283
      }
284
284
 
285
 
      if (connect_with_timeout(sock, t_res->ai_addr, t_res->ai_addrlen, drizzle->options.connect_timeout))
 
285
      if (drizzleclient_connect_with_timeout(sock, t_res->ai_addr, t_res->ai_addrlen, drizzle->options.connect_timeout))
286
286
      {
287
287
        drizzleclient_vio_delete(net->vio);
288
288
        net->vio= 0;
296
296
 
297
297
  if (!net->vio)
298
298
  {
299
 
    drizzle_set_extended_error(drizzle, CR_CONN_HOST_ERROR, sqlstate_get_unknown(),
 
299
    drizzle_set_extended_error(drizzle, CR_CONN_HOST_ERROR, drizzleclient_sqlstate_get_unknown(),
300
300
                               ER(CR_CONN_HOST_ERROR), host, errno);
301
301
    goto error;
302
302
  }
305
305
  {
306
306
    drizzleclient_vio_delete(net->vio);
307
307
    net->vio = 0;
308
 
    drizzle_set_error(drizzle, CR_OUT_OF_MEMORY, sqlstate_get_unknown());
 
308
    drizzle_set_error(drizzle, CR_OUT_OF_MEMORY, drizzleclient_sqlstate_get_unknown());
309
309
    goto error;
310
310
  }
311
311
  drizzleclient_vio_keepalive(net->vio,true);
326
326
  if (drizzle->options.connect_timeout &&
327
327
      drizzleclient_vio_poll_read(net->vio, drizzle->options.connect_timeout))
328
328
  {
329
 
    drizzle_set_extended_error(drizzle, CR_SERVER_LOST, sqlstate_get_unknown(),
 
329
    drizzle_set_extended_error(drizzle, CR_SERVER_LOST, drizzleclient_sqlstate_get_unknown(),
330
330
                               ER(CR_SERVER_LOST_INITIAL_COMM_WAIT),
331
331
                               errno);
332
332
    goto error;
336
336
    Part 1: Connection established, read and parse first packet
337
337
  */
338
338
 
339
 
  if ((pkt_length=cli_safe_read(drizzle)) == packet_error)
 
339
  if ((pkt_length=drizzleclient_cli_safe_read(drizzle)) == packet_error)
340
340
  {
341
341
    if (drizzle->net.last_errno == CR_SERVER_LOST)
342
 
      drizzle_set_extended_error(drizzle, CR_SERVER_LOST, sqlstate_get_unknown(),
 
342
      drizzle_set_extended_error(drizzle, CR_SERVER_LOST, drizzleclient_sqlstate_get_unknown(),
343
343
                                 ER(CR_SERVER_LOST_INITIAL_COMM_READ),
344
344
                                 errno);
345
345
    goto error;
349
349
  drizzle->protocol_version= net->read_pos[0];
350
350
  if (drizzle->protocol_version != PROTOCOL_VERSION)
351
351
  {
352
 
    drizzle_set_extended_error(drizzle, CR_VERSION_ERROR, sqlstate_get_unknown(),
 
352
    drizzle_set_extended_error(drizzle, CR_VERSION_ERROR, drizzleclient_sqlstate_get_unknown(),
353
353
                               ER(CR_VERSION_ERROR), drizzle->protocol_version,
354
354
                               PROTOCOL_VERSION);
355
355
    goto error;
383
383
  if (drizzle->options.secure_auth && passwd[0] &&
384
384
      !(drizzle->server_capabilities & CLIENT_SECURE_CONNECTION))
385
385
  {
386
 
    drizzle_set_error(drizzle, CR_SECURE_AUTH, sqlstate_get_unknown());
 
386
    drizzle_set_error(drizzle, CR_SECURE_AUTH, drizzleclient_sqlstate_get_unknown());
387
387
    goto error;
388
388
  }
389
389
 
393
393
      !(drizzle->user=strdup(user)) ||
394
394
      !(drizzle->passwd=strdup(passwd)))
395
395
  {
396
 
    drizzle_set_error(drizzle, CR_OUT_OF_MEMORY, sqlstate_get_unknown());
 
396
    drizzle_set_error(drizzle, CR_OUT_OF_MEMORY, drizzleclient_sqlstate_get_unknown());
397
397
    goto error;
398
398
  }
399
399
  drizzle->host= drizzle->host_info+strlen(host_info)+1;
464
464
    db= 0;
465
465
  }
466
466
  /* Write authentication package */
467
 
  if (drizzleclient_net_write(net, (unsigned char*) buff, (size_t) (end-buff)) || net_flush(net))
 
467
  if (drizzleclient_net_write(net, (unsigned char*) buff, (size_t) (end-buff)) || drizzleclient_net_flush(net))
468
468
  {
469
 
    drizzle_set_extended_error(drizzle, CR_SERVER_LOST, sqlstate_get_unknown(),
 
469
    drizzle_set_extended_error(drizzle, CR_SERVER_LOST, drizzleclient_sqlstate_get_unknown(),
470
470
                               ER(CR_SERVER_LOST_SEND_AUTH),
471
471
                               errno);
472
472
    goto error;
477
477
    OK-packet, or re-request scrambled password.
478
478
  */
479
479
 
480
 
  if ((pkt_length=cli_safe_read(drizzle)) == packet_error)
 
480
  if ((pkt_length=drizzleclient_cli_safe_read(drizzle)) == packet_error)
481
481
  {
482
482
    if (drizzle->net.last_errno == CR_SERVER_LOST)
483
 
      drizzle_set_extended_error(drizzle, CR_SERVER_LOST, sqlstate_get_unknown(),
 
483
      drizzle_set_extended_error(drizzle, CR_SERVER_LOST, drizzleclient_sqlstate_get_unknown(),
484
484
                                 ER(CR_SERVER_LOST_READ_AUTH),
485
485
                                 errno);
486
486
    goto error;
493
493
  if (db && drizzle_select_db(drizzle, db))
494
494
  {
495
495
    if (drizzle->net.last_errno == CR_SERVER_LOST)
496
 
      drizzle_set_extended_error(drizzle, CR_SERVER_LOST, sqlstate_get_unknown(),
 
496
      drizzle_set_extended_error(drizzle, CR_SERVER_LOST, drizzleclient_sqlstate_get_unknown(),
497
497
                                 ER(CR_SERVER_LOST_SETTING_DB),
498
498
                                 errno);
499
499
    goto error;
544
544
  {
545
545
    /* Allow reconnect next time */
546
546
    drizzle->server_status&= ~SERVER_STATUS_IN_TRANS;
547
 
    drizzle_set_error(drizzle, CR_SERVER_GONE_ERROR, sqlstate_get_unknown());
 
547
    drizzle_set_error(drizzle, CR_SERVER_GONE_ERROR, drizzleclient_sqlstate_get_unknown());
548
548
    return(1);
549
549
  }
550
550
  drizzle_create(&tmp_drizzle);
569
569
  drizzle->free_me=0;
570
570
  drizzle_close(drizzle);
571
571
  *drizzle=tmp_drizzle;
572
 
  net_clear(&drizzle->net, 1);
 
572
  drizzleclient_net_clear(&drizzle->net, 1);
573
573
  drizzle->affected_rows= ~(uint64_t) 0;
574
574
  return(0);
575
575
}
586
586
    drizzleclient_vio_delete(drizzle->net.vio);
587
587
    drizzle->net.vio= 0;          /* Marker */
588
588
  }
589
 
  net_end(&drizzle->net);
590
 
  free_old_query(drizzle);
 
589
  drizzleclient_net_end(&drizzle->net);
 
590
  drizzleclient_free_old_query(drizzle);
591
591
  errno= save_errno;
592
592
}
593
593
 
644
644
    /* If connection is still up, send a QUIT message */
645
645
    if (drizzle->net.vio != 0)
646
646
    {
647
 
      free_old_query(drizzle);
 
647
      drizzleclient_free_old_query(drizzle);
648
648
      drizzle->status=DRIZZLE_STATUS_READY; /* Force command */
649
649
      drizzle->reconnect=0;
650
650
      simple_command(drizzle,COM_QUIT,(unsigned char*) 0,0,1);
659
659
}
660
660
 
661
661
 
662
 
bool cli_read_query_result(DRIZZLE *drizzle)
 
662
bool drizzleclient_cli_read_query_result(DRIZZLE *drizzle)
663
663
{
664
664
  unsigned char *pos;
665
665
  uint32_t field_count;
666
666
  DRIZZLE_DATA *fields;
667
667
  uint32_t length;
668
668
 
669
 
  if ((length = cli_safe_read(drizzle)) == packet_error)
 
669
  if ((length = drizzleclient_cli_safe_read(drizzle)) == packet_error)
670
670
    return(1);
671
 
  free_old_query(drizzle);    /* Free old result */
 
671
  drizzleclient_free_old_query(drizzle);    /* Free old result */
672
672
get_info:
673
673
  pos=(unsigned char*) drizzle->net.read_pos;
674
 
  if ((field_count= net_field_length(&pos)) == 0)
 
674
  if ((field_count= drizzleclient_net_field_length(&pos)) == 0)
675
675
  {
676
 
    drizzle->affected_rows= net_field_length_ll(&pos);
677
 
    drizzle->insert_id=    net_field_length_ll(&pos);
 
676
    drizzle->affected_rows= drizzleclient_drizzleclient_net_field_length_ll(&pos);
 
677
    drizzle->insert_id=    drizzleclient_drizzleclient_net_field_length_ll(&pos);
678
678
 
679
679
    drizzle->server_status= uint2korr(pos); pos+=2;
680
680
    drizzle->warning_count= uint2korr(pos); pos+=2;
681
681
 
682
 
    if (pos < drizzle->net.read_pos+length && net_field_length(&pos))
 
682
    if (pos < drizzle->net.read_pos+length && drizzleclient_net_field_length(&pos))
683
683
      drizzle->info=(char*) pos;
684
684
    return(0);
685
685
  }
689
689
 
690
690
    if (!(drizzle->options.client_flag & CLIENT_LOCAL_FILES))
691
691
    {
692
 
      drizzle_set_error(drizzle, CR_MALFORMED_PACKET, sqlstate_get_unknown());
 
692
      drizzle_set_error(drizzle, CR_MALFORMED_PACKET, drizzleclient_sqlstate_get_unknown());
693
693
      return(1);
694
694
    }
695
695
 
696
 
    error= handle_local_infile(drizzle,(char*) pos);
697
 
    if ((length= cli_safe_read(drizzle)) == packet_error || error)
 
696
    error= drizzleclient_handle_local_infile(drizzle,(char*) pos);
 
697
    if ((length= drizzleclient_cli_safe_read(drizzle)) == packet_error || error)
698
698
      return(1);
699
699
    goto get_info;        /* Get info packet */
700
700
  }
701
701
  if (!(drizzle->server_status & SERVER_STATUS_AUTOCOMMIT))
702
702
    drizzle->server_status|= SERVER_STATUS_IN_TRANS;
703
703
 
704
 
  if (!(fields=cli_read_rows(drizzle,(DRIZZLE_FIELD*)0, 7)))
 
704
  if (!(fields=drizzleclient_cli_read_rows(drizzle,(DRIZZLE_FIELD*)0, 7)))
705
705
    return(1);
706
706
  if (!(drizzle->fields= drizzleclient_unpack_fields(fields, (uint32_t) field_count, 0)))
707
707
    return(1);
746
746
    return(0);
747
747
  if (drizzle->status != DRIZZLE_STATUS_GET_RESULT)
748
748
  {
749
 
    drizzle_set_error(drizzle, CR_COMMANDS_OUT_OF_SYNC, sqlstate_get_unknown());
 
749
    drizzle_set_error(drizzle, CR_COMMANDS_OUT_OF_SYNC, drizzleclient_sqlstate_get_unknown());
750
750
    return(0);
751
751
  }
752
752
  drizzle->status=DRIZZLE_STATUS_READY;    /* server is ready */
754
754
                sizeof(uint32_t) *
755
755
                drizzle->field_count))))
756
756
  {
757
 
    drizzle_set_error(drizzle, CR_OUT_OF_MEMORY, sqlstate_get_unknown());
 
757
    drizzle_set_error(drizzle, CR_OUT_OF_MEMORY, drizzleclient_sqlstate_get_unknown());
758
758
    return(0);
759
759
  }
760
760
  memset(result, 0,(sizeof(DRIZZLE_RES)+ sizeof(uint32_t) *
790
790
  have to wait for the client (and will not wait more than 30 sec/packet).
791
791
**************************************************************************/
792
792
 
793
 
DRIZZLE_RES * cli_use_result(DRIZZLE *drizzle)
 
793
DRIZZLE_RES * drizzleclient_cli_use_result(DRIZZLE *drizzle)
794
794
{
795
795
  DRIZZLE_RES *result;
796
796
 
798
798
    return(0);
799
799
  if (drizzle->status != DRIZZLE_STATUS_GET_RESULT)
800
800
  {
801
 
    drizzle_set_error(drizzle, CR_COMMANDS_OUT_OF_SYNC, sqlstate_get_unknown());
 
801
    drizzle_set_error(drizzle, CR_COMMANDS_OUT_OF_SYNC, drizzleclient_sqlstate_get_unknown());
802
802
    return(0);
803
803
  }
804
804
  if (!(result=(DRIZZLE_RES*) malloc(sizeof(*result)+
872
872
 
873
873
   @param drizzle connection handle
874
874
   @param errcode   CR_* errcode, for client errors
875
 
   @param sqlstate  SQL standard sql state, sqlstate_get_unknown() for the
 
875
   @param sqlstate  SQL standard sql state, drizzleclient_sqlstate_get_unknown() for the
876
876
   majority of client errors.
877
877
   @param format    error message template, in sprintf format
878
878
   @param ...       variable number of arguments
903
903
  Flush result set sent from server
904
904
*/
905
905
 
906
 
void cli_flush_use_result(DRIZZLE *drizzle)
 
906
void drizzleclient_cli_flush_use_result(DRIZZLE *drizzle)
907
907
{
908
908
  /* Clear the current execution status */
909
909
  for (;;)
910
910
  {
911
911
    uint32_t pkt_len;
912
 
    if ((pkt_len=cli_safe_read(drizzle)) == packet_error)
 
912
    if ((pkt_len=drizzleclient_cli_safe_read(drizzle)) == packet_error)
913
913
      break;
914
914
    if (pkt_len <= 8 && drizzle->net.read_pos[0] == DRIZZLE_PROTOCOL_NO_MORE_DATA)
915
915
    {
929
929
  else the lengths are calculated from the offset between pointers.
930
930
**************************************************************************/
931
931
 
932
 
void cli_fetch_lengths(uint32_t *to, DRIZZLE_ROW column, uint32_t field_count)
 
932
void drizzleclient_cli_fetch_lengths(uint32_t *to, DRIZZLE_ROW column, uint32_t field_count)
933
933
{
934
934
  uint32_t *prev_length;
935
935
  char *start=0;