开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
libmysql.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：69k
源码类别：

MySQL数据库

开发平台：

Visual C++

libmysql.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This library is free software; you can redistribute it and/or
  4.    modify it under the terms of the GNU Library General Public
  5.    License as published by the Free Software Foundation; either
  6.    version 2 of the License, or (at your option) any later version.
  7.    
  8.    This library is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11.    Library General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU Library General Public
  14.    License along with this library; if not, write to the Free
  15.    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16.    MA 02111-1307, USA */
  18. #define DONT_USE_RAID
  19. #if defined(__WIN__) || defined(_WIN32) || defined(_WIN64)
  20. #include <winsock.h>
  21. #include <odbcinst.h>
  22. #endif
  23. #include <global.h>
  24. #include <my_sys.h>
  25. #include <mysys_err.h>
  26. #include <m_string.h>
  27. #include <m_ctype.h>
  28. #include "mysql.h"
  29. #include "mysql_version.h"
  30. #include "mysqld_error.h"
  31. #include "errmsg.h"
  32. #include <violite.h>
  33. #include <sys/stat.h>
  34. #include <signal.h>
  35. #include <time.h>
  36. #ifdef  HAVE_PWD_H
  37. #include <pwd.h>
  38. #endif
  39. #if !defined(MSDOS) && !defined(__WIN__)
  40. #include <sys/socket.h>
  41. #include <netinet/in.h>
  42. #include <arpa/inet.h>
  43. #include <netdb.h>
  44. #ifdef HAVE_SELECT_H
  45. #  include <select.h>
  46. #endif
  47. #ifdef HAVE_SYS_SELECT_H
  48. #include <sys/select.h>
  49. #endif
  50. #endif
  51. #ifdef HAVE_SYS_UN_H
  52. #  include <sys/un.h>
  53. #endif
  54. #if defined(THREAD) && !defined(__WIN__)
  55. #include <my_pthread.h> /* because of signal() */
  56. #endif
  57. #ifndef INADDR_NONE
  58. #define INADDR_NONE -1
  59. #endif
  61. static my_bool mysql_client_init=0;
  62. uint mysql_port=0;
  63. my_string mysql_unix_port=0;
  65. #define CLIENT_CAPABILITIES (CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG | CLIENT_LOCAL_FILES | CLIENT_TRANSACTIONS)
  67. #ifdef __WIN__
  68. #define CONNECT_TIMEOUT 20
  69. #else
  70. #define CONNECT_TIMEOUT 0
  71. #endif
  73. #if defined(MSDOS) || defined(__WIN__)
  74. #define ERRNO WSAGetLastError()
  75. #define perror(A)
  76. #else
  77. #include <errno.h>
  78. #define ERRNO errno
  79. #define SOCKET_ERROR -1
  80. #define closesocket(A) close(A)
  81. #endif
  83. static void mysql_once_init(void);
  84. static MYSQL_DATA *read_rows (MYSQL *mysql,MYSQL_FIELD *fields,
  85.       uint field_count);
  86. static int read_one_row(MYSQL *mysql,uint fields,MYSQL_ROW row,
  87. ulong *lengths);
  88. static void end_server(MYSQL *mysql);
  89. static void read_user_name(char *name);
  90. static void append_wild(char *to,char *end,const char *wild);
  91. static my_bool mysql_reconnect(MYSQL *mysql);
  92. static int send_file_to_server(MYSQL *mysql,const char *filename);
  93. static sig_handler pipe_sig_handler(int sig);
  94. static ulong mysql_sub_escape_string(CHARSET_INFO *charset_info, char *to,
  95.      const char *from, ulong length);
  97. /*
  98.   Let the user specify that we don't want SIGPIPE;  This doesn't however work
  99.   with threaded applications as we can have multiple read in progress.
  100. */
  102. #if !defined(__WIN__) && defined(SIGPIPE) && !defined(THREAD)
  103. #define init_sigpipe_variables  sig_return old_signal_handler=(sig_return) 0;
  104. #define set_sigpipe(mysql)     if ((mysql)->client_flag & CLIENT_IGNORE_SIGPIPE) old_signal_handler=signal(SIGPIPE,pipe_sig_handler)
  105. #define reset_sigpipe(mysql) if ((mysql)->client_flag & CLIENT_IGNORE_SIGPIPE) signal(SIGPIPE,old_signal_handler);
  106. #else
  107. #define init_sigpipe_variables
  108. #define set_sigpipe(mysql)
  109. #define reset_sigpipe(mysql)
  110. #endif
  112. /****************************************************************************
  113. * A modified version of connect().  connect2() allows you to specify
  114. * a timeout value, in seconds, that we should wait until we
  115. * derermine we can't connect to a particular host.  If timeout is 0,
  116. * connect2() will behave exactly like connect().
  117. *
  118. * Base version coded by Steve Bernacki, Jr. <steve@navinet.net>
  119. *****************************************************************************/
  121. static int connect2(my_socket s, const struct sockaddr *name, uint namelen,
  122.     uint timeout)
  123. {
  124. #if defined(__WIN__)
  125.   return connect(s, (struct sockaddr*) name, namelen);
  126. #else
  127.   int flags, res, s_err;
  128.   SOCKOPT_OPTLEN_TYPE s_err_size = sizeof(uint);
  129.   fd_set sfds;
  130.   struct timeval tv;
  131.   time_t start_time, now_time;
  133.   /* If they passed us a timeout of zero, we should behave
  134.    * exactly like the normal connect() call does.
  135.    */
  137.   if (timeout == 0)
  138.     return connect(s, (struct sockaddr*) name, namelen);
  140.   flags = fcntl(s, F_GETFL, 0);   /* Set socket to not block */
  141. #ifdef O_NONBLOCK
  142.   fcntl(s, F_SETFL, flags | O_NONBLOCK);  /* and save the flags..  */
  143. #endif
  145.   res = connect(s, (struct sockaddr*) name, namelen);
  146.   s_err = errno; /* Save the error... */
  147.   fcntl(s, F_SETFL, flags);
  148.   if ((res != 0) && (s_err != EINPROGRESS))
  149.   {
  150.     errno = s_err; /* Restore it */
  151.     return(-1);
  152.   }
  153.   if (res == 0) /* Connected quickly! */
  154.     return(0);
  156.   /* Otherwise, our connection is "in progress."  We can use
  157.    * the select() call to wait up to a specified period of time
  158.    * for the connection to suceed.  If select() returns 0
  159.    * (after waiting howevermany seconds), our socket never became
  160.    * writable (host is probably unreachable.)  Otherwise, if
  161.    * select() returns 1, then one of two conditions exist:
  162.    *
  163.    * 1. An error occured.  We use getsockopt() to check for this.
  164.    * 2. The connection was set up sucessfully: getsockopt() will
  165.    * return 0 as an error.
  166.    *
  167.    * Thanks goes to Andrew Gierth <andrew@erlenstar.demon.co.uk>
  168.    * who posted this method of timing out a connect() in
  169.    * comp.unix.programmer on August 15th, 1997.
  170.    */
  172.   FD_ZERO(&sfds);
  173.   FD_SET(s, &sfds);
  174.   /*
  175.    * select could be interrupted by a signal, and if it is, 
  176.    * the timeout should be adjusted and the select restarted
  177.    * to work around OSes that don't restart select and 
  178.    * implementations of select that don't adjust tv upon
  179.    * failure to reflect the time remaining
  180.    */
  181.   start_time = time(NULL);
  182.   for (;;)
  183.   {
  184.     tv.tv_sec = (long) timeout;
  185.     tv.tv_usec = 0;
  186.     if ((res = select(s+1, NULL, &sfds, NULL, &tv)) >= 0)
  187.       break;
  188.     now_time=time(NULL);
  189.     timeout-= (uint) (now_time - start_time);
  190.     if (errno != EINTR || (int) timeout <= 0)
  191.       return -1;
  192.   }
  194.   /* select() returned something more interesting than zero, let's
  195.    * see if we have any errors.  If the next two statements pass,
  196.    * we've got an open socket!
  197.    */
  199.   s_err=0;
  200.   if (getsockopt(s, SOL_SOCKET, SO_ERROR, (char*) &s_err, &s_err_size) != 0)
  201.     return(-1);
  203.   if (s_err)
  204.   { /* getsockopt could succeed */
  205.     errno = s_err;
  206.     return(-1); /* but return an error... */
  207.   }
  208.   return(0); /* It's all good! */
  209. #endif
  210. }
  212. /*
  213. ** Create a named pipe connection
  214. */
  216. #ifdef __WIN__
  218. HANDLE create_named_pipe(NET *net, uint connect_timeout, char **arg_host,
  219.  char **arg_unix_socket)
  220. {
  221.   HANDLE hPipe=INVALID_HANDLE_VALUE;
  222.   char szPipeName [ 257 ];
  223.   DWORD dwMode;
  224.   int i;
  225.   my_bool testing_named_pipes=0;
  226.   char *host= *arg_host, *unix_socket= *arg_unix_socket;
  228.   if ( ! unix_socket || (unix_socket)[0] == 0x00)
  229.     unix_socket = mysql_unix_port;
  230.   if (!host || !strcmp(host,LOCAL_HOST))
  231.     host=LOCAL_HOST_NAMEDPIPE;
  233.   sprintf( szPipeName, "\\%s\pipe\%s", host, unix_socket);
  234.   DBUG_PRINT("info",("Server name: '%s'.  Named Pipe: %s",
  235.      host, unix_socket));
  237.   for (i=0 ; i < 100 ; i++) /* Don't retry forever */
  238.   {
  239.     if ((hPipe = CreateFile(szPipeName,
  240.     GENERIC_READ | GENERIC_WRITE,
  241.     0,
  242.     NULL,
  243.     OPEN_EXISTING,
  244.     0,
  245.     NULL )) != INVALID_HANDLE_VALUE)
  246.       break;
  247.     if (GetLastError() != ERROR_PIPE_BUSY)
  248.     {
  249.       net->last_errno=CR_NAMEDPIPEOPEN_ERROR;
  250.       sprintf(net->last_error,ER(net->last_errno),host, unix_socket,
  251.       (ulong) GetLastError());
  252.       return INVALID_HANDLE_VALUE;
  253.     }
  254.     /* wait for for an other instance */
  255.     if (! WaitNamedPipe(szPipeName, connect_timeout*1000) )
  256.     {
  257.       net->last_errno=CR_NAMEDPIPEWAIT_ERROR;
  258.       sprintf(net->last_error,ER(net->last_errno),host, unix_socket,
  259.       (ulong) GetLastError());
  260.       return INVALID_HANDLE_VALUE;
  261.     }
  262.   }
  263.   if (hPipe == INVALID_HANDLE_VALUE)
  264.   {
  265.     net->last_errno=CR_NAMEDPIPEOPEN_ERROR;
  266.     sprintf(net->last_error,ER(net->last_errno),host, unix_socket,
  267.     (ulong) GetLastError());
  268.     return INVALID_HANDLE_VALUE;
  269.   }
  270.   dwMode = PIPE_READMODE_BYTE | PIPE_WAIT;
  271.   if ( !SetNamedPipeHandleState(hPipe, &dwMode, NULL, NULL) )
  272.   {
  273.     CloseHandle( hPipe );
  274.     net->last_errno=CR_NAMEDPIPESETSTATE_ERROR;
  275.     sprintf(net->last_error,ER(net->last_errno),host, unix_socket,
  276.     (ulong) GetLastError());
  277.     return INVALID_HANDLE_VALUE;
  278.   }
  279.   *arg_host=host ; *arg_unix_socket=unix_socket; /* connect arg */
  280.   return (hPipe);
  281. }
  282. #endif
  285. /*****************************************************************************
  286. ** read a packet from server. Give error message if socket was down
  287. ** or packet is an error message
  288. *****************************************************************************/
  290. static uint
  291. net_safe_read(MYSQL *mysql)
  292. {
  293.   NET *net= &mysql->net;
  294.   uint len=0;
  295.   init_sigpipe_variables
  297.   /* Don't give sigpipe errors if the client doesn't want them */
  298.   set_sigpipe(mysql);
  299.   if (net->vio != 0)
  300.     len=my_net_read(net);
  301.   reset_sigpipe(mysql);
  303.   if (len == packet_error || len == 0)
  304.   {
  305.     DBUG_PRINT("error",("Wrong connection or packet. fd: %s  len: %d",
  306. vio_description(net->vio),len));
  307.     end_server(mysql);
  308.     net->last_errno=(net->last_errno == ER_NET_PACKET_TOO_LARGE ? 
  309.      CR_NET_PACKET_TOO_LARGE:
  310.      CR_SERVER_LOST);
  311.     strmov(net->last_error,ER(net->last_errno));
  312.     return(packet_error);
  313.   }
  314.   if (net->read_pos[0] == 255)
  315.   {
  316.     if (len > 3)
  317.     {
  318.       char *pos=(char*) net->read_pos+1;
  319.       if (mysql->protocol_version > 9)
  320.       { /* New client protocol */
  321. net->last_errno=uint2korr(pos);
  322. pos+=2;
  323. len-=2;
  324.       }
  325.       else
  326.       {
  327. net->last_errno=CR_UNKNOWN_ERROR;
  328. len--;
  329.       }
  330.       (void) strmake(net->last_error,(char*) pos,
  331.      min(len,sizeof(net->last_error)-1));
  332.     }
  333.     else
  334.     {
  335.       net->last_errno=CR_UNKNOWN_ERROR;
  336.       (void) strmov(net->last_error,ER(net->last_errno));
  337.     }
  338.     DBUG_PRINT("error",("Got error: %d (%s)", net->last_errno,
  339. net->last_error));
  340.     return(packet_error);
  341.   }
  342.   return len;
  343. }
  346. /* Get the length of next field. Change parameter to point at fieldstart */
  347. static ulong
  348. net_field_length(uchar **packet)
  349. {
  350.   reg1 uchar *pos= *packet;
  351.   if (*pos < 251)
  352.   {
  353.     (*packet)++;
  354.     return (ulong) *pos;
  355.   }
  356.   if (*pos == 251)
  357.   {
  358.     (*packet)++;
  359.     return NULL_LENGTH;
  360.   }
  361.   if (*pos == 252)
  362.   {
  363.     (*packet)+=3;
  364.     return (ulong) uint2korr(pos+1);
  365.   }
  366.   if (*pos == 253)
  367.   {
  368.     (*packet)+=4;
  369.     return (ulong) uint3korr(pos+1);
  370.   }
  371.   (*packet)+=9; /* Must be 254 when here */
  372.   return (ulong) uint4korr(pos+1);
  373. }
  375. /* Same as above, but returns ulonglong values */
  377. static my_ulonglong
  378. net_field_length_ll(uchar **packet)
  379. {
  380.   reg1 uchar *pos= *packet;
  381.   if (*pos < 251)
  382.   {
  383.     (*packet)++;
  384.     return (my_ulonglong) *pos;
  385.   }
  386.   if (*pos == 251)
  387.   {
  388.     (*packet)++;
  389.     return (my_ulonglong) NULL_LENGTH;
  390.   }
  391.   if (*pos == 252)
  392.   {
  393.     (*packet)+=3;
  394.     return (my_ulonglong) uint2korr(pos+1);
  395.   }
  396.   if (*pos == 253)
  397.   {
  398.     (*packet)+=4;
  399.     return (my_ulonglong) uint3korr(pos+1);
  400.   }
  401.   (*packet)+=9; /* Must be 254 when here */
  402. #ifdef NO_CLIENT_LONGLONG
  403.   return (my_ulonglong) uint4korr(pos+1);
  404. #else
  405.   return (my_ulonglong) uint8korr(pos+1);
  406. #endif
  407. }
  410. static void free_rows(MYSQL_DATA *cur)
  411. {
  412.   if (cur)
  413.   {
  414.     free_root(&cur->alloc,MYF(0));
  415.     my_free((gptr) cur,MYF(0));
  416.   }
  417. }
  420. static int
  421. simple_command(MYSQL *mysql,enum enum_server_command command, const char *arg,
  422.        uint length, my_bool skipp_check)
  423. {
  424.   NET *net= &mysql->net;
  425.   int result= -1;
  426.   init_sigpipe_variables
  428.   /* Don't give sigpipe errors if the client doesn't want them */
  429.   set_sigpipe(mysql);
  430.   if (mysql->net.vio == 0)
  431.   { /* Do reconnect if possible */
  432.     if (mysql_reconnect(mysql))
  433.     {
  434.       net->last_errno=CR_SERVER_GONE_ERROR;
  435.       strmov(net->last_error,ER(net->last_errno));
  436.       goto end;
  437.     }
  438.   }
  439.   if (mysql->status != MYSQL_STATUS_READY)
  440.   {
  441.     strmov(net->last_error,ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
  442.     goto end;
  443.   }
  445.   mysql->net.last_error[0]=0;
  446.   mysql->net.last_errno=0;
  447.   mysql->info=0;
  448.   mysql->affected_rows= ~(my_ulonglong) 0;
  449.   net_clear(net); /* Clear receive buffer */
  450.   if (!arg)
  451.     arg="";
  453.   if (net_write_command(net,(uchar) command,arg,
  454. length ? length : (ulong) strlen(arg)))
  455.   {
  456.     DBUG_PRINT("error",("Can't send command to server. Error: %d",errno));
  457.     end_server(mysql);
  458.     if (mysql_reconnect(mysql) ||
  459. net_write_command(net,(uchar) command,arg,
  460.   length ? length : (ulong) strlen(arg)))
  461.     {
  462.       net->last_errno=CR_SERVER_GONE_ERROR;
  463.       strmov(net->last_error,ER(net->last_errno));
  464.       goto end;
  465.     }
  466.   }
  467.   result=0;
  468.   if (!skipp_check)
  469.     result= ((mysql->packet_length=net_safe_read(mysql)) == packet_error ?
  470.      -1 : 0);
  471.  end:
  472.   reset_sigpipe(mysql);
  473.   return result;
  474. }
  477. static void free_old_query(MYSQL *mysql)
  478. {
  479.   DBUG_ENTER("free_old_query");
  480.   if (mysql->fields)
  481.     free_root(&mysql->field_alloc,MYF(0));
  482.   init_alloc_root(&mysql->field_alloc,8192,0); /* Assume rowlength < 8192 */
  483.   mysql->fields=0;
  484.   mysql->field_count=0; /* For API */
  485.   DBUG_VOID_RETURN;
  486. }
  488. #if defined(HAVE_GETPWUID) && defined(NO_GETPWUID_DECL)
  489. struct passwd *getpwuid(uid_t);
  490. char* getlogin(void);
  491. #endif
  493. #if !defined(MSDOS) && ! defined(VMS) && !defined(__WIN__)
  494. static void read_user_name(char *name)
  495. {
  496.   DBUG_ENTER("read_user_name");
  497.   if (geteuid() == 0)
  498.     (void) strmov(name,"root"); /* allow use of surun */
  499.   else
  500.   {
  501. #ifdef HAVE_GETPWUID
  502.     struct passwd *skr;
  503.     const char *str;
  504.     if ((str=getlogin()) == NULL)
  505.     {
  506.       if ((skr=getpwuid(geteuid())) != NULL)
  507. str=skr->pw_name;
  508.       else if (!(str=getenv("USER")) && !(str=getenv("LOGNAME")) &&
  509.        !(str=getenv("LOGIN")))
  510. str="UNKNOWN_USER";
  511.     }
  512.     (void) strmake(name,str,USERNAME_LENGTH);
  513. #elif HAVE_CUSERID
  514.     (void) cuserid(name);
  515. #else
  516.     strmov(name,"UNKNOWN_USER");
  517. #endif
  518.   }
  519.   DBUG_VOID_RETURN;
  520. }
  522. #else /* If MSDOS || VMS */
  524. static void read_user_name(char *name)
  525. {
  526.   char *str=getenv("USER"); /* ODBC will send user variable */
  527.   strmake(name,str ? str : "ODBC", USERNAME_LENGTH);
  528. }
  530. #endif
  532. #ifdef __WIN__
  533. static my_bool is_NT(void)
  534. {
  535.   char *os=getenv("OS");
  536.   return (os && !strcmp(os, "Windows_NT")) ? 1 : 0;
  537. }
  538. #endif
  540. /*
  541. ** Expand wildcard to a sql string
  542. */
  544. static void
  545. append_wild(char *to, char *end, const char *wild)
  546. {
  547.   end-=5; /* Some extra */
  548.   if (wild && wild[0])
  549.   {
  550.     to=strmov(to," like '");
  551.     while (*wild && to < end)
  552.     {
  553.       if (*wild == '\' || *wild == ''')
  554. *to++='\';
  555.       *to++= *wild++;
  556.     }
  557.     if (*wild) /* Too small buffer */
  558.       *to++='%'; /* Nicer this way */
  559.     to[0]=''';
  560.     to[1]=0;
  561.   }
  562. }
  566. /**************************************************************************
  567. ** Init debugging if MYSQL_DEBUG environment variable is found
  568. **************************************************************************/
  570. void STDCALL
  571. mysql_debug(const char *debug __attribute__((unused)))
  572. {
  573. #ifndef DBUG_OFF
  574.   char *env;
  575.   if (_db_on_)
  576.     return; /* Already using debugging */
  577.   if (debug)
  578.   {
  579.     DEBUGGER_ON;
  580.     DBUG_PUSH(debug);
  581.   }
  582.   else if ((env = getenv("MYSQL_DEBUG")))
  583.   {
  584.     DEBUGGER_ON;
  585.     DBUG_PUSH(env);
  586. #if !defined(_WINVER) && !defined(WINVER)
  587.     puts("n-------------------------------------------------------");
  588.     puts("MYSQL_DEBUG found. libmysql started with the following:");
  589.     puts(env);
  590.     puts("-------------------------------------------------------n");
  591. #else
  592.     {
  593.       char buff[80];
  594.       strmov(strmov(buff,"libmysql: "),env);
  595.       MessageBox((HWND) 0,"Debugging variable MYSQL_DEBUG used",buff,MB_OK);
  596.     }
  597. #endif
  598.   }
  599. #endif
  600. }
  603. /**************************************************************************
  604. ** Close the server connection if we get a SIGPIPE
  605.    ARGSUSED
  606. **************************************************************************/
  608. static sig_handler
  609. pipe_sig_handler(int sig __attribute__((unused)))
  610. {
  611.   DBUG_PRINT("info",("Hit by signal %d",sig));
  612. #ifdef DONT_REMEMBER_SIGNAL
  613.   (void) signal(SIGPIPE,pipe_sig_handler);
  614. #endif
  615. }
  618. /**************************************************************************
  619. ** Shut down connection
  620. **************************************************************************/
  622. static void
  623. end_server(MYSQL *mysql)
  624. {
  625.   DBUG_ENTER("end_server");
  626.   if (mysql->net.vio != 0)
  627.   {
  628.     init_sigpipe_variables
  629.     DBUG_PRINT("info",("Net: %s", vio_description(mysql->net.vio)));
  630.     set_sigpipe(mysql);
  631.     vio_delete(mysql->net.vio);
  632.     reset_sigpipe(mysql);
  633.     mysql->net.vio= 0;          /* Marker */
  634.   }
  635.   net_end(&mysql->net);
  636.   free_old_query(mysql);
  637.   DBUG_VOID_RETURN;
  638. }
  641. void STDCALL
  642. mysql_free_result(MYSQL_RES *result)
  643. {
  644.   DBUG_ENTER("mysql_free_result");
  645.   DBUG_PRINT("enter",("mysql_res: %lx",result));
  646.   if (result)
  647.   {
  648.     if (result->handle && result->handle->status == MYSQL_STATUS_USE_RESULT)
  649.     {
  650.       DBUG_PRINT("warning",("Not all rows in set were read; Ignoring rows"));
  651.       for (;;)
  652.       {
  653. uint pkt_len;
  654. if ((pkt_len=(uint) net_safe_read(result->handle)) == packet_error)
  655.   break;
  656. if (pkt_len == 1 && result->handle->net.read_pos[0] == 254)
  657.   break; /* End of data */
  658.       }
  659.       result->handle->status=MYSQL_STATUS_READY;
  660.     }
  661.     free_rows(result->data);
  662.     if (result->fields)
  663.       free_root(&result->field_alloc,MYF(0));
  664.     if (result->row)
  665.       my_free((gptr) result->row,MYF(0));
  666.     my_free((gptr) result,MYF(0));
  667.   }
  668.   DBUG_VOID_RETURN;
  669. }
  672. /****************************************************************************
  673. ** Get options from my.cnf
  674. ****************************************************************************/
  676. static const char *default_options[]=
  677. {"port","socket","compress","password","pipe", "timeout", "user",
  678.  "init-command", "host", "database", "debug", "return-found-rows",
  679.  "ssl-key" ,"ssl-cert" ,"ssl-ca" ,"ssl-capath",
  680.  "character-set-dir", "default-character-set", "interactive-timeout",
  681.  "connect_timeout",
  682.  NullS
  683. };
  685. static TYPELIB option_types={array_elements(default_options)-1,
  686.      "options",default_options};
  688. static void mysql_read_default_options(struct st_mysql_options *options,
  689.        const char *filename,const char *group)
  690. {
  691.   int argc;
  692.   char *argv_buff[1],**argv;
  693.   const char *groups[3];
  694.   DBUG_ENTER("mysql_read_default_options");
  695.   DBUG_PRINT("enter",("file: %s  group: %s",filename,group ? group :"NULL"));
  697.   argc=1; argv=argv_buff; argv_buff[0]= (char*) "client";
  698.   groups[0]= (char*) "client"; groups[1]= (char*) group; groups[2]=0;
  700.   load_defaults(filename, groups, &argc, &argv);
  701.   if (argc != 1) /* If some default option */
  702.   {
  703.     char **option=argv;
  704.     while (*++option)
  705.     {
  706.       /* DBUG_PRINT("info",("option: %s",option[0])); */
  707.       if (option[0][0] == '-' && option[0][1] == '-')
  708.       {
  709. char *end=strcend(*option,'=');
  710. char *opt_arg=0;
  711. if (*end)
  712. {
  713.   opt_arg=end+1;
  714.   *end=0; /* Remove '=' */
  715. }
  716. switch (find_type(*option+2,&option_types,2)) {
  717. case 1: /* port */
  718.   if (opt_arg)
  719.     options->port=atoi(opt_arg);
  720.   break;
  721. case 2: /* socket */
  722.   if (opt_arg)
  723.   {
  724.     my_free(options->unix_socket,MYF(MY_ALLOW_ZERO_PTR));
  725.     options->unix_socket=my_strdup(opt_arg,MYF(MY_WME));
  726.   }
  727.   break;
  728. case 3: /* compress */
  729.   options->compress=1;
  730.   break;
  731. case 4: /* password */
  732.   if (opt_arg)
  733.   {
  734.     my_free(options->password,MYF(MY_ALLOW_ZERO_PTR));
  735.     options->password=my_strdup(opt_arg,MYF(MY_WME));
  736.   }
  737.   break;
  738. case 5: /* pipe */
  739.   options->named_pipe=1; /* Force named pipe */
  740.   break;
  741. case 20: /* connect_timeout */
  742. case 6: /* timeout */
  743.   if (opt_arg)
  744.     options->connect_timeout=atoi(opt_arg);
  745.   break;
  746. case 7: /* user */
  747.   if (opt_arg)
  748.   {
  749.     my_free(options->user,MYF(MY_ALLOW_ZERO_PTR));
  750.     options->user=my_strdup(opt_arg,MYF(MY_WME));
  751.   }
  752.   break;
  753. case 8: /* init-command */
  754.   if (opt_arg)
  755.   {
  756.     my_free(options->init_command,MYF(MY_ALLOW_ZERO_PTR));
  757.     options->init_command=my_strdup(opt_arg,MYF(MY_WME));
  758.   }
  759.   break;
  760. case 9: /* host */
  761.   if (opt_arg)
  762.   {
  763.     my_free(options->host,MYF(MY_ALLOW_ZERO_PTR));
  764.     options->host=my_strdup(opt_arg,MYF(MY_WME));
  765.   }
  766.   break;
  767. case 10: /* database */
  768.   if (opt_arg)
  769.   {
  770.     my_free(options->db,MYF(MY_ALLOW_ZERO_PTR));
  771.     options->db=my_strdup(opt_arg,MYF(MY_WME));
  772.   }
  773.   break;
  774. case 11: /* debug */
  775.   mysql_debug(opt_arg ? opt_arg : "d:t:o,/tmp/client.trace");
  776.   break;
  777. case 12: /* return-found-rows */
  778.   options->client_flag|=CLIENT_FOUND_ROWS;
  779.   break;
  780. #ifdef HAVE_OPENSSL
  781. case 13: /* ssl_key */
  782.   my_free(options->ssl_key, MYF(MY_ALLOW_ZERO_PTR));
  783.           options->ssl_key = my_strdup(opt_arg, MYF(MY_WME));
  784.           break;
  785. case 14: /* ssl_cert */
  786.   my_free(options->ssl_cert, MYF(MY_ALLOW_ZERO_PTR));
  787.           options->ssl_cert = my_strdup(opt_arg, MYF(MY_WME));
  788.           break;
  789. case 15: /* ssl_ca */
  790.   my_free(options->ssl_ca, MYF(MY_ALLOW_ZERO_PTR));
  791.           options->ssl_ca = my_strdup(opt_arg, MYF(MY_WME));
  792.           break;
  793. case 16: /* ssl_capath */
  794.   my_free(options->ssl_capath, MYF(MY_ALLOW_ZERO_PTR));
  795.           options->ssl_capath = my_strdup(opt_arg, MYF(MY_WME));
  796.           break;
  797. #else
  798. case 13: /* Ignore SSL options */
  799. case 14:
  800. case 15:
  801. case 16:
  802.   break;
  803. #endif /* HAVE_OPENSSL */
  804. case 17: /* charset-lib */
  805.   my_free(options->charset_dir,MYF(MY_ALLOW_ZERO_PTR));
  806.           options->charset_dir = my_strdup(opt_arg, MYF(MY_WME));
  807.   break;
  808. case 18:
  809.   my_free(options->charset_name,MYF(MY_ALLOW_ZERO_PTR));
  810.           options->charset_name = my_strdup(opt_arg, MYF(MY_WME));
  811.   break;
  812. case 19: /* Interactive-timeout */
  813.   options->client_flag|=CLIENT_INTERACTIVE;
  814.   break;
  815. default:
  816.   DBUG_PRINT("warning",("unknown option: %s",option[0]));
  817. }
  818.       }
  819.     }
  820.   }
  821.   free_defaults(argv);
  822.   DBUG_VOID_RETURN;
  823. }
  826. /***************************************************************************
  827. ** Change field rows to field structs
  828. ***************************************************************************/
  830. static MYSQL_FIELD *
  831. unpack_fields(MYSQL_DATA *data,MEM_ROOT *alloc,uint fields,
  832.       my_bool default_value, my_bool long_flag_protocol)
  833. {
  834.   MYSQL_ROWS *row;
  835.   MYSQL_FIELD *field,*result;
  836.   DBUG_ENTER("unpack_fields");
  838.   field=result=(MYSQL_FIELD*) alloc_root(alloc,sizeof(MYSQL_FIELD)*fields);
  839.   if (!result)
  840.     DBUG_RETURN(0);
  842.   for (row=data->data; row ; row = row->next,field++)
  843.   {
  844.     field->table=  strdup_root(alloc,(char*) row->data[0]);
  845.     field->name=   strdup_root(alloc,(char*) row->data[1]);
  846.     field->length= (uint) uint3korr(row->data[2]);
  847.     field->type=   (enum enum_field_types) (uchar) row->data[3][0];
  848.     if (long_flag_protocol)
  849.     {
  850.       field->flags=   uint2korr(row->data[4]);
  851.       field->decimals=(uint) (uchar) row->data[4][2];
  852.     }
  853.     else
  854.     {
  855.       field->flags=   (uint) (uchar) row->data[4][0];
  856.       field->decimals=(uint) (uchar) row->data[4][1];
  857.     }
  858.     if (INTERNAL_NUM_FIELD(field))
  859.       field->flags|= NUM_FLAG;
  860.     if (default_value && row->data[5])
  861.       field->def=strdup_root(alloc,(char*) row->data[5]);
  862.     else
  863.       field->def=0;
  864.     field->max_length= 0;
  865.   }
  866.   free_rows(data); /* Free old data */
  867.   DBUG_RETURN(result);
  868. }
  871. /* Read all rows (fields or data) from server */
  873. static MYSQL_DATA *read_rows(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
  874.      uint fields)
  875. {
  876.   uint field,pkt_len;
  877.   ulong len;
  878.   uchar *cp;
  879.   char *to;
  880.   MYSQL_DATA *result;
  881.   MYSQL_ROWS **prev_ptr,*cur;
  882.   NET *net = &mysql->net;
  883.   DBUG_ENTER("read_rows");
  885.   if ((pkt_len=(uint) net_safe_read(mysql)) == packet_error)
  886.     DBUG_RETURN(0);
  887.   if (!(result=(MYSQL_DATA*) my_malloc(sizeof(MYSQL_DATA),
  888.        MYF(MY_WME | MY_ZEROFILL))))
  889.   {
  890.     net->last_errno=CR_OUT_OF_MEMORY;
  891.     strmov(net->last_error,ER(net->last_errno));
  892.     DBUG_RETURN(0);
  893.   }
  894.   init_alloc_root(&result->alloc,8192,0); /* Assume rowlength < 8192 */
  895.   result->alloc.min_malloc=sizeof(MYSQL_ROWS);
  896.   prev_ptr= &result->data;
  897.   result->rows=0;
  898.   result->fields=fields;
  900.   while (*(cp=net->read_pos) != 254 || pkt_len != 1)
  901.   {
  902.     result->rows++;
  903.     if (!(cur= (MYSQL_ROWS*) alloc_root(&result->alloc,
  904.     sizeof(MYSQL_ROWS))) ||
  905. !(cur->data= ((MYSQL_ROW)
  906.       alloc_root(&result->alloc,
  907.      (fields+1)*sizeof(char *)+pkt_len))))
  908.     {
  909.       free_rows(result);
  910.       net->last_errno=CR_OUT_OF_MEMORY;
  911.       strmov(net->last_error,ER(net->last_errno));
  912.       DBUG_RETURN(0);
  913.     }
  914.     *prev_ptr=cur;
  915.     prev_ptr= &cur->next;
  916.     to= (char*) (cur->data+fields+1);
  917.     for (field=0 ; field < fields ; field++)
  918.     {
  919.       if ((len=(ulong) net_field_length(&cp)) == NULL_LENGTH)
  920.       { /* null field */
  921. cur->data[field] = 0;
  922.       }
  923.       else
  924.       {
  925. cur->data[field] = to;
  926. memcpy(to,(char*) cp,len); to[len]=0;
  927. to+=len+1;
  928. cp+=len;
  929. if (mysql_fields)
  930. {
  931.   if (mysql_fields[field].max_length < len)
  932.     mysql_fields[field].max_length=len;
  933. }
  934.       }
  935.     }
  936.     cur->data[field]=to; /* End of last field */
  937.     if ((pkt_len=net_safe_read(mysql)) == packet_error)
  938.     {
  939.       free_rows(result);
  940.       DBUG_RETURN(0);
  941.     }
  942.   }
  943.   *prev_ptr=0; /* last pointer is null */
  944.   DBUG_PRINT("exit",("Got %d rows",result->rows));
  945.   DBUG_RETURN(result);
  946. }
  949. /*
  950. ** Read one row. Uses packet buffer as storage for fields.
  951. ** When next packet is read, the previous field values are destroyed
  952. */
  955. static int
  956. read_one_row(MYSQL *mysql,uint fields,MYSQL_ROW row, ulong *lengths)
  957. {
  958.   uint field;
  959.   ulong pkt_len,len;
  960.   uchar *pos,*prev_pos;
  962.   if ((pkt_len=(uint) net_safe_read(mysql)) == packet_error)
  963.     return -1;
  964.   if (pkt_len == 1 && mysql->net.read_pos[0] == 254)
  965.     return 1; /* End of data */
  966.   prev_pos= 0; /* allowed to write at packet[-1] */
  967.   pos=mysql->net.read_pos;
  968.   for (field=0 ; field < fields ; field++)
  969.   {
  970.     if ((len=(ulong) net_field_length(&pos)) == NULL_LENGTH)
  971.     { /* null field */
  972.       row[field] = 0;
  973.       *lengths++=0;
  974.     }
  975.     else
  976.     {
  977.       row[field] = (char*) pos;
  978.       pos+=len;
  979.       *lengths++=len;
  980.     }
  981.     if (prev_pos)
  982.       *prev_pos=0; /* Terminate prev field */
  983.     prev_pos=pos;
  984.   }
  985.   row[field]=(char*) prev_pos+1; /* End of last field */
  986.   *prev_pos=0; /* Terminate last field */
  987.   return 0;
  988. }
  990. /****************************************************************************
  991. ** Init MySQL structure or allocate one
  992. ****************************************************************************/
  994. MYSQL * STDCALL
  995. mysql_init(MYSQL *mysql)
  996. {
  997.   mysql_once_init();
  998.   if (!mysql)
  999.   {
  1000.     if (!(mysql=(MYSQL*) my_malloc(sizeof(*mysql),MYF(MY_WME | MY_ZEROFILL))))
  1001.       return 0;
  1002.     mysql->free_me=1;
  1003.     mysql->net.vio = 0;
  1004.   }
  1005.   else
  1006.     bzero((char*) (mysql),sizeof(*(mysql)));
  1007.   mysql->options.connect_timeout=CONNECT_TIMEOUT;
  1008. #if defined(SIGPIPE) && defined(THREAD)
  1009.   if (!((mysql)->client_flag & CLIENT_IGNORE_SIGPIPE))
  1010.     (void) signal(SIGPIPE,pipe_sig_handler);
  1011. #endif
  1012.   return mysql;
  1013. }
  1016. static void mysql_once_init()
  1017. {
  1018.   if (!mysql_client_init)
  1019.   {
  1020.     mysql_client_init=1;
  1021.     my_init(); /* Will init threads */
  1022.     init_client_errs();
  1023.     if (!mysql_port)
  1024.     {
  1025.       mysql_port = MYSQL_PORT;
  1026. #ifndef MSDOS
  1027.       {
  1028. struct servent *serv_ptr;
  1029. char *env;
  1030. if ((serv_ptr = getservbyname("mysql", "tcp")))
  1031.   mysql_port = (uint) ntohs((ushort) serv_ptr->s_port);
  1032. if ((env = getenv("MYSQL_TCP_PORT")))
  1033.   mysql_port =(uint) atoi(env);
  1034.       }
  1035. #endif
  1036.     }
  1037.     if (!mysql_unix_port)
  1038.     {
  1039.       char *env;
  1040. #ifdef __WIN__
  1041.       mysql_unix_port = (char*) MYSQL_NAMEDPIPE;
  1042. #else
  1043.       mysql_unix_port = (char*) MYSQL_UNIX_ADDR;
  1044. #endif
  1045.       if ((env = getenv("MYSQL_UNIX_PORT")))
  1046. mysql_unix_port = env;
  1047.     }
  1048.     mysql_debug(NullS);
  1049. #if defined(SIGPIPE) && !defined(THREAD)
  1050.     (void) signal(SIGPIPE,SIG_IGN);
  1051. #endif
  1052.   }
  1053. #ifdef THREAD
  1054.   else
  1055.     my_thread_init();         /* Init if new thread */
  1056. #endif
  1057. }
  1059. #ifdef HAVE_OPENSSL
  1060. /**************************************************************************
  1061. ** Fill in SSL part of MYSQL structure and set 'use_ssl' flag.
  1062. ** NB! Errors are not reported until you do mysql_real_connect.
  1063. **************************************************************************/
  1065. int STDCALL
  1066. mysql_ssl_set(MYSQL *mysql, const char *key, const char *cert,
  1067.               const char *ca, const char *capath)
  1068. {
  1069.   mysql->options.ssl_key = key==0 ? 0 : my_strdup(key,MYF(0));
  1070.   mysql->options.ssl_cert = cert==0 ? 0 : my_strdup(cert,MYF(0));
  1071.   mysql->options.ssl_ca = ca==0 ? 0 : my_strdup(ca,MYF(0));
  1072.   mysql->options.ssl_capath = capath==0 ? 0 : my_strdup(capath,MYF(0));
  1073.   mysql->options.use_ssl = true;
  1074.   mysql->connector_fd = new_VioSSLConnectorFd(key, cert, ca, capath);
  1075.   return 0;
  1076. }
  1078. /**************************************************************************
  1079. **************************************************************************/
  1081. char * STDCALL
  1082. mysql_ssl_cipher(MYSQL *mysql)
  1083. {
  1084.   return (char *)mysql->net.vio->cipher_description();
  1085. }
  1088. /**************************************************************************
  1089. ** Free strings in the SSL structure and clear 'use_ssl' flag.
  1090. ** NB! Errors are not reported until you do mysql_real_connect.
  1091. **************************************************************************/
  1093. int STDCALL
  1094. mysql_ssl_clear(MYSQL *mysql)
  1095. {
  1096.   my_free(mysql->options.ssl_key, MYF(MY_ALLOW_ZERO_PTR));
  1097.   my_free(mysql->options.ssl_cert, MYF(MY_ALLOW_ZERO_PTR));
  1098.   my_free(mysql->options.ssl_ca, MYF(MY_ALLOW_ZERO_PTR));
  1099.   my_free(mysql->options.ssl_capath, MYF(MY_ALLOW_ZERO_PTR));
  1100.   mysql->options.ssl_key = 0;
  1101.   mysql->options.ssl_cert = 0;
  1102.   mysql->options.ssl_ca = 0;
  1103.   mysql->options.ssl_capath = 0;
  1104.   mysql->options.use_ssl = false;
  1105.   mysql->connector_fd->delete();
  1106.   mysql->connector_fd = 0;
  1107.   return 0;
  1108. }
  1109. #endif /* HAVE_OPENSSL */
  1111. /**************************************************************************
  1112. ** Connect to sql server
  1113. ** If host == 0 then use localhost
  1114. **************************************************************************/
  1116. MYSQL * STDCALL
  1117. mysql_connect(MYSQL *mysql,const char *host,
  1118.       const char *user, const char *passwd)
  1119. {
  1120.   MYSQL *res;
  1121.   mysql=mysql_init(mysql); /* Make it thread safe */
  1122.   {
  1123.     DBUG_ENTER("mysql_connect");
  1124.     if (!(res=mysql_real_connect(mysql,host,user,passwd,NullS,0,NullS,0)))
  1125.     {
  1126.       if (mysql->free_me)
  1127. my_free((gptr) mysql,MYF(0));
  1128.     }
  1129.     DBUG_RETURN(res);
  1130.   }
  1131. }
  1134. /*
  1135. ** Note that the mysql argument must be initialized with mysql_init()
  1136. ** before calling mysql_real_connect !
  1137. */
  1139. MYSQL * STDCALL
  1140. mysql_real_connect(MYSQL *mysql,const char *host, const char *user,
  1141.    const char *passwd, const char *db,
  1142.    uint port, const char *unix_socket,uint client_flag)
  1143. {
  1144.   char buff[NAME_LEN+USERNAME_LENGTH+100],charset_name_buff[16];
  1145.   char *end,*host_info,*charset_name;
  1146.   my_socket sock;
  1147.   uint32 ip_addr;
  1148.   struct sockaddr_in sock_addr;
  1149.   uint pkt_length;
  1150.   NET *net= &mysql->net;
  1151. #ifdef __WIN__
  1152.   HANDLE hPipe=INVALID_HANDLE_VALUE;
  1153. #endif
  1154. #ifdef HAVE_SYS_UN_H
  1155.   struct sockaddr_un UNIXaddr;
  1156. #endif
  1157.   init_sigpipe_variables
  1158.   DBUG_ENTER("mysql_real_connect");
  1160.   DBUG_PRINT("enter",("host: %s  db: %s  user: %s",
  1161.       host ? host : "(Null)",
  1162.       db ? db : "(Null)",
  1163.       user ? user : "(Null)"));
  1165.   /* Don't give sigpipe errors if the client doesn't want them */
  1166.   set_sigpipe(mysql);
  1167.   net->vio = 0; /* If something goes wrong */
  1168.   /* use default options */
  1169.   if (mysql->options.my_cnf_file || mysql->options.my_cnf_group)
  1170.   {
  1171.     mysql_read_default_options(&mysql->options,
  1172.        (mysql->options.my_cnf_file ?
  1173. mysql->options.my_cnf_file : "my"),
  1174.        mysql->options.my_cnf_group);
  1175.     my_free(mysql->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
  1176.     my_free(mysql->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
  1177.     mysql->options.my_cnf_file=mysql->options.my_cnf_group=0;
  1178.   }
  1180.   /* Some empty-string-tests are done because of ODBC */
  1181.   if (!host || !host[0])
  1182.     host=mysql->options.host;
  1183.   if (!user || !user[0])
  1184.     user=mysql->options.user;
  1185.   if (!passwd)
  1186.   {
  1187.     passwd=mysql->options.password;
  1188. #ifndef DONT_USE_MYSQL_PWD
  1189.     if (!passwd)
  1190.       passwd=getenv("MYSQL_PWD");  /* get it from environment (haneke) */
  1191. #endif
  1192.   }
  1193.   if (!db || !db[0])
  1194.     db=mysql->options.db;
  1195.   if (!port)
  1196.     port=mysql->options.port;
  1197.   if (!unix_socket)
  1198.     unix_socket=mysql->options.unix_socket;
  1200.   mysql->reconnect=1; /* Reconnect as default */
  1201.   mysql->server_status=SERVER_STATUS_AUTOCOMMIT;
  1203.   /*
  1204.   ** Grab a socket and connect it to the server
  1205.   */
  1207. #if defined(HAVE_SYS_UN_H)
  1208.   if ((!host || !strcmp(host,LOCAL_HOST)) && (unix_socket || mysql_unix_port))
  1209.   {
  1210.     host=LOCAL_HOST;
  1211.     if (!unix_socket)
  1212.       unix_socket=mysql_unix_port;
  1213.     host_info=(char*) ER(CR_LOCALHOST_CONNECTION);
  1214.     DBUG_PRINT("info",("Using UNIX sock '%s'",unix_socket));
  1215.     if ((sock = socket(AF_UNIX,SOCK_STREAM,0)) == SOCKET_ERROR)
  1216.     {
  1217.       net->last_errno=CR_SOCKET_CREATE_ERROR;
  1218.       sprintf(net->last_error,ER(net->last_errno),ERRNO);
  1219.       goto error;
  1220.     }
  1221.     net->vio = vio_new(sock, VIO_TYPE_SOCKET, TRUE);
  1222.     bzero((char*) &UNIXaddr,sizeof(UNIXaddr));
  1223.     UNIXaddr.sun_family = AF_UNIX;
  1224.     strmov(UNIXaddr.sun_path, unix_socket);
  1225.     if (connect2(sock,(struct sockaddr *) &UNIXaddr, sizeof(UNIXaddr),
  1226.  mysql->options.connect_timeout) <0)
  1227.     {
  1228.       DBUG_PRINT("error",("Got error %d on connect to local server",ERRNO));
  1229.       net->last_errno=CR_CONNECTION_ERROR;
  1230.       sprintf(net->last_error,ER(net->last_errno),unix_socket,ERRNO);
  1231.       goto error;
  1232.     }
  1233.   }
  1234.   else
  1235. #elif defined(__WIN__)
  1236.   {
  1237.     if ((unix_socket ||
  1238.  !host && is_NT() ||
  1239.  host && !strcmp(host,LOCAL_HOST_NAMEDPIPE) ||
  1240.  mysql->options.named_pipe || !have_tcpip))
  1241.     {
  1242.       sock=0;
  1243.       if ((hPipe=create_named_pipe(net, mysql->options.connect_timeout,
  1244.    (char**) &host, (char**) &unix_socket)) ==
  1245.   INVALID_HANDLE_VALUE)
  1246.       {
  1247. DBUG_PRINT("error",
  1248.    ("host: '%s'  socket: '%s'  named_pipe: %d  have_tcpip: %d",
  1249.     host ? host : "<null>",
  1250.     unix_socket ? unix_socket : "<null>",
  1251.     (int) mysql->options.named_pipe,
  1252.     (int) have_tcpip));
  1253. if (mysql->options.named_pipe ||
  1254.     (host && !strcmp(host,LOCAL_HOST_NAMEDPIPE)) ||
  1255.     (unix_socket && !strcmp(unix_socket,MYSQL_NAMEDPIPE)))
  1256.   goto error; /* User only requested named pipes */
  1257. /* Try also with TCP/IP */
  1258.       }
  1259.       else
  1260.       {
  1261. net->vio=vio_new_win32pipe(hPipe);
  1262. sprintf(host_info=buff, ER(CR_NAMEDPIPE_CONNECTION), host,
  1263. unix_socket);
  1264.       }
  1265.     }
  1266.   }
  1267.   if (hPipe == INVALID_HANDLE_VALUE)
  1268. #endif
  1269.   {
  1270.     unix_socket=0; /* This is not used */
  1271.     if (!port)
  1272.       port=mysql_port;
  1273.     if (!host)
  1274.       host=LOCAL_HOST;
  1275.     sprintf(host_info=buff,ER(CR_TCP_CONNECTION),host);
  1276.     DBUG_PRINT("info",("Server name: '%s'.  TCP sock: %d", host,port));
  1277.     /* _WIN64 ;  Assume that the (int) range is enough for socket() */
  1278.     if ((sock = (my_socket) socket(AF_INET,SOCK_STREAM,0)) == SOCKET_ERROR)
  1279.     {
  1280.       net->last_errno=CR_IPSOCK_ERROR;
  1281.       sprintf(net->last_error,ER(net->last_errno),ERRNO);
  1282.       goto error;
  1283.     }
  1284.     net->vio = vio_new(sock,VIO_TYPE_TCPIP,FALSE);
  1285.     bzero((char*) &sock_addr,sizeof(sock_addr));
  1286.     sock_addr.sin_family = AF_INET;
  1288.     /*
  1289.     ** The server name may be a host name or IP address
  1290.     */
  1292.     if ((int) (ip_addr = inet_addr(host)) != (int) INADDR_NONE)
  1293.     {
  1294.       memcpy_fixed(&sock_addr.sin_addr,&ip_addr,sizeof(ip_addr));
  1295.     }
  1296.     else
  1297. #if defined(HAVE_GETHOSTBYNAME_R) && defined(_REENTRANT) && defined(THREAD)
  1298.     {
  1299.       int tmp_errno;
  1300.       struct hostent tmp_hostent,*hp;
  1301.       char buff2[GETHOSTBYNAME_BUFF_SIZE];
  1302.       hp = my_gethostbyname_r(host,&tmp_hostent,buff2,sizeof(buff2),
  1303.       &tmp_errno);
  1304.       if (!hp)
  1305.       {
  1306. net->last_errno=CR_UNKNOWN_HOST;
  1307. sprintf(net->last_error, ER(CR_UNKNOWN_HOST), host, tmp_errno);
  1308. goto error;
  1309.       }
  1310.       memcpy(&sock_addr.sin_addr,hp->h_addr, (size_t) hp->h_length);
  1311.     }
  1312. #else
  1313.     {
  1314.       struct hostent *hp;
  1315.       if (!(hp=gethostbyname(host)))
  1316.       {
  1317. net->last_errno=CR_UNKNOWN_HOST;
  1318. sprintf(net->last_error, ER(CR_UNKNOWN_HOST), host, errno);
  1319. goto error;
  1320.       }
  1321.       memcpy(&sock_addr.sin_addr,hp->h_addr, (size_t) hp->h_length);
  1322.     }
  1323. #endif
  1324.     sock_addr.sin_port = (ushort) htons((ushort) port);
  1325.     if (connect2(sock,(struct sockaddr *) &sock_addr, sizeof(sock_addr),
  1326.  mysql->options.connect_timeout) <0)
  1327.     {
  1328.       DBUG_PRINT("error",("Got error %d on connect to '%s'",ERRNO,host));
  1329.       net->last_errno= CR_CONN_HOST_ERROR;
  1330.       sprintf(net->last_error ,ER(CR_CONN_HOST_ERROR), host, ERRNO);
  1331.       goto error;
  1332.     }
  1333.   }
  1335.   if (!net->vio || my_net_init(net, net->vio))
  1336.   {
  1337.     vio_delete(net->vio);
  1338.     net->vio = 0;
  1339.     net->last_errno=CR_OUT_OF_MEMORY;
  1340.     strmov(net->last_error,ER(net->last_errno));
  1341.     goto error;
  1342.   }
  1343.   vio_keepalive(net->vio,TRUE);
  1345.   /* Get version info */
  1346.   mysql->protocol_version= PROTOCOL_VERSION; /* Assume this */
  1347.   if (mysql->options.connect_timeout &&
  1348.       vio_poll_read(net->vio, mysql->options.connect_timeout))
  1349.   {
  1350.     net->last_errno= CR_SERVER_LOST;
  1351.     strmov(net->last_error,ER(net->last_errno));    
  1352.     goto error;
  1353.   }
  1354.   if ((pkt_length=net_safe_read(mysql)) == packet_error)
  1355.     goto error;
  1357.   /* Check if version of protocoll matches current one */
  1359.   mysql->protocol_version= net->read_pos[0];
  1360.   DBUG_DUMP("packet",(char*) net->read_pos,10);
  1361.   DBUG_PRINT("info",("mysql protocol version %d, server=%d",
  1362.      PROTOCOL_VERSION, mysql->protocol_version));
  1363.   if (mysql->protocol_version != PROTOCOL_VERSION &&
  1364.       mysql->protocol_version != PROTOCOL_VERSION-1)
  1365.   {
  1366.     net->last_errno= CR_VERSION_ERROR;
  1367.     sprintf(net->last_error, ER(CR_VERSION_ERROR), mysql->protocol_version,
  1368.     PROTOCOL_VERSION);
  1369.     goto error;
  1370.   }
  1371.   end=strend((char*) net->read_pos+1);
  1372.   mysql->thread_id=uint4korr(end+1);
  1373.   end+=5;
  1374.   strmake(mysql->scramble_buff,end,8);
  1375.   end+=9;
  1376.   if (pkt_length >= (uint) (end+1 - (char*) net->read_pos))
  1377.     mysql->server_capabilities=uint2korr(end);
  1378.   if (pkt_length >= (uint) (end+18 - (char*) net->read_pos))
  1379.   {
  1380.     /* New protocol with 16 bytes to describe server characteristics */
  1381.     mysql->server_language=end[2];
  1382.     mysql->server_status=uint2korr(end+3);
  1383.   }
  1385.   /* Set character set */
  1386.   if ((charset_name=mysql->options.charset_name))
  1387.   {
  1388.     const char *save=charsets_dir;
  1389.     if (mysql->options.charset_dir)
  1390.       charsets_dir=mysql->options.charset_dir;
  1391.     mysql->charset=get_charset_by_name(mysql->options.charset_name,
  1392.                                        MYF(MY_WME));
  1393.     charsets_dir=save;
  1394.   }
  1395.   else if (mysql->server_language)
  1396.   {
  1397.     charset_name=charset_name_buff;
  1398.     sprintf(charset_name,"%d",mysql->server_language); /* In case of errors */
  1399.     if (!(mysql->charset =
  1400.   get_charset((uint8) mysql->server_language, MYF(MY_WME))))
  1401.       mysql->charset = default_charset_info; /* shouldn't be fatal */
  1403.   }
  1404.   else
  1405.     mysql->charset=default_charset_info;
  1407.   if (!mysql->charset)
  1408.   {
  1409.     net->last_errno=CR_CANT_READ_CHARSET;
  1410.     if (mysql->options.charset_dir)
  1411.       sprintf(net->last_error,ER(net->last_errno),
  1412.               charset_name ? charset_name : "unknown",
  1413.               mysql->options.charset_dir);
  1414.     else
  1415.     {
  1416.       char cs_dir_name[FN_REFLEN];
  1417.       get_charsets_dir(cs_dir_name);
  1418.       sprintf(net->last_error,ER(net->last_errno),
  1419.               charset_name ? charset_name : "unknown",
  1420.               cs_dir_name);
  1421.     }
  1422.     goto error;
  1423.   }
  1425.   /* Save connection information */
  1426.   if (!user) user="";
  1427.   if (!passwd) passwd="";
  1428.   if (!my_multi_malloc(MYF(0),
  1429.        &mysql->host_info, (uint) strlen(host_info)+1,
  1430.        &mysql->host,      (uint) strlen(host)+1,
  1431.        &mysql->unix_socket,unix_socket ?
  1432.        (uint) strlen(unix_socket)+1 : (uint) 1,
  1433.        &mysql->server_version,
  1434.        (uint) (end - (char*) net->read_pos),
  1435.        NullS) ||
  1436.       !(mysql->user=my_strdup(user,MYF(0))) ||
  1437.       !(mysql->passwd=my_strdup(passwd,MYF(0))))
  1438.   {
  1439.     strmov(net->last_error, ER(net->last_errno=CR_OUT_OF_MEMORY));
  1440.     goto error;
  1441.   }
  1442.   strmov(mysql->host_info,host_info);
  1443.   strmov(mysql->host,host);
  1444.   if (unix_socket)
  1445.     strmov(mysql->unix_socket,unix_socket);
  1446.   else
  1447.     mysql->unix_socket=0;
  1448.   strmov(mysql->server_version,(char*) net->read_pos+1);
  1449.   mysql->port=port;
  1450.   client_flag|=mysql->options.client_flag;
  1452.   /* Send client information for access check */
  1453.   client_flag|=CLIENT_CAPABILITIES;
  1455. #ifdef HAVE_OPENSSL
  1456.   if (mysql->options.use_ssl)
  1457.     client_flag|=CLIENT_SSL;
  1458. #endif /* HAVE_OPENSSL */
  1460.   if (db)
  1461.     client_flag|=CLIENT_CONNECT_WITH_DB;
  1462. #ifdef HAVE_COMPRESS
  1463.   if ((mysql->server_capabilities & CLIENT_COMPRESS) &&
  1464.       (mysql->options.compress || (client_flag & CLIENT_COMPRESS)))
  1465.     client_flag|=CLIENT_COMPRESS; /* We will use compression */
  1466.   else
  1467. #endif
  1468.     client_flag&= ~CLIENT_COMPRESS;
  1470. #ifdef HAVE_OPENSSL
  1471.   if ((mysql->server_capabilities & CLIENT_SSL) &&
  1472.       (mysql->options.use_ssl || (client_flag & CLIENT_SSL)))
  1473.   {
  1474.     DBUG_PRINT("info", ("Changing IO layer to SSL"));
  1475.     client_flag |= CLIENT_SSL;
  1476.   }
  1477.   else
  1478.   {
  1479.     if (client_flag & CLIENT_SSL)
  1480.     {
  1481.       DBUG_PRINT("info", ("Leaving IO layer intact because server doesn't support SSL"));
  1482.     }
  1483.     client_flag &= ~CLIENT_SSL;
  1484.   }
  1485. #endif /* HAVE_OPENSSL */
  1487.   int2store(buff,client_flag);
  1488.   mysql->client_flag=client_flag;
  1490. #ifdef HAVE_OPENSSL
  1491.   /* Oops.. are we careful enough to not send ANY information */
  1492.   /* without encryption? */
  1493.   if (client_flag & CLIENT_SSL)
  1494.   {
  1495.     if (my_net_write(net,buff,(uint) (2)) || net_flush(net))
  1496.       goto error;
  1497.     /* Do the SSL layering. */
  1498.     DBUG_PRINT("info", ("IO layer change in progress..."));
  1499.     VioSSLConnectorFd* connector_fd = (VioSSLConnectorFd*)
  1500.       (mysql->connector_fd);
  1501.     VioSocket* vio_socket = (VioSocket*)(mysql->net.vio);
  1502.     VioSSL* vio_ssl =    connector_fd->connect(vio_socket);
  1503.     mysql->net.vio =         (NetVio*)(vio_ssl);
  1504.   }
  1505. #endif /* HAVE_OPENSSL */
  1507.   DBUG_PRINT("info",("Server version = '%s'  capabilites: %ld  status: %d  client_flag: %d",
  1508.      mysql->server_version,mysql->server_capabilities,
  1509.      mysql->server_status, client_flag));
  1511.   int3store(buff+2,max_allowed_packet);
  1512.   if (user && user[0])
  1513.     strmake(buff+5,user,32); /* Max user name */
  1514.   else
  1515.     read_user_name((char*) buff+5);
  1516. #ifdef _CUSTOMCONFIG_
  1517. #include "_cust_libmysql.h";
  1518. #endif
  1519.   DBUG_PRINT("info",("user: %s",buff+5));
  1520.   end=scramble(strend(buff+5)+1, mysql->scramble_buff, passwd,
  1521.        (my_bool) (mysql->protocol_version == 9));
  1522.   if (db && (mysql->server_capabilities & CLIENT_CONNECT_WITH_DB))
  1523.   {
  1524.     end=strmake(end+1,db,NAME_LEN);
  1525.     mysql->db=my_strdup(db,MYF(MY_WME));
  1526.     db=0;
  1527.   }
  1528.   if (my_net_write(net,buff,(uint) (end-buff)) || net_flush(net) ||
  1529.       net_safe_read(mysql) == packet_error)
  1530.     goto error;
  1531.   if (client_flag & CLIENT_COMPRESS) /* We will use compression */
  1532.     net->compress=1;
  1533.   if (db && mysql_select_db(mysql,db))
  1534.     goto error;
  1535.   if (mysql->options.init_command)
  1536.   {
  1537.     my_bool reconnect=mysql->reconnect;
  1538.     mysql->reconnect=0;
  1539.     if (mysql_query(mysql,mysql->options.init_command))
  1540.       goto error;
  1541.     mysql_free_result(mysql_use_result(mysql));
  1542.     mysql->reconnect=reconnect;
  1543.   }
  1545.   DBUG_PRINT("exit",("Mysql handler: %lx",mysql));
  1546.   reset_sigpipe(mysql);
  1547.   DBUG_RETURN(mysql);
  1549. error:
  1550.   reset_sigpipe(mysql);
  1551.   DBUG_PRINT("error",("message: %u (%s)",net->last_errno,net->last_error));
  1552.   {
  1553.     /* Free alloced memory */
  1554.     my_bool free_me=mysql->free_me;
  1555.     end_server(mysql);
  1556.     mysql->free_me=0;
  1557.     mysql_close(mysql);
  1558.     mysql->free_me=free_me;
  1559.   }
  1560.   DBUG_RETURN(0);
  1561. }
  1564. static my_bool mysql_reconnect(MYSQL *mysql)
  1565. {
  1566.   MYSQL tmp_mysql;
  1567.   DBUG_ENTER("mysql_reconnect");
  1569.   if (!mysql->reconnect ||
  1570.       (mysql->server_status & SERVER_STATUS_IN_TRANS) || !mysql->host_info)
  1571.   {
  1572.    /* Allov reconnect next time */
  1573.     mysql->server_status&= ~SERVER_STATUS_IN_TRANS;
  1574.     DBUG_RETURN(1);
  1575.   }
  1576.   mysql_init(&tmp_mysql);
  1577.   tmp_mysql.options=mysql->options;
  1578.   if (!mysql_real_connect(&tmp_mysql,mysql->host,mysql->user,mysql->passwd,
  1579.   mysql->db, mysql->port, mysql->unix_socket,
  1580.   mysql->client_flag))
  1581.     DBUG_RETURN(1);
  1582.   tmp_mysql.free_me=mysql->free_me;
  1583.   mysql->free_me=0;
  1584.   bzero((char*) &mysql->options,sizeof(mysql->options));
  1585.   mysql_close(mysql);
  1586.   *mysql=tmp_mysql;
  1587.   net_clear(&mysql->net);
  1588.   mysql->affected_rows= ~(my_ulonglong) 0;
  1589.   DBUG_RETURN(0);
  1590. }
  1593. /**************************************************************************
  1594. ** Change user and database 
  1595. **************************************************************************/
  1597. my_bool STDCALL mysql_change_user(MYSQL *mysql, const char *user, 
  1598.   const char *passwd, const char *db)
  1599. {
  1600.   char buff[512],*pos=buff;
  1601.   DBUG_ENTER("mysql_change_user");
  1603.   if (!user)
  1604.     user="";
  1605.   if (!passwd)
  1606.     passwd="";
  1608.   pos=strmov(pos,user)+1;
  1609.   pos=scramble(pos, mysql->scramble_buff, passwd,
  1610.        (my_bool) (mysql->protocol_version == 9));
  1611.   pos=strmov(pos+1,db ? db : "");
  1612.   if (simple_command(mysql,COM_CHANGE_USER, buff,(uint) (pos-buff),0))
  1613.     DBUG_RETURN(1);
  1615.   my_free(mysql->user,MYF(MY_ALLOW_ZERO_PTR));
  1616.   my_free(mysql->passwd,MYF(MY_ALLOW_ZERO_PTR));
  1617.   my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
  1619.   mysql->user=  my_strdup(user,MYF(MY_WME));
  1620.   mysql->passwd=my_strdup(passwd,MYF(MY_WME));
  1621.   mysql->db=    db ? my_strdup(db,MYF(MY_WME)) : 0;
  1622.   DBUG_RETURN(0);
  1623. }
  1626. /**************************************************************************
  1627. ** Set current database
  1628. **************************************************************************/
  1630. int STDCALL
  1631. mysql_select_db(MYSQL *mysql, const char *db)
  1632. {
  1633.   int error;
  1634.   DBUG_ENTER("mysql_select_db");
  1635.   DBUG_PRINT("enter",("db: '%s'",db));
  1637.   if ((error=simple_command(mysql,COM_INIT_DB,db,(uint) strlen(db),0)))
  1638.     DBUG_RETURN(error);
  1639.   my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
  1640.   mysql->db=my_strdup(db,MYF(MY_WME));
  1641.   DBUG_RETURN(0);
  1642. }
  1645. /*************************************************************************
  1646. ** Send a QUIT to the server and close the connection
  1647. ** If handle is alloced by mysql connect free it.
  1648. *************************************************************************/
  1650. void STDCALL
  1651. mysql_close(MYSQL *mysql)
  1652. {
  1653.   DBUG_ENTER("mysql_close");
  1654.   if (mysql) /* Some simple safety */
  1655.   {
  1656.     if (mysql->net.vio != 0)
  1657.     {
  1658.       free_old_query(mysql);
  1659.       mysql->status=MYSQL_STATUS_READY; /* Force command */
  1660.       simple_command(mysql,COM_QUIT,NullS,0,1);
  1661.       end_server(mysql);
  1662.     }
  1663.     my_free((gptr) mysql->host_info,MYF(MY_ALLOW_ZERO_PTR));
  1664.     my_free(mysql->user,MYF(MY_ALLOW_ZERO_PTR));
  1665.     my_free(mysql->passwd,MYF(MY_ALLOW_ZERO_PTR));
  1666.     my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
  1667.     my_free(mysql->options.init_command,MYF(MY_ALLOW_ZERO_PTR));
  1668.     my_free(mysql->options.user,MYF(MY_ALLOW_ZERO_PTR));
  1669.     my_free(mysql->options.host,MYF(MY_ALLOW_ZERO_PTR));
  1670.     my_free(mysql->options.password,MYF(MY_ALLOW_ZERO_PTR));
  1671.     my_free(mysql->options.unix_socket,MYF(MY_ALLOW_ZERO_PTR));
  1672.     my_free(mysql->options.db,MYF(MY_ALLOW_ZERO_PTR));
  1673.     my_free(mysql->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
  1674.     my_free(mysql->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
  1675.     my_free(mysql->options.charset_dir,MYF(MY_ALLOW_ZERO_PTR));
  1676.     my_free(mysql->options.charset_name,MYF(MY_ALLOW_ZERO_PTR));
  1677.     /* Clear pointers for better safety */
  1678.     mysql->host_info=mysql->user=mysql->passwd=mysql->db=0;
  1679.     bzero((char*) &mysql->options,sizeof(mysql->options));
  1680.     mysql->net.vio = 0;
  1681. #ifdef HAVE_OPENSSL
  1682.     ((VioConnectorFd*)(mysql->connector_fd))->delete();
  1683.     mysql->connector_fd = 0;
  1684. #endif /* HAVE_OPENSSL */
  1685.     if (mysql->free_me)
  1686.       my_free((gptr) mysql,MYF(0));
  1687.   }
  1688.   DBUG_VOID_RETURN;
  1689. }
  1692. /**************************************************************************
  1693. ** Do a query. If query returned rows, free old rows.
  1694. ** Read data by mysql_store_result or by repeat call of mysql_fetch_row
  1695. **************************************************************************/
  1697. int STDCALL
  1698. mysql_query(MYSQL *mysql, const char *query)
  1699. {
  1700.   return mysql_real_query(mysql,query, (uint) strlen(query));
  1701. }
  1703. /*
  1704.   Send the query and return so we can do something else.
  1705.   Needs to be followed by mysql_read_query_result() when we want to
  1706.   finish processing it.
  1707. */  
  1709. int STDCALL
  1710. mysql_send_query(MYSQL* mysql, const char* query, uint length)
  1711. {
  1712.   return simple_command(mysql, COM_QUERY, query, length, 1);
  1713. }
  1715. int STDCALL mysql_read_query_result(MYSQL *mysql)
  1716. {
  1717.   uchar *pos;
  1718.   ulong field_count;
  1719.   MYSQL_DATA *fields;
  1720.   uint length;
  1721.   DBUG_ENTER("mysql_read_query_result");
  1723.   if ((length = net_safe_read(mysql)) == packet_error)
  1724.     DBUG_RETURN(-1);
  1725.   free_old_query(mysql); /* Free old result */
  1726. get_info:
  1727.   pos=(uchar*) mysql->net.read_pos;
  1728.   if ((field_count= net_field_length(&pos)) == 0)
  1729.   {
  1730.     mysql->affected_rows= net_field_length_ll(&pos);
  1731.     mysql->insert_id=   net_field_length_ll(&pos);
  1732.     if (mysql->server_capabilities & CLIENT_TRANSACTIONS)
  1733.     {
  1734.       mysql->server_status=uint2korr(pos); pos+=2;
  1735.     }
  1736.     if (pos < mysql->net.read_pos+length && net_field_length(&pos))
  1737.       mysql->info=(char*) pos;
  1738.     DBUG_RETURN(0);
  1739.   }
  1740.   if (field_count == NULL_LENGTH) /* LOAD DATA LOCAL INFILE */
  1741.   {
  1742.     int error=send_file_to_server(mysql,(char*) pos);
  1743.     if ((length=net_safe_read(mysql)) == packet_error || error)
  1744.       DBUG_RETURN(-1);
  1745.     goto get_info; /* Get info packet */
  1746.   }
  1747.   if (!(mysql->server_status & SERVER_STATUS_AUTOCOMMIT))
  1748.     mysql->server_status|= SERVER_STATUS_IN_TRANS;
  1750.   mysql->extra_info= net_field_length_ll(&pos); /* Maybe number of rec */
  1751.   if (!(fields=read_rows(mysql,(MYSQL_FIELD*) 0,5)))
  1752.     DBUG_RETURN(-1);
  1753.   if (!(mysql->fields=unpack_fields(fields,&mysql->field_alloc,
  1754.     (uint) field_count,0,
  1755.     (my_bool) test(mysql->server_capabilities &
  1756.    CLIENT_LONG_FLAG))))
  1757.     DBUG_RETURN(-1);
  1758.   mysql->status=MYSQL_STATUS_GET_RESULT;
  1759.   mysql->field_count=field_count;
  1760.   DBUG_RETURN(0);
  1761. }
  1763. int STDCALL
  1764. mysql_real_query(MYSQL *mysql, const char *query, uint length)
  1765. {
  1766.   DBUG_ENTER("mysql_real_query");
  1767.   DBUG_PRINT("enter",("handle: %lx",mysql));
  1768.   DBUG_PRINT("query",("Query = "%s"",query));
  1769.   if (simple_command(mysql,COM_QUERY,query,length,1))
  1770.     DBUG_RETURN(-1);
  1771.   DBUG_RETURN(mysql_read_query_result(mysql));
  1772. }
  1774. static int
  1775. send_file_to_server(MYSQL *mysql, const char *filename)
  1776. {
  1777.   int fd, readcount;
  1778.   char buf[IO_SIZE*15],*tmp_name;
  1779.   DBUG_ENTER("send_file_to_server");
  1781.   fn_format(buf,filename,"","",4); /* Convert to client format */
  1782.   if (!(tmp_name=my_strdup(buf,MYF(0))))
  1783.   {
  1784.     strmov(mysql->net.last_error, ER(mysql->net.last_errno=CR_OUT_OF_MEMORY));
  1785.     DBUG_RETURN(-1);
  1786.   }
  1787.   if ((fd = my_open(tmp_name,O_RDONLY, MYF(0))) < 0)
  1788.   {
  1789.     mysql->net.last_errno=EE_FILENOTFOUND;
  1790.     sprintf(buf,EE(mysql->net.last_errno),tmp_name,errno);
  1791.     strmake(mysql->net.last_error,buf,sizeof(mysql->net.last_error)-1);
  1792.     my_net_write(&mysql->net,"",0); net_flush(&mysql->net);
  1793.     my_free(tmp_name,MYF(0));
  1794.     DBUG_RETURN(-1);
  1795.   }
  1797.   while ((readcount = (int) my_read(fd,buf,sizeof(buf),MYF(0))) > 0)
  1798.   {
  1799.     if (my_net_write(&mysql->net,buf,readcount))
  1800.     {
  1801.       mysql->net.last_errno=CR_SERVER_LOST;
  1802.       strmov(mysql->net.last_error,ER(mysql->net.last_errno));
  1803.       DBUG_PRINT("error",("Lost connection to MySQL server during LOAD DATA of local file"));
  1804.       (void) my_close(fd,MYF(0));
  1805.       my_free(tmp_name,MYF(0));
  1806.       DBUG_RETURN(-1);
  1807.     }
  1808.   }
  1809.   (void) my_close(fd,MYF(0));
  1810.   /* Send empty packet to mark end of file */
  1811.   if (my_net_write(&mysql->net,"",0) || net_flush(&mysql->net))
  1812.   {
  1813.     mysql->net.last_errno=CR_SERVER_LOST;
  1814.     sprintf(mysql->net.last_error,ER(mysql->net.last_errno),errno);
  1815.     my_free(tmp_name,MYF(0));
  1816.     DBUG_RETURN(-1);
  1817.   }
  1818.   if (readcount < 0)
  1819.   {
  1820.     mysql->net.last_errno=EE_READ; /* the errmsg for not entire file read */
  1821.     sprintf(buf,EE(mysql->net.last_errno),tmp_name,errno);
  1822.     strmake(mysql->net.last_error,buf,sizeof(mysql->net.last_error)-1);
  1823.     my_free(tmp_name,MYF(0));
  1824.     DBUG_RETURN(-1);
  1825.   }
  1826.   DBUG_RETURN(0);
  1827. }
  1830. /**************************************************************************
  1831. ** Alloc result struct for buffered results. All rows are read to buffer.
  1832. ** mysql_data_seek may be used.
  1833. **************************************************************************/
  1835. MYSQL_RES * STDCALL
  1836. mysql_store_result(MYSQL *mysql)
  1837. {
  1838.   MYSQL_RES *result;
  1839.   DBUG_ENTER("mysql_store_result");
  1841.   if (!mysql->fields)
  1842.     DBUG_RETURN(0);
  1843.   if (mysql->status != MYSQL_STATUS_GET_RESULT)
  1844.   {
  1845.     strmov(mysql->net.last_error,
  1846.    ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
  1847.     DBUG_RETURN(0);
  1848.   }
  1849.   mysql->status=MYSQL_STATUS_READY; /* server is ready */
  1850.   if (!(result=(MYSQL_RES*) my_malloc(sizeof(MYSQL_RES)+
  1851.       sizeof(ulong)*mysql->field_count,
  1852.       MYF(MY_WME | MY_ZEROFILL))))
  1853.   {
  1854.     mysql->net.last_errno=CR_OUT_OF_MEMORY;
  1855.     strmov(mysql->net.last_error, ER(mysql->net.last_errno));
  1856.     DBUG_RETURN(0);
  1857.   }
  1858.   result->eof=1; /* Marker for buffered */
  1859.   result->lengths=(ulong*) (result+1);
  1860.   if (!(result->data=read_rows(mysql,mysql->fields,mysql->field_count)))
  1861.   {
  1862.     my_free((gptr) result,MYF(0));
  1863.     DBUG_RETURN(0);
  1864.   }
  1865.   mysql->affected_rows= result->row_count= result->data->rows;
  1866.   result->data_cursor= result->data->data;
  1867.   result->fields= mysql->fields;
  1868.   result->field_alloc= mysql->field_alloc;
  1869.   result->field_count= mysql->field_count;
  1870.   result->current_field=0;
  1871.   result->current_row=0; /* Must do a fetch first */
  1872.   mysql->fields=0; /* fields is now in result */
  1873.   DBUG_RETURN(result); /* Data fetched */
  1874. }
  1877. /**************************************************************************
  1878. ** Alloc struct for use with unbuffered reads. Data is fetched by domand
  1879. ** when calling to mysql_fetch_row.
  1880. ** mysql_data_seek is a noop.
  1881. **
  1882. ** No other queries may be specified with the same MYSQL handle.
  1883. ** There shouldn't be much processing per row because mysql server shouldn't
  1884. ** have to wait for the client (and will not wait more than 30 sec/packet).
  1885. **************************************************************************/
  1887. MYSQL_RES * STDCALL
  1888. mysql_use_result(MYSQL *mysql)
  1889. {
  1890.   MYSQL_RES *result;
  1891.   DBUG_ENTER("mysql_use_result");
  1893.   if (!mysql->fields)
  1894.     DBUG_RETURN(0);
  1895.   if (mysql->status != MYSQL_STATUS_GET_RESULT)
  1896.   {
  1897.     strmov(mysql->net.last_error,
  1898.    ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
  1899.     DBUG_RETURN(0);
  1900.   }
  1901.   if (!(result=(MYSQL_RES*) my_malloc(sizeof(*result)+
  1902.       sizeof(ulong)*mysql->field_count,
  1903.       MYF(MY_WME | MY_ZEROFILL))))
  1904.     DBUG_RETURN(0);
  1905.   result->lengths=(ulong*) (result+1);
  1906.   if (!(result->row=(MYSQL_ROW)
  1907. my_malloc(sizeof(result->row[0])*(mysql->field_count+1), MYF(MY_WME))))
  1908.   { /* Ptrs: to one row */
  1909.     my_free((gptr) result,MYF(0));
  1910.     DBUG_RETURN(0);
  1911.   }
  1912.   result->fields= mysql->fields;
  1913.   result->field_alloc= mysql->field_alloc;
  1914.   result->field_count= mysql->field_count;
  1915.   result->current_field=0;
  1916.   result->handle= mysql;
  1917.   result->current_row= 0;
  1918.   mysql->fields=0; /* fields is now in result */
  1919.   mysql->status=MYSQL_STATUS_USE_RESULT;
  1920.   DBUG_RETURN(result); /* Data is read to be fetched */
  1921. }
  1925. /**************************************************************************
  1926. ** Return next field of the query results
  1927. **************************************************************************/
  1929. MYSQL_FIELD * STDCALL
  1930. mysql_fetch_field(MYSQL_RES *result)
  1931. {
  1932.   if (result->current_field >= result->field_count)
  1933.     return(NULL);
  1934.   return &result->fields[result->current_field++];
  1935. }
  1938. /**************************************************************************
  1939. **  Return next row of the query results
  1940. **************************************************************************/
  1942. MYSQL_ROW STDCALL
  1943. mysql_fetch_row(MYSQL_RES *res)
  1944. {
  1945.   DBUG_ENTER("mysql_fetch_row");
  1946.   if (!res->data)
  1947.   { /* Unbufferred fetch */
  1948.     if (!res->eof)
  1949.     {
  1950.       if (!(read_one_row(res->handle,res->field_count,res->row, res->lengths)))
  1951.       {
  1952. res->row_count++;
  1953. DBUG_RETURN(res->current_row=res->row);
  1954.       }
  1955.       else
  1956.       {
  1957. DBUG_PRINT("info",("end of data"));
  1958. res->eof=1;
  1959. res->handle->status=MYSQL_STATUS_READY;
  1960.       }
  1961.     }
  1962.     DBUG_RETURN((MYSQL_ROW) NULL);
  1963.   }
  1964.   {
  1965.     MYSQL_ROW tmp;
  1966.     if (!res->data_cursor)
  1967.     {
  1968.       DBUG_PRINT("info",("end of data"));
  1969.       DBUG_RETURN(res->current_row=(MYSQL_ROW) NULL);
  1970.     }
  1971.     tmp = res->data_cursor->data;
  1972.     res->data_cursor = res->data_cursor->next;
  1973.     DBUG_RETURN(res->current_row=tmp);
  1974.   }
  1975. }
  1977. /**************************************************************************
  1978. ** Get column lengths of the current row
  1979. ** If one uses mysql_use_result, res->lengths contains the length information,
  1980. ** else the lengths are calculated from the offset between pointers.
  1981. **************************************************************************/
  1983. ulong * STDCALL
  1984. mysql_fetch_lengths(MYSQL_RES *res)
  1985. {
  1986.   ulong *lengths,*prev_length;
  1987.   byte *start;
  1988.   MYSQL_ROW column,end;
  1990.   if (!(column=res->current_row))
  1991.     return 0; /* Something is wrong */
  1992.   if (res->data)
  1993.   {
  1994.     start=0;
  1995.     prev_length=0; /* Keep gcc happy */
  1996.     lengths=res->lengths;
  1997.     for (end=column+res->field_count+1 ; column != end ; column++,lengths++)
  1998.     {
  1999.       if (!*column)
  2000.       {
  2001. *lengths=0; /* Null */
  2002. continue;
  2003.       }
  2004.       if (start) /* Found end of prev string */
  2005. *prev_length= (uint) (*column-start-1);
  2006.       start= *column;
  2007.       prev_length=lengths;
  2008.     }
  2009.   }
  2010.   return res->lengths;
  2011. }
  2013. /**************************************************************************
  2014. ** Move to a specific row and column
  2015. **************************************************************************/
  2017. void STDCALL
  2018. mysql_data_seek(MYSQL_RES *result, my_ulonglong row)
  2019. {
  2020.   MYSQL_ROWS *tmp=0;
  2021.   DBUG_PRINT("info",("mysql_data_seek(%ld)",(long) row));
  2022.   if (result->data)
  2023.     for (tmp=result->data->data; row-- && tmp ; tmp = tmp->next) ;
  2024.   result->current_row=0;
  2025.   result->data_cursor = tmp;
  2026. }
  2028. /*************************************************************************
  2029. ** put the row or field cursor one a position one got from mysql_row_tell()
  2030. ** This doesn't restore any data. The next mysql_fetch_row or
  2031. ** mysql_fetch_field will return the next row or field after the last used
  2032. *************************************************************************/
  2034. MYSQL_ROW_OFFSET STDCALL
  2035. mysql_row_seek(MYSQL_RES *result, MYSQL_ROW_OFFSET row)
  2036. {
  2037.   MYSQL_ROW_OFFSET return_value=result->data_cursor;
  2038.   result->current_row= 0;
  2039.   result->data_cursor= row;
  2040.   return return_value;
  2041. }
  2044. MYSQL_FIELD_OFFSET STDCALL
  2045. mysql_field_seek(MYSQL_RES *result, MYSQL_FIELD_OFFSET field_offset)
  2046. {
  2047.   MYSQL_FIELD_OFFSET return_value=result->current_field;
  2048.   result->current_field=field_offset;
  2049.   return return_value;
  2050. }
  2052. /*****************************************************************************
  2053. ** List all databases
  2054. *****************************************************************************/
  2056. MYSQL_RES * STDCALL
  2057. mysql_list_dbs(MYSQL *mysql, const char *wild)
  2058. {
  2059.   char buff[255];
  2060.   DBUG_ENTER("mysql_list_dbs");
  2062.   append_wild(strmov(buff,"show databases"),buff+sizeof(buff),wild);
  2063.   if (mysql_query(mysql,buff))
  2064.     DBUG_RETURN(0);
  2065.   DBUG_RETURN (mysql_store_result(mysql));
  2066. }
  2069. /*****************************************************************************
  2070. ** List all tables in a database
  2071. ** If wild is given then only the tables matching wild is returned
  2072. *****************************************************************************/
  2074. MYSQL_RES * STDCALL
  2075. mysql_list_tables(MYSQL *mysql, const char *wild)
  2076. {
  2077.   char buff[255];
  2078.   DBUG_ENTER("mysql_list_tables");
  2080.   append_wild(strmov(buff,"show tables"),buff+sizeof(buff),wild);
  2081.   if (mysql_query(mysql,buff))
  2082.     DBUG_RETURN(0);
  2083.   DBUG_RETURN (mysql_store_result(mysql));
  2084. }
  2087. /**************************************************************************
  2088. ** List all fields in a table
  2089. ** If wild is given then only the fields matching wild is returned
  2090. ** Instead of this use query:
  2091. ** show fields in 'table' like "wild"
  2092. **************************************************************************/
  2094. MYSQL_RES * STDCALL
  2095. mysql_list_fields(MYSQL *mysql, const char *table, const char *wild)
  2096. {
  2097.   MYSQL_RES *result;
  2098.   MYSQL_DATA *query;
  2099.   char      buff[257],*end;
  2100.   DBUG_ENTER("mysql_list_fields");
  2101.   DBUG_PRINT("enter",("table: '%s'  wild: '%s'",table,wild ? wild : ""));
  2103.   LINT_INIT(query);
  2105.   end=strmake(strmake(buff, table,128)+1,wild ? wild : "",128);
  2106.   if (simple_command(mysql,COM_FIELD_LIST,buff,(uint) (end-buff),1) ||
  2107.       !(query = read_rows(mysql,(MYSQL_FIELD*) 0,6)))
  2108.     DBUG_RETURN(NULL);
  2110.   free_old_query(mysql);
  2111.   if (!(result = (MYSQL_RES *) my_malloc(sizeof(MYSQL_RES),
  2112.  MYF(MY_WME | MY_ZEROFILL))))
  2113.   {
  2114.     free_rows(query);
  2115.     DBUG_RETURN(NULL);
  2116.   }
  2117.   result->field_alloc=mysql->field_alloc;
  2118.   mysql->fields=0;
  2119.   result->field_count = (uint) query->rows;
  2120.   result->fields= unpack_fields(query,&result->field_alloc,
  2121. result->field_count,1,
  2122. (my_bool) test(mysql->server_capabilities &
  2123.        CLIENT_LONG_FLAG));
  2124.   result->eof=1;
  2125.   DBUG_RETURN(result);
  2126. }
  2128. /* List all running processes (threads) in server */
  2130. MYSQL_RES * STDCALL
  2131. mysql_list_processes(MYSQL *mysql)
  2132. {
  2133.   MYSQL_DATA *fields;
  2134.   uint field_count;
  2135.   uchar *pos;
  2136.   DBUG_ENTER("mysql_list_processes");
  2138.   LINT_INIT(fields);
  2139.   if (simple_command(mysql,COM_PROCESS_INFO,0,0,0))
  2140.     DBUG_RETURN(0);
  2141.   free_old_query(mysql);
  2142.   pos=(uchar*) mysql->net.read_pos;
  2143.   field_count=(uint) net_field_length(&pos);
  2144.   if (!(fields = read_rows(mysql,(MYSQL_FIELD*) 0,5)))
  2145.     DBUG_RETURN(NULL);
  2146.   if (!(mysql->fields=unpack_fields(fields,&mysql->field_alloc,field_count,0,
  2147.     (my_bool) test(mysql->server_capabilities &
  2148.    CLIENT_LONG_FLAG))))
  2149.     DBUG_RETURN(0);
  2150.   mysql->status=MYSQL_STATUS_GET_RESULT;
  2151.   mysql->field_count=field_count;
  2152.   DBUG_RETURN(mysql_store_result(mysql));
  2153. }
  2156. int  STDCALL
  2157. mysql_create_db(MYSQL *mysql, const char *db)
  2158. {
  2159.   DBUG_ENTER("mysql_createdb");
  2160.   DBUG_PRINT("enter",("db: %s",db));
  2161.   DBUG_RETURN(simple_command(mysql,COM_CREATE_DB,db, (uint) strlen(db),0));
  2162. }
  2165. int  STDCALL
  2166. mysql_drop_db(MYSQL *mysql, const char *db)
  2167. {
  2168.   DBUG_ENTER("mysql_drop_db");
  2169.   DBUG_PRINT("enter",("db: %s",db));
  2170.   DBUG_RETURN(simple_command(mysql,COM_DROP_DB,db,(uint) strlen(db),0));
  2171. }
  2174. int STDCALL
  2175. mysql_shutdown(MYSQL *mysql)
  2176. {
  2177.   DBUG_ENTER("mysql_shutdown");
  2178.   DBUG_RETURN(simple_command(mysql,COM_SHUTDOWN,0,0,0));
  2179. }
  2182. int STDCALL
  2183. mysql_refresh(MYSQL *mysql,uint options)
  2184. {
  2185.   uchar bits[1];
  2186.   DBUG_ENTER("mysql_refresh");
  2187.   bits[0]= (uchar) options;
  2188.   DBUG_RETURN(simple_command(mysql,COM_REFRESH,(char*) bits,1,0));
  2189. }
  2191. int STDCALL
  2192. mysql_kill(MYSQL *mysql,ulong pid)
  2193. {
  2194.   char buff[12];
  2195.   DBUG_ENTER("mysql_kill");
  2196.   int4store(buff,pid);
  2197.   DBUG_RETURN(simple_command(mysql,COM_PROCESS_KILL,buff,4,0));
  2198. }
  2201. int STDCALL
  2202. mysql_dump_debug_info(MYSQL *mysql)
  2203. {
  2204.   DBUG_ENTER("mysql_dump_debug_info");
  2205.   DBUG_RETURN(simple_command(mysql,COM_DEBUG,0,0,0));
  2206. }
  2208. char * STDCALL
  2209. mysql_stat(MYSQL *mysql)
  2210. {
  2211.   DBUG_ENTER("mysql_stat");
  2212.   if (simple_command(mysql,COM_STATISTICS,0,0,0))
  2213.     return mysql->net.last_error;
  2214.   mysql->net.read_pos[mysql->packet_length]=0; /* End of stat string */
  2215.   if (!mysql->net.read_pos[0])
  2216.   {
  2217.     mysql->net.last_errno=CR_WRONG_HOST_INFO;
  2218.     strmov(mysql->net.last_error, ER(mysql->net.last_errno));
  2219.     return mysql->net.last_error;
  2220.   }
  2221.   DBUG_RETURN((char*) mysql->net.read_pos);
  2222. }
  2225. int STDCALL
  2226. mysql_ping(MYSQL *mysql)
  2227. {
  2228.   DBUG_ENTER("mysql_ping");
  2229.   DBUG_RETURN(simple_command(mysql,COM_PING,0,0,0));
  2230. }
  2233. char * STDCALL
  2234. mysql_get_server_info(MYSQL *mysql)
  2235. {
  2236.   return((char*) mysql->server_version);
  2237. }
  2240. char * STDCALL
  2241. mysql_get_host_info(MYSQL *mysql)
  2242. {
  2243.   return(mysql->host_info);
  2244. }
  2247. uint STDCALL
  2248. mysql_get_proto_info(MYSQL *mysql)
  2249. {
  2250.   return (mysql->protocol_version);
  2251. }
  2253. char * STDCALL
  2254. mysql_get_client_info(void)
  2255. {
  2256.   return (char*) MYSQL_SERVER_VERSION;
  2257. }
  2260. int STDCALL
  2261. mysql_options(MYSQL *mysql,enum mysql_option option, const char *arg)
  2262. {
  2263.   DBUG_ENTER("mysql_option");
  2264.   DBUG_PRINT("enter",("option: %d",(int) option));
  2265.   switch (option) {
  2266.   case MYSQL_OPT_CONNECT_TIMEOUT:
  2267.     mysql->options.connect_timeout= *(uint*) arg;
  2268.     break;
  2269.   case MYSQL_OPT_COMPRESS:
  2270.     mysql->options.compress=1; /* Remember for connect */
  2271.     break;
  2272.   case MYSQL_OPT_NAMED_PIPE:
  2273.     mysql->options.named_pipe=1; /* Force named pipe */
  2274.     break;
  2275.   case MYSQL_INIT_COMMAND:
  2276.     my_free(mysql->options.init_command,MYF(MY_ALLOW_ZERO_PTR));
  2277.     mysql->options.init_command=my_strdup(arg,MYF(MY_WME));
  2278.     break;
  2279.   case MYSQL_READ_DEFAULT_FILE:
  2280.     my_free(mysql->options.my_cnf_file,MYF(MY_ALLOW_ZERO_PTR));
  2281.     mysql->options.my_cnf_file=my_strdup(arg,MYF(MY_WME));
  2282.     break;
  2283.   case MYSQL_READ_DEFAULT_GROUP:
  2284.     my_free(mysql->options.my_cnf_group,MYF(MY_ALLOW_ZERO_PTR));
  2285.     mysql->options.my_cnf_group=my_strdup(arg,MYF(MY_WME));
  2286.     break;
  2287.   case MYSQL_SET_CHARSET_DIR:
  2288.     my_free(mysql->options.charset_dir,MYF(MY_ALLOW_ZERO_PTR));
  2289.     mysql->options.charset_dir=my_strdup(arg,MYF(MY_WME));
  2290.     break;
  2291.   case MYSQL_SET_CHARSET_NAME:
  2292.     my_free(mysql->options.charset_name,MYF(MY_ALLOW_ZERO_PTR));
  2293.     mysql->options.charset_name=my_strdup(arg,MYF(MY_WME));
  2294.     break;
  2295.   default:
  2296.     DBUG_RETURN(-1);
  2297.   }
  2298.   DBUG_RETURN(0);
  2299. }
  2301. /****************************************************************************
  2302. ** Functions to get information from the MySQL structure
  2303. ** These are functions to make shared libraries more usable.
  2304. ****************************************************************************/
  2306. /* MYSQL_RES */
  2307. my_ulonglong STDCALL mysql_num_rows(MYSQL_RES *res)
  2308. {
  2309.   return res->row_count;
  2310. }
  2312. unsigned int STDCALL mysql_num_fields(MYSQL_RES *res)
  2313. {
  2314.   return res->field_count;
  2315. }
  2317. my_bool STDCALL mysql_eof(MYSQL_RES *res)
  2318. {
  2319.   return res->eof;
  2320. }
  2322. MYSQL_FIELD * STDCALL mysql_fetch_field_direct(MYSQL_RES *res,uint fieldnr)
  2323. {
  2324.   return &(res)->fields[fieldnr];
  2325. }
  2327. MYSQL_FIELD * STDCALL mysql_fetch_fields(MYSQL_RES *res)
  2328. {
  2329.   return (res)->fields;
  2330. }
  2332. MYSQL_ROWS * STDCALL mysql_row_tell(MYSQL_RES *res)
  2333. {
  2334.   return res->data_cursor;
  2335. }
  2337. uint STDCALL mysql_field_tell(MYSQL_RES *res)
  2338. {
  2339.   return (res)->current_field;
  2340. }
  2342. /* MYSQL */
  2344. unsigned int STDCALL mysql_field_count(MYSQL *mysql)
  2345. {
  2346.   return mysql->field_count;
  2347. }
  2349. my_ulonglong STDCALL mysql_affected_rows(MYSQL *mysql)
  2350. {
  2351.   return (mysql)->affected_rows;
  2352. }
  2354. my_ulonglong STDCALL mysql_insert_id(MYSQL *mysql)
  2355. {
  2356.   return (mysql)->insert_id;
  2357. }
  2359. uint STDCALL mysql_errno(MYSQL *mysql)
  2360. {
  2361.   return (mysql)->net.last_errno;
  2362. }
  2364. char * STDCALL mysql_error(MYSQL *mysql)
  2365. {
  2366.   return (mysql)->net.last_error;
  2367. }
  2369. char *STDCALL mysql_info(MYSQL *mysql)
  2370. {
  2371.   return (mysql)->info;
  2372. }
  2374. ulong STDCALL mysql_thread_id(MYSQL *mysql)
  2375. {
  2376.   return (mysql)->thread_id;
  2377. }
  2379. const char * STDCALL mysql_character_set_name(MYSQL *mysql)
  2380. {
  2381.   return mysql->charset->name;
  2382. }
  2385. uint STDCALL mysql_thread_safe(void)
  2386. {
  2387. #ifdef THREAD
  2388.   return 1;
  2389. #else
  2390.   return 0;
  2391. #endif
  2392. }
  2394. /****************************************************************************
  2395. ** Some support functions
  2396. ****************************************************************************/
  2398. /*
  2399. ** Add escape characters to a string (blob?) to make it suitable for a insert
  2400. ** to should at least have place for length*2+1 chars
  2401. ** Returns the length of the to string
  2402. */
  2404. ulong STDCALL
  2405. mysql_escape_string(char *to,const char *from,ulong length)
  2406. {
  2407.   return mysql_sub_escape_string(default_charset_info,to,from,length);
  2408. }
  2410. ulong STDCALL
  2411. mysql_real_escape_string(MYSQL *mysql, char *to,const char *from,
  2412.  ulong length)
  2413. {
  2414.   return mysql_sub_escape_string(mysql->charset,to,from,length);
  2415. }
  2418. static ulong
  2419. mysql_sub_escape_string(CHARSET_INFO *charset_info, char *to,
  2420. const char *from, ulong length)
  2421. {
  2422.   const char *to_start=to;
  2423.   const char *end;
  2424. #ifdef USE_MB
  2425.   my_bool use_mb_flag=use_mb(charset_info);
  2426. #endif
  2427.   for (end=from+length; from != end ; from++)
  2428.   {
  2429. #ifdef USE_MB
  2430.     int l;
  2431.     if (use_mb_flag && (l = my_ismbchar(charset_info, from, end)))
  2432.     {
  2433.       while (l--)
  2434.   *to++ = *from++;
  2435.       from--;
  2436.       continue;
  2437.     }
  2438. #endif
  2439.     switch (*from) {
  2440.     case 0: /* Must be escaped for 'mysql' */
  2441.       *to++= '\';
  2442.       *to++= '0';
  2443.       break;
  2444.     case 'n': /* Must be escaped for logs */
  2445.       *to++= '\';
  2446.       *to++= 'n';
  2447.       break;
  2448.     case 'r':
  2449.       *to++= '\';
  2450.       *to++= 'r';
  2451.       break;
  2452.     case '\':
  2453.       *to++= '\';
  2454.       *to++= '\';
  2455.       break;
  2456.     case ''':
  2457.       *to++= '\';
  2458.       *to++= ''';
  2459.       break;
  2460.     case '"': /* Better safe than sorry */
  2461.       *to++= '\';
  2462.       *to++= '"';
  2463.       break;
  2464.     case '32': /* This gives problems on Win32 */
  2465.       *to++= '\';
  2466.       *to++= 'Z';
  2467.       break;
  2468.     default:
  2469.       *to++= *from;
  2470.     }
  2471.   }
  2472.   *to=0;
  2473.   return (ulong) (to-to_start);
  2474. }
  2477. char * STDCALL
  2478. mysql_odbc_escape_string(MYSQL *mysql,
  2479.  char *to, ulong to_length,
  2480.  const char *from, ulong from_length,
  2481.  void *param,
  2482.  char * (*extend_buffer)
  2483.  (void *, char *, ulong *))
  2484. {
  2485.   char *to_end=to+to_length-5;
  2486.   const char *end;
  2487. #ifdef USE_MB
  2488.   my_bool use_mb_flag=use_mb(mysql->charset);
  2489. #endif
  2491.   for (end=from+from_length; from != end ; from++)
  2492.   {
  2493.     if (to >= to_end)
  2494.     {
  2495.       to_length = (ulong) (end-from)+512; /* We want this much more */
  2496.       if (!(to=(*extend_buffer)(param, to, &to_length)))
  2497. return to;
  2498.       to_end=to+to_length-5;
  2499.     }
  2500. #ifdef USE_MB
  2501.     {
  2502.       int l;
  2503.       if (use_mb_flag && (l = my_ismbchar(mysql->charset, from, end)))
  2504.       {
  2505. while (l--)
  2506.   *to++ = *from++;
  2507. from--;
  2508. continue;
  2509.       }
  2510.     }
  2511. #endif
  2512.     switch (*from) {
  2513.     case 0: /* Must be escaped for 'mysql' */
  2514.       *to++= '\';
  2515.       *to++= '0';
  2516.       break;
  2517.     case 'n': /* Must be escaped for logs */
  2518.       *to++= '\';
  2519.       *to++= 'n';
  2520.       break;
  2521.     case 'r':
  2522.       *to++= '\';
  2523.       *to++= 'r';
  2524.       break;
  2525.     case '\':
  2526.       *to++= '\';
  2527.       *to++= '\';
  2528.       break;
  2529.     case ''':
  2530.       *to++= '\';
  2531.       *to++= ''';
  2532.       break;
  2533.     case '"': /* Better safe than sorry */
  2534.       *to++= '\';
  2535.       *to++= '"';
  2536.       break;
  2537.     case '32': /* This gives problems on Win32 */
  2538.       *to++= '\';
  2539.       *to++= 'Z';
  2540.       break;
  2541.     default:
  2542.       *to++= *from;
  2543.     }
  2544.   }
  2545.   return to;
  2546. }
  2548. void STDCALL
  2549. myodbc_remove_escape(MYSQL *mysql,char *name)
  2550. {
  2551.   char *to;
  2552. #ifdef USE_MB
  2553.   my_bool use_mb_flag=use_mb(mysql->charset);
  2554.   char *end;
  2555.   LINT_INIT(end);
  2556.   if (use_mb_flag)
  2557.     for (end=name; *end ; end++) ;
  2558. #endif
  2560.   for (to=name ; *name ; name++)
  2561.   {
  2562. #ifdef USE_MB
  2563.     int l;
  2564.     if (use_mb_flag && (l = my_ismbchar( mysql->charset, name , end ) ) )
  2565.     {
  2566.       while (l--)
  2567. *to++ = *name++;
  2568.       name--;
  2569.       continue;
  2570.     }
  2571. #endif
  2572.     if (*name == '\' && name[1])
  2573.       name++;
  2574.     *to++= *name;
  2575.   }
  2576.   *to=0;
  2577. }