1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

changed manager to use my_net_*

Browse Source 
fixed bug in master - unregister slaves when they disconnect
This commit is contained in:
sasha@mysql.sashanet.com 2001-10-12 09:37:25 -06:00
parent 2f27322adb
commit 2d3f96b483
8 changed files with 120 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
client/mysqlmanagerc.c
View File

@ -14,7 +14,7 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#define MANAGER_CLIENT_VERSION "1.0"
#define MANAGER_CLIENT_VERSION "1.1"
#include <my_global.h>
#include <mysql.h>
@ -28,7 +28,7 @@
#include <unistd.h>
#ifndef MYSQL_MANAGER_PORT
#define MYSQL_MANAGER_PORT 23546
#define MYSQL_MANAGER_PORT 9305
#endif
static void die(const char* fmt, ...);

2
include/mysql.h
View File

@ -238,7 +238,7 @@ typedef struct st_mysql_res {
typedef struct st_mysql_manager
{
Vio* vio;
NET net;
char *host,*user,*passwd;
unsigned int port;
my_bool free_me;

82
libmysql/manager.c
View File

@ -91,6 +91,7 @@ MYSQL_MANAGER* STDCALL mysql_manager_connect(MYSQL_MANAGER* con,
uint32 ip_addr;
char msg_buf[MAX_MYSQL_MANAGER_MSG];
int msg_len;
Vio* vio;
if (!host)
host="localhost";
@ -105,13 +106,14 @@ MYSQL_MANAGER* STDCALL mysql_manager_connect(MYSQL_MANAGER* con,
strmov(con->last_error,"Cannot create socket");
goto err;
}
if (!(con->vio=vio_new(sock,VIO_TYPE_TCPIP,FALSE)))
if (!(vio=vio_new(sock,VIO_TYPE_TCPIP,FALSE)))
{
con->last_errno=ENOMEM;
strmov(con->last_error,"Cannot create network I/O object");
goto err;
}
vio_blocking(con->vio,TRUE);
vio_blocking(vio,TRUE);
my_net_init(&con->net,vio);
bzero((char*) &sock_addr,sizeof(sock_addr));
sock_addr.sin_family = AF_INET;
if ((int) (ip_addr = inet_addr(host)) != (int) INADDR_NONE)
@ -155,7 +157,7 @@ MYSQL_MANAGER* STDCALL mysql_manager_connect(MYSQL_MANAGER* con,
goto err;
}
/* read the greating */
if (vio_read(con->vio,msg_buf,MAX_MYSQL_MANAGER_MSG)<=0)
if (my_net_read(&con->net) == packet_error)
{
con->last_errno=errno;
strmov(con->last_error,"Read error on socket");
@ -163,19 +165,19 @@ MYSQL_MANAGER* STDCALL mysql_manager_connect(MYSQL_MANAGER* con,
}
sprintf(msg_buf,"%-.16s %-.16s\n",user,passwd);
msg_len=strlen(msg_buf);
if (vio_write(con->vio,msg_buf,msg_len)!=msg_len)
if (my_net_write(&con->net,msg_buf,msg_len) || net_flush(&con->net))
{
con->last_errno=errno;
con->last_errno=con->net.last_errno;
strmov(con->last_error,"Write error on socket");
goto err;
}
if (vio_read(con->vio,msg_buf,MAX_MYSQL_MANAGER_MSG)<=0)
if (my_net_read(&con->net) == packet_error)
{
con->last_errno=errno;
strmov(con->last_error,"Read error on socket");
goto err;
}
if ((con->cmd_status=atoi(msg_buf)) != MANAGER_OK)
if ((con->cmd_status=atoi(con->net.read_pos)) != MANAGER_OK)
{
strmov(con->last_error,"Access denied");
goto err;
@ -210,11 +212,7 @@ void STDCALL mysql_manager_close(MYSQL_MANAGER* con)
allocated in my_multimalloc() along with con->host, freeing
con->hosts frees the whole block
*/
if (con->vio)
{
vio_delete(con->vio);
con->vio=0;
}
net_end(&con->net);
if (con->free_me)
my_free((gptr)con,MYF(0));
}
@ -224,7 +222,7 @@ int STDCALL mysql_manager_command(MYSQL_MANAGER* con,const char* cmd,
{
if (!cmd_len)
cmd_len=strlen(cmd);
if (vio_write(con->vio,(char*)cmd,cmd_len) != cmd_len)
if (my_net_write(&con->net,(char*)cmd,cmd_len) || net_flush(&con->net))
{
con->last_errno=errno;
strmov(con->last_error,"Write error on socket");
@ -238,9 +236,9 @@ int STDCALL mysql_manager_fetch_line(MYSQL_MANAGER* con, char* res_buf,
int res_buf_size)
{
char* res_buf_end=res_buf+res_buf_size;
char* net_buf_pos=con->net_buf_pos, *net_buf_end=con->net_data_end;
char* net_buf=con->net.read_pos, *net_buf_end;
int res_buf_shift=RES_BUF_SHIFT;
int done=0;
uint num_bytes;
if (res_buf_size<RES_BUF_SHIFT)
{
@ -249,50 +247,26 @@ int STDCALL mysql_manager_fetch_line(MYSQL_MANAGER* con, char* res_buf,
return 1;
}
for (;;)
if ((num_bytes=my_net_read(&con->net)) == packet_error)
{
for (;net_buf_pos<net_buf_end && res_buf<res_buf_end;
net_buf_pos++,res_buf++)
{
char c=*net_buf_pos;
if (c == '\r')
c=*++net_buf_pos;
if (c == '\n')
{
*res_buf=0;
net_buf_pos++;
done=1;
break;
}
else
*res_buf=*net_buf_pos;
}
if (done || res_buf==res_buf_end)
break;
if (net_buf_pos == net_buf_end && res_buf<res_buf_end)
{
int num_bytes;
if ((num_bytes=vio_read(con->vio,con->net_buf,con->net_buf_size))<=0)
{
con->last_errno=errno;
strmov(con->last_error,"socket read failed");
return 1;
}
net_buf_pos=con->net_buf;
net_buf_end=net_buf_pos+num_bytes;
}
con->last_errno=errno;
strmov(con->last_error,"socket read failed");
return 1;
}
con->net_buf_pos=net_buf_pos;
con->net_data_end=net_buf_end;
res_buf=res_buf_end-res_buf_size;
if ((con->eof=(res_buf[3]==' ')))
net_buf_end=net_buf+num_bytes;
if ((con->eof=(net_buf[3]==' ')))
res_buf_shift--;
res_buf_end-=res_buf_shift;
for (;res_buf<res_buf_end;res_buf++)
net_buf+=res_buf_shift;
res_buf_end[-1]=0;
for (;net_buf<net_buf_end && res_buf < res_buf_end;res_buf++,net_buf++)
{
if(!(*res_buf=res_buf[res_buf_shift]))
if((*res_buf=*net_buf) == '\r')
{
*res_buf=0;
break;
}
}
return 0;
}

7
mysql-test/mysql-test-run.sh
View File

@ -234,6 +234,9 @@ while test $# -gt 0; do
EXTRA_MASTER_MYSQLD_OPT="$EXTRA_MASTER_MYSQLD_OPT $1"
EXTRA_SLAVE_MYSQLD_OPT="$EXTRA_SLAVE_MYSQLD_OPT $1"
;;
--strace-client )
STRACE_CLIENT=1
;;
--debug)
EXTRA_MASTER_MYSQLD_OPT="$EXTRA_MASTER_MYSQLD_OPT \
--debug=d:t:i:O,$MYSQL_TEST_DIR/var/log/master.trace"
@ -299,6 +302,10 @@ if [ x$SOURCE_DIST = x1 ] ; then
else
MYSQL_TEST="$BASEDIR/client/mysqltest"
fi
if [ -n "$STRACE_CLIENT" ]; then
MYSQL_TEST="strace -o $MYSQL_TEST_DIR/var/log/mysqltest.strace $MYSQL_TEST"
fi
MYSQLADMIN="$BASEDIR/client/mysqladmin"
MYSQL_MANAGER_CLIENT="$BASEDIR/client/mysqlmanagerc"
MYSQL_MANAGER="$BASEDIR/tools/mysqlmanager"

2
sql/sql_parse.cc
View File

@ -938,10 +938,12 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
pos = uint4korr(packet);
flags = uint2korr(packet + 4);
pthread_mutex_lock(&LOCK_server_id);
thd->server_id=0; /* avoid suicide */
kill_zombie_dump_threads(slave_server_id = uint4korr(packet+6));
thd->server_id = slave_server_id;
pthread_mutex_unlock(&LOCK_server_id);
mysql_binlog_send(thd, thd->strdup(packet + 10), pos, flags);
unregister_slave(thd,1,1);
// fake COM_QUIT -- if we get here, the thread needs to terminate
error = TRUE;
net->error = 0;

25
sql/sql_repl.cc
View File

@ -106,10 +106,25 @@ static int fake_rotate_event(NET* net, String* packet, char* log_file_name,
p+= len; \
}\
void unregister_slave(THD* thd, bool only_mine, bool need_mutex)
{
if (need_mutex)
pthread_mutex_lock(&LOCK_slave_list);
if (thd->server_id)
{
SLAVE_INFO* old_si;
if ((old_si = (SLAVE_INFO*)hash_search(&slave_list,
(byte*)&thd->server_id, 4)) &&
(!only_mine || old_si->thd == thd))
hash_delete(&slave_list, (byte*)old_si);
}
if (need_mutex)
pthread_mutex_unlock(&LOCK_slave_list);
}
int register_slave(THD* thd, uchar* packet, uint packet_length)
{
SLAVE_INFO *si, *old_si;
SLAVE_INFO *si;
int res = 1;
uchar* p = packet, *p_end = packet + packet_length;
@ -119,18 +134,16 @@ int register_slave(THD* thd, uchar* packet, uint packet_length)
if (!(si = (SLAVE_INFO*)my_malloc(sizeof(SLAVE_INFO), MYF(MY_WME))))
goto err;
si->server_id = uint4korr(p);
thd->server_id = si->server_id = uint4korr(p);
p += 4;
get_object(p,si->host);
get_object(p,si->user);
get_object(p,si->password);
si->port = uint2korr(p);
si->thd = thd;
pthread_mutex_lock(&LOCK_slave_list);
if ((old_si = (SLAVE_INFO*)hash_search(&slave_list,
(byte*)&si->server_id, 4)))
hash_delete(&slave_list, (byte*)old_si);
unregister_slave(thd,0,0);
res = hash_insert(&slave_list, (byte*) si);
pthread_mutex_unlock(&LOCK_slave_list);
return res;

2
sql/sql_repl.h
View File

@ -10,6 +10,7 @@ typedef struct st_slave_info
char user[USERNAME_LENGTH+1];
char password[HASH_PASSWORD_LENGTH+1];
uint16 port;
THD* thd;
} SLAVE_INFO;
extern bool opt_show_slave_auth_info, opt_old_rpl_compat;
@ -44,6 +45,7 @@ void reset_master();
void init_slave_list();
void end_slave_list();
int register_slave(THD* thd, uchar* packet, uint packet_length);
void unregister_slave(THD* thd, bool only_mine, bool need_mutex);
int purge_master_logs(THD* thd, const char* to_log);
bool log_in_use(const char* log_name);
void adjust_linfo_offsets(my_off_t purge_offset);

148
tools/mysqlmanager.c
View File

@ -133,7 +133,7 @@ typedef enum {PARAM_STDOUT,PARAM_STDERR} PARAM_TYPE;
struct manager_thd
{
Vio* vio;
NET net;
char user[MAX_USER_NAME+1];
int priv_flags;
char* cmd_buf;
@ -154,7 +154,7 @@ struct manager_exec* cur_launch_exec=0;
static struct manager_thd* manager_thd_new(Vio* vio);
static struct manager_exec* manager_exec_new(char* arg_start,char* arg_end);
static void manager_exec_print(Vio* vio,struct manager_exec* e);
static void manager_exec_print(NET* net,struct manager_exec* e);
static void manager_thd_free(struct manager_thd* thd);
static void manager_exec_free(void* e);
static void manager_exec_connect(struct manager_exec* e);
@ -291,9 +291,9 @@ static void die(const char* fmt,...);
static void print_time(FILE* fp);
static void clean_up();
static struct manager_cmd* lookup_cmd(char* s,int len);
static void client_msg(Vio* vio,int err_code,const char* fmt,...);
static void client_msg_pre(Vio* vio,int err_code,const char* fmt,...);
static void client_msg_raw(Vio* vio,int err_code,int pre,const char* fmt,
static void client_msg(NET* net,int err_code,const char* fmt,...);
static void client_msg_pre(NET* net,int err_code,const char* fmt,...);
static void client_msg_raw(NET* net,int err_code,int pre,const char* fmt,
va_list args);
static int authenticate(struct manager_thd* thd);
static char* read_line(struct manager_thd* thd); /* returns pointer to end of
@ -371,7 +371,7 @@ static int exec_line(struct manager_thd* thd,char* buf,char* buf_end)
*p=tolower(*p);
if (!(cmd=lookup_cmd(buf,(int)(p-buf))))
{
client_msg(thd->vio,MANAGER_CLIENT_ERR,
client_msg(&thd->net,MANAGER_CLIENT_ERR,
"Unrecognized command, type help to see list of supported\
commands");
return 1;
@ -393,13 +393,13 @@ static struct manager_cmd* lookup_cmd(char* s,int len)
HANDLE_NOARG_DECL(handle_ping)
{
client_msg(thd->vio,MANAGER_OK,"Server management daemon is alive");
client_msg(&thd->net,MANAGER_OK,"Server management daemon is alive");
return 0;
}
HANDLE_NOARG_DECL(handle_quit)
{
client_msg(thd->vio,MANAGER_OK,"Goodbye");
client_msg(&thd->net,MANAGER_OK,"Goodbye");
thd->finished=1;
return 0;
}
@ -407,19 +407,19 @@ HANDLE_NOARG_DECL(handle_quit)
HANDLE_NOARG_DECL(handle_help)
{
struct manager_cmd* cmd = commands;
Vio* vio = thd->vio;
client_msg_pre(vio,MANAGER_INFO,"Available commands:");
NET* net = &thd->net;
client_msg_pre(net,MANAGER_INFO,"Available commands:");
for (;cmd->name;cmd++)
{
client_msg_pre(vio,MANAGER_INFO,"%s - %s", cmd->name, cmd->help);
client_msg_pre(net,MANAGER_INFO,"%s - %s", cmd->name, cmd->help);
}
client_msg_pre(vio,MANAGER_INFO,"End of help");
client_msg_pre(net,MANAGER_INFO,"End of help");
return 0;
}
HANDLE_NOARG_DECL(handle_shutdown)
{
client_msg(thd->vio,MANAGER_OK,"Shutdown started, goodbye");
client_msg(&thd->net,MANAGER_OK,"Shutdown started, goodbye");
thd->finished=1;
shutdown_requested = 1;
if (!one_thread)
@ -470,10 +470,10 @@ HANDLE_DECL(handle_set_exec_con)
}
}
pthread_mutex_unlock(&lock_exec_hash);
client_msg(thd->vio,MANAGER_OK,"Entry updated");
client_msg(&thd->net,MANAGER_OK,"Entry updated");
return 0;
err:
client_msg(thd->vio,MANAGER_CLIENT_ERR,error);
client_msg(&thd->net,MANAGER_CLIENT_ERR,error);
return 1;
}
@ -531,10 +531,10 @@ static int set_exec_param(struct manager_thd* thd, char* args_start,
}
strnmov(param,arg_p,FN_REFLEN);
pthread_mutex_unlock(&lock_exec_hash);
client_msg(thd->vio,MANAGER_OK,"Entry updated");
client_msg(&thd->net,MANAGER_OK,"Entry updated");
return 0;
err:
client_msg(thd->vio,MANAGER_CLIENT_ERR,error);
client_msg(&thd->net,MANAGER_CLIENT_ERR,error);
return 1;
}
@ -581,10 +581,10 @@ HANDLE_DECL(handle_start_exec)
pthread_mutex_unlock(&e->lock);
if (error)
goto err;
client_msg(thd->vio,MANAGER_OK,"'%s' started",e->ident);
client_msg(&thd->net,MANAGER_OK,"'%s' started",e->ident);
return 0;
err:
client_msg(thd->vio,MANAGER_CLIENT_ERR,error);
client_msg(&thd->net,MANAGER_CLIENT_ERR,error);
return 1;
}
@ -636,11 +636,11 @@ HANDLE_DECL(handle_stop_exec)
pthread_mutex_unlock(&e->lock);
if (!error)
{
client_msg(thd->vio,MANAGER_OK,"'%s' terminated",e->ident);
client_msg(&thd->net,MANAGER_OK,"'%s' terminated",e->ident);
return 0;
}
err:
client_msg(thd->vio,MANAGER_CLIENT_ERR,error);
client_msg(&thd->net,MANAGER_CLIENT_ERR,error);
return 1;
}
@ -705,7 +705,7 @@ HANDLE_DECL(handle_query)
*p++='\t';
}
*p=0;
client_msg_pre(thd->vio,MANAGER_OK,buf);
client_msg_pre(&thd->net,MANAGER_OK,buf);
while ((row=mysql_fetch_row(res)))
{
@ -716,14 +716,14 @@ HANDLE_DECL(handle_query)
*p++='\t';
}
*p=0;
client_msg_pre(thd->vio,MANAGER_OK,buf);
client_msg_pre(&thd->net,MANAGER_OK,buf);
}
}
pthread_mutex_unlock(&e->lock);
client_msg(thd->vio,MANAGER_OK,"End");
client_msg(&thd->net,MANAGER_OK,"End");
return 0;
err:
client_msg(thd->vio,MANAGER_CLIENT_ERR,error);
client_msg(&thd->net,MANAGER_CLIENT_ERR,error);
return 1;
}
@ -756,10 +756,10 @@ HANDLE_DECL(handle_def_exec)
}
hash_insert(&exec_hash,(byte*)e);
pthread_mutex_unlock(&lock_exec_hash);
client_msg(thd->vio,MANAGER_OK,"Exec definition created");
client_msg(&thd->net,MANAGER_OK,"Exec definition created");
return 0;
err:
client_msg(thd->vio,MANAGER_CLIENT_ERR,error);
client_msg(&thd->net,MANAGER_CLIENT_ERR,error);
if (e)
manager_exec_free(e);
return 1;
@ -768,16 +768,16 @@ err:
HANDLE_NOARG_DECL(handle_show_exec)
{
uint i;
client_msg_pre(thd->vio,MANAGER_INFO,"Exec_def\tPid\tExit_status\tCon_info\
client_msg_pre(&thd->net,MANAGER_INFO,"Exec_def\tPid\tExit_status\tCon_info\
\tStdout\tStderr\tArguments");
pthread_mutex_lock(&lock_exec_hash);
for (i=0;i<exec_hash.records;i++)
{
struct manager_exec* e=(struct manager_exec*)hash_element(&exec_hash,i);
manager_exec_print(thd->vio,e);
manager_exec_print(&thd->net,e);
}
pthread_mutex_unlock(&lock_exec_hash);
client_msg(thd->vio,MANAGER_INFO,"End");
client_msg(&thd->net,MANAGER_INFO,"End");
return 0;
}
@ -873,7 +873,7 @@ static char* arg_strmov(char* dest, const char* src, int n)
return dest;
}
static void manager_exec_print(Vio* vio,struct manager_exec* e)
static void manager_exec_print(NET* net,struct manager_exec* e)
{
char buf[MAX_MYSQL_MANAGER_MSG];
char* p=buf,*buf_end=buf+sizeof(buf)-1;
@ -921,7 +921,7 @@ static void manager_exec_print(Vio* vio,struct manager_exec* e)
}
end:
*p=0;
client_msg_pre(vio,MANAGER_INFO,buf);
client_msg_pre(net,MANAGER_INFO,buf);
return;
}
@ -933,7 +933,7 @@ static int authenticate(struct manager_thd* thd)
struct manager_user* u;
char c;
client_msg(thd->vio,MANAGER_INFO, manager_greeting);
client_msg(&thd->net,MANAGER_INFO, manager_greeting);
if (!(buf_end=read_line(thd)))
return -1;
for (buf=thd->cmd_buf,p=thd->user,p_end=p+MAX_USER_NAME;
@ -959,7 +959,7 @@ static int authenticate(struct manager_thd* thd)
my_MD5Final(digest,&context);
if (memcmp(u->md5_pass,digest,MD5_LEN))
return 1;
client_msg(thd->vio,MANAGER_OK,"OK");
client_msg(&thd->net,MANAGER_OK,"OK");
return 0;
}
@ -1121,7 +1121,7 @@ static pthread_handler_decl(process_connection,arg)
return 0; /* Don't get cc warning */
}
static void client_msg_raw(Vio* vio, int err_code, int pre, const char* fmt,
static void client_msg_raw(NET* net, int err_code, int pre, const char* fmt,
va_list args)
{
char buf[MAX_CLIENT_MSG_LEN],*p,*buf_end;
@ -1136,73 +1136,44 @@ static void client_msg_raw(Vio* vio, int err_code, int pre, const char* fmt,
p=buf_end - 2;
*p++='\r';
*p++='\n';
if (vio_write(vio,buf,(uint)(p-buf))<=0)
log_err("Failed writing to client: errno=%d",errno);
if (my_net_write(net,buf,(uint)(p-buf)) || net_flush(net))
log_err("Failed writing to client: errno=%d",net->last_errno);
}
static void client_msg(Vio* vio, int err_code, const char* fmt, ...)
static void client_msg(NET* net, int err_code, const char* fmt, ...)
{
va_list args;
va_start(args,fmt);
client_msg_raw(vio,err_code,0,fmt,args);
client_msg_raw(net,err_code,0,fmt,args);
}
static void client_msg_pre(Vio* vio, int err_code, const char* fmt, ...)
static void client_msg_pre(NET* net, int err_code, const char* fmt, ...)
{
va_list args;
va_start(args,fmt);
client_msg_raw(vio,err_code,1,fmt,args);
client_msg_raw(net,err_code,1,fmt,args);
}
static char* read_line(struct manager_thd* thd)
{
char* p=thd->cmd_buf;
char* buf_end = thd->cmd_buf + manager_max_cmd_len;
int escaped = 0;
for (;p<buf_end;)
{
int len,read_len;
char *block_end,*p_back;
uint retry_count=0;
read_len = min(NET_BLOCK,(uint)(buf_end-p));
while ((len=vio_read(thd->vio,p,read_len))<=0)
uint len;
char* p, *buf_end;
if ((len=my_net_read(&thd->net)) == packet_error)
{
if (vio_should_retry(thd->vio) && retry_count++ < MAX_RETRY_COUNT)
continue;
log_err("Error reading command from client (Error: %d)",
vio_errno(thd->vio));
errno);
thd->fatal=1;
return 0;
}
block_end=p+len;
/* a trick to unescape in place */
for (p_back=p;p<block_end;p++)
buf_end=thd->cmd_buf+len;
for (p=thd->cmd_buf;p<buf_end;p++)
if (*p == '\r' || *p == '\n')
{
char c=*p;
if (c==ESCAPE_CHAR)
{
if (!escaped)
{
escaped=1;
continue;
}
else
escaped=0;
}
if (c==EOL_CHAR && !escaped)
break;
*p_back++=c;
escaped=0;
*p=0;
break;
}
if (p!=block_end)
{
*p_back=0;
return p_back;
}
}
client_msg(thd->vio,MANAGER_CLIENT_ERR,"Command line too long");
return 0;
return p;
}
static void handle_child(int __attribute__((unused)) sig)
@ -1225,25 +1196,23 @@ static void handle_child(int __attribute__((unused)) sig)
struct manager_thd* manager_thd_new(Vio* vio)
{
struct manager_thd* tmp;
if (!(tmp=(struct manager_thd*)my_malloc(sizeof(*tmp)+manager_max_cmd_len,
if (!(tmp=(struct manager_thd*)my_malloc(sizeof(*tmp),
MYF(0))))
{
log_err("Out of memory in manager_thd_new");
return 0;
}
tmp->vio=vio;
my_net_init(&tmp->net,vio);
tmp->user[0]=0;
tmp->priv_flags=0;
tmp->fatal=tmp->finished=0;
tmp->cmd_buf=(char*)tmp+sizeof(*tmp);
tmp->cmd_buf=tmp->net.read_pos;
return tmp;
}
static void manager_thd_free(struct manager_thd* thd)
{
if (thd->vio)
vio_close(thd->vio);
my_free((byte*)thd->vio,MYF(0));
net_end(&thd->net);
}
static void clean_up()
@ -1413,7 +1382,7 @@ static int run_server_loop()
if (authenticate(thd))
{
client_msg(vio,MANAGER_ACCESS, "Access denied");
client_msg(&thd->net,MANAGER_ACCESS, "Access denied");
manager_thd_free(thd);
continue;
}
@ -1427,7 +1396,8 @@ static int run_server_loop()
}
else if (pthread_create(&th,&thr_attr,process_connection,(void*)thd))
{
client_msg(vio,MANAGER_INTERNAL_ERR,"Could not create thread, errno=%d",
client_msg(&thd->net,MANAGER_INTERNAL_ERR,
"Could not create thread, errno=%d",
errno);
manager_thd_free(thd);
continue;