home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / libmysql / net.c < prev    next >
C/C++ Source or Header  |  2000-08-31  |  19KB  |  681 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This library is free software; you can redistribute it and/or
  4.    modify it under the terms of the GNU Library General Public
  5.    License as published by the Free Software Foundation; either
  6.    version 2 of the License, or (at your option) any later version.
  7.    
  8.    This library is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11.    Library General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU Library General Public
  14.    License along with this library; if not, write to the Free
  15.    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16.    MA 02111-1307, USA */
  17.  
  18. /* Write and read of logical packets to/from socket
  19. ** Writes are cached into net_buffer_length big packets.
  20. ** Read packets are reallocated dynamicly when reading big packets.
  21. ** Each logical packet has the following pre-info:
  22. ** 3 byte length & 1 byte package-number.
  23. */
  24.  
  25. #ifdef __WIN__
  26. #include <winsock.h>
  27. #endif
  28. #include <global.h>
  29. #include <violite.h>
  30. #include <my_sys.h>
  31. #include <m_string.h>
  32. #include "mysql.h"
  33. #include "mysqld_error.h"
  34. #include <signal.h>
  35. #include <errno.h>
  36. #include <sys/types.h>
  37. #include <violite.h>
  38.  
  39. #ifdef MYSQL_SERVER
  40. ulong max_allowed_packet=65536;
  41. extern ulong net_read_timeout,net_write_timeout;
  42. extern uint test_flags;
  43. #else
  44. ulong max_allowed_packet=16*1024*1024L;
  45. ulong net_read_timeout=  NET_READ_TIMEOUT;
  46. ulong net_write_timeout= NET_WRITE_TIMEOUT;
  47. #endif
  48. ulong net_buffer_length=8192;    /* Default length. Enlarged if necessary */
  49.  
  50. #if !defined(__WIN__) && !defined(MSDOS)
  51. #include <sys/socket.h>
  52. #else
  53. #undef MYSQL_SERVER            // Win32 can't handle interrupts
  54. #endif
  55. #if !defined(MSDOS) && !defined(__WIN__) && !defined(HAVE_BROKEN_NETINET_INCLUDES) && !defined(__BEOS__)
  56. #include <netinet/in_systm.h>
  57. #include <netinet/in.h>
  58. #include <netinet/ip.h>
  59. #if !defined(alpha_linux_port)
  60. #include <netinet/tcp.h>
  61. #endif
  62. #endif
  63. #include "mysqld_error.h"
  64. #ifdef MYSQL_SERVER
  65. #include "my_pthread.h"
  66. #include "thr_alarm.h"
  67. void sql_print_error(const char *format,...);
  68. #define RETRY_COUNT mysqld_net_retry_count
  69. extern ulong mysqld_net_retry_count;
  70. #else
  71. typedef my_bool thr_alarm_t;
  72. typedef my_bool ALARM;
  73. #define thr_alarm_init(A) (*A)=0
  74. #define thr_alarm_in_use(A) (A)
  75. #define thr_end_alarm(A)
  76. #define thr_alarm(A,B,C) local_thr_alarm((A),(B),(C))
  77. static inline int local_thr_alarm(my_bool *A,int B __attribute__((unused)),ALARM *C __attribute__((unused)))
  78. {
  79.   *A=1;
  80.   return 0;
  81. }
  82. #define thr_got_alarm(A) 0
  83. #define RETRY_COUNT 1
  84. #endif
  85.  
  86. #ifdef MYSQL_SERVER
  87. extern ulong bytes_sent, bytes_received; 
  88. extern pthread_mutex_t LOCK_bytes_sent , LOCK_bytes_received;
  89. #else
  90. #undef statistic_add
  91. #define statistic_add(A,B,C)
  92. #endif
  93.  
  94. /*
  95. ** Give error if a too big packet is found
  96. ** The server can change this with the -O switch, but because the client
  97. ** can't normally do this the client should have a bigger max-buffer.
  98. */
  99.  
  100. #define TEST_BLOCKING        8
  101. static int net_write_buff(NET *net,const char *packet,uint len);
  102.  
  103.  
  104.     /* Init with packet info */
  105.  
  106. int my_net_init(NET *net, Vio* vio)
  107. {
  108.   if (!(net->buff=(uchar*) my_malloc(net_buffer_length,MYF(MY_WME))))
  109.     return 1;
  110.   if (net_buffer_length > max_allowed_packet)
  111.     max_allowed_packet=net_buffer_length;
  112.   net->buff_end=net->buff+(net->max_packet=net_buffer_length);
  113.   net->vio = vio;
  114.   net->no_send_ok = 0;
  115.   net->error=0; net->return_errno=0; net->return_status=0;
  116.   net->timeout=(uint) net_read_timeout;        /* Timeout for read */
  117.   net->pkt_nr=0;
  118.   net->write_pos=net->read_pos = net->buff;
  119.   net->last_error[0]=0;
  120.   net->compress=0; net->reading_or_writing=0;
  121.   net->where_b = net->remain_in_buf=0;
  122.   net->last_errno=0;
  123.  
  124.   if (vio != 0)                    /* If real connection */
  125.   {
  126.     net->fd  = vio_fd(vio);            /* For perl DBI/DBD */
  127. #if defined(MYSQL_SERVER) && !defined(___WIN__) && !defined(__EMX__)
  128.     if (!(test_flags & TEST_BLOCKING))
  129.       vio_blocking(vio, FALSE);
  130. #endif
  131.     vio_fastsend(vio,TRUE);
  132.   }
  133.   return 0;
  134. }
  135.  
  136. void net_end(NET *net)
  137. {
  138.   my_free((gptr) net->buff,MYF(MY_ALLOW_ZERO_PTR));
  139.   net->buff=0;
  140. }
  141.  
  142. /* Realloc the packet buffer */
  143.  
  144. static my_bool net_realloc(NET *net, ulong length)
  145. {
  146.   uchar *buff;
  147.   ulong pkt_length;
  148.   if (length >= max_allowed_packet)
  149.   {
  150.     DBUG_PRINT("error",("Packet too large (%lu)", length));
  151.     net->error=1;
  152.     net->last_errno=ER_NET_PACKET_TOO_LARGE;
  153.     return 1;
  154.   }
  155.   pkt_length = (length+IO_SIZE-1) & ~(IO_SIZE-1);
  156.   if (!(buff=(uchar*) my_realloc((char*) net->buff, pkt_length, MYF(MY_WME))))
  157.   {
  158.     net->error=1;
  159. #ifdef MYSQL_SERVER
  160.     net->last_errno=ER_OUT_OF_RESOURCES;
  161. #endif
  162.     return 1;
  163.   }
  164.   net->buff=net->write_pos=buff;
  165.   net->buff_end=buff+(net->max_packet=pkt_length);
  166.   return 0;
  167. }
  168.  
  169.     /* Remove unwanted characters from connection */
  170.  
  171. void net_clear(NET *net)
  172. {
  173. #ifndef EXTRA_DEBUG
  174.   int count;
  175.   bool is_blocking=vio_is_blocking(net->vio);
  176.   if (is_blocking)
  177.     vio_blocking(net->vio, FALSE);
  178.   if (!vio_is_blocking(net->vio))        /* Safety if SSL */
  179.   {
  180.     while ( (count = vio_read(net->vio, (char*) (net->buff),
  181.                   net->max_packet)) > 0)
  182.       DBUG_PRINT("info",("skipped %d bytes from file: %s",
  183.              count,vio_description(net->vio)));
  184.     if (is_blocking)
  185.       vio_blocking(net->vio, TRUE);
  186.   }
  187. #endif /* EXTRA_DEBUG */
  188.   net->pkt_nr=0;                /* Ready for new command */
  189.   net->write_pos=net->buff;
  190. }
  191.  
  192.     /* Flush write_buffer if not empty. */
  193.  
  194. int net_flush(NET *net)
  195. {
  196.   int error=0;
  197.   DBUG_ENTER("net_flush");
  198.   if (net->buff != net->write_pos)
  199.   {
  200.     error=net_real_write(net,(char*) net->buff,
  201.              (uint) (net->write_pos - net->buff));
  202.     net->write_pos=net->buff;
  203.   }
  204.   DBUG_RETURN(error);
  205. }
  206.  
  207.  
  208. /*****************************************************************************
  209. ** Write something to server/client buffer
  210. *****************************************************************************/
  211.  
  212.  
  213. /*
  214. ** Write a logical packet with packet header
  215. ** Format: Packet length (3 bytes), packet number(1 byte)
  216. **         When compression is used a 3 byte compression length is added
  217. ** NOTE: If compression is used the original package is destroyed!
  218. */
  219.  
  220. int
  221. my_net_write(NET *net,const char *packet,ulong len)
  222. {
  223.   uchar buff[NET_HEADER_SIZE];
  224.   int3store(buff,len);
  225.   buff[3]= (net->compress) ? 0 : (uchar) (net->pkt_nr++);
  226.   if (net_write_buff(net,(char*) buff,NET_HEADER_SIZE))
  227.     return 1;
  228.   return net_write_buff(net,packet,len);
  229. }
  230.  
  231. int
  232. net_write_command(NET *net,uchar command,const char *packet,ulong len)
  233. {
  234.   uchar buff[NET_HEADER_SIZE+1];
  235.   uint length=len+1;                /* 1 extra byte for command */
  236.  
  237.   int3store(buff,length);
  238.   buff[3]= (net->compress) ? 0 : (uchar) (net->pkt_nr++);
  239.   buff[4]=command;
  240.   if (net_write_buff(net,(char*) buff,5))
  241.     return 1;
  242.   return test(net_write_buff(net,packet,len) || net_flush(net));
  243. }
  244.  
  245.  
  246. static int
  247. net_write_buff(NET *net,const char *packet,uint len)
  248. {
  249.   uint left_length=(uint) (net->buff_end - net->write_pos);
  250.  
  251.   while (len > left_length)
  252.   {
  253.     memcpy((char*) net->write_pos,packet,left_length);
  254.     if (net_real_write(net,(char*) net->buff,net->max_packet))
  255.       return 1;
  256.     net->write_pos=net->buff;
  257.     packet+=left_length;
  258.     len-=left_length;
  259.     left_length=net->max_packet;
  260.   }
  261.   memcpy((char*) net->write_pos,packet,len);
  262.   net->write_pos+=len;
  263.   return 0;
  264. }
  265.  
  266. /*  Read and write using timeouts */
  267.  
  268. int
  269. net_real_write(NET *net,const char *packet,ulong len)
  270. {
  271.   int length;
  272.   char *pos,*end;
  273.   thr_alarm_t alarmed;
  274. #if (!defined(__WIN__) && !defined(__EMX__))
  275.   ALARM alarm_buff;
  276. #endif
  277.   uint retry_count=0;
  278.   my_bool net_blocking = vio_is_blocking(net->vio);
  279.   DBUG_ENTER("net_real_write");
  280.  
  281.   if (net->error == 2)
  282.     DBUG_RETURN(-1);                /* socket can't be used */
  283.  
  284.   net->reading_or_writing=2;
  285. #ifdef HAVE_COMPRESS
  286.   if (net->compress)
  287.   {
  288.     ulong complen;
  289.     uchar *b;
  290.     uint header_length=NET_HEADER_SIZE+COMP_HEADER_SIZE;
  291.     if (!(b=(uchar*) my_malloc(len + NET_HEADER_SIZE + COMP_HEADER_SIZE,
  292.                     MYF(MY_WME))))
  293.     {
  294. #ifdef MYSQL_SERVER
  295.       net->last_errno=ER_OUT_OF_RESOURCES;
  296.       net->error=2;
  297. #endif
  298.       net->reading_or_writing=0;
  299.       DBUG_RETURN(1);
  300.     }
  301.     memcpy(b+header_length,packet,len);
  302.  
  303.     if (my_compress((byte*) b+header_length,&len,&complen))
  304.     {
  305.       DBUG_PRINT("warning",
  306.          ("Compression error; Continuing without compression"));
  307.       complen=0;
  308.     }
  309.     int3store(&b[NET_HEADER_SIZE],complen);
  310.     int3store(b,len);
  311.     b[3]=(uchar) (net->pkt_nr++);
  312.     len+= header_length;
  313.     packet= (char*) b;
  314.   }
  315. #endif /* HAVE_COMPRESS */
  316.  
  317.   /* DBUG_DUMP("net",packet,len); */
  318. #ifdef MYSQL_SERVER
  319.   thr_alarm_init(&alarmed);
  320.   if (net_blocking)
  321.     thr_alarm(&alarmed,(uint) net_write_timeout,&alarm_buff);
  322. #else
  323.   alarmed=0;
  324. #endif /* MYSQL_SERVER */
  325.  
  326.   pos=(char*) packet; end=pos+len;
  327.   while (pos != end)
  328.   {
  329.     if ((int) (length=vio_write(net->vio,pos,(int) (end-pos))) <= 0)
  330.     {
  331.       my_bool interrupted = vio_should_retry(net->vio);
  332. #if (!defined(__WIN__) && !defined(__EMX__))
  333.       if ((interrupted || length==0) && !thr_alarm_in_use(alarmed))
  334.       {
  335.         if (!thr_alarm(&alarmed,(uint) net_write_timeout,&alarm_buff))
  336.         {                                       /* Always true for client */
  337.       if (!vio_is_blocking(net->vio))
  338.       {
  339.         while (vio_blocking(net->vio, TRUE) < 0)
  340.         {
  341.           if (vio_should_retry(net->vio) && retry_count++ < RETRY_COUNT)
  342.         continue;
  343. #ifdef EXTRA_DEBUG
  344.           fprintf(stderr,
  345.               "%s: my_net_write: fcntl returned error %d, aborting thread\n",
  346.               my_progname,vio_errno(net->vio));
  347. #endif /* EXTRA_DEBUG */
  348.           net->error=2;                     /* Close socket */
  349.           goto end;
  350.         }
  351.       }
  352.       retry_count=0;
  353.       continue;
  354.     }
  355.       }
  356.       else
  357. #endif /* (!defined(__WIN__) && !defined(__EMX__)) */
  358.     if (thr_alarm_in_use(alarmed) && !thr_got_alarm(alarmed) &&
  359.         interrupted)
  360.       {
  361.     if (retry_count++ < RETRY_COUNT)
  362.         continue;
  363. #ifdef EXTRA_DEBUG
  364.       fprintf(stderr, "%s: write looped, aborting thread\n",
  365.           my_progname);
  366. #endif /* EXTRA_DEBUG */
  367.       }
  368. #if defined(THREAD_SAFE_CLIENT) && !defined(MYSQL_SERVER)
  369.       if (vio_errno(net->vio) == EINTR)
  370.       {
  371.     DBUG_PRINT("warning",("Interrupted write. Retrying..."));
  372.     continue;
  373.       }
  374. #endif /* defined(THREAD_SAFE_CLIENT) && !defined(MYSQL_SERVER) */
  375.       net->error=2;                /* Close socket */
  376. #ifdef MYSQL_SERVER
  377.       net->last_errno= (interrupted ? ER_NET_WRITE_INTERRUPTED :
  378.             ER_NET_ERROR_ON_WRITE);
  379. #endif /* MYSQL_SERVER */
  380.       break;
  381.     }
  382.     pos+=length;
  383.     statistic_add(bytes_sent,length,&LOCK_bytes_sent);
  384.   }
  385. #ifndef __WIN__
  386.  end:
  387. #endif
  388. #ifdef HAVE_COMPRESS
  389.   if (net->compress)
  390.     my_free((char*) packet,MYF(0));
  391. #endif
  392.   if (thr_alarm_in_use(alarmed))
  393.   {
  394.     thr_end_alarm(&alarmed);
  395.     vio_blocking(net->vio, net_blocking);
  396.   }
  397.   net->reading_or_writing=0;
  398.   DBUG_RETURN(((int) (pos != end)));
  399. }
  400.  
  401.  
  402. /*****************************************************************************
  403. ** Read something from server/clinet
  404. *****************************************************************************/
  405.  
  406. #ifdef MYSQL_SERVER
  407.  
  408. /*
  409.   Help function to clear the commuication buffer when we get a too
  410.   big packet
  411. */
  412.  
  413. static void my_net_skip_rest(NET *net, ulong remain, thr_alarm_t *alarmed)
  414. {
  415.   char buff[1024];
  416.   ALARM alarm_buff;
  417.   uint retry_count=0;
  418.   if (!thr_alarm_in_use(alarmed))
  419.   {
  420.     if (!thr_alarm(alarmed,net->timeout,&alarm_buff) ||
  421.     (!vio_is_blocking(net->vio) && vio_blocking(net->vio,TRUE) < 0))
  422.       return;                    // Can't setup, abort
  423.   }
  424.   while (remain > 0)
  425.   {
  426.     ulong length;
  427.     if ((int) (length=vio_read(net->vio,(char*) net->buff,remain)) <= 0L)
  428.     {
  429.       my_bool interrupted = vio_should_retry(net->vio);
  430.       if (!thr_got_alarm(alarmed) && interrupted)
  431.       {                    /* Probably in MIT threads */
  432.     if (retry_count++ < RETRY_COUNT)
  433.       continue;
  434.       }
  435.       return;
  436.     }
  437.     remain -=(ulong) length;
  438.     statistic_add(bytes_received,(ulong) length,&LOCK_bytes_received);
  439.   }
  440. }
  441. #endif /* MYSQL_SERVER */
  442.  
  443.  
  444. static uint
  445. my_real_read(NET *net, ulong *complen)
  446. {
  447.   uchar *pos;
  448.   long length;
  449.   uint i,retry_count=0;
  450.   ulong len=packet_error;
  451.   thr_alarm_t alarmed;
  452. #if (!defined(__WIN__) && !defined(__EMX__)) || defined(MYSQL_SERVER)
  453.   ALARM alarm_buff;
  454. #endif
  455.   my_bool net_blocking=vio_is_blocking(net->vio);
  456.   ulong remain= (net->compress ? NET_HEADER_SIZE+COMP_HEADER_SIZE :
  457.          NET_HEADER_SIZE);
  458.   *complen = 0;
  459.  
  460.   net->reading_or_writing=1;
  461.   thr_alarm_init(&alarmed);
  462. #ifdef MYSQL_SERVER
  463.   if (net_blocking)
  464.     thr_alarm(&alarmed,net->timeout,&alarm_buff);
  465. #endif /* MYSQL_SERVER */
  466.  
  467.     pos = net->buff + net->where_b;        /* net->packet -4 */
  468.     for (i=0 ; i < 2 ; i++)
  469.     {
  470.       while (remain > 0)
  471.       {
  472.     /* First read is done with non blocking mode */
  473.         if ((int) (length=vio_read(net->vio,(char*) pos,remain)) <= 0L)
  474.         {
  475.           my_bool interrupted = vio_should_retry(net->vio);
  476.  
  477.       DBUG_PRINT("info",("vio_read returned %d,  errno: %d",
  478.                  length, vio_errno(net->vio)));
  479. #if (!defined(__WIN__) && !defined(__EMX__)) || defined(MYSQL_SERVER)
  480.       /*
  481.         We got an error that there was no data on the socket. We now set up
  482.         an alarm to not 'read forever', change the socket to non blocking
  483.         mode and try again
  484.       */
  485.       if ((interrupted || length == 0) && !thr_alarm_in_use(alarmed))
  486.       {
  487.         if (!thr_alarm(&alarmed,net->timeout,&alarm_buff)) /* Don't wait too long */
  488.         {
  489.               if (!vio_is_blocking(net->vio))
  490.               {
  491.                 while (vio_blocking(net->vio,TRUE) < 0)
  492.                 {
  493.                   if (vio_should_retry(net->vio) &&
  494.               retry_count++ < RETRY_COUNT)
  495.                     continue;
  496.                   DBUG_PRINT("error",
  497.                  ("fcntl returned error %d, aborting thread",
  498.                   vio_errno(net->vio)));
  499. #ifdef EXTRA_DEBUG
  500.                   fprintf(stderr,
  501.                           "%s: read: fcntl returned error %d, aborting thread\n",
  502.                           my_progname,vio_errno(net->vio));
  503. #endif /* EXTRA_DEBUG */
  504.                   len= packet_error;
  505.                   net->error=2;                 /* Close socket */
  506. #ifdef MYSQL_SERVER
  507.           net->last_errno=ER_NET_FCNTL_ERROR;
  508. #endif
  509.           goto end;
  510.                 }
  511.               }
  512.           retry_count=0;
  513.           continue;
  514.         }
  515.       }
  516. #endif /* (!defined(__WIN__) && !defined(__EMX__)) || defined(MYSQL_SERVER) */
  517.       if (thr_alarm_in_use(alarmed) && !thr_got_alarm(alarmed) &&
  518.           interrupted)
  519.       {                    /* Probably in MIT threads */
  520.         if (retry_count++ < RETRY_COUNT)
  521.           continue;
  522. #ifdef EXTRA_DEBUG
  523.         fprintf(stderr, "%s: read looped with error %d, aborting thread\n",
  524.             my_progname,vio_errno(net->vio));
  525. #endif /* EXTRA_DEBUG */
  526.       }
  527. #if defined(THREAD_SAFE_CLIENT) && !defined(MYSQL_SERVER)
  528.       if (vio_should_retry(net->vio))
  529.       {
  530.         DBUG_PRINT("warning",("Interrupted read. Retrying..."));
  531.         continue;
  532.       }
  533. #endif
  534.       DBUG_PRINT("error",("Couldn't read packet: remain: %d  errno: %d  length: %d  alarmed: %d", remain,vio_errno(net->vio),length,alarmed));
  535.       len= packet_error;
  536.       net->error=2;                /* Close socket */
  537. #ifdef MYSQL_SERVER
  538.       net->last_errno= (interrupted ? ER_NET_READ_INTERRUPTED :
  539.                 ER_NET_READ_ERROR);
  540. #endif
  541.       goto end;
  542.     }
  543.     remain -= (ulong) length;
  544.     pos+= (ulong) length;
  545.     statistic_add(bytes_received,(ulong) length,&LOCK_bytes_received);
  546.       }
  547.       if (i == 0)
  548.       {                    /* First parts is packet length */
  549.     ulong helping;
  550.     if (net->buff[net->where_b + 3] != (uchar) net->pkt_nr)
  551.     {
  552.       if (net->buff[net->where_b] != (uchar) 255)
  553.       {
  554.         DBUG_PRINT("error",
  555.                ("Packets out of order (Found: %d, expected %d)",
  556.             (int) net->buff[net->where_b + 3],
  557.             (uint) (uchar) net->pkt_nr));
  558. #ifdef EXTRA_DEBUG
  559.         fprintf(stderr,"Packets out of order (Found: %d, expected %d)\n",
  560.             (int) net->buff[net->where_b + 3],
  561.             (uint) (uchar) net->pkt_nr);
  562. #endif
  563.       }
  564.       len= packet_error;
  565. #ifdef MYSQL_SERVER
  566.       net->last_errno=ER_NET_PACKETS_OUT_OF_ORDER;
  567. #endif
  568.       goto end;
  569.     }
  570.     net->pkt_nr++;
  571. #ifdef HAVE_COMPRESS
  572.     if (net->compress)
  573.     {
  574.       /* complen is > 0 if package is really compressed */
  575.       *complen=uint3korr(&(net->buff[net->where_b + NET_HEADER_SIZE]));
  576.     }
  577. #endif
  578.  
  579.     len=uint3korr(net->buff+net->where_b);
  580.     helping = max(len,*complen) + net->where_b;
  581.     /* The necessary size of net->buff */
  582.     if (helping >= net->max_packet)
  583.     {
  584.       /* We must allocate one extra byte for the end null */
  585.       if (net_realloc(net,helping+1))
  586.       {
  587. #ifdef MYSQL_SERVER
  588.         if (i == 1)
  589.           my_net_skip_rest(net, len, &alarmed);
  590. #endif
  591.         len= packet_error;        /* Return error */
  592.         goto end;
  593.       }
  594.     }
  595.     pos=net->buff + net->where_b;
  596.     remain = len;
  597.       }
  598.     }
  599.  
  600. end:
  601.   if (thr_alarm_in_use(alarmed))
  602.   {
  603.     thr_end_alarm(&alarmed);
  604.     vio_blocking(net->vio, net_blocking);
  605.   }
  606.   net->reading_or_writing=0;
  607.   return(len);
  608. }
  609.  
  610. uint
  611. my_net_read(NET *net)
  612. {
  613.   ulong len,complen;
  614.  
  615. #ifdef HAVE_COMPRESS
  616.   if (!net->compress)
  617.   {
  618. #endif
  619.     len = my_real_read (net,&complen);
  620.     net->read_pos = net->buff + net->where_b;
  621.     if (len != packet_error)
  622.       net->read_pos[len]=0;        /* Safeguard for mysql_use_result */
  623.     return len;
  624. #ifdef HAVE_COMPRESS
  625.   }
  626.   if (net->remain_in_buf)
  627.     net->buff[net->buf_length - net->remain_in_buf]=net->save_char;
  628.   for (;;)
  629.   {
  630.     if (net->remain_in_buf)
  631.     {
  632.       uchar *pos = net->buff + net->buf_length - net->remain_in_buf;
  633.       if (net->remain_in_buf >= 4)
  634.       {
  635.     net->length = uint3korr(pos);
  636.     if (net->length <= net->remain_in_buf - 4)
  637.     {
  638.       /* We have a full packet */
  639.       len=net->length;
  640.       net->remain_in_buf -= net->length + 4;
  641.       net->read_pos=pos + 4;
  642.       break;            /* We have a full packet */
  643.     }
  644.       }
  645.       /* Move data down to read next data packet after current one */
  646.       if (net->buf_length != net->remain_in_buf)
  647.       {
  648.     memmove(net->buff,pos,net->remain_in_buf);
  649.     net->buf_length=net->remain_in_buf;
  650.       }
  651.       net->where_b=net->buf_length;
  652.     }
  653.     else
  654.     {
  655.       net->where_b=0;
  656.       net->buf_length=0;
  657.     }
  658.  
  659.     if ((len = my_real_read(net,&complen)) == packet_error)
  660.       break;
  661.     if (my_uncompress((byte*) net->buff + net->where_b, &len, &complen))
  662.     {
  663.       len= packet_error;
  664.       net->error=2;            /* caller will close socket */
  665. #ifdef MYSQL_SERVER
  666.       net->last_errno=ER_NET_UNCOMPRESS_ERROR;
  667. #endif
  668.       break;
  669.     }
  670.     net->buf_length+=len;
  671.     net->remain_in_buf+=len;
  672.   }
  673.   if (len != packet_error)
  674.   {
  675.     net->save_char= net->read_pos[len];    /* Must be saved */
  676.     net->read_pos[len]=0;        /* Safeguard for mysql_use_result */
  677.   }
  678.   return len;
  679. #endif
  680. }
  681.