net.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:27k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /*
  14.   This file is the net layer API for the MySQL client/server protocol,
  15.   which is a tightly coupled, proprietary protocol owned by MySQL AB.
  16.   Any re-implementations of this protocol must also be under GPL
  17.   unless one has got an license from MySQL AB stating otherwise.
  18. */
  19. /*
  20.   Write and read of logical packets to/from socket
  21.   Writes are cached into net_buffer_length big packets.
  22.   Read packets are reallocated dynamicly when reading big packets.
  23.   Each logical packet has the following pre-info:
  24.   3 byte length & 1 byte package-number.
  25.   This file needs to be written in C as it's used by the libmysql client as a
  26.   C file.
  27. */
  28. /*
  29.   HFTODO this must be hidden if we don't want client capabilities in 
  30.   embedded library
  31.  */
  32. #ifdef __WIN__
  33. #include <winsock.h>
  34. #endif
  35. #include <my_global.h>
  36. #include <mysql.h>
  37. #include <mysql_embed.h>
  38. #include <mysql_com.h>
  39. #include <mysqld_error.h>
  40. #include <my_sys.h>
  41. #include <m_string.h>
  42. #include <my_net.h>
  43. #include <violite.h>
  44. #include <signal.h>
  45. #include <errno.h>
  46. #ifdef EMBEDDED_LIBRARY
  47. #undef MYSQL_SERVER
  48. #undef MYSQL_CLIENT
  49. #define MYSQL_CLIENT
  50. #endif /*EMBEDDED_LIBRARY */
  51. /*
  52.   The following handles the differences when this is linked between the
  53.   client and the server.
  54.   This gives an error if a too big packet is found
  55.   The server can change this with the -O switch, but because the client
  56.   can't normally do this the client should have a bigger max_allowed_packet.
  57. */
  58. #if defined(__WIN__) || !defined(MYSQL_SERVER)
  59.   /* The following is because alarms doesn't work on windows. */
  60. #define NO_ALARM
  61. #endif
  62.   
  63. #ifndef NO_ALARM
  64. #include "my_pthread.h"
  65. void sql_print_error(const char *format,...);
  66. #else
  67. #define DONT_USE_THR_ALARM
  68. #endif /* NO_ALARM */
  69. #include "thr_alarm.h"
  70. #ifdef MYSQL_SERVER
  71. #define USE_QUERY_CACHE
  72. /*
  73.   The following variables/functions should really not be declared
  74.   extern, but as it's hard to include mysql_priv.h here, we have to
  75.   live with this for a while.
  76. */
  77. extern uint test_flags;
  78. extern ulong bytes_sent, bytes_received, net_big_packet_count;
  79. extern pthread_mutex_t LOCK_bytes_sent , LOCK_bytes_received;
  80. extern void query_cache_insert(NET *net, const char *packet, ulong length);
  81. #else
  82. #undef statistic_add
  83. #undef statistic_increment
  84. #define statistic_add(A,B,C)
  85. #define statistic_increment(A,B)
  86. #endif
  87. #define TEST_BLOCKING 8
  88. #define MAX_PACKET_LENGTH (256L*256L*256L-1)
  89. static my_bool net_write_buff(NET *net,const char *packet,ulong len);
  90. /* Init with packet info */
  91. my_bool my_net_init(NET *net, Vio* vio)
  92. {
  93.   DBUG_ENTER("my_net_init");
  94.   my_net_local_init(net); /* Set some limits */
  95.   if (!(net->buff=(uchar*) my_malloc((uint32) net->max_packet+
  96.      NET_HEADER_SIZE + COMP_HEADER_SIZE,
  97.      MYF(MY_WME))))
  98.     DBUG_RETURN(1);
  99.   net->buff_end=net->buff+net->max_packet;
  100.   net->vio = vio;
  101.   net->no_send_ok = 0;
  102.   net->error=0; net->return_errno=0; net->return_status=0;
  103.   net->pkt_nr=net->compress_pkt_nr=0;
  104.   net->write_pos=net->read_pos = net->buff;
  105.   net->last_error[0]=0;
  106.   net->compress=0; net->reading_or_writing=0;
  107.   net->where_b = net->remain_in_buf=0;
  108.   net->last_errno=0;
  109.   net->query_cache_query=0;
  110.   net->report_error= 0;
  111.   if (vio != 0) /* If real connection */
  112.   {
  113.     net->fd  = vio_fd(vio); /* For perl DBI/DBD */
  114. #if defined(MYSQL_SERVER) && !defined(__WIN__) && !defined(__EMX__) && !defined(OS2)
  115.     if (!(test_flags & TEST_BLOCKING))
  116.     {
  117.       my_bool old_mode;
  118.       vio_blocking(vio, FALSE, &old_mode);
  119.     }
  120. #endif
  121.     vio_fastsend(vio);
  122.   }
  123.   DBUG_RETURN(0);
  124. }
  125. void net_end(NET *net)
  126. {
  127.   DBUG_ENTER("net_end");
  128.   my_free((gptr) net->buff,MYF(MY_ALLOW_ZERO_PTR));
  129.   net->buff=0;
  130.   DBUG_VOID_RETURN;
  131. }
  132. /* Realloc the packet buffer */
  133. my_bool net_realloc(NET *net, ulong length)
  134. {
  135.   uchar *buff;
  136.   ulong pkt_length;
  137.   DBUG_ENTER("net_realloc");
  138.   DBUG_PRINT("enter",("length: %lu", length));
  139.   if (length >= net->max_packet_size)
  140.   {
  141.     DBUG_PRINT("error", ("Packet too large. Max size: %lu",
  142.                net->max_packet_size));
  143.     net->error= 1;
  144.     net->report_error= 1;
  145.     net->last_errno= ER_NET_PACKET_TOO_LARGE;
  146.     DBUG_RETURN(1);
  147.   }
  148.   pkt_length = (length+IO_SIZE-1) & ~(IO_SIZE-1); 
  149.   /*
  150.     We must allocate some extra bytes for the end 0 and to be able to
  151.     read big compressed blocks
  152.   */
  153.   if (!(buff=(uchar*) my_realloc((char*) net->buff, (uint32) pkt_length +
  154.  NET_HEADER_SIZE + COMP_HEADER_SIZE,
  155.  MYF(MY_WME))))
  156.   {
  157.     net->error= 1;
  158.     net->report_error= 1;
  159.     net->last_errno= ER_OUT_OF_RESOURCES;
  160.     DBUG_RETURN(1);
  161.   }
  162.   net->buff=net->write_pos=buff;
  163.   net->buff_end=buff+(net->max_packet=pkt_length);
  164.   DBUG_RETURN(0);
  165. }
  166. /* Remove unwanted characters from connection */
  167. void net_clear(NET *net)
  168. {
  169.   DBUG_ENTER("net_clear");
  170. #if !defined(EXTRA_DEBUG) && !defined(EMBEDDED_LIBRARY)
  171.   {
  172.     int count; /* One may get 'unused' warn */
  173.     my_bool old_mode;
  174.     if (!vio_blocking(net->vio, FALSE, &old_mode))
  175.     {
  176.       while ((count = vio_read(net->vio, (char*) (net->buff),
  177.        (uint32) net->max_packet)) > 0)
  178. DBUG_PRINT("info",("skipped %d bytes from file: %s",
  179.    count, vio_description(net->vio)));
  180.       vio_blocking(net->vio, TRUE, &old_mode);
  181.     }
  182.   }
  183. #endif /* EXTRA_DEBUG */
  184.   net->pkt_nr=net->compress_pkt_nr=0; /* Ready for new command */
  185.   net->write_pos=net->buff;
  186.   DBUG_VOID_RETURN;
  187. }
  188. /* Flush write_buffer if not empty. */
  189. my_bool net_flush(NET *net)
  190. {
  191.   my_bool error= 0;
  192.   DBUG_ENTER("net_flush");
  193.   if (net->buff != net->write_pos)
  194.   {
  195.     error=test(net_real_write(net,(char*) net->buff,
  196.       (ulong) (net->write_pos - net->buff)));
  197.     net->write_pos=net->buff;
  198.   }
  199.   /* Sync packet number if using compression */
  200.   if (net->compress)
  201.     net->pkt_nr=net->compress_pkt_nr;
  202.   DBUG_RETURN(error);
  203. }
  204. /*****************************************************************************
  205. ** Write something to server/client buffer
  206. *****************************************************************************/
  207. /*
  208.   Write a logical packet with packet header
  209.   Format: Packet length (3 bytes), packet number(1 byte)
  210.   When compression is used a 3 byte compression length is added
  211.   NOTE
  212.     If compression is used the original package is modified!
  213. */
  214. my_bool
  215. my_net_write(NET *net,const char *packet,ulong len)
  216. {
  217.   uchar buff[NET_HEADER_SIZE];
  218.   if (unlikely(!net->vio)) /* nowhere to write */
  219.     return 0;
  220.   /*
  221.     Big packets are handled by splitting them in packets of MAX_PACKET_LENGTH
  222.     length. The last packet is always a packet that is < MAX_PACKET_LENGTH.
  223.     (The last packet may even have a length of 0)
  224.   */
  225.   while (len >= MAX_PACKET_LENGTH)
  226.   {
  227.     const ulong z_size = MAX_PACKET_LENGTH;
  228.     int3store(buff, z_size);
  229.     buff[3]= (uchar) net->pkt_nr++;
  230.     if (net_write_buff(net, (char*) buff, NET_HEADER_SIZE) ||
  231. net_write_buff(net, packet, z_size))
  232.       return 1;
  233.     packet += z_size;
  234.     len-=     z_size;
  235.   }
  236.   /* Write last packet */
  237.   int3store(buff,len);
  238.   buff[3]= (uchar) net->pkt_nr++;
  239.   if (net_write_buff(net,(char*) buff,NET_HEADER_SIZE))
  240.     return 1;
  241. #ifndef DEBUG_DATA_PACKETS
  242.   DBUG_DUMP("packet_header",(char*) buff,NET_HEADER_SIZE);
  243. #endif
  244.   return test(net_write_buff(net,packet,len));
  245. }
  246. /*
  247.   Send a command to the server.
  248.   SYNOPSIS
  249.     net_write_command()
  250.     net NET handler
  251.     command Command in MySQL server (enum enum_server_command)
  252.     header Header to write after command
  253.     head_len Length of header
  254.     packet Query or parameter to query
  255.     len Length of packet
  256.   DESCRIPTION
  257.     The reason for having both header and packet is so that libmysql
  258.     can easy add a header to a special command (like prepared statements)
  259.     without having to re-alloc the string.
  260.     As the command is part of the first data packet, we have to do some data
  261.     juggling to put the command in there, without having to create a new
  262.     packet.
  263.     This function will split big packets into sub-packets if needed.
  264.     (Each sub packet can only be 2^24 bytes)
  265.   RETURN VALUES
  266.     0 ok
  267.     1 error
  268. */
  269. my_bool
  270. net_write_command(NET *net,uchar command,
  271.   const char *header, ulong head_len,
  272.   const char *packet, ulong len)
  273. {
  274.   ulong length=len+1+head_len; /* 1 extra byte for command */
  275.   uchar buff[NET_HEADER_SIZE+1];
  276.   uint header_size=NET_HEADER_SIZE+1;
  277.   DBUG_ENTER("net_write_command");
  278.   DBUG_PRINT("enter",("length: %lu", len));
  279.   buff[4]=command; /* For first packet */
  280.   if (length >= MAX_PACKET_LENGTH)
  281.   {
  282.     /* Take into account that we have the command in the first header */
  283.     len= MAX_PACKET_LENGTH - 1 - head_len;
  284.     do
  285.     {
  286.       int3store(buff, MAX_PACKET_LENGTH);
  287.       buff[3]= (uchar) net->pkt_nr++;
  288.       if (net_write_buff(net,(char*) buff, header_size) ||
  289.   net_write_buff(net, header, head_len) ||
  290.   net_write_buff(net, packet, len))
  291. DBUG_RETURN(1);
  292.       packet+= len;
  293.       length-= MAX_PACKET_LENGTH;
  294.       len= MAX_PACKET_LENGTH;
  295.       head_len= 0;
  296.       header_size= NET_HEADER_SIZE;
  297.     } while (length >= MAX_PACKET_LENGTH);
  298.     len=length; /* Data left to be written */
  299.   }
  300.   int3store(buff,length);
  301.   buff[3]= (uchar) net->pkt_nr++;
  302.   DBUG_RETURN(test(net_write_buff(net, (char*) buff, header_size) ||
  303.       (head_len && net_write_buff(net, (char*) header, head_len)) ||
  304.       net_write_buff(net, packet, len) || net_flush(net)));
  305. }
  306. /*
  307.   Caching the data in a local buffer before sending it.
  308.   SYNOPSIS
  309.     net_write_buff()
  310.     net Network handler
  311.     packet Packet to send
  312.     len Length of packet
  313.   DESCRIPTION
  314.     Fill up net->buffer and send it to the client when full.
  315.     If the rest of the to-be-sent-packet is bigger than buffer,
  316.     send it in one big block (to avoid copying to internal buffer).
  317.     If not, copy the rest of the data to the buffer and return without
  318.     sending data.
  319.   NOTES
  320.     The cached buffer can be sent as it is with 'net_flush()'.
  321.     In this code we have to be careful to not send a packet longer than
  322.     MAX_PACKET_LENGTH to net_real_write() if we are using the compressed
  323.     protocol as we store the length of the compressed packet in 3 bytes.
  324.   RETURN
  325.   0 ok
  326.   1
  327. */
  328. static my_bool
  329. net_write_buff(NET *net,const char *packet,ulong len)
  330. {
  331.   ulong left_length;
  332.   if (net->compress && net->max_packet > MAX_PACKET_LENGTH)
  333.     left_length= MAX_PACKET_LENGTH - (net->write_pos - net->buff);
  334.   else
  335.     left_length= (ulong) (net->buff_end - net->write_pos);
  336. #ifdef DEBUG_DATA_PACKETS
  337.   DBUG_DUMP("data", packet, len);
  338. #endif
  339.   if (len > left_length)
  340.   {
  341.     if (net->write_pos != net->buff)
  342.     {
  343.       /* Fill up already used packet and write it */
  344.       memcpy((char*) net->write_pos,packet,left_length);
  345.       if (net_real_write(net,(char*) net->buff, 
  346.  (ulong) (net->write_pos - net->buff) + left_length))
  347. return 1;
  348.       net->write_pos= net->buff;
  349.       packet+= left_length;
  350.       len-= left_length;
  351.     }
  352.     if (net->compress)
  353.     {
  354.       /*
  355. We can't have bigger packets than 16M with compression
  356. Because the uncompressed length is stored in 3 bytes
  357.       */
  358.       left_length= MAX_PACKET_LENGTH;
  359.       while (len > left_length)
  360.       {
  361. if (net_real_write(net, packet, left_length))
  362.   return 1;
  363. packet+= left_length;
  364. len-= left_length;
  365.       }
  366.     }
  367.     if (len > net->max_packet)
  368.       return net_real_write(net, packet, len) ? 1 : 0;
  369.     /* Send out rest of the blocks as full sized blocks */
  370.   }
  371.   memcpy((char*) net->write_pos,packet,len);
  372.   net->write_pos+= len;
  373.   return 0;
  374. }
  375. /*
  376.   Read and write one packet using timeouts.
  377.   If needed, the packet is compressed before sending.
  378. */
  379. int
  380. net_real_write(NET *net,const char *packet,ulong len)
  381. {
  382.   long int length;
  383.   char *pos,*end;
  384.   thr_alarm_t alarmed;
  385. #ifndef NO_ALARM
  386.   ALARM alarm_buff;
  387. #endif
  388.   uint retry_count=0;
  389.   my_bool net_blocking = vio_is_blocking(net->vio);
  390.   DBUG_ENTER("net_real_write");
  391. #if defined(MYSQL_SERVER) && defined(HAVE_QUERY_CACHE)
  392.   if (net->query_cache_query != 0)
  393.     query_cache_insert(net, packet, len);
  394. #endif
  395.   if (net->error == 2)
  396.     DBUG_RETURN(-1); /* socket can't be used */
  397.   net->reading_or_writing=2;
  398. #ifdef HAVE_COMPRESS
  399.   if (net->compress)
  400.   {
  401.     ulong complen;
  402.     uchar *b;
  403.     uint header_length=NET_HEADER_SIZE+COMP_HEADER_SIZE;
  404.     if (!(b=(uchar*) my_malloc((uint32) len + NET_HEADER_SIZE +
  405.        COMP_HEADER_SIZE, MYF(MY_WME))))
  406.     {
  407. #ifdef MYSQL_SERVER
  408.       net->last_errno= ER_OUT_OF_RESOURCES;
  409.       net->error= 2;
  410.       /* TODO is it needed to set this variable if we have no socket */
  411.       net->report_error= 1;
  412. #endif
  413.       net->reading_or_writing= 0;
  414.       DBUG_RETURN(1);
  415.     }
  416.     memcpy(b+header_length,packet,len);
  417.     if (my_compress((byte*) b+header_length,&len,&complen))
  418.       complen=0;
  419.     int3store(&b[NET_HEADER_SIZE],complen);
  420.     int3store(b,len);
  421.     b[3]=(uchar) (net->compress_pkt_nr++);
  422.     len+= header_length;
  423.     packet= (char*) b;
  424.   }
  425. #endif /* HAVE_COMPRESS */
  426.   /* DBUG_DUMP("net",packet,len); */
  427. #ifndef NO_ALARM
  428.   thr_alarm_init(&alarmed);
  429.   if (net_blocking)
  430.     thr_alarm(&alarmed,(uint) net->write_timeout,&alarm_buff);
  431. #else
  432.   alarmed=0;
  433.   vio_timeout(net->vio, 1, net->write_timeout);
  434. #endif /* NO_ALARM */
  435.   pos=(char*) packet; end=pos+len;
  436.   while (pos != end)
  437.   {
  438.     if ((long) (length=vio_write(net->vio,pos,(uint32) (end-pos))) <= 0)
  439.     {
  440.       my_bool interrupted = vio_should_retry(net->vio);
  441. #if (!defined(__WIN__) && !defined(__EMX__) && !defined(OS2))
  442.       if ((interrupted || length==0) && !thr_alarm_in_use(&alarmed))
  443.       {
  444.         if (!thr_alarm(&alarmed,(uint) net->write_timeout,&alarm_buff))
  445.         {                                       /* Always true for client */
  446.   my_bool old_mode;
  447.   while (vio_blocking(net->vio, TRUE, &old_mode) < 0)
  448.   {
  449.     if (vio_should_retry(net->vio) && retry_count++ < net->retry_count)
  450.       continue;
  451. #ifdef EXTRA_DEBUG
  452.     fprintf(stderr,
  453.     "%s: my_net_write: fcntl returned error %d, aborting threadn",
  454.     my_progname,vio_errno(net->vio));
  455. #endif /* EXTRA_DEBUG */
  456. #ifdef MYSQL_SERVER     
  457.     net->last_errno= ER_NET_ERROR_ON_WRITE;
  458. #endif
  459.     net->error= 2;                     /* Close socket */
  460.             net->report_error= 1;
  461.     goto end;
  462.   }
  463.   retry_count=0;
  464.   continue;
  465. }
  466.       }
  467.       else
  468. #endif /* (!defined(__WIN__) && !defined(__EMX__)) */
  469. if (thr_alarm_in_use(&alarmed) && !thr_got_alarm(&alarmed) &&
  470.     interrupted)
  471.       {
  472. if (retry_count++ < net->retry_count)
  473.     continue;
  474. #ifdef EXTRA_DEBUG
  475.   fprintf(stderr, "%s: write looped, aborting threadn",
  476.   my_progname);
  477. #endif /* EXTRA_DEBUG */
  478.       }
  479. #if defined(THREAD_SAFE_CLIENT) && !defined(MYSQL_SERVER)
  480.       if (vio_errno(net->vio) == SOCKET_EINTR)
  481.       {
  482. DBUG_PRINT("warning",("Interrupted write. Retrying..."));
  483. continue;
  484.       }
  485. #endif /* defined(THREAD_SAFE_CLIENT) && !defined(MYSQL_SERVER) */
  486.       net->error= 2; /* Close socket */
  487.       net->report_error= 1;
  488. #ifdef MYSQL_SERVER
  489.       net->last_errno= (interrupted ? ER_NET_WRITE_INTERRUPTED :
  490. ER_NET_ERROR_ON_WRITE);
  491. #endif /* MYSQL_SERVER */
  492.       break;
  493.     }
  494.     pos+=length;
  495.     statistic_add(bytes_sent,length,&LOCK_bytes_sent);
  496.   }
  497. #ifndef __WIN__
  498.  end:
  499. #endif
  500. #ifdef HAVE_COMPRESS
  501.   if (net->compress)
  502.     my_free((char*) packet,MYF(0));
  503. #endif
  504.   if (thr_alarm_in_use(&alarmed))
  505.   {
  506.     my_bool old_mode;
  507.     thr_end_alarm(&alarmed);
  508.     vio_blocking(net->vio, net_blocking, &old_mode);
  509.   }
  510.   net->reading_or_writing=0;
  511.   DBUG_RETURN(((int) (pos != end)));
  512. }
  513. /*****************************************************************************
  514. ** Read something from server/clinet
  515. *****************************************************************************/
  516. #ifndef NO_ALARM
  517. static my_bool net_safe_read(NET *net, char *buff, uint32 length,
  518.      thr_alarm_t *alarmed)
  519. {
  520.   uint retry_count=0;
  521.   while (length > 0)
  522.   {
  523.     int tmp;
  524.     if ((tmp=vio_read(net->vio,(char*) net->buff, length)) <= 0)
  525.     {
  526.       my_bool interrupted = vio_should_retry(net->vio);
  527.       if (!thr_got_alarm(alarmed) && interrupted)
  528.       { /* Probably in MIT threads */
  529. if (retry_count++ < net->retry_count)
  530.   continue;
  531.       }
  532.       return 1;
  533.     }
  534.     length-= tmp;
  535.   }
  536.   return 0;
  537. }
  538. /*
  539.   Help function to clear the commuication buffer when we get a too big packet.
  540.   SYNOPSIS
  541.     my_net_skip_rest()
  542.     net Communication handle
  543.     remain Bytes to read
  544.     alarmed Parameter for thr_alarm()
  545.     alarm_buff Parameter for thr_alarm()
  546.   RETURN VALUES
  547.    0 Was able to read the whole packet
  548.    1 Got mailformed packet from client
  549. */
  550. static my_bool my_net_skip_rest(NET *net, uint32 remain, thr_alarm_t *alarmed,
  551. ALARM *alarm_buff)
  552. {
  553.   uint32 old=remain;
  554.   DBUG_ENTER("my_net_skip_rest");
  555.   DBUG_PRINT("enter",("bytes_to_skip: %u", (uint) remain));
  556.   /* The following is good for debugging */
  557.   statistic_increment(net_big_packet_count,&LOCK_bytes_received);
  558.   if (!thr_alarm_in_use(alarmed))
  559.   {
  560.     my_bool old_mode;
  561.     if (thr_alarm(alarmed,net->read_timeout, alarm_buff) ||
  562. vio_blocking(net->vio, TRUE, &old_mode) < 0)
  563.       DBUG_RETURN(1); /* Can't setup, abort */
  564.   }
  565.   for (;;)
  566.   {
  567.     while (remain > 0)
  568.     {
  569.       uint length= min(remain, net->max_packet);
  570.       if (net_safe_read(net, (char*) net->buff, length, alarmed))
  571. DBUG_RETURN(1);
  572.       statistic_add(bytes_received, length, &LOCK_bytes_received);
  573.       remain -= (uint32) length;
  574.     }
  575.     if (old != MAX_PACKET_LENGTH)
  576.       break;
  577.     if (net_safe_read(net, (char*) net->buff, NET_HEADER_SIZE, alarmed))
  578.       DBUG_RETURN(1);
  579.     old=remain= uint3korr(net->buff);
  580.     net->pkt_nr++;
  581.   }
  582.   DBUG_RETURN(0);
  583. }
  584. #endif /* NO_ALARM */
  585. /*
  586.   Reads one packet to net->buff + net->where_b
  587.   Returns length of packet.  Long packets are handled by my_net_read().
  588.   This function reallocates the net->buff buffer if necessary.
  589. */
  590. static ulong
  591. my_real_read(NET *net, ulong *complen)
  592. {
  593.   uchar *pos;
  594.   long length;
  595.   uint i,retry_count=0;
  596.   ulong len=packet_error;
  597.   thr_alarm_t alarmed;
  598. #ifndef NO_ALARM
  599.   ALARM alarm_buff;
  600. #endif
  601.   my_bool net_blocking=vio_is_blocking(net->vio);
  602.   uint32 remain= (net->compress ? NET_HEADER_SIZE+COMP_HEADER_SIZE :
  603.   NET_HEADER_SIZE);
  604.   *complen = 0;
  605.   net->reading_or_writing=1;
  606.   thr_alarm_init(&alarmed);
  607. #ifndef NO_ALARM
  608.   if (net_blocking)
  609.     thr_alarm(&alarmed,net->read_timeout,&alarm_buff);
  610. #else
  611.   vio_timeout(net->vio, 0, net->read_timeout);
  612. #endif /* NO_ALARM */
  613.     pos = net->buff + net->where_b; /* net->packet -4 */
  614.     for (i=0 ; i < 2 ; i++)
  615.     {
  616.       while (remain > 0)
  617.       {
  618. /* First read is done with non blocking mode */
  619.         if ((int) (length=vio_read(net->vio,(char*) pos,remain)) <= 0L)
  620.         {
  621.           my_bool interrupted = vio_should_retry(net->vio);
  622.   DBUG_PRINT("info",("vio_read returned %d,  errno: %d",
  623.      length, vio_errno(net->vio)));
  624. #if (!defined(__WIN__) && !defined(__EMX__) && !defined(OS2)) || defined(MYSQL_SERVER)
  625.   /*
  626.     We got an error that there was no data on the socket. We now set up
  627.     an alarm to not 'read forever', change the socket to non blocking
  628.     mode and try again
  629.   */
  630.   if ((interrupted || length == 0) && !thr_alarm_in_use(&alarmed))
  631.   {
  632.     if (!thr_alarm(&alarmed,net->read_timeout,&alarm_buff)) /* Don't wait too long */
  633.     {
  634.       my_bool old_mode;
  635.       while (vio_blocking(net->vio, TRUE, &old_mode) < 0)
  636.       {
  637. if (vio_should_retry(net->vio) &&
  638.     retry_count++ < net->retry_count)
  639.   continue;
  640. DBUG_PRINT("error",
  641.    ("fcntl returned error %d, aborting thread",
  642.     vio_errno(net->vio)));
  643. #ifdef EXTRA_DEBUG
  644. fprintf(stderr,
  645. "%s: read: fcntl returned error %d, aborting threadn",
  646. my_progname,vio_errno(net->vio));
  647. #endif /* EXTRA_DEBUG */
  648. len= packet_error;
  649. net->error= 2;                 /* Close socket */
  650.         net->report_error= 1;
  651. #ifdef MYSQL_SERVER
  652. net->last_errno= ER_NET_FCNTL_ERROR;
  653. #endif
  654. goto end;
  655.       }
  656.       retry_count=0;
  657.       continue;
  658.     }
  659.   }
  660. #endif /* (!defined(__WIN__) && !defined(__EMX__)) || defined(MYSQL_SERVER) */
  661.   if (thr_alarm_in_use(&alarmed) && !thr_got_alarm(&alarmed) &&
  662.       interrupted)
  663.   { /* Probably in MIT threads */
  664.     if (retry_count++ < net->retry_count)
  665.       continue;
  666. #ifdef EXTRA_DEBUG
  667.     fprintf(stderr, "%s: read looped with error %d, aborting threadn",
  668.     my_progname,vio_errno(net->vio));
  669. #endif /* EXTRA_DEBUG */
  670.   }
  671. #if defined(THREAD_SAFE_CLIENT) && !defined(MYSQL_SERVER)
  672.   if (vio_should_retry(net->vio))
  673.   {
  674.     DBUG_PRINT("warning",("Interrupted read. Retrying..."));
  675.     continue;
  676.   }
  677. #endif
  678.   DBUG_PRINT("error",("Couldn't read packet: remain: %u  errno: %d  length: %ld",
  679.       remain, vio_errno(net->vio), length));
  680.   len= packet_error;
  681.   net->error= 2; /* Close socket */
  682.   net->report_error= 1;
  683. #ifdef MYSQL_SERVER
  684.   net->last_errno= (vio_was_interrupted(net->vio) ? ER_NET_READ_INTERRUPTED :
  685.     ER_NET_READ_ERROR);
  686. #endif
  687.   goto end;
  688. }
  689. remain -= (uint32) length;
  690. pos+= (ulong) length;
  691. statistic_add(bytes_received,(ulong) length,&LOCK_bytes_received);
  692.       }
  693.       if (i == 0)
  694.       { /* First parts is packet length */
  695. ulong helping;
  696.         DBUG_DUMP("packet_header",(char*) net->buff+net->where_b,
  697.                   NET_HEADER_SIZE);
  698. if (net->buff[net->where_b + 3] != (uchar) net->pkt_nr)
  699. {
  700.   if (net->buff[net->where_b] != (uchar) 255)
  701.   {
  702.     DBUG_PRINT("error",
  703.        ("Packets out of order (Found: %d, expected %u)",
  704. (int) net->buff[net->where_b + 3],
  705. net->pkt_nr));
  706. #ifdef EXTRA_DEBUG
  707.     fprintf(stderr,"Packets out of order (Found: %d, expected %d)n",
  708.     (int) net->buff[net->where_b + 3],
  709.     (uint) (uchar) net->pkt_nr);
  710. #endif
  711.   }
  712.   len= packet_error;
  713.   net->report_error= 1;
  714. #ifdef MYSQL_SERVER
  715.   net->last_errno=ER_NET_PACKETS_OUT_OF_ORDER;
  716. #endif
  717.   goto end;
  718. }
  719. net->compress_pkt_nr= ++net->pkt_nr;
  720. #ifdef HAVE_COMPRESS
  721. if (net->compress)
  722. {
  723.   /*
  724.     If the packet is compressed then complen > 0 and contains the
  725.     number of bytes in the uncompressed packet
  726.   */
  727.   *complen=uint3korr(&(net->buff[net->where_b + NET_HEADER_SIZE]));
  728. }
  729. #endif
  730. len=uint3korr(net->buff+net->where_b);
  731. if (!len) /* End of big multi-packet */
  732.   goto end;
  733. helping = max(len,*complen) + net->where_b;
  734. /* The necessary size of net->buff */
  735. if (helping >= net->max_packet)
  736. {
  737.   if (net_realloc(net,helping))
  738.   {
  739. #if defined(MYSQL_SERVER) && !defined(NO_ALARM)
  740.     if (!net->compress &&
  741. !my_net_skip_rest(net, (uint32) len, &alarmed, &alarm_buff))
  742.       net->error= 3; /* Successfully skiped packet */
  743. #endif
  744.     len= packet_error;          /* Return error and close connection */
  745.     goto end;
  746.   }
  747. }
  748. pos=net->buff + net->where_b;
  749. remain = (uint32) len;
  750.       }
  751.     }
  752. end:
  753.   if (thr_alarm_in_use(&alarmed))
  754.   {
  755.     my_bool old_mode;
  756.     thr_end_alarm(&alarmed);
  757.     vio_blocking(net->vio, net_blocking, &old_mode);
  758.   }
  759.   net->reading_or_writing=0;
  760. #ifdef DEBUG_DATA_PACKETS
  761.   if (len != packet_error)
  762.     DBUG_DUMP("data",(char*) net->buff+net->where_b, len);
  763. #endif
  764.   return(len);
  765. }
  766. /*
  767.   Read a packet from the client/server and return it without the internal
  768.   package header.
  769.   If the packet is the first packet of a multi-packet packet
  770.   (which is indicated by the length of the packet = 0xffffff) then
  771.   all sub packets are read and concatenated.
  772.   If the packet was compressed, its uncompressed and the length of the
  773.   uncompressed packet is returned.
  774.   The function returns the length of the found packet or packet_error.
  775.   net->read_pos points to the read data.
  776. */
  777. ulong
  778. my_net_read(NET *net)
  779. {
  780.   ulong len,complen;
  781. #ifdef HAVE_COMPRESS
  782.   if (!net->compress)
  783.   {
  784. #endif
  785.     len = my_real_read(net,&complen);
  786.     if (len == MAX_PACKET_LENGTH)
  787.     {
  788.       /* First packet of a multi-packet.  Concatenate the packets */
  789.       ulong save_pos = net->where_b;
  790.       ulong total_length=0;
  791.       do
  792.       {
  793. net->where_b += len;
  794. total_length += len;
  795. len = my_real_read(net,&complen);
  796.       } while (len == MAX_PACKET_LENGTH);
  797.       if (len != packet_error)
  798. len+= total_length;
  799.       net->where_b = save_pos;
  800.     }
  801.     net->read_pos = net->buff + net->where_b;
  802.     if (len != packet_error)
  803.       net->read_pos[len]=0; /* Safeguard for mysql_use_result */
  804.     return len;
  805. #ifdef HAVE_COMPRESS
  806.   }
  807.   else
  808.   {
  809.     /* We are using the compressed protocol */
  810.     ulong buf_length;
  811.     ulong start_of_packet;
  812.     ulong first_packet_offset;
  813.     uint read_length, multi_byte_packet=0;
  814.     if (net->remain_in_buf)
  815.     {
  816.       buf_length= net->buf_length; /* Data left in old packet */
  817.       first_packet_offset= start_of_packet= (net->buf_length -
  818.      net->remain_in_buf);
  819.       /* Restore the character that was overwritten by the end 0 */
  820.       net->buff[start_of_packet]= net->save_char;
  821.     }
  822.     else
  823.     {
  824.       /* reuse buffer, as there is nothing in it that we need */
  825.       buf_length= start_of_packet= first_packet_offset= 0;
  826.     }
  827.     for (;;)
  828.     {
  829.       ulong packet_len;
  830.       if (buf_length - start_of_packet >= NET_HEADER_SIZE)
  831.       {
  832. read_length = uint3korr(net->buff+start_of_packet);
  833. if (!read_length)
  834.   /* End of multi-byte packet */
  835.   start_of_packet += NET_HEADER_SIZE;
  836.   break;
  837. }
  838. if (read_length + NET_HEADER_SIZE <= buf_length - start_of_packet)
  839. {
  840.   if (multi_byte_packet)
  841.   {
  842.     /* Remove packet header for second packet */
  843.     memmove(net->buff + first_packet_offset + start_of_packet,
  844.     net->buff + first_packet_offset + start_of_packet +
  845.     NET_HEADER_SIZE,
  846.     buf_length - start_of_packet);
  847.     start_of_packet += read_length;
  848.     buf_length -= NET_HEADER_SIZE;
  849.   }
  850.   else
  851.     start_of_packet+= read_length + NET_HEADER_SIZE;
  852.   if (read_length != MAX_PACKET_LENGTH) /* last package */
  853.   {
  854.     multi_byte_packet= 0; /* No last zero len packet */
  855.     break;
  856.   }
  857.   multi_byte_packet= NET_HEADER_SIZE;
  858.   /* Move data down to read next data packet after current one */
  859.   if (first_packet_offset)
  860.   {
  861.     memmove(net->buff,net->buff+first_packet_offset,
  862.     buf_length-first_packet_offset);
  863.     buf_length-=first_packet_offset;
  864.     start_of_packet -= first_packet_offset;
  865.     first_packet_offset=0;
  866.   }
  867.   continue;
  868. }
  869.       }
  870.       /* Move data down to read next data packet after current one */
  871.       if (first_packet_offset)
  872.       {
  873. memmove(net->buff,net->buff+first_packet_offset,
  874. buf_length-first_packet_offset);
  875. buf_length-=first_packet_offset;
  876. start_of_packet -= first_packet_offset;
  877. first_packet_offset=0;
  878.       }
  879.       net->where_b=buf_length;
  880.       if ((packet_len = my_real_read(net,&complen)) == packet_error)
  881. return packet_error;
  882.       if (my_uncompress((byte*) net->buff + net->where_b, &packet_len,
  883. &complen))
  884.       {
  885. net->error= 2; /* caller will close socket */
  886. net->report_error= 1;
  887. #ifdef MYSQL_SERVER
  888. net->last_errno=ER_NET_UNCOMPRESS_ERROR;
  889. #endif
  890. return packet_error;
  891.       }
  892.       buf_length+=packet_len;
  893.     }
  894.     net->read_pos=      net->buff+ first_packet_offset + NET_HEADER_SIZE;
  895.     net->buf_length=    buf_length;
  896.     net->remain_in_buf= (ulong) (buf_length - start_of_packet);
  897.     len = ((ulong) (start_of_packet - first_packet_offset) - NET_HEADER_SIZE -
  898.            multi_byte_packet);
  899.     net->save_char= net->read_pos[len]; /* Must be saved */
  900.     net->read_pos[len]=0; /* Safeguard for mysql_use_result */
  901.   }
  902. #endif /* HAVE_COMPRESS */
  903.   return len;
  904. }