mirror of
https://github.com/MariaDB/server.git
synced 2025-01-16 20:12:31 +01:00
0e6975f33b
in net_printf(), we fill net->last_* variables for the slave SQL thread to know the error. sql/net_pkg.cc: in net_printf(), store the error in net->last_*, so that slave SQL thread can be aware there was an error reported by net_printf() (which is what yacc uses for "you have an error in your syntax").
407 lines
10 KiB
C++
407 lines
10 KiB
C++
/* Copyright (C) 2000-2003 MySQL AB
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
|
|
|
|
|
#include "mysql_priv.h"
|
|
#include <stdarg.h>
|
|
|
|
/* Send a error string to client */
|
|
|
|
void send_error(NET *net, uint sql_errno, const char *err)
|
|
{
|
|
uint length;
|
|
char buff[MYSQL_ERRMSG_SIZE+2];
|
|
THD *thd=current_thd;
|
|
DBUG_ENTER("send_error");
|
|
DBUG_PRINT("enter",("sql_errno: %d err: %s", sql_errno,
|
|
err ? err : net->last_error[0] ?
|
|
net->last_error : "NULL"));
|
|
|
|
query_cache_abort(net);
|
|
if (thd)
|
|
thd->query_error = 1; // needed to catch query errors during replication
|
|
if (!err)
|
|
{
|
|
if (sql_errno)
|
|
err=ER(sql_errno);
|
|
else
|
|
{
|
|
if ((err=net->last_error)[0])
|
|
sql_errno=net->last_errno;
|
|
else
|
|
{
|
|
sql_errno=ER_UNKNOWN_ERROR;
|
|
err=ER(sql_errno); /* purecov: inspected */
|
|
}
|
|
}
|
|
}
|
|
if (net->vio == 0)
|
|
{
|
|
if (thd && thd->bootstrap)
|
|
{
|
|
/* In bootstrap it's ok to print on stderr */
|
|
fprintf(stderr,"ERROR: %d %s\n",sql_errno,err);
|
|
}
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
if (net->return_errno)
|
|
{ // new client code; Add errno before message
|
|
int2store(buff,sql_errno);
|
|
length= (uint) (strmake(buff+2,err,MYSQL_ERRMSG_SIZE-1) - buff);
|
|
err=buff;
|
|
}
|
|
else
|
|
{
|
|
length=(uint) strlen(err);
|
|
set_if_smaller(length,MYSQL_ERRMSG_SIZE);
|
|
}
|
|
VOID(net_write_command(net,(uchar) 255,(char*) err,length));
|
|
if (thd)
|
|
thd->fatal_error=0; // Error message is given
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
/*
|
|
At some point we need to be able to distinguish between warnings and
|
|
errors; The following function will help make this easier.
|
|
*/
|
|
|
|
void send_warning(NET *net, uint sql_errno, const char *err)
|
|
{
|
|
DBUG_ENTER("send_warning");
|
|
send_error(net,sql_errno,err);
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
|
|
/*
|
|
Write error package and flush to client
|
|
It's a little too low level, but I don't want to allow another buffer
|
|
*/
|
|
/* VARARGS3 */
|
|
|
|
void
|
|
net_printf(NET *net, uint errcode, ...)
|
|
{
|
|
va_list args;
|
|
uint length,offset;
|
|
const char *format,*text_pos;
|
|
int head_length= NET_HEADER_SIZE;
|
|
THD *thd=current_thd;
|
|
DBUG_ENTER("net_printf");
|
|
DBUG_PRINT("enter",("message: %u",errcode));
|
|
|
|
if (thd)
|
|
thd->query_error = 1; // if we are here, something is wrong :-)
|
|
query_cache_abort(net); // Safety
|
|
va_start(args,errcode);
|
|
/*
|
|
The following is needed to make net_printf() work with 0 argument for
|
|
errorcode and use the argument after that as the format string. This
|
|
is useful for rare errors that are not worth the hassle to put in
|
|
errmsg.sys, but at the same time, the message is not fixed text
|
|
*/
|
|
if (errcode)
|
|
format= ER(errcode);
|
|
else
|
|
{
|
|
format=va_arg(args,char*);
|
|
errcode= ER_UNKNOWN_ERROR;
|
|
}
|
|
offset= net->return_errno ? 2 : 0;
|
|
text_pos=(char*) net->buff+head_length+offset+1;
|
|
(void) my_vsnprintf(my_const_cast(char*) (text_pos),
|
|
(char*)net->buff_end-text_pos,
|
|
format,args);
|
|
length=(uint) strlen((char*) text_pos);
|
|
if (length >= sizeof(net->last_error))
|
|
length=sizeof(net->last_error)-1; /* purecov: inspected */
|
|
va_end(args);
|
|
|
|
/* Replication slave relies on net->last_* to see if there was error */
|
|
net->last_errno= errcode;
|
|
strmake(net->last_error, text_pos, sizeof(net->last_error)-1);
|
|
|
|
if (net->vio == 0)
|
|
{
|
|
if (thd && thd->bootstrap)
|
|
{
|
|
/*
|
|
In bootstrap it's ok to print on stderr
|
|
This may also happen when we get an error from a slave thread
|
|
*/
|
|
fprintf(stderr,"ERROR: %d %s\n",errcode,text_pos);
|
|
thd->fatal_error=1;
|
|
}
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
int3store(net->buff,length+1+offset);
|
|
net->buff[3]= (net->compress) ? 0 : (uchar) (net->pkt_nr++);
|
|
net->buff[head_length]=(uchar) 255; // Error package
|
|
if (offset)
|
|
int2store(text_pos-2, errcode);
|
|
VOID(net_real_write(net,(char*) net->buff,length+head_length+1+offset));
|
|
if (thd)
|
|
thd->fatal_error=0; // Error message is given
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
|
|
void
|
|
send_ok(NET *net,ha_rows affected_rows,ulonglong id,const char *message)
|
|
{
|
|
if (net->no_send_ok) // hack for re-parsing queries
|
|
return;
|
|
|
|
char buff[MYSQL_ERRMSG_SIZE+10],*pos;
|
|
DBUG_ENTER("send_ok");
|
|
buff[0]=0; // No fields
|
|
pos=net_store_length(buff+1,(ulonglong) affected_rows);
|
|
pos=net_store_length(pos, (ulonglong) id);
|
|
if (net->return_status)
|
|
{
|
|
int2store(pos,*net->return_status);
|
|
pos+=2;
|
|
}
|
|
if (message)
|
|
pos=net_store_data((char*) pos,message);
|
|
if (net->vio != 0)
|
|
{
|
|
VOID(my_net_write(net,buff,(uint) (pos-buff)));
|
|
VOID(net_flush(net));
|
|
}
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
void
|
|
send_eof(NET *net,bool no_flush)
|
|
{
|
|
static char eof_buff[1]= { (char) 254 }; /* Marker for end of fields */
|
|
DBUG_ENTER("send_eof");
|
|
if (net->vio != 0)
|
|
{
|
|
VOID(my_net_write(net,eof_buff,1));
|
|
if (!no_flush)
|
|
VOID(net_flush(net));
|
|
}
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
** Store a field length in logical packet
|
|
****************************************************************************/
|
|
|
|
char *
|
|
net_store_length(char *pkg, ulonglong length)
|
|
{
|
|
uchar *packet=(uchar*) pkg;
|
|
if (length < LL(251))
|
|
{
|
|
*packet=(uchar) length;
|
|
return (char*) packet+1;
|
|
}
|
|
/* 251 is reserved for NULL */
|
|
if (length < LL(65536))
|
|
{
|
|
*packet++=252;
|
|
int2store(packet,(uint) length);
|
|
return (char*) packet+2;
|
|
}
|
|
if (length < LL(16777216))
|
|
{
|
|
*packet++=253;
|
|
int3store(packet,(ulong) length);
|
|
return (char*) packet+3;
|
|
}
|
|
*packet++=254;
|
|
int8store(packet,length);
|
|
return (char*) packet+8;
|
|
}
|
|
|
|
char *
|
|
net_store_length(char *pkg, uint length)
|
|
{
|
|
uchar *packet=(uchar*) pkg;
|
|
if (length < 251)
|
|
{
|
|
*packet=(uchar) length;
|
|
return (char*) packet+1;
|
|
}
|
|
*packet++=252;
|
|
int2store(packet,(uint) length);
|
|
return (char*) packet+2;
|
|
}
|
|
|
|
/* The following will only be used for short strings < 65K */
|
|
char *
|
|
net_store_data(char *to,const char *from)
|
|
{
|
|
uint length=(uint) strlen(from);
|
|
to=net_store_length(to,length);
|
|
memcpy(to,from,length);
|
|
return to+length;
|
|
}
|
|
|
|
|
|
char *
|
|
net_store_data(char *to,int32 from)
|
|
{
|
|
char buff[20];
|
|
uint length=(uint) (int10_to_str(from,buff,10)-buff);
|
|
to=net_store_length(to,length);
|
|
memcpy(to,buff,length);
|
|
return to+length;
|
|
}
|
|
|
|
char *
|
|
net_store_data(char *to,longlong from)
|
|
{
|
|
char buff[22];
|
|
uint length=(uint) (longlong10_to_str(from,buff,10)-buff);
|
|
to=net_store_length(to,length);
|
|
memcpy(to,buff,length);
|
|
return to+length;
|
|
}
|
|
|
|
|
|
bool net_store_null(String *packet)
|
|
{
|
|
return packet->append((char) 251);
|
|
}
|
|
|
|
bool
|
|
net_store_data(String *packet,const char *from,uint length)
|
|
{
|
|
ulong packet_length=packet->length();
|
|
if (packet_length+9+length > packet->alloced_length() &&
|
|
packet->realloc(packet_length+9+length))
|
|
return 1;
|
|
char *to=(char*) net_store_length((char*) packet->ptr()+packet_length,
|
|
(ulonglong) length);
|
|
memcpy(to,from,length);
|
|
packet->length((uint) (to+length-packet->ptr()));
|
|
return 0;
|
|
}
|
|
|
|
/* The following is only used at short, null terminated data */
|
|
|
|
bool
|
|
net_store_data(String *packet,const char *from)
|
|
{
|
|
uint length=(uint) strlen(from);
|
|
uint packet_length=packet->length();
|
|
/*
|
|
3 is the longest coding for storing a string with the used
|
|
net_store_length() function. We use 5 here 'just in case'
|
|
*/
|
|
if (packet_length+5+length > packet->alloced_length() &&
|
|
packet->realloc(packet_length+5+length))
|
|
return 1;
|
|
char *to=(char*) net_store_length((char*) packet->ptr()+packet_length,
|
|
length);
|
|
memcpy(to,from,length);
|
|
packet->length((uint) (to+length-packet->ptr()));
|
|
return 0;
|
|
}
|
|
|
|
|
|
bool
|
|
net_store_data(String *packet,uint32 from)
|
|
{
|
|
char buff[20];
|
|
return net_store_data(packet,(char*) buff,
|
|
(uint) (int10_to_str(from,buff,10)-buff));
|
|
}
|
|
|
|
bool
|
|
net_store_data(String *packet, longlong from)
|
|
{
|
|
char buff[22];
|
|
return net_store_data(packet,(char*) buff,
|
|
(uint) (longlong10_to_str(from,buff,10)-buff));
|
|
}
|
|
|
|
bool
|
|
net_store_data(String *packet,struct tm *tmp)
|
|
{
|
|
char buff[20];
|
|
sprintf(buff,"%04d-%02d-%02d %02d:%02d:%02d",
|
|
((int) (tmp->tm_year+1900)) % 10000,
|
|
(int) tmp->tm_mon+1,
|
|
(int) tmp->tm_mday,
|
|
(int) tmp->tm_hour,
|
|
(int) tmp->tm_min,
|
|
(int) tmp->tm_sec);
|
|
return net_store_data(packet,(char*) buff,19);
|
|
}
|
|
|
|
bool net_store_data(String* packet, I_List<i_string>* str_list)
|
|
{
|
|
char buf[256];
|
|
String tmp(buf, sizeof(buf));
|
|
tmp.length(0);
|
|
I_List_iterator<i_string> it(*str_list);
|
|
i_string* s;
|
|
|
|
while ((s=it++))
|
|
{
|
|
if (tmp.length())
|
|
tmp.append(',');
|
|
tmp.append(s->ptr);
|
|
}
|
|
|
|
return net_store_data(packet, (char*)tmp.ptr(), tmp.length());
|
|
}
|
|
|
|
/*
|
|
** translate and store data; These are mainly used by the SHOW functions
|
|
*/
|
|
|
|
bool
|
|
net_store_data(String *packet,CONVERT *convert, const char *from,uint length)
|
|
{
|
|
if (convert)
|
|
return convert->store(packet, from, length);
|
|
return net_store_data(packet,from,length);
|
|
}
|
|
|
|
bool
|
|
net_store_data(String *packet, CONVERT *convert, const char *from)
|
|
{
|
|
uint length=(uint) strlen(from);
|
|
if (convert)
|
|
return convert->store(packet, from, length);
|
|
return net_store_data(packet,from,length);
|
|
}
|
|
|
|
/*
|
|
Function called by my_net_init() to set some check variables
|
|
*/
|
|
|
|
extern "C" {
|
|
void my_net_local_init(NET *net)
|
|
{
|
|
net->max_packet= (uint) global_system_variables.net_buffer_length;
|
|
net->read_timeout= (uint) global_system_variables.net_read_timeout;
|
|
net->write_timeout=(uint) global_system_variables.net_write_timeout;
|
|
net->retry_count= (uint) global_system_variables.net_retry_count;
|
|
net->max_packet_size= max(global_system_variables.net_buffer_length,
|
|
global_system_variables.max_allowed_packet);
|
|
}
|
|
}
|