mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2025-07-07 17:37:12 +02:00
Integrate MySQL module.
This commit is contained in:
module
CMakeLists.txt
Library
Vendor
CMakeLists.txt
MDBC
CMakeLists.txtCOPYING.LIBREADME
cmake
COPYING-CMAKE-SCRIPTSCheckFunctions.cmakeCheckIncludeFiles.cmakeCheckTypes.cmakeConnectorName.cmakeFindIconv.cmakeSearchLibrary.cmakeWindowsCache.cmakeinstall.cmakelinux_x86_toolchain.cmakesign.cmakesymlink.cmakeversion_info.cmake
examples
include
CMakeLists.txtconfig-win.hdbug.herrmsg.hgetopt.hhash.hm_ctype.hm_string.hma_common.hma_dyncol.hma_secure.hmy_alarm.hmy_base.hmy_config.hmy_config.h.inmy_context.hmy_dir.hmy_global.hmy_list.hmy_net.hmy_no_pthread.hmy_pthread.hmy_stmt.hmy_sys.hmysql.h
mysql
mysql_async.hmysql_com.hmysql_io.hmysql_mm.hmysql_priv.hmysql_version.hmysql_version.h.inmysql_wireprotocol.hmysqld_error.hmysys_err.hsha1.hthr_alarm.hviolite.hlibmariadb
CMakeLists.txtacinclude.m4array.cbchange.cbmove.cbmove_upp.ccharset.cclient_plugin.cdbug.cdefault.cerrmsg.cerrors.cget_password.cgetopt.cgetopt1.chash.cint2str.cis_prefix.clibmariadb.clist.cllstr.clonglong2str.cma_dtoa.cma_dyncol.cma_secure.cma_time.cmf_dirname.cmf_fn_ext.cmf_format.cmf_loadpath.cmf_pack.cmf_path.cmf_unixpath.cmf_wcomp.cmulalloc.cmy_alloc.cmy_auth.cmy_charset.cmy_compress.cmy_context.cmy_div.cmy_error.cmy_fopen.cmy_fstream.cmy_getwd.cmy_init.cmy_lib.cmy_loaddata.cmy_malloc.cmy_messnc.cmy_net.cmy_once.cmy_open.cmy_port.cmy_pthread.cmy_read.cmy_realloc.cmy_seek.cmy_static.cmy_static.hmy_stmt.cmy_stmt_codec.cmy_symlink.cmy_thr_init.cmy_vsnprintf.cmy_write.cmysql_async.cmysys_priv.hnet.cpassword.csha1.cstr2int.cstrcend.cstrcont.cstrend.cstrfill.cstring.cstrinstr.cstrmake.cstrmov.cstrnlen.cstrnmov.cstrto.cstrtoll.cstrtoull.cstrxmov.cstrxnmov.cthr_mutex.ctypelib.cviolite.c
mariadb_config
plugins
win-iconv
win
packaging
resource.rc.inzlib
CMakeLists.txtChangeLogFAQINDEXMakefileMakefile.inREADMEadler32.c
amiga
compress.cconfigurecontrib
README.contrib
crc32.ccrc32.hdeflate.cdeflate.hada
buffer_demo.adbmtest.adbread.adbreadme.txttest.adbzlib-streams.adbzlib-streams.adszlib-thin.adbzlib-thin.adszlib.adbzlib.adszlib.gpr
amd64
asm686
blast
delphi
dotzlib
DotZLib.buildDotZLib.chmDotZLib.sln
DotZLib
AssemblyInfo.csChecksumImpl.csCircularBuffer.csCodecBase.csDeflater.csDotZLib.csDotZLib.csprojGZipStream.csInflater.csUnitTests.cs
LICENSE_1_0.txtreadme.txtgcc_gvmat64
infback9
inflate86
iostream
iostream2
iostream3
masmx64
masmx86
minizip
MakefileMakefile.amMiniZip64_Changes.txtMiniZip64_info.txtconfigure.accrypt.hioapi.cioapi.hiowin32.ciowin32.hmake_vms.comminiunz.cminiunzip.1minizip.1minizip.cminizip.pc.inmztools.cmztools.hunzip.cunzip.hzip.czip.h
pascal
puff
testzlib
untgz
vstudio
readme.txt
vc10
miniunz.vcxprojminiunz.vcxproj.filtersminizip.vcxprojminizip.vcxproj.filterstestzlib.vcxprojtestzlib.vcxproj.filterstestzlibdll.vcxprojtestzlibdll.vcxproj.filterszlib.rczlibstat.vcxprojzlibstat.vcxproj.filterszlibvc.defzlibvc.slnzlibvc.vcxprojzlibvc.vcxproj.filters
vc11
miniunz.vcxprojminizip.vcxprojtestzlib.vcxprojtestzlibdll.vcxprojzlib.rczlibstat.vcxprojzlibvc.defzlibvc.slnzlibvc.vcxproj
vc12
miniunz.vcxprojminizip.vcxprojtestzlib.vcxprojtestzlibdll.vcxprojzlib.rczlibstat.vcxprojzlibvc.defzlibvc.slnzlibvc.vcxproj
vc14
miniunz.vcxprojminizip.vcxprojtestzlib.vcxprojtestzlibdll.vcxprojzlib.rczlibstat.vcxprojzlibvc.defzlibvc.slnzlibvc.vcxproj
vc9
doc
examples
gzclose.cgzguts.hgzlib.cgzread.cgzwrite.cinfback.cinffast.cinffast.hinffixed.hinflate.cinflate.hinftrees.cinftrees.hmake_vms.commsdos
nintendods
old
os400
qnx
test
treebuild.xmltrees.ctrees.huncompr.cwatcom
win32
zconf.h.cmakeinzconf.h.inzconf.h.includedzlib.3zlib.3.pdfzlib.hzlib.mapzlib.pc.cmakeinzlib.pc.inzlib2ansizutil.czutil.h
868
module/Vendor/MDBC/libmariadb/net.c
vendored
Normal file
868
module/Vendor/MDBC/libmariadb/net.c
vendored
Normal file
@ -0,0 +1,868 @@
|
||||
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Library General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with this library; if not, write to the Free
|
||||
Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
||||
MA 02111-1301, USA */
|
||||
|
||||
/* Write and read of logical packets to/from socket
|
||||
** Writes are cached into net_buffer_length big packets.
|
||||
** Read packets are reallocated dynamicly when reading big packets.
|
||||
** Each logical packet has the following pre-info:
|
||||
** 3 byte length & 1 byte package-number.
|
||||
*/
|
||||
|
||||
#include <my_global.h>
|
||||
#include <violite.h>
|
||||
#include <my_sys.h>
|
||||
#include <m_string.h>
|
||||
#include "mysql.h"
|
||||
#include "mysqld_error.h"
|
||||
#include <signal.h>
|
||||
#include <errno.h>
|
||||
#include <sys/types.h>
|
||||
#ifndef _WIN32
|
||||
#include <poll.h>
|
||||
#endif
|
||||
|
||||
#define MAX_PACKET_LENGTH (256L*256L*256L-1)
|
||||
|
||||
/* net_buffer_length and max_allowed_packet are defined in mysql.h
|
||||
See bug conc-57
|
||||
*/
|
||||
#undef net_buffer_length
|
||||
|
||||
#undef max_allowed_packet
|
||||
ulong max_allowed_packet=1024L * 1024L * 1024L;
|
||||
ulong net_read_timeout= NET_READ_TIMEOUT;
|
||||
ulong net_write_timeout= NET_WRITE_TIMEOUT;
|
||||
ulong net_buffer_length=8192; /* Default length. Enlarged if necessary */
|
||||
|
||||
#if !defined(_WIN32) && !defined(MSDOS)
|
||||
#include <sys/socket.h>
|
||||
#else
|
||||
#undef MYSQL_SERVER /* Win32 can't handle interrupts */
|
||||
#endif
|
||||
#if !defined(MSDOS) && !defined(_WIN32) && !defined(HAVE_BROKEN_NETINET_INCLUDES) && !defined(__BEOS__)
|
||||
#include <netinet/in_systm.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/ip.h>
|
||||
#if !defined(alpha_linux_port)
|
||||
#include <netinet/tcp.h>
|
||||
#endif
|
||||
#endif
|
||||
#include "mysqld_error.h"
|
||||
#ifdef MYSQL_SERVER
|
||||
#include "my_pthread.h"
|
||||
#include "thr_alarm.h"
|
||||
void sql_print_error(const char *format,...);
|
||||
#define RETRY_COUNT mysqld_net_retry_count
|
||||
extern ulong mysqld_net_retry_count;
|
||||
#else
|
||||
|
||||
#ifdef OS2 /* avoid name conflict */
|
||||
#define thr_alarm_t thr_alarm_t_net
|
||||
#define ALARM ALARM_net
|
||||
#endif
|
||||
|
||||
typedef my_bool thr_alarm_t;
|
||||
typedef my_bool ALARM;
|
||||
#define thr_alarm_init(A) (*(A))=0
|
||||
#define thr_alarm_in_use(A) (*(A))
|
||||
#define thr_end_alarm(A)
|
||||
#define thr_alarm(A,B,C) local_thr_alarm((A),(B),(C))
|
||||
static inline int local_thr_alarm(my_bool *A,int B __attribute__((unused)),ALARM *C __attribute__((unused)))
|
||||
{
|
||||
*A=1;
|
||||
return 0;
|
||||
}
|
||||
#define thr_got_alarm(A) 0
|
||||
#define RETRY_COUNT 1
|
||||
#endif
|
||||
|
||||
#ifdef MYSQL_SERVER
|
||||
extern ulong bytes_sent, bytes_received;
|
||||
extern pthread_mutex_t LOCK_bytes_sent , LOCK_bytes_received;
|
||||
#else
|
||||
#undef statistic_add
|
||||
#define statistic_add(A,B,C)
|
||||
#endif
|
||||
|
||||
/*
|
||||
** Give error if a too big packet is found
|
||||
** The server can change this with the -O switch, but because the client
|
||||
** can't normally do this the client should have a bigger max-buffer.
|
||||
*/
|
||||
|
||||
#define TEST_BLOCKING 8
|
||||
static int net_write_buff(NET *net,const char *packet, size_t len);
|
||||
|
||||
|
||||
/* Init with packet info */
|
||||
|
||||
int my_net_init(NET *net, Vio* vio)
|
||||
{
|
||||
if (!(net->buff=(uchar*) my_malloc(net_buffer_length,MYF(MY_WME | MY_ZEROFILL))))
|
||||
return 1;
|
||||
max_allowed_packet= net->max_packet_size= MAX(net_buffer_length, max_allowed_packet);
|
||||
net->buff_end=net->buff+(net->max_packet=net_buffer_length);
|
||||
net->vio = vio;
|
||||
net->error=0; net->return_status=0;
|
||||
net->read_timeout=(uint) net_read_timeout; /* Timeout for read */
|
||||
net->compress_pkt_nr= net->pkt_nr= 0;
|
||||
net->write_pos=net->read_pos = net->buff;
|
||||
net->last_error[0]= net->sqlstate[0] =0;
|
||||
|
||||
net->compress=0; net->reading_or_writing=0;
|
||||
net->where_b = net->remain_in_buf=0;
|
||||
net->last_errno=0;
|
||||
|
||||
if (vio != 0) /* If real connection */
|
||||
{
|
||||
net->fd = vio_fd(vio); /* For perl DBI/DBD */
|
||||
#if defined(MYSQL_SERVER) && !defined(__WIN32) && !defined(__EMX__) && !defined(OS2)
|
||||
if (!(test_flags & TEST_BLOCKING))
|
||||
vio_blocking(vio, FALSE, 0);
|
||||
#endif
|
||||
vio_fastsend(vio);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void net_end(NET *net)
|
||||
{
|
||||
my_free(net->buff);
|
||||
net->buff=0;
|
||||
}
|
||||
|
||||
/* Realloc the packet buffer */
|
||||
|
||||
static my_bool net_realloc(NET *net, size_t length)
|
||||
{
|
||||
uchar *buff;
|
||||
size_t pkt_length;
|
||||
|
||||
DBUG_ENTER("net_realloc");
|
||||
DBUG_PRINT("info", ("length: %lu max_allowed_packet: %lu",
|
||||
(ulong)length, max_allowed_packet));
|
||||
|
||||
if (length >= net->max_packet_size)
|
||||
{
|
||||
DBUG_PRINT("error",("Packet too large (%lu)", length));
|
||||
net->error=1;
|
||||
net->last_errno=ER_NET_PACKET_TOO_LARGE;
|
||||
DBUG_RETURN(1);
|
||||
}
|
||||
pkt_length = (length+IO_SIZE-1) & ~(IO_SIZE-1);
|
||||
/* reallocate buffer:
|
||||
size= pkt_length + NET_HEADER_SIZE + COMP_HEADER_SIZE */
|
||||
if (!(buff=(uchar*) my_realloc((char*) net->buff,
|
||||
pkt_length + NET_HEADER_SIZE + COMP_HEADER_SIZE,
|
||||
MYF(MY_WME))))
|
||||
{
|
||||
DBUG_PRINT("info", ("Out of memory"));
|
||||
net->error=1;
|
||||
DBUG_RETURN(1);
|
||||
}
|
||||
net->buff=net->write_pos=buff;
|
||||
net->buff_end=buff+(net->max_packet=pkt_length);
|
||||
DBUG_RETURN(0);
|
||||
}
|
||||
|
||||
|
||||
/* check if the socket is still alive */
|
||||
static my_bool net_check_socket_status(my_socket sock)
|
||||
{
|
||||
#ifndef _WIN32
|
||||
struct pollfd poll_fd;
|
||||
#else
|
||||
FD_SET sfds;
|
||||
struct timeval tv= {0,0};
|
||||
#endif
|
||||
int res;
|
||||
#ifndef _WIN32
|
||||
memset(&poll_fd, 0, sizeof(struct pollfd));
|
||||
poll_fd.events= POLLPRI | POLLIN;
|
||||
poll_fd.fd= sock;
|
||||
|
||||
res= poll(&poll_fd, 1, 0);
|
||||
if (res <= 0) /* timeout or error */
|
||||
return FALSE;
|
||||
if (!(poll_fd.revents & (POLLIN | POLLPRI)))
|
||||
return FALSE;
|
||||
return TRUE;
|
||||
#else
|
||||
/* We can't use the WSAPoll function, it's broken :-(
|
||||
(see Windows 8 Bugs 309411 - WSAPoll does not report failed connections)
|
||||
Instead we need to use select function:
|
||||
If TIMEVAL is initialized to {0, 0}, select will return immediately;
|
||||
this is used to poll the state of the selected sockets.
|
||||
*/
|
||||
FD_ZERO(&sfds);
|
||||
FD_SET(sock, &sfds);
|
||||
|
||||
res= select(sock + 1, &sfds, NULL, NULL, &tv);
|
||||
if (res > 0 && FD_ISSET(sock, &sfds))
|
||||
return TRUE;
|
||||
return FALSE;
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
/* Remove unwanted characters from connection */
|
||||
|
||||
void net_clear(NET *net)
|
||||
{
|
||||
DBUG_ENTER("net_clear");
|
||||
|
||||
/* see conc-71: we need to check the socket status first:
|
||||
if the socket is dead we set net->error, so net_flush
|
||||
will report an error */
|
||||
while (net_check_socket_status(net->vio->sd))
|
||||
{
|
||||
/* vio_read returns size_t. so casting to long is required to check for -1 */
|
||||
if ((long)vio_read(net->vio, (gptr)net->buff, (size_t) net->max_packet) <= 0)
|
||||
{
|
||||
net->error= 2;
|
||||
DBUG_PRINT("info", ("socket disconnected"));
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
}
|
||||
net->compress_pkt_nr= net->pkt_nr=0; /* Ready for new command */
|
||||
net->write_pos=net->buff;
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
|
||||
|
||||
/* Flush write_buffer if not empty. */
|
||||
|
||||
int net_flush(NET *net)
|
||||
{
|
||||
int error=0;
|
||||
DBUG_ENTER("net_flush");
|
||||
if (net->buff != net->write_pos)
|
||||
{
|
||||
error=net_real_write(net,(char*) net->buff,
|
||||
(size_t) (net->write_pos - net->buff));
|
||||
net->write_pos=net->buff;
|
||||
}
|
||||
if (net->compress)
|
||||
net->pkt_nr= net->compress_pkt_nr;
|
||||
DBUG_RETURN(error);
|
||||
}
|
||||
|
||||
|
||||
/*****************************************************************************
|
||||
** Write something to server/client buffer
|
||||
*****************************************************************************/
|
||||
|
||||
|
||||
/*
|
||||
** Write a logical packet with packet header
|
||||
** Format: Packet length (3 bytes), packet number(1 byte)
|
||||
** When compression is used a 3 byte compression length is added
|
||||
** NOTE: If compression is used the original package is destroyed!
|
||||
*/
|
||||
|
||||
int
|
||||
my_net_write(NET *net, const char *packet, size_t len)
|
||||
{
|
||||
uchar buff[NET_HEADER_SIZE];
|
||||
while (len >= MAX_PACKET_LENGTH)
|
||||
{
|
||||
const ulong max_len= MAX_PACKET_LENGTH;
|
||||
int3store(buff,max_len);
|
||||
buff[3]= (uchar)net->pkt_nr++;
|
||||
if (net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
|
||||
net_write_buff(net, packet, max_len))
|
||||
return 1;
|
||||
packet+= max_len;
|
||||
len-= max_len;
|
||||
}
|
||||
/* write last remaining packet, size can be zero */
|
||||
int3store(buff, len);
|
||||
buff[3]= (uchar)net->pkt_nr++;
|
||||
if (net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
|
||||
net_write_buff(net, packet, len))
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
net_write_command(NET *net, uchar command,
|
||||
const char *packet, size_t len)
|
||||
{
|
||||
uchar buff[NET_HEADER_SIZE+1];
|
||||
size_t buff_size= NET_HEADER_SIZE + 1;
|
||||
size_t length= 1 + len; /* 1 extra byte for command */
|
||||
int rc;
|
||||
|
||||
buff[NET_HEADER_SIZE]= 0;
|
||||
buff[4]=command;
|
||||
|
||||
if (length >= MAX_PACKET_LENGTH)
|
||||
{
|
||||
len= MAX_PACKET_LENGTH - 1;
|
||||
do
|
||||
{
|
||||
int3store(buff, MAX_PACKET_LENGTH);
|
||||
buff[3]= (net->compress) ? 0 : (uchar) (net->pkt_nr++);
|
||||
|
||||
if (net_write_buff(net, (char *)buff, buff_size) ||
|
||||
net_write_buff(net, packet, len))
|
||||
return(1);
|
||||
packet+= len;
|
||||
length-= MAX_PACKET_LENGTH;
|
||||
len= MAX_PACKET_LENGTH;
|
||||
buff_size= NET_HEADER_SIZE; /* don't send command for further packets */
|
||||
} while (length >= MAX_PACKET_LENGTH);
|
||||
len= length;
|
||||
}
|
||||
int3store(buff,length);
|
||||
buff[3]= (net->compress) ? 0 : (uchar) (net->pkt_nr++);
|
||||
rc= test (net_write_buff(net,(char *)buff, buff_size) ||
|
||||
net_write_buff(net,packet,len) ||
|
||||
net_flush(net));
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
net_write_buff(NET *net,const char *packet, size_t len)
|
||||
{
|
||||
size_t left_length;
|
||||
|
||||
if (net->max_packet > MAX_PACKET_LENGTH &&
|
||||
net->compress)
|
||||
left_length= (size_t)(MAX_PACKET_LENGTH - (net->write_pos - net->buff));
|
||||
else
|
||||
left_length=(size_t) (net->buff_end - net->write_pos);
|
||||
|
||||
if (len > left_length)
|
||||
{
|
||||
if (net->write_pos != net->buff)
|
||||
{
|
||||
memcpy((char*) net->write_pos,packet,left_length);
|
||||
if (net_real_write(net,(char*) net->buff,
|
||||
(size_t)(net->write_pos - net->buff) + left_length))
|
||||
return 1;
|
||||
packet+=left_length;
|
||||
len-=left_length;
|
||||
net->write_pos= net->buff;
|
||||
}
|
||||
if (net->compress)
|
||||
{
|
||||
/* uncompressed length is stored in 3 bytes,so
|
||||
packet can't be > 0xFFFFFF */
|
||||
left_length= MAX_PACKET_LENGTH;
|
||||
while (len > left_length)
|
||||
{
|
||||
if (net_real_write(net, packet, left_length))
|
||||
return 1;
|
||||
packet+= left_length;
|
||||
len-= left_length;
|
||||
}
|
||||
}
|
||||
if (len > net->max_packet)
|
||||
return(test(net_real_write(net, packet, len)));
|
||||
}
|
||||
memcpy((char*) net->write_pos,packet,len);
|
||||
net->write_pos+=len;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Read and write using timeouts */
|
||||
|
||||
int
|
||||
net_real_write(NET *net,const char *packet,size_t len)
|
||||
{
|
||||
size_t length;
|
||||
char *pos,*end;
|
||||
thr_alarm_t alarmed;
|
||||
#if !defined(_WIN32) && !defined(__EMX__) && !defined(OS2)
|
||||
ALARM alarm_buff;
|
||||
#endif
|
||||
uint retry_count=0;
|
||||
my_bool net_blocking = vio_is_blocking(net->vio);
|
||||
DBUG_ENTER("net_real_write");
|
||||
|
||||
if (net->error == 2)
|
||||
DBUG_RETURN(-1); /* socket can't be used */
|
||||
|
||||
net->reading_or_writing=2;
|
||||
#ifdef HAVE_COMPRESS
|
||||
if (net->compress)
|
||||
{
|
||||
size_t complen;
|
||||
uchar *b;
|
||||
uint header_length=NET_HEADER_SIZE+COMP_HEADER_SIZE;
|
||||
if (!(b=(uchar*) my_malloc(len + NET_HEADER_SIZE + COMP_HEADER_SIZE + 1,
|
||||
MYF(MY_WME))))
|
||||
{
|
||||
net->last_errno=ER_OUT_OF_RESOURCES;
|
||||
net->error=2;
|
||||
net->reading_or_writing=0;
|
||||
DBUG_RETURN(1);
|
||||
}
|
||||
memcpy(b+header_length,packet,len);
|
||||
|
||||
if (my_compress((unsigned char*) b+header_length,&len,&complen))
|
||||
{
|
||||
DBUG_PRINT("warning",
|
||||
("Compression error; Continuing without compression"));
|
||||
complen=0;
|
||||
}
|
||||
int3store(&b[NET_HEADER_SIZE],complen);
|
||||
int3store(b,len);
|
||||
b[3]=(uchar) (net->compress_pkt_nr++);
|
||||
len+= header_length;
|
||||
packet= (char*) b;
|
||||
}
|
||||
#endif /* HAVE_COMPRESS */
|
||||
|
||||
alarmed=0;
|
||||
|
||||
pos=(char*) packet; end=pos+len;
|
||||
while (pos != end)
|
||||
{
|
||||
if ((long) (length=vio_write(net->vio,pos,(size_t) (end-pos))) <= 0)
|
||||
{
|
||||
my_bool interrupted = vio_should_retry(net->vio);
|
||||
#if (!defined(_WIN32) && !defined(__EMX__) && !defined(OS2))
|
||||
if ((interrupted || length==0) && !thr_alarm_in_use(&alarmed))
|
||||
{
|
||||
if (!thr_alarm(&alarmed,(uint) net_write_timeout,&alarm_buff))
|
||||
{ /* Always true for client */
|
||||
if (!vio_is_blocking(net->vio))
|
||||
{
|
||||
while (vio_blocking(net->vio, TRUE, 0) < 0)
|
||||
{
|
||||
if (vio_should_retry(net->vio) && retry_count++ < RETRY_COUNT)
|
||||
continue;
|
||||
#ifdef EXTRA_DEBUG
|
||||
fprintf(stderr,
|
||||
"%s: my_net_write: fcntl returned error %d, aborting thread\n",
|
||||
my_progname,vio_errno(net->vio));
|
||||
#endif /* EXTRA_DEBUG */
|
||||
net->error=2; /* Close socket */
|
||||
net->last_errno= (interrupted ?
|
||||
ER_NET_WRITE_INTERRUPTED : ER_NET_ERROR_ON_WRITE);
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
retry_count=0;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif /* (!defined(_WIN32) && !defined(__EMX__)) */
|
||||
if (thr_alarm_in_use(&alarmed) && !thr_got_alarm(&alarmed) &&
|
||||
interrupted)
|
||||
{
|
||||
if (retry_count++ < RETRY_COUNT)
|
||||
continue;
|
||||
#ifdef EXTRA_DEBUG
|
||||
fprintf(stderr, "%s: write looped, aborting thread\n",
|
||||
my_progname);
|
||||
#endif /* EXTRA_DEBUG */
|
||||
}
|
||||
#if defined(THREAD_SAFE_CLIENT) && !defined(MYSQL_SERVER)
|
||||
if (vio_errno(net->vio) == SOCKET_EINTR)
|
||||
{
|
||||
DBUG_PRINT("warning",("Interrupted write. Retrying..."));
|
||||
continue;
|
||||
}
|
||||
#endif /* defined(THREAD_SAFE_CLIENT) && !defined(MYSQL_SERVER) */
|
||||
net->error=2; /* Close socket */
|
||||
net->last_errno= (interrupted ? ER_NET_WRITE_INTERRUPTED :
|
||||
ER_NET_ERROR_ON_WRITE);
|
||||
break;
|
||||
}
|
||||
pos+=length;
|
||||
statistic_add(bytes_sent,length,&LOCK_bytes_sent);
|
||||
}
|
||||
#ifndef _WIN32
|
||||
end:
|
||||
#endif
|
||||
#ifdef HAVE_COMPRESS
|
||||
if (net->compress)
|
||||
my_free((void *)packet);
|
||||
#endif
|
||||
if (thr_alarm_in_use(&alarmed))
|
||||
{
|
||||
thr_end_alarm(&alarmed);
|
||||
vio_blocking(net->vio, net_blocking, 0);
|
||||
}
|
||||
net->reading_or_writing=0;
|
||||
DBUG_RETURN(((int) (pos != end)));
|
||||
}
|
||||
|
||||
|
||||
/*****************************************************************************
|
||||
** Read something from server/clinet
|
||||
*****************************************************************************/
|
||||
|
||||
#ifdef MYSQL_SERVER
|
||||
|
||||
/*
|
||||
Help function to clear the commuication buffer when we get a too
|
||||
big packet
|
||||
*/
|
||||
|
||||
static void my_net_skip_rest(NET *net, ulong remain, thr_alarm_t *alarmed,
|
||||
ALARM *alarm_buff)
|
||||
{
|
||||
uint retry_count=0;
|
||||
if (!thr_alarm_in_use(alarmed))
|
||||
{
|
||||
if (thr_alarm(alarmed,net->timeout,alarm_buff) ||
|
||||
(!vio_is_blocking(net->vio) && vio_blocking(net->vio,TRUE, 0) < 0))
|
||||
return; /* Can't setup, abort */
|
||||
}
|
||||
while (remain > 0)
|
||||
{
|
||||
ulong length;
|
||||
if ((int) (length=vio_read(net->vio,(char*) net->buff,remain)) <= 0L)
|
||||
{
|
||||
my_bool interrupted = vio_should_retry(net->vio);
|
||||
if (!thr_got_alarm(alarmed) && interrupted)
|
||||
{ /* Probably in MIT threads */
|
||||
if (retry_count++ < RETRY_COUNT)
|
||||
continue;
|
||||
}
|
||||
return;
|
||||
}
|
||||
remain -=(ulong) length;
|
||||
statistic_add(bytes_received,(ulong) length,&LOCK_bytes_received);
|
||||
}
|
||||
}
|
||||
#endif /* MYSQL_SERVER */
|
||||
|
||||
|
||||
static ulong
|
||||
my_real_read(NET *net, size_t *complen)
|
||||
{
|
||||
uchar *pos;
|
||||
size_t length;
|
||||
uint i,retry_count=0;
|
||||
ulong len=packet_error;
|
||||
thr_alarm_t alarmed;
|
||||
#if (!defined(_WIN32) && !defined(__EMX__) && !defined(OS2)) || defined(MYSQL_SERVER)
|
||||
ALARM alarm_buff;
|
||||
#endif
|
||||
my_bool net_blocking=vio_is_blocking(net->vio);
|
||||
size_t remain= (net->compress ? NET_HEADER_SIZE+COMP_HEADER_SIZE :
|
||||
NET_HEADER_SIZE);
|
||||
*complen = 0;
|
||||
|
||||
net->reading_or_writing=1;
|
||||
thr_alarm_init(&alarmed);
|
||||
#ifdef MYSQL_SERVER
|
||||
if (net_blocking)
|
||||
thr_alarm(&alarmed,net->timeout,&alarm_buff);
|
||||
#endif /* MYSQL_SERVER */
|
||||
|
||||
pos = net->buff + net->where_b; /* net->packet -4 */
|
||||
for (i=0 ; i < 2 ; i++)
|
||||
{
|
||||
while (remain > 0)
|
||||
{
|
||||
/* First read is done with non blocking mode */
|
||||
if ((long) (length=vio_read(net->vio,(char*) pos,remain)) <= 0L)
|
||||
{
|
||||
my_bool interrupted = vio_should_retry(net->vio);
|
||||
|
||||
DBUG_PRINT("info",("vio_read returned %d, errno: %d",
|
||||
length, vio_errno(net->vio)));
|
||||
#if (!defined(_WIN32) && !defined(__EMX__) && !defined(OS2)) || defined(MYSQL_SERVER)
|
||||
/*
|
||||
We got an error that there was no data on the socket. We now set up
|
||||
an alarm to not 'read forever', change the socket to non blocking
|
||||
mode and try again
|
||||
*/
|
||||
if ((interrupted || length == 0) && !thr_alarm_in_use(&alarmed))
|
||||
{
|
||||
if (!thr_alarm(&alarmed,net->read_timeout,&alarm_buff)) /* Don't wait too long */
|
||||
{
|
||||
if (!vio_is_blocking(net->vio))
|
||||
{
|
||||
while (vio_blocking(net->vio,TRUE, 0) < 0)
|
||||
{
|
||||
if (vio_should_retry(net->vio) &&
|
||||
retry_count++ < RETRY_COUNT)
|
||||
continue;
|
||||
DBUG_PRINT("error",
|
||||
("fcntl returned error %d, aborting thread",
|
||||
vio_errno(net->vio)));
|
||||
#ifdef EXTRA_DEBUG
|
||||
fprintf(stderr,
|
||||
"%s: read: fcntl returned error %d, aborting thread\n",
|
||||
my_progname,vio_errno(net->vio));
|
||||
#endif /* EXTRA_DEBUG */
|
||||
len= packet_error;
|
||||
net->error=2; /* Close socket */
|
||||
#ifdef MYSQL_SERVER
|
||||
net->last_errno=ER_NET_FCNTL_ERROR;
|
||||
#endif
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
retry_count=0;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
#endif /* (!defined(_WIN32) && !defined(__EMX__)) || defined(MYSQL_SERVER) */
|
||||
if (thr_alarm_in_use(&alarmed) && !thr_got_alarm(&alarmed) &&
|
||||
interrupted)
|
||||
{ /* Probably in MIT threads */
|
||||
if (retry_count++ < RETRY_COUNT)
|
||||
continue;
|
||||
#ifdef EXTRA_DEBUG
|
||||
fprintf(stderr, "%s: read looped with error %d, aborting thread\n",
|
||||
my_progname,vio_errno(net->vio));
|
||||
#endif /* EXTRA_DEBUG */
|
||||
}
|
||||
#if defined(THREAD_SAFE_CLIENT) && !defined(MYSQL_SERVER)
|
||||
if (vio_should_retry(net->vio))
|
||||
{
|
||||
DBUG_PRINT("warning",("Interrupted read. Retrying..."));
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
DBUG_PRINT("error",("Couldn't read packet: remain: %d errno: %d length: %d alarmed: %d", remain,vio_errno(net->vio),length,alarmed));
|
||||
len= packet_error;
|
||||
net->error=2; /* Close socket */
|
||||
goto end;
|
||||
}
|
||||
remain -= (ulong) length;
|
||||
pos+= (ulong) length;
|
||||
statistic_add(bytes_received,(ulong) length,&LOCK_bytes_received);
|
||||
}
|
||||
if (i == 0)
|
||||
{ /* First parts is packet length */
|
||||
ulong helping;
|
||||
if (net->buff[net->where_b + 3] != (uchar) net->pkt_nr)
|
||||
{
|
||||
if (net->buff[net->where_b] != (uchar) 255)
|
||||
{
|
||||
DBUG_PRINT("error",
|
||||
("Packets out of order (Found: %d, expected %d)",
|
||||
(int) net->buff[net->where_b + 3],
|
||||
(uint) (uchar) net->pkt_nr));
|
||||
#ifdef EXTRA_DEBUG
|
||||
fprintf(stderr,"Packets out of order (Found: %d, expected %d)\n",
|
||||
(int) net->buff[net->where_b + 3],
|
||||
(uint) (uchar) net->pkt_nr);
|
||||
#endif
|
||||
}
|
||||
len= packet_error;
|
||||
#ifdef MYSQL_SERVER
|
||||
net->last_errno=ER_NET_PACKETS_OUT_OF_ORDER;
|
||||
#endif
|
||||
goto end;
|
||||
}
|
||||
net->compress_pkt_nr= ++net->pkt_nr;
|
||||
#ifdef HAVE_COMPRESS
|
||||
if (net->compress)
|
||||
{
|
||||
/* complen is > 0 if package is really compressed */
|
||||
*complen=uint3korr(&(net->buff[net->where_b + NET_HEADER_SIZE]));
|
||||
}
|
||||
#endif
|
||||
|
||||
len=uint3korr(net->buff+net->where_b);
|
||||
if (!len)
|
||||
goto end;
|
||||
helping = max(len,(ulong)*complen) + net->where_b;
|
||||
/* The necessary size of net->buff */
|
||||
if (helping >= net->max_packet)
|
||||
{
|
||||
if (net_realloc(net,helping))
|
||||
{
|
||||
#ifdef MYSQL_SERVER
|
||||
if (i == 1)
|
||||
my_net_skip_rest(net, len, &alarmed, &alarm_buff);
|
||||
#endif
|
||||
len= packet_error; /* Return error */
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
pos=net->buff + net->where_b;
|
||||
remain = len;
|
||||
}
|
||||
}
|
||||
|
||||
end:
|
||||
if (thr_alarm_in_use(&alarmed))
|
||||
{
|
||||
thr_end_alarm(&alarmed);
|
||||
vio_blocking(net->vio, net_blocking, 0);
|
||||
}
|
||||
net->reading_or_writing=0;
|
||||
return(len);
|
||||
}
|
||||
|
||||
ulong my_net_read(NET *net)
|
||||
{
|
||||
size_t len,complen;
|
||||
|
||||
#ifdef HAVE_COMPRESS
|
||||
if (!net->compress)
|
||||
{
|
||||
#endif
|
||||
len = my_real_read (net,(size_t *)&complen);
|
||||
if (len == MAX_PACKET_LENGTH)
|
||||
{
|
||||
/* multi packet read */
|
||||
size_t length= 0;
|
||||
ulong last_pos= net->where_b;
|
||||
|
||||
do
|
||||
{
|
||||
length+= len;
|
||||
net->where_b+= (unsigned long)len;
|
||||
len= my_real_read(net, &complen);
|
||||
} while (len == MAX_PACKET_LENGTH);
|
||||
net->where_b= last_pos;
|
||||
if (len != packet_error)
|
||||
len+= length;
|
||||
}
|
||||
net->read_pos = net->buff + net->where_b;
|
||||
if (len != packet_error)
|
||||
net->read_pos[len]=0; /* Safeguard for mysql_use_result */
|
||||
return (ulong)len;
|
||||
#ifdef HAVE_COMPRESS
|
||||
}
|
||||
else
|
||||
{
|
||||
/*
|
||||
compressed protocol:
|
||||
|
||||
--------------------------------------
|
||||
packet_lengt h 3
|
||||
sequence_id 1
|
||||
uncompressed_length 3
|
||||
--------------------------------------
|
||||
compressed data packet_length - 7
|
||||
--------------------------------------
|
||||
|
||||
Another packet will follow if:
|
||||
packet_length == MAX_PACKET_LENGTH
|
||||
|
||||
Last package will be identified by
|
||||
- packet_length is zero (special case)
|
||||
- packet_length < MAX_PACKET_LENGTH
|
||||
*/
|
||||
|
||||
size_t packet_length,
|
||||
buffer_length;
|
||||
size_t current= 0, start= 0;
|
||||
my_bool is_multi_packet= 0;
|
||||
|
||||
/* check if buffer is empty */
|
||||
if (!net->remain_in_buf)
|
||||
{
|
||||
buffer_length= 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* save position and restore \0 character */
|
||||
buffer_length= net->buf_length;
|
||||
current= net->buf_length - net->remain_in_buf;
|
||||
start= current;
|
||||
net->buff[net->buf_length - net->remain_in_buf]=net->save_char;
|
||||
}
|
||||
for (;;)
|
||||
{
|
||||
if (buffer_length - current >= 4)
|
||||
{
|
||||
uchar *pos= net->buff + current;
|
||||
packet_length= uint3korr(pos);
|
||||
|
||||
/* check if we have last package (special case: zero length) */
|
||||
if (!packet_length)
|
||||
{
|
||||
current+= 4; /* length + sequence_id,
|
||||
no more data will follow */
|
||||
break;
|
||||
}
|
||||
if (packet_length + 4 <= buffer_length - current)
|
||||
{
|
||||
if (!is_multi_packet)
|
||||
{
|
||||
current= current + packet_length + 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* remove packet_header */
|
||||
memmove(net->buff + current,
|
||||
net->buff + current + 4,
|
||||
buffer_length - current);
|
||||
buffer_length-= 4;
|
||||
current+= packet_length;
|
||||
}
|
||||
/* do we have last packet ? */
|
||||
if (packet_length != MAX_PACKET_LENGTH)
|
||||
{
|
||||
is_multi_packet= 0;
|
||||
break;
|
||||
}
|
||||
else
|
||||
is_multi_packet= 1;
|
||||
if (start)
|
||||
{
|
||||
memmove(net->buff, net->buff + start,
|
||||
buffer_length - start);
|
||||
/* decrease buflen*/
|
||||
buffer_length-= start;
|
||||
start= 0;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (start)
|
||||
{
|
||||
memmove(net->buff, net->buff + start, buffer_length - start);
|
||||
/* decrease buflen and current */
|
||||
current -= start;
|
||||
buffer_length-= start;
|
||||
start= 0;
|
||||
}
|
||||
|
||||
net->where_b=buffer_length;
|
||||
|
||||
if ((packet_length = my_real_read(net,(size_t *)&complen)) == packet_error)
|
||||
return packet_error;
|
||||
if (my_uncompress((unsigned char*) net->buff + net->where_b, &packet_length, &complen))
|
||||
{
|
||||
len= packet_error;
|
||||
net->error=2; /* caller will close socket */
|
||||
net->last_errno=ER_NET_UNCOMPRESS_ERROR;
|
||||
break;
|
||||
return packet_error;
|
||||
}
|
||||
buffer_length+= complen;
|
||||
}
|
||||
/* set values */
|
||||
net->buf_length= buffer_length;
|
||||
net->remain_in_buf= buffer_length - current;
|
||||
net->read_pos= net->buff + start + 4;
|
||||
len= current - start - 4;
|
||||
if (is_multi_packet)
|
||||
len-= 4;
|
||||
net->save_char= net->read_pos[len]; /* Must be saved */
|
||||
net->read_pos[len]=0; /* Safeguard for mysql_use_result */
|
||||
}
|
||||
#endif
|
||||
return (ulong)len;
|
||||
}
|
Reference in New Issue
Block a user