home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / sql / mini_client.cpp < prev    next >
C/C++ Source or Header  |  2000-11-16  |  23KB  |  810 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program 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
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  16.  
  17. /*
  18.  mini MySQL client to be included into the server to do server to server
  19.  commincation by Sasha Pachev
  20.  
  21.  Note: all file-global symbols must begin with mc_ , even the static ones, just
  22.  in case we decide to make them external at some point
  23.  */
  24.  
  25. #define DONT_USE_RAID
  26. #if defined(__WIN__) || defined(WIN32)
  27. #include <winsock.h>
  28. #include <odbcinst.h>
  29. #endif
  30. #include <global.h>
  31. #include <my_sys.h>
  32. #include <mysys_err.h>
  33. #include <m_string.h>
  34. #include <m_ctype.h>
  35. #include "mysql.h"
  36. #include "mini_client.h"
  37. #include "mysql_version.h"
  38. #include "mysqld_error.h"
  39. #include "errmsg.h"
  40. #include <violite.h>
  41. #include <sys/stat.h>
  42. #include <signal.h>
  43. #ifdef     HAVE_PWD_H
  44. #include <pwd.h>
  45. #endif
  46. #if !defined(MSDOS) && !defined(__WIN__)
  47. #include <sys/socket.h>
  48. #include <netinet/in.h>
  49. #include <arpa/inet.h>
  50. #include <netdb.h>
  51. #ifdef HAVE_SELECT_H
  52. #  include <select.h>
  53. #endif
  54. #ifdef HAVE_SYS_SELECT_H
  55. #include <sys/select.h>
  56. #endif
  57. #endif
  58. #ifdef HAVE_SYS_UN_H
  59. #  include <sys/un.h>
  60. #endif
  61. #if defined(THREAD) && !defined(__WIN__)
  62. #include <my_pthread.h>                /* because of signal()    */
  63. #endif
  64. #ifndef INADDR_NONE
  65. #define INADDR_NONE    -1
  66. #endif
  67.  
  68.  
  69. static void mc_end_server(MYSQL *mysql);
  70. static int mc_sock_connect(File s, const struct sockaddr *name, uint namelen, uint to);
  71. static void mc_free_old_query(MYSQL *mysql);
  72.  
  73.  
  74. #define CLIENT_CAPABILITIES    (CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG | CLIENT_LOCAL_FILES)
  75.  
  76. #if defined(MSDOS) || defined(__WIN__)
  77. #define ERRNO WSAGetLastError()
  78. #define perror(A)
  79. #else
  80. #include <sys/errno.h>
  81. #define ERRNO errno
  82. #define SOCKET_ERROR -1
  83. #define closesocket(A) close(A)
  84. #endif
  85.  
  86. #ifdef __WIN__
  87. static my_bool is_NT(void)
  88. {
  89.   char *os=getenv("OS");
  90.   return (os && !strcmp(os, "Windows_NT")) ? 1 : 0;
  91. }
  92. #endif
  93.  
  94. /*
  95. ** Create a named pipe connection
  96. */
  97.  
  98. #ifdef __WIN__
  99.  
  100. HANDLE create_named_pipe(NET *net, uint connect_timeout, char **arg_host,
  101.              char **arg_unix_socket)
  102. {
  103.   HANDLE hPipe=INVALID_HANDLE_VALUE;
  104.   char szPipeName [ 257 ];
  105.   DWORD dwMode;
  106.   int i;
  107.   my_bool testing_named_pipes=0;
  108.   char *host= *arg_host, *unix_socket= *arg_unix_socket;
  109.  
  110.   if (!host || !strcmp(host,LOCAL_HOST))
  111.     host=LOCAL_HOST_NAMEDPIPE;
  112.  
  113.   sprintf( szPipeName, "\\\\%s\\pipe\\%s", host, unix_socket);
  114.   DBUG_PRINT("info",("Server name: '%s'.  Named Pipe: %s",
  115.              host, unix_socket));
  116.  
  117.   for (i=0 ; i < 100 ; i++)            /* Don't retry forever */
  118.   {
  119.     if ((hPipe = CreateFile(szPipeName,
  120.                 GENERIC_READ | GENERIC_WRITE,
  121.                 0,
  122.                 NULL,
  123.                 OPEN_EXISTING,
  124.                 0,
  125.                 NULL )) != INVALID_HANDLE_VALUE)
  126.       break;
  127.     if (GetLastError() != ERROR_PIPE_BUSY)
  128.     {
  129.       net->last_errno=CR_NAMEDPIPEOPEN_ERROR;
  130.       sprintf(net->last_error,ER(net->last_errno),host, unix_socket,
  131.           (ulong) GetLastError());
  132.       return INVALID_HANDLE_VALUE;
  133.     }
  134.     /* wait for for an other instance */
  135.     if (! WaitNamedPipe(szPipeName, connect_timeout*1000) )
  136.     {
  137.       net->last_errno=CR_NAMEDPIPEWAIT_ERROR;
  138.       sprintf(net->last_error,ER(net->last_errno),host, unix_socket,
  139.           (ulong) GetLastError());
  140.       return INVALID_HANDLE_VALUE;
  141.     }
  142.   }
  143.   if (hPipe == INVALID_HANDLE_VALUE)
  144.   {
  145.     net->last_errno=CR_NAMEDPIPEOPEN_ERROR;
  146.     sprintf(net->last_error,ER(net->last_errno),host, unix_socket,
  147.         (ulong) GetLastError());
  148.     return INVALID_HANDLE_VALUE;
  149.   }
  150.   dwMode = PIPE_READMODE_BYTE | PIPE_WAIT;
  151.   if ( !SetNamedPipeHandleState(hPipe, &dwMode, NULL, NULL) )
  152.   {
  153.     CloseHandle( hPipe );
  154.     net->last_errno=CR_NAMEDPIPESETSTATE_ERROR;
  155.     sprintf(net->last_error,ER(net->last_errno),host, unix_socket,
  156.         (ulong) GetLastError());
  157.     return INVALID_HANDLE_VALUE;
  158.   }
  159.   *arg_host=host ; *arg_unix_socket=unix_socket;    /* connect arg */
  160.   return (hPipe);
  161. }
  162. #endif
  163.  
  164.  
  165. /****************************************************************************
  166. ** Init MySQL structure or allocate one
  167. ****************************************************************************/
  168.  
  169. MYSQL * STDCALL
  170. mc_mysql_init(MYSQL *mysql)
  171. {
  172.   init_client_errs();
  173.   if (!mysql)
  174.   {
  175.     if (!(mysql=(MYSQL*) my_malloc(sizeof(*mysql),MYF(MY_WME | MY_ZEROFILL))))
  176.       return 0;
  177.     mysql->free_me=1;
  178.     mysql->net.vio = 0;
  179.   }
  180.   else
  181.     bzero((char*) (mysql),sizeof(*(mysql)));
  182. #ifdef __WIN__
  183.   mysql->options.connect_timeout=20;
  184. #endif
  185.   return mysql;
  186. }
  187.  
  188. /**************************************************************************
  189. ** Shut down connection
  190. **************************************************************************/
  191.  
  192. static void
  193. mc_end_server(MYSQL *mysql)
  194. {
  195.   DBUG_ENTER("mc_end_server");
  196.   if (mysql->net.vio != 0)
  197.   {
  198.     DBUG_PRINT("info",("Net: %s", vio_description(mysql->net.vio)));
  199.     vio_delete(mysql->net.vio);
  200.     mysql->net.vio= 0;          /* Marker */
  201.   }
  202.   net_end(&mysql->net);
  203.   mc_free_old_query(mysql);
  204.   DBUG_VOID_RETURN;
  205. }
  206.  
  207. static void mc_free_old_query(MYSQL *mysql)
  208. {
  209.   DBUG_ENTER("mc_free_old_query");
  210.   if (mysql->fields)
  211.     free_root(&mysql->field_alloc,MYF(0));
  212.   else
  213.     init_alloc_root(&mysql->field_alloc,8192,0); /* Assume rowlength < 8192 */
  214.   mysql->fields=0;
  215.   mysql->field_count=0;                /* For API */
  216.   DBUG_VOID_RETURN;
  217. }
  218.  
  219.  
  220. /****************************************************************************
  221. * A modified version of connect().  mc_sock_connect() allows you to specify
  222. * a timeout value, in seconds, that we should wait until we
  223. * derermine we can't connect to a particular host.  If timeout is 0,
  224. * mc_sock_connect() will behave exactly like connect().
  225. *
  226. * Base version coded by Steve Bernacki, Jr. <steve@navinet.net>
  227. *****************************************************************************/
  228.  
  229. static int mc_sock_connect(my_socket s, const struct sockaddr *name,
  230.                uint namelen, uint to)
  231. {
  232. #if defined(__WIN__)
  233.   return connect(s, (struct sockaddr*) name, namelen);
  234. #else
  235.   int flags, res, s_err;
  236.   size_socket s_err_size = sizeof(uint);
  237.   fd_set sfds;
  238.   struct timeval tv;
  239.  
  240.   /* If they passed us a timeout of zero, we should behave
  241.    * exactly like the normal connect() call does.
  242.    */
  243.  
  244.   if (to == 0)
  245.     return connect(s, (struct sockaddr*) name, namelen);
  246.  
  247.   flags = fcntl(s, F_GETFL, 0);          /* Set socket to not block */
  248. #ifdef O_NONBLOCK
  249.   fcntl(s, F_SETFL, flags | O_NONBLOCK);  /* and save the flags..  */
  250. #endif
  251.  
  252.   res = connect(s, (struct sockaddr*) name, namelen);
  253.   s_err = errno;            /* Save the error... */
  254.   fcntl(s, F_SETFL, flags);
  255.   if ((res != 0) && (s_err != EINPROGRESS))
  256.   {
  257.     errno = s_err;            /* Restore it */
  258.     return(-1);
  259.   }
  260.   if (res == 0)                /* Connected quickly! */
  261.     return(0);
  262.  
  263.   /* Otherwise, our connection is "in progress."  We can use
  264.    * the select() call to wait up to a specified period of time
  265.    * for the connection to suceed.  If select() returns 0
  266.    * (after waiting howevermany seconds), our socket never became
  267.    * writable (host is probably unreachable.)  Otherwise, if
  268.    * select() returns 1, then one of two conditions exist:
  269.    *
  270.    * 1. An error occured.  We use getsockopt() to check for this.
  271.    * 2. The connection was set up sucessfully: getsockopt() will
  272.    * return 0 as an error.
  273.    *
  274.    * Thanks goes to Andrew Gierth <andrew@erlenstar.demon.co.uk>
  275.    * who posted this method of timing out a connect() in
  276.    * comp.unix.programmer on August 15th, 1997.
  277.    */
  278.  
  279.   FD_ZERO(&sfds);
  280.   FD_SET(s, &sfds);
  281.   tv.tv_sec = (long) to;
  282.   tv.tv_usec = 0;
  283. #ifdef HPUX
  284.   res = select(s+1, NULL, (int*) &sfds, NULL, &tv);
  285. #else
  286.   res = select(s+1, NULL, &sfds, NULL, &tv);
  287. #endif
  288.   if (res <= 0)                    /* Never became writable */
  289.     return(-1);
  290.  
  291.   /* select() returned something more interesting than zero, let's
  292.    * see if we have any errors.  If the next two statements pass,
  293.    * we've got an open socket!
  294.    */
  295.  
  296.   s_err=0;
  297.   if (getsockopt(s, SOL_SOCKET, SO_ERROR, (char*) &s_err, &s_err_size) != 0)
  298.     return(-1);
  299.  
  300.   if (s_err)
  301.   {                        /* getsockopt() could suceed */
  302.     errno = s_err;
  303.     return(-1);                    /* but return an error... */
  304.   }
  305.   return(0);                    /* It's all good! */
  306. #endif
  307. }
  308.  
  309. /*****************************************************************************
  310. ** read a packet from server. Give error message if socket was down
  311. ** or packet is an error message
  312. *****************************************************************************/
  313.  
  314. uint STDCALL
  315. mc_net_safe_read(MYSQL *mysql)
  316. {
  317.   NET *net= &mysql->net;
  318.   uint len=0;
  319.  
  320.   if (net->vio != 0)
  321.     len=my_net_read(net);
  322.  
  323.   if (len == packet_error || len == 0)
  324.   {
  325.     DBUG_PRINT("error",("Wrong connection or packet. fd: %s  len: %d",
  326.             vio_description(net->vio),len));
  327.     if(errno != EINTR)
  328.       {
  329.         mc_end_server(mysql);
  330.         net->last_errno=CR_SERVER_LOST;
  331.         strmov(net->last_error,ER(net->last_errno));
  332.       }    
  333.     return(packet_error);
  334.   }
  335.   if (net->read_pos[0] == 255)
  336.   {
  337.     if (len > 3)
  338.     {
  339.       char *pos=(char*) net->read_pos+1;
  340.       if (mysql->protocol_version > 9)
  341.       {                        /* New client protocol */
  342.     net->last_errno=uint2korr(pos);
  343.     pos+=2;
  344.     len-=2;
  345.     if(!net->last_errno)
  346.       net->last_errno = CR_UNKNOWN_ERROR;
  347.       }
  348.       else
  349.       {
  350.     net->last_errno=CR_UNKNOWN_ERROR;
  351.     len--;
  352.       }
  353.       (void) strmake(net->last_error,(char*) pos,
  354.              min(len,sizeof(net->last_error)-1));
  355.     }
  356.     else
  357.     {
  358.       net->last_errno=CR_UNKNOWN_ERROR;
  359.       (void) strmov(net->last_error,ER(net->last_errno));
  360.     }
  361.     DBUG_PRINT("error",("Got error: %d (%s)", net->last_errno,
  362.             net->last_error));
  363.     return(packet_error);
  364.   }
  365.   return len;
  366. }
  367.  
  368.  
  369. char * STDCALL mc_mysql_error(MYSQL *mysql)
  370. {
  371.   return (mysql)->net.last_error;
  372. }
  373.  
  374. int STDCALL mc_mysql_errno(MYSQL *mysql)
  375. {
  376.   return (mysql)->net.last_errno;
  377. }
  378.  
  379. my_bool STDCALL mc_mysql_reconnect(MYSQL *mysql)
  380. {
  381.   MYSQL tmp_mysql;
  382.   DBUG_ENTER("mc_mysql_reconnect");
  383.  
  384.   mc_mysql_init(&tmp_mysql);
  385.   tmp_mysql.options=mysql->options;
  386.   if (!mc_mysql_connect(&tmp_mysql,mysql->host,mysql->user,mysql->passwd,
  387.               mysql->db, mysql->port, mysql->unix_socket,
  388.               mysql->client_flag))
  389.     DBUG_RETURN(1);
  390.   tmp_mysql.free_me=mysql->free_me;
  391.   mysql->free_me=0;
  392.   bzero((char*) &mysql->options,sizeof(&mysql->options));
  393.   mc_mysql_close(mysql);
  394.   *mysql=tmp_mysql;
  395.   net_clear(&mysql->net);
  396.   mysql->affected_rows= ~(my_ulonglong) 0;
  397.   DBUG_RETURN(0);
  398. }
  399.  
  400.  
  401.  
  402. int STDCALL
  403. mc_simple_command(MYSQL *mysql,enum enum_server_command command, const char *arg,
  404.            uint length, my_bool skipp_check)
  405. {
  406.   NET *net= &mysql->net;
  407.   int result= -1;
  408.  
  409.   if (mysql->net.vio == 0)
  410.   {                        /* Do reconnect if possible */
  411.     if (mc_mysql_reconnect(mysql))
  412.     {
  413.       net->last_errno=CR_SERVER_GONE_ERROR;
  414.       strmov(net->last_error,ER(net->last_errno));
  415.       goto end;
  416.     }
  417.   }
  418.   if (mysql->status != MYSQL_STATUS_READY)
  419.   {
  420.     strmov(net->last_error,ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
  421.     goto end;
  422.   }
  423.  
  424.   mysql->net.last_error[0]=0;
  425.   mysql->net.last_errno=0;
  426.   mysql->info=0;
  427.   mysql->affected_rows= ~(my_ulonglong) 0;
  428.   net_clear(net);            /* Clear receive buffer */
  429.   if (!arg)
  430.     arg="";
  431.  
  432.   if (net_write_command(net,(uchar) command,arg,
  433.             length ? length :(uint) strlen(arg)))
  434.   {
  435.     DBUG_PRINT("error",("Can't send command to server. Error: %d",errno));
  436.     mc_end_server(mysql);
  437.     if (mc_mysql_reconnect(mysql) ||
  438.     net_write_command(net,(uchar) command,arg,
  439.               length ? length :(uint) strlen(arg)))
  440.     {
  441.       net->last_errno=CR_SERVER_GONE_ERROR;
  442.       strmov(net->last_error,ER(net->last_errno));
  443.       goto end;
  444.     }
  445.   }
  446.   result=0;
  447.   if (!skipp_check)
  448.     result= ((mysql->packet_length=mc_net_safe_read(mysql)) == packet_error ?
  449.          -1 : 0);
  450.  end:
  451.   return result;
  452. }
  453.  
  454.  
  455. MYSQL * STDCALL
  456. mc_mysql_connect(MYSQL *mysql,const char *host, const char *user,
  457.            const char *passwd, const char *db,
  458.            uint port, const char *unix_socket,uint client_flag)
  459. {
  460.   char        buff[100],*end,*host_info;
  461.   my_socket    sock;
  462.   ulong        ip_addr;
  463.   struct    sockaddr_in sock_addr;
  464.   uint        pkt_length;
  465.   NET        *net= &mysql->net;
  466. #ifdef __WIN__
  467.   HANDLE    hPipe=INVALID_HANDLE_VALUE;
  468. #endif
  469. #ifdef HAVE_SYS_UN_H
  470.   struct    sockaddr_un UNIXaddr;
  471. #endif
  472.   DBUG_ENTER("mysql_real_connect");
  473.  
  474.   DBUG_PRINT("enter",("host: %s  db: %s  user: %s",
  475.               host ? host : "(Null)",
  476.               db ? db : "(Null)",
  477.               user ? user : "(Null)"));
  478.  
  479.   bzero((char*) &mysql->options,sizeof(mysql->options));
  480.   net->vio = 0;                /* If something goes wrong */
  481.   mysql->charset=default_charset_info;  /* Set character set */
  482.   if (!port)
  483.     port = MYSQL_PORT;            /* Should always be set by mysqld */
  484.   if (!unix_socket)
  485.     unix_socket=MYSQL_UNIX_ADDR;
  486.  
  487.   mysql->reconnect=1;            /* Reconnect as default */
  488.  
  489.   /*
  490.   ** Grab a socket and connect it to the server
  491.   */
  492.  
  493. #if defined(HAVE_SYS_UN_H)
  494.   if (!host || !strcmp(host,LOCAL_HOST))
  495.   {
  496.     host=LOCAL_HOST;
  497.     host_info=(char*) ER(CR_LOCALHOST_CONNECTION);
  498.     DBUG_PRINT("info",("Using UNIX sock '%s'",unix_socket));
  499.     if ((sock = socket(AF_UNIX,SOCK_STREAM,0)) == SOCKET_ERROR)
  500.     {
  501.       net->last_errno=CR_SOCKET_CREATE_ERROR;
  502.       sprintf(net->last_error,ER(net->last_errno),ERRNO);
  503.       goto error;
  504.     }
  505.     net->vio = vio_new(sock, VIO_TYPE_SOCKET, TRUE);
  506.     bzero((char*) &UNIXaddr,sizeof(UNIXaddr));
  507.     UNIXaddr.sun_family = AF_UNIX;
  508.     strmov(UNIXaddr.sun_path, unix_socket);
  509.     if (mc_sock_connect(sock,(struct sockaddr *) &UNIXaddr, sizeof(UNIXaddr),
  510.             mysql->options.connect_timeout) <0)
  511.     {
  512.       DBUG_PRINT("error",("Got error %d on connect to local server",ERRNO));
  513.       net->last_errno=CR_CONNECTION_ERROR;
  514.       sprintf(net->last_error,ER(net->last_errno),unix_socket,ERRNO);
  515.       goto error;
  516.     }
  517.   }
  518.   else
  519. #elif defined(__WIN__)
  520.   {
  521.     if ((unix_socket ||
  522.      !host && is_NT() ||
  523.      host && !strcmp(host,LOCAL_HOST_NAMEDPIPE) ||
  524.      mysql->options.named_pipe || !have_tcpip))
  525.     {
  526.       sock=0;
  527.       if ((hPipe=create_named_pipe(net, mysql->options.connect_timeout,
  528.                    (char**) &host, (char**) &unix_socket)) ==
  529.       INVALID_HANDLE_VALUE)
  530.       {
  531.     DBUG_PRINT("error",
  532.            ("host: '%s'  socket: '%s'  named_pipe: %d  have_tcpip: %d",
  533.             host ? host : "<null>",
  534.             unix_socket ? unix_socket : "<null>",
  535.             (int) mysql->options.named_pipe,
  536.             (int) have_tcpip));
  537.     if (mysql->options.named_pipe ||
  538.         (host && !strcmp(host,LOCAL_HOST_NAMEDPIPE)) ||
  539.         (unix_socket && !strcmp(unix_socket,MYSQL_NAMEDPIPE)))
  540.       goto error;        /* User only requested named pipes */
  541.     /* Try also with TCP/IP */
  542.       }
  543.       else
  544.       {
  545.     net->vio=vio_new_win32pipe(hPipe);
  546.     sprintf(host_info=buff, ER(CR_NAMEDPIPE_CONNECTION), host,
  547.         unix_socket);
  548.       }
  549.     }
  550.   }
  551.   if (hPipe == INVALID_HANDLE_VALUE)
  552. #endif
  553.   {
  554.     unix_socket=0;                /* This is not used */
  555.     if (!host)
  556.       host=LOCAL_HOST;
  557.     sprintf(host_info=buff,ER(CR_TCP_CONNECTION),host);
  558.     DBUG_PRINT("info",("Server name: '%s'.  TCP sock: %d", host,port));
  559.     if ((sock = socket(AF_INET,SOCK_STREAM,0)) == SOCKET_ERROR)
  560.     {
  561.       net->last_errno=CR_IPSOCK_ERROR;
  562.       sprintf(net->last_error,ER(net->last_errno),ERRNO);
  563.       goto error;
  564.     }
  565.     net->vio = vio_new(sock,VIO_TYPE_TCPIP,FALSE);
  566.     bzero((char*) &sock_addr,sizeof(sock_addr));
  567.     sock_addr.sin_family = AF_INET;
  568.  
  569.     /*
  570.     ** The server name may be a host name or IP address
  571.     */
  572.  
  573.     if ((int) (ip_addr = inet_addr(host)) != (int) INADDR_NONE)
  574.     {
  575.       memcpy_fixed(&sock_addr.sin_addr,&ip_addr,sizeof(ip_addr));
  576.     }
  577.     else
  578. #if defined(HAVE_GETHOSTBYNAME_R) && defined(_REENTRANT) && defined(THREAD)
  579.     {
  580.       int tmp_errno;
  581.       struct hostent tmp_hostent,*hp;
  582.       char buff2[GETHOSTBYNAME_BUFF_SIZE];
  583.       hp = my_gethostbyname_r(host,&tmp_hostent,buff2,sizeof(buff2),
  584.                   &tmp_errno);
  585.       if (!hp)
  586.       {
  587.     net->last_errno=CR_UNKNOWN_HOST;
  588.     sprintf(net->last_error, ER(CR_UNKNOWN_HOST), host, tmp_errno);
  589.     goto error;
  590.       }
  591.       memcpy(&sock_addr.sin_addr,hp->h_addr, (size_t) hp->h_length);
  592.     }
  593. #else
  594.     {
  595.       struct hostent *hp;
  596.       if (!(hp=gethostbyname(host)))
  597.       {
  598.     net->last_errno=CR_UNKNOWN_HOST;
  599.     sprintf(net->last_error, ER(CR_UNKNOWN_HOST), host, errno);
  600.     goto error;
  601.       }
  602.       memcpy(&sock_addr.sin_addr,hp->h_addr, (size_t) hp->h_length);
  603.     }
  604. #endif
  605.     sock_addr.sin_port = (ushort) htons((ushort) port);
  606.     if (mc_sock_connect(sock,(struct sockaddr *) &sock_addr, sizeof(sock_addr),
  607.          mysql->options.connect_timeout) <0)
  608.     {
  609.       DBUG_PRINT("error",("Got error %d on connect to '%s'",ERRNO,host));
  610.       net->last_errno= CR_CONN_HOST_ERROR;
  611.       sprintf(net->last_error ,ER(CR_CONN_HOST_ERROR), host, ERRNO);
  612.       goto error;
  613.     }
  614.   }
  615.  
  616.   if (!net->vio || my_net_init(net, net->vio))
  617.   {
  618.     vio_delete(net->vio);
  619.     net->vio = 0; // safety
  620.     net->last_errno=CR_OUT_OF_MEMORY;
  621.     strmov(net->last_error,ER(net->last_errno));
  622.     goto error;
  623.   }
  624.   vio_keepalive(net->vio,TRUE);
  625.  
  626.   /* Get version info */
  627.   mysql->protocol_version= PROTOCOL_VERSION;    /* Assume this */
  628.   if ((pkt_length=mc_net_safe_read(mysql)) == packet_error)
  629.     goto error;
  630.  
  631.   /* Check if version of protocoll matches current one */
  632.  
  633.   mysql->protocol_version= net->read_pos[0];
  634.   DBUG_DUMP("packet",(char*) net->read_pos,10);
  635.   DBUG_PRINT("info",("mysql protocol version %d, server=%d",
  636.              PROTOCOL_VERSION, mysql->protocol_version));
  637.   if (mysql->protocol_version != PROTOCOL_VERSION &&
  638.       mysql->protocol_version != PROTOCOL_VERSION-1)
  639.   {
  640.     net->last_errno= CR_VERSION_ERROR;
  641.     sprintf(net->last_error, ER(CR_VERSION_ERROR), mysql->protocol_version,
  642.         PROTOCOL_VERSION);
  643.     goto error;
  644.   }
  645.   end=strend((char*) net->read_pos+1);
  646.   mysql->thread_id=uint4korr(end+1);
  647.   end+=5;
  648.   strmake(mysql->scramble_buff,end,8);
  649.   if (pkt_length > (uint) (end+9 - (char*) net->read_pos))
  650.     mysql->server_capabilities=uint2korr(end+9);
  651.  
  652.   /* Save connection information */
  653.   if (!user) user="";
  654.   if (!passwd) passwd="";
  655.   if (!my_multi_malloc(MYF(0),
  656.                &mysql->host_info, (uint) strlen(host_info)+1,
  657.                &mysql->host,      (uint) strlen(host)+1,
  658.                &mysql->unix_socket,
  659.                unix_socket ? (uint) strlen(unix_socket)+1 : (uint) 1,
  660.                &mysql->server_version,
  661.                (uint) (end - (char*) net->read_pos),
  662.                NullS) ||
  663.       !(mysql->user=my_strdup(user,MYF(0))) ||
  664.       !(mysql->passwd=my_strdup(passwd,MYF(0))))
  665.   {
  666.     strmov(net->last_error, ER(net->last_errno=CR_OUT_OF_MEMORY));
  667.     goto error;
  668.   }
  669.   strmov(mysql->host_info,host_info);
  670.   strmov(mysql->host,host);
  671.   if (unix_socket)
  672.     strmov(mysql->unix_socket,unix_socket);
  673.   else
  674.     mysql->unix_socket=0;
  675.   strmov(mysql->server_version,(char*) net->read_pos+1);
  676.   mysql->port=port;
  677.   mysql->client_flag=client_flag | mysql->options.client_flag;
  678.   DBUG_PRINT("info",("Server version = '%s'  capabilites: %ld",
  679.              mysql->server_version,mysql->server_capabilities));
  680.  
  681.   /* Send client information for access check */
  682.   client_flag|=CLIENT_CAPABILITIES;
  683.  
  684. #ifdef HAVE_OPENSSL
  685.   if (mysql->options.use_ssl)
  686.     client_flag|=CLIENT_SSL;
  687. #endif /* HAVE_OPENSSL */
  688.  
  689.   if (db)
  690.     client_flag|=CLIENT_CONNECT_WITH_DB;
  691. #ifdef HAVE_COMPRESS
  692.   if (mysql->server_capabilities & CLIENT_COMPRESS &&
  693.       (mysql->options.compress || client_flag & CLIENT_COMPRESS))
  694.     client_flag|=CLIENT_COMPRESS;        /* We will use compression */
  695.   else
  696. #endif
  697.     client_flag&= ~CLIENT_COMPRESS;
  698.  
  699. #ifdef HAVE_OPENSSL
  700.   if ((mysql->server_capabilities & CLIENT_SSL) &&
  701.       (mysql->options.use_ssl || (client_flag & CLIENT_SSL)))
  702.   {
  703.     DBUG_PRINT("info", ("Changing IO layer to SSL"));
  704.     client_flag |= CLIENT_SSL;
  705.   }
  706.   else
  707.   {
  708.     if (client_flag & CLIENT_SSL)
  709.     {
  710.       DBUG_PRINT("info", ("Leaving IO layer intact because server doesn't support SSL"));
  711.     }
  712.     client_flag &= ~CLIENT_SSL;
  713.   }
  714. #endif /* HAVE_OPENSSL */
  715.  
  716.   int2store(buff,client_flag);
  717.   mysql->client_flag=client_flag;
  718.  
  719. #ifdef HAVE_OPENSSL
  720.   /* Oops.. are we careful enough to not send ANY information */
  721.   /* without encryption? */
  722.   if (client_flag & CLIENT_SSL)
  723.   {
  724.     if (my_net_write(net,buff,(uint) (2)) || net_flush(net))
  725.       goto error;
  726.     /* Do the SSL layering. */
  727.     DBUG_PRINT("info", ("IO layer change in progress..."));
  728.     VioSSLConnectorFd* connector_fd = (VioSSLConnectorFd*)
  729.       (mysql->connector_fd);
  730.     VioSocket*    vio_socket = (VioSocket*)(mysql->net.vio);
  731.     VioSSL*    vio_ssl =    connector_fd->connect(vio_socket);
  732.     mysql->net.vio =         (NetVio*)(vio_ssl);
  733.   }
  734. #endif /* HAVE_OPENSSL */
  735.  
  736.   int3store(buff+2,max_allowed_packet);
  737.   if (user && user[0])
  738.     strmake(buff+5,user,32);
  739.   else
  740.     {
  741.       user = getenv("USER");
  742.       if(!user) user = "mysql";
  743.        strmov((char*) buff+5, user );
  744.     }
  745.  
  746.   DBUG_PRINT("info",("user: %s",buff+5));
  747.   end=scramble(strend(buff+5)+1, mysql->scramble_buff, passwd,
  748.            (my_bool) (mysql->protocol_version == 9));
  749.   if (db)
  750.   {
  751.     end=strmov(end+1,db);
  752.     mysql->db=my_strdup(db,MYF(MY_WME));
  753.   }
  754.   if (my_net_write(net,buff,(uint) (end-buff)) || net_flush(net) ||
  755.       mc_net_safe_read(mysql) == packet_error)
  756.     goto error;
  757.   if (client_flag & CLIENT_COMPRESS)        /* We will use compression */
  758.     net->compress=1;
  759.   DBUG_PRINT("exit",("Mysql handler: %lx",mysql));
  760.   DBUG_RETURN(mysql);
  761.  
  762. error:
  763.   DBUG_PRINT("error",("message: %u (%s)",net->last_errno,net->last_error));
  764.   {
  765.     /* Free alloced memory */
  766.     my_bool free_me=mysql->free_me;
  767.     mc_end_server(mysql);
  768.     mysql->free_me=0;
  769.     mc_mysql_close(mysql);
  770.     mysql->free_me=free_me;
  771.   }
  772.   DBUG_RETURN(0);
  773. }
  774.  
  775. /*************************************************************************
  776. ** Send a QUIT to the server and close the connection
  777. ** If handle is alloced by mysql connect free it.
  778. *************************************************************************/
  779.  
  780. void STDCALL
  781. mc_mysql_close(MYSQL *mysql)
  782. {
  783.   DBUG_ENTER("mysql_close");
  784.   if (mysql)                    /* Some simple safety */
  785.   {
  786.     if (mysql->net.vio != 0)
  787.     {
  788.       mc_free_old_query(mysql);
  789.       mysql->status=MYSQL_STATUS_READY; /* Force command */
  790.       mc_simple_command(mysql,COM_QUIT,NullS,0,1);
  791.       mc_end_server(mysql);
  792.     }
  793.     my_free((gptr) mysql->host_info,MYF(MY_ALLOW_ZERO_PTR));
  794.     my_free(mysql->user,MYF(MY_ALLOW_ZERO_PTR));
  795.     my_free(mysql->passwd,MYF(MY_ALLOW_ZERO_PTR));
  796.     my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
  797.     /* Clear pointers for better safety */
  798.     mysql->host_info=mysql->user=mysql->passwd=mysql->db=0;
  799.     bzero((char*) &mysql->options,sizeof(mysql->options));
  800.     mysql->net.vio = 0;
  801. #ifdef HAVE_OPENSSL
  802.     ((VioConnectorFd*)(mysql->connector_fd))->delete();
  803.     mysql->connector_fd = 0;
  804. #endif /* HAVE_OPENSSL */
  805.     if (mysql->free_me)
  806.       my_free((gptr) mysql,MYF(0));
  807.   }
  808.   DBUG_VOID_RETURN;
  809. }
  810.