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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
libmysql.c
资源名称：myodbc-2_50_17a-src.zip　[点击查看]
上传用户：jmzj888
上传日期：2007-01-02
资源大小：220k
文件大小：38k
源码类别：

MySQL数据库

开发平台：

Visual C++

libmysql.c：源码内容
  1. /* Copyright Abandoned 1996 TCX DataKonsult AB & Monty Program KB & Detron HB
  2.    This file is public domain and comes with NO WARRANTY of any kind */
  4. #ifdef _WIN32
  5. #include <winsock.h>
  6. #include <odbcinst.h>
  7. #endif
  8. #include <global.h>
  9. #include <my_sys.h>
  10. #include <m_string.h>
  11. #include <m_ctype.h>
  12. #include "mysql.h"
  13. #include "mysql_version.h"
  14. #include "errmsg.h"
  15. #include <sys/stat.h>
  16. #include <signal.h>
  17. #ifdef  HAVE_PWD_H
  18. #include <pwd.h>
  19. #endif
  20. #if !defined(MSDOS) && !defined(__WIN32__)
  21. #include <sys/socket.h>
  22. #include <netinet/in.h>
  23. #include <arpa/inet.h>
  24. #include <netdb.h>
  25. #endif
  26. #ifdef HAVE_SYS_UN_H
  27. #  include <sys/un.h>
  28. #endif
  29. #if defined(THREAD) && !defined(__WIN32__)
  30. #include <my_pthread.h> /* because of signal() */
  31. #endif
  32. #ifndef INADDR_NONE
  33. #define INADDR_NONE -1
  34. #endif
  36. static my_bool mysql_client_init=0;
  37. static MYSQL *current_mysql;
  38. uint mysql_port=0;
  39. my_string mysql_unix_port=0;
  41. #define CLIENT_CAPABILITIES (CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG)
  43. #if defined(MSDOS) || defined(__WIN32__)
  44. #define ERRNO WSAGetLastError()
  45. #define perror(A)
  46. #else
  47. #define ERRNO errno
  48. #define SOCKET_ERROR -1
  49. #define closesocket(A) close(A)
  50. #endif
  52. static MYSQL_DATA *read_rows (MYSQL *mysql,MYSQL_FIELD *fields,
  53.       uint field_count);
  54. static void end_server(MYSQL *mysql);
  55. static void remember_connection(MYSQL *mysql);
  56. static void read_user_name(char *name);
  57. static void append_wild(char *to,char *end,const char *wild);
  60. /*****************************************************************************
  61. ** read a packet from server. Give error message if socket was down
  62. ** or package is an error message
  63. *****************************************************************************/
  65. static uint
  66. net_safe_read(MYSQL *mysql)
  67. {
  68.   NET *net= &mysql->net;
  69.   uint len=0;
  71.   if (net->fd < 0 || ((len=my_net_read(net)) == packet_error || len == 0))
  72.   {
  73.     DBUG_PRINT("error",("Wrong connection or packet. fd: %d  len: %d",
  74. net->fd,len));
  75.     end_server(mysql);
  76.     net->last_errno=CR_SERVER_LOST;
  77.     strmov(net->last_error,ER(net->last_errno));
  78.     return(packet_error);
  79.   }
  80.   if (net->buff[0] == 255)
  81.   {
  82.     if (len > 3)
  83.     {
  84.       char *pos=(char*) net->buff+1;
  85.       if (mysql->protocol_version > 9)
  86.       { /* New client protocol */
  87. net->last_errno=uint2korr(pos);
  88. pos+=2;
  89.       }
  90.       else
  91. net->last_errno=CR_UNKNOWN_ERROR;
  92.       (void) strmake(net->last_error,(char*) pos, sizeof(net->last_error)-1);
  93.     }
  94.     else
  95.     {
  96.       net->last_errno=CR_UNKNOWN_ERROR;
  97.       (void) strmov(net->last_error,ER(net->last_errno));
  98.     }
  99.     DBUG_PRINT("error",("Got error: %d (%s)", net->last_errno,
  100. net->last_error));
  101.     return(packet_error);
  102.   }
  103.   return len;
  104. }
  107. /* Get the length of next field. Change parameter to point at fieldstart */
  108. static ulong
  109. net_field_length(uchar **packet)
  110. {
  111.   reg1 uchar *pos= *packet;
  112.   if (*pos < 251)
  113.   {
  114.     (*packet)++;
  115.     return (ulong) *pos;
  116.   }
  117.   if (*pos == 251)
  118.   {
  119.     (*packet)++;
  120.     return NULL_LENGTH;
  121.   }
  122.   if (*pos == 252)
  123.   {
  124.     (*packet)+=3;
  125.     return uint2korr(pos+1);
  126.   }
  127.   if (*pos == 253)
  128.   {
  129.     (*packet)+=4;
  130.     return uint3korr(pos+1);
  131.   }
  132.   (*packet)+=6; /* Must be 254 when here */
  133.   return uint4korr(pos+1);
  134. }
  136. static void free_rows(MYSQL_DATA *cur)
  137. {
  138.   if (cur)
  139.   {
  140.     free_root(&cur->alloc);
  141.     my_free((gptr) cur,MYF(0));
  142.   }
  143. }
  146. static my_bool mysql_reconnect(MYSQL *mysql)
  147. {
  148.   MYSQL tmp_mysql;
  149.   DBUG_ENTER("mysql_reconnect");
  151.   if (!mysql->reconnect || !mysql->host_info)
  152.     DBUG_RETURN(1);
  153.   if (!mysql_real_connect(&tmp_mysql,mysql->host,mysql->user,mysql->passwd,
  154.   mysql->db, mysql->port, mysql->unix_socket,
  155.   mysql->client_flag))
  156.     DBUG_RETURN(1);
  157.   tmp_mysql.free_me=mysql->free_me;
  158.   mysql->free_me=0;
  159.   mysql_close(mysql);
  160.   memcpy(mysql,&tmp_mysql,sizeof(tmp_mysql));
  161.   net_clear(&mysql->net);
  162.   mysql->affected_rows= (ulong) ~0L;
  163.   DBUG_RETURN(0);
  164. }
  167. static int
  168. simple_command(MYSQL *mysql,enum enum_server_command command, const char *arg,
  169.        uint length, my_bool skipp_check)
  170. {
  171.   NET *net= &mysql->net;
  173.   if (mysql->net.fd < 0)
  174.   { /* Do reconnect if possible */
  175.     if (mysql_reconnect(mysql))
  176.     {
  177.       net->last_errno=CR_SERVER_GONE_ERROR;
  178.       strmov(net->last_error,ER(net->last_errno));
  179.       return -1;
  180.     }
  181.   }
  182.   if (mysql->status != MYSQL_STATUS_READY)
  183.   {
  184.     strmov(net->last_error,ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
  185.     return -1;
  186.   }
  188.   mysql->net.last_error[0]=0;
  189.   mysql->net.last_errno=0;
  190.   mysql->info=0;
  191.   mysql->affected_rows= (ulong) ~0L;
  192.   remember_connection(mysql);
  193.   net_clear(net); /* Clear receive buffer */
  194.   if (!arg)
  195.     arg="";
  196.   if (net_write_command(net,(uchar) command,arg,
  197. length ? length :strlen(arg)))
  198.   {
  199.     DBUG_PRINT("error",("Can't send command to server. Error: %d",errno));
  200.     end_server(mysql);
  201.     if (mysql_reconnect(mysql) ||
  202. net_write_command(net,(uchar) command,arg,
  203.   length ? length :strlen(arg)))
  204.     {
  205.       net->last_errno=CR_SERVER_GONE_ERROR;
  206.       strmov(net->last_error,ER(net->last_errno));
  207.       return -1;
  208.     }
  209.   }
  210.   if (!skipp_check)
  211.     return (net_safe_read(mysql) == packet_error ? -1 : 0);
  212.   return 0;
  213. }
  216. static void free_old_query(MYSQL *mysql)
  217. {
  218.   DBUG_ENTER("free_old_query");
  219.   if (mysql->fields)
  220.     free_root(&mysql->field_alloc);
  221.   init_alloc_root(&mysql->field_alloc,8192); /* Assume rowlength < 8192 */
  222.   mysql->fields=0;
  223.   mysql->field_count=0; /* For API */
  224.   DBUG_VOID_RETURN;
  225. }
  227. #define USERNAMELENGTH 16
  229. #if !defined(MSDOS) && ! defined(VMS) && !defined(__WIN32__)
  230. static void read_user_name(char *name)
  231. {
  232.   DBUG_ENTER("read_user_name");
  233.   if (geteuid() == 0)
  234.     (void) strmov(name,"root"); /* allow use of surun */
  235.   else
  236.   {
  237. #ifdef HAVE_GETPWUID
  238.     struct passwd *skr,*getpwuid();
  239.     char *str,*getlogin();
  241.     if ((str=getlogin()) == NULL)
  242.       if ((skr=getpwuid(geteuid())) != NULL)
  243. str=skr->pw_name;
  244.       else if (!(str=getenv("USER")) && !(str=getenv("LOGNAME")) &&
  245.        !(str=getenv("LOGIN")))
  246. str="UNKNOWN_USER";
  247.     (void) strmake(name,str,USERNAMELENGTH);
  248. #elif HAVE_CUSERID
  249.     (void) cuserid(name);
  250. #else
  251.     strmov(name,"UNKNOWN_USER");
  252. #endif
  253.   }
  254.   DBUG_VOID_RETURN;
  255. }
  257. #else /* If MSDOS || VMS */
  259. static void read_user_name(char *name)
  260. {
  261.   strmov(name,"ODBC");  /* ODBC will send user variable */
  262. }
  264. #endif
  266. /*
  267. ** Expand wildcard to a sql string
  268. */
  270. static void
  271. append_wild(char *to, char *end, const char *wild)
  272. {
  273.   end-=5; /* Some extra */
  274.   if (wild && wild[0])
  275.   {
  276.     to=strmov(to," like '");
  277.     while (*wild && to < end)
  278.     {
  279.       if (*wild == '\' || *wild == ''')
  280. *to++='\';
  281.       *to++= *wild++;
  282.     }
  283.     if (*wild) /* Too small buffer */
  284.       *to++='%'; /* Nicer this way */
  285.     to[0]=''';
  286.     to[1]=0;
  287.   }
  288. }
  292. /**************************************************************************
  293. ** Init debugging if MYSQL_DEBUG environment variable is found
  294. **************************************************************************/
  296. void STDCALL
  297. mysql_debug(char *debug)
  298. {
  299. #ifndef DBUG_OFF
  300.   char *env;
  301.   if (_db_on_)
  302.     return; /* Already using debugging */
  303.   if (debug)
  304.   {
  305.     DEBUGGER_ON;
  306.     DBUG_PUSH(debug);
  307.   }
  308.   else if ((env = getenv("MYSQL_DEBUG")))
  309.   {
  310.     DEBUGGER_ON;
  311.     DBUG_PUSH(env);
  312. #if !defined(_WINVER) && !defined(WINVER)
  313.     puts("n-------------------------------------------------------");
  314.     puts("MYSQL_DEBUG found. libmysql started with the following:");
  315.     puts(env);
  316.     puts("-------------------------------------------------------n");
  317. #else
  318.     {
  319.       char buff[80];
  320.       strmov(strmov(buff,"libmysql: "),env);
  321.       MessageBox((HWND) 0,"Debugging variable MYSQL_DEBUG used",buff,MB_OK);
  322.     }
  323. #endif
  324.   }
  325. #endif
  326. }
  329. /**************************************************************************
  330. ** Store the server socket currently in use
  331. ** Used by pipe_handler if error on socket interrupt
  332. **************************************************************************/
  334. static void
  335. remember_connection(MYSQL *mysql)
  336. {
  337.   current_mysql = mysql;
  338. }
  340. /**************************************************************************
  341. ** Close the server connection if we get a SIGPIPE
  342.    ARGSUSED
  343. **************************************************************************/
  345. static sig_handler
  346. pipe_sig_handle(int sig __attribute__((unused)))
  347. {
  348.   DBUG_PRINT("info",("Hit by signal %d",sig));
  349. #ifdef NOT_USED
  350.   end_server(current_mysql);
  351. #endif
  352. #ifdef DONT_REMEMBER_SIGNAL
  353.   (void) signal(SIGPIPE,pipe_sig_handle);
  354. #endif
  355. }
  358. /**************************************************************************
  359. ** Shut down connection
  360. **************************************************************************/
  362. static void
  363. end_server(MYSQL *mysql)
  364. {
  365.   DBUG_ENTER("end_server");
  366.   if (mysql->net.fd >= 0)
  367.   {
  368.     DBUG_PRINT("enter",("Socket: %d", mysql->net.fd));
  369.     (void) shutdown(mysql->net.fd,2);
  370.     (void) closesocket(mysql->net.fd);
  371.     mysql->net.fd= -1;
  372.     net_end(&mysql->net);
  373.     free_old_query(mysql);
  374.   }
  375.   DBUG_VOID_RETURN;
  376. }
  379. void STDCALL
  380. mysql_free_result(MYSQL_RES *result)
  381. {
  382.   DBUG_ENTER("mysql_free_result");
  383.   DBUG_PRINT("enter",("mysql_res: %lx",result));
  384.   if (result)
  385.   {
  386.     free_rows(result->data);
  387.     if (result->fields)
  388.       free_root(&result->field_alloc);
  389.     if (result->row)
  390.       my_free((gptr) result->row,MYF(0));
  391.     my_free((gptr) result,MYF(0));
  392.   }
  393.   DBUG_VOID_RETURN;
  394. }
  397. /***************************************************************************
  398. ** Change field rows to field structs
  399. ***************************************************************************/
  401. static MYSQL_FIELD *
  402. unpack_fields(MYSQL_DATA *data,MEM_ROOT *alloc,uint fields,
  403.       my_bool default_value, my_bool long_flag_protocol)
  404. {
  405.   MYSQL_ROWS *row;
  406.   MYSQL_FIELD *field,*result;
  407.   DBUG_ENTER("unpack_fields");
  409.   field=result=(MYSQL_FIELD*) alloc_root(alloc,sizeof(MYSQL_FIELD)*fields);
  410.   if (!result)
  411.     DBUG_RETURN(0);
  413.   for (row=data->data; row ; row = row->next,field++)
  414.   {
  415.     field->table=  strdup_root(alloc,(char*) row->data[0]);
  416.     field->name=   strdup_root(alloc,(char*) row->data[1]);
  417.     field->length= (uint) uint3korr(row->data[2]);
  418.     field->type=   (enum enum_field_types) (uchar) row->data[3][0];
  419.     if (long_flag_protocol)
  420.     {
  421.       field->flags=   uint2korr(row->data[4]);
  422.       field->decimals=(uint) (uchar) row->data[4][2];
  423.     }
  424.     else
  425.     {
  426.       field->flags=   (uint) (uchar) row->data[4][0];
  427.       field->decimals=(uint) (uchar) row->data[4][1];
  428.     }
  429.     if (default_value && row->data[5])
  430.       field->def=strdup_root(alloc,(char*) row->data[5]);
  431.     else
  432.       field->def=0;
  433.     field->max_length= 0;
  434.   }
  435.   free_rows(data); /* Free old data */
  436.   DBUG_RETURN(result);
  437. }
  440. /* Read all rows (fields or data) from server */
  442. static MYSQL_DATA *read_rows(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
  443.      uint fields)
  444. {
  445.   uint field,pkt_len;
  446.   ulong len;
  447.   uchar *cp;
  448.   char *to;
  449.   MYSQL_DATA *result;
  450.   MYSQL_ROWS **prev_ptr,*cur;
  451.   NET *net = &mysql->net;
  452.   DBUG_ENTER("read_rows");
  454.   if ((pkt_len=(uint) net_safe_read(mysql)) == packet_error)
  455.     DBUG_RETURN(0);
  456.   if (!(result=(MYSQL_DATA*) my_malloc(sizeof(MYSQL_DATA),
  457.        MYF(MY_WME | MY_ZEROFILL))))
  458.   {
  459.     net->last_errno=CR_OUT_OF_MEMORY;
  460.     strmov(net->last_error,ER(net->last_errno));
  461.     DBUG_RETURN(0);
  462.   }
  463.   init_alloc_root(&result->alloc,8192); /* Assume rowlength < 8192 */
  464.   result->alloc.min_malloc=sizeof(MYSQL_ROWS);
  465.   prev_ptr= &result->data;
  466.   result->rows=0;
  467.   result->fields=fields;
  469.   while (*(cp=net->buff) != 254 || pkt_len != 1)
  470.   {
  471.     result->rows++;
  472.     if (!(cur= (MYSQL_ROWS*) alloc_root(&result->alloc,
  473.     sizeof(MYSQL_ROWS))) ||
  474. !(cur->data= ((MYSQL_ROW)
  475.       alloc_root(&result->alloc,
  476.      (fields+1)*sizeof(char *)+pkt_len))))
  477.     {
  478.       free_rows(result);
  479.       net->last_errno=CR_OUT_OF_MEMORY;
  480.       strmov(net->last_error,ER(net->last_errno));
  481.       DBUG_RETURN(0);
  482.     }
  483.     *prev_ptr=cur;
  484.     prev_ptr= &cur->next;
  485.     to= (char*) (cur->data+fields+1);
  486.     for (field=0 ; field < fields ; field++)
  487.     {
  488.       if ((len=net_field_length(&cp)) == NULL_LENGTH)
  489.       { /* null field */
  490. cur->data[field] = 0;
  491.       }
  492.       else
  493.       {
  494. cur->data[field] = to;
  495. memcpy(to,(char*) cp,len); to[len]=0;
  496. to+=len+1;
  497. cp+=len;
  498. if (mysql_fields)
  499. {
  500.   if (mysql_fields[field].max_length < len)
  501.     mysql_fields[field].max_length=len;
  502. }
  503.       }
  504.     }
  505.     cur->data[field]=to; /* End of last field */
  506.     if ((pkt_len=net_safe_read(mysql)) == packet_error)
  507.     {
  508.       free_rows(result);
  509.       DBUG_RETURN(0);
  510.     }
  511.   }
  512.   *prev_ptr=0; /* last pointer is null */
  513.   DBUG_PRINT("exit",("Got %d rows",result->rows));
  514.   DBUG_RETURN(result);
  515. }
  518. /*
  519. ** Read one row. Uses packet buffer as storage for fields.
  520. ** When next package is read, the previous field values are destroyed
  521. */
  524. static int
  525. read_one_row(MYSQL *mysql,uint fields,MYSQL_ROW row, uint *lengths)
  526. {
  527.   uint field,pkt_len,len;
  528.   uchar *pos,*prev_pos;
  530.   if ((pkt_len=(uint) net_safe_read(mysql)) == packet_error)
  531.     return -1;
  532.   if (pkt_len == 1 && mysql->net.buff[0] == 254)
  533.     return 1; /* End of data */
  534.   prev_pos= 0; /* allowed to write at packet[-1] */
  535.   pos=mysql->net.buff;
  536.   for (field=0 ; field < fields ; field++)
  537.   {
  538.     if ((len=net_field_length(&pos)) == NULL_LENGTH)
  539.     { /* null field */
  540.       row[field] = 0;
  541.       *lengths++=0;
  542.     }
  543.     else
  544.     {
  545.       row[field] = (char*) pos;
  546.       pos+=len;
  547.       *lengths++=len;
  548.     }
  549.     if (prev_pos)
  550.       *prev_pos=0; /* Terminate prev field */
  551.     prev_pos=pos;
  552.   }
  553.   row[field]=(char*) prev_pos+1; /* End of last field */
  554.   *prev_pos=0; /* Terminate last field */
  555.   return 0;
  556. }
  559. /**************************************************************************
  560. ** Connect to sql server
  561. ** If host == 0 then use localhost
  562. **************************************************************************/
  564. MYSQL * STDCALL
  565. mysql_connect(MYSQL *mysql,const char *host,
  566.       const char *user, const char *passwd)
  567. {
  568.   return mysql_real_connect(mysql,host,user,passwd,NullS,0,NullS,0);
  569. }
  572. MYSQL * STDCALL
  573. mysql_real_connect(MYSQL *mysql,const char *host, const char *user,
  574.    const char *passwd, const char *db,
  575.    uint port, const char *unix_socket,uint client_flag)
  576. {
  577.   char buff[100],scramble_buff[9],*end,*host_info;
  578.   int sock;
  579.   ulong ip_addr;
  580.   struct sockaddr_in sock_addr;
  581.   uint pkt_length;
  582.   NET *net;
  583. #ifndef MSDOS
  584.   char *env;
  585.   int opt;
  586.   struct servent *serv_ptr;
  587. #endif
  589. #ifdef HAVE_SYS_UN_H
  590.   struct sockaddr_un UNIXaddr;
  591. #endif
  592.   DBUG_ENTER("mysql_connect");
  594. #ifndef DONT_USE_MYSQL_PWD
  595.   if (!passwd)
  596.     passwd=getenv("MYSQL_PWD");  /* read Password from environment (haneke) */
  597. #endif
  598.   if (!mysql_client_init)
  599.   {
  600.     mysql_client_init=1;
  601.     my_init();
  602.     init_client_errs();
  603.     if (!mysql_port)
  604.     {
  605.       mysql_port = MYSQL_PORT;
  606. #ifndef MSDOS
  607.       if ((serv_ptr = getservbyname("mysql", "tcp")))
  608. mysql_port = (uint) ntohs((ushort) serv_ptr->s_port);
  609.       if ((env = getenv("MYSQL_TCP_PORT")))
  610. mysql_port =(uint) atoi(env);
  611. #endif
  612.     }
  613. #ifndef MSDOS
  614.     if (!mysql_unix_port)
  615.     {
  616.       mysql_unix_port = MYSQL_UNIX_ADDR;
  617.       if ((env = getenv("MYSQL_UNIX_PORT")))
  618. mysql_unix_port = env;
  619.     }
  620. #endif
  621.     mysql_debug(NullS);
  622.   }
  624.   DBUG_PRINT("enter",("host: %s  db: %s",host ? host : "(Null)",
  625.       db ? db : "(Null)"));
  626.   if (!mysql)
  627.   {
  628.     if (!(mysql=(MYSQL*) my_malloc(sizeof(*mysql),MYF(MY_WME | MY_ZEROFILL))))
  629.       DBUG_RETURN(0);
  630.     mysql->free_me=1;
  631.   }
  632.   else
  633.     bzero(mysql,sizeof(*mysql));
  634.   remember_connection(mysql);
  635.   mysql->reconnect=1; /* Reconnect as default */
  636.   net= &mysql->net;
  637.   net->fd= -1; /* If something goes wrong */
  638.   if (!host && !(host=getenv("MYSQL_HOST")) || !host[0])
  639.     host=LOCAL_HOST;
  641.   /*
  642.   ** Grab a socket and connect it to the server
  643.   */
  645. #ifdef HAVE_SYS_UN_H
  646.   if (!strcmp(host,LOCAL_HOST) && (unix_socket || mysql_unix_port))
  647.   {
  648.     if (!unix_socket)
  649.       unix_socket=mysql_unix_port;
  650.     host_info=ER(CR_LOCALHOST_CONNECTION);
  651.     DBUG_PRINT("info",("Using UNIX sock '%s'",unix_socket));
  652.     if ((sock = socket(AF_UNIX,SOCK_STREAM,0)) == SOCKET_ERROR)
  653.     {
  654.       net->last_errno=CR_SOCKET_CREATE_ERROR;
  655.       strmov(net->last_error,ER(net->last_errno));
  656.       goto error;
  657.     }
  658.     net->fd=sock;
  659.     opt = 1;
  660.     (void) setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char *)&opt,
  661.       sizeof(opt));
  663.     bzero(&UNIXaddr,sizeof(UNIXaddr));
  664.     UNIXaddr.sun_family = AF_UNIX;
  665.     strmov(UNIXaddr.sun_path, unix_socket);
  666.     if (connect(sock,(struct sockaddr *) &UNIXaddr, sizeof(UNIXaddr)) <0)
  667.     {
  668.       DBUG_PRINT("error",("Got error %d on connect to local server",ERRNO));
  669.       net->last_errno=CR_CONNECTION_ERROR;
  670.       strmov(net->last_error,ER(net->last_errno));
  671.       goto error;
  672.     }
  673.   }
  674.   else
  675. #endif
  676.   {
  677.     if (!port)
  678.       port=mysql_port;
  679.     sprintf(host_info=buff,ER(CR_TCP_CONNECTION),host);
  680.     DBUG_PRINT("info",("Server name: '%s'.  TCP sock: %d", host,port));
  681.     if ((sock = socket(AF_INET,SOCK_STREAM,0)) == SOCKET_ERROR)
  682.     {
  683.       net->last_errno=CR_IPSOCK_ERROR;
  684.       strmov(net->last_error,ER(net->last_errno));
  685.       goto error;
  686.     }
  687.     net->fd=sock;
  688. #ifndef MSDOS
  689.     opt = 1;
  690.     (void) setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char *)&opt,
  691.       sizeof(opt));
  692. #endif
  693.     bzero(&sock_addr,sizeof(sock_addr));
  694.     sock_addr.sin_family = AF_INET;
  696.     /*
  697.     ** The server name may be a host name or IP address
  698.     */
  700.     if ((int) (ip_addr = inet_addr(host)) != (int) INADDR_NONE)
  701.     {
  702.       memcpy(&sock_addr.sin_addr,&ip_addr,sizeof(ip_addr));
  703.     }
  704.     else
  705. #if defined(HAVE_GETHOSTBYNAME_R) && defined(_REENTRANT) && defined(THREAD)
  706.     {
  707.       int tmp_errno;
  708.       struct hostent tmp_hostent,*hp;
  709.       char buff2[2048];
  710.       hp = gethostbyname_r(host,&tmp_hostent,buff2,sizeof(buff2),&tmp_errno);
  711.       if (!hp)
  712.       {
  713. net->last_errno=CR_UNKNOWN_HOST;
  714. sprintf(net->last_error, ER(CR_UNKNOWN_HOST), host, tmp_errno);
  715. goto error;
  716.       }
  717.       memcpy(&sock_addr.sin_addr,hp->h_addr, (size_t) hp->h_length);
  718.     }
  719. #else
  720.     {
  721.       struct hostent *hp;
  722.       if (!(hp=gethostbyname(host)))
  723.       {
  724. net->last_errno=CR_UNKNOWN_HOST;
  725. sprintf(net->last_error, ER(CR_UNKNOWN_HOST), host, errno);
  726. goto error;
  727.       }
  728.       memcpy(&sock_addr.sin_addr,hp->h_addr, (size_t) hp->h_length);
  729.     }
  730. #endif
  731.     sock_addr.sin_port = (ushort) htons((u_short) port);
  732.     if (connect(sock,(struct sockaddr *) &sock_addr, sizeof(sock_addr))<0)
  733.     {
  734.       DBUG_PRINT("error",("Got error %d on connect to '%s'",ERRNO,host));
  735.       net->last_errno= CR_CONN_HOST_ERROR;
  736.       sprintf(net->last_error ,ER(CR_CONN_HOST_ERROR), host, ERRNO);
  737.       goto error;
  738.     }
  739.   }
  741. #if defined(SIGPIPE)
  742.   (void) signal(SIGPIPE,SIG_IGN);
  743. #endif
  744.   DBUG_PRINT("info",("Connection socket %d",sock));
  745.   if (my_net_init(net,sock))
  746.     goto error;
  747.   /* Get version info */
  748.   mysql->protocol_version= PROTOCOL_VERSION; /* Assume this */
  749.   if ((pkt_length=net_safe_read(mysql)) == packet_error)
  750.     goto error;
  752.   /* Check if version of protocoll matches current one */
  754.   mysql->protocol_version= net->buff[0];
  755.   DBUG_DUMP("packet",(char*) net->buff,10);
  756.   DBUG_PRINT("info",("mysql protocol version %d, server=%d",
  757.      PROTOCOL_VERSION, mysql->protocol_version));
  758.   if (mysql->protocol_version != PROTOCOL_VERSION &&
  759.       mysql->protocol_version != PROTOCOL_VERSION-1)
  760.   {
  761.     net->last_errno= CR_VERSION_ERROR;
  762.     sprintf(net->last_error, ER(CR_VERSION_ERROR), mysql->protocol_version,
  763.     PROTOCOL_VERSION);
  764.     goto error;
  765.   }
  766.   end=strend((char*) net->buff+1);
  767.   mysql->thread_id=uint4korr(end+1);
  768.   end+=5;
  769.   strmov(scramble_buff,end);
  770.   if (pkt_length > (uint) (end+9 - (char*) net->buff))
  771.     mysql->server_capabilities=uint2korr(end+9);
  773.   /* Save connection information */
  774.   if (!user) user="";
  775.   if (!passwd) passwd="";
  776.   if (!my_multi_malloc(MYF(0),
  777.       &mysql->host_info,strlen(host_info)+1,
  778.       &mysql->host,strlen(host)+1,
  779.       &mysql->user,strlen(user)+1,
  780.       &mysql->passwd,strlen(passwd)+1,
  781.       &mysql->unix_socket,unix_socket ? strlen(unix_socket)+1
  782.       :1,
  783.       &mysql->server_version,(uint) (end - (char*) net->buff),
  784.       NullS))
  785.   {
  786.     strmov(net->last_error, ER(net->last_errno=CR_OUT_OF_MEMORY));
  787.     goto error;
  788.   }
  789.   strmov(mysql->host_info,host_info);
  790.   strmov(mysql->host,host);
  791.   strmov(mysql->user,user);
  792.   strmov(mysql->passwd,passwd);
  793.   if (unix_socket)
  794.     strmov(mysql->unix_socket,unix_socket);
  795.   else
  796.     mysql->unix_socket=0;
  797.   strmov(mysql->server_version,(char*) net->buff+1);
  798.   mysql->port=port;
  799.   mysql->client_flag=client_flag;
  800.   DBUG_PRINT("info",("Server version = '%s'",mysql->server_version));
  802.   /* Send client information for access check */
  803.   client_flag|=CLIENT_CAPABILITIES;
  804.   if (db)
  805.     client_flag|=CLIENT_CONNECT_WITH_DB;
  806.   int2store(buff,client_flag);
  807.   int3store(buff+2,max_allowed_packet);
  808.   if (user && user[0])
  809.     strmake(buff+5,user,32);
  810.   else
  811.     read_user_name((char*) buff+5);
  812.   DBUG_PRINT("info",("user: %s",buff+5));
  813.   end=scramble(strend(buff+5)+1, scramble_buff, passwd,
  814.        (my_bool) (mysql->protocol_version == 9));
  815.   if (db && (mysql->server_capabilities & CLIENT_CONNECT_WITH_DB))
  816.   {
  817.     end=strmov(end+1,db);
  818.     mysql->db=my_strdup(db,MYF(MY_WME));
  819.     db=0;
  820.   }
  821.   if (my_net_write(net,buff,(uint) (end-buff)) || net_flush(net) ||
  822.       net_safe_read(mysql) == packet_error)
  823.     goto error;
  824.   if (db && mysql_select_db(mysql,db))
  825.     goto error;
  826.   DBUG_PRINT("exit",("Mysql handler: %lx",mysql));
  827.   DBUG_RETURN(mysql);
  829. error:
  830.   DBUG_PRINT("error",("message: %u (%s)",net->last_errno,net->last_error));
  831.   end_server(mysql);
  832.   if (mysql->free_me)
  833.     my_free((gptr) mysql,MYF(0));
  834.   DBUG_RETURN(0);
  835. }
  838. /**************************************************************************
  839. ** Set current database
  840. **************************************************************************/
  842. int STDCALL
  843. mysql_select_db(MYSQL *mysql, const char *db)
  844. {
  845.   int error;
  846.   DBUG_ENTER("mysql_select_db");
  847.   DBUG_PRINT("enter",("db: '%s'",db));
  849.   if ((error=simple_command(mysql,COM_INIT_DB,db,strlen(db),0)))
  850.     DBUG_RETURN(error);
  851.   my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
  852.   mysql->db=my_strdup(db,MYF(MY_WME));
  853.   DBUG_RETURN(0);
  854. }
  857. /*************************************************************************
  858. ** Send a QUIT to the server and close the connection
  859. ** If handle is alloced by mysql connect free it.
  860. *************************************************************************/
  862. void STDCALL
  863. mysql_close(MYSQL *mysql)
  864. {
  865.   DBUG_ENTER("mysql_close");
  866.   if (mysql) /* Some simple safety */
  867.   {
  868.     if (mysql->net.fd >= 0)
  869.     {
  870.       free_old_query(mysql);
  871.       mysql->status=MYSQL_STATUS_READY; /* Force command */
  872.       simple_command(mysql,COM_QUIT,NullS,0,1);
  873.       end_server(mysql);
  874.     }
  875.     my_free((gptr) mysql->host_info,MYF(MY_ALLOW_ZERO_PTR));
  876.     my_free(mysql->db,MYF(MY_ALLOW_ZERO_PTR));
  877.     mysql->host_info=mysql->db=0;
  878.     if (mysql->free_me)
  879.       my_free((gptr) mysql,MYF(0));
  880.   }
  881.   DBUG_VOID_RETURN;
  882. }
  885. /**************************************************************************
  886. ** Do a query. If query returned rows, free old rows.
  887. ** Read data by mysql_store_result or by repeat call of mysql_fetch_row
  888. **************************************************************************/
  890. int STDCALL
  891. mysql_query(MYSQL *mysql, const char *query)
  892. {
  893.   return mysql_real_query(mysql,query,strlen(query));
  894. }
  897. int STDCALL
  898. mysql_real_query(MYSQL *mysql, const char *query,uint length)
  899. {
  900.   uchar *pos;
  901.   uint field_count;
  902.   MYSQL_DATA *fields;
  903.   DBUG_ENTER("mysql_real_query");
  904.   DBUG_PRINT("enter",("handle: %lx",mysql));
  905.   DBUG_PRINT("query",("Query = "%s"",query));
  907.   if (simple_command(mysql,COM_QUERY,query,length,1) ||
  908.       (length=net_safe_read(mysql)) == packet_error)
  909.     DBUG_RETURN(-1);
  910.   free_old_query(mysql); /* Free old result */
  911.   pos=(uchar*) mysql->net.buff;
  912.   if ((field_count=(uint) net_field_length(&pos)) == 0)
  913.   {
  914.     mysql->affected_rows= net_field_length(&pos);
  915.     mysql->insert_id=   net_field_length(&pos);
  916.     if (pos < mysql->net.buff+length && net_field_length(&pos))
  917.       mysql->info=(char*) pos;
  918.     DBUG_RETURN(0);
  919.   }
  920.   mysql->extra_info= net_field_length(&pos); /* Maybe number of rec */
  921.   if (!(fields=read_rows(mysql,(MYSQL_FIELD*) 0,5)))
  922.     DBUG_RETURN(-1);
  923.   if (!(mysql->fields=unpack_fields(fields,&mysql->field_alloc,field_count,0,
  924.     (my_bool) test(mysql->server_capabilities &
  925. CLIENT_LONG_FLAG))))
  926.     DBUG_RETURN(-1);
  927.   mysql->status=MYSQL_STATUS_GET_RESULT;
  928.   mysql->field_count=field_count;
  929.   DBUG_RETURN(0);
  930. }
  933. /**************************************************************************
  934. ** Alloc result struct for buffered results. All rows are read to buffer.
  935. ** mysql_data_seek may be used.
  936. **************************************************************************/
  938. MYSQL_RES * STDCALL
  939. mysql_store_result(MYSQL *mysql)
  940. {
  941.   MYSQL_RES *result;
  942.   DBUG_ENTER("mysql_store_result");
  944.   if (!mysql->fields)
  945.     DBUG_RETURN(0);
  946.   if (mysql->status != MYSQL_STATUS_GET_RESULT)
  947.   {
  948.     strmov(mysql->net.last_error,
  949.    ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
  950.     DBUG_RETURN(0);
  951.   }
  952.   mysql->status=MYSQL_STATUS_READY; /* server is ready */
  953.   if (!(result=(MYSQL_RES*) my_malloc(sizeof(MYSQL_RES)+
  954.       sizeof(uint)*mysql->field_count,
  955.       MYF(MY_WME | MY_ZEROFILL))))
  956.   {
  957.     mysql->net.last_errno=CR_OUT_OF_MEMORY;
  958.     strmov(mysql->net.last_error, ER(mysql->net.last_errno));
  959.     DBUG_RETURN(0);
  960.   }
  961.   result->eof=1; /* Marker for buffered */
  962.   result->lengths=(uint*) (result+1);
  963.   if (!(result->data=read_rows(mysql,mysql->fields,mysql->field_count)))
  964.   {
  965.     my_free((gptr) result,MYF(0));
  966.     DBUG_RETURN(0);
  967.   }
  968.   mysql->affected_rows= result->row_count=result->data->rows;
  969.   result->data_cursor= result->data->data;
  970.   result->fields= mysql->fields;
  971.   result->field_alloc= mysql->field_alloc;
  972.   result->field_count= mysql->field_count;
  973.   result->current_field=0;
  974.   result->current_row=0; /* Must do a fetch first */
  975.   mysql->fields=0; /* fields is now in result */
  976.   DBUG_RETURN(result); /* Data fetched */
  977. }
  980. /**************************************************************************
  981. ** Alloc struct for use with unbuffered reads. Data is fetched by domand
  982. ** when calling to mysql_fetch_row.
  983. ** mysql_data_seek is a noop.
  984. **
  985. ** No other queries may be specified with the same MYSQL handle.
  986. ** There shouldn't be much processing per row because mysql server shouldn't
  987. ** have to wait for the client (and will not wait more than 30 sec/packet).
  988. **************************************************************************/
  990. MYSQL_RES * STDCALL
  991. mysql_use_result(MYSQL *mysql)
  992. {
  993.   MYSQL_RES *result;
  994.   DBUG_ENTER("mysql_use_result");
  996.   if (!mysql->fields)
  997.     DBUG_RETURN(0);
  998.   if (mysql->status != MYSQL_STATUS_GET_RESULT)
  999.   {
  1000.     strmov(mysql->net.last_error,
  1001.    ER(mysql->net.last_errno=CR_COMMANDS_OUT_OF_SYNC));
  1002.     DBUG_RETURN(0);
  1003.   }
  1004.   if (!(result=(MYSQL_RES*) my_malloc(sizeof(MYSQL_RES)+
  1005.       sizeof(uint)*mysql->field_count,
  1006.       MYF(MY_WME | MY_ZEROFILL))))
  1007.     DBUG_RETURN(0);
  1008.   result->lengths=(uint*) (result+1);
  1009.   if (!(result->row=(MYSQL_ROW)
  1010. my_malloc(sizeof(result->row[0])*(mysql->field_count+1), MYF(MY_WME))))
  1011.   { /* Ptrs: to one row */
  1012.     my_free((gptr) result,MYF(0));
  1013.     DBUG_RETURN(0);
  1014.   }
  1015.   result->fields= mysql->fields;
  1016.   result->field_alloc= mysql->field_alloc;
  1017.   result->field_count= mysql->field_count;
  1018.   result->current_field=0;
  1019.   result->handle= mysql;
  1020.   result->current_row= 0;
  1021.   mysql->fields=0; /* fields is now in result */
  1022.   mysql->status=MYSQL_STATUS_USE_RESULT;
  1023.   DBUG_RETURN(result); /* Data is read to be fetched */
  1024. }
  1028. /**************************************************************************
  1029. ** Return next field of the query results
  1030. **************************************************************************/
  1032. MYSQL_FIELD * STDCALL
  1033. mysql_fetch_field(MYSQL_RES *result)
  1034. {
  1035.   if (result->current_field >= result->field_count)
  1036.     return(NULL);
  1037.   return &result->fields[result->current_field++];
  1038. }
  1041. /**************************************************************************
  1042. **  Return next row of the query results
  1043. **************************************************************************/
  1045. MYSQL_ROW STDCALL
  1046. mysql_fetch_row(MYSQL_RES *res)
  1047. {
  1048.   if (!res->data)
  1049.   { /* Unbufferred fetch */
  1050.     int error;
  1051.     if (!res->eof)
  1052.     {
  1053.       if (!(error=read_one_row(res->handle,res->field_count,res->row,
  1054.        res->lengths)))
  1055.       {
  1056. res->row_count++;
  1057. return (res->current_row=res->row);
  1058.       }
  1059.       else
  1060.       {
  1061. res->eof=1;
  1062. res->handle->status=MYSQL_STATUS_READY;
  1063.       }
  1064.     }
  1065.     return (MYSQL_ROW) NULL;
  1066.   }
  1067.   else
  1068.   {
  1069.     MYSQL_ROW tmp;
  1070.     if (!res->data_cursor)
  1071.       return (res->current_row=(MYSQL_ROW) NULL);
  1072.     tmp = res->data_cursor->data;
  1073.     res->data_cursor = res->data_cursor->next;
  1074.     return (res->current_row=tmp);
  1075.   }
  1076. }
  1078. /**************************************************************************
  1079. ** Get column lengths of the current row
  1080. ** If one uses mysql_use_result, res->lengths contains the length information,
  1081. ** else the lengths are calculated from the offset between pointers.
  1082. **************************************************************************/
  1084. uint * STDCALL
  1085. mysql_fetch_lengths(MYSQL_RES *res)
  1086. {
  1087.   uint *lengths,*prev_length;
  1088.   byte *start;
  1089.   MYSQL_ROW column,end;
  1091.   if (!(column=res->current_row))
  1092.     return 0; /* Something is wrong */
  1093.   if (res->data)
  1094.   {
  1095.     start=0;
  1096.     prev_length=0; /* Keep gcc happy */
  1097.     lengths=res->lengths;
  1098.     for (end=column+res->field_count+1 ; column != end ; column++,lengths++)
  1099.     {
  1100.       if (!*column)
  1101.       {
  1102. *lengths=0; /* Null */
  1103. continue;
  1104.       }
  1105.       if (start) /* Found end of prev string */
  1106. *prev_length= (uint) (*column-start-1);
  1107.       start= *column;
  1108.       prev_length=lengths;
  1109.     }
  1110.   }
  1111.   return res->lengths;
  1112. }
  1114. /**************************************************************************
  1115. ** Move to a specific row and column
  1116. **************************************************************************/
  1118. void STDCALL
  1119. mysql_data_seek(MYSQL_RES *result, uint row)
  1120. {
  1121.   MYSQL_ROWS *tmp=0;
  1122.   DBUG_PRINT("info",("mysql_data_seek(%d)",row));
  1123.   if (result->data)
  1124.     for (tmp=result->data->data; row-- && tmp ; tmp = tmp->next) ;
  1125.   result->current_row=0;
  1126.   result->data_cursor = tmp;
  1127. }
  1129. /*************************************************************************
  1130. ** put the row or field cursor at the saved position.
  1131. ** This dosen't restore any data. The next mysql_fetch_row or
  1132. ** mysql_fetch_field will return the next row or field after the last used
  1133. *************************************************************************/
  1135. MYSQL_ROW_OFFSET STDCALL
  1136. mysql_row_seek(MYSQL_RES *result, MYSQL_ROW_OFFSET row)
  1137. {
  1138.   MYSQL_ROW_OFFSET return_value=result->data_cursor;
  1139.   result->current_row= 0;
  1140.   result->data_cursor= row;
  1141.   return return_value;
  1142. }
  1145. MYSQL_FIELD_OFFSET STDCALL
  1146. mysql_field_seek(MYSQL_RES *result, uint fieldnr)
  1147. {
  1148.   MYSQL_FIELD_OFFSET return_value=result->current_field;
  1149.   result->current_field=fieldnr;
  1150.   return return_value;
  1151. }
  1153. /*****************************************************************************
  1154. ** List all databases
  1155. *****************************************************************************/
  1157. MYSQL_RES * STDCALL
  1158. mysql_list_dbs(MYSQL *mysql, const char *wild)
  1159. {
  1160.   char buff[100];
  1161.   DBUG_ENTER("mysql_list_dbs");
  1163.   append_wild(strmov(buff,"show databases"),buff+sizeof(buff),wild);
  1164.   if (mysql_query(mysql,buff) < 0)
  1165.     DBUG_RETURN(0);
  1166.   DBUG_RETURN (mysql_store_result(mysql));
  1167. }
  1170. /*****************************************************************************
  1171. ** List all tables in a database
  1172. ** If wild is given then only the tables matching wild is returned
  1173. *****************************************************************************/
  1175. MYSQL_RES * STDCALL
  1176. mysql_list_tables(MYSQL *mysql, const char *wild)
  1177. {
  1178.   char buff[100];
  1179.   DBUG_ENTER("mysql_list_tables");
  1181.   append_wild(strmov(buff,"show tables"),buff+sizeof(buff),wild);
  1182.   if (mysql_query(mysql,buff) < 0)
  1183.     DBUG_RETURN(0);
  1184.   DBUG_RETURN (mysql_store_result(mysql));
  1185. }
  1188. /**************************************************************************
  1189. ** List all fields in a table
  1190. ** If wild is given then only the fields matching wild is returned
  1191. ** Instead of this use query:
  1192. ** show fields in 'table' like "wild"
  1193. **************************************************************************/
  1195. MYSQL_RES * STDCALL
  1196. mysql_list_fields(MYSQL *mysql, const char *table, const char *wild)
  1197. {
  1198.   MYSQL_RES *result;
  1199.   MYSQL_DATA *query;
  1200.   char      buff[257],*end;
  1201.   DBUG_ENTER("mysql_list_fields");
  1202.   DBUG_PRINT("enter",("table: '%s'  wild: '%s'",table,wild ? wild : ""));
  1204.   LINT_INIT(query);
  1206.   end=strmake(strmake(buff, table,128)+1,wild ? wild : "",128);
  1207.   if (simple_command(mysql,COM_FIELD_LIST,buff,(uint) (end-buff),1) ||
  1208.       !(query = read_rows(mysql,(MYSQL_FIELD*) 0,6)))
  1209.     DBUG_RETURN(NULL);
  1211.   free_old_query(mysql);
  1212.   if (!(result = (MYSQL_RES *) my_malloc(sizeof(MYSQL_RES),
  1213.  MYF(MY_WME | MY_ZEROFILL))))
  1214.   {
  1215.     free_rows(query);
  1216.     DBUG_RETURN(NULL);
  1217.   }
  1218.   result->field_alloc=mysql->field_alloc;
  1219.   mysql->fields=0;
  1220.   result->field_count = query->rows;
  1221.   result->fields= unpack_fields(query,&result->field_alloc,
  1222. result->field_count,1,
  1223. (my_bool) test(mysql->server_capabilities &
  1224.        CLIENT_LONG_FLAG));
  1225.   result->eof=1;
  1226.   DBUG_RETURN(result);
  1227. }
  1229. /* List all running processes (threads) in server */
  1231. MYSQL_RES * STDCALL
  1232. mysql_list_processes(MYSQL *mysql)
  1233. {
  1234.   MYSQL_DATA *fields;
  1235.   uint field_count;
  1236.   uchar *pos;
  1237.   DBUG_ENTER("mysql_list_processes");
  1239.   LINT_INIT(fields);
  1240.   if (simple_command(mysql,COM_PROCESS_INFO,0,0,0))
  1241.     DBUG_RETURN(0);
  1242.   free_old_query(mysql);
  1243.   pos=(uchar*) mysql->net.buff;
  1244.   field_count=(uint) net_field_length(&pos);
  1245.   if (!(fields = read_rows(mysql,(MYSQL_FIELD*) 0,5)))
  1246.     DBUG_RETURN(NULL);
  1247.   if (!(mysql->fields=unpack_fields(fields,&mysql->field_alloc,field_count,0,
  1248.     (my_bool) test(mysql->server_capabilities &
  1249.    CLIENT_LONG_FLAG))))
  1250.     DBUG_RETURN(0);
  1251.   mysql->status=MYSQL_STATUS_GET_RESULT;
  1252.   mysql->field_count=field_count;
  1253.   DBUG_RETURN(mysql_store_result(mysql));
  1254. }
  1257. int  STDCALL
  1258. mysql_create_db(MYSQL *mysql, const char *db)
  1259. {
  1260.   DBUG_ENTER("mysql_createdb");
  1261.   DBUG_PRINT("enter",("db: %s",db));
  1262.   DBUG_RETURN(simple_command(mysql,COM_CREATE_DB,db, (uint) strlen(db),0));
  1263. }
  1266. int  STDCALL
  1267. mysql_drop_db(MYSQL *mysql, const char *db)
  1268. {
  1269.   DBUG_ENTER("mysql_drop_db");
  1270.   DBUG_PRINT("enter",("db: %s",db));
  1271.   DBUG_RETURN(simple_command(mysql,COM_DROP_DB,db,(uint) strlen(db),0));
  1272. }
  1275. int STDCALL
  1276. mysql_shutdown(MYSQL *mysql)
  1277. {
  1278.   DBUG_ENTER("mysql_shutdown");
  1279.   DBUG_RETURN(simple_command(mysql,COM_SHUTDOWN,0,0,0));
  1280. }
  1283. int STDCALL
  1284. mysql_refresh(MYSQL *mysql,uint options)
  1285. {
  1286.   uchar bits[1];
  1287.   DBUG_ENTER("mysql_refresh");
  1288.   bits[0]= (uchar) options;
  1289.   DBUG_RETURN(simple_command(mysql,COM_REFRESH,(char*) bits,1,0));
  1290. }
  1292. int STDCALL
  1293. mysql_kill(MYSQL *mysql,ulong pid)
  1294. {
  1295.   char buff[4];
  1296.   DBUG_ENTER("mysql_kill");
  1297.   int4store(buff,pid);
  1298.   DBUG_RETURN(simple_command(mysql,COM_PROCESS_KILL,buff,4,0));
  1299. }
  1302. int STDCALL
  1303. mysql_dump_debug_info(MYSQL *mysql)
  1304. {
  1305.   DBUG_ENTER("mysql_dump_debug_info");
  1306.   DBUG_RETURN(simple_command(mysql,COM_DEBUG,0,0,0));
  1307. }
  1309. char * STDCALL
  1310. mysql_stat(MYSQL *mysql)
  1311. {
  1312.   DBUG_ENTER("mysql_stat");
  1313.   if (simple_command(mysql,COM_STATISTICS,0,0,0))
  1314.     return mysql->net.last_error;
  1315.   if (!mysql->net.buff[0])
  1316.   {
  1317.     mysql->net.last_errno=CR_WRONG_HOST_INFO;
  1318.     strmov(mysql->net.last_error, ER(mysql->net.last_errno));
  1319.     return mysql->net.last_error;
  1320.   }
  1321.   DBUG_RETURN((char*) mysql->net.buff);
  1322. }
  1325. char * STDCALL
  1326. mysql_get_server_info(MYSQL *mysql)
  1327. {
  1328.   return((char*) mysql->server_version);
  1329. }
  1332. char * STDCALL
  1333. mysql_get_host_info(MYSQL *mysql)
  1334. {
  1335.   return(mysql->host_info);
  1336. }
  1339. uint STDCALL
  1340. mysql_get_proto_info(MYSQL *mysql)
  1341. {
  1342.   return (mysql->protocol_version);
  1343. }
  1345. char * STDCALL
  1346. mysql_get_client_info(void)
  1347. {
  1348.   return MYSQL_SERVER_VERSION;
  1349. }
  1352. /****************************************************************************
  1353. ** Some support functions
  1354. ****************************************************************************/
  1356. /*
  1357. ** Add escape characters to a string (blob?) to make it suitable for a insert
  1358. ** to should at least have place for length*2+1 chars
  1359. ** Returns the length of the to string
  1360. */
  1362. uint STDCALL
  1363. mysql_escape_string(char *to,const char *from,uint length)
  1364. {
  1365.   const char *to_start=to;
  1366.   const char *end;
  1367.   for (end=from+length; from != end ; from++)
  1368.   {
  1369. #ifdef USE_BIG5CODE
  1370.     if (from+1 != end && isbig5head(*from))
  1371.     {
  1372.       *to++= *from++;
  1373.       *to++= *from;
  1374.       continue;
  1375.     }
  1376. #endif
  1377. #ifdef USE_MB
  1378.     int l;
  1379.     if ((l = ismbchar(from, end)))
  1380.     {
  1381.       while (l--)
  1382.           *to++ = *from++;
  1383.       from--;
  1384.       continue;
  1385.     }
  1386. #endif
  1387.     switch (*from) {
  1388.     case 0: /* Must be escaped for 'mysql' */
  1389.       *to++= '\';
  1390.       *to++= '0';
  1391.       break;
  1392.     case 'n': /* Must be escaped for logs */
  1393.       *to++= '\';
  1394.       *to++= 'n';
  1395.       break;
  1396.     case 'r':
  1397.       *to++= '\';
  1398.       *to++= 'r';
  1399.       break;
  1400.     case '\':
  1401.       *to++= '\';
  1402.       *to++= '\';
  1403.       break;
  1404.     case ''':
  1405.       *to++= ''';
  1406.       *to++= ''';
  1407.       break;
  1408.     default:
  1409.       *to++= *from;
  1410.     }
  1411.   }
  1412.   *to=0;
  1413.   return (uint) (to-to_start);
  1414. }