← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/client.c

  • Committer: Jay Pipes
  • Date: 2008-07-17 17:44:14 UTC
  • mfrom: (177 drizzle)
  • mto: This revision was merged to the branch mainline in revision 182.
  • Revision ID: jay@mysql.com-20080717174414-sm1e9agb2fjw2ncz
Merged in from trunk.

Made following changes:

libdrizzle/
  client.c
  * Removed DBUG symbols entirely
  * Removed mysql_debug() calls and command line options
  libdrizzle.c
  * Removed DBUG symbols
include/my_sys.h
  * Removed MY_DONT_FREE_DBUG symbol (used in my_end())
mysys/my_init.h
  * Removed MY_DONT_FREE_DBUG symbol (used in my_end())

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/client.c
251
251
void set_mysql_error(MYSQL *mysql, int errcode, const char *sqlstate)
252
252
{
253
253
  NET *net;
254
 
  DBUG_ENTER("set_mysql_error");
255
 
  DBUG_PRINT("enter", ("error :%d '%s'", errcode, ER(errcode)));
256
 
  DBUG_ASSERT(mysql != 0);
 
254
  assert(mysql != 0);
257
255
 
258
256
  if (mysql)
259
257
  {
267
265
    mysql_server_last_errno= errcode;
268
266
    strmov(mysql_server_last_error, ER(errcode));
269
267
  }
270
 
  DBUG_VOID_RETURN;
 
268
  return;
271
269
}
272
270
 
273
271
/**
300
298
{
301
299
  NET *net;
302
300
  va_list args;
303
 
  DBUG_ENTER("set_mysql_extended_error");
304
 
  DBUG_PRINT("enter", ("error :%d '%s'", errcode, format));
305
 
  DBUG_ASSERT(mysql != 0);
 
301
  assert(mysql != 0);
306
302
 
307
303
  net= &mysql->net;
308
304
  net->last_errno= errcode;
312
308
  va_end(args);
313
309
  strmov(net->sqlstate, sqlstate);
314
310
 
315
 
  DBUG_VOID_RETURN;
 
311
  return;
316
312
}
317
313
 
318
314
/*****************************************************************************
334
330
 
335
331
  if (len == packet_error || len == 0)
336
332
  {
337
 
    DBUG_PRINT("error",("Wrong connection or packet. fd: %s  len: %lu",
338
 
                        vio_description(net->vio),len));
339
333
#ifdef MYSQL_SERVER
340
334
    if (net->vio && vio_was_interrupted(net->vio))
341
335
      return (packet_error);
384
378
    */
385
379
    mysql->server_status&= ~SERVER_MORE_RESULTS_EXISTS;
386
380
 
387
 
    DBUG_PRINT("error",("Got error: %d/%s (%s)",
388
 
                        net->last_errno,
389
 
                        net->sqlstate,
390
 
                        net->last_error));
391
381
    return(packet_error);
392
382
  }
393
383
  return len;
411
401
  my_bool result= 1;
412
402
  init_sigpipe_variables
413
403
  my_bool stmt_skip= false;
414
 
  DBUG_ENTER("cli_advanced_command");
415
404
 
416
405
  /* Don't give sigpipe errors if the client doesn't want them */
417
406
  set_sigpipe(mysql);
419
408
  if (mysql->net.vio == 0)
420
409
  {                                             /* Do reconnect if possible */
421
410
    if (mysql_reconnect(mysql) || stmt_skip)
422
 
      DBUG_RETURN(1);
 
411
      return(1);
423
412
  }
424
413
  if (mysql->status != MYSQL_STATUS_READY ||
425
414
      mysql->server_status & SERVER_MORE_RESULTS_EXISTS)
426
415
  {
427
 
    DBUG_PRINT("error",("state: %d", mysql->status));
428
416
    set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
429
 
    DBUG_RETURN(1);
 
417
    return(1);
430
418
  }
431
419
 
432
420
  net_clear_error(net);
442
430
  if (net_write_command(net,(uchar) command, header, header_length,
443
431
                        arg, arg_length))
444
432
  {
445
 
    DBUG_PRINT("error",("Can't send command to server. Error: %d",
446
 
                        socket_errno));
447
433
    if (net->last_errno == ER_NET_PACKET_TOO_LARGE)
448
434
    {
449
435
      set_mysql_error(mysql, CR_NET_PACKET_TOO_LARGE, unknown_sqlstate);
465
451
             1 : 0);
466
452
end:
467
453
  reset_sigpipe(mysql);
468
 
  DBUG_PRINT("exit",("result: %d", result));
469
 
  DBUG_RETURN(result);
 
454
  return(result);
470
455
}
471
456
 
472
457
void free_old_query(MYSQL *mysql)
473
458
{
474
 
  DBUG_ENTER("free_old_query");
475
459
  if (mysql->fields)
476
460
    free_root(&mysql->field_alloc,MYF(0));
477
461
  init_alloc_root(&mysql->field_alloc,8192,0); /* Assume rowlength < 8192 */
479
463
  mysql->field_count= 0;                        /* For API */
480
464
  mysql->warning_count= 0;
481
465
  mysql->info= 0;
482
 
  DBUG_VOID_RETURN;
 
466
  return;
483
467
}
484
468
 
485
469
/*
489
473
static void cli_flush_use_result(MYSQL *mysql)
490
474
{
491
475
  /* Clear the current execution status */
492
 
  DBUG_ENTER("cli_flush_use_result");
493
 
  DBUG_PRINT("warning",("Not all packets read, clearing them"));
494
476
  for (;;)
495
477
  {
496
478
    ulong pkt_len;
507
489
      break;                            /* End of data */
508
490
    }
509
491
  }
510
 
  DBUG_VOID_RETURN;
 
492
  return;
511
493
}
512
494
 
513
495
 
518
500
void end_server(MYSQL *mysql)
519
501
{
520
502
  int save_errno= errno;
521
 
  DBUG_ENTER("end_server");
522
503
  if (mysql->net.vio != 0)
523
504
  {
524
505
    init_sigpipe_variables
525
 
    DBUG_PRINT("info",("Net: %s", vio_description(mysql->net.vio)));
526
506
    set_sigpipe(mysql);
527
507
    vio_delete(mysql->net.vio);
528
508
    reset_sigpipe(mysql);
531
511
  net_end(&mysql->net);
532
512
  free_old_query(mysql);
533
513
  errno= save_errno;
534
 
  DBUG_VOID_RETURN;
 
514
  return;
535
515
}
536
516
 
537
517
 
538
518
void STDCALL
539
519
mysql_free_result(MYSQL_RES *result)
540
520
{
541
 
  DBUG_ENTER("mysql_free_result");
542
 
  DBUG_PRINT("enter",("mysql_res: 0x%lx", (long) result));
543
521
  if (result)
544
522
  {
545
523
    MYSQL *mysql= result->handle;
562
540
      my_free((uchar*) result->row,MYF(0));
563
541
    my_free((uchar*) result,MYF(0));
564
542
  }
565
 
  DBUG_VOID_RETURN;
 
543
  return;
566
544
}
567
545
 
568
546
/****************************************************************************
572
550
static const char *default_options[]=
573
551
{
574
552
  "port","socket","compress","password","pipe", "timeout", "user",
575
 
  "init-command", "host", "database", "debug", "return-found-rows",
 
553
  "init-command", "host", "database", "return-found-rows",
576
554
  "ssl-key" ,"ssl-cert" ,"ssl-ca" ,"ssl-capath",
577
555
  "character-sets-dir", "default-character-set", "interactive-timeout",
578
556
  "connect-timeout", "local-infile", "disable-local-infile",
617
595
  int argc;
618
596
  char *argv_buff[1],**argv;
619
597
  const char *groups[3];
620
 
  DBUG_ENTER("mysql_read_default_options");
621
 
  DBUG_PRINT("enter",("file: %s  group: %s",filename,group ? group :"NULL"));
622
598
 
623
599
  argc=1; argv=argv_buff; argv_buff[0]= (char*) "client";
624
600
  groups[0]= (char*) "client"; groups[1]= (char*) group; groups[2]=0;
629
605
    char **option=argv;
630
606
    while (*++option)
631
607
    {
632
 
      /* DBUG_PRINT("info",("option: %s",option[0])); */
633
608
      if (option[0][0] == '-' && option[0][1] == '-')
634
609
      {
635
610
        char *end=strcend(*option,'=');
696
671
            options->db=my_strdup(opt_arg,MYF(MY_WME));
697
672
          }
698
673
          break;
699
 
        case 11:                        /* debug */
700
 
#ifdef MYSQL_CLIENT
701
 
          mysql_debug(opt_arg ? opt_arg : "d:t:o,/tmp/client.trace");
702
 
          break;
703
 
#endif
704
674
        case 12:                        /* return-found-rows */
705
675
          options->client_flag|=CLIENT_FOUND_ROWS;
706
676
          break;
763
733
          options->report_data_truncation= opt_arg ? test(atoi(opt_arg)) : 1;
764
734
          break;
765
735
        default:
766
 
          DBUG_PRINT("warning",("unknown option: %s",option[0]));
 
736
          break;
767
737
        }
768
738
      }
769
739
    }
770
740
  }
771
741
  free_defaults(argv);
772
 
  DBUG_VOID_RETURN;
 
742
  return;
773
743
}
774
744
 
775
745
 
811
781
  MYSQL_ROWS    *row;
812
782
  MYSQL_FIELD   *field,*result;
813
783
  uint32_t lengths[9];                          /* Max of fields */
814
 
  DBUG_ENTER("unpack_fields");
815
784
 
816
785
  field= result= (MYSQL_FIELD*) alloc_root(alloc,
817
786
                                           (uint) sizeof(*field)*fields);
818
787
  if (!result)
819
788
  {
820
789
    free_rows(data);                            /* Free old data */
821
 
    DBUG_RETURN(0);
 
790
    return(0);
822
791
  }
823
792
  bzero((char*) field, (uint) sizeof(MYSQL_FIELD)*fields);
824
793
  if (server_capabilities & CLIENT_PROTOCOL_41)
828
797
    {
829
798
      uchar *pos;
830
799
      /* fields count may be wrong */
831
 
      DBUG_ASSERT((uint) (field - result) < fields);
 
800
      assert((uint) (field - result) < fields);
832
801
      cli_fetch_lengths(&lengths[0], row->data, default_value ? 8 : 7);
833
802
      field->catalog=   strmake_root(alloc,(char*) row->data[0], lengths[0]);
834
803
      field->db=        strmake_root(alloc,(char*) row->data[1], lengths[1]);
907
876
  }
908
877
#endif /* DELETE_SUPPORT_OF_4_0_PROTOCOL */
909
878
  free_rows(data);                              /* Free old data */
910
 
  DBUG_RETURN(result);
 
879
  return(result);
911
880
}
912
881
 
913
882
/* Read all rows (fields or data) from server */
923
892
  MYSQL_DATA *result;
924
893
  MYSQL_ROWS **prev_ptr,*cur;
925
894
  NET *net = &mysql->net;
926
 
  DBUG_ENTER("cli_read_rows");
927
895
 
928
896
  if ((pkt_len= cli_safe_read(mysql)) == packet_error)
929
 
    DBUG_RETURN(0);
 
897
    return(0);
930
898
  if (!(result=(MYSQL_DATA*) my_malloc(sizeof(MYSQL_DATA),
931
899
                                       MYF(MY_WME | MY_ZEROFILL))))
932
900
  {
933
901
    set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
934
 
    DBUG_RETURN(0);
 
902
    return(0);
935
903
  }
936
904
  init_alloc_root(&result->alloc,8192,0);       /* Assume rowlength < 8192 */
937
905
  result->alloc.min_malloc=sizeof(MYSQL_ROWS);
958
926
    {
959
927
      free_rows(result);
960
928
      set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
961
 
      DBUG_RETURN(0);
 
929
      return(0);
962
930
    }
963
931
    *prev_ptr=cur;
964
932
    prev_ptr= &cur->next;
977
945
        {
978
946
          free_rows(result);
979
947
          set_mysql_error(mysql, CR_MALFORMED_PACKET, unknown_sqlstate);
980
 
          DBUG_RETURN(0);
 
948
          return(0);
981
949
        }
982
950
        memcpy(to,(char*) cp,len); to[len]=0;
983
951
        to+=len+1;
993
961
    if ((pkt_len=cli_safe_read(mysql)) == packet_error)
994
962
    {
995
963
      free_rows(result);
996
 
      DBUG_RETURN(0);
 
964
      return(0);
997
965
    }
998
966
  }
999
967
  *prev_ptr=0;                                  /* last pointer is null */
1001
969
  {
1002
970
    mysql->warning_count= uint2korr(cp+1);
1003
971
    mysql->server_status= uint2korr(cp+3);
1004
 
    DBUG_PRINT("info",("status: %u  warning_count:  %u",
1005
 
                       mysql->server_status, mysql->warning_count));
1006
972
  }
1007
 
  DBUG_PRINT("exit", ("Got %lu rows", (ulong) result->rows));
1008
 
  DBUG_RETURN(result);
 
973
  return(result);
1009
974
}
1010
975
 
1011
976
/*
1240
1205
  NET           *net= &mysql->net;
1241
1206
  struct        sockaddr_un UNIXaddr;
1242
1207
  init_sigpipe_variables
1243
 
  DBUG_ENTER("mysql_real_connect");
1244
 
 
1245
 
  DBUG_PRINT("enter",("host: %s  db: %s  user: %s",
1246
 
                      host ? host : "(Null)",
1247
 
                      db ? db : "(Null)",
1248
 
                      user ? user : "(Null)"));
1249
1208
 
1250
1209
  /* Don't give sigpipe errors if the client doesn't want them */
1251
1210
  set_sigpipe(mysql);
1300
1259
    if ((create_shared_memory(mysql,net, mysql->options.connect_timeout)) ==
1301
1260
        INVALID_HANDLE_VALUE)
1302
1261
    {
1303
 
      DBUG_PRINT("error",
1304
 
                 ("host: '%s'  socket: '%s'  shared memory: %s  have_tcpip: %d",
1305
 
                  host ? host : "<null>",
1306
 
                  unix_socket ? unix_socket : "<null>",
1307
 
                  (int) mysql->options.shared_memory_base_name,
1308
 
                  (int) have_tcpip));
1309
1262
      if (mysql->options.protocol == MYSQL_PROTOCOL_MEMORY)
1310
1263
        goto error;
1311
1264
 
1346
1299
                      VIO_LOCALHOST | VIO_BUFFERED_READ);
1347
1300
    if (!net->vio)
1348
1301
    {
1349
 
      DBUG_PRINT("error",("Unknow protocol %d ", mysql->options.protocol));
1350
1302
      set_mysql_error(mysql, CR_CONN_UNKNOW_PROTOCOL, unknown_sqlstate);
1351
1303
      closesocket(sock);
1352
1304
      goto error;
1356
1308
    if (!unix_socket)
1357
1309
      unix_socket= mysql_unix_port;
1358
1310
    host_info= (char*) ER(CR_LOCALHOST_CONNECTION);
1359
 
    DBUG_PRINT("info", ("Using UNIX sock '%s'", unix_socket));
1360
1311
 
1361
1312
    bzero((char*) &UNIXaddr, sizeof(UNIXaddr));
1362
1313
    UNIXaddr.sun_family= AF_UNIX;
1365
1316
    if (my_connect(sock, (struct sockaddr *) &UNIXaddr, sizeof(UNIXaddr),
1366
1317
                   mysql->options.connect_timeout))
1367
1318
    {
1368
 
      DBUG_PRINT("error",("Got error %d on connect to local server",
1369
 
                          socket_errno));
1370
1319
      set_mysql_extended_error(mysql, CR_CONNECTION_ERROR,
1371
1320
                               unknown_sqlstate,
1372
1321
                               ER(CR_CONNECTION_ERROR),
1394
1343
      host= LOCAL_HOST;
1395
1344
 
1396
1345
    snprintf(host_info=buff, sizeof(buff)-1, ER(CR_TCP_CONNECTION), host);
1397
 
    DBUG_PRINT("info",("Server name: '%s'.  TCP sock: %d", host, port));
1398
1346
 
1399
1347
    memset(&hints, 0, sizeof(hints));
1400
1348
    hints.ai_socktype= SOCK_STREAM;
1401
1349
    hints.ai_protocol= IPPROTO_TCP;
1402
1350
    hints.ai_family= AF_UNSPEC;
1403
1351
 
1404
 
    DBUG_PRINT("info",("IPV6 getaddrinfo %s", host));
1405
1352
    snprintf(port_buf, NI_MAXSERV, "%d", port);
1406
1353
    gai_errno= getaddrinfo(host, port_buf, &hints, &res_lst);
1407
1354
 
1408
1355
    if (gai_errno != 0) 
1409
1356
    { 
1410
 
      /* 
1411
 
        For DBUG we are keeping the right message but for client we default to
1412
 
        historical error message.
1413
 
      */
1414
 
      DBUG_PRINT("info",("IPV6 getaddrinfo error %d", gai_errno));
1415
1357
      set_mysql_extended_error(mysql, CR_UNKNOWN_HOST, unknown_sqlstate,
1416
1358
                               ER(CR_UNKNOWN_HOST), host, errno);
1417
1359
 
1434
1376
      net->vio= vio_new(sock, VIO_TYPE_TCPIP, VIO_BUFFERED_READ);
1435
1377
      if (! net->vio )
1436
1378
      {
1437
 
        DBUG_PRINT("error",("Unknow protocol %d ", mysql->options.protocol));
1438
1379
        set_mysql_error(mysql, CR_CONN_UNKNOW_PROTOCOL, unknown_sqlstate);
1439
1380
        closesocket(sock);
1440
1381
        freeaddrinfo(res_lst);
1444
1385
      if (my_connect(sock, t_res->ai_addr, t_res->ai_addrlen,
1445
1386
                     mysql->options.connect_timeout))
1446
1387
      {
1447
 
        DBUG_PRINT("error",("Got error %d on connect to '%s'",socket_errno,
1448
 
                            host));
1449
1388
        set_mysql_extended_error(mysql, CR_CONN_HOST_ERROR, unknown_sqlstate,
1450
1389
                                 ER(CR_CONN_HOST_ERROR), host, socket_errno);
1451
1390
        vio_delete(net->vio);
1460
1399
 
1461
1400
  if (!net->vio)
1462
1401
  {
1463
 
    DBUG_PRINT("error",("Unknow protocol %d ",mysql->options.protocol));
1464
1402
    set_mysql_error(mysql, CR_CONN_UNKNOW_PROTOCOL, unknown_sqlstate);
1465
1403
    goto error;
1466
1404
  }
1513
1451
  /* Check if version of protocol matches current one */
1514
1452
 
1515
1453
  mysql->protocol_version= net->read_pos[0];
1516
 
  DBUG_DUMP("packet",(uchar*) net->read_pos,10);
1517
 
  DBUG_PRINT("info",("mysql protocol version %d, server=%d",
1518
 
                     PROTOCOL_VERSION, mysql->protocol_version));
1519
1454
  if (mysql->protocol_version != PROTOCOL_VERSION)
1520
1455
  {
1521
1456
    set_mysql_extended_error(mysql, CR_VERSION_ERROR, unknown_sqlstate,
1618
1553
  }
1619
1554
  mysql->client_flag=client_flag;
1620
1555
 
1621
 
  DBUG_PRINT("info",("Server version = '%s'  capabilites: %lu  status: %u  client_flag: %lu",
1622
 
                     mysql->server_version,mysql->server_capabilities,
1623
 
                     mysql->server_status, client_flag));
1624
1556
  /* This needs to be changed as it's not useful with big packets */
1625
1557
  if (user && user[0])
1626
1558
    strmake(end,user,USERNAME_LENGTH);          /* Max user name */
1631
1563
#ifdef _CUSTOMCONFIG_
1632
1564
#include "_cust_libmysql.h"
1633
1565
#endif
1634
 
  DBUG_PRINT("info",("user: %s",end));
1635
1566
  end= strend(end) + 1;
1636
1567
  if (passwd[0])
1637
1568
  {
1714
1645
    mysql->reconnect=reconnect;
1715
1646
  }
1716
1647
 
1717
 
  DBUG_PRINT("exit", ("Mysql handler: 0x%lx", (long) mysql));
1718
1648
  reset_sigpipe(mysql);
1719
 
  DBUG_RETURN(mysql);
 
1649
  return(mysql);
1720
1650
 
1721
1651
error:
1722
1652
  reset_sigpipe(mysql);
1723
 
  DBUG_PRINT("error",("message: %u/%s (%s)",
1724
 
                      net->last_errno,
1725
 
                      net->sqlstate,
1726
 
                      net->last_error));
1727
1653
  {
1728
1654
    /* Free alloced memory */
1729
1655
    end_server(mysql);
1731
1657
    if (!(((ulong) client_flag) & CLIENT_REMEMBER_OPTIONS))
1732
1658
      mysql_close_free_options(mysql);
1733
1659
  }
1734
 
  DBUG_RETURN(0);
 
1660
  return(0);
1735
1661
}
1736
1662
 
1737
1663
 
1738
1664
my_bool mysql_reconnect(MYSQL *mysql)
1739
1665
{
1740
1666
  MYSQL tmp_mysql;
1741
 
  DBUG_ENTER("mysql_reconnect");
1742
 
  DBUG_ASSERT(mysql);
1743
 
  DBUG_PRINT("enter", ("mysql->reconnect: %d", mysql->reconnect));
 
1667
  assert(mysql);
1744
1668
 
1745
1669
  if (!mysql->reconnect ||
1746
1670
      (mysql->server_status & SERVER_STATUS_IN_TRANS) || !mysql->host_info)
1748
1672
    /* Allow reconnect next time */
1749
1673
    mysql->server_status&= ~SERVER_STATUS_IN_TRANS;
1750
1674
    set_mysql_error(mysql, CR_SERVER_GONE_ERROR, unknown_sqlstate);
1751
 
    DBUG_RETURN(1);
 
1675
    return(1);
1752
1676
  }
1753
1677
  mysql_init(&tmp_mysql);
1754
1678
  tmp_mysql.options= mysql->options;
1761
1685
    mysql->net.last_errno= tmp_mysql.net.last_errno;
1762
1686
    strmov(mysql->net.last_error, tmp_mysql.net.last_error);
1763
1687
    strmov(mysql->net.sqlstate, tmp_mysql.net.sqlstate);
1764
 
    DBUG_RETURN(1);
 
1688
    return(1);
1765
1689
  }
1766
1690
  if (mysql_set_character_set(&tmp_mysql, mysql->charset->csname))
1767
1691
  {
1768
 
    DBUG_PRINT("error", ("mysql_set_character_set() failed"));
1769
1692
    bzero((char*) &tmp_mysql.options,sizeof(tmp_mysql.options));
1770
1693
    mysql_close(&tmp_mysql);
1771
1694
    mysql->net.last_errno= tmp_mysql.net.last_errno;
1772
1695
    strmov(mysql->net.last_error, tmp_mysql.net.last_error);
1773
1696
    strmov(mysql->net.sqlstate, tmp_mysql.net.sqlstate);
1774
 
    DBUG_RETURN(1);
 
1697
    return(1);
1775
1698
  }
1776
1699
 
1777
 
  DBUG_PRINT("info", ("reconnect succeded"));
1778
1700
  tmp_mysql.reconnect= 1;
1779
1701
  tmp_mysql.free_me= mysql->free_me;
1780
1702
 
1785
1707
  *mysql=tmp_mysql;
1786
1708
  net_clear(&mysql->net, 1);
1787
1709
  mysql->affected_rows= ~(uint64_t) 0;
1788
 
  DBUG_RETURN(0);
 
1710
  return(0);
1789
1711
}
1790
1712
 
1791
1713
 
1797
1719
mysql_select_db(MYSQL *mysql, const char *db)
1798
1720
{
1799
1721
  int error;
1800
 
  DBUG_ENTER("mysql_select_db");
1801
 
  DBUG_PRINT("enter",("db: '%s'",db));
1802
1722
 
1803
1723
  if ((error=simple_command(mysql,COM_INIT_DB, (const uchar*) db,
1804
1724
                            (ulong) strlen(db),0)))
1805
 
    DBUG_RETURN(error);
 
1725
    return(error);
1806
1726
  my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
1807
1727
  mysql->db=my_strdup(db,MYF(MY_WME));
1808
 
  DBUG_RETURN(0);
 
1728
  return(0);
1809
1729
}
1810
1730
 
1811
1731
 
1816
1736
 
1817
1737
static void mysql_close_free_options(MYSQL *mysql)
1818
1738
{
1819
 
  DBUG_ENTER("mysql_close_free_options");
1820
 
 
1821
1739
  my_free(mysql->options.user,MYF(MY_ALLOW_ZERO_PTR));
1822
1740
  my_free(mysql->options.host,MYF(MY_ALLOW_ZERO_PTR));
1823
1741
  my_free(mysql->options.password,MYF(MY_ALLOW_ZERO_PTR));
1843
1761
    my_free(mysql->options.shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
1844
1762
#endif /* HAVE_SMEM */
1845
1763
  bzero((char*) &mysql->options,sizeof(mysql->options));
1846
 
  DBUG_VOID_RETURN;
 
1764
  return;
1847
1765
}
1848
1766
 
1849
1767
 
1863
1781
 
1864
1782
void STDCALL mysql_close(MYSQL *mysql)
1865
1783
{
1866
 
  DBUG_ENTER("mysql_close");
1867
1784
  if (mysql)                                    /* Some simple safety */
1868
1785
  {
1869
1786
    /* If connection is still up, send a QUIT message */
1880
1797
    if (mysql->free_me)
1881
1798
      my_free((uchar*) mysql,MYF(0));
1882
1799
  }
1883
 
  DBUG_VOID_RETURN;
 
1800
  return;
1884
1801
}
1885
1802
 
1886
1803
 
1890
1807
  ulong field_count;
1891
1808
  MYSQL_DATA *fields;
1892
1809
  ulong length;
1893
 
  DBUG_ENTER("cli_read_query_result");
1894
1810
 
1895
1811
  if ((length = cli_safe_read(mysql)) == packet_error)
1896
 
    DBUG_RETURN(1);
 
1812
    return(1);
1897
1813
  free_old_query(mysql);                /* Free old result */
1898
1814
#ifdef MYSQL_CLIENT                     /* Avoid warn of unused labels*/
1899
1815
get_info:
1903
1819
  {
1904
1820
    mysql->affected_rows= net_field_length_ll(&pos);
1905
1821
    mysql->insert_id=     net_field_length_ll(&pos);
1906
 
    DBUG_PRINT("info",("affected_rows: %lu  insert_id: %lu",
1907
 
                       (ulong) mysql->affected_rows,
1908
 
                       (ulong) mysql->insert_id));
1909
1822
    if (protocol_41(mysql))
1910
1823
    {
1911
1824
      mysql->server_status=uint2korr(pos); pos+=2;
1917
1830
      mysql->server_status=uint2korr(pos); pos+=2;
1918
1831
      mysql->warning_count= 0;
1919
1832
    }
1920
 
    DBUG_PRINT("info",("status: %u  warning_count: %u",
1921
 
                       mysql->server_status, mysql->warning_count));
1922
1833
    if (pos < mysql->net.read_pos+length && net_field_length(&pos))
1923
1834
      mysql->info=(char*) pos;
1924
 
    DBUG_RETURN(0);
 
1835
    return(0);
1925
1836
  }
1926
1837
#ifdef MYSQL_CLIENT
1927
1838
  if (field_count == NULL_LENGTH)               /* LOAD DATA LOCAL INFILE */
1931
1842
    if (!(mysql->options.client_flag & CLIENT_LOCAL_FILES))
1932
1843
    {
1933
1844
      set_mysql_error(mysql, CR_MALFORMED_PACKET, unknown_sqlstate);
1934
 
      DBUG_RETURN(1);
 
1845
      return(1);
1935
1846
    }   
1936
1847
 
1937
1848
    error= handle_local_infile(mysql,(char*) pos);
1938
1849
    if ((length= cli_safe_read(mysql)) == packet_error || error)
1939
 
      DBUG_RETURN(1);
 
1850
      return(1);
1940
1851
    goto get_info;                              /* Get info packet */
1941
1852
  }
1942
1853
#endif
1944
1855
    mysql->server_status|= SERVER_STATUS_IN_TRANS;
1945
1856
 
1946
1857
  if (!(fields=cli_read_rows(mysql,(MYSQL_FIELD*)0, protocol_41(mysql) ? 7:5)))
1947
 
    DBUG_RETURN(1);
 
1858
    return(1);
1948
1859
  if (!(mysql->fields=unpack_fields(fields,&mysql->field_alloc,
1949
1860
                                    (uint) field_count,0,
1950
1861
                                    mysql->server_capabilities)))
1951
 
    DBUG_RETURN(1);
 
1862
    return(1);
1952
1863
  mysql->status= MYSQL_STATUS_GET_RESULT;
1953
1864
  mysql->field_count= (uint) field_count;
1954
 
  DBUG_PRINT("exit",("ok"));
1955
 
  DBUG_RETURN(0);
 
1865
  return(0);
1956
1866
}
1957
1867
 
1958
1868
 
1965
1875
int32_t STDCALL
1966
1876
mysql_send_query(MYSQL* mysql, const char* query, uint32_t length)
1967
1877
{
1968
 
  DBUG_ENTER("mysql_send_query");
1969
 
  DBUG_RETURN(simple_command(mysql, COM_QUERY, (uchar*) query, length, 1));
 
1878
  return(simple_command(mysql, COM_QUERY, (uchar*) query, length, 1));
1970
1879
}
1971
1880
 
1972
1881
 
1973
1882
int32_t STDCALL
1974
1883
mysql_real_query(MYSQL *mysql, const char *query, uint32_t length)
1975
1884
{
1976
 
  DBUG_ENTER("mysql_real_query");
1977
 
  DBUG_PRINT("enter",("handle: 0x%lx", (int32_t) mysql));
1978
 
  DBUG_PRINT("query",("Query = '%-.4096s'",query));
1979
 
 
1980
1885
  if (mysql_send_query(mysql,query,length))
1981
 
    DBUG_RETURN(1);
1982
 
  DBUG_RETURN((int) (*mysql->methods->read_query_result)(mysql));
 
1886
    return(1);
 
1887
  return((int) (*mysql->methods->read_query_result)(mysql));
1983
1888
}
1984
1889
 
1985
1890
 
1991
1896
MYSQL_RES * STDCALL mysql_store_result(MYSQL *mysql)
1992
1897
{
1993
1898
  MYSQL_RES *result;
1994
 
  DBUG_ENTER("mysql_store_result");
1995
1899
 
1996
1900
  if (!mysql->fields)
1997
 
    DBUG_RETURN(0);
 
1901
    return(0);
1998
1902
  if (mysql->status != MYSQL_STATUS_GET_RESULT)
1999
1903
  {
2000
1904
    set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
2001
 
    DBUG_RETURN(0);
 
1905
    return(0);
2002
1906
  }
2003
1907
  mysql->status=MYSQL_STATUS_READY;             /* server is ready */
2004
1908
  if (!(result=(MYSQL_RES*) my_malloc((uint) (sizeof(MYSQL_RES)+
2007
1911
                                      MYF(MY_WME | MY_ZEROFILL))))
2008
1912
  {
2009
1913
    set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
2010
 
    DBUG_RETURN(0);
 
1914
    return(0);
2011
1915
  }
2012
1916
  result->methods= mysql->methods;
2013
1917
  result->eof= 1;                               /* Marker for buffered */
2016
1920
        (*mysql->methods->read_rows)(mysql,mysql->fields,mysql->field_count)))
2017
1921
  {
2018
1922
    my_free((uchar*) result,MYF(0));
2019
 
    DBUG_RETURN(0);
 
1923
    return(0);
2020
1924
  }
2021
1925
  mysql->affected_rows= result->row_count= result->data->rows;
2022
1926
  result->data_cursor=  result->data->data;
2028
1932
  clear_alloc_root(&mysql->field_alloc);
2029
1933
  /* just in case this was mistakenly called after mysql_stmt_execute() */
2030
1934
  mysql->unbuffered_fetch_owner= 0;
2031
 
  DBUG_RETURN(result);                          /* Data fetched */
 
1935
  return(result);                               /* Data fetched */
2032
1936
}
2033
1937
 
2034
1938
 
2045
1949
static MYSQL_RES * cli_use_result(MYSQL *mysql)
2046
1950
{
2047
1951
  MYSQL_RES *result;
2048
 
  DBUG_ENTER("cli_use_result");
2049
1952
 
2050
1953
  if (!mysql->fields)
2051
 
    DBUG_RETURN(0);
 
1954
    return(0);
2052
1955
  if (mysql->status != MYSQL_STATUS_GET_RESULT)
2053
1956
  {
2054
1957
    set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
2055
 
    DBUG_RETURN(0);
 
1958
    return(0);
2056
1959
  }
2057
1960
  if (!(result=(MYSQL_RES*) my_malloc(sizeof(*result)+
2058
1961
                                      sizeof(ulong)*mysql->field_count,
2059
1962
                                      MYF(MY_WME | MY_ZEROFILL))))
2060
 
    DBUG_RETURN(0);
 
1963
    return(0);
2061
1964
  result->lengths=(uint32_t*) (result+1);
2062
1965
  result->methods= mysql->methods;
2063
1966
  if (!(result->row=(MYSQL_ROW)
2064
1967
        my_malloc(sizeof(result->row[0])*(mysql->field_count+1), MYF(MY_WME))))
2065
1968
  {                                     /* Ptrs: to one row */
2066
1969
    my_free((uchar*) result,MYF(0));
2067
 
    DBUG_RETURN(0);
 
1970
    return(0);
2068
1971
  }
2069
1972
  result->fields=       mysql->fields;
2070
1973
  result->field_alloc=  mysql->field_alloc;
2076
1979
  clear_alloc_root(&mysql->field_alloc);
2077
1980
  mysql->status=MYSQL_STATUS_USE_RESULT;
2078
1981
  mysql->unbuffered_fetch_owner= &result->unbuffered_fetch_cancelled;
2079
 
  DBUG_RETURN(result);                  /* Data is read to be fetched */
 
1982
  return(result);                       /* Data is read to be fetched */
2080
1983
}
2081
1984
 
2082
1985
 
2087
1990
MYSQL_ROW STDCALL
2088
1991
mysql_fetch_row(MYSQL_RES *res)
2089
1992
{
2090
 
  DBUG_ENTER("mysql_fetch_row");
2091
1993
  if (!res->data)
2092
1994
  {                                             /* Unbufferred fetch */
2093
1995
    if (!res->eof)
2103
2005
      else if (!(read_one_row(mysql, res->field_count, res->row, res->lengths)))
2104
2006
      {
2105
2007
        res->row_count++;
2106
 
        DBUG_RETURN(res->current_row=res->row);
 
2008
        return(res->current_row=res->row);
2107
2009
      }
2108
 
      DBUG_PRINT("info",("end of data"));
2109
2010
      res->eof=1;
2110
2011
      mysql->status=MYSQL_STATUS_READY;
2111
2012
      /*
2117
2018
      /* Don't clear handle in mysql_free_result */
2118
2019
      res->handle=0;
2119
2020
    }
2120
 
    DBUG_RETURN((MYSQL_ROW) NULL);
 
2021
    return((MYSQL_ROW) NULL);
2121
2022
  }
2122
2023
  {
2123
2024
    MYSQL_ROW tmp;
2124
2025
    if (!res->data_cursor)
2125
2026
    {
2126
 
      DBUG_PRINT("info",("end of data"));
2127
 
      DBUG_RETURN(res->current_row=(MYSQL_ROW) NULL);
 
2027
      return(res->current_row=(MYSQL_ROW) NULL);
2128
2028
    }
2129
2029
    tmp = res->data_cursor->data;
2130
2030
    res->data_cursor = res->data_cursor->next;
2131
 
    DBUG_RETURN(res->current_row=tmp);
 
2031
    return(res->current_row=tmp);
2132
2032
  }
2133
2033
}
2134
2034
 
2155
2055
int STDCALL
2156
2056
mysql_options(MYSQL *mysql,enum mysql_option option, const void *arg)
2157
2057
{
2158
 
  DBUG_ENTER("mysql_option");
2159
 
  DBUG_PRINT("enter",("option: %d",(int) option));
2160
2058
  switch (option) {
2161
2059
  case MYSQL_OPT_CONNECT_TIMEOUT:
2162
2060
    mysql->options.connect_timeout= *(uint*) arg;
2233
2131
      mysql->options.client_flag&= ~CLIENT_SSL_VERIFY_SERVER_CERT;
2234
2132
    break;
2235
2133
  default:
2236
 
    DBUG_RETURN(1);
 
2134
    return(1);
2237
2135
  }
2238
 
  DBUG_RETURN(0);
 
2136
  return(0);
2239
2137
}
2240
2138
 
2241
2139